Update stt_google.py

stt_google.py

@@ -110,116 +110,120 @@ class GoogleCloudSTT(STTInterface):
             log_error(f"❌ Error queuing result: {e}")
     
     def _run_stream(self):
-        """Run the streaming recognition in a separate thread"""
-        try:
-            log_info("🎤 Google STT stream thread started")
-            
-            def request_generator():
-                """Generate streaming requests"""
-                chunk_count = 0
-                start_time = datetime.now()
+            """Run the streaming recognition in a separate thread"""
+            try:
+                log_info("🎤 Google STT stream thread started")
                 
-                while not self.stop_event.is_set():
-                    try:
-                        # 5 dakika sınırına yaklaşıyorsak stream'i sonlandır
-                        elapsed = (datetime.now() - start_time).total_seconds()
-                        if elapsed > 280:  # 4 dakika 40 saniye - güvenli margin
-                            log_warning(f"⚠️ Approaching 5-minute limit ({elapsed:.1f}s), ending stream gracefully")
-                            break
-                        
-                        # Get audio chunk with timeout
-                        chunk = self.audio_queue.get(timeout=0.1)
-                        if chunk is None:  # Poison pill
-                            log_info("📛 Poison pill received, stopping request generator")
-                            break
-                        chunk_count += 1
-                        
-                        # Sadece önemli milestone'larda logla
-                        if chunk_count == 1:
-                            log_info(f"📤 First chunk sent to Google STT, size: {len(chunk)} bytes")
-                        elif chunk_count % 100 == 0:
-                            log_info(f"📤 Sent {chunk_count} chunks to Google STT (elapsed: {elapsed:.1f}s)")
+                def request_generator():
+                    """Generate streaming requests"""
+                    chunk_count = 0
+                    start_time = datetime.now()
+                    
+                    while not self.stop_event.is_set():
+                        try:
+                            # 5 dakika sınırına yaklaşıyorsak stream'i sonlandır
+                            elapsed = (datetime.now() - start_time).total_seconds()
+                            if elapsed > 280:  # 4 dakika 40 saniye - güvenli margin
+                                log_warning(f"⚠️ Approaching 5-minute limit ({elapsed:.1f}s), ending stream gracefully")
+                                break
                             
-                        yield speech.StreamingRecognizeRequest(audio_content=chunk)
-                    except queue.Empty:
-                        continue
-                    except Exception as e:
-                        log_error(f"❌ Error in request generator: {e}")
-                        break
-            
-            # Create streaming client
-            requests = request_generator()
-            
-            log_info("🎤 Creating Google STT streaming client...")
-            
-            try:
-                responses = self.client.streaming_recognize(self.streaming_config, requests)
-                log_info("✅ Google STT streaming client created")
+                            # Get audio chunk with timeout
+                            chunk = self.audio_queue.get(timeout=0.1)
+                            if chunk is None:  # Poison pill
+                                log_info("📛 Poison pill received, stopping request generator")
+                                break
+                            chunk_count += 1
+                            
+                            # Sadece önemli milestone'larda logla
+                            if chunk_count == 1:
+                                log_info(f"📤 First chunk sent to Google STT, size: {len(chunk)} bytes")
+                            elif chunk_count % 100 == 0:
+                                log_info(f"📤 Sent {chunk_count} chunks to Google STT (elapsed: {elapsed:.1f}s)")
+                                
+                            yield speech.StreamingRecognizeRequest(audio_content=chunk)
+                        except queue.Empty:
+                            continue
+                        except Exception as e:
+                            log_error(f"❌ Error in request generator: {e}")
+                            break
+                
+                # Create streaming client
+                requests = request_generator()
                 
-                # Process responses
-                response_count = 0
-                empty_response_count = 0
+                log_info("🎤 Creating Google STT streaming client...")
                 
-                for response in responses:
-                    response_count += 1
+                try:
+                    responses = self.client.streaming_recognize(self.streaming_config, requests)
+                    log_info("✅ Google STT streaming client created")
                     
-                    if self.stop_event.is_set():
-                        log_info("🛑 Stop event detected, breaking response loop")
-                        break
+                    # Process responses
+                    response_count = 0
+                    empty_response_count = 0
                     
-                    # Boş response'ları say ama loglama
-                    if not response.results:
-                        empty_response_count += 1
-                        if empty_response_count % 50 == 0:
-                            log_warning(f"⚠️ Received {empty_response_count} empty responses from Google STT")
-                        continue
+                    for response in responses:
+                        response_count += 1
                         
-                    for result in response.results:
-                        if not result.alternatives:
-                            continue
-                            
-                        # İlk alternatifi al
-                        alternative = result.alternatives[0]
+                        if self.stop_event.is_set():
+                            log_info("🛑 Stop event detected, breaking response loop")
+                            break
                         
-                        # Sadece anlamlı text'leri işle
-                        if alternative.transcript.strip():
-                            # Create transcription result
-                            transcription = TranscriptionResult(
-                                text=alternative.transcript,
-                                is_final=result.is_final,
-                                confidence=alternative.confidence if hasattr(alternative, 'confidence') and alternative.confidence else 0.0,
-                                timestamp=datetime.now().timestamp()
-                            )
+                        # Boş response'ları say ama loglama
+                        if not response.results:
+                            empty_response_count += 1
+                            if empty_response_count % 50 == 0:
+                                log_warning(f"⚠️ Received {empty_response_count} empty responses from Google STT")
+                            continue
                             
-                            # Put result in queue
-                            self._put_result(transcription)
+                        for result in response.results:
+                            if not result.alternatives:
+                                continue
+                                
+                            # İlk alternatifi al
+                            alternative = result.alternatives[0]
                             
-                            # SADECE final result'ları logla
-                            if result.is_final:
-                                log_info(f"🎯 GOOGLE STT FINAL: '{alternative.transcript}'")
+                            # Sadece anlamlı text'leri işle
+                            if alternative.transcript.strip():
+                                # Create transcription result
+                                transcription = TranscriptionResult(
+                                    text=alternative.transcript,
+                                    is_final=result.is_final,
+                                    confidence=alternative.confidence if hasattr(alternative, 'confidence') and alternative.confidence else 0.0,
+                                    timestamp=datetime.now().timestamp()
+                                )
+                                
+                                # Put result in queue
+                                self._put_result(transcription)
+                                
+                                # SADECE final result'ları logla
+                                if result.is_final:
+                                    log_info(f"🎯 GOOGLE STT FINAL: '{alternative.transcript}'")
                             
-                log_info(f"📊 Google STT stream ended. Total responses: {response_count}, Empty: {empty_response_count}")
+                    log_info(f"📊 Google STT stream ended. Total responses: {response_count}, Empty: {empty_response_count}")
                             
-            except Exception as e:
-                error_msg = str(e)
-                
-                # Detaylı hata mesajları
-                if "Exceeded maximum allowed stream duration" in error_msg:
-                    log_warning("⚠️ Stream duration limit exceeded (5 minutes). This is expected for long sessions.")
-                    # Bu bir error değil, normal davranış - result queue'ya error koymuyoruz
-                elif "Bad language code" in error_msg:
-                    log_error(f"❌ Invalid language code in STT config. Check locale settings.")
-                elif "invalid_argument" in error_msg:
-                    log_error(f"❌ Invalid STT configuration. Check encoding and sample rate.")
-                elif "Deadline Exceeded" in error_msg:
-                    log_error(f"❌ Google STT timeout - possibly network issue or slow connection")
-                else:
-                    log_error(f"❌ Google STT stream error: {error_msg}")
+                except Exception as e:
+                    error_msg = str(e)
+                    
+                    # Detaylı hata mesajları
+                    if "Exceeded maximum allowed stream duration" in error_msg:
+                        log_warning("⚠️ Stream duration limit exceeded (5 minutes). This is expected for long sessions.")
+                    elif "Bad language code" in error_msg:
+                        log_error(f"❌ Invalid language code in STT config. Check locale settings.")
+                    elif "invalid_argument" in error_msg:
+                        log_error(f"❌ Invalid STT configuration. Check encoding and sample rate.")
+                    elif "Deadline Exceeded" in error_msg:
+                        log_error(f"❌ Google STT timeout - possibly network issue or slow connection")
+                    elif "503" in error_msg or "Service Unavailable" in error_msg:
+                        log_error(f"❌ Google STT service temporarily unavailable. Will retry...")
+                    else:
+                        log_error(f"❌ Google STT stream error: {error_msg}")
                         
