cadwyn 4.4.3__tar.gz → 4.5.0__tar.gz

{cadwyn-4.4.3 → cadwyn-4.5.0}/.github/actions/setup-python-uv/action.yaml

@@ -8,7 +8,7 @@ inputs:
   uv-version:
     description: "The uv version to set up"
     required: true
-    default: "0.4.18"
+    default: "0.5.8"
 
 runs:
   using: "composite"
@@ -16,12 +16,12 @@ runs:
     - uses: actions/setup-python@v5
       with:
         python-version: ${{ inputs.python-version }}
-    - uses: astral-sh/setup-uv@v3
+    - uses: astral-sh/setup-uv@v5
       with:
         version: ${{ inputs.uv-version }}
         enable-cache: true
         cache-dependency-glob: "uv.lock"
     - run: |
         uv sync --frozen --all-extras --dev
-        echo "$(pwd)/.venv/bin" >> $GITHUB_PATH
+        uv pip install --system tox tox-uv
       shell: bash

{cadwyn-4.4.3 → cadwyn-4.5.0}/.github/workflows/ci.yaml

@@ -10,6 +10,7 @@ on:
     branches: [main, 3.x.x]
     types: [opened, synchronize]
     paths:
+      - ".github/workflows/ci.yaml" # self
       - "**.py"
       - "**.toml"
       - "**.lock"
@@ -40,13 +41,13 @@ jobs:
       - uses: ./.github/actions/setup-python-uv
         with:
           python-version: ${{ matrix.python-version }}
-      - run: uv run coverage run --source=. --parallel-mode -m pytest tests
+      - run: tox run -e py
       - name: Upload coverage results
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v4
         if: matrix.os == 'ubuntu-latest' # Cross-platform coverage combination doesn't work
         with:
-          name: main-tests-coverage-results
-          path: coverage/
+          name: coverage-results-${{ matrix.python-version }}
+          path: .coverage*
   Tutorial-tests:
     runs-on: ubuntu-latest
     name: Tutorial tests
@@ -57,53 +58,65 @@ jobs:
           python-version: "3.10"
       - name: Install cadwyn with instructions from docs
         run: sh docs_src/quickstart/setup/block001.sh
-      - run: pip install pytest coverage dirty-equals
-      - run: coverage run --source=. --parallel-mode -m pytest docs_src
+      - run: |
+          pip install uv
+          uv pip install --system pytest coverage dirty-equals
+          coverage run -m pytest docs_src
       - name: Upload coverage results
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v4
         with:
-          name: docs-tests-coverage-results
-          path: coverage/
+          name: coverage-results-docs
+          path: .coverage*
   Coverage:
     needs: [Tests, Tutorial-tests]
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
-      - name: Download main tests coverage info
-        uses: actions/download-artifact@v3
+      - name: Download coverage info
+        uses: actions/download-artifact@v4
         with:
-          name: main-tests-coverage-results
-          path: coverage/
-      - name: Download docs tests coverage info
-        uses: actions/download-artifact@v3
-        with:
-          name: docs-tests-coverage-results
-          path: coverage/
+          pattern: coverage-results-*
+          merge-multiple: true
+          path: .
       - uses: actions/setup-python@v5
         with:
           python-version: "3.10"
-      - run: pip install 'coverage[toml]'
-      - run: coverage combine
-      - run: coverage xml
+      - run: |
+          pip install uv
+          uv pip install --system tox tox-uv
+          tox run -e coverage_report-ci
       - name: Upload to Codecov
         uses: codecov/codecov-action@v4
         env:
           fail_ci_if_error: true
           CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
-      - run: coverage report --fail-under=100
 
   Lint:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
-      - uses: pre-commit/action@v3.0.0
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.10"
+      - run: |
+          python -m pip install uv
+          uv pip install --system pre-commit pre-commit-uv
+          pre-commit run --all-files
+      - run: tox run -e docs
+      - name: Validate links
+        uses: umbrelladocs/action-linkspector@v1
+        with:
+          reporter: github-pr-review
+          filter_mode: diff_context
+          fail_level: any
 
   Typecheck:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
       - uses: ./.github/actions/setup-python-uv
-
-      - uses: jakebailey/pyright-action@v1
         with:
-          pylance-version: latest-release
+          # When this version is updated,
+          # update the pyright `base_python` version in `tox.ini`, too.
+          python-version: "3.10"
+      - run: tox run -e pyright

{cadwyn-4.4.3 → cadwyn-4.5.0}/.github/workflows/daily_tests.yaml

@@ -21,10 +21,8 @@ jobs:
         with:
           python-version: ${{ matrix.python-version }}
       - run: uv sync --refresh --all-extras --dev --upgrade
-      - run: pytest .
-      - uses: jakebailey/pyright-action@v1
-        with:
-          pylance-version: latest-release
+      - run: uv run pytest . # We intentionally don't use tox here to run tests "as is"
+      - run: uv run pyright --version && uv run pyright .
 
   notify-on-failure:
     name: Notify on failure

{cadwyn-4.4.3 → cadwyn-4.5.0}/.github/workflows/publish_docs.yaml

@@ -14,11 +14,11 @@ jobs:
         run: |
           git config user.name github-actions[bot]
           git config user.email 41898282+github-actions[bot]@users.noreply.github.com
-      - uses: actions/setup-python@v4
+      - uses: actions/setup-python@v5
         with:
           python-version: 3.x
       - run: echo "cache_id=$(date --utc '+%V')" >> $GITHUB_ENV
-      - uses: actions/cache@v3
+      - uses: actions/cache@v4
         with:
           key: mkdocs-material-${{ env.cache_id }}
           path: .cache

cadwyn-4.5.0/.github/workflows/validate_links.yaml

@@ -0,0 +1,25 @@
+name: Check Markdown links
+
+on:
+  schedule:
+    # Run everyday at 9:00 AM
+    - cron: "0 9 * * *"
+  workflow_dispatch: # Allows manual triggering of the workflow
+
+jobs:
+  build-docs-to-validate-links:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: ./.github/actions/setup-python-uv
+      - run: tox run -e docs
+
+  markdown-link-check:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: umbrelladocs/action-linkspector@v1
+        with:
+          reporter: github-check
+          filter_mode: nofilter
+          fail_level: any

{cadwyn-4.4.3 → cadwyn-4.5.0}/.pre-commit-config.yaml

@@ -2,7 +2,7 @@ default_language_version:
   python: python3.10
 repos:
   - repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v4.6.0
+    rev: v5.0.0
     hooks:
       - id: check-added-large-files
       - id: check-yaml
@@ -18,14 +18,14 @@ repos:
       - id: python-check-blanket-noqa
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.6.1
+    rev: v0.8.1
     hooks:
       - id: ruff
         args: [--fix, --exit-non-zero-on-fix]
       - id: ruff-format
 
   - repo: https://github.com/adamchainz/blacken-docs
-    rev: "1.18.0" # replace with latest tag on GitHub
+    rev: "1.19.1" # replace with latest tag on GitHub
     hooks:
       - id: blacken-docs
         additional_dependencies:
@@ -33,7 +33,7 @@ repos:
         args: ["--line-length=80", "--target-version=py310", "--skip-errors"]
 
   - repo: https://github.com/igorshubovych/markdownlint-cli
-    rev: v0.41.0
+    rev: v0.43.0
     hooks:
       - id: markdownlint
         args: ["--disable", "MD013"]

{cadwyn-4.4.3 → cadwyn-4.5.0}/CHANGELOG.md

@@ -5,6 +5,24 @@ Please follow [the Keep a Changelog standard](https://keepachangelog.com/en/1.0.
 
 ## [Unreleased]
 
+## [4.5.0]
+
+### Added
+
+* `check_usage` argument to request/response by schema converters. Cadwyn always checks whether a schema mentioned in a converter applies to one or more endpoints to guarantee that the converter will apply to at least one endpoint. Sometimes, however, you do not need this validation. For example, when you use these converters for converting webhook bodies. Setting `check_usage=False` makes it possible to skip the validation
+
+## [4.4.5]
+
+### Fixed
+
+* Fix invalid migration of pydantic v1 style root validators when pydantic erases information about their "skip_on_failure" attribute
+
+## [4.4.4]
+
+### Fixed
+
+* Type hints for newest pydantic versions
+
 ## [4.4.3]
 
 ### Changed
@@ -299,7 +317,7 @@ Versions 3.x.x are still supported in terms of bug and security fixes but all th
 
 ### Fixed
 
-* When a class-based dependency from **fastapi** was used (anything security related), FastAPI had hardcoded `isinstance` checks for it which it used to enrich swagger with functionality. But when the dependencies were wrapped into our function wrappers, these checks stopped passing, thus breaking this functionality in swagger. Now we ignore all dependencies that FastAPI creates. This also introduces a hard-to-solve bug: if fastapi's class-based security dependency was subclassed and then `__call__` was overriden with new dependencies that are versioned -- we will not migrate them from version to version. I hope this is an extremely rare use case though. In fact, such use case breaks Liskov Substitution Principle and doesn't make much sense because security classes already include `request` parameter which means that no extra dependencies or parameters are necessary.
+* When a class-based dependency from **fastapi** was used (anything security related), FastAPI had hardcoded `isinstance` checks for it which it used to enrich swagger with functionality. But when the dependencies were wrapped into our function wrappers, these checks stopped passing, thus breaking this functionality in swagger. Now we ignore all dependencies that FastAPI creates. This also introduces a hard-to-solve bug: if fastapi's class-based security dependency was subclassed and then `__call__` was overridden with new dependencies that are versioned -- we will not migrate them from version to version. I hope this is an extremely rare use case though. In fact, such use case breaks Liskov Substitution Principle and doesn't make much sense because security classes already include `request` parameter which means that no extra dependencies or parameters are necessary.
 
 ## [3.6.5]
 

cadwyn-4.5.0/Makefile

@@ -0,0 +1,11 @@
+SHELL := /bin/bash
+py_warn = PYTHONDEVMODE=1
+
+install:
+	uv sync --all-extras --dev
+
+lint:
+	pre-commit run --all-files
+
+test:
+	uv run --with tox --with tox-uv tox

{cadwyn-4.4.3 → cadwyn-4.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: cadwyn
-Version: 4.4.3
+Version: 4.5.0
 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

{cadwyn-4.4.3 → cadwyn-4.5.0}/cadwyn/_asts.py

@@ -56,12 +56,13 @@ def get_fancy_repr(value: Any) -> Any:
 
 
 def transform_grouped_metadata(value: "annotated_types.GroupedMetadata"):
-    modified_fields = []
     empty_obj = type(value)
 
-    for key in empty_obj.__dataclass_fields__:  # pyright: ignore[reportAttributeAccessIssue]
-        if getattr(value, key) != getattr(empty_obj, key):
-            modified_fields.append((key, getattr(value, key)))
+    modified_fields = [
+        (key, getattr(value, key))
+        for key in value.__dataclass_fields__  # pyright: ignore[reportAttributeAccessIssue]
+        if getattr(value, key) != getattr(empty_obj, key)
+    ]
 
     return PlainRepr(
         value.__class__.__name__
@@ -120,11 +121,12 @@ def transform_other(value: Any) -> Any:
 
 
 def _get_lambda_source_from_default_factory(source: str) -> str:
-    found_lambdas: list[ast.Lambda] = []
+    found_lambdas: list[ast.Lambda] = [
+        node.value
+        for node in ast.walk(ast.parse(source))
+        if isinstance(node, ast.keyword) and node.arg == "default_factory" and isinstance(node.value, ast.Lambda)
+    ]
 
-    for node in ast.walk(ast.parse(source)):
-        if isinstance(node, ast.keyword) and node.arg == "default_factory" and isinstance(node.value, ast.Lambda):
-            found_lambdas.append(node.value)
     if len(found_lambdas) == 1:
         return ast.unparse(found_lambdas[0])
     # These two errors are really hard to cover. Not sure if even possible, honestly :)

{cadwyn-4.4.3 → cadwyn-4.5.0}/cadwyn/_importer.py

@@ -7,7 +7,7 @@ from cadwyn.exceptions import ImportFromStringError
 def import_attribute_from_string(import_str: str) -> Any:
     module_str, _, attrs_str = import_str.partition(":")
     if not module_str or not attrs_str:
-        message = 'Import string "{import_str}" must be in format "<module>:<attribute>".'
+        message = f'Import string "{import_str}" must be in format "<module>:<attribute>".'
         raise ImportFromStringError(message.format(import_str=import_str))
 
     module = import_module_from_string(module_str)

{cadwyn-4.4.3 → cadwyn-4.5.0}/cadwyn/_utils.py

@@ -1,5 +1,5 @@
 from collections.abc import Callable
-from typing import Any, Generic, TypeVar, Union
+from typing import TYPE_CHECKING, Any, Generic, TypeVar, Union
 
 from pydantic._internal._decorators import unwrap_wrapped_function
 
@@ -40,3 +40,17 @@ def fully_unwrap_decorator(func: Callable, is_pydantic_v1_style_validator: Any):
     if is_pydantic_v1_style_validator and func.__closure__:
         func = func.__closure__[0].cell_contents
     return unwrap_wrapped_function(func)
+
+
+T = TypeVar("T", bound=type[object])
+
+if TYPE_CHECKING:
+    lenient_issubclass = issubclass
+
+else:
+
+    def lenient_issubclass(cls: type, other: T | tuple[T, ...]) -> bool:
+        try:
+            return issubclass(cls, other)
+        except TypeError:  # pragma: no cover
+            return False

{cadwyn-4.4.3 → cadwyn-4.5.0}/cadwyn/changelogs.py

@@ -160,7 +160,7 @@ def _get_openapi_representation_of_a_field(model: type[BaseModel], field_name: s
 
     model_name_map = get_compat_model_name_map([CadwynDummyModelForRepresentation.model_fields["my_field"]])
     schema_generator = GenerateJsonSchema(ref_template=REF_TEMPLATE)
-    field_mapping, definitions = get_definitions(
+    _, definitions = get_definitions(
         fields=[ModelField(CadwynDummyModelForRepresentation.model_fields["my_field"], "my_field")],
         schema_generator=schema_generator,
         model_name_map=model_name_map,

{cadwyn-4.4.3 → cadwyn-4.5.0}/cadwyn/route_generation.py

@@ -179,13 +179,13 @@ class _EndpointTransformer(Generic[_R, _WR]):
                     copy_of_dependant,
                     self.versions,
                 )
-        for _, router in routers.items():
+        for router in routers.values():
             router.routes = [
                 route
                 for route in router.routes
                 if not (isinstance(route, fastapi.routing.APIRoute) and _DELETED_ROUTE_TAG in route.tags)
             ]
-        for _, webhook_router in webhook_routers.items():
+        for webhook_router in webhook_routers.values():
             webhook_router.routes = [
                 route
                 for route in webhook_router.routes
@@ -221,6 +221,8 @@ class _EndpointTransformer(Generic[_R, _WR]):
 
             for by_schema_converters in version_change.alter_request_by_schema_instructions.values():
                 for by_schema_converter in by_schema_converters:
+                    if not by_schema_converter.check_usage:  # pragma: no cover
+                        continue
                     missing_models = set(by_schema_converter.schemas) - head_request_bodies
                     if missing_models:
                         raise RouteRequestBySchemaConverterDoesNotApplyToAnythingError(
@@ -232,6 +234,8 @@ class _EndpointTransformer(Generic[_R, _WR]):
                         )
             for by_schema_converters in version_change.alter_response_by_schema_instructions.values():
                 for by_schema_converter in by_schema_converters:
+                    if not by_schema_converter.check_usage:  # pragma: no cover
+                        continue
                     missing_models = set(by_schema_converter.schemas) - head_response_models
                     if missing_models:
                         raise RouteResponseBySchemaConverterDoesNotApplyToAnythingError(
@@ -240,6 +244,9 @@ class _EndpointTransformer(Generic[_R, _WR]):
                             f"failed to find routes with the following response models: "
                             f"{[m.__name__ for m in missing_models]}. "
                             f"This means that you are trying to apply this converter to non-existing endpoint(s). "
+                            "If this is intentional and this converter really does not apply to any endpoints, then "
+                            "pass check_usage=False argument to "
+                            f"{version_change.__name__}.{by_schema_converter.transformer.__name__}"
                         )
 
     def _extract_all_routes_identifiers(
@@ -466,18 +473,18 @@ def _get_routes(
     *,
     is_deleted: bool = False,
 ) -> list[fastapi.routing.APIRoute]:
-    found_routes = []
     endpoint_path = endpoint_path.rstrip("/")
-    for route in routes:
+    return [
+        route
+        for route in routes
         if (
             isinstance(route, fastapi.routing.APIRoute)
             and route.path.rstrip("/") == endpoint_path
             and set(route.methods).issubset(endpoint_methods)
             and (endpoint_func_name is None or route.endpoint.__name__ == endpoint_func_name)
             and (_DELETED_ROUTE_TAG in route.tags) == is_deleted
-        ):
-            found_routes.append(route)
-    return found_routes
+        )
+    ]
 
 
 def _get_route_from_func(

{cadwyn-4.4.3 → cadwyn-4.5.0}/cadwyn/routing.py

@@ -23,9 +23,9 @@ _logger = getLogger(__name__)
 
 
 class _RootHeaderAPIRouter(APIRouter):
-    """
-    this class should be a root router of the FastAPI app when using header based
-    versioning. It will be used to route the requests to the correct versioned route
+    """Root router of the FastAPI app when using header based versioning.
+
+    It will be used to route the requests to the correct versioned route
     based on the headers. It also supports waterflowing the requests to the latest
     version of the API if the request header doesn't match any of the versions.
 
@@ -88,9 +88,6 @@ class _RootHeaderAPIRouter(APIRouter):
         return self.versioned_routers[version_chosen].routes
 
     async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
-        """
-        The main entry point to the Router class.
-        """
         if "router" not in scope:  # pragma: no cover
             scope["router"] = self
 
@@ -131,10 +128,8 @@ class _RootHeaderAPIRouter(APIRouter):
         self.unversioned_routes.append(self.routes[-1])
 
     async def process_request(self, scope: Scope, receive: Receive, send: Send, routes: Sequence[BaseRoute]) -> None:
-        """
-        its a copy-paste from starlette.routing.Router
-        but in this version self.routes were replaced with routes from the function arguments
-        """
+        # It's a copy-paste from starlette.routing.Router
+        # but in this version self.routes were replaced with routes from the function arguments
 
         partial = None
         partial_scope = {}

{cadwyn-4.4.3 → cadwyn-4.5.0}/cadwyn/schema_generation.py

@@ -30,7 +30,6 @@ import pydantic
 import pydantic._internal._decorators
 from fastapi import Response
 from fastapi.routing import APIRoute
-from issubclass import issubclass
 from pydantic import BaseModel, Field, RootModel
 from pydantic._internal import _decorators
 from pydantic._internal._decorators import (
@@ -44,7 +43,7 @@ from pydantic._internal._decorators import (
 from pydantic.fields import ComputedFieldInfo, FieldInfo
 from typing_extensions import Doc, Self, _AnnotatedAlias, assert_never
 
-from cadwyn._utils import Sentinel, UnionType, fully_unwrap_decorator
+from cadwyn._utils import Sentinel, UnionType, fully_unwrap_decorator, lenient_issubclass
 from cadwyn.exceptions import InvalidGenerationInstructionError
 from cadwyn.structure.common import VersionDate
 from cadwyn.structure.data import ResponseInfo
@@ -159,9 +158,11 @@ def migrate_response_body(
     *,
     latest_body: Any,
     version: VersionDate | str,
-):
-    """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.
+) -> Any:
+    """Convert the data to a specific version
+
+    Apply all version changes from latest until the passed version in reverse order
+    and wrap the result in the correct version of latest_response_model
     """
     if isinstance(version, str):
         version = date.fromisoformat(version)
@@ -213,6 +214,10 @@ def _wrap_validator(func: Callable, is_pydantic_v1_style_validator: Any, decorat
         # There's an inconsistency in their interfaces so we gotta resort to this
         mode = kwargs.pop("mode", "after")
         kwargs["pre"] = mode != "after"
+        if (
+            isinstance(decorator_info, RootValidatorDecoratorInfo) and decorator_info.mode == "after"
+        ):  # pragma: no cover # TODO
+            kwargs["skip_on_failure"] = True
     if decorator_fields is not None:
         return _PerFieldValidatorWrapper(
             func=func, fields=list(decorator_fields), decorator=actual_decorator, kwargs=kwargs
@@ -271,7 +276,8 @@ class _PydanticModelWrapper(Generic[_T_PYDANTIC_MODEL]):
     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 "
+            "Fields that belong to this model, not to its parents. "
+            "I.e. The ones that were either defined or overridden "
         ),
     ] = dataclasses.field(repr=False)
     validators: dict[str, _PerFieldValidatorWrapper | _ValidatorWrapper] = dataclasses.field(repr=False)
@@ -316,7 +322,7 @@ class _PydanticModelWrapper(Generic[_T_PYDANTIC_MODEL]):
         for base in self.cls.mro()[1:]:
             if base in schemas:
                 parents.append(schemas[base])
-            elif issubclass(base, BaseModel):
+            elif lenient_issubclass(base, BaseModel):
                 parents.append(_wrap_pydantic_model(base))
         self._parents = parents
         return parents
@@ -372,10 +378,9 @@ def is_regular_function(call: Callable):
 
 
 class _CallableWrapper:
-    """__eq__ and __hash__ are needed to make sure that dependency overrides work correctly.
-    They are based on putting dependencies (functions) as keys for the dictionary so if we want to be able to
-    override the wrapper, we need to make sure that it is equivalent to the original in __hash__ and __eq__
-    """
+    # __eq__ and __hash__ are needed to make sure that dependency overrides work correctly.
+    # They are based on putting dependencies (functions) as keys for the dictionary so if we want to be able to
+    # override the wrapper, we need to make sure that it is equivalent to the original in __hash__ and __eq__
 
     def __init__(self, original_callable: Callable) -> None:
         super().__init__()
@@ -386,11 +391,9 @@ class _CallableWrapper:
 
     @property
     def __globals__(self):
-        """FastAPI uses __globals__ to resolve forward references in type hints
-        It's supposed to be an attribute on the function but we use it as property to prevent python
-        from trying to pickle globals when we deepcopy this wrapper
-        """
-        #
+        # FastAPI uses __globals__ to resolve forward references in type hints
+        # It's supposed to be an attribute on the function but we use it as property to prevent python
+        # from trying to pickle globals when we deepcopy this wrapper
         return self._original_callable.__globals__
 
     def __call__(self, *args: Any, **kwargs: Any):
@@ -420,8 +423,7 @@ class _AnnotationTransformer:
         )
 
     def change_version_of_annotation(self, annotation: Any) -> Any:
-        """Recursively go through all annotations and change them to the
-        annotations corresponding to the version passed.
+        """Recursively go through all annotations and change them to annotations corresponding to the version passed.
 
         So if we had a annotation "UserResponse" from "head" version, and we passed version of "2022-11-16", it would
         replace "UserResponse" with the the same class but from the "2022-11-16" version.
@@ -503,7 +505,7 @@ class _AnnotationTransformer:
             return annotation
 
     def _change_version_of_type(self, annotation: type):
-        if issubclass(annotation, BaseModel | Enum):
+        if lenient_issubclass(annotation, BaseModel | Enum):
             return self.generator[annotation]
         else:
             return annotation
@@ -607,7 +609,7 @@ def _add_request_and_response_params(route: APIRoute):
 
 @final
 class SchemaGenerator:
-    __slots__ = "annotation_transformer", "model_bundle", "concrete_models"
+    __slots__ = "annotation_transformer", "concrete_models", "model_bundle"
 
     def __init__(self, model_bundle: _ModelBundle) -> None:
         self.annotation_transformer = _AnnotationTransformer(self)
@@ -619,7 +621,11 @@ class SchemaGenerator:
         }
 
     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):
+        if (
+            not isinstance(model, type)
+            or not lenient_issubclass(model, BaseModel | Enum)
+            or model in (BaseModel, RootModel)
+        ):
             return model
         model = _unwrap_model(model)
 
@@ -648,10 +654,10 @@ class SchemaGenerator:
         elif model in self.model_bundle.enums:
             return self.model_bundle.enums[model]
 
-        if issubclass(model, BaseModel):
+        if lenient_issubclass(model, BaseModel):
             wrapper = _wrap_pydantic_model(model)
             self.model_bundle.schemas[model] = wrapper
-        elif issubclass(model, Enum):
+        elif lenient_issubclass(model, Enum):
             wrapper = _EnumWrapper(model)
             self.model_bundle.enums[model] = wrapper
         else: