From 0a205f52b06ad9b12aa13d03794e9e3dfd780440 Mon Sep 17 00:00:00 2001
From: Rokas Kupstys <rokups@zoho.com>
Date: Tue, 23 Mar 2021 10:02:32 +0200
Subject: [PATCH 01/32] Optional support for defining hyperopt parameters in a
 strategy file and reusing common hyperopt/strategy parts.

---
 freqtrade/optimize/hyperopt.py      |  8 ++-
 freqtrade/optimize/hyperopt_auto.py | 83 +++++++++++++++++++++++++
 freqtrade/strategy/__init__.py      |  1 +
 freqtrade/strategy/hyper.py         | 93 +++++++++++++++++++++++++++++
 4 files changed, 183 insertions(+), 2 deletions(-)
 create mode 100644 freqtrade/optimize/hyperopt_auto.py
 create mode 100644 freqtrade/strategy/hyper.py

diff --git a/freqtrade/optimize/hyperopt.py b/freqtrade/optimize/hyperopt.py
index 03f34a511..8dd8f01ac 100644
--- a/freqtrade/optimize/hyperopt.py
+++ b/freqtrade/optimize/hyperopt.py
@@ -26,6 +26,7 @@ from freqtrade.data.history import get_timerange
 from freqtrade.misc import file_dump_json, plural
 from freqtrade.optimize.backtesting import Backtesting
 # Import IHyperOpt and IHyperOptLoss to allow unpickling classes from these modules
+from freqtrade.optimize.hyperopt_auto import HyperOptAuto
 from freqtrade.optimize.hyperopt_interface import IHyperOpt  # noqa: F401
 from freqtrade.optimize.hyperopt_loss_interface import IHyperOptLoss  # noqa: F401
 from freqtrade.optimize.hyperopt_tools import HyperoptTools
@@ -67,8 +68,11 @@ class Hyperopt:
 
         self.backtesting = Backtesting(self.config)
 
-        self.custom_hyperopt = HyperOptResolver.load_hyperopt(self.config)
-        self.custom_hyperopt.__class__.strategy = self.backtesting.strategy
+        if self.config['hyperopt'] == 'HyperOptAuto':
+            self.custom_hyperopt = HyperOptAuto(self.config)
+        else:
+            self.custom_hyperopt = HyperOptResolver.load_hyperopt(self.config)
+        self.custom_hyperopt.strategy = self.backtesting.strategy
 
         self.custom_hyperoptloss = HyperOptLossResolver.load_hyperoptloss(self.config)
         self.calculate_loss = self.custom_hyperoptloss.hyperopt_loss_function
diff --git a/freqtrade/optimize/hyperopt_auto.py b/freqtrade/optimize/hyperopt_auto.py
new file mode 100644
index 000000000..788bd5a79
--- /dev/null
+++ b/freqtrade/optimize/hyperopt_auto.py
@@ -0,0 +1,83 @@
+"""
+HyperOptAuto class.
+This module implements a convenience auto-hyperopt class, which can be used together with strategies that implement
+IHyperStrategy interface.
+"""
+from typing import Any, Callable, Dict, List
+from pandas import DataFrame
+from skopt.space import Categorical, Dimension, Integer, Real  # noqa
+
+from freqtrade.optimize.hyperopt_interface import IHyperOpt
+
+
+# noinspection PyUnresolvedReferences
+class HyperOptAuto(IHyperOpt):
+    """
+    This class delegates functionality to Strategy(IHyperStrategy) and Strategy.HyperOpt classes. Most of the time
+    Strategy.HyperOpt class would only implement indicator_space and sell_indicator_space methods, but other hyperopt
+    methods can be overridden as well.
+    """
+    def buy_strategy_generator(self, params: Dict[str, Any]) -> Callable:
+        assert hasattr(self.strategy, 'enumerate_parameters'), 'Strategy must inherit from IHyperStrategy.'
+
+        def populate_buy_trend(dataframe: DataFrame, metadata: dict):
+            for attr_name, attr in self.strategy.enumerate_parameters('buy'):
+                attr.value = params[attr_name]
+            return self.strategy.populate_buy_trend(dataframe, metadata)
+        return populate_buy_trend
+
+    def sell_strategy_generator(self, params: Dict[str, Any]) -> Callable:
+        assert hasattr(self.strategy, 'enumerate_parameters'), 'Strategy must inherit from IHyperStrategy.'
+
+        def populate_buy_trend(dataframe: DataFrame, metadata: dict):
+            for attr_name, attr in self.strategy.enumerate_parameters('sell'):
+                attr.value = params[attr_name]
+            return self.strategy.populate_sell_trend(dataframe, metadata)
+        return populate_buy_trend
+
+    def _get_func(self, name) -> Callable:
+        """
+        Return a function defined in Strategy.HyperOpt class, or one defined in super() class.
+        :param name: function name.
+        :return: a requested function.
+        """
+        hyperopt_cls = getattr(self.strategy, 'HyperOpt')
+        default_func = getattr(super(), name)
+        if hyperopt_cls:
+            return getattr(hyperopt_cls, name, default_func)
+        else:
+            return default_func
+
+    def _generate_indicator_space(self, category):
+        assert hasattr(self.strategy, 'enumerate_parameters'), 'Strategy must inherit from IHyperStrategy.'
+
+        for attr_name, attr in self.strategy.enumerate_parameters(category):
+            yield attr.get_space(attr_name)
+
+    def _get_indicator_space(self, category, fallback_method_name):
+        indicator_space = list(self._generate_indicator_space(category))
+        if len(indicator_space) > 0:
+            return indicator_space
+        else:
+            return self._get_func(fallback_method_name)()
+
+    def indicator_space(self) -> List[Dimension]:
+        return self._get_indicator_space('buy', 'indicator_space')
+
+    def sell_indicator_space(self) -> List[Dimension]:
+        return self._get_indicator_space('sell', 'sell_indicator_space')
+
+    def generate_roi_table(self, params: Dict) -> Dict[int, float]:
+        return self._get_func('generate_roi_table')(params)
+
+    def roi_space(self) -> List[Dimension]:
+        return self._get_func('roi_space')()
+
+    def stoploss_space(self) -> List[Dimension]:
+        return self._get_func('stoploss_space')()
+
+    def generate_trailing_params(self, params: Dict) -> Dict:
+        return self._get_func('generate_trailing_params')(params)
+
+    def trailing_space(self) -> List[Dimension]:
+        return self._get_func('trailing_space')()
diff --git a/freqtrade/strategy/__init__.py b/freqtrade/strategy/__init__.py
index 85148b6ea..80a7c00de 100644
--- a/freqtrade/strategy/__init__.py
+++ b/freqtrade/strategy/__init__.py
@@ -2,4 +2,5 @@
 from freqtrade.exchange import (timeframe_to_minutes, timeframe_to_msecs, timeframe_to_next_date,
                                 timeframe_to_prev_date, timeframe_to_seconds)
 from freqtrade.strategy.interface import IStrategy
+from freqtrade.strategy.hyper import IHyperStrategy, Parameter
 from freqtrade.strategy.strategy_helper import merge_informative_pair, stoploss_from_open
diff --git a/freqtrade/strategy/hyper.py b/freqtrade/strategy/hyper.py
new file mode 100644
index 000000000..41bb836d4
--- /dev/null
+++ b/freqtrade/strategy/hyper.py
@@ -0,0 +1,93 @@
+"""
+IHyperStrategy interface, hyperoptable Parameter class.
+This module defines a base class for auto-hyperoptable strategies.
+"""
+from abc import ABC
+from typing import Union, List, Iterator, Tuple
+
+from skopt.space import Integer, Real, Categorical
+
+from freqtrade.strategy.interface import IStrategy
+
+
+class Parameter(object):
+    """
+    Defines a parameter that can be optimized by hyperopt.
+    """
+    default: Union[int, float, str, bool]
+    space: List[Union[int, float, str, bool]]
+    category: str
+
+    def __init__(self, *, space: List[Union[int, float, str, bool]], default: Union[int, float, str, bool] = None,
+                 category: str = None, **kwargs):
+        """
+        Initialize hyperopt-optimizable parameter.
+        :param space: Optimization space. [min, max] for ints and floats or a list of strings for categorial parameters.
+        :param default: A default value. Required for ints and floats, optional for categorial parameters (first item
+         from the space will be used). Type of default value determines skopt space used for optimization.
+        :param category: A parameter category. Can be 'buy' or 'sell'. This parameter is optional if parameter field
+         name is prefixed with 'buy_' or 'sell_'.
+        :param kwargs: Extra parameters to skopt.space.(Integer|Real|Categorical).
+        """
+        assert 'name' not in kwargs, 'Name is determined by parameter field name and can not be specified manually.'
+        self.value = default
+        self.space = space
+        self.category = category
+        self._space_params = kwargs
+        if default is None:
+            assert len(space) > 0
+            self.value = space[0]
+
+    def get_space(self, name: str) -> Union[Integer, Real, Categorical, None]:
+        """
+        Create skopt optimization space.
+        :param name: A name of parameter field.
+        :return: skopt space of this parameter, or None if parameter is not optimizable (i.e. space is set to None)
+        """
+        if not self.space:
+            return None
+        if isinstance(self.value, int):
+            assert len(self.space) == 2
+            return Integer(*self.space, name=name, **self._space_params)
+        if isinstance(self.value, float):
+            assert len(self.space) == 2
+            return Real(*self.space, name=name, **self._space_params)
+
+        assert len(self.space) > 0
+        return Categorical(self.space, name=name, **self._space_params)
+
+
+class IHyperStrategy(IStrategy, ABC):
+    """
+    A helper base class which allows HyperOptAuto class to reuse implementations of of buy/sell strategy logic.
+    """
+
+    def __init__(self, config):
+        super().__init__(config)
+        self._load_params(getattr(self, 'buy_params', None))
+        self._load_params(getattr(self, 'sell_params', None))
+
+    def enumerate_parameters(self, category: str = None) -> Iterator[Tuple[str, Parameter]]:
+        """
+        Find all optimizeable parameters and return (name, attr) iterator.
+        :param category:
+        :return:
+        """
+        assert category in ('buy', 'sell', None)
+        for attr_name in dir(self):
+            if not attr_name.startswith('__'):  # Ignore internals, not strictly necessary.
+                attr = getattr(self, attr_name)
+                if isinstance(attr, Parameter):
+                    if category is None or category == attr.category or attr_name.startswith(category + '_'):
+                        yield attr_name, attr
+
+    def _load_params(self, params: dict) -> None:
+        """
+        Set optimizeable parameter values.
+        :param params: Dictionary with new parameter values.
+        """
+        if not params:
+            return
+        for attr_name, attr in self.enumerate_parameters():
+            if attr_name in params:
+                attr.value = params[attr_name]

From bb89e44e19825dc9b9c1bca393ced8a646800cf5 Mon Sep 17 00:00:00 2001
From: Rokas Kupstys <rokups@zoho.com>
Date: Wed, 24 Mar 2021 10:32:34 +0200
Subject: [PATCH 02/32] [SQUASH] Address PR comments.

* Split Parameter into IntParameter/FloatParameter/CategoricalParameter.
* Rename IHyperStrategy to HyperStrategyMixin and use it as mixin.
* --hyperopt parameter is now optional if strategy uses HyperStrategyMixin.
* Use OperationalException() instead of asserts.
---
 freqtrade/commands/cli_options.py        |   1 +
 freqtrade/optimize/hyperopt.py           |   7 +-
 freqtrade/optimize/hyperopt_auto.py      |  22 ++--
 freqtrade/optimize/hyperopt_interface.py |   7 +-
 freqtrade/strategy/__init__.py           |   3 +-
 freqtrade/strategy/hyper.py              | 149 +++++++++++++++++------
 6 files changed, 138 insertions(+), 51 deletions(-)

diff --git a/freqtrade/commands/cli_options.py b/freqtrade/commands/cli_options.py
index 15c13cec9..8e9f0c994 100644
--- a/freqtrade/commands/cli_options.py
+++ b/freqtrade/commands/cli_options.py
@@ -195,6 +195,7 @@ AVAILABLE_CLI_OPTIONS = {
         '--hyperopt',
         help='Specify hyperopt class name which will be used by the bot.',
         metavar='NAME',
+        required=False,
     ),
     "hyperopt_path": Arg(
         '--hyperopt-path',
diff --git a/freqtrade/optimize/hyperopt.py b/freqtrade/optimize/hyperopt.py
index 8dd8f01ac..b5ee1da1a 100644
--- a/freqtrade/optimize/hyperopt.py
+++ b/freqtrade/optimize/hyperopt.py
@@ -23,6 +23,7 @@ from pandas import DataFrame
 from freqtrade.constants import DATETIME_PRINT_FORMAT, LAST_BT_RESULT_FN
 from freqtrade.data.converter import trim_dataframe
 from freqtrade.data.history import get_timerange
+from freqtrade.exceptions import OperationalException
 from freqtrade.misc import file_dump_json, plural
 from freqtrade.optimize.backtesting import Backtesting
 # Import IHyperOpt and IHyperOptLoss to allow unpickling classes from these modules
@@ -68,7 +69,11 @@ class Hyperopt:
 
         self.backtesting = Backtesting(self.config)
 
-        if self.config['hyperopt'] == 'HyperOptAuto':
+        if not self.config.get('hyperopt'):
+            if not getattr(self.backtesting.strategy, 'HYPER_STRATEGY', False):
+                raise OperationalException('Strategy is not auto-hyperoptable. Specify --hyperopt '
+                                           'parameter or add HyperStrategyMixin mixin to your '
+                                           'strategy class.')
             self.custom_hyperopt = HyperOptAuto(self.config)
         else:
             self.custom_hyperopt = HyperOptResolver.load_hyperopt(self.config)
diff --git a/freqtrade/optimize/hyperopt_auto.py b/freqtrade/optimize/hyperopt_auto.py
index 788bd5a79..fdc4da14c 100644
--- a/freqtrade/optimize/hyperopt_auto.py
+++ b/freqtrade/optimize/hyperopt_auto.py
@@ -1,7 +1,7 @@
 """
 HyperOptAuto class.
-This module implements a convenience auto-hyperopt class, which can be used together with strategies that implement
-IHyperStrategy interface.
+This module implements a convenience auto-hyperopt class, which can be used together with strategies
+ that implement IHyperStrategy interface.
 """
 from typing import Any, Callable, Dict, List
 from pandas import DataFrame
@@ -13,26 +13,31 @@ from freqtrade.optimize.hyperopt_interface import IHyperOpt
 # noinspection PyUnresolvedReferences
 class HyperOptAuto(IHyperOpt):
     """
-    This class delegates functionality to Strategy(IHyperStrategy) and Strategy.HyperOpt classes. Most of the time
-    Strategy.HyperOpt class would only implement indicator_space and sell_indicator_space methods, but other hyperopt
-    methods can be overridden as well.
+    This class delegates functionality to Strategy(IHyperStrategy) and Strategy.HyperOpt classes.
+     Most of the time Strategy.HyperOpt class would only implement indicator_space and
+     sell_indicator_space methods, but other hyperopt methods can be overridden as well.
     """
+
     def buy_strategy_generator(self, params: Dict[str, Any]) -> Callable:
-        assert hasattr(self.strategy, 'enumerate_parameters'), 'Strategy must inherit from IHyperStrategy.'
+        if not getattr(self.strategy, 'HYPER_STRATEGY', False):
+            raise OperationalException('Strategy must inherit from IHyperStrategy.')
 
         def populate_buy_trend(dataframe: DataFrame, metadata: dict):
             for attr_name, attr in self.strategy.enumerate_parameters('buy'):
                 attr.value = params[attr_name]
             return self.strategy.populate_buy_trend(dataframe, metadata)
+
         return populate_buy_trend
 
     def sell_strategy_generator(self, params: Dict[str, Any]) -> Callable:
-        assert hasattr(self.strategy, 'enumerate_parameters'), 'Strategy must inherit from IHyperStrategy.'
+        if not getattr(self.strategy, 'HYPER_STRATEGY', False):
+            raise OperationalException('Strategy must inherit from IHyperStrategy.')
 
         def populate_buy_trend(dataframe: DataFrame, metadata: dict):
             for attr_name, attr in self.strategy.enumerate_parameters('sell'):
                 attr.value = params[attr_name]
             return self.strategy.populate_sell_trend(dataframe, metadata)
+
         return populate_buy_trend
 
     def _get_func(self, name) -> Callable:
@@ -49,7 +54,8 @@ class HyperOptAuto(IHyperOpt):
             return default_func
 
     def _generate_indicator_space(self, category):
-        assert hasattr(self.strategy, 'enumerate_parameters'), 'Strategy must inherit from IHyperStrategy.'
+        if not getattr(self.strategy, 'HYPER_STRATEGY', False):
+            raise OperationalException('Strategy must inherit from IHyperStrategy.')
 
         for attr_name, attr in self.strategy.enumerate_parameters(category):
             yield attr.get_space(attr_name)
diff --git a/freqtrade/optimize/hyperopt_interface.py b/freqtrade/optimize/hyperopt_interface.py
index 561fb8e11..2dd8500a6 100644
--- a/freqtrade/optimize/hyperopt_interface.py
+++ b/freqtrade/optimize/hyperopt_interface.py
@@ -5,15 +5,14 @@ This module defines the interface to apply for hyperopt
 import logging
 import math
 from abc import ABC
-from typing import Any, Callable, Dict, List
+from typing import Any, Callable, Dict, List, Union
 
 from skopt.space import Categorical, Dimension, Integer, Real
 
 from freqtrade.exceptions import OperationalException
 from freqtrade.exchange import timeframe_to_minutes
 from freqtrade.misc import round_dict
-from freqtrade.strategy import IStrategy
-
+from freqtrade.strategy import IStrategy, HyperStrategyMixin
 
 logger = logging.getLogger(__name__)
 
@@ -35,7 +34,7 @@ class IHyperOpt(ABC):
     """
     ticker_interval: str  # DEPRECATED
     timeframe: str
-    strategy: IStrategy
+    strategy: Union[IStrategy, HyperStrategyMixin]
 
     def __init__(self, config: dict) -> None:
         self.config = config
diff --git a/freqtrade/strategy/__init__.py b/freqtrade/strategy/__init__.py
index 80a7c00de..e395be106 100644
--- a/freqtrade/strategy/__init__.py
+++ b/freqtrade/strategy/__init__.py
@@ -2,5 +2,6 @@
 from freqtrade.exchange import (timeframe_to_minutes, timeframe_to_msecs, timeframe_to_next_date,
                                 timeframe_to_prev_date, timeframe_to_seconds)
 from freqtrade.strategy.interface import IStrategy
-from freqtrade.strategy.hyper import IHyperStrategy, Parameter
+from freqtrade.strategy.hyper import HyperStrategyMixin, IntParameter, FloatParameter,\
+    CategoricalParameter
 from freqtrade.strategy.strategy_helper import merge_informative_pair, stoploss_from_open
diff --git a/freqtrade/strategy/hyper.py b/freqtrade/strategy/hyper.py
index 41bb836d4..8de986950 100644
--- a/freqtrade/strategy/hyper.py
+++ b/freqtrade/strategy/hyper.py
@@ -2,83 +2,158 @@
 IHyperStrategy interface, hyperoptable Parameter class.
 This module defines a base class for auto-hyperoptable strategies.
 """
-from abc import ABC
-from typing import Union, List, Iterator, Tuple
+from typing import Iterator, Tuple, Any, Optional, Sequence
 
 from skopt.space import Integer, Real, Categorical
 
-from freqtrade.strategy.interface import IStrategy
+from freqtrade.exceptions import OperationalException
 
 
-class Parameter(object):
+class BaseParameter(object):
     """
     Defines a parameter that can be optimized by hyperopt.
     """
-    default: Union[int, float, str, bool]
-    space: List[Union[int, float, str, bool]]
-    category: str
+    category: Optional[str]
+    default: Any
+    value: Any
+    space: Sequence[Any]
 
-    def __init__(self, *, space: List[Union[int, float, str, bool]], default: Union[int, float, str, bool] = None,
-                 category: str = None, **kwargs):
+    def __init__(self, *, space: Sequence[Any], default: Any, category: Optional[str] = None,
+                 **kwargs):
         """
         Initialize hyperopt-optimizable parameter.
-        :param space: Optimization space. [min, max] for ints and floats or a list of strings for categorial parameters.
-        :param default: A default value. Required for ints and floats, optional for categorial parameters (first item
-         from the space will be used). Type of default value determines skopt space used for optimization.
         :param category: A parameter category. Can be 'buy' or 'sell'. This parameter is optional if parameter field
          name is prefixed with 'buy_' or 'sell_'.
         :param kwargs: Extra parameters to skopt.space.(Integer|Real|Categorical).
         """
-        assert 'name' not in kwargs, 'Name is determined by parameter field name and can not be specified manually.'
-        self.value = default
-        self.space = space
+        if 'name' in kwargs:
+            raise OperationalException(
+                'Name is determined by parameter field name and can not be specified manually.')
         self.category = category
         self._space_params = kwargs
-        if default is None:
-            assert len(space) > 0
-            self.value = space[0]
+        self.value = default
+        self.space = space
 
-    def get_space(self, name: str) -> Union[Integer, Real, Categorical, None]:
+    def __repr__(self):
+        return f'{self.__class__.__name__}({self.value})'
+
+
+class IntParameter(BaseParameter):
+    default: int
+    value: int
+    space: Sequence[int]
+
+    def __init__(self, *, space: Sequence[int], default: int, category: Optional[str] = None,
+                 **kwargs):
+        """
+        Initialize hyperopt-optimizable parameter.
+        :param space: Optimization space, [min, max].
+        :param default: A default value.
+        :param category: A parameter category. Can be 'buy' or 'sell'. This parameter is optional if parameter field
+         name is prefixed with 'buy_' or 'sell_'.
+        :param kwargs: Extra parameters to skopt.space.Integer.
+        """
+        if len(space) != 2:
+            raise OperationalException('IntParameter space must be [min, max]')
+        super().__init__(space=space, default=default, category=category, **kwargs)
+
+    def get_space(self, name: str) -> Integer:
         """
         Create skopt optimization space.
         :param name: A name of parameter field.
-        :return: skopt space of this parameter, or None if parameter is not optimizable (i.e. space is set to None)
         """
-        if not self.space:
-            return None
-        if isinstance(self.value, int):
-            assert len(self.space) == 2
-            return Integer(*self.space, name=name, **self._space_params)
-        if isinstance(self.value, float):
-            assert len(self.space) == 2
-            return Real(*self.space, name=name, **self._space_params)
+        return Integer(*self.space, name=name, **self._space_params)
 
-        assert len(self.space) > 0
+
+class FloatParameter(BaseParameter):
+    default: float
+    value: float
+    space: Sequence[float]
+
+    def __init__(self, *, space: Sequence[float], default: float, category: Optional[str] = None,
+                 **kwargs):
+        """
+        Initialize hyperopt-optimizable parameter.
+        :param space: Optimization space, [min, max].
+        :param default: A default value.
+        :param category: A parameter category. Can be 'buy' or 'sell'. This parameter is optional if parameter field
+         name is prefixed with 'buy_' or 'sell_'.
+        :param kwargs: Extra parameters to skopt.space.Real.
+        """
+        if len(space) != 2:
+            raise OperationalException('IntParameter space must be [min, max]')
+        super().__init__(space=space, default=default, category=category, **kwargs)
+
+    def get_space(self, name: str) -> Real:
+        """
+        Create skopt optimization space.
+        :param name: A name of parameter field.
+        """
+        return Real(*self.space, name=name, **self._space_params)
+
+
+class CategoricalParameter(BaseParameter):
+    default: Any
+    value: Any
+    space: Sequence[Any]
+
+    def __init__(self, *, space: Sequence[Any], default: Optional[Any] = None,
+                 category: Optional[str] = None,
+                 **kwargs):
+        """
+        Initialize hyperopt-optimizable parameter.
+        :param space: Optimization space, [a, b, ...].
+        :param default: A default value. If not specified, first item from specified space will be
+         used.
+        :param category: A parameter category. Can be 'buy' or 'sell'. This parameter is optional if
+         parameter field
+         name is prefixed with 'buy_' or 'sell_'.
+        :param kwargs: Extra parameters to skopt.space.Categorical.
+        """
+        if len(space) < 2:
+            raise OperationalException(
+                'IntParameter space must be [a, b, ...] (at least two parameters)')
+        super().__init__(space=space, default=default, category=category, **kwargs)
+
+    def get_space(self, name: str) -> Categorical:
+        """
+        Create skopt optimization space.
+        :param name: A name of parameter field.
+        """
         return Categorical(self.space, name=name, **self._space_params)
 
 
-class IHyperStrategy(IStrategy, ABC):
+class HyperStrategyMixin(object):
     """
-    A helper base class which allows HyperOptAuto class to reuse implementations of of buy/sell strategy logic.
+    A helper base class which allows HyperOptAuto class to reuse implementations of of buy/sell
+     strategy logic.
     """
 
-    def __init__(self, config):
-        super().__init__(config)
+    # Hint that class can be used with HyperOptAuto.
+    HYPER_STRATEGY = 1
+
+    def __init__(self):
+        """
+        Initialize hyperoptable strategy mixin.
+        :param config:
+        """
         self._load_params(getattr(self, 'buy_params', None))
         self._load_params(getattr(self, 'sell_params', None))
 
-    def enumerate_parameters(self, category: str = None) -> Iterator[Tuple[str, Parameter]]:
+    def enumerate_parameters(self, category: str = None) -> Iterator[Tuple[str, BaseParameter]]:
         """
         Find all optimizeable parameters and return (name, attr) iterator.
         :param category:
         :return:
         """
-        assert category in ('buy', 'sell', None)
+        if category not in ('buy', 'sell', None):
+            raise OperationalException('Category must be one of: "buy", "sell", None.')
         for attr_name in dir(self):
             if not attr_name.startswith('__'):  # Ignore internals, not strictly necessary.
                 attr = getattr(self, attr_name)
-                if isinstance(attr, Parameter):
-                    if category is None or category == attr.category or attr_name.startswith(category + '_'):
+                if issubclass(attr.__class__, BaseParameter):
+                    if category is None or category == attr.category or \
+                       attr_name.startswith(category + '_'):
                         yield attr_name, attr
 
     def _load_params(self, params: dict) -> None:

From 2d13e5fd5052511d1077632c281099977a548573 Mon Sep 17 00:00:00 2001
From: Rokas Kupstys <rokups@zoho.com>
Date: Wed, 24 Mar 2021 11:17:17 +0200
Subject: [PATCH 03/32] [SQUASH] Oopsies.

---
 freqtrade/optimize/hyperopt_auto.py |  2 +-
 freqtrade/strategy/hyper.py         | 14 ++++++++++----
 2 files changed, 11 insertions(+), 5 deletions(-)

diff --git a/freqtrade/optimize/hyperopt_auto.py b/freqtrade/optimize/hyperopt_auto.py
index fdc4da14c..41f086ad2 100644
--- a/freqtrade/optimize/hyperopt_auto.py
+++ b/freqtrade/optimize/hyperopt_auto.py
@@ -7,10 +7,10 @@ from typing import Any, Callable, Dict, List
 from pandas import DataFrame
 from skopt.space import Categorical, Dimension, Integer, Real  # noqa
 
+from freqtrade.exceptions import OperationalException
 from freqtrade.optimize.hyperopt_interface import IHyperOpt
 
 
-# noinspection PyUnresolvedReferences
 class HyperOptAuto(IHyperOpt):
     """
     This class delegates functionality to Strategy(IHyperStrategy) and Strategy.HyperOpt classes.
diff --git a/freqtrade/strategy/hyper.py b/freqtrade/strategy/hyper.py
index 8de986950..154dcead6 100644
--- a/freqtrade/strategy/hyper.py
+++ b/freqtrade/strategy/hyper.py
@@ -2,7 +2,7 @@
 IHyperStrategy interface, hyperoptable Parameter class.
 This module defines a base class for auto-hyperoptable strategies.
 """
-from typing import Iterator, Tuple, Any, Optional, Sequence
+from typing import Iterator, Tuple, Any, Optional, Sequence, Union
 
 from skopt.space import Integer, Real, Categorical
 
@@ -22,7 +22,8 @@ class BaseParameter(object):
                  **kwargs):
         """
         Initialize hyperopt-optimizable parameter.
-        :param category: A parameter category. Can be 'buy' or 'sell'. This parameter is optional if parameter field
+        :param category: A parameter category. Can be 'buy' or 'sell'. This parameter is optional if
+         parameter field
          name is prefixed with 'buy_' or 'sell_'.
         :param kwargs: Extra parameters to skopt.space.(Integer|Real|Categorical).
         """
@@ -37,6 +38,9 @@ class BaseParameter(object):
     def __repr__(self):
         return f'{self.__class__.__name__}({self.value})'
 
+    def get_space(self, name: str) -> Union[Integer, Real, Categorical]:
+        raise NotImplementedError()
+
 
 class IntParameter(BaseParameter):
     default: int
@@ -49,7 +53,8 @@ class IntParameter(BaseParameter):
         Initialize hyperopt-optimizable parameter.
         :param space: Optimization space, [min, max].
         :param default: A default value.
-        :param category: A parameter category. Can be 'buy' or 'sell'. This parameter is optional if parameter field
+        :param category: A parameter category. Can be 'buy' or 'sell'. This parameter is optional if
+         parameter field
          name is prefixed with 'buy_' or 'sell_'.
         :param kwargs: Extra parameters to skopt.space.Integer.
         """
@@ -76,7 +81,8 @@ class FloatParameter(BaseParameter):
         Initialize hyperopt-optimizable parameter.
         :param space: Optimization space, [min, max].
         :param default: A default value.
-        :param category: A parameter category. Can be 'buy' or 'sell'. This parameter is optional if parameter field
+        :param category: A parameter category. Can be 'buy' or 'sell'. This parameter is optional if
+         parameter field
          name is prefixed with 'buy_' or 'sell_'.
         :param kwargs: Extra parameters to skopt.space.Real.
         """

From e9f0babe8a7276cdb1fa3f22cb2b21368e209c31 Mon Sep 17 00:00:00 2001
From: Rokas Kupstys <rokups@zoho.com>
Date: Wed, 24 Mar 2021 16:03:38 +0200
Subject: [PATCH 04/32] [SQUASH] Use HyperStrategyMixin as part of IStrategy
 interface.

---
 freqtrade/optimize/hyperopt.py           |  4 ----
 freqtrade/optimize/hyperopt_auto.py      | 10 ----------
 freqtrade/optimize/hyperopt_interface.py |  6 +++---
 freqtrade/strategy/__init__.py           |  3 +--
 freqtrade/strategy/hyper.py              |  4 ----
 freqtrade/strategy/interface.py          |  3 ++-
 6 files changed, 6 insertions(+), 24 deletions(-)

diff --git a/freqtrade/optimize/hyperopt.py b/freqtrade/optimize/hyperopt.py
index b5ee1da1a..4926bf1b3 100644
--- a/freqtrade/optimize/hyperopt.py
+++ b/freqtrade/optimize/hyperopt.py
@@ -70,10 +70,6 @@ class Hyperopt:
         self.backtesting = Backtesting(self.config)
 
         if not self.config.get('hyperopt'):
-            if not getattr(self.backtesting.strategy, 'HYPER_STRATEGY', False):
-                raise OperationalException('Strategy is not auto-hyperoptable. Specify --hyperopt '
-                                           'parameter or add HyperStrategyMixin mixin to your '
-                                           'strategy class.')
             self.custom_hyperopt = HyperOptAuto(self.config)
         else:
             self.custom_hyperopt = HyperOptResolver.load_hyperopt(self.config)
diff --git a/freqtrade/optimize/hyperopt_auto.py b/freqtrade/optimize/hyperopt_auto.py
index 41f086ad2..753e8175e 100644
--- a/freqtrade/optimize/hyperopt_auto.py
+++ b/freqtrade/optimize/hyperopt_auto.py
@@ -7,7 +7,6 @@ from typing import Any, Callable, Dict, List
 from pandas import DataFrame
 from skopt.space import Categorical, Dimension, Integer, Real  # noqa
 
-from freqtrade.exceptions import OperationalException
 from freqtrade.optimize.hyperopt_interface import IHyperOpt
 
 
@@ -19,9 +18,6 @@ class HyperOptAuto(IHyperOpt):
     """
 
     def buy_strategy_generator(self, params: Dict[str, Any]) -> Callable:
-        if not getattr(self.strategy, 'HYPER_STRATEGY', False):
-            raise OperationalException('Strategy must inherit from IHyperStrategy.')
-
         def populate_buy_trend(dataframe: DataFrame, metadata: dict):
             for attr_name, attr in self.strategy.enumerate_parameters('buy'):
                 attr.value = params[attr_name]
@@ -30,9 +26,6 @@ class HyperOptAuto(IHyperOpt):
         return populate_buy_trend
 
     def sell_strategy_generator(self, params: Dict[str, Any]) -> Callable:
-        if not getattr(self.strategy, 'HYPER_STRATEGY', False):
-            raise OperationalException('Strategy must inherit from IHyperStrategy.')
-
         def populate_buy_trend(dataframe: DataFrame, metadata: dict):
             for attr_name, attr in self.strategy.enumerate_parameters('sell'):
                 attr.value = params[attr_name]
@@ -54,9 +47,6 @@ class HyperOptAuto(IHyperOpt):
             return default_func
 
     def _generate_indicator_space(self, category):
-        if not getattr(self.strategy, 'HYPER_STRATEGY', False):
-            raise OperationalException('Strategy must inherit from IHyperStrategy.')
-
         for attr_name, attr in self.strategy.enumerate_parameters(category):
             yield attr.get_space(attr_name)
 
diff --git a/freqtrade/optimize/hyperopt_interface.py b/freqtrade/optimize/hyperopt_interface.py
index 2dd8500a6..46adf55b8 100644
--- a/freqtrade/optimize/hyperopt_interface.py
+++ b/freqtrade/optimize/hyperopt_interface.py
@@ -5,14 +5,14 @@ This module defines the interface to apply for hyperopt
 import logging
 import math
 from abc import ABC
-from typing import Any, Callable, Dict, List, Union
+from typing import Any, Callable, Dict, List
 
 from skopt.space import Categorical, Dimension, Integer, Real
 
 from freqtrade.exceptions import OperationalException
 from freqtrade.exchange import timeframe_to_minutes
 from freqtrade.misc import round_dict
-from freqtrade.strategy import IStrategy, HyperStrategyMixin
+from freqtrade.strategy import IStrategy
 
 logger = logging.getLogger(__name__)
 
@@ -34,7 +34,7 @@ class IHyperOpt(ABC):
     """
     ticker_interval: str  # DEPRECATED
     timeframe: str
-    strategy: Union[IStrategy, HyperStrategyMixin]
+    strategy: IStrategy
 
     def __init__(self, config: dict) -> None:
         self.config = config
diff --git a/freqtrade/strategy/__init__.py b/freqtrade/strategy/__init__.py
index e395be106..a300c601b 100644
--- a/freqtrade/strategy/__init__.py
+++ b/freqtrade/strategy/__init__.py
@@ -2,6 +2,5 @@
 from freqtrade.exchange import (timeframe_to_minutes, timeframe_to_msecs, timeframe_to_next_date,
                                 timeframe_to_prev_date, timeframe_to_seconds)
 from freqtrade.strategy.interface import IStrategy
-from freqtrade.strategy.hyper import HyperStrategyMixin, IntParameter, FloatParameter,\
-    CategoricalParameter
+from freqtrade.strategy.hyper import IntParameter, FloatParameter, CategoricalParameter
 from freqtrade.strategy.strategy_helper import merge_informative_pair, stoploss_from_open
diff --git a/freqtrade/strategy/hyper.py b/freqtrade/strategy/hyper.py
index 154dcead6..53a0c6462 100644
--- a/freqtrade/strategy/hyper.py
+++ b/freqtrade/strategy/hyper.py
@@ -135,13 +135,9 @@ class HyperStrategyMixin(object):
      strategy logic.
     """
 
-    # Hint that class can be used with HyperOptAuto.
-    HYPER_STRATEGY = 1
-
     def __init__(self):
         """
         Initialize hyperoptable strategy mixin.
-        :param config:
         """
         self._load_params(getattr(self, 'buy_params', None))
         self._load_params(getattr(self, 'sell_params', None))
diff --git a/freqtrade/strategy/interface.py b/freqtrade/strategy/interface.py
index 6d40e56cc..b00e0ccb8 100644
--- a/freqtrade/strategy/interface.py
+++ b/freqtrade/strategy/interface.py
@@ -18,6 +18,7 @@ from freqtrade.exceptions import OperationalException, StrategyError
 from freqtrade.exchange import timeframe_to_minutes, timeframe_to_seconds
 from freqtrade.exchange.exchange import timeframe_to_next_date
 from freqtrade.persistence import PairLocks, Trade
+from freqtrade.strategy.hyper import HyperStrategyMixin
 from freqtrade.strategy.strategy_wrapper import strategy_safe_wrapper
 from freqtrade.wallets import Wallets
 
@@ -59,7 +60,7 @@ class SellCheckTuple(NamedTuple):
     sell_type: SellType
 
 
-class IStrategy(ABC):
+class IStrategy(ABC, HyperStrategyMixin):
     """
     Interface for freqtrade strategies
     Defines the mandatory structure must follow any custom strategies

From 11689100e7c2b6a8d8fdcb23060d2f97e3aa206f Mon Sep 17 00:00:00 2001
From: Rokas Kupstys <rokups@zoho.com>
Date: Wed, 24 Mar 2021 16:24:24 +0200
Subject: [PATCH 05/32] [SQUASH] Fix exception when HyperOpt nested class is
 not defined.

---
 freqtrade/optimize/hyperopt_auto.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/freqtrade/optimize/hyperopt_auto.py b/freqtrade/optimize/hyperopt_auto.py
index 753e8175e..08269b092 100644
--- a/freqtrade/optimize/hyperopt_auto.py
+++ b/freqtrade/optimize/hyperopt_auto.py
@@ -39,7 +39,7 @@ class HyperOptAuto(IHyperOpt):
         :param name: function name.
         :return: a requested function.
         """
-        hyperopt_cls = getattr(self.strategy, 'HyperOpt')
+        hyperopt_cls = getattr(self.strategy, 'HyperOpt', None)
         default_func = getattr(super(), name)
         if hyperopt_cls:
             return getattr(hyperopt_cls, name, default_func)

From fd45dfd89413cf938f14e9e65335ce8a21f316f1 Mon Sep 17 00:00:00 2001
From: Rokas Kupstys <rokups@zoho.com>
Date: Thu, 25 Mar 2021 10:00:52 +0200
Subject: [PATCH 06/32] [SQUASH] Make skopt imports optional.

---
 freqtrade/optimize/hyperopt_auto.py | 15 +++++++++------
 freqtrade/strategy/hyper.py         | 12 +++++++-----
 2 files changed, 16 insertions(+), 11 deletions(-)

diff --git a/freqtrade/optimize/hyperopt_auto.py b/freqtrade/optimize/hyperopt_auto.py
index 08269b092..fb8adfe6b 100644
--- a/freqtrade/optimize/hyperopt_auto.py
+++ b/freqtrade/optimize/hyperopt_auto.py
@@ -3,9 +3,12 @@ HyperOptAuto class.
 This module implements a convenience auto-hyperopt class, which can be used together with strategies
  that implement IHyperStrategy interface.
 """
+from contextlib import suppress
 from typing import Any, Callable, Dict, List
+
 from pandas import DataFrame
-from skopt.space import Categorical, Dimension, Integer, Real  # noqa
+with suppress(ImportError):
+    from skopt.space import Dimension
 
 from freqtrade.optimize.hyperopt_interface import IHyperOpt
 
@@ -57,23 +60,23 @@ class HyperOptAuto(IHyperOpt):
         else:
             return self._get_func(fallback_method_name)()
 
-    def indicator_space(self) -> List[Dimension]:
+    def indicator_space(self) -> List['Dimension']:
         return self._get_indicator_space('buy', 'indicator_space')
 
-    def sell_indicator_space(self) -> List[Dimension]:
+    def sell_indicator_space(self) -> List['Dimension']:
         return self._get_indicator_space('sell', 'sell_indicator_space')
 
     def generate_roi_table(self, params: Dict) -> Dict[int, float]:
         return self._get_func('generate_roi_table')(params)
 
-    def roi_space(self) -> List[Dimension]:
+    def roi_space(self) -> List['Dimension']:
         return self._get_func('roi_space')()
 
-    def stoploss_space(self) -> List[Dimension]:
+    def stoploss_space(self) -> List['Dimension']:
         return self._get_func('stoploss_space')()
 
     def generate_trailing_params(self, params: Dict) -> Dict:
         return self._get_func('generate_trailing_params')(params)
 
-    def trailing_space(self) -> List[Dimension]:
+    def trailing_space(self) -> List['Dimension']:
         return self._get_func('trailing_space')()
diff --git a/freqtrade/strategy/hyper.py b/freqtrade/strategy/hyper.py
index 53a0c6462..0378be1d5 100644
--- a/freqtrade/strategy/hyper.py
+++ b/freqtrade/strategy/hyper.py
@@ -2,9 +2,11 @@
 IHyperStrategy interface, hyperoptable Parameter class.
 This module defines a base class for auto-hyperoptable strategies.
 """
+from contextlib import suppress
 from typing import Iterator, Tuple, Any, Optional, Sequence, Union
 
-from skopt.space import Integer, Real, Categorical
+with suppress(ImportError):
+    from skopt.space import Integer, Real, Categorical
 
 from freqtrade.exceptions import OperationalException
 
@@ -38,7 +40,7 @@ class BaseParameter(object):
     def __repr__(self):
         return f'{self.__class__.__name__}({self.value})'
 
-    def get_space(self, name: str) -> Union[Integer, Real, Categorical]:
+    def get_space(self, name: str) -> Union['Integer', 'Real', 'Categorical']:
         raise NotImplementedError()
 
 
@@ -62,7 +64,7 @@ class IntParameter(BaseParameter):
             raise OperationalException('IntParameter space must be [min, max]')
         super().__init__(space=space, default=default, category=category, **kwargs)
 
-    def get_space(self, name: str) -> Integer:
+    def get_space(self, name: str) -> 'Integer':
         """
         Create skopt optimization space.
         :param name: A name of parameter field.
@@ -90,7 +92,7 @@ class FloatParameter(BaseParameter):
             raise OperationalException('IntParameter space must be [min, max]')
         super().__init__(space=space, default=default, category=category, **kwargs)
 
-    def get_space(self, name: str) -> Real:
+    def get_space(self, name: str) -> 'Real':
         """
         Create skopt optimization space.
         :param name: A name of parameter field.
@@ -121,7 +123,7 @@ class CategoricalParameter(BaseParameter):
                 'IntParameter space must be [a, b, ...] (at least two parameters)')
         super().__init__(space=space, default=default, category=category, **kwargs)
 
-    def get_space(self, name: str) -> Categorical:
+    def get_space(self, name: str) -> 'Categorical':
         """
         Create skopt optimization space.
         :param name: A name of parameter field.

From 424cd2a91422f0f85d1b4362a38ff7fbb3950798 Mon Sep 17 00:00:00 2001
From: Rokas Kupstys <rokups@zoho.com>
Date: Thu, 25 Mar 2021 17:58:11 +0200
Subject: [PATCH 07/32] [SQUASH] Use "space" instead of category.

---
 freqtrade/strategy/hyper.py | 73 +++++++++++++++++++++----------------
 1 file changed, 41 insertions(+), 32 deletions(-)

diff --git a/freqtrade/strategy/hyper.py b/freqtrade/strategy/hyper.py
index 0378be1d5..9f7fc3fb6 100644
--- a/freqtrade/strategy/hyper.py
+++ b/freqtrade/strategy/hyper.py
@@ -18,13 +18,13 @@ class BaseParameter(object):
     category: Optional[str]
     default: Any
     value: Any
-    space: Sequence[Any]
+    opt_range: Sequence[Any]
 
-    def __init__(self, *, space: Sequence[Any], default: Any, category: Optional[str] = None,
+    def __init__(self, *, opt_range: Sequence[Any], default: Any, space: Optional[str] = None,
                  **kwargs):
         """
         Initialize hyperopt-optimizable parameter.
-        :param category: A parameter category. Can be 'buy' or 'sell'. This parameter is optional if
+        :param space: A parameter category. Can be 'buy' or 'sell'. This parameter is optional if
          parameter field
          name is prefixed with 'buy_' or 'sell_'.
         :param kwargs: Extra parameters to skopt.space.(Integer|Real|Categorical).
@@ -32,10 +32,10 @@ class BaseParameter(object):
         if 'name' in kwargs:
             raise OperationalException(
                 'Name is determined by parameter field name and can not be specified manually.')
-        self.category = category
+        self.category = space
         self._space_params = kwargs
         self.value = default
-        self.space = space
+        self.opt_range = opt_range
 
     def __repr__(self):
         return f'{self.__class__.__name__}({self.value})'
@@ -47,88 +47,97 @@ class BaseParameter(object):
 class IntParameter(BaseParameter):
     default: int
     value: int
-    space: Sequence[int]
+    opt_range: Sequence[int]
 
-    def __init__(self, *, space: Sequence[int], default: int, category: Optional[str] = None,
-                 **kwargs):
+    def __init__(self, low: Union[int, Sequence[int]], high: Optional[int] = None, *, default: int,
+                 space: Optional[str] = None, **kwargs):
         """
         Initialize hyperopt-optimizable parameter.
-        :param space: Optimization space, [min, max].
+        :param low: lower end of optimization space or [low, high].
+        :param high: high end of optimization space. Must be none of entire range is passed first parameter.
         :param default: A default value.
-        :param category: A parameter category. Can be 'buy' or 'sell'. This parameter is optional if
+        :param space: A parameter category. Can be 'buy' or 'sell'. This parameter is optional if
          parameter field
          name is prefixed with 'buy_' or 'sell_'.
         :param kwargs: Extra parameters to skopt.space.Integer.
         """
-        if len(space) != 2:
-            raise OperationalException('IntParameter space must be [min, max]')
-        super().__init__(space=space, default=default, category=category, **kwargs)
+        if high is None:
+            if len(low) != 2:
+                raise OperationalException('IntParameter space must be [low, high]')
+            opt_range = low
+        else:
+            opt_range = [low, high]
+        super().__init__(opt_range=opt_range, default=default, space=space, **kwargs)
 
     def get_space(self, name: str) -> 'Integer':
         """
         Create skopt optimization space.
         :param name: A name of parameter field.
         """
-        return Integer(*self.space, name=name, **self._space_params)
+        return Integer(*self.opt_range, name=name, **self._space_params)
 
 
 class FloatParameter(BaseParameter):
     default: float
     value: float
-    space: Sequence[float]
+    opt_range: Sequence[float]
 
-    def __init__(self, *, space: Sequence[float], default: float, category: Optional[str] = None,
-                 **kwargs):
+    def __init__(self, low: Union[float, Sequence[float]], high: Optional[int] = None, *,
+                 default: float, space: Optional[str] = None, **kwargs):
         """
         Initialize hyperopt-optimizable parameter.
-        :param space: Optimization space, [min, max].
+        :param low: lower end of optimization space or [low, high].
+        :param high: high end of optimization space. Must be none of entire range is passed first parameter.
         :param default: A default value.
-        :param category: A parameter category. Can be 'buy' or 'sell'. This parameter is optional if
+        :param space: A parameter category. Can be 'buy' or 'sell'. This parameter is optional if
          parameter field
          name is prefixed with 'buy_' or 'sell_'.
         :param kwargs: Extra parameters to skopt.space.Real.
         """
-        if len(space) != 2:
-            raise OperationalException('IntParameter space must be [min, max]')
-        super().__init__(space=space, default=default, category=category, **kwargs)
+        if high is None:
+            if len(low) != 2:
+                raise OperationalException('IntParameter space must be [low, high]')
+            opt_range = low
+        else:
+            opt_range = [low, high]
+        super().__init__(opt_range=opt_range, default=default, space=space, **kwargs)
 
     def get_space(self, name: str) -> 'Real':
         """
         Create skopt optimization space.
         :param name: A name of parameter field.
         """
-        return Real(*self.space, name=name, **self._space_params)
+        return Real(*self.opt_range, name=name, **self._space_params)
 
 
 class CategoricalParameter(BaseParameter):
     default: Any
     value: Any
-    space: Sequence[Any]
+    opt_range: Sequence[Any]
 
-    def __init__(self, *, space: Sequence[Any], default: Optional[Any] = None,
-                 category: Optional[str] = None,
-                 **kwargs):
+    def __init__(self, categories: Sequence[Any], *, default: Optional[Any] = None,
+                 space: Optional[str] = None, **kwargs):
         """
         Initialize hyperopt-optimizable parameter.
-        :param space: Optimization space, [a, b, ...].
+        :param categories: Optimization space, [a, b, ...].
         :param default: A default value. If not specified, first item from specified space will be
          used.
-        :param category: A parameter category. Can be 'buy' or 'sell'. This parameter is optional if
+        :param space: A parameter category. Can be 'buy' or 'sell'. This parameter is optional if
          parameter field
          name is prefixed with 'buy_' or 'sell_'.
         :param kwargs: Extra parameters to skopt.space.Categorical.
         """
-        if len(space) < 2:
+        if len(categories) < 2:
             raise OperationalException(
                 'IntParameter space must be [a, b, ...] (at least two parameters)')
-        super().__init__(space=space, default=default, category=category, **kwargs)
+        super().__init__(opt_range=categories, default=default, space=space, **kwargs)
 
     def get_space(self, name: str) -> 'Categorical':
         """
         Create skopt optimization space.
         :param name: A name of parameter field.
         """
-        return Categorical(self.space, name=name, **self._space_params)
+        return Categorical(self.opt_range, name=name, **self._space_params)
 
 
 class HyperStrategyMixin(object):

From bbe6ece38ddd89ca3c4174e7c9a5d824216a9a98 Mon Sep 17 00:00:00 2001
From: Rokas Kupstys <rokups@zoho.com>
Date: Fri, 26 Mar 2021 14:25:17 +0200
Subject: [PATCH 08/32] [SQUASH] Fix parameter configs not loading.

---
 freqtrade/strategy/hyper.py     | 2 +-
 freqtrade/strategy/interface.py | 1 +
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/freqtrade/strategy/hyper.py b/freqtrade/strategy/hyper.py
index 9f7fc3fb6..0b3021af2 100644
--- a/freqtrade/strategy/hyper.py
+++ b/freqtrade/strategy/hyper.py
@@ -146,7 +146,7 @@ class HyperStrategyMixin(object):
      strategy logic.
     """
 
-    def __init__(self):
+    def __init__(self, *args, **kwargs):
         """
         Initialize hyperoptable strategy mixin.
         """
diff --git a/freqtrade/strategy/interface.py b/freqtrade/strategy/interface.py
index b00e0ccb8..54c7f2353 100644
--- a/freqtrade/strategy/interface.py
+++ b/freqtrade/strategy/interface.py
@@ -141,6 +141,7 @@ class IStrategy(ABC, HyperStrategyMixin):
         self.config = config
         # Dict to determine if analysis is necessary
         self._last_candle_seen_per_pair: Dict[str, datetime] = {}
+        super().__init__(config)
 
     @abstractmethod
     def populate_indicators(self, dataframe: DataFrame, metadata: dict) -> DataFrame:

From 40f5c7853ed06422c53e3e320f670266f0f6cb64 Mon Sep 17 00:00:00 2001
From: Rokas Kupstys <rokups@zoho.com>
Date: Fri, 26 Mar 2021 14:25:49 +0200
Subject: [PATCH 09/32] [SQUASH] Add a way to temporarily disable a parameter
 (excludes from parameter loading/hyperopt) and print parameter values when
 executed.

---
 freqtrade/optimize/hyperopt_auto.py |  3 ++-
 freqtrade/strategy/hyper.py         | 32 +++++++++++++++++++++--------
 2 files changed, 25 insertions(+), 10 deletions(-)

diff --git a/freqtrade/optimize/hyperopt_auto.py b/freqtrade/optimize/hyperopt_auto.py
index fb8adfe6b..31a11e303 100644
--- a/freqtrade/optimize/hyperopt_auto.py
+++ b/freqtrade/optimize/hyperopt_auto.py
@@ -51,7 +51,8 @@ class HyperOptAuto(IHyperOpt):
 
     def _generate_indicator_space(self, category):
         for attr_name, attr in self.strategy.enumerate_parameters(category):
-            yield attr.get_space(attr_name)
+            if attr.enabled:
+                yield attr.get_space(attr_name)
 
     def _get_indicator_space(self, category, fallback_method_name):
         indicator_space = list(self._generate_indicator_space(category))
diff --git a/freqtrade/strategy/hyper.py b/freqtrade/strategy/hyper.py
index 0b3021af2..e6f63f5a5 100644
--- a/freqtrade/strategy/hyper.py
+++ b/freqtrade/strategy/hyper.py
@@ -2,6 +2,7 @@
 IHyperStrategy interface, hyperoptable Parameter class.
 This module defines a base class for auto-hyperoptable strategies.
 """
+import logging
 from contextlib import suppress
 from typing import Iterator, Tuple, Any, Optional, Sequence, Union
 
@@ -11,6 +12,9 @@ with suppress(ImportError):
 from freqtrade.exceptions import OperationalException
 
 
+logger = logging.getLogger(__name__)
+
+
 class BaseParameter(object):
     """
     Defines a parameter that can be optimized by hyperopt.
@@ -21,7 +25,7 @@ class BaseParameter(object):
     opt_range: Sequence[Any]
 
     def __init__(self, *, opt_range: Sequence[Any], default: Any, space: Optional[str] = None,
-                 **kwargs):
+                 enabled: bool = True, **kwargs):
         """
         Initialize hyperopt-optimizable parameter.
         :param space: A parameter category. Can be 'buy' or 'sell'. This parameter is optional if
@@ -36,6 +40,7 @@ class BaseParameter(object):
         self._space_params = kwargs
         self.value = default
         self.opt_range = opt_range
+        self.enabled = enabled
 
     def __repr__(self):
         return f'{self.__class__.__name__}({self.value})'
@@ -50,7 +55,7 @@ class IntParameter(BaseParameter):
     opt_range: Sequence[int]
 
     def __init__(self, low: Union[int, Sequence[int]], high: Optional[int] = None, *, default: int,
-                 space: Optional[str] = None, **kwargs):
+                 space: Optional[str] = None, enabled: bool = True, **kwargs):
         """
         Initialize hyperopt-optimizable parameter.
         :param low: lower end of optimization space or [low, high].
@@ -67,7 +72,8 @@ class IntParameter(BaseParameter):
             opt_range = low
         else:
             opt_range = [low, high]
-        super().__init__(opt_range=opt_range, default=default, space=space, **kwargs)
+        super().__init__(opt_range=opt_range, default=default, space=space, enabled=enabled,
+                         **kwargs)
 
     def get_space(self, name: str) -> 'Integer':
         """
@@ -83,7 +89,7 @@ class FloatParameter(BaseParameter):
     opt_range: Sequence[float]
 
     def __init__(self, low: Union[float, Sequence[float]], high: Optional[int] = None, *,
-                 default: float, space: Optional[str] = None, **kwargs):
+                 default: float, space: Optional[str] = None, enabled: bool = True, **kwargs):
         """
         Initialize hyperopt-optimizable parameter.
         :param low: lower end of optimization space or [low, high].
@@ -100,7 +106,8 @@ class FloatParameter(BaseParameter):
             opt_range = low
         else:
             opt_range = [low, high]
-        super().__init__(opt_range=opt_range, default=default, space=space, **kwargs)
+        super().__init__(opt_range=opt_range, default=default, space=space, enabled=enabled,
+                         **kwargs)
 
     def get_space(self, name: str) -> 'Real':
         """
@@ -116,7 +123,7 @@ class CategoricalParameter(BaseParameter):
     opt_range: Sequence[Any]
 
     def __init__(self, categories: Sequence[Any], *, default: Optional[Any] = None,
-                 space: Optional[str] = None, **kwargs):
+                 space: Optional[str] = None, enabled: bool = True, **kwargs):
         """
         Initialize hyperopt-optimizable parameter.
         :param categories: Optimization space, [a, b, ...].
@@ -130,7 +137,8 @@ class CategoricalParameter(BaseParameter):
         if len(categories) < 2:
             raise OperationalException(
                 'IntParameter space must be [a, b, ...] (at least two parameters)')
-        super().__init__(opt_range=categories, default=default, space=space, **kwargs)
+        super().__init__(opt_range=categories, default=default, space=space, enabled=enabled,
+                         **kwargs)
 
     def get_space(self, name: str) -> 'Categorical':
         """
@@ -167,7 +175,8 @@ class HyperStrategyMixin(object):
                 if issubclass(attr.__class__, BaseParameter):
                     if category is None or category == attr.category or \
                        attr_name.startswith(category + '_'):
-                        yield attr_name, attr
+                        if attr.enabled:
+                            yield attr_name, attr
 
     def _load_params(self, params: dict) -> None:
         """
@@ -178,4 +187,9 @@ class HyperStrategyMixin(object):
             return
         for attr_name, attr in self.enumerate_parameters():
             if attr_name in params:
-                attr.value = params[attr_name]
+                if attr.enabled:
+                    attr.value = params[attr_name]
+                    logger.info(f'attr_name = {attr.value}')
+                else:
+                    logger.warning(f'Parameter "{attr_name}" exists, but is disabled. '
+                                   f'Default value "{attr.value}" used.')

From e934d3ddfbd32ab5cc897883d96c242eec66c5db Mon Sep 17 00:00:00 2001
From: Rokas Kupstys <rokups@zoho.com>
Date: Fri, 26 Mar 2021 16:55:48 +0200
Subject: [PATCH 10/32] [SQUASH] Oopsie.

---
 freqtrade/strategy/hyper.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/freqtrade/strategy/hyper.py b/freqtrade/strategy/hyper.py
index e6f63f5a5..51f937fca 100644
--- a/freqtrade/strategy/hyper.py
+++ b/freqtrade/strategy/hyper.py
@@ -88,7 +88,7 @@ class FloatParameter(BaseParameter):
     value: float
     opt_range: Sequence[float]
 
-    def __init__(self, low: Union[float, Sequence[float]], high: Optional[int] = None, *,
+    def __init__(self, low: Union[float, Sequence[float]], high: Optional[float] = None, *,
                  default: float, space: Optional[str] = None, enabled: bool = True, **kwargs):
         """
         Initialize hyperopt-optimizable parameter.

From 786ddc6a9114dd8b26978be7bbeb1c67db44f48a Mon Sep 17 00:00:00 2001
From: Matthias <xmatthias@outlook.com>
Date: Sat, 27 Mar 2021 10:40:48 +0100
Subject: [PATCH 11/32] remove unused imports

---
 freqtrade/optimize/hyperopt.py           |  1 -
 freqtrade/optimize/hyperopt_auto.py      |  2 ++
 freqtrade/optimize/hyperopt_interface.py |  1 +
 freqtrade/strategy/__init__.py           |  2 +-
 freqtrade/strategy/hyper.py              | 19 ++++++++++---------
 5 files changed, 14 insertions(+), 11 deletions(-)

diff --git a/freqtrade/optimize/hyperopt.py b/freqtrade/optimize/hyperopt.py
index 4926bf1b3..a680d85c8 100644
--- a/freqtrade/optimize/hyperopt.py
+++ b/freqtrade/optimize/hyperopt.py
@@ -23,7 +23,6 @@ from pandas import DataFrame
 from freqtrade.constants import DATETIME_PRINT_FORMAT, LAST_BT_RESULT_FN
 from freqtrade.data.converter import trim_dataframe
 from freqtrade.data.history import get_timerange
-from freqtrade.exceptions import OperationalException
 from freqtrade.misc import file_dump_json, plural
 from freqtrade.optimize.backtesting import Backtesting
 # Import IHyperOpt and IHyperOptLoss to allow unpickling classes from these modules
diff --git a/freqtrade/optimize/hyperopt_auto.py b/freqtrade/optimize/hyperopt_auto.py
index 31a11e303..847d8697a 100644
--- a/freqtrade/optimize/hyperopt_auto.py
+++ b/freqtrade/optimize/hyperopt_auto.py
@@ -7,6 +7,8 @@ from contextlib import suppress
 from typing import Any, Callable, Dict, List
 
 from pandas import DataFrame
+
+
 with suppress(ImportError):
     from skopt.space import Dimension
 
diff --git a/freqtrade/optimize/hyperopt_interface.py b/freqtrade/optimize/hyperopt_interface.py
index 46adf55b8..561fb8e11 100644
--- a/freqtrade/optimize/hyperopt_interface.py
+++ b/freqtrade/optimize/hyperopt_interface.py
@@ -14,6 +14,7 @@ from freqtrade.exchange import timeframe_to_minutes
 from freqtrade.misc import round_dict
 from freqtrade.strategy import IStrategy
 
+
 logger = logging.getLogger(__name__)
 
 
diff --git a/freqtrade/strategy/__init__.py b/freqtrade/strategy/__init__.py
index a300c601b..bc0c45f7c 100644
--- a/freqtrade/strategy/__init__.py
+++ b/freqtrade/strategy/__init__.py
@@ -1,6 +1,6 @@
 # flake8: noqa: F401
 from freqtrade.exchange import (timeframe_to_minutes, timeframe_to_msecs, timeframe_to_next_date,
                                 timeframe_to_prev_date, timeframe_to_seconds)
+from freqtrade.strategy.hyper import CategoricalParameter, FloatParameter, IntParameter
 from freqtrade.strategy.interface import IStrategy
-from freqtrade.strategy.hyper import IntParameter, FloatParameter, CategoricalParameter
 from freqtrade.strategy.strategy_helper import merge_informative_pair, stoploss_from_open
diff --git a/freqtrade/strategy/hyper.py b/freqtrade/strategy/hyper.py
index 51f937fca..32b03d57e 100644
--- a/freqtrade/strategy/hyper.py
+++ b/freqtrade/strategy/hyper.py
@@ -4,7 +4,8 @@ This module defines a base class for auto-hyperoptable strategies.
 """
 import logging
 from contextlib import suppress
-from typing import Iterator, Tuple, Any, Optional, Sequence, Union
+from typing import Any, Iterator, Optional, Sequence, Tuple, Union
+
 
 with suppress(ImportError):
     from skopt.space import Integer, Real, Categorical
@@ -58,12 +59,12 @@ class IntParameter(BaseParameter):
                  space: Optional[str] = None, enabled: bool = True, **kwargs):
         """
         Initialize hyperopt-optimizable parameter.
-        :param low: lower end of optimization space or [low, high].
-        :param high: high end of optimization space. Must be none of entire range is passed first parameter.
+        :param low: Lower end (inclusive) of optimization space or [low, high].
+        :param high: Upper end (inclusive) of optimization space.
+                     Must be none of entire range is passed first parameter.
         :param default: A default value.
         :param space: A parameter category. Can be 'buy' or 'sell'. This parameter is optional if
-         parameter field
-         name is prefixed with 'buy_' or 'sell_'.
+                      parameter fieldname is prefixed with 'buy_' or 'sell_'.
         :param kwargs: Extra parameters to skopt.space.Integer.
         """
         if high is None:
@@ -92,12 +93,12 @@ class FloatParameter(BaseParameter):
                  default: float, space: Optional[str] = None, enabled: bool = True, **kwargs):
         """
         Initialize hyperopt-optimizable parameter.
-        :param low: lower end of optimization space or [low, high].
-        :param high: high end of optimization space. Must be none of entire range is passed first parameter.
+        :param low: Lower end (inclusive) of optimization space or [low, high].
+        :param high: Upper end (inclusive) of optimization space.
+                     Must be none if entire range is passed first parameter.
         :param default: A default value.
         :param space: A parameter category. Can be 'buy' or 'sell'. This parameter is optional if
-         parameter field
-         name is prefixed with 'buy_' or 'sell_'.
+                      parameter fieldname is prefixed with 'buy_' or 'sell_'.
         :param kwargs: Extra parameters to skopt.space.Real.
         """
         if high is None:

From 71e2134694c88815d0c4b39e704abdbfbcadfa30 Mon Sep 17 00:00:00 2001
From: Matthias <xmatthias@outlook.com>
Date: Sat, 27 Mar 2021 11:26:26 +0100
Subject: [PATCH 12/32] Add some simple tests for hyperoptParameters

---
 freqtrade/strategy/hyper.py                   |  14 +-
 tests/rpc/test_rpc_apiserver.py               |   6 +-
 .../strategy/strats/hyperoptable_strategy.py  | 170 ++++++++++++++++++
 tests/strategy/test_interface.py              |  38 +++-
 tests/strategy/test_strategy_loading.py       |   6 +-
 5 files changed, 224 insertions(+), 10 deletions(-)
 create mode 100644 tests/strategy/strats/hyperoptable_strategy.py

diff --git a/freqtrade/strategy/hyper.py b/freqtrade/strategy/hyper.py
index 32b03d57e..b8bfef767 100644
--- a/freqtrade/strategy/hyper.py
+++ b/freqtrade/strategy/hyper.py
@@ -67,8 +67,10 @@ class IntParameter(BaseParameter):
                       parameter fieldname is prefixed with 'buy_' or 'sell_'.
         :param kwargs: Extra parameters to skopt.space.Integer.
         """
-        if high is None:
-            if len(low) != 2:
+        if high is not None and isinstance(low, Sequence):
+            raise OperationalException('IntParameter space invalid.')
+        if high is None or isinstance(low, Sequence):
+            if not isinstance(low, Sequence) or len(low) != 2:
                 raise OperationalException('IntParameter space must be [low, high]')
             opt_range = low
         else:
@@ -101,9 +103,11 @@ class FloatParameter(BaseParameter):
                       parameter fieldname is prefixed with 'buy_' or 'sell_'.
         :param kwargs: Extra parameters to skopt.space.Real.
         """
-        if high is None:
-            if len(low) != 2:
-                raise OperationalException('IntParameter space must be [low, high]')
+        if high is not None and isinstance(low, Sequence):
+            raise OperationalException('FloatParameter space invalid.')
+        if high is None or isinstance(low, Sequence):
+            if not isinstance(low, Sequence) or len(low) != 2:
+                raise OperationalException('FloatParameter space must be [low, high]')
             opt_range = low
         else:
             opt_range = [low, high]
diff --git a/tests/rpc/test_rpc_apiserver.py b/tests/rpc/test_rpc_apiserver.py
index 5a0a04943..bef70a5dd 100644
--- a/tests/rpc/test_rpc_apiserver.py
+++ b/tests/rpc/test_rpc_apiserver.py
@@ -1149,7 +1149,11 @@ def test_api_strategies(botclient):
     rc = client_get(client, f"{BASE_URI}/strategies")
 
     assert_response(rc)
-    assert rc.json() == {'strategies': ['DefaultStrategy', 'TestStrategyLegacy']}
+    assert rc.json() == {'strategies': [
+        'DefaultStrategy',
+        'HyperoptableStrategy',
+        'TestStrategyLegacy'
+        ]}
 
 
 def test_api_strategy(botclient):
diff --git a/tests/strategy/strats/hyperoptable_strategy.py b/tests/strategy/strats/hyperoptable_strategy.py
new file mode 100644
index 000000000..8cde28321
--- /dev/null
+++ b/tests/strategy/strats/hyperoptable_strategy.py
@@ -0,0 +1,170 @@
+# pragma pylint: disable=missing-docstring, invalid-name, pointless-string-statement
+
+import talib.abstract as ta
+from pandas import DataFrame
+
+import freqtrade.vendor.qtpylib.indicators as qtpylib
+from freqtrade.strategy import FloatParameter, IntParameter, IStrategy
+
+
+class HyperoptableStrategy(IStrategy):
+    """
+    Default Strategy provided by freqtrade bot.
+    Please do not modify this strategy, it's  intended for internal use only.
+    Please look at the SampleStrategy in the user_data/strategy directory
+    or strategy repository https://github.com/freqtrade/freqtrade-strategies
+    for samples and inspiration.
+    """
+    INTERFACE_VERSION = 2
+
+    # Minimal ROI designed for the strategy
+    minimal_roi = {
+        "40": 0.0,
+        "30": 0.01,
+        "20": 0.02,
+        "0": 0.04
+    }
+
+    # Optimal stoploss designed for the strategy
+    stoploss = -0.10
+
+    # Optimal ticker interval for the strategy
+    timeframe = '5m'
+
+    # Optional order type mapping
+    order_types = {
+        'buy': 'limit',
+        'sell': 'limit',
+        'stoploss': 'limit',
+        'stoploss_on_exchange': False
+    }
+
+    # Number of candles the strategy requires before producing valid signals
+    startup_candle_count: int = 20
+
+    # Optional time in force for orders
+    order_time_in_force = {
+        'buy': 'gtc',
+        'sell': 'gtc',
+    }
+
+    buy_params = {
+        'buy_rsi': 35,
+        # Intentionally not specified, so "default" is tested
+        # 'buy_plusdi': 0.4
+    }
+
+    sell_params = {
+        'sell_rsi': 74
+    }
+
+    buy_rsi = IntParameter([0, 50], default=30, space='buy')
+    buy_plusdi = FloatParameter(low=0, high=1, default=0.5, space='buy')
+    sell_rsi = IntParameter(low=50, high=100, default=70, space='sell')
+
+    def informative_pairs(self):
+        """
+        Define additional, informative pair/interval combinations to be cached from the exchange.
+        These pair/interval combinations are non-tradeable, unless they are part
+        of the whitelist as well.
+        For more information, please consult the documentation
+        :return: List of tuples in the format (pair, interval)
+            Sample: return [("ETH/USDT", "5m"),
+                            ("BTC/USDT", "15m"),
+                            ]
+        """
+        return []
+
+    def populate_indicators(self, dataframe: DataFrame, metadata: dict) -> 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.
+        :param dataframe: Dataframe with data from the exchange
+        :param metadata: Additional information, like the currently traded pair
+        :return: a Dataframe with all mandatory indicators for the strategies
+        """
+
+        # Momentum Indicator
+        # ------------------------------------
+
+        # ADX
+        dataframe['adx'] = ta.ADX(dataframe)
+
+        # MACD
+        macd = ta.MACD(dataframe)
+        dataframe['macd'] = macd['macd']
+        dataframe['macdsignal'] = macd['macdsignal']
+        dataframe['macdhist'] = macd['macdhist']
+
+        # Minus Directional Indicator / Movement
+        dataframe['minus_di'] = ta.MINUS_DI(dataframe)
+
+        # Plus Directional Indicator / Movement
+        dataframe['plus_di'] = ta.PLUS_DI(dataframe)
+
+        # RSI
+        dataframe['rsi'] = ta.RSI(dataframe)
+
+        # Stoch fast
+        stoch_fast = ta.STOCHF(dataframe)
+        dataframe['fastd'] = stoch_fast['fastd']
+        dataframe['fastk'] = stoch_fast['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['ema10'] = ta.EMA(dataframe, timeperiod=10)
+
+        return dataframe
+
+    def populate_buy_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
+        """
+        Based on TA indicators, populates the buy signal for the given dataframe
+        :param dataframe: DataFrame
+        :param metadata: Additional information, like the currently traded pair
+        :return: DataFrame with buy column
+        """
+        dataframe.loc[
+            (
+                (dataframe['rsi'] < self.buy_rsi.value) &
+                (dataframe['fastd'] < 35) &
+                (dataframe['adx'] > 30) &
+                (dataframe['plus_di'] > self.buy_plusdi.value)
+            ) |
+            (
+                (dataframe['adx'] > 65) &
+                (dataframe['plus_di'] > self.buy_plusdi.value)
+            ),
+            'buy'] = 1
+
+        return dataframe
+
+    def populate_sell_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
+        """
+        Based on TA indicators, populates the sell signal for the given dataframe
+        :param dataframe: DataFrame
+        :param metadata: Additional information, like the currently traded pair
+        :return: DataFrame with buy column
+        """
+        dataframe.loc[
+            (
+                (
+                    (qtpylib.crossed_above(dataframe['rsi'], self.sell_rsi.value)) |
+                    (qtpylib.crossed_above(dataframe['fastd'], 70))
+                ) &
+                (dataframe['adx'] > 10) &
+                (dataframe['minus_di'] > 0)
+            ) |
+            (
+                (dataframe['adx'] > 70) &
+                (dataframe['minus_di'] > 0.5)
+            ),
+            'sell'] = 1
+        return dataframe
diff --git a/tests/strategy/test_interface.py b/tests/strategy/test_interface.py
index f158a1518..9c831d194 100644
--- a/tests/strategy/test_interface.py
+++ b/tests/strategy/test_interface.py
@@ -1,4 +1,5 @@
 # pragma pylint: disable=missing-docstring, C0103
+from freqtrade.strategy.hyper import BaseParameter, FloatParameter, IntParameter
 import logging
 from datetime import datetime, timedelta, timezone
 from unittest.mock import MagicMock
@@ -10,7 +11,7 @@ from pandas import DataFrame
 from freqtrade.configuration import TimeRange
 from freqtrade.data.dataprovider import DataProvider
 from freqtrade.data.history import load_data
-from freqtrade.exceptions import StrategyError
+from freqtrade.exceptions import OperationalException, StrategyError
 from freqtrade.persistence import PairLocks, Trade
 from freqtrade.resolvers import StrategyResolver
 from freqtrade.strategy.interface import SellCheckTuple, SellType
@@ -552,3 +553,38 @@ def test_strategy_safe_wrapper(value):
 
     assert type(ret) == type(value)
     assert ret == value
+
+
+def test_hyperopt_parameters():
+    with pytest.raises(OperationalException, match=r"Name is determined.*"):
+        IntParameter(low=0, high=5, default=1, name='hello')
+
+    with pytest.raises(OperationalException, match=r"IntParameter space must be.*"):
+        IntParameter(low=0, default=5, space='buy')
+
+    with pytest.raises(OperationalException, match=r"FloatParameter space must be.*"):
+        FloatParameter(low=0, default=5, space='buy')
+
+    with pytest.raises(OperationalException, match=r"IntParameter space invalid\."):
+        IntParameter([0, 10], high=7, default=5, space='buy')
+
+    with pytest.raises(OperationalException, match=r"FloatParameter space invalid\."):
+        FloatParameter([0, 10], high=7, default=5, space='buy')
+
+    x = BaseParameter(opt_range=[0, 1], default=1, space='buy')
+    with pytest.raises(NotImplementedError):
+        x.get_space('space')
+
+    fltpar = IntParameter(low=0, high=5, default=1, space='buy')
+    assert fltpar.value == 1
+
+
+def test_auto_hyperopt_interface(default_conf):
+    default_conf.update({'strategy': 'HyperoptableStrategy'})
+    PairLocks.timeframe = default_conf['timeframe']
+    strategy = StrategyResolver.load_strategy(default_conf)
+
+    assert strategy.buy_rsi.value == strategy.buy_params['buy_rsi']
+    # PlusDI is NOT in the buy-params, so default should be used
+    assert strategy.buy_plusdi.value == 0.5
+    assert strategy.sell_rsi.value == strategy.sell_params['sell_rsi']
diff --git a/tests/strategy/test_strategy_loading.py b/tests/strategy/test_strategy_loading.py
index 1c692d2da..965c3d37b 100644
--- a/tests/strategy/test_strategy_loading.py
+++ b/tests/strategy/test_strategy_loading.py
@@ -35,7 +35,7 @@ def test_search_all_strategies_no_failed():
     directory = Path(__file__).parent / "strats"
     strategies = StrategyResolver.search_all_objects(directory, enum_failed=False)
     assert isinstance(strategies, list)
-    assert len(strategies) == 2
+    assert len(strategies) == 3
     assert isinstance(strategies[0], dict)
 
 
@@ -43,10 +43,10 @@ def test_search_all_strategies_with_failed():
     directory = Path(__file__).parent / "strats"
     strategies = StrategyResolver.search_all_objects(directory, enum_failed=True)
     assert isinstance(strategies, list)
-    assert len(strategies) == 3
+    assert len(strategies) == 4
     # with enum_failed=True search_all_objects() shall find 2 good strategies
     # and 1 which fails to load
-    assert len([x for x in strategies if x['class'] is not None]) == 2
+    assert len([x for x in strategies if x['class'] is not None]) == 3
     assert len([x for x in strategies if x['class'] is None]) == 1
 
 

From 4fd7bedcb28f98a8920e51b41a5b7300e62f85de Mon Sep 17 00:00:00 2001
From: Matthias <xmatthias@outlook.com>
Date: Sat, 27 Mar 2021 11:32:51 +0100
Subject: [PATCH 13/32] Sort imports ...

---
 tests/strategy/test_interface.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/strategy/test_interface.py b/tests/strategy/test_interface.py
index 9c831d194..5dd459238 100644
--- a/tests/strategy/test_interface.py
+++ b/tests/strategy/test_interface.py
@@ -1,5 +1,4 @@
 # pragma pylint: disable=missing-docstring, C0103
-from freqtrade.strategy.hyper import BaseParameter, FloatParameter, IntParameter
 import logging
 from datetime import datetime, timedelta, timezone
 from unittest.mock import MagicMock
@@ -14,6 +13,7 @@ from freqtrade.data.history import load_data
 from freqtrade.exceptions import OperationalException, StrategyError
 from freqtrade.persistence import PairLocks, Trade
 from freqtrade.resolvers import StrategyResolver
+from freqtrade.strategy.hyper import BaseParameter, FloatParameter, IntParameter
 from freqtrade.strategy.interface import SellCheckTuple, SellType
 from freqtrade.strategy.strategy_wrapper import strategy_safe_wrapper
 from tests.conftest import log_has, log_has_re

From 8022386404e4aca3fdad77e8c43464990eb11c0d Mon Sep 17 00:00:00 2001
From: Matthias <xmatthias@outlook.com>
Date: Sat, 27 Mar 2021 18:00:07 +0100
Subject: [PATCH 14/32] Type custom_hyperopt

---
 freqtrade/optimize/hyperopt.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/freqtrade/optimize/hyperopt.py b/freqtrade/optimize/hyperopt.py
index a680d85c8..f7c2da4ec 100644
--- a/freqtrade/optimize/hyperopt.py
+++ b/freqtrade/optimize/hyperopt.py
@@ -62,6 +62,7 @@ class Hyperopt:
     hyperopt = Hyperopt(config)
     hyperopt.start()
     """
+    custom_hyperopt: IHyperOpt
 
     def __init__(self, config: Dict[str, Any]) -> None:
         self.config = config

From 20f7e9b4b79dcc9db09592826289d7a030ec5558 Mon Sep 17 00:00:00 2001
From: Matthias <xmatthias@outlook.com>
Date: Sun, 28 Mar 2021 19:31:54 +0200
Subject: [PATCH 15/32] Make BaseParameter get_space abstract

---
 freqtrade/strategy/hyper.py      | 8 ++++++--
 tests/strategy/test_interface.py | 5 ++---
 2 files changed, 8 insertions(+), 5 deletions(-)

diff --git a/freqtrade/strategy/hyper.py b/freqtrade/strategy/hyper.py
index b8bfef767..461e6314f 100644
--- a/freqtrade/strategy/hyper.py
+++ b/freqtrade/strategy/hyper.py
@@ -3,6 +3,7 @@ IHyperStrategy interface, hyperoptable Parameter class.
 This module defines a base class for auto-hyperoptable strategies.
 """
 import logging
+from abc import ABC, abstractmethod
 from contextlib import suppress
 from typing import Any, Iterator, Optional, Sequence, Tuple, Union
 
@@ -16,7 +17,7 @@ from freqtrade.exceptions import OperationalException
 logger = logging.getLogger(__name__)
 
 
-class BaseParameter(object):
+class BaseParameter(ABC):
     """
     Defines a parameter that can be optimized by hyperopt.
     """
@@ -46,8 +47,11 @@ class BaseParameter(object):
     def __repr__(self):
         return f'{self.__class__.__name__}({self.value})'
 
+    @abstractmethod
     def get_space(self, name: str) -> Union['Integer', 'Real', 'Categorical']:
-        raise NotImplementedError()
+        """
+        Get-space - will be used by Hyperopt to get the hyperopt Space
+        """
 
 
 class IntParameter(BaseParameter):
diff --git a/tests/strategy/test_interface.py b/tests/strategy/test_interface.py
index 5dd459238..e9d57dd17 100644
--- a/tests/strategy/test_interface.py
+++ b/tests/strategy/test_interface.py
@@ -571,9 +571,8 @@ def test_hyperopt_parameters():
     with pytest.raises(OperationalException, match=r"FloatParameter space invalid\."):
         FloatParameter([0, 10], high=7, default=5, space='buy')
 
-    x = BaseParameter(opt_range=[0, 1], default=1, space='buy')
-    with pytest.raises(NotImplementedError):
-        x.get_space('space')
+    with pytest.raises(TypeError):
+        BaseParameter(opt_range=[0, 1], default=1, space='buy')
 
     fltpar = IntParameter(low=0, high=5, default=1, space='buy')
     assert fltpar.value == 1

From 929f3296079b4536bfb163b544dcf4ffda46f6ce Mon Sep 17 00:00:00 2001
From: Matthias <xmatthias@outlook.com>
Date: Sun, 28 Mar 2021 19:49:20 +0200
Subject: [PATCH 16/32] more tests

---
 freqtrade/strategy/hyper.py                   |  2 +-
 .../strategy/strats/hyperoptable_strategy.py  |  6 ++++--
 tests/strategy/test_interface.py              | 21 +++++++++++++++++--
 3 files changed, 24 insertions(+), 5 deletions(-)

diff --git a/freqtrade/strategy/hyper.py b/freqtrade/strategy/hyper.py
index 461e6314f..64e457d75 100644
--- a/freqtrade/strategy/hyper.py
+++ b/freqtrade/strategy/hyper.py
@@ -145,7 +145,7 @@ class CategoricalParameter(BaseParameter):
         """
         if len(categories) < 2:
             raise OperationalException(
-                'IntParameter space must be [a, b, ...] (at least two parameters)')
+                'CategoricalParameter space must be [a, b, ...] (at least two parameters)')
         super().__init__(opt_range=categories, default=default, space=space, enabled=enabled,
                          **kwargs)
 
diff --git a/tests/strategy/strats/hyperoptable_strategy.py b/tests/strategy/strats/hyperoptable_strategy.py
index 8cde28321..97d2092d4 100644
--- a/tests/strategy/strats/hyperoptable_strategy.py
+++ b/tests/strategy/strats/hyperoptable_strategy.py
@@ -55,12 +55,14 @@ class HyperoptableStrategy(IStrategy):
     }
 
     sell_params = {
-        'sell_rsi': 74
+        'sell_rsi': 74,
+        'sell_minusdi': 0.4
     }
 
     buy_rsi = IntParameter([0, 50], default=30, space='buy')
     buy_plusdi = FloatParameter(low=0, high=1, default=0.5, space='buy')
     sell_rsi = IntParameter(low=50, high=100, default=70, space='sell')
+    sell_minusdi = FloatParameter(low=0, high=1, default=0.5, space='sell', enabled=False)
 
     def informative_pairs(self):
         """
@@ -164,7 +166,7 @@ class HyperoptableStrategy(IStrategy):
             ) |
             (
                 (dataframe['adx'] > 70) &
-                (dataframe['minus_di'] > 0.5)
+                (dataframe['minus_di'] > self.sell_minusdi.value)
             ),
             'sell'] = 1
         return dataframe
diff --git a/tests/strategy/test_interface.py b/tests/strategy/test_interface.py
index e9d57dd17..72b78338d 100644
--- a/tests/strategy/test_interface.py
+++ b/tests/strategy/test_interface.py
@@ -13,7 +13,8 @@ from freqtrade.data.history import load_data
 from freqtrade.exceptions import OperationalException, StrategyError
 from freqtrade.persistence import PairLocks, Trade
 from freqtrade.resolvers import StrategyResolver
-from freqtrade.strategy.hyper import BaseParameter, FloatParameter, IntParameter
+from freqtrade.strategy.hyper import (BaseParameter, CategoricalParameter, FloatParameter,
+                                      IntParameter)
 from freqtrade.strategy.interface import SellCheckTuple, SellType
 from freqtrade.strategy.strategy_wrapper import strategy_safe_wrapper
 from tests.conftest import log_has, log_has_re
@@ -556,6 +557,7 @@ def test_strategy_safe_wrapper(value):
 
 
 def test_hyperopt_parameters():
+    from skopt.space import Categorical, Integer, Real
     with pytest.raises(OperationalException, match=r"Name is determined.*"):
         IntParameter(low=0, high=5, default=1, name='hello')
 
@@ -571,12 +573,24 @@ def test_hyperopt_parameters():
     with pytest.raises(OperationalException, match=r"FloatParameter space invalid\."):
         FloatParameter([0, 10], high=7, default=5, space='buy')
 
+    with pytest.raises(OperationalException, match=r"CategoricalParameter space must.*"):
+        CategoricalParameter(['aa'], default='aa', space='buy')
+
     with pytest.raises(TypeError):
         BaseParameter(opt_range=[0, 1], default=1, space='buy')
 
-    fltpar = IntParameter(low=0, high=5, default=1, space='buy')
+    intpar = IntParameter(low=0, high=5, default=1, space='buy')
+    assert intpar.value == 1
+    assert isinstance(intpar.get_space(''), Integer)
+
+    fltpar = FloatParameter(low=0.0, high=5.5, default=1.0, space='buy')
+    assert isinstance(fltpar.get_space(''), Real)
     assert fltpar.value == 1
 
+    catpar = CategoricalParameter(['buy_rsi', 'buy_macd', 'buy_none'], default='buy_macd', space='buy')
+    assert isinstance(catpar.get_space(''), Categorical)
+    assert catpar.value == 'buy_macd'
+
 
 def test_auto_hyperopt_interface(default_conf):
     default_conf.update({'strategy': 'HyperoptableStrategy'})
@@ -587,3 +601,6 @@ def test_auto_hyperopt_interface(default_conf):
     # PlusDI is NOT in the buy-params, so default should be used
     assert strategy.buy_plusdi.value == 0.5
     assert strategy.sell_rsi.value == strategy.sell_params['sell_rsi']
+
+    # Parameter is disabled - so value from sell_param dict will NOT be used.
+    assert strategy.sell_minusdi.value == 0.5

From 6954a1e02951e587cee1d6b8e46365913ace34cb Mon Sep 17 00:00:00 2001
From: Matthias <xmatthias@outlook.com>
Date: Mon, 29 Mar 2021 19:27:19 +0200
Subject: [PATCH 17/32] MOre tests for ParameterHyperopt

---
 tests/optimize/conftest.py       |  2 ++
 tests/optimize/test_hyperopt.py  | 17 +++++++++++++++++
 tests/strategy/test_interface.py |  3 ++-
 3 files changed, 21 insertions(+), 1 deletion(-)

diff --git a/tests/optimize/conftest.py b/tests/optimize/conftest.py
index df6f22e01..5c789ec1e 100644
--- a/tests/optimize/conftest.py
+++ b/tests/optimize/conftest.py
@@ -14,6 +14,7 @@ from tests.conftest import patch_exchange
 def hyperopt_conf(default_conf):
     hyperconf = deepcopy(default_conf)
     hyperconf.update({
+        'datadir': Path(default_conf['datadir']),
         'hyperopt': 'DefaultHyperOpt',
         'hyperopt_loss': 'ShortTradeDurHyperOptLoss',
                          'hyperopt_path': str(Path(__file__).parent / 'hyperopts'),
@@ -21,6 +22,7 @@ def hyperopt_conf(default_conf):
                          'timerange': None,
                          'spaces': ['default'],
                          'hyperopt_jobs': 1,
+        'hyperopt_min_trades': 1,
     })
     return hyperconf
 
diff --git a/tests/optimize/test_hyperopt.py b/tests/optimize/test_hyperopt.py
index 193d997db..36b6f1229 100644
--- a/tests/optimize/test_hyperopt.py
+++ b/tests/optimize/test_hyperopt.py
@@ -16,6 +16,7 @@ from freqtrade.commands.optimize_commands import setup_optimize_configuration, s
 from freqtrade.data.history import load_data
 from freqtrade.exceptions import OperationalException
 from freqtrade.optimize.hyperopt import Hyperopt
+from freqtrade.optimize.hyperopt_auto import HyperOptAuto
 from freqtrade.optimize.hyperopt_tools import HyperoptTools
 from freqtrade.resolvers.hyperopt_resolver import HyperOptResolver
 from freqtrade.state import RunMode
@@ -1089,3 +1090,19 @@ def test_print_epoch_details(capsys):
     assert '# ROI table:' in captured.out
     assert re.search(r'^\s+minimal_roi = \{$', captured.out, re.MULTILINE)
     assert re.search(r'^\s+\"90\"\:\s0.14,\s*$', captured.out, re.MULTILINE)
+
+
+def test_in_strategy_auto_hyperopt(mocker, hyperopt_conf, tmpdir) -> None:
+    # mocker.patch('freqtrade.optimize.hyperopt.dump', MagicMock())
+    # mocker.patch('freqtrade.optimize.hyperopt.file_dump_json')
+    (Path(tmpdir) / 'hyperopt_results').mkdir(parents=True)
+    # No hyperopt needed
+    del hyperopt_conf['hyperopt']
+    hyperopt_conf.update({
+        'strategy': 'HyperoptableStrategy',
+        'user_data_dir': Path(tmpdir),
+    })
+    hyperopt = Hyperopt(hyperopt_conf)
+    assert isinstance(hyperopt.custom_hyperopt, HyperOptAuto)
+
+    hyperopt.start()
diff --git a/tests/strategy/test_interface.py b/tests/strategy/test_interface.py
index 72b78338d..4d93f7049 100644
--- a/tests/strategy/test_interface.py
+++ b/tests/strategy/test_interface.py
@@ -587,7 +587,8 @@ def test_hyperopt_parameters():
     assert isinstance(fltpar.get_space(''), Real)
     assert fltpar.value == 1
 
-    catpar = CategoricalParameter(['buy_rsi', 'buy_macd', 'buy_none'], default='buy_macd', space='buy')
+    catpar = CategoricalParameter(['buy_rsi', 'buy_macd', 'buy_none'],
+                                  default='buy_macd', space='buy')
     assert isinstance(catpar.get_space(''), Categorical)
     assert catpar.value == 'buy_macd'
 

From 5e5b11d4d60c6f7f8544e8f1cd8064df01f18a6d Mon Sep 17 00:00:00 2001
From: Rokas Kupstys <rokups@zoho.com>
Date: Wed, 31 Mar 2021 12:31:28 +0300
Subject: [PATCH 18/32] Split "enabled" to "load" and "optimize" parameters.

---
 freqtrade/optimize/hyperopt_auto.py |  8 ++++---
 freqtrade/strategy/hyper.py         | 36 ++++++++++++++++++-----------
 2 files changed, 27 insertions(+), 17 deletions(-)

diff --git a/freqtrade/optimize/hyperopt_auto.py b/freqtrade/optimize/hyperopt_auto.py
index 847d8697a..0e3cf7eac 100644
--- a/freqtrade/optimize/hyperopt_auto.py
+++ b/freqtrade/optimize/hyperopt_auto.py
@@ -25,7 +25,8 @@ class HyperOptAuto(IHyperOpt):
     def buy_strategy_generator(self, params: Dict[str, Any]) -> Callable:
         def populate_buy_trend(dataframe: DataFrame, metadata: dict):
             for attr_name, attr in self.strategy.enumerate_parameters('buy'):
-                attr.value = params[attr_name]
+                if attr.optimize:
+                    attr.value = params[attr_name]
             return self.strategy.populate_buy_trend(dataframe, metadata)
 
         return populate_buy_trend
@@ -33,7 +34,8 @@ class HyperOptAuto(IHyperOpt):
     def sell_strategy_generator(self, params: Dict[str, Any]) -> Callable:
         def populate_buy_trend(dataframe: DataFrame, metadata: dict):
             for attr_name, attr in self.strategy.enumerate_parameters('sell'):
-                attr.value = params[attr_name]
+                if attr.optimize:
+                    attr.value = params[attr_name]
             return self.strategy.populate_sell_trend(dataframe, metadata)
 
         return populate_buy_trend
@@ -53,7 +55,7 @@ class HyperOptAuto(IHyperOpt):
 
     def _generate_indicator_space(self, category):
         for attr_name, attr in self.strategy.enumerate_parameters(category):
-            if attr.enabled:
+            if attr.optimize:
                 yield attr.get_space(attr_name)
 
     def _get_indicator_space(self, category, fallback_method_name):
diff --git a/freqtrade/strategy/hyper.py b/freqtrade/strategy/hyper.py
index 64e457d75..c06ae36da 100644
--- a/freqtrade/strategy/hyper.py
+++ b/freqtrade/strategy/hyper.py
@@ -27,12 +27,14 @@ class BaseParameter(ABC):
     opt_range: Sequence[Any]
 
     def __init__(self, *, opt_range: Sequence[Any], default: Any, space: Optional[str] = None,
-                 enabled: bool = True, **kwargs):
+                 optimize: bool = True, load: bool = True, **kwargs):
         """
         Initialize hyperopt-optimizable parameter.
         :param space: A parameter category. Can be 'buy' or 'sell'. This parameter is optional if
          parameter field
          name is prefixed with 'buy_' or 'sell_'.
+        :param optimize: Include parameter in hyperopt optimizations.
+        :param load: Load parameter value from {space}_params.
         :param kwargs: Extra parameters to skopt.space.(Integer|Real|Categorical).
         """
         if 'name' in kwargs:
@@ -42,7 +44,8 @@ class BaseParameter(ABC):
         self._space_params = kwargs
         self.value = default
         self.opt_range = opt_range
-        self.enabled = enabled
+        self.optimize = optimize
+        self.load = load
 
     def __repr__(self):
         return f'{self.__class__.__name__}({self.value})'
@@ -60,7 +63,7 @@ class IntParameter(BaseParameter):
     opt_range: Sequence[int]
 
     def __init__(self, low: Union[int, Sequence[int]], high: Optional[int] = None, *, default: int,
-                 space: Optional[str] = None, enabled: bool = True, **kwargs):
+                 space: Optional[str] = None, optimize: bool = True, load: bool = True, **kwargs):
         """
         Initialize hyperopt-optimizable parameter.
         :param low: Lower end (inclusive) of optimization space or [low, high].
@@ -69,6 +72,8 @@ class IntParameter(BaseParameter):
         :param default: A default value.
         :param space: A parameter category. Can be 'buy' or 'sell'. This parameter is optional if
                       parameter fieldname is prefixed with 'buy_' or 'sell_'.
+        :param optimize: Include parameter in hyperopt optimizations.
+        :param load: Load parameter value from {space}_params.
         :param kwargs: Extra parameters to skopt.space.Integer.
         """
         if high is not None and isinstance(low, Sequence):
@@ -79,8 +84,8 @@ class IntParameter(BaseParameter):
             opt_range = low
         else:
             opt_range = [low, high]
-        super().__init__(opt_range=opt_range, default=default, space=space, enabled=enabled,
-                         **kwargs)
+        super().__init__(opt_range=opt_range, default=default, space=space, optimize=optimize,
+                         load=load, **kwargs)
 
     def get_space(self, name: str) -> 'Integer':
         """
@@ -96,7 +101,7 @@ class FloatParameter(BaseParameter):
     opt_range: Sequence[float]
 
     def __init__(self, low: Union[float, Sequence[float]], high: Optional[float] = None, *,
-                 default: float, space: Optional[str] = None, enabled: bool = True, **kwargs):
+                 default: float, space: Optional[str] = None, optimize: bool = True, load: bool = True, **kwargs):
         """
         Initialize hyperopt-optimizable parameter.
         :param low: Lower end (inclusive) of optimization space or [low, high].
@@ -105,6 +110,8 @@ class FloatParameter(BaseParameter):
         :param default: A default value.
         :param space: A parameter category. Can be 'buy' or 'sell'. This parameter is optional if
                       parameter fieldname is prefixed with 'buy_' or 'sell_'.
+        :param optimize: Include parameter in hyperopt optimizations.
+        :param load: Load parameter value from {space}_params.
         :param kwargs: Extra parameters to skopt.space.Real.
         """
         if high is not None and isinstance(low, Sequence):
@@ -115,8 +122,8 @@ class FloatParameter(BaseParameter):
             opt_range = low
         else:
             opt_range = [low, high]
-        super().__init__(opt_range=opt_range, default=default, space=space, enabled=enabled,
-                         **kwargs)
+        super().__init__(opt_range=opt_range, default=default, space=space, optimize=optimize,
+                         load=load, **kwargs)
 
     def get_space(self, name: str) -> 'Real':
         """
@@ -132,7 +139,7 @@ class CategoricalParameter(BaseParameter):
     opt_range: Sequence[Any]
 
     def __init__(self, categories: Sequence[Any], *, default: Optional[Any] = None,
-                 space: Optional[str] = None, enabled: bool = True, **kwargs):
+                 space: Optional[str] = None, optimize: bool = True, load: bool = True, **kwargs):
         """
         Initialize hyperopt-optimizable parameter.
         :param categories: Optimization space, [a, b, ...].
@@ -141,13 +148,15 @@ class CategoricalParameter(BaseParameter):
         :param space: A parameter category. Can be 'buy' or 'sell'. This parameter is optional if
          parameter field
          name is prefixed with 'buy_' or 'sell_'.
+        :param optimize: Include parameter in hyperopt optimizations.
+        :param load: Load parameter value from {space}_params.
         :param kwargs: Extra parameters to skopt.space.Categorical.
         """
         if len(categories) < 2:
             raise OperationalException(
                 'CategoricalParameter space must be [a, b, ...] (at least two parameters)')
-        super().__init__(opt_range=categories, default=default, space=space, enabled=enabled,
-                         **kwargs)
+        super().__init__(opt_range=categories, default=default, space=space, optimize=optimize,
+                         load=load, **kwargs)
 
     def get_space(self, name: str) -> 'Categorical':
         """
@@ -184,8 +193,7 @@ class HyperStrategyMixin(object):
                 if issubclass(attr.__class__, BaseParameter):
                     if category is None or category == attr.category or \
                        attr_name.startswith(category + '_'):
-                        if attr.enabled:
-                            yield attr_name, attr
+                        yield attr_name, attr
 
     def _load_params(self, params: dict) -> None:
         """
@@ -196,7 +204,7 @@ class HyperStrategyMixin(object):
             return
         for attr_name, attr in self.enumerate_parameters():
             if attr_name in params:
-                if attr.enabled:
+                if attr.load:
                     attr.value = params[attr_name]
                     logger.info(f'attr_name = {attr.value}')
                 else:

From 5acdc9bf424e6c46329a5f886182b5317321846a Mon Sep 17 00:00:00 2001
From: Matthias <xmatthias@outlook.com>
Date: Thu, 1 Apr 2021 06:47:23 +0200
Subject: [PATCH 19/32] Fix type errors by converting all hyperopt methods to
 instance methods

---
 freqtrade/optimize/hyperopt_interface.py | 33 +++++++++---------------
 freqtrade/strategy/hyper.py              |  3 ++-
 2 files changed, 14 insertions(+), 22 deletions(-)

diff --git a/freqtrade/optimize/hyperopt_interface.py b/freqtrade/optimize/hyperopt_interface.py
index 561fb8e11..e951efddd 100644
--- a/freqtrade/optimize/hyperopt_interface.py
+++ b/freqtrade/optimize/hyperopt_interface.py
@@ -44,36 +44,31 @@ class IHyperOpt(ABC):
         IHyperOpt.ticker_interval = str(config['timeframe'])  # DEPRECATED
         IHyperOpt.timeframe = str(config['timeframe'])
 
-    @staticmethod
-    def buy_strategy_generator(params: Dict[str, Any]) -> Callable:
+    def buy_strategy_generator(self, params: Dict[str, Any]) -> Callable:
         """
         Create a buy strategy generator.
         """
         raise OperationalException(_format_exception_message('buy_strategy_generator', 'buy'))
 
-    @staticmethod
-    def sell_strategy_generator(params: Dict[str, Any]) -> Callable:
+    def sell_strategy_generator(self, params: Dict[str, Any]) -> Callable:
         """
         Create a sell strategy generator.
         """
         raise OperationalException(_format_exception_message('sell_strategy_generator', 'sell'))
 
-    @staticmethod
-    def indicator_space() -> List[Dimension]:
+    def indicator_space(self) -> List[Dimension]:
         """
         Create an indicator space.
         """
         raise OperationalException(_format_exception_message('indicator_space', 'buy'))
 
-    @staticmethod
-    def sell_indicator_space() -> List[Dimension]:
+    def sell_indicator_space(self) -> List[Dimension]:
         """
         Create a sell indicator space.
         """
         raise OperationalException(_format_exception_message('sell_indicator_space', 'sell'))
 
-    @staticmethod
-    def generate_roi_table(params: Dict) -> Dict[int, float]:
+    def generate_roi_table(self, params: Dict) -> Dict[int, float]:
         """
         Create a ROI table.
 
@@ -88,8 +83,7 @@ class IHyperOpt(ABC):
 
         return roi_table
 
-    @staticmethod
-    def roi_space() -> List[Dimension]:
+    def roi_space(self) -> List[Dimension]:
         """
         Create a ROI space.
 
@@ -109,7 +103,7 @@ class IHyperOpt(ABC):
         roi_t_alpha = 1.0
         roi_p_alpha = 1.0
 
-        timeframe_min = timeframe_to_minutes(IHyperOpt.ticker_interval)
+        timeframe_min = timeframe_to_minutes(self.ticker_interval)
 
         # We define here limits for the ROI space parameters automagically adapted to the
         # timeframe used by the bot:
@@ -145,7 +139,7 @@ class IHyperOpt(ABC):
             'roi_p2': roi_limits['roi_p2_min'],
             'roi_p3': roi_limits['roi_p3_min'],
         }
-        logger.info(f"Min roi table: {round_dict(IHyperOpt.generate_roi_table(p), 5)}")
+        logger.info(f"Min roi table: {round_dict(self.generate_roi_table(p), 5)}")
         p = {
             'roi_t1': roi_limits['roi_t1_max'],
             'roi_t2': roi_limits['roi_t2_max'],
@@ -154,7 +148,7 @@ class IHyperOpt(ABC):
             'roi_p2': roi_limits['roi_p2_max'],
             'roi_p3': roi_limits['roi_p3_max'],
         }
-        logger.info(f"Max roi table: {round_dict(IHyperOpt.generate_roi_table(p), 5)}")
+        logger.info(f"Max roi table: {round_dict(self.generate_roi_table(p), 5)}")
 
         return [
             Integer(roi_limits['roi_t1_min'], roi_limits['roi_t1_max'], name='roi_t1'),
@@ -165,8 +159,7 @@ class IHyperOpt(ABC):
             Real(roi_limits['roi_p3_min'], roi_limits['roi_p3_max'], name='roi_p3'),
         ]
 
-    @staticmethod
-    def stoploss_space() -> List[Dimension]:
+    def stoploss_space(self) -> List[Dimension]:
         """
         Create a stoploss space.
 
@@ -177,8 +170,7 @@ class IHyperOpt(ABC):
             Real(-0.35, -0.02, name='stoploss'),
         ]
 
-    @staticmethod
-    def generate_trailing_params(params: Dict) -> Dict:
+    def generate_trailing_params(self, params: Dict) -> Dict:
         """
         Create dict with trailing stop parameters.
         """
@@ -190,8 +182,7 @@ class IHyperOpt(ABC):
             'trailing_only_offset_is_reached': params['trailing_only_offset_is_reached'],
         }
 
-    @staticmethod
-    def trailing_space() -> List[Dimension]:
+    def trailing_space(self) -> List[Dimension]:
         """
         Create a trailing stoploss space.
 
diff --git a/freqtrade/strategy/hyper.py b/freqtrade/strategy/hyper.py
index c06ae36da..a6603ecbf 100644
--- a/freqtrade/strategy/hyper.py
+++ b/freqtrade/strategy/hyper.py
@@ -101,7 +101,8 @@ class FloatParameter(BaseParameter):
     opt_range: Sequence[float]
 
     def __init__(self, low: Union[float, Sequence[float]], high: Optional[float] = None, *,
-                 default: float, space: Optional[str] = None, optimize: bool = True, load: bool = True, **kwargs):
+                 default: float, space: Optional[str] = None,
+                 optimize: bool = True, load: bool = True, **kwargs):
         """
         Initialize hyperopt-optimizable parameter.
         :param low: Lower end (inclusive) of optimization space or [low, high].

From d64295ba24a13958d4d79c7dd8dfb6134b83b85b Mon Sep 17 00:00:00 2001
From: Matthias <xmatthias@outlook.com>
Date: Thu, 1 Apr 2021 06:55:25 +0200
Subject: [PATCH 20/32] Adapt test strategy to new parameters

---
 tests/strategy/strats/hyperoptable_strategy.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/strategy/strats/hyperoptable_strategy.py b/tests/strategy/strats/hyperoptable_strategy.py
index 97d2092d4..a08293058 100644
--- a/tests/strategy/strats/hyperoptable_strategy.py
+++ b/tests/strategy/strats/hyperoptable_strategy.py
@@ -62,7 +62,7 @@ class HyperoptableStrategy(IStrategy):
     buy_rsi = IntParameter([0, 50], default=30, space='buy')
     buy_plusdi = FloatParameter(low=0, high=1, default=0.5, space='buy')
     sell_rsi = IntParameter(low=50, high=100, default=70, space='sell')
-    sell_minusdi = FloatParameter(low=0, high=1, default=0.5, space='sell', enabled=False)
+    sell_minusdi = FloatParameter(low=0, high=1, default=0.5, space='sell', load=False)
 
     def informative_pairs(self):
         """

From ea43d5ba85caf490604d02a6abae8e620324f034 Mon Sep 17 00:00:00 2001
From: Rokas Kupstys <rokups@zoho.com>
Date: Thu, 1 Apr 2021 10:17:39 +0300
Subject: [PATCH 21/32] Implement DecimalParameter and rename FloatParameter to
 RealParameter.

---
 freqtrade/optimize/hyperopt_auto.py           |  6 +-
 freqtrade/strategy/__init__.py                |  3 +-
 freqtrade/strategy/hyper.py                   | 66 +++++++++++++++++--
 .../strategy/strats/hyperoptable_strategy.py  |  7 +-
 tests/strategy/test_interface.py              | 26 ++++++--
 5 files changed, 88 insertions(+), 20 deletions(-)

diff --git a/freqtrade/optimize/hyperopt_auto.py b/freqtrade/optimize/hyperopt_auto.py
index 0e3cf7eac..ed6f2d6f7 100644
--- a/freqtrade/optimize/hyperopt_auto.py
+++ b/freqtrade/optimize/hyperopt_auto.py
@@ -26,7 +26,8 @@ class HyperOptAuto(IHyperOpt):
         def populate_buy_trend(dataframe: DataFrame, metadata: dict):
             for attr_name, attr in self.strategy.enumerate_parameters('buy'):
                 if attr.optimize:
-                    attr.value = params[attr_name]
+                    # noinspection PyProtectedMember
+                    attr._set_value(params[attr_name])
             return self.strategy.populate_buy_trend(dataframe, metadata)
 
         return populate_buy_trend
@@ -35,7 +36,8 @@ class HyperOptAuto(IHyperOpt):
         def populate_buy_trend(dataframe: DataFrame, metadata: dict):
             for attr_name, attr in self.strategy.enumerate_parameters('sell'):
                 if attr.optimize:
-                    attr.value = params[attr_name]
+                    # noinspection PyProtectedMember
+                    attr._set_value(params[attr_name])
             return self.strategy.populate_sell_trend(dataframe, metadata)
 
         return populate_buy_trend
diff --git a/freqtrade/strategy/__init__.py b/freqtrade/strategy/__init__.py
index bc0c45f7c..bd49165df 100644
--- a/freqtrade/strategy/__init__.py
+++ b/freqtrade/strategy/__init__.py
@@ -1,6 +1,7 @@
 # flake8: noqa: F401
 from freqtrade.exchange import (timeframe_to_minutes, timeframe_to_msecs, timeframe_to_next_date,
                                 timeframe_to_prev_date, timeframe_to_seconds)
-from freqtrade.strategy.hyper import CategoricalParameter, FloatParameter, IntParameter
+from freqtrade.strategy.hyper import (CategoricalParameter, DecimalParameter, IntParameter,
+                                      RealParameter)
 from freqtrade.strategy.interface import IStrategy
 from freqtrade.strategy.strategy_helper import merge_informative_pair, stoploss_from_open
diff --git a/freqtrade/strategy/hyper.py b/freqtrade/strategy/hyper.py
index a6603ecbf..e58aac273 100644
--- a/freqtrade/strategy/hyper.py
+++ b/freqtrade/strategy/hyper.py
@@ -56,6 +56,14 @@ class BaseParameter(ABC):
         Get-space - will be used by Hyperopt to get the hyperopt Space
         """
 
+    def _set_value(self, value: Any):
+        """
+        Update current value. Used by hyperopt functions for the purpose where optimization and
+         value spaces differ.
+        :param value: A numerical value.
+        """
+        self.value = value
+
 
 class IntParameter(BaseParameter):
     default: int
@@ -65,7 +73,7 @@ class IntParameter(BaseParameter):
     def __init__(self, low: Union[int, Sequence[int]], high: Optional[int] = None, *, default: int,
                  space: Optional[str] = None, optimize: bool = True, load: bool = True, **kwargs):
         """
-        Initialize hyperopt-optimizable parameter.
+        Initialize hyperopt-optimizable integer parameter.
         :param low: Lower end (inclusive) of optimization space or [low, high].
         :param high: Upper end (inclusive) of optimization space.
                      Must be none of entire range is passed first parameter.
@@ -95,16 +103,16 @@ class IntParameter(BaseParameter):
         return Integer(*self.opt_range, name=name, **self._space_params)
 
 
-class FloatParameter(BaseParameter):
+class RealParameter(BaseParameter):
     default: float
     value: float
     opt_range: Sequence[float]
 
     def __init__(self, low: Union[float, Sequence[float]], high: Optional[float] = None, *,
-                 default: float, space: Optional[str] = None,
-                 optimize: bool = True, load: bool = True, **kwargs):
+                 default: float, space: Optional[str] = None, optimize: bool = True,
+                 load: bool = True, **kwargs):
         """
-        Initialize hyperopt-optimizable parameter.
+        Initialize hyperopt-optimizable floating point parameter with unlimited precision.
         :param low: Lower end (inclusive) of optimization space or [low, high].
         :param high: Upper end (inclusive) of optimization space.
                      Must be none if entire range is passed first parameter.
@@ -116,10 +124,10 @@ class FloatParameter(BaseParameter):
         :param kwargs: Extra parameters to skopt.space.Real.
         """
         if high is not None and isinstance(low, Sequence):
-            raise OperationalException('FloatParameter space invalid.')
+            raise OperationalException(f'{self.__class__.__name__} space invalid.')
         if high is None or isinstance(low, Sequence):
             if not isinstance(low, Sequence) or len(low) != 2:
-                raise OperationalException('FloatParameter space must be [low, high]')
+                raise OperationalException(f'{self.__class__.__name__} space must be [low, high]')
             opt_range = low
         else:
             opt_range = [low, high]
@@ -134,6 +142,50 @@ class FloatParameter(BaseParameter):
         return Real(*self.opt_range, name=name, **self._space_params)
 
 
+class DecimalParameter(RealParameter):
+    default: float
+    value: float
+    opt_range: Sequence[float]
+
+    def __init__(self, low: Union[float, Sequence[float]], high: Optional[float] = None, *,
+                 default: float, decimals: int = 3, space: Optional[str] = None,
+                 optimize: bool = True, load: bool = True, **kwargs):
+        """
+        Initialize hyperopt-optimizable decimal parameter with a limited precision.
+        :param low: Lower end (inclusive) of optimization space or [low, high].
+        :param high: Upper end (inclusive) of optimization space.
+                     Must be none if entire range is passed first parameter.
+        :param default: A default value.
+        :param decimals: A number of decimals after floating point to be included in testing.
+        :param space: A parameter category. Can be 'buy' or 'sell'. This parameter is optional if
+                      parameter fieldname is prefixed with 'buy_' or 'sell_'.
+        :param optimize: Include parameter in hyperopt optimizations.
+        :param load: Load parameter value from {space}_params.
+        :param kwargs: Extra parameters to skopt.space.Real.
+        """
+        self._decimals = decimals
+        default = round(default, self._decimals)
+        super().__init__(low=low, high=high, default=default, space=space, optimize=optimize,
+                         load=load, **kwargs)
+
+    def get_space(self, name: str) -> 'Integer':
+        """
+        Create skopt optimization space.
+        :param name: A name of parameter field.
+        """
+        low = int(self.opt_range[0] * pow(10, self._decimals))
+        high = int(self.opt_range[1] * pow(10, self._decimals))
+        return Integer(low, high, name=name, **self._space_params)
+
+    def _set_value(self, value: int):
+        """
+        Update current value. Used by hyperopt functions for the purpose where optimization and
+         value spaces differ.
+        :param value: An integer value.
+        """
+        self.value = round(value * pow(0.1, self._decimals), self._decimals)
+
+
 class CategoricalParameter(BaseParameter):
     default: Any
     value: Any
diff --git a/tests/strategy/strats/hyperoptable_strategy.py b/tests/strategy/strats/hyperoptable_strategy.py
index a08293058..cc4734e13 100644
--- a/tests/strategy/strats/hyperoptable_strategy.py
+++ b/tests/strategy/strats/hyperoptable_strategy.py
@@ -4,7 +4,7 @@ import talib.abstract as ta
 from pandas import DataFrame
 
 import freqtrade.vendor.qtpylib.indicators as qtpylib
-from freqtrade.strategy import FloatParameter, IntParameter, IStrategy
+from freqtrade.strategy import DecimalParameter, IntParameter, IStrategy, RealParameter
 
 
 class HyperoptableStrategy(IStrategy):
@@ -60,9 +60,10 @@ class HyperoptableStrategy(IStrategy):
     }
 
     buy_rsi = IntParameter([0, 50], default=30, space='buy')
-    buy_plusdi = FloatParameter(low=0, high=1, default=0.5, space='buy')
+    buy_plusdi = RealParameter(low=0, high=1, default=0.5, space='buy')
     sell_rsi = IntParameter(low=50, high=100, default=70, space='sell')
-    sell_minusdi = FloatParameter(low=0, high=1, default=0.5, space='sell', load=False)
+    sell_minusdi = DecimalParameter(low=0, high=1, default=0.5001, decimals=3, space='sell',
+                                    load=False)
 
     def informative_pairs(self):
         """
diff --git a/tests/strategy/test_interface.py b/tests/strategy/test_interface.py
index 4d93f7049..71f877cc3 100644
--- a/tests/strategy/test_interface.py
+++ b/tests/strategy/test_interface.py
@@ -13,8 +13,8 @@ from freqtrade.data.history import load_data
 from freqtrade.exceptions import OperationalException, StrategyError
 from freqtrade.persistence import PairLocks, Trade
 from freqtrade.resolvers import StrategyResolver
-from freqtrade.strategy.hyper import (BaseParameter, CategoricalParameter, FloatParameter,
-                                      IntParameter)
+from freqtrade.strategy.hyper import (BaseParameter, CategoricalParameter, DecimalParameter,
+                                      IntParameter, RealParameter)
 from freqtrade.strategy.interface import SellCheckTuple, SellType
 from freqtrade.strategy.strategy_wrapper import strategy_safe_wrapper
 from tests.conftest import log_has, log_has_re
@@ -564,14 +564,20 @@ def test_hyperopt_parameters():
     with pytest.raises(OperationalException, match=r"IntParameter space must be.*"):
         IntParameter(low=0, default=5, space='buy')
 
-    with pytest.raises(OperationalException, match=r"FloatParameter space must be.*"):
-        FloatParameter(low=0, default=5, space='buy')
+    with pytest.raises(OperationalException, match=r"RealParameter space must be.*"):
+        RealParameter(low=0, default=5, space='buy')
+
+    with pytest.raises(OperationalException, match=r"DecimalParameter space must be.*"):
+        DecimalParameter(low=0, default=5, space='buy')
 
     with pytest.raises(OperationalException, match=r"IntParameter space invalid\."):
         IntParameter([0, 10], high=7, default=5, space='buy')
 
-    with pytest.raises(OperationalException, match=r"FloatParameter space invalid\."):
-        FloatParameter([0, 10], high=7, default=5, space='buy')
+    with pytest.raises(OperationalException, match=r"RealParameter space invalid\."):
+        RealParameter([0, 10], high=7, default=5, space='buy')
+
+    with pytest.raises(OperationalException, match=r"DecimalParameter space invalid\."):
+        DecimalParameter([0, 10], high=7, default=5, space='buy')
 
     with pytest.raises(OperationalException, match=r"CategoricalParameter space must.*"):
         CategoricalParameter(['aa'], default='aa', space='buy')
@@ -583,10 +589,16 @@ def test_hyperopt_parameters():
     assert intpar.value == 1
     assert isinstance(intpar.get_space(''), Integer)
 
-    fltpar = FloatParameter(low=0.0, high=5.5, default=1.0, space='buy')
+    fltpar = RealParameter(low=0.0, high=5.5, default=1.0, space='buy')
     assert isinstance(fltpar.get_space(''), Real)
     assert fltpar.value == 1
 
+    fltpar = DecimalParameter(low=0.0, high=5.5, default=1.0004, decimals=3, space='buy')
+    assert isinstance(fltpar.get_space(''), Integer)
+    assert fltpar.value == 1
+    fltpar._set_value(2222)
+    assert fltpar.value == 2.222
+
     catpar = CategoricalParameter(['buy_rsi', 'buy_macd', 'buy_none'],
                                   default='buy_macd', space='buy')
     assert isinstance(catpar.get_space(''), Categorical)

From 23c19b6852f62026f80366bde35ad7f8254f61b1 Mon Sep 17 00:00:00 2001
From: Rokas Kupstys <rokups@zoho.com>
Date: Sat, 3 Apr 2021 11:17:18 +0300
Subject: [PATCH 22/32] New hyperopt documentation.

---
 docs/hyperopt.md        | 283 +++++++++---------
 docs/hyperopt_legacy.md | 629 ++++++++++++++++++++++++++++++++++++++++
 2 files changed, 759 insertions(+), 153 deletions(-)
 create mode 100644 docs/hyperopt_legacy.md

diff --git a/docs/hyperopt.md b/docs/hyperopt.md
index 69bc57d1a..e9d440a5a 100644
--- a/docs/hyperopt.md
+++ b/docs/hyperopt.md
@@ -14,6 +14,9 @@ To learn how to get data for the pairs and exchange you're interested in, head o
 !!! Bug
     Hyperopt can crash when used with only 1 CPU Core as found out in [Issue #1133](https://github.com/freqtrade/freqtrade/issues/1133)
 
+!!! Note
+    Since 2021.4 release you no longer have to write a separate hyperopt class. Legacy method is still supported, but it is no longer a preferred way of hyperopting. Legacy documentation is available at [Legacy Hyperopt](hyperopt_legacy.md).
+
 ## Install hyperopt dependencies
 
 Since Hyperopt dependencies are not needed to run the bot itself, are heavy, can not be easily built on some platforms (like Raspberry PI), they are not installed by default. Before you run Hyperopt, you need to install the corresponding dependencies, as described in this section below.
@@ -137,47 +140,19 @@ Strategy arguments:
 
 ```
 
-## Prepare Hyperopting
-
-Before we start digging into Hyperopt, we recommend you to take a look at
-the sample hyperopt file located in [user_data/hyperopts/](https://github.com/freqtrade/freqtrade/blob/develop/freqtrade/templates/sample_hyperopt.py).
-
-Configuring hyperopt is similar to writing your own strategy, and many tasks will be similar.
-
-!!! Tip "About this page"
-    For this page, we will be using a fictional strategy called `AwesomeStrategy` - which will be optimized using the `AwesomeHyperopt` class.
-
-The simplest way to get started is to use the following, command, which will create a new hyperopt file from a template, which will be located under `user_data/hyperopts/AwesomeHyperopt.py`.
-
-``` bash
-freqtrade new-hyperopt --hyperopt AwesomeHyperopt
-```
-
 ### Hyperopt checklist
 
 Checklist on all tasks / possibilities in hyperopt
 
 Depending on the space you want to optimize, only some of the below are required:
 
-* fill `buy_strategy_generator` - for buy signal optimization
-* fill `indicator_space` - for buy signal optimization
-* fill `sell_strategy_generator` - for sell signal optimization
-* fill `sell_indicator_space` - for sell signal optimization
+* define parameters with `space='buy'` - for buy signal optimization
+* define parameters with `space='sell'` - for sell signal optimization
 
 !!! Note
     `populate_indicators` needs to create all indicators any of thee spaces may use, otherwise hyperopt will not work.
 
-Optional in hyperopt - can also be loaded from a strategy (recommended):
-
-* `populate_indicators` - fallback to create indicators
-* `populate_buy_trend` - fallback if not optimizing for buy space. should come from strategy
-* `populate_sell_trend` - fallback if not optimizing for sell space. should come from strategy
-
-!!! Note
-    You always have to provide a strategy to Hyperopt, even if your custom Hyperopt class contains all methods.
-    Assuming the optional methods are not in your hyperopt file, please use `--strategy AweSomeStrategy` which contains these methods so hyperopt can use these methods instead.
-
-Rarely you may also need to override:
+Rarely you may also need to create a nested class named `HyperOpt` and implement:
 
 * `roi_space` - for custom ROI optimization (if you need the ranges for the ROI parameters in the optimization hyperspace that differ from default)
 * `generate_roi_table` - for custom ROI optimization (if you need the ranges for the values in the ROI table that differ from default or the number of entries (steps) in the ROI table which differs from the default 4 steps)
@@ -185,31 +160,19 @@ Rarely you may also need to override:
 * `trailing_space` - for custom trailing stop optimization (if you need the ranges for the trailing stop parameters in the optimization hyperspace that differ from default)
 
 !!! Tip "Quickly optimize ROI, stoploss and trailing stoploss"
-    You can quickly optimize the spaces `roi`, `stoploss` and `trailing` without changing anything (i.e. without creation of a "complete" Hyperopt class with dimensions, parameters, triggers and guards, as described in this document) from the default hyperopt template by relying on your strategy to do most of the calculations.
+    You can quickly optimize the spaces `roi`, `stoploss` and `trailing` without changing anything in your strategy.
 
     ```python
     # Have a working strategy at hand.
-    freqtrade new-hyperopt --hyperopt EmptyHyperopt
-
-    freqtrade hyperopt --hyperopt EmptyHyperopt --hyperopt-loss SharpeHyperOptLossDaily --spaces roi stoploss trailing --strategy MyWorkingStrategy --config config.json -e 100
+    freqtrade hyperopt --hyperopt-loss SharpeHyperOptLossDaily --spaces roi stoploss trailing --strategy MyWorkingStrategy --config config.json -e 100
     ```
 
-### Create a Custom Hyperopt File
-
-Let assume you want a hyperopt file `AwesomeHyperopt.py`:  
-
-``` bash
-freqtrade new-hyperopt --hyperopt AwesomeHyperopt
-```
-
-This command will create a new hyperopt file from a template, allowing you to get started quickly.
-
 ### Configure your Guards and Triggers
 
-There are two places you need to change in your hyperopt file to add a new buy hyperopt for testing:
+There are two places you need to change in your strategy file to add a new buy hyperopt for testing:
 
-* Inside `indicator_space()` - the parameters hyperopt shall be optimizing.
-* Within `buy_strategy_generator()` - populate the nested `populate_buy_trend()` to apply the parameters.
+* Define the parameters at the class level hyperopt shall be optimizing.
+* Within `populate_buy_trend()` - use defined parameter values instead of raw constants.
 
 There you have two different types of indicators: 1. `guards` and 2. `triggers`.
 
@@ -225,24 +188,46 @@ Hyper-optimization will, for each epoch round, pick one trigger and possibly
 multiple guards. The constructed strategy will be something like "*buy exactly when close price touches lower Bollinger band, BUT only if
 ADX > 10*".
 
-If you have updated the buy strategy, i.e. changed the contents of `populate_buy_trend()` method, you have to update the `guards` and `triggers` your hyperopt must use correspondingly.
+```python
+from freqtrade.strategy import IntParameter, IStrategy
+
+class MyAwesomeStrategy(IStrategy):
+    # If parameter is prefixed with `buy_` or `sell_` then specifying `space` parameter is optional
+    # and space is inferred from parameter name.
+    buy_adx_min = IntParameter(0, 100, default=10)
+
+    def populate_buy_trend(self, dataframe: 'DataFrame', metadata: dict) -> 'DataFrame':
+        dataframe.loc[
+            (
+                (dataframe['adx'] > self.buy_adx_min.value)
+            ), 'buy'] = 1
+        return dataframe
+```
 
 #### Sell optimization
 
 Similar to the buy-signal above, sell-signals can also be optimized.
 Place the corresponding settings into the following methods
 
-* Inside `sell_indicator_space()` - the parameters hyperopt shall be optimizing.
-* Within `sell_strategy_generator()` - populate the nested method `populate_sell_trend()` to apply the parameters.
+* Define the parameters at the class level hyperopt shall be optimizing.
+* Within `populate_sell_trend()` - use defined parameter values instead of raw constants.
 
 The configuration and rules are the same than for buy signals.
-To avoid naming collisions in the search-space, please prefix all sell-spaces with `sell-`.
 
-#### Using timeframe as a part of the Strategy
+```python
+class MyAwesomeStrategy(IStrategy):
+    # There is no strict parameter naming scheme. If you do not use `buy_` or `sell_` prefixes - 
+    # please specify to which space parameter belongs using `space` parameter. Possible values: 
+    # 'buy' or 'sell'.
+    adx_max = IntParameter(0, 100, default=50, space='sell')
 
-The Strategy class exposes the timeframe value as the `self.timeframe` attribute.
-The same value is available as class-attribute `HyperoptName.timeframe`.
-In the case of the linked sample-value this would be `AwesomeHyperopt.timeframe`.
+    def populate_sell_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
+        dataframe.loc[
+            (
+                (dataframe['adx'] < self.adx_max.value)
+            ), 'buy'] = 1
+        return dataframe
+```
 
 ## Solving a Mystery
 
@@ -252,25 +237,20 @@ help with those buy decisions. If you decide to use RSI or ADX, which values
 should I use for them? So let's use hyperparameter optimization to solve this
 mystery.
 
-We will start by defining a search space:
+We will start by defining hyperoptable parameters:
 
 ```python
-    def indicator_space() -> List[Dimension]:
-        """
-        Define your Hyperopt space for searching strategy parameters
-        """
-        return [
-            Integer(20, 40, name='adx-value'),
-            Integer(20, 40, name='rsi-value'),
-            Categorical([True, False], name='adx-enabled'),
-            Categorical([True, False], name='rsi-enabled'),
-            Categorical(['bb_lower', 'macd_cross_signal'], name='trigger')
-        ]
+class MyAwesomeStrategy(IStrategy):
+    buy_adx = IntParameter(20, 40, default=30)
+    buy_rsi = IntParameter(20, 40, default=30)
+    buy_adx_enabled = CategoricalParameter([True, False]),
+    buy_rsi_enabled = CategoricalParameter([True, False]),
+    buy_trigger = CategoricalParameter(['bb_lower', 'macd_cross_signal']),
 ```
 
 Above definition says: I have five parameters I want you to randomly combine
-to find the best combination. Two of them are integer values (`adx-value`
-and `rsi-value`) and I want you test in the range of values 20 to 40.  
+to find the best combination. Two of them are integer values (`buy_adx`
+and `buy_rsi`) and I want you test in the range of values 20 to 40.  
 Then we have three category variables. First two are either `True` or `False`.
 We use these to either enable or disable the ADX and RSI guards. The last
 one we call `trigger` and use it to decide which buy trigger we want to use.
@@ -278,39 +258,31 @@ one we call `trigger` and use it to decide which buy trigger we want to use.
 So let's write the buy strategy using these values:
 
 ```python
-    @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, metadata: dict) -> DataFrame:
-            conditions = []
-            # GUARDS AND TRENDS
-            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'])
+    def populate_buy_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
+        conditions = []
+        # GUARDS AND TRENDS
+        if self.buy_adx_enabled.value:
+            conditions.append(dataframe['adx'] > self.buy_adx.value)
+        if self.buy_rsi_enabled.value:
+            conditions.append(dataframe['rsi'] < self.buy_rsi.value)
 
