Update stt_google.py

stt_google.py

@@ -58,10 +58,17 @@ class GoogleCloudSTT(STTInterface):
         self.credentials_path = credentials_path  # Sakla
         
     async def start_streaming(self, config: dict) -> None:
-        """Initialize streaming session"""
+        """Initialize streaming session with clean state"""
         try:
             log_info(f"🎤 Starting Google STT streaming 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)
+            
             # Her start_streaming'de yeni client oluştur
             self.client = speech.SpeechClient()
             log_info("✅ Created new Google Speech client")
@@ -94,18 +101,9 @@ class GoogleCloudSTT(STTInterface):
                 single_utterance=stt_config.single_utterance
             )
             
-            # Queue'ları temizle
-            while not self.audio_queue.empty():
-                try:
-                    self.audio_queue.get_nowait()
-                except:
-                    pass
-                    
-            while not self.responses_queue.empty():
-                try:
-                    self.responses_queue.get_nowait()
-                except:
-                    pass
+            # 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()
@@ -114,11 +112,12 @@ class GoogleCloudSTT(STTInterface):
             self.stream_thread = threading.Thread(target=self._run_stream)
             self.stream_thread.start()
             
-            log_info("✅ Google STT streaming started successfully")
+            log_info("✅ Google STT streaming started successfully with clean state")
             
         except Exception as e:
             log_error(f"❌ Failed to start Google STT streaming", error=str(e))
             self.is_streaming = False
+            self.client = None
             raise
 
     def _put_result(self, result: TranscriptionResult):
@@ -308,59 +307,81 @@ class GoogleCloudSTT(STTInterface):
             raise
     
     async def stop_streaming(self) -> Optional[TranscriptionResult]:
-        """Stop streaming and get final result"""
-        if not self.is_streaming:
+        """Stop streaming and clean up all resources"""
+        if not self.is_streaming and not self.stream_thread:
             return None
             
         try:
-            log_info("🛑 Stopping Google STT streaming...")
+            log_info("🛑 Stopping Google STT streaming and cleaning all resources...")
             
+            # Flag'i hemen kapat
             self.is_streaming = False
             self.stop_event.set()
             
-            # Send poison pill to queue
-            self.audio_queue.put(None)
+            # Send poison pill to stop request generator
+            if self.audio_queue:
+                self.audio_queue.put(None)
             
-            # Wait for thread to finish with longer timeout
+            # Wait for thread to finish
             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")
+                    log_warning("⚠️ STT thread did not stop gracefully, forcing termination")
             
-            # Clear queues
-            while not self.audio_queue.empty():
-                try:
-                    self.audio_queue.get_nowait()
-                except:
-                    pass
-                    
+            # 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 = 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
+            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
+                # Queue'yu yeniden oluştur
+                self.responses_queue = queue.Queue()
             
-            # Client'ı kapat
+            # Close and delete client
             if self.client:
                 try:
-                    self.client.transport.close()
-                except:
-                    pass
-                self.client = None
+                    # Transport'u kapat
+                    if hasattr(self.client, 'transport') and hasattr(self.client.transport, 'close'):
+                        self.client.transport.close()
+                    # gRPC channel'ı kapat
+                    if hasattr(self.client, '_transport') and hasattr(self.client._transport, '_grpc_channel'):
+                        self.client._transport._grpc_channel.close()
+                except Exception as e:
+                    log_warning(f"⚠️ Error closing Google client: {e}")
+                finally:
+                    self.client = None
             
-            log_info("✅ Google STT streaming stopped")
+            # Reset all variables
+            self.stream_thread = None
+            self.streaming_config = None
+            self.stop_event.clear()
+            
+            log_info("✅ Google STT streaming stopped and all resources cleaned")
             return final_result
             
         except Exception as e:
             log_error(f"❌ Failed to stop Google STT streaming", error=str(e))
+            # Force cleanup on error
             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()
             return None
     
     def supports_realtime(self) -> bool: