pex 2.54.2__py2.py3-none-any.whl → 2.69.0__py2.py3-none-any.whl

pex/pep_508.py

@@ -3,6 +3,7 @@
 
 from __future__ import absolute_import
 
+from pex.interpreter_implementation import InterpreterImplementation
 from pex.platforms import Platform
 from pex.third_party.packaging import markers
 from pex.typing import TYPE_CHECKING
@@ -117,11 +118,9 @@ class MarkerEnvironment(object):
             sys_platform = "win32"
 
         platform_python_implementation = None
-
-        if platform.impl == "cp":
-            platform_python_implementation = "CPython"
-        elif platform.impl == "pp":
-            platform_python_implementation = "PyPy"
+        for implementation in InterpreterImplementation.values():
+            if implementation.abbr == platform.impl:
+                platform_python_implementation = implementation.value
 
         python_version = ".".join(map(str, platform.version_info[:2]))
 

pex/pex_builder.py

@@ -33,11 +33,11 @@ from pex.enum import Enum
 from pex.executables import chmod_plus_x, create_sh_python_redirector_shebang
 from pex.finders import get_entry_point_from_console_script, get_script_from_distributions
 from pex.fs import safe_rename, safe_symlink
+from pex.installed_wheel import InstalledWheel
 from pex.interpreter import PythonInterpreter
 from pex.layout import Layout
 from pex.orderedset import OrderedSet
 from pex.os import WINDOWS
-from pex.pep_376 import InstalledWheel
 from pex.pex import PEX
 from pex.pex_info import PexInfo
 from pex.sh_boot import create_sh_boot_script
@@ -470,10 +470,7 @@ class PEXBuilder(object):
     def _prepare_code(self):
         chroot_path = self._chroot.path()
         self._pex_info.code_hash = CacheHelper.pex_code_hash(
-            chroot_path,
-            exclude_dirs=tuple(
-                os.path.join(chroot_path, d) for d in (layout.BOOTSTRAP_DIR, layout.DEPS_DIR)
-            ),
+            chroot_path, exclude_dirs=(layout.BOOTSTRAP_DIR, layout.DEPS_DIR)
         )
         self._pex_info.pex_hash = hashlib.sha1(self._pex_info.dump().encode("utf-8")).hexdigest()
         self._chroot.write(self._pex_info.dump().encode("utf-8"), PexInfo.PATH, label="manifest")
