pantsbuild / pants / 19015773527

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

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

    """Contains the wheels isolated from a single local Python distribution."""

    dist_field_set: PythonDistributionFieldSet,

    bash: BashBinary,

    unzip_binary: UnzipBinary,

) -> LocalDistWheels:

        **implicitly(DigestSubset(dist.digest, PathGlobs(["**/*.whl"])))

    )

    # A given local dist might build a wheel and an sdist (and maybe other artifacts -

    # we don't know what setup command was run...)

    # As long as there is a wheel, we can ignore the other artifacts.

            WrappedTargetRequest(dist_field_set.address, description_of_origin="<infallible>"),

            **implicitly(),

        )

            softwrap(

                f"""

                Encountered a dependency on the {tgt.target.alias} target at {dist_field_set.address},

                but this target does not produce a Python wheel artifact. Therefore this target's

                code will be used directly from sources, without a distribution being built,

                and any native extensions in it will not be built.

                See {doc_url("docs/python/overview/building-distributions")} for details on how to set up a

                {tgt.target.alias} target to produce a wheel.

                """

            )

        )

        **implicitly(

            Process(

                argv=[

                    bash.path,

                    "-c",

                    f"""

                set -ex

                for f in {" ".join(shlex.quote(f) for f in wheels)}; do

                  {unzip_binary.path} -Z1 "$f"

                done

                """,

                ],

                input_digest=wheels_snapshot.digest,

                description=f"List contents of artifacts produced by {dist_field_set.address}",

            )

        )

    )

        tuple(sorted(wheels)), wheels_snapshot.digest, frozenset(sorted(provided_files))

    )

    """Request to build the local dists from the dependency closure of a set of addresses."""

    # The result will return these with the sources provided by the dists subtracted out.

    # This will help the caller prevent sources from appearing twice on sys.path.

        self,

        addresses: Iterable[Address],

        *,

        interpreter_constraints: InterpreterConstraints,

        sources: PythonSourceFiles = PythonSourceFiles.empty(),

    ) -> None:

    """A PEX file containing locally-built dists.

    Can be consumed from another PEX, e.g., by adding to PEX_PATH.

    The PEX will only contain locally built dists and not their dependencies. For Pants generated

    `setup.py` / `pyproject.toml`, the dependencies will be included in the standard resolve process

    that the locally-built dists PEX is adjoined to via PEX_PATH. For hand-made `setup.py` /

    `pyproject.toml` with 3rdparty dependencies not hand-mirrored into BUILD file dependencies, this

    will lead to issues. See https://github.com/pantsbuild/pants/issues/13587#issuecomment-974863636

    for one way to fix this corner which is intentionally punted on for now.

    Lists the files provided by the dists on sys.path, so they can be subtracted from

    sources digests, to prevent the same file ending up on sys.path twice.

    """

    # The sources from the request, but with any files provided by the local dists subtracted out.

    request: LocalDistsPexRequest,

) -> LocalDistsPex:

        TransitiveTargetsRequest(request.addresses), **implicitly()

    )

        tgt for tgt in transitive_targets.closure if PythonDistributionFieldSet.is_applicable(tgt)

    ]

        isolate_local_dist_wheels(PythonDistributionFieldSet.create(target), **implicitly())

        for target in applicable_targets

    )

    # The primary use-case of the "local dists" feature is to support consuming native extensions

    # as wheels without having to publish them first.

    # It doesn't seem very useful to consume locally-built sdists, and it makes it hard to

    # reason about possible sys.path collisions between the in-repo sources and whatever the

    # sdist will place on the sys.path when it's installed.

    # So for now we simply ignore sdists, with a warning if necessary.

        PexRequest(

            output_filename="local_dists.pex",

            requirements=PexRequirements(wheels),

            interpreter_constraints=request.interpreter_constraints,

            additional_inputs=wheels_digest,

            # a "local dists" PEX is always just for consumption by some downstream Pants process,

            # i.e. internal

            internal_only=True,

            additional_args=["--intransitive"],

        )

    )

        # The source calculations below are not (always) cheap, so we skip them if no wheels were

        # produced. See https://github.com/pantsbuild/pants/issues/14561 for one possible approach

        # to sharing the cost of these calculations.

    # We check source roots in reverse lexicographic order,

    # so we'll find the innermost root that matches.

        **implicitly(

            DigestSubset(

                request.sources.source_files.snapshot.digest, PathGlobs(sorted(remaining_sources))

            )

        )

    )

        SourceFiles(remaining_sources_snapshot, request.sources.source_files.unrooted_files),

        request.sources.source_roots,

    )

        *collect_rules(),

        *pex_rules(),

        *system_binaries.rules(),

    )