Update stt/stt_google.py

stt/stt_google.py

@@ -67,98 +67,132 @@ class GoogleSTT(STTInterface):
         return language_map.get(language, language)
     
     async def transcribe(self, audio_data: bytes, config: STTConfig) -> Optional[TranscriptionResult]:
-        """Transcribe audio data using Google Cloud Speech API"""
         try:
-            # Check if we have audio to transcribe
             if not audio_data:
                 log_warning("⚠️ No audio data provided")
                 return None
             
             log_info(f"📊 Transcribing {len(audio_data)} bytes of audio")
             
-            # ✅ Debug - audio verisi analizi
-            if len(audio_data) > 100:
-                # İlk ve son 50 byte'ı kontrol et
-                first_50 = audio_data[:50]
-                last_50 = audio_data[-50:]
-                log_debug(f"Audio first 50 bytes: {first_50.hex()}")
-                log_debug(f"Audio last 50 bytes: {last_50.hex()}")
+            # ✅ Detaylı audio analizi - logda
+            import struct
+            samples = struct.unpack(f'{len(audio_data)//2}h', audio_data)
+            total_samples = len(samples)
+            
+            # 1. Genel istatistikler
+            non_zero_samples = [s for s in samples if s != 0]
+            zero_count = total_samples - len(non_zero_samples)
+            
+            if non_zero_samples:
+                avg_amplitude = sum(abs(s) for s in non_zero_samples) / len(non_zero_samples)
+                max_amplitude = max(abs(s) for s in non_zero_samples)
+            else:
+                avg_amplitude = 0
+                max_amplitude = 0
+            
+            log_info(f"🔍 Audio stats: {total_samples} total samples, {zero_count} zeros ({zero_count/total_samples:.1%})")
+            log_info(f"🔍 Non-zero stats: avg={avg_amplitude:.1f}, max={max_amplitude}")
+            
+            # 2. Bölüm bazlı analiz (10 bölüme ayır)
+            section_size = total_samples // 10
+            log_info(f"🔍 Section analysis (each {section_size} samples):")
+            
+            for i in range(10):
+                start_idx = i * section_size
+                end_idx = (i + 1) * section_size if i < 9 else total_samples
+                section = samples[start_idx:end_idx]
+                
+                section_non_zero = [s for s in section if s != 0]
+                section_max = max(abs(s) for s in section_non_zero) if section_non_zero else 0
+                section_avg = sum(abs(s) for s in section_non_zero) / len(section_non_zero) if section_non_zero else 0
+                zero_ratio = (len(section) - len(section_non_zero)) / len(section)
+                
+                log_info(f"  Section {i+1}: max={section_max}, avg={section_avg:.1f}, zeros={zero_ratio:.1%}")
+            
+            # 3. İlk konuşma başlangıcını bul
+            speech_threshold = 500  # RMS eşiği
+            speech_start_idx = -1
+            
+            # 100 sample'lık pencerelerle RMS hesapla
+            window_size = 100
+            for i in range(0, total_samples - window_size, window_size):
+                window = samples[i:i + window_size]
+                rms = (sum(s * s for s in window) / window_size) ** 0.5
                 
-                # Ortalama amplitude kontrolü
-                import struct
-                samples = struct.unpack(f'{len(audio_data)//2}h', audio_data)
-                avg_amplitude = sum(abs(s) for s in samples) / len(samples)
-                max_amplitude = max(abs(s) for s in samples)
-                log_debug(f"Audio stats: avg_amplitude={avg_amplitude:.1f}, max_amplitude={max_amplitude}")
-            
-            # Convert to WAV format for better compatibility
+                if rms > speech_threshold:
+                    speech_start_idx = i
+                    break
+            
+            if speech_start_idx >= 0:
+                speech_start_time = speech_start_idx / config.sample_rate
+                log_info(f"🎤 Speech detected starting at sample {speech_start_idx} ({speech_start_time:.2f}s)")
+            else:
+                log_warning("⚠️ No speech detected above threshold in entire audio")
+            
+            # 4. Audio'nun gerçekten boş olup olmadığını kontrol et
+            if max_amplitude < 100:
+                log_warning(f"⚠️ Audio appears silent: max_amplitude={max_amplitude}")
+                return None
+            
+            if zero_count / total_samples > 0.95:  # %95'den fazla sıfır
+                log_warning(f"⚠️ Audio is mostly zeros: {zero_count/total_samples:.1%}")
+                return None
+            
+            # Convert to WAV format
             wav_audio = self._convert_to_wav(audio_data, config.sample_rate)
             
             # Configure recognition
