python-code-quality 0.1.7__py3-none-any.whl → 0.1.9__py3-none-any.whl

py_cq/parsers/pytestparser.py

@@ -8,11 +8,33 @@ process return code so downstream components can uniformly consume results
 from multiple test tools.  It is part of the test-collection framework and
 enables consistent handling of pytest output across the system."""
 
-import re
+import re as _re
 
 from py_cq.localtypes import AbstractParser, RawResult, ToolResult
 
 
+def _extract_failure(stdout: str, test_name: str, max_lines: int) -> str:
+    """Extract the failure section for test_name from pytest stdout."""
+    lines = stdout.splitlines()
+    pattern = _re.compile(rf"_{{4,}}\s+{_re.escape(test_name)}\s+_{{4,}}")
+    start = None
+    for i, line in enumerate(lines):
+        if pattern.search(line):
+            start = i + 1
+            break
+    if start is None:
+        return ""
+    collected = []
+    for line in lines[start:]:
+        if line.strip().startswith("_") or line.strip().startswith("="):
+            break
+        collected.append(line)
+        if len(collected) >= max_lines:
+            break
+    text = "\n".join(collected).strip()
+    return f"\n```\n{text}\n```" if text else ""
+
+
 class PytestParser(AbstractParser):
     """Parses raw pytest output into a structured `ToolResult`.
 
@@ -51,14 +73,14 @@ class PytestParser(AbstractParser):
         lines = raw_result.stdout.splitlines()
         tr = ToolResult(raw=raw_result)
         if "no tests ran" in raw_result.stdout:
-            pass
+            tr.metrics["tests"] = 0.0
         else:
             tests_found = dict()
             num_tests = 0
             passed_tests = 0
             for line in lines:
                 # tests/test_common.py::test_name[param] PASSED    [ 8%]
-                tests_match = re.search(r"(.*\.py)::([\w\[\].,+\- ]+) (PASSED|FAILED|ERROR|SKIPPED|XFAIL|XPASS)", line)
+                tests_match = _re.search(r"(.*\.py)::([\w\[\].,+\- ]+) (PASSED|FAILED|ERROR|SKIPPED|XFAIL|XPASS)", line)
                 if tests_match:
                     test_file = tests_match.group(1)
                     test_name = tests_match.group(2).strip()
@@ -67,15 +89,44 @@ class PytestParser(AbstractParser):
                     num_tests += 1
                     if test_status == "PASSED":
                         passed_tests += 1
+            if num_tests == 0:
+                # No individual test lines found (e.g. non-verbose output);
+                # fall back to parsing the pytest summary line.
+                summary = _re.search(r"(\d+) passed(?:.*?(\d+) failed)?", raw_result.stdout)
+                if summary:
+                    passed_tests = int(summary.group(1))
+                    failed_tests = int(summary.group(2)) if summary.group(2) else 0
+                    num_tests = passed_tests + failed_tests
             tr.metrics["tests"] = passed_tests / num_tests if num_tests else 0
             tr.details = tests_found
         return tr
 
-    def format_llm_message(self, tr: ToolResult) -> str:
-        """Return the first failing test as a defect description."""
+    def format_llm_message(self, tr: ToolResult, *, context_lines: int = 15) -> str:
+        """Return the first failing test with function body and failure output."""
+        from py_cq.parsers.common import find_function_source
         for file, tests in tr.details.items():
-            if isinstance(tests, dict):
-                for test_name, status in tests.items():
-                    if status == "FAILED":
-                        return f"`{file}::{test_name}` — test **FAILED**"
+            if not isinstance(tests, dict):
+                continue
+            for test_name, status in tests.items():
+                if status != "FAILED":
+                    continue
+                header = f"`{file}::{test_name}` — test **FAILED**"
+                body = find_function_source(file, test_name, max_lines=context_lines)
+                failure = _extract_failure(tr.raw.stdout, test_name, max_lines=context_lines)
+                parts = [header]
+                if body:
+                    parts.append(body)
+                if failure:
+                    parts.append(failure)
+                return "\n".join(parts)
+        if "no tests ran" in tr.raw.stdout:
+            return (
+                "**No tests found.** This project has no pytest test suite.\n\n"
+                "Add a `tests/` directory with at least one test file (e.g. `tests/test_basic.py`) "
+                "and write a first test covering a core function."
+            )
+        output = (tr.raw.stdout + tr.raw.stderr).strip()
+        if output:
+            tail = "\n".join(output.splitlines()[-30:])
+            return f"pytest reported failures:\n\n```\n{tail}\n```"
         return "pytest reported failures (no details available)"

