Blame for app.py

import ast
import gradio as gr
from PIL import Image
import io
import networkx as nx
import matplotlib.pyplot as plt
import copy
import google.generativeai as genai
import os
from dotenv import load_dotenv
import speech_recognition as sr
import numpy as np
import wave
import tempfile

load_dotenv()
# Configure Gemini API
genai.configure(api_key=os.getenv('GEMINI_API_KEY'))
model = genai.GenerativeModel('gemini-1.5-flash')

def generate_code(prompt: str):
    try:
        response = model.generate_content(
            f"Write Python code for this requirement: {prompt}. "
            "Only return the code without any explanation."
        )
        generated_code = response.text.strip()
        # Try parsing the generated code to verify it's valid Python
        
        generated_code = generated_code[9:-3]

        ast.parse(generated_code) #temporarily 
        return "Code generated successfully!", generated_code
    except Exception as e:
        return f"Error: {str(e)}", ""

def transcribe_audio(audio):
    if audio is None:
        return "Error: No audio provided", ""
        
    recognizer = sr.Recognizer()
    try:
        # Handle different audio input formats
        if isinstance(audio, str):
            # Direct file path
            with sr.AudioFile(audio) as source:
                audio_data = recognizer.record(source)
        else:
            # Convert numpy array to WAV file
            sample_rate, y = audio
            with tempfile.NamedTemporaryFile(suffix='.wav', delete=False) as temp_audio:
                with wave.open(temp_audio.name, 'wb') as wf:
                    wf.setnchannels(1)
                    wf.setsampwidth(2)
                    wf.setframerate(sample_rate)
                    wf.writeframes((y * 32767).astype(np.int16).tobytes())
                
                with sr.AudioFile(temp_audio.name) as source:
                    audio_data = recognizer.record(source)
                    
        text = recognizer.recognize_google(audio_data)
        return "Transcription successful!", text
    except Exception as e:
        return f"Error in transcription: {str(e)}", ""

def process_voice_to_code(audio_path):
    status, transcribed_text = transcribe_audio(audio_path)
    if "Error" in status:
        return status, ""
    return generate_code(transcribed_text)

# Step 1: Convert AST to NetworkX
def visualize_ast(code: str):
    try:
        tree = ast.parse(code)
    except SyntaxError as e:
        return f"Syntax Error: {e}", None

    G = nx.DiGraph()
    
    def get_node_label(node):
        if isinstance(node, ast.Name):
            return f"{type(node).__name__}\nid: {node.id}"
        elif isinstance(node, ast.Constant):
            return f"{type(node).__name__}\nvalue: {node.value}"
        elif isinstance(node, ast.FunctionDef):
            return f"{type(node).__name__}\nname: {node.name}"
        elif isinstance(node, ast.ClassDef):
            return f"{type(node).__name__}\nname: {node.name}"
        elif isinstance(node, ast.Call):
            return f"{type(node).__name__}"
        else:
            return type(node).__name__

    def add_nodes_edges(node, parent_id=None, edge_label=""):
        node_id = id(node)
        G.add_node(node_id, label=get_node_label(node))
        if parent_id is not None:
            G.add_edge(parent_id, node_id, label=edge_label)
        
        for field, value in ast.iter_fields(node):
            if isinstance(value, ast.AST):
                add_nodes_edges(value, node_id, field)
            elif isinstance(value, list):
                for item in value:
                    if isinstance(item, ast.AST):
                        add_nodes_edges(item, node_id, field)
    
    add_nodes_edges(tree)
    
    plt.figure(figsize=(15, 10))
    pos = nx.kamada_kawai_layout(G)  # Better layout for hierarchical structures
    
    # Draw edges with labels
    nx.draw_networkx_edges(G, pos, edge_color='gray', arrows=True, arrowsize=20)
    edge_labels = nx.get_edge_attributes(G, 'label')
    nx.draw_networkx_edge_labels(G, pos, edge_labels, font_size=8)
    
    # Draw nodes with custom style
    nx.draw_networkx_nodes(G, pos, node_color='lightblue', 
                          node_size=2500, alpha=0.9)
    
    # Add node labels with better formatting
    labels = nx.get_node_attributes(G, 'label')
    nx.draw_networkx_labels(G, pos, labels, font_size=8)
    
    plt.title("Abstract Syntax Tree Visualization")
    
    # Save to buffer with higher DPI for better quality
    buf = io.BytesIO()
    plt.savefig(buf, format='png', bbox_inches='tight', dpi=200)
    plt.close()
    buf.seek(0)
    image = Image.open(buf)
    
    return "AST Generated Successfully", image

# Step 2: Data Flow Analysis
def analyze_dataflow(code: str):
    try:
        tree = ast.parse(code)
    except SyntaxError as e:
        return f"Syntax Error: {e}", None
    
    
    DFG = nx.DiGraph()
    variables = {}  # Track variable definitions and uses
    
    class DataFlowVisitor(ast.NodeVisitor):
        def visit_Assign(self, node):
            for target in node.targets:
                if isinstance(target, ast.Name):
                    var_name = target.id
                    def_id = f"def_{var_name}_{id(node)}"
                    DFG.add_node(def_id, label=f"Define\n{var_name}", type="def")
                    variables[var_name] = variables.get(var_name, []) + [def_id]
            self.generic_visit(node)
            
        def visit_Name(self, node):
            if isinstance(node.ctx, ast.Load):
                var_name = node.id
                use_id = f"use_{var_name}_{id(node)}"
                DFG.add_node(use_id, label=f"Use\n{var_name}", type="use")
                # Add edges from all previous definitions
                if var_name in variables:
                    for def_id in variables[var_name]:
                        DFG.add_edge(def_id, use_id)
    
    DataFlowVisitor().visit(tree)
    
    if not DFG.nodes():
        return "No data flow to analyze", None
    
    plt.figure(figsize=(15, 10))
    pos = nx.spring_layout(DFG, k=2)  # More spread out layout
    
    # Draw nodes with different colors for def/use
    def_nodes = [n for n, d in DFG.nodes(data=True) if d.get('type') == 'def']
    use_nodes = [n for n, d in DFG.nodes(data=True) if d.get('type') == 'use']
    
    nx.draw_networkx_nodes(DFG, pos, nodelist=def_nodes, node_color='lightgreen', 
                          node_size=3000, alpha=0.9)
    nx.draw_networkx_nodes(DFG, pos, nodelist=use_nodes, node_color='lightblue',
                          node_size=3000, alpha=0.9)
    
    # Draw edges and labels
    nx.draw_networkx_edges(DFG, pos, edge_color='gray', arrows=True, arrowsize=20)
    labels = nx.get_node_attributes(DFG, 'label')
    nx.draw_networkx_labels(DFG, pos, labels, font_size=10)
    
    plt.title("Data Flow Graph")
    
    buf = io.BytesIO()
    plt.savefig(buf, format='png', bbox_inches='tight', dpi=200)
    plt.close()
    buf.seek(0)
    image = Image.open(buf)
    
    return "Data Flow Analysis Complete", image

# Step 3: Optimization Analysis
def analyze_optimizations(code: str):
    try:
        tree = ast.parse(code)
    except SyntaxError as e:
        return f"Syntax Error: {e}", None
    
    CFG = nx.DiGraph()
    constants = {}
    dead_code = set()
    
    class OptimizationVisitor(ast.NodeVisitor):
        def __init__(self):
            self.current_block = 0
            self.last_block = 0
        
        def new_block(self):
            self.last_block = self.current_block
            self.current_block += 1
            return self.current_block
        
        def visit_Assign(self, node):
            if isinstance(node.value, ast.Constant):
                constants[id(node)] = node.value.value
            
            block_id = f"B{self.current_block}"
            label = ast.unparse(node)
            CFG.add_node(block_id, label=label, type='assign')
            
            if self.last_block >= 0:
                CFG.add_edge(f"B{self.last_block}", block_id)
            
            # Mark as dead code if value is never used
            if isinstance(node.targets[0], ast.Name):
                var_name = node.targets[0].id
                if not any(isinstance(n, ast.Name) and n.id == var_name 
                          for n in ast.walk(tree) if isinstance(n, ast.Name) 
                          and isinstance(n.ctx, ast.Load)):
                    dead_code.add(block_id)
            
            self.generic_visit(node)
    
    OptimizationVisitor().visit(tree)
    
    plt.figure(figsize=(15, 10))
    pos = nx.spring_layout(CFG, k=2)
    
    # Draw nodes with different colors based on optimization opportunities
    regular_nodes = [n for n in CFG.nodes() if n not in dead_code]
    dead_nodes = list(dead_code)
    
    # Draw regular nodes
    nx.draw_networkx_nodes(CFG, pos, nodelist=regular_nodes, 
                          node_color='lightblue', node_size=3000)
    # Draw dead code nodes
    nx.draw_networkx_nodes(CFG, pos, nodelist=dead_nodes,
                          node_color='salmon', node_size=3000)
    
    # Draw edges and labels
    nx.draw_networkx_edges(CFG, pos, edge_color='gray', arrows=True, arrowsize=20)
    labels = nx.get_node_attributes(CFG, 'label')
    nx.draw_networkx_labels(CFG, pos, labels, font_size=10)
    
    # Add legend
    plt.plot([], [], 'o', color='salmon', label='Dead Code')
    plt.plot([], [], 'o', color='lightblue', label='Active Code')
    plt.legend()
    
    plt.title("Control Flow Graph with Optimization Opportunities")
    
    buf = io.BytesIO()
    plt.savefig(buf, format='png', bbox_inches='tight', dpi=200)
    plt.close()
    buf.seek(0)
    image = Image.open(buf)
    
    # Prepare optimization summary
    summary = []
    if dead_code:
        summary.append(f"Found {len(dead_code)} dead code block(s)")
    if constants:
        summary.append(f"Found {len(constants)} constant propagation opportunities")
    
    return "\n".join(summary) if summary else "No optimization opportunities found", image

# Step 4: Gradio Interface
with gr.Blocks() as demo:
    gr.Markdown("## 🧠 Python Code Analysis Visualizer")
    
    with gr.Tabs():
        with gr.TabItem("AST Visualization"):
            with gr.Row():
                ast_code_input = gr.Code(label="Enter Python Code", language="python")
                ast_output = gr.Image(label="AST Visualization")
            ast_status = gr.Textbox(label="Status")
            ast_btn = gr.Button("Visualize AST")
            
        with gr.TabItem("Data Flow Analysis"):
            with gr.Row():
                dfg_code_input = gr.Code(label="Enter Python Code", language="python")
                dfg_output = gr.Image(label="Data Flow Graph")
            dfg_status = gr.Textbox(label="Status")
            dfg_btn = gr.Button("Analyze Data Flow")
        
        with gr.TabItem("Optimization Analysis"):
            with gr.Row():
                opt_code_input = gr.Code(label="Enter Python Code", language="python")
                opt_output = gr.Image(label="Optimization Visualization")
            opt_status = gr.Textbox(label="Optimization Opportunities")
            opt_btn = gr.Button("Analyze Optimizations")
        
        with gr.TabItem("Natural Language to Code"):
            with gr.Row():
                with gr.Column():
                    prompt_input = gr.Textbox(
                        label="Enter your requirement in natural language",
                        placeholder="e.g., write a function to calculate fibonacci series"
                    )
                    audio_input = gr.Audio(
                        sources=["microphone"],
                        type="numpy",
                        label="Or speak your requirement"
                    )
                with gr.Column():
                    code_output = gr.Code(
                        label="Generated Code",
                        language="python"
                    )
            gen_status = gr.Textbox(label="Status")
            with gr.Row():
                generate_btn = gr.Button("Generate from Text")
                voice_btn = gr.Button("Generate from Voice")
    
    ast_btn.click(visualize_ast, inputs=ast_code_input, outputs=[ast_status, ast_output])
    dfg_btn.click(analyze_dataflow, inputs=dfg_code_input, outputs=[dfg_status, dfg_output])
    opt_btn.click(analyze_optimizations, inputs=opt_code_input, outputs=[opt_status, opt_output])
    generate_btn.click(
        generate_code,
        inputs=prompt_input,
        outputs=[gen_status, code_output]
    )
    voice_btn.click(
        process_voice_to_code,
        inputs=audio_input,
        outputs=[gen_status, code_output]
    )

demo.launch()