fastapi-rtk 2.1.5__tar.gz → 2.2.0__tar.gz

{fastapi_rtk-2.1.5 → fastapi_rtk-2.2.0}/.gitignore

@@ -218,6 +218,9 @@ web_modules/
 # Optional stylelint cache
 .stylelintcache
 
+# Storybook build output
+storybook-static/
+
 # Microbundle cache
 .rpt2_cache/
 .rts2_cache_cjs/

{fastapi_rtk-2.1.5 → fastapi_rtk-2.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastapi-rtk
-Version: 2.1.5
+Version: 2.2.0
 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.2.0/fastapi_rtk/_version.py

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

{fastapi_rtk-2.1.5 → fastapi_rtk-2.2.0}/fastapi_rtk/backends/sqla/db.py

@@ -31,6 +31,9 @@ LOAD_TYPE_MAPPING = {
     "all": 2,
 }
 
+# Cap for _load_options_cache; keys include a client-reachable column subset, so an unbounded cache is a memory-growth vector.
+_LOAD_OPTIONS_CACHE_MAXSIZE = 1024
+
 
 class LoadColumn(typing.TypedDict):
     statement: Select[tuple[T]] | _AbstractLoad
@@ -68,7 +71,9 @@ class SQLAQueryBuilder(AbstractQueryBuilder[Select[tuple[T]]]):
     ```
     """
 
-    _load_options_cache: dict[str, list[list[_AbstractLoad] | _AbstractLoad]] = {}
+    _load_options_cache: collections.OrderedDict[
+        str, list[list[_AbstractLoad] | _AbstractLoad]
+    ] = collections.OrderedDict()
 
     def __init__(self, datamodel, statement=None):
         if self.statement is None:
@@ -97,6 +102,7 @@ class SQLAQueryBuilder(AbstractQueryBuilder[Select[tuple[T]]]):
         # Check if the columns have been loaded before
         cache_key = f"{self.datamodel.obj.__name__}-{list_columns}"
         if cache_key in self._load_options_cache:
+            self._load_options_cache.move_to_end(cache_key)
             logger.debug(f"Loading columns from cache: {cache_key}")
             for cache_option in self._load_options_cache[cache_key]:
                 if isinstance(cache_option, list):
@@ -113,15 +119,8 @@ class SQLAQueryBuilder(AbstractQueryBuilder[Select[tuple[T]]]):
         return statement.offset(page * page_size).limit(page_size)
 
     def apply_order_by(self, statement, order_column, order_direction):
-        col = order_column
-
-        #! If the order column comes from a request, it will be in the format ClassName.column_name
-        if col.startswith(
-            self.datamodel.obj.__class__.__name__
-        ):  # pragma: no cover - obj.__class__.__name__ is metaclass name (DeclarativeMeta), almost never matches
-            col = col.split(".", 1)[1]
-
-        statement, col = self._retrieve_column(statement, col)
+        # A request may send the order column as ``ClassName.column``; _retrieve_column resolves it by landing on the final path segment.
+        statement, col = self._retrieve_column(statement, order_column)
         if order_direction == "asc":
             statement = statement.order_by(col)
         else:
@@ -336,6 +335,8 @@ class SQLAQueryBuilder(AbstractQueryBuilder[Select[tuple[T]]]):
         if columns:
             cache_key = f"{self.datamodel.obj.__name__}-{columns}"
             self._load_options_cache[cache_key] = []
+            if len(self._load_options_cache) > _LOAD_OPTIONS_CACHE_MAXSIZE:
+                self._load_options_cache.popitem(last=False)
         if load_column["type"] == "defer":
             defers = [
                 defer(getattr(self.datamodel.obj, col))

{fastapi_rtk-2.1.5 → fastapi_rtk-2.2.0}/fastapi_rtk/bases/interface.py

@@ -207,6 +207,12 @@ class AbstractInterface(abc.ABC, typing.Generic[T, C, CT]):
     logger = lazy(
         lambda self: logger.getChild(f"{self.__class__.__name__}[{self.obj.__name__}]")
     )
+    _related_interfaces = lazy(
+        lambda: dict[tuple[typing.Any, bool | None], "AbstractInterface"]()
+    )
+    """
+    Cache of related interfaces keyed by `(related model, with_fk)`, so repeated lookups reuse the lazily computed attributes.
+    """
 
     _cache_schema: dict[str, typing.Type[pydantic.BaseModel]] = {}
 
@@ -867,6 +873,8 @@ class AbstractInterface(abc.ABC, typing.Generic[T, C, CT]):
         """
         Gets the related interface for a given column name.
 
+        Interfaces are cached per `(related model, with_fk)`, so repeated lookups reuse the same instance and its lazily computed attributes.
+
         Args:
             col_name (str): The name of the column for which to get the related interface.
             with_fk (bool | None, optional): Whether to include foreign keys in the related interface. Defaults to None.
@@ -874,7 +882,12 @@ class AbstractInterface(abc.ABC, typing.Generic[T, C, CT]):
         Returns:
             typing.Self: The related interface for the specified column name.
         """
-        return type(self)(self.get_related_model(col_name), with_fk)
+        key = (self.get_related_model(col_name), with_fk)
+        interface = self._related_interfaces.get(key)
+        if interface is None:
+            interface = type(self)(key[0], with_fk)
+            self._related_interfaces[key] = interface
+        return interface
 
     """
     --------------------------------------------------------------------------------------------------------
@@ -1084,6 +1097,8 @@ class AbstractInterface(abc.ABC, typing.Generic[T, C, CT]):
             if value is None or isinstance(value, dict):
                 return value
             for field_name in cls.model_fields:
+                if field_name in async_columns:
+                    continue
                 try:
                     getattr(value, field_name)
                 except sqlalchemy.exc.MissingGreenlet as e:

{fastapi_rtk-2.1.5 → fastapi_rtk-2.2.0}/fastapi_rtk/fastapi_react_toolkit.py

@@ -642,6 +642,10 @@ class FastAPIReactToolkit:
             # Add the endpoint for the metrics
             self.instrumentator.expose(app, **Setting.INSTRUMENTATOR_EXPOSE_CONFIG)
 
+            # The engine is created once in initialize(); a prior lifespan shutdown disposes it, so re-init on re-entry.
+            if db._engine is None:
+                self.connect_to_database()
+
             await db.init_fastapi_rtk_tables()
 
             if self.upgrade_db:

{fastapi_rtk-2.1.5 → fastapi_rtk-2.2.0}/fastapi_rtk/globals.py

@@ -88,10 +88,6 @@ class Globals:
     """
     A boolean value to indicate if the application is loaded by the CLI. `True` when you are running a command from `fastapi-rtk` CLI.
     """
-    is_migrate: bool
-    """
-    Deprecated alias of `is_cli`. TODO(next-minor): remove.
-    """
     sensitive_data: dict[str, list[str]]
     """
     A dictionary used to store list of sensitive columns for each model that should not be returned in the list and get endpoints. Default is `{"User": ["password", "hashed_password"]}`.
@@ -286,8 +282,6 @@ g.set_default(
 )
 g.set_default("config", Config())
 g.set_default("is_cli", False)
-# TODO(next-minor): remove. Deprecated alias; resolves to `is_cli`.
-g.set_default("is_migrate", lazy(lambda: g.is_cli))
 g.set_default("sensitive_data", {"User": ["password", "hashed_password"]})
 g.set_default(
     "file_manager",

{fastapi_rtk-2.1.5 → fastapi_rtk-2.2.0}/fastapi_rtk/utils/run_utils.py

@@ -45,23 +45,27 @@ async def smart_run(
 
 
 def smart_run_sync(
-    func: typing.Callable[P, typing.Union[T, typing.Awaitable[T]]],
-    *args: P.args,
-    **kwargs: P.kwargs,
+    func: typing.Callable[..., typing.Union[T, typing.Awaitable[T]]],
+    *args: typing.Any,
+    loop: asyncio.AbstractEventLoop | None = None,
+    **kwargs: typing.Any,
 ) -> T:
     """
     Run a function synchronously, or run an async function in a thread pool so it can be called from a synchronous context.
 
+    ``loop`` is reserved by this helper and is not forwarded to ``func``.
+
     Args:
-        func (typing.Callable[P, typing.Union[T, typing.Awaitable[T]]]): The function to be executed.
-        *args (P.args): Positional arguments to be passed to the function.
-        **kwargs (P.kwargs): Keyword arguments to be passed to the function.
+        func (typing.Callable[..., typing.Union[T, typing.Awaitable[T]]]): The function to be executed.
+        *args: Positional arguments to be passed to the function.
+        loop (asyncio.AbstractEventLoop | None, optional): A running event loop to submit an async ``func`` to. Defaults to None, which runs it on a fresh loop in a thread pool.
+        **kwargs: Keyword arguments to be passed to the function.
 
     Returns:
         T: The result of the function execution.
     """
     if inspect.iscoroutinefunction(func):
-        return run_coroutine_in_threadpool(func(*args, **kwargs))
+        return run_coroutine_in_threadpool(func(*args, **kwargs), loop=loop)
     return func(*args, **kwargs)
 
 
@@ -83,6 +87,7 @@ async def safe_call(coro: typing.Coroutine[typing.Any, typing.Any, T] | T) -> T:
 def safe_call_sync(
     result_or_coro: typing.Union[T, typing.Coroutine[typing.Any, typing.Any, T]],
     max_workers: int = 1,
+    loop: asyncio.AbstractEventLoop | None = None,
     **kwargs: typing.Any,
 ) -> T:
     """
@@ -91,6 +96,7 @@ def safe_call_sync(
     Args:
         result_or_coro (typing.Union[T, typing.Coroutine[typing.Any, typing.Any, T]]): The result or coroutine to be executed.
         max_workers (int, optional): The maximum number of workers in the thread pool. Defaults to 1.
+        loop (asyncio.AbstractEventLoop | None, optional): A running event loop to submit the coroutine to. Defaults to None, which runs the coroutine on a fresh loop in a thread pool.
         **kwargs: Additional keyword arguments to pass to the `ThreadPoolExecutor`.
 
     Returns:
@@ -98,25 +104,37 @@ def safe_call_sync(
     """
     if isinstance(result_or_coro, typing.Coroutine):
         return run_coroutine_in_threadpool(
-            result_or_coro, max_workers=max_workers, **kwargs
+            result_or_coro, max_workers=max_workers, loop=loop, **kwargs
         )
     return result_or_coro
 
 
 def run_coroutine_in_threadpool(
-    coro: typing.Coroutine[typing.Any, typing.Any, T], max_workers=1, **kwargs
+    coro: typing.Coroutine[typing.Any, typing.Any, T],
+    max_workers=1,
+    loop: asyncio.AbstractEventLoop | None = None,
+    **kwargs,
 ):
     """
     Run a coroutine in a thread pool executor.
 
+    When ``loop`` is given, the coroutine is submitted to that already-running
+    loop via ``asyncio.run_coroutine_threadsafe`` instead of a throwaway loop.
+    This keeps loop-bound resources (asyncpg pools, redis asyncio clients,
+    ``asyncio.Lock``) valid across calls; ``max_workers`` and ``**kwargs`` are
+    then unused. The caller owns the loop and must run it in another thread.
+
     Args:
         coro (typing.Coroutine[typing.Any, typing.Any, T]): The coroutine to run.
         max_workers (int, optional): The maximum number of workers in the thread pool. Defaults to 1.
+        loop (asyncio.AbstractEventLoop | None, optional): A running event loop to submit the coroutine to. Defaults to None, which runs the coroutine on a fresh loop in a thread pool.
         **kwargs: Additional keyword arguments to pass to the `ThreadPoolExecutor`.
 
     Returns:
         T: The result of the coroutine.
     """
+    if loop is not None:
+        return asyncio.run_coroutine_threadsafe(coro, loop).result()
     with ThreadPoolExecutor(max_workers=max_workers, **kwargs) as executor:
         ctx = contextvars.copy_context()
         future = executor.submit(ctx.run, asyncio.run, coro)

{fastapi_rtk-2.1.5 → fastapi_rtk-2.2.0}/tests/unit/backends/sqla/test_db.py

@@ -1,4 +1,5 @@
 import pytest
+
 from fastapi_rtk.backends.sqla.db import (
     SQLAQueryBuilder,
     create_load_column,
@@ -30,12 +31,20 @@ class TestQueryBuilderBasic:
         result = await iface.get_many(session, {"page": 0, "page_size": 2})
         assert len(result) == 2
 
-    async def test_order_by_strips_class_prefix(self, session, iface):
+    async def test_order_by_class_prefixed_column(self, session, iface):
+        # A request may send the order column as ``ClassName.column``; it must resolve to the scalar column.
         result = await iface.get_many(
             session, {"order_column": "Person.age", "order_direction": "asc"}
         )
         assert [p.age for p in result] == [20, 30, 40]
 
+    async def test_order_by_class_prefixed_relation_column(self, session, iface):
+        # ``ClassName.relation.column`` must join the relation and order by its column.
+        result = await iface.get_many(
+            session, {"order_column": "Person.country.name", "order_direction": "asc"}
+        )
+        assert len(result) == 3
+
     async def test_apply_where(self, session, iface):
         result = await iface.get_many(session, {"where": ("name", "Alice")})
         assert [p.name for p in result] == ["Alice"]
@@ -173,9 +182,10 @@ class TestRelationFilterDispatch:
     """Cover line 179 - apply_filter_class with `.` in col routes through _filter_relation."""
 
     async def test_filter_class_with_dotted_col(self, session, iface):
-        from fastapi_rtk.backends.sqla.filters import FilterEqual
         from sqlalchemy import select
 
+        from fastapi_rtk.backends.sqla.filters import FilterEqual
+
         qb = SQLAQueryBuilder(iface)
         stmt = select(iface.obj)
         # _filter_relation expects a filter instance bound to the related interface
@@ -212,14 +222,15 @@ class TestApplyListColumnsCache:
 
     async def test_apply_list_columns_cache_hit_via_repeated_call(self):
         import sqlalchemy as _sa
-        from fastapi_rtk.backends.sqla.interface import SQLAInterface
-        from fastapi_rtk.backends.sqla.model import Model
         from sqlalchemy.ext.asyncio import (
             AsyncSession,
             async_sessionmaker,
             create_async_engine,
         )
 
+        from fastapi_rtk.backends.sqla.interface import SQLAInterface
+        from fastapi_rtk.backends.sqla.model import Model
+
         class CacheWidgetDb(Model):
             __tablename__ = "cache_widget_db"
             __table_args__ = {"extend_existing": True}
@@ -243,21 +254,76 @@ class TestApplyListColumnsCache:
         await engine.dispose()
 
 
+class TestLoadOptionsCacheEviction:
+    """LRU bound on the class-level _load_options_cache (subset-enumeration guard)."""
+
+    @staticmethod
+    def _key(model, cols):
+        return f"{model.__name__}-{sorted(cols)}"
+
+    def test_lru_evicts_oldest_over_maxsize(self, monkeypatch, iface):
+        import collections
+
+        import sqlalchemy as _sa
+
+        from fastapi_rtk.backends.sqla import db as _db
+
+        monkeypatch.setattr(_db, "_LOAD_OPTIONS_CACHE_MAXSIZE", 2)
+        monkeypatch.setattr(
+            SQLAQueryBuilder, "_load_options_cache", collections.OrderedDict()
+        )
+        qb = iface.query
+        model = iface.obj
+        for cols in (["id"], ["name"], ["age"]):
+            qb.apply_list_columns(_sa.select(model), cols)
+
+        cache = SQLAQueryBuilder._load_options_cache
+        assert len(cache) == 2
+        assert self._key(model, ["id"]) not in cache  # oldest evicted
+        assert self._key(model, ["name"]) in cache
+        assert self._key(model, ["age"]) in cache
+
+    def test_lru_hit_keeps_key_alive(self, monkeypatch, iface):
+        import collections
+
+        import sqlalchemy as _sa
+
+        from fastapi_rtk.backends.sqla import db as _db
+
+        monkeypatch.setattr(_db, "_LOAD_OPTIONS_CACHE_MAXSIZE", 2)
+        monkeypatch.setattr(
+            SQLAQueryBuilder, "_load_options_cache", collections.OrderedDict()
+        )
+        qb = iface.query
+        model = iface.obj
+        qb.apply_list_columns(_sa.select(model), ["id"])
+        qb.apply_list_columns(_sa.select(model), ["name"])
+        qb.apply_list_columns(_sa.select(model), ["id"])  # hit -> moves "id" to MRU
+        qb.apply_list_columns(_sa.select(model), ["age"])  # evicts oldest ("name")
+
+        cache = SQLAQueryBuilder._load_options_cache
+        assert len(cache) == 2
+        assert self._key(model, ["name"]) not in cache
+        assert self._key(model, ["id"]) in cache
+        assert self._key(model, ["age"]) in cache
+
+
 @pytest.mark.asyncio
 class TestApplyFilterClassHeavy:
     """Lines 312-313: `is_heavy` filter dispatched via smart_run."""
 
     async def test_heavy_filter_uses_smart_run(self):
         import sqlalchemy as _sa
-        from fastapi_rtk.backends.sqla.filters import BaseFilter
-        from fastapi_rtk.backends.sqla.interface import SQLAInterface
-        from fastapi_rtk.backends.sqla.model import Model
         from sqlalchemy.ext.asyncio import (
             AsyncSession,
             async_sessionmaker,
             create_async_engine,
         )
 
+        from fastapi_rtk.backends.sqla.filters import BaseFilter
+        from fastapi_rtk.backends.sqla.interface import SQLAInterface
+        from fastapi_rtk.backends.sqla.model import Model
+
         class HeavyWidgetDb(Model):
             __tablename__ = "heavy_widget_db"
             __table_args__ = {"extend_existing": True}

{fastapi_rtk-2.1.5 → fastapi_rtk-2.2.0}/tests/unit/bases/test_interface.py

@@ -1,6 +1,11 @@
+import typing
+import warnings
+
 import pydantic
 import pytest
 import sqlalchemy.exc
+
+from fastapi_rtk import AsyncTaskRunner
 from fastapi_rtk.bases.interface import (
     AbstractInterface,
     MissingGreenletError,
@@ -277,6 +282,7 @@ class TestSqlaCompositePKReportsTrue:
 
     def test_composite_pk(self):
         import sqlalchemy
+
         from fastapi_rtk.backends.sqla.interface import SQLAInterface
         from fastapi_rtk.backends.sqla.model import Model
 
@@ -399,3 +405,102 @@ def test_before_validator_raises_on_greenlet_for_regular_attribute():
     assert "'relation'" in msg
     assert "MissingGreenlet" in msg
     assert isinstance(excinfo.value.__cause__, sqlalchemy.exc.MissingGreenlet)
+
+
+@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
+    getattr creates a coroutine the probe discards unawaited, emitting
+    `RuntimeWarning: coroutine ... was never awaited`. The async columns are
+    resolved by the after-validator instead."""
+
+    class _AsyncPropOrm:
+        @property
+        async def async_prop(self):
+            return "async value"
+
+    interface = _make_concrete_subclass()(obj=type("M", (), {}))
+    schema_dict = PydanticGenerationSchema(
+        __config__=pydantic.ConfigDict(from_attributes=True),
+        __async_columns__=["async_prop"],
+        __columns__=None,
+        __with_id__=False,
+        __with_name__=False,
+        __with_property__=True,
+        __optional__=False,
+        __hide_sensitive_columns__=False,
+        __with_fk__=True,
+        __name__="AsyncColRegressionSchema",
+    )
+    schema_dict["async_prop"] = (typing.Any, pydantic.Field(default=None))
+    Schema = interface._generate_schema_from_dict(schema_dict)
+
+    with warnings.catch_warnings(record=True) as caught:
+        warnings.simplefilter("always")
+        async with AsyncTaskRunner():
+            model = Schema.model_validate(_AsyncPropOrm())
+
+    unawaited = [
+        w
+        for w in caught
+        if issubclass(w.category, RuntimeWarning) and "never awaited" in str(w.message)
+    ]
+    assert not unawaited, [str(w.message) for w in unawaited]
+    assert model.async_prop == "async value"
+
+
+class TestGetRelatedInterfaceMemo:
+    """get_related_interface caches instances per (related model, with_fk)."""
+
+    @classmethod
+    def _make_sub_with_relations(cls):
+        Sub = _make_concrete_subclass()
+        RelA = type("RelA", (), {})
+        RelB = type("RelB", (), {})
+
+        class RelSub(Sub):
+            def get_related_model(self, col_name):
+                return {"a": RelA, "a_again": RelA, "b": RelB}[col_name]
+
+        return RelSub, RelA, RelB
+
+    def test_same_column_returns_cached_instance(self):
+        RelSub, RelA, _ = self._make_sub_with_relations()
+        parent = RelSub(obj=type("M", (), {}))
+        first = parent.get_related_interface("a")
+        second = parent.get_related_interface("a")
+        assert first is second
+        assert first.obj is RelA
+
+    def test_with_fk_variants_cached_separately(self):
+        RelSub, _, _ = self._make_sub_with_relations()
+        parent = RelSub(obj=type("M", (), {}))
+        default = parent.get_related_interface("a")
+        with_fk = parent.get_related_interface("a", True)
+        without_fk = parent.get_related_interface("a", False)
+        assert default is not with_fk
+        assert default is not without_fk
+        assert with_fk is not without_fk
+        assert default.with_fk is None
+        assert with_fk.with_fk is True
+        assert without_fk.with_fk is False
+        assert parent.get_related_interface("a", True) is with_fk
+        assert parent.get_related_interface("a", False) is without_fk
+
+    def test_columns_sharing_model_share_interface(self):
+        RelSub, RelA, RelB = self._make_sub_with_relations()
+        parent = RelSub(obj=type("M", (), {}))
+        assert parent.get_related_interface("a") is parent.get_related_interface(
+            "a_again"
+        )
+        assert parent.get_related_interface("a") is not parent.get_related_interface(
+            "b"
+        )
+
+    def test_cache_is_per_parent_instance(self):
+        RelSub, _, _ = self._make_sub_with_relations()
+        parent_one = RelSub(obj=type("M", (), {}))
+        parent_two = RelSub(obj=type("M", (), {}))
+        assert parent_one.get_related_interface(
+            "a"
+        ) is not parent_two.get_related_interface("a")

{fastapi_rtk-2.1.5 → fastapi_rtk-2.2.0}/tests/unit/test_fastapi_react_toolkit.py

@@ -15,6 +15,7 @@ from unittest.mock import MagicMock, patch
 
 import pytest
 from fastapi import FastAPI
+
 from fastapi_rtk.fastapi_react_toolkit import FastAPIReactToolkit
 
 
@@ -614,6 +615,28 @@ class TestToolkitLifespanSmoke:
             assert app is not None
 
 
+class TestToolkitLifespanReentry:
+    """Regression: the lifespan must be re-enterable.
+
+    `db.close()` on shutdown disposes the engine, but the engine is created
+    once in `initialize()` (outside the lifespan). A second entry - the common
+    per-module `TestClient` / `lifespan_context` test pattern - must re-init the
+    engine instead of crashing with "DatabaseSessionManager is not initialized".
+    """
+
+    @pytest.mark.asyncio
+    async def test_lifespan_context_reentrant(self, make_toolkit_app):
+        app = make_toolkit_app()
+        from fastapi_rtk.db import db
+
+        async with app.router.lifespan_context(app):
+            assert db._engine is not None
+        assert db._engine is None  # shutdown disposed the engine
+
+        async with app.router.lifespan_context(app):
+            assert db._engine is not None
+
+
 class TestToolkitLifespanUpgradeDb:
     """Regression: `upgrade_db=True` must not crash on async drivers.
 

{fastapi_rtk-2.1.5 → fastapi_rtk-2.2.0}/tests/unit/test_globals.py

@@ -123,24 +123,6 @@ class TestGlobalSingletonState:
     def test_is_cli_default_false(self):
         assert g.is_cli is False
 
-    def test_is_migrate_alias_resolves_to_is_cli(self):
-        # TODO(next-minor): remove with the deprecated `is_migrate` alias.
-        # The lazy default resolves to `is_cli` at first read, so drop any
-        # cached value before each read.
-        def _fresh_is_migrate():
-            g._bootstrap_values.pop("is_migrate", None)
-            g._vars.pop("is_migrate", None)
-            return g.is_migrate
-
-        try:
-            assert _fresh_is_migrate() == g.is_cli
-            g.is_cli = True
-            assert _fresh_is_migrate() is True
-        finally:
-            g.is_cli = False
-            g._bootstrap_values.pop("is_migrate", None)
-            g._vars.pop("is_migrate", None)
-
     def test_sensitive_data_default(self):
         assert "User" in g.sensitive_data
 

{fastapi_rtk-2.1.5 → fastapi_rtk-2.2.0}/tests/unit/utils/test_run_utils.py

@@ -1,7 +1,9 @@
 import asyncio
 import contextvars
+import threading
 
 import pytest
+
 from fastapi_rtk.utils.run_utils import (
     call_with_valid_kwargs,
     parse_from_values_or_func,
@@ -194,6 +196,55 @@ class TestRunCoroutineInThreadpool:
         assert result == "new value"
 
 
+@pytest.fixture
+def running_loop():
+    loop = asyncio.new_event_loop()
+    thread = threading.Thread(target=loop.run_forever, daemon=True)
+    thread.start()
+    try:
+        yield loop
+    finally:
+        loop.call_soon_threadsafe(loop.stop)
+        thread.join()
+        loop.close()
+
+
+class TestSuppliedLoop:
+    def test_run_coroutine_in_threadpool_on_supplied_loop(self, running_loop):
+        async def async_func(x, y):
+            await asyncio.sleep(0.01)
+            return x + y
+
+        result = run_coroutine_in_threadpool(async_func(2, 3), loop=running_loop)
+        assert result == 5
+
+    def test_run_coroutine_in_threadpool_reuses_loop_bound_resource(self, running_loop):
+        async def make_lock():
+            return asyncio.Lock()
+
+        lock = run_coroutine_in_threadpool(make_lock(), loop=running_loop)
+
+        async def use_lock():
+            async with lock:
+                return "ok"
+
+        assert run_coroutine_in_threadpool(use_lock(), loop=running_loop) == "ok"
+        assert run_coroutine_in_threadpool(use_lock(), loop=running_loop) == "ok"
+
+    def test_safe_call_sync_on_supplied_loop(self, running_loop):
+        async def async_func():
+            return "looped"
+
+        assert safe_call_sync(async_func(), loop=running_loop) == "looped"
+
+    def test_smart_run_sync_on_supplied_loop(self, running_loop):
+        async def async_func(x):
+            await asyncio.sleep(0.01)
+            return x * 2
+
+        assert smart_run_sync(async_func, 5, loop=running_loop) == 10
+
+
 class TestRunFunctionInThreadpool:
     def test_run_function_in_threadpool(self):
         def sync_func(x):

fastapi_rtk-2.1.5/fastapi_rtk/_version.py

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