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

mcp_proxy_adapter/commands/result.py

@@ -13,7 +13,7 @@ class CommandResult(ABC):
     """
     Base abstract class for command execution results.
     """
-    
+
     @abstractmethod
     def to_dict(self) -> Dict[str, Any]:
         """
@@ -23,7 +23,7 @@ class CommandResult(ABC):
             Dictionary with result data.
         """
         pass
-    
+
     @classmethod
     @abstractmethod
     def get_schema(cls) -> Dict[str, Any]:
@@ -34,7 +34,7 @@ class CommandResult(ABC):
             Dictionary with JSON schema.
         """
         pass
-    
+
     def to_json(self, indent: Optional[int] = None) -> str:
         """
         Converts result to JSON string.
@@ -46,7 +46,7 @@ class CommandResult(ABC):
             JSON string with result.
         """
         return json.dumps(self.to_dict(), ensure_ascii=False, indent=indent)
-    
+
     @classmethod
     def from_dict(cls: Type[T], data: Dict[str, Any]) -> T:
         """
@@ -66,8 +66,10 @@ class SuccessResult(CommandResult):
     """
     Base class for successful command results.
     """
-    
-    def __init__(self, data: Optional[Dict[str, Any]] = None, message: Optional[str] = None):
+
+    def __init__(
+        self, data: Optional[Dict[str, Any]] = None, message: Optional[str] = None
+    ):
         """
         Initialize successful result.
 
@@ -77,7 +79,7 @@ class SuccessResult(CommandResult):
         """
         self.data = data or {}
         self.message = message
-    
+
     def to_dict(self) -> Dict[str, Any]:
         """
         Converts result to dictionary for serialization.
@@ -91,7 +93,7 @@ class SuccessResult(CommandResult):
         if self.message:
             result["message"] = self.message
         return result
-    
+
     @classmethod
     def get_schema(cls) -> Dict[str, Any]:
         """
@@ -105,11 +107,11 @@ class SuccessResult(CommandResult):
             "properties": {
                 "success": {"type": "boolean"},
                 "data": {"type": "object"},
-                "message": {"type": "string"}
+                "message": {"type": "string"},
             },
-            "required": ["success"]
+            "required": ["success"],
         }
-    
+
     @classmethod
     def from_dict(cls, data: Dict[str, Any]) -> "SuccessResult":
         """
@@ -121,25 +123,19 @@ class SuccessResult(CommandResult):
         Returns:
             Successful result instance.
         """
-        return cls(
-            data=data.get("data"),
-            message=data.get("message")
-        )
+        return cls(data=data.get("data"), message=data.get("message"))
 
 
 class ErrorResult(CommandResult):
     """
     Base class for command results with error.
-    
+
     This class follows the JSON-RPC 2.0 error object format:
     https://www.jsonrpc.org/specification#error_object
     """
-    
+
     def __init__(
-        self,
-        message: str,
-        code: int = -32000,
-        details: Optional[Dict[str, Any]] = None
+        self, message: str, code: int = -32000, details: Optional[Dict[str, Any]] = None
     ):
         """
         Initialize error result.
@@ -153,7 +149,7 @@ class ErrorResult(CommandResult):
         self.error = message  # For backward compatibility with tests
         self.code = code
         self.details = details or {}
-    
+
     def to_dict(self) -> Dict[str, Any]:
         """
         Converts result to dictionary for serialization.
@@ -163,15 +159,12 @@ class ErrorResult(CommandResult):
         """
         result = {
             "success": False,
-            "error": {
-                "code": self.code,
-                "message": self.message
-            }
+            "error": {"code": self.code, "message": self.message},
         }
         if self.details:
             result["error"]["data"] = self.details
         return result
-    
+
     @classmethod
     def get_schema(cls) -> Dict[str, Any]:
         """
@@ -189,14 +182,14 @@ class ErrorResult(CommandResult):
                     "properties": {
                         "code": {"type": "integer"},
                         "message": {"type": "string"},
-                        "data": {"type": "object"}
+                        "data": {"type": "object"},
                     },
-                    "required": ["code", "message"]
-                }
+                    "required": ["code", "message"],
+                },
             },
