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

py_cq/api.py

@@ -148,13 +148,14 @@ class CQ:
         if clear_cache:
             _cache.clear()
 
-    def raw(self, *, early_exit: bool = False) -> list[ToolResult]:
+    def raw(self, *, early_exit: bool = False, order: str = "severity") -> list[ToolResult]:
         """Run all tools and return parsed results before aggregation."""
         return run_tools(
             self._registry.values(),
             str(self.path),
             self._workers,
             early_exit=early_exit,
+            order=order,
             excludes=self._excludes,
         )
 
@@ -168,22 +169,42 @@ class CQ:
         limit: int = 1,
         silence: list[str] | None = None,
         hint: bool = False,
+        order: str = "severity",
     ) -> dict:
         """Return the top defect as a dict with keys: id, file, project, message.
 
-        Stops running tools after the first error (early_exit) for speed.
+        Stops running tools after the first issue (early_exit) for speed.
+        ``order="phase"`` selects the first issue of the earliest non-clean
+        phase (dependency order); ``"severity"`` (default) selects the most
+        severe issue first.
         """
-        results = self.raw(early_exit=True)
+        _silence = silence or []
+        results = self.raw(early_exit=True, order=order)
         combined = aggregate_metrics(str(self.path), results)
-        return format_for_llm_json(
+        issue = format_for_llm_json(
             self._registry,
             combined,
             context_lines=self._context_lines,
             hint=hint,
             limit=limit,
-            silence=silence or [],
+            silence=_silence,
             project_root=self._project_root,
         )
+        if issue.get("id") is None and _silence:
+            # Early-exit stopped at a phase whose only issues are silenced.
+            # Re-run all tools to surface issues in later phases.
+            results = self.raw(early_exit=False, order=order)
+            combined = aggregate_metrics(str(self.path), results)
+            issue = format_for_llm_json(
+                self._registry,
+                combined,
+                context_lines=self._context_lines,
+                hint=hint,
+                limit=limit,
+                silence=_silence,
+                project_root=self._project_root,
+            )
+        return issue
 
     def is_fixed(self, fingerprint: str) -> bool:
         """Return True if the fingerprinted issue is no longer present.

py_cq/cli.py

@@ -67,6 +67,13 @@ class OutputMode(str, Enum):
     RAW = "raw"
 
 
+class OrderMode(str, Enum):
+    """Selection order for the top issue in -o llm/llm-json."""
+
+    SEVERITY = "severity"
+    PHASE = "phase"
+
+
 def _version_callback(value: bool) -> None:
     if not value:
         return
@@ -159,6 +166,11 @@ def check(
         "-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(
+        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)",
+    ),
 ):
     """Feed the results from 11+ code quality tools to an LLM. Try: cq check . -o llm"""  # --help
     path_obj = Path(path)
@@ -200,7 +212,7 @@ def check(
 
     is_llm = output in (OutputMode.LLM, OutputMode.LLM_JSON)
     t0 = time.perf_counter()
-    tool_results = cq.raw(early_exit=is_llm)
+    tool_results = cq.raw(early_exit=is_llm, order=order.value)
     total_s = time.perf_counter() - t0
     combined = aggregate_metrics(path, tool_results)
 

py_cq/config/config.toml

@@ -53,43 +53,47 @@ error_threshold = 0.5
 run_in_target_env = true
 extra_deps = ["coverage", "pytest"]
 skip_for_file = true
+skip_if = "pytest"
+
+[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
+
+[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 = 7
+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 = 8
+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 = 9
-warning_threshold = 0.5
-error_threshold = 0.3
-
-[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 = 10
-warning_threshold = 0.9999
-error_threshold = 0.8
-
-[python.interrogate]
-command = "{python} -m interrogate \"{context_path}\" -e .claude{exclude} -v --fail-under 0"
-exclude_format = " -e {path}"
-parser = "InterrogateParser"
 order = 11
-warning_threshold = 0.8
+gate_strict = false
+warning_threshold = 0.35
 error_threshold = 0.3
-
-[python.interrogate.parser_config]
-skip_empty_init = true

py_cq/context_hash.py

@@ -41,12 +41,15 @@ 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:
             # Use follow_symlinks=False to prevent cache poisoning from
             # symlinks pointing outside the project tree (M-2)
-            if entry.is_file(follow_symlinks=False) and entry.name.endswith(".py"):
+            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 [

py_cq/execution_engine.py

@@ -18,6 +18,7 @@ import shlex
 import shutil
 import subprocess
 import sys
+import tempfile
 import time
 from collections.abc import Collection
 from concurrent.futures import ThreadPoolExecutor, as_completed
@@ -215,16 +216,24 @@ def run_tool(
     # All user-supplied values (context_path, excludes) are properly quoted
     # via shlex.quote() to prevent injection - see _build_exclude_str and
     # the uv command assembly above.
+    if run_env is None:
+        run_env = dict(os.environ)
+    _fd, coverage_tmp = tempfile.mkstemp(prefix=".coverage.cq.")
+    os.close(_fd)
+    run_env["COVERAGE_FILE"] = coverage_tmp
     t_sub0 = time.perf_counter()
-    result = subprocess.run(
-        command,
-        capture_output=True,
-        text=True,
-        shell=True,
-        encoding="utf-8",
-        errors="replace",
-        env=run_env,
-    )  # nosec
+    try:
+        result = subprocess.run(
+            command,
+            capture_output=True,
+            text=True,
+            shell=True,
+            encoding="utf-8",
+            errors="replace",
+            env=run_env,
+        )  # nosec
+    finally:
+        Path(coverage_tmp).unlink(missing_ok=True)
     t_sub = time.perf_counter() - t_sub0
     log.debug(
         f"{tool_config.name}: [MISS] cache={t_cache * 1000:.1f}ms tool={t_sub * 1000:.0f}ms: {command}"
@@ -248,6 +257,7 @@ def run_tools(
     path: str,
     max_workers: int = 0,
     early_exit: bool = False,
+    order: str = "severity",
     excludes: list[str] | None = None,
     project_root: str | None = None,
 ) -> list[ToolResult]:
@@ -327,28 +337,71 @@ def run_tools(
                     log.warning(f"Early exit: skipped {n_skipped} tool(s): {remaining}")
                 break
             _, tr = prioritized[-1]
-            if tr.metrics and min(tr.metrics.values()) < tool_config.error_threshold:
+            # order="phase" stops at the first phase with *any* finding (not
+            # clean), so phase order is absolute and independent of error/warning
+            # threshold tuning; "severity" stops at the first error.
+            threshold = (
+                tool_config.warning_threshold
+                if order == "phase"
+                else tool_config.error_threshold
+            )
+            if tr.metrics and min(tr.metrics.values()) < threshold:
                 n_skipped = n_total - i - 1
                 if n_skipped:
                     remaining = ", ".join(tc.name for tc in sorted_configs[i + 1 :])
                     log.debug(
-                        f"Error threshold hit at {tool_config.name}: skipped {n_skipped} tool(s): {remaining}"
+                        f"{'Not clean' if order == 'phase' else 'Error threshold hit'} at {tool_config.name}: skipped {n_skipped} tool(s): {remaining}"
                     )
                 break
         log.info(f"cq run_tools elapsed: {time.perf_counter() - t_start:.2f}s")
         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)
+    name_to_future: dict[str, Any] = {}
     with ThreadPoolExecutor(max_workers=max_workers or len(tool_configs)) as executor:
-        future_to_tool = {
-            executor.submit(_run_and_parse, tool_config): tool_config
-            for tool_config in tool_configs
-        }
-        timings: list[tuple[int, str, float]] = []
+        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)
+            future_to_tool[f] = tc
+            name_to_future[tc.name] = f
         for future in as_completed(future_to_tool):
             tool_config = future_to_tool[future]
             try:
-                order, tr = future.result()
-                prioritized.append((order, tr))
-                timings.append((order, tool_config.name, tr.duration_s))
+                tc_order, tr = future.result()
+                prioritized.append((tc_order, tr))
+                timings.append((tc_order, tool_config.name, tr.duration_s))
             except Exception as exc:
                 log.error(f"{tool_config.name} generated an exception: {exc}")
     per_tool = ", ".join(f"{name}={dur:.2f}s" for _, name, dur in sorted(timings))

py_cq/localtypes.py

@@ -43,7 +43,7 @@ class ToolConfig:
 
     name: str  # e.g., "pytest", "coverage", "pydocstyle"
     command: str  # The command to execute (can include placeholders)
-    parser_class: Callable  # Name of the parser class to use
+    parser_class: Callable  # The parser class itself (resolved from its name in config)
     context_path: str = ""  # Path to project or file
     order: int = 5  # 1=first (compilation), 11=last (style)
     warning_threshold: float = 0.7  # Yellow warning if below this
@@ -60,6 +60,8 @@ class ToolConfig:
         default_factory=list
     )  # Top-level dir/file names to omit from {scan_targets}
     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
 
 
 @dataclass
@@ -123,10 +125,12 @@ class ToolResult:
         }
 
 
-@dataclass
 class CombinedToolResults:
     """Aggregates results from multiple tools, stores the associated path, and calculates an overall score by averaging the mean metric values of each ``ToolResult``. If a ``ToolResult`` has no metrics, it contributes zero, and the score defaults to ``0.0`` when the list is empty."""
 
+    score: float
+    path: str
+
     def __init__(self, path: str, tool_results: list[ToolResult]):
         """Initializes a CombinedToolResults instance.
 
@@ -148,9 +152,6 @@ class CombinedToolResults:
             else 0.0
         )
 
