python-doctor 0.1.0__py3-none-any.whl

python_doctor/__init__.py

@@ -0,0 +1,3 @@
+"""Python Doctor — health scoring for Python codebases."""
+
+__version__ = "0.2.0"

python_doctor/analyzers/__init__.py

@@ -0,0 +1 @@
+"""Analyzers for Python Doctor."""

python_doctor/analyzers/bandit_analyzer.py

@@ -0,0 +1,62 @@
+"""Bandit security analyzer."""
+
+import json
+import os
+import subprocess  # nosec B404 — required for running CLI tools
+
+from ..rules import BANDIT_SEVERITY_COST, CATEGORIES, AnalyzerResult, Finding
+
+_EXCLUDE_DIRS = [".venv", "venv", "node_modules", "__pycache__", ".git", ".tox", ".mypy_cache", ".ruff_cache"]
+
+
+def _is_test_file(filepath: str) -> bool:
+    """Check if a file is a test file (in test dir or test-named)."""
+    parts = os.path.normpath(filepath).split(os.sep)
+    if any(p in ("tests", "test") for p in parts):
+        return True
+    basename = os.path.basename(filepath)
+    return basename.startswith("test_") or basename.endswith("_test.py")
+
+
+def analyze(path: str, **_kw) -> AnalyzerResult:
+    """Run bandit security analysis on the project."""
+    result = AnalyzerResult(category="security")
+    max_ded = CATEGORIES["security"]["max_deduction"]
+    abs_path = os.path.abspath(path)
+    excludes = ",".join(os.path.join(abs_path, d) for d in _EXCLUDE_DIRS)
+
+    try:
+        proc = subprocess.run(  # nosec B603 B607 — intentional subprocess call to bandit CLI tool
+            ["bandit", "-r", "-f", "json", "-q",
+             "--exclude", excludes,
+             abs_path],
+            capture_output=True, text=True, timeout=120
+        )
+        data = json.loads(proc.stdout) if proc.stdout.strip() else {}
+        items = data.get("results", [])
+    except FileNotFoundError:
+        result.error = "bandit not found (skipped)"
+        return result
+    except Exception as e:
+        result.error = str(e)
+        return result
+
+    for item in items:
+        sev = item.get("issue_severity", "LOW").upper()
+        cost = BANDIT_SEVERITY_COST.get(sev, 1)
+        test_id = item.get("test_id", "?")
+        msg = item.get("issue_text", "")
+        filename = item.get("filename", "")
+        line = item.get("line_number", 0)
+
+        # Skip B101 (assert) in test files
+        if test_id == "B101" and _is_test_file(filename):
+            continue
+
+        result.findings.append(Finding(
+            category="security", rule=f"bandit/{test_id}", message=msg,
+            file=filename, line=line, severity=sev.lower(), cost=cost,
+        ))
+
+    result.deduction = min(sum(f.cost for f in result.findings), max_ded)
+    return result

python_doctor/analyzers/complexity.py

@@ -0,0 +1,49 @@
+"""Radon cyclomatic complexity analyzer."""
+
+import json
+import subprocess  # nosec B404 — required for running CLI tools
+
+from ..rules import CATEGORIES, AnalyzerResult, Finding
+
+
+def analyze(path: str, **_kw) -> AnalyzerResult:
+    """Analyze cyclomatic complexity using radon."""
+    result = AnalyzerResult(category="complexity")
+    max_ded = CATEGORIES["complexity"]["max_deduction"]
+
+    try:
+        proc = subprocess.run(  # nosec B603 B607 — intentional subprocess call to radon CLI tool
+            ["radon", "cc", "-j", "-n", "C",
+             "-e", ".venv/*,node_modules/*,__pycache__/*,.git/*,.tox/*",
+             path],
+            capture_output=True, text=True, timeout=120
+        )
+        data = json.loads(proc.stdout) if proc.stdout.strip() else {}
+    except FileNotFoundError:
+        result.error = "radon not found (skipped)"
+        return result
+    except Exception as e:
+        result.error = str(e)
+        return result
+
+    for filename, funcs in data.items():
+        for func in funcs:
+            cc = func.get("complexity", 0)
+            name = func.get("name", "?")
+            line = func.get("lineno", 0)
+            if cc > 20:
+                cost = 5
+            elif cc > 10:
+                cost = 2
+            else:
+                continue
+
+            result.findings.append(Finding(
+                category="complexity",
+                rule=f"radon/CC{cc}",
+                message=f"Function '{name}' has complexity {cc}",
+                file=filename, line=line, cost=cost,
+            ))
+
+    result.deduction = min(sum(f.cost for f in result.findings), max_ded)
+    return result

python_doctor/analyzers/dependency_analyzer.py

@@ -0,0 +1,87 @@
+"""Dependency hygiene analyzer."""
+
+import json
+import os
+import subprocess  # nosec B404 — required for running CLI tools
+
+from ..rules import (
+    CATEGORIES,
+    MIXED_BUILD_SYSTEM_COST,
+    NO_BUILD_FILE_COST,
+    VULNERABLE_DEP_COST,
+    AnalyzerResult,
+    Finding,
+)
+
+
+def _check_build_files(path: str) -> tuple[bool, bool, bool, bool]:
+    """Check which build/dependency files exist in the project."""
+    has_pyproject = os.path.isfile(os.path.join(path, "pyproject.toml"))
+    has_setup_py = os.path.isfile(os.path.join(path, "setup.py"))
+    has_setup_cfg = os.path.isfile(os.path.join(path, "setup.cfg"))
+    has_requirements = os.path.isfile(os.path.join(path, "requirements.txt"))
+    return has_pyproject, has_setup_py, has_setup_cfg, has_requirements
+
+
+def _check_build_system(path: str, result: AnalyzerResult) -> None:
+    """Check for missing or mixed build system files."""
+    has_pyproject, has_setup_py, has_setup_cfg, has_requirements = _check_build_files(path)
+
+    if not (has_pyproject or has_setup_py or has_setup_cfg):
+        result.findings.append(Finding(
+            category="dependencies", rule="deps/no-build-file",
+            message="No pyproject.toml, setup.py, or setup.cfg found",
+            cost=NO_BUILD_FILE_COST,
+        ))
+
+    if has_pyproject and has_requirements:
+        result.findings.append(Finding(
+            category="dependencies", rule="deps/mixed-build",
+            message="Both pyproject.toml and requirements.txt found (consider consolidating)",
+            cost=MIXED_BUILD_SYSTEM_COST,
+        ))
+
+
+def _run_pip_audit(path: str) -> list:
+    """Run pip-audit and return vulnerability list."""
+    proc = subprocess.run(  # nosec B603 B607 — intentional subprocess call to pip-audit CLI tool
+        ["pip-audit", "--format", "json", "--path", path],
+        capture_output=True, text=True, timeout=120,
+    )
+    vulns = json.loads(proc.stdout) if proc.stdout.strip() else []
+    if isinstance(vulns, dict):
+        vulns = vulns.get("dependencies", [])
+    return vulns
+
+
+def _check_vulnerabilities(path: str, result: AnalyzerResult) -> None:
+    """Run pip-audit to check for known vulnerabilities."""
+    try:
+        vulns = _run_pip_audit(path)
+    except (FileNotFoundError, subprocess.TimeoutExpired, json.JSONDecodeError):
+        return  # pip-audit not available, skip gracefully
+    except OSError:
+        return
+
+    for v in vulns:
+        if not isinstance(v, dict) or not v.get("vulns"):
+            continue
+        for vuln in v["vulns"]:
+            vid = vuln.get("id", "?") if isinstance(vuln, dict) else str(vuln)
+            result.findings.append(Finding(
+                category="dependencies", rule=f"deps/vuln/{vid}",
+                message=f"Vulnerable: {v.get('name', '?')} {v.get('version', '')}",
+                cost=VULNERABLE_DEP_COST,
+            ))
+
+
+def analyze(path: str, **_kw) -> AnalyzerResult:
+    """Analyze dependency hygiene: build files, mixed systems, and vulnerabilities."""
+    result = AnalyzerResult(category="dependencies")
+    max_ded = CATEGORIES["dependencies"]["max_deduction"]
+
+    _check_build_system(path, result)
+    _check_vulnerabilities(path, result)
+
+    result.deduction = min(sum(f.cost for f in result.findings), max_ded)
+    return result

python_doctor/analyzers/docstring_analyzer.py

@@ -0,0 +1,91 @@
+"""Docstring coverage analyzer."""
+
+import ast
+import os
+
+from ..rules import CATEGORIES, AnalyzerResult, Finding
+
+_SKIP_DIRS = {"__pycache__", ".git", "node_modules", ".venv", "venv", ".tox", ".mypy_cache", ".ruff_cache"}
+
+
+def _is_test_file(filepath: str) -> bool:
+    """Check if a file is a test file."""
+    parts = os.path.normpath(filepath).split(os.sep)
+    if any(p in ("tests", "test") for p in parts):
+        return True
+    basename = os.path.basename(filepath)
+    return basename.startswith("test_") or basename.endswith("_test.py")
+
+
+def _check_file(filepath: str) -> tuple[int, int]:
+    """Return (total_public, documented) counts for public functions/classes."""
+    try:
+        with open(filepath, "r", errors="ignore") as f:
+            source = f.read()
+        tree = ast.parse(source, filename=filepath)
+    except (SyntaxError, OSError):
+        return 0, 0
+
+    total = 0
+    documented = 0
+    for node in ast.iter_child_nodes(tree):
+        if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef)):
+            if node.name.startswith("_"):
+                continue
+            total += 1
+            if (node.body and isinstance(node.body[0], ast.Expr)
+                    and isinstance(node.body[0].value, (ast.Constant, ast.Str))):
+                documented += 1
+    return total, documented
+
+
+def _collect_coverage(path: str) -> tuple[int, int]:
+    """Walk project files and sum up docstring coverage stats."""
+    total_public = 0
+    total_documented = 0
+    for root, dirs, files in os.walk(path):
+        dirs[:] = [d for d in dirs if d not in _SKIP_DIRS]
+        for f in files:
+            if not f.endswith(".py"):
+                continue
+            fp = os.path.join(root, f)
+            if _is_test_file(fp):
+                continue
+            if f == "__init__.py" and os.path.getsize(fp) < 10:
+                continue
+            pub, doc = _check_file(fp)
+            total_public += pub
+            total_documented += doc
+    return total_public, total_documented
+
+
+def _compute_deduction(ratio: float) -> tuple[int, int]:
+    """Compute cost and percentage from docstring coverage ratio."""
+    pct = int(ratio * 100)
+    if ratio < 0.25:
+        return 10, pct
+    if ratio < 0.50:
+        return 5, pct
+    return 0, pct
+
+
+def analyze(path: str, **_kw) -> AnalyzerResult:
+    """Analyze docstring coverage for public functions and classes."""
+    result = AnalyzerResult(category="docs")
+    max_ded = CATEGORIES["docs"]["max_deduction"]
+
+    total_public, total_documented = _collect_coverage(path)
+    if total_public == 0:
+        return result
+
+    ratio = total_documented / total_public
+    cost, pct = _compute_deduction(ratio)
+    if cost > 0:
+        result.findings.append(Finding(
+            category="docs", rule="docs/low-coverage",
+            message=f"Only {pct}% of public functions/classes have docstrings",
+            cost=cost,
+        ))
+
+    result.deduction = min(sum(f.cost for f in result.findings), max_ded)
+    return result

python_doctor/analyzers/exceptions_analyzer.py