@@ -790,9 +787,9 @@ class PEXBuilder(object):
                                 self._chroot.zip(
                                     os.path.join(atomic_zip_dir.work_dir, location),
                                     deterministic=deterministic,
-                                    exclude_file=is_pyc_temporary_file
-                                    if bytecode_compile
-                                    else is_pyc_file,
+                                    exclude_file=(
+                                        is_pyc_temporary_file if bytecode_compile else is_pyc_file
+                                    ),
                                     strip_prefix=os.path.join(pex_info.internal_cache, location),
                                     labels=(location,),
                                     compress=compress,

pex/pex_info.py

@@ -25,11 +25,11 @@ if TYPE_CHECKING:
     from typing import Collection  # type: ignore[attr-defined]
     from typing import Any, Dict, Iterable, Mapping, Optional, Text, Tuple, Union
 
-    from pex.cache.dirs import VenvDir
-    from pex.dist_metadata import Requirement
-
     # N.B.: These are expensive imports and PexInfo is used during PEX bootstrapping which we want
     # to be as fast as possible.
+    from pex.cache.dirs import VenvDir
+    from pex.dependency_configuration import Override
+    from pex.dist_metadata import Requirement
     from pex.interpreter import PythonInterpreter
     from pex.interpreter_constraints import InterpreterConstraints
 
@@ -491,9 +491,9 @@ class PexInfo(object):
         # type: () -> Iterable[str]
         return self._excluded
 
-    def add_override(self, requirement):
-        # type: (Requirement) -> None
-        self._overridden.add(str(requirement))
+    def add_override(self, override):
+        # type: (Override) -> None
+        self._overridden.add(str(override))
 
     @property
     def overridden(self):
@@ -604,9 +604,14 @@ class PexInfo(object):
         data["distributions"] = self._distributions.copy()
         return data
 
-    def dump(self, **extra_json_dumps_kwargs):
-        # type: (**Any) -> str
-        return json.dumps(self.as_json_dict(), sort_keys=True, **extra_json_dumps_kwargs)
+    def dump(self, indent=None):
+        # type: (Optional[int]) -> str
+        return json.dumps(
+            self.as_json_dict(),
+            sort_keys=True,
+            indent=indent,
+            separators=None if indent else (",", ":"),
+        )
 
     def copy(self):
         # type: () -> PexInfo

pex/pip/dependencies/__init__.py

@@ -8,30 +8,82 @@ import os
 
 from pex.common import safe_mkdtemp
 from pex.dependency_configuration import DependencyConfiguration
+from pex.exceptions import reportable_unexpected_error_msg
+from pex.interpreter_implementation import InterpreterImplementation
+from pex.pep_508 import MarkerEnvironment
 from pex.pip.download_observer import DownloadObserver, Patch, PatchSet
-from pex.typing import TYPE_CHECKING
+from pex.resolve.target_system import TargetSystem, UniversalTarget
+from pex.third_party.packaging.specifiers import SpecifierSet
+from pex.typing import TYPE_CHECKING, cast
 
 if TYPE_CHECKING:
-    from typing import Mapping, Optional
+    from typing import Mapping, Optional, Union
 
+    import attr  # vendor:skip
+else:
+    from pex.third_party import attr
 
+
+@attr.s(frozen=True)
 class PatchContext(object):
     _PEX_DEP_CONFIG_FILE_ENV_VAR_NAME = "_PEX_DEP_CONFIG_FILE"
 
     @classmethod
-    def load_dependency_configuration(cls):
-        # type: () -> DependencyConfiguration
+    def load(cls):
+        # type: () -> PatchContext
 
         dep_config_file = os.environ.pop(cls._PEX_DEP_CONFIG_FILE_ENV_VAR_NAME)
         with open(dep_config_file) as fp:
             data = json.load(fp)
-        return DependencyConfiguration.create(
-            excluded=data["excluded"], overridden=data["overridden"]
+
+        universal_target = None  # type: Optional[UniversalTarget]
+        universal_target_data = data["universal_target"]
+        if universal_target_data:
+            implementation = universal_target_data["implementation"]
+            universal_target = UniversalTarget(
+                implementation=(
+                    InterpreterImplementation.for_value(implementation) if implementation else None
+                ),
+                requires_python=tuple(
+                    SpecifierSet(requires_python)
+                    for requires_python in universal_target_data["requires_python"]
+                ),
+                systems=tuple(
+                    TargetSystem.for_value(system) for system in universal_target_data["systems"]
+                ),
+            )
+
+        marker_environment = None  # type: Optional[MarkerEnvironment]
+        marker_environment_data = data["marker_environment"]
+        if marker_environment_data:
+            marker_environment = MarkerEnvironment(**marker_environment_data)
+
+        if not (bool(universal_target) ^ bool(marker_environment)):
+            raise AssertionError(
+                reportable_unexpected_error_msg(
+                    "Expected exactly one of lock_configuration or marker_environment to be "
+                    "defined, found data: {data}",
+                    data=data,
+                )
+            )
+
+        return cls(
+            dependency_configuration=DependencyConfiguration.create(
+                excluded=data["excluded"], overridden=data["overridden"]
+            ),
+            target=cast(
+                "Union[UniversalTarget, MarkerEnvironment]",
+                universal_target or marker_environment,
+            ),
         )
 
     @classmethod
-    def dump_dependency_configuration(cls, dependency_configuration):
-        # type: (DependencyConfiguration) -> Mapping[str, str]
+    def dump(
+        cls,
+        dependency_configuration,  # type: DependencyConfiguration
+        target,  # type: Union[UniversalTarget, MarkerEnvironment]
+    ):
+        # type: (...) -> Mapping[str, str]
 
         dep_config_file = os.path.join(safe_mkdtemp(), "dep_config.json")
         with open(dep_config_file, "w") as fp:
@@ -41,14 +93,36 @@ class PatchContext(object):
                     "overridden": [
                         str(override) for override in dependency_configuration.all_overrides()
                     ],
+                    "universal_target": (
+                        {
+                            "implementation": (
+                                str(target.implementation) if target.implementation else None
+                            ),
+                            "requires_python": [
+                                str(specifier_set) for specifier_set in target.requires_python
+                            ],
+                            "systems": [str(system) for system in target.systems],
+                        }
+                        if isinstance(target, UniversalTarget)
+                        else None
+                    ),
+                    "marker_environment": (
+                        target.as_dict() if isinstance(target, MarkerEnvironment) else None
+                    ),
                 },
                 fp,
             )
         return {cls._PEX_DEP_CONFIG_FILE_ENV_VAR_NAME: dep_config_file}
 
