Update src/streamlit_app.py

src/streamlit_app.py

@@ -4,9 +4,9 @@ import os
 import asyncio
 import base64
 import io
-import atexit
 import threading
 import traceback
+import atexit # Correctly imported
 import time
 import logging
 from dotenv import load_dotenv
@@ -24,8 +24,9 @@ from streamlit_webrtc import (
     WebRtcMode,
     AudioProcessorBase,
     VideoProcessorBase,
+    # ClientSettings # Removed as it's not used in this version
 )
-from aiortc import RTCIceServer, RTCConfiguration # For STUN server configuration
+# from aiortc import RTCIceServer, RTCConfiguration # RTCConfiguration object not needed directly for webrtc_streamer
 
 # --- Configuration ---
 load_dotenv()
@@ -42,8 +43,8 @@ AUDIO_PLAYBACK_QUEUE_MAXSIZE = 50
 MEDIA_TO_GEMINI_QUEUE_MAXSIZE = 30
 
 # Video configuration
-VIDEO_FPS_TO_GEMINI = 2  # Target FPS to send to Gemini (increased slightly)
-VIDEO_API_RESIZE = (1024, 1024) # Max size for images sent to API
+VIDEO_FPS_TO_GEMINI = 2
+VIDEO_API_RESIZE = (1024, 1024)
 
 MODEL_NAME = "models/gemini-2.0-flash-live-001"
 
@@ -67,7 +68,7 @@ Example of a disclaimer you might use: "As an AI assistant, I can describe what
 pya = pyaudio.PyAudio()
 def cleanup_pyaudio():
     logging.info("Terminating PyAudio instance.")
-    if pya: # Check if pya is not None
+    if pya:
         pya.terminate()
 atexit.register(cleanup_pyaudio)
 
@@ -83,10 +84,9 @@ if GEMINI_API_KEY:
     try:
         client = genai.Client(http_options={"api_version": "v1beta"}, api_key=GEMINI_API_KEY)
     except Exception as e:
-        # This error will be shown in Streamlit UI if it happens at startup
         st.error(f"Failed to initialize Gemini client: {e}")
         logging.critical(f"Gemini client initialization failed: {e}", exc_info=True)
-        st.stop() # Stop Streamlit app if client fails
+        st.stop()
 else:
     st.error("GEMINI_API_KEY not found in environment variables. Please set it for the application to run.")
     logging.critical("GEMINI_API_KEY not found.")
@@ -166,7 +166,6 @@ class GeminiInteractionLoop:
                             logging.info(f"Gemini text response: {text_response[:100]}")
                             if 'chat_messages' not in st.session_state: st.session_state.chat_messages = []
                             st.session_state.chat_messages = st.session_state.chat_messages + [{"role": "assistant", "content": text_response}]
-                            # Consider st.experimental_rerun() if a mechanism exists to call it from main thread
                 except types.generation_types.StopCandidateException: logging.info("Gemini response stream ended normally.")
                 except Exception as e:
                     if self.is_running: logging.error(f"Error receiving from Gemini: {e}", exc_info=True)
@@ -184,7 +183,7 @@ class GeminiInteractionLoop:
             while self.is_running:
                 try:
                     audio_chunk = await asyncio.wait_for(audio_from_gemini_playback_q.get(), timeout=1.0)
-                    if audio_chunk: # Not None (sentinel)
+                    if audio_chunk:
                         await asyncio.to_thread(self.playback_stream.write, audio_chunk)
                     if audio_chunk: audio_from_gemini_playback_q.task_done()
                 except asyncio.TimeoutError: continue
@@ -204,17 +203,15 @@ class GeminiInteractionLoop:
         logging.info("Signal to stop GeminiInteractionLoop received.")
         self.is_running = False
         for q in [video_frames_to_gemini_q, audio_chunks_to_gemini_q, audio_from_gemini_playback_q]:
