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

mcp_proxy_adapter/examples/examples/full_application/commands/dynamic_calculator_command.py

@@ -4,43 +4,57 @@ This module demonstrates a dynamically loaded command implementation for the ful
 Author: Vasiliy Zdanovskiy
 email: vasilyvz@gmail.com
 """
+
 from typing import Dict, Any, Optional
 from mcp_proxy_adapter.commands.base import BaseCommand
 from mcp_proxy_adapter.commands.result import CommandResult
+
+
 class CalculatorResult(CommandResult):
     """Result class for calculator command."""
+
     def __init__(self, operation: str, result: float, expression: str):
         self.operation = operation
         self.result = result
         self.expression = expression
+
     def to_dict(self) -> Dict[str, Any]:
         """Convert result to dictionary."""
         return {
             "operation": self.operation,
             "result": self.result,
             "expression": self.expression,
-            "command_type": "dynamic_calculator"
+            "command_type": "dynamic_calculator",
         }
+
     def get_schema(self) -> Dict[str, Any]:
         """Get result schema."""
         return {
             "type": "object",
             "properties": {
-                "operation": {"type": "string", "description": "Mathematical operation"},
+                "operation": {
+                    "type": "string",
+                    "description": "Mathematical operation",
+                },
                 "result": {"type": "number", "description": "Calculation result"},
                 "expression": {"type": "string", "description": "Full expression"},
-                "command_type": {"type": "string", "description": "Command type"}
+                "command_type": {"type": "string", "description": "Command type"},
             },
-            "required": ["operation", "result", "expression", "command_type"]
+            "required": ["operation", "result", "expression", "command_type"],
         }
+
+
 class DynamicCalculatorCommand(BaseCommand):
     """Dynamic calculator command implementation."""
+
     def get_name(self) -> str:
         """Get command name."""
         return "dynamic_calculator"
+
     def get_description(self) -> str:
         """Get command description."""
         return "Dynamic calculator with basic mathematical operations"
+
     def get_schema(self) -> Dict[str, Any]:
         """Get command schema."""
         return {
@@ -49,19 +63,14 @@ class DynamicCalculatorCommand(BaseCommand):
                 "operation": {
                     "type": "string",
                     "description": "Mathematical operation (add, subtract, multiply, divide)",
-                    "enum": ["add", "subtract", "multiply", "divide"]
-                },
-                "a": {
-                    "type": "number",
-                    "description": "First number"
+                    "enum": ["add", "subtract", "multiply", "divide"],
                 },
-                "b": {
-                    "type": "number",
-                    "description": "Second number"
-                }
+                "a": {"type": "number", "description": "First number"},
+                "b": {"type": "number", "description": "Second number"},
             },
-            "required": ["operation", "a", "b"]
+            "required": ["operation", "a", "b"],
         }
+
     async def execute(self, params: Dict[str, Any]) -> CalculatorResult:
         """Execute the calculator command."""
         operation = params.get("operation")
@@ -84,7 +93,5 @@ class DynamicCalculatorCommand(BaseCommand):
         else:
             raise ValueError(f"Unknown operation: {operation}")
         return CalculatorResult(
-            operation=operation,
-            result=result,
-            expression=expression
+            operation=operation, result=result, expression=expression
         )

mcp_proxy_adapter/examples/examples/full_application/hooks/application_hooks.py

@@ -4,12 +4,17 @@ This module demonstrates application-level hooks in the full application example
 Author: Vasiliy Zdanovskiy
 email: vasilyvz@gmail.com
 """
+
 import logging
 from typing import Dict, Any, Optional
 from datetime import datetime
+
 logger = logging.getLogger(__name__)
+
+
 class ApplicationHooks:
     """Application-level hooks."""
+
     @staticmethod
     def on_startup():
         """Hook executed on application startup."""
@@ -18,6 +23,7 @@ class ApplicationHooks:
         logger.info("📊 Initializing application metrics")
         logger.info("🔐 Loading security configurations")
         logger.info("📝 Setting up logging")
+
     @staticmethod
     def on_shutdown():
         """Hook executed on application shutdown."""
@@ -26,6 +32,7 @@ class ApplicationHooks:
         logger.info("🧹 Cleaning up resources")
         logger.info("💾 Saving application state")
         logger.info("📊 Finalizing metrics")
+
     @staticmethod
     def before_request(request_data: Dict[str, Any]) -> Dict[str, Any]:
         """Hook executed before processing any request."""
@@ -34,9 +41,10 @@ class ApplicationHooks:
         request_data["app_metadata"] = {
             "request_id": f"req_{datetime.now().timestamp()}",
             "timestamp": datetime.now().isoformat(),
-            "application": "full_application_example"
+            "application": "full_application_example",
         }
         return request_data
+
     @staticmethod
     def after_request(result: Dict[str, Any]) -> Dict[str, Any]:
         """Hook executed after processing any request."""
@@ -45,9 +53,10 @@ class ApplicationHooks:
         result["app_response_metadata"] = {
             "processed_at": datetime.now().isoformat(),
             "application": "full_application_example",
-            "version": "1.0.0"
+            "version": "1.0.0",
         }
         return result
+
     @staticmethod
     def on_error(error: Exception, context: Dict[str, Any]):
         """Hook executed when an error occurs."""
@@ -56,6 +65,7 @@ class ApplicationHooks:
         logger.error(f"Error type: {type(error).__name__}")
         logger.error(f"Error message: {str(error)}")
         logger.error(f"Context: {context}")
+
     @staticmethod
     def on_command_registered(command_name: str, command_info: Dict[str, Any]):
         """Hook executed when a command is registered."""
@@ -63,6 +73,7 @@ class ApplicationHooks:
         logger.info(f"Command info: {command_info}")
         # Track registered commands
         logger.info(f"📝 Command '{command_name}' registered successfully")
+
     @staticmethod
     def on_command_executed(command_name: str, execution_time: float, success: bool):
         """Hook executed when a command is executed."""
@@ -70,6 +81,8 @@ class ApplicationHooks:
         logger.info(f"Execution time: {execution_time}s, Success: {success}")
         # Track command execution metrics
         if success:
-            logger.info(f"✅ Command '{command_name}' executed successfully in {execution_time}s")
+            logger.info(
+                f"✅ Command '{command_name}' executed successfully in {execution_time}s"
+            )
         else:
             logger.warning(f"⚠️ Command '{command_name}' failed after {execution_time}s")

mcp_proxy_adapter/examples/examples/full_application/hooks/builtin_command_hooks.py

