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

pex/resolve/lock_resolver.py

@@ -5,10 +5,11 @@ from __future__ import absolute_import
 
 from collections import defaultdict
 
-from pex.auth import PasswordDatabase, PasswordEntry
+from pex.auth import PasswordDatabase
 from pex.dependency_configuration import DependencyConfiguration
 from pex.dist_metadata import Requirement, is_wheel
 from pex.exceptions import production_assert
+from pex.interpreter_constraints import InterpreterConstraint
 from pex.network_configuration import NetworkConfiguration
 from pex.pep_427 import InstallableType
 from pex.pep_503 import ProjectName
@@ -19,7 +20,6 @@ from pex.resolve.locked_resolve import (
     DownloadableArtifact,
     LocalProjectArtifact,
     LockConfiguration,
-    LockStyle,
     UnFingerprintedLocalProjectArtifact,
 )
 from pex.resolve.lockfile.download_manager import DownloadedArtifact
@@ -28,6 +28,7 @@ from pex.resolve.lockfile.pep_751 import Package, Pylock
 from pex.resolve.lockfile.pep_751 import subset as subset_pylock
 from pex.resolve.lockfile.subset import SubsetResult
 from pex.resolve.lockfile.subset import subset as subset_pex_lock
+from pex.resolve.package_repository import ReposConfiguration
 from pex.resolve.requirement_configuration import RequirementConfiguration
 from pex.resolve.resolver_configuration import BuildConfiguration, ResolverVersion
 from pex.resolve.resolvers import ResolvedDistribution, Resolver, ResolveResult
@@ -51,6 +52,10 @@ if TYPE_CHECKING:
         Union,
     )
 
