Update stt_google.py

stt_google.py

@@ -40,6 +40,9 @@ class GoogleCloudSTT(STTInterface):
                 test_client = speech.SpeechClient()
                 log_info("🔐 Testing Google credentials...")
                 log_info("✅ Google credentials valid")
+                # Test client'ı kapat
+                if hasattr(test_client, 'transport') and hasattr(test_client.transport, 'close'):
+                    test_client.transport.close()
             except Exception as e:
                 log_error(f"❌ Google credentials error", error=str(e))
                 raise
@@ -51,23 +54,55 @@ class GoogleCloudSTT(STTInterface):
         self.client = None
         self.streaming_config = None
         self.is_streaming = False
-        self.audio_queue = queue.Queue()
-        self.responses_queue = queue.Queue()
+        self.audio_queue = None  # Queue'ları None olarak başlat
+        self.responses_queue = None
         self.stream_thread = None
         self.stop_event = threading.Event()
-        self.credentials_path = credentials_path  # Sakla
+        self.credentials_path = credentials_path
+        
+        # Session tracking
+        self.session_id = 0
+
+    def _create_fresh_queues(self):
+        """Create fresh queue instances"""
+        # Eski queue'ları temizle
+        if self.audio_queue:
+            while not self.audio_queue.empty():
+                try:
+                    self.audio_queue.get_nowait()
+                except:
+                    pass
+                    
+        if self.responses_queue:
+            while not self.responses_queue.empty():
+                try:
+                    self.responses_queue.get_nowait()
+                except:
+                    pass
+        
+        # Yeni queue'lar oluştur
+        self.audio_queue = queue.Queue(maxsize=1000)  # Max size ekle
+        self.responses_queue = queue.Queue(maxsize=100)
+        log_debug("✅ Created fresh queues")
         
     async def start_streaming(self, config: dict) -> None:
         """Initialize streaming session with clean state"""
         try:
-            log_info(f"🎤 Starting Google STT streaming with config: {config}")
+            self.session_id += 1
+            log_info(f"🎤 Starting Google STT streaming session #{self.session_id} with config: {config}")
             
             # Önce mevcut stream'i temizle
             if self.is_streaming or self.stream_thread:
                 log_warning("⚠️ Previous stream still active, stopping it first")
                 await self.stop_streaming()
-                # Temizlik için bekle
-                await asyncio.sleep(0.1)
+                # Temizlik için daha uzun bekle
+                await asyncio.sleep(0.5)
+            
+            # Fresh queue'lar oluştur
+            self._create_fresh_queues()
+            
+            # Stop event'i temizle
+            self.stop_event.clear()
             
             # Her start_streaming'de yeni client oluştur
             self.client = speech.SpeechClient()
@@ -101,23 +136,23 @@ class GoogleCloudSTT(STTInterface):
                 single_utterance=stt_config.single_utterance
             )
             
-            # Queue'ları yeniden oluştur (tamamen temiz başla)
-            self.audio_queue = queue.Queue()
-            self.responses_queue = queue.Queue()
-            
             self.is_streaming = True
-            self.stop_event.clear()
             
-            # Start streaming thread
-            self.stream_thread = threading.Thread(target=self._run_stream)
+            # Start streaming thread with unique name
+            self.stream_thread = threading.Thread(
+                target=self._run_stream,
+                name=f"GoogleSTT-Session-{self.session_id}"
+            )
+            self.stream_thread.daemon = True  # Daemon thread olarak işaretle
             self.stream_thread.start()
             
-            log_info("✅ Google STT streaming started successfully with clean state")
+            log_info(f"✅ Google STT streaming session #{self.session_id} started successfully")
             
         except Exception as e:
             log_error(f"❌ Failed to start Google STT streaming", error=str(e))
             self.is_streaming = False
             self.client = None
+            self._create_fresh_queues()  # Hata durumunda da queue'ları temizle
             raise
 
     def _put_result(self, result: TranscriptionResult):
@@ -309,10 +344,11 @@ class GoogleCloudSTT(STTInterface):
     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("🛑 Stopping Google STT streaming and cleaning all resources...")
+            log_info(f"🛑 Stopping Google STT streaming session #{self.session_id}")
             
             # Flag'i hemen kapat
             self.is_streaming = False
@@ -320,24 +356,24 @@ class GoogleCloudSTT(STTInterface):
             
             # Send poison pill to stop request generator
             if self.audio_queue:
-                self.audio_queue.put(None)
+                try:
+                    self.audio_queue.put(None)
+                except:
+                    pass
             
-            # Wait for thread to finish
+            # Thread'i durdur
             if self.stream_thread and self.stream_thread.is_alive():
-                self.stream_thread.join(timeout=10.0)
+                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, forcing termination")
+                    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")
             
-            # Clear all queues completely
-            if self.audio_queue:
-                while not self.audio_queue.empty():
-                    try:
-                        self.audio_queue.get_nowait()
-                    except:
-                        pass
-                # Queue'yu yeniden oluştur
-                self.audio_queue = queue.Queue()
-                        
+            # Final result'ı al
             final_result = None
             if self.responses_queue:
                 while not self.responses_queue.empty():
@@ -347,41 +383,46 @@ class GoogleCloudSTT(STTInterface):
                             final_result = result
                     except:
                         pass
-                # Queue'yu yeniden oluştur
-                self.responses_queue = queue.Queue()
             
-            # Close and delete client
+            # 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
             
-            # Reset all variables
+            # 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("✅ Google STT streaming stopped and all resources cleaned")
+            log_info(f"✅ Google STT streaming session #{self.session_id} stopped and cleaned")
             return final_result
             
         except Exception as e:
-            log_error(f"❌ Failed to stop Google STT streaming", error=str(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.is_streaming = False
             self.stop_event.clear()
-            self.audio_queue = queue.Queue()
-            self.responses_queue = queue.Queue()
+            self.audio_queue = None
+            self.responses_queue = None
             return None
     
     def supports_realtime(self) -> bool: