v4.0.7

Signed-off-by: TIANHE <[email protected]>

Author: tianhe

backend_api_python/app/services/backtest.py

@@ -2593,7 +2593,7 @@ def _execute_indicator(self, code: str, df: pd.DataFrame, backtest_params: dict
         # Supported indicator signal formats:
         # - Preferred (simple): df['buy'], df['sell'] as boolean
         # - Backtest/internal (4-way): df['open_long'], df['close_long'], df['open_short'], df['close_short'] as boolean
-        signals = pd.Series(0, index=df.index)
+        signals = {}
 
         try:
             # Reset DatetimeIndex to integer so user code can use df.at[0, ...] or df.iloc[0, ...]
@@ -2717,6 +2717,7 @@ def _execute_indicator(self, code: str, df: pd.DataFrame, backtest_params: dict
         except Exception as e:
             logger.error(f"Indicator code execution error: {e}")
             logger.error(traceback.format_exc())
+            raise
 
         return signals
 

backend_api_python/app/services/live_trading/binance.py

@@ -475,7 +475,7 @@ def get_fee_for_order(self, *, symbol: str, order_id: str, max_retries: int = 3)
         return 0.0, ""
 
     def get_fee_rate(self, symbol: str, market_type: str = "swap") -> Optional[Dict[str, float]]:
-        sym = symbol.upper().replace("-", "").replace("/", "")
+        sym = to_binance_futures_symbol(symbol)
         try:
             data = self._signed_request("GET", "/fapi/v1/commissionRate", params={"symbol": sym})
             if isinstance(data, dict):
@@ -484,7 +484,7 @@ def get_fee_rate(self, symbol: str, market_type: str = "swap") -> Optional[Dict[
                 if maker > 0 or taker > 0:
                     return {"maker": maker, "taker": taker}
         except Exception as e:
-            logger.warning(f"Binance get_fee_rate({symbol}) failed: {e}")
+            logger.warning(f"Binance get_fee_rate({symbol}, symbol_param={sym}) failed: {e}")
         return None
 
     def set_leverage(self, *, symbol: str, leverage: float) -> Dict[str, Any]:

backend_api_python/app/services/live_trading/binance_spot.py

@@ -685,7 +685,7 @@ def get_fee_for_order(self, *, symbol: str, order_id: str, max_retries: int = 3)
         return 0.0, ""
 
     def get_fee_rate(self, symbol: str, market_type: str = "spot") -> Optional[Dict[str, float]]:
-        sym = symbol.upper().replace("-", "").replace("/", "")
+        sym = to_binance_futures_symbol(symbol)
         try:
             data = self._signed_request("GET", "/sapi/v1/asset/tradeFee", params={"symbol": sym})
             if isinstance(data, list) and data and isinstance(data[0], dict):
@@ -695,7 +695,7 @@ def get_fee_rate(self, symbol: str, market_type: str = "spot") -> Optional[Dict[
                 if maker > 0 or taker > 0:
                     return {"maker": maker, "taker": taker}
         except Exception as e:
-            logger.warning(f"BinanceSpot get_fee_rate({symbol}) failed: {e}")
+            logger.warning(f"BinanceSpot get_fee_rate({symbol}, symbol_param={sym}) failed: {e}")
         return None
 
     def cancel_order(self, *, symbol: str, order_id: str = "", client_order_id: str = "") -> Dict[str, Any]:

backend_api_python/app/services/live_trading/bitget.py

@@ -649,18 +649,21 @@ def get_positions(self, *, product_type: str = "USDT-FUTURES", symbol: str = "")
         return out
 
     def get_fee_rate(self, symbol: str, market_type: str = "swap") -> Optional[Dict[str, float]]:
-        sym = to_bitget_um_symbol(symbol) if market_type != "spot" else symbol.upper().replace("/", "")
-        product_type = "USDT-FUTURES" if market_type != "spot" else "SPOT"
+        mt = str(market_type or "swap").strip().lower()
+        if mt in ("futures", "future", "perp", "perpetual"):
+            mt = "swap"
+        sym = to_bitget_um_symbol(symbol)
+        business_type = "spot" if mt == "spot" else "mix"
         try:
-            raw = self._signed_request("GET", "/api/v2/common/trade-rate", params={"symbol": sym, "businessType": product_type})
+            raw = self._signed_request("GET", "/api/v2/common/trade-rate", params={"symbol": sym, "businessType": business_type})
             data = raw.get("data") if isinstance(raw, dict) else None
             if isinstance(data, dict):
                 maker = abs(float(data.get("makerFeeRate") or 0))
                 taker = abs(float(data.get("takerFeeRate") or 0))
                 if maker > 0 or taker > 0:
                     return {"maker": maker, "taker": taker}
         except Exception as e:
-            logger.warning(f"Bitget get_fee_rate({symbol}) failed: {e}")
+            logger.warning(f"Bitget get_fee_rate({symbol}, businessType={business_type}, symbol_param={sym}) failed: {e}")
         return None
 
     def set_leverage(

backend_api_python/app/services/live_trading/bitget_spot.py

@@ -263,6 +263,24 @@ def _public_request(self, method: str, path: str, *, params: Optional[Dict[str,
                 raise LiveTradingError(f"BitgetSpot error: {data}")
         return data if isinstance(data, dict) else {"raw": data}
 
+    def get_fee_rate(self, symbol: str, market_type: str = "spot") -> Optional[Dict[str, float]]:
+        sym = to_bitget_um_symbol(symbol)
+        try:
+            raw = self._signed_request(
+                "GET",
+                "/api/v2/common/trade-rate",
+                params={"symbol": sym, "businessType": "spot"},
+            )
+            data = raw.get("data") if isinstance(raw, dict) else None
+            if isinstance(data, dict):
+                maker = abs(float(data.get("makerFeeRate") or 0))
+                taker = abs(float(data.get("takerFeeRate") or 0))
+                if maker > 0 or taker > 0:
+                    return {"maker": maker, "taker": taker}
+        except Exception as e:
+            logger.warning(f"BitgetSpot get_fee_rate({symbol}, businessType=spot, symbol_param={sym}) failed: {e}")
+        return None
+
     def get_symbol_meta(self, *, symbol: str) -> Dict[str, Any]:
         """
         Fetch spot symbol metadata (best-effort).

backend_api_python/app/services/live_trading/okx.py

@@ -426,8 +426,11 @@ def get_balance(self) -> Dict[str, Any]:
         return self._signed_request("GET", "/api/v5/account/balance")
 
     def get_fee_rate(self, symbol: str, market_type: str = "swap") -> Optional[Dict[str, float]]:
-        inst_type = "SPOT" if market_type == "spot" else "SWAP"
-        inst_id = symbol.upper()
+        mt = str(market_type or "swap").strip().lower()
+        if mt in ("futures", "future", "perp", "perpetual"):
+            mt = "swap"
+        inst_type = "SPOT" if mt == "spot" else "SWAP"
+        inst_id = to_okx_spot_inst_id(symbol) if mt == "spot" else to_okx_swap_inst_id(symbol)
         try:
             raw = self._signed_request("GET", "/api/v5/account/trade-fee", params={"instType": inst_type, "instId": inst_id})
             data = (raw.get("data") or []) if isinstance(raw, dict) else []
@@ -438,7 +441,7 @@ def get_fee_rate(self, symbol: str, market_type: str = "swap") -> Optional[Dict[
                 if maker > 0 or taker > 0:
                     return {"maker": maker, "taker": taker}
         except Exception as e:
-            logger.warning(f"OKX get_fee_rate({symbol}) failed: {e}")
+            logger.warning(f"OKX get_fee_rate({symbol}, market_type={mt}, inst_id={inst_id}) failed: {e}")
         return None
 
     def get_positions(self, *, inst_id: str = "", inst_type: str = "SWAP") -> Dict[str, Any]:

backend_api_python/app/services/trading_executor.py

@@ -1957,7 +1957,7 @@ def _is_fatal_error(err: Exception, msg: str) -> bool:
             self._log_crypto_kline_source(
                 strategy_id, market_category, execution_mode, kline_exchange_id, kline_market_type
             )
-            if exchange_config and exchange_config.get('api_key') or exchange_config.get('apiKey'):
+            if exchange_config and (exchange_config.get('api_key') or exchange_config.get('apiKey')):
                 try:
                     self._query_exchange_fee_rate(strategy_id, exchange_config, symbol, market_type)
                 except Exception as e:

backend_api_python/tests/test_backtest_four_way_signals.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import pandas as pd
+import pytest
 
 from app.services.backtest import BacktestService
 from app.services.builtin_indicators import _builtin_specs
@@ -65,3 +66,14 @@ def test_builtin_indicator_sample_executes_with_four_way_contract():
     for col in ("open_long", "close_long", "open_short", "close_short"):
         assert col in out
         assert len(out[col]) == len(df)
+
+
+def test_execute_indicator_missing_signal_columns_raises_clear_error():
+    svc = BacktestService()
+    df = _sample_df()
+    code = """
+df = df.copy()
+df['some_plot_only_value'] = close.rolling(3).mean()
+"""
+    with pytest.raises(ValueError, match="Indicator must define either 4-way columns"):
+        svc._execute_indicator(code, df, backtest_params={})

backend_api_python/tests/test_exchange_fee_rate_params.py

@@ -0,0 +1,125 @@
+from __future__ import annotations
+
+from app.services.live_trading.binance import BinanceFuturesClient
+from app.services.live_trading.binance_spot import BinanceSpotClient
+from app.services.live_trading.bitget import BitgetMixClient
+from app.services.live_trading.bitget_spot import BitgetSpotClient
+from app.services.live_trading.bybit import BybitClient
+from app.services.live_trading.gate import GateSpotClient, GateUsdtFuturesClient
+from app.services.live_trading.okx import OkxClient
+
+
+def _fake_client(cls, response):
+    client = object.__new__(cls)
+    client.seen = []
+
+    def fake_signed_request(method, path, params=None, **kwargs):
+        client.seen.append({"method": method, "path": path, "params": dict(params or {})})
+        return response
+
+    client._signed_request = fake_signed_request
+    return client
+
+
+def test_binance_futures_fee_rate_uses_concatenated_symbol():
+    client = _fake_client(
+        BinanceFuturesClient,
+        {"makerCommissionRate": "0.0002", "takerCommissionRate": "0.0005"},
+    )
+
+    result = client.get_fee_rate("BTC/USDT:USDT")
+
+    assert result == {"maker": 0.0002, "taker": 0.0005}
+    assert client.seen[-1]["path"] == "/fapi/v1/commissionRate"
+    assert client.seen[-1]["params"] == {"symbol": "BTCUSDT"}
+
+
+def test_binance_spot_fee_rate_uses_concatenated_symbol():
+    client = _fake_client(
+        BinanceSpotClient,
+        [{"makerCommission": "0.001", "takerCommission": "0.001"}],
+    )
+
+    result = client.get_fee_rate("ETH/USDT:USDT")
+
+    assert result == {"maker": 0.001, "taker": 0.001}
+    assert client.seen[-1]["path"] == "/sapi/v1/asset/tradeFee"
+    assert client.seen[-1]["params"] == {"symbol": "ETHUSDT"}
+
+
+def test_bitget_mix_fee_rate_uses_official_business_type_mix():
+    client = _fake_client(
+        BitgetMixClient,
+        {"data": {"makerFeeRate": "0.0002", "takerFeeRate": "0.0006"}},
+    )
+
+    result = client.get_fee_rate("SOL/USDT:USDT", market_type="swap")
+
+    assert result == {"maker": 0.0002, "taker": 0.0006}
+    assert client.seen[-1]["path"] == "/api/v2/common/trade-rate"
+    assert client.seen[-1]["params"] == {"symbol": "SOLUSDT", "businessType": "mix"}
+
+
+def test_bitget_spot_fee_rate_uses_official_business_type_spot():
+    client = _fake_client(
+        BitgetSpotClient,
+        {"data": {"makerFeeRate": "0.001", "takerFeeRate": "0.001"}},
+    )
+
+    result = client.get_fee_rate("SOL/USDT:USDT", market_type="spot")
+
+    assert result == {"maker": 0.001, "taker": 0.001}
+    assert client.seen[-1]["path"] == "/api/v2/common/trade-rate"
+    assert client.seen[-1]["params"] == {"symbol": "SOLUSDT", "businessType": "spot"}
+
+
+def test_bybit_fee_rate_uses_category_and_concatenated_symbol():
+    client = _fake_client(
+        BybitClient,
+        {"result": {"list": [{"makerFeeRate": "0.0001", "takerFeeRate": "0.00055"}]}},
+    )
+
+    result = client.get_fee_rate("BTC/USDT:USDT", market_type="swap")
+
+    assert result == {"maker": 0.0001, "taker": 0.00055}
+    assert client.seen[-1]["path"] == "/v5/account/fee-rate"
+    assert client.seen[-1]["params"] == {"category": "linear", "symbol": "BTCUSDT"}
+
+
+def test_gate_spot_fee_rate_uses_currency_pair():
+    client = _fake_client(
+        GateSpotClient,
+        {"maker_fee_rate": "0.001", "taker_fee_rate": "0.001"},
+    )
+
+    result = client.get_fee_rate("BTC/USDT:USDT", market_type="spot")
+
+    assert result == {"maker": 0.001, "taker": 0.001}
+    assert client.seen[-1]["path"] == "/api/v4/wallet/fee"
+    assert client.seen[-1]["params"] == {"currency_pair": "BTC_USDT"}
+
+
+def test_gate_futures_fee_rate_uses_contract_path():
+    client = _fake_client(
+        GateUsdtFuturesClient,
+        {"maker_fee_rate": "0.0002", "taker_fee_rate": "0.0005"},
+    )
+
+    result = client.get_fee_rate("BTC/USDT:USDT", market_type="swap")
+
+    assert result == {"maker": 0.0002, "taker": 0.0005}
+    assert client.seen[-1]["path"] == "/api/v4/futures/usdt/contracts/BTC_USDT"
+    assert client.seen[-1]["params"] == {}
+
+
+def test_okx_fee_rate_uses_inst_type_and_inst_id():
+    client = _fake_client(
+        OkxClient,
+        {"data": [{"maker": "-0.0002", "taker": "-0.0005"}]},
+    )
+
+    result = client.get_fee_rate("SOL/USDT:USDT", market_type="swap")
+
+    assert result == {"maker": 0.0002, "taker": 0.0005}
+    assert client.seen[-1]["path"] == "/api/v5/account/trade-fee"
+    assert client.seen[-1]["params"] == {"instType": "SWAP", "instId": "SOL-USDT-SWAP"}

backend_api_python/tests/test_okx_fee_rate.py

@@ -0,0 +1,33 @@
+from __future__ import annotations
+
+from app.services.live_trading.okx import OkxClient
+
+
+def _fake_okx_client() -> OkxClient:
+    client = object.__new__(OkxClient)
+    client.seen_params = []
+
+    def fake_signed_request(method, path, params=None, body=None):
+        client.seen_params.append({"method": method, "path": path, "params": dict(params or {})})
+        return {"data": [{"maker": "-0.0002", "taker": "-0.0005"}]}
+
+    client._signed_request = fake_signed_request
+    return client
+
+
+def test_okx_fee_rate_uses_swap_inst_id():
+    client = _fake_okx_client()
+
+    result = client.get_fee_rate("SOL/USDT", market_type="swap")
+
+    assert result == {"maker": 0.0002, "taker": 0.0005}
+    assert client.seen_params[-1]["params"] == {"instType": "SWAP", "instId": "SOL-USDT-SWAP"}
+
+
+def test_okx_fee_rate_uses_spot_inst_id():
+    client = _fake_okx_client()
+
+    result = client.get_fee_rate("SOL/USDT", market_type="spot")
+
+    assert result == {"maker": 0.0002, "taker": 0.0005}
+    assert client.seen_params[-1]["params"] == {"instType": "SPOT", "instId": "SOL-USDT"}