Update stt/stt_google.py

stt/stt_google.py

@@ -196,24 +196,24 @@ class GoogleCloudSTT(STTInterface):
     def _run_stream(self):
         """Run the streaming recognition in a separate thread"""
         try:
-            log_info("🎤 Google STT stream thread started")
-
+            log_info(f"🎤 Google STT stream thread started - Single utterance mode: {self.streaming_config.single_utterance}")
+    
             def request_generator():
                 """Generate streaming requests"""
                 chunk_count = 0
                 total_bytes = 0
                 first_chunk_processed = False
-
+    
                 while not self.stop_event.is_set():
                     try:
                         chunk = self.audio_queue.get(timeout=0.1)
                         if chunk is None:
                             log_info("📛 Poison pill received, stopping request generator")
                             break
-
+    
                         chunk_count += 1
                         total_bytes += len(chunk)
-
+    
                         # İlk chunk'ta audio format kontrolü
                         if chunk_count == 1:
                             log_info(f"📤 First chunk - size: {len(chunk)} bytes")
@@ -226,75 +226,75 @@ class GoogleCloudSTT(STTInterface):
                                     log_error(f"❌ Invalid audio format, first 4 bytes: {chunk[:4].hex()}")
                                     # Hatalı format, stream'i durdur
                                     break
-
+    
                         # İlk chunk geçerliyse devam et
                         if chunk_count == 1 and not first_chunk_processed:
                             break
-
+    
                         # Her 100 chunk'ta durum raporu
                         if chunk_count % 100 == 0:
                             avg_chunk_size = total_bytes / chunk_count
                             log_info(f"📤 Progress: {chunk_count} chunks, {total_bytes/1024:.1f}KB total, avg {avg_chunk_size:.0f} bytes/chunk")
-
+    
                         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,
                     timeout=300 # 5 dakika timeout
                 )
-
+    
                 log_info("✅ Google STT streaming client created")
-
+    
                 # Response timeout kontrolü
                 last_response_time = time.time()
                 RESPONSE_TIMEOUT = 30  # 30 saniye içinde response gelmezse
-
+    
                 # Process responses
                 response_count = 0
                 empty_response_count = 0
-
+    
                 for response in responses:
                     last_response_time = time.time()
                     response_count += 1
-
+    
                     # Response type'ı logla
                     if response_count == 1:
                         log_info(f"📨 First response received from Google STT")
-
+    
                     if self.stop_event.is_set():
                         log_info("🛑 Stop event detected, breaking response loop")
                         break
-
+    
                     # Response içeriğini kontrol et
                     if not response.results:
                         empty_response_count += 1
                         if empty_response_count == 1:
                             log_debug("📭 Received empty response (no results)")
                         continue
-
+    
                     for i, result in enumerate(response.results):
                         log_debug(f"📋 Result {i}: is_final={result.is_final}, alternatives={len(result.alternatives)}")
-
+    
                         if not result.alternatives:
                             log_debug(f"📋 Result {i} has no alternatives")
                             continue
-
+    
                         # İlk alternatifi al
                         alternative = result.alternatives[0]
-
+    
                         # Sadece anlamlı text'leri işle
                         if alternative.transcript.strip():
                             # Create transcription result
@@ -304,25 +304,33 @@ class GoogleCloudSTT(STTInterface):
                                 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}'")
+                                
+                                # ✅ Single utterance modunda stream otomatik kapanacak
+                                if self.streaming_config.single_utterance:
+                                    log_info("🏁 Single utterance completed - Stream will auto-close")
+                                    # Google STT single utterance modda otomatik kapatır
+                                    # Ama biz de clean bir şekilde çıkalım
+                                    self.is_streaming = False
+                                    return
                         else:
                             log_debug(f"📋 Result {i} has empty transcript")
                             continue
-
-                if time.time() - last_response_time > RESPONSE_TIMEOUT:
-                    log_error(f"❌ No response from Google STT for {RESPONSE_TIMEOUT} seconds")
-
+    
+                    if time.time() - last_response_time > RESPONSE_TIMEOUT:
+                        log_error(f"❌ No response from Google STT for {RESPONSE_TIMEOUT} seconds")
+    
                 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.")
@@ -336,161 +344,10 @@ class GoogleCloudSTT(STTInterface):
                     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")
             # 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"""
-        if not self.is_streaming:
-            # Daha detaylı hata mesajı
-            log_error(f"❌ STT not streaming - is_streaming: {self.is_streaming}, thread alive: {self.stream_thread and self.stream_thread.is_alive() if hasattr(self, 'stream_thread') else 'No thread'}")
-            raise RuntimeError("Streaming not started. Call start_streaming() first.")
-
-        try:
-            # Put audio in queue for streaming thread
-            self.audio_queue.put(audio_chunk)
-
-            # Check for any results in queue
-            while True:
-                try:
-                    # Non-blocking get from normal queue
-                    result = self.responses_queue.get_nowait()
-                    yield result
-                except queue.Empty:
-                    # No more results in queue
-                    break
-
-        except Exception as e:
-            log_error(f"❌ Google STT streaming error", error=str(e))
-            # Stream'i tekrar başlatmayı tetikle
-            self.is_streaming = False
-            raise
-
-    async def stop_streaming(self) -> Optional[TranscriptionResult]:
-        """Stop streaming and clean up all resources"""
-        if not self.is_streaming and not self.stream_thread:
-            log_debug("Already stopped, nothing to do")
-            return None
-
-        try:
-            log_info(f"🛑 Stopping Google STT streaming session #{self.session_id}")
-
-            # Flag'i hemen kapat
-            self.is_streaming = False
-            self.stop_event.set()
-
-            # Send poison pill to stop request generator
-            if self.audio_queue:
-                try:
-                    self.audio_queue.put(None)
-                except:
-                    pass
-
-            # Thread'i durdur
-            if self.stream_thread and self.stream_thread.is_alive():
-                log_info("⏳ Waiting for stream thread to finish...")
-                self.stream_thread.join(timeout=5.0)  # 5 saniye bekle
-
-                if self.stream_thread.is_alive():
-                    log_warning("⚠️ STT thread did not stop gracefully after 5s")
-                    # Thread'i zorla sonlandıramayız Python'da, ama daemon olduğu için
-                    # ana program kapanınca otomatik kapanacak
-                else:
-                    log_info("✅ Stream thread finished")
-
-            # Final result'ı al
-            final_result = None
-            if self.responses_queue:
-                while not self.responses_queue.empty():
-                    try:
-                        result = self.responses_queue.get_nowait()
-                        if result.is_final:
-                            final_result = result
-                    except:
-                        pass
-
-            # Client'ı kapat
-            if self.client:
-                try:
-                    # Transport'u kapat
-                    if hasattr(self.client, 'transport') and hasattr(self.client.transport, 'close'):
-                        self.client.transport.close()
-                        log_debug("✅ Client transport closed")
-
-                    # gRPC channel'ı kapat
-                    if hasattr(self.client, '_transport') and hasattr(self.client._transport, '_grpc_channel'):
-                        self.client._transport._grpc_channel.close()
-                        log_debug("✅ gRPC channel closed")
-                except Exception as e:
-                    log_warning(f"⚠️ Error closing Google client: {e}")
-                finally:
-                    self.client = None
-
-            # Queue'ları None yap (yeniden kullanım için fresh queue gerekecek)
-            self.audio_queue = None
-            self.responses_queue = None
-
-            # Diğer değişkenleri resetle
-            self.stream_thread = None
-            self.streaming_config = None
-            self.stop_event.clear()
-
-            log_info(f"✅ Google STT streaming session #{self.session_id} stopped and cleaned")
-            return final_result
-
-        except Exception as e:
-            log_error(f"❌ Error during stop_streaming", error=str(e))
-            # Force cleanup on error
-            self.is_streaming = False
-            self.stream_thread = None
-            self.client = None
-            self.streaming_config = None
-            self.stop_event.clear()
-            self.audio_queue = None
-            self.responses_queue = None
-            return None
-
-    def supports_realtime(self) -> bool:
-        """Google Cloud STT supports real-time streaming"""
-        return True
-
-    def get_supported_languages(self) -> List[str]:
-        """Get list of supported language codes"""
-        return [
-            "tr-TR",  # Turkish
-            "en-US",  # English (US)
-            "en-GB",  # English (UK)
-            "de-DE",  # German
-            "fr-FR",  # French
-            "es-ES",  # Spanish
-            "it-IT",  # Italian
-            "pt-BR",  # Portuguese (Brazil)
-            "ru-RU",  # Russian
-            "ja-JP",  # Japanese
-            "ko-KR",  # Korean
-            "zh-CN",  # Chinese (Simplified)
-            "ar-SA",  # Arabic
-        ]
-
-    def get_provider_name(self) -> str:
-        """Get provider name"""
-        return "google"
-
-    def _get_encoding(self, encoding_str: str):
-        """Convert encoding string to Google Speech enum"""
-        if not GOOGLE_SPEECH_AVAILABLE:
-            return None
-
-        encoding_map = {
-            "WEBM_OPUS": speech.RecognitionConfig.AudioEncoding.WEBM_OPUS,
-            "LINEAR16": speech.RecognitionConfig.AudioEncoding.LINEAR16,
-            "FLAC": speech.RecognitionConfig.AudioEncoding.FLAC,
-            "MP3": speech.RecognitionConfig.AudioEncoding.MP3,
-            "OGG_OPUS": speech.RecognitionConfig.AudioEncoding.OGG_OPUS,
-        }
-        return encoding_map.get(encoding_str, speech.RecognitionConfig.AudioEncoding.WEBM_OPUS)
+            self.is_streaming = False