@@ -0,0 +1,72 @@
+"""Exception handling analyzer."""
+
+import ast
+import os
+
+from ..rules import BARE_EXCEPT_COST, CATEGORIES, SILENT_EXCEPTION_COST, AnalyzerResult, Finding
+
+_SKIP_DIRS = {"__pycache__", ".git", "node_modules", ".venv", "venv", ".tox", ".mypy_cache", ".ruff_cache"}
+
+
+def _is_test_file(filepath: str) -> bool:
+    """Check if a file is a test file."""
+    parts = os.path.normpath(filepath).split(os.sep)
+    if any(p in ("tests", "test") for p in parts):
+        return True
+    basename = os.path.basename(filepath)
+    return basename.startswith("test_") or basename.endswith("_test.py")
+
+
+def _check_bare_except(node: ast.ExceptHandler, fp: str, result: AnalyzerResult) -> None:
+    """Flag bare except: clauses without an exception type."""
+    if node.type is None:
+        result.findings.append(Finding(
+            category="exceptions", rule="exceptions/bare",
+            message="Bare except: without exception type",
+            file=fp, line=node.lineno, cost=BARE_EXCEPT_COST,
+        ))
+
+
+def _check_silent_swallow(node: ast.ExceptHandler, fp: str, result: AnalyzerResult) -> None:
+    """Flag except Exception: pass patterns."""
+    if (isinstance(node.type, ast.Name) and node.type.id == "Exception"
+            and len(node.body) == 1 and isinstance(node.body[0], ast.Pass)):
+        result.findings.append(Finding(
+            category="exceptions", rule="exceptions/silent",
+            message="except Exception: pass (silently swallowed)",
+            file=fp, line=node.lineno, cost=SILENT_EXCEPTION_COST,
+        ))
+
+
+def _check_file(fp: str, result: AnalyzerResult) -> None:
+    """Analyze exception handlers in a single file."""
+    try:
+        with open(fp, "r", errors="ignore") as fh:
+            tree = ast.parse(fh.read(), filename=fp)
+    except (SyntaxError, OSError):
+        return
+
+    for node in ast.walk(tree):
+        if not isinstance(node, ast.ExceptHandler):
+            continue
+        _check_bare_except(node, fp, result)
+        _check_silent_swallow(node, fp, result)
+
+
+def analyze(path: str, **_kw) -> AnalyzerResult:
+    """Analyze exception handling patterns across the project."""
+    result = AnalyzerResult(category="exceptions")
+    max_ded = CATEGORIES["exceptions"]["max_deduction"]
+
+    for root, dirs, files in os.walk(path):
+        dirs[:] = [d for d in dirs if d not in _SKIP_DIRS]
+        for f in files:
+            if not f.endswith(".py"):
+                continue
+            fp = os.path.join(root, f)
+            if _is_test_file(fp):
+                continue
+            _check_file(fp, result)
+
+    result.deduction = min(sum(f.cost for f in result.findings), max_ded)
+    return result

python_doctor/analyzers/imports_analyzer.py

@@ -0,0 +1,104 @@
+"""Import hygiene analyzer."""
+
+import ast
+import os
+
+from ..rules import CATEGORIES, CIRCULAR_IMPORT_COST, STAR_IMPORT_COST, AnalyzerResult, Finding
+
+_SKIP_DIRS = {"__pycache__", ".git", "node_modules", ".venv", "venv", ".tox", ".mypy_cache", ".ruff_cache"}
+
+
+def _get_module_name(filepath: str, base_path: str) -> str | None:
+    """Convert filepath to dotted module name relative to base."""
+    rel = os.path.relpath(filepath, base_path)
+    if rel.endswith(".py"):
+        rel = rel[:-3]
+    parts = rel.replace(os.sep, ".").split(".")
+    if parts[-1] == "__init__":
+        parts = parts[:-1]
+    return ".".join(parts) if parts else None
+
+
+def _collect_py_files(path: str) -> list[str]:
+    """Collect all Python files in the project, skipping excluded dirs."""
+    py_files = []
+    for root, dirs, files in os.walk(path):
+        dirs[:] = [d for d in dirs if d not in _SKIP_DIRS]
+        for f in files:
+            if f.endswith(".py"):
+                py_files.append(os.path.join(root, f))
+    return py_files
+
+
+def _check_star_imports(node: ast.ImportFrom, fp: str, result: AnalyzerResult) -> None:
+    """Flag wildcard imports like 'from X import *'."""
+    if node.names:
+        for alias in node.names:
+            if alias.name == "*":
+                result.findings.append(Finding(
+                    category="imports", rule="imports/star",
+                    message=f"from {node.module or '?'} import *",
+                    file=fp, line=node.lineno, cost=STAR_IMPORT_COST,
+                ))
+
+
+def _process_file_imports(
+    fp: str, path: str, imports_graph: dict[str, set[str]], result: AnalyzerResult
+) -> None:
+    """Parse a single file and update the import graph, flagging star imports."""
+    try:
+        with open(fp, "r", errors="ignore") as f:
+            tree = ast.parse(f.read(), filename=fp)
+    except (SyntaxError, OSError):
+        return
+
+    mod_name = _get_module_name(fp, path)
+    if mod_name:
+        imports_graph.setdefault(mod_name, set())
+
+    for node in ast.walk(tree):
+        if isinstance(node, ast.ImportFrom):
+            _check_star_imports(node, fp, result)
+            if mod_name and node.module:
+                imports_graph.setdefault(mod_name, set()).add(node.module)
+        elif isinstance(node, ast.Import):
+            for alias in node.names:
+                if mod_name:
+                    imports_graph.setdefault(mod_name, set()).add(alias.name)
+
+
+def _build_import_graph(py_files: list[str], path: str, result: AnalyzerResult) -> dict[str, set[str]]:
+    """Parse all files and build an import dependency graph, flagging star imports."""
+    imports_graph: dict[str, set[str]] = {}
+    for fp in py_files:
+        _process_file_imports(fp, path, imports_graph, result)
+    return imports_graph
+
+
+def _detect_circular_imports(imports_graph: dict[str, set[str]], result: AnalyzerResult) -> None:
+    """Detect direct circular imports (A->B and B->A)."""
+    seen_cycles: set[tuple[str, str]] = set()
+    for mod_a, deps_a in imports_graph.items():
+        for dep in deps_a:
+            if dep in imports_graph and mod_a in imports_graph[dep]:
+                cycle_key = tuple(sorted([mod_a, dep]))
+                if cycle_key not in seen_cycles:
+                    seen_cycles.add(cycle_key)
+                    result.findings.append(Finding(
+                        category="imports", rule="imports/circular",
+                        message=f"Circular import: {cycle_key[0]} <-> {cycle_key[1]}",
+                        cost=CIRCULAR_IMPORT_COST,
+                    ))
+
+
+def analyze(path: str, **_kw) -> AnalyzerResult:
+    """Analyze import hygiene: star imports and circular dependencies."""
+    result = AnalyzerResult(category="imports")
+    max_ded = CATEGORIES["imports"]["max_deduction"]
+
+    py_files = _collect_py_files(path)
+    imports_graph = _build_import_graph(py_files, path, result)
+    _detect_circular_imports(imports_graph, result)
+
+    result.deduction = min(sum(f.cost for f in result.findings), max_ded)
+    return result

python_doctor/analyzers/ruff_analyzer.py

