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)