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

pex/interpreter_constraints.py

@@ -13,9 +13,10 @@ from pex.compatibility import indent
 from pex.dist_metadata import Requirement, RequirementParseError
 from pex.enum import Enum
 from pex.interpreter import PythonInterpreter
+from pex.interpreter_implementation import InterpreterImplementation
 from pex.orderedset import OrderedSet
 from pex.specifier_sets import UnsatisfiableSpecifierSet, as_range
-from pex.third_party.packaging.specifiers import SpecifierSet
+from pex.third_party.packaging.specifiers import InvalidSpecifier, SpecifierSet
 from pex.typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
@@ -38,23 +39,19 @@ class InterpreterConstraint(object):
     def parse(
         cls,
         constraint,  # type: str
-        default_interpreter=None,  # type: Optional[str]
+        default_interpreter=None,  # type: Optional[InterpreterImplementation.Value]
     ):
         # type: (...) -> InterpreterConstraint
         try:
             requirement = Requirement.parse(constraint)
-            return cls(specifier=requirement.specifier, name=requirement.name)
+            return cls(
+                specifier=requirement.specifier,
+                implementation=InterpreterImplementation.for_value(requirement.name),
+            )
         except RequirementParseError:
-            if default_interpreter is not None:
-                return cls.parse(
-                    constraint="{interpreter}{specifier}".format(
-                        interpreter=default_interpreter, specifier=constraint
-                    ),
-                    default_interpreter=None,
-                )
             try:
