rip out hyperopt things from strategy, add indicator populating to hyperopt

freqtrade/optimize/hyperopt.py

@@ -3,21 +3,28 @@
 
 import json
 import logging
-import sys
+import os
 import pickle
 import signal
-import os
+import sys
+from functools import reduce
 from math import exp
 from operator import itemgetter
+from typing import Dict, List
 
-from hyperopt import STATUS_FAIL, STATUS_OK, Trials, fmin, space_eval, tpe
+import numpy
+import talib.abstract as ta
+from hyperopt import STATUS_FAIL, STATUS_OK, Trials, fmin, hp, space_eval, tpe
 from hyperopt.mongoexp import MongoTrials
 from pandas import DataFrame
 
-from freqtrade import main, misc  # noqa
+import freqtrade.vendor.qtpylib.indicators as qtpylib
-from freqtrade import exchange, optimize
+# Monkey patch config
+from freqtrade import main  # noqa; noqa
+from freqtrade import exchange, misc, optimize
 from freqtrade.exchange import Bittrex
 from freqtrade.misc import load_config
+from freqtrade.optimize import backtesting
 from freqtrade.optimize.backtesting import backtest
 from freqtrade.strategy.strategy import Strategy
 from user_data.hyperopt_conf import hyperopt_optimize_conf
@@ -51,11 +58,129 @@ OPTIMIZE_CONFIG = hyperopt_optimize_conf()
 TRIALS_FILE = os.path.join('user_data', 'hyperopt_trials.pickle')
 TRIALS = Trials()
 
-# Monkey patch config
-from freqtrade import main  # noqa
 main._CONF = OPTIMIZE_CONFIG
 
 
+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']
+    # 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
+
+
 def save_trials(trials, trials_path=TRIALS_FILE):
     """Save hyperopt trials to file"""
     logger.info('Saving Trials to \'{}\''.format(trials_path))
@@ -100,13 +225,146 @@ def calculate_loss(total_profit: float, trade_count: int, trade_duration: float)
     return trade_loss + profit_loss + duration_loss
 
 
+def hyperopt_space() -> List[Dict]:
+    """
+    Define your Hyperopt space for searching strategy parameters
+    """
+    space = {
+        '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', 5, 25, 1)}
+        ]),
+        'fastd': hp.choice('fastd', [
+            {'enabled': False},
+            {'enabled': True, 'value': hp.quniform('fastd-value', 10, 50, 1)}
+        ]),
+        'adx': hp.choice('adx', [
+            {'enabled': False},
+            {'enabled': True, 'value': hp.quniform('adx-value', 15, 50, 1)}
+        ]),
+        'rsi': hp.choice('rsi', [
+            {'enabled': False},
+            {'enabled': True, 'value': hp.quniform('rsi-value', 20, 40, 1)}
+        ]),
+        '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'},
+        ]),
+        'stoploss': hp.uniform('stoploss', -0.5, -0.02),
+    }
+    return space
+
+
+def buy_strategy_generator(params) -> None:
+    """
+    Define the buy strategy parameters to be used by hyperopt
+    """
+    def populate_buy_trend(dataframe: DataFrame) -> DataFrame:
+        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)
+
+        # 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(
+                dataframe['macd'], dataframe['macdsignal']
+            )),
+            'sar_reversal': (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),
+            'buy'] = 1
+
+        return dataframe
+
+    return populate_buy_trend
+
+
 def optimizer(params):
     global _CURRENT_TRIES
 