py_cq/parsers/regexcountparser.py

@@ -0,0 +1,35 @@
+"""Parser that counts stdout lines matching a regex pattern."""
+
+import re
+
+from py_cq.localtypes import AbstractParser, RawResult, ToolResult
+from py_cq.parsers.common import score_logistic_variant
+
+
+class RegexCountParser(AbstractParser):
+    """Score based on the number of stdout lines matching a regex.
+
+    parser_config keys:
+        pattern (str, required): regex pattern to match against each line.
+        scale_factor (int, default 15): passed to score_logistic_variant.
+    """
+
+    def parse(self, raw_result: RawResult) -> ToolResult:
+        pattern = re.compile(self.parser_config["pattern"])
+        scale = self.parser_config.get("scale_factor", 15)
+        lines = (raw_result.stdout or "").splitlines()
+        matches = [ln for ln in lines if pattern.search(ln)]
+        count = len(matches)
+        score = score_logistic_variant(count, scale_factor=scale)
+        return ToolResult(
+            raw=raw_result,
+            metrics={"violations": score},
+            details={"count": count, "matches": matches},
+        )
+
+    def format_llm_message(self, tr: ToolResult, *, context_lines: int = 15) -> str:
+        matches = tr.details.get("matches", [])
+        if not matches:
+            return "No violations found"
+        shown = matches[:context_lines]
+        return "\n".join(shown)

py_cq/parsers/ruffparser.py

@@ -45,7 +45,7 @@ class RuffParser(AbstractParser):
         )
         return ToolResult(raw=raw_result, metrics={"lint": score}, details=files)
 
-    def format_llm_message(self, tr: ToolResult) -> str:
+    def format_llm_message(self, tr: ToolResult, *, context_lines: int = 15) -> str:
         """Return the first lint violation as a defect description."""
         if not tr.details:
             return "ruff reported issues (no details available)"
@@ -54,4 +54,4 @@ class RuffParser(AbstractParser):
         line = issue.get("line", "?")
         code = issue.get("code", "")
         message = issue.get("message", "")
-        return f"`{file}:{line}` — **{code}**: {message}{format_source_context(file, line)}"
+        return f"`{file}:{line}` — **{code}**: {message}{format_source_context(file, line, count=context_lines)}"

py_cq/parsers/typarser.py

@@ -49,7 +49,7 @@ class TyParser(AbstractParser):
         score = score_logistic_variant(weighted, scale_factor=10)
         return ToolResult(raw=raw_result, metrics={"type_check": score}, details=files)
 
-    def format_llm_message(self, tr: ToolResult) -> str:
+    def format_llm_message(self, tr: ToolResult, *, context_lines: int = 15) -> str:
         """Return the first type-check diagnostic as a defect description."""
         if not tr.details:
             return "ty reported issues (no details available)"
@@ -58,4 +58,4 @@ class TyParser(AbstractParser):
         line = issue.get("line", "?")
         code = issue.get("code", "")
         message = issue.get("message", "")
-        return f"`{file}:{line}` — **{code}**: {message}{format_source_context(file, line)}"
+        return f"`{file}:{line}` — **{code}**: {message}{format_source_context(file, line, count=context_lines)}"

py_cq/parsers/vultureparser.py

@@ -36,7 +36,7 @@ class VultureParser(AbstractParser):
         score = score_logistic_variant(count, scale_factor=15)
         return ToolResult(raw=raw_result, metrics={"dead_code": score}, details=files)
 
-    def format_llm_message(self, tr: ToolResult) -> str:
+    def format_llm_message(self, tr: ToolResult, *, context_lines: int = 15) -> str:
         if not tr.details:
             return "vulture reported issues (no details available)"
         file, issues = next(iter(tr.details.items()))
@@ -45,4 +45,4 @@ class VultureParser(AbstractParser):
         kind = issue.get("type", "unused")
         name = issue.get("name", "")
         confidence = issue.get("confidence", "?")
-        return f"`{file}:{line}` — **{kind}** `{name}` ({confidence}% confidence){format_source_context(file, line)}"
+        return f"`{file}:{line}` — **{kind}** `{name}` ({confidence}% confidence){format_source_context(file, line, count=context_lines)}"

py_cq/tool_registry.py

@@ -9,26 +9,27 @@ from py_cq.localtypes import ToolConfig
 
 
 def load_tool_configs() -> dict[str, ToolConfig]:
