Edge case tests, <V.postN interval fix

Author: notatallshaw

PR.md

@@ -0,0 +1,24 @@
+Before merging I wanted to do another pass of finding edge cases, and I found a particularly problematic one. `<V.postN` (where V is not a pre-release) excludes pre-releases sharing V's base release via `_compare_less_than`. The interval model represents `<1.0.post1` as `(-inf, 1.0.post1.dev0)`, which is correct for non-pre-release versions but too wide for pre-releases: it includes `1.0.dev0`, `1.0a1`, `1.0.post0.dev0`, etc. that `_compare_less_than` actually rejects.
+
+This caused my current approach to miss cases like `==1.0.dev0,<1.0.post1`. As `1.0.dev0` falls inside the interval `(-inf, 1.0.post1.dev0)` so the intersection with `==1.0.dev0` looks non-empty. But `filter()` returns nothing because `_compare_less_than` rejects `1.0.dev0` (it is a pre-release of base `1.0`, same base as `1.0.post1`).
+
+Or another case `>=1.0.dev0,<1.0.post1,!=1.0,!=1.0.post0`. After `!=` removes the two non-pre-release versions (`1.0` and `1.0.post0`), only pre-releases remain. All of them are excluded by `<1.0.post1`, but the interval still looks non-empty.
+
+The non-pre-release versions that `<1.0.post1` accepts (`1.0`, `1.0.post0`) are interleaved with pre-releases it rejects (`1.0.dev0`, `1.0.post0.dev0`) on the version number line:
+```
+1.0.dev0 < 1.0a1 < ... < 1.0 < 1.0.post0.dev0 < 1.0.post0 < 1.0.post1.dev0
+^^^^^^^^   ^^^^^         ^^^   ^^^^^^^^^^^^^^^   ^^^^^^^^^^
+rejected   rejected       OK   rejected          OK
+```
+
+No single interval boundary can separate them because they alternate.
+
+One option is to split `<1.0.post1` into separate intervals for each non-pre-release "island":
+
+```
+(-inf, 1.0.dev0)  [1.0, AFTER_LOCALS(1.0)]  [1.0.post0, AFTER_LOCALS(1.0.post0)]
+```
+
+This is correct but produces N+2 intervals for `<V.postN`, and also requires fixing `_BoundaryVersion` comparison for `AFTER_POSTS` vs `AFTER_LOCALS` with different base versions.
+
+Instead I went with keeping the single interval `(-inf, 1.0.post1.dev0)` but tagging the upper bound with the excluded base release. During intersection, `_interval_is_empty` uses this tag to check whether any non-pre-release version of the base survives in the interval. The check derives the relevant post number from the lower bound in O(1) instead of iterating. Concretely: `_UpperBound` gets an `_excl_base` field set by `<V.postN`, `_interval_is_empty` checks if the interval contains a surviving non-pre-release version when the tag is present, and `_intersect_intervals` propagates the tag through `with_excl()`.

src/packaging/specifiers.py

@@ -167,11 +167,27 @@ class _UpperBound:
     ends earlier.
     """
 
-    __slots__ = ("inclusive", "version")
+    __slots__ = ("_excl_base", "inclusive", "version")
 
-    def __init__(self, version: _VersionOrBoundary, inclusive: bool) -> None:
+    def __init__(
+        self,
+        version: _VersionOrBoundary,
+        inclusive: bool,
+        excl_base: Version | None = None,
+    ) -> None:
         self.version = version
         self.inclusive = inclusive
+        # Set by ``<V.postN`` (non-prerelease) to record that
+        # ``_compare_less_than`` excludes pre-releases of this base
+        # release.  Used by ``_interval_is_empty`` to discard intervals
+        # containing only excluded pre-releases.
+        self._excl_base = excl_base
+
+    def with_excl(self, other: _UpperBound) -> _UpperBound:
+        """Return a copy carrying *other*'s exclusion metadata, if needed."""
+        if self._excl_base is not None or other._excl_base is None:
+            return self
+        return _UpperBound(self.version, self.inclusive, other._excl_base)
 
     def __eq__(self, other: object) -> bool:
         if not isinstance(other, _UpperBound):
@@ -212,6 +228,64 @@ def _interval_is_empty(lower: _LowerBound, upper: _UpperBound) -> bool:
     """Is the interval [lower, upper] empty?"""
     if lower.version is None or upper.version is None:
         return False
