Update app.py

app.py

@@ -5,6 +5,7 @@ from dotenv import load_dotenv
 import nltk
 from nltk.tokenize import sent_tokenize
 import pandas as pd
+import ast
 
 # Initialize NLTK
 nltk.download('punkt', quiet=True)
@@ -15,20 +16,61 @@ BLACKBOX_API_KEY = os.getenv("BLACKBOX_API_KEY")
 if not BLACKBOX_API_KEY:
     BLACKBOX_API_KEY = os.environ.get('BLACKBOX_API_KEY')
 
+class CodeAnalyzer(ast.NodeVisitor):
+    def __init__(self):
+        self.func_count = 0
+        self.loop_count = 0
+        self.cond_count = 0
+        self.max_depth = 0
+        self.current_depth = 0
+
+    def visit_FunctionDef(self, node):
+        self.func_count += 1
+        self.generic_visit(node)
+
+    def visit_For(self, node):
+        self.loop_count += 1
+        self._enter_block(node)
+
+    def visit_While(self, node):
+        self.loop_count += 1
+        self._enter_block(node)
+
+    def visit_If(self, node):
+        self.cond_count += 1
+        self._enter_block(node)
+
+    def _enter_block(self, node):
+        self.current_depth += 1
+        self.max_depth = max(self.max_depth, self.current_depth)
+        self.generic_visit(node)
+        self.current_depth -= 1
+
+    def analyze(self, code_str):
+        try:
+            tree = ast.parse(code_str)
+            self.visit(tree)
+        except SyntaxError:
+            pass
+        return {
+            'function_def': self.func_count,
+            'loop': self.loop_count,
+            'conditional': self.cond_count,
+            'max_depth': self.max_depth
+        }
+
 class CodeCopilot:
     def __init__(self):
         self.chat_history = []
         self.context_window = 3
-        
+
     def get_blackbox_response(self, prompt, max_tokens=300, temperature=0.7):
-        """Get response using Blackbox's API"""
         headers = {
             "Content-Type": "application/json",
             "Authorization": f"Bearer {BLACKBOX_API_KEY}"
         }
-        
         try:
-            response = requests.post(
+            resp = requests.post(
                 "https://api.blackbox.ai/chat/completions",
                 headers=headers,
                 json={
@@ -39,131 +81,83 @@ class CodeCopilot:
                 },
                 timeout=30
             )
-            response.raise_for_status()
-            return response.json()["choices"][0]["message"]["content"]
-        except requests.exceptions.RequestException as e:
-            return f"API Error: {str(e)}"
+            resp.raise_for_status()
+            return resp.json()["choices"][0]["message"]["content"]
         except Exception as e:
-            return f"Processing Error: {str(e)}"
-    
-    def analyze_code_patterns(self, text):
-        """Analyze text for coding patterns"""
-        sentences = sent_tokenize(text)
-        patterns = {
-            'function_def': sum(1 for s in sentences if 'def ' in s),
-            'class_def': sum(1 for s in sentences if 'class ' in s),
-            'loop': sum(1 for s in sentences if any(word in s for word in ['for ', 'while ', 'loop'])),
-            'conditional': sum(1 for s in sentences if any(word in s for word in ['if ', 'else ', 'elif ']))
-        }
-        return patterns
-    
-    def generate_suggestions(self, text, patterns):
-        """Generate suggestions based on detected patterns and actual code"""
+            return f"API Error: {e}"
+
+    def generate_suggestions(self, analysis):
         suggestions = []
+        # Functions
+        if analysis['function_def'] == 0:
+            suggestions.append("🚀 Consider defining functions to organize your code and improve reuse.")
+        elif analysis['function_def'] > 3:
+            suggestions.append(f"🔍 Detected {analysis['function_def']} functions – consider grouping related functions into classes or modules.")
 
-        if patterns['function_def'] > 3:
-            suggestions.append("🔍 Your code has many functions. Consider breaking down responsibilities or using classes to organize them.")
+        # Loops
+        if analysis['loop'] >= 1:
+            suggestions.append(f"🔄 {analysis['loop']} loop(s) found – check if list comprehensions or vectorized operations can simplify them.")
 
-        if patterns['loop'] > 2:
-            if 'range' in text:
-                suggestions.append("🔁 Detected multiple loops using `range`. You can optimize using Python's `enumerate()` or list comprehensions.")
-            else:
-                suggestions.append("🔄 You might benefit from list comprehensions or using `map`/`filter` functions.")
+        # Conditionals
+        if analysis['conditional'] >= 2:
+            suggestions.append(f"⚖ {analysis['conditional']} conditional statements – consider simplifying nested logic or using lookup tables.")
 
-        if patterns['conditional'] > 3:
-            if 'elif' in text:
-                suggestions.append("⚖ Your code has multiple conditional branches. Consider using a dictionary-based dispatch or polymorphism.")
-            else:
-                suggestions.append("🧠 Simplify conditionals with clearer boolean logic or helper functions.")
+        # Nesting depth
+        if analysis['max_depth'] > 2:
+            suggestions.append(f"📦 Maximum nesting depth of {analysis['max_depth']} detected – flatten nested blocks for readability.")
 
+        # Default
         if not suggestions:
-            suggestions.append("✅ Your code looks clean! No major structural improvements detected.")
-
+            suggestions.append("✅ Code structure looks clean based on basic analysis.")
         return "\n".join(suggestions)
 
     def process_input(self, user_input):
-        """Process user input and generate response"""
-        patterns = self.analyze_code_patterns(user_input)
-        
+        # AST analysis
+        analyzer = CodeAnalyzer()
+        analysis = analyzer.analyze(user_input)
+        # Build context prompt
         context = "\nPrevious conversation:\n" + "\n".join(
-            [f"User: {h[0]}\nAI: {h[1]}" for h in self.chat_history[-self.context_window:]])
-        
-        prompt = f"""You are an expert coding assistant. Analyze this code and provide helpful suggestions:
-        
-        {context}
-        
-        New input:
-        {user_input}
-        """
-        
-        response = self.get_blackbox_response(prompt)
-        suggestions = self.generate_suggestions(user_input, patterns)
-        
-        self.chat_history.append((user_input, response))
-        
-        return response, patterns, suggestions
+            [f"User: {h[0]}\nAI: {h[1]}" for h in self.chat_history[-self.context_window:]]
+        )
+        prompt = f"You are an expert coding assistant. Analyze this code and provide improvements.\n{context}\nNew input:\n{user_input}"
+        # AI response
+        ai_resp = self.get_blackbox_response(prompt)
+        # Suggestions
+        sugg = self.generate_suggestions(analysis)
+        self.chat_history.append((user_input, ai_resp))
+        return ai_resp, analysis, sugg
 
 # Initialize copilot
 copilot = CodeCopilot()
 
