Upload 3 files

插件_交易/撮合模拟器.py

@@ -0,0 +1,209 @@
+# -*- coding: utf-8 -*-
+from __future__ import annotations
+from enum import Enum
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional, Tuple
+from datetime import datetime
+import time
+
+class 订单类型(Enum):
+    市价 = "MARKET"
+    限价 = "LIMIT"
+    止损市价 = "STOP_MARKET"
+    止损限价 = "STOP_LIMIT"
+
+class 订单状态(Enum):
+    待触发 = "PENDING"
+    部分成交 = "PARTIAL"
+    完全成交 = "FILLED"
+    已取消 = "CANCELLED"
+
+@dataclass
+class 订单:
+    订单ID: str
+    合约: str
+    方向: str          # 'BUY'/'SELL'
+    类型: 订单类型
+    数量: float
+    价格: Optional[float] = None      # 限价
+    触发价: Optional[float] = None    # 止损触发
+    仅减仓: bool = False
+    仅挂单: bool = False             # Post-Only
+    状态: 订单状态 = 订单状态.待触发
+    已成交量: float = 0.0
+    成交均价: float = 0.0
+    创建时间: int = field(default_factory=lambda: int(time.time()*1000))
+    更新时间: int = field(default_factory=lambda: int(time.time()*1000))
+    备注: str = ""
+
+@dataclass
+class 持仓:
+    合约: str
+    方向: str          # 'LONG'/'SHORT'
+    数量: float
+    均价: float
+    浮盈: float = 0.0
+    已实现盈亏: float = 0.0
+    最高价: Optional[float] = None    # 持仓期间最高
+    最低价: Optional[float] = None    # 持仓期间最低
+
+class 纸上交易所:
+    """
+    模拟撮合引擎：
+    - 支持 MARKET/LIMIT/STOP_MARKET/STOP_LIMIT
+    - 支持 ReduceOnly/PostOnly
+    - 支持追踪止损/保本止损（通过策略层动态修改订单）
+    """
+    def __init__(self, 初始资金: float = 10000.0, 手续费率: float = 0.0005, 滑点: float = 0.0003):
+        self.资金 = 初始资金
+        self.手续费率 = 手续费率
+        self.滑点 = 滑点
+        self.持仓: Dict[str, 持仓] = {}
+        self.订单: Dict[str, 订单] = {}
+        self.历史订单: List[订单] = []
+        self.净值 = 1.0
+        self.峰值 = 1.0
+        self.回撤 = 0.0
+        self._订单计数 = 0
+
+    def 下单(self, 合约: str, 方向: str, 类型: 订单类型, 数量: float,
+           价格: Optional[float] = None, 触发价: Optional[float] = None,
+           仅减仓: bool = False, 仅挂单: bool = False, 备注: str = "") -> str:
+        self._订单计数 += 1
+        订单ID = f"SIM_{self._订单计数}_{int(time.time()*1000)}"
+        单 = 订单(订单ID, 合约, 方向, 类型, 数量, 价格, 触发价, 仅减仓, 仅挂单, 备注=备注)
+        self.订单[订单ID] = 单
+        return 订单ID
+
+    def 撤单(self, 订单ID: str) -> bool:
+        if 订单ID in self.订单:
+            单 = self.订单.pop(订单ID)
+            单.状态 = 订单状态.已取消
+            self.历史订单.append(单)
+            return True
+        return False
+
+    def 修改订单(self, 订单ID: str, 新价格: Optional[float] = None, 新触发价: Optional[float] = None) -> bool:
+        if 订单ID in self.订单:
+            单 = self.订单[订单ID]
+            if 新价格 is not None: 单.价格 = 新价格
+            if 新触发价 is not None: 单.触发价 = 新触发价
+            单.更新时间 = int(time.time()*1000)
+            return True
+        return False
+
+    def 喂价(self, 合约: str, 当前价: float, 最高: float, 最低: float):
+        """
+        核心撮合逻辑：根据当前价触发条件单、成交限价单
+        """
+        # 更新持仓浮盈与极值
+        if 合约 in self.持仓:
+            仓 = self.持仓[合约]
+            if 仓.方向 == 'LONG':
+                仓.浮盈 = (当前价 - 仓.均价) * 仓.数量
+            else:
+                仓.浮盈 = (仓.均价 - 当前价) * 仓.数量
+            仓.最高价 = max(仓.最高价 or 当前价, 最高)
+            仓.最低价 = min(仓.最低价 or 当前价, 最低)
+
+        # 遍历订单，触发/成交
+        待删 = []
+        for 订单ID, 单 in list(self.订单.items()):
+            if 单.合约 != 合约: continue
+
+            # STOP触发判断
+            if 单.类型 in (订单类型.止损市价, 订单类型.止损限价):
+                触发 = False
+                if 单.方向 == 'BUY' and 最高 >= 单.触发价: 触发 = True
+                if 单.方向 == 'SELL' and 最低 <= 单.触发价: 触发 = True
+                if not 触发: continue
+
+            # 执行成交
+            成交价 = 当前价
+            if 单.类型 == 订单类型.限价:
+                # 限价单：买单≤当前价，卖单≥当前价
+                if 单.方向 == 'BUY' and 单.价格 < 当前价: continue
+                if 单.方向 == 'SELL' and 单.价格 > 当前价: continue
+                成交价 = 单.价格 if not 单.仅挂单 else 单.价格  # PostOnly理论上以挂单价成交
+            elif 单.类型 in (订单类型.市价, 订单类型.止损市价):
+                # 市价：加滑点
+                if 单.方向 == 'BUY': 成交价 = 当前价 * (1 + self.滑点)
+                else: 成交价 = 当前价 * (1 - self.滑点)
+            elif 单.类型 == 订单类型.止损限价:
+                # 触发后按限价逻辑
+                if 单.方向 == 'BUY' and 单.价格 < 当前价: continue
+                if 单.方向 == 'SELL' and 单.价格 > 当前价: continue
+                成交价 = 单.价格
+
+            # 执行成交（简化：全部成交）
+            self._执行成交(单, 成交价, 单.数量)
+            待删.append(订单ID)
+
+        for 订单ID in 待删:
+            单 = self.订单.pop(订单ID)
+            self.历史订单.append(单)
+
+    def _执行成交(self, 单: 订单, 成交价: float, 成交量: float):
+        单.已成交量 = 成交量
+        单.成交均价 = 成交价
+        单.状态 = 订单状态.完全成交
+        单.更新时间 = int(time.time()*1000)
+
+        # 更新持仓
+        合约 = 单.合约
+        if 单.方向 == 'BUY':
+            # 开多或平空
+            if 合约 not in self.持仓 or self.持仓[合约].方向 == 'LONG':
+                # 开多/加多
+                if 合约 not in self.持仓:
+                    self.持仓[合约] = 持仓(合约, 'LONG', 成交量, 成交价)
+                else:
+                    仓 = self.持仓[合约]
+                    总价值 = 仓.均价 * 仓.数量 + 成交价 * 成交量
+                    仓.数量 += 成交量
+                    仓.均价 = 总价值 / 仓.数量
+            else:
+                # 平空
+                仓 = self.持仓[合约]
+                平仓量 = min(成交量, 仓.数量)
+                盈亏 = (仓.均价 - 成交价) * 平仓量
+                仓.已实现盈亏 += 盈亏
+                仓.数量 -= 平仓量
+                if 仓.数量 <= 0:
+                    del self.持仓[合约]
+        else:
+            # SELL：开空或平多
+            if 合约 not in self.持仓 or self.持仓[合约].方向 == 'SHORT':
+                # 开空/加空
+                if 合约 not in self.持仓:
+                    self.持仓[合约] = 持仓(合约, 'SHORT', 成交量, 成交价)
+                else:
+                    仓 = self.持仓[合约]
+                    总价值 = 仓.均价 * 仓.数量 + 成交价 * 成交量
+                    仓.数量 += 成交量
+                    仓.均价 = 总价值 / 仓.数量
+            else:
+                # 平多
+                仓 = self.持仓[合约]
+                平仓量 = min(成交量, 仓.数量)
+                盈亏 = (成交价 - 仓.均价) * 平仓量
+                仓.已实现盈亏 += 盈亏
+                仓.数量 -= 平仓量
+                if 仓.数量 <= 0:
+                    del self.持仓[合约]
+
+        # 扣手续费（简化）
+        费用 = 成交价 * 成交量 * self.手续费率
+        self.资金 -= 费用
+
+    def 获取持仓(self, 合约: str) -> Optional[持仓]:
+        return self.持仓.get(合约)
+
+    def 计算净值(self) -> float:
+        总权益 = self.资金
+        for 仓 in self.持仓.values():
+            总权益 += 仓.浮盈
+        self.净值 = 总权益 / 10000.0  # 假设初始1万
+        self.峰值 = max(self.峰值, self.净值)
+        self.回撤 = (self.峰值 - self.净值) / self.峰值 if self.峰值 > 0 else 0
+        return self.净值

