pyrepair 1.0.0__tar.gz

pyrepair-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 PyRepair Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pyrepair-1.0.0/PKG-INFO

@@ -0,0 +1,194 @@
+Metadata-Version: 2.4
+Name: pyrepair
+Version: 1.0.0
+Summary: Repair broken Python code before formatting it.
+Author: Sandeep Kumar Mehta
+License: MIT
+Keywords: python,linter,formatter,repair,indentation,syntax
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Quality Assurance
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: typer>=0.12
+Requires-Dist: rich>=13.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: pytest-cov>=5.0; extra == "dev"
+Dynamic: license-file
+
+# PyRepair
+
+> **Repair broken Python code before formatting it.**
+
+Tools like Black, Ruff, and autopep8 require *valid* Python. PyRepair sits upstream — it fixes indentation errors, tab/space mixes, and missing block bodies so those tools can run.
+
+```
+Broken Python → PyRepair → Valid Python → Black/Ruff → Clean Python
+```
+
+---
+
+## Installation
+
+```bash
+pip install pyrepair
+```
+
+Or install from source:
+
+```bash
+git clone https://github.com/sandeep-kumar-mehta/pyrepair.git
+cd pyrepair
+pip install -e ".[dev]"
+```
+
+---
+
+## Quick Start
+
+```bash
+# Repair a single file in-place
+pyrepair broken.py
+
+# Preview changes without writing (safe)
+pyrepair broken.py --dry-run
+
+# Repair all .py files in a directory
+pyrepair src/
+
+# Create a backup before writing
+pyrepair broken.py --backup
+
+# Show detailed issue table
+pyrepair broken.py --report
+```
+
+---
+
+## What Gets Fixed
+
+| Rule | What It Does |
+|---|---|
+| `tabs_to_spaces` | Converts leading `\t` to 4 spaces |
+| `mixed_indent` | Fixes lines that mix tabs and spaces |
+| `indentation_repair` | Indents body of `if`/`for`/`while`/`def`/`class` blocks |
+| `missing_block` | Inserts `pass` when a compound statement has no body |
+
+---
+
+## CLI Reference
+
+```
+pyrepair [TARGET] [OPTIONS]
+
+Arguments:
+  TARGET    Python file or directory to repair.
+
+Options:
+  --dry-run     Show diff only. Do NOT write changes.
+  --backup      Save .bak copy before overwriting.
+  --report, -r  Print detailed issue table for each file.
+  --help        Show this message and exit.
+```
+
+---
+
+## Python API
+
+```python
+from pathlib import Path
+from pyrepair import RepairEngine
+
+engine = RepairEngine()
+
+# Repair a file (returns RepairResult — does NOT write to disk)
+result = engine.repair_file(Path("broken.py"))
+
+print(result.status)           # RepairStatus.SUCCESS
+print(result.total_issues)     # 5
+print(result.total_fixed)      # 5
+print(result.validation_passed)# True
+print(result.repaired_source)  # fixed source code string
+
+# Repair a raw string
+result = engine.repair_source("if True:\nprint('hi')\n")
+```
+
+---
+
+## Adding Custom Rules
+
+```python
+from pyrepair import RepairEngine
+from pyrepair.repair_engine import RepairRule
+from pyrepair.models import Issue, Severity
+
+class RemoveDebugPrintsRule(RepairRule):
+    name = "remove_debug_prints"
+    description = "Remove debug print statements."
+
+    def detect(self, source: str) -> list[Issue]:
+        issues = []
+        for i, line in enumerate(source.splitlines(), 1):
+            if 'print("DEBUG' in line:
+                issues.append(Issue(
+                    rule_name=self.name,
+                    description="Debug print found.",
+                    line_number=i,
+                    severity=Severity.WARNING,
+                    original=line,
+                ))
+        return issues
+
+    def repair(self, source: str) -> str:
+        lines = [l for l in source.splitlines() if 'print("DEBUG' not in l]
+        return "\n".join(lines)
+
+engine = RepairEngine()
+engine.add_rule(RemoveDebugPrintsRule())
+```
+
+---
+
+## Architecture
+
+```
+pyrepair/
+├── cli.py            ← Typer CLI (no business logic)
+├── scanner.py        ← File discovery
+├── repair_engine.py  ← Rule pipeline + RepairEngine
+├── models.py         ← Pure data classes (Issue, RepairResult)
+├── report.py         ← Rich terminal output
+└── utils.py          ← Shared helpers (read/write/validate)
+```
+
+Layers are kept separate (SOLID). The CLI only calls the engine and reporter.
+
+---
+
+## Roadmap
+
+**v1.0**  Indentation repair, tab conversion, missing block, AST validation
+
+**v2.0** Unused/duplicate import detection, import sorting, dead code detection
+
+**v3.0** VS Code extension, HTML reports
+
+---
+
+## Contributing
+
+See [CONTRIBUTING.md](CONTRIBUTING.md).
+
+---
+
+## License
+
+MIT — see [LICENSE](LICENSE).

pyrepair-1.0.0/README.md

@@ -0,0 +1,169 @@
+# PyRepair
+
+> **Repair broken Python code before formatting it.**
+
+Tools like Black, Ruff, and autopep8 require *valid* Python. PyRepair sits upstream — it fixes indentation errors, tab/space mixes, and missing block bodies so those tools can run.
+
+```
+Broken Python → PyRepair → Valid Python → Black/Ruff → Clean Python
+```
+
+---
+
+## Installation
+
+```bash
+pip install pyrepair
+```
+
+Or install from source:
+
+```bash
+git clone https://github.com/sandeep-kumar-mehta/pyrepair.git
+cd pyrepair
+pip install -e ".[dev]"
+```
+
+---
+
+## Quick Start
+
+```bash
+# Repair a single file in-place
+pyrepair broken.py
+
+# Preview changes without writing (safe)
+pyrepair broken.py --dry-run
+
+# Repair all .py files in a directory
+pyrepair src/
+
+# Create a backup before writing
+pyrepair broken.py --backup
+
+# Show detailed issue table
+pyrepair broken.py --report
+```
+
+---
+
+## What Gets Fixed
+
+| Rule | What It Does |
+|---|---|
+| `tabs_to_spaces` | Converts leading `\t` to 4 spaces |
+| `mixed_indent` | Fixes lines that mix tabs and spaces |
+| `indentation_repair` | Indents body of `if`/`for`/`while`/`def`/`class` blocks |
+| `missing_block` | Inserts `pass` when a compound statement has no body |
+
+---
+
+## CLI Reference
+
+```
+pyrepair [TARGET] [OPTIONS]
+
+Arguments:
+  TARGET    Python file or directory to repair.
+
+Options:
+  --dry-run     Show diff only. Do NOT write changes.
+  --backup      Save .bak copy before overwriting.
+  --report, -r  Print detailed issue table for each file.
+  --help        Show this message and exit.
+```
+
+---
+
+## Python API
+
+```python
+from pathlib import Path
+from pyrepair import RepairEngine
+
+engine = RepairEngine()
+
+# Repair a file (returns RepairResult — does NOT write to disk)
+result = engine.repair_file(Path("broken.py"))
+
+print(result.status)           # RepairStatus.SUCCESS
+print(result.total_issues)     # 5
+print(result.total_fixed)      # 5
+print(result.validation_passed)# True
+print(result.repaired_source)  # fixed source code string
+
+# Repair a raw string
+result = engine.repair_source("if True:\nprint('hi')\n")
+```
+
+---
+
+## Adding Custom Rules
+
+```python
+from pyrepair import RepairEngine
+from pyrepair.repair_engine import RepairRule
+from pyrepair.models import Issue, Severity
+
+class RemoveDebugPrintsRule(RepairRule):
+    name = "remove_debug_prints"
+    description = "Remove debug print statements."
+
+    def detect(self, source: str) -> list[Issue]:
+        issues = []
+        for i, line in enumerate(source.splitlines(), 1):
+            if 'print("DEBUG' in line:
+                issues.append(Issue(
+                    rule_name=self.name,
+                    description="Debug print found.",
+                    line_number=i,
+                    severity=Severity.WARNING,
+                    original=line,
+                ))
+        return issues
+
+    def repair(self, source: str) -> str:
+        lines = [l for l in source.splitlines() if 'print("DEBUG' not in l]
+        return "\n".join(lines)
+
+engine = RepairEngine()
+engine.add_rule(RemoveDebugPrintsRule())
+```
+
+---
+
+## Architecture
+
+```
+pyrepair/
+├── cli.py            ← Typer CLI (no business logic)
+├── scanner.py        ← File discovery
+├── repair_engine.py  ← Rule pipeline + RepairEngine
+├── models.py         ← Pure data classes (Issue, RepairResult)
+├── report.py         ← Rich terminal output
+└── utils.py          ← Shared helpers (read/write/validate)
+```
+
+Layers are kept separate (SOLID). The CLI only calls the engine and reporter.
+
+---
+
+## Roadmap
+
+**v1.0**  Indentation repair, tab conversion, missing block, AST validation
+
+**v2.0** Unused/duplicate import detection, import sorting, dead code detection
+
+**v3.0** VS Code extension, HTML reports
+
+---
+
+## Contributing
+
+See [CONTRIBUTING.md](CONTRIBUTING.md).
+
+---
+
+## License
+
+MIT — see [LICENSE](LICENSE).

pyrepair-1.0.0/pyproject.toml

@@ -0,0 +1,55 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pyrepair"
+version = "1.0.0"
+description = "Repair broken Python code before formatting it."
+readme = "README.md"
+license = { text = "MIT" }
+requires-python = ">=3.11"
+authors = [
+    { name = "Sandeep Kumar Mehta" }
+]
+keywords = ["python", "linter", "formatter", "repair", "indentation", "syntax"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Software Development :: Quality Assurance",
+]
+
+dependencies = [
+    "typer>=0.12",
+    "rich>=13.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.0",
+    "pytest-cov>=5.0",
+]
+
+[project.scripts]
+pyrepair = "pyrepair.cli:run"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+addopts = "-v --tb=short"
+
+[tool.coverage.run]
+source = ["src/pyrepair"]
+branch = true
+
+[tool.coverage.report]
+show_missing = true
+skip_covered = false
+fail_under = 80

pyrepair-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

pyrepair-1.0.0/src/pyrepair/__init__.py

@@ -0,0 +1,24 @@
+"""
+PyRepair — Repair broken Python code before formatting it.
+
+Public surface
+──────────────
+    from pyrepair import RepairEngine
+    engine = RepairEngine()
+    result = engine.repair_file(Path("broken.py"))
+"""
+
+from .repair_engine import RepairEngine, RepairRule
+from .models import Issue, RepairResult, RepairStatus, Severity
+from .scanner import Scanner
+
+__version__ = "1.0.0"
+__all__ = [
+    "RepairEngine",
+    "RepairRule",
+    "Issue",
+    "RepairResult",
+    "RepairStatus",
+    "Severity",
+    "Scanner",
+]

pyrepair-1.0.0/src/pyrepair/cli.py

