stable/rpc/telegram.py

import threading

import arrow
from datetime import timedelta

import logging
from telegram.ext import CommandHandler, Updater
from telegram import ParseMode

from persistence import Trade
from exchange import get_exchange_api
from utils import get_conf

logger = logging.getLogger(__name__)

_lock = threading.Condition()
_updater = None

conf = get_conf()
api_wrapper = get_exchange_api(conf)


class TelegramHandler(object):
    @staticmethod
    def get_updater(conf):
        """
        Returns the current telegram updater instantiates a new one
        :param conf:
        :return: telegram.ext.Updater
        """
        global _updater
        _lock.acquire()
        if not _updater:
            _updater = Updater(token=conf['telegram']['token'], workers=0)
        _lock.release()
        return _updater

    @staticmethod
    def listen():
        """
        Registers all known command handlers and starts polling for message updates
        :return: None
        """
        # Register command handler and start telegram message polling
        handles = [CommandHandler('status', TelegramHandler._status),
                   CommandHandler('profit', TelegramHandler._profit),
                   CommandHandler('start', TelegramHandler._start),
                   CommandHandler('stop', TelegramHandler._stop)]
        for handle in handles:
            TelegramHandler.get_updater(conf).dispatcher.add_handler(handle)
        TelegramHandler.get_updater(conf).start_polling(clean=True, bootstrap_retries=3)

    @staticmethod
    def _is_correct_scope(update):
        """
        Checks if it is save to process the given update
        :param update: 
        :return: True if valid else False
        """
        # Only answer to our chat
        return int(update.message.chat_id) == int(conf['telegram']['chat_id'])

    @staticmethod
    def send_msg(markdown_message, bot=None):
        """
        Send given markdown message
        :param markdown_message: message
        :param bot: alternative bot
        :return: None
        """
        if conf['telegram'].get('enabled', False):
            bot = bot or TelegramHandler.get_updater(conf).bot
            try:
                bot.send_message(
                    chat_id=conf['telegram']['chat_id'],
                    text=markdown_message,
                    parse_mode=ParseMode.MARKDOWN,
                )
            except Exception:
                logger.exception('Exception occurred within telegram api')

    @staticmethod
    def _status(bot, update):
        """
        Handler for /status
        :param bot: telegram bot
        :param update: message update
        :return: None
        """
        if not TelegramHandler._is_correct_scope(update):
            return

        # Fetch open trade
        trade = Trade.query.filter(Trade.is_open.is_(True)).first()

        from main import TradeThread
        if not TradeThread.get_instance().is_alive():
            message = '*Status:* `trader stopped`'
        elif not trade:
            message = '*Status:* `no active order`'
        else:
            # calculate profit and send message to user
            current_rate = api_wrapper.get_ticker(trade.pair)['last']
            current_profit = 100 * ((current_rate - trade.open_rate) / trade.open_rate)
            open_orders = api_wrapper.get_open_orders(trade.pair)
            order = open_orders[0] if open_orders else None
            message = """
*Current Pair:* [{pair}](https://bittrex.com/Market/Index?MarketName={pair})
*Open Since:* `{date}`
*Amount:* `{amount}`
*Open Rate:* `{open_rate}`
*Close Rate:* `{close_rate}`
*Current Rate:* `{current_rate}`
*Close Profit:* `{close_profit}`
*Current Profit:* `{current_profit}%`
*Open Order:* `{open_order}`
                    """.format(
                pair=trade.pair.replace('_', '-'),
                date=arrow.get(trade.open_date).humanize(),
                open_rate=trade.open_rate,
                close_rate=trade.close_rate,
                current_rate=current_rate,
                amount=round(trade.amount, 8),
                close_profit='{}%'.format(round(trade.close_profit, 2)) if trade.close_profit else None,
                current_profit=round(current_profit, 2),
                open_order='{} ({})'.format(
                    order['remaining'],
                    order['type']
                ) if order else None,
            )
        TelegramHandler.send_msg(message, bot=bot)

    @staticmethod
    def _profit(bot, update):
        """
        Handler for /profit
        :param bot: telegram bot
        :param update: message update
        :return: None
        """
        if not TelegramHandler._is_correct_scope(update):
            return
        trades = Trade.query.filter(Trade.is_open.is_(False)).all()
        trade_count = len(trades)
        profit_amount = sum((t.close_profit / 100) * t.btc_amount for t in trades)
        profit = sum(t.close_profit for t in trades)
        avg_stake_amount = sum(t.btc_amount for t in trades) / float(trade_count)
        durations_hours = [(t.close_date - t.open_date).total_seconds() / 3600.0 for t in trades]
        avg_duration = sum(durations_hours) / float(len(durations_hours))

        markdown_msg = """
*Total Balance:* `{total_amount} BTC`
*Total Profit:* `{profit_btc} BTC ({profit}%)`
*Trade Count:* `{trade_count}`
*First Action:* `{first_trade_date}`
*Latest Action:* `{latest_trade_date}`
*Avg. Stake Amount:* `{avg_open_amount} BTC`
*Avg. Duration:* `{avg_duration}` 
    """.format(
            total_amount=round(api_wrapper.get_balance('BTC'), 8),
            profit_btc=round(profit_amount, 8),
            profit=round(profit, 2),
            trade_count=trade_count,
            first_trade_date=arrow.get(trades[0].open_date).humanize(),
            latest_trade_date=arrow.get(trades[-1].open_date).humanize(),
            avg_open_amount=round(avg_stake_amount, 8),
            avg_duration=str(timedelta(hours=avg_duration)).split('.')[0],
        )
        TelegramHandler.send_msg(markdown_msg, bot=bot)

    @staticmethod
    def _start(bot, update):
        """
        Handler for /start
        :param bot: telegram bot
        :param update: message update
        :return: None
        """
        if not TelegramHandler._is_correct_scope(update):
            return
        from main import TradeThread
        if TradeThread.get_instance().is_alive():
            TelegramHandler.send_msg('*Status:* `already running`', bot=bot)
            return
        else:
            TradeThread.get_instance(recreate=True).start()

    @staticmethod
    def _stop(bot, update):
        """
        Handler for /stop
        :param bot: telegram bot
        :param update: message update
        :return: None
        """
        if not TelegramHandler._is_correct_scope(update):
            return
        from main import TradeThread
        if TradeThread.get_instance().is_alive():
            TradeThread.stop()
        else:
            TelegramHandler.send_msg('*Status:* `already stopped`', bot=bot)