623 lines
31 KiB
Python
623 lines
31 KiB
Python
# -*- coding: utf-8 -*-
|
|
"""
|
|
个股交易方案 (策略) 运行器 —— PER_STOCK_STRATEGY_PLAN.md §四/§六/§七/§七B
|
|
============================================================================
|
|
每分钟一跳 (挂在 scheduler.intraday_exec 里, 与 run_tick 并列)。载入 ACTIVE 策略, 按类型
|
|
评估 (做T / 网格 / 跟踪止盈), 触发就**发一张短窗口指令** (window_tdays=1, is_command=True,
|
|
origin_type='strategy'), 交 executor.run_tick 用现有管线执行 —— 择时 / 规则闸 / T+1 可卖封顶 /
|
|
下发 / 账本一道不重写; autonomy=confirm 的落一条提议进「等我拍板」, 人点采纳后再由本层发指令。
|
|
|
|
**只做加法**: 本模块不改 executor / rule_gate / action_engine 任何一行, 唯一的引擎触点是
|
|
action_engine.scan 早已加好的「有 ACTIVE 策略的票跳过」那一条 skip (设计 §四)。
|
|
|
|
一条铁律定了整个框架 —— T+1 (设计 §三)
|
|
--------------------------------------------------
|
|
当日买入不可当日卖出, 所以做T / 网格 / 跟踪止盈本质都是「在一只**底仓**上、用 T+1 可卖的存量股
|
|
做买卖」= 同一自动机的三种配置。卖出腿一律经 run_tick 按 avail_qty 封顶, T+1 天然被挡在那里。
|
|
|
|
批次口径 (与 app/core/recon.ACTION_TO_LOT 对齐, 不另立)
|
|
--------------------------------------------------
|
|
做T —— 买卖两腿都用 action='T0_ROUND' → 记 T0 批次; 卖出核销次序 T0→ADD→DCA→FILL→BASE
|
|
先把 T0 批次对冲掉, 底仓与摊薄成本不动, 做T利润自然摊入 realized_t_profit。
|
|
网格 —— 买腿 action='ADD' (记 ADD 批次), 卖腿 action='TRIM' (从 avail 卖)。
|
|
跟踪止盈 —— 卖腿 action='TRIM' (部分) / 'EXIT' (全清)。只卖不买。
|
|
|
|
安全 (设计 §九)
|
|
--------------------------------------------------
|
|
* 全局开关 PMS_STRATEGY_ENABLED (默认 False) —— 关着时本模块整体空转、一条指令都不发。
|
|
* 挂了 ACTIVE 策略的票由 action_engine.scan 排除 (两个大脑不抢同一只)。
|
|
* 策略动作走命令口径 (is_command=True, 过规则闸、不过研判闸)。
|
|
* scheduler 的 @guard(session=True) 兜住: 非交易时段 / 休假模式不跑。
|
|
* 影子/实盘由 PMS_DISPATCH_MODE 决定 (shadow=只落影子出口不碰真 QMT), 与本层无关、自动继承。
|
|
* **双保险**: 本层 rails 先拦 (熔断 / 当日次数 / 上限 / 平回 / 下界), 规则闸再拦一道 (合规)。
|
|
* **关键路径禁止丢弃返回值**: 发不出指令 / 落不了库一律进 out["errors"], 绝不静默当成功。
|
|
"""
|
|
from __future__ import annotations
|
|
|
|
import logging
|
|
from datetime import datetime
|
|
|
|
from app.core import tradedays as td
|
|
from app.core.sizer import LOT
|
|
from app.repo import pms_repo
|
|
from app.services import market, param_store, portfolio
|
|
|
|
logger = logging.getLogger("pms.strategy")
|
|
|
|
# 指令在途 (未终态) 的状态集 —— 与 executor.LIVE 一致; 本层据此判断「上一腿还没走完, 先别再发」。
|
|
LIVE_INS = ("PROPOSED", "RULE_PASSED", "DISPATCHED")
|
|
|
|
# 批次动作 (与 recon.ACTION_TO_LOT 对齐)
|
|
A_T0 = "T0_ROUND" # 做T 买卖两腿 → T0 批次
|
|
A_GRID_BUY = "ADD" # 网格买腿 → ADD 批次
|
|
A_SELL = "TRIM" # 网格 / 跟踪止盈 部分卖
|
|
A_EXIT = "EXIT" # 跟踪止盈 全清 (允许零股一次性清出)
|
|
|
|
# 触发用的小额贴近带 (设计只说「近支撑 / 近压力 / 滞涨」, 未给具体数; 这里取保守小带并写明)。
|
|
NEAR_BAND = 0.005 # 现价距支撑/压力 0.5% 以内算「贴近」
|
|
OFF_HIGH_BAND = 0.003 # 距当日高点回落 0.3% 以上算「滞涨」(反T 用)
|
|
|
|
|
|
# ================================================================ 取数小工具
|
|
def _f(v, d=0.0):
|
|
try:
|
|
return float(v)
|
|
except (TypeError, ValueError):
|
|
return d
|
|
|
|
|
|
def _pos_of(view: dict, code: str) -> dict:
|
|
for x in view.get("positions") or []:
|
|
if x.get("ts_code") == code:
|
|
return x
|
|
return {}
|
|
|
|
|
|
def _round_lot(qty) -> int:
|
|
"""向下取整到一手 (100 股)。不足一手返回 0。"""
|
|
n = int(_f(qty))
|
|
return (n // LOT) * LOT
|
|
|
|
|
|
def _today() -> int:
|
|
return td.ymd()
|
|
|
|
|
|
# ================================================================ 指令 / 提议下发
|
|
def _emit_instruction(st: dict, dec: dict, *, forced: bool = False) -> str:
|
|
"""按决策发一张短窗口命令指令 (window_tdays=1, is_command=True), 交 run_tick 执行。
|
|
|
|
返回 instruction_id。limit_price 不在这里定 —— 交由 run_tick 的择时按实时行情现算
|
|
(与 materialize_plans 同口径: 那里也是 limit_price=None)。
|
|
"""
|
|
code = st["ts_code"]
|
|
now = datetime.now()
|
|
iid = f"STR{_today()}{now.strftime('%H%M%S')}_{code.replace('.', '')}_{dec['leg'][:1]}"[:40]
|
|
prog = {"is_command": True, "deadline": str(_today()), "children": [],
|
|
"origin": "strategy", "strategy_id": st["strategy_id"], "stype": st.get("type"),
|
|
"leg": dec["leg"], "reason": dec.get("reason"), "forced": bool(forced)}
|
|
pms_repo.insert_instruction(
|
|
instruction_id=iid, origin_type="strategy", origin_id=st["strategy_id"],
|
|
ts_code=code, action=dec["action"], side=dec["side"], qty=int(dec["qty"]),
|
|
limit_price=None, window_tdays=1, status="PROPOSED", progress=prog)
|
|
return iid
|
|
|
|
|
|
def _emit_proposal(st: dict, dec: dict) -> str:
|
|
"""autonomy=confirm: 落一条提议进「等我拍板」。hard_numbers 里带全腿谱, 人采纳后由
|
|
main._decide 识别 kind=strategy 再回调本层发指令 (不走通用物化, 因为 T0 两腿同 action、
|
|
side 无法由 action 反推)。"""
|
|
code = st["ts_code"]
|
|
now = datetime.now()
|
|
pid = f"STP{_today()}{now.strftime('%H%M%S')}_{code.replace('.', '')}"[:40]
|
|
hard = {"kind": "strategy", "strategy_id": st["strategy_id"], "stype": st.get("type"),
|
|
"side": dec["side"], "leg": dec["leg"], "action": dec["action"],
|
|
"qty": int(dec["qty"]), "reason": dec.get("reason"), "entry": dec.get("entry")}
|
|
expire = now.replace(hour=15, minute=0, second=0, microsecond=0)
|
|
pms_repo.insert_proposal(proposal_id=pid, ts_code=code, action=dec["action"],
|
|
qty=int(dec["qty"]), hard_numbers=hard, expire_at=expire,
|
|
judge_verdict="STRATEGY",
|
|
judge_reason=f"{st.get('type')} · {dec.get('reason')}")
|
|
return pid
|
|
|
|
|
|
def emit_from_spec(spec: dict) -> dict:
|
|
"""confirm 提议被采纳后的回调 (main._decide 调): 按 hard_numbers 里存的腿谱发指令。
|
|
返回 {ok, instruction_id} 或 {ok:false, error}。"""
|
|
try:
|
|
st = pms_repo.get_strategy(spec.get("strategy_id"))
|
|
if not st:
|
|
return {"ok": False, "error": "策略不存在或已撤下"}
|
|
if st.get("status") != "ACTIVE":
|
|
return {"ok": False, "error": f"策略处于 {st.get('status')}, 不再发指令"}
|
|
dec = {"side": spec["side"], "action": spec["action"], "qty": int(spec["qty"]),
|
|
"leg": spec.get("leg") or "open", "reason": spec.get("reason"),
|
|
"entry": spec.get("entry")}
|
|
iid = _emit_instruction(st, dec)
|
|
state = dict(st.get("state") or {})
|
|
state["pending"] = {"iid": iid, "leg": dec["leg"], "dir": spec.get("dir"),
|
|
"qty": dec["qty"], "entry": dec.get("entry")}
|
|
pms_repo.update_strategy(st["strategy_id"], state=state)
|
|
return {"ok": True, "instruction_id": iid}
|
|
except Exception as e: # noqa: BLE001
|
|
logger.exception("[strategy] 采纳提议发指令失败")
|
|
return {"ok": False, "error": f"{type(e).__name__}: {e}"}
|
|
|
|
|
|
# ================================================================ 在途腿的收敛
|
|
def _pending_terminal(pending: dict):
|
|
"""上一腿是否已终态。返回 (已终态?, 指令行 or None)。无 pending 视为已终态。"""
|
|
if not pending:
|
|
return True, None
|
|
iid = pending.get("iid")
|
|
if not iid: # confirm 提议还没被采纳 —— 看提议是否还在等
|
|
pid = pending.get("pid")
|
|
if not pid:
|
|
return True, None
|
|
pr = pms_repo.get_proposal(pid)
|
|
if pr and pr.get("status") == "WAIT_USER":
|
|
return False, None # 还在等人拍板, 先别再发
|
|
return True, None # 已采纳(转指令,另有pending.iid)/驳回/过期
|
|
ins = pms_repo.get_instruction(iid)
|
|
if not ins:
|
|
return True, None
|
|
return (ins.get("status") not in LIVE_INS), ins
|
|
|
|
|
|
def _reconcile(st: dict, state: dict, pos: dict):
|
|
"""把已终态的上一腿并进 state: 开仓腿成交 → 记 open_leg; 平仓腿成交 → 记一次完成、清 open_leg。
|
|
|
|
做T 用; 网格 / 跟踪止盈 的 filled_levels / high_water 在各自评估器里按现价推进, 不依赖这里。
|
|
"""
|
|
pending = state.get("pending")
|
|
done, ins = _pending_terminal(pending)
|
|
if not done:
|
|
return False # 上一腿未走完
|
|
state["pending"] = None
|
|
if not ins or not pending or not pending.get("iid"):
|
|
return True
|
|
filled = int(ins.get("exec_qty") or 0) > 0
|
|
leg = pending.get("leg")
|
|
if st.get("type") == "T0":
|
|
if leg == "open" and filled:
|
|
state["open_leg"] = {"dir": pending.get("dir"), "qty": int(ins.get("exec_qty") or 0),
|
|
"entry": _f(pending.get("entry")) or _f(ins.get("limit_price")),
|
|
"opened_at": ins.get("updated_at") and str(ins["updated_at"])}
|
|
elif leg == "close":
|
|
# 平仓腿终态: 只有真成交才算一轮完成; 一股没成 (到期/被拒) 要**保留 open_leg**,
|
|
# 让下一跳与 14:50 平回继续补平 —— 绝不能把一条还开着的 T 仓静默丢掉。
|
|
filled_qty = int(ins.get("exec_qty") or 0)
|
|
ol = dict(state.get("open_leg") or {})
|
|
rem = _round_lot(_f(ol.get("qty")) - filled_qty)
|
|
if rem >= LOT:
|
|
ol["qty"] = rem
|
|
state["open_leg"] = ol
|
|
if filled_qty > 0:
|
|
logger.info("[strategy] %s 平仓腿部分成交 %s, 余 %s 股待续平",
|
|
st.get("strategy_id"), filled_qty, rem)
|
|
else:
|
|
state["t_count_today"] = int(state.get("t_count_today") or 0) + 1
|
|
state["open_leg"] = None
|
|
return True
|
|
|
|
|
|
# ================================================================ 评估器: 做T (设计 §六)
|
|
def _eval_t0(st, pos, day, now, ctx):
|
|
"""做T: 正T (回落近支撑 → 买, 目标价差高卖) / 反T (近压力或滞涨 → 卖, 低买回)。
|
|
|
|
rails: 当日 ≤ 3 次; 单票 / 全局当日T亏熔断后当日禁开新T (仍允许平回已开的腿);
|
|
14:50 强制平回由 force_t0_close 走 (本函数不管平回时点, 只管盘中触发)。
|
|
"""
|
|
state = ctx["state"]
|
|
price = _f(day.get("price"))
|
|
if price <= 0:
|
|
return None
|
|
total = int(pos.get("total_qty") or 0)
|
|
avail = int(pos.get("avail_qty") or 0)
|
|
params = st.get("params") or {}
|
|
t_ratio = min(_f(params.get("t_ratio")), param_store.get_float("PMS_T0_RATIO_MAX", 0.333))
|
|
t_qty = _round_lot(total * t_ratio)
|
|
|
|
open_leg = state.get("open_leg")
|
|
round_target = param_store.get_float("PMS_T0_ROUND_TARGET", 0.015)
|
|
|
|
# ---- 有未平的腿 → 只找平回机会 (熔断不挡平回) ----
|
|
if open_leg:
|
|
entry = _f(open_leg.get("entry")) or price
|
|
q = _round_lot(open_leg.get("qty"))
|
|
if open_leg.get("dir") == "long": # 正T: 已买, 等高卖
|
|
pressure = _f(pos.get("pressure_ref"))
|
|
hit = price >= entry * (1 + round_target) or (pressure > 0 and price >= pressure * (1 - NEAR_BAND))
|
|
if hit and q > 0:
|
|
return {"side": "sell", "action": A_T0, "qty": min(q, avail), "leg": "close",
|
|
"reason": f"正T平回: 现价 {price} 达目标 {entry * (1 + round_target):.2f}(买价 {entry})"}
|
|
else: # 反T: 已卖, 等低买回
|
|
support = _f(pos.get("support_ref"))
|
|
hit = price <= entry * (1 - round_target) or (support > 0 and price <= support * (1 + NEAR_BAND))
|
|
if hit and q > 0:
|
|
return {"side": "buy", "action": A_T0, "qty": q, "leg": "close",
|
|
"reason": f"反T平回: 现价 {price} 回到目标 {entry * (1 - round_target):.2f}(卖价 {entry})"}
|
|
return None
|
|
|
|
# ---- 无未平的腿 → 看要不要开新的一轮 (受熔断 / 3 次 / 存量约束) ----
|
|
if ctx.get("halted") or int(state.get("t_count_today") or 0) >= 3:
|
|
return None
|
|
if t_qty < LOT:
|
|
return None
|
|
high = _f(day.get("high"))
|
|
support = _f(pos.get("support_ref"))
|
|
pressure = _f(pos.get("pressure_ref"))
|
|
pull = param_store.get_float("PMS_T0_PULLBACK_PCT", 0.03)
|
|
rally = param_store.get_float("PMS_T0_RALLY_PCT", 0.05)
|
|
dayup = _f(day.get("day_chg_from_open"))
|
|
|
|
# 正T: 距当日高点回落 ≥ 回落阈 且 (近支撑 或 无支撑参照时仅凭回落, 写明)
|
|
if high > 0 and price <= high * (1 - pull):
|
|
near_sup = support > 0 and price <= support * (1 + NEAR_BAND)
|
|
if near_sup or support <= 0:
|
|
note = "近支撑" if near_sup else "无支撑参照, 仅凭回落(偏保守)"
|
|
return {"side": "buy", "action": A_T0, "qty": t_qty, "leg": "open", "dir": "long",
|
|
"entry": price,
|
|
"reason": f"正T开仓: 距高点 {high} 回落 {1 - price / high:.1%} 且{note}, 买 {t_qty} 股"}
|
|
|
|
# 反T: 近压力 或 (日内涨 ≥ 反T阈 且 已从高点滞涨) —— 卖 avail 的 t_qty, 待低买回
|
|
near_pre = pressure > 0 and price >= pressure * (1 - NEAR_BAND)
|
|
stalled = dayup >= rally and high > 0 and price <= high * (1 - OFF_HIGH_BAND)
|
|
if (near_pre or stalled) and avail >= LOT:
|
|
q = min(t_qty, _round_lot(avail))
|
|
if q >= LOT:
|
|
why = "近压力" if near_pre else f"日内涨 {dayup:.1%} 滞涨"
|
|
return {"side": "sell", "action": A_T0, "qty": q, "leg": "open", "dir": "short",
|
|
"entry": price, "reason": f"反T开仓: {why}, 卖 {q} 股待低买回"}
|
|
return None
|
|
|
|
|
|
# ================================================================ 评估器: 网格 (设计 §七)
|
|
def _grid_levels(params: dict) -> list:
|
|
"""按 中枢/档距/上下界 生成一组网格价位 (由低到高)。档距支持百分比(step_pct)或绝对值(step)。"""
|
|
lo, hi = _f(params.get("lower")), _f(params.get("upper"))
|
|
center = _f(params.get("center"))
|
|
step = _f(params.get("step"))
|
|
step_pct = _f(params.get("step_pct"))
|
|
if lo <= 0 or hi <= lo:
|
|
return []
|
|
base = center if center > 0 else (lo + hi) / 2
|
|
if step <= 0 and step_pct > 0:
|
|
step = base * step_pct
|
|
if step <= 0:
|
|
return []
|
|
levels, p, guard = [], lo, 0
|
|
while p <= hi + 1e-9 and guard < 200:
|
|
levels.append(round(p, 3))
|
|
p += step
|
|
guard += 1
|
|
return levels
|
|
|
|
|
|
def _eval_grid(st, pos, day, now, ctx):
|
|
"""网格: 现价跌破未买档 → 买 1 份; 现价涨破已买档 → 卖 1 份(从 avail); 越上界停做;
|
|
跌破下界 = 继续持有、不再买 (设计四点拍板①)。"""
|
|
state = ctx["state"]
|
|
params = st.get("params") or {}
|
|
price = _f(day.get("price"))
|
|
if price <= 0:
|
|
return None
|
|
levels = _grid_levels(params)
|
|
if not levels:
|
|
return None
|
|
lo, hi = levels[0], levels[-1]
|
|
step = round(levels[1] - levels[0], 3) if len(levels) > 1 else 0
|
|
per_lot = _round_lot(params.get("per_lot")) or LOT
|
|
max_capital = _f(params.get("max_capital"))
|
|
filled = {int(k): v for k, v in (state.get("filled_levels") or {}).items()}
|
|
invested = _f(state.get("invested"))
|
|
avail = int(pos.get("avail_qty") or 0)
|
|
|
|
# 跌破下界: 停买入腿、保留已买、告警 (已买档回升仍按规则卖)
|
|
if price < lo:
|
|
if not state.get("below_floor"):
|
|
state["below_floor"] = True
|
|
ctx["notes"].append(f"{st['ts_code']} 跌破网格下界 {lo}, 已停止网格买入(继续持有已买档)")
|
|
# 下界之下不买, 但仍可卖 (若有已买档且价格回升) —— 落到下面卖出分支
|
|
else:
|
|
state["below_floor"] = False
|
|
|
|
# 卖出腿: 现价涨破某已买档 (买价 + 一档) → 卖那一份 (从 avail, T+1 由 run_tick 封顶)
|
|
sell_idx, sell_buyprice = None, -1.0
|
|
for idx, info in filled.items():
|
|
bp = _f(info.get("price"))
|
|
if bp > 0 and price >= bp + step and bp > sell_buyprice:
|
|
sell_idx, sell_buyprice = idx, bp
|
|
if sell_idx is not None and avail >= LOT:
|
|
q = min(per_lot, _round_lot(avail))
|
|
if q >= LOT:
|
|
return {"side": "sell", "action": A_SELL, "qty": q, "leg": f"grid_sell:{sell_idx}",
|
|
"grid_sell_idx": sell_idx,
|
|
"reason": f"网格卖: 现价 {price} 涨破买档 {sell_buyprice}(+一档 {step}), 卖 {q} 股"}
|
|
|
|
# 买入腿: 现价跌破某未买档 → 买一份 (受 max_capital 与 单股上限[规则闸] 双约束)
|
|
if state.get("below_floor") or price < lo or price > hi:
|
|
return None
|
|
buy_idx, buy_level = None, -1.0
|
|
for i, lv in enumerate(levels):
|
|
if i in filled:
|
|
continue
|
|
if price <= lv and lv > buy_level: # 现价已跌到/跌破该档
|
|
buy_idx, buy_level = i, lv
|
|
if buy_idx is not None:
|
|
need = per_lot * price
|
|
if max_capital > 0 and invested + need > max_capital + 1e-6:
|
|
if not state.get("cap_hit"):
|
|
state["cap_hit"] = True
|
|
ctx["notes"].append(f"{st['ts_code']} 网格已达最大投入 {max_capital:.0f} 元, 暂停买入")
|
|
return None
|
|
state["cap_hit"] = False
|
|
return {"side": "buy", "action": A_GRID_BUY, "qty": per_lot, "leg": f"grid_buy:{buy_idx}",
|
|
"grid_buy_idx": buy_idx, "grid_buy_price": price,
|
|
"reason": f"网格买: 现价 {price} 跌破档位 {buy_level}, 买 {per_lot} 股"}
|
|
return None
|
|
|
|
|
|
# ================================================================ 评估器: 跟踪止盈 (设计 §七B)
|
|
def _eval_trail(st, pos, day, now, ctx):
|
|
"""跟踪止盈: 创新高抬止盈线, 从高点回落 ≥ giveback 就卖 (从 avail); 命中硬止盈目标直接全清。
|
|
只卖不买 —— 纯离场保护。"""
|
|
state = ctx["state"]
|
|
params = st.get("params") or {}
|
|
price = _f(day.get("price"))
|
|
if price <= 0:
|
|
return None
|
|
avg = _f(pos.get("avg_cost"))
|
|
avail = int(pos.get("avail_qty") or 0)
|
|
profit = _f(pos.get("cushion_pct")) if pos.get("cushion_pct") is not None else (
|
|
(price / avg - 1) if avg > 0 else 0.0)
|
|
|
|
start_line = _f(params.get("start_line")) or param_store.get_float("PMS_CUSHION_SOLID", 0.03)
|
|
giveback = _f(params.get("giveback"))
|
|
sell_ratio = _f(params.get("sell_ratio")) or 1.0
|
|
hard_target = _f(params.get("hard_target"))
|
|
|
|
# 高水位每跳只抬不降
|
|
hw = max(_f(state.get("high_water")), price)
|
|
state["high_water"] = round(hw, 3)
|
|
if not state.get("armed") and profit >= start_line:
|
|
state["armed"] = True
|
|
ctx["notes"].append(f"{st['ts_code']} 跟踪止盈已武装(浮盈 {profit:.1%} ≥ 启动线 {start_line:.1%})")
|
|
|
|
if avail < LOT:
|
|
return None # 无 T+1 可卖, 只更新高水位
|
|
|
|
# 硬止盈目标: 直接全清
|
|
if hard_target > 0 and profit >= hard_target:
|
|
return {"side": "sell", "action": A_EXIT, "qty": _round_lot(avail) or avail, "leg": "trail_hard",
|
|
"reason": f"跟踪止盈-硬目标: 浮盈 {profit:.1%} ≥ {hard_target:.1%}, 全清 avail {avail} 股"}
|
|
|
|
# 已武装且从高点回落到设定比例 → 卖
|
|
if state.get("armed") and hw > 0 and price <= hw * (1 - giveback) and giveback > 0:
|
|
q = _round_lot(avail * sell_ratio) if sell_ratio < 1 else (_round_lot(avail) or avail)
|
|
if q >= LOT or (sell_ratio >= 1 and q > 0):
|
|
act = A_EXIT if sell_ratio >= 1 else A_SELL
|
|
return {"side": "sell", "action": act, "qty": q, "leg": "trail_sell",
|
|
"reason": f"跟踪止盈: 现价 {price} 自高点 {hw} 回落 {1 - price / hw:.1%} ≥ {giveback:.1%}, 卖 {q} 股"}
|
|
return None
|
|
|
|
|
|
EVALUATORS = {"T0": _eval_t0, "GRID": _eval_grid, "TRAIL": _eval_trail}
|
|
|
|
|
|
# ================================================================ 供 action_engine 排除
|
|
def active_codes() -> set:
|
|
"""有 ACTIVE 策略的 ts_code —— 供 action_engine 排除。读库失败按空集 (不误排除全体持仓)。"""
|
|
try:
|
|
return pms_repo.active_strategy_codes()
|
|
except Exception as e: # noqa: BLE001
|
|
logger.warning("[strategy] 读取 ACTIVE 策略集失败 (按空集): %s", e)
|
|
return set()
|
|
|
|
|
|
# ================================================================ 每分钟主跳
|
|
def _roll_day(state: dict, pos: dict, today: int) -> dict:
|
|
"""做T 的按日重置: 当日次数归零, 记下当日 realized_t_profit 基线 (算当日T盈亏用)。
|
|
网格 filled_levels / 跟踪止盈 high_water 是跨日的, 不在这里动。"""
|
|
if int(state.get("day") or 0) != today:
|
|
state["day"] = today
|
|
state["t_count_today"] = 0
|
|
state["rt_base"] = _f(pos.get("realized_t_profit"))
|
|
# 隔夜后原则上不该留未平的腿 (14:50 已平回); 万一留了, 清掉 open_leg 交对账兜底
|
|
state["open_leg"] = None
|
|
return state
|
|
|
|
|
|
def _day_t_pnl(state: dict, pos: dict) -> float:
|
|
return _f(pos.get("realized_t_profit")) - _f(state.get("rt_base"))
|
|
|
|
|
|
def tick(*, now=None, dry_run: bool = False) -> dict:
|
|
"""盘中每分钟一跳: 载入 ACTIVE 策略 → 逐只评估 → 触发就发短窗口指令 / 落提议 → 更新 state。
|
|
|
|
dry_run=True 只算不发不落库 (页面「试算」用)。
|
|
"""
|
|
now = now or datetime.now()
|
|
out = {"enabled": False, "checked": 0, "fired": [], "queued": [], "skipped": [],
|
|
"notes": [], "errors": [], "dry_run": dry_run}
|
|
if not param_store.get_bool("PMS_STRATEGY_ENABLED", False):
|
|
out["skipped"].append("PMS_STRATEGY_ENABLED=False, 策略层整体停用")
|
|
return out
|
|
out["enabled"] = True
|
|
|
|
try:
|
|
strategies = pms_repo.active_strategies()
|
|
except Exception as e: # noqa: BLE001
|
|
logger.exception("[strategy] 载入 ACTIVE 策略失败")
|
|
return {**out, "ok": False, "errors": [f"载入失败: {type(e).__name__}: {e}"]}
|
|
if not strategies:
|
|
out["ok"] = True
|
|
return out
|
|
|
|
try:
|
|
view = portfolio.positions_view()
|
|
except Exception as e: # noqa: BLE001
|
|
logger.exception("[strategy] 取持仓快照失败")
|
|
return {**out, "ok": False, "errors": [f"取持仓失败: {type(e).__name__}: {e}"]}
|
|
scale = _f(view.get("totals", {}).get("scale"))
|
|
today = _today()
|
|
|
|
# 全局当日T亏熔断: 汇总所有做T策略的当日T盈亏 (realized_t_profit 相对日初基线的增量)
|
|
global_t_pnl = 0.0
|
|
for st in strategies:
|
|
if st.get("type") == "T0":
|
|
global_t_pnl += _day_t_pnl(st.get("state") or {}, _pos_of(view, st["ts_code"]))
|
|
global_loss_cap = param_store.get_float("PMS_T0_GLOBAL_DAY_LOSS", 0.01) * scale
|
|
global_halt = scale > 0 and global_t_pnl <= -global_loss_cap
|
|
if global_halt:
|
|
out["notes"].append(f"全局当日T亏 {global_t_pnl:.0f} 元 达熔断线 {global_loss_cap:.0f} 元, 今日不再开新T")
|
|
|
|
for st in strategies:
|
|
out["checked"] += 1
|
|
code = st.get("ts_code")
|
|
fn = EVALUATORS.get(st.get("type"))
|
|
if not fn:
|
|
out["skipped"].append({"strategy_id": st.get("strategy_id"),
|
|
"why": f"未知策略类型 {st.get('type')}"})
|
|
continue
|
|
try:
|
|
pos = _pos_of(view, code)
|
|
if not pos or int(pos.get("total_qty") or 0) <= 0:
|
|
out["skipped"].append({"strategy_id": st.get("strategy_id"),
|
|
"why": f"{code} 已无持仓, 策略空转 (可撤下)"})
|
|
continue
|
|
state = dict(st.get("state") or {})
|
|
if st.get("type") == "T0":
|
|
state = _roll_day(state, pos, today)
|
|
|
|
# 上一腿还没走完就别再发; 走完了先把结果并进 state
|
|
if not _reconcile(st, state, pos):
|
|
if not dry_run:
|
|
pms_repo.update_strategy(st["strategy_id"], state=state)
|
|
out["skipped"].append({"strategy_id": st["strategy_id"], "why": "上一腿在途, 等它走完"})
|
|
continue
|
|
|
|
day = market.day_snapshot(code)
|
|
if not day or not day.get("price"):
|
|
out["skipped"].append({"strategy_id": st["strategy_id"],
|
|
"why": f"{code} 无实时行情 (停牌/盘前), 顺延"})
|
|
if not dry_run:
|
|
pms_repo.update_strategy(st["strategy_id"], state=state)
|
|
continue
|
|
|
|
# 单票当日T亏熔断 (做T)
|
|
halted = global_halt
|
|
if st.get("type") == "T0" and scale > 0:
|
|
stock_cap = param_store.get_float("PMS_T0_STOCK_DAY_LOSS", 0.003) * scale
|
|
if _day_t_pnl(state, pos) <= -stock_cap:
|
|
halted = True
|
|
out["notes"].append(f"{code} 当日T亏达单票熔断线 {stock_cap:.0f} 元, 今日不再开新T")
|
|
|
|
ctx = {"state": state, "scale": scale, "halted": halted, "notes": out["notes"]}
|
|
dec = fn(st, pos, day, now, ctx)
|
|
|
|
if dec:
|
|
# 网格成交态在这里落 (评估器只给意图, 落 state 由这里做, 保证与发指令原子)
|
|
if not dry_run:
|
|
_apply_grid_state(state, dec)
|
|
if (st.get("autonomy") or "auto") == "confirm":
|
|
pid = _emit_proposal(st, dec)
|
|
state["pending"] = {"pid": pid, "leg": dec["leg"], "dir": dec.get("dir"),
|
|
"qty": dec["qty"], "entry": dec.get("entry")}
|
|
out["queued"].append({"strategy_id": st["strategy_id"], "proposal_id": pid,
|
|
"reason": dec["reason"]})
|
|
else:
|
|
iid = _emit_instruction(st, dec, forced=False)
|
|
state["pending"] = {"iid": iid, "leg": dec["leg"], "dir": dec.get("dir"),
|
|
"qty": dec["qty"], "entry": dec.get("entry")}
|
|
out["fired"].append({"strategy_id": st["strategy_id"], "instruction_id": iid,
|
|
"side": dec["side"], "qty": dec["qty"], "reason": dec["reason"]})
|
|
else:
|
|
out["fired"].append({"strategy_id": st["strategy_id"], "dry_run": True,
|
|
"side": dec["side"], "qty": dec["qty"], "reason": dec["reason"]})
|
|
|
|
if not dry_run:
|
|
pms_repo.update_strategy(st["strategy_id"], state=state)
|
|
except Exception as e: # noqa: BLE001 —— 单策略异常不拖垮整轮
|
|
logger.exception("[strategy] 评估失败 %s", st.get("strategy_id"))
|
|
out["errors"].append(f"{st.get('strategy_id')}: {type(e).__name__}: {e}")
|
|
|
|
out["ok"] = not out["errors"]
|
|
return out
|
|
|
|
|
|
def _apply_grid_state(state: dict, dec: dict):
|
|
"""网格发单同时更新 filled_levels / invested (买入占用一档, 卖出释放一档)。"""
|
|
if "grid_buy_idx" in dec:
|
|
filled = dict(state.get("filled_levels") or {})
|
|
filled[str(dec["grid_buy_idx"])] = {"price": _f(dec.get("grid_buy_price")),
|
|
"qty": int(dec["qty"])}
|
|
state["filled_levels"] = filled
|
|
state["invested"] = _f(state.get("invested")) + _f(dec.get("grid_buy_price")) * int(dec["qty"])
|
|
elif "grid_sell_idx" in dec:
|
|
filled = dict(state.get("filled_levels") or {})
|
|
info = filled.pop(str(dec["grid_sell_idx"]), None)
|
|
state["filled_levels"] = filled
|
|
if info:
|
|
state["invested"] = max(0.0, _f(state.get("invested")) - _f(info.get("price")) * int(info.get("qty") or 0))
|
|
|
|
|
|
# ================================================================ 14:50 强制平回 (设计 §六 rails)
|
|
def force_t0_close(*, now=None) -> dict:
|
|
"""做T 强制平回 (scheduler.t0_close 在 PMS_T0_CLOSE_TIME 调): 对每只有未平腿的做T策略,
|
|
立刻发对向平仓腿把当日T仓打平, 绝不过夜。已有在途腿的先撤后不重复 —— 这里只补「还没平」的。"""
|
|
out = {"closed": [], "skipped": [], "errors": []}
|
|
if not param_store.get_bool("PMS_STRATEGY_ENABLED", False):
|
|
out["skipped"].append("PMS_STRATEGY_ENABLED=False")
|
|
return out
|
|
try:
|
|
strategies = [s for s in pms_repo.active_strategies() if s.get("type") == "T0"]
|
|
except Exception as e: # noqa: BLE001
|
|
return {**out, "errors": [f"载入做T策略失败: {type(e).__name__}: {e}"]}
|
|
if not strategies:
|
|
return out
|
|
try:
|
|
view = portfolio.positions_view()
|
|
except Exception as e: # noqa: BLE001
|
|
return {**out, "errors": [f"取持仓失败: {type(e).__name__}: {e}"]}
|
|
|
|
for st in strategies:
|
|
code = st["ts_code"]
|
|
try:
|
|
state = dict(st.get("state") or {})
|
|
# 先把在途腿收敛掉
|
|
pos = _pos_of(view, code)
|
|
_reconcile(st, state, pos)
|
|
open_leg = state.get("open_leg")
|
|
if not open_leg:
|
|
out["skipped"].append({"strategy_id": st["strategy_id"], "why": "无未平腿"})
|
|
pms_repo.update_strategy(st["strategy_id"], state=state)
|
|
continue
|
|
if state.get("pending"):
|
|
out["skipped"].append({"strategy_id": st["strategy_id"], "why": "平仓腿已在途"})
|
|
continue
|
|
q = _round_lot(open_leg.get("qty"))
|
|
if q < LOT:
|
|
out["skipped"].append({"strategy_id": st["strategy_id"], "why": "残量不足一手"})
|
|
continue
|
|
if open_leg.get("dir") == "long": # 正T 已买 → 卖平
|
|
dec = {"side": "sell", "action": A_T0, "qty": min(q, int(pos.get("avail_qty") or 0)),
|
|
"leg": "close", "reason": "14:50 强制平回(正T)"}
|
|
else: # 反T 已卖 → 买平
|
|
dec = {"side": "buy", "action": A_T0, "qty": q, "leg": "close",
|
|
"reason": "14:50 强制平回(反T)"}
|
|
if int(dec["qty"]) < LOT:
|
|
out["skipped"].append({"strategy_id": st["strategy_id"], "why": "可平量不足 (avail 不够)"})
|
|
continue
|
|
iid = _emit_instruction(st, dec, forced=True)
|
|
state["pending"] = {"iid": iid, "leg": "close", "dir": open_leg.get("dir"),
|
|
"qty": dec["qty"], "entry": open_leg.get("entry")}
|
|
pms_repo.update_strategy(st["strategy_id"], state=state)
|
|
out["closed"].append({"strategy_id": st["strategy_id"], "instruction_id": iid,
|
|
"side": dec["side"], "qty": dec["qty"]})
|
|
except Exception as e: # noqa: BLE001
|
|
logger.exception("[strategy] 强制平回失败 %s", st.get("strategy_id"))
|
|
out["errors"].append(f"{st.get('strategy_id')}: {type(e).__name__}: {e}")
|
|
out["ok"] = not out["errors"]
|
|
return out
|