claude-mpm 4.1.1__py3-none-any.whl → 4.1.2__py3-none-any.whl

claude_mpm/services/event_bus/config.py

@@ -8,78 +8,97 @@ WHY configuration module:
 """
 
 import os
-from typing import List, Optional
 from dataclasses import dataclass, field
+from typing import List, Optional
 
 
 @dataclass
 class EventBusConfig:
     """Configuration for EventBus service.
-    
+
     All settings can be overridden via environment variables.
     """
-    
+
     # Enable/disable the EventBus
     enabled: bool = field(
-        default_factory=lambda: os.environ.get("CLAUDE_MPM_EVENTBUS_ENABLED", "true").lower() == "true"
+        default_factory=lambda: os.environ.get(
+            "CLAUDE_MPM_EVENTBUS_ENABLED", "true"
+        ).lower()
+        == "true"
     )
-    
+
     # Debug logging
     debug: bool = field(
-        default_factory=lambda: os.environ.get("CLAUDE_MPM_EVENTBUS_DEBUG", "false").lower() == "true"
+        default_factory=lambda: os.environ.get(
+            "CLAUDE_MPM_EVENTBUS_DEBUG", "false"
+        ).lower()
+        == "true"
     )
-    
+
     # Event history settings
     max_history_size: int = field(
-        default_factory=lambda: int(os.environ.get("CLAUDE_MPM_EVENTBUS_HISTORY_SIZE", "100"))
+        default_factory=lambda: int(
+            os.environ.get("CLAUDE_MPM_EVENTBUS_HISTORY_SIZE", "100")
+        )
     )
-    
+
     # Event filters (comma-separated list)
     event_filters: List[str] = field(
         default_factory=lambda: [
-            f.strip() for f in os.environ.get("CLAUDE_MPM_EVENTBUS_FILTERS", "").split(",") 
+            f.strip()
+            for f in os.environ.get("CLAUDE_MPM_EVENTBUS_FILTERS", "").split(",")
             if f.strip()
         ]
     )
-    
+
     # Relay configuration
     relay_enabled: bool = field(
-        default_factory=lambda: os.environ.get("CLAUDE_MPM_RELAY_ENABLED", "true").lower() == "true"
+        default_factory=lambda: os.environ.get(
+            "CLAUDE_MPM_RELAY_ENABLED", "true"
+        ).lower()
+        == "true"
     )
-    
+
     relay_port: int = field(
         default_factory=lambda: int(os.environ.get("CLAUDE_MPM_SOCKETIO_PORT", "8765"))
     )
-    
+
     relay_debug: bool = field(
-        default_factory=lambda: os.environ.get("CLAUDE_MPM_RELAY_DEBUG", "false").lower() == "true"
+        default_factory=lambda: os.environ.get(
+            "CLAUDE_MPM_RELAY_DEBUG", "false"
+        ).lower()
+        == "true"
     )
-    
+
     # Connection settings
     relay_max_retries: int = field(
         default_factory=lambda: int(os.environ.get("CLAUDE_MPM_RELAY_MAX_RETRIES", "3"))
     )
-    
+
     relay_retry_delay: float = field(
-        default_factory=lambda: float(os.environ.get("CLAUDE_MPM_RELAY_RETRY_DELAY", "0.5"))
+        default_factory=lambda: float(
+            os.environ.get("CLAUDE_MPM_RELAY_RETRY_DELAY", "0.5")
+        )
     )
-    
+
     relay_connection_cooldown: float = field(
-        default_factory=lambda: float(os.environ.get("CLAUDE_MPM_RELAY_CONNECTION_COOLDOWN", "5.0"))
+        default_factory=lambda: float(
+            os.environ.get("CLAUDE_MPM_RELAY_CONNECTION_COOLDOWN", "5.0")
+        )
     )
-    
+
     @classmethod
     def from_env(cls) -> "EventBusConfig":
         """Create configuration from environment variables.
-        
+
         Returns:
             EventBusConfig: Configuration instance
         """
         return cls()
-    
+
     def to_dict(self) -> dict:
         """Convert configuration to dictionary.
-        
+
         Returns:
             dict: Configuration as dictionary
         """
@@ -93,12 +112,12 @@ class EventBusConfig:
             "relay_debug": self.relay_debug,
             "relay_max_retries": self.relay_max_retries,
             "relay_retry_delay": self.relay_retry_delay,
-            "relay_connection_cooldown": self.relay_connection_cooldown
+            "relay_connection_cooldown": self.relay_connection_cooldown,
         }
-    
+
     def apply_to_eventbus(self, event_bus) -> None:
         """Apply configuration to an EventBus instance.
-        
+
         Args:
             event_bus: EventBus instance to configure
         """
@@ -106,18 +125,18 @@ class EventBusConfig:
             event_bus.disable()
         else:
             event_bus.enable()
-        
+
         event_bus.set_debug(self.debug)
         event_bus._max_history_size = self.max_history_size
-        
+
         # Apply filters
         event_bus.clear_filters()
         for filter_pattern in self.event_filters:
             event_bus.add_filter(filter_pattern)
-    
+
     def apply_to_relay(self, relay) -> None:
         """Apply configuration to a SocketIORelay instance.
-        
+
         Args:
             relay: SocketIORelay instance to configure
         """
@@ -125,7 +144,7 @@ class EventBusConfig:
             relay.disable()
         else:
             relay.enable()
-        
+
         relay.port = self.relay_port
         relay.debug = self.relay_debug
         relay.max_retries = self.relay_max_retries
@@ -139,7 +158,7 @@ _config: Optional[EventBusConfig] = None
 
 def get_config() -> EventBusConfig:
     """Get the global EventBus configuration.
-    
+
     Returns:
         EventBusConfig: Configuration instance
     """
@@ -151,7 +170,7 @@ def get_config() -> EventBusConfig:
 
 def set_config(config: EventBusConfig) -> None:
     """Set the global EventBus configuration.
-    
+
     Args:
         config: Configuration to set
     """
@@ -162,4 +181,4 @@ def set_config(config: EventBusConfig) -> None:
 def reset_config() -> None:
     """Reset configuration to defaults from environment."""
     global _config
-    _config = EventBusConfig.from_env()
+    _config = EventBusConfig.from_env()

claude_mpm/services/event_bus/event_bus.py

@@ -13,6 +13,7 @@ import logging
 import threading
 from datetime import datetime
 from typing import Any, Callable, Dict, List, Optional, Set
+
 from pyee.asyncio import AsyncIOEventEmitter
 
 # Configure logger
@@ -21,17 +22,17 @@ logger = logging.getLogger(__name__)
 
 class EventBus:
     """Singleton Event Bus for decoupled event handling.
-    
+
     WHY singleton pattern:
     - Ensures single point of event coordination
     - Prevents duplicate event processing
     - Simplifies configuration and management
     - Thread-safe initialization with proper locking
     """
-    
+
     _instance: Optional["EventBus"] = None
     _lock = threading.Lock()
-    
+
     def __new__(cls) -> "EventBus":
         """Ensure singleton instance creation."""
         if cls._instance is None:
@@ -39,13 +40,13 @@ class EventBus:
                 if cls._instance is None:
                     cls._instance = super().__new__(cls)
         return cls._instance
-    
+
     def __init__(self):
         """Initialize the event bus once."""
         # Only initialize once
         if hasattr(self, "_initialized"):
             return
-            
+
         self._initialized = True
         self._emitter = AsyncIOEventEmitter()
         self._enabled = True
@@ -54,38 +55,38 @@ class EventBus:
             "events_published": 0,
             "events_filtered": 0,
             "events_failed": 0,
-            "last_event_time": None
+            "last_event_time": None,
         }
         self._debug = False
-        
+
         # Event history for debugging (limited size)
         self._event_history: List[Dict[str, Any]] = []
         self._max_history_size = 100
-        
+
         logger.info("EventBus initialized")
-    
+
     @classmethod
     def get_instance(cls) -> "EventBus":
         """Get the singleton EventBus instance.
-        
+
         Returns:
             EventBus: The singleton instance
         """
         return cls()
-    
+
     def enable(self) -> None:
         """Enable event bus processing."""
         self._enabled = True
         logger.info("EventBus enabled")
-    
+
     def disable(self) -> None:
         """Disable event bus processing (for testing or maintenance)."""
         self._enabled = False
         logger.info("EventBus disabled")
-    
+
     def set_debug(self, debug: bool) -> None:
         """Enable or disable debug logging.
-        
+
         Args:
             debug: Whether to enable debug logging
         """
@@ -94,46 +95,46 @@ class EventBus:
             logger.setLevel(logging.DEBUG)
         else:
             logger.setLevel(logging.INFO)
-    
+
     def add_filter(self, pattern: str) -> None:
         """Add an event filter pattern.
-        
+
         Only events matching filter patterns will be processed.
         Use wildcards: 'hook.*' matches all hook events.
-        
+
         Args:
             pattern: Event name pattern to allow
         """
         self._event_filters.add(pattern)
         logger.debug(f"Added event filter: {pattern}")
-    
+
     def remove_filter(self, pattern: str) -> None:
         """Remove an event filter pattern.
-        
+
         Args:
             pattern: Event name pattern to remove
         """
         self._event_filters.discard(pattern)
         logger.debug(f"Removed event filter: {pattern}")
-    
+
     def clear_filters(self) -> None:
         """Clear all event filters (allow all events)."""
         self._event_filters.clear()
         logger.debug("Cleared all event filters")
-    
+
     def _should_process_event(self, event_type: str) -> bool:
         """Check if an event should be processed based on filters.
-        
+
         Args:
             event_type: The event type to check
-            
+
         Returns:
             bool: True if event should be processed
         """
         # If no filters, process all events
         if not self._event_filters:
             return True
-            
+
         # Check if event matches any filter
         for filter_pattern in self._event_filters:
             if filter_pattern.endswith("*"):
@@ -144,19 +145,19 @@ class EventBus:
             elif event_type == filter_pattern:
                 # Exact match
                 return True
-                
+
         return False
-    
+
     def publish(self, event_type: str, data: Any) -> bool:
         """Publish an event synchronously (for use from sync contexts like hooks).
-        
+
         This method is thread-safe and can be called from any thread.
         Events are dispatched asynchronously to handlers.
-        
+
         Args:
             event_type: The event type (e.g., 'hook.pre_tool')
             data: The event data
-            
+
         Returns:
             bool: True if event was published, False if filtered or disabled
         """
@@ -164,23 +165,23 @@ class EventBus:
             if self._debug:
                 logger.debug(f"EventBus disabled, dropping event: {event_type}")
             return False
-        
+
         # Check filters
         if not self._should_process_event(event_type):
             self._stats["events_filtered"] += 1
             if self._debug:
                 logger.debug(f"Event filtered out: {event_type}")
             return False
-        
+
         try:
             # Record event in history
             self._record_event(event_type, data)
-            
+
             # Emit event to regular handlers (pyee handles thread safety)
             self._emitter.emit(event_type, data)
-            
+
             # Also emit to wildcard handlers
-            if hasattr(self, '_wildcard_handlers'):
+            if hasattr(self, "_wildcard_handlers"):
                 for prefix, handlers in self._wildcard_handlers.items():
                     if event_type.startswith(prefix):
                         for handler in handlers:
@@ -191,9 +192,13 @@ class EventBus:
                                     try:
                                         loop = asyncio.get_event_loop()
                                         if loop.is_running():
-                                            asyncio.create_task(handler(event_type, data))
+                                            asyncio.create_task(
+                                                handler(event_type, data)
+                                            )
                                         else:
-                                            loop.run_until_complete(handler(event_type, data))
+                                            loop.run_until_complete(
+                                                handler(event_type, data)
+                                            )
                                     except RuntimeError:
                                         # No event loop, skip async handler
                                         pass
@@ -202,83 +207,83 @@ class EventBus:
                             except Exception as e:
                                 if self._debug:
                                     logger.debug(f"Wildcard handler error: {e}")
-            
+
             # Update stats
             self._stats["events_published"] += 1
             self._stats["last_event_time"] = datetime.now().isoformat()
-            
+
             if self._debug:
                 logger.debug(f"Published event: {event_type}")
-            
+
             return True
-            
+
         except Exception as e:
             self._stats["events_failed"] += 1
             logger.error(f"Failed to publish event {event_type}: {e}")
             return False
-    
+
     async def publish_async(self, event_type: str, data: Any) -> bool:
         """Publish an event from an async context.
-        
+
         Args:
             event_type: The event type
             data: The event data
-            
+
         Returns:
             bool: True if event was published
         """
         # Just delegate to sync publish (pyee handles both)
         return self.publish(event_type, data)
-    
+
     def on(self, event_type: str, handler: Callable) -> None:
         """Register an event handler.
-        
+
         The handler can be sync or async. For async handlers,
         they will be scheduled on the event loop.
-        
+
         Args:
             event_type: The event type to listen for (supports wildcards)
             handler: The handler function
         """
         if event_type.endswith("*"):
             # Store wildcard handlers separately
-            if not hasattr(self, '_wildcard_handlers'):
+            if not hasattr(self, "_wildcard_handlers"):
                 self._wildcard_handlers = {}
-            
+
             prefix = event_type[:-1]
             if prefix not in self._wildcard_handlers:
                 self._wildcard_handlers[prefix] = []
             self._wildcard_handlers[prefix].append(handler)
-            
+
             logger.debug(f"Registered wildcard handler for: {event_type}")
         else:
             # Regular event registration
             self._emitter.on(event_type, handler)
             logger.debug(f"Registered handler for: {event_type}")
-    
+
     def once(self, event_type: str, handler: Callable) -> None:
         """Register a one-time event handler.
-        
+
         Args:
             event_type: The event type to listen for
             handler: The handler function
         """
         self._emitter.once(event_type, handler)
         logger.debug(f"Registered one-time handler for: {event_type}")
-    
+
     def remove_listener(self, event_type: str, handler: Callable) -> None:
         """Remove an event handler.
-        
+
         Args:
             event_type: The event type
             handler: The handler to remove
         """
         self._emitter.remove_listener(event_type, handler)
         logger.debug(f"Removed handler for: {event_type}")
-    
+
     def remove_all_listeners(self, event_type: Optional[str] = None) -> None:
         """Remove all listeners for an event type, or all listeners.
-        
+
         Args:
             event_type: Optional event type. If None, removes all listeners.
         """
@@ -288,10 +293,10 @@ class EventBus:
         else:
             self._emitter.remove_all_listeners()
             logger.debug("Removed all event handlers")
-    
+
     def _record_event(self, event_type: str, data: Any) -> None:
         """Record event in history for debugging.
-        
+
         Args:
             event_type: The event type
             data: The event data
@@ -299,18 +304,18 @@ class EventBus:
         event_record = {
             "timestamp": datetime.now().isoformat(),
             "type": event_type,
-            "data": data
+            "data": data,
         }
-        
+
         self._event_history.append(event_record)
-        
+
         # Trim history if too large
         if len(self._event_history) > self._max_history_size:
-            self._event_history = self._event_history[-self._max_history_size:]
-    
+            self._event_history = self._event_history[-self._max_history_size :]
+
     def get_stats(self) -> Dict[str, Any]:
         """Get event bus statistics.
-        
+
         Returns:
             dict: Statistics about event processing
         """
@@ -319,31 +324,31 @@ class EventBus:
             "enabled": self._enabled,
             "filters_active": len(self._event_filters) > 0,
             "filter_count": len(self._event_filters),
-            "history_size": len(self._event_history)
+            "history_size": len(self._event_history),
         }
-    
+
     def get_recent_events(self, limit: int = 10) -> List[Dict[str, Any]]:
         """Get recent events from history.
-        
+
         Args:
             limit: Maximum number of events to return
-            
+
         Returns:
             list: Recent events
         """
         return self._event_history[-limit:]
-    
+
     def clear_history(self) -> None:
         """Clear the event history."""
         self._event_history.clear()
         logger.debug("Cleared event history")
-    
+
     def reset_stats(self) -> None:
         """Reset event statistics."""
         self._stats = {
             "events_published": 0,
             "events_filtered": 0,
             "events_failed": 0,
-            "last_event_time": None
+            "last_event_time": None,
         }
-        logger.debug("Reset event statistics")
+        logger.debug("Reset event statistics")