-    score: float = 0.0
-    path: str = ""
-
     def to_dict(self) -> dict:
         """Returns a dictionary containing the path, overall score, and each ToolResult serialized."""
         return {
@@ -163,7 +164,7 @@ class CombinedToolResults:
 class AbstractParser(ABC):
     """Base class for parsers that transform raw tool output into structured `ToolResult` objects.
 
-    Subclasses must implement `parse` to convert a `RawResult` into a `ToolResult`. An optional `provide_help` can be overridden to supply contextual guidance for a parsed result."""
+    Subclasses must implement `parse` to convert a `RawResult` into a `ToolResult`. The `format_llm_message` method can be overridden to supply a richer single-defect description for a parsed result."""
 
     def __init__(self, parser_config: dict | None = None):
         self.parser_config = parser_config or {}

py_cq/parsers/common.py

@@ -1,16 +1,18 @@
-"""Utility functions for normalising numeric values and scoring error magnitudes.
-
-This module provides two small helpers that are often used when working with
-performance metrics or error scores:
-
-* :func:`inv_normalize` - Inversely normalises a value relative to a maximum
-  reference, yielding a float in the interval [0,\u202f1].
-* :func:`score_logistic_variant` - Maps an error magnitude to a bounded score
-  using a logistic-style curve, with optional parameters controlling the scale
-  and steepness of the transition.
-
-Both functions return a float and can be used directly in downstream analytics,
-visualisation or decision-making pipelines."""
+"""Shared helpers used across parsers and the LLM formatter.
+
+This module groups small utilities for several concerns:
+
+* Scoring - :func:`inv_normalize` and :func:`score_logistic_variant` map error
+  magnitudes to bounded ``[0, 1]`` scores.
+* Source context - :func:`read_source_lines`, :func:`format_source_context`,
+  :func:`find_function_source`, :func:`find_enclosing_function`, and
+  :func:`enclosing_function_range` extract fenced code snippets for LLM prompts.
+* Project navigation - :func:`find_in_project`, :func:`format_callee_context`,
+  :func:`extract_callee_name`, :func:`resolve_path`, and :func:`_relative_path`
+  locate and reference definitions across a project tree.
+* Output formatting - :func:`format_issue_header` builds issue headers.
+* Parsing - :func:`parse_json_dict` and :func:`extract_first_issue` read tool
+  output into Python structures."""
 
 import json
 import re

py_cq/parsers/complexityparser.py

@@ -74,6 +74,8 @@ class ComplexityParser(AbstractParser):
         num_items = 0
         max_complexity = 30
         for file, functions in data.items():
+            if not isinstance(functions, list):
+                continue
             file_name = file.replace("\\", "/")
             if file_name not in tr.details:
                 tr.details[file_name] = {}

py_cq/parsers/coverageparser.py

@@ -146,6 +146,8 @@ class CoverageParser(AbstractParser):
             ]
 
         tr.details = details
+        if "coverage" not in tr.metrics:
+            tr.metrics["coverage"] = 0.0
         return tr
 
     def format_llm_message(
@@ -199,4 +201,6 @@ class CoverageParser(AbstractParser):
                 parts.append(f"\nAdd tests to: {location}")
 
             return "\n".join(parts)
+        if tr.metrics.get("coverage", 1.0) == 0.0:
+            return "**Coverage: 0%** - pytest failed or collected no tests, so no coverage data is available."
         return ""

py_cq/parsers/halsteadparser.py

@@ -83,11 +83,12 @@ class HalsteadParser(AbstractParser):
                     "functions": {},
                 }
             if "error" in values:
+                tr.details[file_name]["error"] = values["error"]
                 min_file_nb = 0.0
                 min_file_sm = 0.0
                 min_function_nb = 0.0
                 min_function_sm = 0.0
-                tr.details[file_name]["error"] = values["error"]
+                continue
             if "total" in values:
                 nb, sm = self.extract_bugs_and_volume(
                     values.get("total", {}), MAX_FILE_BUGS, MAX_FILE_VOLUME
@@ -106,7 +107,7 @@ class HalsteadParser(AbstractParser):
                     min_function_nb = min(nb, min_function_nb)
                     min_function_sm = min(sm, min_function_sm)
                     tr.details[file_name]["functions"][function] = {
-                        "no_bugs": nb,
+                        "bug_free": nb,
                         "smallness": sm,
                         "bugs": function_values.get("bugs", 0),
                         "volume": function_values.get("volume", 0),
@@ -141,7 +142,7 @@ class HalsteadParser(AbstractParser):
         for file_name, file_data in tr.details.items():
             if is_function_metric:
                 for func_name, func_data in file_data.get("functions", {}).items():
-                    s = func_data.get("no_bugs" if is_bug_metric else "smallness", 1.0)
+                    s = func_data.get("bug_free" if is_bug_metric else "smallness", 1.0)
                     if s < worst_score:
                         worst_score = s
                         worst_file = file_name

py_cq/parsers/ruffparser.py

@@ -123,7 +123,7 @@ def _format_F821(file: str, line: int, message: str) -> str:
         base += f"\n\nOther references to `{name}` in this file:\n{ref_lines}"
     else:
         base += f"\n\n`{name}` is not imported or defined anywhere else in this file."
-    if enclosing:
+    if enclosing and enclosing not in base:
         base += f"\n\nEnclosing function:{enclosing}"
     return base
 

py_cq/tool_registry.py

@@ -32,6 +32,8 @@ def load_tool_configs() -> dict[str, ToolConfig]:
             exclude_format=tool_data.get("exclude_format", ""),
             scan_exclude_names=tool_data.get("scan_exclude_names", []),
             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", ""),
         )
     return registry
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-code-quality
-Version: 0.2.1
+Version: 0.2.3
 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>

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

@@ -1,35 +1,35 @@
 py_cq/__init__.py,sha256=-C6_QzQeydxft3ndlExTgWnvlqH8fJNPJxfySXULQmU,56
-py_cq/api.py,sha256=iyiL5WDdQDYSwkqmZ_AuFY8-uJ-mM9WWAQhpdjqVk20,9170
-py_cq/cli.py,sha256=5Vw3BPyqjKPeWQBXYCMs_ps7WJmjdhxQFgaNS9lAxiQ,13391
+py_cq/api.py,sha256=AxhTQVX4ACZmgCpdfJgB2_1VXtClxc531NkRoLK1vA0,10118
+py_cq/cli.py,sha256=pP7lKoGE_cW9AGXEfDQMcfpb7inAtn6LJ0-cv0t5ONo,13784
 py_cq/config/__init__.py,sha256=f0wc51O_3kGDTZUnCbGv8_zWnC5yYGl4NWcf2buSImQ,670
-py_cq/config/config.toml,sha256=L8WKLQg4utDvV1ZwcOCSi6uJAtE1mZPvY-_HJVOT2dk,2841
-py_cq/context_hash.py,sha256=UKVrKpBYYw68tVcSAs6ZXkHXV3asQvsn6R9NINOHQ4M,3323
-py_cq/execution_engine.py,sha256=GdrLk8Gok5Kf1FSr39LqMfj1GOoLyJeSfU9qWT_7n4Y,14147
+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/language_detector.py,sha256=rh5bAA3LyCQR3RODmx_EalqRNYvSYK2SJzh2hIkxOUo,1139
 py_cq/llm_formatter.py,sha256=nCV3nFdxJAi2CnH9FKb5tB-0w-yjLWmjywQI5GJ2cSU,8412
-py_cq/localtypes.py,sha256=ELzOFOFlrLSq5Wgj5LvBIPhWR8wfe7lQYkcbINhqE3A,7559
+py_cq/localtypes.py,sha256=kHldvTJlwyoWg0xKbOL-jplLqwKnGmv6aRh95iq8r8Q,7783
 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=dU5JCbPJdngbtPjSqnP0kxT2Oux5D-iYiaBMz8KcZCw,13672
+py_cq/parsers/common.py,sha256=csIv0M7Xq68HjXn37OAD2RfMmoQWaChQ9Jf9lamMkvg,13890
 py_cq/parsers/compileparser.py,sha256=jl0DloyXTKqVHRIUft-t5lvJOndY-PdLPrXB38v9zuA,6927
-py_cq/parsers/complexityparser.py,sha256=dOUCpCDcpNaQXZx_xC61X4dTMktDb9x_nh9tDoWjb5g,5509
-py_cq/parsers/coverageparser.py,sha256=t15CFfTJv1QorhopyurDvY7Jr5JJOMLfet0fqttU3O0,7848
+py_cq/parsers/complexityparser.py,sha256=mX1WHPRgBBc6kOqHfubowRbYXY0E1k4JVwr908Cj10U,5582
+py_cq/parsers/coverageparser.py,sha256=9HtXyAMcQbhsUTb1VNClIHQajBwqCt26H-25t2ZQnY4,8092
 py_cq/parsers/exitcodeparser.py,sha256=b4LWIwwklPwCX3MnqNsGQC1slQU56DKE05vJ0OdWVoA,957
-py_cq/parsers/halsteadparser.py,sha256=cfUNsLUYt74NMQW1sBkktn8AH7jQ_EU5IMFrLgIdk5M,10165
+py_cq/parsers/halsteadparser.py,sha256=789c_WWfomskM4i7SUEbKvB67-F2y5nfqt48aFXOusY,10192
 py_cq/parsers/interrogateparser.py,sha256=cc5Q4mOQlLUIPl3XUyH29QJ_JMBzAA7SiPAAiNGDJdM,11546
 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/regexcountparser.py,sha256=zGzHEYDIori6aiWnVkRFixdE7fWt66npAAWjzvpoBF4,1592
-py_cq/parsers/ruffparser.py,sha256=ofQyVUuc0JK-6pVdwsRZteCWmNBOIfHzZloVPSH7_wI,7608
+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=kWmGsqc_0ryYiW-hqUh03WdY1SJQ0wn5Z5ydH72VJK4,1718
-python_code_quality-0.2.1.dist-info/WHEEL,sha256=Q9FtwzuR2QE37l-JIkuyklGnJJiCBHKnsPVQ9vzCMzQ,81
-python_code_quality-0.2.1.dist-info/entry_points.txt,sha256=cfWbTw7eYO6Trv1-Z_odL6Zta9CqYU6Vk9lAHdfB60Q,40
-python_code_quality-0.2.1.dist-info/METADATA,sha256=fXzBeBOrxJ9jO-fglDIUiZiqCnxjnN1f4OBcsBX4gn8,15650
-python_code_quality-0.2.1.dist-info/RECORD,,
+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,,

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

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