python-code-quality 0.2.3__py3-none-any.whl → 0.3.0__py3-none-any.whl

py_cq/cli.py

@@ -17,7 +17,7 @@ import logging
 import time
 import tomllib
 from enum import Enum
-from importlib.metadata import requires, version
+from importlib.metadata import PackageNotFoundError, requires, version
 from pathlib import Path
 
 import tomlkit
@@ -88,7 +88,7 @@ def _version_callback(value: bool) -> None:
         dep_name = re.split(r"[>=<!;\s\[]", req)[0]
         try:
             dep_versions.append((dep_name, version(dep_name)))
-        except Exception:
+        except PackageNotFoundError:
             pass
     typer.echo(f"{pkg} v{pkg_version}")
     for dep_name, dep_ver in sorted(dep_versions):
@@ -120,7 +120,7 @@ console = Console()
 @app.command()
 def check(
     path: str = typer.Argument(".", help="Path to Python file or project directory"),
-    output: OutputMode = typer.Option(
+    output: OutputMode = typer.Option(  # noqa: B008
         OutputMode.TABLE,
         "--output",
         "-o",
@@ -160,13 +160,13 @@ def check(
     limit: int = typer.Option(
         1, "--limit", help="Number of issues to show with -o llm (default: 1)"
     ),
-    silence: list[str] = typer.Option(
+    silence: list[str] = typer.Option(  # noqa: B008
         [],
         "--silence",
         "-s",
         help="Silence issues from -o llm output (e.g. -s src/foo.py or -s src/foo.py:42:E501)",
     ),
-    order: OrderMode = typer.Option(
+    order: OrderMode = typer.Option(  # noqa: B008
         OrderMode.SEVERITY,
         "--order",
         help="Issue selection order for -o llm/llm-json: severity (most severe first) or phase (first non-clean phase, in dependency order)",
@@ -186,12 +186,10 @@ def check(
         )
         raise typer.Exit(0)
 
-    if path_obj.is_file():
-        if path_obj.suffix != ".py":
-            raise typer.BadParameter(f"File must be a Python file (.py): {path}")
-    elif path_obj.is_dir():  # pragma: no branch
-        if not (path_obj / "pyproject.toml").exists():
-            raise typer.BadParameter(f"Directory must contain pyproject.toml: {path}")
+    if path_obj.is_file() and path_obj.suffix != ".py":
+        raise typer.BadParameter(f"File must be a Python file (.py): {path}")
+    elif path_obj.is_dir() and not (path_obj / "pyproject.toml").exists():
+        raise typer.BadParameter(f"Directory must contain pyproject.toml: {path}")
     log.setLevel(log_level)
 
     only_list = [t.strip() for t in only.split(",")] if only else None

py_cq/config/config.toml

@@ -4,6 +4,7 @@ parser = "CompileParser"
 order = 1
 warning_threshold = 0.9999
 error_threshold = 0.9999
+cache_invariant = "ast"
 
 [python.ruff]
 command = "{python} -m ruff check --output-format concise --no-cache \"{context_path}\" --exclude .claude{exclude}"
@@ -42,6 +43,7 @@ error_threshold = 1.0
 run_in_target_env = true
 extra_deps = ["pytest"]
 skip_for_file = true
+cache_invariant = "ast"
 
 [python.coverage]
 command = "{python} -m coverage run --omit=*/tests/*,*/test_*.py -m pytest \"{context_path}\" --ignore .claude{exclude} && {python} -m coverage report --show-missing --omit=*/tests/*,*/test_*.py"
@@ -54,6 +56,7 @@ run_in_target_env = true
 extra_deps = ["coverage", "pytest"]
 skip_for_file = true
 skip_if = "pytest"
+cache_invariant = "ast"
 
 [python.vulture]
 command = "{python} -m vulture \"{context_path}\" --min-confidence 80 --exclude .venv,dist,.*_cache,docs,.git,.claude{exclude}"
@@ -62,6 +65,7 @@ parser = "VultureParser"
 order = 7
 warning_threshold = 0.9999
 error_threshold = 0.8
+cache_invariant = "ast"
 
 [python.interrogate]
 command = "{python} -m interrogate \"{context_path}\" -e .claude{exclude} -v --fail-under 0"

py_cq/context_hash.py

@@ -12,23 +12,56 @@ change-detection in larger systems:
   a file or directory. For a file it hashes its path, size, and modification
   time; for a directory it aggregates the signatures of all contained files.
 
+When called with ``normalize=True`` the hash is derived from the AST of each
+``.py`` file with docstrings stripped, so changes that cannot affect runtime
+behaviour (docstrings, comments, formatting, mtime-only touches such as a
+``git checkout``) leave the hash unchanged. This is used as the cache key for
+tools whose results only depend on executable code (pytest, coverage).
+
 These functions provide deterministic fingerprints that can be used for
 file integrity verification, caching, and change-detection logic.
 """
 
 import hashlib
 import os
+from pathlib import Path
+
+from py_cq.source_file import get_source
+
+_ENV_FILES = {".python-version", "pyproject.toml", "uv.lock"}
+_SKIP_DIRS = {".venv", "venv", "__pycache__", ".git"}
 
 
-def get_sigs(path: str):
+def _normalized_sig(path: str) -> str:
+    """Return a docstring/comment/format-invariant signature for a ``.py`` file.
+
+    Backed by the shared :class:`~py_cq.source_file.SourceFile` cache, so the
+    AST parsed here is reused by the coverage and interrogate parsers. Falls
+    back to a byte digest when the file can't be parsed (e.g. a mid-edit syntax
+    error), so callers always get a usable signature.
+    """
+    return f"{path}:{get_source(path).norm_digest}"
+
+
+def _byte_sig(path: str) -> str:
+    """Return a path + content digest, independent of mtime."""
+    return f"{path}:{hashlib.md5(Path(path).read_bytes()).hexdigest()}"  # nosec
+
+
+def get_sigs(path: str, *, normalize: bool = False):
     """Recursively scans a directory tree and returns a list of signatures for all Python files.
 
     The signature format is ``<file_path>:<size_bytes>:<mtime>`` where ``mtime`` is the
     last modification timestamp retrieved from ``os.stat``. The traversal skips
     directories named ``.venv``, ``venv`` and ``__pycache__``.
 
+    When ``normalize`` is ``True``, ``.py`` files are fingerprinted by their
+    docstring-stripped AST and env files by their byte content, so the result is
+    invariant to docstrings, comments, formatting, and mtime-only changes.
+
     Args:
         path (str): The root directory to scan.
+        normalize (bool): Use AST/content fingerprints instead of size+mtime.
 
     Returns:
         list[str]: A signature string for each ``.py`` file found.
@@ -41,7 +74,6 @@ def get_sigs(path: str):
         >>> get_sigs('/tmp/project')
         ['/tmp/project/main.py:1024:1680000000.0', ...]
     """
-    _ENV_FILES = {".python-version", "pyproject.toml", "uv.lock"}
     items = []
     with os.scandir(path) as entries:
         for entry in entries:
@@ -50,27 +82,35 @@ def get_sigs(path: str):
             if entry.is_file(follow_symlinks=False) and (
                 entry.name.endswith(".py") or entry.name in _ENV_FILES
             ):
-                stat_info = entry.stat(follow_symlinks=False)
-                items.append(f"{entry.path}:{stat_info.st_size}:{stat_info.st_mtime}")
-            if entry.is_dir(follow_symlinks=False) and entry.name not in [
-                ".venv",
-                "venv",
-                "__pycache__",
-                ".git",
-            ]:
-                items.extend(get_sigs(entry.path))
+                if normalize:
+                    if entry.name.endswith(".py"):
+                        items.append(_normalized_sig(entry.path))
+                    else:
+                        items.append(_byte_sig(entry.path))
+                else:
+                    stat_info = entry.stat(follow_symlinks=False)
+                    items.append(
+                        f"{entry.path}:{stat_info.st_size}:{stat_info.st_mtime}"
+                    )
+            if entry.is_dir(follow_symlinks=False) and entry.name not in _SKIP_DIRS:
+                items.extend(get_sigs(entry.path, normalize=normalize))
     return items
 
 
-def get_context_hash(path: str) -> str:
+def get_context_hash(path: str, *, normalize: bool = False) -> str:
     """Compute an MD5 hash that uniquely identifies a file or directory.
 
     The hash is derived from a signature string. For a file, the signature consists of
     its path, size, and modification time. For a directory, the signature is the
     concatenation of the signatures of all files within it (recursively).
 
+    When ``normalize`` is ``True`` the signatures are derived from each ``.py``
+    file's docstring-stripped AST, making the hash invariant to docstrings,
+    comments, formatting, and mtime-only changes.
+
     Args:
         path (str): The filesystem path to hash.
+        normalize (bool): Use AST/content fingerprints instead of size+mtime.
 
     Returns:
         str: The hexadecimal MD5 digest.
@@ -84,10 +124,13 @@ def get_context_hash(path: str) -> str:
     """
     h = hashlib.md5()  # nosec
     if os.path.isfile(path):
-        s = os.stat(path)
-        h.update(f"{path}:{s.st_size}:{s.st_mtime}".encode())
+        if normalize and path.endswith(".py"):
+            h.update(_normalized_sig(path).encode())
+        else:
+            s = os.stat(path)
+            h.update(f"{path}:{s.st_size}:{s.st_mtime}".encode())
     elif os.path.isdir(path):
-        for sig in sorted(get_sigs(path)):
+        for sig in sorted(get_sigs(path, normalize=normalize)):
             h.update(sig.encode())
     else:
         h.update(b"empty")

py_cq/execution_engine.py

@@ -16,9 +16,11 @@ import logging
 import os
 import shlex
 import shutil
+import signal
 import subprocess
 import sys
 import tempfile
+import threading
 import time
 from collections.abc import Collection
 from concurrent.futures import ThreadPoolExecutor, as_completed
@@ -102,6 +104,80 @@ def _build_exclude_str(
     return "".join(parts)
 
 
+def _terminate_process_tree(proc: "subprocess.Popen") -> None:
+    """Best-effort kill of a shell subprocess and all its children, cross-platform.
+
+    ``shell=True`` spawns a shell that spawns ``uv``/``python``, so killing the
+    immediate child is not enough - the whole tree must go.
+    """
+    if proc.poll() is not None:
+        return
+    if sys.platform == "win32":
+        subprocess.run(
+            ["taskkill", "/F", "/T", "/PID", str(proc.pid)],
+            capture_output=True,
+            check=False,
+        )  # nosec
+    else:
+        try:
+            os.killpg(os.getpgid(proc.pid), signal.SIGTERM)
+        except (ProcessLookupError, PermissionError):
+            proc.kill()
+
+
+def _run_command(
+    command: str, run_env: dict, cancel_event: threading.Event | None
+) -> tuple[str, str, int, bool]:
+    """Run *command* in a shell and return ``(stdout, stderr, returncode, cancelled)``.
+
+    When *cancel_event* fires mid-run the process tree is terminated and
+    ``cancelled`` is True (captured output is discarded). With no event this is
+    a plain blocking ``subprocess.run`` (no poll overhead for the common path).
+    """
+    if cancel_event is None:
+        result = subprocess.run(
+            command,
+            capture_output=True,
+            text=True,
+            shell=True,
+            encoding="utf-8",
+            errors="replace",
+            env=run_env,
+            check=False,
+        )  # nosec
+        return result.stdout, result.stderr, result.returncode, False
+    if cancel_event.is_set():
+        return "", "", -1, True
+    popen_kwargs: dict[str, Any] = {}
+    if sys.platform != "win32":
+        # New session/process group so os.killpg reaches the shell's children.
+        popen_kwargs["start_new_session"] = True
+    proc = subprocess.Popen(
+        command,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        text=True,
+        shell=True,
+        encoding="utf-8",
+        errors="replace",
+        env=run_env,
+        **popen_kwargs,
+    )  # nosec
+    # Poll so a cancel signal can terminate a still-running command.
+    while True:
+        try:
+            stdout, stderr = proc.communicate(timeout=0.1)
+            return stdout, stderr, proc.returncode, False
+        except subprocess.TimeoutExpired:
+            if cancel_event.is_set():
+                _terminate_process_tree(proc)
+                try:
+                    proc.communicate(timeout=5)
+                except subprocess.TimeoutExpired:  # pragma: no cover
+                    proc.kill()
+                return "", "", proc.returncode or -1, True
+
+
 def run_tool(
     tool_config: ToolConfig,
     context_path: str,
@@ -109,6 +185,7 @@ def run_tool(
     *,
     precomputed_hash: str | None = None,
     project_tag: str | None = None,
+    cancel_event: threading.Event | None = None,
 ) -> RawResult:
     """Runs a tool defined by its configuration and returns the execution result.
 
@@ -195,11 +272,12 @@ def run_tool(
         python=python,
         exclude=exclude,
     )
-    context_hash = (
-        precomputed_hash
-        if precomputed_hash is not None
-        else get_context_hash(context_path)
-    )
+    if precomputed_hash is not None:
+        context_hash = precomputed_hash
+    elif tool_config.cache_invariant == "ast":
+        context_hash = get_context_hash(context_path, normalize=True)
+    else:
+        context_hash = get_context_hash(context_path)
     cache_key = f"{command}:{context_hash}"
 
     t_cache0 = time.perf_counter()
@@ -223,18 +301,20 @@ def run_tool(
     run_env["COVERAGE_FILE"] = coverage_tmp
     t_sub0 = time.perf_counter()
     try:
-        result = subprocess.run(
-            command,
-            capture_output=True,
-            text=True,
-            shell=True,
-            encoding="utf-8",
-            errors="replace",
-            env=run_env,
-        )  # nosec
+        stdout, stderr, return_code, cancelled = _run_command(
+            command, run_env, cancel_event
+        )
     finally:
         Path(coverage_tmp).unlink(missing_ok=True)
     t_sub = time.perf_counter() - t_sub0
+    if cancelled:
+        # A dependency (e.g. pytest) already failed, so this run is moot. Return
+        # an empty result - uncached, since it was terminated, not completed -
+        # and let the parser produce its skip/zero output.
+        log.debug(
+            f"{tool_config.name}: [CANCELLED] {tool_config.skip_if} failed; terminated after {t_sub * 1000:.0f}ms"
+        )
+        return RawResult(tool_name=tool_config.name)
     log.debug(
         f"{tool_config.name}: [MISS] cache={t_cache * 1000:.1f}ms tool={t_sub * 1000:.0f}ms: {command}"
     )
@@ -242,9 +322,9 @@ def run_tool(
     raw_result = RawResult(
         tool_name=tool_config.name,
         command=command,
-        stdout=result.stdout,
-        stderr=result.stderr,
-        return_code=result.returncode,
+        stdout=stdout,
+        stderr=stderr,
+        return_code=return_code,
         timestamp=timestamp,
         project_path=project_dir,
     )
@@ -308,16 +388,29 @@ def run_tools(
     shared_hash = get_context_hash(root)
     log.debug(f"context_hash: {(time.perf_counter() - t_hash0) * 1000:.1f}ms {shared_hash}")
 
-    sentinel_key = f"_project_hash:{root}"
-    prev_hash = _cache.get(sentinel_key)
-    if prev_hash is not None and prev_hash != shared_hash:
-        evicted = _cache.evict(root)
-        log.debug(f"project changed: evicted {evicted} stale cache entries for {root}")
-    _cache.set(sentinel_key, shared_hash, expire=5 * 24 * 60 * 60, tag=root)
-
-    def _run_and_parse(tool_config: ToolConfig) -> tuple[int, ToolResult]:
+    # Cache keys are content-based, so a changed project naturally produces new
+    # keys; stale entries age out via TTL + size_limit (no blanket eviction).
+    # Tools flagged cache_invariant="ast" key on the docstring-stripped AST so
+    # docstring/comment/format-only edits stay cache hits. Compute it once here
+    # (not lazily in the worker threads, where pytest and coverage would race
+    # and each re-parse the whole tree) and only when some tool needs it.
+    norm_hash = shared_hash
+    if any(tc.cache_invariant == "ast" for tc in tool_configs):
+        t_norm0 = time.perf_counter()
+        norm_hash = get_context_hash(root, normalize=True)
+        log.debug(f"context_hash(ast): {(time.perf_counter() - t_norm0) * 1000:.1f}ms {norm_hash}")
+
+    def _hash_for(tool_config: ToolConfig) -> str:
+        return norm_hash if tool_config.cache_invariant == "ast" else shared_hash
+
+    def _run_and_parse(
+        tool_config: ToolConfig, cancel_event: threading.Event | None = None
+    ) -> tuple[int, ToolResult]:
         t0 = time.perf_counter()
-        raw_result = run_tool(tool_config, path, excludes, precomputed_hash=shared_hash, project_tag=root)
+        # Only pass cancel_event when present so patched run_tool stubs in tests
+        # (which don't declare the kwarg) keep working for non-cancellable tools.
+        extra = {"cancel_event": cancel_event} if cancel_event is not None else {}
+        raw_result = run_tool(tool_config, path, excludes, precomputed_hash=_hash_for(tool_config), project_tag=root, **extra)
         tr = tool_config.parser_class(tool_config.parser_config).parse(raw_result)
         tr.duration_s = time.perf_counter() - t0
         return tool_config.order, tr
@@ -329,7 +422,7 @@ def run_tools(
         for i, tool_config in enumerate(sorted_configs):
             try:
                 prioritized.append(_run_and_parse(tool_config))
-            except Exception as exc:
+            except Exception as exc:  # noqa: BLE001 - a crashing tool must not abort the run
                 log.error(f"{tool_config.name} generated an exception: {exc} {exc.__traceback__}")
                 n_skipped = n_total - i - 1
                 if n_skipped:
@@ -357,52 +450,52 @@ def run_tools(
         return [tr for _, tr in sorted(prioritized)]
     configs_by_name = {tc.name: tc for tc in tool_configs}
 
-    def _run_if_dep_passed(dep_future, tool_config: ToolConfig, dep_config: ToolConfig) -> tuple[int, ToolResult]:
-        # Wait for the dependency within the same thread pool - no phase split,
-        # so all other tools keep running in parallel while we block here.
-        try:
-            _, dep_tr = dep_future.result()
-        except Exception:
-            return _run_and_parse(tool_config)
-        if dep_tr.metrics and min(dep_tr.metrics.values()) < dep_config.error_threshold:
-            # Dependency failed its error threshold: skip this tool and return a
-            # synthetic empty result. Coverage declares skip_if = "pytest" so that
-            # it never re-invokes pytest (which the coverage command does internally)
-            # when we already know pytest is broken.
-            log.debug(f"{tool_config.name}: skipping because {tool_config.skip_if} failed")
-            t0 = time.perf_counter()
-            tr = tool_config.parser_class(tool_config.parser_config).parse(
-                RawResult(tool_name=tool_config.name)
-            )
-            tr.duration_s = time.perf_counter() - t0
-            return tool_config.order, tr
-        return _run_and_parse(tool_config)
-
     timings: list[tuple[int, str, float]] = []
-    # Sort by order so that when we build name_to_future below, a dependency's
-    # future is always registered before the tool that declares skip_if on it.
     sorted_configs = sorted(tool_configs, key=lambda tc: tc.order)
+    # A tool with skip_if gets a cancel event: it runs in parallel with its
+    # dependency, and is terminated mid-run only if that dependency *fails* its
+    # error threshold. Coverage declares skip_if = "pytest" so a broken pytest
+    # kills the coverage run (which re-invokes pytest internally) instead of
+    # letting it finish a pointless second suite execution.
+    cancel_events = {
+        tc.name: threading.Event()
+        for tc in sorted_configs
+        if tc.skip_if and tc.skip_if in configs_by_name
+    }
     name_to_future: dict[str, Any] = {}
     with ThreadPoolExecutor(max_workers=max_workers or len(tool_configs)) as executor:
         future_to_tool = {}
         for tc in sorted_configs:
-            dep_name = tc.skip_if
-            dep_future = name_to_future.get(dep_name) if dep_name else None
-            dep_config = configs_by_name.get(dep_name) if dep_name else None
-            if dep_future and dep_config:
-                # Submit a wrapper that waits on the dependency future first.
-                f = executor.submit(_run_if_dep_passed, dep_future, tc, dep_config)
-            else:
-                f = executor.submit(_run_and_parse, tc)
+            f = executor.submit(_run_and_parse, tc, cancel_events.get(tc.name))
             future_to_tool[f] = tc
             name_to_future[tc.name] = f
+
+        def _cancel_on_dep_failure(
+            dep_future, ev: threading.Event, dep_config: ToolConfig, name: str
+        ) -> None:
+            try:
+                _, dep_tr = dep_future.result()
+            except Exception:  # noqa: BLE001 - a crashed dep cancels nothing
+                return
+            if dep_tr.metrics and min(dep_tr.metrics.values()) < dep_config.error_threshold:
+                log.debug(f"{name}: cancelling because {dep_config.name} failed")
+                ev.set()
+
+        for tc in sorted_configs:
+            if tc.name in cancel_events:
+                dep_config = configs_by_name[tc.skip_if]
+                name_to_future[tc.skip_if].add_done_callback(
+                    lambda fut, ev=cancel_events[tc.name], dc=dep_config, nm=tc.name: _cancel_on_dep_failure(
+                        fut, ev, dc, nm
+                    )
+                )
         for future in as_completed(future_to_tool):
             tool_config = future_to_tool[future]
             try:
                 tc_order, tr = future.result()
                 prioritized.append((tc_order, tr))
                 timings.append((tc_order, tool_config.name, tr.duration_s))
-            except Exception as exc:
+            except Exception as exc:  # noqa: BLE001 - a crashing tool must not abort the run
                 log.error(f"{tool_config.name} generated an exception: {exc}")
     per_tool = ", ".join(f"{name}={dur:.2f}s" for _, name, dur in sorted(timings))
     log.debug(f"run_tools elapsed: {time.perf_counter() - t_start:.2f}s [{per_tool}]")

py_cq/localtypes.py

@@ -62,6 +62,9 @@ class ToolConfig:
     skip_for_file: bool = False  # If True, skip when context_path is a single file
     gate_strict: bool = True  # If False, small regressions above warning_threshold are accepted
     skip_if: str = ""  # Tool name; if that tool's score is below its error_threshold, skip this tool
+    cache_invariant: str = (
+        ""  # "ast": key the cache on the docstring-stripped AST, ignoring docstrings/comments/format
+    )
 
 
 @dataclass
@@ -172,7 +175,6 @@ class AbstractParser(ABC):
     @abstractmethod
     def parse(self, raw_result: RawResult) -> ToolResult:
         """Converts raw tool output into a structured ToolResult."""
-        pass
 
     def format_llm_message(
         self, tr: ToolResult, *, context_lines: int = 15, limit: int = 1

py_cq/parsers/common.py

@@ -48,9 +48,7 @@ def format_source_context(
     collected = []
     for i, rline in enumerate(raw_lines):
         if i > error_offset and (
-            rline.startswith("def ")
-            or rline.startswith("async def ")
-            or rline.startswith("class ")
+            rline.startswith(("def ", "async def ", "class "))
         ):
             break
         collected.append(f"{context_start + i}: {rline}")
@@ -382,8 +380,7 @@ def score_logistic_variant(
         1.0
         >>> score_logistic_variant(10, scale_factor=0)
         0.0"""
-    if errors < 0:
-        errors = 0
+    errors = max(errors, 0)
     if scale_factor == 0:
         return 1.0 if errors == 0 else 0.0
     try:

py_cq/parsers/coverageparser.py

@@ -1,11 +1,11 @@
 """Parses raw coverage tool output into structured ToolResult instances with per-function granularity."""
 
-import ast
 import logging
 from pathlib import Path
 
 from py_cq.localtypes import AbstractParser, RawResult, ToolResult
 from py_cq.parsers.common import find_function_source, resolve_path
+from py_cq.source_file import get_source
 
 log = logging.getLogger("cq")
 
@@ -29,30 +29,19 @@ def _parse_line_ranges(s: str) -> set[int]:
     return result
 
 
-def _get_signature(node: ast.FunctionDef | ast.AsyncFunctionDef) -> str:
-    """Return the signature of the function definition as a string."""
-    prefix = "async def" if isinstance(node, ast.AsyncFunctionDef) else "def"
-    args = ast.unparse(node.args)
-    returns = f" -> {ast.unparse(node.returns)}" if node.returns else ""
-    return f"{prefix} {node.name}({args}){returns}"
-
-
 def _extract_functions(file: str, missing_lines_str: str) -> list[tuple[str, int, str]]:
     """Return (name, lineno, signature) for functions whose bodies overlap with the missing line ranges."""
     try:
-        source = Path(file).read_text(encoding="utf-8", errors="replace")
-        tree = ast.parse(source)
-    except (OSError, SyntaxError, ValueError):
+        funcs = get_source(file).functions
+    except OSError:
         return []
     missing = _parse_line_ranges(missing_lines_str)
     seen: set[str] = set()
     result: list[tuple[str, int, str]] = []
-    for node in sorted(ast.walk(tree), key=lambda n: getattr(n, "lineno", 0)):
-        if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
-            end = getattr(node, "end_lineno", node.lineno)
-            if missing & set(range(node.lineno, end + 1)) and node.name not in seen:
-                seen.add(node.name)
-                result.append((node.name, node.lineno, _get_signature(node)))
+    for fn in funcs:
+        if missing & set(range(fn.lineno, fn.end_lineno + 1)) and fn.name not in seen:
+            seen.add(fn.name)
+            result.append((fn.name, fn.lineno, fn.signature))
     return result
 
 

py_cq/parsers/interrogateparser.py

@@ -21,6 +21,7 @@ from py_cq.parsers.common import (
     format_issue_header,
     format_source_context,
 )
+from py_cq.source_file import get_source
 
 _SKIP_PARAMS = {"self", "cls"}
 
@@ -34,9 +35,10 @@ def _format_missing_docstring(file_str: str, line: int, code: str, message: str)
         return base + "\n\nInsert a module-level docstring as the very first statement in the file."
 
     try:
-        source = Path(file_str).read_text(encoding="utf-8")
-        tree = ast.parse(source)
-    except (OSError, SyntaxError):
+        tree = get_source(file_str).tree
+    except OSError:
+        tree = None
+    if tree is None:
         return base + "\n\nInsert a docstring as the first statement in the body."
 
     for node in ast.walk(tree):
@@ -88,7 +90,7 @@ def _load_interrogate_cfg(context_path: str) -> dict:
             try:
                 data = tomllib.loads(pyproject.read_text(encoding="utf-8"))
                 return data.get("tool", {}).get("interrogate", {})
-            except Exception:
+            except (tomllib.TOMLDecodeError, OSError, UnicodeDecodeError):
                 return {}
     return {}
 
@@ -104,9 +106,7 @@ def _skip_node(name: str, cfg: dict) -> bool:
         return True
     if is_private and cfg.get("ignore-private"):
         return True
-    if is_semiprivate and cfg.get("ignore-semiprivate"):
-        return True
-    return False
+    return bool(is_semiprivate and cfg.get("ignore-semiprivate"))
 
 
 def _missing_docstrings(file_path: Path, cfg: dict | None = None) -> list[tuple[int, str, str]]:
@@ -117,11 +117,13 @@ def _missing_docstrings(file_path: Path, cfg: dict | None = None) -> list[tuple[
     the module.
     """
     try:
-        source = file_path.read_text(encoding="utf-8")
-        tree = ast.parse(source, filename=str(file_path))
-    except (OSError, SyntaxError):
+        sf = get_source(str(file_path))
+        tree = sf.tree
+    except OSError:
         return []
-    src_lines = source.splitlines()
+    if tree is None:
+        return []
+    src_lines = sf.text.splitlines()
 
     def src_line(lineno: int) -> str:
         """Return the stripped content of the source line at the given line number."""
@@ -137,16 +139,13 @@ def _missing_docstrings(file_path: Path, cfg: dict | None = None) -> list[tuple[
 
     effective_cfg = cfg or {}
     results = []
-    for node in ast.walk(tree):
-        if isinstance(node, ast.Module):
-            if not ast.get_docstring(node):
-                results.append((0, "module", first_code_line()))
-        elif isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
-            if not ast.get_docstring(node) and not _skip_node(node.name, effective_cfg):
-                results.append((node.lineno, "def", src_line(node.lineno)))
-        elif isinstance(node, ast.ClassDef):
-            if not ast.get_docstring(node) and not _skip_node(node.name, effective_cfg):
-                results.append((node.lineno, "class", src_line(node.lineno)))
+    if not sf.module_has_docstring:
+        results.append((0, "module", first_code_line()))
+    for d in sf.definitions:
+        if d.has_docstring or _skip_node(d.name, effective_cfg):
+            continue
+        kind = "def" if d.kind == "function" else "class"
+        results.append((d.lineno, kind, src_line(d.lineno)))
     results.sort(key=lambda x: x[0])
     return results
 

py_cq/parsers/pytestparser.py

@@ -163,7 +163,7 @@ class PytestParser(AbstractParser):
         if "no tests ran" in raw_result.stdout:
             tr.metrics["tests"] = 0.0
         else:
-            tests_found = dict()
+            tests_found = {}
             num_tests = 0
             passed_tests = 0
             for line in lines:

py_cq/source_file.py

@@ -0,0 +1,199 @@
+"""Process-scoped cache of parsed source files, shared across one ``cq check``.
+
+Within a single run the same ``.py`` file is otherwise read and parsed several
+times: by the normalized context hash, the coverage parser, the interrogate
+parser, and the LLM formatters. :class:`SourceFile` parses each file at most
+once and exposes lazy projections (functions, classes, docstring presence) that
+downstream consumers walk instead of re-parsing.
+
+The cache is keyed on ``(path, size, mtime)`` so a content change (which bumps
+``mtime``) misses and forces a fresh parse; correctness never depends on a hit.
+"""
+
+import ast
+import hashlib
+import os
+from dataclasses import dataclass
+from pathlib import Path
+
+
+@dataclass(frozen=True)
+class FuncInfo:
+    """A function or class definition discovered in a source file.
+
+    ``signature`` is the rendered ``def`` line for functions and ``""`` for
+    classes (no consumer needs a class signature). ``kind`` is ``"function"``
+    or ``"class"``.
+    """
+
+    name: str
+    kind: str
+    lineno: int
+    end_lineno: int
+    has_docstring: bool
+    signature: str
+
+
+def _docstring_invariant_digest(tree: ast.AST) -> str:
+    """Return an md5 of ``tree`` with docstrings removed, leaving ``tree`` intact.
+
+    Docstring statements are temporarily detached, the tree is dumped and
+    hashed, then they are reattached - so the digest is docstring-invariant
+    without parsing a second time or mutating the tree that other consumers
+    share. Safe because the hash pass runs single-threaded before the tool pool.
+    """
+    detached = []
+    for node in ast.walk(tree):
+        if isinstance(
+            node, (ast.Module, ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef)
+        ):
+            body = node.body
+            if (
+                body
+                and isinstance(body[0], ast.Expr)
+                and isinstance(body[0].value, ast.Constant)
+                and isinstance(body[0].value.value, str)
+            ):
+                detached.append((node, body[0]))
+                node.body = body[1:]
+    digest = hashlib.md5(ast.dump(tree).encode()).hexdigest()  # nosec
+    for node, doc in detached:
+        node.body = [doc, *node.body]
+    return digest
+
+
+def _signature(node: ast.FunctionDef | ast.AsyncFunctionDef) -> str:
+    """Return the signature of the function definition as a string."""
+    prefix = "async def" if isinstance(node, ast.AsyncFunctionDef) else "def"
+    args = ast.unparse(node.args)
+    returns = f" -> {ast.unparse(node.returns)}" if node.returns else ""
+    return f"{prefix} {node.name}({args}){returns}"
+
+
+class SourceFile:
+    """Lazily-realized view of one source file: text, AST, and projections.
+
+    Fields are computed on first access and cached. ``.tree`` stays pristine
+    (docstrings intact) so multiple consumers can share it; ``.norm_digest``
+    derives its docstring-stripped digest from a throwaway reparse rather than
+    mutating ``.tree``.
+    """
+
+    def __init__(self, path: str) -> None:
+        self.path = path
+        self._raw: bytes | None = None
+        self._text: str | None = None
+        self._tree: ast.AST | None = None
+        self._parsed = False
+        self._norm_digest: str | None = None
+        self._definitions: list[FuncInfo] | None = None
+
+    def _read_bytes(self) -> bytes:
+        if self._raw is None:
+            self._raw = Path(self.path).read_bytes()
+        return self._raw
+
+    @property
+    def text(self) -> str:
+        """Return the file contents decoded as UTF-8 (undecodable bytes replaced)."""
+        if self._text is None:
+            self._text = self._read_bytes().decode("utf-8", "replace")
+        return self._text
+
+    @property
+    def tree(self) -> ast.AST | None:
+        """Return the parsed AST, or ``None`` if the file can't be parsed."""
+        if not self._parsed:
+            self._parsed = True
+            try:
+                self._tree = ast.parse(self.text)
+            except (SyntaxError, ValueError):
+                self._tree = None
+        return self._tree
+
+    @property
+    def norm_digest(self) -> str:
+        """Return a docstring/comment/format-invariant digest of the file.
+
+        Falls back to a byte digest when the file can't be parsed (e.g. a
+        mid-edit syntax error), so callers always get a usable digest.
+        """
+        if self._norm_digest is None:
+            tree = self.tree
+            if tree is None:
+                self._norm_digest = hashlib.md5(self._read_bytes()).hexdigest()  # nosec
+            else:
+                self._norm_digest = _docstring_invariant_digest(tree)
+        return self._norm_digest
+
+    @property
+    def definitions(self) -> list[FuncInfo]:
+        """Return every function and class definition, in source order."""
+        if self._definitions is None:
+            defs: list[FuncInfo] = []
+            tree = self.tree
+            if tree is not None:
+                for node in ast.walk(tree):
+                    if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                        defs.append(
+                            FuncInfo(
+                                node.name,
+                                "function",
+                                node.lineno,
+                                getattr(node, "end_lineno", node.lineno),
+                                ast.get_docstring(node) is not None,
+                                _signature(node),
+                            )
+                        )
+                    elif isinstance(node, ast.ClassDef):
+                        defs.append(
+                            FuncInfo(
+                                node.name,
+                                "class",
+                                node.lineno,
+                                getattr(node, "end_lineno", node.lineno),
+                                ast.get_docstring(node) is not None,
+                                "",
+                            )
+                        )
+                defs.sort(key=lambda d: d.lineno)
+            self._definitions = defs
+        return self._definitions
+
+    @property
+    def functions(self) -> list[FuncInfo]:
+        """Return the function definitions only (no classes), in source order."""
+        return [d for d in self.definitions if d.kind == "function"]
+
+    @property
+    def module_has_docstring(self) -> bool:
+        """Return True if the module has a docstring."""
+        tree = self.tree
+        return isinstance(tree, ast.Module) and ast.get_docstring(tree) is not None
+
+
+# Process-scoped memo: (path, size, mtime) -> SourceFile. A stale mtime only
+# forces a re-parse that reproduces the same projections, so correctness never
+# depends on this cache (matches the lock-free design: a duplicate parse is
+# harmless and GIL-serialized).
+_source_cache: dict[tuple[str, int, float], SourceFile] = {}
+
+
+def get_source(path: str) -> SourceFile:
+    """Return the cached :class:`SourceFile` for ``path``, creating it on miss.
+
+    Keyed on ``(canonical_path, size, mtime)``; a content change misses and
+    re-parses. The path is canonicalized (absolute + OS case folding) so the
+    hash pass and the parsers - which spell the same file differently (relative
+    vs. resolved/posix) - share one cache entry.
+
+    Raises:
+        OSError: If ``path`` cannot be stat'd.
+    """
+    s = os.stat(path)
+    key = (os.path.normcase(os.path.abspath(path)), s.st_size, s.st_mtime)
+    sf = _source_cache.get(key)
+    if sf is None:
+        sf = SourceFile(path)
+        _source_cache[key] = sf
+    return sf

py_cq/table_formatter.py

@@ -21,7 +21,7 @@ def format_as_table(
     table.add_column("Status")
     for tr in data.tool_results:
         tool_name = tr.raw.tool_name
-        config = next((t for t in registry.values() if t.name == tool_name))
+        config = next(t for t in registry.values() if t.name == tool_name)
         for i, (name, value) in enumerate(tr.metrics.items()):
             if value < config.error_threshold:
                 status = "[bold red]Error[/]"

py_cq/tool_registry.py

@@ -34,6 +34,7 @@ def load_tool_configs() -> dict[str, ToolConfig]:
             skip_for_file=tool_data.get("skip_for_file", False),
             gate_strict=tool_data.get("gate_strict", True),
             skip_if=tool_data.get("skip_if", ""),
+            cache_invariant=tool_data.get("cache_invariant", ""),
         )
     return registry
 

{python_code_quality-0.2.3.dist-info → python_code_quality-0.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-code-quality
-Version: 0.2.3
+Version: 0.3.0
 Summary: Python Code Quality Analysis Tool - feed the results from 11 CQ tools straight into an LLM. Minimal tokens.
 Author: Chris Kilner
 Author-email: Chris Kilner <chris@rhiza.fr>
@@ -17,7 +17,7 @@ Requires-Dist: pytest-cov>=6.1.1
 Requires-Dist: pytest-json-report>=1.5.0
 Requires-Dist: radon>=6.0.1
 Requires-Dist: rich>=14.0.0
-Requires-Dist: ruff>=0.14.1
+Requires-Dist: ruff>=0.14.1,<0.17
 Requires-Dist: tomlkit>=0.13.0
 Requires-Dist: ty>=0.0.17
 Requires-Dist: typer>=0.16.0
@@ -65,6 +65,8 @@ uv tool install .
 
 These tools are run in **parallel** except:
 When running '-o llm', we run sequentially and exit early at the first error.
+`coverage` is a special case: it starts alongside `pytest` and is cancelled if
+`pytest` fails, scoring `0%` without a second test run.
 
 | Order | Tool | Measures |
 |----------|------|----------|
@@ -74,11 +76,11 @@ When running '-o llm', we run sequentially and exit early at the first error.
 | 4 | bandit | Security vulnerabilities |
 | 5 | pytest | Test pass rate |
 | 6 | coverage | Test coverage |
-| 7 | radon cc | Cyclomatic complexity |
-| 8 | radon mi | Maintainability index |
-| 9 | radon hal | Halstead volume / bug estimate |
-| 10 | vulture | Dead code |
-| 11 | interrogate | Docstring coverage |
+| 7 | vulture | Dead code |
+| 8 | interrogate | Docstring coverage |
+| 9 | radon cc | Cyclomatic complexity |
+| 10 | radon mi | Maintainability index |
+| 11 | radon hal | Halstead volume / bug estimate |
 
 Diskcache is used to cache tool output for lightning fast re-runs. Sane defaults: <100 Mb, <5 days, No pickle risk.
 
@@ -337,106 +339,117 @@ warning = 0.9
 error = 0.7
 ```
 
-Tool IDs match the keys in `config/config.yaml`: `compile`, `ruff`, `ty`, `bandit`, `pytest`, `coverage`, `radon-cc`, `radon-mi`, `radon-hal`, `vulture`, `interrogate`.
+Tool IDs match the keys in `src/py_cq/config/config.toml`: `compile`, `ruff`, `ty`, `bandit`, `pytest`, `coverage`, `radon-cc`, `radon-mi`, `radon-hal`, `vulture`, `interrogate`.
 
 
 ### Default config
 
-```yaml
-python:
-
-  compile:
-    command: "{python} -m compileall -r 10 -j 8 \"{context_path}\" -x .*venv"
-    parser: "CompileParser"
-    order: 1
-    warning_threshold: 0.9999
-    error_threshold: 0.9999
-
-  ruff:
-    command: "{python} -m ruff check --output-format concise --no-cache \"{context_path}\"{exclude}"
-    exclude_format: " --exclude {path}"
-    parser: "RuffParser"
-    order: 2
-    warning_threshold: 0.9999
-    error_threshold: 0.9
-
-  ty:
-    command: "{python} -m ty check --output-format concise --color never \"{context_path}\"{exclude}"
-    exclude_format: " --exclude {path}"
-    parser: "TyParser"
-    order: 3
-    warning_threshold: 0.9999
-    error_threshold: 0.8
-    run_in_target_env: true
-    extra_deps:
-      - ty
-
-  bandit:
-    command: "{python} -m bandit -r \"{context_path}\" -f json -q -s B101 --severity-level medium --exclude \"{input_path_posix}/.venv,{input_path_posix}/tests{exclude}\""
-    exclude_format: ",{input_path_posix}/{path}"
-    parser: "BanditParser"
-    order: 4
-    warning_threshold: 0.9999
-    error_threshold: 0.8
-
-  pytest:
-    command: "{python} -m pytest -v \"{context_path}\"{exclude}"
-    exclude_format: " --ignore {path}"
-    parser: "PytestParser"
-    order: 5
-    warning_threshold: 1.0
-    error_threshold: 1.0
-    run_in_target_env: true
-    extra_deps:
-      - pytest
-
-  coverage:
-    command: "{python} -m coverage run --omit=*/tests/*,*/test_*.py -m pytest \"{context_path}\" && {python} -m coverage report --omit=*/tests/*,*/test_*.py"
-    parser: "CoverageParser"
-    order: 6
-    warning_threshold: 0.9
-    error_threshold: 0.5
-    run_in_target_env: true
-    extra_deps:
-      - coverage
-      - pytest
-
-  radon-cc:
-    command: "{python} -m radon cc --json \"{context_path}\""
-    parser: "ComplexityParser"
-    order: 7
-    warning_threshold: 0.6
-    error_threshold: 0.4
-
-  radon-mi:
-    command: "{python} -m radon mi -s --json \"{context_path}\""
-    parser: "MaintainabilityParser"
-    order: 8
-    warning_threshold: 0.6
-    error_threshold: 0.4
-
-  radon-hal:
-    command: "{python} -m radon hal -f --json \"{context_path}\""
-    parser: "HalsteadParser"
-    order: 9
-    warning_threshold: 0.5
-    error_threshold: 0.3
-
-  vulture:
-    command: "{python} -m vulture \"{context_path}\" --min-confidence 80 --exclude .venv,dist,.*_cache,docs,.git{exclude}"
-    exclude_format: ",{path}"
-    parser: "VultureParser"
-    order: 10
-    warning_threshold: 0.9999
-    error_threshold: 0.8
-
-  interrogate:
-    command: "{python} -m interrogate \"{context_path}\"{exclude} -v --fail-under 0"
-    exclude_format: " -e {path}"
-    parser: "InterrogateParser"
-    order: 11
-    warning_threshold: 0.8
-    error_threshold: 0.3
+Defined in `src/py_cq/config/config.toml` (sections are namespaced by language):
+
+```toml
+[python.compile]
+command = "{python} -m compileall -r 10 -j 8 \"{context_path}\" -x .*venv|\\.claude"
+parser = "CompileParser"
+order = 1
+warning_threshold = 0.9999
+error_threshold = 0.9999
+cache_invariant = "ast"
+
+[python.ruff]
+command = "{python} -m ruff check --output-format concise --no-cache \"{context_path}\" --exclude .claude{exclude}"
+exclude_format = " --exclude {path}"
+parser = "RuffParser"
+order = 2
+warning_threshold = 0.9999
+error_threshold = 0.9
+
+[python.ty]
+command = "{python} -m ty check --output-format concise --color never \"{context_path}\" --exclude .claude{exclude}"
+exclude_format = " --exclude {path}"
+parser = "TyParser"
+order = 3
+warning_threshold = 0.9999
+error_threshold = 0.8
+run_in_target_env = true
+extra_deps = ["ty"]
+
+[python.bandit]
+command = "{python} -m bandit -r {scan_targets} -f json -q -s B101 --severity-level medium{exclude}"
+scan_exclude_names = [".venv", ".claude", "tests"]
+exclude_format = " --exclude {abs_native_path}"
+parser = "BanditParser"
+order = 4
+warning_threshold = 0.9999
+error_threshold = 0.8
+
+[python.pytest]
+command = "{python} -m pytest -vv \"{context_path}\" --ignore .claude{exclude}"
+exclude_format = " --ignore {path}"
+parser = "PytestParser"
+order = 5
+warning_threshold = 1.0
+error_threshold = 1.0
+run_in_target_env = true
+extra_deps = ["pytest"]
+skip_for_file = true
+cache_invariant = "ast"
+
+[python.coverage]
+command = "{python} -m coverage run --omit=*/tests/*,*/test_*.py -m pytest \"{context_path}\" --ignore .claude{exclude} && {python} -m coverage report --show-missing --omit=*/tests/*,*/test_*.py"
+exclude_format = " --ignore {path}"
+parser = "CoverageParser"
+order = 6
+warning_threshold = 0.9
+error_threshold = 0.5
+run_in_target_env = true
+extra_deps = ["coverage", "pytest"]
+skip_for_file = true
+skip_if = "pytest"
+cache_invariant = "ast"
+
+[python.vulture]
+command = "{python} -m vulture \"{context_path}\" --min-confidence 80 --exclude .venv,dist,.*_cache,docs,.git,.claude{exclude}"
+exclude_format = ",{path}"
+parser = "VultureParser"
+order = 7
+warning_threshold = 0.9999
+error_threshold = 0.8
+cache_invariant = "ast"
+
+[python.interrogate]
+command = "{python} -m interrogate \"{context_path}\" -e .claude{exclude} -v --fail-under 0"
+exclude_format = " -e {path}"
+parser = "InterrogateParser"
+order = 8
+warning_threshold = 0.8
+error_threshold = 0.5
+
+[python.interrogate.parser_config]
+skip_empty_init = true
+
+[python.radon-cc]
+command = "{python} -m radon cc --json --exclude '.claude/**' \"{context_path}\""
+parser = "ComplexityParser"
+order = 9
+gate_strict = false
+warning_threshold = 0.6
+error_threshold = 0.4
+
+[python.radon-mi]
+command = "{python} -m radon mi -s --json --exclude '.claude/**' \"{context_path}\""
+parser = "MaintainabilityParser"
+order = 10
+gate_strict = false
+warning_threshold = 0.6
+error_threshold = 0.4
+
+[python.radon-hal]
+command = "{python} -m radon hal -f --json --exclude '.claude/**' \"{context_path}\""
+parser = "HalsteadParser"
+order = 11
+gate_strict = false
+warning_threshold = 0.35
+error_threshold = 0.3
 ```
 
 ## Respect

{python_code_quality-0.2.3.dist-info → python_code_quality-0.3.0.dist-info}/RECORD

@@ -1,35 +1,36 @@
 py_cq/__init__.py,sha256=-C6_QzQeydxft3ndlExTgWnvlqH8fJNPJxfySXULQmU,56
 py_cq/api.py,sha256=AxhTQVX4ACZmgCpdfJgB2_1VXtClxc531NkRoLK1vA0,10118
-py_cq/cli.py,sha256=pP7lKoGE_cW9AGXEfDQMcfpb7inAtn6LJ0-cv0t5ONo,13784
+py_cq/cli.py,sha256=aaLnBXF81fkUtCvO7DGzmogcq50X5bF5dC4XFC4sbqY,13814
 py_cq/config/__init__.py,sha256=f0wc51O_3kGDTZUnCbGv8_zWnC5yYGl4NWcf2buSImQ,670
-py_cq/config/config.toml,sha256=1-S9e5WK6K19FC1_SaGI5dfePuSwCufH0CssZPfIZgE,2921
-py_cq/context_hash.py,sha256=qYPMacgSEwy0nYLCBW8JllNWsGfaSjVq31EFI811ZcU,3449
-py_cq/execution_engine.py,sha256=ap3tDMxVD9x4bq_leq7IGYZgLM-ryJRnrVFSxSy5jK0,16893
+py_cq/config/config.toml,sha256=fco0qKWfIg84e3ex2pmAcSPYBmcHdbiqL-Geo__EIkM,3017
+py_cq/context_hash.py,sha256=uKMkN394v6QYMukZj9usbxnq8px3i1khyIRPKwe09DE,5614
+py_cq/execution_engine.py,sha256=vAbNDCHP5c-2ADWs9SM0eCEpZBiabhpl-WZp6Er3qb4,20644
 py_cq/language_detector.py,sha256=rh5bAA3LyCQR3RODmx_EalqRNYvSYK2SJzh2hIkxOUo,1139
 py_cq/llm_formatter.py,sha256=nCV3nFdxJAi2CnH9FKb5tB-0w-yjLWmjywQI5GJ2cSU,8412
-py_cq/localtypes.py,sha256=kHldvTJlwyoWg0xKbOL-jplLqwKnGmv6aRh95iq8r8Q,7783
+py_cq/localtypes.py,sha256=mt4sqUg1bz2BenirGA18X4CdtyZahTAuKyOfwFnwfSE,7907
 py_cq/main.py,sha256=5dgr8Zk1LNK5M-0wncYVksBp0qE-jWZYqmOXfb1eOhk,400
 py_cq/metric_aggregator.py,sha256=M2ymo62S7p7qPUqjjoiPg4IVyXQhLMuTr9-jxLiFjCY,853
 py_cq/parsers/__init__.py,sha256=uCy7R0cnvDPNvB5aWMLgM3FB9nDcu1jwUmznFMRROSY,28
 py_cq/parsers/banditparser.py,sha256=YqpWljU5D4IhLdtzat7XVGBm9NXrbOQbr9LI9NKybK8,3298
-py_cq/parsers/common.py,sha256=csIv0M7Xq68HjXn37OAD2RfMmoQWaChQ9Jf9lamMkvg,13890
+py_cq/parsers/common.py,sha256=r8UD7pch-txlJSTsJrOff2o3_0WHRlZhgKbJ-C58L7g,13818
 py_cq/parsers/compileparser.py,sha256=jl0DloyXTKqVHRIUft-t5lvJOndY-PdLPrXB38v9zuA,6927
 py_cq/parsers/complexityparser.py,sha256=mX1WHPRgBBc6kOqHfubowRbYXY0E1k4JVwr908Cj10U,5582
-py_cq/parsers/coverageparser.py,sha256=9HtXyAMcQbhsUTb1VNClIHQajBwqCt26H-25t2ZQnY4,8092
+py_cq/parsers/coverageparser.py,sha256=QGjZ8JJF0G-0uiZ07BzxSnblGiysHtOwq0SYvWrtOhA,7441
 py_cq/parsers/exitcodeparser.py,sha256=b4LWIwwklPwCX3MnqNsGQC1slQU56DKE05vJ0OdWVoA,957
 py_cq/parsers/halsteadparser.py,sha256=789c_WWfomskM4i7SUEbKvB67-F2y5nfqt48aFXOusY,10192
-py_cq/parsers/interrogateparser.py,sha256=cc5Q4mOQlLUIPl3XUyH29QJ_JMBzAA7SiPAAiNGDJdM,11546
+py_cq/parsers/interrogateparser.py,sha256=55HZ2j1Rz34eremwGx-W9oIMI21DIqwxEG524UgsAhk,11249
 py_cq/parsers/linecountparser.py,sha256=-hqebwG4j7_QugzGLUUQRcPukGHicV2nbIp1pR8ZcAw,1310
 py_cq/parsers/maintainabilityparser.py,sha256=3a4m93XNtUurw3IxEI1Iae9idgJY6qiEt7HMYl1wTu0,4793
-py_cq/parsers/pytestparser.py,sha256=rhzFzsBEXv1xloOuEjQyBn8Vp0AyGoq2t5siyAwWWaA,11549
+py_cq/parsers/pytestparser.py,sha256=cIaTs2XxgeJlVragLEVTZcrbB-bzfNYYMdUrakRa-rQ,11545
 py_cq/parsers/regexcountparser.py,sha256=zGzHEYDIori6aiWnVkRFixdE7fWt66npAAWjzvpoBF4,1592
 py_cq/parsers/ruffparser.py,sha256=uE0QEaZ4Ch7IsWY_2ZkfHXPU0TYPGsGPfv66hGe5G34,7634
 py_cq/parsers/typarser.py,sha256=x835OrapG1aUteW2NhC5U0bhj1w1pMtbfmbvb74-1AI,8077
 py_cq/parsers/vultureparser.py,sha256=-yGAXzRY4_fzLRTk7dfwDrrRZ-n97j1Ph5_xo3c6TfU,2229
 py_cq/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-py_cq/table_formatter.py,sha256=2_WZ2RHCwsdna0bzP6ZFxB2YtHtW95wxJB1yBXgCIDo,1610
-py_cq/tool_registry.py,sha256=8B6EG7mGCKR6JeHtesFHa79svNfj1PUbboysXfwV7vY,1828
-python_code_quality-0.2.3.dist-info/WHEEL,sha256=wXwAVsgVaOZ_pwDFqQm5Rd6PID-Fc74nkLc8X8gHiDo,81
-python_code_quality-0.2.3.dist-info/entry_points.txt,sha256=cfWbTw7eYO6Trv1-Z_odL6Zta9CqYU6Vk9lAHdfB60Q,40
-python_code_quality-0.2.3.dist-info/METADATA,sha256=dBNJKPiG5BRMtuPT8jUcYMoasGRsP4uQQG9RvFy_xig,15650
-python_code_quality-0.2.3.dist-info/RECORD,,
+py_cq/source_file.py,sha256=Uyv-CSVeliFnE6TpRB4Y15ykFQs4n0r9-amzxXXlqN0,7562
+py_cq/table_formatter.py,sha256=-22nzVIOaDe3QOBmZ2iBPH7ewIEIPEn5WYSjCoB4Hj4,1608
+py_cq/tool_registry.py,sha256=0s0sD9_iQW-HU0SIKSS8CFDlrzW0c-vlYrAFODEHiSc,1894
+python_code_quality-0.3.0.dist-info/WHEEL,sha256=ZFFp7t7R4RYQ5KYZkmiFWoQvHay7SrTmn-6ZYfoFZ3U,80
+python_code_quality-0.3.0.dist-info/entry_points.txt,sha256=cfWbTw7eYO6Trv1-Z_odL6Zta9CqYU6Vk9lAHdfB60Q,40
+python_code_quality-0.3.0.dist-info/METADATA,sha256=hQBSoblR8TKmTPRriXRt5Ed-uO9jexstNj0nPU4Li4A,16213
+python_code_quality-0.3.0.dist-info/RECORD,,

{python_code_quality-0.2.3.dist-info → python_code_quality-0.3.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: uv 0.11.19
+Generator: uv 0.12.7
 Root-Is-Purelib: true
 Tag: py3-none-any