Update app.py

app.py

@@ -1,484 +1,39 @@
-import gradio as gr
-from llama_index.core import VectorStoreIndex, Document
-from llama_index.llms.openai import OpenAI
-from llama_index.core import Settings
+from Crypto.Cipher import AES
+from Crypto.Protocol.KDF import PBKDF2
 import os
-import pdfplumber
-from docx import Document as DocxDocument
-import json
-from datetime import datetime
-import hashlib
+import tempfile
+from dotenv import load_dotenv
 
-# Global variables
-chat_engine = None
-conversation_history = []
-current_api_key_hash = None
+load_dotenv()  # Load all environment variables
 
-# Function to hash API key for identification
-def hash_api_key(api_key):
-    return hashlib.sha256(api_key.encode()).hexdigest()
+def unpad(data):
+    return data[:-data[-1]]
 
-# Function to read PDF files
-def read_pdf(file_path):
-    with pdfplumber.open(file_path) as pdf:
-        text = ''
-        for page in pdf.pages:
-            text += page.extract_text() + '\n'
-    return text
+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")
 
-# Function to read DOCX files
-def read_docx(file_path):
-    doc = DocxDocument(file_path)
-    text = ''
-    for paragraph in doc.paragraphs:
-        text += paragraph.text + '\n'
-    return text
+    password = password.encode()
 
-# Function to load and index documents
-def load_data(files, api_key):
-    global chat_engine, current_api_key_hash
-    
-    if not files or not api_key:
-        return "Please provide both API key and files to proceed."
-    
-    try:
-        docs = []
-        for file in files:
-            if file.name.endswith('.pdf'):
-                text = read_pdf(file.name)
-                docs.append(Document(text=text))
-            elif file.name.endswith('.docx'):
-                text = read_docx(file.name)
-                docs.append(Document(text=text))
-        
-        # Set OpenAI API key
-        os.environ["OPENAI_API_KEY"] = api_key
-        
-        # Store hashed API key
-        current_api_key_hash = hash_api_key(api_key)
-        
-        Settings.llm = OpenAI(
-            model="gpt-3.5-turbo", 
-            temperature=0.5,
-            api_key=api_key,
-            system_prompt="You are an expert on the Streamlit Python library and your job is to answer technical questions. Assume that all questions are related to the Streamlit Python library. Keep your answers technical and based on facts – do not hallucinate features."
-        )
-        
-        index = VectorStoreIndex.from_documents(docs)
-        chat_engine = index.as_chat_engine(chat_mode="condense_question", verbose=True)
-        
-        return "Documents loaded and indexed successfully! You can now start chatting."
-    except Exception as e:
-        return f"Error loading documents: {str(e)}"
+    with open("code.enc", "rb") as f:
+        encrypted = f.read()
 
-# Function to handle chat
-def chat_with_docs(message, history, api_key):
-    global chat_engine, conversation_history, current_api_key_hash
-    
-    if not api_key:
-        return history + [{"role": "assistant", "content": "Please enter your OpenAI API key first."}]
-    
-    # Set current API key hash if not set
-    if current_api_key_hash is None:
-        current_api_key_hash = hash_api_key(api_key)
-    
-    if chat_engine is None:
-        return history + [
-            {"role": "user", "content": message},
-            {"role": "assistant", "content": "Please upload and load documents first before asking questions."}
-        ]
-    
-    try:
-        response = chat_engine.chat(message)
-        conversation_history.append({"role": "user", "content": message})
-        conversation_history.append({"role": "assistant", "content": response.response})
-        
-        return history + [
-            {"role": "user", "content": message},
-            {"role": "assistant", "content": response.response}
-        ]
-    except Exception as e:
-        return history + [
-            {"role": "user", "content": message},
-            {"role": "assistant", "content": f"Error: {str(e)}"}
-        ]
+    salt = encrypted[:16]
+    iv = encrypted[16:32]
+    ciphertext = encrypted[32:]
 
-# Function to save conversation
-def save_conversation(api_key):
-    global conversation_history, current_api_key_hash
-    
-    if not api_key:
-        return "Please enter your OpenAI API key first.", gr.update()
-    
-    if not conversation_history:
-        return "No conversation to save.", gr.update()
-    
-    try:
-        # Set current API key hash if not set
-        if current_api_key_hash is None:
-            current_api_key_hash = hash_api_key(api_key)
-        
-        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-        with open("conversations.json", "a") as f:
-            conv_data = {
-                "timestamp": timestamp,
-                "api_key_hash": current_api_key_hash,
-                "messages": conversation_history
-            }
-            json.dump(conv_data, f)
-            f.write("\n")
-        
-        # Update the dropdown choices
-        choices = get_conversation_choices(api_key)
-        return "Conversation saved successfully!", gr.update(choices=choices)
-    except Exception as e:
-        return f"Error saving conversation: {str(e)}", gr.update()
+    key = PBKDF2(password, salt, dkLen=32, count=1000000)
+    cipher = AES.new(key, AES.MODE_CBC, iv)
 
-# Function to get conversation choices for dropdown
-def get_conversation_choices(api_key):
-    if not api_key:
-        return []
-    
-    if os.path.exists("conversations.json"):
-        try:
-            api_key_hash = hash_api_key(api_key)
-            with open("conversations.json", "r") as f:
-                conversations = [json.loads(line) for line in f]
-            
-            choices = []
-            for i, conv in enumerate(conversations):
-                # Only show conversations for this API key
-                if conv.get("api_key_hash") == api_key_hash:
-                    timestamp = conv.get("timestamp", "Unknown time")
-                    formatted_time = datetime.strptime(timestamp, "%Y%m%d_%H%M%S").strftime("%Y-%m-%d %H:%M:%S")
-                    choices.append(f"{i + 1}. {formatted_time}")
-            
-            return choices
-        except Exception as e:
-            return []
-    return []
+    plaintext = unpad(cipher.decrypt(ciphertext))
 
-# Function to load previous conversations
-def load_conversations(api_key):
-    if not api_key:
-        return "Please enter your OpenAI API key to view conversations."
-    
-    if os.path.exists("conversations.json"):
-        try:
-            api_key_hash = hash_api_key(api_key)
-            with open("conversations.json", "r") as f:
-                conversations = [json.loads(line) for line in f]
-            
-            conv_text = ""
-            conv_count = 0
-            for i, conv in enumerate(conversations):
-                # Only show conversations for this API key
-                if conv.get("api_key_hash") == api_key_hash:
-                    conv_count += 1
-                    conv_text += f"\n{'='*50}\nConversation {i + 1}\n{'='*50}\n"
-                    timestamp = conv.get("timestamp", "Unknown time")
-                    formatted_time = datetime.strptime(timestamp, "%Y%m%d_%H%M%S").strftime("%Y-%m-%d %H:%M:%S")
-                    conv_text += f"Timestamp: {formatted_time}\n\n"
-                    
-                    messages = conv.get("messages", conv)
-                    for message in messages:
-                        role = message.get('role', 'unknown')
-                        content = message.get('content', '')
-                        conv_text += f"{role.upper()}: {content}\n\n"
-            
-            if conv_count == 0:
-                return "No conversations found for your API key."
-            
-            return conv_text
-        except Exception as e:
-            return f"Error loading conversations: {str(e)}"
-    return "No previous conversations found."
-
-# Function to view selected conversation
-def view_selected_conversation(selection, api_key):
-    if not api_key:
-        return "Please enter your OpenAI API key first."
-    
-    if not selection or selection == "Select a conversation":
-        return "Please select a conversation to view."
-    
-    try:
-        api_key_hash = hash_api_key(api_key)
-        # Extract conversation number from selection
-        conv_number = int(selection.split(".")[0]) - 1
-        
-        if os.path.exists("conversations.json"):
-            with open("conversations.json", "r") as f:
-                conversations = [json.loads(line) for line in f]
-            
-            if conv_number < len(conversations):
-                conv = conversations[conv_number]
-                
-                # Check if this conversation belongs to the current API key
-                if conv.get("api_key_hash") != api_key_hash:
-                    return "This conversation does not belong to your API key."
-                
-                conv_text = f"{'='*50}\n"
-                timestamp = conv.get("timestamp", "Unknown time")
-                formatted_time = datetime.strptime(timestamp, "%Y%m%d_%H%M%S").strftime("%Y-%m-%d %H:%M:%S")
-                conv_text += f"Conversation Timestamp: {formatted_time}\n"
-                conv_text += f"{'='*50}\n\n"
-                
-                messages = conv.get("messages", conv)
-                for message in messages:
-                    role = message.get('role', 'unknown')
-                    content = message.get('content', '')
-                    conv_text += f"{role.upper()}: {content}\n\n"
-                
-                return conv_text
-        
-        return "Conversation not found."
-    except Exception as e:
-        return f"Error viewing conversation: {str(e)}"
-
-# Function to delete selected conversation
-def delete_selected_conversation(selection, api_key):
-    if not api_key:
-        return "Please enter your OpenAI API key first.", gr.update(), "", ""
-    
-    if not selection or selection == "Select a conversation":
-        return "Please select a conversation to delete.", gr.update(), "", ""
-    
-    try:
-        api_key_hash = hash_api_key(api_key)
-        # Extract conversation number from selection
-        conv_number = int(selection.split(".")[0]) - 1
-        
-        if os.path.exists("conversations.json"):
-            with open("conversations.json", "r") as f:
-                conversations = [json.loads(line) for line in f]
-            
-            if conv_number < len(conversations):
-                conv = conversations[conv_number]
-                
-                # Check if this conversation belongs to the current API key
-                if conv.get("api_key_hash") != api_key_hash:
-                    return "You can only delete your own conversations.", gr.update(), "", ""
-                
-                # Remove the selected conversation
-                del conversations[conv_number]
-                
-                # Write back the remaining conversations
-                with open("conversations.json", "w") as f:
-                    for conv in conversations:
-                        json.dump(conv, f)
-                        f.write("\n")
-                
-                # Update dropdown choices
-                choices = get_conversation_choices(api_key)
-                
-                # Get updated all conversations display
-                all_convs = load_conversations(api_key)
-                
-                return f"Conversation {conv_number + 1} deleted successfully!", gr.update(choices=choices, value="Select a conversation"), all_convs, ""
-            else:
-                return "Conversation not found.", gr.update(), "", ""
-        
-        return "No conversations file found.", gr.update(), "", ""
-    except Exception as e:
-        return f"Error deleting conversation: {str(e)}", gr.update(), "", ""
-
-# Function to clear current conversation
-def clear_conversation():
-    global conversation_history
-    conversation_history = []
-    return []
-
-# Function to delete all conversations for current API key
-def delete_all_conversations(api_key):
-    if not api_key:
-        return "Please enter your OpenAI API key first.", gr.update(), "", ""
-    
-    try:
-        api_key_hash = hash_api_key(api_key)
-        
-        if os.path.exists("conversations.json"):
-            with open("conversations.json", "r") as f:
-                conversations = [json.loads(line) for line in f]
-            
-            # Keep only conversations that don't belong to this API key
-            remaining_conversations = [conv for conv in conversations if conv.get("api_key_hash") != api_key_hash]
-            
-            deleted_count = len(conversations) - len(remaining_conversations)
-            
-            if deleted_count == 0:
-                return "No conversations to delete for your API key.", gr.update(), "No previous conversations found.", ""
-            
-            # Write back remaining conversations
-            with open("conversations.json", "w") as f:
-                for conv in remaining_conversations:
-                    json.dump(conv, f)
-                    f.write("\n")
-            
-            # If no conversations left, remove the file
-            if len(remaining_conversations) == 0:
-                os.remove("conversations.json")
-            
-            return f"All {deleted_count} conversation(s) deleted successfully!", gr.update(choices=[], value="Select a conversation"), "No previous conversations found.", ""
-        
-        return "No conversations to delete.", gr.update(), "No previous conversations found.", ""
-    except Exception as e:
-        return f"Error deleting conversations: {str(e)}", gr.update(), "", ""
-
-# Function to refresh dropdown
-def refresh_dropdown(api_key):
-    if not api_key:
-        return gr.update(choices=[])
-    choices = get_conversation_choices(api_key)
-    return gr.update(choices=choices)
-
-# Create Gradio interface
-with gr.Blocks(title="Chat with Documents 💬 📚", theme=gr.themes.Ocean()) as demo:
-    gr.Markdown("# Chat with Documents 💬 📚")
-    gr.Markdown("Upload PDF or DOCX files and chat with them using AI!")
-    gr.Markdown("**Note:** Your conversations are private and tied to your API key. Only you can view and manage your conversations.")
-    
-    with gr.Row():
-        with gr.Column(scale=2):
-            api_key_input = gr.Textbox(
-                label="OpenAI API Key",
-                type="password",
-                placeholder="Enter your OpenAI API key here..."
-            )
-            
-            file_upload = gr.File(
-                label="Upload PDF or DOCX files",
-                file_count="multiple",
-                file_types=[".pdf", ".docx"]
-            )
-            
-            load_btn = gr.Button("Load Documents", variant="primary")
-            load_status = gr.Textbox(label="Status", interactive=False)
-            
-            load_btn.click(
-                fn=load_data,
-                inputs=[file_upload, api_key_input],
-                outputs=load_status
-            )
-    
-    with gr.Row():
-        with gr.Column(scale=3):
-            chatbot = gr.Chatbot(
-                label="Chat",
-                height=400
-            )
-            msg = gr.Textbox(
-                label="Your Question",
-                placeholder="Ask a question about your documents..."
-            )
-            
-            with gr.Row():
-                submit_btn = gr.Button("Send", variant="primary")
-                clear_btn = gr.Button("Clear Chat")
-            
-            with gr.Row():
-                save_btn = gr.Button("Save Conversation")
-                save_status = gr.Textbox(label="Save Status", interactive=False)
-        
-        with gr.Column(scale=1):
-            gr.Markdown("### Conversation Management")
-            gr.Markdown("_Only your conversations are shown below_")
-            
-            with gr.Row():
-                load_convs_btn = gr.Button("Load All Conversations")
-                refresh_btn = gr.Button("🔄 Refresh List")
-            
-            convs_display = gr.Textbox(
-                label="All Conversations",
-                lines=10,
-                interactive=False
-            )
-            
-            gr.Markdown("### Select & Manage Conversation")
-            
-            conversation_dropdown = gr.Dropdown(
-                label="Select Conversation",
-                choices=[],
-                value="Select a conversation",
-                interactive=True
-            )
-            
-            view_btn = gr.Button("View Selected", variant="secondary")
-
-    with gr.Row():
-        with gr.Column(scale=1):
-            selected_conv_display = gr.Textbox(
-                    label="Selected Conversation",
-                    lines=10,
-                    interactive=False
-                )
-                
-            with gr.Row():
-                delete_selected_btn = gr.Button("Delete Selected", variant="stop")
-                delete_all_btn = gr.Button("Delete All Mine", variant="stop")
-                
-            delete_status = gr.Textbox(label="Delete Status", interactive=False)
-                
-    
-    # Event handlers
-    submit_btn.click(
-        fn=chat_with_docs,
-        inputs=[msg, chatbot, api_key_input],
-        outputs=chatbot
-    ).then(
-        lambda: "",
-        outputs=msg
-    )
-    
-    msg.submit(
-        fn=chat_with_docs,
-        inputs=[msg, chatbot, api_key_input],
-        outputs=chatbot
-    ).then(
-        lambda: "",
-        outputs=msg
-    )
-    
-    clear_btn.click(
-        fn=clear_conversation,
-        outputs=chatbot
-    )
-    
-    save_btn.click(
-        fn=save_conversation,
-        inputs=api_key_input,
-        outputs=[save_status, conversation_dropdown]
-    )
-    
-    load_convs_btn.click(
-        fn=load_conversations,
-        inputs=api_key_input,
-        outputs=convs_display
-    )
-    
-    refresh_btn.click(
-        fn=refresh_dropdown,
-        inputs=api_key_input,
-        outputs=conversation_dropdown
-    )
-    
-    view_btn.click(
-        fn=view_selected_conversation,
-        inputs=[conversation_dropdown, api_key_input],
-        outputs=selected_conv_display
-    )
-    
-    delete_selected_btn.click(
-        fn=delete_selected_conversation,
-        inputs=[conversation_dropdown, api_key_input],
-        outputs=[delete_status, conversation_dropdown, convs_display, selected_conv_display]
-    )
-    
-    delete_all_btn.click(
-        fn=delete_all_conversations,
-        inputs=api_key_input,
-        outputs=[delete_status, conversation_dropdown, convs_display, selected_conv_display]
-    )
+    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__":
-    demo.launch(share=True)
+    decrypt_and_run()