fastapi-rtk 2.1.1__tar.gz → 2.1.3__tar.gz

{fastapi_rtk-2.1.1 → fastapi_rtk-2.1.3}/PKG-INFO

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

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

{fastapi_rtk-2.1.1 → fastapi_rtk-2.1.3}/fastapi_rtk/api/base_api.py

@@ -201,24 +201,27 @@ class BaseApi:
                             self, metadata["response_model_str"]
                         )
 
-                    extra_dependencies = []
-                    if metadata.get("dependencies"):
-                        extra_dependencies = metadata["dependencies"]
-                    if extra_dependencies and not data.get("dependencies"):
-                        data["dependencies"] = []
-                    for dep in extra_dependencies:
+                    resolved_dependencies = []
+                    for dep in metadata.get("dependencies") or []:
                         func, kwargs = dep
                         if kwargs:
+                            # Resolve into a fresh dict; the source kwargs live in
+                            # the shared registry and must stay un-mutated so other
+                            # instances of the same Api class can resolve them too.
+                            resolved_kwargs = {}
                             for key, val in kwargs.items():
                                 if val == ":self":
-                                    kwargs[key] = self
-                                elif val.startswith(":f"):
+                                    resolved_kwargs[key] = self
+                                elif isinstance(val, str) and val.startswith(":f"):
                                     prop = val.split(".")[1]
-                                    kwargs[key] = metadata[prop]
-                            func = Depends(func(**kwargs))
+                                    resolved_kwargs[key] = metadata[prop]
+                                else:
+                                    resolved_kwargs[key] = val
+                            resolved_dependencies.append(
+                                Depends(func(**resolved_kwargs))
+                            )
                         else:
-                            func = Depends(func)
-                        data["dependencies"].append(func)
+                            resolved_dependencies.append(Depends(func))
 
                     path, methods, rest_data = (
                         data["path"],
@@ -226,6 +229,11 @@ class BaseApi:
                         {k: v for k, v in data.items() if k != "methods"},
                     )
 
+                    if resolved_dependencies:
+                        rest_data["dependencies"] = (
+                            list(data.get("dependencies") or []) + resolved_dependencies
+                        )
+
                     self.messages.append(
                         f"Registering route {self.router.prefix}{path} {methods}"
                     )

fastapi_rtk-2.1.3/fastapi_rtk/cli/decorators.py

@@ -0,0 +1,80 @@
+import inspect
+from functools import wraps
+
+import typer
+from fastapi_cli.discover import get_import_data
+from fastapi_cli.exceptions import FastAPICLIException
+
+from ..db import db
+from ..globals import g
+from .const import logger
+from .utils import run_in_current_event_loop
+
+
+def ensure_app_loaded(f):
+    """Ensure a FastAPI app is loaded before running `f`.
+
+    Only commands that read models or config (not the database) need this.
+    """
+    return _check_existing_app(f)
+
+
+def ensure_fastapi_rtk_tables_exist(f):
+    """Ensure the fastapi-rtk tables exist before running `f`.
+
+    Implies :func:`ensure_app_loaded`. Use on commands that touch the database.
+
+    Table-init only runs in CLI mode; an in-process caller (e.g. the lifespan)
+    already created the tables on the running loop, and re-running it here on a
+    worker-thread loop would crash async drivers (cross-loop connection reuse).
+
+    For the CLI path, init and body share one loop via
+    :func:`run_in_current_event_loop`: an `async def` command (a
+    :func:`make_sync` wrapper with `f.__wrapped__`) awaits init, body, and
+    `db.close()` in one call; a sync command inits on its own loop then runs.
+    """
+
+    body = getattr(f, "__wrapped__", None)
+
+    @wraps(f)
+    def wrapper(*args, **kwargs):
+        if not g.is_cli:
+            return f(*args, **kwargs)
+
+        if body is not None and inspect.iscoroutinefunction(body):
+
+            async def run():
+                await db.init_fastapi_rtk_tables()
+                try:
+                    return await body(*args, **kwargs)
+                finally:
+                    await db.close()
+
+            return run_in_current_event_loop(run())
+
+        run_in_current_event_loop(db.init_fastapi_rtk_tables())
+        return f(*args, **kwargs)
+
+    return ensure_app_loaded(wrapper)
+
+
+def _check_existing_app(f, *, silent=False):
+    @wraps(f)
+    def wrapper(*args, **kwargs):
+        # No app loaded -> CLI invocation: flag cli (before import, so the
+        # toolkit skips the lifespan) and import from path. Else reuse it.
+        if g.current_app is None:
+            g.is_cli = True
+            try:
+                get_import_data(path=g.path)
+            except FastAPICLIException as e:
+                if not silent:
+                    logger.error(str(e))
+                    raise typer.Exit(code=1) from None
+        return f(*args, **kwargs)
+
+    return wrapper
+
+
+def check_existing_app_silent(f):
+    return _check_existing_app(f, silent=True)

