gavindiaz/DinQuant
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

v3.0.1

Browse Source 
Signed-off-by: Dinger <quantdinger@gmail.com>
This commit is contained in:
Dinger
2026-04-06 23:19:41 +08:00
parent 3ca291a346
commit de3fd0945b
91 changed files with 1504 additions and 405 deletions
Download Patch File Download Diff File Expand all files Collapse all files
backend_api_python/app/services/backtest.py
+71 -1
View File
@@ -504,6 +504,12 @@ class BacktestService:
result['precision_info']['message'] = 'Using standard backtest because scale rules are not fully supported in MTF mode'
elif fallback_reason == 'signal_timing_not_supported_in_mtf':
result['precision_info']['message'] = 'Using standard backtest because this execution timing is not fully supported in MTF mode'
ea = result.get('executionAssumptions') or {}
ea['mtfRequested'] = bool(enable_mtf)
ea['mtfActive'] = False
if fallback_reason:
ea['mtfFallbackReason'] = fallback_reason
result['executionAssumptions'] = ea
return result
logger.info(f"Multi-timeframe backtest: strategy_tf={timeframe}, exec_tf={exec_tf}, range={start_date} ~ {end_date}")
@@ -554,6 +560,11 @@ class BacktestService:
'reason': 'data_unavailable',
'message': f'Cannot fetch {exec_tf} data, using standard backtest'
}
ea = result.get('executionAssumptions') or {}
ea['mtfRequested'] = bool(enable_mtf)
ea['mtfActive'] = False
ea['mtfFallbackReason'] = 'data_unavailable'
result['executionAssumptions'] = ea
return result
logger.info(f"Data fetched: signal_candles={len(df_signal)}, exec_candles={len(df_exec)}")
@@ -598,6 +609,14 @@ class BacktestService:
result['execution_timeframe'] = exec_tf
result['signal_candles'] = len(df_signal)
result['execution_candles'] = len(df_exec)
result['executionAssumptions'] = self._execution_assumptions(
strategy_config,
simulation_mode='mtf',
signal_timeframe=timeframe,
execution_timeframe=exec_tf,
mtf_requested=True,
mtf_active=True,
)
logger.info("Backtest result formatted successfully")
except Exception as e:
logger.error(f"Failed to format result: {str(e)}")
@@ -1487,6 +1506,11 @@ class BacktestService:
'precision': 'standard',
'message': 'Using standard strategy script backtest'
}
result['executionAssumptions'] = self._execution_assumptions(
strategy_config,
simulation_mode='standard',
signal_timeframe=timeframe,
)
return result
def run_code_strategy(
@@ -1607,7 +1631,13 @@ class BacktestService:
metrics = self._calculate_metrics(equity_curve, trades, initial_capital, timeframe, start_date, end_date, total_commission)
# 5. Format result
return self._format_result(metrics, equity_curve, trades)
result = self._format_result(metrics, equity_curve, trades)
result['executionAssumptions'] = self._execution_assumptions(
strategy_config,
simulation_mode='standard',
signal_timeframe=timeframe,
)
return result
def _fetch_kline_data(
self,
@@ -4740,6 +4770,46 @@ import pandas as pd
logger.warning(f"Sharpe ratio calculation failed: {e}")
return 0
def _execution_assumptions(
self,
strategy_config: Optional[Dict[str, Any]],
*,
simulation_mode: str,
signal_timeframe: Optional[str] = None,
execution_timeframe: Optional[str] = None,
mtf_requested: bool = False,
mtf_active: bool = False,
mtf_fallback_reason: Optional[str] = None,
) -> Dict[str, Any]:
"""
Human-facing metadata so the UI can explain how trades were timed vs chart markers.
Keys use camelCase for JSON consumers (frontend).
"""
cfg = strategy_config or {}
raw = str((cfg.get('execution') or {}).get('signalTiming') or 'next_bar_open').strip().lower()
is_next_open = raw in ('next_bar_open', 'next_open', 'nextopen', 'next')
if raw in ('bar_close', 'close', 'same_bar_close', 'current_bar_close'):
timing_key = 'same_bar_close'
elif is_next_open:
timing_key = 'next_bar_open'
else:
timing_key = raw
default_fill = 'open' if is_next_open else 'close'
payload: Dict[str, Any] = {
'signalTiming': timing_key,
'signalTimingRaw': raw,
'defaultFillPrice': default_fill,
'simulationMode': simulation_mode,
'strategyTimeframe': signal_timeframe,
'executionTimeframe': execution_timeframe,
'engineVersion': self.ENGINE_VERSION,
'mtfRequested': bool(mtf_requested),
'mtfActive': bool(mtf_active),
}
if mtf_fallback_reason:
payload['mtfFallbackReason'] = mtf_fallback_reason
return payload
def _format_result(
self,
metrics: Dict,
backend_api_python/app/services/live_trading/binance.py
+84 -14
View File
@@ -40,6 +40,10 @@ class BinanceFuturesClient(BaseRestClient):
self._dual_side_cache: Optional[Tuple[float, bool]] = None
self._dual_side_cache_ttl_sec = 60.0
# serverTime - local_ms; avoids Binance -1021 when the host clock is ahead of Binance.
self._time_offset_ms: int = 0
self._time_sync_monotonic: float = 0.0
@staticmethod
def _to_dec(x: Any) -> Decimal:
try:
@@ -163,6 +167,26 @@ class BinanceFuturesClient(BaseRestClient):
def _signed_headers(self) -> Dict[str, str]:
return {"X-MBX-APIKEY": self.api_key}
def _ensure_server_time(self, *, force: bool = False) -> None:
"""
Align signed request timestamps with Binance server time (GET /fapi/v1/time).
"""
now_m = time.monotonic()
if not force and (now_m - float(self._time_sync_monotonic or 0.0)) < 300.0:
return
try:
code, data, _ = self._request("GET", "/fapi/v1/time")
if code != 200 or not isinstance(data, dict):
return
server_ms = int(data.get("serverTime") or 0)
if server_ms <= 0:
return
local_ms = int(time.time() * 1000)
self._time_offset_ms = server_ms - local_ms
self._time_sync_monotonic = now_m
except Exception:
pass
def _format_client_order_id(self, client_order_id: Optional[str]) -> str:
raw = str(client_order_id or "").strip()
broker_id = str(self.broker_id or "").strip()
@@ -179,17 +203,34 @@ class BinanceFuturesClient(BaseRestClient):
return f"{prefix}{raw[:suffix_budget]}"
def _signed_request(self, method: str, path: str, *, params: Dict[str, Any]) -> Dict[str, Any]:
p = dict(params or {})
# Use server-accepted timestamp in ms.
p["timestamp"] = int(time.time() * 1000)
qs = urlencode(p, doseq=True)
p["signature"] = self._sign(qs)
code, data, text = self._request(method, path, params=p, headers=self._signed_headers())
if code >= 400:
raise LiveTradingError(f"Binance HTTP {code}: {text[:500]}")
if isinstance(data, dict) and data.get("code") and int(data.get("code")) < 0:
raise LiveTradingError(f"Binance error: {data}")
return data if isinstance(data, dict) else {"raw": data}
self._ensure_server_time()
last_err: Optional[LiveTradingError] = None
for attempt in range(2):
p = dict(params or {})
p["timestamp"] = int(time.time() * 1000) + int(self._time_offset_ms)
if "recvWindow" not in p:
p["recvWindow"] = 10000
qs = urlencode(p, doseq=True)
p["signature"] = self._sign(qs)
code, data, text = self._request(method, path, params=p, headers=self._signed_headers())
if code >= 400:
err = LiveTradingError(f"Binance HTTP {code}: {text[:500]}")
if attempt == 0 and ("-1021" in text or "1021" in text):
self._ensure_server_time(force=True)
last_err = err
continue
raise err
if isinstance(data, dict) and data.get("code") and int(data.get("code")) < 0:
err = LiveTradingError(f"Binance error: {data}")
if attempt == 0 and int(data.get("code") or 0) == -1021:
self._ensure_server_time(force=True)
last_err = err
continue
raise err
return data if isinstance(data, dict) else {"raw": data}
if last_err:
raise last_err
raise LiveTradingError("Binance signed request failed")
def _public_request(self, method: str, path: str, *, params: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
code, data, text = self._request(method, path, params=params, headers=None, json_body=None, data=None)
@@ -870,12 +911,41 @@ class BinanceFuturesClient(BaseRestClient):
raise LiveTradingError("Binance cancel_order requires order_id or client_order_id")
return self._signed_request("DELETE", "/fapi/v1/order", params=params)
def get_positions(self) -> Any:
def set_margin_type(self, *, symbol: str, margin_mode: str) -> Dict[str, Any]:
"""
Return all futures positions (position risk endpoint).
Set symbol margin mode on USDT-M futures.
Endpoint: POST /fapi/v1/marginType
margin_mode: cross | crossed | isolated
"""
sym = to_binance_futures_symbol(symbol)
m = (margin_mode or "").strip().lower()
if m in ("cross", "crossed"):
mt = "CROSSED"
elif m in ("isolated", "iso"):
mt = "ISOLATED"
else:
raise LiveTradingError(f"Invalid margin_mode for Binance: {margin_mode}")
return self._signed_request("POST", "/fapi/v1/marginType", params={"symbol": sym, "marginType": mt})
def get_positions(self, *, symbol: str = "") -> Any:
"""
Futures positions (position risk). Optional ``symbol`` filters to one contract.
Endpoint: GET /fapi/v2/positionRisk
"""
return self._signed_request("GET", "/fapi/v2/positionRisk", params={})
raw = self._signed_request("GET", "/fapi/v2/positionRisk", params={})
rows: list
if isinstance(raw, list):
rows = raw
elif isinstance(raw, dict) and isinstance(raw.get("raw"), list):
rows = raw["raw"]
else:
rows = []
want = (symbol or "").strip()
if not want:
return rows
sym = to_binance_futures_symbol(want)
return [p for p in rows if isinstance(p, dict) and str(p.get("symbol") or "") == sym]
backend_api_python/app/services/live_trading/binance_spot.py
+49 -10
View File
@@ -31,6 +31,9 @@ class BinanceSpotClient(BaseRestClient):
self._sym_filter_cache: Dict[str, Tuple[float, Dict[str, Any]]] = {}
self._sym_filter_cache_ttl_sec = 300.0
self._time_offset_ms: int = 0
self._time_sync_monotonic: float = 0.0
@staticmethod
def _to_dec(x: Any) -> Decimal:
try:
@@ -158,6 +161,24 @@ class BinanceSpotClient(BaseRestClient):
def _signed_headers(self) -> Dict[str, str]:
return {"X-MBX-APIKEY": self.api_key}
def _ensure_server_time(self, *, force: bool = False) -> None:
"""Align signed request timestamps with Binance (GET /api/v3/time)."""
now_m = time.monotonic()
if not force and (now_m - float(self._time_sync_monotonic or 0.0)) < 300.0:
return
try:
code, data, _ = self._request("GET", "/api/v3/time")
if code != 200 or not isinstance(data, dict):
return
server_ms = int(data.get("serverTime") or 0)
if server_ms <= 0:
return
local_ms = int(time.time() * 1000)
self._time_offset_ms = server_ms - local_ms
self._time_sync_monotonic = now_m
except Exception:
pass
def _format_client_order_id(self, client_order_id: Optional[str]) -> str:
raw = str(client_order_id or "").strip()
broker_id = str(self.broker_id or "").strip()
@@ -174,16 +195,34 @@ class BinanceSpotClient(BaseRestClient):
return f"{prefix}{raw[:suffix_budget]}"
def _signed_request(self, method: str, path: str, *, params: Dict[str, Any]) -> Dict[str, Any]:
p = dict(params or {})
p["timestamp"] = int(time.time() * 1000)
qs = urlencode(p, doseq=True)
p["signature"] = self._sign(qs)
code, data, text = self._request(method, path, params=p, headers=self._signed_headers())
if code >= 400:
raise LiveTradingError(f"BinanceSpot HTTP {code}: {text[:500]}")
if isinstance(data, dict) and data.get("code") and int(data.get("code")) < 0:
raise LiveTradingError(f"BinanceSpot error: {data}")
return data if isinstance(data, dict) else {"raw": data}
self._ensure_server_time()
last_err: Optional[LiveTradingError] = None
for attempt in range(2):
p = dict(params or {})
p["timestamp"] = int(time.time() * 1000) + int(self._time_offset_ms)
if "recvWindow" not in p:
p["recvWindow"] = 10000
qs = urlencode(p, doseq=True)
p["signature"] = self._sign(qs)
code, data, text = self._request(method, path, params=p, headers=self._signed_headers())
if code >= 400:
err = LiveTradingError(f"BinanceSpot HTTP {code}: {text[:500]}")
if attempt == 0 and ("-1021" in text or "1021" in text):
self._ensure_server_time(force=True)
last_err = err
continue
raise err
if isinstance(data, dict) and data.get("code") and int(data.get("code")) < 0:
err = LiveTradingError(f"BinanceSpot error: {data}")
if attempt == 0 and int(data.get("code") or 0) == -1021:
self._ensure_server_time(force=True)
last_err = err
continue
raise err
return data if isinstance(data, dict) else {"raw": data}
if last_err:
raise last_err
raise LiveTradingError("BinanceSpot signed request failed")
def ping(self) -> bool:
"""
backend_api_python/app/services/live_trading/bitget.py
+184 -11
View File
@@ -61,6 +61,10 @@ class BitgetMixClient(BaseRestClient):
self._lev_cache: Dict[str, Tuple[float, bool]] = {}
self._lev_cache_ttl_sec = 60.0
# posMode from GET /api/v2/mix/account/account (hedge_mode vs one_way_mode), cached per contract.
self._pos_mode_cache: Dict[str, Tuple[float, str]] = {}
self._pos_mode_cache_ttl_sec = 60.0
@staticmethod
def _to_dec(x: Any) -> Decimal:
try:
@@ -242,6 +246,31 @@ class BitgetMixClient(BaseRestClient):
raise LiveTradingError(f"Bitget error: {data}")
return data if isinstance(data, dict) else {"raw": data}
def _post_mix_place_order(
self,
body: Dict[str, Any],
*,
original_side: str,
reduce_only: bool,
) -> Dict[str, Any]:
"""
POST place-order; on 40774 (hedge vs one-way mismatch) retry with alternate position fields.
"""
sd = (original_side or "").lower()
try:
return self._signed_request("POST", "/api/v2/mix/order/place-order", json_body=body)
except LiveTradingError as e:
if "40774" not in str(e):
raise
b2: Dict[str, Any] = {k: v for k, v in body.items() if k not in ("side", "tradeSide", "reduceOnly")}
if "tradeSide" in body:
b2["side"] = sd
b2["reduceOnly"] = "YES" if reduce_only else "NO"
else:
b2["tradeSide"] = "close" if reduce_only else "open"
b2["side"] = ("sell" if sd == "buy" else "buy") if reduce_only else sd
return self._signed_request("POST", "/api/v2/mix/order/place-order", json_body=b2)
def _public_request(self, method: str, path: str, *, params: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
code, data, text = self._request(method, path, params=params, headers=None, json_body=None, data=None)
if code >= 400:
@@ -252,6 +281,117 @@ class BitgetMixClient(BaseRestClient):
raise LiveTradingError(f"Bitget error: {data}")
return data if isinstance(data, dict) else {"raw": data}
def get_ticker(self, *, symbol: str, **kwargs: Any) -> Dict[str, Any]:
"""
Public mix ticker (for USDT-notional -> base size conversion in quick trade).
Endpoint: GET /api/v2/mix/market/ticker
"""
sym = to_bitget_um_symbol(symbol)
pt = str(kwargs.get("product_type") or "USDT-FUTURES")
if not sym:
return {}
try:
raw = self._public_request(
"GET",
"/api/v2/mix/market/ticker",
params={"symbol": sym, "productType": pt},
)
except Exception:
return {}
data = raw.get("data") if isinstance(raw, dict) else None
if isinstance(data, list) and data:
data = data[0]
if not isinstance(data, dict):
return {}
try:
last = float(
data.get("lastPr")
or data.get("last")
or data.get("close")
or data.get("markPrice")
or data.get("indexPrice")
or 0
)
except Exception:
last = 0.0
if last <= 0:
return {}
return {"last": last, "price": last, "close": last}
def get_account_pos_mode(
self,
*,
symbol: str,
margin_coin: str = "USDT",
product_type: str = "USDT-FUTURES",
) -> str:
"""
Returns Bitget posMode for the contract account: 'hedge_mode', 'one_way_mode', or '' if unknown.
GET /api/v2/mix/account/account
"""
sym = to_bitget_um_symbol(symbol)
if not sym:
return ""
mc = (margin_coin or "USDT").strip().upper()
pt = str(product_type or "USDT-FUTURES")
key = f"{pt}:{sym}:{mc}"
now = time.time()
cached = self._pos_mode_cache.get(key)
if cached:
ts, mode = cached
if (now - float(ts or 0.0)) <= float(self._pos_mode_cache_ttl_sec or 60.0) and mode is not None:
return str(mode)
try:
resp = self._signed_request(
"GET",
"/api/v2/mix/account/account",
params={
"symbol": sym.lower(),
"productType": pt,
"marginCoin": mc.lower() or "usdt",
},
)
d = resp.get("data") if isinstance(resp, dict) else None
mode = ""
if isinstance(d, dict):
mode = str(d.get("posMode") or "").strip().lower()
self._pos_mode_cache[key] = (now, mode)
return mode
except Exception:
return ""
def _mix_order_position_fields(
self,
*,
symbol: str,
side: str,
reduce_only: bool,
margin_coin: str,
product_type: str,
) -> Dict[str, Any]:
"""
Bitget mix place-order: hedge_mode requires tradeSide open/close; one_way_mode requires reduceOnly YES/NO
and must not send tradeSide (see Bitget API doc + CCXT bitget.py).
"""
sd = (side or "").lower()
if sd not in ("buy", "sell"):
raise LiveTradingError(f"Invalid side: {side}")
pos_mode = self.get_account_pos_mode(
symbol=symbol, margin_coin=margin_coin, product_type=product_type
)
hedge = pos_mode == "hedge_mode"
if hedge:
# Mirror CCXT: hedge close flips side; hedge open keeps side + tradeSide open.
out: Dict[str, Any] = {
"tradeSide": "close" if reduce_only else "open",
"side": ("sell" if sd == "buy" else "buy") if reduce_only else sd,
}
return out
return {"side": sd, "reduceOnly": "YES" if reduce_only else "NO"}
def get_contract(self, *, symbol: str, product_type: str = "USDT-FUTURES") -> Dict[str, Any]:
"""
Fetch contract metadata (best-effort) from public endpoint.
@@ -354,13 +494,34 @@ class BitgetMixClient(BaseRestClient):
"""
return self._signed_request("GET", "/api/v2/mix/account/accounts", params={"productType": str(product_type or "USDT-FUTURES")})
def get_positions(self, *, product_type: str = "USDT-FUTURES") -> Dict[str, Any]:
def get_positions(self, *, product_type: str = "USDT-FUTURES", symbol: str = "") -> Dict[str, Any]:
"""
Get all positions (best-effort).
Get positions (best-effort).
Endpoint: GET /api/v2/mix/position/all-position
When ``symbol`` is set (e.g. ETH/USDT), filters the response list to that contract only.
"""
return self._signed_request("GET", "/api/v2/mix/position/all-position", params={"productType": str(product_type or "USDT-FUTURES")})
resp = self._signed_request(
"GET",
"/api/v2/mix/position/all-position",
params={"productType": str(product_type or "USDT-FUTURES")},
)
want = (symbol or "").strip()
if not want:
return resp
sym_key = to_bitget_um_symbol(want).upper()
if not isinstance(resp, dict):
return resp
data = resp.get("data")
if not isinstance(data, list):
return resp
filtered = [
p for p in data
if isinstance(p, dict) and str(p.get("symbol") or "").strip().upper() == sym_key
]
out = dict(resp)
out["data"] = filtered
return out
def set_leverage(
self,
@@ -444,16 +605,22 @@ class BitgetMixClient(BaseRestClient):
"productType": str(product_type or "USDT-FUTURES"),
"marginCoin": str(margin_coin or "USDT"),
"marginMode": self._normalize_margin_mode(margin_mode),
"side": sd,
"orderType": "market",
"size": self._dec_str(sz_dec, strict_precision=sz_precision),
}
if reduce_only:
body["reduceOnly"] = "YES"
body.update(
self._mix_order_position_fields(
symbol=symbol,
side=sd,
reduce_only=reduce_only,
margin_coin=str(margin_coin or "USDT"),
product_type=str(product_type or "USDT-FUTURES"),
)
)
if client_order_id:
body["clientOid"] = str(client_order_id)
raw = self._signed_request("POST", "/api/v2/mix/order/place-order", json_body=body)
raw = self._post_mix_place_order(body, original_side=sd, reduce_only=reduce_only)
data = raw.get("data") if isinstance(raw, dict) else None
exchange_order_id = ""
if isinstance(data, dict):
@@ -498,21 +665,27 @@ class BitgetMixClient(BaseRestClient):
"productType": str(product_type or "USDT-FUTURES"),
"marginCoin": str(margin_coin or "USDT"),
"marginMode": self._normalize_margin_mode(margin_mode),
"side": sd,
"orderType": "limit",
"price": str(px),
"size": self._dec_str(sz_dec, strict_precision=sz_precision),
}
body.update(
self._mix_order_position_fields(
symbol=symbol,
side=sd,
reduce_only=reduce_only,
margin_coin=str(margin_coin or "USDT"),
product_type=str(product_type or "USDT-FUTURES"),
)
)
# Force maker behavior when requested (avoid taker fills).
if post_only:
body["force"] = "post_only"
else:
body["force"] = "gtc"
if reduce_only:
body["reduceOnly"] = "YES"
if client_order_id:
body["clientOid"] = str(client_order_id)
raw = self._signed_request("POST", "/api/v2/mix/order/place-order", json_body=body)
raw = self._post_mix_place_order(body, original_side=sd, reduce_only=reduce_only)
data = raw.get("data") if isinstance(raw, dict) else None
exchange_order_id = str(data.get("orderId") or data.get("clientOid") or "") if isinstance(data, dict) else ""
return LiveOrderResult(exchange_id="bitget", exchange_order_id=exchange_order_id, filled=0.0, avg_price=0.0, raw=raw)
backend_api_python/app/services/strategy.py
+26 -7
View File
@@ -489,16 +489,35 @@ class StrategyService:
f"but fails for market_type={market_type}. This is almost always a permissions/product mismatch."
)
msg = f"{msg} | {hint}"
hint_cn = (
"币安接口返回 -2015（密钥/IP/权限不匹配）。请逐项核对："
"① API Key 是否勾选与当前测试一致的业务（现货选现货权限，合约选合约/U 本位权限）；"
"② 若启用 IP 白名单，是否包含当前服务器出口 IP（见下方 egress_ip）；"
"③ base_url 与密钥环境一致（主网密钥配 api.binance.com / fapi，模拟盘配 demo 域名与 demo Key）；"
"④ 无多余空格、复制完整 Secret。"
)
if alt_ok:
hint_cn += (
f" 自动探测：同一密钥在 market_type={alt_market_type} 可通过，"
f"当前选择的 {market_type} 与密钥权限不一致的可能性很大。"
)
else:
hint_cn = ""
fail_payload = {
'exchange': safe_cfg,
'client': client_kind,
'market_type': market_type,
'egress_ip': egress_ip,
'base_url': getattr(client, "base_url", "") or "",
}
if hint_cn:
fail_payload['hint_cn'] = hint_cn
return {
'success': False,
'message': f'Auth failed: {msg}',
'data': {
'exchange': safe_cfg,
'client': client_kind,
'market_type': market_type,
'egress_ip': egress_ip,
'base_url': getattr(client, "base_url", "") or "",
},
'data': fail_payload,
}
return {
backend_api_python/app/services/strategy_script_runtime.py
+193
View File
@@ -0,0 +1,193 @@
"""
Python 策略脚本（on_init / on_bar + ctx.buy/sell/close_position）运行时。
与回测逻辑对齐，供 TradingExecutor 实盘逐根 K 线调用。
"""
from __future__ import annotations
from typing import Any, Callable, Dict, List, Optional, Tuple
import numpy as np
import pandas as pd
from app.utils.logger import get_logger
logger = get_logger(__name__)
class ScriptBar(dict):
def __getattr__(self, name: str) -> Any:
try:
return self[name]
except KeyError as exc:
raise AttributeError(name) from exc
class ScriptPosition(dict):
def __init__(self):
super().__init__()
self.clear_position()
def __getattr__(self, name: str) -> Any:
try:
return self[name]
except KeyError as exc:
raise AttributeError(name) from exc
def __bool__(self) -> bool:
return bool(self.get('side')) and float(self.get('size') or 0) > 0
def __int__(self) -> int:
return int(self.get('direction') or 0)
def __float__(self) -> float:
return float(self.get('direction') or 0)
def __eq__(self, other: Any) -> bool:
try:
return int(self) == int(other)
except Exception:
return dict.__eq__(self, other)
def __lt__(self, other: Any) -> bool:
return int(self) < int(other)
def __le__(self, other: Any) -> bool:
return int(self) <= int(other)
def __gt__(self, other: Any) -> bool:
return int(self) > int(other)
def __ge__(self, other: Any) -> bool:
return int(self) >= int(other)
def clear_position(self) -> None:
self.clear()
self.update({
'side': '',
'size': 0.0,
'entry_price': 0.0,
'direction': 0,
'amount': 0.0,
})
def open_position(self, side: str, entry_price: float, amount: float) -> None:
direction = 1 if side == 'long' else (-1 if side == 'short' else 0)
size = float(amount or 0.0)
price = float(entry_price or 0.0)
self.clear()
self.update({
'side': side,
'size': size,
'entry_price': price,
'direction': direction,
'amount': size,
})
def add_position(self, entry_price: float, amount: float) -> None:
extra = float(amount or 0.0)
if extra <= 0:
return
current_size = float(self.get('size') or 0.0)
current_price = float(self.get('entry_price') or 0.0)
next_size = current_size + extra
next_price = float(entry_price or current_price or 0.0)
if current_size > 0 and current_price > 0 and next_size > 0:
next_price = ((current_price * current_size) + (float(entry_price or current_price) * extra)) / next_size
self['size'] = next_size
self['amount'] = next_size
self['entry_price'] = next_price
class StrategyScriptContext:
"""与回测 ScriptBacktestContext 行为一致，供实盘按根推进。"""
def __init__(self, bars_df: pd.DataFrame, initial_balance: float):
self._bars_df = bars_df
self._params: Dict[str, Any] = {}
self._orders: List[Dict[str, Any]] = []
self._logs: List[str] = []
self.current_index = -1
self.position = ScriptPosition()
self.balance = float(initial_balance)
self.equity = float(initial_balance)
def param(self, name: str, default: Any = None) -> Any:
if name not in self._params:
self._params[name] = default
return self._params[name]
def bars(self, n: int = 1):
start = max(0, self.current_index - int(n) + 1)
out = []
for _, row in self._bars_df.iloc[start:self.current_index + 1].iterrows():
out.append(ScriptBar(
open=float(row.get('open') or 0),
high=float(row.get('high') or 0),
low=float(row.get('low') or 0),
close=float(row.get('close') or 0),
volume=float(row.get('volume') or 0),
timestamp=row.get('time')
))
return out
def log(self, message: Any):
self._logs.append(str(message))
def buy(self, price: Any = None, amount: Any = None):
self._orders.append({'action': 'buy', 'price': price, 'amount': amount})
def sell(self, price: Any = None, amount: Any = None):
self._orders.append({'action': 'sell', 'price': price, 'amount': amount})
def close_position(self):
self._orders.append({'action': 'close'})
def compile_strategy_script_handlers(code: str) -> Tuple[Optional[Callable], Optional[Callable]]:
"""
校验并编译策略脚本，返回 (on_init, on_bar)。
on_bar 不可缺省；on_init 可选。
"""
if not code or not str(code).strip():
raise ValueError("Strategy script is empty")
import builtins
def safe_import(name, *args, **kwargs):
allowed_modules = ['numpy', 'pandas', 'math', 'json', 'datetime', 'time']
if name in allowed_modules or name.split('.')[0] in allowed_modules:
return builtins.__import__(name, *args, **kwargs)
raise ImportError(f"Import not allowed: {name}")
safe_builtins = {k: getattr(builtins, k) for k in dir(builtins)
if not k.startswith('_') and k not in ['eval', 'exec', 'compile', 'open', 'input', 'help', 'exit', 'quit']}
safe_builtins['__import__'] = safe_import
exec_env = {
'__builtins__': safe_builtins,
'np': np,
'pd': pd,
}
from app.utils.safe_exec import validate_code_safety, safe_exec_code
is_safe, error_msg = validate_code_safety(code)
if not is_safe:
raise ValueError(f"Code contains unsafe operations: {error_msg}")
exec_result = safe_exec_code(
code=code,
exec_globals=exec_env,
exec_locals=exec_env,
timeout=60
)
if not exec_result['success']:
raise RuntimeError(f"Code execution failed: {exec_result.get('error')}")
on_init = exec_env.get('on_init')
on_bar = exec_env.get('on_bar')
if not callable(on_bar):
raise ValueError("Strategy script must define on_bar(ctx, bar)")
if on_init is not None and not callable(on_init):
on_init = None
return (on_init if callable(on_init) else None), on_bar
backend_api_python/app/services/trading_executor.py
+393 -128
View File
@@ -1,5 +1,8 @@
"""
实时交易执行服务
实时交易执行服务。
策略线程：拉 K 线/价格、算信号，将订单写入 pending_orders。
实盘成交由 PendingOrderWorker + app.services.live_trading（各所直连 REST）完成，不在此模块使用 ccxt 下单。
"""
import time
import threading
@@ -15,13 +18,17 @@ import json
from decimal import Decimal, ROUND_DOWN, ROUND_UP
import pandas as pd
import numpy as np
import ccxt
from app.utils.logger import get_logger
from app.utils.db import get_db_connection
from app.data_sources import DataSourceFactory
from app.services.kline import KlineService
from app.services.indicator_params import IndicatorParamsParser, IndicatorCaller
from app.services.strategy_script_runtime import (
ScriptBar,
StrategyScriptContext,
compile_strategy_script_handlers,
)
logger = get_logger(__name__)
@@ -465,6 +472,212 @@ class TradingExecutor:
logger.error(f"Failed to stop strategy {strategy_id}: {str(e)}")
logger.error(traceback.format_exc())
return False
def _df_to_script_exec_df(self, df: pd.DataFrame) -> pd.DataFrame:
out = df.reset_index()
c0 = out.columns[0]
if c0 != 'time':
out.rename(columns={c0: 'time'}, inplace=True)
return out
def _script_default_position_ratio(self, trading_config: Dict[str, Any]) -> float:
try:
ep = (trading_config or {}).get('entry_pct')
if ep is not None:
return float(self._to_ratio(ep, default=0.06))
except Exception:
pass
return 0.06
def _hydrate_script_ctx_from_positions(self, ctx: StrategyScriptContext, strategy_id: int, symbol: str) -> None:
ctx.position.clear_position()
pl = self._get_current_positions(strategy_id, symbol)
if not pl:
return
p = pl[0]
side = (p.get('side') or 'long').strip().lower()
if side not in ('long', 'short'):
return
size = float(p.get('size') or 0)
ep = float(p.get('entry_price') or 0)
if size > 0:
ctx.position.open_position(side, ep, size)
def _init_script_strategy_context(
self,
strategy_id: int,
df: pd.DataFrame,
trading_config: Dict[str, Any],
initial_capital: float,
) -> Tuple[StrategyScriptContext, Optional[pd.Timestamp]]:
df_exec = self._df_to_script_exec_df(df)
ctx = StrategyScriptContext(df_exec, float(initial_capital or 0))
raw = (trading_config or {}).get('script_runtime_state') or {}
params = raw.get('params') if isinstance(raw, dict) else {}
if isinstance(params, dict):
ctx._params = dict(params)
last_ts = None
ts_s = raw.get('last_closed_bar_ts') if isinstance(raw, dict) else None
if ts_s:
try:
last_ts = pd.Timestamp(ts_s)
if last_ts.tzinfo is None:
last_ts = last_ts.tz_localize('UTC')
else:
last_ts = last_ts.tz_convert('UTC')
except Exception:
last_ts = None
return ctx, last_ts
def _persist_script_runtime_state(self, strategy_id: int, closed_ts: Any, params: Dict[str, Any]) -> None:
try:
safe_params = json.loads(json.dumps(params or {}, default=str))
except Exception:
safe_params = {}
ts_str = ''
try:
if closed_ts is not None:
ts_str = pd.Timestamp(closed_ts).isoformat()
except Exception:
ts_str = ''
state = {'last_closed_bar_ts': ts_str, 'params': safe_params}
try:
with get_db_connection() as db:
cur = db.cursor()
cur.execute("SELECT trading_config FROM qd_strategies_trading WHERE id = %s", (strategy_id,))
row = cur.fetchone()
if not row:
cur.close()
return
tc = row.get('trading_config')
if isinstance(tc, str) and tc.strip():
try:
tc = json.loads(tc)
except Exception:
tc = {}
elif not isinstance(tc, dict):
tc = {}
tc['script_runtime_state'] = state
cur.execute(
"UPDATE qd_strategies_trading SET trading_config = %s WHERE id = %s",
(json.dumps(tc, ensure_ascii=False), strategy_id),
)
db.commit()
cur.close()
except Exception as e:
logger.warning(f"Persist script runtime state failed: {e}")
def _script_orders_to_execution_signals(
self,
ctx: StrategyScriptContext,
trade_direction: str,
bar_close: float,
closed_ts: pd.Timestamp,
trading_config: Dict[str, Any],
) -> List[Dict[str, Any]]:
td = str(trade_direction or 'both').lower()
if td not in ('long', 'short', 'both'):
td = 'both'
default_ratio = self._script_default_position_ratio(trading_config)
try:
ts_i = int(closed_ts.timestamp())
except Exception:
ts_i = int(time.time())
out: List[Dict[str, Any]] = []
trig = float(bar_close or 0)
for order in list(ctx._orders or []):
action = str(order.get('action') or '').lower()
try:
order_price = float(order.get('price') or bar_close or 0)
except Exception:
order_price = trig
raw_amt = order.get('amount')
pos_ratio = default_ratio
if raw_amt is not None:
try:
v = float(raw_amt)
if v > 0:
pos_ratio = v
except Exception:
pass
if action == 'close':
if ctx.position > 0:
out.append({'type': 'close_long', 'trigger_price': order_price or trig, 'position_size': 0, 'timestamp': ts_i})
ctx.position.clear_position()
elif ctx.position < 0:
out.append({'type': 'close_short', 'trigger_price': order_price or trig, 'position_size': 0, 'timestamp': ts_i})
ctx.position.clear_position()
continue
if action == 'buy':
if ctx.position < 0:
out.append({'type': 'close_short', 'trigger_price': order_price or trig, 'position_size': 0, 'timestamp': ts_i})
ctx.position.clear_position()
if td in ('long', 'both'):
if ctx.position == 0:
out.append({'type': 'open_long', 'trigger_price': order_price or trig, 'position_size': pos_ratio, 'timestamp': ts_i})
ctx.position.open_position('long', order_price or trig, pos_ratio)
else:
out.append({'type': 'add_long', 'trigger_price': order_price or trig, 'position_size': pos_ratio, 'timestamp': ts_i})
ctx.position.add_position(order_price or trig, pos_ratio)
continue
if action == 'sell':
if ctx.position > 0:
out.append({'type': 'close_long', 'trigger_price': order_price or trig, 'position_size': 0, 'timestamp': ts_i})
ctx.position.clear_position()
if td in ('short', 'both'):
if ctx.position == 0:
out.append({'type': 'open_short', 'trigger_price': order_price or trig, 'position_size': pos_ratio, 'timestamp': ts_i})
ctx.position.open_position('short', order_price or trig, pos_ratio)
else:
out.append({'type': 'add_short', 'trigger_price': order_price or trig, 'position_size': pos_ratio, 'timestamp': ts_i})
ctx.position.add_position(order_price or trig, pos_ratio)
return out
def _script_evaluate_new_closed_bar(
self,
df: pd.DataFrame,
ctx: StrategyScriptContext,
on_bar,
trade_direction: str,
last_closed_ts: Optional[pd.Timestamp],
strategy_id: int,
symbol: str,
trading_config: Dict[str, Any],
) -> Tuple[List[Dict[str, Any]], Optional[pd.Timestamp]]:
if df is None or len(df) < 2:
return [], last_closed_ts
closed_ts = df.index[-2]
try:
if last_closed_ts is not None and closed_ts <= last_closed_ts:
return [], last_closed_ts
except Exception:
pass
df_exec = self._df_to_script_exec_df(df)
ctx._bars_df = df_exec
pos = len(df) - 2
ctx.current_index = int(pos)
row = df_exec.iloc[pos]
self._hydrate_script_ctx_from_positions(ctx, strategy_id, symbol)
ctx._orders = []
bar = ScriptBar(
open=float(row.get('open') or 0),
high=float(row.get('high') or 0),
low=float(row.get('low') or 0),
close=float(row.get('close') or 0),
volume=float(row.get('volume') or 0),
timestamp=row.get('time'),
)
try:
on_bar(ctx, bar)
except Exception as e:
logger.error(f"Strategy {strategy_id} script on_bar error: {e}")
logger.error(traceback.format_exc())
return [], last_closed_ts
bar_close = float(row.get('close') or 0)
pending = self._script_orders_to_execution_signals(ctx, trade_direction, bar_close, closed_ts, trading_config)
self._persist_script_runtime_state(strategy_id, closed_ts, ctx._params)
logger.info(f"Strategy {strategy_id} script closed bar {closed_ts} -> {len(pending)} signal(s)")
return pending, closed_ts
def _run_strategy_loop(self, strategy_id: int):
"""
@@ -483,13 +696,15 @@ class TradingExecutor:
logger.error(f"Strategy {strategy_id} not found")
return
if strategy['strategy_type'] != 'IndicatorStrategy':
logger.error(f"Strategy {strategy_id} has unsupported strategy_type for realtime execution: {strategy['strategy_type']}")
stype = strategy.get('strategy_type') or ''
if stype not in ('IndicatorStrategy', 'ScriptStrategy'):
logger.error(f"Strategy {strategy_id} has unsupported strategy_type for realtime execution: {stype}")
return
is_script = stype == 'ScriptStrategy'
# 初始化策略状态
trading_config = strategy['trading_config']
indicator_config = strategy['indicator_config']
indicator_config = strategy.get('indicator_config') or {}
ai_model_config = strategy.get('ai_model_config') or {}
execution_mode = (strategy.get('execution_mode') or 'signal').strip().lower()
if execution_mode not in ['signal', 'live']:
@@ -545,68 +760,84 @@ class TradingExecutor:
market_category = (strategy.get('market_category') or 'Crypto').strip()
logger.info(f"Strategy {strategy_id} market_category: {market_category}")
# Check if this is a cross-sectional strategy
cs_strategy_type = trading_config.get('cs_strategy_type', 'single')
if cs_strategy_type == 'cross_sectional':
# Run cross-sectional strategy loop
self._run_cross_sectional_strategy_loop(
strategy_id, strategy, trading_config, indicator_config,
ai_model_config, execution_mode, notification_config,
strategy_name, market_category, market_type, leverage,
initial_capital, indicator_code, indicator_id
)
return
# 初始化交易所连接（信号模式下无需真实连接）
exchange = None
# 安全获取 initial_capital
# 安全获取 initial_capital（横截面分支也需要）
try:
initial_capital_val = strategy.get('initial_capital', 1000)
if isinstance(initial_capital_val, (list, tuple)):
initial_capital_val = initial_capital_val[0] if initial_capital_val else 1000
initial_capital = float(initial_capital_val)
except:
except Exception:
logger.warning(f"Strategy {strategy_id} invalid initial_capital format, reset to 1000: {strategy.get('initial_capital')}")
initial_capital = 1000.0
# 净值会在首次更新持仓时自动计算和更新
# 获取指标代码
indicator_id = indicator_config.get('indicator_id')
indicator_code = indicator_config.get('indicator_code', '')
# 如果代码为空，尝试从数据库获取
if not indicator_code and indicator_id:
indicator_code = self._get_indicator_code_from_db(indicator_id)
if not indicator_code:
logger.error(f"Strategy {strategy_id} indicator_code is empty")
return
# 确保 indicator_code 是字符串（处理 JSON 转义问题）
if not isinstance(indicator_code, str):
indicator_code = str(indicator_code)
# 处理可能的 JSON 转义问题
if '\\n' in indicator_code and '\n' not in indicator_code:
indicator_id = None
indicator_code = ''
strategy_code = ''
on_init_script = None
on_bar_script = None
if is_script:
strategy_code = (strategy.get('strategy_code') or '').strip()
if not strategy_code:
logger.error(f"Strategy {strategy_id} strategy_code is empty")
return
if '\\n' in strategy_code and '\n' not in strategy_code:
try:
decoded = json.loads(f'"{strategy_code}"')
if isinstance(decoded, str):
strategy_code = decoded
except Exception:
strategy_code = (
strategy_code.replace('\\n', '\n').replace('\\t', '\t').replace('\\r', '\r')
.replace('\\"', '"').replace("\\'", "'").replace('\\\\', '\\')
)
try:
import json
decoded = json.loads(f'"{indicator_code}"')
if isinstance(decoded, str):
indicator_code = decoded
logger.info(f"Strategy {strategy_id} decoded escaped indicator_code")
on_init_script, on_bar_script = compile_strategy_script_handlers(strategy_code)
except Exception as e:
logger.warning(f"Strategy {strategy_id} JSON decode failed; falling back to manual unescape: {str(e)}")
indicator_code = (
indicator_code
.replace('\\n', '\n')
.replace('\\t', '\t')
.replace('\\r', '\r')
.replace('\\"', '"')
.replace("\\'", "'")
.replace('\\\\', '\\')
)
logger.error(f"Strategy {strategy_id} script compile failed: {e}")
logger.error(traceback.format_exc())
return
else:
indicator_config = strategy['indicator_config']
indicator_id = indicator_config.get('indicator_id')
indicator_code = indicator_config.get('indicator_code', '')
if not indicator_code and indicator_id:
indicator_code = self._get_indicator_code_from_db(indicator_id)
if not indicator_code:
logger.error(f"Strategy {strategy_id} indicator_code is empty")
return
if not isinstance(indicator_code, str):
indicator_code = str(indicator_code)
if '\\n' in indicator_code and '\n' not in indicator_code:
try:
decoded = json.loads(f'"{indicator_code}"')
if isinstance(decoded, str):
indicator_code = decoded
logger.info(f"Strategy {strategy_id} decoded escaped indicator_code")
except Exception as e:
logger.warning(f"Strategy {strategy_id} JSON decode failed; falling back to manual unescape: {str(e)}")
indicator_code = (
indicator_code.replace('\\n', '\n').replace('\\t', '\t').replace('\\r', '\r')
.replace('\\"', '"').replace("\\'", "'").replace('\\\\', '\\')
)
# Check if this is a cross-sectional strategy（仅指标策略支持）
cs_strategy_type = trading_config.get('cs_strategy_type', 'single')
if (not is_script) and cs_strategy_type == 'cross_sectional':
self._run_cross_sectional_strategy_loop(
strategy_id, strategy, trading_config, strategy['indicator_config'],
ai_model_config, execution_mode, notification_config,
strategy_name, market_category, market_type, leverage,
initial_capital, indicator_code, indicator_id
)
return
if is_script and cs_strategy_type == 'cross_sectional':
logger.error(f"Strategy {strategy_id} ScriptStrategy does not support cross_sectional mode")
return
# 初始化交易所连接（信号模式下无需真实连接）
exchange = None
# ============================================
# 初始化阶段：获取历史K线并计算指标
@@ -658,29 +889,47 @@ class TradingExecutor:
initial_position_count = 1 # 简化处理，假设是单笔持仓
initial_last_add_price = initial_avg_entry_price
# 关键诊断日志：确认指标是否拿到了持仓状态
logger.info(
f"策略 {strategy_id} 指标注入持仓状态: count={len(current_pos_list)}, "
f"策略 {strategy_id} 持仓快照: count={len(current_pos_list)}, "
f"position={initial_position}, entry_price={initial_avg_entry_price}, highest={initial_highest}"
)
# 执行指标代码，获取信号和触发价格
indicator_result = self._execute_indicator_with_prices(
indicator_code, df, trading_config,
initial_highest_price=initial_highest,
initial_position=initial_position,
initial_avg_entry_price=initial_avg_entry_price,
initial_position_count=initial_position_count,
initial_last_add_price=initial_last_add_price
)
if indicator_result is None:
logger.error(f"Strategy {strategy_id} indicator execution failed")
return
# 提取信号和触发价格
pending_signals = indicator_result.get('pending_signals', []) # 待触发的信号列表
last_kline_time = indicator_result.get('last_kline_time', 0) # 最后一根K线的时间
script_ctx = None
last_script_closed_ts = None
if is_script:
script_ctx, last_script_closed_ts = self._init_script_strategy_context(
strategy_id, df, trading_config, initial_capital
)
if on_init_script:
self._hydrate_script_ctx_from_positions(script_ctx, strategy_id, symbol)
try:
on_init_script(script_ctx)
except Exception as e:
logger.error(f"Strategy {strategy_id} on_init error: {e}")
logger.error(traceback.format_exc())
pending_signals, last_script_closed_ts = self._script_evaluate_new_closed_bar(
df, script_ctx, on_bar_script, trade_direction,
last_script_closed_ts, strategy_id, symbol, trading_config,
)
try:
last_kline_time = int(df.index[-1].timestamp())
except Exception:
last_kline_time = int(time.time())
else:
indicator_result = self._execute_indicator_with_prices(
indicator_code, df, trading_config,
initial_highest_price=initial_highest,
initial_position=initial_position,
initial_avg_entry_price=initial_avg_entry_price,
initial_position_count=initial_position_count,
initial_last_add_price=initial_last_add_price
)
if indicator_result is None:
logger.error(f"Strategy {strategy_id} indicator execution failed")
return
pending_signals = indicator_result.get('pending_signals', [])
last_kline_time = indicator_result.get('last_kline_time', 0)
logger.info(f"Strategy {strategy_id} initialized; pending_signals={len(pending_signals)}")
if pending_signals:
logger.info(f"Initial signals: {pending_signals}")
@@ -744,52 +993,63 @@ class TradingExecutor:
if klines and len(klines) >= 2:
df = self._klines_to_dataframe(klines)
if len(df) > 0:
current_pos_list = self._get_current_positions(strategy_id, symbol)
initial_highest = 0.0
initial_position = 0
initial_avg_entry_price = 0.0
initial_position_count = 0
initial_last_add_price = 0.0
if current_pos_list:
pos = current_pos_list[0]
initial_highest = float(pos.get('highest_price', 0) or 0)
pos_side = pos.get('side', 'long')
initial_position = 1 if pos_side == 'long' else -1
initial_avg_entry_price = float(pos.get('entry_price', 0) or 0)
initial_position_count = 1
initial_last_add_price = initial_avg_entry_price
indicator_result = self._execute_indicator_with_prices(
indicator_code, df, trading_config,
initial_highest_price=initial_highest,
initial_position=initial_position,
initial_avg_entry_price=initial_avg_entry_price,
initial_position_count=initial_position_count,
initial_last_add_price=initial_last_add_price
)
if indicator_result:
pending_signals = indicator_result.get('pending_signals', [])
last_kline_time = indicator_result.get('last_kline_time', 0)
new_hp = indicator_result.get('new_highest_price', 0)
if is_script:
new_sig, last_script_closed_ts = self._script_evaluate_new_closed_bar(
df, script_ctx, on_bar_script, trade_direction,
last_script_closed_ts, strategy_id, symbol, trading_config,
)
pending_signals = new_sig
try:
last_kline_time = int(df.index[-1].timestamp())
except Exception:
last_kline_time = int(time.time())
last_kline_update_time = current_time
else:
current_pos_list = self._get_current_positions(strategy_id, symbol)
initial_highest = 0.0
initial_position = 0
initial_avg_entry_price = 0.0
initial_position_count = 0
initial_last_add_price = 0.0
# 更新 highest_price（使用最新 close 作为 current_price 的近似）
if new_hp > 0 and current_pos_list:
current_close = float(df['close'].iloc[-1])
for p in current_pos_list:
self._update_position(
strategy_id, p['symbol'], p['side'],
float(p['size']), float(p['entry_price']),
current_close,
highest_price=new_hp
)
if current_pos_list:
pos = current_pos_list[0]
initial_highest = float(pos.get('highest_price', 0) or 0)
pos_side = pos.get('side', 'long')
initial_position = 1 if pos_side == 'long' else -1
initial_avg_entry_price = float(pos.get('entry_price', 0) or 0)
initial_position_count = 1
initial_last_add_price = initial_avg_entry_price
indicator_result = self._execute_indicator_with_prices(
indicator_code, df, trading_config,
initial_highest_price=initial_highest,
initial_position=initial_position,
initial_avg_entry_price=initial_avg_entry_price,
initial_position_count=initial_position_count,
initial_last_add_price=initial_last_add_price
)
if indicator_result:
pending_signals = indicator_result.get('pending_signals', [])
last_kline_time = indicator_result.get('last_kline_time', 0)
new_hp = indicator_result.get('new_highest_price', 0)
last_kline_update_time = current_time
if new_hp > 0 and current_pos_list:
current_close = float(df['close'].iloc[-1])
for p in current_pos_list:
self._update_position(
strategy_id, p['symbol'], p['side'],
float(p['size']), float(p['entry_price']),
current_close,
highest_price=new_hp
)
else:
# ============================================
# 3. 非K线更新tick：用当前价更新最后一根K线并重算指标（统一tick节奏）
# 3. 非K线更新 tick：脚本策略不在这里重算（仅在新 K 收盘时 on_bar）
# ============================================
if 'df' in locals() and df is not None and len(df) > 0:
if (not is_script) and 'df' in locals() and df is not None and len(df) > 0:
try:
realtime_df = df.copy()
realtime_df = self._update_dataframe_with_current_price(realtime_df, current_price, timeframe)
@@ -1055,7 +1315,7 @@ class TradingExecutor:
initial_capital, leverage, decide_interval,
execution_mode, notification_config,
indicator_config, exchange_config, trading_config, ai_model_config,
market_category
market_category, strategy_code
FROM qd_strategies_trading
WHERE id = %s
"""
@@ -1144,8 +1404,14 @@ class TradingExecutor:
market_type: str = None,
leverage: float = None,
strategy_id: int = None
) -> Optional[ccxt.Exchange]:
"""(Mock) 信号模式不需要真实交易所连接"""
) -> Any:
"""
占位：策略线程内不创建交易所 SDK 实例。
实盘下单不经过本方法。信号经 _execute_exchange_order 写入 pending_orders，
由 PendingOrderWorker 使用 app.services.live_trading 下的直连 REST 客户端执行。
K 线/现价由 KlineService、DataSourceFactory 等数据层提供（该层可能使用 ccxt 拉行情，与下单解耦）。
"""
return None
def _fetch_latest_kline(self, symbol: str, timeframe: str, limit: int = 500, market_category: str = 'Crypto') -> List[Dict[str, Any]]:
@@ -2434,14 +2700,13 @@ class TradingExecutor:
signal_ts: int = 0,
) -> Optional[Dict[str, Any]]:
"""
Convert a signal into a concrete pending order and enqueue it into DB.
将信号转为 pending_orders 队列记录（本方法不直连交易所、不使用 ccxt）。
A separate worker will poll `pending_orders` and dispatch:
- execution_mode='signal': dispatch notifications (no real trading).
- execution_mode='live': reserved for future live trading execution (not implemented).
PendingOrderWorker 轮询执行：
- execution_mode='signal'：仅通知/模拟路径。
- execution_mode='live'：通过 live_trading 包内的各交易所 REST 客户端下单（非 ccxt）。
Note: Order execution settings (order_mode, maker_wait_sec, maker_offset_bps) are now
configured via environment variables and not passed from strategy config.
行情/K 线不在此处拉取；order_mode 等由环境变量配置。
"""
try:
# Reference price at enqueue time: use current tick price if provided to avoid extra fetch.