dekun
567 lines
23 KiB
Python
567 lines
23 KiB
Python
#!/usr/bin/env python3
|
||
"""One-shot: align crypto_monitor_okx with binance/gate patterns (OKX_* prefixes)."""
|
||
from __future__ import annotations
|
||
|
||
import re
|
||
import shutil
|
||
from pathlib import Path
|
||
|
||
ROOT = Path(__file__).resolve().parents[1]
|
||
OKX = ROOT / "crypto_monitor_okx"
|
||
BIN = ROOT / "crypto_monitor_binance"
|
||
GATE = ROOT / "crypto_monitor_gate"
|
||
|
||
|
||
def patch_app():
|
||
app_path = OKX / "app.py"
|
||
text = app_path.read_text(encoding="utf-8")
|
||
|
||
if "EXCHANGE_DISPLAY_NAME" not in text.split("OKX_POS_MODE")[0]:
|
||
text = text.replace(
|
||
'OKX_POS_MODE = os.getenv("OKX_POS_MODE", "hedge")\n',
|
||
'OKX_POS_MODE = os.getenv("OKX_POS_MODE", "hedge")\n'
|
||
'EXCHANGE_DISPLAY_NAME = (os.getenv("EXCHANGE_DISPLAY_NAME") or "OKX").strip() or "OKX"\n',
|
||
)
|
||
|
||
if "TRADING_DAY_RESET_OPEN_GUARD_ENABLED" not in text:
|
||
text = text.replace(
|
||
"TRADING_DAY_RESET_HOUR = int(os.getenv(\"TRADING_DAY_RESET_HOUR\", \"8\"))\nAPP_TIMEZONE",
|
||
'TRADING_DAY_RESET_HOUR = int(os.getenv("TRADING_DAY_RESET_HOUR", "8"))\n'
|
||
"TRADING_DAY_RESET_OPEN_GUARD_ENABLED = os.getenv(\n"
|
||
' "TRADING_DAY_RESET_OPEN_GUARD_ENABLED", "true"\n'
|
||
').lower() in ("1", "true", "yes", "on")\n'
|
||
"APP_TIMEZONE",
|
||
)
|
||
|
||
extra_env = """
|
||
MANUAL_MIN_PLANNED_RR = float(os.getenv("MANUAL_MIN_PLANNED_RR", "1.4"))
|
||
MAX_ACTIVE_POSITIONS = max(1, int(os.getenv("MAX_ACTIVE_POSITIONS", "1")))
|
||
KEY_VOLUME_MA_BARS = max(1, int(os.getenv("KEY_VOLUME_MA_BARS", "20")))
|
||
KEY_VOLUME_RATIO_MIN = float(os.getenv("KEY_VOLUME_RATIO_MIN", "1.3"))
|
||
KEY_BREAKOUT_AMP_MIN_PCT = float(os.getenv("KEY_BREAKOUT_AMP_MIN_PCT", "0.03"))
|
||
KEY_BREAKOUT_AMP_MAX_PCT = float(os.getenv("KEY_BREAKOUT_AMP_MAX_PCT", "0.5"))
|
||
KEY_CONFIRM_BREAKOUT_BAR = int(os.getenv("KEY_CONFIRM_BREAKOUT_BAR", "-2"))
|
||
KEY_CONFIRM_BAR = int(os.getenv("KEY_CONFIRM_BAR", "-1"))
|
||
"""
|
||
if "MANUAL_MIN_PLANNED_RR = float" not in text:
|
||
text = text.replace(
|
||
"KEY_DAILY_VOLUME_RANK_MAX = int(os.getenv(\"KEY_DAILY_VOLUME_RANK_MAX\", \"30\"))\n",
|
||
"KEY_DAILY_VOLUME_RANK_MAX = max(1, int(os.getenv(\"KEY_DAILY_VOLUME_RANK_MAX\", \"30\")))\n"
|
||
+ extra_env,
|
||
)
|
||
|
||
if "def format_funds_u" not in text:
|
||
text = text.replace(
|
||
"def format_hold_minutes(minutes):",
|
||
'''FUNDS_DECIMALS = 2
|
||
|
||
|
||
def format_funds_u(value):
|
||
if value in (None, ""):
|
||
return "-"
|
||
try:
|
||
return f"{float(value):.{FUNDS_DECIMALS}f}"
|
||
except (TypeError, ValueError):
|
||
return str(value)
|
||
|
||
|
||
def format_hold_minutes(minutes):''',
|
||
)
|
||
|
||
if "def trading_day_reset_allows_new_open" not in text:
|
||
text = text.replace(
|
||
"def precheck_risk(conn, symbol, direction):",
|
||
'''def trading_day_reset_allows_new_open(now):
|
||
if not TRADING_DAY_RESET_OPEN_GUARD_ENABLED:
|
||
return True
|
||
return now.hour >= TRADING_DAY_RESET_HOUR
|
||
|
||
|
||
def precheck_risk(conn, symbol, direction):''',
|
||
)
|
||
|
||
text = re.sub(
|
||
r"def precheck_risk\(conn, symbol, direction\):.*?return True, \"\"",
|
||
'''def precheck_risk(conn, symbol, direction):
|
||
now = app_now()
|
||
if not trading_day_reset_allows_new_open(now):
|
||
return False, f"北京时间 {TRADING_DAY_RESET_HOUR}:00 前不允许持仓"
|
||
active_count = get_active_position_count(conn)
|
||
if active_count >= MAX_ACTIVE_POSITIONS:
|
||
return False, f"已达最大持仓数（{active_count}/{MAX_ACTIVE_POSITIONS}）"
|
||
if direction not in ("long", "short"):
|
||
return False, "方向必须为 long 或 short"
|
||
if symbol.upper().startswith("BTC") or symbol.upper().startswith("ETH"):
|
||
expected = BTC_LEVERAGE
|
||
else:
|
||
expected = ALT_LEVERAGE
|
||
if expected <= 0:
|
||
return False, "杠杆配置异常"
|
||
return True, ""''',
|
||
text,
|
||
count=1,
|
||
flags=re.DOTALL,
|
||
)
|
||
|
||
# _key_hard_checks from gate
|
||
gate_text = (GATE / "app.py").read_text(encoding="utf-8")
|
||
m = re.search(r"def _key_hard_checks\(symbol.*?return out\n", gate_text, re.DOTALL)
|
||
if m:
|
||
kh = m.group(0).replace("normalize_exchange_symbol", "normalize_okx_symbol")
|
||
text = re.sub(r"def _key_hard_checks\(symbol.*?return out\n", kh, text, count=1, flags=re.DOTALL)
|
||
|
||
if "def exchange_private_api_configured" not in text:
|
||
insert = '''
|
||
def exchange_private_api_configured():
|
||
return bool(OKX_API_KEY and OKX_API_SECRET and OKX_API_PASSPHRASE)
|
||
|
||
|
||
def _position_row_effective_contracts(p):
|
||
info = p.get("info", {}) or {}
|
||
contracts = p.get("contracts")
|
||
if contracts is None:
|
||
raw_pos = info.get("pos")
|
||
try:
|
||
contracts = abs(float(raw_pos)) if raw_pos is not None else 0.0
|
||
except Exception:
|
||
contracts = 0.0
|
||
try:
|
||
return float(contracts)
|
||
except Exception:
|
||
return 0.0
|
||
|
||
|
||
def _position_matches_wanted_contract(exchange_symbol, position):
|
||
if not position:
|
||
return False
|
||
sym = position.get("symbol")
|
||
return sym == exchange_symbol
|
||
|
||
|
||
def _select_live_position_row(rows, exchange_symbol, direction, relax_hedge=False):
|
||
if not rows:
|
||
return None
|
||
candidates = []
|
||
for p in rows:
|
||
if not _position_matches_wanted_contract(exchange_symbol, p):
|
||
continue
|
||
info = p.get("info", {}) or {}
|
||
side = (p.get("side") or info.get("posSide") or "").lower()
|
||
contracts = _position_row_effective_contracts(p)
|
||
if contracts <= 0:
|
||
continue
|
||
if (not relax_hedge) and OKX_POS_MODE == "hedge":
|
||
if side and side != (direction or "").lower():
|
||
continue
|
||
candidates.append((contracts, p))
|
||
if not candidates and (not relax_hedge) and OKX_POS_MODE == "hedge":
|
||
return _select_live_position_row(rows, exchange_symbol, direction, relax_hedge=True)
|
||
if not candidates:
|
||
return None
|
||
candidates.sort(key=lambda x: x[0], reverse=True)
|
||
return candidates[0][1]
|
||
|
||
|
||
def parse_ccxt_position_metrics(position, order_leverage=None):
|
||
if not position:
|
||
return None
|
||
p = position
|
||
info = p.get("info", {}) or {}
|
||
initial = _coerce_float(p.get("collateral"), p.get("initialMargin"), p.get("margin"))
|
||
if initial is None or initial <= 0:
|
||
initial = _coerce_float(
|
||
info.get("margin"),
|
||
info.get("imr"),
|
||
info.get("initial_margin"),
|
||
)
|
||
notional = _coerce_float(p.get("notional"), p.get("notionalValue"))
|
||
if notional is None or notional <= 0:
|
||
notional = _coerce_float(info.get("notionalUsd"), info.get("notional"))
|
||
if notional is not None:
|
||
notional = abs(notional)
|
||
if (initial is None or initial <= 0) and notional and notional > 0 and order_leverage:
|
||
try:
|
||
lev = float(order_leverage)
|
||
if lev > 0:
|
||
approx = notional / lev
|
||
if approx > 0:
|
||
initial = approx
|
||
except (TypeError, ValueError):
|
||
pass
|
||
unrealized = _coerce_float(
|
||
p.get("unrealizedPnl"),
|
||
info.get("upl"),
|
||
info.get("unrealized_pnl"),
|
||
)
|
||
mark = _coerce_float(p.get("markPrice"), p.get("mark_price"), info.get("markPx"))
|
||
out = {}
|
||
if initial is not None and initial > 0:
|
||
out["initial_margin"] = round(initial, FUNDS_DECIMALS)
|
||
if notional is not None and notional > 0:
|
||
out["notional"] = round(notional, FUNDS_DECIMALS)
|
||
if unrealized is not None:
|
||
out["unrealized_pnl"] = round(unrealized, FUNDS_DECIMALS)
|
||
if mark is not None and mark > 0:
|
||
out["mark_price"] = round(mark, 8)
|
||
return out or None
|
||
|
||
|
||
def _resolve_tpsl_prices_for_manual(direction, live_price, sltp_mode, data):
|
||
sltp_mode = (sltp_mode or "price").strip().lower()
|
||
if sltp_mode == "pct":
|
||
sl_pct = float(data.get("sl_pct") or 0)
|
||
tp_pct = float(data.get("tp_pct") or 0)
|
||
if sl_pct <= 0 or tp_pct <= 0:
|
||
raise ValueError("百分比止盈止损须为正数")
|
||
sl_ratio = sl_pct / 100.0
|
||
tp_ratio = tp_pct / 100.0
|
||
entry = float(live_price)
|
||
if direction == "short":
|
||
stop_loss = entry * (1 + sl_ratio)
|
||
take_profit = entry * (1 - tp_ratio)
|
||
else:
|
||
stop_loss = entry * (1 - sl_ratio)
|
||
take_profit = entry * (1 + tp_ratio)
|
||
else:
|
||
stop_loss = float(data.get("sl") or data.get("stop_loss") or 0)
|
||
take_profit = float(data.get("tp") or data.get("take_profit") or data.get("tgt") or 0)
|
||
if stop_loss <= 0 or take_profit <= 0:
|
||
raise ValueError("止盈止损价格须大于 0")
|
||
return stop_loss, take_profit
|
||
|
||
|
||
def _okx_tpsl_slot_from_order(order, exchange_symbol):
|
||
info = order.get("info") or {}
|
||
oid = order.get("id") or info.get("algoId") or info.get("ordId")
|
||
trig = _coerce_float(
|
||
info.get("slTriggerPx"),
|
||
info.get("tpTriggerPx"),
|
||
order.get("stopLossPrice"),
|
||
order.get("takeProfitPrice"),
|
||
)
|
||
if trig is None:
|
||
return None
|
||
return {
|
||
"order_id": str(oid) if oid is not None else None,
|
||
"trigger_price": float(trig),
|
||
"trigger_display": format_price_for_symbol(
|
||
exchange_symbol.replace(":USDT", "").replace("/USDT:USDT", ""),
|
||
trig,
|
||
),
|
||
"type": str(order.get("type") or info.get("ordType") or ""),
|
||
}
|
||
|
||
|
||
def fetch_exchange_tpsl_slots(exchange_symbol, direction, plan_sl=None, plan_tp=None):
|
||
slots = {"sl": None, "tp": None}
|
||
if not exchange_symbol:
|
||
return slots
|
||
ok, _ = ensure_okx_live_ready()
|
||
if not ok:
|
||
return slots
|
||
try:
|
||
ensure_markets_loaded()
|
||
ambiguous = []
|
||
for order in exchange.fetch_open_orders(exchange_symbol) or []:
|
||
slot = _okx_tpsl_slot_from_order(order, exchange_symbol)
|
||
if not slot or not slot.get("order_id"):
|
||
continue
|
||
trig = slot.get("trigger_price")
|
||
if plan_sl is not None and plan_tp is not None:
|
||
try:
|
||
role = "sl" if abs(trig - float(plan_sl)) <= abs(trig - float(plan_tp)) else "tp"
|
||
except Exception:
|
||
role = None
|
||
elif plan_sl is not None:
|
||
role = "sl"
|
||
elif plan_tp is not None:
|
||
role = "tp"
|
||
else:
|
||
ambiguous.append(slot)
|
||
continue
|
||
if role in ("sl", "tp") and slots[role] is None:
|
||
slots[role] = slot
|
||
for slot in ambiguous:
|
||
trig = slot.get("trigger_price")
|
||
if trig is None:
|
||
continue
|
||
try:
|
||
plan_sl_f = float(plan_sl) if plan_sl is not None else None
|
||
plan_tp_f = float(plan_tp) if plan_tp is not None else None
|
||
except Exception:
|
||
plan_sl_f = plan_tp_f = None
|
||
if plan_sl_f is not None and plan_tp_f is not None:
|
||
role = "sl" if abs(trig - plan_sl_f) <= abs(trig - plan_tp_f) else "tp"
|
||
elif plan_sl_f is not None:
|
||
role = "sl"
|
||
elif plan_tp_f is not None:
|
||
role = "tp"
|
||
else:
|
||
continue
|
||
if slots[role] is None:
|
||
slots[role] = slot
|
||
except Exception:
|
||
pass
|
||
return slots
|
||
|
||
|
||
def cancel_okx_tpsl_slot(exchange_symbol, slot):
|
||
if not slot or not exchange_symbol:
|
||
return
|
||
oid = slot.get("order_id")
|
||
if not oid:
|
||
return
|
||
ensure_markets_loaded()
|
||
exchange.cancel_order(str(oid), exchange_symbol)
|
||
|
||
|
||
'''
|
||
text = text.replace(
|
||
"def replace_active_monitor_tpsl_on_exchange(order_row, stop_loss, take_profit):",
|
||
insert + "def replace_active_monitor_tpsl_on_exchange(order_row, stop_loss, take_profit):",
|
||
)
|
||
|
||
# render_main_page funding + template vars (gate style)
|
||
text = text.replace(
|
||
" funding_capital, trading_capital = get_exchange_capitals()\n"
|
||
" total_capital = round(funding_capital, 4) if funding_capital is not None else TOTAL_CAPITAL\n"
|
||
" current_capital = round(trading_capital, 4) if trading_capital is not None else round(local_current_capital, 4)\n",
|
||
" funding_capital, trading_capital = get_exchange_capitals()\n"
|
||
" funding_usdt = round(funding_capital, FUNDS_DECIMALS) if funding_capital is not None else None\n"
|
||
" current_capital = round(trading_capital, FUNDS_DECIMALS) if trading_capital is not None else round(local_current_capital, FUNDS_DECIMALS)\n",
|
||
)
|
||
text = text.replace(
|
||
" can_trade = now.hour >= TRADING_DAY_RESET_HOUR and active_count == 0\n"
|
||
" key_gate_rule_text = (\n"
|
||
' f"周期 {KLINE_TIMEFRAME}｜量能/突破/二确门控见箱体与收敛规则｜"\n',
|
||
" can_trade = trading_day_reset_allows_new_open(now) and active_count < MAX_ACTIVE_POSITIONS\n"
|
||
" key_gate_rule_text = (\n"
|
||
' f"周期 {KLINE_TIMEFRAME}｜确认K：突破棒偏移 {KEY_CONFIRM_BREAKOUT_BAR}、确认棒偏移 {KEY_CONFIRM_BAR}｜"\n'
|
||
' f"量能：突破量 > 前{KEY_VOLUME_MA_BARS}均量×{KEY_VOLUME_RATIO_MIN}｜"\n',
|
||
)
|
||
text = text.replace(
|
||
' f"斐波：添加后立即挂限价 @ E，失效按标记价触达 H/L（未成交撤单）"\n',
|
||
' f"箱体/收敛可选 SL/TP 方案（标准 / 箱体1R·止盈1.5H / 趋势单+自填止盈）｜移动保本默认关｜"\n'
|
||
' f"斐波：限价 @ E（SL/TP 为 H/L），可选移动保本｜趋势止损外侧 {KEY_TREND_STOP_OUTSIDE_PCT}%"\n',
|
||
)
|
||
text = text.replace(" total_capital=total_capital,\n", "")
|
||
text = text.replace(
|
||
" key_auto_min_planned_rr=KEY_AUTO_MIN_PLANNED_RR,\n **strategy_extra,",
|
||
" funds_fmt=format_funds_u,\n"
|
||
" exchange_display=EXCHANGE_DISPLAY_NAME,\n"
|
||
" max_active_positions=MAX_ACTIVE_POSITIONS,\n"
|
||
" manual_min_planned_rr=MANUAL_MIN_PLANNED_RR,\n"
|
||
" key_auto_min_planned_rr=KEY_AUTO_MIN_PLANNED_RR,\n"
|
||
" kline_timeframe=KLINE_TIMEFRAME,\n"
|
||
" funding_usdt=funding_usdt,\n"
|
||
" **strategy_extra,",
|
||
)
|
||
|
||
if '@app.route("/key_monitor")' not in text:
|
||
text = text.replace(
|
||
'@app.route("/trade")\n@login_required\ndef trade_page():',
|
||
'@app.route("/key_monitor")\n@login_required\ndef key_monitor_page():\n'
|
||
' return render_main_page("key_monitor")\n\n\n'
|
||
'@app.route("/trade")\n@login_required\ndef trade_page():',
|
||
)
|
||
|
||
# account_snapshot
|
||
text = re.sub(
|
||
r"@app\.route\(\"/api/account_snapshot\"\).*?return jsonify\(\{[^}]+\}\)",
|
||
'''@app.route("/api/account_snapshot")
|
||
@login_required
|
||
def api_account_snapshot():
|
||
now = app_now()
|
||
trading_day = get_trading_day(now)
|
||
conn = get_db()
|
||
session_row = ensure_session(conn, trading_day)
|
||
local_current_capital = float(session_row["current_capital"])
|
||
funding_capital, trading_capital = get_exchange_capitals(force=True)
|
||
funding_usdt = round(funding_capital, FUNDS_DECIMALS) if funding_capital is not None else None
|
||
current_capital = round(trading_capital, FUNDS_DECIMALS) if trading_capital is not None else round(local_current_capital, FUNDS_DECIMALS)
|
||
recommended_capital = get_recommended_capital(current_capital)
|
||
active_count = get_active_position_count(conn)
|
||
conn.close()
|
||
can_trade = trading_day_reset_allows_new_open(now) and active_count < MAX_ACTIVE_POSITIONS
|
||
available_trading_usdt = get_available_trading_usdt()
|
||
return jsonify({
|
||
"funding_usdt": funding_usdt,
|
||
"current_capital": current_capital,
|
||
"available_trading_usdt": round(available_trading_usdt, FUNDS_DECIMALS) if available_trading_usdt is not None else None,
|
||
"recommended_capital": recommended_capital,
|
||
"active_count": active_count,
|
||
"max_active_positions": MAX_ACTIVE_POSITIONS,
|
||
"can_trade": can_trade,
|
||
"manual_min_planned_rr": MANUAL_MIN_PLANNED_RR,
|
||
"trading_day": trading_day,
|
||
})''',
|
||
text,
|
||
count=1,
|
||
flags=re.DOTALL,
|
||
)
|
||
|
||
# api_price_snapshot from gate (OKX positions)
|
||
gate_ps = re.search(
|
||
r'@app\.route\("/api/price_snapshot"\).*?return jsonify\(\{[^}]+\}\)',
|
||
gate_text,
|
||
re.DOTALL,
|
||
)
|
||
if gate_ps:
|
||
ps = gate_ps.group(0)
|
||
ps = ps.replace("exchange_private_api_configured()", "exchange_private_api_configured()")
|
||
ps = ps.replace(
|
||
'all_swap_positions = exchange.fetch_positions(None, {"settle": "usdt"}) or []',
|
||
'all_swap_positions = exchange.fetch_positions(None, {"instType": OKX_POSITION_INST_TYPE}) or []',
|
||
)
|
||
ps = ps.replace("fetch_exchange_tpsl_slots(", "fetch_exchange_tpsl_slots(")
|
||
ps = ps.replace("cancel_gate_tpsl_slot", "cancel_okx_tpsl_slot")
|
||
ps = ps.replace("ensure_exchange_live_ready", "ensure_okx_live_ready")
|
||
text = re.sub(
|
||
r'@app\.route\("/api/price_snapshot"\).*?return jsonify\(\{[^}]+\}\)',
|
||
ps,
|
||
text,
|
||
count=1,
|
||
flags=re.DOTALL,
|
||
)
|
||
|
||
# cancel/place tpsl routes
|
||
if 'api_order_cancel_tpsl' not in text:
|
||
bin_text = (BIN / "app.py").read_text(encoding="utf-8")
|
||
m = re.search(
|
||
r'@app\.route\("/api/order/<int:order_id>/cancel_tpsl".*?exchange_tpsl": slots,\s*\}\s*\)',
|
||
bin_text,
|
||
re.DOTALL,
|
||
)
|
||
if m:
|
||
block = m.group(0)
|
||
block = block.replace("ensure_exchange_live_ready", "ensure_okx_live_ready")
|
||
block = block.replace("cancel_binance_tpsl_slot", "cancel_okx_tpsl_slot")
|
||
block = block.replace(
|
||
'fetch_exchange_tpsl_slots(ex_sym, row["direction"])',
|
||
'fetch_exchange_tpsl_slots(ex_sym, row["direction"], plan_sl=row["stop_loss"], plan_tp=row["take_profit"])',
|
||
)
|
||
block = block.replace(
|
||
'fetch_exchange_tpsl_slots(ex_sym, direction)',
|
||
'fetch_exchange_tpsl_slots(ex_sym, direction, plan_sl=stop_loss, plan_tp=take_profit)',
|
||
)
|
||
text = text.replace(
|
||
'@app.route("/add_key", methods=["POST"])',
|
||
block + '\n\n@app.route("/add_key", methods=["POST"])',
|
||
)
|
||
|
||
# add_order RR + redirects
|
||
if "planned_rr_manual" not in text:
|
||
text = text.replace(
|
||
" if stop_loss <= 0 or take_profit <= 0:\n"
|
||
" conn.close()\n"
|
||
" flash(\"价格参数必须大于0\")\n"
|
||
" return redirect(\"/\")\n"
|
||
" risk_fraction = calc_risk_fraction",
|
||
" if stop_loss <= 0 or take_profit <= 0:\n"
|
||
" conn.close()\n"
|
||
" flash(\"价格参数必须大于0\")\n"
|
||
" return redirect(\"/trade\")\n"
|
||
" planned_rr_manual = calc_rr_ratio(direction, live_price, stop_loss, take_profit)\n"
|
||
" if planned_rr_manual is None or planned_rr_manual < MANUAL_MIN_PLANNED_RR:\n"
|
||
" conn.close()\n"
|
||
" rr_txt = f\"{planned_rr_manual:.4f}\" if planned_rr_manual is not None else \"无法计算\"\n"
|
||
" flash(f\"风控拒绝下单：计划盈亏比 {rr_txt}:1 低于最低要求 {MANUAL_MIN_PLANNED_RR}:1\")\n"
|
||
" return redirect(\"/trade\")\n"
|
||
" risk_fraction = calc_risk_fraction",
|
||
)
|
||
|
||
text = text.replace(
|
||
'if get_active_position_count(conn) > 0:\n'
|
||
' conn.close()\n'
|
||
' flash("当前已有持仓：无法添加「箱体突破 / 收敛突破」（请先平仓或使用阻力/支撑/斐波类型）")',
|
||
'occupied = get_active_position_count(conn)\n'
|
||
' if occupied >= MAX_ACTIVE_POSITIONS:\n'
|
||
' conn.close()\n'
|
||
' flash(\n'
|
||
' f"当前持仓已达上限（{occupied}/{MAX_ACTIVE_POSITIONS}）：无法添加「箱体突破 / 收敛突破」。"\n'
|
||
' "请先平仓或使用阻力/支撑/斐波类型"\n'
|
||
' )',
|
||
)
|
||
|
||
# add_key → /key_monitor (success paths in add_key only)
|
||
text = text.replace(
|
||
'def add_key():\n d = request.form\n symbol = normalize_symbol_input(d.get("symbol"))\n if not symbol:\n flash("symbol 不能为空")\n return redirect("/")',
|
||
'def add_key():\n d = request.form\n symbol = normalize_symbol_input(d.get("symbol"))\n if not symbol:\n flash("symbol 不能为空")\n return redirect("/key_monitor")',
|
||
)
|
||
text = re.sub(
|
||
r'(def add_key\(\):.*?)(return redirect\("/"\))',
|
||
lambda m: m.group(1) + 'return redirect("/key_monitor")',
|
||
text,
|
||
count=0,
|
||
flags=re.DOTALL,
|
||
)
|
||
|
||
text = text.replace(
|
||
'if "一次只能持有一个仓位" in reason:',
|
||
'if "已达最大持仓数" in reason or "一次只能持有一个仓位" in reason:',
|
||
)
|
||
|
||
app_path.write_text(text, encoding="utf-8")
|
||
print("patched", app_path)
|
||
|
||
|
||
def copy_templates():
|
||
src = BIN / "templates" / "index.html"
|
||
dst = OKX / "templates" / "index.html"
|
||
shutil.copy2(src, dst)
|
||
print("copied", dst)
|
||
|
||
|
||
def copy_env_example():
|
||
bin_env = (BIN / ".env.example").read_text(encoding="utf-8")
|
||
okx_path = OKX / ".env.example"
|
||
okx = okx_path.read_text(encoding="utf-8")
|
||
# inject binance-style blocks if missing
|
||
for marker, block in [
|
||
(
|
||
"TRADING_DAY_RESET_OPEN_GUARD",
|
||
"\nTRADING_DAY_RESET_OPEN_GUARD_ENABLED=true\n",
|
||
),
|
||
("MAX_ACTIVE_POSITIONS", "\nMAX_ACTIVE_POSITIONS=1\nMANUAL_MIN_PLANNED_RR=1.4\n"),
|
||
("KEY_CONFIRM_BREAKOUT_BAR", "\nKEY_CONFIRM_BREAKOUT_BAR=-2\nKEY_CONFIRM_BAR=-1\nKEY_VOLUME_MA_BARS=20\nKEY_VOLUME_RATIO_MIN=1.3\nKEY_BREAKOUT_AMP_MIN_PCT=0.03\nKEY_BREAKOUT_AMP_MAX_PCT=0.5\n"),
|
||
("EXCHANGE_DISPLAY_NAME", "\nEXCHANGE_DISPLAY_NAME=OKX\nOKX_ACCOUNT_LABEL=\n"),
|
||
("BACKUP_ROOT", "\nBACKUP_ROOT=/root/backups\nBACKUP_RETENTION_DAYS=30\nBACKUP_INSTANCE=crypto_monitor_okx\n"),
|
||
]:
|
||
if marker not in okx:
|
||
okx += block
|
||
if "TOTAL_CAPITAL=100" in okx and "# TOTAL_CAPITAL" not in okx:
|
||
okx = okx.replace("TOTAL_CAPITAL=100", "# TOTAL_CAPITAL=100 # 已弃用，资金展示读交易所")
|
||
okx_path.write_text(okx, encoding="utf-8")
|
||
print("updated .env.example")
|
||
|
||
|
||
def copy_scripts_docs():
|
||
for name in ("backup_data.sh", "install_backup_cron.sh"):
|
||
s = BIN / "scripts" / name
|
||
d = OKX / "scripts" / name
|
||
if s.is_file():
|
||
d.parent.mkdir(parents=True, exist_ok=True)
|
||
content = s.read_text(encoding="utf-8").replace("crypto_monitor_binance", "crypto_monitor_okx")
|
||
content = content.replace("BINANCE", "OKX")
|
||
d.write_text(content, encoding="utf-8")
|
||
v = BIN / "scripts" / "verify_binance_funding.py"
|
||
if v.is_file():
|
||
t = v.read_text(encoding="utf-8")
|
||
t = t.replace("binance", "okx").replace("BINANCE", "OKX").replace("verify_binance", "verify_okx")
|
||
(OKX / "scripts" / "verify_okx_funding.py").write_text(t, encoding="utf-8")
|
||
doc = BIN / "关键位自动下单说明.md"
|
||
if doc.is_file() and not (OKX / "关键位自动下单说明.md").exists():
|
||
shutil.copy2(doc, OKX / "关键位自动下单说明.md")
|
||
eco = OKX / "ecosystem.config.cjs"
|
||
if eco.is_file():
|
||
t = eco.read_text(encoding="utf-8").replace("GATE_SOCKS_PROXY", "OKX_SOCKS_PROXY")
|
||
eco.write_text(t, encoding="utf-8")
|
||
|
||
|
||
if __name__ == "__main__":
|
||
copy_templates()
|
||
patch_app()
|
||
copy_env_example()
|
||
copy_scripts_docs()
|
||
print("done")
|