+    if lower.version == upper.version:
+        return not (lower.inclusive and upper.inclusive)
+    if lower.version > upper.version:
+        return True
+    # ``<V.postN`` excludes pre-releases sharing V's base release, but
+    # the interval model cannot split those out (pre-releases and
+    # non-pre-releases are interleaved on the number line).  When the
+    # upper bound carries exclusion metadata and the interval is within
+    # the base's range, check whether any non-pre-release version of
+    # that base (the final release and each post-release below the
+    # bound) still falls inside.
+    if upper._excl_base is not None:
+        base = upper._excl_base
+        if not lower.version < base.__replace__(dev=0, local=None):
+            return not _has_surviving_version(lower, upper, base)
+    return False
+
+
+def _has_surviving_version(
+    lower: _LowerBound, upper: _UpperBound, base: Version
+) -> bool:
+    """Is there a non-pre-release version of *base* inside [lower, upper]?
+
+    The non-pre-release versions are ``base, base.post0, base.post1, ...``.
+    They are sorted, so we only need to find the first one at or above
+    *lower* and check whether it is also at or below *upper*.
+    """
+    if _interval_contains(lower, upper, base):
+        return True
+    # base is below lower.  Derive which post-release is nearest.
+    v = lower.version
+    if isinstance(v, _BoundaryVersion):
+        # AFTER_LOCALS(base.postK) -> first candidate is post(K+1).
+        k = (v.version.post + 1) if v.version.post is not None else 0
+    elif isinstance(v, Version) and v.post is not None:
+        k = v.post
+    else:
+        k = 0
+    candidate = base.__replace__(post=k, local=None)
+    if _interval_contains(lower, upper, candidate):
+        return True
+    # If candidate was at the exclusive lower bound, try the next one.
+    next_candidate = base.__replace__(post=k + 1, local=None)
+    return _interval_contains(lower, upper, next_candidate)
+
+
+def _interval_contains(
+    lower: _LowerBound, upper: _UpperBound, version: Version
+) -> bool:
+    """Is *version* inside the interval [lower, upper]?"""
+    point_lo = _LowerBound(version, True)
+    point_hi = _UpperBound(version, True)
+    # version >= lower  AND  version <= upper
+    return not (_bounds_empty(lower, point_hi) or _bounds_empty(point_lo, upper))
+
+
+def _bounds_empty(lower: _LowerBound, upper: _UpperBound) -> bool:
+    """Basic emptiness check (no survivor logic, avoids recursion)."""
     if lower.version == upper.version:
         return not (lower.inclusive and upper.inclusive)
     return lower.version > upper.version
