simple-module-background-tasks 0.0.8__tar.gz → 0.0.10__tar.gz

{simple_module_background_tasks-0.0.8 → simple_module_background_tasks-0.0.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: simple_module_background_tasks
-Version: 0.0.8
+Version: 0.0.10
 Summary: Celery + Redis task queue with admin UI for monitoring and retrying failed/stuck tasks
 Project-URL: Homepage, https://github.com/antosubash/simple_module_python
 Project-URL: Repository, https://github.com/antosubash/simple_module_python
@@ -23,10 +23,10 @@ Classifier: Typing :: Typed
 Requires-Python: >=3.12
 Requires-Dist: celery[redis]>=5.4
 Requires-Dist: redis>=5
-Requires-Dist: simple-module-core==0.0.8
-Requires-Dist: simple-module-db==0.0.8
-Requires-Dist: simple-module-hosting==0.0.8
-Requires-Dist: simple-module-settings==0.0.8
+Requires-Dist: simple-module-core==0.0.10
+Requires-Dist: simple-module-db==0.0.10
+Requires-Dist: simple-module-hosting==0.0.10
+Requires-Dist: simple-module-settings==0.0.10
 Description-Content-Type: text/markdown
 
 # simple_module_background_tasks

{simple_module_background_tasks-0.0.8 → simple_module_background_tasks-0.0.10}/background_tasks/module.py

@@ -96,8 +96,14 @@ class BackgroundTasksModule(ModuleBase):
 
         from background_tasks.celery_app import build_celery
         from background_tasks.signals import bind_event_bus
+        from background_tasks.sync_db import set_database_url
 
         services = app.state.background_tasks
+        # Pin the sync engine to the same URL the host's async settings
+        # resolved — pydantic-settings reads ``.env`` but never propagates
+        # to ``os.environ``, so signals would otherwise fall back to the
+        # SQLite default and silently drop ``TaskExecution`` rows.
+        set_database_url(app.state.sm.settings.database_url)
         # build_celery imports `signals` for side effects and runs
         # `autodiscover_tasks` across every installed module.
         services.celery = build_celery(services.settings)

{simple_module_background_tasks-0.0.8 → simple_module_background_tasks-0.0.10}/background_tasks/sync_db.py

@@ -26,6 +26,7 @@ logger = logging.getLogger(__name__)
 
 _engine: Engine | None = None
 _session_factory: sessionmaker[Session] | None = None
+_url_override: str | None = None
 
 
 def _sync_url(async_url: str) -> str:
@@ -37,9 +38,35 @@ def _sync_url(async_url: str) -> str:
     return async_url.replace("+aiosqlite", "").replace("+asyncpg", "+psycopg2")
 
 
+def set_database_url(url: str | None) -> None:
+    """Pin the URL used to build the sync engine.
+
+    The web process loads ``.env`` via pydantic-settings, but those values
+    never land in ``os.environ`` — so reading ``SM_DATABASE_URL`` directly
+    from the env can silently drop us back to the SQLite default while the
+    rest of the app uses Postgres. ``BackgroundTasksModule.on_startup``
+    calls this with the resolved ``settings.database_url`` so signals use
+    the same DB the app is on. Pass ``None`` to clear the override (used in
+    tests + on shutdown).
+    """
+    global _url_override, _engine, _session_factory
+    if _url_override == url:
+        return
+    _url_override = url
+    if _engine is not None:
+        _engine.dispose()
+    _engine = None
+    _session_factory = None
+
+
+def _resolve_url() -> str:
+    if _url_override is not None:
+        return _url_override
+    return os.environ.get("SM_DATABASE_URL", "sqlite:///./app.db")
+
+
 def _build_engine() -> Engine:
-    url = os.environ.get("SM_DATABASE_URL", "sqlite:///./app.db")
-    sync_url = _sync_url(url)
+    sync_url = _sync_url(_resolve_url())
     # Small pool — signals fire sequentially per worker process.
     return create_engine(sync_url, pool_pre_ping=True, pool_size=2, max_overflow=3)
 
@@ -60,11 +87,12 @@ def dispose_sync_engine() -> None:
     restarts within one process (test runners, uvicorn dev reload) don't
     accumulate engines against the old DB URL.
     """
-    global _engine, _session_factory
+    global _engine, _session_factory, _url_override
     if _engine is not None:
         _engine.dispose()
     _engine = None
     _session_factory = None
+    _url_override = None
 
 
 @contextmanager

{simple_module_background_tasks-0.0.8 → simple_module_background_tasks-0.0.10}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "simple_module_background_tasks"
-version = "0.0.8"
+version = "0.0.10"
 description = "Celery + Redis task queue with admin UI for monitoring and retrying failed/stuck tasks"
 readme = "README.md"
 license = "MIT"
@@ -21,10 +21,10 @@ classifiers = [
     "Typing :: Typed",
 ]
 dependencies = [
-    "simple_module_core==0.0.8",
-    "simple_module_db==0.0.8",
-    "simple_module_hosting==0.0.8",
-    "simple_module_settings==0.0.8",
+    "simple_module_core==0.0.10",
+    "simple_module_db==0.0.10",
+    "simple_module_hosting==0.0.10",
+    "simple_module_settings==0.0.10",
     "celery[redis]>=5.4",
     "redis>=5",
 ]

simple_module_background_tasks-0.0.10/tests/test_sync_db.py

@@ -0,0 +1,60 @@
+"""Tests for the sync session factory's URL resolution.
+
+The web process loads ``.env`` via pydantic-settings but never propagates the
+result to ``os.environ``. ``set_database_url`` lets the module's
+``on_startup`` pin the sync engine to whatever the host settings resolved,
+so signals don't silently fall back to SQLite while the rest of the app
+talks to Postgres.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Iterator
+
+import pytest
+from background_tasks import sync_db
+
+
+@pytest.fixture(autouse=True)
+def _reset_sync_db() -> Iterator[None]:
+    sync_db.dispose_sync_engine()
+    yield
+    sync_db.dispose_sync_engine()
+
+
+def test_resolve_url_falls_back_to_env(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setenv("SM_DATABASE_URL", "sqlite:///./from-env.db")
+    sync_db.set_database_url(None)
+
+    assert sync_db._resolve_url() == "sqlite:///./from-env.db"
+
+
+def test_set_database_url_overrides_env(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setenv("SM_DATABASE_URL", "sqlite:///./from-env.db")
+    sync_db.set_database_url("postgresql+asyncpg://u:p@h/db")
+
+    assert sync_db._resolve_url() == "postgresql+asyncpg://u:p@h/db"
+
+
+def test_set_database_url_resets_engine_when_url_changes(tmp_path) -> None:
+    db_a = tmp_path / "a.db"
+    db_b = tmp_path / "b.db"
+    sync_db.set_database_url(f"sqlite:///{db_a}")
+    factory_a = sync_db.get_sync_session_factory()
+    sync_db.set_database_url(f"sqlite:///{db_a}")
+    factory_a_again = sync_db.get_sync_session_factory()
+    assert factory_a is factory_a_again, "same URL must reuse the cached factory"
+
+    sync_db.set_database_url(f"sqlite:///{db_b}")
+    factory_b = sync_db.get_sync_session_factory()
+    assert factory_b is not factory_a, "URL change must dispose the old engine"
+
+
+def test_dispose_sync_engine_clears_url_override(tmp_path) -> None:
+    url = f"sqlite:///{tmp_path / 'pinned.db'}"
+    sync_db.set_database_url(url)
+    assert sync_db._url_override == url
+
+    sync_db.dispose_sync_engine()
+
+    assert sync_db._url_override is None