Update app.py

app.py

@@ -7,10 +7,22 @@ import uuid
 import sqlite3
 import datetime
 import difflib
+import logging
 from tiktoken import get_encoding
 from openai import AzureOpenAI
 import httpx
 
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.FileHandler('app.log'),
+        logging.StreamHandler()
+    ]
+)
+logger = logging.getLogger(__name__)
+
 # Clear proxy environment variables to avoid interference
 os.environ.pop("HTTP_PROXY", None)
 os.environ.pop("HTTPS_PROXY", None)
@@ -21,6 +33,7 @@ class ConversationMemory:
         self.conn = sqlite3.connect(db_path)
         self.create_table()
         self.tokenizer = get_encoding("cl100k_base")
+        logger.info(f"Initialized ConversationMemory with db_path: {db_path}")
         
     def create_table(self):
         self.conn.execute("""
@@ -35,6 +48,7 @@ class ConversationMemory:
             )
         """)
         self.conn.commit()
+        logger.info("Created conversation_chunks table")
         
     def add_chunk(self, text, role, intent="general"):
         chunk_id = str(uuid.uuid4())
@@ -46,16 +60,20 @@ class ConversationMemory:
             VALUES (?, ?, ?, ?, ?, ?)
         """, (chunk_id, text, role, timestamp, intent, token_count))
         self.conn.commit()
+        logger.info(f"Added chunk: {chunk_id}, role: {role}, intent: {intent}, token_count: {token_count}")
         return chunk_id
         
     def get_chunk(self, chunk_id):
         cursor = self.conn.execute("SELECT * FROM conversation_chunks WHERE chunk_id = ?", (chunk_id,))
         row = cursor.fetchone()
         if row:
-            return {
+            chunk = {
                 "chunk_id": row[0], "text": row[1], "role": row[2],
                 "timestamp": row[3], "intent": row[4], "token_count": row[5]
             }
+            logger.info(f"Retrieved chunk: {chunk_id}")
+            return chunk
+        logger.warning(f"Chunk not found: {chunk_id}")
         return None
         
     def update_chunk(self, chunk_id, text):
@@ -66,16 +84,20 @@ class ConversationMemory:
             WHERE chunk_id = ?
         """, (text, token_count, chunk_id))
         self.conn.commit()
+        logger.info(f"Updated chunk: {chunk_id}, new token_count: {token_count}")
         
     def get_recent_chunks(self, limit=10):
         cursor = self.conn.execute("SELECT * FROM conversation_chunks ORDER BY timestamp DESC LIMIT ?", (limit,))
-        return [{"chunk_id": row[0], "text": row[1], "role": row[2], "timestamp": row[3], "intent": row[4], "token_count": row[5]} for row in cursor]
+        chunks = [{"chunk_id": row[0], "text": row[1], "role": row[2], "timestamp": row[3], "intent": row[4], "token_count": row[5]} for row in cursor]
+        logger.info(f"Retrieved {len(chunks)} recent chunks")
+        return chunks
 
 # TextEditor class
 class TextEditor:
     def __init__(self, memory):
         self.memory = memory
         self.clipboard = ""
+        logger.info("Initialized TextEditor")
         
     def cut(self, chunk_id, start, end):
         chunk = self.memory.get_chunk(chunk_id)
@@ -83,12 +105,18 @@ class TextEditor:
             self.clipboard = chunk['text'][start:end]
             chunk['text'] = chunk['text'][:start] + chunk['text'][end:]
             self.memory.update_chunk(chunk_id, chunk['text'])
+            logger.info(f"Cut text from chunk: {chunk_id}, start: {start}, end: {end}, clipboard: {self.clipboard}")
+        else:
+            logger.warning(f"Failed to cut text, chunk not found: {chunk_id}")
         return chunk['text']
         
     def copy(self, chunk_id, start, end):
         chunk = self.memory.get_chunk(chunk_id)
         if chunk:
             self.clipboard = chunk['text'][start:end]
+            logger.info(f"Copied text from chunk: {chunk_id}, start: {start}, end: {end}, clipboard: {self.clipboard}")
+        else:
+            logger.warning(f"Failed to copy text, chunk not found: {chunk_id}")
         return self.clipboard
         
     def paste(self, chunk_id, position):
@@ -96,6 +124,9 @@ class TextEditor:
         if chunk:
             chunk['text'] = chunk['text'][:position] + self.clipboard + chunk['text'][position:]
             self.memory.update_chunk(chunk_id, chunk['text'])
+            logger.info(f"Pasted text to chunk: {chunk_id}, position: {position}, clipboard: {self.clipboard}")
+        else:
+            logger.warning(f"Failed to paste text, chunk not found: {chunk_id}")
         return chunk['text']
         
     def add_prefix(self, chunk_id, prefix):
@@ -103,6 +134,9 @@ class TextEditor:
         if chunk:
             chunk['text'] = prefix + chunk['text']
             self.memory.update_chunk(chunk_id, chunk['text'])
+            logger.info(f"Added prefix to chunk: {chunk_id}, prefix: {prefix}")
+        else:
+            logger.warning(f"Failed to add prefix, chunk not found: {chunk_id}")
         return chunk['text']
         
     def add_suffix(self, chunk_id, suffix):
@@ -110,6 +144,9 @@ class TextEditor:
         if chunk:
             chunk['text'] = chunk['text'] + suffix
             self.memory.update_chunk(chunk_id, chunk['text'])
