Fix CI: staticmethod callable on <3.10, coverage gaps

Author: notatallshaw

src/packaging/specifiers.py

@@ -70,9 +70,6 @@ def __init__(self, version: Version) -> None:
         self.version = version
         self._trimmed_release = _trim_release(version.release)
 
-    def __repr__(self) -> str:
-        return f"_PostExcludeBound({self.version!r})"
-
     def _is_post_family(self, other: Version) -> bool:
         """Is ``other`` the same version as self.version, or a post-release of it?
 
@@ -95,10 +92,9 @@ def __eq__(self, other: object) -> bool:
     def __lt__(self, other: object) -> bool:
         if isinstance(other, _PostExcludeBound):
             return self.version < other.version
-        if isinstance(other, Version):
-            # self < other iff other is NOT in the post-family and other > V
-            return not self._is_post_family(other) and self.version < other
-        return NotImplemented
+        assert isinstance(other, Version)
+        # self < other iff other is NOT in the post-family and other > V
+        return not self._is_post_family(other) and self.version < other
 
     def __hash__(self) -> int:
         return hash(self.version)
@@ -1335,15 +1331,7 @@ def _get_intervals(self) -> list[_SpecifierInterval]:
         list otherwise. ``===`` specs are modeled as full range (no
         constraint).
         """
-        if self._intervals is not None:
-            return self._intervals
-        if self._is_unsatisfiable is True:
-            return []
-
         specs = self._specs
-        if not specs:
-            self._intervals = _FULL_RANGE
-            return _FULL_RANGE
 
         # Intersect specs' intervals, with early exit on empty intersection.
         result: list[_SpecifierInterval] | None = None

tests/test_specifiers.py

@@ -2131,6 +2131,91 @@ def test_arbitrary_equality_is_intersection_preserving(
         assert versions1 & versions2 == combined_versions
 
 
+def _version_family(base: str) -> list[str]:
+    """All PEP 440 suffixes and combinations around a base version."""
+    return [
+        f"{base}.dev0",
+        f"{base}.dev1",
+        f"{base}.dev0+local",
+        f"{base}a0",
+        f"{base}a0.post0.dev0",
+        f"{base}a0.post0",
+        f"{base}a1.dev1",
+        f"{base}a1.dev1+local",
+        f"{base}a1",
+        f"{base}a1+local",
+        f"{base}b1",
+        f"{base}b2.post1.dev1",
+        f"{base}b2.post1",
+        f"{base}rc1.dev1",
+        f"{base}rc1",
+        f"{base}rc2",
+        base,
+        f"{base}.0",
+        f"{base}.post0.dev0",
+        f"{base}.post0",
+        f"{base}.post1",
+        f"{base}.post1+local",
+        f"{base}+local",
+        f"{base}+local1",
+        f"{base}+local2",
+        f"{base}+1",
+        f"{base}+1.local",
+        f"{base}.1.dev1",
+        f"{base}.1a1",
+        f"{base}.1",
+        f"{base}.1+local",
+        f"{base}.1.post1",
+    ]
+
+
+_SAMPLE_BASES: list[str] = [
+    "0",
+    "0.0",
+    "1.0",
+    "1.1",
+    "1.2",
+    "2.0",
+    "2.1",
+    "3.0",
+    "1.0.1",
+    "1.4.2",
+    "2.0.0",
+    "3.10.2",
+    "3.8",
+    "3.9",
+    "3.10",
+    "3.11",
+    "3.12",
+    "3.13",
+    "3.14",
+    "10.0",
+    "100.0",
+    "1!0.0",
+    "1!1.0",
+    "1!2.0",
+]
+
+
+def _build_sample_versions(
+    bases: list[str], family_fn: Callable[[str], list[str]]
+) -> list[Version]:
+    """version_family x bases, deduplicated."""
+    version_strs: list[str] = []
+    for base in bases:
+        version_strs.extend(family_fn(base))
+    seen: set[str] = set()
+    unique: list[str] = []
+    for v in version_strs:
+        if v not in seen:
+            seen.add(v)
+            unique.append(v)
+    return [Version(v) for v in unique]
+
+
+_SAMPLE_VERSIONS: list[Version] = _build_sample_versions(_SAMPLE_BASES, _version_family)
+
+
 class TestIsUnsatisfiable:
     """Tests for SpecifierSet.is_unsatisfiable().
 
@@ -2139,91 +2224,6 @@ class TestIsUnsatisfiable:
     - SATISFIABLE: not falsely reported as unsatisfiable.
     """
 
-    @staticmethod
-    def _version_family(base: str) -> list[str]:
-        """All PEP 440 suffixes and combinations around a base version."""
-        return [
-            f"{base}.dev0",
-            f"{base}.dev1",
-            f"{base}.dev0+local",
-            f"{base}a0",
-            f"{base}a0.post0.dev0",
-            f"{base}a0.post0",
-            f"{base}a1.dev1",
-            f"{base}a1.dev1+local",
-            f"{base}a1",
-            f"{base}a1+local",
-            f"{base}b1",
-            f"{base}b2.post1.dev1",
-            f"{base}b2.post1",
-            f"{base}rc1.dev1",
-            f"{base}rc1",
-            f"{base}rc2",
-            base,
-            f"{base}.0",
-            f"{base}.post0.dev0",
-            f"{base}.post0",
-            f"{base}.post1",
-            f"{base}.post1+local",
-            f"{base}+local",
-            f"{base}+local1",
-            f"{base}+local2",
-            f"{base}+1",
-            f"{base}+1.local",
-            f"{base}.1.dev1",
-            f"{base}.1a1",
-            f"{base}.1",
-            f"{base}.1+local",
-            f"{base}.1.post1",
-        ]
-
-    SAMPLE_BASES: typing.ClassVar[list[str]] = [
-        "0",
-        "0.0",
-        "1.0",
-        "1.1",
-        "1.2",
-        "2.0",
-        "2.1",
-        "3.0",
-        "1.0.1",
-        "1.4.2",
-        "2.0.0",
-        "3.10.2",
-        "3.8",
-        "3.9",
-        "3.10",
-        "3.11",
-        "3.12",
-        "3.13",
-        "3.14",
-        "10.0",
-        "100.0",
-        "1!0.0",
-        "1!1.0",
-        "1!2.0",
-    ]
-
-    @staticmethod
-    def _build_sample_versions(
-        bases: list[str], family_fn: Callable[[str], list[str]]
-    ) -> list[Version]:
-        """version_family x bases, deduplicated."""
-        version_strs: list[str] = []
-        for base in bases:
-            version_strs.extend(family_fn(base))
-        seen: set[str] = set()
-        unique: list[str] = []
-        for v in version_strs:
-            if v not in seen:
-                seen.add(v)
-                unique.append(v)
-        return [Version(v) for v in unique]
-
-    SAMPLE_VERSIONS: typing.ClassVar[list[Version]] = _build_sample_versions(
-        SAMPLE_BASES, _version_family
-    )
-
     UNSATISFIABLE: typing.ClassVar[list[str]] = [
         # Crossed bounds
         ">=2.0,<1.0",
@@ -2344,7 +2344,7 @@ def test_unsatisfiable(self, spec_str: str) -> None:
         """Unsatisfiable specs must be detected, and filter must return empty."""
         ss = SpecifierSet(spec_str)
         assert ss.is_unsatisfiable(), f"Expected unsatisfiable: {spec_str!r}"
-        result = list(ss.filter(self.SAMPLE_VERSIONS, prereleases=True))
+        result = list(ss.filter(_SAMPLE_VERSIONS, prereleases=True))
         assert result == [], (
             f"is_unsatisfiable() but filter matched: "
             f"{[str(v) for v in result]} for {spec_str!r}"
@@ -2375,3 +2375,23 @@ def test_and_preserves_unsatisfiable(self) -> None:
     def test_and_satisfiable(self) -> None:
         combined = SpecifierSet(">=1.0") & SpecifierSet("<2.0")
         assert not combined.is_unsatisfiable()
+
+    def test_and_reuses_interval_cache(self) -> None:
+        """Specifier interval cache is reused when specs are shared via &."""
+        s1 = SpecifierSet(">=1.0")
+        s2 = SpecifierSet("<2.0")
+        # Compute intervals on the original sets first.
+        assert not s1.is_unsatisfiable()
+        assert not s2.is_unsatisfiable()
+        # __and__ reuses the same Specifier objects, so _to_intervals()
+        # hits the cache on those Specifier instances.
+        combined = s1 & s2
+        assert not combined.is_unsatisfiable()
+
+    def test_interval_bounds_are_hashable(self) -> None:
+        """Interval bounds (including _PostExcludeBound sentinels) are hashable."""
+        spec = Specifier(">1.0")
+        intervals = spec._to_intervals()
+        for lower, upper in intervals:
+            hash(lower)
+            hash(upper)