-# Gradio interface
+# Build Gradio UI
 with gr.Blocks(theme=gr.themes.Soft(), title="🤖 AI Code Copilot") as demo:
-    # Header
-    gr.Markdown(
-        """
-        <div style='text-align: center; margin-bottom: 1rem;'>
-            <h1>🤖 AI Code Copilot</h1>
-            <p>Your interactive assistant for code suggestions and analysis</p>
-        </div>
-        """
+    gr.Markdown("""
+    <div style='text-align: center; margin-bottom: 1rem;'>
+      <h1>🤖 AI Code Copilot</h1>
+      <p>Paste code or ask a question below to get instant analysis.</p>
+    </div>
+    """
     )
-
-    # Main layout: input on the left, outputs on the right
     with gr.Row():
         with gr.Column(scale=3, min_width=300):
-            input_text = gr.Textbox(
-                label="Enter your code or question",
-                placeholder="Paste code snippets or ask a coding question...",
-                lines=10,
-                interactive=True
-            )
-            submit_btn = gr.Button("🚀 Generate", variant="primary")
-        
-        with gr.Column(scale=5, min_width=500):
-            # Display response
-            gr.Markdown("**Assistant Response:**")
-            output_text = gr.Markdown()
-            # Display suggestions
-            gr.Markdown("**Suggestions:**")
-            suggestions_output = gr.Markdown()
-            # Display pattern analysis
-            gr.Markdown("**Pattern Analysis:**")
-            pattern_display = gr.Dataframe(
-                headers=["Pattern", "Count"],
-                datatype=["str", "number"],
-                interactive=False,
-                label="Detected code patterns"
-            )
+            inp = gr.Textbox(label="Your Code / Question", lines=10, placeholder="Enter code here...")
+            btn = gr.Button("🚀 Generate")
+        with gr.Column(scale=6, min_width=500):
+            gr.Markdown("**Assistant Response**")
+            out = gr.Markdown()
+            gr.Markdown("**Pattern Analysis**")
+            df = gr.Dataframe(headers=["Metric","Count"], datatype=["str","number"], interactive=False)
+            gr.Markdown("**Suggestions**")
+            sug = gr.Markdown()
 
-    # Processing function for both button and enter
-    def process_input_wrapper(user_input):
-        response, patterns, sugg = copilot.process_input(user_input)
-        pattern_df = pd.DataFrame({
-            "Pattern": list(patterns.keys()),
-            "Count": list(patterns.values())
-        })
-        return response, sugg, pattern_df
-    
-    submit_btn.click(
-        fn=process_input_wrapper,
-        inputs=input_text,
-        outputs=[output_text, suggestions_output, pattern_display]
-    )
-    input_text.submit(
-        fn=process_input_wrapper,
-        inputs=input_text,
-        outputs=[output_text, suggestions_output, pattern_display]
-    )
+    def run_all(text):
+        ai_text, analysis, suggestions = copilot.process_input(text)
+        df_data = {"Metric": list(analysis.keys()), "Count": list(analysis.values())}
+        return ai_text, pd.DataFrame(df_data), suggestions
+
+    btn.click(fn=run_all, inputs=inp, outputs=[out, df, sug])
+    inp.submit(fn=run_all, inputs=inp, outputs=[out, df, sug])
 
 if __name__ == "__main__":
     demo.launch()