Merge branch 'develop' into pair-to-strat

freqtrade/__init__.py

@@ -1,5 +1,5 @@
 """ FreqTrade bot """
-__version__ = '0.17.0'
+__version__ = '0.17.1'
 
 
 class DependencyException(BaseException):

freqtrade/__main__.py

@@ -7,8 +7,8 @@ To launch Freqtrade as a module
 """
 
 import sys
-from freqtrade import main
 
+from freqtrade import main
 
 if __name__ == '__main__':
     main.set_loggers()

freqtrade/analyze.py

@@ -10,9 +10,9 @@ import arrow
 from pandas import DataFrame, to_datetime
 
 from freqtrade import constants
-from freqtrade.exchange import get_ticker_history
+from freqtrade.exchange import Exchange
 from freqtrade.persistence import Trade
-from freqtrade.strategy.resolver import StrategyResolver, IStrategy
+from freqtrade.strategy.resolver import IStrategy, StrategyResolver
 
 logger = logging.getLogger(__name__)
 
@@ -98,7 +98,14 @@ class Analyze(object):
         """
         return self.strategy.ticker_interval
 
-    def analyze_ticker(self, ticker_history: List[Dict], pair: str) -> DataFrame:
+    def get_stoploss(self) -> float:
+        """
+        Return stoploss to use
+        :return: Strategy stoploss value to use
+        """
+        return self.strategy.stoploss
+
+    def analyze_ticker(self, ticker_history: List[Dict]) -> DataFrame:
         """
         Parses the given ticker history and returns a populated DataFrame
         add several TA indicators and buy signal to it
@@ -111,14 +118,14 @@ class Analyze(object):
         dataframe = self.populate_sell_trend(dataframe, pair)
         return dataframe
 
-    def get_signal(self, pair: str, interval: str) -> Tuple[bool, bool]:
+    def get_signal(self, exchange: Exchange, pair: str, interval: str) -> Tuple[bool, bool]:
         """
         Calculates current signal based several technical analysis indicators
         :param pair: pair in format ANT/BTC
         :param interval: Interval to use (in min)
         :return: (Buy, Sell) A bool-tuple indicating buy/sell signal
         """
-        ticker_hist = get_ticker_history(pair, interval)
+        ticker_hist = exchange.get_ticker_history(pair, interval)
         if not ticker_hist:
             logger.warning('Empty ticker history for pair %s', pair)
             return False, False
@@ -149,7 +156,7 @@ class Analyze(object):
         # Check if dataframe is out of date
         signal_date = arrow.get(latest['date'])
         interval_minutes = constants.TICKER_INTERVAL_MINUTES[interval]
-        if signal_date < arrow.utcnow() - timedelta(minutes=(interval_minutes + 5)):
+        if signal_date < (arrow.utcnow() - timedelta(minutes=(interval_minutes + 5))):
             logger.warning(
                 'Outdated history for pair %s. Last tick is %s minutes old',
                 pair,
@@ -173,33 +180,79 @@ class Analyze(object):
         if the threshold is reached and updates the trade record.
         :return: True if trade should be sold, False otherwise
         """
+        current_profit = trade.calc_profit_percent(rate)
+        if self.stop_loss_reached(current_rate=rate, trade=trade, current_time=date):
+            return True
+
+        experimental = self.config.get('experimental', {})
+
+        if buy and experimental.get('ignore_roi_if_buy_signal', False):
+            logger.debug('Buy signal still active - not selling.')
+            return False
+
         # Check if minimal roi has been reached and no longer in buy conditions (avoiding a fee)
-        if self.min_roi_reached(trade=trade, current_rate=rate, current_time=date):
+        if self.min_roi_reached(trade=trade, current_profit=current_profit, current_time=date):
             logger.debug('Required profit reached. Selling..')
             return True
 
-        # Experimental: Check if the trade is profitable before selling it (avoid selling at loss)
-        if self.config.get('experimental', {}).get('sell_profit_only', False):
+        if experimental.get('sell_profit_only', False):
             logger.debug('Checking if trade is profitable..')
             if trade.calc_profit(rate=rate) <= 0:
                 return False
-
-        if sell and not buy and self.config.get('experimental', {}).get('use_sell_signal', False):
+        if sell and not buy and experimental.get('use_sell_signal', False):
             logger.debug('Sell signal received. Selling..')
             return True
 
         return False
 
-    def min_roi_reached(self, trade: Trade, current_rate: float, current_time: datetime) -> bool:
+    def stop_loss_reached(self, current_rate: float, trade: Trade, current_time: datetime) -> bool:
+        """
+        Based on current profit of the trade and configured (trailing) stoploss,
+        decides to sell or not
+        """
+
+        current_profit = trade.calc_profit_percent(current_rate)
+        trailing_stop = self.config.get('trailing_stop', False)
+
+        trade.adjust_stop_loss(trade.open_rate, self.strategy.stoploss, initial=True)
+
+        # evaluate if the stoploss was hit
+        if self.strategy.stoploss is not None and trade.stop_loss >= current_rate:
+
+            if trailing_stop:
+                logger.debug(
+                    f"HIT STOP: current price at {current_rate:.6f}, "
+                    f"stop loss is {trade.stop_loss:.6f}, "
+                    f"initial stop loss was at {trade.initial_stop_loss:.6f}, "
+                    f"trade opened at {trade.open_rate:.6f}")
+                logger.debug(f"trailing stop saved {trade.stop_loss - trade.initial_stop_loss:.6f}")
+
+            logger.debug('Stop loss hit.')
+            return True
+
+        # update the stop loss afterwards, after all by definition it's supposed to be hanging
+        if trailing_stop:
+
+            # check if we have a special stop loss for positive condition
+            # and if profit is positive
+            stop_loss_value = self.strategy.stoploss
+            if 'trailing_stop_positive' in self.config and current_profit > 0:
+
+                # Ignore mypy error check in configuration that this is a float
+                stop_loss_value = self.config.get('trailing_stop_positive')  # type: ignore
+                logger.debug(f"using positive stop loss mode: {stop_loss_value} "
+                             f"since we have profit {current_profit}")
+
+            trade.adjust_stop_loss(current_rate, stop_loss_value)
+
+        return False
+
+    def min_roi_reached(self, trade: Trade, current_profit: float, current_time: datetime) -> bool:
         """
         Based an earlier trade and current price and ROI configuration, decides whether bot should
         sell
         :return True if bot should sell at current rate
         """
-        current_profit = trade.calc_profit_percent(current_rate)
-        if self.strategy.stoploss is not None and current_profit < self.strategy.stoploss:
-            logger.debug('Stop loss hit.')
-            return True
 
         # Check if time matches and current rate is above threshold
         time_diff = (current_time.timestamp() - trade.open_date.timestamp()) / 60

freqtrade/arguments.py

@@ -2,12 +2,13 @@
 This module contains the argument manager class
 """
 
-import os
 import argparse
 import logging
+import os
 import re
+from typing import List, NamedTuple, Optional
+
 import arrow
-from typing import List, Optional, NamedTuple
 
 from freqtrade import __version__, constants
 
@@ -203,12 +204,6 @@ class Arguments(object):
             type=int,
             metavar='INT',
         )
-        parser.add_argument(
-            '--use-mongodb',
-            help='parallelize evaluations with mongodb (requires mongod in PATH)',
-            dest='mongodb',
-            action='store_true',
-        )
         parser.add_argument(
             '-s', '--spaces',
             help='Specify which parameters to hyperopt. Space separate list. \
@@ -268,17 +263,15 @@ class Arguments(object):
                 stop: int = 0
                 if stype[0]:
                     starts = rvals[index]
-                    if stype[0] == 'date':
-                        start = int(starts) if len(starts) == 10 \
-                            else arrow.get(starts, 'YYYYMMDD').timestamp
+                    if stype[0] == 'date' and len(starts) == 8:
+                        start = arrow.get(starts, 'YYYYMMDD').timestamp
                     else:
                         start = int(starts)
                     index += 1
                 if stype[1]:
                     stops = rvals[index]
-                    if stype[1] == 'date':
-                        stop = int(stops) if len(stops) == 10 \
-                            else arrow.get(stops, 'YYYYMMDD').timestamp
+                    if stype[1] == 'date' and len(stops) == 8:
+                        stop = arrow.get(stops, 'YYYYMMDD').timestamp
                     else:
                         stop = int(stops)
                 return TimeRange(stype[0], stype[1], start, stop)
@@ -342,3 +335,10 @@ class Arguments(object):
             nargs='+',
             dest='timeframes',
         )
+
+        self.parser.add_argument(
+            '--erase',
+            help='Clean all existing data for the selected exchange/pairs/timeframes',
+            dest='erase',
+            action='store_true'
+        )

freqtrade/configuration.py

@@ -1,18 +1,18 @@
 """
 This module contains the configuration class
 """
-import os
 import json
 import logging
+import os
 from argparse import Namespace
-from typing import Optional, Dict, Any
+from typing import Any, Dict, Optional
+
+import ccxt
 from jsonschema import Draft4Validator, validate
 from jsonschema.exceptions import ValidationError, best_match
-import ccxt
 
 from freqtrade import OperationalException, constants
 
-
 logger = logging.getLogger(__name__)
 
 
@@ -62,8 +62,8 @@ class Configuration(object):
                 conf = json.load(file)
         except FileNotFoundError:
             raise OperationalException(
-                'Config file "{}" not found!'
-                ' Please create a config file or check whether it exists.'.format(path))
+                f'Config file "{path}" not found!'
+                ' Please create a config file or check whether it exists.')
 
         if 'internals' not in conf:
             conf['internals'] = {}
@@ -109,7 +109,7 @@ class Configuration(object):
                 config['db_url'] = constants.DEFAULT_DB_PROD_URL
             logger.info('Dry run is disabled')
 
-        logger.info('Using DB: "{}"'.format(config['db_url']))
+        logger.info(f'Using DB: "{config["db_url"]}"')
 
         # Check if the exchange set by the user is supported
         self.check_exchange(config)
@@ -188,11 +188,6 @@ class Configuration(object):
             logger.info('Parameter --epochs detected ...')
             logger.info('Will run Hyperopt with for %s epochs ...', config.get('epochs'))
 
-        # If --mongodb is used we add it to the configuration
-        if 'mongodb' in self.args and self.args.mongodb:
-            config.update({'mongodb': self.args.mongodb})
-            logger.info('Parameter --use-mongodb detected ...')
-
         # If --spaces is used we add it to the configuration
         if 'spaces' in self.args and self.args.spaces:
             config.update({'spaces': self.args.spaces})

freqtrade/constants.py

@@ -11,6 +11,8 @@ RETRY_TIMEOUT = 30  # sec
 DEFAULT_STRATEGY = 'DefaultStrategy'
 DEFAULT_DB_PROD_URL = 'sqlite:///tradesv3.sqlite'
 DEFAULT_DB_DRYRUN_URL = 'sqlite://'
+UNLIMITED_STAKE_AMOUNT = 'unlimited'
+
 
 TICKER_INTERVAL_MINUTES = {
     '1m': 1,
@@ -44,7 +46,11 @@ CONF_SCHEMA = {
         'max_open_trades': {'type': 'integer', 'minimum': 0},
         'ticker_interval': {'type': 'string', 'enum': list(TICKER_INTERVAL_MINUTES.keys())},
         'stake_currency': {'type': 'string', 'enum': ['BTC', 'ETH', 'USDT', 'EUR', 'USD']},
-        'stake_amount': {'type': 'number', 'minimum': 0.0005},
+        'stake_amount': {
+            "type": ["number", "string"],
+            "minimum": 0.0005,
+            "pattern": UNLIMITED_STAKE_AMOUNT
+        },
         'fiat_display_currency': {'type': 'string', 'enum': SUPPORTED_FIAT},
         'dry_run': {'type': 'boolean'},
         'minimal_roi': {
@@ -55,7 +61,15 @@ CONF_SCHEMA = {
             'minProperties': 1
         },
         'stoploss': {'type': 'number', 'maximum': 0, 'exclusiveMaximum': True},
-        'unfilledtimeout': {'type': 'integer', 'minimum': 0},
+        'trailing_stop': {'type': 'boolean'},
+        'trailing_stop_positive': {'type': 'number', 'minimum': 0, 'maximum': 1},
+        'unfilledtimeout': {
+            'type': 'object',
+            'properties': {
+                'buy': {'type': 'number', 'minimum': 3},
+                'sell': {'type': 'number', 'minimum': 10}
+            }
+        },
         'bid_strategy': {
             'type': 'object',
             'properties': {
@@ -73,7 +87,8 @@ CONF_SCHEMA = {
             'type': 'object',
             'properties': {
                 'use_sell_signal': {'type': 'boolean'},
-                'sell_profit_only': {'type': 'boolean'}
+                'sell_profit_only': {'type': 'boolean'},
+                "ignore_roi_if_buy_signal_true": {'type': 'boolean'}
             }
         },
         'telegram': {

freqtrade/exchange/__init__.py

@@ -12,16 +12,8 @@ from freqtrade import constants, OperationalException, DependencyException, Temp
 
 logger = logging.getLogger(__name__)
 
-# Current selected exchange
-_API: ccxt.Exchange = None
-
-_CONF: Dict = {}
 API_RETRY_COUNT = 4
 
-_CACHED_TICKER: Dict[str, Any] = {}
-
-# Holds all open sell orders for dry_run
-_DRY_RUN_OPEN_ORDERS: Dict[str, Any] = {}
 
 # Urls to exchange markets, insert quote and base with .format()
 _EXCHANGE_URLS = {
@@ -48,390 +40,378 @@ def retrier(f):
     return wrapper
 
 
-def init_ccxt(exchange_config: dict) -> ccxt.Exchange:
-    """
-    Initialize ccxt with given config and return valid
-    ccxt instance.
-    :param config: config to use
-    :return: ccxt
-    """
-    # Find matching class for the given exchange name
-    name = exchange_config['name']
+class Exchange(object):
 
-    if name not in ccxt.exchanges:
-        raise OperationalException(f'Exchange {name} is not supported')
-    try:
-        api = getattr(ccxt, name.lower())({
-            'apiKey': exchange_config.get('key'),
-            'secret': exchange_config.get('secret'),
-            'password': exchange_config.get('password'),
-            'uid': exchange_config.get('uid', ''),
-            'enableRateLimit': True,
-        })
-    except (KeyError, AttributeError):
-        raise OperationalException(f'Exchange {name} is not supported')
+    # Current selected exchange
+    _api: ccxt.Exchange = None
+    _conf: Dict = {}
+    _cached_ticker: Dict[str, Any] = {}
 
-    return api
+    # Holds all open sell orders for dry_run
+    _dry_run_open_orders: Dict[str, Any] = {}
 
+    def __init__(self, config: dict) -> None:
+        """
+        Initializes this module with the given config,
+        it does basic validation whether the specified
+        exchange and pairs are valid.
+        :return: None
+        """
+        self._conf.update(config)
 
-def init(config: dict) -> None:
-    """
-    Initializes this module with the given config,
-    it does basic validation whether the specified
-    exchange and pairs are valid.
-    :param config: config to use
-    :return: None
-    """
-    global _CONF, _API
+        if config['dry_run']:
+            logger.info('Instance is running with dry_run enabled')
 
-    _CONF.update(config)
+        exchange_config = config['exchange']
+        self._api = self._init_ccxt(exchange_config)
 
-    if config['dry_run']:
-        logger.info('Instance is running with dry_run enabled')
+        logger.info('Using Exchange "%s"', self.name)
 
-    exchange_config = config['exchange']
-    _API = init_ccxt(exchange_config)
+        # Check if all pairs are available
+        self.validate_pairs(config['exchange']['pair_whitelist'])
 
-    logger.info('Using Exchange "%s"', get_name())
+    def _init_ccxt(self, exchange_config: dict) -> ccxt.Exchange:
+        """
+        Initialize ccxt with given config and return valid
+        ccxt instance.
+        """
+        # Find matching class for the given exchange name
+        name = exchange_config['name']
 
-    # Check if all pairs are available
-    validate_pairs(config['exchange']['pair_whitelist'])
-
-
-def validate_pairs(pairs: List[str]) -> None:
-    """
-    Checks if all given pairs are tradable on the current exchange.
-    Raises OperationalException if one pair is not available.
-    :param pairs: list of pairs
-    :return: None
-    """
-
-    try:
-        markets = _API.load_markets()
-    except ccxt.BaseError as e:
-        logger.warning('Unable to validate pairs (assuming they are correct). Reason: %s', e)
-        return
-
-    stake_cur = _CONF['stake_currency']
-    for pair in pairs:
-        # Note: ccxt has BaseCurrency/QuoteCurrency format for pairs
-        # TODO: add a support for having coins in BTC/USDT format
-        if not pair.endswith(stake_cur):
-            raise OperationalException(
-                f'Pair {pair} not compatible with stake_currency: {stake_cur}')
-        if pair not in markets:
-            raise OperationalException(
-                f'Pair {pair} is not available at {get_name()}')
-
-
-def exchange_has(endpoint: str) -> bool:
-    """
-    Checks if exchange implements a specific API endpoint.
-    Wrapper around ccxt 'has' attribute
-    :param endpoint: Name of endpoint (e.g. 'fetchOHLCV', 'fetchTickers')
-    :return: bool
-    """
-    return endpoint in _API.has and _API.has[endpoint]
-
-
-def buy(pair: str, rate: float, amount: float) -> Dict:
-    if _CONF['dry_run']:
-        global _DRY_RUN_OPEN_ORDERS
-        order_id = f'dry_run_buy_{randint(0, 10**6)}'
-        _DRY_RUN_OPEN_ORDERS[order_id] = {
-            'pair': pair,
-            'price': rate,
-            'amount': amount,
-            'type': 'limit',
-            'side': 'buy',
-            'remaining': 0.0,
-            'datetime': arrow.utcnow().isoformat(),
-            'status': 'closed',
-            'fee': None
-        }
-        return {'id': order_id}
-
-    try:
-        return _API.create_limit_buy_order(pair, amount, rate)
-    except ccxt.InsufficientFunds as e:
-        raise DependencyException(
-            f'Insufficient funds to create limit buy order on market {pair}.'
-            f'Tried to buy amount {amount} at rate {rate} (total {rate*amount}).'
-            f'Message: {e}')
-    except ccxt.InvalidOrder as e:
-        raise DependencyException(
-            f'Could not create limit buy order on market {pair}.'
-            f'Tried to buy amount {amount} at rate {rate} (total {rate*amount}).'
-            f'Message: {e}')
-    except (ccxt.NetworkError, ccxt.ExchangeError) as e:
-        raise TemporaryError(
-            f'Could not place buy order due to {e.__class__.__name__}. Message: {e}')
-    except ccxt.BaseError as e:
-        raise OperationalException(e)
-
-
-def sell(pair: str, rate: float, amount: float) -> Dict:
-    if _CONF['dry_run']:
-        global _DRY_RUN_OPEN_ORDERS
-        order_id = f'dry_run_sell_{randint(0, 10**6)}'
-        _DRY_RUN_OPEN_ORDERS[order_id] = {
-            'pair': pair,
-            'price': rate,
-            'amount': amount,
-            'type': 'limit',
-            'side': 'sell',
-            'remaining': 0.0,
-            'datetime': arrow.utcnow().isoformat(),
-            'status': 'closed'
-        }
-        return {'id': order_id}
-
-    try:
-        return _API.create_limit_sell_order(pair, amount, rate)
-    except ccxt.InsufficientFunds as e:
-        raise DependencyException(
-            f'Insufficient funds to create limit sell order on market {pair}.'
-            f'Tried to sell amount {amount} at rate {rate} (total {rate*amount}).'
-            f'Message: {e}')
-    except ccxt.InvalidOrder as e:
-        raise DependencyException(
-            f'Could not create limit sell order on market {pair}.'
-            f'Tried to sell amount {amount} at rate {rate} (total {rate*amount}).'
-            f'Message: {e}')
-    except (ccxt.NetworkError, ccxt.ExchangeError) as e:
-        raise TemporaryError(
-            f'Could not place sell order due to {e.__class__.__name__}. Message: {e}')
-    except ccxt.BaseError as e:
-        raise OperationalException(e)
-
-
-@retrier
-def get_balance(currency: str) -> float:
-    if _CONF['dry_run']:
-        return 999.9
-
-    # ccxt exception is already handled by get_balances
-    balances = get_balances()
-    balance = balances.get(currency)
-    if balance is None:
-        raise TemporaryError(
-            f'Could not get {currency} balance due to malformed exchange response: {balances}')
-    return balance['free']
-
-
-@retrier
-def get_balances() -> dict:
-    if _CONF['dry_run']:
-        return {}
-
-    try:
-        balances = _API.fetch_balance()
-        # Remove additional info from ccxt results
-        balances.pop("info", None)
-        balances.pop("free", None)
-        balances.pop("total", None)
-        balances.pop("used", None)
-
-        return balances
-    except (ccxt.NetworkError, ccxt.ExchangeError) as e:
-        raise TemporaryError(
-            f'Could not get balance due to {e.__class__.__name__}. Message: {e}')
-    except ccxt.BaseError as e:
-        raise OperationalException(e)
-
-
-@retrier
-def get_tickers() -> Dict:
-    try:
-        return _API.fetch_tickers()
-    except ccxt.NotSupported as e:
-        raise OperationalException(
-            f'Exchange {_API.name} does not support fetching tickers in batch.'
-            f'Message: {e}')
-    except (ccxt.NetworkError, ccxt.ExchangeError) as e:
-        raise TemporaryError(
-            f'Could not load tickers due to {e.__class__.__name__}. Message: {e}')
-    except ccxt.BaseError as e:
-        raise OperationalException(e)
-
-
-@retrier
-def get_ticker(pair: str, refresh: Optional[bool] = True) -> dict:
-    global _CACHED_TICKER
-    if refresh or pair not in _CACHED_TICKER.keys():
+        if name not in ccxt.exchanges:
+            raise OperationalException(f'Exchange {name} is not supported')
         try:
-            data = _API.fetch_ticker(pair)
+            api = getattr(ccxt, name.lower())({
+                'apiKey': exchange_config.get('key'),
+                'secret': exchange_config.get('secret'),
+                'password': exchange_config.get('password'),
+                'uid': exchange_config.get('uid', ''),
+                'enableRateLimit': True,
+            })
+        except (KeyError, AttributeError):
+            raise OperationalException(f'Exchange {name} is not supported')
+
+        return api
+
+    @property
+    def name(self) -> str:
+        """exchange Name (from ccxt)"""
+        return self._api.name
+
+    @property
+    def id(self) -> str:
+        """exchange ccxt id"""
+        return self._api.id
+
+    def validate_pairs(self, pairs: List[str]) -> None:
+        """
+        Checks if all given pairs are tradable on the current exchange.
+        Raises OperationalException if one pair is not available.
+        :param pairs: list of pairs
+        :return: None
+        """
+
+        try:
+            markets = self._api.load_markets()
+        except ccxt.BaseError as e:
+            logger.warning('Unable to validate pairs (assuming they are correct). Reason: %s', e)
+            return
+
+        stake_cur = self._conf['stake_currency']
+        for pair in pairs:
+            # Note: ccxt has BaseCurrency/QuoteCurrency format for pairs
+            # TODO: add a support for having coins in BTC/USDT format
+            if not pair.endswith(stake_cur):
+                raise OperationalException(
+                    f'Pair {pair} not compatible with stake_currency: {stake_cur}')
+            if pair not in markets:
+                raise OperationalException(
+                    f'Pair {pair} is not available at {self.name}')
+
+    def exchange_has(self, endpoint: str) -> bool:
+        """
+        Checks if exchange implements a specific API endpoint.
+        Wrapper around ccxt 'has' attribute
+        :param endpoint: Name of endpoint (e.g. 'fetchOHLCV', 'fetchTickers')
+        :return: bool
+        """
+        return endpoint in self._api.has and self._api.has[endpoint]
+
+    def buy(self, pair: str, rate: float, amount: float) -> Dict:
+        if self._conf['dry_run']:
+            order_id = f'dry_run_buy_{randint(0, 10**6)}'
+            self._dry_run_open_orders[order_id] = {
+                'pair': pair,
+                'price': rate,
+                'amount': amount,
+                'type': 'limit',
+                'side': 'buy',
+                'remaining': 0.0,
+                'datetime': arrow.utcnow().isoformat(),
+                'status': 'closed',
+                'fee': None
+            }
+            return {'id': order_id}
+
+        try:
+            return self._api.create_limit_buy_order(pair, amount, rate)
+        except ccxt.InsufficientFunds as e:
+            raise DependencyException(
+                f'Insufficient funds to create limit buy order on market {pair}.'
+                f'Tried to buy amount {amount} at rate {rate} (total {rate*amount}).'
+                f'Message: {e}')
+        except ccxt.InvalidOrder as e:
+            raise DependencyException(
+                f'Could not create limit buy order on market {pair}.'
+                f'Tried to buy amount {amount} at rate {rate} (total {rate*amount}).'
+                f'Message: {e}')
+        except (ccxt.NetworkError, ccxt.ExchangeError) as e:
+            raise TemporaryError(
+                f'Could not place buy order due to {e.__class__.__name__}. Message: {e}')
+        except ccxt.BaseError as e:
+            raise OperationalException(e)
+
+    def sell(self, pair: str, rate: float, amount: float) -> Dict:
+        if self._conf['dry_run']:
+            order_id = f'dry_run_sell_{randint(0, 10**6)}'
+            self._dry_run_open_orders[order_id] = {
+                'pair': pair,
+                'price': rate,
+                'amount': amount,
+                'type': 'limit',
+                'side': 'sell',
+                'remaining': 0.0,
+                'datetime': arrow.utcnow().isoformat(),
+                'status': 'closed'
+            }
+            return {'id': order_id}
+
+        try:
+            return self._api.create_limit_sell_order(pair, amount, rate)
+        except ccxt.InsufficientFunds as e:
+            raise DependencyException(
+                f'Insufficient funds to create limit sell order on market {pair}.'
+                f'Tried to sell amount {amount} at rate {rate} (total {rate*amount}).'
+                f'Message: {e}')
+        except ccxt.InvalidOrder as e:
+            raise DependencyException(
+                f'Could not create limit sell order on market {pair}.'
+                f'Tried to sell amount {amount} at rate {rate} (total {rate*amount}).'
+                f'Message: {e}')
+        except (ccxt.NetworkError, ccxt.ExchangeError) as e:
+            raise TemporaryError(
+                f'Could not place sell order due to {e.__class__.__name__}. Message: {e}')
+        except ccxt.BaseError as e:
+            raise OperationalException(e)
+
+    @retrier
+    def get_balance(self, currency: str) -> float:
+        if self._conf['dry_run']:
+            return 999.9
+
+        # ccxt exception is already handled by get_balances
+        balances = self.get_balances()
+        balance = balances.get(currency)
+        if balance is None:
+            raise TemporaryError(
+                f'Could not get {currency} balance due to malformed exchange response: {balances}')
+        return balance['free']
+
+    @retrier
+    def get_balances(self) -> dict:
+        if self._conf['dry_run']:
+            return {}
+
+        try:
+            balances = self._api.fetch_balance()
+            # Remove additional info from ccxt results
+            balances.pop("info", None)
+            balances.pop("free", None)
+            balances.pop("total", None)
+            balances.pop("used", None)
+
+            return balances
+        except (ccxt.NetworkError, ccxt.ExchangeError) as e:
+            raise TemporaryError(
+                f'Could not get balance due to {e.__class__.__name__}. Message: {e}')
+        except ccxt.BaseError as e:
+            raise OperationalException(e)
+
+    @retrier
+    def get_tickers(self) -> Dict:
+        try:
+            return self._api.fetch_tickers()
+        except ccxt.NotSupported as e:
+            raise OperationalException(
+                f'Exchange {self._api.name} does not support fetching tickers in batch.'
+                f'Message: {e}')
+        except (ccxt.NetworkError, ccxt.ExchangeError) as e:
+            raise TemporaryError(
+                f'Could not load tickers due to {e.__class__.__name__}. Message: {e}')
+        except ccxt.BaseError as e:
+            raise OperationalException(e)
+
+    @retrier
+    def get_ticker(self, pair: str, refresh: Optional[bool] = True) -> dict:
+        if refresh or pair not in self._cached_ticker.keys():
             try:
-                _CACHED_TICKER[pair] = {
-                    'bid': float(data['bid']),
-                    'ask': float(data['ask']),
-                }
-            except KeyError:
-                logger.debug("Could not cache ticker data for %s", pair)
+                data = self._api.fetch_ticker(pair)
+                try:
+                    self._cached_ticker[pair] = {
+                        'bid': float(data['bid']),
+                        'ask': float(data['ask']),
+                    }
+                except KeyError:
+                    logger.debug("Could not cache ticker data for %s", pair)
+                return data
+            except (ccxt.NetworkError, ccxt.ExchangeError) as e:
+                raise TemporaryError(
+                    f'Could not load ticker history due to {e.__class__.__name__}. Message: {e}')
+            except ccxt.BaseError as e:
+                raise OperationalException(e)
+        else:
+            logger.info("returning cached ticker-data for %s", pair)
+            return self._cached_ticker[pair]
+
+    @retrier
+    def get_ticker_history(self, pair: str, tick_interval: str,
+                           since_ms: Optional[int] = None) -> List[Dict]:
+        try:
+            # last item should be in the time interval [now - tick_interval, now]
+            till_time_ms = arrow.utcnow().shift(
+                            minutes=-constants.TICKER_INTERVAL_MINUTES[tick_interval]
+                        ).timestamp * 1000
+            # it looks as if some exchanges return cached data
+            # and they update it one in several minute, so 10 mins interval
+            # is necessary to skeep downloading of an empty array when all
+            # chached data was already downloaded
+            till_time_ms = min(till_time_ms, arrow.utcnow().shift(minutes=-10).timestamp * 1000)
+
+            data: List[Dict[Any, Any]] = []
+            while not since_ms or since_ms < till_time_ms:
+                data_part = self._api.fetch_ohlcv(pair, timeframe=tick_interval, since=since_ms)
+
+                # Because some exchange sort Tickers ASC and other DESC.
+                # Ex: Bittrex returns a list of tickers ASC (oldest first, newest last)
+                # when GDAX returns a list of tickers DESC (newest first, oldest last)
+                data_part = sorted(data_part, key=lambda x: x[0])
+
+                if not data_part:
+                    break
+
+                logger.debug('Downloaded data for %s time range [%s, %s]',
+                             pair,
+                             arrow.get(data_part[0][0] / 1000).format(),
+                             arrow.get(data_part[-1][0] / 1000).format())
+
+                data.extend(data_part)
+                since_ms = data[-1][0] + 1
+
             return data
+        except ccxt.NotSupported as e:
+            raise OperationalException(
+                f'Exchange {self._api.name} does not support fetching historical candlestick data.'
+                f'Message: {e}')
         except (ccxt.NetworkError, ccxt.ExchangeError) as e:
             raise TemporaryError(
                 f'Could not load ticker history due to {e.__class__.__name__}. Message: {e}')
+        except ccxt.BaseError as e:
+            raise OperationalException(f'Could not fetch ticker data. Msg: {e}')
+
+    @retrier
+    def cancel_order(self, order_id: str, pair: str) -> None:
+        if self._conf['dry_run']:
+            return
+
+        try:
+            return self._api.cancel_order(order_id, pair)
+        except ccxt.InvalidOrder as e:
+            raise DependencyException(
+                f'Could not cancel order. Message: {e}')
+        except (ccxt.NetworkError, ccxt.ExchangeError) as e:
+            raise TemporaryError(
+                f'Could not cancel order due to {e.__class__.__name__}. Message: {e}')
         except ccxt.BaseError as e:
             raise OperationalException(e)
-    else:
-        logger.info("returning cached ticker-data for %s", pair)
-        return _CACHED_TICKER[pair]
 
+    @retrier
+    def get_order(self, order_id: str, pair: str) -> Dict:
+        if self._conf['dry_run']:
+            order = self._dry_run_open_orders[order_id]
+            order.update({
+                'id': order_id
+            })
+            return order
+        try:
+            return self._api.fetch_order(order_id, pair)
+        except ccxt.InvalidOrder as e:
+            raise DependencyException(
+                f'Could not get order. Message: {e}')
+        except (ccxt.NetworkError, ccxt.ExchangeError) as e:
+            raise TemporaryError(
+                f'Could not get order due to {e.__class__.__name__}. Message: {e}')
+        except ccxt.BaseError as e:
+            raise OperationalException(e)
 
-@retrier
-def get_ticker_history(pair: str, tick_interval: str, since_ms: Optional[int] = None) -> List[Dict]:
-    try:
-        # last item should be in the time interval [now - tick_interval, now]
-        till_time_ms = arrow.utcnow().shift(
-                        minutes=-constants.TICKER_INTERVAL_MINUTES[tick_interval]
-                       ).timestamp * 1000
-        # it looks as if some exchanges return cached data
-        # and they update it one in several minute, so 10 mins interval
-        # is necessary to skeep downloading of an empty array when all
-        # chached data was already downloaded
-        till_time_ms = min(till_time_ms, arrow.utcnow().shift(minutes=-10).timestamp * 1000)
+    @retrier
+    def get_trades_for_order(self, order_id: str, pair: str, since: datetime) -> List:
+        if self._conf['dry_run']:
+            return []
+        if not self.exchange_has('fetchMyTrades'):
+            return []
+        try:
+            my_trades = self._api.fetch_my_trades(pair, since.timestamp())
+            matched_trades = [trade for trade in my_trades if trade['order'] == order_id]
 
-        data: List[Dict[Any, Any]] = []
-        while not since_ms or since_ms < till_time_ms:
-            data_part = _API.fetch_ohlcv(pair, timeframe=tick_interval, since=since_ms)
+            return matched_trades
 
-            # Because some exchange sort Tickers ASC and other DESC.
-            # Ex: Bittrex returns a list of tickers ASC (oldest first, newest last)
-            # when GDAX returns a list of tickers DESC (newest first, oldest last)
-            data_part = sorted(data_part, key=lambda x: x[0])
+        except ccxt.NetworkError as e:
+            raise TemporaryError(
+                f'Could not get trades due to networking error. Message: {e}')
+        except ccxt.BaseError as e:
+            raise OperationalException(e)
 
-            if not data_part:
-                break
+    def get_pair_detail_url(self, pair: str) -> str:
+        try:
+            url_base = self._api.urls.get('www')
+            base, quote = pair.split('/')
 
-            logger.debug('Downloaded data for %s time range [%s, %s]',
-                         pair,
-                         arrow.get(data_part[0][0] / 1000).format(),
-                         arrow.get(data_part[-1][0] / 1000).format())
+            return url_base + _EXCHANGE_URLS[self._api.id].format(base=base, quote=quote)
+        except KeyError:
+            logger.warning('Could not get exchange url for %s', self.name)
+            return ""
 
-            data.extend(data_part)
-            since_ms = data[-1][0] + 1
+    @retrier
+    def get_markets(self) -> List[dict]:
+        try:
+            return self._api.fetch_markets()
+        except (ccxt.NetworkError, ccxt.ExchangeError) as e:
+            raise TemporaryError(
+                f'Could not load markets due to {e.__class__.__name__}. Message: {e}')
+        except ccxt.BaseError as e:
+            raise OperationalException(e)
 
-        return data
-    except ccxt.NotSupported as e:
-        raise OperationalException(
-            f'Exchange {_API.name} does not support fetching historical candlestick data.'
-            f'Message: {e}')
-    except (ccxt.NetworkError, ccxt.ExchangeError) as e:
-        raise TemporaryError(
-            f'Could not load ticker history due to {e.__class__.__name__}. Message: {e}')
-    except ccxt.BaseError as e:
-        raise OperationalException(f'Could not fetch ticker data. Msg: {e}')
+    @retrier
+    def get_fee(self, symbol='ETH/BTC', type='', side='', amount=1,
+                price=1, taker_or_maker='maker') -> float:
+        try:
+            # validate that markets are loaded before trying to get fee
+            if self._api.markets is None or len(self._api.markets) == 0:
+                self._api.load_markets()
 
+            return self._api.calculate_fee(symbol=symbol, type=type, side=side, amount=amount,
+                                           price=price, takerOrMaker=taker_or_maker)['rate']
+        except (ccxt.NetworkError, ccxt.ExchangeError) as e:
+            raise TemporaryError(
+                f'Could not get fee info due to {e.__class__.__name__}. Message: {e}')
+        except ccxt.BaseError as e:
+            raise OperationalException(e)
 
-@retrier
-def cancel_order(order_id: str, pair: str) -> None:
-    if _CONF['dry_run']:
-        return
-
-    try:
-        return _API.cancel_order(order_id, pair)
-    except ccxt.InvalidOrder as e:
-        raise DependencyException(
-            f'Could not cancel order. Message: {e}')
-    except (ccxt.NetworkError, ccxt.ExchangeError) as e:
-        raise TemporaryError(
-            f'Could not cancel order due to {e.__class__.__name__}. Message: {e}')
-    except ccxt.BaseError as e:
-        raise OperationalException(e)
-
-
-@retrier
-def get_order(order_id: str, pair: str) -> Dict:
-    if _CONF['dry_run']:
-        order = _DRY_RUN_OPEN_ORDERS[order_id]
-        order.update({
-            'id': order_id
-        })
-        return order
-    try:
-        return _API.fetch_order(order_id, pair)
-    except ccxt.InvalidOrder as e:
-        raise DependencyException(
-            f'Could not get order. Message: {e}')
-    except (ccxt.NetworkError, ccxt.ExchangeError) as e:
-        raise TemporaryError(
-            f'Could not get order due to {e.__class__.__name__}. Message: {e}')
-    except ccxt.BaseError as e:
-        raise OperationalException(e)
-
-
-@retrier
-def get_trades_for_order(order_id: str, pair: str, since: datetime) -> List:
-    if _CONF['dry_run']:
-        return []
-    if not exchange_has('fetchMyTrades'):
-        return []
-    try:
-        my_trades = _API.fetch_my_trades(pair, since.timestamp())
-        matched_trades = [trade for trade in my_trades if trade['order'] == order_id]
-
-        return matched_trades
-
-    except ccxt.NetworkError as e:
-        raise TemporaryError(
-            f'Could not get trades due to networking error. Message: {e}')
-    except ccxt.BaseError as e:
-        raise OperationalException(e)
-
-
-def get_pair_detail_url(pair: str) -> str:
-    try:
-        url_base = _API.urls.get('www')
-        base, quote = pair.split('/')
-
-        return url_base + _EXCHANGE_URLS[_API.id].format(base=base, quote=quote)
-    except KeyError:
-        logger.warning('Could not get exchange url for %s', get_name())
-        return ""
-
-
-@retrier
-def get_markets() -> List[dict]:
-    try:
-        return _API.fetch_markets()
-    except (ccxt.NetworkError, ccxt.ExchangeError) as e:
-        raise TemporaryError(
-            f'Could not load markets due to {e.__class__.__name__}. Message: {e}')
-    except ccxt.BaseError as e:
-        raise OperationalException(e)
-
-
-def get_name() -> str:
-    return _API.name
-
-
-def get_id() -> str:
-    return _API.id
-
-
-@retrier
-def get_fee(symbol='ETH/BTC', type='', side='', amount=1,
-            price=1, taker_or_maker='maker') -> float:
-    try:
+    def get_amount_lots(self, pair: str, amount: float) -> float:
+        """
+        get buyable amount rounding, ..
+        """
         # validate that markets are loaded before trying to get fee
-        if _API.markets is None or len(_API.markets) == 0:
-            _API.load_markets()
-
-        return _API.calculate_fee(symbol=symbol, type=type, side=side, amount=amount,
-                                  price=price, takerOrMaker=taker_or_maker)['rate']
-    except (ccxt.NetworkError, ccxt.ExchangeError) as e:
-        raise TemporaryError(
-            f'Could not get fee info due to {e.__class__.__name__}. Message: {e}')
-    except ccxt.BaseError as e:
-        raise OperationalException(e)
-
-
-def get_amount_lots(pair: str, amount: float) -> float:
-    """
-    get buyable amount rounding, ..
-    """
-    # validate that markets are loaded before trying to get fee
-    if not _API.markets:
-        _API.load_markets()
-    return _API.amount_to_lots(pair, amount)
+        if not self._api.markets:
+            self._api.load_markets()
+        return self._api.amount_to_lots(pair, amount)

freqtrade/fiat_convert.py

@@ -7,10 +7,12 @@ import logging
 import time
 from typing import Dict, List
 
-from coinmarketcap import Market
 from requests.exceptions import RequestException
+from coinmarketcap import Market
+
 from freqtrade.constants import SUPPORTED_FIAT
 
+
 logger = logging.getLogger(__name__)
 
 

freqtrade/freqtradebot.py

@@ -7,18 +7,16 @@ import logging
 import time
 import traceback
 from datetime import datetime
-from typing import Dict, List, Optional, Any, Callable
+from typing import Any, Callable, Dict, List, Optional
 
 import arrow
 import requests
 from cachetools import TTLCache, cached
 
-from freqtrade import (
-    DependencyException, OperationalException, TemporaryError,
-    exchange, persistence, __version__,
-)
-from freqtrade import constants
+from freqtrade import (DependencyException, OperationalException,
+                       TemporaryError, __version__, constants, persistence)
 from freqtrade.analyze import Analyze
+from freqtrade.exchange import Exchange
 from freqtrade.fiat_convert import CryptoToFiatConverter
 from freqtrade.persistence import Trade
 from freqtrade.rpc.rpc_manager import RPCManager
@@ -54,7 +52,7 @@ class FreqtradeBot(object):
         self.fiat_converter = CryptoToFiatConverter()
         self.rpc: RPCManager = RPCManager(self)
         self.persistence = None
-        self.exchange = None
+        self.exchange = Exchange(self.config)
 
         self._init_modules()
 
@@ -66,7 +64,6 @@ class FreqtradeBot(object):
         # Initialize all modules
 
         persistence.init(self.config)
-        exchange.init(self.config)
 
         # Set initial application state
         initial_state = self.config.get('initial_state')
@@ -161,7 +158,7 @@ class FreqtradeBot(object):
 
             if 'unfilledtimeout' in self.config:
                 # Check and handle any timed out open orders
-                self.check_handle_timedout(self.config['unfilledtimeout'])
+                self.check_handle_timedout()
                 Trade.session.flush()
 
         except TemporaryError as error:
@@ -186,13 +183,13 @@ class FreqtradeBot(object):
         :return: List of pairs
         """
 
-        if not exchange.exchange_has('fetchTickers'):
+        if not self.exchange.exchange_has('fetchTickers'):
             raise OperationalException(
                 'Exchange does not support dynamic whitelist.'
                 'Please edit your config and restart the bot'
             )
 
-        tickers = exchange.get_tickers()
+        tickers = self.exchange.get_tickers()
         # check length so that we make sure that '/' is actually in the string
         tickers = [v for k, v in tickers.items()
                    if len(k.split('/')) == 2 and k.split('/')[1] == base_currency]
@@ -210,7 +207,7 @@ class FreqtradeBot(object):
         black_listed
         """
         sanitized_whitelist = whitelist
-        markets = exchange.get_markets()
+        markets = self.exchange.get_markets()
 
         markets = [m for m in markets if m['quote'] == self.config['stake_currency']]
         known_pairs = set()
@@ -245,27 +242,78 @@ class FreqtradeBot(object):
         balance = self.config['bid_strategy']['ask_last_balance']
         return ticker['ask'] + balance * (ticker['last'] - ticker['ask'])
 
+    def _get_trade_stake_amount(self) -> Optional[float]:
+        stake_amount = self.config['stake_amount']
+        avaliable_amount = self.exchange.get_balance(self.config['stake_currency'])
+
+        if stake_amount == constants.UNLIMITED_STAKE_AMOUNT:
+            open_trades = len(Trade.query.filter(Trade.is_open.is_(True)).all())
+            if open_trades >= self.config['max_open_trades']:
+                logger.warning('Can\'t open a new trade: max number of trades is reached')
+                return None
+            return avaliable_amount / (self.config['max_open_trades'] - open_trades)
+
+        # Check if stake_amount is fulfilled
+        if avaliable_amount < stake_amount:
+            raise DependencyException(
+                'Available balance(%f %s) is lower than stake amount(%f %s)' % (
+                    avaliable_amount, self.config['stake_currency'],
+                    stake_amount, self.config['stake_currency'])
+            )
+
+        return stake_amount
+
+    def _get_min_pair_stake_amount(self, pair: str, price: float) -> Optional[float]:
+        markets = self.exchange.get_markets()
+        markets = [m for m in markets if m['symbol'] == pair]
+        if not markets:
+            raise ValueError(f'Can\'t get market information for symbol {pair}')
+
+        market = markets[0]
+
+        if 'limits' not in market:
+            return None
+
+        min_stake_amounts = []
+        limits = market['limits']
+        if ('cost' in limits and 'min' in limits['cost']
+                and limits['cost']['min'] is not None):
+            min_stake_amounts.append(limits['cost']['min'])
+
+        if ('amount' in limits and 'min' in limits['amount']
+                and limits['amount']['min'] is not None):
+            min_stake_amounts.append(limits['amount']['min'] * price)
+
+        if not min_stake_amounts:
+            return None
+
+        amount_reserve_percent = 1 - 0.05  # reserve 5% + stoploss
+        if self.analyze.get_stoploss() is not None:
+            amount_reserve_percent += self.analyze.get_stoploss()
+        # it should not be more than 50%
+        amount_reserve_percent = max(amount_reserve_percent, 0.5)
+        return min(min_stake_amounts)/amount_reserve_percent
+
     def create_trade(self) -> bool:
         """
         Checks the implemented trading indicator(s) for a randomly picked pair,
         if one pair triggers the buy_signal a new trade record gets created
         :return: True if a trade object has been created and persisted, False otherwise
         """
-        stake_amount = self.config['stake_amount']
         interval = self.analyze.get_ticker_interval()
+        stake_amount = self._get_trade_stake_amount()
+
+        if not stake_amount:
+            return False
         stake_currency = self.config['stake_currency']
         fiat_currency = self.config['fiat_display_currency']
-        exc_name = exchange.get_name()
+        exc_name = self.exchange.name
 
         logger.info(
             'Checking buy signals to create a new trade with stake_amount: %f ...',
             stake_amount
         )
         whitelist = copy.deepcopy(self.config['exchange']['pair_whitelist'])
-        # Check if stake_amount is fulfilled
-        if exchange.get_balance(stake_currency) < stake_amount:
-            raise DependencyException(
-                f'stake amount is not fulfilled (currency={stake_currency})')
 
         # Remove currently opened and latest pairs from whitelist
         for trade in Trade.query.filter(Trade.is_open.is_(True)).all():
@@ -278,19 +326,29 @@ class FreqtradeBot(object):
 
         # Pick pair based on buy signals
         for _pair in whitelist:
-            (buy, sell) = self.analyze.get_signal(_pair, interval)
+            (buy, sell) = self.analyze.get_signal(self.exchange, _pair, interval)
             if buy and not sell:
                 pair = _pair
                 break
         else:
             return False
         pair_s = pair.replace('_', '/')
-        pair_url = exchange.get_pair_detail_url(pair)
+        pair_url = self.exchange.get_pair_detail_url(pair)
+
         # Calculate amount
-        buy_limit = self.get_target_bid(exchange.get_ticker(pair))
+        buy_limit = self.get_target_bid(self.exchange.get_ticker(pair))
+
+        min_stake_amount = self._get_min_pair_stake_amount(pair_s, buy_limit)
+        if min_stake_amount is not None and min_stake_amount > stake_amount:
+            logger.warning(
+                f'Can\'t open a new trade for {pair_s}: stake amount'
+                f' is too small ({stake_amount} < {min_stake_amount})'
+            )
+            return False
+
         amount = stake_amount / buy_limit
 
-        order_id = exchange.buy(pair, buy_limit, amount)['id']
+        order_id = self.exchange.buy(pair, buy_limit, amount)['id']
 
         stake_amount_fiat = self.fiat_converter.convert_amount(
             stake_amount,
@@ -305,7 +363,7 @@ with limit `{buy_limit:.8f} ({stake_amount:.6f} \
 {stake_currency}, {stake_amount_fiat:.3f} {fiat_currency})`"""
         )
         # Fee is applied twice because we make a LIMIT_BUY and LIMIT_SELL
-        fee = exchange.get_fee(symbol=pair, taker_or_maker='maker')
+        fee = self.exchange.get_fee(symbol=pair, taker_or_maker='maker')
         trade = Trade(
             pair=pair,
             stake_amount=stake_amount,
@@ -315,7 +373,7 @@ with limit `{buy_limit:.8f} ({stake_amount:.6f} \
             open_rate=buy_limit,
             open_rate_requested=buy_limit,
             open_date=datetime.utcnow(),
-            exchange=exchange.get_id(),
+            exchange=self.exchange.id,
             open_order_id=order_id
         )
         Trade.session.add(trade)
@@ -348,7 +406,7 @@ with limit `{buy_limit:.8f} ({stake_amount:.6f} \
             if trade.open_order_id:
                 # Update trade with order values
                 logger.info('Found open order for %s', trade)
-                order = exchange.get_order(trade.open_order_id, trade.pair)
+                order = self.exchange.get_order(trade.open_order_id, trade.pair)
                 # Try update amount (binance-fix)
                 try:
                     new_amount = self.get_real_amount(trade, order)
@@ -372,7 +430,7 @@ with limit `{buy_limit:.8f} ({stake_amount:.6f} \
     def get_real_amount(self, trade: Trade, order: Dict) -> float:
         """
         Get real amount for the trade
-        Necessary for exchanges which charge fees in base currency (e.g. binance)
+        Necessary for self.exchanges which charge fees in base currency (e.g. binance)
         """
         order_amount = order['amount']
         # Only run for closed orders
@@ -388,7 +446,8 @@ with limit `{buy_limit:.8f} ({stake_amount:.6f} \
                 return new_amount
 
         # Fallback to Trades
-        trades = exchange.get_trades_for_order(trade.open_order_id, trade.pair, trade.open_date)
+        trades = self.exchange.get_trades_for_order(trade.open_order_id, trade.pair,
+                                                    trade.open_date)
 
         if len(trades) == 0:
             logger.info("Applying fee on amount for %s failed: myTrade-Dict empty found", trade)
@@ -420,12 +479,13 @@ with limit `{buy_limit:.8f} ({stake_amount:.6f} \
             raise ValueError(f'attempt to handle closed trade: {trade}')
 
         logger.debug('Handling %s ...', trade)
-        current_rate = exchange.get_ticker(trade.pair)['bid']
+        current_rate = self.exchange.get_ticker(trade.pair)['bid']
 
         (buy, sell) = (False, False)
-
-        if self.config.get('experimental', {}).get('use_sell_signal'):
-            (buy, sell) = self.analyze.get_signal(trade.pair, self.analyze.get_ticker_interval())
+        experimental = self.config.get('experimental', {})
+        if experimental.get('use_sell_signal') or experimental.get('ignore_roi_if_buy_signal'):
+            (buy, sell) = self.analyze.get_signal(self.exchange,
+                                                  trade.pair, self.analyze.get_ticker_interval())
 
         if self.analyze.should_sell(trade, current_rate, datetime.utcnow(), buy, sell):
             self.execute_sell(trade, current_rate)
@@ -433,13 +493,16 @@ with limit `{buy_limit:.8f} ({stake_amount:.6f} \
         logger.info('Found no sell signals for whitelisted currencies. Trying again..')
         return False
 
-    def check_handle_timedout(self, timeoutvalue: int) -> None:
+    def check_handle_timedout(self) -> None:
         """
         Check if any orders are timed out and cancel if neccessary
         :param timeoutvalue: Number of minutes until order is considered timed out
         :return: None
         """
-        timeoutthreashold = arrow.utcnow().shift(minutes=-timeoutvalue).datetime
+        buy_timeout = self.config['unfilledtimeout']['buy']
+        sell_timeout = self.config['unfilledtimeout']['sell']
+        buy_timeoutthreashold = arrow.utcnow().shift(minutes=-buy_timeout).datetime
+        sell_timeoutthreashold = arrow.utcnow().shift(minutes=-sell_timeout).datetime
 
         for trade in Trade.query.filter(Trade.open_order_id.isnot(None)).all():
             try:
@@ -449,7 +512,7 @@ with limit `{buy_limit:.8f} ({stake_amount:.6f} \
                 # updated via /forcesell in a different thread.
                 if not trade.open_order_id:
                     continue
-                order = exchange.get_order(trade.open_order_id, trade.pair)
+                order = self.exchange.get_order(trade.open_order_id, trade.pair)
             except requests.exceptions.RequestException:
                 logger.info(
                     'Cannot query order for %s due to %s',
@@ -462,10 +525,12 @@ with limit `{buy_limit:.8f} ({stake_amount:.6f} \
             if int(order['remaining']) == 0:
                 continue
 
-            if order['side'] == 'buy' and ordertime < timeoutthreashold:
-                self.handle_timedout_limit_buy(trade, order)
-            elif order['side'] == 'sell' and ordertime < timeoutthreashold:
-                self.handle_timedout_limit_sell(trade, order)
+            # Check if trade is still actually open
+            if order['status'] == 'open':
+                if order['side'] == 'buy' and ordertime < buy_timeoutthreashold:
+                    self.handle_timedout_limit_buy(trade, order)
+                elif order['side'] == 'sell' and ordertime < sell_timeoutthreashold:
+                    self.handle_timedout_limit_sell(trade, order)
 
     # FIX: 20180110, why is cancel.order unconditionally here, whereas
     #                it is conditionally called in the
@@ -475,7 +540,7 @@ with limit `{buy_limit:.8f} ({stake_amount:.6f} \
         :return: True if order was fully cancelled
         """
         pair_s = trade.pair.replace('_', '/')
-        exchange.cancel_order(trade.open_order_id, trade.pair)
+        self.exchange.cancel_order(trade.open_order_id, trade.pair)
         if order['remaining'] == order['amount']:
             # if trade is not partially completed, just delete the trade
             Trade.session.delete(trade)
@@ -502,7 +567,7 @@ with limit `{buy_limit:.8f} ({stake_amount:.6f} \
         pair_s = trade.pair.replace('_', '/')
         if order['remaining'] == order['amount']:
             # if trade is not partially completed, just cancel the trade
-            exchange.cancel_order(trade.open_order_id, trade.pair)
+            self.exchange.cancel_order(trade.open_order_id, trade.pair)
             trade.close_rate = None
             trade.close_profit = None
             trade.close_date = None
@@ -525,15 +590,15 @@ with limit `{buy_limit:.8f} ({stake_amount:.6f} \
         exc = trade.exchange
         pair = trade.pair
         # Execute sell and update trade record
-        order_id = exchange.sell(str(trade.pair), limit, trade.amount)['id']
+        order_id = self.exchange.sell(str(trade.pair), limit, trade.amount)['id']
         trade.open_order_id = order_id
         trade.close_rate_requested = limit
 
         fmt_exp_profit = round(trade.calc_profit_percent(rate=limit) * 100, 2)
         profit_trade = trade.calc_profit(rate=limit)
-        current_rate = exchange.get_ticker(trade.pair)['bid']
+        current_rate = self.exchange.get_ticker(trade.pair)['bid']
         profit = trade.calc_profit_percent(limit)
-        pair_url = exchange.get_pair_detail_url(trade.pair)
+        pair_url = self.exchange.get_pair_detail_url(trade.pair)
         gain = "profit" if fmt_exp_profit > 0 else "loss"
 
         message = f"*{exc}:* Selling\n" \
@@ -561,12 +626,8 @@ with limit `{buy_limit:.8f} ({stake_amount:.6f} \
         # Because telegram._forcesell does not have the configuration
         # Ignore the FIAT value and does not show the stake_currency as well
         else:
-            message += '` ({gain}: {profit_percent:.2f}%, {profit_coin:.8f})`'.format(
-                gain="profit" if fmt_exp_profit > 0 else "loss",
-                profit_percent=fmt_exp_profit,
-                profit_coin=profit_trade
-            )
-
+            gain = "profit" if fmt_exp_profit > 0 else "loss"
+            message += f'` ({gain}: {fmt_exp_profit:.2f}%, {profit_trade:.8f})`'
         # Send the message
         self.rpc.send_msg(message)
         Trade.session.flush()

freqtrade/indicator_helpers.py

@@ -1,4 +1,4 @@
-from math import exp, pi, sqrt, cos
+from math import cos, exp, pi, sqrt
 
 import numpy as np
 import talib as ta

freqtrade/main.py

@@ -74,10 +74,7 @@ def reconfigure(freqtrade: FreqtradeBot, args: Namespace) -> FreqtradeBot:
     # Create new instance
     freqtrade = FreqtradeBot(Configuration(args).get_config())
     freqtrade.rpc.send_msg(
-        '*Status:* `Config reloaded ...`'.format(
-            freqtrade.state.name.lower()
-        )
-    )
+        '*Status:* `Config reloaded {freqtrade.state.name.lower()}...`')
     return freqtrade
 
 

freqtrade/misc.py

@@ -2,10 +2,10 @@
 Various tool function for Freqtrade and scripts
 """
 
+import gzip
 import json
 import logging
 import re
-import gzip
 from datetime import datetime
 from typing import Dict
 

freqtrade/optimize/__init__.py

@@ -7,12 +7,10 @@ import os
 from typing import Optional, List, Dict, Tuple, Any
 import arrow
 
-from freqtrade import misc, constants
-from freqtrade.exchange import get_ticker_history
+from freqtrade import misc, constants, OperationalException
+from freqtrade.exchange import Exchange
 from freqtrade.arguments import TimeRange
 
-from user_data.hyperopt_conf import hyperopt_optimize_conf
-
 logger = logging.getLogger(__name__)
 
 
@@ -56,11 +54,8 @@ def load_tickerdata_file(
     :return dict OR empty if unsuccesful
     """
     path = make_testdata_path(datadir)
-    pair_file_string = pair.replace('/', '_')
-    file = os.path.join(path, '{pair}-{ticker_interval}.json'.format(
-        pair=pair_file_string,
-        ticker_interval=ticker_interval,
-    ))
+    pair_s = pair.replace('/', '_')
+    file = os.path.join(path, f'{pair_s}-{ticker_interval}.json')
     gzipfile = file + '.gz'
 
     # If the file does not exist we download it when None is returned.
@@ -83,8 +78,9 @@ def load_tickerdata_file(
 
 def load_data(datadir: str,
               ticker_interval: str,
-              pairs: Optional[List[str]] = None,
+              pairs: List[str],
               refresh_pairs: Optional[bool] = False,
+              exchange: Optional[Exchange] = None,
               timerange: TimeRange = TimeRange(None, None, 0, 0)) -> Dict[str, List]:
     """
     Loads ticker history data for the given parameters
@@ -92,14 +88,15 @@ def load_data(datadir: str,
     """
     result = {}
 
-    _pairs = pairs or hyperopt_optimize_conf()['exchange']['pair_whitelist']
-
     # If the user force the refresh of pairs
     if refresh_pairs:
         logger.info('Download data for all pairs and store them in %s', datadir)
-        download_pairs(datadir, _pairs, ticker_interval, timerange=timerange)
+        if not exchange:
+            raise OperationalException("Exchange needs to be initialized when "
+                                       "calling load_data with refresh_pairs=True")
+        download_pairs(datadir, exchange, pairs, ticker_interval, timerange=timerange)
 
-    for pair in _pairs:
+    for pair in pairs:
         pairdata = load_tickerdata_file(datadir, pair, ticker_interval, timerange=timerange)
         if pairdata:
             result[pair] = pairdata
@@ -123,13 +120,14 @@ def make_testdata_path(datadir: str) -> str:
     )
 
 
-def download_pairs(datadir, pairs: List[str],
+def download_pairs(datadir, exchange: Exchange, pairs: List[str],
                    ticker_interval: str,
                    timerange: TimeRange = TimeRange(None, None, 0, 0)) -> bool:
     """For each pairs passed in parameters, download the ticker intervals"""
     for pair in pairs:
         try:
             download_backtesting_testdata(datadir,
+                                          exchange=exchange,
                                           pair=pair,
                                           tick_interval=ticker_interval,
                                           timerange=timerange)
@@ -187,6 +185,7 @@ def load_cached_data_for_updating(filename: str,
 
 
 def download_backtesting_testdata(datadir: str,
+                                  exchange: Exchange,
                                   pair: str,
                                   tick_interval: str = '5m',
                                   timerange: Optional[TimeRange] = None) -> None:
@@ -220,7 +219,8 @@ def download_backtesting_testdata(datadir: str,
     logger.debug("Current Start: %s", misc.format_ms_time(data[1][0]) if data else 'None')
     logger.debug("Current End: %s", misc.format_ms_time(data[-1][0]) if data else 'None')
 
-    new_data = get_ticker_history(pair=pair, tick_interval=tick_interval, since_ms=since_ms)
+    new_data = exchange.get_ticker_history(pair=pair, tick_interval=tick_interval,
+                                           since_ms=since_ms)
     data.extend(new_data)
 
     logger.debug("New Start: %s", misc.format_ms_time(data[0][0]))

freqtrade/optimize/backtesting.py

@@ -6,23 +6,42 @@ This module contains the backtesting logic
 import logging
 import operator
 from argparse import Namespace
-from typing import Dict, Tuple, Any, List, Optional
+from datetime import datetime
+from typing import Any, Dict, List, NamedTuple, Optional, Tuple
 
 import arrow
 from pandas import DataFrame
 from tabulate import tabulate
 
 import freqtrade.optimize as optimize
-from freqtrade import exchange
+from freqtrade import DependencyException, constants
 from freqtrade.analyze import Analyze
 from freqtrade.arguments import Arguments
 from freqtrade.configuration import Configuration
+from freqtrade.exchange import Exchange
 from freqtrade.misc import file_dump_json
 from freqtrade.persistence import Trade
 
 logger = logging.getLogger(__name__)
 
 
+class BacktestResult(NamedTuple):
+    """
+    NamedTuple Defining BacktestResults inputs.
+    """
+    pair: str
+    profit_percent: float
+    profit_abs: float
+    open_time: datetime
+    close_time: datetime
+    open_index: int
+    close_index: int
+    trade_duration: float
+    open_at_end: bool
+    open_rate: float
+    close_rate: float
+
+
 class Backtesting(object):
     """
     Backtesting class, this class contains all the logic to run a backtest
@@ -45,7 +64,8 @@ class Backtesting(object):
         self.config['exchange']['password'] = ''
         self.config['exchange']['uid'] = ''
         self.config['dry_run'] = True
-        exchange.init(self.config)
+        self.exchange = Exchange(self.config)
+        self.fee = self.exchange.get_fee()
 
     @staticmethod
     def get_timeframe(data: Dict[str, DataFrame]) -> Tuple[arrow.Arrow, arrow.Arrow]:
@@ -73,15 +93,15 @@ class Backtesting(object):
         headers = ['pair', 'buy count', 'avg profit %',
                    'total profit ' + stake_currency, 'avg duration', 'profit', 'loss']
         for pair in data:
-            result = results[results.currency == pair]
+            result = results[results.pair == pair]
             tabular_data.append([
                 pair,
                 len(result.index),
                 result.profit_percent.mean() * 100.0,
-                result.profit_BTC.sum(),
-                result.duration.mean(),
-                len(result[result.profit_BTC > 0]),
-                len(result[result.profit_BTC < 0])
+                result.profit_abs.sum(),
+                result.trade_duration.mean(),
+                len(result[result.profit_abs > 0]),
+                len(result[result.profit_abs < 0])
             ])
 
         # Append Total
@@ -89,27 +109,37 @@ class Backtesting(object):
             'TOTAL',
             len(results.index),
             results.profit_percent.mean() * 100.0,
-            results.profit_BTC.sum(),
-            results.duration.mean(),
-            len(results[results.profit_BTC > 0]),
-            len(results[results.profit_BTC < 0])
+            results.profit_abs.sum(),
+            results.trade_duration.mean(),
+            len(results[results.profit_abs > 0]),
+            len(results[results.profit_abs < 0])
         ])
         return tabulate(tabular_data, headers=headers, floatfmt=floatfmt, tablefmt="pipe")
 
+    def _store_backtest_result(self, recordfilename: Optional[str], results: DataFrame) -> None:
+
+        records = [(t.pair, t.profit_percent, t.open_time.timestamp(),
+                    t.close_time.timestamp(), t.open_index - 1, t.trade_duration,
+                    t.open_rate, t.close_rate, t.open_at_end)
+                   for index, t in results.iterrows()]
+
+        if records:
+            logger.info('Dumping backtest results to %s', recordfilename)
+            file_dump_json(recordfilename, records)
+
     def _get_sell_trade_entry(
             self, pair: str, buy_row: DataFrame,
-            partial_ticker: List, trade_count_lock: Dict, args: Dict) -> Optional[Tuple]:
+            partial_ticker: List, trade_count_lock: Dict, args: Dict) -> Optional[BacktestResult]:
 
         stake_amount = args['stake_amount']
         max_open_trades = args.get('max_open_trades', 0)
-        fee = exchange.get_fee()
         trade = Trade(
             open_rate=buy_row.close,
             open_date=buy_row.date,
             stake_amount=stake_amount,
             amount=stake_amount / buy_row.open,
-            fee_open=fee,
-            fee_close=fee
+            fee_open=self.fee,
+            fee_close=self.fee
         )
 
         # calculate win/lose forwards from buy point
@@ -121,15 +151,37 @@ class Backtesting(object):
             buy_signal = sell_row.buy
             if self.analyze.should_sell(trade, sell_row.close, sell_row.date, buy_signal,
                                         sell_row.sell):
-                return \
-                    sell_row, \
-                    (
-                        pair,
-                        trade.calc_profit_percent(rate=sell_row.close),
-                        trade.calc_profit(rate=sell_row.close),
-                        (sell_row.date - buy_row.date).seconds // 60
-                    ), \
-                    sell_row.date
+
+                return BacktestResult(pair=pair,
+                                      profit_percent=trade.calc_profit_percent(rate=sell_row.close),
+                                      profit_abs=trade.calc_profit(rate=sell_row.close),
+                                      open_time=buy_row.date,
+                                      close_time=sell_row.date,
+                                      trade_duration=(sell_row.date - buy_row.date).seconds // 60,
+                                      open_index=buy_row.Index,
+                                      close_index=sell_row.Index,
+                                      open_at_end=False,
+                                      open_rate=buy_row.close,
+                                      close_rate=sell_row.close
+                                      )
+        if partial_ticker:
+            # no sell condition found - trade stil open at end of backtest period
+            sell_row = partial_ticker[-1]
+            btr = BacktestResult(pair=pair,
+                                 profit_percent=trade.calc_profit_percent(rate=sell_row.close),
+                                 profit_abs=trade.calc_profit(rate=sell_row.close),
+                                 open_time=buy_row.date,
+                                 close_time=sell_row.date,
+                                 trade_duration=(sell_row.date - buy_row.date).seconds // 60,
+                                 open_index=buy_row.Index,
+                                 close_index=sell_row.Index,
+                                 open_at_end=True,
+                                 open_rate=buy_row.close,
+                                 close_rate=sell_row.close
+                                 )
+            logger.debug('Force_selling still open trade %s with %s perc - %s', btr.pair,
+                         btr.profit_percent, btr.profit_abs)
+            return btr
         return None
 
     def backtest(self, args: Dict) -> DataFrame:
@@ -145,17 +197,12 @@ class Backtesting(object):
             processed: a processed dictionary with format {pair, data}
             max_open_trades: maximum number of concurrent trades (default: 0, disabled)
             realistic: do we try to simulate realistic trades? (default: True)
-            sell_profit_only: sell if profit only
-            use_sell_signal: act on sell-signal
         :return: DataFrame
         """
         headers = ['date', 'buy', 'open', 'close', 'sell']
         processed = args['processed']
         max_open_trades = args.get('max_open_trades', 0)
         realistic = args.get('realistic', False)
-        record = args.get('record', None)
-        recordfilename = args.get('recordfn', 'backtest-result.json')
-        records = []
         trades = []
         trade_count_lock: Dict = {}
         for pair, pair_data in processed.items():
@@ -170,6 +217,8 @@ class Backtesting(object):
 
             ticker_data.drop(ticker_data.head(1).index, inplace=True)
 
+            # Convert from Pandas to list for performance reasons
+            # (Looping Pandas is slow.)
             ticker = [x for x in ticker_data.itertuples()]
 
             lock_pair_until = None
@@ -187,28 +236,18 @@ class Backtesting(object):
 
                     trade_count_lock[row.date] = trade_count_lock.get(row.date, 0) + 1
 
-                ret = self._get_sell_trade_entry(pair, row, ticker[index + 1:],
-                                                 trade_count_lock, args)
+                trade_entry = self._get_sell_trade_entry(pair, row, ticker[index + 1:],
+                                                         trade_count_lock, args)
 
-                if ret:
-                    row2, trade_entry, next_date = ret
-                    lock_pair_until = next_date
+                if trade_entry:
+                    lock_pair_until = trade_entry.close_time
                     trades.append(trade_entry)
-                    if record:
-                        # Note, need to be json.dump friendly
-                        # record a tuple of pair, current_profit_percent,
-                        # entry-date, duration
-                        records.append((pair, trade_entry[1],
-                                        row.date.strftime('%s'),
-                                        row2.date.strftime('%s'),
-                                        index, trade_entry[3]))
-        # For now export inside backtest(), maybe change so that backtest()
-        # returns a tuple like: (dataframe, records, logs, etc)
-        if record and record.find('trades') >= 0:
-            logger.info('Dumping backtest results to %s', recordfilename)
-            file_dump_json(recordfilename, records)
-        labels = ['currency', 'profit_percent', 'profit_BTC', 'duration']
-        return DataFrame.from_records(trades, columns=labels)
+                else:
+                    # Set lock_pair_until to end of testing period if trade could not be closed
+                    # This happens only if the buy-signal was with the last candle
+                    lock_pair_until = ticker_data.iloc[-1].date
+
+        return DataFrame.from_records(trades, columns=BacktestResult._fields)
 
     def start(self) -> None:
         """
@@ -223,7 +262,7 @@ class Backtesting(object):
         if self.config.get('live'):
             logger.info('Downloading data for all pairs in whitelist ...')
             for pair in pairs:
-                data[pair] = exchange.get_ticker_history(pair, self.ticker_interval)
+                data[pair] = self.exchange.get_ticker_history(pair, self.ticker_interval)
         else:
             logger.info('Using local backtesting data (using whitelist in given config) ...')
 
@@ -234,6 +273,7 @@ class Backtesting(object):
                 pairs=pairs,
                 ticker_interval=self.ticker_interval,
                 refresh_pairs=self.config.get('refresh_pairs', False),
+                exchange=self.exchange,
                 timerange=timerange
             )
 
@@ -259,24 +299,22 @@ class Backtesting(object):
         )
 
         # Execute backtest and print results
-        sell_profit_only = self.config.get('experimental', {}).get('sell_profit_only', False)
-        use_sell_signal = self.config.get('experimental', {}).get('use_sell_signal', False)
         results = self.backtest(
             {
                 'stake_amount': self.config.get('stake_amount'),
                 'processed': preprocessed,
                 'max_open_trades': max_open_trades,
                 'realistic': self.config.get('realistic_simulation', False),
-                'sell_profit_only': sell_profit_only,
-                'use_sell_signal': use_sell_signal,
-                'record': self.config.get('export'),
-                'recordfn': self.config.get('exportfilename'),
             }
         )
+
+        if self.config.get('export', False):
+            self._store_backtest_result(self.config.get('exportfilename'), results)
+
         logger.info(
-            '\n==================================== '
+            '\n======================================== '
             'BACKTESTING REPORT'
-            ' ====================================\n'
+            ' =========================================\n'
             '%s',
             self._generate_text_table(
                 data,
@@ -284,6 +322,17 @@ class Backtesting(object):
             )
         )
 
+        logger.info(
+            '\n====================================== '
+            'LEFT OPEN TRADES REPORT'
+            ' ======================================\n'
+            '%s',
+            self._generate_text_table(
+                data,
+                results.loc[results.open_at_end]
+            )
+        )
+
 
 def setup_configuration(args: Namespace) -> Dict[str, Any]:
     """
@@ -298,6 +347,10 @@ def setup_configuration(args: Namespace) -> Dict[str, Any]:
     config['exchange']['key'] = ''
     config['exchange']['secret'] = ''
 
+    if config['stake_amount'] == constants.UNLIMITED_STAKE_AMOUNT:
+        raise DependencyException('stake amount could not be "%s" for backtesting' %
+                                  constants.UNLIMITED_STAKE_AMOUNT)
+
     return config
 
 

freqtrade/optimize/hyperopt.py

@@ -4,33 +4,33 @@
 This module contains the hyperopt logic
 """
 
-import json
 import logging
+import multiprocessing
 import os
-import pickle
-import signal
 import sys
 from argparse import Namespace
 from functools import reduce
 from math import exp
 from operator import itemgetter
-from typing import Dict, Any, Callable, Optional
+from typing import Any, Callable, Dict, List
 
-import numpy
 import talib.abstract as ta
-from hyperopt import STATUS_FAIL, STATUS_OK, Trials, fmin, hp, space_eval, tpe
-from hyperopt.mongoexp import MongoTrials
 from pandas import DataFrame
+from sklearn.externals.joblib import Parallel, delayed, dump, load
+from skopt import Optimizer
+from skopt.space import Categorical, Dimension, Integer, Real
 
 import freqtrade.vendor.qtpylib.indicators as qtpylib
 from freqtrade.arguments import Arguments
 from freqtrade.configuration import Configuration
 from freqtrade.optimize import load_data
 from freqtrade.optimize.backtesting import Backtesting
-from user_data.hyperopt_conf import hyperopt_optimize_conf
 
 logger = logging.getLogger(__name__)
 
+MAX_LOSS = 100000  # just a big enough number to be bad result in loss optimization
+TICKERDATA_PICKLE = os.path.join('user_data', 'hyperopt_tickerdata.pkl')
+
 
 class Hyperopt(Backtesting):
     """
@@ -41,13 +41,11 @@ class Hyperopt(Backtesting):
     hyperopt.start()
     """
     def __init__(self, config: Dict[str, Any]) -> None:
-
         super().__init__(config)
         # set TARGET_TRADES to suit your number concurrent trades so its realistic
         # to the number of days
         self.target_trades = 600
         self.total_tries = config.get('epochs', 0)
-        self.current_tries = 0
         self.current_best_loss = 100
 
         # max average trade duration in minutes
@@ -59,130 +57,38 @@ class Hyperopt(Backtesting):
         # check that the reported Σ% values do not exceed this!
         self.expected_max_profit = 3.0
 
-        # Configuration and data used by hyperopt
-        self.processed: Optional[Dict[str, Any]] = None
+        # Previous evaluations
+        self.trials_file = os.path.join('user_data', 'hyperopt_results.pickle')
+        self.trials: List = []
 
-        # Hyperopt Trials
-        self.trials_file = os.path.join('user_data', 'hyperopt_trials.pickle')
-        self.trials = Trials()
+    def get_args(self, params):
+        dimensions = self.hyperopt_space()
+        # Ensure the number of dimensions match
+        # the number of parameters in the list x.
+        if len(params) != len(dimensions):
+            raise ValueError('Mismatch in number of search-space dimensions. '
+                             f'len(dimensions)=={len(dimensions)} and len(x)=={len(params)}')
+
+        # Create a dict where the keys are the names of the dimensions
+        # and the values are taken from the list of parameters x.
+        arg_dict = {dim.name: value for dim, value in zip(dimensions, params)}
+        return arg_dict
 
     @staticmethod
     def populate_indicators(dataframe: DataFrame) -> DataFrame:
-        """
-        Adds several different TA indicators to the given DataFrame
-        """
         dataframe['adx'] = ta.ADX(dataframe)
-        dataframe['ao'] = qtpylib.awesome_oscillator(dataframe)
-        dataframe['cci'] = ta.CCI(dataframe)
         macd = ta.MACD(dataframe)
         dataframe['macd'] = macd['macd']
         dataframe['macdsignal'] = macd['macdsignal']
-        dataframe['macdhist'] = macd['macdhist']
         dataframe['mfi'] = ta.MFI(dataframe)
-        dataframe['minus_dm'] = ta.MINUS_DM(dataframe)
-        dataframe['minus_di'] = ta.MINUS_DI(dataframe)
-        dataframe['plus_dm'] = ta.PLUS_DM(dataframe)
-        dataframe['plus_di'] = ta.PLUS_DI(dataframe)
-        dataframe['roc'] = ta.ROC(dataframe)
         dataframe['rsi'] = ta.RSI(dataframe)
-        # Inverse Fisher transform on RSI, values [-1.0, 1.0] (https://goo.gl/2JGGoy)
-        rsi = 0.1 * (dataframe['rsi'] - 50)
-        dataframe['fisher_rsi'] = (numpy.exp(2 * rsi) - 1) / (numpy.exp(2 * rsi) + 1)
-        # Inverse Fisher transform on RSI normalized, value [0.0, 100.0] (https://goo.gl/2JGGoy)
-        dataframe['fisher_rsi_norma'] = 50 * (dataframe['fisher_rsi'] + 1)
-        # Stoch
-        stoch = ta.STOCH(dataframe)
-        dataframe['slowd'] = stoch['slowd']
-        dataframe['slowk'] = stoch['slowk']
-        # Stoch fast
         stoch_fast = ta.STOCHF(dataframe)
         dataframe['fastd'] = stoch_fast['fastd']
-        dataframe['fastk'] = stoch_fast['fastk']
-        # Stoch RSI
-        stoch_rsi = ta.STOCHRSI(dataframe)
-        dataframe['fastd_rsi'] = stoch_rsi['fastd']
-        dataframe['fastk_rsi'] = stoch_rsi['fastk']
+        dataframe['minus_di'] = ta.MINUS_DI(dataframe)
         # Bollinger bands
         bollinger = qtpylib.bollinger_bands(qtpylib.typical_price(dataframe), window=20, stds=2)
         dataframe['bb_lowerband'] = bollinger['lower']
-        dataframe['bb_middleband'] = bollinger['mid']
-        dataframe['bb_upperband'] = bollinger['upper']
-        # EMA - Exponential Moving Average
-        dataframe['ema3'] = ta.EMA(dataframe, timeperiod=3)
-        dataframe['ema5'] = ta.EMA(dataframe, timeperiod=5)
-        dataframe['ema10'] = ta.EMA(dataframe, timeperiod=10)
-        dataframe['ema50'] = ta.EMA(dataframe, timeperiod=50)
-        dataframe['ema100'] = ta.EMA(dataframe, timeperiod=100)
-        # SAR Parabolic
         dataframe['sar'] = ta.SAR(dataframe)
-        # SMA - Simple Moving Average
-        dataframe['sma'] = ta.SMA(dataframe, timeperiod=40)
-        # TEMA - Triple Exponential Moving Average
-        dataframe['tema'] = ta.TEMA(dataframe, timeperiod=9)
-        # Hilbert Transform Indicator - SineWave
-        hilbert = ta.HT_SINE(dataframe)
-        dataframe['htsine'] = hilbert['sine']
-        dataframe['htleadsine'] = hilbert['leadsine']
-
-        # Pattern Recognition - Bullish candlestick patterns
-        # ------------------------------------
-        """
-        # Hammer: values [0, 100]
-        dataframe['CDLHAMMER'] = ta.CDLHAMMER(dataframe)
-        # Inverted Hammer: values [0, 100]
-        dataframe['CDLINVERTEDHAMMER'] = ta.CDLINVERTEDHAMMER(dataframe)
-        # Dragonfly Doji: values [0, 100]
-        dataframe['CDLDRAGONFLYDOJI'] = ta.CDLDRAGONFLYDOJI(dataframe)
-        # Piercing Line: values [0, 100]
-        dataframe['CDLPIERCING'] = ta.CDLPIERCING(dataframe) # values [0, 100]
-        # Morningstar: values [0, 100]
-        dataframe['CDLMORNINGSTAR'] = ta.CDLMORNINGSTAR(dataframe) # values [0, 100]
-        # Three White Soldiers: values [0, 100]
-        dataframe['CDL3WHITESOLDIERS'] = ta.CDL3WHITESOLDIERS(dataframe) # values [0, 100]
-        """
-
-        # Pattern Recognition - Bearish candlestick patterns
-        # ------------------------------------
-        """
-        # Hanging Man: values [0, 100]
-        dataframe['CDLHANGINGMAN'] = ta.CDLHANGINGMAN(dataframe)
-        # Shooting Star: values [0, 100]
-        dataframe['CDLSHOOTINGSTAR'] = ta.CDLSHOOTINGSTAR(dataframe)
-        # Gravestone Doji: values [0, 100]
-        dataframe['CDLGRAVESTONEDOJI'] = ta.CDLGRAVESTONEDOJI(dataframe)
-        # Dark Cloud Cover: values [0, 100]
-        dataframe['CDLDARKCLOUDCOVER'] = ta.CDLDARKCLOUDCOVER(dataframe)
-        # Evening Doji Star: values [0, 100]
-        dataframe['CDLEVENINGDOJISTAR'] = ta.CDLEVENINGDOJISTAR(dataframe)
-        # Evening Star: values [0, 100]
-        dataframe['CDLEVENINGSTAR'] = ta.CDLEVENINGSTAR(dataframe)
-        """
-
-        # Pattern Recognition - Bullish/Bearish candlestick patterns
-        # ------------------------------------
-        """
-        # Three Line Strike: values [0, -100, 100]
-        dataframe['CDL3LINESTRIKE'] = ta.CDL3LINESTRIKE(dataframe)
-        # Spinning Top: values [0, -100, 100]
-        dataframe['CDLSPINNINGTOP'] = ta.CDLSPINNINGTOP(dataframe) # values [0, -100, 100]
-        # Engulfing: values [0, -100, 100]
-        dataframe['CDLENGULFING'] = ta.CDLENGULFING(dataframe) # values [0, -100, 100]
-        # Harami: values [0, -100, 100]
-        dataframe['CDLHARAMI'] = ta.CDLHARAMI(dataframe) # values [0, -100, 100]
-        # Three Outside Up/Down: values [0, -100, 100]
-        dataframe['CDL3OUTSIDE'] = ta.CDL3OUTSIDE(dataframe) # values [0, -100, 100]
-        # Three Inside Up/Down: values [0, -100, 100]
-        dataframe['CDL3INSIDE'] = ta.CDL3INSIDE(dataframe) # values [0, -100, 100]
-        """
-
-        # Chart type
-        # ------------------------------------
-        # Heikinashi stategy
-        heikinashi = qtpylib.heikinashi(dataframe)
-        dataframe['ha_open'] = heikinashi['open']
-        dataframe['ha_close'] = heikinashi['close']
-        dataframe['ha_high'] = heikinashi['high']
-        dataframe['ha_low'] = heikinashi['low']
 
         return dataframe
 
@@ -190,15 +96,16 @@ class Hyperopt(Backtesting):
         """
         Save hyperopt trials to file
         """
-        logger.info('Saving Trials to \'%s\'', self.trials_file)
-        pickle.dump(self.trials, open(self.trials_file, 'wb'))
+        if self.trials:
+            logger.info('Saving %d evaluations to \'%s\'', len(self.trials), self.trials_file)
+            dump(self.trials, self.trials_file)
 
-    def read_trials(self) -> Trials:
+    def read_trials(self) -> List:
         """
         Read hyperopt trials file
         """
         logger.info('Reading Trials from \'%s\'', self.trials_file)
-        trials = pickle.load(open(self.trials_file, 'rb'))
+        trials = load(self.trials_file)
         os.remove(self.trials_file)
         return trials
 
@@ -206,22 +113,27 @@ class Hyperopt(Backtesting):
         """
         Display Best hyperopt result
         """
-        vals = json.dumps(self.trials.best_trial['misc']['vals'], indent=4)
-        results = self.trials.best_trial['result']['result']
-        logger.info('Best result:\n%s\nwith values:\n%s', results, vals)
+        results = sorted(self.trials, key=itemgetter('loss'))
+        best_result = results[0]
+        logger.info(
+            'Best result:\n%s\nwith values:\n%s',
+            best_result['result'],
+            best_result['params']
+        )
+        if 'roi_t1' in best_result['params']:
+            logger.info('ROI table:\n%s', self.generate_roi_table(best_result['params']))
 
     def log_results(self, results) -> None:
         """
         Log results if it is better than any previous evaluation
         """
         if results['loss'] < self.current_best_loss:
+            current = results['current_tries']
+            total = results['total_tries']
+            res = results['result']
+            loss = results['loss']
             self.current_best_loss = results['loss']
-            log_msg = '\n{:5d}/{}: {}. Loss {:.5f}'.format(
-                results['current_tries'],
-                results['total_tries'],
-                results['result'],
-                results['loss']
-            )
+            log_msg = f'\n{current:5d}/{total}: {res}. Loss {loss:.5f}'
             print(log_msg)
         else:
             print('.', end='')
@@ -234,7 +146,8 @@ class Hyperopt(Backtesting):
         trade_loss = 1 - 0.25 * exp(-(trade_count - self.target_trades) ** 2 / 10 ** 5.8)
         profit_loss = max(0, 1 - total_profit / self.expected_max_profit)
         duration_loss = 0.4 * min(trade_duration / self.max_accepted_trade_duration, 1)
-        return trade_loss + profit_loss + duration_loss
+        result = trade_loss + profit_loss + duration_loss
+        return result
 
     @staticmethod
     def generate_roi_table(params: Dict) -> Dict[int, float]:
@@ -250,87 +163,44 @@ class Hyperopt(Backtesting):
         return roi_table
 
     @staticmethod
-    def roi_space() -> Dict[str, Any]:
+    def roi_space() -> List[Dimension]:
         """
         Values to search for each ROI steps
         """
-        return {
-            'roi_t1': hp.quniform('roi_t1', 10, 120, 20),
-            'roi_t2': hp.quniform('roi_t2', 10, 60, 15),
-            'roi_t3': hp.quniform('roi_t3', 10, 40, 10),
-            'roi_p1': hp.quniform('roi_p1', 0.01, 0.04, 0.01),
-            'roi_p2': hp.quniform('roi_p2', 0.01, 0.07, 0.01),
-            'roi_p3': hp.quniform('roi_p3', 0.01, 0.20, 0.01),
-        }
+        return [
+            Integer(10, 120, name='roi_t1'),
+            Integer(10, 60, name='roi_t2'),
+            Integer(10, 40, name='roi_t3'),
+            Real(0.01, 0.04, name='roi_p1'),
+            Real(0.01, 0.07, name='roi_p2'),
+            Real(0.01, 0.20, name='roi_p3'),
+        ]
 
     @staticmethod
-    def stoploss_space() -> Dict[str, Any]:
+    def stoploss_space() -> List[Dimension]:
         """
-        Stoploss Value to search
+        Stoploss search space
         """
-        return {
-            'stoploss': hp.quniform('stoploss', -0.5, -0.02, 0.02),
-        }
+        return [
+            Real(-0.5, -0.02, name='stoploss'),
+        ]
 
     @staticmethod
-    def indicator_space() -> Dict[str, Any]:
+    def indicator_space() -> List[Dimension]:
         """
         Define your Hyperopt space for searching strategy parameters
         """
-        return {
-            'macd_below_zero': hp.choice('macd_below_zero', [
-                {'enabled': False},
-                {'enabled': True}
-            ]),
-            'mfi': hp.choice('mfi', [
-                {'enabled': False},
-                {'enabled': True, 'value': hp.quniform('mfi-value', 10, 25, 5)}
-            ]),
-            'fastd': hp.choice('fastd', [
-                {'enabled': False},
-                {'enabled': True, 'value': hp.quniform('fastd-value', 15, 45, 5)}
-            ]),
-            'adx': hp.choice('adx', [
-                {'enabled': False},
-                {'enabled': True, 'value': hp.quniform('adx-value', 20, 50, 5)}
-            ]),
-            'rsi': hp.choice('rsi', [
-                {'enabled': False},
-                {'enabled': True, 'value': hp.quniform('rsi-value', 20, 40, 5)}
-            ]),
-            'uptrend_long_ema': hp.choice('uptrend_long_ema', [
-                {'enabled': False},
-                {'enabled': True}
-            ]),
-            'uptrend_short_ema': hp.choice('uptrend_short_ema', [
-                {'enabled': False},
-                {'enabled': True}
-            ]),
-            'over_sar': hp.choice('over_sar', [
-                {'enabled': False},
-                {'enabled': True}
-            ]),
-            'green_candle': hp.choice('green_candle', [
-                {'enabled': False},
-                {'enabled': True}
-            ]),
-            'uptrend_sma': hp.choice('uptrend_sma', [
-                {'enabled': False},
-                {'enabled': True}
-            ]),
-            'trigger': hp.choice('trigger', [
-                {'type': 'lower_bb'},
-                {'type': 'lower_bb_tema'},
-                {'type': 'faststoch10'},
-                {'type': 'ao_cross_zero'},
-                {'type': 'ema3_cross_ema10'},
-                {'type': 'macd_cross_signal'},
-                {'type': 'sar_reversal'},
-                {'type': 'ht_sine'},
-                {'type': 'heiken_reversal_bull'},
-                {'type': 'di_cross'},
-            ]),
-        }
+        return [
+            Integer(10, 25, name='mfi-value'),
+            Integer(15, 45, name='fastd-value'),
+            Integer(20, 50, name='adx-value'),
+            Integer(20, 40, name='rsi-value'),
+            Categorical([True, False], name='mfi-enabled'),
+            Categorical([True, False], name='fastd-enabled'),
+            Categorical([True, False], name='adx-enabled'),
+            Categorical([True, False], name='rsi-enabled'),
+            Categorical(['bb_lower', 'macd_cross_signal', 'sar_reversal'], name='trigger')
+        ]
 
     def has_space(self, space: str) -> bool:
         """
@@ -340,17 +210,17 @@ class Hyperopt(Backtesting):
             return True
         return False
 
-    def hyperopt_space(self) -> Dict[str, Any]:
+    def hyperopt_space(self) -> List[Dimension]:
         """
         Return the space to use during Hyperopt
         """
-        spaces: Dict = {}
+        spaces: List[Dimension] = []
         if self.has_space('buy'):
-            spaces = {**spaces, **Hyperopt.indicator_space()}
+            spaces += Hyperopt.indicator_space()
         if self.has_space('roi'):
-            spaces = {**spaces, **Hyperopt.roi_space()}
+            spaces += Hyperopt.roi_space()
         if self.has_space('stoploss'):
-            spaces = {**spaces, **Hyperopt.stoploss_space()}
+            spaces += Hyperopt.stoploss_space()
         return spaces
 
     @staticmethod
@@ -364,63 +234,26 @@ class Hyperopt(Backtesting):
             """
             conditions = []
             # GUARDS AND TRENDS
-            if 'uptrend_long_ema' in params and params['uptrend_long_ema']['enabled']:
-                conditions.append(dataframe['ema50'] > dataframe['ema100'])
-            if 'macd_below_zero' in params and params['macd_below_zero']['enabled']:
-                conditions.append(dataframe['macd'] < 0)
-            if 'uptrend_short_ema' in params and params['uptrend_short_ema']['enabled']:
-                conditions.append(dataframe['ema5'] > dataframe['ema10'])
-            if 'mfi' in params and params['mfi']['enabled']:
-                conditions.append(dataframe['mfi'] < params['mfi']['value'])
-            if 'fastd' in params and params['fastd']['enabled']:
-                conditions.append(dataframe['fastd'] < params['fastd']['value'])
-            if 'adx' in params and params['adx']['enabled']:
-                conditions.append(dataframe['adx'] > params['adx']['value'])
-            if 'rsi' in params and params['rsi']['enabled']:
-                conditions.append(dataframe['rsi'] < params['rsi']['value'])
-            if 'over_sar' in params and params['over_sar']['enabled']:
-                conditions.append(dataframe['close'] > dataframe['sar'])
-            if 'green_candle' in params and params['green_candle']['enabled']:
-                conditions.append(dataframe['close'] > dataframe['open'])
-            if 'uptrend_sma' in params and params['uptrend_sma']['enabled']:
-                prevsma = dataframe['sma'].shift(1)
-                conditions.append(dataframe['sma'] > prevsma)
+            if 'mfi-enabled' in params and params['mfi-enabled']:
+                conditions.append(dataframe['mfi'] < params['mfi-value'])
+            if 'fastd-enabled' in params and params['fastd-enabled']:
+                conditions.append(dataframe['fastd'] < params['fastd-value'])
+            if 'adx-enabled' in params and params['adx-enabled']:
+                conditions.append(dataframe['adx'] > params['adx-value'])
+            if 'rsi-enabled' in params and params['rsi-enabled']:
+                conditions.append(dataframe['rsi'] < params['rsi-value'])
 
             # TRIGGERS
-            triggers = {
-                'lower_bb': (
-                    dataframe['close'] < dataframe['bb_lowerband']
-                ),
-                'lower_bb_tema': (
-                    dataframe['tema'] < dataframe['bb_lowerband']
-                ),
-                'faststoch10': (qtpylib.crossed_above(
-                    dataframe['fastd'], 10.0
-                )),
-                'ao_cross_zero': (qtpylib.crossed_above(
-                    dataframe['ao'], 0.0
-                )),
-                'ema3_cross_ema10': (qtpylib.crossed_above(
-                    dataframe['ema3'], dataframe['ema10']
-                )),
-                'macd_cross_signal': (qtpylib.crossed_above(
+            if params['trigger'] == 'bb_lower':
+                conditions.append(dataframe['close'] < dataframe['bb_lowerband'])
+            if params['trigger'] == 'macd_cross_signal':
+                conditions.append(qtpylib.crossed_above(
                     dataframe['macd'], dataframe['macdsignal']
-                )),
-                'sar_reversal': (qtpylib.crossed_above(
+                ))
+            if params['trigger'] == 'sar_reversal':
+                conditions.append(qtpylib.crossed_above(
                     dataframe['close'], dataframe['sar']
-                )),
-                'ht_sine': (qtpylib.crossed_above(
-                    dataframe['htleadsine'], dataframe['htsine']
-                )),
-                'heiken_reversal_bull': (
-                    (qtpylib.crossed_above(dataframe['ha_close'], dataframe['ha_open'])) &
-                    (dataframe['ha_low'] == dataframe['ha_open'])
-                ),
-                'di_cross': (qtpylib.crossed_above(
-                    dataframe['plus_di'], dataframe['minus_di']
-                )),
-            }
-            conditions.append(triggers.get(params['trigger']['type']))
+                ))
 
             dataframe.loc[
                 reduce(lambda x, y: x & y, conditions),
@@ -430,7 +263,9 @@ class Hyperopt(Backtesting):
 
         return populate_buy_trend
 
-    def generate_optimizer(self, params: Dict) -> Dict:
+    def generate_optimizer(self, _params) -> Dict:
+        params = self.get_args(_params)
+
         if self.has_space('roi'):
             self.analyze.strategy.minimal_roi = self.generate_roi_table(params)
 
@@ -440,10 +275,11 @@ class Hyperopt(Backtesting):
         if self.has_space('stoploss'):
             self.analyze.strategy.stoploss = params['stoploss']
 
+        processed = load(TICKERDATA_PICKLE)
         results = self.backtest(
             {
                 'stake_amount': self.config['stake_amount'],
-                'processed': self.processed,
+                'processed': processed,
                 'realistic': self.config.get('realistic_simulation', False),
             }
         )
@@ -451,32 +287,20 @@ class Hyperopt(Backtesting):
 
         total_profit = results.profit_percent.sum()
         trade_count = len(results.index)
-        trade_duration = results.duration.mean()
+        trade_duration = results.trade_duration.mean()
 
-        if trade_count == 0 or trade_duration > self.max_accepted_trade_duration:
-            print('.', end='')
-            sys.stdout.flush()
+        if trade_count == 0:
             return {
-                'status': STATUS_FAIL,
-                'loss': float('inf')
+                'loss': MAX_LOSS,
+                'params': params,
+                'result': result_explanation,
             }
 
         loss = self.calculate_loss(total_profit, trade_count, trade_duration)
 
-        self.current_tries += 1
-
-        self.log_results(
-            {
-                'loss': loss,
-                'current_tries': self.current_tries,
-                'total_tries': self.total_tries,
-                'result': result_explanation,
-            }
-        )
-
         return {
             'loss': loss,
-            'status': STATUS_OK,
+            'params': params,
             'result': result_explanation,
         }
 
@@ -484,15 +308,37 @@ class Hyperopt(Backtesting):
         """
         Return the format result in a string
         """
-        return ('{:6d} trades. Avg profit {: 5.2f}%. '
-                'Total profit {: 11.8f} {} ({:.4f}Σ%). Avg duration {:5.1f} mins.').format(
-                    len(results.index),
-                    results.profit_percent.mean() * 100.0,
-                    results.profit_BTC.sum(),
-                    self.config['stake_currency'],
-                    results.profit_percent.sum(),
-                    results.duration.mean(),
-                )
+        trades = len(results.index)
+        avg_profit = results.profit_percent.mean() * 100.0
+        total_profit = results.profit_abs.sum()
+        stake_cur = self.config['stake_currency']
+        profit = results.profit_percent.sum()
+        duration = results.trade_duration.mean()
+
+        return (f'{trades:6d} trades. Avg profit {avg_profit: 5.2f}%. '
+                f'Total profit {total_profit: 11.8f} {stake_cur} '
+                f'({profit:.4f}Σ%). Avg duration {duration:5.1f} mins.')
+
+    def get_optimizer(self, cpu_count) -> Optimizer:
+        return Optimizer(
+            self.hyperopt_space(),
+            base_estimator="ET",
+            acq_optimizer="auto",
+            n_initial_points=30,
+            acq_optimizer_kwargs={'n_jobs': cpu_count}
+        )
+
+    def run_optimizer_parallel(self, parallel, asked) -> List:
+        return parallel(delayed(self.generate_optimizer)(v) for v in asked)
+
+    def load_previous_results(self):
+        """ read trials file if we have one """
+        if os.path.exists(self.trials_file) and os.path.getsize(self.trials_file) > 0:
+            self.trials = self.read_trials()
+            logger.info(
+                'Loaded %d previous evaluations from disk.',
+                len(self.trials)
+            )
 
     def start(self) -> None:
         timerange = Arguments.parse_timerange(None if self.config.get(
@@ -506,79 +352,35 @@ class Hyperopt(Backtesting):
 
         if self.has_space('buy'):
             self.analyze.populate_indicators = Hyperopt.populate_indicators  # type: ignore
-        self.processed = self.tickerdata_to_dataframe(data)
+        dump(self.tickerdata_to_dataframe(data), TICKERDATA_PICKLE)
+        self.exchange = None  # type: ignore
+        self.load_previous_results()
 
-        if self.config.get('mongodb'):
-            logger.info('Using mongodb ...')
-            logger.info(
-                'Start scripts/start-mongodb.sh and start-hyperopt-worker.sh manually!'
-            )
-
-            db_name = 'freqtrade_hyperopt'
-            self.trials = MongoTrials(
-                arg='mongo://127.0.0.1:1234/{}/jobs'.format(db_name),
-                exp_key='exp1'
-            )
-        else:
-            logger.info('Preparing Trials..')
-            signal.signal(signal.SIGINT, self.signal_handler)
-            # read trials file if we have one
-            if os.path.exists(self.trials_file) and os.path.getsize(self.trials_file) > 0:
-                self.trials = self.read_trials()
-
-                self.current_tries = len(self.trials.results)
-                self.total_tries += self.current_tries
-                logger.info(
-                    'Continuing with trials. Current: %d, Total: %d',
-                    self.current_tries,
-                    self.total_tries
-                )
+        cpus = multiprocessing.cpu_count()
+        logger.info(f'Found {cpus} CPU cores. Let\'s make them scream!')
 
+        opt = self.get_optimizer(cpus)
+        EVALS = max(self.total_tries//cpus, 1)
         try:
-            best_parameters = fmin(
-                fn=self.generate_optimizer,
-                space=self.hyperopt_space(),
-                algo=tpe.suggest,
-                max_evals=self.total_tries,
-                trials=self.trials
-            )
+            with Parallel(n_jobs=cpus) as parallel:
+                for i in range(EVALS):
+                    asked = opt.ask(n_points=cpus)
+                    f_val = self.run_optimizer_parallel(parallel, asked)
+                    opt.tell(asked, [i['loss'] for i in f_val])
 
-            results = sorted(self.trials.results, key=itemgetter('loss'))
-            best_result = results[0]['result']
-
-        except ValueError:
-            best_parameters = {}
-            best_result = 'Sorry, Hyperopt was not able to find good parameters. Please ' \
-                          'try with more epochs (param: -e).'
-
-        # Improve best parameter logging display
-        if best_parameters:
-            best_parameters = space_eval(
-                self.hyperopt_space(),
-                best_parameters
-            )
-
-        logger.info('Best parameters:\n%s', json.dumps(best_parameters, indent=4))
-        if 'roi_t1' in best_parameters:
-            logger.info('ROI table:\n%s', self.generate_roi_table(best_parameters))
-
-        logger.info('Best Result:\n%s', best_result)
-
-        # Store trials result to file to resume next time
-        self.save_trials()
-
-    def signal_handler(self, sig, frame) -> None:
-        """
-        Hyperopt SIGINT handler
-        """
-        logger.info(
-            'Hyperopt received %s',
-            signal.Signals(sig).name
-        )
+                    self.trials += f_val
+                    for j in range(cpus):
+                        self.log_results({
+                            'loss': f_val[j]['loss'],
+                            'current_tries': i * cpus + j,
+                            'total_tries': self.total_tries,
+                            'result': f_val[j]['result'],
+                        })
+        except KeyboardInterrupt:
+            print('User interrupted..')
 
         self.save_trials()
         self.log_trials_result()
-        sys.exit(0)
 
 
 def start(args: Namespace) -> None:
@@ -589,18 +391,14 @@ def start(args: Namespace) -> None:
     """
 
     # Remove noisy log messages
-    logging.getLogger('hyperopt.mongoexp').setLevel(logging.WARNING)
     logging.getLogger('hyperopt.tpe').setLevel(logging.WARNING)
 
     # Initialize configuration
     # Monkey patch the configuration with hyperopt_conf.py
     configuration = Configuration(args)
     logger.info('Starting freqtrade in Hyperopt mode')
+    config = configuration.load_config()
 
-    optimize_config = hyperopt_optimize_conf()
-    config = configuration._load_common_config(optimize_config)
-    config = configuration._load_backtesting_config(config)
-    config = configuration._load_hyperopt_config(config)
     config['exchange']['key'] = ''
     config['exchange']['secret'] = ''
 

freqtrade/persistence.py

@@ -5,12 +5,11 @@ This module contains the class to persist trades into SQLite
 import logging
 from datetime import datetime
 from decimal import Decimal, getcontext
-from typing import Dict, Optional, Any
+from typing import Any, Dict, Optional
 
 import arrow
 from sqlalchemy import (Boolean, Column, DateTime, Float, Integer, String,
-                        create_engine)
-from sqlalchemy import inspect
+                        create_engine, inspect)
 from sqlalchemy.exc import NoSuchModuleError
 from sqlalchemy.ext.declarative import declarative_base
 from sqlalchemy.orm.scoping import scoped_session
@@ -21,8 +20,8 @@ from freqtrade import OperationalException
 
 logger = logging.getLogger(__name__)
 
-_CONF = {}
 _DECL_BASE: Any = declarative_base()
+_SQL_DOCS_URL = 'http://docs.sqlalchemy.org/en/latest/core/engines.html#database-urls'
 
 
 def init(config: Dict) -> None:
@@ -33,9 +32,7 @@ def init(config: Dict) -> None:
     :param config: config to use
     :return: None
     """
-    _CONF.update(config)
-
-    db_url = _CONF.get('db_url', None)
+    db_url = config.get('db_url', None)
     kwargs = {}
 
     # Take care of thread ownership if in-memory db
@@ -49,10 +46,8 @@ def init(config: Dict) -> None:
     try:
         engine = create_engine(db_url, **kwargs)
     except NoSuchModuleError:
-        error = 'Given value for db_url: \'{}\' is no valid database URL! (See {}).'.format(
-            db_url, 'http://docs.sqlalchemy.org/en/latest/core/engines.html#database-urls'
-        )
-        raise OperationalException(error)
+        raise OperationalException(f'Given value for db_url: \'{db_url}\' '
+                                   f'is no valid database URL! (See {_SQL_DOCS_URL})')
 
     session = scoped_session(sessionmaker(bind=engine, autoflush=True, autocommit=True))
     Trade.session = session()
@@ -61,7 +56,7 @@ def init(config: Dict) -> None:
     check_migrate(engine)
 
     # Clean dry_run DB if the db is not in-memory
-    if _CONF.get('dry_run', False) and db_url != 'sqlite://':
+    if config.get('dry_run', False) and db_url != 'sqlite://':
         clean_dry_run_db()
 
 
@@ -69,6 +64,10 @@ def has_column(columns, searchname: str) -> bool:
     return len(list(filter(lambda x: x["name"] == searchname, columns))) == 1
 
 
+def get_column_def(columns, column: str, default: str) -> str:
+    return default if not has_column(columns, column) else column
+
+
 def check_migrate(engine) -> None:
     """
     Checks if migration is necessary and migrates if necessary
@@ -76,18 +75,32 @@ def check_migrate(engine) -> None:
     inspector = inspect(engine)
 
     cols = inspector.get_columns('trades')
+    tabs = inspector.get_table_names()
+    table_back_name = 'trades_bak'
+    for i, table_back_name in enumerate(tabs):
+        table_back_name = f'trades_bak{i}'
+        logger.info(f'trying {table_back_name}')
+
+    # Check for latest column
+    if not has_column(cols, 'max_rate'):
+        open_rate_requested = get_column_def(cols, 'open_rate_requested', 'null')
+        close_rate_requested = get_column_def(cols, 'close_rate_requested', 'null')
+        stop_loss = get_column_def(cols, 'stop_loss', '0.0')
+        initial_stop_loss = get_column_def(cols, 'initial_stop_loss', '0.0')
+        max_rate = get_column_def(cols, 'max_rate', '0.0')
 
-    if not has_column(cols, 'fee_open'):
         # Schema migration necessary
-        engine.execute("alter table trades rename to trades_bak")
+        engine.execute(f"alter table trades rename to {table_back_name}")
         # let SQLAlchemy create the schema as required
         _DECL_BASE.metadata.create_all(engine)
 
         # Copy data back - following the correct schema
-        engine.execute("""insert into trades
+        engine.execute(f"""insert into trades
                 (id, exchange, pair, is_open, fee_open, fee_close, open_rate,
                 open_rate_requested, close_rate, close_rate_requested, close_profit,
-                stake_amount, amount, open_date, close_date, open_order_id)
+                stake_amount, amount, open_date, close_date, open_order_id,
+                stop_loss, initial_stop_loss, max_rate
+                )
             select id, lower(exchange),
                 case
                     when instr(pair, '_') != 0 then
@@ -97,21 +110,18 @@ def check_migrate(engine) -> None:
                     end
                 pair,
                 is_open, fee fee_open, fee fee_close,
-                open_rate, null open_rate_requested, close_rate,
-                null close_rate_requested, close_profit,
-                stake_amount, amount, open_date, close_date, open_order_id
-                from trades_bak
+                open_rate, {open_rate_requested} open_rate_requested, close_rate,
+                {close_rate_requested} close_rate_requested, close_profit,
+                stake_amount, amount, open_date, close_date, open_order_id,
+                {stop_loss} stop_loss, {initial_stop_loss} initial_stop_loss,
+                {max_rate} max_rate
+                from {table_back_name}
              """)
 
         # Reread columns - the above recreated the table!
         inspector = inspect(engine)
         cols = inspector.get_columns('trades')
 
-    if not has_column(cols, 'open_rate_requested'):
-        engine.execute("alter table trades add open_rate_requested float")
-    if not has_column(cols, 'close_rate_requested'):
-        engine.execute("alter table trades add close_rate_requested float")
-
 
 def cleanup() -> None:
     """
@@ -154,15 +164,57 @@ class Trade(_DECL_BASE):
     open_date = Column(DateTime, nullable=False, default=datetime.utcnow)
     close_date = Column(DateTime)
     open_order_id = Column(String)
+    # absolute value of the stop loss
+    stop_loss = Column(Float, nullable=True, default=0.0)
+    # absolute value of the initial stop loss
+    initial_stop_loss = Column(Float, nullable=True, default=0.0)
+    # absolute value of the highest reached price
+    max_rate = Column(Float, nullable=True, default=0.0)
 
     def __repr__(self):
-        return 'Trade(id={}, pair={}, amount={:.8f}, open_rate={:.8f}, open_since={})'.format(
-            self.id,
-            self.pair,
-            self.amount,
-            self.open_rate,
-            arrow.get(self.open_date).humanize() if self.is_open else 'closed'
-        )
+        open_since = arrow.get(self.open_date).humanize() if self.is_open else 'closed'
+
+        return (f'Trade(id={self.id}, pair={self.pair}, amount={self.amount:.8f}, '
+                f'open_rate={self.open_rate:.8f}, open_since={open_since})')
+
+    def adjust_stop_loss(self, current_price: float, stoploss: float, initial: bool = False):
+        """this adjusts the stop loss to it's most recently observed setting"""
+
+        if initial and not (self.stop_loss is None or self.stop_loss == 0):
+            # Don't modify if called with initial and nothing to do
+            return
+
+        new_loss = float(current_price * (1 - abs(stoploss)))
+
+        # keeping track of the highest observed rate for this trade
+        if self.max_rate is None:
+            self.max_rate = current_price
+        else:
+            if current_price > self.max_rate:
+                self.max_rate = current_price
+
+        # no stop loss assigned yet
+        if not self.stop_loss:
+            logger.debug("assigning new stop loss")
+            self.stop_loss = new_loss
+            self.initial_stop_loss = new_loss
+
+        # evaluate if the stop loss needs to be updated
+        else:
+            if new_loss > self.stop_loss:  # stop losses only walk up, never down!
+                self.stop_loss = new_loss
+                logger.debug("adjusted stop loss")
+            else:
+                logger.debug("keeping current stop loss")
+
+        logger.debug(
+            f"{self.pair} - current price {current_price:.8f}, "
+            f"bought at {self.open_rate:.8f} and calculated "
+            f"stop loss is at: {self.initial_stop_loss:.8f} initial "
+            f"stop at {self.stop_loss:.8f}. "
+            f"trailing stop loss saved us: "
+            f"{float(self.stop_loss) - float(self.initial_stop_loss):.8f} "
+            f"and max observed rate was {self.max_rate:.8f}")
 
     def update(self, order: Dict) -> None:
         """
@@ -170,6 +222,7 @@ class Trade(_DECL_BASE):
         :param order: order retrieved by exchange.get_order()
         :return: None
         """
+        order_type = order['type']
         # Ignore open and cancelled orders
         if order['status'] == 'open' or order['price'] is None:
             return
@@ -177,16 +230,16 @@ class Trade(_DECL_BASE):
         logger.info('Updating trade (id=%d) ...', self.id)
 
         getcontext().prec = 8  # Bittrex do not go above 8 decimal
-        if order['type'] == 'limit' and order['side'] == 'buy':
+        if order_type == 'limit' and order['side'] == 'buy':
             # Update open rate and actual amount
             self.open_rate = Decimal(order['price'])
             self.amount = Decimal(order['amount'])
             logger.info('LIMIT_BUY has been fulfilled for %s.', self)
             self.open_order_id = None
-        elif order['type'] == 'limit' and order['side'] == 'sell':
+        elif order_type == 'limit' and order['side'] == 'sell':
             self.close(order['price'])
         else:
-            raise ValueError('Unknown order type: {}'.format(order['type']))
+            raise ValueError(f'Unknown order type: {order_type}')
         cleanup()
 
     def close(self, rate: float) -> None:
@@ -257,7 +310,8 @@ class Trade(_DECL_BASE):
             rate=(rate or self.close_rate),
             fee=(fee or self.fee_close)
         )
-        return float("{0:.8f}".format(close_trade_price - open_trade_price))
+        profit = close_trade_price - open_trade_price
+        return float(f"{profit:.8f}")
 
     def calc_profit_percent(
             self,
@@ -277,5 +331,5 @@ class Trade(_DECL_BASE):
             rate=(rate or self.close_rate),
             fee=(fee or self.fee_close)
         )
-
-        return float("{0:.8f}".format((close_trade_price / open_trade_price) - 1))
+        profit_percent = (close_trade_price / open_trade_price) - 1
+        return float(f"{profit_percent:.8f}")

freqtrade/rpc/rpc.py

@@ -2,24 +2,33 @@
 This module contains class to define a RPC communications
 """
 import logging
-from datetime import datetime, timedelta, date
+from abc import abstractmethod
+from datetime import date, datetime, timedelta
 from decimal import Decimal
-from typing import Dict, Tuple, Any
+from typing import Any, Dict, List, Tuple
 
 import arrow
 import sqlalchemy as sql
-from pandas import DataFrame
 from numpy import mean, nan_to_num
+from pandas import DataFrame
 
-from freqtrade import exchange
 from freqtrade.misc import shorten_date
 from freqtrade.persistence import Trade
 from freqtrade.state import State
 
-
 logger = logging.getLogger(__name__)
 
 
+class RPCException(Exception):
+    """
+    Should be raised with a rpc-formatted message in an _rpc_* method
+    if the required state is wrong, i.e.:
+
+    raise RPCException('*Status:* `no active trade`')
+    """
+    pass
+
+
 class RPC(object):
     """
     RPC class can be used to have extra feature, like bot data, and access to DB data
@@ -30,97 +39,104 @@ class RPC(object):
         :param freqtrade: Instance of a freqtrade bot
         :return: None
         """
-        self.freqtrade = freqtrade
+        self._freqtrade = freqtrade
 
-    def rpc_trade_status(self) -> Tuple[bool, Any]:
+    @abstractmethod
+    def cleanup(self) -> None:
+        """ Cleanup pending module resources """
+
+    @property
+    @abstractmethod
+    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) -> 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`'
+        if self._freqtrade.state != State.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:
                 order = None
                 if trade.open_order_id:
-                    order = exchange.get_order(trade.open_order_id, trade.pair)
+                    order = self._freqtrade.exchange.get_order(trade.open_order_id, trade.pair)
                 # calculate profit and send message to user
-                current_rate = exchange.get_ticker(trade.pair, False)['bid']
+                current_rate = self._freqtrade.exchange.get_ticker(trade.pair, False)['bid']
                 current_profit = trade.calc_profit_percent(current_rate)
-                fmt_close_profit = '{:.2f}%'.format(
-                    round(trade.close_profit * 100, 2)
-                ) if trade.close_profit else None
-                message = "*Trade ID:* `{trade_id}`\n" \
-                          "*Current Pair:* [{pair}]({market_url})\n" \
-                          "*Open Since:* `{date}`\n" \
-                          "*Amount:* `{amount}`\n" \
-                          "*Open Rate:* `{open_rate:.8f}`\n" \
-                          "*Close Rate:* `{close_rate}`\n" \
-                          "*Current Rate:* `{current_rate:.8f}`\n" \
-                          "*Close Profit:* `{close_profit}`\n" \
-                          "*Current Profit:* `{current_profit:.2f}%`\n" \
-                          "*Open Order:* `{open_order}`"\
-                          .format(
-                              trade_id=trade.id,
-                              pair=trade.pair,
-                              market_url=exchange.get_pair_detail_url(trade.pair),
-                              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=fmt_close_profit,
-                              current_profit=round(current_profit * 100, 2),
-                              open_order='({} {} rem={:.8f})'.format(
-                                  order['type'], order['side'], order['remaining']
-                              ) if order else None,
-                          )
-                result.append(message)
-            return False, result
+                fmt_close_profit = (f'{round(trade.close_profit * 100, 2):.2f}%'
+                                    if trade.close_profit else None)
+                market_url = self._freqtrade.exchange.get_pair_detail_url(trade.pair)
+                trade_date = arrow.get(trade.open_date).humanize()
+                open_rate = trade.open_rate
+                close_rate = trade.close_rate
+                amount = round(trade.amount, 8)
+                current_profit = round(current_profit * 100, 2)
+                open_order = ''
+                if order:
+                    order_type = order['type']
+                    order_side = order['side']
+                    order_rem = order['remaining']
+                    open_order = f'({order_type} {order_side} rem={order_rem:.8f})'
 
-    def rpc_status_table(self) -> Tuple[bool, Any]:
+                message = f"*Trade ID:* `{trade.id}`\n" \
+                          f"*Current Pair:* [{trade.pair}]({market_url})\n" \
+                          f"*Open Since:* `{trade_date}`\n" \
+                          f"*Amount:* `{amount}`\n" \
+                          f"*Open Rate:* `{open_rate:.8f}`\n" \
+                          f"*Close Rate:* `{close_rate}`\n" \
+                          f"*Current Rate:* `{current_rate:.8f}`\n" \
+                          f"*Close Profit:* `{fmt_close_profit}`\n" \
+                          f"*Current Profit:* `{current_profit:.2f}%`\n" \
+                          f"*Open Order:* `{open_order}`"\
+
+                result.append(message)
+            return result
+
+    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`'
+        if self._freqtrade.state != State.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:
                 # calculate profit and send message to user
-                current_rate = exchange.get_ticker(trade.pair, False)['bid']
+                current_rate = self._freqtrade.exchange.get_ticker(trade.pair, False)['bid']
+                trade_perc = (100 * trade.calc_profit_percent(current_rate))
                 trades_list.append([
                     trade.id,
                     trade.pair,
                     shorten_date(arrow.get(trade.open_date).humanize(only_distance=True)),
-                    '{:.2f}%'.format(100 * trade.calc_profit_percent(current_rate))
+                    f'{trade_perc:.2f}%'
                 ])
 
             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
+        fiat = self._freqtrade.fiat_converter
         for day in range(0, timescale):
             profitday = today - timedelta(days=day)
             trades = Trade.query \
@@ -131,11 +147,11 @@ class RPC(object):
                 .all()
             curdayprofit = sum(trade.calc_profit() for trade in trades)
             profit_days[profitday] = {
-                'amount': format(curdayprofit, '.8f'),
+                'amount': f'{curdayprofit:.8f}',
                 'trades': len(trades)
             }
 
-        stats = [
+        return [
             [
                 key,
                 '{value:.8f} {symbol}'.format(
@@ -157,13 +173,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 = []
@@ -186,7 +199,7 @@ class RPC(object):
                 profit_closed_percent.append(profit_percent)
             else:
                 # Get current rate
-                current_rate = exchange.get_ticker(trade.pair, False)['bid']
+                current_rate = self._freqtrade.exchange.get_ticker(trade.pair, False)['bid']
                 profit_percent = trade.calc_profit_percent(rate=current_rate)
 
             profit_all_coin.append(
@@ -201,13 +214,13 @@ 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
 
         # FIX: we want to keep fiatconverter in a state/environment,
         #      doing this will utilize its caching functionallity, instead we reinitialize it here
-        fiat = self.freqtrade.fiat_converter
+        fiat = self._freqtrade.fiat_converter
         # Prepare data to display
         profit_closed_coin = round(sum(profit_closed_coin), 8)
         profit_closed_percent = round(nan_to_num(mean(profit_closed_percent)) * 100, 2)
@@ -224,42 +237,36 @@ 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():
+        for coin, balance in self._freqtrade.exchange.get_balances().items():
             if not balance['total']:
                 continue
 
-            rate = None
             if coin == 'BTC':
                 rate = 1.0
             else:
                 if coin == 'USDT':
-                    rate = 1.0 / exchange.get_ticker('BTC/USDT', False)['bid']
+                    rate = 1.0 / self._freqtrade.exchange.get_ticker('BTC/USDT', False)['bid']
                 else:
-                    rate = exchange.get_ticker(coin + '/BTC', False)['bid']
+                    rate = self._freqtrade.exchange.get_ticker(coin + '/BTC', False)['bid']
             est_btc: float = rate * balance['total']
             total = total + est_btc
             output.append(
@@ -272,55 +279,50 @@ class RPC(object):
                 }
             )
         if total == 0.0:
-            return True, '`All balances are zero.`'
+            raise RPCException('`All balances are zero.`')
 
-        fiat = self.freqtrade.fiat_converter
+        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.
-        """
-        if self.freqtrade.state == State.RUNNING:
-            return True, '*Status:* `already running`'
+    def _rpc_start(self) -> str:
+        """ Handler for start """
+        if self._freqtrade.state == State.RUNNING:
+            return '*Status:* `already running`'
 
-        self.freqtrade.state = State.RUNNING
-        return False, '`Starting trader ...`'
+        self._freqtrade.state = State.RUNNING
+        return '`Starting trader ...`'
 
-    def rpc_stop(self) -> Tuple[bool, str]:
-        """
-        Handler for stop.
-        """
-        if self.freqtrade.state == State.RUNNING:
-            self.freqtrade.state = State.STOPPED
-            return False, '`Stopping trader ...`'
+    def _rpc_stop(self) -> str:
+        """ Handler for stop """
+        if self._freqtrade.state == State.RUNNING:
+            self._freqtrade.state = State.STOPPED
+            return '`Stopping trader ...`'
 
-        return True, '*Status:* `already stopped`'
+        return '*Status:* `already stopped`'
 
-    def rpc_reload_conf(self) -> str:
+    def _rpc_reload_conf(self) -> str:
         """ Handler for reload_conf. """
-        self.freqtrade.state = State.RELOAD_CONF
+        self._freqtrade.state = State.RELOAD_CONF
         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
             if trade.open_order_id:
-                order = exchange.get_order(trade.open_order_id, trade.pair)
+                order = self._freqtrade.exchange.get_order(trade.open_order_id, trade.pair)
 
                 # Cancel open LIMIT_BUY orders and close trade
                 if order and order['status'] == 'open' \
                         and order['type'] == 'limit' \
                         and order['side'] == 'buy':
-                    exchange.cancel_order(trade.open_order_id, trade.pair)
+                    self._freqtrade.exchange.cancel_order(trade.open_order_id, trade.pair)
                     trade.close(order.get('price') or trade.open_rate)
                     # Do the best effort, if we don't know 'filled' amount, don't try selling
                     if order['filled'] is None:
@@ -334,18 +336,18 @@ class RPC(object):
                     return
 
             # Get current rate and execute sell
-            current_rate = exchange.get_ticker(trade.pair, False)['bid']
-            self.freqtrade.execute_sell(trade, current_rate)
+            current_rate = self._freqtrade.exchange.get_ticker(trade.pair, False)['bid']
+            self._freqtrade.execute_sell(trade, current_rate)
         # ---- EOF def _exec_forcesell ----
 
-        if self.freqtrade.state != State.RUNNING:
-            return True, '`trader is not running`'
+        if self._freqtrade.state != State.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(
@@ -356,19 +358,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`'
+        if self._freqtrade.state != State.RUNNING:
+            raise RPCException('`trader is not running`')
 
         pair_rates = Trade.session.query(Trade.pair,
                                          sql.func.sum(Trade.close_profit).label('profit_sum'),
@@ -377,19 +378,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) -> List[Trade]:
+        """ Returns the number of trades running """
+        if self._freqtrade.state != State.RUNNING:
+            raise RPCException('`trader is not running`')
 
-    def rpc_count(self) -> Tuple[bool, Any]:
-        """
-        Returns the number of trades running
-        :return: None
-        """
-        if self.freqtrade.state != State.RUNNING:
-            return True, '`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/rpc_manager.py

@@ -1,11 +1,10 @@
 """
 This module contains class to manage RPC communications (Telegram, Slack, ...)
 """
-from typing import Any, List
 import logging
+from typing import List
 
-from freqtrade.rpc.telegram import Telegram
-
+from freqtrade.rpc.rpc import RPC
 
 logger = logging.getLogger(__name__)
 
@@ -15,36 +14,23 @@ class RPCManager(object):
     Class to manage RPC objects (Telegram, Slack, ...)
     """
     def __init__(self, freqtrade) -> None:
-        """
-        Initializes all enabled rpc modules
-        :param config: config to use
-        :return: None
-        """
-        self.freqtrade = freqtrade
+        """ Initializes all enabled rpc modules """
+        self.registered_modules: List[RPC] = []
 
-        self.registered_modules: List[str] = []
-        self.telegram: Any = None
-        self._init()
-
-    def _init(self) -> None:
-        """
-        Init RPC modules
-        :return:
-        """
-        if self.freqtrade.config['telegram'].get('enabled', False):
+        # Enable telegram
+        if freqtrade.config['telegram'].get('enabled', False):
             logger.info('Enabling rpc.telegram ...')
-            self.registered_modules.append('telegram')
-            self.telegram = Telegram(self.freqtrade)
+            from freqtrade.rpc.telegram import Telegram
+            self.registered_modules.append(Telegram(freqtrade))
 
     def cleanup(self) -> None:
-        """
-        Stops all enabled rpc modules
-        :return: None
-        """
-        if 'telegram' in self.registered_modules:
-            logger.info('Cleaning up rpc.telegram ...')
-            self.registered_modules.remove('telegram')
-            self.telegram.cleanup()
+        """ Stops all enabled rpc modules """
+        logger.info('Cleaning up rpc modules ...')
+        while self.registered_modules:
+            mod = self.registered_modules.pop()
+            logger.debug('Cleaning up rpc.%s ...', mod.name)
+            mod.cleanup()
+            del mod
 
     def send_msg(self, msg: str) -> None:
         """
@@ -52,6 +38,7 @@ class RPCManager(object):
         :param msg: message
         :return: None
         """
-        logger.info(msg)
-        if 'telegram' in self.registered_modules:
-            self.telegram.send_msg(msg)
+        logger.info('Sending rpc message: %s', msg)
+        for mod in self.registered_modules:
+            logger.debug('Forwarding message to rpc.%s', mod.name)
+            mod.send_msg(msg)

freqtrade/rpc/telegram.py

@@ -12,11 +12,12 @@ 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__)
 
+logger.debug('Included module rpc.telegram ...')
+
 
 def authorized_only(command_handler: Callable[[Any, Bot, Update], None]) -> Callable[..., Any]:
     """
@@ -25,9 +26,7 @@ def authorized_only(command_handler: Callable[[Any, Bot, Update], None]) -> Call
     :return: decorated function
     """
     def wrapper(self, *args, **kwargs):
-        """
-        Decorator logic
-        """
+        """ Decorator logic """
         update = kwargs.get('update') or args[1]
 
         # Reject unauthorized messages
@@ -54,9 +53,12 @@ def authorized_only(command_handler: Callable[[Any, Bot, Update], None]) -> Call
 
 
 class Telegram(RPC):
-    """
-    Telegram, this class send messages to Telegram
-    """
+    """  This class handles all telegram communication """
+
+    @property
+    def name(self) -> str:
+        return "telegram"
+
     def __init__(self, freqtrade) -> None:
         """
         Init the Telegram call, and init the super class RPC
@@ -74,12 +76,7 @@ class Telegram(RPC):
         Initializes this module with the given config,
         registers all known command handlers
         and starts polling for message updates
-        :param config: config to use
-        :return: None
         """
-        if not self.is_enabled():
-            return
-
         self._updater = Updater(token=self._config['telegram']['token'], workers=0)
 
         # Register command handler and start telegram message polling
@@ -115,16 +112,11 @@ class Telegram(RPC):
         Stops all running telegram threads.
         :return: None
         """
-        if not self.is_enabled():
-            return
-
         self._updater.stop()
 
-    def is_enabled(self) -> bool:
-        """
-        Returns True if the telegram module is activated, False otherwise
-        """
-        return bool(self._config.get('telegram', {}).get('enabled', False))
+    def send_msg(self, msg: str) -> None:
+        """ Send a message to telegram channel """
+        self._send_msg(msg)
 
     @authorized_only
     def _status(self, bot: Bot, update: Update) -> None:
@@ -143,13 +135,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:
@@ -160,15 +150,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(f"<pre>{message}</pre>", 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:
@@ -179,31 +166,29 @@ class Telegram(RPC):
         :param update: message update
         :return: None
         """
+        stake_cur = self._config['stake_currency']
+        fiat_disp_cur = self._config['fiat_display_currency']
         try:
             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,
+                stake_cur,
+                fiat_disp_cur
+            )
             stats = tabulate(stats,
                              headers=[
                                  'Day',
-                                 'Profit {}'.format(self._config['stake_currency']),
-                                 'Profit {}'.format(self._config['fiat_display_currency'])
+                                 f'Profit {stake_cur}',
+                                 f'Profit {fiat_disp_cur}'
                              ],
                              tablefmt='simple')
-            message = '<b>Daily Profit over the last {} days</b>:\n<pre>{}</pre>'\
-                      .format(
-                          timescale,
-                          stats
-                      )
-            self.send_msg(message, bot=bot, parse_mode=ParseMode.HTML)
+            message = f'<b>Daily Profit over the last {timescale} days</b>:\n<pre>{stats}</pre>'
+            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:
@@ -214,67 +199,62 @@ 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
+        stake_cur = self._config['stake_currency']
+        fiat_disp_cur = 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)
+        try:
+            stats = self._rpc_trade_statistics(
+                stake_cur,
+                fiat_disp_cur)
+            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']
+            # Message to display
+            markdown_msg = "*ROI:* Close trades\n" \
+                           f"∙ `{profit_closed_coin:.8f} {stake_cur} "\
+                           f"({profit_closed_percent:.2f}%)`\n" \
+                           f"∙ `{profit_closed_fiat:.3f} {fiat_disp_cur}`\n" \
+                           f"*ROI:* All trades\n" \
+                           f"∙ `{profit_all_coin:.8f} {stake_cur} ({profit_all_percent:.2f}%)`\n" \
+                           f"∙ `{profit_all_fiat:.3f} {fiat_disp_cur}`\n" \
+                           f"*Total Trade Count:* `{trade_count}`\n" \
+                           f"*First Trade opened:* `{first_trade_date}`\n" \
+                           f"*Latest Trade opened:* `{latest_trade_date}`\n" \
+                           f"*Avg. Duration:* `{avg_duration}`\n" \
+                           f"*Best Performing:* `{best_pair}: {best_rate:.2f}%`"
+            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
+        """ Handler for /balance """
+        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:
@@ -285,9 +265,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:
@@ -298,8 +277,8 @@ class Telegram(RPC):
         :param update: message update
         :return: None
         """
-        (error, msg) = self.rpc_stop()
-        self.send_msg(msg, bot=bot)
+        msg = self._rpc_stop()
+        self._send_msg(msg, bot=bot)
 
     @authorized_only
     def _reload_conf(self, bot: Bot, update: Update) -> None:
@@ -310,8 +289,8 @@ class Telegram(RPC):
         :param update: message update
         :return: None
         """
-        msg = self.rpc_reload_conf()
-        self.send_msg(msg, bot=bot)
+        msg = self._rpc_reload_conf()
+        self._send_msg(msg, bot=bot)
 
     @authorized_only
     def _forcesell(self, bot: Bot, update: Update) -> None:
@@ -324,10 +303,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:
@@ -338,19 +317,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:
@@ -361,19 +339,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:
@@ -399,7 +376,7 @@ class Telegram(RPC):
                   "*/help:* `This help message`\n" \
                   "*/version:* `Show version`"
 
-        self.send_msg(message, bot=bot)
+        self._send_msg(message, bot=bot)
 
     @authorized_only
     def _version(self, bot: Bot, update: Update) -> None:
@@ -410,10 +387,10 @@ class Telegram(RPC):
         :param update: message update
         :return: None
         """
-        self.send_msg('*Version:* `{}`'.format(__version__), bot=bot)
+        self._send_msg('*Version:* `{}`'.format(__version__), bot=bot)
 
-    def send_msg(self, msg: str, bot: Bot = None,
-                 parse_mode: ParseMode = ParseMode.MARKDOWN) -> None:
+    def _send_msg(self, msg: str, bot: Bot = None,
+                  parse_mode: ParseMode = ParseMode.MARKDOWN) -> None:
         """
         Send given markdown message
         :param msg: message
@@ -421,9 +398,6 @@ class Telegram(RPC):
         :param parse_mode: telegram parse mode
         :return: None
         """
-        if not self.is_enabled():
-            return
-
         bot = bot or self._updater.bot
 
         keyboard = [['/daily', '/profit', '/balance'],

freqtrade/strategy/__init__.py

@@ -0,0 +1,32 @@
+import logging
+from copy import deepcopy
+
+from freqtrade.strategy.interface import IStrategy
+
+
+logger = logging.getLogger(__name__)
+
+
+def import_strategy(strategy: IStrategy) -> IStrategy:
+    """
+    Imports given Strategy instance to global scope
+    of freqtrade.strategy and returns an instance of it
+    """
+    # Copy all attributes from base class and class
+    attr = deepcopy({**strategy.__class__.__dict__, **strategy.__dict__})
+    # Adjust module name
+    attr['__module__'] = 'freqtrade.strategy'
+
+    name = strategy.__class__.__name__
+    clazz = type(name, (IStrategy,), attr)
+
+    logger.debug(
+        'Imported strategy %s.%s as %s.%s',
+        strategy.__module__, strategy.__class__.__name__,
+        clazz.__module__, strategy.__class__.__name__,
+    )
+
+    # Modify global scope to declare class
+    globals()[name] = clazz
+
+    return clazz()

freqtrade/strategy/interface.py

@@ -3,6 +3,7 @@ IStrategy interface
 This module defines the interface to apply for strategies
 """
 import warnings
+from abc import ABC, abstractmethod
 from typing import Dict
 
 from abc import ABC

freqtrade/strategy/resolver.py

@@ -8,9 +8,10 @@ import inspect
 import logging
 import os
 from collections import OrderedDict
-from typing import Optional, Dict, Type
+from typing import Dict, Optional, Type
 
 from freqtrade import constants
+from freqtrade.strategy import import_strategy
 from freqtrade.strategy.interface import IStrategy
 
 logger = logging.getLogger(__name__)
@@ -70,7 +71,7 @@ class StrategyResolver(object):
         """
         current_path = os.path.dirname(os.path.realpath(__file__))
         abs_paths = [
-            os.path.join(current_path, '..', '..', 'user_data', 'strategies'),
+            os.path.join(os.getcwd(), 'user_data', 'strategies'),
             current_path,
         ]
 
@@ -79,10 +80,13 @@ class StrategyResolver(object):
             abs_paths.insert(0, extra_dir)
 
         for path in abs_paths:
-            strategy = self._search_strategy(path, strategy_name)
-            if strategy:
-                logger.info('Using resolved strategy %s from \'%s\'', strategy_name, path)
-                return strategy
+            try:
+                strategy = self._search_strategy(path, strategy_name)
+                if strategy:
+                    logger.info('Using resolved strategy %s from \'%s\'', strategy_name, path)
+                    return import_strategy(strategy)
+            except FileNotFoundError:
+                logger.warning('Path "%s" does not exist', path)
 
         raise ImportError(
             "Impossible to load Strategy '{}'. This class does not exist"
@@ -99,7 +103,7 @@ class StrategyResolver(object):
         """
 
         # Generate spec based on absolute path
-        spec = importlib.util.spec_from_file_location('user_data.strategies', module_path)
+        spec = importlib.util.spec_from_file_location('unknown', module_path)
         module = importlib.util.module_from_spec(spec)
         spec.loader.exec_module(module)  # type: ignore # importlib does not use typehints
 

freqtrade/tests/conftest.py

@@ -2,8 +2,8 @@
 import json
 import logging
 from datetime import datetime
-from typing import Dict, Optional
 from functools import reduce
+from typing import Dict, Optional
 from unittest.mock import MagicMock
 
 import arrow
@@ -11,8 +11,9 @@ import pytest
 from jsonschema import validate
 from telegram import Chat, Message, Update
 
-from freqtrade.analyze import Analyze
 from freqtrade import constants
+from freqtrade.analyze import Analyze
+from freqtrade.exchange import Exchange
 from freqtrade.freqtradebot import FreqtradeBot
 
 logging.getLogger('').setLevel(logging.INFO)
@@ -26,6 +27,20 @@ def log_has(line, logs):
                   False)
 
 
+def patch_exchange(mocker, api_mock=None) -> None:
+    mocker.patch('freqtrade.exchange.Exchange.validate_pairs', MagicMock())
+    if api_mock:
+        mocker.patch('freqtrade.exchange.Exchange._init_ccxt', MagicMock(return_value=api_mock))
+    else:
+        mocker.patch('freqtrade.exchange.Exchange._init_ccxt', MagicMock())
+
+
+def get_patched_exchange(mocker, config, api_mock=None) -> Exchange:
+    patch_exchange(mocker, api_mock)
+    exchange = Exchange(config)
+    return exchange
+
+
 # Functions for recurrent object patching
 def get_patched_freqtradebot(mocker, config) -> FreqtradeBot:
     """
@@ -39,7 +54,7 @@ def get_patched_freqtradebot(mocker, config) -> FreqtradeBot:
     mocker.patch('freqtrade.freqtradebot.Analyze', MagicMock())
     mocker.patch('freqtrade.freqtradebot.RPCManager', MagicMock())
     mocker.patch('freqtrade.freqtradebot.persistence.init', MagicMock())
-    mocker.patch('freqtrade.freqtradebot.exchange.init', MagicMock())
+    patch_exchange(mocker, None)
     mocker.patch('freqtrade.freqtradebot.RPCManager._init', MagicMock())
     mocker.patch('freqtrade.freqtradebot.RPCManager.send_msg', MagicMock())
     mocker.patch('freqtrade.freqtradebot.Analyze.get_signal', MagicMock())
@@ -85,7 +100,10 @@ def default_conf():
             "0": 0.04
         },
         "stoploss": -0.10,
-        "unfilledtimeout": 600,
+        "unfilledtimeout": {
+            "buy": 10,
+            "sell": 30
+        },
         "bid_strategy": {
             "ask_last_balance": 0.0
         },
@@ -174,7 +192,10 @@ def markets():
                     'max': 1000,
                 },
                 'price': 500000,
-                'cost': 500000,
+                'cost': {
+                    'min': 1,
+                    'max': 500000,
+                },
             },
             'info': '',
         },
@@ -196,7 +217,10 @@ def markets():
                     'max': 1000,
                 },
                 'price': 500000,
-                'cost': 500000,
+                'cost': {
+                    'min': 1,
+                    'max': 500000,
+                },
             },
             'info': '',
         },
@@ -218,7 +242,85 @@ def markets():
                     'max': 1000,
                 },
                 'price': 500000,
-                'cost': 500000,
+                'cost': {
+                    'min': 1,
+                    'max': 500000,
+                },
+            },
+            'info': '',
+        },
+        {
+            'id': 'ltcbtc',
+            'symbol': 'LTC/BTC',
+            'base': 'LTC',
+            'quote': 'BTC',
+            'active': False,
+            'precision': {
+                'price': 8,
+                'amount': 8,
+                'cost': 8,
+            },
+            'lot': 0.00000001,
+            'limits': {
+                'amount': {
+                    'min': 0.01,
+                    'max': 1000,
+                },
+                'price': 500000,
+                'cost': {
+                    'min': 1,
+                    'max': 500000,
+                },
+            },
+            'info': '',
+        },
+        {
+            'id': 'xrpbtc',
+            'symbol': 'XRP/BTC',
+            'base': 'XRP',
+            'quote': 'BTC',
+            'active': False,
+            'precision': {
+                'price': 8,
+                'amount': 8,
+                'cost': 8,
+            },
+            'lot': 0.00000001,
+            'limits': {
+                'amount': {
+                    'min': 0.01,
+                    'max': 1000,
+                },
+                'price': 500000,
+                'cost': {
+                    'min': 1,
+                    'max': 500000,
+                },
+            },
+            'info': '',
+        },
+        {
+            'id': 'neobtc',
+            'symbol': 'NEO/BTC',
+            'base': 'NEO',
+            'quote': 'BTC',
+            'active': False,
+            'precision': {
+                'price': 8,
+                'amount': 8,
+                'cost': 8,
+            },
+            'lot': 0.00000001,
+            'limits': {
+                'amount': {
+                    'min': 0.01,
+                    'max': 1000,
+                },
+                'price': 500000,
+                'cost': {
+                    'min': 1,
+                    'max': 500000,
+                },
             },
             'info': '',
         }

freqtrade/tests/exchange/test_exchange.py

@@ -2,44 +2,54 @@
 # pragma pylint: disable=protected-access
 import logging
 from copy import deepcopy
+from datetime import datetime
 from random import randint
 from unittest.mock import MagicMock, PropertyMock
 
 import ccxt
 import pytest
 
-import freqtrade.exchange as exchange
-from freqtrade import OperationalException, DependencyException, TemporaryError
-from freqtrade.exchange import (init, validate_pairs, buy, sell, get_balance, get_balances,
-                                get_ticker, get_ticker_history, cancel_order, get_name, get_fee,
-                                get_id, get_pair_detail_url, get_amount_lots)
-from freqtrade.tests.conftest import log_has
-
-API_INIT = False
+from freqtrade import DependencyException, OperationalException, TemporaryError
+from freqtrade.exchange import API_RETRY_COUNT, Exchange
+from freqtrade.tests.conftest import get_patched_exchange, log_has
 
 
-def maybe_init_api(conf, mocker, force=False):
-    global API_INIT
-    if force or not API_INIT:
-        mocker.patch('freqtrade.exchange.validate_pairs',
-                     side_effect=lambda s: True)
-        init(config=conf)
-        API_INIT = True
+def ccxt_exceptionhandlers(mocker, default_conf, api_mock, fun, mock_ccxt_fun, **kwargs):
+    """Function to test ccxt exception handling """
+
+    with pytest.raises(TemporaryError):
+        api_mock.__dict__[mock_ccxt_fun] = MagicMock(side_effect=ccxt.NetworkError)
+        exchange = get_patched_exchange(mocker, default_conf, api_mock)
+        getattr(exchange, fun)(**kwargs)
+    assert api_mock.__dict__[mock_ccxt_fun].call_count == API_RETRY_COUNT + 1
+
+    with pytest.raises(OperationalException):
+        api_mock.__dict__[mock_ccxt_fun] = MagicMock(side_effect=ccxt.BaseError)
+        exchange = get_patched_exchange(mocker, default_conf, api_mock)
+        getattr(exchange, fun)(**kwargs)
+    assert api_mock.__dict__[mock_ccxt_fun].call_count == 1
 
 
 def test_init(default_conf, mocker, caplog):
     caplog.set_level(logging.INFO)
-    maybe_init_api(default_conf, mocker, True)
+    get_patched_exchange(mocker, default_conf)
     assert log_has('Instance is running with dry_run enabled', caplog.record_tuples)
 
 
-def test_init_exception(default_conf):
+def test_init_exception(default_conf, mocker):
     default_conf['exchange']['name'] = 'wrong_exchange_name'
 
     with pytest.raises(
             OperationalException,
             match='Exchange {} is not supported'.format(default_conf['exchange']['name'])):
-        init(config=default_conf)
+        Exchange(default_conf)
+
+    default_conf['exchange']['name'] = 'binance'
+    with pytest.raises(
+            OperationalException,
+            match='Exchange {} is not supported'.format(default_conf['exchange']['name'])):
+        mocker.patch("ccxt.binance", MagicMock(side_effect=AttributeError))
+        Exchange(default_conf)
 
 
 def test_validate_pairs(default_conf, mocker):
@@ -50,18 +60,17 @@ def test_validate_pairs(default_conf, mocker):
     id_mock = PropertyMock(return_value='test_exchange')
     type(api_mock).id = id_mock
 
-    mocker.patch('freqtrade.exchange._API', api_mock)
-    mocker.patch.dict('freqtrade.exchange._CONF', default_conf)
-    validate_pairs(default_conf['exchange']['pair_whitelist'])
+    mocker.patch('freqtrade.exchange.Exchange._init_ccxt', MagicMock(return_value=api_mock))
+    Exchange(default_conf)
 
 
 def test_validate_pairs_not_available(default_conf, mocker):
     api_mock = MagicMock()
     api_mock.load_markets = MagicMock(return_value={})
-    mocker.patch('freqtrade.exchange._API', api_mock)
-    mocker.patch.dict('freqtrade.exchange._CONF', default_conf)
+    mocker.patch('freqtrade.exchange.Exchange._init_ccxt', MagicMock(return_value=api_mock))
+
     with pytest.raises(OperationalException, match=r'not available'):
-        validate_pairs(default_conf['exchange']['pair_whitelist'])
+        Exchange(default_conf)
 
 
 def test_validate_pairs_not_compatible(default_conf, mocker):
@@ -71,25 +80,27 @@ def test_validate_pairs_not_compatible(default_conf, mocker):
     })
     conf = deepcopy(default_conf)
     conf['stake_currency'] = 'ETH'
-    mocker.patch('freqtrade.exchange._API', api_mock)
-    mocker.patch.dict('freqtrade.exchange._CONF', conf)
+    mocker.patch('freqtrade.exchange.Exchange._init_ccxt', MagicMock(return_value=api_mock))
+
     with pytest.raises(OperationalException, match=r'not compatible'):
-        validate_pairs(conf['exchange']['pair_whitelist'])
+        Exchange(conf)
 
 
 def test_validate_pairs_exception(default_conf, mocker, caplog):
     caplog.set_level(logging.INFO)
     api_mock = MagicMock()
-    api_mock.name = 'Binance'
-    mocker.patch('freqtrade.exchange._API', api_mock)
-    mocker.patch.dict('freqtrade.exchange._CONF', default_conf)
+    mocker.patch('freqtrade.exchange.Exchange.name', PropertyMock(return_value='Binance'))
 
     api_mock.load_markets = MagicMock(return_value={})
+    mocker.patch('freqtrade.exchange.Exchange._init_ccxt', api_mock)
+
     with pytest.raises(OperationalException, match=r'Pair ETH/BTC is not available at Binance'):
-        validate_pairs(default_conf['exchange']['pair_whitelist'])
+        Exchange(default_conf)
 
     api_mock.load_markets = MagicMock(side_effect=ccxt.BaseError())
-    validate_pairs(default_conf['exchange']['pair_whitelist'])
+
+    mocker.patch('freqtrade.exchange.Exchange._init_ccxt', MagicMock(return_value=api_mock))
+    Exchange(default_conf)
     assert log_has('Unable to validate pairs (assuming they are correct). Reason: ',
                    caplog.record_tuples)
 
@@ -99,22 +110,35 @@ def test_validate_pairs_stake_exception(default_conf, mocker, caplog):
     conf = deepcopy(default_conf)
     conf['stake_currency'] = 'ETH'
     api_mock = MagicMock()
-    api_mock.name = 'binance'
-    mocker.patch('freqtrade.exchange._API', api_mock)
-    mocker.patch.dict('freqtrade.exchange._CONF', conf)
+    api_mock.name = MagicMock(return_value='binance')
+    mocker.patch('freqtrade.exchange.Exchange._init_ccxt', api_mock)
 
     with pytest.raises(
         OperationalException,
         match=r'Pair ETH/BTC not compatible with stake_currency: ETH'
     ):
-        validate_pairs(default_conf['exchange']['pair_whitelist'])
+        Exchange(conf)
+
+
+def test_exchangehas(default_conf, mocker):
+    exchange = get_patched_exchange(mocker, default_conf)
+    assert not exchange.exchange_has('ASDFASDF')
+    api_mock = MagicMock()
+
+    type(api_mock).has = PropertyMock(return_value={'deadbeef': True})
+    exchange = get_patched_exchange(mocker, default_conf, api_mock)
+    assert exchange.exchange_has("deadbeef")
+
+    type(api_mock).has = PropertyMock(return_value={'deadbeef': False})
+    exchange = get_patched_exchange(mocker, default_conf, api_mock)
+    assert not exchange.exchange_has("deadbeef")
 
 
 def test_buy_dry_run(default_conf, mocker):
     default_conf['dry_run'] = True
-    mocker.patch.dict('freqtrade.exchange._CONF', default_conf)
+    exchange = get_patched_exchange(mocker, default_conf)
 
-    order = buy(pair='ETH/BTC', rate=200, amount=1)
+    order = exchange.buy(pair='ETH/BTC', rate=200, amount=1)
     assert 'id' in order
     assert 'dry_run_buy_' in order['id']
 
@@ -128,12 +152,10 @@ def test_buy_prod(default_conf, mocker):
             'foo': 'bar'
         }
     })
-    mocker.patch('freqtrade.exchange._API', api_mock)
-
     default_conf['dry_run'] = False
-    mocker.patch.dict('freqtrade.exchange._CONF', default_conf)
+    exchange = get_patched_exchange(mocker, default_conf, api_mock)
 
-    order = buy(pair='ETH/BTC', rate=200, amount=1)
+    order = exchange.buy(pair='ETH/BTC', rate=200, amount=1)
     assert 'id' in order
     assert 'info' in order
     assert order['id'] == order_id
@@ -141,30 +163,30 @@ def test_buy_prod(default_conf, mocker):
     # test exception handling
     with pytest.raises(DependencyException):
         api_mock.create_limit_buy_order = MagicMock(side_effect=ccxt.InsufficientFunds)
-        mocker.patch('freqtrade.exchange._API', api_mock)
-        buy(pair='ETH/BTC', rate=200, amount=1)
+        exchange = get_patched_exchange(mocker, default_conf, api_mock)
+        exchange.buy(pair='ETH/BTC', rate=200, amount=1)
 
     with pytest.raises(DependencyException):
         api_mock.create_limit_buy_order = MagicMock(side_effect=ccxt.InvalidOrder)
-        mocker.patch('freqtrade.exchange._API', api_mock)
-        buy(pair='ETH/BTC', rate=200, amount=1)
+        exchange = get_patched_exchange(mocker, default_conf, api_mock)
+        exchange.buy(pair='ETH/BTC', rate=200, amount=1)
 
     with pytest.raises(TemporaryError):
         api_mock.create_limit_buy_order = MagicMock(side_effect=ccxt.NetworkError)
-        mocker.patch('freqtrade.exchange._API', api_mock)
-        buy(pair='ETH/BTC', rate=200, amount=1)
+        exchange = get_patched_exchange(mocker, default_conf, api_mock)
+        exchange.buy(pair='ETH/BTC', rate=200, amount=1)
 
     with pytest.raises(OperationalException):
         api_mock.create_limit_buy_order = MagicMock(side_effect=ccxt.BaseError)
-        mocker.patch('freqtrade.exchange._API', api_mock)
-        buy(pair='ETH/BTC', rate=200, amount=1)
+        exchange = get_patched_exchange(mocker, default_conf, api_mock)
+        exchange.buy(pair='ETH/BTC', rate=200, amount=1)
 
 
 def test_sell_dry_run(default_conf, mocker):
     default_conf['dry_run'] = True
-    mocker.patch.dict('freqtrade.exchange._CONF', default_conf)
+    exchange = get_patched_exchange(mocker, default_conf)
 
-    order = sell(pair='ETH/BTC', rate=200, amount=1)
+    order = exchange.sell(pair='ETH/BTC', rate=200, amount=1)
     assert 'id' in order
     assert 'dry_run_sell_' in order['id']
 
@@ -178,12 +200,11 @@ def test_sell_prod(default_conf, mocker):
             'foo': 'bar'
         }
     })
-    mocker.patch('freqtrade.exchange._API', api_mock)
-
     default_conf['dry_run'] = False
-    mocker.patch.dict('freqtrade.exchange._CONF', default_conf)
 
-    order = sell(pair='ETH/BTC', rate=200, amount=1)
+    exchange = get_patched_exchange(mocker, default_conf, api_mock)
+
+    order = exchange.sell(pair='ETH/BTC', rate=200, amount=1)
     assert 'id' in order
     assert 'info' in order
     assert order['id'] == order_id
@@ -191,53 +212,57 @@ def test_sell_prod(default_conf, mocker):
     # test exception handling
     with pytest.raises(DependencyException):
         api_mock.create_limit_sell_order = MagicMock(side_effect=ccxt.InsufficientFunds)
-        mocker.patch('freqtrade.exchange._API', api_mock)
-        sell(pair='ETH/BTC', rate=200, amount=1)
+        exchange = get_patched_exchange(mocker, default_conf, api_mock)
+        exchange.sell(pair='ETH/BTC', rate=200, amount=1)
 
     with pytest.raises(DependencyException):
         api_mock.create_limit_sell_order = MagicMock(side_effect=ccxt.InvalidOrder)
-        mocker.patch('freqtrade.exchange._API', api_mock)
-        sell(pair='ETH/BTC', rate=200, amount=1)
+        exchange = get_patched_exchange(mocker, default_conf, api_mock)
+        exchange.sell(pair='ETH/BTC', rate=200, amount=1)
 
     with pytest.raises(TemporaryError):
         api_mock.create_limit_sell_order = MagicMock(side_effect=ccxt.NetworkError)
-        mocker.patch('freqtrade.exchange._API', api_mock)
-        sell(pair='ETH/BTC', rate=200, amount=1)
+        exchange = get_patched_exchange(mocker, default_conf, api_mock)
+        exchange.sell(pair='ETH/BTC', rate=200, amount=1)
 
     with pytest.raises(OperationalException):
         api_mock.create_limit_sell_order = MagicMock(side_effect=ccxt.BaseError)
-        mocker.patch('freqtrade.exchange._API', api_mock)
-        sell(pair='ETH/BTC', rate=200, amount=1)
+        exchange = get_patched_exchange(mocker, default_conf, api_mock)
+        exchange.sell(pair='ETH/BTC', rate=200, amount=1)
 
 
 def test_get_balance_dry_run(default_conf, mocker):
     default_conf['dry_run'] = True
-    mocker.patch.dict('freqtrade.exchange._CONF', default_conf)
 
-    assert get_balance(currency='BTC') == 999.9
+    exchange = get_patched_exchange(mocker, default_conf)
+    assert exchange.get_balance(currency='BTC') == 999.9
 
 
 def test_get_balance_prod(default_conf, mocker):
     api_mock = MagicMock()
     api_mock.fetch_balance = MagicMock(return_value={'BTC': {'free': 123.4}})
-    mocker.patch('freqtrade.exchange._API', api_mock)
-
     default_conf['dry_run'] = False
-    mocker.patch.dict('freqtrade.exchange._CONF', default_conf)
 
-    assert get_balance(currency='BTC') == 123.4
+    exchange = get_patched_exchange(mocker, default_conf, api_mock)
+
+    assert exchange.get_balance(currency='BTC') == 123.4
 
     with pytest.raises(OperationalException):
         api_mock.fetch_balance = MagicMock(side_effect=ccxt.BaseError)
-        mocker.patch('freqtrade.exchange._API', api_mock)
-        get_balance(currency='BTC')
+        exchange = get_patched_exchange(mocker, default_conf, api_mock)
+
+        exchange.get_balance(currency='BTC')
+
+    with pytest.raises(TemporaryError, match=r'.*balance due to malformed exchange response:.*'):
+        exchange = get_patched_exchange(mocker, default_conf, api_mock)
+        mocker.patch('freqtrade.exchange.Exchange.get_balances', MagicMock(return_value={}))
+        exchange.get_balance(currency='BTC')
 
 
 def test_get_balances_dry_run(default_conf, mocker):
     default_conf['dry_run'] = True
-    mocker.patch.dict('freqtrade.exchange._CONF', default_conf)
-
-    assert get_balances() == {}
+    exchange = get_patched_exchange(mocker, default_conf)
+    assert exchange.get_balances() == {}
 
 
 def test_get_balances_prod(default_conf, mocker):
@@ -253,33 +278,57 @@ def test_get_balances_prod(default_conf, mocker):
         '2ST': balance_item,
         '3ST': balance_item
     })
-    mocker.patch('freqtrade.exchange._API', api_mock)
-
     default_conf['dry_run'] = False
-    mocker.patch.dict('freqtrade.exchange._CONF', default_conf)
+    exchange = get_patched_exchange(mocker, default_conf, api_mock)
+    assert len(exchange.get_balances()) == 3
+    assert exchange.get_balances()['1ST']['free'] == 10.0
+    assert exchange.get_balances()['1ST']['total'] == 10.0
+    assert exchange.get_balances()['1ST']['used'] == 0.0
 
-    assert len(get_balances()) == 3
-    assert get_balances()['1ST']['free'] == 10.0
-    assert get_balances()['1ST']['total'] == 10.0
-    assert get_balances()['1ST']['used'] == 0.0
+    ccxt_exceptionhandlers(mocker, default_conf, api_mock,
+                           "get_balances", "fetch_balance")
 
-    with pytest.raises(TemporaryError):
-        api_mock.fetch_balance = MagicMock(side_effect=ccxt.NetworkError)
-        mocker.patch('freqtrade.exchange._API', api_mock)
-        get_balances()
-    assert api_mock.fetch_balance.call_count == exchange.API_RETRY_COUNT + 1
+
+def test_get_tickers(default_conf, mocker):
+    api_mock = MagicMock()
+    tick = {'ETH/BTC': {
+          'symbol': 'ETH/BTC',
+          'bid': 0.5,
+          'ask': 1,
+          'last': 42,
+      }, 'BCH/BTC': {
+          'symbol': 'BCH/BTC',
+          'bid': 0.6,
+          'ask': 0.5,
+          'last': 41,
+      }
+      }
+    api_mock.fetch_tickers = MagicMock(return_value=tick)
+    exchange = get_patched_exchange(mocker, default_conf, api_mock)
+    # retrieve original ticker
+    tickers = exchange.get_tickers()
+
+    assert 'ETH/BTC' in tickers
+    assert 'BCH/BTC' in tickers
+    assert tickers['ETH/BTC']['bid'] == 0.5
+    assert tickers['ETH/BTC']['ask'] == 1
+    assert tickers['BCH/BTC']['bid'] == 0.6
+    assert tickers['BCH/BTC']['ask'] == 0.5
+
+    ccxt_exceptionhandlers(mocker, default_conf, api_mock,
+                           "get_tickers", "fetch_tickers")
 
     with pytest.raises(OperationalException):
-        api_mock.fetch_balance = MagicMock(side_effect=ccxt.BaseError)
-        mocker.patch('freqtrade.exchange._API', api_mock)
-        get_balances()
-    assert api_mock.fetch_balance.call_count == 1
+        api_mock.fetch_tickers = MagicMock(side_effect=ccxt.NotSupported)
+        exchange = get_patched_exchange(mocker, default_conf, api_mock)
+        exchange.get_tickers()
+
+    api_mock.fetch_tickers = MagicMock(return_value={})
+    exchange = get_patched_exchange(mocker, default_conf, api_mock)
+    exchange.get_tickers()
 
 
-# This test is somewhat redundant with
-# test_exchange_bittrex.py::test_exchange_bittrex_get_ticker
 def test_get_ticker(default_conf, mocker):
-    maybe_init_api(default_conf, mocker)
     api_mock = MagicMock()
     tick = {
         'symbol': 'ETH/BTC',
@@ -288,10 +337,9 @@ def test_get_ticker(default_conf, mocker):
         'last': 0.0001,
     }
     api_mock.fetch_ticker = MagicMock(return_value=tick)
-    mocker.patch('freqtrade.exchange._API', api_mock)
-
+    exchange = get_patched_exchange(mocker, default_conf, api_mock)
     # retrieve original ticker
-    ticker = get_ticker(pair='ETH/BTC')
+    ticker = exchange.get_ticker(pair='ETH/BTC')
 
     assert ticker['bid'] == 0.00001098
     assert ticker['ask'] == 0.00001099
@@ -304,38 +352,32 @@ def test_get_ticker(default_conf, mocker):
         'last': 42,
     }
     api_mock.fetch_ticker = MagicMock(return_value=tick)
-    mocker.patch('freqtrade.exchange._API', api_mock)
+    exchange = get_patched_exchange(mocker, default_conf, api_mock)
 
     # if not caching the result we should get the same ticker
     # if not fetching a new result we should get the cached ticker
-    ticker = get_ticker(pair='ETH/BTC')
+    ticker = exchange.get_ticker(pair='ETH/BTC')
 
     assert api_mock.fetch_ticker.call_count == 1
     assert ticker['bid'] == 0.5
     assert ticker['ask'] == 1
 
-    assert 'ETH/BTC' in exchange._CACHED_TICKER
-    assert exchange._CACHED_TICKER['ETH/BTC']['bid'] == 0.5
-    assert exchange._CACHED_TICKER['ETH/BTC']['ask'] == 1
+    assert 'ETH/BTC' in exchange._cached_ticker
+    assert exchange._cached_ticker['ETH/BTC']['bid'] == 0.5
+    assert exchange._cached_ticker['ETH/BTC']['ask'] == 1
 
     # Test caching
     api_mock.fetch_ticker = MagicMock()
-    get_ticker(pair='ETH/BTC', refresh=False)
+    exchange.get_ticker(pair='ETH/BTC', refresh=False)
     assert api_mock.fetch_ticker.call_count == 0
 
-    with pytest.raises(TemporaryError):  # test retrier
-        api_mock.fetch_ticker = MagicMock(side_effect=ccxt.NetworkError)
-        mocker.patch('freqtrade.exchange._API', api_mock)
-        get_ticker(pair='ETH/BTC', refresh=True)
-
-    with pytest.raises(OperationalException):
-        api_mock.fetch_ticker = MagicMock(side_effect=ccxt.BaseError)
-        mocker.patch('freqtrade.exchange._API', api_mock)
-        get_ticker(pair='ETH/BTC', refresh=True)
+    ccxt_exceptionhandlers(mocker, default_conf, api_mock,
+                           "get_ticker", "fetch_ticker",
+                           pair='ETH/BTC', refresh=True)
 
     api_mock.fetch_ticker = MagicMock(return_value={})
-    mocker.patch('freqtrade.exchange._API', api_mock)
-    get_ticker(pair='ETH/BTC', refresh=True)
+    exchange = get_patched_exchange(mocker, default_conf, api_mock)
+    exchange.get_ticker(pair='ETH/BTC', refresh=True)
 
 
 def make_fetch_ohlcv_mock(data):
@@ -361,10 +403,10 @@ def test_get_ticker_history(default_conf, mocker):
     ]
     type(api_mock).has = PropertyMock(return_value={'fetchOHLCV': True})
     api_mock.fetch_ohlcv = MagicMock(side_effect=make_fetch_ohlcv_mock(tick))
-    mocker.patch('freqtrade.exchange._API', api_mock)
+    exchange = get_patched_exchange(mocker, default_conf, api_mock)
 
     # retrieve original ticker
-    ticks = get_ticker_history('ETH/BTC', default_conf['ticker_interval'])
+    ticks = exchange.get_ticker_history('ETH/BTC', default_conf['ticker_interval'])
     assert ticks[0][0] == 1511686200000
     assert ticks[0][1] == 1
     assert ticks[0][2] == 2
@@ -384,9 +426,9 @@ def test_get_ticker_history(default_conf, mocker):
         ]
     ]
     api_mock.fetch_ohlcv = MagicMock(side_effect=make_fetch_ohlcv_mock(new_tick))
-    mocker.patch('freqtrade.exchange._API', api_mock)
+    exchange = get_patched_exchange(mocker, default_conf, api_mock)
 
-    ticks = get_ticker_history('ETH/BTC', default_conf['ticker_interval'])
+    ticks = exchange.get_ticker_history('ETH/BTC', default_conf['ticker_interval'])
     assert ticks[0][0] == 1511686210000
     assert ticks[0][1] == 6
     assert ticks[0][2] == 7
@@ -394,17 +436,14 @@ def test_get_ticker_history(default_conf, mocker):
     assert ticks[0][4] == 9
     assert ticks[0][5] == 10
 
-    with pytest.raises(TemporaryError):  # test retrier
-        api_mock.fetch_ohlcv = MagicMock(side_effect=ccxt.NetworkError)
-        mocker.patch('freqtrade.exchange._API', api_mock)
-        # new symbol to get around cache
-        get_ticker_history('ABCD/BTC', default_conf['ticker_interval'])
+    ccxt_exceptionhandlers(mocker, default_conf, api_mock,
+                           "get_ticker_history", "fetch_ohlcv",
+                           pair='ABCD/BTC', tick_interval=default_conf['ticker_interval'])
 
-    with pytest.raises(OperationalException):
-        api_mock.fetch_ohlcv = MagicMock(side_effect=ccxt.BaseError)
-        mocker.patch('freqtrade.exchange._API', api_mock)
-        # new symbol to get around cache
-        get_ticker_history('EFGH/BTC', default_conf['ticker_interval'])
+    with pytest.raises(OperationalException, match=r'Exchange .* does not support.*'):
+        api_mock.fetch_ohlcv = MagicMock(side_effect=ccxt.NotSupported)
+        exchange = get_patched_exchange(mocker, default_conf, api_mock)
+        exchange.get_ticker_history(pair='ABCD/BTC', tick_interval=default_conf['ticker_interval'])
 
 
 def test_get_ticker_history_sort(default_conf, mocker):
@@ -426,10 +465,11 @@ def test_get_ticker_history_sort(default_conf, mocker):
     ]
     type(api_mock).has = PropertyMock(return_value={'fetchOHLCV': True})
     api_mock.fetch_ohlcv = MagicMock(side_effect=make_fetch_ohlcv_mock(tick))
-    mocker.patch('freqtrade.exchange._API', api_mock)
+
+    exchange = get_patched_exchange(mocker, default_conf, api_mock)
 
     # Test the ticker history sort
-    ticks = get_ticker_history('ETH/BTC', default_conf['ticker_interval'])
+    ticks = exchange.get_ticker_history('ETH/BTC', default_conf['ticker_interval'])
     assert ticks[0][0] == 1527830400000
     assert ticks[0][1] == 0.07649
     assert ticks[0][2] == 0.07651
@@ -460,10 +500,9 @@ def test_get_ticker_history_sort(default_conf, mocker):
     ]
     type(api_mock).has = PropertyMock(return_value={'fetchOHLCV': True})
     api_mock.fetch_ohlcv = MagicMock(side_effect=make_fetch_ohlcv_mock(tick))
-    mocker.patch('freqtrade.exchange._API', api_mock)
-
+    exchange = get_patched_exchange(mocker, default_conf, api_mock)
     # Test the ticker history sort
-    ticks = get_ticker_history('ETH/BTC', default_conf['ticker_interval'])
+    ticks = exchange.get_ticker_history('ETH/BTC', default_conf['ticker_interval'])
     assert ticks[0][0] == 1527827700000
     assert ticks[0][1] == 0.07659999
     assert ticks[0][2] == 0.0766
@@ -481,117 +520,159 @@ def test_get_ticker_history_sort(default_conf, mocker):
 
 def test_cancel_order_dry_run(default_conf, mocker):
     default_conf['dry_run'] = True
-    mocker.patch.dict('freqtrade.exchange._CONF', default_conf)
-
-    assert cancel_order(order_id='123', pair='TKN/BTC') is None
+    exchange = get_patched_exchange(mocker, default_conf)
+    assert exchange.cancel_order(order_id='123', pair='TKN/BTC') is None
 
 
 # Ensure that if not dry_run, we should call API
 def test_cancel_order(default_conf, mocker):
     default_conf['dry_run'] = False
-    mocker.patch.dict('freqtrade.exchange._CONF', default_conf)
     api_mock = MagicMock()
     api_mock.cancel_order = MagicMock(return_value=123)
-    mocker.patch('freqtrade.exchange._API', api_mock)
-    assert cancel_order(order_id='_', pair='TKN/BTC') == 123
-
-    with pytest.raises(TemporaryError):
-        api_mock.cancel_order = MagicMock(side_effect=ccxt.NetworkError)
-        mocker.patch('freqtrade.exchange._API', api_mock)
-        cancel_order(order_id='_', pair='TKN/BTC')
-    assert api_mock.cancel_order.call_count == exchange.API_RETRY_COUNT + 1
+    exchange = get_patched_exchange(mocker, default_conf, api_mock)
+    assert exchange.cancel_order(order_id='_', pair='TKN/BTC') == 123
 
     with pytest.raises(DependencyException):
         api_mock.cancel_order = MagicMock(side_effect=ccxt.InvalidOrder)
-        mocker.patch('freqtrade.exchange._API', api_mock)
-        cancel_order(order_id='_', pair='TKN/BTC')
-    assert api_mock.cancel_order.call_count == exchange.API_RETRY_COUNT + 1
+        exchange = get_patched_exchange(mocker, default_conf, api_mock)
+        exchange.cancel_order(order_id='_', pair='TKN/BTC')
+    assert api_mock.cancel_order.call_count == API_RETRY_COUNT + 1
 
-    with pytest.raises(OperationalException):
-        api_mock.cancel_order = MagicMock(side_effect=ccxt.BaseError)
-        mocker.patch('freqtrade.exchange._API', api_mock)
-        cancel_order(order_id='_', pair='TKN/BTC')
-    assert api_mock.cancel_order.call_count == 1
+    ccxt_exceptionhandlers(mocker, default_conf, api_mock,
+                           "cancel_order", "cancel_order",
+                           order_id='_', pair='TKN/BTC')
 
 
 def test_get_order(default_conf, mocker):
     default_conf['dry_run'] = True
-    mocker.patch.dict('freqtrade.exchange._CONF', default_conf)
     order = MagicMock()
     order.myid = 123
-    exchange._DRY_RUN_OPEN_ORDERS['X'] = order
+    exchange = get_patched_exchange(mocker, default_conf)
+    exchange._dry_run_open_orders['X'] = order
     print(exchange.get_order('X', 'TKN/BTC'))
     assert exchange.get_order('X', 'TKN/BTC').myid == 123
 
     default_conf['dry_run'] = False
-    mocker.patch.dict('freqtrade.exchange._CONF', default_conf)
     api_mock = MagicMock()
     api_mock.fetch_order = MagicMock(return_value=456)
-    mocker.patch('freqtrade.exchange._API', api_mock)
+    exchange = get_patched_exchange(mocker, default_conf, api_mock)
     assert exchange.get_order('X', 'TKN/BTC') == 456
 
-    with pytest.raises(TemporaryError):
-        api_mock.fetch_order = MagicMock(side_effect=ccxt.NetworkError)
-        mocker.patch('freqtrade.exchange._API', api_mock)
-        exchange.get_order(order_id='_', pair='TKN/BTC')
-    assert api_mock.fetch_order.call_count == exchange.API_RETRY_COUNT + 1
-
     with pytest.raises(DependencyException):
         api_mock.fetch_order = MagicMock(side_effect=ccxt.InvalidOrder)
-        mocker.patch('freqtrade.exchange._API', api_mock)
+        exchange = get_patched_exchange(mocker, default_conf, api_mock)
         exchange.get_order(order_id='_', pair='TKN/BTC')
-    assert api_mock.fetch_order.call_count == exchange.API_RETRY_COUNT + 1
+    assert api_mock.fetch_order.call_count == API_RETRY_COUNT + 1
 
-    with pytest.raises(OperationalException):
-        api_mock.fetch_order = MagicMock(side_effect=ccxt.BaseError)
-        mocker.patch('freqtrade.exchange._API', api_mock)
-        exchange.get_order(order_id='_', pair='TKN/BTC')
-    assert api_mock.fetch_order.call_count == 1
+    ccxt_exceptionhandlers(mocker, default_conf, api_mock,
+                           'get_order', 'fetch_order',
+                           order_id='_', pair='TKN/BTC')
 
 
-def test_get_name(default_conf, mocker):
-    mocker.patch('freqtrade.exchange.validate_pairs',
+def test_name(default_conf, mocker):
+    mocker.patch('freqtrade.exchange.Exchange.validate_pairs',
                  side_effect=lambda s: True)
     default_conf['exchange']['name'] = 'binance'
-    init(default_conf)
+    exchange = Exchange(default_conf)
 
-    assert get_name() == 'Binance'
+    assert exchange.name == 'Binance'
 
 
-def test_get_id(default_conf, mocker):
-    mocker.patch('freqtrade.exchange.validate_pairs',
+def test_id(default_conf, mocker):
+    mocker.patch('freqtrade.exchange.Exchange.validate_pairs',
                  side_effect=lambda s: True)
     default_conf['exchange']['name'] = 'binance'
-    init(default_conf)
-
-    assert get_id() == 'binance'
+    exchange = Exchange(default_conf)
+    assert exchange.id == 'binance'
 
 
-def test_get_pair_detail_url(default_conf, mocker):
-    mocker.patch('freqtrade.exchange.validate_pairs',
+def test_get_pair_detail_url(default_conf, mocker, caplog):
+    mocker.patch('freqtrade.exchange.Exchange.validate_pairs',
                  side_effect=lambda s: True)
     default_conf['exchange']['name'] = 'binance'
-    init(default_conf)
+    exchange = Exchange(default_conf)
 
-    url = get_pair_detail_url('TKN/ETH')
+    url = exchange.get_pair_detail_url('TKN/ETH')
     assert 'TKN' in url
     assert 'ETH' in url
 
-    url = get_pair_detail_url('LOOONG/BTC')
+    url = exchange.get_pair_detail_url('LOOONG/BTC')
     assert 'LOOONG' in url
     assert 'BTC' in url
 
     default_conf['exchange']['name'] = 'bittrex'
-    init(default_conf)
+    exchange = Exchange(default_conf)
 
-    url = get_pair_detail_url('TKN/ETH')
+    url = exchange.get_pair_detail_url('TKN/ETH')
     assert 'TKN' in url
     assert 'ETH' in url
 
-    url = get_pair_detail_url('LOOONG/BTC')
+    url = exchange.get_pair_detail_url('LOOONG/BTC')
     assert 'LOOONG' in url
     assert 'BTC' in url
 
+    default_conf['exchange']['name'] = 'poloniex'
+    exchange = Exchange(default_conf)
+    url = exchange.get_pair_detail_url('LOOONG/BTC')
+    assert '' == url
+    assert log_has('Could not get exchange url for Poloniex', caplog.record_tuples)
+
+
+def test_get_trades_for_order(default_conf, mocker):
+    order_id = 'ABCD-ABCD'
+    since = datetime(2018, 5, 5)
+    default_conf["dry_run"] = False
+    mocker.patch('freqtrade.exchange.Exchange.exchange_has', return_value=True)
+    api_mock = MagicMock()
+
+    api_mock.fetch_my_trades = MagicMock(return_value=[{'id': 'TTR67E-3PFBD-76IISV',
+                                                        'order': 'ABCD-ABCD',
+                                                        'info': {'pair': 'XLTCZBTC',
+                                                                 'time': 1519860024.4388,
+                                                                 'type': 'buy',
+                                                                 'ordertype': 'limit',
+                                                                 'price': '20.00000',
+                                                                 'cost': '38.62000',
+                                                                 'fee': '0.06179',
+                                                                 'vol': '5',
+                                                                 'id': 'ABCD-ABCD'},
+                                                        'timestamp': 1519860024438,
+                                                        'datetime': '2018-02-28T23:20:24.438Z',
+                                                        'symbol': 'LTC/BTC',
+                                                        'type': 'limit',
+                                                        'side': 'buy',
+                                                        'price': 165.0,
+                                                        'amount': 0.2340606,
+                                                        'fee': {'cost': 0.06179, 'currency': 'BTC'}
+                                                        }])
+    exchange = get_patched_exchange(mocker, default_conf, api_mock)
+
+    orders = exchange.get_trades_for_order(order_id, 'LTC/BTC', since)
+    assert len(orders) == 1
+    assert orders[0]['price'] == 165
+
+    ccxt_exceptionhandlers(mocker, default_conf, api_mock,
+                           'get_trades_for_order', 'fetch_my_trades',
+                           order_id=order_id, pair='LTC/BTC', since=since)
+
+    mocker.patch('freqtrade.exchange.Exchange.exchange_has', MagicMock(return_value=False))
+    assert exchange.get_trades_for_order(order_id, 'LTC/BTC', since) == []
+
+
+def test_get_markets(default_conf, mocker, markets):
+    api_mock = MagicMock()
+    api_mock.fetch_markets = markets
+    exchange = get_patched_exchange(mocker, default_conf, api_mock)
+    ret = exchange.get_markets()
+    assert isinstance(ret, list)
+    assert len(ret) == 6
+
+    assert ret[0]["id"] == "ethbtc"
+    assert ret[0]["symbol"] == "ETH/BTC"
+
+    ccxt_exceptionhandlers(mocker, default_conf, api_mock,
+                           'get_markets', 'fetch_markets')
+
 
 def test_get_fee(default_conf, mocker):
     api_mock = MagicMock()
@@ -601,12 +682,21 @@ def test_get_fee(default_conf, mocker):
         'rate': 0.025,
         'cost': 0.05
     })
-    mocker.patch('freqtrade.exchange._API', api_mock)
-    assert get_fee() == 0.025
+    exchange = get_patched_exchange(mocker, default_conf, api_mock)
+
+    assert exchange.get_fee() == 0.025
+
+    ccxt_exceptionhandlers(mocker, default_conf, api_mock,
+                           'get_fee', 'calculate_fee')
 
 
 def test_get_amount_lots(default_conf, mocker):
     api_mock = MagicMock()
     api_mock.amount_to_lots = MagicMock(return_value=1.0)
-    mocker.patch('freqtrade.exchange._API', api_mock)
-    assert get_amount_lots('LTC/BTC', 1.54) == 1
+    api_mock.markets = None
+    marketmock = MagicMock()
+    api_mock.load_markets = marketmock
+    exchange = get_patched_exchange(mocker, default_conf, api_mock)
+
+    assert exchange.get_amount_lots('LTC/BTC', 1.54) == 1
+    assert marketmock.call_count == 1

freqtrade/tests/optimize/test_backtesting.py

@@ -9,13 +9,15 @@ from unittest.mock import MagicMock
 
 import numpy as np
 import pandas as pd
+import pytest
 from arrow import Arrow
 
-from freqtrade import optimize
+from freqtrade import DependencyException, constants, optimize
 from freqtrade.analyze import Analyze
 from freqtrade.arguments import Arguments, TimeRange
-from freqtrade.optimize.backtesting import Backtesting, start, setup_configuration
-from freqtrade.tests.conftest import log_has
+from freqtrade.optimize.backtesting import (Backtesting, setup_configuration,
+                                            start)
+from freqtrade.tests.conftest import log_has, patch_exchange
 
 
 def get_args(args) -> List[str]:
@@ -83,7 +85,7 @@ def load_data_test(what):
 
 
 def simple_backtest(config, contour, num_results, mocker) -> None:
-    mocker.patch('freqtrade.exchange.validate_pairs', MagicMock(return_value=True))
+    patch_exchange(mocker)
     backtesting = Backtesting(config)
 
     data = load_data_test(contour)
@@ -101,7 +103,8 @@ def simple_backtest(config, contour, num_results, mocker) -> None:
     assert len(results) == num_results
 
 
-def mocked_load_data(datadir, pairs=[], ticker_interval='0m', refresh_pairs=False, timerange=None):
+def mocked_load_data(datadir, pairs=[], ticker_interval='0m', refresh_pairs=False,
+                     timerange=None, exchange=None):
     tickerdata = optimize.load_tickerdata_file(datadir, 'UNITTEST/BTC', '1m', timerange=timerange)
     pairdata = {'UNITTEST/BTC': tickerdata}
     return pairdata
@@ -118,7 +121,7 @@ def _load_pair_as_ticks(pair, tickfreq):
 def _make_backtest_conf(mocker, conf=None, pair='UNITTEST/BTC', record=None):
     data = optimize.load_data(None, ticker_interval='8m', pairs=[pair])
     data = trim_dictlist(data, -201)
-    mocker.patch('freqtrade.exchange.validate_pairs', MagicMock(return_value=True))
+    patch_exchange(mocker)
     backtesting = Backtesting(conf)
     return {
         'stake_amount': conf['stake_amount'],
@@ -267,13 +270,35 @@ def test_setup_configuration_with_arguments(mocker, default_conf, caplog) -> Non
     )
 
 
+def test_setup_configuration_unlimited_stake_amount(mocker, default_conf, caplog) -> None:
+    """
+    Test setup_configuration() function
+    """
+
+    conf = deepcopy(default_conf)
+    conf['stake_amount'] = constants.UNLIMITED_STAKE_AMOUNT
+
+    mocker.patch('freqtrade.configuration.open', mocker.mock_open(
+        read_data=json.dumps(conf)
+    ))
+
+    args = [
+        '--config', 'config.json',
+        '--strategy', 'DefaultStrategy',
+        'backtesting'
+    ]
+
+    with pytest.raises(DependencyException, match=r'.*stake amount.*'):
+        setup_configuration(get_args(args))
+
+
 def test_start(mocker, fee, default_conf, caplog) -> None:
     """
     Test start() function
     """
     start_mock = MagicMock()
-    mocker.patch('freqtrade.exchange.get_fee', fee)
-    mocker.patch('freqtrade.exchange.validate_pairs', MagicMock(return_value=True))
+    mocker.patch('freqtrade.exchange.Exchange.get_fee', fee)
+    patch_exchange(mocker)
     mocker.patch('freqtrade.optimize.backtesting.Backtesting.start', start_mock)
     mocker.patch('freqtrade.configuration.open', mocker.mock_open(
         read_data=json.dumps(default_conf)
@@ -296,7 +321,8 @@ def test_backtesting_init(mocker, default_conf) -> None:
     """
     Test Backtesting._init() method
     """
-    mocker.patch('freqtrade.exchange.validate_pairs', MagicMock(return_value=True))
+    patch_exchange(mocker)
+    get_fee = mocker.patch('freqtrade.exchange.Exchange.get_fee', MagicMock(return_value=0.5))
     backtesting = Backtesting(default_conf)
     assert backtesting.config == default_conf
     assert isinstance(backtesting.analyze, Analyze)
@@ -304,13 +330,15 @@ def test_backtesting_init(mocker, default_conf) -> None:
     assert callable(backtesting.tickerdata_to_dataframe)
     assert callable(backtesting.populate_buy_trend)
     assert callable(backtesting.populate_sell_trend)
+    get_fee.assert_called()
+    assert backtesting.fee == 0.5
 
 
 def test_tickerdata_to_dataframe(default_conf, mocker) -> None:
     """
     Test Backtesting.tickerdata_to_dataframe() method
     """
-    mocker.patch('freqtrade.exchange.validate_pairs', MagicMock(return_value=True))
+    patch_exchange(mocker)
     timerange = TimeRange(None, 'line', 0, -100)
     tick = optimize.load_tickerdata_file(None, 'UNITTEST/BTC', '1m', timerange=timerange)
     tickerlist = {'UNITTEST/BTC': tick}
@@ -329,7 +357,7 @@ def test_get_timeframe(default_conf, mocker) -> None:
     """
     Test Backtesting.get_timeframe() method
     """
-    mocker.patch('freqtrade.exchange.validate_pairs', MagicMock(return_value=True))
+    patch_exchange(mocker)
     backtesting = Backtesting(default_conf)
 
     data = backtesting.tickerdata_to_dataframe(
@@ -348,15 +376,15 @@ def test_generate_text_table(default_conf, mocker):
     """
     Test Backtesting.generate_text_table() method
     """
-    mocker.patch('freqtrade.exchange.validate_pairs', MagicMock(return_value=True))
+    patch_exchange(mocker)
     backtesting = Backtesting(default_conf)
 
     results = pd.DataFrame(
         {
-            'currency': ['ETH/BTC', 'ETH/BTC'],
+            'pair': ['ETH/BTC', 'ETH/BTC'],
             'profit_percent': [0.1, 0.2],
-            'profit_BTC': [0.2, 0.4],
-            'duration': [10, 30],
+            'profit_abs': [0.2, 0.4],
+            'trade_duration': [10, 30],
             'profit': [2, 0],
             'loss': [0, 0]
         }
@@ -385,8 +413,8 @@ def test_backtesting_start(default_conf, mocker, caplog) -> None:
 
     mocker.patch('freqtrade.freqtradebot.Analyze', MagicMock())
     mocker.patch('freqtrade.optimize.load_data', mocked_load_data)
-    mocker.patch('freqtrade.exchange.get_ticker_history')
-    mocker.patch('freqtrade.exchange.validate_pairs', MagicMock(return_value=True))
+    mocker.patch('freqtrade.exchange.Exchange.get_ticker_history')
+    patch_exchange(mocker)
     mocker.patch.multiple(
         'freqtrade.optimize.backtesting.Backtesting',
         backtest=MagicMock(),
@@ -426,8 +454,8 @@ def test_backtesting_start_no_data(default_conf, mocker, caplog) -> None:
 
     mocker.patch('freqtrade.freqtradebot.Analyze', MagicMock())
     mocker.patch('freqtrade.optimize.load_data', MagicMock(return_value={}))
-    mocker.patch('freqtrade.exchange.get_ticker_history')
-    mocker.patch('freqtrade.exchange.validate_pairs', MagicMock(return_value=True))
+    mocker.patch('freqtrade.exchange.Exchange.get_ticker_history')
+    patch_exchange(mocker)
     mocker.patch.multiple(
         'freqtrade.optimize.backtesting.Backtesting',
         backtest=MagicMock(),
@@ -454,8 +482,8 @@ def test_backtest(default_conf, fee, mocker) -> None:
     """
     Test Backtesting.backtest() method
     """
-    mocker.patch('freqtrade.exchange.get_fee', fee)
-    mocker.patch('freqtrade.exchange.validate_pairs', MagicMock(return_value=True))
+    mocker.patch('freqtrade.exchange.Exchange.get_fee', fee)
+    patch_exchange(mocker)
     backtesting = Backtesting(default_conf)
 
     data = optimize.load_data(None, ticker_interval='5m', pairs=['UNITTEST/BTC'])
@@ -469,14 +497,15 @@ def test_backtest(default_conf, fee, mocker) -> None:
         }
     )
     assert not results.empty
+    assert len(results) == 2
 
 
 def test_backtest_1min_ticker_interval(default_conf, fee, mocker) -> None:
     """
     Test Backtesting.backtest() method with 1 min ticker
     """
-    mocker.patch('freqtrade.exchange.get_fee', fee)
-    mocker.patch('freqtrade.exchange.validate_pairs', MagicMock(return_value=True))
+    mocker.patch('freqtrade.exchange.Exchange.get_fee', fee)
+    patch_exchange(mocker)
     backtesting = Backtesting(default_conf)
 
     # Run a backtesting for an exiting 5min ticker_interval
@@ -491,13 +520,14 @@ def test_backtest_1min_ticker_interval(default_conf, fee, mocker) -> None:
         }
     )
     assert not results.empty
+    assert len(results) == 1
 
 
 def test_processed(default_conf, mocker) -> None:
     """
     Test Backtesting.backtest() method with offline data
     """
-    mocker.patch('freqtrade.exchange.validate_pairs', MagicMock(return_value=True))
+    patch_exchange(mocker)
     backtesting = Backtesting(default_conf)
 
     dict_of_tickerrows = load_data_test('raise')
@@ -511,16 +541,16 @@ def test_processed(default_conf, mocker) -> None:
 
 
 def test_backtest_pricecontours(default_conf, fee, mocker) -> None:
-    mocker.patch('freqtrade.optimize.backtesting.exchange.get_fee', fee)
-    tests = [['raise', 17], ['lower', 0], ['sine', 16]]
+    mocker.patch('freqtrade.exchange.Exchange.get_fee', fee)
+    tests = [['raise', 18], ['lower', 0], ['sine', 16]]
     for [contour, numres] in tests:
         simple_backtest(default_conf, contour, numres, mocker)
 
 
 # Test backtest using offline data (testdata directory)
 def test_backtest_ticks(default_conf, fee, mocker):
-    mocker.patch('freqtrade.exchange.get_fee', fee)
-    mocker.patch('freqtrade.exchange.validate_pairs', MagicMock(return_value=True))
+    mocker.patch('freqtrade.exchange.Exchange.get_fee', fee)
+    patch_exchange(mocker)
     ticks = [1, 5]
     fun = Backtesting(default_conf).populate_buy_trend
     for _ in ticks:
@@ -539,7 +569,6 @@ def test_backtest_clash_buy_sell(mocker, default_conf):
         sell_value = 1
         return _trend(dataframe, buy_value, sell_value)
 
-    mocker.patch('freqtrade.exchange.validate_pairs', MagicMock(return_value=True))
     backtest_conf = _make_backtest_conf(mocker, conf=default_conf)
     backtesting = Backtesting(default_conf)
     backtesting.populate_buy_trend = fun  # Override
@@ -555,7 +584,6 @@ def test_backtest_only_sell(mocker, default_conf):
         sell_value = 1
         return _trend(dataframe, buy_value, sell_value)
 
-    mocker.patch('freqtrade.exchange.validate_pairs', MagicMock(return_value=True))
     backtest_conf = _make_backtest_conf(mocker, conf=default_conf)
     backtesting = Backtesting(default_conf)
     backtesting.populate_buy_trend = fun  # Override
@@ -565,50 +593,68 @@ def test_backtest_only_sell(mocker, default_conf):
 
 
 def test_backtest_alternate_buy_sell(default_conf, fee, mocker):
-    mocker.patch('freqtrade.optimize.backtesting.exchange.get_fee', fee)
-    mocker.patch('freqtrade.exchange.validate_pairs', MagicMock(return_value=True))
+    mocker.patch('freqtrade.exchange.Exchange.get_fee', fee)
     backtest_conf = _make_backtest_conf(mocker, conf=default_conf, pair='UNITTEST/BTC')
     backtesting = Backtesting(default_conf)
     backtesting.populate_buy_trend = _trend_alternate  # Override
     backtesting.populate_sell_trend = _trend_alternate  # Override
     results = backtesting.backtest(backtest_conf)
-    assert len(results) == 3
+    backtesting._store_backtest_result("test_.json", results)
+    assert len(results) == 4
+    # One trade was force-closed at the end
+    assert len(results.loc[results.open_at_end]) == 1
 
 
 def test_backtest_record(default_conf, fee, mocker):
     names = []
     records = []
-    mocker.patch('freqtrade.exchange.validate_pairs', MagicMock(return_value=True))
-    mocker.patch('freqtrade.optimize.backtesting.exchange.get_fee', fee)
+    patch_exchange(mocker)
+    mocker.patch('freqtrade.exchange.Exchange.get_fee', fee)
     mocker.patch(
         'freqtrade.optimize.backtesting.file_dump_json',
         new=lambda n, r: (names.append(n), records.append(r))
     )
-    backtest_conf = _make_backtest_conf(
-        mocker,
-        conf=default_conf,
-        pair='UNITTEST/BTC',
-        record="trades"
-    )
+
     backtesting = Backtesting(default_conf)
-    backtesting.populate_buy_trend = _trend_alternate  # Override
-    backtesting.populate_sell_trend = _trend_alternate  # Override
-    results = backtesting.backtest(backtest_conf)
-    assert len(results) == 3
+    results = pd.DataFrame({"pair": ["UNITTEST/BTC", "UNITTEST/BTC",
+                                     "UNITTEST/BTC", "UNITTEST/BTC"],
+                            "profit_percent": [0.003312, 0.010801, 0.013803, 0.002780],
+                            "profit_abs": [0.000003, 0.000011, 0.000014, 0.000003],
+                            "open_time": [Arrow(2017, 11, 14, 19, 32, 00).datetime,
+                                          Arrow(2017, 11, 14, 21, 36, 00).datetime,
+                                          Arrow(2017, 11, 14, 22, 12, 00).datetime,
+                                          Arrow(2017, 11, 14, 22, 44, 00).datetime],
+                            "close_time": [Arrow(2017, 11, 14, 21, 35, 00).datetime,
+                                           Arrow(2017, 11, 14, 22, 10, 00).datetime,
+                                           Arrow(2017, 11, 14, 22, 43, 00).datetime,
+                                           Arrow(2017, 11, 14, 22, 58, 00).datetime],
+                            "open_rate": [0.002543, 0.003003, 0.003089, 0.003214],
+                            "close_rate": [0.002546, 0.003014, 0.003103, 0.003217],
+                            "open_index": [1, 119, 153, 185],
+                            "close_index": [118, 151, 184, 199],
+                            "trade_duration": [123, 34, 31, 14],
+                            "open_at_end": [False, False, False, True]
+                            })
+    backtesting._store_backtest_result("backtest-result.json", results)
+    assert len(results) == 4
     # Assert file_dump_json was only called once
     assert names == ['backtest-result.json']
     records = records[0]
     # Ensure records are of correct type
-    assert len(records) == 3
+    assert len(records) == 4
     # ('UNITTEST/BTC', 0.00331158, '1510684320', '1510691700', 0, 117)
     # Below follows just a typecheck of the schema/type of trade-records
     oix = None
-    for (pair, profit, date_buy, date_sell, buy_index, dur) in records:
+    for (pair, profit, date_buy, date_sell, buy_index, dur,
+         openr, closer, open_at_end) in records:
         assert pair == 'UNITTEST/BTC'
-        isinstance(profit, float)
+        assert isinstance(profit, float)
         # FIX: buy/sell should be converted to ints
-        isinstance(date_buy, str)
-        isinstance(date_sell, str)
+        assert isinstance(date_buy, float)
+        assert isinstance(date_sell, float)
+        assert isinstance(openr, float)
+        assert isinstance(closer, float)
+        assert isinstance(open_at_end, bool)
         isinstance(buy_index, pd._libs.tslib.Timestamp)
         if oix:
             assert buy_index > oix
@@ -619,9 +665,9 @@ def test_backtest_record(default_conf, fee, mocker):
 def test_backtest_start_live(default_conf, mocker, caplog):
     conf = deepcopy(default_conf)
     conf['exchange']['pair_whitelist'] = ['UNITTEST/BTC']
-    mocker.patch('freqtrade.exchange.get_ticker_history',
-                 new=lambda n, i: _load_pair_as_ticks(n, i))
-    mocker.patch('freqtrade.exchange.validate_pairs', MagicMock())
+    mocker.patch('freqtrade.exchange.Exchange.get_ticker_history',
+                 new=lambda s, n, i: _load_pair_as_ticks(n, i))
+    patch_exchange(mocker)
     mocker.patch('freqtrade.optimize.backtesting.Backtesting.backtest', MagicMock())
     mocker.patch('freqtrade.optimize.backtesting.Backtesting._generate_text_table', MagicMock())
     mocker.patch('freqtrade.configuration.open', mocker.mock_open(

freqtrade/tests/optimize/test_hyperopt.py

@@ -1,6 +1,5 @@
 # pragma pylint: disable=missing-docstring,W0212,C0103
 import os
-import signal
 from copy import deepcopy
 from unittest.mock import MagicMock
 
@@ -10,7 +9,7 @@ import pytest
 from freqtrade.optimize.__init__ import load_tickerdata_file
 from freqtrade.optimize.hyperopt import Hyperopt, start
 from freqtrade.strategy.resolver import StrategyResolver
-from freqtrade.tests.conftest import log_has
+from freqtrade.tests.conftest import log_has, patch_exchange
 from freqtrade.tests.optimize.test_backtesting import get_args
 
 # Avoid to reinit the same object again and again
@@ -22,10 +21,7 @@ _HYPEROPT = None
 def init_hyperopt(default_conf, mocker):
     global _HYPEROPT_INITIALIZED, _HYPEROPT
     if not _HYPEROPT_INITIALIZED:
-        mocker.patch('freqtrade.exchange.validate_pairs', MagicMock(return_value=True))
-        mocker.patch('freqtrade.optimize.hyperopt.hyperopt_optimize_conf',
-                     MagicMock(return_value=default_conf))
-        mocker.patch('freqtrade.exchange.validate_pairs', MagicMock())
+        patch_exchange(mocker)
         _HYPEROPT = Hyperopt(default_conf)
         _HYPEROPT_INITIALIZED = True
 
@@ -43,30 +39,22 @@ def create_trials(mocker) -> None:
     mocker.patch('freqtrade.optimize.hyperopt.os.path.exists', return_value=False)
     mocker.patch('freqtrade.optimize.hyperopt.os.path.getsize', return_value=1)
     mocker.patch('freqtrade.optimize.hyperopt.os.remove', return_value=True)
-    mocker.patch('freqtrade.optimize.hyperopt.pickle.dump', return_value=None)
+    mocker.patch('freqtrade.optimize.hyperopt.dump', return_value=None)
 
-    return mocker.Mock(
-        results=[
-            {
-                'loss': 1,
-                'result': 'foo',
-                'status': 'ok'
-            }
-        ],
-        best_trial={'misc': {'vals': {'adx': 999}}}
-    )
+    return [{'loss': 1, 'result': 'foo', 'params': {}}]
 
 
-# Unit tests
 def test_start(mocker, default_conf, caplog) -> None:
     """
     Test start() function
     """
     start_mock = MagicMock()
+    mocker.patch(
+        'freqtrade.configuration.Configuration._load_config_file',
+        lambda *args, **kwargs: default_conf
+    )
     mocker.patch('freqtrade.optimize.hyperopt.Hyperopt.start', start_mock)
-    mocker.patch('freqtrade.optimize.hyperopt.hyperopt_optimize_conf',
-                 MagicMock(return_value=default_conf))
-    mocker.patch('freqtrade.freqtradebot.exchange.validate_pairs', MagicMock())
+    patch_exchange(mocker)
 
     args = [
         '--config', 'config.json',
@@ -149,159 +137,18 @@ def test_no_log_if_loss_does_not_improve(init_hyperopt, caplog) -> None:
     assert caplog.record_tuples == []
 
 
-def test_fmin_best_results(mocker, init_hyperopt, default_conf, caplog) -> None:
-    fmin_result = {
-        "macd_below_zero": 0,
-        "adx": 1,
-        "adx-value": 15.0,
-        "fastd": 1,
-        "fastd-value": 40.0,
-        "green_candle": 1,
-        "mfi": 0,
-        "over_sar": 0,
-        "rsi": 1,
-        "rsi-value": 37.0,
-        "trigger": 2,
-        "uptrend_long_ema": 1,
-        "uptrend_short_ema": 0,
-        "uptrend_sma": 0,
-        "stoploss": -0.1,
-        "roi_t1": 1,
-        "roi_t2": 2,
-        "roi_t3": 3,
-        "roi_p1": 1,
-        "roi_p2": 2,
-        "roi_p3": 3,
-    }
-
-    conf = deepcopy(default_conf)
-    conf.update({'config': 'config.json.example'})
-    conf.update({'epochs': 1})
-    conf.update({'timerange': None})
-    conf.update({'spaces': 'all'})
-
-    mocker.patch('freqtrade.optimize.hyperopt.load_data', MagicMock())
-    mocker.patch('freqtrade.optimize.hyperopt.fmin', return_value=fmin_result)
-    mocker.patch('freqtrade.optimize.hyperopt.hyperopt_optimize_conf', return_value=conf)
-    mocker.patch('freqtrade.freqtradebot.exchange.validate_pairs', MagicMock())
-
-    StrategyResolver({'strategy': 'DefaultStrategy'})
-    hyperopt = Hyperopt(conf)
-    hyperopt.trials = create_trials(mocker)
-    hyperopt.tickerdata_to_dataframe = MagicMock()
-    hyperopt.start()
-
-    exists = [
-        'Best parameters:',
-        '"adx": {\n        "enabled": true,\n        "value": 15.0\n    },',
-        '"fastd": {\n        "enabled": true,\n        "value": 40.0\n    },',
-        '"green_candle": {\n        "enabled": true\n    },',
-        '"macd_below_zero": {\n        "enabled": false\n    },',
-        '"mfi": {\n        "enabled": false\n    },',
-        '"over_sar": {\n        "enabled": false\n    },',
-        '"roi_p1": 1.0,',
-        '"roi_p2": 2.0,',
-        '"roi_p3": 3.0,',
-        '"roi_t1": 1.0,',
-        '"roi_t2": 2.0,',
-        '"roi_t3": 3.0,',
-        '"rsi": {\n        "enabled": true,\n        "value": 37.0\n    },',
-        '"stoploss": -0.1,',
-        '"trigger": {\n        "type": "faststoch10"\n    },',
-        '"uptrend_long_ema": {\n        "enabled": true\n    },',
-        '"uptrend_short_ema": {\n        "enabled": false\n    },',
-        '"uptrend_sma": {\n        "enabled": false\n    }',
-        'ROI table:\n{0: 6.0, 3.0: 3.0, 5.0: 1.0, 6.0: 0}',
-        'Best Result:\nfoo'
-    ]
-    for line in exists:
-        assert line in caplog.text
-
-
-def test_fmin_throw_value_error(mocker, init_hyperopt, default_conf, caplog) -> None:
-    mocker.patch('freqtrade.optimize.hyperopt.load_data', MagicMock())
-    mocker.patch('freqtrade.optimize.hyperopt.fmin', side_effect=ValueError())
-
-    conf = deepcopy(default_conf)
-    conf.update({'config': 'config.json.example'})
-    conf.update({'epochs': 1})
-    conf.update({'timerange': None})
-    conf.update({'spaces': 'all'})
-    mocker.patch('freqtrade.optimize.hyperopt.hyperopt_optimize_conf', return_value=conf)
-    mocker.patch('freqtrade.freqtradebot.exchange.validate_pairs', MagicMock())
-
-    StrategyResolver({'strategy': 'DefaultStrategy'})
-    hyperopt = Hyperopt(conf)
-    hyperopt.trials = create_trials(mocker)
-    hyperopt.tickerdata_to_dataframe = MagicMock()
-
-    hyperopt.start()
-
-    exists = [
-        'Best Result:',
-        'Sorry, Hyperopt was not able to find good parameters. Please try with more epochs '
-        '(param: -e).',
-    ]
-
-    for line in exists:
-        assert line in caplog.text
-
-
-def test_resuming_previous_hyperopt_results_succeeds(mocker, init_hyperopt, default_conf) -> None:
-    trials = create_trials(mocker)
-
-    conf = deepcopy(default_conf)
-    conf.update({'config': 'config.json.example'})
-    conf.update({'epochs': 1})
-    conf.update({'mongodb': False})
-    conf.update({'timerange': None})
-    conf.update({'spaces': 'all'})
-
-    mocker.patch('freqtrade.optimize.hyperopt.os.path.exists', return_value=True)
-    mocker.patch('freqtrade.optimize.hyperopt.len', return_value=len(trials.results))
-    mock_read = mocker.patch(
-        'freqtrade.optimize.hyperopt.Hyperopt.read_trials',
-        return_value=trials
-    )
-    mock_save = mocker.patch(
-        'freqtrade.optimize.hyperopt.Hyperopt.save_trials',
-        return_value=None
-    )
-    mocker.patch('freqtrade.optimize.hyperopt.sorted', return_value=trials.results)
-    mocker.patch('freqtrade.optimize.hyperopt.load_data', MagicMock())
-    mocker.patch('freqtrade.optimize.hyperopt.fmin', return_value={})
-    mocker.patch('freqtrade.optimize.hyperopt.hyperopt_optimize_conf', return_value=conf)
-    mocker.patch('freqtrade.exchange.validate_pairs', MagicMock())
-
-    StrategyResolver({'strategy': 'DefaultStrategy'})
-    hyperopt = Hyperopt(conf)
-    hyperopt.trials = trials
-    hyperopt.tickerdata_to_dataframe = MagicMock()
-
-    hyperopt.start()
-
-    mock_read.assert_called_once()
-    mock_save.assert_called_once()
-
-    current_tries = hyperopt.current_tries
-    total_tries = hyperopt.total_tries
-
-    assert current_tries == len(trials.results)
-    assert total_tries == (current_tries + len(trials.results))
-
-
 def test_save_trials_saves_trials(mocker, init_hyperopt, caplog) -> None:
-    create_trials(mocker)
-    mock_dump = mocker.patch('freqtrade.optimize.hyperopt.pickle.dump', return_value=None)
+    trials = create_trials(mocker)
+    mock_dump = mocker.patch('freqtrade.optimize.hyperopt.dump', return_value=None)
 
     hyperopt = _HYPEROPT
-    mocker.patch('freqtrade.optimize.hyperopt.open', return_value=hyperopt.trials_file)
+    _HYPEROPT.trials = trials
 
     hyperopt.save_trials()
 
     trials_file = os.path.join('freqtrade', 'tests', 'optimize', 'ut_trials.pickle')
     assert log_has(
-        'Saving Trials to \'{}\''.format(trials_file),
+        'Saving 1 evaluations to \'{}\''.format(trials_file),
         caplog.record_tuples
     )
     mock_dump.assert_called_once()
@@ -309,8 +156,7 @@ def test_save_trials_saves_trials(mocker, init_hyperopt, caplog) -> None:
 
 def test_read_trials_returns_trials_file(mocker, init_hyperopt, caplog) -> None:
     trials = create_trials(mocker)
-    mock_load = mocker.patch('freqtrade.optimize.hyperopt.pickle.load', return_value=trials)
-    mock_open = mocker.patch('freqtrade.optimize.hyperopt.open', return_value=mock_load)
+    mock_load = mocker.patch('freqtrade.optimize.hyperopt.load', return_value=trials)
 
     hyperopt = _HYPEROPT
     hyperopt_trial = hyperopt.read_trials()
@@ -320,7 +166,6 @@ def test_read_trials_returns_trials_file(mocker, init_hyperopt, caplog) -> None:
         caplog.record_tuples
     )
     assert hyperopt_trial == trials
-    mock_open.assert_called_once()
     mock_load.assert_called_once()
 
 
@@ -338,56 +183,31 @@ def test_roi_table_generation(init_hyperopt) -> None:
     assert hyperopt.generate_roi_table(params) == {0: 6, 15: 3, 25: 1, 30: 0}
 
 
-def test_start_calls_fmin(mocker, init_hyperopt, default_conf) -> None:
-    trials = create_trials(mocker)
-    mocker.patch('freqtrade.optimize.hyperopt.sorted', return_value=trials.results)
+def test_start_calls_optimizer(mocker, init_hyperopt, default_conf, caplog) -> None:
+    dumper = mocker.patch('freqtrade.optimize.hyperopt.dump', MagicMock())
     mocker.patch('freqtrade.optimize.hyperopt.load_data', MagicMock())
-    mocker.patch('freqtrade.exchange.validate_pairs', MagicMock())
-    mock_fmin = mocker.patch('freqtrade.optimize.hyperopt.fmin', return_value={})
-
-    conf = deepcopy(default_conf)
-    conf.update({'config': 'config.json.example'})
-    conf.update({'epochs': 1})
-    conf.update({'mongodb': False})
-    conf.update({'timerange': None})
-    conf.update({'spaces': 'all'})
-
-    hyperopt = Hyperopt(conf)
-    hyperopt.trials = trials
-    hyperopt.tickerdata_to_dataframe = MagicMock()
-
-    hyperopt.start()
-    mock_fmin.assert_called_once()
-
-
-def test_start_uses_mongotrials(mocker, init_hyperopt, default_conf) -> None:
-    mocker.patch('freqtrade.optimize.hyperopt.load_data', MagicMock())
-    mock_fmin = mocker.patch('freqtrade.optimize.hyperopt.fmin', return_value={})
-    mock_mongotrials = mocker.patch(
-        'freqtrade.optimize.hyperopt.MongoTrials',
-        return_value=create_trials(mocker)
+    mocker.patch('freqtrade.optimize.hyperopt.multiprocessing.cpu_count', MagicMock(return_value=1))
+    parallel = mocker.patch(
+        'freqtrade.optimize.hyperopt.Hyperopt.run_optimizer_parallel',
+        MagicMock(return_value=[{'loss': 1, 'result': 'foo result', 'params': {}}])
     )
+    patch_exchange(mocker)
 
     conf = deepcopy(default_conf)
     conf.update({'config': 'config.json.example'})
     conf.update({'epochs': 1})
-    conf.update({'mongodb': True})
     conf.update({'timerange': None})
     conf.update({'spaces': 'all'})
-    mocker.patch('freqtrade.optimize.hyperopt.hyperopt_optimize_conf', return_value=conf)
-    mocker.patch('freqtrade.freqtradebot.exchange.validate_pairs', MagicMock())
 
     hyperopt = Hyperopt(conf)
     hyperopt.tickerdata_to_dataframe = MagicMock()
 
     hyperopt.start()
-    mock_mongotrials.assert_called_once()
-    mock_fmin.assert_called_once()
+    parallel.assert_called_once()
 
+    assert 'Best result:\nfoo result\nwith values:\n{}' in caplog.text
+    assert dumper.called
 
-# test log_trials_result
-# test buy_strategy_generator def populate_buy_trend
-# test optimizer if 'ro_t1' in params
 
 def test_format_results(init_hyperopt):
     """
@@ -400,7 +220,7 @@ def test_format_results(init_hyperopt):
         ('LTC/BTC', 1, 1, 123),
         ('XPR/BTC', -1, -2, -246)
     ]
-    labels = ['currency', 'profit_percent', 'profit_BTC', 'duration']
+    labels = ['currency', 'profit_percent', 'profit_abs', 'trade_duration']
     df = pd.DataFrame.from_records(trades, columns=labels)
 
     result = _HYPEROPT.format_results(df)
@@ -419,20 +239,6 @@ def test_format_results(init_hyperopt):
     assert result.find('Total profit 1.00000000 EUR')
 
 
-def test_signal_handler(mocker, init_hyperopt):
-    """
-    Test Hyperopt.signal_handler()
-    """
-    m = MagicMock()
-    mocker.patch('sys.exit', m)
-    mocker.patch('freqtrade.optimize.hyperopt.Hyperopt.save_trials', m)
-    mocker.patch('freqtrade.optimize.hyperopt.Hyperopt.log_trials_result', m)
-
-    hyperopt = _HYPEROPT
-    hyperopt.signal_handler(signal.SIGTERM, None)
-    assert m.call_count == 3
-
-
 def test_has_space(init_hyperopt):
     """
     Test Hyperopt.has_space() method
@@ -457,8 +263,8 @@ def test_populate_indicators(init_hyperopt) -> None:
 
     # Check if some indicators are generated. We will not test all of them
     assert 'adx' in dataframe
-    assert 'ao' in dataframe
-    assert 'cci' in dataframe
+    assert 'mfi' in dataframe
+    assert 'rsi' in dataframe
 
 
 def test_buy_strategy_generator(init_hyperopt) -> None:
@@ -472,44 +278,15 @@ def test_buy_strategy_generator(init_hyperopt) -> None:
 
     populate_buy_trend = _HYPEROPT.buy_strategy_generator(
         {
-            'uptrend_long_ema': {
-                'enabled': True
-            },
-            'macd_below_zero': {
-                'enabled': True
-            },
-            'uptrend_short_ema': {
-                'enabled': True
-            },
-            'mfi': {
-                'enabled': True,
-                'value': 20
-            },
-            'fastd': {
-                'enabled': True,
-                'value': 20
-            },
-            'adx': {
-                'enabled': True,
-                'value': 20
-            },
-            'rsi': {
-                'enabled': True,
-                'value': 20
-            },
-            'over_sar': {
-                'enabled': True,
-            },
-            'green_candle': {
-                'enabled': True,
-            },
-            'uptrend_sma': {
-                'enabled': True,
-            },
-
-            'trigger': {
-                'type': 'lower_bb'
-            }
+            'adx-value': 20,
+            'fastd-value': 20,
+            'mfi-value': 20,
+            'rsi-value': 20,
+            'adx-enabled': True,
+            'fastd-enabled': True,
+            'mfi-enabled': True,
+            'rsi-enabled': True,
+            'trigger': 'bb_lower'
         }
     )
     result = populate_buy_trend(dataframe)
@@ -530,43 +307,42 @@ def test_generate_optimizer(mocker, init_hyperopt, default_conf) -> None:
     trades = [
         ('POWR/BTC', 0.023117, 0.000233, 100)
     ]
-    labels = ['currency', 'profit_percent', 'profit_BTC', 'duration']
+    labels = ['currency', 'profit_percent', 'profit_abs', 'trade_duration']
     backtest_result = pd.DataFrame.from_records(trades, columns=labels)
 
     mocker.patch(
         'freqtrade.optimize.hyperopt.Hyperopt.backtest',
         MagicMock(return_value=backtest_result)
     )
-    mocker.patch('freqtrade.exchange.validate_pairs', MagicMock())
+    patch_exchange(mocker)
+    mocker.patch('freqtrade.optimize.hyperopt.load', MagicMock())
 
     optimizer_param = {
-        'adx': {'enabled': False},
-        'fastd': {'enabled': True, 'value': 35.0},
-        'green_candle': {'enabled': True},
-        'macd_below_zero': {'enabled': True},
-        'mfi': {'enabled': False},
-        'over_sar': {'enabled': False},
-        'roi_p1': 0.01,
-        'roi_p2': 0.01,
-        'roi_p3': 0.1,
+        'adx-value': 0,
+        'fastd-value': 35,
+        'mfi-value': 0,
+        'rsi-value': 0,
+        'adx-enabled': False,
+        'fastd-enabled': True,
+        'mfi-enabled': False,
+        'rsi-enabled': False,
+        'trigger': 'macd_cross_signal',
         'roi_t1': 60.0,
         'roi_t2': 30.0,
         'roi_t3': 20.0,
-        'rsi': {'enabled': False},
+        'roi_p1': 0.01,
+        'roi_p2': 0.01,
+        'roi_p3': 0.1,
         'stoploss': -0.4,
-        'trigger': {'type': 'macd_cross_signal'},
-        'uptrend_long_ema': {'enabled': False},
-        'uptrend_short_ema': {'enabled': True},
-        'uptrend_sma': {'enabled': True}
     }
 
     response_expected = {
         'loss': 1.9840569076926293,
         'result': '     1 trades. Avg profit  2.31%. Total profit  0.00023300 BTC '
                   '(0.0231Σ%). Avg duration 100.0 mins.',
-        'status': 'ok'
+        'params': optimizer_param
     }
 
     hyperopt = Hyperopt(conf)
-    generate_optimizer_value = hyperopt.generate_optimizer(optimizer_param)
+    generate_optimizer_value = hyperopt.generate_optimizer(list(optimizer_param.values()))
     assert generate_optimizer_value == response_expected

freqtrade/tests/optimize/test_hyperopt_config.py

@@ -1,16 +0,0 @@
-# pragma pylint: disable=missing-docstring,W0212
-
-from user_data.hyperopt_conf import hyperopt_optimize_conf
-
-
-def test_hyperopt_optimize_conf():
-    hyperopt_conf = hyperopt_optimize_conf()
-
-    assert "max_open_trades" in hyperopt_conf
-    assert "stake_currency" in hyperopt_conf
-    assert "stake_amount" in hyperopt_conf
-    assert "minimal_roi" in hyperopt_conf
-    assert "stoploss" in hyperopt_conf
-    assert "bid_strategy" in hyperopt_conf
-    assert "exchange" in hyperopt_conf
-    assert "pair_whitelist" in hyperopt_conf['exchange']

freqtrade/tests/optimize/test_optimize.py

@@ -3,16 +3,19 @@
 import json
 import os
 import uuid
-import arrow
 from shutil import copyfile
 
+import arrow
+
 from freqtrade import optimize
-from freqtrade.misc import file_dump_json
-from freqtrade.optimize.__init__ import make_testdata_path, download_pairs, \
-    download_backtesting_testdata, load_tickerdata_file, trim_tickerlist, \
-    load_cached_data_for_updating
 from freqtrade.arguments import TimeRange
-from freqtrade.tests.conftest import log_has
+from freqtrade.misc import file_dump_json
+from freqtrade.optimize.__init__ import (download_backtesting_testdata,
+                                         download_pairs,
+                                         load_cached_data_for_updating,
+                                         load_tickerdata_file,
+                                         make_testdata_path, trim_tickerlist)
+from freqtrade.tests.conftest import get_patched_exchange, log_has
 
 # Change this if modifying UNITTEST/BTC testdatafile
 _BTC_UNITTEST_LENGTH = 13681
@@ -49,12 +52,11 @@ def _clean_test_file(file: str) -> None:
         os.rename(file_swp, file)
 
 
-def test_load_data_30min_ticker(ticker_history, mocker, caplog) -> None:
+def test_load_data_30min_ticker(ticker_history, mocker, caplog, default_conf) -> None:
     """
     Test load_data() with 30 min ticker
     """
-    mocker.patch('freqtrade.optimize.get_ticker_history', return_value=ticker_history)
-
+    mocker.patch('freqtrade.exchange.Exchange.get_ticker_history', return_value=ticker_history)
     file = os.path.join(os.path.dirname(__file__), '..', 'testdata', 'UNITTEST_BTC-30m.json')
     _backup_file(file, copy_file=True)
     optimize.load_data(None, pairs=['UNITTEST/BTC'], ticker_interval='30m')
@@ -63,11 +65,11 @@ def test_load_data_30min_ticker(ticker_history, mocker, caplog) -> None:
     _clean_test_file(file)
 
 
-def test_load_data_5min_ticker(ticker_history, mocker, caplog) -> None:
+def test_load_data_5min_ticker(ticker_history, mocker, caplog, default_conf) -> None:
     """
     Test load_data() with 5 min ticker
     """
-    mocker.patch('freqtrade.optimize.get_ticker_history', return_value=ticker_history)
+    mocker.patch('freqtrade.exchange.Exchange.get_ticker_history', return_value=ticker_history)
 
     file = os.path.join(os.path.dirname(__file__), '..', 'testdata', 'UNITTEST_BTC-5m.json')
     _backup_file(file, copy_file=True)
@@ -81,7 +83,7 @@ def test_load_data_1min_ticker(ticker_history, mocker, caplog) -> None:
     """
     Test load_data() with 1 min ticker
     """
-    mocker.patch('freqtrade.optimize.get_ticker_history', return_value=ticker_history)
+    mocker.patch('freqtrade.exchange.Exchange.get_ticker_history', return_value=ticker_history)
 
     file = os.path.join(os.path.dirname(__file__), '..', 'testdata', 'UNITTEST_BTC-1m.json')
     _backup_file(file, copy_file=True)
@@ -91,12 +93,12 @@ def test_load_data_1min_ticker(ticker_history, mocker, caplog) -> None:
     _clean_test_file(file)
 
 
-def test_load_data_with_new_pair_1min(ticker_history, mocker, caplog) -> None:
+def test_load_data_with_new_pair_1min(ticker_history, mocker, caplog, default_conf) -> None:
     """
     Test load_data() with 1 min ticker
     """
-    mocker.patch('freqtrade.optimize.get_ticker_history', return_value=ticker_history)
-
+    mocker.patch('freqtrade.exchange.Exchange.get_ticker_history', return_value=ticker_history)
+    exchange = get_patched_exchange(mocker, default_conf)
     file = os.path.join(os.path.dirname(__file__), '..', 'testdata', 'MEME_BTC-1m.json')
 
     _backup_file(file)
@@ -114,6 +116,7 @@ def test_load_data_with_new_pair_1min(ticker_history, mocker, caplog) -> None:
     optimize.load_data(None,
                        ticker_interval='1m',
                        refresh_pairs=True,
+                       exchange=exchange,
                        pairs=['MEME/BTC'])
     assert os.path.isfile(file) is True
     assert log_has('Download the pair: "MEME/BTC", Interval: 1m', caplog.record_tuples)
@@ -124,9 +127,9 @@ def test_testdata_path() -> None:
     assert os.path.join('freqtrade', 'tests', 'testdata') in make_testdata_path(None)
 
 
-def test_download_pairs(ticker_history, mocker) -> None:
-    mocker.patch('freqtrade.optimize.__init__.get_ticker_history', return_value=ticker_history)
-
+def test_download_pairs(ticker_history, mocker, default_conf) -> None:
+    mocker.patch('freqtrade.exchange.Exchange.get_ticker_history', return_value=ticker_history)
+    exchange = get_patched_exchange(mocker, default_conf)
     file1_1 = os.path.join(os.path.dirname(__file__), '..', 'testdata', 'MEME_BTC-1m.json')
     file1_5 = os.path.join(os.path.dirname(__file__), '..', 'testdata', 'MEME_BTC-5m.json')
     file2_1 = os.path.join(os.path.dirname(__file__), '..', 'testdata', 'CFI_BTC-1m.json')
@@ -140,7 +143,8 @@ def test_download_pairs(ticker_history, mocker) -> None:
     assert os.path.isfile(file1_1) is False
     assert os.path.isfile(file2_1) is False
 
-    assert download_pairs(None, pairs=['MEME/BTC', 'CFI/BTC'], ticker_interval='1m') is True
+    assert download_pairs(None, exchange,
+                          pairs=['MEME/BTC', 'CFI/BTC'], ticker_interval='1m') is True
 
     assert os.path.isfile(file1_1) is True
     assert os.path.isfile(file2_1) is True
@@ -152,7 +156,8 @@ def test_download_pairs(ticker_history, mocker) -> None:
     assert os.path.isfile(file1_5) is False
     assert os.path.isfile(file2_5) is False
 
-    assert download_pairs(None, pairs=['MEME/BTC', 'CFI/BTC'], ticker_interval='5m') is True
+    assert download_pairs(None, exchange,
+                          pairs=['MEME/BTC', 'CFI/BTC'], ticker_interval='5m') is True
 
     assert os.path.isfile(file1_5) is True
     assert os.path.isfile(file2_5) is True
@@ -265,30 +270,32 @@ def test_load_cached_data_for_updating(mocker) -> None:
     assert start_ts is None
 
 
-def test_download_pairs_exception(ticker_history, mocker, caplog) -> None:
-    mocker.patch('freqtrade.optimize.__init__.get_ticker_history', return_value=ticker_history)
+def test_download_pairs_exception(ticker_history, mocker, caplog, default_conf) -> None:
+    mocker.patch('freqtrade.exchange.Exchange.get_ticker_history', return_value=ticker_history)
     mocker.patch('freqtrade.optimize.__init__.download_backtesting_testdata',
                  side_effect=BaseException('File Error'))
+    exchange = get_patched_exchange(mocker, default_conf)
 
     file1_1 = os.path.join(os.path.dirname(__file__), '..', 'testdata', 'MEME_BTC-1m.json')
     file1_5 = os.path.join(os.path.dirname(__file__), '..', 'testdata', 'MEME_BTC-5m.json')
     _backup_file(file1_1)
     _backup_file(file1_5)
 
-    download_pairs(None, pairs=['MEME/BTC'], ticker_interval='1m')
+    download_pairs(None, exchange, pairs=['MEME/BTC'], ticker_interval='1m')
     # clean files freshly downloaded
     _clean_test_file(file1_1)
     _clean_test_file(file1_5)
     assert log_has('Failed to download the pair: "MEME/BTC", Interval: 1m', caplog.record_tuples)
 
 
-def test_download_backtesting_testdata(ticker_history, mocker) -> None:
-    mocker.patch('freqtrade.optimize.__init__.get_ticker_history', return_value=ticker_history)
+def test_download_backtesting_testdata(ticker_history, mocker, default_conf) -> None:
+    mocker.patch('freqtrade.exchange.Exchange.get_ticker_history', return_value=ticker_history)
+    exchange = get_patched_exchange(mocker, default_conf)
 
     # Download a 1 min ticker file
     file1 = os.path.join(os.path.dirname(__file__), '..', 'testdata', 'XEL_BTC-1m.json')
     _backup_file(file1)
-    download_backtesting_testdata(None, pair="XEL/BTC", tick_interval='1m')
+    download_backtesting_testdata(None, exchange, pair="XEL/BTC", tick_interval='1m')
     assert os.path.isfile(file1) is True
     _clean_test_file(file1)
 
@@ -296,21 +303,21 @@ def test_download_backtesting_testdata(ticker_history, mocker) -> None:
     file2 = os.path.join(os.path.dirname(__file__), '..', 'testdata', 'STORJ_BTC-5m.json')
     _backup_file(file2)
 
-    download_backtesting_testdata(None, pair="STORJ/BTC", tick_interval='5m')
+    download_backtesting_testdata(None, exchange, pair="STORJ/BTC", tick_interval='5m')
     assert os.path.isfile(file2) is True
     _clean_test_file(file2)
 
 
-def test_download_backtesting_testdata2(mocker) -> None:
+def test_download_backtesting_testdata2(mocker, default_conf) -> None:
     tick = [
         [1509836520000, 0.00162008, 0.00162008, 0.00162008, 0.00162008, 108.14853839],
         [1509836580000, 0.00161, 0.00161, 0.00161, 0.00161, 82.390199]
     ]
     json_dump_mock = mocker.patch('freqtrade.misc.file_dump_json', return_value=None)
-    mocker.patch('freqtrade.optimize.__init__.get_ticker_history', return_value=tick)
-
-    download_backtesting_testdata(None, pair="UNITTEST/BTC", tick_interval='1m')
-    download_backtesting_testdata(None, pair="UNITTEST/BTC", tick_interval='3m')
+    mocker.patch('freqtrade.exchange.Exchange.get_ticker_history', return_value=tick)
+    exchange = get_patched_exchange(mocker, default_conf)
+    download_backtesting_testdata(None, exchange, pair="UNITTEST/BTC", tick_interval='1m')
+    download_backtesting_testdata(None, exchange, pair="UNITTEST/BTC", tick_interval='3m')
     assert json_dump_mock.call_count == 2
 
 
@@ -326,10 +333,10 @@ def test_load_tickerdata_file() -> None:
 
 
 def test_init(default_conf, mocker) -> None:
-    conf = {'exchange': {'pair_whitelist': []}}
-    mocker.patch('freqtrade.optimize.hyperopt_optimize_conf', return_value=conf)
+    exchange = get_patched_exchange(mocker, default_conf)
     assert {} == optimize.load_data(
         '',
+        exchange=exchange,
         pairs=[],
         refresh_pairs=True,
         ticker_interval=default_conf['ticker_interval']

freqtrade/tests/rpc/test_rpc.py

@@ -7,11 +7,14 @@ Unit test file for rpc/rpc.py
 from datetime import datetime
 from unittest.mock import MagicMock
 
+import pytest
+
 from freqtrade.freqtradebot import FreqtradeBot
 from freqtrade.persistence import Trade
-from freqtrade.rpc.rpc import RPC
+from freqtrade.rpc.rpc import RPC, RPCException
 from freqtrade.state import State
-from freqtrade.tests.test_freqtradebot import patch_get_signal, patch_coinmarketcap
+from freqtrade.tests.test_freqtradebot import (patch_coinmarketcap,
+                                               patch_get_signal)
 
 
 # Functions for recurrent object patching
@@ -23,37 +26,35 @@ def prec_satoshi(a, b) -> float:
 
 
 # Unit tests
-def test_rpc_trade_status(default_conf, ticker, fee, mocker) -> None:
+def test_rpc_trade_status(default_conf, ticker, fee, markets, mocker) -> None:
     """
     Test rpc_trade_status() method
     """
     patch_get_signal(mocker, (True, False))
     patch_coinmarketcap(mocker)
-    mocker.patch('freqtrade.rpc.rpc_manager.Telegram', MagicMock())
+    mocker.patch('freqtrade.rpc.telegram.Telegram', MagicMock())
     mocker.patch.multiple(
-        'freqtrade.freqtradebot.exchange',
+        'freqtrade.exchange.Exchange',
         validate_pairs=MagicMock(),
         get_ticker=ticker,
-        get_fee=fee
+        get_fee=fee,
+        get_markets=markets
     )
 
     freqtradebot = FreqtradeBot(default_conf)
     rpc = RPC(freqtradebot)
 
     freqtradebot.state = State.STOPPED
-    (error, result) = rpc.rpc_trade_status()
-    assert error
-    assert 'trader is not running' in result
+    with pytest.raises(RPCException, match=r'.*trader is not running*'):
+        rpc._rpc_trade_status()
 
     freqtradebot.state = State.RUNNING
-    (error, result) = rpc.rpc_trade_status()
-    assert error
-    assert 'no active trade' in result
+    with pytest.raises(RPCException, match=r'.*no active trade*'):
+        rpc._rpc_trade_status()
 
     freqtradebot.create_trade()
-    (error, result) = rpc.rpc_trade_status()
-    assert not error
-    trade = result[0]
+    trades = rpc._rpc_trade_status()
+    trade = trades[0]
 
     result_message = [
         '*Trade ID:* `1`\n'
@@ -68,57 +69,57 @@ def test_rpc_trade_status(default_conf, ticker, fee, mocker) -> None:
         '*Current Profit:* `-0.59%`\n'
         '*Open Order:* `(limit buy rem=0.00000000)`'
     ]
-    assert result == result_message
+    assert trades == result_message
     assert trade.find('[ETH/BTC]') >= 0
 
 
-def test_rpc_status_table(default_conf, ticker, fee, mocker) -> None:
+def test_rpc_status_table(default_conf, ticker, fee, markets, mocker) -> None:
     """
     Test rpc_status_table() method
     """
     patch_get_signal(mocker, (True, False))
     patch_coinmarketcap(mocker)
-    mocker.patch('freqtrade.rpc.rpc_manager.Telegram', MagicMock())
+    mocker.patch('freqtrade.rpc.telegram.Telegram', MagicMock())
     mocker.patch.multiple(
-        'freqtrade.freqtradebot.exchange',
+        'freqtrade.exchange.Exchange',
         validate_pairs=MagicMock(),
         get_ticker=ticker,
-        get_fee=fee
+        get_fee=fee,
+        get_markets=markets
     )
 
     freqtradebot = FreqtradeBot(default_conf)
     rpc = RPC(freqtradebot)
 
     freqtradebot.state = State.STOPPED
-    (error, result) = rpc.rpc_status_table()
-    assert error
-    assert '*Status:* `trader is not running`' in result
+    with pytest.raises(RPCException, match=r'.*\*Status:\* `trader is not running``*'):
+        rpc._rpc_status_table()
 
     freqtradebot.state = State.RUNNING
-    (error, result) = rpc.rpc_status_table()
-    assert error
-    assert '*Status:* `no active order`' in result
+    with pytest.raises(RPCException, match=r'.*\*Status:\* `no active order`*'):
+        rpc._rpc_status_table()
 
     freqtradebot.create_trade()
-    (error, result) = rpc.rpc_status_table()
+    result = rpc._rpc_status_table()
     assert 'just now' in result['Since'].all()
     assert 'ETH/BTC' in result['Pair'].all()
     assert '-0.59%' in result['Profit'].all()
 
 
 def test_rpc_daily_profit(default_conf, update, ticker, fee,
-                          limit_buy_order, limit_sell_order, mocker) -> None:
+                          limit_buy_order, limit_sell_order, markets, mocker) -> None:
     """
     Test rpc_daily_profit() method
     """
     patch_get_signal(mocker, (True, False))
     patch_coinmarketcap(mocker, value={'price_usd': 15000.0})
-    mocker.patch('freqtrade.rpc.rpc_manager.Telegram', MagicMock())
+    mocker.patch('freqtrade.rpc.telegram.Telegram', MagicMock())
     mocker.patch.multiple(
-        'freqtrade.freqtradebot.exchange',
+        'freqtrade.exchange.Exchange',
         validate_pairs=MagicMock(),
         get_ticker=ticker,
-        get_fee=fee
+        get_fee=fee,
+        get_markets=markets
     )
 
     freqtradebot = FreqtradeBot(default_conf)
@@ -140,8 +141,7 @@ def test_rpc_daily_profit(default_conf, update, ticker, fee,
 
     # Try valid data
     update.message.text = '/daily 2'
-    (error, days) = rpc.rpc_daily_profit(7, stake_currency, fiat_display_currency)
-    assert not error
+    days = rpc._rpc_daily_profit(7, stake_currency, fiat_display_currency)
     assert len(days) == 7
     for day in days:
         # [datetime.date(2018, 1, 11), '0.00000000 BTC', '0.000 USD']
@@ -154,13 +154,12 @@ def test_rpc_daily_profit(default_conf, update, ticker, fee,
     assert str(days[0][0]) == str(datetime.utcnow().date())
 
     # Try invalid data
-    (error, days) = rpc.rpc_daily_profit(0, stake_currency, fiat_display_currency)
-    assert error
-    assert days.find('must be an integer greater than 0') >= 0
+    with pytest.raises(RPCException, match=r'.*must be an integer greater than 0*'):
+        rpc._rpc_daily_profit(0, stake_currency, fiat_display_currency)
 
 
 def test_rpc_trade_statistics(default_conf, ticker, ticker_sell_up, fee,
-                              limit_buy_order, limit_sell_order, mocker) -> None:
+                              limit_buy_order, limit_sell_order, markets, mocker) -> None:
     """
     Test rpc_trade_statistics() method
     """
@@ -170,12 +169,13 @@ def test_rpc_trade_statistics(default_conf, ticker, ticker_sell_up, fee,
         ticker=MagicMock(return_value={'price_usd': 15000.0}),
     )
     mocker.patch('freqtrade.fiat_convert.CryptoToFiatConverter._find_price', return_value=15000.0)
-    mocker.patch('freqtrade.rpc.rpc_manager.Telegram', MagicMock())
+    mocker.patch('freqtrade.rpc.telegram.Telegram', MagicMock())
     mocker.patch.multiple(
-        'freqtrade.freqtradebot.exchange',
+        'freqtrade.exchange.Exchange',
         validate_pairs=MagicMock(),
         get_ticker=ticker,
-        get_fee=fee
+        get_fee=fee,
+        get_markets=markets
     )
 
     freqtradebot = FreqtradeBot(default_conf)
@@ -184,9 +184,8 @@ def test_rpc_trade_statistics(default_conf, ticker, ticker_sell_up, fee,
 
     rpc = RPC(freqtradebot)
 
-    (error, stats) = rpc.rpc_trade_statistics(stake_currency, fiat_display_currency)
-    assert error
-    assert stats.find('no closed trade') >= 0
+    with pytest.raises(RPCException, match=r'.*no closed trade*'):
+        rpc._rpc_trade_statistics(stake_currency, fiat_display_currency)
 
     # Create some test data
     freqtradebot.create_trade()
@@ -196,7 +195,7 @@ def test_rpc_trade_statistics(default_conf, ticker, ticker_sell_up, fee,
 
     # Update the ticker with a market going up
     mocker.patch.multiple(
-        'freqtrade.freqtradebot.exchange',
+        'freqtrade.exchange.Exchange',
         validate_pairs=MagicMock(),
         get_ticker=ticker_sell_up
     )
@@ -211,7 +210,7 @@ def test_rpc_trade_statistics(default_conf, ticker, ticker_sell_up, fee,
 
     # Update the ticker with a market going up
     mocker.patch.multiple(
-        'freqtrade.freqtradebot.exchange',
+        'freqtrade.exchange.Exchange',
         validate_pairs=MagicMock(),
         get_ticker=ticker_sell_up
     )
@@ -219,8 +218,7 @@ def test_rpc_trade_statistics(default_conf, ticker, ticker_sell_up, fee,
     trade.close_date = datetime.utcnow()
     trade.is_open = False
 
-    (error, stats) = rpc.rpc_trade_statistics(stake_currency, fiat_display_currency)
-    assert not error
+    stats = rpc._rpc_trade_statistics(stake_currency, fiat_display_currency)
     assert prec_satoshi(stats['profit_closed_coin'], 6.217e-05)
     assert prec_satoshi(stats['profit_closed_percent'], 6.2)
     assert prec_satoshi(stats['profit_closed_fiat'], 0.93255)
@@ -237,7 +235,7 @@ def test_rpc_trade_statistics(default_conf, ticker, ticker_sell_up, fee,
 
 # Test that rpc_trade_statistics can handle trades that lacks
 # trade.open_rate (it is set to None)
-def test_rpc_trade_statistics_closed(mocker, default_conf, ticker, fee,
+def test_rpc_trade_statistics_closed(mocker, default_conf, ticker, fee, markets,
                                      ticker_sell_up, limit_buy_order, limit_sell_order):
     """
     Test rpc_trade_statistics() method
@@ -248,12 +246,13 @@ def test_rpc_trade_statistics_closed(mocker, default_conf, ticker, fee,
         ticker=MagicMock(return_value={'price_usd': 15000.0}),
     )
     mocker.patch('freqtrade.fiat_convert.CryptoToFiatConverter._find_price', return_value=15000.0)
-    mocker.patch('freqtrade.rpc.rpc_manager.Telegram', MagicMock())
+    mocker.patch('freqtrade.rpc.telegram.Telegram', MagicMock())
     mocker.patch.multiple(
-        'freqtrade.freqtradebot.exchange',
+        'freqtrade.exchange.Exchange',
         validate_pairs=MagicMock(),
         get_ticker=ticker,
-        get_fee=fee
+        get_fee=fee,
+        get_markets=markets
     )
 
     freqtradebot = FreqtradeBot(default_conf)
@@ -269,7 +268,7 @@ def test_rpc_trade_statistics_closed(mocker, default_conf, ticker, fee,
     trade.update(limit_buy_order)
     # Update the ticker with a market going up
     mocker.patch.multiple(
-        'freqtrade.freqtradebot.exchange',
+        'freqtrade.exchange.Exchange',
         validate_pairs=MagicMock(),
         get_ticker=ticker_sell_up,
         get_fee=fee
@@ -281,8 +280,7 @@ def test_rpc_trade_statistics_closed(mocker, default_conf, ticker, fee,
     for trade in Trade.query.order_by(Trade.id).all():
         trade.open_rate = None
 
-    (error, stats) = rpc.rpc_trade_statistics(stake_currency, fiat_display_currency)
-    assert not error
+    stats = rpc._rpc_trade_statistics(stake_currency, fiat_display_currency)
     assert prec_satoshi(stats['profit_closed_coin'], 0)
     assert prec_satoshi(stats['profit_closed_percent'], 0)
     assert prec_satoshi(stats['profit_closed_fiat'], 0)
@@ -320,9 +318,9 @@ def test_rpc_balance_handle(default_conf, mocker):
         ticker=MagicMock(return_value={'price_usd': 15000.0}),
     )
     mocker.patch('freqtrade.fiat_convert.CryptoToFiatConverter._find_price', return_value=15000.0)
-    mocker.patch('freqtrade.rpc.rpc_manager.Telegram', MagicMock())
+    mocker.patch('freqtrade.rpc.telegram.Telegram', MagicMock())
     mocker.patch.multiple(
-        'freqtrade.freqtradebot.exchange',
+        'freqtrade.exchange.Exchange',
         validate_pairs=MagicMock(),
         get_balances=MagicMock(return_value=mock_balance)
     )
@@ -330,18 +328,16 @@ def test_rpc_balance_handle(default_conf, mocker):
     freqtradebot = FreqtradeBot(default_conf)
     rpc = RPC(freqtradebot)
 
-    (error, res) = rpc.rpc_balance(default_conf['fiat_display_currency'])
-    assert not error
-    (trade, x, y, z) = res
-    assert prec_satoshi(x, 12)
-    assert prec_satoshi(z, 180000)
-    assert 'USD' in y
-    assert len(trade) == 1
-    assert 'BTC' in trade[0]['currency']
-    assert prec_satoshi(trade[0]['available'], 10)
-    assert prec_satoshi(trade[0]['balance'], 12)
-    assert prec_satoshi(trade[0]['pending'], 2)
-    assert prec_satoshi(trade[0]['est_btc'], 12)
+    output, total, symbol, value = rpc._rpc_balance(default_conf['fiat_display_currency'])
+    assert prec_satoshi(total, 12)
+    assert prec_satoshi(value, 180000)
+    assert 'USD' in symbol
+    assert len(output) == 1
+    assert 'BTC' in output[0]['currency']
+    assert prec_satoshi(output[0]['available'], 10)
+    assert prec_satoshi(output[0]['balance'], 12)
+    assert prec_satoshi(output[0]['pending'], 2)
+    assert prec_satoshi(output[0]['est_btc'], 12)
 
 
 def test_rpc_start(mocker, default_conf) -> None:
@@ -350,9 +346,9 @@ def test_rpc_start(mocker, default_conf) -> None:
     """
     patch_get_signal(mocker, (True, False))
     patch_coinmarketcap(mocker)
-    mocker.patch('freqtrade.rpc.rpc_manager.Telegram', MagicMock())
+    mocker.patch('freqtrade.rpc.telegram.Telegram', MagicMock())
     mocker.patch.multiple(
-        'freqtrade.freqtradebot.exchange',
+        'freqtrade.exchange.Exchange',
         validate_pairs=MagicMock(),
         get_ticker=MagicMock()
     )
@@ -361,13 +357,11 @@ def test_rpc_start(mocker, default_conf) -> None:
     rpc = RPC(freqtradebot)
     freqtradebot.state = State.STOPPED
 
-    (error, result) = rpc.rpc_start()
-    assert not error
+    result = rpc._rpc_start()
     assert '`Starting trader ...`' in result
     assert freqtradebot.state == State.RUNNING
 
-    (error, result) = rpc.rpc_start()
-    assert error
+    result = rpc._rpc_start()
     assert '*Status:* `already running`' in result
     assert freqtradebot.state == State.RUNNING
 
@@ -378,9 +372,9 @@ def test_rpc_stop(mocker, default_conf) -> None:
     """
     patch_get_signal(mocker, (True, False))
     patch_coinmarketcap(mocker)
-    mocker.patch('freqtrade.rpc.rpc_manager.Telegram', MagicMock())
+    mocker.patch('freqtrade.rpc.telegram.Telegram', MagicMock())
     mocker.patch.multiple(
-        'freqtrade.freqtradebot.exchange',
+        'freqtrade.exchange.Exchange',
         validate_pairs=MagicMock(),
         get_ticker=MagicMock()
     )
@@ -389,28 +383,26 @@ def test_rpc_stop(mocker, default_conf) -> None:
     rpc = RPC(freqtradebot)
     freqtradebot.state = State.RUNNING
 
-    (error, result) = rpc.rpc_stop()
-    assert not error
+    result = rpc._rpc_stop()
     assert '`Stopping trader ...`' in result
     assert freqtradebot.state == State.STOPPED
 
-    (error, result) = rpc.rpc_stop()
-    assert error
+    result = rpc._rpc_stop()
     assert '*Status:* `already stopped`' in result
     assert freqtradebot.state == State.STOPPED
 
 
-def test_rpc_forcesell(default_conf, ticker, fee, mocker) -> None:
+def test_rpc_forcesell(default_conf, ticker, fee, mocker, markets) -> None:
     """
     Test rpc_forcesell() method
     """
     patch_get_signal(mocker, (True, False))
     patch_coinmarketcap(mocker)
-    mocker.patch('freqtrade.rpc.rpc_manager.Telegram', MagicMock())
+    mocker.patch('freqtrade.rpc.telegram.Telegram', MagicMock())
 
     cancel_order_mock = MagicMock()
     mocker.patch.multiple(
-        'freqtrade.freqtradebot.exchange',
+        'freqtrade.exchange.Exchange',
         validate_pairs=MagicMock(),
         get_ticker=ticker,
         cancel_order=cancel_order_mock,
@@ -422,42 +414,33 @@ def test_rpc_forcesell(default_conf, ticker, fee, mocker) -> None:
             }
         ),
         get_fee=fee,
+        get_markets=markets
     )
 
     freqtradebot = FreqtradeBot(default_conf)
     rpc = RPC(freqtradebot)
 
     freqtradebot.state = State.STOPPED
-    (error, res) = rpc.rpc_forcesell(None)
-    assert error
-    assert res == '`trader is not running`'
+    with pytest.raises(RPCException, match=r'.*`trader is not running`*'):
+        rpc._rpc_forcesell(None)
 
     freqtradebot.state = State.RUNNING
-    (error, res) = rpc.rpc_forcesell(None)
-    assert error
-    assert res == 'Invalid argument.'
+    with pytest.raises(RPCException, match=r'.*Invalid argument.*'):
+        rpc._rpc_forcesell(None)
 
-    (error, res) = rpc.rpc_forcesell('all')
-    assert not error
-    assert res == ''
+    rpc._rpc_forcesell('all')
 
     freqtradebot.create_trade()
-    (error, res) = rpc.rpc_forcesell('all')
-    assert not error
-    assert res == ''
+    rpc._rpc_forcesell('all')
 
-    (error, res) = rpc.rpc_forcesell('1')
-    assert not error
-    assert res == ''
+    rpc._rpc_forcesell('1')
 
     freqtradebot.state = State.STOPPED
-    (error, res) = rpc.rpc_forcesell(None)
-    assert error
-    assert res == '`trader is not running`'
+    with pytest.raises(RPCException, match=r'.*`trader is not running`*'):
+        rpc._rpc_forcesell(None)
 
-    (error, res) = rpc.rpc_forcesell('all')
-    assert error
-    assert res == '`trader is not running`'
+    with pytest.raises(RPCException, match=r'.*`trader is not running`*'):
+        rpc._rpc_forcesell('all')
 
     freqtradebot.state = State.RUNNING
     assert cancel_order_mock.call_count == 0
@@ -465,7 +448,7 @@ def test_rpc_forcesell(default_conf, ticker, fee, mocker) -> None:
     trade = Trade.query.filter(Trade.id == '1').first()
     filled_amount = trade.amount / 2
     mocker.patch(
-        'freqtrade.freqtradebot.exchange.get_order',
+        'freqtrade.exchange.Exchange.get_order',
         return_value={
             'status': 'open',
             'type': 'limit',
@@ -475,9 +458,7 @@ def test_rpc_forcesell(default_conf, ticker, fee, mocker) -> None:
     )
     # check that the trade is called, which is done by ensuring exchange.cancel_order is called
     # and trade amount is updated
-    (error, res) = rpc.rpc_forcesell('1')
-    assert not error
-    assert res == ''
+    rpc._rpc_forcesell('1')
     assert cancel_order_mock.call_count == 1
     assert trade.amount == filled_amount
 
@@ -486,7 +467,7 @@ def test_rpc_forcesell(default_conf, ticker, fee, mocker) -> None:
     amount = trade.amount
     # make an limit-buy open trade, if there is no 'filled', don't sell it
     mocker.patch(
-        'freqtrade.freqtradebot.exchange.get_order',
+        'freqtrade.exchange.Exchange.get_order',
         return_value={
             'status': 'open',
             'type': 'limit',
@@ -495,43 +476,40 @@ def test_rpc_forcesell(default_conf, ticker, fee, mocker) -> None:
         }
     )
     # check that the trade is called, which is done by ensuring exchange.cancel_order is called
-    (error, res) = rpc.rpc_forcesell('2')
-    assert not error
-    assert res == ''
+    rpc._rpc_forcesell('2')
     assert cancel_order_mock.call_count == 2
     assert trade.amount == amount
 
     freqtradebot.create_trade()
     # make an limit-sell open trade
     mocker.patch(
-        'freqtrade.freqtradebot.exchange.get_order',
+        'freqtrade.exchange.Exchange.get_order',
         return_value={
             'status': 'open',
             'type': 'limit',
             'side': 'sell'
         }
     )
-    (error, res) = rpc.rpc_forcesell('3')
-    assert not error
-    assert res == ''
+    rpc._rpc_forcesell('3')
     # status quo, no exchange calls
     assert cancel_order_mock.call_count == 2
 
 
 def test_performance_handle(default_conf, ticker, limit_buy_order, fee,
-                            limit_sell_order, mocker) -> None:
+                            limit_sell_order, markets, mocker) -> None:
     """
     Test rpc_performance() method
     """
     patch_get_signal(mocker, (True, False))
     patch_coinmarketcap(mocker)
-    mocker.patch('freqtrade.rpc.rpc_manager.Telegram', MagicMock())
+    mocker.patch('freqtrade.rpc.telegram.Telegram', MagicMock())
     mocker.patch.multiple(
-        'freqtrade.freqtradebot.exchange',
+        'freqtrade.exchange.Exchange',
         validate_pairs=MagicMock(),
         get_balances=MagicMock(return_value=ticker),
         get_ticker=ticker,
-        get_fee=fee
+        get_fee=fee,
+        get_markets=markets
     )
 
     freqtradebot = FreqtradeBot(default_conf)
@@ -550,40 +528,38 @@ def test_performance_handle(default_conf, ticker, limit_buy_order, fee,
 
     trade.close_date = datetime.utcnow()
     trade.is_open = False
-    (error, res) = rpc.rpc_performance()
-    assert not error
+    res = rpc._rpc_performance()
     assert len(res) == 1
     assert res[0]['pair'] == 'ETH/BTC'
     assert res[0]['count'] == 1
     assert prec_satoshi(res[0]['profit'], 6.2)
 
 
-def test_rpc_count(mocker, default_conf, ticker, fee) -> None:
+def test_rpc_count(mocker, default_conf, ticker, fee, markets) -> None:
     """
     Test rpc_count() method
     """
     patch_get_signal(mocker, (True, False))
     patch_coinmarketcap(mocker)
-    mocker.patch('freqtrade.rpc.rpc_manager.Telegram', MagicMock())
+    mocker.patch('freqtrade.rpc.telegram.Telegram', MagicMock())
     mocker.patch.multiple(
-        'freqtrade.freqtradebot.exchange',
+        'freqtrade.exchange.Exchange',
         validate_pairs=MagicMock(),
         get_balances=MagicMock(return_value=ticker),
         get_ticker=ticker,
         get_fee=fee,
+        get_markets=markets
     )
 
     freqtradebot = FreqtradeBot(default_conf)
     rpc = RPC(freqtradebot)
 
-    (error, trades) = rpc.rpc_count()
+    trades = rpc._rpc_count()
     nb_trades = len(trades)
-    assert not error
     assert nb_trades == 0
 
     # Create some test data
     freqtradebot.create_trade()
-    (error, trades) = rpc.rpc_count()
+    trades = rpc._rpc_count()
     nb_trades = len(trades)
-    assert not error
     assert nb_trades == 1

freqtrade/tests/rpc/test_rpc_manager.py

@@ -7,49 +7,35 @@ from copy import deepcopy
 from unittest.mock import MagicMock
 
 from freqtrade.rpc.rpc_manager import RPCManager
-from freqtrade.rpc.telegram import Telegram
-from freqtrade.tests.conftest import log_has, get_patched_freqtradebot
+from freqtrade.tests.conftest import get_patched_freqtradebot, log_has
 
 
 def test_rpc_manager_object() -> None:
-    """
-    Test the Arguments object has the mandatory methods
-    :return: None
-    """
-    assert hasattr(RPCManager, '_init')
+    """ Test the Arguments object has the mandatory methods """
     assert hasattr(RPCManager, 'send_msg')
     assert hasattr(RPCManager, 'cleanup')
 
 
 def test__init__(mocker, default_conf) -> None:
-    """
-    Test __init__() method
-    """
-    init_mock = mocker.patch('freqtrade.rpc.rpc_manager.RPCManager._init', MagicMock())
-    freqtradebot = get_patched_freqtradebot(mocker, default_conf)
+    """ Test __init__() method """
+    conf = deepcopy(default_conf)
+    conf['telegram']['enabled'] = False
 
-    rpc_manager = RPCManager(freqtradebot)
-    assert rpc_manager.freqtrade == freqtradebot
+    rpc_manager = RPCManager(get_patched_freqtradebot(mocker, conf))
     assert rpc_manager.registered_modules == []
-    assert rpc_manager.telegram is None
-    assert init_mock.call_count == 1
 
 
 def test_init_telegram_disabled(mocker, default_conf, caplog) -> None:
-    """
-    Test _init() method with Telegram disabled
-    """
+    """ Test _init() method with Telegram disabled """
     caplog.set_level(logging.DEBUG)
 
     conf = deepcopy(default_conf)
     conf['telegram']['enabled'] = False
 
-    freqtradebot = get_patched_freqtradebot(mocker, conf)
-    rpc_manager = RPCManager(freqtradebot)
+    rpc_manager = RPCManager(get_patched_freqtradebot(mocker, conf))
 
     assert not log_has('Enabling rpc.telegram ...', caplog.record_tuples)
     assert rpc_manager.registered_modules == []
-    assert rpc_manager.telegram is None
 
 
 def test_init_telegram_enabled(mocker, default_conf, caplog) -> None:
@@ -59,14 +45,12 @@ def test_init_telegram_enabled(mocker, default_conf, caplog) -> None:
     caplog.set_level(logging.DEBUG)
     mocker.patch('freqtrade.rpc.telegram.Telegram._init', MagicMock())
 
-    freqtradebot = get_patched_freqtradebot(mocker, default_conf)
-    rpc_manager = RPCManager(freqtradebot)
+    rpc_manager = RPCManager(get_patched_freqtradebot(mocker, default_conf))
 
     assert log_has('Enabling rpc.telegram ...', caplog.record_tuples)
     len_modules = len(rpc_manager.registered_modules)
     assert len_modules == 1
-    assert 'telegram' in rpc_manager.registered_modules
-    assert isinstance(rpc_manager.telegram, Telegram)
+    assert 'telegram' in [mod.name for mod in rpc_manager.registered_modules]
 
 
 def test_cleanup_telegram_disabled(mocker, default_conf, caplog) -> None:
@@ -99,11 +83,11 @@ def test_cleanup_telegram_enabled(mocker, default_conf, caplog) -> None:
     rpc_manager = RPCManager(freqtradebot)
 
     # Check we have Telegram as a registered modules
-    assert 'telegram' in rpc_manager.registered_modules
+    assert 'telegram' in [mod.name for mod in rpc_manager.registered_modules]
 
     rpc_manager.cleanup()
     assert log_has('Cleaning up rpc.telegram ...', caplog.record_tuples)
-    assert 'telegram' not in rpc_manager.registered_modules
+    assert 'telegram' not in [mod.name for mod in rpc_manager.registered_modules]
     assert telegram_mock.call_count == 1
 
 
@@ -120,7 +104,7 @@ def test_send_msg_telegram_disabled(mocker, default_conf, caplog) -> None:
     rpc_manager = RPCManager(freqtradebot)
     rpc_manager.send_msg('test')
 
-    assert log_has('test', caplog.record_tuples)
+    assert log_has('Sending rpc message: test', caplog.record_tuples)
     assert telegram_mock.call_count == 0
 
 
@@ -135,5 +119,5 @@ def test_send_msg_telegram_enabled(mocker, default_conf, caplog) -> None:
     rpc_manager = RPCManager(freqtradebot)
     rpc_manager.send_msg('test')
 
-    assert log_has('test', caplog.record_tuples)
+    assert log_has('Sending rpc message: test', caplog.record_tuples)
     assert telegram_mock.call_count == 1

freqtrade/tests/rpc/test_rpc_telegram.py

@@ -11,17 +11,18 @@ from datetime import datetime
 from random import randint
 from unittest.mock import MagicMock
 
-from telegram import Update, Message, Chat
+from telegram import Chat, Message, Update
 from telegram.error import NetworkError
 
 from freqtrade import __version__
 from freqtrade.freqtradebot import FreqtradeBot
 from freqtrade.persistence import Trade
-from freqtrade.rpc.telegram import Telegram
-from freqtrade.rpc.telegram import authorized_only
+from freqtrade.rpc.telegram import Telegram, authorized_only
 from freqtrade.state import State
-from freqtrade.tests.conftest import get_patched_freqtradebot, log_has
-from freqtrade.tests.test_freqtradebot import patch_get_signal, patch_coinmarketcap
+from freqtrade.tests.conftest import (get_patched_freqtradebot, log_has,
+                                      patch_exchange)
+from freqtrade.tests.test_freqtradebot import (patch_coinmarketcap,
+                                               patch_get_signal)
 
 
 class DummyCls(Telegram):
@@ -32,6 +33,9 @@ class DummyCls(Telegram):
         super().__init__(freqtrade)
         self.state = {'called': False}
 
+    def _init(self):
+        pass
+
     @authorized_only
     def dummy_handler(self, *args, **kwargs) -> None:
         """
@@ -60,9 +64,7 @@ def test__init__(default_conf, mocker) -> None:
 
 
 def test_init(default_conf, mocker, caplog) -> None:
-    """
-    Test _init() method
-    """
+    """ Test _init() method """
     start_polling = MagicMock()
     mocker.patch('freqtrade.rpc.telegram.Updater', MagicMock(return_value=start_polling))
 
@@ -80,21 +82,6 @@ def test_init(default_conf, mocker, caplog) -> None:
     assert log_has(message_str, caplog.record_tuples)
 
 
-def test_init_disabled(default_conf, mocker, caplog) -> None:
-    """
-    Test _init() method when Telegram is disabled
-    """
-    conf = deepcopy(default_conf)
-    conf['telegram']['enabled'] = False
-    Telegram(get_patched_freqtradebot(mocker, conf))
-
-    message_str = "rpc.telegram is listening for following commands: [['status'], ['profit'], " \
-                  "['balance'], ['start'], ['stop'], ['forcesell'], ['performance'], ['daily'], " \
-                  "['count'], ['help'], ['version']]"
-
-    assert not log_has(message_str, caplog.record_tuples)
-
-
 def test_cleanup(default_conf, mocker) -> None:
     """
     Test cleanup() method
@@ -103,51 +90,18 @@ def test_cleanup(default_conf, mocker) -> None:
     updater_mock.stop = MagicMock()
     mocker.patch('freqtrade.rpc.telegram.Updater', updater_mock)
 
-    # not enabled
-    conf = deepcopy(default_conf)
-    conf['telegram']['enabled'] = False
-    telegram = Telegram(get_patched_freqtradebot(mocker, conf))
-    telegram.cleanup()
-    assert telegram._updater is None
-    assert updater_mock.call_count == 0
-    assert not hasattr(telegram._updater, 'stop')
-    assert updater_mock.stop.call_count == 0
-
-    # enabled
-    conf['telegram']['enabled'] = True
-    telegram = Telegram(get_patched_freqtradebot(mocker, conf))
+    telegram = Telegram(get_patched_freqtradebot(mocker, default_conf))
     telegram.cleanup()
     assert telegram._updater.stop.call_count == 1
 
 
-def test_is_enabled(default_conf, mocker) -> None:
-    """
-    Test is_enabled() method
-    """
-    mocker.patch('freqtrade.rpc.telegram.Updater', MagicMock())
-
-    telegram = Telegram(get_patched_freqtradebot(mocker, default_conf))
-    assert telegram.is_enabled()
-
-
-def test_is_not_enabled(default_conf, mocker) -> None:
-    """
-    Test is_enabled() method
-    """
-    conf = deepcopy(default_conf)
-    conf['telegram']['enabled'] = False
-    telegram = Telegram(get_patched_freqtradebot(mocker, conf))
-
-    assert not telegram.is_enabled()
-
-
 def test_authorized_only(default_conf, mocker, caplog) -> None:
     """
     Test authorized_only() method when we are authorized
     """
     patch_get_signal(mocker, (True, False))
     patch_coinmarketcap(mocker)
-    mocker.patch('freqtrade.freqtradebot.exchange.init', MagicMock())
+    patch_exchange(mocker, None)
 
     chat = Chat(0, 0)
     update = Update(randint(1, 100))
@@ -178,8 +132,7 @@ def test_authorized_only_unauthorized(default_conf, mocker, caplog) -> None:
     """
     patch_get_signal(mocker, (True, False))
     patch_coinmarketcap(mocker)
-    mocker.patch('freqtrade.freqtradebot.exchange.init', MagicMock())
-
+    patch_exchange(mocker, None)
     chat = Chat(0xdeadbeef, 0)
     update = Update(randint(1, 100))
     update.message = Message(randint(1, 100), 0, datetime.utcnow(), chat)
@@ -209,7 +162,7 @@ def test_authorized_only_exception(default_conf, mocker, caplog) -> None:
     """
     patch_get_signal(mocker, (True, False))
     patch_coinmarketcap(mocker)
-    mocker.patch('freqtrade.freqtradebot.exchange.init', MagicMock())
+    patch_exchange(mocker)
 
     update = Update(randint(1, 100))
     update.message = Message(randint(1, 100), 0, datetime.utcnow(), Chat(0, 0))
@@ -233,7 +186,7 @@ def test_authorized_only_exception(default_conf, mocker, caplog) -> None:
     )
 
 
-def test_status(default_conf, update, mocker, fee, ticker) -> None:
+def test_status(default_conf, update, mocker, fee, ticker, markets) -> None:
     """
     Test _status() method
     """
@@ -245,20 +198,21 @@ def test_status(default_conf, update, mocker, fee, ticker) -> None:
     patch_get_signal(mocker, (True, False))
     patch_coinmarketcap(mocker)
     mocker.patch.multiple(
-        'freqtrade.freqtradebot.exchange',
+        'freqtrade.exchange.Exchange',
         validate_pairs=MagicMock(),
         get_ticker=ticker,
         get_pair_detail_url=MagicMock(),
         get_fee=fee,
+        get_markets=markets
     )
     msg_mock = MagicMock()
     status_table = MagicMock()
     mocker.patch.multiple(
         'freqtrade.rpc.telegram.Telegram',
         _init=MagicMock(),
-        rpc_trade_status=MagicMock(return_value=(False, [1, 2, 3])),
+        _rpc_trade_status=MagicMock(return_value=[1, 2, 3]),
         _status_table=status_table,
-        send_msg=msg_mock
+        _send_msg=msg_mock
     )
     mocker.patch('freqtrade.freqtradebot.RPCManager', MagicMock())
 
@@ -278,17 +232,18 @@ def test_status(default_conf, update, mocker, fee, ticker) -> None:
     assert status_table.call_count == 1
 
 
-def test_status_handle(default_conf, update, ticker, fee, mocker) -> None:
+def test_status_handle(default_conf, update, ticker, fee, markets, mocker) -> None:
     """
     Test _status() method
     """
     patch_get_signal(mocker, (True, False))
     patch_coinmarketcap(mocker)
     mocker.patch.multiple(
-        'freqtrade.freqtradebot.exchange',
+        'freqtrade.exchange.Exchange',
         validate_pairs=MagicMock(),
         get_ticker=ticker,
         get_fee=fee,
+        get_markets=markets
     )
     msg_mock = MagicMock()
     status_table = MagicMock()
@@ -296,7 +251,7 @@ def test_status_handle(default_conf, update, ticker, fee, mocker) -> None:
         'freqtrade.rpc.telegram.Telegram',
         _init=MagicMock(),
         _status_table=status_table,
-        send_msg=msg_mock
+        _send_msg=msg_mock
     )
     mocker.patch('freqtrade.freqtradebot.RPCManager', MagicMock())
 
@@ -324,24 +279,25 @@ def test_status_handle(default_conf, update, ticker, fee, mocker) -> None:
     assert '[ETH/BTC]' in msg_mock.call_args_list[0][0][0]
 
 
-def test_status_table_handle(default_conf, update, ticker, fee, mocker) -> None:
+def test_status_table_handle(default_conf, update, ticker, fee, markets, mocker) -> None:
     """
     Test _status_table() method
     """
     patch_get_signal(mocker, (True, False))
     patch_coinmarketcap(mocker)
     mocker.patch.multiple(
-        'freqtrade.freqtradebot.exchange',
+        'freqtrade.exchange.Exchange',
         validate_pairs=MagicMock(),
         get_ticker=ticker,
         buy=MagicMock(return_value={'id': 'mocked_order_id'}),
         get_fee=fee,
+        get_markets=markets
     )
     msg_mock = MagicMock()
     mocker.patch.multiple(
         'freqtrade.rpc.telegram.Telegram',
         _init=MagicMock(),
-        send_msg=msg_mock
+        _send_msg=msg_mock
     )
     mocker.patch('freqtrade.freqtradebot.RPCManager', MagicMock())
 
@@ -377,7 +333,7 @@ def test_status_table_handle(default_conf, update, ticker, fee, mocker) -> None:
 
 
 def test_daily_handle(default_conf, update, ticker, limit_buy_order, fee,
-                      limit_sell_order, mocker) -> None:
+                      limit_sell_order, markets, mocker) -> None:
     """
     Test _daily() method
     """
@@ -388,16 +344,17 @@ def test_daily_handle(default_conf, update, ticker, limit_buy_order, fee,
         return_value=15000.0
     )
     mocker.patch.multiple(
-        'freqtrade.freqtradebot.exchange',
+        'freqtrade.exchange.Exchange',
         validate_pairs=MagicMock(),
         get_ticker=ticker,
-        get_fee=fee
+        get_fee=fee,
+        get_markets=markets
     )
     msg_mock = MagicMock()
     mocker.patch.multiple(
         'freqtrade.rpc.telegram.Telegram',
         _init=MagicMock(),
-        send_msg=msg_mock
+        _send_msg=msg_mock
     )
     mocker.patch('freqtrade.freqtradebot.RPCManager', MagicMock())
 
@@ -457,7 +414,7 @@ def test_daily_wrong_input(default_conf, update, ticker, mocker) -> None:
     patch_get_signal(mocker, (True, False))
     patch_coinmarketcap(mocker, value={'price_usd': 15000.0})
     mocker.patch.multiple(
-        'freqtrade.freqtradebot.exchange',
+        'freqtrade.exchange.Exchange',
         validate_pairs=MagicMock(),
         get_ticker=ticker
     )
@@ -465,7 +422,7 @@ def test_daily_wrong_input(default_conf, update, ticker, mocker) -> None:
     mocker.patch.multiple(
         'freqtrade.rpc.telegram.Telegram',
         _init=MagicMock(),
-        send_msg=msg_mock
+        _send_msg=msg_mock
     )
     mocker.patch('freqtrade.freqtradebot.RPCManager', MagicMock())
 
@@ -489,7 +446,7 @@ def test_daily_wrong_input(default_conf, update, ticker, mocker) -> None:
 
 
 def test_profit_handle(default_conf, update, ticker, ticker_sell_up, fee,
-                       limit_buy_order, limit_sell_order, mocker) -> None:
+                       limit_buy_order, limit_sell_order, markets, mocker) -> None:
     """
     Test _profit() method
     """
@@ -497,16 +454,17 @@ def test_profit_handle(default_conf, update, ticker, ticker_sell_up, fee,
     patch_coinmarketcap(mocker, value={'price_usd': 15000.0})
     mocker.patch('freqtrade.fiat_convert.CryptoToFiatConverter._find_price', return_value=15000.0)
     mocker.patch.multiple(
-        'freqtrade.freqtradebot.exchange',
+        'freqtrade.exchange.Exchange',
         validate_pairs=MagicMock(),
         get_ticker=ticker,
-        get_fee=fee
+        get_fee=fee,
+        get_markets=markets
     )
     msg_mock = MagicMock()
     mocker.patch.multiple(
         'freqtrade.rpc.telegram.Telegram',
         _init=MagicMock(),
-        send_msg=msg_mock
+        _send_msg=msg_mock
     )
     mocker.patch('freqtrade.freqtradebot.RPCManager', MagicMock())
 
@@ -531,7 +489,7 @@ def test_profit_handle(default_conf, update, ticker, ticker_sell_up, fee,
     msg_mock.reset_mock()
 
     # Update the ticker with a market going up
-    mocker.patch('freqtrade.freqtradebot.exchange.get_ticker', ticker_sell_up)
+    mocker.patch('freqtrade.exchange.Exchange.get_ticker', ticker_sell_up)
     trade.update(limit_sell_order)
 
     trade.close_date = datetime.utcnow()
@@ -596,18 +554,17 @@ def test_telegram_balance_handle(default_conf, update, mocker) -> None:
 
     patch_get_signal(mocker, (True, False))
     patch_coinmarketcap(mocker, value={'price_usd': 15000.0})
-    mocker.patch('freqtrade.freqtradebot.exchange.init', MagicMock())
-    mocker.patch('freqtrade.freqtradebot.exchange.get_balances', return_value=mock_balance)
-    mocker.patch('freqtrade.freqtradebot.exchange.get_ticker', side_effect=mock_ticker)
+    mocker.patch('freqtrade.exchange.Exchange.get_balances', return_value=mock_balance)
+    mocker.patch('freqtrade.exchange.Exchange.get_ticker', side_effect=mock_ticker)
 
     msg_mock = MagicMock()
     mocker.patch.multiple(
         'freqtrade.rpc.telegram.Telegram',
         _init=MagicMock(),
-        send_msg=msg_mock
+        _send_msg=msg_mock
     )
 
-    freqtradebot = FreqtradeBot(default_conf)
+    freqtradebot = get_patched_freqtradebot(mocker, default_conf)
     telegram = Telegram(freqtradebot)
 
     telegram._balance(bot=MagicMock(), update=update)
@@ -626,18 +583,16 @@ def test_zero_balance_handle(default_conf, update, mocker) -> None:
     Test _balance() method when the Exchange platform returns nothing
     """
     patch_get_signal(mocker, (True, False))
-    patch_coinmarketcap(mocker, value={'price_usd': 15000.0})
-    mocker.patch('freqtrade.freqtradebot.exchange.init', MagicMock())
-    mocker.patch('freqtrade.freqtradebot.exchange.get_balances', return_value={})
+    mocker.patch('freqtrade.exchange.Exchange.get_balances', return_value={})
 
     msg_mock = MagicMock()
     mocker.patch.multiple(
         'freqtrade.rpc.telegram.Telegram',
         _init=MagicMock(),
-        send_msg=msg_mock
+        _send_msg=msg_mock
     )
 
-    freqtradebot = FreqtradeBot(default_conf)
+    freqtradebot = get_patched_freqtradebot(mocker, default_conf)
     telegram = Telegram(freqtradebot)
 
     telegram._balance(bot=MagicMock(), update=update)
@@ -650,41 +605,35 @@ def test_start_handle(default_conf, update, mocker) -> None:
     """
     Test _start() method
     """
-    patch_coinmarketcap(mocker)
-    mocker.patch('freqtrade.freqtradebot.exchange.init', MagicMock())
     msg_mock = MagicMock()
     mocker.patch.multiple(
         'freqtrade.rpc.telegram.Telegram',
         _init=MagicMock(),
-        send_msg=msg_mock
+        _send_msg=msg_mock
     )
-    mocker.patch('freqtrade.freqtradebot.RPCManager', MagicMock())
 
-    freqtradebot = FreqtradeBot(default_conf)
+    freqtradebot = get_patched_freqtradebot(mocker, default_conf)
     telegram = Telegram(freqtradebot)
 
     freqtradebot.state = State.STOPPED
     assert freqtradebot.state == State.STOPPED
     telegram._start(bot=MagicMock(), update=update)
     assert freqtradebot.state == State.RUNNING
-    assert msg_mock.call_count == 0
+    assert msg_mock.call_count == 1
 
 
 def test_start_handle_already_running(default_conf, update, mocker) -> None:
     """
     Test _start() method
     """
-    patch_coinmarketcap(mocker)
-    mocker.patch('freqtrade.freqtradebot.exchange.init', MagicMock())
     msg_mock = MagicMock()
     mocker.patch.multiple(
         'freqtrade.rpc.telegram.Telegram',
         _init=MagicMock(),
-        send_msg=msg_mock
+        _send_msg=msg_mock
     )
-    mocker.patch('freqtrade.freqtradebot.RPCManager', MagicMock())
 
-    freqtradebot = FreqtradeBot(default_conf)
+    freqtradebot = get_patched_freqtradebot(mocker, default_conf)
     telegram = Telegram(freqtradebot)
 
     freqtradebot.state = State.RUNNING
@@ -700,16 +649,14 @@ def test_stop_handle(default_conf, update, mocker) -> None:
     Test _stop() method
     """
     patch_coinmarketcap(mocker)
-    mocker.patch('freqtrade.freqtradebot.exchange.init', MagicMock())
     msg_mock = MagicMock()
     mocker.patch.multiple(
         'freqtrade.rpc.telegram.Telegram',
         _init=MagicMock(),
-        send_msg=msg_mock
+        _send_msg=msg_mock
     )
-    mocker.patch('freqtrade.freqtradebot.RPCManager', MagicMock())
 
-    freqtradebot = FreqtradeBot(default_conf)
+    freqtradebot = get_patched_freqtradebot(mocker, default_conf)
     telegram = Telegram(freqtradebot)
 
     freqtradebot.state = State.RUNNING
@@ -725,16 +672,14 @@ def test_stop_handle_already_stopped(default_conf, update, mocker) -> None:
     Test _stop() method
     """
     patch_coinmarketcap(mocker)
-    mocker.patch('freqtrade.freqtradebot.exchange.init', MagicMock())
     msg_mock = MagicMock()
     mocker.patch.multiple(
         'freqtrade.rpc.telegram.Telegram',
         _init=MagicMock(),
-        send_msg=msg_mock
+        _send_msg=msg_mock
     )
-    mocker.patch('freqtrade.freqtradebot.RPCManager', MagicMock())
 
-    freqtradebot = FreqtradeBot(default_conf)
+    freqtradebot = get_patched_freqtradebot(mocker, default_conf)
     telegram = Telegram(freqtradebot)
 
     freqtradebot.state = State.STOPPED
@@ -748,16 +693,14 @@ def test_stop_handle_already_stopped(default_conf, update, mocker) -> None:
 def test_reload_conf_handle(default_conf, update, mocker) -> None:
     """ Test _reload_conf() method """
     patch_coinmarketcap(mocker)
-    mocker.patch('freqtrade.freqtradebot.exchange.init', MagicMock())
     msg_mock = MagicMock()
     mocker.patch.multiple(
         'freqtrade.rpc.telegram.Telegram',
         _init=MagicMock(),
-        send_msg=msg_mock
+        _send_msg=msg_mock
     )
-    mocker.patch('freqtrade.freqtradebot.RPCManager', MagicMock())
 
-    freqtradebot = FreqtradeBot(default_conf)
+    freqtradebot = get_patched_freqtradebot(mocker, default_conf)
     telegram = Telegram(freqtradebot)
 
     freqtradebot.state = State.RUNNING
@@ -768,7 +711,8 @@ def test_reload_conf_handle(default_conf, update, mocker) -> None:
     assert 'Reloading config' in msg_mock.call_args_list[0][0][0]
 
 
-def test_forcesell_handle(default_conf, update, ticker, fee, ticker_sell_up, mocker) -> None:
+def test_forcesell_handle(default_conf, update, ticker, fee,
+                          ticker_sell_up, markets, mocker) -> None:
     """
     Test _forcesell() method
     """
@@ -778,10 +722,11 @@ def test_forcesell_handle(default_conf, update, ticker, fee, ticker_sell_up, moc
     rpc_mock = mocker.patch('freqtrade.rpc.telegram.Telegram.send_msg', MagicMock())
     mocker.patch('freqtrade.rpc.telegram.Telegram._init', MagicMock())
     mocker.patch.multiple(
-        'freqtrade.freqtradebot.exchange',
+        'freqtrade.exchange.Exchange',
         validate_pairs=MagicMock(),
         get_ticker=ticker,
-        get_fee=fee
+        get_fee=fee,
+        get_markets=markets
     )
 
     freqtradebot = FreqtradeBot(default_conf)
@@ -794,7 +739,7 @@ def test_forcesell_handle(default_conf, update, ticker, fee, ticker_sell_up, moc
     assert trade
 
     # Increase the price and sell it
-    mocker.patch('freqtrade.freqtradebot.exchange.get_ticker', ticker_sell_up)
+    mocker.patch('freqtrade.exchange.Exchange.get_ticker', ticker_sell_up)
 
     update.message.text = '/forcesell 1'
     telegram._forcesell(bot=MagicMock(), update=update)
@@ -808,7 +753,8 @@ def test_forcesell_handle(default_conf, update, ticker, fee, ticker_sell_up, moc
     assert '0.919 USD' in rpc_mock.call_args_list[-1][0][0]
 
 
-def test_forcesell_down_handle(default_conf, update, ticker, fee, ticker_sell_down, mocker) -> None:
+def test_forcesell_down_handle(default_conf, update, ticker, fee,
+                               ticker_sell_down, markets, mocker) -> None:
     """
     Test _forcesell() method
     """
@@ -818,10 +764,11 @@ def test_forcesell_down_handle(default_conf, update, ticker, fee, ticker_sell_do
     rpc_mock = mocker.patch('freqtrade.rpc.telegram.Telegram.send_msg', MagicMock())
     mocker.patch('freqtrade.rpc.telegram.Telegram._init', MagicMock())
     mocker.patch.multiple(
-        'freqtrade.freqtradebot.exchange',
+        'freqtrade.exchange.Exchange',
         validate_pairs=MagicMock(),
         get_ticker=ticker,
-        get_fee=fee
+        get_fee=fee,
+        get_markets=markets
     )
 
     freqtradebot = FreqtradeBot(default_conf)
@@ -832,7 +779,7 @@ def test_forcesell_down_handle(default_conf, update, ticker, fee, ticker_sell_do
 
     # Decrease the price and sell it
     mocker.patch.multiple(
-        'freqtrade.freqtradebot.exchange',
+        'freqtrade.exchange.Exchange',
         validate_pairs=MagicMock(),
         get_ticker=ticker_sell_down
     )
@@ -852,7 +799,7 @@ def test_forcesell_down_handle(default_conf, update, ticker, fee, ticker_sell_do
     assert '-0.824 USD' in rpc_mock.call_args_list[-1][0][0]
 
 
-def test_forcesell_all_handle(default_conf, update, ticker, fee, mocker) -> None:
+def test_forcesell_all_handle(default_conf, update, ticker, fee, markets, mocker) -> None:
     """
     Test _forcesell() method
     """
@@ -861,12 +808,13 @@ def test_forcesell_all_handle(default_conf, update, ticker, fee, mocker) -> None
     mocker.patch('freqtrade.fiat_convert.CryptoToFiatConverter._find_price', return_value=15000.0)
     rpc_mock = mocker.patch('freqtrade.rpc.telegram.Telegram.send_msg', MagicMock())
     mocker.patch('freqtrade.rpc.telegram.Telegram._init', MagicMock())
-    mocker.patch('freqtrade.exchange.get_pair_detail_url', MagicMock())
+    mocker.patch('freqtrade.exchange.Exchange.get_pair_detail_url', MagicMock())
     mocker.patch.multiple(
-        'freqtrade.freqtradebot.exchange',
+        'freqtrade.exchange.Exchange',
         validate_pairs=MagicMock(),
         get_ticker=ticker,
-        get_fee=fee
+        get_fee=fee,
+        get_markets=markets
     )
 
     freqtradebot = FreqtradeBot(default_conf)
@@ -898,9 +846,9 @@ def test_forcesell_handle_invalid(default_conf, update, mocker) -> None:
     mocker.patch.multiple(
         'freqtrade.rpc.telegram.Telegram',
         _init=MagicMock(),
-        send_msg=msg_mock
+        _send_msg=msg_mock
     )
-    mocker.patch('freqtrade.freqtradebot.exchange.validate_pairs', MagicMock())
+    mocker.patch('freqtrade.exchange.Exchange.validate_pairs', MagicMock())
 
     freqtradebot = FreqtradeBot(default_conf)
     telegram = Telegram(freqtradebot)
@@ -930,7 +878,7 @@ def test_forcesell_handle_invalid(default_conf, update, mocker) -> None:
 
 
 def test_performance_handle(default_conf, update, ticker, fee,
-                            limit_buy_order, limit_sell_order, mocker) -> None:
+                            limit_buy_order, limit_sell_order, markets, mocker) -> None:
     """
     Test _performance() method
     """
@@ -940,13 +888,14 @@ def test_performance_handle(default_conf, update, ticker, fee,
     mocker.patch.multiple(
         'freqtrade.rpc.telegram.Telegram',
         _init=MagicMock(),
-        send_msg=msg_mock
+        _send_msg=msg_mock
     )
     mocker.patch.multiple(
-        'freqtrade.freqtradebot.exchange',
+        'freqtrade.exchange.Exchange',
         validate_pairs=MagicMock(),
         get_ticker=ticker,
-        get_fee=fee
+        get_fee=fee,
+        get_markets=markets
     )
     mocker.patch('freqtrade.freqtradebot.RPCManager', MagicMock())
     freqtradebot = FreqtradeBot(default_conf)
@@ -981,9 +930,9 @@ def test_performance_handle_invalid(default_conf, update, mocker) -> None:
     mocker.patch.multiple(
         'freqtrade.rpc.telegram.Telegram',
         _init=MagicMock(),
-        send_msg=msg_mock
+        _send_msg=msg_mock
     )
-    mocker.patch('freqtrade.freqtradebot.exchange.validate_pairs', MagicMock())
+    mocker.patch('freqtrade.exchange.Exchange.validate_pairs', MagicMock())
     freqtradebot = FreqtradeBot(default_conf)
     telegram = Telegram(freqtradebot)
 
@@ -994,7 +943,7 @@ def test_performance_handle_invalid(default_conf, update, mocker) -> None:
     assert 'not running' in msg_mock.call_args_list[0][0][0]
 
 
-def test_count_handle(default_conf, update, ticker, fee, mocker) -> None:
+def test_count_handle(default_conf, update, ticker, fee, markets, mocker) -> None:
     """
     Test _count() method
     """
@@ -1004,15 +953,16 @@ def test_count_handle(default_conf, update, ticker, fee, mocker) -> None:
     mocker.patch.multiple(
         'freqtrade.rpc.telegram.Telegram',
         _init=MagicMock(),
-        send_msg=msg_mock
+        _send_msg=msg_mock
     )
     mocker.patch.multiple(
-        'freqtrade.freqtradebot.exchange',
+        'freqtrade.exchange.Exchange',
         validate_pairs=MagicMock(),
         get_ticker=ticker,
-        buy=MagicMock(return_value={'id': 'mocked_order_id'})
+        buy=MagicMock(return_value={'id': 'mocked_order_id'}),
+        get_markets=markets
     )
-    mocker.patch('freqtrade.optimize.backtesting.exchange.get_fee', fee)
+    mocker.patch('freqtrade.exchange.Exchange.get_fee', fee)
     freqtradebot = FreqtradeBot(default_conf)
     telegram = Telegram(freqtradebot)
 
@@ -1042,14 +992,14 @@ def test_help_handle(default_conf, update, mocker) -> None:
     Test _help() method
     """
     patch_coinmarketcap(mocker)
-    mocker.patch('freqtrade.freqtradebot.exchange.init', MagicMock())
     msg_mock = MagicMock()
     mocker.patch.multiple(
         'freqtrade.rpc.telegram.Telegram',
         _init=MagicMock(),
-        send_msg=msg_mock
+        _send_msg=msg_mock
     )
-    freqtradebot = FreqtradeBot(default_conf)
+    freqtradebot = get_patched_freqtradebot(mocker, default_conf)
+
     telegram = Telegram(freqtradebot)
 
     telegram._help(bot=MagicMock(), update=update)
@@ -1062,14 +1012,13 @@ def test_version_handle(default_conf, update, mocker) -> None:
     Test _version() method
     """
     patch_coinmarketcap(mocker)
-    mocker.patch('freqtrade.freqtradebot.exchange.init', MagicMock())
     msg_mock = MagicMock()
     mocker.patch.multiple(
         'freqtrade.rpc.telegram.Telegram',
         _init=MagicMock(),
-        send_msg=msg_mock
+        _send_msg=msg_mock
     )
-    freqtradebot = FreqtradeBot(default_conf)
+    freqtradebot = get_patched_freqtradebot(mocker, default_conf)
     telegram = Telegram(freqtradebot)
 
     telegram._version(bot=MagicMock(), update=update)
@@ -1082,20 +1031,14 @@ def test_send_msg(default_conf, mocker) -> None:
     Test send_msg() method
     """
     patch_coinmarketcap(mocker)
-    mocker.patch('freqtrade.freqtradebot.exchange.init', MagicMock())
     mocker.patch('freqtrade.rpc.telegram.Telegram._init', MagicMock())
     conf = deepcopy(default_conf)
     bot = MagicMock()
-    freqtradebot = FreqtradeBot(conf)
+    freqtradebot = get_patched_freqtradebot(mocker, conf)
     telegram = Telegram(freqtradebot)
 
-    telegram._config['telegram']['enabled'] = False
-    telegram.send_msg('test', bot)
-    assert not bot.method_calls
-    bot.reset_mock()
-
     telegram._config['telegram']['enabled'] = True
-    telegram.send_msg('test', bot)
+    telegram._send_msg('test', bot)
     assert len(bot.method_calls) == 1
 
 
@@ -1104,16 +1047,15 @@ def test_send_msg_network_error(default_conf, mocker, caplog) -> None:
     Test send_msg() method
     """
     patch_coinmarketcap(mocker)
-    mocker.patch('freqtrade.freqtradebot.exchange.init', MagicMock())
     mocker.patch('freqtrade.rpc.telegram.Telegram._init', MagicMock())
     conf = deepcopy(default_conf)
     bot = MagicMock()
     bot.send_message = MagicMock(side_effect=NetworkError('Oh snap'))
-    freqtradebot = FreqtradeBot(conf)
+    freqtradebot = get_patched_freqtradebot(mocker, conf)
     telegram = Telegram(freqtradebot)
 
     telegram._config['telegram']['enabled'] = True
-    telegram.send_msg('test', bot)
+    telegram._send_msg('test', bot)
 
     # Bot should've tried to send it twice
     assert len(bot.method_calls) == 2

freqtrade/tests/strategy/test_strategy.py

@@ -1,14 +1,39 @@
 # pragma pylint: disable=missing-docstring, protected-access, C0103
-
 import logging
 import os
 
 import pytest
 
+from freqtrade.strategy import import_strategy
+from freqtrade.strategy.default_strategy import DefaultStrategy
 from freqtrade.strategy.interface import IStrategy
 from freqtrade.strategy.resolver import StrategyResolver
 
 
+def test_import_strategy(caplog):
+    caplog.set_level(logging.DEBUG)
+
+    strategy = DefaultStrategy()
+    strategy.some_method = lambda *args, **kwargs: 42
+
+    assert strategy.__module__ == 'freqtrade.strategy.default_strategy'
+    assert strategy.some_method() == 42
+
+    imported_strategy = import_strategy(strategy)
+
+    assert dir(strategy) == dir(imported_strategy)
+
+    assert imported_strategy.__module__ == 'freqtrade.strategy'
+    assert imported_strategy.some_method() == 42
+
+    assert (
+        'freqtrade.strategy',
+        logging.DEBUG,
+        'Imported strategy freqtrade.strategy.default_strategy.DefaultStrategy '
+        'as freqtrade.strategy.DefaultStrategy',
+    ) in caplog.record_tuples
+
+
 def test_search_strategy():
     default_location = os.path.join(os.path.dirname(
         os.path.realpath(__file__)), '..', '..', 'strategy'
@@ -20,19 +45,21 @@ def test_search_strategy():
 
 
 def test_load_strategy(result):
-    resolver = StrategyResolver()
-    resolver._load_strategy('TestStrategy')
+    resolver = StrategyResolver({'strategy': 'TestStrategy'})
     assert hasattr(resolver.strategy, 'populate_indicators')
     assert 'adx' in resolver.strategy.populate_indicators(result)
 
 
-def test_load_strategy_custom_directory(result):
+def test_load_strategy_invalid_directory(result, caplog):
     resolver = StrategyResolver()
     extra_dir = os.path.join('some', 'path')
-    with pytest.raises(
-            FileNotFoundError,
-            match=r".*No such file or directory: '{}'".format(extra_dir)):
-        resolver._load_strategy('TestStrategy', extra_dir)
+    resolver._load_strategy('TestStrategy', extra_dir)
+
+    assert (
+        'freqtrade.strategy.resolver',
+        logging.WARNING,
+        'Path "{}" does not exist'.format(extra_dir),
+    ) in caplog.record_tuples
 
     assert hasattr(resolver.strategy, 'populate_indicators')
     assert 'adx' in resolver.strategy.populate_indicators(result)

freqtrade/tests/test_acl_pair.py

@@ -1,8 +1,9 @@
 # pragma pylint: disable=missing-docstring,C0103,protected-access
 
-import freqtrade.tests.conftest as tt  # test tools
 from unittest.mock import MagicMock
 
+import freqtrade.tests.conftest as tt  # test tools
+
 # whitelist, blacklist, filtering, all of that will
 # eventually become some rules to run on a generic ACL engine
 # perhaps try to anticipate that by using some python package
@@ -32,7 +33,7 @@ def test_refresh_market_pair_not_in_whitelist(mocker, markets):
 
     freqtradebot = tt.get_patched_freqtradebot(mocker, conf)
 
-    mocker.patch('freqtrade.freqtradebot.exchange.get_markets', markets)
+    mocker.patch('freqtrade.exchange.Exchange.get_markets', markets)
     refreshedwhitelist = freqtradebot._refresh_whitelist(
         conf['exchange']['pair_whitelist'] + ['XXX/BTC']
     )
@@ -46,7 +47,7 @@ def test_refresh_whitelist(mocker, markets):
     conf = whitelist_conf()
     freqtradebot = tt.get_patched_freqtradebot(mocker, conf)
 
-    mocker.patch('freqtrade.freqtradebot.exchange.get_markets', markets)
+    mocker.patch('freqtrade.exchange.Exchange.get_markets', markets)
     refreshedwhitelist = freqtradebot._refresh_whitelist(conf['exchange']['pair_whitelist'])
 
     # List ordered by BaseVolume
@@ -59,7 +60,7 @@ def test_refresh_whitelist_dynamic(mocker, markets, tickers):
     conf = whitelist_conf()
     freqtradebot = tt.get_patched_freqtradebot(mocker, conf)
     mocker.patch.multiple(
-        'freqtrade.freqtradebot.exchange',
+        'freqtrade.exchange.Exchange',
         get_markets=markets,
         get_tickers=tickers,
         exchange_has=MagicMock(return_value=True)
@@ -78,7 +79,7 @@ def test_refresh_whitelist_dynamic(mocker, markets, tickers):
 def test_refresh_whitelist_dynamic_empty(mocker, markets_empty):
     conf = whitelist_conf()
     freqtradebot = tt.get_patched_freqtradebot(mocker, conf)
-    mocker.patch('freqtrade.freqtradebot.exchange.get_markets', markets_empty)
+    mocker.patch('freqtrade.exchange.Exchange.get_markets', markets_empty)
 
     # argument: use the whitelist dynamically by exchange-volume
     whitelist = []

freqtrade/tests/test_analyze.py

@@ -12,9 +12,9 @@ import arrow
 from pandas import DataFrame
 
 from freqtrade.analyze import Analyze, SignalType
-from freqtrade.optimize.__init__ import load_tickerdata_file
 from freqtrade.arguments import TimeRange
-from freqtrade.tests.conftest import log_has
+from freqtrade.optimize.__init__ import load_tickerdata_file
+from freqtrade.tests.conftest import get_patched_exchange, log_has
 
 # Avoid to reinit the same object again and again
 _ANALYZE = Analyze({'strategy': 'DefaultStrategy'})
@@ -42,6 +42,7 @@ def test_analyze_object() -> None:
     assert hasattr(Analyze, 'get_signal')
     assert hasattr(Analyze, 'should_sell')
     assert hasattr(Analyze, 'min_roi_reached')
+    assert hasattr(Analyze, 'stop_loss_reached')
 
 
 def test_dataframe_correct_length(result):
@@ -68,16 +69,16 @@ def test_populates_sell_trend(result):
     assert 'sell' in dataframe.columns
 
 
-def test_returns_latest_buy_signal(mocker):
-    mocker.patch('freqtrade.analyze.get_ticker_history', return_value=MagicMock())
-
+def test_returns_latest_buy_signal(mocker, default_conf):
+    mocker.patch('freqtrade.exchange.Exchange.get_ticker_history', return_value=MagicMock())
+    exchange = get_patched_exchange(mocker, default_conf)
     mocker.patch.multiple(
         'freqtrade.analyze.Analyze',
         analyze_ticker=MagicMock(
             return_value=DataFrame([{'buy': 1, 'sell': 0, 'date': arrow.utcnow()}])
         )
     )
-    assert _ANALYZE.get_signal('ETH/BTC', '5m') == (True, False)
+    assert _ANALYZE.get_signal(exchange, 'ETH/BTC', '5m') == (True, False)
 
     mocker.patch.multiple(
         'freqtrade.analyze.Analyze',
@@ -85,11 +86,12 @@ def test_returns_latest_buy_signal(mocker):
             return_value=DataFrame([{'buy': 0, 'sell': 1, 'date': arrow.utcnow()}])
         )
     )
-    assert _ANALYZE.get_signal('ETH/BTC', '5m') == (False, True)
+    assert _ANALYZE.get_signal(exchange, 'ETH/BTC', '5m') == (False, True)
 
 
-def test_returns_latest_sell_signal(mocker):
-    mocker.patch('freqtrade.analyze.get_ticker_history', return_value=MagicMock())
+def test_returns_latest_sell_signal(mocker, default_conf):
+    mocker.patch('freqtrade.exchange.Exchange.get_ticker_history', return_value=MagicMock())
+    exchange = get_patched_exchange(mocker, default_conf)
     mocker.patch.multiple(
         'freqtrade.analyze.Analyze',
         analyze_ticker=MagicMock(
@@ -97,7 +99,7 @@ def test_returns_latest_sell_signal(mocker):
         )
     )
 
-    assert _ANALYZE.get_signal('ETH/BTC', '5m') == (False, True)
+    assert _ANALYZE.get_signal(exchange, 'ETH/BTC', '5m') == (False, True)
 
     mocker.patch.multiple(
         'freqtrade.analyze.Analyze',
@@ -105,45 +107,49 @@ def test_returns_latest_sell_signal(mocker):
             return_value=DataFrame([{'sell': 0, 'buy': 1, 'date': arrow.utcnow()}])
         )
     )
-    assert _ANALYZE.get_signal('ETH/BTC', '5m') == (True, False)
+    assert _ANALYZE.get_signal(exchange, 'ETH/BTC', '5m') == (True, False)
 
 
 def test_get_signal_empty(default_conf, mocker, caplog):
     caplog.set_level(logging.INFO)
-    mocker.patch('freqtrade.analyze.get_ticker_history', return_value=None)
-    assert (False, False) == _ANALYZE.get_signal('foo', default_conf['ticker_interval'])
+    mocker.patch('freqtrade.exchange.Exchange.get_ticker_history', return_value=None)
+    exchange = get_patched_exchange(mocker, default_conf)
+    assert (False, False) == _ANALYZE.get_signal(exchange, 'foo', default_conf['ticker_interval'])
     assert log_has('Empty ticker history for pair foo', caplog.record_tuples)
 
 
 def test_get_signal_exception_valueerror(default_conf, mocker, caplog):
     caplog.set_level(logging.INFO)
-    mocker.patch('freqtrade.analyze.get_ticker_history', return_value=1)
+    mocker.patch('freqtrade.exchange.Exchange.get_ticker_history', return_value=1)
+    exchange = get_patched_exchange(mocker, default_conf)
     mocker.patch.multiple(
         'freqtrade.analyze.Analyze',
         analyze_ticker=MagicMock(
             side_effect=ValueError('xyz')
         )
     )
-    assert (False, False) == _ANALYZE.get_signal('foo', default_conf['ticker_interval'])
+    assert (False, False) == _ANALYZE.get_signal(exchange, 'foo', default_conf['ticker_interval'])
     assert log_has('Unable to analyze ticker for pair foo: xyz', caplog.record_tuples)
 
 
 def test_get_signal_empty_dataframe(default_conf, mocker, caplog):
     caplog.set_level(logging.INFO)
-    mocker.patch('freqtrade.analyze.get_ticker_history', return_value=1)
+    mocker.patch('freqtrade.exchange.Exchange.get_ticker_history', return_value=1)
+    exchange = get_patched_exchange(mocker, default_conf)
     mocker.patch.multiple(
         'freqtrade.analyze.Analyze',
         analyze_ticker=MagicMock(
             return_value=DataFrame([])
         )
     )
-    assert (False, False) == _ANALYZE.get_signal('xyz', default_conf['ticker_interval'])
+    assert (False, False) == _ANALYZE.get_signal(exchange, 'xyz', default_conf['ticker_interval'])
     assert log_has('Empty dataframe for pair xyz', caplog.record_tuples)
 
 
 def test_get_signal_old_dataframe(default_conf, mocker, caplog):
     caplog.set_level(logging.INFO)
-    mocker.patch('freqtrade.analyze.get_ticker_history', return_value=1)
+    mocker.patch('freqtrade.exchange.Exchange.get_ticker_history', return_value=1)
+    exchange = get_patched_exchange(mocker, default_conf)
     # FIX: The get_signal function has hardcoded 10, which we must inturn hardcode
     oldtime = arrow.utcnow() - datetime.timedelta(minutes=11)
     ticks = DataFrame([{'buy': 1, 'date': oldtime}])
@@ -153,15 +159,16 @@ def test_get_signal_old_dataframe(default_conf, mocker, caplog):
             return_value=DataFrame(ticks)
         )
     )
-    assert (False, False) == _ANALYZE.get_signal('xyz', default_conf['ticker_interval'])
+    assert (False, False) == _ANALYZE.get_signal(exchange, 'xyz', default_conf['ticker_interval'])
     assert log_has(
         'Outdated history for pair xyz. Last tick is 11 minutes old',
         caplog.record_tuples
     )
 
 
-def test_get_signal_handles_exceptions(mocker):
-    mocker.patch('freqtrade.analyze.get_ticker_history', return_value=MagicMock())
+def test_get_signal_handles_exceptions(mocker, default_conf):
+    mocker.patch('freqtrade.exchange.Exchange.get_ticker_history', return_value=MagicMock())
+    exchange = get_patched_exchange(mocker, default_conf)
     mocker.patch.multiple(
         'freqtrade.analyze.Analyze',
         analyze_ticker=MagicMock(
@@ -169,7 +176,7 @@ def test_get_signal_handles_exceptions(mocker):
         )
     )
 
-    assert _ANALYZE.get_signal('ETH/BTC', '5m') == (False, False)
+    assert _ANALYZE.get_signal(exchange, 'ETH/BTC', '5m') == (False, False)
 
 
 def test_parse_ticker_dataframe(ticker_history):

freqtrade/tests/test_configuration.py

@@ -4,17 +4,18 @@
 Unit test file for configuration.py
 """
 import json
+from argparse import Namespace
 from copy import deepcopy
 from unittest.mock import MagicMock
-from argparse import Namespace
 
 import pytest
 from jsonschema import ValidationError
 
+from freqtrade import OperationalException
 from freqtrade.arguments import Arguments
 from freqtrade.configuration import Configuration
+from freqtrade.constants import DEFAULT_DB_DRYRUN_URL, DEFAULT_DB_PROD_URL
 from freqtrade.tests.conftest import log_has
-from freqtrade import OperationalException
 
 
 def test_configuration_object() -> None:
@@ -54,6 +55,18 @@ def test_load_config_missing_attributes(default_conf) -> None:
         configuration._validate_config(conf)
 
 
+def test_load_config_incorrect_stake_amount(default_conf) -> None:
+    """
+    Test the configuration validator with a missing attribute
+    """
+    conf = deepcopy(default_conf)
+    conf['stake_amount'] = 'fake'
+
+    with pytest.raises(ValidationError, match=r'.*\'fake\' does not match \'unlimited\'.*'):
+        configuration = Configuration(Namespace())
+        configuration._validate_config(conf)
+
+
 def test_load_config_file(default_conf, mocker, caplog) -> None:
     """
     Test Configuration._load_config_file() method
@@ -140,6 +153,43 @@ def test_load_config_with_params(default_conf, mocker) -> None:
     assert validated_conf.get('strategy_path') == '/some/path'
     assert validated_conf.get('db_url') == 'sqlite:///someurl'
 
+    conf = default_conf.copy()
+    conf["dry_run"] = False
+    del conf["db_url"]
+    mocker.patch('freqtrade.configuration.open', mocker.mock_open(
+        read_data=json.dumps(conf)
+    ))
+
+    arglist = [
+         '--dynamic-whitelist', '10',
+         '--strategy', 'TestStrategy',
+         '--strategy-path', '/some/path'
+     ]
+    args = Arguments(arglist, '').get_parsed_arg()
+
+    configuration = Configuration(args)
+    validated_conf = configuration.load_config()
+    assert validated_conf.get('db_url') == DEFAULT_DB_PROD_URL
+
+    # Test dry=run with ProdURL
+    conf = default_conf.copy()
+    conf["dry_run"] = True
+    conf["db_url"] = DEFAULT_DB_PROD_URL
+    mocker.patch('freqtrade.configuration.open', mocker.mock_open(
+        read_data=json.dumps(conf)
+    ))
+
+    arglist = [
+        '--dynamic-whitelist', '10',
+        '--strategy', 'TestStrategy',
+        '--strategy-path', '/some/path'
+    ]
+    args = Arguments(arglist, '').get_parsed_arg()
+
+    configuration = Configuration(args)
+    validated_conf = configuration.load_config()
+    assert validated_conf.get('db_url') == DEFAULT_DB_DRYRUN_URL
+
 
 def test_load_custom_strategy(default_conf, mocker) -> None:
     """
@@ -310,7 +360,6 @@ def test_hyperopt_with_arguments(mocker, default_conf, caplog) -> None:
     arglist = [
         'hyperopt',
         '--epochs', '10',
-        '--use-mongodb',
         '--spaces', 'all',
     ]
 
@@ -324,10 +373,6 @@ def test_hyperopt_with_arguments(mocker, default_conf, caplog) -> None:
     assert log_has('Parameter --epochs detected ...', caplog.record_tuples)
     assert log_has('Will run Hyperopt with for 10 epochs ...', caplog.record_tuples)
 
-    assert 'mongodb' in config
-    assert config['mongodb'] is True
-    assert log_has('Parameter --use-mongodb detected ...', caplog.record_tuples)
-
     assert 'spaces' in config
     assert config['spaces'] == ['all']
     assert log_has('Parameter -s/--spaces detected: [\'all\']', caplog.record_tuples)

freqtrade/tests/test_fiat_convert.py

@@ -5,7 +5,6 @@ import time
 from unittest.mock import MagicMock
 
 import pytest
-
 from requests.exceptions import RequestException
 
 from freqtrade.fiat_convert import CryptoFiat, CryptoToFiatConverter
@@ -40,7 +39,8 @@ def test_pair_convertion_object():
     assert pair_convertion.price == 30000.123
 
 
-def test_fiat_convert_is_supported():
+def test_fiat_convert_is_supported(mocker):
+    patch_coinmarketcap(mocker)
     fiat_convert = CryptoToFiatConverter()
     assert fiat_convert._is_supported_fiat(fiat='USD') is True
     assert fiat_convert._is_supported_fiat(fiat='usd') is True
@@ -48,7 +48,9 @@ def test_fiat_convert_is_supported():
     assert fiat_convert._is_supported_fiat(fiat='ABC') is False
 
 
-def test_fiat_convert_add_pair():
+def test_fiat_convert_add_pair(mocker):
+    patch_coinmarketcap(mocker)
+
     fiat_convert = CryptoToFiatConverter()
 
     pair_len = len(fiat_convert._pairs)
@@ -70,11 +72,8 @@ def test_fiat_convert_add_pair():
 
 
 def test_fiat_convert_find_price(mocker):
-    api_mock = MagicMock(return_value={
-        'price_usd': 12345.0,
-        'price_eur': 13000.2
-    })
-    mocker.patch('freqtrade.fiat_convert.Market.ticker', api_mock)
+    patch_coinmarketcap(mocker)
+
     fiat_convert = CryptoToFiatConverter()
 
     with pytest.raises(ValueError, match=r'The fiat ABC is not supported.'):
@@ -92,17 +91,15 @@ def test_fiat_convert_find_price(mocker):
 
 def test_fiat_convert_unsupported_crypto(mocker, caplog):
     mocker.patch('freqtrade.fiat_convert.CryptoToFiatConverter._cryptomap', return_value=[])
+    patch_coinmarketcap(mocker)
     fiat_convert = CryptoToFiatConverter()
     assert fiat_convert._find_price(crypto_symbol='CRYPTO_123', fiat_symbol='EUR') == 0.0
     assert log_has('unsupported crypto-symbol CRYPTO_123 - returning 0.0', caplog.record_tuples)
 
 
 def test_fiat_convert_get_price(mocker):
-    api_mock = MagicMock(return_value={
-        'price_usd': 28000.0,
-        'price_eur': 15000.0
-    })
-    mocker.patch('freqtrade.fiat_convert.Market.ticker', api_mock)
+    patch_coinmarketcap(mocker)
+
     mocker.patch('freqtrade.fiat_convert.CryptoToFiatConverter._find_price', return_value=28000.0)
 
     fiat_convert = CryptoToFiatConverter()
@@ -172,8 +169,9 @@ def test_fiat_init_network_exception(mocker):
     assert length_cryptomap == 0
 
 
-def test_fiat_convert_without_network():
+def test_fiat_convert_without_network(mocker):
     # Because CryptoToFiatConverter is a Singleton we reset the value of _coinmarketcap
+    patch_coinmarketcap(mocker)
 
     fiat_convert = CryptoToFiatConverter()
 
@@ -186,6 +184,7 @@ def test_fiat_convert_without_network():
 
 
 def test_convert_amount(mocker):
+    patch_coinmarketcap(mocker)
     mocker.patch('freqtrade.fiat_convert.CryptoToFiatConverter.get_price', return_value=12345.0)
 
     fiat_convert = CryptoToFiatConverter()

freqtrade/tests/test_indicator_helpers.py

@@ -1,6 +1,6 @@
 import pandas as pd
 
-from freqtrade.indicator_helpers import went_up, went_down
+from freqtrade.indicator_helpers import went_down, went_up
 
 
 def test_went_up():

freqtrade/tests/test_main.py

@@ -11,9 +11,9 @@ import pytest
 from freqtrade import OperationalException
 from freqtrade.arguments import Arguments
 from freqtrade.freqtradebot import FreqtradeBot
-from freqtrade.main import main, set_loggers, reconfigure
+from freqtrade.main import main, reconfigure, set_loggers
 from freqtrade.state import State
-from freqtrade.tests.conftest import log_has
+from freqtrade.tests.conftest import log_has, patch_exchange
 
 
 def test_parse_args_backtesting(mocker) -> None:
@@ -70,6 +70,7 @@ def test_main_fatal_exception(mocker, default_conf, caplog) -> None:
     Test main() function
     In this test we are skipping the while True loop by throwing an exception.
     """
+    patch_exchange(mocker)
     mocker.patch.multiple(
         'freqtrade.freqtradebot.FreqtradeBot',
         _init_modules=MagicMock(),
@@ -97,6 +98,7 @@ def test_main_keyboard_interrupt(mocker, default_conf, caplog) -> None:
     Test main() function
     In this test we are skipping the while True loop by throwing an exception.
     """
+    patch_exchange(mocker)
     mocker.patch.multiple(
         'freqtrade.freqtradebot.FreqtradeBot',
         _init_modules=MagicMock(),
@@ -124,6 +126,7 @@ def test_main_operational_exception(mocker, default_conf, caplog) -> None:
     Test main() function
     In this test we are skipping the while True loop by throwing an exception.
     """
+    patch_exchange(mocker)
     mocker.patch.multiple(
         'freqtrade.freqtradebot.FreqtradeBot',
         _init_modules=MagicMock(),
@@ -151,6 +154,7 @@ def test_main_reload_conf(mocker, default_conf, caplog) -> None:
     Test main() function
     In this test we are skipping the while True loop by throwing an exception.
     """
+    patch_exchange(mocker)
     mocker.patch.multiple(
         'freqtrade.freqtradebot.FreqtradeBot',
         _init_modules=MagicMock(),
@@ -178,6 +182,7 @@ def test_main_reload_conf(mocker, default_conf, caplog) -> None:
 
 def test_reconfigure(mocker, default_conf) -> None:
     """ Test recreate() function """
+    patch_exchange(mocker)
     mocker.patch.multiple(
         'freqtrade.freqtradebot.FreqtradeBot',
         _init_modules=MagicMock(),

freqtrade/tests/test_misc.py

@@ -8,8 +8,8 @@ import datetime
 from unittest.mock import MagicMock
 
 from freqtrade.analyze import Analyze
-from freqtrade.misc import (shorten_date, datesarray_to_datetimearray,
-                            common_datearray, file_dump_json, format_ms_time)
+from freqtrade.misc import (common_datearray, datesarray_to_datetimearray,
+                            file_dump_json, format_ms_time, shorten_date)
 from freqtrade.optimize.__init__ import load_tickerdata_file
 
 

freqtrade/tests/test_persistence.py

@@ -5,8 +5,9 @@ from unittest.mock import MagicMock
 import pytest
 from sqlalchemy import create_engine
 
-from freqtrade import constants, OperationalException
-from freqtrade.persistence import Trade, init, clean_dry_run_db
+from freqtrade import OperationalException, constants
+from freqtrade.persistence import Trade, clean_dry_run_db, init
+from freqtrade.tests.conftest import log_has
 
 
 @pytest.fixture(scope='function')
@@ -14,9 +15,7 @@ def init_persistence(default_conf):
     init(default_conf)
 
 
-def test_init_create_session(default_conf, mocker):
-    mocker.patch.dict('freqtrade.persistence._CONF', default_conf)
-
+def test_init_create_session(default_conf):
     # Check if init create a session
     init(default_conf)
     assert hasattr(Trade, 'session')
@@ -29,20 +28,17 @@ def test_init_custom_db_url(default_conf, mocker):
     # Update path to a value other than default, but still in-memory
     conf.update({'db_url': 'sqlite:///tmp/freqtrade2_test.sqlite'})
     create_engine_mock = mocker.patch('freqtrade.persistence.create_engine', MagicMock())
-    mocker.patch.dict('freqtrade.persistence._CONF', conf)
 
     init(conf)
     assert create_engine_mock.call_count == 1
     assert create_engine_mock.mock_calls[0][1][0] == 'sqlite:///tmp/freqtrade2_test.sqlite'
 
 
-def test_init_invalid_db_url(default_conf, mocker):
+def test_init_invalid_db_url(default_conf):
     conf = deepcopy(default_conf)
 
     # Update path to a value other than default, but still in-memory
     conf.update({'db_url': 'unknown:///some.url'})
-    mocker.patch.dict('freqtrade.persistence._CONF', conf)
-
     with pytest.raises(OperationalException, match=r'.*no valid database URL*'):
         init(conf)
 
@@ -53,7 +49,6 @@ def test_init_prod_db(default_conf, mocker):
     conf.update({'db_url': constants.DEFAULT_DB_PROD_URL})
 
     create_engine_mock = mocker.patch('freqtrade.persistence.create_engine', MagicMock())
-    mocker.patch.dict('freqtrade.persistence._CONF', conf)
 
     init(conf)
     assert create_engine_mock.call_count == 1
@@ -66,7 +61,6 @@ def test_init_dryrun_db(default_conf, mocker):
     conf.update({'db_url': constants.DEFAULT_DB_DRYRUN_URL})
 
     create_engine_mock = mocker.patch('freqtrade.persistence.create_engine', MagicMock())
-    mocker.patch.dict('freqtrade.persistence._CONF', conf)
 
     init(conf)
     assert create_engine_mock.call_count == 1
@@ -407,9 +401,12 @@ def test_migrate_old(mocker, default_conf, fee):
     assert trade.stake_amount == default_conf.get("stake_amount")
     assert trade.pair == "ETC/BTC"
     assert trade.exchange == "bittrex"
+    assert trade.max_rate == 0.0
+    assert trade.stop_loss == 0.0
+    assert trade.initial_stop_loss == 0.0
 
 
-def test_migrate_new(mocker, default_conf, fee):
+def test_migrate_new(mocker, default_conf, fee, caplog):
     """
     Test Database migration (starting with new pairformat)
     """
@@ -446,6 +443,11 @@ def test_migrate_new(mocker, default_conf, fee):
     # Create table using the old format
     engine.execute(create_table_old)
     engine.execute(insert_table_old)
+
+    # fake previous backup
+    engine.execute("create table trades_bak as select * from trades")
+
+    engine.execute("create table trades_bak1 as select * from trades")
     # Run init to test migration
     init(default_conf)
 
@@ -460,3 +462,54 @@ def test_migrate_new(mocker, default_conf, fee):
     assert trade.stake_amount == default_conf.get("stake_amount")
     assert trade.pair == "ETC/BTC"
     assert trade.exchange == "binance"
+    assert trade.max_rate == 0.0
+    assert trade.stop_loss == 0.0
+    assert trade.initial_stop_loss == 0.0
+    assert log_has("trying trades_bak1", caplog.record_tuples)
+    assert log_has("trying trades_bak2", caplog.record_tuples)
+
+
+def test_adjust_stop_loss(limit_buy_order, limit_sell_order, fee):
+    trade = Trade(
+        pair='ETH/BTC',
+        stake_amount=0.001,
+        fee_open=fee.return_value,
+        fee_close=fee.return_value,
+        exchange='bittrex',
+        open_rate=1,
+    )
+
+    trade.adjust_stop_loss(trade.open_rate, 0.05, True)
+    assert trade.stop_loss == 0.95
+    assert trade.max_rate == 1
+    assert trade.initial_stop_loss == 0.95
+
+    # Get percent of profit with a lowre rate
+    trade.adjust_stop_loss(0.96, 0.05)
+    assert trade.stop_loss == 0.95
+    assert trade.max_rate == 1
+    assert trade.initial_stop_loss == 0.95
+
+    # Get percent of profit with a custom rate (Higher than open rate)
+    trade.adjust_stop_loss(1.3, -0.1)
+    assert round(trade.stop_loss, 8) == 1.17
+    assert trade.max_rate == 1.3
+    assert trade.initial_stop_loss == 0.95
+
+    # current rate lower again ... should not change
+    trade.adjust_stop_loss(1.2, 0.1)
+    assert round(trade.stop_loss, 8) == 1.17
+    assert trade.max_rate == 1.3
+    assert trade.initial_stop_loss == 0.95
+
+    # current rate higher... should raise stoploss
+    trade.adjust_stop_loss(1.4, 0.1)
+    assert round(trade.stop_loss, 8) == 1.26
+    assert trade.max_rate == 1.4
+    assert trade.initial_stop_loss == 0.95
+
+    #  Initial is true but stop_loss set - so doesn't do anything
+    trade.adjust_stop_loss(1.7, 0.1, True)
+    assert round(trade.stop_loss, 8) == 1.26
+    assert trade.max_rate == 1.4
+    assert trade.initial_stop_loss == 0.95

freqtrade/vendor/qtpylib/indicators.py

@@ -110,10 +110,13 @@ def heikinashi(bars):
     bars = bars.copy()
     bars['ha_close'] = (bars['open'] + bars['high'] +
                         bars['low'] + bars['close']) / 4
+
     bars['ha_open'] = (bars['open'].shift(1) + bars['close'].shift(1)) / 2
     bars.loc[:1, 'ha_open'] = bars['open'].values[0]
-    bars.loc[1:, 'ha_open'] = (
-        (bars['ha_open'].shift(1) + bars['ha_close'].shift(1)) / 2)[1:]
+    for x in range(2):
+        bars.loc[1:, 'ha_open'] = (
+            (bars['ha_open'].shift(1) + bars['ha_close'].shift(1)) / 2)[1:]
+
     bars['ha_high'] = bars.loc[:, ['high', 'ha_open', 'ha_close']].max(axis=1)
     bars['ha_low'] = bars.loc[:, ['low', 'ha_open', 'ha_close']].min(axis=1)
 
@@ -248,45 +251,36 @@ def crossed_below(series1, series2):
 
 def rolling_std(series, window=200, min_periods=None):
     min_periods = window if min_periods is None else min_periods
-    try:
-        if min_periods == window:
-            return numpy_rolling_std(series, window, True)
-        else:
-            try:
-                return series.rolling(window=window, min_periods=min_periods).std()
-            except BaseException:
-                return pd.Series(series).rolling(window=window, min_periods=min_periods).std()
-    except BaseException:
-        return pd.rolling_std(series, window=window, min_periods=min_periods)
-
+    if min_periods == window and len(series) > window:
+        return numpy_rolling_std(series, window, True)
+    else:
+        try:
+            return series.rolling(window=window, min_periods=min_periods).std()
+        except BaseException:
+            return pd.Series(series).rolling(window=window, min_periods=min_periods).std()
 
 # ---------------------------------------------
 
+
 def rolling_mean(series, window=200, min_periods=None):
     min_periods = window if min_periods is None else min_periods
-    try:
-        if min_periods == window:
-            return numpy_rolling_mean(series, window, True)
-        else:
-            try:
-                return series.rolling(window=window, min_periods=min_periods).mean()
-            except BaseException:
-                return pd.Series(series).rolling(window=window, min_periods=min_periods).mean()
-    except BaseException:
-        return pd.rolling_mean(series, window=window, min_periods=min_periods)
-
+    if min_periods == window and len(series) > window:
+        return numpy_rolling_mean(series, window, True)
+    else:
+        try:
+            return series.rolling(window=window, min_periods=min_periods).mean()
+        except BaseException:
+            return pd.Series(series).rolling(window=window, min_periods=min_periods).mean()
 
 # ---------------------------------------------
 
+
 def rolling_min(series, window=14, min_periods=None):
     min_periods = window if min_periods is None else min_periods
     try:
-        try:
-            return series.rolling(window=window, min_periods=min_periods).min()
-        except BaseException:
-            return pd.Series(series).rolling(window=window, min_periods=min_periods).min()
+        return series.rolling(window=window, min_periods=min_periods).min()
     except BaseException:
-        return pd.rolling_min(series, window=window, min_periods=min_periods)
+        return pd.Series(series).rolling(window=window, min_periods=min_periods).min()
 
 
 # ---------------------------------------------
@@ -294,12 +288,9 @@ def rolling_min(series, window=14, min_periods=None):
 def rolling_max(series, window=14, min_periods=None):
     min_periods = window if min_periods is None else min_periods
     try:
-        try:
-            return series.rolling(window=window, min_periods=min_periods).min()
-        except BaseException:
-            return pd.Series(series).rolling(window=window, min_periods=min_periods).min()
+        return series.rolling(window=window, min_periods=min_periods).min()
     except BaseException:
-        return pd.rolling_min(series, window=window, min_periods=min_periods)
+        return pd.Series(series).rolling(window=window, min_periods=min_periods).min()
 
 
 # ---------------------------------------------
@@ -566,9 +557,9 @@ def stoch(df, window=14, d=3, k=3, fast=False):
 
     return pd.DataFrame(index=df.index, data=data)
 
-
 # ---------------------------------------------
 
+
 def zscore(bars, window=20, stds=1, col='close'):
     """ get zscore of price """
     std = numpy_rolling_std(bars[col], window)