cadwyn 3.15.10__py3-none-any.whl → 4.1.0__py3-none-any.whl

cadwyn/_utils.py

@@ -1,13 +1,7 @@
-import functools
-import importlib
-import inspect
-import sys
-from collections.abc import Callable, Collection
-from pathlib import Path
-from types import ModuleType
+from collections.abc import Callable
 from typing import Any, Generic, TypeVar, Union
 
-from cadwyn.exceptions import CadwynError, ModuleIsNotVersionedError
+from pydantic._internal._decorators import unwrap_wrapped_function
 
 Sentinel: Any = object()
 UnionType = type(int | str) | type(Union[int, str])
@@ -41,102 +35,8 @@ def same_definition_as_in(t: _T) -> Callable[[Callable], _T]:
     return decorator
 
 
-@functools.cache
-def get_another_version_of_cls(
-    cls_from_old_version: type[Any], new_version_dir: Path, version_dirs: frozenset[Path] | tuple[Path, ...]
-):
-    # version_dir = /home/myuser/package/companies/v2021_01_01
-    module_from_old_version = sys.modules[cls_from_old_version.__module__]
-    try:
-        module = get_another_version_of_module(module_from_old_version, new_version_dir, version_dirs)
-    except ModuleIsNotVersionedError:
-        return cls_from_old_version
-    return getattr(module, cls_from_old_version.__name__)
-
-
-def get_another_version_of_module(
-    module_from_old_version: ModuleType,
-    new_version_dir: Path,
-    version_dirs: frozenset[Path] | tuple[Path, ...],
-):
-    new_model_module_python_path = get_pythonpath_to_another_version_of_module(
-        module_from_old_version,
-        new_version_dir,
-        version_dirs,
-    )
-    return importlib.import_module(new_model_module_python_path)
-
-
-def get_pythonpath_to_another_version_of_module(
-    module_from_old_version: ModuleType,
-    new_version_dir: Path,
-    version_dirs: frozenset[Path] | tuple[Path, ...],
-) -> str:
-    # ['package', 'companies', 'head', 'schemas']
-    #                           ^^^^^^
-    #                           index = 2
-    index_of_base_schema_dir = get_index_of_head_schema_dir_in_module_python_path(
-        module_from_old_version,
-        new_version_dir,
-        version_dirs,
-    )
-
-    # ['package', 'companies', 'head', 'schemas']
-    model_split_python_path = module_from_old_version.__name__.split(".")
-    # ['package', 'companies', 'v2021_01_01', 'schemas']
-    model_split_python_path[index_of_base_schema_dir] = new_version_dir.name
-    # package.companies.v2021_01_01.schemas
-    return ".".join(model_split_python_path)
-
-
-@functools.cache
-def get_index_of_head_schema_dir_in_module_python_path(
-    module_from_old_version: ModuleType,
-    parallel_dir: Path,
-    version_dirs: frozenset[Path] = frozenset(),
-) -> int:
-    """If version_dirs have been passed, we will check if the module is versioned and raise an exception if it isn't"""
-    file = inspect.getsourcefile(module_from_old_version)
-    # Impossible to cover
-    if file is None:  # pragma: no cover
-        raise CadwynError(
-            f"Model {module_from_old_version} is not defined in a file. It is likely because it's a compiled module "
-            "which Cadwyn couldn't migrate to an older version. "
-            "If you are seeing this error -- you've encountered a bug in Cadwyn.",
-        )
-    # /home/myuser/package/companies/head/__init__.py
-    file = Path(file)
-    _validate_that_module_is_versioned(file, version_dirs)
-    is_package = file.name == "__init__.py"
-    if is_package:
-        # /home/myuser/package/companies/head/
-        file = file.parent
-    # /home/myuser/package/companies
-    root_dir = parallel_dir.parent
-    # head/schemas
-    relative_file = file.relative_to(root_dir).with_suffix("")
-    # ['head', 'schemas']
-    relative_file_parts = relative_file.parts
-    # package.companies.head.schemas.payables
-    module_python_path = module_from_old_version.__name__
-    # ['package', 'companies', 'head', 'schemas']
-    module_split_python_path = module_python_path.split(".")
-
-    index = len(module_split_python_path) - len(relative_file_parts) - int(is_package)
-
-    # When we are in latest/__init__.py, we have this special case
-    if len(relative_file_parts) == 1 and is_package:
-        index += 1
-    return index
-
-
-def _validate_that_module_is_versioned(file: Path, version_dirs: Collection[Path]):
-    if not version_dirs:
-        return
-    for version_dir in version_dirs:
-        try:
-            file.relative_to(version_dir)
-            return
-        except ValueError:
-            pass
-    raise ModuleIsNotVersionedError(f"Module {file} is not versioned.")
+def fully_unwrap_decorator(func: Callable, is_pydantic_v1_style_validator: Any):
+    func = unwrap_wrapped_function(func)
+    if is_pydantic_v1_style_validator and func.__closure__:
+        func = func.__closure__[0].cell_contents
+    return unwrap_wrapped_function(func)

cadwyn/applications.py

@@ -4,7 +4,6 @@ from collections.abc import Callable, Coroutine, Sequence
 from datetime import date
 from logging import getLogger
 from pathlib import Path
-from types import ModuleType
 from typing import Any, cast
 
 from fastapi import APIRouter, FastAPI, HTTPException, routing
@@ -24,7 +23,7 @@ from starlette.requests import Request
 from starlette.responses import JSONResponse, Response
 from starlette.routing import BaseRoute, Route
 from starlette.types import Lifespan
-from typing_extensions import Self, deprecated
+from typing_extensions import Self
 
 from cadwyn.middleware import HeaderVersioningMiddleware, _get_api_version_dependency
 from cadwyn.route_generation import generate_versioned_routers
@@ -95,9 +94,6 @@ class Cadwyn(FastAPI):
     ) -> None:
         self.versions = versions
         # TODO: Remove argument entirely in any major version.
-        latest_schemas_package = extra.pop("latest_schemas_package", None) or self.versions.head_schemas_package
-        self.versions.head_schemas_package = latest_schemas_package
-        self._latest_schemas_package = cast(ModuleType, latest_schemas_package)
         self._dependency_overrides_provider = FakeDependencyOverridesProvider({})
 
         super().__init__(
@@ -175,9 +171,10 @@ class Cadwyn(FastAPI):
 
     @property
     def dependency_overrides(self) -> dict[Callable[..., Any], Callable[..., Any]]:
+        # TODO: Remove this approach as it is no longer necessary
         # This is only necessary because we cannot send self to versioned router generator
-        # because it takes a deepcopy of the router and self.versions.head_schemas_package is a module
-        # which cannot be copied.
+        # because it takes a deepcopy of the router and self.versions.head_schemas_package was a module
+        # which couldn't be copied.
         return self._dependency_overrides_provider.dependency_overrides
 
     @dependency_overrides.setter
@@ -187,16 +184,6 @@ class Cadwyn(FastAPI):
     ) -> None:
         self._dependency_overrides_provider.dependency_overrides = value
 
-    @property  # pragma: no cover
-    @deprecated("It is going to be deleted in the future. Use VersionBundle.head_schemas_package instead")
-    def latest_schemas_package(self):
-        return self._latest_schemas_package
-
-    @latest_schemas_package.setter  # pragma: no cover
-    @deprecated("It is going to be deleted in the future. Use VersionBundle.head_schemas_package instead")
-    def latest_schemas_package(self, value: ModuleType | None):
-        self._latest_schemas_package = value
-
     def _add_openapi_endpoints(self, unversioned_router: APIRouter):
         if self.openapi_url is not None:
             unversioned_router.add_route(
@@ -233,10 +220,7 @@ class Cadwyn(FastAPI):
         root_router = APIRouter(dependency_overrides_provider=self._dependency_overrides_provider)
         for router in routers:
             root_router.include_router(router)
-        router_versions = generate_versioned_routers(
-            root_router,
-            versions=self.versions,
-        )
+        router_versions = generate_versioned_routers(root_router, versions=self.versions)
         for version, router in router_versions.items():
             self.add_header_versioned_routers(router, header_value=version.isoformat())
 
@@ -358,16 +342,3 @@ class Cadwyn(FastAPI):
         self.router.routes.extend(added_routes)
 
         return added_routes
-
-    @deprecated("Use builtin FastAPI methods such as include_router instead")
-    def add_unversioned_routers(self, *routers: APIRouter):
-        for router in routers:
-            self.include_router(router)
-
-    @deprecated("Use builtin FastAPI methods such as add_api_route instead")
-    def add_unversioned_routes(self, *routes: Route):
-        router = APIRouter(routes=list(routes))
-        self.include_router(router)
-
-    @deprecated("It no longer does anything")
-    def enrich_swagger(self): ...

cadwyn/exceptions.py

@@ -5,6 +5,10 @@ from typing import Any
 from fastapi.routing import APIRoute
 
 
+class CadwynRenderError(Exception):
+    pass
+
+
 class CadwynError(Exception):
     pass
 
@@ -26,15 +30,15 @@ class LintingError(CadwynError):
     pass
 
 
-class CodeGenerationError(CadwynError):
+class SchemaGenerationError(CadwynError):
     pass
 
 
-class ModuleIsNotAvailableAsTextError(CodeGenerationError):
+class ModuleIsNotAvailableAsTextError(SchemaGenerationError):
     pass
 
 
-class InvalidGenerationInstructionError(CodeGenerationError):
+class InvalidGenerationInstructionError(SchemaGenerationError):
     pass
 
 
@@ -70,3 +74,7 @@ class CadwynStructureError(CadwynError):
 
 class ModuleIsNotVersionedError(ValueError):
     pass
+
+
+class ImportFromStringError(CadwynError):
+    pass

cadwyn/middleware.py

@@ -64,11 +64,11 @@ class HeaderVersioningMiddleware(BaseHTTPMiddleware):
                     request=request,
                     dependant=self.version_header_validation_dependant,
                     async_exit_stack=async_exit_stack,
-                    embed_body_fields=False,
                 )
-                if solved_result.errors:
-                    return self.default_response_class(status_code=422, content=_normalize_errors(solved_result.errors))
-                api_version = cast(date, solved_result.values[self.api_version_header_name.replace("-", "_")])
+                values, errors, *_ = solved_result
+                if errors:
+                    return self.default_response_class(status_code=422, content=_normalize_errors(errors))
+                api_version = cast(date, values[self.api_version_header_name.replace("-", "_")])
                 self.api_version_var.set(api_version)
 
         response = await call_next(request)