Fix some tests and rebase issues

freqtrade/optimize/__init__.py

@@ -20,6 +20,7 @@ from pandas import DataFrame
 from freqtrade import misc, constants, OperationalException
 from freqtrade.exchange import Exchange
 from freqtrade.arguments import TimeRange
+from freqtrade.optimize.default_hyperopt import DefaultHyperOpts  # noqa: F401
 
 logger = logging.getLogger(__name__)
 

freqtrade/optimize/default_hyperopt.py

@@ -2,11 +2,11 @@
 
 import talib.abstract as ta
 from pandas import DataFrame
-from typing import Dict, Any, Callable
+from typing import Dict, Any, Callable, List
 from functools import reduce
 
 import numpy
-from hyperopt import hp
+from skopt.space import Categorical, Dimension, Integer, Real
 
 import freqtrade.vendor.qtpylib.indicators as qtpylib
 from freqtrade.optimize.interface import IHyperOpt
@@ -21,193 +21,52 @@ class DefaultHyperOpts(IHyperOpt):
     """
 
     @staticmethod
-    def populate_indicators(dataframe: DataFrame) -> DataFrame:
+    def populate_indicators(dataframe: DataFrame, metadata: dict) -> 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']
+        dataframe['minus_di'] = ta.MINUS_DI(dataframe)
-        # Stoch RSI
-        stoch_rsi = ta.STOCHRSI(dataframe)
-        dataframe['fastd_rsi'] = stoch_rsi['fastd']
-        dataframe['fastk_rsi'] = stoch_rsi['fastk']
         # 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
 
-    @staticmethod
+    def buy_strategy_generator(self, params: Dict[str, Any]) -> Callable:
-    def buy_strategy_generator(params: Dict[str, Any]) -> Callable:
         """
         Define the buy strategy parameters to be used by hyperopt
         """
-        def populate_buy_trend(dataframe: DataFrame) -> DataFrame:
+        def populate_buy_trend(dataframe: DataFrame, metadata: dict) -> DataFrame:
             """
             Buy strategy Hyperopt will build and use
             """
             conditions = []
             # GUARDS AND TRENDS
-            if 'uptrend_long_ema' in params and params['uptrend_long_ema']['enabled']:
+            if 'mfi-enabled' in params and params['mfi-enabled']:
-                conditions.append(dataframe['ema50'] > dataframe['ema100'])
+                conditions.append(dataframe['mfi'] < params['mfi-value'])
-            if 'macd_below_zero' in params and params['macd_below_zero']['enabled']:
+            if 'fastd-enabled' in params and params['fastd-enabled']:
-                conditions.append(dataframe['macd'] < 0)
+                conditions.append(dataframe['fastd'] < params['fastd-value'])
-            if 'uptrend_short_ema' in params and params['uptrend_short_ema']['enabled']:
+            if 'adx-enabled' in params and params['adx-enabled']:
-                conditions.append(dataframe['ema5'] > dataframe['ema10'])
+                conditions.append(dataframe['adx'] > params['adx-value'])
-            if 'mfi' in params and params['mfi']['enabled']:
+            if 'rsi-enabled' in params and params['rsi-enabled']:
-                conditions.append(dataframe['mfi'] < params['mfi']['value'])
+                conditions.append(dataframe['rsi'] < params['rsi-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)
 
             # TRIGGERS
-            triggers = {
+            if params['trigger'] == 'bb_lower':
-                'lower_bb': (
+                conditions.append(dataframe['close'] < dataframe['bb_lowerband'])
-                    dataframe['close'] < dataframe['bb_lowerband']
+            if params['trigger'] == 'macd_cross_signal':
-                ),
+                conditions.append(qtpylib.crossed_above(
-                '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(
                     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),
@@ -218,64 +77,21 @@ class DefaultHyperOpts(IHyperOpt):
         return populate_buy_trend
 
     @staticmethod
-    def indicator_space() -> Dict[str, Any]:
+    def indicator_space() -> List[Dimension]:
         """
         Define your Hyperopt space for searching strategy parameters
         """
-        return {
+        return [
-            'macd_below_zero': hp.choice('macd_below_zero', [
+            Integer(10, 25, name='mfi-value'),
-                {'enabled': False},
+            Integer(15, 45, name='fastd-value'),
-                {'enabled': True}
+            Integer(20, 50, name='adx-value'),
-            ]),
+            Integer(20, 40, name='rsi-value'),
-            'mfi': hp.choice('mfi', [
+            Categorical([True, False], name='mfi-enabled'),
-                {'enabled': False},
+            Categorical([True, False], name='fastd-enabled'),
-                {'enabled': True, 'value': hp.quniform('mfi-value', 10, 25, 5)}
+            Categorical([True, False], name='adx-enabled'),
-            ]),
+            Categorical([True, False], name='rsi-enabled'),
-            'fastd': hp.choice('fastd', [
+            Categorical(['bb_lower', 'macd_cross_signal', 'sar_reversal'], name='trigger')
-                {'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'},
-            ]),
-        }
 
     @staticmethod
     def generate_roi_table(params: Dict) -> Dict[int, float]:
@@ -291,24 +107,24 @@ class DefaultHyperOpts(IHyperOpt):
         return roi_table
 
     @staticmethod
-    def stoploss_space() -> Dict[str, Any]:
+    def stoploss_space() -> List[Dimension]:
         """
         Stoploss Value to search
         """
-        return {
+        return [
-            'stoploss': hp.quniform('stoploss', -0.5, -0.02, 0.02),
+            Real(-0.5, -0.02, name='stoploss'),
-        }
+        ]
 
     @staticmethod
-    def roi_space() -> Dict[str, Any]:
+    def roi_space() -> List[Dimension]:
         """
         Values to search for each ROI steps
         """
-        return {
+        return [
-            'roi_t1': hp.quniform('roi_t1', 10, 120, 20),
+            Integer(10, 120, name='roi_t1'),
-            'roi_t2': hp.quniform('roi_t2', 10, 60, 15),
+            Integer(10, 60, name='roi_t2'),
-            'roi_t3': hp.quniform('roi_t3', 10, 40, 10),
+            Integer(10, 40, name='roi_t3'),
-            'roi_p1': hp.quniform('roi_p1', 0.01, 0.04, 0.01),
+            Real(0.01, 0.04, name='roi_p1'),
-            'roi_p2': hp.quniform('roi_p2', 0.01, 0.07, 0.01),
+            Real(0.01, 0.07, name='roi_p2'),
-            'roi_p3': hp.quniform('roi_p3', 0.01, 0.20, 0.01),
+            Real(0.01, 0.20, name='roi_p3'),
-        }
+        ]

freqtrade/optimize/hyperopt.py

@@ -105,7 +105,7 @@ class Hyperopt(Backtesting):
             best_result['params']
         )
         if 'roi_t1' in best_result['params']:
-            logger.info('ROI table:\n%s', self.generate_roi_table(best_result['params']))
+            logger.info('ROI table:\n%s', self.custom_hyperopt.generate_roi_table(best_result['params']))
 
     def log_results(self, results) -> None:
         """