@@ -0,0 +1,53 @@
+"""Ruff linter analyzer."""
+
+import json
+import subprocess  # nosec B404 — required for running CLI tools
+
+from ..rules import CATEGORIES, RUFF_ERROR_COST, RUFF_WARNING_COST, AnalyzerResult, Finding
+
+
+def analyze(path: str, fix: bool = False) -> AnalyzerResult:
+    """Run ruff linting analysis, optionally auto-fixing issues."""
+    result = AnalyzerResult(category="lint")
+    max_ded = CATEGORIES["lint"]["max_deduction"]
+
+    try:
+        if fix:
+            subprocess.run(  # nosec B603 B607 — intentional subprocess call to ruff CLI tool
+                ["ruff", "check", "--fix",
+                 "--exclude", ".venv,node_modules,__pycache__,.git,.tox",
+                 path],
+                capture_output=True, text=True, timeout=120
+            )
+
+        proc = subprocess.run(  # nosec B603 B607 — intentional subprocess call to ruff CLI tool
+            ["ruff", "check", "--output-format", "json",
+             "--exclude", ".venv,node_modules,__pycache__,.git,.tox",
+             path],
+            capture_output=True, text=True, timeout=120
+        )
+        items = json.loads(proc.stdout) if proc.stdout.strip() else []
+    except FileNotFoundError:
+        result.error = "ruff not found (skipped)"
+        return result
+    except Exception as e:
+        result.error = str(e)
+        return result
+
+    for item in items:
+        code = item.get("code", "?")
+        msg = item.get("message", "")
+        filename = item.get("filename", "")
+        line = item.get("location", {}).get("row", 0)
+        # E/W prefixes are warnings, others are errors
+        is_warning = code.startswith(("W", "D"))
+        cost = RUFF_WARNING_COST if is_warning else RUFF_ERROR_COST
+
+        result.findings.append(Finding(
+            category="lint", rule=f"ruff/{code}", message=msg,
+            file=filename, line=line,
+            severity="warning" if is_warning else "error", cost=cost,
+        ))
+
+    result.deduction = min(sum(f.cost for f in result.findings), max_ded)
+    return result

python_doctor/analyzers/structure.py

