feat: ✨ Support recursive validation (maybe, untested)

Author: ddanier

pydantic_async_validation/metaclasses.py

@@ -10,7 +10,7 @@
 )
 
 if TYPE_CHECKING:
-    from pydantic_async_validation.validators import Validator
+    from pydantic_async_validation.validators import ValidationInfo
 
 
 class AsyncValidationModelMetaclass(ModelMetaclass):
@@ -21,12 +21,12 @@ def __new__(
         namespace: dict[str, Any],
         **kwargs: Any,
     ) -> Any:
-        async_field_validators: List[Tuple[List[str], Validator]] = []
-        async_model_validators: List[Validator] = []
+        async_field_validators: List[Tuple[List[str], ValidationInfo]] = []
+        async_model_validators: List[ValidationInfo] = []
 
         async_field_validator_fields: Optional[List[str]]
-        async_field_validator_config: "Optional[Validator]"
-        async_model_validator_config: "Optional[Validator]"
+        async_field_validator_config: "Optional[ValidationInfo]"
+        async_model_validator_config: "Optional[ValidationInfo]"
 
         for base in bases:
             async_field_validators += getattr(

pydantic_async_validation/mixins.py

@@ -1,7 +1,7 @@
-from typing import ClassVar, List, Tuple
+from typing import ClassVar, List, Tuple, Union, cast
 
 import pydantic
-from pydantic_core import ErrorDetails, PydanticCustomError, ValidationError
+from pydantic_core import InitErrorDetails, PydanticCustomError, ValidationError
 
 from pydantic_async_validation.constants import (
     ASYNC_FIELD_VALIDATOR_CONFIG_KEY,
@@ -10,16 +10,17 @@
     ASYNC_MODEL_VALIDATORS_KEY,
 )
 from pydantic_async_validation.metaclasses import AsyncValidationModelMetaclass
-from pydantic_async_validation.validators import Validator
+from pydantic_async_validation.utils import prefix_errors
+from pydantic_async_validation.validators import ValidationInfo
 
 
 class AsyncValidationModelMixin(
     pydantic.BaseModel,
     metaclass=AsyncValidationModelMetaclass,
 ):
     # MUST match names defined in constants.py!
-    pydantic_model_async_field_validators: ClassVar[List[Tuple[List[str], Validator]]]
-    pydantic_model_async_model_validators: ClassVar[List[Validator]]
+    pydantic_model_async_field_validators: ClassVar[List[Tuple[List[str], ValidationInfo]]]
+    pydantic_model_async_model_validators: ClassVar[List[ValidationInfo]]
 
     async def model_async_validate(self) -> None:
         """
@@ -29,60 +30,99 @@ async def model_async_validate(self) -> None:
         collected and raised as a `ValidationError` exception.
         """
         field_names: list[str]
-        validator: Validator
+        field_validator: ValidationInfo
+        model_validator: ValidationInfo
 
         validation_errors = []
-        validators = getattr(self, ASYNC_FIELD_VALIDATORS_KEY, [])
-        root_validators = getattr(self, ASYNC_MODEL_VALIDATORS_KEY, [])
+        field_validators = getattr(self, ASYNC_FIELD_VALIDATORS_KEY, [])
+        model_validators = getattr(self, ASYNC_MODEL_VALIDATORS_KEY, [])
 
-        for validator_attr in validators:
-            field_names, validator = getattr(
-                validator_attr,
+        # Call all field validators
+        for field_validator_attr in field_validators:
+            field_names, field_validator = getattr(
+                field_validator_attr,
                 ASYNC_FIELD_VALIDATOR_CONFIG_KEY,
             )
             for field_name in field_names:
                 try:
-                    await validator.func(
+                    await field_validator.func(
                         self,
                         getattr(self, field_name, None),
                         field_name,
-                        validator,
+                        field_validator,
                     )
                 except (ValueError, TypeError, AssertionError) as o_O:
                     validation_errors.append(
-                        ErrorDetails(
-                            type=PydanticCustomError('value_error', str(o_O)),
-                            msg=str(o_O),
+                        InitErrorDetails(
+                            type=PydanticCustomError('value_error', str(o_O)),  # type: ignore
                             loc=(field_name,),
                             input=getattr(self, field_name, None),
                         ),
                     )
 
-        for validator_attr in root_validators:
-            validator = getattr(
-                validator_attr,
+        # Call all model validators
+        for model_validator_attr in model_validators:
+            model_validator = getattr(
+                model_validator_attr,
                 ASYNC_MODEL_VALIDATOR_CONFIG_KEY,
             )
             try:
-                await validator.func(
+                await model_validator.func(
                     self,
-                    validator,
+                    model_validator,
                 )
             except (ValueError, TypeError, AssertionError) as o_O:
                 validation_errors.append(
-                    ErrorDetails(
-                        type=PydanticCustomError('value_error', str(o_O)),
-                        msg=str(o_O),
+                    InitErrorDetails(
+                        type=PydanticCustomError('value_error', str(o_O)),  # type: ignore
                         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()
+        # Also call async validation on attribute values
+        async def extend_with_validation_errors_by(
+            prefix: Tuple[Union[int, str], ...],
+            instance: AsyncValidationModelMixin,
+        ) -> None:
+            try:
+                await instance.model_async_validate()
+            except ValidationError as O_o:
+                validation_errors.extend(
+                    prefix_errors(
+                        prefix,
+                        cast(
+                            List[InitErrorDetails],
+                            O_o.errors(),
+                        ),
+                    ),
+                )
+
+        for attribute_name, attribute_value in self.__dict__.items():
+            # Direct child instance
+            if isinstance(attribute_value, AsyncValidationModelMixin):
+                await extend_with_validation_errors_by(
+                    (attribute_name,),
+                    attribute_value,
+                )
+            # List of child instances
+            if isinstance(attribute_value, list):
+                for index, item in enumerate(attribute_value):
+                    if isinstance(item, AsyncValidationModelMixin):
+                        await extend_with_validation_errors_by(
+                            (attribute_name, index),
+                            item,
+                        )
+            # Dict of child instances
+            if isinstance(attribute_value, dict):
+                for key, item in attribute_value.items():
+                    if isinstance(item, AsyncValidationModelMixin):
+                        await extend_with_validation_errors_by(
+                            (attribute_name, key),
+                            item,
+                        )
 
+        # If some errors did occur, raise them as a ValidationError
         if len(validation_errors) > 0:
             raise ValidationError.from_exception_data(
                 self.__class__.__name__,

pydantic_async_validation/utils.py

@@ -1,8 +1,9 @@
 from functools import wraps
 from inspect import Signature, signature
-from typing import Callable
+from typing import Callable, List, Tuple, Union, cast
 
 from pydantic import PydanticUserError
+from pydantic_core import InitErrorDetails
 
 
 def make_generic_field_validator(validator_func: Callable) -> Callable:
@@ -143,3 +144,27 @@ def generic_model_validator_wrapper(
     return lambda self, config: validator_func(
         self, config=config,
     )
+
+
+def prefix_errors(
+    prefix: Tuple[Union[int, str], ...],
+    errors: List[InitErrorDetails],
+) -> List[InitErrorDetails]:
+    """
+    Extend all errors passed as list to include an additional prefix.
+
+    This is used to prefix errors occuring in child classes to include the parents
+    field details in the error locations.
+    """
+
+    return [
+        cast(
+            InitErrorDetails,
+            {
+                **error,
+                'loc': (*prefix, *error['loc']),
+            },
+        )
+        for error
+        in errors
+    ]

pydantic_async_validation/validators.py

@@ -1,5 +1,5 @@
 from types import FunctionType
-from typing import TYPE_CHECKING, Any, Callable, Optional, Tuple, Union
+from typing import TYPE_CHECKING, Any, Callable, Optional, Tuple
 
 from pydantic.errors import PydanticUserError
 
@@ -27,7 +27,7 @@
     ValidatorListDict = "dict[str, list[Validator]]"
 
 
-class Validator:
+class ValidationInfo:
     """Helper / data class to store validator information."""
 
     __slots__ = ('func', 'extra')
@@ -48,7 +48,7 @@ def async_field_validator(
     /,
     *additional_field_names: str,
     **extra: Any,
-) -> Callable[[Callable], classmethod]:
+) -> Callable[[Callable], Callable]:
     """
     Decorate methods on a model indicating that they should be used to validate data.
 
@@ -66,13 +66,13 @@ def async_field_validator(
 
     field_names: Tuple[str, ...] = __field_name, *additional_field_names
 
-    def dec(func: Callable) -> classmethod:
+    def dec(func: Callable) -> Callable:
         setattr(
             func,
             ASYNC_FIELD_VALIDATOR_CONFIG_KEY,
             (
                 field_names,
-                Validator(
+                ValidationInfo(
                     func=make_generic_field_validator(func),
                     extra=extra,
                 ),
@@ -85,19 +85,19 @@ def dec(func: Callable) -> classmethod:
 
 def async_model_validator(
     **extra: Any,
-) -> Union[classmethod, Callable[[Callable], classmethod]]:
+) -> Callable[[Callable], Callable]:
     """
     Decorate methods on a model indicating that they should be used to validate data.
 
     This decorator allows you to assign your validation
     function to the whole model (root validator).
     """
 
-    def dec(func: Callable) -> classmethod:
+    def dec(func: Callable) -> Callable:
         setattr(
             func,
             ASYNC_MODEL_VALIDATOR_CONFIG_KEY,
-            Validator(
+            ValidationInfo(
                 func=make_generic_model_validator(func),
                 extra=extra,
             ),