update speech again

mrrrme/backend/processing/speech.py

@@ -1,3 +1,17 @@
+"""MrrrMe Backend - Speech Processing Pipeline (COMPLETE)"""
+import requests
+import numpy as np
+from typing import Optional, Dict
+from ..models.loader import get_models
+from ..session.manager import save_message
+from ..utils.helpers import get_avatar_api_url
+from ..config import HALLUCINATION_PHRASES, MIN_TRANSCRIPTION_LENGTH, EMOTION_MAP
+
+AVATAR_API = get_avatar_api_url()
+
+
+def filter_transcription(transcription: str) -> tuple:
+    """
     Filter out short or meaningless transcriptions
     
     Returns:
@@ -37,10 +51,10 @@ async def process_speech_end(
     7. Send to client
     """
     
-    print(f"\n{'='*80}")
-    print(f"[Speech End] USER FINISHED SPEAKING: {username}")
-    print(f"{'='*80}")
-    print(f"[Transcription] '{transcription}'")
+    print(f"\n{'='*80}", flush=True)
+    print(f"[Speech End] USER FINISHED SPEAKING: {username}", flush=True)
+    print(f"{'='*80}", flush=True)
+    print(f"[Transcription] '{transcription}'", flush=True)
     
     # Get latest model instances
     models = get_models()
