copied from private space

.gitignore

@@ -0,0 +1,125 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# Virtual Environment
+venv/
+env/
+ENV/
+env.bak/
+venv.bak/
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db
+
+# Gradio
+.gradio/
+gradio_cached_examples/
+
+# Temporary files
+testing_space/
+temp_diagrams/
+*.tmp
+*.temp
+temp_*/
+output/
+
+# Logs
+*.log
+logs/
+
+# PlantUML output
+*.puml
+*.png
+*.svg
+diagrams/
+
+# Environment variables
+.env
+.env.local
+.env.*.local
+
+# Node modules (for MCP tools)
+node_modules/
+package-lock.json
+
+# Test files
+test_*.py
+*_test.py
+tests/
+
+# Documentation build
+docs/_build/
+
+# Coverage reports
+htmlcov/
+.coverage
+.coverage.*
+coverage.xml
+*.cover
+.hypothesis/
+.pytest_cache/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# pyenv
+.python-version
+
+# Celery
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+repomix-output.xml

QUICKSTART.md

@@ -0,0 +1,119 @@
+# 🚀 Quick Start Guide
+
+## Getting Started in 3 Steps
+
+### Step 1: Test Your Setup
+```bash
+python test_setup.py
+```
+This will verify all dependencies are working correctly.
+
+### Step 2: Start the Application
+
+**Option A: Use the batch file (Windows)**
+```bash
+run.bat
+```
+
+**Option B: Manual start**
+```bash
+# Activate virtual environment
+venv\Scripts\activate  # Windows
+# or
+source venv/bin/activate  # Linux/Mac
+
+# Run the app
+python app.py
+```
+
+### Step 3: Access the Application
+- **Web Interface**: http://127.0.0.1:7860
+- **MCP Endpoint**: http://127.0.0.1:7860/gradio_api/mcp/sse
+
+## Claude Desktop Integration
+
+### Prerequisites
+1. Install Node.js from https://nodejs.org
+2. Install mcp-remote:
+   ```bash
+   npm install -g mcp-remote
+   ```
+
+### Configuration
+1. **Find your Claude Desktop config file:**
+   - **Windows**: `%APPDATA%\Claude\claude_desktop_config.json`
+   - **macOS**: `~/Library/Application Support/Claude/claude_desktop_config.json`
+
+2. **Copy the contents of `claude_config.json` to your Claude config file**
+
+3. **Restart Claude Desktop**
+
+### Testing Claude Integration
+In Claude Desktop, try these prompts:
+
+```
+Generate a UML diagram for this Python code:
+
+class Vehicle:
+    def __init__(self, brand):
+        self.brand = brand
+    
+    def start(self):
+        pass
+
+class Car(Vehicle):
+    def start(self):
+        return "Engine started"
+```
+
+or
+
+```
+Analyze the structure of this Python code:
+
+class Calculator:
+    def add(self, a, b):
+        return a + b
+    
+    def multiply(self, a, b):
+        return a * b
+```
+
+## Troubleshooting
+
+### Common Issues
+
+1. **Import errors when running test_setup.py:**
+   ```bash
+   pip install -r requirements.txt
+   ```
+
+2. **Claude Desktop doesn't recognize the MCP server:**
+   - Check Node.js installation: `node --version`
+   - Check mcp-remote installation: `npx mcp-remote --version`
+   - Verify the app is running: visit http://127.0.0.1:7860
+   - Restart Claude Desktop after config changes
+
+3. **No diagram generated:**
+   - Ensure your Python code contains class definitions
+   - Check for syntax errors in your code
+   - Verify internet connection (PlantUML service)
+
+### Debug Commands
+
+```bash
+# Check if the app is running
+curl http://127.0.0.1:7860/gradio_api/mcp/schema
+
+# Test MCP endpoint
+npx mcp-remote http://127.0.0.1:7860/gradio_api/mcp/sse --transport sse-only
+```
+
+## Next Steps
+
+1. Try the sample code in the web interface
+2. Experiment with your own Python classes
+3. Test the MCP integration with Claude Desktop
+4. Explore the code analysis features
+
+Happy diagramming! 🎨

README.md

@@ -1,14 +1,198 @@
 ---
-title: Python Code To Diagram Generator MCP
-emoji: 🚀
+title: Python UML Diagram Generator & MCP Server
+emoji: 🐍
 colorFrom: blue
-colorTo: gray
+colorTo: purple
 sdk: gradio
 sdk_version: 5.33.0
 app_file: app.py
 pinned: false
 license: mit
-short_description: Transform your Python code into comprehensive visual diagram
+models:
+  - PlantUML
+tags:
+  - uml
+  - python
+  - diagrams
+  - mcp
+  - code-analysis
+  - visualization
+  - mcp-server-track
+short_description: Python UML diagram generator with MCP server support
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# 🐍 Python UML Diagram Generator & MCP Server
+
+A powerful tool that generates UML class diagrams from Python code with integrated Model Context Protocol (MCP) server functionality for AI assistants.
+
+## 🚀 Features
+
+- **🎨 Interactive Web Interface**: Generate UML class diagrams interactively from Python code
+- **🤖 MCP Server Integration**: Works with Claude Desktop, Cursor, and other MCP clients  
+- **📊 Advanced Code Analysis**: Enhanced analysis with call graphs, complexity metrics, and function dependencies
+- **🔗 Function Call Graphs**: Visualize function relationships and dependencies using pyan3 + graphviz
+- **📈 Complexity Metrics**: Cyclomatic complexity, lines of code, parameter analysis
+- **⚙️ Standalone Function Analysis**: Perfect for utility scripts with functions (not just classes)
+- **🔄 Real-time Processing**: Fast diagram generation using PlantUML
+- **💾 Multiple Formats**: PNG images, PlantUML source code, and call graph visualizations
+- **🔍 Inheritance Visualization**: Clear parent-child class relationships
+
+## 🎯 Quick Start
+
+1. **Paste Python Code**: Enter your Python code in the text area
+2. **Generate Diagram**: Click "Generate Diagram" to create UML visualization
+3. **Analyze Structure**: Use "Analyze Code" for detailed code analysis
+4. **Download Results**: Save generated diagrams and analysis
+
+## 🤖 MCP Server Integration
+
+This Space automatically serves as an MCP server! To integrate with AI assistants:
+
+### For Claude Desktop (with mcp-remote):
+```json
+{
+  "mcpServers": {
+    "python-diagram-generator": {
+      "command": "npx",
+      "args": [
+        "mcp-remote",
+        "https://your-username-space-name.hf.space/gradio_api/mcp/sse",
+        "--transport",
+        "sse-only"
+      ]
+    }
+  }
+}
+```
+
+### For Cursor, Cline, and other SSE-compatible clients:
+```json
+{
+  "mcpServers": {
+    "python-diagram-generator": {
+      "url": "https://your-username-space-name.hf.space/gradio_api/mcp/sse"
+    }
+  }
+}
+```
+
+### For Private Spaces:
+```json
+{
+  "mcpServers": {
+    "python-diagram-generator": {
+      "url": "https://your-username-space-name.hf.space/gradio_api/mcp/sse",
+      "headers": {
+        "Authorization": "Bearer hf_your_token_here"
+      }
+    }
+  }
+}
+```
+
+## 🛠️ Available MCP Tools
+
+1. **generate_diagram**: Creates UML class diagrams from Python code
+2. **analyze_code_structure**: Provides detailed code structure analysis with enhanced metrics
+
+## 📊 Advanced Analysis Features
+
+### **🔬 Advanced Analysis Tab**
+- **Function Call Graphs**: Visual network diagrams showing function dependencies
+- **Complexity Analysis**: Cyclomatic complexity scoring for each function
+- **Function Metrics**: Lines of code, parameter counts, docstring detection
+- **Call Relationship Mapping**: Which functions call which, and call frequency analysis
+- **Isolated Function Detection**: Find functions that aren't connected to others
+- **Code Quality Recommendations**: Suggestions for refactoring and improvements
+
+### **Enhanced for Standalone Functions**
+Perfect for analyzing utility scripts, mathematical functions, data processing pipelines, and other function-heavy code that traditional class-based UML tools miss.
+
+## 💡 Usage Examples
+
+### Example 1: Basic Classes
+```python
+class Animal:
+    def __init__(self, name: str):
+        self.name = name
+    
+    def speak(self) -> str:
+        pass
+
+class Dog(Animal):
+    def speak(self) -> str:
+        return f"{self.name} says Woof!"
+```
+
+### Example 2: Complex Inheritance
+```python
+class Vehicle:
+    def __init__(self, brand: str, model: str):
+        self.brand = brand
+        self.model = model
+
+class Car(Vehicle):
+    def __init__(self, brand: str, model: str, doors: int):
+        super().__init__(brand, model)
+        self.doors = doors
+    
+    def start_engine(self):
+        return "Engine started"
+
+class ElectricCar(Car):
+    def __init__(self, brand: str, model: str, doors: int, battery_capacity: float):
+        super().__init__(brand, model, doors)
+        self.battery_capacity = battery_capacity
+    
+    def charge(self):
+        return "Charging battery"
+```
+
+## 🔧 Technical Details
+
+- **Built with**: Gradio 5.33+ with MCP support
+- **Analysis Engine**: Python AST + py2puml + pyan3
+- **Call Graph Generation**: pyan3 + graphviz for function dependency visualization
+- **Diagram Rendering**: PlantUML web service + graphviz DOT rendering
+- **Output Formats**: PNG images, PlantUML source code, DOT call graphs
+- **MCP Protocol**: Server-Sent Events (SSE) transport
+- **Function Analysis**: Cyclomatic complexity, parameter analysis, docstring detection
+
+## 🎨 Features Showcase
+
+- **Real-time Analysis**: Code structure updates as you type
+- **Inheritance Detection**: Visualizes parent-child relationships
+- **Method & Attribute Mapping**: Complete class member analysis
+- **Function Call Graphs**: Interactive network diagrams of function dependencies
+- **Complexity Metrics**: Cyclomatic complexity analysis with recommendations
+- **Standalone Function Support**: Perfect for utility scripts and mathematical functions
+- **Error Handling**: Syntax error detection and reporting
+- **Sample Code**: Ready-to-use examples for both classes and functions
+
+## 📱 Compatible MCP Clients
+
+- **Claude Desktop** (via mcp-remote)
+- **Cursor IDE**
+- **Cline VS Code Extension**
+- **Continue VS Code Extension**
+- **Custom MCP implementations**
+
+## 🌟 Perfect For
+
+- **Developers**: Understanding code structure and function dependencies quickly
+- **Code Reviews**: Visualizing class relationships and call patterns
+- **Documentation**: Generating architectural diagrams and function flow charts
+- **Education**: Teaching OOP concepts and functional programming patterns
+- **Utility Script Analysis**: Understanding standalone function files and mathematical algorithms
+- **Refactoring**: Identifying complex functions and isolated code segments
+- **AI Assistants**: Enhanced code analysis capabilities with complexity metrics
+
+## 📞 Support & Feedback
+
+- Test with the provided sample code first
+- Check the MCP configuration tab for setup instructions
+- View API documentation via the "View API" link in the footer
+
+---
+
+**Transform your Python code into beautiful UML diagrams! 🎨✨**

