mcp-proxy-adapter 6.1.1__py3-none-any.whl → 6.2.0__py3-none-any.whl

mcp_proxy_adapter/examples/proxy_registration_example.py

@@ -1,38 +1,28 @@
 """
 Proxy Registration Example
-
 This example demonstrates how to use the MCP Proxy Adapter framework
 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))
-
 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.
-        
         Args:
             server_url: Server URL
             auth_token: Authentication token
@@ -40,7 +30,6 @@ class ProxyRegistrationExample:
         self.server_url = server_url
         self.auth_token = auth_token
         self.session: Optional[aiohttp.ClientSession] = None
-        
         # Test data
         self.test_servers = [
             {
@@ -59,7 +48,7 @@ class ProxyRegistrationExample:
                 "security_enabled": True
             },
             {
-                "server_id": "example-server-2", 
+                "server_id": "example-server-2",
                 "server_url": "http://localhost:8002",
                 "server_name": "Example Server 2",
                 "description": "Another example server",
@@ -74,7 +63,6 @@ class ProxyRegistrationExample:
                 "security_enabled": True
             }
         ]
-    
     async def __aenter__(self):
         """Async context manager entry."""
         # Create SSL context for HTTPS
@@ -83,42 +71,32 @@ class ProxyRegistrationExample:
             ssl_context = ssl.create_default_context()
             ssl_context.check_hostname = False
             ssl_context.verify_mode = ssl.CERT_NONE
-        
         # Create connector
         connector = TCPConnector(ssl=ssl_context) if ssl_context else None
-        
         # Create session
         timeout = ClientTimeout(total=30)
         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"
         }
-        
         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.
-        
         Args:
             server_data: Server registration data
-            
         Returns:
             Test result
         """
@@ -133,10 +111,8 @@ class ProxyRegistrationExample:
                     **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",
@@ -144,17 +120,14 @@ class ProxyRegistrationExample:
                 headers=self._get_headers()
             ) as response:
                 result = await response.json()
-                
                 logger.info(f"Response status: {response.status}")
                 logger.debug(f"Response: {json.dumps(result, indent=2)}")
-                
                 return {
                     "success": response.status == 200,
                     "status_code": response.status,
                     "result": result,
                     "server_id": server_data["server_id"]
                 }
-                
         except Exception as e:
             logger.error(f"Registration test failed: {e}")
             return {
@@ -162,11 +135,9 @@ class ProxyRegistrationExample:
                 "error": str(e),
                 "server_id": server_data["server_id"]
             }
-    
     async def test_discovery(self) -> Dict[str, Any]:
         """
         Test discovery operation.
-        
         Returns:
             Test result
         """
@@ -180,9 +151,7 @@ class ProxyRegistrationExample:
                     "operation": "discover"
                 }
             }
-            
             logger.info("Testing discovery operation")
-            
             # Make request
             async with self.session.post(
                 f"{self.server_url}/cmd",
@@ -190,30 +159,24 @@ class ProxyRegistrationExample:
                 headers=self._get_headers()
             ) as response:
                 result = await response.json()
-                
                 logger.info(f"Response status: {response.status}")
                 logger.debug(f"Response: {json.dumps(result, indent=2)}")
-                
                 return {
                     "success": response.status == 200,
                     "status_code": response.status,
                     "result": result
                 }
-                
         except Exception as e:
             logger.error(f"Discovery test failed: {e}")
             return {
                 "success": False,
                 "error": str(e)
             }
-    
     async def test_heartbeat(self, server_key: str) -> Dict[str, Any]:
         """
         Test heartbeat operation.
-        
         Args:
             server_key: Server key for heartbeat
-            
         Returns:
             Test result
         """
@@ -230,9 +193,7 @@ class ProxyRegistrationExample:
                     "status": "healthy"
                 }
             }
-            
             logger.info(f"Testing heartbeat for server: {server_key}")
-            
             # Make request
             async with self.session.post(
                 f"{self.server_url}/cmd",
@@ -240,17 +201,14 @@ class ProxyRegistrationExample:
                 headers=self._get_headers()
             ) as response:
                 result = await response.json()
-                
                 logger.info(f"Response status: {response.status}")
                 logger.debug(f"Response: {json.dumps(result, indent=2)}")
