183 lines
8.1 KiB
Python
183 lines
8.1 KiB
Python
"""Global risk gate for paper trading entries."""
|
|
|
|
from __future__ import annotations
|
|
|
|
from app.core.market_regime import classify_market_regime
|
|
from app.core.sector_map import get_sector_for_coin
|
|
from app.services.market_overview import get_crypto_market_overview
|
|
|
|
|
|
def _safe_float(value, default: float = 0.0) -> float:
|
|
try:
|
|
if value is None or value == "":
|
|
return default
|
|
return float(value)
|
|
except Exception:
|
|
return default
|
|
|
|
|
|
def _safe_int(value, default: int = 0) -> int:
|
|
try:
|
|
return int(value or 0)
|
|
except Exception:
|
|
return default
|
|
|
|
|
|
def _portfolio_snapshot(conn, account_equity: float, additional_notional: float) -> dict:
|
|
open_rows = conn.execute("SELECT notional_usdt, pnl_pct FROM paper_trades WHERE status='open'").fetchall()
|
|
pending_notional = _safe_float(conn.execute("SELECT COALESCE(SUM(notional_usdt),0) FROM paper_orders WHERE status='pending'").fetchone()[0])
|
|
open_notional = 0.0
|
|
unrealized = 0.0
|
|
for row in open_rows:
|
|
notional = _safe_float(row["notional_usdt"])
|
|
open_notional += notional
|
|
unrealized += notional * _safe_float(row["pnl_pct"]) / 100
|
|
projected_notional = open_notional + pending_notional + max(0.0, _safe_float(additional_notional))
|
|
current_equity = account_equity + unrealized
|
|
return {
|
|
"open_count": len(open_rows),
|
|
"open_notional_usdt": round(open_notional, 8),
|
|
"pending_notional_usdt": round(pending_notional, 8),
|
|
"additional_notional_usdt": round(max(0.0, _safe_float(additional_notional)), 8),
|
|
"projected_notional_usdt": round(projected_notional, 8),
|
|
"unrealized_pnl_usdt": round(unrealized, 8),
|
|
"current_equity_usdt": round(current_equity, 8),
|
|
"unrealized_drawdown_pct": round(abs(min(0.0, unrealized)) / account_equity * 100, 6) if account_equity > 0 else 0,
|
|
"projected_cumulative_leverage": round(projected_notional / max(1.0, current_equity), 6),
|
|
}
|
|
|
|
|
|
def _sector_names(symbol: str, rec: dict | None = None) -> list[str]:
|
|
sectors = []
|
|
rec = rec or {}
|
|
raw = rec.get("sector") or ""
|
|
if raw:
|
|
sectors.extend([x.strip() for x in str(raw).split(",") if x.strip()])
|
|
if not sectors:
|
|
sectors.extend(get_sector_for_coin(symbol))
|
|
return sorted({x for x in sectors if x})
|
|
|
|
|
|
def _concentration_snapshot(conn, rec: dict | None = None) -> dict:
|
|
rec = rec or {}
|
|
target_symbol = str(rec.get("symbol") or "").strip().upper()
|
|
target_side = str(rec.get("side") or rec.get("direction") or "long").strip().lower()
|
|
target_sectors = _sector_names(target_symbol, rec)
|
|
open_rows = [dict(r) for r in conn.execute("SELECT symbol, side, notional_usdt FROM paper_trades WHERE status='open'").fetchall()]
|
|
same_direction_count = 0
|
|
same_direction_notional = 0.0
|
|
sector_counts = {sector: 0 for sector in target_sectors}
|
|
sector_notional = {sector: 0.0 for sector in target_sectors}
|
|
for row in open_rows:
|
|
row_side = str(row.get("side") or "long").strip().lower()
|
|
if row_side == target_side:
|
|
same_direction_count += 1
|
|
same_direction_notional += _safe_float(row.get("notional_usdt"))
|
|
row_sectors = _sector_names(row.get("symbol") or "")
|
|
for sector in target_sectors:
|
|
if sector in row_sectors:
|
|
sector_counts[sector] = sector_counts.get(sector, 0) + 1
|
|
sector_notional[sector] = sector_notional.get(sector, 0.0) + _safe_float(row.get("notional_usdt"))
|
|
return {
|
|
"target_symbol": target_symbol,
|
|
"target_side": target_side,
|
|
"target_sectors": target_sectors,
|
|
"same_direction_count": same_direction_count,
|
|
"same_direction_notional_usdt": round(same_direction_notional, 8),
|
|
"same_sector_counts": sector_counts,
|
|
"same_sector_notional_usdt": {k: round(v, 8) for k, v in sector_notional.items()},
|
|
}
|
|
|
|
|
|
def evaluate_global_risk(
|
|
*,
|
|
conn,
|
|
config: dict,
|
|
rec: dict | None = None,
|
|
additional_notional: float = 0.0,
|
|
overview: dict | None = None,
|
|
) -> dict:
|
|
"""Evaluate whether the system should allow a new paper-trading entry."""
|
|
cfg = config if isinstance(config, dict) else {}
|
|
if not bool(cfg.get("global_risk_gate_enabled", True)):
|
|
return {
|
|
"enabled": False,
|
|
"allow_new_entries": True,
|
|
"risk_level": "disabled",
|
|
"reasons": ["全局风控门禁已关闭"],
|
|
}
|
|
|
|
if overview is None:
|
|
overview = get_crypto_market_overview(allow_live_fallback=False)
|
|
regime = classify_market_regime(overview)
|
|
account_equity = max(1.0, _safe_float(cfg.get("account_equity_usdt"), 20000.0))
|
|
portfolio = _portfolio_snapshot(conn, account_equity, additional_notional)
|
|
concentration = _concentration_snapshot(conn, rec)
|
|
rec_score = _safe_float((rec or {}).get("rec_score") or (rec or {}).get("score"))
|
|
min_score_high = max(0.0, _safe_float(cfg.get("global_risk_high_min_rec_score"), 70.0))
|
|
max_drawdown_critical = max(0.0, _safe_float(cfg.get("global_risk_critical_drawdown_pct"), 6.0))
|
|
max_drawdown_high = max(0.0, _safe_float(cfg.get("global_risk_high_drawdown_pct"), 3.0))
|
|
reasons = list(regime.get("reasons") or [])
|
|
risk_level = str(regime.get("risk_level") or "medium")
|
|
allow = True
|
|
decision = "allow"
|
|
|
|
drawdown = _safe_float(portfolio.get("unrealized_drawdown_pct"))
|
|
if max_drawdown_critical > 0 and drawdown >= max_drawdown_critical:
|
|
risk_level = "critical"
|
|
reasons.append("账户浮亏已进入 critical 区间，暂停所有新开仓")
|
|
elif max_drawdown_high > 0 and drawdown >= max_drawdown_high and risk_level not in {"critical"}:
|
|
risk_level = "high"
|
|
reasons.append("账户浮亏偏高，只允许高质量机会")
|
|
|
|
if risk_level == "critical" and bool(cfg.get("global_risk_block_critical", True)):
|
|
allow = False
|
|
decision = "block_critical"
|
|
elif risk_level == "high" and rec_score < min_score_high:
|
|
allow = False
|
|
decision = "block_high_weak_score"
|
|
reasons.append(f"高风险环境下推荐分 {rec_score:.1f} 低于 {min_score_high:.1f}")
|
|
|
|
max_open_positions = max(0, _safe_int(cfg.get("global_risk_max_open_positions"), 0))
|
|
if allow and max_open_positions > 0 and int(portfolio.get("open_count") or 0) >= max_open_positions:
|
|
allow = False
|
|
decision = "block_max_open_positions"
|
|
risk_level = "high" if risk_level not in {"critical"} else risk_level
|
|
reasons.append(f"持仓数量已达到上限 {max_open_positions}")
|
|
|
|
max_same_direction = max(0, _safe_int(cfg.get("global_risk_max_same_direction_positions"), 0))
|
|
projected_same_direction = _safe_int(concentration.get("same_direction_count")) + (1 if rec else 0)
|
|
if allow and max_same_direction > 0 and projected_same_direction > max_same_direction:
|
|
allow = False
|
|
decision = "block_same_direction_concentration"
|
|
risk_level = "high" if risk_level not in {"critical"} else risk_level
|
|
reasons.append(f"同方向持仓将达到 {projected_same_direction} 个，超过上限 {max_same_direction}")
|
|
|
|
max_same_sector = max(0, _safe_int(cfg.get("global_risk_max_same_sector_positions"), 0))
|
|
if allow and max_same_sector > 0:
|
|
for sector, count in (concentration.get("same_sector_counts") or {}).items():
|
|
projected = _safe_int(count) + 1
|
|
if projected > max_same_sector:
|
|
allow = False
|
|
decision = "block_same_sector_concentration"
|
|
risk_level = "high" if risk_level not in {"critical"} else risk_level
|
|
reasons.append(f"{sector} 板块持仓将达到 {projected} 个，超过上限 {max_same_sector}")
|
|
break
|
|
|
|
return {
|
|
"enabled": True,
|
|
"allow_new_entries": allow,
|
|
"decision": decision,
|
|
"risk_level": risk_level,
|
|
"position_multiplier": regime.get("position_multiplier", 1.0),
|
|
"max_open_positions": max_open_positions,
|
|
"min_score_when_high_risk": min_score_high,
|
|
"reasons": reasons,
|
|
"market_regime": regime,
|
|
"portfolio": portfolio,
|
|
"concentration": concentration,
|
|
}
|
|
|
|
|
|
__all__ = ["evaluate_global_risk"]
|