dependency-analyzer

Analyze Python imports and dependencies. Use to understand project structure, find unused imports, or generate requirements.txt files.

⭐5stars🔀1forks📁View on GitHub🕐Updated Jan 11, 2026

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.
namedependency-analyzer
descriptionAnalyze 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).