deeptrade-quant 0.4.0__tar.gz → 0.4.2__tar.gz

{deeptrade_quant-0.4.0 → deeptrade_quant-0.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deeptrade-quant
-Version: 0.4.0
+Version: 0.4.2
 Summary: LLM-driven A-share (Shanghai/Shenzhen main board) stock screening CLI
 Project-URL: Homepage, https://github.com/ty19880929/deeptrade
 Project-URL: Repository, https://github.com/ty19880929/deeptrade

{deeptrade_quant-0.4.0 → deeptrade_quant-0.4.2}/deeptrade/__init__.py

@@ -2,5 +2,5 @@
 
 from __future__ import annotations
 
-__version__ = "0.4.0"
+__version__ = "0.4.2"
 __all__ = ["__version__"]

{deeptrade_quant-0.4.0 → deeptrade_quant-0.4.2}/deeptrade/cli.py

@@ -126,7 +126,20 @@ def _build_plugin_command(plugin_id: str) -> click.Command | None:
         if not hasattr(plugin, "dispatch"):
             typer.echo(f"✘ plugin {plugin_id!r} does not implement dispatch()")
             raise typer.Exit(2)
-        rc = plugin.dispatch(list(ctx.args))
+        try:
+            rc = plugin.dispatch(list(ctx.args))
+        except (SystemExit, KeyboardInterrupt):
+            # Exit codes / Ctrl-C must propagate unaltered.
+            raise
+        except BaseException as e:  # noqa: BLE001 — final safety net
+            # Plugins are encouraged to install their own dispatch-tail handler
+            # (see plugins_api.render_exception). This catch only fires when a
+            # plugin lets an exception escape — we still want DEEPTRADE_DEBUG=1
+            # to surface the traceback rather than a bare crash.
+            from deeptrade.plugins_api import render_exception
+
+            sys.stderr.write(render_exception(e) + "\n")
+            raise typer.Exit(1) from e
         raise typer.Exit(rc or 0)
 
     return _dispatch
@@ -181,10 +194,16 @@ def init(
     paths.ensure_layout()
     db_file = paths.db_path()
     fresh = not db_file.exists()
-    db = Database(db_file)
+    # auto_migrate=False so we can collect & print the precise list of versions
+    # newly applied below; the auto-migrate path swallows that information by
+    # design (it runs unconditionally on every Database open).
+    db = Database(db_file, auto_migrate=False)
     try:
+        applied = apply_core_migrations(db)
         if fresh:
             typer.echo(f"✔ Database created: {db_file}")
+        for v in applied:
+            typer.echo(f"✔ Schema applied: {v}")
     finally:
         db.close()
 
@@ -219,7 +238,9 @@ def db_init() -> None:
     paths.ensure_layout()
     db_file = paths.db_path()
     fresh = not db_file.exists()
-    db = Database(db_file)
+    # auto_migrate=False so this command reports which versions it applied;
+    # the Database auto-migrate path returns nothing.
+    db = Database(db_file, auto_migrate=False)
     try:
         applied = apply_core_migrations(db)
         if fresh:

{deeptrade_quant-0.4.0 → deeptrade_quant-0.4.2}/deeptrade/core/db.py

@@ -6,6 +6,7 @@ held by AppContext; writes are serialized on the runner main thread.
 
 from __future__ import annotations
 
+import os
 import re
 import threading
 from collections.abc import Iterator
@@ -20,6 +21,20 @@ from deeptrade.core import paths
 
 _MIGRATION_FILENAME_RE = re.compile(r"^(\d{8}_\d{3,})_.+\.sql$")
 
+# Escape hatch: set DEEPTRADE_SKIP_AUTO_MIGRATE=1 to bypass the auto-migrate
+# step in Database.__init__. Intended for recovery (e.g. a corrupt schema
+# blocking every CLI command); not part of the documented main flow.
+_SKIP_AUTO_MIGRATE_ENV = "DEEPTRADE_SKIP_AUTO_MIGRATE"
+
+
+def _skip_auto_migrate() -> bool:
+    return os.environ.get(_SKIP_AUTO_MIGRATE_ENV, "").strip().lower() in {
+        "1",
+        "true",
+        "yes",
+        "on",
+    }
+
 
 class Database:
     """Thin wrapper around a single DuckDB connection.
@@ -29,7 +44,7 @@ class Database:
     consumed by the main thread (DESIGN §13.3).
     """
 
-    def __init__(self, db_file: Path | None = None) -> None:
+    def __init__(self, db_file: Path | None = None, *, auto_migrate: bool = True) -> None:
         self._path = db_file or paths.db_path()
         self._path.parent.mkdir(parents=True, exist_ok=True)
         self._conn: duckdb.DuckDBPyConnection = duckdb.connect(str(self._path))
@@ -39,6 +54,14 @@ class Database:
         self._write_lock = threading.RLock()
         self._tx_depth = 0  # for reentrant transaction(); only outermost BEGIN/COMMIT
 
+        # Auto-migrate: any CLI / SDK code path that opens the DB pulls schema
+        # forward so wheel upgrades don't strand stale rows for the new
+        # readers (see v0.4.1 tushare_cache_blob format change). The CLI's own
+        # `init` / `db init` / `db upgrade` commands opt out so they can print
+        # the precise list of versions newly applied.
+        if auto_migrate and not _skip_auto_migrate():
+            apply_core_migrations(self)
+
     @property
     def path(self) -> Path:
         return self._path

deeptrade_quant-0.4.2/deeptrade/core/migrations/core/20260512_001_drop_legacy_tushare_cache.sql

@@ -0,0 +1,10 @@
+-- v0.4.1 — drop legacy tushare_cache_blob entries.
+--
+-- Pre-v0.4.1 payloads were stored as a bare JSON array, then read back via
+-- pd.read_json which triggered a pandas FutureWarning on string columns whose
+-- names matched its date heuristic (trade_date, cal_date, ...). The cache
+-- read/write path now wraps payloads as {version:1, schema:{...}, data:[...]}
+-- and restores dtypes explicitly. Old rows are incompatible with that reader,
+-- so wipe the table; TushareClient._ensure_cache_table re-creates it lazily on
+-- the next write.
+DROP TABLE IF EXISTS tushare_cache_blob;

{deeptrade_quant-0.4.0 → deeptrade_quant-0.4.2}/deeptrade/core/tushare_client.py

@@ -19,7 +19,6 @@ Cache class buckets:
 from __future__ import annotations
 
 import hashlib
-import io
 import json
 import logging
 import threading
@@ -896,6 +895,15 @@ class TushareClient:
             ")"
         )
 
+    # Payload wrapper format (v0.4.1+):
+    #   {"version": 1, "schema": {col: dtype_str}, "data": [...records...]}
+    # Bypasses pd.read_json's date-column heuristic (which warns on string
+    # columns named like dates — trade_date / cal_date / ann_date) and
+    # restores dtypes explicitly from the recorded schema. Pre-v0.4.1 rows
+    # were a bare records array; those are wiped by core migration
+    # 20260512_001_drop_legacy_tushare_cache.sql, so no legacy branch here.
+    _CACHE_PAYLOAD_VERSION = 1
+
     def _write_cached(
         self,
         api_name: str,
@@ -906,7 +914,14 @@ class TushareClient:
         self._ensure_cache_table()
         body = json.dumps(params, sort_keys=True, default=str)
         h = hashlib.sha256(body.encode("utf-8")).hexdigest()
-        payload = df.to_json(orient="records", date_format="iso")
+        records_json = df.to_json(orient="records", date_format="iso")
+        payload = json.dumps(
+            {
+                "version": self._CACHE_PAYLOAD_VERSION,
+                "schema": {col: str(dt) for col, dt in df.dtypes.items()},
+                "data": json.loads(records_json) if records_json else [],
+            }
+        )
         with self._db.transaction():
             self._db.execute(
                 "DELETE FROM tushare_cache_blob "
@@ -937,12 +952,34 @@ class TushareClient:
         )
         if row is None:
             return pd.DataFrame()
-        df = pd.read_json(io.StringIO(row[0]), orient="records")
+        wrapper = json.loads(row[0])
+        df = self._restore_cached_frame(wrapper)
         if fields:
             cols = [c.strip() for c in fields.split(",") if c.strip() in df.columns]
             df = df[cols]
         return df
 
+    @classmethod
+    def _restore_cached_frame(cls, wrapper: dict[str, Any]) -> pd.DataFrame:
+        schema: dict[str, str] = wrapper["schema"]
+        data: list[dict[str, Any]] = wrapper["data"]
+        df = pd.DataFrame.from_records(data, columns=list(schema.keys()))
+        for col, dtype_str in schema.items():
+            if col not in df.columns:
+                continue
+            if dtype_str.startswith("datetime"):
+                df[col] = pd.to_datetime(df[col], errors="coerce")
+            elif dtype_str == "object":
+                continue
+            else:
+                try:
+                    df[col] = df[col].astype(dtype_str)
+                except (TypeError, ValueError):
+                    # Best-effort: if a numeric/bool column can't be coerced
+                    # back (e.g. all-null), leave the inferred dtype.
+                    pass
+        return df
+
 
 # ---------------------------------------------------------------------------
 # Fallback predicate (DESIGN §13.2 + S4)

{deeptrade_quant-0.4.0 → deeptrade_quant-0.4.2}/deeptrade/plugins_api/__init__.py

@@ -6,11 +6,13 @@ Stable surface (api_version = "1"):
     - Plugin (Protocol), PluginContext — every plugin's contract: metadata + validate_static + dispatch
     - PluginMetadata, TableSpec, MigrationSpec, PluginPermissions, ...
     - StageProfile — LLM 调参档；插件持有 preset → stage 映射表，自行解析
+    - render_exception — uniform DEEPTRADE_DEBUG-aware error formatter for dispatch tails
 """
 
 from __future__ import annotations
 
 from deeptrade.plugins_api.base import Plugin, PluginContext
+from deeptrade.plugins_api.errors import debug_enabled, render_exception
 from deeptrade.plugins_api.llm import StageProfile
 from deeptrade.plugins_api.metadata import (
     MigrationSpec,
@@ -29,4 +31,6 @@ __all__ = [
     "StageProfile",
     "TableSpec",
     "TushareApiPermissions",
+    "debug_enabled",
+    "render_exception",
 ]

deeptrade_quant-0.4.2/deeptrade/plugins_api/errors.py

@@ -0,0 +1,45 @@
+"""Error rendering helpers for plugin dispatch.
+
+Plugins commonly install a generic ``except Exception`` at the top of their
+``dispatch`` to translate any uncaught error into a non-zero exit code while
+keeping the user-facing output short. The downside is the loss of the
+traceback when something unexpected goes wrong.
+
+``render_exception`` centralizes that one-liner/traceback decision behind a
+single environment variable so users can opt into a full stack without
+plugins inventing their own conventions:
+
+    DEEPTRADE_DEBUG=1   → traceback (chained causes included)
+    unset / "0" / ""    → one-line "{glyph} {ExcType}: {msg}"
+
+Both the framework (``deeptrade/cli.py::_dispatch``) and plugin dispatch
+tails should use this helper so the toggle is honored uniformly.
+"""
+
+from __future__ import annotations
+
+import os
+import traceback
+
+_DEBUG_ENV = "DEEPTRADE_DEBUG"
+
+
+def debug_enabled() -> bool:
+    """True when ``DEEPTRADE_DEBUG`` is set to a truthy value."""
+    return os.environ.get(_DEBUG_ENV, "").strip().lower() in {"1", "true", "yes", "on"}
+
+
+def render_exception(exc: BaseException, *, header_glyph: str = "✘") -> str:
+    """Format ``exc`` for stderr.
+
+    With ``DEEPTRADE_DEBUG=1`` returns the full ``traceback.format_exception``
+    output (which already includes chained causes and exception groups)
+    prefixed by ``header_glyph``. Otherwise returns the one-liner
+    ``"{header_glyph} {ExcType}: {message}"``.
+
+    The output has no trailing newline; callers append their own.
+    """
+    if debug_enabled():
+        body = "".join(traceback.format_exception(type(exc), exc, exc.__traceback__))
+        return f"{header_glyph} {body.rstrip()}"
+    return f"{header_glyph} {type(exc).__name__}: {exc}"

{deeptrade_quant-0.4.0 → deeptrade_quant-0.4.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "deeptrade-quant"
-version = "0.4.0"
+version = "0.4.2"
 description = "LLM-driven A-share (Shanghai/Shenzhen main board) stock screening CLI"
 readme = "README.md"
 requires-python = ">=3.11"

deeptrade_quant-0.4.2/tests/core/test_db.py

@@ -0,0 +1,252 @@
+"""Core schema invariants — framework-only tables (Plan A pure isolation).
+
+After the v0.5 reshape the framework owns ONLY:
+    app_config, secret_store, schema_migrations,
+    plugins, plugin_tables, plugin_schema_migrations,
+    llm_calls, tushare_sync_state, tushare_calls
+
+All business / strategy data is plugin-owned.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+from typer.testing import CliRunner
+
+from deeptrade.cli import app
+from deeptrade.core.db import Database, apply_core_migrations
+
+
+@pytest.fixture
+def fresh_db(tmp_path: Path) -> Database:
+    # auto_migrate=False keeps the "fresh" semantics tests depend on: each
+    # test exercises apply_core_migrations explicitly to assert what it does.
+    return Database(tmp_path / "test.duckdb", auto_migrate=False)
+
+
+# --- init creates DB + dirs ----------------------------------------------
+
+
+def test_init_creates_db_file_and_dirs(monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> None:
+    monkeypatch.setenv("DEEPTRADE_HOME", str(tmp_path))
+    runner = CliRunner()
+    result = runner.invoke(app, ["init", "--no-prompts"])
+    assert result.exit_code == 0, result.stdout
+    assert (tmp_path / "deeptrade.duckdb").is_file()
+    assert (tmp_path / "logs").is_dir()
+
+
+def test_init_is_idempotent(monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> None:
+    monkeypatch.setenv("DEEPTRADE_HOME", str(tmp_path))
+    runner = CliRunner()
+    runner.invoke(app, ["init", "--no-prompts"])
+    result = runner.invoke(app, ["init", "--no-prompts"])
+    assert result.exit_code == 0
+
+
+# --- migrations record version --------------------------------------------
+
+
+def test_apply_core_migrations_records_version(fresh_db: Database) -> None:
+    """Framework owns no business tables."""
+    applied = apply_core_migrations(fresh_db)
+    assert applied == ["20260509_001", "20260512_001"]
+    rows = fresh_db.fetchall("SELECT version FROM schema_migrations ORDER BY version")
+    assert tuple(rows) == (("20260509_001",), ("20260512_001",))
+
+
+def test_apply_core_migrations_skips_applied_versions(fresh_db: Database) -> None:
+    apply_core_migrations(fresh_db)
+    second = apply_core_migrations(fresh_db)
+    assert second == []
+
+
+# --- framework tables exist; business tables do NOT -----------------------
+
+
+def test_framework_owns_only_minimal_table_set(fresh_db: Database) -> None:
+    apply_core_migrations(fresh_db)
+    tables = {
+        r[0]
+        for r in fresh_db.fetchall(
+            "SELECT table_name FROM information_schema.tables WHERE table_schema='main'"
+        )
+    }
+    expected = {
+        "app_config",
+        "secret_store",
+        "schema_migrations",
+        "plugins",
+        "plugin_tables",
+        "plugin_schema_migrations",
+        "llm_calls",
+        "tushare_sync_state",
+        "tushare_calls",
+    }
+    assert tables == expected, f"unexpected drift: {tables - expected} missing: {expected - tables}"
+
+
+# --- tushare_sync_state has plugin_id in PK (Plan A pure isolation) -------
+
+
+def test_tushare_sync_state_has_plugin_id_column_and_pk(fresh_db: Database) -> None:
+    apply_core_migrations(fresh_db)
+    cols = [
+        r[0]
+        for r in fresh_db.fetchall(
+            "SELECT column_name FROM information_schema.columns "
+            "WHERE table_name='tushare_sync_state' ORDER BY ordinal_position"
+        )
+    ]
+    # plugin_id is the first PK column
+    assert cols[0] == "plugin_id"
+    assert "data_completeness" in cols
+
+
+def test_tushare_sync_state_default_data_completeness(fresh_db: Database) -> None:
+    apply_core_migrations(fresh_db)
+    fresh_db.execute(
+        "INSERT INTO tushare_sync_state(plugin_id, api_name, trade_date, status) "
+        "VALUES (?, ?, ?, ?)",
+        ("test-plugin", "stock_basic", "*", "ok"),
+    )
+    row = fresh_db.fetchone(
+        "SELECT data_completeness FROM tushare_sync_state WHERE api_name='stock_basic'"
+    )
+    assert row is not None and row[0] == "final"
+
+
+def test_tushare_calls_has_plugin_id_column(fresh_db: Database) -> None:
+    apply_core_migrations(fresh_db)
+    cols = {
+        r[0]
+        for r in fresh_db.fetchall(
+            "SELECT column_name FROM information_schema.columns WHERE table_name='tushare_calls'"
+        )
+    }
+    assert "plugin_id" in cols
+
+
+# --- Database.__init__ auto-migrate (v0.4.2) -----------------------------
+
+
+def test_database_init_runs_pending_migrations(tmp_path: Path) -> None:
+    """A fresh Database() with default auto_migrate=True applies every core
+    migration on first open — no separate `db upgrade` call needed."""
+    db = Database(tmp_path / "auto.duckdb")
+    try:
+        rows = db.fetchall("SELECT version FROM schema_migrations ORDER BY version")
+        assert tuple(rows) == (("20260509_001",), ("20260512_001",))
+    finally:
+        db.close()
+
+
+def test_database_init_auto_migrate_false_skips(tmp_path: Path) -> None:
+    """auto_migrate=False is the documented opt-out for the CLI's
+    `db init` / `db upgrade` commands that want to collect the applied
+    list themselves."""
+    db = Database(tmp_path / "manual.duckdb", auto_migrate=False)
+    try:
+        rows = db.fetchall(
+            "SELECT table_name FROM information_schema.tables "
+            "WHERE table_schema='main' AND table_name='schema_migrations'"
+        )
+        assert rows == []
+    finally:
+        db.close()
+
+
+def test_database_init_env_var_skips_auto_migrate(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+) -> None:
+    """DEEPTRADE_SKIP_AUTO_MIGRATE=1 is the recovery escape hatch."""
+    monkeypatch.setenv("DEEPTRADE_SKIP_AUTO_MIGRATE", "1")
+    db = Database(tmp_path / "skip.duckdb")
+    try:
+        rows = db.fetchall(
+            "SELECT table_name FROM information_schema.tables "
+            "WHERE table_schema='main' AND table_name='schema_migrations'"
+        )
+        assert rows == []
+    finally:
+        db.close()
+
+
+def test_database_init_migration_failure_propagates(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+) -> None:
+    """A failing migration must bubble out of Database() as a hard error so
+    callers can't proceed against a half-migrated schema."""
+    from deeptrade.core import db as db_module
+
+    boom = RuntimeError("synthetic migration failure")
+
+    def _failing(_db: Database) -> list[str]:
+        raise boom
+
+    monkeypatch.setattr(db_module, "apply_core_migrations", _failing)
+
+    with pytest.raises(RuntimeError, match="synthetic migration failure"):
+        Database(tmp_path / "broken.duckdb")
+
+
+def test_legacy_tushare_cache_wiped_on_first_open(tmp_path: Path) -> None:
+    """v0.4.1 introduced a wrapped tushare cache payload format and a
+    migration that drops the legacy table. Auto-migrate must apply that
+    migration on first open so a pre-0.4.1 DB doesn't poison the v0.4.1+
+    reader. Regression-locks the TypeError reported against
+    `deeptrade limit-up-board lgb train`.
+    """
+    db_file = tmp_path / "legacy.duckdb"
+
+    # Stage 1: simulate a pre-0.4.1 DB — only the very first migration is on
+    # record, and the legacy cache table has a bare-array payload row.
+    db = Database(db_file, auto_migrate=False)
+    try:
+        # Apply only the v0.4.0 migration (init schema) by name; intentionally
+        # leave the v0.4.1 drop migration unrecorded.
+        from deeptrade.core.db import _list_core_migrations
+
+        for version, sql_text in _list_core_migrations():
+            if version != "20260509_001":
+                continue
+            with db.transaction():
+                db.execute(sql_text)
+                db.execute(
+                    "INSERT INTO schema_migrations(version) VALUES (?)",
+                    (version,),
+                )
+        db.execute(
+            "CREATE TABLE tushare_cache_blob ("
+            "  plugin_id VARCHAR NOT NULL,"
+            "  api_name VARCHAR NOT NULL,"
+            "  trade_date VARCHAR NOT NULL,"
+            "  params_hash VARCHAR NOT NULL,"
+            "  payload_json VARCHAR NOT NULL,"
+            "  cached_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,"
+            "  PRIMARY KEY (plugin_id, api_name, trade_date, params_hash)"
+            ")"
+        )
+        db.execute(
+            "INSERT INTO tushare_cache_blob(plugin_id, api_name, trade_date, "
+            "params_hash, payload_json) VALUES (?, ?, ?, ?, ?)",
+            ("legacy-plugin", "trade_cal", "*", "0" * 64, '[{"cal_date":"20260101"}]'),
+        )
+    finally:
+        db.close()
+
+    # Stage 2: re-open with auto_migrate=True → the drop migration must run
+    # and the legacy table must be gone.
+    db = Database(db_file)
+    try:
+        rows = db.fetchall(
+            "SELECT table_name FROM information_schema.tables "
+            "WHERE table_schema='main' AND table_name='tushare_cache_blob'"
+        )
+        assert rows == [], "legacy tushare_cache_blob should be dropped by auto-migrate"
+        applied = {r[0] for r in db.fetchall("SELECT version FROM schema_migrations")}
+        assert "20260512_001" in applied
+    finally:
+        db.close()

{deeptrade_quant-0.4.0 → deeptrade_quant-0.4.2}/tests/core/test_tushare_client.py

@@ -5,6 +5,7 @@
 
 from __future__ import annotations
 
+import warnings
 from datetime import datetime, timedelta
 from pathlib import Path
 
@@ -452,3 +453,36 @@ def test_cache_hit_requires_payload_present(
     client.call("limit_list_d", trade_date="20260427")
     # Should hit transport (because no payload despite state=ok)
     assert len(transport.calls) == 1
+
+
+# ---------------------------------------------------------------------------
+# Cache payload round-trip — dtypes preserved, no pandas FutureWarning
+# ---------------------------------------------------------------------------
+
+
+def test_cache_payload_round_trip_preserves_dtypes(client: TushareClient) -> None:
+    """v0.4.1 wrapper format restores dtypes explicitly so plugins don't see
+    pandas' read_json date-heuristic warnings on tushare-style date columns."""
+    df = pd.DataFrame(
+        {
+            "trade_date": ["20260427", "20260428"],  # YYYYMMDD strings — triggers heuristic
+            "ts_code": ["000001.SZ", "000002.SZ"],
+            "close": [12.5, 14.7],
+            "vol": [1000, 2000],
+            "is_st": [True, False],
+            "ann_dt": pd.to_datetime(["2026-04-27", "2026-04-28"]),  # real datetime64[ns]
+        }
+    )
+    api, td, params = "limit_list_d", "20260427", {"trade_date": "20260427"}
+
+    client._write_cached(api, td, params, df)  # noqa: SLF001 — exercising internal contract
+
+    with warnings.catch_warnings():
+        warnings.simplefilter("error", FutureWarning)
+        out = client._read_cached(api, td, params, fields=None)  # noqa: SLF001
+
+    assert list(out.columns) == list(df.columns)
+    for col in df.columns:
+        assert out[col].dtype == df[col].dtype, f"dtype drift on {col}: {out[col].dtype}"
+    assert out["trade_date"].tolist() == ["20260427", "20260428"]
+    assert (out["ann_dt"] == df["ann_dt"]).all()

deeptrade_quant-0.4.2/tests/plugins_api/test_errors.py

@@ -0,0 +1,77 @@
+"""Tests for ``deeptrade.plugins_api.errors`` — DEEPTRADE_DEBUG-aware
+exception rendering for plugin dispatch tails."""
+
+from __future__ import annotations
+
+import pytest
+
+from deeptrade.plugins_api import debug_enabled, render_exception
+
+
+def _make_chained_error() -> Exception:
+    """Build an exception with both ``__traceback__`` and ``__cause__`` set,
+    matching what a real `try/except ... raise X from e` would yield."""
+    try:
+        try:
+            raise ValueError("inner cause")
+        except ValueError as inner:
+            raise RuntimeError("outer failure") from inner
+    except RuntimeError as e:
+        return e
+
+
+# --- default mode (no DEBUG) ---------------------------------------------
+
+
+def test_render_exception_one_liner_by_default(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.delenv("DEEPTRADE_DEBUG", raising=False)
+    try:
+        raise TypeError("list indices must be integers or slices, not str")
+    except TypeError as e:
+        out = render_exception(e)
+    assert out == "✘ TypeError: list indices must be integers or slices, not str"
+    assert "\n" not in out, "default mode must be a single line"
+
+
+def test_render_exception_custom_glyph(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.delenv("DEEPTRADE_DEBUG", raising=False)
+    e = ValueError("bad input")
+    out = render_exception(e, header_glyph="!!")
+    assert out == "!! ValueError: bad input"
+
+
+# --- DEBUG mode ----------------------------------------------------------
+
+
+@pytest.mark.parametrize("truthy", ["1", "true", "yes", "on", "TRUE", "On"])
+def test_render_exception_traceback_when_debug(
+    monkeypatch: pytest.MonkeyPatch, truthy: str
+) -> None:
+    monkeypatch.setenv("DEEPTRADE_DEBUG", truthy)
+    e = _make_chained_error()
+    out = render_exception(e)
+    # Header glyph still present
+    assert out.startswith("✘ ")
+    # Outer exception + message present
+    assert "RuntimeError: outer failure" in out
+    # Chained cause surfaced (this is the user-facing payoff over the one-liner)
+    assert "ValueError: inner cause" in out
+    # Traceback frames present (file + lineno)
+    assert "Traceback" in out
+    # No trailing newline — caller appends its own
+    assert not out.endswith("\n")
+
+
+def test_render_exception_falsy_env_still_one_liner(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setenv("DEEPTRADE_DEBUG", "0")
+    e = RuntimeError("x")
+    assert render_exception(e) == "✘ RuntimeError: x"
+
+
+def test_debug_enabled_reflects_env(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.delenv("DEEPTRADE_DEBUG", raising=False)
+    assert debug_enabled() is False
+    monkeypatch.setenv("DEEPTRADE_DEBUG", "1")
+    assert debug_enabled() is True
+    monkeypatch.setenv("DEEPTRADE_DEBUG", "0")
+    assert debug_enabled() is False

deeptrade_quant-0.4.0/tests/core/test_db.py

@@ -1,127 +0,0 @@
-"""Core schema invariants — framework-only tables (Plan A pure isolation).
-
-After the v0.5 reshape the framework owns ONLY:
-    app_config, secret_store, schema_migrations,
-    plugins, plugin_tables, plugin_schema_migrations,
-    llm_calls, tushare_sync_state, tushare_calls
-
-All business / strategy data is plugin-owned.
-"""
-
-from __future__ import annotations
-
-from pathlib import Path
-
-import pytest
-from typer.testing import CliRunner
-
-from deeptrade.cli import app
-from deeptrade.core.db import Database, apply_core_migrations
-
-
-@pytest.fixture
-def fresh_db(tmp_path: Path) -> Database:
-    return Database(tmp_path / "test.duckdb")
-
-
-# --- init creates DB + dirs ----------------------------------------------
-
-
-def test_init_creates_db_file_and_dirs(monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> None:
-    monkeypatch.setenv("DEEPTRADE_HOME", str(tmp_path))
-    runner = CliRunner()
-    result = runner.invoke(app, ["init", "--no-prompts"])
-    assert result.exit_code == 0, result.stdout
-    assert (tmp_path / "deeptrade.duckdb").is_file()
-    assert (tmp_path / "logs").is_dir()
-
-
-def test_init_is_idempotent(monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> None:
-    monkeypatch.setenv("DEEPTRADE_HOME", str(tmp_path))
-    runner = CliRunner()
-    runner.invoke(app, ["init", "--no-prompts"])
-    result = runner.invoke(app, ["init", "--no-prompts"])
-    assert result.exit_code == 0
-
-
-# --- migrations record version --------------------------------------------
-
-
-def test_apply_core_migrations_records_version(fresh_db: Database) -> None:
-    """Framework owns no business tables."""
-    applied = apply_core_migrations(fresh_db)
-    assert applied == ["20260509_001"]
-    rows = fresh_db.fetchall("SELECT version FROM schema_migrations ORDER BY version")
-    assert tuple(rows) == (("20260509_001",),)
-
-
-def test_apply_core_migrations_skips_applied_versions(fresh_db: Database) -> None:
-    apply_core_migrations(fresh_db)
-    second = apply_core_migrations(fresh_db)
-    assert second == []
-
-
-# --- framework tables exist; business tables do NOT -----------------------
-
-
-def test_framework_owns_only_minimal_table_set(fresh_db: Database) -> None:
-    apply_core_migrations(fresh_db)
-    tables = {
-        r[0]
-        for r in fresh_db.fetchall(
-            "SELECT table_name FROM information_schema.tables WHERE table_schema='main'"
-        )
-    }
-    expected = {
-        "app_config",
-        "secret_store",
-        "schema_migrations",
-        "plugins",
-        "plugin_tables",
-        "plugin_schema_migrations",
-        "llm_calls",
-        "tushare_sync_state",
-        "tushare_calls",
-    }
-    assert tables == expected, f"unexpected drift: {tables - expected} missing: {expected - tables}"
-
-
-# --- tushare_sync_state has plugin_id in PK (Plan A pure isolation) -------
-
-
-def test_tushare_sync_state_has_plugin_id_column_and_pk(fresh_db: Database) -> None:
-    apply_core_migrations(fresh_db)
-    cols = [
-        r[0]
-        for r in fresh_db.fetchall(
-            "SELECT column_name FROM information_schema.columns "
-            "WHERE table_name='tushare_sync_state' ORDER BY ordinal_position"
-        )
-    ]
-    # plugin_id is the first PK column
-    assert cols[0] == "plugin_id"
-    assert "data_completeness" in cols
-
-
-def test_tushare_sync_state_default_data_completeness(fresh_db: Database) -> None:
-    apply_core_migrations(fresh_db)
-    fresh_db.execute(
-        "INSERT INTO tushare_sync_state(plugin_id, api_name, trade_date, status) "
-        "VALUES (?, ?, ?, ?)",
-        ("test-plugin", "stock_basic", "*", "ok"),
-    )
-    row = fresh_db.fetchone(
-        "SELECT data_completeness FROM tushare_sync_state WHERE api_name='stock_basic'"
-    )
-    assert row is not None and row[0] == "final"
-
-
-def test_tushare_calls_has_plugin_id_column(fresh_db: Database) -> None:
-    apply_core_migrations(fresh_db)
-    cols = {
-        r[0]
-        for r in fresh_db.fetchall(
-            "SELECT column_name FROM information_schema.columns WHERE table_name='tushare_calls'"
-        )
-    }
-    assert "plugin_id" in cols