-        except Exception as e:
-            log_error(f"❌ Fatal error in STT stream thread", error=str(e), traceback=traceback.format_exc())
-        finally:
-            log_info("🎤 Google STT stream thread ended")
+            except Exception as e:
+                import traceback
+                log_error(f"❌ Fatal error in STT stream thread", error=str(e), traceback=traceback.format_exc())
+            finally:
+                log_info("🎤 Google STT stream thread ended")
+                # Thread bittiğinde streaming flag'ini kapat
+                self.is_streaming = False
             
     async def stream_audio(self, audio_chunk: bytes) -> AsyncIterator[TranscriptionResult]:
         """Stream audio chunk and get transcription results"""
@@ -246,39 +250,51 @@ class GoogleCloudSTT(STTInterface):
             raise
     
     async def stop_streaming(self) -> Optional[TranscriptionResult]:
-        """Stop streaming and get final result"""
-        if not self.is_streaming:
-            return None
-            
-        try:
-            log_info("🛑 Stopping Google STT streaming...")
-            
-            self.is_streaming = False
-            self.stop_event.set()
-            
-            # Send poison pill to queue
-            self.audio_queue.put(None)
-            
-            # Wait for thread to finish
-            if self.stream_thread:
-                self.stream_thread.join(timeout=5.0)
-            
-            # Clear queues
-            while not self.audio_queue.empty():
-                self.audio_queue.get_nowait()
+            """Stop streaming and get final result"""
+            if not self.is_streaming:
+                return None
                 
-            final_result = None
-            while not self.responses_queue.empty():
-                result = await self.responses_queue.get()
-                if result.is_final:
-                    final_result = result
-            
-            log_info("✅ Google STT streaming stopped")
-            return final_result
-            
-        except Exception as e:
-            log_error(f"❌ Failed to stop Google STT streaming", error=str(e))
-            return None
+            try:
+                log_info("🛑 Stopping Google STT streaming...")
+                
+                self.is_streaming = False
+                self.stop_event.set()
+                
+                # Send poison pill to queue
+                self.audio_queue.put(None)
+                
+                # Wait for thread to finish with longer timeout
+                if self.stream_thread and self.stream_thread.is_alive():
+                    self.stream_thread.join(timeout=10.0)
+                    if self.stream_thread.is_alive():
+                        log_warning("⚠️ STT thread did not stop gracefully")
+                
+                # Clear queues
+                while not self.audio_queue.empty():
+                    try:
+                        self.audio_queue.get_nowait()
+                    except:
+                        pass
+                        
+                final_result = None
+                while not self.responses_queue.empty():
+                    try:
+                        result = self.responses_queue.get_nowait()
+                        if result.is_final:
+                            final_result = result
+                    except:
+                        pass
+                
+                # Reset thread reference
+                self.stream_thread = None
+                
+                log_info("✅ Google STT streaming stopped")
+                return final_result
+                
+            except Exception as e:
+                log_error(f"❌ Failed to stop Google STT streaming", error=str(e))
+                self.stream_thread = None
+                return None
     
     def supports_realtime(self) -> bool:
         """Google Cloud STT supports real-time streaming"""