cndb 0.1.6__py3-none-any.whl

cndb/__init__.py

@@ -0,0 +1,34 @@
+"""cndb - FastAPI + SQLAlchemy + Plugin 架构脚手架.
+
+对外门面（facade），仅做 re-export，不承载业务实现。
+使用者可直接：
+
+    from cndb import AppFactory, PluginBase, Settings
+
+依赖完整 re-export 清单见 __all__。
+"""
+
+from __future__ import annotations
+
+from cndb import core, plugins
+from cndb.app import app as _fastapi_app
+from cndb.core.config import Settings
+from cndb.plugins.base import AppItem, NavItem, PluginBase
+
+__all__ = [
+    "AppItem",
+    "NavItem",
+    "PluginBase",
+    "Settings",
+    "__version__",
+    "app",
+    "core",
+    "plugins",
+]
+
+
+# 版本号：与 pyproject.toml 保持同步（由 bump-my-version 自动维护）
+__version__ = "0.1.6"
+
+# 给调用者一个便捷入口：from cndb import app
+app = _fastapi_app

cndb/api/__init__.py

@@ -0,0 +1,10 @@
+"""FastAPI 依赖注入包.
+
+集中定义 Depends() 里用到的可调用对象，避免散落在各路由文件里。
+"""
+
+from __future__ import annotations
+
+from cndb.api.deps import get_request_id
+
+__all__ = ["get_request_id"]

cndb/api/deps.py

@@ -0,0 +1,111 @@
+"""FastAPI 依赖注入工具函数.
+
+集中放置 Depends() 可调用对象，避免散落在各路由文件.
+
+认证方式：JWT（Authorization: Bearer <jwt>），由前端登录流程签发.
+"""
+
+from __future__ import annotations
+
+import logging
+import uuid
+from typing import TYPE_CHECKING, Annotated
+
+from fastapi import Depends, Header, HTTPException, Request, status
+from sqlalchemy.orm import Session
+
+if TYPE_CHECKING:
+    from cndb.plugins.accounts.models import User
+
+from cndb.core.config import settings
+from cndb.core.database import get_db
+from cndb.core.security import decode_access_token
+
+logger = logging.getLogger(__name__)
+
+
+def get_request_id(x_request_id: str | None = Header(default=None)) -> str:
+    """生成或透传请求 ID（链路追踪用）.
+
+    若上游调用方已传入 X-Request-Id，则直接透传；否则生成一个新的 UUID.
+    下游服务可通过依赖注入在任意位置拿到同一个 request_id.
+    """
+    if x_request_id:
+        return x_request_id
+    return uuid.uuid4().hex
+
+
+# ── 认证依赖 ──────────────────────────────────────────
+
+
+def _authenticate_jwt(token: str, db: Session) -> User | None:
+    """尝试用 JWT 解析令牌并加载用户."""
+    from cndb.plugins.accounts.models import User
+
+    try:
+        payload = decode_access_token(token)
+    except Exception:
+        return None
+    sub = payload.get("sub")
+    if not sub:
+        return None
+    return db.query(User).filter(User.id == int(sub), User.is_active.is_(True)).first()
+
+
+def get_current_user(
+    request: Request,
+    db: Annotated[Session, Depends(get_db)],
+) -> object | None:
+    """JWT 认证：解析 Bearer 令牌并加载用户.
+
+    返回：
+        认证成功返回 User 对象；AUTH_ENABLED=False 或无认证头时返回 None；
+        AUTH_ENABLED=True 但认证失败时抛 401.
+    """
+
+    if not settings.AUTH_ENABLED:
+        return None
+
+    auth_header = request.headers.get("Authorization") or request.headers.get("authorization")
+    if not auth_header:
+        return None
+
+    # 格式: "Bearer <token>"
+    parts = auth_header.split(" ", 1)
+    if len(parts) != 2 or parts[0].lower() != "bearer":
+        return None
+
+    token = parts[1].strip()
+    if not token:
+        return None
+
+    user: User | None = _authenticate_jwt(token, db)
+
+    if user is None:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="无效或过期的令牌",
+            headers={"WWW-Authenticate": "Bearer"},
+        )
+    return user
+
+
+def get_optional_user(
+    request: Request,
+    db: Annotated[Session, Depends(get_db)],
+) -> object | None:
+    """可选认证：有令牌则解析，无令牌或无效也不报错（返回 None）.
+
+    适用于公开表单/共享视图等"登录更好、匿名也行"的场景.
+    """
+    try:
+        return get_current_user(request, db)
+    except HTTPException:
+        return None
+
+
+__all__ = [
+    "get_current_user",
+    "get_optional_user",
+    "get_request_id",
+]

