fastapi-rtk 2.12.3__tar.gz → 2.12.4__tar.gz

{fastapi_rtk-2.12.3 → fastapi_rtk-2.12.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: fastapi-rtk
-Version: 2.12.3
+Version: 2.12.4
 Summary: A package that provides a set of tools to build a FastAPI application with a Class-Based CRUD API.
 Project-URL: Homepage, https://codeberg.org/datatactics/fastapi-rtk
 Project-URL: Issues, https://codeberg.org/datatactics/fastapi-rtk/issues

fastapi_rtk-2.12.4/fastapi_rtk/_version.py

@@ -0,0 +1 @@
+__version__ = "2.12.4"

{fastapi_rtk-2.12.3 → fastapi_rtk-2.12.4}/fastapi_rtk/bases/__init__.py

@@ -23,7 +23,6 @@ __all__ = [
     "PydanticGenerationSchema",
     "AbstractInterface",
     "AbstractLoopManager",
-    "MissingGreenletError",
     "BasicModel",
     "AbstractSession",
     "AbstractUserSerializer",

{fastapi_rtk-2.12.3 → fastapi_rtk-2.12.4}/fastapi_rtk/bases/interface.py

@@ -11,7 +11,7 @@ import pydantic
 import sqlalchemy.exc
 
 from ..const import logger
-from ..exceptions import FastAPIReactToolkitException, raise_exception
+from ..exceptions import MissingGreenletError, raise_exception
 from ..globals import g
 from ..schemas import PRIMARY_KEY, ColumnEnumInfo, ColumnInfo, ColumnRelationInfo
 from ..utils import AsyncTaskRunner, C, T, deep_merge, lazy_self, smart_run
@@ -32,7 +32,6 @@ if typing.TYPE_CHECKING:
 __all__ = [
     "PydanticGenerationSchema",
     "AbstractInterface",
-    "MissingGreenletError",
 ]
 
 
@@ -56,70 +55,6 @@ class PydanticGenerationSchema(typing.TypedDict):
     name_: tuple[type[str], pydantic.Field] | None
 
 
-class MissingGreenletError(FastAPIReactToolkitException):
-    """Raised when an ORM attribute access during pydantic schema validation
-    triggers a SQLAlchemy lazy-load outside the asyncio greenlet.
-
-    Covers both async-property columns (awaited explicitly by
-    ``_populate_async_column``) and regular columns / relationships read by
-    pydantic's ``from_attributes`` machinery.
-
-    The most common causes are:
-
-    - The ORM instance is detached from its session (commit/close happened
-      before the schema was rendered).
-    - The async session was expired between the query and the
-      response-serialisation step.
-    - A relationship the schema reads has not been eager-loaded. Prefer
-      ``selectinload`` / ``joinedload`` on the query, call
-      ``await instance.load("<col>")`` before returning the instance, or
-      add the column to ``list_columns`` / ``show_columns`` (or the
-      narrower ``list_select_columns`` / ``show_select_columns``, or
-      ``extra_list_fetch_columns`` / ``extra_show_fetch_columns`` when
-      the column should be fetched but not surfaced in the response) on
-      the ``ModelRestApi`` subclass so the toolkit eager-loads it for
-      you.
-    """
-
-    def __init__(self, *, model, col: str | None, original: Exception):
-        self.model = model
-        self.col = col
-        self.original = original
-        model_label = type(model).__name__
-        if col is None:
-            super().__init__(
-                f"Failed to validate schema for '{model_label}': SQLAlchemy "
-                f"raised MissingGreenlet while pydantic accessed an attribute. "
-                f"Fix by eager-loading the missing relationship "
-                f"(`selectinload` / `joinedload`), by calling "
-                f'`await instance.load("<col>")` before the instance leaves '
-                f"the async context, or by adding the column to "
-                f"`list_columns` / `show_columns` (or the narrower "
-                f"`list_select_columns` / `show_select_columns`, or "
-                f"`extra_list_fetch_columns` / `extra_show_fetch_columns` "
-                f"when the column should be fetched but not surfaced in the "
-                f"response) on the ModelRestApi subclass. Original error: "
-                f"{original!r}."
-            )
-        else:
-            super().__init__(
-                f"Failed to populate column '{col}' on '{model_label}': "
-                f"SQLAlchemy raised MissingGreenlet. The ORM attempted I/O "
-                f"outside the async greenlet. Fix by eager-loading the "
-                f"underlying relationship "
-                f"(e.g. add `selectinload({model_label}.{col})` or "
-                f"`joinedload({model_label}.{col})` to the query), by "
-                f'calling `await instance.load("{col}")` before the instance '
-                f'leaves the async context, or by adding `"{col}"` to '
-                f"`list_columns` / `show_columns` (or the narrower "
-                f"`list_select_columns` / `show_select_columns`, or "
-                f"`extra_list_fetch_columns` / `extra_show_fetch_columns` "
-                f"when the column should be fetched but not surfaced in the "
-                f"response) on the ModelRestApi subclass. Original error: "
-                f"{original!r}."
-            )
-
-
 class lazy(lazy_self["AbstractInterface", T]): ...
 
 
@@ -1081,7 +1016,7 @@ class AbstractInterface(abc.ABC, typing.Generic[T, C, CT]):
         try:
             value = await getattr(model, col)
         except sqlalchemy.exc.MissingGreenlet as e:
-            raise MissingGreenletError(
+            raise MissingGreenletError.from_attribute_read(
                 model=model,
                 col=col,
                 original=e,
@@ -1119,7 +1054,7 @@ class AbstractInterface(abc.ABC, typing.Generic[T, C, CT]):
                 try:
                     getattr(value, field_name)
                 except sqlalchemy.exc.MissingGreenlet as e:
-                    raise MissingGreenletError(
+                    raise MissingGreenletError.from_attribute_read(
                         model=value,
                         col=field_name,
                         original=e,

fastapi_rtk-2.12.4/fastapi_rtk/exceptions.py

@@ -0,0 +1,235 @@
+import types
+import typing
+
+import fastapi
+import pydantic
+import sqlalchemy.exc
+
+from .utils import T, prettify_dict
+
+__all__ = [
+    "raise_exception",
+    "FastAPIReactToolkitException",
+    "RolesMismatchException",
+    "HTTPWithValidationException",
+    "MissingGreenletError",
+]
+
+
+def raise_exception(message: str, return_type: type[T] | None = None) -> T:
+    """
+    Raise a FastAPIReactToolkitException with the given message.
+
+    Args:
+        message (str): The error message.
+        return_type (type[T] | None, optional): The expected return type. Defaults to None.
+
+    Raises:
+        FastAPIReactToolkitException: Always raised.
+
+    Returns:
+        T: The return value.
+    """
+    raise FastAPIReactToolkitException(message)
+
+
+class FastAPIReactToolkitException(Exception):
+    """Base exception for FastAPI React Toolkit errors."""
+
+
+class RolesMismatchException(FastAPIReactToolkitException):
+    """Exception raised when the roles do not match the expected roles."""
+
+
+class HTTPWithValidationException(fastapi.HTTPException):
+    """
+    Custom HTTP Exception for FastAPI with validation details.
+    """
+
+    URL = f"https://errors.pydantic.dev/{pydantic.version.version_short()}/v"
+    _no_input = object()
+
+    def __init__(
+        self,
+        status_code: int,
+        type: str,
+        location_type: typing.Literal["path", "query", "body"],
+        field: str,
+        msg: str,
+        input: typing.Any = _no_input,
+        headers: dict[str, str] | None = None,
+    ):
+        """
+        Initialize the HTTPWithValidationException.
+
+        Args:
+            status_code (int): HTTP status code for the exception.
+            type (str): Type of the error (e.g., "string_type", "validation_error").
+            location_type (typing.Literal["path", "query", "body"]): Location type of the error, either "path", "query", or "body".
+            field (str): Field name where the error occurred.
+            msg (str): Error message describing the validation issue.
+            input (typing.Any, optional): Optional input value that caused the error. Defaults to _no_input.
+            headers (dict[str, str] | None, optional): Optional headers to include in the response. Defaults to None.
+        """
+        obj = {"type": type, "loc": [location_type, field], "msg": msg}
+        if input is not self._no_input:
+            if isinstance(input, pydantic.BaseModel):
+                input = input.model_dump(mode="json")
+            else:
+                input = str(input)
+            obj["input"] = input
+        obj["url"] = f"{self.URL}/{type}"
+
+        super().__init__(status_code, [obj], headers)
+
+
+class MissingGreenletError(FastAPIReactToolkitException):
+    """Raised when an ORM attribute access triggers a SQLAlchemy lazy-load
+    outside the asyncio greenlet.
+
+    Covers async-property columns (awaited explicitly by
+    ``_populate_async_column``), regular columns / relationships read by
+    pydantic's ``from_attributes`` machinery, and any attribute read by
+    application code during a request (hooks, filters, custom endpoints),
+    which ``globals_middleware_dispatch`` converts through
+    ``from_lazy_load``.
+
+    The most common causes are:
+
+    - The ORM instance is detached from its session (commit/close happened
+      before the schema was rendered).
+    - The async session was expired between the query and the
+      response-serialisation step.
+    - A relationship the schema reads has not been eager-loaded. Prefer
+      ``selectinload`` / ``joinedload`` on the query, call
+      ``await instance.load("<col>")`` before returning the instance, or
+      add the column to ``list_columns`` / ``show_columns`` (or the
+      narrower ``list_select_columns`` / ``show_select_columns``, or
+      ``extra_list_fetch_columns`` / ``extra_show_fetch_columns`` when
+      the column should be fetched but not surfaced in the response) on
+      the ``ModelRestApi`` subclass so the toolkit eager-loads it for
+      you.
+    """
+
+    def __init__(
+        self,
+        *,
+        model,
+        col: str | None,
+        source: str | None = None,
+        original: Exception,
+    ):
+        self.model = model
+        self.col = col
+        self.original = original
+        self.source = source
+        model_label = type(model).__name__
+        col_label = col or "<col>"
+        detail = {}
+        if col is None:
+            detail["problem"] = (
+                f"Failed to validate schema for '{model_label}': SQLAlchemy raised "
+                f"MissingGreenlet while pydantic read an attribute."
+            )
+        else:
+            detail["problem"] = (
+                f"Failed to populate column '{col}' on '{model_label}': SQLAlchemy "
+                f"raised MissingGreenlet, the ORM attempted I/O outside the async "
+                f"greenlet."
+            )
+        if source:
+            detail["accessed at"] = source
+        detail["fix by any of"] = [
+            f"Eager-load the relationship: add `selectinload({model_label}.{col_label})` or `joinedload({model_label}.{col_label})` to the query.",
+            f'Load it before the instance leaves the async context: `await instance.load("{col_label}")`.',
+            f'Add `"{col_label}"` to `list_columns` / `show_columns` on the ModelRestApi subclass, or to the narrower `list_select_columns` / `show_select_columns`.',
+            f'Add `"{col_label}"` to `extra_list_fetch_columns` / `extra_show_fetch_columns` when the column should be fetched but not surfaced in the response.',
+        ]
+        detail["original error"] = repr(original)
+        super().__init__("\n" + prettify_dict(detail))
+
+    @classmethod
+    def from_lazy_load(cls, original: sqlalchemy.exc.MissingGreenlet):
+        """
+        Build an enriched error from a MissingGreenlet raised by an ORM attribute read.
+
+        Args:
+            original (sqlalchemy.exc.MissingGreenlet): The exception SQLAlchemy raised.
+
+        Returns:
+            MissingGreenletError | None: The enriched error, or None when the traceback carries no ORM attribute read to name.
+        """
+        model, col = _lazy_load_target(original.__traceback__)
+        if model is None or col is None:
+            return None
+        return cls.from_attribute_read(model=model, col=col, original=original)
+
+    @classmethod
+    def from_attribute_read(cls, *, model, col: str | None, original: Exception):
+        """
+        Build the error for a known model and column, taking the call site from the traceback.
+
+        Args:
+            model: The model whose attribute was read.
+            col (str | None): The column that was read, or None when pydantic validation failed on an unnamed attribute.
+            original (Exception): The exception SQLAlchemy raised.
+
+        Returns:
+            MissingGreenletError: The error, carrying the call site when the traceback holds one.
+        """
+        return cls(
+            model=model,
+            col=col,
+            source=_lazy_load_source(original.__traceback__),
+            original=original,
+        )
+
+
+def _lazy_load_target(tb: types.TracebackType | None):
+    """
+    Find the ORM instance and attribute name whose read triggered a lazy load.
+
+    Args:
+        tb (types.TracebackType | None): Traceback of the raised MissingGreenlet.
+
+    Returns:
+        tuple: The ORM instance and its column name, or (None, None) when the traceback holds no attribute read.
+    """
+    while tb is not None:
+        frame = tb.tb_frame
+        if (
+            frame.f_code.co_name == "__get__"
+            and frame.f_globals.get("__name__") == "sqlalchemy.orm.attributes"
+        ):
+            instance = frame.f_locals.get("instance")
+            col = getattr(frame.f_locals.get("self"), "key", None)
+            if instance is not None and col:
+                return instance, col
+        tb = tb.tb_next
+    return None, None
+
+
+def _lazy_load_source(tb: types.TracebackType | None):
+    """
+    Locate the call site that triggered the lazy load, the last non-toolkit frame before SQLAlchemy took over.
+
+    Toolkit frames are skipped because the schema-validation probe reads every field itself, so its own line names no code the reader can act on.
+
+    Args:
+        tb (types.TracebackType | None): Traceback of the raised MissingGreenlet.
+
+    Returns:
+        str | None: A "path:line in function" label, or None when only SQLAlchemy and toolkit frames read the attribute.
+    """
+    caller = None
+    while tb is not None:
+        module = tb.tb_frame.f_globals.get("__name__", "")
+        if module.startswith("sqlalchemy."):
+            break
+        if not module.startswith("fastapi_rtk."):
+            caller = tb
+        tb = tb.tb_next
+    if caller is None:
+        return None
+    code = caller.tb_frame.f_code
+    return f"{code.co_filename}:{caller.tb_lineno} in {code.co_name}"

{fastapi_rtk-2.12.3 → fastapi_rtk-2.12.4}/fastapi_rtk/globals.py

@@ -40,6 +40,7 @@ import contextvars
 import typing
 
 import fastapi
+import sqlalchemy.exc
 import starlette.middleware.base
 import starlette.types
 import werkzeug.local
@@ -51,6 +52,7 @@ from .const import (
     COOKIE_CONFIG,
     COOKIE_STRATEGY_CONFIG,
 )
+from .exceptions import MissingGreenletError
 from .utils import lazy, lazy_import
 
 if typing.TYPE_CHECKING:
@@ -240,14 +242,31 @@ async def globals_middleware_dispatch(
     request: fastapi.Request,
     call_next: collections.abc.Callable,
 ) -> fastapi.Response:
-    """Dispatch the request in a new context to allow globals to be used."""
+    """
+    Dispatch the request in a new context to allow globals to be used.
+
+    Args:
+        request (fastapi.Request): The incoming request.
+        call_next (collections.abc.Callable): The next handler in the middleware chain.
 
+    Raises:
+        MissingGreenletError: When a lazy-load of an ORM attribute happened outside the asyncio greenlet, naming the model, the column, and the call site.
+
+    Returns:
+        fastapi.Response: The response produced by the rest of the chain.
+    """
     ctx = contextvars.copy_context()
 
     def _call_next() -> collections.abc.Awaitable[fastapi.Response]:
         return call_next(request)
 
-    return await ctx.run(_call_next)
+    try:
+        return await ctx.run(_call_next)
+    except sqlalchemy.exc.MissingGreenlet as e:
+        enriched = MissingGreenletError.from_lazy_load(e)
+        if not enriched:
+            raise
+        raise enriched from e
 
 
 class GlobalsMiddleware(starlette.middleware.base.BaseHTTPMiddleware):  # noqa

{fastapi_rtk-2.12.3 → fastapi_rtk-2.12.4}/tests/conftest.py

@@ -14,6 +14,9 @@ import typing
 
 import fastapi
 import pytest
+import sqlalchemy
+import sqlalchemy.ext.asyncio
+import sqlalchemy.orm
 
 from fastapi_rtk.globals import g
 
@@ -205,3 +208,67 @@ def make_toolkit_app(tmp_path, config_setter):
     # Tear down in reverse order.
     while cleanup_stack:
         cleanup_stack.pop()()
+
+
+@pytest.fixture
+def lazy_parent():
+    """Factory fixture: returns an async context manager yielding a persistent ORM instance whose `child` relationship is unloaded, so reading it raises a real sqlalchemy MissingGreenlet."""
+
+    return _lazy_parent
+
+
+@pytest.fixture
+def raise_lazy_load(lazy_parent):
+    """Factory fixture: returns an async callable that reads the unloaded relationship itself, so the raising frame is application code.
+
+    Args:
+        lazy_parent: The factory yielding the ORM instance.
+
+    Returns:
+        collections.abc.Callable: The async callable that raises.
+    """
+
+    async def _raise():
+        async with lazy_parent() as parent:
+            parent.child
+
+    return _raise
+
+
+@contextlib.asynccontextmanager
+async def _lazy_parent():
+    """
+    Yield a persistent ORM instance backed by an in-memory aiosqlite engine, with its `child` relationship left unloaded.
+
+    Yields:
+        Parent: The instance, still attached to an open AsyncSession.
+    """
+    base = sqlalchemy.orm.declarative_base()
+
+    class Child(base):
+        __tablename__ = "greenlet_child"
+        id = sqlalchemy.Column(sqlalchemy.Integer, primary_key=True)
+
+    class Parent(base):
+        __tablename__ = "greenlet_parent"
+        id = sqlalchemy.Column(sqlalchemy.Integer, primary_key=True)
+        child_id = sqlalchemy.Column(
+            sqlalchemy.Integer, sqlalchemy.ForeignKey("greenlet_child.id")
+        )
+        child = sqlalchemy.orm.relationship("Child")
+
+        @property
+        def child_via_property(self):
+            return self.child
+
+    engine = sqlalchemy.ext.asyncio.create_async_engine("sqlite+aiosqlite://")
+    try:
+        async with engine.begin() as conn:
+            await conn.run_sync(base.metadata.create_all)
+        async with sqlalchemy.ext.asyncio.AsyncSession(engine) as session:
+            session.add(Parent(id=1, child=Child(id=1)))
+            await session.commit()
+        async with sqlalchemy.ext.asyncio.AsyncSession(engine) as session:
+            yield await session.get(Parent, 1)
+    finally:
+        await engine.dispose()

{fastapi_rtk-2.12.3 → fastapi_rtk-2.12.4}/tests/unit/bases/test_interface.py

@@ -1,3 +1,4 @@
+import types
 import typing
 import warnings
 
@@ -6,11 +7,8 @@ import pytest
 import sqlalchemy.exc
 
 from fastapi_rtk import AsyncTaskRunner
-from fastapi_rtk.bases.interface import (
-    AbstractInterface,
-    MissingGreenletError,
-    PydanticGenerationSchema,
-)
+from fastapi_rtk.bases.interface import AbstractInterface, PydanticGenerationSchema
+from fastapi_rtk.exceptions import MissingGreenletError
 
 
 class TestPydanticGenerationSchema:
@@ -346,6 +344,21 @@ async def test_populate_async_column_raises_on_missing_greenlet():
     assert isinstance(excinfo.value.__cause__, sqlalchemy.exc.MissingGreenlet)
 
 
+@pytest.mark.asyncio
+async def test_populate_async_column_names_the_call_site(raise_lazy_load):
+    """The async column body is user code, so its frame must reach the message."""
+
+    interface = _make_concrete_subclass()(obj=type("M", (), {}))
+    model = types.SimpleNamespace(boom=raise_lazy_load())
+
+    with pytest.raises(MissingGreenletError) as excinfo:
+        await interface._populate_async_column(model, "boom")
+
+    assert excinfo.value.source.endswith("in _raise")
+    assert "conftest.py" in excinfo.value.source
+    assert "accessed at" in str(excinfo.value)
+
+
 @pytest.mark.asyncio
 async def test_populate_async_column_raises_on_non_greenlet_error():
     interface = _make_concrete_subclass()(obj=type("M", (), {}))
@@ -407,6 +420,64 @@ def test_before_validator_raises_on_greenlet_for_regular_attribute():
     assert isinstance(excinfo.value.__cause__, sqlalchemy.exc.MissingGreenlet)
 
 
+def _probe_schema(interface, field: str, name: str):
+    """Build a schema carrying only the greenlet probe and one field.
+
+    Args:
+        interface: The interface generating the schema.
+        field (str): The field the probe reads.
+        name (str): The schema name, kept unique per test to bypass the schema cache.
+
+    Returns:
+        type[pydantic.BaseModel]: The generated schema.
+    """
+    schema_dict = PydanticGenerationSchema(
+        __config__=pydantic.ConfigDict(from_attributes=True),
+        __async_columns__=[],
+        __columns__=None,
+        __with_id__=False,
+        __with_name__=False,
+        __with_property__=True,
+        __optional__=False,
+        __hide_sensitive_columns__=False,
+        __with_fk__=True,
+        __name__=name,
+    )
+    schema_dict[field] = (typing.Any, pydantic.Field(default=None))
+    return interface._generate_schema_from_dict(schema_dict)
+
+
+@pytest.mark.asyncio
+async def test_probe_on_mapped_column_reports_no_call_site(lazy_parent):
+    """The probe reads the attribute itself, so its own frame names no code the reader can act on."""
+
+    interface = _make_concrete_subclass()(obj=type("M", (), {}))
+    Schema = _probe_schema(interface, "child", "ProbeMappedSchema")
+
+    async with lazy_parent() as parent:
+        with pytest.raises(MissingGreenletError) as excinfo:
+            Schema.model_validate(parent)
+
+    assert excinfo.value.col == "child"
+    assert excinfo.value.source is None
+    assert "accessed at" not in str(excinfo.value)
+
+
+@pytest.mark.asyncio
+async def test_probe_through_property_names_the_property(lazy_parent):
+    """A python property reading ORM state is application code, so its frame must reach the message."""
+
+    interface = _make_concrete_subclass()(obj=type("M", (), {}))
+    Schema = _probe_schema(interface, "child_via_property", "ProbePropertySchema")
+
+    async with lazy_parent() as parent:
+        with pytest.raises(MissingGreenletError) as excinfo:
+            Schema.model_validate(parent)
+
+    assert excinfo.value.source.endswith("in child_via_property")
+    assert "conftest.py" in excinfo.value.source
+
+
 @pytest.mark.asyncio
 async def test_before_validator_skips_async_columns_no_unawaited_coroutine():
     """The greenlet probe must skip async-property columns. Probing them via

{fastapi_rtk-2.12.3 → fastapi_rtk-2.12.4}/tests/unit/test_exceptions.py

@@ -1,9 +1,11 @@
 import fastapi
 import pydantic
 import pytest
+import sqlalchemy.exc
 from fastapi_rtk.exceptions import (
     FastAPIReactToolkitException,
     HTTPWithValidationException,
+    MissingGreenletError,
     RolesMismatchException,
     raise_exception,
 )
@@ -105,3 +107,31 @@ class TestHTTPWithValidationException:
             msg="m",
         )
         assert "input" not in exc.detail[0]
+
+
+class TestFromLazyLoad:
+    @pytest.mark.asyncio
+    async def test_names_model_column_and_call_site(self, raise_lazy_load):
+        with pytest.raises(sqlalchemy.exc.MissingGreenlet) as excinfo:
+            await raise_lazy_load()
+
+        error = MissingGreenletError.from_lazy_load(excinfo.value)
+
+        assert error is not None
+        assert error.col == "child"
+        assert type(error.model).__name__ == "Parent"
+        assert error.source.endswith("in _raise")
+        assert "conftest.py" in error.source
+        msg = str(error)
+        assert "'child'" in msg
+        assert "'Parent'" in msg
+        assert "accessed at" in msg
+        assert "selectinload" in msg
+
+    def test_returns_none_without_attribute_read(self):
+        try:
+            raise sqlalchemy.exc.MissingGreenlet(
+                "greenlet_spawn has not been called; can't call await_only() here"
+            )
+        except sqlalchemy.exc.MissingGreenlet as e:
+            assert MissingGreenletError.from_lazy_load(e) is None

{fastapi_rtk-2.12.3 → fastapi_rtk-2.12.4}/tests/unit/test_globals.py

@@ -2,6 +2,7 @@ import asyncio
 import contextvars
 
 import pytest
+import sqlalchemy.exc
 
 from fastapi_rtk.config import Config
 from fastapi_rtk.globals import (
@@ -172,3 +173,40 @@ class TestBasicCallback:
         assert ac.bearer_config["tokenUrl"] == "/custom/login"
         assert ac.cookie_strategy_config["lifetime_seconds"] == 1234
         assert ac.bearer_strategy_config["lifetime_seconds"] == 5678
+
+
+class TestGlobalsMiddlewareDispatch:
+    @pytest.mark.asyncio
+    async def test_lazy_load_error_is_enriched(self, raise_lazy_load):
+        from fastapi_rtk.exceptions import MissingGreenletError
+        from fastapi_rtk.globals import globals_middleware_dispatch
+
+        async def call_next(request):
+            await raise_lazy_load()
+
+        with pytest.raises(MissingGreenletError) as excinfo:
+            await globals_middleware_dispatch(None, call_next)
+
+        assert excinfo.value.col == "child"
+        assert isinstance(excinfo.value.__cause__, sqlalchemy.exc.MissingGreenlet)
+
+    @pytest.mark.asyncio
+    async def test_missing_greenlet_without_attribute_read_propagates(self):
+        from fastapi_rtk.globals import globals_middleware_dispatch
+
+        async def call_next(request):
+            raise sqlalchemy.exc.MissingGreenlet(
+                "greenlet_spawn has not been called; can't call await_only() here"
+            )
+
+        with pytest.raises(sqlalchemy.exc.MissingGreenlet):
+            await globals_middleware_dispatch(None, call_next)
+
+    @pytest.mark.asyncio
+    async def test_response_passes_through(self):
+        from fastapi_rtk.globals import globals_middleware_dispatch
+
+        async def call_next(request):
+            return "response"
+
+        assert await globals_middleware_dispatch(None, call_next) == "response"

fastapi_rtk-2.12.3/fastapi_rtk/_version.py

@@ -1 +0,0 @@
-__version__ = "2.12.3"