pz-cli 5.0.0__py3-none-any.whl

pz_foundation/db/tortoise_manager.py

@@ -0,0 +1,724 @@
+from __future__ import annotations
+
+import asyncio
+import importlib
+import traceback
+from dataclasses import dataclass
+from types import SimpleNamespace
+from typing import Any, Callable, Optional
+
+from ..observability import get_logger
+
+try:
+    from tortoise import Tortoise, connections
+except Exception:  # pragma: no cover
+    Tortoise = None  # type: ignore[assignment]
+    connections = None  # type: ignore[assignment]
+
+
+logger = get_logger(__name__)
+
+ConfigBuilder = Callable[[], dict[str, Any]]
+ClusterFactory = Callable[[], Any]
+
+
+@dataclass(frozen=True, slots=True)
+class _RuntimeStateInspection:
+    connections_compatible: bool
+    apps_compatible: bool
+    reasons: tuple[str, ...]
+
+    @property
+    def compatible(self) -> bool:
+        return self.connections_compatible and self.apps_compatible
+
+    @property
+    def can_rebuild_aliases(self) -> bool:
+        return (not self.connections_compatible) and self.apps_compatible
+
+
+class _FallbackConnection:
+    def __init__(self, alias: str, payload: Any) -> None:
+        self.alias = alias
+        self.payload = payload
+
+    async def execute_query(self, query: str, params: list[Any] | None = None):
+        return {"alias": self.alias, "query": query, "params": list(params or []), "payload": self.payload}
+
+    def in_transaction(self):
+        class _Tx:
+            async def __aenter__(self_inner):
+                return self_inner
+
+            async def __aexit__(self_inner, exc_type, exc, tb):
+                return False
+
+        return _Tx()
+
+    async def close(self) -> None:
+        return None
+
+
+class _TortoiseManager:
+    def __init__(self) -> None:
+        self._init_lock = asyncio.Lock()
+        self._initialized: bool = False
+        self._last_config: Optional[dict[str, Any]] = None
+        self._cluster = None
+        self._ctx = None
+        self._pool_close_patched = False
+        self._fallback_connections: dict[str, _FallbackConnection] = {}
+        self._last_reconnect_at: dict[str, float] = {}
+        self._reconnect_min_interval = 0.1
+        self._loop_id: int | None = None
+
+    async def _close_tortoise_connections_quietly(self, *, reason: str) -> None:
+        if Tortoise is None:
+            return
+        try:
+            await Tortoise.close_connections()
+        except asyncio.CancelledError:
+            # Safe to ignore here because this path only runs while tearing down or
+            # replacing an old Tortoise connection set. Treating it as cleanup noise
+            # avoids surfacing a transient shutdown cancellation as a startup failure.
+            try:
+                logger.debug("Ignored CancelledError from Tortoise.close_connections during %s", reason)
+            except Exception:
+                pass
+        except Exception:
+            pass
+
+    def _install_pool_close_probe(self) -> None:
+        if self._pool_close_patched:
+            return
+        try:
+            import asyncpg.pool as _ap  # type: ignore
+        except Exception:
+            return
+        original_close = _ap.Pool.close
+
+        async def _logged_close(pool, *args, **kwargs):
+            try:
+                logger.error("asyncpg pool.close called\n%s", "".join(traceback.format_stack(limit=12)))
+            except Exception:
+                pass
+            return await original_close(pool, *args, **kwargs)
+
+        _ap.Pool.close = _logged_close
+        self._pool_close_patched = True
+
+    def _configured_aliases(self) -> tuple[str, ...]:
+        return tuple((self._last_config or {}).get("connections", {}).keys())
+
+    @staticmethod
+    def _current_loop_id() -> int | None:
+        try:
+            return id(asyncio.get_running_loop())
+        except RuntimeError:
+            return None
+
+    @staticmethod
+    def _get_active_context() -> Any | None:
+        try:
+            if connections is None:
+                return None
+            if not bool(getattr(connections, "_db_config", None)) and not connections._get_storage():
+                return None
+            return SimpleNamespace(
+                connections=connections,
+                inited=bool(getattr(connections, "_db_config", None)),
+            )
+        except Exception:
+            return None
+
+    def _adopt_active_context(self, cfg: dict[str, Any], *, current_loop_id: int | None = None) -> bool:
+        ctx = self._get_active_context()
+        if ctx is None or not bool(getattr(ctx, "inited", False)):
+            return False
+        try:
+            available_aliases = set(getattr(ctx.connections, "_db_config", {}) or {})
+        except Exception:
+            return False
+        expected_aliases = set((cfg or {}).get("connections", {}).keys())
+        if not available_aliases:
+            return False
+        if expected_aliases and not expected_aliases.intersection(available_aliases) and "default" not in available_aliases:
+            return False
+        inspection = self._inspect_runtime_state(cfg, current_loop_id=current_loop_id)
+        if not inspection.compatible:
+            return False
+        self._ctx = ctx
+        self._initialized = True
+        self._install_pool_close_probe()
+        return True
+
+    @staticmethod
+    def _configs_equivalent(left: dict[str, Any] | None, right: dict[str, Any] | None) -> bool:
+        return dict(left or {}) == dict(right or {})
+
+    def _expected_model_names(self, cfg: dict[str, Any]) -> dict[str, set[str]]:
+        if Tortoise is None:
+            return {}
+        expected: dict[str, set[str]] = {}
+        for app_label, app_cfg in (cfg or {}).get("apps", {}).items():
+            discovered: set[str] = set()
+            for module_path in app_cfg.get("models", []):
+                try:
+                    models = Tortoise._discover_models(module_path, app_label)
+                except Exception:
+                    return {}
+                for model in models:
+                    discovered.add(f"{model.__module__}.{model.__name__}")
+            expected[app_label] = discovered
+        return expected
+
+    @staticmethod
+    def _expected_aliases(cfg: dict[str, Any]) -> tuple[str, ...]:
+        return tuple(dict((cfg or {}).get("connections", {}) or {}).keys())
+
+    def _inspect_runtime_state(
+        self,
+        cfg: dict[str, Any],
+        *,
+        current_loop_id: int | None = None,
+    ) -> _RuntimeStateInspection:
+        connection_reasons = self._inspect_connection_state(cfg, current_loop_id=current_loop_id)
+        app_reasons = self._inspect_app_state(cfg)
+        return _RuntimeStateInspection(
+            connections_compatible=not connection_reasons,
+            apps_compatible=not app_reasons,
+            reasons=tuple((*connection_reasons, *app_reasons)),
+        )
+
+    def _inspect_connection_state(
+        self,
+        cfg: dict[str, Any],
+        *,
+        current_loop_id: int | None = None,
+    ) -> tuple[str, ...]:
+        expected_aliases = set(self._expected_aliases(cfg))
+        if Tortoise is None or connections is None:
+            if expected_aliases.issubset(set(self._fallback_connections.keys())):
+                return ()
+            missing = sorted(expected_aliases.difference(self._fallback_connections.keys()))
+            return tuple(f"missing_fallback_alias:{alias}" for alias in missing)
+
+        reasons: list[str] = []
+        try:
+            current_aliases = set(getattr(connections, "db_config", {}).keys())
+        except Exception:
+            return ("db_config_unavailable",)
+        missing_config_aliases = sorted(expected_aliases.difference(current_aliases))
+        reasons.extend(f"missing_db_config_alias:{alias}" for alias in missing_config_aliases)
+
+        try:
+            storage = connections._get_storage()
+        except Exception:
+            return (*reasons, "connection_storage_unavailable")
+
+        live_aliases = set(storage.keys())
+        missing_live_aliases = sorted(expected_aliases.difference(live_aliases))
+        reasons.extend(f"missing_live_alias:{alias}" for alias in missing_live_aliases)
+
+        for alias in expected_aliases.intersection(live_aliases):
+            conn = storage.get(alias)
+            pool = getattr(conn, "_pool", None)
+            if pool is not None and bool(getattr(pool, "closed", False) or getattr(pool, "_closed", False)):
+                reasons.append(f"closed_pool:{alias}")
+                continue
+            if not self._connection_pools_match_loop(
+                storage,
+                {alias},
+                current_loop_id=current_loop_id,
+            ):
+                reasons.append(f"loop_mismatch:{alias}")
+        return tuple(reasons)
+
+    def _inspect_app_state(self, cfg: dict[str, Any]) -> tuple[str, ...]:
+        if Tortoise is None:
+            return ()
+
+        reasons: list[str] = []
+        try:
+            expected_apps = set((cfg or {}).get("apps", {}).keys())
+            current_apps = getattr(Tortoise, "apps", {}) or {}
+            missing_apps = sorted(expected_apps.difference(set(current_apps.keys())))
+            reasons.extend(f"missing_app_registry:{app_label}" for app_label in missing_apps)
+
+            expected_model_names = self._expected_model_names(cfg)
+            if expected_apps and not expected_model_names:
+                reasons.append("expected_models_unavailable")
+                return tuple(reasons)
+
+            for app_label in sorted(expected_apps):
+                app_models = current_apps.get(app_label)
+                if not app_models:
+                    if f"missing_app_registry:{app_label}" not in reasons:
+                        reasons.append(f"missing_models:{app_label}")
+                    continue
+                current_model_names = {f"{model.__module__}.{model.__name__}" for model in app_models.values()}
+                expected_names = expected_model_names.get(app_label, set())
+                if current_model_names != expected_names:
+                    reasons.append(f"model_registry_mismatch:{app_label}")
+                for model in app_models.values():
+                    meta = getattr(model, "_meta", None)
+                    if meta is None:
+                        continue
+                    if getattr(meta, "default_connection", None) is None:
+                        reasons.append(f"missing_default_connection:{model.__module__}.{model.__name__}")
+                    basequery = getattr(meta, "basequery", None)
+                    if basequery is None or not hasattr(basequery, "get_parameterized_sql"):
+                        reasons.append(f"missing_basequery:{model.__module__}.{model.__name__}")
+        except Exception:
+            return ("app_registry_inspection_failed",)
+        return tuple(reasons)
+
+    def _is_current_state_compatible(self, cfg: dict[str, Any], *, current_loop_id: int | None = None) -> bool:
+        inspection = self._inspect_runtime_state(cfg, current_loop_id=current_loop_id)
+        return inspection.compatible
+
+    @staticmethod
+    def _pool_matches_loop(pool: Any, *, current_loop_id: int | None) -> bool:
+        if current_loop_id is None or pool is None:
+            return True
+        pool_loop = getattr(pool, "_loop", None)
+        if pool_loop is not None and id(pool_loop) != current_loop_id:
+            return False
+        return True
+
+    @staticmethod
+    def _connection_pools_match_loop(
+        storage: dict[str, Any],
+        expected_aliases: set[str],
+        *,
+        current_loop_id: int | None,
+    ) -> bool:
+        if current_loop_id is None:
+            return True
+        for alias in expected_aliases:
+            conn = storage.get(alias)
+            pool = getattr(conn, "_pool", None)
+            if pool is not None and not _TortoiseManager._pool_matches_loop(pool, current_loop_id=current_loop_id):
+                return False
+            if pool is None:
+                continue
+            workers = tuple(getattr(pool, "_workers", ()) or ())
+            scheduler = getattr(pool, "_sched_runner", None)
+            maintenance_tasks = tuple(task for task in (*workers, scheduler) if task is not None)
+            if not maintenance_tasks and hasattr(pool, "_tasks"):
+                return False
+            for task in maintenance_tasks:
+                done = getattr(task, "done", None)
+                if callable(done):
+                    try:
+                        if bool(done()):
+                            return False
+                    except Exception:
+                        return False
+                get_loop = getattr(task, "get_loop", None)
+                if not callable(get_loop):
+                    continue
+                try:
+                    task_loop = get_loop()
+                except Exception:
+                    return False
+                if id(task_loop) != current_loop_id:
+                    return False
+        return True
+
+    def _connection_pool_ready(self, alias: str) -> bool:
+        if connections is None:
+            return alias in self._fallback_connections
+        try:
+            storage = connections._get_storage()
+            conn = storage.get(alias)
+        except Exception:
+            return False
+        if conn is None:
+            return False
+        pool = getattr(conn, "_pool", None)
+        if pool is not None and bool(getattr(pool, "closed", False) or getattr(pool, "_closed", False)):
+            return False
+        return self._connection_pools_match_loop(
+            storage,
+            {alias},
+            current_loop_id=self._current_loop_id(),
+        )
+
+    @staticmethod
+    def _has_real_tortoise_config(cfg: dict[str, Any]) -> bool:
+        connections_cfg = dict((cfg or {}).get("connections", {}))
+        if not connections_cfg:
+            return False
+        for payload in connections_cfg.values():
+            if not isinstance(payload, dict):
+                return False
+            if payload.get("db_url"):
+                continue
+            engine = payload.get("engine")
+            if isinstance(engine, str) and engine.strip():
+                try:
+                    importlib.import_module(engine.strip())
+                except Exception:
+                    return False
+                continue
+            return False
+        return True
+
+    @staticmethod
+    def _bind_configured_models(cfg: dict[str, Any]) -> None:
+        if Tortoise is None:
+            return
+        current_apps = getattr(Tortoise, "apps", None)
+        if not isinstance(current_apps, dict):
+            return
+        for app_label, app_cfg in dict((cfg or {}).get("apps", {}) or {}).items():
+            modules = tuple(app_cfg.get("models", ()) or ())
+            if not modules:
+                continue
+            default_connection = str(app_cfg.get("default_connection") or "default").strip() or "default"
+            registry = current_apps.setdefault(app_label, {})
+            for module_path in modules:
+                try:
+                    models = Tortoise._discover_models(module_path, app_label)
+                except Exception:
+                    continue
+                for model in models:
+                    meta = getattr(model, "_meta", None)
+                    if meta is None:
+                        continue
+                    if getattr(meta, "default_connection", None) is None:
+                        meta.default_connection = default_connection
+                    registry.setdefault(getattr(model, "__name__", str(id(model))), model)
+
+    @staticmethod
+    def _clear_global_context_fallback() -> None:
+        return None
+
+    async def _init_with_config(self, cfg: dict[str, Any]) -> None:
+        if Tortoise is None or not self._has_real_tortoise_config(cfg):
+            if Tortoise is not None:
+                await self._close_tortoise_connections_quietly(reason="fallback init")
+                self._clear_global_context_fallback()
+                try:
+                    await Tortoise._reset_apps()
+                except Exception:
+                    pass
+            self._ctx = None
+            self._fallback_connections = {
+                alias: _FallbackConnection(alias, payload)
+                for alias, payload in dict((cfg or {}).get("connections", {})).items()
+            }
+            return
+
+        self._fallback_connections.clear()
+        await self._close_tortoise_connections_quietly(reason="real init")
+        self._clear_global_context_fallback()
+        try:
+            await Tortoise._reset_apps()
+        except Exception:
+            pass
+
+        try:
+            self._ctx = await Tortoise.init(config=cfg, _enable_global_fallback=True)  # type: ignore[call-arg]
+        except TypeError:
+            self._ctx = await Tortoise.init(config=cfg)
+        except Exception as exc:
+            if "Global context fallback is already enabled" in str(exc):
+                self._ctx = await Tortoise.init(config=cfg, _enable_global_fallback=False)  # type: ignore[call-arg]
+            else:
+                raise
+
+    async def _close_connection(self, conn: Any) -> None:
+        if conn is None:
+            return
+        close = getattr(conn, "close", None)
+        if close is None:
+            return
+        try:
+            result = close()
+            if asyncio.iscoroutine(result):
+                await result
+        except asyncio.CancelledError:
+            # Alias rebuild publishes the replacement connection before retiring the
+            # previous pool. Cross-loop or already-tearing-down pools can surface a
+            # cancellation during close; once the new alias is live this is cleanup
+            # noise, not a fatal runtime initialization failure.
+            try:
+                logger.debug("Ignored CancelledError while retiring rebuilt DB connection")
+            except Exception:
+                pass
+        except Exception:
+            pass
+
+    async def _close_cluster(self, cluster: Any) -> None:
+        if cluster is None:
+            return
+        for attr_name in ("aclose", "close", "shutdown", "disconnect"):
+            closer = getattr(cluster, attr_name, None)
+            if closer is None:
+                continue
+            try:
+                result = closer()
+                if asyncio.iscoroutine(result):
+                    await result
+            except Exception:
+                pass
+            return
+
+    def _rebuild_connection(self, alias: str):
+        if connections is None:
+            old_conn = self._fallback_connections.get(alias)
+            payload = ((self._last_config or {}).get("connections", {}) or {}).get(alias)
+            if payload is not None:
+                self._fallback_connections[alias] = _FallbackConnection(alias, payload)
+            return old_conn, self._fallback_connections.get(alias)
+
+        old_conn = connections.discard(alias)
+        new_conn = connections._create_connection(alias)
+        connections._get_storage()[alias] = new_conn
+        return old_conn, new_conn
+
+    def _rebuild_aliases(self, aliases: tuple[str, ...]) -> list[Any]:
+        rebuilt_old_connections: list[Any] = []
+        for name in aliases:
+            old_conn, _new_conn = self._rebuild_connection(name)
+            rebuilt_old_connections.append(old_conn)
+        self._install_pool_close_probe()
+        scope_key = ",".join(aliases) if aliases else "*"
+        self._last_reconnect_at[scope_key] = asyncio.get_running_loop().time()
+        return rebuilt_old_connections
+
+    def has_connection(self, alias: str) -> bool:
+        if self._fallback_connections:
+            return alias in self._fallback_connections
+        if connections is None:
+            return False
+        try:
+            return alias in connections._get_storage()
+        except Exception:
+            return False
+
+    def get_connection(self, alias: str):
+        if self._fallback_connections:
+            if alias not in self._fallback_connections:
+                raise KeyError(alias)
+            return self._fallback_connections[alias]
+        if Tortoise is None:
+            raise KeyError(alias)
+        return Tortoise.get_connection(alias)
+
+    async def generate_schemas(self, *, safe: bool = True) -> None:
+        if self._fallback_connections:
+            raise RuntimeError("schema generation is unavailable for fallback-only connections")
+        if Tortoise is None:
+            raise RuntimeError("tortoise is unavailable")
+        await Tortoise.generate_schemas(safe=safe)
+
+    async def ensure_initialized(
+        self,
+        config_builder: Optional[ConfigBuilder] = None,
+        cluster_factory: Optional[ClusterFactory] = None,
+    ) -> None:
+        cfg_builder = config_builder or self._default_config_builder()
+        cfg = cfg_builder() if cfg_builder is not None else {"connections": {"default": {}}, "apps": {}}
+        wants_fallback_only = not self._has_real_tortoise_config(cfg)
+        current_loop_id = self._current_loop_id()
+        loop_changed = (
+            current_loop_id is not None
+            and self._loop_id is not None
+            and self._loop_id != current_loop_id
+        )
+
+        if wants_fallback_only:
+            if self._initialized and self._configs_equivalent(self._last_config, cfg) and (
+                self._fallback_connections or self._is_current_state_compatible(cfg)
+            ):
+                self._last_config = cfg
+                self._loop_id = current_loop_id
+                return
+            async with self._init_lock:
+                if self._initialized and self._configs_equivalent(self._last_config, cfg) and (
+                    self._fallback_connections or self._is_current_state_compatible(cfg)
+                ):
+                    self._last_config = cfg
+                    self._loop_id = current_loop_id
+                    return
+
+                old_cluster = self._cluster
+                self._last_config = cfg
+                await self._init_with_config(cfg)
+                new_cluster = None
+                try:
+                    if cluster_factory is not None:
+                        new_cluster = cluster_factory()
+                except Exception:
+                    new_cluster = None
+                self._cluster = new_cluster
+                if old_cluster is not None and old_cluster is not new_cluster:
+                    await self._close_cluster(old_cluster)
+                self._initialized = True
+                self._loop_id = current_loop_id
+                return
+
+        if self._adopt_active_context(cfg, current_loop_id=current_loop_id):
+            self._last_config = cfg
+            self._loop_id = current_loop_id
+            return
+
+        if Tortoise is not None and bool(getattr(Tortoise, "_inited", False)):
+            if (
+                not loop_changed
+                and self._is_current_state_compatible(cfg, current_loop_id=current_loop_id)
+                and self._configs_equivalent(self._last_config, cfg)
+            ):
+                try:
+                    self._ctx = self._ctx or self._get_active_context()
+                except Exception:
+                    pass
+                self._initialized = True
+                self._last_config = cfg
+                self._loop_id = current_loop_id
+                self._install_pool_close_probe()
+                return
+
+        if (
+            not loop_changed
+            and self._initialized
+            and self._is_current_state_compatible(cfg, current_loop_id=current_loop_id)
+            and self._configs_equivalent(self._last_config, cfg)
+        ):
+            self._last_config = cfg
+            self._loop_id = current_loop_id
+            return
+
+        rebuilt_old_connections: list[Any] = []
+        should_close_rebuilt_connections = False
+        handled_rebuild = False
+        async with self._init_lock:
+            inspection = self._inspect_runtime_state(cfg, current_loop_id=current_loop_id)
+            if (
+                self._initialized
+                and inspection.compatible
+                and self._configs_equivalent(self._last_config, cfg)
+            ):
+                if loop_changed and not wants_fallback_only:
+                    aliases = self._configured_aliases()
+                    rebuilt_old_connections = self._rebuild_aliases(aliases)
+                    should_close_rebuilt_connections = True
+                self._last_config = cfg
+                self._loop_id = current_loop_id
+                handled_rebuild = True
+                if not should_close_rebuilt_connections:
+                    return
+
+            elif (
+                self._initialized
+                and not wants_fallback_only
+                and inspection.can_rebuild_aliases
+                and self._configs_equivalent(self._last_config, cfg)
+            ):
+                aliases = self._expected_aliases(cfg)
+                logger.warning(
+                    "Tortoise runtime degraded; rebuilding configured aliases without full re-init: %s",
+                    ", ".join(inspection.reasons) or "unknown",
+                )
+                rebuilt_old_connections = self._rebuild_aliases(aliases)
+                should_close_rebuilt_connections = True
+                self._last_config = cfg
+                self._loop_id = current_loop_id
+                handled_rebuild = True
+                if not should_close_rebuilt_connections:
+                    return
+
+            else:
+                if self._initialized and not inspection.compatible:
+                    logger.warning(
+                        "Tortoise runtime requires full re-init: %s",
+                        ", ".join(inspection.reasons) or "unknown",
+                    )
+                old_cluster = self._cluster
+                self._last_config = cfg
+                await self._init_with_config(cfg)
+                self._bind_configured_models(cfg)
+                self._install_pool_close_probe()
+                new_cluster = None
+                try:
+                    if cluster_factory is not None:
+                        new_cluster = cluster_factory()
+                except Exception:
+                    new_cluster = None
+                self._cluster = new_cluster
+                if old_cluster is not None and old_cluster is not new_cluster:
+                    await self._close_cluster(old_cluster)
+                self._initialized = True
+                self._loop_id = current_loop_id
+
+        if handled_rebuild and should_close_rebuilt_connections:
+            for old_conn in rebuilt_old_connections:
+                await self._close_connection(old_conn)
+            return
+
+    @staticmethod
+    def _default_config_builder() -> Optional[ConfigBuilder]:
+        try:
+            from pz_foundation.host.db.config import get_tortoise_config
+
+            return get_tortoise_config
+        except Exception:
+            return None
+
+    async def reconnect(self, alias: str | None = None) -> None:
+        if self._last_config is None:
+            await self.ensure_initialized()
+            return
+
+        async with self._init_lock:
+            aliases = self._configured_aliases()
+            if alias is not None:
+                aliases = tuple(name for name in aliases if name == alias)
+                if not aliases:
+                    raise KeyError(alias)
+            scope_key = ",".join(aliases) if aliases else "*"
+            now = asyncio.get_running_loop().time()
+            last_reconnect_at = self._last_reconnect_at.get(scope_key, 0.0)
+            if last_reconnect_at and now - last_reconnect_at < self._reconnect_min_interval:
+                return
+            rebuilt_old_connections = self._rebuild_aliases(aliases)
+
+        for old_conn in rebuilt_old_connections:
+            await self._close_connection(old_conn)
+
+    async def close_connections(self) -> None:
+        old_cluster = self._cluster
+        if self._fallback_connections:
+            self._fallback_connections.clear()
+        if Tortoise is not None:
+            await self._close_tortoise_connections_quietly(reason="manager close")
+        self._clear_global_context_fallback()
+        self._last_config = None
+        self._cluster = None
+        self._ctx = None
+        self._initialized = False
+        self._last_reconnect_at.clear()
+        self._loop_id = None
+        await self._close_cluster(old_cluster)
+
+    async def get_connection_status(self) -> dict[str, Any]:
+        from .lifecycle_status import connection_lifecycle_status
+
+        lifecycle = connection_lifecycle_status(self)
+        return {
+            "default": lifecycle.alias_status("default"),
+            "read_only": lifecycle.alias_status("read_only"),
+        }
+
+
+tortoise_manager = _TortoiseManager()
+
+
+async def get_connection_status() -> dict[str, Any]:
+    return await tortoise_manager.get_connection_status()
+
+
+__all__ = ["ConfigBuilder", "ClusterFactory", "_TortoiseManager", "get_connection_status", "tortoise_manager"]