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

claude_mpm/services/events/interfaces.py

@@ -8,223 +8,207 @@ Defines the contracts for event producers and consumers in the event bus system.
 from abc import ABC, abstractmethod
 from dataclasses import dataclass
 from enum import Enum
-from typing import Any, Callable, Dict, List, Optional, Pattern, Set
+from typing import Any, Callable, Dict, List, Optional, Pattern
 
 from .core import Event
 
 
 class ConsumerPriority(Enum):
     """Priority levels for event consumers."""
-    CRITICAL = 1    # Process first (e.g., error handlers)
-    HIGH = 2        # Important consumers (e.g., Socket.IO)
-    NORMAL = 3      # Default priority
-    LOW = 4         # Background processing
-    DEFERRED = 5    # Process last (e.g., metrics, logging)
+
+    CRITICAL = 1  # Process first (e.g., error handlers)
+    HIGH = 2  # Important consumers (e.g., Socket.IO)
+    NORMAL = 3  # Default priority
+    LOW = 4  # Background processing
+    DEFERRED = 5  # Process last (e.g., metrics, logging)
 
 
 @dataclass
 class ConsumerConfig:
     """Configuration for an event consumer."""
-    name: str                                    # Consumer identifier
-    topics: Optional[List[str]] = None          # Topics to subscribe to (None = all)
-    topic_pattern: Optional[Pattern] = None     # Regex pattern for topics
+
+    name: str  # Consumer identifier
+    topics: Optional[List[str]] = None  # Topics to subscribe to (None = all)
+    topic_pattern: Optional[Pattern] = None  # Regex pattern for topics
     priority: ConsumerPriority = ConsumerPriority.NORMAL
-    batch_size: int = 1                         # Process events in batches
-    batch_timeout: float = 0.0                  # Max time to wait for batch
-    max_retries: int = 3                        # Retry failed events
-    retry_backoff: float = 1.0                  # Backoff multiplier
-    error_handler: Optional[Callable] = None    # Custom error handler
-    filter_func: Optional[Callable] = None      # Event filter function
-    transform_func: Optional[Callable] = None   # Event transformation
+    batch_size: int = 1  # Process events in batches
+    batch_timeout: float = 0.0  # Max time to wait for batch
+    max_retries: int = 3  # Retry failed events
+    retry_backoff: float = 1.0  # Backoff multiplier
+    error_handler: Optional[Callable] = None  # Custom error handler
+    filter_func: Optional[Callable] = None  # Event filter function
+    transform_func: Optional[Callable] = None  # Event transformation
 
 
 class IEventProducer(ABC):
     """
     Interface for event producers.
-    
+
     Producers create and publish events to the event bus without
     knowing about consumers or handling errors.
     """
-    
+
     @abstractmethod
     async def publish(self, event: Event) -> bool:
         """
         Publish an event to the bus.
-        
+
         Args:
             event: The event to publish
-            
+
         Returns:
             True if event was accepted, False otherwise
         """
-        pass
-    
+
     @abstractmethod
     async def publish_batch(self, events: List[Event]) -> int:
         """
         Publish multiple events efficiently.
-        
+
         Args:
             events: List of events to publish
-            
+
         Returns:
             Number of events successfully published
         """
-        pass
-    
+
     @property
     @abstractmethod
     def source_name(self) -> str:
         """Get the name of this event source."""
-        pass
 
 
 class IEventConsumer(ABC):
     """
     Interface for event consumers.
-    
+
     Consumers subscribe to events and process them asynchronously.
     Each consumer is responsible for its own error handling.
     """
-    
+
     @abstractmethod
     async def initialize(self) -> bool:
         """
         Initialize the consumer.
-        
+
         Returns:
             True if initialization successful
         """
-        pass
-    
+
     @abstractmethod
     async def consume(self, event: Event) -> bool:
         """
         Process a single event.
-        
+
         Args:
             event: The event to process
-            
+
         Returns:
             True if event processed successfully
         """
-        pass
-    
+
     @abstractmethod
     async def consume_batch(self, events: List[Event]) -> int:
         """
         Process multiple events in a batch.
-        
+
         Args:
             events: List of events to process
-            
+
         Returns:
             Number of events successfully processed
         """
-        pass
-    
+
     @abstractmethod
     async def shutdown(self) -> None:
         """Shutdown the consumer gracefully."""
-        pass
-    
+
     @property
     @abstractmethod
     def config(self) -> ConsumerConfig:
         """Get consumer configuration."""
-        pass
-    
+
     @property
     @abstractmethod
     def is_healthy(self) -> bool:
         """Check if consumer is healthy."""
-        pass
-    
+
     @abstractmethod
     def get_metrics(self) -> Dict[str, Any]:
         """
         Get consumer metrics.
-        
+
         Returns:
             Dictionary of metrics (events processed, errors, etc.)
         """
-        pass
 
 
 class IEventBus(ABC):
     """
     Interface for the event bus.
-    
+
     The event bus manages subscriptions and routes events from
     producers to consumers.
     """
-    
+
     @abstractmethod
     async def start(self) -> None:
         """Start the event bus."""
-        pass
-    
+
     @abstractmethod
     async def stop(self) -> None:
         """Stop the event bus gracefully."""
-        pass
-    
+
     @abstractmethod
     async def publish(self, event: Event) -> bool:
         """
         Publish an event to the bus.
-        
+
         Args:
             event: The event to publish
-            
+
         Returns:
             True if event was queued successfully
         """
-        pass
-    
+
     @abstractmethod
     async def subscribe(self, consumer: IEventConsumer) -> bool:
         """
         Subscribe a consumer to the bus.
-        
+
         Args:
             consumer: The consumer to subscribe
-            
+
         Returns:
             True if subscription successful
         """
-        pass
-    
+
     @abstractmethod
     async def unsubscribe(self, consumer_name: str) -> bool:
         """
         Unsubscribe a consumer from the bus.
-        
+
         Args:
             consumer_name: Name of the consumer to unsubscribe
-            
+
         Returns:
             True if unsubscription successful
         """
-        pass
-    
+
     @abstractmethod
     def get_consumers(self) -> List[IEventConsumer]:
         """Get list of active consumers."""
-        pass
-    
+
     @abstractmethod
     def get_metrics(self) -> Dict[str, Any]:
         """
         Get event bus metrics.
-        
+
         Returns:
             Dictionary of metrics (queue size, throughput, etc.)
         """
-        pass
-    
+
     @property
     @abstractmethod
     def is_running(self) -> bool:
         """Check if event bus is running."""
-        pass

claude_mpm/services/events/producers/__init__.py

@@ -11,4 +11,4 @@ from .system import SystemEventProducer
 __all__ = [
     "HookEventProducer",
     "SystemEventProducer",
-]
+]

claude_mpm/services/events/producers/hook.py

@@ -19,64 +19,64 @@ from ..interfaces import IEventBus, IEventProducer
 class HookEventProducer(IEventProducer):
     """
     Publishes hook events to the event bus.
-    
+
     This producer is used by the hook handler to publish events
     without knowing about Socket.IO or other consumers.
     """
-    
+
     def __init__(self, event_bus: IEventBus):
         """
         Initialize hook event producer.
-        
+
         Args:
             event_bus: The event bus to publish to
         """
         self.logger = get_logger("HookEventProducer")
         self.event_bus = event_bus
         self._source_name = "hook_handler"
-        
+
         # Metrics
         self._metrics = {
             "events_published": 0,
             "events_failed": 0,
             "batch_published": 0,
         }
-    
+
     async def publish(self, event: Event) -> bool:
         """Publish a hook event to the bus."""
         try:
             success = await self.event_bus.publish(event)
-            
+
             if success:
                 self._metrics["events_published"] += 1
             else:
                 self._metrics["events_failed"] += 1
-            
+
             return success
-            
+
         except Exception as e:
             self.logger.error(f"Error publishing hook event: {e}")
             self._metrics["events_failed"] += 1
             return False
-    
+
     async def publish_batch(self, events: List[Event]) -> int:
         """Publish multiple hook events."""
         successful = 0
-        
+
         for event in events:
             if await self.publish(event):
                 successful += 1