app.py

@@ -0,0 +1,1012 @@
+import gradio as gr
+import sys
+import os
+import tempfile
+import shutil
+import ast
+import time
+import subprocess
+import re
+from typing import List, Dict, Optional, Tuple, Any
+from py2puml.py2puml import py2puml
+from plantuml import PlantUML
+import pyan
+from pathlib import Path
+
+if os.name == "nt":  # nt == Windows
+    graphviz_bin = r"C:\\Program Files\\Graphviz\\bin"
+    if graphviz_bin not in os.environ["PATH"]:
+        os.environ["PATH"] += os.pathsep + graphviz_bin
+
+
+def setup_testing_space():
+    """Create persistent testing_space directory and __init__.py at startup."""
+    testing_dir = os.path.join(os.getcwd(), "testing_space")
+    os.makedirs(testing_dir, exist_ok=True)
+
+    init_file = os.path.join(testing_dir, "__init__.py")
+    if not os.path.exists(init_file):
+        with open(init_file, "w", encoding="utf-8") as f:
+            f.write("# Testing space for py2puml analysis\n")
+        print("📁 Created testing_space directory and __init__.py")
+    else:
+        print("🔄 testing_space directory already exists")
+
+
+def cleanup_testing_space():
+    """Remove all .py files except __init__.py from testing_space."""
+    testing_dir = os.path.join(os.getcwd(), "testing_space")
+    if not os.path.exists(testing_dir):
+        print("⚠️ testing_space directory not found, creating it...")
+        setup_testing_space()
+        return
+
+    # Clean up any leftover .py files (keep only __init__.py)
+    files_removed = 0
+    for file in os.listdir(testing_dir):
+        if file.endswith(".py") and file != "__init__.py":
+            file_path = os.path.join(testing_dir, file)
+            try:
+                os.remove(file_path)
+                files_removed += 1
+            except Exception as e:
+                print(f"⚠️ Could not remove {file}: {e}")
+
+    if files_removed > 0:
+        print(f"🧹 Cleaned up {files_removed} leftover .py files from testing_space")
+
+
+def verify_testing_space():
+    """Verify testing_space contains only __init__.py."""
+    testing_dir = os.path.join(os.getcwd(), "testing_space")
+    if not os.path.exists(testing_dir):
+        return False
+
+    files = os.listdir(testing_dir)
+    expected_files = ["__init__.py"]
+
+    return files == expected_files
+
+
+def generate_call_graph_with_pyan3(
+    python_code: str, filename: str = "analysis"
+) -> Tuple[Optional[str], Optional[str], Dict[str, Any]]:
+    """Generate call graph using pyan3 and return DOT content, PNG path, and structured data.
+
+    Args:
+        python_code: The Python code to analyze
+        filename: Base filename for temporary files
+
+    Returns:
+        Tuple of (dot_content, png_path, structured_data)
+    """
+    if not python_code.strip():
+        return None, None, {}
+
+    # Create unique filename using timestamp
+    timestamp = str(int(time.time() * 1000))
+    unique_filename = f"{filename}_{timestamp}"
+
+    # Paths
+    testing_dir = os.path.join(os.getcwd(), "testing_space")
+    code_file = os.path.join(testing_dir, f"{unique_filename}.py")
+
+    try:
+        # Write Python code to file
+        with open(code_file, "w", encoding="utf-8") as f:
+            f.write(python_code)
+
+        print(f"📊 Generating call graph for: {unique_filename}.py")
+
+        try:
+
+            dot_content = pyan.create_callgraph(
+                filenames=[str(code_file)],
+                format="dot",
+                colored=True,
+                grouped=True,
+                annotated=True,
+            )
+
+            png_path = None
+            with tempfile.TemporaryDirectory() as temp_dir:
+                dot_file = os.path.join(temp_dir, f"{unique_filename}.dot")
+                temp_png = os.path.join(temp_dir, f"{unique_filename}.png")
+
+                # Write DOT content to file
+                with open(dot_file, "w", encoding="utf-8") as f:
+                    f.write(dot_content)
+
+                # Generate PNG using dot command
+                dot_cmd = ["dot", "-Tpng", dot_file, "-o", temp_png]
+
+                try:
+                    subprocess.run(dot_cmd, check=True, timeout=30)
+
+                    if os.path.exists(temp_png):
+                        # Copy to permanent location
+                        permanent_dir = os.path.join(os.getcwd(), "temp_diagrams")
+                        os.makedirs(permanent_dir, exist_ok=True)
+                        png_path = os.path.join(
+                            permanent_dir, f"callgraph_{unique_filename}.png"
+                        )
+                        shutil.copy2(temp_png, png_path)
+                        print(f"🎨 Call graph PNG saved: {os.path.basename(png_path)}")
+
+                except subprocess.SubprocessError as e:
+                    print(f"⚠️ Graphviz PNG generation failed: {e}")
+                    # Continue without PNG, DOT content is still useful
+
+            # Parse DOT content for structured data
+            structured_data = parse_call_graph_data(dot_content)
+
+            return dot_content, png_path, structured_data
+
+        except subprocess.TimeoutExpired:
+            print("⚠️ pyan3 analysis timed out, trying simplified approach...")
+            return try_fallback_analysis(python_code, unique_filename)
+        except subprocess.SubprocessError as e:
+            print(f"⚠️ pyan3 execution failed: {e}, trying fallback...")
+            return try_fallback_analysis(python_code, unique_filename)
+
+    except Exception as e:
+        print(f"❌ Call graph generation error: {e}")
+        return None, None, {"error": str(e)}
+
+    finally:
+        # Clean up temporary file
+        if os.path.exists(code_file):
+            try:
+                os.remove(code_file)
+                print(f"🧹 Cleaned up analysis file: {unique_filename}.py")
+            except Exception as e:
+                print(f"⚠️ Could not remove analysis file: {e}")
+
+
+def parse_call_graph_data(dot_content: str) -> Dict[str, Any]:
+    """Parse pyan3 DOT output into structured function call data.
+
+    Args:
+        dot_content: DOT format string from pyan3
+
+    Returns:
+        Dictionary with parsed call graph information
+    """
+    if not dot_content:
+        return {}
+
+    try:
+        # Extract nodes (functions/classes)
+        node_pattern = r'"([^"]+)"\s*\['
+        nodes = re.findall(node_pattern, dot_content)
+
+        # Extract edges (function calls)
+        edge_pattern = r'"([^"]+)"\s*->\s*"([^"]+)"'
+        edges = re.findall(edge_pattern, dot_content)
+
+        # Build function call mapping
+        call_graph = {}
+        called_by = {}
+
+        for caller, callee in edges:
+            if caller not in call_graph:
+                call_graph[caller] = []
+            call_graph[caller].append(callee)
+
+            if callee not in called_by:
+                called_by[callee] = []
+            called_by[callee].append(caller)
+
+        # Calculate metrics
+        function_metrics = {}
+        for node in nodes:
+            out_degree = len(call_graph.get(node, []))
+            in_degree = len(called_by.get(node, []))
+
+            function_metrics[node] = {
+                "calls_made": out_degree,
+                "called_by_count": in_degree,
+                "calls_to": call_graph.get(node, []),
+                "called_by": called_by.get(node, []),
+            }
+
+        return {
+            "nodes": nodes,
+            "edges": edges,
+            "total_functions": len(nodes),
+            "total_calls": len(edges),
+            "call_graph": call_graph,
+            "function_metrics": function_metrics,
+        }
+
+    except Exception as e:
+        return {"parse_error": str(e)}
+
+
+def try_fallback_analysis(
+    python_code: str, unique_filename: str
+) -> Tuple[Optional[str], Optional[str], Dict[str, Any]]:
+    """Fallback analysis when pyan3 fails - basic function call detection.
+
+    Args:
+        python_code: The Python code to analyze
+        unique_filename: Unique filename for this analysis
+
+    Returns:
+        Tuple of (None, None, fallback_analysis_data)
+    """
+    print("🔄 Using fallback analysis approach...")
+
+    try:
+        import ast
+        import re
+
+        tree = ast.parse(python_code)
+        functions = []
+        calls = []
+
+        # Extract function definitions
+        for node in ast.walk(tree):
+            if isinstance(node, ast.FunctionDef):
+                functions.append(node.name)
+
+        # Simple regex-based call detection (fallback approach)
+        for func in functions:
+            # Look for calls to this function
+            pattern = rf"\b{re.escape(func)}\s*\("
+            if re.search(pattern, python_code):
+                calls.append(("unknown", func))
+
+        return (
+            None,
+            None,
+            {
+                "fallback": True,
+                "functions_detected": functions,
+                "total_functions": len(functions),
+                "total_calls": len(calls),
+                "info": f"Fallback analysis: detected {len(functions)} functions",
+                "function_metrics": {
+                    func: {
+                        "calls_made": 0,
+                        "called_by_count": 0,
+                        "calls_to": [],
+                        "called_by": [],
+                    }
+                    for func in functions
+                },
+            },
+        )
+
+    except Exception as e:
+        return None, None, {"error": f"Fallback analysis also failed: {str(e)}"}
+
+
+def analyze_function_complexity(python_code: str) -> Dict[str, Any]:
+    """Analyze function complexity using AST.
+
+    Args:
+        python_code: The Python code to analyze
+
+    Returns:
+        Dictionary with function complexity metrics
+    """
+    if not python_code.strip():
+        return {}
+
+    try:
+        tree = ast.parse(python_code)
+        function_analysis = {}
+
+        for node in ast.walk(tree):
+            if isinstance(node, ast.FunctionDef):
+                # Calculate cyclomatic complexity (simplified)
+                complexity = 1  # Base complexity
+
+                for child in ast.walk(node):
+                    if isinstance(
+                        child,
+                        (
+                            ast.If,
+                            ast.While,
+                            ast.For,
+                            ast.Try,
+                            ast.ExceptHandler,
+                            ast.With,
+                            ast.Assert,
+                        ),
+                    ):
+                        complexity += 1
+                    elif isinstance(child, ast.BoolOp):
+                        complexity += len(child.values) - 1
+
+                # Count lines of code
+                lines = (
+                    node.end_lineno - node.lineno + 1
+                    if hasattr(node, "end_lineno")
+                    else 0
+                )
+
+                # Extract parameters
+                params = [arg.arg for arg in node.args.args]
+
+                # Check for docstring
+                has_docstring = (
+                    len(node.body) > 0
+                    and isinstance(node.body[0], ast.Expr)
+                    and isinstance(node.body[0].value, ast.Constant)
+                    and isinstance(node.body[0].value.value, str)
+                )
+
+                function_analysis[node.name] = {
+                    "complexity": complexity,
+                    "lines_of_code": lines,
+                    "parameter_count": len(params),
+                    "parameters": params,
+                    "has_docstring": has_docstring,
+                    "line_start": node.lineno,
+                    "line_end": getattr(node, "end_lineno", node.lineno),
+                }
+
+        return function_analysis
+
+    except Exception as e:
+        return {"error": str(e)}
+
+
+def generate_diagram(python_code: str, filename: str = "diagram") -> Optional[str]:
+    """Generate a UML class diagram from Python code.
+
+    Args:
+        python_code: The Python code to analyze and convert to UML
+        filename: Optional name for the generated diagram file
+
+    Returns:
+        Path to the generated PNG diagram image or None if failed
+    """
+    if not python_code.strip():
+        return None
+
+    print(f"🔄 Processing code for diagram generation...")
+
+    # Clean testing space (ensure only __init__.py exists)
+    cleanup_testing_space()
+
+    # Verify clean state
+    if not verify_testing_space():
+        print("⚠️ testing_space verification failed, recreating...")
+        setup_testing_space()
+        cleanup_testing_space()
+
+    # Create unique filename using timestamp
+    timestamp = str(int(time.time() * 1000))  # millisecond timestamp
+    unique_filename = f"{filename}_{timestamp}"
+
+    # Paths
+    testing_dir = os.path.join(os.getcwd(), "testing_space")
+    code_file = os.path.join(testing_dir, f"{unique_filename}.py")
+
+    # Use PlantUML web service for rendering
+    server = PlantUML(url="http://www.plantuml.com/plantuml/img/")
+
+    try:
+        # Write Python code to file in testing_space
+        with open(code_file, "w", encoding="utf-8") as f:
+            f.write(python_code)
+
+        print(f"📝 Created temporary file: testing_space/{unique_filename}.py")
+
+        # Generate PlantUML content using py2puml (no sys.path manipulation needed)
+        print(f"📝 Generating PlantUML content...")
+        puml_content_lines = py2puml(
+            os.path.join(
+                testing_dir, unique_filename
+            ),  # path to the .py file (without extension)
+            f"testing_space.{unique_filename}",  # module name
+        )
+        puml_content = "".join(puml_content_lines)
+
+        if not puml_content.strip():
+            print("⚠️ No UML content generated - check if your code contains classes")
+            return None
+
+        # Create temporary directory for PlantUML processing
+        with tempfile.TemporaryDirectory() as temp_dir:
+            # Save PUML file
+            puml_file = os.path.join(temp_dir, f"{unique_filename}.puml")
+            with open(puml_file, "w", encoding="utf-8") as f:
+                f.write(puml_content)
+
+            print(f"🎨 Rendering diagram...")
+            # Generate PNG
+            output_png = os.path.join(temp_dir, f"{unique_filename}.png")
+            server.processes_file(puml_file, outfile=output_png)
+
+            if os.path.exists(output_png):
+                print("✅ Diagram generated successfully!")
+                # Copy to a permanent location for Gradio to serve
+                permanent_dir = os.path.join(os.getcwd(), "temp_diagrams")
+                os.makedirs(permanent_dir, exist_ok=True)
+                permanent_path = os.path.join(
+                    permanent_dir, f"{filename}_{hash(python_code) % 10000}.png"
+                )
+                shutil.copy2(output_png, permanent_path)
+                return permanent_path
+            else:
+                print("❌ Failed to generate PNG")
+                return None
+
+    except Exception as e:
+        print(f"❌ Error: {e}")
+        return None
+
+    finally:
+        # Always clean up the temporary .py file
+        if os.path.exists(code_file):
+            try:
+                os.remove(code_file)
+                print(f"🧹 Cleaned up temporary file: {unique_filename}.py")
+            except Exception as e:
+                print(f"⚠️ Could not remove temporary file: {e}")
+
+
+def analyze_code_structure(python_code: str) -> str:
+    """Enhanced code analysis combining AST + pyan3 call graphs.
+
+    Args:
+        python_code: The Python code to analyze
+
+    Returns:
+        Comprehensive analysis report in markdown format
+    """
+    if not python_code.strip():
+        return "No code provided for analysis."
+
+    try:
+        # Basic AST analysis
+        tree = ast.parse(python_code)
+        classes = []
+        functions = []
+        imports = []
+
+        for node in ast.walk(tree):
+            if isinstance(node, ast.ClassDef):
+                methods = []
+                attributes = []
+
+                for item in node.body:
+                    if isinstance(item, ast.FunctionDef):
+                        methods.append(item.name)
+                    elif isinstance(item, ast.Assign):
+                        for target in item.targets:
+                            if isinstance(target, ast.Name):
+                                attributes.append(target.id)
+
+                # Check for inheritance
+                parents = [base.id for base in node.bases if isinstance(base, ast.Name)]
+
+                classes.append(
+                    {
+                        "name": node.name,
+                        "methods": methods,
+                        "attributes": attributes,
+                        "parents": parents,
+                    }
+                )
+
+            elif isinstance(node, ast.FunctionDef):
+                # Check if it's a top-level function (not inside a class)
+                is_method = any(
+                    isinstance(parent, ast.ClassDef)
+                    for parent in ast.walk(tree)
+                    if hasattr(parent, "body") and node in getattr(parent, "body", [])
+                )
+                if not is_method:
+                    functions.append(node.name)
+
+            elif isinstance(node, (ast.Import, ast.ImportFrom)):
+                if isinstance(node, ast.Import):
+                    for alias in node.names:
+                        imports.append(alias.name)
+                else:
+                    module = node.module or ""
+                    for alias in node.names:
+                        imports.append(
+                            f"{module}.{alias.name}" if module else alias.name
+                        )
+
+        # Enhanced function complexity analysis
+        function_complexity = analyze_function_complexity(python_code)
+
+        # Call graph analysis (for files with functions)
+        call_graph_data = {}
+        if functions or any(classes):  # Only run if there are functions to analyze
+            try:
+                cleanup_testing_space()  # Ensure clean state
+                dot_content, png_path, call_graph_data = generate_call_graph_with_pyan3(
+                    python_code
+                )
+            except Exception as e:
+                print(f"⚠️ Call graph analysis failed: {e}")
+                call_graph_data = {"error": str(e)}
+
+        # Build comprehensive summary
+        summary = "📊 **Enhanced Code Analysis Results**\n\n"
+
+        # === OVERVIEW SECTION ===
+        summary += "## 📋 **Overview**\n"
+        summary += f"• **{len(classes)}** classes found\n"
+        summary += f"• **{len(functions)}** standalone functions found\n"
+        summary += f"• **{len(set(imports))}** unique imports\n"
+
+        if call_graph_data and "total_functions" in call_graph_data:
+            summary += f"• **{call_graph_data['total_functions']}** total functions/methods in call graph\n"
+            summary += (
+                f"• **{call_graph_data['total_calls']}** function calls detected\n"
+            )
+
+        summary += "\n"
+
+        # === CLASSES SECTION ===
+        if classes:
+            summary += "## 🏗️ **Classes**\n"
+            for cls in classes:
+                summary += f"### **{cls['name']}**\n"
+                if cls["parents"]:
+                    summary += f"  - **Inherits from**: {', '.join(cls['parents'])}\n"
+                summary += f"  - **Methods**: {len(cls['methods'])}"
+                if cls["methods"]:
+                    summary += f" ({', '.join(cls['methods'])})"
+                summary += "\n"
+                if cls["attributes"]:
+                    summary += f"  - **Attributes**: {', '.join(cls['attributes'])}\n"
+                summary += "\n"
+
+        # === STANDALONE FUNCTIONS SECTION ===
+        if functions:
+            summary += "## ⚙️ **Standalone Functions**\n"
+            for func in functions:
+                summary += f"### **{func}()**\n"
+
+                # Add complexity metrics if available
+                if func in function_complexity:
+                    metrics = function_complexity[func]
+                    summary += (
+                        f"  - **Complexity**: {metrics['complexity']} (cyclomatic)\n"
+                    )
+                    summary += f"  - **Lines of Code**: {metrics['lines_of_code']}\n"
+                    summary += f"  - **Parameters**: {metrics['parameter_count']}"
+                    if metrics["parameters"]:
+                        summary += f" ({', '.join(metrics['parameters'])})"
+                    summary += "\n"
+                    summary += f"  - **Has Docstring**: {'✅' if metrics['has_docstring'] else '❌'}\n"
+                    summary += f"  - **Lines**: {metrics['line_start']}-{metrics['line_end']}\n"
+
+                # Add call graph info if available
+                if call_graph_data and "function_metrics" in call_graph_data:
+                    if func in call_graph_data["function_metrics"]:
+                        call_metrics = call_graph_data["function_metrics"][func]
+                        summary += f"  - **Calls Made**: {call_metrics['calls_made']}\n"
+                        if call_metrics["calls_to"]:
+                            summary += (
+                                f"    - Calls: {', '.join(call_metrics['calls_to'])}\n"
+                            )
+                        summary += f"  - **Called By**: {call_metrics['called_by_count']} functions\n"
+                        if call_metrics["called_by"]:
+                            summary += f"    - Called by: {', '.join(call_metrics['called_by'])}\n"
+
+                summary += "\n"
+
+        # === CALL GRAPH ANALYSIS ===
+        if (
+            call_graph_data
+            and "function_metrics" in call_graph_data
+            and call_graph_data["total_calls"] > 0
+        ):
+            summary += "## 🔗 **Function Call Analysis**\n"
+
+            # Most called functions
+            sorted_by_calls = sorted(
+                call_graph_data["function_metrics"].items(),
+                key=lambda x: x[1]["called_by_count"],
+                reverse=True,
+            )[:5]
+
+            if sorted_by_calls and sorted_by_calls[0][1]["called_by_count"] > 0:
+                summary += "**Most Called Functions:**\n"
+                for func_name, metrics in sorted_by_calls:
+                    if metrics["called_by_count"] > 0:
+                        summary += f"• **{func_name}**: called {metrics['called_by_count']} times\n"
+                summary += "\n"
+
+            # Most complex functions (by calls made)
+            sorted_by_complexity = sorted(
+                call_graph_data["function_metrics"].items(),
+                key=lambda x: x[1]["calls_made"],
+                reverse=True,
+            )[:5]
+
+            if sorted_by_complexity and sorted_by_complexity[0][1]["calls_made"] > 0:
+                summary += "**Functions Making Most Calls:**\n"
+                for func_name, metrics in sorted_by_complexity:
+                    if metrics["calls_made"] > 0:
+                        summary += (
+                            f"• **{func_name}**: makes {metrics['calls_made']} calls\n"
+                        )
+                summary += "\n"
+
+        # === COMPLEXITY ANALYSIS ===
+        if function_complexity:
+            summary += "## 📈 **Complexity Analysis**\n"
+
+            # Sort by complexity
+            sorted_complexity = sorted(
+                function_complexity.items(),
+                key=lambda x: x[1]["complexity"],
+                reverse=True,
+            )[:5]
+
+            summary += "**Most Complex Functions:**\n"
+            for func_name, metrics in sorted_complexity:
+                summary += f"• **{func_name}**: complexity {metrics['complexity']}, {metrics['lines_of_code']} lines\n"
+
+            # Overall stats
+            total_functions = len(function_complexity)
+            avg_complexity = (
+                sum(m["complexity"] for m in function_complexity.values())
+                / total_functions
+            )
+            avg_lines = (
+                sum(m["lines_of_code"] for m in function_complexity.values())
+                / total_functions
+            )
+            functions_with_docs = sum(
+                1 for m in function_complexity.values() if m["has_docstring"]
+            )
+
+            summary += "\n**Overall Function Metrics:**\n"
+            summary += f"• **Average Complexity**: {avg_complexity:.1f}\n"
+            summary += f"• **Average Lines per Function**: {avg_lines:.1f}\n"
+            summary += f"• **Functions with Docstrings**: {functions_with_docs}/{total_functions} ({100*functions_with_docs/total_functions:.1f}%)\n"
+            summary += "\n"
+
+        # === IMPORTS SECTION ===
+        if imports:
+            summary += "## 📦 **Imports**\n"
+            unique_imports = list(set(imports))
+            for imp in unique_imports[:10]:  # Show first 10 imports
+                summary += f"• {imp}\n"
+            if len(unique_imports) > 10:
+                summary += f"• ... and {len(unique_imports) - 10} more\n"
+            summary += "\n"
+
+        # === CALL GRAPH ERROR/INFO ===
+        if call_graph_data and "error" in call_graph_data:
+            summary += "## ⚠️ **Call Graph Analysis**\n"
+            summary += f"Call graph generation failed: {call_graph_data['error']}\n\n"
+        elif call_graph_data and "info" in call_graph_data:
+            summary += "## 📊 **Call Graph Analysis**\n"
+            summary += f"{call_graph_data['info']}\n\n"
+
+        # === RECOMMENDATIONS ===
+        summary += "## 💡 **Recommendations**\n"
+        if function_complexity:
+            high_complexity = [
+                f for f, m in function_complexity.items() if m["complexity"] > 10
+            ]
+            if high_complexity:
+                summary += f"• Consider refactoring high-complexity functions: {', '.join(high_complexity)}\n"
+
+            no_docs = [
+                f for f, m in function_complexity.items() if not m["has_docstring"]
+            ]
+            if no_docs:
+                summary += f"• Add docstrings to: {', '.join(no_docs[:5])}{'...' if len(no_docs) > 5 else ''}\n"
+
+        if call_graph_data and "function_metrics" in call_graph_data:
+            isolated_functions = [
+                f
+                for f, m in call_graph_data["function_metrics"].items()
+                if m["calls_made"] == 0 and m["called_by_count"] == 0
+            ]
+            if isolated_functions:
+                summary += f"• Review isolated functions: {', '.join(isolated_functions[:3])}{'...' if len(isolated_functions) > 3 else ''}\n"
+
+        return summary
+
+    except SyntaxError as e:
+        return f"❌ **Syntax Error in Python code:**\n```\n{str(e)}\n```"
+    except Exception as e:
+        return f"❌ **Error analyzing code:**\n```\n{str(e)}\n```"
+
+
+def list_example_files() -> list:
+    """List all example .py files in the examples/ directory."""
+    examples_dir = os.path.join(os.getcwd(), "examples")
+    if not os.path.exists(examples_dir):
+        return []
+    return [f for f in os.listdir(examples_dir) if f.endswith(".py")]
+
+
+def get_sample_code(filename: str) -> str:
+    """Return sample Python code from examples/ directory."""
+    examples_dir = os.path.join(os.getcwd(), "examples")
+    file_path = os.path.join(examples_dir, filename)
+    with open(file_path, "r", encoding="utf-8") as f:
+        return f.read()
+
+
+def generate_all_diagrams(python_code: str, filename: str = "diagram") -> Tuple[Optional[str], Optional[str], str]:
+    """Generate all diagrams and analysis at once.
+    
+    Args:
+        python_code: The Python code to analyze
+        filename: Base filename for diagrams
+        
+    Returns:
+        Tuple of (uml_diagram_path, call_graph_path, analysis_text)
+    """
+    if not python_code.strip():
+        return None, None, "No code provided for analysis."
+    
+    print("🚀 Starting comprehensive diagram generation...")
+    
+    # Step 1: Generate UML Class Diagram
+    print("📊 Step 1/3: Generating UML class diagram...")
+    uml_diagram_path = generate_diagram(python_code, filename)
+    
+    # Step 2: Generate Call Graph
+    print("🔗 Step 2/3: Generating call graph...")
+    try:
+        cleanup_testing_space()
+        dot_content, call_graph_path, structured_data = generate_call_graph_with_pyan3(python_code)
+    except Exception as e:
+        print(f"⚠️ Call graph generation failed: {e}")
+        call_graph_path = None
+    
+    # Step 3: Generate Analysis
+    print("📈 Step 3/3: Performing code analysis...")
+    analysis_text = analyze_code_structure(python_code)
+    
+    print("✅ All diagrams and analysis completed!")
+    
+    return uml_diagram_path, call_graph_path, analysis_text
+
+
+# Create Gradio interface
+with gr.Blocks(
+    title="Python UML Diagram Generator & MCP Server",
+    theme=gr.themes.Soft(),
+    css="""
+    .gradio-container {
+        max-width: 1400px !important;
+    }
+    .code-input {
+        font-family: 'Courier New', monospace !important;
+    }
+    """,
+) as demo:
+    # Header
+    gr.Markdown(
+        """
+    # 🐍 Python UML Diagram Generator & MCP Server
+    
+    **Dual Functionality:**
+    - 🖥️ **Web Interface**: Generate UML class diagrams and call graphs from Python code
+    - 🤖 **MCP Server**: Provides tools for AI assistants (Claude Desktop, Cursor, etc.)
+    
+    Transform your Python code into comprehensive visual diagrams and analysis!
+    """
+    )
+
+    with gr.Tab("🎨 Diagram Generator"):
+        with gr.Row():
+            with gr.Column(scale=1):
+                gr.Markdown("### Input")
+
+                example_files = list_example_files()
+                example_dropdown = gr.Dropdown(
+                    label="Choose Example",
+                    choices=example_files,
+                    value=example_files[0] if example_files else None,
+                )
+
+                code_input = gr.Textbox(
+                    label="Python Code",
+                    placeholder="Paste your Python code here...",
+                    lines=20,
+                    max_lines=35,
+                    value=get_sample_code(example_files[0]) if example_files else "",
+                    elem_classes=["code-input"],
+                )
+
+                with gr.Row():
+                    filename_input = gr.Textbox(
+                        label="Diagram Name",
+                        value="my_diagram",
+                        placeholder="Enter a name for your diagram",
+                        scale=2,
+                    )
+
+                with gr.Row():
+                    generate_diagrams_btn = gr.Button(
+                        "🔄 Generate Diagrams", variant="primary", size="lg"
+                    )
+
+            with gr.Column(scale=1):
+                gr.Markdown("### Generated UML Class Diagram")
+
+                uml_diagram_output = gr.Image(
+                    label="UML Class Diagram",
+                    show_download_button=True,
+                    height=300,
+                )
+                
+                gr.Markdown("### Generated Call Graph Diagram")
+
+                call_graph_output = gr.Image(
+                    label="Function Call Graph",
+                    show_download_button=True,
+                    height=300,
+                )
+
+        with gr.Row():
+            gr.Markdown("### Code Analysis")
+            
+        with gr.Row():
+            analysis_output = gr.Textbox(
+                label="Comprehensive Code Analysis",
+                lines=15,
+                max_lines=25,
+                interactive=False,
+                show_copy_button=True,
+            )
+
+    with gr.Tab("ℹ️ About & Help"):
+        gr.Markdown(
+            """
+        ## About This Tool
+        
+        This Python UML Diagram Generator helps you visualize the structure of your Python code by creating comprehensive diagrams and analysis.
+        ### Inspiration:
+        The idea for this mcp server was inspired by a tweet made by karpathy [tweet](https://x.com/karpathy/status/1930305209747812559).
+        He makes the point that generated images are easy to discriminate by humans while going through a 300 line LLM generated code is time consuming.
+        This tool aims to provide a visual quick smell test for generated code so that user can quickly identify issues instead of going through the code line by line.
+        This is only a very rough and basic implementation of the idea.
+        Making compound AI systems instead of text-to-text chatbots is the necessary direction. 
+
+        ### ✨ Features:
+        - **UML Class Diagrams**: Automatically identifies classes, methods, attributes, and inheritance
+        - **Call Graph Diagrams**: Visualizes function dependencies and call relationships  
+        - **Code Analysis**: Provides detailed structure analysis with complexity metrics
+        - **MCP Integration**: Works with AI assistants via Model Context Protocol
+        
+        ### 📚 How to Use:
+        1. **Paste Code**: Enter your Python code in the text area
+        2. **Set Name**: Choose a name for your diagrams (optional)
+        3. **Generate**: Click "Generate Diagrams" to create all visualizations and analysis
+        4. **Download**: Save the generated diagram images
+        5. **Review**: Read the comprehensive code analysis
+        
+        ### 🔧 Technical Details:
+        - Built with **Gradio** for the web interface
+        - Uses **py2puml** for Python-to-PlantUML conversion
+        - **PlantUML** for UML diagram rendering
+        - **pyan3** and **Graphviz** for call graph generation
+        - **AST** (Abstract Syntax Tree) for code analysis
+        
+        ### 💡 Tips:
+        - Include type hints for better diagram quality
+        - Use meaningful class and method names
+        - Keep inheritance hierarchies clear
+        - Add docstrings for better understanding
+        - Works great with both class-based and function-based code
+        
+        ### 🐛 Troubleshooting:
+        - **No UML diagram generated**: Check if your code contains class definitions
+        - **No call graph generated**: Ensure your code has function definitions and calls
+        - **Syntax errors**: Ensure your Python code is valid
+        - **Import errors**: Stick to standard library imports for best results
+        
+        ## Model Context Protocol (MCP) Server
+        
+        This application automatically serves as an MCP server for AI assistants!
+        
+        ### 🌐 For Hugging Face Spaces (Public):
+        ```json
+        {
+          "mcpServers": {
+            "python-diagram-generator": {
+              "url": "https://your-username-space-name.hf.space/gradio_api/mcp/sse"
+            }
+          }
+        }
+        ```
+        
+        ### 🏠 For Local Development:
+        ```json
+        {
+          "mcpServers": {
+            "python-diagram-generator": {
+              "command": "npx",
+              "args": [
+                "mcp-remote",
+                "http://127.0.0.1:7860/gradio_api/mcp/sse",
+                "--transport",
+                "sse-only"
+              ]
+            }
+          }
+        }
+        ```
+        
+        ### 🔒 For Private Spaces:
+        ```json
+        {
+          "mcpServers": {
+            "python-diagram-generator": {
+              "url": "https://your-username-space-name.hf.space/gradio_api/mcp/sse",
+              "headers": {
+                "Authorization": "Bearer hf_your_token_here"
+              }
+            }
+          }
+        }
+        ```
+        
+        ### 📋 Setup Instructions:
+        1. Install Node.js and mcp-remote: `npm install -g mcp-remote`
+        2. Add the configuration above to your MCP client
+        3. Restart your MCP client (e.g., Claude Desktop)
+        4. Test with prompts like: "Generate a UML diagram for this Python code: [your code]"
+        
+        ---
+        
+        **Local MCP Endpoint**: `http://127.0.0.1:7860/gradio_api/mcp/sse`  
+        **MCP Schema**: View at `/gradio_api/mcp/schema`
+        
+        ### 🚀 Future Features:
+        - Logic flowcharts
+        - Data flow diagrams  
+        - State machine diagrams
+        - Multi-file analysis
+        - Enhanced UML features
+        """
+        )
+
+    # Event handlers
+    def load_example(example_filename):
+        return get_sample_code(example_filename)
+
+    example_dropdown.change(
+        fn=load_example,
+        inputs=example_dropdown,
+        outputs=code_input,
+    )
+
+    generate_diagrams_btn.click(
+        fn=generate_all_diagrams,
+        inputs=[code_input, filename_input],
+        outputs=[uml_diagram_output, call_graph_output, analysis_output],
+        show_progress=True,
+    )
+
+    code_input.change(
+        fn=analyze_code_structure,
+        inputs=code_input,
+        outputs=analysis_output,
+        show_progress=False,
+    )
+
+# Launch configuration
+if __name__ == "__main__":
+    # Setup persistent testing space at startup
+    setup_testing_space()
+
+    demo.launch(
+        mcp_server=True,  # Enable MCP functionality
+        show_api=True,  # Show API documentation
+        show_error=True,  # Show errors in interface
+        # share = False  # Share the app publicly
+        debug=True,  # Enable debug mode for development
+    )

