Esempio n. 1
0
    def stochrsi(self, interval, stochrsi_perc, is_sell=False):
        # Получаем данные с биржи
        klines = bot.klines(symbol=self.pair, interval=interval, limit=300)

        close = pd.Series([float(item[4]) for item in klines])
        stochrsi_K, stochrsi_D = self.stochrsi_indicator(close)

        perc = stochrsi_D.iloc[-1] * 100
        activity_time = False

        if is_sell:
            if stochrsi_D.iloc[-1] >= stochrsi_K.iloc[
                    -1] and perc >= stochrsi_perc:
                activity_time = True
        else:
            if stochrsi_D.iloc[-1] >= stochrsi_K.iloc[
                    -1] and perc <= stochrsi_perc:
                activity_time = True

        return activity_time
Esempio n. 2
0
    def macd(self,
             interval,
             fastperiod=12,
             slowperiod=26,
             signalperiod=9,
             bull_perc=30,
             bear_perc=70):
        # Получаем данные с биржи
        klines = bot.klines(symbol=self.pair, interval=interval, limit=300)

        close = np.asarray([float(item[4]) for item in klines])
        macd, macdsignal, macdhist = tb.MACD(close, fastperiod, slowperiod,
                                             signalperiod)

        idx = np.argwhere(
            np.diff(np.sign(macd - macdsignal)) != 0).reshape(-1) + 0

        max_v = 0

        for offset, elem in enumerate(macdhist):
            activity_time = False
            curr_v = macd[offset] - macdsignal[offset]
            if abs(curr_v) > abs(max_v):
                max_v = curr_v
            perc = curr_v / max_v

            # восходящий тренд
            if ((macd[offset] > macdsignal[offset] and perc * 100 > bull_perc)
                    or (macd[offset] < macdsignal[offset] and perc * 100 <=
                        (100 - bear_perc))):
                activity_time = True

            if offset in idx and not np.isnan(elem):
                # тренд изменился
                max_v = curr_v = 0  # обнуляем пик спреда между линиями

        return activity_time
    def scalping(self):
        log.info('Ожидаем благоприятную ситуацию для продажи\n')
        indicators = Indicators(self.pair_name)
        ready_to_check = False
        log.info('Ожидаем бычьего тренда и перекупленности более 55%...')
        while True:
            macd_condition = indicators.macd(
                self.pair_obj['interval'], self.pair_obj['macd_fast_period'],
                self.pair_obj['macd_slow_period'],
                self.pair_obj['macd_signal_period'], 0, 100)

            stochrsi_condition = indicators.stochrsi(self.pair_obj['interval'],
                                                     55, True)

            if macd_condition and stochrsi_condition:
                ready_to_check = True

            klines = bot.klines(symbol=self.pair_name,
                                interval=self.pair_obj['interval'],
                                limit=2)

            last_kline = klines[-1]
            second_kline = klines[-2]

            max_condition = float(last_kline[2]) > float(second_kline[2])

            condition_messages = []
            if macd_condition:
                condition_messages.append('Рынок БЫЧИЙ. Условие соблюдено')
            else:
                condition_messages.append(
                    'Рынок МЕДВЕЖИЙ. Условие не соблюдено')
            if stochrsi_condition:
                condition_messages.append(
                    'Рынок перекуплен БОЛЕЕ чем на 55%. Условие соблюдено')
            else:
                condition_messages.append(
                    'Рынок перекуплен МЕНЕЕ чем на 55%. Условие не соблюдено')
            if max_condition:
                condition_messages.append(
                    'high price текущей свечи ВЫШЕ, чем high price предыдущей. Условие соблюдено'
                )
            else:
                condition_messages.append(
                    'high price текущей свечи НИЖЕ, чем high price предыдущей. Условие не соблюдено'
                )

            if not ready_to_check:
                continue
            elif macd_condition and stochrsi_condition and max_condition:
                log.info(
                    'Все условия соблюдены. Ожидаем ещё более благоприятной ситуации\n'
                )
                continue
            else:
                kline_delay = int(last_kline[0] +
                                  (last_kline[6] - last_kline[0]) *
                                  0.5) // 1000
                current_time = int(time.time())
                time_condition = current_time > kline_delay

                if time_condition:
                    curr_rate = float(
                        bot.tickerPrice(symbol=self.pair_name)['price'])
                    if curr_rate > self.cut_price:
                        log.info(
                            'На рынке благоприятная ситуация. Готовимся к созданию ордера'
                        )
                        need_price = curr_rate - curr_rate * 0.00005
                        return need_price, curr_rate
                    else:
                        log.info(
                            'Ситуация на рынке меняется в худшую сторону. Создаём ордер по минимальному профиту'
                        )
                        need_price = self.cut_price
                        return need_price, curr_rate
                else:
                    log.info(
                        'Пара {0}\n    {1}\n    {2}\n    {3}\nОжидаем окончания свечи...\n'
                        .format(self.pair_name, condition_messages[0],
                                condition_messages[1], condition_messages[2]))
                    continue
    def scalping(self):
        log.info('Ожидаем благоприятную ситуацию для закупки\n')
        while True:
            klines = bot.klines(symbol=self.pair_name,
                                interval=self.pair_obj['interval'],
                                limit=1000)

            last_kline = klines[-1]
            current_low_price = float(last_kline[3])
            current_high_price = float(last_kline[2])

            if self.pair_obj['scalp_min'] == 0:
                min_condition = True
            else:
                lowest_price = min([float(kline[3]) for kline in klines
                                    ][-self.pair_obj['scalp_min']:-1])
                min_condition = current_low_price <= lowest_price

            if self.pair_obj['scalp_red'] == 0:
                red_condition = True
            else:
                red_klines = [
                    float(kline[4]) < float(kline[1])
                    for kline in klines[-self.pair_obj['scalp_red']:]
                ]
                red_condition = False not in red_klines

            kline_part_time = int(last_kline[0] +
                                  (last_kline[6] - last_kline[0]) *
                                  self.pair_obj['scalp_delay']) // 1000
            current_time = int(time.time())
            time_condition = current_time > kline_part_time

            macd_condition = self.indicators.macd(
                self.pair_obj['interval'], self.pair_obj['macd_fast_period'],
                self.pair_obj['macd_slow_period'],
                self.pair_obj['macd_signal_period'], MACD_BULL_PERC,
                MACD_BEAR_PERC)

            stochrsi_condition = self.indicators.stochrsi(
                self.pair_obj['interval'], STOCHRSI_PERC)

            condition_messages = []
            if min_condition:
                condition_messages.append('Условие scalp_min соблюдено')
            else:
                condition_messages.append('Условие scalp_min не соблюдено')
            if red_condition:
                condition_messages.append('Условие scalp_red соблюдено')
            else:
                condition_messages.append('Условие scalp_red не соблюдено')
            if time_condition:
                condition_messages.append('Условие scalp_delay соблюдено')
            else:
                condition_messages.append('Условие scalp_delay не соблюдено')
            if macd_condition:
                condition_messages.append('Условия индикатора MACD соблюдены')
            else:
                condition_messages.append(
                    'Условия индикатора MACD не соблюдены')
            if stochrsi_condition:
                condition_messages.append(
                    'Условия индикатора Stochastic RSI соблюдены')
            else:
                condition_messages.append(
                    'Условия индикатора Stochastic RSI не соблюдены')

            if min_condition and red_condition and time_condition and macd_condition and stochrsi_condition:
                log.info(
                    'На рынке благоприятная ситуация. Готовимся к созданию ордера'
                )
                min_price_with_markup = (
                    current_low_price +
                    (current_high_price - current_low_price) *
                    self.pair_obj['scalp_low_price_markup'])
                my_need_price = adjust_to_step(
                    min_price_with_markup,
                    self.curr_limits['filters'][0]['tickSize'])
                return my_need_price
            else:
                log.info(
                    'Пара {0}\n    {1}\n    {2}\n    {3}\n    {4}\n    {5}\n'.
                    format(self.pair_name, condition_messages[0],
                           condition_messages[1], condition_messages[2],
                           condition_messages[3], condition_messages[4]))
                continue
    def dynamic_klines(self):
        log.info('Ожидаем благоприятную ситуацию для закупки\n')
        while True:
            curr_price = float(bot.tickerPrice(symbol=self.pair_name)['price'])
            klines = bot.klines(symbol=self.pair_name,
                                interval=self.pair_obj['interval'],
                                limit=1000)

            last_kline = klines[-1]
            second_kline = klines[-2]
            third_kline = klines[-3]
            curr_low_price = float(last_kline[3])
            curr_high_price = float(last_kline[2])

            delay = int(last_kline[0] + (last_kline[6] - last_kline[0]) *
                        self.pair_obj['dk_delay']) // 1000
            curr_time = int(time.time())
            delay_condition = curr_time > delay

            turn_condition = (float(last_kline[3]) > float(
                second_kline[3])) and (float(second_kline[3]) < float(
                    third_kline[3]))
            main_stochrsi_condition = self.indicators.stochrsi(
                self.pair_obj['interval'], STOCHRSI_PERC)
            extra_stochrsi_condition = self.indicators.stochrsi(
                self.pair_obj['dk_extra_interval'], STOCHRSI_PERC)

            macd_condition = self.indicators.macd(
                self.pair_obj['interval'], self.pair_obj['macd_fast_period'],
                self.pair_obj['macd_slow_period'],
                self.pair_obj['macd_signal_period'], MACD_BULL_PERC,
                MACD_BEAR_PERC)

            open_less_curr_condition = curr_price < float(second_kline[1])

            condition_messages = []
            if turn_condition:
                condition_messages.append('Условие разворота рынка соблюдено')
            else:
                condition_messages.append(
                    'Условие разворота рынка не соблюдено')
            if open_less_curr_condition:
                condition_messages.append(
                    'Условие current_prcie < second_open_price соблюдено')
            else:
                condition_messages.append(
                    'Условие current_prcie < second_open_price не соблюдено')
            if delay_condition:
                condition_messages.append('Условие dk_delay соблюдено')
            else:
                condition_messages.append('Условие dk_delay не соблюдено')
            if macd_condition:
                condition_messages.append('Условия индикатора MACD соблюдены')
            else:
                condition_messages.append(
                    'Условия индикатора MACD не соблюдены')
            if main_stochrsi_condition:
                condition_messages.append(
                    'Условия индикатора Stochastic RSI на {}-интервале соблюдены'
                    .format(self.pair_obj['interval']))
            else:
                condition_messages.append(
                    'Условия индикатора Stochastic RSI на {}-интервале не соблюдены'
                    .format(self.pair_obj['interval']))
            if extra_stochrsi_condition:
                condition_messages.append(
                    'Условия индикатора Stochastic RSI на {}-интервале соблюдены'
                    .format(self.pair_obj['dk_extra_interval']))
            else:
                condition_messages.append(
                    'Условия индикатора Stochastic RSI на {}-интервале не соблюдены'
                    .format(self.pair_obj['dk_extra_interval']))

            if turn_condition and open_less_curr_condition and delay_condition and macd_condition and main_stochrsi_condition and extra_stochrsi_condition:
                log.info(
                    'На рынке благоприятная ситуация. Готовимся к созданию ордера'
                )
                min_price_with_markup = (curr_low_price +
                                         (curr_high_price - curr_low_price) *
                                         self.pair_obj['dk_low_price_markup'])
                my_need_price = adjust_to_step(
                    min_price_with_markup,
                    self.curr_limits['filters'][0]['tickSize'])
                return my_need_price
            else:
                log.info(
                    'Пара {0}\n    {1}\n    {2}\n    {3}\n    {4}\n    {5}\n    {6}\n'
                    .format(self.pair_name, condition_messages[0],
                            condition_messages[1], condition_messages[2],
                            condition_messages[3], condition_messages[4],
                            condition_messages[5]))