Delete stt_lifecycle_manager.py

stt_lifecycle_manager.py

@@ -1,368 +0,0 @@
-"""
-STT Lifecycle Manager for Flare
-===============================
-Manages STT instances lifecycle per session
-"""
-import asyncio
-from typing import Dict, Optional, Any
-from datetime import datetime
-import traceback
-import base64
-
-from event_bus import EventBus, Event, EventType, publish_error
-from resource_manager import ResourceManager, ResourceType
-from stt.stt_factory import STTFactory
-from stt.stt_interface import STTInterface, STTConfig, TranscriptionResult
-from utils.logger import log_info, log_error, log_debug, log_warning
-
-
-class STTSession:
-    """STT session wrapper"""
-    
-    def __init__(self, session_id: str, stt_instance: STTInterface):
-        self.session_id = session_id
-        self.stt_instance = stt_instance
-        self.is_streaming = False
-        self.config: Optional[STTConfig] = None
-        self.created_at = datetime.utcnow()
-        self.last_activity = datetime.utcnow()
-        self.total_chunks = 0
-        self.total_bytes = 0
-        
-    def update_activity(self):
-        """Update last activity timestamp"""
-        self.last_activity = datetime.utcnow()
-
-
-class STTLifecycleManager:
-    """Manages STT instances lifecycle"""
-    
-    def __init__(self, event_bus: EventBus, resource_manager: ResourceManager):
-        self.event_bus = event_bus
-        self.resource_manager = resource_manager
-        self.stt_sessions: Dict[str, STTSession] = {}
-        self._setup_event_handlers()
-        self._setup_resource_pool()
-        
-    def _setup_event_handlers(self):
-        """Subscribe to STT-related events"""
-        self.event_bus.subscribe(EventType.STT_STARTED, self._handle_stt_start)
-        self.event_bus.subscribe(EventType.STT_STOPPED, self._handle_stt_stop)
-        self.event_bus.subscribe(EventType.AUDIO_CHUNK_RECEIVED, self._handle_audio_chunk)
-        self.event_bus.subscribe(EventType.SESSION_ENDED, self._handle_session_ended)
-        
-    def _setup_resource_pool(self):
-        """Setup STT instance pool"""
-        self.resource_manager.register_pool(
-            resource_type=ResourceType.STT_INSTANCE,
-            factory=self._create_stt_instance,
-            max_idle=5,
-            max_age_seconds=300  # 5 minutes
-        )
-        
-    async def _create_stt_instance(self) -> STTInterface:
-        """Factory for creating STT instances"""
-        try:
-            stt_instance = STTFactory.create_provider()
-            if not stt_instance:
-                raise ValueError("Failed to create STT instance")
-                
-            log_debug("🎤 Created new STT instance")
-            return stt_instance
-            
-        except Exception as e:
-            log_error(f"❌ Failed to create STT instance", error=str(e))
-            raise
-            
-    async def _handle_stt_start(self, event: Event):
-        """Handle STT start request"""
-        session_id = event.session_id
-        config_data = event.data
-        
-        try:
-            log_info(f"🎤 Starting STT", session_id=session_id)
-            
-            # Check if already exists
-            if session_id in self.stt_sessions:
-                stt_session = self.stt_sessions[session_id]
-                if stt_session.is_streaming:
-                    log_warning(f"⚠️ STT already streaming", session_id=session_id)
-                    return
-            else:
-                # Acquire STT instance from pool
-                resource_id = f"stt_{session_id}"
-                stt_instance = await self.resource_manager.acquire(
-                    resource_id=resource_id,
-                    session_id=session_id,
-                    resource_type=ResourceType.STT_INSTANCE,
-                    cleanup_callback=self._cleanup_stt_instance
-                )
-                
-                # Create session wrapper
-                stt_session = STTSession(session_id, stt_instance)
-                self.stt_sessions[session_id] = stt_session
-                
-            # Get session locale from state orchestrator
-            locale = config_data.get("locale", "tr")
-            
-            # Build STT config - ✅ CONTINUOUS LISTENING İÇİN AYARLAR
-            stt_config = STTConfig(
-                language=self._get_language_code(locale),
-                sample_rate=config_data.get("sample_rate", 16000),
-                encoding=config_data.get("encoding", "WEBM_OPUS"),  # Try "LINEAR16" if WEBM fails
-                enable_punctuation=config_data.get("enable_punctuation", True),
-                enable_word_timestamps=False,
-                model=config_data.get("model", "latest_long"),
-                use_enhanced=config_data.get("use_enhanced", True),
-                single_utterance=False,  # ✅ Continuous listening için FALSE olmalı
-                interim_results=True,    # ✅ Interim results'ı AÇ
-            )
-            
-            # Log the exact config being used
-            log_info(f"📋 STT Config: encoding={stt_config.encoding}, "
-                     f"sample_rate={stt_config.sample_rate}, "
-                     f"single_utterance={stt_config.single_utterance}, "
-                     f"interim_results={stt_config.interim_results}")
-            
-            stt_session.config = stt_config
-            
-            # Start streaming
-            await stt_session.stt_instance.start_streaming(stt_config)
-            stt_session.is_streaming = True
-            stt_session.update_activity()
-            
-            log_info(f"✅ STT started in continuous mode with interim results", session_id=session_id, language=stt_config.language)
-            
-            # Notify STT is ready
-            await self.event_bus.publish(Event(
-                type=EventType.STT_READY,
-                session_id=session_id,
-                data={"language": stt_config.language}
-            ))
-            
-        except Exception as e:
-            log_error(
-                f"❌ Failed to start STT",
-                session_id=session_id,
-                error=str(e),
-                traceback=traceback.format_exc()
-            )
-            
-            # Clean up on error
-            if session_id in self.stt_sessions:
-                await self._cleanup_session(session_id)
-                
-            # Publish error event
-            await publish_error(
-                session_id=session_id,
-                error_type="stt_error",
-                error_message=f"Failed to start STT: {str(e)}"
-            )
-            
-    async def _handle_stt_stop(self, event: Event):
-        """Handle STT stop request"""
-        session_id = event.session_id
-        reason = event.data.get("reason", "unknown")
-        
-        log_info(f"🛑 Stopping STT", session_id=session_id, reason=reason)
-        
-        stt_session = self.stt_sessions.get(session_id)
-        if not stt_session:
-            log_warning(f"⚠️ No STT session found", session_id=session_id)
-            return
-            
-        try:
-            if stt_session.is_streaming:
-                # Stop streaming
-                final_result = await stt_session.stt_instance.stop_streaming()
-                stt_session.is_streaming = False
-                
-                # If we got a final result, publish it
-                if final_result and final_result.text:
-                    await self.event_bus.publish(Event(
-                        type=EventType.STT_RESULT,
-                        session_id=session_id,
-                        data={
-                            "text": final_result.text,
-                            "is_final": True,
-                            "confidence": final_result.confidence
-                        }
-                    ))
-                    
-            # Don't remove session immediately - might restart
-            stt_session.update_activity()
-            
-            log_info(f"✅ STT stopped", session_id=session_id)
-            
-        except Exception as e:
-            log_error(
-                f"❌ Error stopping STT",
-                session_id=session_id,
-                error=str(e)
-            )
-            
-    async def _handle_audio_chunk(self, event: Event):
-        """Process audio chunk through STT"""
-        session_id = event.session_id
-        
-        stt_session = self.stt_sessions.get(session_id)
-        if not stt_session or not stt_session.is_streaming:
-            # STT not ready, ignore chunk
-            return
-            
-        try:
-            # Decode audio data
-            audio_data = base64.b64decode(event.data.get("audio_data", ""))
-            
-            # Update stats
-            stt_session.total_chunks += 1
-            stt_session.total_bytes += len(audio_data)
-            stt_session.update_activity()
-            
-            # Stream to STT
-            async for result in stt_session.stt_instance.stream_audio(audio_data):
-                # Publish transcription results
-                await self.event_bus.publish(Event(
-                    type=EventType.STT_RESULT,
-                    session_id=session_id,
-                    data={
-                        "text": result.text,
-                        "is_final": result.is_final,
-                        "confidence": result.confidence,
-                        "timestamp": result.timestamp
-                    }
-                ))
-                
-                # Log final results
-                if result.is_final:
-                    log_info(
-                        f"📝 STT final result",
-                        session_id=session_id,
-                        text=result.text[:50] + "..." if len(result.text) > 50 else result.text,
-                        confidence=result.confidence
-                    )
-                    
-            # Log progress periodically
-            if stt_session.total_chunks % 100 == 0:
-                log_debug(
-                    f"📊 STT progress",
-                    session_id=session_id,
-                    chunks=stt_session.total_chunks,
-                    bytes=stt_session.total_bytes
-                )
-                
-        except Exception as e:
-            log_error(
-                f"❌ Error processing audio chunk",
-                session_id=session_id,
-                error=str(e)
-            )
-            
-            # Check if it's a recoverable error
-            if "stream duration" in str(e) or "timeout" in str(e).lower():
-                # STT timeout, restart needed
-                await publish_error(
-                    session_id=session_id,
-                    error_type="stt_timeout",
-                    error_message="STT stream timeout, restart needed"
-                )
-            else:
-                # Other STT error
-                await publish_error(
-                    session_id=session_id,
-                    error_type="stt_error",
-                    error_message=str(e)
-                )
-                
-    async def _handle_session_ended(self, event: Event):
-        """Clean up STT resources when session ends"""
-        session_id = event.session_id
-        await self._cleanup_session(session_id)
-        
-    async def _cleanup_session(self, session_id: str):
-        """Clean up STT session"""
-        stt_session = self.stt_sessions.pop(session_id, None)
-        if not stt_session:
-            return
-            
-        try:
-            # Stop streaming if active
-            if stt_session.is_streaming:
-                await stt_session.stt_instance.stop_streaming()
-                
-            # Release resource
-            resource_id = f"stt_{session_id}"
-            await self.resource_manager.release(resource_id, delay_seconds=60)
-            
-            log_info(
-                f"🧹 STT session cleaned up",
-                session_id=session_id,
-                total_chunks=stt_session.total_chunks,
-                total_bytes=stt_session.total_bytes
-            )
-            
-        except Exception as e:
-            log_error(
-                f"❌ Error cleaning up STT session",
-                session_id=session_id,
-                error=str(e)
-            )
-            
-    async def _cleanup_stt_instance(self, stt_instance: STTInterface):
-        """Cleanup callback for STT instance"""
-        try:
-            # Ensure streaming is stopped
-            if hasattr(stt_instance, 'is_streaming') and stt_instance.is_streaming:
-                await stt_instance.stop_streaming()
-                
-            log_debug("🧹 STT instance cleaned up")
-            
-        except Exception as e:
-            log_error(f"❌ Error cleaning up STT instance", error=str(e))
-            
-    def _get_language_code(self, locale: str) -> str:
-        """Convert locale to STT language code"""
-        # Map common locales to STT language codes
-        locale_map = {
-            "tr": "tr-TR",
-            "en": "en-US",
-            "de": "de-DE",
-            "fr": "fr-FR",
-            "es": "es-ES",
-            "it": "it-IT",
-            "pt": "pt-BR",
-            "ru": "ru-RU",
-            "ja": "ja-JP",
-            "ko": "ko-KR",
-            "zh": "zh-CN",
-            "ar": "ar-SA"
-        }
-        
-        # Check direct match
-        if locale in locale_map:
-            return locale_map[locale]
-            
-        # Check if it's already a full code
-        if "-" in locale and len(locale) == 5:
-            return locale
-            
-        # Default to locale-LOCALE format
-        return f"{locale}-{locale.upper()}"
-        
-    def get_stats(self) -> Dict[str, Any]:
-        """Get STT manager statistics"""
-        session_stats = {}
-        for session_id, stt_session in self.stt_sessions.items():
-            session_stats[session_id] = {
-                "is_streaming": stt_session.is_streaming,
-                "total_chunks": stt_session.total_chunks,
-                "total_bytes": stt_session.total_bytes,
-                "uptime_seconds": (datetime.utcnow() - stt_session.created_at).total_seconds(),
-                "last_activity": stt_session.last_activity.isoformat()
-            }
-            
-        return {
-            "active_sessions": len(self.stt_sessions),
-            "streaming_sessions": sum(1 for s in self.stt_sessions.values() if s.is_streaming),
-            "sessions": session_stats
-        }