check-duplicate-python-functions 1.0.0__tar.gz

check_duplicate_python_functions-1.0.0/CHANGELOG.md

@@ -0,0 +1,58 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+### Added
+- Comprehensive code comments and docstrings throughout the codebase
+- Detailed README.md with usage instructions, features, and examples
+- CHANGELOG.md to track project changes
+- PyPI packaging support with `setup.py` and `pyproject.toml`
+- `MANIFEST.in` for including non-Python files in distribution
+- `.gitignore` for build artifacts and development files
+- `PYPI_UPLOAD.md` guide for publishing to PyPI
+- Version number (`__version__ = "1.0.0"`) in main module
+- Console script entry point: `check-duplicate-functions` command
+
+### Changed
+- Enhanced docstrings for all classes and functions with detailed parameter descriptions
+- Improved inline comments explaining complex logic
+- Updated module-level docstring with comprehensive usage information
+- Enhanced error messages and documentation
+- Updated README.md with PyPI installation instructions
+- Added multiple installation options (PyPI, git clone, direct download)
+
+### Documentation
+- Added comprehensive README.md covering:
+  - Features and capabilities
+  - Installation and usage instructions (including PyPI)
+  - Output format and exit codes
+  - How the tool works internally
+  - Special method handling
+  - Limitations and error handling
+  - Example use cases
+- Added PyPI upload guide with step-by-step instructions
+
+## [1.0.0] - Initial Release
+
+### Added
+- Initial implementation of duplicate function detection
+- AST-based function analysis using Python's `ast` module
+- Support for regular and async function detection
+- Class context tracking for methods
+- Special method exclusion (dunder methods)
+- Function signature extraction with type annotation support
+- Error handling for file operations and syntax errors
+- Command-line interface
+
+### Features
+- Detects duplicate function names in Python files
+- Handles async functions
+- Tracks class context for methods
+- Excludes special methods from duplicate checks
+- Extracts and compares function signatures
+- Comprehensive error handling

check_duplicate_python_functions-1.0.0/MANIFEST.in

@@ -0,0 +1,4 @@
+include README.md
+include CHANGELOG.md
+include pyproject.toml
+recursive-include . *.py

check_duplicate_python_functions-1.0.0/PKG-INFO

