Update app.py

app.py

@@ -1,42 +1,160 @@
 import gradio as gr
 from ultralytics import YOLO
+from typing import List
+import time
 
 model = YOLO("yolo11n.pt")
 
-def create_minimal_chat_interface():
-    """Create a stripped-down minimal chat interface for debugging."""
+
+def create_chat_interface():
+    """Create a minimal chat interface that mirrors the original structure."""
     
     with gr.Blocks() as demo:
-        # Basic chatbot with no additional parameters
+        # Match the original chatbot structure
         chatbot = gr.Chatbot(
             show_label=False,
         )
         
-        # Simple textbox for input
         msg = gr.Textbox(
             show_label=False, 
             placeholder="Type your message here..."
         )
         
-        def respond(message, chat_history):
-            """Simple echo function for testing."""
-            chat_history.append((message, f"You said: {message}"))
-            return "", chat_history
+        # Keep all the original state objects
+        transcript_processor_state = gr.State()
+        call_id_state = gr.State()
+        colab_id_state = gr.State()
+        origin_state = gr.State()
+        ct_state = gr.State()
+        turl_state = gr.State()
+        uid_state = gr.State()
+        
+        # Keep the streaming functionality
+        def respond(
+            message: str,
+            chat_history: List,
+            transcript_processor,
+            cid,
+            rsid,
+            origin,
+            ct,
+            uid,
+        ):
+            if not transcript_processor:
+                bot_message = "Transcript processor not initialized."
+                chat_history.append((message, bot_message))
+                return "", chat_history
+
+            chat_history.append((message, ""))
+            # Simulate streaming with a simple loop
+            for i in range(5):
+                partial_response = f"Processing... {i+1}/5"
+                chat_history[-1] = (message, partial_response)
+                yield "", chat_history
+                time.sleep(0.3)
+            
+            # Final response
+            final_response = f"Processed message: {message}\nWith call_id: {cid}"
+            chat_history[-1] = (message, final_response)
+            yield "", chat_history
         
+        # Keep the exact same function call structure
         msg.submit(
             respond,
-            [msg, chatbot],
+            [
+                msg,
+                chatbot,
+                transcript_processor_state,
+                call_id_state,
+                colab_id_state,
+                origin_state,
+                ct_state,
+                uid_state,
+            ],
             [msg, chatbot],
         )
         
-        # Simple load function with no request parameter
-        def on_load():
-            chatbot_value = [(None, "Welcome! This is a minimal test interface.")]
-            return chatbot_value
+        # Match the original on_app_load function
+        def on_app_load(request: gr.Request):
+            # Simplified parameter handling
+            cid = "test_cid"
+            rsid = "test_rsid"
+            origin = "test_origin"
+            ct = "test_ct"
+            turl = "test_turl"
+            uid = "test_uid"
+            
+            # Create a dummy transcript processor
+            transcript_processor = {"initialized": True}
+            
+            # Initialize with welcome message
+            chatbot_value = [(None, "Welcome to the debug interface")]
+            
+            return [
+                chatbot_value,
+                transcript_processor,
+                cid,
+                rsid,
+                origin,
+                ct,
+                turl,
+                uid,
+            ]
         
+        def display_processing_message(chatbot_value):
+            """Display the processing message while maintaining state."""
+            # Create new chatbot value with processing message
+            new_chatbot_value = [
+                (None, "Processing... Please wait...")
+            ]
+            return new_chatbot_value
+        
+        def stream_initial_analysis(
+            chatbot_value, transcript_processor, cid, rsid, origin, ct, uid
+        ):
+            if not transcript_processor:
+                return chatbot_value
+            
+            # Simulate streaming with a simple loop
+            for i in range(3):
+                # Update the existing message
+                chatbot_value[0] = (None, f"Initial analysis step {i+1}/3...")
+                yield chatbot_value
+                time.sleep(0.5)
+            
+            # Final message
+            chatbot_value[0] = (None, "Ready to chat! Call ID: " + cid)
+            yield chatbot_value
+        
+        # Keep the exact same load chain
         demo.load(
-            on_load,
+            on_app_load,
             inputs=None,
+            outputs=[
+                chatbot,
+                transcript_processor_state,
+                call_id_state,
+                colab_id_state,
+                origin_state,
+                ct_state,
+                turl_state,
+                uid_state,
+            ],
+        ).then(
+            display_processing_message,
+            inputs=[chatbot],
+            outputs=[chatbot],
+        ).then(
+            stream_initial_analysis,
+            inputs=[
+                chatbot,
+                transcript_processor_state,
+                call_id_state,
+                colab_id_state,
+                origin_state,
+                ct_state,
+                uid_state,
+            ],
             outputs=[chatbot],
         )
     
@@ -44,5 +162,5 @@ def create_minimal_chat_interface():
 
 # Launch the application
 if __name__ == "__main__":
-    app = create_minimal_chat_interface()
-    app.launch()
+    app = create_chat_interface()
+    app.launch()