Python DyEvent.data['class']方法代码示例

# 需要导入模块: from EventEngine import DyEvent [as 别名]
# 或者: from EventEngine.DyEvent import data['class'] [as 别名]
    def checkAll(self, strategyCls, eventEngine):
        """ check '运行' 和 '监控' """

        if self.isState(DyStockStrategyState.running) and self.isState(DyStockStrategyState.monitoring):
            return

        if self._state is None:
            event = DyEvent(DyEventType.startStockCtaStrategy)

            event.data['class'] = strategyCls
            event.data['state'] = DyStockStrategyState(DyStockStrategyState.running, DyStockStrategyState.monitoring)

            self.add(DyStockStrategyState.running, DyStockStrategyState.monitoring)

        else:
            if self.isState(DyStockStrategyState.running):
                self.add(DyStockStrategyState.monitoring)
            else:
                self.add(DyStockStrategyState.running)

            event = DyEvent(DyEventType.changeStockCtaStrategyState)

            event.data['class'] = strategyCls
            event.data['state'] = DyStockStrategyState(DyStockStrategyState.monitoring, DyStockStrategyState.running)

        eventEngine.put(event)

# 需要导入模块: from EventEngine import DyEvent [as 别名]
# 或者: from EventEngine.DyEvent import data['class'] [as 别名]
    def _backTestingParamGroups(self):
        """
            类似于窗口推进方式回测参数组合
        """
        if not (self._paramGroups or self._runningBackTestingParamGroups):
            self._eventEngine.put(DyEvent(DyEventType.finish))
            return True

        while len(self._runningBackTestingParamGroups) < self._paramGroupNbr:
            if not self._paramGroups:
                break

            self._paramGroupCount += 1

            self._info.print("开始回测策略: {0}, 参数组合: {1}...".format(self._strategyCls.chName, self._paramGroupCount), DyLogData.ind)

            """ 开始一个参数组合的回测 """
            # pop one param group
            param = self._paramGroups.pop(0)

            # it's one new running paramGroup
            self._runningBackTestingParamGroups[self._paramGroupCount] = []

            # notify Ui to create new param group widget for strategy
            event = DyEvent(DyEventType.newStockStrategyBackTestingParam)
            event.data['class'] = self._strategyCls
            event.data['param'] = {'groupNo': self._paramGroupCount, 'data': param}

            self._eventEngine.put(event)

            """ 开始一个参数组合的多个周期回测 """
            # 分成@self._periodNbr个周期，通过子进程并行运行
            stepSize = (len(self._tradeDays) + self._periodNbr - 1)//self._periodNbr
            if stepSize == 0: return False

            for i in range(0, len(self._tradeDays), stepSize):
                # period
                tradeDays_ = self._tradeDays[i:i + stepSize]

                # notify Ui to create new period widget for strategy
                event = DyEvent(DyEventType.newStockStrategyBackTestingPeriod)
                event.data['class'] = self._strategyCls
                event.data['paramGroupNo'] = self._paramGroupCount
                event.data['period'] = [tradeDays_[0], tradeDays_[-1]]

                self._eventEngine.put(event)

                sleep(1) # !!!sleep so that UI windows can be created firstly.

                # it's one new running period for one new paramGroup
                self._runningBackTestingParamGroups[self._paramGroupCount].append(event.data['period'])

                # create subprocess for processing each period
                reqData = DyStockBackTestingStrategyReqData(self._strategyCls, tradeDays_, self._settings, param, self._testedStocks, self._paramGroupCount)
                self._proxy.startBackTesting(reqData)

        return True

# 需要导入模块: from EventEngine import DyEvent [as 别名]
# 或者: from EventEngine.DyEvent import data['class'] [as 别名]
    def runStrategy(self, strategyCls, paramters):
        self._info.print("开始准备运行选股策略: {0}".format(strategyCls.chName), DyLogData.ind)
        self._info.initProgress()

        # init
        self._init()

        # create strategy instance
        self._strategy = strategyCls(paramters, self._info)

        # run
        if self._run():
            # ack
            event = DyEvent(DyEventType.stockSelectStrategySelectAck)
            event.data['class'] = strategyCls
            event.data['result'] = self._result
            event.data['baseDate'] = self._strategy.baseDate

            self._eventEngine.put(event)

            # finish
            self._eventEngine.put(DyEvent(DyEventType.finish))

            ret = True
        else:
            # fail
            self._eventEngine.put(DyEvent(DyEventType.fail))

            ret = False

        return ret

