feat: ✨ Refactor validation to be a more straight forward implementation

Author: ddanier

pydantic_async_validation/__init__.py

@@ -1,3 +1,2 @@
-from pydantic_async_validation.exceptions import AsyncValidationError
 from pydantic_async_validation.mixins import AsyncValidationModelMixin
 from pydantic_async_validation.validators import async_field_validator, async_model_validator

pydantic_async_validation/exceptions.py

@@ -4,15 +4,16 @@
 from fastapi.exceptions import RequestValidationError
 from pydantic import ValidationError
 
-from pydantic_async_validation.exceptions import AsyncValidationError
-
 
 class ensure_request_validation_errors():
     """
-    Converter for ValidationErrors.
+    Converter for `ValidationError` to `RequestValidationError`.
 
-    This will convert any ValidationError's inside the called code
-    into RequestValidationErrors which will trigger HTTP 422 responses.
+    This will convert any ValidationError's inside the called code into
+    RequestValidationErrors which will trigger HTTP 422 responses in
+    FastAPI. This is useful for when you want to do extra validation in
+    your code that is not covered by FastAPI's normal request parameter
+    handling.
 
     Usage examples:
 
@@ -56,5 +57,3 @@ def __exit__(
 
         if isinstance(exc_value, ValidationError):
             raise RequestValidationError(errors=exc_value.errors())
-        if isinstance(exc_value, AsyncValidationError):
-            raise RequestValidationError(errors=exc_value.errors())

pydantic_async_validation/fastapi.py

@@ -41,7 +41,7 @@ def __new__(
             )
 
         for _attr_name, attr_value in namespace.items():
-            # Register all validators
+            # Register all field validators
             async_field_validator_fields, async_field_validator_config = getattr(
                 attr_value,
                 ASYNC_FIELD_VALIDATOR_CONFIG_KEY,
@@ -54,7 +54,7 @@ def __new__(
             ):
                 async_field_validators.append(attr_value)
 
-            # Register all root validators
+            # Register all model validators
             async_model_validator_config = getattr(
                 attr_value,
                 ASYNC_MODEL_VALIDATOR_CONFIG_KEY,

pydantic_async_validation/metaclasses.py

@@ -1,15 +1,14 @@
 from typing import ClassVar, List, Tuple
 
 import pydantic
-from pydantic_core import ErrorDetails
+from pydantic_core import ErrorDetails, PydanticCustomError, ValidationError
 
 from pydantic_async_validation.constants import (
     ASYNC_FIELD_VALIDATOR_CONFIG_KEY,
     ASYNC_FIELD_VALIDATORS_KEY,
     ASYNC_MODEL_VALIDATOR_CONFIG_KEY,
     ASYNC_MODEL_VALIDATORS_KEY,
 )
-from pydantic_async_validation.exceptions import AsyncValidationError
 from pydantic_async_validation.metaclasses import AsyncValidationModelMetaclass
 from pydantic_async_validation.validators import Validator
 
@@ -23,6 +22,12 @@ class AsyncValidationModelMixin(
     pydantic_model_async_model_validators: ClassVar[List[Validator]]
 
     async def model_async_validate(self) -> None:
+        """
+        Run async validation for the model instance.
+
+        Will call all async field and async model validators. All errors will be
+        collected and raised as a `ValidationError` exception.
+        """
         field_names: list[str]
         validator: Validator
 
@@ -38,16 +43,15 @@ async def model_async_validate(self) -> None:
             for field_name in field_names:
                 try:
                     await validator.func(
-                        self.__class__,
-                        getattr(self, field_name, None),
                         self,
+                        getattr(self, field_name, None),
                         field_name,
                         validator,
                     )
                 except (ValueError, TypeError, AssertionError) as o_O:
                     validation_errors.append(
                         ErrorDetails(
-                            type='value_error',
+                            type=PydanticCustomError('value_error', str(o_O)),
                             msg=str(o_O),
                             loc=(field_name,),
                             input=getattr(self, field_name, None),
@@ -59,22 +63,28 @@ async def model_async_validate(self) -> None:
                 validator_attr,
                 ASYNC_MODEL_VALIDATOR_CONFIG_KEY,
             )
-            if validator.skip_on_failure and validation_errors:
-                continue
             try:
-                await validator.func(self.__class__, self)
+                await validator.func(
+                    self,
+                    validator,
+                )
             except (ValueError, TypeError, AssertionError) as o_O:
                 validation_errors.append(
                     ErrorDetails(
-                        type='value_error',
+                        type=PydanticCustomError('value_error', str(o_O)),
                         msg=str(o_O),
-                        loc=(),
+                        loc=('__root__',),
                         input=self.__dict__,
                     ),
                 )
 
+        # TODO:
+        # for attribute_name, attribute_value in self.__dict__.items():
+        #     if isinstance(attribute_value, AsyncValidationModelMixin):
+        #         await attribute_value.model_async_validate()
+
         if len(validation_errors) > 0:
-            raise AsyncValidationError(
-                errors=validation_errors,
-                model=self.__class__,
+            raise ValidationError.from_exception_data(
+                self.__class__.__name__,
+                validation_errors,
             )

pydantic_async_validation/mixins.py

@@ -1,76 +1,40 @@
 from functools import wraps
-from inspect import Signature
+from inspect import Signature, signature
 from typing import Callable
 
-import pydantic
 from pydantic import PydanticUserError
 
-_ASYNC_VALIDATOR_FUNCS: set[str] = set()
 
-
-def prepare_validator(function: Callable, allow_reuse: bool = False) -> classmethod:
-    """
-    Return the function as classmethod and check for duplicate names.
-
-    Avoid validators with duplicated names since without this,
-    validators can be overwritten silently
-    which generally isn't the intended behaviour,
-    don't run in ipython (see #312) or if allow_reuse is False.
+def make_generic_field_validator(validator_func: Callable) -> Callable:
     """
-    f_cls: classmethod = (
-        function
-        if isinstance(function, classmethod)
-        else classmethod(function)
-    )
-    if not allow_reuse:
-        ref = f_cls.__func__.__module__ + '.' + f_cls.__func__.__qualname__
-        if ref in _ASYNC_VALIDATOR_FUNCS:
-            # TODO: Does this still make sense? pydantic v2 seems to now need this?
-            raise pydantic.PydanticUserError(
-                f'Duplicate validator function "{ref}"; if this is intended, '
-                f'set `allow_reuse=True`',
-                # TODO: Find correct code for this - if we keep this exception
-                code='validator-reuse',  # type: ignore
-            )
-        _ASYNC_VALIDATOR_FUNCS.add(ref)
-    return f_cls
-
-
-def make_generic_validator(validator: Callable) -> Callable:
+    Make a generic function which calls a field validator with the right arguments.
     """
-    Make a generic function which calls a validator with the right arguments.
-
-    Unfortunately other approaches
-    (eg. return a partial of a function that builds the arguments) is slow,
-    hence this laborious way of doing things.
 
-    It's done like this so validators don't all need **kwargs in
-    their signature, eg. any combination of
-    the arguments "values", "fields" and/or "config" are permitted.
-    """
-    from inspect import signature  # noqa
-
-    sig = signature(validator)
+    sig = signature(validator_func)
     args = list(sig.parameters.keys())
     first_arg = args.pop(0)
-    if first_arg == 'self':
+    if first_arg == 'cls':
         raise PydanticUserError(
-            f'Invalid signature for validator {validator}: {sig},'
-            f'"self" not permitted as first argument, '
-            f'should be: (cls, value, instance, config, field), '
-            f'"instance", "config" and "field" are all optional.',
+            f'Invalid signature for validator {validator_func}: {sig},'
+            f'"cls" not permitted as first argument, '
+            f'should be: (self, value, field, config), '
+            f'"field" and "config" are all optional.',
             code='validator-signature',
         )
-    return wraps(validator)(
-        generic_validator_cls(validator, sig, set(args[1:])),
+    return wraps(validator_func)(
+        generic_field_validator_wrapper(
+            validator_func,
+            sig,
+            set(args[1:]),
+        ),
     )
 
 
-all_kwargs = {'instance', 'field', 'config'}
+all_field_validator_kwargs = {'field', 'validator'}
 
 
-def generic_validator_cls(
-    validator: Callable,
+def generic_field_validator_wrapper(
+    validator_func: Callable,
     sig: 'Signature',
     args: set[str],
 ) -> Callable:
@@ -83,47 +47,99 @@ def generic_validator_cls(
         has_kwargs = True
         args -= {'kwargs'}
 
-    if not args.issubset(all_kwargs):
+    if not args.issubset(all_field_validator_kwargs):
         raise PydanticUserError( # noqa
-            f'Invalid signature for validator {validator}: {sig}, '
+            f'Invalid signature for validator {validator_func}: {sig}, '
             f'should be: '
-            f'(cls, value, instance, config, field), '
-            f'"instance", "config" and "field" are all optional.',
+            f'(self, value, field, config), '
+            f'"field" and "config" are all optional.',
             code='validator-signature',
         )
 
     if has_kwargs:
-        return lambda cls, v, instance, field, config: validator(
-            cls, v, instance=instance, field=field, config=config,
+        return lambda self, v, field, config: validator_func(
+            self, v, field=field, config=config,
         )
     if args == set():
-        return lambda cls, v, instance, field, config: validator(cls, v)
-    if args == {'instance'}:
-        return lambda cls, v, instance, field, config: validator(
-            cls, v, instance=instance,
+        return lambda self, v, field, config: validator_func(
+            self, v,
         )
     if args == {'field'}:
-        return lambda cls, v, instance, field, config: validator(
-            cls, v, field=field,
+        return lambda self, v, field, config: validator_func(
+            self, v, field=field,
         )
     if args == {'config'}:
-        return lambda cls, v, instance, field, config: validator(
-            cls, v, config=config,
+        return lambda self, v, field, config: validator_func(
+            self, v, config=config,
         )
-    if args == {'instance', 'field'}:
-        return lambda cls, v, instance, field, config: validator(
-            cls, v, instance=instance, field=field,
+
+    # args == {'field', 'validator'}
+    return lambda self, v, field, config: validator_func(
+        self, v, field=field, config=config,
+    )
+
+
+def make_generic_model_validator(validator_func: Callable) -> Callable:
+    """
+    Make a generic function which calls a model validator with the right arguments.
+    """
+
+    sig = signature(validator_func)
+    args = list(sig.parameters.keys())
+    first_arg = args.pop(0)
+    if first_arg == 'cls':
+        raise PydanticUserError(
+            f'Invalid signature for validator {validator_func}: {sig},'
+            f'"cls" not permitted as first argument, '
+            f'should be: (self, config), '
+            f'"config" is optional.',
+            code='validator-signature',
+        )
+    return wraps(validator_func)(
+        generic_model_validator_wrapper(
+            validator_func,
+            sig,
+            set(args[1:]),
+        ),
+    )
+
+
+all_model_validator_kwargs = {'validator'}
+
+
+def generic_model_validator_wrapper(
+    validator_func: Callable,
+    sig: 'Signature',
+    args: set[str],
+) -> Callable:
+    """
+    Return a helper function to wrap a method to be called with its defined parameters.
+    """
+    # assume the first argument is value
+    has_kwargs = False
+    if 'kwargs' in args:
+        has_kwargs = True
+        args -= {'kwargs'}
+
+    if not args.issubset(all_model_validator_kwargs):
+        raise PydanticUserError( # noqa
+            f'Invalid signature for validator {validator_func}: {sig}, '
+            f'should be: '
+            f'(self, config), '
+            f'"config" is optional.',
+            code='validator-signature',
         )
-    if args == {'instance', 'config'}:
-        return lambda cls, v, instance, field, config: validator(
-            cls, v, instance=instance, config=config,
+
+    if has_kwargs:
+        return lambda self, config: validator_func(
+            self, config=config,
         )
-    if args == {'field', 'config'}:
-        return lambda cls, v, instance, field, config: validator(
-            cls, v, field=field, config=config,
+    if args == set():
+        return lambda self, config: validator_func(
+            self,
         )
 
-    # args == {'instance', 'field', 'config'}
-    return lambda cls, v, instance, field, config: validator(
-        cls, v, instance=instance, field=field, config=config,
+    # args == {'validator'}
+    return lambda self, config: validator_func(
+        self, config=config,
     )