cadwyn 3.3.4__py3-none-any.whl → 3.4.0__py3-none-any.whl

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/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/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/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()

cadwyn/codegen/_plugins/class_migrations.py

@@ -1,21 +1,31 @@
 import ast
 from collections.abc import Sequence
+from typing import Annotated, Any, cast, get_args, get_origin
 
 from typing_extensions import assert_never
 
-from cadwyn._compat import FieldInfo, PydanticFieldWrapper, dict_of_empty_field_info, is_pydantic_constrained_type
+from cadwyn._compat import (
+    PYDANTIC_V2,
+    FieldInfo,
+    PydanticFieldWrapper,
+    dict_of_empty_field_info,
+    is_constrained_type,
+)
 from cadwyn._package_utils import IdentifierPythonPath, get_cls_pythonpath
 from cadwyn._utils import Sentinel
-from cadwyn.codegen._asts import add_keyword_to_call
+from cadwyn.codegen._asts import add_keyword_to_call, delete_keyword_from_call, get_fancy_repr
 from cadwyn.codegen._common import GlobalCodegenContext, PydanticModelWrapper, _EnumWrapper
 from cadwyn.exceptions import InvalidGenerationInstructionError
 from cadwyn.structure.enums import AlterEnumSubInstruction, EnumDidntHaveMembersInstruction, EnumHadMembersInstruction
 from cadwyn.structure.schemas import (
-    AlterSchemaInstruction,
     AlterSchemaSubInstruction,
-    OldSchemaFieldDidntExist,
-    OldSchemaFieldExistedWith,
-    OldSchemaFieldHad,
+    FieldDidntExistInstruction,
+    FieldDidntHaveInstruction,
+    FieldExistedAsInstruction,
+    FieldHadInstruction,
+    SchemaHadInstruction,
+    ValidatorDidntExistInstruction,
+    ValidatorExistedInstruction,
 )
 
 
@@ -35,26 +45,41 @@ def class_migration_plugin(context: GlobalCodegenContext):
 
 def _apply_alter_schema_instructions(
     modified_schemas: dict[IdentifierPythonPath, PydanticModelWrapper],
-    alter_schema_instructions: Sequence[AlterSchemaSubInstruction | AlterSchemaInstruction],
+    alter_schema_instructions: Sequence[AlterSchemaSubInstruction | SchemaHadInstruction],
     version_change_name: str,
 ):
     for alter_schema_instruction in alter_schema_instructions:
         schema = alter_schema_instruction.schema
         schema_path = get_cls_pythonpath(schema)
-        mutable_schema_info = modified_schemas[schema_path]
-        if isinstance(alter_schema_instruction, OldSchemaFieldDidntExist):
-            _delete_field_from_model(mutable_schema_info, alter_schema_instruction.field_name, version_change_name)
-        elif isinstance(alter_schema_instruction, OldSchemaFieldHad):
+        schema_info = modified_schemas[schema_path]
+        if isinstance(alter_schema_instruction, FieldExistedAsInstruction):
+            _add_field_to_model(schema_info, modified_schemas, alter_schema_instruction, version_change_name)
+        elif isinstance(alter_schema_instruction, FieldHadInstruction | FieldDidntHaveInstruction):
             _change_field_in_model(
-                mutable_schema_info,
+                schema_info,
                 modified_schemas,
                 alter_schema_instruction,
                 version_change_name,
             )
-        elif isinstance(alter_schema_instruction, OldSchemaFieldExistedWith):
-            _add_field_to_model(mutable_schema_info, modified_schemas, alter_schema_instruction, version_change_name)
-        elif isinstance(alter_schema_instruction, AlterSchemaInstruction):
-            _change_model(mutable_schema_info, alter_schema_instruction, version_change_name)
+        elif isinstance(alter_schema_instruction, FieldDidntExistInstruction):
+            _delete_field_from_model(schema_info, alter_schema_instruction.name, version_change_name)
+        elif isinstance(alter_schema_instruction, ValidatorExistedInstruction):
+            validator_name = alter_schema_instruction.validator.__name__
+            schema_info.validators[validator_name] = alter_schema_instruction.validator_info
+        elif isinstance(alter_schema_instruction, ValidatorDidntExistInstruction):
+            if alter_schema_instruction.name not in schema_info.validators:
+                raise InvalidGenerationInstructionError(
+                    f'You tried to delete a validator "{alter_schema_instruction.name}" from "{schema_info.name}" '
+                    f'in "{version_change_name}" but it doesn\'t have such a validator.',
+                )
+            if schema_info.validators[alter_schema_instruction.name].is_deleted:
+                raise InvalidGenerationInstructionError(
+                    f'You tried to delete a validator "{alter_schema_instruction.name}" from "{schema_info.name}" '
+                    f'in "{version_change_name}" but it is already deleted.',
+                )
+            schema_info.validators[alter_schema_instruction.name].is_deleted = True
+        elif isinstance(alter_schema_instruction, SchemaHadInstruction):
+            _change_model(schema_info, alter_schema_instruction, version_change_name)
         else:
             assert_never(alter_schema_instruction)
 
