pex 2.92.2__tar.gz → 2.93.0__tar.gz

{pex-2.92.2 → pex-2.93.0}/CHANGES.md

@@ -1,5 +1,20 @@
 # Release Notes
 
+## 2.93.0
+
+This release adds support for `--pip-version 26.1`.
+
+* Add support for `--pip-version 26.1`. (#3155)
+
+## 2.92.3
+
+This release fixes universal lock splits that use extra markers not directly related to
+`--style universal` target systems or `--interpreter-constraints`. Previously these triggered an
+internal exception. That bug is now fixed and the scope of manually induced splits is now
+broadened to include extra markers when used alone.
+
+* Fix universal lock splitting for extra markers. (#3150)
+
 ## 2.92.2
 
 This release fixes `pex3 lock create --avoid-downloads` hashing of VCS requirements where the VCS

{pex-2.92.2 → pex-2.93.0}/PKG-INFO

@@ -1,15 +1,15 @@
 Metadata-Version: 2.4
 Name: pex
-Version: 2.92.2
+Version: 2.93.0
 Summary: The PEX packaging toolchain.
 Home-page: https://github.com/pex-tool/pex
-Download-URL: https://github.com/pex-tool/pex/releases/download/v2.92.2/pex
+Download-URL: https://github.com/pex-tool/pex/releases/download/v2.93.0/pex
 Author: The PEX developers
 Author-email: developers@pex-tool.org
 License-Expression: Apache-2.0
-Project-URL: Changelog, https://github.com/pex-tool/pex/blob/v2.92.2/CHANGES.md
+Project-URL: Changelog, https://github.com/pex-tool/pex/blob/v2.93.0/CHANGES.md
 Project-URL: Documentation, https://docs.pex-tool.org/
-Project-URL: Source, https://github.com/pex-tool/pex/tree/v2.92.2
+Project-URL: Source, https://github.com/pex-tool/pex/tree/v2.93.0
 Keywords: package,executable,virtualenv,lock,freeze
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers

{pex-2.92.2 → pex-2.93.0}/pex/pip/version.py

@@ -480,6 +480,13 @@ class PipVersion(Enum["PipVersionValue"]):
         requires_python=">=3.9,<3.16",
     )
 
+    v26_1 = PipVersionValue(
+        version="26.1",
+        setuptools_version="82.0.1",
+        wheel_version="0.47.0",
+        requires_python=">=3.10,<3.16",
+    )
+
     ADHOC = Adhoc()
 
     VENDORED = v20_3_4_patched
@@ -491,6 +498,7 @@ class PipVersion(Enum["PipVersionValue"]):
             v23_2,  # First to support 3.12.
             v24_1,  # First with 3.8 lower bound and first to support 3.14.
             v25_1,  # First with 3.9 lower bound.
+            v26_1,  # First with 3.10 lower bound.
         )
     )
 

{pex-2.92.2 → pex-2.93.0}/pex/resolve/lockfile/targets.py

