pantsbuild / pants / 19015773527

# Copyright 2023 Pants project contributors (see CONTRIBUTORS.md).

# Licensed under the Apache License, Version 2.0 (see LICENSE).

"""Function-as-a-service (FaaS) support like AWS Lambda and Google Cloud Functions."""

    PythonModuleOwnersRequest,

    map_module_to_address,

)

    AmbiguityResolution,

    PythonInferSubsystem,

)

    PexCompletePlatformsField,

    PexLayout,

    PythonResolveField,

)

    CompletePlatforms,

    create_pex,

    digest_complete_platform_addresses,

)

    InterpreterConstraintsRequest,

    PexFromTargetsRequest,

    interpreter_constraints_for_targets,

)

    EMPTY_DIGEST,

    CreateDigest,

    FileContent,

    GlobMatchErrorBehavior,

    PathGlobs,

)

    create_digest,

    digest_to_snapshot,

    merge_digests,

    path_globs_to_paths,

)

    AsyncFieldMixin,

    Dependencies,

    DependenciesRequest,

    FieldSet,

    InferDependenciesRequest,

    InferredDependencies,

    InvalidFieldException,

    InvalidTargetException,

    StringField,

    StringSequenceField,

)

        """

        Control the layout of the final artifact: `flat` creates a directory with the

        source and requirements at the top level, as recommended by cloud vendors,

        while `flat-zipped` (the default) wraps this up into a single zip file.

        """

    )

        """

        Any extra arguments to pass to the `pex3 venv create` invocation that is used to create the

        final zip file or directory.

        For example, `pex3_venv_create_extra_args=["--collisions-ok"]`, if using packages that have

        colliding files that aren't required at runtime (errors like "Encountered collisions

        populating ...").

        """

    )

        """

        Additional arguments to pass to the `pex` invocation that is used to collect the requirements

        and sources for packaging.

        For example, `pex_build_extra_args=["--exclude=pypi-package-name"]` to force a package called

        `pypi-package-name` isn't included in the artifact.

        Note: Excluding dependencies currently causes Pex to throw an error. You can additionally pass

        the `--ignore-errors` flag.

        """

    )

        """

        You can specify a full module like `'path.to.module:handler_func'` or use a shorthand to

        specify a file name, using the same syntax as the `sources` field, e.g.

        `'cloud_function.py:handler_func'`.

        """

    )

                f"The `{cls.alias}` field in target at {address} must end in the "

                f"format `:my_handler_func`, but was {value}."

            )

    request: ResolvePythonFaaSHandlerRequest,

) -> ResolvedPythonFaaSHandler:

    # If it's already a module, simply use that. Otherwise, convert the file name into a module

    # path.

    # Use the engine to validate that the file exists and that it resolves to only one file.

        PathGlobs(

            [full_glob],

            glob_match_error_behavior=GlobMatchErrorBehavior.error,

            description_of_origin=f"{address}'s `{field_alias}` field",

        )

    )

    # We will have already raised if the glob did not match, i.e. if there were no files. But

    # we need to check if they used a file glob (`*` or `**`) that resolved to >1 file.

            f"Multiple files matched for the `{field_alias}` {repr(handler_val)} for the target "

            f"{address}, but only one file expected. Are you using a glob, rather than a file "

            f"name?\n\nAll matching files: {list(handler_paths.files)}."

        )

        PythonFaaSDependencies,

        PythonFaaSHandlerField,

        PythonResolveField,

    )

    request: InferPythonFaaSHandlerDependency,

    python_infer_subsystem: PythonInferSubsystem,

    python_setup: PythonSetup,

) -> InferredDependencies:

        determine_explicitly_provided_dependencies(

            **implicitly(DependenciesRequest(request.field_set.dependencies))

        ),

        resolve_python_faas_handler(ResolvePythonFaaSHandlerRequest(request.field_set.handler)),

    )

    # Only set locality if needed, to avoid unnecessary rule graph memoization misses.

    # When set, use the source root, which is useful in practice, but incurs fewer memoization

    # misses than using the full spec_path.

            SourceRootRequest.for_address(request.field_set.address)

        )

        PythonModuleOwnersRequest(

            handler.module,

            resolve=request.field_set.resolve.normalized_value(python_setup),

            locality=locality,

        ),

        **implicitly(),

    )

        owners.ambiguous,

        address,

        # If the handler was specified as a file, like `app.py`, we know the module must

        # live in the python_google_cloud_function's directory or subdirectory, so the owners must be ancestors.

        owners_must_be_ancestors=handler.file_name_used,

        import_reference="module",

        context=(

            f"The target {address} has the field "

            f"`handler={repr(request.field_set.handler.value)}`, which maps "

            f"to the Python module `{handler.module}`"

        ),

    )

        owners.ambiguous, owners_must_be_ancestors=handler.file_name_used

    )

        (maybe_disambiguated,) if maybe_disambiguated else ()

    )

        f"""

        {PexCompletePlatformsField.help}

        N.B.: only one of this and `runtime` can be set. If `runtime` is set, a default complete

        platform is chosen, if one is known for that runtime. Explicitly set this to `[]` to use the

        platform's ambient interpreter, such as when running in an docker environment.

        """

    )

        # the runtime field subclasses are conventionally in a `target_types.py` file, and we want

        # to put the JSONs in a sibling file

        """Returns the Python version implied by the runtime, as (major, minor)."""

        """Returns an appropriately-formatted runtime argument."""

        # We hardcode the platform value to the appropriate one for each FaaS runtime.

        # (Running the "hello world" cloud function in the example code will report the platform, and can be

        # used to verify correctness of these platform strings.)

    # set pymalloc ABI flag - this was removed in python 3.8 https://bugs.python.org/issue36707

    complete_platforms: PythonFaaSCompletePlatforms,

) -> CompletePlatforms:

        InterpreterConstraintsRequest([request.address]), **implicitly()

    )

    # Future proofing: use naive non-universe-based IC requirement matching to determine if the

    # requirements cover exactly (and all patch versions of) one major.minor interpreter

    # version.

    #

    # Either reasonable option for a universe (`PythonSetup.interpreter_universe` or the FaaS's

    # known runtimes) can and will be expanded during a Pants upgrade: for instance, at the time of

    # writing, Pants only supports up to 3.11 but might soon add support for 3.12, or AWS Lambda

    # (and pants.backend.awslambda.python's known runtimes) only supports up to 3.10 but might soon

    # add support for 3.11.

    #

    # When this happens, some ranges (like `>=3.11`, if using `PythonSetup.interpreter_universe`)

    # will go from covering one major.minor interpreter version to covering more than one, and thus

    # inference starts breaking during the upgrade, requiring the user to do distracting changes

    # without deprecations/warnings to help.

        softwrap(

            f"""

            The {request.target_name!r} target {request.address} cannot have its runtime platform

            inferred, because inference requires simple interpreter constraints covering exactly one

            minor release of Python, and all its patch version. The constraints for this target

            ({ics}) aren't understood.

            To fix, provide one of the following:

            - a value for the `{request.runtime.alias}` field, or

            - a value for the `{request.complete_platforms.alias}` field, or

            - simple and narrow interpreter constraints (for example, `==3.10.*` or `>=3.10,<3.11` are simple enough to imply Python 3.10)

            """

        )

    )

        # explicit complete platforms wins:

        # Don't bother trying to infer the runtime version if the user has provided their own

        # complete platform; they probably know what they're doing.

        # if there's not a specified version, let's try to infer it from the interpreter constraints

            rt.file_name()

            for rt in request.runtime.known_runtimes

            if version == (rt.major, rt.minor) and request.architecture.value == rt.architecture

        )

        # No known runtime, so prompt the user to specify

            FrozenOrderedSet(r.name for r in request.runtime.known_runtimes)

        )

            softwrap(

                f"""

                Could not find a known runtime for the {version_adjective} Python version and machine architecture!

                * Python version: {version} {version_modifier}

                * Machine architecture: {request.architecture.value}

                * Known runtime values: {known_runtimes_str}

                To fix, please generate a `complete_platforms` file for the given Python version and

                machine architecture, or specify a runtime that is known to Pants.

                You can follow the instructions at {doc_url("docs/python/overview/pex#generating-the-complete_platforms-file")}

                to generate a `complete_platforms` file for your Python version and machine

                architecture.

                """

            ),

            description_of_origin=f"In the {request.target_name!r} target",

        ) from None

        **implicitly(CreateDigest([FileContent(file_name, content)]))

    )

        interpreter_version=version, complete_platforms=CompletePlatforms.from_snapshot(snapshot)

    )

    request: BuildPythonFaaSRequest,

) -> BuiltPackage:

        # Ensure we can resolve manylinux wheels in addition to any AMI-specific wheels.

        "--manylinux=manylinux2014",

        # When we're executing Pex on Linux, allow a local interpreter to be resolved if

        # available and matching the AMI platform.

        "--resolve-local-platforms",

        # Additional args from request

        *(request.pex_build_extra_args.value or ()),

    )

        RuntimePlatformsRequest(

            address=request.address,

            target_name=request.target_name,

            runtime=request.runtime,

            architecture=request.architecture,

            complete_platforms=request.complete_platforms,

        ),

    )

            platforms_get,

            resolve_python_faas_handler(ResolvePythonFaaSHandlerRequest(request.handler)),

        )

    else:

    # TODO: improve diagnostics if there's more than one platform/complete_platform

        # synthesise a source file that gives a fixed handler path, no matter what the entry point is:

        # some platforms require a certain name (e.g. GCF), and even on others, giving a fixed name

        # means users don't need to duplicate the entry_point config in both the pants BUILD file and

        # infrastructure definitions (the latter can always use the same names, for every lambda).

            f"from {handler.module} import {handler.func} as {reexported_handler_func}"

        )

            CreateDigest(

                [FileContent(reexported_handler_file, reexported_handler_content.encode())]

            )

        )

    else:

        addresses=[request.address],

        internal_only=False,

        include_requirements=request.include_requirements,

        include_source_files=request.include_sources,

        output_filename=repository_filename,

        complete_platforms=platforms.complete_platforms,

        layout=PexLayout.PACKED,

        additional_args=additional_pex_args,

        additional_lockfile_args=additional_pex_args,

        additional_sources=additional_sources,

        warn_for_transitive_files_targets=True,

    )

        file_ending="zip" if layout is PexVenvLayout.FLAT_ZIPPED else None

    )

        PexVenvRequest(

            pex=pex_result,

            layout=layout,

            complete_platforms=platforms.complete_platforms,

            extra_args=request.pex3_venv_create_extra_args.value or (),

            prefix=request.prefix_in_artifact,

            output_path=Path(output_filename),

            description=f"Build {request.target_name} artifact for {request.address}",

        ),

    )

        else:

        CreateDigest(

            [

                FileContent(

                    metadata_filename, json.dumps(metadata, indent=2, sort_keys=True).encode()

                )

            ]

        )

    )

        output_filename,

        extra_log_lines=tuple(extra_log_lines),

    )

        *collect_rules(),

        *import_rules(),

        *pex_venv_rules(),

        *pex_from_targets_rules(),

        UnionRule(InferDependenciesRequest, InferPythonFaaSHandlerDependency),

    )