Fix pex3 lock sync for multiple requirements for the same project. (#3191)

jsirois · web-flow · commit 6c35b4918d76 · 2026-06-21T06:47:02.000-07:00
Issue discovered in pantsbuild/pants#23407.
diff --git a/CHANGES.md b/CHANGES.md
@@ -1,5 +1,12 @@
 # Release Notes
 
+## 2.96.1
+
+This release fixes `pex3 lock sync` to handle multiple input requirements for the same project
+name.
+
+* Fix `pex3 lock sync` for multiple requirements for the same project.
+
 ## 2.96.0
 
 This release adds support for `--pip-version 26.1.2`.
diff --git a/pex/cli/commands/lock.py b/pex/cli/commands/lock.py
@@ -1894,15 +1894,27 @@ def _process_lock_update(
     ):
         # type: (...) -> Result
 
-        original_requirements_by_project_name = OrderedDict(
-            (requirement.project_name, requirement) for requirement in lock_file.requirements
-        )
-        requirements_by_project_name = OrderedDict(
-            (requirement.project_name, requirement) for requirement in lock_update.requirements
-        )
+        original_requirements_by_project_name = (
+            OrderedDict()
+        )  # type: OrderedDict[ProjectName, OrderedSet[Requirement]]
+        for requirement in lock_file.requirements:
+            original_requirements_by_project_name.setdefault(
+                requirement.project_name, OrderedSet()
+            ).add(requirement)
 
+        requirements_by_project_name = (
+            OrderedDict()
+        )  # type: OrderedDict[ProjectName, OrderedSet[Requirement]]
+        for requirement in lock_update.requirements:
+            requirements_by_project_name.setdefault(requirement.project_name, OrderedSet()).add(
+                requirement
+            )
+
+        # TODO(John Sirois): Support multiple constraints for the same project name distinguished
+        #  by markers.
         original_constraints_by_project_name = OrderedDict(
-            (constraint.project_name, constraint) for constraint in lock_file.constraints
+            (constraint.project_name, OrderedSet([constraint]))
+            for constraint in lock_file.constraints
         )
         constraints_by_project_name = original_constraints_by_project_name.copy()
 
@@ -1951,7 +1963,14 @@ def _process_lock_update(
                         "earlier. Found deleted project {project_name} in updated requirements:\n"
                         "{requirements}",
                         project_name=project_name,
-                        requirements="\n".join(map(str, requirements_by_project_name.values())),
+                        requirements="\n".join(
+                            map(
+                                str,
+                                itertools.chain.from_iterable(
+                                    requirements_by_project_name.values()
+                                ),
+                            )
+                        ),
                     )
                     constraints_by_project_name.pop(project_name, None)
                 elif isinstance(update, VersionUpdate):
@@ -1972,7 +1991,9 @@ def _process_lock_update(
                         # grab the latest version in the range already constrained by an existing
                         # requirement or constraint.
                         if update_req and str(update_req) != update_req.name:
-                            constraints_by_project_name[project_name] = update_req.as_constraint()
+                            constraints_by_project_name[project_name] = OrderedSet(
+                                [update_req.as_constraint()]
+                            )
                     else:
                         print(
                             "  {lead_in} {project_name} {updated_version}".format(
@@ -1983,7 +2004,9 @@ def _process_lock_update(
                             file=output,
                         )
                         if update_req:
-                            requirements_by_project_name[project_name] = update_req
+                            requirements_by_project_name.setdefault(project_name, OrderedSet()).add(
+                                update_req
+                            )
                 elif isinstance(update, ArtifactsUpdate):
                     message_lines = [
                         "  {lead_in} {project_name} {version} artifacts:".format(
@@ -2053,50 +2076,50 @@ def _process_lock_update(
                 )
 
         def process_req_edit(
-            original,  # type: Optional[Constraint]
-            final,  # type: Optional[Constraint]
+            original,  # type: Iterable[Constraint]
+            final,  # type: Iterable[Constraint]
         ):
             # type: (...) -> None
             if not original:
                 print(
                     "  {lead_in} {requirement!r}".format(
                         lead_in="Would add" if dry_run else "Added",
-                        requirement=str(final),
+                        requirement=", ".join(map(str, final)),
                     ),
                     file=output,
                 )
             elif not final:
                 print(
                     "  {lead_in} {requirement!r}".format(
                         lead_in="Would delete" if dry_run else "Deleted",
-                        requirement=str(original),
+                        requirement=", ".join(map(str, original)),
                     ),
                     file=output,
                 )
             else:
                 print(
                     "  {lead_in} {original!r} to {final!r}".format(
                         lead_in="Would update" if dry_run else "Updated",
-                        original=str(original),
-                        final=str(final),
+                        original=", ".join(map(str, original)),
+                        final=", ".join(map(str, final)),
                     ),
                     file=output,
                 )
 
         def process_req_edits(
             requirement_type,  # type: str
-            original,  # type: Mapping[ProjectName, Constraint]
-            final,  # type: Mapping[ProjectName, Constraint]
+            original,  # type: Mapping[ProjectName, Iterable[Constraint]]
+            final,  # type: Mapping[ProjectName, Iterable[Constraint]]
         ):
-            # type: (...) -> Tuple[Tuple[Optional[Constraint], Optional[Constraint]], ...]
-            edits = []  # type: List[Tuple[Optional[Constraint], Optional[Constraint]]]
-            for name, original_req in original.items():
-                final_req = final.get(name)
-                if final_req != original_req:
-                    edits.append((original_req, final_req))
-            for name, final_req in final.items():
+            # type: (...) -> Tuple[Tuple[Iterable[Constraint], Iterable[Constraint]], ...]
+            edits = []  # type: List[Tuple[Iterable[Constraint], Iterable[Constraint]]]
+            for name, original_reqs in original.items():
+                final_reqs = final.get(name, OrderedSet())
+                if final_reqs != original_reqs:
+                    edits.append((original_reqs, final_reqs))
+            for name, final_reqs in final.items():
                 if name not in original:
-                    edits.append((None, final_req))
+                    edits.append((OrderedSet(), final_reqs))
             if not edits:
                 return ()
 
@@ -2138,8 +2161,13 @@ def process_req_edits(
                 lock_file=attr.evolve(
                     lock_file,
                     pex_version=__version__,
-                    requirements=SortedTuple(requirements_by_project_name.values(), key=str),
-                    constraints=SortedTuple(constraints_by_project_name.values(), key=str),
+                    requirements=SortedTuple(
+                        itertools.chain.from_iterable(requirements_by_project_name.values()),
+                        key=str,
+                    ),
+                    constraints=SortedTuple(
+                        itertools.chain.from_iterable(constraints_by_project_name.values()), key=str
+                    ),
                     locked_resolves=SortedTuple(
                         resolve_update.updated_resolve for resolve_update in lock_update.resolves
                     ),
diff --git a/pex/resolve/lockfile/updater.py b/pex/resolve/lockfile/updater.py
@@ -256,28 +256,39 @@ def derived(
     ):
         # type: (...) -> Union[ResolveUpdater, Error]
 
-        original_requirements_by_project_name = OrderedDict(
-            (requirement.project_name, requirement) for requirement in lock_file.requirements
-        )  # type: OrderedDict[ProjectName, Requirement]
+        original_requirements_by_project_name = (
+            OrderedDict()
+        )  # type: OrderedDict[ProjectName, OrderedSet[Requirement]]
+        for requirement in lock_file.requirements:
+            original_requirements_by_project_name.setdefault(
+                requirement.project_name, OrderedSet()
+            ).add(requirement)
 
-        replace_requirements = []  # type: List[Requirement]
+        parsed_requirements_by_project_name = (
+            OrderedDict()
+        )  # type: OrderedDict[ProjectName, OrderedSet[Requirement]]
         for parsed_requirement in parsed_requirements:
             if isinstance(parsed_requirement, (PyPIRequirement, URLRequirement, VCSRequirement)):
                 requirement = parsed_requirement.requirement
-                original_requirement = original_requirements_by_project_name.pop(
-                    requirement.project_name, None
-                )
-                if requirement != original_requirement:
-                    replace_requirements.append(requirement)
+                parsed_requirements_by_project_name.setdefault(
+                    requirement.project_name, OrderedSet()
+                ).add(requirement)
             else:
                 return Error(
                     "Cannot update a bare local project directory requirement on {path}.\n"
                     "Try re-phrasing as a PEP-508 direct reference with a file:// URL.\n"
                     "See: https://peps.python.org/pep-0508/".format(path=parsed_requirement.path)
                 )
+        replace_requirements = OrderedSet()  # type: OrderedSet[Requirement]
+        for project_name, parsed_requirements in parsed_requirements_by_project_name.items():
+            original_reqs = original_requirements_by_project_name.pop(project_name, None)
+            if not original_reqs or parsed_requirements != original_reqs:
+                replace_requirements.update(parsed_requirements)
 
         deletes = tuple(original_requirements_by_project_name) if parsed_requirements else ()
 
+        # TODO(John Sirois): Support multiple constraints for the same project name distinguished
+        #  by markers.
         original_constraints_by_project_name = OrderedDict(
             (constraint.project_name, constraint) for constraint in lock_file.constraints
         )  # type: OrderedDict[ProjectName, Constraint]
@@ -296,15 +307,24 @@ def derived(
                 )
             update_constraints_by_project_name[project_name] = requirement.as_constraint()
 
-        original_requirements = OrderedDict(
-            (requirement.project_name, requirement) for requirement in lock_file.requirements
-        )  # type: OrderedDict[ProjectName, Requirement]
-        original_requirements.update(
-            (replacement.project_name, replacement) for replacement in replace_requirements
-        )
+        original_requirements = (
+            OrderedDict()
+        )  # type: OrderedDict[ProjectName, OrderedSet[Requirement]]
+        for requirement in lock_file.requirements:
+            original_requirements.setdefault(requirement.project_name, OrderedSet()).add(
+                requirement
+            )
+        for replacement in replace_requirements:
+            original_requirements.pop(replacement.project_name, None)
+        for replacement in replace_requirements:
+            original_requirements.setdefault(replacement.project_name, OrderedSet()).add(
+                replacement
+            )
         return cls(
             requirement_configuration=requirement_configuration,
-            original_requirements=tuple(original_requirements.values()),
+            original_requirements=tuple(
+                itertools.chain.from_iterable(original_requirements.values())
+            ),
             update_constraints_by_project_name=update_constraints_by_project_name,
             deletes=frozenset(deletes),
             pure_delete=bool(deletes and not replace_requirements),
diff --git a/pex/version.py b/pex/version.py
@@ -1,4 +1,4 @@
 # Copyright 2015 Pex project contributors.
 # Licensed under the Apache License, Version 2.0 (see LICENSE).
 
-__version__ = "2.96.0"
+__version__ = "2.96.1"
diff --git a/testing/data/locks/bug-report-pantsbuild-23407.lock.json b/testing/data/locks/bug-report-pantsbuild-23407.lock.json
diff --git a/tests/integration/cli/commands/test_lock_sync.py b/tests/integration/cli/commands/test_lock_sync.py