@@ -161,11 +161,23 @@ def _iter_universal_targets(
             implementations.add(implementation)
             requires_python.add(python_specifier)
         impl = implementations.pop() if len(implementations) == 1 else None
-        yield UniversalTarget(
-            implementation=impl,
-            systems=tuple(systems),
-            requires_python=tuple(requires_python),
+        conflicts = ExtraMarkers.extract_conflicts(
+            tuple(split_markers[marker] for marker in markers)
         )
+        if conflicts:
+            for extra_markers in conflicts:
+                yield UniversalTarget(
+                    implementation=impl,
+                    systems=tuple(systems),
+                    requires_python=tuple(requires_python),
+                    extra_markers=extra_markers,
+                )
+        else:
+            yield UniversalTarget(
+                implementation=impl,
+                systems=tuple(systems),
+                requires_python=tuple(requires_python),
+            )
 
 
 if TYPE_CHECKING:

{pex-2.92.2 → pex-2.93.0}/pex/resolve/target_system.py

@@ -5,6 +5,7 @@ from __future__ import absolute_import
 
 import operator
 import sys
+from collections import OrderedDict
 
 from pex import pex_warnings
 from pex.common import pluralize
@@ -290,6 +291,25 @@ class Values(object):
         # type: () -> Dict[str, Any]
         return {"marker_name": self.marker_name, "values": self.values, "inclusive": self.inclusive}
 
+    def as_marker(self):
+        # type: () -> Marker
+
+        op = "==" if self.inclusive else "!="
+
+        def format_clause(value):
+            # type: (str) -> str
+            return "{name} {op} '{value}'".format(name=self.marker_name, op=op, value=value)
+
+        if len(self.values) == 1:
+            return Marker(format_clause(self.values[0]))
+
+        conjunction = " or " if self.inclusive else " and "
+        return Marker(
+            "({values})".format(
+                values=conjunction.join(format_clause(value) for value in self.values)
+            )
+        )
+
     def apply(self, func):
         # type: (Callable[[str], bool]) -> bool
         if len(self.values) == 0:
@@ -516,7 +536,7 @@ class EvalMarkerFunc(object):
 class ExtraMarkersVisitor(MarkerVisitor[str]):
     def __init__(self):
         # type: () -> None
-        self.conflicts = OrderedSet()  # type: OrderedSet[str]
+        self.conflicts = OrderedDict()  # type: OrderedDict[str, Tuple[str, OrderedSet[str], bool]]
         self._marker_values = {}  # type: Dict[str, Tuple[str, OrderedSet[str], bool]]
 
     def visit_op(
@@ -555,7 +575,7 @@ class ExtraMarkersVisitor(MarkerVisitor[str]):
                 name, (context, OrderedSet(), True)
             )
             if not inclusive:
-                self.conflicts.add(
+                conflict = (
                     "The requirement {context} includes {value} for {name} but the requirement "
                     "{requirement} established {name} as an exclusive set with values: "
                     "{values}.".format(
@@ -566,6 +586,10 @@ class ExtraMarkersVisitor(MarkerVisitor[str]):
                         values=" ".join(values),
                     )
                 )
+                _, conflicting_values, _ = self.conflicts.setdefault(
+                    conflict, (name, OrderedSet(), True)
+                )
+                conflicting_values.add(value)
             else:
                 values.add(value)
         elif op_symbol == "!=":
@@ -573,7 +597,7 @@ class ExtraMarkersVisitor(MarkerVisitor[str]):
                 name, (context, OrderedSet(), False)
             )
             if inclusive:
-                self.conflicts.add(
+                conflict = (
                     "The requirement {context} excludes {value} for {name} but the requirement "
                     "{requirement} established {name} as an inclusive set with values: "
                     "{values}.".format(
@@ -584,6 +608,10 @@ class ExtraMarkersVisitor(MarkerVisitor[str]):
                         values=" ".join(values),
                     )
                 )
+                _, conflicting_values, _ = self.conflicts.setdefault(
+                    conflict, (name, OrderedSet(), False)
+                )
+                conflicting_values.add(value)
             else:
                 values.add(value)
         else:
@@ -605,6 +633,38 @@ class ExtraMarkersVisitor(MarkerVisitor[str]):
 
 @attr.s(frozen=True)
 class ExtraMarkers(object):
+    @classmethod
+    def extract_conflicts(cls, markers):
+        # type: (Iterable[Marker]) -> Tuple[ExtraMarkers, ...]
+
+        visitor = ExtraMarkersVisitor()
+        marker_parser = MarkerParser(visitor)
+        for marker in markers:
+            marker_parser.parse(marker, context=str(marker))
+
+        conflicts = []
+        if visitor.conflicts:
+            values_by_marker_name = {
+                values.marker_name: values for values in visitor.marker_values()
+            }
+            for (name, conflicting_vals, inclusive) in visitor.conflicts.values():
+                values = values_by_marker_name[name]
+                conflicts.append(
+                    cls(markers=tuple([values.as_marker()]), marker_values=tuple([values]))
+                )
+                conflicting_values = Values(
+                    marker_name=name,
+                    values=tuple(conflicting_vals),
+                    inclusive=inclusive,
+                )
+                conflicts.append(
+                    cls(
+                        markers=tuple([conflicting_values.as_marker()]),
+                        marker_values=tuple([conflicting_values]),
+                    )
+                )
+        return tuple(conflicts)
+
     @classmethod
     def extract(cls, requirements):
         # type: (Iterable[Tuple[Marker, str]]) -> Optional[ExtraMarkers]
@@ -669,7 +729,16 @@ class MarkerEnv(object):
     @classmethod
     def from_dict(cls, data):
         # type: (Dict[str, Any]) -> MarkerEnv
-        return cls(**data)
+        return cls(
+            extras=SortedTuple(data["extras"]),
+            os_names=SortedTuple(data["os_names"]),
+            platform_systems=SortedTuple(data["platform_systems"]),
+            sys_platforms=SortedTuple(data["sys_platforms"]),
+            platform_python_implementations=SortedTuple(data["platform_python_implementations"]),
+            python_versions=SortedTuple(data["python_versions"]),
+            python_full_versions=SortedTuple(data["python_full_versions"]),
+            extra_markers=ExtraMarkers.from_dict(data["extra_markers"]),
+        )
 
     @classmethod
     def create(
@@ -740,7 +809,16 @@ class MarkerEnv(object):
 
     def as_dict(self):
         # type: () -> Dict[str, Any]
-        return attr.asdict(self)
+        return {
+            "extras": self.extras,
+            "os_names": self.os_names,
+            "platform_systems": self.platform_systems,
+            "sys_platforms": self.sys_platforms,
+            "platform_python_implementations": self.platform_python_implementations,
+            "python_versions": self.python_versions,
+            "python_full_versions": self.python_full_versions,
+            "extra_markers": self.extra_markers.to_dict(),
+        }
 
     def evaluate(self, marker):
         # type: (Marker) -> bool

{pex-2.92.2 → pex-2.93.0}/pex/vendor/__init__.py

@@ -315,7 +315,7 @@ def iter_vendor_specs(
         yield VendorSpec.pinned("packaging", "24.0", import_path="packaging_24_0")
     if not python_major_minor or python_major_minor >= (3, 8):
         # Modern packaging for everyone else.
-        yield VendorSpec.pinned("packaging", "26.0", import_path="packaging_26_0")
+        yield VendorSpec.pinned("packaging", "26.2", import_path="packaging_26_2")
 
     # N.B.: All vendored items below are optional and may not be present in Pex distributions
     # targeting newer Pythons.

pex-2.93.0/pex/vendor/_vendored/packaging_26_2/.layout.json

@@ -0,0 +1 @@
+{"fingerprint":"09e51d5fb82da97200bb23ff1cdf81fdfec33d43583fceb19ecbd9e793acd5a8","record_relpath":"packaging-26.2.dist-info/RECORD","root_is_purelib":true,"stash_dir":".prefix","sys_path_entries":["."]}

pex-2.93.0/pex/vendor/_vendored/packaging_26_2/constraints.txt

@@ -0,0 +1 @@
+packaging==26.2

{pex-2.92.2/pex/vendor/_vendored/packaging_26_0 → pex-2.93.0/pex/vendor/_vendored/packaging_26_2}/packaging/__init__.py

@@ -6,7 +6,7 @@ __title__ = "packaging"
 __summary__ = "Core utilities for Python packages"
 __uri__ = "https://github.com/pypa/packaging"
 
-__version__ = "26.0"
+__version__ = "26.2"
 
 __author__ = "Donald Stufft and individual contributors"
 __email__ = "donald@stufft.io"

{pex-2.92.2/pex/vendor/_vendored/packaging_26_0 → pex-2.93.0/pex/vendor/_vendored/packaging_26_2}/packaging/_parser.py

@@ -27,6 +27,34 @@ class Node:
     def serialize(self) -> str:
         raise NotImplementedError
 
+    def __getstate__(self) -> str:
+        # Return just the value string for compactness and stability.
+        return self.value
+
+    def _restore_value(self, value: object) -> None:
+        if not isinstance(value, str):
+            raise TypeError(
+                f"Cannot restore {self.__class__.__name__} value from {value!r}"
+            )
+        self.value = value
+
+    def __setstate__(self, state: object) -> None:
+        if isinstance(state, str):
+            # New format (26.2+): just the value string.
+            self._restore_value(state)
+            return
+        if isinstance(state, tuple) and len(state) == 2:
+            # Old format (packaging <= 26.0, __slots__): (None, {slot: value}).
+            _, slot_dict = state
+            if isinstance(slot_dict, dict) and "value" in slot_dict:
+                self._restore_value(slot_dict["value"])
+                return
+        if isinstance(state, dict) and "value" in state:
+            # Old format (packaging <= 25.0, no __slots__): plain __dict__.
+            self._restore_value(state["value"])
+            return
+        raise TypeError(f"Cannot restore {self.__class__.__name__} from {state!r}")
+
 
 class Variable(Node):
     __slots__ = ()

pex-2.93.0/pex/vendor/_vendored/packaging_26_2/packaging/_structures.py

@@ -0,0 +1,33 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+"""Backward-compatibility shim for unpickling Version objects serialized before
+packaging 26.1.
+
+Old pickles reference ``packaging._structures.InfinityType`` and
+``packaging._structures.NegativeInfinityType``.  This module provides minimal
+stand-in classes so that ``pickle.loads()`` can resolve those references.
+The deserialized objects are not used for comparisons — ``Version.__setstate__``
+discards the stale ``_key`` cache and recomputes it from the core version fields.
+"""
+
+from __future__ import annotations
+
+
+class InfinityType:
+    """Stand-in for the removed ``InfinityType`` used in old comparison keys."""
+
+    def __repr__(self) -> str:
+        return "Infinity"
+
+
+class NegativeInfinityType:
+    """Stand-in for the removed ``NegativeInfinityType`` used in old comparison keys."""
+
+    def __repr__(self) -> str:
+        return "-Infinity"
+
+
+Infinity = InfinityType()
+NegativeInfinity = NegativeInfinityType()

{pex-2.92.2/pex/vendor/_vendored/packaging_26_0 → pex-2.93.0/pex/vendor/_vendored/packaging_26_2}/packaging/_tokenizer.py

@@ -75,7 +75,7 @@ DEFAULT_RULES: dict[str, re.Pattern[str]] = {
         re.VERBOSE,
     ),
     "SPECIFIER": re.compile(
-        Specifier._operator_regex_str + Specifier._version_regex_str,
+        Specifier._specifier_regex_str,
         re.VERBOSE | re.IGNORECASE,
     ),
     "AT": re.compile(r"\@"),

pex-2.93.0/pex/vendor/_vendored/packaging_26_2/packaging/dependency_groups.py

@@ -0,0 +1,302 @@
+from __future__ import annotations
+
+import re
+from collections.abc import Mapping, Sequence
+
+from .errors import _ErrorCollector
+from .requirements import Requirement
+
+__all__ = [
+    "CyclicDependencyGroup",
+    "DependencyGroupInclude",
+    "DependencyGroupResolver",
+    "DuplicateGroupNames",
+    "InvalidDependencyGroupObject",
+    "resolve_dependency_groups",
+]
+
+
+def __dir__() -> list[str]:
+    return __all__
+
+
+# -----------
+# Error Types
+# -----------
+
+
+class DuplicateGroupNames(ValueError):
+    """
+    The same dependency groups were defined twice, with different non-normalized names.
+    """
+
+
+class CyclicDependencyGroup(ValueError):
+    """
+    The dependency group includes form a cycle.
+    """
+
+    def __init__(self, requested_group: str, group: str, include_group: str) -> None:
+        self.requested_group = requested_group
+        self.group = group
+        self.include_group = include_group
+
+        if include_group == group:
+            reason = f"{group} includes itself"
+        else:
+            reason = f"{include_group} -> {group}, {group} -> {include_group}"
+        super().__init__(
+            "Cyclic dependency group include while resolving "
+            f"{requested_group}: {reason}"
+        )
+
+
+# in the PEP 735 spec, the tables in dependency group lists were described as
+# "Dependency Object Specifiers", but the only defined type of object was a
+# "Dependency Group Include" -- hence the naming of this error as "Object"
+class InvalidDependencyGroupObject(ValueError):
+    """
+    A member of a dependency group was identified as a dict, but was not in a valid
+    format.
+    """
+
+
+# ------------------------
+# Object Model & Interface
+# ------------------------
+
+
+class DependencyGroupInclude:
+    __slots__ = ("include_group",)
+
+    def __init__(self, include_group: str) -> None:
+        """
+        Initialize a DependencyGroupInclude.
+
+        :param include_group: The name of the group referred to by this include.
+        """
+        self.include_group = include_group
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}({self.include_group!r})"
+
+
+class DependencyGroupResolver:
+    """
+    A resolver for Dependency Group data.
+
+    This class handles caching, name normalization, cycle detection, and other
+    parsing requirements. There are only two public methods for exploring the data:
+    ``lookup()`` and ``resolve()``.
+
+    :param dependency_groups: A mapping, as provided via pyproject
+        ``[dependency-groups]``.
+    """
+
+    def __init__(
+        self,
+        dependency_groups: Mapping[str, Sequence[str | Mapping[str, str]]],
+    ) -> None:
+        errors = _ErrorCollector()
+
+        self.dependency_groups = _normalize_group_names(dependency_groups, errors)
+
+        # a map of group names to parsed data
+        self._parsed_groups: dict[
+            str, tuple[Requirement | DependencyGroupInclude, ...]
+        ] = {}
+        # a map of group names to their ancestors, used for cycle detection
+        self._include_graph_ancestors: dict[str, tuple[str, ...]] = {}
+        # a cache of completed resolutions to Requirement lists
+        self._resolve_cache: dict[str, tuple[Requirement, ...]] = {}
+
+        errors.finalize("[dependency-groups] data was invalid")
+
+    def lookup(self, group: str) -> tuple[Requirement | DependencyGroupInclude, ...]:
+        """
+        Lookup a group name, returning the parsed dependency data for that group.
+        This will not resolve includes.
+
+        :param group: the name of the group to lookup
+        """
+        group = _normalize_name(group)
+
+        with _ErrorCollector().on_exit(
+            f"[dependency-groups] data for {group!r} was malformed"
+        ) as errors:
+            return self._parse_group(group, errors)
+
+    def resolve(self, group: str) -> tuple[Requirement, ...]:
+        """
+        Resolve a dependency group to a list of requirements.
+
+        :param group: the name of the group to resolve
+        """
+        group = _normalize_name(group)
+
+        with _ErrorCollector().on_exit(
+            f"[dependency-groups] data for {group!r} was malformed"
+        ) as errors:
+            return self._resolve(group, group, errors)
+
+    def _resolve(
+        self, group: str, requested_group: str, errors: _ErrorCollector
+    ) -> tuple[Requirement, ...]:
+        """
+        This is a helper for cached resolution to strings. It preserves the name of the
+        group which the user initially requested in order to present a clearer error in
+        the event that a cycle is detected.
+
+        :param group: The normalized name of the group to resolve.
+        :param requested_group: The group which was used in the original, user-facing
+            request.
+        """
+        if group in self._resolve_cache:
+            return self._resolve_cache[group]
+
+        parsed = self._parse_group(group, errors)
+
+        resolved_group = []
+
+        for item in parsed:
+            if isinstance(item, Requirement):
+                resolved_group.append(item)
+            elif isinstance(item, DependencyGroupInclude):
+                include_group = _normalize_name(item.include_group)
+
+                # if a group is cyclic, record the error
+                # otherwise, follow the include_group reference
+                #
+                # this allows us to examine all includes in a group, even in the
+                # presence of errors
+                if include_group in self._include_graph_ancestors.get(group, ()):
+                    errors.error(
+                        CyclicDependencyGroup(
+                            requested_group, group, item.include_group
+                        )
+                    )
+                else:
+                    self._include_graph_ancestors[include_group] = (
+                        *self._include_graph_ancestors.get(group, ()),
+                        group,
+                    )
+                    resolved_group.extend(
+                        self._resolve(include_group, requested_group, errors)
+                    )
+            else:  # pragma: no cover
+                raise NotImplementedError(
+                    f"Invalid dependency group item after parse: {item}"
+                )
+
+        # in the event that errors were detected, present the group as empty and do not
+        # cache the result
+        # this ensures that repeated access to a cyclic group will raise multiple errors
+        if errors.errors:
+            return ()
+
+        self._resolve_cache[group] = tuple(resolved_group)
+        return self._resolve_cache[group]
+
+    def _parse_group(
+        self, group: str, errors: _ErrorCollector
+    ) -> tuple[Requirement | DependencyGroupInclude, ...]:
+        # short circuit -- never do the work twice
+        if group in self._parsed_groups:
+            return self._parsed_groups[group]
+
+        if group not in self.dependency_groups:
+            errors.error(LookupError(f"Dependency group '{group}' not found"))
+            return ()
+
+        raw_group = self.dependency_groups[group]
+        if isinstance(raw_group, str):
+            errors.error(
+                TypeError(
+                    f"Dependency group {group!r} contained a string rather than a list."
+                )
+            )
+            return ()
+
+        if not isinstance(raw_group, Sequence):
+            errors.error(
+                TypeError(f"Dependency group {group!r} is not a sequence type.")
+            )
+            return ()
+
+        elements: list[Requirement | DependencyGroupInclude] = []
+        for item in raw_group:
+            if isinstance(item, str):
+                # packaging.requirements.Requirement parsing ensures that this is a
+                # valid PEP 508 Dependency Specifier
+                # raises InvalidRequirement on failure
+                elements.append(Requirement(item))
+            elif isinstance(item, Mapping):
+                if tuple(item.keys()) != ("include-group",):
+                    errors.error(
+                        InvalidDependencyGroupObject(
+                            f"Invalid dependency group item: {item!r}"
+                        )
+                    )
+                else:
+                    include_group = item["include-group"]
+                    elements.append(DependencyGroupInclude(include_group=include_group))
+            else:
+                errors.error(TypeError(f"Invalid dependency group item: {item!r}"))
+
+        self._parsed_groups[group] = tuple(elements)
+        return self._parsed_groups[group]
+
+
+# --------------------
+# Functional Interface
+# --------------------
+
+
+def resolve_dependency_groups(
+    dependency_groups: Mapping[str, Sequence[str | Mapping[str, str]]], /, *groups: str
+) -> tuple[str, ...]:
+    """
+    Resolve a dependency group to a tuple of requirements, as strings.
+
+    :param dependency_groups: the parsed contents of the ``[dependency-groups]`` table
+        from ``pyproject.toml``
+    :param groups: the name of the group(s) to resolve
+    """
+    resolver = DependencyGroupResolver(dependency_groups)
+    return tuple(str(r) for group in groups for r in resolver.resolve(group))
+
+
+# ----------------
+# internal helpers
+# ----------------
+
+
+_NORMALIZE_PATTERN = re.compile(r"[-_.]+")
+
+
+def _normalize_name(name: str) -> str:
+    return _NORMALIZE_PATTERN.sub("-", name).lower()
+
+
+def _normalize_group_names(
+    dependency_groups: Mapping[str, Sequence[str | Mapping[str, str]]],
+    errors: _ErrorCollector,
+) -> dict[str, Sequence[str | Mapping[str, str]]]:
+    original_names: dict[str, list[str]] = {}
+    normalized_groups: dict[str, Sequence[str | Mapping[str, str]]] = {}
+
+    for group_name, value in dependency_groups.items():
+        normed_group_name = _normalize_name(group_name)
+        original_names.setdefault(normed_group_name, []).append(group_name)
+        normalized_groups[normed_group_name] = value
+
+    for normed_name, names in original_names.items():
+        if len(names) > 1:
+            errors.error(
+                DuplicateGroupNames(
+                    "Duplicate dependency group names: "
+                    f"{normed_name} ({', '.join(names)})"
+                )
+            )
+
+    return normalized_groups