Implement initial project structure and setup

.gitignore

@@ -0,0 +1,41 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Virtual Environment
+venv/
+ENV/
+env/
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# Project specific
+output/
+*.gif
+.env
+
+# OS specific
+.DS_Store
+Thumbs.db 

.gradio/certificate.pem

@@ -0,0 +1,31 @@
+-----BEGIN CERTIFICATE-----
+MIIFazCCA1OgAwIBAgIRAIIQz7DSQONZRGPgu2OCiwAwDQYJKoZIhvcNAQELBQAw
+TzELMAkGA1UEBhMCVVMxKTAnBgNVBAoTIEludGVybmV0IFNlY3VyaXR5IFJlc2Vh
+cmNoIEdyb3VwMRUwEwYDVQQDEwxJU1JHIFJvb3QgWDEwHhcNMTUwNjA0MTEwNDM4
+WhcNMzUwNjA0MTEwNDM4WjBPMQswCQYDVQQGEwJVUzEpMCcGA1UEChMgSW50ZXJu
+ZXQgU2VjdXJpdHkgUmVzZWFyY2ggR3JvdXAxFTATBgNVBAMTDElTUkcgUm9vdCBY
+MTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAK3oJHP0FDfzm54rVygc
+h77ct984kIxuPOZXoHj3dcKi/vVqbvYATyjb3miGbESTtrFj/RQSa78f0uoxmyF+
+0TM8ukj13Xnfs7j/EvEhmkvBioZxaUpmZmyPfjxwv60pIgbz5MDmgK7iS4+3mX6U
+A5/TR5d8mUgjU+g4rk8Kb4Mu0UlXjIB0ttov0DiNewNwIRt18jA8+o+u3dpjq+sW
+T8KOEUt+zwvo/7V3LvSye0rgTBIlDHCNAymg4VMk7BPZ7hm/ELNKjD+Jo2FR3qyH
+B5T0Y3HsLuJvW5iB4YlcNHlsdu87kGJ55tukmi8mxdAQ4Q7e2RCOFvu396j3x+UC
+B5iPNgiV5+I3lg02dZ77DnKxHZu8A/lJBdiB3QW0KtZB6awBdpUKD9jf1b0SHzUv
+KBds0pjBqAlkd25HN7rOrFleaJ1/ctaJxQZBKT5ZPt0m9STJEadao0xAH0ahmbWn
+OlFuhjuefXKnEgV4We0+UXgVCwOPjdAvBbI+e0ocS3MFEvzG6uBQE3xDk3SzynTn
+jh8BCNAw1FtxNrQHusEwMFxIt4I7mKZ9YIqioymCzLq9gwQbooMDQaHWBfEbwrbw
+qHyGO0aoSCqI3Haadr8faqU9GY/rOPNk3sgrDQoo//fb4hVC1CLQJ13hef4Y53CI
+rU7m2Ys6xt0nUW7/vGT1M0NPAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNV
+HRMBAf8EBTADAQH/MB0GA1UdDgQWBBR5tFnme7bl5AFzgAiIyBpY9umbbjANBgkq
+hkiG9w0BAQsFAAOCAgEAVR9YqbyyqFDQDLHYGmkgJykIrGF1XIpu+ILlaS/V9lZL
+ubhzEFnTIZd+50xx+7LSYK05qAvqFyFWhfFQDlnrzuBZ6brJFe+GnY+EgPbk6ZGQ
+3BebYhtF8GaV0nxvwuo77x/Py9auJ/GpsMiu/X1+mvoiBOv/2X/qkSsisRcOj/KK
+NFtY2PwByVS5uCbMiogziUwthDyC3+6WVwW6LLv3xLfHTjuCvjHIInNzktHCgKQ5
+ORAzI4JMPJ+GslWYHb4phowim57iaztXOoJwTdwJx4nLCgdNbOhdjsnvzqvHu7Ur
+TkXWStAmzOVyyghqpZXjFaH3pO3JLF+l+/+sKAIuvtd7u+Nxe5AW0wdeRlN8NwdC
+jNPElpzVmbUq4JUagEiuTDkHzsxHpFKVK7q4+63SM1N95R1NbdWhscdCb+ZAJzVc
+oyi3B43njTOQ5yOf+1CceWxG1bQVs5ZufpsMljq4Ui0/1lvh+wjChP4kqKOJ2qxq
+4RgqsahDYVvTH9w7jXbyLeiNdd8XM2w9U/t7y0Ff/9yi0GE44Za4rF2LN9d11TPA
+mRGunUHBcnWEvgJBQl9nJEiU0Zsnvgc/ubhPgXRR4Xq37Z0j4r7g1SgEEzwxA57d
+emyPxgcYxn/eR44/KJ4EBs+lVDR3veyJm+kXQ99b21/+jh5Xos1AnX5iItreGCc=
+-----END CERTIFICATE-----

