cadwyn 3.3.4__tar.gz → 3.4.0__tar.gz

{cadwyn-3.3.4 → cadwyn-3.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cadwyn
-Version: 3.3.4
+Version: 3.4.0
 Summary: Production-ready community-driven modern Stripe-like API versioning in FastAPI
 Home-page: https://github.com/zmievsa/cadwyn
 License: MIT

{cadwyn-3.3.4 → cadwyn-3.4.0}/cadwyn/_compat.py

@@ -3,16 +3,19 @@ import dataclasses
 import inspect
 from typing import Any, TypeAlias
 
+import pydantic
 from fastapi._compat import ModelField as FastAPIModelField
 from pydantic import BaseModel, Field
 
 ModelField: TypeAlias = Any  # pyright: ignore[reportGeneralTypeIssues]
-Undefined: TypeAlias = Any
+PydanticUndefined: TypeAlias = Any
+VALIDATOR_CONFIG_KEY = "__validators__"
 
 try:
     PYDANTIC_V2 = False
 
-    from pydantic.fields import FieldInfo, ModelField, Undefined  # pyright: ignore # noqa: PGH003
+    from pydantic.fields import FieldInfo, ModelField  # pyright: ignore # noqa: PGH003
+    from pydantic.fields import Undefined as PydanticUndefined  # pyright: ignore # noqa: PGH003
 
     _all_field_arg_names = []
     EXTRA_FIELD_NAME = "extra"
@@ -20,10 +23,9 @@ except ImportError:
     PYDANTIC_V2 = True
 
     from pydantic.fields import FieldInfo
-    from pydantic_core import PydanticUndefined
+    from pydantic_core import PydanticUndefined  # pyright: ignore # noqa: PGH003
 
     ModelField: TypeAlias = FieldInfo  # pyright: ignore # noqa: PGH003
-    Undefined = PydanticUndefined  # pyright: ignore # noqa: PGH003
     _all_field_arg_names = sorted(
         [
             name
@@ -38,38 +40,34 @@ _empty_field_info = Field()
 dict_of_empty_field_info = {k: getattr(_empty_field_info, k) for k in FieldInfo.__slots__}
 
 
-def is_pydantic_constrained_type(value: object):
+def is_pydantic_1_constrained_type(value: object):
+    """This method only works for pydanticV1. It is always False in PydanticV2"""
     return isinstance(value, type) and value.__name__.startswith("Constrained") and value.__name__.endswith("Value")
 
 
-def get_attrs_that_are_not_from_field_and_that_are_from_field(value: type):
-    parent_public_attrs = {k: v for k, v in value.mro()[1].__dict__.items() if not k.startswith("_")}
-    value_private_attrs = {k: v for k, v in value.__dict__.items() if not k.startswith("_")}
-    attrs_in_value_different_from_parent = {
-        k: v for k, v in value_private_attrs.items() if k in parent_public_attrs and parent_public_attrs[k] != v
-    }
-    attrs_in_value_different_from_parent_that_are_not_in_field_def = {
-        k: v for k, v in attrs_in_value_different_from_parent.items() if k not in dict_of_empty_field_info
-    }
-    attrs_in_value_different_from_parent_that_are_in_field_def = {
-        k: v for k, v in attrs_in_value_different_from_parent.items() if k in dict_of_empty_field_info
-    }
-
-    return (
-        attrs_in_value_different_from_parent_that_are_not_in_field_def,
-        attrs_in_value_different_from_parent_that_are_in_field_def,
-    )
+def is_constrained_type(value: object):
+    if PYDANTIC_V2:
+        import annotated_types
+
+        return isinstance(value, annotated_types.Len | annotated_types.Interval | pydantic.StringConstraints)
+
+    else:
+        return is_pydantic_1_constrained_type(value)
 
 
 @dataclasses.dataclass(slots=True)
 class PydanticFieldWrapper:
+    """We DO NOT maintain field.metadata at all"""
+
     annotation: Any
 
     init_model_field: dataclasses.InitVar[ModelField]  # pyright: ignore[reportGeneralTypeIssues]
     field_info: FieldInfo = dataclasses.field(init=False)
 
     annotation_ast: ast.expr | None = None
-    field_ast: ast.expr | None = None
+    # In the expressions "foo: str | None = None" and "foo: str | None = Field(default=None)"
+    # the value_ast is "None" and "Field(default=None)" respectively
+    value_ast: ast.expr | None = None
 
     def __post_init__(self, init_model_field: ModelField):  # pyright: ignore[reportGeneralTypeIssues]
         if isinstance(init_model_field, FieldInfo):
@@ -77,20 +75,18 @@ class PydanticFieldWrapper:
         else:
             self.field_info = init_model_field.field_info
 
-    def get_annotation_for_rendering(self):
-        if self.annotation_ast:
-            return self.annotation_ast
-        else:
-            return self.annotation
-
     def update_attribute(self, *, name: str, value: Any):
         if PYDANTIC_V2:
-            if name in FieldInfo.metadata_lookup:
-                self.field_info.metadata.extend(FieldInfo._collect_metadata({name: value}))
             self.field_info._attributes_set[name] = value
         else:
             setattr(self.field_info, name, value)
 
+    def delete_attribute(self, *, name: str) -> None:
+        if PYDANTIC_V2:
+            self.field_info._attributes_set.pop(name)
+        else:
+            setattr(self.field_info, name, PydanticUndefined)
+
     @property
     def passed_field_attributes(self):
         if PYDANTIC_V2:

{cadwyn-3.3.4 → cadwyn-3.4.0}/cadwyn/codegen/_asts.py

@@ -2,6 +2,7 @@ import ast
 import inspect
 import re
 from collections.abc import Callable
+from dataclasses import dataclass
 from enum import Enum, auto
 from pathlib import Path
 from types import GenericAlias, LambdaType, ModuleType, NoneType
@@ -15,8 +16,7 @@ from typing import (  # noqa: UP035
 
 from cadwyn._compat import (
     PYDANTIC_V2,
-    get_attrs_that_are_not_from_field_and_that_are_from_field,
-    is_pydantic_constrained_type,
+    is_pydantic_1_constrained_type,
 )
 from cadwyn._package_utils import (
     get_absolute_python_path_of_import,
@@ -108,29 +108,22 @@ def transform_none(_: NoneType) -> Any:
 
 def transform_type(value: type) -> Any:
     # This is a hack for pydantic's Constrained types
-    if is_pydantic_constrained_type(value):
-        if get_attrs_that_are_not_from_field_and_that_are_from_field(value)[0]:
-            parent = value.mro()[1]
-            snake_case = _RE_CAMEL_TO_SNAKE.sub("_", value.__name__)
-            cls_name = "con" + "".join(snake_case.split("_")[1:-1])
-            return (
-                cls_name.lower()
-                + "("
-                + ", ".join(
-                    [
-                        f"{key}={get_fancy_repr(val)}"
-                        for key, val in value.__dict__.items()
-                        if not key.startswith("_") and val is not None and val != parent.__dict__[key]
-                    ],
-                )
-                + ")"
+    if is_pydantic_1_constrained_type(value):
+        parent = value.mro()[1]
+        snake_case = _RE_CAMEL_TO_SNAKE.sub("_", value.__name__)
+        cls_name = "con" + "".join(snake_case.split("_")[1:-1])
+        return (
+            cls_name.lower()
+            + "("
+            + ", ".join(
+                [
+                    f"{key}={get_fancy_repr(val)}"
+                    for key, val in value.__dict__.items()
+                    if not key.startswith("_") and val is not None and val != parent.__dict__[key]
+                ],
             )
-        else:
-            # In pydantic V1:
-            # MRO of constr looks like: [ConstrainedStrValue, pydantic.types.ConstrainedStr, str, object]
-            #                                                                                -2     -1
-            #                                                                                ^^^
-            value = value.mro()[-2]
+            + ")"
+        )
 
     return value.__name__
 
@@ -230,11 +223,17 @@ def add_keyword_to_call(attr_name: str, attr_value: Any, call: ast.Call):
         call.keywords.append(new_keyword)
 
 
+def delete_keyword_from_call(attr_name: str, call: ast.Call):
+    for i, keyword in enumerate(call.keywords):  # pragma: no branch
+        if keyword.arg == attr_name:
+            call.keywords.pop(i)
+            break
+
+
 def get_ast_keyword_from_argument_name_and_value(name: str, value: Any):
-    return ast.keyword(
-        arg=name,
-        value=ast.parse(get_fancy_repr(value), mode="eval").body,
-    )
+    if not isinstance(value, ast.AST):
+        value = ast.parse(get_fancy_repr(value), mode="eval").body
+    return ast.keyword(arg=name, value=value)
 
 
 def pop_docstring_from_cls_body(cls_body: list[ast.stmt]) -> list[ast.stmt]:
@@ -247,3 +246,31 @@ def pop_docstring_from_cls_body(cls_body: list[ast.stmt]) -> list[ast.stmt]:
         return [cls_body.pop(0)]
     else:
         return []
+
+
+@dataclass(slots=True)
+class _ValidatorWrapper:
+    func_ast: ast.FunctionDef
+    index_of_validator_decorator: int
+    field_names: set[str | ast.expr] | None
+    is_deleted: bool = False
+
+
+def get_validator_info_or_none(method: ast.FunctionDef) -> _ValidatorWrapper | None:
+    for index, decorator in enumerate(method.decorator_list):
+        # The cases we handle here:
+        # * `Name(id="root_validator")`
+        # * `Call(func=Name(id="validator"), args=[Constant(value="foo")])`
+        # * `Attribute(value=Name(id="pydantic"), attr="root_validator")`
+        # * `Call(func=Attribute(value=Name(id="pydantic"), attr="root_validator"), args=[])`
+
+        if isinstance(decorator, ast.Call) and ast.unparse(decorator.func).endswith("validator"):
+            if len(decorator.args) == 0:
+                return _ValidatorWrapper(method, index, None)
+            else:
+                return _ValidatorWrapper(
+                    method, index, {arg.value if isinstance(arg, ast.Constant) else arg for arg in decorator.args}
+                )
+        elif isinstance(decorator, ast.Name | ast.Attribute) and ast.unparse(decorator).endswith("validator"):
+            return _ValidatorWrapper(method, index, None)
+    return None

{cadwyn-3.3.4 → cadwyn-3.4.0}/cadwyn/codegen/_common.py

@@ -16,6 +16,8 @@ from cadwyn._package_utils import IdentifierPythonPath
 from cadwyn.exceptions import CodeGenerationError
 from cadwyn.structure.versions import Version
 
+from ._asts import _ValidatorWrapper, get_validator_info_or_none
+
 _FieldName: TypeAlias = str
 _CodegenPluginASTType = TypeVar("_CodegenPluginASTType", bound=ast.AST)
 
@@ -25,6 +27,7 @@ class PydanticModelWrapper:
     cls: type[BaseModel]
     name: str
     fields: dict[_FieldName, PydanticFieldWrapper]
+    validators: dict[_FieldName, _ValidatorWrapper]
     _parents: list[Self] | None = dataclasses.field(init=False, default=None)
 
     def _get_parents(self, schemas: "dict[IdentifierPythonPath, Self]"):
@@ -37,11 +40,14 @@ class PydanticModelWrapper:
             if schema_path in schemas:
                 parents.append(schemas[schema_path])
             elif issubclass(base, BaseModel):
-                parents.append(type(self)(base, base.__name__, get_fields_from_model(base)))
+                fields, validators = get_fields_and_validators_from_model(base)
+                parents.append(type(self)(base, base.__name__, fields, validators))
         self._parents = parents
         return parents
 
-    def _get_defined_fields(self, schemas: "dict[IdentifierPythonPath, Self]") -> dict[str, PydanticFieldWrapper]:
+    def _get_defined_fields_through_mro(
+        self, schemas: "dict[IdentifierPythonPath, Self]"
+    ) -> dict[str, PydanticFieldWrapper]:
         fields = {}
 
         for parent in reversed(self._get_parents(schemas)):
@@ -49,9 +55,19 @@ class PydanticModelWrapper:
 
         return fields | self.fields
 
+    def _get_defined_annotations_through_mro(self, schemas: "dict[IdentifierPythonPath, Self]") -> dict[str, Any]:
+        annotations = {}
+
+        for parent in reversed(self._get_parents(schemas)):
+            annotations |= parent.cls.__annotations__
+
+        return annotations | self.cls.__annotations__
+
 
 @cache
-def get_fields_from_model(cls: type) -> dict[str, PydanticFieldWrapper]:
+def get_fields_and_validators_from_model(
+    cls: type,
+) -> tuple[dict[_FieldName, PydanticFieldWrapper], dict[_FieldName, _ValidatorWrapper]]:
     if not isinstance(cls, type) or not issubclass(cls, BaseModel):
         raise CodeGenerationError(f"Model {cls} is not a subclass of BaseModel")
 
@@ -59,25 +75,37 @@ def get_fields_from_model(cls: type) -> dict[str, PydanticFieldWrapper]:
     try:
         source = inspect.getsource(cls)
     except OSError:
-        return {
-            field_name: PydanticFieldWrapper(
-                annotation=field.annotation,
-                init_model_field=field,
-            )
-            for field_name, field in fields.items()
-        }
+        return (
+            {
+                field_name: PydanticFieldWrapper(annotation=field.annotation, init_model_field=field)
+                for field_name, field in fields.items()
+            },
+            {},
+        )
     else:
         cls_ast = cast(ast.ClassDef, ast.parse(source).body[0])
-        return {
-            node.target.id: PydanticFieldWrapper(
-                annotation=fields[node.target.id].annotation,
-                init_model_field=fields[node.target.id],
-                annotation_ast=node.annotation,
-                field_ast=node.value,
-            )
+        validators: dict[str, _ValidatorWrapper] = {}
+
+        validators_and_nones = (
+            get_validator_info_or_none(node)
             for node in cls_ast.body
-            if isinstance(node, ast.AnnAssign) and isinstance(node.target, ast.Name) and node.target.id in fields
-        }
+            if isinstance(node, ast.FunctionDef) and node.decorator_list
+        )
+        validators = {validator.func_ast.name: validator for validator in validators_and_nones if validator is not None}
+
+        return (
+            {
+                node.target.id: PydanticFieldWrapper(
+                    annotation=fields[node.target.id].annotation,
+                    init_model_field=fields[node.target.id],
+                    annotation_ast=node.annotation,
+                    value_ast=node.value,
+                )
+                for node in cls_ast.body
+                if isinstance(node, ast.AnnAssign) and isinstance(node.target, ast.Name) and node.target.id in fields
+            },
+            validators,
+        )
 
 
 @dataclass(slots=True)

{cadwyn-3.3.4 → cadwyn-3.4.0}/cadwyn/codegen/_main.py

@@ -21,7 +21,7 @@ from cadwyn.codegen._common import (
     PydanticModelWrapper,
     _EnumWrapper,
     _ModuleWrapper,
-    get_fields_from_model,
+    get_fields_and_validators_from_model,
 )
 from cadwyn.codegen._plugins.class_migrations import class_migration_plugin
 from cadwyn.codegen._plugins.class_rebuilding import ClassRebuildingPlugin
@@ -63,14 +63,15 @@ def generate_code_for_versioned_packages(
         version of the latest module.
     """
     extra_context = extra_context or {}
+    schemas = {}
+    for k, v in deepcopy(versions.versioned_schemas).items():
+        fields, validators = get_fields_and_validators_from_model(v)
+        schemas[k] = PydanticModelWrapper(v, v.__name__, fields, validators)
 
     _generate_versioned_directories(
         template_module,
         versions=list(versions),
-        schemas={
-            k: PydanticModelWrapper(v, v.__name__, get_fields_from_model(v))
-            for k, v in deepcopy(versions.versioned_schemas).items()
-        },
+        schemas=schemas,
         enums={
             k: _EnumWrapper(v, {member.name: member.value for member in v})
             for k, v in deepcopy(versions.versioned_enums).items()