-                
                 return {
                     "success": response.status == 200,
                     "status_code": response.status,
                     "result": result,
                     "server_key": server_key
                 }
-                
         except Exception as e:
             logger.error(f"Heartbeat test failed: {e}")
             return {
@@ -258,12 +216,9 @@ class ProxyRegistrationExample:
                 "error": str(e),
                 "server_key": server_key
             }
-
-
 async def run_proxy_registration_example():
     """Run proxy registration example."""
     logger.info("🚀 Starting proxy registration example")
-    
     # Test configurations
     test_configs = [
         {
@@ -273,7 +228,7 @@ async def run_proxy_registration_example():
         },
         {
             "name": "User Token",
-            "server_url": "http://localhost:8002", 
+            "server_url": "http://localhost:8002",
             "auth_token": "user-token-456"
         },
         {
@@ -282,16 +237,13 @@ async def run_proxy_registration_example():
             "auth_token": "readonly-token-123"
         }
     ]
-    
     results = []
-    
     for config in test_configs:
         logger.info(f"\n📋 Testing: {config['name']}")
         logger.info(f"Server URL: {config['server_url']}")
         logger.info(f"Auth Token: {config['auth_token']}")
-        
         async with ProxyRegistrationExample(
-            config['server_url'], 
+            config['server_url'],
             config['auth_token']
         ) as client:
             # Test registration
@@ -302,7 +254,6 @@ async def run_proxy_registration_example():
                     "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")
@@ -313,14 +264,12 @@ async def run_proxy_registration_example():
                             "server_key": server_key,
                             **heartbeat_result
                         })
-            
             # Test discovery
             discovery_result = await client.test_discovery()
             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:
@@ -331,24 +280,19 @@ async def run_proxy_registration_example():
                 "server_id": server_data["server_id"],
                 **result
             })
-    
     # Print results
     logger.info("\n" + "="*80)
     logger.info("📊 EXAMPLE RESULTS")
     logger.info("="*80)
-    
     passed = 0
     failed = 0
-    
     for result in results:
         status = "✅ PASS" if result["success"] else "❌ FAIL"
         logger.info(f"{status} {result['test']}")
-        
         if result["success"]:
             passed += 1
         else:
             failed += 1
-            
         if "error" in result:
             logger.error(f"   Error: {result['error']}")
         elif "result" in result:
@@ -361,41 +305,30 @@ 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(f"📈 SUMMARY: {passed} passed, {failed} failed")
     logger.info("="*80)
-    
     return passed, failed
-
-
 def main():
     """Main function for the example."""
     logger.info("🔧 MCP Proxy Adapter - Proxy Registration Example")
     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))
     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")
         sys.exit(1)
-    
     logger.info("✅ Server is running on localhost:8002")
     logger.info("🚀 Starting proxy registration example...")
-    
     # Run example
     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

@@ -1,81 +1,59 @@
 #!/usr/bin/env python3
 """
 Example Runner Script
-
 This script provides a simple way to run the examples.
-
 Author: Vasiliy Zdanovskiy
 email: vasilyvz@gmail.com
 """
-
 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"
     main_script = Path(__file__).parent / "basic_framework" / "main.py"
-    
     if not config_path.exists():
         print(f"❌ Configuration file not found: {config_path}")
         return False
-    
     cmd = [sys.executable, str(main_script), "--config", str(config_path)]
     if port:
         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"
     main_script = Path(__file__).parent / "full_application" / "main.py"
-    
     if not config_path.exists():
         print(f"❌ Configuration file not found: {config_path}")
         return False
-    
     cmd = [sys.executable, str(main_script), "--config", str(config_path)]
     if port:
         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("--port", type=int, help="Override port")
-    
     args = parser.parse_args()
-    
     # Available configurations
     configs = [
-        "http_simple", "https_simple", "http_auth", 
+        "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}")
         print(f"Available configurations: {', '.join(configs)}")
         return 1
-    
     # Run the appropriate example
     if args.example == "basic":
         success = run_basic_example(args.config, args.port)
     else:
         success = run_full_example(args.config, args.port)
-    
     return 0 if success else 1
-
-
 if __name__ == "__main__":
     sys.exit(main())