def writeDrLog(self, content):
"""快速发出日志事件"""
log = VtLogData()
log.logContent = content
event = Event(type_=EVENT_DATARECORDER_LOG)
event.dict_['data'] = log
self.eventEngine.put(event)
def writeCtaLog(self, content):
"""快速发出CTA模块日志事件"""
log = VtLogData()
log.logContent = content
event = Event(type_=EVENT_CTA_LOG)
event.dict_['data'] = log
self.eventEngine.put(event)
def putSettingEvent(self, settingName, algoSetting):
"""发出算法配置更新事件"""
algoSetting['settingName'] = settingName
event = Event(EVENT_ALGO_SETTING)
event.dict_['data'] = algoSetting
self.eventEngine.put(event)
def writeLog(self, content):
"""快速发出日志事件"""
print "%s.%s.%s" % (__name__, self.__class__.__name__, get_current_function_name())
log = VtLogData()
log.logContent = content
event = Event(type_=EVENT_LOG)
event.dict_['data'] = log
self.eventEngine.put(event)
def writeLog(self, content):
"""快速发出日志事件"""
log = VtLogData()
log.logContent = content
log.gatewayName = 'MAIN_ENGINE'
event = Event(type_=EVENT_LOG)
event.dict_['data'] = log
self.eventEngine.put(event)
def writeLog(self, content):
"""发出日志事件"""
log = VtLogData()
log.logContent = content
log.gatewayName = 'JAQS_SERVICE'
event = Event(type_=EVENT_JS_LOG)
event.dict_['data'] = log
self.eventEngine.put(event)
def writeLog(self, msg):
""""""
log = VtLogData()
log.logContent = msg
event = Event(EVENT_TC_LOG)
event.dict_['data'] = log
self.eventEngine.put(event)
def writeLog(self, content):
"""发出日志 """
log = VtLogData()
log.logContent = content
event = Event(EVENT_OM_LOG)
event.dict_['data'] = log
self.eventEngine.put(event)
def putSpreadPosEvent(self, spread):
"""发出价差持仓事件"""
event1 = Event(EVENT_SPREADTRADING_POS+spread.name)
event1.dict_['data'] = spread
self.eventEngine.put(event1)
event2 = Event(EVENT_SPREADTRADING_POS)
event2.dict_['data'] = spread
self.eventEngine.put(event2)
def writeLog(self, content):
"""输出日志"""
log = VtLogData()
log.logContent = content
event = Event(EVENT_SPREADTRADING_ALGOLOG)
event.dict_['data'] = log
self.eventEngine.put(event)
def writeLog(self, content):
"""记录日志"""
log = VtLogData()
log.logContent = content
log.gatewayName = self.ENGINE_NAME
event = Event(EVENT_RTDSERVICE_LOG)
event.dict_['data'] = log
self.eventEngine.put(event)
def putSpreadTickEvent(self, spread):
"""发出价差行情更新事件"""
event1 = Event(EVENT_SPREADTRADING_TICK+spread.name)
event1.dict_['data'] = spread
self.eventEngine.put(event1)
event2 = Event(EVENT_SPREADTRADING_TICK)
event2.dict_['data'] = spread
self.eventEngine.put(event2)
def cancelOrder(self, cancelOrderReq, gatewayName):
"""对特定接口撤单"""
gateway = self.getGateway(gatewayName)
event1 = Event(type_=EVENT_PRE_CANCEL_ORDER)
event1.dict_['data'] = cancelOrderReq
self.eventEngine.put(event1)
if gateway:
gateway.cancelOrder(cancelOrderReq)
def writeLog(self, content, algo=None):
"""输出日志"""
log = VtLogData()
log.logContent = content
if algo:
log.gatewayName = algo.algoName
event = Event(EVENT_ALGO_LOG)
event.dict_['data'] = log
self.eventEngine.put(event)
def putStrategyEvent(self, name):
"""触发策略状态变化事件（通常用于通知GUI更新）"""
strategy = self.strategyDict[name]
d = {k:strategy.__getattribute__(k) for k in strategy.varList}
event = Event(EVENT_CTA_STRATEGY+name)
event.dict_['data'] = d
self.eventEngine.put(event)
d2 = {k:str(v) for k,v in d.items()}
d2['name'] = name
event2 = Event(EVENT_CTA_STRATEGY)
event2.dict_['data'] = d2
self.eventEngine.put(event2)
def writeRiskLog(self, content):
"""快速发出日志事件"""
# 发出报警提示音
if platform.uname() == 'Windows':
import winsound
winsound.PlaySound("SystemHand", winsound.SND_ASYNC)
# 发出日志事件
log = VtLogData()
log.logContent = content
log.gatewayName = self.name
event = Event(type_=EVENT_LOG)
event.dict_['data'] = log
self.eventEngine.put(event)
def sendOrder(self, orderReq, gatewayName):
"""对特定接口发单"""
# 如果创建了风控引擎，且风控检查失败则不发单
if self.rmEngine and not self.rmEngine.checkRisk(orderReq, gatewayName):
return ''
gateway = self.getGateway(gatewayName)
event1 = Event(type_=EVENT_PRE_ORDER)
event1.dict_['data'] = orderReq
self.eventEngine.put(event1)
if gateway:
vtOrderID = gateway.sendOrder(orderReq)
self.dataEngine.updateOrderReq(orderReq, vtOrderID) # 更新发出的委托请求到数据引擎中
return vtOrderID
else:
return ''
def putParamEvent(self, algo, d):
"""更新参数"""
algoName = algo.algoName
d['algoName'] = algoName
event = Event(EVENT_ALGO_PARAM)
event.dict_['data'] = d
self.eventEngine.put(event)
# RPC推送
if self.rpcServer:
self.rpcServer.publish('AlgoTrading', event)
# 保存数据到数据库
history = self.historyDict.setdefault(algoName, {})
history['algoName'] = algoName
history['param'] = d
self.mainEngine.dbUpdate(ALGOTRADING_DB_NAME,
HISTORY_COLLECTION_NAME,
history,
{'algoName': algoName},
True)
def processTradeEvent(self, event):
"""处理成交推送"""
# 检查成交是否需要处理
trade = event.dict_['data']
if trade.vtSymbol not in self.legDict:
return
# 更新腿持仓
leg = self.legDict[trade.vtSymbol]
direction = trade.direction
offset = trade.offset
if direction == DIRECTION_LONG:
if offset == OFFSET_OPEN:
leg.longPos += trade.volume
else:
leg.shortPos -= trade.volume
else:
if offset == OFFSET_OPEN:
leg.shortPos += trade.volume
else:
leg.longPos -= trade.volume
leg.netPos = leg.longPos - leg.shortPos
# 更新价差持仓
spread = self.vtSymbolSpreadDict[trade.vtSymbol]
spread.calculatePos()
# 推送价差持仓更新
event1 = Event(EVENT_SPREADTRADING_POS+spread.name)
event1.dict_['data'] = spread
self.eventEngine.put(event1)
event2 = Event(EVENT_SPREADTRADING_POS)
event2.dict_['data'] = spread
self.eventEngine.put(event2)
def run_optimization(
self,
class_name: str,
vt_symbol: str,
interval: str,
start: datetime,
end: datetime,
rate: float,
slippage: float,
size: int,
pricetick: float,
capital: int,
inverse: bool,
optimization_setting: OptimizationSetting,
use_ga: bool
):
""""""
if use_ga:
self.write_log("开始遗传算法参数优化")
else:
self.write_log("开始多进程参数优化")
self.result_values = None
engine = self.backtesting_engine
engine.clear_data()
engine.set_parameters(
vt_symbol=vt_symbol,
interval=interval,
start=start,
end=end,
rate=rate,
slippage=slippage,
size=size,
pricetick=pricetick,
capital=capital,
inverse=inverse
)
strategy_class = self.classes[class_name]
engine.add_strategy(
strategy_class,
{}
)
if use_ga:
self.result_values = engine.run_ga_optimization(
optimization_setting,
output=False
)
else:
self.result_values = engine.run_optimization(
optimization_setting,
output=False
)
# Clear thread object handler.
self.thread = None
self.write_log("多进程参数优化完成")
# Put optimization done event
event = Event(EVENT_BACKTESTER_OPTIMIZATION_FINISHED)
self.event_engine.put(event)
def put_pos_event(self, spread: SpreadData) -> None:
""""""
event = Event(EVENT_SPREAD_POS, spread)
self.event_engine.put(event)
def addListWidget(self, data):
event = Event(type_=u"addListWidget")
event.dict_['data'] = data
self.eventEngine.put(event)
def write_algo_log(self, algo: ElectronicEyeAlgo, msg: str) -> None:
""""""
msg = f"[{algo.vt_symbol}] {msg}"
log = LogData(APP_NAME, msg)
event = Event(EVENT_OPTION_ALGO_LOG, log)
self.event_engine.put(event)
def put_algo_event(self, algo: SpreadAlgoTemplate) -> None:
""""""
event = Event(EVENT_SPREAD_ALGO, algo)
self.event_engine.put(event)
class OmManager(QtWidgets.QWidget):
"""管理组件"""
signal = QtCore.pyqtSignal(type(Event()))
#----------------------------------------------------------------------
def __init__(self, omEngine, eventEngine, parent=None):
"""Constructor"""
super(OmManager, self).__init__(parent)
self.omEngine = omEngine
self.eventEngine = eventEngine
self.widgetDict = {}
self.initUi()
self.registerEvent()
#----------------------------------------------------------------------
def initUi(self):
"""初始化界面"""
self.setWindowTitle(u'OptionMaster管理')
# 读取配置文件
settingFileList = []
path = os.getcwd()
for root, subdirs, files in os.walk(path):
for name in files:
if '_portfolio.json' in name:
settingFileList.append(name)
# 设置界面
self.comboSettingFile = QtWidgets.QComboBox()
self.comboSettingFile.addItems(settingFileList)
self.comboSettingFile.setCurrentIndex(0)
self.buttonInit = QtWidgets.QPushButton(u'初始化')
self.buttonInit.clicked.connect(self.initOmEngine)
self.buttonManualTrader = QtWidgets.QPushButton(u'手动交易')
self.buttonManualTrader.clicked.connect(self.openManualTrader)
self.buttonManualTrader.setDisabled(True)
self.buttonGreeksMonitor = QtWidgets.QPushButton(u'希腊值监控')
self.buttonGreeksMonitor.clicked.connect(self.openGreeksMonitor)
self.buttonGreeksMonitor.setDisabled(True)
self.buttonVolatilityChart = QtWidgets.QPushButton(u'波动率图表')
self.buttonVolatilityChart.clicked.connect(self.openVolatilityChart)
self.buttonVolatilityChart.setDisabled(True)
self.buttonVolatilityManager = QtWidgets.QPushButton(u'波动率管理')
self.buttonVolatilityManager.clicked.connect(self.openVolatilityManager)
self.buttonVolatilityManager.setDisabled(True)
self.buttonAnalysisManager = QtWidgets.QPushButton(u'持仓分析')
self.buttonAnalysisManager.clicked.connect(self.openAnalysisManager)
self.buttonAnalysisManager.setDisabled(True)
self.buttonStrategyManager = QtWidgets.QPushButton(u'策略交易')
self.buttonStrategyManager.clicked.connect(self.openStrategyManager)
self.buttonStrategyManager.setDisabled(True)
self.buttonAdjustR = QtWidgets.QPushButton(u'拟合利率')
self.buttonAdjustR.clicked.connect(self.omEngine.adjustR)
self.buttonAdjustR.setDisabled(True)
self.logMonitor = QtWidgets.QTextEdit()
self.logMonitor.setReadOnly(True)
hbox = QtWidgets.QHBoxLayout()
hbox.addWidget(self.comboSettingFile)
hbox.addWidget(self.buttonInit)
hbox.addWidget(self.buttonManualTrader)
hbox.addWidget(self.buttonGreeksMonitor)
hbox.addWidget(self.buttonVolatilityChart)
hbox.addWidget(self.buttonVolatilityManager)
hbox.addWidget(self.buttonAnalysisManager)
hbox.addWidget(self.buttonStrategyManager)
hbox.addWidget(self.buttonAdjustR)
hbox.addStretch()
hbox2 = QtWidgets.QHBoxLayout()
hbox2.addStretch()
vbox = QtWidgets.QVBoxLayout()
vbox.addLayout(hbox)
vbox.addLayout(hbox2)
vbox.addWidget(self.logMonitor)
self.setLayout(vbox)
#----------------------------------------------------------------------
def initOmEngine(self):
"""初始化引擎"""
path = os.getcwd()
fileName = text_type(self.comboSettingFile.currentText())
fileName = os.path.join(path, fileName)
result = self.omEngine.initEngine(fileName)
if result:
self.writeLog(u'引擎初始化成功')
self.enableButtons()
else:
self.writeLog(u'请勿重复初始化引擎')
#----------------------------------------------------------------------
def enableButtons(self):
"""启用按钮"""
self.comboSettingFile.setDisabled(True)
self.buttonInit.setDisabled(True)
self.buttonManualTrader.setEnabled(True)
self.buttonGreeksMonitor.setEnabled(True)
self.buttonVolatilityChart.setEnabled(True)
self.buttonVolatilityManager.setEnabled(True)
self.buttonAnalysisManager.setEnabled(True)
self.buttonStrategyManager.setEnabled(True)
self.buttonAdjustR.setEnabled(True)
#----------------------------------------------------------------------
def writeLog(self, content, time=''):
"""记录日志"""
if not time:
time = datetime.now().strftime('%H:%M:%S')
content = time + '\t' + content
self.logMonitor.append(content)
#----------------------------------------------------------------------
def processLogEvent(self, event):
"""处理日志事件"""
log = event.dict_['data']
self.writeLog(log.logContent, log.logTime)
self.raise_()
#----------------------------------------------------------------------
def openManualTrader(self):
"""打开手动交易组件"""
try:
self.widgetDict['manualTrader'].showMaximized()
except KeyError:
self.widgetDict['manualTrader'] = ManualTrader(self.omEngine)
self.widgetDict['manualTrader'].showMaximized()
#----------------------------------------------------------------------
def openGreeksMonitor(self):
"""打开希腊值监控组件"""
try:
self.widgetDict['greeksMonitor'].showMaximized()
except KeyError:
self.widgetDict['greeksMonitor'] = GreeksMonitor(self.omEngine)
self.widgetDict['greeksMonitor'].showMaximized()
#----------------------------------------------------------------------
def openVolatilityChart(self):
"""打开波动率图表组件"""
try:
self.widgetDict['volatilityChart'].showMaximized()
except KeyError:
self.widgetDict['volatilityChart'] = VolatilityChart(self.omEngine)
self.widgetDict['volatilityChart'].showMaximized()
#----------------------------------------------------------------------
def openVolatilityManager(self):
"""打开波动率管理组件"""
try:
self.widgetDict['volatilityManager'].show()
except KeyError:
self.widgetDict['volatilityManager'] = VolatilityManager(self.omEngine)
self.widgetDict['volatilityManager'].show()
#----------------------------------------------------------------------
def openAnalysisManager(self):
"""打开持仓分析组件"""
try:
self.widgetDict['analysisManager'].showMaximized()
except KeyError:
self.widgetDict['analysisManager'] = AnalysisManager(self.omEngine)
self.widgetDict['analysisManager'].showMaximized()
#----------------------------------------------------------------------
def openStrategyManager(self):
"""打开策略交易组件"""
try:
self.widgetDict['strategyManager'].showMaximized()
except KeyError:
self.widgetDict['strategyManager'] = StrategyEngineManager(self.omEngine)
self.widgetDict['strategyManager'].showMaximized()
#----------------------------------------------------------------------
def close(self):
"""关闭"""
for widget in self.widgetDict.values():
widget.close()
super(OmManager, self).close()
#----------------------------------------------------------------------
def registerEvent(self):
"""注册事件监听"""
self.signal.connect(self.processLogEvent)
self.eventEngine.register(EVENT_OM_LOG, self.signal.emit)
def write_log(self, msg: str):
""""""
event = Event(EVENT_RECORDER_LOG, msg)
self.event_engine.put(event)
def put_setting_event(self, setting_name: str, setting: dict):
""""""
event = Event(EVENT_ALGO_SETTING)
event.data = {"setting_name": setting_name, "setting": setting}
self.event_engine.put(event)
def put_parameters_event(self, algo: AlgoTemplate, parameters: dict):
""""""
event = Event(EVENT_ALGO_PARAMETERS)
event.data = {"algo_name": algo.algo_name, "parameters": parameters}
self.event_engine.put(event)
def put_variables_event(self, algo: AlgoTemplate, variables: dict):
""""""
event = Event(EVENT_ALGO_VARIABLES)
event.data = {"algo_name": algo.algo_name, "variables": variables}
self.event_engine.put(event)
def put_algo_status_event(self, algo: ElectronicEyeAlgo) -> None:
""""""
event = Event(EVENT_OPTION_ALGO_STATUS, algo)
self.event_engine.put(event)
def put_algo_trading_event(self, algo: ElectronicEyeAlgo) -> None:
""""""
event = Event(EVENT_OPTION_ALGO_TRADING, algo)
self.event_engine.put(event)
def on_event(self, type_: str, data: Any):
event = Event(type_, data)
self.event_engine.put(event)
def write_log(self, msg: str) -> None:
""""""
log = LogData(msg=msg, gateway_name=APP_NAME)
event = Event(EVENT_RPC_LOG, log)
self.event_engine.put(event)
class StAlgoManager(QtWidgets.QTableWidget):
"""价差算法管理组件"""
signalPos = QtCore.pyqtSignal(type(Event()))
#----------------------------------------------------------------------
def __init__(self, stEngine, parent=None):
"""Constructor"""
super(StAlgoManager, self).__init__(parent)
self.algoEngine = stEngine.algoEngine
self.eventEngine = stEngine.eventEngine
self.buttonActiveDict = {} # spreadName: buttonActive
self.posCellDict = {} # spreadName: cell
self.initUi()
self.registerEvent()
#----------------------------------------------------------------------
def initUi(self):
"""初始化表格"""
headers = [u'价差',
u'算法',
u'净持仓'
'BuyPrice',
'SellPrice',
'CoverPrice',
'ShortPrice',
u'委托上限',
u'持仓上限',
u'模式',
u'状态']
self.setColumnCount(len(headers))
self.setHorizontalHeaderLabels(headers)
try:
self.horizontalHeader().setResizeMode(QtWidgets.QHeaderView.Stretch)
except AttributeError:
self.horizontalHeader().setSectionResizeMode(QtWidgets.QHeaderView.Stretch)
self.verticalHeader().setVisible(False)
self.setEditTriggers(self.NoEditTriggers)
#----------------------------------------------------------------------
def initCells(self):
"""初始化单元格"""
algoEngine = self.algoEngine
l = self.algoEngine.getAllAlgoParams()
self.setRowCount(len(l))
for row, d in enumerate(l):
cellSpreadName = QtWidgets.QTableWidgetItem(d['spreadName'])
cellAlgoName = QtWidgets.QTableWidgetItem(d['algoName'])
cellNetPos = QtWidgets.QTableWidgetItem('0')
spinBuyPrice = StBuyPriceSpinBox(algoEngine, d['spreadName'], d['buyPrice'])
spinSellPrice = StSellPriceSpinBox(algoEngine, d['spreadName'], d['sellPrice'])
spinShortPrice = StShortPriceSpinBox(algoEngine, d['spreadName'], d['shortPrice'])
spinCoverPrice = StCoverPriceSpinBox(algoEngine, d['spreadName'], d['coverPrice'])
spinMaxOrderSize = StMaxOrderSizeSpinBox(algoEngine, d['spreadName'], d['maxOrderSize'])
spinMaxPosSize = StMaxPosSizeSpinBox(algoEngine, d['spreadName'], d['maxPosSize'])
comboMode = StModeComboBox(algoEngine, d['spreadName'], d['mode'])
buttonActive = StActiveButton(algoEngine, d['spreadName'])
self.setItem(row, 0, cellSpreadName)
self.setItem(row, 1, cellAlgoName)
self.setItem(row, 2, cellNetPos)
self.setCellWidget(row, 3, spinBuyPrice)
self.setCellWidget(row, 4, spinSellPrice)
self.setCellWidget(row, 5, spinCoverPrice)
self.setCellWidget(row, 6, spinShortPrice)
self.setCellWidget(row, 7, spinMaxOrderSize)
self.setCellWidget(row, 8, spinMaxPosSize)
self.setCellWidget(row, 9, comboMode)
self.setCellWidget(row, 10, buttonActive)
buttonActive.signalActive.connect(spinBuyPrice.algoActiveChanged)
buttonActive.signalActive.connect(spinSellPrice.algoActiveChanged)
buttonActive.signalActive.connect(spinShortPrice.algoActiveChanged)
buttonActive.signalActive.connect(spinCoverPrice.algoActiveChanged)
buttonActive.signalActive.connect(spinMaxOrderSize.algoActiveChanged)
buttonActive.signalActive.connect(spinMaxPosSize.algoActiveChanged)
buttonActive.signalActive.connect(comboMode.algoActiveChanged)
self.buttonActiveDict[d['spreadName']] = buttonActive
self.posCellDict[d['spreadName']] = cellNetPos
#----------------------------------------------------------------------
def stopAll(self):
"""停止所有算法"""
for button in self.buttonActiveDict.values():
button.stop()
#----------------------------------------------------------------------
def processStPosEvent(self, event):
""""""
pos = event.dict_['data']
cell = self.posCellDict[pos.name]
cell.setText(str(pos.netPos))
#----------------------------------------------------------------------
def registerEvent(self):
""""""
self.signalPos.connect(self.processStPosEvent)
self.eventEngine.register(EVENT_SPREADTRADING_POS, self.signalPos.emit)
class MmEngineManager(QtWidgets.QMainWindow): #QWidget
"""监控引擎的管理组件"""
signal = QtCore.Signal(type(Event()))
signal_tick = QtCore.Signal(type(Event()))
settingFileName = 'Daily_setting.json'
settingfilePath = getJsonPath(settingFileName, __file__)
def __init__(self, MmEngine, eventEngine, parent=None):
"""Constructor"""
super(MmEngineManager, self).__init__(parent)
self.MmEngine = MmEngine
self.eventEngine = eventEngine
self.isReplay = False ##监控
# 监控的事件类型
self.eventType = EVENT_TICK
if isinstance(self.MmEngine.mainEngine, MainEngine) == True:
print("replay")
self.isReplay = True ##复盘
self.name = "zzsd"
self.stopOrderMonitor = None
self.traderOrderMonitor = None
self.klineDay = None
self.klineOpt = None
self.symbolText = None
self.dayBarData = {}
self.hourBarData = {}
self.hourSarData = {}
self.currrentSymbol = None
self.currrentXmin = None
self.initUi()
# ----------------------------------------------------------------------
def initUi(self):
"""初始化界面"""
self.setWindowTitle(u"监控界面")
self.initMenu()
##log
self.logMonitor = LogMonitor(self.MmEngine, self.eventEngine)
widgetLogM, dockLogM = self.createDock(self.logMonitor, u"log",
QtCore.Qt.LeftDockWidgetArea)
##行情
self.marketMonitor = MarketMonitor(self.MmEngine, self.eventEngine)
widgetMarketM, dockMarketM = self.createDock(
self.marketMonitor, vtText.MARKET_DATA,
QtCore.Qt.LeftDockWidgetArea)
##合约
self.symbolMonitor = ContractManager(self.MmEngine, self.eventEngine,
self)
widgetSymbolM, dockLogM = self.createDock(self.symbolMonitor, u"订阅合约",
QtCore.Qt.LeftDockWidgetArea)
##成交单
self.traderOrderMonitor = TraderOrderMonitor(None, self.eventEngine)
widgetStopOrderM, dockStopOrderM = self.createDock(
self.traderOrderMonitor, u"成交单", QtCore.Qt.LeftDockWidgetArea)
self.updateTraderMonitor() ##更新一下数据
self.traderOrderMonitor.cellDoubleClicked.connect(self.symbolSelect)
self.logMonitor.setMaximumWidth(575)
self.traderOrderMonitor.setMaximumWidth(575)
##K线跟随
self.klineOpt = KLineWidget(name="opt")
widgetklineOptM, dockklineOptM = self.createDock(
self.klineOpt, u"操作周期线", QtCore.Qt.RightDockWidgetArea)
# self.klineDay = KLineWidget(name="day")
# widgetklineDayM, dockklineDayM = self.createDock(self.klineDay, u"周线", QtCore.Qt.RightDockWidgetArea)
if self.isReplay == True:
self.fun_timer(
) #每隔5秒执行一次加载交易数据的函数和日志函数updateTraderMonitor()，updateLogMonitor()
self.refreshTimer = thd.Timer(60, self.fun_timer)
self.refreshTimer.start()
def fun_timer(self):
##加载交易数据
self.updateTraderMonitor()
##加载log数据
self.updateLogMonitor()
def closeEvent(self, event):
if self.refreshTimer:
self.refreshTimer.cancel()
def initMenu(self):
"""初始化菜单"""
# 创建菜单
menubar = self.menuBar()
self.cycle = ["1min", "3min", "5min", "15min", "30min", "1H", "day"]
n = 0
for item in self.cycle:
action = QtWidgets.QAction(item, self)
menubar.addAction(action)
try:
action.triggered[()].connect(
lambda item=item: self.cycleAction(item)
) #一个空元组用于指定触发的信号。如果没有这样做，触发信号将在默认情况下发送一个布尔值，这将阻塞lambda的项目参数。
finally:
pass
def cycleAction(self, cycle):
self.loadXKlineData(self.currrentSymbol, cycle)
def logSelect(self, row=None, column=None):
content = self.logMonitor.item(row, 1).text()
print(content)
if content and content.startswith("subscribe===") == True:
symbol = content[len("subscribe==="):len(content)]
self.loadKlineData(symbol)
##显示合约k线
def symbolSelect(self, row=None, column=None):
symbol = self.traderOrderMonitor.item(row, 1).text()
print(symbol)
if symbol:
self.loadKlineData(symbol)
##显示合约k线
def symbolSelectMarket(self, row=None, column=None):
symbol = self.marketMonitor.item(row, 0).text()
if symbol:
self.loadKlineData(symbol)
def loadKlineData(self, symbol):
if self.currrentSymbol == symbol:
return
self.subscribeEvent(symbol) # 订阅合约
self.currrentSymbol = symbol
print symbol
self.loadBar(symbol)
# self.klineDay.clearData()
self.klineOpt.clearData()
self.klineOpt.KLtitle.setText(symbol + " opt", size='20pt')
self.klineOpt.loadDataBarArray(self.hourBarData[symbol].barData)
def subscribeEvent(self, symbol):
# # 重新注册事件监听
# self.eventEngine.unregister(EVENT_TICK + self.currrentSymbol, self.signal_tick.emit)
self.signal_tick.connect(self.updateEvent)
self.eventEngine.register(EVENT_TICK + symbol, self.signal_tick.emit)
self.signal_tick.connect(self.processTickEvent)
self.eventEngine.register(EVENT_TICK + symbol, self.signal_tick.emit)
# 订阅行情
req = VtSubscribeReq()
req.symbol = symbol
# req.exchange ="SHFE"
self.MmEngine.mainEngine.subscribe(req, "CTP")
# ----------------------------------------------------------------------
def updateEvent(self, event):
"""收到事件更新"""
data = event.dict_['data']
self.marketMonitor.updateData(data)
def loadXKlineData(self, symbol, xmin):
if self.currrentSymbol == symbol and self.currrentXmin == xmin:
return
# 订阅合约
self.subscribeEvent(symbol)
self.currrentSymbol = symbol
self.currrentXmin = xmin
print symbol
self.loadXBar(symbol, xmin)
self.klineOpt.clearData()
self.klineOpt.KLtitle.setText(symbol + " opt=" + xmin, size='20pt')
if xmin == "day":
self.klineOpt.loadDataBarArray(self.dayBarData[symbol].barData)
else:
self.klineOpt.loadDataBarArray(self.hourBarData[symbol].barData)
# 初始化sar指标
self.klineOpt.initIndicator("SAR")
def refreshKline(self, symbol):
if self.hourBarData.has_key(symbol):
hourBar = VtBarData()
hourBar.__dict__ = self.hourBarData[symbol].barData[-1]
self.klineOpt.onBar(hourBar)
def loadBar(self, symbol):
"""读取策略配置"""
with open(self.settingfilePath) as f:
l = json.load(f)
db = MINUTE_5_DB_NAME
xmin = 5
self.currrentXmin = 5
if xmin == "day":
if not self.dayBarData.has_key(symbol):
dbDayList = self.loadAllBarFromDb(DAY_DB_NAME, symbol)
self.dayBarData[symbol] = BarManager(dbDayList,
symbol,
isDay=True)
else:
# if not self.hourBarData.has_key(symbol):
dbHourList = self.loadAllBarFromDb(db, symbol)
self.hourBarData[symbol] = BarManager(dbHourList, symbol, xmin)
def loadXBar(self, symbol, cycle):
db = MINUTE_5_DB_NAME
xmin = 5
if cycle == 'week':
db = WEEK_DB_NAME
elif cycle == 'day':
db = DAILY_DB_NAME
xmin = "day"
elif cycle == '1H':
xmin = 60
db = MINUTE_60_DB_NAME
else:
xmin = cycle_number[cycle]
db = cycle_db[cycle]
self.currrentXmin = xmin
if xmin == "day":
if not self.dayBarData.has_key(symbol):
dbDayList = self.loadAllBarFromDb(DAY_DB_NAME, symbol)
self.dayBarData[symbol] = BarManager(dbDayList,
symbol,
isDay=True)
else:
# if not self.hourBarData.has_key(symbol):
dbHourList = self.loadAllBarFromDb(db, symbol)
self.hourBarData[symbol] = BarManager(dbHourList, symbol, xmin)
# ----------------------------------------------------------------------
def loadAllBarFromDb(self, dbName, collectionName):
"""从数据库中读取Bar数据，startDate是datetime对象"""
d = {}
if hasattr(self.MmEngine, "client"): ##rpc模式
barData = self.MmEngine.client.mainEngine.dbQuery(
dbName, collectionName, d, 'datetime')
else:
barData = self.MmEngine.mainEngine.dbQuery(dbName, collectionName,
d, 'datetime')
return barData
def updateLogMonitor(self):
logList = self.MmEngine.mainEngine.mysqlClient.dbSelect(
SQL_TABLENAME_LOG, None, "all")
for log in logList:
logEntity = VtLogData()
logEntity.gatewayName = log["gatewayName"]
logEntity.logContent = log["logContent"]
logEntity.logLevel = log["logLevel"]
logEntity.logTime = log["logTime"]
self.logMonitor.updateData(logEntity)
##日志table加入click事件 subscribe===
self.logMonitor.cellDoubleClicked.connect(self.logSelect)
def updateTraderMonitor(self):
##更新交易单
varOrders = self.MmEngine.getTraderOrders()
self.traderOrderMonitor.updateAllData(varOrders)
# ----------------------------------------------------------------------
def processTickEvent(self, event):
"""收到事件更新"""
tick = event.dict_['data']
if self.dayBarData.has_key(tick.symbol):
self.dayBarData[tick.symbol].updateTick(tick)
if self.hourBarData.has_key(tick.symbol):
self.hourBarData[tick.symbol].updateTick(tick)
if self.currrentSymbol == tick.symbol:
self.refreshKline(tick.symbol)
# ----------------------------------------------------------------------
def createDock(self, widget, widgetName, widgetArea):
"""创建停靠组件"""
dock = QtWidgets.QDockWidget(widgetName)
dock.setWidget(widget)
dock.setObjectName(widgetName)
dock.setFeatures(dock.DockWidgetFloatable | dock.DockWidgetMovable)
self.addDockWidget(widgetArea, dock)
return widget, dock
def write_log(self, msg: str):
""""""
event = Event(EVENT_BACKTESTER_LOG)
event.data = msg
self.event_engine.put(event)
def put_limit_order_event(self, limit_order: LimitOrder):
"""
Put an event to update stop order status.
"""
event = Event(EVENT_CTA_LIMITORDER, limit_order)
self.event_engine.put(event)
def putStrategyEvent(self, name):
"""触发策略状态变化事件（通常用于通知GUI更新）"""
event = Event(EVENT_OM_STRATEGY + name)
self.eventEngine.put(event)
def put_event(self, event_type: str, data: Any) -> None:
""""""
event = Event(event_type, data)
self.event_engine.put(event)
class CtaStrategyManager(QtWidgets.QGroupBox):
"""策略管理组件"""
signal = QtCore.Signal(type(Event()))
#----------------------------------------------------------------------
def __init__(self, ctaEngine, eventEngine, name, parent=None):
"""Constructor"""
super(CtaStrategyManager, self).__init__(parent)
self.ctaEngine = ctaEngine
self.eventEngine = eventEngine
self.name = name
self.initUi()
self.updateMonitor()
self.registerEvent()
#----------------------------------------------------------------------
def initUi(self):
"""初始化界面"""
self.setTitle(self.name)
self.paramMonitor = CtaValueMonitor(self)
self.varMonitor = CtaValueMonitor(self)
self.dictMonitor = GridControlDictMonitor(self)
height = 65
self.paramMonitor.setFixedHeight(height)
self.varMonitor.setFixedHeight(height)
buttonInit = QtWidgets.QPushButton(text.INIT)
buttonStart = QtWidgets.QPushButton(text.START)
buttonStop = QtWidgets.QPushButton(text.STOP)
buttonInit.clicked.connect(self.init)
buttonStart.clicked.connect(self.start)
buttonStop.clicked.connect(self.stop)
hbox1 = QtWidgets.QHBoxLayout()
hbox1.addWidget(buttonInit)
hbox1.addWidget(buttonStart)
hbox1.addWidget(buttonStop)
hbox1.addStretch()
hbox2 = QtWidgets.QHBoxLayout()
hbox2.addWidget(self.paramMonitor)
hbox3 = QtWidgets.QHBoxLayout()
hbox3.addWidget(self.varMonitor)
# ROBINLIN add QTableWidget to show the control_dic
hbox4 = QtWidgets.QHBoxLayout()
hbox4.addWidget(self.dictMonitor)
vbox = QtWidgets.QVBoxLayout()
vbox.addLayout(hbox1)
vbox.addLayout(hbox2)
vbox.addLayout(hbox3)
vbox.addLayout(hbox4)
self.setLayout(vbox)
#----------------------------------------------------------------------
def updateMonitor(self, event=None):
"""显示策略最新状态"""
paramDict = self.ctaEngine.getStrategyParam(self.name)
if paramDict:
self.paramMonitor.updateData(paramDict)
varDict = self.ctaEngine.getStrategyVar(self.name)
if varDict:
self.varMonitor.updateData(varDict)
controlDict = varDict['control_dict']
if controlDict:
self.dictMonitor.updateData(controlDict)
#----------------------------------------------------------------------
def registerEvent(self):
"""注册事件监听"""
self.signal.connect(self.updateMonitor)
self.eventEngine.register(EVENT_CTA_STRATEGY + self.name,
self.signal.emit)
#----------------------------------------------------------------------
def init(self):
"""初始化策略"""
self.ctaEngine.initStrategy(self.name)
#----------------------------------------------------------------------
def start(self):
"""启动策略"""
self.ctaEngine.startStrategy(self.name)
#----------------------------------------------------------------------
def stop(self):
"""停止策略"""
self.ctaEngine.stopStrategy(self.name)
def put_strategy_event(self, strategy: SpreadStrategyTemplate):
""""""
data = strategy.get_data()
event = Event(EVENT_SPREAD_STRATEGY, data)
self.event_engine.put(event)
class CtaEngineManager(QtWidgets.QWidget):
"""CTA引擎管理组件"""
signal = QtCore.Signal(type(Event()))
#----------------------------------------------------------------------
def __init__(self, ctaEngine, eventEngine, parent=None):
"""Constructor"""
super(CtaEngineManager, self).__init__(parent)
self.ctaEngine = ctaEngine
self.eventEngine = eventEngine
self.strategyLoaded = False
self.initUi()
self.registerEvent()
# 记录日志
self.ctaEngine.writeCtaLog(text.CTA_ENGINE_STARTED)
#----------------------------------------------------------------------
def initUi(self):
"""初始化界面"""
self.setWindowTitle(text.CTA_STRATEGY)
# 按钮
loadButton = QtWidgets.QPushButton(text.LOAD_STRATEGY)
initAllButton = QtWidgets.QPushButton(text.INIT_ALL)
startAllButton = QtWidgets.QPushButton(text.START_ALL)
stopAllButton = QtWidgets.QPushButton(text.STOP_ALL)
loadButton.clicked.connect(self.load)
initAllButton.clicked.connect(self.initAll)
startAllButton.clicked.connect(self.startAll)
stopAllButton.clicked.connect(self.stopAll)
# 滚动区域，放置所有的CtaStrategyManager
self.scrollArea = QtWidgets.QScrollArea()
self.scrollArea.setWidgetResizable(True)
# CTA组件的日志监控
self.ctaLogMonitor = QtWidgets.QTextEdit()
self.ctaLogMonitor.setReadOnly(True)
self.ctaLogMonitor.setMaximumHeight(200)
# 设置布局
hbox2 = QtWidgets.QHBoxLayout()
hbox2.addWidget(loadButton)
hbox2.addWidget(initAllButton)
hbox2.addWidget(startAllButton)
hbox2.addWidget(stopAllButton)
hbox2.addStretch()
vbox = QtWidgets.QVBoxLayout()
vbox.addLayout(hbox2)
vbox.addWidget(self.scrollArea)
vbox.addWidget(self.ctaLogMonitor)
self.setLayout(vbox)
self.resize(1024, 800) #ROBINLIN
# ROBINLIN 窗口显示后，立即加载和初始化策略。
self.load()
self.initAll()
self.startAll()
#----------------------------------------------------------------------
def initStrategyManager(self):
"""初始化策略管理组件界面"""
w = QtWidgets.QWidget()
vbox = QtWidgets.QVBoxLayout()
l = self.ctaEngine.getStrategyNames()
for name in l:
strategyManager = CtaStrategyManager(self.ctaEngine,
self.eventEngine, name)
vbox.addWidget(strategyManager)
vbox.addStretch()
w.setLayout(vbox)
self.scrollArea.setWidget(w)
#----------------------------------------------------------------------
def initAll(self):
"""全部初始化"""
self.ctaEngine.initAll()
#----------------------------------------------------------------------
def startAll(self):
"""全部启动"""
self.ctaEngine.startAll()
#----------------------------------------------------------------------
def stopAll(self):
"""全部停止"""
self.ctaEngine.stopAll()
#----------------------------------------------------------------------
def load(self):
"""加载策略"""
if not self.strategyLoaded:
self.ctaEngine.loadSetting()
self.initStrategyManager()
self.strategyLoaded = True
self.ctaEngine.writeCtaLog(text.STRATEGY_LOADED)
#----------------------------------------------------------------------
def updateCtaLog(self, event):
"""更新CTA相关日志"""
log = event.dict_['data']
content = '\t'.join([log.logTime, log.logContent])
self.ctaLogMonitor.append(content)
#----------------------------------------------------------------------
def registerEvent(self):
"""注册事件监听"""
self.signal.connect(self.updateCtaLog)
self.eventEngine.register(EVENT_CTA_LOG, self.signal.emit)
#----------------------------------------------------------------------
def closeEvent(self, event):
print "uiCtaWidget:closeEvent"
self.stopAll()
def on_event(self, type: str, data: Any = None) -> None:
"""
General event push.
"""
event = Event(type, data)
self.event_engine.put(event)
class DrEngineManager(QtWidgets.QWidget):
"""行情数据记录引擎管理组件"""
signal = QtCore.Signal(type(Event()))
#----------------------------------------------------------------------
def __init__(self, drEngine, eventEngine, parent=None):
"""Constructor"""
super(DrEngineManager, self).__init__(parent)
self.drEngine = drEngine
self.eventEngine = eventEngine
self.initUi()
self.updateSetting()
self.registerEvent()
#----------------------------------------------------------------------
def initUi(self):
"""初始化界面"""
self.setWindowTitle(text.DATA_RECORDER)
# 记录合约配置监控
tickLabel = QtWidgets.QLabel(text.TICK_RECORD)
self.tickTable = QtWidgets.QTableWidget()
self.tickTable.setColumnCount(2)
self.tickTable.verticalHeader().setVisible(False)
self.tickTable.setEditTriggers(QtWidgets.QTableWidget.NoEditTriggers)
self.tickTable.setAlternatingRowColors(True)
self.tickTable.setHorizontalHeaderLabels(
[text.CONTRACT_SYMBOL, text.GATEWAY])
barLabel = QtWidgets.QLabel(text.BAR_RECORD)
self.barTable = QtWidgets.QTableWidget()
self.barTable.setColumnCount(2)
self.barTable.verticalHeader().setVisible(False)
self.barTable.setEditTriggers(QtWidgets.QTableWidget.NoEditTriggers)
self.barTable.setAlternatingRowColors(True)
self.barTable.setHorizontalHeaderLabels(
[text.CONTRACT_SYMBOL, text.GATEWAY])
activeLabel = QtWidgets.QLabel(text.DOMINANT_CONTRACT)
self.activeTable = QtWidgets.QTableWidget()
self.activeTable.setColumnCount(2)
self.activeTable.verticalHeader().setVisible(False)
self.activeTable.setEditTriggers(QtWidgets.QTableWidget.NoEditTriggers)
self.activeTable.setAlternatingRowColors(True)
self.activeTable.setHorizontalHeaderLabels(
[text.DOMINANT_SYMBOL, text.CONTRACT_SYMBOL])
# 日志监控
self.logMonitor = QtWidgets.QTextEdit()
self.logMonitor.setReadOnly(True)
self.logMonitor.setMinimumHeight(600)
# 设置布局
grid = QtWidgets.QGridLayout()
grid.addWidget(tickLabel, 0, 0)
grid.addWidget(barLabel, 0, 1)
grid.addWidget(activeLabel, 0, 2)
grid.addWidget(self.tickTable, 1, 0)
grid.addWidget(self.barTable, 1, 1)
grid.addWidget(self.activeTable, 1, 2)
vbox = QtWidgets.QVBoxLayout()
vbox.addLayout(grid)
vbox.addWidget(self.logMonitor)
self.setLayout(vbox)
#----------------------------------------------------------------------
def updateLog(self, event):
"""更新日志"""
log = event.dict_['data']
content = '\t'.join([log.logTime, log.logContent])
self.logMonitor.append(content)
#----------------------------------------------------------------------
def registerEvent(self):
"""注册事件监听"""
self.signal.connect(self.updateLog)
self.eventEngine.register(EVENT_DATARECORDER_LOG, self.signal.emit)
#----------------------------------------------------------------------
def updateSetting(self):
"""显示引擎行情记录配置"""
setting, activeSetting = self.drEngine.getSetting()
for d in setting.values():
if 'tick' in d and d['tick']:
self.tickTable.insertRow(0)
self.tickTable.setItem(0, 0, TableCell(d['symbol']))
self.tickTable.setItem(0, 1, TableCell(d['gateway']))
if 'bar' in d and d['bar']:
self.barTable.insertRow(0)
self.barTable.setItem(0, 0, TableCell(d['symbol']))
self.barTable.setItem(0, 1, TableCell(d['gateway']))
for vtSymbol, activeSymbol in activeSetting.items():
self.activeTable.insertRow(0)
self.activeTable.setItem(0, 0, TableCell(activeSymbol))
self.activeTable.setItem(0, 1, TableCell(vtSymbol))
self.tickTable.resizeColumnsToContents()
self.barTable.resizeColumnsToContents()
self.activeTable.resizeColumnsToContents()
def put_stop_order_event(self, stop_order: StopOrder):
"""
Put an event to update stop order status.
"""
event = Event(EVENT_CTA_STOPORDER, stop_order)
self.event_engine.put(event)
def addTable(self, data):
event = Event(type_=u"addTable")
event.dict_['data'] = data
self.eventEngine.put(event)
def run_backtesting(
self,
class_name: str,
vt_symbol: str,
interval: str,
start: datetime,
end: datetime,
rate: float,
slippage: float,
size: int,
pricetick: float,
capital: int,
inverse: bool,
setting: dict
):
""""""
self.result_df = None
self.result_statistics = None
engine = self.backtesting_engine
engine.clear_data()
engine.set_parameters(
vt_symbol=vt_symbol,
interval=interval,
start=start,
end=end,
rate=rate,
slippage=slippage,
size=size,
pricetick=pricetick,
capital=capital,
inverse=inverse
)
strategy_class = self.classes[class_name]
engine.add_strategy(
strategy_class,
setting
)
engine.load_data()
try:
engine.run_backtesting()
except Exception:
msg = f"策略回测失败，触发异常：\n{traceback.format_exc()}"
self.write_log(msg)
self.thread = None
return
self.result_df = engine.calculate_result()
self.result_statistics = engine.calculate_statistics(output=False)
# Clear thread object handler.
self.thread = None
# Put backtesting done event
event = Event(EVENT_BACKTESTER_BACKTESTING_FINISHED)
self.event_engine.put(event)
def putAlgoEvent(self, algo):
"""发出算法状态更新事件"""
event = Event(EVENT_SPREADTRADING_ALGO+algo.name)
self.eventEngine.put(event)
def put_data_event(self, spread: SpreadData) -> None:
""""""
event = Event(EVENT_SPREAD_DATA, spread)
self.event_engine.put(event)
