autodocstring-tool 0.1.0__py3-none-any.whl

autodocstring/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

autodocstring/__main__.py

@@ -0,0 +1,4 @@
+from autodocstring.cli import main
+
+if __name__ == "__main__":
+    main()

autodocstring/cli.py

@@ -0,0 +1,91 @@
+import sys
+import argparse
+from pathlib import Path
+
+from autodocstring.parser import parse_file
+from autodocstring.coverage import coverage_report
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Docstring coverage checker and reporter",
+        epilog="Example: python cli.py samples/ --style Google --min-coverage 80 --verbose",
+    )
+    parser.add_argument(
+        "paths",
+        nargs="*",
+        default=["samples"],
+        help="Path(s) to check (folder or files). Default: samples",
+    )
+    parser.add_argument(
+        "--min-coverage",
+        type=float,
+        default=80.0,
+        help="Minimum coverage per file (default: 80.0)",
+    )
+    parser.add_argument(
+        "--style",
+        default="Google",
+        choices=["Google", "NumPy", "reST"],
+        help="Docstring style (default: Google)",
+    )
+    parser.add_argument(
+        "--verbose",
+        action="store_true",
+        help="Print detailed output for each file",
+    )
+
+    args = parser.parse_args()
+
+    files = []
+    for p in args.paths:
+        path = Path(p)
+        if path.is_dir():
+            files.extend(path.rglob("*.py"))
+        elif path.is_file() and path.suffix.lower() == ".py":
+            files.append(path)
+        else:
+            if args.verbose:
+                print(f"Skipping non-Python path: {path}")
+
+    if not files:
+        print("No Python files found.")
+        sys.exit(1)
+
+    failed = []
+    print(f"Checking {len(files)} file(s)")
+
+    for file_path in files:
+        try:
+            parsed = parse_file(str(file_path))
+            report = coverage_report(parsed)
+
+            # Safe access to keys with defaults
+            coverage_pct = report.get("Coverage (%)", 0.0)
+            missing_count = report.get("Missing", 0)
+
+            if coverage_pct < args.min_coverage:
+                failed.append((file_path, coverage_pct, missing_count))
+                print(
+                    f"  {file_path}: {coverage_pct:.2f}% - missing {missing_count} items"
+                )
+            else:
+                if args.verbose:
+                    print(f"  {file_path}: {coverage_pct:.2f}%  OK")
+
+        except Exception as e:
+            print(f"Error processing {file_path}: {type(e).__name__}: {str(e)}")
+            failed.append((file_path, 0.0, "error"))
+
+    if failed:
+        print(
+            f"\nFailed: {len(failed)} file(s) below {args.min_coverage}% or had errors"
+        )
+        sys.exit(1)
+
+    print("All checked files passed coverage check.")
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()

autodocstring/compliance.py

@@ -0,0 +1,53 @@
+def analyze_docstring(func, style=None):
+    raw_doc = func.get("docstring") or ""
+    doc = raw_doc.lower()
+    missing = []
+    formatting_issues = []
+    warnings = []
+    # ---------- SECTION COMPLETENESS ----------
+    if func["params"] and not any(k in doc for k in ["param", "args", "parameters"]):
+        missing.append("Parameters")
+
+    if func["returns"] and "return" not in doc:
+        missing.append("Returns")
+
+    if func["raises"] and "raise" not in doc:
+        missing.append("Raises")
+
+    if func["is_generator"] and "yield" not in doc:
+        missing.append("Yields")
+
+    if func.get("class") and func.get("attributes") and "attribute" not in doc:
+        missing.append("Attributes")
+    # ---------- SUMMARY LINE CHECK ----------
+    if raw_doc:
+        first_line = raw_doc.strip().split("\n")[0].strip()
+
+        if not first_line:
+            formatting_issues.append("Empty summary line")
+        elif not first_line.endswith("."):
+            warnings.append("Summary line should end with a period")
+        elif len(first_line) > 72:
+            warnings.append("Summary line is too long")
+        elif first_line.lower().startswith(
+            ("returns", "does", "divides", "calculates")
+        ):
+            warnings.append("Summary line not in imperative mood")
+    else:
+        formatting_issues.append("Missing summary line")
+    # ---------- STYLE-SPECIFIC CHECK ----------
+    if style and raw_doc:
+        if style == "Google" and "args:" not in doc:
+            warnings.append("Google style expects 'Args:' section")
+
+        if style == "NumPy" and "parameters" not in doc:
+            warnings.append("NumPy style expects 'Parameters' section")
+
+        if style == "reST" and ":param" not in doc:
+            warnings.append("reST style expects ':param:' fields")
+    return {
+        "missing_sections": missing,
+        "formatting_issues": formatting_issues,
+        "warnings": warnings,
+        "pep257_compliant": len(missing) == 0 and len(formatting_issues) == 0,
+    }

autodocstring/config.py

@@ -0,0 +1,20 @@
+import tomllib
+from pathlib import Path
+
+
+def load_config():
+    path = Path("pyproject.toml")
+
+    defaults = {
+        "style": "Google",
+        "min_coverage": 80,
+        "enforce_pep257": True,
+    }
+
+    if not path.exists():
+        return defaults
+
+    with open(path, "rb") as f:
+        data = tomllib.load(f)
+
+    return {**defaults, **data.get("tool", {}).get("autodoc", {})}

autodocstring/coverage.py

@@ -0,0 +1,70 @@
+from autodocstring.compliance import analyze_docstring
+
+
+def coverage_report(parsed_data):
+    functions = parsed_data["functions"]
+    classes = parsed_data["classes"]
+    methods = [m for c in classes for m in c["methods"]]
+    all_items = functions + methods
+    missing = {"Parameters": 0, "Returns": 0, "Raises": 0, "Yields": 0, "Attributes": 0}
+    compliant = 0
+    # ✅ NEW: collect non-compliant details
+    non_compliant_items = []
+
+    for item in all_items:
+        result = analyze_docstring(item)
+
+        if result["pep257_compliant"]:
+            compliant += 1
+        else:
+            non_compliant_items.append(
+                {
+                    "Name": (
+                        item["name"]
+                        if not item.get("class")
+                        else f"{item['class']}.{item['name']}"
+                    ),
+                    "Type": "Method" if item.get("class") else "Function",
+                    "Missing Sections": ", ".join(result["missing_sections"]) or "None",
+                    "Formatting Issues": ", ".join(result.get("formatting_issues", []))
+                    or "None",
+                }
+            )
+
+        for sec in result["missing_sections"]:
+            missing[sec] += 1
+
+    total = len(all_items)
+    documented = sum(i["has_docstring"] for i in all_items)
+    # ---------- TYPE-WISE COUNTS ----------
+    documented_functions = sum(f["has_docstring"] for f in functions)
+    documented_methods = sum(m["has_docstring"] for m in methods)
+    documented_classes = sum(c["has_docstring"] for c in classes)
+    return {
+        # ---------- COUNTS ----------
+        "Functions": len(functions),
+        "Classes": len(classes),
+        "Methods": len(methods),
+        "Total": total,
+        # ---------- OVERALL COVERAGE ----------
+        "Documented": documented,
+        "Missing": total - documented,
+        "Coverage (%)": (documented / total * 100) if total else 0,
+        # ---------- TYPE-WISE COVERAGE ----------
+        "Function Coverage (%)": (
+            documented_functions / len(functions) * 100 if functions else 0
+        ),
+        "Method Coverage (%)": (
+            documented_methods / len(methods) * 100 if methods else 0
+        ),
+        "Class Coverage (%)": (
+            documented_classes / len(classes) * 100 if classes else 0
+        ),
+        # ---------- COMPLIANCE ----------
+        "PEP-257 Compliant": compliant,
+        "PEP-257 Compliance (%)": (compliant / total * 100) if total else 0,
+        # ---------- MISSING SECTIONS ----------
+        **{f"Missing {k}": v for k, v in missing.items()},
+        # ---------- ✅ NEW ADDITION ----------
+        "Non-Compliant Items": non_compliant_items,
+    }

autodocstring/generator.py

@@ -0,0 +1,78 @@
+def _summary(item, class_name=None):
+    if "name" in item:
+        name = f"{class_name}.{item['name']}" if class_name else item["name"]
+    else:
+        name = "Object"
+
+    return f"Generate documentation for {name}."
+
+
+def generate_google(func, class_name=None):
+    doc = f"{_summary(func, class_name)}\n\n"
+
+    if func.get("params"):
+        doc += "Args:\n"
+        for p in func["params"]:
+            doc += f"    {p['name']} ({p['type'] or 'Any'}): Description.\n"
+
+    if func.get("returns"):
+        doc += f"\nReturns:\n    {func['returns']}: Description.\n"
+
+    if func.get("raises"):
+        doc += "\nRaises:\n"
+        for r in func["raises"]:
+            doc += f"    {r}: Description.\n"
+
+    if func.get("is_generator"):
+        doc += "\nYields:\n    value: Generated value.\n"
+
+    return doc.strip()
+
+
+def generate_numpy(func, class_name=None):
+    doc = f"{_summary(func, class_name)}\n\n"
+
+    if func.get("params"):
+        doc += "Parameters\n----------\n"
+        for p in func["params"]:
+            doc += f"{p['name']} : {p['type'] or 'Any'}\n    Description.\n"
+
+    if func.get("returns"):
+        doc += f"\nReturns\n-------\n{func['returns']}\n    Description.\n"
+
+    if func.get("raises"):
+        doc += "\nRaises\n------\n"
+        for r in func["raises"]:
+            doc += f"{r}\n    Description.\n"
+
+    if func.get("is_generator"):
+        doc += "\nYields\n------\nvalue\n    Generated value.\n"
+
+    return doc.strip()
+
+
+def generate_rest(func, class_name=None):
+    doc = f"{_summary(func, class_name)}\n\n"
+
+    for p in func.get("params", []):
+        doc += f":param {p['name']}: Description.\n"
+        doc += f":type {p['name']}: {p['type'] or 'Any'}\n"
+
+    if func.get("returns"):
+        doc += f":return: {func['returns']}.\n"
+
+    for r in func.get("raises", []):
+        doc += f":raises {r}: Description.\n"
+
+    if func.get("is_generator"):
+        doc += ":yields: Generated value.\n"
+
+    return doc.strip()
+
+
+def generate_docstring(func, class_name=None, style="Google"):
+    if style == "NumPy":
+        return generate_numpy(func, class_name)
+    if style == "reST":
+        return generate_rest(func, class_name)
+    return generate_google(func, class_name)

autodocstring/injector.py

@@ -0,0 +1,64 @@
+import ast
+from autodocstring.llm_generator import generate_docstring_llm
+
+
+class DocstringInjector(ast.NodeTransformer):
+    """Injects clean PEP 257 docstrings into functions and methods."""
+
+    def __init__(self, style: str = "Google"):
+        self.style = style
+
+    def visit_FunctionDef(self, node):
+        self.generic_visit(node)
+
+        try:
+            source = ast.unparse(node)
+            raw_body = generate_docstring_llm(source, self.style)
+
+            # Strip any triple quotes the LLM might have added
+            body = raw_body.strip()
+            for q in ['"""', "'''"]:
+                if body.startswith(q) and body.endswith(q):
+                    body = body[len(q) : -len(q)].strip()
+
+            # Remove any leading/trailing junk
+            body = body.strip()
+
+            # Build clean docstring (we add the quotes here only once)
+            docstring = f"\n{    body}\n    "
+
+            doc_node = ast.Expr(value=ast.Constant(value=docstring))
+
+            # Replace existing docstring or insert at the beginning
+            if node.body and isinstance(node.body[0], ast.Expr):
+                if isinstance(node.body[0].value, ast.Constant) and isinstance(
+                    node.body[0].value.value, str
+                ):
+                    # Replace old docstring
+                    node.body[0] = doc_node
+                else:
+                    # Insert new one
+                    node.body.insert(0, doc_node)
+            else:
+                node.body.insert(0, doc_node)
+
+        except Exception as e:
+            print(f"Docstring generation failed for {node.name}: {e}")
+
+        return node
+
+
+def inject_docstrings(source_code: str, style: str = "Google") -> str:
+    """
+    Parse source code and inject docstrings into all functions/methods.
+    """
+    try:
+        tree = ast.parse(source_code)
+    except SyntaxError as e:
+        raise SyntaxError(f"Invalid Python code: {str(e)}")
+
+    transformer = DocstringInjector(style=style)
+    new_tree = transformer.visit(tree)
+
+    ast.fix_missing_locations(new_tree)
+    return ast.unparse(new_tree)

autodocstring/llm_generator.py

@@ -0,0 +1,173 @@
+import requests
+import re
+import textwrap
+
+OLLAMA_URL = "http://localhost:11434/api/generate"
+MODEL = "qwen2.5-coder:3b"
+
+
+def build_prompt(code: str, style: str) -> str:
+    """
+    Build a strong, clear prompt optimized for qwen2.5-coder:3b
+    """
+    style = style.lower()
+    if style in ["rst", "restructuredtext"]:
+        style = "reST"
+
+    return f"""You are an expert Python docstring generator.
+
+Generate EXACTLY ONE PEP 257 compliant docstring for the given function/method.
+
+MANDATORY RULES - YOU MUST FOLLOW ALL:
+- Output ONLY the docstring content (text that goes between triple quotes)
+- Start with one short imperative summary sentence. End with a period.
+- Then exactly one blank line.
+- Then only needed sections: Args/Parameters, Returns, Raises, Yields
+- Follow the selected style strictly: {style}
+- Use exactly 4 spaces for indentation under sections
+- Do NOT include ```python
+- Do NOT repeat the function definition
+- Do NOT add extra triple quotes around your output
+- Do NOT add examples, notes, explanations, or any extra text
+- Do NOT include the words "python" or "code" unless in type hints
+- Return ONLY the pure docstring text — nothing before or after
+
+Style reference:
+- google: Args:, Returns:, Raises:
+- numpy: Parameters\n----------, Returns\n-------, Raises\n------
+- reST: :param name:, :returns:, :raises:
+
+STRICT OUTPUT RULES - YOU MUST OBEY:
+- Output ONLY the docstring content (the text INSIDE the triple quotes)
+- Start directly with the summary sentence
+- Then one blank line
+- Then only needed sections
+- Do NOT output triple quotes at all
+- Do NOT repeat the function definition
+- Do NOT include ```python or any fences
+- Do NOT add extra text, examples, explanations or markup
+- Return pure text only
+
+
+
+Code:
+{code}
+
+Style: {style}
+
+Respond with ONLY the docstring content. No other text.
+"""
+
+
+def clean_docstring(raw: str) -> str:
+    """
+    Clean LLM output and ensure it becomes a valid docstring.
+    """
+    raw = raw.strip()
+
+    # Remove common LLM mistakes
+    raw = re.sub(r"^```(?:python|py)?\s*", "", raw, flags=re.IGNORECASE)
+    raw = re.sub(r"\s*```$", "", raw)
+    raw = re.sub(r'^("""|\'\'\')+', "", raw)
+    raw = re.sub(r'("""|\'\'\')+$', "", raw)
+
+    # Split into lines and clean
+    lines = [line.rstrip() for line in raw.splitlines()]
+
+    # Remove leading/trailing empty lines
+    while lines and not lines[0].strip():
+        lines.pop(0)
+    while lines and not lines[-1].strip():
+        lines.pop()
+
+    if not lines:
+        return '"""\nNo description available.\n"""'
+
+    # Force PEP 257 structure: summary + blank line
+    summary = lines[0].strip()
+    body = lines[1:]
+
+    result = [summary, ""]  # summary + blank line
+
+    for line in body:
+        stripped = line.rstrip()
+        if stripped:
+            # Keep section headers clean, indent descriptions
+            if re.match(r"^(Args|Parameters|Returns|Raises|Yields):", stripped.strip()):
+                result.append(stripped)
+            else:
+                result.append("    " + stripped.lstrip())
+        else:
+            result.append("    ")
+
+    # Add triple quotes
+    result = ['"""'] + result + ['"""']
+
+    return "\n".join(result)
+
+
+def generate_docstring_llm(code: str, style: str = "Google") -> str:
+    """
+    Generate a PEP 257 compliant docstring using Ollama + qwen2.5-coder:3b
+
+    Args:
+        code: Function/method code as string
+        style: "Google", "NumPy", "reST"
+
+    Returns:
+        Properly formatted docstring string (with triple quotes)
+    """
+    prompt = build_prompt(code, style)
+
+    payload = {
+        "model": MODEL,
+        "prompt": prompt,
+        "stream": False,
+        "options": {
+            "temperature": 0.0,
+            "top_p": 0.9,
+            "repeat_penalty": 1.1,
+            "num_predict": 512,  # enough for most docstrings
+        },
+    }
+
+    try:
+        response = requests.post(OLLAMA_URL, json=payload, timeout=120)
+        response.raise_for_status()
+
+        raw = response.json().get("response", "").strip()
+
+        if not raw:
+            return '"""\nGenerated docstring.\n"""'
+
+        cleaned = clean_docstring(raw)
+
+        # Final safety: ensure triple quotes
+        if not cleaned.startswith('"""'):
+            cleaned = '"""\n' + cleaned.lstrip()
+        if not cleaned.endswith('"""'):
+            cleaned = cleaned.rstrip() + '\n"""'
+
+        return cleaned
+
+    except requests.exceptions.RequestException as e:
+        raise RuntimeError(f"Ollama connection failed: {e}") from e
+    except Exception as e:
+        raise RuntimeError(f"Docstring generation failed: {e}") from e
+
+
+# ────────────────────────────────────────────────
+# Optional test
+# ────────────────────────────────────────────────
+if __name__ == "__main__":
+    sample = """
+def add(a: int, b: int = 0) -> int:
+    return a + b
+"""
+
+    try:
+        doc = generate_docstring_llm(sample, style="Google")
+        print("Generated docstring:\n")
+        print(doc)
+    except Exception as e:
+        print(f"Error: {e}")

autodocstring/parser.py

@@ -0,0 +1,89 @@
+import ast
+
+
+class CodeParser(ast.NodeVisitor):
+    def __init__(self):
+        self.functions = []
+        self.classes = []
+        self.current_class = None
+
+    # ---------- TOP-LEVEL FUNCTIONS ----------
+    def visit_FunctionDef(self, node):
+        if self.current_class is None:
+            self.functions.append(self.extract_function(node))
+        self.generic_visit(node)
+
+    # ---------- CLASSES ----------
+    def visit_ClassDef(self, node):
+        class_docstring = ast.get_docstring(node)
+
+        class_info = {
+            "class_name": node.name,
+            "has_docstring": class_docstring is not None,
+            "docstring": class_docstring,
+            "attributes": [],
+            "methods": [],
+        }
+
+        self.current_class = node.name
+
+        for item in node.body:
+            if isinstance(item, ast.Assign):
+                for target in item.targets:
+                    if isinstance(target, ast.Name):
+                        class_info["attributes"].append(target.id)
+
+            if isinstance(item, ast.FunctionDef):
+                class_info["methods"].append(self.extract_function(item, node.name))
+
+        self.classes.append(class_info)
+        self.current_class = None
+
+    # ---------- FUNCTION EXTRACTION ----------
+    def extract_function(self, node, class_name=None):
+        docstring = ast.get_docstring(node)
+
+        params = [
+            {
+                "name": arg.arg,
+                "type": ast.unparse(arg.annotation) if arg.annotation else None,
+            }
+            for arg in node.args.args
+        ]
+
+        param_names = [p["name"] for p in params]
+        signature = f"{node.name}({', '.join(param_names)})"
+
+        returns = ast.unparse(node.returns) if node.returns else None
+
+        raises = []
+        is_generator = False
+
+        for child in ast.walk(node):
+            if isinstance(child, ast.Raise):
+                raises.append(ast.unparse(child.exc) if child.exc else "Exception")
+            if isinstance(child, (ast.Yield, ast.YieldFrom)):
+                is_generator = True
+
+        return {
+            "name": node.name,
+            "class": class_name,
+            "signature": signature,  # ⭐ ADDED
+            "params": params,
+            "returns": returns,
+            "has_docstring": docstring is not None,
+            "lineno": node.lineno,
+            "docstring": docstring,
+            "raises": list(set(raises)),
+            "is_generator": is_generator,
+        }
+
+
+def parse_file(file_path):
+    with open(file_path, "r", encoding="utf-8") as f:
+        tree = ast.parse(f.read())
+
+    parser = CodeParser()
+    parser.visit(tree)
+
+    return {"functions": parser.functions, "classes": parser.classes}

autodocstring/pep257_fixer.py

@@ -0,0 +1,60 @@
+import subprocess
+import re
+
+CATEGORY_MAP = {
+    "D10": "Missing Docstrings",
+    "D20": "Whitespace Issues",
+    "D30": "Quotes Issues",
+    "D40": "Docstring Content Issues",
+}
+
+
+def categorize(code):
+    for k in CATEGORY_MAP:
+        if code.startswith(k):
+            return CATEGORY_MAP[k]
+    return "Other"
+
+
+def run_full_pep257(file_path):
+    result = subprocess.run(["pydocstyle", file_path], capture_output=True, text=True)
+
+    issues = []
+
+    for line in result.stdout.splitlines():
+
+        match = re.match(r"(.*?):(\d+)\s+(D\d+)\s+(.*)", line)
+
+        if match:
+            code = match.group(3)
+
+            issues.append(
+                {
+                    "File": match.group(1),
+                    "Line": int(match.group(2)),
+                    "Code": code,
+                    "Category": categorize(code),
+                    "Message": match.group(4),
+                    "Fix": suggest_fix(code),
+                }
+            )
+
+    return issues
+
+
+# Only SAFE automatic fixes
+def suggest_fix(code):
+
+    fixes = {
+        "D100": "Add module docstring at top of file",
+        "D101": "Add class docstring",
+        "D102": "Add method docstring",
+        "D103": "Add function docstring",
+        "D205": "Add blank line after summary",
+        "D400": "End summary with period",
+        "D401": "Use imperative mood",
+        "D403": "Capitalize first word",
+        "D404": "Avoid starting with 'This'",
+    }
+
+    return fixes.get(code, "Manual fix required")

autodocstring/pydoc_report.py

@@ -0,0 +1,31 @@
+import subprocess
+
+
+def run_pydocstyle(file_path):
+    """
+    Runs pydocstyle and returns RAW violations.
+    This version is FAIL-SAFE.
+    """
+
+    try:
+        result = subprocess.run(
+            ["pydocstyle", file_path],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+        )
+
+        output = result.stdout + result.stderr
+
+        if not output.strip():
+            return []
+
+        issues = []
+
+        for line in output.splitlines():
+            issues.append({"Violation": line})
+
+        return issues
+
+    except Exception as e:
+        return [{"Violation": str(e)}]

autodocstring/quality.py

@@ -0,0 +1,29 @@
+import subprocess
+import tempfile
+import os
+
+
+def pep257_report(file_path):
+    """
+    Runs pydocstyle on a Python file and returns:
+    - Total errors
+    - Error messages
+    - Compliance %
+    """
+
+    try:
+        result = subprocess.run(
+            ["pydocstyle", file_path], capture_output=True, text=True
+        )
+
+        errors = result.stdout.strip().split("\n") if result.stdout else []
+        errors = [e for e in errors if e.strip()]
+
+        return {
+            "total_errors": len(errors),
+            "messages": errors,
+            "compliance": 0 if errors else 100,
+        }
+
+    except Exception as e:
+        return {"total_errors": 0, "messages": [str(e)], "compliance": 0}

autodocstring_tool-0.1.0.dist-info/METADATA

@@ -0,0 +1,10 @@
+Metadata-Version: 2.4
+Name: autodocstring-tool
+Version: 0.1.0
+Summary: Automated Python docstring generator and enforcer
+Requires-Python: >=3.9
+License-File: LICENSE
+Requires-Dist: streamlit
+Requires-Dist: pandas
+Requires-Dist: pydocstyle
+Dynamic: license-file

autodocstring_tool-0.1.0.dist-info/RECORD

@@ -0,0 +1,19 @@
+autodocstring/__init__.py,sha256=kUR5RAFc7HCeiqdlX36dZOHkUI5wI6V_43RpEcD8b-0,22
+autodocstring/__main__.py,sha256=xzXQLgKVJ0b_xAWbzwNaeK6kGZaN0r0EIODKY1hAC0M,77
+autodocstring/cli.py,sha256=g1M0_FpILS_vZvnOrnTpfSmeRh0XvQJjvRkFlB5vEds,2676
+autodocstring/compliance.py,sha256=GKevPx2ciwtoi6aBUXUMh-1cKdeDGObX8FdPVoO2csc,2081
+autodocstring/config.py,sha256=XhCGQs3sJo1q-xk9A7O0RRu0GLmhKrwqHNFNYzDTvh8,409
+autodocstring/coverage.py,sha256=BEls7x1HPacmekNWkM5GbssLWPul1tYfC4VQEd6L1dk,2795
+autodocstring/generator.py,sha256=uh1izp0JNuM4Yw_CpP2BJKelt1Fbh_TufyTtAmN-3Gs,2305
+autodocstring/injector.py,sha256=XpTC2pMhqUytjeejVKYdw_c3gcXTGyKP_qJ40ov5IXc,2175
+autodocstring/llm_generator.py,sha256=tUZ7ofYrIp223aCm0RfAtWYEjxMcO3G0kRD5B0QvJeg,5392
+autodocstring/parser.py,sha256=uxECK0SnmZL0dSUA3mYIwpvz57ksi0kAwR_wsprjRWI,2819
+autodocstring/pep257_fixer.py,sha256=x9rbONRllE28cnbg6xOo0wC5bx0l_EDECheu50ebnZQ,1561
+autodocstring/pydoc_report.py,sha256=0OPX4AZP7d65NEQoJGv5BFOsvNDSUKm3GPYWiD_ouIU,666
+autodocstring/quality.py,sha256=DRcXOsI4_CiH53-kYyllZuqG4VSo7p7Poqs_oi5CDDM,731
+autodocstring_tool-0.1.0.dist-info/licenses/LICENSE,sha256=wNekdRt3aqWWk7_mI-LKOqoh8i_kSEcYsk_7hp_nbZs,1094
+autodocstring_tool-0.1.0.dist-info/METADATA,sha256=V-RmBF_5kENCmRHZNAdwCXSq46EfS0X8nV704GJElEY,271
+autodocstring_tool-0.1.0.dist-info/WHEEL,sha256=YCfwYGOYMi5Jhw2fU4yNgwErybb2IX5PEwBKV4ZbdBo,91
+autodocstring_tool-0.1.0.dist-info/entry_points.txt,sha256=84sJzO0Ap7fEMbOJxfjZjYJfNZ2HsSBnVzJ8F_8WaWY,57
+autodocstring_tool-0.1.0.dist-info/top_level.txt,sha256=so2wqryBeazxmDEbIO1vC1ma_wnCkiB0jaNjpL0RAmc,14
+autodocstring_tool-0.1.0.dist-info/RECORD,,

autodocstring_tool-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

autodocstring_tool-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+autodocstring = autodocstring.cli:main

autodocstring_tool-0.1.0.dist-info/licenses/LICENSE

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

autodocstring_tool-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+autodocstring