dependency-analyzer
Analyze Python imports and dependencies. Use to understand project structure, find unused imports, or generate requirements.txt files.
When & Why to Use This Skill
The Dependency Analyzer is a comprehensive Claude skill designed to streamline Python project management by auditing imports and dependencies. It helps developers maintain high code quality by identifying unused imports, detecting circular dependencies, and visualizing complex project structures. By automating the generation of requirements.txt files and distinguishing between standard library and third-party modules, it significantly reduces manual overhead in environment configuration and architectural refactoring.
Use Cases
- Automated Environment Setup: Quickly generate accurate requirements.txt files by scanning project directories, ensuring consistent deployments across different environments.
- Codebase Optimization and Cleanup: Identify and remove redundant or unused imports to reduce technical debt and improve code readability.
- Architectural Auditing: Detect circular dependencies and visualize module relationships to facilitate better project modularity and refactoring.
- Onboarding and Project Mapping: Help new developers understand a large codebase by providing a clear breakdown of internal module structures and external dependencies.
| name | dependency-analyzer |
|---|---|
| description | Analyze Python imports and dependencies. Use to understand project structure, find unused imports, or generate requirements.txt files. |
Dependency Analyzer
Analyze Python file imports and project dependencies.
Features
- Import Extraction: List all imports from Python files
- Dependency Graph: Visualize import relationships
- Unused Detection: Find unused imports
- Requirements Generation: Auto-generate requirements.txt
- Standard Library Detection: Separate stdlib from third-party
- Circular Import Detection: Find circular dependencies
Quick Start
from dependency_analyzer import DependencyAnalyzer
analyzer = DependencyAnalyzer()
# Analyze single file
imports = analyzer.analyze_file("main.py")
print(imports)
# Analyze project
result = analyzer.analyze_project("./src")
print(result['third_party']) # External dependencies
CLI Usage
# Analyze single file
python dependency_analyzer.py --file main.py
# Analyze project directory
python dependency_analyzer.py --dir ./src
# Generate requirements.txt
python dependency_analyzer.py --dir ./src --requirements --output requirements.txt
# Find unused imports
python dependency_analyzer.py --file main.py --unused
# Show dependency graph
python dependency_analyzer.py --dir ./src --graph
# JSON output
python dependency_analyzer.py --dir ./src --json
API Reference
DependencyAnalyzer Class
class DependencyAnalyzer:
def __init__(self)
# Analysis
def analyze_file(self, filepath: str) -> dict
def analyze_project(self, directory: str) -> dict
# Detection
def find_unused_imports(self, filepath: str) -> list
def find_circular_imports(self, directory: str) -> list
# Generation
def generate_requirements(self, directory: str) -> list
def save_requirements(self, deps: list, output: str)
# Classification
def is_stdlib(self, module: str) -> bool
def is_local(self, module: str, directory: str) -> bool
Output Format
File Analysis
{
"file": "main.py",
"imports": [
{"module": "os", "type": "stdlib", "line": 1},
{"module": "json", "type": "stdlib", "line": 2},
{"module": "requests", "type": "third_party", "line": 3},
{"module": "utils.helpers", "type": "local", "line": 4}
],
"from_imports": [
{"module": "typing", "names": ["Dict", "List"], "type": "stdlib"},
{"module": "flask", "names": ["Flask", "request"], "type": "third_party"}
]
}
Project Analysis
{
"directory": "./src",
"files_analyzed": 15,
"stdlib": ["os", "sys", "json", "typing", ...],
"third_party": ["requests", "flask", "pandas", ...],
"local": ["utils", "models", "config", ...],
"by_file": {
"main.py": {...},
"app.py": {...}
}
}
Example Workflows
Generate Requirements
analyzer = DependencyAnalyzer()
deps = analyzer.generate_requirements("./src")
analyzer.save_requirements(deps, "requirements.txt")
Find Unused Imports
analyzer = DependencyAnalyzer()
unused = analyzer.find_unused_imports("main.py")
for imp in unused:
print(f"Line {imp['line']}: {imp['module']} is unused")
Analyze Project Structure
analyzer = DependencyAnalyzer()
result = analyzer.analyze_project("./myproject")
print("Third-party dependencies:")
for dep in result['third_party']:
print(f" - {dep}")
print("\nLocal modules:")
for mod in result['local']:
print(f" - {mod}")
Check for Circular Imports
analyzer = DependencyAnalyzer()
circular = analyzer.find_circular_imports("./src")
if circular:
print("Circular imports detected:")
for cycle in circular:
print(f" {' -> '.join(cycle)}")
Module Classification
| Type | Description | Example |
|---|---|---|
stdlib |
Python standard library | os, sys, json |
third_party |
External packages | requests, pandas |
local |
Project modules | utils.helpers |
Dependencies
No external dependencies - uses Python standard library (ast module).