@@ -230,6 +304,8 @@ def _intersect_intervals(
 
         lower = max(left_lower, right_lower)
         upper = min(left_upper, right_upper)
+        # Propagate <V.postN exclusion metadata to the winning bound.
+        upper = upper.with_excl(left_upper).with_excl(right_upper)
 
         if not _interval_is_empty(lower, upper):
             result.append((lower, upper))
@@ -343,6 +419,18 @@ def _base_dev0(version: Version) -> Version:
     return Version.from_parts(epoch=version.epoch, release=version.release, dev=0)
 
 
+def _base_version(version: Version) -> Version:
+    """Strip pre/post/dev/local, keeping only epoch and release."""
+    if (
+        version.pre is None
+        and version.post is None
+        and version.dev is None
+        and version.local is None
+    ):
+        return version
+    return version.__replace__(pre=None, post=None, dev=None, local=None)
+
+
 class InvalidSpecifier(ValueError):
     """
     Raised when attempting to create a :class:`Specifier` with a specifier
@@ -674,12 +762,17 @@ def _standard_intervals(self, op: str, ver_str: str) -> list[_SpecifierInterval]
 
         if op == "<":
             # <V excludes prereleases of V when V is not a prerelease.
-            # V.dev0 is the earliest prerelease of V regardless of
-            # whether V is a final, post, or pre-of-pre release.
+            # V.dev0 is the earliest prerelease of V (final, post, etc.).
             bound = v if v.is_prerelease else v.__replace__(dev=0, local=None)
             if bound <= _MIN_VERSION:
                 return []
-            return [(_NEG_INF, _UpperBound(bound, False))]
+            # For <V.postN, tag the bound with the base release so
+            # _interval_is_empty can detect intervals containing only
+            # excluded pre-releases.
+            excl_base = (
+                _base_version(v) if not v.is_prerelease and v.post is not None else None
+            )
+            return [(_NEG_INF, _UpperBound(bound, False, excl_base))]
 
         if op == "==":
             # ==V (no local) matches V+local; ==V+local matches exactly.

tests/test_specifiers.py

@@ -2320,6 +2320,7 @@ def _build_sample_versions(
     "not-a-version",
     "1.01",
     "1.0-1",
+    "v1.0",
 ]
 
 
@@ -2412,6 +2413,37 @@ class TestIsUnsatisfiable:
         "===1.0,!=1.0",
         "===1.0,>1.0",
         "===1.01,==1.0",
+        # Non-overlapping wildcards (adjacent boundaries, upper exclusive)
+        "==1.0.*,==1.1.*",
+        "==1.*,==2.*",
+        # Conflicting compatible releases
+        "~=1.0,~=2.0",
+        "~=1.4.2,~=1.5.0",
+        # Local excluded by non-local != (locals ignored per spec)
+        "==1.0+local1,!=1.0",
+        # Wildcard exhaustion (single and multiple)
+        ">=1.0,<1.1,!=1.0.*",
+        "!=1.*,!=2.*,>=1.0,<3.0",
+        "~=1.0,!=1.*",
+        # >V excludes posts of pre-release V
+        ">1.0a1,<1.0a1.post2",
+        # Adjacent dev of zero: no version between devN and dev(N+1)
+        ">0.dev0,<0.dev1",
+        # Compatible release with pre/dev suffix vs <base
+        "~=1.0a1,<1.0",
+        "~=1.0.dev5,<1.0",
+        # Between post dev and post: >V.postK.devN leaves no room
+        ">1.0.post0.dev0,<1.0.post0",
+        # Deep release crossing compatible release boundary
+        "~=1.2.3.4.5,>=1.2.3.5",
+        # <V.postN excludes pre-releases with same base release
+        "==1.0.dev0,<1.0.post1",
+        "==1.0a1,<1.0.post0",
+        "==1.0rc1,<1.0.post0",
+        "==1.0.post0.dev0,<1.0.post1",
+        ">=1.0.dev0,<1.0.post1,!=1.0,!=1.0.post0",
+        # Different base but release is above the <V.postN bound
+        "==1.1.dev0,<1.0.post1",
     ]
 
     # Specifier sets that must NOT be detected as unsatisfiable.
@@ -2501,6 +2533,35 @@ class TestIsUnsatisfiable:
         "===1.01,>=1.0",
         # === with unnormalized version that parses to a matching version
         "===1.01,==1.1",
+        # === case-insensitive identity
+        "===FOOBAR,===foobar",
+        "===FooBar,===FOOBAR",
+        # Final version sits below its own post-releases
+        ">=1.0,<1.0.post0",
+        ">=1.0,<1.0.post1",
+        # Lower bound below base.dev0: other-base versions survive
+        ">=0,<1.0.post0,!=1.0",
+        # === with normalization variants
+        "===v1.0,>=1.0",
+        "===1.0-1,>=1.0",
+        # Zero-padding equivalence
+        "==1.0,==1.0.0",
+        # Compatible release with post suffix
+        "~=1.0.post1,>=1.0",
+        # Range below post dev
+        ">=1.0,<1.0.post0.dev1",
+        # Post of alpha satisfies (1.0a1.post0 exists)
+        ">=1.0a1,<1.0a2,!=1.0a1",
+        # Alpha-to-beta range has room (1.0a2.dev0, etc.)
+        ">1.0a1,<1.0b1",
+        # Overlapping compatible releases
+        "~=1.0,~=1.1",
+        "~=1.0,~=1.0.1",
+        # Partial wildcard exclusion doesn't exhaust range
+        ">=1.0,<2.0,!=1.0.*,!=1.1.*",
+        # ~= with pre/dev lower bound still accepts the final release
+        "~=1.0.dev0,<1.0.post0",
+        "~=1.0a1,<1.0.post0",
     ]
 
     @pytest.mark.parametrize("spec_str", UNSATISFIABLE)