alpha-visualizer 0.1.0__py3-none-any.whl

alpha_visualizer/routers/results.py

@@ -0,0 +1,352 @@
+"""バックテスト結果 API ルーター
+
+`/api/results` (一覧) と `/api/results/{run_id}` (詳細) を提供する。
+詳細レスポンスはフロントエンド（visualizer/）の BacktestDetail 型と一致するよう整形済み。
+"""
+from __future__ import annotations
+
+import json
+import logging
+import math
+from datetime import datetime
+from typing import Any
+
+from fastapi import APIRouter, HTTPException, Query, Request
+from sqlalchemy import create_engine, select
+
+from alpha_visualizer.db import backtest_results
+from alpha_visualizer.forge_config import ForgeConfig
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter()
+
+_MONTHS = list(range(1, 13))
+
+
+def _parse_dt(s: str) -> datetime:
+    return datetime.fromisoformat(s.replace("Z", "+00:00")).replace(tzinfo=None)
+
+
+def _shape_monthly_returns(raw: dict[str, float] | None) -> dict[int, list[float | None]]:
+    if not raw:
+        return {}
+    by_year: dict[int, list[float | None]] = {}
+    for ym, pct in raw.items():
+        try:
+            year_str, month_str = ym.split("-", 1)
+            year = int(year_str)
+            month = int(month_str)
+        except (ValueError, AttributeError):
+            continue
+        if month < 1 or month > 12:
+            continue
+        bucket = by_year.setdefault(year, [None] * 12)
+        bucket[month - 1] = float(pct) if pct is not None else None
+    return by_year
+
+
+def _shape_trades(
+    raw_trades: list[dict[str, Any]] | None,
+    trade_analysis: dict[str, Any] | None,
+) -> list[dict[str, Any]]:
+    if not raw_trades:
+        return []
+    mae_list: list[float] = list(trade_analysis.get("per_trade_mae_pct", [])) if trade_analysis else []
+    mfe_list: list[float] = list(trade_analysis.get("per_trade_mfe_pct", [])) if trade_analysis else []
+    out: list[dict[str, Any]] = []
+    for i, t in enumerate(raw_trades):
+        direction = t.get("direction") or t.get("signal") or "long"
+        return_pct = float(t.get("return_pct") or 0.0)
+        pnl = float(t.get("pnl") or 0.0)
+        out.append(
+            {
+                "id": t.get("id", i),
+                "direction": "long" if str(direction).lower().startswith("long") else "short",
+                "entry_date": t.get("entry_date") or "",
+                "exit_date": t.get("exit_date") or "",
+                "entry_price": float(t.get("entry_price") or 0.0),
+                "return_pct": return_pct,
+                "pnl": pnl,
+                "holding_days": int(t.get("holding_days") or 0),
+                "mae_pct": float(mae_list[i]) if i < len(mae_list) else float(t.get("mae_pct") or 0.0),
+                "mfe_pct": float(mfe_list[i]) if i < len(mfe_list) else float(t.get("mfe_pct") or 0.0),
+            }
+        )
+    return out
+
+
+def _compute_drawdown(values: list[float]) -> list[float]:
+    if not values:
+        return []
+    out: list[float] = []
+    peak = values[0]
+    for v in values:
+        if v > peak:
+            peak = v
+        out.append(0.0 if peak == 0 else (v - peak) / peak * 100.0)
+    return out
+
+
+def _compute_daily_returns(values: list[float]) -> list[float]:
+    if len(values) < 2:
+        return []
+    results: list[float] = []
+    for i in range(1, len(values)):
+        prev = values[i - 1]
+        curr = values[i]
+        if prev == 0.0 or not math.isfinite(prev) or not math.isfinite(curr):
+            results.append(0.0)
+        else:
+            results.append(round((curr - prev) / prev * 100.0, 6))
+    return results
+
+
+def _compute_buy_hold_equity(record: dict[str, Any]) -> list[float]:
+    raw = record.get("buy_hold_curve")
+    if not raw or not isinstance(raw, list):
+        return []
+    try:
+        if isinstance(raw[0], dict):
+            vals = [float(item.get("value", 0.0)) for item in raw]
+        else:
+            vals = [float(v) for v in raw]
+    except (TypeError, ValueError):
+        return []
+    if not vals or vals[0] == 0.0 or not math.isfinite(vals[0]):
+        return []
+    base = vals[0]
+    return [round(v / base * 100.0, 4) if math.isfinite(v) else 0.0 for v in vals]
+
+
+def _shape_equity(raw: list[Any] | None) -> tuple[list[str], list[float]]:
+    if not raw:
+        return [], []
+    dates: list[str] = []
+    values: list[float] = []
+    for item in raw:
+        if isinstance(item, dict):
+            dates.append(str(item.get("date", "")))
+            values.append(float(item.get("value", 0.0)))
+        else:
+            try:
+                values.append(float(item))
+                dates.append("")
+            except (TypeError, ValueError):
+                continue
+    return dates, values
+
+
+def _is_cutoff(dates: list[str], oos_start: str | None) -> dict[str, Any]:
+    if not oos_start or not dates:
+        return {"date": None, "index": -1}
+    target = oos_start[:10] if len(oos_start) >= 10 else oos_start
+    for i, d in enumerate(dates):
+        if d >= target:
+            prev = dates[i - 1] if i > 0 else None
+            return {"date": prev, "index": i}
+    return {"date": dates[-1] if dates else None, "index": len(dates)}
+
+
+def _split_metrics(
+    metrics: dict[str, Any], cutoff_idx: int, total: int
+) -> tuple[dict[str, Any] | None, dict[str, Any] | None]:
+    if cutoff_idx <= 0 or cutoff_idx >= total or not metrics:
+        return None, None
+    is_ratio = cutoff_idx / total
+    oos_ratio = 1.0 - is_ratio
+    period_independent = {"sharpe_ratio", "sortino_ratio", "calmar_ratio", "win_rate_pct", "profit_factor"}
+    is_m: dict[str, Any] = {}
+    oos_m: dict[str, Any] = {}
+    for key in (
+        "total_return_pct", "cagr_pct", "sharpe_ratio", "sortino_ratio", "calmar_ratio",
+        "max_drawdown_pct", "win_rate_pct", "profit_factor", "total_trades",
+    ):
+        v = metrics.get(key)
+        if v is None:
+            continue
+        if key in period_independent:
+            is_m[key] = float(v)
+            oos_m[key] = float(v)
+        elif key == "total_trades":
+            is_m[key] = int(round(float(v) * is_ratio))
+            oos_m[key] = max(int(v) - is_m[key], 0)
+        else:
+            is_m[key] = float(v) * is_ratio
+            oos_m[key] = float(v) * oos_ratio
+    return is_m or None, oos_m or None
+
+
+def _row_to_dict(row: Any) -> dict[str, Any]:
+    """SQLAlchemy Row をフラットな dict に変換する。metrics_json 等を展開する。"""
+    metrics: dict[str, Any] = {}
+    if row.metrics_json:
+        try:
+            metrics = json.loads(row.metrics_json)
+        except (json.JSONDecodeError, TypeError):
+            pass
+
+    equity_curve: list[Any] = []
+    if row.equity_curve_json:
+        try:
+            equity_curve = json.loads(row.equity_curve_json)
+        except (json.JSONDecodeError, TypeError):
+            pass
+
+    buy_hold_curve: list[Any] = []
+    if row.buy_hold_curve_json:
+        try:
+            buy_hold_curve = json.loads(row.buy_hold_curve_json)
+        except (json.JSONDecodeError, TypeError):
+            pass
+
+    trades: list[Any] = []
+    if row.trades_json:
+        try:
+            trades = json.loads(row.trades_json)
+        except (json.JSONDecodeError, TypeError):
+            pass
+
+    # DB のトップレベルカラムを metrics にマージ（元 forge との互換性のため）
+    for col in ("sharpe_ratio", "total_return_pct", "cagr_pct", "sortino_ratio",
+                "calmar_ratio", "max_drawdown_pct", "total_trades", "win_rate_pct",
+                "profit_factor", "avg_holding_days"):
+        val = getattr(row, col, None)
+        if val is not None and col not in metrics:
+            metrics[col] = val
+
+    return {
+        "run_id": row.run_id,
+        "strategy_id": row.strategy_id,
+        "symbol": row.symbol,
+        "run_at": row.run_at,
+        "sharpe_ratio": row.sharpe_ratio,
+        "total_return_pct": row.total_return_pct,
+        "cagr_pct": row.cagr_pct,
+        "max_drawdown_pct": row.max_drawdown_pct,
+        "total_trades": row.total_trades,
+        "oos_start": row.oos_start,
+        "metrics": metrics,
+        "equity_curve": equity_curve,
+        "buy_hold_curve": buy_hold_curve,
+        "trades": trades,
+    }
+
+
+def _shape_detail(record: dict[str, Any]) -> dict[str, Any]:
+    metrics: dict[str, Any] = dict(record.get("metrics") or {})
+    raw_equity = record.get("equity_curve")
+    dates, values = _shape_equity(raw_equity)
+    drawdown = _compute_drawdown(values)
+    cutoff = _is_cutoff(dates, record.get("oos_start"))
+    monthly = _shape_monthly_returns(metrics.get("monthly_returns"))
+    trade_analysis = metrics.get("trade_analysis") or {}
+    trades = _shape_trades(record.get("trades"), trade_analysis)
+    is_m, oos_m = _split_metrics(metrics, cutoff["index"], len(values))
+    period_start = dates[0][:7] if dates else ""
+    period_end = dates[-1][:7] if dates else ""
+
+    return {
+        "run_id": record.get("run_id", ""),
+        "strategy_id": record.get("strategy_id", ""),
+        "strategy_name": record.get("strategy_id", ""),
+        "symbol": record.get("symbol", ""),
+        "timeframe": record.get("timeframe", "1d"),
+        "run_at": record.get("run_at", ""),
+        "period": {"start": period_start, "end": period_end},
+        "equity": {"dates": dates, "values": values},
+        "drawdown": drawdown,
+        "daily_returns": _compute_daily_returns(values),
+        "buy_hold_equity": _compute_buy_hold_equity(record),
+        "is_cutoff": cutoff,
+        "metrics": metrics,
+        "is_metrics": is_m,
+        "oos_metrics": oos_m,
+        "monthly_returns": monthly,
+        "trades": trades,
+    }
+
+
+def _list_results_from_db(
+    config: ForgeConfig,
+    strategy_id: str | None,
+    since: datetime | None,
+) -> list[dict[str, Any]]:
+    db_path = config.forge_db
+    if not db_path.exists():
+        return []
+    engine = create_engine(f"sqlite:///{db_path}", future=True)
+    stmt = select(
+        backtest_results.c.run_id,
+        backtest_results.c.strategy_id,
+        backtest_results.c.symbol,
+        backtest_results.c.run_at,
+        backtest_results.c.sharpe_ratio,
+        backtest_results.c.total_return_pct,
+        backtest_results.c.max_drawdown_pct,
+        backtest_results.c.total_trades,
+    ).order_by(backtest_results.c.run_at.desc())
+    if strategy_id:
+        stmt = stmt.where(backtest_results.c.strategy_id == strategy_id)
+    rows: list[dict[str, Any]] = []
+    with engine.connect() as conn:
+        for r in conn.execute(stmt):
+            if since is not None:
+                try:
+                    if _parse_dt(r.run_at or "") < since:
+                        continue
+                except ValueError:
+                    pass
+            rows.append({
+                "run_id": r.run_id,
+                "strategy_id": r.strategy_id,
+                "symbol": r.symbol,
+                "run_at": r.run_at,
+                "sharpe_ratio": r.sharpe_ratio,
+                "total_return_pct": r.total_return_pct,
+                "max_drawdown_pct": r.max_drawdown_pct,
+                "total_trades": r.total_trades,
+            })
+    return rows
+
+
+def _get_result_from_db(config: ForgeConfig, run_id: str) -> dict[str, Any] | None:
+    db_path = config.forge_db
+    if not db_path.exists():
+        return None
+    engine = create_engine(f"sqlite:///{db_path}", future=True)
+    with engine.connect() as conn:
+        row = conn.execute(
+            backtest_results.select().where(backtest_results.c.run_id == run_id)
+        ).first()
+    if row is None:
+        return None
+    return _row_to_dict(row)
+
+
+@router.get("/results")
+async def list_results(
+    request: Request,
+    strategy_id: str | None = Query(default=None),
+    since: str | None = Query(default=None),
+) -> list[dict[str, Any]]:
+    config: ForgeConfig = request.app.state.forge_config
+    since_dt: datetime | None = None
+    if since:
+        try:
+            since_dt = _parse_dt(since)
+        except ValueError as e:
+            raise HTTPException(status_code=400, detail=f"since の形式が不正です: {since}") from e
+    return _list_results_from_db(config, strategy_id, since_dt)
+
+
+@router.get("/results/{run_id}")
+async def get_result(run_id: str, request: Request) -> dict[str, Any]:
+    config: ForgeConfig = request.app.state.forge_config
+    record = _get_result_from_db(config, run_id)
+    if record is None:
+        raise HTTPException(status_code=404, detail=f"run_id '{run_id}' が見つかりません")
+    return _shape_detail(record)
+
+
+__all__ = ["router", "_shape_detail"]

