Gahow Wang
cc1366b2dc
Strategies - BarStrategy protocol (close/open/high/low/volume bars; row d uses bars through d-1) and RobustMomentumStrategy: overnight_recovery_top10 (US), lowrisk_momentum_top15 and lowbeta_sharpe_mom_top20 (CN), top-N with rank hysteresis, 10-day rebalance, weights drift between rebalances. - trader: strategy_fields/strategy_bars/bar_session_weights; one signal path (_signals_for_sessions) replaces generate_target_weights. Live fixes - CSI 300 constituents come from China Securities Index's file; the Wikipedia table was 122 names off the real index. - S&P 500 change log moved to "Historical components of the S&P 500". - data_manager: tickers missing from a partial Yahoo batch are retried alone before being marked unavailable (CEG, GEV, SNDK ... were dropped). update() takes fields=[...] and stores high/low/volume panels. - Whole-lot orders go to the nearest lot within cash (CN books held ~62% cash); held names are resized only beyond RESIZE_BAND (10%), so books no longer pay a ticket fee to trade daily drift. Web backtests - backtest_runner.py replaces the duplicated bridge/precompute code: PIT membership in both markets (data/csi300_history.json), stock universe limited to index members (ETFs and benchmarks in the shared panel were pickable), and the book kept like the live trader (simulate_live_book: signal timing, drift, order floor, resize band, fees on orders placed). Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2009 lines
85 KiB
Python
2009 lines
85 KiB
Python
"""
|
|
Daily trading simulation system.
|
|
|
|
Subcommands:
|
|
morning — Download today's open prices, run strategy, output trade orders
|
|
evening — Download close prices, record execution, update portfolio
|
|
auto — Single daily run (morning + evening in one step, for cron)
|
|
monitor — Long-running daemon for US+CN, all strategies (one tmux)
|
|
status — Print current portfolio, P&L, and recent trades
|
|
simulate — Replay a date range day-by-day (for forward testing)
|
|
log — View daily log: each day's holdings, cash, and operations
|
|
compare — Compare all strategies side-by-side (auto-discovers state files)
|
|
|
|
Usage:
|
|
uv run python trader.py morning --market us --strategy recovery_mom_top10
|
|
uv run python trader.py evening --market us --strategy recovery_mom_top10
|
|
uv run python trader.py auto --market us --strategy recovery_mom_top10
|
|
uv run python trader.py monitor --market us --strategy recovery_mom_top10
|
|
uv run python trader.py status --market us --strategy recovery_mom_top10
|
|
uv run python trader.py simulate --market us --strategy recovery_mom_top10 \\
|
|
--start 2026-01-01 --end 2026-04-04
|
|
|
|
Monitor mode (recommended for tmux):
|
|
tmux new -s quant
|
|
uv run python trader.py monitor --market us --strategy recovery_mom_top10
|
|
# Ctrl-B D to detach; tmux attach -t quant to reconnect
|
|
|
|
State is persisted in data/trader_{market}_{strategy}.json between runs.
|
|
"""
|
|
|
|
import argparse
|
|
import json
|
|
import os
|
|
import sys
|
|
import zoneinfo
|
|
from datetime import datetime, timedelta, timezone
|
|
|
|
import numpy as np
|
|
import pandas as pd
|
|
import yfinance as yf
|
|
|
|
import data_manager
|
|
from strategies.base import BarStrategy
|
|
from strategies.buy_and_hold import BuyAndHoldStrategy
|
|
from strategies.dual_momentum import DualMomentumStrategy
|
|
from strategies.factor_combo import FactorComboStrategy
|
|
from strategies.inverse_vol import InverseVolatilityStrategy
|
|
from strategies.momentum import MomentumStrategy
|
|
from strategies.momentum_quality import MomentumQualityStrategy
|
|
from strategies.permanent import (
|
|
ETF_UNIVERSE,
|
|
GLOBAL_ETF_UNIVERSE,
|
|
HK_ETF_UNIVERSE,
|
|
TREND_RIDER_V4_UNIVERSE,
|
|
TrendRiderV3,
|
|
TrendRiderV4,
|
|
)
|
|
from strategies.recovery_momentum import RecoveryMomentumStrategy
|
|
from strategies.robust_momentum import RobustMomentumStrategy
|
|
from strategies.trend_following import TrendFollowingStrategy
|
|
from strategies.trend_rider_v5 import TrendRiderV5
|
|
from strategies.trend_rider_voltgt import (
|
|
TrendRiderV3VolTarget,
|
|
TrendRiderV5VolTarget,
|
|
)
|
|
from strategies.trend_rider_v7 import TrendRiderV7
|
|
from strategies.ensemble_alpha import (
|
|
EnsembleAlphaStrategy,
|
|
EnhancedFactorComboStrategy,
|
|
RiskManagedEnsembleStrategy,
|
|
SharpeBoostedEnsembleStrategy,
|
|
)
|
|
from strategies.composite_alpha import CompositeAlphaStrategy
|
|
from strategies.enhanced_recovery_momentum import EnhancedRecoveryMomentumStrategy
|
|
from strategies.hybrid_alpha import HybridAlphaStrategy, RecoveryQualityBlendStrategy
|
|
from strategies.improved_momentum_quality import ImprovedMomentumQualityStrategy
|
|
from strategies.trend_rider_v6 import TrendRiderV6
|
|
from universe import UNIVERSES
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Per-market fixed trading fees (per trade, in the market's local currency)
|
|
# ---------------------------------------------------------------------------
|
|
# These are applied automatically by cmd_monitor and cmd_auto; they can still
|
|
# be overridden by explicitly passing --fixed-fee on the CLI.
|
|
MARKET_FEES = {
|
|
"us": 2.0, # USD per trade (floor)
|
|
"cn": 5.0, # CNY per trade (A-share minimum commission)
|
|
}
|
|
|
|
# IBKR-style tiered schedule on top of the floor. `commission = max(fixed_fee,
|
|
# fee_base + fee_per_share * shares)`. CN defaults stay at flat 5 CNY.
|
|
MARKET_FEE_TIERED = {
|
|
"us": {"fee_base": 1.88, "fee_per_share": 0.009},
|
|
}
|
|
|
|
# Minimum tradable lot per market when trading whole shares. A-shares trade in
|
|
# board lots of 100.
|
|
MARKET_LOT_SIZE = {"us": 1, "cn": 100}
|
|
|
|
# A position already held is resized only once it is this far from its target
|
|
# (relative to the target value); entries and exits always trade. Without the
|
|
# band the books paid a ticket fee almost daily to trade weight drift that
|
|
# the backtests never trade.
|
|
RESIZE_BAND = 0.10
|
|
|
|
# Default live capital per market, in the market's own currency.
|
|
MONITOR_CAPITAL = {"us": 10_000.0, "cn": 70_000.0}
|
|
|
|
# Exchange close per price panel. A bar dated today is treated as a closing
|
|
# price only once the session has closed and settled for a few minutes.
|
|
MARKET_SESSION = {
|
|
"us": ("America/New_York", 16, 0),
|
|
"etfs": ("America/New_York", 16, 0),
|
|
"cn": ("Asia/Shanghai", 15, 0),
|
|
}
|
|
SESSION_SETTLE_MINUTES = 20
|
|
|
|
# HK-listed tickers held in a USD book are converted with this FX series
|
|
# (HKD per 1 USD). HKD is pegged within 7.75-7.85, so the band midpoint is
|
|
# used on dates the series has no quote (Yahoo's FX feed is intermittent).
|
|
HKD_FX_TICKER = "HKD=X"
|
|
HKD_PEG_MIDPOINT = 7.80
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Strategy registry
|
|
# ---------------------------------------------------------------------------
|
|
|
|
STRATEGY_REGISTRY = {
|
|
# --- Original strategies ---
|
|
"recovery_mom_top10": lambda **kw: RecoveryMomentumStrategy(top_n=10),
|
|
"recovery_mom_top20": lambda **kw: RecoveryMomentumStrategy(top_n=20),
|
|
"recovery_mom_top50": lambda **kw: RecoveryMomentumStrategy(top_n=50),
|
|
"momentum": lambda **kw: MomentumStrategy(lookback=252, skip=21, top_n=kw.get("top_n", 20)),
|
|
"momentum_quality": lambda **kw: MomentumQualityStrategy(top_n=kw.get("top_n", 20)),
|
|
"dual_momentum": lambda **kw: DualMomentumStrategy(top_n=kw.get("top_n", 20)),
|
|
"inverse_vol": lambda **kw: InverseVolatilityStrategy(vol_window=20),
|
|
"trend_following": lambda **kw: TrendFollowingStrategy(top_n=kw.get("top_n", 20)),
|
|
"buy_and_hold": lambda **kw: BuyAndHoldStrategy(),
|
|
# --- Factor combo: US champions ---
|
|
"fc_rec_mfilt_deep_upvol_daily": lambda **kw: FactorComboStrategy("rec_mfilt+deep_upvol", rebal_freq=1),
|
|
"fc_rec_mfilt_deep_upvol_weekly": lambda **kw: FactorComboStrategy("rec_mfilt+deep_upvol", rebal_freq=5),
|
|
"fc_rec_mfilt_deep_upvol_biweekly": lambda **kw: FactorComboStrategy("rec_mfilt+deep_upvol", rebal_freq=10),
|
|
"fc_rec_mfilt_deep_upvol_monthly": lambda **kw: FactorComboStrategy("rec_mfilt+deep_upvol", rebal_freq=21),
|
|
"fc_ma200_mom7m_rec126_daily": lambda **kw: FactorComboStrategy("ma200+mom7m+rec126", rebal_freq=1),
|
|
"fc_ma200_mom7m_rec126_weekly": lambda **kw: FactorComboStrategy("ma200+mom7m+rec126", rebal_freq=5),
|
|
"fc_ma200_mom7m_rec126_biweekly": lambda **kw: FactorComboStrategy("ma200+mom7m+rec126", rebal_freq=10),
|
|
"fc_ma200_mom7m_rec126_monthly": lambda **kw: FactorComboStrategy("ma200+mom7m+rec126", rebal_freq=21),
|
|
"fc_rec_mfilt_ma200_daily": lambda **kw: FactorComboStrategy("rec_mfilt+ma200", rebal_freq=1),
|
|
"fc_rec_mfilt_ma200_weekly": lambda **kw: FactorComboStrategy("rec_mfilt+ma200", rebal_freq=5),
|
|
"fc_rec_mfilt_ma200_biweekly": lambda **kw: FactorComboStrategy("rec_mfilt+ma200", rebal_freq=10),
|
|
"fc_rec_mfilt_ma200_monthly": lambda **kw: FactorComboStrategy("rec_mfilt+ma200", rebal_freq=21),
|
|
"fc_mom7m_rec126_daily": lambda **kw: FactorComboStrategy("mom7m+rec126", rebal_freq=1),
|
|
"fc_mom7m_rec126_weekly": lambda **kw: FactorComboStrategy("mom7m+rec126", rebal_freq=5),
|
|
"fc_mom7m_rec126_biweekly": lambda **kw: FactorComboStrategy("mom7m+rec126", rebal_freq=10),
|
|
"fc_mom7m_rec126_monthly": lambda **kw: FactorComboStrategy("mom7m+rec126", rebal_freq=21),
|
|
# --- Factor combo: CN champions ---
|
|
"fc_up_cap_quality_mom_daily": lambda **kw: FactorComboStrategy("up_cap+quality_mom", rebal_freq=1),
|
|
"fc_up_cap_quality_mom_weekly": lambda **kw: FactorComboStrategy("up_cap+quality_mom", rebal_freq=5),
|
|
"fc_up_cap_quality_mom_biweekly": lambda **kw: FactorComboStrategy("up_cap+quality_mom", rebal_freq=10),
|
|
"fc_up_cap_quality_mom_monthly": lambda **kw: FactorComboStrategy("up_cap+quality_mom", rebal_freq=21),
|
|
"fc_down_resil_qual_mom_daily": lambda **kw: FactorComboStrategy("down_resil+qual_mom", rebal_freq=1),
|
|
"fc_down_resil_qual_mom_weekly": lambda **kw: FactorComboStrategy("down_resil+qual_mom", rebal_freq=5),
|
|
"fc_down_resil_qual_mom_biweekly": lambda **kw: FactorComboStrategy("down_resil+qual_mom", rebal_freq=10),
|
|
"fc_down_resil_qual_mom_monthly": lambda **kw: FactorComboStrategy("down_resil+qual_mom", rebal_freq=21),
|
|
"fc_rec63_mom_gap_daily": lambda **kw: FactorComboStrategy("rec63+mom_gap", rebal_freq=1),
|
|
"fc_rec63_mom_gap_weekly": lambda **kw: FactorComboStrategy("rec63+mom_gap", rebal_freq=5),
|
|
"fc_rec63_mom_gap_biweekly": lambda **kw: FactorComboStrategy("rec63+mom_gap", rebal_freq=10),
|
|
"fc_rec63_mom_gap_monthly": lambda **kw: FactorComboStrategy("rec63+mom_gap", rebal_freq=21),
|
|
"fc_up_cap_mom_gap_daily": lambda **kw: FactorComboStrategy("up_cap+mom_gap", rebal_freq=1),
|
|
"fc_up_cap_mom_gap_weekly": lambda **kw: FactorComboStrategy("up_cap+mom_gap", rebal_freq=5),
|
|
"fc_up_cap_mom_gap_biweekly": lambda **kw: FactorComboStrategy("up_cap+mom_gap", rebal_freq=10),
|
|
"fc_up_cap_mom_gap_monthly": lambda **kw: FactorComboStrategy("up_cap+mom_gap", rebal_freq=21),
|
|
# --- ETF tactical allocation strategies ---
|
|
"trend_rider_v3_us": lambda **kw: TrendRiderV3(),
|
|
"trend_rider_v3_global": lambda **kw: TrendRiderV3(
|
|
risk_on=("TQQQ", "UPRO", "YINN", "CHAU"),
|
|
risk_off=("GLD", "DBC"),
|
|
),
|
|
"trend_rider_v3_hk": lambda **kw: TrendRiderV3(
|
|
risk_on=("7200.HK", "7500.HK"),
|
|
risk_off=("GLD", "DBC"),
|
|
),
|
|
"trend_rider_v4": lambda **kw: TrendRiderV4(),
|
|
# --- V5: V3 + conviction-gated leverage tier modulator ---
|
|
"trend_rider_v5_us": lambda **kw: TrendRiderV5(),
|
|
"trend_rider_v5_panic": lambda **kw: TrendRiderV5(
|
|
panic_vol_ratio=1.4, panic_peak_drop_pct=0.03,
|
|
),
|
|
"trend_rider_v5_global": lambda **kw: TrendRiderV5(
|
|
risk_on=("TQQQ", "UPRO", "YINN", "CHAU"),
|
|
risk_off=("GLD", "DBC"),
|
|
),
|
|
# --- Vol-targeted variants (smoother equity, tighter drawdowns) ---
|
|
"trend_rider_v3_vt28": lambda **kw: TrendRiderV3VolTarget(
|
|
target_vol=0.28, min_lev=0.6,
|
|
),
|
|
"trend_rider_v3_vt28_ief": lambda **kw: TrendRiderV3VolTarget(
|
|
target_vol=0.28, min_lev=0.6, risk_off=("GLD", "DBC", "IEF"),
|
|
),
|
|
"trend_rider_v3_vt32": lambda **kw: TrendRiderV3VolTarget(
|
|
target_vol=0.32, min_lev=0.7,
|
|
),
|
|
"trend_rider_v3_vt24": lambda **kw: TrendRiderV3VolTarget(
|
|
target_vol=0.24, min_lev=0.5,
|
|
),
|
|
"trend_rider_v5_vt30": lambda **kw: TrendRiderV5VolTarget(
|
|
target_vol=0.30, min_lev=0.6,
|
|
),
|
|
# --- V7: V3 + vol-target + profit-take for leveraged ETFs ---
|
|
"trend_rider_v7": lambda **kw: TrendRiderV7(),
|
|
"trend_rider_v7_vt24": lambda **kw: TrendRiderV7(target_vol=0.24, min_lev=0.5),
|
|
"trend_rider_v7_vt32": lambda **kw: TrendRiderV7(target_vol=0.32, min_lev=0.7),
|
|
"trend_rider_v7_vt36": lambda **kw: TrendRiderV7(target_vol=0.36, min_lev=0.75),
|
|
# --- Stock-picker ensemble strategies (S&P 500 universe) ---
|
|
"ensemble_alpha_top10": lambda **kw: EnsembleAlphaStrategy(top_n=10),
|
|
"ensemble_alpha_top12": lambda **kw: EnsembleAlphaStrategy(top_n=12),
|
|
"ensemble_alpha_top15_tail": lambda **kw: EnsembleAlphaStrategy(
|
|
top_n=15, tail_protection=True, tail_threshold=-0.12, tail_scale=0.4,
|
|
),
|
|
"enhanced_factor_combo_top10": lambda **kw: EnhancedFactorComboStrategy(top_n=10),
|
|
"risk_managed_ensemble_top10": lambda **kw: RiskManagedEnsembleStrategy(top_n=10),
|
|
"sharpe_boosted_ensemble_top8": lambda **kw: SharpeBoostedEnsembleStrategy(top_n=8),
|
|
"sharpe_boosted_ensemble_top12_rebal63": lambda **kw: SharpeBoostedEnsembleStrategy(
|
|
top_n=12, rebal_freq=63,
|
|
),
|
|
# --- Research-round stock strategies ---
|
|
"composite_alpha_top20": lambda **kw: CompositeAlphaStrategy(top_n=20),
|
|
"composite_alpha_top10": lambda **kw: CompositeAlphaStrategy(top_n=10),
|
|
"enhanced_recovery_top20": lambda **kw: EnhancedRecoveryMomentumStrategy(top_n=20),
|
|
"enhanced_recovery_top10": lambda **kw: EnhancedRecoveryMomentumStrategy(top_n=10),
|
|
"hybrid_alpha_top20": lambda **kw: HybridAlphaStrategy(top_n=20),
|
|
"hybrid_alpha_top10": lambda **kw: HybridAlphaStrategy(top_n=10),
|
|
"recovery_quality_blend_top20": lambda **kw: RecoveryQualityBlendStrategy(top_n=20),
|
|
"recovery_quality_blend_top10": lambda **kw: RecoveryQualityBlendStrategy(top_n=10),
|
|
"improved_mom_quality_top20": lambda **kw: ImprovedMomentumQualityStrategy(top_n=20),
|
|
"improved_mom_quality_top10": lambda **kw: ImprovedMomentumQualityStrategy(top_n=10),
|
|
# --- Robust momentum (2026-09 PIT research; bar strategies) ---
|
|
"overnight_recovery_top10": lambda **kw: RobustMomentumStrategy(
|
|
"overnight_recovery", top_n=10, rebal_freq=10, buffer=2.0,
|
|
),
|
|
"lowrisk_momentum_top15": lambda **kw: RobustMomentumStrategy(
|
|
"lowrisk_momentum", top_n=15, rebal_freq=10, buffer=2.0,
|
|
),
|
|
"lowbeta_sharpe_mom_top20": lambda **kw: RobustMomentumStrategy(
|
|
"lowbeta_sharpe_mom", top_n=20, rebal_freq=10, buffer=1.0,
|
|
),
|
|
# --- TrendRiderV6: stock-picking + V5 regime engine ---
|
|
"trend_rider_v6": lambda **kw: TrendRiderV6(),
|
|
"trend_rider_v6_top10": lambda **kw: TrendRiderV6(top_n=10),
|
|
}
|
|
|
|
ETF_STRATEGY_UNIVERSES = {
|
|
"trend_rider_v3_us": sorted(set(ETF_UNIVERSE)),
|
|
"trend_rider_v3_global": sorted(set(GLOBAL_ETF_UNIVERSE)),
|
|
"trend_rider_v3_hk": sorted(set(HK_ETF_UNIVERSE)),
|
|
"trend_rider_v4": sorted(set(TREND_RIDER_V4_UNIVERSE)),
|
|
"trend_rider_v5_us": sorted(set(ETF_UNIVERSE)),
|
|
"trend_rider_v5_panic": sorted(set(ETF_UNIVERSE)),
|
|
"trend_rider_v5_global": sorted(set(GLOBAL_ETF_UNIVERSE)),
|
|
"trend_rider_v3_vt28": sorted(set(ETF_UNIVERSE)),
|
|
"trend_rider_v3_vt28_ief": sorted(set(ETF_UNIVERSE + ["IEF"])),
|
|
"trend_rider_v3_vt32": sorted(set(ETF_UNIVERSE)),
|
|
"trend_rider_v3_vt24": sorted(set(ETF_UNIVERSE)),
|
|
"trend_rider_v5_vt30": sorted(set(ETF_UNIVERSE)),
|
|
"trend_rider_v7": sorted(set(ETF_UNIVERSE)),
|
|
"trend_rider_v7_vt24": sorted(set(ETF_UNIVERSE)),
|
|
"trend_rider_v7_vt32": sorted(set(ETF_UNIVERSE)),
|
|
"trend_rider_v7_vt36": sorted(set(ETF_UNIVERSE)),
|
|
}
|
|
|
|
# Strategies that use the market's stock universe PLUS fixed extra ETF tickers.
|
|
# These are NOT pure-ETF strategies — they need both stocks and ETFs in the panel.
|
|
MIXED_STRATEGY_EXTRA_TICKERS = {
|
|
"trend_rider_v6": sorted(set(ETF_UNIVERSE)),
|
|
"trend_rider_v6_top10": sorted(set(ETF_UNIVERSE)),
|
|
}
|
|
|
|
# Registered strategies the live monitor does not run, with the reason.
|
|
LIVE_EXCLUDED_STRATEGIES = {
|
|
"buy_and_hold": "equal weight across ~500 names is not investable with whole "
|
|
"shares at live capital (every slice is below the minimum trade)",
|
|
}
|
|
|
|
DEFAULT_MONITOR_STRATEGIES = [
|
|
name for name in STRATEGY_REGISTRY if name not in LIVE_EXCLUDED_STRATEGIES
|
|
]
|
|
|
|
|
|
def strategy_extra_tickers(strategy_name: str) -> list[str]:
|
|
"""Fixed ETF tickers a mixed stock+ETF strategy needs beside its stock universe."""
|
|
return list(MIXED_STRATEGY_EXTRA_TICKERS.get(strategy_name.removeprefix("sim_"), []))
|
|
|
|
|
|
def strategy_fields(strategy_name: str) -> tuple[str, ...]:
|
|
"""Bar fields a strategy reads; close-price strategies read ("close",)."""
|
|
strategy = STRATEGY_REGISTRY[strategy_name.removeprefix("sim_")]()
|
|
return tuple(strategy.fields) if isinstance(strategy, BarStrategy) else ("close",)
|
|
|
|
|
|
def strategy_supports_market(strategy_name: str, market: str) -> bool:
|
|
"""ETF-based strategies trade USD-listed ETFs, so they only run in the US book."""
|
|
base_name = strategy_name.removeprefix("sim_")
|
|
if base_name in ETF_STRATEGY_UNIVERSES or base_name in MIXED_STRATEGY_EXTRA_TICKERS:
|
|
return market == "us"
|
|
return True
|
|
|
|
|
|
def strategy_universe(market: str, strategy_name: str) -> tuple[list[str], str]:
|
|
"""Return tradable tickers and benchmark for a strategy.
|
|
|
|
Stock strategies use the market's dynamic universe. TrendRider variants
|
|
trade fixed USD/HK ETF baskets and use SPY as the regime benchmark.
|
|
Mixed strategies (e.g. V6) get the stock universe + extra ETF tickers.
|
|
"""
|
|
base_name = strategy_name.removeprefix("sim_")
|
|
if base_name in ETF_STRATEGY_UNIVERSES:
|
|
return ETF_STRATEGY_UNIVERSES[base_name], "SPY"
|
|
|
|
universe = UNIVERSES[market]
|
|
tickers = universe["fetch"]()
|
|
|
|
if base_name in MIXED_STRATEGY_EXTRA_TICKERS:
|
|
extras = MIXED_STRATEGY_EXTRA_TICKERS[base_name]
|
|
tickers = sorted(set(tickers + extras))
|
|
|
|
return tickers, universe["benchmark"]
|
|
|
|
|
|
def strategy_data_market(market: str, strategy_name: str) -> str:
|
|
"""Return the cache namespace used for a strategy's price data."""
|
|
base_name = strategy_name.removeprefix("sim_")
|
|
return "etfs" if base_name in ETF_STRATEGY_UNIVERSES else market
|
|
|
|
|
|
def filter_tradable_tickers(price_data: pd.DataFrame, tickers: list[str]) -> list[str]:
|
|
"""Keep requested tickers that are present in a downloaded price panel."""
|
|
return [t for t in tickers if t in price_data.columns]
|
|
|
|
|
|
def _hk_columns(columns) -> list[str]:
|
|
return [c for c in columns if str(c).endswith(".HK")]
|
|
|
|
|
|
def convert_quote_currency(panel: pd.DataFrame) -> pd.DataFrame:
|
|
"""Express HK-listed tickers of a USD panel in USD using the HKD=X series."""
|
|
hk = _hk_columns(panel.columns)
|
|
if not hk:
|
|
return panel
|
|
if HKD_FX_TICKER in panel.columns:
|
|
fx = panel[HKD_FX_TICKER].ffill().bfill().fillna(HKD_PEG_MIDPOINT)
|
|
else:
|
|
print(f" WARNING: {HKD_FX_TICKER} not in panel; converting HK prices at "
|
|
f"the peg midpoint {HKD_PEG_MIDPOINT}", file=sys.stderr)
|
|
fx = pd.Series(HKD_PEG_MIDPOINT, index=panel.index)
|
|
out = panel.copy()
|
|
out[hk] = out[hk].div(fx, axis=0)
|
|
return out
|
|
|
|
|
|
def price_request(market: str, tickers: list[str]) -> list[str]:
|
|
"""Tickers to download for a USD panel, including FX needed for conversion."""
|
|
request = sorted(set(tickers))
|
|
if market != "cn" and _hk_columns(request):
|
|
request.append(HKD_FX_TICKER)
|
|
return request
|
|
|
|
|
|
def load_strategy_prices(market: str, strategy_name: str, tickers: list[str],
|
|
benchmark: str, with_open: bool = False, refresh: bool = True):
|
|
"""Load a strategy's prices in its portfolio currency, refreshing them first
|
|
unless ``refresh`` is False (the panel is then read as stored).
|
|
|
|
Returns ``(close, open_or_None, close_raw)``. ``close_raw`` keeps NaN
|
|
where the exchange printed no bar that day, so callers can distinguish a
|
|
stale forward-filled price from a real one.
|
|
"""
|
|
data_market = strategy_data_market(market, strategy_name)
|
|
fields = ["close", "open"] if with_open else ["close"]
|
|
fields += [f for f in strategy_fields(strategy_name) if f not in fields]
|
|
if refresh:
|
|
request = price_request(market, list(tickers) + [benchmark])
|
|
panels = data_manager.update(data_market, request, fields=fields)
|
|
else:
|
|
panels = data_manager.load_fields(data_market, fields)
|
|
close = panels["close"]
|
|
open_data = panels["open"] if with_open else None
|
|
close_raw = data_manager.load_raw(data_market, "close").reindex(
|
|
index=close.index, columns=close.columns,
|
|
)
|
|
close = convert_quote_currency(close)
|
|
close_raw = convert_quote_currency(close_raw)
|
|
if open_data is not None:
|
|
open_data = convert_quote_currency(open_data)
|
|
return close, open_data, close_raw
|
|
|
|
|
|
def completed_sessions(close_raw: pd.DataFrame, data_market: str, benchmark: str,
|
|
now: datetime | None = None) -> pd.DatetimeIndex:
|
|
"""Trading days whose closing prices are final.
|
|
|
|
Stored panel rows are trading days (sparse rows are dropped on update).
|
|
The ETF panel mixes US and HK listings, so there a day also needs a
|
|
benchmark (SPY) print. Today's bar is excluded until the exchange has
|
|
closed and settled, because before that it is an intraday snapshot.
|
|
"""
|
|
index = close_raw.index
|
|
if data_market == "etfs" and benchmark in close_raw.columns:
|
|
index = index[close_raw[benchmark].notna().to_numpy()]
|
|
tz_name, hour, minute = MARKET_SESSION.get(data_market, MARKET_SESSION["us"])
|
|
now_local = (now or datetime.now(timezone.utc)).astimezone(zoneinfo.ZoneInfo(tz_name))
|
|
today = pd.Timestamp(now_local.date())
|
|
settled = now_local.replace(hour=hour, minute=minute, second=0, microsecond=0) + timedelta(
|
|
minutes=SESSION_SETTLE_MINUTES,
|
|
)
|
|
return index[index < today] if now_local < settled else index[index <= today]
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Persistent state
|
|
# ---------------------------------------------------------------------------
|
|
|
|
def _state_path(market: str, strategy_name: str) -> str:
|
|
return os.path.join("data", f"trader_{market}_{strategy_name}.json")
|
|
|
|
|
|
def load_state(market: str, strategy_name: str) -> dict:
|
|
path = _state_path(market, strategy_name)
|
|
if os.path.exists(path):
|
|
with open(path) as f:
|
|
return json.load(f)
|
|
return {}
|
|
|
|
|
|
def save_state(state: dict, market: str, strategy_name: str) -> None:
|
|
os.makedirs("data", exist_ok=True)
|
|
path = _state_path(market, strategy_name)
|
|
with open(path, "w") as f:
|
|
json.dump(state, f, indent=2, default=str)
|
|
|
|
|
|
def init_state(market: str, strategy_name: str, capital: float) -> dict:
|
|
return {
|
|
"strategy": strategy_name,
|
|
"market": market,
|
|
"initial_capital": capital,
|
|
"cash": capital,
|
|
"holdings": {}, # ticker -> shares (float)
|
|
"pending_trades": None, # set by morning, consumed by evening
|
|
"trade_log": [], # list of trade dicts
|
|
"daily_equity": {}, # date_str -> portfolio value
|
|
"daily_log": [], # list of per-day snapshots (holdings, cash, trades)
|
|
"last_morning": None,
|
|
"last_evening": None,
|
|
}
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Core logic
|
|
# ---------------------------------------------------------------------------
|
|
|
|
def portfolio_value(holdings: dict, prices: dict, cash: float) -> float:
|
|
stock_value = sum(holdings.get(t, 0) * prices.get(t, 0) for t in holdings)
|
|
return cash + stock_value
|
|
|
|
|
|
def strategy_bars(market: str, strategy_name: str, tickers: list[str],
|
|
close: pd.DataFrame, open_data: pd.DataFrame | None) -> dict | None:
|
|
"""Stored bar panels a BarStrategy reads (refreshed by load_strategy_prices),
|
|
aligned to ``close``; None for close-price strategies."""
|
|
fields = strategy_fields(strategy_name)
|
|
if not isinstance(STRATEGY_REGISTRY[strategy_name.removeprefix("sim_")](), BarStrategy):
|
|
return None
|
|
stored = data_manager.load_fields(strategy_data_market(market, strategy_name),
|
|
[f for f in fields if f not in ("close", "open")])
|
|
bars = {"close": close[tickers]}
|
|
if "open" in fields:
|
|
bars["open"] = open_data[tickers]
|
|
for f in fields:
|
|
if f not in bars:
|
|
bars[f] = stored[f].reindex(index=close.index, columns=tickers)
|
|
return bars
|
|
|
|
|
|
def bar_session_weights(strategy: BarStrategy, bars: dict, days: pd.DatetimeIndex) -> pd.DataFrame:
|
|
"""Targets traded at the close of each day in ``days``: row d uses bars through d-1."""
|
|
hist = {f: b.loc[:days[-1]] for f, b in bars.items()}
|
|
close = hist["close"]
|
|
if days[-1] not in close.index:
|
|
# morning run before today's bar exists: add an empty row for today
|
|
hist = {f: pd.concat([b, pd.DataFrame(np.nan, index=[days[-1]], columns=b.columns)])
|
|
for f, b in hist.items()}
|
|
return strategy.generate_signals(hist).reindex(days).fillna(0.0)
|
|
|
|
|
|
def _allocate_lots(desired: dict, holdings: dict, prices: dict, cash: float,
|
|
lot_size: int, reserve: float) -> dict:
|
|
"""Whole-lot share targets: round each move toward zero, then spend the
|
|
remaining cash one lot at a time on the names furthest below target,
|
|
as long as the lot brings them nearer (nearest-lot rounding)."""
|
|
final, spend = {}, 0.0
|
|
for t, want in desired.items():
|
|
cur = holdings.get(t, 0.0)
|
|
if want <= 0:
|
|
final[t] = 0.0 # full exit, odd lot included
|
|
else:
|
|
final[t] = cur + int((want - cur) / lot_size) * lot_size
|
|
spend += (final[t] - cur) * prices[t]
|
|
budget = cash - spend - reserve
|
|
short = sorted(((desired[t] - final[t]) * prices[t], t) for t in desired if desired[t] > 0)
|
|
for gap, t in reversed(short):
|
|
lot_value = lot_size * prices[t]
|
|
if gap > 0.5 * lot_value and lot_value <= budget:
|
|
final[t] += lot_size
|
|
budget -= lot_value
|
|
return final
|
|
|
|
|
|
def compute_trades(holdings: dict, cash: float, target_weights: dict,
|
|
prices: dict, min_trade_value: float = 50.0,
|
|
integer_shares: bool = False, lot_size: int = 1,
|
|
frozen: set | None = None, resize_band: float = 0.0) -> list[dict]:
|
|
"""
|
|
Compute trades needed to move from current holdings to target weights.
|
|
|
|
If integer_shares=True, positions move in whole multiples of ``lot_size``
|
|
(e.g. 100-share A-share board lots): each move is rounded toward zero and
|
|
leftover cash then buys one more lot for the names furthest below target
|
|
when that lot brings them nearer; a position whose target is zero is
|
|
always sold in full, odd lot included.
|
|
A held position with a nonzero target is not resized while it is within
|
|
``resize_band`` (fraction of its target value) of the target.
|
|
Tickers in ``frozen`` (no fresh price today) are neither bought nor sold.
|
|
|
|
Returns list of {ticker, shares_delta, direction, est_value}.
|
|
"""
|
|
total = portfolio_value(holdings, prices, cash)
|
|
frozen = frozen or set()
|
|
desired = {}
|
|
for ticker in sorted(set(target_weights) | set(holdings)):
|
|
if ticker in frozen:
|
|
continue
|
|
price = prices.get(ticker, 0.0)
|
|
if price <= 0:
|
|
continue
|
|
target_weight = target_weights.get(ticker, 0.0)
|
|
target_value = total * target_weight
|
|
current_shares = holdings.get(ticker, 0.0)
|
|
if (current_shares > 0 and target_weight > 0
|
|
and abs(target_value - current_shares * price) < resize_band * target_value):
|
|
continue
|
|
desired[ticker] = target_value / price
|
|
|
|
targets = (_allocate_lots(desired, holdings, prices, cash, lot_size,
|
|
reserve=0.002 * total + 10.0 * len(desired))
|
|
if integer_shares else desired)
|
|
|
|
raw = []
|
|
for ticker, target_shares in targets.items():
|
|
price = prices[ticker]
|
|
current_shares = holdings.get(ticker, 0.0)
|
|
delta = target_shares - current_shares
|
|
trade_value = abs(delta * price)
|
|
if trade_value < min_trade_value:
|
|
continue
|
|
if integer_shares and abs(delta) < 1:
|
|
continue
|
|
|
|
raw.append({
|
|
"ticker": ticker,
|
|
"shares_delta": int(round(delta)) if integer_shares else round(delta, 4),
|
|
"direction": "BUY" if delta > 0 else "SELL",
|
|
"est_value": round(trade_value, 2),
|
|
"price": round(price, 6),
|
|
"target_shares": int(round(target_shares)) if integer_shares else round(target_shares, 4),
|
|
"current_shares": int(current_shares) if integer_shares else round(current_shares, 4),
|
|
})
|
|
|
|
return raw
|
|
|
|
|
|
def _per_trade_commission(
|
|
shares: float,
|
|
price: float,
|
|
tx_cost: float,
|
|
fixed_fee: float,
|
|
fee_base: float = 0.0,
|
|
fee_per_share: float = 0.0,
|
|
) -> float:
|
|
"""Commission for one trade.
|
|
|
|
Matches the IBKR-style tiered formula used by the backtest engine:
|
|
commission = bps_cost + max(fixed_fee, fee_base + fee_per_share * shares)
|
|
With fee_base=0 and fee_per_share=0 this degenerates to the flat
|
|
fixed-fee model (legacy behavior).
|
|
"""
|
|
bps_cost = abs(shares) * price * tx_cost
|
|
per_trade = fee_base + fee_per_share * abs(shares)
|
|
floor = max(fixed_fee, per_trade)
|
|
return bps_cost + floor
|
|
|
|
|
|
def execute_trades(state: dict, trades: list[dict], prices: dict,
|
|
tx_cost: float = 0.001, fixed_fee: float = 0.0,
|
|
fee_base: float = 0.0, fee_per_share: float = 0.0,
|
|
trade_date: str = "", integer_shares: bool = False,
|
|
lot_size: int = 1) -> None:
|
|
"""Execute trades: update holdings and cash in state, append to trade_log.
|
|
|
|
When integer_shares=True, sells are executed first to free up cash,
|
|
then buys are executed only if sufficient cash is available.
|
|
|
|
Per-trade commission supports both the legacy flat ``fixed_fee`` and
|
|
the IBKR-style tiered ``max(fixed_fee, fee_base + fee_per_share*shares)``
|
|
schedule used by the backtest engine.
|
|
"""
|
|
holdings = state["holdings"]
|
|
cash = state["cash"]
|
|
|
|
# When using integer shares, execute sells first to free cash for buys
|
|
sells = [t for t in trades if t["shares_delta"] < 0]
|
|
buys = [t for t in trades if t["shares_delta"] > 0]
|
|
ordered = sells + buys if integer_shares else trades
|
|
|
|
us_fee_per_share = fee_per_share
|
|
for trade in ordered:
|
|
ticker = trade["ticker"]
|
|
delta = trade["shares_delta"]
|
|
price = prices.get(ticker, trade["price"])
|
|
cost = abs(delta * price)
|
|
# The per-share schedule applies to US-listed shares only; HK lines
|
|
# (often < $1/share) pay the proportional cost and the ticket floor.
|
|
fee_per_share = 0.0 if ticker.endswith(".HK") else us_fee_per_share
|
|
commission = _per_trade_commission(
|
|
abs(delta), price, tx_cost, fixed_fee, fee_base, fee_per_share,
|
|
)
|
|
|
|
if delta > 0:
|
|
# BUY — skip if insufficient cash in integer mode
|
|
if integer_shares and (cost + commission) > cash:
|
|
# Try buying fewer shares that we can afford, accounting for
|
|
# the per-share variable component of the commission.
|
|
affordable_price_unit = price * (1 + tx_cost) + fee_per_share
|
|
if affordable_price_unit <= 0:
|
|
continue
|
|
affordable = int((cash - max(fixed_fee, fee_base)) / affordable_price_unit)
|
|
affordable = affordable // lot_size * lot_size
|
|
if affordable < 1:
|
|
continue
|
|
delta = affordable
|
|
cost = abs(delta * price)
|
|
commission = _per_trade_commission(
|
|
delta, price, tx_cost, fixed_fee, fee_base, fee_per_share,
|
|
)
|
|
cash -= (cost + commission)
|
|
holdings[ticker] = holdings.get(ticker, 0.0) + delta
|
|
else:
|
|
# SELL
|
|
cash += (cost - commission)
|
|
holdings[ticker] = holdings.get(ticker, 0.0) + delta # delta is negative
|
|
|
|
# Remove zero holdings
|
|
if ticker in holdings and abs(holdings[ticker]) < (0.5 if integer_shares else 0.001):
|
|
del holdings[ticker]
|
|
|
|
state["trade_log"].append({
|
|
"date": trade_date,
|
|
"action": "BUY" if delta > 0 else "SELL",
|
|
"ticker": ticker,
|
|
"shares": abs(delta) if integer_shares else round(abs(delta), 4),
|
|
"price": round(price, 6),
|
|
"value": round(cost, 2),
|
|
"commission": round(commission, 2),
|
|
})
|
|
|
|
state["cash"] = round(cash, 2)
|
|
if integer_shares:
|
|
state["holdings"] = {k: int(round(v)) for k, v in holdings.items() if abs(v) >= 0.5}
|
|
else:
|
|
state["holdings"] = {k: round(v, 4) for k, v in holdings.items() if abs(v) >= 0.001}
|
|
|
|
|
|
def record_daily_snapshot(state: dict, date_str: str, prices: dict,
|
|
trades: list[dict], prev_equity: float) -> None:
|
|
"""Append a daily snapshot to state['daily_log'].
|
|
|
|
Each entry captures the full picture: date, holdings with prices/values,
|
|
cash, total equity, daily return, and today's operations.
|
|
"""
|
|
holdings = state["holdings"]
|
|
cash = state["cash"]
|
|
total = portfolio_value(holdings, prices, cash)
|
|
daily_ret = (total / prev_equity - 1) * 100 if prev_equity > 0 else 0.0
|
|
|
|
# Holdings detail: ticker -> {shares, price, value}
|
|
positions = {}
|
|
for ticker, shares in sorted(holdings.items()):
|
|
p = prices.get(ticker, 0.0)
|
|
positions[ticker] = {
|
|
"shares": shares,
|
|
"price": round(p, 6),
|
|
"value": round(shares * p, 2),
|
|
}
|
|
|
|
# Operations: list of {action, ticker, shares, price, value, commission}
|
|
operations = []
|
|
for t in trades:
|
|
p = prices.get(t["ticker"], t["price"])
|
|
operations.append({
|
|
"action": t["direction"],
|
|
"ticker": t["ticker"],
|
|
"shares": abs(t["shares_delta"]),
|
|
"price": round(p, 6),
|
|
"value": round(abs(t["shares_delta"]) * p, 2),
|
|
})
|
|
|
|
entry = {
|
|
"date": date_str,
|
|
"equity": round(total, 2),
|
|
"cash": round(cash, 2),
|
|
"daily_return_pct": round(daily_ret, 2),
|
|
"n_positions": len(holdings),
|
|
"n_trades": len(trades),
|
|
"holdings": positions,
|
|
"operations": operations,
|
|
}
|
|
|
|
if "daily_log" not in state:
|
|
state["daily_log"] = []
|
|
state["daily_log"].append(entry)
|
|
|
|
|
|
def get_prices_for_date(tickers: list[str], date_idx, price_df: pd.DataFrame) -> dict:
|
|
"""Extract prices for specific tickers on a given date from a DataFrame."""
|
|
if date_idx in price_df.index:
|
|
row = price_df.loc[date_idx]
|
|
else:
|
|
idx = price_df.index.get_indexer([date_idx], method="ffill")
|
|
if idx[0] >= 0:
|
|
row = price_df.iloc[idx[0]]
|
|
else:
|
|
return {}
|
|
return {t: float(row[t]) for t in tickers if t in row.index and pd.notna(row[t])}
|
|
|
|
|
|
def _with_last_known_prices(state: dict, prices: dict) -> dict:
|
|
"""Fill prices of held tickers missing from the panel with their last recorded price.
|
|
|
|
Without this a holding that drops out of the price panel would be valued
|
|
at zero and could never be sold.
|
|
"""
|
|
missing = [t for t in state["holdings"] if t not in prices]
|
|
if not missing:
|
|
return prices
|
|
out = dict(prices)
|
|
for entry in reversed(state.get("daily_log", [])):
|
|
for ticker in missing:
|
|
if ticker not in out:
|
|
price = entry.get("holdings", {}).get(ticker, {}).get("price")
|
|
if price:
|
|
out[ticker] = float(price)
|
|
if all(t in out for t in missing):
|
|
break
|
|
still = [t for t in missing if t not in out]
|
|
print(f" WARNING: no panel price for held {missing}; "
|
|
f"{'unvalued: ' + str(still) if still else 'using last recorded prices'}")
|
|
return out
|
|
|
|
|
|
def _strategy_fees(args, market: str) -> dict:
|
|
tier = MARKET_FEE_TIERED.get(market, {})
|
|
return {
|
|
"tx_cost": args.tx_cost,
|
|
"fixed_fee": args.fixed_fee if args.fixed_fee > 0 else MARKET_FEES.get(market, 0.0),
|
|
"fee_base": tier.get("fee_base", 0.0),
|
|
"fee_per_share": tier.get("fee_per_share", 0.0),
|
|
}
|
|
|
|
|
|
def _signals_for_sessions(strategy_name: str, open_data: pd.DataFrame,
|
|
days: pd.DatetimeIndex, bars: dict | None = None) -> pd.DataFrame:
|
|
"""Target weights traded at the close of each day in ``days``, in one pass.
|
|
|
|
A close-price strategy reads opens as its prices: the row for ``d`` uses
|
|
opens up to ``d`` (a dummy row after the last open makes the strategy's
|
|
internal shift(1) yield that row). A BarStrategy uses completed bars
|
|
through d-1. Every registered strategy must be causal (weights at t never
|
|
depend on data after t), so one pass equals running each day separately.
|
|
"""
|
|
strategy = STRATEGY_REGISTRY[strategy_name]()
|
|
if isinstance(strategy, BarStrategy):
|
|
return bar_session_weights(strategy, bars, days)
|
|
hist = open_data.loc[:days[-1]]
|
|
dummy = pd.DataFrame([hist.iloc[-1].values], index=[hist.index[-1] + pd.Timedelta(days=1)],
|
|
columns=hist.columns)
|
|
weights = strategy.generate_signals(pd.concat([hist, dummy]))
|
|
return weights.shift(-1).reindex(days).fillna(0.0)
|
|
|
|
|
|
def _run_session(state: dict, strategy_name: str, market: str, day: pd.Timestamp,
|
|
tickers: list[str], benchmark: str, close_data: pd.DataFrame,
|
|
open_data: pd.DataFrame, close_raw: pd.DataFrame, fees: dict,
|
|
integer_shares: bool, signal_row: pd.Series | None = None,
|
|
bars: dict | None = None) -> dict:
|
|
"""Signal on ``day``'s open (a BarStrategy: bars through the previous
|
|
session), execute at ``day``'s close, record the day.
|
|
|
|
Tickers without a real closing print on ``day`` (forward-filled price) are
|
|
valued but not traded. ``signal_row`` supplies precomputed target weights.
|
|
"""
|
|
day_str = str(day.date())
|
|
lot_size = MARKET_LOT_SIZE.get(market, 1) if integer_shares else 1
|
|
if signal_row is None:
|
|
signal_row = _signals_for_sessions(strategy_name, open_data[tickers],
|
|
pd.DatetimeIndex([day]), bars).loc[day]
|
|
target_weights = {t: float(w) for t, w in signal_row.items() if w > 1e-6}
|
|
|
|
all_held = sorted(set(target_weights) | set(state["holdings"]))
|
|
close_prices = _with_last_known_prices(
|
|
state, get_prices_for_date(all_held + [benchmark], day, close_data),
|
|
)
|
|
raw_row = close_raw.loc[day]
|
|
frozen = {t for t in all_held if t not in raw_row.index or pd.isna(raw_row[t])}
|
|
|
|
pre_value = portfolio_value(state["holdings"], close_prices, state["cash"])
|
|
trades = compute_trades(
|
|
state["holdings"], state["cash"], target_weights, close_prices,
|
|
min_trade_value=max(50, pre_value * 0.001),
|
|
integer_shares=integer_shares, lot_size=lot_size, frozen=frozen,
|
|
resize_band=RESIZE_BAND,
|
|
)
|
|
n_log = len(state["trade_log"])
|
|
execute_trades(state, trades, close_prices, trade_date=day_str,
|
|
integer_shares=integer_shares, lot_size=lot_size, **fees)
|
|
post_value = portfolio_value(state["holdings"], close_prices, state["cash"])
|
|
|
|
previous = [d for d in sorted(state["daily_equity"]) if d < day_str]
|
|
prev_eq = state["daily_equity"][previous[-1]] if previous else state["initial_capital"]
|
|
state["daily_equity"][day_str] = round(post_value, 2)
|
|
record_daily_snapshot(state, day_str, close_prices, trades, prev_eq)
|
|
state["last_morning"] = day_str
|
|
state["last_evening"] = day_str
|
|
state["pending_trades"] = None
|
|
return {
|
|
"date": day_str,
|
|
"value": post_value,
|
|
"daily_return": post_value / prev_eq - 1 if prev_eq else 0.0,
|
|
"trades": len(state["trade_log"]) - n_log,
|
|
"commission": sum(t["commission"] for t in state["trade_log"][n_log:]),
|
|
"frozen": sorted(t for t in frozen if t in state["holdings"] or t in target_weights),
|
|
"positions": len(state["holdings"]),
|
|
}
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Commands
|
|
# ---------------------------------------------------------------------------
|
|
|
|
def cmd_morning(args):
|
|
"""Morning: download open prices, generate today's trade orders."""
|
|
market = args.market
|
|
strategy_name = args.strategy
|
|
if not strategy_supports_market(strategy_name, market):
|
|
print(f"{strategy_name} does not run in the {market.upper()} book; skipping.")
|
|
return
|
|
tickers, benchmark = strategy_universe(market, strategy_name)
|
|
|
|
# Load or init state
|
|
state = load_state(market, strategy_name)
|
|
if not state:
|
|
capital = args.capital or MONITOR_CAPITAL.get(market, 10_000.0)
|
|
state = init_state(market, strategy_name, capital)
|
|
print(f"--- Initialized new portfolio: {capital:,.0f} cash ---")
|
|
|
|
# Download data (close + open)
|
|
close_data, open_data, _ = load_strategy_prices(
|
|
market, strategy_name, tickers, benchmark, with_open=True,
|
|
refresh=getattr(args, "refresh", True),
|
|
)
|
|
tickers = filter_tradable_tickers(close_data, tickers)
|
|
|
|
today = open_data.index[-1]
|
|
today_str = str(today.date())
|
|
|
|
if state["last_morning"] == today_str:
|
|
print(f"Morning already run for {today_str}. Showing pending trades.\n")
|
|
|
|
print(f"\n{'='*60}")
|
|
print(f" MORNING SIGNAL — {today_str}")
|
|
print(f" Strategy: {strategy_name} | Market: {market.upper()}")
|
|
print(f"{'='*60}")
|
|
|
|
# Run strategy on open prices (a BarStrategy: on completed bars)
|
|
bars = strategy_bars(market, strategy_name, tickers, close_data, open_data)
|
|
row = _signals_for_sessions(strategy_name, open_data[tickers],
|
|
pd.DatetimeIndex([today]), bars).loc[today]
|
|
target_weights = {t: float(w) for t, w in row.items() if w > 1e-6}
|
|
|
|
# Get today's open prices for trade computation
|
|
open_prices = get_prices_for_date(
|
|
list(set(list(target_weights.keys()) + list(state["holdings"].keys()))),
|
|
today, open_data
|
|
)
|
|
|
|
total = portfolio_value(state["holdings"], open_prices, state["cash"])
|
|
trades = compute_trades(state["holdings"], state["cash"], target_weights,
|
|
open_prices, min_trade_value=max(50, total * 0.001),
|
|
integer_shares=args.integer_shares,
|
|
lot_size=MARKET_LOT_SIZE.get(market, 1),
|
|
resize_band=RESIZE_BAND)
|
|
|
|
# Store pending
|
|
state["pending_trades"] = {
|
|
"date": today_str,
|
|
"target_weights": target_weights,
|
|
"trades": trades,
|
|
}
|
|
state["last_morning"] = today_str
|
|
save_state(state, market, strategy_name)
|
|
|
|
# Print summary
|
|
print(f"\n Portfolio value (at open): ${total:,.2f}")
|
|
print(f" Cash: ${state['cash']:,.2f}")
|
|
print(f" Target positions: {len(target_weights)}")
|
|
print(f" Trades needed: {len(trades)}")
|
|
|
|
if target_weights:
|
|
print(f"\n {'Target Weights':}")
|
|
print(f" {'Ticker':<8} {'Weight':>8} {'Open Price':>12}")
|
|
print(f" {'-'*30}")
|
|
for t, w in sorted(target_weights.items(), key=lambda x: -x[1]):
|
|
p = open_prices.get(t, 0)
|
|
print(f" {t:<8} {w:>7.1%} {p:>11.2f}")
|
|
|
|
if trades:
|
|
print(f"\n {'Trade Orders (execute at close)':}")
|
|
print(f" {'Action':<6} {'Ticker':<8} {'Shares':>10} {'~Value':>12} {'Open':>10}")
|
|
print(f" {'-'*48}")
|
|
total_buy = 0
|
|
total_sell = 0
|
|
for t in trades:
|
|
print(f" {t['direction']:<6} {t['ticker']:<8} {t['shares_delta']:>+10.2f} "
|
|
f"${t['est_value']:>10,.2f} {t['price']:>10.2f}")
|
|
if t["direction"] == "BUY":
|
|
total_buy += t["est_value"]
|
|
else:
|
|
total_sell += t["est_value"]
|
|
print(f"\n Total buys: ${total_buy:>12,.2f}")
|
|
print(f" Total sells: ${total_sell:>12,.2f}")
|
|
print(f" Net flow: ${total_sell - total_buy:>+12,.2f}")
|
|
else:
|
|
print("\n No trades needed today.")
|
|
|
|
print()
|
|
|
|
|
|
def cmd_evening(args):
|
|
"""Evening: record execution at close prices, update portfolio."""
|
|
market = args.market
|
|
strategy_name = args.strategy
|
|
tickers, benchmark = strategy_universe(market, strategy_name)
|
|
|
|
state = load_state(market, strategy_name)
|
|
if not state:
|
|
print("No state found. Run 'morning' first.")
|
|
return
|
|
|
|
if not state.get("pending_trades"):
|
|
print("No pending trades. Run 'morning' first.")
|
|
return
|
|
|
|
pending = state["pending_trades"]
|
|
trade_date = pending["date"]
|
|
|
|
if state["last_evening"] == trade_date:
|
|
print(f"Evening already recorded for {trade_date}.")
|
|
return
|
|
|
|
# Get close prices
|
|
close_data, _, _ = load_strategy_prices(market, strategy_name, tickers, benchmark)
|
|
tickers = filter_tradable_tickers(close_data, tickers)
|
|
|
|
target_date = pd.Timestamp(trade_date)
|
|
all_held = list(set(
|
|
list(pending.get("target_weights", {}).keys()) +
|
|
list(state["holdings"].keys())
|
|
))
|
|
close_prices = _with_last_known_prices(
|
|
state, get_prices_for_date(all_held, target_date, close_data),
|
|
)
|
|
|
|
# Recompute trades at close prices for accurate execution
|
|
trades = pending.get("trades", [])
|
|
|
|
print(f"\n{'='*60}")
|
|
print(f" EVENING EXECUTION — {trade_date}")
|
|
print(f" Strategy: {strategy_name} | Market: {market.upper()}")
|
|
print(f"{'='*60}")
|
|
|
|
pre_value = portfolio_value(state["holdings"], close_prices, state["cash"])
|
|
print(f"\n Pre-trade value: ${pre_value:,.2f}")
|
|
|
|
# Recompute trades with close prices for execution
|
|
target_weights = pending.get("target_weights", {})
|
|
lot_size = MARKET_LOT_SIZE.get(market, 1)
|
|
exec_trades = compute_trades(
|
|
state["holdings"], state["cash"], target_weights,
|
|
close_prices, min_trade_value=max(50, pre_value * 0.001),
|
|
integer_shares=args.integer_shares, lot_size=lot_size,
|
|
)
|
|
execute_trades(state, exec_trades, close_prices, trade_date=trade_date,
|
|
integer_shares=args.integer_shares, lot_size=lot_size,
|
|
**_strategy_fees(args, market))
|
|
|
|
post_value = portfolio_value(state["holdings"], close_prices, state["cash"])
|
|
state["daily_equity"][trade_date] = round(post_value, 2)
|
|
|
|
# Record daily snapshot so daily_log stays complete even on no-trade days
|
|
eq_vals = list(state["daily_equity"].values())
|
|
prev_eq = eq_vals[-2] if len(eq_vals) >= 2 else state["initial_capital"]
|
|
record_daily_snapshot(state, trade_date, close_prices, exec_trades, prev_eq)
|
|
|
|
state["pending_trades"] = None
|
|
state["last_evening"] = trade_date
|
|
save_state(state, market, strategy_name)
|
|
|
|
n_executed = len(exec_trades)
|
|
total_commission = sum(t.get("commission", 0)
|
|
for t in state["trade_log"][-n_executed:]) if n_executed else 0
|
|
|
|
print(f" Trades executed: {n_executed}")
|
|
print(f" Total commission: ${total_commission:,.2f}")
|
|
print(f" Post-trade value: ${post_value:,.2f}")
|
|
print(f" Cash remaining: ${state['cash']:,.2f}")
|
|
print(f" Holdings: {len(state['holdings'])} positions")
|
|
|
|
if exec_trades:
|
|
print(f"\n {'Executed':}")
|
|
print(f" {'Action':<6} {'Ticker':<8} {'Shares':>10} {'Close':>10} {'Value':>12}")
|
|
print(f" {'-'*48}")
|
|
for t in exec_trades:
|
|
p = close_prices.get(t["ticker"], t["price"])
|
|
v = abs(t["shares_delta"]) * p
|
|
print(f" {t['direction']:<6} {t['ticker']:<8} {t['shares_delta']:>+10.2f} "
|
|
f"{p:>10.2f} ${v:>10,.2f}")
|
|
|
|
pnl = post_value - state["initial_capital"]
|
|
pnl_pct = pnl / state["initial_capital"] * 100
|
|
print(f"\n P&L since inception: ${pnl:>+,.2f} ({pnl_pct:>+.2f}%)")
|
|
print()
|
|
|
|
|
|
def cmd_status(args):
|
|
"""Print current portfolio status."""
|
|
market = args.market
|
|
strategy_name = args.strategy
|
|
|
|
state = load_state(market, strategy_name)
|
|
if not state:
|
|
print("No state found. Run 'morning' to initialize.")
|
|
return
|
|
|
|
# Get latest prices
|
|
tickers, benchmark = strategy_universe(market, strategy_name)
|
|
close_data, _, _ = load_strategy_prices(market, strategy_name, tickers, benchmark)
|
|
|
|
last_date = close_data.index[-1]
|
|
all_held = list(state["holdings"].keys())
|
|
prices = _with_last_known_prices(
|
|
state, get_prices_for_date(all_held + [benchmark], last_date, close_data),
|
|
)
|
|
|
|
total = portfolio_value(state["holdings"], prices, state["cash"])
|
|
pnl = total - state["initial_capital"]
|
|
|
|
print(f"\n{'='*60}")
|
|
print(f" PORTFOLIO STATUS")
|
|
print(f" Strategy: {strategy_name} | Market: {market.upper()}")
|
|
print(f" Last data: {last_date.date()}")
|
|
print(f"{'='*60}")
|
|
|
|
print(f"\n Initial capital: ${state['initial_capital']:>12,.2f}")
|
|
print(f" Current value: ${total:>12,.2f}")
|
|
print(f" Cash: ${state['cash']:>12,.2f}")
|
|
print(f" P&L: ${pnl:>+12,.2f} ({pnl/state['initial_capital']*100:>+.2f}%)")
|
|
print(f" Last morning: {state.get('last_morning', 'N/A')}")
|
|
print(f" Last evening: {state.get('last_evening', 'N/A')}")
|
|
|
|
if state["holdings"]:
|
|
print(f"\n {'Holdings':}")
|
|
print(f" {'Ticker':<8} {'Shares':>10} {'Price':>10} {'Value':>12} {'Weight':>8}")
|
|
print(f" {'-'*52}")
|
|
stock_value = total - state["cash"]
|
|
for ticker, shares in sorted(state["holdings"].items(),
|
|
key=lambda x: -x[1] * prices.get(x[0], 0)):
|
|
p = prices.get(ticker, 0)
|
|
v = shares * p
|
|
w = v / total if total > 0 else 0
|
|
print(f" {ticker:<8} {shares:>10.2f} {p:>10.2f} ${v:>10,.2f} {w:>7.1%}")
|
|
print(f" {'Cash':<8} {'':>10} {'':>10} ${state['cash']:>10,.2f} "
|
|
f"{state['cash']/total*100 if total > 0 else 0:>6.1f}%")
|
|
else:
|
|
print("\n No holdings (100% cash)")
|
|
|
|
# Equity curve
|
|
if state.get("daily_equity"):
|
|
eq = state["daily_equity"]
|
|
dates = sorted(eq.keys())
|
|
print(f"\n {'Equity History (last 10 days)':}")
|
|
print(f" {'Date':<12} {'Value':>12} {'Daily':>8}")
|
|
print(f" {'-'*34}")
|
|
for i, d in enumerate(dates[-10:]):
|
|
v = eq[d]
|
|
prev = eq[dates[dates.index(d) - 1]] if dates.index(d) > 0 else state["initial_capital"]
|
|
daily_ret = (v / prev - 1) * 100
|
|
print(f" {d:<12} ${v:>10,.2f} {daily_ret:>+7.2f}%")
|
|
|
|
# Recent trades
|
|
log = state.get("trade_log", [])
|
|
if log:
|
|
recent = log[-15:]
|
|
print(f"\n {'Recent Trades (last 15)':}")
|
|
print(f" {'Date':<12} {'Action':<6} {'Ticker':<8} {'Shares':>8} {'Price':>10} {'Value':>10}")
|
|
print(f" {'-'*58}")
|
|
for t in recent:
|
|
print(f" {t['date']:<12} {t['action']:<6} {t['ticker']:<8} "
|
|
f"{t['shares']:>8.2f} {t['price']:>10.2f} ${t['value']:>8,.2f}")
|
|
|
|
print()
|
|
|
|
|
|
def cmd_compare(args):
|
|
"""Compare multiple strategies side-by-side."""
|
|
import glob as _glob
|
|
|
|
market = args.market
|
|
strategy_names = getattr(args, "strategy", None)
|
|
|
|
# Auto-discover: find all trader_{market}_*.json state files
|
|
if not strategy_names:
|
|
pattern = os.path.join("data", f"trader_{market}_*.json")
|
|
files = sorted(_glob.glob(pattern))
|
|
strategy_names = []
|
|
for f in files:
|
|
# Extract strategy name: trader_{market}_{name}.json
|
|
base = os.path.basename(f) # trader_us_foo.json
|
|
prefix = f"trader_{market}_"
|
|
name = base[len(prefix):-len(".json")]
|
|
# Skip sim_ prefixed (historical simulations) unless no live ones
|
|
strategy_names.append(name)
|
|
|
|
if not strategy_names:
|
|
print(f"No state files found for market '{market}' in data/.")
|
|
print(f"Run 'monitor' or 'auto' first to generate state.")
|
|
return
|
|
|
|
print(f" Auto-discovered {len(strategy_names)} strategies: "
|
|
f"{', '.join(strategy_names)}")
|
|
|
|
# Load all states
|
|
states = {}
|
|
for name in strategy_names:
|
|
state = load_state(market, name)
|
|
if state and state.get("daily_equity"):
|
|
states[name] = state
|
|
else:
|
|
print(f" Warning: no data for '{name}' — skipping")
|
|
|
|
if not states:
|
|
print("No strategies with data found.")
|
|
return
|
|
|
|
# Find common date range
|
|
all_dates = set()
|
|
for state in states.values():
|
|
all_dates.update(state["daily_equity"].keys())
|
|
all_dates = sorted(all_dates)
|
|
|
|
if not all_dates:
|
|
print("No equity data found.")
|
|
return
|
|
|
|
print(f"\n{'='*80}")
|
|
print(f" STRATEGY COMPARISON — {market.upper()}")
|
|
print(f" Period: {all_dates[0]} to {all_dates[-1]} ({len(all_dates)} days)")
|
|
print(f"{'='*80}")
|
|
|
|
# Summary table
|
|
results = []
|
|
for name, state in states.items():
|
|
eq = state["daily_equity"]
|
|
dates = sorted(eq.keys())
|
|
if len(dates) < 2:
|
|
continue
|
|
|
|
initial = state["initial_capital"]
|
|
final = eq[dates[-1]]
|
|
n_days = len(dates)
|
|
total_ret = (final / initial - 1) * 100
|
|
ann_ret = ((final / initial) ** (252 / n_days) - 1) * 100 if n_days > 0 else 0
|
|
|
|
# Max drawdown
|
|
values = [eq[d] for d in dates]
|
|
peak = values[0]
|
|
max_dd = 0
|
|
for v in values:
|
|
peak = max(peak, v)
|
|
dd = (v - peak) / peak
|
|
max_dd = min(max_dd, dd)
|
|
|
|
# Sharpe
|
|
daily_rets = []
|
|
for i in range(1, len(values)):
|
|
daily_rets.append(values[i] / values[i - 1] - 1)
|
|
daily_rets = np.array(daily_rets) if daily_rets else np.array([0])
|
|
sharpe = (daily_rets.mean() / daily_rets.std() * np.sqrt(252)) if daily_rets.std() > 0 else 0
|
|
|
|
n_trades = len(state.get("trade_log", []))
|
|
total_comm = sum(t.get("commission", 0) for t in state.get("trade_log", []))
|
|
|
|
results.append({
|
|
"name": name,
|
|
"initial": initial,
|
|
"final": final,
|
|
"total_ret": total_ret,
|
|
"ann_ret": ann_ret,
|
|
"sharpe": sharpe,
|
|
"max_dd": max_dd * 100,
|
|
"n_trades": n_trades,
|
|
"commission": total_comm,
|
|
"n_days": n_days,
|
|
"n_positions": len(state.get("holdings", {})),
|
|
"cash": state.get("cash", 0),
|
|
})
|
|
|
|
# Sort by total return descending
|
|
results.sort(key=lambda r: -r["total_ret"])
|
|
|
|
# Print ranking
|
|
print(f"\n {'#':<3} {'Strategy':<25} {'Return':>9} {'Ann.Ret':>9} "
|
|
f"{'Sharpe':>8} {'MaxDD':>8} {'Trades':>7} {'Final':>14}")
|
|
print(f" {'─'*87}")
|
|
|
|
for i, r in enumerate(results, 1):
|
|
print(f" {i:<3} {r['name']:<25} {r['total_ret']:>+8.1f}% {r['ann_ret']:>+8.1f}% "
|
|
f"{r['sharpe']:>8.2f} {r['max_dd']:>7.1f}% {r['n_trades']:>7} "
|
|
f"${r['final']:>12,.2f}")
|
|
|
|
# Equity curve comparison (last 20 dates)
|
|
recent_dates = all_dates[-20:]
|
|
print(f"\n Equity Curve (last {len(recent_dates)} days):")
|
|
header = f" {'Date':<12}"
|
|
for r in results:
|
|
header += f" {r['name'][:14]:>14}"
|
|
print(header)
|
|
print(f" {'─' * (12 + 15 * len(results))}")
|
|
|
|
for d in recent_dates:
|
|
row = f" {d:<12}"
|
|
for r in results:
|
|
eq = states[r["name"]]["daily_equity"]
|
|
if d in eq:
|
|
row += f" ${eq[d]:>12,.2f}"
|
|
else:
|
|
row += f" {'—':>14}"
|
|
print(row)
|
|
|
|
# Winner summary
|
|
if results:
|
|
best = results[0]
|
|
worst = results[-1]
|
|
print(f"\n Best: {best['name']} ({best['total_ret']:>+.1f}%)")
|
|
if len(results) > 1:
|
|
print(f" Worst: {worst['name']} ({worst['total_ret']:>+.1f}%)")
|
|
print(f" Spread: {best['total_ret'] - worst['total_ret']:.1f}pp")
|
|
print()
|
|
|
|
|
|
def cmd_log(args):
|
|
"""Print the daily log: each day's holdings, cash, operations."""
|
|
market = args.market
|
|
strategy_name = args.strategy
|
|
|
|
state = load_state(market, strategy_name)
|
|
if not state:
|
|
print("No state found. Run 'simulate' or 'auto' first.")
|
|
return
|
|
|
|
daily_log = state.get("daily_log", [])
|
|
if not daily_log:
|
|
print("No daily log entries. Re-run simulate with the latest code to generate logs.")
|
|
return
|
|
|
|
# Optional date filter
|
|
start = args.start if hasattr(args, "start") and args.start else None
|
|
end = args.end if hasattr(args, "end") and args.end else None
|
|
|
|
filtered = daily_log
|
|
if start:
|
|
filtered = [d for d in filtered if d["date"] >= start]
|
|
if end:
|
|
filtered = [d for d in filtered if d["date"] <= end]
|
|
|
|
if not filtered:
|
|
print(f"No log entries in range {start or '...'} to {end or '...'}.")
|
|
return
|
|
|
|
print(f"\n{'='*80}")
|
|
print(f" DAILY LOG — {strategy_name} | {market.upper()}")
|
|
print(f" {filtered[0]['date']} to {filtered[-1]['date']} ({len(filtered)} days)")
|
|
print(f"{'='*80}")
|
|
|
|
for entry in filtered:
|
|
d = entry["date"]
|
|
eq = entry["equity"]
|
|
cash = entry["cash"]
|
|
ret = entry["daily_return_pct"]
|
|
ops = entry.get("operations", [])
|
|
holds = entry.get("holdings", {})
|
|
|
|
print(f"\n┌─ {d} equity: ${eq:>10,.2f} daily: {ret:>+.2f}% "
|
|
f"cash: ${cash:>10,.2f} positions: {entry['n_positions']}")
|
|
|
|
# Holdings
|
|
if holds:
|
|
print(f"│ {'Ticker':<8} {'Shares':>8} {'Price':>10} {'Value':>12} {'Weight':>8}")
|
|
print(f"│ {'─'*50}")
|
|
for ticker in sorted(holds, key=lambda t: -holds[t]["value"]):
|
|
h = holds[ticker]
|
|
w = h["value"] / eq * 100 if eq > 0 else 0
|
|
print(f"│ {ticker:<8} {h['shares']:>8} {h['price']:>10.2f} "
|
|
f"${h['value']:>10,.2f} {w:>7.1f}%")
|
|
cash_w = cash / eq * 100 if eq > 0 else 0
|
|
print(f"│ {'Cash':<8} {'':>8} {'':>10} ${cash:>10,.2f} {cash_w:>7.1f}%")
|
|
|
|
# Operations
|
|
if ops:
|
|
print(f"│")
|
|
print(f"│ Operations:")
|
|
print(f"│ {'Action':<6} {'Ticker':<8} {'Shares':>8} {'Price':>10} {'Value':>12}")
|
|
print(f"│ {'─'*46}")
|
|
for op in ops:
|
|
sign = "+" if op["action"] == "BUY" else "-"
|
|
print(f"│ {op['action']:<6} {op['ticker']:<8} {sign}{op['shares']:>7} "
|
|
f"{op['price']:>10.2f} ${op['value']:>10,.2f}")
|
|
else:
|
|
print(f"│ (no trades)")
|
|
|
|
print(f"└{'─'*79}")
|
|
|
|
# Summary
|
|
first = filtered[0]
|
|
last = filtered[-1]
|
|
total_ops = sum(e["n_trades"] for e in filtered)
|
|
trade_days = sum(1 for e in filtered if e["n_trades"] > 0)
|
|
print(f"\n Period: {first['date']} → {last['date']}")
|
|
print(f" Start equity: ${first['equity']:>12,.2f}")
|
|
print(f" End equity: ${last['equity']:>12,.2f}")
|
|
print(f" Return: {(last['equity']/first['equity']-1)*100:>+11.2f}%")
|
|
print(f" Total trades: {total_ops:>11}")
|
|
print(f" Trade days: {trade_days:>11} / {len(filtered)}")
|
|
print()
|
|
|
|
|
|
def cmd_simulate(args):
|
|
"""Simulate day-by-day over a date range."""
|
|
market = args.market
|
|
strategy_name = args.strategy
|
|
tickers, benchmark = strategy_universe(market, strategy_name)
|
|
|
|
# Load both open and close data
|
|
close_data, open_data, _ = load_strategy_prices(
|
|
market, strategy_name, tickers, benchmark, with_open=True,
|
|
)
|
|
tickers = filter_tradable_tickers(close_data, tickers)
|
|
|
|
# Date range
|
|
start = pd.Timestamp(args.start)
|
|
end = pd.Timestamp(args.end)
|
|
trading_days = close_data.index[(close_data.index >= start) & (close_data.index <= end)]
|
|
|
|
if len(trading_days) == 0:
|
|
print(f"No trading days found between {args.start} and {args.end}")
|
|
return
|
|
|
|
# Fresh state for simulation
|
|
state = init_state(market, f"sim_{strategy_name}", args.capital)
|
|
|
|
# Pre-compute strategy weights for the full period (much faster than per-day)
|
|
# Append dummy row so shift(1) inside strategy produces valid last-day signal
|
|
bars = strategy_bars(market, strategy_name, tickers, close_data, open_data)
|
|
full_weights = _signals_for_sessions(strategy_name, open_data[tickers], trading_days, bars)
|
|
|
|
print(f"\n{'='*70}")
|
|
print(f" SIMULATION: {strategy_name} | {market.upper()}")
|
|
print(f" Period: {trading_days[0].date()} to {trading_days[-1].date()} "
|
|
f"({len(trading_days)} trading days)")
|
|
print(f" Capital: ${args.capital:,.0f}")
|
|
print(f"{'='*70}\n")
|
|
|
|
total_trades = 0
|
|
total_commission = 0.0
|
|
|
|
for i, day in enumerate(trading_days):
|
|
day_str = str(day.date())
|
|
|
|
# Morning: get target weights from pre-computed matrix
|
|
if day in full_weights.index:
|
|
row = full_weights.loc[day]
|
|
target_weights = {t: float(w) for t, w in row.items() if w > 1e-6}
|
|
else:
|
|
target_weights = {}
|
|
|
|
# Get open and close prices
|
|
all_held = list(set(list(target_weights.keys()) + list(state["holdings"].keys())))
|
|
open_prices = get_prices_for_date(all_held, day, open_data)
|
|
close_prices = get_prices_for_date(all_held + [benchmark], day, close_data)
|
|
|
|
if not close_prices:
|
|
continue
|
|
|
|
# Compute portfolio value before trades (at close, reflecting overnight changes)
|
|
pre_value = portfolio_value(state["holdings"], close_prices, state["cash"])
|
|
|
|
# Compute and execute trades at close prices
|
|
lot_size = MARKET_LOT_SIZE.get(market, 1)
|
|
trades = compute_trades(
|
|
state["holdings"], state["cash"], target_weights,
|
|
close_prices, min_trade_value=max(50, pre_value * 0.001),
|
|
integer_shares=args.integer_shares, lot_size=lot_size,
|
|
resize_band=RESIZE_BAND,
|
|
)
|
|
|
|
execute_trades(state, trades, close_prices,
|
|
tx_cost=args.tx_cost, fixed_fee=args.fixed_fee,
|
|
trade_date=day_str, integer_shares=args.integer_shares,
|
|
lot_size=lot_size)
|
|
|
|
post_value = portfolio_value(state["holdings"], close_prices, state["cash"])
|
|
state["daily_equity"][day_str] = round(post_value, 2)
|
|
|
|
# Record daily snapshot (holdings + operations)
|
|
prev_eq_val = args.capital if i == 0 else list(state["daily_equity"].values())[-2] if len(state["daily_equity"]) >= 2 else args.capital
|
|
record_daily_snapshot(state, day_str, close_prices, trades, prev_eq_val)
|
|
|
|
day_trades = len(trades)
|
|
day_commission = sum(
|
|
t.get("commission", 0) for t in state["trade_log"][-day_trades:]
|
|
) if day_trades else 0
|
|
total_trades += day_trades
|
|
total_commission += day_commission
|
|
|
|
# Progress: print weekly or on trade days
|
|
if day_trades > 0 or i == 0 or i == len(trading_days) - 1:
|
|
prev_date = dates[-1] if (dates := sorted(state["daily_equity"].keys())[:-1]) else None
|
|
prev_val = state["daily_equity"].get(prev_date, args.capital) if prev_date else args.capital
|
|
daily_ret = (post_value / prev_val - 1) * 100 if prev_val > 0 else 0
|
|
print(f" {day_str} ${post_value:>12,.2f} {daily_ret:>+7.2f}% "
|
|
f"trades: {day_trades:>2} positions: {len(state['holdings']):>2}")
|
|
|
|
# Final summary
|
|
equity = state["daily_equity"]
|
|
dates = sorted(equity.keys())
|
|
final = equity[dates[-1]]
|
|
initial = args.capital
|
|
total_ret = (final / initial - 1) * 100
|
|
n_days = len(dates)
|
|
ann_ret = ((final / initial) ** (252 / n_days) - 1) * 100 if n_days > 0 else 0
|
|
|
|
# Max drawdown
|
|
values = [equity[d] for d in dates]
|
|
peak = values[0]
|
|
max_dd = 0
|
|
for v in values:
|
|
peak = max(peak, v)
|
|
dd = (v - peak) / peak
|
|
max_dd = min(max_dd, dd)
|
|
|
|
# Daily returns for Sharpe
|
|
daily_rets = []
|
|
for i in range(1, len(values)):
|
|
daily_rets.append(values[i] / values[i - 1] - 1)
|
|
daily_rets = np.array(daily_rets) if daily_rets else np.array([0])
|
|
sharpe = (daily_rets.mean() / daily_rets.std() * np.sqrt(252)) if daily_rets.std() > 0 else 0
|
|
|
|
print(f"\n{'='*70}")
|
|
print(f" SIMULATION RESULTS")
|
|
print(f"{'='*70}")
|
|
print(f" Initial capital: ${initial:>12,.2f}")
|
|
print(f" Final value: ${final:>12,.2f}")
|
|
print(f" Total return: {total_ret:>+11.2f}%")
|
|
print(f" Annualized return: {ann_ret:>+11.2f}%")
|
|
print(f" Sharpe ratio: {sharpe:>11.2f}")
|
|
print(f" Max drawdown: {max_dd * 100:>11.2f}%")
|
|
print(f" Total trades: {total_trades:>11}")
|
|
print(f" Total commission: ${total_commission:>11,.2f}")
|
|
print(f" Trading days: {n_days:>11}")
|
|
|
|
# Save state for review
|
|
state["strategy"] = strategy_name
|
|
state["market"] = market
|
|
save_state(state, market, f"sim_{strategy_name}")
|
|
print(f"\n State saved to: {_state_path(market, f'sim_{strategy_name}')}")
|
|
|
|
# Benchmark comparison
|
|
bench_start = close_data[benchmark].loc[trading_days[0]]
|
|
bench_end = close_data[benchmark].loc[trading_days[-1]]
|
|
bench_ret = (bench_end / bench_start - 1) * 100
|
|
print(f"\n Benchmark ({benchmark}): {bench_ret:>+.2f}%")
|
|
print(f" Alpha: {total_ret - bench_ret:>+.2f}%")
|
|
print()
|
|
|
|
|
|
def cmd_monitor(args):
|
|
"""
|
|
Long-running monitor — runs in a tmux session, automatically executes daily.
|
|
|
|
Manages ALL markets (US + CN) in a single process. Each market has its
|
|
own timezone and two daily phases (morning + evening). All strategies
|
|
run for every market.
|
|
|
|
Usage:
|
|
tmux new -s quant
|
|
uv run python trader.py monitor
|
|
# Ctrl-B D to detach
|
|
"""
|
|
import copy
|
|
import time as _time
|
|
import zoneinfo
|
|
|
|
markets = args.market # list of markets
|
|
strategies = args.strategy # list of strategy names
|
|
|
|
# Market schedule configuration — two phases per day
|
|
MARKET_CONFIG = {
|
|
"us": {
|
|
"tz": zoneinfo.ZoneInfo("America/New_York"),
|
|
"open_hour": 9, "open_min": 30, "open_buffer": 15, # run at 9:45 AM ET
|
|
"close_hour": 16, "close_min": 0, "close_buffer": 35, # run at 4:35 PM ET
|
|
"label": "US (NYSE/NASDAQ)",
|
|
},
|
|
"cn": {
|
|
"tz": zoneinfo.ZoneInfo("Asia/Shanghai"),
|
|
"open_hour": 9, "open_min": 30, "open_buffer": 15, # run at 9:45 AM CST
|
|
"close_hour": 15, "close_min": 0, "close_buffer": 35, # run at 3:35 PM CST
|
|
"label": "CN (SSE/SZSE)",
|
|
},
|
|
}
|
|
|
|
# Compute run times for each market
|
|
market_schedules = {}
|
|
for mkt in markets:
|
|
cfg = MARKET_CONFIG[mkt]
|
|
tz = cfg["tz"]
|
|
morn_h = cfg["open_hour"]
|
|
morn_m = cfg["open_min"] + cfg["open_buffer"]
|
|
if morn_m >= 60:
|
|
morn_h += morn_m // 60
|
|
morn_m = morn_m % 60
|
|
eve_h = cfg["close_hour"]
|
|
eve_m = cfg["close_min"] + cfg["close_buffer"]
|
|
if eve_m >= 60:
|
|
eve_h += eve_m // 60
|
|
eve_m = eve_m % 60
|
|
market_schedules[mkt] = {
|
|
"tz": tz, "label": cfg["label"],
|
|
"morn_h": morn_h, "morn_m": morn_m,
|
|
"eve_h": eve_h, "eve_m": eve_m,
|
|
}
|
|
|
|
# Banner
|
|
print(f"\n{'='*60}")
|
|
print(f" MONITOR MODE — {len(markets)} market(s), "
|
|
f"{len(strategies)} strategies")
|
|
capital_note = (f"{args.capital:,.0f}" if args.capital else
|
|
", ".join(f"{m.upper()} {MONITOR_CAPITAL[m]:,.0f}" for m in markets))
|
|
print(f" Capital (new portfolios): {capital_note} | "
|
|
f"Integer shares: {args.integer_shares}")
|
|
for mkt, sched in market_schedules.items():
|
|
fee = MARKET_FEES.get(mkt, args.fixed_fee)
|
|
print(f" {sched['label']}:")
|
|
print(f" Morning: {sched['morn_h']:02d}:{sched['morn_m']:02d} {sched['tz']}")
|
|
print(f" Evening: {sched['eve_h']:02d}:{sched['eve_m']:02d} {sched['tz']}")
|
|
print(f" Fixed fee: {fee:.2f}/trade")
|
|
print(f" Strategies: {', '.join(strategies)}")
|
|
print(f" Auto-reload: ON (new strategies picked up each phase)")
|
|
print(f"{'='*60}")
|
|
|
|
# Use UTC as common reference for sleeping
|
|
utc = zoneinfo.ZoneInfo("UTC")
|
|
print(f"[monitor] Started at {datetime.now(utc).strftime('%Y-%m-%d %H:%M:%S UTC')}")
|
|
print(f"[monitor] Press Ctrl+C to stop\n")
|
|
|
|
def _next_events_for_market(mkt, now_utc):
|
|
"""Return list of (utc_datetime, market, phase) for next events."""
|
|
sched = market_schedules[mkt]
|
|
tz = sched["tz"]
|
|
now_local = now_utc.astimezone(tz)
|
|
|
|
candidates = []
|
|
for phase, h, m in [("morning", sched["morn_h"], sched["morn_m"]),
|
|
("evening", sched["eve_h"], sched["eve_m"])]:
|
|
target = now_local.replace(hour=h, minute=m, second=0, microsecond=0)
|
|
if now_local >= target:
|
|
target += timedelta(days=1)
|
|
# Skip weekends
|
|
while target.weekday() >= 5:
|
|
target += timedelta(days=1)
|
|
candidates.append((target.astimezone(utc), mkt, phase))
|
|
return candidates
|
|
|
|
def _next_event(now_utc):
|
|
"""Find the globally next event across all markets."""
|
|
all_candidates = []
|
|
for mkt in markets:
|
|
all_candidates.extend(_next_events_for_market(mkt, now_utc))
|
|
return min(all_candidates, key=lambda x: x[0])
|
|
|
|
def _reload_strategies():
|
|
"""Re-read STRATEGY_REGISTRY to pick up new strategies without restart."""
|
|
import importlib
|
|
import trader as _self_mod
|
|
importlib.reload(_self_mod)
|
|
current = list(_self_mod.DEFAULT_MONITOR_STRATEGIES)
|
|
return current, _self_mod.STRATEGY_REGISTRY
|
|
|
|
def _run_phase(market, phase, now_utc):
|
|
"""Run all strategies for a market/phase."""
|
|
nonlocal strategies
|
|
sched = market_schedules[market]
|
|
tz = sched["tz"]
|
|
now_local = now_utc.astimezone(tz)
|
|
|
|
# Hot-reload strategy list from registry
|
|
try:
|
|
reloaded_names, reloaded_reg = _reload_strategies()
|
|
new_strats = set(reloaded_names) - set(strategies)
|
|
if new_strats:
|
|
print(f"[monitor] Hot-reload: +{len(new_strats)} new strategies: "
|
|
f"{', '.join(sorted(new_strats))}")
|
|
strategies = reloaded_names
|
|
# Update the global registry so cmd_morning/cmd_auto use new strategies
|
|
globals().update({"STRATEGY_REGISTRY": reloaded_reg})
|
|
except Exception as e:
|
|
print(f"[monitor] Hot-reload failed (using cached list): {e}")
|
|
|
|
print(f"\n[monitor] {'='*55}")
|
|
print(f"[monitor] {market.upper()} {phase.upper()} at "
|
|
f"{now_local.strftime('%Y-%m-%d %H:%M:%S %Z')}")
|
|
print(f"[monitor] {'='*55}")
|
|
|
|
market_fee = MARKET_FEES.get(market, args.fixed_fee)
|
|
eligible = [s for s in strategies if strategy_supports_market(s, market)]
|
|
# One download per price panel per phase; strategies then read offline.
|
|
try:
|
|
refresh_panels(market, eligible, label="monitor")
|
|
except Exception as e:
|
|
print(f"[monitor] Panel refresh failed ({e}); using stored prices")
|
|
for strat_name in eligible:
|
|
sub_args = copy.copy(args)
|
|
sub_args.refresh = False
|
|
sub_args.strategy = strat_name
|
|
sub_args.market = market
|
|
sub_args.fixed_fee = market_fee
|
|
|
|
print(f"\n[monitor] --- {market.upper()}:{strat_name} ---")
|
|
try:
|
|
if phase == "morning":
|
|
cmd_morning(sub_args)
|
|
else:
|
|
# Evening always goes through auto: it re-derives the open
|
|
# signal, executes at the final close and catches up any
|
|
# sessions missed while the monitor was down.
|
|
cmd_auto(sub_args)
|
|
print(f"[monitor] {market.upper()}:{strat_name} {phase} OK")
|
|
except KeyboardInterrupt:
|
|
raise
|
|
except Exception as e:
|
|
print(f"[monitor] ERROR {market.upper()}:{strat_name} "
|
|
f"{phase}: {e}")
|
|
import traceback
|
|
traceback.print_exc()
|
|
|
|
print(f"[monitor] {market.upper()} {phase} done — "
|
|
f"{len(eligible)} strategies\n")
|
|
|
|
# Catch up sessions missed while the monitor was down. cmd_auto only
|
|
# processes sessions whose close is final, so this is safe at any time.
|
|
for mkt in markets:
|
|
print(f"[monitor] Startup catch-up for {mkt.upper()}")
|
|
_run_phase(mkt, "evening", datetime.now(utc))
|
|
|
|
while True:
|
|
now_utc = datetime.now(utc)
|
|
target_utc, next_mkt, next_phase = _next_event(now_utc)
|
|
wait_seconds = (target_utc - now_utc).total_seconds()
|
|
next_tz = market_schedules[next_mkt]["tz"]
|
|
target_local = target_utc.astimezone(next_tz)
|
|
|
|
print(f"[monitor] {now_utc.strftime('%Y-%m-%d %H:%M UTC')} — "
|
|
f"Next: {next_mkt.upper()} {next_phase.upper()} at "
|
|
f"{target_local.strftime('%H:%M %Z %m/%d')} "
|
|
f"(in {wait_seconds/3600:.1f}h)")
|
|
|
|
# Sleep in chunks
|
|
while True:
|
|
now_utc = datetime.now(utc)
|
|
remaining = (target_utc - now_utc).total_seconds()
|
|
if remaining <= 0:
|
|
break
|
|
chunk = min(remaining, 900)
|
|
_time.sleep(chunk)
|
|
|
|
now_utc = datetime.now(utc)
|
|
remaining = (target_utc - now_utc).total_seconds()
|
|
if remaining > 60:
|
|
hours_left = remaining / 3600
|
|
if int(remaining) % 3600 < 900:
|
|
print(f"[monitor] {now_utc.strftime('%H:%M UTC')} — "
|
|
f"waiting... ({hours_left:.1f}h until "
|
|
f"{next_mkt.upper()} {next_phase})")
|
|
|
|
# Execute
|
|
now_utc = datetime.now(utc)
|
|
|
|
# Run all events that are due NOW (within 2 min window) — handles
|
|
# case where US evening and CN morning overlap
|
|
for mkt in markets:
|
|
for phase_check in ("morning", "evening"):
|
|
sched = market_schedules[mkt]
|
|
tz = sched["tz"]
|
|
now_local = now_utc.astimezone(tz)
|
|
if phase_check == "morning":
|
|
h, m = sched["morn_h"], sched["morn_m"]
|
|
else:
|
|
h, m = sched["eve_h"], sched["eve_m"]
|
|
target_local = now_local.replace(
|
|
hour=h, minute=m, second=0, microsecond=0)
|
|
diff = abs((now_local - target_local).total_seconds())
|
|
# Fire if within 2-minute window and it's a weekday
|
|
if diff < 120 and now_local.weekday() < 5:
|
|
try:
|
|
_run_phase(mkt, phase_check, now_utc)
|
|
except KeyboardInterrupt:
|
|
raise
|
|
except Exception as e:
|
|
print(f"[monitor] ERROR in {mkt} {phase_check}: {e}")
|
|
import traceback
|
|
traceback.print_exc()
|
|
|
|
print()
|
|
|
|
|
|
def refresh_panels(market: str, strategy_names: list[str], label: str) -> None:
|
|
"""Refresh every price panel the strategies read, once, for the union of their tickers."""
|
|
requests: dict[str, set[str]] = {}
|
|
fields: dict[str, set[str]] = {}
|
|
for name in strategy_names:
|
|
tickers, benchmark = strategy_universe(market, name)
|
|
data_market = strategy_data_market(market, name)
|
|
requests.setdefault(data_market, set()).update(
|
|
price_request(market, list(tickers) + [benchmark]))
|
|
fields.setdefault(data_market, {"close", "open"}).update(strategy_fields(name))
|
|
for data_market, request in requests.items():
|
|
print(f"[{label}] Refreshing {data_market} panel for {len(request)} tickers")
|
|
data_manager.update(data_market, sorted(request), fields=sorted(fields[data_market]))
|
|
|
|
|
|
def _process_sessions(args, state: dict | None, start: pd.Timestamp | None = None,
|
|
label: str = "auto", refresh: bool = True) -> dict | None:
|
|
"""Run every completed session not yet recorded in ``state`` (catch-up safe).
|
|
|
|
A fresh portfolio starts at ``start`` when given, otherwise at the most
|
|
recent completed session. Returns the updated state, or None if skipped.
|
|
"""
|
|
market = args.market
|
|
strategy_name = args.strategy
|
|
if not strategy_supports_market(strategy_name, market):
|
|
print(f"[{label}] {strategy_name} does not run in the {market.upper()} book; skipping.")
|
|
return None
|
|
tickers, benchmark = strategy_universe(market, strategy_name)
|
|
close_data, open_data, close_raw = load_strategy_prices(
|
|
market, strategy_name, tickers, benchmark, with_open=True, refresh=refresh,
|
|
)
|
|
tickers = filter_tradable_tickers(close_data, tickers)
|
|
sessions = completed_sessions(close_raw, strategy_data_market(market, strategy_name), benchmark)
|
|
if len(sessions) == 0:
|
|
print(f"[{label}] No completed session in the price panel.")
|
|
return None
|
|
|
|
if not state:
|
|
capital = args.capital or MONITOR_CAPITAL.get(market, 10_000.0)
|
|
state = init_state(market, strategy_name, capital)
|
|
first = start if start is not None else sessions[-1]
|
|
todo = sessions[sessions >= first]
|
|
print(f"[{label}] Initialized {strategy_name} ({market.upper()}) with {capital:,.0f} cash")
|
|
else:
|
|
last = state.get("last_evening")
|
|
todo = sessions[sessions > pd.Timestamp(last)] if last else sessions[-1:]
|
|
|
|
if len(todo) == 0:
|
|
print(f"[{label}] {strategy_name}: {state.get('last_evening')} already processed.")
|
|
return state
|
|
if len(todo) > 1:
|
|
print(f"[{label}] {strategy_name}: processing {len(todo)} sessions "
|
|
f"{todo[0].date()} .. {todo[-1].date()}")
|
|
|
|
fees = _strategy_fees(args, market)
|
|
bars = strategy_bars(market, strategy_name, tickers, close_data, open_data)
|
|
signals = _signals_for_sessions(strategy_name, open_data[tickers], todo, bars)
|
|
for day in todo:
|
|
r = _run_session(state, strategy_name, market, day, tickers, benchmark,
|
|
close_data, open_data, close_raw, fees, args.integer_shares,
|
|
signal_row=signals.loc[day], bars=bars)
|
|
frozen = f" | no fresh price: {', '.join(r['frozen'])}" if r["frozen"] else ""
|
|
print(f"[{label}] {r['date']} {strategy_name:<34} value {r['value']:>12,.2f} "
|
|
f"({r['daily_return']:+.2%}) trades {r['trades']:>2} "
|
|
f"fee {r['commission']:>6.2f} positions {r['positions']:>2}{frozen}")
|
|
return state
|
|
|
|
|
|
def cmd_auto(args):
|
|
"""
|
|
Automated daily run — signal on each session's open, execute at its close.
|
|
|
|
Processes every completed session since the last recorded one, so missed
|
|
days (monitor downtime, late data) are caught up in order. A session is
|
|
only processed after the exchange has closed.
|
|
|
|
Usage with cron (US market, run at 5pm ET weekdays):
|
|
0 17 * * 1-5 cd /path/to/quant && uv run python trader.py auto --market us
|
|
For CN market (run at 4pm CST):
|
|
0 16 * * 1-5 cd /path/to/quant && uv run python trader.py auto --market cn
|
|
"""
|
|
state = load_state(args.market, args.strategy)
|
|
state = _process_sessions(args, state, refresh=getattr(args, "refresh", True))
|
|
if state is not None:
|
|
save_state(state, args.market, args.strategy)
|
|
pnl = state["daily_equity"][state["last_evening"]] - state["initial_capital"]
|
|
print(f"[auto] P&L since inception: {pnl:>+,.2f} "
|
|
f"({pnl / state['initial_capital']:+.2%}) | state: "
|
|
f"{_state_path(args.market, args.strategy)}")
|
|
|
|
|
|
def cmd_replay(args):
|
|
"""Rebuild live state files by replaying every session from each strategy's start.
|
|
|
|
Uses exactly the per-session logic of ``auto``. Existing state files are
|
|
replaced; their original start date is kept unless ``--start`` is given.
|
|
"""
|
|
import copy
|
|
names = args.strategy or sorted(
|
|
os.path.basename(p)[len(f"trader_{args.market}_"):-len(".json")]
|
|
for p in __import__("glob").glob(os.path.join("data", f"trader_{args.market}_*.json"))
|
|
)
|
|
live_names = [n for n in names if not n.startswith("sim_") and n in STRATEGY_REGISTRY
|
|
and n not in LIVE_EXCLUDED_STRATEGIES and strategy_supports_market(n, args.market)]
|
|
|
|
# Refresh each price panel once for the union of tickers, then replay offline.
|
|
refresh_panels(args.market, live_names, label="replay")
|
|
|
|
for name in names:
|
|
if name.startswith("sim_"):
|
|
continue
|
|
sub = copy.copy(args)
|
|
sub.strategy = name
|
|
if name not in STRATEGY_REGISTRY or name in LIVE_EXCLUDED_STRATEGIES \
|
|
or not strategy_supports_market(name, args.market):
|
|
print(f"[replay] {args.market.upper()}:{name} is not a live strategy here; "
|
|
f"removing its state file")
|
|
if os.path.exists(_state_path(args.market, name)):
|
|
os.remove(_state_path(args.market, name))
|
|
continue
|
|
old = load_state(args.market, name)
|
|
start = pd.Timestamp(args.start) if args.start else (
|
|
pd.Timestamp(min(old["daily_equity"])) if old.get("daily_equity") else None
|
|
)
|
|
if start is None:
|
|
print(f"[replay] {name}: no start date; skipping")
|
|
continue
|
|
state = _process_sessions(sub, None, start=start, label="replay", refresh=False)
|
|
if state is not None:
|
|
save_state(state, args.market, name)
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# CLI
|
|
# ---------------------------------------------------------------------------
|
|
|
|
def main():
|
|
parser = argparse.ArgumentParser(description="Daily trading simulation")
|
|
sub = parser.add_subparsers(dest="command", required=True)
|
|
|
|
# Common args
|
|
def add_common(p):
|
|
p.add_argument("--market", choices=UNIVERSES.keys(), default="us")
|
|
p.add_argument("--strategy", choices=STRATEGY_REGISTRY.keys(),
|
|
default="recovery_mom_top10")
|
|
p.add_argument("--capital", type=float, default=100_000)
|
|
p.add_argument("--tx-cost", type=float, default=0.001,
|
|
help="Proportional transaction cost (default: 0.001 = 10bps)")
|
|
p.add_argument("--fixed-fee", type=float, default=0.0,
|
|
help="Fixed dollar fee per trade")
|
|
p.add_argument("--integer-shares", action="store_true", default=False,
|
|
help="Only trade whole shares (no fractional)")
|
|
|
|
# Morning
|
|
p_morning = sub.add_parser("morning", help="Generate trade orders from open prices")
|
|
add_common(p_morning)
|
|
|
|
# Evening
|
|
p_evening = sub.add_parser("evening", help="Record execution at close prices")
|
|
add_common(p_evening)
|
|
|
|
# Auto (single daily run — for cron/systemd)
|
|
p_auto = sub.add_parser("auto",
|
|
help="Automated daily run: signal + execute in one step (for cron)")
|
|
add_common(p_auto)
|
|
|
|
# Monitor (long-running daemon for tmux) — all markets + all strategies
|
|
p_monitor = sub.add_parser("monitor",
|
|
help="Long-running daemon: runs ALL markets & strategies (for tmux)")
|
|
p_monitor.add_argument("--market", nargs="+",
|
|
choices=list(UNIVERSES.keys()),
|
|
default=list(UNIVERSES.keys()),
|
|
help="Markets to monitor (default: ALL)")
|
|
p_monitor.add_argument("--strategy", nargs="+",
|
|
choices=list(STRATEGY_REGISTRY.keys()),
|
|
default=DEFAULT_MONITOR_STRATEGIES,
|
|
help="Strategies to run (default: ALL)")
|
|
p_monitor.add_argument("--capital", type=float, default=None,
|
|
help="Capital for new portfolios (default: per-market MONITOR_CAPITAL)")
|
|
p_monitor.add_argument("--tx-cost", type=float, default=0.001,
|
|
help="Proportional transaction cost (default: 0.001 = 10bps)")
|
|
p_monitor.add_argument("--fixed-fee", type=float, default=2.0,
|
|
help="Fixed dollar fee per trade (default: $2)")
|
|
p_monitor.add_argument("--integer-shares", action="store_true", default=True,
|
|
help="Only trade whole shares (default: True)")
|
|
|
|
# Replay: rebuild live state files from each strategy's start date
|
|
p_replay = sub.add_parser("replay",
|
|
help="Rebuild live state files by replaying all sessions (replaces state)")
|
|
p_replay.add_argument("--market", choices=list(UNIVERSES.keys()), default="us")
|
|
p_replay.add_argument("--strategy", nargs="+", default=None,
|
|
help="Strategies to replay (default: every existing state file)")
|
|
p_replay.add_argument("--start", default=None,
|
|
help="Start date (default: each state file's first recorded day)")
|
|
p_replay.add_argument("--capital", type=float, default=None,
|
|
help="Initial capital (default: per-market MONITOR_CAPITAL)")
|
|
p_replay.add_argument("--tx-cost", type=float, default=0.001)
|
|
p_replay.add_argument("--fixed-fee", type=float, default=0.0,
|
|
help="Per-trade fee floor (default: per-market MARKET_FEES)")
|
|
p_replay.add_argument("--integer-shares", action=argparse.BooleanOptionalAction, default=True)
|
|
|
|
# Status (strategy is a free-form string to allow sim_ prefixed names)
|
|
p_status = sub.add_parser("status", help="Show current portfolio")
|
|
p_status.add_argument("--market", choices=UNIVERSES.keys(), default="us")
|
|
p_status.add_argument("--strategy", default="recovery_mom_top10",
|
|
help="Strategy name (or sim_<name> for simulation state)")
|
|
p_status.add_argument("--capital", type=float, default=100_000)
|
|
p_status.add_argument("--tx-cost", type=float, default=0.001)
|
|
p_status.add_argument("--fixed-fee", type=float, default=0.0)
|
|
p_status.add_argument("--integer-shares", action="store_true", default=False)
|
|
|
|
# Simulate
|
|
p_sim = sub.add_parser("simulate", help="Simulate over a date range")
|
|
add_common(p_sim)
|
|
p_sim.add_argument("--start", required=True, help="Start date (YYYY-MM-DD)")
|
|
p_sim.add_argument("--end", required=True, help="End date (YYYY-MM-DD)")
|
|
|
|
# Log viewer
|
|
p_log = sub.add_parser("log", help="View daily log (holdings + operations per day)")
|
|
p_log.add_argument("--market", choices=UNIVERSES.keys(), default="us")
|
|
p_log.add_argument("--strategy", default="sim_recovery_mom_top10",
|
|
help="Strategy name (e.g. sim_recovery_mom_top10)")
|
|
p_log.add_argument("--start", default=None, help="Start date filter (YYYY-MM-DD)")
|
|
p_log.add_argument("--end", default=None, help="End date filter (YYYY-MM-DD)")
|
|
|
|
# Compare strategies
|
|
p_cmp = sub.add_parser("compare",
|
|
help="Compare strategies side-by-side (auto-discovers all if no --strategy)")
|
|
p_cmp.add_argument("--market", choices=UNIVERSES.keys(), default="us")
|
|
p_cmp.add_argument("--strategy", nargs="+", default=None,
|
|
help="Strategy names to compare (default: auto-discover all)")
|
|
|
|
args = parser.parse_args()
|
|
|
|
if args.command == "morning":
|
|
cmd_morning(args)
|
|
elif args.command == "evening":
|
|
cmd_evening(args)
|
|
elif args.command == "auto":
|
|
cmd_auto(args)
|
|
elif args.command == "monitor":
|
|
cmd_monitor(args)
|
|
elif args.command == "replay":
|
|
cmd_replay(args)
|
|
elif args.command == "status":
|
|
cmd_status(args)
|
|
elif args.command == "simulate":
|
|
cmd_simulate(args)
|
|
elif args.command == "log":
|
|
cmd_log(args)
|
|
elif args.command == "compare":
|
|
cmd_compare(args)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|