update

core/eventbus.py

@@ -1,10 +1,7 @@
 
 # 市场数据监听控制事件
+EventMarketActiveSwitch = "market_active_switch"
 MarketDataUpdate = "market_data_update"
-ActionEnableMarketData = "enable_market_data"
-ActionDisableMarketData = "disable_market_data"
-MarketDataEnabled = "market_data_enabled"
-MarketDataDisabled = "market_data_disabled"
 MarketOrderCreated = "market_order_created"
 MarketOrderTraded = "market_order_traded"
 # Pring Log

core/qmt.py

@@ -1,4 +1,5 @@
 import datetime
+import threading
 import time
 import config
 from xtquant.xttype import StockAccount, XtOrder, XtOrderResponse, XtPosition, XtTrade
@@ -15,6 +16,11 @@ class QmtV(XtQuantTraderCallback):
         self.xttrader: XtQuantTrader
         self.inited: bool = False
         self.details = {}
+        self.lastMarketDataUpdateTimestamp = time.time()
+        self.isMarketActive = False
+        self.refresh_thread = threading.Thread(target=self.marketStatusNotifier, daemon=True)
+        self.refresh_thread.start()
+        # time.sleep(3.1)
 
     def getTrader(self) -> XtQuantTrader:
         return self.xttrader
@@ -94,48 +100,6 @@ class QmtV(XtQuantTraderCallback):
         return self.cacheStockDetail(stock_code)['UpStopPrice']
     def dailyDownStop(self, stock_code:str):
         return self.cacheStockDetail(stock_code)['DownStopPrice']
-
-    # def print_position_info(self):
-    #     positions:list[XtPosition] = self.xt_trader.query_stock_positions(self.account)
-    #     if positions:
-    #         PrintLog(LogLevel.INFO, "\n- 持仓信息")
-    #         for temp in positions:
-    #             pos : XtPosition = temp
-    #             if pos.volume <=0:
-    #                 continue
-    #             PrintLog(LogLevel.INFO, f"股票代码: {pos.stock_code}-{getInstrumentName(pos.stock_code)}")
-    #             PrintLog(LogLevel.INFO, f"总持仓: {pos.volume}")
-    #             PrintLog(LogLevel.INFO, f"可用持仓: {pos.can_use_volume}")
-    #             PrintLog(LogLevel.INFO, f"持仓成本: {pos.avg_price}")
-    #             PrintLog(LogLevel.INFO, "---")
-    #     else:
-    #         PrintLog(LogLevel.INFO, "\n当前无持仓")
-
-    # def print_account_info(self):
-    #     temp = self.xt_trader.query_stock_asset(self.account)
-    #     asset: XtAsset = temp # type: ignore
-        
-    #     PrintLog(LogLevel.INFO, f"=== 账户信息 {self.account.account_id} ===") # type: ignore
-    #     PrintLog(LogLevel.INFO, f"可用资金: {asset.cash}")
-    #     PrintLog(LogLevel.INFO, f"总资产: {asset.total_asset}")
-    #     PrintLog(LogLevel.INFO, f"证券市值: {asset.market_value}")
-    
-    # def print_stock_orders(self):
-    #     orders = self.xt_trader.query_stock_orders(self.account, cancelable_only=True)
-    #     if orders:
-    #         PrintLog(LogLevel.INFO, "\n=== 委托信息 ===")
-    #         for order in orders:
-    #             PrintLog(LogLevel.INFO, f"委托编号: {order.order_id}")
-    #             PrintLog(LogLevel.INFO, f"股票代码: {order.stock_code} {getInstrumentName(order.stock_code)}")
-    #             PrintLog(LogLevel.INFO, f"委托方向: {order.offset_flag} ")
-    #             PrintLog(LogLevel.INFO, f"委托价格: {order.price}")
-    #             PrintLog(LogLevel.INFO, f"委托数量: {order.order_volume}")
-    #             PrintLog(LogLevel.INFO, f"已成交数量: {order.traded_volume}")
-    #             PrintLog(LogLevel.INFO, f"委托状态: {order.order_status} ")
-    #             PrintLog(LogLevel.INFO, "---")
-    #     else:
-    #         PrintLog(LogLevel.INFO, "\n当前无委托记录")
-    
     
     # ========================================#
     def startMarketDataSubscription(self):
