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

cadwyn/structure/__init__.py

@@ -6,7 +6,6 @@ from .data import (
 )
 from .endpoints import endpoint
 from .enums import enum
-from .modules import module
 from .schemas import schema
 from .versions import (
     HeadVersion,
@@ -25,7 +24,6 @@ __all__ = [
     "endpoint",
     "schema",
     "enum",
-    "module",
     "convert_response_to_previous_version_for",
     "convert_request_to_next_version_for",
     "RequestInfo",

cadwyn/structure/schemas.py

@@ -1,16 +1,13 @@
-import ast
-import inspect
-import textwrap
 from collections.abc import Callable
-from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, Any, Literal
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, Literal, cast
 
+from issubclass import issubclass as lenient_issubclass
 from pydantic import BaseModel, Field
+from pydantic._internal._decorators import PydanticDescriptorProxy, unwrap_wrapped_function
 from pydantic.fields import FieldInfo
 
-from cadwyn._asts import _ValidatorWrapper, get_validator_info_or_none
-from cadwyn._compat import PYDANTIC_V2
-from cadwyn._utils import Sentinel
+from cadwyn._utils import Sentinel, fully_unwrap_decorator
 from cadwyn.exceptions import CadwynStructureError
 
 if TYPE_CHECKING:
@@ -105,7 +102,6 @@ class FieldDidntExistInstruction:
 class FieldExistedAsInstruction:
     schema: type[BaseModel]
     name: str
-    type: type
     field: FieldInfo
 
 
@@ -148,23 +144,19 @@ class AlterFieldInstructionFactory:
         discriminator: str = Sentinel,
         repr: bool = Sentinel,
     ) -> FieldHadInstruction:
-        if PYDANTIC_V2:
-            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)",
-                )
-        else:
-            if pattern is not Sentinel:
-                raise CadwynStructureError("`pattern` is only available in Pydantic 2. use `regex` instead")
+        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,
@@ -219,30 +211,28 @@ class AlterFieldInstructionFactory:
         type: Any,
         info: FieldInfo | None = None,
     ) -> FieldExistedAsInstruction:
-        return FieldExistedAsInstruction(
-            self.schema,
-            name=self.name,
-            type=type,
-            field=info or Field(),
-        )
+        if info is None:
+            info = cast(FieldInfo, Field())
+        info.annotation = type
+        return FieldExistedAsInstruction(self.schema, name=self.name, field=info)
+
+
+def _get_model_decorators(model: type[BaseModel]):
+    return [
+        *model.__pydantic_decorators__.validators.values(),
+        *model.__pydantic_decorators__.field_validators.values(),
+        *model.__pydantic_decorators__.root_validators.values(),
+        *model.__pydantic_decorators__.field_serializers.values(),
+        *model.__pydantic_decorators__.model_serializers.values(),
+        *model.__pydantic_decorators__.model_validators.values(),
+        *model.__pydantic_decorators__.computed_fields.values(),
+    ]
 
 
 @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
+    validator: Callable[..., Any] | PydanticDescriptorProxy
 
 
 @dataclass(slots=True)
@@ -254,7 +244,7 @@ class ValidatorDidntExistInstruction:
 @dataclass(slots=True)
 class AlterValidatorInstructionFactory:
     schema: type[BaseModel]
-    func: Callable[..., Any]
+    func: Callable[..., Any] | PydanticDescriptorProxy
 
     @property
     def existed(self) -> ValidatorExistedInstruction:
@@ -288,9 +278,20 @@ class AlterSchemaInstructionFactory:
     def field(self, name: str, /) -> AlterFieldInstructionFactory:
         return AlterFieldInstructionFactory(self.schema, name)
 
-    def validator(self, func: "Callable[..., Any] | classmethod[Any, Any, Any]", /) -> AlterValidatorInstructionFactory:
-        if isinstance(func, classmethod):
-            func = func.__wrapped__
+    def validator(
+        self, func: "Callable[..., Any] | classmethod[Any, Any, Any] | PydanticDescriptorProxy", /
+    ) -> AlterValidatorInstructionFactory:
+        func = cast(Callable | PydanticDescriptorProxy, unwrap_wrapped_function(func))
+
+        if not isinstance(func, PydanticDescriptorProxy):
+            if hasattr(func, "__self__"):
+                owner = func.__self__
+                if lenient_issubclass(owner, BaseModel) and any(  # pragma: no branch
+                    fully_unwrap_decorator(decorator.func, decorator.shim) == func
+                    for decorator in _get_model_decorators(owner)
+                ):
+                    return AlterValidatorInstructionFactory(self.schema, func)
+            raise CadwynStructureError("The passed function must be a pydantic validator")
         return AlterValidatorInstructionFactory(self.schema, func)
 
     def had(self, *, name: str) -> SchemaHadInstruction:

cadwyn/structure/versions.py

@@ -2,20 +2,18 @@ import email.message
 import functools
 import inspect
 import json
-import warnings
 from collections import defaultdict
 from collections.abc import Callable, Iterator, Sequence
 from contextlib import AsyncExitStack
 from contextvars import ContextVar
+from datetime import date
 from enum import Enum
-from pathlib import Path
-from types import ModuleType
-from typing import Any, ClassVar, ParamSpec, TypeAlias, TypeVar, cast, overload
+from typing import Any, ClassVar, ParamSpec, TypeAlias, TypeVar
 
 from fastapi import HTTPException, params
 from fastapi import Request as FastapiRequest
 from fastapi import Response as FastapiResponse
-from fastapi._compat import _normalize_errors
+from fastapi._compat import ModelField, _normalize_errors
 from fastapi.concurrency import run_in_threadpool
 from fastapi.dependencies.models import Dependant
 from fastapi.dependencies.utils import solve_dependencies
@@ -23,18 +21,16 @@ from fastapi.exceptions import RequestValidationError
 from fastapi.responses import FileResponse, JSONResponse, StreamingResponse
 from fastapi.routing import APIRoute, _prepare_response_content
 from pydantic import BaseModel
+from pydantic_core import PydanticUndefined
 from starlette._utils import is_async_callable
-from typing_extensions import assert_never, deprecated
-
-from cadwyn._compat import PYDANTIC_V2, ModelField, PydanticUndefined, model_dump
-from cadwyn._package_utils import (
-    IdentifierPythonPath,
-    get_cls_pythonpath,
-    get_package_path_from_module,
-    get_version_dir_path,
+from typing_extensions import assert_never
+
+from cadwyn._utils import classproperty
+from cadwyn.exceptions import (
+    CadwynError,
+    CadwynHeadRequestValidationError,
+    CadwynStructureError,
 )
-from cadwyn._utils import classproperty, get_another_version_of_cls
-from cadwyn.exceptions import CadwynError, CadwynHeadRequestValidationError, CadwynStructureError
 
 from .._utils import Sentinel
 from .common import Endpoint, VersionDate, VersionedModel
@@ -49,7 +45,6 @@ from .data import (
 )
 from .endpoints import AlterEndpointSubInstruction
 from .enums import AlterEnumSubInstruction
-from .modules import AlterModuleInstruction
 from .schemas import AlterSchemaSubInstruction, SchemaHadInstruction
 
 _CADWYN_REQUEST_PARAM_NAME = "cadwyn_request_param"
@@ -61,10 +56,10 @@ PossibleInstructions: TypeAlias = (
     | AlterEndpointSubInstruction
     | AlterEnumSubInstruction
     | SchemaHadInstruction
-    | AlterModuleInstruction
     | staticmethod
 )
 APIVersionVarType: TypeAlias = ContextVar[VersionDate | None] | ContextVar[VersionDate]
+IdentifierPythonPath = str
 
 
 class VersionChange:
@@ -72,7 +67,6 @@ class VersionChange:
     instructions_to_migrate_to_previous_version: ClassVar[Sequence[PossibleInstructions]] = 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
     alter_request_by_schema_instructions: ClassVar[dict[type[BaseModel], list[_AlterRequestBySchemaInstruction]]] = (
         Sentinel
@@ -111,7 +105,6 @@ class VersionChange:
     def _extract_list_instructions_into_correct_containers(cls):
         cls.alter_schema_instructions = []
         cls.alter_enum_instructions = []
-        cls.alter_module_instructions = []
         cls.alter_endpoint_instructions = []
         cls.alter_request_by_schema_instructions = defaultdict(list)
         cls.alter_request_by_path_instructions = defaultdict(list)
@@ -122,8 +115,6 @@ class VersionChange:
                 cls.alter_schema_instructions.append(alter_instruction)
             elif isinstance(alter_instruction, AlterEnumSubInstruction):
                 cls.alter_enum_instructions.append(alter_instruction)
-            elif isinstance(alter_instruction, AlterModuleInstruction):
-                cls.alter_module_instructions.append(alter_instruction)
             elif isinstance(alter_instruction, AlterEndpointSubInstruction):
                 cls.alter_endpoint_instructions.append(alter_instruction)
             elif isinstance(alter_instruction, staticmethod):  # pragma: no cover
@@ -207,9 +198,11 @@ class VersionChangeWithSideEffects(VersionChange, _abstract=True):
 
 
 class Version:
-    def __init__(self, value: VersionDate, *version_changes: type[VersionChange]) -> None:
+    def __init__(self, value: VersionDate | str, *version_changes: type[VersionChange]) -> None:
         super().__init__()
 
+        if isinstance(value, str):
+            value = date.fromisoformat(value)
         self.value = value
         self.version_changes = version_changes
 
@@ -236,36 +229,17 @@ class HeadVersion:
                 )
 
 
-class VersionBundle:
-    @overload
-    def __init__(
-        self,
-        latest_version_or_head_version: Version | HeadVersion,
-        /,
-        *other_versions: Version,
-        api_version_var: APIVersionVarType | None = None,
-        head_schemas_package: ModuleType | None = None,
-    ) -> None: ...
+def get_cls_pythonpath(cls: type) -> IdentifierPythonPath:
+    return f"{cls.__module__}.{cls.__name__}"
 
-    @overload
-    @deprecated("Pass head_version_package instead of latest_schemas_package.")
-    def __init__(
-        self,
-        latest_version_or_head_version: Version | HeadVersion,
-        /,
-        *other_versions: Version,
-        api_version_var: APIVersionVarType | None = None,
-        latest_schemas_package: ModuleType | None = None,
-    ) -> None: ...
 
+class VersionBundle:
     def __init__(
         self,
         latest_version_or_head_version: Version | HeadVersion,
         /,
         *other_versions: Version,
         api_version_var: APIVersionVarType | None = None,
-        head_schemas_package: ModuleType | None = None,
-        latest_schemas_package: ModuleType | None = None,
     ) -> None:
         super().__init__()
 
@@ -276,7 +250,6 @@ class VersionBundle:
             self.head_version = HeadVersion()
             self.versions = (latest_version_or_head_version, *other_versions)
 
-        self.head_schemas_package = head_schemas_package or latest_schemas_package
         self.version_dates = tuple(version.value for version in self.versions)
         if api_version_var is None:
             api_version_var = ContextVar("cadwyn_api_version")
@@ -310,39 +283,9 @@ class VersionBundle:
                     )
                 version_change._bound_version_bundle = self
 
