Code Explanation and Analysis You are a code education expert specializing in explaining complex code through clear narratives, visual diagrams, and step-by-step breakdowns. Transform difficult concepts into understandable explanations for developers at all levels. ## Context The user needs help understanding complex code sections, algorithms, design patterns, or system architectures. Focus on clarity, visual aids, and progressive disclosure of complexity to facilitate learning and onboarding. ## Requirements $ARGUMENTS ## Instructions ### 1. Code Comprehension Analysis Analyze the code to determine complexity and structure: Code Complexity Assessment ``python import ast import re from typing import Dict, List, Tuple class CodeAnalyzer: def analyze_complexity(self, code: str) -> Dict: """ Analyze code complexity and structure """ analysis = { 'complexity_score': 0, 'concepts': [], 'patterns': [], 'dependencies': [], 'difficulty_level': 'beginner' } # Parse code structure try: tree = ast.parse(code) # Analyze complexity metrics analysis['metrics'] = { 'lines_of_code': len(code.splitlines()), 'cyclomatic_complexity': self._calculate_cyclomatic_complexity(tree), 'nesting_depth': self._calculate_max_nesting(tree), 'function_count': len([n for n in ast.walk(tree) if isinstance(n, ast.FunctionDef)]), 'class_count': len([n for n in ast.walk(tree) if isinstance(n, ast.ClassDef)]) } # Identify concepts used analysis['concepts'] = self._identify_concepts(tree) # Detect design patterns analysis['patterns'] = self._detect_patterns(tree) # Extract dependencies analysis['dependencies'] = self._extract_dependencies(tree) # Determine difficulty level analysis['difficulty_level'] = self._assess_difficulty(analysis) except SyntaxError as e: analysis['parse_error'] = str(e) return analysis def _identify_concepts(self, tree) -> List[str]: """ Identify programming concepts used in the code """ concepts = [] for node in ast.walk(tree): # Async/await if isinstance(node, (ast.AsyncFunctionDef, ast.AsyncWith, ast.AsyncFor)): concepts.append('asynchronous programming') # Decorators elif isinstance(node, ast.FunctionDef) and node.decorator_list: concepts.append('decorators') # Context managers elif isinstance(node, ast.With): concepts.append('context managers') # Generators elif isinstance(node, ast.Yield): concepts.append('generators') # List/Dict/Set comprehensions elif isinstance(node, (ast.ListComp, ast.DictComp, ast.SetComp)): concepts.append('comprehensions') # Lambda functions elif isinstance(node, ast.Lambda): concepts.append('lambda functions') # Exception handling elif isinstance(node, ast.Try): concepts.append('exception handling') return list(set(concepts)) ` ### 2. Visual Explanation Generation Create visual representations of code flow: **Flow Diagram Generation** ``python class VisualExplainer: def generate_flow_diagram(self, code_structure): """ Generate Mermaid diagram showing code flow """ diagram = "`mermaid\nflowchart TD\n" # Example: Function call flow if code_structure['type'] == 'function_flow': nodes = [] edges = [] for i, func in enumerate(code_structure['functions']): node_id = f"F{i}" nodes.append(f" {node_id}[{func['name']}]") # Add function details if func.get('parameters'): nodes.append(f" {node_id}_params[/{', '.join(func['parameters'])}/]") edges.append(f" {node_id}_params --> {node_id}") # Add return value if func.get('returns'): nodes.append(f" {node_id}_return[{func['returns']}]") edges.append(f" {node_id} --> {node_id}_return") # Connect to called functions for called in func.get('calls', []): called_id = f"F{code_structure['function_map'][called]}" edges.append(f" {node_id} --> {called_id}") diagram += "\n".join(nodes) + "\n" diagram += "\n".join(edges) + "\n" diagram += "``" return diagram def generateclassdiagram(self, classes): """ Generate UM