-            language_code = self._map_language_code(config.language)
-
-            """
-            recognition_config = RecognitionConfig(
-                encoding=RecognitionConfig.AudioEncoding.LINEAR16,
-                sample_rate_hertz=config.sample_rate,
-                language_code=language_code,
-                enable_automatic_punctuation=config.enable_punctuation,
-                model=config.model,
-                use_enhanced=config.use_enhanced,
-                enable_word_time_offsets=config.enable_word_timestamps,
-            )
-            """
-
             recognition_config = RecognitionConfig(
                 encoding=RecognitionConfig.AudioEncoding.LINEAR16,
                 sample_rate_hertz=16000,
                 language_code="tr-TR",
-                audio_channel_count=1,  # Frontend mono audio gönderiyor
+                audio_channel_count=1,
                 enable_separate_recognition_per_channel=False,
+                enable_automatic_punctuation=True,
             )
-                
-            log_debug(f"Recognition config: language={language_code}, sample_rate={config.sample_rate}, model={config.model}")
-
+            
             # Create audio object
             audio = RecognitionAudio(content=wav_audio)
             
             # Perform synchronous recognition
             log_info(f"🔄 Sending audio to Google Cloud Speech API...")
             response = self.client.recognize(config=recognition_config, audio=audio)
-
-            # ✅ Debug response
-            log_debug(f"API Response: {response}")
-
+    
+            # ✅ Detaylı response analizi
+            log_info(f"🔍 Google response details:")
+            log_info(f"  - Has results: {bool(response.results)}")
+            log_info(f"  - Results count: {len(response.results) if response.results else 0}")
+            
+            if hasattr(response, 'total_billed_time'):
+                if response.total_billed_time and response.total_billed_time.total_seconds() > 0:
+                    log_info(f"  - Billed time: {response.total_billed_time.total_seconds()}s")
+                else:
+                    log_info(f"  - Billed time: 0s (no audio processed)")
+            
             # Process results
-            if response.results:
+            if response.results and len(response.results) > 0:
+                for i, result in enumerate(response.results):
+                    log_info(f"  - Result {i}: {len(result.alternatives)} alternatives")
+                    if result.alternatives:
+                        for j, alt in enumerate(result.alternatives):
+                            log_info(f"    - Alt {j}: '{alt.transcript}' (conf: {alt.confidence:.3f})")
+                
                 result = response.results[0]
-                if result.alternatives:
+                if result.alternatives and len(result.alternatives) > 0:
                     alternative = result.alternatives[0]
                     
-                    # Extract word timestamps if available
-                    word_timestamps = None
-                    if config.enable_word_timestamps and hasattr(alternative, 'words'):
-                        word_timestamps = [
-                            {
-                                "word": word_info.word,
-                                "start_time": word_info.start_time.total_seconds(),
-                                "end_time": word_info.end_time.total_seconds()
-                            }
-                            for word_info in alternative.words
-                        ]
-                    
                     transcription = TranscriptionResult(
                         text=alternative.transcript,
                         confidence=alternative.confidence,
                         timestamp=datetime.now().timestamp(),
-                        language=language_code,
-                        word_timestamps=word_timestamps
+                        language="tr-TR",
+                        word_timestamps=None
                     )
                     
-                    log_info(f"✅ Transcription: '{alternative.transcript}' (confidence: {alternative.confidence:.2f})")
+                    log_info(f"✅ Transcription SUCCESS: '{alternative.transcript}' (confidence: {alternative.confidence:.2f})")
                     return transcription
             
-            log_warning("⚠️ No transcription results")
+            log_warning("⚠️ No transcription results - Google couldn't recognize speech")
             return None
             
         except Exception as e: