chore: ♻️ Ensure typing details are all setup correctly

Author: ddanier

pydantic_async_validation/metaclasses.py

@@ -1,4 +1,4 @@
-from typing import TYPE_CHECKING, Any, Optional
+from typing import TYPE_CHECKING, Any, List, Optional, Tuple
 
 from pydantic._internal._model_construction import ModelMetaclass  # noqa
 
@@ -21,8 +21,12 @@ def __new__(
         namespace: dict[str, Any],
         **kwargs: Any,
     ) -> Any:
-        async_field_validators = []
-        async_model_validators = []
+        async_field_validators: List[Tuple[List[str], Validator]] = []
+        async_model_validators: List[Validator] = []
+
+        async_field_validator_fields: Optional[List[str]]
+        async_field_validator_config: "Optional[Validator]"
+        async_model_validator_config: "Optional[Validator]"
 
         for base in bases:
             async_field_validators += getattr(
@@ -37,23 +41,21 @@ def __new__(
             )
 
         for _attr_name, attr_value in namespace.items():
-            async_model_validator_config: "Optional[Validator]"
-
             # Register all validators
-            async_field_validator_fields, async_model_validator_config = getattr(
+            async_field_validator_fields, async_field_validator_config = getattr(
                 attr_value,
                 ASYNC_FIELD_VALIDATOR_CONFIG_KEY,
                 (None, None),
             )
             if (
                 async_field_validator_fields is not None
-                and async_model_validator_config is not None
-                and callable(async_model_validator_config.func)
+                and async_field_validator_config is not None
+                and callable(async_field_validator_config.func)
             ):
                 async_field_validators.append(attr_value)
 
             # Register all root validators
-            async_model_validator_config: "Optional[Validator]" = getattr(
+            async_model_validator_config = getattr(
                 attr_value,
                 ASYNC_MODEL_VALIDATOR_CONFIG_KEY,
                 None,

pydantic_async_validation/mixins.py

@@ -23,38 +23,39 @@ class AsyncValidationModelMixin(
     pydantic_model_async_model_validators: ClassVar[List[Validator]]
 
     async def model_async_validate(self) -> None:
+        field_names: list[str]
+        validator: Validator
+
         validation_errors = []
         validators = getattr(self, ASYNC_FIELD_VALIDATORS_KEY, [])
         root_validators = getattr(self, ASYNC_MODEL_VALIDATORS_KEY, [])
 
         for validator_attr in validators:
-            fields: list[str]
-            validator: Validator
-            fields, validator = getattr(
+            field_names, validator = getattr(
                 validator_attr,
                 ASYNC_FIELD_VALIDATOR_CONFIG_KEY,
             )
-            for field in fields:
+            for field_name in field_names:
                 try:
                     await validator.func(
                         self.__class__,
-                        getattr(self, field, None),
+                        getattr(self, field_name, None),
                         self,
-                        field,
+                        field_name,
                         validator,
                     )
                 except (ValueError, TypeError, AssertionError) as o_O:
                     validation_errors.append(
                         ErrorDetails(
                             type='value_error',
                             msg=str(o_O),
-                            loc=(field,),
-                            input=getattr(self, field, None),
+                            loc=(field_name,),
+                            input=getattr(self, field_name, None),
                         ),
                     )
 
         for validator_attr in root_validators:
-            validator: Validator = getattr(
+            validator = getattr(
                 validator_attr,
                 ASYNC_MODEL_VALIDATOR_CONFIG_KEY,
             )

pydantic_async_validation/utils.py

@@ -17,17 +17,20 @@ def prepare_validator(function: Callable, allow_reuse: bool = False) -> classmet
     which generally isn't the intended behaviour,
     don't run in ipython (see #312) or if allow_reuse is False.
     """
-    f_cls = (
+    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:
-            raise pydantic.ConfigError(
+            # 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

pydantic_async_validation/validators.py

@@ -1,5 +1,5 @@
 from types import FunctionType
-from typing import TYPE_CHECKING, Any, Callable, Optional, Union
+from typing import TYPE_CHECKING, Any, Callable, Optional, Tuple, Union
 
 from pydantic.errors import PydanticUserError
 
@@ -24,7 +24,6 @@ def __init__(
 if TYPE_CHECKING:
     from inspect import Signature  # noqa
 
-    from pydantic.fields import ModelField  # noqa
     from pydantic.main import BaseConfig  # noqa
     from pydantic.types import ModelOrDc  # noqa
 
@@ -33,7 +32,7 @@ def __init__(
             Optional[ModelOrDc],
             Any,
             dict[str, Any],
-            ModelField,
+            str,
             type[BaseConfig],
         ],
         Any,
@@ -44,9 +43,9 @@ def __init__(
 
 
 def async_field_validator(
-    __field: str,
+    __field_name: str,
     /,
-    *additional_fields: str,
+    *additional_field_names: str,
     allow_reuse: bool = False,
 ) -> Callable[[Callable], classmethod]:
     """
@@ -56,23 +55,23 @@ def async_field_validator(
     function to a list of fields.
     """
 
-    if isinstance(__field, FunctionType):
+    if isinstance(__field_name, FunctionType):
         raise PydanticUserError(
             "validators should be used with fields and keyword arguments, "
             "not bare. "
             "E.g. usage should be `@async_field_validator('<field_name>', ...)`",
             code='validator-instance-method',
         )
 
-    fields = __field, *additional_fields
+    field_names: Tuple[str, ...] = __field_name, *additional_field_names
 
     def dec(func: Callable) -> classmethod:
         f_cls = prepare_validator(func, allow_reuse)
         setattr(
             f_cls,
             ASYNC_FIELD_VALIDATOR_CONFIG_KEY,
             (
-                fields,
+                field_names,
                 Validator(
                     func=make_generic_validator(f_cls.__func__),
                 ),