mcp-proxy-adapter 6.3.4__py3-none-any.whl → 6.3.6__py3-none-any.whl

mcp_proxy_adapter/commands/hooks.py

@@ -13,6 +13,7 @@ from mcp_proxy_adapter.core.logging import logger
 
 class HookType(Enum):
     """Types of hooks that can be registered."""
+
     CUSTOM_COMMANDS = "custom_commands"
     BEFORE_INIT = "before_init"
     AFTER_INIT = "after_init"
@@ -25,6 +26,7 @@ class HookType(Enum):
 @dataclass
 class HookContext:
     """Context object passed to hook functions."""
+
     hook_type: HookType
     command_name: Optional[str] = None
     params: Optional[Dict[str, Any]] = None
@@ -32,7 +34,7 @@ class HookContext:
     registry: Optional[Any] = None
     metadata: Optional[Dict[str, Any]] = None
     standard_processing: bool = True
-    
+
     def __post_init__(self):
         """Initialize metadata if not provided."""
         if self.metadata is None:
@@ -43,7 +45,7 @@ class CommandHooks:
     """
     Hook system for command registration.
     """
-    
+
     def __init__(self):
         """
         Initialize command hooks.
@@ -53,177 +55,191 @@ class CommandHooks:
         self._after_init_hooks: List[Callable] = []
         self._before_command_hooks: List[Callable] = []
         self._after_command_hooks: List[Callable] = []
-    
+
     def register_custom_commands_hook(self, hook_func: Callable) -> None:
         """
         Register a hook function for custom commands registration.
-        
+
         Args:
             hook_func: Function that registers custom commands.
                       Should accept registry as parameter.
         """
         self._custom_commands_hooks.append(hook_func)
         logger.debug(f"Registered custom commands hook: {hook_func.__name__}")
-    
+
     def register_before_init_hook(self, hook_func: Callable) -> None:
         """
         Register a hook function to be called before system initialization.
-        
+
         Args:
             hook_func: Function to call before initialization.
         """
         self._before_init_hooks.append(hook_func)
         logger.debug(f"Registered before init hook: {hook_func.__name__}")
-    
+
     def register_after_init_hook(self, hook_func: Callable) -> None:
         """
         Register a hook function to be called after system initialization.
-        
+
         Args:
             hook_func: Function to call after initialization.
         """
         self._after_init_hooks.append(hook_func)
         logger.debug(f"Registered after init hook: {hook_func.__name__}")
-    
+
     def register_before_command_hook(self, hook_func: Callable) -> None:
         """
         Register a hook function to be called before command execution.
-        
+
         Args:
             hook_func: Function to call before command execution.
                       Should accept command_name and params as parameters.
         """
         self._before_command_hooks.append(hook_func)
         logger.debug(f"Registered before command hook: {hook_func.__name__}")
-    
+
     def register_after_command_hook(self, hook_func: Callable) -> None:
         """
         Register a hook function to be called after command execution.
-        
+
         Args:
             hook_func: Function to call after command execution.
                       Should accept command_name, params, and result as parameters.
         """
         self._after_command_hooks.append(hook_func)
         logger.debug(f"Registered after command hook: {hook_func.__name__}")
-    
+
     def execute_custom_commands_hooks(self, registry) -> int:
         """
         Execute all registered custom commands hooks.
-        
+
         Args:
             registry: Command registry instance.
-            
+
         Returns:
             Number of hooks executed.
         """
         logger.debug("Executing custom commands hooks...")
         hooks_executed = 0
-        
+
         for hook_func in self._custom_commands_hooks:
             try:
                 hook_func(registry)
                 hooks_executed += 1
                 logger.debug(f"Executed custom commands hook: {hook_func.__name__}")
             except Exception as e:
-                logger.error(f"Failed to execute custom commands hook {hook_func.__name__}: {e}")
-        
+                logger.error(
+                    f"Failed to execute custom commands hook {hook_func.__name__}: {e}"
+                )
+
         logger.info(f"Executed {hooks_executed} custom commands hooks")
         return hooks_executed
-    
+
     def execute_before_init_hooks(self) -> int:
         """
         Execute all registered before initialization hooks.
-        
+
         Returns:
             Number of hooks executed.
         """
         logger.debug("Executing before init hooks...")
         hooks_executed = 0
-        
+
         for hook_func in self._before_init_hooks:
             try:
                 hook_func()
                 hooks_executed += 1
                 logger.debug(f"Executed before init hook: {hook_func.__name__}")
             except Exception as e:
-                logger.error(f"Failed to execute before init hook {hook_func.__name__}: {e}")
-        
+                logger.error(
+                    f"Failed to execute before init hook {hook_func.__name__}: {e}"
+                )
+
         logger.debug(f"Executed {hooks_executed} before init hooks")
         return hooks_executed
-    
+
     def execute_after_init_hooks(self) -> int:
         """
         Execute all registered after initialization hooks.
