Update stt_google.py

stt_google.py

@@ -121,71 +121,109 @@ class GoogleCloudSTT(STTInterface):
                         # 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
-                        log_debug(f"📤 Sending chunk {chunk_count} to Google STT, size: {len(chunk)} bytes")
+                        
+                        # 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")
+                            
                         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...")
-            responses = self.client.streaming_recognize(self.streaming_config, requests)
-            log_info("✅ Google STT streaming client created")
             
-            # Process responses
-            response_count = 0
-            for response in responses:
-                response_count += 1
-                log_debug(f"📥 Google STT response {response_count} received")
+            try:
+                responses = self.client.streaming_recognize(self.streaming_config, requests)
+                log_info("✅ Google STT streaming client created")
                 
-                if self.stop_event.is_set():
-                    break
+                # Process responses
+                response_count = 0
+                empty_response_count = 0
+                
+                for response in responses:
+                    response_count += 1
                     
-                for result in response.results:
-                    if result.alternatives:
-                        # Create transcription result
-                        transcription = TranscriptionResult(
-                            text=result.alternatives[0].transcript,
-                            is_final=result.is_final,
-                            confidence=result.alternatives[0].confidence if result.alternatives[0].confidence else 0.0,
-                            timestamp=datetime.now().timestamp()
-                        )
-                        
-                        # Put result in async queue - create task and add to list
-                        task = loop.create_task(self._put_result(transcription))
-                        pending_tasks.append(task)
+                    if self.stop_event.is_set():
+                        log_info("🛑 Stop event detected, breaking response loop")
+                        break
+                    
+                    # Boş response'ları say ama loglamaa
+                    if not response.results:
+                        empty_response_count += 1
+                        if empty_response_count % 10 == 0:
+                            log_warning(f"⚠️ Received {empty_response_count} empty responses from Google STT")
+                        continue
                         
-                        log_debug(f"📝 STT result: {result.alternatives[0].transcript}, final: {result.is_final}")
+                    for result in response.results:
+                        if not result.alternatives:
+                            continue
+                            
+                        # İlk alternatifi al
+                        alternative = result.alternatives[0]
                         
-                        # ÖNEMLI: Final result'u loglayalım
-                        if result.is_final:
-                            log_info(f"🎯 FINAL STT RESULT: {result.alternatives[0].transcript}")
-            
-            # Wait for all pending tasks before closing loop
-            if pending_tasks:
-                loop.run_until_complete(asyncio.gather(*pending_tasks, return_exceptions=True))
+                        # Sadece anlamlı text'leri logla
+                        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 async queue - create task and add to list
+                            task = loop.create_task(self._put_result(transcription))
+                            pending_tasks.append(task)
+                            
+                            # Önemli: Final result'ları her zaman logla
+                            if result.is_final:
+                                log_info(f"🎯 GOOGLE STT FINAL: '{alternative.transcript}'")
+                            else:
+                                # Interim result'ları sadece ilk harfi büyükse logla (cümle başı)
+                                if alternative.transcript and alternative.transcript[0].isupper():
+                                    log_info(f"📝 Google STT interim: '{alternative.transcript}'")
+                            
+                log_info(f"📊 Google STT stream ended. Total responses: {response_count}, Empty: {empty_response_count}")
+                            
+            except Exception as e:
+                error_msg = str(e)
+                log_error(f"❌ Google STT stream error: {error_msg}")
+                
+                # Detaylı hata mesajları
+                if "Exceeded maximum allowed stream duration" in error_msg:
+                    log_error("❌ Stream duration limit exceeded (5 minutes). Need to restart stream.")
+                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")
                         
         except Exception as e:
-            error_msg = str(e)
-            log_error(f"❌ Google STT stream error", error=error_msg, traceback=traceback.format_exc())
-            
-            # Send error to responses queue
-            if "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")
-                    
+            log_error(f"❌ Fatal error in STT stream thread", error=str(e), traceback=traceback.format_exc())
         finally:
             # Wait for remaining tasks
             if pending_tasks:
-                loop.run_until_complete(asyncio.gather(*pending_tasks, return_exceptions=True))
+                try:
+                    loop.run_until_complete(asyncio.gather(*pending_tasks, return_exceptions=True))
+                except Exception as e:
+                    log_error(f"❌ Error waiting for pending tasks: {e}")
             log_info("🎤 Google STT stream thread ended")
-            loop.close()
+            try:
+                loop.close()
+            except Exception as e:
+                log_error(f"❌ Error closing event loop: {e}")
     
     async def _put_result(self, result: TranscriptionResult):
         """Helper to put result in queue"""
@@ -201,9 +239,11 @@ class GoogleCloudSTT(STTInterface):
             self.audio_queue.put(audio_chunk)
             
             # Check for any results (non-blocking)
+            results_found = 0
             try:
                 while True:
                     result = self.responses_queue.get_nowait()
+                    results_found += 1
                     yield result
             except asyncio.QueueEmpty:
                 pass