@@ -147,19 +147,20 @@ class Hyperopt(Backtesting):
         """
         spaces: List[Dimension] = []
         if self.has_space('buy'):
-            spaces = {**spaces, **self.custom_hyperopt.indicator_space()}
+            spaces += self.custom_hyperopt.indicator_space()
         if self.has_space('roi'):
-            spaces = {**spaces, **self.custom_hyperopt.roi_space()}
+            spaces += self.custom_hyperopt.roi_space()
         if self.has_space('stoploss'):
-            spaces = {**spaces, **self.custom_hyperopt.stoploss_space()}
+            spaces += self.custom_hyperopt.stoploss_space()
         return spaces
 
-    def generate_optimizer(self, params: Dict) -> Dict:
+    def generate_optimizer(self, _params: Dict) -> Dict:
+        params = self.get_args(_params)
         if self.has_space('roi'):
-            self.analyze.strategy.minimal_roi = self.custom_hyperopt.generate_roi_table(params)
+            self.strategy.minimal_roi = self.custom_hyperopt.generate_roi_table(params)
 
         if self.has_space('buy'):
-            self.populate_buy_trend = self.custom_hyperopt.buy_strategy_generator(params)
+            self.advise_buy = self.custom_hyperopt.buy_strategy_generator(params)
 
         if self.has_space('stoploss'):
             self.strategy.stoploss = params['stoploss']

user_data/hyperopts/sample_hyperopt.py

@@ -0,0 +1,138 @@
+# pragma pylint: disable=missing-docstring, invalid-name, pointless-string-statement
+
+import talib.abstract as ta
+from pandas import DataFrame
+from typing import Dict, Any, Callable, List
+from functools import reduce
+
+import numpy
+from skopt.space import Categorical, Dimension, Integer, Real
+
+import freqtrade.vendor.qtpylib.indicators as qtpylib
+from freqtrade.optimize.interface import IHyperOpt
+
+class_name = 'SampleHyperOpts'
+
+
+# This class is a sample. Feel free to customize it.
+class SampleHyperOpts(IHyperOpt):
+    """
+    This is a test hyperopt to inspire you.
+    More information in https://github.com/freqtrade/freqtrade/blob/develop/docs/hyperopt.md
+     You can:
+    - Rename the class name (Do not forget to update class_name)
+    - Add any methods you want to build your hyperopt
+    - Add any lib you need to build your hyperopt
+     You must keep:
+    - the prototype for the methods: populate_indicators, indicator_space, buy_strategy_generator,
+    roi_space, generate_roi_table, stoploss_space
+    """
+
+    @staticmethod
+    def populate_indicators(dataframe: DataFrame, metadata: dict) -> DataFrame:
+        dataframe['adx'] = ta.ADX(dataframe)
+        macd = ta.MACD(dataframe)
+        dataframe['macd'] = macd['macd']
+        dataframe['macdsignal'] = macd['macdsignal']
+        dataframe['mfi'] = ta.MFI(dataframe)
+        dataframe['rsi'] = ta.RSI(dataframe)
+        stoch_fast = ta.STOCHF(dataframe)
+        dataframe['fastd'] = stoch_fast['fastd']
+        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['sar'] = ta.SAR(dataframe)
+        return dataframe
+
+    def buy_strategy_generator(self, params: Dict[str, Any]) -> Callable:
+        """
+        Define the buy strategy parameters to be used by hyperopt
+        """
+        def populate_buy_trend(dataframe: DataFrame, metadata: dict) -> DataFrame:
+            """
+            Buy strategy Hyperopt will build and use
+            """
+            conditions = []
+            # GUARDS AND TRENDS
+            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
+            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']
+                ))
+            if params['trigger'] == 'sar_reversal':
+                conditions.append(qtpylib.crossed_above(
+                    dataframe['close'], dataframe['sar']
+                ))
+
+            dataframe.loc[
+                reduce(lambda x, y: x & y, conditions),
+                'buy'] = 1
+
+            return dataframe
+
+        return populate_buy_trend
+
+    @staticmethod
+    def indicator_space() -> List[Dimension]:
+        """
+        Define your Hyperopt space for searching strategy parameters
+        """
+        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')
+        ]
+
+    @staticmethod
+    def generate_roi_table(params: Dict) -> Dict[int, float]:
+        """
+        Generate the ROI table that will be used by Hyperopt
+        """
+        roi_table = {}
+        roi_table[0] = params['roi_p1'] + params['roi_p2'] + params['roi_p3']
+        roi_table[params['roi_t3']] = params['roi_p1'] + params['roi_p2']
+        roi_table[params['roi_t3'] + params['roi_t2']] = params['roi_p1']
+        roi_table[params['roi_t3'] + params['roi_t2'] + params['roi_t1']] = 0
+
+        return roi_table
+
+    @staticmethod
+    def stoploss_space() -> List[Dimension]:
+        """
+        Stoploss Value to search
+        """
+        return [
+            Real(-0.5, -0.02, name='stoploss'),
+        ]
+
+    @staticmethod
+    def roi_space() -> List[Dimension]:
+        """
+        Values to search for each ROI steps
+        """
+        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'),
+        ]

user_data/hyperopts/test_hyperopt.py

@@ -1,279 +0,0 @@
-# pragma pylint: disable=missing-docstring, invalid-name, pointless-string-statement
-
-import talib.abstract as ta
-from pandas import DataFrame
-from typing import Dict, Any, Callable
-from functools import reduce
-from math import exp
-
-import numpy
-import talib.abstract as ta
-from hyperopt import STATUS_FAIL, STATUS_OK, Trials, fmin, hp, space_eval, tpe
-
-import freqtrade.vendor.qtpylib.indicators as qtpylib
-from freqtrade.indicator_helpers import fishers_inverse
-from freqtrade.optimize.interface import IHyperOpt
-
-
-# This class is a sample. Feel free to customize it.
-class TestHyperOpt(IHyperOpt):
-    """
-    This is a test hyperopt to inspire you.
-    More information in https://github.com/gcarq/freqtrade/blob/develop/docs/hyperopt.md
-
-    You can:
-    - Rename the class name (Do not forget to update class_name)
-    - Add any methods you want to build your hyperopt
-    - Add any lib you need to build your hyperopt
-
-    You must keep:
-    - the prototype for the methods: populate_indicators, indicator_space, buy_strategy_generator,
-    roi_space, generate_roi_table, stoploss_space
-    """
-
-    @staticmethod
-    def populate_indicators(dataframe: DataFrame) -> DataFrame:
-        """
-        Adds several different TA indicators to the given DataFrame
-
-        Performance Note: For the best performance be frugal on the number of indicators
-        you are using. Let uncomment only the indicator you are using in your strategies
-        or your hyperopt configuration, otherwise you will waste your memory and CPU usage.
-        """
-
-        # Momentum Indicator
-        # ------------------------------------
-
-        # ADX
-        dataframe['adx'] = ta.ADX(dataframe)
-
-        """
-        # Awesome oscillator
-        dataframe['ao'] = qtpylib.awesome_oscillator(dataframe)
-
-        # Commodity Channel Index: values Oversold:<-100, Overbought:>100
-        dataframe['cci'] = ta.CCI(dataframe)
-
-        # MACD
-        macd = ta.MACD(dataframe)
-        dataframe['macd'] = macd['macd']
-        dataframe['macdsignal'] = macd['macdsignal']
-        dataframe['macdhist'] = macd['macdhist']
-
-        # MFI
-        dataframe['mfi'] = ta.MFI(dataframe)
-
-        # Minus Directional Indicator / Movement
-        dataframe['minus_dm'] = ta.MINUS_DM(dataframe)
-        dataframe['minus_di'] = ta.MINUS_DI(dataframe)
-
-        # Plus Directional Indicator / Movement
-        dataframe['plus_dm'] = ta.PLUS_DM(dataframe)
-        dataframe['plus_di'] = ta.PLUS_DI(dataframe)
-        dataframe['minus_di'] = ta.MINUS_DI(dataframe)
-
-        # ROC
-        dataframe['roc'] = ta.ROC(dataframe)
-
-        # RSI
-        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']
-        """
-
-        # Overlap Studies
-        # ------------------------------------
-
-        # 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 Parabol
-        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)
-
-        # Cycle Indicator
-        # ------------------------------------
-        # 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
-
-    @staticmethod
-    def indicator_space() -> Dict[str, Any]:
-        """
-        Define your Hyperopt space for searching strategy parameters
-        """
-        return {
-            'adx': hp.choice('adx', [
-                {'enabled': False},
-                {'enabled': True, 'value': hp.quniform('adx-value', 50, 80, 5)}
-            ]),
-            'uptrend_tema': hp.choice('uptrend_tema', [
-                {'enabled': False},
-                {'enabled': True}
-            ]),
-            'trigger': hp.choice('trigger', [
-                {'type': 'middle_bb_tema'},
-            ]),
-        }
-    
-    @staticmethod
-    def buy_strategy_generator(params: Dict[str, Any]) -> Callable:
-        """
-        Define the buy strategy parameters to be used by hyperopt
-        """
-        def populate_buy_trend(dataframe: DataFrame) -> DataFrame:
-            conditions = []
-            # GUARDS AND TRENDS
-            if 'adx' in params and params['adx']['enabled']:
-                conditions.append(dataframe['adx'] > params['adx']['value'])
-            if 'uptrend_tema' in params and params['uptrend_tema']['enabled']:
-                prevtema = dataframe['tema'].shift(1)
-                conditions.append(dataframe['tema'] > prevtema)
-
-            # TRIGGERS
-            triggers = {
-                'middle_bb_tema': (
-                    dataframe['tema'] > dataframe['bb_middleband']
-                ),
-            }
-            conditions.append(triggers.get(params['trigger']['type']))
-
-            dataframe.loc[
-                reduce(lambda x, y: x & y, conditions),
-                'buy'] = 1
-
-            return dataframe
-
-        return populate_buy_trend
-        
-    @staticmethod
-    def roi_space() -> Dict[str, Any]:
-        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),
-        }
-
-    @staticmethod
-    def generate_roi_table(params: Dict) -> Dict[int, float]:
-        """
-        Generate the ROI table that will be used by Hyperopt
-        """
-        roi_table = {}
-        roi_table[0] = params['roi_p1'] + params['roi_p2'] + params['roi_p3']
-        roi_table[params['roi_t3']] = params['roi_p1'] + params['roi_p2']
-        roi_table[params['roi_t3'] + params['roi_t2']] = params['roi_p1']
-        roi_table[params['roi_t3'] + params['roi_t2'] + params['roi_t1']] = 0
-
-        return roi_table
-
-    @staticmethod
-    def stoploss_space() -> Dict[str, Any]:
-        return {
-            'stoploss': hp.quniform('stoploss', -0.5, -0.02, 0.02),
-        }