claude-mpm 3.9.9__py3-none-any.whl → 4.0.3__py3-none-any.whl

claude_mpm/core/socketio_pool.py

@@ -12,19 +12,18 @@ WHY connection pooling:
 """
 
 import asyncio
-import json
 import os
-import sys
 import threading
 import time
-from collections import deque, defaultdict
+from collections import defaultdict, deque
+from dataclasses import dataclass, field
 from datetime import datetime, timedelta
 from enum import Enum
-from typing import Dict, Any, Optional, List, Deque
-from dataclasses import dataclass, field
+from typing import Any, Deque, Dict, List, Optional
 
 try:
     import socketio
+
     SOCKETIO_AVAILABLE = True
 except ImportError:
     SOCKETIO_AVAILABLE = False
@@ -38,6 +37,7 @@ except ImportError:
         DEFAULT_DASHBOARD_PORT = 8765
         SOCKETIO_PORT_RANGE = (8080, 8099)
         DEFAULT_SOCKETIO_PORT = 8080
+
     socketio = None
 
 from ..core.logger import get_logger
@@ -45,14 +45,16 @@ from ..core.logger import get_logger
 
 class CircuitState(Enum):
     """Circuit breaker states."""
-    CLOSED = "closed"      # Normal operation
-    OPEN = "open"          # Failing, reject requests
+
+    CLOSED = "closed"  # Normal operation
+    OPEN = "open"  # Failing, reject requests
     HALF_OPEN = "half_open"  # Testing if service recovered
 
 
 @dataclass
 class ConnectionStats:
     """Connection statistics for monitoring."""
+
     created_at: datetime = field(default_factory=datetime.now)
     last_used: datetime = field(default_factory=datetime.now)
     events_sent: int = 0
@@ -61,9 +63,10 @@ class ConnectionStats:
     is_connected: bool = False
 
 
-@dataclass 
+@dataclass
 class BatchEvent:
     """Event to be batched."""
+
     namespace: str
     event: str
     data: Dict[str, Any]
@@ -72,14 +75,14 @@ class BatchEvent:
 
 class CircuitBreaker:
     """Circuit breaker for Socket.IO failures.
-    
+
     WHY circuit breaker pattern:
     - Prevents cascading failures when Socket.IO server is down
     - Fails fast instead of hanging on broken connections
     - Automatically recovers when service is restored
     - Reduces resource waste during outages
     """
-    
+
     def __init__(self, failure_threshold: int = 5, recovery_timeout: int = 30):
         self.failure_threshold = failure_threshold
         self.recovery_timeout = recovery_timeout
@@ -87,25 +90,30 @@ class CircuitBreaker:
         self.last_failure_time = None
         self.state = CircuitState.CLOSED
         self.logger = get_logger("circuit_breaker")
-    
+
     def can_execute(self) -> bool:
         """Check if execution is allowed based on circuit state."""
         if self.state == CircuitState.CLOSED:
             return True
         elif self.state == CircuitState.OPEN:
             # Check if recovery timeout has passed
-            if self.last_failure_time and \
-               datetime.now() - self.last_failure_time > timedelta(seconds=self.recovery_timeout):
+            if (
+                self.last_failure_time
+                and datetime.now() - self.last_failure_time
+                > timedelta(seconds=self.recovery_timeout)
+            ):
                 self.state = CircuitState.HALF_OPEN
-                self.logger.info("Circuit breaker transitioning to HALF_OPEN for testing")
+                self.logger.info(
+                    "Circuit breaker transitioning to HALF_OPEN for testing"
+                )
                 return True
             return False
         elif self.state == CircuitState.HALF_OPEN:
             # Allow one test request
             return True
-        
+
         return False
-    
+
     def record_success(self):
         """Record successful execution."""
         if self.state == CircuitState.HALF_OPEN:
@@ -115,25 +123,30 @@ class CircuitBreaker:
         elif self.state == CircuitState.CLOSED:
             # Reset failure count on success
             self.failure_count = 0
-    
+
     def record_failure(self):
         """Record failed execution."""
         self.failure_count += 1
         self.last_failure_time = datetime.now()
-        
+
         if self.state == CircuitState.HALF_OPEN:
             # Test failed, go back to OPEN
             self.state = CircuitState.OPEN
             self.logger.warning("Circuit breaker OPEN - test failed")
-        elif self.state == CircuitState.CLOSED and self.failure_count >= self.failure_threshold:
+        elif (
+            self.state == CircuitState.CLOSED
+            and self.failure_count >= self.failure_threshold
+        ):
             # Too many failures, open circuit
             self.state = CircuitState.OPEN
-            self.logger.error(f"Circuit breaker OPEN - {self.failure_count} consecutive failures")
+            self.logger.error(
+                f"Circuit breaker OPEN - {self.failure_count} consecutive failures"
+            )
 
 
 class SocketIOConnectionPool:
     """Connection pool for Socket.IO clients with circuit breaker and batching.
-    
+
     WHY this design:
     - Maintains max 5 persistent connections to reduce overhead
     - Implements circuit breaker for resilience
@@ -141,139 +154,158 @@ class SocketIOConnectionPool:
     - Thread-safe connection management
     - Automatic connection health monitoring
     """
-    
-    def __init__(self, max_connections: int = 5, batch_window_ms: int = 50, health_check_interval: int = 30):
+
+    def __init__(
+        self,
+        max_connections: int = 5,
+        batch_window_ms: int = 50,
+        health_check_interval: int = 30,
+    ):
         self.max_connections = max_connections
         self.batch_window_ms = batch_window_ms
         self.health_check_interval = health_check_interval
         self.logger = get_logger("socketio_pool")
-        
+
         # Connection pool
         self.available_connections: Deque[socketio.AsyncClient] = deque()
         self.active_connections: Dict[str, socketio.AsyncClient] = {}
         self.connection_stats: Dict[str, ConnectionStats] = {}
         self.pool_lock = threading.Lock()
-        
+
         # Circuit breaker
         self.circuit_breaker = CircuitBreaker()
-        
+
         # Batch processing
         self.batch_queue: Deque[BatchEvent] = deque()
         self.batch_lock = threading.Lock()
         self.batch_thread = None
         self.batch_running = False
-        
+
         # Health monitoring
         self.health_thread = None
         self.health_running = False
         self.last_health_check = datetime.now()
-        
+
         # Server configuration
         self.server_url = None
         self.server_port = None
-        
+
         # Pool lifecycle
         self._running = False
-        
+
         if not SOCKETIO_AVAILABLE:
             self.logger.warning("Socket.IO not available - connection pool disabled")
-    
+
     def start(self):
         """Start the connection pool and batch processor."""
         if not SOCKETIO_AVAILABLE:
             return
-        
+
         self._running = True
         self._detect_server()
-        
+
         # Start batch processing thread
         self.batch_running = True
         self.batch_thread = threading.Thread(target=self._batch_processor, daemon=True)
         self.batch_thread.start()
-        
+
         # Start health monitoring thread
         self.health_running = True
         self.health_thread = threading.Thread(target=self._health_monitor, daemon=True)
         self.health_thread.start()
-        
-        self.logger.info(f"Socket.IO connection pool started (max_connections={self.max_connections}, batch_window={self.batch_window_ms}ms, health_check={self.health_check_interval}s)")
-    
+
+        self.logger.info(
+            f"Socket.IO connection pool started (max_connections={self.max_connections}, batch_window={self.batch_window_ms}ms, health_check={self.health_check_interval}s)"
+        )
+
     def stop(self):
         """Stop the connection pool and cleanup connections."""
         self._running = False
         self.batch_running = False
         self.health_running = False
-        
+
         if self.batch_thread:
             self.batch_thread.join(timeout=2.0)
-        
+
         if self.health_thread:
             self.health_thread.join(timeout=2.0)
-        
+
         # Close all connections
         with self.pool_lock:
             # Close available connections
             while self.available_connections:
                 client = self.available_connections.popleft()
                 try:
-                    if hasattr(client, 'disconnect'):
+                    if hasattr(client, "disconnect"):
                         # Run disconnect in a new event loop if needed
                         try:
                             loop = asyncio.get_event_loop()
                         except RuntimeError:
                             loop = asyncio.new_event_loop()
                             asyncio.set_event_loop(loop)
-                        
+
                         if client.connected:
                             loop.run_until_complete(client.disconnect())
                 except Exception as e:
                     self.logger.debug(f"Error closing connection: {e}")
-            
+
             # Close active connections
             for conn_id, client in self.active_connections.items():
                 try:
-                    if hasattr(client, 'disconnect') and client.connected:
+                    if hasattr(client, "disconnect") and client.connected:
                         try:
                             loop = asyncio.get_event_loop()
                         except RuntimeError:
                             loop = asyncio.new_event_loop()
                             asyncio.set_event_loop(loop)
-                        
+
                         loop.run_until_complete(client.disconnect())
                 except Exception as e:
                     self.logger.debug(f"Error closing active connection {conn_id}: {e}")
-            
+
             self.active_connections.clear()
             self.connection_stats.clear()
-        
+
         self.logger.info("Socket.IO connection pool stopped")
-    
+
     def _detect_server(self):
         """Detect Socket.IO server configuration."""
         # Check environment variable first
-        env_port = os.environ.get('CLAUDE_MPM_SOCKETIO_PORT')
+        env_port = os.environ.get("CLAUDE_MPM_SOCKETIO_PORT")
         if env_port:
             try:
                 self.server_port = int(env_port)
                 self.server_url = f"http://localhost:{self.server_port}"
-                self.logger.debug(f"Using Socket.IO server from environment: {self.server_url}")
+                self.logger.debug(
+                    f"Using Socket.IO server from environment: {self.server_url}"
+                )
                 return
             except ValueError:
                 pass
-        
+
         # Try to detect running server on common ports
         import socket
+
         # Create a list of common ports starting with dashboard port, then socketio range
-        common_ports = [NetworkConfig.DEFAULT_DASHBOARD_PORT, NetworkConfig.DEFAULT_SOCKETIO_PORT]
+        common_ports = [
+            NetworkConfig.DEFAULT_DASHBOARD_PORT,
+            NetworkConfig.DEFAULT_SOCKETIO_PORT,
+        ]
         # Add other ports from the SocketIO range
-        for port in range(NetworkConfig.SOCKETIO_PORT_RANGE[0] + 1, min(NetworkConfig.SOCKETIO_PORT_RANGE[0] + 6, NetworkConfig.SOCKETIO_PORT_RANGE[1] + 1)):
+        for port in range(
+            NetworkConfig.SOCKETIO_PORT_RANGE[0] + 1,
+            min(
+                NetworkConfig.SOCKETIO_PORT_RANGE[0] + 6,
+                NetworkConfig.SOCKETIO_PORT_RANGE[1] + 1,
+            ),
+        ):
             common_ports.append(port)
-        
+
         for port in common_ports:
             try:
                 with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
                     s.settimeout(0.05)
-                    result = s.connect_ex(('localhost', port))
+                    result = s.connect_ex(("localhost", port))
                     if result == 0:
                         self.server_port = port
                         self.server_url = f"http://localhost:{port}"
@@ -281,17 +313,17 @@ class SocketIOConnectionPool:
                         return
             except:
                 continue
-        
+
         # Fall back to default
         self.server_port = NetworkConfig.DEFAULT_DASHBOARD_PORT
         self.server_url = f"http://localhost:{self.server_port}"
         self.logger.debug(f"Using default Socket.IO server: {self.server_url}")
-    
+
     def _create_client(self) -> Optional[socketio.AsyncClient]:
         """Create a new Socket.IO client connection."""
         if not SOCKETIO_AVAILABLE or not self.server_url:
             return None
-        
+
         try:
             client = socketio.AsyncClient(
                 reconnection=True,
@@ -300,40 +332,40 @@ class SocketIOConnectionPool:
                 reconnection_delay_max=2,
                 randomization_factor=0.2,
                 logger=False,
-                engineio_logger=False
+                engineio_logger=False,
             )
-            
+
             # Create connection ID
             conn_id = f"pool_{len(self.connection_stats)}_{int(time.time())}"
-            
+
             # Setup event handlers
             @client.event
             async def connect():
                 self.connection_stats[conn_id].is_connected = True
                 self.logger.debug(f"Pool connection {conn_id} established")
-            
+
             @client.event
             async def disconnect():
                 if conn_id in self.connection_stats:
                     self.connection_stats[conn_id].is_connected = False
                 self.logger.debug(f"Pool connection {conn_id} disconnected")
-            
+
             @client.event
             async def connect_error(data):
                 if conn_id in self.connection_stats:
                     self.connection_stats[conn_id].errors += 1
                     self.connection_stats[conn_id].consecutive_errors += 1
                 self.logger.debug(f"Pool connection {conn_id} error: {data}")
-            
+
             # Initialize stats
             self.connection_stats[conn_id] = ConnectionStats()
-            
+
             return client
-            
+
         except Exception as e:
             self.logger.error(f"Failed to create Socket.IO client: {e}")
             return None
-    
+
     def _get_connection(self) -> Optional[socketio.AsyncClient]:
         """Get an available connection from the pool."""
         with self.pool_lock:
@@ -345,7 +377,7 @@ class SocketIOConnectionPool:
                     if stats.is_connected:
                         stats.last_used = datetime.now()
                         return client
-            
+
             # Create new connection if under limit
             if len(self.active_connections) < self.max_connections:
                 client = self._create_client()
@@ -353,11 +385,11 @@ class SocketIOConnectionPool:
                     conn_id = f"pool_{len(self.active_connections)}_{int(time.time())}"
                     self.active_connections[conn_id] = client
                     return client
-            
+
             # Pool exhausted
             self.logger.warning("Socket.IO connection pool exhausted")
             return None
-    
+
     def _return_connection(self, client: socketio.AsyncClient):
         """Return a connection to the pool."""
         with self.pool_lock:
@@ -369,15 +401,14 @@ class SocketIOConnectionPool:
                     if client.connected:
                         # Schedule disconnect (don't block)
                         threading.Thread(
-                            target=lambda: asyncio.run(client.disconnect()),
-                            daemon=True
+                            target=lambda: asyncio.run(client.disconnect()), daemon=True
                         ).start()
                 except Exception as e:
                     self.logger.debug(f"Error closing excess connection: {e}")
-    
+
     def emit_event(self, namespace: str, event: str, data: Dict[str, Any]):
         """Emit event using connection pool with batching.
-        
+
         WHY batching approach:
         - Collects events in 50ms windows to reduce network overhead
         - Maintains event ordering within batches
@@ -385,98 +416,106 @@ class SocketIOConnectionPool:
         """
         if not SOCKETIO_AVAILABLE or not self._running:
             return
-        
+
         # Check circuit breaker
         if not self.circuit_breaker.can_execute():
-            self.logger.debug(f"Circuit breaker OPEN - dropping event {namespace}/{event}")
+            self.logger.debug(
+                f"Circuit breaker OPEN - dropping event {namespace}/{event}"
+            )
             return
-        
+
         # Add to batch queue
         batch_event = BatchEvent(namespace, event, data)
         with self.batch_lock:
             self.batch_queue.append(batch_event)
-    
+
     def _batch_processor(self):
         """Process batched events in micro-batches."""
         self.logger.debug("Batch processor started")
-        
+
         while self.batch_running:
             try:
                 # Sleep for batch window
                 time.sleep(self.batch_window_ms / 1000.0)
-                
+
                 # Collect batch
                 current_batch = []
                 with self.batch_lock:
-                    while self.batch_queue and len(current_batch) < 10:  # Max 10 events per batch
+                    while (
+                        self.batch_queue and len(current_batch) < 10
+                    ):  # Max 10 events per batch
                         current_batch.append(self.batch_queue.popleft())
-                
+
                 # Process batch
                 if current_batch:
                     self._process_batch(current_batch)
-                    
+
             except Exception as e:
                 self.logger.error(f"Batch processor error: {e}")
                 time.sleep(0.1)  # Brief pause on error
-        
+
         self.logger.debug("Batch processor stopped")
-    
+
     def _process_batch(self, batch: List[BatchEvent]):
         """Process a batch of events."""
         if not batch:
             return
-        
+
         # Group events by namespace for efficiency
         namespace_groups = defaultdict(list)
         for event in batch:
             namespace_groups[event.namespace].append(event)
-        
+
         # Process each namespace group
         for namespace, events in namespace_groups.items():
             success = self._emit_batch_to_namespace(namespace, events)
-            
+
             # Update circuit breaker
             if success:
                 self.circuit_breaker.record_success()
             else:
                 self.circuit_breaker.record_failure()
-    
-    async def _async_emit_batch(self, client: socketio.AsyncClient, namespace: str, events: List[BatchEvent]) -> bool:
+
+    async def _async_emit_batch(
+        self, client: socketio.AsyncClient, namespace: str, events: List[BatchEvent]
+    ) -> bool:
         """Async version of emit batch."""
         try:
             # Connect if not connected
             if not client.connected:
                 await self._connect_client(client)
-            
+
             # Emit events
             for event in events:
                 enhanced_data = {
                     **event.data,
                     "timestamp": event.timestamp.isoformat(),
-                    "batch_id": f"batch_{int(time.time() * 1000)}"
+                    "batch_id": f"batch_{int(time.time() * 1000)}",
                 }
-                
+
                 await client.emit(event.event, enhanced_data, namespace=namespace)
-            
+
             # Update stats
             for conn_id, stats in self.connection_stats.items():
                 if stats.is_connected:
                     stats.events_sent += len(events)
                     stats.consecutive_errors = 0
                     break
-            
+
             self.logger.debug(f"Emitted batch of {len(events)} events to {namespace}")
             return True
         except Exception as e:
             self.logger.error(f"Failed to emit batch to {namespace}: {e}")
             return False
-    
-    def _emit_batch_to_namespace(self, namespace: str, events: List[BatchEvent]) -> bool:
+
+    def _emit_batch_to_namespace(
+        self, namespace: str, events: List[BatchEvent]
+    ) -> bool:
         """Emit a batch of events to a specific namespace."""
         client = self._get_connection()
         if not client:
             return False
-        
+
         loop = None
         try:
             # Get or create event loop for this thread
@@ -484,50 +523,51 @@ class SocketIOConnectionPool:
                 loop = asyncio.get_running_loop()
                 # We're in an async context, use it directly
                 return asyncio.run_coroutine_threadsafe(
-                    self._async_emit_batch(client, namespace, events),
-                    loop
+                    self._async_emit_batch(client, namespace, events), loop
                 ).result(timeout=5.0)
             except RuntimeError:
                 # No running loop, create one
                 loop = asyncio.new_event_loop()
                 asyncio.set_event_loop(loop)
-                
+
                 # Connect if not connected
                 if not client.connected:
                     loop.run_until_complete(self._connect_client(client))
-                
+
                 # Emit events
                 for event in events:
                     enhanced_data = {
                         **event.data,
                         "timestamp": event.timestamp.isoformat(),
-                        "batch_id": f"batch_{int(time.time() * 1000)}"
+                        "batch_id": f"batch_{int(time.time() * 1000)}",
                     }
-                    
+
                     loop.run_until_complete(
                         client.emit(event.event, enhanced_data, namespace=namespace)
                     )
-                
+
                 # Update stats
                 for conn_id, stats in self.connection_stats.items():
                     if stats.is_connected:
                         stats.events_sent += len(events)
                         stats.consecutive_errors = 0
                         break
-                
-                self.logger.debug(f"Emitted batch of {len(events)} events to {namespace}")
+
+                self.logger.debug(
+                    f"Emitted batch of {len(events)} events to {namespace}"
+                )
                 return True
-            
+
         except Exception as e:
             self.logger.error(f"Failed to emit batch to {namespace}: {e}")
-            
+
             # Update stats
             for conn_id, stats in self.connection_stats.items():
                 if stats.is_connected:
                     stats.errors += 1
                     stats.consecutive_errors += 1
                     break
-            
+
             return False
         finally:
             self._return_connection(client)
@@ -543,33 +583,29 @@ class SocketIOConnectionPool:
                     loop.close()
                 except:
                     pass
-    
+
     async def _connect_client(self, client: socketio.AsyncClient):
         """Connect a client with timeout."""
         try:
             # Use asyncio timeout instead of signal (thread-safe)
             import asyncio
-            
+
             # 2-second timeout for connection
             await asyncio.wait_for(
-                client.connect(
-                    self.server_url,
-                    auth={'token': 'dev-token'},
-                    wait=True
-                ),
-                timeout=2.0
+                client.connect(self.server_url, auth={"token": "dev-token"}, wait=True),
+                timeout=2.0,
             )
-                
+
         except asyncio.TimeoutError:
             self.logger.debug("Socket.IO connection timeout")
             raise TimeoutError("Socket.IO connection timeout")
         except Exception as e:
             self.logger.debug(f"Client connection failed: {e}")
             raise
-    
+
     def _health_monitor(self):
         """Monitor health of connections in the pool.
-        
+
         WHY health monitoring:
         - Detects stale/broken connections proactively
         - Removes unhealthy connections before they cause failures
@@ -577,102 +613,111 @@ class SocketIOConnectionPool:
         - Reduces connection errors by 40-60%
         """
         self.logger.debug("Health monitor started")
-        
+
         while self.health_running:
             try:
                 # Sleep for health check interval
                 time.sleep(self.health_check_interval)
-                
+
                 # Check connection health
                 self._check_connections_health()
-                
+
                 # Update last health check time
                 self.last_health_check = datetime.now()
-                
+
             except Exception as e:
                 self.logger.error(f"Health monitor error: {e}")
                 time.sleep(5)  # Brief pause on error
-        
+
         self.logger.debug("Health monitor stopped")
-    
+
     def _check_connections_health(self):
         """Check health of all connections in the pool."""
         with self.pool_lock:
             unhealthy_connections = []
-            
+
             # Check each connection's health
             for conn_id, client in list(self.active_connections.items()):
                 stats = self.connection_stats.get(conn_id)
                 if not stats:
                     continue
-                
+
                 # Health criteria:
                 # 1. Too many consecutive errors
                 if stats.consecutive_errors > 3:
                     unhealthy_connections.append((conn_id, client, "excessive_errors"))
                     continue
-                
+
                 # 2. Connection is not actually connected
                 if not client.connected and stats.is_connected:
                     unhealthy_connections.append((conn_id, client, "disconnected"))
                     stats.is_connected = False
                     continue
-                
+
                 # 3. Connection idle for too long (>5 minutes)
                 idle_time = (datetime.now() - stats.last_used).total_seconds()
-                if idle_time > 300 and conn_id not in [id for id, _ in enumerate(self.available_connections)]:
+                if idle_time > 300 and conn_id not in [
+                    id for id, _ in enumerate(self.available_connections)
+                ]:
                     unhealthy_connections.append((conn_id, client, "idle_timeout"))
                     continue
-                
+
                 # 4. High error rate (>10% of events)
                 if stats.events_sent > 100 and stats.errors > stats.events_sent * 0.1:
                     unhealthy_connections.append((conn_id, client, "high_error_rate"))
-            
+
             # Remove unhealthy connections
             for conn_id, client, reason in unhealthy_connections:
-                self.logger.warning(f"Removing unhealthy connection {conn_id}: {reason}")
-                
+                self.logger.warning(
+                    f"Removing unhealthy connection {conn_id}: {reason}"
+                )
+
                 # Remove from active connections
                 self.active_connections.pop(conn_id, None)
-                
+
                 # Remove from available if present
                 if client in self.available_connections:
                     self.available_connections.remove(client)
-                
+
                 # Try to disconnect
                 try:
                     if client.connected:
                         threading.Thread(
-                            target=lambda: asyncio.run(client.disconnect()),
-                            daemon=True
+                            target=lambda: asyncio.run(client.disconnect()), daemon=True
                         ).start()
                 except Exception as e:
                     self.logger.debug(f"Error disconnecting unhealthy connection: {e}")
-                
+
                 # Remove stats
                 self.connection_stats.pop(conn_id, None)
-            
+
             # Log health check results
             if unhealthy_connections:
-                self.logger.info(f"Health check removed {len(unhealthy_connections)} unhealthy connections")
-            
+                self.logger.info(
+                    f"Health check removed {len(unhealthy_connections)} unhealthy connections"
+                )
+
             # Pre-create connections if pool is too small
-            current_total = len(self.active_connections) + len(self.available_connections)
+            current_total = len(self.active_connections) + len(
+                self.available_connections
+            )
             if current_total < min(2, self.max_connections):
                 self.logger.debug("Pre-creating connections to maintain pool minimum")
                 for _ in range(min(2, self.max_connections) - current_total):
                     client = self._create_client()
                     if client:
-                        conn_id = f"pool_{len(self.active_connections)}_{int(time.time())}"
+                        conn_id = (
+                            f"pool_{len(self.active_connections)}_{int(time.time())}"
+                        )
                         self.active_connections[conn_id] = client
                         self.available_connections.append(client)
-    
+
     async def _ping_connection(self, client: socketio.AsyncClient) -> bool:
         """Ping a connection to check if it's alive.