-    from freqtrade.optimize import backtesting
+    backtesting.populate_buy_trend = buy_strategy_generator(params)
-
-    strategy = Strategy()
-    backtesting.populate_buy_trend = strategy.buy_strategy_generator(params)
 
     results = backtest({'stake_amount': OPTIMIZE_CONFIG['stake_amount'],
                         'processed': PROCESSED,
@@ -179,6 +437,7 @@ def start(args):
     data = optimize.load_data(args.datadir, pairs=pairs,
                               ticker_interval=args.ticker_interval,
                               timerange=timerange)
+    optimize.populate_indicators = populate_indicators
     PROCESSED = optimize.tickerdata_to_dataframe(data)
 
     if args.mongodb:
@@ -203,7 +462,7 @@ def start(args):
     try:
         best_parameters = fmin(
             fn=optimizer,
-            space=strategy.hyperopt_space(),
+            space=hyperopt_space(),
             algo=tpe.suggest,
             max_evals=TOTAL_TRIES,
             trials=TRIALS
@@ -220,7 +479,7 @@ def start(args):
     # Improve best parameter logging display
     if best_parameters:
         best_parameters = space_eval(
-            strategy.hyperopt_space(),
+            hyperopt_space(),
             best_parameters
         )
 

freqtrade/strategy/default_strategy.py

@@ -2,9 +2,6 @@ import talib.abstract as ta
 import freqtrade.vendor.qtpylib.indicators as qtpylib
 from freqtrade.strategy.interface import IStrategy
 from pandas import DataFrame
-from hyperopt import hp
-from functools import reduce
-from typing import Dict, List
 
 
 class_name = 'DefaultStrategy'
@@ -239,137 +236,3 @@ class DefaultStrategy(IStrategy):
             ),
             'sell'] = 1
         return dataframe
-
-    def hyperopt_space(self) -> List[Dict]:
-        """
-        Define your Hyperopt space for the strategy
-        """
-        space = {
-            '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', 5, 25, 1)}
-            ]),
-            'fastd': hp.choice('fastd', [
-                {'enabled': False},
-                {'enabled': True, 'value': hp.quniform('fastd-value', 10, 50, 1)}
-            ]),
-            'adx': hp.choice('adx', [
-                {'enabled': False},
-                {'enabled': True, 'value': hp.quniform('adx-value', 15, 50, 1)}
-            ]),
-            'rsi': hp.choice('rsi', [
-                {'enabled': False},
-                {'enabled': True, 'value': hp.quniform('rsi-value', 20, 40, 1)}
-            ]),
-            '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'},
-            ]),
-            'stoploss': hp.uniform('stoploss', -0.5, -0.02),
-        }
-        return space
-
-    def buy_strategy_generator(self, params) -> None:
-        """
-        Define the buy strategy parameters to be used by hyperopt
-        """
-        def populate_buy_trend(dataframe: DataFrame) -> DataFrame:
-            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)
-
-            # 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(
-                    dataframe['macd'], dataframe['macdsignal']
-                )),
-                'sar_reversal': (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),
-                'buy'] = 1
-
-            return dataframe
-
-        return populate_buy_trend

freqtrade/strategy/interface.py

@@ -1,6 +1,5 @@
 from abc import ABC, abstractmethod
 from pandas import DataFrame
-from typing import Dict
 
 
 class IStrategy(ABC):
@@ -43,15 +42,3 @@ class IStrategy(ABC):
         :param dataframe: DataFrame
         :return: DataFrame with buy column
         """
-
-    @abstractmethod
-    def hyperopt_space(self) -> Dict:
-        """
-        Define your Hyperopt space for the strategy
-        """
-
-    @abstractmethod
-    def buy_strategy_generator(self, params) -> None:
-        """
-        Define the buy strategy parameters to be used by hyperopt
-        """

freqtrade/strategy/strategy.py

@@ -164,15 +164,3 @@ class Strategy(object):
         :return: DataFrame with buy column
         """
         return self.custom_strategy.populate_sell_trend(dataframe)
-
-    def hyperopt_space(self) -> Dict:
-        """
-        Define your Hyperopt space for the strategy
-        """
-        return self.custom_strategy.hyperopt_space()
-
-    def buy_strategy_generator(self, params) -> None:
-        """
-        Define the buy strategy parameters to be used by hyperopt
-        """
-        return self.custom_strategy.buy_strategy_generator(params)

freqtrade/tests/strategy/test_default_strategy.py

@@ -22,8 +22,6 @@ def test_default_strategy_structure():
     assert hasattr(DefaultStrategy, 'populate_indicators')
     assert hasattr(DefaultStrategy, 'populate_buy_trend')
     assert hasattr(DefaultStrategy, 'populate_sell_trend')
-    assert hasattr(DefaultStrategy, 'hyperopt_space')
-    assert hasattr(DefaultStrategy, 'buy_strategy_generator')
 
 
 def test_default_strategy(result):
@@ -36,5 +34,3 @@ def test_default_strategy(result):
     assert type(indicators) is DataFrame
     assert type(strategy.populate_buy_trend(indicators)) is DataFrame
     assert type(strategy.populate_sell_trend(indicators)) is DataFrame
-    assert type(strategy.hyperopt_space()) is dict
-    assert callable(strategy.buy_strategy_generator({}))

freqtrade/tests/strategy/test_strategy.py

@@ -33,8 +33,6 @@ def test_strategy_structure():
     assert hasattr(Strategy, 'populate_indicators')
     assert hasattr(Strategy, 'populate_buy_trend')
     assert hasattr(Strategy, 'populate_sell_trend')
-    assert hasattr(Strategy, 'hyperopt_space')
-    assert hasattr(Strategy, 'buy_strategy_generator')
 
 
 def test_load_strategy(result):
@@ -71,12 +69,6 @@ def test_strategy(result):
     dataframe = strategy.populate_sell_trend(strategy.populate_indicators(result))
     assert 'sell' in dataframe.columns
 
-    assert hasattr(strategy.custom_strategy, 'hyperopt_space')
-    assert 'adx' in strategy.hyperopt_space()
-
-    assert hasattr(strategy.custom_strategy, 'buy_strategy_generator')
-    assert callable(strategy.buy_strategy_generator({}))
-
 
 def test_strategy_override_minimal_roi(caplog):
     config = {