rpc: remove tuple return madness

freqtrade/rpc/rpc.py

@@ -5,7 +5,7 @@ import logging
 from abc import abstractmethod
 from datetime import datetime, timedelta, date
 from decimal import Decimal
-from typing import Dict, Tuple, Any
+from typing import Dict, Tuple, Any, List
 
 import arrow
 import sqlalchemy as sql
@@ -20,6 +20,10 @@ from freqtrade.state import State
 logger = logging.getLogger(__name__)
 
 
+class RPCException(Exception):
+    pass
+
+
 class RPC(object):
     """
     RPC class can be used to have extra feature, like bot data, and access to DB data
@@ -33,30 +37,29 @@ class RPC(object):
         self.freqtrade = freqtrade
 
     @abstractmethod
-    def cleanup(self) -> str:
+    def cleanup(self) -> None:
         """ Cleanup pending module resources """
 
     @property
     @abstractmethod
-    def name(self) -> None:
+    def name(self) -> str:
         """ Returns the lowercase name of this module """
 
     @abstractmethod
     def send_msg(self, msg: str) -> None:
         """ Sends a message to all registered rpc modules """
 
-    def rpc_trade_status(self) -> Tuple[bool, Any]:
+    def _rpc_trade_status(self) -> List[str]:
         """
         Below follows the RPC backend it is prefixed with rpc_ to raise awareness that it is
         a remotely exposed function
