docstring-format-checker 0.6.0__tar.gz → 0.8.0__tar.gz

{docstring_format_checker-0.6.0 → docstring_format_checker-0.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: docstring-format-checker
-Version: 0.6.0
+Version: 0.8.0
 Summary: A CLI tool to check and validate Python docstring formatting and completeness
 Author: Chris Mahoney
 Author-email: Chris Mahoney <docstring-format-checker@data-science-extensions.com>

{docstring_format_checker-0.6.0 → docstring_format_checker-0.8.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "docstring-format-checker"
-version = "v0.6.0"
+version = "v0.8.0"
 description = "A CLI tool to check and validate Python docstring formatting and completeness"
 readme = "README.md"
 license = "MIT"

{docstring_format_checker-0.6.0 → docstring_format_checker-0.8.0}/src/docstring_format_checker/__init__.py

@@ -4,7 +4,7 @@ Docstring Format Checker.
 A CLI tool to check and validate Python docstring formatting and completeness.
 """
 
-__version__ = "v0.6.0"
+__version__ = "v0.8.0"
 __author__ = "Chris Mahoney"
 __email__ = "docstring-format-checker@data-science-extensions.com"
 

{docstring_format_checker-0.6.0 → docstring_format_checker-0.8.0}/src/docstring_format_checker/cli.py

@@ -434,30 +434,24 @@ def _display_results(results: dict[str, list[DocstringError]], quiet: bool, outp
         console.print(table)
 
     else:
-        # Show compact output - each individual error on its own line
+        # Show compact output with grouped errors under function/class headers
         for file_path, errors in results.items():
             console.print(f"{NEW_LINE}{_cyan(file_path)}")
             for error in errors:
-                # Split error message into individual errors for list mode
+                # Print the header line with line number, item type and name
+                if error.line_number > 0:
+                    console.print(f"  [red]Line {error.line_number}[/red] - {error.item_type} '{error.item_name}':")
+                else:
+                    console.print(f"  {_red('Error')} - {error.item_type} '{error.item_name}':")
+
+                # Split error message into individual errors and indent them
                 if "; " in error.message:
                     individual_errors = [msg.strip() for msg in error.message.split("; ") if msg.strip()]
                     for individual_error in individual_errors:
-                        formatted_error = f"- {individual_error}"
-                        if error.line_number > 0:
-                            console.print(
-                                f"  [red]Line {error.line_number}[/red] - {error.item_type} '{error.item_name}': {formatted_error}"
-                            )
-                        else:
-                            console.print(f"  {_red('Error')}: {formatted_error}")
+                        console.print(f"    - {individual_error}")
                 else:
                     # Single error message
-                    formatted_error = f"- {error.message.strip()}"
-                    if error.line_number > 0:
-                        console.print(
-                            f"  [red]Line {error.line_number}[/red] - {error.item_type} '{error.item_name}': {formatted_error}"
-                        )
-                    else:
-                        console.print(f"  {_red('Error')}: {formatted_error}")
+                    console.print(f"    - {error.message.strip()}")
 
     # Summary - more descriptive message
     if total_functions == 1:

{docstring_format_checker-0.6.0 → docstring_format_checker-0.8.0}/src/docstring_format_checker/core.py

@@ -924,6 +924,7 @@ class DocstringChecker:
         # Check each line in the docstring
         lines: list[str] = docstring.split("\n")
         current_section = None
+        type_line_indent = None  # Track indentation of type definition lines
 
         for i, line in enumerate(lines):
             stripped_line: str = line.strip()
@@ -938,6 +939,7 @@ class DocstringChecker:
                 current_section: Optional[SectionConfig] = next(
                     (s for s in parentheses_sections if s.name.lower() == section_name), None
                 )
+                type_line_indent = None  # Reset for new section
                 continue
 
             # Non-admonition sections - only match actual section headers, not indented content
@@ -955,6 +957,7 @@ class DocstringChecker:
                         current_section = next(
                             (s for s in parentheses_sections if s.name.lower() == section_name), None
                         )
+                        type_line_indent = None  # Reset for new section
                         continue
                     # If it doesn't match a known section, fall through to content processing
 
@@ -962,6 +965,9 @@ class DocstringChecker:
             if current_section and stripped_line and not stripped_line.startswith(("!", "?", "#")):
                 # Look for parameter/type definitions
                 if ":" in stripped_line:
+                    # Calculate current line indentation
+                    current_indent = len(line) - len(line.lstrip())
+
                     # Skip description lines that start with common description words
                     description_prefixes = [
                         "default:",
@@ -986,30 +992,65 @@ class DocstringChecker:
                     ):
                         continue
 
+                    # For list_type sections, we need special handling
+                    if current_section.type == "list_type":
+                        # Check if this line has parentheses at the beginning
+                        if re.search(r"^\s*\([^)]+\):", stripped_line):
+                            # This is a valid type definition line, remember its indentation
+                            type_line_indent = current_indent
+                            continue
+                        else:
+                            # If no type definition has been found yet, allow lines with colons as possible descriptions
+                            if type_line_indent is None:
+                                continue
+                            # Check if this is a description line (more indented than type line)
+                            if current_indent > type_line_indent:
+                                # This is a description line, skip validation
+                                continue
+                            else:
+                                # This should be a type definition but doesn't have proper format
+                                errors.append(
+                                    f"Section '{current_section.name}' (type: '{current_section.type}') requires "
+                                    f"parenthesized types, see: '{stripped_line}'"
+                                )
                     # For list_name_and_type sections, check format like "name (type):" or "(type):"
-                    if current_section.type == "list_name_and_type":
-                        # Pattern: name (type): or (type):
-                        # But skip if it doesn't look like a parameter definition (e.g., has multiple words before the colon)
-                        colon_part = stripped_line.split(":")[0].strip()
-                        # Skip if it contains phrases that indicate it's a description, not a parameter
-                        if any(
-                            word in colon_part.lower() for word in ["default", "output", "format", "show", "example"]
-                        ):
+                    elif current_section.type == "list_name_and_type":
+                        # Check if this line has parentheses and looks like a parameter definition
+                        if re.search(r"\([^)]+\):", stripped_line):
+                            # This is a valid parameter definition line, remember its indentation
+                            type_line_indent = current_indent
                             continue
-
-                        if not re.search(r"\([^)]+\):", stripped_line):
-                            errors.append(
-                                f"Section '{current_section.name}' (type: '{current_section.type}') requires "
-                                f"parenthesized types, see: '{stripped_line}'"
-                            )
-
-                    # For list_type sections, check format like "(Type):"
-                    elif current_section.type == "list_type":
-                        # Pattern: (Type):
-                        if not re.search(r"^\s*\([^)]+\):", stripped_line):
-                            errors.append(
-                                f"Section '{current_section.name}' (type: '{current_section.type}') requires "
-                                f"parenthesized types, see: '{stripped_line}'"
-                            )
+                        else:
+                            # Check if this is likely a description line based on various criteria
+                            colon_part = stripped_line.split(":")[0].strip()
+
+                            # Skip if it contains phrases that indicate it's a description, not a parameter
+                            if any(
+                                word in colon_part.lower()
+                                for word in ["default", "output", "format", "show", "example"]
+                            ):
+                                continue
+
+                            # Skip if it starts with bullet points or list markers
+                            if stripped_line.strip().startswith(("-", "*", "•", "+")):
+                                continue
+
+                            # If we have found a parameter definition, check if this is a description line
+                            if type_line_indent is not None:
+                                # Skip if this is more indented than the parameter definition (description line)
+                                if current_indent > type_line_indent:
+                                    continue
+
+                            # Skip if the line before the colon contains multiple words (likely description)
+                            words_before_colon = colon_part.split()
+                            if len(words_before_colon) > 2:  # More than "param_name (type)"
+                                continue
+
+                            # Only flag lines that could reasonably be parameter definitions
+                            if ":" in stripped_line and not stripped_line.strip().startswith("#"):
+                                errors.append(
+                                    f"Section '{current_section.name}' (type: '{current_section.type}') requires "
+                                    f"parenthesized types, see: '{stripped_line}'"
+                                )
 
         return errors