app.py

@@ -0,0 +1,277 @@
+import os
+import uuid
+import gradio as gr
+from openai import OpenAI
+
+# Get API key from environment
+api_key = os.environ.get("NEBIUS_API_KEY")
+if not api_key:
+    print("Warning: NEBIUS_API_KEY environment variable not set. LLM features will be disabled.")
+    client = None
+else:
+    client = OpenAI(
+        base_url="https://api.studio.nebius.com/v1/",
+        api_key=api_key,
+    )
+
+# Import visualization tools and helper
+from tools.visualizer_linked_list import generate_linked_list_gif
+from tools.visualizer_sort import generate_bubble_sort_gif
+from tools.utility_helpers import ensure_output_dir
+from tools.code_analyzer import CodeAnalyzer
+
+ensure_output_dir()  # make sure ./output/ exists
+code_analyzer = CodeAnalyzer()
+
+PLACEHOLDER_IMG = os.path.join("output", "no_visualization.gif")
+
+def create_placeholder_gif():
+    # Create a simple placeholder GIF if it doesn't exist
+    if not os.path.exists(PLACEHOLDER_IMG):
+        from PIL import Image, ImageDraw
+        img = Image.new('RGB', (400, 100), color='white')
+        d = ImageDraw.Draw(img)
+        d.text((10, 40), "No visualization available", fill=(0, 0, 0))
+        img.save(PLACEHOLDER_IMG, format='GIF')
+
+create_placeholder_gif()
+
+def explain_algorithm_with_llm(code_snippet: str, code_info: dict = None):
+    """
+    Send a prompt to Nebius-hosted LLM (Meta-Llama-3.1-70B-Instruct).
+    Returns the model's explanation text.
+    """
+    if not client:
+        return "LLM features are disabled. Please set the NEBIUS_API_KEY environment variable to enable AI explanations."
+    
+    if code_info:
+        prompt = code_analyzer.get_explanation_prompt(code_info)
+        prompt += f"\n\nCode:\n{code_snippet}"
+    else:
+        prompt = f"Please explain this code step by step:\n\n{code_snippet}"
+    
+    response = client.chat.completions.create(
+        model="meta-llama/Meta-Llama-3.1-70B-Instruct",
+        messages=[{"role": "user", "content": prompt}],
+        temperature=0.6
+    )
+    return response.choices[0].message.content
+
+def extract_array_from_code(code: str):
+    import re
+    # Try to find Python list or comma-separated numbers
+    array_match = re.search(r'\[([\d\s,]+)\]', code)
+    if array_match:
+        try:
+            return [int(x.strip()) for x in array_match.group(1).split(',') if x.strip()]
+        except Exception:
+            pass
+    # Try to find comma-separated numbers in the code
+    csv_match = re.search(r'(\d+(?:\s*,\s*\d+)+)', code)
+    if csv_match:
+        try:
+            return [int(x.strip()) for x in csv_match.group(1).split(',') if x.strip()]
+        except Exception:
+            pass
+    return None
+
+def extract_linked_list_ops_from_code(code: str):
+    import re
+    operations = []
+    for line in code.split('\n'):
+        if 'insert' in line.lower():
+            num_match = re.search(r'insert\s+(\d+)', line.lower())
+            if num_match:
+                operations.append(f"insert {num_match.group(1)}")
+        elif 'delete' in line.lower():
+            operations.append("delete")
+    return operations if operations else None
+
+def generate_visualization(code_info: dict, code: str) -> str:
+    """
+    Generate appropriate visualization based on code analysis.
+    Returns the path to the generated GIF.
+    """
+    gif_name = f"{uuid.uuid4()}.gif"
+    output_path = os.path.join("output", gif_name)
+    
+    # Extract values for visualization from the code
+    try:
+        # For sorting algorithms, try to find array/list in the code
+        if any('sort' in algo for algo in code_info['patterns']['algorithms']):
+            values = extract_array_from_code(code)
+            if values:
+                generate_bubble_sort_gif(values, output_path)
+                return output_path
+        
+        # For linked list operations
+        if any('linked_list' in ds for ds in code_info['patterns']['data_structures']):
+            operations = extract_linked_list_ops_from_code(code)
+            if operations:
+                generate_linked_list_gif(operations, output_path)
+                return output_path
+    except Exception as e:
+        print(f"Error generating visualization: {e}")
+    
+    return PLACEHOLDER_IMG
+
+def process_code(code_snippet: str):
+    """
+    Process the input code:
+    1. Analyze the code
+    2. Generate visualization
+    3. Get LLM explanation
+    """
+    # Analyze the code
+    code_info = code_analyzer.analyze_code(code_snippet)
+    debug_log = []
+    if code_info.get('type') == 'error':
+        return f"❌ Code analysis failed: {code_info.get('error')}", PLACEHOLDER_IMG
+    
+    # Generate visualization
+    visualization_path = generate_visualization(code_info, code_snippet)
+    no_visual = (visualization_path == PLACEHOLDER_IMG)
+    
+    # Get LLM explanation
+    explanation = explain_algorithm_with_llm(code_snippet, code_info)
+    
+    # Create a beautiful markdown output
+    markdown_output = f"""
+# 📊 Code Analysis Report
+
+## 🎯 Code Type & Name
+- **Type:** {code_info['type'].title()}
+{f"- **Name:** `{code_info['name']}`" if code_info['name'] else ""}
+- **Complexity:** `{code_info['complexity']}`
+
+## 🔍 Detected Patterns
+"""
+    
+    if code_info['patterns']['algorithms']:
+        markdown_output += "\n### 🧮 Algorithms\n"
+        for algo in code_info['patterns']['algorithms']:
+            markdown_output += f"- {algo.replace(':', ': ').title()}\n"
+    
+    if code_info['patterns']['data_structures']:
+        markdown_output += "\n### 📚 Data Structures\n"
+        for ds in code_info['patterns']['data_structures']:
+            markdown_output += f"- {ds.replace(':', ': ').title()}\n"
+    
+    markdown_output += "\n## 📝 Code Structure\n"
+    structure = code_info['structure']
+    markdown_output += f"- {'✅' if structure['has_recursion'] else '❌'} Recursion\n"
+    markdown_output += f"- {'✅' if structure['has_classes'] else '❌'} Classes\n"
+    markdown_output += f"- {'✅' if structure['has_functions'] else '❌'} Functions\n"
+    markdown_output += f"- {'✅' if structure['has_loops'] else '❌'} Loops\n"
+    
+    if no_visual:
+        markdown_output += """
+## ⚠️ Visualization Note
+No visualization could be generated for this code.
+
+**Supported Visualizations:**
+- Bubble Sort (with array)
+- Linked List (with 'insert N'/'delete' lines)
+"""
+    
+    markdown_output += "\n## 📖 Explanation\n"
+    markdown_output += explanation
+    
+    return markdown_output, visualization_path
+
+# Custom CSS
+css = """
+.code-input {
+    font-family: 'Consolas', 'Monaco', monospace !important;
+    font-size: 14px !important;
+}
+.explanation-output {
+    font-size: 14px !important;
+    line-height: 1.6 !important;
+}
+.visualization-output {
+    border-radius: 8px !important;
+    box-shadow: 0 2px 4px rgba(0,0,0,0.1) !important;
+}
+"""
+
+# Gradio UI
+with gr.Blocks(theme=gr.themes.Soft(), css=css) as demo:
+    gr.Markdown("""
+    # 🧠 CodeViz: Visual Learning of Algorithms
+    
+    Enter your code below to get:
+    1. A detailed explanation of how it works
+    2. A visualization of the algorithm/data structure
+    3. Analysis of its complexity and patterns
+    
+    Examples:
+    ```python
+    # Bubble Sort
+    def bubble_sort(arr):
+        n = len(arr)
+        for i in range(n):
+            for j in range(0, n-i-1):
+                if arr[j] > arr[j+1]:
+                    arr[j], arr[j+1] = arr[j+1], arr[j]
+        return arr
+    
+    # Test with array
+    arr = [64, 34, 25, 12, 22, 11, 90]
+    ```
+    
+    ```python
+    # Linked List Insert
+    class Node:
+        def __init__(self, data):
+            self.data = data
+            self.next = None
+    
+    def insert_at_end(head, data):
+        new_node = Node(data)
+        if head is None:
+            return new_node
+        current = head
+        while current.next:
+            current = current.next
+        current.next = new_node
+        return head
+    ```
+    """)
+
+    with gr.Row():
+        with gr.Column(scale=1):
+            code_input = gr.Textbox(
+                label="Enter your code", 
+                lines=10, 
+                placeholder="Paste your code here...",
+                elem_classes=["code-input"],
+                type="text"
+            )
+            run_btn = gr.Button("Visualize & Explain", variant="primary")
+        
+        with gr.Column(scale=1):
+            explanation_output = gr.Markdown(
+                label="Explanation & Analysis",
+                elem_classes=["explanation-output"]
+            )
+            visualization_output = gr.Image(
+                label="Visualization",
+                type="filepath",
+                elem_classes=["visualization-output"]
+            )
+
+    run_btn.click(
+        fn=process_code,
+        inputs=[code_input],
+        outputs=[explanation_output, visualization_output],
+        api_name="process_code"
+    )
+
+if __name__ == "__main__":
+    demo.queue().launch(
+        server_name="0.0.0.0", 
+        server_port=7860,
+        share=True,  # Enable sharing for easier access
+        show_error=True  # Show detailed error messages
+    )