-        :return:
         """
         # Fetch open trade
         trades = Trade.query.filter(Trade.is_open.is_(True)).all()
         if self.freqtrade.state != State.RUNNING:
-            return True, '*Status:* `trader is not running`'
+            raise RPCException('*Status:* `trader is not running`')
         elif not trades:
-            return True, '*Status:* `no active trade`'
+            raise RPCException('*Status:* `no active trade`')
         else:
             result = []
             for trade in trades:
@@ -95,14 +98,14 @@ class RPC(object):
                               ) if order else None,
                           )
                 result.append(message)
-            return False, result
+            return result
 
-    def rpc_status_table(self) -> Tuple[bool, Any]:
+    def _rpc_status_table(self) -> DataFrame:
         trades = Trade.query.filter(Trade.is_open.is_(True)).all()
         if self.freqtrade.state != State.RUNNING:
-            return True, '*Status:* `trader is not running`'
+            raise RPCException('*Status:* `trader is not running`')
         elif not trades:
-            return True, '*Status:* `no active order`'
+            raise RPCException('*Status:* `no active order`')
         else:
             trades_list = []
             for trade in trades:
@@ -118,20 +121,16 @@ class RPC(object):
             columns = ['ID', 'Pair', 'Since', 'Profit']
             df_statuses = DataFrame.from_records(trades_list, columns=columns)
             df_statuses = df_statuses.set_index(columns[0])
-            # The style used throughout is to return a tuple
-            # consisting of (error_occured?, result)
-            # Another approach would be to just return the
-            # result, or raise error
-            return False, df_statuses
+            return df_statuses
 
-    def rpc_daily_profit(
+    def _rpc_daily_profit(
             self, timescale: int,
-            stake_currency: str, fiat_display_currency: str) -> Tuple[bool, Any]:
+            stake_currency: str, fiat_display_currency: str) -> List[List[Any]]:
         today = datetime.utcnow().date()
         profit_days: Dict[date, Dict] = {}
 
         if not (isinstance(timescale, int) and timescale > 0):
-            return True, '*Daily [n]:* `must be an integer greater than 0`'
+            raise RPCException('*Daily [n]:* `must be an integer greater than 0`')
 
         fiat = self.freqtrade.fiat_converter
         for day in range(0, timescale):
@@ -148,7 +147,7 @@ class RPC(object):
                 'trades': len(trades)
             }
 
-        stats = [
+        return [
             [
                 key,
                 '{value:.8f} {symbol}'.format(
@@ -170,13 +169,10 @@ class RPC(object):
             ]
             for key, value in profit_days.items()
         ]
-        return False, stats
 
-    def rpc_trade_statistics(
-            self, stake_currency: str, fiat_display_currency: str) -> Tuple[bool, Any]:
-        """
-        :return: cumulative profit statistics.
-        """
+    def _rpc_trade_statistics(
+            self, stake_currency: str, fiat_display_currency: str) -> Dict[str, Any]:
+        """ Returns cumulative profit statistics """
         trades = Trade.query.order_by(Trade.id).all()
 
         profit_all_coin = []
@@ -214,7 +210,7 @@ class RPC(object):
             .order_by(sql.text('profit_sum DESC')).first()
 
         if not best_pair:
-            return True, '*Status:* `no closed trade`'
+            raise RPCException('*Status:* `no closed trade`')
 
         bp_pair, bp_rate = best_pair
 
@@ -237,35 +233,29 @@ class RPC(object):
             fiat_display_currency
         )
         num = float(len(durations) or 1)
-        return (
-            False,
-            {
-                'profit_closed_coin': profit_closed_coin,
-                'profit_closed_percent': profit_closed_percent,
-                'profit_closed_fiat': profit_closed_fiat,
-                'profit_all_coin': profit_all_coin,
-                'profit_all_percent': profit_all_percent,
-                'profit_all_fiat': profit_all_fiat,
-                'trade_count': len(trades),
-                'first_trade_date': arrow.get(trades[0].open_date).humanize(),
-                'latest_trade_date': arrow.get(trades[-1].open_date).humanize(),
-                'avg_duration': str(timedelta(seconds=sum(durations) / num)).split('.')[0],
-                'best_pair': bp_pair,
-                'best_rate': round(bp_rate * 100, 2)
-            }
-        )
+        return {
+            'profit_closed_coin': profit_closed_coin,
+            'profit_closed_percent': profit_closed_percent,
+            'profit_closed_fiat': profit_closed_fiat,
+            'profit_all_coin': profit_all_coin,
+            'profit_all_percent': profit_all_percent,
+            'profit_all_fiat': profit_all_fiat,
+            'trade_count': len(trades),
+            'first_trade_date': arrow.get(trades[0].open_date).humanize(),
+            'latest_trade_date': arrow.get(trades[-1].open_date).humanize(),
+            'avg_duration': str(timedelta(seconds=sum(durations) / num)).split('.')[0],
+            'best_pair': bp_pair,
+            'best_rate': round(bp_rate * 100, 2),
+        }
 
-    def rpc_balance(self, fiat_display_currency: str) -> Tuple[bool, Any]:
-        """
-        :return: current account balance per crypto
-        """
+    def _rpc_balance(self, fiat_display_currency: str) -> Tuple[List[Dict], float, str, float]:
+        """ Returns current account balance per crypto """
         output = []
         total = 0.0
         for coin, balance in exchange.get_balances().items():
             if not balance['total']:
                 continue
 
-            rate = None
             if coin == 'BTC':
                 rate = 1.0
             else:
@@ -285,32 +275,28 @@ class RPC(object):
                 }
             )
         if total == 0.0:
-            return True, '`All balances are zero.`'
+            raise RPCException('`All balances are zero.`')
 
         fiat = self.freqtrade.fiat_converter
         symbol = fiat_display_currency
         value = fiat.convert_amount(total, 'BTC', symbol)
-        return False, (output, total, symbol, value)
+        return output, total, symbol, value
 
-    def rpc_start(self) -> Tuple[bool, str]:
-        """
-        Handler for start.
-        """
+    def _rpc_start(self) -> str:
+        """ Handler for start """
         if self.freqtrade.state == State.RUNNING:
-            return True, '*Status:* `already running`'
+            return '*Status:* `already running`'
 
         self.freqtrade.state = State.RUNNING
-        return False, '`Starting trader ...`'
+        return '`Starting trader ...`'
 
-    def rpc_stop(self) -> Tuple[bool, str]:
-        """
-        Handler for stop.
-        """
+    def _rpc_stop(self) -> str:
+        """ Handler for stop """
         if self.freqtrade.state == State.RUNNING:
             self.freqtrade.state = State.STOPPED
-            return False, '`Stopping trader ...`'
+            return '`Stopping trader ...`'
 
-        return True, '*Status:* `already stopped`'
+        return '*Status:* `already stopped`'
 
     def rpc_reload_conf(self) -> str:
         """ Handler for reload_conf. """
@@ -318,11 +304,10 @@ class RPC(object):
         return '*Status:* `Reloading config ...`'
 
     # FIX: no test for this!!!!
-    def rpc_forcesell(self, trade_id) -> Tuple[bool, Any]:
+    def _rpc_forcesell(self, trade_id) -> None:
         """
         Handler for forcesell <id>.
         Sells the given trade at current price
