lintro 0.5.3__tar.gz → 0.6.1__tar.gz

{lintro-0.5.3/lintro.egg-info → lintro-0.6.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lintro
-Version: 0.5.3
+Version: 0.6.1
 Summary: A unified CLI tool for code formatting, linting, and quality assurance
 Author-email: TurboCoder13 <turbocoder13@gmail.com>
 License: MIT License
@@ -58,7 +58,7 @@ Requires-Dist: allure-pytest==2.15.0; extra == "dev"
 Requires-Dist: ruff; extra == "dev"
 Requires-Dist: mypy; extra == "dev"
 Requires-Dist: coverage-badge==1.1.2; extra == "dev"
-Requires-Dist: python-semantic-release==10.3.1; extra == "dev"
+Requires-Dist: python-semantic-release==10.3.2; extra == "dev"
 Requires-Dist: assertpy==1.1; extra == "dev"
 Requires-Dist: httpx==0.28.1; extra == "dev"
 Provides-Extra: test
@@ -121,6 +121,7 @@ Lintro is a unified command-line interface that brings together multiple code qu
 | [![Darglint](https://img.shields.io/badge/Darglint-docstrings-3776AB?logo=python&logoColor=white)](https://github.com/terrencepreilly/darglint)     | 🐍 Python           | -        |
 | [![Hadolint](https://img.shields.io/badge/Hadolint-lint-2496ED?logo=docker&logoColor=white)](https://github.com/hadolint/hadolint)                  | 🐳 Dockerfile       | -        |
 | [![Prettier](https://img.shields.io/badge/Prettier-format-1a2b34?logo=prettier&logoColor=white)](https://prettier.io/)                              | 🟨 JS/TS · 🧾 JSON  | ✅       |
+| [![Black](https://img.shields.io/badge/Black-format-000000?logo=python&logoColor=white)](https://github.com/psf/black)                              | 🐍 Python           | ✅       |
 | [![Ruff](https://img.shields.io/badge/Ruff-lint%2Bformat-000?logo=ruff&logoColor=white)](https://github.com/astral-sh/ruff)                         | 🐍 Python           | ✅       |
 | [![Yamllint](https://img.shields.io/badge/Yamllint-lint-cb171e?logo=yaml&logoColor=white)](https://github.com/adrienverge/yamllint)                 | 🧾 YAML             | -        |
 
@@ -216,11 +217,12 @@ lintro check --exclude "migrations,node_modules,dist"
 # Tool-specific options use key=value (lists with |)
 lintro check --tool-options "ruff:line_length=88,prettier:print_width=80"
 
-# Ruff fix configuration (fmt):
-# By default, fmt applies both lint fixes and formatting for Ruff.
-# Disable either stage as needed:
-lintro format --tool-options ruff:lint_fix=False     # format only
-lintro format --tool-options ruff:format=False       # lint fixes only
+# Ruff + Black cooperation:
+# Lintro prefers Ruff for linting and Black for formatting.
+# When Black is configured as a post-check, Lintro disables Ruff formatting by
+# default to avoid double-formatting. Override if needed:
+lintro format --tool-options ruff:format=True        # force Ruff to format
+lintro check  --tool-options ruff:format_check=True  # force Ruff format check
 ```
 
 ### CI/CD Integration

{lintro-0.5.3 → lintro-0.6.1}/README.md

@@ -47,6 +47,7 @@ Lintro is a unified command-line interface that brings together multiple code qu
 | [![Darglint](https://img.shields.io/badge/Darglint-docstrings-3776AB?logo=python&logoColor=white)](https://github.com/terrencepreilly/darglint)     | 🐍 Python           | -        |
 | [![Hadolint](https://img.shields.io/badge/Hadolint-lint-2496ED?logo=docker&logoColor=white)](https://github.com/hadolint/hadolint)                  | 🐳 Dockerfile       | -        |
 | [![Prettier](https://img.shields.io/badge/Prettier-format-1a2b34?logo=prettier&logoColor=white)](https://prettier.io/)                              | 🟨 JS/TS · 🧾 JSON  | ✅       |
+| [![Black](https://img.shields.io/badge/Black-format-000000?logo=python&logoColor=white)](https://github.com/psf/black)                              | 🐍 Python           | ✅       |
 | [![Ruff](https://img.shields.io/badge/Ruff-lint%2Bformat-000?logo=ruff&logoColor=white)](https://github.com/astral-sh/ruff)                         | 🐍 Python           | ✅       |
 | [![Yamllint](https://img.shields.io/badge/Yamllint-lint-cb171e?logo=yaml&logoColor=white)](https://github.com/adrienverge/yamllint)                 | 🧾 YAML             | -        |
 
@@ -142,11 +143,12 @@ lintro check --exclude "migrations,node_modules,dist"
 # Tool-specific options use key=value (lists with |)
 lintro check --tool-options "ruff:line_length=88,prettier:print_width=80"
 
-# Ruff fix configuration (fmt):
-# By default, fmt applies both lint fixes and formatting for Ruff.
-# Disable either stage as needed:
-lintro format --tool-options ruff:lint_fix=False     # format only
-lintro format --tool-options ruff:format=False       # lint fixes only
+# Ruff + Black cooperation:
+# Lintro prefers Ruff for linting and Black for formatting.
+# When Black is configured as a post-check, Lintro disables Ruff formatting by
+# default to avoid double-formatting. Override if needed:
+lintro format --tool-options ruff:format=True        # force Ruff to format
+lintro check  --tool-options ruff:format_check=True  # force Ruff format check
 ```
 
 ### CI/CD Integration

{lintro-0.5.3 → lintro-0.6.1}/docs/README.md

@@ -105,15 +105,16 @@ lintro format
 
 ## 🛠️ Supported Tools
 
-| Tool           | Language/Format  | Purpose              | Documentation                                           |
-| -------------- | ---------------- | -------------------- | ------------------------------------------------------- |
-| **Ruff**       | Python           | Linting & Formatting | [Config Guide](configuration.md#ruff-configuration)     |
-| **Darglint**   | Python           | Docstring Validation | [Analysis](tool-analysis/darglint-analysis.md)          |
-| **Bandit**     | Python           | Security Linting     | [Analysis](tool-analysis/bandit-analysis.md)            |
-| **Prettier**   | JS/TS/JSON/CSS   | Code Formatting      | [Analysis](tool-analysis/prettier-analysis.md)          |
-| **Yamllint**   | YAML             | Syntax & Style       | [Config Guide](configuration.md#yamllint-configuration) |
-| **Actionlint** | GitHub Workflows | Workflow Linting     | [Analysis](tool-analysis/actionlint-analysis.md)        |
-| **Hadolint**   | Dockerfile       | Best Practices       | [Config Guide](configuration.md#hadolint-configuration) |
+| Tool           | Language/Format  | Purpose                 | Documentation                                              |
+| -------------- | ---------------- | ----------------------- | ---------------------------------------------------------- |
+| **Ruff**       | Python           | Linting & Formatting    | [Config Guide](configuration.md#ruff-configuration)        |
+| **Black**      | Python           | Formatting (Post-check) | [Config Guide](configuration.md#post-checks-configuration) |
+| **Darglint**   | Python           | Docstring Validation    | [Analysis](tool-analysis/darglint-analysis.md)             |
+| **Bandit**     | Python           | Security Linting        | [Analysis](tool-analysis/bandit-analysis.md)               |
+| **Prettier**   | JS/TS/JSON/CSS   | Code Formatting         | [Analysis](tool-analysis/prettier-analysis.md)             |
+| **Yamllint**   | YAML             | Syntax & Style          | [Config Guide](configuration.md#yamllint-configuration)    |
+| **Actionlint** | GitHub Workflows | Workflow Linting        | [Analysis](tool-analysis/actionlint-analysis.md)           |
+| **Hadolint**   | Dockerfile       | Best Practices          | [Config Guide](configuration.md#hadolint-configuration)    |
 
 ## 📋 Command Reference
 

{lintro-0.5.3 → lintro-0.6.1}/docs/configuration.md

@@ -69,6 +69,94 @@ format = true      # run `ruff format` during fmt (default true)
 lint_fix = true    # run `ruff check --fix` during fmt (default true)
 ```
 
+### Post-checks Configuration
+
+Black is integrated as a post-check tool by default. Post-checks run after the
+main tools complete and can be configured to enforce failure if issues are
+found. This avoids double-formatting with Ruff and keeps formatting decisions
+explicit.
+
+```toml
+[tool.lintro.post_checks]
+enabled = true
+tools = ["black"]        # Black runs after core tools
+enforce_failure = true   # Fail the run if Black finds issues in check mode
+```
+
+Notes:
+
+- With post-checks enabled for Black, Ruff’s `format`/`format_check` stages can
+  be disabled or overridden via CLI when desired.
+- In `lintro check`, Black runs with `--check` and contributes to failure when
+  `enforce_failure` is true. In `lintro format`, Black formats files in the
+  post-check phase.
+
+#### Black Options via `--tool-options`
+
+You can override Black behavior on the CLI. Supported options include
+`line_length`, `target_version`, `fast`, `preview`, and `diff`.
+
+```bash
+# Increase line length and target a specific Python version
+lintro check --tool-options "black:line_length=100,black:target_version=py313"
+
+# Enable fast and preview modes
+lintro format --tool-options "black:fast=True,black:preview=True"
+
+# Show diffs during formatting (in addition to applying changes)
+lintro format --tool-options "black:diff=True"
+```
+
+These options can also be set in `pyproject.toml` under `[tool.lintro.black]`:
+
+```toml
+[tool.lintro.black]
+line_length = 100
+target_version = "py313"
+fast = false
+preview = false
+diff = false
+```
+
+### Ruff vs Black Policy (Python)
+
+Lintro enforces Ruff-first linting and Black-first formatting when Black is
+configured as a post-check.
+
+- Ruff: primary linter (keep strict rules like `COM812` trailing commas and
+  `E501` line length enabled for checks)
+- Black: primary formatter (applies formatting during post-checks; performs
+  safe line breaking where Ruff’s auto-format may be limited)
+
+Runtime behavior with Black as post-check:
+
+- lintro format
+  - Ruff fixes lint issues only (Ruff `format=False`) unless explicitly
+    overridden
+  - Black performs formatting in the post-check phase
+
+- lintro check
+  - Ruff runs lint checks (Ruff `format_check=False`) unless explicitly
+    overridden
+  - Black runs `--check` as a post-check to enforce formatting
+
+Overrides when needed:
+
+```bash
+# Force Ruff to format during fmt
+lintro format --tool-options ruff:format=True
+
+# Force Ruff to include format check during check
+lintro check --tool-options ruff:format_check=True
+```
+
+Rationale:
+
+- Avoids double-formatting churn (Ruff format followed by Black format) while
+  preserving Ruff’s stricter lint rules (e.g., `COM812`, `E501`).
+- Black’s safe wrapping is preferred for long lines; Ruff continues to enforce
+  lint limits during checks.
+
 ### Python Tools
 
 #### Ruff Configuration

{lintro-0.5.3 → lintro-0.6.1}/docs/getting-started.md

@@ -120,11 +120,18 @@ lintro check src/ tests/ --tools ruff,darglint
 
 # Format Python code
 lintro format src/ --tools ruff
+
+# Run Black as a post-check (configured via pyproject)
+lintro check src/
+
+# Override Black on the fly
+lintro check src/ --tool-options "black:line_length=100,black:target_version=py313"
 ```
 
 **Tools:**
 
 - **Ruff** - Fast Python linter and formatter
+- **Black** - Python formatter (runs as a post-check by default)
 - **Darglint** - Docstring validation
 
 ### JavaScript/TypeScript Projects

{lintro-0.5.3 → lintro-0.6.1}/docs/github-integration.md

@@ -23,6 +23,7 @@ The repository includes pre-configured GitHub Actions workflows. To activate the
 - 📊 **Detailed reporting** in GitHub Actions summaries
 - 🚀 **Multi-tool analysis:**
   - Python: Ruff + Darglint
+  - Python formatting (post-check): Black
   - YAML: Yamllint
   - JSON: Prettier
   - Docker: Hadolint
@@ -248,6 +249,7 @@ jobs:
 
       - name: Run Lintro
         run: |
+          # Run core tools, then post-checks (Black) per pyproject config
           uv run lintro check --output-format grid --output lintro-results.txt
           cat lintro-results.txt
 

{lintro-0.5.3 → lintro-0.6.1}/docs/tool-analysis/README.md

@@ -60,6 +60,14 @@ This directory contains comprehensive analyses comparing Lintro's wrapper implem
 - ⚠️ **Limited**: Runtime rule customization, Docker Compose support, auto-fixing
 - 🚀 **Enhanced**: Issue normalization, Python integration, error parsing
 
+### [Black Analysis](./black-analysis.md)
+
+**Python Code Formatter**
+
+- ✅ **Preserved**: Core formatting, pyproject config, check and write flows
+- ⚙️ **Pass-throughs**: `line_length`, `target_version`, `fast`, `preview`, `diff`
+- 🚀 **Notes**: Cooperates with Ruff via Lintro post-check policy
+
 ## Analysis Framework
 
 Each analysis follows a consistent structure:

lintro-0.6.1/docs/tool-analysis/black-analysis.md

@@ -0,0 +1,111 @@
+# Black Tool Analysis
+
+## Overview
+
+Black is the Python code formatter that provides opinionated, deterministic
+formatting. This analysis compares Lintro's wrapper implementation with the
+core Black tool.
+
+## Core Tool Capabilities
+
+Black provides a stable set of formatting capabilities:
+
+- Code formatting with stable, minimal-diff output
+- Check mode (`--check`) and write mode (default)
+- Configuration via `pyproject.toml`
+- Options such as `--line-length`, `--target-version`, `--fast`, `--preview`,
+  and `--diff`
+
+## Lintro Implementation Analysis
+
+### ✅ Preserved Features
+
+- Formatting via Black with check and write flows
+- Respect for Black's configuration in `pyproject.toml`
+- Standard CLI behavior surfaced through the wrapper
+
+### ⚙️ Runtime Options (Pass-through)
+
+Lintro exposes a subset of Black's CLI options for controlled pass-through:
+
+- `line_length` → `--line-length`
+- `target_version` → `--target-version`
+- `fast` → `--fast`
+- `preview` → `--preview`
+- `diff` → `--diff` (when formatting during fix)
+
+These can be provided via `--tool-options` or through
+`[tool.lintro.black]` in `pyproject.toml`.
+
+```bash
+# CLI overrides
+lintro check . --tool-options "black:line_length=100,black:target_version=py313"
+lintro format . --tool-options "black:fast=True,black:preview=True"
+lintro format . --tool-options "black:diff=True"
+```
+
+```toml
+[tool.lintro.black]
+line_length = 100
+target_version = "py313"
+fast = false
+preview = false
+diff = false
+```
+
+### 🧩 Cooperation with Ruff
+
+When Black is configured as a post-check in Lintro, Ruff focuses on linting by
+default to avoid double-formatting. See the Ruff analysis for details on the
+Ruff↔Black policy and how to override with `--tool-options`.
+
+## Usage Comparison
+
+### Core Black
+
+```bash
+# Check
+black --check src/
+
+# Format
+black src/
+
+# With options
+black --line-length 100 --target-version py313 src/
+```
+
+### Lintro Wrapper
+
+```python
+from lintro.tools.implementations.tool_black import BlackTool
+
+tool = BlackTool()
+tool.set_options(line_length=100, target_version="py313")
+result = tool.check(["src/"])
+# or
+result = tool.fix(["src/"])
+```
+
+With CLI overrides:
+
+```bash
+lintro check src/ --tool-options "black:line_length=100,black:target_version=py313"
+```
+
+## Configuration Strategy
+
+- Primary configuration via Black's own `pyproject.toml`
+- Optional overrides via `[tool.lintro.black]` and `--tool-options`
+- Black can be used as a post-check via `[tool.lintro.post_checks]`
+
+## ⚠️ Limited/Missing Features
+
+- No JSON output; Black output is parsed from text
+- Only a curated subset of Black options are passed through at runtime
+- No stdin-based formatting via wrapper (run core Black for advanced usage)
+
+## Recommendations
+
+- Use Black post-checks to ensure final formatting consistency when combining
+  tools (Ruff for lint; Black for formatting)
+- Prefer `pyproject.toml` for defaults; use `--tool-options` for ad-hoc runs

{lintro-0.5.3 → lintro-0.6.1}/docs/tool-analysis/ruff-analysis.md

@@ -50,6 +50,27 @@ cmd = self._get_executable_command("ruff") + ["format"]
 - ✅ **Fix options**: `fix_only`, `unsafe_fixes`, `show_fixes`
 - ✅ **Formatting control**: `format` boolean to enable/disable formatting
 
+### Cooperation with Black (Policy)
+
+When Black is configured as a post-check in Lintro, Ruff focuses on linting by
+default:
+
+- In `lintro format`, Ruff fixes lint issues while `format=False` unless
+  explicitly overridden via `--tool-options ruff:format=True`.
+- In `lintro check`, Ruff runs lint checks with `format_check=False` unless
+  explicitly overridden via `--tool-options ruff:format_check=True`.
+
+This avoids double-formatting and lets Black handle final formatting. You can
+override either side via CLI or `[tool.lintro.ruff]` and `[tool.lintro.post_checks]`.
+
+```bash
+# Force Ruff to format even with Black post-checks enabled
+lintro format --tool-options "ruff:format=True"
+
+# Force Ruff to include format-check during check
+lintro check --tool-options "ruff:format_check=True"
+```
+
 ### ⚠️ Limited/Missing Features
 
 **Advanced Configuration:**

{lintro-0.5.3 → lintro-0.6.1}/lintro/__init__.py

@@ -1,3 +1,3 @@
 """Lintro - A unified CLI core for code formatting, linting, and quality assurance."""
 
-__version__ = "0.5.3"
+__version__ = "0.6.1"

{lintro-0.5.3 → lintro-0.6.1}/lintro/formatters/tools/actionlint_formatter.py

@@ -54,7 +54,7 @@ class ActionlintTableDescriptor(TableDescriptor):
                     issue.level,
                     issue.code or "",
                     issue.message,
-                ]
+                ],
             )
         return rows
 

{lintro-0.5.3 → lintro-0.6.1}/lintro/formatters/tools/bandit_formatter.py

@@ -38,7 +38,7 @@ class BanditTableDescriptor(TableDescriptor):
                     f"{severity_icon} {issue.issue_severity}",
                     issue.issue_confidence,
                     issue.issue_text,
-                ]
+                ],
             )
         return rows
 

lintro-0.6.1/lintro/formatters/tools/black_formatter.py

@@ -0,0 +1,48 @@
+"""Formatter for Black issues."""
+
+from __future__ import annotations
+
+from lintro.formatters.core.table_descriptor import TableDescriptor
+from lintro.formatters.styles.csv import CsvStyle
+from lintro.formatters.styles.grid import GridStyle
+from lintro.formatters.styles.html import HtmlStyle
+from lintro.formatters.styles.json import JsonStyle
+from lintro.formatters.styles.markdown import MarkdownStyle
+from lintro.formatters.styles.plain import PlainStyle
+from lintro.parsers.black.black_issue import BlackIssue
+from lintro.utils.path_utils import normalize_file_path_for_display
+
+FORMAT_MAP = {
+    "plain": PlainStyle(),
+    "grid": GridStyle(),
+    "markdown": MarkdownStyle(),
+    "html": HtmlStyle(),
+    "json": JsonStyle(),
+    "csv": CsvStyle(),
+}
+
+
+class BlackTableDescriptor(TableDescriptor):
+    def get_columns(self) -> list[str]:
+        return ["File", "Message"]
+
+    def get_rows(self, issues: list[BlackIssue]) -> list[list[str]]:
+        rows: list[list[str]] = []
+        for issue in issues:
+            rows.append(
+                [
+                    normalize_file_path_for_display(issue.file),
+                    issue.message,
+                ],
+            )
+        return rows
+
+
+def format_black_issues(issues: list[BlackIssue], format: str = "grid") -> str:
+    descriptor = BlackTableDescriptor()
+    formatter = FORMAT_MAP.get(format, GridStyle())
+    columns = descriptor.get_columns()
+    rows = descriptor.get_rows(issues)
+    if format == "json":
+        return formatter.format(columns=columns, rows=rows, tool_name="black")
+    return formatter.format(columns=columns, rows=rows)

{lintro-0.5.3 → lintro-0.6.1}/lintro/formatters/tools/darglint_formatter.py

@@ -63,7 +63,9 @@ def format_darglint_issues(
     # For JSON format, pass tool name
     if format == "json":
         formatted_table = formatter.format(
-            columns=columns, rows=rows, tool_name="darglint"
+            columns=columns,
+            rows=rows,
+            tool_name="darglint",
         )
     else:
         # For other formats, use standard formatting

lintro-0.6.1/lintro/parsers/black/black_issue.py

@@ -0,0 +1,22 @@
+"""Black issue models.
+
+This module defines lightweight dataclasses used to represent Black findings
+in a normalized form that Lintro formatters can consume.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass
+class BlackIssue:
+    """Represents a Black formatting issue.
+
+    Attributes:
+        file: Path to the file with a formatting difference.
+        message: Short human-readable description (e.g., "Would reformat file").
+    """
+
+    file: str
+    message: str

lintro-0.6.1/lintro/parsers/black/black_parser.py

@@ -0,0 +1,90 @@
+"""Parser for Black output.
+
+Black commonly emits terse messages like:
+- "would reformat foo.py" (check mode with --check)
+- "reformatted foo.py" (fix mode)
+- a summary line like "1 file would be reformatted" or
+  "2 files reformatted" (with no per-file lines in some environments).
+
+We normalize items into ``BlackIssue`` objects so the table formatter can
+render consistent rows. When only a summary is present, we synthesize one
+``BlackIssue`` per counted file with ``file`` set to "<unknown>" so totals
+remain accurate across environments.
+"""
+
+from __future__ import annotations
+
+import re
+from collections.abc import Iterable
+
+from lintro.parsers.black.black_issue import BlackIssue
+
+_WOULD_REFORMAT = re.compile(r"^would reformat\s+(?P<file>.+)$", re.IGNORECASE)
+_REFORMATTED = re.compile(r"^reformatted\s+(?P<file>.+)$", re.IGNORECASE)
+_SUMMARY_WOULD = re.compile(
+    r"(?P<count>\d+)\s+file(?:s)?\s+would\s+be\s+reformatted\.?",
+    re.IGNORECASE,
+)
+_SUMMARY_REFORMATTED = re.compile(
+    r"(?P<count>\d+)\s+file(?:s)?\s+reformatted\.?",
+    re.IGNORECASE,
+)
+
+
+def _iter_issue_lines(lines: Iterable[str]) -> Iterable[str]:
+    for line in lines:
+        s = line.strip()
+        if not s:
+            continue
+        yield s
+
+
+def parse_black_output(output: str) -> list[BlackIssue]:
+    """Parse Black CLI output into a list of ``BlackIssue`` objects.
+
+    Args:
+        output: Raw stdout+stderr from a Black invocation.
+
+    Returns:
+        list[BlackIssue]: Per-file issues indicating formatting diffs. If only
+        a summary is present (no per-file lines), returns a synthesized list
+        sized to the summary count with ``file`` set to "<unknown>".
+    """
+    if not output:
+        return []
+
+    issues: list[BlackIssue] = []
+    for line in _iter_issue_lines(output.splitlines()):
+        m = _WOULD_REFORMAT.match(line)
+        if m:
+            issues.append(
+                BlackIssue(file=m.group("file"), message="Would reformat file"),
+            )
+            continue
+        m = _REFORMATTED.match(line)
+        if m:
+            issues.append(BlackIssue(file=m.group("file"), message="Reformatted file"))
+            continue
+
+    # Some environments (e.g., CI) may emit only a summary line without listing
+    # per-file entries. In that case, synthesize issues so counts remain
+    # consistent across environments.
+    if not issues:
+        m_sum = _SUMMARY_WOULD.search(output)
+        if not m_sum:
+            m_sum = _SUMMARY_REFORMATTED.search(output)
+        if m_sum:
+            try:
+                count = int(m_sum.group("count"))
+            except Exception:
+                count = 0
+            if count > 0:
+                for _ in range(count):
+                    issues.append(
+                        BlackIssue(
+                            file="<unknown>",
+                            message="Formatting change detected",
+                        ),
+                    )
+
+    return issues

{lintro-0.5.3 → lintro-0.6.1}/lintro/parsers/darglint/darglint_parser.py

@@ -56,7 +56,7 @@ def parse_darglint_output(output: str) -> list[DarglintIssue]:
                 line=int(line_num),
                 code=code,
                 message=full_message,
-            )
+            ),
         )
         i = j
     return issues

{lintro-0.5.3 → lintro-0.6.1}/lintro/parsers/hadolint/hadolint_parser.py

@@ -32,7 +32,7 @@ def parse_hadolint_output(output: str) -> list[HadolintIssue]:
 
     # Pattern for hadolint output: filename:line code level: message
     pattern: re.Pattern[str] = re.compile(
-        r"^(.+?):(\d+)\s+([A-Z]+\d+)\s+(error|warning|info|style):\s+(.+)$"
+        r"^(.+?):(\d+)\s+([A-Z]+\d+)\s+(error|warning|info|style):\s+(.+)$",
     )
 
     lines: list[str] = output.splitlines()
@@ -59,7 +59,7 @@ def parse_hadolint_output(output: str) -> list[HadolintIssue]:
                     level=level,
                     code=code,
                     message=message.strip(),
-                )
+                ),
             )
 
     return issues