python-checkup 0.0.1__py3-none-any.whl

python_checkup/diff.py

@@ -0,0 +1,130 @@
+from __future__ import annotations
+
+import logging
+import subprocess
+from pathlib import Path
+
+logger = logging.getLogger("python_checkup")
+
+
+class GitError(Exception):
+    """Raised when a git command fails."""
+
+
+def get_changed_files(
+    project_root: Path,
+    *,
+    base: str = "main",
+) -> list[Path]:
+    """Get Python files changed between current branch and base.
+
+    Uses merge-base to find the common ancestor, then lists files
+    changed since that point. This matches what a PR would show.
+
+    Returns empty list if not in a git repo or if git commands fail.
+    """
+    try:
+        # Step 1: Verify we're in a git repo
+        _run_git(["rev-parse", "--git-dir"], cwd=project_root)
+
+        # Step 2: Get current branch name (for logging)
+        current_branch = _run_git(
+            ["rev-parse", "--abbrev-ref", "HEAD"],
+            cwd=project_root,
+        ).strip()
+        logger.debug("Current branch: %s", current_branch)
+
+        # Step 3: Find merge-base (common ancestor)
+        try:
+            merge_base = _run_git(
+                ["merge-base", base, "HEAD"],
+                cwd=project_root,
+            ).strip()
+            logger.debug("Merge base with %s: %s", base, merge_base[:10])
+        except GitError:
+            logger.warning(
+                "Could not find merge-base with '%s'. Comparing directly against '%s'.",
+                base,
+                base,
+            )
+            merge_base = base
+
+        # Step 4: Get changed files (committed)
+        # --diff-filter=ACMR: Added, Copied, Modified, Renamed
+        output = _run_git(
+            [
+                "diff",
+                "--name-only",
+                "--diff-filter=ACMR",
+                "--relative",
+                merge_base,
+            ],
+            cwd=project_root,
+        )
+
+        # Also include uncommitted changes (staged + unstaged)
+        uncommitted = _run_git(
+            [
+                "diff",
+                "--name-only",
+                "--diff-filter=ACMR",
+                "--relative",
+                "HEAD",
+            ],
+            cwd=project_root,
+        )
+
+        # Combine and deduplicate
+        all_files = set(output.strip().split("\n")) | set(
+            uncommitted.strip().split("\n")
+        )
+
+        # Step 5: Filter to Python files that exist
+        python_files: list[Path] = []
+        for f in sorted(all_files):
+            f = f.strip()
+            if not f or not f.endswith(".py"):
+                continue
+            full_path = project_root / f
+            if full_path.is_file():
+                python_files.append(full_path)
+
+        logger.info(
+            "Found %d changed Python files (branch: %s, base: %s)",
+            len(python_files),
+            current_branch,
+            base,
+        )
+        return python_files
+
+    except GitError as e:
+        logger.warning("Git diff failed: %s. Falling back to full scan.", e)
+        return []
+
+
+def _run_git(args: list[str], cwd: Path) -> str:
+    """Run a git command and return stdout.
+
+    Raises GitError if the command fails.
+    """
+    try:
+        result = subprocess.run(
+            ["git", *args],
+            cwd=cwd,
+            capture_output=True,
+            text=True,
+            timeout=10,
+        )
+    except FileNotFoundError as exc:
+        raise GitError("git is not installed or not on PATH") from exc
+    except subprocess.TimeoutExpired as exc:
+        raise GitError(f"git {args[0]} timed out") from exc
+
+    if result.returncode != 0:
+        raise GitError(
+            f"git {' '.join(args)} failed "
+            f"(exit {result.returncode}): "
+            f"{result.stderr.strip()}"
+        )
+
+    return result.stdout

python_checkup/discovery.py

@@ -0,0 +1,180 @@
+from __future__ import annotations
+
+import logging
+import subprocess
+from fnmatch import fnmatch
+from pathlib import Path
+
+logger = logging.getLogger("python_checkup")
+
+# Directories always ignored, regardless of config.
+DEFAULT_IGNORE_DIRS: frozenset[str] = frozenset(
+    {
+        ".venv",
+        "venv",
+        ".env",
+        "env",
+        "__pycache__",
+        ".git",
+        "node_modules",
+        ".tox",
+        ".nox",
+        ".mypy_cache",
+        ".ruff_cache",
+        ".pytest_cache",
+        ".eggs",
+        "build",
+        "dist",
+        ".hatch",
+        ".pixi",
+    }
+)
+
+
+def discover_python_files(
+    root: Path,
+    ignore_patterns: list[str] | None = None,
+) -> list[Path]:
+    """Find all Python files in root, respecting .gitignore and config.
+
+    Strategy:
+    1. If inside a git repo, use `git ls-files` -- this automatically
+       respects .gitignore, .git/info/exclude, and global gitignore.
+    2. If not in a git repo, fall back to rglob with default ignores.
+
+    In both cases, apply user-configured ignore patterns on top.
+    """
+    ignore_patterns = ignore_patterns or []
+
+    # Try git-based discovery first
+    files = _git_ls_files(root)
+    if files is None:
+        # Not a git repo -- fall back to rglob
+        files = _rglob_discovery(root)
+
+    if ignore_patterns:
+        files = _apply_ignore_patterns(files, root, ignore_patterns)
+
+    return sorted(files)
+
+
+def _git_ls_files(root: Path) -> list[Path] | None:
+    """Use git ls-files to find tracked + untracked Python files.
+
+    Returns None if not in a git repo.
+
+    git ls-files --cached --others --exclude-standard gives us:
+    - All tracked files (--cached)
+    - Untracked files that aren't gitignored (--others --exclude-standard)
+    """
+    try:
+        subprocess.run(  # noqa: S603
+            ["git", "rev-parse", "--git-dir"],
+            cwd=root,
+            capture_output=True,
+            check=True,
+            timeout=5,
+        )
+    except (
+        subprocess.CalledProcessError,
+        FileNotFoundError,
+        subprocess.TimeoutExpired,
+    ):
+        return None
+
+    try:
+        result = subprocess.run(  # noqa: S603
+            [
+                "git",
+                "ls-files",
+                "--cached",
+                "--others",
+                "--exclude-standard",
+                "-z",
+                "*.py",
+            ],
+            cwd=root,
+            capture_output=True,
+            text=True,
+            timeout=10,
+        )
+    except (subprocess.CalledProcessError, subprocess.TimeoutExpired):
+        return None
+
+    if result.returncode != 0:
+        return None
+
+    files: list[Path] = []
+    for entry in result.stdout.split("\0"):
+        entry = entry.strip()
+        if not entry:
+            continue
+        full_path = (root / entry).resolve()
+        if full_path.is_file():
+            files.append(full_path)
+
+    logger.debug("git ls-files found %d Python files", len(files))
+    return files
+
+
+def _rglob_discovery(root: Path) -> list[Path]:
+    """Fallback file discovery using rglob with default ignores."""
+    files: list[Path] = []
+    for py_file in root.rglob("*.py"):
+        try:
+            relative = py_file.relative_to(root)
+        except ValueError:
+            continue
+
+        parts = relative.parts
+        if any(part in DEFAULT_IGNORE_DIRS for part in parts):
+            continue
+
+        # Skip egg-info directories
+        if any(part.endswith(".egg-info") for part in parts):
+            continue
+
+        files.append(py_file)
+
+    logger.debug("rglob found %d Python files", len(files))
+    return files
+
+
+def _apply_ignore_patterns(
+    files: list[Path],
+    root: Path,
+    patterns: list[str],
+) -> list[Path]:
+    """Apply user-configured ignore patterns.
+
+    Supports simple glob patterns:
+    - "tests/**" -- ignore everything under tests/
+    - "*.generated.py" -- ignore files matching pattern
+    - "migrations/" -- ignore directory by name
+    """
+    filtered: list[Path] = []
+    for f in files:
+        try:
+            relative = str(f.relative_to(root))
+        except ValueError:
+            relative = str(f)
+
+        if any(fnmatch(relative, pat) for pat in patterns):
+            continue
+
+        # Also check directory components
+        try:
+            parts = f.relative_to(root).parts
+        except ValueError:
+            parts = ()
+
+        if any(fnmatch(part, pat.rstrip("/")) for part in parts for pat in patterns):
+            continue
+
+        filtered.append(f)
+
+    skipped = len(files) - len(filtered)
+    if skipped > 0:
+        logger.debug("Ignore patterns filtered out %d files", skipped)
+
+    return filtered

python_checkup/formatters/badge.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+from urllib.parse import quote
+
+
+def generate_badge_url(score: int) -> str:
+    """Generate a shields.io badge URL for the given score.
+
+    Example output:
+        https://img.shields.io/badge/py--checkup-87%2F100-brightgreen
+    """
+    color = _badge_color(score)
+    # shields.io uses single hyphens as field separators (label-value-color),
+    # so literal hyphens in label/value must be doubled to "--"
+    label = "python--checkup"
+    value = quote(f"{score}/100")
+    return f"https://img.shields.io/badge/{label}-{value}-{color}"
+
+
+def generate_badge_markdown(score: int, repo_url: str = "") -> str:
+    """Generate complete markdown for a README badge.
+
+    If repo_url is provided, the badge links to it.
+    """
+    url = generate_badge_url(score)
+    alt = f"python-checkup: {score}/100"
+    if repo_url:
+        return f"[![{alt}]({url})]({repo_url})"
+    return f"![{alt}]({url})"
+
+
+def _badge_color(score: int) -> str:
+    if score >= 75:
+        return "brightgreen"
+    elif score >= 50:
+        return "yellow"
+    else:
+        return "red"

python_checkup/formatters/json_fmt.py

@@ -0,0 +1,22 @@
+from __future__ import annotations
+
+import json
+from dataclasses import asdict
+from pathlib import Path
+from typing import Any
+
+from python_checkup.models import HealthReport
+
+
+def format_json(report: HealthReport) -> str:
+    data = asdict(report)
+    return json.dumps(data, indent=2, default=_json_serializer)
+
+
+def _json_serializer(obj: Any) -> Any:
+    if isinstance(obj, Path):
+        return str(obj)
+    if hasattr(obj, "value"):  # Enum
+        return obj.value
+    msg = f"Object of type {type(obj)} is not JSON serializable"
+    raise TypeError(msg)