environment.yml

@@ -0,0 +1,21 @@
+name: codeviz3
+channels:
+  - conda-forge
+  - defaults
+dependencies:
+  - python=3.10
+  - pip
+  - pip:
+    - gradio>=4.19.2
+    - openai
+    - pillow
+    - matplotlib
+    - networkx
+    - imageio
+    - uvicorn
+    - fastapi
+    - pydantic
+    - astroid
+    - tree-sitter
+    - tree-sitter-python
+    - jedi 

requirements.txt

@@ -0,0 +1,8 @@
+gradio>=4.19.2
+mcp
+openai
+pillow
+matplotlib
+networkx
+imageio
+uvicorn

tools/code_analyzer.py

@@ -0,0 +1,151 @@
+import ast
+import astroid
+from typing import Dict, List, Tuple, Optional
+import re
+
+class CodeAnalyzer:
+    def __init__(self):
+        self.algorithm_patterns = {
+            'sort': ['bubble', 'quick', 'merge', 'insertion', 'selection'],
+            'search': ['binary', 'linear', 'depth', 'breadth'],
+            'graph': ['dijkstra', 'floyd', 'bellman', 'kruskal', 'prim'],
+            'tree': ['binary', 'avl', 'red-black', 'b-tree'],
+            'dynamic': ['knapsack', 'longest', 'shortest', 'matrix']
+        }
+        
+        self.data_structure_patterns = {
+            'linked_list': ['node', 'next', 'prev', 'head', 'tail'],
+            'tree': ['node', 'left', 'right', 'root', 'leaf'],
+            'graph': ['vertex', 'edge', 'adjacent', 'neighbor'],
+            'stack': ['push', 'pop', 'peek', 'top'],
+            'queue': ['enqueue', 'dequeue', 'front', 'rear'],
+            'heap': ['heapify', 'sift', 'priority']
+        }
+
+    def analyze_code(self, code: str) -> Dict:
+        """
+        Analyze the given code and return information about its type and structure.
+        """
+        try:
+            # Parse the code using ast
+            tree = ast.parse(code)
+            
+            # Get basic code information
+            info = {
+                'type': 'unknown',
+                'name': self._get_function_name(tree),
+                'complexity': self._analyze_complexity(tree),
+                'patterns': self._find_patterns(code),
+                'structure': self._analyze_structure(tree)
+            }
+            
+            # Determine the type of code
+            info['type'] = self._determine_code_type(info['patterns'])
+            
+            return info
+        except Exception as e:
+            return {
+                'type': 'error',
+                'error': str(e)
+            }
+
+    def _get_function_name(self, tree: ast.AST) -> Optional[str]:
+        """Extract the main function name from the code."""
+        for node in ast.walk(tree):
+            if isinstance(node, ast.FunctionDef):
+                return node.name
+        return None
+
+    def _analyze_complexity(self, tree: ast.AST) -> str:
+        """Analyze the time complexity of the code."""
+        # This is a simplified version - in practice, you'd want more sophisticated analysis
+        loops = 0
+        for node in ast.walk(tree):
+            if isinstance(node, (ast.For, ast.While)):
+                loops += 1
+        
+        if loops > 2:
+            return "O(n³) or worse"
+        elif loops == 2:
+            return "O(n²)"
+        elif loops == 1:
+            return "O(n)"
+        else:
+            return "O(1)"
+
+    def _find_patterns(self, code: str) -> Dict[str, List[str]]:
+        """Find patterns in the code that indicate its type."""
+        patterns = {
+            'algorithms': [],
+            'data_structures': []
+        }
+        
+        # Check for algorithm patterns
+        for category, keywords in self.algorithm_patterns.items():
+            for keyword in keywords:
+                if keyword.lower() in code.lower():
+                    patterns['algorithms'].append(f"{category}:{keyword}")
+        
+        # Check for data structure patterns
+        for structure, keywords in self.data_structure_patterns.items():
+            for keyword in keywords:
+                if keyword.lower() in code.lower():
+                    patterns['data_structures'].append(f"{structure}:{keyword}")
+        
+        return patterns
+
+    def _analyze_structure(self, tree: ast.AST) -> Dict:
+        """Analyze the code structure and return relevant information."""
+        structure = {
+            'has_recursion': False,
+            'has_classes': False,
+            'has_functions': False,
+            'has_loops': False
+        }
+        
+        for node in ast.walk(tree):
+            if isinstance(node, ast.ClassDef):
+                structure['has_classes'] = True
+            elif isinstance(node, ast.FunctionDef):
+                structure['has_functions'] = True
+                # Check for recursion: if the function calls itself
+                for child in ast.walk(node):
+                    if isinstance(child, ast.Call) and isinstance(child.func, ast.Name):
+                        if child.func.id == node.name:
+                            structure['has_recursion'] = True
+            elif isinstance(node, (ast.For, ast.While)):
+                structure['has_loops'] = True
+        
+        return structure
+
+    def _determine_code_type(self, patterns: Dict) -> str:
+        """Determine the type of code based on found patterns."""
+        if patterns['algorithms']:
+            return 'algorithm'
+        elif patterns['data_structures']:
+            return 'data_structure'
+        else:
+            return 'general'
+
+    def get_explanation_prompt(self, code_info: Dict) -> str:
+        """Generate a prompt for the LLM based on the code analysis."""
+        prompt = f"This code appears to be a {code_info['type']} "
+        
+        if code_info['name']:
+            prompt += f"named '{code_info['name']}' "
+        
+        prompt += f"with {code_info['complexity']} time complexity.\n\n"
+        
+        if code_info['patterns']['algorithms']:
+            prompt += "It implements the following algorithms: " + ", ".join(code_info['patterns']['algorithms']) + ".\n"
+        
+        if code_info['patterns']['data_structures']:
+            prompt += "It uses the following data structures: " + ", ".join(code_info['patterns']['data_structures']) + ".\n"
+        
+        prompt += "\nPlease explain how this code works step by step, focusing on:\n"
+        prompt += "1. The main purpose and functionality\n"
+        prompt += "2. The key components and how they work together\n"
+        prompt += "3. The time and space complexity\n"
+        prompt += "4. Any important edge cases or considerations\n"
+        
+        return prompt 

tools/utility_helpers.py

@@ -0,0 +1,8 @@
+import os
+
+def ensure_output_dir():
+    """
+    Make sure the './output' directory exists.
+    """
+    if not os.path.exists("output"):
+        os.makedirs("output")

tools/visualizer_linked_list.py

@@ -0,0 +1,50 @@
+import base64
+from io import BytesIO
+from PIL import Image, ImageDraw, ImageFont
+
+def draw_linked_list_frame(nodes):
+    """
+    Given a list of node values (strings), return a PIL Image representing the current state.
+    """
+    width = max(600, len(nodes) * 120)
+    img = Image.new('RGB', (width, 100), color='white')
+    draw = ImageDraw.Draw(img)
+    font = ImageFont.load_default()
+
+    for i, val in enumerate(nodes):
+        x0 = i * 100 + 10
+        # Draw node rectangle
+        draw.rectangle([x0, 30, x0 + 80, 70], outline='black', width=2)
+        draw.text((x0 + 25, 40), val, fill='black', font=font)
+        # Draw arrow to next node if exists
+        if i < len(nodes) - 1:
+            draw.line((x0 + 80, 50, x0 + 100, 50), fill='black', width=2)
+    return img
+
+def generate_linked_list_gif(operations, output_path):
+    """
+    Given a list of operations like ["insert 5", "insert 10", "delete"], build a sequence of frames,
+    then save as an animated GIF to output_path.
+    """
+    frames = []
+    nodes = []
+    for op in operations:
+        parts = op.split()
+        if len(parts) >= 2 and parts[0] == "insert":
+            nodes.append(parts[1])
+        elif parts[0] == "delete":
+            if nodes:
+                nodes.pop(0)  # delete head
+        # Draw current state
+        img = draw_linked_list_frame(nodes)
+        frames.append(img)
+
+    # Save frames as GIF
+    frames[0].save(
+        output_path,
+        save_all=True,
+        append_images=frames[1:],
+        duration=800,
+        loop=0
+    )
+    return output_path

tools/visualizer_sort.py

@@ -0,0 +1,65 @@
+import matplotlib.pyplot as plt
+from io import BytesIO
+import imageio
+import numpy as np
+
+def generate_bubble_sort_gif(values, output_path):
+    """
+    Given a list of integer values (e.g. [5,3,8,1]), produce an animated GIF showing
+    each comparison + swap step in bubble sort. Save the GIF to output_path.
+    """
+    if not values:
+        # Create a single frame with empty array if no values provided
+        fig, ax = plt.subplots()
+        ax.bar([], [], color="skyblue")
+        ax.set_title("Bubble Sort: No values provided")
+        buf = BytesIO()
+        plt.savefig(buf, format='png')
+        plt.close(fig)
+        buf.seek(0)
+        imageio.mimsave(output_path, [imageio.imread(buf)], format='GIF', fps=1)
+        return output_path
+
+    images = []
+    arr = values.copy()
+    n = len(arr)
+    
+    # Always add initial state
+    fig, ax = plt.subplots()
+    ax.bar(range(len(arr)), arr, color="skyblue")
+    ax.set_title("Bubble Sort: Initial State")
+    buf = BytesIO()
+    plt.savefig(buf, format='png')
+    plt.close(fig)
+    buf.seek(0)
+    images.append(imageio.imread(buf))
+
+    # Perform bubble sort and capture each step
+    for i in range(n):
+        for j in range(0, n - i - 1):
+            if arr[j] > arr[j + 1]:
+                arr[j], arr[j + 1] = arr[j + 1], arr[j]
+            # Plot current array state as a bar chart
+            fig, ax = plt.subplots()
+            ax.bar(range(len(arr)), arr, color="skyblue")
+            ax.set_title(f"Bubble Sort: pass {i}, compare {j}")
+            buf = BytesIO()
+            plt.savefig(buf, format='png')
+            plt.close(fig)
+            buf.seek(0)
+            images.append(imageio.imread(buf))
+
+    # Add final state if no swaps were made
+    if len(images) == 1:
+        fig, ax = plt.subplots()
+        ax.bar(range(len(arr)), arr, color="skyblue")
+        ax.set_title("Bubble Sort: Final State")
+        buf = BytesIO()
+        plt.savefig(buf, format='png')
+        plt.close(fig)
+        buf.seek(0)
+        images.append(imageio.imread(buf))
+
+    # Save as GIF
+    imageio.mimsave(output_path, images, format='GIF', fps=1)
+    return output_path