+            logger.info(f"Added suffix to chunk: {chunk_id}, suffix: {suffix}")
+        else:
+            logger.warning(f"Failed to add suffix, chunk not found: {chunk_id}")
         return chunk['text']
         
     def diff(self, chunk_id, original_text):
@@ -117,24 +154,27 @@ class TextEditor:
         if chunk:
             differ = difflib.Differ()
             diff = list(differ.compare(original_text.splitlines(), chunk['text'].splitlines()))
+            logger.info(f"Generated diff for chunk: {chunk_id}")
             return '\n'.join(diff)
+        logger.warning(f"Failed to generate diff, chunk not found: {chunk_id}")
         return ""
 
 # OpenAIApi class
 class OpenAIApi:
-    def __init__(self, preprompt="", endpoint="https://T-App-GPT4o.openai.azure.com/openai/v1/", model="gpt-4o", api_key=None):
+    def __init__(self, preprompt="", endpoint="https://<your-resource-name>.openai.azure.com/", model="gpt-4o", api_key=None):
         # Use a minimal httpx.Client to avoid proxies parameter
         http_client = httpx.Client()
         self.client = AzureOpenAI(
             azure_endpoint=endpoint,
             api_key=api_key or os.getenv("AZURE_OPENAI_API_KEY"),
-            api_version="2025-01-01-preview",
+            api_version="2024-02-15-preview",
             http_client=http_client
         )
         self.model = model
         self.preprompt = preprompt
         self.memory = ConversationMemory()
         self.editor = TextEditor(self.memory)
+        logger.info(f"Initialized OpenAIApi with endpoint: {endpoint}, model: {model}, api_version: 2024-02-15-preview")
         self.functions = [
             {
                 "type": "function",
@@ -216,6 +256,8 @@ class OpenAIApi:
         messages.extend({"role": c["role"], "content": c["text"]} for c in context)
         messages.append({"role": "user", "content": sanitized_prompt})
         
+        logger.info(f"Sending request to model: {self.model}, messages: {json.dumps(messages, ensure_ascii=False)}")
+        
         try:
             response = await self.client.chat.completions.create(
                 model=self.model,
@@ -238,11 +280,13 @@ class OpenAIApi:
                     tool_calls.extend(chunk.choices[0].delta.tool_calls)
             
             response_chunk_id = self.memory.add_chunk(full_response, "assistant")
+            logger.info(f"Received response for chunk: {response_chunk_id}, length: {len(full_response)}")
             
             for tool_call in tool_calls:
                 if tool_call and hasattr(tool_call, 'function'):
                     func_name = tool_call.function.name
                     args = json.loads(tool_call.function.arguments)
+                    logger.info(f"Processing tool call: {func_name}, args: {args}")
                     if func_name == "cut_text":
                         result = self.editor.cut(args["chunk_id"], args["start"], args["end"])
                         self.memory.add_chunk(f"Cut result: {result}", "system")
@@ -265,6 +309,7 @@ class OpenAIApi:
             
         except Exception as e:
             error_msg = f"API Error: {str(e)}"
+            logger.error(f"API request failed: {error_msg}, endpoint: {self.client.azure_endpoint}, model: {self.model}")
             self.memory.add_chunk(error_msg, "system")
             return {"error": error_msg}
 
@@ -274,16 +319,29 @@ async def chat_submit(user_input, chat_history, preprompt):
     response = await api.fetch_response(user_input)
     if "error" in response:
         chat_history.append({"role": "assistant", "content": f"Error: {response['error']}"})
+        logger.warning(f"Chat error: {response['error']}")
     else:
         chat_history.append({"role": "user", "content": user_input})
         chat_history.append({"role": "assistant", "content": response["content"]})
+        logger.info("Chat response added to history")
     return chat_history, preprompt
 
 def get_history():
     memory = ConversationMemory()
     return memory.get_recent_chunks(limit=10)
 
+def get_logs():
+    try:
+        with open("app.log", "r") as f:
+            logs = f.read()
+        logger.info("Retrieved logs from app.log")
+        return logs
+    except Exception as e:
+        logger.error(f"Failed to read logs: {str(e)}")
+        return f"Error reading logs: {str(e)}"
+
 def select_chunk(evt: gr.SelectData):
+    logger.info(f"Selected chunk: {evt.value['chunk_id']}")
     return evt.value["chunk_id"], evt.value["text"]
 
 async def edit_cut(chunk_id, start, end):
@@ -361,10 +419,17 @@ def create_ui():
             prefix_btn.click(fn=edit_prefix, inputs=[chunk_id, prefix], outputs=[chunk_text, diff_output])
             suffix_btn.click(fn=edit_suffix, inputs=[chunk_id, suffix], outputs=[chunk_text, diff_output])
         
+        with gr.Tab("Logs"):
+            logs = gr.Textbox(label="Application Logs", interactive=False)
+            logs_btn = gr.Button("Refresh Logs")
+            logs_btn.click(fn=get_logs, outputs=logs)
+        
         gr.Markdown(f"Current Time: {datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S %Z')}")
     
+    logger.info("Created Gradio UI")
     return demo
 
 if __name__ == "__main__":
+    logger.info("Starting application")
     demo = create_ui()
     demo.launch(server_name="0.0.0.0", server_port=7860)