examples/complex_class.py

@@ -0,0 +1,73 @@
+"""Complex class example with properties, decorators, and advanced features."""
+
+from datetime import datetime
+from typing import Optional, List
+
+
+class Product:
+    """Product class with advanced Python features."""
+    
+    # Class variable
+    total_products = 0
+    
+    def __init__(self, name: str, price: float, category: str):
+        self._name = name
+        self._price = price
+        self._category = category
+        self._created_at = datetime.now()
+        self._discount = 0.0
+        Product.total_products += 1
+    
+    @property
+    def name(self) -> str:
+        """Product name property."""
+        return self._name
+    
+    @name.setter
+    def name(self, value: str):
+        if not value.strip():
+            raise ValueError("Product name cannot be empty")
+        self._name = value
+    
+    @property
+    def price(self) -> float:
+        """Product price with discount applied."""
+        return self._price * (1 - self._discount)
+    
+    @property
+    def original_price(self) -> float:
+        """Original price before discount."""
+        return self._price
+    
+    @original_price.setter
+    def original_price(self, value: float):
+        if value < 0:
+            raise ValueError("Price cannot be negative")
+        self._price = value
+    
+    def apply_discount(self, percentage: float):
+        """Apply discount percentage."""
+        if 0 <= percentage <= 100:
+            self._discount = percentage / 100
+    
+    @staticmethod
+    def validate_category(category: str) -> bool:
+        """Validate if category is allowed."""
+        allowed_categories = ["electronics", "clothing", "books", "food"]
+        return category.lower() in allowed_categories
+    
+    @classmethod
+    def create_book(cls, title: str, price: float):
+        """Factory method to create a book product."""
+        return cls(title, price, "books")
+    
+    @classmethod
+    def get_total_products(cls) -> int:
+        """Get total number of products created."""
+        return cls.total_products
+    
+    def __str__(self) -> str:
+        return f"{self._name} - ${self.price:.2f}"
+    
+    def __repr__(self) -> str:
+        return f"Product(name='{self._name}', price={self._price}, category='{self._category}')"

