Update stt/stt_google.py

stt/stt_google.py

@@ -79,29 +79,66 @@ class GoogleCloudSTT(STTInterface):
         }
         return encoding_map.get(encoding_str, speech.RecognitionConfig.AudioEncoding.WEBM_OPUS)
     
-    async def stream_audio(self, audio_chunk: bytes) -> AsyncIterator[TranscriptionResult]:
-        """Stream audio chunk and get transcription results"""
+    async def stream_audio(self, audio_chunk: bytes) -> AsyncGenerator[TranscriptionResult, None]:
+        """Stream audio chunk and get results"""
         if not self.is_streaming:
-            log_error(f"❌ STT not streaming - is_streaming: {self.is_streaming}")
-            raise RuntimeError("Streaming not started. Call start_streaming() first.")
-
+            raise Exception("Streaming not started")
+        
         try:
-            # Put audio in queue for streaming thread
+            # Audio validation and logging
+            chunk_size = len(audio_chunk)
+            
+            # Log first chunk details
+            if self.chunk_count == 0:
+                log_info(f"📤 First chunk - size: {chunk_size} bytes")
+                # Check for WEBM header
+                if audio_chunk.startswith(b'\x1a\x45\xdf\xa3'):
+                    log_info("✅ Valid WEBM header detected")
+                else:
+                    hex_preview = audio_chunk[:20].hex()
+                    log_warning(f"⚠️ Unexpected audio format. First 20 bytes: {hex_preview}")
+            
+            # Try to measure audio level (if it's raw PCM)
+            try:
+                import numpy as np
+                # This might fail for WEBM, but let's try
+                audio_array = np.frombuffer(audio_chunk[-1000:], dtype=np.int16)  # Last 1000 bytes
+                if len(audio_array) > 0:
+                    rms = np.sqrt(np.mean(audio_array.astype(float) ** 2))
+                    db = 20 * np.log10(max(rms, 1) / 32768.0)
+                    if self.chunk_count % 50 == 0:
+                        log_info(f"🔊 Audio level estimate: {db:.1f} dB")
+            except:
+                # Expected for WEBM format
+                pass
+            
+            # Put chunk in queue
             self.audio_queue.put(audio_chunk)
-
-            # Check for any results in queue
-            while True:
+            self.chunk_count += 1
+            self.total_bytes += chunk_size
+            
+            # Log progress
+            if self.chunk_count % 50 == 0:
+                log_info(f"📤 Progress: {self.chunk_count} chunks, {self.total_bytes/1024:.1f}KB total")
+            
+            # Check for responses with timeout
+            timeout = 0.1  # 100ms timeout for checking responses
+            end_time = time.time() + timeout
+            
+            while time.time() < end_time:
                 try:
-                    # Non-blocking get from queue
                     result = self.responses_queue.get_nowait()
+                    log_info(f"🎯 Got result from queue: is_final={result.is_final}, text='{result.text[:30]}...'")
                     yield result
                 except queue.Empty:
-                    # No more results in queue
+                    # No results yet, continue
+                    await asyncio.sleep(0.01)
+                except Exception as e:
+                    log_error(f"Error getting result from queue: {e}")
                     break
-
+                    
         except Exception as e:
-            log_error(f"❌ Google STT streaming error", error=str(e))
-            self.is_streaming = False
+            log_error(f"❌ Error in stream_audio: {e}")
             raise
 
     async def stop_streaming(self) -> Optional[TranscriptionResult]:
@@ -343,142 +380,71 @@ class GoogleCloudSTT(STTInterface):
             log_error(f"❌ Error queuing result: {e}")
 
     def _run_stream(self):
-        """Run the streaming recognition in a separate thread"""
+        """Run the streaming recognition loop in a separate thread"""
         try:
-            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
-                
-                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")
-                            if len(chunk) >= 4 and chunk[:4] == b'\x1a\x45\xdf\xa3':
-                                log_info("✅ Valid WEBM header detected")
-    
-                        # Her 50 chunk'ta durum raporu
-                        if chunk_count % 50 == 0:
-                            log_info(f"📤 Progress: {chunk_count} chunks, {total_bytes/1024:.1f}KB total")
-    
-                        yield speech.StreamingRecognizeRequest(audio_content=chunk)
-    
-                    except queue.Empty:
-                        continue
-                    except Exception as e:
-                        log_error(f"❌ Error in request generator: {e}")
-                        break
-    
-                log_info(f"📊 Request generator finished. Total chunks: {chunk_count}, Total bytes: {total_bytes}")
-    
+            log_info("🎤 Google STT stream thread started - Single utterance mode: {}".format(self.single_utterance))
+            
+            # Create request generator
+            requests = self._request_generator()
+            
             # Create streaming client
-            requests = request_generator()
             log_info("🎤 Creating Google STT streaming client...")