-        
+
         Returns:
             Number of hooks executed.
         """
         logger.debug("Executing after init hooks...")
         hooks_executed = 0
-        
+
         for hook_func in self._after_init_hooks:
             try:
                 hook_func()
                 hooks_executed += 1
                 logger.debug(f"Executed after init hook: {hook_func.__name__}")
             except Exception as e:
-                logger.error(f"Failed to execute after init hook {hook_func.__name__}: {e}")
-        
+                logger.error(
+                    f"Failed to execute after init hook {hook_func.__name__}: {e}"
+                )
+
         logger.debug(f"Executed {hooks_executed} after init hooks")
         return hooks_executed
-    
-    def execute_before_command_hooks(self, command_name: str, params: Dict[str, Any]) -> int:
+
+    def execute_before_command_hooks(
+        self, command_name: str, params: Dict[str, Any]
+    ) -> int:
         """
         Execute all registered before command execution hooks.
-        
+
         Args:
             command_name: Name of the command being executed
             params: Command parameters
-            
+
         Returns:
             Number of hooks executed.
         """
         logger.debug(f"Executing before command hooks for: {command_name}")
         hooks_executed = 0
-        
+
         for hook_func in self._before_command_hooks:
             try:
                 hook_func(command_name, params)
                 hooks_executed += 1
                 logger.debug(f"Executed before command hook: {hook_func.__name__}")
             except Exception as e:
-                logger.error(f"Failed to execute before command hook {hook_func.__name__}: {e}")
-        
+                logger.error(
+                    f"Failed to execute before command hook {hook_func.__name__}: {e}"
+                )
+
         logger.debug(f"Executed {hooks_executed} before command hooks")
         return hooks_executed
-    
-    def execute_after_command_hooks(self, command_name: str, params: Dict[str, Any], result: Any) -> int:
+
+    def execute_after_command_hooks(
+        self, command_name: str, params: Dict[str, Any], result: Any
+    ) -> int:
         """
         Execute all registered after command execution hooks.
-        
+
         Args:
             command_name: Name of the command that was executed
             params: Command parameters that were used
             result: Command execution result
-            
+
         Returns:
             Number of hooks executed.
         """
         logger.debug(f"Executing after command hooks for: {command_name}")
         hooks_executed = 0
-        
+
         for hook_func in self._after_command_hooks:
             try:
                 hook_func(command_name, params, result)
                 hooks_executed += 1
                 logger.debug(f"Executed after command hook: {hook_func.__name__}")
             except Exception as e:
-                logger.error(f"Failed to execute after command hook {hook_func.__name__}: {e}")
-        
+                logger.error(
+                    f"Failed to execute after command hook {hook_func.__name__}: {e}"
+                )
+
         logger.debug(f"Executed {hooks_executed} after command hooks")
         return hooks_executed
-    
+
     def clear_hooks(self) -> None:
         """
         Clear all registered hooks.
@@ -243,7 +259,7 @@ hooks = CommandHooks()
 def register_custom_commands_hook(hook_func: Callable) -> None:
     """
     Register a hook function for custom commands registration.
-    
+
     Args:
         hook_func: Function that registers custom commands.
                   Should accept registry as parameter.
@@ -254,7 +270,7 @@ def register_custom_commands_hook(hook_func: Callable) -> None:
 def register_before_init_hook(hook_func: Callable) -> None:
     """
     Register a hook function to be called before system initialization.
-    
+
     Args:
         hook_func: Function to call before initialization.
     """
@@ -264,7 +280,7 @@ def register_before_init_hook(hook_func: Callable) -> None:
 def register_after_init_hook(hook_func: Callable) -> None:
     """
     Register a hook function to be called after system initialization.
-    
+
     Args:
         hook_func: Function to call after initialization.
     """
@@ -274,7 +290,7 @@ def register_after_init_hook(hook_func: Callable) -> None:
 def register_before_command_hook(hook_func: Callable) -> None:
     """
     Register a hook function to be called before command execution.
-    
+
     Args:
         hook_func: Function to call before command execution.
                   Should accept command_name and params as parameters.
@@ -285,9 +301,9 @@ def register_before_command_hook(hook_func: Callable) -> None:
 def register_after_command_hook(hook_func: Callable) -> None:
     """
     Register a hook function to be called after command execution.
-    
+
     Args:
         hook_func: Function to call after command execution.
                   Should accept command_name, params, and result as parameters.
     """
-    hooks.register_after_command_hook(hook_func) 
+    hooks.register_after_command_hook(hook_func)