aria-code 0.167.0__py3-none-win_amd64.whl

aria_code/apps/cli/cloud_models.py

@@ -0,0 +1,231 @@
+"""The models each cloud provider offers, read from the provider itself.
+
+`/model` used to list Aria's own catalogue and, for a cloud provider, only the
+model already selected: a hand-kept list is out of date within weeks (Google
+retired Gemini 3.5 Flash a month after this catalogue called it stable). So for
+every provider with a key, the model list endpoint is asked what it serves now.
+
+The answer is cached for a few hours. An expired cache is shown straight away
+and refreshed behind it, so opening the picker never waits on a slow provider;
+only a provider with no cache at all is waited for, and only for a few seconds.
+Offline, or when a provider is down, the cache (however old) is used, and a
+provider with neither simply has no section.
+
+Keys are used for the request and never written to the cache.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+import threading
+import time
+import urllib.error
+import urllib.request
+from concurrent.futures import ThreadPoolExecutor
+from pathlib import Path
+from typing import Callable, Dict, List, Optional
+
+CACHE_TTL_S = 6 * 3600
+FETCH_TIMEOUT_S = 4.0
+MAX_PER_PROVIDER = 60
+
+#: provider -> (heading, kind, models URL). The URL for Google carries the key
+#: as a header, not in the query string.
+PROVIDERS: Dict[str, tuple] = {
+    "google": ("Google Gemini", "google", "https://generativelanguage.googleapis.com/v1beta/models?pageSize=200"),
+    "openai": ("OpenAI", "openai", "https://api.openai.com/v1/models"),
+    "anthropic": ("Anthropic Claude", "anthropic", "https://api.anthropic.com/v1/models?limit=100"),
+    "deepseek": ("DeepSeek", "openai", "https://api.deepseek.com/models"),
+    "groq": ("Groq", "openai", "https://api.groq.com/openai/v1/models"),
+    "together": ("Together AI", "openai", "https://api.together.xyz/v1/models"),
+    "dashscope": ("Alibaba DashScope", "openai", "https://dashscope.aliyuncs.com/compatible-mode/v1/models"),
+    "siliconflow": ("SiliconFlow", "openai", "https://api.siliconflow.cn/v1/models"),
+    "moonshot": ("Moonshot", "openai", "https://api.moonshot.cn/v1/models"),
+    "zhipu": ("Zhipu GLM", "openai", "https://open.bigmodel.cn/api/paas/v4/models"),
+}
+
+#: Not chat models: embeddings, speech, images, video, music, moderation, live audio.
+_NOT_CHAT = re.compile(
+    r"embed|whisper|tts|transcribe|speech|audio|realtime|dall-e|image|imagen|veo|lyria|"
+    r"omni-|nano-banana|moderation|rerank|guard|-live|robotics|computer-use|sora|deep-research|"
+    r"search-preview|davinci|babbage|aqa|text-bison|vision-preview",
+    re.IGNORECASE,
+)
+
+_refreshing: set = set()
+_lock = threading.Lock()
+
+
+def cache_dir() -> Path:
+    from aria_code.packages.aria_core.paths import aria_home
+
+    return Path(aria_home()) / "cloud_models"
+
+
+def _http_json(url: str, headers: Dict[str, str], timeout: float) -> object:
+    request = urllib.request.Request(url, headers={"User-Agent": "aria-code", "Accept": "application/json", **headers})
+    with urllib.request.urlopen(request, timeout=timeout) as response:  # noqa: S310 - fixed https endpoints above
+        return json.load(response)
+
+
+def _natural_key(text: str):
+    """Sort key where 3.10 follows 3.9 and a higher version sorts later."""
+    return [int(part) if part.isdigit() else part for part in re.split(r"(\d+)", text.lower())]
+
+
+def _ctx_label(tokens) -> str:
+    try:
+        n = int(tokens)
+    except (TypeError, ValueError):
+        return ""
+    if n >= 900_000:
+        return f"ctx {round(n / 1_048_576)}M"
+    return f"ctx {n // 1000}K" if n >= 1000 else ""
+
+
+def _date(epoch: int) -> str:
+    import datetime
+
+    try:
+        return datetime.date.fromtimestamp(epoch).isoformat()
+    except (OverflowError, OSError, ValueError):
+        return ""
+
+
+def _is_shut_down(value: object, today: Optional[float] = None) -> bool:
+    """True when a provider's `shutdown_date` (epoch seconds or ISO date) has passed."""
+    now = time.time() if today is None else today
+    if isinstance(value, (int, float)) and value > 0:
+        return float(value) < now
+    if isinstance(value, str) and value:
+        import datetime
+
+        try:
+            return datetime.date.fromisoformat(value[:10]) < datetime.date.fromtimestamp(now)
+        except ValueError:
+            return False
+    return False
+
+
+def parse(provider: str, payload: object) -> List[dict]:
+    """The chat models in a provider's list response, newest first: [{id, name, detail}]."""
+    kind = PROVIDERS[provider][1]
+    rows: List[dict] = []
+    if kind == "google":
+        for item in (payload or {}).get("models", []) if isinstance(payload, dict) else []:
+            methods = item.get("supportedGenerationMethods") or []
+            ident = str(item.get("name", "")).removeprefix("models/")
+            if "generateContent" not in methods or not ident or _NOT_CHAT.search(ident):
+                continue
+            detail = " · ".join(x for x in (_ctx_label(item.get("inputTokenLimit")),) if x)
+            rows.append({"id": ident, "name": item.get("displayName") or ident, "detail": detail})
+    elif kind == "anthropic":
+        for item in (payload or {}).get("data", []) if isinstance(payload, dict) else []:
+            ident = str(item.get("id", ""))
+            if ident:
+                rows.append({"id": ident, "name": item.get("display_name") or ident, "detail": ""})
+    else:
+        items = payload.get("data", []) if isinstance(payload, dict) else payload
+        for item in items if isinstance(items, list) else []:
+            ident = str(item.get("id", "")) if isinstance(item, dict) else ""
+            if not ident or _NOT_CHAT.search(ident) or _is_shut_down(item.get("shutdown_date")):
+                continue
+            created = item.get("created")
+            created = int(created) if isinstance(created, (int, float)) and created > 0 else 0
+            detail = _date(created) if created else ""
+            rows.append({"id": ident, "name": ident, "detail": detail, "created": created})
+    # Newest first by the provider's own creation date where it gives one (OpenAI does);
+    # otherwise by version number in the id, which is only a rough proxy.
+    rows.sort(key=lambda r: (r.get("created", 0), _natural_key(r["id"])), reverse=True)
+    return [{k: v for k, v in r.items() if k != "created"} for r in rows[:MAX_PER_PROVIDER]]
+
+
+def fetch(provider: str, key: str, timeout: float = FETCH_TIMEOUT_S) -> Optional[List[dict]]:
+    """Ask the provider; None when it cannot be reached or refuses the key."""
+    _heading, kind, url = PROVIDERS[provider]
+    if kind == "google":
+        headers = {"x-goog-api-key": key}
+    elif kind == "anthropic":
+        headers = {"x-api-key": key, "anthropic-version": "2023-06-01"}
+    else:
+        headers = {"Authorization": f"Bearer {key}"}
+    try:
+        return parse(provider, _http_json(url, headers, timeout))
+    except (OSError, urllib.error.URLError, ValueError):
+        return None
+
+
+def _read_cache(provider: str) -> Optional[dict]:
+    try:
+        data = json.loads((cache_dir() / f"{provider}.json").read_text(encoding="utf-8"))
+        if isinstance(data.get("models"), list):
+            return data
+    except (OSError, ValueError):
+        pass
+    return None
+
+
+def _write_cache(provider: str, models: List[dict], now: float) -> None:
+    try:
+        directory = cache_dir()
+        directory.mkdir(parents=True, exist_ok=True)
+        (directory / f"{provider}.json").write_text(json.dumps({"at": now, "models": models}), encoding="utf-8")
+    except OSError:
+        pass
+
+
+def _refresh_later(provider: str, key: str) -> None:
+    with _lock:
+        if provider in _refreshing:
+            return
+        _refreshing.add(provider)
+
+    def run() -> None:
+        try:
+            models = fetch(provider, key)
+            if models:
+                _write_cache(provider, models, time.time())
+        finally:
+            with _lock:
+                _refreshing.discard(provider)
+
+    threading.Thread(target=run, daemon=True, name=f"aria-models-{provider}").start()
+
+
+def models_for(provider: str, key: str, *, offline: bool = False, now: Optional[float] = None) -> List[dict]:
+    """The provider's models: fresh cache, else stale cache (refreshed behind), else a live request."""
+    stamp = time.time() if now is None else now
+    cached = _read_cache(provider)
+    if cached and (offline or stamp - float(cached.get("at", 0)) < CACHE_TTL_S):
+        return cached["models"]
+    if cached:
+        _refresh_later(provider, key)
+        return cached["models"]
+    if offline:
+        return []
+    models = fetch(provider, key)
+    if models:
+        _write_cache(provider, models, stamp)
+    return models or []
+
+
+def collect(key_for: Callable[[str], str], *, offline: Optional[bool] = None) -> Dict[str, List[dict]]:
+    """Models for every provider that has a key, looked up in parallel: {provider: [models]}."""
+    if offline is None:
+        offline = os.environ.get("ARIA_OFFLINE", "").lower() in {"1", "true", "yes", "on"}
+    keyed = {p: key for p in PROVIDERS if (key := key_for(p))}
+    if not keyed:
+        return {}
+    with ThreadPoolExecutor(max_workers=min(8, len(keyed))) as pool:
+        futures = {p: pool.submit(models_for, p, key, offline=offline) for p, key in keyed.items()}
+        out = {}
+        for provider, future in futures.items():
+            try:
+                models = future.result(timeout=FETCH_TIMEOUT_S + 2)
+            except Exception:
+                models = []
+            if models:
+                out[provider] = models
+    return out

