Release v2025.5.0

Author: sco1

.bumper.toml

@@ -1,5 +1,6 @@
 [tool.bumper]
-current_version = "0.1.0"
+current_version = "2025.5.0"
+versioning_type = "calver"
 
 [[tool.bumper.files]]
 file = "./pyproject.toml"

README.md

@@ -11,13 +11,13 @@ Add this to your `.pre-commit-config.yaml`
 
 ```yaml
 -   repo: https://github.com/sco1/pre-commit-python-eol
-    rev: v0.1.0
+    rev: v2025.5.0
     hooks:
     - id: check-eol
 ```
 
 ## Hooks
-**NOTE:** Only pyproject.toml is currently inspected. It is assumed that project metadata is supported per [PyPA Guidance](https://packaging.python.org/en/latest/guides/writing-pyproject-toml/)
+**NOTE:** Only pyproject.toml is currently inspected. It is assumed that project metadata is specified per [PyPA Guidance](https://packaging.python.org/en/latest/guides/writing-pyproject-toml/)
 
 ### `check-eol`
 Check `requires-python` against the current Python lifecycle & fail if an EOL version is included.

cached_release_cycle.json

@@ -1,9 +1,17 @@
 {
-  "3.14": {
+  "3.15": {
     "branch": "main",
-    "pep": 745,
+    "pep": 790,
     "status": "feature",
-    "first_release": "2025-10-01",
+    "first_release": "2026-10-01",
+    "end_of_life": "2031-10",
+    "release_manager": "Hugo van Kemenade"
+  },
+  "3.14": {
+    "branch": "3.14",
+    "pep": 745,
+    "status": "prerelease",
+    "first_release": "2025-10-07",
     "end_of_life": "2030-10",
     "release_manager": "Hugo van Kemenade"
   },

pre_commit_python_eol/check_eol.py

@@ -9,6 +9,7 @@
 from collections import abc
 from dataclasses import dataclass
 from enum import StrEnum
+from operator import attrgetter
 from pathlib import Path
 
 from packaging import specifiers, version
@@ -58,25 +59,12 @@ def _parse_eol_date(date_str: str) -> dt.date:
 
 
 @dataclass(frozen=True)
-class PythonRelease:
-    """
-    Represent the relevant metadata information for a Python release.
-
-    For the purposes of this tool, instances of `PythonRelease` are considered equal if their
-    respective `python_ver` attributes are equal.
-    """
-
+class PythonRelease:  # noqa: D101
     python_ver: version.Version
     status: ReleasePhase
     end_of_life: dt.date
 
-    def __eq__(self, other: object) -> bool:
-        if not isinstance(other, PythonRelease):
-            return NotImplemented
-
-        return self.python_ver == other.python_ver
-
-    def __str__(self) -> str:
+    def __str__(self) -> str:  # pragma: no cover
         return f"Python {self.python_ver} - Status: {self.status}, EOL: {self.end_of_life}"
 
     @classmethod
@@ -94,15 +82,25 @@ def from_json(cls, ver: str, metadata: dict[str, t.Any]) -> PythonRelease:
         )
 
 
-def _get_cached_release_cycle(cache_json: Path = CACHED_RELEASE_CYCLE) -> set[PythonRelease]:
-    """Parse the locally cached Python release cycle into `PythonRelease` instance(s)."""
+def _get_cached_release_cycle(cache_json: Path) -> list[PythonRelease]:
+    """
+    Parse the locally cached Python release cycle into `PythonRelease` instance(s).
+
+    Results are sorted by Python version in descending order.
+    """
     with cache_json.open("r", encoding="utf-8") as f:
         contents = json.load(f)
 
-    return {PythonRelease.from_json(v, m) for v, m in contents.items()}
+    # The sorting is probably unnecessary since the JSON should already be sorted, but going to
+    # retain since it's expected downstream
+    return sorted(
+        (PythonRelease.from_json(v, m) for v, m in contents.items()),
+        key=attrgetter("python_ver"),
+        reverse=True,
+    )
 
 
-def check_python_support(toml_file: Path) -> None:
+def check_python_support(toml_file: Path, cache_json: Path = CACHED_RELEASE_CYCLE) -> None:
     with toml_file.open("rb") as f:
         contents = tomllib.load(f)
 
@@ -111,8 +109,24 @@ def check_python_support(toml_file: Path) -> None:
         raise RequiresPythonNotFoundError
 
     package_spec = specifiers.SpecifierSet(requires_python)
+    release_cycle = _get_cached_release_cycle(cache_json)
+    utc_today = dt.datetime.now(dt.timezone.utc).date()
+
+    eol_supported = []
+    for r in release_cycle:
+        if r.python_ver in package_spec:
+            if r.status == ReleasePhase.EOL:
+                eol_supported.append(r)
+                continue
+
+            if r.end_of_life <= utc_today:
+                eol_supported.append(r)
+                continue
 
-    raise NotImplementedError
+    if eol_supported:
+        eol_supported.sort(key=attrgetter("python_ver"))  # Sort ascending for error msg generation
+        joined_vers = ", ".join(str(r.python_ver) for r in eol_supported)
+        raise EOLPythonError(f"EOL Python support found: {joined_vers}")
 
 
 def main(argv: abc.Sequence[str] | None = None) -> int:  # noqa: D103
@@ -124,8 +138,8 @@ def main(argv: abc.Sequence[str] | None = None) -> int:  # noqa: D103
     for file in args.filenames:
         try:
             check_python_support(file)
-        except EOLPythonError:
-            print(f"{file}: Fail.")
+        except EOLPythonError as e:
+            print(f"{file}: {e}")
             ec = 1
         except RequiresPythonNotFoundError:
             print(f"{file} 'requires-python' could not be located, or it is empty.")

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pre-commit-python-eol"
-version = "0.1.0"
+version = "2025.5.0"
 description = "A pre-commit hook for enforcing supported Python EOL"
 license = "MIT"
 license-files = ["LICENSE"]
@@ -22,7 +22,7 @@ classifiers = [
 
 requires-python = ">=3.11"
 dependencies = [
-    "packaging~=24.2",
+    "packaging~=25.0",
 ]
 
 [project.urls]
@@ -47,7 +47,8 @@ dev-dependencies = [
     "pytest-cov~=6.0",
     "pytest-randomly~=3.16",
     "ruff~=0.9",
-    "sco1-bumper~=1.0",
+    "sco1-bumper~=2.0",
+    "time-machine~=2.16",
     "tox~=4.23",
     "tox-uv~=1.17",
 ]

tests/__init__.py

@@ -0,0 +1,215 @@
+import datetime as dt
+from pathlib import Path
+
+import pytest
+import time_machine
+from packaging import version
+
+from pre_commit_python_eol.check_eol import (
+    EOLPythonError,
+    PythonRelease,
+    ReleasePhase,
+    RequiresPythonNotFoundError,
+    _get_cached_release_cycle,
+    _parse_eol_date,
+    check_python_support,
+)
+
+EOL_DATE_PARSE_CASES = (
+    ("2025-01-01", dt.date(year=2025, month=1, day=1)),
+    ("2025-01", dt.date(year=2025, month=1, day=1)),
+)
+
+
+@pytest.mark.parametrize(("date_str", "truth_date"), EOL_DATE_PARSE_CASES)
+def test_parse_eol_date(date_str: str, truth_date: dt.date) -> None:
+    assert _parse_eol_date(date_str) == truth_date
+
+
+def test_parse_eol_date_unknown_fmt_raises() -> None:
+    with pytest.raises(ValueError, match="Unknown date format"):
+        _ = _parse_eol_date("123456")
+
+
+def test_python_release_from_json() -> None:
+    sample_metadata = {
+        "branch": "3.14",
+        "pep": 745,
+        "status": "prerelease",
+        "first_release": "2025-10-07",
+        "end_of_life": "2030-10",
+        "release_manager": "Hugo van Kemenade",
+    }
+
+    truth_rel = PythonRelease(
+        python_ver=version.Version("3.14"),
+        status=ReleasePhase.PRERELEASE,
+        end_of_life=dt.date(year=2030, month=10, day=1),
+    )
+
+    assert PythonRelease.from_json("3.14", metadata=sample_metadata) == truth_rel
+
+
+#  Intentionally out of expected order so sorting can be checked
+SAMPLE_JSON = """\
+{
+  "3.14": {
+    "branch": "3.14",
+    "pep": 745,
+    "status": "prerelease",
+    "first_release": "2025-10-07",
+    "end_of_life": "2030-10",
+    "release_manager": "Hugo van Kemenade"
+  },
+  "3.15": {
+    "branch": "main",
+    "pep": 790,
+    "status": "feature",
+    "first_release": "2026-10-01",
+    "end_of_life": "2031-10",
+    "release_manager": "Hugo van Kemenade"
+  }
+}
+"""
+
+TRUTH_RELEASE_CYCLE = [
+    PythonRelease(
+        python_ver=version.Version("3.15"),
+        status=ReleasePhase.FEATURE,
+        end_of_life=dt.date(year=2031, month=10, day=1),
+    ),
+    PythonRelease(
+        python_ver=version.Version("3.14"),
+        status=ReleasePhase.PRERELEASE,
+        end_of_life=dt.date(year=2030, month=10, day=1),
+    ),
+]
+
+
+def test_get_cached_release_cycle(tmp_path: Path) -> None:
+    json_file = tmp_path / "cache.json"
+    json_file.write_text(SAMPLE_JSON)
+
+    release_cycle = _get_cached_release_cycle(cache_json=json_file)
+    assert release_cycle == TRUTH_RELEASE_CYCLE
+
+
+RELEASE_CACHE_WITH_EOL = """\
+{
+  "3.14": {
+    "branch": "3.14",
+    "pep": 745,
+    "status": "prerelease",
+    "first_release": "2025-10-07",
+    "end_of_life": "2030-10",
+    "release_manager": "Hugo van Kemenade"
+  },
+  "3.8": {
+    "branch": "3.8",
+    "pep": 569,
+    "status": "end-of-life",
+    "first_release": "2019-10-14",
+    "end_of_life": "2024-10-07",
+    "release_manager": "Lukasz Langa"
+  },
+  "3.7": {
+    "branch": "3.7",
+    "pep": 537,
+    "status": "end-of-life",
+    "first_release": "2018-06-27",
+    "end_of_life": "2023-06-27",
+    "release_manager": "Ned Deily"
+  }
+}
+"""
+
+
+@pytest.fixture
+def path_with_cache(tmp_path: Path) -> tuple[Path, Path]:
+    json_file = tmp_path / "cache.json"
+    json_file.write_text(RELEASE_CACHE_WITH_EOL)
+
+    return tmp_path, json_file
+
+
+SAMPLE_PYPROJECT_NO_VERSION = """\
+[project]
+"""
+
+
+def test_check_python_no_version_spec_raises(path_with_cache: tuple[Path, Path]) -> None:
+    base_path, cache_path = path_with_cache
+    pyproject = base_path / "pyproject.toml"
+    pyproject.write_text(SAMPLE_PYPROJECT_NO_VERSION)
+
+    with pytest.raises(RequiresPythonNotFoundError):
+        check_python_support(pyproject, cache_json=cache_path)
+
+
+SAMPLE_PYPROJECT_NO_EOL = """\
+[project]
+requires-python = ">=3.11"
+"""
+
+
+def test_check_python_support_no_eol(path_with_cache: tuple[Path, Path]) -> None:
+    base_path, cache_path = path_with_cache
+    pyproject = base_path / "pyproject.toml"
+    pyproject.write_text(SAMPLE_PYPROJECT_NO_EOL)
+
+    with time_machine.travel(dt.date(year=2025, month=5, day=1)):
+        check_python_support(pyproject, cache_json=cache_path)
+
+
+SAMPLE_PYPROJECT_SINGLE_EOL = """\
+[project]
+requires-python = ">=3.8"
+"""
+
+
+def test_check_python_support_single_eol_raises(path_with_cache: tuple[Path, Path]) -> None:
+    base_path, cache_path = path_with_cache
+    pyproject = base_path / "pyproject.toml"
+    pyproject.write_text(SAMPLE_PYPROJECT_SINGLE_EOL)
+
+    with time_machine.travel(dt.date(year=2025, month=5, day=1)):
+        with pytest.raises(EOLPythonError) as e:
+            check_python_support(pyproject, cache_json=cache_path)
+
+    assert str(e.value).endswith("3.8")
+
+
+SAMPLE_PYPROJECT_SINGLE_EOL_BY_DATE = """\
+[project]
+requires-python = ">=3.11"
+"""
+
+
+def test_check_python_support_single_eol_raises_by_date(path_with_cache: tuple[Path, Path]) -> None:
+    base_path, cache_path = path_with_cache
+    pyproject = base_path / "pyproject.toml"
+    pyproject.write_text(SAMPLE_PYPROJECT_SINGLE_EOL_BY_DATE)
+
+    with time_machine.travel(dt.date(year=2031, month=11, day=1)):
+        with pytest.raises(EOLPythonError) as e:
+            check_python_support(pyproject, cache_json=cache_path)
+
+    assert str(e.value).endswith("3.14")
+
+
+SAMPLE_PYPROJECT_MULTI_EOL = """\
+[project]
+requires-python = ">=3.7"
+"""
+
+
+def test_check_python_support_multi_eol_raises(path_with_cache: tuple[Path, Path]) -> None:
+    base_path, cache_path = path_with_cache
+    pyproject = base_path / "pyproject.toml"
+    pyproject.write_text(SAMPLE_PYPROJECT_MULTI_EOL)
+
+    with time_machine.travel(dt.date(year=2025, month=5, day=1)):
+        with pytest.raises(EOLPythonError) as e:
+            check_python_support(pyproject, cache_json=cache_path)
+
+    assert str(e.value).endswith("3.7, 3.8")