markers: avoid combinatorial explosion by replacing compatible MultiMarker/MarkerUnion with AtomicMultiMarker/AtomicMarkerUnion

Author: radoering

src/poetry/core/constraints/generic/union_constraint.py

@@ -1,5 +1,7 @@
 from __future__ import annotations
 
+import itertools
+
 from poetry.core.constraints.generic import AnyConstraint
 from poetry.core.constraints.generic.base_constraint import BaseConstraint
 from poetry.core.constraints.generic.constraint import Constraint
@@ -132,19 +134,28 @@ def union(self, other: BaseConstraint) -> BaseConstraint:
         new_constraints: list[BaseConstraint] = []
         if isinstance(other, UnionConstraint):
             # (A or B) or (C or D) => A or B or C or D
+            our_new_constraints: list[BaseConstraint] = []
+            their_new_constraints: list[BaseConstraint] = []
+            merged_new_constraints: list[BaseConstraint] = []
             for our_constraint in self._constraints:
                 for their_constraint in other.constraints:
                     union = our_constraint.union(their_constraint)
                     if union.is_any():
                         return AnyConstraint()
                     if isinstance(union, Constraint):
-                        if union not in new_constraints:
-                            new_constraints.append(union)
+                        if union not in merged_new_constraints:
+                            merged_new_constraints.append(union)
                     else:
-                        if our_constraint not in new_constraints:
-                            new_constraints.append(our_constraint)
-                        if their_constraint not in new_constraints:
-                            new_constraints.append(their_constraint)
+                        if our_constraint not in our_new_constraints:
+                            our_new_constraints.append(our_constraint)
+                        if their_constraint not in their_new_constraints:
+                            their_new_constraints.append(their_constraint)
+            new_constraints = our_new_constraints
+            for constraint in itertools.chain(
+                their_new_constraints, merged_new_constraints
+            ):
+                if constraint not in new_constraints:
+                    new_constraints.append(constraint)
 
         else:
             assert isinstance(other, MultiConstraint)

src/poetry/core/packages/dependency.py

@@ -176,8 +176,12 @@ def marker(self, marker: str | BaseMarker) -> None:
             self.deactivate()
 
             for or_ in markers["extra"]:
-                for _, extra in or_:
-                    self.in_extras.append(canonicalize_name(extra))
+                for op, extra in or_:
+                    if op == "==":
+                        self.in_extras.append(canonicalize_name(extra))
+                    elif op == "" and "||" in extra:
+                        for _extra in extra.split(" || "):
+                            self.in_extras.append(canonicalize_name(_extra))
 
         # Recalculate python versions.
         self._python_versions = "*"

src/poetry/core/packages/utils/utils.py

@@ -18,6 +18,7 @@
 from poetry.core.constraints.version import VersionRange
 from poetry.core.constraints.version import parse_constraint
 from poetry.core.pyproject.toml import PyProjectTOML
+from poetry.core.version.markers import SingleMarkerLike
 from poetry.core.version.markers import dnf
 
 
@@ -179,10 +180,18 @@ def add_constraint(
     for i, sub_marker in enumerate(conjunctions):
         if isinstance(sub_marker, MultiMarker):
             for m in sub_marker.markers:
-                assert isinstance(m, SingleMarker)
-                add_constraint(m.name, (m.operator, m.value), i)
-        elif isinstance(sub_marker, SingleMarker):
-            add_constraint(sub_marker.name, (sub_marker.operator, sub_marker.value), i)
+                assert isinstance(m, SingleMarkerLike)
+                if isinstance(m, SingleMarker):
+                    add_constraint(m.name, (m.operator, m.value), i)
+                else:
+                    add_constraint(m.name, ("", str(m.constraint)), i)
+        elif isinstance(sub_marker, SingleMarkerLike):
+            if isinstance(sub_marker, SingleMarker):
+                add_constraint(
+                    sub_marker.name, (sub_marker.operator, sub_marker.value), i
+                )
+            else:
+                add_constraint(sub_marker.name, ("", str(sub_marker.constraint)), i)
 
     for group_name in requirements:
         # remove duplicates