Fix CI: staticmethod callable on <3.10, coverage gaps

Author: notatallshaw

src/packaging/specifiers.py

@@ -81,10 +81,6 @@ def __init__(self, version: Version, kind: int) -> None:
         self._kind = kind
         self._trimmed_release = _trim_release(version.release)
 
-    def __repr__(self) -> str:
-        label = "AFTER_LOCALS" if self._kind == _AFTER_LOCALS else "AFTER_POSTS"
-        return f"_ExclusionBound({self.version!r}, {label})"
-
     def _is_family(self, other: Version) -> bool:
         """Is ``other`` a version that this sentinel sorts above?"""
         v = self.version
@@ -110,10 +106,9 @@ def __lt__(self, other: object) -> bool:
             if self.version != other.version:
                 return self.version < other.version
             return self._kind < other._kind
-        if isinstance(other, Version):
-            # self < other iff other is NOT in the family and other > V
-            return not self._is_family(other) and self.version < other
-        return NotImplemented
+        assert isinstance(other, Version)
+        # self < other iff other is NOT in the family and other > V
+        return not self._is_family(other) and self.version < other
 
     def __hash__(self) -> int:
         return hash((self.version, self._kind))
@@ -1120,13 +1115,8 @@ def _get_intervals(self) -> list[_SpecifierInterval] | None:
         """
         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, bailing out if we encounter ===
         # (string matching, not version comparison) or if the intersection

tests/test_specifiers.py

@@ -2137,6 +2137,96 @@ 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.
+
+    Covers dev, alpha/beta/rc (with dev-of-pre and post-of-pre),
+    final, post (with dev-of-post), local variants (string, integer,
+    multi-segment, distinct labels), and a patch sub-release family.
+    """
+    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() and interval-based filtering.
 
@@ -2148,98 +2238,6 @@ class TestIsUnsatisfiable:
       sample of versions (version_family x SAMPLE_BASES).
     """
 
-    @staticmethod
-    def _version_family(base: str) -> list[str]:
-        """All PEP 440 suffixes and combinations around a base version.
-
-        Covers dev, alpha/beta/rc (with dev-of-pre and post-of-pre),
-        final, post (with dev-of-post), local variants (string, integer,
-        multi-segment, distinct labels), and a patch sub-release family.
-        """
-        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",
-        ]
-
-    # Base versions: zero, MAJOR.MINOR, MAJOR.MINOR.PATCH, real-world,
-    # large numbers, and epoch versions.
-    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
-    )
-
     # Specifier sets that must be detected as unsatisfiable.
     UNSATISFIABLE: typing.ClassVar[list[str]] = [
         # Crossed bounds
@@ -2366,7 +2364,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}"
@@ -2384,9 +2382,9 @@ def test_filter_matches_per_spec_filter(self, spec_str: str) -> None:
         if not spec_str:
             return
         ss = SpecifierSet(spec_str)
-        interval_result = set(ss.filter(self.SAMPLE_VERSIONS, prereleases=True))
+        interval_result = set(ss.filter(_SAMPLE_VERSIONS, prereleases=True))
         manual_result = set()
-        for v in self.SAMPLE_VERSIONS:
+        for v in _SAMPLE_VERSIONS:
             if all(spec.contains(v, prereleases=True) for spec in ss._specs):
                 manual_result.add(v)
         assert interval_result == manual_result, (
@@ -2414,3 +2412,25 @@ 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 _ExclusionBound sentinels) are hashable."""
+        spec = Specifier(">1.0")
+        intervals = spec._to_intervals()
+        # Bounds are tuples of (version_or_sentinel, inclusive); hashing the
+        # interval tuple exercises _ExclusionBound.__hash__.
+        for lower, upper in intervals:
+            hash(lower)
+            hash(upper)