Merge pull request #124 from dapper91/dev

- request validator refactored. Validator is built once on method initialization to increase request handling performance.

Author: dapper91

CHANGELOG.rst

@@ -1,12 +1,10 @@
 Changelog
 =========
 
-1.14.0 (2025-04-08)
+1.15.0 (2025-05-18)
 -------------------
 
-- pydantic 2.11 compatibility.
-- request kwargs passed to a tracer.
-- pydantic validator model cached.
+- request validator refactored. Validator is built once on method initialization to increase request handling performance.
 
 
 1.13.0 (2025-02-15)

pjrpc/__about__.py

@@ -2,7 +2,7 @@
 __description__ = 'Extensible JSON-RPC library'
 __url__ = 'https://github.com/dapper91/pjrpc'
 
-__version__ = '1.14.0'
+__version__ = '1.15.0'
 
 __author__ = 'Dmitry Pershin'
 __email__ = '[email protected]'

pjrpc/server/dispatcher.py

@@ -51,13 +51,18 @@ def __init__(
 
         meta = utils.set_meta(method, method_name=self.name, context_name=context)
 
-        self.validator, self.validator_args = meta.get('validator', default_validator), meta.get('validator_args', {})
+        validator_factory: validators.BaseValidator = meta.get('validator', default_validator)
+        validator_args = meta.get('validator_args', {})
+
+        self.validator = validator_factory.build_method_validator(
+            method,
+            exclude=(self.context,) if self.context else (),
+            **validator_args,
+        )
 
     def bind(self, params: Optional['JsonRpcParams'], context: Optional[Any] = None) -> MethodType:
         method_args = []
-        method_kwargs = self.validator.validate_method(
-            self.method, params, exclude=(self.context,) if self.context else (), **self.validator_args,
-        )
+        method_kwargs = self.validator.validate_params(params)
 
         if self.context is not None:
             if self.positional:
@@ -99,16 +104,17 @@ def __init__(
         context: Optional[Any] = None,
         positional: bool = False,
     ):
-        super().__init__(getattr(view_cls, method_name), name or method_name, context, positional)
+        super().__init__(getattr(view_cls, method_name), name or method_name, 'self', positional)
+        self.view_context = context
 
         self.view_cls = view_cls
         self.method_name = method_name
 
     def bind(self, params: Optional['JsonRpcParams'], context: Optional[Any] = None) -> MethodType:
-        view = self.view_cls(context) if self.context else self.view_cls()
+        view = self.view_cls(context) if self.view_context else self.view_cls()
         method = getattr(view, self.method_name)
 
-        method_params = self.validator.validate_method(method, params, **self.validator_args)
+        method_params = self.validator.validate_params(params)
 
         return ft.partial(method, **method_params)
 

pjrpc/server/validators/__init__.py

@@ -2,10 +2,11 @@
 JSON-RPC method parameters validators.
 """
 
-from .base import BaseValidator, ExcludeFunc, ValidationError
+from .base import BaseMethodValidator, BaseValidator, ExcludeFunc, ValidationError
 
 __all__ = [
     'BaseValidator',
+    'BaseMethodValidator',
     'ExcludeFunc',
     'ValidationError',
 ]

pjrpc/server/validators/base.py

@@ -1,4 +1,3 @@
-import functools as ft
 import inspect
 from typing import Any, Dict, Iterable, List, Optional, Tuple
 
@@ -15,7 +14,7 @@ class ValidationError(Exception):
 
 class BaseValidator:
     """
-    Base method parameters validator. Uses :py:func:`inspect.signature` for validation.
+    Base method parameters validator factory. Uses :py:func:`inspect.signature` for validation.
 
     :param exclude_param: a function that decides if the parameters must be excluded
                           from validation (useful for dependency injection)
@@ -29,7 +28,7 @@ def validate(self, maybe_method: Optional[MethodType] = None, **kwargs: Any) ->
         Decorator marks a method the parameters of which to be validated when calling it using JSON-RPC protocol.
 
         :param maybe_method: method the parameters of which to be validated or ``None`` if called as @validate(...)
-        :param kwargs: validator arguments
+        :param kwargs: method validator arguments
         """
 
         def decorator(method: MethodType) -> MethodType:
@@ -43,28 +42,39 @@ def decorator(method: MethodType) -> MethodType:
         else:
             return decorator(maybe_method)
 
-    def validate_method(
-        self, method: MethodType, params: Optional['JsonRpcParams'], exclude: Iterable[str] = (), **kwargs: Any,
-    ) -> Dict[str, Any]:
+    def build_method_validator(
+            self,
+            method: MethodType,
+            exclude: Iterable[str] = (),
+            **kwargs: Any,
+    ) -> 'BaseMethodValidator':
+        return BaseMethodValidator(method, self._exclude_param, exclude)
+
+
+class BaseMethodValidator:
+    """
+    Base method parameters validator.
+    """
+
+    def __init__(self, method: MethodType, exclude_func: ExcludeFunc, exclude: Iterable[str] = ()):
+        self._method = method
+        self._signature = self._build_signature(method, exclude_func, tuple(exclude))
+
+    def validate_params(self, params: Optional['JsonRpcParams']) -> Dict[str, Any]:
         """
         Validates params against method signature.
 
-        :param method: method to validate parameters against
         :param params: parameters to be validated
-        :param exclude: parameter names to be excluded from validation
-        :param kwargs: additional validator arguments
 
         :raises: :py:class:`pjrpc.server.validators.ValidationError`
         :returns: bound method parameters
         """
 
-        signature = self.signature(method, tuple(exclude))
-        return self.bind(signature, params).arguments
+        return self._bind(params).arguments
 
-    def bind(self, signature: inspect.Signature, params: Optional['JsonRpcParams']) -> inspect.BoundArguments:
+    def _bind(self, params: Optional['JsonRpcParams']) -> inspect.BoundArguments:
         """
         Binds parameters to method.
-        :param signature: method to bind parameters to
         :param params: parameters to be bound
 
         :raises: ValidationError is parameters binding failed
@@ -75,12 +85,16 @@ def bind(self, signature: inspect.Signature, params: Optional['JsonRpcParams'])
         method_kwargs = params if isinstance(params, dict) else {}
 
         try:
-            return signature.bind(*method_args, **method_kwargs)
+            return self._signature.bind(*method_args, **method_kwargs)
         except TypeError as e:
             raise ValidationError(str(e)) from e
 
-    @ft.lru_cache(None)
-    def signature(self, method: MethodType, exclude: Tuple[str, ...]) -> inspect.Signature:
+    def _build_signature(
+            self,
+            method: MethodType,
+            exclude_func: ExcludeFunc,
+            exclude: Tuple[str, ...] = (),
+    ) -> inspect.Signature:
         """
         Returns method signature.
 
@@ -93,7 +107,7 @@ def signature(self, method: MethodType, exclude: Tuple[str, ...]) -> inspect.Sig
 
         method_parameters: List[inspect.Parameter] = []
         for param in signature.parameters.values():
-            if param.name not in exclude and not self._exclude_param(param.name, param.annotation, param.default):
+            if param.name not in exclude and not exclude_func(param.name, param.annotation, param.default):
                 method_parameters.append(param)
 
         return signature.replace(parameters=method_parameters)

pjrpc/server/validators/jsonschema.py

@@ -10,7 +10,7 @@
 
 class JsonSchemaValidator(base.BaseValidator):
     """
-    Parameters validator based on `jsonschema <https://python-jsonschema.readthedocs.io/en/stable/>`_ library.
+    Parameters validator factory based on `jsonschema <https://python-jsonschema.readthedocs.io/en/stable/>`_ library.
 
     :param kwargs: default jsonschema validator arguments
     :param exclude_param: a function that decides if the parameters must be excluded
@@ -20,27 +20,36 @@ class JsonSchemaValidator(base.BaseValidator):
     def __init__(self, exclude_param: Optional[ExcludeFunc] = None, **kwargs: Any):
         super().__init__(exclude_param=exclude_param)
         kwargs.setdefault('types', {'array': (list, tuple)})
-        self.default_kwargs = kwargs
+        self._default_kwargs = kwargs
 
-    def validate_method(
-        self, method: MethodType, params: Optional['JsonRpcParams'], exclude: Iterable[str] = (), **kwargs: Any,
-    ) -> Dict[str, Any]:
+    def build_method_validator(
+            self,
+            method: MethodType,
+            exclude: Iterable[str] = (),
+            **kwargs: Any,
+    ) -> 'JsonSchemaMethodValidator':
+        return JsonSchemaMethodValidator(method, self._exclude_param, exclude, **dict(self._default_kwargs, **kwargs))
+
+
+class JsonSchemaMethodValidator(base.BaseMethodValidator):
+    def __init__(self, method: MethodType, exclude_func: ExcludeFunc, exclude: Iterable[str] = (), **kwargs: Any):
+        super().__init__(method, exclude_func, exclude)
+        self._signature = self._build_signature(method, exclude_func, tuple(exclude))
+        self._validator_args = kwargs
+
+    def validate_params(self, params: Optional['JsonRpcParams']) -> Dict[str, Any]:
         """
         Validates params against method using ``pydantic`` validator.
 
-        :param method: method to validate parameters against
         :param params: parameters to be validated
-        :param exclude: parameter names to be excluded from validation
-        :param kwargs: jsonschema validator arguments
 
         :raises: :py:class:`pjrpc.server.validators.ValidationError`
         """
 
-        arguments = super().validate_method(method, params, exclude)
+        arguments = super().validate_params(params)
 
         try:
-            kwargs = {**self.default_kwargs, **kwargs}
-            jsonschema.validate(arguments, **kwargs)
+            jsonschema.validate(arguments, **self._validator_args)
         except jsonschema.ValidationError as e:
             raise base.ValidationError(str(e)) from e
 

pjrpc/server/validators/pydantic.py

@@ -1,18 +1,17 @@
-import functools as ft
 import inspect
-from typing import Any, Callable, Dict, Iterable, List, Optional, Type
+from typing import Any, Dict, Iterable, List, Optional, Type
 
 import pydantic
 
-from pjrpc.common.typedefs import JsonRpcParams
+from pjrpc.common.typedefs import JsonRpcParams, MethodType
 from pjrpc.server.typedefs import ExcludeFunc
 
 from . import base
 
 
 class PydanticValidator(base.BaseValidator):
     """
-    Parameters validator based on `pydantic <https://pydantic-docs.helpmanual.io/>`_ library.
+    Method parameters validator factory based on `pydantic <https://pydantic-docs.helpmanual.io/>`_ library.
     Uses python type annotations for parameters validation.
 
     :param coerce: if ``True`` returns converted (coerced) parameters according to parameter type annotation
@@ -30,36 +29,56 @@ def __init__(self, coerce: bool = True, exclude_param: Optional[ExcludeFunc] = N
         # https://pydantic-docs.helpmanual.io/usage/model_config/
         self._model_config = pydantic.ConfigDict(**config_args)  # type: ignore[typeddict-item]
 
-    def validate_method(
-        self, method: Callable[..., Any], params: Optional['JsonRpcParams'], exclude: Iterable[str] = (), **kwargs: Any,
-    ) -> Dict[str, Any]:
+    def build_method_validator(
+            self,
+            method: MethodType,
+            exclude: Iterable[str] = (),
+            **kwargs: Any,
+    ) -> 'PydanticMethodValidator':
+        return PydanticMethodValidator(method, self._exclude_param, exclude, self._coerce, self._model_config)
+
+
+class PydanticMethodValidator(base.BaseMethodValidator):
+    """
+    Pydantic method parameters validator based on `pydantic <https://pydantic-docs.helpmanual.io/>`_ library.
+    """
+
+    def __init__(
+            self,
+            method: MethodType,
+            exclude_func: ExcludeFunc,
+            exclude: Iterable[str],
+            coerce: bool,
+            model_config: pydantic.ConfigDict,
+    ):
+        super().__init__(method, exclude_func, exclude)
+        self._coerce = coerce
+        self._model_config = model_config
+        self._params_model = self._build_validation_model(method.__name__)
+
+    def validate_params(self, params: Optional['JsonRpcParams']) -> Dict[str, Any]:
         """
         Validates params against method using ``pydantic`` validator.
 
-        :param method: method to validate parameters against
         :param params: parameters to be validated
-        :param exclude: parameter names to be excluded from validation
 
         :returns: coerced parameters if `coerce` flag is ``True`` otherwise parameters as is
         :raises: ValidationError
         """
 
-        signature = self.signature(method, tuple(exclude))
-        params_model = self.build_validation_model(method.__name__, signature)
-        bound_params = self.bind(signature, params)
+        bound_params = self._bind(params)
         try:
-            obj = params_model(**bound_params.arguments)
+            obj = self._params_model(**bound_params.arguments)
         except pydantic.ValidationError as e:
             raise base.ValidationError(*e.errors()) from e
 
         return {attr: getattr(obj, attr) for attr in obj.model_fields} if self._coerce else bound_params.arguments
 
-    @ft.lru_cache(maxsize=None)
-    def build_validation_model(self, method_name: str, signature: inspect.Signature) -> Type[pydantic.BaseModel]:
-        schema = self.build_validation_schema(signature)
+    def _build_validation_model(self, method_name: str) -> Type[pydantic.BaseModel]:
+        schema = self._build_validation_schema(self._signature)
         return pydantic.create_model(method_name, **schema, __config__=self._model_config)
 
-    def build_validation_schema(self, signature: inspect.Signature) -> Dict[str, Any]:
+    def _build_validation_schema(self, signature: inspect.Signature) -> Dict[str, Any]:
         """
         Builds pydantic model based validation schema from method signature.
 

pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "pjrpc"
-version = "1.14.0"
+version = "1.15.0"
 description = "Extensible JSON-RPC library"
 authors = ["Dmitry Pershin <[email protected]>"]
 license = "Unlicense"

tests/server/test_base_validator.py

@@ -19,8 +19,10 @@
     ], indirect=['dyn_method'],
 )
 def test_validation_success(dyn_method, params):
-    validator = validators.BaseValidator()
-    validator.validate_method(dyn_method, params)
+    validator_factory = validators.BaseValidator()
+    validator = validator_factory.build_method_validator(dyn_method)
+
+    validator.validate_params(params)
 
 
 @pytest.mark.parametrize(
@@ -35,10 +37,11 @@ def test_validation_success(dyn_method, params):
     ], indirect=['dyn_method'],
 )
 def test_validation_error(dyn_method, params):
-    validator = validators.BaseValidator()
+    validator_factory = validators.BaseValidator()
+    validator = validator_factory.build_method_validator(dyn_method)
 
     with pytest.raises(validators.ValidationError):
-        validator.validate_method(dyn_method, params)
+        validator.validate_params(params)
 
 
 @pytest.mark.parametrize(
@@ -51,8 +54,10 @@ def test_validation_error(dyn_method, params):
     ], indirect=['dyn_method'],
 )
 def test_validation_exclude_success(dyn_method, exclude, params):
-    validator = validators.BaseValidator()
-    validator.validate_method(dyn_method, params, exclude=exclude)
+    validator_factory = validators.BaseValidator()
+    validator = validator_factory.build_method_validator(dyn_method, exclude=exclude)
+
+    validator.validate_params(params)
 
 
 @pytest.mark.parametrize(
@@ -63,7 +68,8 @@ def test_validation_exclude_success(dyn_method, exclude, params):
     ], indirect=['dyn_method'],
 )
 def test_validation_exclude_error(dyn_method, exclude, params):
-    validator = validators.BaseValidator()
+    validator_factory = validators.BaseValidator()
+    validator = validator_factory.build_method_validator(dyn_method, exclude=exclude)
 
     with pytest.raises(validators.ValidationError):
-        validator.validate_method(dyn_method, params, exclude=exclude)
+        validator.validate_params(params)