wip: pypa/packaging compliance

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

@@ -2,6 +2,7 @@
 
 from poetry.core.constraints.version.empty_constraint import EmptyConstraint
 from poetry.core.constraints.version.parser import parse_constraint
+from poetry.core.constraints.version.parser import parse_marker_version_constraint
 from poetry.core.constraints.version.util import constraint_regions
 from poetry.core.constraints.version.version import Version
 from poetry.core.constraints.version.version_constraint import VersionConstraint
@@ -21,4 +22,5 @@
  "VersionUnion",
  "constraint_regions",
  "parse_constraint",
+ "parse_marker_version_constraint",
 ]

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

@@ -6,10 +6,21 @@
 
 
 if TYPE_CHECKING:
+ from poetry.core.constraints.version.version import Version
  from poetry.core.constraints.version.version_constraint import VersionConstraint
 
 
 def parse_constraint(constraints: str) -> VersionConstraint:
+ return _parse_constraint(constraints=constraints)
+
+
+def parse_marker_version_constraint(constraints: str) -> VersionConstraint:
+ return _parse_constraint(constraints=constraints, is_marker_constraint=True)
+
+
+def _parse_constraint(
+ constraints: str, is_marker_constraint: bool = False
+) -> VersionConstraint:
  if constraints == "*":
  from poetry.core.constraints.version.version_range import VersionRange
 
@@ -28,9 +39,13 @@ def parse_constraint(constraints: str) -> VersionConstraint:
 
  if len(and_constraints) > 1:
  for constraint in and_constraints:
- constraint_objects.append(parse_single_constraint(constraint))
+ constraint_objects.append(
+ parse_single_constraint(constraint, is_marker_constraint)
+ )
  else:
- constraint_objects.append(parse_single_constraint(and_constraints[0]))
+ constraint_objects.append(
+ parse_single_constraint(and_constraints[0], is_marker_constraint)
+ )
 
  if len(constraint_objects) == 1:
  constraint = constraint_objects[0]
@@ -49,7 +64,9 @@ def parse_constraint(constraints: str) -> VersionConstraint:
  return VersionUnion.of(*or_groups)
 
 
-def parse_single_constraint(constraint: str) -> VersionConstraint:
+def parse_single_constraint(
+ constraint: str, is_marker_constraint: bool = False
+) -> VersionConstraint:
  from poetry.core.constraints.version.patterns import BASIC_CONSTRAINT
  from poetry.core.constraints.version.patterns import CARET_CONSTRAINT
  from poetry.core.constraints.version.patterns import TILDE_CONSTRAINT
@@ -95,26 +112,15 @@ def parse_single_constraint(constraint: str) -> VersionConstraint:
  m = X_CONSTRAINT.match(constraint)
  if m:
  op = m.group("op")
- major = int(m.group(2))
- minor = m.group(3)
 
- if minor is not None:
- version = Version.from_parts(major, int(minor), 0)
- result: VersionConstraint = VersionRange(
- version, version.next_minor(), include_min=True
+ try:
+ return _make_x_constraint_range(
+ version=Version.parse(m.group("version")),
+ invert=op == "!=",
+ is_marker_constraint=is_marker_constraint,
  )
- else:
- if major == 0:
- result = VersionRange(max=Version.from_parts(1, 0, 0))
- else:
- version = Version.from_parts(major, 0, 0)
-
- result = VersionRange(version, version.next_major(), include_min=True)
-
- if op == "!=":
- result = VersionRange().difference(result)
-
- return result
+ except ValueError:
+ raise ValueError(f"Could not parse version constraint: {constraint}")
 
  # Basic comparator
  m = BASIC_CONSTRAINT.match(constraint)
@@ -138,10 +144,55 @@ def parse_single_constraint(constraint: str) -> VersionConstraint:
  return VersionRange(min=version)
  if op == ">=":
  return VersionRange(min=version, include_min=True)
+
+ if m.group("wildcard") is not None:
+ return _make_x_constraint_range(
+ version=version,
+ invert=op == "!=",
+ is_marker_constraint=is_marker_constraint,
+ )
+
  if op == "!=":
  return VersionUnion(VersionRange(max=version), VersionRange(min=version))
+
  return version
 
  from poetry.core.constraints.version.exceptions import ParseConstraintError
 
  raise ParseConstraintError(f"Could not parse version constraint: {constraint}")
+
+
+def _make_x_constraint_range(
+ version: Version, invert: bool = False, is_marker_constraint: bool = False
+) -> VersionConstraint:
+ from poetry.core.constraints.version.version_range import VersionRange
+
+ _is_zero_major = version.major == 0 and version.precision == 1
+
+ if version.is_postrelease():
+ _next = version.next_postrelease()
+ _is_zero_major = False
+ elif version.is_stable():
+ _next = version.next_stable()
+ elif version.is_prerelease():
+ _next = version.next_prerelease()
+ _is_zero_major = False
+ elif version.is_devrelease():
+ _next = version.next_devrelease()
+ _is_zero_major = False
+
+ if _is_zero_major:
+ result = VersionRange(max=_next.with_precision(3))
+ else:
+ _min = version.with_precision(max(version.precision, 3))
+
+ if not is_marker_constraint and not _next.is_unstable():
+ _min = _min.next_devrelease()
+
+ _max = _next.with_precision(max(version.precision, 3))
+ result = VersionRange(_min, _max, include_min=True)
+
+ if invert:
+ return VersionRange().difference(result)
+
+ return result

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

@@ -17,12 +17,12 @@
  rf"^~=\s*(?P<version>{VERSION_PATTERN})$", re.VERBOSE | re.IGNORECASE
 )
 X_CONSTRAINT = re.compile(
- r"^(?P<op>!=|==)?\s*v?(\d+)(?:\.(\d+))?(?:\.(\d+))?(?:\.[xX*])+$"
+ r"^(?P<op>!=|==)?\s*v?(?P<version>(\d+)(?:\.(\d+))?(?:\.(\d+))?)(?:\.[xX*])+$"
 )
 
 # note that we also allow technically incorrect version patterns with astrix (eg: 3.5.*)
 # as this is supported by pip and appears in metadata within python packages
 BASIC_CONSTRAINT = re.compile(
- rf"^(?P<op><>|!=|>=?|<=?|==?)?\s*(?P<version>{VERSION_PATTERN}|dev)(\.\*)?$",
+ rf"^(?P<op><>|!=|>=?|<=?|==?)?\s*(?P<version>{VERSION_PATTERN}|dev)(?P<wildcard>\.\*)?$",
  re.VERBOSE | re.IGNORECASE,
 )

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