插件_交易/策略_自适应.py

@@ -0,0 +1,191 @@
+# -*- coding: utf-8 -*-
+from typing import Dict, List, Any, Optional
+import numpy as np
+import pandas as pd
+from 策略基类 import 策略接口
+from 插件_行情.类型定义 import 蜡烛
+
+class 自适应策略(策略接口):
+    """
+    读取你的"最优参数_60分.json"等，实现V1/V2策略逻辑
+    """
+    def __init__(self, 名称: str, 参数: Dict[str, Any]):
+        super().__init__(名称, 参数)
+        self.版本 = 参数.get('ver', 'v1')
+        self.入场时间戳: Optional[int] = None
+        self.入场价: Optional[float] = None
+        self.入场后最高: Optional[float] = None
+        self.入场后最低: Optional[float] = None
+        self.入场后根数 = 0
+
+    def 收到K线收盘(self, K: 蜡烛, 历史: List[蜡烛]) -> List[Dict[str, Any]]:
+        """
+        基于上一根K线的特征，计算下一根的入场触发价/止损价
+        与你回测逻辑对齐：prev = 上一根，k = 当前根
+        """
+        if len(历史) < 50:  # 需要足够历史计算指标
+            return []
+
+        # 转DataFrame计算指标（与你回测一致）
+        df = self._K列表转DF(历史 + [K])
+        特征 = self._计算特征(df)
+        if len(特征) < 2:
+            return []
+
+        prev = 特征.iloc[-2]  # 上一根（已收盘）
+        订单 = []
+
+        # 持仓管理
+        if self.持仓方向:
+            self.入场后根数 += 1
+            # 更新极值（用于追踪止损）
+            if self.持仓方向 == 'LONG' and K.高 > (self.入场后最高 or 0):
+                self.入场后最高 = K.高
+            elif self.持仓方向 == 'SHORT' and K.低 < (self.入场后最低 or float('inf')):
+                self.入场后最低 = K.低
+
+            # 生成出场订单
+            出场单 = self._生成出场订单(prev, K)
+            if 出场单:
+                订单.extend(出场单)
+        else:
+            # 生成入场订单
+            入场单 = self._生成入场订单(prev)
+            if 入场单:
+                订单.extend(入场单)
+
+        return 订单
+
+    def _K列表转DF(self, K列表: List[蜡烛]) -> pd.DataFrame:
+        data = []
+        for k in K列表:
+            data.append({
+                '时间': pd.Timestamp(k.时间戳, unit='ms'),
+                '开': k.开, '高': k.高, '低': k.低, '收': k.收, '量': k.量
+            })
+        return pd.DataFrame(data).set_index('时间')
+
+    def _计算特征(self, df: pd.DataFrame) -> pd.DataFrame:
+        """简化版特征计算（你可以复制完整版）"""
+        p = self.参数
+        # ADX（简化）
+        df['ADX'] = 25.0  # 占位，实际要算
+        df['PDI'] = 30.0
+        df['MDI'] = 20.0
+        df['ATR'] = df['高'].rolling(14).mean() - df['低'].rolling(14).mean()
+
+        # 布林带
+        w = 20
+        df['BB_MID'] = df['收'].rolling(w).mean()
+        std = df['收'].rolling(w).std()
+        df['BB_UP'] = df['BB_MID'] + 2*std
+        df['BB_LO'] = df['BB_MID'] - 2*std
+        df['BB_WIDTH'] = (df['BB_UP'] - df['BB_LO']) / df['BB_MID']
+
+        # 突破通道
+        df['BRK_H'] = df['高'].rolling(20).max().shift(1)
+        df['BRK_L'] = df['低'].rolling(20).min().shift(1)
+        df['EX_H'] = df['高'].rolling(10).max().shift(1)
+        df['EX_L'] = df['低'].rolling(10).min().shift(1)
+
+        # RSI
+        delta = df['收'].diff()
+        up = delta.where(delta > 0, 0)
+        dn = -delta.where(delta < 0, 0)
+        rs = up.rolling(14).mean() / dn.rolling(14).mean()
+        df['RSI'] = 100 - (100/(1+rs))
+
+        return df.dropna()
+
+    def _生成入场订单(self, prev) -> List[Dict[str, Any]]:
+        p = self.参数
+        订单 = []
+
+        if self.版本 == 'v1':
+            # V1逻辑
+            adx_thr = p.get('adx_thr', 25)
+            in_trend = prev['ADX'] >= adx_thr
+
+            if in_trend:
+                atr_buf = p.get('atr_buf_tr', 0.1)
+                if prev['PDI'] >= prev['MDI']:
+                    # 趋势做多
+                    订单.append({
+                        '动作': '开多',
+                        '类型': '止损市价',
+                        '触发价': prev['BRK_H'] + atr_buf * prev['ATR'],
+                        '止损价': prev['EX_L'],
+                        '数量': 1.0
+                    })
+                else:
+                    # 趋势做空
+                    订单.append({
+                        '动作': '开空',
+                        '类型': '止损市价',
+                        '触发价': prev['BRK_L'] - atr_buf * prev['ATR'],
+                        '止损价': prev['EX_H'],
+                        '数量': 1.0
+                    })
+            else:
+                # 震荡
+                rsi_low = p.get('rsi_low', 30)
+                rsi_high = p.get('rsi_high', 70)
+                mr_stop_atr = p.get('mr_stop_atr', 2.0)
+
+                if prev['RSI'] <= rsi_low:
+                    订单.append({
+                        '动作': '开多',
+                        '类型': '限价',
+                        '价格': prev['BB_LO'],
+                        '止损价': prev['BB_LO'] - mr_stop_atr * prev['ATR'],
+                        '数量': 1.0
+                    })
+                elif prev['RSI'] >= rsi_high:
+                    订单.append({
+                        '动作': '开空',
+                        '类型': '限价',
+                        '价格': prev['BB_UP'],
+                        '止损价': prev['BB_UP'] + mr_stop_atr * prev['ATR'],
+                        '数量': 1.0
+                    })
+
+        elif self.版本 == 'v2':
+            # V2逻辑（简化示例）
+            adx_thr = p.get('adx_thr', 25)
+            bb_width_thr = p.get('bb_width_thr', 0.02)
+            in_trend = (prev['ADX'] >= adx_thr and prev['BB_WIDTH'] >= bb_width_thr)
+
+            if in_trend:
+                atr_buf = p.get('atr_buf_tr', 0.1)
+                if prev['PDI'] >= prev['MDI']:
+                    订单.append({
+                        '动作': '开多',
+                        '类型': '止损市价',
+                        '触发价': prev['BRK_H'] + atr_buf * prev['ATR'],
+                        '止损价': prev['EX_L'],
+                        '数量': 1.0
+                    })
+
+        return 订单
+
+    def _生成出场订单(self, prev, K) -> List[Dict[str, Any]]:
+        p = self.参数
+        订单 = []
+
+        if self.版本 == 'v2':
+            # ATR追踪止损
+            if self.持仓方向 == 'LONG' and self.入场后最高:
+                atr_trail = p.get('atr_trail', 2.0)
+                trail_stop = self.入场后最高 - atr_trail * prev['ATR']
+                if K.低 <= trail_stop:
+                    订单.append({'动作': '平多', '类型': '市价'})
+
+            # 时间止盈（震荡）
+            mr_time_exit = p.get('mr_time_exit', 10)
+            if self.入场后根数 >= mr_time_exit:
+                if self.持仓方向 == 'LONG':
+                    订单.append({'动作': '平多', '类型': '市价'})
+                else:
+                    订单.append({'动作': '平空', '类型': '市价'})
+
+        return 订单

插件_交易/策略基类.py

@@ -0,0 +1,26 @@
+# -*- coding: utf-8 -*-
+from __future__ import annotations
+from abc import ABC, abstractmethod
+from typing import Dict, List, Optional, Any
+from ..插件_行情.类型定义 import 蜡烛
+
+class 策略接口(ABC):
+    def __init__(self, 名称: str, 参数: Dict[str, Any]):
+        self.名称 = 名称
+        self.参数 = 参数
+        self.持仓方向: Optional[str] = None  # 'LONG'/'SHORT'/None
+
+    @abstractmethod
+    def 收到K线收盘(self, K: 蜡烛, 历史: List[蜡烛]) -> List[Dict[str, Any]]:
+        """
+        输入：当前收盘的K线 + 历史K线列表
+        返回：订单意图列表
+        [
+          {'动作': '开多'/'开空'/'平多'/'平空'/'追踪止损'/'保本止损',
+           '价格': float, '触发价': float, '数量': float, ...}
+        ]
+        """
+        pass
+
+    def 重置(self):
+        self.持仓方向 = None