@@ -0,0 +1,182 @@
+Metadata-Version: 2.4
+Name: check-duplicate-python-functions
+Version: 1.0.0
+Summary: A Python tool to detect duplicate function names in Python source files using AST parsing
+Home-page: https://github.com/pandiyarajk/check-duplicate-python-functions
+Author: Pandiyaraj Karuppasamy
+Author-email: Pandiyaraj Karuppasamy <pandiyarajk@live.com>
+Maintainer-email: Pandiyaraj Karuppasamy <pandiyarajk@live.com>
+Project-URL: Homepage, https://github.com/pandiyarajk/check-duplicate-python-functions
+Project-URL: Documentation, https://github.com/pandiyarajk/check-duplicate-python-functions#readme
+Project-URL: Repository, https://github.com/pandiyarajk/check-duplicate-python-functions
+Project-URL: Issues, https://github.com/pandiyarajk/check-duplicate-python-functions/issues
+Project-URL: Changelog, https://github.com/pandiyarajk/check-duplicate-python-functions/blob/main/CHANGE_LOG.md
+Keywords: python,ast,duplicate,functions,code-quality,static-analysis,linter
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+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: Topic :: Software Development :: Testing
+Classifier: Topic :: Software Development :: Quality Assurance
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Dynamic: author
+Dynamic: home-page
+Dynamic: requires-python
+
+# check-duplicate-python-functions
+
+A Python tool to detect duplicate function names in Python source files using AST (Abstract Syntax Tree) parsing.
+
+**Repository**: [https://github.com/pandiyarajk/check-duplicate-python-functions](https://github.com/pandiyarajk/check-duplicate-python-functions)
+
+**Author**: Pandiyaraj Karuppasamy (pandiyarajk@live.com)
+
+## Features
+
+- **Detects duplicate function names**: Identifies functions with the same name defined multiple times in a file
+- **AST-based analysis**: Uses Python's built-in AST module for accurate parsing
+- **Handles async functions**: Properly identifies and distinguishes async functions
+- **Class context awareness**: Tracks function context (module-level vs class methods)
+- **Special method exclusion**: Excludes special methods (like `__init__`, `__str__`, etc.) from duplicate checks since they can legitimately appear in multiple classes
+- **Signature extraction**: Extracts and compares function signatures including type annotations
+- **Comprehensive error handling**: Handles file not found, permission errors, encoding issues, and syntax errors gracefully
+
+## Requirements
+
+- Python 3.6 or higher
+- No external dependencies (uses only Python standard library)
+
+## Installation
+
+### Option 1: Install from PyPI (Recommended)
+```bash
+pip install check-duplicate-python-functions
+```
+
+After installation, you can use the command-line tool:
+```bash
+check-duplicate-functions <python_file_path>
+```
+
+### Option 2: Clone the repository
+```bash
+git clone https://github.com/pandiyarajk/check-duplicate-python-functions.git
+cd check-duplicate-python-functions
+python check_duplicate_functions.py <python_file_path>
+```
+
+### Option 3: Download directly
+No installation required. Simply download the `check_duplicate_functions.py` file and run it:
+```bash
+python check_duplicate_functions.py <python_file_path>
+```
+
+## Usage
+
+### If installed from PyPI:
+```bash
+check-duplicate-functions <python_file_path>
+```
+
+### If using the script directly:
+```bash
+python check_duplicate_functions.py <python_file_path>
+```
+
+### Examples
+
+```bash
+# Check a single Python file (PyPI installation)
+check-duplicate-functions my_script.py
+
+# Check a file in a subdirectory (PyPI installation)
+check-duplicate-functions src/utils.py
+
+# Using the script directly
+python check_duplicate_functions.py my_script.py
+python check_duplicate_functions.py src/utils.py
+```
+
+## Output
+
+The script produces output only when duplicates are found or errors occur:
+
+- **No duplicates**: Script exits silently with exit code 0
+- **Duplicates found**: Prints each duplicate function name and the line numbers where it appears:
+  ```
+  [DUPLICATE] 'my_function' appears on lines: 10, 25, 42
+  ```
+- **Errors**: Prints error messages for file not found, syntax errors, etc.:
+  ```
+  [ERROR] File not found: nonexistent.py
+  [ERROR] Syntax error in file.py: invalid syntax (line 5)
+  ```
+
+## Exit Codes
+
+- `0`: Success (no duplicates found or analysis completed successfully)
+- `1`: Error (invalid arguments, file not found, syntax error, or other issues)
+
+## How It Works
+
+1. **File Reading**: Reads the Python source file with UTF-8 encoding
+2. **AST Parsing**: Parses the source code into an Abstract Syntax Tree
+3. **Function Extraction**: Traverses the AST to extract all function definitions:
+   - Regular functions (`def`)
+   - Async functions (`async def`)
+   - Methods within classes
+   - Function signatures with type annotations
+4. **Duplicate Detection**: Identifies functions with duplicate names (excluding special methods)
+5. **Result Reporting**: Prints duplicate function names and their line numbers
+
+## Special Methods
+
+Special methods (dunder methods) like `__init__`, `__str__`, `__repr__`, etc. are excluded from duplicate checking because:
+- They are expected to appear in multiple classes
+- They serve specific purposes in Python's object model
+- Having them in multiple classes is not considered a code quality issue
+
+## Limitations
+
+- Only analyzes a single file at a time (no recursive directory scanning)
+- Does not detect duplicates across different files
+- Special methods are excluded from duplicate detection
+- Functions with identical names but different signatures are still reported as duplicates
+
+## Error Handling
+
+The script handles various error conditions:
+
+- **File not found**: Returns appropriate error message
+- **Permission denied**: Reports permission errors
+- **Encoding errors**: Handles files with non-UTF-8 encoding issues
+- **Syntax errors**: Reports Python syntax errors with line information
+- **Unexpected errors**: Catches and reports any unexpected exceptions
+
+## Example Use Cases
+
+- **Code review**: Quickly identify potential duplicate function definitions before code review
+- **Refactoring**: Find duplicate functions that might need to be consolidated
+- **Code quality**: Maintain clean codebase by detecting accidental function name reuse
+- **Large codebases**: Analyze individual files in large projects for duplicate functions
+
+## License
+
+This project is provided as-is for use in detecting duplicate functions in Python code.
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit issues or pull requests on [GitHub](https://github.com/pandiyarajk/check-duplicate-python-functions).
+
+## Author
+
+**Pandiyaraj Karuppasamy**
+- Email: pandiyarajk@live.com
+- GitHub: [@pandiyarajk](https://github.com/pandiyarajk)

check_duplicate_python_functions-1.0.0/README.md

@@ -0,0 +1,150 @@
+# check-duplicate-python-functions
+
+A Python tool to detect duplicate function names in Python source files using AST (Abstract Syntax Tree) parsing.
+
+**Repository**: [https://github.com/pandiyarajk/check-duplicate-python-functions](https://github.com/pandiyarajk/check-duplicate-python-functions)
+
+**Author**: Pandiyaraj Karuppasamy (pandiyarajk@live.com)
+
+## Features
+
+- **Detects duplicate function names**: Identifies functions with the same name defined multiple times in a file
+- **AST-based analysis**: Uses Python's built-in AST module for accurate parsing
+- **Handles async functions**: Properly identifies and distinguishes async functions
+- **Class context awareness**: Tracks function context (module-level vs class methods)
+- **Special method exclusion**: Excludes special methods (like `__init__`, `__str__`, etc.) from duplicate checks since they can legitimately appear in multiple classes
+- **Signature extraction**: Extracts and compares function signatures including type annotations
+- **Comprehensive error handling**: Handles file not found, permission errors, encoding issues, and syntax errors gracefully
+
+## Requirements
+
+- Python 3.6 or higher
+- No external dependencies (uses only Python standard library)
+
+## Installation
+
+### Option 1: Install from PyPI (Recommended)
+```bash
+pip install check-duplicate-python-functions
+```
+
+After installation, you can use the command-line tool:
+```bash
+check-duplicate-functions <python_file_path>
+```
+
+### Option 2: Clone the repository
+```bash
+git clone https://github.com/pandiyarajk/check-duplicate-python-functions.git
+cd check-duplicate-python-functions
+python check_duplicate_functions.py <python_file_path>
+```
+
+### Option 3: Download directly
+No installation required. Simply download the `check_duplicate_functions.py` file and run it:
+```bash
+python check_duplicate_functions.py <python_file_path>
+```
+
+## Usage
+
+### If installed from PyPI:
+```bash
+check-duplicate-functions <python_file_path>
+```
+
+### If using the script directly:
+```bash
+python check_duplicate_functions.py <python_file_path>
+```
+
+### Examples
+
+```bash
+# Check a single Python file (PyPI installation)
+check-duplicate-functions my_script.py
+
+# Check a file in a subdirectory (PyPI installation)
+check-duplicate-functions src/utils.py
+
+# Using the script directly
+python check_duplicate_functions.py my_script.py
+python check_duplicate_functions.py src/utils.py
+```
+
+## Output
+
+The script produces output only when duplicates are found or errors occur:
+
+- **No duplicates**: Script exits silently with exit code 0
+- **Duplicates found**: Prints each duplicate function name and the line numbers where it appears:
+  ```
+  [DUPLICATE] 'my_function' appears on lines: 10, 25, 42
+  ```
+- **Errors**: Prints error messages for file not found, syntax errors, etc.:
+  ```
+  [ERROR] File not found: nonexistent.py
+  [ERROR] Syntax error in file.py: invalid syntax (line 5)
+  ```
+
+## Exit Codes
+
+- `0`: Success (no duplicates found or analysis completed successfully)
+- `1`: Error (invalid arguments, file not found, syntax error, or other issues)
+
+## How It Works
+
+1. **File Reading**: Reads the Python source file with UTF-8 encoding
+2. **AST Parsing**: Parses the source code into an Abstract Syntax Tree
+3. **Function Extraction**: Traverses the AST to extract all function definitions:
+   - Regular functions (`def`)
+   - Async functions (`async def`)
+   - Methods within classes
+   - Function signatures with type annotations
+4. **Duplicate Detection**: Identifies functions with duplicate names (excluding special methods)
+5. **Result Reporting**: Prints duplicate function names and their line numbers
+
+## Special Methods
+
+Special methods (dunder methods) like `__init__`, `__str__`, `__repr__`, etc. are excluded from duplicate checking because:
+- They are expected to appear in multiple classes
+- They serve specific purposes in Python's object model
+- Having them in multiple classes is not considered a code quality issue
+
+## Limitations
+
+- Only analyzes a single file at a time (no recursive directory scanning)
+- Does not detect duplicates across different files
+- Special methods are excluded from duplicate detection
+- Functions with identical names but different signatures are still reported as duplicates
+
+## Error Handling
+
+The script handles various error conditions:
+
+- **File not found**: Returns appropriate error message
+- **Permission denied**: Reports permission errors
+- **Encoding errors**: Handles files with non-UTF-8 encoding issues
+- **Syntax errors**: Reports Python syntax errors with line information
+- **Unexpected errors**: Catches and reports any unexpected exceptions
+
+## Example Use Cases
+
+- **Code review**: Quickly identify potential duplicate function definitions before code review
+- **Refactoring**: Find duplicate functions that might need to be consolidated
+- **Code quality**: Maintain clean codebase by detecting accidental function name reuse
+- **Large codebases**: Analyze individual files in large projects for duplicate functions
+
+## License
+
+This project is provided as-is for use in detecting duplicate functions in Python code.
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit issues or pull requests on [GitHub](https://github.com/pandiyarajk/check-duplicate-python-functions).
+
+## Author
+
+**Pandiyaraj Karuppasamy**
+- Email: pandiyarajk@live.com
+- GitHub: [@pandiyarajk](https://github.com/pandiyarajk)

check_duplicate_python_functions-1.0.0/check_duplicate_functions.py

@@ -0,0 +1,377 @@
+#!/usr/bin/env python3
+"""
+Python script to detect duplicate function names in Python files.
+
+This script analyzes Python source files using AST (Abstract Syntax Tree) parsing
+to identify duplicate function definitions. It can detect:
+- Duplicate function names at module level
+- Duplicate method names within classes
+- Functions with identical signatures (potential code duplication)
+- Special methods (like __init__, __str__, etc.) are excluded from duplicate checks
+  as they can legitimately appear in multiple classes
+
+Usage:
+    python check_duplicate_functions.py <python_file_path>
+
+Example:
+    python check_duplicate_functions.py my_script.py
+
+Exit codes:
+    0 - Success (no duplicates found or script completed successfully)
+    1 - Error (file not found, syntax error, or other issues)
+"""
+
+__version__ = "1.0.0"
+
+import ast
+import os
+import sys
+from collections import Counter, defaultdict
+from typing import Dict
+
+
+class FunctionAnalyzer(ast.NodeVisitor):
+    """
+    AST visitor to extract function definitions from Python code.
+    
+    This class traverses the Abstract Syntax Tree of a Python file to collect
+    information about all function definitions, including their names, line numbers,
+    signatures, and class context.
+    
+    Attributes:
+        functions: List of tuples containing function information:
+            (name, line_number, signature, class_context, is_method, is_special_method)
+        function_lines: Dictionary mapping function names to lists of line numbers
+            where they are defined (excludes special methods)
+        function_signatures: Dictionary mapping function names to lists of their
+            signatures (excludes special methods)
+        class_stack: Stack to track the current class context during AST traversal
+    """
+
+    def __init__(self):
+        """Initialize the FunctionAnalyzer with empty data structures."""
+        self.functions = []
+        # function_name -> list of line numbers where function is defined
+        self.function_lines = {}
+        # function_name -> list of signatures (for detecting identical signatures)
+        self.function_signatures = {}
+        # Track current class context during AST traversal
+        self.class_stack = []
+
+    def visit_FunctionDef(self, node):
+        """
+        Visit regular (synchronous) function definitions.
+        
+        Args:
+            node: AST node representing a function definition
+        """
+        self._add_function(node.name, node.lineno, self._get_signature(node))
+        self.generic_visit(node)
+
+    def visit_AsyncFunctionDef(self, node):
+        """
+        Visit async function definitions.
+        
+        Args:
+            node: AST node representing an async function definition
+        """
+        self._add_function(f"async {node.name}", node.lineno, self._get_signature(node))
+        self.generic_visit(node)
+
+    def visit_ClassDef(self, node):
+        """
+        Visit class definitions to track class context for methods.
+        
+        This method maintains a stack of class names to provide context
+        for nested class definitions and their methods.
+        
+        Args:
+            node: AST node representing a class definition
+        """
+        self.class_stack.append(node.name)
+        self.generic_visit(node)
+        self.class_stack.pop()
+
+    def _add_function(self, name: str, lineno: int, signature: str):
+        """
+        Add function to the tracking lists with context information.
+        
+        This method stores function information including whether it's a method,
+        whether it's a special method (like __init__), and its class context.
+        Special methods are excluded from duplicate checking since they can
+        legitimately appear in multiple classes.
+        
+        Args:
+            name: Function name (may include "async " prefix for async functions)
+            lineno: Line number where the function is defined
+            signature: String representation of the function signature
+        """
+        # Determine if function is defined within a class (method)
+        class_context = self.class_stack[-1] if self.class_stack else None
+        is_method = class_context is not None
+        # Check if this is a special method (dunder method)
+        is_special_method = name.startswith("__") and name.endswith("__")
+
+        # Store complete function information
+        func_info = (
+            name,
+            lineno,
+            signature,
+            class_context,
+            is_method,
+            is_special_method,
+        )
+        self.functions.append(func_info)
+
+        # For duplicate checking, exclude special methods like __init__, __str__, etc.
+        # since they can legitimately appear in multiple classes
+        if not is_special_method:
+            # Track line numbers for each function name
+            if name not in self.function_lines:
+                self.function_lines[name] = []
+            self.function_lines[name].append(lineno)
+
+            # Track signatures for detecting identical function signatures
+            if name not in self.function_signatures:
+                self.function_signatures[name] = []
+            self.function_signatures[name].append(signature)
+
+    def _get_signature(self, node) -> str:
+        """
+        Extract function signature as a string representation.
+        
+        This method constructs a complete function signature including:
+        - Regular arguments with optional type annotations
+        - *args (variable positional arguments)
+        - **kwargs (variable keyword arguments)
+        - Keyword-only arguments
+        - Return type annotation
+        
+        Args:
+            node: AST node representing a function definition
+            
+        Returns:
+            String representation of the function signature, e.g.:
+            "(arg1: str, arg2: int, *args, **kwargs) -> bool"
+        """
+        args = []
+        
+        # Process regular positional arguments
+        if node.args.args:
+            for arg in node.args.args:
+                arg_str = arg.arg
+                if arg.annotation:
+                    arg_str += f": {self._get_annotation_name(arg.annotation)}"
+                args.append(arg_str)
+
+        # Handle *args (variable positional arguments)
+        if node.args.vararg:
+            vararg_str = f"*{node.args.vararg.arg}"
+            if node.args.vararg.annotation:
+                vararg_str += f": {self._get_annotation_name(node.args.vararg.annotation)}"
+            args.append(vararg_str)
+
+        # Handle **kwargs (variable keyword arguments)
+        if node.args.kwarg:
+            kwarg_str = f"**{node.args.kwarg.arg}"
+            if node.args.kwarg.annotation:
+                kwarg_str += f": {self._get_annotation_name(node.args.kwarg.annotation)}"
+            args.append(kwarg_str)
+
+        # Handle keyword-only arguments (arguments after * or *args)
+        if node.args.kwonlyargs:
+            for arg in node.args.kwonlyargs:
+                arg_str = arg.arg
+                if arg.annotation:
+                    arg_str += f": {self._get_annotation_name(arg.annotation)}"
+                args.append(arg_str)
+
+        signature = f"({', '.join(args)})"
+
+        # Add return type annotation if present
+        if node.returns:
+            signature += f" -> {self._get_annotation_name(node.returns)}"
+
+        return signature
+
+    def _get_annotation_name(self, annotation) -> str:
+        """
+        Convert AST annotation node to string representation.
+        
+        This method recursively processes type annotations from the AST,
+        handling various annotation types including:
+        - Simple names (e.g., 'str', 'int')
+        - Attribute access (e.g., 'typing.List', 'collections.abc.Iterable')
+        - Subscripts (e.g., 'List[str]', 'Dict[str, int]')
+        - Literal types (e.g., 'Literal["value"]')
+        - Compatibility with older Python versions (ast.Index)
+        
+        Args:
+            annotation: AST node representing a type annotation
+            
+        Returns:
+            String representation of the type annotation
+        """
+        if isinstance(annotation, ast.Name):
+            # Simple type name like 'str', 'int', 'bool'
+            return annotation.id
+        elif isinstance(annotation, ast.Attribute):
+            # Attribute access like 'typing.List', 'collections.abc.Iterable'
+            return f"{self._get_annotation_name(annotation.value)}.{annotation.attr}"
+        elif isinstance(annotation, ast.Subscript):
+            # Generic types like 'List[str]', 'Dict[str, int]'
+            return f"{self._get_annotation_name(annotation.value)}[{self._get_annotation_name(annotation.slice)}]"
+        elif isinstance(annotation, ast.Index):
+            # Compatibility with older Python versions (< 3.9)
+            return self._get_annotation_name(annotation.value)
+        elif isinstance(annotation, ast.Constant):
+            # Literal types and constants
+            return repr(annotation.value)
+        else:
+            # Fallback for any other annotation types
+            return str(annotation)
+
+
+def analyze_file(file_path: str) -> Dict:
+    """
+    Analyze a Python file for duplicate function names.
+    
+    This function reads a Python file, parses it into an AST, and analyzes
+    all function definitions to identify duplicates. It handles various
+    error cases including file not found, permission errors, encoding issues,
+    and syntax errors.
+    
+    Args:
+        file_path: Path to the Python file to analyze
+        
+    Returns:
+        Dictionary containing analysis results with the following keys:
+        - 'duplicates': Dictionary mapping function names to sorted lists of
+          line numbers where duplicates are found (excludes special methods)
+        - 'all_functions': List of tuples containing all function information:
+          (name, line_number, signature, class_context, is_method, is_special_method)
+        - 'duplicate_signatures': Dictionary mapping signatures to lists of
+          function names that share identical signatures
+        - 'total_functions': Total number of functions found (including special methods)
+        - 'unique_function_names': Number of unique function names (excluding special methods)
+        - 'special_methods': List of special methods (dunder methods) found
+        - 'error': Error message string (only present if an error occurred)
+    """
+    # Read the source file with error handling
+    try:
+        with open(file_path, "r", encoding="utf-8") as f:
+            source_code = f.read()
+    except FileNotFoundError:
+        return {"error": f"File not found: {file_path}"}
+    except PermissionError:
+        return {"error": f"Permission denied: {file_path}"}
+    except UnicodeDecodeError:
+        return {"error": f"Encoding error reading file: {file_path}"}
+
+    # Parse the source code into an AST
+    try:
+        tree = ast.parse(source_code, filename=file_path)
+    except SyntaxError as e:
+        return {"error": f"Syntax error in {file_path}: {e}"}
+
+    # Analyze the AST to extract function information
+    analyzer = FunctionAnalyzer()
+    analyzer.visit(tree)
+
+    # Find duplicate function names (functions with the same name defined multiple times)
+    duplicates = {}
+    for func_name, lines in analyzer.function_lines.items():
+        if len(lines) > 1:
+            duplicates[func_name] = sorted(lines)
+
+    # Find functions with identical signatures (potential code duplication or overloads)
+    duplicate_signatures = defaultdict(list)
+    for func_name, signatures in analyzer.function_signatures.items():
+        sig_counter = Counter(signatures)
+        for sig, count in sig_counter.items():
+            if count > 1:
+                duplicate_signatures[sig].extend([func_name] * count)
+
+    return {
+        "duplicates": duplicates,
+        "all_functions": analyzer.functions,
+        "duplicate_signatures": dict(duplicate_signatures),
+        "total_functions": len(analyzer.functions),
+        "unique_function_names": len(analyzer.function_lines),
+        # Extract special methods (functions where is_special_method=True, index 5 in tuple)
+        "special_methods": [f for f in analyzer.functions if f[5]],
+    }
+
+
+def print_analysis_results(file_path: str, results: Dict):
+    """
+    Print the analysis results in a readable format.
+    
+    This function only prints output when duplicates are found or errors occur.
+    If no duplicates are found, the function produces no output (silent success).
+    
+    Args:
+        file_path: Path to the analyzed file (for context in error messages)
+        results: Dictionary containing analysis results from analyze_file()
+    """
+    # Print error messages if any occurred during analysis
+    if "error" in results:
+        print(f"[ERROR] {results['error']}")
+        return
+
+    # Print duplicate function names and their line numbers
+    duplicates = results.get("duplicates", {})
+    if duplicates:
+        for func_name, lines in duplicates.items():
+            print(f"[DUPLICATE] '{func_name}' appears on lines: {', '.join(map(str, lines))}")
+
+
+def main():
+    """
+    Main function to handle command line arguments and orchestrate the analysis.
+    
+    This function:
+    1. Validates command line arguments
+    2. Checks if the file exists
+    3. Warns if the file doesn't have a .py extension
+    4. Analyzes the file for duplicate functions
+    5. Prints the results
+    
+    Exit codes:
+        0: Success (no duplicates found or analysis completed)
+        1: Error (invalid arguments, file not found, or analysis error)
+    """
+    # Validate command line arguments
+    if len(sys.argv) != 2:
+        print("Usage: python check_duplicate_functions.py <python_file_path>")
+        print("Example: python check_duplicate_functions.py my_script.py")
+        sys.exit(1)
+
+    file_path = sys.argv[1]
+
+    # Check if file exists
+    if not os.path.isfile(file_path):
+        print(f"[ERROR] File not found: {file_path}")
+        sys.exit(1)
+
+    # Warn if file doesn't have .py extension (but continue anyway)
+    if not file_path.endswith(".py"):
+        print(f"[WARNING] File doesn't have .py extension: {file_path}")
+
+    # Perform analysis and print results
+    results = analyze_file(file_path)
+    print_analysis_results(file_path, results)
+
+
+if __name__ == "__main__":
+    """
+    Entry point for the script when run directly.
+    
+    Wraps main() in a try-except block to handle any unexpected errors
+    and ensure proper exit codes.
+    """
+    try:
+        main()
+    except Exception as e:
+        print(f"[ERROR] Unexpected error: {str(e)}")
+        sys.exit(1)

check_duplicate_python_functions-1.0.0/check_duplicate_python_functions.egg-info/PKG-INFO

@@ -0,0 +1,182 @@
+Metadata-Version: 2.4
+Name: check-duplicate-python-functions
+Version: 1.0.0
+Summary: A Python tool to detect duplicate function names in Python source files using AST parsing
+Home-page: https://github.com/pandiyarajk/check-duplicate-python-functions
+Author: Pandiyaraj Karuppasamy
+Author-email: Pandiyaraj Karuppasamy <pandiyarajk@live.com>
+Maintainer-email: Pandiyaraj Karuppasamy <pandiyarajk@live.com>
+Project-URL: Homepage, https://github.com/pandiyarajk/check-duplicate-python-functions
+Project-URL: Documentation, https://github.com/pandiyarajk/check-duplicate-python-functions#readme
+Project-URL: Repository, https://github.com/pandiyarajk/check-duplicate-python-functions
+Project-URL: Issues, https://github.com/pandiyarajk/check-duplicate-python-functions/issues
+Project-URL: Changelog, https://github.com/pandiyarajk/check-duplicate-python-functions/blob/main/CHANGE_LOG.md
+Keywords: python,ast,duplicate,functions,code-quality,static-analysis,linter
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+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: Topic :: Software Development :: Testing
+Classifier: Topic :: Software Development :: Quality Assurance
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Dynamic: author
+Dynamic: home-page
+Dynamic: requires-python
+
+# check-duplicate-python-functions
+
+A Python tool to detect duplicate function names in Python source files using AST (Abstract Syntax Tree) parsing.
+
+**Repository**: [https://github.com/pandiyarajk/check-duplicate-python-functions](https://github.com/pandiyarajk/check-duplicate-python-functions)
+
+**Author**: Pandiyaraj Karuppasamy (pandiyarajk@live.com)
+
+## Features
+
+- **Detects duplicate function names**: Identifies functions with the same name defined multiple times in a file
+- **AST-based analysis**: Uses Python's built-in AST module for accurate parsing
+- **Handles async functions**: Properly identifies and distinguishes async functions
+- **Class context awareness**: Tracks function context (module-level vs class methods)
+- **Special method exclusion**: Excludes special methods (like `__init__`, `__str__`, etc.) from duplicate checks since they can legitimately appear in multiple classes
+- **Signature extraction**: Extracts and compares function signatures including type annotations
+- **Comprehensive error handling**: Handles file not found, permission errors, encoding issues, and syntax errors gracefully
+
+## Requirements
+
+- Python 3.6 or higher
+- No external dependencies (uses only Python standard library)
+
+## Installation
+
+### Option 1: Install from PyPI (Recommended)
+```bash
+pip install check-duplicate-python-functions
+```
+
+After installation, you can use the command-line tool:
+```bash
+check-duplicate-functions <python_file_path>
+```
+
+### Option 2: Clone the repository
+```bash
+git clone https://github.com/pandiyarajk/check-duplicate-python-functions.git
+cd check-duplicate-python-functions
+python check_duplicate_functions.py <python_file_path>
+```
+
+### Option 3: Download directly
+No installation required. Simply download the `check_duplicate_functions.py` file and run it:
+```bash
+python check_duplicate_functions.py <python_file_path>
+```
+
+## Usage
+
+### If installed from PyPI:
+```bash
+check-duplicate-functions <python_file_path>
+```
+
+### If using the script directly:
+```bash
+python check_duplicate_functions.py <python_file_path>
+```
+
+### Examples
+
+```bash
+# Check a single Python file (PyPI installation)
+check-duplicate-functions my_script.py
+
+# Check a file in a subdirectory (PyPI installation)
+check-duplicate-functions src/utils.py
+
+# Using the script directly
+python check_duplicate_functions.py my_script.py
+python check_duplicate_functions.py src/utils.py
+```
+
+## Output
+
+The script produces output only when duplicates are found or errors occur:
+
+- **No duplicates**: Script exits silently with exit code 0
+- **Duplicates found**: Prints each duplicate function name and the line numbers where it appears:
+  ```
+  [DUPLICATE] 'my_function' appears on lines: 10, 25, 42
+  ```
+- **Errors**: Prints error messages for file not found, syntax errors, etc.:
+  ```
+  [ERROR] File not found: nonexistent.py
+  [ERROR] Syntax error in file.py: invalid syntax (line 5)
+  ```
+
+## Exit Codes
+
+- `0`: Success (no duplicates found or analysis completed successfully)
+- `1`: Error (invalid arguments, file not found, syntax error, or other issues)
+
+## How It Works
+
+1. **File Reading**: Reads the Python source file with UTF-8 encoding
+2. **AST Parsing**: Parses the source code into an Abstract Syntax Tree
+3. **Function Extraction**: Traverses the AST to extract all function definitions:
+   - Regular functions (`def`)
+   - Async functions (`async def`)
+   - Methods within classes
+   - Function signatures with type annotations
+4. **Duplicate Detection**: Identifies functions with duplicate names (excluding special methods)
+5. **Result Reporting**: Prints duplicate function names and their line numbers
+
+## Special Methods
+
+Special methods (dunder methods) like `__init__`, `__str__`, `__repr__`, etc. are excluded from duplicate checking because:
+- They are expected to appear in multiple classes
+- They serve specific purposes in Python's object model
+- Having them in multiple classes is not considered a code quality issue
+
+## Limitations
+
+- Only analyzes a single file at a time (no recursive directory scanning)
+- Does not detect duplicates across different files
+- Special methods are excluded from duplicate detection
+- Functions with identical names but different signatures are still reported as duplicates
+
+## Error Handling
+
+The script handles various error conditions:
+
+- **File not found**: Returns appropriate error message
+- **Permission denied**: Reports permission errors
+- **Encoding errors**: Handles files with non-UTF-8 encoding issues
+- **Syntax errors**: Reports Python syntax errors with line information
+- **Unexpected errors**: Catches and reports any unexpected exceptions
+
+## Example Use Cases
+
+- **Code review**: Quickly identify potential duplicate function definitions before code review
+- **Refactoring**: Find duplicate functions that might need to be consolidated
+- **Code quality**: Maintain clean codebase by detecting accidental function name reuse
+- **Large codebases**: Analyze individual files in large projects for duplicate functions
+
+## License
+
+This project is provided as-is for use in detecting duplicate functions in Python code.
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit issues or pull requests on [GitHub](https://github.com/pandiyarajk/check-duplicate-python-functions).
+
+## Author
+
+**Pandiyaraj Karuppasamy**
+- Email: pandiyarajk@live.com
+- GitHub: [@pandiyarajk](https://github.com/pandiyarajk)

check_duplicate_python_functions-1.0.0/check_duplicate_python_functions.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+CHANGELOG.md
+MANIFEST.in
+README.md
+check_duplicate_functions.py
+pyproject.toml
+setup.cfg
+setup.py
+./check_duplicate_functions.py
+./setup.py
+check_duplicate_python_functions.egg-info/PKG-INFO
+check_duplicate_python_functions.egg-info/SOURCES.txt
+check_duplicate_python_functions.egg-info/dependency_links.txt
+check_duplicate_python_functions.egg-info/entry_points.txt
+check_duplicate_python_functions.egg-info/top_level.txt

check_duplicate_python_functions-1.0.0/check_duplicate_python_functions.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

check_duplicate_python_functions-1.0.0/check_duplicate_python_functions.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+check-duplicate-functions = check_duplicate_functions:main

check_duplicate_python_functions-1.0.0/check_duplicate_python_functions.egg-info/top_level.txt

@@ -0,0 +1 @@
+check_duplicate_functions

check_duplicate_python_functions-1.0.0/pyproject.toml

@@ -0,0 +1,53 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "check-duplicate-python-functions"
+version = "1.0.0"
+description = "A Python tool to detect duplicate function names in Python source files using AST parsing"
+readme = "README.md"
+requires-python = ">=3.7"
+authors = [
+    {name = "Pandiyaraj Karuppasamy", email = "pandiyarajk@live.com"},
+]
+maintainers = [
+    {name = "Pandiyaraj Karuppasamy", email = "pandiyarajk@live.com"},
+]
+keywords = [
+    "python",
+    "ast",
+    "duplicate",
+    "functions",
+    "code-quality",
+    "static-analysis",
+    "linter"
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.7",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Software Development :: Testing",
+    "Topic :: Software Development :: Quality Assurance",
+]
+dependencies = []
+
+[project.scripts]
+check-duplicate-functions = "check_duplicate_functions:main"
+
+[project.urls]
+Homepage = "https://github.com/pandiyarajk/check-duplicate-python-functions"
+Documentation = "https://github.com/pandiyarajk/check-duplicate-python-functions#readme"
+Repository = "https://github.com/pandiyarajk/check-duplicate-python-functions"
+Issues = "https://github.com/pandiyarajk/check-duplicate-python-functions/issues"
+Changelog = "https://github.com/pandiyarajk/check-duplicate-python-functions/blob/main/CHANGE_LOG.md"
+
+[tool.setuptools]
+py-modules = ["check_duplicate_functions"]

check_duplicate_python_functions-1.0.0/setup.cfg

@@ -0,0 +1,10 @@
+[metadata]
+license_file = 
+
+[options]
+py_modules = check_duplicate_functions
+
+[egg_info]
+tag_build = 
+tag_date = 0
+

check_duplicate_python_functions-1.0.0/setup.py

@@ -0,0 +1,57 @@
+"""Setup configuration for check-duplicate-python-functions package."""
+
+from setuptools import setup, find_packages
+from pathlib import Path
+
+# Read the README file
+readme_file = Path(__file__).parent / "README.md"
+long_description = readme_file.read_text(encoding="utf-8") if readme_file.exists() else ""
+
+# Read version from the main module
+version = {}
+version_file = Path(__file__).parent / "check_duplicate_functions.py"
+if version_file.exists():
+    with open(version_file, "r", encoding="utf-8") as f:
+        for line in f:
+            if line.startswith("__version__"):
+                exec(line, version)
+                break
+
+setup(
+    name="check-duplicate-python-functions",
+    version=version.get("__version__", "1.0.0"),
+    author="Pandiyaraj Karuppasamy",
+    author_email="pandiyarajk@live.com",
+    description="A Python tool to detect duplicate function names in Python source files using AST parsing",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    url="https://github.com/pandiyarajk/check-duplicate-python-functions",
+    py_modules=["check_duplicate_functions"],
+    classifiers=[
+        "Development Status :: 4 - Beta",
+        "Intended Audience :: Developers",
+        "Topic :: Software Development :: Quality Assurance",
+        "Topic :: Software Development :: Libraries :: Python Modules",
+        "License :: OSI Approved :: MIT License",
+        "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3.7",
+        "Programming Language :: Python :: 3.8",
+        "Programming Language :: Python :: 3.9",
+        "Programming Language :: Python :: 3.10",
+        "Programming Language :: Python :: 3.11",
+        "Programming Language :: Python :: 3.12",
+        "Operating System :: OS Independent",
+    ],
+    python_requires=">=3.7",
+    entry_points={
+        "console_scripts": [
+            "check-duplicate-functions=check_duplicate_functions:main",
+        ],
+    },
+    keywords="python, ast, duplicate, functions, code-quality, static-analysis, linter",
+    project_urls={
+        "Bug Reports": "https://github.com/pandiyarajk/check-duplicate-python-functions/issues",
+        "Source": "https://github.com/pandiyarajk/check-duplicate-python-functions",
+        "Documentation": "https://github.com/pandiyarajk/check-duplicate-python-functions#readme",
+    },
+)