-                return cls(specifier=SpecifierSet(constraint))
-            except RequirementParseError as e:
+                return cls(specifier=SpecifierSet(constraint), implementation=default_interpreter)
+            except InvalidSpecifier as e:
                 raise ValueError(
                     "Unparseable interpreter constraint {constraint}: {err}".format(
                         constraint=constraint, err=e
@@ -74,13 +71,13 @@ class InterpreterConstraint(object):
         # type: (Optional[PythonInterpreter]) -> InterpreterConstraint
         python_identity = (interpreter or PythonInterpreter.get()).identity
         return cls.parse(
-            "{interpreter}=={version}".format(
-                interpreter=python_identity.interpreter, version=python_identity.version_str
+            "{implementation}=={version}".format(
+                implementation=python_identity.implementation, version=python_identity.version_str
             )
         )
 
     specifier = attr.ib()  # type: SpecifierSet
-    name = attr.ib(default=None)  # type: Optional[str]
+    implementation = attr.ib(default=None)  # type: Optional[InterpreterImplementation.Value]
 
     @specifier.validator
     def _validate_specifier(
@@ -107,12 +104,14 @@ class InterpreterConstraint(object):
 
     def __str__(self):
         # type: () -> str
-        return "{name}{specifier}".format(name=self.name or "", specifier=self.specifier)
+        return "{implementation}{specifier}".format(
+            implementation=self.implementation or "", specifier=self.specifier
+        )
 
     def __contains__(self, interpreter):
         # type: (PythonInterpreter) -> bool
         python_identity = interpreter.identity
-        if self.name and self.name != python_identity.interpreter:
+        if self.implementation and self.implementation is not python_identity.implementation:
             return False
         return python_identity.version_str in self.specifier
 
@@ -376,22 +375,23 @@ COMPATIBLE_PYTHON_VERSIONS = (
     PythonVersion(Lifecycle.EOL, 3, 6, 15),
     PythonVersion(Lifecycle.EOL, 3, 7, 17),
     PythonVersion(Lifecycle.EOL, 3, 8, 20),
-    PythonVersion(Lifecycle.STABLE, 3, 9, 23),
-    PythonVersion(Lifecycle.STABLE, 3, 10, 18),
-    PythonVersion(Lifecycle.STABLE, 3, 11, 13),
-    PythonVersion(Lifecycle.STABLE, 3, 12, 11),
-    PythonVersion(Lifecycle.STABLE, 3, 13, 7),
-    PythonVersion(Lifecycle.DEV, 3, 14, 0),
+    PythonVersion(Lifecycle.EOL, 3, 9, 25),
+    PythonVersion(Lifecycle.STABLE, 3, 10, 19),
+    PythonVersion(Lifecycle.STABLE, 3, 11, 14),
+    PythonVersion(Lifecycle.STABLE, 3, 12, 12),
+    PythonVersion(Lifecycle.STABLE, 3, 13, 9),
+    PythonVersion(Lifecycle.STABLE, 3, 14, 0),
+    PythonVersion(Lifecycle.DEV, 3, 15, 0),
 )
 
 
 def iter_compatible_versions(
-    requires_python,  # type: Iterable[str]
+    requires_python,  # type: Iterable[SpecifierSet]
     max_patch=DEFAULT_MAX_PATCH,  # type: int
 ):
     # type: (...) -> Iterator[Tuple[int, int, int]]
 
-    specifier_sets = OrderedSet(SpecifierSet(req) for req in requires_python)
+    specifier_sets = OrderedSet(requires_python)
     return itertools.chain.from_iterable(
         python_version.iter_compatible_versions(specifier_sets, max_patch=max_patch)
         for python_version in COMPATIBLE_PYTHON_VERSIONS

pex/interpreter_implementation.py

@@ -0,0 +1,40 @@
+# Copyright 2025 Pex project contributors.
+# Licensed under the Apache License, Version 2.0 (see LICENSE).
+
+from __future__ import absolute_import
+
+from pex.enum import Enum
+from pex.typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from typing import Optional, Tuple
+
+
+class _InterpreterImplementationValue(Enum.Value):
+    def __init__(
+        self,
+        value,  # type: str
+        abbr,  # type: str
+        binary_name,  # type: str
+    ):
+        # type: (...) -> None
+        super(_InterpreterImplementationValue, self).__init__(value)
+        self.abbr = abbr
+        self.binary_name = binary_name
+
+    def calculate_binary_name(self, version=None):
+        # type: (Optional[Tuple[int, ...]]) -> str
+        if not version:
+            return self.binary_name
+        return "{name}{version}".format(name=self.binary_name, version=".".join(map(str, version)))
+
+
+class InterpreterImplementation(Enum["InterpreterImplementation.Value"]):
+    class Value(_InterpreterImplementationValue):
+        pass
+
+    CPYTHON = Value("CPython", "cp", "python")
+    PYPY = Value("PyPy", "pp", "pypy")
+
+
+InterpreterImplementation.seal()

pex/jobs.py

@@ -724,6 +724,19 @@ def iter_map_parallel(
     if not input_items:
         return
 
+    # We want each of the job slots to process MULTIPROCESSING_DEFAULT_MIN_AVERAGE_LOAD on
+    # average in order to overcome multiprocessing overheads. If we don't need at least 2 slots, we
+    # are unlikely to get any boost from multiprocessing.
+    needed_slots = len(input_items) // min_average_load
+    if needed_slots < 2:
+        for item in input_items:
+            yield function(item)
+        return
+
+    # Of course, if there are fewer available cores than that or the user has pinned max jobs lower,
+    # we clamp to that.
+    pool_size = min(needed_slots, _sanitize_max_jobs(max_jobs))
+
     if costing_function is not None:
         # We ensure no job slot is so unlucky as to get all the biggest jobs and thus become an
         # un-necessarily long pole by sorting based on cost. Some examples to illustrate the effect
@@ -740,12 +753,6 @@ def iter_map_parallel(
         #
         input_items.sort(key=costing_function, reverse=True)
 
-    # We want each of the job slots above to process MULTIPROCESSING_DEFAULT_MIN_AVERAGE_LOAD on
-    # average in order to overcome multiprocessing overheads. Of course, if there are fewer
-    # available cores than that or the user has pinned max jobs lower, we clamp to that. Finally, we
-    # always want at least two slots to ensure we process input items in parallel.
-    pool_size = max(2, min(len(input_items) // min_average_load, _sanitize_max_jobs(max_jobs)))
-
     apply_function = functools.partial(_apply_function, function)
 
     slots = defaultdict(list)  # type: DefaultDict[int, List[float]]