-            # TRIGGERS
-            if 'trigger' in params:
-                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']
-                    ))
+        # TRIGGERS
+        if self.buy_trigger.value == 'bb_lower':
+            conditions.append(dataframe['close'] < dataframe['bb_lowerband'])
+        if self.buy_trigger.value == 'macd_cross_signal':
+            conditions.append(qtpylib.crossed_above(
+                dataframe['macd'], dataframe['macdsignal']
+            ))
 
-            # Check that volume is not 0
-            conditions.append(dataframe['volume'] > 0)
+        # Check that volume is not 0
+        conditions.append(dataframe['volume'] > 0)
 
-            if conditions:
-                dataframe.loc[
-                    reduce(lambda x, y: x & y, conditions),
-                    'buy'] = 1
+        if conditions:
+            dataframe.loc[
+                reduce(lambda x, y: x & y, conditions),
+                'buy'] = 1
 
-            return dataframe
-
-        return populate_buy_trend
+        return dataframe
 ```
 
 Hyperopt will now call `populate_buy_trend()` many times (`epochs`) with different value combinations.  
@@ -322,6 +294,20 @@ Based on the results, hyperopt will tell you which parameter combination produce
     When you want to test an indicator that isn't used by the bot currently, remember to
     add it to the `populate_indicators()` method in your strategy or hyperopt file.
 
+## Parameter types
+
+There are four parameter types each suited for different purposes.
+* `IntParameter` - defines an integral parameter with upper and lower boundaries of search space.
+* `DecimalParameter` - defines a floating point parameter with a limited number of decimals (default 3). Should be preferred instead of `RealParameter` in most cases.
+* `RealParameter` - defines a floating point parameter with upper and lower boundarie and no precision limit. Rarely used.
+* `CategoricalParameter` - defines a parameter with a predetermined number of choices.
+
+!!! Tip "Disabling parameter optimization"
+    Each parameter takes two boolean parameters:
+    * `load` - when set to `False` it will not load values configured in `buy_params` and `sell_params`.
+    * `optimize` - when set to `False` parameter will not be included in optimization process.
+    Use these parameters to quickly prototype various ideas.
+
 ## Loss-functions
 
 Each hyperparameter tuning requires a target. This is usually defined as a loss function (sometimes also called objective function), which should decrease for more desirable results, and increase for bad results.
@@ -348,11 +334,9 @@ Because hyperopt tries a lot of combinations to find the best parameters it will
 We strongly recommend to use `screen` or `tmux` to prevent any connection loss.
 
 ```bash
-freqtrade hyperopt --config config.json --hyperopt <hyperoptname> --hyperopt-loss <hyperoptlossname> --strategy <strategyname> -e 500 --spaces all
+freqtrade hyperopt --config config.json --hyperopt-loss <hyperoptlossname> --strategy <strategyname> -e 500 --spaces all
 ```
 
-Use `<hyperoptname>` as the name of the custom hyperopt used.
-
 The `-e` option will set how many evaluations hyperopt will do. Since hyperopt uses Bayesian search, running too many epochs at once may not produce greater results. Experience has shown that best results are usually not improving much after 500-1000 epochs.  
 Doing multiple runs (executions) with a few 1000 epochs and different random state will most likely produce different results.
 
@@ -378,14 +362,6 @@ For example, to use one month of data, pass the following parameter to the hyper
 freqtrade hyperopt --hyperopt <hyperoptname> --strategy <strategyname> --timerange 20180401-20180501
 ```
 
-### Running Hyperopt using methods from a strategy
-
-Hyperopt can reuse `populate_indicators`, `populate_buy_trend`, `populate_sell_trend` from your strategy, assuming these methods are **not** in your custom hyperopt file, and a strategy is provided.
-
-```bash
-freqtrade hyperopt --hyperopt AwesomeHyperopt --hyperopt-loss SharpeHyperOptLossDaily --strategy AwesomeStrategy
-```
-
 ### Running Hyperopt with Smaller Search Space
 
 Use the `--spaces` option to limit the search space used by hyperopt.
@@ -439,7 +415,7 @@ If you have not changed anything in the command line options, configuration, tim
 
 ## Understand the Hyperopt Result
 
-Once Hyperopt is completed you can use the result to create a new strategy.
+Once Hyperopt is completed you can use the result to update your strategy.
 Given the following result from hyperopt:
 
 ```
@@ -447,40 +423,36 @@ Best result:
 
     44/100:    135 trades. Avg profit  0.57%. Total profit  0.03871918 BTC (0.7722Σ%). Avg duration 180.4 mins. Objective: 1.94367
 
-Buy hyperspace params:
-{    'adx-value': 44,
-     'rsi-value': 29,
-     'adx-enabled': False,
-     'rsi-enabled': True,
-     'trigger': 'bb_lower'}
+    # Buy hyperspace params:
+    buy_params = {
+        'buy_adx': 44,
+        'buy_rsi': 29,
+        'buy_adx_enabled': False,
+        'buy_rsi_enabled': True,
+        'buy_trigger': 'bb_lower'
+    }
 ```
 
 You should understand this result like:
 
 - The buy trigger that worked best was `bb_lower`.
-- You should not use ADX because `adx-enabled: False`)
-- You should **consider** using the RSI indicator (`rsi-enabled: True` and the best value is `29.0` (`rsi-value: 29.0`)
+- You should not use ADX because `'buy_adx_enabled': False`)
+- You should **consider** using the RSI indicator (`'buy_rsi_enabled': True` and the best value is `29.0` (`'buy_rsi': 29.0`)
 
-You have to look inside your strategy file into `buy_strategy_generator()`
-method, what those values match to.
+Your strategy class can immediately take advantage of these results. Simply copy hyperopt results block and paste it at class level, replacing old parameters (if any). New parameters will automatically be loaded next time strategy is executed.
 
-So for example you had `rsi-value: 29.0` so we would look at `rsi`-block, that translates to the following code block:
+Transferring your whole hyperopt result to your strategy would then look like:
 
 ```python
-(dataframe['rsi'] < 29.0)
-```
-
-Translating your whole hyperopt result as the new buy-signal would then look like:
-
-```python
-def populate_buy_trend(self, dataframe: DataFrame) -> DataFrame:
-    dataframe.loc[
-        (
-            (dataframe['rsi'] < 29.0) &  # rsi-value
-            dataframe['close'] < dataframe['bb_lowerband']  # trigger
-        ),
-        'buy'] = 1
-    return dataframe
+class MyAwsomeStrategy(IStrategy):
+    # Buy hyperspace params:
+    buy_params = {
+        'buy_adx': 44,
+        'buy_rsi': 29,
+        'buy_adx_enabled': False,
+        'buy_rsi_enabled': True,
+        'buy_trigger': 'bb_lower'
+    }
 ```
 
 By default, hyperopt prints colorized results -- epochs with positive profit are printed in the green color. This highlighting helps you find epochs that can be interesting for later analysis. Epochs with zero total profit or with negative profits (losses) are printed in the normal color. If you do not need colorization of results (for instance, when you are redirecting hyperopt output to a file) you can switch colorization off by specifying the `--no-color` option in the command line.
@@ -499,11 +471,13 @@ Best result:
 
     44/100:    135 trades. Avg profit  0.57%. Total profit  0.03871918 BTC (0.7722Σ%). Avg duration 180.4 mins. Objective: 1.94367
 
-ROI table:
-{   0: 0.10674,
-    21: 0.09158,
-    78: 0.03634,
-    118: 0}
+    # ROI table:
+    minimal_roi = {
+        0: 0.10674,
+        21: 0.09158,
+        78: 0.03634,
+        118: 0
+    }
 ```
 
 In order to use this best ROI table found by Hyperopt in backtesting and for live trades/dry-run, copy-paste it as the value of the `minimal_roi` attribute of your custom strategy:
@@ -549,13 +523,16 @@ Best result:
 
     44/100:    135 trades. Avg profit  0.57%. Total profit  0.03871918 BTC (0.7722Σ%). Avg duration 180.4 mins. Objective: 1.94367
 
-Buy hyperspace params:
-{   'adx-value': 44,
-    'rsi-value': 29,
-    'adx-enabled': False,
-    'rsi-enabled': True,
-    'trigger': 'bb_lower'}
-Stoploss: -0.27996
+    # Buy hyperspace params:
+    buy_params = {
+        'buy_adx': 44,
+        'buy_rsi': 29,
+        'buy_adx_enabled': False,
+        'buy_rsi_enabled': True,
+        'buy_trigger': 'bb_lower'
+    }
+
+    stoploss: -0.27996
 ```
 
 In order to use this best stoploss value found by Hyperopt in backtesting and for live trades/dry-run, copy-paste it as the value of the `stoploss` attribute of your custom strategy:
@@ -585,11 +562,11 @@ Best result:
 
     45/100:    606 trades. Avg profit  1.04%. Total profit  0.31555614 BTC ( 630.48Σ%). Avg duration 150.3 mins. Objective: -1.10161
 
-Trailing stop:
-{   'trailing_only_offset_is_reached': True,
-    'trailing_stop': True,
-    'trailing_stop_positive': 0.02001,
-    'trailing_stop_positive_offset': 0.06038}
+    # Trailing stop:
+    trailing_stop = True
+    trailing_stop_positive = 0.02001
+    trailing_stop_positive_offset = 0.06038
+    trailing_only_offset_is_reached = True
 ```
 
 In order to use these best trailing stop parameters found by Hyperopt in backtesting and for live trades/dry-run, copy-paste them as the values of the corresponding attributes of your custom strategy:
diff --git a/docs/hyperopt_legacy.md b/docs/hyperopt_legacy.md
new file mode 100644
index 000000000..8c6972b5f
--- /dev/null
+++ b/docs/hyperopt_legacy.md
@@ -0,0 +1,629 @@
+# Legacy Hyperopt
+
+This page explains how to tune your strategy by finding the optimal
+parameters, a process called hyperparameter optimization. The bot uses several
+algorithms included in the `scikit-optimize` package to accomplish this. The
+search will burn all your CPU cores, make your laptop sound like a fighter jet
+and still take a long time.
+
+In general, the search for best parameters starts with a few random combinations (see [below](#reproducible-results) for more details) and then uses Bayesian search with a ML regressor algorithm (currently ExtraTreesRegressor) to quickly find a combination of parameters in the search hyperspace that minimizes the value of the [loss function](#loss-functions).
+
+Hyperopt requires historic data to be available, just as backtesting does.
+To learn how to get data for the pairs and exchange you're interested in, head over to the [Data Downloading](data-download.md) section of the documentation.
+
+!!! Note
+    Since 2021.4 release you no longer have to write a separate hyperopt class. Legacy method is still supported, but it is no longer a preferred way of hyperopting. Please update your strategy class following new documentation at [Hyperopt](hyperopt.md).
+
+!!! Bug
+Hyperopt can crash when used with only 1 CPU Core as found out in [Issue #1133](https://github.com/freqtrade/freqtrade/issues/1133)
+
+## Install hyperopt dependencies
+
+Since Hyperopt dependencies are not needed to run the bot itself, are heavy, can not be easily built on some platforms (like Raspberry PI), they are not installed by default. Before you run Hyperopt, you need to install the corresponding dependencies, as described in this section below.
+
+!!! Note
+Since Hyperopt is a resource intensive process, running it on a Raspberry Pi is not recommended nor supported.
+
+### Docker
+
+The docker-image includes hyperopt dependencies, no further action needed.
+
+### Easy installation script (setup.sh) / Manual installation
+
+```bash
+source .env/bin/activate
+pip install -r requirements-hyperopt.txt
+```
+
+## Hyperopt command reference
+
+
+```
+usage: freqtrade hyperopt [-h] [-v] [--logfile FILE] [-V] [-c PATH] [-d PATH]
+                          [--userdir PATH] [-s NAME] [--strategy-path PATH]
+                          [-i TIMEFRAME] [--timerange TIMERANGE]
+                          [--data-format-ohlcv {json,jsongz,hdf5}]
+                          [--max-open-trades INT]
+                          [--stake-amount STAKE_AMOUNT] [--fee FLOAT]
+                          [--hyperopt NAME] [--hyperopt-path PATH] [--eps]
+                          [--dmmp] [--enable-protections]
+                          [--dry-run-wallet DRY_RUN_WALLET] [-e INT]
+                          [--spaces {all,buy,sell,roi,stoploss,trailing,default} [{all,buy,sell,roi,stoploss,trailing,default} ...]]
+                          [--print-all] [--no-color] [--print-json] [-j JOBS]
+                          [--random-state INT] [--min-trades INT]
+                          [--hyperopt-loss NAME]
+
+optional arguments:
+  -h, --help            show this help message and exit
+  -i TIMEFRAME, --timeframe TIMEFRAME, --ticker-interval TIMEFRAME
+                        Specify ticker interval (`1m`, `5m`, `30m`, `1h`,
+                        `1d`).
+  --timerange TIMERANGE
+                        Specify what timerange of data to use.
+  --data-format-ohlcv {json,jsongz,hdf5}
+                        Storage format for downloaded candle (OHLCV) data.
+                        (default: `None`).
+  --max-open-trades INT
+                        Override the value of the `max_open_trades`
+                        configuration setting.
+  --stake-amount STAKE_AMOUNT
+                        Override the value of the `stake_amount` configuration
+                        setting.
+  --fee FLOAT           Specify fee ratio. Will be applied twice (on trade
+                        entry and exit).
+  --hyperopt NAME       Specify hyperopt class name which will be used by the
+                        bot.
+  --hyperopt-path PATH  Specify additional lookup path for Hyperopt and
+                        Hyperopt Loss functions.
+  --eps, --enable-position-stacking
+                        Allow buying the same pair multiple times (position
+                        stacking).
+  --dmmp, --disable-max-market-positions
+                        Disable applying `max_open_trades` during backtest
+                        (same as setting `max_open_trades` to a very high
+                        number).
+  --enable-protections, --enableprotections
+                        Enable protections for backtesting.Will slow
+                        backtesting down by a considerable amount, but will
+                        include configured protections
+  --dry-run-wallet DRY_RUN_WALLET, --starting-balance DRY_RUN_WALLET
+                        Starting balance, used for backtesting / hyperopt and
+                        dry-runs.
+  -e INT, --epochs INT  Specify number of epochs (default: 100).
+  --spaces {all,buy,sell,roi,stoploss,trailing,default} [{all,buy,sell,roi,stoploss,trailing,default} ...]
+                        Specify which parameters to hyperopt. Space-separated
+                        list.
+  --print-all           Print all results, not only the best ones.
+  --no-color            Disable colorization of hyperopt results. May be
+                        useful if you are redirecting output to a file.
+  --print-json          Print output in JSON format.
+  -j JOBS, --job-workers JOBS
+                        The number of concurrently running jobs for
+                        hyperoptimization (hyperopt worker processes). If -1
+                        (default), all CPUs are used, for -2, all CPUs but one
+                        are used, etc. If 1 is given, no parallel computing
+                        code is used at all.
+  --random-state INT    Set random state to some positive integer for
+                        reproducible hyperopt results.
+  --min-trades INT      Set minimal desired number of trades for evaluations
+                        in the hyperopt optimization path (default: 1).
+  --hyperopt-loss NAME  Specify the class name of the hyperopt loss function
+                        class (IHyperOptLoss). Different functions can
+                        generate completely different results, since the
+                        target for optimization is different. Built-in
+                        Hyperopt-loss-functions are:
+                        ShortTradeDurHyperOptLoss, OnlyProfitHyperOptLoss,
+                        SharpeHyperOptLoss, SharpeHyperOptLossDaily,
+                        SortinoHyperOptLoss, SortinoHyperOptLossDaily
+
+Common arguments:
+  -v, --verbose         Verbose mode (-vv for more, -vvv to get all messages).
+  --logfile FILE        Log to the file specified. Special values are:
+                        'syslog', 'journald'. See the documentation for more
+                        details.
+  -V, --version         show program's version number and exit
+  -c PATH, --config PATH
+                        Specify configuration file (default:
+                        `userdir/config.json` or `config.json` whichever
+                        exists). Multiple --config options may be used. Can be
+                        set to `-` to read config from stdin.
+  -d PATH, --datadir PATH
+                        Path to directory with historical backtesting data.
+  --userdir PATH, --user-data-dir PATH
+                        Path to userdata directory.
+
+Strategy arguments:
+  -s NAME, --strategy NAME
+                        Specify strategy class name which will be used by the
+                        bot.
+  --strategy-path PATH  Specify additional strategy lookup path.
+
+```
+
+## Prepare Hyperopting
+
+Before we start digging into Hyperopt, we recommend you to take a look at
+the sample hyperopt file located in [user_data/hyperopts/](https://github.com/freqtrade/freqtrade/blob/develop/freqtrade/templates/sample_hyperopt.py).
+
+Configuring hyperopt is similar to writing your own strategy, and many tasks will be similar.
+
+!!! Tip "About this page"
+For this page, we will be using a fictional strategy called `AwesomeStrategy` - which will be optimized using the `AwesomeHyperopt` class.
+
+The simplest way to get started is to use the following, command, which will create a new hyperopt file from a template, which will be located under `user_data/hyperopts/AwesomeHyperopt.py`.
+
+``` bash
+freqtrade new-hyperopt --hyperopt AwesomeHyperopt
+```
+
+### Hyperopt checklist
+
+Checklist on all tasks / possibilities in hyperopt
+
+Depending on the space you want to optimize, only some of the below are required:
+
+* fill `buy_strategy_generator` - for buy signal optimization
+* fill `indicator_space` - for buy signal optimization
+* fill `sell_strategy_generator` - for sell signal optimization
+* fill `sell_indicator_space` - for sell signal optimization
+
+!!! Note
+`populate_indicators` needs to create all indicators any of thee spaces may use, otherwise hyperopt will not work.
+
+Optional in hyperopt - can also be loaded from a strategy (recommended):
+
+* `populate_indicators` - fallback to create indicators
+* `populate_buy_trend` - fallback if not optimizing for buy space. should come from strategy
+* `populate_sell_trend` - fallback if not optimizing for sell space. should come from strategy
+
+!!! Note
+You always have to provide a strategy to Hyperopt, even if your custom Hyperopt class contains all methods.
+Assuming the optional methods are not in your hyperopt file, please use `--strategy AweSomeStrategy` which contains these methods so hyperopt can use these methods instead.
+
+Rarely you may also need to override:
+
+* `roi_space` - for custom ROI optimization (if you need the ranges for the ROI parameters in the optimization hyperspace that differ from default)
+* `generate_roi_table` - for custom ROI optimization (if you need the ranges for the values in the ROI table that differ from default or the number of entries (steps) in the ROI table which differs from the default 4 steps)
+* `stoploss_space` - for custom stoploss optimization (if you need the range for the stoploss parameter in the optimization hyperspace that differs from default)
+* `trailing_space` - for custom trailing stop optimization (if you need the ranges for the trailing stop parameters in the optimization hyperspace that differ from default)
+
+!!! Tip "Quickly optimize ROI, stoploss and trailing stoploss"
+You can quickly optimize the spaces `roi`, `stoploss` and `trailing` without changing anything (i.e. without creation of a "complete" Hyperopt class with dimensions, parameters, triggers and guards, as described in this document) from the default hyperopt template by relying on your strategy to do most of the calculations.
+
+    ```python
+    # Have a working strategy at hand.
+    freqtrade new-hyperopt --hyperopt EmptyHyperopt
+
+    freqtrade hyperopt --hyperopt EmptyHyperopt --hyperopt-loss SharpeHyperOptLossDaily --spaces roi stoploss trailing --strategy MyWorkingStrategy --config config.json -e 100
+    ```
+
+### Create a Custom Hyperopt File
+
+Let assume you want a hyperopt file `AwesomeHyperopt.py`:
+
+``` bash
+freqtrade new-hyperopt --hyperopt AwesomeHyperopt
+```
+
+This command will create a new hyperopt file from a template, allowing you to get started quickly.
+
+### Configure your Guards and Triggers
+
+There are two places you need to change in your hyperopt file to add a new buy hyperopt for testing:
+
+* Inside `indicator_space()` - the parameters hyperopt shall be optimizing.
+* Within `buy_strategy_generator()` - populate the nested `populate_buy_trend()` to apply the parameters.
+
+There you have two different types of indicators: 1. `guards` and 2. `triggers`.
+
+1. Guards are conditions like "never buy if ADX < 10", or never buy if current price is over EMA10.
+2. Triggers are ones that actually trigger buy in specific moment, like "buy when EMA5 crosses over EMA10" or "buy when close price touches lower Bollinger band".
+
+!!! Hint "Guards and Triggers"
+Technically, there is no difference between Guards and Triggers.  
+However, this guide will make this distinction to make it clear that signals should not be "sticking".
+Sticking signals are signals that are active for multiple candles. This can lead into buying a signal late (right before the signal disappears - which means that the chance of success is a lot lower than right at the beginning).
+
+Hyper-optimization will, for each epoch round, pick one trigger and possibly
+multiple guards. The constructed strategy will be something like "*buy exactly when close price touches lower Bollinger band, BUT only if
+ADX > 10*".
+
+If you have updated the buy strategy, i.e. changed the contents of `populate_buy_trend()` method, you have to update the `guards` and `triggers` your hyperopt must use correspondingly.
+
+#### Sell optimization
+
+Similar to the buy-signal above, sell-signals can also be optimized.
+Place the corresponding settings into the following methods
+
+* Inside `sell_indicator_space()` - the parameters hyperopt shall be optimizing.
+* Within `sell_strategy_generator()` - populate the nested method `populate_sell_trend()` to apply the parameters.
+
+The configuration and rules are the same than for buy signals.
+To avoid naming collisions in the search-space, please prefix all sell-spaces with `sell-`.
+
+#### Using timeframe as a part of the Strategy
+
+The Strategy class exposes the timeframe value as the `self.timeframe` attribute.
+The same value is available as class-attribute `HyperoptName.timeframe`.
+In the case of the linked sample-value this would be `AwesomeHyperopt.timeframe`.
+
+## Solving a Mystery
+
+Let's say you are curious: should you use MACD crossings or lower Bollinger
+Bands to trigger your buys. And you also wonder should you use RSI or ADX to
+help with those buy decisions. If you decide to use RSI or ADX, which values
+should I use for them? So let's use hyperparameter optimization to solve this
+mystery.
+
+We will start by defining a search space:
+
+```python
+    def indicator_space() -> List[Dimension]:
+        """
+        Define your Hyperopt space for searching strategy parameters
+        """
+        return [
+            Integer(20, 40, name='adx-value'),
+            Integer(20, 40, name='rsi-value'),
+            Categorical([True, False], name='adx-enabled'),
+            Categorical([True, False], name='rsi-enabled'),
+            Categorical(['bb_lower', 'macd_cross_signal'], name='trigger')
+        ]
+```
+
+Above definition says: I have five parameters I want you to randomly combine
+to find the best combination. Two of them are integer values (`adx-value`
+and `rsi-value`) and I want you test in the range of values 20 to 40.  
+Then we have three category variables. First two are either `True` or `False`.
+We use these to either enable or disable the ADX and RSI guards. The last
+one we call `trigger` and use it to decide which buy trigger we want to use.
+
+So let's write the buy strategy using these values:
+
+```python
+    @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, metadata: dict) -> DataFrame:
+            conditions = []
+            # GUARDS AND TRENDS
+            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 'trigger' in params:
+                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']
+                    ))
+
+            # Check that volume is not 0
+            conditions.append(dataframe['volume'] > 0)
+
+            if conditions:
+                dataframe.loc[
+                    reduce(lambda x, y: x & y, conditions),
+                    'buy'] = 1
+
+            return dataframe
+
+        return populate_buy_trend
+```
+
+Hyperopt will now call `populate_buy_trend()` many times (`epochs`) with different value combinations.  
+It will use the given historical data and make buys based on the buy signals generated with the above function.  
+Based on the results, hyperopt will tell you which parameter combination produced the best results (based on the configured [loss function](#loss-functions)).
+
+!!! Note
+The above setup expects to find ADX, RSI and Bollinger Bands in the populated indicators.
+When you want to test an indicator that isn't used by the bot currently, remember to
+add it to the `populate_indicators()` method in your strategy or hyperopt file.
+
+## Loss-functions
+
+Each hyperparameter tuning requires a target. This is usually defined as a loss function (sometimes also called objective function), which should decrease for more desirable results, and increase for bad results.
+
+A loss function must be specified via the `--hyperopt-loss <Class-name>` argument (or optionally via the configuration under the `"hyperopt_loss"` key).
+This class should be in its own file within the `user_data/hyperopts/` directory.
+
+Currently, the following loss functions are builtin:
+
+* `ShortTradeDurHyperOptLoss` (default legacy Freqtrade hyperoptimization loss function) - Mostly for short trade duration and avoiding losses.
+* `OnlyProfitHyperOptLoss` (which takes only amount of profit into consideration)
+* `SharpeHyperOptLoss` (optimizes Sharpe Ratio calculated on trade returns relative to standard deviation)
+* `SharpeHyperOptLossDaily` (optimizes Sharpe Ratio calculated on **daily** trade returns relative to standard deviation)
+* `SortinoHyperOptLoss` (optimizes Sortino Ratio calculated on trade returns relative to **downside** standard deviation)
+* `SortinoHyperOptLossDaily` (optimizes Sortino Ratio calculated on **daily** trade returns relative to **downside** standard deviation)
+
+Creation of a custom loss function is covered in the [Advanced Hyperopt](advanced-hyperopt.md) part of the documentation.
+
+## Execute Hyperopt
+
+Once you have updated your hyperopt configuration you can run it.
+Because hyperopt tries a lot of combinations to find the best parameters it will take time to get a good result. More time usually results in better results.
+
+We strongly recommend to use `screen` or `tmux` to prevent any connection loss.
+
+```bash
+freqtrade hyperopt --config config.json --hyperopt <hyperoptname> --hyperopt-loss <hyperoptlossname> --strategy <strategyname> -e 500 --spaces all
+```
+
+Use `<hyperoptname>` as the name of the custom hyperopt used.
+
+The `-e` option will set how many evaluations hyperopt will do. Since hyperopt uses Bayesian search, running too many epochs at once may not produce greater results. Experience has shown that best results are usually not improving much after 500-1000 epochs.  
+Doing multiple runs (executions) with a few 1000 epochs and different random state will most likely produce different results.
+
+The `--spaces all` option determines that all possible parameters should be optimized. Possibilities are listed below.
+
+!!! Note
+Hyperopt will store hyperopt results with the timestamp of the hyperopt start time.
+Reading commands (`hyperopt-list`, `hyperopt-show`) can use `--hyperopt-filename <filename>` to read and display older hyperopt results.
+You can find a list of filenames with `ls -l user_data/hyperopt_results/`.
+
+### Execute Hyperopt with different historical data source
+
+If you would like to hyperopt parameters using an alternate historical data set that
+you have on-disk, use the `--datadir PATH` option. By default, hyperopt
+uses data from directory `user_data/data`.
+
+### Running Hyperopt with a smaller test-set
+
+Use the `--timerange` argument to change how much of the test-set you want to use.
+For example, to use one month of data, pass the following parameter to the hyperopt call:
+
+```bash
+freqtrade hyperopt --hyperopt <hyperoptname> --strategy <strategyname> --timerange 20180401-20180501
+```
+
+### Running Hyperopt using methods from a strategy
+
+Hyperopt can reuse `populate_indicators`, `populate_buy_trend`, `populate_sell_trend` from your strategy, assuming these methods are **not** in your custom hyperopt file, and a strategy is provided.
+
+```bash
+freqtrade hyperopt --hyperopt AwesomeHyperopt --hyperopt-loss SharpeHyperOptLossDaily --strategy AwesomeStrategy
+```
+
+### Running Hyperopt with Smaller Search Space
+
+Use the `--spaces` option to limit the search space used by hyperopt.
+Letting Hyperopt optimize everything is a huuuuge search space.
+Often it might make more sense to start by just searching for initial buy algorithm.
+Or maybe you just want to optimize your stoploss or roi table for that awesome new buy strategy you have.
+
+Legal values are:
+
+* `all`: optimize everything
+* `buy`: just search for a new buy strategy
+* `sell`: just search for a new sell strategy
+* `roi`: just optimize the minimal profit table for your strategy
+* `stoploss`: search for the best stoploss value
+* `trailing`: search for the best trailing stop values
+* `default`: `all` except `trailing`
+* space-separated list of any of the above values for example `--spaces roi stoploss`
+
+The default Hyperopt Search Space, used when no `--space` command line option is specified, does not include the `trailing` hyperspace. We recommend you to run optimization for the `trailing` hyperspace separately, when the best parameters for other hyperspaces were found, validated and pasted into your custom strategy.
+
+### Position stacking and disabling max market positions
+
+In some situations, you may need to run Hyperopt (and Backtesting) with the
+`--eps`/`--enable-position-staking` and `--dmmp`/`--disable-max-market-positions` arguments.
+
+By default, hyperopt emulates the behavior of the Freqtrade Live Run/Dry Run, where only one
+open trade is allowed for every traded pair. The total number of trades open for all pairs
+is also limited by the `max_open_trades` setting. During Hyperopt/Backtesting this may lead to
+some potential trades to be hidden (or masked) by previously open trades.
+
+The `--eps`/`--enable-position-stacking` argument allows emulation of buying the same pair multiple times,
+while `--dmmp`/`--disable-max-market-positions` disables applying `max_open_trades`
+during Hyperopt/Backtesting (which is equal to setting `max_open_trades` to a very high
+number).
+
+!!! Note
+Dry/live runs will **NOT** use position stacking - therefore it does make sense to also validate the strategy without this as it's closer to reality.
+
+You can also enable position stacking in the configuration file by explicitly setting
+`"position_stacking"=true`.
+
+### Reproducible results
+
+The search for optimal parameters starts with a few (currently 30) random combinations in the hyperspace of parameters, random Hyperopt epochs. These random epochs are marked with an asterisk character (`*`) in the first column in the Hyperopt output.
+
+The initial state for generation of these random values (random state) is controlled by the value of the `--random-state` command line option. You can set it to some arbitrary value of your choice to obtain reproducible results.
+
+If you have not set this value explicitly in the command line options, Hyperopt seeds the random state with some random value for you. The random state value for each Hyperopt run is shown in the log, so you can copy and paste it into the `--random-state` command line option to repeat the set of the initial random epochs used.
+
+If you have not changed anything in the command line options, configuration, timerange, Strategy and Hyperopt classes, historical data and the Loss Function -- you should obtain same hyper-optimization results with same random state value used.
+
+## Understand the Hyperopt Result
+
+Once Hyperopt is completed you can use the result to create a new strategy.
+Given the following result from hyperopt:
+
+```
+Best result:
+
+    44/100:    135 trades. Avg profit  0.57%. Total profit  0.03871918 BTC (0.7722Σ%). Avg duration 180.4 mins. Objective: 1.94367
+
+Buy hyperspace params:
+{    'adx-value': 44,
+     'rsi-value': 29,
+     'adx-enabled': False,
+     'rsi-enabled': True,
+     'trigger': 'bb_lower'}
+```
+
+You should understand this result like:
+
+- The buy trigger that worked best was `bb_lower`.
+- You should not use ADX because `adx-enabled: False`)
+- You should **consider** using the RSI indicator (`rsi-enabled: True` and the best value is `29.0` (`rsi-value: 29.0`)
+
+You have to look inside your strategy file into `buy_strategy_generator()`
+method, what those values match to.
+
+So for example you had `rsi-value: 29.0` so we would look at `rsi`-block, that translates to the following code block:
+
+```python
+(dataframe['rsi'] < 29.0)
+```
+
+Translating your whole hyperopt result as the new buy-signal would then look like:
+
+```python
+def populate_buy_trend(self, dataframe: DataFrame) -> DataFrame:
+    dataframe.loc[
+        (
+            (dataframe['rsi'] < 29.0) &  # rsi-value
+            dataframe['close'] < dataframe['bb_lowerband']  # trigger
+        ),
+        'buy'] = 1
+    return dataframe
+```
+
+By default, hyperopt prints colorized results -- epochs with positive profit are printed in the green color. This highlighting helps you find epochs that can be interesting for later analysis. Epochs with zero total profit or with negative profits (losses) are printed in the normal color. If you do not need colorization of results (for instance, when you are redirecting hyperopt output to a file) you can switch colorization off by specifying the `--no-color` option in the command line.
+
+You can use the `--print-all` command line option if you would like to see all results in the hyperopt output, not only the best ones. When `--print-all` is used, current best results are also colorized by default -- they are printed in bold (bright) style. This can also be switched off with the `--no-color` command line option.
+
+!!! Note "Windows and color output"
+Windows does not support color-output natively, therefore it is automatically disabled. To have color-output for hyperopt running under windows, please consider using WSL.
+
+### Understand Hyperopt ROI results
+
+If you are optimizing ROI (i.e. if optimization search-space contains 'all', 'default' or 'roi'), your result will look as follows and include a ROI table:
+
+```
+Best result:
+
+    44/100:    135 trades. Avg profit  0.57%. Total profit  0.03871918 BTC (0.7722Σ%). Avg duration 180.4 mins. Objective: 1.94367
+
+ROI table:
+{   0: 0.10674,
+    21: 0.09158,
+    78: 0.03634,
+    118: 0}
+```
+
+In order to use this best ROI table found by Hyperopt in backtesting and for live trades/dry-run, copy-paste it as the value of the `minimal_roi` attribute of your custom strategy:
+
+```
+    # Minimal ROI designed for the strategy.
+    # This attribute will be overridden if the config file contains "minimal_roi"
+    minimal_roi = {
+        0: 0.10674,
+        21: 0.09158,
+        78: 0.03634,
+        118: 0
+    }
+```
+
+As stated in the comment, you can also use it as the value of the `minimal_roi` setting in the configuration file.
+
+#### Default ROI Search Space
+
+If you are optimizing ROI, Freqtrade creates the 'roi' optimization hyperspace for you -- it's the hyperspace of components for the ROI tables. By default, each ROI table generated by the Freqtrade consists of 4 rows (steps). Hyperopt implements adaptive ranges for ROI tables with ranges for values in the ROI steps that depend on the timeframe used. By default the values vary in the following ranges (for some of the most used timeframes, values are rounded to 5 digits after the decimal point):
+
+| # step | 1m     |                   | 5m       |             | 1h         |                   | 1d           |                   |
+| ------ | ------ | ----------------- | -------- | ----------- | ---------- | ----------------- | ------------ | ----------------- |
+| 1      | 0      | 0.01161...0.11992 | 0        | 0.03...0.31 | 0          | 0.06883...0.71124 | 0            | 0.12178...1.25835 |
+| 2      | 2...8  | 0.00774...0.04255 | 10...40  | 0.02...0.11 | 120...480  | 0.04589...0.25238 | 2880...11520 | 0.08118...0.44651 |
+| 3      | 4...20 | 0.00387...0.01547 | 20...100 | 0.01...0.04 | 240...1200 | 0.02294...0.09177 | 5760...28800 | 0.04059...0.16237 |
+| 4      | 6...44 | 0.0               | 30...220 | 0.0         | 360...2640 | 0.0               | 8640...63360 | 0.0               |
+
+These ranges should be sufficient in most cases. The minutes in the steps (ROI dict keys) are scaled linearly depending on the timeframe used. The ROI values in the steps (ROI dict values) are scaled logarithmically depending on the timeframe used.
+
+If you have the `generate_roi_table()` and `roi_space()` methods in your custom hyperopt file, remove them in order to utilize these adaptive ROI tables and the ROI hyperoptimization space generated by Freqtrade by default.
+
+Override the `roi_space()` method if you need components of the ROI tables to vary in other ranges. Override the `generate_roi_table()` and `roi_space()` methods and implement your own custom approach for generation of the ROI tables during hyperoptimization if you need a different structure of the ROI tables or other amount of rows (steps).
+
+A sample for these methods can be found in [sample_hyperopt_advanced.py](https://github.com/freqtrade/freqtrade/blob/develop/freqtrade/templates/sample_hyperopt_advanced.py).
+
+### Understand Hyperopt Stoploss results
+
+If you are optimizing stoploss values (i.e. if optimization search-space contains 'all', 'default' or 'stoploss'), your result will look as follows and include stoploss:
+
+```
+Best result:
+
+    44/100:    135 trades. Avg profit  0.57%. Total profit  0.03871918 BTC (0.7722Σ%). Avg duration 180.4 mins. Objective: 1.94367
+
+Buy hyperspace params:
+{   'adx-value': 44,
+    'rsi-value': 29,
+    'adx-enabled': False,
+    'rsi-enabled': True,
+    'trigger': 'bb_lower'}
+Stoploss: -0.27996
+```
+
+In order to use this best stoploss value found by Hyperopt in backtesting and for live trades/dry-run, copy-paste it as the value of the `stoploss` attribute of your custom strategy:
+
+``` python
+    # Optimal stoploss designed for the strategy
+    # This attribute will be overridden if the config file contains "stoploss"
+    stoploss = -0.27996
+```
+
+As stated in the comment, you can also use it as the value of the `stoploss` setting in the configuration file.
+
+#### Default Stoploss Search Space
+
+If you are optimizing stoploss values, Freqtrade creates the 'stoploss' optimization hyperspace for you. By default, the stoploss values in that hyperspace vary in the range -0.35...-0.02, which is sufficient in most cases.
+
+If you have the `stoploss_space()` method in your custom hyperopt file, remove it in order to utilize Stoploss hyperoptimization space generated by Freqtrade by default.
+
+Override the `stoploss_space()` method and define the desired range in it if you need stoploss values to vary in other range during hyperoptimization. A sample for this method can be found in [user_data/hyperopts/sample_hyperopt_advanced.py](https://github.com/freqtrade/freqtrade/blob/develop/freqtrade/templates/sample_hyperopt_advanced.py).
+
+### Understand Hyperopt Trailing Stop results
+
+If you are optimizing trailing stop values (i.e. if optimization search-space contains 'all' or 'trailing'), your result will look as follows and include trailing stop parameters:
+
+```
+Best result:
+
+    45/100:    606 trades. Avg profit  1.04%. Total profit  0.31555614 BTC ( 630.48Σ%). Avg duration 150.3 mins. Objective: -1.10161
+
+Trailing stop:
+{   'trailing_only_offset_is_reached': True,
+    'trailing_stop': True,
+    'trailing_stop_positive': 0.02001,
+    'trailing_stop_positive_offset': 0.06038}
+```
+
+In order to use these best trailing stop parameters found by Hyperopt in backtesting and for live trades/dry-run, copy-paste them as the values of the corresponding attributes of your custom strategy:
+
+``` python
+    # Trailing stop
+    # These attributes will be overridden if the config file contains corresponding values.
+    trailing_stop = True
+    trailing_stop_positive = 0.02001
+    trailing_stop_positive_offset = 0.06038
+    trailing_only_offset_is_reached = True
+```
+
+As stated in the comment, you can also use it as the values of the corresponding settings in the configuration file.
+
+#### Default Trailing Stop Search Space
+
+If you are optimizing trailing stop values, Freqtrade creates the 'trailing' optimization hyperspace for you. By default, the `trailing_stop` parameter is always set to True in that hyperspace, the value of the `trailing_only_offset_is_reached` vary between True and False, the values of the `trailing_stop_positive` and `trailing_stop_positive_offset` parameters vary in the ranges 0.02...0.35 and 0.01...0.1 correspondingly, which is sufficient in most cases.
+
+Override the `trailing_space()` method and define the desired range in it if you need values of the trailing stop parameters to vary in other ranges during hyperoptimization. A sample for this method can be found in [user_data/hyperopts/sample_hyperopt_advanced.py](https://github.com/freqtrade/freqtrade/blob/develop/freqtrade/templates/sample_hyperopt_advanced.py).
+
+## Show details of Hyperopt results
+
+After you run Hyperopt for the desired amount of epochs, you can later list all results for analysis, select only best or profitable once, and show the details for any of the epochs previously evaluated. This can be done with the `hyperopt-list` and `hyperopt-show` sub-commands. The usage of these sub-commands is described in the [Utils](utils.md#list-hyperopt-results) chapter.
+
+## Validate backtesting results
+
+Once the optimized strategy has been implemented into your strategy, you should backtest this strategy to make sure everything is working as expected.
+
+To achieve same results (number of trades, their durations, profit, etc.) than during Hyperopt, please use same configuration and parameters (timerange, timeframe, ...) used for hyperopt `--dmmp`/`--disable-max-market-positions` and `--eps`/`--enable-position-stacking` for Backtesting.
+
+Should results don't match, please double-check to make sure you transferred all conditions correctly.
+Pay special care to the stoploss (and trailing stoploss) parameters, as these are often set in configuration files, which override changes to the strategy.
+You should also carefully review the log of your backtest to ensure that there were no parameters inadvertently set by the configuration (like `stoploss` or `trailing_stop`).

From faf40482ef9bebf9cbb5469f17b4d136fded3ced Mon Sep 17 00:00:00 2001
From: Rokas Kupstys <rokups@zoho.com>
Date: Sat, 3 Apr 2021 13:49:24 +0300
Subject: [PATCH 23/32] Fix parameter printing.

---
 freqtrade/strategy/hyper.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/freqtrade/strategy/hyper.py b/freqtrade/strategy/hyper.py
index e58aac273..6282d91c0 100644
--- a/freqtrade/strategy/hyper.py
+++ b/freqtrade/strategy/hyper.py
@@ -259,7 +259,7 @@ class HyperStrategyMixin(object):
             if attr_name in params:
                 if attr.load:
                     attr.value = params[attr_name]
-                    logger.info(f'attr_name = {attr.value}')
+                    logger.info(f'{attr_name} = {attr.value}')
                 else:
                     logger.warning(f'Parameter "{attr_name}" exists, but is disabled. '
                                    f'Default value "{attr.value}" used.')

From 4eb7ce52cd61fcd14f546b72be3b45ee03bcc8a8 Mon Sep 17 00:00:00 2001
From: Matthias <xmatthias@outlook.com>
Date: Sat, 3 Apr 2021 15:15:38 +0200
Subject: [PATCH 24/32] Remove duplicate entries from hyperopt_legacy

---
 docs/hyperopt.md        |  47 ++---
 docs/hyperopt_legacy.md | 446 ++++------------------------------------
 2 files changed, 62 insertions(+), 431 deletions(-)

diff --git a/docs/hyperopt.md b/docs/hyperopt.md
index e9d440a5a..725afebf3 100644
--- a/docs/hyperopt.md
+++ b/docs/hyperopt.md
@@ -1,21 +1,21 @@
 # Hyperopt
 
 This page explains how to tune your strategy by finding the optimal
-parameters, a process called hyperparameter optimization. The bot uses several
-algorithms included in the `scikit-optimize` package to accomplish this. The
-search will burn all your CPU cores, make your laptop sound like a fighter jet
-and still take a long time.
+parameters, a process called hyperparameter optimization. The bot uses algorithms included in the `scikit-optimize` package to accomplish this.
+The search will burn all your CPU cores, make your laptop sound like a fighter jet and still take a long time.
 
 In general, the search for best parameters starts with a few random combinations (see [below](#reproducible-results) for more details) and then uses Bayesian search with a ML regressor algorithm (currently ExtraTreesRegressor) to quickly find a combination of parameters in the search hyperspace that minimizes the value of the [loss function](#loss-functions).
 
-Hyperopt requires historic data to be available, just as backtesting does.
+Hyperopt requires historic data to be available, just as backtesting does (hyperopt runs backtesting many times with different parameters).
 To learn how to get data for the pairs and exchange you're interested in, head over to the [Data Downloading](data-download.md) section of the documentation.
 
 !!! Bug
     Hyperopt can crash when used with only 1 CPU Core as found out in [Issue #1133](https://github.com/freqtrade/freqtrade/issues/1133)
 
 !!! Note
-    Since 2021.4 release you no longer have to write a separate hyperopt class. Legacy method is still supported, but it is no longer a preferred way of hyperopting. Legacy documentation is available at [Legacy Hyperopt](hyperopt_legacy.md).
+    Since 2021.4 release you no longer have to write a separate hyperopt class, but can configure the parameters directly in the strategy.
+    The legacy method is still supported, but it is no longer the recommended way of setting up hyperopt. 
+    The legacy documentation is available at [Legacy Hyperopt](hyperopt_legacy.md).
 
 ## Install hyperopt dependencies
 
@@ -37,7 +37,6 @@ pip install -r requirements-hyperopt.txt
 
 ## Hyperopt command reference
 
-
 ```
 usage: freqtrade hyperopt [-h] [-v] [--logfile FILE] [-V] [-c PATH] [-d PATH]
                           [--userdir PATH] [-s NAME] [--strategy-path PATH]
