cadwyn 4.0.0__py3-none-any.whl → 4.2.0__py3-none-any.whl

cadwyn/schema_generation.py

@@ -20,6 +20,7 @@ from typing import (
     final,
     get_args,
     get_origin,
+    overload,
 )
 
 import fastapi.params
@@ -104,6 +105,8 @@ class PydanticFieldWrapper:
     init_model_field: dataclasses.InitVar[FieldInfo]
 
     annotation: Any
+    name_from_newer_version: str
+
     passed_field_attributes: dict[str, Any] = dataclasses.field(init=False)
 
     def __post_init__(self, init_model_field: FieldInfo):
@@ -115,7 +118,7 @@ class PydanticFieldWrapper:
     def delete_attribute(self, *, name: str) -> None:
         self.passed_field_attributes.pop(name)
 
-    def generate_field_copy(self, generator: "_SchemaGenerator") -> pydantic.fields.FieldInfo:
+    def generate_field_copy(self, generator: "SchemaGenerator") -> pydantic.fields.FieldInfo:
         return pydantic.Field(
             **generator.annotation_transformer.change_version_of_annotation(self.passed_field_attributes)
         )
@@ -136,7 +139,7 @@ def _extract_passed_field_attributes(field_info: FieldInfo):
 @dataclasses.dataclass(slots=True)
 class _ModelBundle:
     enums: dict[type[Enum], "_EnumWrapper"]
-    schemas: dict[type[BaseModel], "_PydanticRuntimeModelWrapper"]
+    schemas: dict[type[BaseModel], "_PydanticModelWrapper"]
 
 
 @dataclasses.dataclass(slots=True, kw_only=True)
@@ -173,7 +176,7 @@ def migrate_response_body(
 
     version = versions._get_closest_lesser_version(version)
 
-    versioned_response_model: type[pydantic.BaseModel] = _generate_versioned_models(versions)[str(version)][
+    versioned_response_model: type[pydantic.BaseModel] = generate_versioned_models(versions)[str(version)][
         latest_response_model
     ]
     return versioned_response_model.model_validate(migrated_response.body)
@@ -222,7 +225,7 @@ def _is_dunder(attr_name: str):
     return attr_name.startswith("__") and attr_name.endswith("__")
 
 
-def _wrap_pydantic_model(model: type[_T_PYDANTIC_MODEL]) -> "_PydanticRuntimeModelWrapper[_T_PYDANTIC_MODEL]":
+def _wrap_pydantic_model(model: type[_T_PYDANTIC_MODEL]) -> "_PydanticModelWrapper[_T_PYDANTIC_MODEL]":
     decorators = _get_model_decorators(model)
     validators = {}
     for decorator_wrapper in decorators:
@@ -232,7 +235,7 @@ def _wrap_pydantic_model(model: type[_T_PYDANTIC_MODEL]) -> "_PydanticRuntimeMod
         wrapped_validator = _wrap_validator(decorator_wrapper.func, decorator_wrapper.shim, decorator_wrapper.info)
         validators[decorator_wrapper.cls_var_name] = wrapped_validator
     fields = {
-        field_name: PydanticFieldWrapper(model.model_fields[field_name], model.__annotations__[field_name])
+        field_name: PydanticFieldWrapper(model.model_fields[field_name], model.__annotations__[field_name], field_name)
         for field_name in model.__annotations__
     }
 
@@ -248,7 +251,7 @@ def _wrap_pydantic_model(model: type[_T_PYDANTIC_MODEL]) -> "_PydanticRuntimeMod
         "__module__": model.__module__,
         "__qualname__": model.__qualname__,
     }
-    return _PydanticRuntimeModelWrapper(
+    return _PydanticModelWrapper(
         model,
         name=model.__name__,
         doc=model.__doc__,
@@ -261,20 +264,20 @@ def _wrap_pydantic_model(model: type[_T_PYDANTIC_MODEL]) -> "_PydanticRuntimeMod
 
 @final
 @dataclasses.dataclass(slots=True)
-class _PydanticRuntimeModelWrapper(Generic[_T_PYDANTIC_MODEL]):
-    cls: type[_T_PYDANTIC_MODEL]
+class _PydanticModelWrapper(Generic[_T_PYDANTIC_MODEL]):
+    cls: type[_T_PYDANTIC_MODEL] = dataclasses.field(repr=False)
     name: str
-    doc: str | None
+    doc: str | None = dataclasses.field(repr=False)
     fields: Annotated[
         dict["_FieldName", PydanticFieldWrapper],
         Doc(
             "Fields that belong to this model, not to its parents. I.e. The ones that were either defined or overriden "
         ),
-    ]
-    validators: dict[str, _PerFieldValidatorWrapper | _ValidatorWrapper]
-    other_attributes: dict[str, Any]
-    annotations: dict[str, Any]
-    _parents: list[Self] | None = dataclasses.field(init=False, default=None)
+    ] = dataclasses.field(repr=False)
+    validators: dict[str, _PerFieldValidatorWrapper | _ValidatorWrapper] = dataclasses.field(repr=False)
+    other_attributes: dict[str, Any] = dataclasses.field(repr=False)
+    annotations: dict[str, Any] = dataclasses.field(repr=False)
+    _parents: list[Self] | None = dataclasses.field(init=False, default=None, repr=False)
 
     def __post_init__(self):
         # This isn't actually supposed to run, it's just a precaution
@@ -291,7 +294,7 @@ class _PydanticRuntimeModelWrapper(Generic[_T_PYDANTIC_MODEL]):
                 )
 
     def __deepcopy__(self, memo: dict[int, Any]):
-        result = _PydanticRuntimeModelWrapper(
+        result = _PydanticModelWrapper(
             self.cls,
             name=self.name,
             doc=self.doc,
@@ -303,6 +306,9 @@ class _PydanticRuntimeModelWrapper(Generic[_T_PYDANTIC_MODEL]):
         memo[id(self)] = result
         return result
 
+    def __hash__(self) -> int:
+        return hash(id(self))
+
     def _get_parents(self, schemas: "dict[type, Self]"):
         if self._parents is not None:
             return self._parents
@@ -331,7 +337,7 @@ class _PydanticRuntimeModelWrapper(Generic[_T_PYDANTIC_MODEL]):
 
         return annotations | self.annotations
 
-    def generate_model_copy(self, generator: "_SchemaGenerator") -> type[_T_PYDANTIC_MODEL]:
+    def generate_model_copy(self, generator: "SchemaGenerator") -> type[_T_PYDANTIC_MODEL]:
         per_field_validators = {
             name: validator.decorator(*validator.fields, **validator.kwargs)(validator.func)
             for name, validator in self.validators.items()
@@ -345,7 +351,7 @@ class _PydanticRuntimeModelWrapper(Generic[_T_PYDANTIC_MODEL]):
         fields = {name: field.generate_field_copy(generator) for name, field in self.fields.items()}
         model_copy = type(self.cls)(
             self.name,
-            tuple(generator[base] for base in self.cls.__bases__),
+            tuple(generator[cast(type[BaseModel], base)] for base in self.cls.__bases__),
             self.other_attributes
             | per_field_validators
             | root_validators
@@ -398,7 +404,7 @@ class _AsyncCallableWrapper(_CallableWrapper):
 
 @final
 class _AnnotationTransformer:
-    def __init__(self, generator: "_SchemaGenerator") -> None:
+    def __init__(self, generator: "SchemaGenerator") -> None:
         # This cache is not here for speeding things up. It's for preventing the creation of copies of the same object
         # because such copies could produce weird behaviors at runtime, especially if you/fastapi do any comparisons.
         # It's defined here and not on the method because of this: https://youtu.be/sVjtp6tGo0g
@@ -587,7 +593,7 @@ def _add_request_and_response_params(route: APIRoute):
 
 
 @final
-class _SchemaGenerator:
+class SchemaGenerator:
     __slots__ = "annotation_transformer", "model_bundle", "concrete_models"
 
     def __init__(self, model_bundle: _ModelBundle) -> None:
@@ -599,9 +605,9 @@ class _SchemaGenerator:
             for k, wrapper in (self.model_bundle.schemas | self.model_bundle.enums).items()
         }
 
-    def __getitem__(self, model: type, /) -> Any:
+    def __getitem__(self, model: type[_T_ANY_MODEL], /) -> type[_T_ANY_MODEL]:
         if not isinstance(model, type) or not issubclass(model, BaseModel | Enum) or model in (BaseModel, RootModel):
-            return model
+            return model  # pyright: ignore[reportReturnType]
         model = _unwrap_model(model)
 
         if model in self.concrete_models:
@@ -614,9 +620,14 @@ class _SchemaGenerator:
         self.concrete_models[model] = model_copy
         return model_copy
 
+    @overload
+    def _get_wrapper_for_model(self, model: type[BaseModel]) -> "_PydanticModelWrapper[BaseModel]": ...
+    @overload
+    def _get_wrapper_for_model(self, model: type[Enum]) -> "_EnumWrapper[Enum]": ...
+
     def _get_wrapper_for_model(
         self, model: type[BaseModel | Enum]
-    ) -> "_PydanticRuntimeModelWrapper[BaseModel] | _EnumWrapper[Enum]":
+    ) -> "_PydanticModelWrapper[BaseModel] | _EnumWrapper[Enum]":
         model = _unwrap_model(model)
 
         if model in self.model_bundle.schemas:
@@ -636,7 +647,7 @@ class _SchemaGenerator:
 
 
 @cache
-def _generate_versioned_models(versions: "VersionBundle") -> "dict[str, _SchemaGenerator]":
+def generate_versioned_models(versions: "VersionBundle") -> "dict[str, SchemaGenerator]":
     models = _create_model_bundle(versions)
 
     version_to_context_map = {}
@@ -645,7 +656,7 @@ def _generate_versioned_models(versions: "VersionBundle") -> "dict[str, _SchemaG
 
     for version in versions.versions:
         context = _RuntimeSchemaGenContext(current_version=version, models=models, version_bundle=versions)
-        version_to_context_map[str(version.value)] = _SchemaGenerator(copy.deepcopy(models))
+        version_to_context_map[str(version.value)] = SchemaGenerator(copy.deepcopy(models))
         # note that the last migration will not contain any version changes so we don't need to save the results
         _migrate_classes(context)
 
@@ -660,7 +671,7 @@ def _create_model_bundle(versions: "VersionBundle"):
 
 
 def _migrate_classes(context: _RuntimeSchemaGenContext) -> None:
-    for version_change in context.current_version.version_changes:
+    for version_change in context.current_version.changes:
         _apply_alter_schema_instructions(
             context.models.schemas,
             version_change.alter_schema_instructions,
@@ -674,7 +685,7 @@ def _migrate_classes(context: _RuntimeSchemaGenContext) -> None:
 
 
 def _apply_alter_schema_instructions(
-    modified_schemas: dict[type, _PydanticRuntimeModelWrapper],
+    modified_schemas: dict[type, _PydanticModelWrapper],
     alter_schema_instructions: Sequence[AlterSchemaSubInstruction | SchemaHadInstruction],
     version_change_name: str,
 ) -> None:
@@ -747,7 +758,7 @@ def _apply_alter_enum_instructions(
 
 
 def _change_model(
-    model: _PydanticRuntimeModelWrapper,
+    model: _PydanticModelWrapper,
     alter_schema_instruction: SchemaHadInstruction,
     version_change_name: str,
 ):
@@ -761,8 +772,8 @@ def _change_model(
 
 
 def _add_field_to_model(
-    model: _PydanticRuntimeModelWrapper,
-    schemas: "dict[type, _PydanticRuntimeModelWrapper]",
+    model: _PydanticModelWrapper,
+    schemas: "dict[type, _PydanticModelWrapper]",
     alter_schema_instruction: FieldExistedAsInstruction,
     version_change_name: str,
 ):
@@ -773,14 +784,16 @@ def _add_field_to_model(
             f'in "{version_change_name}" but there is already a field with that name.',
         )
 
-    field = PydanticFieldWrapper(alter_schema_instruction.field, alter_schema_instruction.field.annotation)
+    field = PydanticFieldWrapper(
+        alter_schema_instruction.field, alter_schema_instruction.field.annotation, alter_schema_instruction.name
+    )
     model.fields[alter_schema_instruction.name] = field
     model.annotations[alter_schema_instruction.name] = alter_schema_instruction.field.annotation
 
 
 def _change_field_in_model(
-    model: _PydanticRuntimeModelWrapper,
-    schemas: "dict[type, _PydanticRuntimeModelWrapper]",
+    model: _PydanticModelWrapper,
+    schemas: "dict[type, _PydanticModelWrapper]",
     alter_schema_instruction: FieldHadInstruction | FieldDidntHaveInstruction,
     version_change_name: str,
 ):
@@ -817,7 +830,7 @@ def _change_field_in_model(
 
 
 def _change_field(
-    model: _PydanticRuntimeModelWrapper,
+    model: _PydanticModelWrapper,
     alter_schema_instruction: FieldHadInstruction,
     version_change_name: str,
     defined_annotations: dict[str, Any],
@@ -861,7 +874,7 @@ def _change_field(
 
 
 def _delete_field_attributes(
-    model: _PydanticRuntimeModelWrapper,
+    model: _PydanticModelWrapper,
     alter_schema_instruction: FieldDidntHaveInstruction,
     version_change_name: str,
     field: PydanticFieldWrapper,
@@ -884,7 +897,7 @@ def _delete_field_attributes(
             )
 
 
-def _delete_field_from_model(model: _PydanticRuntimeModelWrapper, field_name: str, version_change_name: str):
+def _delete_field_from_model(model: _PydanticModelWrapper, field_name: str, version_change_name: str):
     if field_name not in model.fields:
         raise InvalidGenerationInstructionError(
             f'You tried to delete a field "{field_name}" from "{model.name}" '
@@ -906,10 +919,11 @@ class _DummyEnum(Enum):
 
 @final
 class _EnumWrapper(Generic[_T_ENUM]):
-    __slots__ = "cls", "members"
+    __slots__ = "cls", "members", "name"
 
     def __init__(self, cls: type[_T_ENUM]):
         self.cls = _unwrap_model(cls)
+        self.name = cls.__name__
         self.members = {member.name: member.value for member in cls}
 
     def __deepcopy__(self, memo: Any):
@@ -918,14 +932,14 @@ class _EnumWrapper(Generic[_T_ENUM]):
         memo[id(self)] = result
         return result
 
-    def generate_model_copy(self, generator: "_SchemaGenerator") -> type[_T_ENUM]:
-        enum_dict = Enum.__prepare__(self.cls.__name__, self.cls.__bases__)
+    def generate_model_copy(self, generator: "SchemaGenerator") -> type[_T_ENUM]:
+        enum_dict = Enum.__prepare__(self.name, self.cls.__bases__)
 
         raw_member_map = {k: v.value if isinstance(v, Enum) else v for k, v in self.members.items()}
         initialization_namespace = self._get_initialization_namespace_for_enum(self.cls) | raw_member_map
         for attr_name, attr in initialization_namespace.items():
             enum_dict[attr_name] = attr
-        model_copy = cast(type[_T_ENUM], type(self.cls.__name__, self.cls.__bases__, enum_dict))
+        model_copy = cast(type[_T_ENUM], type(self.name, self.cls.__bases__, enum_dict))
         model_copy.__cadwyn_original_model__ = self.cls  # pyright: ignore[reportAttributeAccessIssue]
         return model_copy
 

cadwyn/structure/common.py

@@ -1,5 +1,6 @@
 import datetime
 from collections.abc import Callable
+from dataclasses import dataclass
 from typing import ParamSpec, TypeAlias, TypeVar
 
 from pydantic import BaseModel
@@ -9,3 +10,8 @@ VersionDate = datetime.date
 _P = ParamSpec("_P")
 _R = TypeVar("_R")
 Endpoint: TypeAlias = Callable[_P, _R]
+
+
+@dataclass(slots=True, kw_only=True)
+class _HiddenAttributeMixin:
+    is_hidden_from_changelog: bool = False

cadwyn/structure/endpoints.py

@@ -11,6 +11,7 @@ from starlette.routing import BaseRoute
 from cadwyn.exceptions import LintingError
 
 from .._utils import Sentinel
+from .common import _HiddenAttributeMixin
 
 HTTP_METHODS = {"GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS", "HEAD"}
 
@@ -44,7 +45,7 @@ class EndpointAttributesPayload:
     response_description: str
     responses: dict[int | str, dict[str, Any]]
     deprecated: bool
-    methods: list[str]
+    methods: set[str]
     operation_id: str
     include_in_schema: bool
     response_class: type[Response]
@@ -55,7 +56,7 @@ class EndpointAttributesPayload:
 
 
 @dataclass(slots=True)
-class EndpointHadInstruction:
+class EndpointHadInstruction(_HiddenAttributeMixin):
     endpoint_path: str
     endpoint_methods: set[str]
     endpoint_func_name: str | None
@@ -63,14 +64,14 @@ class EndpointHadInstruction:
 
 
 @dataclass(slots=True)
-class EndpointExistedInstruction:
+class EndpointExistedInstruction(_HiddenAttributeMixin):
     endpoint_path: str
     endpoint_methods: set[str]
     endpoint_func_name: str | None
 
 
 @dataclass(slots=True)
-class EndpointDidntExistInstruction:
+class EndpointDidntExistInstruction(_HiddenAttributeMixin):
     endpoint_path: str
     endpoint_methods: set[str]
     endpoint_func_name: str | None
@@ -135,7 +136,7 @@ class EndpointInstructionFactory:
                 response_description=response_description,
                 responses=responses,
                 deprecated=deprecated,
-                methods=methods,
+                methods=set(methods) if methods is not Sentinel else Sentinel,
                 operation_id=operation_id,
                 include_in_schema=include_in_schema,
                 response_class=response_class,

cadwyn/structure/enums.py

@@ -3,15 +3,17 @@ from dataclasses import dataclass
 from enum import Enum
 from typing import Any
 
+from .common import _HiddenAttributeMixin
+
 
 @dataclass(slots=True)
-class EnumHadMembersInstruction:
+class EnumHadMembersInstruction(_HiddenAttributeMixin):
     enum: type[Enum]
     members: Mapping[str, Any]
 
 
 @dataclass(slots=True)
-class EnumDidntHaveMembersInstruction:
+class EnumDidntHaveMembersInstruction(_HiddenAttributeMixin):
     enum: type[Enum]
     members: tuple[str, ...]
 

cadwyn/structure/schemas.py

@@ -10,6 +10,8 @@ from pydantic.fields import FieldInfo
 from cadwyn._utils import Sentinel, fully_unwrap_decorator
 from cadwyn.exceptions import CadwynStructureError
 
+from .common import _HiddenAttributeMixin
+
 if TYPE_CHECKING:
     from pydantic.typing import AbstractSetIntStr, MappingIntStrAny
 
@@ -21,24 +23,21 @@ PossibleFieldAttributes = Literal[
     "title",
     "description",
     "exclude",
-    "include",
     "const",
     "gt",
     "ge",
     "lt",
     "le",
+    "deprecated",
+    "fail_fast",
     "strict",
     "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",
@@ -53,8 +52,9 @@ class FieldChanges:
     title: str
     description: str
     exclude: "AbstractSetIntStr | MappingIntStrAny | Any"
-    include: "AbstractSetIntStr | MappingIntStrAny | Any"
     const: bool
+    deprecated: bool
+    fail_fast: bool
     gt: float
     ge: float
     lt: float
@@ -64,20 +64,16 @@ class FieldChanges:
     allow_inf_nan: bool
     max_digits: int
     decimal_places: int
-    min_items: int
-    max_items: int
-    unique_items: bool
     min_length: int
     max_length: int
     allow_mutation: bool
-    regex: str
     pattern: str
     discriminator: str
     repr: bool
 
 
 @dataclass(slots=True)
-class FieldHadInstruction:
+class FieldHadInstruction(_HiddenAttributeMixin):
     schema: type[BaseModel]
     name: str
     type: type
@@ -86,20 +82,20 @@ class FieldHadInstruction:
 
 
 @dataclass(slots=True)
-class FieldDidntHaveInstruction:
+class FieldDidntHaveInstruction(_HiddenAttributeMixin):
     schema: type[BaseModel]
     name: str
     attributes: tuple[str, ...]
 
 
 @dataclass(slots=True)
-class FieldDidntExistInstruction:
+class FieldDidntExistInstruction(_HiddenAttributeMixin):
     schema: type[BaseModel]
     name: str
 
 
 @dataclass(slots=True)
-class FieldExistedAsInstruction:
+class FieldExistedAsInstruction(_HiddenAttributeMixin):
     schema: type[BaseModel]
     name: str
     field: FieldInfo
@@ -122,41 +118,25 @@ class AlterFieldInstructionFactory:
         title: str = Sentinel,
         description: str = Sentinel,
         exclude: "AbstractSetIntStr | MappingIntStrAny | Any" = Sentinel,
-        include: "AbstractSetIntStr | MappingIntStrAny | Any" = Sentinel,
         const: bool = Sentinel,
         gt: float = Sentinel,
         ge: float = Sentinel,
         lt: float = Sentinel,
         le: float = Sentinel,
         strict: bool = Sentinel,
+        deprecated: bool = Sentinel,
         multiple_of: float = Sentinel,
         allow_inf_nan: bool = Sentinel,
         max_digits: int = Sentinel,
         decimal_places: int = Sentinel,
-        min_items: int = Sentinel,
-        max_items: int = Sentinel,
-        unique_items: bool = Sentinel,
         min_length: int = Sentinel,
         max_length: int = Sentinel,
         allow_mutation: bool = Sentinel,
-        regex: str = Sentinel,
         pattern: str = Sentinel,
         discriminator: str = Sentinel,
         repr: bool = Sentinel,
+        fail_fast: bool = Sentinel,
     ) -> FieldHadInstruction:
-        if regex is not Sentinel:
-            raise CadwynStructureError("`regex` was removed in Pydantic 2. Use `pattern` instead")
-        if include is not Sentinel:
-            raise CadwynStructureError("`include` was removed in Pydantic 2. Use `exclude` instead")
-        if min_items is not Sentinel:
-            raise CadwynStructureError("`min_items` was removed in Pydantic 2. Use `min_length` instead")
-        if max_items is not Sentinel:
-            raise CadwynStructureError("`max_items` was removed in Pydantic 2. Use `max_length` instead")
-        if unique_items is not Sentinel:
-            raise CadwynStructureError(
-                "`unique_items` was removed in Pydantic 2. Use `Set` type annotation instead"
-                "(this feature is discussed in https://github.com/pydantic/pydantic-core/issues/296)",
-            )
         return FieldHadInstruction(
             schema=self.schema,
             name=self.name,
@@ -169,27 +149,24 @@ class AlterFieldInstructionFactory:
                 title=title,
                 description=description,
                 exclude=exclude,
-                include=include,
                 const=const,
                 gt=gt,
                 ge=ge,
                 lt=lt,
                 le=le,
+                deprecated=deprecated,
                 strict=strict,
                 multiple_of=multiple_of,
                 allow_inf_nan=allow_inf_nan,
                 max_digits=max_digits,
                 decimal_places=decimal_places,
-                min_items=min_items,
-                max_items=max_items,
-                unique_items=unique_items,
                 min_length=min_length,
                 max_length=max_length,
                 allow_mutation=allow_mutation,
-                regex=regex,
                 pattern=pattern,
                 discriminator=discriminator,
                 repr=repr,
+                fail_fast=fail_fast,
             ),
         )
 
@@ -266,7 +243,7 @@ AlterSchemaSubInstruction = (
 
 
 @dataclass(slots=True)
-class SchemaHadInstruction:
+class SchemaHadInstruction(_HiddenAttributeMixin):
     schema: type[BaseModel]
     name: str