alpha_visualizer/routers/strategies.py

@@ -0,0 +1,272 @@
+"""戦略 API ルーター
+
+`/api/strategies`、`/api/strategies/compare`、`/api/strategies/{strategy_id}` を提供する。
+戦略定義の取得元は forge.yaml の ``strategies.use_db`` で切り替わる:
+- ``true``: ``strategies.db`` の ``strategies`` テーブルから読む
+- ``false`` または未設定: ``strategies_dir/*.json`` を glob する（後方互換）
+"""
+from __future__ import annotations
+
+import json
+import logging
+import pathlib
+from typing import Any
+
+from fastapi import APIRouter, HTTPException, Query, Request
+from sqlalchemy import create_engine, select
+
+from alpha_visualizer.db import backtest_results, optimization_runs, strategies
+from alpha_visualizer.forge_config import ForgeConfig
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter()
+
+
+def _load_strategies_from_db(db_path: pathlib.Path) -> list[dict[str, Any]]:
+    """``strategies.db`` から戦略定義を読み取る。"""
+    engine = create_engine(f"sqlite:///{db_path}", future=True)
+    out: list[dict[str, Any]] = []
+    with engine.connect() as conn:
+        for row in conn.execute(select(strategies)):
+            try:
+                data = json.loads(row.definition_json)
+            except (json.JSONDecodeError, TypeError) as e:
+                logger.warning(
+                    "戦略定義 JSON のパースに失敗: %s (%s)", row.strategy_id, e
+                )
+                continue
+            if not isinstance(data, dict):
+                continue
+            data.setdefault("strategy_id", row.strategy_id)
+            data.setdefault("name", row.name)
+            # 戦略定義 JSON に timeframe が無ければ strategies テーブルの列値を使う。
+            data.setdefault("timeframe", row.timeframe)
+            out.append(data)
+    return out
+
+
+def _load_strategies_from_json(strategies_dir: pathlib.Path) -> list[dict[str, Any]]:
+    """``strategies_dir/*.json`` から戦略定義を読み取る（後方互換経路）。"""
+    if not strategies_dir.exists():
+        return []
+    out: list[dict[str, Any]] = []
+    for p in sorted(strategies_dir.glob("*.json")):
+        try:
+            data = json.loads(p.read_text(encoding="utf-8"))
+        except (json.JSONDecodeError, OSError) as e:
+            logger.warning("戦略ファイルの読み込みをスキップ: %s (%s)", p, e)
+            continue
+        if not isinstance(data, dict):
+            continue
+        data.setdefault("strategy_id", p.stem)
+        data.setdefault("name", p.stem)
+        out.append(data)
+    return out
+
+
+def _load_all_strategy_records(config: ForgeConfig) -> list[dict[str, Any]]:
+    """forge.yaml の設定に従って戦略定義の一覧を返す。"""
+    if config.strategies_db is not None and config.strategies_db.exists():
+        return _load_strategies_from_db(config.strategies_db)
+    return _load_strategies_from_json(config.strategies_dir)
+
+
+def _load_strategy_record(
+    config: ForgeConfig, strategy_id: str
+) -> dict[str, Any] | None:
+    """指定 strategy_id の戦略定義を取得する。"""
+    for record in _load_all_strategy_records(config):
+        if record.get("strategy_id") == strategy_id:
+            return record
+    return None
+
+
+def _get_latest_result(config: ForgeConfig, strategy_id: str) -> dict[str, Any] | None:
+    db_path = config.forge_db
+    if not db_path.exists():
+        return None
+    engine = create_engine(f"sqlite:///{db_path}", future=True)
+    with engine.connect() as conn:
+        row = conn.execute(
+            select(
+                backtest_results.c.symbol,
+                backtest_results.c.sharpe_ratio,
+                backtest_results.c.total_return_pct,
+                backtest_results.c.max_drawdown_pct,
+                backtest_results.c.total_trades,
+                backtest_results.c.cagr_pct,
+                backtest_results.c.sortino_ratio,
+                backtest_results.c.win_rate_pct,
+                backtest_results.c.profit_factor,
+                backtest_results.c.run_at,
+            )
+            .where(backtest_results.c.strategy_id == strategy_id)
+            .order_by(backtest_results.c.run_at.desc())
+            .limit(1)
+        ).first()
+    if row is None:
+        return None
+    return {
+        "symbol": row.symbol,
+        "sharpe_ratio": row.sharpe_ratio,
+        "total_return_pct": row.total_return_pct,
+        "max_drawdown_pct": row.max_drawdown_pct,
+        "total_trades": row.total_trades,
+        "cagr_pct": row.cagr_pct,
+        "sortino_ratio": row.sortino_ratio,
+        "win_rate_pct": row.win_rate_pct,
+        "profit_factor": row.profit_factor,
+        "run_at": row.run_at,
+    }
+
+
+def _get_all_results(config: ForgeConfig, strategy_id: str) -> list[dict[str, Any]]:
+    db_path = config.forge_db
+    if not db_path.exists():
+        return []
+    engine = create_engine(f"sqlite:///{db_path}", future=True)
+    with engine.connect() as conn:
+        rows = conn.execute(
+            select(
+                backtest_results.c.run_id,
+                backtest_results.c.symbol,
+                backtest_results.c.sharpe_ratio,
+                backtest_results.c.total_return_pct,
+                backtest_results.c.max_drawdown_pct,
+                backtest_results.c.total_trades,
+                backtest_results.c.run_at,
+            )
+            .where(backtest_results.c.strategy_id == strategy_id)
+            .order_by(backtest_results.c.run_at.desc())
+        ).fetchall()
+    return [
+        {
+            "run_id": r.run_id,
+            "symbol": r.symbol,
+            "sharpe": r.sharpe_ratio,
+            "return_pct": r.total_return_pct,
+            "max_drawdown_pct": r.max_drawdown_pct,
+            "total_trades": r.total_trades,
+            "run_at": r.run_at,
+        }
+        for r in rows
+    ]
+
+
+def _get_optimization_history(config: ForgeConfig, strategy_id: str) -> list[dict[str, Any]]:
+    db_path = config.forge_db
+    if not db_path.exists():
+        return []
+    engine = create_engine(f"sqlite:///{db_path}", future=True)
+    with engine.connect() as conn:
+        rows = conn.execute(
+            select(
+                optimization_runs.c.best_metric_value,
+                optimization_runs.c.run_at,
+                optimization_runs.c.n_trials,
+            )
+            .where(optimization_runs.c.strategy_id == strategy_id)
+            .order_by(optimization_runs.c.run_at.desc())
+        ).fetchall()
+    history = []
+    for i, row in enumerate(reversed(rows), start=1):
+        history.append({
+            "trial": i,
+            "best_sharpe": row.best_metric_value,
+            "run_at": row.run_at,
+            "n_trials": row.n_trials,
+        })
+    return history
+
+
+@router.get("/strategies")
+async def list_strategies(request: Request) -> list[dict[str, Any]]:
+    config: ForgeConfig = request.app.state.forge_config
+    result: list[dict[str, Any]] = []
+    for record in _load_all_strategy_records(config):
+        sid = record.get("strategy_id")
+        if not isinstance(sid, str):
+            continue
+        entry: dict[str, Any] = {
+            "strategy_id": sid,
+            "name": record.get("name", sid),
+            "symbol": None,
+            "timeframe": record.get("timeframe"),
+            "latest_sharpe": None,
+            "latest_return_pct": None,
+            "latest_max_drawdown_pct": None,
+            "latest_profit_factor": None,
+            "latest_win_rate_pct": None,
+            "latest_total_trades": None,
+            "last_run_at": None,
+        }
+        latest = _get_latest_result(config, sid)
+        if latest:
+            entry["symbol"] = latest.get("symbol")
+            entry["latest_sharpe"] = latest.get("sharpe_ratio")
+            entry["latest_return_pct"] = latest.get("total_return_pct")
+            entry["latest_max_drawdown_pct"] = latest.get("max_drawdown_pct")
+            entry["latest_profit_factor"] = latest.get("profit_factor")
+            entry["latest_win_rate_pct"] = latest.get("win_rate_pct")
+            entry["latest_total_trades"] = latest.get("total_trades")
+            entry["last_run_at"] = latest.get("run_at")
+        result.append(entry)
+    return result
+
+
+@router.get("/strategies/compare")
+async def compare_strategies(
+    request: Request,
+    ids: str = Query(..., description="カンマ区切りの strategy_id"),
+) -> list[dict[str, Any]]:
+    config: ForgeConfig = request.app.state.forge_config
+    parsed = [s for s in (i.strip() for i in ids.split(",")) if s]
+    if not parsed:
+        raise HTTPException(status_code=400, detail="ids が空です")
+    out: list[dict[str, Any]] = []
+    for idx, sid in enumerate(parsed):
+        latest = _get_latest_result(config, sid)
+        if not latest:
+            continue
+        record = _load_strategy_record(config, sid)
+        name = record.get("name", sid) if record else sid
+        out.append(
+            {
+                "id": sid,
+                "name": name,
+                "symbol": latest.get("symbol", ""),
+                "total_return_pct": float(latest.get("total_return_pct") or 0.0),
+                "cagr_pct": float(latest.get("cagr_pct") or 0.0),
+                "sharpe_ratio": float(latest.get("sharpe_ratio") or 0.0),
+                "sortino_ratio": float(latest.get("sortino_ratio") or 0.0),
+                "max_drawdown_pct": float(latest.get("max_drawdown_pct") or 0.0),
+                "win_rate_pct": float(latest.get("win_rate_pct") or 0.0),
+                "profit_factor": float(latest.get("profit_factor") or 0.0),
+                "total_trades": int(latest.get("total_trades") or 0),
+                "is_baseline": idx == 0,
+            }
+        )
+    if not out:
+        raise HTTPException(
+            status_code=404,
+            detail=f"指定した戦略のバックテスト結果が見つかりません: {parsed}",
+        )
+    return out
+
+
+@router.get("/strategies/{strategy_id}")
+async def get_strategy(strategy_id: str, request: Request) -> dict[str, Any]:
+    config: ForgeConfig = request.app.state.forge_config
+    record = _load_strategy_record(config, strategy_id)
+    if record is None:
+        raise HTTPException(
+            status_code=404, detail=f"strategy_id '{strategy_id}' が見つかりません"
+        )
+    return {
+        "strategy_id": record.get("strategy_id", strategy_id),
+        "name": record.get("name", strategy_id),
+        "parameters": record.get("parameters", {}),
+        "results": _get_all_results(config, strategy_id),
+        "optimization_history": _get_optimization_history(config, strategy_id),
+    }