checkup-python 0.2.0__tar.gz

checkup_python-0.2.0/.gitignore

@@ -0,0 +1,15 @@
+.env
+dist
+site/
+
+.DS_Store
+__pycache__
+
+# Testing
+.coverage
+coverage.xml
+htmlcov/
+.pytest_cache/
+
+# Virtual environments
+.venv/

checkup_python-0.2.0/PKG-INFO

@@ -0,0 +1,6 @@
+Metadata-Version: 2.4
+Name: checkup-python
+Version: 0.2.0
+Summary: Python metrics for checkup
+Requires-Python: >=3.12
+Requires-Dist: checkup

checkup_python-0.2.0/pyproject.toml

@@ -0,0 +1,18 @@
+[project]
+name = "checkup-python"
+version = "0.2.0"
+description = "Python metrics for checkup"
+requires-python = ">=3.12"
+dependencies = [
+    "checkup",
+]
+
+[tool.uv.sources]
+checkup = { workspace = true }
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/checkup_python"]

checkup_python-0.2.0/src/checkup_python/__init__.py

@@ -0,0 +1,4 @@
+# version
+# black
+# ruff
+# dep manager which,

checkup_python-0.2.0/src/checkup_python/metrics/__init__.py

@@ -0,0 +1,3 @@
+from checkup_python.metrics.version import PythonVersionMetric
+
+__all__ = ["PythonVersionMetric"]

checkup_python-0.2.0/src/checkup_python/metrics/utils.py

@@ -0,0 +1,7 @@
+def parse_semantic_version(version: str) -> tuple[int, ...]:
+    """
+    Parse version string into tuple of integers for comparison.
+    """
+
+    parts = version.split(".")
+    return tuple(int(part) for part in parts if part.isdigit())

checkup_python-0.2.0/src/checkup_python/metrics/version.py

@@ -0,0 +1,112 @@
+import re
+import sys
+from pathlib import Path
+from typing import ClassVar
+
+from checkup.metric import Metric
+from checkup.types import Context
+from checkup_python.metrics.utils import parse_semantic_version
+
+
+class PythonVersionMetric(Metric):
+    """
+    Metric to detect the Python version configured for a project.
+
+    Checks (in order):
+    1. .python-version file
+    2. pyproject.toml
+    3. Falls back to current runtime version
+    """
+
+    name: ClassVar[str] = "python_version"
+    description: ClassVar[str] = "The Python version configured for the project"
+    unit: ClassVar[str] = "version"
+
+    def calculate(self, context: Context, metrics: dict[type[Metric], Metric]) -> None:
+        path = None
+
+        if "path" in context:
+            path = Path(context["path"])
+        else:
+            path = Path.cwd()
+
+        version = (
+            self._read_python_version_file(path)
+            or self._read_pyproject_toml(path)
+            or self._get_runtime_version()
+        )
+
+        self.value = version
+
+    def _read_python_version_file(self, path: Path) -> str | None:
+        """
+        Read version from `.python-version`.
+        """
+
+        version_file = path / ".python-version"
+        if not version_file.exists():
+            return None
+
+        return (
+            version_file.read_text().strip().removeprefix("python-").removeprefix("py")
+        )
+
+    def _read_pyproject_toml(self, path: Path) -> str | None:
+        """
+        Extract Python version from `pyproject.toml`.
+        """
+
+        pyproject_file = path / "pyproject.toml"
+        if not pyproject_file.exists():
+            return None
+
+        content = pyproject_file.read_text()
+        # Look for requires-python = ">=3.11" or similar
+        match = re.search(r'requires-python\s*=\s*["\']([^"\']+)["\']', content)
+        if not match:
+            return None
+
+        version_spec = match.group(1)
+        # Extract version number from spec like ">=3.11", "^3.11", "~=3.11.0"
+        version_match = re.search(r"(\d+\.\d+(?:\.\d+)?)", version_spec)
+        if not version_match:
+            return None
+
+        return version_match.group(1)
+
+    def _get_runtime_version(self) -> str:
+        """
+        Get the current runtime Python version.
+        """
+
+        return f"{sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}"
+
+    def __lt__(self, other) -> bool:
+        if not isinstance(other, PythonVersionMetric):
+            return NotImplemented
+        return parse_semantic_version(self.value) < parse_semantic_version(other.value)
+
+    def __le__(self, other) -> bool:
+        if not isinstance(other, PythonVersionMetric):
+            return NotImplemented
+        return parse_semantic_version(self.value) <= parse_semantic_version(other.value)
+
+    def __gt__(self, other) -> bool:
+        if not isinstance(other, PythonVersionMetric):
+            return NotImplemented
+        return parse_semantic_version(self.value) > parse_semantic_version(other.value)
+
+    def __ge__(self, other) -> bool:
+        if not isinstance(other, PythonVersionMetric):
+            return NotImplemented
+        return parse_semantic_version(self.value) >= parse_semantic_version(other.value)
+
+    def __eq__(self, other) -> bool:
+        if not isinstance(other, PythonVersionMetric):
+            return NotImplemented
+        return parse_semantic_version(self.value) == parse_semantic_version(other.value)
+
+    def __ne__(self, other) -> bool:
+        if not isinstance(other, PythonVersionMetric):
+            return NotImplemented
+        return parse_semantic_version(self.value) != parse_semantic_version(other.value)

checkup_python-0.2.0/src/checkup_python/metrics/version_check.py

@@ -0,0 +1,36 @@
+from typing import ClassVar
+
+from checkup.metric import Metric
+from checkup.types import Context
+from checkup_python.metrics.utils import parse_semantic_version
+from checkup_python.metrics.version import PythonVersionMetric
+
+
+class PythonVersionCheckMetric(Metric):
+    """
+    Metric that checks the Python version of the current project
+    and compares it to given thresholds.
+    """
+
+    name: ClassVar[str] = "python_version_check"
+    description: ClassVar[str] = (
+        "The Python version adheres to a minimum and maximum boundary"
+    )
+    unit: ClassVar[str] = "bool"
+
+    min_version: str
+    max_version: str
+
+    @classmethod
+    def depends_on(cls) -> list[type[Metric]]:
+        return [PythonVersionMetric]
+
+    def calculate(self, context: Context, metrics: dict[type[Metric], Metric]) -> None:
+        version_metric = metrics[PythonVersionMetric]
+        actual_version = version_metric.value
+
+        actual = parse_semantic_version(actual_version)
+        min_ver = parse_semantic_version(self.min_version)
+        max_ver = parse_semantic_version(self.max_version)
+
+        self.value = min_ver <= actual <= max_ver

checkup_python-0.2.0/tests/fixtures/test_config.yaml

@@ -0,0 +1,4 @@
+metrics:
+  python_version_check:
+    min_version: "3.12"
+    max_version: "3.14"

checkup_python-0.2.0/tests/test_python_hub.py

@@ -0,0 +1,18 @@
+from pathlib import Path
+
+from checkup_python.metrics.version_check import PythonVersionCheckMetric
+
+from checkup.hub import CheckHub
+
+
+def test_measure() -> None:
+    config_path = Path(__file__).parent / "fixtures" / "test_config.yaml"
+
+    result = (
+        CheckHub(config_path=config_path)
+        .with_metrics([PythonVersionCheckMetric])
+        .measure()
+    )
+
+    # `PythonVersionCheckMetric` depends on `PythonVersionMetric`
+    assert len(result.metrics) == 2

checkup_python-0.2.0/tests/test_python_metric.py

@@ -0,0 +1,21 @@
+from checkup_python.metrics import PythonVersionMetric
+
+
+def test_python_version_metric_calculate() -> None:
+    metric = PythonVersionMetric()
+    metric.calculate(context={}, metrics={})
+
+    assert metric.value is not None
+
+
+def test_python_version_metric_compare() -> None:
+    metric1 = PythonVersionMetric()
+    metric1.value = "3.8.10"
+
+    metric2 = PythonVersionMetric()
+    metric2.value = "3.9"
+
+    assert metric1 < metric2
+    assert metric2 > metric1
+    assert metric1 != metric2
+    assert not (metric1 == metric2)