# 需要导入模块: from EventEngine import DyEvent [as 别名]
# 或者: from EventEngine.DyEvent import data['class'] [as 别名]
    def putStockMarketStrengthUpdateEvent(self, strategyCls, time, marketStrengthInfo):
        event = DyEvent(DyEventType.stockMarketStrengthUpdate)
        event.data['class'] = strategyCls
        event.data['time'] = time
        event.data['data'] = marketStrengthInfo

        self._eventEngine.put(event)

# 需要导入模块: from EventEngine import DyEvent [as 别名]
# 或者: from EventEngine.DyEvent import data['class'] [as 别名]
def dyStockSelectRegressionEngineProcess(outQueue, inQueue, tradeDays, strategy, codes, histDaysDataSource):
    strategyCls = strategy['class']
    parameters = strategy['param']

    DyStockCommon.defaultHistDaysDataSource = histDaysDataSource

    dummyEventEngine = DyDummyEventEngine()
    queueInfo = DyQueueInfo(outQueue)

    selectEngine = DyStockSelectSelectEngine(dummyEventEngine, queueInfo, False)
    selectEngine.setTestedStocks(codes)

    for day in tradeDays:
        try:
            event = inQueue.get_nowait()
        except queue.Empty:
            pass

        parameters['基准日期'] = day

        if selectEngine.runStrategy(strategyCls, parameters):
            event = DyEvent(DyEventType.stockSelectStrategyRegressionAck)
            event.data['class'] = strategyCls
            event.data['period'] = [tradeDays[0], tradeDays[-1]]
            event.data['day'] = day
            event.data['result'] = selectEngine.result

            outQueue.put(event)
        else:
            queueInfo.print('回归选股策略失败:{0}, 周期[{1}, {2}], 基准日期{3}'.format(strategyCls.chName, tradeDays[0], tradeDays[-1], day), DyLogData.error)

# 需要导入模块: from EventEngine import DyEvent [as 别名]
# 或者: from EventEngine.DyEvent import data['class'] [as 别名]
    def _stockMarketTicksHandler(self, event):
        if self._pushAction is None:
            return

        ticks = event.data

        strategyData = self._latestStrategyData.get('DyST_IndexMeanReversion')
        if strategyData is None:
            return

        strategyCls = strategyData[0]

        tick = ticks.get(strategyCls.targetCode)
        if tick is None:
            return

        # event
        event = DyEvent(DyEventType.stockStrategyManualBuy)
        event.data['class'] = strategyCls
        event.data['tick'] = tick
        event.data['volume'] = 100

        event.data['price'] = round(tick.preClose * 0.92, 3)

        self._eventEngine.put(event)

        self._info.print('通过WX委托买入{0}, {1}股, 价格{2}'.format(tick.name, event.data['volume'], event.data['price']), DyLogData.ind1)

        # sent to WX
        self._sendWx('委托买入{0}, {1}股, 价格{2}'.format(tick.name, event.data['volume'], event.data['price']))

        # clear
        self._pushAction = None
        self._eventEngine.unregister(DyEventType.stockMarketTicks, self._stockMarketTicksHandler, DyStockTradeEventHandType.wxEngine)

# 需要导入模块: from EventEngine import DyEvent [as 别名]
# 或者: from EventEngine.DyEvent import data['class'] [as 别名]
    def uncheckState(self, state, strategyCls, eventEngine):
        if not self.isState(state):
            return

        self.remove(state)

        if not self._state:
            event = DyEvent(DyEventType.stopStockCtaStrategy)

            event.data['class'] = strategyCls
        else:
            event = DyEvent(DyEventType.changeStockCtaStrategyState)

            event.data['class'] = strategyCls
            event.data['state'] = DyStockStrategyState(self._state)

        eventEngine.put(event)

# 需要导入模块: from EventEngine import DyEvent [as 别名]
# 或者: from EventEngine.DyEvent import data['class'] [as 别名]
    def checkState(self, state, strategyCls, eventEngine):
        if self.isState(state):
            return

        self.add(state)

        if self._state == state:
            event = DyEvent(DyEventType.startStockCtaStrategy)

            event.data['class'] = strategyCls
            event.data['state'] = DyStockStrategyState(self._state)
        else:
            event = DyEvent(DyEventType.changeStockCtaStrategyState)

            event.data['class'] = strategyCls
            event.data['state'] = DyStockStrategyState(*self._state.split('+'))

        eventEngine.put(event)