@@ -21,22 +21,9 @@ def __init__(
  max: Version | None = None,
  include_min: bool = False,
  include_max: bool = False,
- always_include_max_prerelease: bool = False,
  ) -> None:
- full_max = max
- if (
- not always_include_max_prerelease
- and not include_max
- and full_max is not None
- and full_max.is_stable()
- and not full_max.is_postrelease()
- and (min is None or min.is_stable() or min.release != full_max.release)
- ):
- full_max = full_max.first_prerelease()
-
- self._min = min
  self._max = max
- self._full_max = full_max
+ self._min = min
  self._include_min = include_min
  self._include_max = include_max
 
@@ -48,10 +35,6 @@ def min(self) -> Version | None:
  def max(self) -> Version | None:
  return self._max
 
- @property
- def full_max(self) -> Version | None:
- return self._full_max
-
  @property
  def include_min(self) -> bool:
  return self._include_min
@@ -71,27 +54,35 @@ def is_simple(self) -> bool:
 
  def allows(self, other: Version) -> bool:
  if self._min is not None:
- if other < self._min:
+ _this, _other = self.allowed_min, other
+
+ assert _this is not None
+
+ if not _this.is_postrelease() and _other.is_postrelease():
+ _other = _other.without_postrelease()
+
+ if not _this.is_local() and _other.is_local():
+ _other = other.without_local()
+
+ if _other < _this:
  return False
 
- if not self._include_min and other == self._min:
+ if not self._include_min and (_other == self._min or _other == _this):
  return False
 
- if self.full_max is not None:
- _this, _other = self.full_max, other
+ if self.max is not None:
+ _this, _other = self.allowed_max, other
+
+ assert _this is not None
 
  if not _this.is_local() and _other.is_local():
  # allow weak equality to allow `3.0.0+local.1` for `<=3.0.0`
  _other = _other.without_local()
 
- if not _this.is_postrelease() and _other.is_postrelease():
- # allow weak equality to allow `3.0.0-1` for `<=3.0.0`
- _other = _other.without_postrelease()
-
  if _other > _this:
  return False
 
- if not self._include_max and _other == _this:
+ if not self._include_max and (_other == self._max or _other == _this):
  return False
 
  return True

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

@@ -21,11 +21,6 @@ def min(self) -> Version | None:
  def max(self) -> Version | None:
  raise NotImplementedError()
 
- @property
- @abstractmethod
- def full_max(self) -> Version | None:
- raise NotImplementedError()
-
  @property
  @abstractmethod
  def include_min(self) -> bool:
@@ -36,44 +31,78 @@ def include_min(self) -> bool:
  def include_max(self) -> bool:
  raise NotImplementedError()
 
- def allows_lower(self, other: VersionRangeConstraint) -> bool:
+ @property
+ def allowed_min(self) -> Version | None:
  if self.min is None:
- return other.min is not None
+ return None
+
+ if not self.include_min or self.min.is_unstable():
+ return self.min
+
+ if self.min == self.max and (self.include_min or self.include_max):
+ # this is an equality range
+ return self.min
 
- if other.min is None:
+ return self.min
+
+ @property
+ def allowed_max(self) -> Version | None:
+ if self.max is None:
+ return None
+
+ if self.include_max or self.max.is_unstable():
+ return self.max
+
+ if self.min == self.max and (self.include_min or self.include_max):
+ # this is an equality range
+ return self.max
+
+ return self.max.next_devrelease()
+
+ def allows_lower(self, other: VersionRangeConstraint) -> bool:
+ _this, _other = self.allowed_min, other.allowed_min
+
+ if _this is None:
+ return _other is not None
+
+ if _other is None:
  return False
 
- if self.min < other.min:
+ if _this < _other:
  return True
 
- if self.min > other.min:
+ if _this > _other:
  return False
 
  return self.include_min and not other.include_min
 
  def allows_higher(self, other: VersionRangeConstraint) -> bool:
- if self.full_max is None:
- return other.max is not None
+ _this, _other = self.allowed_max, other.allowed_max
 
- if other.full_max is None:
+ if _this is None:
+ return _other is not None
+
+ if _other is None:
  return False
 
- if self.full_max < other.full_max:
+ if _this < _other:
  return False
 
- if self.full_max > other.full_max:
+ if _this > _other:
  return True
 
  return self.include_max and not other.include_max
 
  def is_strictly_lower(self, other: VersionRangeConstraint) -> bool:
- if self.full_max is None or other.min is None:
+ _this, _other = self.allowed_max, other.allowed_min
+
+ if _this is None or _other is None:
  return False
 
- if self.full_max < other.min:
+ if _this < _other:
  return True
 
- if self.full_max > other.min:
+ if _this > _other:
  return False
 
  return not self.include_max or not other.include_min