-            "required": ["success", "error"]
+            "required": ["success", "error"],
         }
-    
+
     @classmethod
     def from_dict(cls, data: Dict[str, Any]) -> "ErrorResult":
         """
@@ -212,5 +205,5 @@ class ErrorResult(CommandResult):
         return cls(
             message=error.get("message", "Unknown error"),
             code=error.get("code", -32000),
-            details=error.get("data")
+            details=error.get("data"),
         )

mcp_proxy_adapter/commands/role_test_command.py

@@ -18,11 +18,11 @@ logger = logging.getLogger(__name__)
 
 class RoleTestCommandResult(SuccessResult):
     """Result for role test command."""
-    
+
     def __init__(self, user_role: str, permissions: list, action: str, allowed: bool):
         """
         Initialize role test result.
-        
+
         Args:
             user_role: User's role
             permissions: User's permissions
@@ -34,7 +34,7 @@ class RoleTestCommandResult(SuccessResult):
         self.permissions = permissions
         self.action = action
         self.allowed = allowed
-    
+
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dictionary."""
         return {
@@ -43,11 +43,11 @@ class RoleTestCommandResult(SuccessResult):
                 "user_role": self.user_role,
                 "permissions": self.permissions,
                 "action": self.action,
-                "allowed": self.allowed
+                "allowed": self.allowed,
             },
-            "message": f"Action '{self.action}' {'allowed' if self.allowed else 'denied'} for role '{self.user_role}'"
+            "message": f"Action '{self.action}' {'allowed' if self.allowed else 'denied'} for role '{self.user_role}'",
         }
-    
+
     @classmethod
     def get_schema(cls) -> Dict[str, Any]:
         """Get JSON schema."""
@@ -61,53 +61,53 @@ class RoleTestCommandResult(SuccessResult):
                         "user_role": {"type": "string"},
                         "permissions": {"type": "array", "items": {"type": "string"}},
                         "action": {"type": "string"},
-                        "allowed": {"type": "boolean"}
-                    }
+                        "allowed": {"type": "boolean"},
+                    },
                 },
-                "message": {"type": "string"}
-            }
+                "message": {"type": "string"},
+            },
         }
 
 
 class RoleTestCommand(Command):
     """Test role-based access control."""
-    
+
     name = "roletest"
     descr = "Test role-based access control"
     category = "security"
     author = "Vasiliy Zdanovskiy"
     email = "vasilyvz@gmail.com"
-    
+
     async def execute(self, **kwargs) -> RoleTestCommandResult:
         """
         Execute role test command.
-        
+
         Args:
             **kwargs: Command parameters including context
-            
+
         Returns:
             RoleTestCommandResult
         """
         # Extract parameters
         action = kwargs.get("action", "read")
         context = kwargs.get("context", {})
-        
+
         # Get user info from context
         user_role = "guest"  # Default
         permissions = ["read"]  # Default
-        
+
         if context:
             user_info = context.get("user", {})
             user_role = user_info.get("role", "guest")
             permissions = user_info.get("permissions", ["read"])
-        
+
         # Check if action is allowed
         allowed = self._check_permission(action, permissions)
-        
+
         logger.info(f"Role test: user={user_role}, action={action}, allowed={allowed}")
-        
+
         return RoleTestCommandResult(user_role, permissions, action, allowed)
-    
+
     @classmethod
     def get_schema(cls) -> Dict[str, Any]:
         """Get JSON schema for command parameters."""
@@ -117,26 +117,26 @@ class RoleTestCommand(Command):
                 "action": {
                     "type": "string",
                     "description": "Action to test",
-                    "default": "read"
+                    "default": "read",
                 }
             },
-            "additionalProperties": False
+            "additionalProperties": False,
         }
-    
+
     def _check_permission(self, action: str, permissions: list) -> bool:
         """
         Check if action is allowed for given permissions.
-        
+
         Args:
             action: Action to check
             permissions: User permissions
-            
+
         Returns:
             True if allowed, False otherwise
         """
         # Admin has all permissions
         if "*" in permissions:
             return True
-        
+
         # Check specific permission
         return action in permissions