Private-AI

Running

App Files Files Community

seawolf2357 commited on 9 days ago

Commit

1283bb7

verified ·

1 Parent(s): f98e6c2

Update app.py

Browse files

Files changed (1) hide show

app.py +106 -40

app.py CHANGED Viewed

@@ -755,6 +755,13 @@ HTML_CONTENT = """<!DOCTYPE html>
             const message = textInput.value.trim();
             if (!message) return;
             // Add user message to chat
             addMessage('user', message);
             textInput.value = '';
@@ -1246,13 +1253,18 @@ class PersonalAssistantDB:
     @staticmethod
     async def save_message(session_id: str, role: str, content: str):
         """Save a message to the database"""
         # Detect language
         detected_language = None
         try:
             if content and len(content) > 10:
                 detected_language = detect(content)
-        except LangDetectException:
-            pass
         async with aiosqlite.connect(DB_PATH) as db:
             await db.execute(
@@ -1390,7 +1402,7 @@ class PersonalAssistantDB:
         # Prepare conversation text for analysis
         conversation_text = "\n".join([
             f"{msg['role']}: {msg['content']}"
-            for msg in messages
         ])
         # Use GPT to extract memories
@@ -1484,10 +1496,11 @@ def format_memories_for_prompt(memories: Dict[str, List[str]]) -> str:
     memory_text = "\n\n=== 기억된 정보 ===\n"
     for category, items in memories.items():
-        if items:
             memory_text += f"\n[{category}]\n"
             for item in items:
-                memory_text += f"- {item}\n"
     return memory_text
@@ -1496,6 +1509,10 @@ async def process_text_chat(message: str, web_search_enabled: bool, session_id:
                           user_name: str = "", memories: Dict = None) -> Dict[str, str]:
     """Process text chat using GPT-4o-mini model"""
     try:
         # Check for stop words
         stop_words = ["중단", "그만", "스톱", "stop", "닥쳐", "멈춰", "중지"]
         if any(word in message.lower() for word in stop_words):
@@ -1519,7 +1536,7 @@ IMPORTANT: Give only ONE response. Do not repeat or give multiple answers."""
         messages = [{"role": "system", "content": base_prompt}]
         # Handle web search if enabled
-        if web_search_enabled and search_client:
             search_keywords = ["날씨", "기온", "비", "눈", "뉴스", "소식", "현재", "최근",
                              "오늘", "지금", "가격", "환율", "주가", "weather", "news",
                              "current", "today", "price", "2024", "2025"]
@@ -1729,24 +1746,53 @@ IMPORTANT: Give only ONE response per user input. Do not repeat yourself or give
                 "voice": "alloy"
             }
-            await conn.session.update(session=session_update)
-            self.connection = conn
-            print(f"Connected with tools: {len(tools)} functions")
             async for event in self.connection:
-                # Handle user transcription for stop detection
-                if event.type == "conversation.item.created":
                     if hasattr(event, 'item') and hasattr(event.item, 'role') and event.item.role == "user":
                         if hasattr(event.item, 'content') and event.item.content:
                             for content_item in event.item.content:
-                                if hasattr(content_item, 'transcript'):
                                     user_text = content_item.transcript.lower()
                                     stop_words = ["중단", "그만", "스톱", "stop", "닥쳐", "멈춰", "중지"]
                                     if any(word in user_text for word in stop_words):
                                         print(f"[STOP DETECTED] User said: {content_item.transcript}")
                                         self.should_stop = True
-                                        # Cancel any ongoing response
                                         if self.connection:
                                             try:
                                                 await self.connection.response.cancel()
@@ -1758,25 +1804,25 @@ IMPORTANT: Give only ONE response per user input. Do not repeat yourself or give
                                     if self.session_id:
                                         await PersonalAssistantDB.save_message(self.session_id, "user", content_item.transcript)
-                if event.type == "response.audio_transcript.done":
                     # Prevent multiple responses
                     if self.is_responding:
                         print("[DUPLICATE RESPONSE] Skipping duplicate response")
                         continue
                     self.is_responding = True
-                    print(f"[RESPONSE] Transcript: {event.transcript[:100]}...")
                     # Detect language
                     detected_language = None
                     try:
                         if event.transcript and len(event.transcript) > 10:
                             detected_language = detect(event.transcript)
-                    except:
-                        pass
                     # Save to database
