deeptrade-quant 0.0.2__tar.gz → 0.1.0__tar.gz

{deeptrade_quant-0.0.2 → deeptrade_quant-0.1.0}/.gitignore

@@ -28,6 +28,9 @@ htmlcov/
 *.swp
 *.swo
 
+# Claude Code workspace
+.claude/
+
 # Environment
 .env
 .env.local

{deeptrade_quant-0.0.2 → deeptrade_quant-0.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deeptrade-quant
-Version: 0.0.2
+Version: 0.1.0
 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
@@ -14,6 +14,7 @@ Requires-Dist: click>=8.1
 Requires-Dist: duckdb>=1.0
 Requires-Dist: keyring>=25.0
 Requires-Dist: openai>=1.0
+Requires-Dist: packaging>=23.0
 Requires-Dist: pandas>=2.2
 Requires-Dist: pydantic>=2.7
 Requires-Dist: pyyaml>=6.0

{deeptrade_quant-0.0.2 → deeptrade_quant-0.1.0}/deeptrade/__init__.py

@@ -4,5 +4,5 @@ from __future__ import annotations
 
 from deeptrade.core.notifier import notification_session, notify
 
-__version__ = "0.0.1"
+__version__ = "0.1.0"
 __all__ = ["__version__", "notification_session", "notify"]

{deeptrade_quant-0.0.2 → deeptrade_quant-0.1.0}/deeptrade/channels_builtin/stdout/deeptrade_plugin.yaml

@@ -15,8 +15,8 @@ permissions:
   llm_tools: false
 
 migrations:
-  - version: "20260429_001"
-    file: migrations/20260429_001_init.sql
+  - version: "20260509_001"
+    file: migrations/20260509_001_init.sql
     checksum: "sha256:7317d23d4ac91b9a1259e2ba4d990863491de8fe1115e19052b02f83939399cc"
 
 tables:

{deeptrade_quant-0.0.2 → deeptrade_quant-0.1.0}/deeptrade/cli.py

@@ -184,14 +184,8 @@ def init(
     fresh = not db_file.exists()
     db = Database(db_file)
     try:
-        applied = apply_core_migrations(db)
         if fresh:
             typer.echo(f"✔ Database created: {db_file}")
-        if applied:
-            for v in applied:
-                typer.echo(f"✔ Schema applied: {v}")
-        else:
-            typer.echo("✔ Database already initialized; schema up-to-date")
     finally:
         db.close()
 
@@ -210,5 +204,38 @@ def init(
         cmd_set_llm()
 
 
+
+@app.command(name="db", context_settings={"ignore_unknown_options": True, "allow_extra_args": True})
+def db_cmd(ctx: click.Context) -> None:
+    """Database migration and management commands (legacy stub; use `deeptrade db init` via group if added)."""
+    pass
+
+db_app = typer.Typer(name="db", help="Database migration and management commands.")
+app.add_typer(db_app, name="db")
+
+@db_app.command("init")
+def db_init() -> None:
+    """Initialize the core database tables and apply migrations."""
+    paths.ensure_layout()
+    db_file = paths.db_path()
+    fresh = not db_file.exists()
+    db = Database(db_file)
+    try:
+        applied = apply_core_migrations(db)
+        if fresh:
+            typer.echo(f"✔ Database created: {db_file}")
+        if applied:
+            for v in applied:
+                typer.echo(f"✔ Schema applied: {v}")
+        else:
+            typer.echo("✔ Database already initialized; schema up-to-date")
+    finally:
+        db.close()
+
+@db_app.command("upgrade")
+def db_upgrade() -> None:
+    """Apply any pending core migrations."""
+    db_init()
+
 if __name__ == "__main__":
     app()

{deeptrade_quant-0.0.2 → deeptrade_quant-0.1.0}/deeptrade/cli_config.py

@@ -191,13 +191,35 @@ def _set_llm_new(svc: ConfigService) -> None:
         typer.echo(f"Provider {name!r} already exists; pick edit instead.")
         raise typer.Exit(2)
     default_base = _DEFAULT_BASE_URLS.get(name.split("-")[0], "")
-    _prompt_and_save_provider(svc, name, defaults=None, default_base_url=default_base)
+    # Adding into an empty dict auto-promotes to default; offer the choice
+    # only when a default is already in place.
+    promote_default: bool | None = None
+    if cfg.llm_providers:
+        promote_default = bool(
+            questionary.confirm(
+                f"Set {name!r} as the default LLM provider?",
+                default=False,
+            ).ask()
+        )
+    _prompt_and_save_provider(
+        svc,
+        name,
+        defaults=None,
+        default_base_url=default_base,
+        is_default=promote_default,
+    )
 
 
 def _set_llm_edit(svc: ConfigService, name: str) -> None:
     cfg = svc.get_app_config()
     cur = cfg.llm_providers[name]
-    _prompt_and_save_provider(svc, name, defaults=cur.model_dump(), default_base_url=cur.base_url)
+    _prompt_and_save_provider(
+        svc,
+        name,
+        defaults=cur.model_dump(),
+        default_base_url=cur.base_url,
+        is_default=None,
+    )
 
 
 def _prompt_and_save_provider(
@@ -206,6 +228,7 @@ def _prompt_and_save_provider(
     *,
     defaults: dict | None,
     default_base_url: str,
+    is_default: bool | None = None,
 ) -> None:
     base_url_default = defaults.get("base_url", default_base_url) if defaults else default_base_url
     model_default = defaults.get("model", "") if defaults else ""
@@ -251,6 +274,7 @@ def _prompt_and_save_provider(
             model=model,
             timeout=timeout,
             api_key=api_key if api_key else None,
+            is_default=is_default,
         )
     except ValueError as e:
         typer.echo(f"Invalid provider: {e}")
@@ -274,8 +298,48 @@ def _set_llm_delete(svc: ConfigService, existing: list[str]) -> None:
     ).ask()
     if not confirm:
         raise typer.Exit(1)
+    prior_default = svc.get_default_llm_provider()
     svc.delete_llm_provider(name)
     typer.echo(f"✔ Deleted LLM provider {name!r}")
+    new_default = svc.get_default_llm_provider()
+    if prior_default == name and new_default is not None:
+        typer.echo(f"✔ Default LLM provider auto-switched to {new_default!r}")
+
+
+@app.command("set-default-llm")
+def cmd_set_default_llm(
+    name: str = typer.Argument(..., help="Provider name to mark as default."),
+) -> None:
+    """Mark ``name`` as the default LLM provider.
+
+    The default is consumed by ``LLMManager.get_client()`` when callers
+    don't name a provider (non-debate plugin path). Switching default
+    clears the flag on every other provider so the
+    "exactly-one-default" invariant holds.
+    """
+    db, svc = _open_service()
+    try:
+        cfg = svc.get_app_config()
+        provider = cfg.llm_providers.get(name)
+        if provider is None:
+            typer.echo(
+                f"Unknown LLM provider: {name!r}; configured providers: "
+                + (", ".join(sorted(cfg.llm_providers.keys())) or "(none)")
+            )
+            raise typer.Exit(2)
+        if provider.is_default:
+            typer.echo(f"{name!r} is already the default LLM provider")
+            return
+        svc.set_llm_provider(
+            name,
+            base_url=provider.base_url,
+            model=provider.model,
+            timeout=provider.timeout,
+            is_default=True,
+        )
+        typer.echo(f"✔ Default LLM provider set to {name!r}")
+    finally:
+        db.close()
 
 
 @app.command("list-llm")

deeptrade_quant-0.1.0/deeptrade/cli_plugin.py

@@ -0,0 +1,330 @@
+"""`deeptrade plugin` subcommand group."""
+
+from __future__ import annotations
+
+import questionary
+import typer
+import yaml
+from rich.console import Console
+from rich.table import Table
+
+from deeptrade.core import paths
+from deeptrade.core.db import Database
+from deeptrade.core.github_fetch import (
+    GitHubFetchError,
+    NoMatchingReleaseError,
+    TarballFetchError,
+)
+from deeptrade.core.plugin_manager import (
+    PluginInstallError,
+    PluginManager,
+    PluginNotFoundError,
+    UpgradeNoop,
+    _load_metadata_yaml,
+    summarize_for_install,
+)
+from deeptrade.core.plugin_source import (
+    ResolvedSource,
+    SourceResolveError,
+    SourceResolver,
+)
+from deeptrade.core.registry import (
+    RegistryClient,
+    RegistryFetchError,
+    RegistryNotFoundError,
+    RegistrySchemaError,
+)
+
+app = typer.Typer(help="Install / manage plugins", no_args_is_help=True)
+
+_RESOLVE_ERRORS: tuple[type[Exception], ...] = (
+    RegistryNotFoundError,
+    RegistryFetchError,
+    RegistrySchemaError,
+    NoMatchingReleaseError,
+    TarballFetchError,
+    GitHubFetchError,
+    SourceResolveError,
+)
+
+
+def _open() -> tuple[Database, PluginManager]:
+    db = Database(paths.db_path())
+    return db, PluginManager(db)
+
+
+def _format_origin(resolved: ResolvedSource) -> str:
+    d = resolved.origin_detail
+    if resolved.origin == "local":
+        return f"本地路径 ({d.get('local_path', resolved.path)})"
+    if resolved.origin == "github_registry":
+        return (
+            f"GitHub 注册表 ({d['repo']}@{d['ref']}, subdir={d['subdir']})"
+        )
+    if resolved.origin == "github_url":
+        return f"GitHub URL ({d['repo']}@{d['ref']})"
+    return resolved.origin
+
+
+@app.command("install")
+def cmd_install(
+    source: str = typer.Argument(
+        ..., help="短名（注册表）/ 本地路径 / GitHub URL"
+    ),
+    ref: str | None = typer.Option(
+        None, "--ref", help="Tag / branch / sha (默认 = 该插件最新 release)"
+    ),
+    yes: bool = typer.Option(False, "-y", "--yes", help="Skip the confirmation prompt"),
+) -> None:
+    """Install a plugin from the registry, a GitHub URL, or a local directory."""
+    resolver = SourceResolver()
+    try:
+        resolved = resolver.resolve(source, ref)
+    except _RESOLVE_ERRORS as e:
+        typer.echo(f"✘ {e}")
+        raise typer.Exit(2) from e
+
+    try:
+        try:
+            meta = _load_metadata_yaml(resolved.path / "deeptrade_plugin.yaml")
+        except PluginInstallError as e:
+            typer.echo(f"✘ {e}")
+            raise typer.Exit(2) from e
+
+        typer.echo("─── 即将安装 ─────────────────────────────")
+        typer.echo(f"来源: {_format_origin(resolved)}")
+        typer.echo(summarize_for_install(meta, resolved.path))
+        typer.echo("──────────────────────────────────────────")
+        if not yes:
+            ok = questionary.confirm("确认安装?", default=False).ask()
+            if not ok:
+                typer.echo("Aborted.")
+                raise typer.Exit(1)
+
+        db, mgr = _open()
+        try:
+            rec = mgr.install(resolved.path)
+        except PluginInstallError as e:
+            typer.echo(f"✘ Install failed: {e}")
+            raise typer.Exit(2) from e
+        finally:
+            db.close()
+
+        typer.echo(f"✔ 已安装: {rec.plugin_id} v{rec.version}")
+    finally:
+        if resolved.cleanup is not None:
+            resolved.cleanup()
+
+
+@app.command("list")
+def cmd_list() -> None:
+    """List installed plugins."""
+    db, mgr = _open()
+    try:
+        records = mgr.list_all()
+    finally:
+        db.close()
+
+    console = Console()
+    table = Table(title="Installed Plugins")
+    table.add_column("plugin_id", style="cyan")
+    table.add_column("name")
+    table.add_column("version")
+    table.add_column("enabled", style="green")
+    if not records:
+        typer.echo("(no plugins installed)")
+        return
+    for r in records:
+        table.add_row(r.plugin_id, r.name, r.version, "yes" if r.enabled else "no")
+    console.print(table)
+
+
+@app.command("info")
+def cmd_info(plugin_id: str = typer.Argument(...)) -> None:
+    """Show metadata for a plugin.
+
+    If installed locally: shows the full installed metadata.yaml.
+    If not installed: falls back to the registry entry (with an install hint).
+    """
+    db, mgr = _open()
+    try:
+        try:
+            rec = mgr.info(plugin_id)
+            typer.echo(
+                yaml.safe_dump(rec.metadata.model_dump(mode="json"), allow_unicode=True)
+            )
+            return
+        except PluginNotFoundError:
+            pass  # fall through to registry lookup
+    finally:
+        db.close()
+
+    try:
+        entry = RegistryClient().resolve(plugin_id)
+    except RegistryNotFoundError as e:
+        typer.echo(f"✘ {plugin_id} 既未安装，也不在注册表中")
+        raise typer.Exit(2) from e
+    except (RegistryFetchError, RegistrySchemaError) as e:
+        typer.echo(f"✘ {plugin_id} 未安装；查询注册表失败: {e}")
+        raise typer.Exit(2) from e
+
+    typer.echo(f"(未安装) {entry.plugin_id}")
+    typer.echo(f"  name:        {entry.name}")
+    typer.echo(f"  type:        {entry.type}")
+    typer.echo(f"  description: {entry.description}")
+    typer.echo(f"  repo:        {entry.repo}")
+    typer.echo(f"  subdir:      {entry.subdir}")
+    typer.echo(f"  install:     deeptrade plugin install {entry.plugin_id}")
+
+
+@app.command("disable")
+def cmd_disable(plugin_id: str = typer.Argument(...)) -> None:
+    db, mgr = _open()
+    try:
+        try:
+            mgr.disable(plugin_id)
+        except PluginNotFoundError as e:
+            typer.echo(f"✘ {plugin_id} not installed")
+            raise typer.Exit(2) from e
+        typer.echo(f"✔ disabled: {plugin_id}")
+    finally:
+        db.close()
+
+
+@app.command("enable")
+def cmd_enable(plugin_id: str = typer.Argument(...)) -> None:
+    db, mgr = _open()
+    try:
+        try:
+            mgr.enable(plugin_id)
+        except PluginNotFoundError as e:
+            typer.echo(f"✘ {plugin_id} not installed")
+            raise typer.Exit(2) from e
+        typer.echo(f"✔ enabled: {plugin_id}")
+    finally:
+        db.close()
+
+
+@app.command("uninstall")
+def cmd_uninstall(
+    plugin_id: str = typer.Argument(...),
+    purge: bool = typer.Option(False, "--purge", help="DROP plugin tables and forget all data"),
+    yes: bool = typer.Option(False, "-y", "--yes", help="Skip confirmation"),
+) -> None:
+    """Uninstall a plugin. Default: keep tables (just disable). --purge: drop tables."""
+    db, mgr = _open()
+    try:
+        try:
+            rec = mgr.info(plugin_id)
+        except PluginNotFoundError as e:
+            typer.echo(f"✘ {plugin_id} not installed")
+            raise typer.Exit(2) from e
+
+        if purge and not yes:
+            tables = [t.name for t in rec.metadata.tables if t.purge_on_uninstall]
+            typer.echo(f"将删除以下表（不可恢复）: {tables}")
+            ok = questionary.confirm("确认 --purge?", default=False).ask()
+            if not ok:
+                typer.echo("Aborted.")
+                raise typer.Exit(1)
+
+        result = mgr.uninstall(plugin_id, purge=purge)
+        action = "purged" if purge else "disabled"
+        typer.echo(f"✔ {action}: {plugin_id} (dropped tables: {result['purged_tables']})")
+    finally:
+        db.close()
+
+
+@app.command("upgrade")
+def cmd_upgrade(
+    source: str = typer.Argument(
+        ..., help="短名（注册表）/ 本地路径 / GitHub URL"
+    ),
+    ref: str | None = typer.Option(
+        None, "--ref", help="Tag / branch / sha (默认 = 该插件最新 release)"
+    ),
+) -> None:
+    """Upgrade an installed plugin.
+
+    Exit codes:
+      0 — upgraded, or already at the candidate version
+      2 — not installed / candidate < installed (downgrade forbidden) /
+          network or registry failure
+    """
+    resolver = SourceResolver()
+    try:
+        resolved = resolver.resolve(source, ref)
+    except _RESOLVE_ERRORS as e:
+        typer.echo(f"✘ {e}")
+        raise typer.Exit(2) from e
+
+    try:
+        db, mgr = _open()
+        try:
+            try:
+                result = mgr.upgrade(resolved.path)
+            except PluginNotFoundError as e:
+                try:
+                    meta = _load_metadata_yaml(resolved.path / "deeptrade_plugin.yaml")
+                    pid = meta.plugin_id
+                except PluginInstallError:
+                    pid = source
+                typer.echo(
+                    f'✘ 插件 "{pid}" 未安装，请先执行 deeptrade plugin install'
+                )
+                raise typer.Exit(2) from e
+            except PluginInstallError as e:
+                typer.echo(f"✘ Upgrade failed: {e}")
+                raise typer.Exit(2) from e
+
+            if isinstance(result, UpgradeNoop):
+                typer.echo(f"已是最新版本 v{result.version}")
+                return
+            typer.echo(f"✔ upgraded: {result.plugin_id} → v{result.version}")
+        finally:
+            db.close()
+    finally:
+        if resolved.cleanup is not None:
+            resolved.cleanup()
+
+
+@app.command("search")
+def cmd_search(
+    keyword: str | None = typer.Argument(
+        None, help="可选过滤关键词（匹配 plugin_id / name / description）"
+    ),
+    no_cache: bool = typer.Option(
+        False, "--no-cache", help="强制刷新注册表（旁路 ETag 缓存）"
+    ),
+) -> None:
+    """List plugins available in the official registry."""
+    try:
+        registry = RegistryClient().fetch(force=no_cache)
+    except (RegistryFetchError, RegistrySchemaError) as e:
+        typer.echo(f"✘ {e}")
+        raise typer.Exit(2) from e
+
+    rows = list(registry.plugins.values())
+    if keyword:
+        kw = keyword.lower()
+        rows = [
+            entry
+            for entry in rows
+            if kw in entry.plugin_id.lower()
+            or kw in entry.name.lower()
+            or kw in entry.description.lower()
+        ]
+
+    if not rows:
+        typer.echo("(no plugins matched)" if keyword else "(registry is empty)")
+        return
+
+    console = Console()
+    table = Table(title="Available Plugins")
+    table.add_column("plugin_id", style="cyan")
+    table.add_column("name")
+    table.add_column("type", style="green")
+    table.add_column("description")
+    for entry in sorted(rows, key=lambda x: x.plugin_id):
+        table.add_row(entry.plugin_id, entry.name, entry.type, entry.description)
+    console.print(table)

{deeptrade_quant-0.0.2 → deeptrade_quant-0.1.0}/deeptrade/core/config.py

@@ -51,12 +51,20 @@ class LLMProviderConfig(BaseModel):
 
     The api_key is NOT stored here; it lives in ``secret_store`` under the
     key ``llm.<name>.api_key`` and is routed via ``is_secret_key()``.
+
+    ``is_default`` marks the provider used by ``LLMManager.get_client()``
+    when the caller does not name a provider (non-debate plugin path).
+    Invariant: while ``llm_providers`` is non-empty, exactly one entry
+    has ``is_default=True``. ``ConfigService.set_llm_provider`` /
+    ``delete_llm_provider`` maintain this invariant; legacy configs are
+    repaired by ``config_migrations``.
     """
 
     model_config = ConfigDict(extra="forbid")
     base_url: str
     model: str
     timeout: int = Field(default=180, ge=10)
+    is_default: bool = False
 
 
 class AppConfig(BaseModel):
@@ -317,9 +325,23 @@ class ConfigService:
         model: str,
         timeout: int = 180,
         api_key: str | None = None,
+        is_default: bool | None = None,
     ) -> None:
         """Insert or update a provider entry. If ``api_key`` is given, also
         persist it to secret_store under ``llm.<name>.api_key``.
+
+        Default-provider invariant (one entry has ``is_default=True`` while
+        ``llm.providers`` is non-empty) is maintained here:
+
+          * Adding the first provider auto-marks it default regardless of
+            the ``is_default`` argument.
+          * ``is_default=True`` on a non-first add or update promotes this
+            provider and clears the flag on every other entry.
+          * ``is_default=None`` on update preserves the existing flag (no
+            silent demotion); on a non-first add it defaults to False.
+          * ``is_default=False`` is honored only when another provider
+            already holds the default flag — never used to leave the dict
+            with zero defaults.
         """
         if not name or "." in name:
             raise ValueError(
@@ -327,18 +349,79 @@ class ConfigService:
             )
         current_raw = self.get("llm.providers")
         current: dict[str, Any] = dict(current_raw) if isinstance(current_raw, dict) else {}
-        current[name] = {"base_url": base_url, "model": model, "timeout": timeout}
+        is_first = len(current) == 0
+        existing = dict(current.get(name) or {})
+        prior_default = bool(existing.get("is_default", False))
+
+        # Resolve the new is_default flag for this provider.
+        if is_first:
+            new_default = True
+        elif is_default is True:
+            new_default = True
+        elif is_default is None:
+            new_default = prior_default
+        else:  # is_default is False
+            # Only honor an explicit demotion if some other provider is
+            # already default; otherwise we'd leave the dict with no
+            # default at all. Preserve prior_default in that case.
+            other_has_default = any(
+                k != name and bool((v or {}).get("is_default"))
+                for k, v in current.items()
+            )
+            new_default = prior_default if not other_has_default else False
+
+        # If this provider is becoming default, demote every other entry so
+        # the invariant "at most one default" holds.
+        if new_default:
+            for other_name, other_cfg in current.items():
+                if other_name != name and isinstance(other_cfg, dict) and other_cfg.get("is_default"):
+                    current[other_name] = {**other_cfg, "is_default": False}
+
+        current[name] = {
+            "base_url": base_url,
+            "model": model,
+            "timeout": timeout,
+            "is_default": new_default,
+        }
         self.set("llm.providers", current)
         if api_key is not None:
             self.set(f"llm.{name}.api_key", api_key)
 
     def delete_llm_provider(self, name: str) -> None:
-        """Remove a provider entry plus its api_key. Idempotent on missing name."""
+        """Remove a provider entry plus its api_key. Idempotent on missing name.
+
+        If the removed provider held ``is_default=True`` and ≥1 entry
+        survives, the first remaining entry (insertion order) is auto-
+        promoted to default to maintain the invariant.
+        """
         current_raw = self.get("llm.providers")
         current: dict[str, Any] = dict(current_raw) if isinstance(current_raw, dict) else {}
-        current.pop(name, None)
+        removed = current.pop(name, None)
+        removed_was_default = bool(isinstance(removed, dict) and removed.get("is_default"))
+
+        if removed_was_default and current:
+            first_key = next(iter(current.keys()))
+            first_cfg = current[first_key]
+            if isinstance(first_cfg, dict):
+                current[first_key] = {**first_cfg, "is_default": True}
+
         if current:
             self.set("llm.providers", current)
         else:
             self.delete("llm.providers")
         self.delete(f"llm.{name}.api_key")
+
+    def get_default_llm_provider(self) -> str | None:
+        """Return the name of the provider with ``is_default=True``, or None
+        if no providers are configured.
+
+        Used by :class:`LLMManager.get_client` to resolve ``name=None`` calls
+        from non-debate plugins. Not exposed as a CLI; the CLI sets the
+        default via ``set-default-llm`` which routes through
+        :meth:`set_llm_provider`.
+        """
+        cfg = self.get_app_config()
+        for provider_name, provider in cfg.llm_providers.items():
+            if provider.is_default:
+                return provider_name
+        return None