mcp-proxy-adapter 6.4.12__py3-none-any.whl → 6.4.15__py3-none-any.whl

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

@@ -1,88 +0,0 @@
-"""
-Application Hooks
-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."""
-        logger.info("🚀 Application startup hook executed")
-        # Initialize application-specific resources
-        logger.info("📊 Initializing application metrics")
-        logger.info("🔐 Loading security configurations")
-        logger.info("📝 Setting up logging")
-
-    @staticmethod
-    def on_shutdown():
-        """Hook executed on application shutdown."""
-        logger.info("🛑 Application shutdown hook executed")
-        # Cleanup application resources
-        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."""
-        logger.info(f"🔧 Application hook: before_request with data: {request_data}")
-        # Add request metadata
-        request_data["app_metadata"] = {
-            "request_id": f"req_{datetime.now().timestamp()}",
-            "timestamp": datetime.now().isoformat(),
-            "application": "full_application_example",
-        }
-        return request_data
-
-    @staticmethod
-    def after_request(result: Dict[str, Any]) -> Dict[str, Any]:
-        """Hook executed after processing any request."""
-        logger.info(f"🔧 Application hook: after_request with result: {result}")
-        # Add response metadata
-        result["app_response_metadata"] = {
-            "processed_at": datetime.now().isoformat(),
-            "application": "full_application_example",
-            "version": "1.0.0",
-        }
-        return result
-
-    @staticmethod
-    def on_error(error: Exception, context: Dict[str, Any]):
-        """Hook executed when an error occurs."""
-        logger.error(f"🔧 Application hook: on_error - {error} in context: {context}")
-        # Log error details
-        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."""
-        logger.info(f"🔧 Application hook: on_command_registered - {command_name}")
-        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."""
-        logger.info(f"🔧 Application hook: on_command_executed - {command_name}")
-        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"
-            )
-        else:
-            logger.warning(f"⚠️ Command '{command_name}' failed after {execution_time}s")

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

@@ -1,81 +0,0 @@
-"""
-Built-in Command Hooks
-This module demonstrates hooks for built-in commands 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 BuiltinCommandHooks:
-    """Hooks for built-in commands."""
-
-    @staticmethod
-    def before_echo_command(params: Dict[str, Any]) -> Dict[str, Any]:
-        """Hook executed before echo command."""
-        logger.info(f"🔧 Built-in hook: before_echo_command with params: {params}")
-        # Add timestamp to message
-        if "message" in params:
-            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."""
-        logger.info(f"🔧 Built-in hook: after_echo_command with result: {result}")
-        # Add hook metadata
-        result["hook_metadata"] = {
-            "hook_type": "builtin_after_echo",
-            "timestamp": datetime.now().isoformat(),
-            "processed": True,
-        }
-        return result
-
-    @staticmethod
-    def before_health_command(params: Dict[str, Any]) -> Dict[str, Any]:
-        """Hook executed before health command."""
-        logger.info(f"🔧 Built-in hook: before_health_command with params: {params}")
-        # Add custom health check parameters
-        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."""
-        logger.info(f"🔧 Built-in hook: after_health_command with result: {result}")
-        # Add custom health metrics
-        if "status" in result and result["status"] == "healthy":
-            result["custom_metrics"] = {
-                "uptime": "24h",
-                "memory_usage": "45%",
-                "cpu_usage": "12%",
-            }
-        return result
-
-    @staticmethod
-    def before_config_command(params: Dict[str, Any]) -> Dict[str, Any]:
-        """Hook executed before config command."""
-        logger.info(f"🔧 Built-in hook: before_config_command with params: {params}")
-        # Add configuration validation
-        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."""
-        logger.info(f"🔧 Built-in hook: after_config_command with result: {result}")
-        # Add configuration metadata
-        result["config_metadata"] = {
-            "last_modified": datetime.now().isoformat(),
-            "version": "1.0.0",
-            "environment": "development",
-        }
-        return result

mcp_proxy_adapter/examples/examples/full_application/main.py

@@ -1,61 +0,0 @@
-#!/usr/bin/env python3
-"""
-Full Application Example
-This is a complete application that demonstrates all features of MCP Proxy Adapter framework:
-- Built-in commands
-- Custom commands
-- Dynamically loaded commands
-- Built-in command hooks
-- Application hooks
-Author: Vasiliy Zdanovskiy
-email: vasilyvz@gmail.com
-"""
-import sys
-import argparse
-import asyncio
-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
-
-
-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("--host", help="Server host")
-    parser.add_argument("--port", type=int, help="Server port")
-    parser.add_argument("--debug", action="store_true", help="Enable debug mode")
-    args = parser.parse_args()
-    
-    # Override configuration if specified
-    config_overrides = {}
-    if args.host:
-        config_overrides["host"] = args.host
-    if args.port:
-        config_overrides["port"] = args.port
-    if args.debug:
-        config_overrides["debug"] = True
-    
-    print(f"🚀 Starting Full Application Example")
-    print(f"📋 Configuration: {args.config}")
-    print(f"🔧 Features: Built-in commands, Custom commands, Dynamic commands, Hooks, Proxy endpoints")
-    print("=" * 60)
-    
-    # Use the factory method to create and run the server
-    asyncio.run(create_and_run_server(
-        config_path=args.config,
-        title="Full Application Example",
-        description="Complete MCP Proxy Adapter with all features",
-        version="1.0.0",
-        host=config_overrides.get("host", "0.0.0.0"),
-        log_level="debug" if config_overrides.get("debug", False) else "info",
-    ))
-
-
-if __name__ == "__main__":
-    main()

mcp_proxy_adapter/examples/examples/full_application/proxy_endpoints.py

@@ -1,188 +0,0 @@
-"""
-Proxy Registration Endpoints
-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
-    description: Optional[str] = None
-    version: Optional[str] = "1.0.0"
-    capabilities: Optional[List[str]] = None
-    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."""
-    try:
-        # Generate unique server key
-        server_key = f"{registration.server_id}_{uuid.uuid4().hex[:8]}"
-        copy_number = 1
-        # Store server information
-        _registry[server_key] = {
-            "server_id": registration.server_id,
-            "server_url": registration.server_url,
-            "server_name": registration.server_name,
-            "description": registration.description,
-            "version": registration.version,
-            "capabilities": registration.capabilities or [],
-            "endpoints": registration.endpoints or {},
-            "auth_method": registration.auth_method,
-            "security_enabled": registration.security_enabled,
-            "registered_at": int(time.time()),
-            "last_heartbeat": int(time.time()),
-            "status": "active",
-        }
-        return RegistrationResponse(
-            success=True,
-            server_key=server_key,
-            message=f"Server {registration.server_name} registered successfully",
-            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."""
-    try:
-        # Check if server exists in registry
-        if unregistration.server_key not in _registry:
-            raise HTTPException(status_code=404, detail="Server not found")
-        # Remove from registry
-        del _registry[unregistration.server_key]
-        return {"success": True, "message": "Server unregistered successfully"}
-    except HTTPException:
-        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."""
-    try:
-        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]["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."""
-    try:
-        current_time = int(time.time())
-        active_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"],
-                    }
-                )
-        return DiscoveryResponse(
-            success=True,
-            servers=active_servers,
-            total=len(_registry),
-            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()
-            if current_time - server["last_heartbeat"] < 300
-        )
-        return {
-            "success": True,
-            "total_registered": len(_registry),
-            "active_servers": 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)."""
-    try:
-        _registry.clear()
-        return {"success": True, "message": "Registry cleared"}
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Clear failed: {str(e)}")