# 需要导入模块: from EventEngine import DyEvent [as 别名]
# 或者: from EventEngine.DyEvent import data['class'] [as 别名]
    def uncheckAll(self, strategyCls, eventEngine):
        if self._state is None:
            return

        self._state = None

        event = DyEvent(DyEventType.stopStockCtaStrategy)
        event.data['class'] = strategyCls

        eventEngine.put(event)

# 需要导入模块: from EventEngine import DyEvent [as 别名]
# 或者: from EventEngine.DyEvent import data['class'] [as 别名]
    def _stockSelect(self):
        strategyCls, param = self._widgetStrategy.getStrategy()
        if strategyCls is None: return

        # change UI
        self._startRunningMutexAction(self._stockSelectAction)

        event = DyEvent(DyEventType.stockSelectStrategySelectReq)
        event.data['class'] = strategyCls
        event.data['param'] = param

        self._mainEngine.eventEngine.put(event)

# 需要导入模块: from EventEngine import DyEvent [as 别名]
# 或者: from EventEngine.DyEvent import data['class'] [as 别名]
    def _endStockTradeDayHandler(self, event):
        if not self._strategyMirror and self._strategies:
            self._info.print('股票CTA引擎: 结束交易日[{}]'.format(self._curDate), DyLogData.ind2)

            # save strategies and stop strategy running
            for strategy, _ in self._strategies.values():
                # save
                self._strategyMirror[strategy.__class__] = strategy.state

                # stop
                event = DyEvent(DyEventType.stopStockCtaStrategy)
                event.data['class'] = strategy.__class__
                event.data['oneKeyHangUp'] = True

                self._stopStockCtaStrategyHandler(event)

# 需要导入模块: from EventEngine import DyEvent [as 别名]
# 或者: from EventEngine.DyEvent import data['class'] [as 别名]
    def _beginStockTradeDayHandler(self, event):
        if self._strategyMirror and not self._strategies:
            # init
            self._curInit()

            self._info.print('股票CTA引擎: 开始交易日[{}]'.format(self._curDate), DyLogData.ind2)

            # start strategies
            for strategyCls, state in self._strategyMirror.items():
                event = DyEvent(DyEventType.startStockCtaStrategy)
                event.data['class'] = strategyCls
                event.data['state'] = state

                self._startStockCtaStrategyHandler(event)

            self._strategyMirror = {}

# 需要导入模块: from EventEngine import DyEvent [as 别名]
# 或者: from EventEngine.DyEvent import data['class'] [as 别名]
    def _stockRegression(self):
        strategyCls, param = self._widgetStrategy.getStrategy()
        if strategyCls is None: return

        data = {}
        if not DyDateDlg(data).exec_():
            return

        # change UI
        self._startRunningMutexAction(self._stockRegressionAction)

        event = DyEvent(DyEventType.stockSelectStrategyRegressionReq)
        event.data['class'] = strategyCls
        event.data['param'] = param
        event.data['startDate'] = data['startDate']
        event.data['endDate'] = data['endDate']

        self._mainEngine.eventEngine.put(event)

# 需要导入模块: from EventEngine import DyEvent [as 别名]
# 或者: from EventEngine.DyEvent import data['class'] [as 别名]
    def putStockMarketMonitorUiEvent(self, strategyCls, data=None, newData=False, op=None, signalDetails=None, datetime_=None):
        """
            触发策略行情监控事件(通常用于通知GUI更新)
            @strategyCls: strategy class
            @data: 策略显示数据, [[]]
            @newData: True-策略显示数据是全新的数据，False-只是更新策略显示数据
            @op: 策略操作数据, [[]]。
                 若策略是运行状态（实盘状态）并且绑定券商账户，则op是实盘操作。若策略是监控状态或者没有绑定券商账户，则op就是非实盘操作。
                 其实非实盘时，可以不向UI推送操作，这么做只是为了非真正实盘时，能看到策略的操作明细。
                 信号明细和操作明细是不同的，有信号未必就会有操作，因为实盘时的操作牵涉到风控和资金管理。
            @signalDetails: 策略信号明细数据, [[]]
            @datetime_: 行情数据时有效
        """
        event = DyEvent(DyEventType.stockMarketMonitorUi + strategyCls.name)

        # data
        if data:
            event.data['data'] = {'data': data,
                                  'new': newData,
                                  'datetime': datetime_
                                  }

        # indication
        ind = {}
        if op:
            ind['op'] = op

        if signalDetails:
            ind['signalDetails'] = signalDetails

        if ind:
            event.data['ind'] = ind

        # put event
        if event.data:
            event.data['class'] = strategyCls
            self._eventEngine.put(event)