@@ -4,12 +4,17 @@ This module demonstrates hooks for built-in commands in the full application exa
 Author: Vasiliy Zdanovskiy
 email: vasilyvz@gmail.com
 """
+
 import logging
 from typing import Dict, Any, Optional
 from datetime import datetime
+
 logger = logging.getLogger(__name__)
+
+
 class BuiltinCommandHooks:
     """Hooks for built-in commands."""
+
     @staticmethod
     def before_echo_command(params: Dict[str, Any]) -> Dict[str, Any]:
         """Hook executed before echo command."""
@@ -19,6 +24,7 @@ class BuiltinCommandHooks:
             timestamp = datetime.now().isoformat()
             params["message"] = f"[{timestamp}] {params['message']}"
         return params
+
     @staticmethod
     def after_echo_command(result: Dict[str, Any]) -> Dict[str, Any]:
         """Hook executed after echo command."""
@@ -27,9 +33,10 @@ class BuiltinCommandHooks:
         result["hook_metadata"] = {
             "hook_type": "builtin_after_echo",
             "timestamp": datetime.now().isoformat(),
-            "processed": True
+            "processed": True,
         }
         return result
+
     @staticmethod
     def before_health_command(params: Dict[str, Any]) -> Dict[str, Any]:
         """Hook executed before health command."""
@@ -38,6 +45,7 @@ class BuiltinCommandHooks:
         params["include_detailed_info"] = True
         params["check_dependencies"] = True
         return params
+
     @staticmethod
     def after_health_command(result: Dict[str, Any]) -> Dict[str, Any]:
         """Hook executed after health command."""
@@ -47,9 +55,10 @@ class BuiltinCommandHooks:
             result["custom_metrics"] = {
                 "uptime": "24h",
                 "memory_usage": "45%",
-                "cpu_usage": "12%"
+                "cpu_usage": "12%",
             }
         return result
+
     @staticmethod
     def before_config_command(params: Dict[str, Any]) -> Dict[str, Any]:
         """Hook executed before config command."""
@@ -58,6 +67,7 @@ class BuiltinCommandHooks:
         params["validate_config"] = True
         params["include_secrets"] = False
         return params
+
     @staticmethod
     def after_config_command(result: Dict[str, Any]) -> Dict[str, Any]:
         """Hook executed after config command."""
@@ -66,6 +76,6 @@ class BuiltinCommandHooks:
         result["config_metadata"] = {
             "last_modified": datetime.now().isoformat(),
             "version": "1.0.0",
-            "environment": "development"
+            "environment": "development",
         }
         return result

mcp_proxy_adapter/examples/examples/full_application/main.py

@@ -14,14 +14,18 @@ import sys
 import argparse
 import logging
 from pathlib import Path
+
 # Add the framework to the path
 sys.path.insert(0, str(Path(__file__).parent.parent.parent))
 from mcp_proxy_adapter.core.app_factory import create_and_run_server
 from mcp_proxy_adapter.api.app import create_app
 from mcp_proxy_adapter.config import Config
 from mcp_proxy_adapter.commands.command_registry import CommandRegistry
+
+
 class FullApplication:
     """Full application example with all framework features."""
+
     def __init__(self, config_path: str):
         self.config_path = config_path
         self.config = Config(config_path)
@@ -30,12 +34,14 @@ class FullApplication:
         # Setup logging
         logging.basicConfig(level=logging.INFO)
         self.logger = logging.getLogger(__name__)
+
     def setup_hooks(self):
         """Setup application hooks."""
         try:
             # Import hooks
             from hooks.application_hooks import ApplicationHooks
             from hooks.builtin_command_hooks import BuiltinCommandHooks
+
             # Register application hooks
             self.logger.info("🔧 Setting up application hooks...")
             # Register built-in command hooks
@@ -45,6 +51,7 @@ class FullApplication:
             self.logger.info("✅ Hooks setup completed")
         except ImportError as e:
             self.logger.warning(f"⚠️ Could not import hooks: {e}")
+
     def setup_custom_commands(self):
         """Setup custom commands."""
         try:
@@ -52,23 +59,27 @@ class FullApplication:
             # Import custom commands
             from commands.custom_echo_command import CustomEchoCommand
             from commands.dynamic_calculator_command import DynamicCalculatorCommand
+
             # Register custom commands
             # Note: In a real implementation, these would be registered
             # with the framework's command registry
             self.logger.info("✅ Custom commands setup completed")
         except ImportError as e:
             self.logger.warning(f"⚠️ Could not import custom commands: {e}")
+
     def setup_proxy_endpoints(self):
         """Setup proxy registration endpoints."""
         try:
             self.logger.info("🔧 Setting up proxy endpoints...")
             # Import proxy endpoints
             from proxy_endpoints import router as proxy_router
+
             # Add proxy router to the application
             self.app.include_router(proxy_router)
             self.logger.info("✅ Proxy endpoints setup completed")
         except ImportError as e:
             self.logger.warning(f"⚠️ Could not import proxy endpoints: {e}")
+
     def create_application(self):
         """Create the FastAPI application."""
         self.logger.info("🔧 Creating application...")
@@ -80,6 +91,7 @@ class FullApplication:
         # Setup proxy endpoints after app creation
         self.setup_proxy_endpoints()
         self.logger.info("✅ Application created successfully")
+
     def run(self, host: str = None, port: int = None, debug: bool = False):
         """Run the application using the factory method."""
         # Override configuration if specified
@@ -92,7 +104,9 @@ class FullApplication:
             config_overrides["debug"] = True
         print(f"🚀 Starting Full Application Example")
         print(f"📋 Configuration: {self.config_path}")
-        print(f"🔧 Features: Built-in commands, Custom commands, Dynamic commands, Hooks, Proxy endpoints")
+        print(
+            f"🔧 Features: Built-in commands, Custom commands, Dynamic commands, Hooks, Proxy endpoints"
+        )
         print("=" * 60)
         # Create application with configuration
         self.create_application()
@@ -121,6 +135,7 @@ class FullApplication:
             import hypercorn.asyncio
             import hypercorn.config
             import asyncio
+
             # Configure hypercorn
             config_hypercorn = hypercorn.config.Config()
             config_hypercorn.bind = [f"{server_host}:{server_port}"]
@@ -132,6 +147,7 @@ class FullApplication:
                     config_hypercorn.ca_certs = ssl_ca_cert
                 if verify_client:
                     import ssl
+
                     config_hypercorn.verify_mode = ssl.CERT_REQUIRED
                 print(f"🔐 Starting HTTPS server with hypercorn...")
             else:
@@ -141,13 +157,18 @@ class FullApplication:
         except ImportError:
             print("❌ hypercorn not installed. Installing...")
             import subprocess
+
             subprocess.run([sys.executable, "-m", "pip", "install", "hypercorn"])
             print("✅ hypercorn installed. Please restart the application.")
             return
+
+
 def main():
     """Main entry point for the full application example."""
     parser = argparse.ArgumentParser(description="Full Application Example")
-    parser.add_argument("--config", "-c", required=True, help="Path to configuration file")
+    parser.add_argument(
+        "--config", "-c", required=True, help="Path to configuration file"
+    )
     parser.add_argument("--host", help="Server host")
     parser.add_argument("--port", type=int, help="Server port")
     parser.add_argument("--debug", action="store_true", help="Enable debug mode")
@@ -155,9 +176,12 @@ def main():
     # Create and run application
     app = FullApplication(args.config)
     app.run(host=args.host, port=args.port, debug=args.debug)
+
+
 # Create global app instance for import
 app = None
 
+
 def get_app():
     """Get the FastAPI application instance."""
     global app
@@ -169,5 +193,6 @@ def get_app():
         app = app_instance.app
     return app
 
+
 if __name__ == "__main__":
     main()

mcp_proxy_adapter/examples/examples/full_application/proxy_endpoints.py

@@ -4,16 +4,21 @@ This module provides proxy registration endpoints for testing.
 Author: Vasiliy Zdanovskiy
 email: vasilyvz@gmail.com
 """
+
 from fastapi import APIRouter, HTTPException
 from pydantic import BaseModel
 from typing import Dict, List, Optional
 import time
 import uuid
+
 # In-memory registry for testing
 _registry: Dict[str, Dict] = {}
 router = APIRouter(prefix="/proxy", tags=["proxy"])
+
+
 class ServerRegistration(BaseModel):
     """Server registration request model."""
+
     server_id: str
     server_url: str
     server_name: str
@@ -23,27 +28,41 @@ class ServerRegistration(BaseModel):
     endpoints: Optional[Dict[str, str]] = None
     auth_method: Optional[str] = "none"
     security_enabled: Optional[bool] = False
+
+
 class ServerUnregistration(BaseModel):
     """Server unregistration request model."""
+
     server_key: str  # Use server_key directly
+
+
 class HeartbeatData(BaseModel):
     """Heartbeat data model."""
+
     server_id: str
     server_key: str
     timestamp: Optional[int] = None
     status: Optional[str] = "healthy"
+
+
 class RegistrationResponse(BaseModel):
     """Registration response model."""
+
     success: bool
     server_key: str
     message: str
     copy_number: int
+
+
 class DiscoveryResponse(BaseModel):
     """Discovery response model."""
+
     success: bool
     servers: List[Dict]
     total: int
     active: int
