Merge pull request #5281 from rokups/rk/helpers

A decorator for easy creation of informative pairs

docs/strategy-advanced.md

@@ -288,6 +288,12 @@ Stoploss values returned from `custom_stoploss()` always specify a percentage re
 
 The helper function [`stoploss_from_open()`](strategy-customization.md#stoploss_from_open) can be used to convert from an open price relative stop, to a current price relative stop which can be returned from `custom_stoploss()`.
 
+### Calculating stoploss percentage from absolute price
+
+Stoploss values returned from `custom_stoploss()` always specify a percentage relative to `current_rate`. In order to set a stoploss at specified absolute price level, we need to use `stop_rate` to calculate what percentage relative to the `current_rate` will give you the same result as if the percentage was specified from the open price.
+
+The helper function [`stoploss_from_absolute()`](strategy-customization.md#stoploss_from_absolute) can be used to convert from an absolute price, to a current price relative stop which can be returned from `custom_stoploss()`.
+
 #### Stepped stoploss
 
 Instead of continuously trailing behind the current price, this example sets fixed stoploss price levels based on the current profit.

docs/strategy-customization.md

@@ -639,6 +639,170 @@ Stoploss values returned from `custom_stoploss` must specify a percentage relati
 
     Full examples can be found in the [Custom stoploss](strategy-advanced.md#custom-stoploss) section of the Documentation.
 
+!!! Note
+    Providing invalid input to `stoploss_from_open()` may produce "CustomStoploss function did not return valid stoploss" warnings.
+    This may happen if `current_profit` parameter is below specified `open_relative_stop`. Such situations may arise when closing trade
+    is blocked by `confirm_trade_exit()` method. Warnings can be solved by never blocking stop loss sells by checking `sell_reason` in
+    `confirm_trade_exit()`, or by using `return stoploss_from_open(...) or 1` idiom, which will request to not change stop loss when
+    `current_profit < open_relative_stop`.
+
+### *stoploss_from_absolute()*
+
+In some situations it may be confusing to deal with stops relative to current rate. Instead, you may define a stoploss level using an absolute price.
+
+??? Example "Returning a stoploss using absolute price from the custom stoploss function"
+
+    If we want to trail a stop price at 2xATR below current proce we can call `stoploss_from_absolute(current_rate - (candle['atr'] * 2), current_rate)`.
+
+    ``` python
+
+    from datetime import datetime
+    from freqtrade.persistence import Trade
+    from freqtrade.strategy import IStrategy, stoploss_from_open
+
+    class AwesomeStrategy(IStrategy):
+
+        use_custom_stoploss = True
+
+        def populate_indicators_1h(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
+            dataframe['atr'] = ta.ATR(dataframe, timeperiod=14)
+            return dataframe
+
+        def custom_stoploss(self, pair: str, trade: 'Trade', current_time: datetime,
+                            current_rate: float, current_profit: float, **kwargs) -> float:
+            dataframe, _ = self.dp.get_analyzed_dataframe(pair, self.timeframe)
+            candle = dataframe.iloc[-1].squeeze()
+            return stoploss_from_absolute(current_rate - (candle['atr'] * 2), current_rate)
+
+    ```
+
+### *@informative()*
+
+``` python
+def informative(timeframe: str, asset: str = '',
+                fmt: Optional[Union[str, Callable[[KwArg(str)], str]]] = None,
+                ffill: bool = True) -> Callable[[PopulateIndicators], PopulateIndicators]:
+    """
+    A decorator for populate_indicators_Nn(self, dataframe, metadata), allowing these functions to
+    define informative indicators.
+
+    Example usage:
+
+        @informative('1h')
+        def populate_indicators_1h(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
+            dataframe['rsi'] = ta.RSI(dataframe, timeperiod=14)
+            return dataframe
+
+    :param timeframe: Informative timeframe. Must always be equal or higher than strategy timeframe.
+    :param asset: Informative asset, for example BTC, BTC/USDT, ETH/BTC. Do not specify to use
+    current pair.
+    :param fmt: Column format (str) or column formatter (callable(name, asset, timeframe)). When not
+    specified, defaults to:
+    * {base}_{quote}_{column}_{timeframe} if asset is specified. 
+    * {column}_{timeframe} if asset is not specified.
+    Format string supports these format variables:
+    * {asset} - full name of the asset, for example 'BTC/USDT'.
+    * {base} - base currency in lower case, for example 'eth'.
+    * {BASE} - same as {base}, except in upper case.
+    * {quote} - quote currency in lower case, for example 'usdt'.
+    * {QUOTE} - same as {quote}, except in upper case.
+    * {column} - name of dataframe column.
+    * {timeframe} - timeframe of informative dataframe.
+    :param ffill: ffill dataframe after merging informative pair.
+    """
+```
+
+In most common case it is possible to easily define informative pairs by using a decorator. All decorated `populate_indicators_*` methods run in isolation,
+not having access to data from other informative pairs, in the end all informative dataframes are merged and passed to main `populate_indicators()` method.
+When hyperopting, use of hyperoptable parameter `.value` attribute is not supported. Please use `.range` attribute. See [optimizing an indicator parameter](hyperopt.md#optimizing-an-indicator-parameter)
+for more information.
+
+??? Example "Fast and easy way to define informative pairs"
+
+    Most of the time we do not need power and flexibility offered by `merge_informative_pair()`, therefore we can use a decorator to quickly define informative pairs.
+
+    ``` python
+
+    from datetime import datetime
+    from freqtrade.persistence import Trade
+    from freqtrade.strategy import IStrategy, informative
+
+    class AwesomeStrategy(IStrategy):
+        
+        # This method is not required. 
+        # def informative_pairs(self): ...
+
+        # Define informative upper timeframe for each pair. Decorators can be stacked on same 
+        # method. Available in populate_indicators as 'rsi_30m' and 'rsi_1h'.
+        @informative('30m')
+        @informative('1h')
+        def populate_indicators_1h(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
+            dataframe['rsi'] = ta.RSI(dataframe, timeperiod=14)
+            return dataframe
+
+        # Define BTC/STAKE informative pair. Available in populate_indicators and other methods as
+        # 'btc_rsi_1h'. Current stake currency should be specified as {stake} format variable 
+        # instead of hardcoding actual stake currency. Available in populate_indicators and other 
+        # methods as 'btc_usdt_rsi_1h' (when stake currency is USDT).
+        @informative('1h', 'BTC/{stake}')
+        def populate_indicators_btc_1h(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
+            dataframe['rsi'] = ta.RSI(dataframe, timeperiod=14)
+            return dataframe
+
+        # Define BTC/ETH informative pair. You must specify quote currency if it is different from
+        # stake currency. Available in populate_indicators and other methods as 'eth_btc_rsi_1h'.
+        @informative('1h', 'ETH/BTC')
+        def populate_indicators_eth_btc_1h(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
+            dataframe['rsi'] = ta.RSI(dataframe, timeperiod=14)
+            return dataframe
+    
+        # Define BTC/STAKE informative pair. A custom formatter may be specified for formatting
+        # column names. A callable `fmt(**kwargs) -> str` may be specified, to implement custom
+        # formatting. Available in populate_indicators and other methods as 'rsi_upper'.
+        @informative('1h', 'BTC/{stake}', '{column}')
+        def populate_indicators_btc_1h_2(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
+            dataframe['rsi_upper'] = ta.RSI(dataframe, timeperiod=14)
+            return dataframe
+    
+        def populate_indicators(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
+            # Strategy timeframe indicators for current pair.
+            dataframe['rsi'] = ta.RSI(dataframe, timeperiod=14)
+            # Informative pairs are available in this method.
+            dataframe['rsi_less'] = dataframe['rsi'] < dataframe['rsi_1h']
+            return dataframe
+
+    ```
+
+!!! Note
+    Do not use `@informative` decorator if you need to use data of one informative pair when generating another informative pair. Instead, define informative pairs
+    manually as described [in the DataProvider section](#complete-data-provider-sample).
+
+!!! Note
+    Use string formatting when accessing informative dataframes of other pairs. This will allow easily changing stake currency in config without having to adjust strategy code.
+
+    ``` python
+    def populate_buy_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
+        stake = self.config['stake_currency']
+        dataframe.loc[
+            (
+                (dataframe[f'btc_{stake}_rsi_1h'] < 35)
+                &
+                (dataframe['volume'] > 0)
+            ),
+            ['buy', 'buy_tag']] = (1, 'buy_signal_rsi')
+    
+        return dataframe
+    ```
+
+    Alternatively column renaming may be used to remove stake currency from column names: `@informative('1h', 'BTC/{stake}', fmt='{base}_{column}_{timeframe}')`.
+
+!!! Warning "Duplicate method names"
+    Methods tagged with `@informative()` decorator must always have unique names! Re-using same name (for example when copy-pasting already defined informative method)
+    will overwrite previously defined method and not produce any errors due to limitations of Python programming language. In such cases you will find that indicators
+    created in earlier-defined methods are not available in the dataframe. Carefully review method names and make sure they are unique!
+
+!!! Warning
+    When using a legacy hyperopt implementation informative pairs defined with a decorator will not be executed. Please update your strategy if necessary.
 
 ## Additional data (Wallets)
 

freqtrade/edge/edge_positioning.py

@@ -119,7 +119,7 @@ class Edge:
             )
             # Download informative pairs too
             res = defaultdict(list)
-            for p, t in self.strategy.informative_pairs():
+            for p, t in self.strategy.gather_informative_pairs():
                 res[t].append(p)
             for timeframe, inf_pairs in res.items():
                 timerange_startup = deepcopy(self._timerange)

freqtrade/freqtradebot.py

@@ -83,10 +83,10 @@ class FreqtradeBot(LoggingMixin):
 
         self.dataprovider = DataProvider(self.config, self.exchange, self.pairlists)
 
-        # Attach Dataprovider to Strategy baseclass
+        # Attach Dataprovider to strategy instance
-        IStrategy.dp = self.dataprovider
+        self.strategy.dp = self.dataprovider
-        # Attach Wallets to Strategy baseclass
+        # Attach Wallets to strategy instance
-        IStrategy.wallets = self.wallets
+        self.strategy.wallets = self.wallets
 
         # Initializing Edge only if enabled
         self.edge = Edge(self.config, self.exchange, self.strategy) if \
@@ -160,7 +160,7 @@ class FreqtradeBot(LoggingMixin):
 
         # Refreshing candles
         self.dataprovider.refresh(self.pairlists.create_pair_list(self.active_pair_whitelist),
-                                  self.strategy.informative_pairs())
+                                  self.strategy.gather_informative_pairs())
 
         strategy_safe_wrapper(self.strategy.bot_loop_start, supress_error=True)()
 

freqtrade/optimize/backtesting.py

@@ -154,7 +154,7 @@ class Backtesting:
         self.strategy: IStrategy = strategy
         strategy.dp = self.dataprovider
         # Attach Wallets to Strategy baseclass
-        IStrategy.wallets = self.wallets
+        strategy.wallets = self.wallets
         # Set stoploss_on_exchange to false for backtesting,
         # since a "perfect" stoploss-sell is assumed anyway
         # And the regular "stoploss" function would not apply to that case

freqtrade/optimize/edge_cli.py

@@ -8,6 +8,7 @@ from typing import Any, Dict
 
 from freqtrade import constants
 from freqtrade.configuration import TimeRange, validate_config_consistency
+from freqtrade.data.dataprovider import DataProvider
 from freqtrade.edge import Edge
 from freqtrade.optimize.optimize_reports import generate_edge_table
 from freqtrade.resolvers import ExchangeResolver, StrategyResolver
@@ -33,6 +34,7 @@ class EdgeCli:
         self.config['stake_amount'] = constants.UNLIMITED_STAKE_AMOUNT
         self.exchange = ExchangeResolver.load_exchange(self.config['exchange']['name'], self.config)
         self.strategy = StrategyResolver.load_strategy(self.config)
+        self.strategy.dp = DataProvider(config, None)
 
         validate_config_consistency(self.config)
 

freqtrade/strategy/__init__.py

@@ -3,5 +3,7 @@ from freqtrade.exchange import (timeframe_to_minutes, timeframe_to_msecs, timefr
                                 timeframe_to_prev_date, timeframe_to_seconds)
 from freqtrade.strategy.hyper import (BooleanParameter, CategoricalParameter, DecimalParameter,
                                       IntParameter, RealParameter)
+from freqtrade.strategy.informative_decorator import informative
 from freqtrade.strategy.interface import IStrategy
-from freqtrade.strategy.strategy_helper import merge_informative_pair, stoploss_from_open
+from freqtrade.strategy.strategy_helper import (merge_informative_pair, stoploss_from_absolute,
+                                                stoploss_from_open)

freqtrade/strategy/informative_decorator.py

@@ -0,0 +1,128 @@
+from typing import Any, Callable, NamedTuple, Optional, Union
+
+from pandas import DataFrame
+
+from freqtrade.exceptions import OperationalException
+from freqtrade.strategy.strategy_helper import merge_informative_pair
+
+
+PopulateIndicators = Callable[[Any, DataFrame, dict], DataFrame]
+
+
+class InformativeData(NamedTuple):
+    asset: Optional[str]
+    timeframe: str
+    fmt: Union[str, Callable[[Any], str], None]
+    ffill: bool
+
+
+def informative(timeframe: str, asset: str = '',
+                fmt: Optional[Union[str, Callable[[Any], str]]] = None,
+                ffill: bool = True) -> Callable[[PopulateIndicators], PopulateIndicators]:
+    """
+    A decorator for populate_indicators_Nn(self, dataframe, metadata), allowing these functions to
+    define informative indicators.
+
+    Example usage:
+
+        @informative('1h')
+        def populate_indicators_1h(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
+            dataframe['rsi'] = ta.RSI(dataframe, timeperiod=14)
+            return dataframe
+
+    :param timeframe: Informative timeframe. Must always be equal or higher than strategy timeframe.
+    :param asset: Informative asset, for example BTC, BTC/USDT, ETH/BTC. Do not specify to use
+    current pair.
+    :param fmt: Column format (str) or column formatter (callable(name, asset, timeframe)). When not
+    specified, defaults to:
+    * {base}_{quote}_{column}_{timeframe} if asset is specified.
+    * {column}_{timeframe} if asset is not specified.
+    Format string supports these format variables:
+    * {asset} - full name of the asset, for example 'BTC/USDT'.
+    * {base} - base currency in lower case, for example 'eth'.
+    * {BASE} - same as {base}, except in upper case.
+    * {quote} - quote currency in lower case, for example 'usdt'.
+    * {QUOTE} - same as {quote}, except in upper case.
+    * {column} - name of dataframe column.
+    * {timeframe} - timeframe of informative dataframe.
+    :param ffill: ffill dataframe after merging informative pair.
+    """
+    _asset = asset
+    _timeframe = timeframe
+    _fmt = fmt
+    _ffill = ffill
+
+    def decorator(fn: PopulateIndicators):
+        informative_pairs = getattr(fn, '_ft_informative', [])
+        informative_pairs.append(InformativeData(_asset, _timeframe, _fmt, _ffill))
+        setattr(fn, '_ft_informative', informative_pairs)
+        return fn
+    return decorator
+
+
+def _format_pair_name(config, pair: str) -> str:
+    return pair.format(stake_currency=config['stake_currency'],
+                       stake=config['stake_currency']).upper()
+
+
+def _create_and_merge_informative_pair(strategy, dataframe: DataFrame, metadata: dict,
+                                       inf_data: InformativeData,
+                                       populate_indicators: PopulateIndicators):
+    asset = inf_data.asset or ''
+    timeframe = inf_data.timeframe
+    fmt = inf_data.fmt
+    config = strategy.config
+
+    if asset:
+        # Insert stake currency if needed.
+        asset = _format_pair_name(config, asset)
+    else:
+        # Not specifying an asset will define informative dataframe for current pair.
+        asset = metadata['pair']
+
+    if '/' in asset:
+        base, quote = asset.split('/')
+    else:
+        # When futures are supported this may need reevaluation.
+        # base, quote = asset, ''
+        raise OperationalException('Not implemented.')
+
+    # Default format. This optimizes for the common case: informative pairs using same stake
+    # currency. When quote currency matches stake currency, column name will omit base currency.
+    # This allows easily reconfiguring strategy to use different base currency. In a rare case
+    # where it is desired to keep quote currency in column name at all times user should specify
+    # fmt='{base}_{quote}_{column}_{timeframe}' format or similar.
+    if not fmt:
+        fmt = '{column}_{timeframe}'                # Informatives of current pair
+        if inf_data.asset:
+            fmt = '{base}_{quote}_' + fmt           # Informatives of other pairs
+
+    inf_metadata = {'pair': asset, 'timeframe': timeframe}
+    inf_dataframe = strategy.dp.get_pair_dataframe(asset, timeframe)
+    inf_dataframe = populate_indicators(strategy, inf_dataframe, inf_metadata)
+
+    formatter: Any = None
+    if callable(fmt):
+        formatter = fmt             # A custom user-specified formatter function.
+    else:
+        formatter = fmt.format      # A default string formatter.
+
+    fmt_args = {
+        'BASE': base.upper(),
+        'QUOTE': quote.upper(),
+        'base': base.lower(),
+        'quote': quote.lower(),
+        'asset': asset,
+        'timeframe': timeframe,
+    }
+    inf_dataframe.rename(columns=lambda column: formatter(column=column, **fmt_args),
+                         inplace=True)
+
+    date_column = formatter(column='date', **fmt_args)
+    if date_column in dataframe.columns:
+        raise OperationalException(f'Duplicate column name {date_column} exists in '
+                                   f'dataframe! Ensure column names are unique!')
+    dataframe = merge_informative_pair(dataframe, inf_dataframe, strategy.timeframe, timeframe,
+                                       ffill=inf_data.ffill, append_timeframe=False,
+                                       date_column=date_column)
+    return dataframe

freqtrade/strategy/interface.py

@@ -19,6 +19,9 @@ 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.informative_decorator import (InformativeData, PopulateIndicators,
+                                                      _create_and_merge_informative_pair,
+                                                      _format_pair_name)
 from freqtrade.strategy.strategy_wrapper import strategy_safe_wrapper
 from freqtrade.wallets import Wallets
 
@@ -118,7 +121,7 @@ class IStrategy(ABC, HyperStrategyMixin):
     # Class level variables (intentional) containing
     # the dataprovider (dp) (access to other candles, historic data, ...)
     # and wallets - access to the current balance.
-    dp: Optional[DataProvider] = None
+    dp: Optional[DataProvider]
     wallets: Optional[Wallets] = None
     # Filled from configuration
     stake_currency: str
@@ -134,6 +137,24 @@ class IStrategy(ABC, HyperStrategyMixin):
         self._last_candle_seen_per_pair: Dict[str, datetime] = {}
         super().__init__(config)
 
+        # Gather informative pairs from @informative-decorated methods.
+        self._ft_informative: List[Tuple[InformativeData, PopulateIndicators]] = []
+        for attr_name in dir(self.__class__):
+            cls_method = getattr(self.__class__, attr_name)
+            if not callable(cls_method):
+                continue
+            informative_data_list = getattr(cls_method, '_ft_informative', None)
+            if not isinstance(informative_data_list, list):
+                # Type check is required because mocker would return a mock object that evaluates to
+                # True, confusing this code.
+                continue
+            strategy_timeframe_minutes = timeframe_to_minutes(self.timeframe)
+            for informative_data in informative_data_list:
+                if timeframe_to_minutes(informative_data.timeframe) < strategy_timeframe_minutes:
+                    raise OperationalException('Informative timeframe must be equal or higher than '
+                                               'strategy timeframe!')
+                self._ft_informative.append((informative_data, cls_method))
+
     @abstractmethod
     def populate_indicators(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
         """
@@ -377,6 +398,23 @@ class IStrategy(ABC, HyperStrategyMixin):
 # END - Intended to be overridden by strategy
 ###
 
+    def gather_informative_pairs(self) -> ListPairsWithTimeframes:
+        """
+        Internal method which gathers all informative pairs (user or automatically defined).
+        """
+        informative_pairs = self.informative_pairs()
+        for inf_data, _ in self._ft_informative:
+            if inf_data.asset:
+                pair_tf = (_format_pair_name(self.config, inf_data.asset), inf_data.timeframe)
+                informative_pairs.append(pair_tf)
+            else:
+                if not self.dp:
+                    raise OperationalException('@informative decorator with unspecified asset '
+                                               'requires DataProvider instance.')
+                for pair in self.dp.current_whitelist():
+                    informative_pairs.append((pair, inf_data.timeframe))
+        return list(set(informative_pairs))
+
     def get_strategy_name(self) -> str:
         """
         Returns strategy class name
@@ -793,6 +831,12 @@ class IStrategy(ABC, HyperStrategyMixin):
         :return: a Dataframe with all mandatory indicators for the strategies
         """
         logger.debug(f"Populating indicators for pair {metadata.get('pair')}.")
+
+        # call populate_indicators_Nm() which were tagged with @informative decorator.
+        for inf_data, populate_fn in self._ft_informative:
+            dataframe = _create_and_merge_informative_pair(
+                self, dataframe, metadata, inf_data, populate_fn)
+
         if self._populate_fun_len == 2:
             warnings.warn("deprecated - check out the Sample strategy to see "
                           "the current function headers!", DeprecationWarning)

freqtrade/strategy/strategy_helper.py

@@ -4,7 +4,9 @@ from freqtrade.exchange import timeframe_to_minutes
 
 
 def merge_informative_pair(dataframe: pd.DataFrame, informative: pd.DataFrame,
-                           timeframe: str, timeframe_inf: str, ffill: bool = True) -> pd.DataFrame:
+                           timeframe: str, timeframe_inf: str, ffill: bool = True,
+                           append_timeframe: bool = True,
+                           date_column: str = 'date') -> pd.DataFrame:
     """
     Correctly merge informative samples to the original dataframe, avoiding lookahead bias.
 
@@ -24,6 +26,8 @@ def merge_informative_pair(dataframe: pd.DataFrame, informative: pd.DataFrame,
     :param timeframe: Timeframe of the original pair sample.
     :param timeframe_inf: Timeframe of the informative pair sample.
     :param ffill: Forwardfill missing values - optional but usually required
+    :param append_timeframe: Rename columns by appending timeframe.
+    :param date_column: A custom date column name.
     :return: Merged dataframe
     :raise: ValueError if the secondary timeframe is shorter than the dataframe timeframe
     """
@@ -32,25 +36,29 @@ def merge_informative_pair(dataframe: pd.DataFrame, informative: pd.DataFrame,
     minutes = timeframe_to_minutes(timeframe)
     if minutes == minutes_inf:
         # No need to forwardshift if the timeframes are identical
-        informative['date_merge'] = informative["date"]
+        informative['date_merge'] = informative[date_column]
     elif minutes < minutes_inf:
         # Subtract "small" timeframe so merging is not delayed by 1 small candle
         # Detailed explanation in https://github.com/freqtrade/freqtrade/issues/4073
         informative['date_merge'] = (
-            informative["date"] + pd.to_timedelta(minutes_inf, 'm') - pd.to_timedelta(minutes, 'm')
+            informative[date_column] + pd.to_timedelta(minutes_inf, 'm') -
+            pd.to_timedelta(minutes, 'm')
         )
     else:
         raise ValueError("Tried to merge a faster timeframe to a slower timeframe."
                          "This would create new rows, and can throw off your regular indicators.")
 
     # Rename columns to be unique
+    date_merge = 'date_merge'
+    if append_timeframe:
+        date_merge = f'date_merge_{timeframe_inf}'
         informative.columns = [f"{col}_{timeframe_inf}" for col in informative.columns]
 
     # Combine the 2 dataframes
     # all indicators on the informative sample MUST be calculated before this point
     dataframe = pd.merge(dataframe, informative, left_on='date',
-                         right_on=f'date_merge_{timeframe_inf}', how='left')
+                         right_on=date_merge, how='left')
-    dataframe = dataframe.drop(f'date_merge_{timeframe_inf}', axis=1)
+    dataframe = dataframe.drop(date_merge, axis=1)
 
     if ffill:
         dataframe = dataframe.ffill()
@@ -83,3 +91,28 @@ def stoploss_from_open(open_relative_stop: float, current_profit: float) -> floa
 
     # negative stoploss values indicate the requested stop price is higher than the current price
     return max(stoploss, 0.0)
+
+
+def stoploss_from_absolute(stop_rate: float, current_rate: float) -> float:
+    """
+    Given current price and desired stop price, return a stop loss value that is relative to current
+    price.
+
+    The requested stop can be positive for a stop above the open price, or negative for
+    a stop below the open price. The return value is always >= 0.
+
+    Returns 0 if the resulting stop price would be above the current price.
+
+    :param stop_rate: Stop loss price.
+    :param current_rate: Current asset price.
+    :return: Positive stop loss value relative to current price
+    """
+
+    # formula is undefined for current_rate 0, return maximum value
+    if current_rate == 0:
+        return 1
+
+    stoploss = 1 - (stop_rate / current_rate)
+
+    # negative stoploss values indicate the requested stop price is higher than the current price
+    return max(stoploss, 0.0)

tests/rpc/test_rpc_apiserver.py

@@ -1218,6 +1218,7 @@ def test_api_strategies(botclient):
     assert_response(rc)
     assert rc.json() == {'strategies': [
         'HyperoptableStrategy',
+        'InformativeDecoratorTest',
         'StrategyTestV2',
         'TestStrategyLegacyV1'
     ]}

tests/strategy/strats/informative_decorator_strategy.py

@@ -0,0 +1,75 @@
+# pragma pylint: disable=missing-docstring, invalid-name, pointless-string-statement
+
+from pandas import DataFrame
+
+from freqtrade.strategy import informative, merge_informative_pair
+from freqtrade.strategy.interface import IStrategy
+
+
+class InformativeDecoratorTest(IStrategy):
+    """
+    Strategy used by tests 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
+    stoploss = -0.10
+    timeframe = '5m'
+    startup_candle_count: int = 20
+
+    def informative_pairs(self):
+        return [('BTC/USDT', '5m')]
+
+    def populate_buy_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
+        dataframe['buy'] = 0
+        return dataframe
+
+    def populate_sell_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
+        dataframe['sell'] = 0
+        return dataframe
+
+    # Decorator stacking test.
+    @informative('30m')
+    @informative('1h')
+    def populate_indicators_1h(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
+        dataframe['rsi'] = 14
+        return dataframe
+
+    # Simple informative test.
+    @informative('1h', 'BTC/{stake}')
+    def populate_indicators_btc_1h(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
+        dataframe['rsi'] = 14
+        return dataframe
+
+    # Quote currency different from stake currency test.
+    @informative('1h', 'ETH/BTC')
+    def populate_indicators_eth_btc_1h(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
+        dataframe['rsi'] = 14
+        return dataframe
+
+    # Formatting test.
+    @informative('30m', 'BTC/{stake}', '{column}_{BASE}_{QUOTE}_{base}_{quote}_{asset}_{timeframe}')
+    def populate_indicators_btc_1h_2(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
+        dataframe['rsi'] = 14
+        return dataframe
+
+    # Custom formatter test
+    @informative('30m', 'ETH/{stake}', fmt=lambda column, **kwargs: column + '_from_callable')
+    def populate_indicators_eth_30m(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
+        dataframe['rsi'] = 14
+        return dataframe
+
+    def populate_indicators(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
+        # Strategy timeframe indicators for current pair.
+        dataframe['rsi'] = 14
+        # Informative pairs are available in this method.
+        dataframe['rsi_less'] = dataframe['rsi'] < dataframe['rsi_1h']
+
+        # Mixing manual informative pairs with decorators.
+        informative = self.dp.get_pair_dataframe('BTC/USDT', '5m')
+        informative['rsi'] = 14
+        dataframe = merge_informative_pair(dataframe, informative, self.timeframe, '5m', ffill=True)
+
+        return dataframe

tests/strategy/test_interface.py

@@ -607,7 +607,7 @@ def test_is_informative_pairs_callback(default_conf):
     strategy = StrategyResolver.load_strategy(default_conf)
     # Should return empty
     # Uses fallback to base implementation
-    assert [] == strategy.informative_pairs()
+    assert [] == strategy.gather_informative_pairs()
 
 
 @pytest.mark.parametrize('error', [

tests/strategy/test_strategy_helpers.py

@@ -4,7 +4,9 @@ import numpy as np
 import pandas as pd
 import pytest
 
-from freqtrade.strategy import merge_informative_pair, stoploss_from_open, timeframe_to_minutes
+from freqtrade.data.dataprovider import DataProvider
+from freqtrade.strategy import (merge_informative_pair, stoploss_from_absolute, stoploss_from_open,
+                                timeframe_to_minutes)
 
 
 def generate_test_data(timeframe: str, size: int):
@@ -132,3 +134,65 @@ def test_stoploss_from_open():
                         assert stoploss == 0
                     else:
                         assert isclose(stop_price, expected_stop_price, rel_tol=0.00001)
+
+
+def test_stoploss_from_absolute():
+    assert stoploss_from_absolute(90, 100) == 1 - (90 / 100)
+    assert stoploss_from_absolute(100, 100) == 0
+    assert stoploss_from_absolute(110, 100) == 0
+    assert stoploss_from_absolute(100, 0) == 1
+    assert stoploss_from_absolute(0, 100) == 1
+
+
+def test_informative_decorator(mocker, default_conf):
+    test_data_5m = generate_test_data('5m', 40)
+    test_data_30m = generate_test_data('30m', 40)
+    test_data_1h = generate_test_data('1h', 40)
+    data = {
+        ('XRP/USDT', '5m'): test_data_5m,
+        ('XRP/USDT', '30m'): test_data_30m,
+        ('XRP/USDT', '1h'): test_data_1h,
+        ('LTC/USDT', '5m'): test_data_5m,
+        ('LTC/USDT', '30m'): test_data_30m,
+        ('LTC/USDT', '1h'): test_data_1h,
+        ('BTC/USDT', '30m'): test_data_30m,
+        ('BTC/USDT', '5m'): test_data_5m,
+        ('BTC/USDT', '1h'): test_data_1h,
+        ('ETH/USDT', '1h'): test_data_1h,
+        ('ETH/USDT', '30m'): test_data_30m,
+        ('ETH/BTC', '1h'): test_data_1h,
+    }
+    from .strats.informative_decorator_strategy import InformativeDecoratorTest
+    default_conf['stake_currency'] = 'USDT'
+    strategy = InformativeDecoratorTest(config=default_conf)
+    strategy.dp = DataProvider({}, None, None)
+    mocker.patch.object(strategy.dp, 'current_whitelist', return_value=[
+        'XRP/USDT', 'LTC/USDT', 'BTC/USDT'
+    ])
+
+    assert len(strategy._ft_informative) == 6   # Equal to number of decorators used
+    informative_pairs = [('XRP/USDT', '1h'), ('LTC/USDT', '1h'), ('XRP/USDT', '30m'),
+                         ('LTC/USDT', '30m'), ('BTC/USDT', '1h'), ('BTC/USDT', '30m'),
+                         ('BTC/USDT', '5m'), ('ETH/BTC', '1h'), ('ETH/USDT', '30m')]
+    for inf_pair in informative_pairs:
+        assert inf_pair in strategy.gather_informative_pairs()
+
+    def test_historic_ohlcv(pair, timeframe):
+        return data[(pair, timeframe or strategy.timeframe)].copy()
+    mocker.patch('freqtrade.data.dataprovider.DataProvider.historic_ohlcv',
+                 side_effect=test_historic_ohlcv)
+
+    analyzed = strategy.advise_all_indicators(
+        {p: data[(p, strategy.timeframe)] for p in ('XRP/USDT', 'LTC/USDT')})
+    expected_columns = [
+        'rsi_1h', 'rsi_30m',                    # Stacked informative decorators
+        'btc_usdt_rsi_1h',                      # BTC 1h informative
+        'rsi_BTC_USDT_btc_usdt_BTC/USDT_30m',   # Column formatting
+        'rsi_from_callable',                    # Custom column formatter
+        'eth_btc_rsi_1h',                       # Quote currency not matching stake currency
+        'rsi', 'rsi_less',                      # Non-informative columns
+        'rsi_5m',                               # Manual informative dataframe
+    ]
+    for _, dataframe in analyzed.items():
+        for col in expected_columns:
+            assert col in dataframe.columns

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) == 3
+    assert len(strategies) == 4
     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) == 4
+    assert len(strategies) == 5
     # 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]) == 3
+    assert len([x for x in strategies if x['class'] is not None]) == 4
     assert len([x for x in strategies if x['class'] is None]) == 1