pz-cli 5.0.0__py3-none-any.whl

pz_foundation/db/config.py

@@ -0,0 +1,358 @@
+from __future__ import annotations
+
+from copy import deepcopy
+from dataclasses import dataclass
+import importlib
+from importlib.util import find_spec
+from functools import lru_cache
+from pathlib import Path
+from typing import Any
+from typing import Iterable
+import pkgutil
+
+import pz_settings_center.public as settings_center
+from pz_core.runtime.discovery import discover_declared_app_references
+
+from .database import FoundationDatabaseSettings, load_foundation_database_settings, normalize_foundation_database_settings
+from .mysql import build_mysql_connections
+from .postgresql import build_postgresql_connections
+from .sqlite import build_sqlite_connections
+
+
+@dataclass(frozen=True, slots=True)
+class _ConnectionSettings:
+    db_urls: tuple[str, ...]
+    db_host: str
+    db_port: str
+    db_user: str
+    db_password: str
+    db_name: str
+    db_min_size: int = 1
+    db_max_size: int = 10
+    db_connection_timeout: float = 5.0
+    db_pool_acquire_timeout: float = 5.0
+    db_statement_timeout_ms: int = 30000
+    db_idle_in_transaction_session_timeout_ms: int = 30000
+    db_pool_max_lifetime: float = 3600.0
+    db_pool_max_idle: float = 600.0
+    db_reconnect_timeout: float = 30.0
+    ssl_mode: str = ""
+    ssl_root_cert: str = ""
+    ssl_cert: str = ""
+    ssl_key: str = ""
+    ssl_password: str = ""
+    target_session_attrs: str = ""
+    options: dict[str, Any] | None = None
+
+
+def _coerce_database_settings(*, project_dir: str | None = None) -> FoundationDatabaseSettings:
+    return load_foundation_database_settings(project_dir=project_dir)
+
+
+def _effective_project_dir(project_dir: str | None = None) -> str | None:
+    if project_dir:
+        return str(Path(project_dir).resolve())
+    try:
+        value = getattr(settings_center.resolve_settings().project, "project_dir", None)
+    except Exception:
+        value = None
+    if value is None:
+        return None
+    return str(Path(str(value)).resolve())
+
+
+def build_foundation_connections(
+    *,
+    project_dir: str | None = None,
+    settings: FoundationDatabaseSettings | None = None,
+) -> dict[str, Any]:
+    resolved_project_dir = _effective_project_dir(project_dir)
+    if settings is None:
+        return deepcopy(_default_foundation_connections(resolved_project_dir))
+    return _build_foundation_connections(project_dir=resolved_project_dir, settings=settings)
+
+
+def _build_foundation_connections(
+    *,
+    project_dir: str | None = None,
+    settings: FoundationDatabaseSettings | None = None,
+) -> dict[str, Any]:
+    resolved = (
+        normalize_foundation_database_settings(settings)
+        if settings is not None
+        else _coerce_database_settings(project_dir=project_dir)
+    )
+    if not resolved.enabled:
+        raise RuntimeError("foundation database is disabled")
+    if resolved.driver == "sqlite":
+        return build_sqlite_connections(resolved)
+    normalized = _connection_settings(resolved)
+    if resolved.driver == "mysql":
+        return build_mysql_connections(normalized)
+    if resolved.driver == "postgresql":
+        return build_postgresql_connections(normalized)
+    raise RuntimeError(f"unsupported foundation database driver: {resolved.driver!r}")
+
+
+def build_foundation_tortoise_config(
+    *,
+    models: Iterable[str] = (),
+    app_label: str = "models",
+    project_dir: str | None = None,
+    settings: FoundationDatabaseSettings | None = None,
+    installed_apps: Iterable[str] | None = None,
+) -> dict[str, Any]:
+    resolved_project_dir = _effective_project_dir(project_dir)
+    model_list = [str(item).strip() for item in models if str(item).strip()]
+    if settings is None and not model_list and installed_apps is None:
+        return deepcopy(_default_foundation_tortoise_config(resolved_project_dir))
+    return _build_foundation_tortoise_config(
+        models=model_list,
+        app_label=app_label,
+        project_dir=resolved_project_dir,
+        settings=settings,
+        installed_apps=installed_apps,
+    )
+
+
+def _build_foundation_tortoise_config(
+    *,
+    models: Iterable[str] = (),
+    app_label: str = "models",
+    project_dir: str | None = None,
+    settings: FoundationDatabaseSettings | None = None,
+    installed_apps: Iterable[str] | None = None,
+) -> dict[str, Any]:
+    connections = _build_foundation_connections(project_dir=project_dir, settings=settings)
+    model_list = [str(item).strip() for item in models if str(item).strip()]
+    apps: dict[str, Any]
+    if model_list:
+        apps = {str(app_label or "models"): {"models": model_list, "default_connection": "default"}}
+    else:
+        apps = _discover_foundation_tortoise_apps(project_dir=project_dir, installed_apps=installed_apps)
+    return {"connections": connections, "apps": apps}
+
+
+def get_foundation_tortoise_config(
+    *,
+    models: Iterable[str] = (),
+    app_label: str = "models",
+    project_dir: str | None = None,
+    settings: FoundationDatabaseSettings | None = None,
+    installed_apps: Iterable[str] | None = None,
+) -> dict[str, Any]:
+    return build_foundation_tortoise_config(
+        models=models,
+        app_label=app_label,
+        project_dir=project_dir,
+        settings=settings,
+        installed_apps=installed_apps,
+    )
+
+
+@lru_cache(maxsize=8)
+def _default_foundation_connections(project_dir: str | None) -> dict[str, Any]:
+    return _build_foundation_connections(
+        project_dir=project_dir,
+        settings=_coerce_database_settings(project_dir=project_dir),
+    )
+
+
+@lru_cache(maxsize=8)
+def _default_foundation_tortoise_config(project_dir: str | None) -> dict[str, Any]:
+    return _build_foundation_tortoise_config(
+        project_dir=project_dir,
+        settings=_coerce_database_settings(project_dir=project_dir),
+    )
+
+
+def _discover_foundation_tortoise_apps(
+    *,
+    project_dir: str | None = None,
+    installed_apps: Iterable[str] | None = None,
+) -> dict[str, dict[str, Any]]:
+    modules_by_label: dict[str, list[str]] = {}
+    if _module_exists("aerich.models"):
+        _add_labeled_module(modules_by_label, "aerich.models", label="aerich")
+    for module_path in _installed_apps(project_dir=project_dir, installed_apps=installed_apps):
+        label = _app_id_for_module(module_path)
+        for discovered in _iter_model_modules(module_path):
+            _add_labeled_module(modules_by_label, discovered, label=label)
+    out: dict[str, dict[str, Any]] = {}
+    for label, modules in modules_by_label.items():
+        dedup = _dedupe_modules(modules)
+        if dedup:
+            out[label] = {"models": dedup, "default_connection": "default"}
+    return out
+
+
+def _installed_apps(*, project_dir: str | None = None, installed_apps: Iterable[str] | None = None) -> tuple[str, ...]:
+    if installed_apps is not None:
+        declared = tuple(str(item).strip() for item in installed_apps if str(item).strip())
+    else:
+        try:
+            values = getattr(settings_center.resolve_settings(project_dir=project_dir).project, "installed_apps", ()) or ()
+            declared = tuple(str(item).strip() for item in values if str(item).strip())
+        except Exception:
+            declared = ()
+    if not declared:
+        return ()
+    try:
+        refs = discover_declared_app_references(declared, project_dir=project_dir)
+    except Exception:
+        return declared
+    expanded = tuple(str(ref.module_path).strip() for ref in refs if str(ref.module_path).strip())
+    return expanded or declared
+
+
+def _app_id_for_module(module_path: str) -> str:
+    module_name = str(module_path or "").split(":", 1)[0].strip()
+    if not module_name:
+        return "models"
+    try:
+        apps_module = importlib.import_module(f"{module_name}.apps")
+        app_obj = getattr(apps_module, "app", None)
+        app_id = str(getattr(app_obj, "id", "") or "").strip()
+        if app_id:
+            return app_id
+    except Exception:
+        pass
+    fallback = module_name.split(".")[-1] or "models"
+    return fallback
+
+
+def _iter_model_modules(module_path: str) -> tuple[str, ...]:
+    module_name = str(module_path or "").split(":", 1)[0].strip()
+    if not module_name:
+        return ()
+    discovered: list[str] = []
+    for candidate in (
+        f"{module_name}.models",
+        f"{module_name}.module.models",
+        f"{module_name}.runtime.models",
+        f"{module_name}.settings_runtime.models",
+    ):
+        if _module_exists(candidate):
+            discovered.extend(_scan_models_entry(candidate))
+    return tuple(_dedupe_modules(discovered))
+
+
+def _module_exists(module_name: str) -> bool:
+    try:
+        return find_spec(module_name) is not None
+    except Exception:
+        return False
+
+
+def _scan_models_entry(module_name: str) -> list[str]:
+    found: list[str] = []
+    if _module_has_tortoise_models(module_name):
+        found.append(module_name)
+    try:
+        module = importlib.import_module(module_name)
+    except Exception:
+        return found
+    package_path = getattr(module, "__path__", None)
+    if package_path is None:
+        return found
+    prefix = module_name + "."
+    for child in pkgutil.walk_packages(package_path, prefix=prefix):
+        if _module_has_tortoise_models(child.name):
+            found.append(child.name)
+    return found
+
+
+def _module_has_tortoise_models(module_name: str) -> bool:
+    try:
+        module = importlib.import_module(module_name)
+    except Exception:
+        return False
+    try:
+        from tortoise.models import Model  # type: ignore
+    except Exception:
+        return False
+    for obj in vars(module).values():
+        try:
+            if not (isinstance(obj, type) and issubclass(obj, Model) and obj is not Model):
+                continue
+            if getattr(obj, "__module__", "") != module_name:
+                continue
+            meta = getattr(obj, "Meta", None)
+            if getattr(meta, "abstract", False):
+                continue
+            return True
+        except Exception:
+            continue
+    return False
+
+
+def _add_labeled_module(target: dict[str, list[str]], module_name: str, *, label: str) -> None:
+    if not module_name.strip():
+        return
+    target.setdefault(label, []).append(module_name)
+
+
+def _dedupe_modules(modules: Iterable[str]) -> list[str]:
+    out: list[str] = []
+    seen: set[str] = set()
+    for item in modules:
+        value = str(item or "").strip()
+        if not value or value in seen:
+            continue
+        seen.add(value)
+        out.append(value)
+    return out
+
+
+def _connection_settings(settings: FoundationDatabaseSettings) -> _ConnectionSettings:
+    default_port = 5432 if settings.driver == "postgresql" else 3306
+    hosts = tuple(str(item).strip() for item in getattr(settings, "hosts", ()) if str(item).strip())
+    ports: list[int] = []
+    for item in getattr(settings, "ports", ()):
+        try:
+            value = int(item)
+        except Exception:
+            continue
+        if value > 0:
+            ports.append(value)
+    db_host = ",".join(hosts) if hosts else str(settings.host or "")
+    if ports:
+        db_port = ",".join(str(item) for item in ports)
+    else:
+        db_port = str(int(settings.port or default_port))
+    return _ConnectionSettings(
+        db_urls=tuple(str(item).strip() for item in getattr(settings, "urls", ()) if str(item).strip()),
+        db_host=db_host,
+        db_port=db_port,
+        db_user=str(settings.user or ""),
+        db_password=str(settings.password or ""),
+        db_name=str(settings.database or ""),
+        db_min_size=max(1, int(getattr(settings, "min_size", 1) or 1)),
+        db_max_size=max(
+            max(1, int(getattr(settings, "min_size", 1) or 1)),
+            int(getattr(settings, "max_size", 10) or 10),
+        ),
+        db_connection_timeout=float(settings.connect_timeout or 5.0),
+        db_pool_acquire_timeout=float(getattr(settings, "pool_acquire_timeout", 5.0) or 5.0),
+        db_statement_timeout_ms=int(getattr(settings, "statement_timeout_ms", 30000) or 0),
+        db_idle_in_transaction_session_timeout_ms=int(
+            getattr(settings, "idle_in_transaction_session_timeout_ms", 30000) or 0
+        ),
+        db_pool_max_lifetime=float(getattr(settings, "pool_max_lifetime", 3600.0) or 0.0),
+        db_pool_max_idle=float(getattr(settings, "pool_max_idle", 600.0) or 0.0),
+        db_reconnect_timeout=float(getattr(settings, "reconnect_timeout", 30.0) or 0.0),
+        ssl_mode=str(settings.ssl_mode or ""),
+        ssl_root_cert=str(settings.ssl_root_cert or ""),
+        ssl_cert=str(settings.ssl_cert or ""),
+        ssl_key=str(settings.ssl_key or ""),
+        ssl_password=str(settings.ssl_password or ""),
+        target_session_attrs=str(getattr(settings, "target_session_attrs", "") or ""),
+        options=dict(settings.options or {}),
+    )
+
+
+__all__ = [
+    "build_foundation_connections",
+    "build_foundation_tortoise_config",
+    "get_foundation_tortoise_config",
+]