ferro-orm 0.12.1__tar.gz → 0.12.2__tar.gz

{ferro_orm-0.12.1 → ferro_orm-0.12.2}/CHANGELOG.md

@@ -1,6 +1,14 @@
 # CHANGELOG
 
 
+## v0.12.2 (2026-06-23)
+
+### Bug Fixes
+
+- Cross-context session teardown (Fixes #123) ([#127](https://github.com/syn54x/ferro-orm/pull/127),
+  [`6b9ae13`](https://github.com/syn54x/ferro-orm/commit/6b9ae1332becef88f14bdb4beae1d24e3a4104cd))
+
+
 ## v0.12.1 (2026-06-23)
 
 ### Bug Fixes

{ferro_orm-0.12.1 → ferro_orm-0.12.2}/Cargo.lock

@@ -288,7 +288,7 @@ dependencies = [
 
 [[package]]
 name = "ferro"
-version = "0.12.1"
+version = "0.12.2"
 dependencies = [
  "dashmap",
  "ferro-migrate",

{ferro_orm-0.12.1 → ferro_orm-0.12.2}/Cargo.toml

@@ -3,7 +3,7 @@ members = ["crates/ferro-schema-ir", "crates/ferro-migrate"]
 
 [package]
 name = "ferro"
-version = "0.12.1"
+version = "0.12.2"
 edition = "2024"
 readme = "README.md"
 

{ferro_orm-0.12.1 → ferro_orm-0.12.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ferro-orm
-Version: 0.12.1
+Version: 0.12.2
 Requires-Dist: pydantic>=2.0
 Requires-Dist: alembic>=1.18.1 ; extra == 'alembic'
 Requires-Dist: sqlalchemy>=2.0.46 ; extra == 'alembic'

{ferro_orm-0.12.1 → ferro_orm-0.12.2}/docs/pages/api/connection.md

@@ -2,6 +2,8 @@
 
 Functions for managing database connections and the global model registry. `connect()` registers a (optionally named) connection pool; `reset_engine()` tears everything down; the registry helpers control schema creation and the identity map. Sessionized routing is exposed via `ferro.engines.session(name)` / `ferro.Session`. See the [Connections & Databases guide](../guide/connections.md).
 
+::: ferro.Session
+
 ::: ferro.connect
 
 ::: ferro.PoolConfig

{ferro_orm-0.12.1 → ferro_orm-0.12.2}/docs/pages/guide/connections.md

@@ -114,6 +114,37 @@ async with ferro.engines.session("analytics") as s:
 
 Inside an active session context, convenience APIs (`User.all()`, `User.where(...)`, `ferro.execute(...)`) automatically bind to that session's connection.
 
+### Request-scoped sessions
+
+For short units of work (HTTP handlers, scripts, tests), use `async with`:
+
+```python
+async with ferro.engines.session("analytics"):
+    rows = await User.where(lambda t: t.active == True).all()  # noqa: E712
+```
+
+### Long-lived sessions (GUI, app lifecycle)
+
+When startup and shutdown run in different asyncio tasks (for example Textual `on_mount` / `on_unmount`), open a session handle at startup and close it explicitly at shutdown:
+
+```python
+class App:
+    async def on_mount(self) -> None:
+        self.session = ferro.engines.session("default")
+        await self.session.__aenter__()
+
+    async def on_unmount(self) -> None:
+        await self.session.close()
+```
+
+`Session.close()` is safe across asyncio contexts and idempotent. Prefer explicit `session=` routing when ambient context may be unavailable in the closing task.
+
+After a cross-context close, the enter task may still hold a stale ambient session object until a new session is opened; ambient operations then raise `RuntimeError` with a session-closed message (including when `using=` names another connection). If nested sessions are open, close inner sessions from the same task or via cross-context `close()` before closing the outer handle in the original task.
+
+Operations on a closed session handle (ambient or explicit `session=`) raise `RuntimeError` rather than falling back to legacy default routing.
+
+`ferro.reset_engine()` tears down **all** connections and is intended for test isolation — not per-session app lifecycle teardown.
+
 Legacy implicit default-connection routing (calling unqualified operations outside a session) is still temporarily supported for compatibility, but now emits a deprecation warning and is on the `v0.14.0` removal track.
 Follow [Migrating to v0.12.0](../howto/migrating-to-v0-12-0.md) to remove these legacy call sites during the compatibility window.
 

{ferro_orm-0.12.1 → ferro_orm-0.12.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "ferro-orm"
-version = "0.12.1"
+version = "0.12.2"
 description = "A high-performance, Rust-backed ORM for Python."
 readme = "README.md"
 authors = [

ferro_orm-0.12.2/src/ferro/session.py

@@ -0,0 +1,122 @@
+"""Session-scoped runtime state for Ferro operations."""
+
+from __future__ import annotations
+
+import asyncio
+import contextvars
+from dataclasses import dataclass, field
+from typing import Any
+
+from ._core import close_session as _core_close_session
+from ._core import open_session as _core_open_session
+from .state import _CURRENT_SESSION
+
+_SESSION_CLOSE_AMBIENT_MISMATCH = (
+    "Session close failed: ambient session does not match the closing session. "
+    "This usually indicates session lifecycle misuse in the current asyncio context."
+)
+
+
+@dataclass(slots=True)
+class Session:
+    connection_name: str | None = None
+    session_id: str | None = None
+    _token: Any = field(default=None, repr=False, compare=False)
+    _enter_context: contextvars.Context | None = field(
+        default=None, repr=False, compare=False
+    )
+    _enter_task: asyncio.Task[Any] | None = field(
+        default=None, repr=False, compare=False
+    )
+
+    async def __aenter__(self) -> "Session":
+        self.session_id, resolved_name = _core_open_session(self.connection_name)
+        if self.connection_name is None:
+            self.connection_name = resolved_name
+        self._token = _CURRENT_SESSION.set(self)
+        self._enter_context = contextvars.copy_context()
+        self._enter_task = asyncio.current_task()
+        return self
+
+    async def __aexit__(self, exc_type, exc, tb) -> None:
+        try:
+            await self.close()
+        except Exception as close_exc:
+            if exc_type is None:
+                raise
+            if exc is not None:
+                raise exc from close_exc
+            raise close_exc
+
+    async def close(self) -> None:
+        """Close this session and release its runtime state.
+
+        Safe to call from a different asyncio context than ``__aenter__``.
+        Repeated calls are no-ops.
+
+        Raises:
+            RuntimeError: If the ambient session in this asyncio context does not
+                match this handle (same-context lifecycle misuse).
+        """
+        if self.session_id is None and self._token is None:
+            return
+
+        self._assert_close_allowed()
+
+        if self.session_id is not None:
+            session_id = self.session_id
+            _core_close_session(session_id)
+            self.session_id = None
+
+        if self._token is None:
+            self._enter_context = None
+            self._enter_task = None
+            return
+
+        token = self._token
+        self._token = None
+        self._enter_context = None
+        self._enter_task = None
+        self._restore_ambient_session(token)
+
+    def _assert_close_allowed(self) -> None:
+        if self._token is None:
+            return
+        if asyncio.current_task() is not self._enter_task:
+            return
+        ambient = _CURRENT_SESSION.get()
+        if ambient is self:
+            return
+        entered_ambient = (
+            self._enter_context.get(_CURRENT_SESSION)
+            if self._enter_context is not None
+            else None
+        )
+        if entered_ambient is self and ambient is not None:
+            raise RuntimeError(_SESSION_CLOSE_AMBIENT_MISMATCH)
+
+    def _restore_ambient_session(self, token: Any) -> None:
+        ambient = _CURRENT_SESSION.get()
+        if ambient is not self:
+            try:
+                _CURRENT_SESSION.reset(token)
+            except ValueError:
+                return
+            raise RuntimeError(_SESSION_CLOSE_AMBIENT_MISMATCH)
+        try:
+            _CURRENT_SESSION.reset(token)
+        except ValueError:
+            return
+
+    def query(self, model_cls):
+        from .query import Query
+
+        return Query(model_cls, session=self)
+
+
+class EngineManager:
+    def session(self, name: str | None = None) -> Session:
+        return Session(connection_name=name)
+
+
+engines = EngineManager()

{ferro_orm-0.12.1 → ferro_orm-0.12.2}/src/ferro/state.py

@@ -34,6 +34,16 @@ _LEGACY_DEFAULT_CONNECTION_REASON = (
     "ORM/raw operations."
 )
 
+_SESSION_CLOSED_MESSAGE = (
+    "Session is closed. Open a new session with "
+    "`async with ferro.engines.session(...)` or pass an active session handle."
+)
+
+
+def _ensure_active_session(session: SessionLike | None) -> None:
+    if session is not None and session.session_id is None:
+        raise RuntimeError(_SESSION_CLOSED_MESSAGE)
+
 # Global registry for models (Python side)
 _MODEL_REGISTRY_PY = {}
 
@@ -76,6 +86,11 @@ def resolve_operation_scope(
         if explicit_session is None and using != effective_session.connection_name:
             effective_session = None
 
+    if explicit_session is None and ambient_session is not None:
+        _ensure_active_session(ambient_session)
+
+    _ensure_active_session(effective_session)
+
     session_id = effective_session.session_id if effective_session is not None else None
 
     if tx_id is not None:
@@ -124,6 +139,11 @@ def resolve_transaction_scope(
         if explicit_session is None and using != effective_session.connection_name:
             effective_session = None
 
+    if explicit_session is None and ambient_session is not None:
+        _ensure_active_session(ambient_session)
+
+    _ensure_active_session(effective_session)
+
     if parent_tx_id is not None:
         # Nested tx route is always inherited from parent.
         return parent_tx_id, None, (

ferro_orm-0.12.2/tests/test_session.py

@@ -0,0 +1,387 @@
+import asyncio
+import warnings
+from contextlib import AsyncExitStack
+from typing import Annotated
+
+import pytest
+
+import ferro
+
+
+pytestmark = pytest.mark.sqlite_only
+
+
+class SessionMarker(ferro.Model):
+    id: Annotated[int | None, ferro.FerroField(primary_key=True)] = None
+    label: str
+
+
+@pytest.fixture(autouse=True)
+def _ensure_models_registered():
+    from ferro.state import _MODEL_REGISTRY_PY
+
+    SessionMarker._reregister_ferro()
+    _MODEL_REGISTRY_PY[SessionMarker.__name__] = SessionMarker
+    yield
+
+
+@pytest.mark.asyncio
+async def test_session_query_api_routes_to_bound_connection(tmp_path):
+    app_db = tmp_path / "app.db"
+    analytics_db = tmp_path / "analytics.db"
+
+    await ferro.connect(f"sqlite:{app_db}?mode=rwc", name="app", default=True)
+    await ferro.connect(f"sqlite:{analytics_db}?mode=rwc", name="analytics")
+    await ferro.create_tables()
+    await ferro.create_tables(using="analytics")
+
+    async with ferro.engines.session("analytics") as session:
+        created = await SessionMarker.create(id=1, label="analytics")
+        fetched = await session.query(SessionMarker).where(lambda t: t.id == 1).first()
+
+    assert created.id == 1
+    assert fetched is not None
+    assert fetched.label == "analytics"
+
+    with pytest.warns(
+        DeprecationWarning, match="Implicit default-connection routing.*v0\\.14\\.0"
+    ):
+        default_rows = await SessionMarker.all()
+    assert default_rows == []
+
+
+@pytest.mark.asyncio
+async def test_nested_sessions_shadow_and_restore(tmp_path):
+    app_db = tmp_path / "app.db"
+    analytics_db = tmp_path / "analytics.db"
+
+    await ferro.connect(f"sqlite:{app_db}?mode=rwc", name="app", default=True)
+    await ferro.connect(f"sqlite:{analytics_db}?mode=rwc", name="analytics")
+    await ferro.create_tables()
+    await ferro.create_tables(using="analytics")
+
+    async with ferro.engines.session("app"):
+        await SessionMarker.create(id=1, label="app")
+        async with ferro.engines.session("analytics"):
+            await SessionMarker.create(id=1, label="analytics")
+            inner_rows = await SessionMarker.all()
+            assert [row.label for row in inner_rows] == ["analytics"]
+        outer_rows = await SessionMarker.all()
+        assert [row.label for row in outer_rows] == ["app"]
+
+
+@pytest.mark.asyncio
+async def test_explicit_session_override_beats_ambient(tmp_path):
+    app_db = tmp_path / "app.db"
+    analytics_db = tmp_path / "analytics.db"
+
+    await ferro.connect(f"sqlite:{app_db}?mode=rwc", name="app", default=True)
+    await ferro.connect(f"sqlite:{analytics_db}?mode=rwc", name="analytics")
+    await ferro.create_tables()
+    await ferro.create_tables(using="analytics")
+
+    async with ferro.engines.session("app") as app_session:
+        await SessionMarker.create(id=1, label="app")
+        async with ferro.engines.session("analytics"):
+            await SessionMarker.create(id=1, label="analytics")
+            rows = await SessionMarker.all(session=app_session)
+            assert [row.label for row in rows] == ["app"]
+
+
+@pytest.mark.asyncio
+async def test_unnamed_session_binds_default_connection(tmp_path):
+    app_db = tmp_path / "app.db"
+    await ferro.connect(f"sqlite:{app_db}?mode=rwc", auto_migrate=True)
+
+    async with ferro.engines.session() as session:
+        assert session.connection_name == "default"
+        with warnings.catch_warnings(record=True) as caught:
+            warnings.simplefilter("always", DeprecationWarning)
+            exists = await SessionMarker.where(
+                lambda t: t.label == "missing"
+            ).exists()
+            created = await SessionMarker.create(id=20, label="session-bound")
+
+        session_warnings = [
+            w
+            for w in caught
+            if issubclass(w.category, DeprecationWarning)
+            and "without an active session" in str(w.message)
+        ]
+        assert not session_warnings
+        assert exists is False
+        assert created.id == 20
+
+
+@pytest.mark.asyncio
+async def test_legacy_unqualified_operation_warns(tmp_path):
+    app_db = tmp_path / "app.db"
+    await ferro.connect(f"sqlite:{app_db}?mode=rwc", name="app", default=True)
+    await ferro.create_tables()
+
+    with pytest.warns(
+        DeprecationWarning, match="Implicit default-connection routing.*v0\\.14\\.0"
+    ):
+        created = await SessionMarker.create(id=10, label="legacy")
+    with pytest.warns(
+        DeprecationWarning, match="Implicit default-connection routing.*v0\\.14\\.0"
+    ):
+        loaded = await SessionMarker.get(10)
+
+    assert created.id == 10
+    assert loaded.label == "legacy"
+
+
+@pytest.mark.asyncio
+async def test_session_exit_from_different_asyncio_context_succeeds(tmp_path):
+    app_db = tmp_path / "app.db"
+    await ferro.connect(f"sqlite:{app_db}?mode=rwc", auto_migrate=True)
+
+    stack = AsyncExitStack()
+    await stack.__aenter__()
+    await stack.enter_async_context(ferro.engines.session("default"))
+    await SessionMarker.create(id=1, label="demo")
+
+    async def close_stack() -> None:
+        await stack.__aexit__(None, None, None)
+
+    await asyncio.create_task(close_stack())
+
+    with pytest.raises(RuntimeError, match="Session is closed.*Open a new session"):
+        await SessionMarker.all()
+
+
+@pytest.mark.asyncio
+async def test_session_close_from_different_context_succeeds(tmp_path):
+    app_db = tmp_path / "app.db"
+    await ferro.connect(f"sqlite:{app_db}?mode=rwc", auto_migrate=True)
+
+    session = ferro.engines.session("default")
+    await session.__aenter__()
+    await SessionMarker.create(id=2, label="demo")
+
+    async def close_session() -> None:
+        await session.close()
+
+    await asyncio.create_task(close_session())
+    assert session.session_id is None
+
+    with pytest.raises(RuntimeError, match="Session is closed.*Open a new session"):
+        await SessionMarker.all()
+
+
+@pytest.mark.asyncio
+async def test_session_close_is_idempotent(tmp_path):
+    app_db = tmp_path / "app.db"
+    await ferro.connect(f"sqlite:{app_db}?mode=rwc", auto_migrate=True)
+
+    session = ferro.engines.session("default")
+    await session.__aenter__()
+    await session.close()
+    await session.close()
+    assert session.session_id is None
+
+
+@pytest.mark.asyncio
+async def test_nested_session_cross_context_close_inner_then_outer(tmp_path):
+    app_db = tmp_path / "app.db"
+    analytics_db = tmp_path / "analytics.db"
+
+    await ferro.connect(f"sqlite:{app_db}?mode=rwc", name="app", default=True)
+    await ferro.connect(f"sqlite:{analytics_db}?mode=rwc", name="analytics")
+    await ferro.create_tables()
+    await ferro.create_tables(using="analytics")
+
+    outer = ferro.engines.session("app")
+    inner = ferro.engines.session("analytics")
+    await outer.__aenter__()
+    await SessionMarker.create(id=1, label="app")
+    await inner.__aenter__()
+    await SessionMarker.create(id=1, label="analytics")
+
+    async def close_inner() -> None:
+        await inner.close()
+
+    await asyncio.create_task(close_inner())
+
+    with pytest.raises(RuntimeError, match="Session is closed.*Open a new session"):
+        await SessionMarker.all()
+
+    rows = await SessionMarker.all(session=outer)
+    assert [row.label for row in rows] == ["app"]
+
+    async def close_outer() -> None:
+        await outer.close()
+
+    await asyncio.create_task(close_outer())
+    assert outer.session_id is None
+
+    with pytest.raises(RuntimeError, match="Session is closed.*Open a new session"):
+        await SessionMarker.all(session=outer)
+
+
+@pytest.mark.asyncio
+async def test_ambient_operations_after_session_close_fail_with_session_closed_error(
+    tmp_path,
+):
+    app_db = tmp_path / "app.db"
+    await ferro.connect(f"sqlite:{app_db}?mode=rwc", auto_migrate=True)
+
+    session = ferro.engines.session("default")
+    await session.__aenter__()
+    await SessionMarker.create(id=3, label="demo")
+
+    async def close_session() -> None:
+        await session.close()
+
+    await asyncio.create_task(close_session())
+
+    with pytest.raises(RuntimeError, match="Session is closed.*Open a new session"):
+        await SessionMarker.all()
+
+
+@pytest.mark.asyncio
+async def test_explicit_session_query_after_close_fails_with_session_closed_error(
+    tmp_path,
+):
+    app_db = tmp_path / "app.db"
+    await ferro.connect(f"sqlite:{app_db}?mode=rwc", auto_migrate=True)
+
+    session = ferro.engines.session("default")
+    await session.__aenter__()
+    await session.close()
+
+    with pytest.raises(RuntimeError, match="Session is closed.*Open a new session"):
+        await session.query(SessionMarker).where(lambda t: t.id == 1).first()
+
+
+@pytest.mark.asyncio
+async def test_same_context_exit_when_ambient_session_replaced_raises_clear_error(
+    tmp_path,
+):
+    from ferro.state import _CURRENT_SESSION
+
+    app_db = tmp_path / "app.db"
+    await ferro.connect(f"sqlite:{app_db}?mode=rwc", name="app", default=True)
+    await ferro.create_tables()
+
+    outer = ferro.engines.session("app")
+    inner = ferro.engines.session("analytics")
+    await outer.__aenter__()
+    _CURRENT_SESSION.set(inner)
+
+    with pytest.raises(RuntimeError, match="ambient session does not match"):
+        await outer.close()
+
+    assert outer.session_id is not None
+    assert _CURRENT_SESSION.get() is inner
+
+
+@pytest.mark.asyncio
+async def test_same_context_outer_close_after_inner_cross_context_close_raises(
+    tmp_path,
+):
+    app_db = tmp_path / "app.db"
+    analytics_db = tmp_path / "analytics.db"
+
+    await ferro.connect(f"sqlite:{app_db}?mode=rwc", name="app", default=True)
+    await ferro.connect(f"sqlite:{analytics_db}?mode=rwc", name="analytics")
+    await ferro.create_tables()
+    await ferro.create_tables(using="analytics")
+
+    outer = ferro.engines.session("app")
+    inner = ferro.engines.session("analytics")
+    await outer.__aenter__()
+    await inner.__aenter__()
+
+    async def close_inner() -> None:
+        await inner.close()
+
+    await asyncio.create_task(close_inner())
+
+    with pytest.raises(RuntimeError, match="ambient session does not match"):
+        await outer.close()
+
+    assert outer.session_id is not None
+
+
+@pytest.mark.asyncio
+async def test_stale_ambient_with_using_still_raises_session_closed(tmp_path):
+    app_db = tmp_path / "app.db"
+    analytics_db = tmp_path / "analytics.db"
+
+    await ferro.connect(f"sqlite:{app_db}?mode=rwc", name="app", default=True)
+    await ferro.connect(f"sqlite:{analytics_db}?mode=rwc", name="analytics")
+    await ferro.create_tables()
+    await ferro.create_tables(using="analytics")
+
+    session = ferro.engines.session("app")
+    await session.__aenter__()
+
+    async def close_session() -> None:
+        await session.close()
+
+    await asyncio.create_task(close_session())
+
+    with pytest.raises(RuntimeError, match="Session is closed.*Open a new session"):
+        await SessionMarker.all(using="analytics")
+
+
+@pytest.mark.asyncio
+async def test_transaction_after_cross_context_close_raises(tmp_path):
+    app_db = tmp_path / "app.db"
+    await ferro.connect(f"sqlite:{app_db}?mode=rwc", auto_migrate=True)
+
+    session = ferro.engines.session("default")
+    await session.__aenter__()
+
+    async def close_session() -> None:
+        await session.close()
+
+    await asyncio.create_task(close_session())
+
+    with pytest.raises(RuntimeError, match="Session is closed.*Open a new session"):
+        async with ferro.transaction():
+            pass
+
+
+@pytest.mark.asyncio
+async def test_aexit_preserves_body_exception_when_close_fails(tmp_path):
+    from ferro.state import _CURRENT_SESSION
+
+    app_db = tmp_path / "app.db"
+    await ferro.connect(f"sqlite:{app_db}?mode=rwc", name="app", default=True)
+    await ferro.create_tables()
+
+    outer = ferro.engines.session("app")
+    inner = ferro.engines.session("analytics")
+    await outer.__aenter__()
+    _CURRENT_SESSION.set(inner)
+
+    body_error = ValueError("body failed")
+    with pytest.raises(ValueError, match="body failed") as exc_info:
+        await outer.__aexit__(ValueError, body_error, None)
+
+    assert isinstance(exc_info.value.__cause__, RuntimeError)
+    assert "ambient session does not match" in str(exc_info.value.__cause__)
+
+
+@pytest.mark.asyncio
+async def test_aexit_preserves_cancelled_error_when_close_fails(tmp_path):
+    from ferro.state import _CURRENT_SESSION
+
+    app_db = tmp_path / "app.db"
+    await ferro.connect(f"sqlite:{app_db}?mode=rwc", name="app", default=True)
+    await ferro.create_tables()
+
+    outer = ferro.engines.session("app")
+    inner = ferro.engines.session("analytics")
+    await outer.__aenter__()
+    _CURRENT_SESSION.set(inner)
+
+    cancelled = asyncio.CancelledError("shutdown")
+    with pytest.raises(asyncio.CancelledError, match="shutdown") as exc_info:
+        await outer.__aexit__(asyncio.CancelledError, cancelled, None)
+
+    assert isinstance(exc_info.value.__cause__, RuntimeError)
+    assert "ambient session does not match" in str(exc_info.value.__cause__)

ferro_orm-0.12.1/src/ferro/session.py

@@ -1,45 +0,0 @@
-"""Session-scoped runtime state for Ferro operations."""
-
-from __future__ import annotations
-
-from dataclasses import dataclass
-from typing import Any
-
-from ._core import close_session as _core_close_session
-from ._core import open_session as _core_open_session
-from .state import _CURRENT_SESSION
-
-
-@dataclass(slots=True)
-class Session:
-    connection_name: str | None = None
-    session_id: str | None = None
-    _token: Any = None
-
-    async def __aenter__(self) -> "Session":
-        self.session_id, resolved_name = _core_open_session(self.connection_name)
-        if self.connection_name is None:
-            self.connection_name = resolved_name
-        self._token = _CURRENT_SESSION.set(self)
-        return self
-
-    async def __aexit__(self, exc_type, exc, tb) -> None:
-        if self._token is not None:
-            _CURRENT_SESSION.reset(self._token)
-            self._token = None
-        if self.session_id is not None:
-            _core_close_session(self.session_id)
-            self.session_id = None
-
-    def query(self, model_cls):
-        from .query import Query
-
-        return Query(model_cls, session=self)
-
-
-class EngineManager:
-    def session(self, name: str | None = None) -> Session:
-        return Session(connection_name=name)
-
-
-engines = EngineManager()