v3.0.1

Signed-off-by: Dinger <quantdinger@gmail.com>

Author: quantdinger-lab

backend_api_python/app/routes/quick_trade.py

@@ -4,6 +4,7 @@
 from flask import Blueprint, request, jsonify, g
 from datetime import datetime
 import json
+import re
 import traceback
 import time
 
@@ -770,15 +771,16 @@ def start_strategy():
 
         # Get strategy type
         strategy_type = get_strategy_service().get_strategy_type(strategy_id)
-        
-        # Update strategy status
-        get_strategy_service().update_strategy_status(strategy_id, 'running', user_id=user_id)
-        
-        # Local backend: AI strategy executor was removed. Only indicator strategies are supported.
+
+        # IndicatorStrategy and ScriptStrategy are executed by TradingExecutor.
         if strategy_type == 'PromptBasedStrategy':
-            return jsonify({'code': 0, 'msg': 'AI strategy has been removed; local edition does not support starting AI strategies', 'data': None}), 400
+            return jsonify({
+                'code': 0,
+                'msg': 'AI strategy has been removed; local edition does not support starting AI strategies',
+                'data': None
+            }), 400
+        get_strategy_service().update_strategy_status(strategy_id, 'running', user_id=user_id)
 
-        # Indicator strategy
         success = get_trading_executor().start_strategy(strategy_id)
 
         if not success:
@@ -1241,12 +1243,65 @@ def verify_strategy_code():
 @strategy_bp.route('/strategies/ai-generate', methods=['POST'])
 @login_required
 def ai_generate_strategy():
-    """Generate strategy code using AI."""
+    """Generate strategy code or suggest template parameter updates using AI."""
     try:
         payload = request.get_json() or {}
         prompt = payload.get('prompt', '')
         if not prompt.strip():
-            return jsonify({'code': '', 'msg': 'Prompt is empty'})
+            return jsonify({'code': '', 'msg': 'Prompt is empty', 'params': None})
+
+        intent = (payload.get('intent') or 'generate_code').strip()
+        from app.services.llm import LLMService
+        llm = LLMService()
+        api_key = llm.get_api_key()
+        if not api_key:
+            return jsonify({'code': '', 'msg': 'No LLM API key configured', 'params': None})
+
+        if intent == 'adjust_params':
+            template_key = payload.get('template_key') or ''
+            current_params = payload.get('params') or {}
+            code_snapshot = (payload.get('code') or '')[:8000]
+            system_prompt = """You tune quantitative strategy template parameters from the user's request.
+Return ONLY a single JSON object: keys are parameter names (strings), values are JSON numbers or booleans.
+You may return a partial object (only keys that should change) or a full object.
+Do not use markdown fences, do not add explanations before or after the JSON."""
+
+            user_content = (
+                f"Template key: {template_key}\n"
+                f"Current parameters (JSON):\n{json.dumps(current_params, ensure_ascii=False)}\n\n"
+                f"Strategy code excerpt (context):\n{code_snapshot}\n\n"
+                f"User request:\n{prompt.strip()}\n\n"
+                "Respond with JSON only."
+            )
+
+            content = llm.call_llm_api(
+                messages=[
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": user_content},
+                ],
+                model=llm.get_code_generation_model(),
+                temperature=0.3,
+                use_json_mode=False
+            )
+
+            raw = (content or '').strip()
+            if raw.startswith('```'):
+                raw = re.sub(r'^```[a-zA-Z]*', '', raw).strip()
+                if raw.endswith('```'):
+                    raw = raw[:-3].strip()
+            updates = None
+            try:
+                updates = json.loads(raw)
+            except json.JSONDecodeError:
+                m = re.search(r'\{[\s\S]*\}', raw)
+                if m:
+                    try:
+                        updates = json.loads(m.group(0))
+                    except json.JSONDecodeError:
+                        updates = None
+            if not isinstance(updates, dict):
+                return jsonify({'code': '', 'params': None, 'msg': 'AI did not return valid JSON parameters'})
+            return jsonify({'code': '', 'params': updates, 'msg': 'success'})
 
         system_prompt = """You are a quantitative trading strategy code generator.
 Generate Python strategy code that follows this framework:
@@ -1264,16 +1319,26 @@ def ai_generate_strategy():
 
 Return ONLY the Python code, no explanations."""
 
-        from app.services.llm import LLMService
-        llm = LLMService()
-        api_key = llm.get_api_key()
-        if not api_key:
-            return jsonify({'code': '', 'msg': 'No LLM API key configured'})
+        extra = ''
+        template_key = payload.get('template_key')
+        params = payload.get('params')
+        code_ctx = (payload.get('code') or '').strip()
+        if template_key or params is not None or code_ctx:
+            extra_parts = []
+            if template_key:
+                extra_parts.append(f"Current template key: {template_key}")
+            if isinstance(params, dict) and params:
+                extra_parts.append('Current template parameters (JSON):\n' + json.dumps(params, ensure_ascii=False))
+            if code_ctx:
+                extra_parts.append('Current code (may be long):\n' + code_ctx[:12000])
+            extra = '\n\n' + '\n\n'.join(extra_parts)
+
+        user_prompt = prompt.strip() + extra
 
         content = llm.call_llm_api(
             messages=[
                 {"role": "system", "content": system_prompt},
-                {"role": "user", "content": prompt},
+                {"role": "user", "content": user_prompt},
             ],
             model=llm.get_code_generation_model(),
             temperature=0.7,
@@ -1290,12 +1355,12 @@ def ai_generate_strategy():
         content = content.strip()
 
         if content:
-            return jsonify({'code': content, 'msg': 'success'})
+            return jsonify({'code': content, 'msg': 'success', 'params': None})
         else:
-            return jsonify({'code': '', 'msg': 'AI generation returned empty result'})
+            return jsonify({'code': '', 'msg': 'AI generation returned empty result', 'params': None})
     except Exception as e:
         logger.error(f"ai_generate_strategy failed: {str(e)}")
-        return jsonify({'code': '', 'msg': str(e)})
+        return jsonify({'code': '', 'msg': str(e), 'params': None})
 
 
 @strategy_bp.route('/strategies/performance', methods=['GET'])

backend_api_python/app/routes/strategy.py

@@ -504,6 +504,12 @@ def run_multi_timeframe(
                     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 @@ def run_multi_timeframe(
                 '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 @@ def run_multi_timeframe(
             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 @@ def _run_script_strategy(
             '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 @@ def run(
         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 @@ def _calculate_sharpe(self, values: List[float], timeframe: str = '1D', risk_fre
             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/backtest.py

@@ -40,6 +40,10 @@ def __init__(self, *, api_key: str, secret_key: str, base_url: str = None, enabl
         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 @@ def _sign(self, query_string: str) -> str:
     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 @@ def _format_client_order_id(self, client_order_id: Optional[str]) -> str:
         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 @@ def cancel_order(self, *, symbol: str, order_id: str = "", client_order_id: str
             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]