681 lines
27 KiB
Python
681 lines
27 KiB
Python
"""全天候策略回测入口。
|
|
|
|
用法(Mac 默认 baostock;VPS Windows / miniQMT 已连用 miniqmt):
|
|
# Mac 默认 baostock(跨平台,不依赖 miniQMT 客户端)
|
|
python -m sanguo_portfolio.runner_backtest \\
|
|
--start 2020-01-01 --end 2024-12-31 --cash 1000000
|
|
|
|
# VPS miniQMT(实盘/精准 xtquant)
|
|
python -m sanguo_portfolio.runner_backtest --provider miniqmt \\
|
|
--start 2020-01-01 --end 2024-12-31 --cash 1000000
|
|
|
|
JSON 输出(供 SSH 捕获,前端 MVP 用):
|
|
python -m sanguo_portfolio.runner_backtest --json \\
|
|
--start 2024-01-01 --end 2024-02-29 --cash 1000000
|
|
|
|
Mac 跑 baostock 默认链路;miniQMT 链路仍保留(实盘 runner_live 用)。
|
|
"""
|
|
from __future__ import annotations
|
|
|
|
# ENV GUARD 必须早于任何 bullet_trade import
|
|
# bullet_trade __init__ 加载时 _create_provider() 读 DEFAULT_DATA_PROVIDER 创建默认 provider:
|
|
# miniqmt → import xtquant(周六休市 miniQMT 客户端不响应→卡死)
|
|
# jqdata → import jqdatasdk(用户铁律不装→ModuleNotFoundError)
|
|
# 方案: ENV 设 jqdata + 预插 mock jqdatasdk, 让 import 走 jqdata 分支拿 mock 不崩不卡;
|
|
# 真实 provider 由 set_data_provider 运行时注入覆盖(local/baostock/miniqmt)。
|
|
import os
|
|
import sys as _sys
|
|
from unittest.mock import MagicMock as _MagicMock
|
|
os.environ.setdefault("DEFAULT_DATA_PROVIDER", "jqdata")
|
|
if "jqdatasdk" not in _sys.modules:
|
|
_m = _MagicMock()
|
|
# jqdata.py 用 @jq.utils.assert_auth 装饰器;MagicMock 的 assert_* 前缀被保护→AttributeError
|
|
_m.utils.assert_auth = lambda func: func # passthrough 装饰器
|
|
_sys.modules["jqdatasdk"] = _m
|
|
|
|
import argparse
|
|
import json
|
|
import logging
|
|
from typing import Any, Dict
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
|
|
def parse_args() -> argparse.Namespace:
|
|
p = argparse.ArgumentParser(description="sanguo_portfolio 组合回测")
|
|
p.add_argument("--start", default="2020-01-01", help="回测开始日期 YYYY-MM-DD")
|
|
p.add_argument("--end", default="2024-12-31", help="回测结束日期 YYYY-MM-DD")
|
|
p.add_argument("--cash", type=float, default=1_000_000.0, help="初始资金(元)")
|
|
p.add_argument("--benchmark", default="000300.XSHG", help="基准代码")
|
|
p.add_argument("--max-pool", type=int, default=0, help="限制选股池前N只(0=不限,MVP验证用)")
|
|
p.add_argument("--frequency", default="day", help="回测频率 day/minute")
|
|
# A 股费用(对齐个股回测;BulletTrade 默认仅印花税千1+最低5元,这里显式可配)
|
|
p.add_argument("--commission-rate", type=float, default=0.0003, help="佣金率双边(万3=0.0003)")
|
|
p.add_argument("--stamp-duty-rate", type=float, default=0.001, help="印花税率卖出(千1=0.001)")
|
|
p.add_argument("--min-commission", type=float, default=5.0, help="单笔最低佣金(元)")
|
|
p.add_argument("--slippage", type=float, default=0.0, help="滑点比率(万10=0.001,0=不加)")
|
|
p.add_argument(
|
|
"--strategy", default="all_weather",
|
|
choices=["all_weather", "momentum_timing", "value_selection", "small_cap"],
|
|
help="策略: all_weather(全天候轮动) / momentum_timing(牛熊分界+取强舍弱+均线动量) / value_selection(价值精选6条月度调仓) / small_cap(小市值20只轮动,无对冲)",
|
|
)
|
|
p.add_argument(
|
|
"--provider", default="local", choices=["local", "baostock", "miniqmt", "unified"],
|
|
help="数据 provider:local(parquet,旧) / baostock(Mac 跨平台) / miniqmt(VPS 实盘) / unified(方案A 权威层)",
|
|
)
|
|
p.add_argument(
|
|
"--provider-config", default="{}",
|
|
help="provider 配置 JSON 字符串,如 '{\"data_dir\":\"D:/xtdata\"}'",
|
|
)
|
|
p.add_argument(
|
|
"--result-file", default="docs/portfolio_backtest_result.md",
|
|
help="结果输出文件(.md)",
|
|
)
|
|
p.add_argument(
|
|
"--json", action="store_true",
|
|
help="JSON 模式:print(json.dumps(result)) 到 stdout,供 SSH 捕获",
|
|
)
|
|
return p.parse_args()
|
|
|
|
|
|
def build_provider(provider_name: str, config_str: str) -> Any:
|
|
"""构造 provider 实例。
|
|
|
|
Args:
|
|
provider_name: "baostock"(Mac 默认) 或 "miniqmt"(VPS 实盘)
|
|
config_str: provider 配置 JSON 字符串
|
|
"""
|
|
import json
|
|
from .providers import (
|
|
BaostockProvider,
|
|
LocalParquetProvider,
|
|
LocalUnifiedProvider,
|
|
SanguoMiniQmtProvider,
|
|
)
|
|
|
|
cfg: Dict[str, Any] = {}
|
|
if config_str and config_str != "{}":
|
|
try:
|
|
cfg = json.loads(config_str)
|
|
except Exception as exc:
|
|
logger.warning("provider-config 解析失败,用默认: %s", exc)
|
|
cfg.setdefault("mode", "backtest")
|
|
|
|
name = (provider_name or "baostock").lower()
|
|
if name == "miniqmt":
|
|
return SanguoMiniQmtProvider(cfg)
|
|
if name == "baostock":
|
|
return BaostockProvider(cfg)
|
|
if name == "local":
|
|
return LocalParquetProvider(cfg)
|
|
if name == "unified":
|
|
return LocalUnifiedProvider(cfg)
|
|
raise ValueError(f"未知 provider: {name}(支持: local / baostock / miniqmt / unified)")
|
|
|
|
|
|
def build_broker_facade(engine: Any) -> Any:
|
|
"""把 BacktestEngine 的聚宽风格 API 包成 BrokerFacade。"""
|
|
from .strategies.all_weather import BrokerFacade
|
|
|
|
# bullet_trade 的 BacktestEngine 把 set_benchmark/run_daily 等顶层函数注入到策略
|
|
# 模块 globals 里。这里把 engine 持有的对应函数转发给 BrokerFacade。
|
|
def _order_target_value(code: str, value: float):
|
|
try:
|
|
return engine.api.order_target_value(code, value)
|
|
except Exception:
|
|
try:
|
|
return engine.order_target_value(code, value)
|
|
except Exception as exc:
|
|
logger.warning("order_target_value 失败 %s=%s: %s", code, value, exc)
|
|
return None
|
|
|
|
def _order_value(code: str, value: float):
|
|
try:
|
|
return engine.api.order_value(code, value)
|
|
except Exception:
|
|
try:
|
|
return engine.order_value(code, value)
|
|
except Exception as exc:
|
|
logger.warning("order_value 失败 %s=%s: %s", code, value, exc)
|
|
return None
|
|
|
|
return BrokerFacade(
|
|
order_target_value=_order_target_value,
|
|
order_value=_order_value,
|
|
)
|
|
|
|
|
|
def _build_strategy(args: argparse.Namespace, provider: Any) -> Any:
|
|
"""根据 --strategy 构造策略实例(分发)。"""
|
|
name = args.strategy
|
|
if name == "all_weather":
|
|
from .strategies import AllWeatherConfig, AllWeatherStrategy
|
|
return AllWeatherStrategy(
|
|
provider=provider,
|
|
config=AllWeatherConfig(max_pool=args.max_pool),
|
|
)
|
|
if name == "momentum_timing":
|
|
from .strategies import MomentumTimingConfig, MomentumTimingStrategy
|
|
return MomentumTimingStrategy(
|
|
provider=provider,
|
|
config=MomentumTimingConfig(max_pool=args.max_pool),
|
|
)
|
|
if name == "value_selection":
|
|
from .strategies import ValueSelectionConfig, ValueSelectionStrategy
|
|
return ValueSelectionStrategy(
|
|
provider=provider,
|
|
config=ValueSelectionConfig(max_pool=args.max_pool),
|
|
)
|
|
if name == "small_cap":
|
|
from .strategies import SmallCapConfig, SmallCapStrategy
|
|
return SmallCapStrategy(
|
|
provider=provider,
|
|
config=SmallCapConfig(max_pool=args.max_pool),
|
|
)
|
|
raise ValueError(
|
|
f"未知 strategy: {name}(支持: all_weather / momentum_timing / value_selection / small_cap)"
|
|
)
|
|
|
|
|
|
def _register_schedule(strategy: Any) -> None:
|
|
"""按策略类型注册 bullet_trade 顶层 run_daily/run_monthly 定时任务。"""
|
|
try:
|
|
from bullet_trade.core import run_daily, run_monthly # type: ignore
|
|
except Exception as exc:
|
|
logger.warning("注册定时任务失败(回测可能不触达): %s", exc)
|
|
return
|
|
|
|
try:
|
|
from .strategies import (
|
|
AllWeatherStrategy,
|
|
MomentumTimingStrategy,
|
|
SmallCapStrategy,
|
|
ValueSelectionStrategy,
|
|
)
|
|
if isinstance(strategy, AllWeatherStrategy):
|
|
run_daily(strategy.prepare_stock_list, "9:05")
|
|
run_monthly(strategy.monthly_adjustment, 1, "9:30")
|
|
run_daily(strategy.stop_loss, "14:00")
|
|
return
|
|
if isinstance(strategy, MomentumTimingStrategy):
|
|
# 原策略 handle_data 单位时间触发 → 每日 9:30
|
|
run_daily(strategy.handle_data, "9:30")
|
|
return
|
|
if isinstance(strategy, ValueSelectionStrategy):
|
|
# 原策略 run_monthly 第 5 个交易日(月度调仓)
|
|
run_monthly(strategy.monthly_adjustment, 5, "9:30")
|
|
return
|
|
if isinstance(strategy, SmallCapStrategy):
|
|
# 原策略 handle_data 单位时间触发 → 每日 9:30
|
|
# 5 日调仓周期由 handle_data 内部 day_count % tc == 0 控制(对齐 g.t % g.tc)
|
|
run_daily(strategy.handle_data, "9:30")
|
|
return
|
|
except Exception as exc:
|
|
logger.warning("注册定时任务失败(%s): %s", type(strategy).__name__, exc)
|
|
return
|
|
logger.warning("未知策略类型 %s,未注册定时任务", type(strategy).__name__)
|
|
|
|
|
|
def run_backtest(args: argparse.Namespace) -> Dict[str, Any]:
|
|
"""跑回测,返回结果 dict。
|
|
|
|
BulletTrade 的 BacktestEngine 接受 strategy_file 或 initialize 等函数。
|
|
我们把策略类包成 initialize 函数:initialize 闭包挂 run_daily 等。
|
|
"""
|
|
from bullet_trade import BacktestEngine # type: ignore
|
|
from bullet_trade.data.api import set_data_provider # type: ignore
|
|
|
|
provider = build_provider(args.provider, args.provider_config)
|
|
set_data_provider(provider)
|
|
|
|
# 占位策略:initialize 里把 self(strategy)挂到聚宽风格定时器
|
|
holder: Dict[str, Any] = {}
|
|
|
|
def initialize(context):
|
|
strategy = _build_strategy(args, provider)
|
|
holder["strategy"] = strategy
|
|
|
|
# 注册定时任务(按策略类型分发)
|
|
_register_schedule(strategy)
|
|
|
|
# 先注入 broker(含 set_option 委托) 再 initialize: initialize 里 set_option("use_real_price",True)
|
|
# 才能真正设到 bullet_trade settings → fq_mode=pre 与 get_current_data 一致, 买入才成交
|
|
holder["broker"] = build_broker_facade_inner(strategy, context)
|
|
strategy.broker = holder["broker"]
|
|
# A 股费用 + 滑点(聚宽风格全局函数,对齐个股回测;BulletTrade 默认费用不全)
|
|
from bullet_trade.core.api import set_order_cost, set_slippage # type: ignore
|
|
from bullet_trade.core.settings import OrderCost, FixedSlippage # type: ignore
|
|
set_order_cost(
|
|
OrderCost(
|
|
open_tax=0.0,
|
|
close_tax=args.stamp_duty_rate,
|
|
open_commission=args.commission_rate,
|
|
close_commission=args.commission_rate,
|
|
min_commission=args.min_commission,
|
|
),
|
|
type="stock",
|
|
)
|
|
if args.slippage:
|
|
set_slippage(FixedSlippage(value=args.slippage))
|
|
strategy.initialize(context)
|
|
|
|
def build_broker_facade_inner(strategy: Any, context: Any):
|
|
from .strategies.all_weather import BrokerFacade
|
|
# 在回测内,聚宽风格 order_target_value 来自 bullet_trade 顶层
|
|
from bullet_trade.core.api import ( # type: ignore
|
|
order_target_value as bt_otv,
|
|
order_value as bt_ov,
|
|
)
|
|
from bullet_trade.core.settings import set_option as bt_set_option # type: ignore
|
|
return BrokerFacade(
|
|
order_target_value=lambda c, v: bt_otv(c, v),
|
|
order_value=lambda c, v: bt_ov(c, v),
|
|
# 注入 set_option 委托 bullet_trade settings: 让策略 set_option("use_real_price",True)
|
|
# 真正生效 → engine fq_mode=pre 与 get_current_data(fq=pre) 一致, 避免保护价<当前价不成交
|
|
set_option=lambda k, v: bt_set_option(k, v),
|
|
)
|
|
|
|
print(f"[runner] ENGINE_BUILD_PRE strategy={args.strategy}", flush=True)
|
|
engine = BacktestEngine(
|
|
initialize=initialize,
|
|
start_date=args.start,
|
|
end_date=args.end,
|
|
frequency=args.frequency,
|
|
initial_cash=args.cash,
|
|
benchmark=args.benchmark,
|
|
)
|
|
print("[runner] RUN_START", flush=True)
|
|
result = engine.run()
|
|
print("[runner] RUN_DONE type=%s" % type(result).__name__, flush=True)
|
|
|
|
# 引擎不把基准序列放进 results——这里带出(引擎已按区间加载 benchmark_data)
|
|
try:
|
|
bd = getattr(engine, "benchmark_data", None)
|
|
if bd is not None and len(bd) and isinstance(result, dict):
|
|
result["benchmark_curve"] = _extract_benchmark_curve(bd)
|
|
except Exception as exc:
|
|
logger.warning("提取基准曲线失败: %s", exc)
|
|
|
|
# 输出结果摘要到 markdown(JSON 模式时 result_file="" 跳过)
|
|
if getattr(args, "result_file", ""):
|
|
_write_result_md(result, args.result_file, args)
|
|
return result
|
|
|
|
|
|
def _write_result_md(result: Dict[str, Any], path: str, args: argparse.Namespace) -> None:
|
|
"""把回测关键指标写成 markdown(给 docs/portfolio_backtest_result.md)。"""
|
|
try:
|
|
summary = result.get("summary", {}) if isinstance(result, dict) else {}
|
|
strategy_name = getattr(args, "strategy", "all_weather")
|
|
title_map = {
|
|
"all_weather": "全天候轮动",
|
|
"momentum_timing": "牛熊分界+均线动量",
|
|
"value_selection": "价值精选6条月度调仓",
|
|
"small_cap": "小市值20只轮动(无对冲)",
|
|
}
|
|
title = title_map.get(strategy_name, strategy_name)
|
|
lines = [
|
|
f"# sanguo_portfolio {title}回测结果",
|
|
"",
|
|
f"- 策略: {strategy_name}",
|
|
f"- 区间: {args.start} ~ {args.end}",
|
|
f"- 初始资金: {args.cash:,.0f}",
|
|
f"- 基准: {args.benchmark}",
|
|
"",
|
|
"## 关键指标",
|
|
"",
|
|
"| 指标 | 值 |",
|
|
"|---|---|",
|
|
]
|
|
for k in (
|
|
"total_returns", "annual_returns", "benchmark_returns",
|
|
"alpha", "beta", "sharpe", "sortino", "max_drawdown",
|
|
"win_rate", "turnover",
|
|
):
|
|
if k in summary:
|
|
lines.append(f"| {k} | {summary[k]} |")
|
|
content = "\n".join(lines)
|
|
with open(path, "w") as f:
|
|
f.write(content + "\n")
|
|
logger.info("回测结果写入 %s", path)
|
|
except Exception as exc:
|
|
logger.warning("写结果文件失败: %s", exc)
|
|
|
|
|
|
def run_backtest_json(params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""JSON 入口(供 SSH 触发,前端 MVP 用)。
|
|
|
|
Args:
|
|
params: {
|
|
pool: 标的池(暂未实际使用,占位),
|
|
start_date, end_date: YYYY-MM-DD,
|
|
initial_cash: 初始资金,
|
|
}
|
|
|
|
Returns:
|
|
{
|
|
"strategy": "all_weather" | "momentum_timing",
|
|
"period": {"start": ..., "end": ..., "trading_days": N},
|
|
"stocks_selected": [{"code":..., "name":...}, ...], # 末日持仓
|
|
"trades": [{date, code, side, amount, price, ...}, ...],
|
|
"equity_curve": [{"date":..., "equity":...}, ...],
|
|
"metrics": {total_return, annual_return, max_drawdown, sharpe, ...},
|
|
}
|
|
"""
|
|
# 构造一个 Namespace 复用 run_backtest
|
|
strategy_name = params.get("strategy", "all_weather")
|
|
args = argparse.Namespace(
|
|
start=params.get("start_date", "2024-01-01"),
|
|
end=params.get("end_date", "2024-02-29"),
|
|
cash=float(params.get("initial_cash", 1_000_000.0)),
|
|
benchmark=params.get("benchmark", "000300.XSHG"),
|
|
frequency="day",
|
|
strategy=strategy_name,
|
|
provider=params.get("provider", "local"),
|
|
provider_config=params.get("provider_config", "{}"),
|
|
result_file="", # JSON 模式不写 md
|
|
max_pool=int(params.get("max_pool", 0)),
|
|
commission_rate=float(params.get("commission_rate", 0.0003)),
|
|
stamp_duty_rate=float(params.get("stamp_duty_rate", 0.001)),
|
|
min_commission=float(params.get("min_commission", 5.0)),
|
|
slippage=float(params.get("slippage", 0.0)),
|
|
)
|
|
raw = run_backtest(args)
|
|
|
|
summary = raw.get("summary", {}) if isinstance(raw, dict) else {}
|
|
metrics = _extract_metrics(summary)
|
|
|
|
# 净值曲线:daily_records 是 DataFrame,index=date,列含 total_value
|
|
equity_curve = _extract_equity_curve(raw.get("daily_records"))
|
|
|
|
# 基准曲线(对齐策略交易日、归一化) + 回撤序列 + 扩展指标
|
|
benchmark_curve = _align_benchmark(raw.get("benchmark_curve"), equity_curve)
|
|
drawdown_curve = _extract_drawdown(equity_curve)
|
|
metrics.update(_compute_extended_metrics(equity_curve, benchmark_curve))
|
|
|
|
# 选股(末日持仓):daily_positions 最后一日
|
|
stocks_selected = _extract_last_positions(raw.get("daily_positions"))
|
|
|
|
# 成交明细
|
|
trades = _extract_trades(raw.get("trades"))
|
|
|
|
meta = raw.get("meta", {}) if isinstance(raw, dict) else {}
|
|
return {
|
|
"strategy": strategy_name,
|
|
"period": {
|
|
"start": meta.get("start_date", args.start),
|
|
"end": meta.get("end_date", args.end),
|
|
"trading_days": len(equity_curve),
|
|
},
|
|
"stocks_selected": stocks_selected,
|
|
"trades": trades,
|
|
"equity_curve": equity_curve,
|
|
"benchmark_curve": benchmark_curve,
|
|
"drawdown_curve": drawdown_curve,
|
|
"metrics": metrics,
|
|
"raw_summary": summary,
|
|
}
|
|
|
|
|
|
def _to_float(v: Any) -> float | None:
|
|
"""从 string/number 提取 float,失败返 None。bullet-trade summary 多为 '12.34%' 字符串。"""
|
|
if v is None:
|
|
return None
|
|
if isinstance(v, (int, float)):
|
|
return float(v)
|
|
s = str(v).strip().replace("%", "").replace(",", "")
|
|
try:
|
|
return float(s)
|
|
except (TypeError, ValueError):
|
|
return None
|
|
|
|
|
|
def _extract_metrics(summary: Dict[str, Any]) -> Dict[str, float | None]:
|
|
"""bullet-trade summary 用中文 key('策略收益'/'最大回撤'/...)。
|
|
百分比按字面数值(12.34% → 12.34),前端按需 /100 显示。
|
|
"""
|
|
return {
|
|
"total_return": _to_float(summary.get("策略收益")),
|
|
"annual_return": _to_float(summary.get("策略年化收益")),
|
|
"max_drawdown": _to_float(summary.get("最大回撤")),
|
|
"sharpe": _to_float(summary.get("夏普比率")),
|
|
"win_rate_daily": _to_float(summary.get("日胜率")),
|
|
"win_rate_trade": _to_float(summary.get("交易胜率")),
|
|
"trading_days": _to_float(summary.get("交易天数")),
|
|
}
|
|
|
|
|
|
def _extract_equity_curve(daily_records: Any) -> list[Dict[str, Any]]:
|
|
"""daily_records: DataFrame,index=date,列含 total_value。"""
|
|
out: list[Dict[str, Any]] = []
|
|
if daily_records is None:
|
|
return out
|
|
try:
|
|
import pandas as pd # type: ignore
|
|
if isinstance(daily_records, pd.DataFrame):
|
|
df = daily_records.reset_index()
|
|
date_col = "date" if "date" in df.columns else df.columns[0]
|
|
val_col = "total_value" if "total_value" in df.columns else None
|
|
if val_col is None:
|
|
return out
|
|
for _, row in df.iterrows():
|
|
d = row[date_col]
|
|
out.append({
|
|
"date": getattr(d, "strftime", lambda f: str(d))("%Y-%m-%d"),
|
|
"equity": float(row[val_col]),
|
|
})
|
|
except Exception as exc:
|
|
logger.warning("解析 equity_curve 失败: %s", exc)
|
|
return out
|
|
|
|
|
|
def _extract_benchmark_curve(bd: Any) -> list[Dict[str, Any]]:
|
|
"""engine.benchmark_data → [{date, close}]。jq 风格 DataFrame(index=date,含 close)或 Series。"""
|
|
out: list[Dict[str, Any]] = []
|
|
try:
|
|
import pandas as pd # type: ignore
|
|
if isinstance(bd, pd.Series):
|
|
df = bd.to_frame(name="close").reset_index()
|
|
df.columns = ["date", "close"]
|
|
elif isinstance(bd, pd.DataFrame) and "close" in bd.columns:
|
|
df = bd[["close"]].reset_index()
|
|
df.columns = ["date", "close"]
|
|
else:
|
|
return out
|
|
for _, row in df.iterrows():
|
|
d = row["date"]
|
|
close = row["close"]
|
|
if close is None or str(close) == "nan":
|
|
continue
|
|
out.append({
|
|
"date": getattr(d, "strftime", lambda f: str(d))("%Y-%m-%d"),
|
|
"close": float(close),
|
|
})
|
|
except Exception as exc:
|
|
logger.warning("解析 benchmark_curve 失败: %s", exc)
|
|
return out
|
|
|
|
|
|
def _align_benchmark(benchmark: Any, equity_curve: list[Dict[str, Any]]) -> list[Dict[str, Any]]:
|
|
"""基准收盘对齐策略交易日(前向填充)并归一化为净值 1.0 起。
|
|
|
|
基准日历(指数)与策略交易日历基本一致;不一致时用最近一日基准价填充,
|
|
首日之前无基准则从首个可得日起以该日为 1.0。
|
|
"""
|
|
if not benchmark or not equity_curve:
|
|
return []
|
|
close_by_date: Dict[str, float] = {}
|
|
for p in benchmark:
|
|
try:
|
|
close_by_date[p["date"]] = float(p["close"])
|
|
except (KeyError, TypeError, ValueError):
|
|
continue
|
|
out: list[Dict[str, Any]] = []
|
|
last_close: float | None = None
|
|
base: float | None = None
|
|
for point in equity_curve:
|
|
d = point["date"]
|
|
c = close_by_date.get(d)
|
|
if c is None or c <= 0:
|
|
c = last_close
|
|
else:
|
|
last_close = c
|
|
if c is None or c <= 0:
|
|
out.append({"date": d, "benchmark": 1.0}) # 基准缺头几天:先垫 1.0
|
|
continue
|
|
if base is None:
|
|
base = c
|
|
out.append({"date": d, "benchmark": c / base})
|
|
return out
|
|
|
|
|
|
def _extract_drawdown(equity_curve: list[Dict[str, Any]]) -> list[Dict[str, Any]]:
|
|
"""净值 → 回撤序列(%,负值):dd = equity/历史峰值 - 1。"""
|
|
out: list[Dict[str, Any]] = []
|
|
peak: float | None = None
|
|
for point in equity_curve:
|
|
v = float(point.get("equity", 0) or 0)
|
|
if peak is None or v > peak:
|
|
peak = v
|
|
dd = (v / peak - 1) * 100 if peak else 0.0
|
|
out.append({"date": point["date"], "drawdown": dd})
|
|
return out
|
|
|
|
|
|
def _compute_extended_metrics(
|
|
equity_curve: list[Dict[str, Any]],
|
|
benchmark_curve: list[Dict[str, Any]],
|
|
) -> Dict[str, float]:
|
|
"""从净值/基准序列算扩展指标(纯 python,不引 numpy)。
|
|
|
|
惯例与 _extract_metrics 一致:比率类原值、百分比类用百分数字面值。
|
|
"""
|
|
out: Dict[str, float] = {}
|
|
vals = [float(p["equity"]) for p in equity_curve]
|
|
if len(vals) < 2:
|
|
return out
|
|
rets = [vals[i] / vals[i - 1] - 1 for i in range(1, len(vals)) if vals[i - 1] > 0]
|
|
n = len(rets)
|
|
if n == 0:
|
|
return out
|
|
mean = sum(rets) / n
|
|
var = sum((r - mean) ** 2 for r in rets) / max(n - 1, 1)
|
|
vol = (var ** 0.5) * (252 ** 0.5)
|
|
out["annual_volatility"] = vol * 100
|
|
downside = [r for r in rets if r < 0]
|
|
if downside:
|
|
dstd = (sum(r * r for r in downside) / len(downside)) ** 0.5
|
|
if dstd > 0:
|
|
out["sortino"] = (mean / dstd) * (252 ** 0.5)
|
|
days = len(equity_curve)
|
|
ann_s = (vals[-1] / vals[0]) ** (252 / days) - 1 if vals[0] > 0 and vals[-1] > 0 else None
|
|
total_dd = min(p["drawdown"] for p in _extract_drawdown(equity_curve)) if days else None
|
|
if total_dd is not None and total_dd < 0 and ann_s is not None:
|
|
out["calmar"] = ann_s / abs(total_dd / 100)
|
|
|
|
bench = [float(p.get("benchmark", 1.0) or 1.0) for p in benchmark_curve] if benchmark_curve else []
|
|
if len(bench) == days and bench[0] > 0:
|
|
brets = [bench[i] / bench[i - 1] - 1 for i in range(1, len(bench)) if bench[i - 1] > 0]
|
|
if brets:
|
|
out["benchmark_return"] = (bench[-1] - 1) * 100
|
|
out["excess_return"] = (vals[-1] / vals[0] - 1) * 100 - out["benchmark_return"]
|
|
bmean = sum(brets) / len(brets)
|
|
bvar = sum((r - bmean) ** 2 for r in brets) / max(len(brets) - 1, 1)
|
|
if bvar > 0:
|
|
cov = sum((rets[i] - mean) * (brets[i] - bmean) for i in range(min(n, len(brets)))) / max(min(n, len(brets)) - 1, 1)
|
|
beta = cov / bvar
|
|
out["beta"] = beta
|
|
ann_b = (bench[-1] / bench[0]) ** (252 / days) - 1
|
|
if ann_s is not None:
|
|
out["alpha"] = (ann_s - beta * ann_b) * 100
|
|
return out
|
|
|
|
|
|
def _extract_last_positions(daily_positions: Any) -> list[Dict[str, Any]]:
|
|
"""daily_positions: DataFrame,列含 date/code/amount/avg_cost/price/value。
|
|
取最后一日的非零持仓作为选股名单。"""
|
|
out: list[Dict[str, Any]] = []
|
|
if daily_positions is None:
|
|
return out
|
|
try:
|
|
import pandas as pd # type: ignore
|
|
if isinstance(daily_positions, pd.DataFrame) and not daily_positions.empty:
|
|
df = daily_positions
|
|
if "date" in df.columns:
|
|
last_date = df["date"].max()
|
|
df = df[df["date"] == last_date]
|
|
for _, row in df.iterrows():
|
|
amt = row.get("amount", 0)
|
|
if amt is None or float(amt) <= 0:
|
|
continue
|
|
out.append({
|
|
"code": str(row.get("code", "")),
|
|
"name": str(row.get("code", "")), # name 字段 bullet-trade 没存,前端展示 code
|
|
"amount": float(amt),
|
|
"avg_cost": float(row.get("avg_cost", 0) or 0),
|
|
"price": float(row.get("price", 0) or 0),
|
|
"value": float(row.get("value", 0) or 0),
|
|
})
|
|
except Exception as exc:
|
|
logger.warning("解析 last_positions 失败: %s", exc)
|
|
return out
|
|
|
|
|
|
def _extract_trades(trades: Any) -> list[Dict[str, Any]]:
|
|
"""trades: list[Trade],用 __dict__ 或属性兜底提取关键字段。"""
|
|
out: list[Dict[str, Any]] = []
|
|
if not trades:
|
|
return out
|
|
keys = ("datetime", "date", "code", "side", "action", "amount",
|
|
"filled_amount", "price", "filled_price", "commission", "status")
|
|
for t in trades:
|
|
item: Dict[str, Any] = {}
|
|
for k in keys:
|
|
v = None
|
|
if hasattr(t, k):
|
|
v = getattr(t, k)
|
|
elif isinstance(t, dict):
|
|
v = t.get(k)
|
|
if v is None:
|
|
continue
|
|
# datetime 类转字符串
|
|
if hasattr(v, "strftime"):
|
|
v = v.strftime("%Y-%m-%d %H:%M:%S")
|
|
try:
|
|
if isinstance(v, (int, float)):
|
|
v = float(v)
|
|
except Exception:
|
|
pass
|
|
item[k] = v
|
|
if item:
|
|
out.append(item)
|
|
return out
|
|
|
|
|
|
def main() -> None:
|
|
logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(name)s: %(message)s")
|
|
args = parse_args()
|
|
if args.json:
|
|
# JSON 模式:stderr 仍打日志,stdout 只输出 JSON(供 SSH 捕获)
|
|
result = run_backtest_json({
|
|
"strategy": args.strategy,
|
|
"start_date": args.start,
|
|
"end_date": args.end,
|
|
"initial_cash": args.cash,
|
|
"benchmark": args.benchmark,
|
|
"provider": args.provider,
|
|
"provider_config": args.provider_config,
|
|
"max_pool": args.max_pool,
|
|
"commission_rate": args.commission_rate,
|
|
"stamp_duty_rate": args.stamp_duty_rate,
|
|
"min_commission": args.min_commission,
|
|
"slippage": args.slippage,
|
|
})
|
|
print(json.dumps(result, ensure_ascii=False, default=str))
|
|
else:
|
|
run_backtest(args)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|