examples/fibonacci_functions.py

@@ -0,0 +1,88 @@
+"""
+Fibonacci computation functions for testing function analysis.
+"""
+
+def fibonacci_recursive(n):
+    """Calculate fibonacci number using recursion."""
+    if n <= 1:
+        return n
+    return fibonacci_recursive(n - 1) + fibonacci_recursive(n - 2)
+
+
+def fibonacci_iterative(n):
+    """Calculate fibonacci number using iteration."""
+    if n <= 1:
+        return n
+    
+    a, b = 0, 1
+    for _ in range(2, n + 1):
+        a, b = b, a + b
+    return b
+
+
+def fibonacci_memoized(n, memo=None):
+    """Calculate fibonacci number using memoization."""
+    if memo is None:
+        memo = {}
+    
+    if n in memo:
+        return memo[n]
+    
+    if n <= 1:
+        memo[n] = n
+        return n
+    
+    memo[n] = fibonacci_memoized(n - 1, memo) + fibonacci_memoized(n - 2, memo)
+    return memo[n]
+
+
+def fibonacci_sequence(count):
+    """Generate a sequence of fibonacci numbers."""
+    sequence = []
+    for i in range(count):
+        sequence.append(fibonacci_iterative(i))
+    return sequence
+
+
+def compare_fibonacci_methods(n):
+    """Compare different fibonacci calculation methods."""
+    import time
+    
+    methods = [
+        ("Recursive", fibonacci_recursive),
+        ("Iterative", fibonacci_iterative), 
+        ("Memoized", fibonacci_memoized)
+    ]
+    
+    results = {}
+    for name, func in methods:
+        start_time = time.time()
+        result = func(n)
+        end_time = time.time()
+        results[name] = {
+            'result': result,
+            'time': end_time - start_time
+        }
+    
+    return results
+
+
+def validate_fibonacci_result(n, result):
+    """Validate if a fibonacci result is correct."""
+    if n <= 1:
+        return result == n
+    
+    # Use iterative method as baseline for validation
+    expected = fibonacci_iterative(n)
+    return result == expected
+
+
+if __name__ == "__main__":
+    n = 10
+    print(f"Fibonacci({n}) using different methods:")
+    
+    results = compare_fibonacci_methods(n)
+    for method, data in results.items():
+        print(f"{method}: {data['result']} (took {data['time']:.6f} seconds)")
+    
+    print(f"\nFirst 15 fibonacci numbers: {fibonacci_sequence(15)}")

examples/inheritance_example.py

@@ -0,0 +1,48 @@
+"""Class inheritance example for testing AST parsing."""
+
+class Animal:
+    """Base animal class."""
+    
+    def __init__(self, name, species):
+        self.name = name
+        self.species = species
+        self.is_alive = True
+    
+    def speak(self):
+        return "Some generic animal sound"
+    
+    def eat(self):
+        return f"{self.name} is eating"
+
+
+class Dog(Animal):
+    """Dog class inheriting from Animal."""
+    
+    def __init__(self, name, breed):
+        super().__init__(name, "Canine")
+        self.breed = breed
+        self.is_trained = False
+    
+    def speak(self):
+        return "Woof!"
+    
+    def fetch(self):
+        return f"{self.name} is fetching the ball"
+    
+    def train(self):
+        self.is_trained = True
+
+
+class Cat(Animal):
+    """Cat class inheriting from Animal."""
+    
+    def __init__(self, name, color):
+        super().__init__(name, "Feline")
+        self.color = color
+        self.lives_left = 9
+    
+    def speak(self):
+        return "Meow!"
+    
+    def climb(self):
+        return f"{self.name} is climbing"

examples/main_with_helpers.py

@@ -0,0 +1,223 @@
+"""
+Main function with multiple helper functions for testing function analysis.
+"""
+
+import os
+import json
+from datetime import datetime
+from typing import Dict, List, Any
+
+
+def read_config_file(config_path):
+    """Read configuration from JSON file."""
+    try:
+        with open(config_path, 'r') as file:
+            return json.load(file)
+    except FileNotFoundError:
+        print(f"Config file not found: {config_path}")
+        return {}
+    except json.JSONDecodeError:
+        print(f"Invalid JSON in config file: {config_path}")
+        return {}
+
+
+def validate_config(config):
+    """Validate configuration parameters."""
+    required_keys = ['input_directory', 'output_directory', 'file_extensions']
+    
+    for key in required_keys:
+        if key not in config:
+            print(f"Missing required config key: {key}")
+            return False
+    
+    # Validate directories exist
+    if not os.path.exists(config['input_directory']):
+        print(f"Input directory does not exist: {config['input_directory']}")
+        return False
+    
+    return True
+
+
+def create_output_directory(output_path):
+    """Create output directory if it doesn't exist."""
+    try:
+        os.makedirs(output_path, exist_ok=True)
+        print(f"Output directory ready: {output_path}")
+        return True
+    except PermissionError:
+        print(f"Permission denied creating directory: {output_path}")
+        return False
+
+
+def scan_files(directory, extensions):
+    """Scan directory for files with specified extensions."""
+    found_files = []
+    
+    for root, dirs, files in os.walk(directory):
+        for file in files:
+            file_extension = os.path.splitext(file)[1].lower()
+            if file_extension in extensions:
+                full_path = os.path.join(root, file)
+                found_files.append(full_path)
+    
+    return found_files
+
+
+def analyze_file(file_path):
+    """Analyze a single file and return statistics."""
+    try:
+        with open(file_path, 'r', encoding='utf-8') as file:
+            content = file.read()
+        
+        stats = {
+            'file_path': file_path,
+            'file_size': os.path.getsize(file_path),
+            'line_count': len(content.splitlines()),
+            'character_count': len(content),
+            'word_count': len(content.split()),
+            'last_modified': datetime.fromtimestamp(os.path.getmtime(file_path)).isoformat()
+        }
+        
+        return stats
+        
+    except Exception as e:
+        print(f"Error analyzing file {file_path}: {e}")
+        return None
+
+
+def process_files(file_list):
+    """Process multiple files and return aggregated results."""
+    results = []
+    total_size = 0
+    total_lines = 0
+    
+    print(f"Processing {len(file_list)} files...")
+    
+    for file_path in file_list:
+        print(f"  Analyzing: {os.path.basename(file_path)}")
+        
+        file_stats = analyze_file(file_path)
+        if file_stats:
+            results.append(file_stats)
+            total_size += file_stats['file_size']
+            total_lines += file_stats['line_count']
+    
+    summary = {
+        'total_files': len(results),
+        'total_size_bytes': total_size,
+        'total_lines': total_lines,
+        'average_file_size': total_size / len(results) if results else 0,
+        'average_lines_per_file': total_lines / len(results) if results else 0
+    }
+    
+    return results, summary
+
+
+def generate_report(results, summary, output_file):
+    """Generate a detailed report of the analysis."""
+    report = {
+        'generated_at': datetime.now().isoformat(),
+        'summary': summary,
+        'file_details': results
+    }
+    
+    try:
+        with open(output_file, 'w') as file:
+            json.dump(report, file, indent=2)
+        print(f"Report generated: {output_file}")
+        return True
+    except Exception as e:
+        print(f"Error generating report: {e}")
+        return False
+
+
+def print_summary(summary):
+    """Print a human-readable summary."""
+    print("\n" + "="*50)
+    print("FILE ANALYSIS SUMMARY")
+    print("="*50)
+    print(f"Total files processed: {summary['total_files']}")
+    print(f"Total size: {summary['total_size_bytes']:,} bytes")
+    print(f"Total lines: {summary['total_lines']:,}")
+    print(f"Average file size: {summary['average_file_size']:.1f} bytes")
+    print(f"Average lines per file: {summary['average_lines_per_file']:.1f}")
+    print("="*50)
+
+
+def cleanup_temp_files(temp_directory):
+    """Clean up temporary files."""
+    if not os.path.exists(temp_directory):
+        return
+    
+    try:
+        temp_files = os.listdir(temp_directory)
+        for temp_file in temp_files:
+            if temp_file.startswith('temp_'):
+                file_path = os.path.join(temp_directory, temp_file)
+                os.remove(file_path)
+                print(f"Removed temp file: {temp_file}")
+    except Exception as e:
+        print(f"Error during cleanup: {e}")
+
+
+def main():
+    """Main function that orchestrates the file analysis process."""
+    print("Starting File Analysis Tool")
+    print("-" * 30)
+    
+    # Step 1: Read configuration
+    config_file = "config.json"
+    config = read_config_file(config_file)
+    
+    if not config:
+        print("Using default configuration...")
+        config = {
+            'input_directory': '.',
+            'output_directory': './output',
+            'file_extensions': ['.py', '.txt', '.md'],
+            'generate_report': True
+        }
+    
+    # Step 2: Validate configuration
+    if not validate_config(config):
+        print("Configuration validation failed. Exiting.")
+        return False
+    
+    # Step 3: Create output directory
+    if not create_output_directory(config['output_directory']):
+        print("Failed to create output directory. Exiting.")
+        return False
+    
+    # Step 4: Scan for files
+    print(f"Scanning for files in: {config['input_directory']}")
+    file_list = scan_files(config['input_directory'], config['file_extensions'])
+    
+    if not file_list:
+        print("No files found matching criteria.")
+        return False
+    
+    print(f"Found {len(file_list)} files to process")
+    
+    # Step 5: Process files
+    results, summary = process_files(file_list)
+    
+    # Step 6: Generate report
+    if config.get('generate_report', True):
+        report_file = os.path.join(config['output_directory'], 'analysis_report.json')
+        generate_report(results, summary, report_file)
+    
+    # Step 7: Display summary
+    print_summary(summary)
+    
+    # Step 8: Cleanup
+    temp_dir = config.get('temp_directory')
+    if temp_dir:
+        cleanup_temp_files(temp_dir)
+    
+    print("\nFile analysis completed successfully!")
+    return True
+
+
+if __name__ == "__main__":
+    success = main()
+    exit(0 if success else 1)

examples/multiple_classes.py

@@ -0,0 +1,62 @@
+"""Multiple classes example for testing AST parsing."""
+
+class BankAccount:
+    """Simple bank account class."""
+    
+    def __init__(self, account_number, initial_balance=0):
+        self.account_number = account_number
+        self.balance = initial_balance
+        self.transaction_history = []
+    
+    def deposit(self, amount):
+        self.balance += amount
+        self.transaction_history.append(f"Deposit: +{amount}")
+    
+    def withdraw(self, amount):
+        if amount <= self.balance:
+            self.balance -= amount
+            self.transaction_history.append(f"Withdrawal: -{amount}")
+            return True
+        return False
+    
+    def get_balance(self):
+        return self.balance
+
+
+class Customer:
+    """Customer class to hold account information."""
+    
+    def __init__(self, customer_id, name, email):
+        self.customer_id = customer_id
+        self.name = name
+        self.email = email
+        self.accounts = []
+    
+    def add_account(self, account):
+        self.accounts.append(account)
+    
+    def get_total_balance(self):
+        return sum(account.get_balance() for account in self.accounts)
+
+
+class Bank:
+    """Bank class to manage customers and accounts."""
+    
+    def __init__(self, name):
+        self.name = name
+        self.customers = {}
+        self.next_account_number = 1000
+    
+    def create_customer(self, name, email):
+        customer_id = len(self.customers) + 1
+        customer = Customer(customer_id, name, email)
+        self.customers[customer_id] = customer
+        return customer
+    
+    def create_account(self, customer_id, initial_balance=0):
+        if customer_id in self.customers:
+            account = BankAccount(self.next_account_number, initial_balance)
+            self.customers[customer_id].add_account(account)
+            self.next_account_number += 1
+            return account
+        return None

examples/sample_classes.py

@@ -0,0 +1,62 @@
+class Animal:
+    def __init__(self, name: str, age: int):
+        self.name = name
+        self.age = age
+
+    def speak(self) -> str:
+        pass
+
+    def get_info(self) -> str:
+        return f"{self.name} is {self.age} years old"
+
+
+class Dog(Animal):
+    def __init__(self, name: str, age: int, breed: str):
+        super().__init__(name, age)
+        self.breed = breed
+
+    def speak(self) -> str:
+        return f"{self.name} says Woof!"
+
+    def fetch(self) -> str:
+        return f"{self.name} is fetching the ball"
+
+
+class Cat(Animal):
+    def __init__(self, name: str, age: int, indoor: bool = True):
+        super().__init__(name, age)
+        self.indoor = indoor
+
+    def speak(self) -> str:
+        return f"{self.name} says Meow!"
+
+    def climb(self) -> str:
+        return f"{self.name} is climbing"
+
+
+class PetOwner:
+    def __init__(self, name: str):
+        self.name = name
+        self.pets = []
+
+    def add_pet(self, pet: Animal):
+        self.pets.append(pet)
+
+    def call_all_pets(self) -> list:
+        # return [pet.speak() for pet in self.pets]
+        result = []
+
+        for pet in self.pets:
+            result.append(pet.speak())
+        return result
+
+
+def create_pet_family():
+    owner = PetOwner("Alice")
+    dog = Dog("Buddy", 3, "Golden Retriever")
+    cat = Cat("Whiskers", 2, True)
+
+    owner.add_pet(dog)
+    owner.add_pet(cat)
+
+    return owner

examples/sample_functions.py

@@ -0,0 +1,139 @@
+import math
+import random
+from typing import List, Tuple
+
+def calculate_factorial(n: int) -> int:
+    """Calculate factorial of a number recursively."""
+    if n <= 1:
+        return 1
+    return n * calculate_factorial(n - 1)
+
+def fibonacci_sequence(n: int) -> List[int]:
+    """Generate fibonacci sequence up to n terms."""
+    if n <= 0:
+        return []
+    elif n == 1:
+        return [0]
+    elif n == 2:
+        return [0, 1]
+    
+    sequence = [0, 1]
+    for i in range(2, n):
+        sequence.append(sequence[i-1] + sequence[i-2])
+    return sequence
+
+def is_prime(num: int) -> bool:
+    """Check if a number is prime."""
+    if num < 2:
+        return False
+    if num == 2:
+        return True
+    if num % 2 == 0:
+        return False
+    
+    for i in range(3, int(math.sqrt(num)) + 1, 2):
+        if num % i == 0:
+            return False
+    return True
+
+def find_primes_in_range(start: int, end: int) -> List[int]:
+    """Find all prime numbers in a given range."""
+    primes = []
+    for num in range(start, end + 1):
+        if is_prime(num):
+            primes.append(num)
+    return primes
+
+def calculate_statistics(numbers: List[float]) -> dict:
+    """Calculate basic statistics for a list of numbers."""
+    if not numbers:
+        return {"error": "Empty list provided"}
+    
+    n = len(numbers)
+    mean = sum(numbers) / n
+    sorted_nums = sorted(numbers)
+    
+    # Calculate median
+    if n % 2 == 0:
+        median = (sorted_nums[n//2 - 1] + sorted_nums[n//2]) / 2
+    else:
+        median = sorted_nums[n//2]
+    
+    # Calculate variance and standard deviation
+    variance = sum((x - mean) ** 2 for x in numbers) / n
+    std_dev = math.sqrt(variance)
+    
+    return {
+        "count": n,
+        "mean": mean,
+        "median": median,
+        "min": min(numbers),
+        "max": max(numbers),
+        "variance": variance,
+        "std_deviation": std_dev
+    }
+
+def monte_carlo_pi(iterations: int) -> float:
+    """Estimate Pi using Monte Carlo method."""
+    inside_circle = 0
+    
+    for _ in range(iterations):
+        x, y = random.random(), random.random()
+        if x*x + y*y <= 1:
+            inside_circle += 1
+    
+    return 4 * inside_circle / iterations
+
+def process_data_pipeline(data: List[int]) -> dict:
+    """Complex data processing pipeline demonstrating function calls."""
+    # Step 1: Filter for positive numbers
+    positive_data = []
+    for x in data:
+        if x > 0:
+            positive_data.append(x)
+    
+    # Step 2: Find primes in the data
+    primes_in_data = []
+    for x in positive_data:
+        if is_prime(x):
+            primes_in_data.append(x)
+    
+    # Step 3: Calculate statistics
+    positive_data_floats = []
+    for x in positive_data:
+        positive_data_floats.append(float(x))
+    stats = calculate_statistics(positive_data_floats)
+    
+    # Step 4: Generate fibonacci sequence up to max value
+    max_val = max(positive_data) if positive_data else 0
+    fib_count = min(max_val, 20)  # Limit to reasonable size
+    fib_sequence = fibonacci_sequence(fib_count)
+    
+    # Step 5: Calculate factorials for small numbers
+    small_numbers = []
+    for x in positive_data:
+        if x <= 10:
+            small_numbers.append(x)
+    factorials = {}
+    for x in small_numbers:
+        factorials[x] = calculate_factorial(x)
+    
+    return {
+        "original_count": len(data),
+        "positive_count": len(positive_data),
+        "primes_found": primes_in_data,
+        "statistics": stats,
+        "fibonacci_sequence": fib_sequence,
+        "factorials": factorials,
+        "pi_estimate": monte_carlo_pi(1000)
+    }
+
+def main():
+    """Main function demonstrating the pipeline."""
+    sample_data = [1, 2, 3, 5, 8, 13, 21, -1, 0, 17, 19, 23]
+    result = process_data_pipeline(sample_data)
+    print(f"Processing complete: {len(result)} metrics calculated")
+    return result
+
+if __name__ == "__main__":
+    main()

examples/simple_class.py

@@ -0,0 +1,21 @@
+"""Simple class example for testing AST parsing."""
+
+class Person:
+    """A simple Person class."""
+    
+    def __init__(self, name, age):
+        self.name = name
+        self.age = age
+        self.email = None
+    
+    def get_name(self):
+        return self.name
+    
+    def set_email(self, email):
+        self.email = email
+    
+    def greet(self):
+        return f"Hello, I'm {self.name}"
+    
+    def is_adult(self):
+        return self.age >= 18

examples/string_processing.py

@@ -0,0 +1,163 @@
+"""
+String processing pipeline functions for testing function analysis.
+"""
+
+import re
+from typing import List
+
+
+def normalize_whitespace(text):
+    """Normalize whitespace by removing extra spaces and newlines."""
+    # Replace multiple whitespace with single space
+    text = re.sub(r'\s+', ' ', text)
+    # Strip leading and trailing whitespace
+    return text.strip()
+
+
+def remove_special_characters(text, keep_chars=""):
+    """Remove special characters, optionally keeping specified characters."""
+    # Keep alphanumeric, spaces, and specified characters
+    pattern = fr"[^a-zA-Z0-9\s{re.escape(keep_chars)}]"
+    return re.sub(pattern, '', text)
+
+
+def convert_to_lowercase(text):
+    """Convert text to lowercase."""
+    return text.lower()
+
+
+def remove_stopwords(text, stopwords=None):
+    """Remove common stopwords from text."""
+    if stopwords is None:
+        stopwords = {
+            'the', 'a', 'an', 'and', 'or', 'but', 'in', 'on', 'at', 'to', 
+            'for', 'of', 'with', 'by', 'is', 'are', 'was', 'were', 'be',
+            'been', 'being', 'have', 'has', 'had', 'do', 'does', 'did',
+            'will', 'would', 'could', 'should', 'may', 'might', 'must'
+        }
+    
+    words = text.split()
+    filtered_words = [word for word in words if word.lower() not in stopwords]
+    return ' '.join(filtered_words)
+
+
+def extract_keywords(text, min_length=3):
+    """Extract keywords (words longer than min_length)."""
+    words = text.split()
+    keywords = [word for word in words if len(word) >= min_length]
+    return keywords
+
+
+def count_word_frequency(text):
+    """Count frequency of each word in text."""
+    words = text.split()
+    frequency = {}
+    for word in words:
+        frequency[word] = frequency.get(word, 0) + 1
+    return frequency
+
+
+def capitalize_words(text, exceptions=None):
+    """Capitalize first letter of each word, with exceptions."""
+    if exceptions is None:
+        exceptions = {'a', 'an', 'the', 'and', 'or', 'but', 'in', 'on', 'at', 'to', 'for', 'of', 'with', 'by'}
+    
+    words = text.split()
+    capitalized = []
+    
+    for i, word in enumerate(words):
+        if i == 0 or word.lower() not in exceptions:
+            capitalized.append(word.capitalize())
+        else:
+            capitalized.append(word.lower())
+    
+    return ' '.join(capitalized)
+
+
+def truncate_text(text, max_length=100, suffix="..."):
+    """Truncate text to specified length with suffix."""
+    if len(text) <= max_length:
+        return text
+    
+    truncated = text[:max_length - len(suffix)]
+    # Try to break at last complete word
+    last_space = truncated.rfind(' ')
+    if last_space > max_length * 0.8:  # If we can break at a word boundary
+        truncated = truncated[:last_space]
+    
+    return truncated + suffix
+
+
+def text_processing_pipeline(text, operations=None):
+    """Process text through a pipeline of operations."""
+    if operations is None:
+        operations = [
+            'normalize_whitespace',
+            'remove_special_characters', 
+            'convert_to_lowercase',
+            'remove_stopwords'
+        ]
+    
+    # Map operation names to functions
+    operation_map = {
+        'normalize_whitespace': normalize_whitespace,
+        'remove_special_characters': remove_special_characters,
+        'convert_to_lowercase': convert_to_lowercase,
+        'remove_stopwords': remove_stopwords,
+        'capitalize_words': capitalize_words,
+        'truncate_text': truncate_text
+    }
+    
+    result = text
+    processing_steps = []
+    
+    for operation in operations:
+        if operation in operation_map:
+            before = result
+            result = operation_map[operation](result)
+            processing_steps.append({
+                'operation': operation,
+                'before': before[:50] + "..." if len(before) > 50 else before,
+                'after': result[:50] + "..." if len(result) > 50 else result
+            })
+    
+    return result, processing_steps
+
+
+def analyze_text_statistics(text):
+    """Analyze various statistics about the text."""
+    words = text.split()
+    
+    stats = {
+        'character_count': len(text),
+        'word_count': len(words),
+        'sentence_count': len(re.findall(r'[.!?]+', text)),
+        'average_word_length': sum(len(word) for word in words) / len(words) if words else 0,
+        'longest_word': max(words, key=len) if words else "",
+        'shortest_word': min(words, key=len) if words else ""
+    }
+    
+    return stats
+
+
+if __name__ == "__main__":
+    sample_text = """
+    This is a SAMPLE text with various   formatting issues!!! 
+    It has multiple    spaces, special @#$% characters, and 
+    needs some serious cleaning & processing...
+    """
+    
+    print("Original text:")
+    print(repr(sample_text))
+    
+    processed_text, steps = text_processing_pipeline(sample_text)
+    
+    print("\nProcessing steps:")
+    for step in steps:
+        print(f"After {step['operation']}:")
+        print(f"  {step['after']}")
+    
+    print(f"\nFinal result: {processed_text}")
+    
+    stats = analyze_text_statistics(processed_text)
+    print(f"\nText statistics: {stats}")

packages.txt

@@ -0,0 +1 @@
+graphviz

pyproject.toml

@@ -0,0 +1,23 @@
+[project]
+name = "gradio-plant-uml"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+    "datasets>=3.6.0",
+    "fastapi>=0.115.12",
+    "flask>=3.1.1",
+    "gradio[mcp]>=5.33.0",
+    "graphviz>=0.20.3",
+    "matplotlib>=3.10.3",
+    "numpy>=2.2.6",
+    "pandas>=2.3.0",
+    "plantuml>=0.3.0",
+    "polars>=1.30.0",
+    "py2puml>=0.10.0",
+    "pyan3>=1.2.0",
+    "requests>=2.32.3",
+    "scikit-learn>=1.7.0",
+    "transformers>=4.52.4",
+]

requirements.txt

@@ -0,0 +1,302 @@
+# This file was autogenerated by uv via the following command:
+#    uv pip compile pyproject.toml -o requirements.txt
+aiofiles==24.1.0
+    # via gradio
+aiohappyeyeballs==2.6.1
+    # via aiohttp
+aiohttp==3.12.9
+    # via fsspec
+aiosignal==1.3.2
+    # via aiohttp
+annotated-types==0.7.0
+    # via pydantic
+anyio==4.9.0
+    # via
+    #   gradio
+    #   httpx
+    #   mcp
+    #   sse-starlette
+    #   starlette
+attrs==25.3.0
+    # via aiohttp
+blinker==1.9.0
+    # via flask
+certifi==2025.4.26
+    # via
+    #   httpcore
+    #   httpx
+    #   requests
+charset-normalizer==3.4.2
+    # via requests
+click==8.2.1
+    # via
+    #   flask
+    #   typer
+    #   uvicorn
+colorama==0.4.6
+    # via
+    #   click
+    #   tqdm
+contourpy==1.3.2
+    # via matplotlib
+cycler==0.12.1
+    # via matplotlib
+datasets==3.6.0
+    # via gradio-plant-uml (pyproject.toml)
+dill==0.3.8
+    # via
+    #   datasets
+    #   multiprocess
+fastapi==0.115.12
+    # via
+    #   gradio-plant-uml (pyproject.toml)
+    #   gradio
+ffmpy==0.6.0
+    # via gradio
+filelock==3.18.0
+    # via
+    #   datasets
+    #   huggingface-hub
+    #   transformers
+flask==3.1.1
+    # via gradio-plant-uml (pyproject.toml)
+fonttools==4.58.1
+    # via matplotlib
+frozenlist==1.6.2
+    # via
+    #   aiohttp
+    #   aiosignal
+fsspec==2025.3.0
+    # via
+    #   datasets
+    #   gradio-client
+    #   huggingface-hub
+gradio==5.33.0
+    # via gradio-plant-uml (pyproject.toml)
+gradio-client==1.10.2
+    # via gradio
+graphviz==0.20.3
+    # via gradio-plant-uml (pyproject.toml)
+groovy==0.1.2
+    # via gradio
+h11==0.16.0
+    # via
+    #   httpcore
+    #   uvicorn
+httpcore==1.0.9
+    # via httpx
+httplib2==0.22.0
+    # via plantuml
+httpx==0.28.1
+    # via
+    #   gradio
+    #   gradio-client
+    #   mcp
+    #   safehttpx
+httpx-sse==0.4.0
+    # via mcp
+huggingface-hub==0.32.4
+    # via
+    #   datasets
+    #   gradio
+    #   gradio-client
+    #   tokenizers
+    #   transformers
+idna==3.10
+    # via
+    #   anyio
+    #   httpx
+    #   requests
+    #   yarl
+itsdangerous==2.2.0
+    # via flask
+jinja2==3.1.6
+    # via
+    #   flask
+    #   gradio
+    #   pyan3
+joblib==1.5.1
+    # via scikit-learn
+kiwisolver==1.4.8
+    # via matplotlib
+markdown-it-py==3.0.0
+    # via rich
+markupsafe==3.0.2
+    # via
+    #   flask
+    #   gradio
+    #   jinja2
+    #   werkzeug
+matplotlib==3.10.3
+    # via gradio-plant-uml (pyproject.toml)
+mcp==1.9.0
+    # via gradio
+mdurl==0.1.2
+    # via markdown-it-py
+multidict==6.4.4
+    # via
+    #   aiohttp
+    #   yarl
+multiprocess==0.70.16
+    # via datasets
+numpy==2.2.6
+    # via
+    #   gradio-plant-uml (pyproject.toml)
+    #   contourpy
+    #   datasets
+    #   gradio
+    #   matplotlib
+    #   pandas
+    #   scikit-learn
+    #   scipy
+    #   transformers
+orjson==3.10.18
+    # via gradio
+packaging==25.0
+    # via
+    #   datasets
+    #   gradio
+    #   gradio-client
+    #   huggingface-hub
+    #   matplotlib
+    #   transformers
+pandas==2.3.0
+    # via
+    #   gradio-plant-uml (pyproject.toml)
+    #   datasets
+    #   gradio
+pillow==11.2.1
+    # via
+    #   gradio
+    #   matplotlib
+plantuml==0.3.0
+    # via gradio-plant-uml (pyproject.toml)
+polars==1.30.0
+    # via gradio-plant-uml (pyproject.toml)
+propcache==0.3.1
+    # via
+    #   aiohttp
+    #   yarl
+py2puml==0.10.0
+    # via gradio-plant-uml (pyproject.toml)
+pyan3==1.2.0
+    # via gradio-plant-uml (pyproject.toml)
+pyarrow==20.0.0
+    # via datasets
+pydantic==2.11.5
+    # via
+    #   fastapi
+    #   gradio
+    #   mcp
+    #   pydantic-settings
+pydantic-core==2.33.2
+    # via pydantic
+pydantic-settings==2.9.1
+    # via mcp
+pydub==0.25.1
+    # via gradio
+pygments==2.19.1
+    # via rich
+pyparsing==3.2.3
+    # via
+    #   httplib2
+    #   matplotlib
+python-dateutil==2.9.0.post0
+    # via
+    #   matplotlib
+    #   pandas
+python-dotenv==1.1.0
+    # via pydantic-settings
+python-multipart==0.0.20
+    # via
+    #   gradio
+    #   mcp
+pytz==2025.2
+    # via pandas
+pyyaml==6.0.2
+    # via
+    #   datasets
+    #   gradio
+    #   huggingface-hub
+    #   transformers
+regex==2024.11.6
+    # via transformers
+requests==2.32.3
+    # via
+    #   gradio-plant-uml (pyproject.toml)
+    #   datasets
+    #   huggingface-hub
+    #   transformers
+rich==14.0.0
+    # via typer
+ruff==0.11.13
+    # via gradio
+safehttpx==0.1.6
+    # via gradio
+safetensors==0.5.3
+    # via transformers
+scikit-learn==1.7.0
+    # via gradio-plant-uml (pyproject.toml)
+scipy==1.15.3
+    # via scikit-learn
+semantic-version==2.10.0
+    # via gradio
+shellingham==1.5.4
+    # via typer
+six==1.17.0
+    # via python-dateutil
+sniffio==1.3.1
+    # via anyio
+sse-starlette==2.3.6
+    # via mcp
+starlette==0.46.2
+    # via
+    #   fastapi
+    #   gradio
+    #   mcp
+threadpoolctl==3.6.0
+    # via scikit-learn
+tokenizers==0.21.1
+    # via transformers
+tomlkit==0.13.3
+    # via gradio
+tqdm==4.67.1
+    # via
+    #   datasets
+    #   huggingface-hub
+    #   transformers
+transformers==4.52.4
+    # via gradio-plant-uml (pyproject.toml)
+typer==0.16.0
+    # via gradio
+typing-extensions==4.14.0
+    # via
+    #   anyio
+    #   fastapi
+    #   gradio
+    #   gradio-client
+    #   huggingface-hub
+    #   pydantic
+    #   pydantic-core
+    #   typer
+    #   typing-inspection
+typing-inspection==0.4.1
+    # via
+    #   pydantic
+    #   pydantic-settings
+tzdata==2025.2
+    # via pandas
+urllib3==2.4.0
+    # via requests
+uvicorn==0.34.3
+    # via
+    #   gradio
+    #   mcp
+websockets==15.0.1
+    # via gradio-client
+werkzeug==3.1.3
+    # via flask
+xxhash==3.5.0
+    # via datasets
+yarl==1.20.0
+    # via aiohttp