@@ -0,0 +1,127 @@
+"""
+CLI entry point for PyRepair.
+
+All business logic lives in repair_engine / scanner / report.
+This file only:
+  1. Parses CLI arguments (via Typer)
+  2. Calls the right service
+  3. Displays results (via report module)
+  4. Writes files back when appropriate
+
+Commands
+────────
+  pyrepair <target>               repair in-place
+  pyrepair <target> --dry-run     show diff only, don't write
+  pyrepair <target> --backup      create .bak before writing
+  pyrepair <target> --report      verbose issue table
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Optional
+
+import typer
+
+from .repair_engine import RepairEngine
+from .scanner import Scanner
+from .models import RepairStatus
+from .utils import backup_file, write_source
+from . import report
+
+# Create the Typer application
+app = typer.Typer(
+    name="pyrepair",
+    help="Repair broken Python code before formatting it.",
+    add_completion=False,
+)
+
+
+@app.command()
+def main(
+    target: Path = typer.Argument(
+        ...,
+        help="Python file or directory to repair.",
+        exists=True,
+    ),
+    dry_run: bool = typer.Option(
+        False,
+        "--dry-run",
+        help="Show diff only — do NOT write changes to disk.",
+    ),
+    backup: bool = typer.Option(
+        False,
+        "--backup",
+        help="Save a .bak copy before overwriting the file.",
+    ),
+    verbose: bool = typer.Option(
+        False,
+        "--report",
+        "-r",
+        help="Print detailed issue table for each file.",
+    ),
+) -> None:
+    """
+    Repair broken Python indentation, tabs, and missing blocks.
+
+    Examples
+    ────────
+      pyrepair app.py
+      pyrepair src/ --dry-run
+      pyrepair broken.py --backup --report
+    """
+    report.print_banner()
+
+    # ── 1. Discover files ─────────────────────────────────────────────────
+    scanner = Scanner()
+    try:
+        files = scanner.scan(target)
+    except FileNotFoundError as exc:
+        typer.echo(f"Error: {exc}", err=True)
+        raise typer.Exit(code=1)
+
+    if not files:
+        typer.echo("No Python files found.")
+        raise typer.Exit()
+
+    # ── 2. Repair each file ───────────────────────────────────────────────
+    engine  = RepairEngine()
+    results = []
+
+    for file_path in files:
+        result = engine.repair_file(file_path)
+        results.append(result)
+
+        # Show per-file result
+        report.print_result(result, verbose=verbose)
+
+        if dry_run:
+            # Show what WOULD change, but don't touch the file
+            report.print_diff(result)
+            continue
+
+        if result.status == RepairStatus.FAILED:
+            # File couldn't be read — skip
+            continue
+
+        if result.was_modified:
+            if backup:
+                backup_path = backup_file(file_path)
+                typer.echo(f"    Backup → {backup_path}")
+
+            write_source(file_path, result.repaired_source)
+
+        report.print_validation(result.validation_passed)
+
+    # ── 3. Print aggregate summary ────────────────────────────────────────
+    report.print_summary(results)
+
+    # Exit with non-zero code if any file failed
+    any_failed = any(r.status == RepairStatus.FAILED for r in results)
+    if any_failed:
+        raise typer.Exit(code=1)
+
+
+def run() -> None:
+    """Entry point registered in pyproject.toml."""
+    app()

pyrepair-1.0.0/src/pyrepair/models.py

@@ -0,0 +1,63 @@
+"""
+Data models for PyRepair.
+
+These are pure data classes — no business logic lives here.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from enum import Enum
+from pathlib import Path
+
+
+class Severity(str, Enum):
+    """How serious is the issue?"""
+    INFO = "info"
+    WARNING = "warning"
+    ERROR = "error"
+
+
+class RepairStatus(str, Enum):
+    """Final outcome after the repair pipeline runs."""
+    SUCCESS   = "success"    # repaired AND valid Python
+    PARTIAL   = "partial"    # changes made but still invalid
+    UNCHANGED = "unchanged"  # nothing needed fixing
+    FAILED    = "failed"     # could not even read the file
+
+
+@dataclass
+class Issue:
+    """One detected problem in the source code."""
+    rule_name:   str           # e.g. "tabs_to_spaces"
+    description: str           # human-readable explanation
+    line_number: int           # 1-based line where issue was found
+    severity:    Severity      # how bad is it?
+    original:    str = ""      # the raw line that had the problem
+
+
+@dataclass
+class RepairResult:
+    """Everything PyRepair learned and did for one file."""
+    file_path:        Path
+    original_source:  str
+    repaired_source:  str
+    status:           RepairStatus        = RepairStatus.UNCHANGED
+    issues:           list[Issue]         = field(default_factory=list)
+    fixed_issues:     list[Issue]         = field(default_factory=list)
+    validation_passed: bool               = False
+    elapsed_seconds:  float               = 0.0
+    error_message:    str                 = ""
+
+    @property
+    def was_modified(self) -> bool:
+        """True when the repaired source differs from the original."""
+        return self.original_source != self.repaired_source
+
+    @property
+    def total_issues(self) -> int:
+        return len(self.issues)
+
+    @property
+    def total_fixed(self) -> int:
+        return len(self.fixed_issues)