dekun
968 lines
38 KiB
Python
968 lines
38 KiB
Python
"""策略状态机：选向开仓 / 盯盘平仓 / 休息（无开仓窗、无轮次上限）。"""
|
||
|
||
from __future__ import annotations
|
||
|
||
import asyncio
|
||
import logging
|
||
import time
|
||
from typing import Any
|
||
|
||
from ..config import get_settings
|
||
from .session import get_session
|
||
from ..models.db import get_db
|
||
from ..sim.ledger import Ledger
|
||
from ..live import get_executor
|
||
from ..live.rate_limit import LiveRetryGate, is_rate_limit_error
|
||
from ..env_store import live_ready
|
||
from .clock import can_open_new, window_key
|
||
from .exits import check_expiry_close, check_exits, resolve_exit_target
|
||
from .group import next_group_id
|
||
from .open_capacity import assess_open_capacity, maybe_notify_funds_short
|
||
|
||
logger = logging.getLogger(__name__)
|
||
|
||
|
||
class StrategyEngine:
|
||
def __init__(self) -> None:
|
||
self.db = get_db()
|
||
self.ledger = Ledger(self.db)
|
||
self.matcher = get_executor(self.db)
|
||
self._task: asyncio.Task[None] | None = None
|
||
self._lock = asyncio.Lock()
|
||
self._retry_gate = LiveRetryGate()
|
||
self._extra_sleep_sec = 0.0
|
||
|
||
def refresh_executor(self) -> None:
|
||
"""MODE 变更后刷新执行器。"""
|
||
self.matcher = get_executor(self.db)
|
||
|
||
def _gate_key(self, kind: str) -> str:
|
||
pos = self.matcher.current_position()
|
||
gid = str(pos.get("group_id") or "none")
|
||
return f"{kind}:{gid}"
|
||
|
||
def _note_retry_result(self, kind: str, *, ok: bool, detail: str = "") -> None:
|
||
key = self._gate_key(kind)
|
||
if ok:
|
||
self._retry_gate.success(key)
|
||
return
|
||
rl = is_rate_limit_error(detail)
|
||
delay = self._retry_gate.fail(key, rate_limited=rl)
|
||
if rl:
|
||
self._extra_sleep_sec = max(self._extra_sleep_sec, min(delay, 60.0))
|
||
logger.warning(
|
||
"live retry backoff kind=%s fails=%s delay=%.1fs rate_limited=%s detail=%s",
|
||
kind,
|
||
self._retry_gate.fails(key),
|
||
delay,
|
||
rl,
|
||
(detail or "")[:160],
|
||
)
|
||
|
||
def _retry_allowed(self, kind: str) -> tuple[bool, float]:
|
||
return self._retry_gate.allow(self._gate_key(kind))
|
||
|
||
def state(self) -> dict[str, Any]:
|
||
row = self.db.fetchone("SELECT * FROM strategy_state WHERE id=1")
|
||
assert row is not None
|
||
upl = self.matcher.unrealized()
|
||
s = get_settings()
|
||
exit_mode = self.ledger.get_setting_str("exit_mode", s.exit_mode)
|
||
net_target = self.ledger.get_setting_float(
|
||
"net_profit_target", s.net_profit_target
|
||
)
|
||
prem_mult = self.ledger.get_setting_float(
|
||
"premium_exit_multiple", s.premium_exit_multiple
|
||
)
|
||
exit_amt, _ = resolve_exit_target(
|
||
exit_mode=exit_mode,
|
||
net_profit_target=net_target,
|
||
premium_exit_multiple=prem_mult,
|
||
initial_premium=float(upl.get("initial_premium") or 0),
|
||
)
|
||
rest_sec = self.ledger.get_setting_int("rest_seconds", s.rest_seconds)
|
||
skip_weekends = self.ledger.get_setting_bool("skip_weekends", s.skip_weekends)
|
||
leverage = self.ledger.get_setting_float("leverage", s.leverage)
|
||
perp_mm = str(
|
||
self.ledger.get_setting_str("perp_margin_mode", s.perp_margin_mode)
|
||
or s.perp_margin_mode
|
||
or "cross"
|
||
).strip().lower()
|
||
if perp_mm not in ("cross", "isolated"):
|
||
perp_mm = "cross"
|
||
min_hours = self.ledger.get_setting_float("min_option_hours", s.min_option_hours)
|
||
min_opt_lev = self.ledger.get_setting_float(
|
||
"min_option_leverage", s.min_option_leverage
|
||
)
|
||
atm_off_on = self.ledger.get_setting_bool(
|
||
"atm_open_offset_enabled", s.atm_open_offset_enabled
|
||
)
|
||
max_atm_off = self.ledger.get_setting_float(
|
||
"max_atm_open_offset", s.max_atm_open_offset
|
||
)
|
||
fixed_dir_on = self.ledger.get_setting_bool(
|
||
"fixed_direction_enabled", s.fixed_direction_enabled
|
||
)
|
||
fixed_perp = str(
|
||
self.ledger.get_setting_str("fixed_perp_side", s.fixed_perp_side)
|
||
or s.fixed_perp_side
|
||
or "long"
|
||
).strip().lower()
|
||
if fixed_perp not in ("long", "short"):
|
||
fixed_perp = "long"
|
||
perp_qty = self.ledger.get_setting_float("perp_qty_eth", s.perp_qty_eth)
|
||
opt_qty = self.ledger.get_setting_float("option_qty_eth", s.option_qty_eth)
|
||
sizing_mode = (
|
||
sm
|
||
if (
|
||
sm := str(
|
||
self.ledger.get_setting_str("sizing_mode", "manual") or "manual"
|
||
)
|
||
.strip()
|
||
.lower()
|
||
)
|
||
in ("manual", "risk_based")
|
||
else "manual"
|
||
)
|
||
risk_perp_unit = self.ledger.get_setting_float("risk_perp_unit", 1.0)
|
||
risk_option_unit = self.ledger.get_setting_float("risk_option_unit", 2.0)
|
||
risk_exit_unit = self.ledger.get_setting_float("risk_exit_unit", 15.0)
|
||
risk_last_k = self.ledger.get_setting_float("risk_last_k", 0.0)
|
||
risk_preview: dict[str, Any] | None = None
|
||
pos_status = str(upl.get("status") or "flat")
|
||
trade_locked = pos_status in (
|
||
"open",
|
||
"half_open",
|
||
"option_closed_perp_pending",
|
||
"opening",
|
||
)
|
||
locked_exit = None
|
||
try:
|
||
from .exits import read_locked_exit_target
|
||
|
||
locked_exit = read_locked_exit_target(upl)
|
||
except Exception:
|
||
locked_exit = None
|
||
if trade_locked and locked_exit is not None:
|
||
# 持仓中：出场目标锁定，不再用盘口重算覆盖
|
||
net_target = float(locked_exit)
|
||
exit_amt = float(locked_exit)
|
||
# 以损定仓：仅空仓时用实时估算覆盖展示；持仓中保持开仓锁定名义/k/目标
|
||
if sizing_mode == "risk_based" and not trade_locked:
|
||
try:
|
||
from .risk_sizing import preview_risk_sizing
|
||
|
||
risk_preview = preview_risk_sizing(self.db)
|
||
if risk_preview.get("ok"):
|
||
if risk_preview.get("perp_qty_eth") is not None:
|
||
perp_qty = float(risk_preview["perp_qty_eth"])
|
||
if risk_preview.get("option_qty_eth") is not None:
|
||
opt_qty = float(risk_preview["option_qty_eth"])
|
||
if risk_preview.get("net_profit_target") is not None:
|
||
net_target = float(risk_preview["net_profit_target"])
|
||
exit_amt = net_target
|
||
if risk_preview.get("k") is not None:
|
||
risk_last_k = float(risk_preview["k"])
|
||
if risk_preview.get("perp_unit") is not None:
|
||
risk_perp_unit = float(risk_preview["perp_unit"])
|
||
if risk_preview.get("option_unit") is not None:
|
||
risk_option_unit = float(risk_preview["option_unit"])
|
||
if risk_preview.get("exit_unit") is not None:
|
||
risk_exit_unit = float(risk_preview["exit_unit"])
|
||
except Exception:
|
||
logger.exception("risk sizing preview for state() failed")
|
||
risk_preview = {"ok": False, "detail": "以损定仓预览失败"}
|
||
elif sizing_mode == "risk_based" and trade_locked:
|
||
risk_preview = {
|
||
"ok": True,
|
||
"locked": True,
|
||
"detail": "持仓中已锁定本组成交目标与名义，平仓后再自动计算",
|
||
"net_profit_target": net_target,
|
||
"k": risk_last_k if risk_last_k > 0 else None,
|
||
"perp_qty_eth": perp_qty,
|
||
"option_qty_eth": opt_qty,
|
||
}
|
||
rest_until = row["rest_until_ms"]
|
||
rest_left = 0
|
||
if rest_until:
|
||
rest_left = max(0, int((int(rest_until) - time.time() * 1000) / 1000))
|
||
last_error = row["last_error"]
|
||
if last_error and "PriceResult" in str(last_error) and "__dict__" in str(last_error):
|
||
self._set_state(last_error=None)
|
||
last_error = None
|
||
allow_open = can_open_new(skip_weekends=skip_weekends)
|
||
try:
|
||
open_cap = assess_open_capacity(self.db)
|
||
except Exception:
|
||
logger.exception("assess_open_capacity failed")
|
||
open_cap = {
|
||
"perp_can_open": None,
|
||
"option_can_open": None,
|
||
"perp_label": f"永续{int(round(leverage))}x —",
|
||
"option_label": "期权 —",
|
||
"funds_ok": False,
|
||
"leverage": leverage,
|
||
}
|
||
return {
|
||
"running": bool(row["running"]),
|
||
"phase": row["phase"],
|
||
"rounds_done": self._closed_rounds(),
|
||
"window_key": row["window_key"],
|
||
"rest_until_ms": rest_until,
|
||
"rest_left_sec": rest_left,
|
||
"rest_seconds": rest_sec,
|
||
"skip_weekends": skip_weekends,
|
||
"exit_mode": exit_mode,
|
||
"net_profit_target": net_target,
|
||
"premium_exit_multiple": prem_mult,
|
||
"exit_target_usdt": exit_amt,
|
||
"leverage": leverage,
|
||
"perp_margin_mode": perp_mm,
|
||
"perp_qty_eth": perp_qty,
|
||
"option_qty_eth": opt_qty,
|
||
"sizing_mode": sizing_mode,
|
||
"risk_based": sizing_mode == "risk_based",
|
||
"risk_perp_unit": risk_perp_unit,
|
||
"risk_option_unit": risk_option_unit,
|
||
"risk_exit_unit": risk_exit_unit,
|
||
"risk_last_k": risk_last_k if risk_last_k > 0 else None,
|
||
"risk_sizing_preview": risk_preview,
|
||
"risk_sizing_locked": bool(trade_locked and sizing_mode == "risk_based"),
|
||
"min_option_hours": min_hours,
|
||
"min_option_leverage": min_opt_lev,
|
||
"atm_open_offset_enabled": atm_off_on,
|
||
"max_atm_open_offset": max_atm_off,
|
||
"fixed_direction_enabled": fixed_dir_on,
|
||
"fixed_perp_side": fixed_perp,
|
||
"can_open": allow_open,
|
||
"open_capacity": open_cap,
|
||
"last_error": last_error,
|
||
"position": upl,
|
||
"residuals": self.matcher.list_residual_options(pending_only=True),
|
||
"ledger": self.ledger.snapshot(),
|
||
"mode": "SIM" if s.is_sim else "LIVE",
|
||
"sim": s.is_sim,
|
||
"exchange": str(s.exchange or "okx").lower(),
|
||
"live_ready": (live_ready()[0] if not s.is_sim else True),
|
||
"live_ready_reason": (live_ready()[1] if not s.is_sim else "sim"),
|
||
"show_manual_trade_buttons": self.ledger.get_setting_bool(
|
||
"show_manual_trade_buttons", False
|
||
),
|
||
}
|
||
|
||
def _set_state(self, **kwargs: Any) -> None:
|
||
cols = []
|
||
vals: list[Any] = []
|
||
for k, v in kwargs.items():
|
||
cols.append(f"{k}=?")
|
||
vals.append(v)
|
||
cols.append("updated_at_ms=?")
|
||
vals.append(int(time.time() * 1000))
|
||
sql = f"UPDATE strategy_state SET {', '.join(cols)} WHERE id=1"
|
||
self.db.execute(sql, tuple(vals))
|
||
|
||
async def pause(self) -> dict[str, Any]:
|
||
self._set_state(running=0, phase="paused", last_error=None)
|
||
try:
|
||
from ..notify import wecom
|
||
|
||
wecom.notify_pause()
|
||
except Exception:
|
||
logger.exception("wecom notify_pause failed")
|
||
return self.state()
|
||
|
||
async def start(self) -> dict[str, Any]:
|
||
self.refresh_executor()
|
||
s = get_settings()
|
||
if not s.is_sim:
|
||
ok, reason = live_ready()
|
||
if not ok:
|
||
self._set_state(running=0, phase="paused", last_error=reason)
|
||
try:
|
||
from ..notify import wecom
|
||
|
||
wecom.notify_fault(title="启动失败", detail=reason, dedupe_key="start_fail")
|
||
except Exception:
|
||
pass
|
||
return self.state()
|
||
self._set_state(running=1, last_error=None, phase="idle")
|
||
self.ensure_loop()
|
||
try:
|
||
from ..notify import wecom
|
||
|
||
wecom.notify_start()
|
||
except Exception:
|
||
logger.exception("wecom notify_start failed")
|
||
return self.state()
|
||
|
||
def ensure_loop(self) -> None:
|
||
"""保证后台循环在跑（暂停时仍盯目标/到期，不新开）。"""
|
||
if self._task is None or self._task.done():
|
||
self._task = asyncio.create_task(self._loop(), name="strategy-engine")
|
||
|
||
async def emergency_close(self) -> dict[str, Any]:
|
||
async with self._lock:
|
||
close_data: dict[str, Any] | None = None
|
||
detail = "flat"
|
||
ok = True
|
||
pos = self.matcher.current_position()
|
||
st = str(pos.get("status") or "flat")
|
||
|
||
if st == "half_open":
|
||
repair = getattr(self.matcher, "repair_half_open", None)
|
||
if callable(repair):
|
||
r = repair()
|
||
else:
|
||
r = self.matcher.close_group(reason="emergency", bypass_liquidity=True)
|
||
ok = r.ok
|
||
detail = r.detail
|
||
close_data = r.data
|
||
if r.ok:
|
||
self.enter_rest_after_close()
|
||
elif st == "opening":
|
||
recover = getattr(self.matcher, "recover_opening", None)
|
||
if callable(recover):
|
||
r = recover()
|
||
ok = r.ok
|
||
detail = r.detail
|
||
close_data = r.data
|
||
st2 = str(self.matcher.current_position().get("status") or "")
|
||
if r.ok and st2 in ("flat",):
|
||
self.enter_rest_after_close()
|
||
else:
|
||
ok = False
|
||
detail = (
|
||
"stuck opening：请核对交易所期权/永续后人工处理"
|
||
"（已占槽防重复开）"
|
||
)
|
||
close_data = {"status": "opening"}
|
||
try:
|
||
from ..notify import wecom
|
||
|
||
wecom.notify_fault(
|
||
title="紧急全平遇到 stuck opening",
|
||
detail=detail,
|
||
dedupe_key="emergency:opening",
|
||
)
|
||
except Exception:
|
||
pass
|
||
elif st in ("open", "option_closed_perp_pending"):
|
||
# A：双腿（或续平永续）
|
||
r = self.matcher.close_group(reason="emergency", bypass_liquidity=True)
|
||
if not r.ok and st == "open":
|
||
# B：砸不出期权时强制只平永续（不要求远虚）
|
||
abandon = getattr(self.matcher, "close_perp_abandon_option", None)
|
||
if callable(abandon):
|
||
try:
|
||
r2 = abandon(reason="emergency_perp", require_deep_otm=False)
|
||
except TypeError:
|
||
r2 = abandon(reason="emergency_perp")
|
||
if r2.ok:
|
||
r = r2
|
||
ok = r.ok
|
||
detail = r.detail
|
||
close_data = r.data
|
||
if r.ok:
|
||
self.enter_rest_after_close()
|
||
|
||
residuals = self.matcher.settle_all_residuals_now()
|
||
try:
|
||
if ok:
|
||
from ..notify import wecom
|
||
|
||
wecom.notify_close(
|
||
reason="emergency",
|
||
detail=detail,
|
||
data=close_data or {},
|
||
)
|
||
except Exception:
|
||
logger.exception("wecom emergency notify failed")
|
||
return {
|
||
"close": {
|
||
"ok": ok,
|
||
"detail": detail,
|
||
"data": close_data,
|
||
"residuals_settled": residuals,
|
||
},
|
||
"state": self.state(),
|
||
}
|
||
|
||
def enter_rest_after_close(self) -> None:
|
||
"""全平成功后进入组间休息（自动 / 手动 / 紧急共用）。"""
|
||
self._after_close()
|
||
|
||
def _closed_rounds(self) -> int:
|
||
"""已完成组数 = 已平仓组数量（与顶栏总交易口径一致，避免计数漂移）。"""
|
||
row = self.db.fetchone(
|
||
"SELECT COUNT(*) AS n FROM groups WHERE status='closed'"
|
||
)
|
||
return int(row["n"] or 0) if row else 0
|
||
|
||
def _after_close(self) -> None:
|
||
s = get_settings()
|
||
rounds = self._closed_rounds()
|
||
rest_sec = self.ledger.get_setting_int("rest_seconds", s.rest_seconds)
|
||
rest_until = int(time.time() * 1000) + rest_sec * 1000
|
||
self._set_state(
|
||
rounds_done=rounds,
|
||
phase="resting",
|
||
rest_until_ms=rest_until,
|
||
)
|
||
|
||
def _count_groups_for_day(self, wkey: str) -> int:
|
||
rows = self.db.fetchall(
|
||
"SELECT group_id FROM groups WHERE group_id LIKE ?",
|
||
(f"G-{wkey}-%",),
|
||
)
|
||
return len(rows)
|
||
|
||
def _position_expiry_ms(self, upl: dict[str, Any]) -> int | None:
|
||
raw = upl.get("expiry_ms")
|
||
if raw is not None:
|
||
try:
|
||
return int(raw)
|
||
except (TypeError, ValueError):
|
||
pass
|
||
ymd = upl.get("expiry_ymd")
|
||
if ymd:
|
||
try:
|
||
from ..exchange.expiry import expiry_ms_from_ymd
|
||
|
||
return int(expiry_ms_from_ymd(str(ymd)))
|
||
except Exception:
|
||
return None
|
||
return None
|
||
|
||
async def _close_open_position(
|
||
self,
|
||
*,
|
||
reason: str,
|
||
bypass_liquidity: bool,
|
||
pending_close: bool,
|
||
abandon_if_deep_otm: bool = False,
|
||
retry_kind: str | None = None,
|
||
) -> None:
|
||
kind = retry_kind or (
|
||
"perp_pending"
|
||
if reason == "perp_pending_retry"
|
||
else ("liquidity" if pending_close or not bypass_liquidity else "close")
|
||
)
|
||
allowed, left = self._retry_allowed(kind)
|
||
if not allowed:
|
||
self._set_state(
|
||
phase="liquidity_wait" if kind == "liquidity" else "closing",
|
||
last_error=f"限流/失败退避中，{left:.0f}s 后再试 ({kind})",
|
||
)
|
||
return
|
||
|
||
if not pending_close:
|
||
self._set_state(phase="closing", last_error=None)
|
||
|
||
# 目标平仓 B：远虚 → 只平永续，期权归档
|
||
if abandon_if_deep_otm and reason != "expiry" and self.matcher.option_is_deep_otm():
|
||
abandon = self.matcher.close_perp_abandon_option
|
||
try:
|
||
r = await asyncio.to_thread(
|
||
abandon,
|
||
reason="target_perp_only",
|
||
require_deep_otm=True,
|
||
)
|
||
except TypeError:
|
||
r = await asyncio.to_thread(abandon, reason="target_perp_only")
|
||
if r.ok:
|
||
self._note_retry_result(kind, ok=True)
|
||
self._after_close()
|
||
self._set_state(
|
||
last_error=None,
|
||
phase="resting",
|
||
)
|
||
try:
|
||
from ..notify import wecom
|
||
|
||
wecom.notify_close(
|
||
reason="target_perp_only",
|
||
detail=r.detail,
|
||
data=r.data or {},
|
||
)
|
||
except Exception:
|
||
logger.exception("wecom notify_close failed")
|
||
else:
|
||
self._note_retry_result(kind, ok=False, detail=r.detail)
|
||
self._set_state(phase="closing", last_error=r.detail)
|
||
return
|
||
|
||
r = await asyncio.to_thread(
|
||
self.matcher.close_group,
|
||
reason=reason,
|
||
bypass_liquidity=bypass_liquidity,
|
||
)
|
||
if r.ok:
|
||
self._note_retry_result(kind, ok=True)
|
||
self._after_close()
|
||
try:
|
||
from ..notify import wecom
|
||
|
||
wecom.notify_close(
|
||
reason=reason,
|
||
detail=r.detail,
|
||
data=r.data or {},
|
||
)
|
||
except Exception:
|
||
logger.exception("wecom notify_close failed")
|
||
elif r.liquidity_wait and not bypass_liquidity:
|
||
# 等待期间若已变成远虚，下一 tick 走归档
|
||
if self.matcher.option_is_deep_otm():
|
||
r2 = await asyncio.to_thread(
|
||
self.matcher.close_perp_abandon_option,
|
||
reason="target_perp_only",
|
||
)
|
||
if r2.ok:
|
||
self._note_retry_result(kind, ok=True)
|
||
self._after_close()
|
||
try:
|
||
from ..notify import wecom
|
||
|
||
wecom.notify_close(
|
||
reason="target_perp_only",
|
||
detail=r2.detail,
|
||
data=r2.data or {},
|
||
)
|
||
except Exception:
|
||
logger.exception("wecom notify_close failed")
|
||
return
|
||
self._note_retry_result("liquidity", ok=False, detail=r.detail)
|
||
self._set_state(phase="liquidity_wait", last_error=r.detail)
|
||
else:
|
||
self._note_retry_result(kind, ok=False, detail=r.detail)
|
||
self._set_state(phase="closing", last_error=r.detail)
|
||
|
||
async def _settle_residuals(self) -> None:
|
||
await asyncio.to_thread(self.matcher.settle_due_residuals)
|
||
|
||
async def _maybe_expiry_close(self) -> bool:
|
||
"""若持仓已到期则强制全平。返回是否触发到期平仓。"""
|
||
await self._settle_residuals()
|
||
pos = self.matcher.current_position()
|
||
if pos.get("status") not in ("open", "option_closed_perp_pending"):
|
||
return False
|
||
upl = self.matcher.unrealized()
|
||
expired = check_expiry_close(expiry_ms=self._position_expiry_ms(upl))
|
||
if not expired.should_close:
|
||
return False
|
||
st = self.db.fetchone("SELECT * FROM strategy_state WHERE id=1")
|
||
assert st is not None
|
||
pending = st["phase"] in ("liquidity_wait", "closing")
|
||
await self._close_open_position(
|
||
reason="expiry",
|
||
bypass_liquidity=True,
|
||
pending_close=pending,
|
||
abandon_if_deep_otm=False,
|
||
retry_kind="expiry",
|
||
)
|
||
return True
|
||
|
||
async def _loop(self) -> None:
|
||
logger.info("strategy engine loop started")
|
||
while True:
|
||
try:
|
||
row = self.db.fetchone("SELECT running FROM strategy_state WHERE id=1")
|
||
running = bool(row and int(row["running"]))
|
||
if not running:
|
||
# 暂停：不新开仓；仍盯目标平仓 + 到期平仓
|
||
async with self._lock:
|
||
await self._tick_manage_positions()
|
||
await asyncio.sleep(1)
|
||
continue
|
||
async with self._lock:
|
||
try:
|
||
await get_session().ensure_atm_async(force=False)
|
||
except Exception as e:
|
||
logger.warning("ATM ensure before tick failed: %s", e)
|
||
await self._tick_async()
|
||
except asyncio.CancelledError:
|
||
raise
|
||
except Exception as e:
|
||
err = str(e)
|
||
if is_rate_limit_error(err):
|
||
logger.warning("strategy tick rate-limited: %s", err[:200])
|
||
self._set_state(last_error="交易/行情接口限流，稍后自动重试")
|
||
await asyncio.sleep(20)
|
||
continue
|
||
logger.exception("strategy tick failed")
|
||
self._set_state(last_error=err)
|
||
try:
|
||
from ..notify import wecom
|
||
|
||
wecom.notify_fault(
|
||
title="策略循环异常",
|
||
detail=err,
|
||
dedupe_key=f"tick:{err[:80]}",
|
||
)
|
||
except Exception:
|
||
pass
|
||
sleep_for = 1.0 + max(0.0, self._extra_sleep_sec)
|
||
self._extra_sleep_sec = 0.0
|
||
await asyncio.sleep(min(sleep_for, 60.0))
|
||
|
||
async def _tick_manage_positions(self) -> None:
|
||
"""有仓时的盯盘：残留结算 / 半仓修复 / 目标平 / 到期平。不新开仓。"""
|
||
await self._settle_residuals()
|
||
|
||
s = get_settings()
|
||
st = self.db.fetchone("SELECT * FROM strategy_state WHERE id=1")
|
||
assert st is not None
|
||
exit_mode = self.ledger.get_setting_str("exit_mode", s.exit_mode)
|
||
net_target = self.ledger.get_setting_float(
|
||
"net_profit_target", s.net_profit_target
|
||
)
|
||
prem_mult = self.ledger.get_setting_float(
|
||
"premium_exit_multiple", s.premium_exit_multiple
|
||
)
|
||
pos = self.matcher.current_position()
|
||
st_pos = str(pos.get("status") or "flat")
|
||
|
||
if st_pos == "opening":
|
||
allowed, left = self._retry_allowed("opening")
|
||
if not allowed:
|
||
self._set_state(
|
||
phase="opening_stuck",
|
||
last_error=f"opening 恢复退避中，{left:.0f}s 后再试",
|
||
)
|
||
return
|
||
recover = getattr(self.matcher, "recover_opening", None)
|
||
if callable(recover):
|
||
r = await asyncio.to_thread(recover)
|
||
self._note_retry_result("opening", ok=r.ok, detail=r.detail)
|
||
if r.ok:
|
||
try:
|
||
from ..notify import wecom
|
||
|
||
wecom.notify_fault(
|
||
title="opening 已自动恢复",
|
||
detail=r.detail,
|
||
dedupe_key=f"opening_ok:{r.detail[:60]}",
|
||
)
|
||
except Exception:
|
||
pass
|
||
# 恢复后按新状态继续本 tick（half_open/open/flat）
|
||
pos = self.matcher.current_position()
|
||
st_pos = str(pos.get("status") or "flat")
|
||
if st_pos == "opening":
|
||
self._set_state(phase="opening_stuck", last_error=r.detail)
|
||
return
|
||
if st_pos == "flat":
|
||
self._set_state(phase="idle", last_error=None)
|
||
return
|
||
# half_open / open / pending：落入下方分支
|
||
self._set_state(
|
||
phase="open" if st_pos == "open" else "closing",
|
||
last_error=None,
|
||
)
|
||
else:
|
||
self._set_state(phase="opening_stuck", last_error=r.detail)
|
||
try:
|
||
from ..notify import wecom
|
||
|
||
wecom.notify_fault(
|
||
title="opening 恢复失败",
|
||
detail=r.detail,
|
||
dedupe_key=f"opening_fail:{r.detail[:60]}",
|
||
)
|
||
except Exception:
|
||
pass
|
||
return
|
||
else:
|
||
return
|
||
|
||
if st_pos == "half_open":
|
||
allowed, left = self._retry_allowed("half_open")
|
||
if not allowed:
|
||
self._set_state(
|
||
phase="closing",
|
||
last_error=f"half_open 修复退避中，{left:.0f}s 后再试",
|
||
)
|
||
return
|
||
repair = getattr(self.matcher, "repair_half_open", None)
|
||
if callable(repair):
|
||
r = await asyncio.to_thread(repair)
|
||
if r.ok:
|
||
self._note_retry_result("half_open", ok=True)
|
||
self._after_close()
|
||
self._set_state(phase="resting", last_error=None)
|
||
try:
|
||
from ..notify import wecom
|
||
|
||
wecom.notify_close(
|
||
reason="emergency",
|
||
detail=r.detail or "half_open repaired",
|
||
data=r.data or {},
|
||
)
|
||
except Exception:
|
||
pass
|
||
else:
|
||
self._note_retry_result("half_open", ok=False, detail=r.detail)
|
||
self._set_state(phase="closing", last_error=r.detail)
|
||
return
|
||
|
||
if st_pos == "option_closed_perp_pending":
|
||
await self._close_open_position(
|
||
reason="perp_pending_retry",
|
||
bypass_liquidity=True,
|
||
pending_close=True,
|
||
abandon_if_deep_otm=False,
|
||
retry_kind="perp_pending",
|
||
)
|
||
return
|
||
|
||
if st_pos == "open":
|
||
upl = self.matcher.unrealized()
|
||
from .exits import lock_trade_exit_target, read_locked_exit_target
|
||
|
||
locked_exit = read_locked_exit_target(upl)
|
||
if locked_exit is None and upl.get("group_id"):
|
||
try:
|
||
locked_exit = lock_trade_exit_target(
|
||
self.db,
|
||
group_id=str(upl["group_id"]),
|
||
initial_premium=float(upl.get("initial_premium") or 0),
|
||
)
|
||
except Exception:
|
||
logger.exception("backfill exit lock failed")
|
||
expired = check_expiry_close(expiry_ms=self._position_expiry_ms(upl))
|
||
decision = check_exits(
|
||
net_pnl=float(upl.get("net_pnl") or 0),
|
||
exit_mode=exit_mode,
|
||
net_profit_target=net_target,
|
||
premium_exit_multiple=prem_mult,
|
||
initial_premium=float(upl.get("initial_premium") or 0),
|
||
locked_exit_target=locked_exit,
|
||
)
|
||
pending_close = st["phase"] in ("liquidity_wait", "closing")
|
||
if expired.should_close or decision.should_close or pending_close:
|
||
if expired.should_close:
|
||
reason = "expiry"
|
||
bypass = True
|
||
abandon = False
|
||
rkind = "expiry"
|
||
else:
|
||
reason = decision.reason or "liquidity_retry"
|
||
bypass = False
|
||
abandon = bool(decision.should_close or pending_close)
|
||
rkind = "liquidity" if pending_close else "close"
|
||
await self._close_open_position(
|
||
reason=reason,
|
||
bypass_liquidity=bypass,
|
||
pending_close=pending_close,
|
||
abandon_if_deep_otm=abandon,
|
||
retry_kind=rkind,
|
||
)
|
||
else:
|
||
self._set_state(phase="open", last_error=None)
|
||
|
||
async def _tick_async(self) -> None:
|
||
# 先盯仓（平仓路径）
|
||
await self._tick_manage_positions()
|
||
|
||
s = get_settings()
|
||
st = self.db.fetchone("SELECT * FROM strategy_state WHERE id=1")
|
||
assert st is not None
|
||
wkey = window_key()
|
||
if st["window_key"] != wkey:
|
||
self._set_state(window_key=wkey, phase="idle")
|
||
|
||
st = self.db.fetchone("SELECT * FROM strategy_state WHERE id=1")
|
||
assert st is not None
|
||
pos = self.matcher.current_position()
|
||
st_pos = str(pos.get("status") or "flat")
|
||
# 仍有活跃仓或半仓：本 tick 不再开新仓
|
||
if st_pos in ("open", "half_open", "option_closed_perp_pending", "opening"):
|
||
return
|
||
|
||
if st["phase"] == "resting" and st["rest_until_ms"]:
|
||
if int(time.time() * 1000) < int(st["rest_until_ms"]):
|
||
return
|
||
self._set_state(phase="idle", rest_until_ms=None)
|
||
|
||
st = self.db.fetchone("SELECT * FROM strategy_state WHERE id=1")
|
||
assert st is not None
|
||
if st["phase"] in ("paused",):
|
||
return
|
||
|
||
# 旧「轮次停开」状态：自动恢复为空闲以便继续
|
||
if st["phase"] in ("stopped", "outside_window"):
|
||
self._set_state(phase="idle")
|
||
|
||
skip_weekends = self.ledger.get_setting_bool("skip_weekends", s.skip_weekends)
|
||
if not can_open_new(skip_weekends=skip_weekends):
|
||
self._set_state(
|
||
phase="weekend_skip",
|
||
last_error="周六/周日跳过开仓（上海时区）；持仓仍可平仓",
|
||
)
|
||
return
|
||
if st["phase"] == "weekend_skip":
|
||
self._set_state(phase="idle", last_error=None)
|
||
|
||
# 双保险：账本仍显示有仓则不开
|
||
if self.matcher.has_open_position():
|
||
self._set_state(phase="open", last_error="有未平仓，禁止开下一组")
|
||
return
|
||
|
||
# OKX：等待选约时仅预览名义+兑 USDC（不落库改 qty/exit）
|
||
try:
|
||
from .open_pipeline import prepare_usdc_while_waiting
|
||
|
||
prep = prepare_usdc_while_waiting(self.db)
|
||
conv = prep.get("convert") or {}
|
||
if conv.get("acted"):
|
||
logger.info("auto_usdc while waiting: %s", conv.get("detail"))
|
||
elif conv.get("ok") is False:
|
||
logger.warning("auto_usdc while waiting: %s", conv.get("detail"))
|
||
except Exception:
|
||
logger.exception("prepare USDC while waiting failed")
|
||
|
||
self._set_state(phase="wait_signal")
|
||
pick = await get_session().pick_for_open_async()
|
||
if pick is None:
|
||
try:
|
||
from .open_capacity import assess_open_capacity, funds_gate_blocks
|
||
|
||
cap = assess_open_capacity(self.db)
|
||
blocked, why = funds_gate_blocks(cap)
|
||
if blocked and cap.get("option_can_open") is False:
|
||
self._set_state(
|
||
phase="wait_funds",
|
||
last_error=(
|
||
"无合格期权；且交易账户 USDC 不够开仓"
|
||
f"（需≈{cap.get('option_need_usdc')}U / 有{cap.get('option_have_usdc')}U）。"
|
||
"系统会在冷却后自动市价兑 USDC。"
|
||
),
|
||
)
|
||
return
|
||
if blocked and cap.get("option_can_open") is None:
|
||
self._set_state(
|
||
phase="wait_funds",
|
||
last_error=why,
|
||
)
|
||
return
|
||
except Exception:
|
||
pass
|
||
self._set_state(
|
||
last_error="无合格期权：需剩余时长、杠杆（及已开启的ATM偏差）同时满足"
|
||
)
|
||
return
|
||
|
||
# 选约后：定仓落库 → 兑 USDC → 资金门 fail-closed（与手动开仓同一管道）
|
||
from .open_pipeline import size_and_gate
|
||
|
||
prep = size_and_gate(
|
||
index_px=float(pick.underlying_px),
|
||
option_ask=float(pick.option_ask),
|
||
db=self.db,
|
||
)
|
||
if not prep.ok:
|
||
phase = "wait_funds" if prep.capacity is not None else "idle"
|
||
self._set_state(phase=phase, last_error=prep.detail)
|
||
if prep.capacity is not None:
|
||
maybe_notify_funds_short(prep.capacity)
|
||
if "以损定仓" in (prep.detail or ""):
|
||
try:
|
||
from ..notify import wecom
|
||
|
||
wecom.notify_fault(
|
||
title="以损定仓失败",
|
||
detail=prep.detail,
|
||
dedupe_key=f"risk_sizing:{prep.detail[:80]}",
|
||
)
|
||
except Exception:
|
||
pass
|
||
return
|
||
if st["phase"] == "wait_funds":
|
||
self._set_state(phase="idle", last_error=None)
|
||
|
||
self._set_state(phase="opening", last_error=None)
|
||
wkey = window_key()
|
||
count = self._count_groups_for_day(wkey)
|
||
gid = next_group_id(count)
|
||
option_inst = (
|
||
pick.pair.call_inst_id if pick.option_side == "call" else pick.pair.put_inst_id
|
||
)
|
||
entry_idx = pick.underlying_px
|
||
if not get_settings().is_sim:
|
||
from ..live.reconcile import assert_safe_to_open_live
|
||
|
||
safe, safe_msg = assert_safe_to_open_live(self.matcher)
|
||
if not safe:
|
||
self._set_state(phase="idle", last_error=safe_msg)
|
||
try:
|
||
from ..notify import wecom
|
||
|
||
wecom.notify_fault(
|
||
title="开仓前对账拒绝",
|
||
detail=safe_msg,
|
||
dedupe_key=f"recon:{safe_msg[:80]}",
|
||
)
|
||
except Exception:
|
||
pass
|
||
return
|
||
r = await asyncio.to_thread(
|
||
self.matcher.open_group,
|
||
group_id=gid,
|
||
bias=pick.bias,
|
||
option_side=pick.option_side,
|
||
perp_side=pick.perp_side,
|
||
option_inst_id=option_inst,
|
||
entry_index_px=float(entry_idx),
|
||
strike=pick.pair.strike,
|
||
expiry_ymd=pick.pair.expiry_ymd,
|
||
)
|
||
if r.ok:
|
||
self._set_state(phase="open", last_error=None)
|
||
try:
|
||
from ..notify import wecom
|
||
|
||
wecom.notify_open(
|
||
group_id=gid,
|
||
detail=r.detail,
|
||
extra={
|
||
"bias": pick.bias,
|
||
"option_side": pick.option_side,
|
||
"option_inst_id": option_inst,
|
||
"strike": pick.pair.strike,
|
||
"expiry_ymd": pick.pair.expiry_ymd,
|
||
},
|
||
)
|
||
except Exception:
|
||
logger.exception("wecom notify_open failed")
|
||
else:
|
||
# 保留 opening 时勿伪装 idle
|
||
pos_after = self.matcher.current_position()
|
||
if str(pos_after.get("status") or "") == "opening":
|
||
self._set_state(phase="opening_stuck", last_error=r.detail)
|
||
else:
|
||
self._set_state(phase="idle", last_error=r.detail)
|
||
try:
|
||
from ..notify import wecom
|
||
|
||
wecom.notify_fault(
|
||
title="开仓失败",
|
||
detail=r.detail,
|
||
dedupe_key=f"open_fail:{r.detail[:80]}",
|
||
)
|
||
except Exception:
|
||
pass
|
||
|
||
|
||
_engine: StrategyEngine | None = None
|
||
|
||
|
||
def get_engine() -> StrategyEngine:
|
||
global _engine
|
||
if _engine is None:
|
||
_engine = StrategyEngine()
|
||
return _engine
|
||
|
||
|
||
def set_engine(engine: StrategyEngine | None) -> None:
|
||
global _engine
|
||
_engine = engine
|