@@ -54,7 +68,7 @@ async def process_speech_end(
     should_process, skip_reason = filter_transcription(transcription)
     
     if not should_process:
-        print(f"[Filter] Skipped: {skip_reason}")
+        print(f"[Filter] Skipped: {skip_reason}", flush=True)
         return
     
     # Step 2: Save user message
@@ -62,57 +76,56 @@ async def process_speech_end(
     
     try:
         # ========== EMOTION DETECTION PIPELINE ==========
-        print(f"\n[Pipeline] Starting emotion analysis pipeline...")
-        print(f"{'─'*80}")
+        print(f"\n[Pipeline] Starting emotion analysis pipeline...", flush=True)
+        print(f"{'─'*80}", flush=True)
         
         # Step 3: Get face emotion
-        print(f"[Step 1/4] FACIAL EXPRESSION ANALYSIS")
+        print(f"[Step 1/4] FACIAL EXPRESSION ANALYSIS", flush=True)
         face_emotion = face_processor.get_last_emotion() or "Neutral"
         face_confidence = face_processor.get_last_confidence() or 0.0
         face_quality = getattr(face_processor, 'get_last_quality', lambda: 0.5)()
         
         # Create emotion probabilities
-        # ✅ FIX #2: Use module-level EMOTION_MAP (capital letters)
         face_probs = np.array([0.25, 0.25, 0.25, 0.25], dtype=np.float32)
         if face_emotion in EMOTION_MAP:
             face_idx = EMOTION_MAP[face_emotion]
             face_probs[face_idx] = face_confidence
             face_probs = face_probs / face_probs.sum()
         
-        print(f"   Result: {face_emotion}")
-        print(f"   Confidence: {face_confidence:.3f}")
-        print(f"   Quality Score: {face_quality:.3f}")
-        print(f"   Distribution: Neutral={face_probs[0]:.3f} | Happy={face_probs[1]:.3f} | Sad={face_probs[2]:.3f} | Angry={face_probs[3]:.3f}")
+        print(f"   Result: {face_emotion}", flush=True)
+        print(f"   Confidence: {face_confidence:.3f}", flush=True)
+        print(f"   Quality Score: {face_quality:.3f}", flush=True)
+        print(f"   Distribution: Neutral={face_probs[0]:.3f} | Happy={face_probs[1]:.3f} | Sad={face_probs[2]:.3f} | Angry={face_probs[3]:.3f}", flush=True)
         
         # Step 4: Get voice emotion
-        print(f"\n[Step 2/4] VOICE TONE ANALYSIS")
+        print(f"\n[Step 2/4] VOICE TONE ANALYSIS", flush=True)
         voice_probs, voice_emotion = voice_worker.get_probs()
         voice_state = voice_worker.get_state()
         voice_active = voice_state.get('speech_active', False)
         voice_inferences = voice_state.get('inference_count', 0)
         voice_skipped = voice_state.get('skipped_inferences', 0)
         
-        print(f"   {'ACTIVELY PROCESSING' if voice_active else 'IDLE (no recent speech)'}")
-        print(f"   Result: {voice_emotion}")
-        print(f"   Distribution: Neutral={voice_probs[0]:.3f} | Happy={voice_probs[1]:.3f} | Sad={voice_probs[2]:.3f} | Angry={voice_probs[3]:.3f}")
-        print(f"   Inferences completed: {voice_inferences}")
-        print(f"   Skipped (silence optimization): {voice_skipped}")
+        print(f"   {'ACTIVELY PROCESSING' if voice_active else 'IDLE (no recent speech)'}", flush=True)
+        print(f"   Result: {voice_emotion}", flush=True)
+        print(f"   Distribution: Neutral={voice_probs[0]:.3f} | Happy={voice_probs[1]:.3f} | Sad={voice_probs[2]:.3f} | Angry={voice_probs[3]:.3f}", flush=True)
+        print(f"   Inferences completed: {voice_inferences}", flush=True)
+        print(f"   Skipped (silence optimization): {voice_skipped}", flush=True)
         efficiency = (voice_inferences / (voice_inferences + voice_skipped) * 100) if (voice_inferences + voice_skipped) > 0 else 0
-        print(f"   Processing efficiency: {efficiency:.1f}%")
+        print(f"   Processing efficiency: {efficiency:.1f}%", flush=True)
         
         # Step 5: Analyze text sentiment
-        print(f"\n[Step 3/4] TEXT SENTIMENT ANALYSIS")
-        print(f"   Using Whisper transcription")
+        print(f"\n[Step 3/4] TEXT SENTIMENT ANALYSIS", flush=True)
+        print(f"   Using Whisper transcription", flush=True)
         text_analyzer.analyze(transcription)
         text_probs, _ = text_analyzer.get_probs()
         text_emotion = ['Neutral', 'Happy', 'Sad', 'Angry'][int(np.argmax(text_probs))]
         
-        print(f"   Result: {text_emotion}")
-        print(f"   Distribution: Neutral={text_probs[0]:.3f} | Happy={text_probs[1]:.3f} | Sad={text_probs[2]:.3f} | Angry={text_probs[3]:.3f}")
-        print(f"   Text length: {len(transcription)} characters")
+        print(f"   Result: {text_emotion}", flush=True)
+        print(f"   Distribution: Neutral={text_probs[0]:.3f} | Happy={text_probs[1]:.3f} | Sad={text_probs[2]:.3f} | Angry={text_probs[3]:.3f}", flush=True)
+        print(f"   Text length: {len(transcription)} characters", flush=True)
         
         # Step 6: Calculate fusion with quality-aware weights
-        print(f"\n[Step 4/4] MULTI-MODAL FUSION")
+        print(f"\n[Step 4/4] MULTI-MODAL FUSION", flush=True)
         base_weights = {
             'face': fusion_engine.alpha_face,
             'voice': fusion_engine.alpha_voice,
@@ -142,12 +155,12 @@ async def process_speech_end(
         total_weight = sum(adjusted_weights.values())
         final_weights = {k: v/total_weight for k, v in adjusted_weights.items()}
         
-        print(f"   Base weights:     Face={base_weights['face']:.3f} | Voice={base_weights['voice']:.3f} | Text={base_weights['text']:.3f}")
+        print(f"   Base weights:     Face={base_weights['face']:.3f} | Voice={base_weights['voice']:.3f} | Text={base_weights['text']:.3f}", flush=True)
         if adjustments_made:
-            print(f"   Adjustments:")
+            print(f"   Adjustments:", flush=True)
             for adj in adjustments_made:
-                print(f"      - {adj}")
-        print(f"   Final weights:    Face={final_weights['face']:.3f} | Voice={final_weights['voice']:.3f} | Text={final_weights['text']:.3f}")
+                print(f"      - {adj}", flush=True)
+        print(f"   Final weights:    Face={final_weights['face']:.3f} | Voice={final_weights['voice']:.3f} | Text={final_weights['text']:.3f}", flush=True)
         
         # Calculate weighted fusion
         fused_probs = (
@@ -170,84 +183,83 @@ async def process_speech_end(
         all_same = (face_emotion == voice_emotion == text_emotion)
         has_conflict = len({face_emotion, voice_emotion, text_emotion}) == 3
         
-        print(f"\n   {'─'*76}")
-        print(f"   FUSION RESULTS:")
-        print(f"   {'─'*76}")
-        print(f"   Input emotions:")
-        # ✅ FIX #3: Use module-level EMOTION_MAP (capital letters)
-        print(f"      Face:  {face_emotion:7s} (confidence={face_probs[EMOTION_MAP.get(face_emotion, 0)]:.3f}, weight={final_weights['face']:.3f})")
-        print(f"      Voice: {voice_emotion:7s} (confidence={voice_probs[EMOTION_MAP.get(voice_emotion, 0)]:.3f}, weight={final_weights['voice']:.3f})")
-        print(f"      Text:  {text_emotion:7s} (confidence={text_probs[EMOTION_MAP.get(text_emotion, 0)]:.3f}, weight={final_weights['text']:.3f})")
-        print(f"   {'─'*76}")
-        print(f"   FUSED EMOTION: {fused_emotion}")
-        print(f"   Intensity: {intensity:.3f}")
-        print(f"   Fused distribution: Neutral={fused_probs[0]:.3f} | Happy={fused_probs[1]:.3f} | Sad={fused_probs[2]:.3f} | Angry={fused_probs[3]:.3f}")
-        print(f"   {'─'*76}")
-        print(f"   Agreement: {agreement_count}/3 modalities ({agreement_score*100:.1f}%)")
+        print(f"\n   {'─'*76}", flush=True)
+        print(f"   FUSION RESULTS:", flush=True)
+        print(f"   {'─'*76}", flush=True)
+        print(f"   Input emotions:", flush=True)
+        print(f"      Face:  {face_emotion:7s} (confidence={face_probs[EMOTION_MAP.get(face_emotion, 0)]:.3f}, weight={final_weights['face']:.3f})", flush=True)
+        print(f"      Voice: {voice_emotion:7s} (confidence={voice_probs[EMOTION_MAP.get(voice_emotion, 0)]:.3f}, weight={final_weights['voice']:.3f})", flush=True)
+        print(f"      Text:  {text_emotion:7s} (confidence={text_probs[EMOTION_MAP.get(text_emotion, 0)]:.3f}, weight={final_weights['text']:.3f})", flush=True)
+        print(f"   {'─'*76}", flush=True)
+        print(f"   FUSED EMOTION: {fused_emotion}", flush=True)
+        print(f"   Intensity: {intensity:.3f}", flush=True)
+        print(f"   Fused distribution: Neutral={fused_probs[0]:.3f} | Happy={fused_probs[1]:.3f} | Sad={fused_probs[2]:.3f} | Angry={fused_probs[3]:.3f}", flush=True)
+        print(f"   {'─'*76}", flush=True)
+        print(f"   Agreement: {agreement_count}/3 modalities ({agreement_score*100:.1f}%)", flush=True)
         
         if all_same:
-            print(f"   Status: Perfect agreement - all modalities aligned")
+            print(f"   Status: Perfect agreement - all modalities aligned", flush=True)
         elif has_conflict:
-            print(f"   Status: Full conflict - weighted fusion resolved disagreement")
+            print(f"   Status: Full conflict - weighted fusion resolved disagreement", flush=True)
         else:
-            print(f"   Status: Partial agreement - majority vote with confidence weighting")
+            print(f"   Status: Partial agreement - majority vote with confidence weighting", flush=True)
         
-        print(f"   {'─'*76}")
+        print(f"   {'─'*76}", flush=True)
         
         # ========== LLM INPUT PREPARATION ==========
-        print(f"\n[LLM Input] Preparing context for language model...")
+        print(f"\n[LLM Input] Preparing context for language model...", flush=True)
         
         user_language = user_preferences.get("language", "en")
         
         context_prefix = ""
         if user_summary:
             context_prefix = f"[User context for {username}: {user_summary}]\n\n"
-            print(f"[LLM Input]    - User context: YES ({len(user_summary)} chars)")
+            print(f"[LLM Input]    - User context: YES ({len(user_summary)} chars)", flush=True)
         else:
-            print(f"[LLM Input]    - User context: NO (new user)")
+            print(f"[LLM Input]    - User context: NO (new user)", flush=True)
         
         # Add language instruction
         if user_language == "nl":
             context_prefix += "[BELANGRIJK: Antwoord ALTIJD in het Nederlands!]\n\n"
-            print(f"[LLM Input]    - Language: Dutch (Nederlands)")
+            print(f"[LLM Input]    - Language: Dutch (Nederlands)", flush=True)
         else:
             context_prefix += "[IMPORTANT: ALWAYS respond in English!]\n\n"
-            print(f"[LLM Input]    - Language: English")
+            print(f"[LLM Input]    - Language: English", flush=True)
         
         full_llm_input = context_prefix + transcription
         
-        print(f"[LLM Input]    - Fused emotion: {fused_emotion}")
-        print(f"[LLM Input]    - Face emotion: {face_emotion}")
-        print(f"[LLM Input]    - Voice emotion: {voice_emotion}")
-        print(f"[LLM Input]    - Intensity: {intensity:.3f}")
-        print(f"[LLM Input]    - User text: '{transcription}'")
-        print(f"[LLM Input]    - Full prompt length: {len(full_llm_input)} chars")
+        print(f"[LLM Input]    - Fused emotion: {fused_emotion}", flush=True)
+        print(f"[LLM Input]    - Face emotion: {face_emotion}", flush=True)
+        print(f"[LLM Input]    - Voice emotion: {voice_emotion}", flush=True)
+        print(f"[LLM Input]    - Intensity: {intensity:.3f}", flush=True)
+        print(f"[LLM Input]    - User text: '{transcription}'", flush=True)
+        print(f"[LLM Input]    - Full prompt length: {len(full_llm_input)} chars", flush=True)
         
         if len(context_prefix) > 50:
-            print(f"[LLM Input]    - Context preview: '{context_prefix[:100]}...'")
+            print(f"[LLM Input]    - Context preview: '{context_prefix[:100]}...'", flush=True)
         
         # Generate LLM response
-        print(f"\n[LLM] Generating response...")
+        print(f"\n[LLM] Generating response...", flush=True)
         response_text = llm_generator.generate_response(
             fused_emotion, face_emotion, voice_emotion,
             full_llm_input, force=True, intensity=intensity
         )
         
-        print(f"[LLM] Response generated: '{response_text}'")
+        print(f"[LLM] Response generated: '{response_text}'", flush=True)
         
         # Save assistant message
         save_message(session_id, "assistant", response_text, fused_emotion)
         
         # ========== SEND TO AVATAR FOR TTS ==========
-        print(f"\n[TTS] Sending to avatar backend...")
+        print(f"\n[TTS] Sending to avatar backend...", flush=True)
         
         try:
             voice_preference = user_preferences.get("voice", "female")
             language_preference = user_preferences.get("language", "en")
             
-            print(f"[TTS]    - Voice: {voice_preference}")
-            print(f"[TTS]    - Language: {language_preference}")
-            print(f"[TTS]    - Text: '{response_text}'")
+            print(f"[TTS]    - Voice: {voice_preference}", flush=True)
+            print(f"[TTS]    - Language: {language_preference}", flush=True)
+            print(f"[TTS]    - Text: '{response_text}'", flush=True)
             
             avatar_response = requests.post(
                 f"{AVATAR_API}/speak",
@@ -261,9 +273,9 @@ async def process_speech_end(
             avatar_response.raise_for_status()
             avatar_data = avatar_response.json()
             
-            print(f"[TTS] Avatar TTS generated")
-            print(f"[TTS]    - Audio URL: {avatar_data.get('audio_url', 'N/A')}")
-            print(f"[TTS]    - Visemes: {len(avatar_data.get('visemes', []))} keyframes")
+            print(f"[TTS] Avatar TTS generated", flush=True)
+            print(f"[TTS]    - Audio URL: {avatar_data.get('audio_url', 'N/A')}", flush=True)
+            print(f"[TTS]    - Visemes: {len(avatar_data.get('visemes', []))} keyframes", flush=True)
             
             await websocket.send_json({
                 "type": "llm_response",
@@ -274,10 +286,10 @@ async def process_speech_end(
                 "visemes": avatar_data.get("visemes")
             })
             
-            print(f"[Pipeline] Complete response sent to {username}")
+            print(f"[Pipeline] Complete response sent to {username}", flush=True)
         
         except requests.exceptions.ConnectionError:
-            print(f"[TTS] Avatar service not available - sending text-only")
+            print(f"[TTS] Avatar service not available - sending text-only", flush=True)
             await websocket.send_json({
                 "type": "llm_response",
                 "text": response_text,
@@ -287,7 +299,7 @@ async def process_speech_end(
             })
         
         except Exception as avatar_err:
-            print(f"[TTS] Avatar error: {avatar_err}")
+            print(f"[TTS] Avatar error: {avatar_err}", flush=True)
             await websocket.send_json({
                 "type": "llm_response",
                 "text": response_text,
@@ -297,9 +309,9 @@ async def process_speech_end(
                 "text_only": True
             })
         
-        print(f"{'='*80}\n")
+        print(f"{'='*80}\n", flush=True)
     
     except Exception as e:
-        print(f"[Pipeline] Error in emotion processing: {e}")
+        print(f"[Pipeline] Error in emotion processing: {e}", flush=True)
         import traceback
         traceback.print_exc()