Merge branch 'develop' into BASE64

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

@@ -12,8 +12,7 @@ from pandas import DataFrame, to_datetime
 from freqtrade import constants
 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__)
 
@@ -180,7 +179,7 @@ class Analyze(object):
         :return: True if trade should be sold, False otherwise
         """
         current_profit = trade.calc_profit_percent(rate)
-        if self.stop_loss_reached(current_profit=current_profit):
+        if self.stop_loss_reached(current_rate=rate, trade=trade, current_time=date):
             return True
 
         experimental = self.config.get('experimental', {})
@@ -204,12 +203,46 @@ class Analyze(object):
 
         return False
 
-    def stop_loss_reached(self, current_profit: float) -> bool:
-        """Based on current profit of the trade and configured stoploss, decides to sell or not"""
+    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}")
 
-        if self.strategy.stoploss is not None and current_profit < self.strategy.stoploss:
             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:

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
 
@@ -334,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)

freqtrade/constants.py

@@ -61,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': {

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,16 +7,14 @@ 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, 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
@@ -160,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:
@@ -277,11 +275,14 @@ class FreqtradeBot(object):
             return None
 
         min_stake_amounts = []
-        if 'cost' in market['limits'] and 'min' in market['limits']['cost']:
-            min_stake_amounts.append(market['limits']['cost']['min'])
+        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 market['limits'] and 'min' in market['limits']['amount']:
-            min_stake_amounts.append(market['limits']['amount']['min'] * price)
+        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
@@ -492,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:
@@ -521,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
@@ -620,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

@@ -54,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.

freqtrade/optimize/backtesting.py

@@ -7,18 +7,18 @@ import logging
 import operator
 from argparse import Namespace
 from datetime import datetime
-from typing import Dict, Tuple, Any, List, Optional, NamedTuple
+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 constants, DependencyException
-from freqtrade.exchange 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
 
@@ -38,6 +38,8 @@ class BacktestResult(NamedTuple):
     close_index: int
     trade_duration: float
     open_at_end: bool
+    open_rate: float
+    close_rate: float
 
 
 class Backtesting(object):
@@ -116,11 +118,10 @@ class Backtesting(object):
 
     def _store_backtest_result(self, recordfilename: Optional[str], results: DataFrame) -> None:
 
-        records = [(trade_entry.pair, trade_entry.profit_percent,
-                    trade_entry.open_time.timestamp(),
-                    trade_entry.close_time.timestamp(),
-                    trade_entry.open_index - 1, trade_entry.trade_duration)
-                   for index, trade_entry in results.iterrows()]
+        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)
@@ -159,7 +160,9 @@ class Backtesting(object):
                                       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_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
@@ -172,7 +175,9 @@ class Backtesting(object):
                                  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_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)

freqtrade/optimize/hyperopt.py

@@ -4,22 +4,21 @@
 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 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
@@ -29,6 +28,9 @@ from freqtrade.optimize.backtesting import Backtesting
 
 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):
     """
@@ -44,7 +46,6 @@ class Hyperopt(Backtesting):
         # 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
@@ -56,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
 
@@ -187,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
 
@@ -203,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='')
@@ -231,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]:
@@ -247,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:
         """
@@ -337,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
@@ -361,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),
@@ -427,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)
 
@@ -437,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),
             }
         )
@@ -450,30 +289,18 @@ class Hyperopt(Backtesting):
         trade_count = len(results.index)
         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,
         }
 
@@ -481,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_abs.sum(),
-                    self.config['stake_currency'],
-                    results.profit_percent.sum(),
-                    results.trade_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(
@@ -503,67 +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()
 
-        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:

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
@@ -22,6 +21,7 @@ from freqtrade import OperationalException
 logger = logging.getLogger(__name__)
 
 _DECL_BASE: Any = declarative_base()
+_SQL_DOCS_URL = 'http://docs.sqlalchemy.org/en/latest/core/engines.html#database-urls'
 
 
 def init(config: Dict) -> None:
@@ -46,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()
@@ -66,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
@@ -73,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
@@ -94,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:
     """
@@ -151,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:
         """
@@ -167,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
@@ -174,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:
@@ -254,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,
@@ -274,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

@@ -3,9 +3,9 @@ This module contains class to define a RPC communications
 """
 import logging
 from abc import abstractmethod
-from datetime import datetime, timedelta, date
+from datetime import date, datetime, timedelta
 from decimal import Decimal
-from typing import Dict, Tuple, Any, List
+from typing import Any, Dict, List, Tuple
 
 import arrow
 import sqlalchemy as sql
@@ -74,34 +74,32 @@ class RPC(object):
                 # calculate profit and send message to user
                 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=self._freqtrade.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,
-                          )
+                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})'
+
+                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
 
@@ -116,11 +114,12 @@ class RPC(object):
             for trade in trades:
                 # calculate profit and send message to user
                 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']
@@ -148,7 +147,7 @@ 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)
             }
 

freqtrade/rpc/telegram.py

@@ -153,7 +153,7 @@ class Telegram(RPC):
         try:
             df_statuses = self._rpc_status_table()
             message = tabulate(df_statuses, headers='keys', tablefmt='simple')
-            self._send_msg("<pre>{}</pre>".format(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)
 
@@ -166,6 +166,8 @@ 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):
@@ -173,18 +175,17 @@ class Telegram(RPC):
         try:
             stats = self._rpc_daily_profit(
                 timescale,
-                self._config['stake_currency'],
-                self._config['fiat_display_currency']
+                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)
+            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)
@@ -198,39 +199,38 @@ class Telegram(RPC):
         :param update: message update
         :return: None
         """
+        stake_cur = self._config['stake_currency']
+        fiat_disp_cur = self._config['fiat_display_currency']
+
         try:
             stats = self._rpc_trade_statistics(
-                self._config['stake_currency'],
-                self._config['fiat_display_currency'])
-
+                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" \
-                           "∙ `{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']
-                           )
+                           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)

freqtrade/strategy/interface.py

@@ -2,8 +2,8 @@
 IStrategy interface
 This module defines the interface to apply for strategies
 """
-from typing import Dict
 from abc import ABC, abstractmethod
+from typing import Dict
 
 from pandas import DataFrame
 

freqtrade/strategy/resolver.py

@@ -8,7 +8,7 @@ import inspect
 import logging
 from base64 import urlsafe_b64decode
 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
@@ -17,6 +17,7 @@ import tempfile
 import os
 from pathlib import Path
 
+
 logger = logging.getLogger(__name__)
 
 
@@ -82,8 +83,8 @@ class StrategyResolver(object):
             # Add extra strategy directory on top of search paths
             abs_paths.insert(0, extra_dir)
 
-        if ":" in strategy_name and "http" not in strategy_name:
-            print("loading none http based strategy: {}".format(strategy_name))
+        if ":" in strategy_name:
+            logger.debug(("loading base64 endocded strategy".)
             strat = strategy_name.split(":")
 
             if len(strat) == 2:

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,8 @@ 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
 
@@ -100,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
         },

freqtrade/tests/exchange/test_exchange.py

@@ -2,16 +2,32 @@
 # pragma pylint: disable=protected-access
 import logging
 from copy import deepcopy
-from random import randint
 from datetime import datetime
+from random import randint
 from unittest.mock import MagicMock, PropertyMock
 
 import ccxt
 import pytest
 
-from freqtrade import OperationalException, DependencyException, TemporaryError
-from freqtrade.exchange import Exchange, API_RETRY_COUNT
-from freqtrade.tests.conftest import log_has, get_patched_exchange
+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 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):
@@ -20,7 +36,7 @@ def test_init(default_conf, mocker, caplog):
     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(
@@ -28,6 +44,13 @@ def test_init_exception(default_conf):
             match='Exchange {} is not supported'.format(default_conf['exchange']['name'])):
         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):
     api_mock = MagicMock()
@@ -97,6 +120,20 @@ def test_validate_pairs_stake_exception(default_conf, mocker, caplog):
         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
     exchange = get_patched_exchange(mocker, default_conf)
@@ -216,6 +253,11 @@ def test_get_balance_prod(default_conf, mocker):
 
         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
@@ -243,17 +285,8 @@ def test_get_balances_prod(default_conf, mocker):
     assert exchange.get_balances()['1ST']['total'] == 10.0
     assert exchange.get_balances()['1ST']['used'] == 0.0
 
-    with pytest.raises(TemporaryError):
-        api_mock.fetch_balance = MagicMock(side_effect=ccxt.NetworkError)
-        exchange = get_patched_exchange(mocker, default_conf, api_mock)
-        exchange.get_balances()
-    assert api_mock.fetch_balance.call_count == API_RETRY_COUNT + 1
-
-    with pytest.raises(OperationalException):
-        api_mock.fetch_balance = MagicMock(side_effect=ccxt.BaseError)
-        exchange = get_patched_exchange(mocker, default_conf, api_mock)
-        exchange.get_balances()
-    assert api_mock.fetch_balance.call_count == 1
+    ccxt_exceptionhandlers(mocker, default_conf, api_mock,
+                           "get_balances", "fetch_balance")
 
 
 def test_get_tickers(default_conf, mocker):
@@ -282,15 +315,8 @@ def test_get_tickers(default_conf, mocker):
     assert tickers['BCH/BTC']['bid'] == 0.6
     assert tickers['BCH/BTC']['ask'] == 0.5
 
-    with pytest.raises(TemporaryError):  # test retrier
-        api_mock.fetch_tickers = MagicMock(side_effect=ccxt.NetworkError)
-        exchange = get_patched_exchange(mocker, default_conf, api_mock)
-        exchange.get_tickers()
-
-    with pytest.raises(OperationalException):
-        api_mock.fetch_tickers = MagicMock(side_effect=ccxt.BaseError)
-        exchange = get_patched_exchange(mocker, default_conf, api_mock)
-        exchange.get_tickers()
+    ccxt_exceptionhandlers(mocker, default_conf, api_mock,
+                           "get_tickers", "fetch_tickers")
 
     with pytest.raises(OperationalException):
         api_mock.fetch_tickers = MagicMock(side_effect=ccxt.NotSupported)
@@ -345,15 +371,9 @@ def test_get_ticker(default_conf, mocker):
     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)
-        exchange = get_patched_exchange(mocker, default_conf, api_mock)
-        exchange.get_ticker(pair='ETH/BTC', refresh=True)
-
-    with pytest.raises(OperationalException):
-        api_mock.fetch_ticker = MagicMock(side_effect=ccxt.BaseError)
-        exchange = get_patched_exchange(mocker, default_conf, api_mock)
-        exchange.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={})
     exchange = get_patched_exchange(mocker, default_conf, api_mock)
@@ -416,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)
-        exchange = get_patched_exchange(mocker, default_conf, api_mock)
-        # new symbol to get around cache
-        exchange.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)
+    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)
-        # new symbol to get around cache
-        exchange.get_ticker_history('EFGH/BTC', default_conf['ticker_interval'])
+        exchange.get_ticker_history(pair='ABCD/BTC', tick_interval=default_conf['ticker_interval'])
 
 
 def test_get_ticker_history_sort(default_conf, mocker):
@@ -515,24 +532,15 @@ def test_cancel_order(default_conf, mocker):
     exchange = get_patched_exchange(mocker, default_conf, api_mock)
     assert exchange.cancel_order(order_id='_', pair='TKN/BTC') == 123
 
-    with pytest.raises(TemporaryError):
-        api_mock.cancel_order = MagicMock(side_effect=ccxt.NetworkError)
-
-        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(DependencyException):
         api_mock.cancel_order = MagicMock(side_effect=ccxt.InvalidOrder)
         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)
-        exchange = get_patched_exchange(mocker, default_conf, api_mock)
-        exchange.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):
@@ -550,23 +558,15 @@ def test_get_order(default_conf, mocker):
     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)
-        exchange = get_patched_exchange(mocker, default_conf, api_mock)
-        exchange.get_order(order_id='_', pair='TKN/BTC')
-    assert api_mock.fetch_order.call_count == API_RETRY_COUNT + 1
-
     with pytest.raises(DependencyException):
         api_mock.fetch_order = MagicMock(side_effect=ccxt.InvalidOrder)
         exchange = get_patched_exchange(mocker, default_conf, api_mock)
         exchange.get_order(order_id='_', pair='TKN/BTC')
     assert api_mock.fetch_order.call_count == API_RETRY_COUNT + 1
 
-    with pytest.raises(OperationalException):
-        api_mock.fetch_order = MagicMock(side_effect=ccxt.BaseError)
-        exchange = get_patched_exchange(mocker, default_conf, 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_name(default_conf, mocker):
@@ -651,19 +651,12 @@ def test_get_trades_for_order(default_conf, mocker):
     assert len(orders) == 1
     assert orders[0]['price'] == 165
 
-    # test Exceptions
-    with pytest.raises(OperationalException):
-        api_mock = MagicMock()
-        api_mock.fetch_my_trades = MagicMock(side_effect=ccxt.BaseError)
-        exchange = get_patched_exchange(mocker, default_conf, api_mock)
-        exchange.get_trades_for_order(order_id, 'LTC/BTC', since)
+    ccxt_exceptionhandlers(mocker, default_conf, api_mock,
+                           'get_trades_for_order', 'fetch_my_trades',
+                           order_id=order_id, pair='LTC/BTC', since=since)
 
-    with pytest.raises(TemporaryError):
-        api_mock = MagicMock()
-        api_mock.fetch_my_trades = MagicMock(side_effect=ccxt.NetworkError)
-        exchange = get_patched_exchange(mocker, default_conf, api_mock)
-        exchange.get_trades_for_order(order_id, 'LTC/BTC', since)
-    assert api_mock.fetch_my_trades.call_count == API_RETRY_COUNT + 1
+    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):
@@ -677,19 +670,8 @@ def test_get_markets(default_conf, mocker, markets):
     assert ret[0]["id"] == "ethbtc"
     assert ret[0]["symbol"] == "ETH/BTC"
 
-    # test Exceptions
-    with pytest.raises(OperationalException):
-        api_mock = MagicMock()
-        api_mock.fetch_markets = MagicMock(side_effect=ccxt.BaseError)
-        exchange = get_patched_exchange(mocker, default_conf, api_mock)
-        exchange.get_markets()
-
-    with pytest.raises(TemporaryError):
-        api_mock = MagicMock()
-        api_mock.fetch_markets = MagicMock(side_effect=ccxt.NetworkError)
-        exchange = get_patched_exchange(mocker, default_conf, api_mock)
-        exchange.get_markets()
-    assert api_mock.fetch_markets.call_count == API_RETRY_COUNT + 1
+    ccxt_exceptionhandlers(mocker, default_conf, api_mock,
+                           'get_markets', 'fetch_markets')
 
 
 def test_get_fee(default_conf, mocker):
@@ -704,19 +686,8 @@ def test_get_fee(default_conf, mocker):
 
     assert exchange.get_fee() == 0.025
 
-    # test Exceptions
-    with pytest.raises(OperationalException):
-        api_mock = MagicMock()
-        api_mock.calculate_fee = MagicMock(side_effect=ccxt.BaseError)
-        exchange = get_patched_exchange(mocker, default_conf, api_mock)
-        exchange.get_fee()
-
-    with pytest.raises(TemporaryError):
-        api_mock = MagicMock()
-        api_mock.calculate_fee = MagicMock(side_effect=ccxt.NetworkError)
-        exchange = get_patched_exchange(mocker, default_conf, api_mock)
-        exchange.get_fee()
-    assert api_mock.calculate_fee.call_count == API_RETRY_COUNT + 1
+    ccxt_exceptionhandlers(mocker, default_conf, api_mock,
+                           'get_fee', 'calculate_fee')
 
 
 def test_get_amount_lots(default_conf, mocker):

freqtrade/tests/optimize/test_backtesting.py

@@ -3,19 +3,20 @@
 import json
 import math
 import random
-import pytest
 from copy import deepcopy
 from typing import List
 from unittest.mock import MagicMock
 
 import numpy as np
 import pandas as pd
+import pytest
 from arrow import Arrow
 
-from freqtrade import optimize, constants, DependencyException
+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.optimize.backtesting import (Backtesting, setup_configuration,
+                                            start)
 from freqtrade.tests.conftest import log_has, patch_exchange
 
 
@@ -627,9 +628,13 @@ def test_backtest_record(default_conf, fee, mocker):
                                            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]})
+                            "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
@@ -640,12 +645,16 @@ def test_backtest_record(default_conf, fee, mocker):
     # ('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

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
 
@@ -40,21 +39,11 @@ 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
@@ -148,155 +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)
-    patch_exchange(mocker)
-
-    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'})
-    patch_exchange(mocker)
-
-    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({'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={})
-    patch_exchange(mocker)
-
-    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()
@@ -304,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()
@@ -315,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()
 
 
@@ -333,12 +183,15 @@ 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.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)
-    mock_fmin = mocker.patch('freqtrade.optimize.hyperopt.fmin', return_value={})
 
     conf = deepcopy(default_conf)
     conf.update({'config': 'config.json.example'})
@@ -347,11 +200,13 @@ def test_start_calls_fmin(mocker, init_hyperopt, default_conf) -> None:
     conf.update({'spaces': 'all'})
 
     hyperopt = Hyperopt(conf)
-    hyperopt.trials = trials
     hyperopt.tickerdata_to_dataframe = MagicMock()
 
     hyperopt.start()
-    mock_fmin.assert_called_once()
+    parallel.assert_called_once()
+
+    assert 'Best result:\nfoo result\nwith values:\n{}' in caplog.text
+    assert dumper.called
 
 
 def test_format_results(init_hyperopt):
@@ -384,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
@@ -422,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:
@@ -437,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)
@@ -503,35 +315,34 @@ def test_generate_optimizer(mocker, init_hyperopt, default_conf) -> None:
         MagicMock(return_value=backtest_result)
     )
     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_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, get_patched_exchange
+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

freqtrade/tests/rpc/test_rpc.py

@@ -13,7 +13,8 @@ from freqtrade.freqtradebot import FreqtradeBot
 from freqtrade.persistence import Trade
 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

freqtrade/tests/rpc/test_rpc_manager.py

@@ -7,7 +7,7 @@ from copy import deepcopy
 from unittest.mock import MagicMock
 
 from freqtrade.rpc.rpc_manager import RPCManager
-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:

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, patch_exchange, 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):

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

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, get_patched_exchange
+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):

freqtrade/tests/test_configuration.py

@@ -4,18 +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_PROD_URL, DEFAULT_DB_DRYRUN_URL
+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:

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

freqtrade/tests/test_freqtradebot.py

@@ -14,11 +14,13 @@ import arrow
 import pytest
 import requests
 
-from freqtrade import constants, DependencyException, OperationalException, TemporaryError
+from freqtrade import (DependencyException, OperationalException,
+                       TemporaryError, constants)
 from freqtrade.freqtradebot import FreqtradeBot
 from freqtrade.persistence import Trade
 from freqtrade.state import State
-from freqtrade.tests.conftest import log_has, patch_coinmarketcap, patch_exchange
+from freqtrade.tests.conftest import (log_has, patch_coinmarketcap,
+                                      patch_exchange)
 
 
 # Functions for recurrent object patching
@@ -348,6 +350,34 @@ def test_get_min_pair_stake_amount(mocker, default_conf) -> None:
     result = freqtrade._get_min_pair_stake_amount('ETH/BTC', 1)
     assert result is None
 
+    # no cost Min
+    mocker.patch(
+        'freqtrade.exchange.Exchange.get_markets',
+        MagicMock(return_value=[{
+            'symbol': 'ETH/BTC',
+            'limits': {
+                'cost': {"min": None},
+                'amount': {}
+            }
+        }])
+    )
+    result = freqtrade._get_min_pair_stake_amount('ETH/BTC', 1)
+    assert result is None
+
+    # no amount Min
+    mocker.patch(
+        'freqtrade.exchange.Exchange.get_markets',
+        MagicMock(return_value=[{
+            'symbol': 'ETH/BTC',
+            'limits': {
+                'cost': {},
+                'amount': {"min": None}
+            }
+        }])
+    )
+    result = freqtrade._get_min_pair_stake_amount('ETH/BTC', 1)
+    assert result is None
+
     # empty 'cost'/'amount' section
     mocker.patch(
         'freqtrade.exchange.Exchange.get_markets',
@@ -1124,7 +1154,7 @@ def test_check_handle_timedout_buy(default_conf, ticker, limit_buy_order_old, fe
     Trade.session.add(trade_buy)
 
     # check it does cancel buy orders over the time limit
-    freqtrade.check_handle_timedout(600)
+    freqtrade.check_handle_timedout()
     assert cancel_order_mock.call_count == 1
     assert rpc_mock.call_count == 1
     trades = Trade.query.filter(Trade.open_order_id.is_(trade_buy.open_order_id)).all()
@@ -1165,7 +1195,7 @@ def test_check_handle_timedout_sell(default_conf, ticker, limit_sell_order_old,
     Trade.session.add(trade_sell)
 
     # check it does cancel sell orders over the time limit
-    freqtrade.check_handle_timedout(600)
+    freqtrade.check_handle_timedout()
     assert cancel_order_mock.call_count == 1
     assert rpc_mock.call_count == 1
     assert trade_sell.is_open is True
@@ -1205,7 +1235,7 @@ def test_check_handle_timedout_partial(default_conf, ticker, limit_buy_order_old
 
     # check it does cancel buy orders over the time limit
     # note this is for a partially-complete buy order
-    freqtrade.check_handle_timedout(600)
+    freqtrade.check_handle_timedout()
     assert cancel_order_mock.call_count == 1
     assert rpc_mock.call_count == 1
     trades = Trade.query.filter(Trade.open_order_id.is_(trade_buy.open_order_id)).all()
@@ -1256,7 +1286,7 @@ def test_check_handle_timedout_exception(default_conf, ticker, mocker, caplog) -
         'recent call last):\n.*'
     )
 
-    freqtrade.check_handle_timedout(600)
+    freqtrade.check_handle_timedout()
     assert filter(regexp.match, caplog.record_tuples)
 
 
@@ -1599,6 +1629,7 @@ def test_sell_profit_only_disable_loss(default_conf, limit_buy_order, fee, marke
         }),
         buy=MagicMock(return_value={'id': limit_buy_order['id']}),
         get_fee=fee,
+        get_markets=markets
     )
 
     conf = deepcopy(default_conf)
@@ -1616,7 +1647,7 @@ def test_sell_profit_only_disable_loss(default_conf, limit_buy_order, fee, marke
     assert freqtrade.handle_trade(trade) is True
 
 
-def test_ignore_roi_if_buy_signal(default_conf, limit_buy_order, fee, mocker) -> None:
+def test_ignore_roi_if_buy_signal(default_conf, limit_buy_order, fee, markets, mocker) -> None:
     """
     Test sell_profit_only feature when enabled and we have a loss
     """
@@ -1634,6 +1665,7 @@ def test_ignore_roi_if_buy_signal(default_conf, limit_buy_order, fee, mocker) ->
         }),
         buy=MagicMock(return_value={'id': limit_buy_order['id']}),
         get_fee=fee,
+        get_markets=markets
     )
 
     conf = deepcopy(default_conf)
@@ -1654,6 +1686,103 @@ def test_ignore_roi_if_buy_signal(default_conf, limit_buy_order, fee, mocker) ->
     assert freqtrade.handle_trade(trade) is True
 
 
+def test_trailing_stop_loss(default_conf, limit_buy_order, fee, caplog, mocker) -> None:
+    """
+    Test sell_profit_only feature when enabled and we have a loss
+    """
+    patch_get_signal(mocker)
+    patch_RPCManager(mocker)
+    patch_coinmarketcap(mocker)
+    mocker.patch('freqtrade.freqtradebot.Analyze.min_roi_reached', return_value=False)
+    mocker.patch.multiple(
+        'freqtrade.exchange.Exchange',
+        validate_pairs=MagicMock(),
+        get_ticker=MagicMock(return_value={
+            'bid': 0.00000102,
+            'ask': 0.00000103,
+            'last': 0.00000102
+        }),
+        buy=MagicMock(return_value={'id': limit_buy_order['id']}),
+        get_fee=fee,
+    )
+
+    conf = deepcopy(default_conf)
+    conf['trailing_stop'] = True
+    print(limit_buy_order)
+    freqtrade = FreqtradeBot(conf)
+    freqtrade.create_trade()
+
+    trade = Trade.query.first()
+    trade.update(limit_buy_order)
+    caplog.set_level(logging.DEBUG)
+    # Sell as trailing-stop is reached
+    assert freqtrade.handle_trade(trade) is True
+    assert log_has(
+        f'HIT STOP: current price at 0.000001, stop loss is {trade.stop_loss:.6f}, '
+        f'initial stop loss was at 0.000010, trade opened at 0.000011', caplog.record_tuples)
+
+
+def test_trailing_stop_loss_positive(default_conf, limit_buy_order, fee, caplog, mocker) -> None:
+    """
+    Test sell_profit_only feature when enabled and we have a loss
+    """
+    buy_price = limit_buy_order['price']
+    patch_get_signal(mocker)
+    patch_RPCManager(mocker)
+    patch_coinmarketcap(mocker)
+    mocker.patch('freqtrade.freqtradebot.Analyze.min_roi_reached', return_value=False)
+    mocker.patch.multiple(
+        'freqtrade.exchange.Exchange',
+        validate_pairs=MagicMock(),
+        get_ticker=MagicMock(return_value={
+            'bid': buy_price - 0.000001,
+            'ask': buy_price - 0.000001,
+            'last': buy_price - 0.000001
+        }),
+        buy=MagicMock(return_value={'id': limit_buy_order['id']}),
+        get_fee=fee,
+    )
+
+    conf = deepcopy(default_conf)
+    conf['trailing_stop'] = True
+    conf['trailing_stop_positive'] = 0.01
+    freqtrade = FreqtradeBot(conf)
+    freqtrade.create_trade()
+
+    trade = Trade.query.first()
+    trade.update(limit_buy_order)
+    caplog.set_level(logging.DEBUG)
+    # stop-loss not reached
+    assert freqtrade.handle_trade(trade) is False
+
+    # Raise ticker above buy price
+    mocker.patch('freqtrade.exchange.Exchange.get_ticker',
+                 MagicMock(return_value={
+                     'bid': buy_price + 0.000003,
+                     'ask': buy_price + 0.000003,
+                     'last': buy_price + 0.000003
+                 }))
+    # stop-loss not reached, adjusted stoploss
+    assert freqtrade.handle_trade(trade) is False
+    assert log_has(f'using positive stop loss mode: 0.01 since we have profit 0.26662643',
+                   caplog.record_tuples)
+    assert log_has(f'adjusted stop loss', caplog.record_tuples)
+    assert trade.stop_loss == 0.0000138501
+
+    mocker.patch('freqtrade.exchange.Exchange.get_ticker',
+                 MagicMock(return_value={
+                     'bid': buy_price + 0.000002,
+                     'ask': buy_price + 0.000002,
+                     'last': buy_price + 0.000002
+                 }))
+    # Lower price again (but still positive)
+    assert freqtrade.handle_trade(trade) is True
+    assert log_has(
+        f'HIT STOP: current price at {buy_price + 0.000002:.6f}, '
+        f'stop loss is {trade.stop_loss:.6f}, '
+        f'initial stop loss was at 0.000010, trade opened at 0.000011', caplog.record_tuples)
+
+
 def test_disable_ignore_roi_if_buy_signal(default_conf, limit_buy_order,
                                           fee, markets, mocker) -> None:
     """

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,7 +11,7 @@ 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, patch_exchange
 

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')
@@ -400,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)
     """
@@ -439,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)
 
@@ -453,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