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

mcp_proxy_adapter/examples/debug_request_state.py

@@ -9,89 +9,106 @@ import asyncio
 import json
 import sys
 from pathlib import Path
+
 # Add project root to path
 project_root = Path(__file__).parent.parent.parent
 sys.path.insert(0, str(project_root))
 from fastapi import FastAPI, Request
 from fastapi.testclient import TestClient
 from mcp_proxy_adapter.api.app import create_app
+
+
 async def debug_request_state():
     """Debug request state handling."""
     print("🔍 ОТЛАДКА REQUEST.STATE")
     print("=" * 50)
     # Create test app with proper configuration
-    config_path = project_root / "mcp_proxy_adapter" / "examples" / "server_configs" / "config_http_token.json"
+    config_path = (
+        project_root
+        / "mcp_proxy_adapter"
+        / "examples"
+        / "server_configs"
+        / "config_http_token.json"
+    )
     with open(config_path) as f:
         config = json.load(f)
     # Override global config for testing
     import mcp_proxy_adapter.config
+
     mcp_proxy_adapter.config.config = config
     app = create_app(config)
     client = TestClient(app)
     print("📋 1. ТЕСТИРОВАНИЕ БЕЗ АУТЕНТИФИКАЦИИ")
     print("-" * 30)
     # Test without authentication
-    response = client.post("/cmd", json={
-        "jsonrpc": "2.0",
-        "method": "echo",
-        "params": {"message": "test"},
-        "id": 1
-    })
+    response = client.post(
+        "/cmd",
+        json={
+            "jsonrpc": "2.0",
+            "method": "echo",
+            "params": {"message": "test"},
+            "id": 1,
+        },
+    )
     print(f"Status: {response.status_code}")
     print(f"Response: {response.json()}")
     print("\n📋 2. ТЕСТИРОВАНИЕ С ADMIN ТОКЕНОМ")
     print("-" * 30)
     # Test with admin token
-    response = client.post("/cmd",
+    response = client.post(
+        "/cmd",
         json={
             "jsonrpc": "2.0",
             "method": "echo",
             "params": {"message": "test"},
-            "id": 1
+            "id": 1,
         },
-        headers={"X-API-Key": "test-token-123"}
+        headers={"X-API-Key": "test-token-123"},
     )
     print(f"Status: {response.status_code}")
     print(f"Response: {response.json()}")
     print("\n📋 3. ТЕСТИРОВАНИЕ С USER ТОКЕНОМ")
     print("-" * 30)
     # Test with user token
-    response = client.post("/cmd",
+    response = client.post(
+        "/cmd",
         json={
             "jsonrpc": "2.0",
             "method": "echo",
             "params": {"message": "test"},
-            "id": 1
+            "id": 1,
         },
-        headers={"X-API-Key": "user-token-456"}
+        headers={"X-API-Key": "user-token-456"},
     )
     print(f"Status: {response.status_code}")
     print(f"Response: {response.json()}")
     print("\n📋 4. ТЕСТИРОВАНИЕ С READONLY ТОКЕНОМ")
     print("-" * 30)
     # Test with readonly token
-    response = client.post("/cmd",
+    response = client.post(
+        "/cmd",
         json={
             "jsonrpc": "2.0",
             "method": "echo",
             "params": {"message": "test"},
-            "id": 1
+            "id": 1,
         },
-        headers={"X-API-Key": "readonly-token-123"}
+        headers={"X-API-Key": "readonly-token-123"},
     )
     print(f"Status: {response.status_code}")
     print(f"Response: {response.json()}")
     print("\n📋 5. ТЕСТИРОВАНИЕ ROLE_TEST КОМАНДЫ")
     print("-" * 30)
     # Test role_test command with readonly token
-    response = client.post("/cmd",
+    response = client.post(
+        "/cmd",
         json={
             "jsonrpc": "2.0",
             "method": "role_test",
             "params": {"action": "write"},
-            "id": 1
+            "id": 1,
         },
-        headers={"X-API-Key": "readonly-token-123"}
+        headers={"X-API-Key": "readonly-token-123"},
     )
     print(f"Status: {response.status_code}")
     print(f"Response: {response.json()}")
@@ -108,5 +125,7 @@ async def debug_request_state():
     print("2. Убедиться, что framework middleware устанавливает user info")
     print("3. Добавить проверку прав в команды")
     print("4. Проверить интеграцию middleware")
+
+
 if __name__ == "__main__":
     asyncio.run(debug_request_state())

mcp_proxy_adapter/examples/debug_role_chain.py

@@ -9,17 +9,30 @@ import asyncio
 import json
 import sys
 from pathlib import Path
+
 # Add project root to path
 project_root = Path(__file__).parent.parent.parent
 sys.path.insert(0, str(project_root))
 from mcp_security_framework import SecurityManager, AuthManager, PermissionManager
-from mcp_security_framework.schemas.config import SecurityConfig, AuthConfig, PermissionConfig
+from mcp_security_framework.schemas.config import (
+    SecurityConfig,
+    AuthConfig,
+    PermissionConfig,
+)
+
+
 async def debug_role_chain():
     """Debug the complete role chain from authentication to blocking."""
     print("🔍 АНАЛИЗ ЦЕПОЧКИ БЛОКИРОВКИ РОЛЕЙ")
     print("=" * 60)
     # Load configuration
-    config_path = project_root / "mcp_proxy_adapter" / "examples" / "server_configs" / "config_http_token.json"
+    config_path = (
+        project_root
+        / "mcp_proxy_adapter"
+        / "examples"
+        / "server_configs"
+        / "config_http_token.json"
+    )
     with open(config_path) as f:
         config = json.load(f)
     security_config = config.get("security", {})
@@ -37,7 +50,13 @@ async def debug_role_chain():
     print("-" * 30)
     # Create permission config
     perm_config = PermissionConfig(
-        roles_file=str(project_root / "mcp_proxy_adapter" / "examples" / "server_configs" / "roles.json"),
+        roles_file=str(
+            project_root
+            / "mcp_proxy_adapter"
+            / "examples"
+            / "server_configs"
+            / "roles.json"
+        ),
         default_role="guest",
         admin_role="admin",
         role_hierarchy=security_config.get("permissions", {}).get("role_hierarchy", {}),
@@ -45,7 +64,7 @@ async def debug_role_chain():
         permission_cache_ttl=300,
         wildcard_permissions=False,
         strict_mode=True,
-        roles=roles_config
+        roles=roles_config,
     )
     # Create auth config
     auth_config = AuthConfig(
@@ -57,17 +76,18 @@ async def debug_role_chain():
         jwt_algorithm=security_config.get("auth", {}).get("jwt_algorithm", "HS256"),
         jwt_expiry_hours=security_config.get("auth", {}).get("jwt_expiry_hours", 24),
         certificate_auth=security_config.get("auth", {}).get("certificate_auth", False),
-        certificate_roles_oid=security_config.get("auth", {}).get("certificate_roles_oid"),
-        certificate_permissions_oid=security_config.get("auth", {}).get("certificate_permissions_oid"),
+        certificate_roles_oid=security_config.get("auth", {}).get(
+            "certificate_roles_oid"
+        ),
+        certificate_permissions_oid=security_config.get("auth", {}).get(
+            "certificate_permissions_oid"
+        ),
         basic_auth=security_config.get("auth", {}).get("basic_auth", False),
         oauth2_config=security_config.get("auth", {}).get("oauth2_config"),
-        public_paths=security_config.get("auth", {}).get("public_paths", [])
+        public_paths=security_config.get("auth", {}).get("public_paths", []),
     )
     # Create security config
-    security_config_obj = SecurityConfig(
-        auth=auth_config,
-        permissions=perm_config
-    )
+    security_config_obj = SecurityConfig(auth=auth_config, permissions=perm_config)
     print("✅ Конфигурации созданы")
     print("\n📋 4. ИНИЦИАЛИЗАЦИЯ МЕНЕДЖЕРОВ")
     print("-" * 30)
@@ -83,7 +103,7 @@ async def debug_role_chain():
         "admin": "test-token-123",
         "user": "user-token-456",
         "readonly": "readonly-token-123",
-        "invalid": "invalid-token-999"
+        "invalid": "invalid-token-999",
     }
     auth_results = {}
     for role, token in test_tokens.items():
@@ -91,7 +111,9 @@ async def debug_role_chain():
         try:
             result = auth_manager.authenticate_api_key(token)
             auth_results[role] = result
-            print(f"  ✅ Аутентификация: {'УСПЕШНА' if result.is_valid else 'НЕУДАЧНА'}")
+            print(
+                f"  ✅ Аутентификация: {'УСПЕШНА' if result.is_valid else 'НЕУДАЧНА'}"
+            )
             if result.is_valid:
                 print(f"  👤 Пользователь: {result.username}")
                 print(f"  🏷️ Роли: {result.roles}")
@@ -107,20 +129,29 @@ async def debug_role_chain():
     test_actions = ["read", "write", "manage", "delete"]
     for role, auth_result in auth_results.items():
         if auth_result and auth_result.is_valid:
-            print(f"\n🔒 Тестирование прав для роли '{role}' (роли: {auth_result.roles})")
+            print(
+                f"\n🔒 Тестирование прав для роли '{role}' (роли: {auth_result.roles})"
+            )
             for action in test_actions:
                 try:
                     # Check permissions using permission manager
                     validation_result = permission_manager.validate_access(
-                        auth_result.roles,
-                        [action]
+                        auth_result.roles, [action]
+                    )
+                    status = (
+                        "✅ РАЗРЕШЕНО"
+                        if validation_result.is_valid
+                        else "❌ ЗАБЛОКИРОВАНО"
                     )
-                    status = "✅ РАЗРЕШЕНО" if validation_result.is_valid else "❌ ЗАБЛОКИРОВАНО"
                     print(f"  {action}: {status}")
                     if not validation_result.is_valid:
                         print(f"    📝 Причина: {validation_result.error_message}")
-                        print(f"    🎯 Эффективные права: {validation_result.effective_permissions}")
-                        print(f"    ❌ Отсутствующие права: {validation_result.missing_permissions}")
+                        print(
+                            f"    🎯 Эффективные права: {validation_result.effective_permissions}"
+                        )
+                        print(
+                            f"    ❌ Отсутствующие права: {validation_result.missing_permissions}"
+                        )
                 except Exception as e:
                     print(f"  {action}: ❌ ОШИБКА - {e}")
     print("\n📋 7. ТЕСТИРОВАНИЕ ПОЛНОЙ ЦЕПОЧКИ")
@@ -131,7 +162,7 @@ async def debug_role_chain():
         request_data = {
             "api_key": token,
             "required_permissions": ["write"],
-            "client_ip": "127.0.0.1"
+            "client_ip": "127.0.0.1",
         }
         try:
             result = security_manager.validate_request(request_data)
@@ -154,5 +185,7 @@ async def debug_role_chain():
     print("2. Добавить проверку прав на уровне middleware")
     print("3. Убедиться, что request.state содержит user info")
     print("4. Проверить интеграцию между middleware и командами")
+
+
 if __name__ == "__main__":
     asyncio.run(debug_role_chain())

mcp_proxy_adapter/examples/demo_client.py

@@ -5,13 +5,17 @@ authentication methods and connection types.
 Author: Vasiliy Zdanovskiy
 email: vasilyvz@gmail.com
 """
+
 import asyncio
 import json
 import sys
 from pathlib import Path
+
 # Add project root to path
 sys.path.insert(0, str(Path(__file__).parent.parent))
 from examples.universal_client import UniversalClient, create_client_config
+
+
 async def demo_from_config_file(config_file: str):
     """
     Demo client using configuration from file.
@@ -22,9 +26,11 @@ async def demo_from_config_file(config_file: str):
     print("=" * 50)
     try:
         # Load configuration
-        with open(config_file, 'r') as f:
+        with open(config_file, "r") as f:
             config = json.load(f)
-        print(f"Configuration loaded: {config.get('security', {}).get('auth_method', 'none')} auth")
+        print(
+            f"Configuration loaded: {config.get('security', {}).get('auth_method', 'none')} auth"
+        )
         # Create and use client
         async with UniversalClient(config) as client:
             # Test connection
@@ -47,6 +53,8 @@ async def demo_from_config_file(config_file: str):
         print(f"❌ Invalid JSON in configuration file: {config_file}")
     except Exception as e:
         print(f"❌ Demo failed: {e}")
+
+
 async def demo_api_calls(client: UniversalClient):
     """Demonstrate various API calls."""
     print("\n📡 API Calls Demo:")
@@ -70,9 +78,9 @@ async def demo_api_calls(client: UniversalClient):
             "method": "test_command",
             "params": {
                 "message": "Hello from universal client!",
-                "timestamp": "2024-01-01T00:00:00Z"
+                "timestamp": "2024-01-01T00:00:00Z",
             },
-            "id": 1
+            "id": 1,
         }
         result = await client.post("/api/jsonrpc", command_data)
         print(f"Command Result: {result}")
@@ -83,16 +91,15 @@ async def demo_api_calls(client: UniversalClient):
         security_data = {
             "jsonrpc": "2.0",
             "method": "security_command",
-            "params": {
-                "action": "get_status",
-                "include_certificates": True
-            },
-            "id": 2
+            "params": {"action": "get_status", "include_certificates": True},
+            "id": 2,
         }
         result = await client.post("/api/jsonrpc", security_data)
         print(f"Security Status: {result}")
     except Exception as e:
         print(f"Security command failed: {e}")
+
+
 async def demo_all_configs():
     """Demo all available client configurations."""
     print("🚀 Demo All Client Configurations")
@@ -112,6 +119,8 @@ async def demo_all_configs():
     for config_file in config_files:
         await demo_from_config_file(str(config_file))
         print("\n" + "-" * 50)
+
+
 async def demo_programmatic_config():
     """Demo client with programmatically created configuration."""
     print("🚀 Demo Programmatic Configuration")
@@ -121,10 +130,8 @@ async def demo_programmatic_config():
         {
             "name": "API Key Client",
             "config": create_client_config(
-                "http://localhost:8000",
-                "api_key",
-                api_key="demo_api_key_123"
-            )
+                "http://localhost:8000", "api_key", api_key="demo_api_key_123"
+            ),
         },
         {
             "name": "JWT Client",
@@ -133,8 +140,8 @@ async def demo_programmatic_config():
                 "jwt",
                 username="demo_user",
                 password="demo_password",
-                secret="demo_jwt_secret"
-            )
+                secret="demo_jwt_secret",
+            ),
         },
         {
             "name": "Certificate Client",
@@ -143,8 +150,8 @@ async def demo_programmatic_config():
                 "certificate",
                 cert_file="./certs/client.crt",
                 key_file="./keys/client.key",
-                ca_cert_file="./certs/ca.crt"
-            )
+                ca_cert_file="./certs/ca.crt",
+            ),
         },
         {
             "name": "Basic Auth Client",
@@ -152,9 +159,9 @@ async def demo_programmatic_config():
                 "http://localhost:8000",
                 "basic",
                 username="demo_user",
-                password="demo_password"
-            )
-        }
+                password="demo_password",
+            ),
+        },
     ]
     for config_info in configs:
         print(f"\n📋 Testing: {config_info['name']}")