-    @property  # pragma: no cover
-    @deprecated("Use head_version_package instead.")
-    def latest_schemas_package(self):
-        return self.head_schemas_package
-
     def __iter__(self) -> Iterator[Version]:
         yield from self.versions
 
-    def _validate_head_schemas_package_structure(self):
-        # This entire function won't be necessary once we start raising an exception
-        # upon receiving `latest`.
-
-        head_schemas_package = cast(ModuleType, self.head_schemas_package)
-        if not hasattr(head_schemas_package, "__path__"):
-            raise CadwynStructureError(
-                f'The head schemas package must be a package. "{head_schemas_package.__name__}" is not a package.',
-            )
-        elif head_schemas_package.__name__.endswith(".head") or head_schemas_package.__name__ == "head":
-            return "head"
-        elif head_schemas_package.__name__.endswith(".latest"):
-            warnings.warn(
-                'The name of the head schemas module must be "head". '
-                f'Received "{head_schemas_package.__name__}" instead.',
-                DeprecationWarning,
-                stacklevel=4,
-            )
-            return "latest"
-        else:
-            raise CadwynStructureError(
-                'The name of the head schemas module must be "head". '
-                f'Received "{head_schemas_package.__name__}" instead.',
-            )
-
     @functools.cached_property
     def _all_versions(self):
         return (self.head_version, *self.versions)
@@ -374,56 +317,6 @@ class VersionBundle:
             for instruction in version_change.alter_enum_instructions
         }
 
