create_python_repl_request

@rule_helper

async def whatever()

import logging
from dataclasses import dataclass
from typing import ClassVar

from pants.backend.python.goals.repl import PythonRepl, create_python_repl_request
from pants.backend.python.subsystems.setup import PythonSetup
from pants.backend.python.util_rules.pex_environment import PexEnvironment
from pants.core.goals.package import BuiltPackage, BuiltPackageArtifact, OutputPathField, PackageFieldSet
from pants.core.util_rules.environments import EnvironmentField
from pants.engine.env_vars import CompleteEnvironmentVars
from pants.engine.fs import CreateDigest, Digest, FileContent
from pants.engine.process import Process, ProcessResult
from pants.engine.rules import Get, collect_rules, rule
from pants.engine.target import (
    COMMON_TARGET_FIELDS,
    Dependencies,
    DependenciesRequest,
    DictStringToStringField,
    Field,
    StringField,
    Target,
    Targets,
)
from pants.engine.unions import UnionRule
from pants.util.logging import LogLevel

logger = logging.getLogger(__name__)


class GeneratorFunction(StringField):
    alias = "generator_function"
    required = True


class GeneratorEnvironmentField(DictStringToStringField):
    alias = "generator_environment"
    required = False


class GeneratedFile(Target):
    alias = "generated_file"
    core_fields: ClassVar[tuple[type[Field], ...]] = (
        *COMMON_TARGET_FIELDS,
        GeneratorFunction,
        GeneratorEnvironmentField,
        OutputPathField,
        EnvironmentField,
        Dependencies,
    )


@dataclass(frozen=True)
class GeneratedFileFieldSet(PackageFieldSet):
    required_fields = (GeneratorFunction, OutputPathField)

    generator_function: GeneratorFunction
    generator_environment: GeneratorEnvironmentField
    output_path: OutputPathField
    dependencies: Dependencies


@rule(level=<http://LogLevel.INFO|LogLevel.INFO>)
async def package_generated_file(
    field_set: GeneratedFileFieldSet,
    pex_env: PexEnvironment,
    python_setup: PythonSetup,
    complete_env: CompleteEnvironmentVars,
) -> BuiltPackage:
    targets = await Get(Targets, DependenciesRequest(field_set.dependencies))
    repl_impl = PythonRepl(targets=targets)
    # Because we're (ab)using another rule here that we need to call the inner
    # function of the rule, rather than just the rule itself due to issues passing
    # python setup to rule.
    repl_request = await create_python_repl_request.__wrapped__(repl_impl, pex_env, python_setup)
    env = {**complete_env, **repl_request.extra_env, **(field_set.generator_environment.value or {})}
    process_result = await Get(
        ProcessResult,
        Process(
            argv=(*repl_request.args, *field_set.generator_function.value.split(" ")),
            env=env,
            description=f"Generating file using {GeneratorFunction.alias}",
            input_digest=repl_request.digest,
            immutable_input_digests=repl_request.immutable_input_digests,
            append_only_caches=repl_request.append_only_caches,
        ),
    )
    output_path = field_set.output_path.value_or_default(file_ending="")
    generated_digest = await Get(Digest, CreateDigest([FileContent(output_path, process_result.stdout)]))
    artefact = BuiltPackageArtifact(output_path)
    return BuiltPackage(digest=generated_digest, artifacts=(artefact,))


def rules():
    return (
        *collect_rules(),
        UnionRule(PackageFieldSet, GeneratedFileFieldSet),
    )


def target_types():
    return [
        GeneratedFile,
    ]

create_python_repl_request