+    dependency_configuration = attr.ib()  # type: DependencyConfiguration
+    target = attr.ib()  # type: Union[UniversalTarget, MarkerEnvironment]
+
 
-def patch(dependency_configuration):
-    # type: (DependencyConfiguration) -> Optional[DownloadObserver]
+def patch(
+    dependency_configuration,  # type: DependencyConfiguration
+    target,  # type: Union[UniversalTarget, MarkerEnvironment]
+):
+    # type: (...) -> Optional[DownloadObserver]
 
     if not dependency_configuration:
         return None
@@ -57,9 +131,7 @@ def patch(dependency_configuration):
         analyzer=None,
         patch_set=PatchSet.create(
             Patch.from_code_resource(
-                __name__,
-                "requires.py",
-                **PatchContext.dump_dependency_configuration(dependency_configuration)
+                __name__, "requires.py", **PatchContext.dump(dependency_configuration, target)
             )
         ),
     )

pex/pip/dependencies/requires.py

@@ -1,7 +1,7 @@
 # Copyright 2024 Pex project contributors.
 # Licensed under the Apache License, Version 2.0 (see LICENSE).
 
-from __future__ import absolute_import, print_function
+from __future__ import absolute_import
 
 import logging
 import sys
@@ -14,9 +14,34 @@ def patch():
 
     from pex.common import pluralize
     from pex.dist_metadata import Requirement as PexRequirement
+    from pex.pep_508 import MarkerEnvironment
     from pex.pip.dependencies import PatchContext
+    from pex.resolve.target_system import UniversalTarget
+    from pex.typing import TYPE_CHECKING
 
-    dependency_configuration = PatchContext.load_dependency_configuration()
+    if TYPE_CHECKING:
+        from typing import Dict, Optional, Sequence
+
+    patch_context = PatchContext.load()
+    dependency_configuration = patch_context.dependency_configuration
+    target = patch_context.target
+
+    marker_environment = None  # type: Optional[Dict[str, str]]
+    if isinstance(target, MarkerEnvironment):
+        marker_environment = target.as_dict()
+
+    def are_exhaustive(
+        universal_target,  # type: UniversalTarget
+        overrides,  # type: Sequence[Requirement]
+    ):
+        # type: (...) -> bool
+
+        markers = [override.marker for override in overrides if override.marker]
+        if len(markers) < len(overrides):
+            # We have at least one override without a marker; i.e.: the override always applies.
+            return True
+
+        return universal_target.are_exhaustive(markers=markers)
 
     def create_requires(orig_requires):
         def requires(self, *args, **kwargs):
@@ -37,7 +62,17 @@ def patch():
                         )
                     )
                     continue
-                overrides = dependency_configuration.overrides_for(requirement)
+
+                overrides = list(dependency_configuration.overrides_for(requirement))
+                if marker_environment:
+                    overrides = [
+                        override
+                        for override in overrides
+                        if not override.marker or override.marker.evaluate(marker_environment)
+                    ]
+                elif overrides and not are_exhaustive(patch_context.target, overrides):
+                    overrides.append(req)
+
                 if overrides:
                     logger.debug(
                         "[{type}: patched {orig_requires}] Overrode {dep} from {dist} with "

pex/pip/foreign_platform/__init__.py

@@ -12,6 +12,7 @@ from pex.pep_425 import CompatibilityTags
 from pex.pip.download_observer import DownloadObserver, Patch, PatchSet
 from pex.platforms import PlatformSpec
 from pex.targets import AbbreviatedPlatform, CompletePlatform, Target
+from pex.third_party.packaging.specifiers import SpecifierSet
 from pex.tracer import TRACER
 from pex.typing import TYPE_CHECKING
 
@@ -156,7 +157,7 @@ def patch(target):
         "environment markers defined and an abbreviated platform should always have at least the"
         "`python_version` environment marker defined. Given: {target}".format(target=target)
     )
-    requires_python = (
+    requires_python = SpecifierSet(
         "=={full_version}".format(full_version=target.marker_environment.python_full_version)
         if target.marker_environment.python_full_version
         else "=={version}.*".format(version=target.marker_environment.python_version)
@@ -179,7 +180,7 @@ def patch_tags(
 
 
 def patch_requires_python(
-    requires_python,  # type: Iterable[str]
+    requires_python,  # type: Iterable[SpecifierSet]
     patches_dir=None,  # type: Optional[str]
 ):
     # type: (...) -> Patch
@@ -193,7 +194,7 @@ def patch_requires_python(
     """
     with TRACER.timed(
         "Calculating compatible python versions for {requires_python}".format(
-            requires_python=requires_python
+            requires_python=" or ".join(map(str, requires_python))
         )
     ):
         python_full_versions = list(iter_compatible_versions(requires_python))

pex/pip/installation.py

@@ -221,7 +221,7 @@ def _install_wheel(wheel_path):
     with atomic_directory(installed_wheel_dir) as atomic_dir:
         if not atomic_dir.is_finalized():
             installed_wheel = pep_427.install_wheel_chroot(
-                wheel_path=wheel_path, destination=atomic_dir.work_dir
+                wheel=wheel_path, destination=atomic_dir.work_dir
             )
             runtime_key_dir = InstalledWheelDir.create(
                 wheel_name=wheel_name,
@@ -384,7 +384,7 @@ class PipInstallation(object):
                 "{pip_version} requires Python {requires_python}.".format(
                     pip_requirement=self.version.requirement,
                     pip_version=self.version.value,
-                    python_impl=self.interpreter.identity.interpreter,
+                    python_impl=self.interpreter.identity.implementation,
                     python_version=self.interpreter.identity.version_str,
                     python_binary=self.interpreter.binary,
                     requires_python=self.version.requires_python,

pex/pip/local_project.py

@@ -4,9 +4,8 @@
 from __future__ import absolute_import
 
 import os.path
-import tarfile
 
-from pex import hashing
+from pex import hashing, sdist
 from pex.build_system import pep_517
 from pex.common import temporary_dir
 from pex.pip.version import PipVersionValue
@@ -33,25 +32,18 @@ def digest_local_project(
     # type: (...) -> Union[str, Error]
     with TRACER.timed("Fingerprinting local project at {directory}".format(directory=directory)):
         with temporary_dir() as td:
-            sdist_or_error = pep_517.build_sdist(
+            sdist_path_or_error = pep_517.build_sdist(
                 project_directory=directory,
                 dist_dir=os.path.join(td, "dists"),
                 pip_version=pip_version,
                 target=target,
                 resolver=resolver,
             )
-            if isinstance(sdist_or_error, Error):
-                return sdist_or_error
-            sdist = sdist_or_error
+            if isinstance(sdist_path_or_error, Error):
+                return sdist_path_or_error
+            sdist_path = sdist_path_or_error
 
             extract_dir = dest_dir or os.path.join(td, "extracted")
-            with tarfile.open(sdist) as tf:
-                tf.extractall(extract_dir)
-            listing = os.listdir(extract_dir)
-            assert len(listing) == 1, (
-                "Expected sdist generated for {directory} to contain one top-level directory, "
-                "found:\n{listing}".format(directory=directory, listing="\n".join(listing))
-            )
-            project_dir = os.path.join(extract_dir, listing[0])
+            project_dir = sdist.extract_tarball(sdist_path, dest_dir=extract_dir)
             hashing.dir_hash(directory=project_dir, digest=digest)
             return os.path.join(extract_dir, project_dir)

pex/pip/package_repositories/__init__.py

@@ -0,0 +1,78 @@
+# Copyright 2025 Pex project contributors.
+# Licensed under the Apache License, Version 2.0 (see LICENSE).
+
+from __future__ import absolute_import
+
+import json
+import os
+
+from pex.common import safe_mkdtemp
+from pex.pep_508 import MarkerEnvironment
+from pex.pip.download_observer import DownloadObserver, Patch, PatchSet
+from pex.pip.version import PipVersion, PipVersionValue
+from pex.resolve.package_repository import PackageRepositories, ReposConfiguration
+from pex.resolve.target_system import MarkerEnv, UniversalTarget
+from pex.typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from typing import Dict, Mapping, Optional, Union
+
+    import attr  # vendor:skip
+else:
+    from pex.third_party import attr
+
+
+@attr.s(frozen=True)
+class PatchContext(object):
+    _PEX_REPOS_CONFIG_FILE_ENV_VAR_NAME = "_PEX_REPOS_CONFIG_FILE"
+
+    @classmethod
+    def load(cls):
+        # type: () -> PatchContext
+
+        dep_config_file = os.environ.pop(cls._PEX_REPOS_CONFIG_FILE_ENV_VAR_NAME)
+        with open(dep_config_file) as fp:
+            data = json.load(fp)
+        return cls(
+            pip_version=PipVersion.for_value(data["pip_version"]),
+            package_repositories=PackageRepositories.from_dict(data["package_repositories"]),
+        )
+
+    def dump(self):
+        # type: () -> Mapping[str, str]
+
+        repos_config_file = os.path.join(safe_mkdtemp(), "repos_config.json")
+        with open(repos_config_file, "w") as fp:
+            json.dump(
+                {
+                    "pip_version": str(self.pip_version),
+                    "package_repositories": self.package_repositories.as_dict(),
+                },
+                fp,
+            )
+        return {self._PEX_REPOS_CONFIG_FILE_ENV_VAR_NAME: repos_config_file}
+
+    pip_version = attr.ib()  # type: PipVersionValue
+    package_repositories = attr.ib()  # type: PackageRepositories
+
+
+def patch(
+    repos_configuration,  # type: ReposConfiguration
+    pip_version,  # type: PipVersionValue
+    target,  # type: Union[UniversalTarget, MarkerEnvironment]
+):
+    # type: (...) -> Optional[DownloadObserver]
+
+    target_env = (
+        target.marker_env() if isinstance(target, UniversalTarget) else target.as_dict()
+    )  # type: Union[MarkerEnv, Dict[str, str]]
+    package_repositories = repos_configuration.scoped(target_env)
+    if not package_repositories.has_scoped_repositories:
+        return None
+
+    patches = [
+        Patch.from_code_resource(
+            __name__, "link_collector.py", **PatchContext(pip_version, package_repositories).dump()
+        )
+    ]
+    return DownloadObserver(analyzer=None, patch_set=PatchSet(patches=tuple(patches)))

pex/pip/package_repositories/link_collector.py

@@ -0,0 +1,96 @@
+# Copyright 2025 Pex project contributors.
+# Licensed under the Apache License, Version 2.0 (see LICENSE).
+
+from __future__ import absolute_import
+
+import logging
+
+from pex.pip.version import PipVersion
+
+logger = logging.getLogger(__name__)
+
+
+def patch():
+    # type: () -> None
+
+    from contextlib import contextmanager
+
+    from pip._internal.index.collector import LinkCollector
+    from pip._internal.models.search_scope import SearchScope
+
+    from pex.common import pluralize
+    from pex.pep_503 import ProjectName
+    from pex.pip.package_repositories import PatchContext
+    from pex.typing import TYPE_CHECKING
+
+    if TYPE_CHECKING:
+        from typing import Any, Iterator
+
+    patch_context = PatchContext.load()
+
+    @contextmanager
+    def scoped_repositories(link_collector, project_name):
+        # type: (...) -> Iterator[None]
+
+        project = ProjectName(project_name)
+        find_links = patch_context.package_repositories.in_scope_find_links(project)
+        if find_links:
+            logger.debug(
+                "pex: scoped {project_name} to {find_links_repos} {locations}".format(
+                    project_name=project_name,
+                    find_links_repos=pluralize(find_links, "find links repo"),
+                    locations=" and ".join(find_links),
+                )
+            )
+        index_urls = patch_context.package_repositories.in_scope_indexes(project)
+        if index_urls:
+            logger.debug(
+                "pex: scoped {project_name} to {indexes} {locations}".format(
+                    project_name=project_name,
+                    indexes=pluralize(index_urls, "index"),
+                    locations=" and ".join(index_urls),
+                )
+            )
+        if not find_links and not index_urls:
+            find_links = list(patch_context.package_repositories.global_find_links)
+            index_urls = list(patch_context.package_repositories.global_indexes)
+
+        kwargs = {}
+        if patch_context.pip_version >= PipVersion.v22_3:
+            kwargs["no_index"] = link_collector.search_scope.no_index
+
+        orig_search_scope = link_collector.search_scope
+        link_collector.search_scope = SearchScope.create(
+            find_links=find_links, index_urls=index_urls, **kwargs
+        )
+        try:
+            yield
+        finally:
+            link_collector.search_scope = orig_search_scope
+
+    if patch_context.pip_version is PipVersion.VENDORED:
+        orig_collect_links = LinkCollector.collect_links
+
+        def collect_links(
+            self,  # type: LinkCollector
+            project_name,  # type: str
+        ):
+            # type: (...) -> Any
+            with scoped_repositories(self, project_name):
+                return orig_collect_links(self, project_name)
+
+        LinkCollector.collect_links = collect_links
+    else:
+        orig_collect_sources = LinkCollector.collect_sources
+
+        def collect_sources(
+            self,  # type: LinkCollector
+            project_name,  # type: str
+            *args,  # type: Any
+            **kwargs  # type: Any
+        ):
+            # type: (...) -> Any
+            with scoped_repositories(self, project_name):
+                return orig_collect_sources(self, project_name, *args, **kwargs)
+
+        LinkCollector.collect_sources = collect_sources