-    """Load tool configurations from the bundled tools.yaml and return a registry.
+    """Load tool configurations from the bundled config.yaml and return a registry.
 
     Returns:
         dict[str, ToolConfig]: A mapping from tool ID to its configuration instance."""
-    yaml_text = files("py_cq.config").joinpath("tools.yaml").read_text(encoding="utf-8")
+    yaml_text = files("py_cq.config").joinpath("config.yaml").read_text(encoding="utf-8")
     config = yaml.safe_load(yaml_text)
     registry = {}
-    for tool_id, tool_data in config["tools"].items():
+    for tool_id, tool_data in config["python"].items():
         # Dynamically import parser class
         module = import_module(f"py_cq.parsers.{tool_data['parser'].lower()}")
         parser_class = getattr(module, tool_data["parser"])
         registry[tool_id] = ToolConfig(
-            name=tool_data["name"],
+            name=tool_id,
             command=tool_data["command"],
             parser_class=parser_class,
-            priority=tool_data["priority"],
+            order=tool_data["order"],
             warning_threshold=tool_data["warning_threshold"],
             error_threshold=tool_data["error_threshold"],
             run_in_target_env=tool_data.get("run_in_target_env", False),
             extra_deps=tool_data.get("extra_deps", []),
+            parser_config=tool_data.get("parser_config", {}),
         )
     return registry
 

{python_code_quality-0.1.7.dist-info → python_code_quality-0.1.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-code-quality
-Version: 0.1.7
+Version: 0.1.9
 Summary: Python Code Quality Analysis Tool - feed the results from 11 CQ tools straight into an LLM. Minimal tokens.
 Project-URL: Homepage, https://github.com/rhiza-fr/py-cq
 Project-URL: Repository, https://github.com/rhiza-fr/py-cq
@@ -28,14 +28,16 @@ Description-Content-Type: text/markdown
 
 Feed the results from 11+ code quality tools to an LLM. Minimal tokens.
 
+Why? It removes the mental burden of understanding all these tools and parsing their results.
+
 The primary workflow is:
 
 ```bash
 # get the single most critical defect as markdown
 cq check . -o llm
 ```
-Outputs the top error from the first priority tool where the score < warning_threshold,. The code context is expanded if available.
-```md
+
+```python
 `data/problems/travelling_salesman/ts_bad.py:21` — **F841**: Local variable `unused_variable` is assigned to but never used
 
 18:     min_dist = float("inf")
@@ -51,10 +53,13 @@ Please fix only this issue. After fixing, run `cq check . -o llm` to verify.
 ```
 Feed to an LLM with edit tools and repeat until there are no issues, e.g.
 
-```
+```python
 cq check . -o llm | claude -p "fix this"
+# or
+cq check . -o llm | ollama run gpt-oss:20b "Explain how to fix this"
 ```
 
+
 ## Install
 
 ```bash
@@ -62,21 +67,22 @@ cq check . -o llm | claude -p "fix this"
 uv tool install python-code-quality
 
 # or, clone it then install 
-git pull https://github.com/rhiza-fr/py-cq.git
+git clone https://github.com/rhiza-fr/py-cq.git
 cd py-cq
 uv tool install .
 ```
 
 ## Tools
 
-These tools are run in **parallel**:
+These tools are run in **parallel** except:
+When running '-o llm', we run sequentially and exit early at the first error.
 
-| Priority | Tool | Measures |
+| Order | Tool | Measures |
 |----------|------|----------|
 | 1 | compileall | Syntax errors |
-| 2 | bandit | Security vulnerabilities |
-| 3 | ruff | Lint / style |
-| 4 | ty | Type errors |
+| 2 | ruff | Lint / style |
+| 3 | ty | Type errors |
+| 4 | bandit | Security vulnerabilities |
 | 5 | pytest | Test pass rate |
 | 6 | coverage | Test coverage |
 | 7 | radon cc | Cyclomatic complexity |
@@ -85,37 +91,28 @@ These tools are run in **parallel**:
 | 10 | vulture | Dead code |
 | 11 | interrogate | Docstring coverage |
 
-Diskcache is used to cache tool output for lightning fast re-runs. Sane defaults: <100 Mb, <5 days, No pickle
+Diskcache is used to cache tool output for lightning fast re-runs. Sane defaults: <100 Mb, <5 days, No pickle risk.
 
 
 ## Usage
 
 ```bash
-# LLM workflow: get the top defect as markdown (primary use case)
-cq check -o llm
-
-# Rich table with all metrics
-cq check .
-
-# Numeric score only — useful in CI or scripts
-cq check . -o score
-
-# Full JSON output, including raw test results
-cq check . -o json
-
-# Explicit path
-cq check path/to/project/
-cq check path/to/file.py
-
-# Run sequentially if you like things slow
-cq check . --workers 1
+cq check .                 # Table overview of scores for humans
+cq check . -o llm          # Top defect as markdown for LLMs
+cq check . -o score        # Numeric score only for CI
+cq check . -o json         # Detailed parsed JSON output for jq
+cq check . -o raw          # Raw tool output for debug
+cq check path/to/file.py   # Just one file (skips pytest and coverage)
+cq check . --workers 1     # Run sequentially if you like things slow
+cq check . --clear-cache   # Clear cached results before running (rarely needed)
+cq config path/to/project/ # Show effective tool configuration
+```
 
-# Clear cached results before running (rarely needed)
-cq check . --clear-cache
+**Exit codes:** `cq check` exits with code `1` if any tool metric falls below its `error_threshold`, making it suitable as a CI gate:
 
-# Show effective tool configuration (thresholds, enabled/disabled status)
-cq config
-cq config path/to/project/
+```bash
+cq check . && deploy        # block deploy on errors
+cq check . -o score         # print score, exit 1 on errors
 ```
 
 ## Table output
@@ -129,9 +126,9 @@ cq config path/to/project/
 ┃ Tool             ┃     Time ┃                    Metric ┃ Score   ┃ Status   ┃
 ┡━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━╇━━━━━━━━━━┩
 │ compile          │    0.42s │                   compile │ 1.000   │ OK       │
-│ bandit           │    0.56s │                  security │ 1.000   │ OK       │
 │ ruff             │    0.17s │                      lint │ 1.000   │ OK       │
 │ ty               │    0.33s │                type_check │ 1.000   │ OK       │
+│ bandit           │    0.56s │                  security │ 1.000   │ OK       │
 │ pytest           │    0.91s │                     tests │ 1.000   │ OK       │
 │ coverage         │    1.26s │                  coverage │ 0.910   │ OK       │
 │ radon cc         │    0.32s │                simplicity │ 0.982   │ OK       │
@@ -160,30 +157,36 @@ cq config path/to/project/
 ```
 
 ```json
-{
-  "metrics": [
-    {
-      "metrics": {
-        "compile": 1.0
-      },
-      "details": {},
-      "raw": {
-        "tool_name": "compile",
-        "command": ".venv\\Scripts\\python.exe -m compileall -r 10 -j 8 . -x .*venv",
-        "stdout": "Compiling './src/project/file.py'...",
-        "stderr": "",
-        "return_code": 0,
-        "timestamp": "2026-02-19 05:03:11"
-      },
-      "duration_s": 0.08294440002646297
+[
+  {
+    "tool_name": "compile",
+    "metrics": {
+      "compile": 1.0
     },
-    {
-      "metrics": {
-        "security": 1.0
-      }
-      // many more lines ...
-    }
-]}
+    "details": {},
+    "duration_s": 0.05611889995634556
+  }
+  ...
+]
+```
+
+## Raw output
+```bash
+> cq check . -o raw
+```
+
+```json
+[
+  {
+    "tool_name": "compile",
+    "command": "D:\\ai\\py-cq\\.venv\\Scripts\\python.exe -m compileall -r 10 -j 8 . -x .*venv",
+    "stdout": "",
+    "stderr": "",
+    "return_code": 0,
+    "timestamp": "2026-02-20 10:01:22"
+  }
+  ...
+]
 ```
 
 ## Configuration
@@ -195,69 +198,66 @@ Add a `[tool.cq]` section to your project's `pyproject.toml`:
 # Skip tools that are slow or not relevant to your project
 disable = ["coverage", "interrogate"]
 
+# Lines of source context shown around each defect in LLM output (default: 15)
+context_lines = 15
+
 # Override warning/error thresholds per tool
 [tool.cq.thresholds.coverage]
 warning = 0.9
 error = 0.7
 ```
 
-Tool IDs match the keys in `config/tools.yaml`: `compilation`, `bandit`, `ruff`, `ty`, `pytest`, `coverage`, `complexity`, `maintainability`, `halstead`, `vulture`, `interrogate`.
+Tool IDs match the keys in `config/config.yaml`: `compile`, `ruff`, `ty`, `bandit`, `pytest`, `coverage`, `radon-cc`, `radon-mi`, `radon-hal`, `vulture`, `interrogate`.
 
 
 ### Default config
 
 ```yaml
-tools:
+python:
 
-  compilation:
-    name: "compile"
+  compile:
     command: "{python} -m compileall -r 10 -j 8 {context_path} -x .*venv"
     parser: "CompileParser"
-    priority: 1
+    order: 1
     warning_threshold: 0.9999
     error_threshold: 0.9999
 
-  bandit:
-    name: "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"
-    parser: "BanditParser"
-    priority: 2
-    warning_threshold: 0.9999
-    error_threshold: 0.8
-
   ruff:
-    name: "ruff"
     command: "{python} -m ruff check --output-format concise --no-cache {context_path}"
     parser: "RuffParser"
-    priority: 3
+    order: 2
     warning_threshold: 0.9999
     error_threshold: 0.9
 
   ty:
-    name: "ty"
     command: "{python} -m ty check --output-format concise --color never {context_path}"
     parser: "TyParser"
-    priority: 4
+    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"
+    parser: "BanditParser"
+    order: 4
+    warning_threshold: 0.9999
+    error_threshold: 0.8
+
   pytest:
-    name: "pytest"
     command: "{python} -m pytest -v {context_path}"
     parser: "PytestParser"
-    priority: 5
-    warning_threshold: 0.7
-    error_threshold: 0.5
+    order: 5
+    warning_threshold: 1.0
+    error_threshold: 1.0
     run_in_target_env: true
 
   coverage:
-    name: "coverage"
-    command: "{python} -m coverage run -m pytest {context_path} && {python} -m coverage report"
+    command: "{python} -m coverage run --omit=*/tests/*,*/test_*.py -m pytest {context_path} && {python} -m coverage report --omit=*/tests/*,*/test_*.py"
     parser: "CoverageParser"
-    priority: 6
+    order: 6
     warning_threshold: 0.9
     error_threshold: 0.5
     run_in_target_env: true
@@ -265,43 +265,38 @@ tools:
       - coverage
       - pytest
 
-  complexity:
-    name: "radon cc"
+  radon-cc:
     command: "{python} -m radon cc --json {context_path}"
     parser: "ComplexityParser"
-    priority: 7
+    order: 7
     warning_threshold: 0.6
     error_threshold: 0.4
 
-  maintainability:
-    name: "radon mi"
+  radon-mi:
     command: "{python} -m radon mi -s --json {context_path}"
     parser: "MaintainabilityParser"
-    priority: 8
+    order: 8
     warning_threshold: 0.6
     error_threshold: 0.4
 
-  halstead:
-    name: "radon hal"
+  radon-hal:
     command: "{python} -m radon hal -f --json {context_path}"
     parser: "HalsteadParser"
-    priority: 9
+    order: 9
     warning_threshold: 0.5
     error_threshold: 0.3
 
   vulture:
-    name: "vulture"
     command: "{python} -m vulture {context_path} --min-confidence 80 --exclude .venv,dist,.*_cache,docs,.git"
     parser: "VultureParser"
-    priority: 10
+    order: 10
     warning_threshold: 0.9999
     error_threshold: 0.8
 
   interrogate:
-    name: "interrogate"
     command: "{python} -m interrogate {context_path} -v --fail-under 0"
     parser: "InterrogateParser"
-    priority: 11
+    order: 11
     warning_threshold: 0.8
     error_threshold: 0.3
 

python_code_quality-0.1.9.dist-info/RECORD

@@ -0,0 +1,34 @@
+py_cq/__init__.py,sha256=rS7kf1RU1zZskvJlkbZaMqEpdRYPspwDPAFbxzF3tXg,373
+py_cq/cli.py,sha256=wu1GlxSDxS835i9-mO4-xmyBLfr6puU-ES-26T7Mty0,11007
+py_cq/context_hash.py,sha256=h-i7Rhd7AUfLv9SkQvE79bjJvTsm_ZwoVwSmUKXWmfM,2977
+py_cq/execution_engine.py,sha256=tgNGFOO3h-EyetCEzC_RS2K-b9OkOFpOwGwrEAHIpZA,7477
+py_cq/language_detector.py,sha256=6av5HaimcZ54RkN69xQmGgC0mxtTvGzPV3SL8NGG8Uc,1116
+py_cq/llm_formatter.py,sha256=l74O5iqNWMR16789Xncoi93xOqgQJhW5IQK9_OyA9mE,1632
+py_cq/localtypes.py,sha256=jCX1ZuwTixQooEk2N1Gi1XRuDcdBc2NlOdQBKysEybk,6128
+py_cq/main.py,sha256=VKoXI8R8rB2fEROBYoTVURfinLqyh8XTNIIWAOtH7dw,380
+py_cq/metric_aggregator.py,sha256=M2ymo62S7p7qPUqjjoiPg4IVyXQhLMuTr9-jxLiFjCY,853
+py_cq/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+py_cq/tool_registry.py,sha256=oMEkFHkU3gg5UpeGD4zHtynOYmWieRgDN5kTwZ5KsE8,1584
+py_cq/config/__init__.py,sha256=f0wc51O_3kGDTZUnCbGv8_zWnC5yYGl4NWcf2buSImQ,670
+py_cq/config/config.yaml,sha256=R8CjZH8erBQSbJFKgHt-CCwD1Mgj6ZCGQ3OtWH0Ebig,2402
+py_cq/parsers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+py_cq/parsers/banditparser.py,sha256=Ju_CkuXtkVn1Th9aQ6mv6fTUTpb9pc1YD8Nzt_nMgFQ,2326
+py_cq/parsers/common.py,sha256=thbziNjqaf-SY3Y0W-KmPwzlcC-YCV98Z8jubUJM7_4,5203
+py_cq/parsers/compileparser.py,sha256=YsT7ePUDRjsUHTLqgRv4x6jJBCTt6cbm1mgxplzxETg,6256
+py_cq/parsers/complexityparser.py,sha256=2t1-wmNjUu65fULcIm5jcgv7ZLWwjakyiY_r-Fx1QQg,3983
+py_cq/parsers/coverageparser.py,sha256=n4h_RCxKvJoYgp356PA4laAmFcngjQ41b_GXZvKkVgc,4041
+py_cq/parsers/exitcodeparser.py,sha256=ZFL3EbPhGvFjm2qZhfLD1_5dNjR9ULYNQpKgy0Z_dGo,729
+py_cq/parsers/halsteadparser.py,sha256=ZCN7LP1iUZ91tf3tlspKAPQrTEa78XVdE9Fjn9yPvYk,9008
+py_cq/parsers/interrogateparser.py,sha256=G07beMaGR0Mq-pGVozAbwK0xOx9MdMaNVGq2CGrUb7w,2225
+py_cq/parsers/linecountparser.py,sha256=nxWvFntuR8T6FDGpafrlevvt-jR3rwkbVo_t2JX4TF0,1067
+py_cq/parsers/maintainabilityparser.py,sha256=Ax0ZFA6zzqYIWZH1hP1_GUtdVn2LIJ8SKWtqVNdszYs,3411
+py_cq/parsers/pytestparser.py,sha256=3N1X4wKhJ2h-2U1GuM3gHWHpHxU9f0LPGcPaojra9W4,6377
+py_cq/parsers/regexcountparser.py,sha256=KSoNh2spucXU06pxxr2QW0LrPLfJkFMAsmSgjooaFv0,1316
+py_cq/parsers/ruffparser.py,sha256=ZdIya4sct2PrsOyfKfMGmXHLh3Qu7HtFqXNY9IuNFog,2275
+py_cq/parsers/typarser.py,sha256=zrI0KS65MUGPxYPP74B6BRyTbjcPhKyQPjH2KZIyxN0,2495
+py_cq/parsers/vultureparser.py,sha256=U6zC7P0ATA_N4SB90BahKF5QHMITf_z-NsOgrh_Q5rA,1995
+python_code_quality-0.1.9.dist-info/METADATA,sha256=MtSk0DgDh6bkeATKhz03Y8thLZvxxuOcYlvfvOmHkD8,10149
+python_code_quality-0.1.9.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+python_code_quality-0.1.9.dist-info/entry_points.txt,sha256=j5Q_gGr0b7389lddt1JlZ7gcL4Z7RHxuDhij_G-IhBY,39
+python_code_quality-0.1.9.dist-info/licenses/LICENSE,sha256=Bpuh8tbf37so8M5NtRGTLmT5ue7diJ17223L9f9nsT0,1086
+python_code_quality-0.1.9.dist-info/RECORD,,

{python_code_quality-0.1.7.dist-info → python_code_quality-0.1.9.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.28.0
+Generator: hatchling 1.29.0
 Root-Is-Purelib: true
 Tag: py3-none-any