{fastapi_rtk-2.1.1 → fastapi_rtk-2.1.3}/tests/conftest.py

@@ -130,6 +130,7 @@ def make_toolkit_app(tmp_path, config_setter):
         extra_apis: optional list of API classes to register via add_api.
         extra_lifespans: optional list of async context managers.
         config_overrides: optional dict of additional config values.
+        upgrade_db: run the alembic upgrade step in the lifespan.
 
     Returns:
         FastAPI app instance with toolkit initialized.
@@ -144,6 +145,7 @@ def make_toolkit_app(tmp_path, config_setter):
         extra_apis: Iterable[Any] | None = None,
         extra_lifespans: Iterable[Any] | None = None,
         config_overrides: dict | None = None,
+        upgrade_db: bool = False,
     ):
         db_path = tmp_path / "test.db"
         config_setter("SQLALCHEMY_DATABASE_URI", f"sqlite+aiosqlite:///{db_path}")
@@ -187,6 +189,7 @@ def make_toolkit_app(tmp_path, config_setter):
 
         toolkit = FastAPIReactToolkit(
             create_tables=False,
+            upgrade_db=upgrade_db,
             exclude_apis=["LicenseApi"],
             lifespans=list(extra_lifespans or []),
             auth={"secret_key": "tier-integration-secret-32-bytes!!"},

{fastapi_rtk-2.1.1 → fastapi_rtk-2.1.3}/tests/unit/api/test_base_api.py

@@ -130,6 +130,29 @@ class TestExposedRoutes:
         api = TierMsgApi()
         assert any("Registering route" in m for m in api.messages)
 
+    def test_protect_dependency_resolved_per_instance(self):
+        # Regression: resolving @protect's ":self" / ":f" placeholders must not
+        # mutate the shared registry metadata. Otherwise a second instance of
+        # the same class crashes ("... object has no attribute 'startswith'")
+        # and dependencies accumulate across registrations.
+        class TierSharedApi(BaseApi):
+            base_permissions = [f"{PERMISSION_PREFIX}read"]
+
+            @expose("/shared", methods=["GET"])
+            @protect()
+            @permission_name("read")
+            async def shared(self):
+                return {}
+
+        for _ in range(2):
+            api = TierSharedApi()
+            deps = [
+                rest_data.get("dependencies")
+                for _, rest_data, _, _ in api.routes_to_register
+                if rest_data["path"] == "/shared"
+            ]
+            assert deps and len(deps[0]) == 1
+
 
 class TestPriorityRoutes:
     def test_priority_routes_reordered(self):

{fastapi_rtk-2.1.1 → fastapi_rtk-2.1.3}/tests/unit/cli/commands/test_db.py

@@ -219,9 +219,7 @@ class TestAppCheckPartition:
         neutralize_app_check.get_import_data.assert_called_once()
         neutralize_app_check.run_in_current_event_loop.assert_called_once()
 
-    def test_migrate_checks_once_via_revision(
-        self, monkeypatch, neutralize_app_check
-    ):
+    def test_migrate_checks_once_via_revision(self, monkeypatch, neutralize_app_check):
         from fastapi_rtk.cli.commands.db import migrate
 
         self._patch_alembic(monkeypatch, "revision")

{fastapi_rtk-2.1.1 → fastapi_rtk-2.1.3}/tests/unit/cli/commands/test_export.py

@@ -29,17 +29,22 @@ class TestAppCheckPartition:
         neutralize_app_check.get_import_data.assert_called_once()
         neutralize_app_check.run_in_current_event_loop.assert_not_called()
 
-    def test_api_docs_is_import_only(
-        self, tmp_path, monkeypatch, global_setter, neutralize_app_check
-    ):
+    def test_api_docs_is_import_only(self, tmp_path, monkeypatch, neutralize_app_check):
         from unittest.mock import MagicMock
 
         from fastapi_rtk.cli.commands import export as ex_mod
+        from fastapi_rtk.globals import g
 
         app_mock = MagicMock()
         app_mock.apis = []
         app_mock.app.openapi.return_value = {"paths": {}, "components": {}}
-        global_setter("current_app", app_mock)
+
+        # No app loaded yet -> CLI (from-path) branch: importing the app is what
+        # populates `g.current_app`, so the mock mirrors that side effect.
+        def _load(*args, **kwargs):
+            g.current_app = app_mock
+
+        neutralize_app_check.get_import_data.side_effect = _load
 
         ex_mod.api_docs(filename=str(tmp_path / "out.md"))
         neutralize_app_check.get_import_data.assert_called_once()

fastapi_rtk-2.1.3/tests/unit/cli/conftest.py

@@ -0,0 +1,30 @@
+"""Shared fixtures for tier 14 cli/ tests.
+
+Commands decorated with `@ensure_app_loaded` / `@ensure_fastapi_rtk_tables_exist`
+discriminate CLI from in-process by `g.current_app`: when it is unset they import
+the app from path and flag `g.is_cli = True`. Both flags leak into later tests,
+so isolate them. `current_app` is cleared *before* each test so the CLI
+(from-path) branch is exercised, and both are restored afterwards.
+"""
+
+import pytest
+
+from fastapi_rtk.globals import g
+
+_MISSING = object()
+
+
+@pytest.fixture(autouse=True)
+def _reset_cli_globals():
+    saved_boot = g._bootstrap_values.pop("current_app", _MISSING)
+    saved_var = g._vars.pop("current_app", _MISSING)
+    yield
+    g.is_cli = False
+    if saved_boot is _MISSING:
+        g._bootstrap_values.pop("current_app", None)
+    else:
+        g._bootstrap_values["current_app"] = saved_boot
+    if saved_var is _MISSING:
+        g._vars.pop("current_app", None)
+    else:
+        g._vars["current_app"] = saved_var

{fastapi_rtk-2.1.1 → fastapi_rtk-2.1.3}/tests/unit/cli/test_decorators.py

@@ -8,7 +8,6 @@ import typer
 
 from fastapi_rtk.cli.decorators import (
     _check_existing_app,
-    _set_cli_mode,
     check_existing_app_silent,
     ensure_app_loaded,
     ensure_fastapi_rtk_tables_exist,
@@ -16,29 +15,6 @@ from fastapi_rtk.cli.decorators import (
 from fastapi_rtk.cli.utils import make_sync
 
 
-class TestSetCliMode:
-    def test_sets_cli_flag(self, global_setter):
-        global_setter("is_cli", False)
-
-        from fastapi_rtk.globals import g
-
-        captured = []
-
-        @_set_cli_mode
-        def fn():
-            captured.append(g.is_cli)
-            return "ok"
-
-        try:
-            result = fn()
-            assert result == "ok"
-            assert captured == [True]
-        finally:
-            # Restore the default - the decorator writes to g._vars which
-            # bypasses the global_setter fixture's restore semantics.
-            g.is_cli = False
-
-
 class TestCheckExistingApp:
     def test_runs_when_app_exists(self):
         with patch("fastapi_rtk.cli.decorators.get_import_data"):
@@ -125,6 +101,47 @@ class TestEnsureAppLoaded:
                 g.is_cli = False
 
 
+class TestInProcessReusesLoadedApp:
+    """When `g.current_app` is set (in-process, e.g. the app lifespan) the
+    decorators reuse the loaded app: no import, no CLI flag, no table-init.
+    """
+
+    def test_check_existing_app_skips_import_when_app_loaded(self):
+        from fastapi_rtk.globals import g
+
+        g.current_app = object()
+        with patch("fastapi_rtk.cli.decorators.get_import_data") as mock_import:
+
+            @_check_existing_app
+            def fn():
+                return "result"
+
+            assert fn() == "result"
+
+        mock_import.assert_not_called()
+        assert g.is_cli is False
+
+    def test_tables_exist_skips_init_when_app_loaded(self):
+        from fastapi_rtk.globals import g
+
+        g.current_app = object()
+        with (
+            patch("fastapi_rtk.cli.decorators.get_import_data") as mock_import,
+            patch("fastapi_rtk.cli.decorators.run_in_current_event_loop") as mock_run,
+        ):
+
+            @ensure_fastapi_rtk_tables_exist
+            def fn():
+                return "done"
+
+            assert fn() == "done"
+
+        # In-process: no app import and no table-init (the foreign-loop touch).
+        mock_import.assert_not_called()
+        mock_run.assert_not_called()
+        assert g.is_cli is False
+
+
 class TestEnsureFastapiRtkTablesExist:
     def test_initializes_tables(self):
         with (

{fastapi_rtk-2.1.1 → fastapi_rtk-2.1.3}/tests/unit/test_fastapi_react_toolkit.py

@@ -133,7 +133,9 @@ class TestInitializeWithFeatures:
         assert "SecWebPatchDocsMiddleware" in names
         assert "SecWebPatchReDocMiddleware" in names
 
-    def test_profiler_enabled_adds_middleware(self, config_setter, tmp_path, monkeypatch):
+    def test_profiler_enabled_adds_middleware(
+        self, config_setter, tmp_path, monkeypatch
+    ):
         import sys
         from unittest.mock import MagicMock
 
@@ -239,16 +241,12 @@ class TestTemplateFolderRoute:
             # Without index.html we hit the TemplateNotFound -> 404
             assert r.status_code == 404
 
-    def test_template_folder_index_renders_when_present(
-        self, tmp_path, config_setter
-    ):
+    def test_template_folder_index_renders_when_present(self, tmp_path, config_setter):
         from starlette.testclient import TestClient
 
         tmpl_dir = tmp_path / "tmpl"
         tmpl_dir.mkdir()
-        (tmpl_dir / "index.html").write_text(
-            "<html>{{ app_name }}</html>"
-        )
+        (tmpl_dir / "index.html").write_text("<html>{{ app_name }}</html>")
         config_setter("TEMPLATE_FOLDER", str(tmpl_dir))
         config_setter("APP_NAME", "MyApp")
 
@@ -616,6 +614,33 @@ class TestToolkitLifespanSmoke:
             assert app is not None
 
 
+class TestToolkitLifespanUpgradeDb:
+    """Regression: `upgrade_db=True` must not crash on async drivers.
+
+    The lifespan creates the fastapi-rtk tables on the running loop and then
+    runs the alembic upgrade. Routing that upgrade through the CLI
+    `ensure_fastapi_rtk_tables_exist` decorator re-touches the shared async
+    engine on a fresh event loop in a worker thread, which asyncpg / aiosqlite
+    reject with "got Future ... attached to a different loop". The upgrade must
+    run without re-entering the async table-init.
+    """
+
+    @pytest.mark.asyncio
+    async def test_upgrade_db_lifespan_no_cross_loop(self, make_toolkit_app):
+        from unittest.mock import MagicMock
+
+        from fastapi_rtk.cli.commands import db as db_mod
+
+        with patch.object(db_mod.alembic.command, "upgrade", MagicMock()) as upgrade:
+            app = make_toolkit_app(upgrade_db=True)
+            async with app.router.lifespan_context(app):
+                pass
+
+        # Alembic ran (on its own sync engine), and the lifespan completed
+        # without the cross-loop RuntimeError.
+        upgrade.assert_called_once()
+
+
 class TestToolkitDebugLogLevel:
     """Line 634: DEBUG=True sets logger level to DEBUG."""
 

fastapi_rtk-2.1.1/fastapi_rtk/_version.py

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

fastapi_rtk-2.1.1/fastapi_rtk/cli/decorators.py

@@ -1,87 +0,0 @@
-import inspect
-from functools import wraps
-
-import typer
-from fastapi_cli.discover import get_import_data
-from fastapi_cli.exceptions import FastAPICLIException
-
-from ..db import db
-from ..globals import g
-from .const import logger
-from .utils import run_in_current_event_loop
-
-
-def ensure_app_loaded(f):
-    """Load the app for the CLI: set `g.is_cli`, then import the app.
-
-    Importing the app is what registers the models and populates `g.config`,
-    so any command that reads models or config (but does not touch the
-    database) only needs this.
-    """
-    return _set_cli_mode(_check_existing_app(f))
-
-
-def ensure_fastapi_rtk_tables_exist(f):
-    """Ensure the fastapi-rtk tables exist before running `f`.
-
-    Creating the tables reads config and reflects the registered models, so it
-    implies :func:`ensure_app_loaded`. Use this on commands that touch the
-    database; use :func:`ensure_app_loaded` on the rest.
-
-    The table-creation and the command body must run on the **same** event
-    loop: the async engine pools a connection bound to whichever loop opened
-    it, and asyncpg / aiosqlite raise when that connection is reused from a
-    second loop. `f` is normally a :func:`fastapi_rtk.cli.utils.make_sync`
-    wrapper whose original coroutine is exposed as ``f.__wrapped__``; when so,
-    the table init and the body are awaited inside one
-    :func:`run_in_current_event_loop` call and the engine is disposed before
-    that loop closes. A plain synchronous `f` cannot share the loop (it has no
-    coroutine), so the init runs on its own loop and `f` is called directly.
-    """
-
-    body = getattr(f, "__wrapped__", None)
-
-    @wraps(f)
-    def wrapper(*args, **kwargs):
-        if body is not None and inspect.iscoroutinefunction(body):
-
-            async def run():
-                await db.init_fastapi_rtk_tables()
-                try:
-                    return await body(*args, **kwargs)
-                finally:
-                    await db.close()
-
-            return run_in_current_event_loop(run())
-
-        run_in_current_event_loop(db.init_fastapi_rtk_tables())
-        return f(*args, **kwargs)
-
-    return ensure_app_loaded(wrapper)
-
-
-def _check_existing_app(f, *, silent=False):
-    @wraps(f)
-    def wrapper(*args, **kwargs):
-        try:
-            get_import_data(path=g.path)
-        except FastAPICLIException as e:
-            if not silent:
-                logger.error(str(e))
-                raise typer.Exit(code=1) from None
-        return f(*args, **kwargs)
-
-    return wrapper
-
-
-def check_existing_app_silent(f):
-    return _check_existing_app(f, silent=True)
-
-
-def _set_cli_mode(f):
-    @wraps(f)
-    def wrapper(*args, **kwargs):
-        g.is_cli = True
-        return f(*args, **kwargs)
-
-    return wrapper

fastapi_rtk-2.1.1/tests/unit/cli/conftest.py

@@ -1,15 +0,0 @@
-"""Shared fixtures for tier 14 cli/ tests.
-
-Commands decorated with `@ensure_app_loaded` / `@ensure_fastapi_rtk_tables_exist`
-set `g.is_cli = True`. The flag leaks into later tests, so reset it after each.
-"""
-
-import pytest
-
-from fastapi_rtk.globals import g
-
-
-@pytest.fixture(autouse=True)
-def _reset_is_cli():
-    yield
-    g.is_cli = False