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

pex/scie/__init__.py

@@ -222,6 +222,32 @@ def register_options(parser):
             "to the patch level."
         ),
     )
+    parser.add_argument(
+        "--scie-pbs-free-threaded",
+        "--no-scie-pbs-free-threaded",
+        dest="scie_pbs_free_threaded",
+        default=False,
+        type=bool,
+        action=HandleBoolAction,
+        help=(
+            "Should the Python Standalone Builds CPython distributions be free-threaded. If left "
+            "unspecified or otherwise turned off, creating a scie from a PEX with free-threaded "
+            "abi wheels will automatically turn this option on. Note that this option is not "
+            "compatible with `--scie-pbs-stripped`."
+        ),
+    )
+    parser.add_argument(
+        "--scie-pbs-debug",
+        "--no-scie-pbs-debug",
+        dest="scie_pbs_debug",
+        default=False,
+        type=bool,
+        action=HandleBoolAction,
+        help=(
+            "Should the Python Standalone Builds CPython distributions be debug builds. Note that "
+            "this option is not compatible with `--scie-pbs-stripped`."
+        ),
+    )
     parser.add_argument(
         "--scie-pbs-stripped",
         "--no-scie-pbs-stripped",
@@ -232,7 +258,8 @@ def register_options(parser):
         help=(
             "Should the Python Standalone Builds CPython distributions used be stripped of debug "
             "symbols or not. For Linux and Windows particularly, the stripped distributions are "
-            "less than half the size of the distributions that ship with debug symbols."
+            "less than half the size of the distributions that ship with debug symbols. Note that"
+            "this option is not compatible with `--scie-pbs-free-threaded` or `--scie-pbs-debug`."
         ),
     )
     parser.add_argument(
@@ -318,6 +345,10 @@ def render_options(options):
     if options.python_version:
         args.append("--scie-python-version")
         args.append(".".join(map(str, options.python_version)))
+    if options.pbs_free_threaded:
+        args.append("--scie-pbs-free-threaded")
+    if options.pbs_debug:
+        args.append("--scie-pbs-debug")
     if options.pbs_stripped:
         args.append("--scie-pbs-stripped")
     for hash_algorithm in options.hash_algorithms:
@@ -398,6 +429,12 @@ def extract_options(options):
                 )
             )
 
+    if options.scie_pbs_stripped and (options.scie_pbs_free_threaded or options.scie_pbs_debug):
+        raise ValueError(
+            "Python Standalone Builds does not release stripped distributions for debug or "
+            "free-threaded builds."
+        )
+
     science_binary = None  # type: Optional[Union[File, Url]]
     if options.scie_science_binary:
         url_info = urlparse.urlparse(options.scie_science_binary)
@@ -420,6 +457,8 @@ def extract_options(options):
         pbs_release=options.scie_pbs_release,
         pypy_release=options.scie_pypy_release,
         python_version=python_version,
+        pbs_free_threaded=options.scie_pbs_free_threaded,
+        pbs_debug=options.scie_pbs_debug,
         pbs_stripped=options.scie_pbs_stripped,
         hash_algorithms=tuple(options.scie_hash_algorithms),
         science_binary=science_binary,

pex/scie/model.py

@@ -303,6 +303,8 @@ class ScieOptions(object):
     python_version = attr.ib(
         default=None
     )  # type: Optional[Union[Tuple[int, int], Tuple[int, int, int]]]
+    pbs_free_threaded = attr.ib(default=False)  # type: bool
+    pbs_debug = attr.ib(default=False)  # type: bool
     pbs_stripped = attr.ib(default=False)  # type: bool
     hash_algorithms = attr.ib(default=())  # type: Tuple[str, ...]
     science_binary = attr.ib(default=None)  # type: Optional[Union[File, Url]]

pex/scie/science.py

@@ -24,6 +24,7 @@ from pex.hashing import Sha256
 from pex.os import is_exe
 from pex.pep_440 import Version
 from pex.pex import PEX
+from pex.pex_info import PexInfo
 from pex.result import Error, try_
 from pex.scie.model import (
     File,
@@ -37,6 +38,7 @@ from pex.scie.model import (
 )
 from pex.sysconfig import SysPlatform
 from pex.third_party.packaging.specifiers import SpecifierSet
+from pex.third_party.packaging.utils import parse_wheel_filename
 from pex.third_party.packaging.version import InvalidVersion
 from pex.tracer import TRACER
 from pex.typing import TYPE_CHECKING
@@ -66,7 +68,7 @@ class Manifest(object):
 
 
 SCIENCE_RELEASES_URL = "https://github.com/a-scie/lift/releases"
-MIN_SCIENCE_VERSION = Version("0.13.0")
+MIN_SCIENCE_VERSION = Version("0.15.1")
 SCIENCE_REQUIREMENT = SpecifierSet("~={min_version}".format(min_version=MIN_SCIENCE_VERSION))
 
 
@@ -104,6 +106,16 @@ class Filenames(Enum["Filenames.Value"]):
 Filenames.seal()
 
 
+def _is_free_threaded_pex(pex_info):
+    # type: (PexInfo) -> bool
+    for distribution in pex_info.distributions:
+        _, _, _, tags = parse_wheel_filename(os.path.basename(distribution))
+        for tag in tags:
+            if tag.abi.startswith(("cp", "abi3")) and "t" in tag.abi:
+                return True
+    return False
+
+
 def create_manifests(
     configuration,  # type: ScieConfiguration
     name,  # type: str
@@ -270,6 +282,7 @@ def create_manifests(
     }
 
     configure_binding_args = [Filenames.PEX.placeholder, Filenames.CONFIGURE_BINDING.placeholder]
+    pbs_free_threaded = _is_free_threaded_pex(pex_info) or configuration.options.pbs_free_threaded
     for interpreter in configuration.interpreters:
         lift = lift_template.copy()
 
@@ -285,10 +298,17 @@ def create_manifests(
             interpreter.platform.qualified_file_name("{name}-lift.toml".format(name=name)),
         )
 
+        version_str = interpreter.version_str
+        if Provider.PythonBuildStandalone is interpreter.provider:
+            if configuration.options.pbs_debug:
+                version_str += "d"
+            if pbs_free_threaded:
+                version_str += "t"
+
         interpreter_config = {
             "id": "python-distribution",
             "provider": interpreter.provider.value,
-            "version": interpreter.version_str,
+            "version": version_str,
             "lazy": configuration.options.style is ScieStyle.LAZY,
         }
         if interpreter.release:
@@ -297,7 +317,9 @@ def create_manifests(
             interpreter_config["base_url"] = "/".join(
                 (configuration.options.assets_base_url, "providers", str(interpreter.provider))
             )
-        if Provider.PythonBuildStandalone is interpreter.provider:
+        if Provider.PythonBuildStandalone is interpreter.provider and not (
+            configuration.options.pbs_debug or pbs_free_threaded
+        ):
             interpreter_config.update(
                 flavor=(
                     "install_only_stripped"

pex/sdist.py

@@ -0,0 +1,219 @@
+# Copyright 2025 Pex project contributors.
+# Licensed under the Apache License, Version 2.0 (see LICENSE).
+
+from __future__ import absolute_import
+
+import copy
+import os.path
+import sys
+import tarfile
+from tarfile import TarInfo
+
+from pex.compatibility import commonpath
+from pex.typing import TYPE_CHECKING, cast
+
+if TYPE_CHECKING:
+    from typing import Any, Dict, Optional, Text, TypeVar
+
+
+class FilterError(tarfile.TarError):
+    pass
+
+
+class AbsolutePathError(FilterError):
+    pass
+
+
+class OutsideDestinationError(FilterError):
+    pass
+
+
+class SpecialFileError(FilterError):
+    pass
+
+
+class AbsoluteLinkError(FilterError):
+    pass
+
+
+class LinkOutsideDestinationError(FilterError):
+    pass
+
+
+_REALPATH_KWARGS = (
+    {"strict": getattr(os.path, "ALLOW_MISSING", False)} if sys.version_info[:2] >= (3, 10) else {}
+)  # type: Dict[str, Any]
+
+
+if TYPE_CHECKING:
+    _Text = TypeVar("_Text", str, Text)
+
+
+def _realpath(path):
+    # type: (_Text) -> _Text
+    return os.path.realpath(path, **_REALPATH_KWARGS)
+
+
+def _get_filtered_attrs(
+    member,  # type: TarInfo
+    dest_path,  # type: Text
+    for_data=True,  # type: bool
+):
+    # type: (...) -> Dict[str, Any]
+
+    # N.B.: Copied from CPython 3.14 stdlib tarfile.py
+    # Modifications:
+    # + Exception types replicated with error messages placed at call site.
+    # + `os.path.realpath` -> `_realpath` to deal with `strict` parameter.
+    # + `os.path.commonpath` -> `pex.compatibility.commonpath`
+    # + `mode = None` guarded by `sys.version_info[:2] >= (3, 12)` with commentary.
+    # + `{uid,gid,uname,gname} = None` guarded by `sys.version_info[:2] >= (3, 12)` with commentary.
+
+    new_attrs = {}  # type: Dict[str, Any]
+    name = member.name
+    dest_path = _realpath(dest_path)
+    # Strip leading / (tar's directory separator) from filenames.
+    # Include os.sep (target OS directory separator) as well.
+    if name.startswith(("/", os.sep)):
+        name = new_attrs["name"] = member.path.lstrip("/" + os.sep)
+    if os.path.isabs(name):
+        # Path is absolute even after stripping.
+        # For example, 'C:/foo' on Windows.
+        raise AbsolutePathError("member {name!r} has an absolute path".format(name=member.name))
+    # Ensure we stay in the destination
+    target_path = _realpath(os.path.join(dest_path, name))
+    if commonpath([target_path, dest_path]) != dest_path:
+        raise OutsideDestinationError(
+            "{name!r} would be extracted to {path!r}, which is outside the destination".format(
+                name=member.name, path=target_path
+            )
+        )
+    # Limit permissions (no high bits, and go-w)
+    mode = member.mode  # type: Optional[int]
+    if mode is not None:
+        # Strip high bits & group/other write bits
+        mode = mode & 0o755
+        if for_data:
+            # For data, handle permissions & file types
+            if member.isreg() or member.islnk():
+                if not mode & 0o100:
+                    # Clear executable bits if not executable by user
+                    mode &= ~0o111
+                # Ensure owner can read & write
+                mode |= 0o600
+            elif member.isdir() or member.issym():
+                if sys.version_info[:2] >= (3, 12):
+                    # Ignore mode for directories & symlinks
+                    mode = None
+                else:
+                    # Retain stripped mode since older Pythons do not support None.
+                    pass
+            else:
+                # Reject special files
+                raise SpecialFileError("{name!r} is a special file".format(name=member.name))
+        if mode != member.mode:
+            new_attrs["mode"] = mode
+    if for_data:
+        if sys.version_info[:2] >= (3, 12):
+            # Ignore ownership for 'data'
+            if member.uid is not None:
+                new_attrs["uid"] = None
+            if member.gid is not None:
+                new_attrs["gid"] = None
+            if member.uname is not None:
+                new_attrs["uname"] = None
+            if member.gname is not None:
+                new_attrs["gname"] = None
+        else:
+            # Retain uid/gid/uname/gname since older Pythons do not support None.
+            pass
+
+        # Check link destination for 'data'
+        if member.islnk() or member.issym():
+            if os.path.isabs(member.linkname):
+                raise AbsoluteLinkError(
+                    "{name!r} is a link to an absolute path".format(name=member.name)
+                )
+            normalized = os.path.normpath(member.linkname)
+            if normalized != member.linkname:
+                new_attrs["linkname"] = normalized
+            if member.issym():
+                target_path = os.path.join(dest_path, os.path.dirname(name), member.linkname)
+            else:
+                target_path = os.path.join(dest_path, member.linkname)
+            target_path = _realpath(target_path)
+            if commonpath([target_path, dest_path]) != dest_path:
+                raise LinkOutsideDestinationError(
+                    "{name!r} would link to {path!r}, which is outside the destination".format(
+                        name=member.name, path=target_path
+                    )
+                )
+    return new_attrs
+
+
+def _replace(
+    member,  # type: TarInfo
+    attrs,  # type: Dict[str, Any]
+):
+    # type: (...) -> TarInfo
+
+    replace = getattr(member, "replace", None)
+    if replace:
+        attrs["deep"] = False
+        return cast(TarInfo, replace(**attrs))
+
+    result = copy.copy(member)
+    for attr, value in attrs.items():
+        setattr(result, attr, value)
+    return result
+
+
+def _data_filter(
+    member,  # type: TarInfo
+    dest_path,  # type: Text
+):
+    # type: (...) -> TarInfo
+    new_attrs = _get_filtered_attrs(member, dest_path, True)
+    if new_attrs:
+        return _replace(member, new_attrs)
+    return member
+
+
+_EXTRACTALL_DATA_FILTER_KWARGS = {"filter": "data"}  # type: Dict[str, Any]
+
+
+class InvalidSourceDistributionError(ValueError):
+    pass
+
+
+def extract_tarball(
+    tarball_path,  # type: Text
+    dest_dir,  # type: _Text
+):
+    # type: (...) -> _Text
+
+    with tarfile.open(tarball_path) as tf:
+        if sys.version_info[:2] >= (3, 12):
+            tf.extractall(dest_dir, **_EXTRACTALL_DATA_FILTER_KWARGS)
+        else:
+            for tar_info in tf:  # type: ignore[unreachable]
+                tar_info = _data_filter(tar_info, dest_dir)
+                tf.extract(tar_info, dest_dir)
+
+    listing = os.listdir(dest_dir)
+    if len(listing) != 1:
+        raise InvalidSourceDistributionError(
+            "Expected one top-level project directory to be extracted from {project}, "
+            "found {count}: {listing}".format(
+                project=tarball_path, count=len(listing), listing=", ".join(listing)
+            )
+        )
+
+    project_dir = os.path.join(dest_dir, listing[0])
+    if not os.path.isdir(project_dir):
+        raise InvalidSourceDistributionError(
+            "Expected one top-level project directory to be extracted from {project}, "
+            "found file: {path}".format(project=tarball_path, path=listing[0])
+        )
+
+    return project_dir

pex/sh_boot.py

@@ -11,14 +11,16 @@ from textwrap import dedent
 from pex import dist_metadata, variables
 from pex.compatibility import shlex_quote
 from pex.dist_metadata import Distribution
-from pex.interpreter import PythonInterpreter, calculate_binary_name
+from pex.interpreter import PythonInterpreter
 from pex.interpreter_constraints import InterpreterConstraints, iter_compatible_versions
+from pex.interpreter_implementation import InterpreterImplementation
 from pex.layout import Layout
 from pex.orderedset import OrderedSet
 from pex.os import WINDOWS
 from pex.pep_440 import Version
 from pex.pex_info import PexInfo
 from pex.targets import Targets
+from pex.third_party.packaging.specifiers import SpecifierSet
 from pex.typing import TYPE_CHECKING
 from pex.version import __version__
 
@@ -32,14 +34,12 @@ else:
 
 @attr.s(frozen=True)
 class PythonBinaryName(object):
-    name = attr.ib()  # type: str
+    implementation = attr.ib()  # type: InterpreterImplementation.Value
     version = attr.ib()  # type: Tuple[int, ...]
 
     def render(self, version_components=2):
         # type: (int) -> str
-        return "{name}{version}".format(
-            name=self.name, version=".".join(map(str, self.version[:version_components]))
-        )
+        return self.implementation.calculate_binary_name(self.version[:version_components])
 
 
 def _calculate_applicable_binary_names(
@@ -55,17 +55,15 @@ def _calculate_applicable_binary_names(
     ic_majors_minors = OrderedSet()  # type: OrderedSet[PythonBinaryName]
     if interpreter_constraints:
         ic_majors_minors.update(
-            PythonBinaryName(
-                name=calculate_binary_name(platform_python_implementation=name), version=version
-            )
+            PythonBinaryName(implementation=implementation, version=version)
             for interpreter_constraint in interpreter_constraints
             for version in iter_compatible_versions(
-                requires_python=[str(interpreter_constraint.requires_python)]
+                requires_python=[interpreter_constraint.specifier]
             )
-            for name in (
-                (interpreter_constraint.name,)
-                if interpreter_constraint.name
-                else ("CPython", "PyPy")
+            for implementation in (
+                (interpreter_constraint.implementation,)
+                if interpreter_constraint.implementation
+                else InterpreterImplementation.values()
             )
         )
     # If we get targets from ICs, we only want explicitly specified local interpreter targets;
@@ -75,10 +73,10 @@ def _calculate_applicable_binary_names(
     names = OrderedSet()  # type: OrderedSet[PythonBinaryName]
     # 1. Explicit targets 1st.
     for target in targets.unique_targets(only_explicit=only_explicit):
-        if target.python_version is not None:
+        if target.implementation and target.python_version is not None:
             names.add(
                 PythonBinaryName(
-                    name=target.binary_name(version_components=0), version=target.python_version
+                    implementation=target.implementation, version=target.python_version
                 )
             )
 
@@ -89,10 +87,14 @@ def _calculate_applicable_binary_names(
     # more sophisticated detection and re-direction from these during its own bootstrap. When doing
     # so, select these interpreters from newest to oldest since it more likely any given machine
     # will have Python 3 at this point than it will Python 2.
-    pex_requires_python = ">=2.7"
-    dist = dist_metadata.find_distribution("pex")  # type: Optional[Distribution]
-    if dist and dist.metadata.version == Version(__version__):
-        pex_requires_python = str(dist.metadata.requires_python)
+    pex_requires_python_override = os.environ.get("_PEX_REQUIRES_PYTHON", None)
+    if pex_requires_python_override:
+        pex_requires_python = SpecifierSet(pex_requires_python_override)
+    else:
+        pex_requires_python = SpecifierSet(">=2.7")
+        dist = dist_metadata.find_distribution("pex")  # type: Optional[Distribution]
+        if dist and dist.metadata.version == Version(__version__):
+            pex_requires_python = dist.metadata.requires_python
     pex_supported_python_versions = tuple(
         reversed(list(iter_compatible_versions(requires_python=[pex_requires_python])))
     )
@@ -102,11 +104,12 @@ def _calculate_applicable_binary_names(
     # for CPython end targets and for PyPy it need not be quite as fast since it inherently asks you
     # to trade startup latency for longer term jit performance.
     names.update(
-        PythonBinaryName(name="python", version=version)
+        PythonBinaryName(implementation=InterpreterImplementation.CPYTHON, version=version)
         for version in pex_supported_python_versions
     )
     names.update(
-        PythonBinaryName(name="pypy", version=version) for version in pex_supported_python_versions
+        PythonBinaryName(implementation=InterpreterImplementation.PYPY, version=version)
+        for version in pex_supported_python_versions
     )
 
     # Favor more specific interpreter names since these should need re-direction less often.

pex/sysconfig.py

@@ -82,7 +82,7 @@ class _PlatformValue(Enum.Value):
         self.arch = arch
 
     @property
-    def extension(self):
+    def exe_extension(self):
         # type: () -> str
         return ".exe" if self.os is Os.WINDOWS else ""
 
@@ -93,12 +93,14 @@ class _PlatformValue(Enum.Value):
 
     def binary_name(self, binary_name):
         # type: (_Text) -> _Text
-        return "{binary_name}{extension}".format(binary_name=binary_name, extension=self.extension)
+        return "{binary_name}{extension}".format(
+            binary_name=binary_name, extension=self.exe_extension
+        )
 
     def qualified_binary_name(self, binary_name):
         # type: (_Text) -> _Text
         return "{binary_name}-{platform}{extension}".format(
-            binary_name=binary_name, platform=self, extension=self.extension
+            binary_name=binary_name, platform=self, extension=self.exe_extension
         )
 
     def qualified_file_name(self, file_name):

pex/targets.py

@@ -5,8 +5,9 @@ from __future__ import absolute_import
 
 import os
 
-from pex.dist_metadata import Distribution, Requirement
-from pex.interpreter import PythonInterpreter, calculate_binary_name
+from pex.dist_metadata import Constraint, Distribution
+from pex.interpreter import PythonInterpreter
+from pex.interpreter_implementation import InterpreterImplementation
 from pex.orderedset import OrderedSet
 from pex.pep_425 import CompatibilityTags, RankedTag
 from pex.pep_508 import MarkerEnvironment
@@ -48,14 +49,25 @@ class Target(object):
     id = attr.ib()  # type: str
     platform = attr.ib()  # type: Platform
     marker_environment = attr.ib()  # type: MarkerEnvironment
+    implementation = attr.ib(init=False)  # type: Optional[InterpreterImplementation.Value]
+
+    def __attrs_post_init__(self):
+        interpreter_implementation = None  # type: Optional[InterpreterImplementation.Value]
+        for interpreter_impl in InterpreterImplementation.values():
+            if interpreter_impl.value == self.marker_environment.platform_python_implementation:
+                interpreter_implementation = interpreter_impl
+                break
+        object.__setattr__(self, "implementation", interpreter_implementation)
 
     def binary_name(self, version_components=2):
         # type: (int) -> str
-        return calculate_binary_name(
-            platform_python_implementation=self.marker_environment.platform_python_implementation,
-            python_version=self.python_version[:version_components]
-            if self.python_version and version_components > 0
-            else None,
+        interpreter_implementation = self.implementation or InterpreterImplementation.CPYTHON
+        return interpreter_implementation.calculate_binary_name(
+            version=(
+                self.python_version[:version_components]
+                if self.python_version and version_components > 0
+                else None
+            )
         )
 
     @property
@@ -145,7 +157,7 @@ class Target(object):
 
     def requirement_applies(
         self,
-        requirement,  # type: Requirement
+        requirement,  # type: Constraint
         extras=(),  # type: Iterable[str]
     ):
         # type: (...) -> bool
@@ -171,7 +183,7 @@ class Target(object):
 
     def wheel_applies(self, wheel):
         # type: (Distribution) -> WheelEvaluation
-        wheel_tags = CompatibilityTags.from_wheel(wheel.location)
+        wheel_tags = CompatibilityTags.from_wheel(wheel)
         ranked_tag = self.supported_tags.best_match(wheel_tags)
         return WheelEvaluation(
             tags=tuple(wheel_tags),
@@ -193,6 +205,7 @@ class Target(object):
         return str(self.platform.tag)
 
     def render_description(self):
+        # type: () -> str
         raise NotImplementedError()
 
     def __repr__(self):
@@ -247,6 +260,7 @@ class LocalInterpreter(Target):
         return self.interpreter.binary
 
     def render_description(self):
+        # type: () -> str
         return "{platform} interpreter at {path}".format(
             platform=self.interpreter.platform.tag, path=self.interpreter.binary
         )
@@ -269,6 +283,7 @@ class AbbreviatedPlatform(Target):
         return self.platform.supported_tags
 
     def render_description(self):
+        # type: () -> str
         return "abbreviated platform {platform}".format(platform=self.platform.tag)
 
 
@@ -311,6 +326,7 @@ class CompletePlatform(Target):
         return self._supported_tags
 
     def render_description(self):
+        # type: () -> str
         return "complete platform {platform}".format(platform=self.platform.tag)
 
 
@@ -330,6 +346,11 @@ class Targets(object):
     complete_platforms = attr.ib(default=())  # type: Tuple[CompletePlatform, ...]
     platforms = attr.ib(default=())  # type: Tuple[Optional[Platform], ...]
 
+    @property
+    def is_empty(self):
+        # type: () -> bool
+        return not self.interpreters and not self.complete_platforms and not self.platforms
+
     @property
     def interpreter(self):
         # type: () -> Optional[PythonInterpreter]
@@ -391,7 +412,7 @@ class Targets(object):
 
     def require_at_most_one_target(self, purpose):
         # type: (str) -> Union[Optional[Target], Error]
-        resolved_targets = self.unique_targets(only_explicit=False)
+        resolved_targets = self.unique_targets(only_explicit=True)
         if len(resolved_targets) > 1:
             return Error(
                 "At most a single target is required for {purpose}.\n"

pex/third_party/__init__.py

@@ -639,7 +639,7 @@ def expose_installed_wheels(
 
     from pex.atomic_directory import atomic_directory
     from pex.cache.dirs import InstalledWheelDir
-    from pex.pep_376 import InstalledWheel
+    from pex.installed_wheel import InstalledWheel
 
     for path in expose(dists, interpreter=interpreter):
         # TODO(John Sirois): Maybe consolidate with pex.resolver.BuildAndInstallRequest.