cndb/app.py

@@ -0,0 +1,163 @@
+"""cndb FastAPI 应用入口.
+
+职责：
+- 组装 FastAPI app（配置/中间件/lifespan）
+- 启动时自动发现并挂载所有插件
+- 暴露框架级元路由（/api/health /api/plugins /api/navigation）
+- 不承载业务逻辑，业务由 plugins 按需挂载
+- 使用 FastAPIOffline，Swagger UI / ReDoc 静态资源从本地加载，避免外网依赖
+
+启动方式：
+- cndb serve（CLI 入口，见 runner.py）
+- uvicorn cndb.app:app --reload
+"""
+
+from __future__ import annotations
+
+from collections.abc import AsyncGenerator
+from contextlib import asynccontextmanager
+from pathlib import Path
+
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import FileResponse
+from fastapi.staticfiles import StaticFiles
+from fastapi_offline import FastAPIOffline
+
+from cndb.core.config import settings
+from cndb.core.plugin_registry import plugin_registry
+from cndb.plugins.tables.routers.public import router as public_router
+
+
+@asynccontextmanager
+async def lifespan(_app: FastAPI) -> AsyncGenerator[None]:
+    """应用生命周期管理."""
+
+    yield
+
+
+app = FastAPIOffline(
+    title=settings.APP_NAME,
+    version=settings.APP_VERSION,
+    description="cndb - FastAPI + SQLAlchemy + Plugin 架构脚手架",
+    lifespan=lifespan,
+)
+
+
+# ── 启动时自动发现并挂载插件（模块加载时执行，避免依赖 TestClient lifespan）──
+if settings.PLUGINS_AUTO_DISCOVER:  # pragma: no cover - 配置开关
+    plugin_registry.discover_and_load()
+plugin_registry.mount_routes(app)
+
+# tables 插件全局公开路由
+app.include_router(public_router)
+
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=settings.CORS_ORIGINS,
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+@app.get("/api/health", tags=["framework"])
+def health_check() -> dict[str, object]:
+    """框架级健康检查（最简版）."""
+    return {"status": "ok", "version": settings.APP_VERSION, "app": settings.APP_NAME}
+
+
+@app.get("/api/plugins", tags=["framework"])
+def list_plugins() -> dict[str, object]:
+    """获取已加载插件列表."""
+    return {"plugins": plugin_registry.get_plugin_info_list()}
+
+
+@app.get("/api/navigation", tags=["framework"])
+def get_navigation() -> dict[str, object]:
+    """汇总所有插件注册的侧边栏导航项."""
+    return {"navigation": plugin_registry.get_all_navigation()}
+
+
+# ── 前端静态资源（Vite build 产物挂 src/cndb/static/）─────────────
+from collections.abc import Awaitable, Callable  # noqa: E402
+
+from starlette.requests import Request  # noqa: E402
+from starlette.responses import Response  # noqa: E402
+
+
+def should_spa_fallback(path: str, accept_header: str) -> bool:
+    """判断是否应该对 404 请求回退 index.html.
+
+    Args:
+        path: 请求路径（如 ``"/w/1/tables"``）.
+        accept_header: HTTP Accept 头的值.
+
+    Returns:
+        ``True`` 表示应该回退到 index.html.
+    """
+    # API 路由不走前端
+    if path.startswith("/api/"):
+        return False
+    # /assets/ 下的静态资源直接返回 404，避免把不存在的 JS chunk 回成 HTML
+    if path.startswith("/assets/"):
+        return False
+    # 仅对浏览器页面请求回退（Accept 包含 text/html）
+    return "text/html" in accept_header
+
+
+_STATIC = Path(__file__).resolve().parent / "static"
+_ASSETS_DIR = _STATIC / "assets"
+_INDEX_HTML = _STATIC / "index.html"
+# 仅当下目录结构完整时才挂载 SPA 静态资源；前端未 build 时（如 CI、纯后端测试）跳过，
+# 避免 StaticFiles 构造器因目录不存在抛 RuntimeError
+_SPA_READY = _STATIC.is_dir() and _ASSETS_DIR.is_dir() and _INDEX_HTML.is_file()
+
+if _SPA_READY:  # pragma: no cover - 需要前端构建产物
+    # 挂载 /assets 为独立静态目录（带 hash 的产物，可长缓存）
+    app.mount("/assets", StaticFiles(directory=str(_ASSETS_DIR)), name="assets")
+
+    @app.middleware("http")
+    async def _spa_fallback(request: Request, call_next: Callable[[Request], Awaitable[Response]]) -> Response:
+        """SPA 路由 fallback + 缓存策略中间件.
+
+        缓存策略：
+        - index.html 及其它顶层 HTML：Cache-Control: no-cache（每次协商获取最新版本）
+          原因：Vite 构建产物文件名带 hash，index.html 是唯一引用入口，必须及时刷新
+        - /assets/*：Cache-Control: public, max-age=31536000, immutable
+          原因：Vite 输出带内容 hash，内容永不变化，可长缓存
+
+        fallback 逻辑：
+        仅对以下条件同时满足的 404 请求回退到 index.html：
+        1. 非 /api/ 开头（API 路由不走前端）
+        2. 非 /assets/ 开头（不存在的 chunk 文件直接返回 404，不要回 HTML）
+        3. Accept 头包含 text/html（浏览器请求页面才 fallback，JS/CSS/XHR 请求不回）
+        """
+        response = await call_next(request)
+        path = request.url.path
+
+        # /assets/ 下带 hash 的产物 —— 一年长缓存 + immutable
+        if path.startswith("/assets/") and response.status_code == 200:
+            response.headers["Cache-Control"] = "public, max-age=31536000, immutable"
+            return response
+
+        # HTML 页面 —— 禁止缓存，确保每次都拿到最新 index.html
+        is_html_path = path == "/" or path.endswith(".html")
+        if is_html_path and response.status_code == 200:
+            response.headers["Cache-Control"] = "no-cache, must-revalidate"
+
+        if response.status_code != 404:
+            return response
+
+        # 404 路径 —— 优先尝试直接命中静态文件（favicon.svg 等顶层资源）
+        fp = _STATIC / path.lstrip("/")
+        if fp.is_file():
+            return FileResponse(str(fp))
+        # 用纯函数判断是否需要 fallback
+        if should_spa_fallback(path, request.headers.get("accept", "")):
+            return FileResponse(
+                str(_STATIC / "index.html"),
+                headers={"Cache-Control": "no-cache, must-revalidate"},
+            )
+        return response

cndb/backup.py

@@ -0,0 +1,349 @@
+"""数据备份模块.
+
+提供完整的数据备份能力，覆盖：
+1. SQLite 数据库文件（使用 sqlite3.Connection.backup 热备份，无需停服）
+2. uploads 目录下的所有附件文件
+
+输出格式为 ``.tar.gz`` 归档，包含 ``manifest.json`` 元信息供恢复端校验。
+
+备份模式：
+- ``native``（默认）：直接备份数据库文件，速度最快，仅 SQLite 可用
+- ``sqlalchemy``：通过 SQLAlchemy 序列化所有表数据，跨数据库兼容
+
+归档结构::
+
+    backup-<timestamp>.tar.gz
+    ├── manifest.json          # 备份元信息（版本、时间、表清单、文件统计）
+    ├── database/              # 数据库备份
+    │   ├── cndb.db            # native 模式下的原始文件（SQLite）
+    │   └── dump.json          # sqlalchemy 模式下的 JSON 导出
+    └── uploads/               # 附件文件目录（按 workspace_id 隔离）
+"""
+
+from __future__ import annotations
+
+import argparse
+import datetime as dt
+import json
+import os
+import shutil
+import sqlite3
+import tarfile
+import tempfile
+from dataclasses import asdict, dataclass, field
+from pathlib import Path
+from typing import Any
+from urllib.parse import urlparse
+
+__all__ = ["BackupError", "BackupManifest", "create_backup"]
+
+MANIFEST_VERSION = "1"  # 当前 manifest 协议版本，restore 端检查此值做兼容性判断
+
+
+class BackupError(RuntimeError):
+    """备份过程中的业务错误基类."""
+
+
+@dataclass
+class UploadsInfo:
+    """uploads 目录统计信息."""
+
+    included: bool = False
+    file_count: int = 0
+    total_size: int = 0
+
+
+@dataclass
+class DatabaseInfo:
+    """数据库备份统计."""
+
+    path: str = ""
+    db_type: str = "sqlite"
+    backup_mode: str = "native"
+    tables: list[str] = field(default_factory=list)
+    row_counts: dict[str, int] = field(default_factory=dict)
+
+
+@dataclass
+class BackupManifest:
+    """备份元信息（序列化写入 manifest.json）."""
+
+    version: str = MANIFEST_VERSION
+    app_version: str = ""
+    created_at: str = ""
+    database: DatabaseInfo = field(default_factory=DatabaseInfo)
+    uploads: UploadsInfo = field(default_factory=UploadsInfo)
+
+
+def _is_sqlite_url(database_url: str) -> bool:
+    """判断 DATABASE_URL 是否为 SQLite."""
+    parsed = urlparse(database_url)
+    return parsed.scheme.startswith("sqlite")
+
+
+def _resolve_sqlite_path(database_url: str) -> Path:
+    """从 SQLite DATABASE_URL 解析出实际文件路径."""
+    # sqlite:///absolute/path/to/db → absolute/path/to/db
+    # sqlite:///./relative/path  → 处理相对路径
+    parsed = urlparse(database_url)
+    # netloc 为空时，path 开头已有斜杠
+    path_str = parsed.path
+    # 去掉前导斜杠（sqlite:/// 产生三个斜杠）
+    if path_str.startswith("/"):
+        path_str = path_str[1:]
+    return Path(path_str).resolve()
+
+
+def _backup_sqlite_native(db_path: Path, target_dir: Path) -> tuple[str, dict[str, int]]:
+    """使用 sqlite3 的 backup() API 热备份数据库文件.
+
+    Returns:
+        (备份文件名, 表名 → 行数 映射)
+    """
+    dest = target_dir / "cndb.db"
+    # 使用 sqlite3.Connection.backup() 做联机备份
+    src_conn = sqlite3.connect(str(db_path))
+    try:
+        dest_conn = sqlite3.connect(str(dest))
+        try:
+            src_conn.backup(dest_conn)
+        finally:
+            dest_conn.close()
+    finally:
+        src_conn.close()
+
+    # 统计表行数
+    row_counts: dict[str, int] = {}
+    conn = sqlite3.connect(str(dest))
+    try:
+        cursor = conn.execute(
+            "SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%' ORDER BY name"
+        )
+        tables = [row[0] for row in cursor.fetchall()]
+        for table in tables:
+            count = conn.execute(f'SELECT COUNT(*) FROM "{table}"').fetchone()[0]
+            row_counts[table] = count
+    finally:
+        conn.close()
+    return "cndb.db", row_counts
+
+
+def _backup_sqlalchemy(database_url: str, target_dir: Path) -> tuple[str, dict[str, int], list[str]]:
+    """通过 SQLAlchemy 序列化所有表数据（跨数据库兼容）.
+
+    Returns:
+        (备份文件名, 表名 → 行数 映射, 表清单)
+    """
+    from sqlalchemy import MetaData, create_engine, text
+
+    from cndb.core.plugin_registry import plugin_registry
+
+    plugin_registry.discover_and_load()
+
+    engine = create_engine(database_url)
+    try:
+        metadata = MetaData()
+        metadata.reflect(bind=engine)
+        tables_info: list[dict[str, Any]] = []
+        row_counts: dict[str, int] = {}
+
+        with engine.connect() as conn:
+            for table_name in sorted(metadata.tables.keys()):
+                sa_table = metadata.tables[table_name]
+                # 反射列名（按顺序）
+                columns = [c.name for c in sa_table.columns]
+                # 统计行数
+                count = conn.execute(text(f'SELECT COUNT(*) FROM "{table_name}"')).scalar() or 0
+                row_counts[table_name] = count
+                # 导出所有行（limit 保护：单表超 100 万行报警）
+                rows = conn.execute(sa_table.select()).mappings().all()
+                if len(rows) > 1_000_000:
+                    print(f"[backup] 警告：表 {table_name} 行数 {len(rows)} 超过一百万，序列化体积较大")
+                # 转成普通 dict，处理 datetime 等不可序列化类型
+                clean_rows = [{k: _to_json_safe(v) for k, v in row.items()} for row in rows]
+                tables_info.append({"table": table_name, "columns": columns, "rows": clean_rows})
+
+        dump = {"tables": tables_info}
+    finally:
+        engine.dispose()
+
+    dest = target_dir / "dump.json"
+    dest.write_text(json.dumps(dump, ensure_ascii=False, indent=2), encoding="utf-8")
+    return "dump.json", row_counts, sorted(metadata.tables.keys())
+
+
+def _to_json_safe(value: Any) -> Any:
+    """将 datetime/bytes/Decimal 等不可 JSON 序列化的类型转为安全值."""
+    if value is None:
+        return None
+    if isinstance(value, (dt.datetime, dt.date, dt.time)):
+        return value.isoformat()
+    if isinstance(value, bytes):
+        import base64
+
+        return {"__base64__": base64.b64encode(value).decode("ascii")}
+    # Decimal / UUID 等有 __str__ 的类型
+    return value
+
+
+def _collect_uploads(upload_dir: Path, target_dir: Path) -> UploadsInfo:
+    """收集 uploads 目录并复制到目标临时目录.
+
+    保留子目录结构（按 workspace_id 隔离）。空目录自动跳过。
+    """
+    info = UploadsInfo(included=False, file_count=0, total_size=0)
+    if not upload_dir.is_dir():
+        return info
+
+    target_uploads = target_dir / "uploads"
+    target_uploads.mkdir(parents=True, exist_ok=True)
+
+    for root, dirs, files in os.walk(upload_dir):
+        # 跳过隐藏目录
+        dirs[:] = [d for d in dirs if not d.startswith(".")]
+        for fname in files:
+            if fname.startswith("."):
+                continue
+            src_file = Path(root) / fname
+            rel_path = src_file.relative_to(upload_dir)
+            dst_file = target_uploads / rel_path
+            dst_file.parent.mkdir(parents=True, exist_ok=True)
+            shutil.copy2(src_file, dst_file)
+            info.file_count += 1
+            info.total_size += src_file.stat().st_size
+
+    if info.file_count > 0:
+        info.included = True
+    return info
+
+
+def _make_tar_archive(source_dir: Path, output_path: Path) -> None:
+    """将 source_dir 打包为 output_path（.tar.gz）.
+
+    使用 GNU 长文件格式以支持 Windows 下的长路径。
+    """
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    with tarfile.open(output_path, "w:gz", format=tarfile.GNU_FORMAT) as tar:
+        tar.add(source_dir, arcname="backup")
+
+
+def _total_size(path: Path) -> int:
+    """计算目录或文件总字节数."""
+    if path.is_file():
+        return path.stat().st_size
+    return sum(f.stat().st_size for f in path.rglob("*") if f.is_file())
+
+
+def create_backup(
+    output: Path | None = None,
+    mode: str = "auto",
+    include_uploads: bool = True,
+    database_url: str | None = None,
+    upload_dir: Path | None = None,
+) -> Path:
+    """创建完整数据备份.
+
+    Args:
+        output: 输出归档路径（默认 ``backup-<timestamp>.tar.gz``）.
+        mode: 备份模式 — ``auto``（SQLite 用 native，其它 sqlalchemy）/ ``native`` / ``sqlalchemy``.
+        include_uploads: 是否包含 uploads 目录附件.
+        database_url: 覆盖 settings.DATABASE_URL（测试用）.
+        upload_dir: 覆盖 settings.UPLOAD_DIR（测试用）.
+
+    Returns:
+        备份归档的绝对路径.
+
+    Raises:
+        BackupError: 备份过程中的业务错误（DB 不可用、路径不存在等）.
+    """
+    import cndb
+    from cndb.core.config import settings
+
+    db_url = database_url or settings.DATABASE_URL
+    up_dir = upload_dir or settings.UPLOAD_DIR
+    is_sqlite = _is_sqlite_url(db_url)
+
+    # 解析最终使用的模式
+    resolved_mode = mode
+    if mode == "auto":
+        resolved_mode = "native" if is_sqlite else "sqlalchemy"
+    if resolved_mode == "native" and not is_sqlite:
+        raise BackupError("native 备份模式仅支持 SQLite，当前数据库类型不支持，请使用 --mode sqlalchemy")
+
+    # 设置默认输出文件名
+    if output is None:
+        ts = dt.datetime.now(dt.UTC).strftime("%Y%m%dT%H%M%SZ")
+        output = Path(f"backup-{ts}.tar.gz").resolve()
+    else:
+        output = Path(output).resolve()
+
+    # 临时目录：拼装 manifest / database / uploads 后一次性打包
+    temp_root = Path(tempfile.mkdtemp(prefix="cndb-backup-"))
+    try:
+        db_dir = temp_root / "database"
+        db_dir.mkdir()
+
+        manifest = BackupManifest(
+            app_version=cndb.__version__,
+            created_at=dt.datetime.now(dt.UTC).isoformat(),
+            database=DatabaseInfo(db_type="sqlite" if is_sqlite else "other", backup_mode=resolved_mode),
+        )
+
+        print(f"[backup] 模式: {resolved_mode}，数据库: {db_url}")
+
+        # 1) 备份数据库
+        if resolved_mode == "native":
+            db_path = _resolve_sqlite_path(db_url)
+            if not db_path.is_file():
+                raise BackupError(f"SQLite 数据库文件不存在: {db_path}")
+            db_file, row_counts = _backup_sqlite_native(db_path, db_dir)
+            manifest.database.path = db_file
+            manifest.database.tables = sorted(row_counts.keys())
+            manifest.database.row_counts = row_counts
+        else:
+            db_file, row_counts, tables = _backup_sqlalchemy(db_url, db_dir)
+            manifest.database.path = db_file
+            manifest.database.tables = tables
+            manifest.database.row_counts = row_counts
+
+        total_rows = sum(row_counts.values())
+        print(f"[backup] 数据库备份完成: {len(row_counts)} 张表, 共 {total_rows} 行")
+
+        # 2) 收集 uploads
+        if include_uploads:
+            print(f"[backup] 收集附件目录: {up_dir}")
+            manifest.uploads = _collect_uploads(up_dir, temp_root)
+            if manifest.uploads.included:
+                size_kb = manifest.uploads.total_size / 1024
+                print(f"[backup] 附件: {manifest.uploads.file_count} 个文件, {size_kb:.1f} KB")
+            else:
+                print("[backup] uploads 目录为空或不存在，跳过附件备份")
+
+        # 3) 写入 manifest
+        manifest_path = temp_root / "manifest.json"
+        manifest_path.write_text(json.dumps(asdict(manifest), ensure_ascii=False, indent=2), encoding="utf-8")
+
+        # 4) 打包
+        print(f"[backup] 打包归档 → {output}")
+        _make_tar_archive(temp_root, output)
+        size_mb = output.stat().st_size / 1024 / 1024
+        print(f"[backup] 完成！归档大小: {size_mb:.2f} MB")
+        return output
+
+    finally:
+        shutil.rmtree(temp_root, ignore_errors=True)
+
+
+def backup_command(args: argparse.Namespace) -> None:
+    """CLI 命令：``cndb backup``."""
+    try:
+        output = Path(args.output).resolve() if args.output else None
+        include_uploads = not args.no_uploads
+        result = create_backup(output=output, mode=args.mode, include_uploads=include_uploads)
+        print(f"[ok] 备份成功: {result}")
+    except BackupError as exc:
+        print(f"[error] {exc}", file=os.sys.stderr)
+        os.sys.exit(1)
+    except Exception as exc:  # 兜底：捕获并格式化未预期异常
+        print(f"[error] 备份失败: {exc}", file=os.sys.stderr)
+        os.sys.exit(1)

cndb/core/__init__.py

@@ -0,0 +1,3 @@
+"""cndb 核心模块（配置、数据库、安全、插件注册中心）."""
+
+from __future__ import annotations