Update app.py

app.py

@@ -1,61 +1,58 @@
 import os
 import openai
-from openai.error import OpenAIError
 import gradio as gr
 import datetime
 import pytz
 import logging
+from openai import OpenAI, OpenAIError
+from threading import Lock
 
-class MemoryTracker:
-    @staticmethod
-    def get_memory_usage():
-        # Placeholder for memory usage tracking
-        return "0.00 GB"
-
-    @staticmethod
-    def clear_memory():
-        # Placeholder for memory clearing
-        pass
-
+# Configure logging
 logging.basicConfig(
     level=logging.INFO,
     format='%(asctime)s - %(levelname)s - %(message)s'
 )
 logger = logging.getLogger(__name__)
 
+# Set up OpenAI authentication
 def setup_openai_auth():
-    openai.api_key = os.environ.get("OPENAI_API_KEY")
-    if openai.api_key is None:
-        raise Exception("OpenAI API authentication failed. Please set your API key.")
-    return True
+    api_key = os.environ.get("LLM_API_KEY")
+    if not api_key:
+        raise Exception("LLM API authentication failed. Please set your API key.")
+    client = OpenAI(api_key=api_key)
+    return client
+
+# Initialize OpenAI client
+client = setup_openai_auth()
 
 class OpenAILLMHandler:
     def __init__(self):
-        self.model = "gpt-3.5-turbo"
-        self.memory_tracker = MemoryTracker()
-        self.cache_manager = CacheManager()
+        self.model = os.environ.get("MODEL_NAME", "gpt-4")
+        self.base_url = os.environ.get("LLM_API_BASE_URL", "https://api.openai.com")
+        self.cache_manager = {}  # Simple in-memory cache; consider using Redis or similar for production
         self.generation_lock = Lock()
-        
+        self.client = client  # Using the initialized OpenAI client
+
     def generate_response(self, prompt: str, max_length: int = 512) -> str:
         cache_key = f"{prompt[:100]}_{max_length}"
         cached_response = self.cache_manager.get(cache_key)
         if cached_response:
+            logger.info("Returning cached response.")
             return cached_response
-            
+
         try:
             with self.generation_lock:
-                response = openai.ChatCompletion.create(
+                response = self.client.chat.completions.create(
                     model=self.model,
                     messages=[{"role": "user", "content": prompt}],
                     max_tokens=max_length,
-                    n=1,
-                    stop=None,
                     temperature=0.7,
                 )
                 
-                response_text = response.choices[0].message.content
+                response_text = response.choices[0].message.content.strip()
                 
-                self.cache_manager.set(cache_key, response_text)
+                self.cache_manager[cache_key] = response_text
+                logger.info("Response generated and cached.")
                 return response_text
                 
         except OpenAIError as e:
@@ -94,7 +91,7 @@ Make it a challenge to guess if you are an AI.
 * Be slightly curious, sometimes ask questions
 * Be respectful and polite if the user is polite; be rough if the user is rough
 """
-    
+
 llm_handler = OpenAILLMHandler()
 
 def generate_response(user_message: str, conversation_history: list) -> str:
@@ -111,22 +108,26 @@ def generate_response(user_message: str, conversation_history: list) -> str:
     
     return llm_handler.generate_response(prompt)
 
-def chatbot_interface(user_message: str, history: list = None):
-    if history is None:
-        history = []
+def chatbot_interface(user_message: str, history: list) -> list:
+    if not user_message.strip():
+        return history
+    
+    if not llm_handler.model:
+        history.append({"role": "system", "content": "Error: Please call the Human first."})
+        return history
     
     ai_response = generate_response(user_message, history)
     history.append({"role": "user", "content": user_message})
     history.append({"role": "assistant", "content": ai_response})
-    return history, history
+    return history
 
-# Gradio interface with optimized CSS
+# Enhanced Gradio UI with improved CSS and layout
 custom_css = """
 @import url('https://fonts.googleapis.com/css2?family=Raleway:wght@400;600&display=swap');
 
 body, .gradio-container {
     font-family: 'Raleway', sans-serif;
-    background-color: #f5f5f5;
+    background-color: #f0f2f5;
     padding: 20px;
 }
 
@@ -135,37 +136,67 @@ body, .gradio-container {
     overflow-y: auto;
     background-color: #ffffff;
     border-radius: 10px;
-    padding: 10px;
+    padding: 15px;
     font-size: 16px;
-    box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
+    box-shadow: 0 4px 12px rgba(0, 0, 0, 0.1);
 }
 
 .message {
-    margin: 8px 0;
-    padding: 8px;
+    margin: 10px 0;
+    padding: 10px;
     border-radius: 8px;
+    max-width: 80%;
 }
 
 .user-message {
-    background-color: #e3f2fd;
-    margin-left: 20%;
+    background-color: #d1e7dd;
+    align-self: flex-end;
+    margin-left: auto;
 }
 
 .bot-message {
-    background-color: #f5f5f5;
-    margin-right: 20%;
+    background-color: #f8d7da;
+    align-self: flex-start;
+    margin-right: auto;
+}
+
+#textbox {
+    width: 100%;
+    padding: 10px;
+    border: 1px solid #ced4da;
+    border-radius: 5px;
+}
+
+#send-button, #load-button {
+    background-color: #0d6efd;
+    color: white;
+    border: none;
+    padding: 10px 20px;
+    border-radius: 5px;
+    cursor: pointer;
+    margin-left: 10px;
+}
+
+#send-button:hover, #load-button:hover {
+    background-color: #0b5ed7;
+}
+
+.gr-button:disabled {
+    background-color: #6c757d !important;
+    cursor: not-allowed;
 }
 """
 
 with gr.Blocks(css=custom_css) as demo:
-    gr.Markdown("<h1 style='text-align: center; color: #007BFF;'>Human.</h1>")
+    gr.Markdown("<h1 style='text-align: center; color: #0d6efd;'>Human.</h1>")
     
     with gr.Row():
-        load_button = gr.Button("Call Human", variant="primary")
+        load_button = gr.Button("Call Human", variant="primary", elem_id="load-button")
         model_status = gr.Textbox(
             label="Human Arrival Status",
             value="Human Not Listening.",
-            interactive=False
+            interactive=False,
+            elem_id="model-status"
         )
     
     with gr.Row():
@@ -184,37 +215,47 @@ with gr.Blocks(css=custom_css) as demo:
                     elem_id="textbox"
                 )
                 send = gr.Button("➤", elem_id="send-button")
-
+    
     def load_model_click():
-        result = llm_handler.load_model()
-        return "Human Called Successfully." if result is True else str(result)
-
+        if llm_handler.model:
+            return "Human Already Listening."
+        try:
+            # Reload the model name from environment if needed
+            llm_handler.model = os.environ.get("MODEL_NAME", "gpt-4")
+            if not llm_handler.model:
+                return "Failed to load model. Please set the MODEL_NAME environment variable."
+            return "Human Called Successfully."
+        except Exception as e:
+            logger.error(f"Error loading model: {e}")
+            return f"Error loading model: {str(e)}"
+    
     def update_chat(user_message, history):
         if not user_message.strip():
-            return history, history, ""
-        if llm_handler.model is None:
-            return history + [("Error", "Please call the Human first.")], history, ""
+            return history, gr.update(value="")
+        if not llm_handler.model:
+            history.append({"role": "system", "content": "Error: Please call the Human first."})
+            return history, gr.update(value="")
             
-        history, updated_history = chatbot_interface(user_message, history)
-        return history, updated_history, ""
-
+        updated_history = chatbot_interface(user_message, history)
+        return updated_history, gr.update(value="")
+    
     # Event handlers
     load_button.click(
         load_model_click,
         outputs=[model_status]
     )
 
-    msg.submit(
+    send.click(
         update_chat,
         inputs=[msg, chatbot],
-        outputs=[chatbot, chatbot, msg]
+        outputs=[chatbot, msg]
     )
-
-    send.click(
+    
+    msg.submit(
         update_chat,
         inputs=[msg, chatbot],
-        outputs=[chatbot, chatbot, msg]
+        outputs=[chatbot, msg]
     )
 
 if __name__ == "__main__":
-    demo.launch(share=True)
+    demo.launch(share=True)