@@ -0,0 +1,269 @@
+"""Structure analyzer: file sizes, tests, type hints, project health."""
+
+import ast
+import os
+
+from ..rules import (
+    CATEGORIES,
+    LARGE_FILE_COST,
+    LARGE_FILE_THRESHOLD,
+    LOW_TEST_RATIO_COST,
+    LOW_TYPE_HINTS_COST,
+    NO_GITIGNORE_COST,
+    NO_LICENSE_COST,
+    NO_LINTER_CONFIG_COST,
+    NO_PY_TYPED_COST,
+    NO_README_COST,
+    NO_TESTS_COST,
+    NO_TYPE_CHECKER_COST,
+    TYPE_HINT_THRESHOLD,
+    VERY_LOW_TEST_RATIO_COST,
+    AnalyzerResult,
+    Finding,
+)
+
+_SKIP_DIRS = {"__pycache__", ".git", "node_modules", ".venv", "venv", ".tox", ".mypy_cache", ".ruff_cache"}
+
+
+def _count_lines(filepath: str) -> int:
+    """Count total lines in a file."""
+    try:
+        with open(filepath, "r", errors="ignore") as f:
+            return sum(1 for _ in f)
+    except OSError:
+        return 0
+
+
+def _count_code_lines(filepath: str) -> int:
+    """Count non-blank, non-comment lines."""
+    count = 0
+    try:
+        with open(filepath, "r", errors="ignore") as f:
+            for line in f:
+                stripped = line.strip()
+                if stripped and not stripped.startswith("#"):
+                    count += 1
+    except OSError:
+        pass
+    return count
+
+
+def _has_type_hints(filepath: str) -> bool:
+    """Check if a file contains any type annotations."""
+    try:
+        with open(filepath, "r", errors="ignore") as f:
+            tree = ast.parse(f.read(), filename=filepath)
+    except (SyntaxError, OSError):
+        return False
+
+    for node in ast.walk(tree):
+        if isinstance(node, ast.FunctionDef | ast.AsyncFunctionDef):
+            if node.returns is not None:
+                return True
+            for arg in node.args.args + node.args.kwonlyargs:
+                if arg.annotation is not None:
+                    return True
+        if isinstance(node, ast.AnnAssign):
+            return True
+    return False
+
+
+def _is_test_file(filepath: str) -> bool:
+    """Check if a file is a test file."""
+    parts = os.path.normpath(filepath).split(os.sep)
+    if any(p in ("tests", "test") for p in parts):
+        return True
+    basename = os.path.basename(filepath)
+    return basename.startswith("test_") or basename.endswith("_test.py")
+
+
+def _collect_py_files(path: str) -> tuple[list[str], list[str], list[str], bool]:
+    """Walk the project and classify Python files into source and test files."""
+    py_files = []
+    test_files = []
+    source_files = []
+    has_tests = False
+    for root, dirs, files in os.walk(path):
+        dirs[:] = [d for d in dirs if d not in _SKIP_DIRS]
+        if any(d in ("tests", "test") for d in dirs):
+            has_tests = True
+        for f in files:
+            if f.endswith(".py"):
+                fp = os.path.join(root, f)
+                py_files.append(fp)
+                if _is_test_file(fp):
+                    has_tests = True
+                    test_files.append(fp)
+                else:
+                    source_files.append(fp)
+    return py_files, test_files, source_files, has_tests
+
+
+def _check_large_files(py_files: list[str], result: AnalyzerResult) -> None:
+    """Flag files exceeding the line threshold."""
+    for fp in py_files:
+        lines = _count_lines(fp)
+        if lines > LARGE_FILE_THRESHOLD:
+            result.findings.append(Finding(
+                category="structure", rule="structure/large-file",
+                message=f"{lines} lines (consider splitting)",
+                file=fp, cost=LARGE_FILE_COST,
+            ))
+
+
+def _check_tests(has_tests: bool, test_files: list[str], source_files: list[str], result: AnalyzerResult) -> None:
+    """Check for test existence and test-to-source ratio."""
+    if not has_tests:
+        result.findings.append(Finding(
+            category="structure", rule="structure/no-tests",
+            message="No tests directory or test files found",
+            cost=NO_TESTS_COST,
+        ))
+        return
+
+    test_lines = sum(_count_code_lines(f) for f in test_files)
+    source_lines = sum(_count_code_lines(f) for f in source_files)
+    if source_lines <= 0:
+        return
+
+    ratio = test_lines / source_lines
+    if ratio < 0.1:
+        result.findings.append(Finding(
+            category="structure", rule="structure/low-test-ratio",
+            message=f"Test-to-source ratio is {ratio:.2f} (very low, <0.1)",
+            cost=VERY_LOW_TEST_RATIO_COST,
+        ))
+    elif ratio < 0.3:
+        result.findings.append(Finding(
+            category="structure", rule="structure/low-test-ratio",
+            message=f"Test-to-source ratio is {ratio:.2f} (low, <0.3)",
+            cost=LOW_TEST_RATIO_COST,
+        ))
+
+
+def _check_type_hints(py_files: list[str], result: AnalyzerResult) -> bool:
+    """Check type hint coverage across files. Returns whether type hints are used."""
+    hinted = sum(1 for fp in py_files if _has_type_hints(fp))
+    uses_type_hints = hinted > 0
+    ratio = hinted / len(py_files) if py_files else 1
+    if ratio < TYPE_HINT_THRESHOLD:
+        pct = int((1 - ratio) * 100)
+        result.findings.append(Finding(
+            category="structure", rule="structure/type-hints",
+            message=f"No type hints found in {pct}% of files",
+            cost=LOW_TYPE_HINTS_COST,
+        ))
+    return uses_type_hints
+
+
+def _check_readme(path: str, result: AnalyzerResult) -> None:
+    """Check for README file."""
+    if not any(os.path.isfile(os.path.join(path, n)) for n in ("README.md", "README.rst", "README")):
+        result.findings.append(Finding(
+            category="structure", rule="structure/no-readme",
+            message="No README found", cost=NO_README_COST,
+        ))
+
+
+def _check_license(path: str, result: AnalyzerResult) -> None:
+    """Check for LICENSE file."""
+    if not any(os.path.isfile(os.path.join(path, n)) for n in ("LICENSE", "LICENSE.md", "LICENSE.txt", "LICENCE")):
+        result.findings.append(Finding(
+            category="structure", rule="structure/no-license",
+            message="No LICENSE file found", cost=NO_LICENSE_COST,
+        ))
+
+
+def _check_gitignore(path: str, result: AnalyzerResult) -> None:
+    """Check for .gitignore file."""
+    if not os.path.isfile(os.path.join(path, ".gitignore")):
+        result.findings.append(Finding(
+            category="structure", rule="structure/no-gitignore",
+            message="No .gitignore found", cost=NO_GITIGNORE_COST,
+        ))
+
+
+def _check_linter_config(path: str, result: AnalyzerResult) -> None:
+    """Check for linter configuration."""
+    if os.path.isfile(os.path.join(path, "ruff.toml")):
+        return
+    pyproject = os.path.join(path, "pyproject.toml")
+    if os.path.isfile(pyproject):
+        try:
+            with open(pyproject) as f:
+                if "[tool.ruff]" in f.read():
+                    return
+        except OSError:
+            pass
+    setup_cfg = os.path.join(path, "setup.cfg")
+    if os.path.isfile(setup_cfg):
+        try:
+            with open(setup_cfg) as f:
+                if "[flake8]" in f.read():
+                    return
+        except OSError:
+            pass
+    result.findings.append(Finding(
+        category="structure", rule="structure/no-linter-config",
+        message="No linter configuration found", cost=NO_LINTER_CONFIG_COST,
+    ))
+
+
+def _check_type_checker_config(path: str, result: AnalyzerResult) -> None:
+    """Check for type checker configuration."""
+    if any(os.path.isfile(os.path.join(path, n)) for n in ("mypy.ini", "pyrightconfig.json", ".mypy.ini")):
+        return
+    pyproject = os.path.join(path, "pyproject.toml")
+    if os.path.isfile(pyproject):
+        try:
+            with open(pyproject) as f:
+                if "[tool.mypy]" in f.read():
+                    return
+        except OSError:
+            pass
+    result.findings.append(Finding(
+        category="structure", rule="structure/no-type-checker",
+        message="No type checker configuration found", cost=NO_TYPE_CHECKER_COST,
+    ))
+
+
+def _check_py_typed(path: str, uses_type_hints: bool, result: AnalyzerResult) -> None:
+    """Check for py.typed marker file when type hints are used."""
+    if not uses_type_hints:
+        return
+    for root, dirs, files in os.walk(path):
+        dirs[:] = [d for d in dirs if d not in _SKIP_DIRS]
+        if "py.typed" in files:
+            return
+    result.findings.append(Finding(
+        category="structure", rule="structure/no-py-typed",
+        message="Type hints used but no py.typed marker found", cost=NO_PY_TYPED_COST,
+    ))
+
+
+def _check_project_health(path: str, result: AnalyzerResult, uses_type_hints: bool) -> None:
+    """Check for README, LICENSE, .gitignore, linter config, type checker config."""
+    _check_readme(path, result)
+    _check_license(path, result)
+    _check_gitignore(path, result)
+    _check_linter_config(path, result)
+    _check_type_checker_config(path, result)
+    _check_py_typed(path, uses_type_hints, result)
+
+
+def analyze(path: str, **_kw) -> AnalyzerResult:
+    """Analyze project structure: file sizes, tests, type hints, and project health."""
+    result = AnalyzerResult(category="structure")
+    max_ded = CATEGORIES["structure"]["max_deduction"]
+
+    py_files, test_files, source_files, has_tests = _collect_py_files(path)
+    if not py_files:
+        return result
+
+    _check_large_files(py_files, result)
+    _check_tests(has_tests, test_files, source_files, result)
+    uses_type_hints = _check_type_hints(py_files, result)
+    _check_project_health(path, result, uses_type_hints)
+
+    result.deduction = min(sum(f.cost for f in result.findings), max_ded)
+    return result

python_doctor/analyzers/vulture_analyzer.py

@@ -0,0 +1,41 @@
+"""Vulture dead code analyzer."""
+
+import re
+import subprocess  # nosec B404 — required for running CLI tools
+
+from ..rules import CATEGORIES, VULTURE_COST, AnalyzerResult, Finding
+
+
+def analyze(path: str, **_kw) -> AnalyzerResult:
+    """Analyze dead code using vulture."""
+    result = AnalyzerResult(category="dead_code")
+    max_ded = CATEGORIES["dead_code"]["max_deduction"]
+
+    try:
+        proc = subprocess.run(  # nosec B603 B607 — intentional subprocess call to vulture CLI tool
+            ["vulture", "--min-confidence", "80",
+             "--exclude", ".venv,node_modules,__pycache__,.git,.tox",
+             path],
+            capture_output=True, text=True, timeout=120
+        )
+        lines = proc.stdout.strip().splitlines() if proc.stdout else []
+    except FileNotFoundError:
+        result.error = "vulture not found (skipped)"
+        return result
+    except Exception as e:
+        result.error = str(e)
+        return result
+
+    # vulture output: filename:line: unused X 'name' (NN% confidence)
+    pat = re.compile(r"^(.+?):(\d+): (.+)$")
+    for line in lines:
+        m = pat.match(line)
+        if m:
+            filename, lineno, msg = m.group(1), int(m.group(2)), m.group(3)
+            result.findings.append(Finding(
+                category="dead_code", rule="vulture", message=msg,
+                file=filename, line=lineno, cost=VULTURE_COST,
+            ))
+
+    result.deduction = min(sum(f.cost for f in result.findings), max_ded)
+    return result

