Delete event_bus.py

event_bus.py

@@ -1,430 +0,0 @@
-"""
-Event Bus Implementation for Flare
-==================================
-Provides async event publishing and subscription mechanism
-"""
-import asyncio
-from typing import Dict, List, Callable, Any, Optional
-from enum import Enum
-from dataclasses import dataclass, field
-from datetime import datetime
-import traceback
-from collections import defaultdict
-import sys
-
-from utils.logger import log_info, log_error, log_debug, log_warning
-
-
-class EventType(Enum):
-    """All event types in the system"""
-    # Lifecycle events
-    SESSION_STARTED = "session_started"
-    SESSION_ENDED = "session_ended"
-    CONVERSATION_STARTED = "conversation_started"
-    CONVERSATION_ENDED = "conversation_ended" 
-    
-    # STT events
-    STT_STARTED = "stt_started"
-    STT_STOPPED = "stt_stopped"
-    STT_RESULT = "stt_result"
-    STT_ERROR = "stt_error"
-    STT_READY = "stt_ready"
-    
-    # TTS events
-    TTS_STARTED = "tts_started"
-    TTS_CHUNK_READY = "tts_chunk_ready"
-    TTS_COMPLETED = "tts_completed"
-    TTS_ERROR = "tts_error"
-    TTS_STOPPED = "tts_stopped"
-    
-    # Audio events
-    AUDIO_PLAYBACK_STARTED = "audio_playback_started"
-    AUDIO_PLAYBACK_COMPLETED = "audio_playback_completed"
-    AUDIO_BUFFER_LOW = "audio_buffer_low"
-    AUDIO_CHUNK_RECEIVED = "audio_chunk_received"
-    
-    # LLM events
-    LLM_PROCESSING_STARTED = "llm_processing_started"
-    LLM_RESPONSE_READY = "llm_response_ready"
-    LLM_ERROR = "llm_error"
-    
-    # Error events
-    CRITICAL_ERROR = "critical_error"
-    RECOVERABLE_ERROR = "recoverable_error"
-    
-    # State events
-    STATE_TRANSITION = "state_transition"
-    STATE_ROLLBACK = "state_rollback"
-    
-    # WebSocket events
-    WEBSOCKET_CONNECTED = "websocket_connected"
-    WEBSOCKET_DISCONNECTED = "websocket_disconnected"
-    WEBSOCKET_MESSAGE = "websocket_message"
-    WEBSOCKET_ERROR = "websocket_error"
-
-
-@dataclass
-class Event:
-    """Event data structure"""
-    type: EventType
-    data: Dict[str, Any]
-    session_id: Optional[str] = None
-    timestamp: datetime = field(default_factory=datetime.utcnow)
-    priority: int = 0
-    
-    def __lt__(self, other):
-        """Compare events by priority for PriorityQueue"""
-        if not isinstance(other, Event):
-            return NotImplemented
-        # Önce priority'ye göre karşılaştır
-        if self.priority != other.priority:
-            return self.priority < other.priority
-        # Priority eşitse timestamp'e göre karşılaştır
-        return self.timestamp < other.timestamp
-    
-    def __eq__(self, other):
-        """Check event equality"""
-        if not isinstance(other, Event):
-            return NotImplemented
-        return (self.priority == other.priority and 
-                self.timestamp == other.timestamp and
-                self.type == other.type)
-    
-    def __le__(self, other):
-        """Less than or equal comparison"""
-        return self == other or self < other
-    
-    def __gt__(self, other):
-        """Greater than comparison"""
-        return not self <= other
-    
-    def __ge__(self, other):
-        """Greater than or equal comparison"""
-        return not self < other
-        
-    def __post_init__(self):
-        if self.timestamp is None:
-            self.timestamp = datetime.utcnow()
-    
-    def to_dict(self) -> Dict[str, Any]:
-        """Convert to dictionary for serialization"""
-        return {
-            "type": self.type.value,
-            "session_id": self.session_id,
-            "data": self.data,
-            "timestamp": self.timestamp.isoformat(),
-            "priority": self.priority
-        }
-
-
-class EventBus:
-    """Central event bus for component communication with session isolation"""
-    
-    def __init__(self):
-        self._subscribers: Dict[EventType, List[Callable]] = defaultdict(list)
-        self._session_handlers: Dict[str, Dict[EventType, List[Callable]]] = defaultdict(lambda: defaultdict(list))
-        
-        # Session-specific queues for parallel processing
-        self._session_queues: Dict[str, asyncio.PriorityQueue] = {}
-        self._session_processors: Dict[str, asyncio.Task] = {}
-        
-        # Global queue for non-session events
-        self._global_queue: asyncio.PriorityQueue = asyncio.PriorityQueue()
-        self._global_processor: Optional[asyncio.Task] = None
-        
-        self._running = False
-        self._event_history: List[Event] = []
-        self._max_history_size = 1000
-        
-    async def start(self):
-        """Start the event processor"""
-        if self._running:
-            log_warning("EventBus already running")
-            return
-            
-        self._running = True
-        
-        # Start global processor
-        self._global_processor = asyncio.create_task(self._process_global_events())
-        
-        log_info("✅ EventBus started")
-        
-    async def stop(self):
-        """Stop the event processor"""
-        self._running = False
-        
-        # Stop all session processors
-        for session_id, task in list(self._session_processors.items()):
-            task.cancel()
-            try:
-                await asyncio.wait_for(task, timeout=2.0)
-            except (asyncio.TimeoutError, asyncio.CancelledError):
-                pass
-                
-        # Stop global processor
-        if self._global_processor:
-            await self._global_queue.put((999, None))  # Sentinel
-            try:
-                await asyncio.wait_for(self._global_processor, timeout=5.0)
-            except asyncio.TimeoutError:
-                log_warning("EventBus global processor timeout, cancelling")
-                self._global_processor.cancel()
-                
-        log_info("✅ EventBus stopped")
-        
-    async def publish(self, event: Event):
-        """Publish an event to the bus"""
-        if not self._running:
-            log_error("EventBus not running, cannot publish event", event_type=event.type.value)
-            return
-            
-        # Add to history
-        self._event_history.append(event)
-        if len(self._event_history) > self._max_history_size:
-            self._event_history.pop(0)
-            
-        # Route to appropriate queue
-        if event.session_id:
-            # Ensure session queue exists
-            if event.session_id not in self._session_queues:
-                await self._create_session_processor(event.session_id)
-                
-            # Add to session queue
-            queue = self._session_queues[event.session_id]
-            await queue.put((-event.priority, event))
-        else:
-            # Add to global queue
-            await self._global_queue.put((-event.priority, event))
-                    
-    async def _create_session_processor(self, session_id: str):
-        """Create a processor for session-specific events"""
-        if session_id in self._session_processors:
-            return
-            
-        # Create queue
-        self._session_queues[session_id] = asyncio.PriorityQueue()
-        
-        # Create processor task
-        task = asyncio.create_task(self._process_session_events(session_id))
-        self._session_processors[session_id] = task
-        
-        log_debug(f"📌 Created session processor", session_id=session_id)
-        
-    async def _process_session_events(self, session_id: str):
-        """Process events for a specific session"""
-        queue = self._session_queues[session_id]
-        log_info(f"🔄 Session event processor started", session_id=session_id)
-        
-        while self._running:
-            try:
-                # Wait for event with timeout
-                priority, event = await asyncio.wait_for(
-                    queue.get(),
-                    timeout=60.0  # Longer timeout for sessions
-                )
-                
-                # Check for session cleanup
-                if event is None:
-                    break
-                    
-                # Process the event
-                await self._dispatch_event(event)
-                
-            except asyncio.TimeoutError:
-                # Check if session is still active
-                if session_id not in self._session_handlers:
-                    log_info(f"Session inactive, stopping processor", session_id=session_id)
-                    break
-                continue
-            except Exception as e:
-                log_error(
-                    f"❌ Error processing session event",
-                    session_id=session_id,
-                    error=str(e),
-                    traceback=traceback.format_exc()
-                )
-                
-        # Cleanup
-        self._session_queues.pop(session_id, None)
-        self._session_processors.pop(session_id, None)
-        log_info(f"🔄 Session event processor stopped", session_id=session_id)
-        
-    async def _process_global_events(self):
-        """Process global events (no session_id)"""
-        log_info("🔄 Global event processor started")
-        
-        while self._running:
-            try:
-                priority, event = await asyncio.wait_for(
-                    self._global_queue.get(),
-                    timeout=1.0
-                )
-                
-                if event is None:  # Sentinel
-                    break
-                    
-                await self._dispatch_event(event)
-                
-            except asyncio.TimeoutError:
-                continue
-            except Exception as e:
-                log_error(
-                    "❌ Error processing global event",
-                    error=str(e),
-                    traceback=traceback.format_exc()
-                )
-                
-        log_info("🔄 Global event processor stopped")
-        
-    def subscribe(self, event_type: EventType, handler: Callable):
-        """Subscribe to an event type globally"""
-        self._subscribers[event_type].append(handler)
-        log_debug(f"📌 Global subscription added", event_type=event_type.value)
-        
-    def subscribe_session(self, session_id: str, event_type: EventType, handler: Callable):
-        """Subscribe to an event type for a specific session"""
-        self._session_handlers[session_id][event_type].append(handler)
-        log_debug(
-            f"📌 Session subscription added",
-            event_type=event_type.value,
-            session_id=session_id
-        )
-        
-    def unsubscribe(self, event_type: EventType, handler: Callable):
-        """Unsubscribe from an event type"""
-        if handler in self._subscribers[event_type]:
-            self._subscribers[event_type].remove(handler)
-            log_debug(f"📌 Global subscription removed", event_type=event_type.value)
-            
-    def unsubscribe_session(self, session_id: str, event_type: EventType = None):
-        """Unsubscribe session handlers"""
-        if event_type:
-            # Remove specific event type for session
-            if session_id in self._session_handlers and event_type in self._session_handlers[session_id]:
-                del self._session_handlers[session_id][event_type]
-        else:
-            # Remove all handlers for session
-            if session_id in self._session_handlers:
-                del self._session_handlers[session_id]
-                log_debug(f"📌 All session subscriptions removed", session_id=session_id)
-
-        
-    async def _dispatch_event(self, event: Event):
-        """Dispatch event to all subscribers"""
-        try:
-            handlers = []
-            
-            # Get global handlers
-            if event.type in self._subscribers:
-                handlers.extend(self._subscribers[event.type])
-                
-            # Get session-specific handlers
-            if event.session_id in self._session_handlers:
-                if event.type in self._session_handlers[event.session_id]:
-                    handlers.extend(self._session_handlers[event.session_id][event.type])
-                    
-            if not handlers:
-                log_debug(
-                    f"📭 No handlers for event",
-                    event_type=event.type.value,
-                    session_id=event.session_id
-                )
-                return
-            
-            # Call all handlers concurrently
-            tasks = []
-            for handler in handlers:
-                if asyncio.iscoroutinefunction(handler):
-                    task = asyncio.create_task(handler(event))
-                else:
-                    # Wrap sync handler in async
-                    task = asyncio.create_task(asyncio.to_thread(handler, event))
-                tasks.append(task)
-                
-            # Wait for all handlers to complete
-            results = await asyncio.gather(*tasks, return_exceptions=True)
-            
-            # Log any exceptions
-            for i, result in enumerate(results):
-                if isinstance(result, Exception):
-                    log_error(
-                        f"❌ Handler error",
-                        handler=handlers[i].__name__,
-                        event_type=event.type.value,
-                        error=str(result),
-                        traceback=traceback.format_exception(type(result), result, result.__traceback__)
-                    )
-                    
-        except Exception as e:
-            log_error(
-                f"❌ Error dispatching event",
-                event_type=event.type.value,
-                error=str(e),
-                traceback=traceback.format_exc()
-            )
-            
-    def get_event_history(self, session_id: Optional[str] = None, event_type: Optional[EventType] = None) -> List[Event]:
-        """Get event history with optional filters"""
-        history = self._event_history
-        
-        if session_id:
-            history = [e for e in history if e.session_id == session_id]
-            
-        if event_type:
-            history = [e for e in history if e.type == event_type]
-            
-        return history
-        
-    def clear_session_data(self, session_id: str):
-        """Clear all session-related data and stop processor"""
-        # Remove session handlers
-        self.unsubscribe_session(session_id)
-        
-        # Stop session processor
-        if session_id in self._session_processors:
-            task = self._session_processors[session_id]
-            task.cancel()
-            
-        # Clear queues
-        self._session_queues.pop(session_id, None)
-        self._session_processors.pop(session_id, None)
-        
-        # Remove session events from history
-        self._event_history = [e for e in self._event_history if e.session_id != session_id]
-        
-        log_debug(f"🧹 Session data cleared", session_id=session_id)
-
-
-# Global event bus instance
-event_bus = EventBus()
-
-
-# Helper functions for common event publishing patterns
-async def publish_error(session_id: str, error_type: str, error_message: str, details: Dict[str, Any] = None):
-    """Helper to publish error events"""
-    event = Event(
-        type=EventType.RECOVERABLE_ERROR if error_type != "critical" else EventType.CRITICAL_ERROR,
-        session_id=session_id,
-        data={
-            "error_type": error_type,
-            "message": error_message,
-            "details": details or {}
-        },
-        priority=10  # High priority for errors
-    )
-    await event_bus.publish(event)
-    
-
-async def publish_state_transition(session_id: str, from_state: str, to_state: str, reason: str = None):
-    """Helper to publish state transition events"""
-    event = Event(
-        type=EventType.STATE_TRANSITION,
-        session_id=session_id,
-        data={
-            "from_state": from_state,
-            "to_state": to_state,
-            "reason": reason
-        },
-        priority=5  # Medium priority for state changes
-    )
-    await event_bus.publish(event)