1# module_a.py
2def process_data(data):
3    validate(data)
4    return transform(data)
5
6# module_b.py
7from module_a import process_data
8def main_workflow():
9    result = process_data(raw_data)
10    save_result(result)

1code-explorer/
2├── src/
3│   ├── parser.py         # AST parsing
4│   ├── graph.py          # Dependency graph
5│   ├── analyzer.py       # Code analysis
6│   └── cli.py            # Command interface
7└── tests/
8    └── test_parser.py

1# src/parser.py
2import ast
3from typing import List, Dict
4
5class PythonParser:
6    def parse_file(self, filepath: Path) -> Dict:
7        with open(filepath) as f:
8            tree = ast.parse(f.read(), filename=str(filepath))
9
10        functions = []
11        for node in ast.walk(tree):
12            if isinstance(node, ast.FunctionDef):
13                functions.append({
14                    'name': node.name,
15                    'calls': self._extract_calls(node)
16                })
17
18        return {
19            'file': str(filepath),
20            'functions': functions
21        }
22
23    def _extract_calls(self, func_node: ast.FunctionDef) -> List[str]:
24        calls = []
25        for node in ast.walk(func_node):
26            if isinstance(node, ast.Call) and isinstance(node.func, ast.Name):
27                calls.append(node.func.id)
28        return calls

1# src/graph.py
2import networkx as nx
3
4class DependencyGraph:
5    def __init__(self):
6        self.graph = nx.DiGraph()
7
8    def add_function(self, module: str, func: str):
9        node_id = f"{module}.{func}"
10        self.graph.add_node(node_id)
11
12    def add_call(self, caller: str, callee: str):
13        self.graph.add_edge(caller, callee)
14
15    def find_cycles(self):
16        return list(nx.simple_cycles(self.graph))
17
18    def get_dependencies(self, func: str, depth: int = 5):
19        return nx.descendants(self.graph, func)

1# src/analyzer.py
2class DeadCodeAnalyzer:
3    def __init__(self, graph: DependencyGraph):
4        self.graph = graph
5
6    def find_unused_functions(self):
7        all_nodes = set(self.graph.graph.nodes())
8        called_nodes = set()
9
10        for _, target in self.graph.graph.edges():
11            called_nodes.add(target)
12
13        # Fonctions sans appels = code mort
14        return list(all_nodes - called_nodes)

1# src/cli.py
2import click
3from rich.console import Console
4
5@click.command()
6@click.argument('path', type=click.Path(exists=True))
7def analyze(path):
8    """Analyser les dépendances d'un projet Python."""
9    console = Console()
10
11    parser = PythonParser()
12    graph = DependencyGraph()
13
14    # Parser tous les fichiers Python
15    for py_file in Path(path).rglob("*.py"):
16        data = parser.parse_file(py_file)
17        # Construction du graphe...
18
19    # Analyse de code mort
20    analyzer = DeadCodeAnalyzer(graph)
21    unused = analyzer.find_unused_functions()
22
23    console.print("[bold green]Fonctions non utilisées :[/bold green]")
24    for func in unused:
25        console.print(f" - {func}")