Update app.py

app.py

@@ -1,643 +1,42 @@
-import gradio as gr
-import json
+from Crypto.Cipher import AES
+from Crypto.Protocol.KDF import PBKDF2
 import os
-import time
-from datetime import datetime
-from typing import List, Dict, Any, Optional, Tuple
 import tempfile
-import base64
-from pathlib import Path
+from dotenv import load_dotenv
 
-# Core dependencies
-try:
-    from together import Together
-    import speech_recognition as sr
-    import io
-    import subprocess
-    import sys
-except ImportError as e:
-    print(f"Missing dependency: {e}")
-    print("Install with: pip install together speechrecognition pyaudio")
-    sys.exit(1)
+load_dotenv()  # Load all environment variables
 
-class ConversationMemory:
-    """Manages conversation context and memory across sessions"""
-    
-    def __init__(self):
-        self.conversations = []
-        self.context_graph = {}
-        self.session_data = {}
-    
-    def add_interaction(self, input_type: str, content: str, response: str, metadata: Dict = None):
-        interaction = {
-            "timestamp": datetime.now().isoformat(),
-            "input_type": input_type,
-            "content": content[:500] + "..." if len(content) > 500 else content,
-            "response": response[:1000] + "..." if len(response) > 1000 else response,
-            "metadata": metadata or {}
-        }
-        self.conversations.append(interaction)
-    
-    def clear_history(self):
-        """Clear conversation history"""
-        self.conversations = []
-        self.context_graph = {}
-        self.session_data = {}
-    
-    def get_relevant_context(self, query: str, limit: int = 3) -> List[Dict]:
-        relevant = []
-        query_lower = query.lower()
-        
-        for conv in reversed(self.conversations[-10:]):
-            score = 0
-            content_lower = conv["content"].lower()
-            response_lower = conv["response"].lower()
-            
-            for word in query_lower.split():
-                if len(word) > 3:
-                    if word in content_lower or word in response_lower:
-                        score += 1
-            
-            if score > 0:
-                relevant.append((score, conv))
-        
-        relevant.sort(key=lambda x: x[0], reverse=True)
-        return [conv for score, conv in relevant[:limit]]
+def unpad(data):
+    return data[:-data[-1]]
 
-class NexusAI:
-    """Main AI processing class"""
-    
-    def __init__(self, api_key: str = None):
-        self.api_key = api_key
-        self.client = None
-        self.memory = ConversationMemory()
-        
-        if api_key:
-            self.initialize_client(api_key)
-    
-    def initialize_client(self, api_key: str):
-        """Initialize Together AI client"""
-        try:
-            self.client = Together(api_key=api_key)
-            self.api_key = api_key
-            return True, "✅ API key initialized successfully!"
-        except Exception as e:
-            return False, f"❌ Failed to initialize API key: {str(e)}"
-    
-    def transcribe_audio(self, audio_path: str) -> str:
-        """Transcribe audio to text"""
-        try:
-            r = sr.Recognizer()
-            with sr.AudioFile(audio_path) as source:
-                audio_data = r.record(source)
-                text = r.recognize_google(audio_data)
-                return text
-        except Exception as e:
-            return f"Error transcribing audio: {str(e)}"
-    
-    def execute_code(self, code: str, language: str = "python") -> str:
-        """Execute code safely (basic implementation)"""
-        try:
-            if language.lower() == "python":
-                with tempfile.NamedTemporaryFile(mode='w', suffix='.py', delete=False) as f:
-                    f.write(code)
-                    temp_file = f.name
-                
-                try:
-                    result = subprocess.run([sys.executable, temp_file], 
-                                          capture_output=True, text=True, timeout=10)
-                    output = result.stdout
-                    if result.stderr:
-                        output += f"\nErrors:\n{result.stderr}"
-                    return output
-                except subprocess.TimeoutExpired:
-                    return "Code execution timed out (10s limit)"
-                finally:
-                    os.unlink(temp_file)
-            else:
-                return f"Language '{language}' not supported yet. Only Python is available."
-        except Exception as e:
-            return f"Error executing code: {str(e)}"
-    
-    def build_context_messages(self, user_input: str, input_type: str, extracted_content: str = "") -> List[Dict]:
-        """Build context messages for the AI model"""
-        messages = []
-        
-        system_msg = """You are Nexus AI, a creative multimodal assistant that helps users across different types of content. 
-        You excel at connecting insights across text, voice, and code. Always provide helpful, 
-        contextual responses that build on previous interactions when relevant."""
-        
-        messages.append({"role": "system", "content": system_msg})
-        
-        relevant_context = self.memory.get_relevant_context(user_input)
-        for context in relevant_context:
-            messages.append({
-                "role": "assistant", 
-                "content": f"[Previous {context['input_type']} interaction] {context['response'][:200]}..."
-            })
-        
-        current_content = f"Input Type: {input_type}\n\n"
-        
-        if extracted_content:
-            current_content += f"Extracted Content:\n{extracted_content[:2000]}...\n\n" if len(extracted_content) > 2000 else f"Extracted Content:\n{extracted_content}\n\n"
-        
-        current_content += f"User Query: {user_input}"
-        
-        messages.append({"role": "user", "content": current_content})
-        
-        return messages
-    
-    def generate_response(self, user_input: str, input_type: str, extracted_content: str = "") -> str:
-        """Generate AI response using AFM-4.5B model"""
-        if not self.client:
-            return "❌ Please initialize your Together AI API key first!"
-        
-        try:
-            messages = self.build_context_messages(user_input, input_type, extracted_content)
-            
-            response = self.client.chat.completions.create(
-                model="arcee-ai/AFM-4.5B-Preview",
-                messages=messages,
-                max_tokens=1024,
-                temperature=0.7
-            )
-            
-            ai_response = response.choices[0].message.content
-            
-            self.memory.add_interaction(
-                input_type=input_type,
-                content=user_input + ("\n" + extracted_content if extracted_content else ""),
-                response=ai_response
-            )
-            
-            return ai_response
-            
-        except Exception as e:
-            return f"❌ Error generating response: {str(e)}"
+def decrypt_and_run():
+    # Get password from Hugging Face Secrets environment variable
+    password = os.getenv("PASSWORD")
+    if not password:
+        raise ValueError("PASSWORD secret not found in environment variables")
 
-nexus_ai = NexusAI()
+    password = password.encode()
 
-def initialize_api_key(api_key: str) -> Tuple[str, str]:
-    """Initialize the API key"""
-    if not api_key.strip():
-        return "❌ Please enter a valid API key", "error"
-    
-    success, message = nexus_ai.initialize_client(api_key.strip())
-    status = "success" if success else "error"
-    return message, status
+    with open("code.enc", "rb") as f:
+        encrypted = f.read()
 
-def process_text_input(user_input: str, api_key_status: str) -> str:
-    """Process text input"""
-    if api_key_status != "success":
-        return "❌ Please initialize your Together AI API key first!"
-    
-    if not user_input.strip():
-        return "Please enter some text to get started!"
-    
-    return nexus_ai.generate_response(user_input, "text")
+    salt = encrypted[:16]
+    iv = encrypted[16:32]
+    ciphertext = encrypted[32:]
 
-def process_audio_input(audio_file, user_question: str, api_key_status: str) -> str:
-    """Process audio input with question"""
-    if api_key_status != "success":
-        return "❌ Please initialize your Together AI API key first!"
-    
-    if audio_file is None:
-        return "Please upload an audio file first!"
-    
-    transcribed_text = nexus_ai.transcribe_audio(audio_file)
-    
-    if user_question.strip():
-        combined_input = f"Transcribed audio: '{transcribed_text}'\n\nUser question: {user_question}"
-        return nexus_ai.generate_response(combined_input, "audio", transcribed_text)
-    else:
-        return nexus_ai.generate_response("Please help me with this audio content", "audio", transcribed_text)
+    key = PBKDF2(password, salt, dkLen=32, count=1000000)
+    cipher = AES.new(key, AES.MODE_CBC, iv)
 
-def process_code_input(code_input: str, language: str, action: str, api_key_status: str) -> str:
-    """Process code input"""
-    if api_key_status != "success":
-        return "❌ Please initialize your Together AI API key first!"
-    
-    if not code_input.strip():
-        return "Please enter some code first!"
-    
-    result = ""
-    
-    if action == "Execute Code":
-        execution_result = nexus_ai.execute_code(code_input, language)
-        result = f"**Code Execution Result:**\n```\n{execution_result}\n```\n\n"
-    
-    ai_response = nexus_ai.generate_response(
-        f"Please analyze this {language} code and provide insights:\n\n{code_input}", 
-        "code", 
-        result
-    )
-    
-    return result + ai_response
+    plaintext = unpad(cipher.decrypt(ciphertext))
 
-def show_conversation_history() -> str:
-    """Show recent conversation history"""
-    if not nexus_ai.memory.conversations:
-        return "No conversation history yet. Start chatting to build your knowledge base!"
-    
-    history = "## 📚 Recent Conversation History\n\n"
-    for i, conv in enumerate(nexus_ai.memory.conversations[-10:], 1):
-        timestamp = datetime.fromisoformat(conv["timestamp"]).strftime("%H:%M:%S")
-        history += f"**{i}. [{conv['input_type'].upper()}] {timestamp}**\n"
-        history += f"Input: {conv['content'][:100]}{'...' if len(conv['content']) > 100 else ''}\n"
-        history += f"Response: {conv['response'][:150]}{'...' if len(conv['response']) > 150 else ''}\n\n"
-    
-    return history
-
-def clear_conversation_history() -> str:
-    """Clear conversation history"""
-    nexus_ai.memory.clear_history()
-    return "✅ Conversation history has been cleared!"
-
-def clear_text_inputs():
-    """Clear text input and output"""
-    return "", ""
-
-def clear_audio_inputs():
-    """Clear audio input and output"""
-    return None, "", ""
-
-def clear_code_inputs():
-    """Clear code input and output"""
-    return "", "", "python", "Execute Code"
-
-def create_nexus_interface():
-    with gr.Blocks(
-        theme=gr.themes.Soft(),
-        title="Nexus AI Assistant",
-        css="""
-        .gradio-container {
-            max-width: 1400px !important;
-            margin: 0 auto !important;
-            padding: 20px !important;
-        }
-        
-        .api-key-section {
-            background: linear-gradient(135deg, #f5f7fa 0%, #c3cfe2 100%);
-            border-radius: 12px;
-            padding: 20px;
-            margin-bottom: 25px;
-            box-shadow: 0 4px 6px rgba(0, 0, 0, 0.07);
-            border: 1px solid #e1e8ed;
-        }
-        
-        .primary-button {
-            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%) !important;
-            border: none !important;
-            color: white !important;
-            font-weight: 600 !important;
-            border-radius: 8px !important;
-            padding: 12px 24px !important;
-            transition: all 0.3s ease !important;
-            box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1) !important;
-            margin: auto;
-        }
-        
-        .primary-button:hover {
-            transform: translateY(-2px) !important;
-            box-shadow: 0 4px 12px rgba(0, 0, 0, 0.2) !important;
-        }
-        .primary-button2 {
-            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%) !important;
-            border: none !important;
-            color: white !important;
-            font-weight: 600 !important;
-            border-radius: 8px !important;
-            padding: 12px 24px !important;
-            transition: all 0.3s ease !important;
-            box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1) !important;
-            margin: auto;
-            margin-left: 10px;
-            margin-right: 10px;
-        }
-        
-        .primary-button2:hover {
-            transform: translateY(-2px) !important;
-            box-shadow: 0 4px 12px rgba(0, 0, 0, 0.2) !important;
-        }
-        
-        .secondary-button {
-            background: linear-gradient(135deg, #74b9ff 0%, #0984e3 100%) !important;
-            border: none !important;
-            color: white !important;
-            font-weight: 500 !important;
-            border-radius: 8px !important;
-            transition: all 0.3s ease !important;
-        }
-        
-        .danger-button {
-            background: linear-gradient(135deg, #fd79a8 0%, #e84393 100%) !important;
-            border: none !important;
-            color: white !important;
-            font-weight: 500 !important;
-            border-radius: 8px !important;
-            transition: all 0.3s ease !important;
-        }
-        
-        .tab-nav button {
-            border-radius: 8px 8px 0 0 !important;
-            font-weight: 500 !important;
-            padding: 12px 20px !important;
-        }
-        
-        .scrollable-textarea textarea {
-            overflow-y: auto !important;
-            resize: vertical !important;
-        }
-        
-        .input-card {
-            background: #ffffff;
-            border-radius: 10px;
-            padding: 20px;
-            box-shadow: 0 2px 8px rgba(0, 0, 0, 0.05);
-            border: 1px solid #f0f0f0;
-            margin-bottom: 15px;
-        }
-        
-        .output-card {
-            background: #f8f9fc;
-            border-radius: 10px;
-            padding: 20px;
-            box-shadow: inset 0 2px 4px rgba(0, 0, 0, 0.02);
-            border: 1px solid #e9ecef;
-        }
-        
-        .header-gradient {
-            background: linear-gradient(135deg, #667eea 0%, #764ba2 50%, #667eea 100%);
-            background-size: 200% 200%;
-            animation: gradientShift 4s ease infinite;
-        }
-        
-        @keyframes gradientShift {
-            0% { background-position: 0% 50%; }
-            50% { background-position: 100% 50%; }
-            100% { background-position: 0% 50%; }
-        }
-        
-        .status-success {
-            border-left: 4px solid #00b894 !important;
-            background-color: #d1f2eb !important;
-        }
-        
-        .status-error {
-            border-left: 4px solid #e17055 !important;
-            background-color: #fadbd8 !important;
-        }
-        
-        @media (max-width: 768px) {
-            .gradio-container {
-                padding: 10px !important;
-            }
-        }
-        """
-    ) as app:
-        
-        gr.HTML("""
-        <div class="header-gradient" style="text-align: center; padding: 30px; border-radius: 15px; margin-bottom: 25px;">
-            <h1 style="color: white; margin: 0; font-size: 3em; font-weight: 700; text-shadow: 2px 2px 4px rgba(0,0,0,0.3);">
-                🚀 Nexus AI Assistant
-            </h1>
-            <p style="color: white; margin: 15px 0 0 0; font-size: 1.3em; text-shadow: 1px 1px 2px rgba(0,0,0,0.2);">
-                Creative Multimodal AI Powered by AFM-4.5B
-            </p>
-        </div>
-        """)
-        
-        with gr.Group(elem_classes=["api-key-section"]):
-            gr.HTML("<h3 style='margin-top: 0; color: #2d3748;'>🔑 API Configuration</h3>")
-            with gr.Row():
-                api_key_input = gr.Textbox(
-                    label="Together AI API Key",
-                    type="password",
-                    placeholder="Enter your Together AI API key here...",
-                    scale=3,
-                    container=True
-                )
-                api_key_btn = gr.Button(
-                    "Initialize API Key", 
-                    variant="primary", 
-                    scale=1,
-                    elem_classes=["primary-button2"]
-                )
-            
-            api_key_status = gr.Textbox(
-                label="Status",
-                interactive=False,
-                value="Please enter your API key to get started",
-                elem_classes=["scrollable-textarea"]
-            )
-            
-            api_key_state = gr.State(value="not_initialized")
-        
-        with gr.Tabs():
-            
-            with gr.Tab("💬 Text Chat"):
-                with gr.Row():
-                    with gr.Column(scale=1, elem_classes=["input-card"]):
-                        text_input = gr.Textbox(
-                            label="Your Message",
-                            placeholder="Ask me anything! I can help with creative tasks, analysis, problem-solving...",
-                            lines=4,
-                            elem_classes=["scrollable-textarea"]
-                        )
-                        with gr.Row():
-                            text_btn = gr.Button(
-                                "Send Message", 
-                                variant="primary",
-                                elem_classes=["primary-button"]
-                            )
-                            text_clear_btn = gr.Button(
-                                "Clear", 
-                                variant="secondary",
-                                elem_classes=["danger-button"]
-                            )
-                    
-                    with gr.Column(scale=1, elem_classes=["output-card"]):
-                        text_output = gr.Textbox(
-                            label="Nexus AI Response",
-                            lines=10,
-                            interactive=False,
-                            elem_classes=["scrollable-textarea"]
-                        )
-            
-            with gr.Tab("🎤 Voice Processing"):
-                with gr.Row():
-                    with gr.Column(scale=1, elem_classes=["input-card"]):
-                        audio_file = gr.Audio(
-                            label="Upload Audio (WAV File supported)",
-                            type="filepath"
-                        )
-                        audio_question = gr.Textbox(
-                            label="Additional Question (optional)",
-                            placeholder="Any specific question about the audio content?",
-                            lines=3,
-                            elem_classes=["scrollable-textarea"]
-                        )
-                        with gr.Row():
-                            audio_btn = gr.Button(
-                                "Process Audio", 
-                                variant="primary",
-                                elem_classes=["primary-button"]
-                            )
-                            audio_clear_btn = gr.Button(
-                                "Clear", 
-                                variant="secondary",
-                                elem_classes=["danger-button"]
-                            )
-                    
-                    with gr.Column(scale=1, elem_classes=["output-card"]):
-                        audio_output = gr.Textbox(
-                            label="Processing Result",
-                            lines=12,
-                            interactive=False,
-                            elem_classes=["scrollable-textarea"]
-                        )
-            
-            with gr.Tab("⚡ Code Executor"):
-                with gr.Row():
-                    with gr.Column(scale=1, elem_classes=["input-card"]):
-                        code_input = gr.Code(
-                            label="Code Input",
-                            language="python",
-                            lines=10
-                        )
-                        with gr.Row():
-                            language_select = gr.Dropdown(
-                                choices=["python", "No other Language supported yet!"],
-                                value="python",
-                                label="Language",
-                                scale=1
-                            )
-                            code_action = gr.Radio(
-                                choices=["Execute Code", "Analyze Only"],
-                                value="Execute Code",
-                                label="Action",
-                                scale=1
-                            )
-                        with gr.Row():
-                            code_btn = gr.Button(
-                                "Process Code", 
-                                variant="primary",
-                                elem_classes=["primary-button"]
-                            )
-                            code_clear_btn = gr.Button(
-                                "Clear", 
-                                variant="secondary",
-                                elem_classes=["danger-button"]
-                            )
-                    
-                    with gr.Column(scale=1, elem_classes=["output-card"]):
-                        code_output = gr.Textbox(
-                            label="Result & Analysis",
-                            lines=15,
-                            interactive=False,
-                            elem_classes=["scrollable-textarea"]
-                        )
-            
-            with gr.Tab("🧠 Memory & History"):
-                with gr.Column(elem_classes=["input-card"]):
-                    gr.HTML("<h3 style='margin-top: 0;'>Conversation Memory</h3>")
-                    gr.HTML("<p>Nexus AI remembers your interactions and can connect insights across different input types.</p>")
-                    
-                    with gr.Row():
-                        history_btn = gr.Button(
-                            "Show Recent History", 
-                            variant="secondary",
-                            elem_classes=["secondary-button"],
-                            scale=1
-                        )
-                        clear_btn = gr.Button(
-                            "Clear History", 
-                            variant="secondary",
-                            elem_classes=["danger-button"],
-                            scale=1
-                        )
-                    
-                    history_output = gr.Textbox(
-                        label="Conversation History",
-                        lines=15,
-                        interactive=False,
-                        elem_classes=["scrollable-textarea"]
-                    )
-        
-        def update_api_status(api_key):
-            message, status = initialize_api_key(api_key)
-            if status == "success":
-                return gr.update(value=message, elem_classes=["scrollable-textarea", "status-success"]), status
-            else:
-                return gr.update(value=message, elem_classes=["scrollable-textarea", "status-error"]), status
-        
-        api_key_btn.click(
-            fn=update_api_status,
-            inputs=[api_key_input],
-            outputs=[api_key_status, api_key_state]
-        )
-        
-        text_btn.click(
-            fn=process_text_input,
-            inputs=[text_input, api_key_state],
-            outputs=[text_output]
-        )
-        
-        text_clear_btn.click(
-            fn=clear_text_inputs,
-            inputs=[],
-            outputs=[text_input, text_output]
-        )
-        
-        audio_btn.click(
-            fn=process_audio_input,
-            inputs=[audio_file, audio_question, api_key_state],
-            outputs=[audio_output]
-        )
-        
-        audio_clear_btn.click(
-            fn=clear_audio_inputs,
-            inputs=[],
-            outputs=[audio_file, audio_question, audio_output]
-        )
-        
-        code_btn.click(
-            fn=process_code_input,
-            inputs=[code_input, language_select, code_action, api_key_state],
-            outputs=[code_output]
-        )
-        
-        code_clear_btn.click(
-            fn=clear_code_inputs,
-            inputs=[],
-            outputs=[code_input, code_output, language_select, code_action]
-        )
-        
-        history_btn.click(
-            fn=show_conversation_history,
-            outputs=[history_output]
-        )
-        
-        clear_btn.click(
-            fn=clear_conversation_history,
-            outputs=[history_output]
-        )
-        
-        gr.HTML("""
-        <div style="text-align: center; padding: 25px; margin-top: 30px; border-top: 2px solid #e9ecef; background: linear-gradient(135deg, #f8f9fa 0%, #e9ecef 100%); border-radius: 10px;">
-            <p style="color: #495057; font-size: 1.1em; margin: 0;">
-                🚀 <strong>Nexus AI Assistant</strong> - Powered by AFM-4.5B | Built with ❤️ using Gradio
-            </p>
-            <p style="color: #6c757d; font-size: 0.9em; margin: 5px 0 0 0;">
-                Multi-modal AI assistant for creative and analytical tasks
-            </p>
-        </div>
-        """)
-    
-    return app
+    with tempfile.NamedTemporaryFile(suffix=".py", delete=False, mode='wb') as tmp:
+        tmp.write(plaintext)
+        tmp.flush()
+        print(f"[INFO] Running decrypted code from {tmp.name}")
+        os.system(f"python {tmp.name}")
 
 if __name__ == "__main__":
-    app = create_nexus_interface()
-    app.launch(
-        share=True
-    )
+    decrypt_and_run()
+
+# This script decrypts the encrypted code and runs it.
+# Ensure you have the PASSWORD secret set in your Hugging Face Secrets