@@ -155,7 +119,29 @@ class QmtV(XtQuantTraderCallback):
     # ====== 市场回调方法 -- 以下方法由XtQuantData调用 ======
     def onDataUpdate(self, data):
         # 收集所有市场数据用于市场监控
+        PrintLog(LogLevel.INFO, f'- [市场数据更新] {len(data)}')
         eBus.event_bus.publish(eBus.MarketDataUpdate, data)
+        now = time.time()
+        if now - self.lastMarketDataUpdateTimestamp < 5:
+            self.isMarketActive = True
+            PrintLog(LogLevel.INFO, f'- [市场状态变更] 市场已 Active') # 市场已 inactive
+        self.lastMarketDataUpdateTimestamp = now
+
+    def marketStatusNotifier(self):
+        # 市场状态通知器
+        tmpMarketStatus = False
+        while True:
+            PrintLog(LogLevel.INFO, f'- [市场状态检查器] {self.isMarketActive}')
+            tmpTime = time.time()
+            time.sleep(10)
+            if tmpMarketStatus != self.isMarketActive and tmpTime - self.lastMarketDataUpdateTimestamp < 5:
+                tmpMarketStatus = self.isMarketActive
+                PrintLog(LogLevel.INFO, f'- [市场状态变更] {self.isMarketActive}')
+                eBus.event_bus.publish(eBus.EventMarketActiveSwitch, self.isMarketActive)
+            if tmpMarketStatus and self.isMarketActive:
+                if tmpTime - self.lastMarketDataUpdateTimestamp > 10: # 上次更新市场状态已经超过10秒
+                    self.isMarketActive = False
+                    PrintLog(LogLevel.INFO, f'- [市场状态变更] 市场已 inactive') # 市场已 inactive
 
 
     # ====== 市场回调方法 -- 以下方法由XtQuantTrader调用 ======
