Update app.py

app.py

@@ -1,129 +1,153 @@
 import gradio as gr
-import requests
 import os
+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)
+nltk.download('punkt', quiet=True)
 
 # Load environment variables
 load_dotenv()
+BLACKBOX_API_KEY = os.getenv("BLACKBOX_API_KEY")
 
-# Constants
-BLACKBOX_API_ENDPOINT = "https://www.blackbox.ai/api/chat"
-BLACKBOX_API_KEY = os.getenv("sk--yuitsASMpfxFL4jNViUGw", "")
-
-def generate_text_with_blackbox(prompt):
-    """Generate text using Blackbox AI API with proper error handling"""
-    if not BLACKBOX_API_KEY:
-        return "Error: BLACKBOX_API_KEY not found in environment variables"
+class CodeCopilot:
+    def __init__(self):
+        self.chat_history = []
+        self.context_window = 5
+        
+    def get_blackbox_response(self, prompt, max_tokens=300, temperature=0.7):
+        """Get response from Blackbox AI API"""
+        headers = {
+            "Authorization": f"Bearer {BLACKBOX_API_KEY}",
+            "Content-Type": "application/json"
+        }
+        data = {
+            "prompt": prompt,
+            "max_tokens": max_tokens,
+            "temperature": temperature
+        }
+        
+        try:
+            response = requests.post(
+                "https://api.blackbox.ai/generate",
+                headers=headers,
+                json=data,
+                timeout=30
+            )
+            response.raise_for_status()
+            return response.json().get("text", "No response text found.")
+        except Exception as e:
+            return f"Error: {str(e)}"
     
-    headers = {
-        "Content-Type": "application/json",
-        "Authorization": f"Bearer {BLACKBOX_API_KEY}"
-    }
+    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 ']))
+        }
+        return patterns
     
-    payload = {
-        "messages": [{"role": "user", "content": prompt}],
-        "id": "code-copilot-session",
-        "userId": "gradio-chat-interface",
-        "codeModelMode": True,
-        "previewToken": None
-    }
+    def generate_suggestions(self, patterns):
+        """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.")
+        if patterns['loop'] > 2:
+            suggestions.append("You might benefit from using list comprehensions or map/filter functions.")
+        if patterns['conditional'] > 3:
+            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."
     
-    try:
-        response = requests.post(
-            BLACKBOX_API_ENDPOINT,
-            headers=headers,
-            json=payload,
-            timeout=30
-        )
+    def process_input(self, user_input, history=None):
+        """Process user input and generate response"""
+        # Analyze patterns
+        patterns = self.analyze_code_patterns(user_input)
+        suggestions = self.generate_suggestions(patterns)
         
-        # Check for successful response
-        response.raise_for_status()
+        # 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}
         
-        # Parse the response
-        if response.status_code == 200:
-            try:
-                return response.json().get("content", "No content returned")
-            except ValueError:
-                return "Error parsing JSON response"
-        else:
-            return f"API Error: {response.status_code} - {response.text}"
-            
-    except requests.exceptions.RequestException as e:
-        return f"Request failed: {str(e)}"
-    except Exception as e:
-        return f"Unexpected error: {str(e)}"
+        User Input:
+        {user_input}
+        
+        Respond as a helpful coding assistant that also provides suggestions for improvement.
+        Suggestions to consider:
+        {suggestions}
+        """
+        
+        # Get response from Blackbox AI
+        response = self.get_blackbox_response(prompt)
+        
+        # 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
 
-def analyze_code(code):
-    """Analyze code and provide suggestions"""
-    analysis_prompt = f"""
-    Analyze this code and provide detailed suggestions for improvement:
-    - Code quality
-    - Optimizations
-    - Best practices
-    - Security considerations
-    - Readability enhancements
-    
-    Code to analyze:
-    {code}
-    
-    Respond with clear bullet points and explanations.
-    """
-    return generate_text_with_blackbox(analysis_prompt)
+# Initialize copilot
+copilot = CodeCopilot()
 
-with gr.Blocks(title="AI Code Copilot", theme=gr.themes.Soft()) as app:
+# 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.Row():
-        gr.Markdown("# 🚀 AI Code Copilot")
-        gr.Markdown("Powered by Blackbox AI")
+        with gr.Column():
+            input_text = gr.Textbox(
+                label="Your code or question",
+                placeholder="Paste your code or ask a question...",
+                lines=5
+            )
+            submit_btn = gr.Button("Generate")
+            
+        with gr.Column():
+            output_text = gr.Textbox(
+                label="Copilot Response",
+                lines=10,
+                interactive=False
+            )
     
-    with gr.Tabs():
-        with gr.TabItem("Code Generation"):
-            with gr.Column():
-                prompt = gr.Textbox(
-                    label="Enter your prompt",
-                    placeholder="Describe what code you want to generate...",
-                    lines=3
-                )
-                generate_btn = gr.Button("Generate Code")
-                output = gr.Code(
-                    label="Generated Code",
-                    language="python",
-                    interactive=True
-                )
-                
-        with gr.TabItem("Code Analysis"):
-            with gr.Column():
-                code_input = gr.Code(
-                    label="Paste your code here",
-                    language="python",
-                    lines=10
-                )
-                analyze_btn = gr.Button("Analyze Code")
-                suggestions = gr.Markdown(
-                    label="Suggestions",
-                    value="Your suggestions will appear here..."
-                )
+    with gr.Accordion("Pattern Analysis", open=False):
+        pattern_display = gr.Dataframe(
+            headers=["Pattern", "Count"],
+            datatype=["str", "number"],
+            interactive=False
+        )
     
-    generate_btn.click(
-        fn=generate_text_with_blackbox,
-        inputs=prompt,
-        outputs=output
-    )
+    def process_and_analyze(input_text):
+        response = copilot.process_input(input_text)
+        patterns = copilot.analyze_code_patterns(input_text)
+        pattern_df = pd.DataFrame({
+            "Pattern": list(patterns.keys()),
+            "Count": list(patterns.values())
+        })
+        return response, pattern_df
     
-    analyze_btn.click(
-        fn=analyze_code,
-        inputs=code_input,
-        outputs=suggestions
+    submit_btn.click(
+        fn=process_and_analyze,
+        inputs=input_text,
+        outputs=[output_text, pattern_display]
     )
-    
-    gr.Markdown("---")
-    gr.Markdown("### Note:")
-    gr.Markdown("1. Make sure you have a valid BLACKBOX_API_KEY in your `.env` file")
-    gr.Markdown("2. Be specific with your prompts for better results")
+
+    demo.launch()
 
 if __name__ == "__main__":
-    app.launch(
-        server_name="0.0.0.0",
-        server_port=7860,
-        show_error=True,
-        debug=True
-    )
+    demo.launch()