python_doctor/cli.py

@@ -0,0 +1,149 @@
+"""Main CLI entry point for Python Doctor."""
+
+import argparse
+import json
+import os
+import sys
+
+from . import __version__
+from .analyzers import (
+    bandit_analyzer,
+    complexity,
+    dependency_analyzer,
+    docstring_analyzer,
+    exceptions_analyzer,
+    imports_analyzer,
+    ruff_analyzer,
+    structure,
+    vulture_analyzer,
+)
+from .rules import CATEGORIES
+from .scorer import category_score, compute_score, score_label
+
+ANALYZERS = [
+    ("security", bandit_analyzer),
+    ("lint", ruff_analyzer),
+    ("dead_code", vulture_analyzer),
+    ("complexity", complexity),
+    ("structure", structure),
+    ("dependencies", dependency_analyzer),
+    ("docs", docstring_analyzer),
+    ("imports", imports_analyzer),
+    ("exceptions", exceptions_analyzer),
+]
+
+MAX_FINDINGS_DISPLAY = 5
+
+
+def run_analyzers(path: str, fix: bool = False):
+    """Run all analyzers on the given path and return results."""
+    results = []
+    for cat_name, mod in ANALYZERS:
+        kwargs = {"path": path}
+        if cat_name == "lint":
+            kwargs["fix"] = fix
+        result = mod.analyze(**kwargs)
+        results.append(result)
+    return results
+
+
+def format_finding(f, path: str) -> str:
+    """Format a single finding for display."""
+    rel = os.path.relpath(f.file, path) if f.file else ""
+    loc = f"{rel}:{f.line}" if f.line else rel
+    icon = "⚠" if f.severity in ("warning", "low", "medium") else "✗"
+    return f"  {icon} {f.rule}: {f.message}" + (f" ({loc})" if loc else "")
+
+
+def print_report(results, path: str, verbose: bool = False):
+    """Print the full health report to stdout."""
+    print(f"\n🐍 Python Doctor v{__version__}")
+    print(f"Scanning: {path}\n")
+
+    score = compute_score(results)
+    label = score_label(score)
+    print(f"📊 Score: {score}/100 ({label})\n")
+
+    for result in results:
+        cat = CATEGORIES[result.category]
+        cat_sc = category_score(result)
+        emoji = cat["emoji"]
+        name = cat["label"]
+        max_d = cat["max_deduction"]
+
+        if result.error:
+            print(f"{emoji} {name} — ⚠ {result.error}")
+            continue
+
+        check = " ✓" if not result.findings else ""
+        print(f"{emoji} {name} ({cat_sc}/{max_d}){check}")
+
+        if not result.findings:
+            print("  ✓ All clear.")
+        else:
+            limit = None if verbose else MAX_FINDINGS_DISPLAY
+            shown = result.findings[:limit]
+            for f in shown:
+                print(format_finding(f, path))
+            remaining = len(result.findings) - len(shown)
+            if remaining > 0:
+                print(f"  ... and {remaining} more")
+        print()
+
+
+def main():
+    """CLI entry point for python-doctor."""
+    parser = argparse.ArgumentParser(
+        prog="python-doctor",
+        description="Scan Python codebases and get a 0-100 health score.",
+    )
+    parser.add_argument("path", nargs="?", default=".", help="Directory to scan")
+    parser.add_argument("--verbose", "-v", action="store_true", help="Show all findings")
+    parser.add_argument("--score", action="store_true", help="Output only the score number")
+    parser.add_argument("--json", dest="json_out", action="store_true", help="JSON output")
+    parser.add_argument("--fix", action="store_true", help="Auto-fix what's possible (ruff --fix)")
+    parser.add_argument("--version", action="version", version=f"%(prog)s {__version__}")
+
+    args = parser.parse_args()
+    path = os.path.abspath(args.path)
+
+    if not os.path.isdir(path):
+        print(f"Error: '{path}' is not a directory.", file=sys.stderr)
+        sys.exit(1)
+
+    results = run_analyzers(path, fix=args.fix)
+    score = compute_score(results)
+
+    if args.score:
+        print(score)
+        return
+
+    if args.json_out:
+        output = {
+            "version": __version__,
+            "path": path,
+            "score": score,
+            "label": score_label(score),
+            "categories": {},
+        }
+        for r in results:
+            cat = CATEGORIES[r.category]
+            output["categories"][r.category] = {
+                "score": category_score(r),
+                "max": cat["max_deduction"],
+                "deduction": r.deduction,
+                "error": r.error,
+                "findings": [
+                    {"rule": f.rule, "message": f.message, "file": f.file, "line": f.line, "severity": f.severity}
+                    for f in r.findings
+                ],
+            }
+        print(json.dumps(output, indent=2))
+        return
+
+    print_report(results, path, verbose=args.verbose)
+    sys.exit(0 if score >= 50 else 1)
+
+
+if __name__ == "__main__":
+    main()

python_doctor/rules.py

@@ -0,0 +1,76 @@
+"""Rule definitions and scoring categories."""
+
+from dataclasses import dataclass, field
+
+CATEGORIES = {
+    "security": {"emoji": "🔒", "label": "Security", "max_deduction": 30},
+    "lint": {"emoji": "🧹", "label": "Lint", "max_deduction": 25},
+    "dead_code": {"emoji": "💀", "label": "Dead Code", "max_deduction": 15},
+    "complexity": {"emoji": "🔄", "label": "Complexity", "max_deduction": 15},
+    "structure": {"emoji": "🏗", "label": "Structure", "max_deduction": 15},
+    "dependencies": {"emoji": "📦", "label": "Dependencies", "max_deduction": 15},
+    "docs": {"emoji": "📝", "label": "Docstrings", "max_deduction": 10},
+    "imports": {"emoji": "🔗", "label": "Imports", "max_deduction": 10},
+    "exceptions": {"emoji": "⚡", "label": "Exceptions", "max_deduction": 10},
+}
+
+BANDIT_SEVERITY_COST = {"HIGH": 3, "MEDIUM": 2, "LOW": 1}
+RUFF_ERROR_COST = 1.0
+RUFF_WARNING_COST = 0.5
+VULTURE_COST = 0.5
+COMPLEXITY_COST = {10: 2, 20: 5}  # CC>10: -2, CC>20: -5
+LARGE_FILE_THRESHOLD = 500
+LARGE_FILE_COST = 2
+NO_TESTS_COST = 5
+LOW_TYPE_HINTS_COST = 5
+TYPE_HINT_THRESHOLD = 0.5
+
+# Dependency analyzer costs
+NO_BUILD_FILE_COST = 3
+VULNERABLE_DEP_COST = 2
+MIXED_BUILD_SYSTEM_COST = 1
+
+# Docstring analyzer
+DOCSTRING_LOW_COVERAGE_COST = 5
+DOCSTRING_NO_COVERAGE_COST = 10
+
+# Import analyzer
+STAR_IMPORT_COST = 1
+CIRCULAR_IMPORT_COST = 3
+
+# Exception analyzer
+BARE_EXCEPT_COST = 2
+SILENT_EXCEPTION_COST = 1
+
+# Structure: project health
+NO_README_COST = 2
+NO_LICENSE_COST = 1
+NO_GITIGNORE_COST = 1
+NO_LINTER_CONFIG_COST = 1
+NO_TYPE_CHECKER_COST = 1
+NO_PY_TYPED_COST = 1
+
+# Structure: test quality
+LOW_TEST_RATIO_COST = 2
+VERY_LOW_TEST_RATIO_COST = 4
+
+
+@dataclass
+class Finding:
+    """A single diagnostic finding from an analyzer."""
+    category: str
+    rule: str
+    message: str
+    file: str = ""
+    line: int = 0
+    severity: str = "medium"
+    cost: float = 0.0
+
+
+@dataclass
+class AnalyzerResult:
+    """Result from running an analyzer, containing findings and deduction."""
+    category: str
+    findings: list[Finding] = field(default_factory=list)
+    deduction: float = 0.0
+    error: str | None = None

python_doctor/scorer.py

@@ -0,0 +1,27 @@
+"""Score aggregation logic."""
+
+from .rules import CATEGORIES, AnalyzerResult
+
+
+def compute_score(results: list[AnalyzerResult]) -> int:
+    """Compute the overall health score (0-100) from analyzer results."""
+    total_deduction = sum(r.deduction for r in results)
+    return max(0, int(100 - total_deduction))
+
+
+def score_label(score: int) -> str:
+    """Return a human-readable label for the given score."""
+    if score >= 90:
+        return "Excellent"
+    elif score >= 75:
+        return "Good"
+    elif score >= 50:
+        return "Needs Work"
+    else:
+        return "Critical"
+
+
+def category_score(result: AnalyzerResult) -> int:
+    """Compute the score for a single category."""
+    cat = CATEGORIES[result.category]
+    return int(cat["max_deduction"] - result.deduction)

python_doctor-0.1.0.dist-info/METADATA

@@ -0,0 +1,191 @@
+Metadata-Version: 2.4
+Name: python-doctor
+Version: 0.1.0
+Summary: One command. One score. Built for AI agents. Scans Python codebases and returns a 0-100 health score.
+Project-URL: Homepage, https://github.com/saikatkumardey/python-doctor
+Project-URL: Repository, https://github.com/saikatkumardey/python-doctor
+Project-URL: Issues, https://github.com/saikatkumardey/python-doctor/issues
+Project-URL: Changelog, https://github.com/saikatkumardey/python-doctor/blob/main/CHANGELOG.md
+Author-email: Saikat Kumar Dey <deysaikatkumar@gmail.com>
+License: MIT
+License-File: LICENSE
+Keywords: ai-agents,code-quality,developer-tools,linting,python,static-analysis
+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.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Quality Assurance
+Classifier: Topic :: Software Development :: Testing
+Requires-Python: >=3.10
+Requires-Dist: bandit>=1.7.0
+Requires-Dist: radon>=6.0.0
+Requires-Dist: ruff>=0.4.0
+Requires-Dist: vulture>=2.11
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# Python Doctor 🐍
+
+[![Tests](https://github.com/saikatkumardey/python-doctor/actions/workflows/test.yml/badge.svg)](https://github.com/saikatkumardey/python-doctor/actions/workflows/test.yml)
+[![PyPI](https://img.shields.io/pypi/v/python-doctor)](https://pypi.org/project/python-doctor/)
+[![Python](https://img.shields.io/pypi/pyversions/python-doctor)](https://pypi.org/project/python-doctor/)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
+
+**One command. One score. Built for AI agents.**
+
+Python Doctor scans a Python codebase and returns a 0-100 health score with structured, actionable output. It's designed so an AI agent can run it, read the results, fix the issues, and verify the fix — in a loop, without human intervention.
+
+```bash
+python-doctor .
+# 📊 Score: 98/100 (Excellent)
+```
+
+## Why?
+
+Setting up linting, security scanning, dead code detection, and complexity analysis means configuring 5+ tools, reading 5 different output formats, and deciding what matters. Python Doctor wraps them all into a single command with a single score.
+
+An agent doesn't need to know what Bandit is. It just needs to know the score dropped and which lines to fix.
+
+## Install the CLI
+
+```bash
+# Using uv (recommended)
+uv tool install git+https://github.com/saikatkumardey/python-doctor
+
+# Using pip
+pip install git+https://github.com/saikatkumardey/python-doctor
+
+# Or clone and run directly
+git clone https://github.com/saikatkumardey/python-doctor.git
+cd python-doctor
+uv run python-doctor /path/to/project
+```
+
+## Add to Your Coding Agent
+
+Python Doctor works with any agent that can run shell commands. Install the CLI (above), then add the rule to your agent:
+
+### Claude Code
+
+Add to your `CLAUDE.md`:
+
+```markdown
+## Python Health Check
+
+Before finishing work on Python files, run:
+  python-doctor . --json
+
+Fix any findings with severity "error". Target score: 80+.
+If score drops below 50, do not commit — fix the issues first.
+```
+
+### Cursor
+
+Add to `.cursor/rules/python-doctor.mdc`:
+
+```markdown
+---
+description: Python codebase health check
+globs: "**/*.py"
+alwaysApply: false
+---
+
+Run `python-doctor . --json` after modifying Python files.
+Fix findings. Target score: 80+. Do not commit below 50.
+```
+
+### OpenAI Codex
+
+Add to `AGENTS.md`:
+
+```markdown
+## Python Health Check
+
+After modifying Python files, run `python-doctor . --json` to check codebase health.
+Fix any findings. Target score: 80+. Exit code 1 means score < 50 — fix before committing.
+```
+
+### Windsurf / Cline / Aider
+
+Add to your project rules or system prompt:
+
+```
+After modifying Python files, run: python-doctor . --json
+Read the output. Fix findings with severity "error" first, then warnings.
+Re-run to verify the score improved. Target: 80+.
+```
+
+### OpenClaw
+
+```bash
+clawhub install python-doctor
+```
+
+### GitHub Actions (CI)
+
+```yaml
+- name: Health Check
+  run: |
+    uv tool install git+https://github.com/saikatkumardey/python-doctor
+    python-doctor . --verbose
+```
+
+Exits with code 1 if score < 50.
+
+## Usage
+
+```bash
+# Scan current directory
+python-doctor .
+
+# Verbose — show all findings with line numbers
+python-doctor . --verbose
+
+# Just the score (for CI or quick checks)
+python-doctor . --score
+
+# Structured JSON for agents
+python-doctor . --json
+
+# Auto-fix what Ruff can handle, then report the rest
+python-doctor . --fix
+```
+
+## What It Checks
+
+9 categories, 5 external tools + 4 custom AST analyzers:
+
+| Category | Max | What |
+|----------|-----|------|
+| 🔒 Security | -30 | Bandit (SQLi, hardcoded secrets, unsafe calls). Auto-skips `assert` in test files. |
+| 🧹 Lint | -25 | Ruff (unused imports, undefined names, style) |
+| 💀 Dead Code | -15 | Vulture (unused functions, variables, imports) |
+| 🔄 Complexity | -15 | Radon (cyclomatic complexity > 10) |
+| 🏗 Structure | -15 | File sizes, test ratio, type hints, README, LICENSE, linter/type-checker config |
+| 📦 Dependencies | -15 | Build file exists, no mixed systems, pip-audit vulnerabilities |
+| 📝 Docstrings | -10 | Public function/class docstring coverage |
+| 🔗 Imports | -10 | Star imports, circular import detection |
+| ⚡ Exceptions | -10 | Bare `except:`, silently swallowed exceptions |
+
+Score = `max(0, 100 - total_deductions)`. Each category is capped at its max.
+
+## The Loop
+
+This is how an agent uses it:
+
+1. `python-doctor . --json` → read the report
+2. Fix the findings (auto-fix with `--fix`, manual fixes for the rest)
+3. `python-doctor . --score` → verify improvement
+4. Repeat until score target met
+
+We built Python Doctor, then ran it on itself. Score: 47. Fixed everything it flagged. Score: 98. The tool eats its own dogfood.
+
+## License
+
+MIT — Saikat Kumar Dey, 2026

python_doctor-0.1.0.dist-info/RECORD

@@ -0,0 +1,20 @@
+python_doctor/__init__.py,sha256=N0uv_1jmUicRwPRW5sPW8lAVxfeFtVZiCpOTWQDNsug,84
+python_doctor/cli.py,sha256=Di74xyaGLk0iv-x7P0DGIk0eHiJTQoQ3uvjvt4IAjM0,4644
+python_doctor/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+python_doctor/rules.py,sha256=H-0ET7-A9JsVGlxN14e3rjLiXWE7XFgvbYV_yyv4bZA,2135
+python_doctor/scorer.py,sha256=qEqRw436GyCmDjqw-IwDd175UxU2xMK5KGV-Bzmf-M8,787
+python_doctor/analyzers/__init__.py,sha256=y9QKh8aD_8jKviICtx3-QmxZrkJ5AXW0gjid73tlPlw,35
+python_doctor/analyzers/bandit_analyzer.py,sha256=Ku9Q1bo3XHesB4ZsyyYoY46IuDRr971lJqBJAWjtCZo,2274
+python_doctor/analyzers/complexity.py,sha256=3LP15RvHfin-OXJcn7wXKuAWW0tyzW56PAZau-3R4h0,1644
+python_doctor/analyzers/dependency_analyzer.py,sha256=pgLo3fN2ubvaBv7tBV8M-Igt98KOSNT7Gu33aZTisw0,3283
+python_doctor/analyzers/docstring_analyzer.py,sha256=Rf9bERdW7JQorJSd4vjR4FovS9Sk7ZKfB5z-D9d4rXE,3030
+python_doctor/analyzers/exceptions_analyzer.py,sha256=D9Exl4W9ASkO_kT42e324YIerXj9n6tyM11Oh_A24E4,2658
+python_doctor/analyzers/imports_analyzer.py,sha256=ld7DDjZtM_4xIiVIb8R4q8HFpcADe0HAclYZ41G5lWo,4034
+python_doctor/analyzers/ruff_analyzer.py,sha256=D70NygBGQCXOgX7uDLHXF2SVD-4exKOGU8zGqAN71-4,2014
+python_doctor/analyzers/structure.py,sha256=jCrvL6P9j5_U7OKcyjD2pXdqKlP_YQUX9leVwM2k1OU,9543
+python_doctor/analyzers/vulture_analyzer.py,sha256=PE_UZB2zYgKd3QOABwK3nvQYILJkxEohOjEjKniUrOE,1495
+python_doctor-0.1.0.dist-info/METADATA,sha256=H878TW_cIFqsuIt86faKBdAfUXo0KLy-35-xACKREoo,6169
+python_doctor-0.1.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+python_doctor-0.1.0.dist-info/entry_points.txt,sha256=J40LC_mJMQt2ai5r_9PVhgnjR_ykSkoczMspOn2h-xM,57
+python_doctor-0.1.0.dist-info/licenses/LICENSE,sha256=rlgCkmloUxFvtgQeP6gf9B7pTVjkZyutQCKf56KQIbA,1073
+python_doctor-0.1.0.dist-info/RECORD,,

python_doctor-0.1.0.dist-info/WHEEL

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

python_doctor-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+python-doctor = python_doctor.cli:main

python_doctor-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Saikat Kumar Dey
+
+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.