@@ -178,16 +164,8 @@ class QmtV(XtQuantTraderCallback):
         :param order: XtOrder对象
         :return:
         """
-        print(f"委托回调 on_stock_order 投资备注 {order.order_id} {order.strategy_name} {order.order_remark}")
+        pass
-        # print(f'orderd {order.strategy_name}-{order.stock_code} {order.order_id} {order.order_volume}-{order.order_status}')
+        # print(f"委托回调 on_stock_order 投资备注 {order.order_id} {order.strategy_name} {order.order_remark}")
-        # stockCode = order.stock_code
-        # ctrl:SFGridStrategy = self.stock_trade_ctrl[stockCode]
-        # # 如果存在对应的StockTradeController，则调用其onDataUpdate方法
-        # if ctrl is not None and order.strategy_name == ctrl.getName():
-        #     print(f'controller info {ctrl.getName()}')
-        #     ctrl.onAsyncOrderResponse(order) # type: ignore
-        # else:
-        #     print(f"委托下单回调 投资备注 orderId: {order.order_sysid} [{order.stock_code}-{order.instrument_name}] volume: {order.order_volume} 订单策略: '{order.strategy_name}'<-->'{ctrl.getName()}'")
 
         
     def on_stock_trade(self, trade:XtTrade):
@@ -206,7 +184,7 @@ class QmtV(XtQuantTraderCallback):
         #     print(f"委托回调 投资备注 {trade.strategy_name} 不匹配 {ctrl.getName()}")
     
     def on_order_stock_async_response(self, response:XtOrderResponse):
-        print(f"委托回调 on_order_stock_async_response 投资备注 {response.order_id} {response.seq} {response.error_msg}{response.strategy_name} {response.order_remark}")
+        # print(f"委托回调 on_order_stock_async_response 投资备注 {response.order_id} {response.seq} {response.error_msg}{response.strategy_name} {response.order_remark}")
         eBus.event_bus.publish(eBus.MarketOrderCreated, response)
         
     #     stockCode = response.order_remark

core/sfgrid/model.py

@@ -34,13 +34,13 @@ class SFGridTradeTarget(BaseModel):
         if self.priceGrid is None or len(self.priceGrid) == 0:
             for i in range(self.grid_upper_count):  # type: ignore 
                 upperPrice = self.grid_start_price + (self.grid_upper_count - i) * self.grid_size
-                self.priceGrid.append(upperPrice)
+                self.priceGrid.append(round(upperPrice, 3))
             
             self.priceGrid.append(self.grid_start_price)
             
             for i in range(self.grid_lower_count): # type: ignore 5
                 lowerPrice = self.grid_start_price - (i + 1) * self.grid_size
-                self.priceGrid.append(lowerPrice)
+                self.priceGrid.append(round(lowerPrice, 3))
         
         return self.priceGrid
 

core/sfgrid/sfgrid_strategy.py

@@ -1,11 +1,11 @@
+from core import util
 from core.logger import LogLevel, PrintLog
 from core.qmt import qmtv
 from core.sfgrid import bus_events
 from core.sfgrid.bus_events import EventTradeTargetUpdate
 import core.sfgrid.model as model
-from core import constants
 from core.eventbus import event_bus
-from core.constants import OrderTypeBuy, OrderTypeInit, OrderTypeSell
+from core.constants import OrderTypeBuy, OrderTypeSell, OrderTypeInit
 from core.util import is_trading_time
 
 from xtquant import xtconstant
@@ -18,26 +18,69 @@ class SFGridStrategy:
 
     def __init__(self, tradeTarget: model.SFGridTradeTarget):
         self.tradeTarget:model.SFGridTradeTarget = tradeTarget
-        self.enabledTrading(tradeTarget.enabled)  # type: ignore
         event_bus.subscribe(eBus.MarketOrderCreated, self.onOrderCreateAsync)
         event_bus.subscribe(eBus.MarketOrderTraded, self.onOrderTrade)
         self.todayUpStopPrice=qmtv.dailyUpStop(tradeTarget.stock_code) # type: ignore
         self.todayDownStopPrice=qmtv.dailyDownStop(tradeTarget.stock_code) # type: ignore
-        self.refreshPlanPrice()
+        PrintLog(LogLevel.INFO, f'|- 标的{tradeTarget.targetName()}初始化: 停涨价 {self.todayUpStopPrice}, 停跌价 {self.todayDownStopPrice}')
+        self.orderGrid = {} # grid index, order_seq | order_id
+        self.enabledTrading(tradeTarget.enabled)  # type: ignore
         self.dataUpdateLock = threading.Lock()
+
+    def onMarketActiveSwitch(self, isActive: bool):
+        if isActive and self.tradeTarget.enabled:
+            self.refreshGridOrder()
     
-    def updateTradeTarget(self, inTradeTarget:model.SFGridTradeTarget):
+    def refreshGridOrder(self): # 下网格单
-        # PrintLog(LogLevel.INFO, f'|- 标的{self.tradeTarget.targetName()}信息更新: START')
+        if not qmtv.isMarketActive:
-        # self.dataUpdateLock.acquire()
+            return
-        # PrintLog(LogLevel.INFO ,f'|- 标的{self.tradeTarget.targetName()}信息更新: LOCKED')
+
-        # try:
+        currentIdx:int = 0
-        self.tradeTarget = inTradeTarget
+
-        self.refreshPlanPrice()
+        if self.tradeTarget.status == 0:
-        # finally:
+            price = self.tradeTarget.getPriceGrid()[0]
-            # PrintLog(LogLevel.INFO ,f'|- 标的{self.tradeTarget.targetName()}信息更新: UNLOCKED')
+            tmpOrderSeq = qmtv.orderAsync(
-            # self.dataUpdateLock.release()
+                str(self.tradeTarget.stock_code), 
-            # self.refreshPlanPrice()
+                self.tradeTarget.grid_volume,
-            # PrintLog(LogLevel.INFO ,f'|- 标的{self.tradeTarget.targetName()}信息更新: END')
+                xtconstant.STOCK_BUY, 
+                price,
+                xtconstant.FIX_PRICE,
+                OrderTypeInit, # remark  # type: ignore
+                self.getName(), # strategy_name
+            )
+            self.orderGrid[xtconstant.STOCK_BUY] = tmpOrderSeq # seq
+            PrintLog(LogLevel.INFO, f'|- 标的[{self.tradeTarget.targetName()}] 初始化: 建仓单，建仓价: {price:.3f}')
+        else:
+            currentIdx = self.tradeTarget.grid_index # type: ignore
+
+            # 向上下一单，向下下一单
+            if currentIdx > 0: # 可以下空单
+                sellPrice = self.tradeTarget.getPriceGrid()[currentIdx - 1]
+                tmpOrderSeq = qmtv.orderAsync(
+                            str(self.tradeTarget.stock_code), 
+                            self.tradeTarget.grid_volume,
+                            xtconstant.STOCK_SELL, 
+                            sellPrice,
+                            xtconstant.FIX_PRICE,
+                            OrderTypeSell, # remark  # type: ignore
+                            self.getName(), # strategy_name
+                            )
+                self.orderGrid[xtconstant.STOCK_SELL] = tmpOrderSeq # seq
+                PrintLog(LogLevel.INFO, f'|- 标的[{self.tradeTarget.targetName()}] 初始化: 下空单，价格: {sellPrice:.3f}')
+            if currentIdx < len(self.tradeTarget.getPriceGrid()) - 1: # 可以下多单
+                buyPrice = self.tradeTarget.getPriceGrid()[currentIdx + 1]
+                tmpOrderSeq = qmtv.orderAsync(
+                            str(self.tradeTarget.stock_code), 
+                            self.tradeTarget.grid_volume,
+                            xtconstant.STOCK_BUY, 
+                            buyPrice,
+                            xtconstant.FIX_PRICE,
+                            OrderTypeBuy, # remark  # type: ignore
+                            self.getName(), # strategy_name
+                            )
+                self.orderGrid[xtconstant.STOCK_BUY] = tmpOrderSeq # seq
+                PrintLog(LogLevel.INFO, f'|- 标的[{self.tradeTarget.targetName()}] 初始化: 下多单，价格: {buyPrice:.3f}')
+
     
     def deleteTradeTarget(self, tradeTarget:model.SFGridTradeTarget):
         PrintLog(LogLevel.INFO, f'|- 标的{tradeTarget.targetName()}信息删除: START')
@@ -57,7 +100,6 @@ class SFGridStrategy:
             if self.tradeTarget.status == 0: # 未建仓
                 print(f"  |- 标的{self.tradeTarget.targetName()}初始状态, 设置网格序号 1,")
                 self.tradeTarget.grid_index = 1  # pyright: ignore[reportAttributeAccessIssue]
-                self.refreshPlanPrice()
             else: # 已建仓
                 # 交易阶段，检查仓位，检查现有订单
                 print(f"  |- 标的{self.tradeTarget.targetName()}已有仓位或非初始状态 无需建初始仓 当前仓位: {self.tradeTarget.current_position} 状态: {self.tradeTarget.status}")
@@ -67,6 +109,7 @@ class SFGridStrategy:
                 else:
                     print(f'  |- 仓位检查: 持仓需求不足, (gridVolume*gridIndex)={minRequirePosition}, 当前持仓：{self.tradeTarget.current_position}, 交易启动失败')
                     self.tradeTarget.enabled = False  # type: ignore
+            self.refreshGridOrder()
         else:
             orders = qmtv.queryPendingOrder(self.tradeTarget.stock_code, self.getName()) # type: ignore
             for order in orders:
@@ -81,116 +124,51 @@ class SFGridStrategy:
         print(f'|- 检查交易状态[{self.tradeTarget.stock_code}-{self.tradeTarget.stock_name}] - {self.tradeTarget.enabled}')
         return bool(self.tradeTarget.enabled)  # 修复返回类型问题
 
-    def onDataUpdate(self, inTradeTarget:model.SFGridTradeTarget):
+    def onOrderCreateAsync(self, response:XtOrderResponse): # 下单成功回调，更新orderID到 self.orderGrid
-
-        if not is_trading_time():
-            return
-
-        if not self.tradeTarget.enabled: # 策略中止，自动交易暂停
-            return
-        
-        self.dataUpdateLock.acquire()
-        try:
-            lastPrice = inTradeTarget.market_price
-            orderPrice:float = -1
-            orderType = -1
-            index: int =  self.tradeTarget.grid_index  # pyright: ignore[reportAssignmentType]
-            orderRemark= ""
-            if self.tradeTarget.enabled and self.tradeTarget.status == 0 and lastPrice <= inTradeTarget.getPriceGrid()[1]: # 已启用，未建仓，准备建仓单信息
-                PrintLog(LogLevel.INFO, f'|- 市价更新[{self.tradeTarget.stock_code}-{self.tradeTarget.stock_name}] - 准备建仓单信息')
-                orderPrice =  inTradeTarget.getPriceGrid()[1]
-                orderType = xtconstant.STOCK_BUY
-                orderRemark = OrderTypeInit
-            elif self.tradeTarget.enabled and self.tradeTarget.status == 1 and self.tradeTarget.plan_buy_price > 0 and lastPrice <= self.tradeTarget.plan_buy_price: 
-                # 已启用，已建仓，准备网格多单信息
-                PrintLog(LogLevel.INFO, f'|- 市价更新[{self.tradeTarget.stock_code}-{self.tradeTarget.stock_name}] - 准备网格多单信息')
-                orderPrice = self.tradeTarget.plan_buy_price # type: ignore
-                orderType = xtconstant.STOCK_BUY
-                orderRemark = OrderTypeBuy
-            elif self.tradeTarget.enabled and self.tradeTarget.status == 1 and self.tradeTarget.plan_buy_price > 0 and lastPrice >= self.tradeTarget.plan_sell_price:
-                # 已启用，已建仓，准备网格空单信息
-                PrintLog(LogLevel.INFO, f'|- 市价更新[{self.tradeTarget.stock_code}-{self.tradeTarget.stock_name}] - 准备网格空单信息')
-                orderPrice = self.tradeTarget.plan_sell_price # type: ignore
-                orderType = xtconstant.STOCK_SELL
-                orderRemark = OrderTypeSell
-
-            # status = "未建初始仓" if self.tradeTarget.status == 0 else "已建初始仓"
-            PrintLog(LogLevel.INFO, f'|- 市价更新[{self.tradeTarget.stock_code}-{self.tradeTarget.stock_name}] - 当前持仓   : \t{self.tradeTarget.current_position}')
-            PrintLog(LogLevel.INFO, f'|- 市价更新[{self.tradeTarget.stock_code}-{self.tradeTarget.stock_name}] - 当前价格   : \t{lastPrice}')
-            PrintLog(LogLevel.INFO, f'|- 市价更新[{self.tradeTarget.stock_code}-{self.tradeTarget.stock_name}] - 计划卖出价 : \t{self.tradeTarget.plan_sell_price:.3f}')
-            PrintLog(LogLevel.INFO, f'|- 市价更新[{self.tradeTarget.stock_code}-{self.tradeTarget.stock_name}] - 网格价格({index}): \t{self.tradeTarget.getPriceGrid()[index]:.3f}')
-            PrintLog(LogLevel.INFO, f'|- 市价更新[{self.tradeTarget.stock_code}-{self.tradeTarget.stock_name}] - 计划买入价 : \t{self.tradeTarget.plan_buy_price:.3f}')
-            if orderType != -1:
-                orders = qmtv.queryPendingOrder(str(self.tradeTarget.stock_code), self.getName())
-                if len([order for order in orders if order.order_type == orderType and order.price == orderPrice]) > 0:
-                    # 已存在未交易的多单
-                    PrintLog(LogLevel.INFO, f'|- 市价更新[{self.tradeTarget.stock_code}-{self.tradeTarget.stock_name}] - 已存在未交易的{"多单" if orderType == xtconstant.STOCK_BUY else "空单"}，不重复下单')
-                else:
-                    PrintLog(LogLevel.INFO, f'|- 市价更新[{self.tradeTarget.stock_code}-{self.tradeTarget.stock_name}] - 下网格{"多单" if orderType == xtconstant.STOCK_BUY else "空单"}')
-                    self.tradeTarget.current_order_no = qmtv.orderAsync(
-                            str(self.tradeTarget.stock_code), 
-                            self.tradeTarget.grid_volume,
-                            orderType, 
-                            orderPrice,
-                            xtconstant.FIX_PRICE,
-                            orderRemark, # remark  # type: ignore
-                            self.getName(), # strategy_name
-                            )
-                orderTypeName = ""
-                if orderRemark == OrderTypeBuy:
-                    orderTypeName = "多单"
-                elif orderRemark == OrderTypeSell:
-                    orderTypeName = "空单"
-                elif orderRemark == OrderTypeInit:
-                    orderTypeName = "建仓单"
-                gridBasePrice  =  -1 if index>=len(inTradeTarget.getPriceGrid()) or index < 0 else inTradeTarget.getPriceGrid()[int(index)]  # pyright: ignore[reportArgumentType]
-                PrintLog(LogLevel.INFO, f'|- {orderTypeName}委托[{self.tradeTarget.stock_code}-{self.tradeTarget.stock_name}] - 单号 {self.tradeTarget.current_order_no}, 网格基准价 {gridBasePrice:.3f}, 下单价 {orderPrice:.3f}, 下单量 {self.tradeTarget.grid_volume}')
-        finally:
-            self.saveProxy()
-            self.dataUpdateLock.release()
-
-    def onOrderCreateAsync(self, response:XtOrderResponse):
         self.dataUpdateLock.acquire()
         try:
             if response.strategy_name == self.getName() and response.seq == self.tradeTarget.current_order_no:
                 print(f"委托创建通知 onOrderCreateAsync[{self.tradeTarget.stock_code}-{self.tradeTarget.stock_name}]: {response.order_id}")
-                self.tradeTarget.current_order_no = response.order_id
+                for gridIdx, orderNo in self.orderGrid.items():
-                self.saveProxy()
+                    if orderNo == response.seq:
+                        self.orderGrid[gridIdx] = response.order_id
+                        break
+        except Exception as e:
+            PrintLog(LogLevel.ERROR, f"|- 委托创建通知 onOrderCreateAsync[{self.tradeTarget.stock_code}-{self.tradeTarget.stock_name}]: {response.order_id} - {str(e)}")
         finally:
-            self.dataUpdateLock.release() 
+            self.dataUpdateLock.release()
 
-    def onOrderTrade(self, trade:XtTrade):
+    def onOrderTrade(self, trade:XtTrade): # TODO 委托成交通知,处理成交后网格切换
         if trade.strategy_name != self.getName():
             return
-        PrintLog(LogLevel.INFO, f'|- 委托成交通知[{self.tradeTarget.stock_code}-{self.tradeTarget.stock_name}-{trade.order_id}]:START, {trade.order_id}')
+        PrintLog(LogLevel.INFO, f'|- 委托成交通知[{self.tradeTarget.stock_code}-{self.tradeTarget.stock_name}-{trade.order_id}] : {trade.order_id}')
 
         self.dataUpdateLock.acquire()
         try:
             type:str = ""
-            if self.tradeTarget.status == 0 and trade.order_id == self.tradeTarget.current_order_no and trade.order_remark == constants.OrderTypeInit:
+            if trade.order_remark == OrderTypeInit:
-                # 此时为建仓成交
+                PrintLog(LogLevel.INFO, f'|- 委托成交通知[{self.tradeTarget.targetName()}-{trade.order_id}] - 建仓单成交')
-                self.tradeTarget.current_position = int(self.tradeTarget.current_position) + trade.traded_volume # 当前持仓数，账户原有持仓不在策略范围内  # type: ignore
-                self.tradeTarget.last_trade_price = float(trade.traded_price)  # type: ignore
-                self.tradeTarget.grid_index = 1  # type: ignore
                 self.tradeTarget.status = 1  # type: ignore
-                type = "建初始仓"
+                self.tradeTarget.grid_index = 1  # type: ignore
-            elif trade.order_id == self.tradeTarget.current_order_no and self.tradeTarget.status == 1 and trade.order_type == xtconstant.STOCK_SELL:  # type: ignore
+                self.saveProxy()
-                # 上涨一格：此时空单成交
+                type = "建仓单"
-                self.tradeTarget.current_position = int(self.tradeTarget.current_position) - trade.traded_volume  # type: ignore
-                self.tradeTarget.last_trade_price = float(trade.traded_price)  # type: ignore
-                self.tradeTarget.grid_index = int(self.tradeTarget.grid_index) - 1  # type: ignore
-                type = "上涨一格"
-            elif trade.order_id == self.tradeTarget.current_order_no and self.tradeTarget.status == 1 and trade.order_type == xtconstant.STOCK_BUY:  # type: ignore
-                # 下跌一格：此时多单成交
-                self.tradeTarget.current_position = int(self.tradeTarget.current_position) + trade.traded_volume  # type: ignore
-                self.tradeTarget.last_trade_price = float(trade.traded_price)  # type: ignore
-                self.tradeTarget.grid_index = int(self.tradeTarget.grid_index) + 1  # type: ignore
-                type = "下跌一格"
             else:
-                type = "其他异常状态"
+                PrintLog(LogLevel.INFO, f'|- 委托成交通知[{self.tradeTarget.targetName()}-{trade.order_id}] - 网格单成交')
-            
+                oriIdx = self.tradeTarget.grid_index
-            self.refreshPlanPrice()
+                for idx, tmpOrderNo in self.orderGrid.items():
+                    if tmpOrderNo == trade.order_id:
+                        if idx > self.tradeTarget.grid_index:
+                            type = "下移一格"
+                        elif idx < self.tradeTarget.grid_index:
+                            type = "上移一格"
+                        elif idx == self.tradeTarget.grid_index:
+                            type = "保持格, 理论上不应该输出"
+                        self.tradeTarget.grid_index = idx
+                        break
+                PrintLog(LogLevel.INFO, f'|- 委托成交通知[{self.tradeTarget.stock_code}-{self.tradeTarget.stock_name} - 原网格位置 {oriIdx}, 现网格位置 {self.tradeTarget.grid_index}')
+            self.saveProxy()
             self.printTradeReport(trade, type)
+            self.refreshGridOrder() # 更新网格订单
         finally:
             self.dataUpdateLock.release()
     
@@ -201,28 +179,6 @@ class SFGridStrategy:
         PrintLog(LogLevel.INFO, f'   手续费  : {trade.commission:.3f}')
 
 
-    def refreshPlanPrice(self):
-        buyIdx = 0
-        sellIdx= 0
-        if self.tradeTarget.status == 0: # 未建仓
-            self.tradeTarget.grid_index = 0 # type: ignore
-            buyIdx = 1
-            sellIdx = 0
-        else:
-            buyIdx: int = self.tradeTarget.grid_index + 1  # pyright: ignore[reportAssignmentType]
-            sellIdx: int = self.tradeTarget.grid_index - 1
-
-        if self.tradeTarget.grid_index > 0: # 可以下空单
-            self.tradeTarget.plan_sell_price = float(self.tradeTarget.getPriceGrid()[sellIdx])  # pyright: ignore[reportAttributeAccessIssue]
-        else:
-            self.tradeTarget.plan_sell_price = -1.0  # type: ignore
-
-        if self.tradeTarget.grid_index < len(self.tradeTarget.getPriceGrid()) - 1:
-            self.tradeTarget.plan_buy_price = float(self.tradeTarget.getPriceGrid()[buyIdx])  # pyright: ignore[reportAttributeAccessIssue]
-        else:
-            self.tradeTarget.plan_buy_price = -1.0  # pyright: ignore[reportAttributeAccessIssue]
-        event_bus.publish(EventTradeTargetUpdate, self.tradeTarget)
-    
     def getName(self):
         return "SFGRID"
     

core/sfgrid/sfgrid_ui.py

@@ -61,7 +61,7 @@ class TradeTargetUI(ttk.Frame):
                 PrintLog(LogLevel.INFO, f'|- 市价更新[{tradeTarget.targetName()}] - {timeStr.strftime("%H:%M:%S")} 市场数据更新======================={id}')
                 lastPrice = float("{:.3f}".format(tickData['lastPrice']))    
                 tradeTarget.market_price = lastPrice  # type: ignore
-                self.updateTradeTarget(tradeTarget, False, True) # 市价更新
+                self.updateTradeTarget(tradeTarget, False) # 市价更新
             else:
                 # 非目标交易，发布市场数据更新事件用于市场监控
                 lastPrice = tickData['lastPrice']
@@ -90,7 +90,7 @@ class TradeTargetUI(ttk.Frame):
 
 
     # priceChange 用于控制是否对更新价格数据，进行交易判断
-    def updateTradeTarget(self, target: SFGridTradeTarget, save: bool = True, priceChange:bool = False):
+    def updateTradeTarget(self, target: SFGridTradeTarget, save: bool = True):
         if save:
             target.save()
 
@@ -102,10 +102,6 @@ class TradeTargetUI(ttk.Frame):
         if id not in self.strategy_ctrl:
             self.stockCodeIdMap[target.stock_code] = id  # type: ignore
             self.strategy_ctrl[id] = SFGridStrategy(target)  # pyright: ignore[reportArgumentType]
-        else:
-            self.strategy_ctrl[id].updateTradeTarget(target)
-            if priceChange:
-                self.strategy_ctrl[id].onDataUpdate(target)
 
     # UI CREATE
     def create_ui(self):