jiaofu-dbview 0.2.0__tar.gz

jiaofu_dbview-0.2.0/PKG-INFO

@@ -0,0 +1,42 @@
+Metadata-Version: 2.4
+Name: jiaofu-dbview
+Version: 0.2.0
+Summary: Shared database access layer for Jiaofu AgentOS services
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: pymysql>=1.1.1
+
+# jiaofu-dbview
+
+Shared database access package for Jiaofu AgentOS services.
+
+The distribution name is `jiaofu-dbview`; the Python import name remains
+`dbview`, so existing application imports do not need to change:
+
+```python
+from dbview.pys.dbview_dataset import DbViewDataset
+```
+
+Both the OceanBase and SQLite SQL definitions are included in the wheel.
+Runtime SQLite database files are deliberately not packaged.
+
+Configuration is supplied explicitly by the caller; this package does not read
+service config files or environment variables:
+
+```python
+from dbview import OceanBaseConfig, SQLiteConfig
+from dbview.pys.dbview_dataset import DbViewDataset
+
+oceanbase = DbViewDataset(
+    "oceanbase",
+    OceanBaseConfig(
+        host="db.example.internal",
+        port=2880,
+        user="user",
+        password="secret",
+        database="tikumis",
+    ),
+)
+
+sqlite = DbViewDataset("sqlite", SQLiteConfig(path="/data/sessions.db"))
+```

jiaofu_dbview-0.2.0/README.md

@@ -0,0 +1,34 @@
+# jiaofu-dbview
+
+Shared database access package for Jiaofu AgentOS services.
+
+The distribution name is `jiaofu-dbview`; the Python import name remains
+`dbview`, so existing application imports do not need to change:
+
+```python
+from dbview.pys.dbview_dataset import DbViewDataset
+```
+
+Both the OceanBase and SQLite SQL definitions are included in the wheel.
+Runtime SQLite database files are deliberately not packaged.
+
+Configuration is supplied explicitly by the caller; this package does not read
+service config files or environment variables:
+
+```python
+from dbview import OceanBaseConfig, SQLiteConfig
+from dbview.pys.dbview_dataset import DbViewDataset
+
+oceanbase = DbViewDataset(
+    "oceanbase",
+    OceanBaseConfig(
+        host="db.example.internal",
+        port=2880,
+        user="user",
+        password="secret",
+        database="tikumis",
+    ),
+)
+
+sqlite = DbViewDataset("sqlite", SQLiteConfig(path="/data/sessions.db"))
+```

jiaofu_dbview-0.2.0/__init__.py

@@ -0,0 +1,5 @@
+"""Public configuration types for the dbview package."""
+
+from dbview.config import OceanBaseConfig, SQLiteConfig
+
+__all__ = ["OceanBaseConfig", "SQLiteConfig"]

jiaofu_dbview-0.2.0/config.py

@@ -0,0 +1,80 @@
+"""Explicit database configuration objects used by dbview callers."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Mapping, TypeAlias
+
+
+@dataclass(frozen=True)
+class OceanBaseConfig:
+    host: str
+    user: str
+    password: str
+    database: str
+    port: int = 2880
+    charset: str = "utf8mb4"
+
+    def connection_params(self) -> dict:
+        return {
+            "host": self.host,
+            "port": self.port,
+            "user": self.user,
+            "password": self.password,
+            "database": self.database,
+            "charset": self.charset,
+        }
+
+
+@dataclass(frozen=True)
+class SQLiteConfig:
+    path: str
+
+    def resolved_path(self) -> str:
+        return str(Path(self.path).expanduser().resolve())
+
+
+DatabaseConfig: TypeAlias = OceanBaseConfig | SQLiteConfig
+
+
+def normalize_config(
+    backend: str,
+    config: DatabaseConfig | Mapping[str, object],
+) -> DatabaseConfig:
+    """Validate and normalize a caller-provided backend configuration."""
+    if backend == "oceanbase":
+        if isinstance(config, OceanBaseConfig):
+            result = config
+        elif isinstance(config, Mapping):
+            required = ("host", "user", "password", "database")
+            missing = [key for key in required if key not in config]
+            if missing:
+                raise ValueError(f"missing OceanBase config fields: {', '.join(missing)}")
+            result = OceanBaseConfig(
+                host=str(config["host"]),
+                port=int(config.get("port", 2880)),
+                user=str(config["user"]),
+                password=str(config["password"]),
+                database=str(config["database"]),
+                charset=str(config.get("charset", "utf8mb4")),
+            )
+        else:
+            raise TypeError("oceanbase config must be OceanBaseConfig or a mapping")
+        if not result.host or not result.user or not result.database:
+            raise ValueError("OceanBase host, user and database must not be empty")
+        return result
+
+    if backend == "sqlite":
+        if isinstance(config, SQLiteConfig):
+            result = config
+        elif isinstance(config, Mapping):
+            if "path" not in config:
+                raise ValueError("missing SQLite config field: path")
+            result = SQLiteConfig(path=str(config["path"]))
+        else:
+            raise TypeError("sqlite config must be SQLiteConfig or a mapping")
+        if not result.path:
+            raise ValueError("SQLite path must not be empty")
+        return result
+
+    raise ValueError(f"unsupported dbview backend: {backend!r}")

jiaofu_dbview-0.2.0/init_db_example.py

@@ -0,0 +1,50 @@
+"""Unified database schema initializer."""
+from __future__ import annotations
+
+import argparse
+
+from dbview.config import OceanBaseConfig, SQLiteConfig
+from dbview.pys.dbview_dataset import DbViewDataset
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Initialize dbview schema")
+    parser.add_argument(
+        "--backend",
+        choices=("sqlite", "oceanbase"),
+        required=True,
+        help="database backend to initialize",
+    )
+    parser.add_argument("--sqlite-path")
+    parser.add_argument("--host")
+    parser.add_argument("--port", type=int, default=2880)
+    parser.add_argument("--user")
+    parser.add_argument("--password")
+    parser.add_argument("--database")
+    parser.add_argument("--charset", default="utf8mb4")
+    args = parser.parse_args()
+
+    if args.backend == "sqlite":
+        if not args.sqlite_path:
+            parser.error("--sqlite-path is required for sqlite")
+        config = SQLiteConfig(path=args.sqlite_path)
+    else:
+        missing = [name for name in ("host", "user", "password", "database") if not getattr(args, name)]
+        if missing:
+            parser.error("OceanBase requires: " + ", ".join(f"--{name}" for name in missing))
+        config = OceanBaseConfig(
+            host=args.host,
+            port=args.port,
+            user=args.user,
+            password=args.password,
+            database=args.database,
+            charset=args.charset,
+        )
+
+    dataset = DbViewDataset(args.backend, config)
+    dataset.init_schema()
+    print(f"initialized {dataset.backend} schema")
+
+
+if __name__ == "__main__":
+    main()

jiaofu_dbview-0.2.0/jiaofu_dbview.egg-info/PKG-INFO

@@ -0,0 +1,42 @@
+Metadata-Version: 2.4
+Name: jiaofu-dbview
+Version: 0.2.0
+Summary: Shared database access layer for Jiaofu AgentOS services
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: pymysql>=1.1.1
+
+# jiaofu-dbview
+
+Shared database access package for Jiaofu AgentOS services.
+
+The distribution name is `jiaofu-dbview`; the Python import name remains
+`dbview`, so existing application imports do not need to change:
+
+```python
+from dbview.pys.dbview_dataset import DbViewDataset
+```
+
+Both the OceanBase and SQLite SQL definitions are included in the wheel.
+Runtime SQLite database files are deliberately not packaged.
+
+Configuration is supplied explicitly by the caller; this package does not read
+service config files or environment variables:
+
+```python
+from dbview import OceanBaseConfig, SQLiteConfig
+from dbview.pys.dbview_dataset import DbViewDataset
+
+oceanbase = DbViewDataset(
+    "oceanbase",
+    OceanBaseConfig(
+        host="db.example.internal",
+        port=2880,
+        user="user",
+        password="secret",
+        database="tikumis",
+    ),
+)
+
+sqlite = DbViewDataset("sqlite", SQLiteConfig(path="/data/sessions.db"))
+```

jiaofu_dbview-0.2.0/jiaofu_dbview.egg-info/SOURCES.txt

@@ -0,0 +1,87 @@
+README.md
+__init__.py
+config.py
+init_db_example.py
+pyproject.toml
+./__init__.py
+./config.py
+./init_db_example.py
+./oceanbase/__init__.py
+./oceanbase/init_db.py
+./oceanbase/mysql_cli.py
+./pys/__init__.py
+./pys/agent_messages_dao.py
+./pys/agent_sessions_dao.py
+./pys/backend.py
+./pys/dbview_dataset.py
+./pys/loader.py
+./pys/profile_task_queue_dao.py
+./pys/request_traces_dao.py
+./pys/sql_executor.py
+./pys/user_books_dao.py
+./pys/user_feedback_dao.py
+./pys/user_profile_dao.py
+./pys/users_dao.py
+./sqlite/__init__.py
+./sqlite/init_db.py
+./sqlite/main.py
+./sqls/ddl/oceanbase.sql
+./sqls/ddl/sqlite.sql
+./sqls/dml/oceanbase/agent_messages.sql
+./sqls/dml/oceanbase/agent_sessions.sql
+./sqls/dml/oceanbase/profile_task_queue.sql
+./sqls/dml/oceanbase/request_traces.sql
+./sqls/dml/oceanbase/user_books.sql
+./sqls/dml/oceanbase/user_feedback.sql
+./sqls/dml/oceanbase/user_profile.sql
+./sqls/dml/oceanbase/users.sql
+./sqls/dml/sqlite/agent_messages.sql
+./sqls/dml/sqlite/agent_sessions.sql
+./sqls/dml/sqlite/profile_task_queue.sql
+./sqls/dml/sqlite/request_traces.sql
+./sqls/dml/sqlite/user_books.sql
+./sqls/dml/sqlite/user_feedback.sql
+./sqls/dml/sqlite/user_profile.sql
+./sqls/dml/sqlite/users.sql
+jiaofu_dbview.egg-info/PKG-INFO
+jiaofu_dbview.egg-info/SOURCES.txt
+jiaofu_dbview.egg-info/dependency_links.txt
+jiaofu_dbview.egg-info/requires.txt
+jiaofu_dbview.egg-info/top_level.txt
+oceanbase/__init__.py
+oceanbase/init_db.py
+oceanbase/mysql_cli.py
+pys/__init__.py
+pys/agent_messages_dao.py
+pys/agent_sessions_dao.py
+pys/backend.py
+pys/dbview_dataset.py
+pys/loader.py
+pys/profile_task_queue_dao.py
+pys/request_traces_dao.py
+pys/sql_executor.py
+pys/user_books_dao.py
+pys/user_feedback_dao.py
+pys/user_profile_dao.py
+pys/users_dao.py
+sqlite/__init__.py
+sqlite/init_db.py
+sqlite/main.py
+sqls/ddl/oceanbase.sql
+sqls/ddl/sqlite.sql
+sqls/dml/oceanbase/agent_messages.sql
+sqls/dml/oceanbase/agent_sessions.sql
+sqls/dml/oceanbase/profile_task_queue.sql
+sqls/dml/oceanbase/request_traces.sql
+sqls/dml/oceanbase/user_books.sql
+sqls/dml/oceanbase/user_feedback.sql
+sqls/dml/oceanbase/user_profile.sql
+sqls/dml/oceanbase/users.sql
+sqls/dml/sqlite/agent_messages.sql
+sqls/dml/sqlite/agent_sessions.sql
+sqls/dml/sqlite/profile_task_queue.sql
+sqls/dml/sqlite/request_traces.sql
+sqls/dml/sqlite/user_books.sql
+sqls/dml/sqlite/user_feedback.sql
+sqls/dml/sqlite/user_profile.sql
+sqls/dml/sqlite/users.sql

jiaofu_dbview-0.2.0/jiaofu_dbview.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

jiaofu_dbview-0.2.0/jiaofu_dbview.egg-info/requires.txt

@@ -0,0 +1 @@
+pymysql>=1.1.1

jiaofu_dbview-0.2.0/jiaofu_dbview.egg-info/top_level.txt

@@ -0,0 +1 @@
+dbview

jiaofu_dbview-0.2.0/oceanbase/init_db.py

@@ -0,0 +1,104 @@
+"""OceanBase (MySQL protocol) backend keyed by explicit connection config."""
+from __future__ import annotations
+
+import threading
+
+from dbview.config import OceanBaseConfig
+
+
+class OceanBaseDB:
+    _instances: dict[OceanBaseConfig, "OceanBaseDB"] = {}
+    _instances_lock = threading.Lock()
+
+    def __init__(self, config: OceanBaseConfig) -> None:
+        import pymysql  # lazy: only needed on the mysql path
+        from pymysql.cursors import DictCursor
+
+        self._pymysql = pymysql
+        self._DictCursor = DictCursor
+        self._lock = threading.Lock()
+        self.config = config
+        self.conn = self._connect()
+
+    def _connect(self):
+        params = self.config.connection_params()
+        params["cursorclass"] = self._DictCursor
+        params["autocommit"] = False
+        return self._pymysql.connect(**params)
+
+    def _reconnect(self) -> None:
+        try:
+            self.conn.close()
+        except Exception:
+            pass
+        self.conn = self._connect()
+
+    def _ensure_connection(self) -> None:
+        try:
+            self.conn.ping(reconnect=True)
+        except Exception:
+            self._reconnect()
+
+    @classmethod
+    def instance(cls, config: OceanBaseConfig) -> "OceanBaseDB":
+        with cls._instances_lock:
+            if config not in cls._instances:
+                cls._instances[config] = cls(config)
+            return cls._instances[config]
+
+    def init_schema(self, statements: list[str]) -> None:
+        """Execute schema statements from the unified initializer."""
+        with self._lock:
+            self._ensure_connection()
+            with self.conn.cursor() as cur:
+                for stmt in statements:
+                    try:
+                        cur.execute(stmt)
+                    except Exception as e:
+                        code = getattr(e, "args", [None])[0]
+                        if code not in (1050, 1061):
+                            raise
+            self.conn.commit()
+
+    def execute(self, sql: str, params: dict | None = None, fetch: str = "none"):
+        """Run one statement; commit on writes."""
+        last_exc = None
+        for attempt in (1, 2):
+            with self._lock:
+                try:
+                    self._ensure_connection()
+                    with self.conn.cursor() as cur:
+                        cur.execute(sql, params or {})
+                        if fetch == "one":
+                            row = cur.fetchone()
+                            return row if row is not None else None
+                        if fetch == "all":
+                            return list(cur.fetchall())
+                        if cur.description is None:
+                            self.conn.commit()
+                            return cur.rowcount
+                        return None
+                except self._pymysql.err.InterfaceError as exc:
+                    last_exc = exc
+                    self._reconnect()
+                    if attempt == 2:
+                        raise
+                except self._pymysql.err.OperationalError as exc:
+                    last_exc = exc
+                    try:
+                        self.conn.rollback()
+                    except Exception:
+                        pass
+                    code = getattr(exc, "args", [None])[0]
+                    if code in (2006, 2013, 0):
+                        self._reconnect()
+                        if attempt == 1:
+                            continue
+                    raise
+                except Exception:
+                    try:
+                        self.conn.rollback()
+                    except Exception:
+                        pass
+                    raise
+        raise last_exc

jiaofu_dbview-0.2.0/oceanbase/mysql_cli.py

@@ -0,0 +1,58 @@
+#!/usr/bin/env python3
+"""Small OceanBase SQL client with explicit connection arguments."""
+from __future__ import annotations
+
+import argparse
+
+import pymysql
+
+from dbview.config import OceanBaseConfig
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Connect to OceanBase")
+    parser.add_argument("--host", required=True)
+    parser.add_argument("--port", type=int, default=2880)
+    parser.add_argument("--user", required=True)
+    parser.add_argument("--password", required=True)
+    parser.add_argument("--database", required=True)
+    parser.add_argument("--charset", default="utf8mb4")
+    parser.add_argument("sql", nargs="*")
+    args = parser.parse_args()
+
+    config = OceanBaseConfig(
+        host=args.host,
+        port=args.port,
+        user=args.user,
+        password=args.password,
+        database=args.database,
+        charset=args.charset,
+    )
+    conn = pymysql.connect(**config.connection_params())
+    cursor = conn.cursor()
+    try:
+        if args.sql:
+            statements = [" ".join(args.sql)]
+        else:
+            print("Connected to OceanBase. Type SQL (Ctrl+D to exit):")
+            statements = iter(lambda: input("mysql> ").strip(), "")
+
+        for sql in statements:
+            if not sql:
+                continue
+            cursor.execute(sql)
+            if cursor.description:
+                print("\t".join(item[0] for item in cursor.description))
+                for row in cursor.fetchall():
+                    print("\t".join(str(value) for value in row))
+            print(f"Rows: {cursor.rowcount}")
+            conn.commit()
+    except EOFError:
+        pass
+    finally:
+        cursor.close()
+        conn.close()
+
+
+if __name__ == "__main__":
+    main()

jiaofu_dbview-0.2.0/pyproject.toml

@@ -0,0 +1,30 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "jiaofu-dbview"
+version = "0.2.0"
+description = "Shared database access layer for Jiaofu AgentOS services"
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+    "pymysql>=1.1.1",
+]
+
+[tool.setuptools]
+packages = [
+    "dbview",
+    "dbview.oceanbase",
+    "dbview.pys",
+    "dbview.sqlite",
+]
+package-dir = {dbview = "."}
+include-package-data = true
+
+[tool.setuptools.package-data]
+dbview = [
+    "sqls/ddl/*.sql",
+    "sqls/dml/oceanbase/*.sql",
+    "sqls/dml/sqlite/*.sql",
+]

jiaofu_dbview-0.2.0/pys/agent_messages_dao.py

@@ -0,0 +1,70 @@
+"""DAO for the agent_messages table (history reads + profile-worker reads)."""
+from __future__ import annotations
+
+from .backend import run
+
+
+def insert_message(session_id: str, message_data: str, turn_number: int | None = None, book_id: str | None = None) -> None:
+    run("insert_message", {
+        "session_id": session_id,
+        "book_id": book_id or "",
+        "message_data": message_data,
+        "turn_number": turn_number,
+    })
+
+
+def max_msg_id(session_id: str) -> dict | None:
+    return run("max_msg_id", {"session_id": session_id}, fetch="one")
+
+
+def count_messages(cuid: str, uid: str | None = None) -> dict | None:
+    return run("count_messages", {"cuid": cuid, "uid": uid}, fetch="one")
+
+
+def list_history_turns(cuid: str, before_msg_id: int, limit: int, uid: str | None = None) -> list[dict]:
+    return run("list_history_turns", {
+        "cuid": cuid,
+        "uid": uid,
+        "before_msg_id": before_msg_id,
+        "limit": limit,
+    }, fetch="all")
+
+
+def list_turn_items(session_id: str, turn_number: int) -> list[dict]:
+    return run("list_turn_items", {
+        "session_id": session_id,
+        "turn_number": turn_number,
+    }, fetch="all")
+
+
+def has_more_history(cuid: str, first_msg_id: int, uid: str | None = None) -> dict | None:
+    return run("has_more_history", {
+        "cuid": cuid,
+        "uid": uid,
+        "first_msg_id": first_msg_id,
+    }, fetch="one")
+
+
+def list_items_by_msg_range(cuid: str, from_msg_id: int, max_turns: int, uid: str | None = None) -> list[dict]:
+    return run("list_items_by_msg_range", {
+        "cuid": cuid,
+        "uid": uid,
+        "from_msg_id": from_msg_id,
+        "max_turns": max_turns,
+    }, fetch="all")
+
+
+def list_session_turn_items(session_id: str, from_turn: int | None = None, to_turn: int | None = None, book_id: str | None = None) -> list[dict]:
+    return run("list_session_turn_items", {
+        "session_id": session_id,
+        "book_id": book_id or "",
+        "from_turn": from_turn,
+        "to_turn": to_turn,
+    }, fetch="all")
+
+
+def list_session_books(session_id: str) -> list[dict]:
+    return run("list_session_books", {"session_id": session_id}, fetch="all")
+
+def max_turn_number(session_id: str) -> dict | None:
+    return run("max_turn_number", {"session_id": session_id}, fetch="one")

jiaofu_dbview-0.2.0/pys/agent_sessions_dao.py

@@ -0,0 +1,28 @@
+"""DAO for the agent_sessions table."""
+from __future__ import annotations
+
+from .backend import run
+
+
+def insert_session(session_id: str, cuid: str | None, last_book_id: str | None, uid: str | None = None) -> None:
+    updated = run("touch_session", {"session_id": session_id})
+    if updated:
+        return
+    run("insert_session", {
+        "session_id": session_id,
+        "cuid": cuid,
+        "uid": uid,
+        "book_id": last_book_id,
+    })
+
+
+def touch_session(session_id: str) -> None:
+    run("touch_session", {"session_id": session_id})
+
+
+def set_last_book(session_id: str, last_book_id: str | None) -> None:
+    run("set_last_book", {"session_id": session_id, "last_book_id": last_book_id})
+
+
+def get_latest_session(cuid: str, uid: str | None = None) -> dict | None:
+    return run("get_latest_session", {"cuid": cuid, "uid": uid}, fetch="one")

jiaofu_dbview-0.2.0/pys/backend.py

@@ -0,0 +1,13 @@
+"""Deprecated function-style DAO dispatcher.
+
+Use ``dbview.pys.dbview_dataset.DbViewDataset`` instead. Keeping this module only makes
+old imports fail loudly instead of silently using an unintended database.
+"""
+from __future__ import annotations
+
+
+def run(*args, **kwargs):
+    raise RuntimeError(
+        "dbview.pys.backend.run is deprecated; create "
+        "DbViewDataset(backend, config) and call methods on that instance"
+    )