+
+
 @router.post("/register", response_model=RegistrationResponse)
 async def register_server(registration: ServerRegistration):
     """Register a server with the proxy."""
@@ -64,16 +83,18 @@ async def register_server(registration: ServerRegistration):
             "security_enabled": registration.security_enabled,
             "registered_at": int(time.time()),
             "last_heartbeat": int(time.time()),
-            "status": "active"
+            "status": "active",
         }
         return RegistrationResponse(
             success=True,
             server_key=server_key,
             message=f"Server {registration.server_name} registered successfully",
-            copy_number=copy_number
+            copy_number=copy_number,
         )
     except Exception as e:
         raise HTTPException(status_code=500, detail=f"Registration failed: {str(e)}")
+
+
 @router.post("/unregister")
 async def unregister_server(unregistration: ServerUnregistration):
     """Unregister a server from the proxy."""
@@ -88,6 +109,8 @@ async def unregister_server(unregistration: ServerUnregistration):
         raise
     except Exception as e:
         raise HTTPException(status_code=500, detail=f"Unregistration failed: {str(e)}")
+
+
 @router.post("/heartbeat")
 async def send_heartbeat(heartbeat: HeartbeatData):
     """Send heartbeat for a registered server."""
@@ -95,13 +118,17 @@ async def send_heartbeat(heartbeat: HeartbeatData):
         if heartbeat.server_key not in _registry:
             raise HTTPException(status_code=404, detail="Server not found")
         # Update heartbeat information
-        _registry[heartbeat.server_key]["last_heartbeat"] = heartbeat.timestamp or int(time.time())
+        _registry[heartbeat.server_key]["last_heartbeat"] = heartbeat.timestamp or int(
+            time.time()
+        )
         _registry[heartbeat.server_key]["status"] = heartbeat.status
         return {"success": True, "message": "Heartbeat received"}
     except HTTPException:
         raise
     except Exception as e:
         raise HTTPException(status_code=500, detail=f"Heartbeat failed: {str(e)}")
+
+
 @router.get("/discover", response_model=DiscoveryResponse)
 async def discover_servers():
     """Discover active servers."""
@@ -111,39 +138,46 @@ async def discover_servers():
         for server_key, server in _registry.items():
             # Consider server active if heartbeat was within last 5 minutes
             if current_time - server["last_heartbeat"] < 300:
-                active_servers.append({
-                    "server_key": server_key,
-                    "server_id": server["server_id"],
-                    "server_name": server["server_name"],
-                    "server_url": server["server_url"],
-                    "status": server["status"],
-                    "last_heartbeat": server["last_heartbeat"]
-                })
+                active_servers.append(
+                    {
+                        "server_key": server_key,
+                        "server_id": server["server_id"],
+                        "server_name": server["server_name"],
+                        "server_url": server["server_url"],
+                        "status": server["status"],
+                        "last_heartbeat": server["last_heartbeat"],
+                    }
+                )
         return DiscoveryResponse(
             success=True,
             servers=active_servers,
             total=len(_registry),
-            active=len(active_servers)
+            active=len(active_servers),
         )
     except Exception as e:
         raise HTTPException(status_code=500, detail=f"Discovery failed: {str(e)}")
+
+
 @router.get("/status")
 async def get_proxy_status():
     """Get proxy status."""
     try:
         current_time = int(time.time())
         active_count = sum(
-            1 for server in _registry.values()
+            1
+            for server in _registry.values()
             if current_time - server["last_heartbeat"] < 300
         )
         return {
             "success": True,
             "total_registered": len(_registry),
             "active_servers": active_count,
-            "inactive_servers": len(_registry) - active_count
+            "inactive_servers": len(_registry) - active_count,
         }
     except Exception as e:
         raise HTTPException(status_code=500, detail=f"Status check failed: {str(e)}")
