dekun
503 lines
17 KiB
Python
503 lines
17 KiB
Python
"""期权目标位委托:指数目标价仅用于监控触发;触发后按买一限价平仓(无止损,到期结算)."""
|
|
from __future__ import annotations
|
|
|
|
import sqlite3
|
|
import time
|
|
from typing import Any, Callable
|
|
|
|
from lib.options.options_db import init_options_tables
|
|
from lib.options.options_pricing_lib import close_ref_prices, fetch_option_mark_px
|
|
|
|
|
|
def _safe_float(v: Any) -> float | None:
|
|
if v is None or v == "":
|
|
return None
|
|
try:
|
|
return float(v)
|
|
except (TypeError, ValueError):
|
|
return None
|
|
|
|
|
|
def _pos_close_refs(ex: Any, pos: dict[str, Any], quote: dict[str, Any] | None = None) -> tuple[float | None, float | None]:
|
|
from lib.exchange.okx_options_lib import option_fields_from_inst_id
|
|
|
|
inst_id = str(pos.get("instId") or pos.get("inst_id") or "")
|
|
mark = _safe_float(pos.get("markPx")) or _safe_float((quote or {}).get("mark_px") or (quote or {}).get("mark"))
|
|
if mark is None:
|
|
mark = fetch_option_mark_px(ex, inst_id)
|
|
opt_type = pos.get("optType") or (quote or {}).get("opt_type")
|
|
strike = _safe_float(pos.get("stk")) or _safe_float((quote or {}).get("strike"))
|
|
if not opt_type or strike is None:
|
|
pt, ps = option_fields_from_inst_id(inst_id)
|
|
opt_type = opt_type or pt
|
|
if strike is None:
|
|
strike = ps
|
|
idx = _safe_float(pos.get("idxPx")) or _safe_float((quote or {}).get("index_px"))
|
|
return close_ref_prices(
|
|
mark_px=mark,
|
|
opt_type=str(opt_type or ""),
|
|
strike=strike,
|
|
index_px=idx,
|
|
inst_id=inst_id,
|
|
)
|
|
|
|
|
|
def ensure_target_tables(conn: sqlite3.Connection) -> None:
|
|
init_options_tables(conn)
|
|
conn.execute(
|
|
"""
|
|
CREATE TABLE IF NOT EXISTS options_target_monitors (
|
|
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
|
inst_id TEXT NOT NULL,
|
|
underlying TEXT,
|
|
opt_type TEXT,
|
|
target_index REAL NOT NULL,
|
|
trade_id INTEGER,
|
|
sheets INTEGER,
|
|
status TEXT DEFAULT 'active',
|
|
trigger_idx REAL,
|
|
close_ord_id TEXT,
|
|
message TEXT,
|
|
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
|
|
triggered_at TIMESTAMP
|
|
)
|
|
"""
|
|
)
|
|
conn.execute(
|
|
"""
|
|
CREATE INDEX IF NOT EXISTS idx_options_target_monitors_status
|
|
ON options_target_monitors(status)
|
|
"""
|
|
)
|
|
|
|
|
|
def target_hit(*, opt_type: str | None, index_px: float, target_index: float) -> bool:
|
|
"""Call:指数涨到/超过目标平仓;Put:指数跌到/低于目标平仓."""
|
|
ot = (opt_type or "").strip().upper()
|
|
if ot == "P":
|
|
return index_px <= target_index
|
|
return index_px >= target_index
|
|
|
|
|
|
def upsert_target_monitor(
|
|
conn: sqlite3.Connection,
|
|
*,
|
|
inst_id: str,
|
|
target_index: float,
|
|
underlying: str | None = None,
|
|
opt_type: str | None = None,
|
|
trade_id: int | None = None,
|
|
sheets: int | None = None,
|
|
) -> dict[str, Any]:
|
|
ensure_target_tables(conn)
|
|
inst_id = (inst_id or "").strip()
|
|
if not inst_id:
|
|
return {"ok": False, "msg": "缺少 inst_id"}
|
|
if target_index is None or float(target_index) <= 0:
|
|
return {"ok": False, "msg": "目标位无效"}
|
|
target_index = float(target_index)
|
|
row = conn.execute(
|
|
"""
|
|
SELECT id FROM options_target_monitors
|
|
WHERE inst_id = ? AND status IN ('active', 'closing')
|
|
ORDER BY CASE status WHEN 'active' THEN 0 WHEN 'closing' THEN 1 ELSE 2 END, id DESC
|
|
LIMIT 1
|
|
""",
|
|
(inst_id,),
|
|
).fetchone()
|
|
if row:
|
|
conn.execute(
|
|
"""
|
|
UPDATE options_target_monitors
|
|
SET target_index = ?,
|
|
underlying = COALESCE(?, underlying),
|
|
opt_type = COALESCE(?, opt_type),
|
|
trade_id = COALESCE(?, trade_id),
|
|
sheets = COALESCE(?, sheets),
|
|
status = 'active',
|
|
trigger_idx = NULL,
|
|
close_ord_id = NULL,
|
|
message = NULL,
|
|
triggered_at = NULL
|
|
WHERE id = ?
|
|
""",
|
|
(target_index, underlying, opt_type, trade_id, sheets, int(row["id"])),
|
|
)
|
|
mon_id = int(row["id"])
|
|
# 同一合约其他进行中的委托取消,避免双轨触发重复推送
|
|
conn.execute(
|
|
"""
|
|
UPDATE options_target_monitors
|
|
SET status = 'cancelled', message = '被新目标位覆盖'
|
|
WHERE inst_id = ? AND id != ? AND status IN ('active', 'closing')
|
|
""",
|
|
(inst_id, mon_id),
|
|
)
|
|
else:
|
|
cur = conn.execute(
|
|
"""
|
|
INSERT INTO options_target_monitors
|
|
(inst_id, underlying, opt_type, target_index, trade_id, sheets, status)
|
|
VALUES (?, ?, ?, ?, ?, ?, 'active')
|
|
""",
|
|
(inst_id, underlying, opt_type, target_index, trade_id, sheets),
|
|
)
|
|
mon_id = int(cur.lastrowid)
|
|
return {"ok": True, "id": mon_id, "inst_id": inst_id, "target_index": target_index}
|
|
|
|
|
|
def cancel_target_monitor(conn: sqlite3.Connection, *, inst_id: str | None = None, monitor_id: int | None = None) -> int:
|
|
ensure_target_tables(conn)
|
|
if monitor_id is not None:
|
|
cur = conn.execute(
|
|
"""
|
|
UPDATE options_target_monitors
|
|
SET status = 'cancelled', message = '手动取消'
|
|
WHERE id = ? AND status IN ('active', 'closing')
|
|
""",
|
|
(int(monitor_id),),
|
|
)
|
|
return int(cur.rowcount or 0)
|
|
if inst_id:
|
|
cur = conn.execute(
|
|
"""
|
|
UPDATE options_target_monitors
|
|
SET status = 'cancelled', message = '手动取消'
|
|
WHERE inst_id = ? AND status IN ('active', 'closing')
|
|
""",
|
|
(inst_id.strip(),),
|
|
)
|
|
return int(cur.rowcount or 0)
|
|
return 0
|
|
|
|
|
|
def _row_to_target(r: sqlite3.Row) -> dict[str, Any]:
|
|
return {
|
|
"id": int(r["id"]),
|
|
"inst_id": r["inst_id"],
|
|
"underlying": r["underlying"],
|
|
"opt_type": r["opt_type"],
|
|
"target_index": _safe_float(r["target_index"]),
|
|
"trade_id": r["trade_id"],
|
|
"sheets": r["sheets"],
|
|
"status": r["status"],
|
|
"message": r["message"],
|
|
"created_at": r["created_at"],
|
|
}
|
|
|
|
|
|
def list_active_targets(conn: sqlite3.Connection) -> list[dict[str, Any]]:
|
|
ensure_target_tables(conn)
|
|
rows = conn.execute(
|
|
"""
|
|
SELECT id, inst_id, underlying, opt_type, target_index, trade_id, sheets,
|
|
status, message, created_at
|
|
FROM options_target_monitors
|
|
WHERE status = 'active'
|
|
ORDER BY id DESC
|
|
"""
|
|
).fetchall()
|
|
return [_row_to_target(r) for r in rows]
|
|
|
|
|
|
def list_closing_targets(conn: sqlite3.Connection) -> list[dict[str, Any]]:
|
|
"""已挂出平仓单、等待成交的目标(不再重复推送微信)."""
|
|
ensure_target_tables(conn)
|
|
rows = conn.execute(
|
|
"""
|
|
SELECT id, inst_id, underlying, opt_type, target_index, trade_id, sheets,
|
|
status, message, created_at
|
|
FROM options_target_monitors
|
|
WHERE status = 'closing'
|
|
ORDER BY id DESC
|
|
"""
|
|
).fetchall()
|
|
return [_row_to_target(r) for r in rows]
|
|
|
|
|
|
def targets_by_inst(conn: sqlite3.Connection) -> dict[str, dict[str, Any]]:
|
|
"""UI/持仓挂载:active 与 closing 都算进行中."""
|
|
out: dict[str, dict[str, Any]] = {}
|
|
for t in list_closing_targets(conn) + list_active_targets(conn):
|
|
inst = str(t.get("inst_id") or "")
|
|
if inst and inst not in out:
|
|
out[inst] = t
|
|
return out
|
|
|
|
|
|
def mark_monitor(
|
|
conn: sqlite3.Connection,
|
|
monitor_id: int,
|
|
*,
|
|
status: str,
|
|
trigger_idx: float | None = None,
|
|
close_ord_id: str | None = None,
|
|
message: str | None = None,
|
|
) -> None:
|
|
conn.execute(
|
|
"""
|
|
UPDATE options_target_monitors
|
|
SET status = ?,
|
|
trigger_idx = COALESCE(?, trigger_idx),
|
|
close_ord_id = COALESCE(?, close_ord_id),
|
|
message = COALESCE(?, message),
|
|
triggered_at = CASE
|
|
WHEN ? IN ('triggered', 'expired', 'closing') THEN COALESCE(triggered_at, CURRENT_TIMESTAMP)
|
|
ELSE triggered_at
|
|
END
|
|
WHERE id = ?
|
|
""",
|
|
(status, trigger_idx, close_ord_id, message, status, int(monitor_id)),
|
|
)
|
|
|
|
|
|
def cancel_orphans_without_position(
|
|
conn: sqlite3.Connection,
|
|
*,
|
|
live_inst_ids: set[str],
|
|
) -> int:
|
|
"""持仓已消失的目标委托标记为 expired(到期/已平),不挂止损."""
|
|
ensure_target_tables(conn)
|
|
rows = list_active_targets(conn) + list_closing_targets(conn)
|
|
n = 0
|
|
for t in rows:
|
|
inst = str(t.get("inst_id") or "")
|
|
if inst and inst not in live_inst_ids:
|
|
mark_monitor(conn, int(t["id"]), status="expired", message="持仓已平/到期,委托结束")
|
|
n += 1
|
|
return n
|
|
|
|
|
|
def _commit_monitor(conn: sqlite3.Connection) -> None:
|
|
"""状态变更立刻落库,避免后续 sync 异常回滚后重复触发/推送."""
|
|
try:
|
|
conn.commit()
|
|
except Exception:
|
|
pass
|
|
|
|
|
|
def close_option_by_bid_depth(
|
|
cfg: dict[str, Any],
|
|
ex: Any,
|
|
inst_id: str,
|
|
*,
|
|
sheets: int | None = None,
|
|
) -> dict[str, Any]:
|
|
"""目标触发后只锁买一限价卖出;需过 2×门控(通过后同仓续批只验流动性)."""
|
|
from lib.options.options_close_exec_lib import close_option_by_bid1
|
|
|
|
return close_option_by_bid1(
|
|
cfg,
|
|
ex,
|
|
inst_id,
|
|
sheets=sheets,
|
|
require_recycle_gate=True,
|
|
signal_note="目标位平仓",
|
|
)
|
|
|
|
|
|
|
|
def _notify_target_close(
|
|
cfg: dict[str, Any] | None,
|
|
send_wechat: Callable[[str], None] | None,
|
|
*,
|
|
account_label: str,
|
|
inst_id: str,
|
|
target: float,
|
|
idx: float,
|
|
result: dict[str, Any],
|
|
conn: Any = None,
|
|
) -> None:
|
|
"""目标位平仓推送:优先走统一平仓必发(幂等);无 cfg 时回退旧文案."""
|
|
if result.get("fully_closed") or result.get("already_flat"):
|
|
if cfg is not None:
|
|
try:
|
|
from lib.options.options_notify_lib import notify_options_close
|
|
|
|
notify_options_close(
|
|
cfg,
|
|
conn,
|
|
inst_id=inst_id,
|
|
reason="目标位平仓",
|
|
sheets=result.get("submitted_sheets"),
|
|
premium_received=result.get("premium_received"),
|
|
close_quote=result.get("locked_bid_px") or result.get("bid"),
|
|
target_index=target,
|
|
trigger_idx=idx,
|
|
)
|
|
return
|
|
except Exception:
|
|
pass
|
|
if not send_wechat:
|
|
return
|
|
try:
|
|
send_wechat(
|
|
"\n".join(
|
|
[
|
|
"【OKX期权·目标位平仓】",
|
|
f"账户:{account_label}",
|
|
f"合约:{inst_id}",
|
|
f"目标指数:{target:g}",
|
|
f"触发指数:{idx:g}",
|
|
f"提交张数:{result.get('submitted_sheets') or '—'}",
|
|
f"预估收回:{result.get('premium_received') if result.get('premium_received') is not None else '—'} USDC",
|
|
f"状态:{'已全平' if (result.get('fully_closed') or result.get('already_flat')) else '挂单中/部分'}",
|
|
]
|
|
)
|
|
)
|
|
except Exception:
|
|
pass
|
|
|
|
|
|
def _result_fully_done(result: dict[str, Any]) -> bool:
|
|
if result.get("already_flat"):
|
|
return True
|
|
if result.get("fully_closed"):
|
|
return True
|
|
remaining = result.get("remaining_sheets")
|
|
if remaining is not None and int(remaining) <= 0 and result.get("ok"):
|
|
return True
|
|
return False
|
|
|
|
|
|
def run_options_target_closes(
|
|
conn: sqlite3.Connection,
|
|
positions: list[dict[str, Any]],
|
|
*,
|
|
close_fn: Callable[[str], dict[str, Any]],
|
|
index_fn: Callable[[dict[str, Any]], float | None] | None = None,
|
|
send_wechat: Callable[[str], None] | None = None,
|
|
account_label: str = "OKX期权",
|
|
cfg: dict[str, Any] | None = None,
|
|
) -> int:
|
|
"""
|
|
扫描 active 目标委托;指数到位后限价平仓.
|
|
状态先 commit 再推微信,避免 sync 失败回滚导致同一笔反复推送.
|
|
未完全成交进入 closing,仅重试平仓不再推送.
|
|
返回本次新触发(并推送)的条数.
|
|
"""
|
|
ensure_target_tables(conn)
|
|
pos_by_inst = {str(p.get("inst_id") or p.get("instId") or ""): p for p in positions}
|
|
live_ids = {k for k in pos_by_inst if k}
|
|
hedge_managed: set[str] = set()
|
|
try:
|
|
from lib.hedge_plan.hedge_plan_db import active_hedge_option_inst_ids, init_hedge_plan_tables
|
|
|
|
init_hedge_plan_tables(conn)
|
|
hedge_managed = active_hedge_option_inst_ids(conn)
|
|
except Exception:
|
|
# fail-closed:本轮不执行任何单独目标平仓,避免误平对冲腿
|
|
return 0
|
|
cancel_orphans_without_position(conn, live_inst_ids=live_ids)
|
|
_commit_monitor(conn)
|
|
|
|
# 先处理已挂单等待成交的,绝不再发微信
|
|
for mon in list_closing_targets(conn):
|
|
inst_id = str(mon.get("inst_id") or "")
|
|
if not inst_id:
|
|
continue
|
|
if inst_id in hedge_managed:
|
|
mark_monitor(
|
|
conn,
|
|
int(mon["id"]),
|
|
status="expired",
|
|
message="已移交对冲计划托管,跳过单独目标平仓",
|
|
)
|
|
_commit_monitor(conn)
|
|
continue
|
|
if inst_id not in pos_by_inst:
|
|
mark_monitor(conn, int(mon["id"]), status="expired", message="持仓已平")
|
|
_commit_monitor(conn)
|
|
continue
|
|
result = close_fn(inst_id)
|
|
idx = _safe_float(pos_by_inst[inst_id].get("idx_px") or pos_by_inst[inst_id].get("idxPx"))
|
|
if result.get("already_flat") or _result_fully_done(result):
|
|
mark_monitor(
|
|
conn,
|
|
int(mon["id"]),
|
|
status="triggered",
|
|
trigger_idx=idx,
|
|
close_ord_id=result.get("close_ord_id"),
|
|
message="目标位限价平仓完成",
|
|
)
|
|
_commit_monitor(conn)
|
|
continue
|
|
mark_monitor(
|
|
conn,
|
|
int(mon["id"]),
|
|
status="closing",
|
|
trigger_idx=idx,
|
|
close_ord_id=result.get("close_ord_id"),
|
|
message=str(result.get("msg") or result.get("stopped_reason") or "等待买一成交"),
|
|
)
|
|
_commit_monitor(conn)
|
|
|
|
triggered = 0
|
|
for mon in list_active_targets(conn):
|
|
inst_id = str(mon.get("inst_id") or "")
|
|
target = _safe_float(mon.get("target_index"))
|
|
if not inst_id or target is None:
|
|
continue
|
|
if inst_id in hedge_managed:
|
|
mark_monitor(
|
|
conn,
|
|
int(mon["id"]),
|
|
status="expired",
|
|
message="已移交对冲计划托管,跳过单独目标平仓",
|
|
)
|
|
_commit_monitor(conn)
|
|
continue
|
|
pos = pos_by_inst.get(inst_id)
|
|
if not pos:
|
|
continue
|
|
if index_fn is not None:
|
|
idx = index_fn(pos)
|
|
else:
|
|
idx = _safe_float(pos.get("idx_px") or pos.get("idxPx"))
|
|
if idx is None:
|
|
continue
|
|
opt_type = mon.get("opt_type") or pos.get("opt_type") or pos.get("optType")
|
|
if not target_hit(opt_type=str(opt_type) if opt_type else None, index_px=idx, target_index=target):
|
|
continue
|
|
|
|
result = close_fn(inst_id)
|
|
if result.get("already_flat"):
|
|
mark_monitor(conn, int(mon["id"]), status="expired", trigger_idx=idx, message="持仓已平")
|
|
_commit_monitor(conn)
|
|
continue
|
|
if not result.get("ok"):
|
|
mark_monitor(
|
|
conn,
|
|
int(mon["id"]),
|
|
status="active",
|
|
trigger_idx=idx,
|
|
message=str(result.get("msg") or result.get("stopped_reason") or "平仓未完成,将重试"),
|
|
)
|
|
_commit_monitor(conn)
|
|
continue
|
|
|
|
done = _result_fully_done(result)
|
|
status = "triggered" if done else "closing"
|
|
mark_monitor(
|
|
conn,
|
|
int(mon["id"]),
|
|
status=status,
|
|
trigger_idx=idx,
|
|
close_ord_id=result.get("close_ord_id"),
|
|
message="目标位触发限价平仓" if done else "目标位已挂买一限价,等待成交",
|
|
)
|
|
# 关键:先落库,再推送——否则后续 sync 异常回滚会让同一笔反复推微信
|
|
_commit_monitor(conn)
|
|
triggered += 1
|
|
_notify_target_close(
|
|
cfg,
|
|
send_wechat,
|
|
account_label=account_label,
|
|
inst_id=inst_id,
|
|
target=target,
|
|
idx=idx,
|
|
result=result,
|
|
conn=conn,
|
|
)
|
|
return triggered
|