pex 2.61.0__py2.py3-none-any.whl → 2.62.0__py2.py3-none-any.whl

pex/resolve/locker_patches.py

@@ -3,224 +3,82 @@
 
 from __future__ import absolute_import
 
+import json
 import os
 
-try:
-    from . import requires_python  # type:ignore[attr-defined] # This file will be relocated.
-
-    python_full_versions = requires_python.PYTHON_FULL_VERSIONS
-    python_versions = requires_python.PYTHON_VERSIONS
-    python_majors = sorted(set(version[0] for version in python_full_versions))
-except ImportError:
-    python_full_versions = []
-    python_versions = []
-    python_majors = []
-
-os_names = []
-platform_systems = []
-sys_platforms = []
-platform_tag_regexps = []
+from pex.interpreter_implementation import InterpreterImplementation
+from pex.resolve.target_system import UniversalTarget
 
 # N.B.: The following environment variables are used by the Pex runtime to control Pip and must be
 # kept in-sync with `locker.py`.
-target_systems_file = os.environ.pop("_PEX_TARGET_SYSTEMS_FILE", None)
-
-if target_systems_file:
-    import json
-
-    with open(target_systems_file) as fp:
-        target_systems = json.load(fp)
-    os_names = target_systems["os_names"]
-    platform_systems = target_systems["platform_systems"]
-    sys_platforms = target_systems["sys_platforms"]
-    platform_tag_regexps = target_systems["platform_tag_regexps"]
+target_systems_file = os.environ.pop("_PEX_UNIVERSAL_TARGET_FILE")
+with open(target_systems_file) as fp:
+    universal_target = UniversalTarget.from_dict(json.load(fp))
 
 
 def patch_marker_evaluate():
     from pip._vendor.packaging import markers
 
-    from pex.exceptions import production_assert
-    from pex.interpreter_implementation import InterpreterImplementation
-    from pex.typing import TYPE_CHECKING
-
-    if TYPE_CHECKING:
-        from typing import Any, Callable, Dict, Iterable, List, Tuple, Type
-
-    interpreter_implementation = os.environ.get("_PEX_INTERPRETER_IMPLEMENTATION")
-    interpreter_implementations = []  # type: List[str]
-    if interpreter_implementation:
-        interpreter_implementations.append(str(interpreter_implementation))
-    else:
-        interpreter_implementations.extend(
-            str(implementation) for implementation in InterpreterImplementation.values()
-        )
-
-    original_eval_op = markers._eval_op
+    from pex.pep_503 import ProjectName
+    from pex.sorted_tuple import SortedTuple
+    from pex.third_party import attr
 
-    # N.B.: The `packaging` distribution vendored with Pip>=24.1 has a patch that tests the
-    # `python_full_version` marker environment value to see if it ends with "+", in which case it
-    # appends "local" to it (see: https://github.com/pypa/packaging/pull/802). We support this test
-    # by ensuring our value for `python_full_version`, either a `skip` sentinel or a list value,
-    # both support the `endswith(value)` test and always return `False`.
-    class NeverEndsWithMixin(object):
-        def endswith(self, *args, **kwargs):
-            # type: (...) -> bool
-            return False
+    no_extras_marker_env = universal_target.marker_env()
 
-    class NeverEndsWithStr(NeverEndsWithMixin, str):
-        pass
-
-    skip = NeverEndsWithStr()
-
-    class NeverEndsWithList(NeverEndsWithMixin, list):
-        pass
-
-    def versions_to_string(
-        versions,  # type: Iterable[Tuple[int, ...]]
-        version_modifier=lambda version: version,  # type: Callable[[str], str]
-        list_type=list,  # type: Type[List]
-    ):
-        # type: (...) -> List[str]
-        return list_type(version_modifier(".".join(map(str, version))) for version in versions)
-
-    original_extra = markers.default_environment().get("extra")
-    python_versions_strings = versions_to_string(python_versions) or skip
-    python_full_versions_strings = (
-        versions_to_string(
-            python_full_versions,
-            # N.B.: We replicate the logic `packaging` vendored with Pip>=24.1 has for dealing with
-            # non-tagged CPython builds, which is fine to apply across all versions of Pip and its
-            # vendored packaging that we support.
-            version_modifier=lambda version: (
-                version + "local" if version.endswith("+") else version
-            ),
-            list_type=NeverEndsWithList,
-        )
-        or skip
-    )
-    os_names_strings = os_names or skip
-    platform_systems_strings = platform_systems or skip
-    sys_platforms_strings = sys_platforms or skip
-
-    class EvaluationEnvironment(dict):
-        @classmethod
-        def get_env(
-            cls,
-            environment,  # type: Dict[Any, Any]
-            name,  # type: Any
-        ):
-            # type: (...) -> Any
-            production_assert(
-                isinstance(environment, cls),
-                "Expected environment to come from the {function} function, "
-                "which we patch to return {expected_type}, but was {actual_type}",
-                function=markers.default_environment,
-                expected_type=cls,
-                actual_type=type(environment),
-            )
-            return environment[name]
-
-        def __missing__(self, name):
-            # type: (Any) -> Any
-            if name == "extra":
-                if original_extra is None:
-                    raise markers.UndefinedEnvironmentName(
-                        "'extra' does not exist in evaluation environment."
-                    )
-                return original_extra
-            if name == "platform_python_implementation":
-                return interpreter_implementations
-            if name == "python_version":
-                return python_versions_strings
-            if name == "python_full_version":
-                return python_full_versions_strings
-            if name == "os_name":
-                return os_names_strings
-            if name == "platform_system":
-                return platform_systems_strings
-            if name == "sys_platform":
-                return sys_platforms_strings
-            return skip
-
-    def _eval_op(
-        lhs,  # type: Any
-        op,  # type: Any
-        rhs,  # type: Any
-    ):
-        # type: (...) -> bool
-        if lhs is skip or rhs is skip:
-            return True
-        return any(
-            original_eval_op(left, op, right)
-            for left in (lhs if isinstance(lhs, list) else [lhs])
-            for right in (rhs if isinstance(rhs, list) else [rhs])
-        )
+    def evaluate(self, environment=None):
+        extra = environment.get("extra") if environment else None
+        if extra:
+            return attr.evolve(
+                no_extras_marker_env, extras=SortedTuple([ProjectName(extra).normalized])
+            ).evaluate(self)
+        return no_extras_marker_env.evaluate(self)
 
-    def _evaluate_markers(
-        marker_values,  # type: List[Any]
-        environment,  # type: Dict[str, str]
-    ):
-        # type: (...) -> bool
-        groups = [[]]  # type: List[List[bool]]
-
-        for marker in marker_values:
-            if isinstance(marker, list):
-                groups[-1].append(_evaluate_markers(marker, environment))
-            elif isinstance(marker, tuple):
-                lhs, op, rhs = marker
-
-                if isinstance(lhs, markers.Variable):
-                    lhs_value = EvaluationEnvironment.get_env(environment, lhs.value)
-                    rhs_value = rhs.value
-                else:
-                    lhs_value = lhs.value
-                    rhs_value = EvaluationEnvironment.get_env(environment, rhs.value)
-
-                groups[-1].append(_eval_op(lhs_value, op, rhs_value))
-            else:
-                assert marker in ["and", "or"]
-                if marker == "or":
-                    groups.append([])
-
-        return any(all(item) for item in groups)
-
-    # Works with all Pip vendored packaging distributions.
-    markers.default_environment = EvaluationEnvironment
-
-    # Covers Pip<24.1 vendored packaging.
-    markers._get_env = EvaluationEnvironment.get_env
-
-    markers._eval_op = _eval_op
-
-    # Covers Pip>=25.1 vendored packaging where an assertion is added in the tuple case that lhs is
-    # a string, defeating our EvaluationEnvironment patching above which returns lists of strings
-    # for some environment markers. If it weren't for the assertion, we could use the existing
-    # function.
-    markers._evaluate_markers = _evaluate_markers
+    markers.Marker.evaluate = evaluate
 
 
 def patch_wheel_model():
     from pip._internal.models.wheel import Wheel
 
+    from pex.interpreter_constraints import iter_compatible_versions
+    from pex.resolve.target_system import TargetSystem
+
+    python_versions = sorted(
+        set(version[:2] for version in iter_compatible_versions(universal_target.requires_python))
+    )
+    python_majors = sorted(set(version[0] for version in python_versions))
+
     Wheel.support_index_min = lambda *args, **kwargs: 0
 
     # N.B.: Pip 25.1 updated the Wheel model, removing pyversions, abis and plats and replacing
     # these with a set of file-tags Tag objects. We unify with these helpers.
 
     def get_abi_info(self):