@@ -169,6 +176,8 @@ async def demo_programmatic_config():
                     print("❌ Connection failed")
         except Exception as e:
             print(f"❌ Test failed: {e}")
+
+
 async def interactive_demo():
     """Interactive demo with user input."""
     print("🚀 Interactive Client Demo")
@@ -186,14 +195,16 @@ async def interactive_demo():
             "2": "api_key",
             "3": "jwt",
             "4": "certificate",
-            "5": "basic"
+            "5": "basic",
         }
         if choice not in auth_methods:
             print("❌ Invalid choice")
             return
         auth_method = auth_methods[choice]
         # Get server URL
-        server_url = input("Enter server URL (default: http://localhost:8000): ").strip()
+        server_url = input(
+            "Enter server URL (default: http://localhost:8000): "
+        ).strip()
         if not server_url:
             server_url = "http://localhost:8000"
         # Create configuration based on choice
@@ -207,29 +218,26 @@ async def interactive_demo():
             password = input("Enter password: ").strip()
             secret = input("Enter JWT secret: ").strip()
             if username and password and secret:
-                config_kwargs.update({
-                    "username": username,
-                    "password": password,
-                    "secret": secret
-                })
+                config_kwargs.update(
+                    {"username": username, "password": password, "secret": secret}
+                )
         elif auth_method == "certificate":
             cert_file = input("Enter certificate file path: ").strip()
             key_file = input("Enter key file path: ").strip()
             ca_cert_file = input("Enter CA certificate file path: ").strip()
             if cert_file and key_file:
-                config_kwargs.update({
-                    "cert_file": cert_file,
-                    "key_file": key_file,
-                    "ca_cert_file": ca_cert_file
-                })
+                config_kwargs.update(
+                    {
+                        "cert_file": cert_file,
+                        "key_file": key_file,
+                        "ca_cert_file": ca_cert_file,
+                    }
+                )
         elif auth_method == "basic":
             username = input("Enter username: ").strip()
             password = input("Enter password: ").strip()
             if username and password:
-                config_kwargs.update({
-                    "username": username,
-                    "password": password
-                })
+                config_kwargs.update({"username": username, "password": password})
         # Create configuration
         config = create_client_config(server_url, auth_method, **config_kwargs)
         print(f"\nConfiguration created for {auth_method} authentication")
@@ -246,6 +254,8 @@ async def interactive_demo():
         print("\n\nDemo interrupted by user")
     except Exception as e:
         print(f"❌ Interactive demo failed: {e}")
+
+
 def main():
     """Main demo function."""
     if len(sys.argv) > 1:
@@ -271,5 +281,7 @@ def main():
     else:
         # Default: demo all configs
         asyncio.run(demo_all_configs())
+
+
 if __name__ == "__main__":
     main()

mcp_proxy_adapter/examples/examples/basic_framework/main.py

@@ -9,13 +9,18 @@ email: vasilyvz@gmail.com
 import sys
 import argparse
 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 basic framework example."""
     parser = argparse.ArgumentParser(description="Basic Framework 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")
@@ -38,7 +43,9 @@ def main():
         description="Basic MCP Proxy Adapter with minimal configuration",
         version="1.0.0",
         host=config_overrides.get("host", "0.0.0.0"),
-        log_level="debug" if config_overrides.get("debug", False) else "info"
+        log_level="debug" if config_overrides.get("debug", False) else "info",
     )
+
+
 if __name__ == "__main__":
     main()

mcp_proxy_adapter/examples/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/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
         )