cadwyn 5.1.2__tar.gz → 5.1.4__tar.gz

{cadwyn-5.1.2 → cadwyn-5.1.4}/CHANGELOG.md

@@ -5,6 +5,21 @@ Please follow [the Keep a Changelog standard](https://keepachangelog.com/en/1.0.
 
 ## [Unreleased]
 
+## [5.1.4]
+
+### Fixed
+
+* a bug where a custom HTTP exception was not being copied correctly so its unique properties are ignored
+
+## [5.1.3]
+
+### Fixed
+
+* `__doc__` attribute is now copied from the original enum to the generated enum
+* Python 3.12 type aliases and their typing_extensions backports are now supported (including `pydantic.JsonValue` and other `typing_extensions.TypeAliasType` instances)
+* The bug when solve_dependencies error on the migration of a request to the latest version responds with a non-json serializable error and cadwyn showed a failed to serialize error instead of the actual error
+* Updated minimum fastapi version to 0.112.4 because embed_body_fields was added in 0.112.4
+
 ## [5.1.2]
 
 ### Fixed

{cadwyn-5.1.2 → cadwyn-5.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cadwyn
-Version: 5.1.2
+Version: 5.1.4
 Summary: Production-ready community-driven modern Stripe-like API versioning in FastAPI
 Project-URL: Source code, https://github.com/zmievsa/cadwyn
 Project-URL: Documentation, https://docs.cadwyn.dev
@@ -35,7 +35,7 @@ Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Typing :: Typed
 Requires-Python: >=3.9
 Requires-Dist: backports-strenum<2,>=1.3.1; python_version < '3.11'
-Requires-Dist: fastapi>=0.112.3
+Requires-Dist: fastapi>=0.112.4
 Requires-Dist: issubclass>=0.1.2
 Requires-Dist: jinja2>=3.1.2
 Requires-Dist: pydantic>=2.0.0

{cadwyn-5.1.2 → cadwyn-5.1.4}/cadwyn/exceptions.py

@@ -1,4 +1,3 @@
-import json
 from typing import Any
 
 from fastapi.routing import APIRoute
@@ -21,7 +20,7 @@ class CadwynHeadRequestValidationError(CadwynError):
             f"We failed to migrate the request with version={self.version}. "
             "This means that there is some error in your migrations or schema structure that makes it impossible "
             "to migrate the request of that version to latest.\n"
-            f"body={self.body}\n\nerrors={json.dumps(self.errors, indent=4, ensure_ascii=False)}"
+            f"body={self.body}\n\nerrors={self.errors}"
         )
 
 

{cadwyn-5.1.2 → cadwyn-5.1.4}/cadwyn/schema_generation.py

@@ -40,6 +40,7 @@ from typing_extensions import (
     NewType,
     Self,
     TypeAlias,
+    TypeAliasType,
     TypeVar,
     _AnnotatedAlias,
     assert_never,
@@ -100,6 +101,7 @@ PYDANTIC_DECORATOR_TYPE_TO_DECORATOR_MAP = {
     ModelSerializerDecoratorInfo: pydantic.model_serializer,
     ComputedFieldInfo: pydantic.computed_field,
 }
+_PYDANTIC_ALL_EXPORTED_NAMES = set(pydantic.__all__)
 
 
 VALIDATOR_CONFIG_KEY = "__validators__"
@@ -580,6 +582,17 @@ class _AnnotationTransformer:
     def _change_version_of_a_non_container_annotation(self, annotation: Any) -> Any:
         if isinstance(annotation, (_BaseGenericAlias, types.GenericAlias)):
             return get_origin(annotation)[tuple(self.change_version_of_annotation(arg) for arg in get_args(annotation))]
+        elif isinstance(annotation, TypeAliasType):
+            if (
+                annotation.__module__ is not None and (annotation.__module__.startswith("pydantic."))
+            ) or annotation.__name__ in _PYDANTIC_ALL_EXPORTED_NAMES:
+                return annotation
+            else:
+                return TypeAliasType(  # pyright: ignore[reportGeneralTypeIssues]
+                    name=annotation.__name__,
+                    value=self.change_version_of_annotation(annotation.__value__),
+                    type_params=self.change_version_of_annotation(annotation.__type_params__),
+                )
         elif isinstance(annotation, fastapi.params.Security):
             return fastapi.params.Security(
                 self.change_version_of_annotation(annotation.dependency),
@@ -1079,6 +1092,7 @@ class _EnumWrapper(Generic[_T_ENUM]):
         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
+        enum_dict["__doc__"] = self.cls.__doc__
         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-5.1.2 → cadwyn-5.1.4}/cadwyn/structure/versions.py

@@ -1,5 +1,6 @@
 import email.message
 import functools
+import http
 import inspect
 import json
 from collections import defaultdict
@@ -8,7 +9,7 @@ from contextlib import AsyncExitStack
 from contextvars import ContextVar
 from datetime import date
 from enum import Enum
-from typing import TYPE_CHECKING, ClassVar, Union
+from typing import TYPE_CHECKING, ClassVar, Union, cast
 
 from fastapi import BackgroundTasks, HTTPException, params
 from fastapi import Request as FastapiRequest
@@ -616,12 +617,13 @@ class VersionBundle:
                     detail = response_info.body["detail"]
                 else:
                     detail = response_info.body
+                if detail is None:
+                    detail = http.HTTPStatus(response_info.status_code).phrase
+                raised_exception.detail = cast(str, detail)
+                raised_exception.headers = dict(response_info.headers)
+                raised_exception.status_code = response_info.status_code
 
-                raise HTTPException(
-                    status_code=response_info.status_code,
-                    detail=detail,
-                    headers=dict(response_info.headers),
-                )
+                raise raised_exception
             return response_info._response
         return response_info.body
 

{cadwyn-5.1.2 → cadwyn-5.1.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cadwyn"
-version = "5.1.2"
+version = "5.1.4"
 description = "Production-ready community-driven modern Stripe-like API versioning in FastAPI"
 authors = [{ name = "Stanislav Zmiev", email = "zmievsa@gmail.com" }]
 license = "MIT"
@@ -51,7 +51,7 @@ classifiers = [
     "Topic :: Internet :: WWW/HTTP",
 ]
 dependencies = [
-    "fastapi >=0.112.3",
+    "fastapi >=0.112.4",
     "starlette >=0.30.0",
     "pydantic >=2.0.0",
     "jinja2 >=3.1.2",
@@ -73,7 +73,8 @@ dev-dependencies = [
     "svcs ~=24.1.0",
     "httpx >=0.26.0",
     "pytest-fixture-classes >=1.0.3",
-    "pytest >=7.2.1",
+    # pytest==8.3.5 has a bug that fails our windows python 3.10 tests
+    "pytest==8.3.4",
     "pytest-cov >=4.0.0",
     "dirty-equals >=0.6.0",
     "uvicorn ~=0.23.0",

{cadwyn-5.1.2 → cadwyn-5.1.4}/tests/test_data_migrations.py

@@ -3,7 +3,7 @@ import re
 from collections.abc import Callable, Coroutine
 from contextvars import ContextVar
 from io import StringIO
-from typing import Any, Literal, Union
+from typing import Any, Literal, Optional, Union
 
 import fastapi
 import pytest
@@ -11,6 +11,7 @@ from dirty_equals import IsPartialDict, IsStr
 from fastapi import APIRouter, Body, Cookie, File, Header, HTTPException, Query, Request, Response, UploadFile
 from fastapi.responses import JSONResponse
 from fastapi.routing import APIRoute
+from fastapi.testclient import TestClient
 from pydantic import BaseModel, Field, RootModel
 from starlette.responses import StreamingResponse
 
@@ -32,6 +33,7 @@ from cadwyn.structure.data import RequestInfo, ResponseInfo
 from cadwyn.structure.schemas import schema
 from cadwyn.structure.versions import Version, VersionBundle
 from tests.conftest import (
+    CreateVersionedApp,
     CreateVersionedClients,
     client,
     version_change,
@@ -1226,3 +1228,41 @@ def test__request_and_response_migrations__with_multiple_schemas_in_converters(
         resp_2001 = client_2001.post(f"/{endpoint}", json={"i": ["original_request"]})
         assert resp_2001.status_code == 200
         assert resp_2001.json() == {"i": ["original_request", endpoint]}
+
+
+def test__response_migrations__with_custom_http_exception(
+    create_versioned_app: CreateVersionedApp,
+    router: VersionedAPIRouter,
+) -> None:
+    class CustomHTTPException(HTTPException):
+        error_code: Optional[str] = None
+
+        def __init__(self, detail: str, error_code: Optional[str] = None):
+            self.error_code = error_code
+            super().__init__(status_code=400, detail=detail)
+
+    def http_exception_handler(request, exc):
+        # Check if the exception has an error_code attribute
+        error_code = exc.error_code if hasattr(exc, "error_code") else "generic_error"
+
+        return JSONResponse(
+            status_code=exc.status_code,
+            content={"code": error_code, "message": exc.detail},
+        )
+
+    # Register exception handler for Cadwyn
+
+    @router.post("/test")
+    async def endpoint():
+        raise CustomHTTPException("Cadwyn error occurred", error_code="cadwyn_error")
+
+    app = create_versioned_app(version_change())
+    app.add_exception_handler(HTTPException, http_exception_handler)
+    with TestClient(app) as client:
+        resp = client.post("/test", headers={"X-API-VERSION": "2000-01-01"})
+        assert resp.status_code == 400
+        assert resp.json() == {"code": "cadwyn_error", "message": "Cadwyn error occurred"}
+
+        resp_2001 = client.post("/test", headers={"X-API-VERSION": "2001-01-01"})
+        assert resp_2001.status_code == 400
+        assert resp_2001.json() == {"code": "cadwyn_error", "message": "Cadwyn error occurred"}

{cadwyn-5.1.2 → cadwyn-5.1.4}/tests/test_router_generation.py

@@ -14,10 +14,10 @@ from fastapi.security import HTTPAuthorizationCredentials, HTTPBearer
 from fastapi.security.http import HTTPBasic
 from fastapi.testclient import TestClient
 from inline_snapshot import snapshot
-from pydantic import BaseModel
+from pydantic import BaseModel, JsonValue
 from pytest_fixture_classes import fixture_class
 from starlette.responses import FileResponse
-from typing_extensions import Any, NewType, TypeAlias, get_args
+from typing_extensions import Any, NewType, TypeAlias, TypeAliasType, get_args
 
 from cadwyn import VersionBundle, VersionedAPIRouter
 from cadwyn.dependencies import current_dependency_solver
@@ -800,7 +800,7 @@ def test__router_generation__using_unversioned_models(
     assert routes_2001[3].dependant.body_params[0].type_ is schemas["2001-01-01"][UnversionedSchema3]
 
 
-def test__router_generation__using_weird_typehints(
+def test__router_generation__using_newtype_and_union_typehints(
     router: VersionedAPIRouter,
     create_versioned_api_routes: CreateVersionedAPIRoutes,
 ):
@@ -822,7 +822,7 @@ def test__router_generation__using_weird_typehints(
     assert getattr(routes_2001[1].dependant.body_params[1], TYPE_ATTR) == Union[str, int]
 
 
-def test__router_generation__using_pydantic_typehints__internal_pydantic_typehints_should_work(
+def test__router_generation__using_uploadfile_typehint(
     router: VersionedAPIRouter,
     create_versioned_api_routes: CreateVersionedAPIRoutes,
 ):
@@ -837,6 +837,54 @@ def test__router_generation__using_pydantic_typehints__internal_pydantic_typehin
     # We are intentionally not checking anything here. Our goal is to validate that there is no exception
 
 
+def test__router_generation__using_jsonvalue_typehint(
+    router: VersionedAPIRouter,
+    create_versioned_clients: CreateVersionedClients,
+):
+    @router.post("/test")
+    async def test(param1: JsonValue = Body()):
+        return param1
+
+    clients = create_versioned_clients(
+        version_change(endpoint("/test", ["POST"]).had(response_model=dict[str, str])),
+    )
+    assert clients["2000-01-01"].post("/test", json={"foo": "bar"}).json() == {"foo": "bar"}
+    assert clients["2001-01-01"].post("/test", json={"foo": "bar"}).json() == {"foo": "bar"}
+
+
+def test__router_generation__using_typealias_type_typehint(
+    router: VersionedAPIRouter,
+    create_versioned_clients: CreateVersionedClients,
+):
+    class MySchema(BaseModel):
+        foo: str
+
+    typealias = TypeAliasType("typealias", list[MySchema])  # pyright: ignore[reportGeneralTypeIssues]
+
+    @router.post("/test")
+    async def test(param1: typealias = Body()):
+        return param1
+
+    clients = create_versioned_clients(
+        version_change(schema(MySchema).field("foo").had(name="baz")),
+    )
+    assert clients["2000-01-01"].post("/test", json=[{"foo": "bar"}]).json() == snapshot(
+        {
+            "detail": [
+                {
+                    "type": "missing",
+                    "loc": ["body", 0, "baz"],
+                    "msg": "Field required",
+                    "input": {
+                        "foo": "bar",
+                    },
+                }
+            ]
+        }
+    )
+    assert clients["2001-01-01"].post("/test", json=[{"foo": "bar"}]).json() == [{"foo": "bar"}]
+
+
 def test__router_generation__updating_request_depends(
     router: VersionedAPIRouter, create_versioned_app: CreateVersionedApp
 ):

{cadwyn-5.1.2 → cadwyn-5.1.4}/tests/test_schema_generation/test_enum.py

@@ -11,7 +11,7 @@ from tests.conftest import CreateRuntimeSchemas, serialize_enum, version_change
 
 
 class EmptyEnum(Enum):
-    pass
+    """My docstring"""
 
 
 class EnumWithOneMember(Enum):
@@ -34,6 +34,12 @@ class EnumWithOneMemberAndMethods(Enum):
         return cls.world_member  # pyright: ignore[reportAttributeAccessIssue]
 
 
+def test__enum_had__should_copy_docstring_too(create_runtime_schemas: CreateRuntimeSchemas):
+    models = create_runtime_schemas(version_change(enum(EmptyEnum).had(b=auto())))
+    assert models["2000-01-01"][EmptyEnum].__doc__ == "My docstring"
+    assert models["2001-01-01"][EmptyEnum].__doc__ == "My docstring"
+
+
 def test__enum_had__original_enum_is_empty(create_runtime_schemas: CreateRuntimeSchemas):
     models = create_runtime_schemas(version_change(enum(EmptyEnum).had(b=auto())))
     assert serialize_enum(models["2000-01-01"][EmptyEnum]) == {"b": 1}