-        if hasattr(self, "abis"):
-            abis = set(self.abis)
-        else:
-            abis = {file_tag.abi for file_tag in self.file_tags}
-
-        is_abi3 = {"abi3"} == abis
-        is_abi_none = {"none"} == abis
-        return is_abi3, is_abi_none
-
-    def get_py_versions(self):
-        if hasattr(self, "pyversions"):
-            return self.pyversions
-        return tuple(file_tag.interpreter for file_tag in self.file_tags)
+        if not hasattr(self, "is_abi3"):
+            abis = (
+                set(self.abis)
+                if hasattr(self, "abis")
+                else {file_tag.abi for file_tag in self.file_tags}
+            )
+            self.is_abi3 = {"abi3"} == abis
+            self.is_abi_none = {"none"} == abis
+        return self.is_abi3, self.is_abi_none
+
+    def get_py_versions_info(self):
+        if not hasattr(self, "pyversions_info"):
+            pyversions_info = []
+            for file_tag in self.file_tags:
+                # For the format, see: https://peps.python.org/pep-0425/#python-tag
+                match = re.search(
+                    r"^(?P<impl>\D{2,})(?P<major>\d)(?P<minor>\d+)?", file_tag.interpreter
+                )
+                if not match:
+                    continue
+                impl = match.group("impl")
+                major = int(match.group("major"))
+                minor = match.group("minor")
+                pyversions_info.append((impl, major, minor))
+            self.pyversions_info = tuple(pyversions_info)
+        return self.pyversions_info
 
     def get_platforms(self):
         if hasattr(self, "plats"):
@@ -235,18 +93,10 @@ def patch_wheel_model():
             if not hasattr(self, "_versions"):
                 versions = set()
                 is_abi3, is_abi_none = get_abi_info(self)
-                for pyversion in get_py_versions(self):
-                    # For the format, see: https://peps.python.org/pep-0425/#python-tag
-                    match = re.search(r"^(?P<impl>\D{2,})(?P<major>\d)(?P<minor>\d+)?", pyversion)
-                    if not match:
-                        continue
-
-                    impl = match.group("impl")
-                    if impl not in ("cp", "pp", "py", "cpython", "pypy"):
+                for impl, major, minor in get_py_versions_info(self):
+                    if impl not in ("py", "cp", "cpython", "pp", "pypy"):
                         continue
 
-                    major = int(match.group("major"))
-                    minor = match.group("minor")
                     if is_abi_none or (is_abi3 and major == 3):
                         versions.add(major)
                     elif minor:
@@ -263,19 +113,83 @@ def patch_wheel_model():
 
         supported_checks.append(supported_version)
 
-    if platform_tag_regexps:
+    if universal_target.systems and set(universal_target.systems) != set(TargetSystem.values()):
         import re
 
-        def supported_platform_tag(self, *_args, **_kwargs):
+        # See: https://peps.python.org/pep-0425/#platform-tag for more about the wheel platform tag.
+        platform_tag_substrings = []
+        for system in universal_target.systems:
+            if system is TargetSystem.LINUX:
+                platform_tag_substrings.append("linux")
+            elif system is TargetSystem.MAC:
+                platform_tag_substrings.append("macosx")
+            elif system is TargetSystem.WINDOWS:
+                platform_tag_substrings.append("win")
+
+        def supported_os_tag(self, *_args, **_kwargs):
+            platforms = get_platforms(self)
+            if any(plat == "any" for plat in platforms):
+                return True
+            for platform_tag_substring in platform_tag_substrings:
+                if any((platform_tag_substring in plat) for plat in platforms):
+                    return True
+            return False
+
+        supported_checks.append(supported_os_tag)
+
+    platform_machine_values = universal_target.extra_markers.get_values("platform_machine")
+    if platform_machine_values:
+        import re
+
+        # See: https://peps.python.org/pep-0425/#platform-tag for more about the wheel platform tag.
+        platform_machine_regexps = tuple(
+            re.compile(re.escape(machine), flags=re.IGNORECASE)
+            for machine in platform_machine_values
+        )
+
+        def supported_machine_tag(self, *_args, **_kwargs):
             platforms = get_platforms(self)
+
             if any(plat == "any" for plat in platforms):
                 return True
-            for platform_tag_regexp in platform_tag_regexps:
-                if any(re.search(platform_tag_regexp, plat) for plat in platforms):
+
+            if platform_machine_values.inclusive:
+                for platform_machine_regexp in platform_machine_regexps:
+                    if any(platform_machine_regexp.search(plat) for plat in platforms):
+                        return True
+                return False
+
+            if all(
+                all(platform_machine_regexp.search(plat) for plat in platforms)
+                for platform_machine_regexp in platform_machine_regexps
+            ):
+                return False
+
+            return True
+
+        supported_checks.append(supported_machine_tag)
+
+    if universal_target.implementation:
+
+        def supported_impl(self, *_args, **_kwargs):
+            for impl, _, _ in get_py_versions_info(self):
+                if impl == "py":
+                    return True
+
+                if (
+                    universal_target.implementation is InterpreterImplementation.CPYTHON
+                    and impl in ("cp", "cpython")
+                ):
+                    return True
+
+                if universal_target.implementation is InterpreterImplementation.PYPY and impl in (
+                    "pp",
+                    "pypy",
+                ):
                     return True
             return False
 