@@ -150,7 +149,7 @@ Depending on the space you want to optimize, only some of the below are required
 * define parameters with `space='sell'` - for sell signal optimization
 
 !!! Note
-    `populate_indicators` needs to create all indicators any of thee spaces may use, otherwise hyperopt will not work.
+    `populate_indicators` needs to create all indicators any of the spaces may use, otherwise hyperopt will not work.
 
 Rarely you may also need to create a nested class named `HyperOpt` and implement:
 
@@ -299,7 +298,7 @@ Based on the results, hyperopt will tell you which parameter combination produce
 There are four parameter types each suited for different purposes.
 * `IntParameter` - defines an integral parameter with upper and lower boundaries of search space.
 * `DecimalParameter` - defines a floating point parameter with a limited number of decimals (default 3). Should be preferred instead of `RealParameter` in most cases.
-* `RealParameter` - defines a floating point parameter with upper and lower boundarie and no precision limit. Rarely used.
+* `RealParameter` - defines a floating point parameter with upper and lower boundaries and no precision limit. Rarely used as it creates a space with a near infinite number of possibilities.
 * `CategoricalParameter` - defines a parameter with a predetermined number of choices.
 
 !!! Tip "Disabling parameter optimization"
@@ -329,7 +328,7 @@ Creation of a custom loss function is covered in the [Advanced Hyperopt](advance
 ## Execute Hyperopt
 
 Once you have updated your hyperopt configuration you can run it.
-Because hyperopt tries a lot of combinations to find the best parameters it will take time to get a good result. More time usually results in better results.
+Because hyperopt tries a lot of combinations to find the best parameters it will take time to get a good result.
 
 We strongly recommend to use `screen` or `tmux` to prevent any connection loss.
 
@@ -365,7 +364,7 @@ freqtrade hyperopt --hyperopt <hyperoptname> --strategy <strategyname> --timeran
 ### Running Hyperopt with Smaller Search Space
 
 Use the `--spaces` option to limit the search space used by hyperopt.
-Letting Hyperopt optimize everything is a huuuuge search space. 
+Letting Hyperopt optimize everything is a huuuuge search space.
 Often it might make more sense to start by just searching for initial buy algorithm.
 Or maybe you just want to optimize your stoploss or roi table for that awesome new buy strategy you have.
 
@@ -435,16 +434,16 @@ Best result:
 
 You should understand this result like:
 
-- The buy trigger that worked best was `bb_lower`.
-- You should not use ADX because `'buy_adx_enabled': False`)
-- You should **consider** using the RSI indicator (`'buy_rsi_enabled': True` and the best value is `29.0` (`'buy_rsi': 29.0`)
+* The buy trigger that worked best was `bb_lower`.
+* You should not use ADX because `'buy_adx_enabled': False`.
+* You should **consider** using the RSI indicator (`'buy_rsi_enabled': True`) and the best value is `29.0` (`'buy_rsi': 29.0`)
 
-Your strategy class can immediately take advantage of these results. Simply copy hyperopt results block and paste it at class level, replacing old parameters (if any). New parameters will automatically be loaded next time strategy is executed.
+Your strategy class can immediately take advantage of these results. Simply copy hyperopt results block and paste them at class level, replacing old parameters (if any). New parameters will automatically be loaded next time strategy is executed.
 
 Transferring your whole hyperopt result to your strategy would then look like:
 
 ```python
-class MyAwsomeStrategy(IStrategy):
+class MyAwesomeStrategy(IStrategy):
     # Buy hyperspace params:
     buy_params = {
         'buy_adx': 44,
@@ -455,13 +454,6 @@ class MyAwsomeStrategy(IStrategy):
     }
 ```
 
-By default, hyperopt prints colorized results -- epochs with positive profit are printed in the green color. This highlighting helps you find epochs that can be interesting for later analysis. Epochs with zero total profit or with negative profits (losses) are printed in the normal color. If you do not need colorization of results (for instance, when you are redirecting hyperopt output to a file) you can switch colorization off by specifying the `--no-color` option in the command line.
-
-You can use the `--print-all` command line option if you would like to see all results in the hyperopt output, not only the best ones. When `--print-all` is used, current best results are also colorized by default -- they are printed in bold (bright) style. This can also be switched off with the `--no-color` command line option.
-
-!!! Note "Windows and color output"
-    Windows does not support color-output natively, therefore it is automatically disabled. To have color-output for hyperopt running under windows, please consider using WSL.
-
 ### Understand Hyperopt ROI results
 
 If you are optimizing ROI (i.e. if optimization search-space contains 'all', 'default' or 'roi'), your result will look as follows and include a ROI table:
@@ -588,6 +580,15 @@ If you are optimizing trailing stop values, Freqtrade creates the 'trailing' opt
 
 Override the `trailing_space()` method and define the desired range in it if you need values of the trailing stop parameters to vary in other ranges during hyperoptimization. A sample for this method can be found in [user_data/hyperopts/sample_hyperopt_advanced.py](https://github.com/freqtrade/freqtrade/blob/develop/freqtrade/templates/sample_hyperopt_advanced.py).
 
+### Output formatting
+
+By default, hyperopt prints colorized results -- epochs with positive profit are printed in the green color. This highlighting helps you find epochs that can be interesting for later analysis. Epochs with zero total profit or with negative profits (losses) are printed in the normal color. If you do not need colorization of results (for instance, when you are redirecting hyperopt output to a file) you can switch colorization off by specifying the `--no-color` option in the command line.
+
+You can use the `--print-all` command line option if you would like to see all results in the hyperopt output, not only the best ones. When `--print-all` is used, current best results are also colorized by default -- they are printed in bold (bright) style. This can also be switched off with the `--no-color` command line option.
+
+!!! Note "Windows and color output"
+    Windows does not support color-output natively, therefore it is automatically disabled. To have color-output for hyperopt running under windows, please consider using WSL.
+
 ## Show details of Hyperopt results
 
 After you run Hyperopt for the desired amount of epochs, you can later list all results for analysis, select only best or profitable once, and show the details for any of the epochs previously evaluated. This can be done with the `hyperopt-list` and `hyperopt-show` sub-commands. The usage of these sub-commands is described in the [Utils](utils.md#list-hyperopt-results) chapter.
diff --git a/docs/hyperopt_legacy.md b/docs/hyperopt_legacy.md
index 8c6972b5f..03c1eb358 100644
--- a/docs/hyperopt_legacy.md
+++ b/docs/hyperopt_legacy.md
@@ -1,162 +1,29 @@
 # Legacy Hyperopt
 
-This page explains how to tune your strategy by finding the optimal
-parameters, a process called hyperparameter optimization. The bot uses several
-algorithms included in the `scikit-optimize` package to accomplish this. The
-search will burn all your CPU cores, make your laptop sound like a fighter jet
-and still take a long time.
+This Section explains the configuration of an explicit Hyperopt file (separate to the strategy).
 
-In general, the search for best parameters starts with a few random combinations (see [below](#reproducible-results) for more details) and then uses Bayesian search with a ML regressor algorithm (currently ExtraTreesRegressor) to quickly find a combination of parameters in the search hyperspace that minimizes the value of the [loss function](#loss-functions).
+!!! Warning "Deprecated / legacy mode"
+    Since the 2021.4 release you no longer have to write a separate hyperopt class, but all strategies can be hyperopted.
+    Please read the [main hyperopt page](hyperopt.md) for more details.
 
-Hyperopt requires historic data to be available, just as backtesting does.
-To learn how to get data for the pairs and exchange you're interested in, head over to the [Data Downloading](data-download.md) section of the documentation.
+## Prepare hyperopt file
 
-!!! Note
-    Since 2021.4 release you no longer have to write a separate hyperopt class. Legacy method is still supported, but it is no longer a preferred way of hyperopting. Please update your strategy class following new documentation at [Hyperopt](hyperopt.md).
-
-!!! Bug
-Hyperopt can crash when used with only 1 CPU Core as found out in [Issue #1133](https://github.com/freqtrade/freqtrade/issues/1133)
-
-## Install hyperopt dependencies
-
-Since Hyperopt dependencies are not needed to run the bot itself, are heavy, can not be easily built on some platforms (like Raspberry PI), they are not installed by default. Before you run Hyperopt, you need to install the corresponding dependencies, as described in this section below.
-
-!!! Note
-Since Hyperopt is a resource intensive process, running it on a Raspberry Pi is not recommended nor supported.
-
-### Docker
-
-The docker-image includes hyperopt dependencies, no further action needed.
-
-### Easy installation script (setup.sh) / Manual installation
-
-```bash
-source .env/bin/activate
-pip install -r requirements-hyperopt.txt
-```
-
-## Hyperopt command reference
-
-
-```
-usage: freqtrade hyperopt [-h] [-v] [--logfile FILE] [-V] [-c PATH] [-d PATH]
-                          [--userdir PATH] [-s NAME] [--strategy-path PATH]
-                          [-i TIMEFRAME] [--timerange TIMERANGE]
-                          [--data-format-ohlcv {json,jsongz,hdf5}]
-                          [--max-open-trades INT]
-                          [--stake-amount STAKE_AMOUNT] [--fee FLOAT]
-                          [--hyperopt NAME] [--hyperopt-path PATH] [--eps]
-                          [--dmmp] [--enable-protections]
-                          [--dry-run-wallet DRY_RUN_WALLET] [-e INT]
-                          [--spaces {all,buy,sell,roi,stoploss,trailing,default} [{all,buy,sell,roi,stoploss,trailing,default} ...]]
-                          [--print-all] [--no-color] [--print-json] [-j JOBS]
-                          [--random-state INT] [--min-trades INT]
-                          [--hyperopt-loss NAME]
-
-optional arguments:
-  -h, --help            show this help message and exit
-  -i TIMEFRAME, --timeframe TIMEFRAME, --ticker-interval TIMEFRAME
-                        Specify ticker interval (`1m`, `5m`, `30m`, `1h`,
-                        `1d`).
-  --timerange TIMERANGE
-                        Specify what timerange of data to use.
-  --data-format-ohlcv {json,jsongz,hdf5}
-                        Storage format for downloaded candle (OHLCV) data.
-                        (default: `None`).
-  --max-open-trades INT
-                        Override the value of the `max_open_trades`
-                        configuration setting.
-  --stake-amount STAKE_AMOUNT
-                        Override the value of the `stake_amount` configuration
-                        setting.
-  --fee FLOAT           Specify fee ratio. Will be applied twice (on trade
-                        entry and exit).
-  --hyperopt NAME       Specify hyperopt class name which will be used by the
-                        bot.
-  --hyperopt-path PATH  Specify additional lookup path for Hyperopt and
-                        Hyperopt Loss functions.
-  --eps, --enable-position-stacking
-                        Allow buying the same pair multiple times (position
-                        stacking).
-  --dmmp, --disable-max-market-positions
-                        Disable applying `max_open_trades` during backtest
-                        (same as setting `max_open_trades` to a very high
-                        number).
-  --enable-protections, --enableprotections
-                        Enable protections for backtesting.Will slow
-                        backtesting down by a considerable amount, but will
-                        include configured protections
-  --dry-run-wallet DRY_RUN_WALLET, --starting-balance DRY_RUN_WALLET
-                        Starting balance, used for backtesting / hyperopt and
-                        dry-runs.
-  -e INT, --epochs INT  Specify number of epochs (default: 100).
-  --spaces {all,buy,sell,roi,stoploss,trailing,default} [{all,buy,sell,roi,stoploss,trailing,default} ...]
-                        Specify which parameters to hyperopt. Space-separated
-                        list.
-  --print-all           Print all results, not only the best ones.
-  --no-color            Disable colorization of hyperopt results. May be
-                        useful if you are redirecting output to a file.
-  --print-json          Print output in JSON format.
-  -j JOBS, --job-workers JOBS
-                        The number of concurrently running jobs for
-                        hyperoptimization (hyperopt worker processes). If -1
-                        (default), all CPUs are used, for -2, all CPUs but one
-                        are used, etc. If 1 is given, no parallel computing
-                        code is used at all.
-  --random-state INT    Set random state to some positive integer for
-                        reproducible hyperopt results.
-  --min-trades INT      Set minimal desired number of trades for evaluations
-                        in the hyperopt optimization path (default: 1).
-  --hyperopt-loss NAME  Specify the class name of the hyperopt loss function
-                        class (IHyperOptLoss). Different functions can
-                        generate completely different results, since the
-                        target for optimization is different. Built-in
-                        Hyperopt-loss-functions are:
-                        ShortTradeDurHyperOptLoss, OnlyProfitHyperOptLoss,
-                        SharpeHyperOptLoss, SharpeHyperOptLossDaily,
-                        SortinoHyperOptLoss, SortinoHyperOptLossDaily
-
-Common arguments:
-  -v, --verbose         Verbose mode (-vv for more, -vvv to get all messages).
-  --logfile FILE        Log to the file specified. Special values are:
-                        'syslog', 'journald'. See the documentation for more
-                        details.
-  -V, --version         show program's version number and exit
-  -c PATH, --config PATH
-                        Specify configuration file (default:
-                        `userdir/config.json` or `config.json` whichever
-                        exists). Multiple --config options may be used. Can be
-                        set to `-` to read config from stdin.
-  -d PATH, --datadir PATH
-                        Path to directory with historical backtesting data.
-  --userdir PATH, --user-data-dir PATH
-                        Path to userdata directory.
-
-Strategy arguments:
-  -s NAME, --strategy NAME
-                        Specify strategy class name which will be used by the
-                        bot.
-  --strategy-path PATH  Specify additional strategy lookup path.
-
-```
-
-## Prepare Hyperopting
-
-Before we start digging into Hyperopt, we recommend you to take a look at
-the sample hyperopt file located in [user_data/hyperopts/](https://github.com/freqtrade/freqtrade/blob/develop/freqtrade/templates/sample_hyperopt.py).
-
-Configuring hyperopt is similar to writing your own strategy, and many tasks will be similar.
+Configuring an explicit hyperopt file is similar to writing your own strategy, and many tasks will be similar.
 
 !!! Tip "About this page"
-For this page, we will be using a fictional strategy called `AwesomeStrategy` - which will be optimized using the `AwesomeHyperopt` class.
+    For this page, we will be using a fictional strategy called `AwesomeStrategy` - which will be optimized using the `AwesomeHyperopt` class.
 
-The simplest way to get started is to use the following, command, which will create a new hyperopt file from a template, which will be located under `user_data/hyperopts/AwesomeHyperopt.py`.
+### Create a Custom Hyperopt File
+
+The simplest way to get started is to use the following command, which will create a new hyperopt file from a template, which will be located under `user_data/hyperopts/AwesomeHyperopt.py`.
+
+Let assume you want a hyperopt file `AwesomeHyperopt.py`:
 
 ``` bash
 freqtrade new-hyperopt --hyperopt AwesomeHyperopt
 ```
 
-### Hyperopt checklist
+### Legacy Hyperopt checklist
 
 Checklist on all tasks / possibilities in hyperopt
 
@@ -168,7 +35,7 @@ Depending on the space you want to optimize, only some of the below are required
 * fill `sell_indicator_space` - for sell signal optimization
 
 !!! Note
-`populate_indicators` needs to create all indicators any of thee spaces may use, otherwise hyperopt will not work.
+    `populate_indicators` needs to create all indicators any of thee spaces may use, otherwise hyperopt will not work.
 
 Optional in hyperopt - can also be loaded from a strategy (recommended):
 
@@ -177,8 +44,8 @@ Optional in hyperopt - can also be loaded from a strategy (recommended):
 * `populate_sell_trend` - fallback if not optimizing for sell space. should come from strategy
 
 !!! Note
-You always have to provide a strategy to Hyperopt, even if your custom Hyperopt class contains all methods.
-Assuming the optional methods are not in your hyperopt file, please use `--strategy AweSomeStrategy` which contains these methods so hyperopt can use these methods instead.
+    You always have to provide a strategy to Hyperopt, even if your custom Hyperopt class contains all methods.
+    Assuming the optional methods are not in your hyperopt file, please use `--strategy AweSomeStrategy` which contains these methods so hyperopt can use these methods instead.
 
 Rarely you may also need to override:
 
@@ -187,67 +54,7 @@ Rarely you may also need to override:
 * `stoploss_space` - for custom stoploss optimization (if you need the range for the stoploss parameter in the optimization hyperspace that differs from default)
 * `trailing_space` - for custom trailing stop optimization (if you need the ranges for the trailing stop parameters in the optimization hyperspace that differ from default)
 
-!!! Tip "Quickly optimize ROI, stoploss and trailing stoploss"
-You can quickly optimize the spaces `roi`, `stoploss` and `trailing` without changing anything (i.e. without creation of a "complete" Hyperopt class with dimensions, parameters, triggers and guards, as described in this document) from the default hyperopt template by relying on your strategy to do most of the calculations.
-
-    ```python
-    # Have a working strategy at hand.
-    freqtrade new-hyperopt --hyperopt EmptyHyperopt
-
-    freqtrade hyperopt --hyperopt EmptyHyperopt --hyperopt-loss SharpeHyperOptLossDaily --spaces roi stoploss trailing --strategy MyWorkingStrategy --config config.json -e 100
-    ```
-
-### Create a Custom Hyperopt File
-
-Let assume you want a hyperopt file `AwesomeHyperopt.py`:
-
-``` bash
-freqtrade new-hyperopt --hyperopt AwesomeHyperopt
-```
-
-This command will create a new hyperopt file from a template, allowing you to get started quickly.
-
-### Configure your Guards and Triggers
-
-There are two places you need to change in your hyperopt file to add a new buy hyperopt for testing:
-
-* Inside `indicator_space()` - the parameters hyperopt shall be optimizing.
-* Within `buy_strategy_generator()` - populate the nested `populate_buy_trend()` to apply the parameters.
-
-There you have two different types of indicators: 1. `guards` and 2. `triggers`.
-
-1. Guards are conditions like "never buy if ADX < 10", or never buy if current price is over EMA10.
-2. Triggers are ones that actually trigger buy in specific moment, like "buy when EMA5 crosses over EMA10" or "buy when close price touches lower Bollinger band".
-
-!!! Hint "Guards and Triggers"
-Technically, there is no difference between Guards and Triggers.  
-However, this guide will make this distinction to make it clear that signals should not be "sticking".
-Sticking signals are signals that are active for multiple candles. This can lead into buying a signal late (right before the signal disappears - which means that the chance of success is a lot lower than right at the beginning).
-
-Hyper-optimization will, for each epoch round, pick one trigger and possibly
-multiple guards. The constructed strategy will be something like "*buy exactly when close price touches lower Bollinger band, BUT only if
-ADX > 10*".
-
-If you have updated the buy strategy, i.e. changed the contents of `populate_buy_trend()` method, you have to update the `guards` and `triggers` your hyperopt must use correspondingly.
-
-#### Sell optimization
-
-Similar to the buy-signal above, sell-signals can also be optimized.
-Place the corresponding settings into the following methods
-
-* Inside `sell_indicator_space()` - the parameters hyperopt shall be optimizing.
-* Within `sell_strategy_generator()` - populate the nested method `populate_sell_trend()` to apply the parameters.
-
-The configuration and rules are the same than for buy signals.
-To avoid naming collisions in the search-space, please prefix all sell-spaces with `sell-`.
-
-#### Using timeframe as a part of the Strategy
-
-The Strategy class exposes the timeframe value as the `self.timeframe` attribute.
-The same value is available as class-attribute `HyperoptName.timeframe`.
-In the case of the linked sample-value this would be `AwesomeHyperopt.timeframe`.
-
-## Solving a Mystery
+### Defining a buy signal optimization
 
 Let's say you are curious: should you use MACD crossings or lower Bollinger
 Bands to trigger your buys. And you also wonder should you use RSI or ADX to
@@ -272,13 +79,12 @@ We will start by defining a search space:
 ```
 
 Above definition says: I have five parameters I want you to randomly combine
-to find the best combination. Two of them are integer values (`adx-value`
-and `rsi-value`) and I want you test in the range of values 20 to 40.  
+to find the best combination. Two of them are integer values (`adx-value` and `rsi-value`) and I want you test in the range of values 20 to 40.  
 Then we have three category variables. First two are either `True` or `False`.
-We use these to either enable or disable the ADX and RSI guards. The last
-one we call `trigger` and use it to decide which buy trigger we want to use.
+We use these to either enable or disable the ADX and RSI guards.
+The last one we call `trigger` and use it to decide which buy trigger we want to use.
 
-So let's write the buy strategy using these values:
+So let's write the buy strategy generator using these values:
 
 ```python
     @staticmethod
@@ -321,27 +127,20 @@ It will use the given historical data and make buys based on the buy signals gen
 Based on the results, hyperopt will tell you which parameter combination produced the best results (based on the configured [loss function](#loss-functions)).
 
 !!! Note
-The above setup expects to find ADX, RSI and Bollinger Bands in the populated indicators.
-When you want to test an indicator that isn't used by the bot currently, remember to
-add it to the `populate_indicators()` method in your strategy or hyperopt file.
+    The above setup expects to find ADX, RSI and Bollinger Bands in the populated indicators.
+    When you want to test an indicator that isn't used by the bot currently, remember to
+    add it to the `populate_indicators()` method in your strategy or hyperopt file.
 
-## Loss-functions
+### Sell optimization
 
-Each hyperparameter tuning requires a target. This is usually defined as a loss function (sometimes also called objective function), which should decrease for more desirable results, and increase for bad results.
+Similar to the buy-signal above, sell-signals can also be optimized.
+Place the corresponding settings into the following methods
 
-A loss function must be specified via the `--hyperopt-loss <Class-name>` argument (or optionally via the configuration under the `"hyperopt_loss"` key).
-This class should be in its own file within the `user_data/hyperopts/` directory.
+* Inside `sell_indicator_space()` - the parameters hyperopt shall be optimizing.
+* Within `sell_strategy_generator()` - populate the nested method `populate_sell_trend()` to apply the parameters.
 
-Currently, the following loss functions are builtin:
-
-* `ShortTradeDurHyperOptLoss` (default legacy Freqtrade hyperoptimization loss function) - Mostly for short trade duration and avoiding losses.
-* `OnlyProfitHyperOptLoss` (which takes only amount of profit into consideration)
-* `SharpeHyperOptLoss` (optimizes Sharpe Ratio calculated on trade returns relative to standard deviation)
-* `SharpeHyperOptLossDaily` (optimizes Sharpe Ratio calculated on **daily** trade returns relative to standard deviation)
-* `SortinoHyperOptLoss` (optimizes Sortino Ratio calculated on trade returns relative to **downside** standard deviation)
-* `SortinoHyperOptLossDaily` (optimizes Sortino Ratio calculated on **daily** trade returns relative to **downside** standard deviation)
-
-Creation of a custom loss function is covered in the [Advanced Hyperopt](advanced-hyperopt.md) part of the documentation.
+The configuration and rules are the same than for buy signals.
+To avoid naming collisions in the search-space, please prefix all sell-spaces with `sell-`.
 
 ## Execute Hyperopt
 
@@ -362,24 +161,9 @@ Doing multiple runs (executions) with a few 1000 epochs and different random sta
 The `--spaces all` option determines that all possible parameters should be optimized. Possibilities are listed below.
 
 !!! Note
-Hyperopt will store hyperopt results with the timestamp of the hyperopt start time.
-Reading commands (`hyperopt-list`, `hyperopt-show`) can use `--hyperopt-filename <filename>` to read and display older hyperopt results.
-You can find a list of filenames with `ls -l user_data/hyperopt_results/`.
-
-### Execute Hyperopt with different historical data source
-
-If you would like to hyperopt parameters using an alternate historical data set that
-you have on-disk, use the `--datadir PATH` option. By default, hyperopt
-uses data from directory `user_data/data`.
-
-### Running Hyperopt with a smaller test-set
-
-Use the `--timerange` argument to change how much of the test-set you want to use.
-For example, to use one month of data, pass the following parameter to the hyperopt call:
-
-```bash
-freqtrade hyperopt --hyperopt <hyperoptname> --strategy <strategyname> --timerange 20180401-20180501
-```
+    Hyperopt will store hyperopt results with the timestamp of the hyperopt start time.
+    Reading commands (`hyperopt-list`, `hyperopt-show`) can use `--hyperopt-filename <filename>` to read and display older hyperopt results.
+    You can find a list of filenames with `ls -l user_data/hyperopt_results/`.
 
 ### Running Hyperopt using methods from a strategy
 
@@ -389,57 +173,6 @@ Hyperopt can reuse `populate_indicators`, `populate_buy_trend`, `populate_sell_t
 freqtrade hyperopt --hyperopt AwesomeHyperopt --hyperopt-loss SharpeHyperOptLossDaily --strategy AwesomeStrategy
 ```
 
-### Running Hyperopt with Smaller Search Space
-
-Use the `--spaces` option to limit the search space used by hyperopt.
-Letting Hyperopt optimize everything is a huuuuge search space.
-Often it might make more sense to start by just searching for initial buy algorithm.
-Or maybe you just want to optimize your stoploss or roi table for that awesome new buy strategy you have.
-
-Legal values are:
-
-* `all`: optimize everything
-* `buy`: just search for a new buy strategy
-* `sell`: just search for a new sell strategy
-* `roi`: just optimize the minimal profit table for your strategy
-* `stoploss`: search for the best stoploss value
-* `trailing`: search for the best trailing stop values
-* `default`: `all` except `trailing`
-* space-separated list of any of the above values for example `--spaces roi stoploss`
-
-The default Hyperopt Search Space, used when no `--space` command line option is specified, does not include the `trailing` hyperspace. We recommend you to run optimization for the `trailing` hyperspace separately, when the best parameters for other hyperspaces were found, validated and pasted into your custom strategy.
-
-### Position stacking and disabling max market positions
-
-In some situations, you may need to run Hyperopt (and Backtesting) with the
-`--eps`/`--enable-position-staking` and `--dmmp`/`--disable-max-market-positions` arguments.
-
-By default, hyperopt emulates the behavior of the Freqtrade Live Run/Dry Run, where only one
-open trade is allowed for every traded pair. The total number of trades open for all pairs
-is also limited by the `max_open_trades` setting. During Hyperopt/Backtesting this may lead to
-some potential trades to be hidden (or masked) by previously open trades.
-
-The `--eps`/`--enable-position-stacking` argument allows emulation of buying the same pair multiple times,
-while `--dmmp`/`--disable-max-market-positions` disables applying `max_open_trades`
-during Hyperopt/Backtesting (which is equal to setting `max_open_trades` to a very high
-number).
-
-!!! Note
-Dry/live runs will **NOT** use position stacking - therefore it does make sense to also validate the strategy without this as it's closer to reality.
-
-You can also enable position stacking in the configuration file by explicitly setting
-`"position_stacking"=true`.
-
-### Reproducible results
-
-The search for optimal parameters starts with a few (currently 30) random combinations in the hyperspace of parameters, random Hyperopt epochs. These random epochs are marked with an asterisk character (`*`) in the first column in the Hyperopt output.
-
-The initial state for generation of these random values (random state) is controlled by the value of the `--random-state` command line option. You can set it to some arbitrary value of your choice to obtain reproducible results.
-
-If you have not set this value explicitly in the command line options, Hyperopt seeds the random state with some random value for you. The random state value for each Hyperopt run is shown in the log, so you can copy and paste it into the `--random-state` command line option to repeat the set of the initial random epochs used.
-
-If you have not changed anything in the command line options, configuration, timerange, Strategy and Hyperopt classes, historical data and the Loss Function -- you should obtain same hyper-optimization results with same random state value used.
-
 ## Understand the Hyperopt Result
 
 Once Hyperopt is completed you can use the result to create a new strategy.
@@ -460,9 +193,9 @@ Buy hyperspace params:
 
 You should understand this result like:
 
-- The buy trigger that worked best was `bb_lower`.
-- You should not use ADX because `adx-enabled: False`)
-- You should **consider** using the RSI indicator (`rsi-enabled: True` and the best value is `29.0` (`rsi-value: 29.0`)
+* The buy trigger that worked best was `bb_lower`.
+* You should not use ADX because `adx-enabled: False`)
+* You should **consider** using the RSI indicator (`rsi-enabled: True` and the best value is `29.0` (`rsi-value: 29.0`)
 
 You have to look inside your strategy file into `buy_strategy_generator()`
 method, what those values match to.
@@ -486,63 +219,6 @@ def populate_buy_trend(self, dataframe: DataFrame) -> DataFrame:
     return dataframe
 ```
 
-By default, hyperopt prints colorized results -- epochs with positive profit are printed in the green color. This highlighting helps you find epochs that can be interesting for later analysis. Epochs with zero total profit or with negative profits (losses) are printed in the normal color. If you do not need colorization of results (for instance, when you are redirecting hyperopt output to a file) you can switch colorization off by specifying the `--no-color` option in the command line.
-
-You can use the `--print-all` command line option if you would like to see all results in the hyperopt output, not only the best ones. When `--print-all` is used, current best results are also colorized by default -- they are printed in bold (bright) style. This can also be switched off with the `--no-color` command line option.
-
-!!! Note "Windows and color output"
-Windows does not support color-output natively, therefore it is automatically disabled. To have color-output for hyperopt running under windows, please consider using WSL.
-
-### Understand Hyperopt ROI results
-
-If you are optimizing ROI (i.e. if optimization search-space contains 'all', 'default' or 'roi'), your result will look as follows and include a ROI table:
-
-```
-Best result:
-
-    44/100:    135 trades. Avg profit  0.57%. Total profit  0.03871918 BTC (0.7722Σ%). Avg duration 180.4 mins. Objective: 1.94367
-
-ROI table:
-{   0: 0.10674,
-    21: 0.09158,
-    78: 0.03634,
-    118: 0}
-```
-
-In order to use this best ROI table found by Hyperopt in backtesting and for live trades/dry-run, copy-paste it as the value of the `minimal_roi` attribute of your custom strategy:
-
-```
-    # Minimal ROI designed for the strategy.
-    # This attribute will be overridden if the config file contains "minimal_roi"
-    minimal_roi = {
-        0: 0.10674,
-        21: 0.09158,
-        78: 0.03634,
-        118: 0
-    }
-```
-
-As stated in the comment, you can also use it as the value of the `minimal_roi` setting in the configuration file.
-
-#### Default ROI Search Space
-
-If you are optimizing ROI, Freqtrade creates the 'roi' optimization hyperspace for you -- it's the hyperspace of components for the ROI tables. By default, each ROI table generated by the Freqtrade consists of 4 rows (steps). Hyperopt implements adaptive ranges for ROI tables with ranges for values in the ROI steps that depend on the timeframe used. By default the values vary in the following ranges (for some of the most used timeframes, values are rounded to 5 digits after the decimal point):
-
-| # step | 1m     |                   | 5m       |             | 1h         |                   | 1d           |                   |
-| ------ | ------ | ----------------- | -------- | ----------- | ---------- | ----------------- | ------------ | ----------------- |
-| 1      | 0      | 0.01161...0.11992 | 0        | 0.03...0.31 | 0          | 0.06883...0.71124 | 0            | 0.12178...1.25835 |
-| 2      | 2...8  | 0.00774...0.04255 | 10...40  | 0.02...0.11 | 120...480  | 0.04589...0.25238 | 2880...11520 | 0.08118...0.44651 |
-| 3      | 4...20 | 0.00387...0.01547 | 20...100 | 0.01...0.04 | 240...1200 | 0.02294...0.09177 | 5760...28800 | 0.04059...0.16237 |
-| 4      | 6...44 | 0.0               | 30...220 | 0.0         | 360...2640 | 0.0               | 8640...63360 | 0.0               |
-
-These ranges should be sufficient in most cases. The minutes in the steps (ROI dict keys) are scaled linearly depending on the timeframe used. The ROI values in the steps (ROI dict values) are scaled logarithmically depending on the timeframe used.
-
-If you have the `generate_roi_table()` and `roi_space()` methods in your custom hyperopt file, remove them in order to utilize these adaptive ROI tables and the ROI hyperoptimization space generated by Freqtrade by default.
-
-Override the `roi_space()` method if you need components of the ROI tables to vary in other ranges. Override the `generate_roi_table()` and `roi_space()` methods and implement your own custom approach for generation of the ROI tables during hyperoptimization if you need a different structure of the ROI tables or other amount of rows (steps).
-
-A sample for these methods can be found in [sample_hyperopt_advanced.py](https://github.com/freqtrade/freqtrade/blob/develop/freqtrade/templates/sample_hyperopt_advanced.py).
-
 ### Understand Hyperopt Stoploss results
 
 If you are optimizing stoploss values (i.e. if optimization search-space contains 'all', 'default' or 'stoploss'), your result will look as follows and include stoploss:
@@ -571,56 +247,10 @@ In order to use this best stoploss value found by Hyperopt in backtesting and fo
 
 As stated in the comment, you can also use it as the value of the `stoploss` setting in the configuration file.
 
-#### Default Stoploss Search Space
-
-If you are optimizing stoploss values, Freqtrade creates the 'stoploss' optimization hyperspace for you. By default, the stoploss values in that hyperspace vary in the range -0.35...-0.02, which is sufficient in most cases.
-
-If you have the `stoploss_space()` method in your custom hyperopt file, remove it in order to utilize Stoploss hyperoptimization space generated by Freqtrade by default.
-
-Override the `stoploss_space()` method and define the desired range in it if you need stoploss values to vary in other range during hyperoptimization. A sample for this method can be found in [user_data/hyperopts/sample_hyperopt_advanced.py](https://github.com/freqtrade/freqtrade/blob/develop/freqtrade/templates/sample_hyperopt_advanced.py).
-
-### Understand Hyperopt Trailing Stop results
-
-If you are optimizing trailing stop values (i.e. if optimization search-space contains 'all' or 'trailing'), your result will look as follows and include trailing stop parameters:
-
-```
-Best result:
-
-    45/100:    606 trades. Avg profit  1.04%. Total profit  0.31555614 BTC ( 630.48Σ%). Avg duration 150.3 mins. Objective: -1.10161
-
-Trailing stop:
-{   'trailing_only_offset_is_reached': True,
-    'trailing_stop': True,
-    'trailing_stop_positive': 0.02001,
-    'trailing_stop_positive_offset': 0.06038}
-```
-
-In order to use these best trailing stop parameters found by Hyperopt in backtesting and for live trades/dry-run, copy-paste them as the values of the corresponding attributes of your custom strategy:
-
-``` python
-    # Trailing stop
-    # These attributes will be overridden if the config file contains corresponding values.
-    trailing_stop = True
-    trailing_stop_positive = 0.02001
-    trailing_stop_positive_offset = 0.06038
-    trailing_only_offset_is_reached = True
-```
-
-As stated in the comment, you can also use it as the values of the corresponding settings in the configuration file.
-
-#### Default Trailing Stop Search Space
-
-If you are optimizing trailing stop values, Freqtrade creates the 'trailing' optimization hyperspace for you. By default, the `trailing_stop` parameter is always set to True in that hyperspace, the value of the `trailing_only_offset_is_reached` vary between True and False, the values of the `trailing_stop_positive` and `trailing_stop_positive_offset` parameters vary in the ranges 0.02...0.35 and 0.01...0.1 correspondingly, which is sufficient in most cases.
-
-Override the `trailing_space()` method and define the desired range in it if you need values of the trailing stop parameters to vary in other ranges during hyperoptimization. A sample for this method can be found in [user_data/hyperopts/sample_hyperopt_advanced.py](https://github.com/freqtrade/freqtrade/blob/develop/freqtrade/templates/sample_hyperopt_advanced.py).
-
-## Show details of Hyperopt results
-
-After you run Hyperopt for the desired amount of epochs, you can later list all results for analysis, select only best or profitable once, and show the details for any of the epochs previously evaluated. This can be done with the `hyperopt-list` and `hyperopt-show` sub-commands. The usage of these sub-commands is described in the [Utils](utils.md#list-hyperopt-results) chapter.
 
 ## Validate backtesting results
 
-Once the optimized strategy has been implemented into your strategy, you should backtest this strategy to make sure everything is working as expected.
+Once the optimized parameters and conditions have been implemented into your strategy, you should backtest the strategy to make sure everything is working as expected.
 
 To achieve same results (number of trades, their durations, profit, etc.) than during Hyperopt, please use same configuration and parameters (timerange, timeframe, ...) used for hyperopt `--dmmp`/`--disable-max-market-positions` and `--eps`/`--enable-position-stacking` for Backtesting.
 

From 32a503491d76fa84f4c4823095b279eff0515bfc Mon Sep 17 00:00:00 2001
From: Matthias <xmatthias@outlook.com>
Date: Sat, 3 Apr 2021 15:41:43 +0200
Subject: [PATCH 25/32] Reorder hyperopt methods

---
 docs/hyperopt.md | 70 +++++++++++++++++++++++++-----------------------
 1 file changed, 36 insertions(+), 34 deletions(-)

diff --git a/docs/hyperopt.md b/docs/hyperopt.md
index 725afebf3..806ce3c94 100644
--- a/docs/hyperopt.md
+++ b/docs/hyperopt.md
@@ -355,10 +355,12 @@ uses data from directory `user_data/data`.
 ### Running Hyperopt with a smaller test-set
 
 Use the `--timerange` argument to change how much of the test-set you want to use.
-For example, to use one month of data, pass the following parameter to the hyperopt call:
+For example, to use one month of data, pass `--timerange 20210101-20210201` (from january 2021 - february 2021) to the hyperopt call.
+
+Full command:
 
 ```bash
-freqtrade hyperopt --hyperopt <hyperoptname> --strategy <strategyname> --timerange 20180401-20180501
+freqtrade hyperopt --hyperopt <hyperoptname> --strategy <strategyname> --timerange 20210101-20210201
 ```
 
 ### Running Hyperopt with Smaller Search Space
@@ -381,37 +383,6 @@ Legal values are:
 
 The default Hyperopt Search Space, used when no `--space` command line option is specified, does not include the `trailing` hyperspace. We recommend you to run optimization for the `trailing` hyperspace separately, when the best parameters for other hyperspaces were found, validated and pasted into your custom strategy.
 
-### Position stacking and disabling max market positions
-
-In some situations, you may need to run Hyperopt (and Backtesting) with the
-`--eps`/`--enable-position-staking` and `--dmmp`/`--disable-max-market-positions` arguments.
-
-By default, hyperopt emulates the behavior of the Freqtrade Live Run/Dry Run, where only one
-open trade is allowed for every traded pair. The total number of trades open for all pairs
-is also limited by the `max_open_trades` setting. During Hyperopt/Backtesting this may lead to
-some potential trades to be hidden (or masked) by previously open trades.
-
-The `--eps`/`--enable-position-stacking` argument allows emulation of buying the same pair multiple times,
-while `--dmmp`/`--disable-max-market-positions` disables applying `max_open_trades`
-during Hyperopt/Backtesting (which is equal to setting `max_open_trades` to a very high
-number).
-
-!!! Note
-    Dry/live runs will **NOT** use position stacking - therefore it does make sense to also validate the strategy without this as it's closer to reality.
-
-You can also enable position stacking in the configuration file by explicitly setting
-`"position_stacking"=true`.
-
-### Reproducible results
-
-The search for optimal parameters starts with a few (currently 30) random combinations in the hyperspace of parameters, random Hyperopt epochs. These random epochs are marked with an asterisk character (`*`) in the first column in the Hyperopt output.
-
-The initial state for generation of these random values (random state) is controlled by the value of the `--random-state` command line option. You can set it to some arbitrary value of your choice to obtain reproducible results.
-
-If you have not set this value explicitly in the command line options, Hyperopt seeds the random state with some random value for you. The random state value for each Hyperopt run is shown in the log, so you can copy and paste it into the `--random-state` command line option to repeat the set of the initial random epochs used.
-
-If you have not changed anything in the command line options, configuration, timerange, Strategy and Hyperopt classes, historical data and the Loss Function -- you should obtain same hyper-optimization results with same random state value used.
-
 ## Understand the Hyperopt Result
 
 Once Hyperopt is completed you can use the result to update your strategy.
@@ -580,7 +551,17 @@ If you are optimizing trailing stop values, Freqtrade creates the 'trailing' opt
 
 Override the `trailing_space()` method and define the desired range in it if you need values of the trailing stop parameters to vary in other ranges during hyperoptimization. A sample for this method can be found in [user_data/hyperopts/sample_hyperopt_advanced.py](https://github.com/freqtrade/freqtrade/blob/develop/freqtrade/templates/sample_hyperopt_advanced.py).
 
-### Output formatting
+### Reproducible results
+
+The search for optimal parameters starts with a few (currently 30) random combinations in the hyperspace of parameters, random Hyperopt epochs. These random epochs are marked with an asterisk character (`*`) in the first column in the Hyperopt output.
+
+The initial state for generation of these random values (random state) is controlled by the value of the `--random-state` command line option. You can set it to some arbitrary value of your choice to obtain reproducible results.
+
+If you have not set this value explicitly in the command line options, Hyperopt seeds the random state with some random value for you. The random state value for each Hyperopt run is shown in the log, so you can copy and paste it into the `--random-state` command line option to repeat the set of the initial random epochs used.
+
+If you have not changed anything in the command line options, configuration, timerange, Strategy and Hyperopt classes, historical data and the Loss Function -- you should obtain same hyper-optimization results with same random state value used.
+
+## Output formatting
 
 By default, hyperopt prints colorized results -- epochs with positive profit are printed in the green color. This highlighting helps you find epochs that can be interesting for later analysis. Epochs with zero total profit or with negative profits (losses) are printed in the normal color. If you do not need colorization of results (for instance, when you are redirecting hyperopt output to a file) you can switch colorization off by specifying the `--no-color` option in the command line.
 
@@ -589,6 +570,27 @@ You can use the `--print-all` command line option if you would like to see all r
 !!! Note "Windows and color output"
     Windows does not support color-output natively, therefore it is automatically disabled. To have color-output for hyperopt running under windows, please consider using WSL.
 
+## Position stacking and disabling max market positions
+
+In some situations, you may need to run Hyperopt (and Backtesting) with the
+`--eps`/`--enable-position-staking` and `--dmmp`/`--disable-max-market-positions` arguments.
+
+By default, hyperopt emulates the behavior of the Freqtrade Live Run/Dry Run, where only one
+open trade is allowed for every traded pair. The total number of trades open for all pairs
+is also limited by the `max_open_trades` setting. During Hyperopt/Backtesting this may lead to
+some potential trades to be hidden (or masked) by previously open trades.
+
+The `--eps`/`--enable-position-stacking` argument allows emulation of buying the same pair multiple times,
+while `--dmmp`/`--disable-max-market-positions` disables applying `max_open_trades`
+during Hyperopt/Backtesting (which is equal to setting `max_open_trades` to a very high
+number).
+
+!!! Note
+    Dry/live runs will **NOT** use position stacking - therefore it does make sense to also validate the strategy without this as it's closer to reality.
+
+You can also enable position stacking in the configuration file by explicitly setting
+`"position_stacking"=true`.
+
 ## Show details of Hyperopt results
 
 After you run Hyperopt for the desired amount of epochs, you can later list all results for analysis, select only best or profitable once, and show the details for any of the epochs previously evaluated. This can be done with the `hyperopt-list` and `hyperopt-show` sub-commands. The usage of these sub-commands is described in the [Utils](utils.md#list-hyperopt-results) chapter.

From c2d43a526cf5f0e96f016851b2b74eb814c9ac74 Mon Sep 17 00:00:00 2001
From: Matthias <xmatthias@outlook.com>
Date: Sat, 3 Apr 2021 16:08:08 +0200
Subject: [PATCH 26/32] Combine Legacy and advanced hyperopt sections

---
 docs/advanced-hyperopt.md | 349 ++++++++++++++++++++++++++++++--------
 docs/hyperopt.md          |  14 +-
 docs/hyperopt_legacy.md   | 259 ----------------------------
 3 files changed, 282 insertions(+), 340 deletions(-)
 delete mode 100644 docs/hyperopt_legacy.md

diff --git a/docs/advanced-hyperopt.md b/docs/advanced-hyperopt.md
index bdaafb936..6a559ec96 100644
--- a/docs/advanced-hyperopt.md
+++ b/docs/advanced-hyperopt.md
@@ -4,79 +4,6 @@ This page explains some advanced Hyperopt topics that may require higher
 coding skills and Python knowledge than creation of an ordinal hyperoptimization
 class.
 
-## Derived hyperopt classes
-
-Custom hyperopt classes can be derived in the same way [it can be done for strategies](strategy-customization.md#derived-strategies).
-
-Applying to hyperoptimization, as an example, you may override how dimensions are defined in your optimization hyperspace:
-
-```python
-class MyAwesomeHyperOpt(IHyperOpt):
-    ...
-    # Uses default stoploss dimension
-
-class MyAwesomeHyperOpt2(MyAwesomeHyperOpt):
-    @staticmethod
-    def stoploss_space() -> List[Dimension]:
-        # Override boundaries for stoploss
-        return [
-            Real(-0.33, -0.01, name='stoploss'),
-        ]
-```
-
-and then quickly switch between hyperopt classes, running optimization process with hyperopt class you need in each particular case:
-
-```
-$ freqtrade hyperopt --hyperopt MyAwesomeHyperOpt --hyperopt-loss SharpeHyperOptLossDaily --strategy MyAwesomeStrategy ...
-or
-$ freqtrade hyperopt --hyperopt MyAwesomeHyperOpt2 --hyperopt-loss SharpeHyperOptLossDaily --strategy MyAwesomeStrategy ...
-```
-
-## Sharing methods with your strategy
-
-Hyperopt classes provide access to the Strategy via the `strategy` class attribute.
-This can be a great way to reduce code duplication if used correctly, but will also complicate usage for inexperienced users.
-
-``` python
-from pandas import DataFrame
-from freqtrade.strategy.interface import IStrategy
-import freqtrade.vendor.qtpylib.indicators as qtpylib
-
-class MyAwesomeStrategy(IStrategy):
-
-    buy_params = {
-        'rsi-value': 30,
-        'adx-value': 35,
-    }
-
-    def populate_buy_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
-        return self.buy_strategy_generator(self.buy_params, dataframe, metadata)
-
-    @staticmethod
-    def buy_strategy_generator(params, dataframe: DataFrame, metadata: dict) -> DataFrame:
-        dataframe.loc[
-            (
-                qtpylib.crossed_above(dataframe['rsi'], params['rsi-value']) &
-                dataframe['adx'] > params['adx-value']) &
-                dataframe['volume'] > 0
-            )
-            , 'buy'] = 1
-        return dataframe
-
-class MyAwesomeHyperOpt(IHyperOpt):
-    ...
-    @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, metadata: dict) -> DataFrame:
-            # Call strategy's buy strategy generator
-            return self.StrategyClass.buy_strategy_generator(params, dataframe, metadata)
-
-        return populate_buy_trend
-```
-
 ## Creating and using a custom loss function
 
 To use a custom loss function class, make sure that the function `hyperopt_loss_function` is defined in your custom hyperopt loss class.
@@ -142,3 +69,279 @@ This function needs to return a floating point number (`float`). Smaller numbers
 
 !!! Note
     Please keep the arguments `*args` and `**kwargs` in the interface to allow us to extend this interface later.
+
+## Legacy Hyperopt
+
+This Section explains the configuration of an explicit Hyperopt file (separate to the strategy).
+
+!!! Warning "Deprecated / legacy mode"
+    Since the 2021.4 release you no longer have to write a separate hyperopt class, but all strategies can be hyperopted.
+    Please read the [main hyperopt page](hyperopt.md) for more details.
+
+### Prepare hyperopt file
+
+Configuring an explicit hyperopt file is similar to writing your own strategy, and many tasks will be similar.
+
+!!! Tip "About this page"
+    For this page, we will be using a fictional strategy called `AwesomeStrategy` - which will be optimized using the `AwesomeHyperopt` class.
+
+#### Create a Custom Hyperopt File
+
+The simplest way to get started is to use the following command, which will create a new hyperopt file from a template, which will be located under `user_data/hyperopts/AwesomeHyperopt.py`.
+
+Let assume you want a hyperopt file `AwesomeHyperopt.py`:
+
+``` bash
+freqtrade new-hyperopt --hyperopt AwesomeHyperopt
+```
+
+#### Legacy Hyperopt checklist
+
+Checklist on all tasks / possibilities in hyperopt
+
+Depending on the space you want to optimize, only some of the below are required:
+
+* fill `buy_strategy_generator` - for buy signal optimization
+* fill `indicator_space` - for buy signal optimization
+* fill `sell_strategy_generator` - for sell signal optimization
+* fill `sell_indicator_space` - for sell signal optimization
+
+!!! Note
+    `populate_indicators` needs to create all indicators any of thee spaces may use, otherwise hyperopt will not work.
+
+Optional in hyperopt - can also be loaded from a strategy (recommended):
+
+* `populate_indicators` - fallback to create indicators
+* `populate_buy_trend` - fallback if not optimizing for buy space. should come from strategy
+* `populate_sell_trend` - fallback if not optimizing for sell space. should come from strategy
+
+!!! Note
+    You always have to provide a strategy to Hyperopt, even if your custom Hyperopt class contains all methods.
+    Assuming the optional methods are not in your hyperopt file, please use `--strategy AweSomeStrategy` which contains these methods so hyperopt can use these methods instead.
+
+Rarely you may also need to override:
+
+* `roi_space` - for custom ROI optimization (if you need the ranges for the ROI parameters in the optimization hyperspace that differ from default)
+* `generate_roi_table` - for custom ROI optimization (if you need the ranges for the values in the ROI table that differ from default or the number of entries (steps) in the ROI table which differs from the default 4 steps)
+* `stoploss_space` - for custom stoploss optimization (if you need the range for the stoploss parameter in the optimization hyperspace that differs from default)
+* `trailing_space` - for custom trailing stop optimization (if you need the ranges for the trailing stop parameters in the optimization hyperspace that differ from default)
+
+#### Defining a buy signal optimization
+
+Let's say you are curious: should you use MACD crossings or lower Bollinger
+Bands to trigger your buys. And you also wonder should you use RSI or ADX to
+help with those buy decisions. If you decide to use RSI or ADX, which values
+should I use for them? So let's use hyperparameter optimization to solve this
+mystery.
+
+We will start by defining a search space:
+
+```python
+    def indicator_space() -> List[Dimension]:
+        """
+        Define your Hyperopt space for searching strategy parameters
+        """
+        return [
+            Integer(20, 40, name='adx-value'),
+            Integer(20, 40, name='rsi-value'),
+            Categorical([True, False], name='adx-enabled'),
+            Categorical([True, False], name='rsi-enabled'),
+            Categorical(['bb_lower', 'macd_cross_signal'], name='trigger')
+        ]
+```
+
+Above definition says: I have five parameters I want you to randomly combine
+to find the best combination. Two of them are integer values (`adx-value` and `rsi-value`) and I want you test in the range of values 20 to 40.  
+Then we have three category variables. First two are either `True` or `False`.
+We use these to either enable or disable the ADX and RSI guards.
+The last one we call `trigger` and use it to decide which buy trigger we want to use.
+
+So let's write the buy strategy generator using these values:
+
+```python
+    @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, metadata: dict) -> DataFrame:
+            conditions = []
+            # GUARDS AND TRENDS
+            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 'trigger' in params:
+                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']
+                    ))
+
+            # Check that volume is not 0
+            conditions.append(dataframe['volume'] > 0)
+
+            if conditions:
+                dataframe.loc[
+                    reduce(lambda x, y: x & y, conditions),
+                    'buy'] = 1
+
+            return dataframe
+
+        return populate_buy_trend
+```
+
+Hyperopt will now call `populate_buy_trend()` many times (`epochs`) with different value combinations.  
+It will use the given historical data and make buys based on the buy signals generated with the above function.  
+Based on the results, hyperopt will tell you which parameter combination produced the best results (based on the configured [loss function](#loss-functions)).
+
+!!! Note
+    The above setup expects to find ADX, RSI and Bollinger Bands in the populated indicators.
+    When you want to test an indicator that isn't used by the bot currently, remember to
+    add it to the `populate_indicators()` method in your strategy or hyperopt file.
+
+#### Sell optimization
+
+Similar to the buy-signal above, sell-signals can also be optimized.
+Place the corresponding settings into the following methods
+
+* Inside `sell_indicator_space()` - the parameters hyperopt shall be optimizing.
+* Within `sell_strategy_generator()` - populate the nested method `populate_sell_trend()` to apply the parameters.
+
+The configuration and rules are the same than for buy signals.
+To avoid naming collisions in the search-space, please prefix all sell-spaces with `sell-`.
+
+### Execute Hyperopt
+
+Once you have updated your hyperopt configuration you can run it.
+Because hyperopt tries a lot of combinations to find the best parameters it will take time to get a good result. More time usually results in better results.
+
+We strongly recommend to use `screen` or `tmux` to prevent any connection loss.
+
+```bash
+freqtrade hyperopt --config config.json --hyperopt <hyperoptname> --hyperopt-loss <hyperoptlossname> --strategy <strategyname> -e 500 --spaces all
+```
+
+Use `<hyperoptname>` as the name of the custom hyperopt used.
+
+The `-e` option will set how many evaluations hyperopt will do. Since hyperopt uses Bayesian search, running too many epochs at once may not produce greater results. Experience has shown that best results are usually not improving much after 500-1000 epochs.  
+Doing multiple runs (executions) with a few 1000 epochs and different random state will most likely produce different results.
+
+The `--spaces all` option determines that all possible parameters should be optimized. Possibilities are listed below.
+
+!!! Note
+    Hyperopt will store hyperopt results with the timestamp of the hyperopt start time.
+    Reading commands (`hyperopt-list`, `hyperopt-show`) can use `--hyperopt-filename <filename>` to read and display older hyperopt results.
+    You can find a list of filenames with `ls -l user_data/hyperopt_results/`.
+
+#### Running Hyperopt using methods from a strategy
+
+Hyperopt can reuse `populate_indicators`, `populate_buy_trend`, `populate_sell_trend` from your strategy, assuming these methods are **not** in your custom hyperopt file, and a strategy is provided.
+
+```bash
+freqtrade hyperopt --hyperopt AwesomeHyperopt --hyperopt-loss SharpeHyperOptLossDaily --strategy AwesomeStrategy
+```
+
+### Understand the Hyperopt Result
+
+Once Hyperopt is completed you can use the result to create a new strategy.
+Given the following result from hyperopt:
+
+```
+Best result:
+
+    44/100:    135 trades. Avg profit  0.57%. Total profit  0.03871918 BTC (0.7722Σ%). Avg duration 180.4 mins. Objective: 1.94367
+
+Buy hyperspace params:
+{    'adx-value': 44,
+     'rsi-value': 29,
+     'adx-enabled': False,
+     'rsi-enabled': True,
+     'trigger': 'bb_lower'}
+```
+
+You should understand this result like:
+
+* The buy trigger that worked best was `bb_lower`.
+* You should not use ADX because `adx-enabled: False`)
+* You should **consider** using the RSI indicator (`rsi-enabled: True` and the best value is `29.0` (`rsi-value: 29.0`)
+
+You have to look inside your strategy file into `buy_strategy_generator()`
+method, what those values match to.
+
+So for example you had `rsi-value: 29.0` so we would look at `rsi`-block, that translates to the following code block:
+
+```python
+(dataframe['rsi'] < 29.0)
+```
+
+Translating your whole hyperopt result as the new buy-signal would then look like:
+
+```python
+def populate_buy_trend(self, dataframe: DataFrame) -> DataFrame:
+    dataframe.loc[
+        (
+            (dataframe['rsi'] < 29.0) &  # rsi-value
+            dataframe['close'] < dataframe['bb_lowerband']  # trigger
+        ),
+        'buy'] = 1
+    return dataframe
+```
+
+### Validate backtesting results
+
+Once the optimized parameters and conditions have been implemented into your strategy, you should backtest the strategy to make sure everything is working as expected.
+
+To achieve same results (number of trades, their durations, profit, etc.) than during Hyperopt, please use same configuration and parameters (timerange, timeframe, ...) used for hyperopt `--dmmp`/`--disable-max-market-positions` and `--eps`/`--enable-position-stacking` for Backtesting.
+
+Should results don't match, please double-check to make sure you transferred all conditions correctly.
+Pay special care to the stoploss (and trailing stoploss) parameters, as these are often set in configuration files, which override changes to the strategy.
+You should also carefully review the log of your backtest to ensure that there were no parameters inadvertently set by the configuration (like `stoploss` or `trailing_stop`).
+
+### Sharing methods with your strategy
+
+Hyperopt classes provide access to the Strategy via the `strategy` class attribute.
+This can be a great way to reduce code duplication if used correctly, but will also complicate usage for inexperienced users.
+
+``` python
+from pandas import DataFrame
+from freqtrade.strategy.interface import IStrategy
+import freqtrade.vendor.qtpylib.indicators as qtpylib
+
+class MyAwesomeStrategy(IStrategy):
+
+    buy_params = {
+        'rsi-value': 30,
+        'adx-value': 35,
+    }
+
+    def populate_buy_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
+        return self.buy_strategy_generator(self.buy_params, dataframe, metadata)
+
+    @staticmethod
+    def buy_strategy_generator(params, dataframe: DataFrame, metadata: dict) -> DataFrame:
+        dataframe.loc[
+            (
+                qtpylib.crossed_above(dataframe['rsi'], params['rsi-value']) &
+                dataframe['adx'] > params['adx-value']) &
+                dataframe['volume'] > 0
+            )
+            , 'buy'] = 1
+        return dataframe
+
+class MyAwesomeHyperOpt(IHyperOpt):
+    ...
+    @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, metadata: dict) -> DataFrame:
+            # Call strategy's buy strategy generator
+            return self.StrategyClass.buy_strategy_generator(params, dataframe, metadata)
+
+        return populate_buy_trend
+```
diff --git a/docs/hyperopt.md b/docs/hyperopt.md
index 806ce3c94..cb8d4ad9d 100644
--- a/docs/hyperopt.md
+++ b/docs/hyperopt.md
@@ -15,7 +15,7 @@ To learn how to get data for the pairs and exchange you're interested in, head o
 !!! Note
     Since 2021.4 release you no longer have to write a separate hyperopt class, but can configure the parameters directly in the strategy.
     The legacy method is still supported, but it is no longer the recommended way of setting up hyperopt. 
-    The legacy documentation is available at [Legacy Hyperopt](hyperopt_legacy.md).
+    The legacy documentation is available at [Legacy Hyperopt](advanced-hyperopt.md#legacy-hyperopt).
 
 ## Install hyperopt dependencies
 
@@ -247,12 +247,11 @@ class MyAwesomeStrategy(IStrategy):
     buy_trigger = CategoricalParameter(['bb_lower', 'macd_cross_signal']),
 ```
 
-Above definition says: I have five parameters I want you to randomly combine
-to find the best combination. Two of them are integer values (`buy_adx`
-and `buy_rsi`) and I want you test in the range of values 20 to 40.  
+Above definition says: I have five parameters I want to randomly combine to find the best combination.
+Two of them are integer values (`buy_adx` and `buy_rsi`) and I want you test in the range of values 20 to 40.  
 Then we have three category variables. First two are either `True` or `False`.
-We use these to either enable or disable the ADX and RSI guards. The last
-one we call `trigger` and use it to decide which buy trigger we want to use.
+We use these to either enable or disable the ADX and RSI guards.
+The last one we call `trigger` and use it to decide which buy trigger we want to use.
 
 So let's write the buy strategy using these values:
 
@@ -349,8 +348,7 @@ The `--spaces all` option determines that all possible parameters should be opti
 ### Execute Hyperopt with different historical data source
 
 If you would like to hyperopt parameters using an alternate historical data set that
-you have on-disk, use the `--datadir PATH` option. By default, hyperopt
-uses data from directory `user_data/data`.
+you have on-disk, use the `--datadir PATH` option. By default, hyperopt uses data from directory `user_data/data`.
 
 ### Running Hyperopt with a smaller test-set
 
diff --git a/docs/hyperopt_legacy.md b/docs/hyperopt_legacy.md
deleted file mode 100644
index 03c1eb358..000000000
--- a/docs/hyperopt_legacy.md
+++ /dev/null
@@ -1,259 +0,0 @@
-# Legacy Hyperopt
-
-This Section explains the configuration of an explicit Hyperopt file (separate to the strategy).
-
-!!! Warning "Deprecated / legacy mode"
-    Since the 2021.4 release you no longer have to write a separate hyperopt class, but all strategies can be hyperopted.
-    Please read the [main hyperopt page](hyperopt.md) for more details.
-
-## Prepare hyperopt file
-
-Configuring an explicit hyperopt file is similar to writing your own strategy, and many tasks will be similar.
-
-!!! Tip "About this page"
-    For this page, we will be using a fictional strategy called `AwesomeStrategy` - which will be optimized using the `AwesomeHyperopt` class.
-
-### Create a Custom Hyperopt File
-
-The simplest way to get started is to use the following command, which will create a new hyperopt file from a template, which will be located under `user_data/hyperopts/AwesomeHyperopt.py`.
-
-Let assume you want a hyperopt file `AwesomeHyperopt.py`:
-
-``` bash
-freqtrade new-hyperopt --hyperopt AwesomeHyperopt
-```
-
-### Legacy Hyperopt checklist
-
-Checklist on all tasks / possibilities in hyperopt
-
-Depending on the space you want to optimize, only some of the below are required:
-
-* fill `buy_strategy_generator` - for buy signal optimization
-* fill `indicator_space` - for buy signal optimization
-* fill `sell_strategy_generator` - for sell signal optimization
-* fill `sell_indicator_space` - for sell signal optimization
-
-!!! Note
-    `populate_indicators` needs to create all indicators any of thee spaces may use, otherwise hyperopt will not work.
-
-Optional in hyperopt - can also be loaded from a strategy (recommended):
-
-* `populate_indicators` - fallback to create indicators
-* `populate_buy_trend` - fallback if not optimizing for buy space. should come from strategy
-* `populate_sell_trend` - fallback if not optimizing for sell space. should come from strategy
-
-!!! Note
-    You always have to provide a strategy to Hyperopt, even if your custom Hyperopt class contains all methods.
-    Assuming the optional methods are not in your hyperopt file, please use `--strategy AweSomeStrategy` which contains these methods so hyperopt can use these methods instead.
-
-Rarely you may also need to override:
-
-* `roi_space` - for custom ROI optimization (if you need the ranges for the ROI parameters in the optimization hyperspace that differ from default)
-* `generate_roi_table` - for custom ROI optimization (if you need the ranges for the values in the ROI table that differ from default or the number of entries (steps) in the ROI table which differs from the default 4 steps)
-* `stoploss_space` - for custom stoploss optimization (if you need the range for the stoploss parameter in the optimization hyperspace that differs from default)
-* `trailing_space` - for custom trailing stop optimization (if you need the ranges for the trailing stop parameters in the optimization hyperspace that differ from default)
-
-### Defining a buy signal optimization
-
-Let's say you are curious: should you use MACD crossings or lower Bollinger
-Bands to trigger your buys. And you also wonder should you use RSI or ADX to
-help with those buy decisions. If you decide to use RSI or ADX, which values
-should I use for them? So let's use hyperparameter optimization to solve this
-mystery.
-
-We will start by defining a search space:
-
-```python
-    def indicator_space() -> List[Dimension]:
-        """
-        Define your Hyperopt space for searching strategy parameters
-        """
-        return [
-            Integer(20, 40, name='adx-value'),
-            Integer(20, 40, name='rsi-value'),
-            Categorical([True, False], name='adx-enabled'),
-            Categorical([True, False], name='rsi-enabled'),
-            Categorical(['bb_lower', 'macd_cross_signal'], name='trigger')
-        ]
-```
-
-Above definition says: I have five parameters I want you to randomly combine
-to find the best combination. Two of them are integer values (`adx-value` and `rsi-value`) and I want you test in the range of values 20 to 40.  
-Then we have three category variables. First two are either `True` or `False`.
-We use these to either enable or disable the ADX and RSI guards.
-The last one we call `trigger` and use it to decide which buy trigger we want to use.
-
-So let's write the buy strategy generator using these values:
-
-```python
-    @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, metadata: dict) -> DataFrame:
-            conditions = []
-            # GUARDS AND TRENDS
-            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 'trigger' in params:
-                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']
-                    ))
-
-            # Check that volume is not 0
-            conditions.append(dataframe['volume'] > 0)
-
-            if conditions:
-                dataframe.loc[
-                    reduce(lambda x, y: x & y, conditions),
-                    'buy'] = 1
-
-            return dataframe
-
-        return populate_buy_trend
-```
-
-Hyperopt will now call `populate_buy_trend()` many times (`epochs`) with different value combinations.  
-It will use the given historical data and make buys based on the buy signals generated with the above function.  
-Based on the results, hyperopt will tell you which parameter combination produced the best results (based on the configured [loss function](#loss-functions)).
-
-!!! Note
-    The above setup expects to find ADX, RSI and Bollinger Bands in the populated indicators.
-    When you want to test an indicator that isn't used by the bot currently, remember to
-    add it to the `populate_indicators()` method in your strategy or hyperopt file.
-
-### Sell optimization
-
-Similar to the buy-signal above, sell-signals can also be optimized.
-Place the corresponding settings into the following methods
-
-* Inside `sell_indicator_space()` - the parameters hyperopt shall be optimizing.
-* Within `sell_strategy_generator()` - populate the nested method `populate_sell_trend()` to apply the parameters.
-
-The configuration and rules are the same than for buy signals.
-To avoid naming collisions in the search-space, please prefix all sell-spaces with `sell-`.
-
-## Execute Hyperopt
-
-Once you have updated your hyperopt configuration you can run it.
-Because hyperopt tries a lot of combinations to find the best parameters it will take time to get a good result. More time usually results in better results.
-
-We strongly recommend to use `screen` or `tmux` to prevent any connection loss.
-
-```bash
-freqtrade hyperopt --config config.json --hyperopt <hyperoptname> --hyperopt-loss <hyperoptlossname> --strategy <strategyname> -e 500 --spaces all
-```
-
-Use `<hyperoptname>` as the name of the custom hyperopt used.
-
-The `-e` option will set how many evaluations hyperopt will do. Since hyperopt uses Bayesian search, running too many epochs at once may not produce greater results. Experience has shown that best results are usually not improving much after 500-1000 epochs.  
-Doing multiple runs (executions) with a few 1000 epochs and different random state will most likely produce different results.
-
-The `--spaces all` option determines that all possible parameters should be optimized. Possibilities are listed below.
-
-!!! Note
-    Hyperopt will store hyperopt results with the timestamp of the hyperopt start time.
-    Reading commands (`hyperopt-list`, `hyperopt-show`) can use `--hyperopt-filename <filename>` to read and display older hyperopt results.
-    You can find a list of filenames with `ls -l user_data/hyperopt_results/`.
-
-### Running Hyperopt using methods from a strategy
-
-Hyperopt can reuse `populate_indicators`, `populate_buy_trend`, `populate_sell_trend` from your strategy, assuming these methods are **not** in your custom hyperopt file, and a strategy is provided.
-
-```bash
-freqtrade hyperopt --hyperopt AwesomeHyperopt --hyperopt-loss SharpeHyperOptLossDaily --strategy AwesomeStrategy
-```
-
-## Understand the Hyperopt Result
-
-Once Hyperopt is completed you can use the result to create a new strategy.
-Given the following result from hyperopt:
-
-```
-Best result:
-
-    44/100:    135 trades. Avg profit  0.57%. Total profit  0.03871918 BTC (0.7722Σ%). Avg duration 180.4 mins. Objective: 1.94367
-
-Buy hyperspace params:
-{    'adx-value': 44,
-     'rsi-value': 29,
-     'adx-enabled': False,
-     'rsi-enabled': True,
-     'trigger': 'bb_lower'}
-```
-
-You should understand this result like:
-
-* The buy trigger that worked best was `bb_lower`.
-* You should not use ADX because `adx-enabled: False`)
-* You should **consider** using the RSI indicator (`rsi-enabled: True` and the best value is `29.0` (`rsi-value: 29.0`)
-
-You have to look inside your strategy file into `buy_strategy_generator()`
-method, what those values match to.
-
-So for example you had `rsi-value: 29.0` so we would look at `rsi`-block, that translates to the following code block:
-
-```python
-(dataframe['rsi'] < 29.0)
-```
-
-Translating your whole hyperopt result as the new buy-signal would then look like:
-
-```python
-def populate_buy_trend(self, dataframe: DataFrame) -> DataFrame:
-    dataframe.loc[
-        (
-            (dataframe['rsi'] < 29.0) &  # rsi-value
-            dataframe['close'] < dataframe['bb_lowerband']  # trigger
-        ),
-        'buy'] = 1
-    return dataframe
-```
-
-### Understand Hyperopt Stoploss results
-
-If you are optimizing stoploss values (i.e. if optimization search-space contains 'all', 'default' or 'stoploss'), your result will look as follows and include stoploss:
-
-```
-Best result:
-
-    44/100:    135 trades. Avg profit  0.57%. Total profit  0.03871918 BTC (0.7722Σ%). Avg duration 180.4 mins. Objective: 1.94367
-
-Buy hyperspace params:
-{   'adx-value': 44,
-    'rsi-value': 29,
-    'adx-enabled': False,
-    'rsi-enabled': True,
-    'trigger': 'bb_lower'}
-Stoploss: -0.27996
-```
-
-In order to use this best stoploss value found by Hyperopt in backtesting and for live trades/dry-run, copy-paste it as the value of the `stoploss` attribute of your custom strategy:
-
-``` python
-    # Optimal stoploss designed for the strategy
-    # This attribute will be overridden if the config file contains "stoploss"
-    stoploss = -0.27996
-```
-
-As stated in the comment, you can also use it as the value of the `stoploss` setting in the configuration file.
-
-
-## Validate backtesting results
-
-Once the optimized parameters and conditions have been implemented into your strategy, you should backtest the strategy to make sure everything is working as expected.
-
-To achieve same results (number of trades, their durations, profit, etc.) than during Hyperopt, please use same configuration and parameters (timerange, timeframe, ...) used for hyperopt `--dmmp`/`--disable-max-market-positions` and `--eps`/`--enable-position-stacking` for Backtesting.
-
-Should results don't match, please double-check to make sure you transferred all conditions correctly.
-Pay special care to the stoploss (and trailing stoploss) parameters, as these are often set in configuration files, which override changes to the strategy.
-You should also carefully review the log of your backtest to ensure that there were no parameters inadvertently set by the configuration (like `stoploss` or `trailing_stop`).

From 093d6ce8af24bdf37a14b0505f23dd414d40682f Mon Sep 17 00:00:00 2001
From: Matthias <xmatthias@outlook.com>
Date: Sat, 3 Apr 2021 16:13:49 +0200
Subject: [PATCH 27/32] Add sample for Nested space

---
 docs/advanced-hyperopt.md | 12 ++++++++++++
 docs/hyperopt.md          |  2 +-
 2 files changed, 13 insertions(+), 1 deletion(-)

diff --git a/docs/advanced-hyperopt.md b/docs/advanced-hyperopt.md
index 6a559ec96..723163b2c 100644
--- a/docs/advanced-hyperopt.md
+++ b/docs/advanced-hyperopt.md
@@ -70,6 +70,18 @@ This function needs to return a floating point number (`float`). Smaller numbers
 !!! Note
     Please keep the arguments `*args` and `**kwargs` in the interface to allow us to extend this interface later.
 
+## Overriding pre-defined spaces
+
+To override a pre-defined space (`roi_space`, `generate_roi_table`, `stoploss_space`, `trailing_space`), define a nested class called Hyperopt and define the required spaces as follows:
+
+```python
+class MyAwesomeStrategy(IStrategy):
+    class HyperOpt:
+        # Define a custom stoploss space.
+        def stoploss_space(self):
+            return [Real(-0.05, -0.01, name='stoploss')]
+```
+
 ## Legacy Hyperopt
 
 This Section explains the configuration of an explicit Hyperopt file (separate to the strategy).
diff --git a/docs/hyperopt.md b/docs/hyperopt.md
index cb8d4ad9d..1ce1f9a86 100644
--- a/docs/hyperopt.md
+++ b/docs/hyperopt.md
@@ -151,7 +151,7 @@ Depending on the space you want to optimize, only some of the below are required
 !!! Note
     `populate_indicators` needs to create all indicators any of the spaces may use, otherwise hyperopt will not work.
 
-Rarely you may also need to create a nested class named `HyperOpt` and implement:
+Rarely you may also need to create a [nested class](advanced-hyperopt.md#overriding-pre-defined-spaces) named `HyperOpt` and implement
 
 * `roi_space` - for custom ROI optimization (if you need the ranges for the ROI parameters in the optimization hyperspace that differ from default)
 * `generate_roi_table` - for custom ROI optimization (if you need the ranges for the values in the ROI table that differ from default or the number of entries (steps) in the ROI table which differs from the default 4 steps)

From 771fc057494a55902624e633d9ff8066eb1da323 Mon Sep 17 00:00:00 2001
From: Matthias <xmatthias@outlook.com>
Date: Sat, 3 Apr 2021 16:32:16 +0200
Subject: [PATCH 28/32] Update sample strategy with hyperoptable Parameters

---
 freqtrade/templates/base_strategy.py.j2 |  4 +++-
 freqtrade/templates/sample_strategy.py  | 16 ++++++++++++----
 2 files changed, 15 insertions(+), 5 deletions(-)

diff --git a/freqtrade/templates/base_strategy.py.j2 b/freqtrade/templates/base_strategy.py.j2
index dd6b773e1..9d69ee520 100644
--- a/freqtrade/templates/base_strategy.py.j2
+++ b/freqtrade/templates/base_strategy.py.j2
@@ -1,4 +1,5 @@
 # pragma pylint: disable=missing-docstring, invalid-name, pointless-string-statement
+# flake8: noqa: F401
 
 # --- Do not remove these libs ---
 import numpy as np  # noqa
@@ -6,6 +7,7 @@ import pandas as pd  # noqa
 from pandas import DataFrame
 
 from freqtrade.strategy import IStrategy
+from freqtrade.strategy import CategoricalParameter, DecimalParameter, IntParameter
 
 # --------------------------------
 # Add your lib to import here
@@ -16,7 +18,7 @@ import freqtrade.vendor.qtpylib.indicators as qtpylib
 class {{ strategy }}(IStrategy):
     """
     This is a strategy template to get you started.
-    More information in https://github.com/freqtrade/freqtrade/blob/develop/docs/bot-optimization.md
+    More information in https://www.freqtrade.io/en/latest/strategy-customization/
 
     You can:
         :return: a Dataframe with all mandatory indicators for the strategies
diff --git a/freqtrade/templates/sample_strategy.py b/freqtrade/templates/sample_strategy.py
index db1ba48b8..84f3fbc9e 100644
--- a/freqtrade/templates/sample_strategy.py
+++ b/freqtrade/templates/sample_strategy.py
@@ -1,11 +1,13 @@
 # pragma pylint: disable=missing-docstring, invalid-name, pointless-string-statement
+# flake8: noqa: F401
 # isort: skip_file
 # --- Do not remove these libs ---
 import numpy as np  # noqa
 import pandas as pd  # noqa
 from pandas import DataFrame
 
-from freqtrade.strategy.interface import IStrategy
+from freqtrade.strategy import IStrategy
+from freqtrade.strategy import CategoricalParameter, DecimalParameter, IntParameter
 
 # --------------------------------
 # Add your lib to import here
@@ -52,7 +54,11 @@ class SampleStrategy(IStrategy):
     # trailing_stop_positive = 0.01
     # trailing_stop_positive_offset = 0.0  # Disabled / not configured
 
-    # Optimal ticker interval for the strategy.
+    # Hyperoptable parameters
+    buy_rsi = IntParameter(low=1, high=50, default=30, space='buy', optimize=True, load=True)
+    sell_rsi = IntParameter(low=50, high=100, defualt=70, space='buy', optimize=True, load=True)
+
+    # Optimal timeframe for the strategy.
     timeframe = '5m'
 
     # Run "populate_indicators()" only for new candle.
@@ -339,7 +345,8 @@ class SampleStrategy(IStrategy):
         """
         dataframe.loc[
             (
-                (qtpylib.crossed_above(dataframe['rsi'], 30)) &  # Signal: RSI crosses above 30
+                # Signal: RSI crosses above 30
+                (qtpylib.crossed_above(dataframe['rsi'], self.buy_rsi.value)) &
                 (dataframe['tema'] <= dataframe['bb_middleband']) &  # Guard: tema below BB middle
                 (dataframe['tema'] > dataframe['tema'].shift(1)) &  # Guard: tema is raising
                 (dataframe['volume'] > 0)  # Make sure Volume is not 0
@@ -357,7 +364,8 @@ class SampleStrategy(IStrategy):
         """
         dataframe.loc[
             (
-                (qtpylib.crossed_above(dataframe['rsi'], 70)) &  # Signal: RSI crosses above 70
+                # Signal: RSI crosses above 70
+                (qtpylib.crossed_above(dataframe['rsi'], self.sell_rsi.value)) &
                 (dataframe['tema'] > dataframe['bb_middleband']) &  # Guard: tema above BB middle
                 (dataframe['tema'] < dataframe['tema'].shift(1)) &  # Guard: tema is falling
                 (dataframe['volume'] > 0)  # Make sure Volume is not 0

From 9d4b5cc6bb961125df6a5afa94ed62848537f010 Mon Sep 17 00:00:00 2001
From: Matthias <xmatthias@outlook.com>
Date: Sat, 3 Apr 2021 17:10:39 +0200
Subject: [PATCH 29/32] Fix typo

---
 freqtrade/optimize/hyperopt_interface.py | 2 +-
 freqtrade/templates/sample_strategy.py   | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/freqtrade/optimize/hyperopt_interface.py b/freqtrade/optimize/hyperopt_interface.py
index 8eefff99c..633c8bdd5 100644
--- a/freqtrade/optimize/hyperopt_interface.py
+++ b/freqtrade/optimize/hyperopt_interface.py
@@ -103,7 +103,7 @@ class IHyperOpt(ABC):
         roi_t_alpha = 1.0
         roi_p_alpha = 1.0
 
-        timeframe_min = timeframe_to_minutes(self.ticker_interval)
+        timeframe_min = timeframe_to_minutes(self.timeframe)
 
         # We define here limits for the ROI space parameters automagically adapted to the
         # timeframe used by the bot:
diff --git a/freqtrade/templates/sample_strategy.py b/freqtrade/templates/sample_strategy.py
index 29b550ea4..a51b30f3f 100644
--- a/freqtrade/templates/sample_strategy.py
+++ b/freqtrade/templates/sample_strategy.py
@@ -57,7 +57,7 @@ class SampleStrategy(IStrategy):
 
     # Hyperoptable parameters
     buy_rsi = IntParameter(low=1, high=50, default=30, space='buy', optimize=True, load=True)
-    sell_rsi = IntParameter(low=50, high=100, defualt=70, space='buy', optimize=True, load=True)
+    sell_rsi = IntParameter(low=50, high=100, default=70, space='sell', optimize=True, load=True)
 
     # Optimal timeframe for the strategy.
     timeframe = '5m'

From 30e5e9296817f54ca773772a124548fd290c9d9f Mon Sep 17 00:00:00 2001
From: Matthias <xmatthias@outlook.com>
Date: Sat, 3 Apr 2021 20:17:48 +0200
Subject: [PATCH 30/32] Don't allow one parmeter to be in 2 spaces

use the explicit user wish (given explicitly with "space")
---
 freqtrade/strategy/hyper.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/freqtrade/strategy/hyper.py b/freqtrade/strategy/hyper.py
index 6282d91c0..e7f31e20d 100644
--- a/freqtrade/strategy/hyper.py
+++ b/freqtrade/strategy/hyper.py
@@ -244,8 +244,8 @@ class HyperStrategyMixin(object):
             if not attr_name.startswith('__'):  # Ignore internals, not strictly necessary.
                 attr = getattr(self, attr_name)
                 if issubclass(attr.__class__, BaseParameter):
-                    if category is None or category == attr.category or \
-                       attr_name.startswith(category + '_'):
+                    if (category is None or category == attr.category or
+                            (attr_name.startswith(category + '_') and attr.category is None)):
                         yield attr_name, attr
 
     def _load_params(self, params: dict) -> None:

From dc406fe19f85197d9223342c7777a466caabb480 Mon Sep 17 00:00:00 2001
From: Matthias <xmatthias@outlook.com>
Date: Mon, 5 Apr 2021 10:53:00 +0200
Subject: [PATCH 31/32] Fail in case of name and explicit space name collisions

---
 freqtrade/strategy/hyper.py      | 4 ++++
 tests/optimize/test_hyperopt.py  | 2 --
 tests/strategy/test_interface.py | 5 +++++
 3 files changed, 9 insertions(+), 2 deletions(-)

diff --git a/freqtrade/strategy/hyper.py b/freqtrade/strategy/hyper.py
index e7f31e20d..0b7055f01 100644
--- a/freqtrade/strategy/hyper.py
+++ b/freqtrade/strategy/hyper.py
@@ -244,6 +244,10 @@ class HyperStrategyMixin(object):
             if not attr_name.startswith('__'):  # Ignore internals, not strictly necessary.
                 attr = getattr(self, attr_name)
                 if issubclass(attr.__class__, BaseParameter):
+                    if (category and attr_name.startswith(category + '_')
+                            and attr.category is not None and attr.category != category):
+                        raise OperationalException(
+                            f'Inconclusive parameter name {attr_name}, category: {attr.category}.')
                     if (category is None or category == attr.category or
                             (attr_name.startswith(category + '_') and attr.category is None)):
                         yield attr_name, attr
diff --git a/tests/optimize/test_hyperopt.py b/tests/optimize/test_hyperopt.py
index 36b6f1229..c13da0d76 100644
--- a/tests/optimize/test_hyperopt.py
+++ b/tests/optimize/test_hyperopt.py
@@ -1093,8 +1093,6 @@ def test_print_epoch_details(capsys):
 
 
 def test_in_strategy_auto_hyperopt(mocker, hyperopt_conf, tmpdir) -> None:
-    # mocker.patch('freqtrade.optimize.hyperopt.dump', MagicMock())
-    # mocker.patch('freqtrade.optimize.hyperopt.file_dump_json')
     (Path(tmpdir) / 'hyperopt_results').mkdir(parents=True)
     # No hyperopt needed
     del hyperopt_conf['hyperopt']
diff --git a/tests/strategy/test_interface.py b/tests/strategy/test_interface.py
index 71f877cc3..3bfa691b4 100644
--- a/tests/strategy/test_interface.py
+++ b/tests/strategy/test_interface.py
@@ -617,3 +617,8 @@ def test_auto_hyperopt_interface(default_conf):
 
     # Parameter is disabled - so value from sell_param dict will NOT be used.
     assert strategy.sell_minusdi.value == 0.5
+
+    strategy.sell_rsi = IntParameter([0, 10], default=5, space='buy')
+
+    with pytest.raises(OperationalException, match=r"Inconclusive parameter.*"):
+        [x for x in strategy.enumerate_parameters('sell')]

From c51839dc3be4c47a32394719eb3bfba0e94ff1a6 Mon Sep 17 00:00:00 2001
From: Matthias <xmatthias@outlook.com>
Date: Mon, 5 Apr 2021 11:21:20 +0200
Subject: [PATCH 32/32] Make the logmessage for loaded parameters clearer

---
 freqtrade/strategy/hyper.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/freqtrade/strategy/hyper.py b/freqtrade/strategy/hyper.py
index 0b7055f01..709179997 100644
--- a/freqtrade/strategy/hyper.py
+++ b/freqtrade/strategy/hyper.py
@@ -263,7 +263,7 @@ class HyperStrategyMixin(object):
             if attr_name in params:
                 if attr.load:
                     attr.value = params[attr_name]
-                    logger.info(f'{attr_name} = {attr.value}')
+                    logger.info(f'Strategy Parameter: {attr_name} = {attr.value}')
                 else:
                     logger.warning(f'Parameter "{attr_name}" exists, but is disabled. '
                                    f'Default value "{attr.value}" used.')