-        
+
         self._metrics["batch_published"] += 1
         return successful
-    
+
     @property
     def source_name(self) -> str:
         """Get the name of this event source."""
         return self._source_name
-    
+
     # Convenience methods for common hook events
-    
+
     async def publish_response(
         self,
         response_data: Dict[str, Any],
@@ -84,11 +84,11 @@ class HookEventProducer(IEventProducer):
     ) -> bool:
         """
         Publish an assistant response event.
-        
+
         Args:
             response_data: The response data
             correlation_id: Optional correlation ID
-            
+
         Returns:
             True if published successfully
         """
@@ -102,9 +102,9 @@ class HookEventProducer(IEventProducer):
             correlation_id=correlation_id,
             priority=EventPriority.HIGH,
         )
-        
+
         return await self.publish(event)
-    
+
     async def publish_tool_use(
         self,
         tool_name: str,
@@ -114,13 +114,13 @@ class HookEventProducer(IEventProducer):
     ) -> bool:
         """
         Publish a tool usage event.
-        
+
         Args:
             tool_name: Name of the tool used
             tool_params: Parameters passed to the tool
             tool_result: Optional tool result
             correlation_id: Optional correlation ID
-            
+
         Returns:
             True if published successfully
         """
@@ -138,9 +138,9 @@ class HookEventProducer(IEventProducer):
             correlation_id=correlation_id,
             priority=EventPriority.NORMAL,
         )
-        
+
         return await self.publish(event)
-    
+
     async def publish_error(
         self,
         error_type: str,
@@ -150,13 +150,13 @@ class HookEventProducer(IEventProducer):
     ) -> bool:
         """
         Publish an error event.
-        
+
         Args:
             error_type: Type of error
             error_message: Error message
             error_details: Optional additional details
             correlation_id: Optional correlation ID
-            
+
         Returns:
             True if published successfully
         """
@@ -174,9 +174,9 @@ class HookEventProducer(IEventProducer):
             correlation_id=correlation_id,
             priority=EventPriority.CRITICAL,
         )
-        
+
         return await self.publish(event)
-    
+
     async def publish_subagent_event(
         self,
         subagent_name: str,
@@ -186,13 +186,13 @@ class HookEventProducer(IEventProducer):
     ) -> bool:
         """
         Publish a subagent-related event.
-        
+
         Args:
             subagent_name: Name of the subagent
             event_type: Type of subagent event
             event_data: Event data
             correlation_id: Optional correlation ID
-            
+
         Returns:
             True if published successfully
         """
@@ -209,9 +209,9 @@ class HookEventProducer(IEventProducer):
             correlation_id=correlation_id,
             priority=EventPriority.NORMAL,
         )
-        
+
         return await self.publish(event)
-    
+
     async def publish_raw_hook_event(
         self,
         hook_type: str,
@@ -220,14 +220,14 @@ class HookEventProducer(IEventProducer):
     ) -> bool:
         """
         Publish a raw hook event.
-        
+
         This is for hook events that don't fit the standard patterns.
-        
+
         Args:
             hook_type: Type of hook event
             hook_data: Raw hook data
             correlation_id: Optional correlation ID
-            
+
         Returns:
             True if published successfully
         """
@@ -242,7 +242,7 @@ class HookEventProducer(IEventProducer):
             topic = "hook.subagent"
         else:
             topic = "hook.generic"
-        
+
         # Determine priority
         if "error" in hook_type.lower() or "critical" in hook_type.lower():
             priority = EventPriority.CRITICAL
@@ -250,7 +250,7 @@ class HookEventProducer(IEventProducer):
             priority = EventPriority.HIGH
         else:
             priority = EventPriority.NORMAL
-        
+
         event = Event(
             id=str(uuid.uuid4()),
             topic=topic,
@@ -261,9 +261,9 @@ class HookEventProducer(IEventProducer):
             correlation_id=correlation_id,
             priority=priority,
         )
-        
+
         return await self.publish(event)
-    
+
     def get_metrics(self) -> Dict[str, Any]:
         """Get producer metrics."""
-        return self._metrics
+        return self._metrics