Update app.py

app.py

@@ -4,57 +4,57 @@ import requests
 from dotenv import load_dotenv
 import nltk
 from nltk.tokenize import sent_tokenize
-import numpy as np
 import pandas as pd
-from tqdm import tqdm
 
-# Initialize NLTK (download punkt if needed)
+# Initialize NLTK
 nltk.download('punkt', quiet=True)
 
 # Load environment variables
 load_dotenv()
 BLACKBOX_API_KEY = os.getenv("BLACKBOX_API_KEY")
+if not BLACKBOX_API_KEY:
+    BLACKBOX_API_KEY = os.environ.get('BLACKBOX_API_KEY')
 
 class CodeCopilot:
     def __init__(self):
         self.chat_history = []
-        self.context_window = 5
+        self.context_window = 3
         
     def get_blackbox_response(self, prompt, max_tokens=300, temperature=0.7):
-        """Get response from Blackbox AI API"""
+        """Get response using Blackbox's API"""
         headers = {
-            "Authorization": f"Bearer {BLACKBOX_API_KEY}",
-            "Content-Type": "application/json"
-        }
-        data = {
-            "prompt": prompt,
-            "max_tokens": max_tokens,
-            "temperature": temperature
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {BLACKBOX_API_KEY}"
         }
         
         try:
+            # Correct API endpoint based on Blackbox documentation
             response = requests.post(
-                "https://api.blackbox.ai/generate",
+                "https://developer.blackbox.ai/api/v1/chat/completions",
                 headers=headers,
-                json=data,
+                json={
+                    "messages": [{"role": "user", "content": prompt}],
+                    "max_tokens": max_tokens,
+                    "temperature": temperature,
+                    "model": "blackbox-code"
+                },
                 timeout=30
             )
             response.raise_for_status()
-            return response.json().get("text", "No response text found.")
+            return response.json()["choices"][0]["message"]["content"]
+        except requests.exceptions.RequestException as e:
+            return f"API Error: {str(e)}"
         except Exception as e:
-            return f"Error: {str(e)}"
+            return f"Processing Error: {str(e)}"
     
     def analyze_code_patterns(self, text):
         """Analyze text for coding patterns"""
         sentences = sent_tokenize(text)
-        # Simple pattern detection (can be expanded)
         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 ']))
+            '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
     
@@ -62,92 +62,86 @@ class CodeCopilot:
         """Generate suggestions based on detected patterns"""
         suggestions = []
         if patterns['function_def'] > 3:
-            suggestions.append("Consider breaking down into smaller functions or using a class structure.")
+            suggestions.append("🔍 Consider breaking down into smaller functions or using a class structure.")
         if patterns['loop'] > 2:
-            suggestions.append("You might benefit from using list comprehensions or map/filter functions.")
+            suggestions.append("🔄 You might benefit from list comprehensions or map/filter functions.")
         if patterns['conditional'] > 3:
-            suggestions.append("Complex conditionals might be simplified using polymorphism or strategy pattern.")
+            suggestions.append("⚖ Complex conditionals might be simplified using polymorphism or strategy pattern.")
         return "\n".join(suggestions) if suggestions else "No specific suggestions at this time."
     
-    def process_input(self, user_input, history=None):
+    def process_input(self, user_input):
         """Process user input and generate response"""
         # Analyze patterns
         patterns = self.analyze_code_patterns(user_input)
-        suggestions = self.generate_suggestions(patterns)
         
         # Create context-aware prompt
-        context = "\n".join([f"User: {h[0]}\nAI: {h[1]}" for h in self.chat_history[-self.context_window:]])
-        prompt = f"""
-        Context:
+        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}
         
-        User Input:
+        New input:
         {user_input}
-        
-        Respond as a helpful coding assistant that also provides suggestions for improvement.
-        Suggestions to consider:
-        {suggestions}
         """
         
-        # Get response from Blackbox AI
+        # Get response
         response = self.get_blackbox_response(prompt)
+        suggestions = self.generate_suggestions(patterns)
         
         # Update chat history
         self.chat_history.append((user_input, response))
         
-        # Format full response with suggestions
-        full_response = f"{response}\n\n=== Suggestions ===\n{suggestions}"
-        return full_response
+        return response, patterns, suggestions
 
 # Initialize copilot
 copilot = CodeCopilot()
 
 # Gradio interface
-with gr.Blocks(title="AI Code Copilot") as demo:
-    gr.Markdown("""
-    # AI Code Copilot
-    Your intelligent assistant for coding tasks that learns patterns and provides proactive suggestions.
-    """)
+with gr.Blocks(theme=gr.themes.Soft(), title="AI Code Copilot") as demo:
+    gr.Markdown("""<h1 style="text-align: center">🤖 AI Code Copilot</h1>""")
     
     with gr.Row():
-        with gr.Column():
+        with gr.Column(scale=3):
             input_text = gr.Textbox(
-                label="Your code or question",
+                label="Your Code or Question",
                 placeholder="Paste your code or ask a question...",
-                lines=5
+                lines=7
             )
-            submit_btn = gr.Button("Generate")
+            submit_btn = gr.Button("Generate", variant="primary")
             
-        with gr.Column():
-            output_text = gr.Textbox(
-                label="Copilot Response",
-                lines=10,
-                interactive=False
-            )
+        with gr.Column(scale=7):
+            with gr.Tab("Assistant Response"):
+                output_text = gr.Markdown()
+            with gr.Tab("Suggestions"):
+                suggestions = gr.Markdown()
+            with gr.Tab("Pattern Analysis"):
+                pattern_display = gr.Dataframe(
+                    headers=["Pattern", "Count"],
+                    datatype=["str", "number"],
+                    interactive=False
+                )
     
-    with gr.Accordion("Pattern Analysis", open=False):
-        pattern_display = gr.Dataframe(
-            headers=["Pattern", "Count"],
-            datatype=["str", "number"],
-            interactive=False
-        )
-    
-    def process_and_analyze(input_text):
-        response = copilot.process_input(input_text)
-        patterns = copilot.analyze_code_patterns(input_text)
+    def process_input(user_input):
+        response, patterns, sugg = copilot.process_input(user_input)
         pattern_df = pd.DataFrame({
             "Pattern": list(patterns.keys()),
             "Count": list(patterns.values())
         })
-        return response, pattern_df
+        return response, sugg, pattern_df
     
     submit_btn.click(
-        fn=process_and_analyze,
+        fn=process_input,
         inputs=input_text,
-        outputs=[output_text, pattern_display]
+        outputs=[output_text, suggestions, pattern_display]
+    )
+    
+    input_text.submit(
+        fn=process_input,
+        inputs=input_text,
+        outputs=[output_text, suggestions, pattern_display]
     )
-
-    demo.launch()
 
 if __name__ == "__main__":
     demo.launch()