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

mcp_proxy_adapter/examples/proxy_registration_example.py

@@ -5,12 +5,14 @@ for proxy registration with different authentication methods.
 Author: Vasiliy Zdanovskiy
 email: vasilyvz@gmail.com
 """
+
 import asyncio
 import json
 import sys
 import os
 from pathlib import Path
 from typing import Dict, Any, Optional
+
 # Add project root to path
 project_root = Path(__file__).parent.parent.parent
 sys.path.insert(0, str(project_root))
@@ -18,8 +20,11 @@ import aiohttp
 from aiohttp import ClientTimeout, TCPConnector
 import ssl
 from mcp_proxy_adapter.core.logging import logger
+
+
 class ProxyRegistrationExample:
     """Example client for testing proxy registration functionality."""
+
     def __init__(self, server_url: str, auth_token: Optional[str] = None):
         """
         Initialize example client.
@@ -42,10 +47,10 @@ class ProxyRegistrationExample:
                 "endpoints": {
                     "jsonrpc": "/api/jsonrpc",
                     "rest": "/cmd",
-                    "health": "/health"
+                    "health": "/health",
                 },
                 "auth_method": "api_key",
-                "security_enabled": True
+                "security_enabled": True,
             },
             {
                 "server_id": "example-server-2",
@@ -57,12 +62,13 @@ class ProxyRegistrationExample:
                 "endpoints": {
                     "jsonrpc": "/api/jsonrpc",
                     "rest": "/cmd",
-                    "health": "/health"
+                    "health": "/health",
                 },
                 "auth_method": "certificate",
-                "security_enabled": True
-            }
+                "security_enabled": True,
+            },
         ]
+
     async def __aenter__(self):
         """Async context manager entry."""
         # Create SSL context for HTTPS
@@ -75,23 +81,21 @@ class ProxyRegistrationExample:
         connector = TCPConnector(ssl=ssl_context) if ssl_context else None
         # Create session
         timeout = ClientTimeout(total=30)
-        self.session = aiohttp.ClientSession(
-            connector=connector,
-            timeout=timeout
-        )
+        self.session = aiohttp.ClientSession(connector=connector, timeout=timeout)
         return self
+
     async def __aexit__(self, exc_type, exc_val, exc_tb):
         """Async context manager exit."""
         if self.session:
             await self.session.close()
+
     def _get_headers(self) -> Dict[str, str]:
         """Get request headers with authentication."""
-        headers = {
-            "Content-Type": "application/json"
-        }
+        headers = {"Content-Type": "application/json"}
         if self.auth_token:
             headers["X-API-Key"] = self.auth_token
         return headers
+
     async def test_registration(self, server_data: Dict[str, Any]) -> Dict[str, Any]:
         """
         Test registration with authentication.
@@ -106,18 +110,13 @@ class ProxyRegistrationExample:
                 "jsonrpc": "2.0",
                 "id": 1,
                 "method": "proxy_registration",
-                "params": {
-                    "operation": "register",
-                    **server_data
-                }
+                "params": {"operation": "register", **server_data},
             }
             logger.info(f"Testing registration for server: {server_data['server_id']}")
             logger.debug(f"Request data: {json.dumps(request_data, indent=2)}")
             # Make request
             async with self.session.post(
-                f"{self.server_url}/cmd",
-                json=request_data,
-                headers=self._get_headers()
+                f"{self.server_url}/cmd", json=request_data, headers=self._get_headers()
             ) as response:
                 result = await response.json()
                 logger.info(f"Response status: {response.status}")
@@ -126,15 +125,16 @@ class ProxyRegistrationExample:
                     "success": response.status == 200,
                     "status_code": response.status,
                     "result": result,
-                    "server_id": server_data["server_id"]
+                    "server_id": server_data["server_id"],
                 }
         except Exception as e:
             logger.error(f"Registration test failed: {e}")
             return {
                 "success": False,
                 "error": str(e),
-                "server_id": server_data["server_id"]
+                "server_id": server_data["server_id"],
             }
+
     async def test_discovery(self) -> Dict[str, Any]:
         """
         Test discovery operation.
@@ -147,16 +147,12 @@ class ProxyRegistrationExample:
                 "jsonrpc": "2.0",
                 "id": 1,
                 "method": "proxy_registration",
-                "params": {
-                    "operation": "discover"
-                }
+                "params": {"operation": "discover"},
             }
             logger.info("Testing discovery operation")
             # Make request
             async with self.session.post(
-                f"{self.server_url}/cmd",
-                json=request_data,
-                headers=self._get_headers()
+                f"{self.server_url}/cmd", json=request_data, headers=self._get_headers()
             ) as response:
                 result = await response.json()
                 logger.info(f"Response status: {response.status}")
@@ -164,14 +160,12 @@ class ProxyRegistrationExample:
                 return {
                     "success": response.status == 200,
                     "status_code": response.status,
-                    "result": result
+                    "result": result,
                 }
         except Exception as e:
             logger.error(f"Discovery test failed: {e}")
-            return {
-                "success": False,
-                "error": str(e)
-            }
+            return {"success": False, "error": str(e)}
+
     async def test_heartbeat(self, server_key: str) -> Dict[str, Any]:
         """
         Test heartbeat operation.
@@ -190,15 +184,13 @@ class ProxyRegistrationExample:
                     "operation": "heartbeat",
                     "server_key": server_key,
                     "timestamp": 1234567890,
-                    "status": "healthy"
-                }
+                    "status": "healthy",
+                },
             }
             logger.info(f"Testing heartbeat for server: {server_key}")
             # Make request
             async with self.session.post(
-                f"{self.server_url}/cmd",
-                json=request_data,
-                headers=self._get_headers()
+                f"{self.server_url}/cmd", json=request_data, headers=self._get_headers()
             ) as response:
                 result = await response.json()
                 logger.info(f"Response status: {response.status}")
@@ -207,15 +199,13 @@ class ProxyRegistrationExample:
                     "success": response.status == 200,
                     "status_code": response.status,
                     "result": result,
-                    "server_key": server_key
+                    "server_key": server_key,
                 }
         except Exception as e:
             logger.error(f"Heartbeat test failed: {e}")
-            return {
-                "success": False,
-                "error": str(e),
-                "server_key": server_key
-            }
+            return {"success": False, "error": str(e), "server_key": server_key}
+
+
 async def run_proxy_registration_example():
     """Run proxy registration example."""
     logger.info("🚀 Starting proxy registration example")
@@ -224,18 +214,18 @@ async def run_proxy_registration_example():
         {
             "name": "Admin Token",
             "server_url": "http://localhost:8002",
-            "auth_token": "test-token-123"
+            "auth_token": "test-token-123",
         },
         {
             "name": "User Token",
             "server_url": "http://localhost:8002",
-            "auth_token": "user-token-456"
+            "auth_token": "user-token-456",
         },
         {
             "name": "Readonly Token",
             "server_url": "http://localhost:8002",
-            "auth_token": "readonly-token-123"
-        }
+            "auth_token": "readonly-token-123",
+        },
     ]
     results = []
     for config in test_configs:
@@ -243,47 +233,51 @@ async def run_proxy_registration_example():
         logger.info(f"Server URL: {config['server_url']}")
         logger.info(f"Auth Token: {config['auth_token']}")
         async with ProxyRegistrationExample(
-            config['server_url'],
-            config['auth_token']
+            config["server_url"], config["auth_token"]
         ) as client:
             # Test registration
             for server_data in client.test_servers:
                 result = await client.test_registration(server_data)
-                results.append({
-                    "test": f"{config['name']} - Registration",
-                    "server_id": server_data["server_id"],
-                    **result
-                })
+                results.append(
+                    {
+                        "test": f"{config['name']} - Registration",
+                        "server_id": server_data["server_id"],
+                        **result,
+                    }
+                )
                 # If registration successful, test heartbeat
                 if result["success"] and "result" in result:
                     server_key = result["result"].get("result", {}).get("server_key")
                     if server_key:
                         heartbeat_result = await client.test_heartbeat(server_key)
-                        results.append({
-                            "test": f"{config['name']} - Heartbeat",
-                            "server_key": server_key,
-                            **heartbeat_result
-                        })
+                        results.append(
+                            {
+                                "test": f"{config['name']} - Heartbeat",
+                                "server_key": server_key,
+                                **heartbeat_result,
+                            }
+                        )
             # Test discovery
             discovery_result = await client.test_discovery()
-            results.append({
-                "test": f"{config['name']} - Discovery",
-                **discovery_result
-            })
+            results.append(
+                {"test": f"{config['name']} - Discovery", **discovery_result}
+            )
     # Test without authentication
     logger.info(f"\n📋 Testing: No Authentication")
     async with ProxyRegistrationExample("http://localhost:8002") as client:
         for server_data in client.test_servers:
             result = await client.test_registration(server_data)
-            results.append({
-                "test": "No Auth - Registration",
-                "server_id": server_data["server_id"],
-                **result
-            })
+            results.append(
+                {
+                    "test": "No Auth - Registration",
+                    "server_id": server_data["server_id"],
+                    **result,
+                }
+            )
     # Print results
-    logger.info("\n" + "="*80)
+    logger.info("\n" + "=" * 80)
     logger.info("📊 EXAMPLE RESULTS")
-    logger.info("="*80)
+    logger.info("=" * 80)
     passed = 0
     failed = 0
     for result in results:
@@ -305,24 +299,29 @@ async def run_proxy_registration_example():
                     logger.info(f"   Server Key: {api_result['server_key']}")
                 if "message" in api_result:
                     logger.info(f"   Message: {api_result['message']}")
-    logger.info("\n" + "="*80)
+    logger.info("\n" + "=" * 80)
     logger.info(f"📈 SUMMARY: {passed} passed, {failed} failed")
-    logger.info("="*80)
+    logger.info("=" * 80)
     return passed, failed
+
+
 def main():
     """Main function for the example."""
     logger.info("🔧 MCP Proxy Adapter - Proxy Registration Example")
-    logger.info("="*60)
+    logger.info("=" * 60)
     # Check if server is running
     import socket
+
     sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-    result = sock.connect_ex(('localhost', 8002))
+    result = sock.connect_ex(("localhost", 8002))
     sock.close()
     if result != 0:
         logger.error("❌ Server is not running on localhost:8002")
         logger.info("💡 Please start the server first:")
         logger.info("   cd mcp_proxy_adapter/examples")
-        logger.info("   python -m mcp_proxy_adapter.main --config server_configs/config_proxy_registration.json")
+        logger.info(
+            "   python -m mcp_proxy_adapter.main --config server_configs/config_proxy_registration.json"
+        )
         sys.exit(1)
     logger.info("✅ Server is running on localhost:8002")
     logger.info("🚀 Starting proxy registration example...")
@@ -330,5 +329,7 @@ def main():
     passed, failed = asyncio.run(run_proxy_registration_example())
     # Exit with appropriate code
     sys.exit(0 if failed == 0 else 1)
+
+
 if __name__ == "__main__":
     main()

mcp_proxy_adapter/examples/run_example.py

@@ -9,9 +9,13 @@ import sys
 import subprocess
 import argparse
 from pathlib import Path
+
+
 def run_basic_example(config_name: str, port: int = None):
     """Run basic framework example."""
-    config_path = Path(__file__).parent / "basic_framework" / "configs" / f"{config_name}.json"
+    config_path = (
+        Path(__file__).parent / "basic_framework" / "configs" / f"{config_name}.json"
+    )
     main_script = Path(__file__).parent / "basic_framework" / "main.py"
     if not config_path.exists():
         print(f"❌ Configuration file not found: {config_path}")
@@ -21,9 +25,13 @@ def run_basic_example(config_name: str, port: int = None):
         cmd.extend(["--port", str(port)])
     print(f"🚀 Running basic framework example with {config_name} configuration...")
     return subprocess.run(cmd).returncode == 0
+
+
 def run_full_example(config_name: str, port: int = None):
     """Run full application example."""
-    config_path = Path(__file__).parent / "full_application" / "configs" / f"{config_name}.json"
+    config_path = (
+        Path(__file__).parent / "full_application" / "configs" / f"{config_name}.json"
+    )
     main_script = Path(__file__).parent / "full_application" / "main.py"
     if not config_path.exists():
         print(f"❌ Configuration file not found: {config_path}")
@@ -33,17 +41,25 @@ def run_full_example(config_name: str, port: int = None):
         cmd.extend(["--port", str(port)])
     print(f"🚀 Running full application example with {config_name} configuration...")
     return subprocess.run(cmd).returncode == 0
+
+
 def main():
     """Main function."""
     parser = argparse.ArgumentParser(description="Run MCP Proxy Adapter Examples")
     parser.add_argument("example", choices=["basic", "full"], help="Example type")
-    parser.add_argument("config", help="Configuration name (e.g., http_simple, https_auth)")
+    parser.add_argument(
+        "config", help="Configuration name (e.g., http_simple, https_auth)"
+    )
     parser.add_argument("--port", type=int, help="Override port")
     args = parser.parse_args()
     # Available configurations
     configs = [
-        "http_simple", "https_simple", "http_auth",
-        "https_auth", "mtls_no_roles", "mtls_with_roles"
+        "http_simple",
+        "https_simple",
+        "http_auth",
+        "https_auth",
+        "mtls_no_roles",
+        "mtls_with_roles",
     ]
     if args.config not in configs:
         print(f"❌ Unknown configuration: {args.config}")
@@ -55,5 +71,7 @@ def main():
     else:
         success = run_full_example(args.config, args.port)
     return 0 if success else 1
+
+
 if __name__ == "__main__":
     sys.exit(main())