+
+
 @router.delete("/clear")
 async def clear_registry():
     """Clear the registry (for testing)."""

mcp_proxy_adapter/examples/full_application/__init__.py

@@ -8,5 +8,6 @@ This example demonstrates advanced usage of MCP Proxy Adapter including:
 """
 
 from .main import get_app
+
 app = get_app()
 from .proxy_endpoints import router as proxy_router

mcp_proxy_adapter/examples/full_application/commands/custom_echo_command.py

@@ -4,23 +4,29 @@ This module demonstrates a custom command implementation for the full applicatio
 Author: Vasiliy Zdanovskiy
 email: vasilyvz@gmail.com
 """
+
 from typing import Dict, Any, Optional
 from mcp_proxy_adapter.commands.base import BaseCommand
 from mcp_proxy_adapter.commands.result import CommandResult
+
+
 class CustomEchoResult(CommandResult):
     """Result class for custom echo command."""
+
     def __init__(self, message: str, timestamp: str, echo_count: int):
         self.message = message
         self.timestamp = timestamp
         self.echo_count = echo_count
+
     def to_dict(self) -> Dict[str, Any]:
         """Convert result to dictionary."""
         return {
             "message": self.message,
             "timestamp": self.timestamp,
             "echo_count": self.echo_count,
-            "command_type": "custom_echo"
+            "command_type": "custom_echo",
         }
+
     def get_schema(self) -> Dict[str, Any]:
         """Get result schema."""
         return {
@@ -29,21 +35,27 @@ class CustomEchoResult(CommandResult):
                 "message": {"type": "string", "description": "Echoed message"},
                 "timestamp": {"type": "string", "description": "Timestamp of echo"},
                 "echo_count": {"type": "integer", "description": "Number of echoes"},
-                "command_type": {"type": "string", "description": "Command type"}
+                "command_type": {"type": "string", "description": "Command type"},
             },
-            "required": ["message", "timestamp", "echo_count", "command_type"]
+            "required": ["message", "timestamp", "echo_count", "command_type"],
         }
+
+
 class CustomEchoCommand(BaseCommand):
     """Custom echo command implementation."""
+
     def __init__(self):
         super().__init__()
         self.echo_count = 0
+
     def get_name(self) -> str:
         """Get command name."""
         return "custom_echo"
+
     def get_description(self) -> str:
         """Get command description."""
         return "Custom echo command with enhanced features"
+
     def get_schema(self) -> Dict[str, Any]:
         """Get command schema."""
         return {
@@ -52,29 +64,29 @@ class CustomEchoCommand(BaseCommand):
                 "message": {
                     "type": "string",
                     "description": "Message to echo",
-                    "default": "Hello from custom echo!"
+                    "default": "Hello from custom echo!",
                 },
                 "repeat": {
                     "type": "integer",
                     "description": "Number of times to repeat",
                     "default": 1,
                     "minimum": 1,
-                    "maximum": 10
-                }
+                    "maximum": 10,
+                },
             },
-            "required": ["message"]
+            "required": ["message"],
         }
+
     async def execute(self, params: Dict[str, Any]) -> CustomEchoResult:
         """Execute the custom echo command."""
         message = params.get("message", "Hello from custom echo!")
         repeat = min(max(params.get("repeat", 1), 1), 10)
         self.echo_count += 1
         from datetime import datetime
+
         timestamp = datetime.now().isoformat()
         # Repeat the message
         echoed_message = " ".join([message] * repeat)
         return CustomEchoResult(
-            message=echoed_message,
-            timestamp=timestamp,
-            echo_count=self.echo_count
+            message=echoed_message, timestamp=timestamp, echo_count=self.echo_count
         )