-            try: q.put_nowait(None) # Sentinel to unblock .get()
+            try: q.put_nowait(None)
             except asyncio.QueueFull: logging.warning(f"Queue was full when trying to put sentinel for stop signal.")
             except Exception as e: logging.error(f"Error putting sentinel in queue: {e}", exc_info=True)
 
-
     async def run_main_loop(self):
         self.async_event_loop = asyncio.get_running_loop()
         self.is_running = True
         logging.info("GeminiInteractionLoop run_main_loop starting...")
         if client is None:
-
             logging.critical("Gemini client is None in run_main_loop. Aborting.")
             return
 
@@ -255,7 +252,6 @@ class VideoProcessor(VideoProcessorBase):
     def __init__(self):
         self.frame_counter = 0
         self.last_gemini_send_time = time.monotonic()
-        # No need to get loop here if create_task is used on the default loop
 
     async def _process_and_queue_frame_async(self, frame_ndarray):
         self.frame_counter += 1
@@ -279,28 +275,15 @@ class VideoProcessor(VideoProcessorBase):
             video_frames_to_gemini_q.put_nowait(api_data)
         except Exception as e: logging.error(f"Error processing/queueing video frame: {e}", exc_info=True)
 
-    async def recv(self, frame): # Called by streamlit-webrtc
+    async def recv(self, frame):
         img_bgr = frame.to_ndarray(format="bgr24")
         asyncio.create_task(self._process_and_queue_frame_async(img_bgr))
-        return frame # Return original frame for WebRTC to display
+        return frame
 
 class AudioProcessor(AudioProcessorBase):
     async def _process_and_queue_audio_async(self, audio_frames):
-        for frame in audio_frames: # frame is an AudioFrame from aiortc
-            # frame.planes[0].to_bytes() is the raw audio data
-            # frame.sample_rate, frame.layout.channels
-            # logging.info(f"Audio frame: {len(frame.planes[0].to_bytes())} bytes, SR={frame.sample_rate}, C={frame.layout.channels}")
-            
-            # CRITICAL NOTE: This sends audio as received from WebRTC.
-            # If Gemini requires a specific sample rate (e.g., 16000 Hz) and WebRTC provides
-            # a different one (e.g., 48000 Hz), audio recognition may be poor.
-            # Proper solution: Implement resampling here. This is omitted for brevity.
+        for frame in audio_frames:
             audio_data = frame.planes[0].to_bytes()
-            # Mime type should reflect the actual data being sent.
-            # Example: "audio/L16;rate=48000;channels=1" if that's what WebRTC provides.
-            # Gemini documentation should specify what it accepts for PCM.
-            # Assuming "audio/pcm" is generic enough, or be more specific.
-            # Forcing L16 (16-bit linear PCM) as that's common.
             mime_type = f"audio/L16;rate={frame.sample_rate};channels={frame.layout.channels}"
             api_data = {"data": audio_data, "mime_type": mime_type}
 
@@ -311,7 +294,7 @@ class AudioProcessor(AudioProcessorBase):
                 audio_chunks_to_gemini_q.put_nowait(api_data)
             except Exception as e: logging.error(f"Error queueing audio chunk: {e}", exc_info=True)
     
-    async def recv(self, frames): # Called by streamlit-webrtc
+    async def recv(self, frames):
         asyncio.create_task(self._process_and_queue_audio_async(frames))
         return frames
 
@@ -321,7 +304,7 @@ def initialize_app_session_state():
         'gemini_session_active': False,
         'gemini_loop_instance': None,
         'chat_messages': [],
-        'webrtc_component_key': f"webrtc_streamer_key_{int(time.time())}", # Initial dynamic key
+        'webrtc_component_key': f"webrtc_streamer_key_{int(time.time())}",
     }
     for key, value in defaults.items():
         if key not in st.session_state:
@@ -329,7 +312,7 @@ def initialize_app_session_state():
 
 def run_streamlit_app():
     st.set_page_config(page_title="Live AI Medical Assistant (HF Spaces)", layout="wide")
-    initialize_app_session_state() # Ensure state is initialized
+    initialize_app_session_state()
 
     st.title("Live AI Medical Assistant")
     st.markdown("Utilizing Gemini Live API via WebRTC on Hugging Face Spaces")
@@ -350,9 +333,9 @@ def run_streamlit_app():
                 st.session_state.gemini_loop_instance = gemini_loop
                 threading.Thread(target=lambda: asyncio.run(gemini_loop.run_main_loop()), name="GeminiLoopThread", daemon=True).start()
                 st.success("Gemini session starting... WebRTC will attempt to connect.")
-                st.session_state.webrtc_component_key = f"webrtc_streamer_key_{int(time.time())}" # Force re-render of WebRTC
+                st.session_state.webrtc_component_key = f"webrtc_streamer_key_{int(time.time())}"
                 st.rerun()
-        else: # Session is active
+        else:
             if st.button("🛑 Stop Session", type="secondary", use_container_width=True, key="stop_session_btn"):
                 if st.session_state.gemini_loop_instance:
                     st.session_state.gemini_loop_instance.signal_stop()
@@ -364,39 +347,40 @@ def run_streamlit_app():
 
     if st.session_state.gemini_session_active:
         st.subheader("Your Live Feed (from your browser)")
-        RTC_CONFIGURATION = RTCConfiguration({"iceServers": [{"urls": ["stun:stun.l.google.com:19302"]}]})
+        
         MEDIA_STREAM_CONSTRAINTS = {
-            "video": True, # Or specific constraints like {"width": 640, "height": 480}
-            "audio": { # Request specific audio format
+            "video": True, 
+            "audio": { 
                 "sampleRate": {"ideal": WEBRTC_REQUESTED_SEND_SAMPLE_RATE},
                 "channelCount": {"exact": WEBRTC_REQUESTED_AUDIO_CHANNELS},
-                "echoCancellation": True, # Recommended for voice
-                "noiseSuppression": True  # Recommended for voice
+                "echoCancellation": True, 
+                "noiseSuppression": True  
             }
         }
         
         webrtc_ctx = webrtc_streamer(
             key=st.session_state.webrtc_component_key,
             mode=WebRtcMode.SENDONLY,
-            rtc_configuration=RTC_CONFIGURATION,
+            rtc_configuration={ # MODIFIED HERE: Pass dictionary directly
+                "iceServers": [{"urls": ["stun:stun.l.google.com:19302"]}]
+            },
             media_stream_constraints=MEDIA_STREAM_CONSTRAINTS,
             video_processor_factory=VideoProcessor,
             audio_processor_factory=AudioProcessor,
             async_processing=True,
-            # desired_playing_state=st.session_state.gemini_session_active # Let it be controlled by rendering
         )
 
         if webrtc_ctx.state.playing:
             st.caption("WebRTC connected. Streaming your camera and microphone.")
         elif st.session_state.gemini_session_active:
             st.caption("WebRTC attempting to connect. Ensure camera/microphone permissions are granted in your browser.")
-            if webrtc_ctx.state.error:
+            if hasattr(webrtc_ctx.state, 'error') and webrtc_ctx.state.error: # Check if error attribute exists
                 st.error(f"WebRTC Connection Error: {webrtc_ctx.state.error}")
     else:
         st.info("Click 'Start Session' in the sidebar to enable the live feed and assistant.")
 
     st.subheader("Chat with Assistant")
-    chat_placeholder = st.container() # Use a container for chat messages
+    chat_placeholder = st.container() 
     with chat_placeholder:
         for msg in st.session_state.get('chat_messages', []):
             with st.chat_message(msg["role"]):
@@ -427,7 +411,7 @@ def run_streamlit_app():
         st.rerun()
 
 if __name__ == "__main__":
-    if client is None: # Final check before running
+    if client is None:
         logging.critical("Gemini client could not be initialized. Application cannot start.")
     else:
         run_streamlit_app()