-        :return: error or None
         """
         def _exec_forcesell(trade: Trade) -> None:
             # Check if there is there is an open order
@@ -352,13 +337,13 @@ class RPC(object):
         # ---- EOF def _exec_forcesell ----
 
         if self.freqtrade.state != State.RUNNING:
-            return True, '`trader is not running`'
+            raise RPCException('`trader is not running`')
 
         if trade_id == 'all':
             # Execute sell for all open orders
             for trade in Trade.query.filter(Trade.is_open.is_(True)).all():
                 _exec_forcesell(trade)
-            return False, ''
+            return
 
         # Query for trade
         trade = Trade.query.filter(
@@ -369,19 +354,18 @@ class RPC(object):
         ).first()
         if not trade:
             logger.warning('forcesell: Invalid argument received')
-            return True, 'Invalid argument.'
+            raise RPCException('Invalid argument.')
 
         _exec_forcesell(trade)
         Trade.session.flush()
-        return False, ''
 
-    def rpc_performance(self) -> Tuple[bool, Any]:
+    def _rpc_performance(self) -> List[Dict]:
         """
         Handler for performance.
         Shows a performance statistic from finished trades
         """
         if self.freqtrade.state != State.RUNNING:
-            return True, '`trader is not running`'
+            raise RPCException('`trader is not running`')
 
         pair_rates = Trade.session.query(Trade.pair,
                                          sql.func.sum(Trade.close_profit).label('profit_sum'),
@@ -390,19 +374,14 @@ class RPC(object):
             .group_by(Trade.pair) \
             .order_by(sql.text('profit_sum DESC')) \
             .all()
-        trades = []
-        for (pair, rate, count) in pair_rates:
-            trades.append({'pair': pair, 'profit': round(rate * 100, 2), 'count': count})
+        return [
+            {'pair': pair, 'profit': round(rate * 100, 2), 'count': count}
+            for pair, rate, count in pair_rates
+        ]
 
-        return False, trades
-
-    def rpc_count(self) -> Tuple[bool, Any]:
-        """
-        Returns the number of trades running
-        :return: None
-        """
+    def _rpc_count(self) -> List[Trade]:
+        """ Returns the number of trades running """
         if self.freqtrade.state != State.RUNNING:
-            return True, '`trader is not running`'
+            raise RPCException('`trader is not running`')
 
-        trades = Trade.query.filter(Trade.is_open.is_(True)).all()
-        return False, trades
+        return Trade.query.filter(Trade.is_open.is_(True)).all()

freqtrade/rpc/telegram.py

@@ -12,7 +12,7 @@ from telegram.error import NetworkError, TelegramError
 from telegram.ext import CommandHandler, Updater
 
 from freqtrade.__init__ import __version__
-from freqtrade.rpc.rpc import RPC
+from freqtrade.rpc.rpc import RPC, RPCException
 
 logger = logging.getLogger(__name__)
 
@@ -151,13 +151,11 @@ class Telegram(RPC):
             self._status_table(bot, update)
             return
 
-        # Fetch open trade
-        (error, trades) = self.rpc_trade_status()
-        if error:
-            self._send_msg(trades, bot=bot)
-        else:
-            for trademsg in trades:
-                self._send_msg(trademsg, bot=bot)
+        try:
+            for trade_msg in self._rpc_trade_status():
+                self._send_msg(trade_msg, bot=bot)
+        except RPCException as e:
+            self._send_msg(str(e), bot=bot)
 
     @authorized_only
     def _status_table(self, bot: Bot, update: Update) -> None:
@@ -168,15 +166,12 @@ class Telegram(RPC):
         :param update: message update
         :return: None
         """
-        # Fetch open trade
-        (err, df_statuses) = self.rpc_status_table()
-        if err:
-            self._send_msg(df_statuses, bot=bot)
-        else:
+        try:
+            df_statuses = self._rpc_status_table()
             message = tabulate(df_statuses, headers='keys', tablefmt='simple')
-            message = "<pre>{}</pre>".format(message)
-
-            self._send_msg(message, parse_mode=ParseMode.HTML)
+            self._send_msg("<pre>{}</pre>".format(message), parse_mode=ParseMode.HTML)
+        except RPCException as e:
+            self._send_msg(str(e), bot=bot)
 
     @authorized_only
     def _daily(self, bot: Bot, update: Update) -> None:
@@ -191,14 +186,12 @@ class Telegram(RPC):
             timescale = int(update.message.text.replace('/daily', '').strip())
         except (TypeError, ValueError):
             timescale = 7
-        (error, stats) = self.rpc_daily_profit(
-            timescale,
-            self._config['stake_currency'],
-            self._config['fiat_display_currency']
-        )
-        if error:
-            self._send_msg(stats, bot=bot)
-        else:
+        try:
+            stats = self._rpc_daily_profit(
+                timescale,
+                self._config['stake_currency'],
+                self._config['fiat_display_currency']
+            )
             stats = tabulate(stats,
                              headers=[
                                  'Day',
@@ -207,11 +200,10 @@ class Telegram(RPC):
                              ],
                              tablefmt='simple')
             message = '<b>Daily Profit over the last {} days</b>:\n<pre>{}</pre>'\
-                      .format(
-                          timescale,
-                          stats
-                      )
+                      .format(timescale, stats)
             self._send_msg(message, bot=bot, parse_mode=ParseMode.HTML)
+        except RPCException as e:
+            self._send_msg(str(e), bot=bot)
 
     @authorized_only
     def _profit(self, bot: Bot, update: Update) -> None:
@@ -222,67 +214,65 @@ class Telegram(RPC):
         :param update: message update
         :return: None
         """
-        (error, stats) = self.rpc_trade_statistics(
-            self._config['stake_currency'],
-            self._config['fiat_display_currency']
-        )
-        if error:
-            self._send_msg(stats, bot=bot)
-            return
+        try:
+            stats = self._rpc_trade_statistics(
+                self._config['stake_currency'],
+                self._config['fiat_display_currency'])
 
-        # Message to display
-        markdown_msg = "*ROI:* Close trades\n" \
-                       "∙ `{profit_closed_coin:.8f} {coin} ({profit_closed_percent:.2f}%)`\n" \
-                       "∙ `{profit_closed_fiat:.3f} {fiat}`\n" \
-                       "*ROI:* All trades\n" \
-                       "∙ `{profit_all_coin:.8f} {coin} ({profit_all_percent:.2f}%)`\n" \
-                       "∙ `{profit_all_fiat:.3f} {fiat}`\n" \
-                       "*Total Trade Count:* `{trade_count}`\n" \
-                       "*First Trade opened:* `{first_trade_date}`\n" \
-                       "*Latest Trade opened:* `{latest_trade_date}`\n" \
-                       "*Avg. Duration:* `{avg_duration}`\n" \
-                       "*Best Performing:* `{best_pair}: {best_rate:.2f}%`"\
-                       .format(
-                           coin=self._config['stake_currency'],
-                           fiat=self._config['fiat_display_currency'],
-                           profit_closed_coin=stats['profit_closed_coin'],
-                           profit_closed_percent=stats['profit_closed_percent'],
-                           profit_closed_fiat=stats['profit_closed_fiat'],
-                           profit_all_coin=stats['profit_all_coin'],
-                           profit_all_percent=stats['profit_all_percent'],
-                           profit_all_fiat=stats['profit_all_fiat'],
-                           trade_count=stats['trade_count'],
-                           first_trade_date=stats['first_trade_date'],
-                           latest_trade_date=stats['latest_trade_date'],
-                           avg_duration=stats['avg_duration'],
-                           best_pair=stats['best_pair'],
-                           best_rate=stats['best_rate']
-                       )
-        self._send_msg(markdown_msg, bot=bot)
+            # Message to display
+            markdown_msg = "*ROI:* Close trades\n" \
+                           "∙ `{profit_closed_coin:.8f} {coin} ({profit_closed_percent:.2f}%)`\n" \
+                           "∙ `{profit_closed_fiat:.3f} {fiat}`\n" \
+                           "*ROI:* All trades\n" \
+                           "∙ `{profit_all_coin:.8f} {coin} ({profit_all_percent:.2f}%)`\n" \
+                           "∙ `{profit_all_fiat:.3f} {fiat}`\n" \
+                           "*Total Trade Count:* `{trade_count}`\n" \
+                           "*First Trade opened:* `{first_trade_date}`\n" \
+                           "*Latest Trade opened:* `{latest_trade_date}`\n" \
+                           "*Avg. Duration:* `{avg_duration}`\n" \
+                           "*Best Performing:* `{best_pair}: {best_rate:.2f}%`"\
+                           .format(
+                               coin=self._config['stake_currency'],
+                               fiat=self._config['fiat_display_currency'],
+                               profit_closed_coin=stats['profit_closed_coin'],
+                               profit_closed_percent=stats['profit_closed_percent'],
+                               profit_closed_fiat=stats['profit_closed_fiat'],
+                               profit_all_coin=stats['profit_all_coin'],
+                               profit_all_percent=stats['profit_all_percent'],
+                               profit_all_fiat=stats['profit_all_fiat'],
+                               trade_count=stats['trade_count'],
+                               first_trade_date=stats['first_trade_date'],
+                               latest_trade_date=stats['latest_trade_date'],
+                               avg_duration=stats['avg_duration'],
+                               best_pair=stats['best_pair'],
+                               best_rate=stats['best_rate']
+                           )
+            self._send_msg(markdown_msg, bot=bot)
+        except RPCException as e:
+            self._send_msg(str(e), bot=bot)
 
     @authorized_only
     def _balance(self, bot: Bot, update: Update) -> None:
         """
         Handler for /balance
         """
-        (error, result) = self.rpc_balance(self._config['fiat_display_currency'])
-        if error:
-            self._send_msg('`All balances are zero.`')
-            return
+        try:
+            currencys, total, symbol, value = \
+                self._rpc_balance(self._config['fiat_display_currency'])
+            output = ''
+            for currency in currencys:
+                output += "*{currency}:*\n" \
+                          "\t`Available: {available: .8f}`\n" \
+                          "\t`Balance: {balance: .8f}`\n" \
+                          "\t`Pending: {pending: .8f}`\n" \
+                          "\t`Est. BTC: {est_btc: .8f}`\n".format(**currency)
 
-        (currencys, total, symbol, value) = result
-        output = ''
-        for currency in currencys:
-            output += "*{currency}:*\n" \
-                      "\t`Available: {available: .8f}`\n" \
-                      "\t`Balance: {balance: .8f}`\n" \
-                      "\t`Pending: {pending: .8f}`\n" \
-                      "\t`Est. BTC: {est_btc: .8f}`\n".format(**currency)
-
-        output += "\n*Estimated Value*:\n" \
-                  "\t`BTC: {0: .8f}`\n" \
-                  "\t`{1}: {2: .2f}`\n".format(total, symbol, value)
-        self._send_msg(output)
+            output += "\n*Estimated Value*:\n" \
+                      "\t`BTC: {0: .8f}`\n" \
+                      "\t`{1}: {2: .2f}`\n".format(total, symbol, value)
+            self._send_msg(output, bot=bot)
+        except RPCException as e:
+            self._send_msg(str(e), bot=bot)
 
     @authorized_only
     def _start(self, bot: Bot, update: Update) -> None:
@@ -293,9 +283,8 @@ class Telegram(RPC):
         :param update: message update
         :return: None
         """
-        (error, msg) = self.rpc_start()
-        if error:
-            self._send_msg(msg, bot=bot)
+        msg = self._rpc_start()
+        self._send_msg(msg, bot=bot)
 
     @authorized_only
     def _stop(self, bot: Bot, update: Update) -> None:
@@ -306,7 +295,7 @@ class Telegram(RPC):
         :param update: message update
         :return: None
         """
-        (error, msg) = self.rpc_stop()
+        msg = self._rpc_stop()
         self._send_msg(msg, bot=bot)
 
     @authorized_only
@@ -332,10 +321,10 @@ class Telegram(RPC):
         """
 
         trade_id = update.message.text.replace('/forcesell', '').strip()
-        (error, message) = self.rpc_forcesell(trade_id)
-        if error:
-            self._send_msg(message, bot=bot)
-            return
+        try:
+            self._rpc_forcesell(trade_id)
+        except RPCException as e:
+            self._send_msg(str(e), bot=bot)
 
     @authorized_only
     def _performance(self, bot: Bot, update: Update) -> None:
@@ -346,19 +335,18 @@ class Telegram(RPC):
         :param update: message update
         :return: None
         """
-        (error, trades) = self.rpc_performance()
-        if error:
-            self._send_msg(trades, bot=bot)
-            return
-
-        stats = '\n'.join('{index}.\t<code>{pair}\t{profit:.2f}% ({count})</code>'.format(
-            index=i + 1,
-            pair=trade['pair'],
-            profit=trade['profit'],
-            count=trade['count']
-        ) for i, trade in enumerate(trades))
-        message = '<b>Performance:</b>\n{}'.format(stats)
-        self._send_msg(message, parse_mode=ParseMode.HTML)
+        try:
+            trades = self._rpc_performance()
+            stats = '\n'.join('{index}.\t<code>{pair}\t{profit:.2f}% ({count})</code>'.format(
+                index=i + 1,
+                pair=trade['pair'],
+                profit=trade['profit'],
+                count=trade['count']
+            ) for i, trade in enumerate(trades))
+            message = '<b>Performance:</b>\n{}'.format(stats)
+            self._send_msg(message, parse_mode=ParseMode.HTML)
+        except RPCException as e:
+            self._send_msg(str(e), bot=bot)
 
     @authorized_only
     def _count(self, bot: Bot, update: Update) -> None:
@@ -369,19 +357,18 @@ class Telegram(RPC):
         :param update: message update
         :return: None
         """
-        (error, trades) = self.rpc_count()
-        if error:
-            self._send_msg(trades, bot=bot)
-            return
-
-        message = tabulate({
-            'current': [len(trades)],
-            'max': [self._config['max_open_trades']],
-            'total stake': [sum((trade.open_rate * trade.amount) for trade in trades)]
-        }, headers=['current', 'max', 'total stake'], tablefmt='simple')
-        message = "<pre>{}</pre>".format(message)
-        logger.debug(message)
-        self._send_msg(message, parse_mode=ParseMode.HTML)
+        try:
+            trades = self._rpc_count()
+            message = tabulate({
+                'current': [len(trades)],
+                'max': [self._config['max_open_trades']],
+                'total stake': [sum((trade.open_rate * trade.amount) for trade in trades)]
+            }, headers=['current', 'max', 'total stake'], tablefmt='simple')
+            message = "<pre>{}</pre>".format(message)
+            logger.debug(message)
+            self._send_msg(message, parse_mode=ParseMode.HTML)
+        except RPCException as e:
+            self._send_msg(str(e), bot=bot)
 
     @authorized_only
     def _help(self, bot: Bot, update: Update) -> None: