google-docstring-parser 0.0.1__py3-none-any.whl

google_docstring_parser/__init__.py

@@ -0,0 +1,4 @@
+"""Google Docstring Parser package.
+
+A lightweight, efficient parser for Google-style Python docstrings that converts them into structured dictionaries.
+"""

google_docstring_parser/google_docstring_parser.py

@@ -0,0 +1,133 @@
+"""Parser for Google-style docstrings.
+
+This module provides functions to parse Google-style docstrings into structured dictionaries.
+
+# CUSTOM LICENSE NOTICE FOR GOOGLE DOCSTRING PARSER
+#
+# Copyright (c) 2025 Vladimir Iglovikov
+#
+# ⚠️ IMPORTANT LICENSE NOTICE ⚠️
+# This package requires a PAID LICENSE for all users EXCEPT the Albumentations Team.
+#
+# - Free for Albumentations Team projects (https://github.com/albumentations-team)
+# - Paid license required for all other users
+#
+# Contact iglovikov@gmail.com to obtain a license before using this software.
+# See the LICENSE file for complete details.
+"""
+
+from __future__ import annotations
+
+import re
+from typing import Any
+
+from docstring_parser import parse
+
+
+def _extract_sections(docstring: str) -> dict[str, str]:
+    """Extract sections from a docstring.
+
+    Args:
+        docstring (str): The docstring to extract sections from
+
+    Returns:
+        A dictionary mapping section names to their content
+    """
+    sections: dict[str, str] = {}
+    current_section = "Description"
+    lines = docstring.split("\n")
+
+    section_content: list[str] = []
+    indent_level: int | None = None
+
+    for line in lines:
+        if not (stripped := line.strip()) and not section_content:
+            continue
+
+        # Check if this is a section header
+        if section_match := re.match(r"^([A-Za-z][A-Za-z0-9 ]+):$", stripped):
+            # Save previous section content
+            if section_content:
+                sections[current_section] = "\n".join(section_content).strip()
+                section_content = []
+
+            # Set new current section
+            current_section = section_match[1]
+            indent_level = None
+        else:
+            # If this is the first content line after a section header, determine indent level
+            if indent_level is None and stripped:
+                indent_level = len(line) - len(line.lstrip())
+
+            # Add line to current section content, removing one level of indentation
+            if stripped or section_content:  # Only add empty lines if we already have content
+                if indent_level is not None and line.startswith(" " * indent_level):
+                    # Remove one level of indentation
+                    processed_line = line[indent_level:]
+                    section_content.append(processed_line)
+                else:
+                    section_content.append(line)
+
+    # Add the last section
+    if section_content:
+        sections[current_section] = "\n".join(section_content).strip()
+
+    return sections
+
+
+def parse_google_docstring(docstring: str) -> dict[str, Any]:
+    """Parse a Google-style docstring into a structured dictionary.
+
+    Args:
+        docstring (str): The docstring to parse
+
+    Returns:
+        A dictionary with parsed docstring sections
+    """
+    if not docstring:
+        return {}
+
+    # Clean up the docstring
+    docstring = docstring.strip()
+
+    # Initialize result dictionary with only description
+    result: dict[str, Any] = {"Description": ""}
+
+    # Extract sections and parse docstring
+    sections = _extract_sections(docstring)
+    parsed = parse(docstring)
+
+    # Process description
+    if parsed.description:
+        result["Description"] = parsed.description.rstrip()
+
+    # Process args (only if present)
+    if "Args" in sections and (
+        args := [
+            {
+                "name": arg.arg_name.rstrip() if arg.arg_name is not None else None,
+                "type": arg.type_name.rstrip() if arg.type_name is not None else None,
+                "description": arg.description.rstrip() if arg.description is not None else None,
+            }
+            for arg in parsed.params
+        ]
+    ):
+        result["Args"] = args
+
+    # Process returns
+    if (
+        "Returns" in sections
+        and (returns_lines := sections["Returns"].split("\n"))
+        and (return_match := re.match(r"^(?:(\w+):\s*)?(.*)$", returns_lines[0].strip()))
+        and (return_desc := return_match[2])
+    ):
+        result["Returns"] = [{"type": return_match[1], "description": return_desc.rstrip()}]
+    else:
+        result["Returns"] = []
+
+    # Add other sections directly using dict union
+    return result | {
+        section: content.rstrip()
+        for section, content in sections.items()
+        if section not in ["Description", "Args", "Returns"]
+    }

google_docstring_parser-0.0.1.dist-info/LICENSE

@@ -0,0 +1,58 @@
+# CUSTOM LICENSE AGREEMENT FOR GOOGLE DOCSTRING PARSER
+
+Copyright (c) 2025 Vladimir Iglovikov
+
+## 1. DEFINITIONS
+
+"Software" refers to the Google Docstring Parser library, including all source code, documentation, and associated files.
+
+"Licensor" refers to Vladimir Iglovikov, the copyright holder of the Software.
+
+"Albumentations Team" refers to all projects hosted under the GitHub organization at https://github.com/albumentations-team.
+
+"User" refers to any individual or entity that uses, copies, modifies, or distributes the Software.
+
+## 2. GRANT OF LICENSE
+
+### 2.1 Albumentations Team Projects Use
+The Licensor hereby grants, free of charge, to all projects within the Albumentations Team GitHub organization and their official contributors the right to use, copy, modify, merge, publish, and distribute the Software for the purpose of developing and maintaining any project within the Albumentations Team organization.
+
+### 2.2 All Other Use
+All other Users, including but not limited to individuals, commercial entities, non-profit organizations, and open source projects other than Albumentations, must obtain a paid license from the Licensor before using, copying, modifying, or distributing the Software for any purpose.
+
+## 3. RESTRICTIONS
+
+### 3.1 General Restrictions
+Without a paid license, no User (except as specified in Section 2.1) may:
+- Use the Software for any purpose
+- Copy, modify, or distribute the Software
+- Create derivative works based on the Software
+- Sublicense the Software
+
+### 3.2 Albumentations Team Restrictions
+The Albumentations Team projects may not:
+- Grant rights to the Software to any third party beyond what is necessary for the development and maintenance of the Albumentations Team projects
+- Use the Software for purposes unrelated to the Albumentations Team projects
+
+## 4. OBTAINING A PAID LICENSE
+
+To obtain a paid license for the Software, please contact:
+
+Vladimir Iglovikov
+iglovikov@gmail.com
+
+## 5. WARRANTY DISCLAIMER
+
+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.
+
+## 6. TERMINATION
+
+This license automatically terminates if you violate any of its terms. Upon termination, you must cease all use of the Software and destroy all copies of the Software in your possession.
+
+## 7. MISCELLANEOUS
+
+This License represents the complete agreement concerning the subject matter hereof. If any provision of this License is held to be unenforceable, such provision shall be reformed only to the extent necessary to make it enforceable.
+
+## 8. GOVERNING LAW
+
+This License shall be governed by the laws of the United States of America.

google_docstring_parser-0.0.1.dist-info/METADATA

@@ -0,0 +1,148 @@
+Metadata-Version: 2.2
+Name: google-docstring-parser
+Version: 0.0.1
+Summary: A lightweight, efficient parser for Google-style Python docstrings that converts them into structured dictionaries.
+Author: Vladimir Iglovikov
+Maintainer: Vladimir Iglovikov
+License: Custom License - See LICENSE file for details
+Keywords: docstring,documentation,google-style,parser,python,static-analysis,type-hints
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: Other/Proprietary License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+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 :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Documentation
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: docstring-parser>=0.16
+Requires-Dist: typing-extensions>=4.9; python_version < "3.10"
+Provides-Extra: dev
+Requires-Dist: pre-commit>=3.5; extra == "dev"
+Requires-Dist: pytest>=8.3.3; extra == "dev"
+
+# Google Docstring Parser
+
+> [!IMPORTANT]
+> This package requires a PAID LICENSE for all users EXCEPT the Albumentations Team.
+> Contact iglovikov@gmail.com to obtain a license before using this software.
+
+A Python package for parsing Google-style docstrings into structured dictionaries.
+
+## License Information
+
+This package is available under a custom license:
+- **Free for Albumentations Team projects** (https://github.com/albumentations-team)
+- **Paid license required for all other users** (individuals, companies, and other open-source projects)
+
+See the [LICENSE](LICENSE) file for complete details.
+
+## Installation
+
+```bash
+pip install google-docstring-parser
+```
+
+## Usage
+
+```python
+from google_docstring_parser import parse_google_docstring
+
+docstring = '''Apply elastic deformation to images, masks, bounding boxes, and keypoints.
+
+This transformation introduces random elastic distortions to the input data. It's particularly
+useful for data augmentation in training deep learning models, especially for tasks like
+image segmentation or object detection where you want to maintain the relative positions of
+features while introducing realistic deformations.
+
+Args:
+    alpha (float): Scaling factor for the random displacement fields. Higher values result in
+        more pronounced distortions. Default: 1.0
+    sigma (float): Standard deviation of the Gaussian filter used to smooth the displacement
+        fields. Higher values result in smoother, more global distortions. Default: 50.0
+
+Example:
+    >>> import albumentations as A
+    >>> transform = A.ElasticTransform(alpha=1, sigma=50, p=0.5)
+'''
+
+parsed = parse_google_docstring(docstring)
+print(parsed)
+```
+
+Output:
+```python
+{
+    'Description': 'Apply elastic deformation to images, masks, bounding boxes, and keypoints.\n\nThis transformation introduces random elastic distortions to the input data. It\'s particularly\nuseful for data augmentation in training deep learning models, especially for tasks like\nimage segmentation or object detection where you want to maintain the relative positions of\nfeatures while introducing realistic deformations.',
+    'Args': [
+        {
+            'name': 'alpha',
+            'type': 'float',
+            'description': 'Scaling factor for the random displacement fields. Higher values result in\nmore pronounced distortions. Default: 1.0'
+        },
+        {
+            'name': 'sigma',
+            'type': 'float',
+            'description': 'Standard deviation of the Gaussian filter used to smooth the displacement\nfields. Higher values result in smoother, more global distortions. Default: 50.0'
+        }
+    ],
+    'Example': '>>> import albumentations as A\n>>> transform = A.ElasticTransform(alpha=1, sigma=50, p=0.5)'
+}
+```
+
+## Features
+
+- Parses Google-style docstrings into structured dictionaries
+- Extracts parameter names, types, and descriptions
+- Preserves other sections like Examples, Notes, etc.
+- Handles multi-line descriptions and indentation properly
+
+
+## Pre-commit Hook
+
+This package includes a pre-commit hook that checks if Google-style docstrings in your codebase can be parsed correctly.
+
+### Usage in Other Projects
+
+To use this hook in another project, add the following to your `.pre-commit-config.yaml`:
+
+```yaml
+- repo: https://github.com/ternaus/google-docstring-parser
+  rev: v0.0.1  # Use the latest version
+  hooks:
+    - id: check-google-docstrings
+      additional_dependencies: ["tomli>=2.0.0"]  # Required for pyproject.toml configuration
+```
+
+### Configuration
+
+The hook is configured via pyproject.toml, following modern Python tooling conventions like those used by mypy, ruff, and other tools.
+
+Add a `[tool.docstring_checker]` section to your pyproject.toml:
+
+```toml
+[tool.docstring_checker]
+paths = ["src", "tests"]                     # Directories or files to scan
+require_param_types = true                   # Require parameter types in docstrings
+exclude_files = ["conftest.py", "__init__.py"] # Files to exclude from checks
+verbose = false                              # Enable verbose output
+```
+
+This approach has several advantages:
+- Keeps all your project configuration in one place
+- Follows modern Python tooling conventions
+- Makes it easier to maintain and update configuration
+- Provides better IDE support and documentation
+
+For more details, see the [tools README](tools/README.md).

google_docstring_parser-0.0.1.dist-info/RECORD

@@ -0,0 +1,9 @@
+google_docstring_parser/__init__.py,sha256=SGFCYmhurVwW9Xg1c5aJihIvjvhZ0-yBO6UNJqpY91A,157
+google_docstring_parser/google_docstring_parser.py,sha256=gTtuCa_l8yhCdvf-NIOA0nRxpjLtxgvbrvSLpumgNNw,4379
+tools/__init__.py,sha256=kcECZzlVqWRVzmpblGFiuaEs-0iFCriLWzjJRNlpjMw,53
+tools/check_docstrings.py,sha256=4lnEy1wbzh0VA14cnKsqG0T0eemDobfk_o0RQJlIBD0,13139
+google_docstring_parser-0.0.1.dist-info/LICENSE,sha256=K28e2_I4KXVBq-N8hSFwN4QP4SA4GnUypO0Dy1k4VdE,3003
+google_docstring_parser-0.0.1.dist-info/METADATA,sha256=CFOV68kgnS0jQv8dcMyoBek4Izr017WvQTu-zD4HSlk,5955
+google_docstring_parser-0.0.1.dist-info/WHEEL,sha256=52BFRY2Up02UkjOa29eZOS2VxUrpPORXg1pkohGGUS8,91
+google_docstring_parser-0.0.1.dist-info/top_level.txt,sha256=_0utD2jjoqeoDpyqjmzAM1MBO1TdgbwvB0HTmbpyI8c,30
+google_docstring_parser-0.0.1.dist-info/RECORD,,

google_docstring_parser-0.0.1.dist-info/WHEEL

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

google_docstring_parser-0.0.1.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+google_docstring_parser
+tools

tools/__init__.py

@@ -0,0 +1 @@
+"""Tools for the google-docstring-parser package."""

tools/check_docstrings.py

@@ -0,0 +1,440 @@
+#!/usr/bin/env python
+"""Check that docstrings in specified folders can be parsed.
+
+This script scans Python files in specified directories and checks if their
+docstrings can be parsed with the google_docstring_parser.
+"""
+
+from __future__ import annotations
+
+import argparse
+import ast
+import re
+import sys
+from pathlib import Path
+from typing import Any, NamedTuple
+
+import tomli
+
+from google_docstring_parser.google_docstring_parser import parse_google_docstring
+
+# Default configuration
+DEFAULT_CONFIG = {
+    "paths": ["."],
+    "require_param_types": False,
+    "exclude_files": [],
+    "verbose": False,
+}
+
+
+class DocstringContext(NamedTuple):
+    """Context for docstring processing.
+
+    Args:
+        file_path (Path): Path to the file
+        line_no (int): Line number
+        name (str): Name of the function or class
+        verbose (bool): Whether to print verbose output
+        require_param_types (bool): Whether parameter types are required
+    """
+
+    file_path: Path
+    line_no: int
+    name: str
+    verbose: bool
+    require_param_types: bool = False
+
+
+def load_pyproject_config() -> dict[str, Any]:
+    """Load configuration from pyproject.toml if it exists.
+
+    Returns:
+        Dictionary with configuration values
+    """
+    config = DEFAULT_CONFIG.copy()
+
+    # Look for pyproject.toml in the current directory
+    pyproject_path = Path("pyproject.toml")
+    if not pyproject_path.is_file():
+        return config
+
+    try:
+        with pyproject_path.open("rb") as f:
+            pyproject_data = tomli.load(f)
+
+        # Check if our tool is configured
+        tool_config = pyproject_data.get("tool", {}).get("docstring_checker", {})
+        if not tool_config:
+            return config
+
+        # Update config with values from pyproject.toml
+        if "paths" in tool_config:
+            config["paths"] = tool_config["paths"]
+        if "require_param_types" in tool_config:
+            config["require_param_types"] = bool(tool_config["require_param_types"])
+        if "exclude_files" in tool_config:
+            config["exclude_files"] = tool_config["exclude_files"]
+        if "verbose" in tool_config:
+            config["verbose"] = bool(tool_config["verbose"])
+
+    except Exception as e:
+        print(f"Warning: Failed to load configuration from pyproject.toml: {e}")
+
+    return config
+
+
+def get_docstrings(file_path: Path) -> list[tuple[str, int, str | None, ast.AST | None]]:
+    """Extract docstrings from a Python file.
+
+    Args:
+        file_path (Path): Path to the Python file
+
+    Returns:
+        List of tuples containing (function/class name, line number, docstring, node)
+    """
+    with file_path.open(encoding="utf-8") as f:
+        content = f.read()
+
+    try:
+        tree = ast.parse(content)
+    except SyntaxError as e:
+        print(f"Syntax error in {file_path}: {e}")
+        return []
+
+    docstrings = []
+
+    # Get module docstring
+    if len(tree.body) > 0 and isinstance(tree.body[0], ast.Expr) and isinstance(tree.body[0].value, ast.Constant):
+        docstrings.append(("module", 1, tree.body[0].value.value, None))
+
+    # Get function and class docstrings
+    for node in ast.walk(tree):
+        if isinstance(node, (ast.FunctionDef, ast.ClassDef, ast.AsyncFunctionDef)):
+            docstring = ast.get_docstring(node)
+            if docstring:
+                docstrings.append((node.name, node.lineno, docstring, node))
+
+    return docstrings
+
+
+def check_param_types(docstring_dict: dict[str, Any], require_types: bool) -> list[str]:
+    """Check if all parameters have types if required.
+
+    Args:
+        docstring_dict (dict[str, Any]): Parsed docstring dictionary
+        require_types (bool): Whether parameter types are required
+
+    Returns:
+        List of error messages for parameters missing types or having invalid types
+    """
+    if not require_types or "Args" not in docstring_dict:
+        return []
+
+    errors = []
+    for arg in docstring_dict["Args"]:
+        if arg["type"] is None:
+            errors.append(f"Parameter '{arg['name']}' is missing a type in docstring")
+        elif "invalid type" in arg["type"].lower():
+            errors.append(f"Parameter '{arg['name']}' has an invalid type in docstring: '{arg['type']}'")
+
+    return errors
+
+
+def validate_docstring(docstring: str) -> list[str]:
+    """Perform additional validation on a docstring.
+
+    Args:
+        docstring (str): The docstring to validate
+
+    Returns:
+        List of validation error messages
+    """
+    errors = []
+
+    # Check for unclosed parentheses in parameter types
+    lines = docstring.split("\n")
+    for line in lines:
+        stripped_line = line.strip()
+        if not stripped_line:
+            continue
+
+        # Check for parameter definitions with unclosed parentheses
+        # Improved regex to better detect unclosed parentheses and brackets
+        if param_match := re.match(
+            r"^\s*(\w+)\s+\(([^)]*$|.*\[[^\]]*$)",
+            stripped_line,
+        ):
+            errors.append(f"Unclosed parenthesis in parameter type: '{stripped_line}'")
+
+        # Check for invalid type declarations
+        param_match = re.match(r"^\s*(\w+)\s+\((invalid type)\)", stripped_line)
+        if param_match:
+            errors.append(f"Invalid type declaration: '{stripped_line}'")
+
+    return errors
+
+
+def _format_error(context: DocstringContext, error: str) -> str:
+    """Format an error message consistently.
+
+    Args:
+        context (DocstringContext): Docstring context
+        error (str): Error message
+
+    Returns:
+        str: Formatted error message
+    """
+    msg = f"{context.file_path}:{context.line_no}: {error} in '{context.name}'"
+    if context.verbose:
+        print(msg)
+    return msg
+
+
+def _process_docstring(context: DocstringContext, docstring: str) -> list[str]:
+    """Process a single docstring.
+
+    Args:
+        context (DocstringContext): Docstring context
+        docstring (str): The docstring to process
+
+    Returns:
+        list[str]: List of error messages
+    """
+    errors = []
+    if not docstring:
+        return errors
+
+    # Validate docstring inline
+    try:
+        val_errors = validate_docstring(docstring)
+        if val_errors:
+            errors.extend(_format_error(context, err) for err in val_errors)
+    except Exception as e:
+        errors.append(_format_error(context, f"Error validating docstring: {e}"))
+        return errors
+
+    # Parse docstring inline
+    try:
+        parsed = parse_google_docstring(docstring)
+    except Exception as e:
+        errors.append(_format_error(context, f"Error parsing docstring: {e}"))
+        return errors
+
+    # Check parameter types (if required) inline
+    if context.require_param_types:
+        try:
+            type_errors = check_param_types(parsed, context.require_param_types)
+            errors.extend(_format_error(context, err) for err in type_errors)
+        except Exception as e:
+            errors.append(_format_error(context, f"Error checking parameter types: {e}"))
+
+    return errors
+
+
+def check_file(
+    file_path: Path,
+    require_param_types: bool = False,
+    verbose: bool = False,
+) -> list[str]:
+    """Check docstrings in a file.
+
+    Args:
+        file_path (Path): Path to the Python file
+        require_param_types (bool): Whether parameter types are required
+        verbose (bool): Whether to print verbose output
+
+    Returns:
+        List of error messages
+    """
+    if verbose:
+        print(f"Checking {file_path}")
+
+    errors = []
+
+    try:
+        docstrings = get_docstrings(file_path)
+    except Exception as e:
+        error_msg = f"{file_path}: Error getting docstrings: {e!s}"
+        errors.append(error_msg)
+        if verbose:
+            print(error_msg)
+        return errors
+
+    for name, line_no, docstring, _ in docstrings:
+        context = DocstringContext(
+            file_path=file_path,
+            line_no=line_no,
+            name=name,
+            verbose=verbose,
+            require_param_types=require_param_types,
+        )
+        errors.extend(_process_docstring(context, docstring))
+
+    return errors
+
+
+def scan_directory(
+    directory: Path,
+    exclude_files: list[str] | None = None,
+    require_param_types: bool = False,
+    verbose: bool = False,
+) -> list[str]:
+    """Scan a directory for Python files and check their docstrings.
+
+    Args:
+        directory (Path): Directory to scan
+        exclude_files (list[str] | None): List of filenames to exclude
+        require_param_types (bool): Whether parameter types are required
+        verbose (bool): Whether to print verbose output
+
+    Returns:
+        List of error messages
+    """
+    if exclude_files is None:
+        exclude_files = []
+
+    errors = []
+    for py_file in directory.glob("**/*.py"):
+        # Check if the file should be excluded
+        should_exclude = False
+        for exclude_pattern in exclude_files:
+            # Check if the filename matches exactly
+            if py_file.name == exclude_pattern:
+                should_exclude = True
+                break
+            # Check if the path ends with the pattern (for subdirectories)
+            if str(py_file).endswith(f"/{exclude_pattern}"):
+                should_exclude = True
+                break
+
+        if not should_exclude:
+            errors.extend(check_file(py_file, require_param_types, verbose))
+    return errors
+
+
+def _parse_args() -> argparse.Namespace:
+    """Parse command line arguments.
+
+    Returns:
+        Parsed arguments
+    """
+    parser = argparse.ArgumentParser(
+        description="Check that docstrings in specified folders can be parsed.",
+    )
+    parser.add_argument(
+        "paths",
+        nargs="*",
+        help="Directories or files to scan for Python docstrings",
+    )
+    parser.add_argument(
+        "--require-param-types",
+        action="store_true",
+        help="Require parameter types in docstrings",
+    )
+    parser.add_argument(
+        "--exclude-files",
+        help="Comma-separated list of filenames to exclude",
+        default="",
+    )
+    parser.add_argument("-v", "--verbose", action="store_true", help="Verbose output")
+    return parser.parse_args()
+
+
+def _get_config_values(args: argparse.Namespace, config: dict[str, Any]) -> tuple[list[str], bool, bool, list[str]]:
+    """Get configuration values from command line args and config.
+
+    Args:
+        args (argparse.Namespace): Command line arguments
+        config (dict[str, Any]): Configuration from pyproject.toml
+
+    Returns:
+        Tuple of (paths, require_param_types, verbose, exclude_files)
+    """
+    # Get paths
+    paths = args.paths or config["paths"]
+
+    # Get require_param_types
+    require_param_types = args.require_param_types or config["require_param_types"]
+
+    # Get verbose
+    verbose = args.verbose or config["verbose"]
+
+    # Get exclude_files
+    exclude_files = []
+    if args.exclude_files:
+        exclude_files = [f.strip() for f in args.exclude_files.split(",") if f.strip()]
+
+    # If no exclude_files specified on command line, use the ones from config
+    if not exclude_files:
+        exclude_files = config["exclude_files"]
+
+    return paths, require_param_types, verbose, exclude_files
+
+
+def _process_paths(
+    paths: list[str],
+    exclude_files: list[str],
+    require_param_types: bool,
+    verbose: bool,
+) -> list[str]:
+    """Process paths and collect errors.
+
+    Args:
+        paths (list[str]): List of paths to process
+        exclude_files (list[str]): List of files to exclude
+        require_param_types (bool): Whether to require parameter types
+        verbose (bool): Whether to print verbose output
+
+    Returns:
+        List of error messages
+    """
+    all_errors = []
+    for path_str in paths:
+        path = Path(path_str)
+        if path.is_dir():
+            errors = scan_directory(path, exclude_files, require_param_types, verbose)
+            all_errors.extend(errors)
+        elif path.is_file() and path.suffix == ".py":
+            errors = check_file(path, require_param_types, verbose)
+            all_errors.extend(errors)
+        else:
+            print(f"Error: {path} is not a directory or Python file")
+    return all_errors
+
+
+def main():
+    """Run the docstring checker."""
+    # Load configuration from pyproject.toml
+    config = load_pyproject_config()
+
+    # Parse command line arguments
+    args = _parse_args()
+
+    # Get configuration values
+    paths, require_param_types, verbose, exclude_files = _get_config_values(args, config)
+
+    # Print configuration if verbose
+    if verbose:
+        print("Configuration:")
+        print(f"  Paths: {paths}")
+        print(f"  Require parameter types: {require_param_types}")
+        print(f"  Exclude files: {exclude_files}")
+
+    if all_errors := _process_paths(
+        paths,
+        exclude_files,
+        require_param_types,
+        verbose,
+    ):
+        for error in all_errors:
+            print(error)
+        print(f"\nFound {len(all_errors)} error{'s' if len(all_errors) != 1 else ''}")
+        sys.exit(1)
+    elif verbose:
+        print("All docstrings parsed successfully!")
+
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()