-    @functools.cached_property
-    def versioned_modules(self) -> dict[IdentifierPythonPath, ModuleType]:
-        return {
-            # We do this because when users import their modules, they might import
-            # the __init__.py file directly instead of the package itself
-            # which results in this extra `.__init__` suffix in the name
-            instruction.module.__name__.removesuffix(".__init__"): instruction.module
-            for version in self._all_versions
-            for version_change in version.version_changes
-            for instruction in version_change.alter_module_instructions
-        }
-
-    @functools.cached_property
-    def versioned_directories_with_head(self) -> tuple[Path, ...]:
-        if self.head_schemas_package is None:
-            raise CadwynError(
-                f"You cannot call 'VersionBundle.{self.migrate_response_body.__name__}' because it has no access to "
-                "'head_schemas_package'. It likely means that it was not attached "
-                "to any Cadwyn application which attaches 'head_schemas_package' during initialization."
-            )
-        return tuple(
-            [get_package_path_from_module(self.head_schemas_package)]
-            + [get_version_dir_path(self.head_schemas_package, version.value) for version in self]
-        )
-
-    @functools.cached_property
-    def versioned_directories_without_head(self) -> tuple[Path, ...]:
-        return self.versioned_directories_with_head[1:]
-
-    def migrate_response_body(self, latest_response_model: type[BaseModel], *, latest_body: Any, version: VersionDate):
-        """Convert the data to a specific version by applying all version changes from latest until that version
-        in reverse order and wrapping the result in the correct version of latest_response_model.
-        """
-        response = ResponseInfo(FastapiResponse(status_code=200), body=latest_body)
-        migrated_response = self._migrate_response(
-            response,
-            current_version=version,
-            head_response_model=latest_response_model,
-            path="\0\0\0",
-            method="GET",
-        )
-
-        version = self._get_closest_lesser_version(version)
-        version_dir = self.versioned_directories_without_head[self.version_dates.index(version)]
-
-        versioned_response_model: type[BaseModel] = get_another_version_of_cls(
-            latest_response_model, version_dir, self.versioned_directories_with_head
-        )
-        return versioned_response_model.parse_obj(migrated_response.body)  # pyright: ignore[reportDeprecated]
-
     def _get_closest_lesser_version(self, version: VersionDate):
         for defined_version in self.version_dates:
             if defined_version <= version:
@@ -449,8 +342,6 @@ class VersionBundle:
         current_version: VersionDate,
         head_route: APIRoute,
         exit_stack: AsyncExitStack,
-        *,
-        embed_body_fields: bool,
     ) -> dict[str, Any]:
         method = request.method
         for v in reversed(self.versions):
@@ -467,20 +358,19 @@ class VersionBundle:
         request.scope["headers"] = tuple((key.encode(), value.encode()) for key, value in request_info.headers.items())
         del request._headers
         # Remember this: if len(body_params) == 1, then route.body_schema == route.dependant.body_params[0]
-        result = await solve_dependencies(
+        dependencies, errors, _, _, _ = await solve_dependencies(
             request=request,
             response=response,
             dependant=head_dependant,
             body=request_info.body,
             dependency_overrides_provider=head_route.dependency_overrides_provider,
             async_exit_stack=exit_stack,
-            embed_body_fields=embed_body_fields,
         )
-        if result.errors:
+        if errors:
             raise CadwynHeadRequestValidationError(
-                _normalize_errors(result.errors), body=request_info.body, version=current_version
+                _normalize_errors(errors), body=request_info.body, version=current_version
             )
-        return result.values
+        return dependencies
 
     def _migrate_response(
         self,
@@ -580,7 +470,7 @@ class VersionBundle:
             if response_param_name == _CADWYN_RESPONSE_PARAM_NAME:
                 _add_keyword_only_parameter(decorator, _CADWYN_RESPONSE_PARAM_NAME, FastapiResponse)
 
-            return decorator  # pyright: ignore[reportReturnType]
+            return decorator
 
         return wrapper
 
@@ -740,9 +630,7 @@ class VersionBundle:
             elif not isinstance(raw_body, BaseModel):
                 body = raw_body
             else:
-                body = model_dump(raw_body, by_alias=True, exclude_unset=True)
-                if not PYDANTIC_V2 and raw_body.__custom_root_type__:  # pyright: ignore[reportAttributeAccessIssue]
-                    body = body["__root__"]
+                body = raw_body.model_dump(by_alias=True, exclude_unset=True)
         else:
             # This is for requests without body or with complex body such as form or file
             body = await _get_body(request, route.body_field, exit_stack)
@@ -758,7 +646,6 @@ class VersionBundle:
             api_version,
             head_route,
             exit_stack=exit_stack,
-            embed_body_fields=route._embed_body_fields,
         )
         # Because we re-added it into our kwargs when we did solve_dependencies
         if _CADWYN_REQUEST_PARAM_NAME in new_kwargs:

{cadwyn-3.15.9.dist-info → cadwyn-4.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cadwyn
-Version: 3.15.9
+Version: 4.0.0
 Summary: Production-ready community-driven modern Stripe-like API versioning in FastAPI
 Home-page: https://github.com/zmievsa/cadwyn
 License: MIT
@@ -32,12 +32,11 @@ Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Typing :: Typed
 Provides-Extra: cli
-Requires-Dist: better-ast-comments (>=1.2.1,<1.3.0)
-Requires-Dist: fastapi (>=0.115.2)
+Requires-Dist: fastapi (>=0.110.0)
 Requires-Dist: issubclass (>=0.1.2,<0.2.0)
 Requires-Dist: jinja2 (>=3.1.2)
-Requires-Dist: pydantic (>=1.0.0)
-Requires-Dist: starlette (>=0.36.3)
+Requires-Dist: pydantic (>=2.0.0)
+Requires-Dist: starlette (>=0.30.0)
 Requires-Dist: typer (>=0.7.0) ; extra == "cli"
 Requires-Dist: typing-extensions
 Project-URL: Documentation, https://docs.cadwyn.dev

cadwyn-4.0.0.dist-info/RECORD

@@ -0,0 +1,27 @@
+cadwyn/__init__.py,sha256=N98kE6Eb7g7mH-YW1XuAqb084W2NKvPhA1cUs_O0nak,930
+cadwyn/__main__.py,sha256=fGoKJPNVueqqXW4rqwmRUBBMoDGeLEyATdT-rel5Pvs,2449
+cadwyn/_asts.py,sha256=kNDXS0Ju0pYZyohAmJNVgJpspwKai5_a9tbekkGehUE,5130
+cadwyn/_importer.py,sha256=2mZrDHlfY2heZsMBW-9RBpvKsCk9I-Wa8pxZ6f2f8gY,1074
+cadwyn/_render.py,sha256=-eY4zMzBEJPteDF_CRwJah5DWFmUl2zHQHrb21mcfb8,5482
+cadwyn/_utils.py,sha256=GK9w_qzyOI_o6UaGVfwLLYhnJFMzXistoYI9fq2E9dE,1159
+cadwyn/applications.py,sha256=g4VlB3SzQMjfAq5vX8u6DYj2OZei2oGBffSUTVVyaAA,14478
+cadwyn/exceptions.py,sha256=VlJKRmEGfFTDtHbOWc8kXK4yMi2N172K684Y2UIV8rI,1832
+cadwyn/middleware.py,sha256=8cuBri_yRkl0goe6G0MLwtL04WGbW9Infah3wy9hUVM,3372
+cadwyn/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cadwyn/route_generation.py,sha256=GiCUCAKFQoIID3Zv5dYGTIbsGu3TSxDnB62ZUH-Mh58,22961
+cadwyn/routing.py,sha256=9AHSojmuLgUAQlLMIqXz-ViZ9n-fljgOsn7oxha7PjM,7341
+cadwyn/schema_generation.py,sha256=SZoP0IPgVdlJ015ItW5dxwvlWYcA41Lx1pQzCOwV7TE,39386
+cadwyn/static/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cadwyn/static/docs.html,sha256=WNm5ANJVy51TcIUFOaqKf1Z8eF86CC85TTHPxACtkzw,3455
+cadwyn/structure/__init__.py,sha256=vej7TdTMSOg8U8Wk7GTNdA4rc6loA9083FWaTg4jAaY,655
+cadwyn/structure/common.py,sha256=6Z4nI97XPWTCinn6np73m-rLPyYNrz2fWXKJlqjsiaQ,269
+cadwyn/structure/data.py,sha256=1ALPhBBCE_t4GrxM0Fa3hQ-jkORJgeWNySnZ42bsi0g,7382
+cadwyn/structure/endpoints.py,sha256=JhTgVrqLjm5LkE9thjvU1UuWcSCmDgW2bMdqznsZb2Y,5777
+cadwyn/structure/enums.py,sha256=iMokxA2QYJ61SzyB-Pmuq3y7KL7-e6TsnjLVUaVZQnw,954
+cadwyn/structure/schemas.py,sha256=dfVeVL6R6RjcNeehbd4yPlCYCkpiHi0Ujrwkq4pCvd8,9285
+cadwyn/structure/versions.py,sha256=3SXzQD9Ps3jukF6prhGTABUAik70jd7KebTApY8B3Ns,32190
+cadwyn-4.0.0.dist-info/LICENSE,sha256=KeCWewiDQYpmSnzF-p_0YpoWiyDcUPaCuG8OWQs4ig4,1072
+cadwyn-4.0.0.dist-info/METADATA,sha256=0Exz0MGTvNEndoEkQ4xJ8Nn_c3Puk52utPDTJtrCIx0,4344
+cadwyn-4.0.0.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
+cadwyn-4.0.0.dist-info/entry_points.txt,sha256=eO05hLn9GoRzzpwT9GONPmXKsonjuMNssM2D2WHWKGk,46
+cadwyn-4.0.0.dist-info/RECORD,,

cadwyn/_compat.py

@@ -1,151 +0,0 @@
-import ast
-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[reportRedeclaration]
-PydanticUndefined: TypeAlias = Any
-VALIDATOR_CONFIG_KEY = "__validators__"
-
-try:
-    PYDANTIC_V2 = False
-
-    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"
-except ImportError:
-    PYDANTIC_V2 = True
-
-    from pydantic.fields import FieldInfo
-    from pydantic_core import PydanticUndefined  # pyright: ignore # noqa: PGH003
-
-    ModelField: TypeAlias = FieldInfo  # pyright: ignore # noqa: PGH003
-    _all_field_arg_names = sorted(
-        [
-            name
-            for name, param in inspect.signature(Field).parameters.items()
-            if param.kind in {inspect._ParameterKind.KEYWORD_ONLY, inspect._ParameterKind.POSITIONAL_OR_KEYWORD}
-        ],
-    )
-    EXTRA_FIELD_NAME = "json_schema_extra"
-
-
-_empty_field_info = Field()
-dict_of_empty_field_info = {k: getattr(_empty_field_info, k) for k in FieldInfo.__slots__}
-
-
-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 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]
-    field_info: FieldInfo = dataclasses.field(init=False)
-
-    annotation_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):
-        if isinstance(init_model_field, FieldInfo):
-            self.field_info = init_model_field
-        else:
-            self.field_info = init_model_field.field_info
-
-    def update_attribute(self, *, name: str, value: Any):
-        if PYDANTIC_V2:
-            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:
-            attributes = {
-                attr_name: self.field_info._attributes_set[attr_name]
-                for attr_name in _all_field_arg_names
-                if attr_name in self.field_info._attributes_set
-            }
-            # PydanticV2 always adds frozen to _attributes_set but we don't want it if it wasn't explicitly set
-            if attributes.get("frozen", ...) is None:
-                attributes.pop("frozen")
-            return attributes
-
-        else:
-            attributes = {
-                attr_name: attr_val
-                for attr_name, default_attr_val in dict_of_empty_field_info.items()
-                if attr_name != EXTRA_FIELD_NAME
-                and (attr_val := getattr(self.field_info, attr_name)) != default_attr_val
-            }
-            extras = getattr(self.field_info, EXTRA_FIELD_NAME) or {}
-            return attributes | extras
-
-
-def get_annotation_from_model_field(model: ModelField) -> Any:
-    if PYDANTIC_V2:
-        return model.field_info.annotation
-    else:
-        return model.annotation
-
-
-def model_fields(model: type[BaseModel]) -> dict[str, FieldInfo]:
-    if PYDANTIC_V2:
-        return model.model_fields
-    else:
-        return model.__fields__  # pyright: ignore[reportDeprecated]
-
-
-def model_dump(model: BaseModel, by_alias: bool = False, exclude_unset: bool = False) -> dict[str, Any]:
-    if PYDANTIC_V2:
-        return model.model_dump(by_alias=by_alias, exclude_unset=exclude_unset)
-    else:
-        return model.dict(by_alias=by_alias, exclude_unset=exclude_unset)  # pyright: ignore[reportDeprecated]
-
-
-def rebuild_fastapi_body_param(old_body_param: FastAPIModelField, new_body_param_type: type[BaseModel]):
-    kwargs: dict[str, Any] = {"name": old_body_param.name, "field_info": old_body_param.field_info}
-    if PYDANTIC_V2:
-        old_body_param.field_info.annotation = new_body_param_type
-        kwargs.update({"mode": old_body_param.mode})
-    else:
-        kwargs.update(
-            {
-                "type_": new_body_param_type,
-                "class_validators": old_body_param.class_validators,  # pyright: ignore[reportAttributeAccessIssue]
-                "default": old_body_param.default,
-                "required": old_body_param.required,
-                "model_config": old_body_param.model_config,  # pyright: ignore[reportAttributeAccessIssue]
-                "alias": old_body_param.alias,
-            },
-        )
-    return FastAPIModelField(**kwargs)