From 1ec27bb52f435f18870a03b942e14e44caea8818 Mon Sep 17 00:00:00 2001 From: "GDP\\solonot" Date: Mon, 10 Nov 2025 17:15:35 +0800 Subject: [PATCH 1/9] =?UTF-8?q?=E5=8E=BB=E6=8E=89=E4=B8=8D=E7=94=A8?= =?UTF-8?q?=E7=9A=84=E9=85=8D=E7=BD=AE?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- config.ini | 1 - 1 file changed, 1 deletion(-) diff --git a/config.ini b/config.ini index 35e46b5..3083273 100644 --- a/config.ini +++ b/config.ini @@ -3,5 +3,4 @@ miniqmtpath = D:/Programs/DTQMT/userdata_mini grid_price = 11.0,10.0,9.0,8.0,7.0,6.0,5.0,4.0,3.0,2.0,1.0,0.0 grid_volume = 100 account_no = 99082560 -max_enabled_targets = 10 From 7cfb433aaf0735f8966d7f176f74ea75e0a62ef3 Mon Sep 17 00:00:00 2001 From: "GDP\\solonot" Date: Mon, 10 Nov 2025 17:16:06 +0800 Subject: [PATCH 2/9] update --- example.db | Bin 24576 -> 0 bytes 1 file changed, 0 insertions(+), 0 deletions(-) delete mode 100644 example.db diff --git a/example.db b/example.db deleted file mode 100644 index 7432cba2b8afec16c006e969a0e94ca3685325ac..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 24576 zcmeI(&rc&|7zgloC@s^H>FmLTc#(I9U|>sdptMkp*;cH(L|~;9WxX`hc6QTH+U|5P zuBTRz*#Ka%ug2yNIk-G!xZXTD`FOPq&P=kkxXDk=SMWX7n;0;HP*{@(i-n z^d6??E$Zs(>FX2jbhV~ZL!vlrQ;4O{k*Px)x*np+@i}D0v`ZkWG-prqd8LYV#@gf% zRoW&HRgTLZsX-I2>l}^w+NhySW^fBdyJu*9*26AUC#2CaTzG(%`D(?CJ^m zgw@IFb=Qy=iNo{S@F~9sx#}6SFgrE35M_6k*Q1L~_nwBTisZR8+jNk(VBMGwyHIFk zezKOpJb(GKJb$)te7@(Oqd))x5P$##AOHafKmY;|fB*y_a0&z@Z<08qec~OFf0XvE z?G#K5Q-A;jAOHafKmY;|fB*y_00HufM<%`fU4mN>1o5owb_Z2;!mkd`U)8sM`pZEx;w+$`;UURk~W>yyu-@i)%@6mufUPpfLblebLxS^^%-mqYyfYkt1sf()@X z`>Nw0);Nw{PvBv}4*4e{|0$Q)4g~@bfB*y_009U<00Izz00bZaf&Yzw Date: Tue, 11 Nov 2025 12:15:40 +0800 Subject: [PATCH 3/9] update for restructure --- .gitignore | 2 + core/constants.py | 6 + core/database.py | 14 + core/logger.py | 3 + core/main_controller.py | 136 ++------ core/main_ui.py | 327 ++++++++++++++++++ core/sfgrid/main_controller.py | 402 +++++++++++++++++++++++ core/{strategy_db.py => sfgrid/model.py} | 19 +- core/{ => sfgrid}/objects.py | 2 +- core/{ => sfgrid}/sfgrid_strategy.py | 45 +-- core/{ => sfgrid}/ui.py | 186 +++-------- core/util.py | 4 +- sfgrid_constants.py => sfgrid_config.py | 13 +- starter.py | 25 +- starter.spec | 2 +- 15 files changed, 880 insertions(+), 306 deletions(-) create mode 100644 core/constants.py create mode 100644 core/database.py create mode 100644 core/main_ui.py create mode 100644 core/sfgrid/main_controller.py rename core/{strategy_db.py => sfgrid/model.py} (63%) rename core/{ => sfgrid}/objects.py (79%) rename core/{ => sfgrid}/sfgrid_strategy.py (87%) rename core/{ => sfgrid}/ui.py (88%) rename sfgrid_constants.py => sfgrid_config.py (89%) diff --git a/.gitignore b/.gitignore index c18dd8d..35bf4c6 100644 --- a/.gitignore +++ b/.gitignore @@ -1 +1,3 @@ __pycache__/ +dist/ +example.db diff --git a/core/constants.py b/core/constants.py new file mode 100644 index 0000000..dd64a00 --- /dev/null +++ b/core/constants.py @@ -0,0 +1,6 @@ +import xtquant.xtconstant as xtconstant + +OrderTypeBuy = f'{xtconstant.STOCK_BUY}' # 买 +OrderTypeSell = f'{xtconstant.STOCK_SELL}' # 卖 +OrderTypeInit = "0" # 建仓 +OrderTypeNone = "None" \ No newline at end of file diff --git a/core/database.py b/core/database.py new file mode 100644 index 0000000..3629252 --- /dev/null +++ b/core/database.py @@ -0,0 +1,14 @@ +from peewee import SqliteDatabase, Model, CharField, IntegerField, FloatField, BooleanField + +from core.logger import LogLevel, PrintLog +from xtquant import xtconstant + +# 连接到SQLite数据库 +db = SqliteDatabase('example.db') + +db.connect() +PrintLog(LogLevel.INFO, '- [成功]数据库连接') +# 定义基础模型类 +class BaseModel(Model): + class Meta: + database = db \ No newline at end of file diff --git a/core/logger.py b/core/logger.py index 9938f81..a306836 100644 --- a/core/logger.py +++ b/core/logger.py @@ -1,6 +1,7 @@ from enum import Enum from core.eventbus import EventPrintLog, event_bus +import sfgrid_config class LogLevel(Enum): DEBUG = "DEBUG" @@ -17,3 +18,5 @@ class LogData: def PrintLog(level:LogLevel, message:str): data = LogData(level, message) event_bus.publish(EventPrintLog, data) + if sfgrid_config.console_log: + print(f'{level.value} {message}') diff --git a/core/main_controller.py b/core/main_controller.py index 048473d..7ac52a4 100644 --- a/core/main_controller.py +++ b/core/main_controller.py @@ -1,30 +1,30 @@ # coding:utf-8 -from core.strategy_db import TradeTarget +from core.sfgrid.model import TradeTarget from core.eventbus import ActionDisableMarketData, ActionEnableMarketData, ActionEventAddTradeTarget, ActionEventDeleteTradeTarget, ActionEventDisableTrade, ActionEventEnableTrade, EventTradeTargetUpdate, MarketDataUpdate, MarketDataEnabled, MarketDataDisabled, ResultEventTradeDisabled, ResultEventTradeEnabled, ResultEventTradeTargetDeleted, ActionEventGridFix, event_bus from xtquant.xttrader import XtQuantTrader import time from peewee import ModelSelect -import core.strategy_db as strategy_db -import sfgrid_constants -from core.sfgrid_strategy import SFGridStrategy +import core.sfgrid.model as model +import sfgrid_config +from core.sfgrid.sfgrid_strategy import SFGridStrategy from core.util import getInstrumentName, getStockPosition, queryPendingOrder from xtquant.xttrader import XtQuantTrader -from xtquant.xttype import StockAccount, XtAsset, XtOrder, XtOrderResponse, XtPosition, XtTrade +from xtquant.xttype import StockAccount, XtAsset, XtOrder, XtPosition, XtTrade from xtquant import xtdata from xtquant.xttrader import XtQuantTraderCallback import datetime -import core.ui as ui +import core.sfgrid.ui as ui from core.logger import PrintLog, LogLevel -from core.objects import GridFixData +from core.sfgrid.objects import GridFixData # 量化核心控制对象 -class SFGridController(XtQuantTraderCallback): +class MainController(XtQuantTraderCallback): def __init__(self, account_no: str, miniQmtPath: str): super().__init__() self.registerEventHandler() - self.appUi = ui.TradeTargetUI() + # self.appUi = ui.TradeTargetUI() xtdata.enable_hello = False @@ -118,13 +118,10 @@ class SFGridController(XtQuantTraderCallback): except Exception as e: PrintLog(LogLevel.ERROR, f"网格修正更新失败: {str(e)}") - def hold(self): - self.appUi.run() - def startMarketData(self): PrintLog(LogLevel.INFO, '- 启动市场数据订阅') - self.seq = xtdata.subscribe_whole_quote(['SH', 'SZ'], callback=self.onDataUpdate) + # self.seq = xtdata.subscribe_whole_quote(['SH', 'SZ'], callback=self.onDataUpdate) if self.seq == -1: PrintLog(LogLevel.ERROR, '- 市场数据订阅失败') else: @@ -149,12 +146,12 @@ class SFGridController(XtQuantTraderCallback): return # 检查是否已存在该标的 - existing_target = strategy_db.TradeTarget.get_or_none(strategy_db.TradeTarget.stock_code == stock_code) + existing_target = model.TradeTarget.get_or_none(model.TradeTarget.stock_code == stock_code) if existing_target: PrintLog(LogLevel.INFO, f'交易标的 {stock_code} {stock_name} 已存在') return - new_target = strategy_db.TradeTarget.create( + new_target = model.TradeTarget.create( stock_name=stock_name, stock_code=stock_code, market_price=0.0, @@ -171,7 +168,7 @@ class SFGridController(XtQuantTraderCallback): PrintLog(LogLevel.INFO, f'新增交易标的 {stock_code} {stock_name}, {new_target.id}') # 刷新标的持仓 pos = getStockPosition(stock_code, self.xt_trader, self.account) # type: ignore - strategy_db.TradeTarget.update(current_position=pos).where(strategy_db.TradeTarget.stock_code == stock_code).execute() + model.TradeTarget.update(current_position=pos).where(model.TradeTarget.stock_code == stock_code).execute() # 更新标的池 self.refresh_targets() # 添加交易控制器 @@ -189,7 +186,7 @@ class SFGridController(XtQuantTraderCallback): PrintLog(LogLevel.ERROR, f"交易标的 ID {id} 不存在") return - target: strategy_db.TradeTarget = self.instrument_pool[id] + target: model.TradeTarget = self.instrument_pool[id] # 如果存在交易控制器，先停止交易 if target.stock_code in self.stock_trade_ctrl: @@ -215,9 +212,9 @@ class SFGridController(XtQuantTraderCallback): for id in self.instrument_pool: target:TradeTarget = self.instrument_pool[id] status = "新建" if target.status == 0 else "已建初始仓" - PrintLog(LogLevel.INFO, f' [序号-{id}] 股票代码: {target.stock_code}-{target.stock_name} 当前持仓: {getStockPosition(target.stock_code, self.xt_trader, self.account)} 网格索引: {target.grid_index} 基准价格 {sfgrid_constants.grid_price[target.grid_index]} 状态: {status} 启用交易线程: {'自动交易中' if target.enabled else '交易已停止'}') # type: ignore + PrintLog(LogLevel.INFO, f' [序号-{id}] 股票代码: {target.stock_code}-{target.stock_name} 当前持仓: {getStockPosition(target.stock_code, self.xt_trader, self.account)} 网格索引: {target.grid_index} 基准价格 {sfgrid_config.grid_price[target.grid_index]} 状态: {status} 启用交易线程: {'自动交易中' if target.enabled else '交易已停止'}') # type: ignore - tradeTarget:strategy_db.TradeTarget = self.instrument_pool[id] + tradeTarget:model.TradeTarget = self.instrument_pool[id] tradeTarget.current_position = getStockPosition(tradeTarget.stock_code, xtTrader, account) # type: ignore result = tradeTarget.save() PrintLog(LogLevel.INFO, f' |- 同步[{target.stock_code}-{target.stock_name}]持仓信息[{'成功' if result == 1 else '失败'}]') @@ -230,10 +227,10 @@ class SFGridController(XtQuantTraderCallback): def refresh_targets(self): # 更新标的池 - results:ModelSelect = strategy_db.TradeTarget.select() - self.instrument_pool: dict[int, strategy_db.TradeTarget] = {} + results:ModelSelect = model.TradeTarget.select() + self.instrument_pool: dict[int, model.TradeTarget] = {} for temp in results: - result :strategy_db.TradeTarget = temp + result :model.TradeTarget = temp self.instrument_pool[result.get_id()] = result def print_position_info(self): @@ -293,7 +290,7 @@ class SFGridController(XtQuantTraderCallback): def pause_stock_trade(self, id: int): - localTarget: strategy_db.TradeTarget = self.instrument_pool[id] + localTarget: model.TradeTarget = self.instrument_pool[id] print(f'暂停标的交易 {localTarget.stock_code} - enabled {localTarget.enabled}') if localTarget.stock_code in self.stock_trade_ctrl: tradeController: SFGridStrategy = self.stock_trade_ctrl[localTarget.stock_code] @@ -307,96 +304,3 @@ class SFGridController(XtQuantTraderCallback): else: print(f"标的交易控制器不存在 {localTarget.stock_code} {localTarget.stock_name}\n") - - # ====== 市场回调方法 -- 以下方法由XtQuantData调用 ====== - def onDataUpdate(self, data): - # 收集所有市场数据用于市场监控 - for stock_code, tickData in data.items(): - if stock_code in self.stock_trade_ctrl: - stock_controller: SFGridStrategy = self.stock_trade_ctrl[stock_code] - stock_controller.onDataUpdate(data) - else: - # 非目标交易，发布市场数据更新事件用于市场监控 - lastPrice = tickData['lastPrice'] - if lastPrice == 10 or stock_code in self.listening_stock: - # 发布市场数据更新事件用于市场监控 - market_target = TradeTarget() - market_target.stock_code = stock_code - market_target.stock_name = getInstrumentName(stock_code) # type: ignore - market_target.market_price = lastPrice # type: ignore - event_bus.publish(MarketDataUpdate, market_target) - if stock_code not in self.listening_stock: - self.listening_stock.append(stock_code) - - - # ====== 市场回调方法 -- 以下方法由XtQuantTrader调用 ====== - def on_connected(self): - """ - 连接成功推送 - """ - print(datetime.datetime.now(), '连接成功回调') - - def on_disconnected(self): - """ - 连接断开 - :return: - """ - print(datetime.datetime.now(), '连接断开回调') - - def on_stock_order(self, order:XtOrder): - """ - 委托回报推送 - :param order: XtOrder对象 - :return: - """ - print(f'orderd {order.strategy_name}-{order.stock_code} {order.order_id} {order.order_volume}-{order.order_status}') - 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): - """ - 成交变动推送 - :param trade: XtTrade对象 - :return: - """ - stockCode = trade.stock_code - ctrl:SFGridStrategy = self.stock_trade_ctrl[stockCode] - # 如果存在对应的StockTradeController，则调用其onDataUpdate方法 - if ctrl is not None and trade.strategy_name == ctrl.getName(): - ctrl.onOrderTrade(trade) - else: - print(f"委托回调 投资备注 {trade.strategy_name} 不匹配 {ctrl.getName()}") - - # def on_order_stock_async_response(self, response:XtOrderResponse): - # stockCode = response.order_remark - # ctrl:SFGridStrategy = self.stock_trade_ctrl[stockCode] - # # 如果存在对应的StockTradeController，则调用其onDataUpdate方法 - # if ctrl is not None and response.strategy_name == ctrl.getName(): - # ctrl.onAsyncOrderResponse(response) - # else: - # print(f"委托回调 投资备注 {response.strategy_name} 不匹配 {ctrl.getName()}") - - def on_order_error(self, order_error): - """ - 委托失败推送 - :param order_error:XtOrderError 对象 - :return: - """ - # print("on order_error callback") - # print(order_error.order_id, order_error.error_id, order_error.error_msg) - print(f"\n委托报错回调 {order_error.order_remark} {order_error.error_msg}") - - - def on_account_status(self, status): - """ - :param response: XtAccountStatus 对象 - :return: - """ - print(datetime.datetime.now(), status) \ No newline at end of file diff --git a/core/main_ui.py b/core/main_ui.py new file mode 100644 index 0000000..a4d7d94 --- /dev/null +++ b/core/main_ui.py @@ -0,0 +1,327 @@ +import time +import tkinter as tk +from tkinter import ttk +from core.logger import LogLevel, PrintLog +from core.sfgrid.ui import TradeTargetUI +import sfgrid_config +from xtquant import xtdata +from xtquant.xttrader import XtQuantTrader, XtQuantTraderCallback +import datetime +from xtquant.xttype import StockAccount, XtAsset, XtOrder, XtOrderResponse, XtPosition, XtTrade + +class MainWindow(XtQuantTraderCallback): + def __init__(self): + self.root = tk.Tk() + self.root.title("三疯交易系统") + self.root.geometry("1400x700") + + # 当前选中的策略Tab索引 + self.current_strategy_index = 0 + # 存储各个Frame的引用 + self.strategy_frames = {} + # 日志面板可见性标志 + self.log_visible = False + + self.initQmt() + # 创建界面 + self.create_ui() + + def initQmt(self): + xtdata.enable_hello = False + + session_id = int(time.time()) + + self.xt_trader: XtQuantTrader = XtQuantTrader(sfgrid_config.miniQMTPath, session_id) + self.xt_trader.register_callback(self) + self.xt_trader.start() + self.xt_trader.connect() + PrintLog(LogLevel.INFO, f'- [{'成功' if self.xt_trader.connected else '失败'}]市场交易连接: {sfgrid_config.miniQMTPath}') + if self.xt_trader.connected == False: + self.inited: bool = False + return + else: + self.inited = True + + self.account= StockAccount(sfgrid_config.account_no, 'STOCK') + PrintLog(LogLevel.INFO, f'- [成功]交易账号对象初始化完成, 账号: {self.account.account_id}') # pyright: ignore[reportAttributeAccessIssue] + subscribe_result = self.xt_trader.subscribe(self.account) + PrintLog(LogLevel.INFO, f'- [{'成功' if subscribe_result == 0 else '失败'}:{subscribe_result}]交易状态订阅') + if subscribe_result == 0: + self.inited = True + else: + self.inited = False + return + + def create_ui(self): + """创建UI界面""" + # 主容器 + main_container = ttk.Frame(self.root) + main_container.pack(fill=tk.BOTH, expand=True, padx=10, pady=10) + + # 中间主体区域（左右布局） + content_area = ttk.Frame(main_container) + content_area.pack(fill=tk.BOTH, expand=True) + + # 左侧Tab按钮栏（垂直排列） + tab_bar_frame = ttk.Frame(content_area) + tab_bar_frame.pack(side=tk.LEFT, fill=tk.Y, padx=(0, 10)) + + # 创建Tab按钮（垂直排列，文字垂直显示） + self.tab_buttons = [] + strategy_names = ["三疯\n网格", "通用\n网格", "涨停\n分析"] + + for idx, name in enumerate(strategy_names): + btn = ttk.Button( + tab_bar_frame, + text=name, + command=lambda i=idx: self.switch_strategy_tab(i), + width=4 + ) + btn.pack(side=tk.TOP, pady=2, fill=tk.X) + self.tab_buttons.append(btn) + + # 在Tab按钮下方添加退出按钮和日志按钮（底部对齐） + # 使用一个填充Frame将按钮推到底部 + spacer = ttk.Frame(tab_bar_frame) + spacer.pack(side=tk.TOP, fill=tk.X, ipady=10) + + # 清空日志按钮（底部第三个） + clear_log_btn = ttk.Button( + tab_bar_frame, + text="🗑", # 垃圾桶图标 + command=self.clear_logs, + width=3 + ) + clear_log_btn.pack(side=tk.TOP, pady=2, fill=tk.X) + + # 日志显示按钮（退出按钮上方） + self.log_toggle_btn = ttk.Button( + tab_bar_frame, + text="📋", # 日志图标 + command=self.toggle_log_panel, + width=3 + ) + self.log_toggle_btn.pack(side=tk.TOP, pady=2, fill=tk.X) + + # 退出按钮（最底部） + exit_btn = ttk.Button( + tab_bar_frame, + text="⏻", # 电源图标 + command=self.on_exit, + width=3 + ) + exit_btn.pack(side=tk.TOP, pady=2, fill=tk.X) + + # 添加垂直分隔线 + separator = ttk.Separator(content_area, orient='vertical') + separator.pack(side=tk.LEFT, fill=tk.Y, padx=1) + + # 右侧内容区域容器（用于放置不同策略的Frame） + self.content_container = ttk.Frame(content_area) + self.content_container.pack(side=tk.LEFT, fill=tk.BOTH, expand=True) + + # 创建各个策略的Frame + self.create_strategy_frames(strategy_names) + + # 创建全局日志面板（默认隐藏） + self.create_global_log_panel(main_container) + + # 默认显示第一个策略 + self.switch_strategy_tab(0) + + def create_global_log_panel(self, parent): + """创建全局日志面板""" + # 日志区域(默认隐藏) + self.log_frame = ttk.LabelFrame(parent, text="操作日志", padding=10) + # 默认不显示,通过工具栏按钮控制 + + # 创建日志表格 + columns = ("timestamp", "level", "message") + + self.log_table = ttk.Treeview(self.log_frame, columns=columns, show='headings', height=8) + + log_column_configs = { + "timestamp": ("时间", 100), + "level": ("级别", 50), + "message": ("消息", 1150) # 调整宽度适应全局布局 + } + + for col in columns: + title, width = log_column_configs[col] + self.log_table.heading(col, text=title) + self.log_table.column(col, width=width, anchor=tk.W) + + # 添加初始日志 + from datetime import datetime + timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S") + self.log_table.insert('', tk.END, values=(timestamp, "INFO", "系统启动成功")) + + # 滚动条 + scrollbar = ttk.Scrollbar(self.log_frame, orient=tk.VERTICAL, command=self.log_table.yview) + self.log_table.configure(yscrollcommand=scrollbar.set) + + self.log_table.pack(side=tk.LEFT, fill=tk.BOTH, expand=True) + scrollbar.pack(side=tk.RIGHT, fill=tk.Y) + + def add_log(self, level:LogLevel, message): + """添加日志记录 - 全局方法""" + from datetime import datetime + timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S") + self.log_table.insert('', 0, values=(timestamp, level.value, message)) + + def clear_logs(self): + """清空日志记录""" + # 删除所有日志项 + for item in self.log_table.get_children(): + self.log_table.delete(item) + self.add_log(LogLevel.DEBUG, "日志已清空") + + def create_strategy_frames(self, strategy_names): + """创建各个策略的Frame""" + for idx, name in enumerate(strategy_names): + if idx == 0: + # 第一个Tab使用TradeTargetUI，传入main_window引用 + frame = TradeTargetUI(self.content_container, self) + self.strategy_frames[idx] = frame + else: + # 其他策略使用占位Frame + frame = ttk.Frame(self.content_container) + self.strategy_frames[idx] = frame + + # 添加占位内容 + placeholder = ttk.Label( + frame, + text=f"{name} - 策略界面将在此实现", + font=('Arial', 14), + foreground='gray' + ) + placeholder.pack(expand=True) + + def switch_strategy_tab(self, index): + """切换策略Tab""" + # 隐藏当前Frame + if self.current_strategy_index in self.strategy_frames: + self.strategy_frames[self.current_strategy_index].pack_forget() + + # 更新当前索引 + self.current_strategy_index = index + + # 显示选中的Frame + if index in self.strategy_frames: + self.strategy_frames[index].pack(fill=tk.BOTH, expand=True) + + # 更新Tab按钮样式（可选，用于视觉反馈） + self.update_tab_button_styles() + + + + + def update_tab_button_styles(self): + """更新Tab按钮的样式以显示选中状态""" + # 注意：ttk.Button的样式需要通过ttk.Style来设置 + # 这里简化处理，仅作为接口预留 + pass + + def toggle_log_panel(self): + """切换日志面板的显示/隐藏""" + if self.log_visible: + # 隐藏日志面板 + self.log_frame.pack_forget() + self.log_visible = False + self.log_toggle_btn.config(text="📋") # 日志图标 + else: + # 显示日志面板 + self.log_frame.pack(side=tk.BOTTOM, fill=tk.X, pady=(5, 0)) + self.log_visible = True + self.log_toggle_btn.config(text="🔽") # 使用不同图标表示隐藏 + + def on_exit(self): + """退出程序""" + from tkinter import messagebox + result = messagebox.askyesno("确认退出", "确定要退出系统吗？") + if result: + self.root.destroy() + + def run(self): + """运行程序""" + self.root.mainloop() + + + # ====== 市场回调方法 -- 以下方法由XtQuantData调用 ====== + def onDataUpdate(self, data): + # 收集所有市场数据用于市场监控 + print(f'market data update {len(data)}') + + + # ====== 市场回调方法 -- 以下方法由XtQuantTrader调用 ====== + def on_connected(self): + """ + 连接成功推送 + """ + print(datetime.datetime.now(), '连接成功回调') + + def on_disconnected(self): + """ + 连接断开 + :return: + """ + print(datetime.datetime.now(), '连接断开回调') + + def on_stock_order(self, order:XtOrder): + """ + 委托回报推送 + :param order: XtOrder对象 + :return: + """ + print(f'orderd {order.strategy_name}-{order.stock_code} {order.order_id} {order.order_volume}-{order.order_status}') + # 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): + """ + 成交变动推送 + :param trade: XtTrade对象 + :return: + """ + print(f"委托回调 投资备注 {trade.stock_code}-{trade.instrument_name} {trade.strategy_name} 不匹配 {trade.order_remark}") + # stockCode = trade.stock_code + # ctrl:SFGridStrategy = self.stock_trade_ctrl[stockCode] + # # 如果存在对应的StockTradeController，则调用其onDataUpdate方法 + # if ctrl is not None and trade.strategy_name == ctrl.getName(): + # ctrl.onOrderTrade(trade) + # else: + # print(f"委托回调 投资备注 {trade.strategy_name} 不匹配 {ctrl.getName()}") + + def on_order_stock_async_response(self, response:XtOrderResponse): + print(f"委托回调 投资备注 {response.error_msg}{response.strategy_name} {response.order_remark}") + + # stockCode = response.order_remark + # ctrl:SFGridStrategy = self.stock_trade_ctrl[stockCode] + # # 如果存在对应的StockTradeController，则调用其onDataUpdate方法 + # if ctrl is not None and response.strategy_name == ctrl.getName(): + # ctrl.onAsyncOrderResponse(response) + # else: + # print(f"委托回调 投资备注 {response.strategy_name} 不匹配 {ctrl.getName()}") + + def on_order_error(self, order_error): + """ + 委托失败推送 + :param order_error:XtOrderError 对象 + :return: + """ + print(f"\n委托报错回调 {order_error.order_remark} {order_error.error_msg}") + + + def on_account_status(self, status): + """ + :param response: XtAccountStatus 对象 + :return: + """ + print(datetime.datetime.now(), status) \ No newline at end of file diff --git a/core/sfgrid/main_controller.py b/core/sfgrid/main_controller.py new file mode 100644 index 0000000..98efe18 --- /dev/null +++ b/core/sfgrid/main_controller.py @@ -0,0 +1,402 @@ +# coding:utf-8 +from core.sfgrid.model import TradeTarget +from core.eventbus import ActionDisableMarketData, ActionEnableMarketData, ActionEventAddTradeTarget, ActionEventDeleteTradeTarget, ActionEventDisableTrade, ActionEventEnableTrade, EventTradeTargetUpdate, MarketDataUpdate, MarketDataEnabled, MarketDataDisabled, ResultEventTradeDisabled, ResultEventTradeEnabled, ResultEventTradeTargetDeleted, ActionEventGridFix, event_bus +from xtquant.xttrader import XtQuantTrader +import time +from peewee import ModelSelect + +import core.sfgrid.model as model +import sfgrid_config +from core.sfgrid.sfgrid_strategy import SFGridStrategy +from core.util import getInstrumentName, getStockPosition, queryPendingOrder +from xtquant.xttrader import XtQuantTrader +from xtquant.xttype import StockAccount, XtAsset, XtOrder, XtPosition, XtTrade +from xtquant import xtdata +from xtquant.xttrader import XtQuantTraderCallback +import datetime +import core.sfgrid.ui as ui +from core.logger import PrintLog, LogLevel +from core.sfgrid.objects import GridFixData + +# 量化核心控制对象 +class SFGridController(XtQuantTraderCallback): + def __init__(self, account_no: str, miniQmtPath: str): + super().__init__() + + self.registerEventHandler() + self.appUi = ui.TradeTargetUI() + + xtdata.enable_hello = False + + session_id = int(time.time()) + + self.xt_trader: XtQuantTrader = XtQuantTrader(miniQmtPath, session_id) + self.xt_trader.register_callback(self) + self.xt_trader.start() + self.xt_trader.connect() + PrintLog(LogLevel.INFO, f'- [{'成功' if self.xt_trader.connected else '失败'}]市场交易连接: {miniQmtPath}') + if self.xt_trader.connected == False: + self.inited: bool = False + return + else: + self.inited = True + + self.account= StockAccount(account_no, 'STOCK') + PrintLog(LogLevel.INFO, f'- [成功]交易账号对象初始化完成, 账号: {self.account.account_id}') # pyright: ignore[reportAttributeAccessIssue] + subscribe_result = self.xt_trader.subscribe(self.account) + PrintLog(LogLevel.INFO, f'- [{'成功' if subscribe_result == 0 else '失败'}:{subscribe_result}]交易状态订阅') + if subscribe_result == 0: + self.inited = True + else: + self.inited = False + return + self.listening_stock = [] + self.stock_trade_ctrl = {} + self.init_instrument_pool(self.xt_trader, self.account) # type: ignore + + self.seq = None + PrintLog(LogLevel.INFO, '- [成功]三疯交易系统初始化完成') + self.startMarketData() + + def registerEventHandler(self): + event_bus.subscribe(ActionEventEnableTrade, self.onEnableTrade) + event_bus.subscribe(ActionEventDisableTrade, self.onDisableTrade) + event_bus.subscribe(ActionEnableMarketData, self.onMarketDataEnabled) + event_bus.subscribe(ActionDisableMarketData, self.onMarketDataDisabled) + event_bus.subscribe(ActionEventAddTradeTarget, self.onAddTradeTarget) + event_bus.subscribe(ActionEventDeleteTradeTarget, self.onDeleteTradeTarget) + event_bus.subscribe(ActionEventGridFix, self.onGridFix) + + def onDeleteTradeTarget(self, id: int): + """处理删除交易标的事件""" + self.del_trade_target(id) + # 发布删除完成事件 + event_bus.publish(ResultEventTradeTargetDeleted, id) + + def onAddTradeTarget(self, stock_code: str): + """处理添加交易标的事件""" + self.add_trade_target(stock_code) + + def onMarketDataEnabled(self, data): + """处理市场数据监听启用事件""" + self.startMarketData() + + def onMarketDataDisabled(self, data): + """处理市场数据监听禁用事件""" + self.stopMarketData() + + def onEnableTrade(self, id: int): + self.start_stock_trade(id) + + def onDisableTrade(self, id: int): + self.pause_stock_trade(id) + + def onGridFix(self, data: GridFixData): + """处理网格修正事件""" + self.update_trade_target_grid(data) + + def update_trade_target_grid(self, data: GridFixData): + """更新交易标的网格信息""" + try: + target = data.tradeTarget + grid_index = data.grid_index + + # 更新数据库中的网格索引 + target.grid_index = grid_index + target.save() + + # 更新内存中的交易标的 + if target.get_id() in self.instrument_pool: + self.instrument_pool[target.get_id()] = target + + # 更新交易控制器中的网格信息 + if target.stock_code in self.stock_trade_ctrl: + trade_controller: SFGridStrategy = self.stock_trade_ctrl[target.stock_code] + trade_controller.updateGridIndex(grid_index) # type: ignore + + PrintLog(LogLevel.INFO, f"网格修正已应用: {target.stock_code} - {target.stock_name}, 网格索引: {grid_index}") + except Exception as e: + PrintLog(LogLevel.ERROR, f"网格修正更新失败: {str(e)}") + + def hold(self): + self.appUi.run() + + def startMarketData(self): + PrintLog(LogLevel.INFO, '- 启动市场数据订阅') + + self.seq = xtdata.subscribe_whole_quote(['SH', 'SZ'], callback=self.onDataUpdate) + if self.seq == -1: + PrintLog(LogLevel.ERROR, '- 市场数据订阅失败') + else: + event_bus.publish(MarketDataEnabled, True) + PrintLog(LogLevel.INFO, f'- 市场数据订阅成功, 订阅号={self.seq}') + + + + def stopMarketData(self): + PrintLog(LogLevel.INFO, '- 停止市场数据订阅') + + if self.seq is not None and self.seq > 0: + xtdata.unsubscribe_quote(self.seq) + event_bus.publish(MarketDataDisabled, False) + + + def add_trade_target(self, stock_code: str): + try: + stock_name = getInstrumentName(stock_code) + if not stock_name: + PrintLog(LogLevel.ERROR, f'无法获取股票代码 {stock_code} 的名称，请检查代码是否正确') + return + + # 检查是否已存在该标的 + existing_target = model.TradeTarget.get_or_none(model.TradeTarget.stock_code == stock_code) + if existing_target: + PrintLog(LogLevel.INFO, f'交易标的 {stock_code} {stock_name} 已存在') + return + + new_target = model.TradeTarget.create( + stock_name=stock_name, + stock_code=stock_code, + market_price=0.0, + current_position=0, + grid_index=0, + last_trade_price=0.0, + plan_buy_price=0.0, + plan_sell_price=0.0, + current_order_price=0.0, + current_order_no='', + current_order_type='' + ) + new_target.save() + PrintLog(LogLevel.INFO, f'新增交易标的 {stock_code} {stock_name}, {new_target.id}') + # 刷新标的持仓 + pos = getStockPosition(stock_code, self.xt_trader, self.account) # type: ignore + model.TradeTarget.update(current_position=pos).where(model.TradeTarget.stock_code == stock_code).execute() + # 更新标的池 + self.refresh_targets() + # 添加交易控制器 + stockTradeController = SFGridStrategy(new_target, self.xt_trader, self.account) # type: ignore + self.stock_trade_ctrl[stock_code] = stockTradeController + + except Exception as e: + PrintLog(LogLevel.ERROR, f'新增交易标的失败 {stock_code} {e}') + + + def del_trade_target(self, id:int): + try: + # 检查标的是否存在 + if id not in self.instrument_pool: + PrintLog(LogLevel.ERROR, f"交易标的 ID {id} 不存在") + return + + target: model.TradeTarget = self.instrument_pool[id] + + # 如果存在交易控制器，先停止交易 + if target.stock_code in self.stock_trade_ctrl: + # 停止交易控制器 + del self.stock_trade_ctrl[target.stock_code] + + # 从数据库中删除 + target.delete_instance() + + # 从内存中删除 + del self.instrument_pool[id] + + # 刷新标的池 + self.refresh_targets() + + PrintLog(LogLevel.INFO, f"已删除交易标的: {target.stock_code} - {target.stock_name}") + except Exception as e: + PrintLog(LogLevel.ERROR, f"删除交易标的失败 ID {id}: {str(e)}") + + def init_instrument_pool(self, xtTrader:XtQuantTrader, account:StockAccount): + self.refresh_targets() + + for id in self.instrument_pool: + target:TradeTarget = self.instrument_pool[id] + status = "新建" if target.status == 0 else "已建初始仓" + PrintLog(LogLevel.INFO, f' [序号-{id}] 股票代码: {target.stock_code}-{target.stock_name} 当前持仓: {getStockPosition(target.stock_code, self.xt_trader, self.account)} 网格索引: {target.grid_index} 基准价格 {sfgrid_config.grid_price[target.grid_index]} 状态: {status} 启用交易线程: {'自动交易中' if target.enabled else '交易已停止'}') # type: ignore + + tradeTarget:model.TradeTarget = self.instrument_pool[id] + tradeTarget.current_position = getStockPosition(tradeTarget.stock_code, xtTrader, account) # type: ignore + result = tradeTarget.save() + PrintLog(LogLevel.INFO, f' |- 同步[{target.stock_code}-{target.stock_name}]持仓信息[{'成功' if result == 1 else '失败'}]') + stockTradeController = SFGridStrategy(tradeTarget, self.xt_trader, self.account) # type: ignore + self.stock_trade_ctrl[tradeTarget.stock_code] = stockTradeController + event_bus.publish(EventTradeTargetUpdate, tradeTarget) + + PrintLog(LogLevel.INFO, f'- [成功]交易标的信息初始化, 共 {len(self.instrument_pool)} 个标的') + + + def refresh_targets(self): + # 更新标的池 + results:ModelSelect = model.TradeTarget.select() + self.instrument_pool: dict[int, model.TradeTarget] = {} + for temp in results: + result :model.TradeTarget = temp + self.instrument_pool[result.get_id()] = result + + 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 start_stock_trade(self, id: int): + tradeTarget: TradeTarget = self.instrument_pool[id] + # check existing thread + if tradeTarget.stock_code in self.stock_trade_ctrl: + tradeController: SFGridStrategy = self.stock_trade_ctrl[tradeTarget.stock_code] + + tradeTarget = tradeController.enabledTrading(True) + self.instrument_pool[id] = tradeTarget + event_bus.publish(ResultEventTradeEnabled, tradeTarget) + else: + PrintLog(LogLevel.INFO, f"\t创建标的交易控制器 {tradeTarget.stock_code} {getInstrumentName(tradeTarget.stock_code)}") + + + def pause_stock_trade(self, id: int): + localTarget: model.TradeTarget = self.instrument_pool[id] + print(f'暂停标的交易 {localTarget.stock_code} - enabled {localTarget.enabled}') + if localTarget.stock_code in self.stock_trade_ctrl: + tradeController: SFGridStrategy = self.stock_trade_ctrl[localTarget.stock_code] + tradeTarget = tradeController.enabledTrading(False) + orders = queryPendingOrder(localTarget.stock_code, tradeController.getName(), self.xt_trader, self.account) # type: ignore + for order in orders: + self.xt_trader.cancel_order_stock_async(self.account, order.order_id) + print(f'取消未成交订单 {len(orders)}') + self.instrument_pool[id] = tradeTarget + event_bus.publish(ResultEventTradeDisabled, tradeTarget) + else: + print(f"标的交易控制器不存在 {localTarget.stock_code} {localTarget.stock_name}\n") + + + # ====== 市场回调方法 -- 以下方法由XtQuantData调用 ====== + def onDataUpdate(self, data): + # 收集所有市场数据用于市场监控 + for stock_code, tickData in data.items(): + if stock_code in self.stock_trade_ctrl: + stock_controller: SFGridStrategy = self.stock_trade_ctrl[stock_code] + stock_controller.onDataUpdate(data) + else: + # 非目标交易，发布市场数据更新事件用于市场监控 + lastPrice = tickData['lastPrice'] + if lastPrice == 10 or stock_code in self.listening_stock: + # 发布市场数据更新事件用于市场监控 + market_target = TradeTarget() + market_target.stock_code = stock_code + market_target.stock_name = getInstrumentName(stock_code) # type: ignore + market_target.market_price = lastPrice # type: ignore + event_bus.publish(MarketDataUpdate, market_target) + if stock_code not in self.listening_stock: + self.listening_stock.append(stock_code) + + + # ====== 市场回调方法 -- 以下方法由XtQuantTrader调用 ====== + def on_connected(self): + """ + 连接成功推送 + """ + print(datetime.datetime.now(), '连接成功回调') + + def on_disconnected(self): + """ + 连接断开 + :return: + """ + print(datetime.datetime.now(), '连接断开回调') + + def on_stock_order(self, order:XtOrder): + """ + 委托回报推送 + :param order: XtOrder对象 + :return: + """ + print(f'orderd {order.strategy_name}-{order.stock_code} {order.order_id} {order.order_volume}-{order.order_status}') + 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): + """ + 成交变动推送 + :param trade: XtTrade对象 + :return: + """ + stockCode = trade.stock_code + ctrl:SFGridStrategy = self.stock_trade_ctrl[stockCode] + # 如果存在对应的StockTradeController，则调用其onDataUpdate方法 + if ctrl is not None and trade.strategy_name == ctrl.getName(): + ctrl.onOrderTrade(trade) + else: + print(f"委托回调 投资备注 {trade.strategy_name} 不匹配 {ctrl.getName()}") + + # def on_order_stock_async_response(self, response:XtOrderResponse): + # stockCode = response.order_remark + # ctrl:SFGridStrategy = self.stock_trade_ctrl[stockCode] + # # 如果存在对应的StockTradeController，则调用其onDataUpdate方法 + # if ctrl is not None and response.strategy_name == ctrl.getName(): + # ctrl.onAsyncOrderResponse(response) + # else: + # print(f"委托回调 投资备注 {response.strategy_name} 不匹配 {ctrl.getName()}") + + def on_order_error(self, order_error): + """ + 委托失败推送 + :param order_error:XtOrderError 对象 + :return: + """ + # print("on order_error callback") + # print(order_error.order_id, order_error.error_id, order_error.error_msg) + print(f"\n委托报错回调 {order_error.order_remark} {order_error.error_msg}") + + + def on_account_status(self, status): + """ + :param response: XtAccountStatus 对象 + :return: + """ + print(datetime.datetime.now(), status) \ No newline at end of file diff --git a/core/strategy_db.py b/core/sfgrid/model.py similarity index 63% rename from core/strategy_db.py rename to core/sfgrid/model.py index 784d021..d17de04 100644 --- a/core/strategy_db.py +++ b/core/sfgrid/model.py @@ -1,19 +1,7 @@ -from peewee import SqliteDatabase, Model, CharField, IntegerField, FloatField, BooleanField +from peewee import CharField, IntegerField, FloatField, BooleanField -from xtquant import xtconstant +from core.database import BaseModel, db -# 连接到SQLite数据库 -db = SqliteDatabase('example.db') - -# 定义基础模型类 -class BaseModel(Model): - class Meta: - database = db - -OrderTypeBuy = f'{xtconstant.STOCK_BUY}' # 买 -OrderTypeSell = f'{xtconstant.STOCK_SELL}' # 卖 -OrderTypeInit = "0" # 建仓 -OrderTypeNone = "None" # 定义Target类，对应targets表 class TradeTarget(BaseModel): @@ -33,3 +21,6 @@ class TradeTarget(BaseModel): def targetName(self): return f'{self.stock_name}[{self.stock_code}]' + + +db.create_tables([TradeTarget]) \ No newline at end of file diff --git a/core/objects.py b/core/sfgrid/objects.py similarity index 79% rename from core/objects.py rename to core/sfgrid/objects.py index 2156859..f8a6f47 100644 --- a/core/objects.py +++ b/core/sfgrid/objects.py @@ -1,4 +1,4 @@ -from core.strategy_db import TradeTarget +from core.sfgrid.model import TradeTarget class GridFixData: diff --git a/core/sfgrid_strategy.py b/core/sfgrid/sfgrid_strategy.py similarity index 87% rename from core/sfgrid_strategy.py rename to core/sfgrid/sfgrid_strategy.py index b6b6817..faafe4b 100644 --- a/core/sfgrid_strategy.py +++ b/core/sfgrid/sfgrid_strategy.py @@ -1,18 +1,19 @@ -from core import strategy_db +import core.sfgrid.model as model +from core import constants from core.eventbus import EventTradeTargetUpdate, event_bus -from core.strategy_db import OrderTypeBuy, OrderTypeInit, OrderTypeSell, TradeTarget +from core.constants import OrderTypeBuy, OrderTypeInit, OrderTypeSell from core.util import queryPendingOrder, is_trading_time from xtquant import xttrader, xtconstant from xtquant.xttype import StockAccount, XtOrder, XtTrade -import sfgrid_constants +import sfgrid_config import threading class SFGridStrategy: - def __init__(self, tradeTarget: TradeTarget, xt_trader: xttrader.XtQuantTrader, account: StockAccount): - self.tradeTarget:TradeTarget = tradeTarget + def __init__(self, tradeTarget: model.TradeTarget, xt_trader: xttrader.XtQuantTrader, account: StockAccount): + self.tradeTarget:model.TradeTarget = tradeTarget self.xt_trader: xttrader.XtQuantTrader = xt_trader self.account:StockAccount = account self.enabledTrading(bool(tradeTarget.enabled)) # 修复类型兼容性问题 @@ -26,7 +27,7 @@ class SFGridStrategy: self.refreshPlanPrice() self.saveProxy() - def enabledTrading(self, enabled: bool) -> TradeTarget: + def enabledTrading(self, enabled: bool) -> model.TradeTarget: self.tradeTarget.enabled = enabled # type: ignore self.saveProxy() @@ -39,7 +40,7 @@ class SFGridStrategy: else: # 已建仓 # 交易阶段，检查仓位，检查现有订单 print(f" |- 标的{self.tradeTarget.targetName()}已有仓位或非初始状态 无需建初始仓 当前仓位: {self.tradeTarget.current_position} 状态: {self.tradeTarget.status}") - minRequirePosition:int = sfgrid_constants.grid_volume * int(self.tradeTarget.grid_index) # type: ignore + minRequirePosition:int = sfgrid_config.grid_volume * int(self.tradeTarget.grid_index) # type: ignore if minRequirePosition <= int(self.tradeTarget.current_position): # type: ignore print(f' |- 仓位检查: 持仓需求充足, (gridVolume*gridIndex)={minRequirePosition}, 当前持仓：{self.tradeTarget.current_position}') else: @@ -78,16 +79,16 @@ class SFGridStrategy: index: int = self.tradeTarget.grid_index # pyright: ignore[reportAssignmentType] orderRemark= "" - gridBasePrice = -1 if index>=len(sfgrid_constants.grid_price) or index < 0 else sfgrid_constants.grid_price[int(index)] # pyright: ignore[reportArgumentType] + gridBasePrice = -1 if index>=len(sfgrid_config.grid_price) or index < 0 else sfgrid_config.grid_price[int(index)] # pyright: ignore[reportArgumentType] - if self.tradeTarget.enabled and self.tradeTarget.status == 0 and lastPrice <= sfgrid_constants.grid_price[1]: # 已启用，未建仓，建仓 - orderPrice = sfgrid_constants.grid_price[index] + if self.tradeTarget.enabled and self.tradeTarget.status == 0 and lastPrice <= sfgrid_config.grid_price[1]: # 已启用，未建仓，建仓 + orderPrice = sfgrid_config.grid_price[index] orderType = xtconstant.STOCK_BUY orderRemark = OrderTypeInit if self.tradeTarget.enabled and self.tradeTarget.status == 1: # 已启用，已建仓，网格单 - lowPrice = -1 if index+1>=len(sfgrid_constants.grid_price) else sfgrid_constants.grid_price[int(index) + 1] # pyright: ignore[reportArgumentType] - highPrice = sfgrid_constants.grid_price[index - 1] + lowPrice = -1 if index+1>=len(sfgrid_config.grid_price) else sfgrid_config.grid_price[int(index) + 1] # pyright: ignore[reportArgumentType] + highPrice = sfgrid_config.grid_price[index - 1] if lastPrice <= lowPrice: # 下下方多单 orderPrice = lowPrice @@ -110,7 +111,7 @@ class SFGridStrategy: self.account, str(self.tradeTarget.stock_code), orderType, - sfgrid_constants.grid_volume, + sfgrid_config.grid_volume, xtconstant.FIX_PRICE, orderPrice, self.getName(), # strategy_name @@ -123,7 +124,7 @@ class SFGridStrategy: orderTypeName = "空单" elif orderRemark == OrderTypeInit: orderTypeName = "建仓单" - print(f' |- {orderTypeName}委托, 单号 {self.tradeTarget.current_order_no}, 网格基准价 {gridBasePrice}, 下单价 {orderPrice}, 下单量 {sfgrid_constants.grid_volume}') + print(f' |- {orderTypeName}委托, 单号 {self.tradeTarget.current_order_no}, 网格基准价 {gridBasePrice}, 下单价 {orderPrice}, 下单量 {sfgrid_config.grid_volume}') finally: print(f'|- 市价更新[{self.tradeTarget.stock_code}-{self.tradeTarget.stock_name}] - release lock') self.saveProxy() @@ -156,13 +157,13 @@ class SFGridStrategy: if not trade.strategy_name == self.getName(): print(f' |- 委托成交通知[{self.tradeTarget.stock_code}-{self.tradeTarget.stock_name}-{trade.order_id}]: 不在策略监控范围内{trade.strategy_name}') return - if self.tradeTarget.status == 0 and trade.order_id == self.tradeTarget.current_order_no and trade.order_remark == strategy_db.OrderTypeInit: + if self.tradeTarget.status == 0 and trade.order_id == self.tradeTarget.current_order_no and trade.order_remark == constants.OrderTypeInit: # 此时为建仓成交 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.plan_buy_price = float(sfgrid_constants.grid_price[2]) # type: ignore - self.tradeTarget.plan_sell_price = float(sfgrid_constants.grid_price[0]) # type: ignore + self.tradeTarget.plan_buy_price = float(sfgrid_config.grid_price[2]) # type: ignore + self.tradeTarget.plan_sell_price = float(sfgrid_config.grid_price[0]) # type: ignore self.tradeTarget.status = 1 # type: ignore self.saveProxy() print(f"|- 标的{self.tradeTarget.stock_code}-{self.tradeTarget.stock_name} 建初始仓订单ID: {self.tradeTarget.current_order_no}已成交 ") @@ -174,7 +175,7 @@ class SFGridStrategy: 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 - print(f"|- 标的{self.tradeTarget.stock_code}-{self.tradeTarget.stock_name} 上涨 卖单已成交 订单ID: {self.tradeTarget.current_order_no} Price: {sfgrid_constants.grid_price[int(self.tradeTarget.grid_index)]} Volume: {sfgrid_constants.grid_volume} 手续费: {trade.commission}\n") # type: ignore + print(f"|- 标的{self.tradeTarget.stock_code}-{self.tradeTarget.stock_name} 上涨 卖单已成交 订单ID: {self.tradeTarget.current_order_no} Price: {sfgrid_config.grid_price[int(self.tradeTarget.grid_index)]} Volume: {sfgrid_config.grid_volume} 手续费: {trade.commission}\n") # type: ignore print(f' 成交价: {trade.traded_price} 成交量: {trade.traded_volume}') print(f' 当前持仓: {self.tradeTarget.current_position}') print(f' 网格坐标: {self.tradeTarget.grid_index}') @@ -183,7 +184,7 @@ class SFGridStrategy: 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 - print(f"|- 标的{self.tradeTarget.stock_code}-{self.tradeTarget.stock_name} 下跌 买单已成交 订单ID: {self.tradeTarget.current_order_no} Price: {trade.traded_price} Volume: {sfgrid_constants.grid_volume} 手续费: {trade.commission}") + print(f"|- 标的{self.tradeTarget.stock_code}-{self.tradeTarget.stock_name} 下跌 买单已成交 订单ID: {self.tradeTarget.current_order_no} Price: {trade.traded_price} Volume: {sfgrid_config.grid_volume} 手续费: {trade.commission}") print(f' 成交价: {trade.traded_price} 成交量: {trade.traded_volume}') print(f' 当前持仓: {self.tradeTarget.current_position}') print(f' 网格坐标: {self.tradeTarget.grid_index}') @@ -201,11 +202,11 @@ class SFGridStrategy: 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(sfgrid_constants.grid_price[sellIdx]) # pyright: ignore[reportAttributeAccessIssue] + self.tradeTarget.plan_sell_price = float(sfgrid_config.grid_price[sellIdx]) # pyright: ignore[reportAttributeAccessIssue] else: self.tradeTarget.plan_sell_price = -1.0 # type: ignore - if self.tradeTarget.grid_index < len(sfgrid_constants.grid_price) - 1: - self.tradeTarget.plan_buy_price = float(sfgrid_constants.grid_price[buyIdx]) # pyright: ignore[reportAttributeAccessIssue] + if self.tradeTarget.grid_index < len(sfgrid_config.grid_price) - 1: + self.tradeTarget.plan_buy_price = float(sfgrid_config.grid_price[buyIdx]) # pyright: ignore[reportAttributeAccessIssue] else: self.tradeTarget.plan_buy_price = -1.0 # pyright: ignore[reportAttributeAccessIssue] else: diff --git a/core/ui.py b/core/sfgrid/ui.py similarity index 88% rename from core/ui.py rename to core/sfgrid/ui.py index 33588ff..0a11e71 100644 --- a/core/ui.py +++ b/core/sfgrid/ui.py @@ -8,15 +8,20 @@ import threading import time import core.eventbus as eBus from core.logger import LogData, LogLevel -from core.strategy_db import TradeTarget +from core.sfgrid.model import TradeTarget, db import configparser -import sfgrid_constants -from core.objects import GridFixData +import sfgrid_config +from core.sfgrid.objects import GridFixData from core.util import getInstrumentName -class TradeTargetUI: - def __init__(self): +class TradeTargetUI(ttk.Frame): + def __init__(self, parent, main_window): + super().__init__(parent) + + # 保存主窗口的引用，用于访问全局日志 + self.main_window = main_window + self.tradeTargetData:dict[int, TradeTarget] = {} self.market_data_enabled = False # 添加市场数据监听状态变量 self.ui_refresh_enabled = False # 添加UI刷新线程状态变量 @@ -28,9 +33,6 @@ class TradeTargetUI: # 市场监控数据 self.marketData: dict[str, Any] = {} # 存储市场数据 {stock_code: {stock_name, last_price, time}} - self.root = tk.Tk() - self.root.title("三疯交易系统") - self.root.geometry("1400x700") # 创建界面 self.create_ui() @@ -56,8 +58,7 @@ class TradeTargetUI: """刷新循环""" while self.refresh_thread_running: # 在主线程中更新UI - if hasattr(self, 'root') and self.root: - self.root.after(0, self.refresh_table) + self.after(0, self.refresh_table) time.sleep(0.5) # 每0.5秒刷新一次 def stop_refresh_thread(self): @@ -104,11 +105,8 @@ class TradeTargetUI: def create_ui(self): """创建UI界面""" - # 创建菜单栏 - self.create_menu_bar() - - # 主框架 - main_frame = ttk.Frame(self.root) + # 主框架（使用self作为父容器） + main_frame = ttk.Frame(self) main_frame.pack(fill=tk.BOTH, expand=True, padx=10, pady=10) # 创建工具栏 @@ -141,15 +139,6 @@ class TradeTargetUI: # ) # self.market_data_switch.pack(side=tk.LEFT, padx=2) - # 日志显示/隐藏按钮 - self.log_toggle_btn = ttk.Button(toolbar_frame, text="📋 显示日志", - command=self.toggle_log_panel, width=12) - self.log_toggle_btn.pack(side=tk.LEFT, padx=2) - - # 添加清空日志按钮 - ttk.Button(toolbar_frame, text="🗑 清空日志", - command=self.clear_logs, width=12).pack(side=tk.LEFT, padx=2) - # 表格区域 self.create_tables_area(main_frame) @@ -180,24 +169,7 @@ class TradeTargetUI: self.refresh_thread_running = False self.add_log(LogLevel.INFO, "UI刷新线程已停止") - def create_menu_bar(self): - """创建菜单栏""" - menubar = tk.Menu(self.root) - self.root.config(menu=menubar) - - # 系统菜单 - system_menu = tk.Menu(menubar, tearoff=0) - menubar.add_cascade(label="系统", menu=system_menu) - system_menu.add_command(label="系统设置", command=self.system_settings) - system_menu.add_separator() - system_menu.add_command(label="退出", command=self.on_exit) - - def on_exit(self): - """退出程序""" - # 停止刷新线程 - self.stop_refresh_thread() - # 关闭窗口 - self.root.destroy() + def create_tables_area(self, parent): """创建表格区域""" @@ -218,15 +190,6 @@ class TradeTargetUI: # 创建市场监控表格 self.create_market_monitor_table(market_frame) - - # 下方操作日志区域(默认隐藏) - self.log_frame = ttk.LabelFrame(parent, text="操作日志", padding=10) - # 默认不显示,通过工具栏按钮控制 - # self.log_frame.pack(fill=tk.X, pady=(5, 0)) - self.log_visible = False # 日志区域可见性标志 - - # 创建操作日志表格 - self.create_log_table(self.log_frame) def create_trade_target_table(self, parent): """创建交易标的表格""" @@ -395,37 +358,7 @@ class TradeTargetUI: self.trade_table.insert('', tk.END, values=values) - def create_log_table(self, parent): - """创建操作日志表格""" - columns = ("timestamp", "level", "message") - - self.log_table = ttk.Treeview(parent, columns=columns, show='headings', height=8) - - log_column_configs = { - "timestamp": ("时间", 100), - "level": ("级别", 50), - "message": ("消息", 850) - } - - for col in columns: - title, width = log_column_configs[col] - self.log_table.heading(col, text=title) - self.log_table.column(col, width=width, anchor=tk.W) - - # 填充示例日志 - sample_logs = [ - ("2024-01-15 10:30:15", "INFO", "系统启动成功"), - ] - - for log in sample_logs: - self.log_table.insert('', tk.END, values=log) - - # 滚动条 - scrollbar = ttk.Scrollbar(parent, orient=tk.VERTICAL, command=self.log_table.yview) - self.log_table.configure(yscrollcommand=scrollbar.set) - - self.log_table.pack(side=tk.LEFT, fill=tk.BOTH, expand=True) - scrollbar.pack(side=tk.RIGHT, fill=tk.Y) + def get_status_text(self, status): """获取状态文本""" @@ -533,20 +466,23 @@ class TradeTargetUI: def add_trade_target(self): """添加新的交易标的""" + # 获取顶层窗口 + root = self.winfo_toplevel() + # 创建顶层窗口 - add_window = tk.Toplevel(self.root) + add_window = tk.Toplevel(root) add_window.title("添加交易标的") add_window.geometry("400x150") add_window.resizable(False, False) # 设置窗口模态 - add_window.transient(self.root) + add_window.transient(root) add_window.grab_set() # 居中显示 - self.root.update_idletasks() - x = self.root.winfo_x() + (self.root.winfo_width() // 2) - 200 - y = self.root.winfo_y() + (self.root.winfo_height() // 2) - 75 + root.update_idletasks() + x = root.winfo_x() + (root.winfo_width() // 2) - 200 + y = root.winfo_y() + (root.winfo_height() // 2) - 75 add_window.geometry(f"400x150+{x}+{y}") # 创建输入框架 @@ -585,18 +521,7 @@ class TradeTargetUI: self.add_log(LogLevel.INFO, "点击添加交易标的按钮") - def toggle_log_panel(self): - """切换日志面板的显示/隐藏""" - if self.log_visible: - # 隐藏日志面板 - self.log_frame.pack_forget() - self.log_visible = False - self.log_toggle_btn.config(text="📋 显示日志") - else: - # 显示日志面板 - self.log_frame.pack(fill=tk.X, pady=(5, 0)) - self.log_visible = True - self.log_toggle_btn.config(text="📋 隐藏日志") + def refresh_table(self): """刷新表格数据""" @@ -626,23 +551,19 @@ class TradeTargetUI: self.populate_market_table() def onLog(self, data:LogData): - self.add_log(data.level, data.message) + # 使用全局日志 + self.main_window.add_log(data.level, data.message) def add_log(self, level:LogLevel, message): - """添加日志记录""" - timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S") - self.log_table.insert('', 0, values=(timestamp, level.value, message)) - - def clear_logs(self): - """清空日志记录""" - # 删除所有日志项 - for item in self.log_table.get_children(): - self.log_table.delete(item) - self.add_log(LogLevel.DEBUG, "日志已清空") + """添加日志记录 - 转发到全局日志""" + self.main_window.add_log(level, message) def system_settings(self): """系统设置""" - settings_window = tk.Toplevel(self.root) + # 获取顶层窗口 + root = self.winfo_toplevel() + + settings_window = tk.Toplevel(root) settings_window.title("网格交易系统配置") # 设置窗口大小 @@ -650,17 +571,17 @@ class TradeTargetUI: window_height = 550 # 先设置为模态窗口 - settings_window.transient(self.root) + settings_window.transient(root) # 确保主窗口完全初始化 - self.root.update_idletasks() + root.update_idletasks() # 获取主窗口的实际大小（包括边框） # 使用winfo_rootx/rooty获取窗口在屏幕上的绝对位置 - main_x = self.root.winfo_rootx() - main_y = self.root.winfo_rooty() - main_width = self.root.winfo_width() - main_height = self.root.winfo_height() + main_x = root.winfo_rootx() + main_y = root.winfo_rooty() + main_width = root.winfo_width() + main_height = root.winfo_height() # 计算设置窗口相对于主窗口的居中位置 x = main_x + (main_width - window_width) // 2 @@ -691,7 +612,7 @@ class TradeTargetUI: # 读取当前配置 config = configparser.ConfigParser() - config_path = sfgrid_constants.get_config_path() + config_path = sfgrid_config.get_config_path() config.read(config_path, encoding='utf-8') # 创建输入框字典用于保存引用 @@ -918,12 +839,12 @@ class TradeTargetUI: config.set('config', 'account_no', entries['account_no'].get()) # 写入配置文件 - config_path = sfgrid_constants.get_config_path() + config_path = sfgrid_config.get_config_path() with open(config_path, 'w', encoding='utf-8') as configfile: config.write(configfile) # 重新加载配置到内存中 - sfgrid_constants.initConfig() + sfgrid_config.initConfig() messagebox.showinfo("成功", f"配置已保存！\n网格价格序列: {grid_price_str}\n部分配置可能需要重启程序后生效。") self.add_log(LogLevel.INFO, f"系统配置已更新 - 网格数量: {len(grid_prices)}") @@ -952,20 +873,23 @@ class TradeTargetUI: def create_grid_correction_window(self, target: TradeTarget): """创建网格修正窗口""" + # 获取顶层窗口 + root = self.winfo_toplevel() + # 创建顶层窗口 - correction_window = tk.Toplevel(self.root) + correction_window = tk.Toplevel(root) correction_window.title(f"网格修正 - {target.stock_code} ({target.stock_name})") correction_window.geometry("500x400") correction_window.resizable(False, False) # 设置窗口模态 - correction_window.transient(self.root) + correction_window.transient(root) correction_window.grab_set() # 居中显示 - self.root.update_idletasks() - x = self.root.winfo_x() + (self.root.winfo_width() // 2) - 250 - y = self.root.winfo_y() + (self.root.winfo_height() // 2) - 200 + root.update_idletasks() + x = root.winfo_x() + (root.winfo_width() // 2) - 250 + y = root.winfo_y() + (root.winfo_height() // 2) - 200 correction_window.geometry(f"500x400+{x}+{y}") # 创建主框架 @@ -1005,7 +929,7 @@ class TradeTargetUI: required_position_frame.pack(fill=tk.X, pady=5) grid_index_value = getattr(target, 'grid_index') - required_position = grid_index_value * sfgrid_constants.grid_volume + required_position = grid_index_value * sfgrid_config.grid_volume ttk.Label(required_position_frame, text="需求持仓量:", width=12).pack(side=tk.LEFT) required_position_label = ttk.Label(required_position_frame, text=str(required_position), width=10, anchor=tk.CENTER) required_position_label.pack(side=tk.LEFT, padx=5) @@ -1030,7 +954,7 @@ class TradeTargetUI: # 增加按钮 ttk.Button(grid_index_frame, text="+", width=3, - command=lambda: self.increase_grid_index(grid_index_var, len(sfgrid_constants.grid_price)-1, target, required_position_label, position_status_label)).pack(side=tk.LEFT, padx=(5, 0)) + command=lambda: self.increase_grid_index(grid_index_var, len(sfgrid_config.grid_price)-1, target, required_position_label, position_status_label)).pack(side=tk.LEFT, padx=(5, 0)) # 当前价格（实时更新） price_frame = ttk.Frame(options_frame) @@ -1087,7 +1011,7 @@ class TradeTargetUI: setattr(target, 'grid_index', new_grid_index) # 重新计算需求持仓量 - required_position = new_grid_index * sfgrid_constants.grid_volume + required_position = new_grid_index * sfgrid_config.grid_volume # 检查持仓量是否满足要求 current_position = getattr(target, 'current_position') @@ -1111,9 +1035,7 @@ class TradeTargetUI: # 添加日志 self.add_log(LogLevel.INFO, f"网格修正已保存: {target.stock_code} - {target.stock_name}, 网格序号: {new_grid_index}") - def run(self): - """运行程序""" - self.root.mainloop() + def decrease_grid_index(self, grid_index_var: tk.IntVar, target: TradeTarget, required_position_label: ttk.Label, position_status_label: ttk.Label): """减少网格序号""" @@ -1134,7 +1056,7 @@ class TradeTargetUI: def update_required_position_and_status(self, grid_index: int, target: TradeTarget, required_position_label: ttk.Label, position_status_label: ttk.Label): """更新需求持仓量和持仓状态""" # 计算需求持仓量 - required_position = grid_index * sfgrid_constants.grid_volume + required_position = grid_index * sfgrid_config.grid_volume required_position_label.config(text=str(required_position)) # 更新持仓量状态 diff --git a/core/util.py b/core/util.py index 05052ef..1371717 100644 --- a/core/util.py +++ b/core/util.py @@ -1,4 +1,4 @@ -import sfgrid_constants +import sfgrid_config import xtquant.xtconstant as xtconstant from xtquant import xtdata, xttrader from xtquant.xttype import StockAccount, XtOrder, XtPosition @@ -58,7 +58,7 @@ def getStockPosition(stock_code: str, xt_trader: xttrader.XtQuantTrader, account return volume def minPosition(gridIndex:int): - return sfgrid_constants.grid_volume * gridIndex + return sfgrid_config.grid_volume * gridIndex def queryPendingOrder(stock_code:str, tag: str, xt_trader: xttrader.XtQuantTrader, account: StockAccount) -> list[XtOrder]: if stock_code == None or tag == None: diff --git a/sfgrid_constants.py b/sfgrid_config.py similarity index 89% rename from sfgrid_constants.py rename to sfgrid_config.py index 1358a93..92afdaf 100644 --- a/sfgrid_constants.py +++ b/sfgrid_config.py @@ -1,6 +1,6 @@ from typing import List import configparser -import os +from pathlib import Path import sys # miniQMTPath = r'D:\\Programs\\DTQMT_MN\\userdata_mini' # miniQMT软件的安装路径 @@ -10,20 +10,21 @@ miniQMTPath = r'D:\\Programs\\DTQMT\\userdata_mini' # miniQMT软件的安装路 grid_price:List[float] = [] # 网格价格设置，从高到低 grid_volume:int = 100 # 每个网格的交易手数 account_no:str = '99082560' +console_log = True # account_no:str = '89009170' # 交易账号 -def get_config_path(): +def get_config_path() -> Path: """获取配置文件的正确路径（兼容开发环境和打包后的可执行文件）""" if getattr(sys, 'frozen', False): # 打包后的可执行文件环境 # sys._MEIPASS是PyInstaller解压临时文件的目录 # 配置文件应该放在可执行文件同目录下 - base_path = os.path.dirname(sys.executable) + base_path = Path(sys.executable).parent else: # 开发环境 - base_path = os.path.dirname(os.path.abspath(__file__)) + base_path = Path(__file__).resolve().parent - return os.path.join(base_path, 'config.ini') + return base_path / 'config.ini' def create_default_config(): """创建默认配置文件""" @@ -46,7 +47,7 @@ def initConfig(): config_path = get_config_path() # 检查配置文件是否存在，不存在则创建 - if not os.path.exists(config_path): + if not config_path.exists(): create_default_config() config = configparser.ConfigParser() diff --git a/starter.py b/starter.py index be7e0b3..83c3b7c 100644 --- a/starter.py +++ b/starter.py @@ -1,20 +1,21 @@ # coding:utf-8 -from core import strategy_db -from core.main_controller import SFGridController +from core.database import db +from core.main_ui import MainWindow +from core.sfgrid.main_controller import SFGridController from core.logger import LogLevel, PrintLog -import sfgrid_constants as sdConstants +import sfgrid_config as sdConstants -def startTrade(index: int): - ctrl.start_stock_trade(index) +# def startTrade(index: int): +# ctrl.start_stock_trade(index) -def pauseTrade(index: int): - ctrl.pause_stock_trade(index) +# def pauseTrade(index: int): +# ctrl.pause_stock_trade(index) if __name__ == '__main__': sdConstants.initConfig() - strategy_db.db.connect() - strategy_db.db.create_tables([strategy_db.TradeTarget]) - PrintLog(LogLevel.INFO, '- [成功]数据库模块初始化') - ctrl: SFGridController = SFGridController(sdConstants.account_no, sdConstants.miniQMTPath) + # ctrl: SFGridController = SFGridController(sdConstants.account_no, sdConstants.miniQMTPath) - ctrl.hold() + # ctrl.hold() + + window = MainWindow() + window.run() diff --git a/starter.spec b/starter.spec index 935fc84..b44d58c 100644 --- a/starter.spec +++ b/starter.spec @@ -28,7 +28,7 @@ exe = EXE( upx=True, upx_exclude=[], runtime_tmpdir=None, - console=False, + console=True, disable_windowed_traceback=False, argv_emulation=False, target_arch=None, From 662a1ea7c10ccb9e9ea06239fa6b89cfbbf74ddd Mon Sep 17 00:00:00 2001 From: "GDP\\solonot" Date: Tue, 11 Nov 2025 16:47:55 +0800 Subject: [PATCH 4/9] update --- sfgrid_config.py => config.py | 0 core/database.py | 10 +- core/logger.py | 4 +- core/main_controller.py | 306 ------------------ core/main_ui.py | 114 +------ core/qmt.py | 203 ++++++++++++ core/sfgrid/model.py | 4 +- core/sfgrid/objects.py | 2 +- ...ain_controller.py => sfgrid_controller.py} | 103 ++---- core/sfgrid/sfgrid_strategy.py | 50 ++- core/sfgrid/{ui.py => sfgrid_ui.py} | 182 ++++++----- core/util.py | 4 +- starter.py | 17 +- 13 files changed, 361 insertions(+), 638 deletions(-) rename sfgrid_config.py => config.py (100%) delete mode 100644 core/main_controller.py create mode 100644 core/qmt.py rename core/sfgrid/{main_controller.py => sfgrid_controller.py} (75%) rename core/sfgrid/{ui.py => sfgrid_ui.py} (86%) diff --git a/sfgrid_config.py b/config.py similarity index 100% rename from sfgrid_config.py rename to config.py diff --git a/core/database.py b/core/database.py index 3629252..2631fa0 100644 --- a/core/database.py +++ b/core/database.py @@ -1,14 +1,12 @@ -from peewee import SqliteDatabase, Model, CharField, IntegerField, FloatField, BooleanField - +from peewee import SqliteDatabase, Model from core.logger import LogLevel, PrintLog -from xtquant import xtconstant # 连接到SQLite数据库 -db = SqliteDatabase('example.db') - +db: SqliteDatabase = SqliteDatabase('example.db') db.connect() PrintLog(LogLevel.INFO, '- [成功]数据库连接') + # 定义基础模型类 class BaseModel(Model): class Meta: - database = db \ No newline at end of file + database: SqliteDatabase = db \ No newline at end of file diff --git a/core/logger.py b/core/logger.py index a306836..896e46a 100644 --- a/core/logger.py +++ b/core/logger.py @@ -1,7 +1,7 @@ from enum import Enum from core.eventbus import EventPrintLog, event_bus -import sfgrid_config +import config class LogLevel(Enum): DEBUG = "DEBUG" @@ -18,5 +18,5 @@ class LogData: def PrintLog(level:LogLevel, message:str): data = LogData(level, message) event_bus.publish(EventPrintLog, data) - if sfgrid_config.console_log: + if config.console_log: print(f'{level.value} {message}') diff --git a/core/main_controller.py b/core/main_controller.py deleted file mode 100644 index 7ac52a4..0000000 --- a/core/main_controller.py +++ /dev/null @@ -1,306 +0,0 @@ -# coding:utf-8 -from core.sfgrid.model import TradeTarget -from core.eventbus import ActionDisableMarketData, ActionEnableMarketData, ActionEventAddTradeTarget, ActionEventDeleteTradeTarget, ActionEventDisableTrade, ActionEventEnableTrade, EventTradeTargetUpdate, MarketDataUpdate, MarketDataEnabled, MarketDataDisabled, ResultEventTradeDisabled, ResultEventTradeEnabled, ResultEventTradeTargetDeleted, ActionEventGridFix, event_bus -from xtquant.xttrader import XtQuantTrader -import time -from peewee import ModelSelect - -import core.sfgrid.model as model -import sfgrid_config -from core.sfgrid.sfgrid_strategy import SFGridStrategy -from core.util import getInstrumentName, getStockPosition, queryPendingOrder -from xtquant.xttrader import XtQuantTrader -from xtquant.xttype import StockAccount, XtAsset, XtOrder, XtPosition, XtTrade -from xtquant import xtdata -from xtquant.xttrader import XtQuantTraderCallback -import datetime -import core.sfgrid.ui as ui -from core.logger import PrintLog, LogLevel -from core.sfgrid.objects import GridFixData - -# 量化核心控制对象 -class MainController(XtQuantTraderCallback): - def __init__(self, account_no: str, miniQmtPath: str): - super().__init__() - - self.registerEventHandler() - # self.appUi = ui.TradeTargetUI() - - xtdata.enable_hello = False - - session_id = int(time.time()) - - self.xt_trader: XtQuantTrader = XtQuantTrader(miniQmtPath, session_id) - self.xt_trader.register_callback(self) - self.xt_trader.start() - self.xt_trader.connect() - PrintLog(LogLevel.INFO, f'- [{'成功' if self.xt_trader.connected else '失败'}]市场交易连接: {miniQmtPath}') - if self.xt_trader.connected == False: - self.inited: bool = False - return - else: - self.inited = True - - self.account= StockAccount(account_no, 'STOCK') - PrintLog(LogLevel.INFO, f'- [成功]交易账号对象初始化完成, 账号: {self.account.account_id}') # pyright: ignore[reportAttributeAccessIssue] - subscribe_result = self.xt_trader.subscribe(self.account) - PrintLog(LogLevel.INFO, f'- [{'成功' if subscribe_result == 0 else '失败'}:{subscribe_result}]交易状态订阅') - if subscribe_result == 0: - self.inited = True - else: - self.inited = False - return - self.listening_stock = [] - self.stock_trade_ctrl = {} - self.init_instrument_pool(self.xt_trader, self.account) # type: ignore - - self.seq = None - PrintLog(LogLevel.INFO, '- [成功]三疯交易系统初始化完成') - self.startMarketData() - - def registerEventHandler(self): - event_bus.subscribe(ActionEventEnableTrade, self.onEnableTrade) - event_bus.subscribe(ActionEventDisableTrade, self.onDisableTrade) - event_bus.subscribe(ActionEnableMarketData, self.onMarketDataEnabled) - event_bus.subscribe(ActionDisableMarketData, self.onMarketDataDisabled) - event_bus.subscribe(ActionEventAddTradeTarget, self.onAddTradeTarget) - event_bus.subscribe(ActionEventDeleteTradeTarget, self.onDeleteTradeTarget) - event_bus.subscribe(ActionEventGridFix, self.onGridFix) - - def onDeleteTradeTarget(self, id: int): - """处理删除交易标的事件""" - self.del_trade_target(id) - # 发布删除完成事件 - event_bus.publish(ResultEventTradeTargetDeleted, id) - - def onAddTradeTarget(self, stock_code: str): - """处理添加交易标的事件""" - self.add_trade_target(stock_code) - - def onMarketDataEnabled(self, data): - """处理市场数据监听启用事件""" - self.startMarketData() - - def onMarketDataDisabled(self, data): - """处理市场数据监听禁用事件""" - self.stopMarketData() - - def onEnableTrade(self, id: int): - self.start_stock_trade(id) - - def onDisableTrade(self, id: int): - self.pause_stock_trade(id) - - def onGridFix(self, data: GridFixData): - """处理网格修正事件""" - self.update_trade_target_grid(data) - - def update_trade_target_grid(self, data: GridFixData): - """更新交易标的网格信息""" - try: - target = data.tradeTarget - grid_index = data.grid_index - - # 更新数据库中的网格索引 - target.grid_index = grid_index - target.save() - - # 更新内存中的交易标的 - if target.get_id() in self.instrument_pool: - self.instrument_pool[target.get_id()] = target - - # 更新交易控制器中的网格信息 - if target.stock_code in self.stock_trade_ctrl: - trade_controller: SFGridStrategy = self.stock_trade_ctrl[target.stock_code] - trade_controller.updateGridIndex(grid_index) # type: ignore - - PrintLog(LogLevel.INFO, f"网格修正已应用: {target.stock_code} - {target.stock_name}, 网格索引: {grid_index}") - except Exception as e: - PrintLog(LogLevel.ERROR, f"网格修正更新失败: {str(e)}") - - def startMarketData(self): - PrintLog(LogLevel.INFO, '- 启动市场数据订阅') - - # self.seq = xtdata.subscribe_whole_quote(['SH', 'SZ'], callback=self.onDataUpdate) - if self.seq == -1: - PrintLog(LogLevel.ERROR, '- 市场数据订阅失败') - else: - event_bus.publish(MarketDataEnabled, True) - PrintLog(LogLevel.INFO, f'- 市场数据订阅成功, 订阅号={self.seq}') - - - - def stopMarketData(self): - PrintLog(LogLevel.INFO, '- 停止市场数据订阅') - - if self.seq is not None and self.seq > 0: - xtdata.unsubscribe_quote(self.seq) - event_bus.publish(MarketDataDisabled, False) - - - def add_trade_target(self, stock_code: str): - try: - stock_name = getInstrumentName(stock_code) - if not stock_name: - PrintLog(LogLevel.ERROR, f'无法获取股票代码 {stock_code} 的名称，请检查代码是否正确') - return - - # 检查是否已存在该标的 - existing_target = model.TradeTarget.get_or_none(model.TradeTarget.stock_code == stock_code) - if existing_target: - PrintLog(LogLevel.INFO, f'交易标的 {stock_code} {stock_name} 已存在') - return - - new_target = model.TradeTarget.create( - stock_name=stock_name, - stock_code=stock_code, - market_price=0.0, - current_position=0, - grid_index=0, - last_trade_price=0.0, - plan_buy_price=0.0, - plan_sell_price=0.0, - current_order_price=0.0, - current_order_no='', - current_order_type='' - ) - new_target.save() - PrintLog(LogLevel.INFO, f'新增交易标的 {stock_code} {stock_name}, {new_target.id}') - # 刷新标的持仓 - pos = getStockPosition(stock_code, self.xt_trader, self.account) # type: ignore - model.TradeTarget.update(current_position=pos).where(model.TradeTarget.stock_code == stock_code).execute() - # 更新标的池 - self.refresh_targets() - # 添加交易控制器 - stockTradeController = SFGridStrategy(new_target, self.xt_trader, self.account) # type: ignore - self.stock_trade_ctrl[stock_code] = stockTradeController - - except Exception as e: - PrintLog(LogLevel.ERROR, f'新增交易标的失败 {stock_code} {e}') - - - def del_trade_target(self, id:int): - try: - # 检查标的是否存在 - if id not in self.instrument_pool: - PrintLog(LogLevel.ERROR, f"交易标的 ID {id} 不存在") - return - - target: model.TradeTarget = self.instrument_pool[id] - - # 如果存在交易控制器，先停止交易 - if target.stock_code in self.stock_trade_ctrl: - # 停止交易控制器 - del self.stock_trade_ctrl[target.stock_code] - - # 从数据库中删除 - target.delete_instance() - - # 从内存中删除 - del self.instrument_pool[id] - - # 刷新标的池 - self.refresh_targets() - - PrintLog(LogLevel.INFO, f"已删除交易标的: {target.stock_code} - {target.stock_name}") - except Exception as e: - PrintLog(LogLevel.ERROR, f"删除交易标的失败 ID {id}: {str(e)}") - - def init_instrument_pool(self, xtTrader:XtQuantTrader, account:StockAccount): - self.refresh_targets() - - for id in self.instrument_pool: - target:TradeTarget = self.instrument_pool[id] - status = "新建" if target.status == 0 else "已建初始仓" - PrintLog(LogLevel.INFO, f' [序号-{id}] 股票代码: {target.stock_code}-{target.stock_name} 当前持仓: {getStockPosition(target.stock_code, self.xt_trader, self.account)} 网格索引: {target.grid_index} 基准价格 {sfgrid_config.grid_price[target.grid_index]} 状态: {status} 启用交易线程: {'自动交易中' if target.enabled else '交易已停止'}') # type: ignore - - tradeTarget:model.TradeTarget = self.instrument_pool[id] - tradeTarget.current_position = getStockPosition(tradeTarget.stock_code, xtTrader, account) # type: ignore - result = tradeTarget.save() - PrintLog(LogLevel.INFO, f' |- 同步[{target.stock_code}-{target.stock_name}]持仓信息[{'成功' if result == 1 else '失败'}]') - stockTradeController = SFGridStrategy(tradeTarget, self.xt_trader, self.account) # type: ignore - self.stock_trade_ctrl[tradeTarget.stock_code] = stockTradeController - event_bus.publish(EventTradeTargetUpdate, tradeTarget) - - PrintLog(LogLevel.INFO, f'- [成功]交易标的信息初始化, 共 {len(self.instrument_pool)} 个标的') - - - def refresh_targets(self): - # 更新标的池 - results:ModelSelect = model.TradeTarget.select() - self.instrument_pool: dict[int, model.TradeTarget] = {} - for temp in results: - result :model.TradeTarget = temp - self.instrument_pool[result.get_id()] = result - - 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 start_stock_trade(self, id: int): - tradeTarget: TradeTarget = self.instrument_pool[id] - # check existing thread - if tradeTarget.stock_code in self.stock_trade_ctrl: - tradeController: SFGridStrategy = self.stock_trade_ctrl[tradeTarget.stock_code] - - tradeTarget = tradeController.enabledTrading(True) - self.instrument_pool[id] = tradeTarget - event_bus.publish(ResultEventTradeEnabled, tradeTarget) - else: - PrintLog(LogLevel.INFO, f"\t创建标的交易控制器 {tradeTarget.stock_code} {getInstrumentName(tradeTarget.stock_code)}") - - - def pause_stock_trade(self, id: int): - localTarget: model.TradeTarget = self.instrument_pool[id] - print(f'暂停标的交易 {localTarget.stock_code} - enabled {localTarget.enabled}') - if localTarget.stock_code in self.stock_trade_ctrl: - tradeController: SFGridStrategy = self.stock_trade_ctrl[localTarget.stock_code] - tradeTarget = tradeController.enabledTrading(False) - orders = queryPendingOrder(localTarget.stock_code, tradeController.getName(), self.xt_trader, self.account) # type: ignore - for order in orders: - self.xt_trader.cancel_order_stock_async(self.account, order.order_id) - print(f'取消未成交订单 {len(orders)}') - self.instrument_pool[id] = tradeTarget - event_bus.publish(ResultEventTradeDisabled, tradeTarget) - else: - print(f"标的交易控制器不存在 {localTarget.stock_code} {localTarget.stock_name}\n") - diff --git a/core/main_ui.py b/core/main_ui.py index a4d7d94..87c2607 100644 --- a/core/main_ui.py +++ b/core/main_ui.py @@ -2,14 +2,14 @@ import time import tkinter as tk from tkinter import ttk from core.logger import LogLevel, PrintLog -from core.sfgrid.ui import TradeTargetUI -import sfgrid_config +from core.sfgrid.sfgrid_ui import TradeTargetUI +import config from xtquant import xtdata from xtquant.xttrader import XtQuantTrader, XtQuantTraderCallback import datetime from xtquant.xttype import StockAccount, XtAsset, XtOrder, XtOrderResponse, XtPosition, XtTrade -class MainWindow(XtQuantTraderCallback): +class MainWindow: def __init__(self): self.root = tk.Tk() self.root.title("三疯交易系统") @@ -21,36 +21,9 @@ class MainWindow(XtQuantTraderCallback): self.strategy_frames = {} # 日志面板可见性标志 self.log_visible = False - - self.initQmt() # 创建界面 self.create_ui() - def initQmt(self): - xtdata.enable_hello = False - - session_id = int(time.time()) - - self.xt_trader: XtQuantTrader = XtQuantTrader(sfgrid_config.miniQMTPath, session_id) - self.xt_trader.register_callback(self) - self.xt_trader.start() - self.xt_trader.connect() - PrintLog(LogLevel.INFO, f'- [{'成功' if self.xt_trader.connected else '失败'}]市场交易连接: {sfgrid_config.miniQMTPath}') - if self.xt_trader.connected == False: - self.inited: bool = False - return - else: - self.inited = True - - self.account= StockAccount(sfgrid_config.account_no, 'STOCK') - PrintLog(LogLevel.INFO, f'- [成功]交易账号对象初始化完成, 账号: {self.account.account_id}') # pyright: ignore[reportAttributeAccessIssue] - subscribe_result = self.xt_trader.subscribe(self.account) - PrintLog(LogLevel.INFO, f'- [{'成功' if subscribe_result == 0 else '失败'}:{subscribe_result}]交易状态订阅') - if subscribe_result == 0: - self.inited = True - else: - self.inited = False - return def create_ui(self): """创建UI界面""" @@ -181,7 +154,7 @@ class MainWindow(XtQuantTraderCallback): for idx, name in enumerate(strategy_names): if idx == 0: # 第一个Tab使用TradeTargetUI，传入main_window引用 - frame = TradeTargetUI(self.content_container, self) + frame = TradeTargetUI(self.content_container) self.strategy_frames[idx] = frame else: # 其他策略使用占位Frame @@ -246,82 +219,3 @@ class MainWindow(XtQuantTraderCallback): """运行程序""" self.root.mainloop() - - # ====== 市场回调方法 -- 以下方法由XtQuantData调用 ====== - def onDataUpdate(self, data): - # 收集所有市场数据用于市场监控 - print(f'market data update {len(data)}') - - - # ====== 市场回调方法 -- 以下方法由XtQuantTrader调用 ====== - def on_connected(self): - """ - 连接成功推送 - """ - print(datetime.datetime.now(), '连接成功回调') - - def on_disconnected(self): - """ - 连接断开 - :return: - """ - print(datetime.datetime.now(), '连接断开回调') - - def on_stock_order(self, order:XtOrder): - """ - 委托回报推送 - :param order: XtOrder对象 - :return: - """ - print(f'orderd {order.strategy_name}-{order.stock_code} {order.order_id} {order.order_volume}-{order.order_status}') - # 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): - """ - 成交变动推送 - :param trade: XtTrade对象 - :return: - """ - print(f"委托回调 投资备注 {trade.stock_code}-{trade.instrument_name} {trade.strategy_name} 不匹配 {trade.order_remark}") - # stockCode = trade.stock_code - # ctrl:SFGridStrategy = self.stock_trade_ctrl[stockCode] - # # 如果存在对应的StockTradeController，则调用其onDataUpdate方法 - # if ctrl is not None and trade.strategy_name == ctrl.getName(): - # ctrl.onOrderTrade(trade) - # else: - # print(f"委托回调 投资备注 {trade.strategy_name} 不匹配 {ctrl.getName()}") - - def on_order_stock_async_response(self, response:XtOrderResponse): - print(f"委托回调 投资备注 {response.error_msg}{response.strategy_name} {response.order_remark}") - - # stockCode = response.order_remark - # ctrl:SFGridStrategy = self.stock_trade_ctrl[stockCode] - # # 如果存在对应的StockTradeController，则调用其onDataUpdate方法 - # if ctrl is not None and response.strategy_name == ctrl.getName(): - # ctrl.onAsyncOrderResponse(response) - # else: - # print(f"委托回调 投资备注 {response.strategy_name} 不匹配 {ctrl.getName()}") - - def on_order_error(self, order_error): - """ - 委托失败推送 - :param order_error:XtOrderError 对象 - :return: - """ - print(f"\n委托报错回调 {order_error.order_remark} {order_error.error_msg}") - - - def on_account_status(self, status): - """ - :param response: XtAccountStatus 对象 - :return: - """ - print(datetime.datetime.now(), status) \ No newline at end of file diff --git a/core/qmt.py b/core/qmt.py new file mode 100644 index 0000000..0a64c15 --- /dev/null +++ b/core/qmt.py @@ -0,0 +1,203 @@ +import datetime +import time +import config +from xtquant.xttype import StockAccount, XtOrder, XtOrderResponse, XtPosition, XtTrade +from xtquant.xttrader import XtQuantTrader +from xtquant.xttype import StockAccount +from core.logger import LogLevel, PrintLog +from xtquant.xttrader import XtQuantTrader, XtQuantTraderCallback +from xtquant.xttype import StockAccount +from xtquant import xtconstant, xtdata + +class QmtV(XtQuantTraderCallback): + def __init__(self) -> None: + self.xttrader: XtQuantTrader + self.inited: bool = False + + def getTrader(self) -> XtQuantTrader: + return self.xttrader + + def init_qmtv(self): + sessionId= int(time.time()) + self.xttrader = XtQuantTrader(config.miniQMTPath, sessionId) + xtdata.enable_hello = False + + def connect(self): + self.xttrader.register_callback(self) + self.xttrader.start() + self.xttrader.connect() + + PrintLog(LogLevel.INFO, f'- [{'成功' if self.xttrader.connected else '失败'}]市场交易连接: {config.miniQMTPath}') + if self.xttrader.connected == False: + self.inited = False + return + else: + self.inited = True + + self.account = StockAccount(config.account_no, 'STOCK') # pyright: ignore[reportAssignmentType, reportAttributeAccessIssue] + PrintLog(LogLevel.INFO, f'- [成功]交易账号对象初始化完成, 账号: {config.account_no}') # pyright: ignore[reportOptionalMemberAccess] + subscribe_result = self.xttrader.subscribe(self.account) + PrintLog(LogLevel.INFO, f'- [{'成功' if subscribe_result == 0 else '失败'}:{subscribe_result}]交易状态订阅') + if subscribe_result != 0: + self.inited = False + return + + + def getStockPosition(self, stock_code: str): + volume = 0 + print(f'获取股票持仓: {stock_code}, {self.xttrader.connected}, {self.account.account_id if self.account else None}') # pyright: ignore[reportAttributeAccessIssue] + positions = self.xttrader.query_stock_positions(self.account) + if positions: + for temp in positions: + pos:XtPosition = temp + if pos.stock_code == stock_code: + volume = pos.volume + break + + return volume + + + def queryPendingOrder(self, stock_code:str, tag: str) -> list[XtOrder]: + if stock_code == None or tag == None: + return [] + orders = self.xttrader.query_stock_orders(self.account) + result = [order for order in orders if order.order_status == xtconstant.ORDER_REPORTED and order.stock_code == stock_code and order.strategy_name == tag] + return result + + def orderAsync(self, stock_code, orderVolume, orderType, orderPrice, priceType, orderRemark, strategy_name): + return self.xttrader.order_stock_async( + self.account, + str(stock_code), + orderType, + orderVolume, + priceType, + orderPrice, + strategy_name, # strategy_name + orderRemark # remark # type: ignore + ) + + # 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当前无委托记录") + + + # ========================================# + + # ====== 市场回调方法 -- 以下方法由XtQuantData调用 ====== + def onDataUpdate(self, data): + # 收集所有市场数据用于市场监控 + print(f'market data update {len(data)}') + + + # ====== 市场回调方法 -- 以下方法由XtQuantTrader调用 ====== + def on_connected(self): + """ + 连接成功推送 + """ + print(datetime.datetime.now(), '连接成功回调') + + def on_disconnected(self): + """ + 连接断开 + :return: + """ + print(datetime.datetime.now(), '连接断开回调') + + def on_stock_order(self, order:XtOrder): + """ + 委托回报推送 + :param order: XtOrder对象 + :return: + """ + print(f'orderd {order.strategy_name}-{order.stock_code} {order.order_id} {order.order_volume}-{order.order_status}') + # 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): + """ + 成交变动推送 + :param trade: XtTrade对象 + :return: + """ + print(f"委托回调 投资备注 {trade.stock_code}-{trade.instrument_name} {trade.strategy_name} 不匹配 {trade.order_remark}") + # stockCode = trade.stock_code + # ctrl:SFGridStrategy = self.stock_trade_ctrl[stockCode] + # # 如果存在对应的StockTradeController，则调用其onDataUpdate方法 + # if ctrl is not None and trade.strategy_name == ctrl.getName(): + # ctrl.onOrderTrade(trade) + # else: + # print(f"委托回调 投资备注 {trade.strategy_name} 不匹配 {ctrl.getName()}") + + def on_order_stock_async_response(self, response:XtOrderResponse): + print(f"委托回调 投资备注 {response.error_msg}{response.strategy_name} {response.order_remark}") + + # stockCode = response.order_remark + # ctrl:SFGridStrategy = self.stock_trade_ctrl[stockCode] + # # 如果存在对应的StockTradeController，则调用其onDataUpdate方法 + # if ctrl is not None and response.strategy_name == ctrl.getName(): + # ctrl.onAsyncOrderResponse(response) + # else: + # print(f"委托回调 投资备注 {response.strategy_name} 不匹配 {ctrl.getName()}") + + def on_order_error(self, order_error): + """ + 委托失败推送 + :param order_error:XtOrderError 对象 + :return: + """ + print(f"\n委托报错回调 {order_error.order_remark} {order_error.error_msg}") + + + def on_account_status(self, status): + """ + :param response: XtAccountStatus 对象 + :return: + """ + print(datetime.datetime.now(), status) + + +qmtv = QmtV() diff --git a/core/sfgrid/model.py b/core/sfgrid/model.py index d17de04..96824fc 100644 --- a/core/sfgrid/model.py +++ b/core/sfgrid/model.py @@ -4,7 +4,7 @@ from core.database import BaseModel, db # 定义Target类，对应targets表 -class TradeTarget(BaseModel): +class SFGridTradeTarget(BaseModel): stock_code = CharField(unique=True) stock_name = CharField() market_price = FloatField() @@ -23,4 +23,4 @@ class TradeTarget(BaseModel): return f'{self.stock_name}[{self.stock_code}]' -db.create_tables([TradeTarget]) \ No newline at end of file +db.create_tables([SFGridTradeTarget]) \ No newline at end of file diff --git a/core/sfgrid/objects.py b/core/sfgrid/objects.py index f8a6f47..62917e4 100644 --- a/core/sfgrid/objects.py +++ b/core/sfgrid/objects.py @@ -1,4 +1,4 @@ -from core.sfgrid.model import TradeTarget +from core.sfgrid.model import SFGridTradeTarget as TradeTarget class GridFixData: diff --git a/core/sfgrid/main_controller.py b/core/sfgrid/sfgrid_controller.py similarity index 75% rename from core/sfgrid/main_controller.py rename to core/sfgrid/sfgrid_controller.py index 98efe18..41a14bf 100644 --- a/core/sfgrid/main_controller.py +++ b/core/sfgrid/sfgrid_controller.py @@ -1,12 +1,13 @@ # coding:utf-8 -from core.sfgrid.model import TradeTarget +from core.sfgrid.model import SFGridTradeTarget as TradeTarget from core.eventbus import ActionDisableMarketData, ActionEnableMarketData, ActionEventAddTradeTarget, ActionEventDeleteTradeTarget, ActionEventDisableTrade, ActionEventEnableTrade, EventTradeTargetUpdate, MarketDataUpdate, MarketDataEnabled, MarketDataDisabled, ResultEventTradeDisabled, ResultEventTradeEnabled, ResultEventTradeTargetDeleted, ActionEventGridFix, event_bus +from xtquant import xttrader from xtquant.xttrader import XtQuantTrader import time from peewee import ModelSelect import core.sfgrid.model as model -import sfgrid_config +import config from core.sfgrid.sfgrid_strategy import SFGridStrategy from core.util import getInstrumentName, getStockPosition, queryPendingOrder from xtquant.xttrader import XtQuantTrader @@ -14,45 +15,21 @@ from xtquant.xttype import StockAccount, XtAsset, XtOrder, XtPosition, XtTrade from xtquant import xtdata from xtquant.xttrader import XtQuantTraderCallback import datetime -import core.sfgrid.ui as ui +import core.sfgrid.sfgrid_ui as sfgrid_ui from core.logger import PrintLog, LogLevel +from core.qmt import qmtv from core.sfgrid.objects import GridFixData # 量化核心控制对象 class SFGridController(XtQuantTraderCallback): - def __init__(self, account_no: str, miniQmtPath: str): + def __init__(self): super().__init__() self.registerEventHandler() - self.appUi = ui.TradeTargetUI() - - xtdata.enable_hello = False - - session_id = int(time.time()) - self.xt_trader: XtQuantTrader = XtQuantTrader(miniQmtPath, session_id) - self.xt_trader.register_callback(self) - self.xt_trader.start() - self.xt_trader.connect() - PrintLog(LogLevel.INFO, f'- [{'成功' if self.xt_trader.connected else '失败'}]市场交易连接: {miniQmtPath}') - if self.xt_trader.connected == False: - self.inited: bool = False - return - else: - self.inited = True - - self.account= StockAccount(account_no, 'STOCK') - PrintLog(LogLevel.INFO, f'- [成功]交易账号对象初始化完成, 账号: {self.account.account_id}') # pyright: ignore[reportAttributeAccessIssue] - subscribe_result = self.xt_trader.subscribe(self.account) - PrintLog(LogLevel.INFO, f'- [{'成功' if subscribe_result == 0 else '失败'}:{subscribe_result}]交易状态订阅') - if subscribe_result == 0: - self.inited = True - else: - self.inited = False - return self.listening_stock = [] self.stock_trade_ctrl = {} - self.init_instrument_pool(self.xt_trader, self.account) # type: ignore + self.init_instrument_pool(qmtv.xttrader, qmtv.account) # type: ignore self.seq = None PrintLog(LogLevel.INFO, '- [成功]三疯交易系统初始化完成') @@ -118,9 +95,6 @@ class SFGridController(XtQuantTraderCallback): except Exception as e: PrintLog(LogLevel.ERROR, f"网格修正更新失败: {str(e)}") - def hold(self): - self.appUi.run() - def startMarketData(self): PrintLog(LogLevel.INFO, '- 启动市场数据订阅') @@ -149,12 +123,12 @@ class SFGridController(XtQuantTraderCallback): return # 检查是否已存在该标的 - existing_target = model.TradeTarget.get_or_none(model.TradeTarget.stock_code == stock_code) + existing_target = TradeTarget.get_or_none(TradeTarget.stock_code == stock_code) if existing_target: PrintLog(LogLevel.INFO, f'交易标的 {stock_code} {stock_name} 已存在') return - new_target = model.TradeTarget.create( + new_target = TradeTarget.create( stock_name=stock_name, stock_code=stock_code, market_price=0.0, @@ -171,7 +145,7 @@ class SFGridController(XtQuantTraderCallback): PrintLog(LogLevel.INFO, f'新增交易标的 {stock_code} {stock_name}, {new_target.id}') # 刷新标的持仓 pos = getStockPosition(stock_code, self.xt_trader, self.account) # type: ignore - model.TradeTarget.update(current_position=pos).where(model.TradeTarget.stock_code == stock_code).execute() + TradeTarget.update(current_position=pos).where(TradeTarget.stock_code == stock_code).execute() # 更新标的池 self.refresh_targets() # 添加交易控制器 @@ -189,7 +163,7 @@ class SFGridController(XtQuantTraderCallback): PrintLog(LogLevel.ERROR, f"交易标的 ID {id} 不存在") return - target: model.TradeTarget = self.instrument_pool[id] + target: TradeTarget = self.instrument_pool[id] # 如果存在交易控制器，先停止交易 if target.stock_code in self.stock_trade_ctrl: @@ -215,9 +189,9 @@ class SFGridController(XtQuantTraderCallback): for id in self.instrument_pool: target:TradeTarget = self.instrument_pool[id] status = "新建" if target.status == 0 else "已建初始仓" - PrintLog(LogLevel.INFO, f' [序号-{id}] 股票代码: {target.stock_code}-{target.stock_name} 当前持仓: {getStockPosition(target.stock_code, self.xt_trader, self.account)} 网格索引: {target.grid_index} 基准价格 {sfgrid_config.grid_price[target.grid_index]} 状态: {status} 启用交易线程: {'自动交易中' if target.enabled else '交易已停止'}') # type: ignore + PrintLog(LogLevel.INFO, f' [序号-{id}] 股票代码: {target.stock_code}-{target.stock_name} 当前持仓: {getStockPosition(target.stock_code, self.xt_trader, self.account)} 网格索引: {target.grid_index} 基准价格 {config.grid_price[target.grid_index]} 状态: {status} 启用交易线程: {'自动交易中' if target.enabled else '交易已停止'}') # type: ignore - tradeTarget:model.TradeTarget = self.instrument_pool[id] + tradeTarget:TradeTarget = self.instrument_pool[id] tradeTarget.current_position = getStockPosition(tradeTarget.stock_code, xtTrader, account) # type: ignore result = tradeTarget.save() PrintLog(LogLevel.INFO, f' |- 同步[{target.stock_code}-{target.stock_name}]持仓信息[{'成功' if result == 1 else '失败'}]') @@ -230,53 +204,12 @@ class SFGridController(XtQuantTraderCallback): def refresh_targets(self): # 更新标的池 - results:ModelSelect = model.TradeTarget.select() - self.instrument_pool: dict[int, model.TradeTarget] = {} + results:ModelSelect = TradeTarget.select() + self.instrument_pool: dict[int, TradeTarget] = {} for temp in results: - result :model.TradeTarget = temp + result :TradeTarget = temp self.instrument_pool[result.get_id()] = result - 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 start_stock_trade(self, id: int): @@ -293,14 +226,14 @@ class SFGridController(XtQuantTraderCallback): def pause_stock_trade(self, id: int): - localTarget: model.TradeTarget = self.instrument_pool[id] + localTarget: TradeTarget = self.instrument_pool[id] print(f'暂停标的交易 {localTarget.stock_code} - enabled {localTarget.enabled}') if localTarget.stock_code in self.stock_trade_ctrl: tradeController: SFGridStrategy = self.stock_trade_ctrl[localTarget.stock_code] tradeTarget = tradeController.enabledTrading(False) orders = queryPendingOrder(localTarget.stock_code, tradeController.getName(), self.xt_trader, self.account) # type: ignore for order in orders: - self.xt_trader.cancel_order_stock_async(self.account, order.order_id) + qmtv.xttrader.cancel_order_stock_async(qmtv.account, order.order_id) print(f'取消未成交订单 {len(orders)}') self.instrument_pool[id] = tradeTarget event_bus.publish(ResultEventTradeDisabled, tradeTarget) diff --git a/core/sfgrid/sfgrid_strategy.py b/core/sfgrid/sfgrid_strategy.py index faafe4b..723bfe8 100644 --- a/core/sfgrid/sfgrid_strategy.py +++ b/core/sfgrid/sfgrid_strategy.py @@ -1,3 +1,4 @@ +from core.qmt import qmtv import core.sfgrid.model as model from core import constants from core.eventbus import EventTradeTargetUpdate, event_bus @@ -6,16 +7,14 @@ from core.util import queryPendingOrder, is_trading_time from xtquant import xttrader, xtconstant from xtquant.xttype import StockAccount, XtOrder, XtTrade -import sfgrid_config +import config import threading class SFGridStrategy: - def __init__(self, tradeTarget: model.TradeTarget, xt_trader: xttrader.XtQuantTrader, account: StockAccount): - self.tradeTarget:model.TradeTarget = tradeTarget - self.xt_trader: xttrader.XtQuantTrader = xt_trader - self.account:StockAccount = account + def __init__(self, tradeTarget: model.SFGridTradeTarget): + self.tradeTarget:model.SFGridTradeTarget = tradeTarget self.enabledTrading(bool(tradeTarget.enabled)) # 修复类型兼容性问题 event_bus.publish(EventTradeTargetUpdate, self.tradeTarget) @@ -27,7 +26,7 @@ class SFGridStrategy: self.refreshPlanPrice() self.saveProxy() - def enabledTrading(self, enabled: bool) -> model.TradeTarget: + def enabledTrading(self, enabled: bool) -> model.SFGridTradeTarget: self.tradeTarget.enabled = enabled # type: ignore self.saveProxy() @@ -40,7 +39,7 @@ class SFGridStrategy: else: # 已建仓 # 交易阶段，检查仓位，检查现有订单 print(f" |- 标的{self.tradeTarget.targetName()}已有仓位或非初始状态 无需建初始仓 当前仓位: {self.tradeTarget.current_position} 状态: {self.tradeTarget.status}") - minRequirePosition:int = sfgrid_config.grid_volume * int(self.tradeTarget.grid_index) # type: ignore + minRequirePosition:int = config.grid_volume * int(self.tradeTarget.grid_index) # type: ignore if minRequirePosition <= int(self.tradeTarget.current_position): # type: ignore print(f' |- 仓位检查: 持仓需求充足, (gridVolume*gridIndex)={minRequirePosition}, 当前持仓：{self.tradeTarget.current_position}') else: @@ -79,16 +78,16 @@ class SFGridStrategy: index: int = self.tradeTarget.grid_index # pyright: ignore[reportAssignmentType] orderRemark= "" - gridBasePrice = -1 if index>=len(sfgrid_config.grid_price) or index < 0 else sfgrid_config.grid_price[int(index)] # pyright: ignore[reportArgumentType] + gridBasePrice = -1 if index>=len(config.grid_price) or index < 0 else config.grid_price[int(index)] # pyright: ignore[reportArgumentType] - if self.tradeTarget.enabled and self.tradeTarget.status == 0 and lastPrice <= sfgrid_config.grid_price[1]: # 已启用，未建仓，建仓 - orderPrice = sfgrid_config.grid_price[index] + if self.tradeTarget.enabled and self.tradeTarget.status == 0 and lastPrice <= config.grid_price[1]: # 已启用，未建仓，建仓 + orderPrice = config.grid_price[index] orderType = xtconstant.STOCK_BUY orderRemark = OrderTypeInit if self.tradeTarget.enabled and self.tradeTarget.status == 1: # 已启用，已建仓，网格单 - lowPrice = -1 if index+1>=len(sfgrid_config.grid_price) else sfgrid_config.grid_price[int(index) + 1] # pyright: ignore[reportArgumentType] - highPrice = sfgrid_config.grid_price[index - 1] + lowPrice = -1 if index+1>=len(config.grid_price) else config.grid_price[int(index) + 1] # pyright: ignore[reportArgumentType] + highPrice = config.grid_price[index - 1] if lastPrice <= lowPrice: # 下下方多单 orderPrice = lowPrice @@ -101,21 +100,20 @@ class SFGridStrategy: orderRemark = OrderTypeSell if orderType != -1: - orders = queryPendingOrder(str(self.tradeTarget.stock_code), self.getName(), self.xt_trader, self.account) + 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: # 已存在未交易的多单 print(f' |- [{self.tradeTarget.stock_code}-{self.tradeTarget.stock_name}]已存在未交易的{"多单" if orderType == xtconstant.STOCK_BUY else "空单"}，不重复下单') else: print(f' |- 下网格{"多单" if orderType == xtconstant.STOCK_BUY else "空单"}') - self.tradeTarget.current_order_no = self.xt_trader.order_stock_async( - self.account, + self.tradeTarget.current_order_no = qmtv.orderAsync( str(self.tradeTarget.stock_code), + config.grid_volume, orderType, - sfgrid_config.grid_volume, - xtconstant.FIX_PRICE, orderPrice, + xtconstant.FIX_PRICE, + orderRemark, # remark # type: ignore self.getName(), # strategy_name - orderRemark # remark # type: ignore ) orderTypeName = "" if orderRemark == OrderTypeBuy: @@ -124,7 +122,7 @@ class SFGridStrategy: orderTypeName = "空单" elif orderRemark == OrderTypeInit: orderTypeName = "建仓单" - print(f' |- {orderTypeName}委托, 单号 {self.tradeTarget.current_order_no}, 网格基准价 {gridBasePrice}, 下单价 {orderPrice}, 下单量 {sfgrid_config.grid_volume}') + print(f' |- {orderTypeName}委托, 单号 {self.tradeTarget.current_order_no}, 网格基准价 {gridBasePrice}, 下单价 {orderPrice}, 下单量 {config.grid_volume}') finally: print(f'|- 市价更新[{self.tradeTarget.stock_code}-{self.tradeTarget.stock_name}] - release lock') self.saveProxy() @@ -162,8 +160,8 @@ class SFGridStrategy: 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.plan_buy_price = float(sfgrid_config.grid_price[2]) # type: ignore - self.tradeTarget.plan_sell_price = float(sfgrid_config.grid_price[0]) # type: ignore + self.tradeTarget.plan_buy_price = float(config.grid_price[2]) # type: ignore + self.tradeTarget.plan_sell_price = float(config.grid_price[0]) # type: ignore self.tradeTarget.status = 1 # type: ignore self.saveProxy() print(f"|- 标的{self.tradeTarget.stock_code}-{self.tradeTarget.stock_name} 建初始仓订单ID: {self.tradeTarget.current_order_no}已成交 ") @@ -175,7 +173,7 @@ class SFGridStrategy: 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 - print(f"|- 标的{self.tradeTarget.stock_code}-{self.tradeTarget.stock_name} 上涨 卖单已成交 订单ID: {self.tradeTarget.current_order_no} Price: {sfgrid_config.grid_price[int(self.tradeTarget.grid_index)]} Volume: {sfgrid_config.grid_volume} 手续费: {trade.commission}\n") # type: ignore + print(f"|- 标的{self.tradeTarget.stock_code}-{self.tradeTarget.stock_name} 上涨 卖单已成交 订单ID: {self.tradeTarget.current_order_no} Price: {config.grid_price[int(self.tradeTarget.grid_index)]} Volume: {config.grid_volume} 手续费: {trade.commission}\n") # type: ignore print(f' 成交价: {trade.traded_price} 成交量: {trade.traded_volume}') print(f' 当前持仓: {self.tradeTarget.current_position}') print(f' 网格坐标: {self.tradeTarget.grid_index}') @@ -184,7 +182,7 @@ class SFGridStrategy: 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 - print(f"|- 标的{self.tradeTarget.stock_code}-{self.tradeTarget.stock_name} 下跌 买单已成交 订单ID: {self.tradeTarget.current_order_no} Price: {trade.traded_price} Volume: {sfgrid_config.grid_volume} 手续费: {trade.commission}") + print(f"|- 标的{self.tradeTarget.stock_code}-{self.tradeTarget.stock_name} 下跌 买单已成交 订单ID: {self.tradeTarget.current_order_no} Price: {trade.traded_price} Volume: {config.grid_volume} 手续费: {trade.commission}") print(f' 成交价: {trade.traded_price} 成交量: {trade.traded_volume}') print(f' 当前持仓: {self.tradeTarget.current_position}') print(f' 网格坐标: {self.tradeTarget.grid_index}') @@ -202,11 +200,11 @@ class SFGridStrategy: 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(sfgrid_config.grid_price[sellIdx]) # pyright: ignore[reportAttributeAccessIssue] + self.tradeTarget.plan_sell_price = float(config.grid_price[sellIdx]) # pyright: ignore[reportAttributeAccessIssue] else: self.tradeTarget.plan_sell_price = -1.0 # type: ignore - if self.tradeTarget.grid_index < len(sfgrid_config.grid_price) - 1: - self.tradeTarget.plan_buy_price = float(sfgrid_config.grid_price[buyIdx]) # pyright: ignore[reportAttributeAccessIssue] + if self.tradeTarget.grid_index < len(config.grid_price) - 1: + self.tradeTarget.plan_buy_price = float(config.grid_price[buyIdx]) # pyright: ignore[reportAttributeAccessIssue] else: self.tradeTarget.plan_buy_price = -1.0 # pyright: ignore[reportAttributeAccessIssue] else: diff --git a/core/sfgrid/ui.py b/core/sfgrid/sfgrid_ui.py similarity index 86% rename from core/sfgrid/ui.py rename to core/sfgrid/sfgrid_ui.py index 0a11e71..9b4901b 100644 --- a/core/sfgrid/ui.py +++ b/core/sfgrid/sfgrid_ui.py @@ -1,52 +1,71 @@ from typing import Any - import tkinter as tk from tkinter import ttk, messagebox, filedialog from datetime import datetime import threading import time import core.eventbus as eBus -from core.logger import LogData, LogLevel -from core.sfgrid.model import TradeTarget, db +from core.logger import LogLevel, PrintLog +from core.sfgrid.model import SFGridTradeTarget import configparser -import sfgrid_config +import config from core.sfgrid.objects import GridFixData -from core.util import getInstrumentName +from core.qmt import qmtv +from core.sfgrid.sfgrid_strategy import SFGridStrategy class TradeTargetUI(ttk.Frame): - def __init__(self, parent, main_window): + def __init__(self, parent): super().__init__(parent) - # 保存主窗口的引用，用于访问全局日志 - self.main_window = main_window - - self.tradeTargetData:dict[int, TradeTarget] = {} - self.market_data_enabled = False # 添加市场数据监听状态变量 - self.ui_refresh_enabled = False # 添加UI刷新线程状态变量 + self.tradeTargetData:dict[int, SFGridTradeTarget] = {} # id->trade_target + self.strategy_ctrl:dict[str, SFGridStrategy] = {} # stock_code->trade_target + self.init_trade_target_pool() self.registerEventHandler() # 创建刷新线程标志 - self.refresh_thread_running = False # 默认不启动刷新线程 + self.refresh_thread_running = True # 默认不启动刷新线程 # 市场监控数据 self.marketData: dict[str, Any] = {} # 存储市场数据 {stock_code: {stock_name, last_price, time}} # 创建界面 self.create_ui() - - # 不再自动启动刷新线程，由市场数据开关控制 + + def refresh_targets(self): + # 更新标的池 + results = SFGridTradeTarget.select() + for temp in results: + result :SFGridTradeTarget = temp + self.tradeTargetData[result.get_id()] = result + + + def init_trade_target_pool(self): + self.refresh_targets() + + for id, tradeTarget in self.tradeTargetData.items(): + status = "新建" if tradeTarget.status == 0 else "已建初始仓" + PrintLog(LogLevel.INFO, f' [序号-{id}] 股票代码: {tradeTarget.stock_code}-{tradeTarget.stock_name} 当前持仓: {qmtv.getStockPosition(tradeTarget.stock_code)} 网格索引: {tradeTarget.grid_index} 基准价格 {config.grid_price[tradeTarget.grid_index]} 状态: {status} 启用交易线程: {'自动交易中' if tradeTarget.enabled else '交易已停止'}') # type: ignore + + tradeTarget.current_position = qmtv.getStockPosition(tradeTarget.stock_code) # type: ignore + result = tradeTarget.save() + PrintLog(LogLevel.INFO, f' |- 同步[{tradeTarget.stock_code}-{tradeTarget.stock_name}]持仓信息[{'成功' if result == 1 else '失败'}]') + stockTradeController = SFGridStrategy(tradeTarget) # type: ignore + self.strategy_ctrl[tradeTarget.stock_code] = stockTradeController # pyright: ignore[reportArgumentType] + # eBus.event_bus.publish(eBus.EventTradeTargetUpdate, tradeTarget) + + PrintLog(LogLevel.INFO, f'- [成功]交易标的信息初始化, 共 {len(self.tradeTargetData)} 个标的') + def registerEventHandler(self): - eBus.event_bus.subscribe(eBus.EventTradeTargetUpdate, self.onTradeTargetUpdated) - eBus.event_bus.subscribe(eBus.MarketDataUpdate, self.onMarketDataUpdated) - eBus.event_bus.subscribe(eBus.ResultEventTradeEnabled, self.onTradeEnabled) - eBus.event_bus.subscribe(eBus.ResultEventTradeDisabled, self.onTradeDisabled) - eBus.event_bus.subscribe(eBus.MarketDataEnabled, self.onMarketDataToggled) - eBus.event_bus.subscribe(eBus.MarketDataDisabled, self.onMarketDataToggled) + # eBus.event_bus.subscribe(eBus.EventTradeTargetUpdate, self.onTradeTargetUpdated) + # eBus.event_bus.subscribe(eBus.MarketDataUpdate, self.onMarketDataUpdated) + # eBus.event_bus.subscribe(eBus.ResultEventTradeEnabled, self.onTradeEnabled) + # eBus.event_bus.subscribe(eBus.ResultEventTradeDisabled, self.onTradeDisabled) + # eBus.event_bus.subscribe(eBus.MarketDataEnabled, self.onMarketDataToggled) + # eBus.event_bus.subscribe(eBus.MarketDataDisabled, self.onMarketDataToggled) eBus.event_bus.subscribe(eBus.ResultEventTradeTargetDeleted, self.onTradeTargetDeleted) - eBus.event_bus.subscribe(eBus.EventPrintLog, self.onLog) def start_refresh_thread(self): """启动刷新线程""" @@ -71,30 +90,30 @@ class TradeTargetUI(ttk.Frame): if id in self.tradeTargetData: del self.tradeTargetData[id] # 添加日志 - self.add_log(LogLevel.INFO, f"交易标的已删除，ID: {id}") + PrintLog(LogLevel.INFO, f"交易标的已删除，ID: {id}") def onMarketDataToggled(self, data:bool): self.market_data_enabled = self.market_data_switch_var.get() - self.add_log(LogLevel.INFO, "市场数据监听已" + ("启用" if data else "禁用")) + PrintLog(LogLevel.INFO, "市场数据监听已" + ("启用" if data else "禁用")) # 同步UI刷新线程状态 if data: self.start_ui_refresh() else: self.stop_ui_refresh() - def onTradeEnabled(self, target:TradeTarget): - self.add_log(LogLevel.INFO, f"交易启用: {target.stock_code} - {target.stock_name}") + def onTradeEnabled(self, target:SFGridTradeTarget): + PrintLog(LogLevel.INFO, f"交易启用: {target.stock_code} - {target.stock_name}") - def onTradeDisabled(self, target:TradeTarget): - self.add_log(LogLevel.INFO, f"交易禁用: {target.stock_code} - {target.stock_name}") + def onTradeDisabled(self, target:SFGridTradeTarget): + PrintLog(LogLevel.INFO, f"交易禁用: {target.stock_code} - {target.stock_name}") - def onTradeTargetUpdated(self, target: TradeTarget): + def onTradeTargetUpdated(self, target: SFGridTradeTarget): # 更新或添加数据到本地缓存 self.tradeTargetData[target.get_id()] = target - def onMarketDataUpdated(self, target: TradeTarget): + def onMarketDataUpdated(self, target: SFGridTradeTarget): # 更新市场监控数据 current_time = datetime.now().strftime("%H:%M:%S") self.marketData[str(target.stock_code)] = { @@ -160,14 +179,14 @@ class TradeTargetUI(ttk.Frame): if not self.refresh_thread_running: self.refresh_thread_running = True self.start_refresh_thread() - self.add_log(LogLevel.INFO, "UI刷新线程已启动") + PrintLog(LogLevel.INFO, "UI刷新线程已启动") def stop_ui_refresh(self): """停止UI刷新线程""" if self.refresh_thread_running: self.stop_refresh_thread() self.refresh_thread_running = False - self.add_log(LogLevel.INFO, "UI刷新线程已停止") + PrintLog(LogLevel.INFO, "UI刷新线程已停止") @@ -315,9 +334,9 @@ class TradeTargetUI(ttk.Frame): if result: # 发布事件通知主控制器添加标的 eBus.event_bus.publish(eBus.ActionEventAddTradeTarget, stock_code) - self.add_log(LogLevel.INFO, f"已发送添加请求: {stock_code} - {stock_name}") + PrintLog(LogLevel.INFO, f"已发送添加请求: {stock_code} - {stock_name}") - def get_status_indicator(self, target: TradeTarget) -> str: + def get_status_indicator(self, target: SFGridTradeTarget) -> str: """获取状态指示器（带颜色色块的文本）""" if target.status == 1: # 绿色圆点表示交易中 @@ -337,8 +356,7 @@ class TradeTargetUI(ttk.Frame): def populate_trade_table(self): """填充交易标的表格数据""" - for temp in self.tradeTargetData: - target: TradeTarget = self.tradeTargetData[temp] + for temp, target in self.tradeTargetData.items(): values = [ target.id, # type: ignore target.stock_code, @@ -374,7 +392,7 @@ class TradeTargetUI(ttk.Frame): if selected: item = selected[0] values = self.trade_table.item(item)['values'] - self.add_log(LogLevel.DEBUG, f"双击查看详情: {values[0]} - {values[1]}") + PrintLog(LogLevel.DEBUG, f"双击查看详情: {values[0]} - {values[1]}") def get_selected_target(self): """获取选中的交易标的""" @@ -418,7 +436,7 @@ class TradeTargetUI(ttk.Frame): # self.add_log("INFO", f"已启动交易: {target.stock_code} - {target.stock_name}") # messagebox.showinfo("启动成功", f"已启动 {target.stock_code} ({target.stock_name}) 的交易") - def on_trade_enabled(self, target: TradeTarget): + def on_trade_enabled(self, target: SFGridTradeTarget): eBus.event_bus.publish(eBus.ActionEventEnableTrade, target) def pause_selected_trade(self): @@ -462,7 +480,7 @@ class TradeTargetUI(ttk.Frame): if result: # 通过事件总线发出删除动作 eBus.event_bus.publish(eBus.ActionEventDeleteTradeTarget, target.get_id()) - self.add_log(LogLevel.INFO, f"已发送删除请求: {target.stock_code} - {target.stock_name}") + PrintLog(LogLevel.INFO, f"已发送删除请求: {target.stock_code} - {target.stock_name}") def add_trade_target(self): """添加新的交易标的""" @@ -519,7 +537,7 @@ class TradeTargetUI(ttk.Frame): # 绑定回车键确认 stock_code_entry.bind('', lambda event: confirm_add()) - self.add_log(LogLevel.INFO, "点击添加交易标的按钮") + PrintLog(LogLevel.INFO, "点击添加交易标的按钮") @@ -550,14 +568,6 @@ class TradeTargetUI(ttk.Frame): # 刷新市场监控表格 self.populate_market_table() - def onLog(self, data:LogData): - # 使用全局日志 - self.main_window.add_log(data.level, data.message) - - def add_log(self, level:LogLevel, message): - """添加日志记录 - 转发到全局日志""" - self.main_window.add_log(level, message) - def system_settings(self): """系统设置""" # 获取顶层窗口 @@ -612,7 +622,7 @@ class TradeTargetUI(ttk.Frame): # 读取当前配置 config = configparser.ConfigParser() - config_path = sfgrid_config.get_config_path() + config_path = config.get('config', 'config_path') config.read(config_path, encoding='utf-8') # 创建输入框字典用于保存引用 @@ -823,40 +833,42 @@ class TradeTargetUI(ttk.Frame): # 定义保存和取消按钮的功能（button_frame已在上方创建） def save_settings(): """保存配置""" - try: - # 计算网格价格序列 - grid_prices = calculate_grid_prices() - if not grid_prices: - messagebox.showerror("错误", "网格价格参数有误，请检查输入！") - return + # try: + # # 计算网格价格序列 + # grid_prices = calculate_grid_prices() + # if not grid_prices: + # messagebox.showerror("错误", "网格价格参数有误，请检查输入！") + # return - grid_price_str = ",".join([str(p) for p in grid_prices]) + # grid_price_str = ",".join([str(p) for p in grid_prices]) - # 更新配置对象 - config.set('config', 'miniQMTPath', entries['miniQMTPath'].get()) - config.set('config', 'grid_price', grid_price_str) - config.set('config', 'grid_volume', entries['grid_volume'].get()) - config.set('config', 'account_no', entries['account_no'].get()) + # # 更新配置对象 + # config.set('config', 'miniQMTPath', entries['miniQMTPath'].get()) + # config.set('config', 'grid_price', grid_price_str) + # config.set('config', 'grid_volume', entries['grid_volume'].get()) + # config.set('config', 'account_no', entries['account_no'].get()) - # 写入配置文件 - config_path = sfgrid_config.get_config_path() - with open(config_path, 'w', encoding='utf-8') as configfile: - config.write(configfile) + # # 写入配置文件 + # config_path = config.get_config_path() + # with open(config_path, 'w', encoding='utf-8') as configfile: + # config.write(configfile) - # 重新加载配置到内存中 - sfgrid_config.initConfig() + # # 重新加载配置到内存中 + # config.initConfig() - messagebox.showinfo("成功", f"配置已保存！\n网格价格序列: {grid_price_str}\n部分配置可能需要重启程序后生效。") - self.add_log(LogLevel.INFO, f"系统配置已更新 - 网格数量: {len(grid_prices)}") - settings_window.destroy() + # messagebox.showinfo("成功", f"配置已保存！\n网格价格序列: {grid_price_str}\n部分配置可能需要重启程序后生效。") + # self.add_log(LogLevel.INFO, f"系统配置已更新 - 网格数量: {len(grid_prices)}") + # settings_window.destroy() - except Exception as e: - messagebox.showerror("错误", f"保存配置失败：{str(e)}") - self.add_log(LogLevel.ERROR, f"保存配置失败: {str(e)}") + # except Exception as e: + # messagebox.showerror("错误", f"保存配置失败：{str(e)}") + # self.add_log(LogLevel.ERROR, f"保存配置失败: {str(e)}") + pass def cancel_settings(): """取消设置""" - settings_window.destroy() + # settings_window.destroy() + pass # 在button_frame中添加按钮 ttk.Button(button_frame, text="💾 保存配置", command=save_settings, width=15).pack(side=tk.LEFT, padx=5) @@ -871,7 +883,7 @@ class TradeTargetUI(ttk.Frame): # 创建网格修正窗口 self.create_grid_correction_window(target) - def create_grid_correction_window(self, target: TradeTarget): + def create_grid_correction_window(self, target: SFGridTradeTarget): """创建网格修正窗口""" # 获取顶层窗口 root = self.winfo_toplevel() @@ -929,7 +941,7 @@ class TradeTargetUI(ttk.Frame): required_position_frame.pack(fill=tk.X, pady=5) grid_index_value = getattr(target, 'grid_index') - required_position = grid_index_value * sfgrid_config.grid_volume + required_position = grid_index_value * config.grid_volume ttk.Label(required_position_frame, text="需求持仓量:", width=12).pack(side=tk.LEFT) required_position_label = ttk.Label(required_position_frame, text=str(required_position), width=10, anchor=tk.CENTER) required_position_label.pack(side=tk.LEFT, padx=5) @@ -954,7 +966,7 @@ class TradeTargetUI(ttk.Frame): # 增加按钮 ttk.Button(grid_index_frame, text="+", width=3, - command=lambda: self.increase_grid_index(grid_index_var, len(sfgrid_config.grid_price)-1, target, required_position_label, position_status_label)).pack(side=tk.LEFT, padx=(5, 0)) + command=lambda: self.increase_grid_index(grid_index_var, len(config.grid_price)-1, target, required_position_label, position_status_label)).pack(side=tk.LEFT, padx=(5, 0)) # 当前价格（实时更新） price_frame = ttk.Frame(options_frame) @@ -978,7 +990,7 @@ class TradeTargetUI(ttk.Frame): command=correction_window.destroy).pack(side=tk.RIGHT, padx=5) # 监听市场数据更新 - def on_market_data_update(updated_target: TradeTarget): + def on_market_data_update(updated_target: SFGridTradeTarget): if updated_target.get_id() == target.get_id(): current_price_var.set(f"{updated_target.market_price:.3f}" if updated_target.market_price else "-") @@ -1005,13 +1017,13 @@ class TradeTargetUI(ttk.Frame): shortage = required_position - current_position status_label.config(text=f"还需补充 {shortage} 手仓位", foreground="red") - def save_grid_correction(self, window, target: TradeTarget, new_grid_index: int): + def save_grid_correction(self, window, target: SFGridTradeTarget, new_grid_index: int): """保存网格修正""" # 更新网格序号 setattr(target, 'grid_index', new_grid_index) # 重新计算需求持仓量 - required_position = new_grid_index * sfgrid_config.grid_volume + required_position = new_grid_index * config.grid_volume # 检查持仓量是否满足要求 current_position = getattr(target, 'current_position') @@ -1033,11 +1045,11 @@ class TradeTargetUI(ttk.Frame): window.destroy() # 添加日志 - self.add_log(LogLevel.INFO, f"网格修正已保存: {target.stock_code} - {target.stock_name}, 网格序号: {new_grid_index}") + PrintLog(LogLevel.INFO, f"网格修正已保存: {target.stock_code} - {target.stock_name}, 网格序号: {new_grid_index}") - def decrease_grid_index(self, grid_index_var: tk.IntVar, target: TradeTarget, required_position_label: ttk.Label, position_status_label: ttk.Label): + def decrease_grid_index(self, grid_index_var: tk.IntVar, target: SFGridTradeTarget, required_position_label: ttk.Label, position_status_label: ttk.Label): """减少网格序号""" current_value = grid_index_var.get() if current_value > 0: @@ -1045,7 +1057,7 @@ class TradeTargetUI(ttk.Frame): # 同步更新需求持仓量和持仓状态 self.update_required_position_and_status(grid_index_var.get(), target, required_position_label, position_status_label) - def increase_grid_index(self, grid_index_var: tk.IntVar, max_index: int, target: TradeTarget, required_position_label: ttk.Label, position_status_label: ttk.Label): + def increase_grid_index(self, grid_index_var: tk.IntVar, max_index: int, target: SFGridTradeTarget, required_position_label: ttk.Label, position_status_label: ttk.Label): """增加网格序号""" current_value = grid_index_var.get() if current_value < max_index: @@ -1053,10 +1065,10 @@ class TradeTargetUI(ttk.Frame): # 同步更新需求持仓量和持仓状态 self.update_required_position_and_status(grid_index_var.get(), target, required_position_label, position_status_label) - def update_required_position_and_status(self, grid_index: int, target: TradeTarget, required_position_label: ttk.Label, position_status_label: ttk.Label): + def update_required_position_and_status(self, grid_index: int, target: SFGridTradeTarget, required_position_label: ttk.Label, position_status_label: ttk.Label): """更新需求持仓量和持仓状态""" # 计算需求持仓量 - required_position = grid_index * sfgrid_config.grid_volume + required_position = grid_index * config.grid_volume required_position_label.config(text=str(required_position)) # 更新持仓量状态 diff --git a/core/util.py b/core/util.py index 1371717..5811fac 100644 --- a/core/util.py +++ b/core/util.py @@ -1,4 +1,4 @@ -import sfgrid_config +import config import xtquant.xtconstant as xtconstant from xtquant import xtdata, xttrader from xtquant.xttype import StockAccount, XtOrder, XtPosition @@ -58,7 +58,7 @@ def getStockPosition(stock_code: str, xt_trader: xttrader.XtQuantTrader, account return volume def minPosition(gridIndex:int): - return sfgrid_config.grid_volume * gridIndex + return config.grid_volume * gridIndex def queryPendingOrder(stock_code:str, tag: str, xt_trader: xttrader.XtQuantTrader, account: StockAccount) -> list[XtOrder]: if stock_code == None or tag == None: diff --git a/starter.py b/starter.py index 83c3b7c..8bca37e 100644 --- a/starter.py +++ b/starter.py @@ -1,21 +1,12 @@ # coding:utf-8 from core.database import db from core.main_ui import MainWindow -from core.sfgrid.main_controller import SFGridController -from core.logger import LogLevel, PrintLog -import sfgrid_config as sdConstants - -# def startTrade(index: int): -# ctrl.start_stock_trade(index) - -# def pauseTrade(index: int): -# ctrl.pause_stock_trade(index) +import config as sdConstants +from core.qmt import qmtv if __name__ == '__main__': sdConstants.initConfig() - # ctrl: SFGridController = SFGridController(sdConstants.account_no, sdConstants.miniQMTPath) - - # ctrl.hold() - + qmtv.init_qmtv() + qmtv.connect() window = MainWindow() window.run() From 54fd7c9545a9d1700bf90673972d20387fde3660 Mon Sep 17 00:00:00 2001 From: "GDP\\solonot" Date: Tue, 11 Nov 2025 17:45:56 +0800 Subject: [PATCH 5/9] new update --- core/eventbus.py | 14 +- core/qmt.py | 7 + core/sfgrid/bus_events.py | 14 ++ core/sfgrid/sfgrid_controller.py | 355 +++++++++---------------------- core/sfgrid/sfgrid_strategy.py | 7 +- core/sfgrid/sfgrid_ui.py | 70 ++---- core/util.py | 7 - 7 files changed, 148 insertions(+), 326 deletions(-) create mode 100644 core/sfgrid/bus_events.py diff --git a/core/eventbus.py b/core/eventbus.py index 713c16b..8d25158 100644 --- a/core/eventbus.py +++ b/core/eventbus.py @@ -1,22 +1,10 @@ -# 定义事件处理函数 -ActionEventEnableTrade = "enable_trade" -ResultEventTradeEnabled = "trade_enabled" -ActionEventDisableTrade = "disable_trade" -ResultEventTradeDisabled = "trade_disabled" + # 市场数据监听控制事件 MarketDataUpdate = "market_data_update" ActionEnableMarketData = "enable_market_data" ActionDisableMarketData = "disable_market_data" MarketDataEnabled = "market_data_enabled" MarketDataDisabled = "market_data_disabled" -# 删除交易标的事件 -EventTradeTargetUpdate = "trade_target_update" -ActionEventAddTradeTarget = "add_trade_target" -ResultEventTradeTargetAdded = "trade_target_added" -ActionEventDeleteTradeTarget = "delete_trade_target" -ResultEventTradeTargetDeleted = "trade_target_deleted" -# 网格修正事件 -ActionEventGridFix = "grid_fix" # Pring Log EventPrintLog = "print_log" diff --git a/core/qmt.py b/core/qmt.py index 0a64c15..cdff455 100644 --- a/core/qmt.py +++ b/core/qmt.py @@ -75,6 +75,13 @@ class QmtV(XtQuantTraderCallback): strategy_name, # strategy_name orderRemark # remark # type: ignore ) + + def getInstrumentName(self, stock_code:str): + # print(f"getInstrumentName: 获取标的名称 {stock_code}") + detail = xtdata.get_instrument_detail(stock_code, False) + if detail is None: + return None + return detail['InstrumentName'] # def print_position_info(self): # positions:list[XtPosition] = self.xt_trader.query_stock_positions(self.account) diff --git a/core/sfgrid/bus_events.py b/core/sfgrid/bus_events.py new file mode 100644 index 0000000..1542033 --- /dev/null +++ b/core/sfgrid/bus_events.py @@ -0,0 +1,14 @@ +# 删除交易标的事件 +EventTradeTargetUpdate = "trade_target_update" +ActionEventAddTradeTarget = "add_trade_target" +ResultEventTradeTargetAdded = "trade_target_added" +ActionEventDeleteTradeTarget = "delete_trade_target" +ResultEventTradeTargetDeleted = "trade_target_deleted" +# 网格修正事件 +ActionEventGridFix = "grid_fix" + +# 定义事件处理函数 +ActionEventEnableTrade = "enable_trade" +ResultEventTradeEnabled = "trade_enabled" +ActionEventDisableTrade = "disable_trade" +ResultEventTradeDisabled = "trade_disabled" \ No newline at end of file diff --git a/core/sfgrid/sfgrid_controller.py b/core/sfgrid/sfgrid_controller.py index 41a14bf..bbcf010 100644 --- a/core/sfgrid/sfgrid_controller.py +++ b/core/sfgrid/sfgrid_controller.py @@ -1,6 +1,10 @@ # coding:utf-8 +from typing import Any + + from core.sfgrid.model import SFGridTradeTarget as TradeTarget -from core.eventbus import ActionDisableMarketData, ActionEnableMarketData, ActionEventAddTradeTarget, ActionEventDeleteTradeTarget, ActionEventDisableTrade, ActionEventEnableTrade, EventTradeTargetUpdate, MarketDataUpdate, MarketDataEnabled, MarketDataDisabled, ResultEventTradeDisabled, ResultEventTradeEnabled, ResultEventTradeTargetDeleted, ActionEventGridFix, event_bus +from .bus_events import ActionEventAddTradeTarget, ActionEventDeleteTradeTarget, ActionEventDisableTrade, ActionEventEnableTrade, EventTradeTargetUpdate, ResultEventTradeDisabled, ResultEventTradeEnabled, ResultEventTradeTargetAdded, ResultEventTradeTargetDeleted, ActionEventGridFix +from core.eventbus import event_bus, MarketDataEnabled, MarketDataDisabled, MarketDataUpdate from xtquant import xttrader from xtquant.xttrader import XtQuantTrader import time @@ -9,7 +13,7 @@ from peewee import ModelSelect import core.sfgrid.model as model import config from core.sfgrid.sfgrid_strategy import SFGridStrategy -from core.util import getInstrumentName, getStockPosition, queryPendingOrder +from core.util import getStockPosition, queryPendingOrder from xtquant.xttrader import XtQuantTrader from xtquant.xttype import StockAccount, XtAsset, XtOrder, XtPosition, XtTrade from xtquant import xtdata @@ -21,52 +25,79 @@ from core.qmt import qmtv from core.sfgrid.objects import GridFixData # 量化核心控制对象 -class SFGridController(XtQuantTraderCallback): +class SFGridController: def __init__(self): super().__init__() self.registerEventHandler() - self.listening_stock = [] - self.stock_trade_ctrl = {} - self.init_instrument_pool(qmtv.xttrader, qmtv.account) # type: ignore - self.seq = None PrintLog(LogLevel.INFO, '- [成功]三疯交易系统初始化完成') - self.startMarketData() + def registerEventHandler(self): event_bus.subscribe(ActionEventEnableTrade, self.onEnableTrade) event_bus.subscribe(ActionEventDisableTrade, self.onDisableTrade) - event_bus.subscribe(ActionEnableMarketData, self.onMarketDataEnabled) - event_bus.subscribe(ActionDisableMarketData, self.onMarketDataDisabled) event_bus.subscribe(ActionEventAddTradeTarget, self.onAddTradeTarget) event_bus.subscribe(ActionEventDeleteTradeTarget, self.onDeleteTradeTarget) event_bus.subscribe(ActionEventGridFix, self.onGridFix) - def onDeleteTradeTarget(self, id: int): + def onDeleteTradeTarget(self, target: TradeTarget): """处理删除交易标的事件""" - self.del_trade_target(id) - # 发布删除完成事件 - event_bus.publish(ResultEventTradeTargetDeleted, id) + id = target.get_id() + try: + # 从数据库中删除 + target.delete_instance() + + PrintLog(LogLevel.INFO, f"已删除交易标的: id{id} {target.stock_code} - {target.stock_name}") + # 发布删除完成事件 + event_bus.publish(ResultEventTradeTargetDeleted, target) + except Exception as e: + PrintLog(LogLevel.ERROR, f"删除交易标的失败 ID {id}: {str(e)}") def onAddTradeTarget(self, stock_code: str): """处理添加交易标的事件""" - self.add_trade_target(stock_code) - - def onMarketDataEnabled(self, data): - """处理市场数据监听启用事件""" - self.startMarketData() - - def onMarketDataDisabled(self, data): - """处理市场数据监听禁用事件""" - self.stopMarketData() + try: + stock_name = qmtv.getInstrumentName(stock_code) + if not stock_name: + PrintLog(LogLevel.ERROR, f'无法获取股票代码 {stock_code} 的名称，请检查代码是否正确') + return + + # 检查是否已存在该标的 + existing_target = TradeTarget.get_or_none(TradeTarget.stock_code == stock_code) + if existing_target: + PrintLog(LogLevel.INFO, f'交易标的 {stock_code} {stock_name} 已存在') + return + + # 刷新标的持仓 + pos = qmtv.getStockPosition(stock_code) # type: ignore + new_target = TradeTarget.create( + stock_name=stock_name, + stock_code=stock_code, + market_price=0.0, + current_position=pos, + grid_index=0, + last_trade_price=0.0, + plan_buy_price=0.0, + plan_sell_price=0.0, + current_order_price=0.0, + current_order_no='', + current_order_type='' + ) + new_target.save() + # 更新标的池 + event_bus.publish(ResultEventTradeTargetAdded, new_target) + + except Exception as e: + PrintLog(LogLevel.ERROR, f'新增交易标的失败 {stock_code} {e}') def onEnableTrade(self, id: int): - self.start_stock_trade(id) + pass + # self.start_stock_trade(id) def onDisableTrade(self, id: int): - self.pause_stock_trade(id) + pass + # self.pause_stock_trade(id) def onGridFix(self, data: GridFixData): """处理网格修正事件""" @@ -82,28 +113,9 @@ class SFGridController(XtQuantTraderCallback): target.grid_index = grid_index target.save() - # 更新内存中的交易标的 - if target.get_id() in self.instrument_pool: - self.instrument_pool[target.get_id()] = target - - # 更新交易控制器中的网格信息 - if target.stock_code in self.stock_trade_ctrl: - trade_controller: SFGridStrategy = self.stock_trade_ctrl[target.stock_code] - trade_controller.updateGridIndex(grid_index) # type: ignore - PrintLog(LogLevel.INFO, f"网格修正已应用: {target.stock_code} - {target.stock_name}, 网格索引: {grid_index}") except Exception as e: PrintLog(LogLevel.ERROR, f"网格修正更新失败: {str(e)}") - - def startMarketData(self): - PrintLog(LogLevel.INFO, '- 启动市场数据订阅') - - self.seq = xtdata.subscribe_whole_quote(['SH', 'SZ'], callback=self.onDataUpdate) - if self.seq == -1: - PrintLog(LogLevel.ERROR, '- 市场数据订阅失败') - else: - event_bus.publish(MarketDataEnabled, True) - PrintLog(LogLevel.INFO, f'- 市场数据订阅成功, 订阅号={self.seq}') @@ -114,222 +126,53 @@ class SFGridController(XtQuantTraderCallback): xtdata.unsubscribe_quote(self.seq) event_bus.publish(MarketDataDisabled, False) - - def add_trade_target(self, stock_code: str): - try: - stock_name = getInstrumentName(stock_code) - if not stock_name: - PrintLog(LogLevel.ERROR, f'无法获取股票代码 {stock_code} 的名称，请检查代码是否正确') - return - - # 检查是否已存在该标的 - existing_target = TradeTarget.get_or_none(TradeTarget.stock_code == stock_code) - if existing_target: - PrintLog(LogLevel.INFO, f'交易标的 {stock_code} {stock_name} 已存在') - return - - new_target = TradeTarget.create( - stock_name=stock_name, - stock_code=stock_code, - market_price=0.0, - current_position=0, - grid_index=0, - last_trade_price=0.0, - plan_buy_price=0.0, - plan_sell_price=0.0, - current_order_price=0.0, - current_order_no='', - current_order_type='' - ) - new_target.save() - PrintLog(LogLevel.INFO, f'新增交易标的 {stock_code} {stock_name}, {new_target.id}') - # 刷新标的持仓 - pos = getStockPosition(stock_code, self.xt_trader, self.account) # type: ignore - TradeTarget.update(current_position=pos).where(TradeTarget.stock_code == stock_code).execute() - # 更新标的池 - self.refresh_targets() - # 添加交易控制器 - stockTradeController = SFGridStrategy(new_target, self.xt_trader, self.account) # type: ignore - self.stock_trade_ctrl[stock_code] = stockTradeController - - except Exception as e: - PrintLog(LogLevel.ERROR, f'新增交易标的失败 {stock_code} {e}') - - - def del_trade_target(self, id:int): - try: - # 检查标的是否存在 - if id not in self.instrument_pool: - PrintLog(LogLevel.ERROR, f"交易标的 ID {id} 不存在") - return - - target: TradeTarget = self.instrument_pool[id] - - # 如果存在交易控制器，先停止交易 - if target.stock_code in self.stock_trade_ctrl: - # 停止交易控制器 - del self.stock_trade_ctrl[target.stock_code] - - # 从数据库中删除 - target.delete_instance() - - # 从内存中删除 - del self.instrument_pool[id] - - # 刷新标的池 - self.refresh_targets() - - PrintLog(LogLevel.INFO, f"已删除交易标的: {target.stock_code} - {target.stock_name}") - except Exception as e: - PrintLog(LogLevel.ERROR, f"删除交易标的失败 ID {id}: {str(e)}") - def init_instrument_pool(self, xtTrader:XtQuantTrader, account:StockAccount): - self.refresh_targets() - - for id in self.instrument_pool: - target:TradeTarget = self.instrument_pool[id] - status = "新建" if target.status == 0 else "已建初始仓" - PrintLog(LogLevel.INFO, f' [序号-{id}] 股票代码: {target.stock_code}-{target.stock_name} 当前持仓: {getStockPosition(target.stock_code, self.xt_trader, self.account)} 网格索引: {target.grid_index} 基准价格 {config.grid_price[target.grid_index]} 状态: {status} 启用交易线程: {'自动交易中' if target.enabled else '交易已停止'}') # type: ignore - - tradeTarget:TradeTarget = self.instrument_pool[id] - tradeTarget.current_position = getStockPosition(tradeTarget.stock_code, xtTrader, account) # type: ignore - result = tradeTarget.save() - PrintLog(LogLevel.INFO, f' |- 同步[{target.stock_code}-{target.stock_name}]持仓信息[{'成功' if result == 1 else '失败'}]') - stockTradeController = SFGridStrategy(tradeTarget, self.xt_trader, self.account) # type: ignore - self.stock_trade_ctrl[tradeTarget.stock_code] = stockTradeController - event_bus.publish(EventTradeTargetUpdate, tradeTarget) - - PrintLog(LogLevel.INFO, f'- [成功]交易标的信息初始化, 共 {len(self.instrument_pool)} 个标的') + # # 初始化指定标的交易控制器 + # def start_stock_trade(self, tradeTarget: TradeTarget): + # # check existing thread + # if tradeTarget.stock_code in self.stock_trade_ctrl: + # tradeController: SFGridStrategy = self.stock_trade_ctrl[tradeTarget.stock_code] + + # tradeTarget = tradeController.enabledTrading(True) + # self.instrument_pool[id] = tradeTarget + # event_bus.publish(ResultEventTradeEnabled, tradeTarget) + # else: + # PrintLog(LogLevel.INFO, f"\t创建标的交易控制器 {tradeTarget.stock_code} {getInstrumentName(tradeTarget.stock_code)}") - def refresh_targets(self): - # 更新标的池 - results:ModelSelect = TradeTarget.select() - self.instrument_pool: dict[int, TradeTarget] = {} - for temp in results: - result :TradeTarget = temp - self.instrument_pool[result.get_id()] = result - - - # 初始化指定标的交易控制器 - def start_stock_trade(self, id: int): - tradeTarget: TradeTarget = self.instrument_pool[id] - # check existing thread - if tradeTarget.stock_code in self.stock_trade_ctrl: - tradeController: SFGridStrategy = self.stock_trade_ctrl[tradeTarget.stock_code] - - tradeTarget = tradeController.enabledTrading(True) - self.instrument_pool[id] = tradeTarget - event_bus.publish(ResultEventTradeEnabled, tradeTarget) - else: - PrintLog(LogLevel.INFO, f"\t创建标的交易控制器 {tradeTarget.stock_code} {getInstrumentName(tradeTarget.stock_code)}") - - - def pause_stock_trade(self, id: int): - localTarget: TradeTarget = self.instrument_pool[id] - print(f'暂停标的交易 {localTarget.stock_code} - enabled {localTarget.enabled}') - if localTarget.stock_code in self.stock_trade_ctrl: - tradeController: SFGridStrategy = self.stock_trade_ctrl[localTarget.stock_code] - tradeTarget = tradeController.enabledTrading(False) - orders = queryPendingOrder(localTarget.stock_code, tradeController.getName(), self.xt_trader, self.account) # type: ignore - for order in orders: - qmtv.xttrader.cancel_order_stock_async(qmtv.account, order.order_id) - print(f'取消未成交订单 {len(orders)}') - self.instrument_pool[id] = tradeTarget - event_bus.publish(ResultEventTradeDisabled, tradeTarget) - else: - print(f"标的交易控制器不存在 {localTarget.stock_code} {localTarget.stock_name}\n") + # def pause_stock_trade(self, id: int): + # localTarget: TradeTarget = self.instrument_pool[id] + # print(f'暂停标的交易 {localTarget.stock_code} - enabled {localTarget.enabled}') + # if localTarget.stock_code in self.stock_trade_ctrl: + # tradeController: SFGridStrategy = self.stock_trade_ctrl[localTarget.stock_code] + # tradeTarget = tradeController.enabledTrading(False) + # orders = queryPendingOrder(localTarget.stock_code, tradeController.getName(), self.xt_trader, self.account) # type: ignore + # for order in orders: + # qmtv.xttrader.cancel_order_stock_async(qmtv.account, order.order_id) + # print(f'取消未成交订单 {len(orders)}') + # self.instrument_pool[id] = tradeTarget + # event_bus.publish(ResultEventTradeDisabled, tradeTarget) + # else: + # print(f"标的交易控制器不存在 {localTarget.stock_code} {localTarget.stock_name}\n") # ====== 市场回调方法 -- 以下方法由XtQuantData调用 ====== - def onDataUpdate(self, data): - # 收集所有市场数据用于市场监控 - for stock_code, tickData in data.items(): - if stock_code in self.stock_trade_ctrl: - stock_controller: SFGridStrategy = self.stock_trade_ctrl[stock_code] - stock_controller.onDataUpdate(data) - else: - # 非目标交易，发布市场数据更新事件用于市场监控 - lastPrice = tickData['lastPrice'] - if lastPrice == 10 or stock_code in self.listening_stock: - # 发布市场数据更新事件用于市场监控 - market_target = TradeTarget() - market_target.stock_code = stock_code - market_target.stock_name = getInstrumentName(stock_code) # type: ignore - market_target.market_price = lastPrice # type: ignore - event_bus.publish(MarketDataUpdate, market_target) - if stock_code not in self.listening_stock: - self.listening_stock.append(stock_code) + # def onDataUpdate(self, data): + # # 收集所有市场数据用于市场监控 + # for stock_code, tickData in data.items(): + # if stock_code in self.stock_trade_ctrl: + # stock_controller: SFGridStrategy = self.stock_trade_ctrl[stock_code] + # stock_controller.onDataUpdate(data) + # else: + # # 非目标交易，发布市场数据更新事件用于市场监控 + # lastPrice = tickData['lastPrice'] + # if lastPrice == 10 or stock_code in self.listening_stock: + # # 发布市场数据更新事件用于市场监控 + # market_target = TradeTarget() + # market_target.stock_code = stock_code + # market_target.stock_name = getInstrumentName(stock_code) # type: ignore + # market_target.market_price = lastPrice # type: ignore + # event_bus.publish(MarketDataUpdate, market_target) + # if stock_code not in self.listening_stock: + # self.listening_stock.append(stock_code) - - # ====== 市场回调方法 -- 以下方法由XtQuantTrader调用 ====== - def on_connected(self): - """ - 连接成功推送 - """ - print(datetime.datetime.now(), '连接成功回调') - - def on_disconnected(self): - """ - 连接断开 - :return: - """ - print(datetime.datetime.now(), '连接断开回调') - - def on_stock_order(self, order:XtOrder): - """ - 委托回报推送 - :param order: XtOrder对象 - :return: - """ - print(f'orderd {order.strategy_name}-{order.stock_code} {order.order_id} {order.order_volume}-{order.order_status}') - 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): - """ - 成交变动推送 - :param trade: XtTrade对象 - :return: - """ - stockCode = trade.stock_code - ctrl:SFGridStrategy = self.stock_trade_ctrl[stockCode] - # 如果存在对应的StockTradeController，则调用其onDataUpdate方法 - if ctrl is not None and trade.strategy_name == ctrl.getName(): - ctrl.onOrderTrade(trade) - else: - print(f"委托回调 投资备注 {trade.strategy_name} 不匹配 {ctrl.getName()}") - - # def on_order_stock_async_response(self, response:XtOrderResponse): - # stockCode = response.order_remark - # ctrl:SFGridStrategy = self.stock_trade_ctrl[stockCode] - # # 如果存在对应的StockTradeController，则调用其onDataUpdate方法 - # if ctrl is not None and response.strategy_name == ctrl.getName(): - # ctrl.onAsyncOrderResponse(response) - # else: - # print(f"委托回调 投资备注 {response.strategy_name} 不匹配 {ctrl.getName()}") - - def on_order_error(self, order_error): - """ - 委托失败推送 - :param order_error:XtOrderError 对象 - :return: - """ - # print("on order_error callback") - # print(order_error.order_id, order_error.error_id, order_error.error_msg) - print(f"\n委托报错回调 {order_error.order_remark} {order_error.error_msg}") - - - def on_account_status(self, status): - """ - :param response: XtAccountStatus 对象 - :return: - """ - print(datetime.datetime.now(), status) \ No newline at end of file diff --git a/core/sfgrid/sfgrid_strategy.py b/core/sfgrid/sfgrid_strategy.py index 723bfe8..3283b99 100644 --- a/core/sfgrid/sfgrid_strategy.py +++ b/core/sfgrid/sfgrid_strategy.py @@ -1,12 +1,13 @@ from core.qmt import qmtv +from core.sfgrid.bus_events import EventTradeTargetUpdate import core.sfgrid.model as model from core import constants -from core.eventbus import EventTradeTargetUpdate, event_bus +from core.eventbus import event_bus from core.constants import OrderTypeBuy, OrderTypeInit, OrderTypeSell from core.util import queryPendingOrder, is_trading_time -from xtquant import xttrader, xtconstant -from xtquant.xttype import StockAccount, XtOrder, XtTrade +from xtquant import xtconstant +from xtquant.xttype import XtOrder, XtTrade import config import threading diff --git a/core/sfgrid/sfgrid_ui.py b/core/sfgrid/sfgrid_ui.py index 9b4901b..7f19c43 100644 --- a/core/sfgrid/sfgrid_ui.py +++ b/core/sfgrid/sfgrid_ui.py @@ -7,31 +7,36 @@ import threading import time import core.eventbus as eBus from core.logger import LogLevel, PrintLog +from core.sfgrid.bus_events import ActionEventAddTradeTarget, ActionEventDeleteTradeTarget, ActionEventDisableTrade, ActionEventEnableTrade, ActionEventGridFix, EventTradeTargetUpdate, ResultEventTradeTargetAdded, ResultEventTradeTargetDeleted from core.sfgrid.model import SFGridTradeTarget import configparser import config from core.sfgrid.objects import GridFixData from core.qmt import qmtv +from core.sfgrid.sfgrid_controller import SFGridController from core.sfgrid.sfgrid_strategy import SFGridStrategy class TradeTargetUI(ttk.Frame): def __init__(self, parent): super().__init__(parent) + self.controller = SFGridController() self.tradeTargetData:dict[int, SFGridTradeTarget] = {} # id->trade_target - self.strategy_ctrl:dict[str, SFGridStrategy] = {} # stock_code->trade_target + self.strategy_ctrl:dict[int, SFGridStrategy] = {} # stock_code->trade_target self.init_trade_target_pool() self.registerEventHandler() # 创建刷新线程标志 - self.refresh_thread_running = True # 默认不启动刷新线程 + self.refresh_thread_running = False # 默认不启动刷新线程 # 市场监控数据 self.marketData: dict[str, Any] = {} # 存储市场数据 {stock_code: {stock_name, last_price, time}} # 创建界面 self.create_ui() + + self.start_ui_refresh() def refresh_targets(self): # 更新标的池 @@ -52,20 +57,21 @@ class TradeTargetUI(ttk.Frame): result = tradeTarget.save() PrintLog(LogLevel.INFO, f' |- 同步[{tradeTarget.stock_code}-{tradeTarget.stock_name}]持仓信息[{'成功' if result == 1 else '失败'}]') stockTradeController = SFGridStrategy(tradeTarget) # type: ignore - self.strategy_ctrl[tradeTarget.stock_code] = stockTradeController # pyright: ignore[reportArgumentType] + self.strategy_ctrl[id] = stockTradeController # pyright: ignore[reportArgumentType] # eBus.event_bus.publish(eBus.EventTradeTargetUpdate, tradeTarget) PrintLog(LogLevel.INFO, f'- [成功]交易标的信息初始化, 共 {len(self.tradeTargetData)} 个标的') def registerEventHandler(self): - # eBus.event_bus.subscribe(eBus.EventTradeTargetUpdate, self.onTradeTargetUpdated) + eBus.event_bus.subscribe(EventTradeTargetUpdate, self.onTradeTargetUpdated) # eBus.event_bus.subscribe(eBus.MarketDataUpdate, self.onMarketDataUpdated) # eBus.event_bus.subscribe(eBus.ResultEventTradeEnabled, self.onTradeEnabled) # eBus.event_bus.subscribe(eBus.ResultEventTradeDisabled, self.onTradeDisabled) # eBus.event_bus.subscribe(eBus.MarketDataEnabled, self.onMarketDataToggled) # eBus.event_bus.subscribe(eBus.MarketDataDisabled, self.onMarketDataToggled) - eBus.event_bus.subscribe(eBus.ResultEventTradeTargetDeleted, self.onTradeTargetDeleted) + eBus.event_bus.subscribe(ResultEventTradeTargetDeleted, self.onTradeTargetDeleted) + eBus.event_bus.subscribe(ResultEventTradeTargetAdded, self.onTradeTargetUpdated) def start_refresh_thread(self): """启动刷新线程""" @@ -84,22 +90,17 @@ class TradeTargetUI(ttk.Frame): """停止刷新线程""" self.refresh_thread_running = False - def onTradeTargetDeleted(self, id: int): + def onTradeTargetDeleted(self, target: SFGridTradeTarget): """处理交易标的删除完成事件""" # 从本地数据中删除 + id = target.get_id() if id in self.tradeTargetData: + PrintLog(LogLevel.DEBUG, f"删除交易标的，ID: {id}") del self.tradeTargetData[id] + del self.strategy_ctrl[id] # 添加日志 PrintLog(LogLevel.INFO, f"交易标的已删除，ID: {id}") - - def onMarketDataToggled(self, data:bool): - self.market_data_enabled = self.market_data_switch_var.get() - PrintLog(LogLevel.INFO, "市场数据监听已" + ("启用" if data else "禁用")) - # 同步UI刷新线程状态 - if data: - self.start_ui_refresh() - else: - self.stop_ui_refresh() + def onTradeEnabled(self, target:SFGridTradeTarget): PrintLog(LogLevel.INFO, f"交易启用: {target.stock_code} - {target.stock_name}") @@ -147,33 +148,9 @@ class TradeTargetUI(ttk.Frame): # 添加分隔符 ttk.Separator(toolbar_frame, orient='vertical').pack(side=tk.LEFT, fill=tk.Y, padx=10) - # 市场数据监听开关 - self.market_data_switch_var = tk.BooleanVar(value=False) - # self.market_data_switch = ttk.Checkbutton( - # toolbar_frame, - # text="📊 市场数据", - # variable=self.market_data_switch_var, - # command=self.toggle_market_data, - # width=12 - # ) - # self.market_data_switch.pack(side=tk.LEFT, padx=2) - # 表格区域 self.create_tables_area(main_frame) - def toggle_market_data(self): - """切换市场数据监听状态""" - print(f'市场数据监听开关') - self.market_data_enabled = self.market_data_switch_var.get() - if self.market_data_enabled: - eBus.event_bus.publish(eBus.ActionEnableMarketData, True) - # 同步开启UI刷新线程 - self.start_ui_refresh() - else: - eBus.event_bus.publish(eBus.ActionDisableMarketData, True) - # 同步关闭UI刷新线程 - self.stop_ui_refresh() - def start_ui_refresh(self): """启动UI刷新线程""" if not self.refresh_thread_running: @@ -333,7 +310,7 @@ class TradeTargetUI(ttk.Frame): if result: # 发布事件通知主控制器添加标的 - eBus.event_bus.publish(eBus.ActionEventAddTradeTarget, stock_code) + eBus.event_bus.publish(ActionEventAddTradeTarget, stock_code) PrintLog(LogLevel.INFO, f"已发送添加请求: {stock_code} - {stock_name}") def get_status_indicator(self, target: SFGridTradeTarget) -> str: @@ -432,12 +409,12 @@ class TradeTargetUI(ttk.Frame): if result: target.enabled = True # type: ignore - eBus.event_bus.publish(eBus.ActionEventEnableTrade, target.get_id()) + eBus.event_bus.publish(ActionEventEnableTrade, target.get_id()) # self.add_log("INFO", f"已启动交易: {target.stock_code} - {target.stock_name}") # messagebox.showinfo("启动成功", f"已启动 {target.stock_code} ({target.stock_name}) 的交易") def on_trade_enabled(self, target: SFGridTradeTarget): - eBus.event_bus.publish(eBus.ActionEventEnableTrade, target) + eBus.event_bus.publish(ActionEventEnableTrade, target) def pause_selected_trade(self): """暂停选中的交易""" @@ -458,7 +435,7 @@ class TradeTargetUI(ttk.Frame): if result: target.enabled = False # type: ignore - eBus.event_bus.publish(eBus.ActionEventDisableTrade, target.get_id()) + eBus.event_bus.publish(ActionEventDisableTrade, target.get_id()) # self.add_log("INFO", f"已暂停交易: {target.stock_code} - {target.stock_name}") # messagebox.showinfo("暂停成功", f"已暂停 {target.stock_code} ({target.stock_name}) 的交易") @@ -479,7 +456,7 @@ class TradeTargetUI(ttk.Frame): if result: # 通过事件总线发出删除动作 - eBus.event_bus.publish(eBus.ActionEventDeleteTradeTarget, target.get_id()) + eBus.event_bus.publish(ActionEventDeleteTradeTarget, target) PrintLog(LogLevel.INFO, f"已发送删除请求: {target.stock_code} - {target.stock_name}") def add_trade_target(self): @@ -524,7 +501,7 @@ class TradeTargetUI(ttk.Frame): return # 发布事件通知主控制器添加标的 - eBus.event_bus.publish(eBus.ActionEventAddTradeTarget, stock_code) + eBus.event_bus.publish(ActionEventAddTradeTarget, stock_code) add_window.destroy() def cancel_add(): @@ -540,7 +517,6 @@ class TradeTargetUI(ttk.Frame): PrintLog(LogLevel.INFO, "点击添加交易标的按钮") - def refresh_table(self): """刷新表格数据""" # 保存当前选中的项 @@ -1039,7 +1015,7 @@ class TradeTargetUI(ttk.Frame): # 发布网格修正事件，传递GridFixData对象 grid_fix_data = GridFixData(new_grid_index, target) - eBus.event_bus.publish(eBus.ActionEventGridFix, grid_fix_data) + eBus.event_bus.publish(ActionEventGridFix, grid_fix_data) # 关闭窗口 window.destroy() diff --git a/core/util.py b/core/util.py index 5811fac..27addb4 100644 --- a/core/util.py +++ b/core/util.py @@ -37,13 +37,6 @@ def is_trading_time(): return False -def getInstrumentName(stock_code): - # print(f"getInstrumentName: 获取标的名称 {stock_code}") - detail = xtdata.get_instrument_detail(stock_code, False) - if detail is None: - return "UnNamed" - return detail['InstrumentName'] - def getStockPosition(stock_code: str, xt_trader: xttrader.XtQuantTrader, account: StockAccount): volume = 0 From 0dbd8e8ddeaa6cfed2fd4269c150d97552204fe9 Mon Sep 17 00:00:00 2001 From: "GDP\\solonot" Date: Tue, 11 Nov 2025 18:09:42 +0800 Subject: [PATCH 6/9] =?UTF-8?q?=E5=AE=8C=E6=88=90=E6=B7=BB=E5=8A=A0?= =?UTF-8?q?=EF=BC=8C=E5=88=A0=E9=99=A4=EF=BC=8C=E5=BC=80=E5=90=AF=EF=BC=8C?= =?UTF-8?q?=E5=81=9C=E6=AD=A2=E6=96=B9=E6=B3=95=E7=9A=84=E9=87=8D=E6=9E=84?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- core/main_ui.py | 9 ++------- core/sfgrid/sfgrid_controller.py | 27 --------------------------- core/sfgrid/sfgrid_ui.py | 29 ++++++++++++++++++++--------- 3 files changed, 22 insertions(+), 43 deletions(-) diff --git a/core/main_ui.py b/core/main_ui.py index 87c2607..df9eed5 100644 --- a/core/main_ui.py +++ b/core/main_ui.py @@ -1,18 +1,13 @@ -import time import tkinter as tk from tkinter import ttk from core.logger import LogLevel, PrintLog from core.sfgrid.sfgrid_ui import TradeTargetUI -import config -from xtquant import xtdata -from xtquant.xttrader import XtQuantTrader, XtQuantTraderCallback -import datetime -from xtquant.xttype import StockAccount, XtAsset, XtOrder, XtOrderResponse, XtPosition, XtTrade + class MainWindow: def __init__(self): self.root = tk.Tk() - self.root.title("三疯交易系统") + self.root.title("神之一手 - 交易系统") self.root.geometry("1400x700") # 当前选中的策略Tab索引 diff --git a/core/sfgrid/sfgrid_controller.py b/core/sfgrid/sfgrid_controller.py index bbcf010..e011675 100644 --- a/core/sfgrid/sfgrid_controller.py +++ b/core/sfgrid/sfgrid_controller.py @@ -36,8 +36,6 @@ class SFGridController: def registerEventHandler(self): - event_bus.subscribe(ActionEventEnableTrade, self.onEnableTrade) - event_bus.subscribe(ActionEventDisableTrade, self.onDisableTrade) event_bus.subscribe(ActionEventAddTradeTarget, self.onAddTradeTarget) event_bus.subscribe(ActionEventDeleteTradeTarget, self.onDeleteTradeTarget) event_bus.subscribe(ActionEventGridFix, self.onGridFix) @@ -90,14 +88,6 @@ class SFGridController: except Exception as e: PrintLog(LogLevel.ERROR, f'新增交易标的失败 {stock_code} {e}') - - def onEnableTrade(self, id: int): - pass - # self.start_stock_trade(id) - - def onDisableTrade(self, id: int): - pass - # self.pause_stock_trade(id) def onGridFix(self, data: GridFixData): """处理网格修正事件""" @@ -139,23 +129,6 @@ class SFGridController: # else: # PrintLog(LogLevel.INFO, f"\t创建标的交易控制器 {tradeTarget.stock_code} {getInstrumentName(tradeTarget.stock_code)}") - - # def pause_stock_trade(self, id: int): - # localTarget: TradeTarget = self.instrument_pool[id] - # print(f'暂停标的交易 {localTarget.stock_code} - enabled {localTarget.enabled}') - # if localTarget.stock_code in self.stock_trade_ctrl: - # tradeController: SFGridStrategy = self.stock_trade_ctrl[localTarget.stock_code] - # tradeTarget = tradeController.enabledTrading(False) - # orders = queryPendingOrder(localTarget.stock_code, tradeController.getName(), self.xt_trader, self.account) # type: ignore - # for order in orders: - # qmtv.xttrader.cancel_order_stock_async(qmtv.account, order.order_id) - # print(f'取消未成交订单 {len(orders)}') - # self.instrument_pool[id] = tradeTarget - # event_bus.publish(ResultEventTradeDisabled, tradeTarget) - # else: - # print(f"标的交易控制器不存在 {localTarget.stock_code} {localTarget.stock_name}\n") - - # ====== 市场回调方法 -- 以下方法由XtQuantData调用 ====== # def onDataUpdate(self, data): # # 收集所有市场数据用于市场监控 diff --git a/core/sfgrid/sfgrid_ui.py b/core/sfgrid/sfgrid_ui.py index 7f19c43..558f652 100644 --- a/core/sfgrid/sfgrid_ui.py +++ b/core/sfgrid/sfgrid_ui.py @@ -352,7 +352,6 @@ class TradeTargetUI(ttk.Frame): ] self.trade_table.insert('', tk.END, values=values) - def get_status_text(self, status): @@ -408,13 +407,16 @@ class TradeTargetUI(ttk.Frame): ) if result: + PrintLog(LogLevel.INFO, f'启动标的交易 {target.targetName()}') target.enabled = True # type: ignore - eBus.event_bus.publish(ActionEventEnableTrade, target.get_id()) - # self.add_log("INFO", f"已启动交易: {target.stock_code} - {target.stock_name}") - # messagebox.showinfo("启动成功", f"已启动 {target.stock_code} ({target.stock_name}) 的交易") - def on_trade_enabled(self, target: SFGridTradeTarget): - eBus.event_bus.publish(ActionEventEnableTrade, target) + id = target.get_id() + if id in self.strategy_ctrl: + tradeController: SFGridStrategy = self.strategy_ctrl[target.get_id()] + tradeTarget = tradeController.enabledTrading(True) + self.tradeTargetData[id] = tradeTarget + else: + PrintLog(LogLevel.INFO, f"\t创建标的交易控制器 {target.targetName()}") def pause_selected_trade(self): """暂停选中的交易""" @@ -434,8 +436,18 @@ class TradeTargetUI(ttk.Frame): ) if result: - target.enabled = False # type: ignore - eBus.event_bus.publish(ActionEventDisableTrade, target.get_id()) + PrintLog(LogLevel.INFO, f'暂停标的交易 {target.targetName()}') + id = target.get_id() + if id in self.strategy_ctrl: + tradeController: SFGridStrategy = self.strategy_ctrl[target.get_id()] + tradeTarget = tradeController.enabledTrading(False) + orders = qmtv.queryPendingOrder(target.stock_code, tradeController.getName()) # type: ignore + for order in orders: + qmtv.xttrader.cancel_order_stock_async(qmtv.account, order.order_id) + print(f'取消未成交订单 {len(orders)}') + self.tradeTargetData[id] = tradeTarget + else: + print(f"标的交易控制器不存在 {target.stock_code} {target.stock_name}\n") # self.add_log("INFO", f"已暂停交易: {target.stock_code} - {target.stock_name}") # messagebox.showinfo("暂停成功", f"已暂停 {target.stock_code} ({target.stock_name}) 的交易") @@ -516,7 +528,6 @@ class TradeTargetUI(ttk.Frame): PrintLog(LogLevel.INFO, "点击添加交易标的按钮") - def refresh_table(self): """刷新表格数据""" # 保存当前选中的项 From ba9cd9a700adb8154795509eff312bf68f406f77 Mon Sep 17 00:00:00 2001 From: "GDP\\solonot" Date: Wed, 12 Nov 2025 10:15:14 +0800 Subject: [PATCH 7/9] update --- core/main_ui.py | 3 - core/qmt.py | 12 ++- core/sfgrid/sfgrid_controller.py | 151 ------------------------------- core/sfgrid/sfgrid_ui.py | 138 +++++++++++++++++----------- core/sfgrid/ui.py | 0 5 files changed, 94 insertions(+), 210 deletions(-) delete mode 100644 core/sfgrid/sfgrid_controller.py create mode 100644 core/sfgrid/ui.py diff --git a/core/main_ui.py b/core/main_ui.py index df9eed5..7a9a828 100644 --- a/core/main_ui.py +++ b/core/main_ui.py @@ -180,9 +180,6 @@ class MainWindow: # 更新Tab按钮样式（可选，用于视觉反馈） self.update_tab_button_styles() - - - def update_tab_button_styles(self): """更新Tab按钮的样式以显示选中状态""" diff --git a/core/qmt.py b/core/qmt.py index cdff455..eb90423 100644 --- a/core/qmt.py +++ b/core/qmt.py @@ -8,6 +8,7 @@ from core.logger import LogLevel, PrintLog from xtquant.xttrader import XtQuantTrader, XtQuantTraderCallback from xtquant.xttype import StockAccount from xtquant import xtconstant, xtdata +import core.eventbus as eBus class QmtV(XtQuantTraderCallback): def __init__(self) -> None: @@ -41,6 +42,7 @@ class QmtV(XtQuantTraderCallback): if subscribe_result != 0: self.inited = False return + self.startMarketDataSubscription() def getStockPosition(self, stock_code: str): @@ -126,11 +128,19 @@ class QmtV(XtQuantTraderCallback): # ========================================# + def startMarketDataSubscription(self): + self.subscriptionId = xtdata.subscribe_whole_quote(['SH', 'SZ'], self.onDataUpdate) + + def stopMarketDataSubscription(self): + PrintLog(LogLevel.INFO, '- 停止市场数据订阅') + + if self.subscriptionId is not None and self.subscriptionId > 0: + xtdata.unsubscribe_quote(self.subscriptionId) # ====== 市场回调方法 -- 以下方法由XtQuantData调用 ====== def onDataUpdate(self, data): # 收集所有市场数据用于市场监控 - print(f'market data update {len(data)}') + eBus.event_bus.publish(eBus.MarketDataUpdate, data) # ====== 市场回调方法 -- 以下方法由XtQuantTrader调用 ====== diff --git a/core/sfgrid/sfgrid_controller.py b/core/sfgrid/sfgrid_controller.py deleted file mode 100644 index e011675..0000000 --- a/core/sfgrid/sfgrid_controller.py +++ /dev/null @@ -1,151 +0,0 @@ -# coding:utf-8 -from typing import Any - - -from core.sfgrid.model import SFGridTradeTarget as TradeTarget -from .bus_events import ActionEventAddTradeTarget, ActionEventDeleteTradeTarget, ActionEventDisableTrade, ActionEventEnableTrade, EventTradeTargetUpdate, ResultEventTradeDisabled, ResultEventTradeEnabled, ResultEventTradeTargetAdded, ResultEventTradeTargetDeleted, ActionEventGridFix -from core.eventbus import event_bus, MarketDataEnabled, MarketDataDisabled, MarketDataUpdate -from xtquant import xttrader -from xtquant.xttrader import XtQuantTrader -import time -from peewee import ModelSelect - -import core.sfgrid.model as model -import config -from core.sfgrid.sfgrid_strategy import SFGridStrategy -from core.util import getStockPosition, queryPendingOrder -from xtquant.xttrader import XtQuantTrader -from xtquant.xttype import StockAccount, XtAsset, XtOrder, XtPosition, XtTrade -from xtquant import xtdata -from xtquant.xttrader import XtQuantTraderCallback -import datetime -import core.sfgrid.sfgrid_ui as sfgrid_ui -from core.logger import PrintLog, LogLevel -from core.qmt import qmtv -from core.sfgrid.objects import GridFixData - -# 量化核心控制对象 -class SFGridController: - def __init__(self): - super().__init__() - - self.registerEventHandler() - - self.seq = None - PrintLog(LogLevel.INFO, '- [成功]三疯交易系统初始化完成') - - - def registerEventHandler(self): - event_bus.subscribe(ActionEventAddTradeTarget, self.onAddTradeTarget) - event_bus.subscribe(ActionEventDeleteTradeTarget, self.onDeleteTradeTarget) - event_bus.subscribe(ActionEventGridFix, self.onGridFix) - - def onDeleteTradeTarget(self, target: TradeTarget): - """处理删除交易标的事件""" - id = target.get_id() - try: - # 从数据库中删除 - target.delete_instance() - - PrintLog(LogLevel.INFO, f"已删除交易标的: id{id} {target.stock_code} - {target.stock_name}") - # 发布删除完成事件 - event_bus.publish(ResultEventTradeTargetDeleted, target) - except Exception as e: - PrintLog(LogLevel.ERROR, f"删除交易标的失败 ID {id}: {str(e)}") - - def onAddTradeTarget(self, stock_code: str): - """处理添加交易标的事件""" - try: - stock_name = qmtv.getInstrumentName(stock_code) - if not stock_name: - PrintLog(LogLevel.ERROR, f'无法获取股票代码 {stock_code} 的名称，请检查代码是否正确') - return - - # 检查是否已存在该标的 - existing_target = TradeTarget.get_or_none(TradeTarget.stock_code == stock_code) - if existing_target: - PrintLog(LogLevel.INFO, f'交易标的 {stock_code} {stock_name} 已存在') - return - - # 刷新标的持仓 - pos = qmtv.getStockPosition(stock_code) # type: ignore - new_target = TradeTarget.create( - stock_name=stock_name, - stock_code=stock_code, - market_price=0.0, - current_position=pos, - grid_index=0, - last_trade_price=0.0, - plan_buy_price=0.0, - plan_sell_price=0.0, - current_order_price=0.0, - current_order_no='', - current_order_type='' - ) - new_target.save() - # 更新标的池 - event_bus.publish(ResultEventTradeTargetAdded, new_target) - - except Exception as e: - PrintLog(LogLevel.ERROR, f'新增交易标的失败 {stock_code} {e}') - - def onGridFix(self, data: GridFixData): - """处理网格修正事件""" - self.update_trade_target_grid(data) - - def update_trade_target_grid(self, data: GridFixData): - """更新交易标的网格信息""" - try: - target = data.tradeTarget - grid_index = data.grid_index - - # 更新数据库中的网格索引 - target.grid_index = grid_index - target.save() - - PrintLog(LogLevel.INFO, f"网格修正已应用: {target.stock_code} - {target.stock_name}, 网格索引: {grid_index}") - except Exception as e: - PrintLog(LogLevel.ERROR, f"网格修正更新失败: {str(e)}") - - - - def stopMarketData(self): - PrintLog(LogLevel.INFO, '- 停止市场数据订阅') - - if self.seq is not None and self.seq > 0: - xtdata.unsubscribe_quote(self.seq) - event_bus.publish(MarketDataDisabled, False) - - - # # 初始化指定标的交易控制器 - # def start_stock_trade(self, tradeTarget: TradeTarget): - # # check existing thread - # if tradeTarget.stock_code in self.stock_trade_ctrl: - # tradeController: SFGridStrategy = self.stock_trade_ctrl[tradeTarget.stock_code] - - # tradeTarget = tradeController.enabledTrading(True) - # self.instrument_pool[id] = tradeTarget - # event_bus.publish(ResultEventTradeEnabled, tradeTarget) - # else: - # PrintLog(LogLevel.INFO, f"\t创建标的交易控制器 {tradeTarget.stock_code} {getInstrumentName(tradeTarget.stock_code)}") - - # ====== 市场回调方法 -- 以下方法由XtQuantData调用 ====== - # def onDataUpdate(self, data): - # # 收集所有市场数据用于市场监控 - # for stock_code, tickData in data.items(): - # if stock_code in self.stock_trade_ctrl: - # stock_controller: SFGridStrategy = self.stock_trade_ctrl[stock_code] - # stock_controller.onDataUpdate(data) - # else: - # # 非目标交易，发布市场数据更新事件用于市场监控 - # lastPrice = tickData['lastPrice'] - # if lastPrice == 10 or stock_code in self.listening_stock: - # # 发布市场数据更新事件用于市场监控 - # market_target = TradeTarget() - # market_target.stock_code = stock_code - # market_target.stock_name = getInstrumentName(stock_code) # type: ignore - # market_target.market_price = lastPrice # type: ignore - # event_bus.publish(MarketDataUpdate, market_target) - # if stock_code not in self.listening_stock: - # self.listening_stock.append(stock_code) - diff --git a/core/sfgrid/sfgrid_ui.py b/core/sfgrid/sfgrid_ui.py index 558f652..5e9cfd7 100644 --- a/core/sfgrid/sfgrid_ui.py +++ b/core/sfgrid/sfgrid_ui.py @@ -13,19 +13,16 @@ import configparser import config from core.sfgrid.objects import GridFixData from core.qmt import qmtv -from core.sfgrid.sfgrid_controller import SFGridController from core.sfgrid.sfgrid_strategy import SFGridStrategy class TradeTargetUI(ttk.Frame): def __init__(self, parent): super().__init__(parent) - self.controller = SFGridController() - self.tradeTargetData:dict[int, SFGridTradeTarget] = {} # id->trade_target self.strategy_ctrl:dict[int, SFGridStrategy] = {} # stock_code->trade_target self.init_trade_target_pool() - self.registerEventHandler() + eBus.event_bus.subscribe(eBus.MarketDataUpdate, self.onMarketDataUpdated) # 创建刷新线程标志 self.refresh_thread_running = False # 默认不启动刷新线程 @@ -38,6 +35,21 @@ class TradeTargetUI(ttk.Frame): self.start_ui_refresh() + def onMarketDataUpdated(self, data): + # 更新市场监控数据 + for item in data: + if item['stock_code'] in self.tradeTargetData: + # 更新交易标准池信息 + continue + else: + # 监控10元的票 + current_time = datetime.now().strftime("%H:%M:%S") + self.marketData[str(item['stock_code'])] = { + 'stock_name': item['stock_name'], + 'last_price': item['market_price'] if item['market_price'] is not None else 0.0, + 'time': current_time + } + def refresh_targets(self): # 更新标的池 results = SFGridTradeTarget.select() @@ -59,19 +71,9 @@ class TradeTargetUI(ttk.Frame): stockTradeController = SFGridStrategy(tradeTarget) # type: ignore self.strategy_ctrl[id] = stockTradeController # pyright: ignore[reportArgumentType] # eBus.event_bus.publish(eBus.EventTradeTargetUpdate, tradeTarget) + self.updateTradeTarget(tradeTarget) PrintLog(LogLevel.INFO, f'- [成功]交易标的信息初始化, 共 {len(self.tradeTargetData)} 个标的') - - - def registerEventHandler(self): - eBus.event_bus.subscribe(EventTradeTargetUpdate, self.onTradeTargetUpdated) - # eBus.event_bus.subscribe(eBus.MarketDataUpdate, self.onMarketDataUpdated) - # eBus.event_bus.subscribe(eBus.ResultEventTradeEnabled, self.onTradeEnabled) - # eBus.event_bus.subscribe(eBus.ResultEventTradeDisabled, self.onTradeDisabled) - # eBus.event_bus.subscribe(eBus.MarketDataEnabled, self.onMarketDataToggled) - # eBus.event_bus.subscribe(eBus.MarketDataDisabled, self.onMarketDataToggled) - eBus.event_bus.subscribe(ResultEventTradeTargetDeleted, self.onTradeTargetDeleted) - eBus.event_bus.subscribe(ResultEventTradeTargetAdded, self.onTradeTargetUpdated) def start_refresh_thread(self): """启动刷新线程""" @@ -89,17 +91,6 @@ class TradeTargetUI(ttk.Frame): def stop_refresh_thread(self): """停止刷新线程""" self.refresh_thread_running = False - - def onTradeTargetDeleted(self, target: SFGridTradeTarget): - """处理交易标的删除完成事件""" - # 从本地数据中删除 - id = target.get_id() - if id in self.tradeTargetData: - PrintLog(LogLevel.DEBUG, f"删除交易标的，ID: {id}") - del self.tradeTargetData[id] - del self.strategy_ctrl[id] - # 添加日志 - PrintLog(LogLevel.INFO, f"交易标的已删除，ID: {id}") def onTradeEnabled(self, target:SFGridTradeTarget): @@ -109,19 +100,9 @@ class TradeTargetUI(ttk.Frame): PrintLog(LogLevel.INFO, f"交易禁用: {target.stock_code} - {target.stock_name}") - def onTradeTargetUpdated(self, target: SFGridTradeTarget): + def updateTradeTarget(self, target: SFGridTradeTarget): # 更新或添加数据到本地缓存 self.tradeTargetData[target.get_id()] = target - - - def onMarketDataUpdated(self, target: SFGridTradeTarget): - # 更新市场监控数据 - current_time = datetime.now().strftime("%H:%M:%S") - self.marketData[str(target.stock_code)] = { - 'stock_name': target.stock_name, - 'last_price': target.market_price if target.market_price is not None else 0.0, - 'time': current_time - } def create_ui(self): """创建UI界面""" @@ -193,7 +174,7 @@ class TradeTargetUI(ttk.Frame): columns = ("ID", "股票代码", "股票名称", "市场价", "持仓数量", "网格索引", "最新成交价", "计划买入价", "计划卖出价", "当前订单价", "当前订单号", "当前订单类型", - "启用状态", "交易状态" + "交易状态" ) self.trade_table = ttk.Treeview(parent, columns=columns, show='headings', height=15) @@ -212,7 +193,6 @@ class TradeTargetUI(ttk.Frame): "当前订单价": (90, tk.CENTER), "当前订单号": (90, tk.CENTER), "当前订单类型": (90, tk.CENTER), - "启用状态": (80, tk.CENTER), "交易状态": (80, tk.CENTER) } @@ -310,19 +290,7 @@ class TradeTargetUI(ttk.Frame): if result: # 发布事件通知主控制器添加标的 - eBus.event_bus.publish(ActionEventAddTradeTarget, stock_code) - PrintLog(LogLevel.INFO, f"已发送添加请求: {stock_code} - {stock_name}") - - def get_status_indicator(self, target: SFGridTradeTarget) -> str: - """获取状态指示器（带颜色色块的文本）""" - if target.status == 1: - # 绿色圆点表示交易中 - return "🟢 已建仓" - elif target.status == 0: - # 黄色圆点表示暂停 - return "🟡 未建仓" - else: - return "🔴 错误状态" + self.onAddTradeTarget(stock_code) def get_trade_enabled_indicator(self, enabled: bool) -> str: """获取交易状态指示器""" @@ -347,7 +315,6 @@ class TradeTargetUI(ttk.Frame): '-' if target.current_order_price is None else f"{target.current_order_price:.3f}", target.current_order_no, target.current_order_type, - self.get_status_indicator(target), self.get_trade_enabled_indicator(target.enabled) # type: ignore ] @@ -466,9 +433,19 @@ class TradeTargetUI(ttk.Frame): icon='warning' ) + id = target.get_id() if result: # 通过事件总线发出删除动作 - eBus.event_bus.publish(ActionEventDeleteTradeTarget, target) + try: + # 从数据库中删除 + target.delete_instance() + + del self.tradeTargetData[id] + del self.strategy_ctrl[id] + # 添加日志 + PrintLog(LogLevel.INFO, f"交易标的已删除，ID: {id} {target.targetName()}") + except Exception as e: + PrintLog(LogLevel.ERROR, f"删除交易标的失败 ID {id}: {str(e)}") PrintLog(LogLevel.INFO, f"已发送删除请求: {target.stock_code} - {target.stock_name}") def add_trade_target(self): @@ -1060,4 +1037,55 @@ class TradeTargetUI(ttk.Frame): # 更新持仓量状态 current_position = getattr(target, 'current_position') - self.update_position_status(current_position, required_position, position_status_label) \ No newline at end of file + self.update_position_status(current_position, required_position, position_status_label) + + + def onAddTradeTarget(self, stock_code: str): + """处理添加交易标的事件""" + try: + stock_name = qmtv.getInstrumentName(stock_code) + if not stock_name: + PrintLog(LogLevel.ERROR, f'无法获取股票代码 {stock_code} 的名称，请检查代码是否正确') + return + + # 检查是否已存在该标的 + existing_target = SFGridTradeTarget.get_or_none(SFGridTradeTarget.stock_code == stock_code) + if existing_target: + PrintLog(LogLevel.INFO, f'交易标的 {stock_code} {stock_name} 已存在') + return + + # 刷新标的持仓 + pos = qmtv.getStockPosition(stock_code) # type: ignore + new_target = SFGridTradeTarget.create( + stock_name=stock_name, + stock_code=stock_code, + market_price=0.0, + current_position=pos, + grid_index=0, + last_trade_price=0.0, + plan_buy_price=0.0, + plan_sell_price=0.0, + current_order_price=0.0, + current_order_no='', + current_order_type='' + ) + new_target.save() + # 更新标的池 + self.updateTradeTarget(new_target) + + except Exception as e: + PrintLog(LogLevel.ERROR, f'新增交易标的失败 {stock_code} {e}') + + def update_trade_target_grid(self, data: GridFixData): + """更新交易标的网格信息""" + try: + target = data.tradeTarget + grid_index = data.grid_index + + # 更新数据库中的网格索引 + target.grid_index = grid_index + target.save() + + PrintLog(LogLevel.INFO, f"网格修正已应用: {target.stock_code} - {target.stock_name}, 网格索引: {grid_index}") + except Exception as e: + PrintLog(LogLevel.ERROR, f"网格修正更新失败: {str(e)}") \ No newline at end of file diff --git a/core/sfgrid/ui.py b/core/sfgrid/ui.py new file mode 100644 index 0000000..e69de29 From 0d54f8b05a6893705503bf5248f1c9e2558e151b Mon Sep 17 00:00:00 2001 From: "GDP\\solonot" Date: Wed, 12 Nov 2025 10:48:43 +0800 Subject: [PATCH 8/9] update --- core/sfgrid/sfgrid_strategy.py | 7 ++---- core/sfgrid/sfgrid_ui.py | 41 ++++++++++++++++++++++++---------- 2 files changed, 31 insertions(+), 17 deletions(-) diff --git a/core/sfgrid/sfgrid_strategy.py b/core/sfgrid/sfgrid_strategy.py index 3283b99..9ff22d1 100644 --- a/core/sfgrid/sfgrid_strategy.py +++ b/core/sfgrid/sfgrid_strategy.py @@ -55,12 +55,8 @@ class SFGridStrategy: print(f'|- 检查交易状态[{self.tradeTarget.stock_code}-{self.tradeTarget.stock_name}] - {self.tradeTarget.enabled}') return bool(self.tradeTarget.enabled) # 修复返回类型问题 - def onDataUpdate(self, data): + def onDataUpdate(self, inTradeTarget:model.SFGridTradeTarget): print(f'|- 市价更新[{self.tradeTarget.stock_code}-{self.tradeTarget.stock_name}] - START') - - lastPrice = float("{:.3f}".format(data[self.tradeTarget.stock_code]['lastPrice'])) - self.tradeTarget.market_price = lastPrice # type: ignore - self.saveProxy() if not is_trading_time(): print(f"|- 市价更新[{self.tradeTarget.stock_code}-{self.tradeTarget.stock_name}] - 非交易时间，不进行自动交易") @@ -74,6 +70,7 @@ class SFGridStrategy: print(f'|- 市价更新[{self.tradeTarget.stock_code}-{self.tradeTarget.stock_name}] - LOCKED') try: + lastPrice = inTradeTarget.market_price orderPrice:float = -1 orderType = -1 index: int = self.tradeTarget.grid_index # pyright: ignore[reportAssignmentType] diff --git a/core/sfgrid/sfgrid_ui.py b/core/sfgrid/sfgrid_ui.py index 5e9cfd7..f3463cd 100644 --- a/core/sfgrid/sfgrid_ui.py +++ b/core/sfgrid/sfgrid_ui.py @@ -20,7 +20,9 @@ class TradeTargetUI(ttk.Frame): def __init__(self, parent): super().__init__(parent) self.tradeTargetData:dict[int, SFGridTradeTarget] = {} # id->trade_target + self.stockCodeIdMap:dict[str, int] = {} self.strategy_ctrl:dict[int, SFGridStrategy] = {} # stock_code->trade_target + self.listening_stock = [] self.init_trade_target_pool() eBus.event_bus.subscribe(eBus.MarketDataUpdate, self.onMarketDataUpdated) @@ -36,19 +38,30 @@ class TradeTargetUI(ttk.Frame): self.start_ui_refresh() def onMarketDataUpdated(self, data): - # 更新市场监控数据 - for item in data: - if item['stock_code'] in self.tradeTargetData: - # 更新交易标准池信息 - continue + # 收集所有市场数据用于市场监控 + for stock_code, tickData in data.items(): + id = self.stockCodeIdMap.get(stock_code) + if id is not None and stock_code in self.tradeTargetData: + tradeTarget = self.tradeTargetData[id] + PrintLog(LogLevel.INFO, f' [市价更新 序号-{id}] {stock_code} - {tickData}') + + lastPrice = float("{:.3f}".format(tickData['lastPrice'])) + tradeTarget.market_price = lastPrice # type: ignore + stock_controller: SFGridStrategy = self.strategy_ctrl[id] + stock_controller.onDataUpdate(tradeTarget) else: - # 监控10元的票 - current_time = datetime.now().strftime("%H:%M:%S") - self.marketData[str(item['stock_code'])] = { - 'stock_name': item['stock_name'], - 'last_price': item['market_price'] if item['market_price'] is not None else 0.0, - 'time': current_time - } + # 非目标交易，发布市场数据更新事件用于市场监控 + lastPrice = tickData['lastPrice'] + if lastPrice == 10 or stock_code in self.listening_stock: + PrintLog(LogLevel.INFO, f' [市价更新 序号-X] {stock_code} - {lastPrice}') + # 发布市场数据更新事件用于市场监控 + market_target = SFGridTradeTarget() + market_target.stock_code = stock_code + market_target.stock_name = qmtv.getInstrumentName(stock_code) # type: ignore + market_target.market_price = lastPrice # type: ignore + if stock_code not in self.listening_stock: + self.listening_stock.append(stock_code) + def refresh_targets(self): # 更新标的池 @@ -56,6 +69,7 @@ class TradeTargetUI(ttk.Frame): for temp in results: result :SFGridTradeTarget = temp self.tradeTargetData[result.get_id()] = result + self.stockCodeIdMap[str(result.stock_code)] = result.get_id() def init_trade_target_pool(self): @@ -85,6 +99,7 @@ class TradeTargetUI(ttk.Frame): """刷新循环""" while self.refresh_thread_running: # 在主线程中更新UI + PrintLog(LogLevel.INFO, "刷新UI") self.after(0, self.refresh_table) time.sleep(0.5) # 每0.5秒刷新一次 @@ -103,6 +118,7 @@ class TradeTargetUI(ttk.Frame): def updateTradeTarget(self, target: SFGridTradeTarget): # 更新或添加数据到本地缓存 self.tradeTargetData[target.get_id()] = target + self.stockCodeIdMap[target.stock_code] = target.get_id() # type: ignore def create_ui(self): """创建UI界面""" @@ -442,6 +458,7 @@ class TradeTargetUI(ttk.Frame): del self.tradeTargetData[id] del self.strategy_ctrl[id] + del self.stockCodeIdMap[str(target.stock_code)] # 添加日志 PrintLog(LogLevel.INFO, f"交易标的已删除，ID: {id} {target.targetName()}") except Exception as e: From 5e64e931729b962dd3c51599ded12ba1c2336058 Mon Sep 17 00:00:00 2001 From: "GDP\\solonot" Date: Wed, 12 Nov 2025 11:51:40 +0800 Subject: [PATCH 9/9] update --- core/main_ui.py | 2 +- core/sfgrid/sfgrid_strategy.py | 4 +- core/sfgrid/sfgrid_ui.py | 123 ++++++++++++++++++++++----------- 3 files changed, 86 insertions(+), 43 deletions(-) diff --git a/core/main_ui.py b/core/main_ui.py index 7a9a828..2df1df6 100644 --- a/core/main_ui.py +++ b/core/main_ui.py @@ -36,7 +36,7 @@ class MainWindow: # 创建Tab按钮（垂直排列，文字垂直显示） self.tab_buttons = [] - strategy_names = ["三疯\n网格", "通用\n网格", "涨停\n分析"] + strategy_names = ["蒙派\n策略", "涨停\n分析"] for idx, name in enumerate(strategy_names): btn = ttk.Button( diff --git a/core/sfgrid/sfgrid_strategy.py b/core/sfgrid/sfgrid_strategy.py index 9ff22d1..8cc8065 100644 --- a/core/sfgrid/sfgrid_strategy.py +++ b/core/sfgrid/sfgrid_strategy.py @@ -56,16 +56,14 @@ class SFGridStrategy: return bool(self.tradeTarget.enabled) # 修复返回类型问题 def onDataUpdate(self, inTradeTarget:model.SFGridTradeTarget): - print(f'|- 市价更新[{self.tradeTarget.stock_code}-{self.tradeTarget.stock_name}] - START') if not is_trading_time(): - print(f"|- 市价更新[{self.tradeTarget.stock_code}-{self.tradeTarget.stock_name}] - 非交易时间，不进行自动交易") return if not self.tradeTarget.enabled: # 未建仓，自动交易暂停 - print(f"|- 市价更新[{self.tradeTarget.stock_code}-{self.tradeTarget.stock_name}] - 未建仓或交易监控暂停，不进行自动交易") return + print(f'|- 市价更新[{self.tradeTarget.stock_code}-{self.tradeTarget.stock_name}] - START') self.dataUpdateLock.acquire() print(f'|- 市价更新[{self.tradeTarget.stock_code}-{self.tradeTarget.stock_name}] - LOCKED') diff --git a/core/sfgrid/sfgrid_ui.py b/core/sfgrid/sfgrid_ui.py index f3463cd..2cc9a62 100644 --- a/core/sfgrid/sfgrid_ui.py +++ b/core/sfgrid/sfgrid_ui.py @@ -32,6 +32,9 @@ class TradeTargetUI(ttk.Frame): # 市场监控数据 self.marketData: dict[str, Any] = {} # 存储市场数据 {stock_code: {stock_name, last_price, time}} + # 市场监控窗口显示状态 + self.market_monitor_visible = True + # 创建界面 self.create_ui() @@ -40,20 +43,18 @@ class TradeTargetUI(ttk.Frame): def onMarketDataUpdated(self, data): # 收集所有市场数据用于市场监控 for stock_code, tickData in data.items(): - id = self.stockCodeIdMap.get(stock_code) - if id is not None and stock_code in self.tradeTargetData: + if stock_code in self.stockCodeIdMap: + id:int = self.stockCodeIdMap[stock_code] tradeTarget = self.tradeTargetData[id] - PrintLog(LogLevel.INFO, f' [市价更新 序号-{id}] {stock_code} - {tickData}') - lastPrice = float("{:.3f}".format(tickData['lastPrice'])) tradeTarget.market_price = lastPrice # type: ignore + self.updateTradeTarget(tradeTarget) stock_controller: SFGridStrategy = self.strategy_ctrl[id] stock_controller.onDataUpdate(tradeTarget) else: # 非目标交易，发布市场数据更新事件用于市场监控 lastPrice = tickData['lastPrice'] if lastPrice == 10 or stock_code in self.listening_stock: - PrintLog(LogLevel.INFO, f' [市价更新 序号-X] {stock_code} - {lastPrice}') # 发布市场数据更新事件用于市场监控 market_target = SFGridTradeTarget() market_target.stock_code = stock_code @@ -61,7 +62,13 @@ class TradeTargetUI(ttk.Frame): market_target.market_price = lastPrice # type: ignore if stock_code not in self.listening_stock: self.listening_stock.append(stock_code) - + # 更新市场监控数据用于UI显示 + current_time = datetime.now().strftime("%H:%M:%S") + self.marketData[str(stock_code)] = { + 'stock_name': qmtv.getInstrumentName(stock_code), + 'last_price': tickData['lastPrice'], + 'time': current_time + } def refresh_targets(self): # 更新标的池 @@ -84,7 +91,6 @@ class TradeTargetUI(ttk.Frame): PrintLog(LogLevel.INFO, f' |- 同步[{tradeTarget.stock_code}-{tradeTarget.stock_name}]持仓信息[{'成功' if result == 1 else '失败'}]') stockTradeController = SFGridStrategy(tradeTarget) # type: ignore self.strategy_ctrl[id] = stockTradeController # pyright: ignore[reportArgumentType] - # eBus.event_bus.publish(eBus.EventTradeTargetUpdate, tradeTarget) self.updateTradeTarget(tradeTarget) PrintLog(LogLevel.INFO, f'- [成功]交易标的信息初始化, 共 {len(self.tradeTargetData)} 个标的') @@ -99,9 +105,9 @@ class TradeTargetUI(ttk.Frame): """刷新循环""" while self.refresh_thread_running: # 在主线程中更新UI - PrintLog(LogLevel.INFO, "刷新UI") self.after(0, self.refresh_table) - time.sleep(0.5) # 每0.5秒刷新一次 + self.after(0, self.populate_market_table) + time.sleep(0.2) # 每0.5秒刷新一次 def stop_refresh_thread(self): """停止刷新线程""" @@ -113,7 +119,6 @@ class TradeTargetUI(ttk.Frame): def onTradeDisabled(self, target:SFGridTradeTarget): PrintLog(LogLevel.INFO, f"交易禁用: {target.stock_code} - {target.stock_name}") - def updateTradeTarget(self, target: SFGridTradeTarget): # 更新或添加数据到本地缓存 @@ -142,8 +147,10 @@ class TradeTargetUI(ttk.Frame): ttk.Button(toolbar_frame, text="🛠 网格修正", command=self.grid_correction, width=12).pack(side=tk.LEFT, padx=2) - # 添加分隔符 - ttk.Separator(toolbar_frame, orient='vertical').pack(side=tk.LEFT, fill=tk.Y, padx=10) + # 添加抽屉按钮到工具栏最右侧 + self.toggle_market_monitor_btn = ttk.Button(toolbar_frame, text="◀▶", + command=self.toggle_market_monitor, width=3) + self.toggle_market_monitor_btn.pack(side=tk.RIGHT, padx=2) # 表格区域 self.create_tables_area(main_frame) @@ -163,7 +170,6 @@ class TradeTargetUI(ttk.Frame): PrintLog(LogLevel.INFO, "UI刷新线程已停止") - def create_tables_area(self, parent): """创建表格区域""" # 创建主表格框架（水平排列） @@ -178,17 +184,17 @@ class TradeTargetUI(ttk.Frame): self.create_trade_target_table(trade_frame) # 右侧市场监控区域 - market_frame = ttk.LabelFrame(tables_frame, text="市场监控", padding=10) - market_frame.pack(side=tk.RIGHT, fill=tk.BOTH, expand=True, padx=(5, 0)) + self.market_frame = ttk.LabelFrame(tables_frame, text="市场监控", padding=10) + self.market_frame.pack(side=tk.RIGHT, fill=tk.BOTH, expand=True, padx=(5, 0)) # 创建市场监控表格 - self.create_market_monitor_table(market_frame) + self.create_market_monitor_table(self.market_frame) def create_trade_target_table(self, parent): """创建交易标的表格""" columns = ("ID", - "股票代码", "股票名称", "市场价", "持仓数量", "网格索引", + "股票代码", "股票名称", "市场价", "持仓数量", "最新成交价", "计划买入价", "计划卖出价", "当前订单价", "当前订单号", "当前订单类型", "交易状态" ) @@ -199,17 +205,16 @@ class TradeTargetUI(ttk.Frame): column_configs = { "ID": (50, tk.CENTER), "股票代码": (90, tk.CENTER), - "股票名称": (80, tk.CENTER), - "市场价": (70, tk.CENTER), - "持仓数量": (80, tk.CENTER), - "网格索引": (80, tk.CENTER), - "最新成交价": (90, tk.CENTER), - "计划买入价": (90, tk.CENTER), - "计划卖出价": (90, tk.CENTER), - "当前订单价": (90, tk.CENTER), - "当前订单号": (90, tk.CENTER), - "当前订单类型": (90, tk.CENTER), - "交易状态": (80, tk.CENTER) + "股票名称": (80, tk.E), + "市场价": (70, tk.E), + "持仓数量": (80, tk.E), + "最新成交价": (90, tk.E), + "计划买入价": (90, tk.E), + "计划卖出价": (90, tk.E), + "当前订单价": (90, tk.E), + "当前订单号": (90, tk.E), + "当前订单类型": (90, tk.E), + "交易状态": (80, tk.E) } for col in columns: @@ -232,16 +237,15 @@ class TradeTargetUI(ttk.Frame): def create_market_monitor_table(self, parent): """创建市场监控表格""" - columns = ("时间", "股票代码", "股票名称", "最新价格") + columns = ("时间", "股票名称", "最新价格") self.market_table = ttk.Treeview(parent, columns=columns, show='headings', height=15) # 列配置 column_configs = { - "时间": (120, "center"), - "股票代码": (90, "center"), - "股票名称": (80, "center"), - "最新价格": (80, "center") + "时间": (50, tk.CENTER), + "股票名称": (80, tk.CENTER), + "最新价格": (80, tk.CENTER) } for col in columns: @@ -264,7 +268,14 @@ class TradeTargetUI(ttk.Frame): def populate_market_table(self): """填充市场监控表格数据""" - pass + # 保存当前选中的项 + selected_items = self.market_table.selection() + selected_values = [] + for item in selected_items: + values = self.market_table.item(item)['values'] + if values: + selected_values.append(values[1]) # 保存股票代码 + # 清空现有数据 for item in self.market_table.get_children(): self.market_table.delete(item) @@ -272,13 +283,35 @@ class TradeTargetUI(ttk.Frame): # 填充市场数据 tmp = self.marketData.copy() for stock_code, data in tmp.items(): + # 处理时间格式，仅显示 hh:mm:ss + time_str = data['time'] + # 如果时间字符串包含空格，说明包含日期和时间，只取时间部分 + if ' ' in time_str: + time_str = time_str.split(' ')[1] + + # 确保时间格式为 hh:mm:ss，如果只有 hh:mm 则补充 :00 + if ':' in time_str: + time_components = time_str.split(':') + if len(time_components) == 2: + # 只有小时和分钟，补充秒 + time_str = f"{time_components[0]}:{time_components[1]}:00" + elif len(time_components) >= 3: + # 有小时、分钟和秒，只取前三个部分 + time_str = f"{time_components[0]}:{time_components[1]}:{time_components[2]}" + values = [ - data['time'], - stock_code, - data['stock_name'], + time_str, + data['stock_name']+f"{stock_code}", f"{data['last_price']:.3f}" ] self.market_table.insert('', tk.END, values=values) + + # 恢复之前选中的项 + if selected_values: + for item in self.market_table.get_children(): + values = self.market_table.item(item)['values'] + if values and values[1] in selected_values: # 比较股票代码 + self.market_table.selection_add(item) def on_market_table_double_click(self, event): """市场监控表格双击事件""" @@ -324,7 +357,6 @@ class TradeTargetUI(ttk.Frame): target.stock_name, "-" if target.market_price is None else f"{target.market_price:.3f}", target.current_position, - target.grid_index, '-' if target.last_trade_price is None else f"{target.last_trade_price:.3f}", '-' if target.plan_buy_price is None else f"{target.plan_buy_price:.3f}", '-' if target.plan_sell_price is None else f"{target.plan_sell_price:.3f}", @@ -1105,4 +1137,17 @@ class TradeTargetUI(ttk.Frame): PrintLog(LogLevel.INFO, f"网格修正已应用: {target.stock_code} - {target.stock_name}, 网格索引: {grid_index}") except Exception as e: - PrintLog(LogLevel.ERROR, f"网格修正更新失败: {str(e)}") \ No newline at end of file + PrintLog(LogLevel.ERROR, f"网格修正更新失败: {str(e)}") + + def toggle_market_monitor(self): + """切换市场监控窗口显示/隐藏""" + if self.market_monitor_visible: + # 隐藏市场监控窗口 + self.market_frame.pack_forget() + self.toggle_market_monitor_btn.config(text="▶") + self.market_monitor_visible = False + else: + # 显示市场监控窗口 + self.market_frame.pack(side=tk.RIGHT, fill=tk.BOTH, expand=True, padx=(5, 0)) + self.toggle_market_monitor_btn.config(text="◀▶") + self.market_monitor_visible = True