@@ -90,7 +115,7 @@ def _apply_alter_enum_instructions(
 
 def _change_model(
     model: PydanticModelWrapper,
-    alter_schema_instruction: AlterSchemaInstruction,
+    alter_schema_instruction: SchemaHadInstruction,
     version_change_name: str,
 ):
     # We only handle names right now so we just go ahead and check
@@ -99,69 +124,144 @@ def _change_model(
             f'You tried to change the name of "{model.name}" in "{version_change_name}" '
             "but it already has the name you tried to assign.",
         )
+
     model.name = alter_schema_instruction.name
 
 
 def _add_field_to_model(
     model: PydanticModelWrapper,
     schemas: "dict[IdentifierPythonPath, PydanticModelWrapper]",
-    alter_schema_instruction: OldSchemaFieldExistedWith,
+    alter_schema_instruction: FieldExistedAsInstruction,
     version_change_name: str,
 ):
-    defined_fields = model._get_defined_fields(schemas)
-    if alter_schema_instruction.field_name in defined_fields:
+    defined_fields = model._get_defined_fields_through_mro(schemas)
+    if alter_schema_instruction.name in defined_fields:
         raise InvalidGenerationInstructionError(
-            f'You tried to add a field "{alter_schema_instruction.field_name}" to "{model.name}" '
+            f'You tried to add a field "{alter_schema_instruction.name}" to "{model.name}" '
             f'in "{version_change_name}" but there is already a field with that name.',
         )
 
-    model.fields[alter_schema_instruction.field_name] = PydanticFieldWrapper(
-        annotation_ast=None,
+    fancy_type_repr = get_fancy_repr(alter_schema_instruction.type)
+    field = PydanticFieldWrapper(
+        annotation_ast=ast.parse(fancy_type_repr, mode="eval").body,
         annotation=alter_schema_instruction.type,
         init_model_field=alter_schema_instruction.field,
-        field_ast=None,
+        value_ast=None,
     )
+    model.fields[alter_schema_instruction.name] = field
+
+    passed_field_attributes = field.passed_field_attributes
+    if passed_field_attributes:
+        field_call_ast = cast(ast.Call, ast.parse("Field()", mode="eval").body)
+        for attr_name, attr_value in passed_field_attributes.items():
+            add_keyword_to_call(attr_name, attr_value, field_call_ast)
+        field.value_ast = field_call_ast
+    model.cls.__annotations__[alter_schema_instruction.name] = alter_schema_instruction.type
 
 
 def _change_field_in_model(
     model: PydanticModelWrapper,
     schemas: "dict[IdentifierPythonPath, PydanticModelWrapper]",
-    alter_schema_instruction: OldSchemaFieldHad,
+    alter_schema_instruction: FieldHadInstruction | FieldDidntHaveInstruction,
     version_change_name: str,
 ):
-    defined_fields = model._get_defined_fields(schemas)
-    if alter_schema_instruction.field_name not in defined_fields:
+    defined_annotations = model._get_defined_annotations_through_mro(schemas)
+    defined_fields = model._get_defined_fields_through_mro(schemas)
+    if alter_schema_instruction.name not in defined_fields:
         raise InvalidGenerationInstructionError(
-            f'You tried to change the type of field "{alter_schema_instruction.field_name}" from '
+            f'You tried to change the field "{alter_schema_instruction.name}" from '
             f'"{model.name}" in "{version_change_name}" but it doesn\'t have such a field.',
         )
 
-    field = defined_fields[alter_schema_instruction.field_name]
-    model.fields[alter_schema_instruction.field_name] = field
+    field = defined_fields[alter_schema_instruction.name]
+    model.fields[alter_schema_instruction.name] = field
+    model.cls.__annotations__[alter_schema_instruction.name] = defined_annotations[alter_schema_instruction.name]
+
+    annotation_ast, field_call_ast, contype_is_definitely_used = _get_constraint_asts_and_field_call_ast(
+        schemas, model, alter_schema_instruction.name, field
+    )
+
+    constrained_type_annotation = None
+
+    if annotation_ast is not None:
+        field_type_is_annotated = True  # I.e. typing.Annotated
+        # PydanticV2 changed field annotation handling so field.annotation lies to us
+        real_annotation = model._get_defined_annotations_through_mro(schemas)[alter_schema_instruction.name]
+        type_annotation = get_args(real_annotation)[0]
+        if is_constrained_type(type_annotation):
+            constrained_type_annotation = type_annotation
+    else:
+        field_type_is_annotated = False
+        type_annotation = field.annotation
+        if is_constrained_type(type_annotation):
+            constrained_type_annotation = type_annotation
+        annotation_ast = field.annotation_ast
+    if field_call_ast is None:
+        field_call_ast = field.value_ast
 
-    current_field_is_constrained_type = is_pydantic_constrained_type(field.annotation)
+    if isinstance(alter_schema_instruction, FieldHadInstruction):
+        # TODO: This naming sucks
+        _change_field(
+            model,
+            alter_schema_instruction,
+            version_change_name,
+            defined_annotations,
+            field,
+            annotation_ast,
+            field_call_ast,
+            type_annotation,
+            field_type_is_annotated,
+            constrained_type_annotation,
+        )
+    else:
+        _delete_field_attributes(
+            model,
+            alter_schema_instruction,
+            version_change_name,
+            field,
+            annotation_ast,
+            field_call_ast,
+            type_annotation,
+            constrained_type_annotation,
+            contype_is_definitely_used,
+        )
+
+
+def _change_field(  # noqa: C901
+    model: PydanticModelWrapper,
+    alter_schema_instruction: FieldHadInstruction,
+    version_change_name: str,
+    defined_annotations: dict[str, Any],
+    field: PydanticFieldWrapper,
+    annotation_ast: ast.expr | None,
+    field_call_ast: ast.expr | None,
+    type_annotation: Any,
+    field_type_is_annotated: bool,
+    constrained_type_annotation: Any | None,
+):
     if alter_schema_instruction.type is not Sentinel:
         if field.annotation == alter_schema_instruction.type:
             raise InvalidGenerationInstructionError(
-                f'You tried to change the type of field "{alter_schema_instruction.field_name}" to '
+                f'You tried to change the type of field "{alter_schema_instruction.name}" to '
                 f'"{alter_schema_instruction.type}" from "{model.name}" in "{version_change_name}" '
                 f'but it already has type "{field.annotation}"',
             )
         field.annotation = alter_schema_instruction.type
-
-        field.annotation_ast = None
-        if current_field_is_constrained_type:
-            field.field_ast = None
+        model.cls.__annotations__[alter_schema_instruction.name] = alter_schema_instruction.type
+        fancy_type_repr = get_fancy_repr(alter_schema_instruction.type)
+        field.annotation_ast = ast.parse(fancy_type_repr, mode="eval").body
 
     if alter_schema_instruction.new_name is not Sentinel:
-        if alter_schema_instruction.new_name == alter_schema_instruction.field_name:
+        if alter_schema_instruction.new_name == alter_schema_instruction.name:
             raise InvalidGenerationInstructionError(
-                f'You tried to change the name of field "{alter_schema_instruction.field_name}" '
+                f'You tried to change the name of field "{alter_schema_instruction.name}" '
                 f'from "{model.name}" in "{version_change_name}" '
                 "but it already has that name.",
             )
-        model.fields[alter_schema_instruction.new_name] = model.fields.pop(
-            alter_schema_instruction.field_name,
+        model.fields[alter_schema_instruction.new_name] = model.fields.pop(alter_schema_instruction.name)
+        model.cls.__annotations__[alter_schema_instruction.new_name] = model.cls.__annotations__.pop(
+            alter_schema_instruction.name,
+            defined_annotations[alter_schema_instruction.name],
         )
 
     field_info = field.field_info
@@ -176,26 +276,129 @@ def _change_field_in_model(
             if field.passed_field_attributes.get(attr_name, Sentinel) == attr_value:
                 raise InvalidGenerationInstructionError(
                     f'You tried to change the attribute "{attr_name}" of field '
-                    f'"{alter_schema_instruction.field_name}" '
+                    f'"{alter_schema_instruction.name}" '
                     f'from "{model.name}" to {attr_value!r} in "{version_change_name}" '
                     "but it already has that value.",
                 )
+            if constrained_type_annotation is not None and hasattr(constrained_type_annotation, attr_name):
+                _setattr_on_constrained_type(constrained_type_annotation, attr_name, attr_value)
+                if isinstance(annotation_ast, ast.Call):
+                    add_keyword_to_call(attr_name, attr_value, annotation_ast)
+                elif not PYDANTIC_V2:  # pragma: no branch
+                    field.update_attribute(name=attr_name, value=attr_value)
+                    if isinstance(field_call_ast, ast.Call):  # pragma: no branch
+                        add_keyword_to_call(attr_name, attr_value, field_call_ast)
 
-            if hasattr(field.annotation, attr_name) and current_field_is_constrained_type:
-                setattr(field.annotation, attr_name, attr_value)
-                ann_ast = field.annotation_ast
-                if ann_ast is not None and isinstance(ann_ast, ast.Call):
-                    add_keyword_to_call(attr_name, attr_value, ann_ast)
-                else:
-                    field.field_ast = None
-                    field.annotation_ast = None
             else:
                 field.update_attribute(name=attr_name, value=attr_value)
-                field_ast = field.field_ast
-                if isinstance(field_ast, ast.Call):
-                    add_keyword_to_call(attr_name, attr_value, field_ast)
+                if field_type_is_annotated and attr_name == "default":
+                    field.value_ast = ast.parse(get_fancy_repr(attr_value), mode="eval").body
+                elif isinstance(field_call_ast, ast.Call):
+                    add_keyword_to_call(attr_name, attr_value, field_call_ast)
+                elif field.value_ast is not None:
+                    field_call_ast = cast(ast.Call, ast.parse("Field()", mode="eval").body)
+                    add_keyword_to_call("default", field.value_ast, field_call_ast)
+                    add_keyword_to_call(attr_name, attr_value, field_call_ast)
+                    field.value_ast = field_call_ast
                 else:
-                    field.field_ast = None
+                    field.value_ast = cast(ast.Call, ast.parse("Field()", mode="eval").body)
+                    field_call_ast = field.value_ast
+                    add_keyword_to_call(attr_name, attr_value, field_call_ast)
+
+
+def _setattr_on_constrained_type(constrained_type_annotation: Any, attr_name: str, attr_value: Any) -> None:
+    setattr(constrained_type_annotation, attr_name, attr_value)
+
+
+def _delete_field_attributes(
+    model: PydanticModelWrapper,
+    alter_schema_instruction: FieldDidntHaveInstruction,
+    version_change_name: str,
+    field: PydanticFieldWrapper,
+    type_annotation_ast: ast.expr | None,
+    field_call_ast: ast.expr | None,
+    type_annotation: Any,
+    constrained_type_annotation: Any,
+    contype_is_definitely_used: bool,
+) -> None:
+    for attr_name in alter_schema_instruction.attributes:
+        if attr_name in field.passed_field_attributes:
+            field.delete_attribute(name=attr_name)
+            if isinstance(field_call_ast, ast.Call):
+                delete_keyword_from_call(attr_name, field_call_ast)
+            elif attr_name == "default":  # pragma: no branch
+                field.value_ast = None
+        # In case annotation_ast is a conint/constr/etc. Notice how we do not support
+        # the same operation for **adding** constraints for simplicity.
+        elif (hasattr(constrained_type_annotation, attr_name)) or contype_is_definitely_used:
+            if hasattr(constrained_type_annotation, attr_name):
+                _setattr_on_constrained_type(constrained_type_annotation, attr_name, None)
+            if isinstance(type_annotation_ast, ast.Call):  # pragma: no branch
+                delete_keyword_from_call(attr_name, type_annotation_ast)
+        else:
+            raise InvalidGenerationInstructionError(
+                f'You tried to delete the attribute "{attr_name}" of field "{alter_schema_instruction.name}" '
+                f'from "{model.name}" in "{version_change_name}" '
+                "but it already doesn't have that attribute.",
+            )
+
+
+ContypeIsDefinitelyUsed = bool
+CONTYPES = (
+    "conbytes",
+    "condate",
+    "condecimal",
+    "confloat",
+    "conint",
+    "conlist",
+    "conset",
+    "constr",
+)
+
+
+def _get_constraint_asts_and_field_call_ast(
+    schemas: dict[IdentifierPythonPath, PydanticModelWrapper],
+    model: PydanticModelWrapper,
+    field_name: str,
+    field: PydanticFieldWrapper,
+) -> tuple[ast.expr | None, ast.Call | None, ContypeIsDefinitelyUsed]:
+    """If the field type is Annotated and contains "Field" """
+    # We return both annotation ast and field call ast because annotation might be a constrained type such as conint
+    # and therefore contain constraints that we might want to remove.
+
+    # ContypeIsDefinitely used is used to determine whether constr/conint/etc is used in Pydantic 2
+    # because pydantic 2 changes original type hints to make sure that conint/constr/etc do not appear in annotations.
+
+    real_annotation = model._get_defined_annotations_through_mro(schemas)[field_name]
+    # typing.Annotated scenario
+    if get_origin(real_annotation) == Annotated:
+        index_of_field_info = _find_index_of_field_info_in_annotated(real_annotation)
+        if not (isinstance(field.annotation_ast, ast.Subscript) and isinstance(field.annotation_ast.slice, ast.Tuple)):
+            return (field.annotation_ast, None, True)
+
+        unparsed_annotation = ast.unparse(field.annotation_ast.slice.elts[0])
+        contype_is_definitely_used = any(contype in unparsed_annotation for contype in CONTYPES)
+
+        # In pydantic 2, this means that in fact there is conint/constr/etc instead of an actual Annotated.
+        # Yes, pydantic 2 changes original type hints to make sure that conint/constr/etc do not appear in types.
+
+        if index_of_field_info is not None:
+            field_call_ast = field.annotation_ast.slice.elts[index_of_field_info]
+
+            return (field.annotation_ast.slice.elts[0], cast(ast.Call, field_call_ast), contype_is_definitely_used)
+        return (field.annotation_ast.slice.elts[0], None, contype_is_definitely_used)
+    return (None, None, False)
+
+
+def _find_index_of_field_info_in_annotated(real_annotation: Any):
+    # Pydantic turns `Annotated[conint(lt=2 + 5),                Field(default=11),     annotated_types.Gt(0)]` into:
+    #                `Annotated[int, None, Interval(lt=7), None, FieldInfo(default=11), annotated_types.Gt(0)]`
+    # Why? No idea. Probably due to its weird handling of constrained types. So we gotta go from the last element
+    # because constrained types can only appear and mess up indexing in the first element.
+    for i, arg in enumerate(reversed(get_args(real_annotation)), start=1):
+        if isinstance(arg, FieldInfo):
+            return -i
+    return None
 
 
 def _delete_field_from_model(model: PydanticModelWrapper, field_name: str, version_change_name: str):
@@ -205,3 +408,16 @@ def _delete_field_from_model(model: PydanticModelWrapper, field_name: str, versi
             f'in "{version_change_name}" but it doesn\'t have such a field.',
         )
     model.fields.pop(field_name)
+    for validator_name, validator in model.validators.copy().items():
+        if validator.field_names is not None and field_name in validator.field_names:
+            validator.field_names.remove(field_name)
+
+            validator_decorator = cast(
+                ast.Call, validator.func_ast.decorator_list[validator.index_of_validator_decorator]
+            )
+            for arg in validator_decorator.args.copy():
+                if isinstance(arg, ast.Constant) and arg.value == field_name:
+                    validator_decorator.args.remove(arg)
+            validator.func_ast.decorator_list[0]
+            if not validator.field_names:
+                model.validators[validator_name].is_deleted = True

cadwyn/codegen/_plugins/class_rebuilding.py

@@ -2,14 +2,8 @@ import ast
 import copy
 from typing import Any
 
-from cadwyn._compat import (
-    PydanticFieldWrapper,
-    get_attrs_that_are_not_from_field_and_that_are_from_field,
-    is_pydantic_constrained_type,
-)
 from cadwyn._package_utils import IdentifierPythonPath, get_absolute_python_path_of_import
 from cadwyn.codegen._asts import (
-    get_ast_keyword_from_argument_name_and_value,
     get_fancy_repr,
     pop_docstring_from_cls_body,
 )
@@ -92,48 +86,28 @@ def _modify_schema_cls(
     field_definitions = [
         ast.AnnAssign(
             target=ast.Name(name, ctx=ast.Store()),
-            annotation=_render_annotation(field.get_annotation_for_rendering()),
-            value=_generate_field_ast(field),
+            annotation=copy.deepcopy(field.annotation_ast),
+            # We do this because next plugins **might** use a transformer which will edit the ast within the field
+            # and break rendering
+            value=copy.deepcopy(field.value_ast),
             simple=1,
         )
         for name, field in model_info.fields.items()
     ]
+    validator_definitions = [
+        validator.func_ast for validator in model_info.validators.values() if not validator.is_deleted
+    ]
 
-    old_body = [n for n in cls_node.body if not isinstance(n, ast.AnnAssign | ast.Assign | ast.Pass | ast.Constant)]
+    old_body = [
+        n
+        for n in cls_node.body
+        if not (
+            isinstance(n, ast.AnnAssign | ast.Assign | ast.Pass | ast.Constant)
+            or (isinstance(n, ast.FunctionDef) and n.name in model_info.validators)
+        )
+    ]
     docstring = pop_docstring_from_cls_body(old_body)
-    cls_node.body = docstring + field_definitions + old_body
+    cls_node.body = docstring + field_definitions + validator_definitions + old_body
     if not cls_node.body:
         cls_node.body = [ast.Pass()]
     return cls_node
-
-
-def _render_annotation(annotation: Any):
-    if isinstance(annotation, ast.AST):
-        return copy.deepcopy(annotation)
-    return ast.parse(get_fancy_repr(annotation), mode="eval").body
-
-
-def _generate_field_ast(field: PydanticFieldWrapper):
-    if field.field_ast is not None:
-        # We do this because next plugins **might** use a transformer which will edit the ast within the field
-        # and break rendering
-        return copy.deepcopy(field.field_ast)
-    passed_attrs = field.passed_field_attributes
-    if is_pydantic_constrained_type(field.annotation) and field.annotation_ast is None:
-        (
-            attrs_that_are_only_in_contype,
-            attrs_that_are_only_in_field,
-        ) = get_attrs_that_are_not_from_field_and_that_are_from_field(field.annotation)
-        if not attrs_that_are_only_in_contype:
-            passed_attrs |= attrs_that_are_only_in_field
-
-    if passed_attrs:
-        return ast.Call(
-            func=ast.Name("Field"),
-            args=[],
-            keywords=[
-                get_ast_keyword_from_argument_name_and_value(attr, attr_value)
-                for attr, attr_value in passed_attrs.items()
-            ],
-        )
-    return None

cadwyn/codegen/_plugins/import_auto_adding.py

@@ -5,6 +5,7 @@ from cadwyn.codegen._common import CodegenContext
 
 _extra_imports: list[tuple[str, str]] = [
     ("typing", "import typing"),
+    ("pydantic", "import pydantic"),
     ("Any", "from typing import Any"),
     ("Annotated", "from typing import Annotated"),
     ("Field", "from pydantic import Field"),
@@ -16,6 +17,8 @@ _extra_imports: list[tuple[str, str]] = [
     ("confloat", "from pydantic import confloat"),
     ("condecimal", "from pydantic import condecimal"),
     ("condate", "from pydantic import condate"),
+    ("validator", "from pydantic import validator"),
+    ("root_validator", "from pydantic import root_validator"),
 ]
 
 
@@ -29,6 +32,8 @@ if PYDANTIC_V2:
             ("StrictFloat", "from pydantic import StrictFloat"),
             ("StrictInt", "from pydantic import StrictInt"),
             ("StrictStr", "from pydantic import StrictStr"),
+            ("model_validator", "from pydantic import model_validator"),
+            ("field_validator", "from pydantic import field_validator"),
         ],
     )
 

cadwyn/structure/data.py

@@ -73,7 +73,7 @@ class _AlterDataInstruction:
         signature = inspect.signature(self.transformer)
         if list(signature.parameters) != [self._payload_arg_name]:
             raise ValueError(
-                f"Method '{self.transformer.__name__}' must have 2 parameters: cls and {self._payload_arg_name}",
+                f"Method '{self.transformer.__name__}' must have only 1 parameter: {self._payload_arg_name}",
             )
 
         functools.update_wrapper(self, self.transformer)

cadwyn/structure/schemas.py

@@ -1,19 +1,52 @@
+import ast
+import inspect
+import textwrap
 from collections.abc import Callable
-from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Any, Literal
 
 from pydantic import BaseModel, Field
 from pydantic.fields import FieldInfo
 
+from cadwyn._compat import PYDANTIC_V2
+from cadwyn._utils import Sentinel
+from cadwyn.codegen._asts import _ValidatorWrapper, get_validator_info_or_none
 from cadwyn.exceptions import CadwynStructureError
 
-from .._compat import PYDANTIC_V2
-from .._utils import Sentinel
-
 if TYPE_CHECKING:
     from pydantic.typing import AbstractSetIntStr, MappingIntStrAny
 
 
+PossibleFieldAttributes = Literal[
+    "default",
+    "default_factory",
+    "alias",
+    "title",
+    "description",
+    "exclude",
+    "include",
+    "const",
+    "gt",
+    "ge",
+    "lt",
+    "le",
+    "multiple_of",
+    "allow_inf_nan",
+    "max_digits",
+    "decimal_places",
+    "min_items",
+    "max_items",
+    "unique_items",
+    "min_length",
+    "max_length",
+    "allow_mutation",
+    "regex",
+    "pattern",
+    "discriminator",
+    "repr",
+]
+
+
 @dataclass(slots=True)
 class FieldChanges:
     default: Any
@@ -45,24 +78,31 @@ class FieldChanges:
 
 
 @dataclass(slots=True)
-class OldSchemaFieldHad:
+class FieldHadInstruction:
     schema: type[BaseModel]
-    field_name: str
+    name: str
     type: type
     field_changes: FieldChanges
     new_name: str
 
 
 @dataclass(slots=True)
-class OldSchemaFieldDidntExist:
+class FieldDidntHaveInstruction:
     schema: type[BaseModel]
-    field_name: str
+    name: str
+    attributes: tuple[str, ...]
 
 
 @dataclass(slots=True)
-class OldSchemaFieldExistedWith:
+class FieldDidntExistInstruction:
     schema: type[BaseModel]
-    field_name: str
+    name: str
+
+
+@dataclass(slots=True)
+class FieldExistedAsInstruction:
+    schema: type[BaseModel]
+    name: str
     type: type
     field: FieldInfo
 
@@ -104,7 +144,7 @@ class AlterFieldInstructionFactory:
         pattern: str = Sentinel,
         discriminator: str = Sentinel,
         repr: bool = Sentinel,
-    ) -> OldSchemaFieldHad:
+    ) -> FieldHadInstruction:
         if PYDANTIC_V2:
             if regex is not Sentinel:
                 raise CadwynStructureError("`regex` was removed in Pydantic 2. Use `pattern` instead")
@@ -122,9 +162,9 @@ class AlterFieldInstructionFactory:
         else:
             if pattern is not Sentinel:
                 raise CadwynStructureError("`pattern` is only available in Pydantic 2. use `regex` instead")
-        return OldSchemaFieldHad(
+        return FieldHadInstruction(
             schema=self.schema,
-            field_name=self.name,
+            name=self.name,
             type=type,
             new_name=name,
             field_changes=FieldChanges(
@@ -157,29 +197,82 @@ class AlterFieldInstructionFactory:
             ),
         )
 
+    def didnt_have(self, *attributes: PossibleFieldAttributes) -> FieldDidntHaveInstruction:
+        for attribute in attributes:
+            if attribute not in FieldChanges.__dataclass_fields__:
+                raise CadwynStructureError(
+                    f"Unknown attribute {attribute!r}. Are you sure it's a valid field attribute?"
+                )
+        return FieldDidntHaveInstruction(self.schema, self.name, attributes)
+
     @property
-    def didnt_exist(self) -> OldSchemaFieldDidntExist:
-        return OldSchemaFieldDidntExist(self.schema, field_name=self.name)
+    def didnt_exist(self) -> FieldDidntExistInstruction:
+        return FieldDidntExistInstruction(self.schema, name=self.name)
 
     def existed_as(
         self,
         *,
         type: Any,
         info: FieldInfo | None = None,
-    ) -> OldSchemaFieldExistedWith:
-        return OldSchemaFieldExistedWith(
+    ) -> FieldExistedAsInstruction:
+        return FieldExistedAsInstruction(
             self.schema,
-            field_name=self.name,
+            name=self.name,
             type=type,
             field=info or Field(),
         )
 
 
-AlterSchemaSubInstruction = OldSchemaFieldHad | OldSchemaFieldDidntExist | OldSchemaFieldExistedWith
+@dataclass(slots=True)
+class ValidatorExistedInstruction:
+    schema: type[BaseModel]
+    validator: Callable[..., Any]
+    validator_info: _ValidatorWrapper = field(init=False)
+
+    def __post_init__(self):
+        source = textwrap.dedent(inspect.getsource(self.validator))
+        validator_ast = ast.parse(source).body[0]
+        if not isinstance(validator_ast, ast.FunctionDef):
+            raise CadwynStructureError("The passed validator must be a function")
+
+        validator_info = get_validator_info_or_none(validator_ast)
+        if validator_info is None:
+            raise CadwynStructureError("The passed function must be a pydantic validator")
+        self.validator_info = validator_info
 
 
 @dataclass(slots=True)
-class AlterSchemaInstruction:
+class ValidatorDidntExistInstruction:
+    schema: type[BaseModel]
+    name: str
+
+
+@dataclass(slots=True)
+class AlterValidatorInstructionFactory:
+    schema: type[BaseModel]
+    func: Callable[..., Any]
+
+    @property
+    def existed(self) -> ValidatorExistedInstruction:
+        return ValidatorExistedInstruction(self.schema, self.func)
+
+    @property
+    def didnt_exist(self) -> ValidatorDidntExistInstruction:
+        return ValidatorDidntExistInstruction(self.schema, self.func.__name__)
+
+
+AlterSchemaSubInstruction = (
+    FieldHadInstruction
+    | FieldDidntHaveInstruction
+    | FieldDidntExistInstruction
+    | FieldExistedAsInstruction
+    | ValidatorExistedInstruction
+    | ValidatorDidntExistInstruction
+)
+
+
+@dataclass(slots=True)
+class SchemaHadInstruction:
     schema: type[BaseModel]
     name: str
 
@@ -191,8 +284,13 @@ class AlterSchemaInstructionFactory:
     def field(self, name: str, /) -> AlterFieldInstructionFactory:
         return AlterFieldInstructionFactory(self.schema, name)
 
-    def had(self, *, name: str) -> AlterSchemaInstruction:
-        return AlterSchemaInstruction(self.schema, name)
+    def validator(self, func: "Callable[..., Any] | classmethod[Any, Any, Any]", /) -> AlterValidatorInstructionFactory:
+        if isinstance(func, classmethod):
+            func = func.__wrapped__
+        return AlterValidatorInstructionFactory(self.schema, func)
+
+    def had(self, *, name: str) -> SchemaHadInstruction:
+        return SchemaHadInstruction(self.schema, name)
 
 
 def schema(model: type[BaseModel], /) -> AlterSchemaInstructionFactory:

cadwyn/structure/versions.py

@@ -25,7 +25,7 @@ from pydantic import BaseModel
 from starlette._utils import is_async_callable
 from typing_extensions import assert_never
 
-from cadwyn._compat import PYDANTIC_V2, ModelField, Undefined, model_dump
+from cadwyn._compat import PYDANTIC_V2, ModelField, PydanticUndefined, model_dump
 from cadwyn._package_utils import IdentifierPythonPath, get_cls_pythonpath
 from cadwyn.exceptions import CadwynError, CadwynStructureError
 
@@ -42,7 +42,7 @@ from .data import (
 from .endpoints import AlterEndpointSubInstruction
 from .enums import AlterEnumSubInstruction
 from .modules import AlterModuleInstruction
-from .schemas import AlterSchemaInstruction, AlterSchemaSubInstruction
+from .schemas import AlterSchemaSubInstruction, SchemaHadInstruction
 
 _CADWYN_REQUEST_PARAM_NAME = "cadwyn_request_param"
 _CADWYN_RESPONSE_PARAM_NAME = "cadwyn_response_param"
@@ -52,7 +52,7 @@ PossibleInstructions: TypeAlias = (
     AlterSchemaSubInstruction
     | AlterEndpointSubInstruction
     | AlterEnumSubInstruction
-    | AlterSchemaInstruction
+    | SchemaHadInstruction
     | AlterModuleInstruction
     | staticmethod
 )
@@ -62,7 +62,7 @@ APIVersionVarType: TypeAlias = ContextVar[VersionDate | None] | ContextVar[Versi
 class VersionChange:
     description: ClassVar[str] = Sentinel
     instructions_to_migrate_to_previous_version: ClassVar[Sequence[PossibleInstructions]] = Sentinel
-    alter_schema_instructions: ClassVar[list[AlterSchemaSubInstruction | AlterSchemaInstruction]] = Sentinel
+    alter_schema_instructions: ClassVar[list[AlterSchemaSubInstruction | SchemaHadInstruction]] = Sentinel
     alter_enum_instructions: ClassVar[list[AlterEnumSubInstruction]] = Sentinel
     alter_module_instructions: ClassVar[list[AlterModuleInstruction]] = Sentinel
     alter_endpoint_instructions: ClassVar[list[AlterEndpointSubInstruction]] = Sentinel
@@ -116,7 +116,7 @@ class VersionChange:
         cls.alter_response_by_schema_instructions = {}
         cls.alter_response_by_path_instructions = defaultdict(list)
         for alter_instruction in cls.instructions_to_migrate_to_previous_version:
-            if isinstance(alter_instruction, AlterSchemaInstruction | AlterSchemaSubInstruction):
+            if isinstance(alter_instruction, SchemaHadInstruction | AlterSchemaSubInstruction):
                 cls.alter_schema_instructions.append(alter_instruction)
             elif isinstance(alter_instruction, AlterEnumSubInstruction):
                 cls.alter_enum_instructions.append(alter_instruction)
@@ -567,7 +567,7 @@ async def _get_body(request: FastapiRequest, body_field: ModelField | None):  #
             else:
                 body_bytes = await request.body()
                 if body_bytes:
-                    json_body: Any = Undefined
+                    json_body: Any = PydanticUndefined
                     content_type_value = request.headers.get("content-type")
                     if not content_type_value:
                         json_body = await request.json()
@@ -578,7 +578,7 @@ async def _get_body(request: FastapiRequest, body_field: ModelField | None):  #
                             subtype = message.get_content_subtype()
                             if subtype == "json" or subtype.endswith("+json"):
                                 json_body = await request.json()
-                    if json_body != Undefined:
+                    if json_body != PydanticUndefined:
                         body = json_body
                     else:
                         body = body_bytes

{cadwyn-3.3.4.dist-info → cadwyn-3.4.0.dist-info}/METADATA

@@ -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.dist-info → cadwyn-3.4.0.dist-info}/RECORD

@@ -1,18 +1,18 @@
 cadwyn/__init__.py,sha256=gVLVH3SSBGH0IQYGL5tbro4s0vk--9sAym0UvoG3s1w,478
 cadwyn/__main__.py,sha256=JUNmAhwn7tG1EeXI82QmFZE-fpjfAOv2kxFNDfxWbhQ,2851
-cadwyn/_compat.py,sha256=yUXMFK_PS7jOzKktHDcnwwCt4iT3O3eqrgBRliOSKrY,5782
+cadwyn/_compat.py,sha256=B0K-cj9bN7ytOIehOMjN9O9s0CE3lq9WAkV97pnvll8,5410
 cadwyn/_package_utils.py,sha256=trxTYLmppv-10SKhScfyDQJh21rsQGFoLaOtHycKKR0,1443
 cadwyn/_utils.py,sha256=gEv_1Qqp7uzvdY0u_l77d6lppAsNsOCjD8FEFBKi3Js,3758
 cadwyn/codegen/README.md,sha256=V2Kz2IOz1cTxrC-RnQ7YbWEVCIGYr3tR4IPCvepeq0M,1047
 cadwyn/codegen/__init__.py,sha256=JgddDjxMTjSfVrMXHwNu1ODgdn2QfPWpccrRKquBV6k,355
-cadwyn/codegen/_asts.py,sha256=vWQRIpVYA63ku2Su8a3i_uTF0l81LHZmuWltnLoZYLk,9213
-cadwyn/codegen/_common.py,sha256=iy7CoM6wRaFcouE1L_opHMgz0CDQybRjTxrJGj5QZtw,4586
-cadwyn/codegen/_main.py,sha256=IW-J_9fRfOIkfxiPbkal2QjDzpn4Y2fW-4YeTtB_sgs,9032
+cadwyn/codegen/_asts.py,sha256=rwg3FMC9c_20rawub98UTWzL8hhkBgJ0RdJsqnW9bVE,10161
+cadwyn/codegen/_common.py,sha256=6vU9RtDPkXtuseRDtHeBbWYSTFwGtONv4OCA7BQrr3I,5651
+cadwyn/codegen/_main.py,sha256=wiadc3OYn1MlLwirfWuhkanvr2El-GjeQJpmpxHc4jA,9122
 cadwyn/codegen/_plugins/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cadwyn/codegen/_plugins/class_migrations.py,sha256=m22lfgEvMw2DFXVdaFjbHAQ4JDM7io7QFNNS6EK7pM0,9549
-cadwyn/codegen/_plugins/class_rebuilding.py,sha256=JrALq6B8YfPclGG4zG03fXxtoOsP38Jt2yCSkWhqEzw,4677
+cadwyn/codegen/_plugins/class_migrations.py,sha256=dbmXMdfUGA2X4phsNdtRQQde4SuoOYtNB86XL05U1jY,20159
+cadwyn/codegen/_plugins/class_rebuilding.py,sha256=mJR297bqsLUfP4HW5_1GuHlpiYSQd851yHpG_ajjilg,3703
 cadwyn/codegen/_plugins/class_renaming.py,sha256=5ka2W1c18i4maNbEkEpELvGLEFbd8tthvQX3YA3Bu0A,1843
-cadwyn/codegen/_plugins/import_auto_adding.py,sha256=cYH7Fj_za-5_1h6yOfSiwxymg0X_vVJGyfQ5iJxb4FQ,2314
+cadwyn/codegen/_plugins/import_auto_adding.py,sha256=00zGK99cT-bq2eXKDlYBR5-Z3uHLOGU7dbhB0YFFrt0,2613
 cadwyn/codegen/_plugins/latest_version_aliasing.py,sha256=s8TgpBL9FofKyJaF4AB7UxJYkq-f9LiMVL33LJxFVp4,4010
 cadwyn/codegen/_plugins/module_migrations.py,sha256=TeWJk4Iu4SRQ9K2iI3v3sCs1110jrltKlPdfU9mXIsQ,722
 cadwyn/exceptions.py,sha256=XOLsT4EH1uGNirmKlkgEk03PjUMtD7tgaCDadt_eBbE,695
@@ -21,14 +21,14 @@ cadwyn/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cadwyn/routing.py,sha256=3H8GKT10wAYroAOCtGCNBMuA63SGAQSESze3EhBLwo0,34433
 cadwyn/structure/__init__.py,sha256=BjFPlQYCw8ds_4zxdCi2LimarUGqSzyTNmOdT-FkGms,661
 cadwyn/structure/common.py,sha256=6Z4nI97XPWTCinn6np73m-rLPyYNrz2fWXKJlqjsiaQ,269
-cadwyn/structure/data.py,sha256=g9UmCkcdLJA8SlFMmYJIrBEuuIO8DNkhbfUHiOrYnds,5785
+cadwyn/structure/data.py,sha256=cCaclB67mKlgRiydPFijyfLdng4qyqnY_hP8ApS5pT4,5781
 cadwyn/structure/endpoints.py,sha256=VngfAydGBwekhV2tBOtNDPVgl3X1IgYxUCw--VZ5cQY,5627
 cadwyn/structure/enums.py,sha256=iMokxA2QYJ61SzyB-Pmuq3y7KL7-e6TsnjLVUaVZQnw,954
 cadwyn/structure/modules.py,sha256=1FK-lLm-zOTXEvn-QtyBH38aDRht5PDQiZrOPCsBlM4,1268
-cadwyn/structure/schemas.py,sha256=JmatYHXTaA8lZZcgctGtRyR_HDc-lUqyz8c8NhQgprU,6050
-cadwyn/structure/versions.py,sha256=37pp1ywy6TCSXQuf37IkULK70Gs03n1IWJTNy8agcBQ,27964
-cadwyn-3.3.4.dist-info/entry_points.txt,sha256=eO05hLn9GoRzzpwT9GONPmXKsonjuMNssM2D2WHWKGk,46
-cadwyn-3.3.4.dist-info/LICENSE,sha256=KeCWewiDQYpmSnzF-p_0YpoWiyDcUPaCuG8OWQs4ig4,1072
-cadwyn-3.3.4.dist-info/WHEEL,sha256=vxFmldFsRN_Hx10GDvsdv1wroKq8r5Lzvjp6GZ4OO8c,88
-cadwyn-3.3.4.dist-info/METADATA,sha256=O0H0iQkNJiEoBNMWecsr5K9TuAG1srWWgZt4M_m5D7c,4264
-cadwyn-3.3.4.dist-info/RECORD,,
+cadwyn/structure/schemas.py,sha256=LIKwDuzorVC9AHg4EN-UYdI133lCk_2MkBTdiyAr-EQ,8808
+cadwyn/structure/versions.py,sha256=UcjsvSzYNgRtTmsCgnCXdv0LtNYTZqCs5yEpU68gnq4,27980
+cadwyn-3.4.0.dist-info/entry_points.txt,sha256=eO05hLn9GoRzzpwT9GONPmXKsonjuMNssM2D2WHWKGk,46
+cadwyn-3.4.0.dist-info/LICENSE,sha256=KeCWewiDQYpmSnzF-p_0YpoWiyDcUPaCuG8OWQs4ig4,1072
+cadwyn-3.4.0.dist-info/WHEEL,sha256=vxFmldFsRN_Hx10GDvsdv1wroKq8r5Lzvjp6GZ4OO8c,88
+cadwyn-3.4.0.dist-info/METADATA,sha256=vrs8AOFwEjJZ6L_3fshUEFgRTmfWj7gh_pqGtn5axvg,4264
+cadwyn-3.4.0.dist-info/RECORD,,