-    
-            try:
-                # Start streaming
-                responses = self.client.streaming_recognize(
-                    self.streaming_config,
-                    requests,
-                    timeout=300
-                )
-    
-                log_info("✅ Google STT streaming client created, waiting for responses...")
-    
-                # Process responses
-                response_count = 0
-                result_count = 0
-                last_log_time = time.time()
-    
-                # Response iterator'ı başlat
-                try:
-                    for response in responses:
-                        response_count += 1
+            responses = self.client.streaming_recognize(self.streaming_config, requests)
+            
+            # Track if we've received any response
+            first_response_time = None
+            response_count = 0
+            
+            # Process responses with detailed logging
+            for response in responses:
+                response_count += 1
+                
+                if first_response_time is None:
+                    first_response_time = time.time()
+                    elapsed = first_response_time - self.stream_start_time
+                    log_info(f"🎉 FIRST RESPONSE from Google STT after {elapsed:.2f}s")
+                
+                # Log every response, even if empty
+                log_info(f"📨 Google STT Response #{response_count}: has_results={len(response.results) > 0}")
+                
+                if not response.results:
+                    log_info("📭 Empty response from Google STT (no results)")
+                    continue
+                
+                # Log all results in detail
+                for result_idx, result in enumerate(response.results):
+                    log_info(f"📝 Result #{result_idx}: is_final={result.is_final}, "
+                            f"alternatives={len(result.alternatives)}, "
+                            f"stability={getattr(result, 'stability', 'N/A')}")
+                    
+                    if result.alternatives:
+                        best_alternative = result.alternatives[0]
+                        log_info(f"🗣️ Transcript: '{best_alternative.transcript}' "
+                                f"(confidence: {best_alternative.confidence:.3f})")
                         
-                        # İlk response'u logla
-                        if response_count == 1:
-                            log_info(f"📨 First response received from Google STT")
-    
-                        # Her 5 saniyede bir durum logu
-                        if time.time() - last_log_time > 5:
-                            log_info(f"📊 Still listening... Responses: {response_count}, Results: {result_count}")
-                            last_log_time = time.time()
-    
-                        if self.stop_event.is_set():
-                            log_info("🛑 Stop event detected")
-                            break
-    
-                        # Process results
-                        if not response.results:
-                            log_debug(f"📭 Response #{response_count} has no results")
-                            continue
-    
-                        for result in response.results:
-                            result_count += 1
-                            
-                            if not result.alternatives:
-                                continue
-    
-                            alternative = result.alternatives[0]
-                            
-                            # Log all transcripts, even empty ones
-                            log_debug(f"📝 Transcript: '{alternative.transcript}' (is_final: {result.is_final})")
-                            
-                            if alternative.transcript.strip():
-                                # Create transcription result
-                                transcription = TranscriptionResult(
-                                    text=alternative.transcript,
-                                    is_final=result.is_final,
-                                    confidence=getattr(alternative, 'confidence', 0.0),
-                                    timestamp=datetime.now().timestamp()
-                                )
-    
-                                # Put result in queue
-                                self._put_result(transcription)
-    
-                                if result.is_final:
-                                    log_info(f"🎯 FINAL TRANSCRIPT: '{alternative.transcript}'")
-                                    
-                                    # Single utterance modunda Google STT otomatik kapanır
-                                    if self.streaming_config.single_utterance:
-                                        log_info("✅ Single utterance completed - Stream ending")
-                                        return
-                                else:
-                                    log_debug(f"📝 Interim: '{alternative.transcript}'")
-    
-                except StopIteration:
-                    log_info("✅ Google STT stream ended (StopIteration)")
-                except Exception as e:
-                    log_error(f"❌ Error processing responses: {e}")
-    
-                log_info(f"📊 Google STT stream ended. Responses: {response_count}, Results: {result_count}")
-    
-            except Exception as e:
-                error_msg = str(e)
+                        # Put result in queue
+                        result_obj = TranscriptionResult(
+                            text=best_alternative.transcript,
+                            is_final=result.is_final,
+                            confidence=best_alternative.confidence,
+                            timestamp=datetime.utcnow()
+                        )
+                        
+                        self.responses_queue.put(result_obj)
+                        log_info(f"✅ Result queued: is_final={result.is_final}, text='{best_alternative.transcript[:50]}...'")
+            
+            # Log if we exit without any responses
+            if response_count == 0:
+                log_error("❌ Google STT stream ended without ANY responses!")
+            else:
+                log_info(f"✅ Google STT stream ended normally after {response_count} responses")
                 
-                # Beklenen hatalar
-                if "iterating requests" in error_msg:
-                    log_info("✅ Stream ended normally")
-                elif "Exceeded maximum allowed stream duration" in error_msg:
-                    log_warning("⚠️ Stream duration limit (5 min)")
-                elif "InvalidArgument" in error_msg:
-                    log_error(f"❌ Invalid STT configuration: {error_msg}")
-                else:
-                    log_error(f"❌ Google STT error: {error_msg}")
-    
         except Exception as e:
-            log_error(f"❌ Fatal error in STT stream", error=str(e), traceback=traceback.format_exc())
+            log_error(f"❌ Google STT error: {e}")
+            if hasattr(e, 'details'):
+                log_error(f"Error details: {e.details}")
+            self.error_message = str(e)
         finally:
             log_info("🎤 Google STT stream thread ended")
-            self.is_streaming = False
+            with self.lock:
+                self.is_streaming = False