aria_code/apps/cli/codegen_paths.py

@@ -0,0 +1,29 @@
+"""Path helpers for generated code and strategy artifacts."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+
+def resolve_user_code_path(
+    description: str,
+    save_path: str | None = None,
+    *,
+    user_generated_dir: Path,
+) -> Path:
+    """Resolve a code output path into the user's generated workspace."""
+    from artifacts import slugify_topic
+
+    if save_path:
+        p = Path(save_path).expanduser()
+        if not p.is_absolute():
+            p = user_generated_dir / p
+        if p.suffix != ".py":
+            p = p.with_suffix(".py")
+        return p
+
+    desc_slug = slugify_topic(description, fallback="generated_code")
+    if any(k in description.lower() for k in ("backtest", "strategy", "quant", "portfolio")):
+        desc_slug = f"strategy_{desc_slug}"
+    return user_generated_dir / f"{desc_slug}.py"
+

aria_code/apps/cli/commands/__init__.py

@@ -0,0 +1,34 @@
+"""CLI command adapters, imported only when used.
+
+Importing a lightweight command such as /architecture must not initialize the
+finance stack (pandas/numpy) through this package's __init__.
+"""
+
+from importlib import import_module
+
+__all__ = [
+    "BrokerCommandsMixin",
+    "BacktestCommandsMixin",
+    "WorkspaceCommandsMixin",
+    "ModelCommandsMixin",
+    "MarketCommandsMixin",
+    "PortfolioCommandsMixin",
+]
+
+_MIXIN_MODULES = {
+    "BrokerCommandsMixin": "broker_cmds",
+    "BacktestCommandsMixin": "backtest_cmds",
+    "WorkspaceCommandsMixin": "workspace_cmds",
+    "ModelCommandsMixin": "model_cmds",
+    "MarketCommandsMixin": "market_cmds",
+    "PortfolioCommandsMixin": "portfolio_cmds",
+}
+
+
+def __getattr__(name: str):
+    module_name = _MIXIN_MODULES.get(name)
+    if module_name is None:
+        raise AttributeError(name)
+    value = getattr(import_module(f".{module_name}", __name__), name)
+    globals()[name] = value
+    return value

aria_code/apps/cli/commands/_business_render.py

@@ -0,0 +1,78 @@
+"""Business-workflow renderers, taking the context instead of aria_cli's globals.
+
+These three drew through aria_cli's module-level ``console`` and ``HAS_RICH``,
+so business_workflow_cmds reached into a 7000-line module for three functions
+totalling 56 lines. The state they need is on ``self.context`` already — the
+same move print_error made in _ui.py.
+
+Names lost their leading underscore on the way over: they are this module's
+public surface now, not aria_cli privates borrowed by bare name.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+__all__ = ["p", "print_realty_result", "print_risk_scan"]
+
+
+def p(context, msg: str, style: str = ""):
+    """快速打印辅助（rich 可用时带样式）"""
+    if context.has_rich:
+        tag = {"dim": "dim", "error": "red", "ok": "green"}.get(style, style)
+        context.console.print(f"[{tag}]{msg}[/{tag}]" if tag else msg)
+    else:
+        print(msg)
+
+
+def print_realty_result(context, result, agent_name: str):
+    """格式化打印 realty Agent 结果（地产健康度词汇，见 agents/signal_scheme.py::REALTY_SCHEME）"""
+    _SIGNAL_LABELS = {
+        "GOOD": "[green]正常/推荐[/green]",
+        "WATCH": "[yellow]需观察[/yellow]",
+        "CONCERN": "[red]警示[/red]",
+        "SEVERE": "[bold red]极高风险[/bold red]",
+    }
+    if not context.has_rich:
+        print(f"\n[{agent_name}] Signal: {result.signal}  Confidence: {result.confidence:.0%}")
+        print(result.analysis)
+        return
+
+    context.console.print()
+    context.console.print(f"  [bold]{agent_name.upper().replace('_',' ')}[/bold]"
+                  f"  {_SIGNAL_LABELS.get(result.signal, result.signal)}"
+                  f"  [dim]置信度 {result.confidence:.0%}[/dim]")
+    context.console.print()
+    for pt in (result.key_points or []):
+        context.console.print(f"    • {pt}")
+    if result.analysis:
+        context.console.print()
+        text = result.analysis[:1200] + ("…" if len(result.analysis) > 1200 else "")
+        context.console.print(f"  [dim]{text}[/dim]")
+    context.console.print()
+
+
+def print_risk_scan(context, data: dict):
+    """格式化打印风险扫描结果"""
+    if not context.has_rich:
+        print(f"Risk scan: {data.get('overall_level','?')} "
+              f"(score={data.get('risk_score',0)})")
+        for alert in data.get("alerts", []):
+            print(f"  [{alert['level']}] {alert['desc']}")
+        return
+
+    level = data.get("overall_level", "未知")
+    score = data.get("risk_score", 0)
+    color = {"低": "green", "中": "yellow", "高": "red", "极高": "bold red"}.get(level, "white")
+    context.console.print()
+    context.console.print(f"  风险等级: [{color}]{level}[/{color}]  "
+                  f"风险分值: {score}  "
+                  f"预警项: {data.get('alert_count',0)}")
+    context.console.print()
+    for alert in data.get("alerts", []):
+        ac = {"低": "dim", "中": "yellow", "高": "red", "极高": "bold red"}.get(
+            alert["level"], "white")
+        context.console.print(f"    [{ac}][{alert['level']}][/{ac}] {alert['desc']}")
+    if data.get("suggestion"):
+        context.console.print(f"\n  [dim]建议: {data['suggestion']}[/dim]")
+    context.console.print()

aria_code/apps/cli/commands/_ui.py

@@ -0,0 +1,71 @@
+"""Rendering helpers for the command mixins.
+
+Two different things used to come from aria_cli's module globals, and only one
+of them was ever state:
+
+* ``console`` / ``HAS_RICH`` are per-session state. They belong on
+  ``self.context`` — which 40f23c8 started and this package is finishing.
+* ``rich_box`` and ``Panel`` are not state at all. They are ``rich.box`` and
+  ``rich.panel.Panel``, sitting behind aria_cli's guarded import purely because
+  that is where the try/except happened to live. Reaching into a 7000-line
+  module for them bought nothing, so they are resolved here instead.
+
+``print_error`` takes the context explicitly rather than reading a global, so a
+mixin can render without knowing anything about aria_cli.
+"""
+
+from __future__ import annotations
+
+from contextlib import contextmanager
+from typing import Any
+
+__all__ = ["Panel", "Syntax", "null_ctx", "print_error", "rich_box", "has_rich"]
+
+try:  # Optional: the CLI degrades to plain print when rich is absent.
+    from rich import box as rich_box
+    from rich.panel import Panel
+    from rich.syntax import Syntax
+except ImportError:  # pragma: no cover - exercised only without rich installed
+    rich_box = None  # type: ignore[assignment]
+    Panel = None  # type: ignore[assignment]
+    Syntax = None  # type: ignore[assignment]
+
+
+@contextmanager
+def null_ctx():
+    """No-op context manager, for `with x if cond else null_ctx():`.
+
+    Three lines with no dependencies, defined in aria_cli only because that is
+    where the first caller was. Note the *theme* these renderers use
+    (_SYNTAX_THEME) is deliberately not here: it is read from user config and
+    changes with /theme, so it is session state and belongs on the context.
+    """
+    yield
+
+
+def has_rich() -> bool:
+    """Whether rich is importable.
+
+    For module-level helpers that have no ``self`` and so cannot read
+    ``self.context.has_rich``. Anything with a context should use that instead —
+    a session can be configured without a console even where rich is installed.
+    """
+    return rich_box is not None
+
+
+def print_error(context: Any, msg: str, hint: str = "") -> None:
+    """Render an error through the context's console.
+
+    ``context`` is an AriaContext, or anything exposing ``console`` and
+    ``has_rich``; the renderer already falls back to plain print when console is
+    None, so a context built without one still works.
+    """
+    from aria_code.ui.render.output import print_error as _render
+
+    _render(
+        msg,
+        hint,
+        console=getattr(context, "console", None),
+        has_rich=bool(getattr(context, "has_rich", False)),
+        rich_box=rich_box,
+    )