+    import attr  # vendor:skip
+else:
+    from pex.third_party import attr
+
 
 def _check_subset(
     pylock,  # type: Pylock
@@ -116,11 +121,9 @@ def resolve_from_pylock(
     extras=frozenset(),  # type: FrozenSet[str]
     dependency_groups=frozenset(),  # type: FrozenSet[str]
     constraint_files=None,  # type: Optional[Iterable[str]]
-    indexes=None,  # type: Optional[Sequence[str]]
-    find_links=None,  # type: Optional[Sequence[str]]
+    repos_configuration=ReposConfiguration(),  # type: ReposConfiguration
     resolver_version=None,  # type: Optional[ResolverVersion.Value]
     network_configuration=None,  # type: Optional[NetworkConfiguration]
-    password_entries=(),  # type: Iterable[PasswordEntry]
     build_configuration=BuildConfiguration(),  # type: BuildConfiguration
     compile=False,  # type: bool
     transitive=True,  # type: bool
@@ -157,16 +160,17 @@ def resolve_from_pylock(
         pylock_subset_result.subset_result,
         # This ensures artifact downloads via Pip will not be rejected by Pip for mismatched
         # target interpreters, etc.
-        lock_configuration=LockConfiguration(
-            style=LockStyle.UNIVERSAL,
-            requires_python=tuple([pylock.requires_python]) if pylock.requires_python else (),
+        lock_configuration=LockConfiguration.universal(
+            interpreter_constraints=(
+                [InterpreterConstraint(specifier=pylock.requires_python)]
+                if pylock.requires_python
+                else []
+            )
         ),
         resolver=resolver,
-        indexes=indexes,
-        find_links=find_links,
+        repos_configuration=repos_configuration,
         resolver_version=resolver_version,
         network_configuration=network_configuration,
-        password_entries=password_entries,
         build_configuration=build_configuration,
         compile=compile,
         verify_wheels=verify_wheels,
@@ -204,11 +208,9 @@ def download_from_pylock(
     extras=frozenset(),  # type: FrozenSet[str]
     dependency_groups=frozenset(),  # type: FrozenSet[str]
     constraint_files=None,  # type: Optional[Iterable[str]]
-    indexes=None,  # type: Optional[Sequence[str]]
-    find_links=None,  # type: Optional[Sequence[str]]
+    repos_configuration=ReposConfiguration(),  # type: ReposConfiguration
     resolver_version=None,  # type: Optional[ResolverVersion.Value]
     network_configuration=None,  # type: Optional[NetworkConfiguration]
-    password_entries=(),  # type: Iterable[PasswordEntry]
     build_configuration=BuildConfiguration(),  # type: BuildConfiguration
     transitive=True,  # type: bool
     max_parallel_jobs=None,  # type: Optional[int]
@@ -242,16 +244,17 @@ def download_from_pylock(
         pylock_subset_result.subset_result,
         # This ensures artifact downloads via Pip will not be rejected by Pip for mismatched
         # target interpreters, etc.
-        lock_configuration=LockConfiguration(
-            style=LockStyle.UNIVERSAL,
-            requires_python=tuple([pylock.requires_python]) if pylock.requires_python else (),
+        lock_configuration=LockConfiguration.universal(
+            interpreter_constraints=(
+                [InterpreterConstraint(specifier=pylock.requires_python)]
+                if pylock.requires_python
+                else []
+            ),
         ),
         resolver=resolver,
-        indexes=indexes,
-        find_links=find_links,
+        repos_configuration=repos_configuration,
         resolver_version=resolver_version,
         network_configuration=network_configuration,
-        password_entries=password_entries,
         build_configuration=build_configuration,
         max_parallel_jobs=max_parallel_jobs,
         pip_version=pip_version,
@@ -271,11 +274,9 @@ def resolve_from_pex_lock(
     requirements=None,  # type: Optional[Iterable[str]]
     requirement_files=None,  # type: Optional[Iterable[str]]
     constraint_files=None,  # type: Optional[Iterable[str]]
-    indexes=None,  # type: Optional[Sequence[str]]
-    find_links=None,  # type: Optional[Sequence[str]]
+    repos_configuration=ReposConfiguration(),  # type: ReposConfiguration
     resolver_version=None,  # type: Optional[ResolverVersion.Value]
     network_configuration=None,  # type: Optional[NetworkConfiguration]
-    password_entries=(),  # type: Iterable[PasswordEntry]
     build_configuration=BuildConfiguration(),  # type: BuildConfiguration
     compile=False,  # type: bool
     transitive=True,  # type: bool
@@ -308,13 +309,11 @@ def resolve_from_pex_lock(
     )
     return _resolve_from_subset_result(
         subset_result,
-        lock_configuration=lock.lock_configuration(),
+        lock_configuration=lock.configuration,
         resolver=resolver,
-        indexes=indexes,
-        find_links=find_links,
+        repos_configuration=repos_configuration,
         resolver_version=resolver_version,
         network_configuration=network_configuration,
-        password_entries=password_entries,
         build_configuration=build_configuration,
         compile=compile,
         verify_wheels=verify_wheels,
@@ -335,11 +334,9 @@ def download_from_pex_lock(
     requirements=None,  # type: Optional[Iterable[str]]
     requirement_files=None,  # type: Optional[Iterable[str]]
     constraint_files=None,  # type: Optional[Iterable[str]]
-    indexes=None,  # type: Optional[Sequence[str]]
-    find_links=None,  # type: Optional[Sequence[str]]
+    repos_configuration=ReposConfiguration(),  # type: ReposConfiguration
     resolver_version=None,  # type: Optional[ResolverVersion.Value]
     network_configuration=None,  # type: Optional[NetworkConfiguration]
-    password_entries=(),  # type: Iterable[PasswordEntry]
     build_configuration=BuildConfiguration(),  # type: BuildConfiguration
     transitive=True,  # type: bool
     max_parallel_jobs=None,  # type: Optional[int]
@@ -369,13 +366,11 @@ def download_from_pex_lock(
     )
     downloaded_artifacts = _download_from_subset_result(
         subset_result,
-        lock_configuration=lock.lock_configuration(),
+        lock_configuration=lock.configuration,
         resolver=resolver,
-        indexes=indexes,
-        find_links=find_links,
+        repos_configuration=repos_configuration,
         resolver_version=resolver_version,
         network_configuration=network_configuration,
-        password_entries=password_entries,
         build_configuration=build_configuration,
         max_parallel_jobs=max_parallel_jobs,
         pip_version=pip_version,
@@ -392,11 +387,9 @@ def _download_from_subset_result(
     subset_result,  # type: SubsetResult
     lock_configuration,  # type: LockConfiguration
     resolver,  # type: Resolver
-    indexes=None,  # type: Optional[Sequence[str]]
-    find_links=None,  # type: Optional[Sequence[str]]
+    repos_configuration=ReposConfiguration(),  # type: ReposConfiguration
     resolver_version=None,  # type: Optional[ResolverVersion.Value]
     network_configuration=None,  # type: Optional[NetworkConfiguration]
-    password_entries=(),  # type: Iterable[PasswordEntry]
     build_configuration=BuildConfiguration(),  # type: BuildConfiguration
     max_parallel_jobs=None,  # type: Optional[int]
     pip_version=None,  # type: Optional[PipVersionValue]
@@ -415,13 +408,11 @@ def _download_from_subset_result(
         targets=tuple(resolved_subset.target for resolved_subset in subset_result.subsets),
         lock_configuration=lock_configuration,
         resolver=resolver,
-        indexes=indexes,
-        find_links=find_links,
+        repos_configuration=repos_configuration,
         max_parallel_jobs=max_parallel_jobs,
         pip_version=pip_version,
         resolver_version=resolver_version,
         network_configuration=network_configuration,
-        password_entries=password_entries,
         build_configuration=build_configuration,
         use_pip_config=use_pip_config,
         extra_pip_requirements=extra_pip_requirements,
@@ -440,11 +431,9 @@ def _resolve_from_subset_result(
     subset_result,  # type: SubsetResult
     lock_configuration,  # type: LockConfiguration
     resolver,  # type: Resolver
-    indexes=None,  # type: Optional[Sequence[str]]
-    find_links=None,  # type: Optional[Sequence[str]]
+    repos_configuration=ReposConfiguration(),  # type: ReposConfiguration
     resolver_version=None,  # type: Optional[ResolverVersion.Value]
     network_configuration=None,  # type: Optional[NetworkConfiguration]
-    password_entries=(),  # type: Iterable[PasswordEntry]
     build_configuration=BuildConfiguration(),  # type: BuildConfiguration
     compile=False,  # type: bool
     verify_wheels=True,  # type: bool
@@ -462,11 +451,9 @@ def _resolve_from_subset_result(
         subset_result,
         lock_configuration=lock_configuration,
         resolver=resolver,
-        indexes=indexes,
-        find_links=find_links,
+        repos_configuration=repos_configuration,
         resolver_version=resolver_version,
         network_configuration=network_configuration,
-        password_entries=password_entries,
         build_configuration=build_configuration,
         max_parallel_jobs=max_parallel_jobs,
         pip_version=pip_version,
@@ -486,7 +473,7 @@ def _resolve_from_subset_result(
                 if is_wheel(downloaded_artifact.path):
                     install_requests.append(
                         InstallRequest(
-                            target=resolved_subset.target,
+                            download_target=resolved_subset.target,
                             wheel_path=downloaded_artifact.path,
                             fingerprint=downloaded_artifact.fingerprint,
                         )
@@ -494,7 +481,7 @@ def _resolve_from_subset_result(
                 else:
                     build_requests.append(
                         BuildRequest(
-                            target=resolved_subset.target,
+                            download_target=resolved_subset.target,
                             source_path=downloaded_artifact.path,
                             fingerprint=downloaded_artifact.fingerprint,
                             subdirectory=downloaded_artifact.subdirectory,
@@ -505,6 +492,9 @@ def _resolve_from_subset_result(
             len(build_requests), len(build_requests) + len(install_requests)
         )
     ):
+        password_database = PasswordDatabase.from_netrc().append(
+            repos_configuration.password_entries
+        )
         build_and_install_request = BuildAndInstallRequest(
             build_requests=build_requests,
             install_requests=install_requests,
@@ -512,10 +502,10 @@ def _resolve_from_subset_result(
             package_index_configuration=PackageIndexConfiguration.create(
                 pip_version=pip_version,
                 resolver_version=resolver_version,
-                indexes=indexes,
-                find_links=find_links,
+                repos_configuration=attr.evolve(
+                    repos_configuration, password_entries=password_database.entries
+                ),
                 network_configuration=network_configuration,
-                password_entries=PasswordDatabase.from_netrc().append(password_entries).entries,
                 use_pip_config=use_pip_config,
                 extra_pip_requirements=extra_pip_requirements,
                 keyring_provider=keyring_provider,

pex/resolve/locked_resolve.py

@@ -12,18 +12,23 @@ from functools import total_ordering
 from pex.artifact_url import VCS, ArtifactURL, Fingerprint, VCSScheme
 from pex.common import pluralize
 from pex.dependency_configuration import DependencyConfiguration
-from pex.dist_metadata import DistMetadata, Requirement, is_sdist, is_wheel
+from pex.dist_metadata import ProjectMetadata, Requirement, is_sdist, is_wheel
 from pex.enum import Enum
 from pex.exceptions import production_assert
+from pex.interpreter_constraints import InterpreterConstraint
+from pex.interpreter_implementation import InterpreterImplementation
 from pex.orderedset import OrderedSet
 from pex.pep_425 import CompatibilityTags, TagRank
+from pex.pep_440 import Version
 from pex.pep_503 import ProjectName
 from pex.rank import Rank
 from pex.resolve.resolved_requirement import PartialArtifact, Pin, ResolvedRequirement
 from pex.resolve.resolver_configuration import BuildConfiguration
+from pex.resolve.target_system import TargetSystem, UniversalTarget
 from pex.result import Error
 from pex.sorted_tuple import SortedTuple
 from pex.targets import Target
+from pex.third_party.packaging.markers import Marker
 from pex.tracer import TRACER
 from pex.typing import TYPE_CHECKING, Generic
 
@@ -67,33 +72,71 @@ class LockStyle(Enum["LockStyle.Value"]):
 LockStyle.seal()
 
 
-class TargetSystem(Enum["TargetSystem.Value"]):
-    class Value(Enum.Value):
-        pass
-
-    LINUX = Value("linux")
-    MAC = Value("mac")
-    WINDOWS = Value("windows")
-
-
-TargetSystem.seal()
-
-
 @attr.s(frozen=True)
 class LockConfiguration(object):
+    @classmethod
+    def universal(
+        cls,
+        interpreter_constraints=(),  # type: Iterable[InterpreterConstraint]
+        systems=(),  # type: Iterable[TargetSystem.Value]
+        elide_unused_requires_dist=False,  # type: bool
+    ):
+        # type: (...) -> LockConfiguration
+
+        implementations = defaultdict(
+            set
+        )  # type: DefaultDict[Optional[InterpreterImplementation.Value], Set[SpecifierSet]]
+        for interpreter_constraint in interpreter_constraints:
+            implementations[interpreter_constraint.implementation].add(
+                interpreter_constraint.requires_python
+            )
+        if len(implementations) > 1 and frozenset(implementations) != frozenset(
+            InterpreterImplementation.values()
+        ):
+            raise ValueError(
+                "The interpreter constraints for a universal resolve cannot have mixed "
+                "implementations unless they are all explicit and span the full set of Pex "
+                "supported implementations: {implementations}.\n"
+                "Given: {constraints}".format(
+                    implementations=" and ".join(map(str, InterpreterImplementation.values())),
+                    constraints=" or ".join(map(str, interpreter_constraints)),
+                )
+            )
+        elif len(set(map(frozenset, implementations.values()))) > 1:
+            raise ValueError(
+                "The interpreter constraints for a universal resolve cannot have mixed "
+                "implementations with differing specifiers.\n"
+                "If you feel you need this support, please comment here: "
+                "https://github.com/pex-tool/pex/issues/2897#issuecomment-3256619591\n"
+                "Given: {constraints}".format(
+                    constraints=" or ".join(map(str, interpreter_constraints))
+                )
+            )
+
+        return cls(
+            style=LockStyle.UNIVERSAL,
+            universal_target=UniversalTarget(
+                implementation=next(iter(implementations)) if len(implementations) == 1 else None,
+                requires_python=tuple(
+                    interpreter_constraint.requires_python
+                    for interpreter_constraint in interpreter_constraints
+                ),
+                systems=tuple(systems),
+            ),
+            elide_unused_requires_dist=elide_unused_requires_dist,
+        )
+
     style = attr.ib()  # type: LockStyle.Value
-    requires_python = attr.ib(default=())  # type: Tuple[str, ...]
-    target_systems = attr.ib(default=())  # type: Tuple[TargetSystem.Value, ...]
+    universal_target = attr.ib(default=None)  # type: Optional[UniversalTarget]
     elide_unused_requires_dist = attr.ib(default=False)  # type: bool
 
-    @requires_python.validator
-    @target_systems.validator
+    @universal_target.validator
     def _validate_only_set_for_universal(
         self,
         attribute,  # type: Any
         value,  # type: Any
     ):
-        if value and self.style != LockStyle.UNIVERSAL:
+        if value and self.style is not LockStyle.UNIVERSAL:
             raise ValueError(
                 "The {field_name} field should only be set for {universal} style locks; "
                 "this lock is {style} style and given {field_name} value of {value}".format(
@@ -238,7 +281,11 @@ class VCSArtifact(Artifact):
     def split_requested_revision(artifact_url):
         # type: (ArtifactURL) -> Tuple[ArtifactURL, Optional[str]]
 
-        vcs_url, _, requested_revision = artifact_url.normalized_url.partition("@")
+        vcs_url = artifact_url.normalized_url
+        if "@" in artifact_url.path:
+            vcs_url, _, requested_revision = vcs_url.rpartition("@")
+        else:
+            requested_revision = None
         return ArtifactURL.parse(vcs_url), requested_revision or None
 
     @classmethod
@@ -541,7 +588,7 @@ class DownloadableArtifact(object):
         attr.ib()
     )  # type: Union[FileArtifact, LocalProjectArtifact, UnFingerprintedLocalProjectArtifact, UnFingerprintedVCSArtifact, VCSArtifact]
     satisfied_direct_requirements = attr.ib(default=SortedTuple())  # type: SortedTuple[Requirement]
-    version = attr.ib(default=None)
+    version = attr.ib(default=None)  # type: Optional[Version]
 
     def specifier(self):
         # type: () -> str
@@ -613,9 +660,10 @@ class LockedResolve(object):
     def create(
         cls,
         resolved_requirements,  # type: Iterable[ResolvedRequirement]
-        dist_metadatas,  # type: Iterable[DistMetadata]
+        project_metadatas,  # type: Iterable[ProjectMetadata]
         fingerprinter,  # type: Fingerprinter
         platform_tag=None,  # type: Optional[tags.Tag]
+        marker=None,  # type: Optional[Marker]
     ):
         # type: (...) -> LockedResolve
 
@@ -655,21 +703,21 @@ class LockedResolve(object):
                 editable=partial_artifact.editable,
             )
 
-        dist_metadata_by_pin = {
+        project_metadata_by_pin = {
             Pin(dist_info.project_name, dist_info.version): dist_info
-            for dist_info in dist_metadatas
+            for dist_info in project_metadatas
         }
         locked_requirements = []
         for resolved_requirement in resolved_requirements:
-            distribution_metadata = dist_metadata_by_pin.get(resolved_requirement.pin)
-            if distribution_metadata is None:
+            project_metadata = project_metadata_by_pin.get(resolved_requirement.pin)
+            if project_metadata is None:
                 raise ValueError(
-                    "No distribution metadata found for {project}.\n"
-                    "Given distribution metadata for:\n"
+                    "No project metadata found for {project}.\n"
+                    "Given project metadata for:\n"
                     "{projects}".format(
                         project=resolved_requirement.pin.as_requirement(),
                         projects="\n".join(
-                            sorted(str(pin.as_requirement()) for pin in dist_metadata_by_pin)
+                            sorted(str(pin.as_requirement()) for pin in project_metadata_by_pin)
                         ),
                     )
                 )
@@ -677,23 +725,32 @@ class LockedResolve(object):
                 LockedRequirement.create(
                     pin=resolved_requirement.pin,
                     artifact=resolve_fingerprint(resolved_requirement.artifact),
-                    requires_dists=distribution_metadata.requires_dists,
-                    requires_python=distribution_metadata.requires_python,
+                    requires_dists=project_metadata.requires_dists,
+                    requires_python=project_metadata.requires_python,
                     additional_artifacts=(
                         resolve_fingerprint(artifact)
                         for artifact in resolved_requirement.additional_artifacts
                     ),
                 )
             )
-        return cls(locked_requirements=SortedTuple(locked_requirements), platform_tag=platform_tag)
+        return cls(
+            locked_requirements=SortedTuple(locked_requirements),
+            platform_tag=platform_tag,
+            marker=marker,
+        )
 
     locked_requirements = attr.ib()  # type: SortedTuple[LockedRequirement]
     platform_tag = attr.ib(order=str, default=None)  # type: Optional[tags.Tag]
+    marker = attr.ib(order=str, default=None)  # type: Optional[Marker]
 
     @property
     def target_platform(self):
         # type: () -> str
-        return str(self.platform_tag) if self.platform_tag else "universal"
+        if self.platform_tag:
+            return str(self.platform_tag)
+        if self.marker:
+            return "universal {marker}".format(marker=self.marker)
+        return "universal"
 
     def create_resolved_artifacts(
         self,