Check point 4

app.py

@@ -16,7 +16,7 @@ import asyncio
 import uvicorn
 from queue import Queue
 import logging
-from gradio_webrtc import WebRTC
+from fastrtc import WebRTC
 
 # Set up logging
 logging.basicConfig(level=logging.INFO)
@@ -331,47 +331,10 @@ class RealtimeSpeakerDiarization:
             logger.error(f"Model initialization error: {e}")
             return False
     
-    def feed_audio(self, audio_data):
-        """Feed audio data directly to the recorder for live transcription"""
-        if not self.is_running or not self.recorder:
-            return
-            
-        try:
-            # Normalize if needed
-            if isinstance(audio_data, np.ndarray):
-                if audio_data.dtype != np.float32:
-                    audio_data = audio_data.astype(np.float32)
-                
-                # Convert to int16 for the recorder
-                audio_int16 = (audio_data * 32767).astype(np.int16)
-                audio_bytes = audio_int16.tobytes()
-                
-                # Feed to recorder
-                self.recorder.feed_audio(audio_bytes)
-                
-                # Also process for speaker detection
-                self.process_audio_chunk(audio_data)
-                
-            elif isinstance(audio_data, bytes):
-                # Feed raw bytes directly
-                self.recorder.feed_audio(audio_data)
-                
-                # Convert to float for speaker detection
-                audio_int16 = np.frombuffer(audio_data, dtype=np.int16)
-                audio_float = audio_int16.astype(np.float32) / 32768.0
-                self.process_audio_chunk(audio_float)
-                
-            logger.debug("Audio fed to recorder")
-        except Exception as e:
-            logger.error(f"Error feeding audio: {e}")
-    
     def live_text_detected(self, text):
         """Callback for real-time transcription updates"""
         with self.transcription_lock:
             self.last_transcription = text.strip()
-            
-        # Update the display immediately on new transcription
-        self.update_conversation_display()
     
     def process_final_text(self, text):
         """Process final transcribed text with speaker embedding"""
@@ -626,33 +589,18 @@ class DiarizationHandler(AsyncStreamHandler):
             # Extract audio data
             audio_data = getattr(frame, 'data', frame)
             
-            # Check if this is a tuple (sample_rate, audio_array)
-            if isinstance(audio_data, tuple) and len(audio_data) >= 2:
-                sample_rate, audio_array = audio_data
+            # Convert to numpy array
+            if isinstance(audio_data, bytes):
+                audio_array = np.frombuffer(audio_data, dtype=np.int16).astype(np.float32) / 32768.0
+            elif isinstance(audio_data, (list, tuple)):
+                audio_array = np.array(audio_data, dtype=np.float32)
             else:
-                # If not a tuple, assume it's raw audio bytes/array
-                sample_rate = SAMPLE_RATE  # Use default sample rate
-                
-                # Convert to numpy array
-                if isinstance(audio_data, bytes):
-                    audio_array = np.frombuffer(audio_data, dtype=np.int16).astype(np.float32) / 32768.0
-                elif isinstance(audio_data, (list, tuple)):
-                    audio_array = np.array(audio_data, dtype=np.float32)
-                else:
-                    audio_array = np.array(audio_data, dtype=np.float32)
+                audio_array = np.array(audio_data, dtype=np.float32)
             
             # Ensure 1D
             if len(audio_array.shape) > 1:
                 audio_array = audio_array.flatten()
             
-            # Send audio to recorder for live transcription
-            if self.diarization_system.recorder:
-                try:
-                    self.diarization_system.recorder.feed_audio(audio_array)
-                    logger.info("Fed audio to recorder")
-                except Exception as e:
-                    logger.error(f"Error feeding audio to recorder: {e}")
-            
             # Buffer audio chunks
             self.audio_buffer.extend(audio_array)
             
@@ -679,20 +627,11 @@ class DiarizationHandler(AsyncStreamHandler):
             )
         except Exception as e:
             logger.error(f"Error in async audio processing: {e}")
-            
-    async def start_up(self):
-        logger.info("DiarizationHandler started")
-        
-    async def shutdown(self):
-        logger.info("DiarizationHandler shutdown")
 
 
 # Global instances
 diarization_system = RealtimeSpeakerDiarization()
-
-# We'll initialize the stream in initialize_system()
-# For now, just create a placeholder
-stream = None
+audio_handler = None
 
 def initialize_system():
     """Initialize the diarization system"""
@@ -700,18 +639,8 @@ def initialize_system():
     try:
         success = diarization_system.initialize_models()
         if success:
-            # Create a DiarizationHandler linked to our system
-            handler = DiarizationHandler(diarization_system)
-            # Update the Stream's handler
-            stream = Stream(
-                handler=handler,
-                modality="audio",
-                mode="send-receive"
-            )
-            
-            # Mount the stream to the FastAPI app
-            stream.mount(app)
-            
+            # Update the Stream's handler to use our DiarizationHandler
+            stream.handler = DiarizationHandler(diarization_system)
             return "✅ System initialized successfully!"
         else:
             return "❌ Failed to initialize system. Check logs for details."
@@ -777,11 +706,11 @@ def create_interface():
         
         with gr.Row():
             with gr.Column(scale=2):
-                # Replace standard Audio with WebRTC component
-                audio_component = WebRTC(
+                # Replace WebRTC with standard Gradio audio component
+                audio_component = gr.Audio(
                     label="Audio Input",
-                    modality="audio",
-                    mode="send-receive"
+                    sources=["microphone"],
+                    streaming=True
                 )
                 
                 # Conversation display
@@ -912,15 +841,50 @@ def create_interface():
         status_timer = gr.Timer(2)
         status_timer.tick(refresh_status, outputs=[status_output])
 
+        # Process audio from Gradio component
+        def process_audio_input(audio_data):
+            if audio_data is not None and diarization_system.is_running:
+                # Extract audio data
+                if isinstance(audio_data, tuple) and len(audio_data) >= 2:
+                    sample_rate, audio_array = audio_data[0], audio_data[1]
+                    diarization_system.process_audio_chunk(audio_array, sample_rate)
+            return get_conversation()
+        
+        # Connect audio component to processing function
+        audio_component.stream(
+            fn=process_audio_input,
+            outputs=[conversation_output]
+        )
+
     return interface
 
 
 # FastAPI setup for FastRTC integration
 app = FastAPI()
 
-# We'll initialize the stream in initialize_system()
-# For now, just create a placeholder
-stream = None
+# Create a placeholder handler - will be properly initialized later
+class DefaultHandler(AsyncStreamHandler):
+    def __init__(self):
+        super().__init__()
+    
+    async def receive(self, frame):
+        pass
+    
+    async def emit(self):
+        return None
+    
+    def copy(self):
+        return DefaultHandler()
+    
+    async def shutdown(self):
+        pass
+    
+    async def start_up(self):
+        pass
+
+# Initialize with placeholder handler
+stream = Stream(handler=DefaultHandler(), modality="audio", mode="send-receive")
+stream.mount(app)
 
 @app.get("/")
 async def root():