fix and simplify handling of single wildcard range exclusion (e.g. "!…

…=1.2.*")

src/poetry/core/constraints/version/parser.py

@@ -205,11 +205,14 @@ def _make_x_constraint_range(
  raise RuntimeError("version is neither stable, nor pre-release nor dev-release")
 
  _min = version
+ _max = _next
 
- if not is_marker_constraint and not _next.is_unstable():
+ if not is_marker_constraint:
  _min = _min.first_devrelease()
+ if not _max.is_devrelease():
+ _max = _max.first_devrelease()
 
- result = VersionRange(_min, _next, include_min=True)
+ result = VersionRange(_min, _max, include_min=True)
 
  if invert:
  return VersionRange().difference(result)

src/poetry/core/constraints/version/version_constraint.py

@@ -63,3 +63,64 @@ def __hash__(self) -> int:
 
  def __eq__(self, other: object) -> bool:
  raise NotImplementedError
+
+
+def _is_wildcard_candidate(
+ min_: Version, max_: Version, *, inverted: bool = False
+) -> bool:
+ if (
+ min_.is_local()
+ or max_.is_local()
+ or min_.is_prerelease()
+ or max_.is_prerelease()
+ or min_.is_postrelease() is not max_.is_postrelease()
+ or min_.first_devrelease() != min_
+ or (max_.is_devrelease() and max_.first_devrelease() != max_)
+ ):
+ return False
+
+ first = max_ if inverted else min_
+ second = min_ if inverted else max_
+
+ parts_first = list(first.parts)
+ parts_second = list(second.parts)
+
+ # remove trailing zeros from second
+ while parts_second and parts_second[-1] == 0:
+ del parts_second[-1]
+
+ # fill up first with zeros
+ parts_first += [0] * (len(parts_second) - len(parts_first))
+
+ # all exceeding parts of first must be zero
+ if set(parts_first[len(parts_second) :]) not in [set(), {0}]:
+ return False
+
+ parts_first = parts_first[: len(parts_second)]
+
+ if first.is_postrelease():
+ assert first.post is not None
+ return parts_first == parts_second and first.post.next() == second.post
+
+ return (
+ parts_first[:-1] == parts_second[:-1]
+ and parts_first[-1] + 1 == parts_second[-1]
+ )
+
+
+def _single_wildcard_range_string(first: Version, second: Version) -> str:
+ if first.is_postrelease():
+ base_version = str(first.without_devrelease())
+
+ else:
+ parts = list(second.parts)
+
+ # remove trailing zeros from max
+ while parts and parts[-1] == 0:
+ del parts[-1]
+
+ parts[-1] = parts[-1] - 1
+
+ base_version = ".".join(str(part) for part in parts)
+
+ return f"{base_version}.*"

src/poetry/core/constraints/version/version_range.py

@@ -4,6 +4,10 @@
 from typing import TYPE_CHECKING
 
 from poetry.core.constraints.version.empty_constraint import EmptyConstraint
+from poetry.core.constraints.version.version_constraint import _is_wildcard_candidate
+from poetry.core.constraints.version.version_constraint import (
+ _single_wildcard_range_string,
+)
 from poetry.core.constraints.version.version_range_constraint import (
  VersionRangeConstraint,
 )
@@ -339,23 +343,9 @@ def _single_wildcard_range_string(self) -> str:
  if not self.is_single_wildcard_range():
  raise ValueError("Not a valid wildcard range")
 
- if self.min.is_postrelease():
- assert self.min is not None
- base_version = str(self.min.without_devrelease())
-
- else:
- assert self.max is not None
- parts = list(self.max.parts)
-
- # remove trailing zeros from max
- while parts and parts[-1] == 0:
- del parts[-1]
-
- parts[-1] = parts[-1] - 1
-
- base_version = ".".join(str(part) for part in parts)
-
- return f"=={base_version}.*"
+ assert self.min is not None
+ assert self.max is not None
+ return f"=={_single_wildcard_range_string(self.min, self.max)}"
 
  def is_single_wildcard_range(self) -> bool:
  # e.g.
@@ -367,31 +357,10 @@ def is_single_wildcard_range(self) -> bool:
  or self.max is None
  or not self.include_min
  or self.include_max
- or self.min.is_local()
- or self.max.is_local()
- or self.max.is_prerelease()
- or self.min.is_postrelease() is not self.max.is_postrelease()
- or self.min.first_devrelease() != self.min
- or (self.max.is_devrelease() and self.max.first_devrelease() != self.max)
  ):
  return False
 
- parts_min = list(self.min.parts)
- parts_max = list(self.max.parts)
-
- # remove trailing zeros from max
- while parts_max and parts_max[-1] == 0:
- del parts_max[-1]
-
- # fill up min with zeros
- parts_min += [0] * (len(parts_max) - len(parts_min))
-
- if set(parts_min[len(parts_max) :]) not in [set(), {0}]:
- return False
- parts_min = parts_min[: len(parts_max)]
- if self.min.is_postrelease():
- return parts_min == parts_max and self.min.post.next() == self.max.post
- return parts_min[:-1] == parts_max[:-1] and parts_min[-1] + 1 == parts_max[-1]
+ return _is_wildcard_candidate(self.min, self.max)
 
  def __eq__(self, other: object) -> bool:
  if not isinstance(other, VersionRangeConstraint):

src/poetry/core/constraints/version/version_union.py

@@ -7,6 +7,10 @@
 
 from poetry.core.constraints.version.empty_constraint import EmptyConstraint
 from poetry.core.constraints.version.version_constraint import VersionConstraint
+from poetry.core.constraints.version.version_constraint import _is_wildcard_candidate
+from poetry.core.constraints.version.version_constraint import (
+ _single_wildcard_range_string,
+)
 from poetry.core.constraints.version.version_range_constraint import (
  VersionRangeConstraint,
 )
@@ -256,168 +260,33 @@ def _exclude_single_wildcard_range_string(self) -> str:
  if not self.excludes_single_wildcard_range():
  raise ValueError("Not a valid wildcard range")
 
- # we assume here that since it is a single exclusion range
- # that it is one of "< 2.0.0 || >= 2.1.0" or ">= 2.1.0 || < 2.0.0"
- # and the one with the max is the first part
  idx_order = (0, 1) if self._ranges[0].max else (1, 0)
- one = self._ranges[idx_order[0]].max
- assert one is not None
- two = self._ranges[idx_order[1]].min
- assert two is not None
-
- # versions can have both semver and non semver parts
- parts_one = [
- one.major,
- one.minor or 0,
- one.patch or 0,
- *list(one.non_semver_parts or []),
- ]
- parts_two = [
- two.major,
- two.minor or 0,
- two.patch or 0,
- *list(two.non_semver_parts or []),
- ]
-
- # we assume here that a wildcard range implies that the part following the
- # first part that is different in the second range is the wildcard, this means
- # that multiple wildcards are not supported right now.
- parts = []
-
- for idx, part in enumerate(parts_one):
- parts.append(str(part))
- if parts_two[idx] != part:
- # since this part is different the next one is the wildcard
- # for example, "< 2.0.0 || >= 2.1.0" gets us a wildcard range
- # 2.0.*
- parts.append("*")
- break
- else:
- # we should not ever get here, however it is likely that poorly
- # constructed metadata exists
- raise ValueError("Not a valid wildcard range")
-
- return f"!={'.'.join(parts)}"
-
- @staticmethod
- def _excludes_single_wildcard_range_check_is_valid_range(
- one: VersionRangeConstraint, two: VersionRangeConstraint
- ) -> bool:
- """
- Helper method to determine if two versions define a single wildcard range.
-
- In cases where !=2.0.* was parsed by us, the union is of the range
- <2.0.0 || >=2.1.0. In user defined ranges, precision might be different.
- For example, a union <2.0 || >= 2.1.0 is still !=2.0.*. In order to
- handle these cases we make sure that if precisions do not match, extra
- checks are performed to validate that the constraint is a valid single
- wildcard range.
- """
+ one = self._ranges[idx_order[0]]
+ two = self._ranges[idx_order[1]]
 
  assert one.max is not None
  assert two.min is not None
-
- _max = one.max
- _min = two.min
-
- if _max.is_devrelease() and _max.dev is not None and _max.dev.number == 0:
- # handle <2.0.0.dev0 || >= 2.1.0
- _max = _max.without_devrelease()
-
- if _min.is_devrelease():
- assert _min.dev is not None
-
- if _min.dev.number != 0:
- # if both are dev releases, they should both have dev0
- return False
- _min = _min.without_devrelease()
-
- max_precision = max(_max.precision, _min.precision)
-
- if max_precision <= 3:
- # In cases where both versions have a precision less than 3,
- # we can make use of the next major/minor/patch versions.
- return _min in {
- _max.next_major(),
- _max.next_minor(),
- _max.next_patch(),
- }
- else:
- # When there are non-semver parts in one of the versions, we need to
- # ensure we use zero padded version and in addition to next major/minor/
- # patch versions, also check each next release for the extra parts.
- from_parts = _max.__class__.from_parts
-
- _extras: list[list[int]] = []
- _versions: list[Version] = []
-
- for _version in (_max, _min):
- _extra = list(_version.non_semver_parts or [])
-
- while len(_extra) < (max_precision - 3):
- # pad zeros for extra parts to ensure precisions are equal
- _extra.append(0)
-
- # create a new release with unspecified parts padded with zeros
- _padded_version: Version = from_parts(
- major=_version.major,
- minor=_version.minor or 0,
- patch=_version.patch or 0,
- extra=tuple(_extra),
- )
-
- _extras.append(_extra)
- _versions.append(_padded_version)
-
- _extra_one = _extras[0]
- _padded_version_one = _versions[0]
- _padded_version_two = _versions[1]
-
- _check_versions = {
- _padded_version_one.next_major(),
- _padded_version_one.next_minor(),
- _padded_version_one.next_patch(),
- }
-
- # for each non-semver (extra) part, bump a version
- for idx, val in enumerate(_extra_one):
- _extra = [
- *_extra_one[: idx - 1],
- (val + 1),
- *_extra_one[idx + 1 :],
- ]
- _check_versions.add(
- from_parts(
- _padded_version_one.major,
- _padded_version_one.minor,
- _padded_version_one.patch,
- tuple(_extra),
- )
- )
-
- return _padded_version_two in _check_versions
+ return f"!={_single_wildcard_range_string(one.max, two.min)}"
 
  def excludes_single_wildcard_range(self) -> bool:
- from poetry.core.constraints.version.version_range import VersionRange
-
  if len(self._ranges) != 2:
  return False
 
  idx_order = (0, 1) if self._ranges[0].max else (1, 0)
  one = self._ranges[idx_order[0]]
  two = self._ranges[idx_order[1]]
 
- is_range_exclusion = (
- one.max and not one.include_max and two.min and two.include_min
- )
-
- if not is_range_exclusion:
- return False
-
- if not self._excludes_single_wildcard_range_check_is_valid_range(one, two):
+ if (
+ one.max is None
+  or one.include_max
+ or one.min is not None
+  or two.min is None
+ or not two.include_min
+ or two.max is not None
+ ):
  return False
 
- return isinstance(VersionRange().difference(self), VersionRange)
+ return _is_wildcard_candidate(two.min, one.max, inverted=True)
 
  def excludes_single_version(self) -> bool:
  from poetry.core.constraints.version.version import Version