-        supported_checks.append(supported_platform_tag)
+        supported_checks.append(supported_impl)
 
     Wheel.supported = lambda *args, **kwargs: all(
         check(*args, **kwargs) for check in supported_checks

pex/resolve/lockfile/create.py

@@ -41,7 +41,7 @@ from pex.resolve.locked_resolve import (
 from pex.resolve.locker import Locker
 from pex.resolve.lockfile.download_manager import DownloadManager
 from pex.resolve.lockfile.model import Lockfile
-from pex.resolve.lockfile.targets import LockTargets
+from pex.resolve.lockfile.targets import calculate_download_input
 from pex.resolve.package_repository import ReposConfiguration
 from pex.resolve.pep_691.fingerprint_service import FingerprintService
 from pex.resolve.requirement_configuration import RequirementConfiguration
@@ -49,7 +49,7 @@ from pex.resolve.resolved_requirement import Pin, ResolvedRequirement
 from pex.resolve.resolver_configuration import BuildConfiguration, PipConfiguration, ResolverVersion
 from pex.resolve.resolvers import Resolver
 from pex.resolver import BuildRequest, Downloaded, DownloadTarget, ResolveObserver, WheelBuilder
-from pex.resolver import download as pip_download
+from pex.resolver import download_requests as pip_download_requests
 from pex.result import Error, try_
 from pex.targets import Target, Targets
 from pex.tracer import TRACER
@@ -333,12 +333,22 @@ class LockObserver(ResolveObserver):
                 dist_metadatas_by_download_target[local_distribution.download_target].add(
                     DistMetadata.load(local_distribution.path)
                 )
+            elif os.path.isfile(local_distribution.path):
+                build_requests.add(
+                    BuildRequest.for_file(
+                        target=local_distribution.download_target,
+                        source_path=local_distribution.path,
+                        subdirectory=local_distribution.subdirectory,
+                    )
+                )
             else:
                 build_requests.add(
-                    BuildRequest.create(
+                    BuildRequest.for_directory(
                         target=local_distribution.download_target,
                         source_path=local_distribution.path,
                         subdirectory=local_distribution.subdirectory,
+                        resolver=self.resolver,
+                        pip_version=self.package_index_configuration.pip_version,
                     )
                 )
 
@@ -348,7 +358,12 @@ class LockObserver(ResolveObserver):
         for analysis in self._analysis:
             lock_result = analysis.analyzer.lock_result
             build_requests.update(
-                BuildRequest.create(target=analysis.download_target, source_path=local_project)
+                BuildRequest.for_directory(
+                    target=analysis.download_target,
+                    source_path=local_project,
+                    resolver=self.resolver,
+                    pip_version=self.package_index_configuration.pip_version,
+                )
                 for local_project in lock_result.local_projects
             )
             resolved_requirements_by_download_target[
@@ -511,7 +526,7 @@ def create(
 
     download_dir = safe_mkdtemp()
     with TRACER.timed("Calculating lock targets"):
-        lock_targets = LockTargets.calculate(
+        download_input = calculate_download_input(
             targets=targets,
             requirement_configuration=requirement_configuration,
             network_configuration=network_configuration,
@@ -519,11 +534,9 @@ def create(
             universal_target=lock_configuration.universal_target,
         )
     try:
-        downloaded = pip_download(
-            targets=lock_targets.targets,
-            requirements=requirement_configuration.requirements,
-            requirement_files=requirement_configuration.requirement_files,
-            constraint_files=requirement_configuration.constraint_files,
+        downloaded = pip_download_requests(
+            requests=download_input.download_requests,
+            direct_requirements=download_input.direct_requirements,
             allow_prereleases=pip_configuration.allow_prereleases,
             transitive=pip_configuration.transitive,
             repos_configuration=pip_configuration.repos_configuration,
@@ -540,7 +553,6 @@ def create(
             extra_pip_requirements=pip_configuration.extra_requirements,
             keyring_provider=pip_configuration.keyring_provider,
             dependency_configuration=dependency_configuration,
-            universal_targets=lock_targets.universal_targets,
         )
     except resolvers.ResolveError as e:
         return Error(str(e))
@@ -553,7 +565,9 @@ def create(
             download_dir=download_dir, locked_resolves=locked_resolves
         )
         create_lock_download_manager.store_all(
-            targets=lock_targets.targets.unique_targets(),
+            targets=OrderedSet(
+                download_request.target for download_request in download_input.download_requests
+            ),
             lock_configuration=lock_configuration,
             resolver=configured_resolver,
             repos_configuration=pip_configuration.repos_configuration,