def handleStatisticJudgeEvent(self, event, callback): self._logger.debug( "src.core.engine.handler.Handler.handleStatisticJudgeEvent: {id=%s, type=%s, priority=%s, timeStamp=%s, args=%s}" % (event.id, event.type, event.priority, event.timeStamp, event.args)) # 接收事件 [exchange, types] = event.args exchange = str_to_list(exchange) types = str_to_list(types) try: db = DB() calc = Calc() # calc dis type if TYPE_DIS in types: statisticDis = calc.calcStatisticJudgeMarketTickerDis( exchange, TYPE_DIS_TIMEWINDOW) if not statisticDis == []: db.insertStatisticJudgeMarketTickerDis(statisticDis) # calc tra type if TYPE_TRA in types: statisticTra = calc.calcStatisticJudgeMarketTickerTra( exchange, TYPE_TRA_TIMEWINDOW) if not statisticTra == []: db.insertStatisticJudgeMarketTickerTra(statisticTra) # calc pair type if TYPE_PAIR in types: statisticPair = calc.calcStatisticJudgeMarketTickerPair( exchange, TYPE_PAIR_TIMEWINDOW) if not statisticPair == []: db.insertStatisticJudgeMarketTickerPair(statisticPair) except (DBException, CalcException, EngineException, Exception) as err: errStr = "src.core.engine.handler.Handler.handleStatisticJudgeEvent: { type=%s, priority=%s, args=%s }, err=%s" % ( event.type, event.priority, event.args, err) self._logger.error(errStr) callback(event.id)
def handleListenMarketTickerEvent(self, event, callback): self._logger.debug( "src.core.engine.handler.Handler.handleListenMarketTickerEvent: {id=%s, type=%s, priority=%s, timeStamp=%s, args=%s}" % (event.id, event.type, event.priority, event.timeStamp, event.args)) # 接收事件 [exchange, fSymbol, tSymbol, aggDepth] = event.args exchange = str_to_list(exchange) try: db = DB() db.insertMarketTicker(exchange, fSymbol, tSymbol, aggDepth) except (DBException, CalcException, EngineException, Exception) as err: errStr = "src.core.engine.handler.Handler.handleListenTickerEvent: { type=%s, priority=%s, args=%s }, err=%s" % ( event.type, event.priority, event.args, err) self._logger.error(errStr) callback(event.id)
def handleListenAccountWithdrawEvent(self, event, callback): # 接收事件 self._logger.debug( "src.core.engine.handler.Handler.handleListenAccountWithdrawEvent: {id=%s, type=%s, priority=%s, timeStamp=%s, args=%s}" % (event.id, event.type, event.priority, event.timeStamp, event.args)) [exchange, asset] = event.args exchange = str_to_list(exchange) try: db = DB() db.insertAccountWithdrawHistoryAsset(exchange, asset) except (DBException, CalcException, EngineException, Exception) as err: errStr = "src.core.engine.handler.Handler.handleListenAccountWithdrawEvent: { type=%s, priority=%s, args=%s }, err=%s" % ( event.type, event.priority, event.args, err) self._logger.error(errStr) callback(event.id)
def handleOrderHistorySyncEvent(self, event, callback): self._logger.debug( "src.core.engine.handler.Handler.handleOrderHistorySyncEvent: {id=%s, type=%s, priority=%s, timeStamp=%s, args=%s}" % (event.id, event.type, event.priority, event.timeStamp, event.args)) # 接收事件 [exchange, fSymbol, tSymbol, limit, ratio] = event.args exchange = str_to_list(exchange) try: db = DB() db.insertSyncTradeOrderHistory(exchange, fSymbol, tSymbol, limit, ratio) except (DBException, CalcException, EngineException, Exception) as err: errStr = "src.core.engine.handler.Handler.handleOrderHistorySyncEvent: { type=%s, priority=%s, args=%s }, err=%s" % ( event.type, event.priority, event.args, err) self._logger.error(errStr) callback(event.id)
def handleStatisticOrderEvent(self, event, callback): self._logger.debug( "src.core.engine.handler.Handler.handleStatisticOrderEvent: {id=%s, type=%s, priority=%s, timeStamp=%s, args=%s}" % (event.id, event.type, event.priority, event.timeStamp, event.args)) # 接收事件 [signals] = event.args signals = str_to_list(signals) for signal in signals: signal['status_assets'] = json.loads( json_reverse(signal['status_assets'])) try: db = DB() calc = Calc() statistic = calc.calcStatisticTradeOrderHistory(signals) db.insertStatisticTradeOrderHistory(statistic) except (DBException, CalcException, EngineException, Exception) as err: errStr = "src.core.engine.handler.Handler.handleStatisticOrderEvent: { type=%s, priority=%s, args=%s }, err=%s" % ( event.type, event.priority, event.args, err) self._logger.error(errStr) callback(event.id)
def handleJudgeMarketTickerEvent(self, event, callback): self._logger.debug( "src.core.engine.handler.Handler.handleJudgeMarketTickerEvent: " + event.type) # 接收事件 [exchange, types] = event.args exchange = str_to_list(exchange) types = str_to_list(types) try: db = DB() calc = Calc() resInfoSymbol = pd.DataFrame(db.getViewMarketSymbolPairs(exchange)) prs = [] # calc dis type if TYPE_DIS in types: signalDis = calc.calcJudgeMarketTickerDis( exchange, TYPE_DIS_THRESHOLD, resInfoSymbol) if not signalDis == []: db.insertJudgeMarketTickerDis(signalDis) # calc tra type if TYPE_TRA in types: signalTra = calc.calcJudgeMarketTickerTra( exchange, TYPE_TRA_THRESHOLD, resInfoSymbol) if not signalTra == []: db.insertJudgeMarketTickerTra(signalTra) # calc pair type if TYPE_PAIR in types: signalPair = calc.calcJudgeMarketTickerPair( exchange, TYPE_PAIR_THRESHOLD, resInfoSymbol) if not signalPair == []: db.insertJudgeMarketTickerPair(signalPair) except (DBException, CalcException, EngineException, Exception) as err: errStr = "src.core.engine.handler.Handler.handleJudgeMarketTickerEvent: { type=%s, priority=%s, args=%s }, err=%s" % ( event.type, event.priority, event.args, err) self._logger.error(errStr) callback(event.id)
# -*- coding: utf-8 -*- import os import sys import unittest import pandas as pd sys.path.append(os.getcwd()) from src.core.calc.calc import Calc from src.core.calc.signal import Signal from src.core.db.db import DB from src.core.util.log import Logger db = DB() calc = Calc() sgn = Signal() logger = Logger() resInfoSymbol = pd.DataFrame(db.getInfoSymbol(['okex','binance','huobi'])) class TestDB(unittest.TestCase): def test_initDB(self): db.initDB() res = db.getTables() logger.debug(res) self.assertIsInstance(res, list) def test_getViews(self): res = db.getViews()
def handleBacktestHistoryCreatEvent(self, event, callback): self._logger.debug( "src.core.engine.handler.Handler.handleBacktestHistoryCreatEvent: {id=%s, type=%s, priority=%s, timeStamp=%s, args=%s}" % (event.id, event.type, event.priority, event.timeStamp, event.args)) # 接收事件 [exchange, signals, timeout] = event.args exchange = str_to_list(exchange) signals = str_to_list(signals) timeout = float(timeout) # 处理事件 try: db = DB() sgn = Signal(signals) resInfoSymbol = pd.DataFrame(db.getViewMarketSymbolPairs(exchange)) # 0. start identify = 0 startTime = time.time() str = "src.core.engine.handler.Handler.handleBacktestHistoryCreatEvent: { type=%s, priority=%s, args=%s }" % ( event.type, event.priority, event.args) warnStr = Template( ", err=$err, backtest trade filed at $here, will try again...") errStr = Template( "BACKTEST TRADE ERROR. pre trade failed at $here.") ######################################## # 1. pre trade # 1.1 calc pre orders preOrders = [] isError = SIGNAL_MAX_NUM while isError > 0: try: isError = isError - 1 preOrders = sgn.backtestSignalsPreTrade(resInfoSymbol) isError = 0 except Exception as err: self._logger.warn(str + warnStr.substitute( err=err, here='1.1 calc pre orders')) if isError > 0: raise Exception(errStr.substitute(here='1.1 calc pre orders')) # print('1. pre signals preOrders:\n%s' % preOrders) # 1.2 calc preExecOrders preExecOrders = [] if not preOrders == []: for order in preOrders: identify = identify + 1 isError = SIGNAL_MAX_NUM res = [] while isError > 0: try: isError = isError - 1 res = db.insertCreatTradeBacktestHistory( order['server'], order['fSymbol'], order['tSymbol'], order['ask_or_bid'], order['price'], order['quantity'], order['ratio'], order['type'], order['signal_id'], order['group_id'], identify) isError = 0 except Exception as err: self._logger.warn(str + warnStr.substitute( err=err, here='1.2 excute preOrders')) if not res == []: preExecOrders.extend(res) if isError > 0: # rollback: pdOrders = pd.DataFrame(preExecOrders) self.rollbackHandleBacktestHistoryCreatEvent( sgn, pdOrders, exchange, resInfoSymbol) raise Exception( errStr.substitute(here='1.2 excute preOrders')) # print('1. pre signals preExecOrders:\n%s' % preExecOrders) # 1.3 calc preInfoOrders preInfoOrders = [] if not preExecOrders == []: preExecOrders = pd.DataFrame(preExecOrders) for server in exchange: res = [] orderIDs = preExecOrders[(preExecOrders['server'] == server )]['order_id'].tolist() res = db.getTradeBacktestHistoryServerOrder([server], orderIDs) if not res == []: preInfoOrders.extend(res) # print('1. pre signals preInfoOrders:\n%s' % preInfoOrders) # 1.4 update signals status if not preInfoOrders == []: preInfoOrders = pd.DataFrame(preInfoOrders) isError = SIGNAL_MAX_NUM while isError > 0: try: isError = isError - 1 sgn.backtestUpdateSignalStatusByOrders( preInfoOrders, resInfoSymbol) isError = 0 except Exception as err: self._logger.warn(str + warnStr.substitute( err=err, here='1.4 update signals status')) if isError > 0: # rollback: pdOrders = preExecOrders self.rollbackHandleBacktestHistoryCreatEvent( sgn, pdOrders, exchange, resInfoSymbol) raise Exception( errStr.substitute(here='1.4 update signals status')) # insert db signals db.insertSignalTradeDis(sgn.signals(exchange, [TYPE_DIS]), SIGNAL_BACKTEST) db.insertSignalTradeTra(sgn.signals(exchange, [TYPE_TRA]), SIGNAL_BACKTEST) db.insertSignalTradePair(sgn.signals(exchange, [TYPE_PAIR]), SIGNAL_BACKTEST) # print('1. pre signals after update:\n%s' % sgn.signals()) ######################################## # 2. run trade isError = True while isError and (time.time() - startTime < timeout or timeout == 0): # 2.1 calc run orders runOrders = [] isSubError = SIGNAL_MAX_NUM while isSubError > 0 and (time.time() - startTime < timeout or timeout == 0): try: isSubError = isSubError - 1 runOrders = sgn.backtestSignalsRunTrade(resInfoSymbol) isSubError = 0 except Exception as err: self._logger.warn(str + warnStr.substitute( err=err, here='2.1 calc run orders')) if isSubError > 0: # rollback: pdOrders = [] self.rollbackHandleBacktestHistoryCreatEvent( sgn, pdOrders, exchange, resInfoSymbol) raise Exception( errStr.substitute(here='2.1 calc run orders')) # print('2. run signals runOrders:\n%s' % runOrders) # 2.2 calc runExecOrders runExecOrders = [] if not runOrders == []: for order in runOrders: identify = identify + 1 isSubError = SIGNAL_MAX_NUM res = [] while isSubError > 0 and (time.time() - startTime < timeout or timeout == 0): try: isSubError = isSubError - 1 res = db.insertCreatTradeBacktestHistory( order['server'], order['fSymbol'], order['tSymbol'], order['ask_or_bid'], order['price'], order['quantity'], order['ratio'], order['type'], order['signal_id'], order['group_id'], identify) isSubError = 0 except Exception as err: self._logger.warn(str + warnStr.substitute( err=err, here='2.2 execute runOrders')) if not res == []: runExecOrders.extend(res) if isSubError > 0: # rollback: pdOrders = pd.DataFrame(runExecOrders) self.rollbackHandleBacktestHistoryCreatEvent( sgn, pdOrders, exchange, resInfoSymbol) raise Exception( errStr.substitute(here='2.2 execute runOrders')) # print('2. run signals runExecOrders:\n%s' % runExecOrders) # 2.3 calc runInfoOrders runInfoOrders = [] if not runExecOrders == []: runExecOrders = pd.DataFrame(runExecOrders) for server in exchange: res = [] orderIDs = runExecOrders[( runExecOrders['server'] == server )]['order_id'].tolist() res = db.getTradeBacktestHistoryServerOrder([server], orderIDs) if not res == []: runInfoOrders.extend(res) # print('2. run signals runInfoOrders:\n%s' % runInfoOrders) # 2.4 update signals status if not runInfoOrders == []: runInfoOrders = pd.DataFrame(runInfoOrders) isSubError = SIGNAL_MAX_NUM while isSubError > 0 and (time.time() - startTime < timeout or timeout == 0): try: isSubError = isSubError - 1 sgn.backtestUpdateSignalStatusByOrders( runInfoOrders, resInfoSymbol) isSubError = 0 except Exception as err: self._logger.warn(str + warnStr.substitute( err=err, here='2.4 update signals status')) if isSubError > 0: # rollback: pdOrders = runExecOrders self.rollbackHandleBacktestHistoryCreatEvent( sgn, pdOrders, exchange, resInfoSymbol) raise Exception( errStr.substitute( here='2.4 update signals status')) # insert db signals db.insertSignalTradeDis(sgn.signals(exchange, [TYPE_DIS]), SIGNAL_BACKTEST) db.insertSignalTradeTra(sgn.signals(exchange, [TYPE_TRA]), SIGNAL_BACKTEST) db.insertSignalTradePair( sgn.signals(exchange, [TYPE_PAIR]), SIGNAL_BACKTEST) # print('2. run signals after update:\n%s' % sgn.signals()) # 2.5 update isError isMore = sgn.backtestSignalsIsRunMore(resInfoSymbol) if not isMore: isError = False ######################################## # 3. after trade isError = SIGNAL_MAX_NUM while isError > 0: isError = isError - 1 # 3.1 calc after orders afterOrders = [] isSubError = SIGNAL_MAX_NUM while isSubError > 0: try: isSubError = isSubError - 1 afterOrders = sgn.backtestSignalsAfterTrade( resInfoSymbol) isSubError = 0 except Exception as err: self._logger.warn(str + warnStr.substitute( err=err, here='3.1 calc after orders')) if isSubError > 0: # rollback pdOrders = [] self.rollbackHandleBacktestHistoryCreatEvent( sgn, pdOrders, exchange, resInfoSymbol) raise Exception( errStr.substitute(here='3.1 calc after orders')) # print('3. after signals afterOrders:\n%s' % afterOrders) # 3.2 calc afterExecOrders afterExecOrders = [] if not afterOrders == []: for order in afterOrders: identify = identify + 1 isSubError = SIGNAL_MAX_NUM res = [] while isSubError > 0: try: isSubError = isSubError - 1 res = db.insertCreatTradeBacktestHistory( order['server'], order['fSymbol'], order['tSymbol'], order['ask_or_bid'], order['price'], order['quantity'], order['ratio'], order['type'], order['signal_id'], order['group_id'], identify) isSubError = 0 except Exception as err: self._logger.warn(str + warnStr.substitute( err=err, here='3.2 excute preOrders')) if not res == []: afterExecOrders.extend(res) if isSubError > 0: # rollback: pdOrders = pd.DataFrame(afterExecOrders) self.rollbackHandleBacktestHistoryCreatEvent( sgn, pdOrders, exchange, resInfoSymbol) raise Exception( errStr.substitute(here='3.2 excute preOrders')) # print('3. after signals afterExecOrders:\n%s' % afterExecOrders) # 3.3 calc afterInfoOrders afterInfoOrders = [] if not afterExecOrders == []: afterExecOrders = pd.DataFrame(afterExecOrders) for server in exchange: res = [] orderIDs = preExecOrders[( preExecOrders['server'] == server )]['order_id'].tolist() res = db.getTradeBacktestHistoryServerOrder([server], orderIDs) if not res == []: afterInfoOrders.extend(res) # print('3. after signals afterInfoOrders:\n%s' % afterInfoOrders) # 3.4 update signals status if not afterInfoOrders == []: afterInfoOrders = pd.DataFrame(afterInfoOrders) isSubError = SIGNAL_MAX_NUM while isSubError > 0: try: isSubError = isSubError - 1 sgn.backtestUpdateSignalStatusByOrders( afterInfoOrders, resInfoSymbol) isSubError = 0 except Exception as err: self._logger.warn(str + warnStr.substitute( err=err, here='3.4 update signals status')) if isSubError > 0: # rollback: pdOrders = afterExecOrders self.rollbackHandleBacktestHistoryCreatEvent( sgn, pdOrders, exchange, resInfoSymbol) raise Exception( errStr.substitute( here='3.4 update signals status')) # insert db signals db.insertSignalTradeDis(sgn.signals(exchange, [TYPE_DIS]), SIGNAL_BACKTEST) db.insertSignalTradeTra(sgn.signals(exchange, [TYPE_TRA]), SIGNAL_BACKTEST) db.insertSignalTradePair( sgn.signals(exchange, [TYPE_PAIR]), SIGNAL_BACKTEST) # print('3. after signals after update:\n%s' % sgn.signals()) # 3.5 update isError isMore = sgn.backtestSignalsIsRunMore(resInfoSymbol) if not isMore: isError = 0 except (DBException, CalcException, EngineException, Exception) as err: errStr = "src.core.engine.handler.Handler.handleBacktestHistoryCreatEvent: { type=%s, priority=%s, args=%s }, err=%s" % ( event.type, event.priority, event.args, err) self._logger.error(errStr) callback(event.id)
def rollbackHandleBacktestHistoryCreatEvent(self, sgn, pdOrders, exchange, resInfoSymbol): self._logger.debug( "src.core.engine.handler.Handler.rollbackHandleBacktestHistoryCreatEvent" ) try: db = DB() # update orders sgn status infoOrders = [] if not pdOrders.empty: for server in exchange: res = [] orderIDs = pdOrders[( pdOrders['server'] == server)]['order_id'].tolist() res = db.getTradeBacktestHistoryServerOrder([server], orderIDs) if not res == []: infoOrders.extend(res) if not infoOrders == []: infoOrders = pd.DataFrame(infoOrders) isError = SIGNAL_MAX_NUM while isError > 0: try: isError = isError - 1 sgn.backtestUpdateSignalStatusByOrders( infoOrders, resInfoSymbol) isError = 0 except Exception as err: self._logger.warn('rollback failed, will try again...') if isError > 0: raise Exception( 'rollback error, start_base assets may loss control.') # insert db signals db.insertSignalTradeDis(sgn.signals(exchange, [TYPE_DIS]), SIGNAL_BACKTEST) db.insertSignalTradeTra(sgn.signals(exchange, [TYPE_TRA]), SIGNAL_BACKTEST) db.insertSignalTradePair(sgn.signals(exchange, [TYPE_PAIR]), SIGNAL_BACKTEST) # rollback assets isError = SIGNAL_MAX_NUM while isError > 0: isError = isError - 1 # calc after orders afterOrders = [] isSubError = SIGNAL_MAX_NUM while isSubError > 0: try: isSubError = isSubError - 1 afterOrders = sgn.backtestSignalsAfterTrade( resInfoSymbol) isSubError = 0 except Exception as err: self._logger.warn('rollback failed, will try again...') if isSubError > 0: raise Exception( 'rollback error, start_base assets may loss control.') # calc afterExecOrders afterExecOrders = [] if not afterOrders == []: for order in afterOrders: identify = identify + 1 isSubError = SIGNAL_MAX_NUM res = [] while isSubError > 0: try: isSubError = isSubError - 1 res = db.insertCreatTradeBacktestHistory( order['server'], order['fSymbol'], order['tSymbol'], order['ask_or_bid'], order['price'], order['quantity'], order['ratio'], order['type'], order['signal_id'], order['group_id'], identify) isSubError = 0 except Exception as err: self._logger.warn( 'rollback failed, will try again...') if not res == []: afterExecOrders.extend(res) if isSubError > 0: raise Exception( 'rollback error, start_base assets may loss control.' ) # calc afterInfoOrders afterInfoOrders = [] if not afterExecOrders == []: afterExecOrders = pd.DataFrame(afterExecOrders) for server in exchange: res = [] orderIDs = preExecOrders[( preExecOrders['server'] == server )]['order_id'].tolist() res = db.getTradeBacktestHistoryServerOrder([server], orderIDs) if not res == []: afterInfoOrders.extend(res) # update signals status if not afterInfoOrders == []: afterInfoOrders = pd.DataFrame(afterInfoOrders) isSubError = SIGNAL_MAX_NUM while isSubError > 0: try: isSubError = isSubError - 1 sgn.backtestUpdateSignalStatusByOrders( afterInfoOrders, resInfoSymbol) isSubError = 0 except Exception as err: self._logger.warn( 'rollback failed, will try again...') if isSubError > 0: raise Exception( 'rollback error, start_base assets may loss control.' ) # insert db signals db.insertSignalTradeDis(sgn.signals(exchange, [TYPE_DIS]), SIGNAL_BACKTEST) db.insertSignalTradeTra(sgn.signals(exchange, [TYPE_TRA]), SIGNAL_BACKTEST) db.insertSignalTradePair( sgn.signals(exchange, [TYPE_PAIR]), SIGNAL_BACKTEST) # update isError isMore = sgn.backtestSignalsIsRunMore(resInfoSymbol) if not isMore: isError = 0 except Exception as err: errStr = "src.core.engine.handler.Handler.rollbackHandleBacktestHistoryCreatEvent, err=%s" % err self._logger.critical(errStr)