-                    if self.session_id:
                         await PersonalAssistantDB.save_message(self.session_id, "assistant", event.transcript)
                     output_data = {
@@ -1796,14 +1842,20 @@ IMPORTANT: Give only ONE response per user input. Do not repeat yourself or give
                     if self.should_stop:
                         continue
-                    await self.output_queue.put(
-                        (
-                            self.output_sample_rate,
-                            np.frombuffer(
-                                base64.b64decode(event.delta), dtype=np.int16
-                            ).reshape(1, -1),
-                        ),
-                    )
                 # Handle function calls
                 elif event.type == "response.function_call_arguments.start":
@@ -1856,7 +1908,15 @@ IMPORTANT: Give only ONE response per user input. Do not repeat yourself or give
             print(f"[RECEIVE] No connection, skipping")
             return
         try:
             _, array = frame
             array = array.squeeze()
             audio_message = base64.b64encode(array.tobytes()).decode("utf-8")
             await self.connection.input_audio_buffer.append(audio=audio_message)
@@ -1908,20 +1968,26 @@ stream.mount(app)
 # Initialize database on startup
 @app.on_event("startup")
 async def startup_event():
-    await PersonalAssistantDB.init()
-    print(f"Database initialized at: {DB_PATH}")
-    print(f"Persistent directory: {PERSISTENT_DIR}")
-    print(f"DB file exists: {os.path.exists(DB_PATH)}")
-    # Check if we're in Hugging Face Space
-    if os.path.exists("/data"):
-        print("Running in Hugging Face Space with persistent storage")
-        # List files in persistent directory
-        try:
-            files = os.listdir(PERSISTENT_DIR)
-            print(f"Files in persistent directory: {files}")
-        except Exception as e:
-            print(f"Error listing files: {e}")
 # Intercept offer to capture settings
 @app.post("/webrtc/offer", include_in_schema=False)

             const message = textInput.value.trim();
             if (!message) return;
+            // Check for stop words
+            const stopWords = ["중단", "그만", "스톱", "stop", "닥쳐", "멈춰", "중지"];
+            if (stopWords.some(word => message.toLowerCase().includes(word))) {
+                addMessage('assistant', '대화를 중단합니다.');
+                return;
+            }
             // Add user message to chat
             addMessage('user', message);
             textInput.value = '';
     @staticmethod
     async def save_message(session_id: str, role: str, content: str):
         """Save a message to the database"""
+        # Check for None or empty content
+        if not content:
+            print(f"[SAVE_MESSAGE] Empty content for {role} message, skipping")
+            return
         # Detect language
         detected_language = None
         try:
             if content and len(content) > 10:
                 detected_language = detect(content)
+        except (LangDetectException, Exception) as e:
+            print(f"Language detection error: {e}")
         async with aiosqlite.connect(DB_PATH) as db:
             await db.execute(
         # Prepare conversation text for analysis
         conversation_text = "\n".join([
             f"{msg['role']}: {msg['content']}"
+            for msg in messages if msg.get('content')
         ])
         # Use GPT to extract memories
     memory_text = "\n\n=== 기억된 정보 ===\n"
     for category, items in memories.items():
+        if items and isinstance(items, list):
             memory_text += f"\n[{category}]\n"
             for item in items:
+                if item:  # Check if item is not None or empty
+                    memory_text += f"- {item}\n"
     return memory_text
                           user_name: str = "", memories: Dict = None) -> Dict[str, str]:
     """Process text chat using GPT-4o-mini model"""
     try:
+        # Check for empty or None message
+        if not message:
+            return {"error": "메시지가 비어있습니다."}
         # Check for stop words
         stop_words = ["중단", "그만", "스톱", "stop", "닥쳐", "멈춰", "중지"]
         if any(word in message.lower() for word in stop_words):
         messages = [{"role": "system", "content": base_prompt}]
         # Handle web search if enabled
+        if web_search_enabled and search_client and message:
             search_keywords = ["날씨", "기온", "비", "눈", "뉴스", "소식", "현재", "최근",
                              "오늘", "지금", "가격", "환율", "주가", "weather", "news",
                              "current", "today", "price", "2024", "2025"]
                 "voice": "alloy"
             }
+            try:
+                await conn.session.update(session=session_update)
+                self.connection = conn
+                print(f"Connected with tools: {len(tools)} functions")
+                print(f"Session update successful")
+            except Exception as e:
+                print(f"Error updating session: {e}")
+                raise
             async for event in self.connection:
+                # Debug log for all events
+                if hasattr(event, 'type'):
+                    if event.type not in ["response.audio.delta", "response.audio.done"]:
+                        print(f"[EVENT] Type: {event.type}")
+                # Handle user input audio transcription
+                if event.type == "conversation.item.input_audio_transcription.completed":
+                    if hasattr(event, 'transcript') and event.transcript:
+                        user_text = event.transcript.lower()
+                        stop_words = ["중단", "그만", "스톱", "stop", "닥쳐", "멈춰", "중지"]
+                        if any(word in user_text for word in stop_words):
+                            print(f"[STOP DETECTED] User said: {event.transcript}")
+                            self.should_stop = True
+                            if self.connection:
+                                try:
+                                    await self.connection.response.cancel()
+                                except:
+                                    pass
+                            continue
+                        # Save user message to database
+                        if self.session_id:
+                            await PersonalAssistantDB.save_message(self.session_id, "user", event.transcript)
+                # Handle user transcription for stop detection (alternative event)
+                elif event.type == "conversation.item.created":
                     if hasattr(event, 'item') and hasattr(event.item, 'role') and event.item.role == "user":
                         if hasattr(event.item, 'content') and event.item.content:
                             for content_item in event.item.content:
+                                if hasattr(content_item, 'transcript') and content_item.transcript:
                                     user_text = content_item.transcript.lower()
                                     stop_words = ["중단", "그만", "스톱", "stop", "닥쳐", "멈춰", "중지"]
                                     if any(word in user_text for word in stop_words):
                                         print(f"[STOP DETECTED] User said: {content_item.transcript}")
                                         self.should_stop = True
                                         if self.connection:
                                             try:
                                                 await self.connection.response.cancel()
                                     if self.session_id:
                                         await PersonalAssistantDB.save_message(self.session_id, "user", content_item.transcript)
+                elif event.type == "response.audio_transcript.done":
                     # Prevent multiple responses
                     if self.is_responding:
                         print("[DUPLICATE RESPONSE] Skipping duplicate response")
                         continue
                     self.is_responding = True
+                    print(f"[RESPONSE] Transcript: {event.transcript[:100] if event.transcript else 'None'}...")
                     # Detect language
                     detected_language = None
                     try:
                         if event.transcript and len(event.transcript) > 10:
                             detected_language = detect(event.transcript)
+                    except Exception as e:
+                        print(f"Language detection error: {e}")
                     # Save to database
+                    if self.session_id and event.transcript:
                         await PersonalAssistantDB.save_message(self.session_id, "assistant", event.transcript)
                     output_data = {
                     if self.should_stop:
                         continue
+                    if hasattr(event, 'delta'):
+                        await self.output_queue.put(
+                            (
+                                self.output_sample_rate,
+                                np.frombuffer(
+                                    base64.b64decode(event.delta), dtype=np.int16
+                                ).reshape(1, -1),
+                            ),
+                        )
+                # Handle errors
+                elif event.type == "error":
+                    print(f"[ERROR] {event}")
+                    self.is_responding = False
                 # Handle function calls
                 elif event.type == "response.function_call_arguments.start":
             print(f"[RECEIVE] No connection, skipping")
             return
         try:
+            if frame is None or len(frame) < 2:
+                print(f"[RECEIVE] Invalid frame")
+                return
             _, array = frame
+            if array is None:
+                print(f"[RECEIVE] Null array")
+                return
             array = array.squeeze()
             audio_message = base64.b64encode(array.tobytes()).decode("utf-8")
             await self.connection.input_audio_buffer.append(audio=audio_message)
 # Initialize database on startup
 @app.on_event("startup")
 async def startup_event():
+    try:
+        await PersonalAssistantDB.init()
+        print(f"Database initialized at: {DB_PATH}")
+        print(f"Persistent directory: {PERSISTENT_DIR}")
+        print(f"DB file exists: {os.path.exists(DB_PATH)}")
+        # Check if we're in Hugging Face Space
+        if os.path.exists("/data"):
+            print("Running in Hugging Face Space with persistent storage")
+            # List files in persistent directory
+            try:
+                files = os.listdir(PERSISTENT_DIR)
+                print(f"Files in persistent directory: {files}")
+            except Exception as e:
+                print(f"Error listing files: {e}")
+    except Exception as e:
+        print(f"Error during startup: {e}")
+        # Try to create directory if it doesn't exist
+        os.makedirs(PERSISTENT_DIR, exist_ok=True)
+        await PersonalAssistantDB.init()
 # Intercept offer to capture settings
 @app.post("/webrtc/offer", include_in_schema=False)