Handle & test editable lock overrides.

jsirois · jsirois · commit 0bcefd9bb4bf · 2026-03-08T22:57:16.000-07:00
diff --git a/pex/cache/dirs.py b/pex/cache/dirs.py
@@ -3,7 +3,9 @@
 
 from __future__ import absolute_import
 
+import base64
 import glob
+import hashlib
 import os
 
 from pex.common import pluralize, safe_rmtree
@@ -837,6 +839,7 @@ def create(
         fingerprint,  # type: str
         pnav=None,  # type: Optional[ProjectNameAndVersion]
         target=None,  # type: Optional[Target]
+        editable=False,  # type: bool
         pex_root=ENV,  # type: Union[str, Variables]
     ):
         # type: (...) -> BuiltWheelDir
@@ -847,9 +850,15 @@ def create(
         if is_sdist(sdist):
             dist_type = "sdists"
             file_name = os.path.basename(sdist)
+            dist_name = file_name
         else:
-            dist_type = "local_projects"
+            dist_type = "editable_projects" if editable else "local_projects"
             file_name = None
+            dist_name = str(
+                base64.urlsafe_b64encode(hashlib.sha1(sdist.encode("utf-8")).digest())
+                .decode("utf-8")
+                .rstrip("=")
+            )
 
         # For the purposes of building a wheel from source, the product should be uniqued by the
         # wheel name which is unique on the host os up to the python and abi tags. In other words,
@@ -871,9 +880,7 @@ def create(
             abi_tag=interpreter.identity.abi_tag,
             platform_tag=interpreter.identity.platform_tag,
         )
-        sdist_dir = CacheDir.BUILT_WHEELS.path(
-            dist_type, os.path.basename(sdist), pex_root=pex_root
-        )
+        sdist_dir = CacheDir.BUILT_WHEELS.path(dist_type, dist_name, pex_root=pex_root)
         dist_dir = os.path.join(sdist_dir, fingerprint, target_tags)
 
         if is_sdist(sdist):
diff --git a/pex/resolve/locked_resolve.py b/pex/resolve/locked_resolve.py
@@ -933,7 +933,12 @@ def request_resolve(requests):
                 if not target.requirement_applies(request.requirement, extras=request.extras):
                     continue
                 to_be_resolved.append(request)
-                if request.overridden and request.editable and request.requirement.url:
+                if (
+                    request.overridden
+                    and request.editable
+                    and build_configuration.honor_editable
+                    and request.requirement.url
+                ):
                     overridden[request.project_name] = ArtifactURL.parse(request.requirement.url)
 
         resolved = {}  # type: Dict[ProjectName, Set[str]]
diff --git a/pex/resolve/lockfile/pep_751.py b/pex/resolve/lockfile/pep_751.py
@@ -3,6 +3,7 @@
 
 from __future__ import absolute_import
 
+import hashlib
 import os
 import sys
 from collections import OrderedDict, defaultdict, deque
@@ -34,6 +35,7 @@
     LockedRequirement,
     LockedResolve,
     Resolved,
+    UnFingerprintedArtifact,
     UnFingerprintedLocalProjectArtifact,
     UnFingerprintedVCSArtifact,
     VCSArtifact,
@@ -53,6 +55,7 @@
 from pex.toml import InlineTable, TomlDecodeError
 from pex.tracer import TRACER
 from pex.typing import TYPE_CHECKING, cast
+from pex.util import CacheHelper
 
 if TYPE_CHECKING:
     from typing import (
@@ -1176,6 +1179,10 @@ class ResolveError(Exception):
     pass
 
 
+if TYPE_CHECKING:
+    _A = TypeVar("_A", bound=UnFingerprintedArtifact)
+
+
 @attr.s(frozen=True)
 class PackageEvaluator(object):
     @classmethod
@@ -1331,6 +1338,46 @@ def select_best_fit_wheel(self, wheels):
     def select_best_fit_artifact(self, package):
         # type: (Package) -> Union[FileArtifact, UnFingerprintedLocalProjectArtifact, UnFingerprintedVCSArtifact]
 
+        requirement = (
+            self.requirements_by_project_name.get(package.project_name) or package.as_requirement()
+        )
+        override = self.dependency_configuration.overridden_by(requirement, target=self.target)
+        if override:
+
+            def create_invalid_override_error():
+                # type: () -> ResolveError
+                return ResolveError(
+                    "Only local artifacts or projects can be used to override packages in a "
+                    "pylock.toml. Given: {override}".format(override=override)
+                )
+
+            if not override.url:
+                raise create_invalid_override_error()
+            url = ArtifactURL.parse(override.url)
+            if url.scheme != "file":
+                raise create_invalid_override_error()
+            if os.path.isfile(url.path):
+                return FileArtifact(
+                    filename=url.path,
+                    fingerprint=(
+                        url.fingerprint
+                        or Fingerprint(
+                            algorithm="sha256",
+                            hash=CacheHelper.hash(url.path, hasher=hashlib.sha256),
+                        )
+                    ),
+                    url=url,
+                    verified=True,
+                )
+            elif os.path.isdir(url.path):
+                return UnFingerprintedLocalProjectArtifact(
+                    directory=url.path,
+                    editable=self.build_configuration.honor_editable and override.editable,
+                    url=url,
+                    verified=True,
+                )
+            raise create_invalid_override_error()
+
         if not package.has_wheel or not self.build_configuration.allow_wheel(package.project_name):
             # A source distribution (sdist, directory, archive or vcs).
             return package.artifact
diff --git a/pex/resolver.py b/pex/resolver.py
@@ -714,9 +714,15 @@ def prepare(self):
             "Unexpected archive type for sdist {project}".format(project=self.source_path)
         )
 
-    def result(self, source_path=None):
-        # type: (Optional[str]) -> BuildResult
-        return BuildResult.from_request(self, source_path=source_path)
+    def result(
+        self,
+        source_path=None,  # type: Optional[str]
+        honor_editable=False,  # type: bool
+    ):
+        # type: (...) -> BuildResult
+        return BuildResult.from_request(
+            self, source_path=source_path, honor_editable=honor_editable
+        )
 
 
 @attr.s(frozen=True)
@@ -726,13 +732,15 @@ def from_request(
         cls,
         build_request,  # type: BuildRequest
         source_path=None,  # type: Optional[str]
+        honor_editable=False,  # type: bool
     ):
         # type: (...) -> BuildResult
         if build_request.fingerprint:
             built_wheel = BuiltWheelDir.create(
                 sdist=source_path or build_request.source_path,
                 fingerprint=build_request.fingerprint,
                 target=build_request.target,
+                editable=honor_editable and build_request.editable,
             )
             target_dir = built_wheel.dist_dir
         else:
@@ -1028,8 +1036,8 @@ def __init__(
         self._pip_version = pip_version
         self._resolver = resolver
 
-    @staticmethod
     def _categorize_build_requests(
+        self,
         build_requests,  # type: Iterable[BuildRequest]
         check_compatible=True,  # type: bool
     ):
@@ -1039,7 +1047,9 @@ def _categorize_build_requests(
             OrderedSet
         )  # type: DefaultDict[str, OrderedSet[InstallRequest]]
         for build_request in build_requests:
-            build_result = build_request.result()
+            build_result = build_request.result(
+                honor_editable=self._build_configuration.honor_editable
+            )
             if not build_result.is_built:
                 TRACER.log(
                     "Building {} to {}".format(build_request.source_path, build_result.dist_dir)
@@ -1059,7 +1069,9 @@ def _categorize_build_requests(
     def _spawn_wheel_build(self, build_request):
         # type: (BuildRequest) -> SpawnedJob[BuildResult]
         source_path, editable = build_request.prepare()
-        build_result = build_request.result(source_path)
+        build_result = build_request.result(
+            source_path, honor_editable=self._build_configuration.honor_editable
+        )
 
         def spawn_build_wheel():
             # type: () -> SpawnedJob[BuildResult]
diff --git a/tests/integration/test_venv_editables.py b/tests/integration/test_venv_editables.py
@@ -95,7 +95,7 @@ def edit_local_project_all_caps(
 
 
 @skip_too_old_setuptools
-def test_venv_create(
+def test_venv_create_pip(
     tmpdir,  # type: Tempdir
     local_project,  # type: str
 ):
@@ -115,6 +115,91 @@ def test_venv_create(
     assert b"foo" == subprocess.check_output(args=[local_project_script, "foo"])
 
 
+@pytest.fixture
+def pex_lock(
+    tmpdir,  # type: Tempdir
+    local_project,  # type: str
+):
+    # type: (...) -> str
+    pex_lock = tmpdir.join("lock.json")
+    run_pex3("lock", "create", local_project, "--indent", "2", "-o", pex_lock).assert_success()
+    return pex_lock
+
+
+@skip_too_old_setuptools
+def test_venv_create_pex_lock(
+    tmpdir,  # type: Tempdir
+    pex_lock,  # type: str
+    local_project,  # type: str
+):
+    # type: (...) -> None
+
+    venv_dir = tmpdir.join("venv")
+    run_pex3("venv", "create", "--lock", pex_lock, "-d", venv_dir).assert_success()
+    local_project_script = Virtualenv(venv_dir).bin_path("local-project")
+
+    assert b"foo" == subprocess.check_output(args=[local_project_script, "foo"])
+    edit_local_project_all_caps(local_project, all_caps=True)
+    assert b"foo" == subprocess.check_output(args=[local_project_script, "foo"])
+
+    run_pex3(
+        "venv",
+        "create",
+        "--override=-e local_project @ {local_project}".format(local_project=local_project),
+        "--lock",
+        pex_lock,
+        "-d",
+        venv_dir,
+        "--force",
+    ).assert_success()
+    assert b"FOO" == subprocess.check_output(args=[local_project_script, "foo"])
+    edit_local_project_all_caps(local_project, all_caps=False)
+    assert b"foo" == subprocess.check_output(args=[local_project_script, "foo"])
+
+
+@pytest.fixture
+def pylock(
+    tmpdir,  # type: Tempdir
+    pex_lock,  # type: str
+):
+    # type: (...) -> str
+    pylock = tmpdir.join("pylock.toml")
+    # pep-751
+    run_pex3("lock", "export", "--format", "pep-751", "-o", pylock, pex_lock).assert_success()
+    return pylock
+
+
+@skip_too_old_setuptools
+def test_venv_create_pylock(
+    tmpdir,  # type: Tempdir
+    pylock,  # type: str
+    local_project,  # type: str
+):
+    # type: (...) -> None
+
+    venv_dir = tmpdir.join("venv")
+    run_pex3("venv", "create", "--pylock", pylock, "-d", venv_dir).assert_success()
+    local_project_script = Virtualenv(venv_dir).bin_path("local-project")
+
+    assert b"foo" == subprocess.check_output(args=[local_project_script, "foo"])
+    edit_local_project_all_caps(local_project, all_caps=True)
+    assert b"foo" == subprocess.check_output(args=[local_project_script, "foo"])
+
+    run_pex3(
+        "venv",
+        "create",
+        "--override=-e local_project @ file:{local_project}".format(local_project=local_project),
+        "--pylock",
+        pylock,
+        "-d",
+        venv_dir,
+        "--force",
+    ).assert_success()
+    assert b"FOO" == subprocess.check_output(args=[local_project_script, "foo"])
+    edit_local_project_all_caps(local_project, all_caps=False)
+    assert b"foo" == subprocess.check_output(args=[local_project_script, "foo"])
+
+
 @skip_too_old_setuptools
 def test_run(
     tmpdir,  # type: Tempdir
