added changelog and refactor

Author: CosmoV

docs/changelog.rst

@@ -2,6 +2,21 @@ Changelog
 #########
 
 
+**2.3.1**
+*********
+
+Pydantic validators inheritance fix
+====================================
+
+* fixed bag with schema validators passthrough `#45 <https://github.com/mts-ai/FastAPI-JSONAPI/pull/45>`_
+
+Authors
+"""""""
+
+* `@CosmoV`_
+* `@mahenzon`_
+
+
 **2.3.0**
 *********
 

fastapi_jsonapi/schema_builder.py

@@ -1,5 +1,4 @@
 """JSON API schemas builder class."""
-from copy import deepcopy
 from dataclasses import dataclass
 from typing import (
     Any,
@@ -8,27 +7,16 @@
     Iterable,
     List,
     Optional,
-    Set,
     Tuple,
     Type,
     TypeVar,
     Union,
 )
 
 import pydantic
-from pydantic import (
-    BaseConfig,
-    root_validator,
-    validator,
-)
+from pydantic import BaseConfig
 from pydantic import BaseModel as PydanticBaseModel
-from pydantic.class_validators import (
-    extract_root_validators,
-    extract_validators,
-    inherit_validators,
-)
-from pydantic.fields import FieldInfo, ModelField, Validator
-from pydantic.utils import unique_list
+from pydantic.fields import FieldInfo, ModelField
 
 from fastapi_jsonapi.data_typing import TypeSchema
 from fastapi_jsonapi.schema import (
@@ -45,6 +33,10 @@
 )
 from fastapi_jsonapi.schema_base import BaseModel, Field, RelationshipInfo, registry
 from fastapi_jsonapi.splitter import SPLIT_REL
+from fastapi_jsonapi.validation_utils import (
+    extract_field_validators,
+    extract_validators,
+)
 
 JSON_API_RESPONSE_TYPE = Dict[Union[int, str], Dict[str, Any]]
 
@@ -301,7 +293,7 @@ def _get_info_from_schema_for_building(
                 # works both for to-one and to-many
                 included_schemas.append((name, field.type_, relationship.resource_type))
             elif name == "id":
-                id_validators = self._extract_field_validators(
+                id_validators = extract_field_validators(
                     schema,
                     include_for_field_names={"id"},
                 )
@@ -323,7 +315,7 @@ class ConfigOrmMode(BaseConfig):
             f"{base_name}AttributesJSONAPI",
             **attributes_schema_fields,
             __config__=ConfigOrmMode,
-            __validators__=self._extract_validators(schema, exclude_for_field_names={"id"}),
+            __validators__=extract_validators(schema, exclude_for_field_names={"id"}),
         )
 
         relationships_schema = pydantic.create_model(
@@ -391,110 +383,6 @@ def create_relationship_data_schema(
         self.relationship_schema_cache[cache_key] = relationship_data_schema
         return relationship_data_schema
 
-    def _extract_root_validators(self, model: Type[BaseModel]) -> Dict[str, Callable]:
-        pre_rv_new, post_rv_new = extract_root_validators(model.__dict__)
-        pre_root_validators = unique_list(
-            model.__pre_root_validators__ + pre_rv_new,
-            name_factory=lambda v: v.__name__,
-        )
-        post_root_validators = unique_list(
-            model.__post_root_validators__ + post_rv_new,
-            name_factory=lambda skip_on_failure_and_v: skip_on_failure_and_v[1].__name__,
-        )
-
-        result_validators = {}
-
-        for validator_func in pre_root_validators:
-            result_validators[validator_func.__name__] = root_validator(
-                pre=True,
-                allow_reuse=True,
-            )(validator_func)
-
-        for skip_on_failure, validator_func in post_root_validators:
-            result_validators[validator_func.__name__] = root_validator(
-                allow_reuse=True,
-                skip_on_failure=skip_on_failure,
-            )(validator_func)
-
-        return result_validators
-
-    def _deduplicate_field_validators(self, validators: dict) -> dict:
-        result_validators = {}
-
-        for field_name, field_validators in validators.items():
-            result_validators[field_name] = list(
-                {
-                    # override in definition order
-                    field_validator.func.__name__: field_validator
-                    for field_validator in field_validators
-                }.values(),
-            )
-
-        return result_validators
-
-    def _extract_field_validators(
-        self,
-        model: Type[BaseModel],
-        *,
-        include_for_field_names: Set[str] = None,
-        exclude_for_field_names: Set[str] = None,
-    ):
-        validators = inherit_validators(
-            extract_validators(model.__dict__),
-            deepcopy(model.__validators__),
-        )
-        validators = self._deduplicate_field_validators(validators)
-        validator_origin_param_keys = (
-            "pre",
-            "each_item",
-            "always",
-            "check_fields",
-        )
-
-        exclude_for_field_names = exclude_for_field_names or set()
-
-        if include_for_field_names and exclude_for_field_names:
-            exclude_for_field_names = include_for_field_names.difference(
-                exclude_for_field_names,
-            )
-
-        result_validators = {}
-        for field_name, field_validators in validators.items():
-            if field_name in exclude_for_field_names:
-                continue
-
-            if include_for_field_names and field_name not in include_for_field_names:
-                continue
-
-            field_validator: Validator
-            for field_validator in field_validators:
-                validator_name = f"{field_name}_{field_validator.func.__name__}_validator"
-                validator_params = {
-                    # copy validator params
-                    param_key: getattr(field_validator, param_key)
-                    for param_key in validator_origin_param_keys
-                }
-                result_validators[validator_name] = validator(
-                    field_name,
-                    **validator_params,
-                    allow_reuse=True,
-                )(field_validator.func)
-
-        return result_validators
-
-    def _extract_validators(
-        self,
-        model: Type[BaseModel],
-        exclude_for_field_names: Set[str] = None,
-    ) -> Dict[str, Callable]:
-        return {
-            **self._extract_field_validators(
-                model,
-                exclude_for_field_names=exclude_for_field_names,
-            ),
-            **self._extract_root_validators(model),
-        }
-
     def _build_jsonapi_object(
         self,
         base_name: str,

fastapi_jsonapi/validation_utils.py

@@ -0,0 +1,123 @@
+from copy import deepcopy
+from typing import (
+    Callable,
+    Dict,
+    Set,
+    Type,
+)
+
+from pydantic import (
+    class_validators,
+    root_validator,
+    validator,
+)
+from pydantic.fields import Validator
+from pydantic.utils import unique_list
+
+from fastapi_jsonapi.schema_base import BaseModel
+
+
+def extract_root_validators(model: Type[BaseModel]) -> Dict[str, Callable]:
+    pre_rv_new, post_rv_new = class_validators.extract_root_validators(model.__dict__)
+    pre_root_validators = unique_list(
+        model.__pre_root_validators__ + pre_rv_new,
+        name_factory=lambda v: v.__name__,
+    )
+    post_root_validators = unique_list(
+        model.__post_root_validators__ + post_rv_new,
+        name_factory=lambda skip_on_failure_and_v: skip_on_failure_and_v[1].__name__,
+    )
+
+    result_validators = {}
+
+    for validator_func in pre_root_validators:
+        result_validators[validator_func.__name__] = root_validator(
+            pre=True,
+            allow_reuse=True,
+        )(validator_func)
+
+    for skip_on_failure, validator_func in post_root_validators:
+        result_validators[validator_func.__name__] = root_validator(
+            allow_reuse=True,
+            skip_on_failure=skip_on_failure,
+        )(validator_func)
+
+    return result_validators
+
+
+def _deduplicate_field_validators(validators: Dict) -> Dict:
+    result_validators = {}
+
+    for field_name, field_validators in validators.items():
+        result_validators[field_name] = list(
+            {
+                # override in definition order
+                field_validator.func.__name__: field_validator
+                for field_validator in field_validators
+            }.values(),
+        )
+
+    return result_validators
+
+
+def extract_field_validators(
+    model: Type[BaseModel],
+    *,
+    include_for_field_names: Set[str] = None,
+    exclude_for_field_names: Set[str] = None,
+):
+    validators = class_validators.inherit_validators(
+        class_validators.extract_validators(model.__dict__),
+        deepcopy(model.__validators__),
+    )
+    validators = _deduplicate_field_validators(validators)
+    validator_origin_param_keys = (
+        "pre",
+        "each_item",
+        "always",
+        "check_fields",
+    )
+
+    exclude_for_field_names = exclude_for_field_names or set()
+
+    if include_for_field_names and exclude_for_field_names:
+        exclude_for_field_names = include_for_field_names.difference(
+            exclude_for_field_names,
+        )
+
+    result_validators = {}
+    for field_name, field_validators in validators.items():
+        if field_name in exclude_for_field_names:
+            continue
+
+        if include_for_field_names and field_name not in include_for_field_names:
+            continue
+
+        field_validator: Validator
+        for field_validator in field_validators:
+            validator_name = f"{field_name}_{field_validator.func.__name__}_validator"
+            validator_params = {
+                # copy validator params
+                param_key: getattr(field_validator, param_key)
+                for param_key in validator_origin_param_keys
+            }
+            result_validators[validator_name] = validator(
+                field_name,
+                **validator_params,
+                allow_reuse=True,
+            )(field_validator.func)
+
+    return result_validators
+
+
+def extract_validators(
+    model: Type[BaseModel],
+    exclude_for_field_names: Set[str] = None,
+) -> Dict[str, Callable]:
+    return {
+        **extract_field_validators(
+            model,
+            exclude_for_field_names=exclude_for_field_names,
+        ),
+        **extract_root_validators(model),
+    }