-        
+
         Args:
             client: The Socket.IO client to ping
-        
+
         Returns:
             True if connection is healthy, False otherwise
         """
@@ -680,34 +725,43 @@ class SocketIOConnectionPool:
             # Send a ping and wait for response
             await asyncio.wait_for(
                 client.emit("ping", {"timestamp": time.time()}, namespace="/health"),
-                timeout=1.0
+                timeout=1.0,
             )
             return True
         except (asyncio.TimeoutError, Exception):
             return False
-    
+
     def get_stats(self) -> Dict[str, Any]:
         """Get connection pool statistics."""
         with self.pool_lock:
             # Calculate health metrics
             healthy_connections = sum(
-                1 for stats in self.connection_stats.values()
+                1
+                for stats in self.connection_stats.values()
                 if stats.is_connected and stats.consecutive_errors < 3
             )
-            
+
             return {
                 "max_connections": self.max_connections,
                 "available_connections": len(self.available_connections),
                 "active_connections": len(self.active_connections),
                 "healthy_connections": healthy_connections,
-                "total_events_sent": sum(stats.events_sent for stats in self.connection_stats.values()),
-                "total_errors": sum(stats.errors for stats in self.connection_stats.values()),
+                "total_events_sent": sum(
+                    stats.events_sent for stats in self.connection_stats.values()
+                ),
+                "total_errors": sum(
+                    stats.errors for stats in self.connection_stats.values()
+                ),
                 "circuit_state": self.circuit_breaker.state.value,
                 "circuit_failures": self.circuit_breaker.failure_count,
                 "batch_queue_size": len(self.batch_queue),
                 "server_url": self.server_url,
-                "last_health_check": self.last_health_check.isoformat() if hasattr(self, 'last_health_check') else None,
-                "health_check_interval": self.health_check_interval
+                "last_health_check": (
+                    self.last_health_check.isoformat()
+                    if hasattr(self, "last_health_check")
+                    else None
+                ),
+                "health_check_interval": self.health_check_interval,
             }
 
 
@@ -736,4 +790,4 @@ def stop_connection_pool():
 def emit_hook_event(namespace: str, event: str, data: Dict[str, Any]):
     """Emit a hook event using the connection pool."""
     pool = get_connection_pool()
-    pool.emit_event(namespace, event, data)
+    pool.emit_event(namespace, event, data)