From 457e738b4a049cbc522987612dc2e4bd91b272e9 Mon Sep 17 00:00:00 2001
From: Sergey Khliustin <sergey.khliustin@gmail.com>
Date: Thu, 16 Sep 2021 14:48:02 +0300
Subject: [PATCH 01/34] Added days parameter to PerformanceFilter

---
 freqtrade/persistence/models.py               | 28 ++++++++++++++++++-
 .../plugins/pairlist/PerformanceFilter.py     | 15 ++++++++--
 2 files changed, 40 insertions(+), 3 deletions(-)

diff --git a/freqtrade/persistence/models.py b/freqtrade/persistence/models.py
index 8c8c1e0a9..91a26eba7 100644
--- a/freqtrade/persistence/models.py
+++ b/freqtrade/persistence/models.py
@@ -2,7 +2,7 @@
 This module contains the class to persist trades into SQLite
 """
 import logging
-from datetime import datetime, timezone
+from datetime import datetime, timezone, timedelta
 from decimal import Decimal
 from typing import Any, Dict, List, Optional
 
@@ -856,6 +856,32 @@ class Trade(_DECL_BASE, LocalTrade):
             for pair, profit, profit_abs, count in pair_rates
         ]
 
+    @staticmethod
+    def get_performance(days: int) -> List[Dict[str, Any]]:
+        """
+        Returns List of dicts containing all Trades, including profit and trade count
+        NOTE: Not supported in Backtesting.
+        """
+        start_date = datetime.today() - timedelta(days)
+        pair_rates = Trade.query.with_entities(
+            Trade.pair,
+            func.sum(Trade.close_profit).label('profit_sum'),
+            func.sum(Trade.close_profit_abs).label('profit_sum_abs'),
+            func.count(Trade.pair).label('count')
+        ).filter(Trade.is_open.is_(False) & (Trade.close_date >= start_date))\
+            .group_by(Trade.pair) \
+            .order_by(desc('profit_sum_abs')) \
+            .all()
+        return [
+            {
+                'pair': pair,
+                'profit': profit,
+                'profit_abs': profit_abs,
+                'count': count
+            }
+            for pair, profit, profit_abs, count in pair_rates
+        ]
+
     @staticmethod
     def get_best_pair(start_date: datetime = datetime.fromtimestamp(0)):
         """
diff --git a/freqtrade/plugins/pairlist/PerformanceFilter.py b/freqtrade/plugins/pairlist/PerformanceFilter.py
index 46a289ae6..4d530fe88 100644
--- a/freqtrade/plugins/pairlist/PerformanceFilter.py
+++ b/freqtrade/plugins/pairlist/PerformanceFilter.py
@@ -2,11 +2,12 @@
 Performance pair list filter
 """
 import logging
-from typing import Dict, List
+from typing import Dict, List, Any
 
 import pandas as pd
 
 from freqtrade.persistence import Trade
+from freqtrade.exceptions import OperationalException
 from freqtrade.plugins.pairlist.IPairList import IPairList
 
 
@@ -15,6 +16,13 @@ logger = logging.getLogger(__name__)
 
 class PerformanceFilter(IPairList):
 
+    def __init__(self, exchange, pairlistmanager,
+                 config: Dict[str, Any], pairlistconfig: Dict[str, Any],
+                 pairlist_pos: int) -> None:
+        super().__init__(exchange, pairlistmanager, config, pairlistconfig, pairlist_pos)
+
+        self._days = pairlistconfig.get('days', 0)
+
     @property
     def needstickers(self) -> bool:
         """
@@ -40,7 +48,10 @@ class PerformanceFilter(IPairList):
         """
         # Get the trading performance for pairs from database
         try:
-            performance = pd.DataFrame(Trade.get_overall_performance())
+            if self._days > 0:
+                performance = pd.DataFrame(Trade.get_performance(self._days))
+            else:
+                performance = pd.DataFrame(Trade.get_overall_performance())
         except AttributeError:
             # Performancefilter does not work in backtesting.
             self.log_once("PerformanceFilter is not available in this mode.", logger.warning)

From 54ef36a4971d77467a10fa343857aec27a312e5a Mon Sep 17 00:00:00 2001
From: Sergey Khliustin <sergey.khliustin@gmail.com>
Date: Fri, 17 Sep 2021 13:45:44 +0300
Subject: [PATCH 02/34] Updates after review to PerformanceFilter days param

---
 freqtrade/persistence/models.py               | 34 ++++---------------
 .../plugins/pairlist/PerformanceFilter.py     |  5 +--
 2 files changed, 7 insertions(+), 32 deletions(-)

diff --git a/freqtrade/persistence/models.py b/freqtrade/persistence/models.py
index 91a26eba7..222be7169 100644
--- a/freqtrade/persistence/models.py
+++ b/freqtrade/persistence/models.py
@@ -832,43 +832,21 @@ class Trade(_DECL_BASE, LocalTrade):
         return total_open_stake_amount or 0
 
     @staticmethod
-    def get_overall_performance() -> List[Dict[str, Any]]:
+    def get_overall_performance(days=None) -> List[Dict[str, Any]]:
         """
         Returns List of dicts containing all Trades, including profit and trade count
         NOTE: Not supported in Backtesting.
         """
+        filters = [Trade.is_open.is_(False)]
+        if days:
+            start_date = datetime.today() - timedelta(days)
+            filters.append((Trade.close_date >= start_date))
         pair_rates = Trade.query.with_entities(
             Trade.pair,
             func.sum(Trade.close_profit).label('profit_sum'),
             func.sum(Trade.close_profit_abs).label('profit_sum_abs'),
             func.count(Trade.pair).label('count')
-        ).filter(Trade.is_open.is_(False))\
-            .group_by(Trade.pair) \
-            .order_by(desc('profit_sum_abs')) \
-            .all()
-        return [
-            {
-                'pair': pair,
-                'profit': profit,
-                'profit_abs': profit_abs,
-                'count': count
-            }
-            for pair, profit, profit_abs, count in pair_rates
-        ]
-
-    @staticmethod
-    def get_performance(days: int) -> List[Dict[str, Any]]:
-        """
-        Returns List of dicts containing all Trades, including profit and trade count
-        NOTE: Not supported in Backtesting.
-        """
-        start_date = datetime.today() - timedelta(days)
-        pair_rates = Trade.query.with_entities(
-            Trade.pair,
-            func.sum(Trade.close_profit).label('profit_sum'),
-            func.sum(Trade.close_profit_abs).label('profit_sum_abs'),
-            func.count(Trade.pair).label('count')
-        ).filter(Trade.is_open.is_(False) & (Trade.close_date >= start_date))\
+        ).filter(filters)\
             .group_by(Trade.pair) \
             .order_by(desc('profit_sum_abs')) \
             .all()
diff --git a/freqtrade/plugins/pairlist/PerformanceFilter.py b/freqtrade/plugins/pairlist/PerformanceFilter.py
index 4d530fe88..920b884a0 100644
--- a/freqtrade/plugins/pairlist/PerformanceFilter.py
+++ b/freqtrade/plugins/pairlist/PerformanceFilter.py
@@ -48,10 +48,7 @@ class PerformanceFilter(IPairList):
         """
         # Get the trading performance for pairs from database
         try:
-            if self._days > 0:
-                performance = pd.DataFrame(Trade.get_performance(self._days))
-            else:
-                performance = pd.DataFrame(Trade.get_overall_performance())
+            performance = pd.DataFrame(Trade.get_overall_performance(self._days))
         except AttributeError:
             # Performancefilter does not work in backtesting.
             self.log_once("PerformanceFilter is not available in this mode.", logger.warning)

From 982deeedf04cb1be9c5ae7b1ec3598a9d09a4b9a Mon Sep 17 00:00:00 2001
From: sergeykhliustin <51409210+sergeykhliustin@users.noreply.github.com>
Date: Fri, 17 Sep 2021 18:23:13 +0300
Subject: [PATCH 03/34] Update freqtrade/persistence/models.py

Co-authored-by: Matthias <xmatthias@outlook.com>
---
 freqtrade/persistence/models.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/freqtrade/persistence/models.py b/freqtrade/persistence/models.py
index 222be7169..a2e30d58c 100644
--- a/freqtrade/persistence/models.py
+++ b/freqtrade/persistence/models.py
@@ -846,7 +846,7 @@ class Trade(_DECL_BASE, LocalTrade):
             func.sum(Trade.close_profit).label('profit_sum'),
             func.sum(Trade.close_profit_abs).label('profit_sum_abs'),
             func.count(Trade.pair).label('count')
-        ).filter(filters)\
+        ).filter(*filters)\
             .group_by(Trade.pair) \
             .order_by(desc('profit_sum_abs')) \
             .all()

From 3a98fb72a491536cef7b601573c3ca45f64e8fc5 Mon Sep 17 00:00:00 2001
From: raphael <rtnanje@gmail.com>
Date: Fri, 17 Sep 2021 11:42:33 -0400
Subject: [PATCH 04/34] Update prepare_trials_columns() return type

Was returning str, updated to pd.DataFrame
---
 freqtrade/optimize/hyperopt_tools.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/freqtrade/optimize/hyperopt_tools.py b/freqtrade/optimize/hyperopt_tools.py
index b2e024f65..2fcab0b0f 100755
--- a/freqtrade/optimize/hyperopt_tools.py
+++ b/freqtrade/optimize/hyperopt_tools.py
@@ -7,6 +7,7 @@ from pathlib import Path
 from typing import Any, Dict, Iterator, List, Optional, Tuple
 
 import numpy as np
+import pandas as pd
 import rapidjson
 import tabulate
 from colorama import Fore, Style
@@ -298,7 +299,7 @@ class HyperoptTools():
                 f"Objective: {results['loss']:.5f}")
 
     @staticmethod
-    def prepare_trials_columns(trials, legacy_mode: bool, has_drawdown: bool) -> str:
+    def prepare_trials_columns(trials, legacy_mode: bool, has_drawdown: bool) -> pd.DataFrame:
 
         trials['Best'] = ''
 

From 5fc993231a2d138e9ff994f1d4548888551dd73c Mon Sep 17 00:00:00 2001
From: raphael <rtnanje@gmail.com>
Date: Fri, 17 Sep 2021 11:51:55 -0400
Subject: [PATCH 05/34] Update HyperoptTools.export_csv_file usage

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

diff --git a/freqtrade/commands/hyperopt_commands.py b/freqtrade/commands/hyperopt_commands.py
index 089529d15..614c4b3f5 100755
--- a/freqtrade/commands/hyperopt_commands.py
+++ b/freqtrade/commands/hyperopt_commands.py
@@ -53,7 +53,7 @@ def start_hyperopt_list(args: Dict[str, Any]) -> None:
 
     if epochs and export_csv:
         HyperoptTools.export_csv_file(
-            config, epochs, total_epochs, not config.get('hyperopt_list_best', False), export_csv
+            config, epochs, export_csv
         )
 
 

From 124e97f3b9a7006cfcf2337255f10c8bcc3e0038 Mon Sep 17 00:00:00 2001
From: raphael <rtnanje@gmail.com>
Date: Fri, 17 Sep 2021 11:57:36 -0400
Subject: [PATCH 06/34] Remove ununsed variables from export_csv_file

---
 freqtrade/optimize/hyperopt_tools.py | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/freqtrade/optimize/hyperopt_tools.py b/freqtrade/optimize/hyperopt_tools.py
index b2e024f65..6a5c31d56 100755
--- a/freqtrade/optimize/hyperopt_tools.py
+++ b/freqtrade/optimize/hyperopt_tools.py
@@ -435,8 +435,7 @@ class HyperoptTools():
         return table
 
     @staticmethod
-    def export_csv_file(config: dict, results: list, total_epochs: int, highlight_best: bool,
-                        csv_file: str) -> None:
+    def export_csv_file(config: dict, results: list, csv_file: str) -> None:
         """
         Log result to csv-file
         """

From fb6beb90e87e75d2997651324daaf0c5954e661a Mon Sep 17 00:00:00 2001
From: Ottavio Miele <RacerOttavio97@gmail.com>
Date: Fri, 17 Sep 2021 18:03:54 +0200
Subject: [PATCH 07/34] Include Raspberry Pi armv6 (0, 0W,...)

---
 setup.sh | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/setup.sh b/setup.sh
index 217500569..aee7c80b5 100755
--- a/setup.sh
+++ b/setup.sh
@@ -62,7 +62,7 @@ function updateenv() {
     then
         REQUIREMENTS_PLOT="-r requirements-plot.txt"
     fi
-    if [ "${SYS_ARCH}" == "armv7l" ]; then
+    if [ "${SYS_ARCH}" == "armv7l" ] || [ "${SYS_ARCH}" == "armv6l" ]; then
         echo "Detected Raspberry, installing cython, skipping hyperopt installation."
         ${PYTHON} -m pip install --upgrade cython
     else

From 9525a5b96cf779dfa80abdae355e2d5c9382f505 Mon Sep 17 00:00:00 2001
From: raphael <rtnanje@gmail.com>
Date: Fri, 17 Sep 2021 14:10:37 -0400
Subject: [PATCH 08/34] Add type to "trials" parameter

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

diff --git a/freqtrade/optimize/hyperopt_tools.py b/freqtrade/optimize/hyperopt_tools.py
index 2fcab0b0f..1874b2949 100755
--- a/freqtrade/optimize/hyperopt_tools.py
+++ b/freqtrade/optimize/hyperopt_tools.py
@@ -299,7 +299,7 @@ class HyperoptTools():
                 f"Objective: {results['loss']:.5f}")
 
     @staticmethod
-    def prepare_trials_columns(trials, legacy_mode: bool, has_drawdown: bool) -> pd.DataFrame:
+    def prepare_trials_columns(trials: pd.DataFrame, legacy_mode: bool, has_drawdown: bool) -> pd.DataFrame:
 
         trials['Best'] = ''
 

From e715f2a253afe2ef4332166c0357595976dd7dfc Mon Sep 17 00:00:00 2001
From: raphael <rtnanje@gmail.com>
Date: Fri, 17 Sep 2021 14:23:26 -0400
Subject: [PATCH 09/34] Update formatting

Line 302 was too long
---
 freqtrade/optimize/hyperopt_tools.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/freqtrade/optimize/hyperopt_tools.py b/freqtrade/optimize/hyperopt_tools.py
index 1874b2949..ac92ad682 100755
--- a/freqtrade/optimize/hyperopt_tools.py
+++ b/freqtrade/optimize/hyperopt_tools.py
@@ -299,7 +299,8 @@ class HyperoptTools():
                 f"Objective: {results['loss']:.5f}")
 
     @staticmethod
-    def prepare_trials_columns(trials: pd.DataFrame, legacy_mode: bool, has_drawdown: bool) -> pd.DataFrame:
+    def prepare_trials_columns(trials: pd.DataFrame, legacy_mode: bool, 
+                               has_drawdown: bool) -> pd.DataFrame:
 
         trials['Best'] = ''
 

From 4b2c1a9b8e0e487a60454125e8916026b8443c5c Mon Sep 17 00:00:00 2001
From: raphael <rtnanje@gmail.com>
Date: Fri, 17 Sep 2021 14:39:15 -0400
Subject: [PATCH 10/34] Remove trailing whitespace

---
 freqtrade/optimize/hyperopt_tools.py | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/freqtrade/optimize/hyperopt_tools.py b/freqtrade/optimize/hyperopt_tools.py
index ac92ad682..7a4ce5f23 100755
--- a/freqtrade/optimize/hyperopt_tools.py
+++ b/freqtrade/optimize/hyperopt_tools.py
@@ -299,9 +299,8 @@ class HyperoptTools():
                 f"Objective: {results['loss']:.5f}")
 
     @staticmethod
-    def prepare_trials_columns(trials: pd.DataFrame, legacy_mode: bool, 
+    def prepare_trials_columns(trials: pd.DataFrame, legacy_mode: bool,
                                has_drawdown: bool) -> pd.DataFrame:
-
         trials['Best'] = ''
 
         if 'results_metrics.winsdrawslosses' not in trials.columns:

From d7395e873be5560932752e00200c70fc2cd169c3 Mon Sep 17 00:00:00 2001
From: Sergey Khliustin <sergey.khliustin@gmail.com>
Date: Fri, 17 Sep 2021 22:05:57 +0300
Subject: [PATCH 11/34] Removed unused OperationalException

---
 freqtrade/plugins/pairlist/PerformanceFilter.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/freqtrade/plugins/pairlist/PerformanceFilter.py b/freqtrade/plugins/pairlist/PerformanceFilter.py
index 920b884a0..5750b721c 100644
--- a/freqtrade/plugins/pairlist/PerformanceFilter.py
+++ b/freqtrade/plugins/pairlist/PerformanceFilter.py
@@ -7,7 +7,6 @@ from typing import Dict, List, Any
 import pandas as pd
 
 from freqtrade.persistence import Trade
-from freqtrade.exceptions import OperationalException
 from freqtrade.plugins.pairlist.IPairList import IPairList
 
 

From 12c12d42df5e0f838aad1ef971ca8530345d2d00 Mon Sep 17 00:00:00 2001
From: Matthias <xmatthias@outlook.com>
Date: Sat, 18 Sep 2021 08:26:48 +0200
Subject: [PATCH 12/34] Add documentation for days parameter in
 PerformanceFilter

---
 docs/includes/pairlists.md                      | 14 ++++++++++++++
 freqtrade/persistence/models.py                 |  4 ++--
 freqtrade/plugins/pairlist/PerformanceFilter.py |  2 +-
 3 files changed, 17 insertions(+), 3 deletions(-)

diff --git a/docs/includes/pairlists.md b/docs/includes/pairlists.md
index 69e12d5dc..71165f93b 100644
--- a/docs/includes/pairlists.md
+++ b/docs/includes/pairlists.md
@@ -165,6 +165,7 @@ Example to remove the first 10 pairs from the pairlist:
 
 ```json
 "pairlists": [
+    // ...
     {
         "method": "OffsetFilter",
         "offset": 10
@@ -190,6 +191,19 @@ Sorts pairs by past trade performance, as follows:
 
 Trade count is used as a tie breaker.
 
+You can use the `days` parameter to only consider performance of the past X days.
+Not defining this parameter (or setting it to 0) will use all-time performance.
+
+```json
+"pairlists": [
+    // ...
+    {
+        "method": "PerformanceFilter",
+        "days": 10
+    }
+],
+```
+
 !!! Note
     `PerformanceFilter` does not support backtesting mode.
 
diff --git a/freqtrade/persistence/models.py b/freqtrade/persistence/models.py
index a2e30d58c..f5f4e3a26 100644
--- a/freqtrade/persistence/models.py
+++ b/freqtrade/persistence/models.py
@@ -2,7 +2,7 @@
 This module contains the class to persist trades into SQLite
 """
 import logging
-from datetime import datetime, timezone, timedelta
+from datetime import datetime, timedelta, timezone
 from decimal import Decimal
 from typing import Any, Dict, List, Optional
 
@@ -840,7 +840,7 @@ class Trade(_DECL_BASE, LocalTrade):
         filters = [Trade.is_open.is_(False)]
         if days:
             start_date = datetime.today() - timedelta(days)
-            filters.append((Trade.close_date >= start_date))
+            filters.append(Trade.close_date >= start_date)
         pair_rates = Trade.query.with_entities(
             Trade.pair,
             func.sum(Trade.close_profit).label('profit_sum'),
diff --git a/freqtrade/plugins/pairlist/PerformanceFilter.py b/freqtrade/plugins/pairlist/PerformanceFilter.py
index 5750b721c..ee443b0fe 100644
--- a/freqtrade/plugins/pairlist/PerformanceFilter.py
+++ b/freqtrade/plugins/pairlist/PerformanceFilter.py
@@ -2,7 +2,7 @@
 Performance pair list filter
 """
 import logging
-from typing import Dict, List, Any
+from typing import Any, Dict, List
 
 import pandas as pd
 

From 564e0b9a1ac89c19f2a9c1e94c04cafd4fd96afe Mon Sep 17 00:00:00 2001
From: Matthias <xmatthias@outlook.com>
Date: Sat, 18 Sep 2021 08:36:06 +0200
Subject: [PATCH 13/34] Switch performanceFilter to use Minutes lookback
 resolution

closes #5060
---
 docs/includes/pairlists.md                      | 4 ++--
 freqtrade/persistence/models.py                 | 6 +++---
 freqtrade/plugins/pairlist/PerformanceFilter.py | 4 ++--
 3 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/docs/includes/pairlists.md b/docs/includes/pairlists.md
index 71165f93b..b612a4ddf 100644
--- a/docs/includes/pairlists.md
+++ b/docs/includes/pairlists.md
@@ -191,7 +191,7 @@ Sorts pairs by past trade performance, as follows:
 
 Trade count is used as a tie breaker.
 
-You can use the `days` parameter to only consider performance of the past X days.
+You can use the `minutes` parameter to only consider performance of the past X minutes (rolling window).
 Not defining this parameter (or setting it to 0) will use all-time performance.
 
 ```json
@@ -199,7 +199,7 @@ Not defining this parameter (or setting it to 0) will use all-time performance.
     // ...
     {
         "method": "PerformanceFilter",
-        "days": 10
+        "minutes": 1440  // rolling 24h
     }
 ],
 ```
diff --git a/freqtrade/persistence/models.py b/freqtrade/persistence/models.py
index f5f4e3a26..bc5ef961a 100644
--- a/freqtrade/persistence/models.py
+++ b/freqtrade/persistence/models.py
@@ -832,14 +832,14 @@ class Trade(_DECL_BASE, LocalTrade):
         return total_open_stake_amount or 0
 
     @staticmethod
-    def get_overall_performance(days=None) -> List[Dict[str, Any]]:
+    def get_overall_performance(minutes=None) -> List[Dict[str, Any]]:
         """
         Returns List of dicts containing all Trades, including profit and trade count
         NOTE: Not supported in Backtesting.
         """
         filters = [Trade.is_open.is_(False)]
-        if days:
-            start_date = datetime.today() - timedelta(days)
+        if minutes:
+            start_date = datetime.now(timezone.utc) - timedelta(minutes=minutes)
             filters.append(Trade.close_date >= start_date)
         pair_rates = Trade.query.with_entities(
             Trade.pair,
diff --git a/freqtrade/plugins/pairlist/PerformanceFilter.py b/freqtrade/plugins/pairlist/PerformanceFilter.py
index ee443b0fe..301ee57ab 100644
--- a/freqtrade/plugins/pairlist/PerformanceFilter.py
+++ b/freqtrade/plugins/pairlist/PerformanceFilter.py
@@ -20,7 +20,7 @@ class PerformanceFilter(IPairList):
                  pairlist_pos: int) -> None:
         super().__init__(exchange, pairlistmanager, config, pairlistconfig, pairlist_pos)
 
-        self._days = pairlistconfig.get('days', 0)
+        self._minutes = pairlistconfig.get('minutes', 0)
 
     @property
     def needstickers(self) -> bool:
@@ -47,7 +47,7 @@ class PerformanceFilter(IPairList):
         """
         # Get the trading performance for pairs from database
         try:
-            performance = pd.DataFrame(Trade.get_overall_performance(self._days))
+            performance = pd.DataFrame(Trade.get_overall_performance(self._minutes))
         except AttributeError:
             # Performancefilter does not work in backtesting.
             self.log_once("PerformanceFilter is not available in this mode.", logger.warning)

From 56fb25c5e521415c9880e47c4938bfe357550bec Mon Sep 17 00:00:00 2001
From: Matthias <xmatthias@outlook.com>
Date: Sat, 18 Sep 2021 09:10:37 +0200
Subject: [PATCH 14/34] Add test for PerformanceFilter lookback

---
 tests/plugins/test_pairlist.py | 28 +++++++++++++++++++++++++++-
 1 file changed, 27 insertions(+), 1 deletion(-)

diff --git a/tests/plugins/test_pairlist.py b/tests/plugins/test_pairlist.py
index 34770c03d..1ce8d172c 100644
--- a/tests/plugins/test_pairlist.py
+++ b/tests/plugins/test_pairlist.py
@@ -12,7 +12,8 @@ from freqtrade.persistence import Trade
 from freqtrade.plugins.pairlist.pairlist_helpers import expand_pairlist
 from freqtrade.plugins.pairlistmanager import PairListManager
 from freqtrade.resolvers import PairListResolver
-from tests.conftest import get_patched_exchange, get_patched_freqtradebot, log_has, log_has_re
+from tests.conftest import (create_mock_trades, get_patched_exchange, get_patched_freqtradebot,
+                            log_has, log_has_re)
 
 
 @pytest.fixture(scope="function")
@@ -663,6 +664,31 @@ def test_PerformanceFilter_error(mocker, whitelist_conf, caplog) -> None:
     assert log_has("PerformanceFilter is not available in this mode.", caplog)
 
 
+@pytest.mark.usefixtures("init_persistence")
+def test_PerformanceFilter_lookback(mocker, whitelist_conf, fee) -> None:
+    whitelist_conf['exchange']['pair_whitelist'].append('XRP/BTC')
+    whitelist_conf['pairlists'] = [
+        {"method": "StaticPairList"},
+        {"method": "PerformanceFilter", "minutes": 60}
+    ]
+    mocker.patch('freqtrade.exchange.Exchange.exchange_has', MagicMock(return_value=True))
+    exchange = get_patched_exchange(mocker, whitelist_conf)
+    pm = PairListManager(exchange, whitelist_conf)
+    pm.refresh_pairlist()
+
+    assert pm.whitelist == ['ETH/BTC', 'TKN/BTC', 'XRP/BTC']
+
+    with time_machine.travel("2021-09-01 05:00:00 +00:00") as t:
+        create_mock_trades(fee)
+        pm.refresh_pairlist()
+        assert pm.whitelist == ['XRP/BTC', 'ETH/BTC', 'TKN/BTC']
+
+        # Move to "outside" of lookback window, so original sorting is restored.
+        t.move_to("2021-09-01 07:00:00 +00:00")
+        pm.refresh_pairlist()
+        assert pm.whitelist == ['ETH/BTC', 'TKN/BTC', 'XRP/BTC']
+
+
 def test_gen_pair_whitelist_not_supported(mocker, default_conf, tickers) -> None:
     default_conf['pairlists'] = [{'method': 'VolumePairList', 'number_assets': 10}]
 

From d84ef34740a65df4922a13b8e8e523167637ae2e Mon Sep 17 00:00:00 2001
From: Rokas Kupstys <rokups@zoho.com>
Date: Sat, 17 Jul 2021 18:09:08 +0300
Subject: [PATCH 15/34] A helper to calculate stoploss value from absolute
 price.

---
 docs/strategy-advanced.md             |  6 ++++
 docs/strategy-customization.md        | 41 +++++++++++++++++++++++++++
 freqtrade/strategy/__init__.py        |  3 +-
 freqtrade/strategy/strategy_helper.py | 11 +++++++
 4 files changed, 60 insertions(+), 1 deletion(-)

diff --git a/docs/strategy-advanced.md b/docs/strategy-advanced.md
index 4409af6ea..2b9517f3b 100644
--- a/docs/strategy-advanced.md
+++ b/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.
diff --git a/docs/strategy-customization.md b/docs/strategy-customization.md
index cfea60d22..1f8116deb 100644
--- a/docs/strategy-customization.md
+++ b/docs/strategy-customization.md
@@ -639,6 +639,47 @@ 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"
+
+    Say the open price was $100, and `current_price` is $121 (`current_profit` will be `0.21`).
+
+    If we want a stop price at $107 price we can call `stoploss_from_absolute(107, current_rate)` which will return `0.1157024793`.  11.57% below $121 is $107, which is the same as 7% above $100.
+
+    ``` python
+
+    from datetime import datetime
+    from freqtrade.persistence import Trade
+    from freqtrade.strategy import IStrategy, stoploss_from_open
+
+    class AwesomeStrategy(IStrategy):
+
+        # ... populate_* methods
+
+        use_custom_stoploss = True
+
+        def custom_stoploss(self, pair: str, trade: 'Trade', current_time: datetime,
+                            current_rate: float, current_profit: float, **kwargs) -> float:
+
+            # once the profit has risen above 10%, keep the stoploss at 7% above the open price
+            if current_profit > 0.10:
+                return stoploss_from_absolute(trade.open_rate * 1.07, current_rate)
+
+            return 1
+
+    ```
+
+    Full examples can be found in the [Custom stoploss](strategy-advanced.md#custom-stoploss) section of the Documentation.
 
 ## Additional data (Wallets)
 
diff --git a/freqtrade/strategy/__init__.py b/freqtrade/strategy/__init__.py
index be655fc33..703cdabc1 100644
--- a/freqtrade/strategy/__init__.py
+++ b/freqtrade/strategy/__init__.py
@@ -4,4 +4,5 @@ from freqtrade.exchange import (timeframe_to_minutes, timeframe_to_msecs, timefr
 from freqtrade.strategy.hyper import (BooleanParameter, CategoricalParameter, DecimalParameter,
                                       IntParameter, RealParameter)
 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)
diff --git a/freqtrade/strategy/strategy_helper.py b/freqtrade/strategy/strategy_helper.py
index e089ebf31..32f7a9886 100644
--- a/freqtrade/strategy/strategy_helper.py
+++ b/freqtrade/strategy/strategy_helper.py
@@ -83,3 +83,14 @@ 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.
+    :param stop_rate: Stop loss price.
+    :param current_rate: Current asset price.
+    :return: Positive stop loss value relative to current price
+    """
+    return 1 - (stop_rate / current_rate)

From 1fdb656334208f57916fe4539ab83e9363d7b984 Mon Sep 17 00:00:00 2001
From: Rokas Kupstys <rokups@zoho.com>
Date: Sat, 17 Jul 2021 19:19:49 +0300
Subject: [PATCH 16/34] Add a decorator which can be used to declare
 populate_indicators() functions for informative pairs.

---
 docs/strategy-customization.md                |  84 +++++++++-
 freqtrade/edge/edge_positioning.py            |   2 +-
 freqtrade/freqtradebot.py                     |   2 +-
 freqtrade/strategy/__init__.py                |   2 +-
 freqtrade/strategy/interface.py               |  53 ++++++-
 freqtrade/strategy/strategy_helper.py         | 148 +++++++++++++++++-
 tests/rpc/test_rpc_apiserver.py               |   1 +
 .../strats/informative_decorator_strategy.py  |  75 +++++++++
 tests/strategy/test_interface.py              |   2 +-
 tests/strategy/test_strategy_helpers.py       |  55 +++++++
 tests/strategy/test_strategy_loading.py       |   6 +-
 11 files changed, 414 insertions(+), 16 deletions(-)
 create mode 100644 tests/strategy/strats/informative_decorator_strategy.py

diff --git a/docs/strategy-customization.md b/docs/strategy-customization.md
index 1f8116deb..526c111c5 100644
--- a/docs/strategy-customization.md
+++ b/docs/strategy-customization.md
@@ -679,7 +679,89 @@ In some situations it may be confusing to deal with stops relative to current ra
 
     ```
 
-    Full examples can be found in the [Custom stoploss](strategy-advanced.md#custom-stoploss) section of the Documentation.
+### *@informative()*
+
+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, please follow instructions of [optimizing an indicator parameter](hyperopt.md#optimizing-an-indicator-parameter).
+
+??? 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_rsi_1h'.
+        @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. 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.
+        # 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}', '{name}')
+        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
+
+    ```
+
+    See docstring of `@informative()` decorator for more information.
+
+!!! 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).
+
+!!! Warning
+    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)
 
diff --git a/freqtrade/edge/edge_positioning.py b/freqtrade/edge/edge_positioning.py
index f12b1b37d..1950f0d08 100644
--- a/freqtrade/edge/edge_positioning.py
+++ b/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)
diff --git a/freqtrade/freqtradebot.py b/freqtrade/freqtradebot.py
index 7f668273c..bdc438c9a 100644
--- a/freqtrade/freqtradebot.py
+++ b/freqtrade/freqtradebot.py
@@ -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)()
 
diff --git a/freqtrade/strategy/__init__.py b/freqtrade/strategy/__init__.py
index 703cdabc1..a7de34916 100644
--- a/freqtrade/strategy/__init__.py
+++ b/freqtrade/strategy/__init__.py
@@ -4,5 +4,5 @@ from freqtrade.exchange import (timeframe_to_minutes, timeframe_to_msecs, timefr
 from freqtrade.strategy.hyper import (BooleanParameter, CategoricalParameter, DecimalParameter,
                                       IntParameter, RealParameter)
 from freqtrade.strategy.interface import IStrategy
-from freqtrade.strategy.strategy_helper import (merge_informative_pair,
+from freqtrade.strategy.strategy_helper import (informative, merge_informative_pair,
                                                 stoploss_from_absolute, stoploss_from_open)
diff --git a/freqtrade/strategy/interface.py b/freqtrade/strategy/interface.py
index 00ad3faf0..8e8b8b404 100644
--- a/freqtrade/strategy/interface.py
+++ b/freqtrade/strategy/interface.py
@@ -6,7 +6,7 @@ import logging
 import warnings
 from abc import ABC, abstractmethod
 from datetime import datetime, timedelta, timezone
-from typing import Dict, List, Optional, Tuple, Union
+from typing import Any, Callable, Dict, List, Optional, Tuple, Union
 
 import arrow
 from pandas import DataFrame
@@ -19,6 +19,8 @@ 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_helper import (InformativeData, _create_and_merge_informative_pair,
+                                                _format_pair_name)
 from freqtrade.strategy.strategy_wrapper import strategy_safe_wrapper
 from freqtrade.wallets import Wallets
 
@@ -134,6 +136,39 @@ 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: Dict[
+            Tuple[str, str], Tuple[InformativeData,
+                                   Callable[[Any, DataFrame, dict], DataFrame]]] = {}
+        for attr_name in dir(self.__class__):
+            cls_method = getattr(self.__class__, attr_name)
+            if not callable(cls_method):
+                continue
+            ft_informative = getattr(cls_method, '_ft_informative', [])
+            if not isinstance(ft_informative, list):
+                # Type check is required because mocker would return a mock object that evaluates to
+                # True, confusing this code.
+                continue
+            for informative_data in ft_informative:
+                asset = informative_data.asset
+                timeframe = informative_data.timeframe
+                if asset:
+                    pair = _format_pair_name(self.config, asset)
+                    if (pair, timeframe) in self._ft_informative:
+                        raise OperationalException(f'Informative pair {pair} {timeframe} can not '
+                                                   f'be defined more than once!')
+                    self._ft_informative[(pair, timeframe)] = (informative_data, cls_method)
+                elif self.dp is not None:
+                    for pair in self.dp.current_whitelist():
+                        if (pair, timeframe) in self._ft_informative:
+                            raise OperationalException(f'Informative pair {pair} {timeframe} can '
+                                                       f'not be defined more than once!')
+                        self._ft_informative[(pair, timeframe)] = (informative_data, cls_method)
+
+    def _format_pair(self, pair: str) -> str:
+        return pair.format(stake_currency=self.config['stake_currency'],
+                           stake=self.config['stake_currency']).upper()
+
     @abstractmethod
     def populate_indicators(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
         """
@@ -377,6 +412,14 @@ 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()
+        informative_pairs += list(self._ft_informative.keys())
+        return list(set(informative_pairs))
+
     def get_strategy_name(self) -> str:
         """
         Returns strategy class name
@@ -793,6 +836,14 @@ 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 (pair, timeframe), (informative_data, populate_fn) in self._ft_informative.items():
+            if not informative_data.asset and pair != metadata['pair']:
+                continue
+            dataframe = _create_and_merge_informative_pair(
+                self, dataframe, metadata, informative_data, populate_fn)
+
         if self._populate_fun_len == 2:
             warnings.warn("deprecated - check out the Sample strategy to see "
                           "the current function headers!", DeprecationWarning)
diff --git a/freqtrade/strategy/strategy_helper.py b/freqtrade/strategy/strategy_helper.py
index 32f7a9886..aa828d330 100644
--- a/freqtrade/strategy/strategy_helper.py
+++ b/freqtrade/strategy/strategy_helper.py
@@ -1,10 +1,24 @@
-import pandas as pd
+from typing import Any, Callable, NamedTuple, Optional, Union
 
+import pandas as pd
+from mypy_extensions import KwArg
+from pandas import DataFrame
+
+from freqtrade.exceptions import OperationalException
 from freqtrade.exchange import timeframe_to_minutes
 
 
+class InformativeData(NamedTuple):
+    asset: Optional[str]
+    timeframe: str
+    fmt: Union[str, Callable[[KwArg(str)], str], None]
+    ffill: bool
+
+
 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 +38,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 +48,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
-    informative.columns = [f"{col}_{timeframe_inf}" for col in informative.columns]
+    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')
-    dataframe = dataframe.drop(f'date_merge_{timeframe_inf}', axis=1)
+                         right_on=date_merge, how='left')
+    dataframe = dataframe.drop(date_merge, axis=1)
 
     if ffill:
         dataframe = dataframe.ffill()
@@ -94,3 +114,117 @@ def stoploss_from_absolute(stop_rate: float, current_rate: float) -> float:
     :return: Positive stop loss value relative to current price
     """
     return 1 - (stop_rate / current_rate)
+
+
+def informative(timeframe: str, asset: str = '',
+                fmt: Optional[Union[str, Callable[[KwArg(str)], str]]] = None,
+                ffill: bool = True) -> Callable[[Callable[[Any, DataFrame, dict], DataFrame]],
+                                                Callable[[Any, DataFrame, dict], DataFrame]]:
+    """
+    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 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 {asset}_{name}_{timeframe} if asset is specified, or {name}_{timeframe}
+    otherwise.
+    * {asset}: name of informative asset, provided in lower-case, with / replaced with _. Stake
+    currency is not included in this string.
+    * {name}: user-specified dataframe column name.
+    * {timeframe}: informative timeframe.
+    :param ffill: ffill dataframe after mering informative pair.
+    """
+    _asset = asset
+    _timeframe = timeframe
+    _fmt = fmt
+    _ffill = ffill
+
+    def decorator(fn: Callable[[Any, DataFrame, dict], DataFrame]):
+        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, informative_data: InformativeData,
+                                       populate_indicators: Callable[[Any, DataFrame, dict],
+                                                                     DataFrame]):
+    asset = informative_data.asset or ''
+    timeframe = informative_data.timeframe
+    fmt = informative_data.fmt
+    ffill = informative_data.ffill
+    config = strategy.config
+    dp = strategy.dp
+
+    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, None
+        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 asset != metadata['pair']:
+            if quote == config['stake_currency']:
+                fmt = '{base}_' + fmt               # Informatives of other pair
+            else:
+                fmt = '{base}_{quote}_' + fmt       # Informatives of different quote currency
+
+    inf_metadata = {'pair': asset, 'timeframe': timeframe}
+    inf_dataframe = 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=ffill, append_timeframe=False,
+                                       date_column=date_column)
+    return dataframe
diff --git a/tests/rpc/test_rpc_apiserver.py b/tests/rpc/test_rpc_apiserver.py
index 2852486ed..43eb70938 100644
--- a/tests/rpc/test_rpc_apiserver.py
+++ b/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'
     ]}
diff --git a/tests/strategy/strats/informative_decorator_strategy.py b/tests/strategy/strats/informative_decorator_strategy.py
new file mode 100644
index 000000000..a32ad79e8
--- /dev/null
+++ b/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
diff --git a/tests/strategy/test_interface.py b/tests/strategy/test_interface.py
index 250dcf63d..dcb9e3e64 100644
--- a/tests/strategy/test_interface.py
+++ b/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', [
diff --git a/tests/strategy/test_strategy_helpers.py b/tests/strategy/test_strategy_helpers.py
index 3b84fc254..7784f3f77 100644
--- a/tests/strategy/test_strategy_helpers.py
+++ b/tests/strategy/test_strategy_helpers.py
@@ -4,6 +4,7 @@ import numpy as np
 import pandas as pd
 import pytest
 
+from freqtrade.data.dataprovider import DataProvider
 from freqtrade.strategy import merge_informative_pair, stoploss_from_open, timeframe_to_minutes
 
 
@@ -132,3 +133,57 @@ def test_stoploss_from_open():
                         assert stoploss == 0
                     else:
                         assert isclose(stop_price, expected_stop_price, rel_tol=0.00001)
+
+
+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'
+    InformativeDecoratorTest.dp = DataProvider({}, None, None)
+    mocker.patch.object(InformativeDecoratorTest.dp, 'current_whitelist', return_value=[
+        'XRP/USDT', 'LTC/USDT'
+    ])
+    strategy = InformativeDecoratorTest(config=default_conf)
+
+    assert len(strategy._ft_informative) == 8
+    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_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
diff --git a/tests/strategy/test_strategy_loading.py b/tests/strategy/test_strategy_loading.py
index 2cbc9d0c6..3a30a824a 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) == 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
 
 

From f2a1d9d2fc8efe238e47f5404dd6c924511e683b Mon Sep 17 00:00:00 2001
From: Rokas Kupstys <rokups@zoho.com>
Date: Sun, 5 Sep 2021 09:54:05 +0300
Subject: [PATCH 17/34] [SQUASH] Address PR comments.

---
 docs/strategy-customization.md        | 56 ++++++++++++++++++++-------
 freqtrade/strategy/interface.py       | 18 ++++-----
 freqtrade/strategy/strategy_helper.py | 32 +++++++++------
 3 files changed, 72 insertions(+), 34 deletions(-)

diff --git a/docs/strategy-customization.md b/docs/strategy-customization.md
index 526c111c5..f2bf6cf7c 100644
--- a/docs/strategy-customization.md
+++ b/docs/strategy-customization.md
@@ -681,9 +681,47 @@ In some situations it may be confusing to deal with stops relative to current ra
 
 ### *@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}_{column}_{timeframe} if asset is specified and quote currency does match stake
+    curerncy. 
+    * {base}_{quote}_{column}_{timeframe} if asset is specified and quote currency does not match 
+    stake curerncy. 
+    * {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, please follow instructions of [optimizing an indicator parameter](hyperopt.md#optimizing-an-indicator-parameter).
+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"
 
@@ -725,17 +763,9 @@ When hyperopting, please follow instructions of [optimizing an indicator paramet
             return dataframe
     
         # Define BTC/STAKE informative pair. A custom formatter may be specified for formatting
-        # column names. 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.
-        # 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}', '{name}')
+        # 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
@@ -749,8 +779,6 @@ When hyperopting, please follow instructions of [optimizing an indicator paramet
 
     ```
 
-    See docstring of `@informative()` decorator for more information.
-
 !!! 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).
diff --git a/freqtrade/strategy/interface.py b/freqtrade/strategy/interface.py
index 8e8b8b404..0546deb01 100644
--- a/freqtrade/strategy/interface.py
+++ b/freqtrade/strategy/interface.py
@@ -6,7 +6,7 @@ import logging
 import warnings
 from abc import ABC, abstractmethod
 from datetime import datetime, timedelta, timezone
-from typing import Any, Callable, Dict, List, Optional, Tuple, Union
+from typing import Dict, List, Optional, Tuple, Union
 
 import arrow
 from pandas import DataFrame
@@ -19,7 +19,8 @@ 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_helper import (InformativeData, _create_and_merge_informative_pair,
+from freqtrade.strategy.strategy_helper 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
@@ -138,20 +139,23 @@ class IStrategy(ABC, HyperStrategyMixin):
 
         # Gather informative pairs from @informative-decorated methods.
         self._ft_informative: Dict[
-            Tuple[str, str], Tuple[InformativeData,
-                                   Callable[[Any, DataFrame, dict], DataFrame]]] = {}
+            Tuple[str, str], Tuple[InformativeData, PopulateIndicators]] = {}
         for attr_name in dir(self.__class__):
             cls_method = getattr(self.__class__, attr_name)
             if not callable(cls_method):
                 continue
-            ft_informative = getattr(cls_method, '_ft_informative', [])
+            ft_informative = getattr(cls_method, '_ft_informative', None)
             if not isinstance(ft_informative, 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 ft_informative:
                 asset = informative_data.asset
                 timeframe = informative_data.timeframe
+                if timeframe_to_minutes(timeframe) < strategy_timeframe_minutes:
+                    raise OperationalException('Informative timeframe must be equal or higher than '
+                                               'strategy timeframe!')
                 if asset:
                     pair = _format_pair_name(self.config, asset)
                     if (pair, timeframe) in self._ft_informative:
@@ -165,10 +169,6 @@ class IStrategy(ABC, HyperStrategyMixin):
                                                        f'not be defined more than once!')
                         self._ft_informative[(pair, timeframe)] = (informative_data, cls_method)
 
-    def _format_pair(self, pair: str) -> str:
-        return pair.format(stake_currency=self.config['stake_currency'],
-                           stake=self.config['stake_currency']).upper()
-
     @abstractmethod
     def populate_indicators(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
         """
diff --git a/freqtrade/strategy/strategy_helper.py b/freqtrade/strategy/strategy_helper.py
index aa828d330..64d9bdea8 100644
--- a/freqtrade/strategy/strategy_helper.py
+++ b/freqtrade/strategy/strategy_helper.py
@@ -8,6 +8,9 @@ from freqtrade.exceptions import OperationalException
 from freqtrade.exchange import timeframe_to_minutes
 
 
+PopulateIndicators = Callable[[Any, DataFrame, dict], DataFrame]
+
+
 class InformativeData(NamedTuple):
     asset: Optional[str]
     timeframe: str
@@ -118,8 +121,7 @@ def stoploss_from_absolute(stop_rate: float, current_rate: float) -> float:
 
 def informative(timeframe: str, asset: str = '',
                 fmt: Optional[Union[str, Callable[[KwArg(str)], str]]] = None,
-                ffill: bool = True) -> Callable[[Callable[[Any, DataFrame, dict], DataFrame]],
-                                                Callable[[Any, DataFrame, dict], DataFrame]]:
+                ffill: bool = True) -> Callable[[PopulateIndicators], PopulateIndicators]:
     """
     A decorator for populate_indicators_Nn(self, dataframe, metadata), allowing these functions to
     define informative indicators.
@@ -131,24 +133,32 @@ def informative(timeframe: str, asset: str = '',
             dataframe['rsi'] = ta.RSI(dataframe, timeperiod=14)
             return dataframe
 
-    :param timeframe: Informative timeframe. Must always be higher than strategy timeframe.
+    :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 {asset}_{name}_{timeframe} if asset is specified, or {name}_{timeframe}
-    otherwise.
-    * {asset}: name of informative asset, provided in lower-case, with / replaced with _. Stake
-    currency is not included in this string.
-    * {name}: user-specified dataframe column name.
-    * {timeframe}: informative timeframe.
-    :param ffill: ffill dataframe after mering informative pair.
+    specified, defaults to:
+    * {base}_{column}_{timeframe} if asset is specified and quote currency does match stake
+    curerncy.
+    * {base}_{quote}_{column}_{timeframe} if asset is specified and quote currency does not match
+    stake curerncy.
+    * {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: Callable[[Any, DataFrame, dict], DataFrame]):
+    def decorator(fn: PopulateIndicators):
         informative_pairs = getattr(fn, '_ft_informative', [])
         informative_pairs.append(InformativeData(_asset, _timeframe, _fmt, _ffill))
         setattr(fn, '_ft_informative', informative_pairs)

From dfa61b7ad2297a94b0b26309ca74c64a7c1d08a7 Mon Sep 17 00:00:00 2001
From: Rokas Kupstys <rokups@zoho.com>
Date: Tue, 7 Sep 2021 15:40:53 +0300
Subject: [PATCH 18/34] [SQUASH] Fix informatives for each pair not being
 created because dataprovider was not available. Fix not being able to have
 informative dataframe of a pair in whitelist.

---
 docs/strategy-customization.md          |  4 +--
 freqtrade/freqtradebot.py               | 10 ++++---
 freqtrade/optimize/backtesting.py       |  3 +-
 freqtrade/optimize/edge_cli.py          |  3 ++
 freqtrade/strategy/interface.py         | 38 +++++++++++++++----------
 freqtrade/strategy/strategy_helper.py   | 13 ++++-----
 tests/strategy/test_strategy_helpers.py |  9 +++---
 7 files changed, 47 insertions(+), 33 deletions(-)

diff --git a/docs/strategy-customization.md b/docs/strategy-customization.md
index f2bf6cf7c..a994d9acd 100644
--- a/docs/strategy-customization.md
+++ b/docs/strategy-customization.md
@@ -702,9 +702,9 @@ def informative(timeframe: str, asset: str = '',
     :param fmt: Column format (str) or column formatter (callable(name, asset, timeframe)). When not
     specified, defaults to:
     * {base}_{column}_{timeframe} if asset is specified and quote currency does match stake
-    curerncy. 
+    currency. 
     * {base}_{quote}_{column}_{timeframe} if asset is specified and quote currency does not match 
-    stake curerncy. 
+    stake currency. 
     * {column}_{timeframe} if asset is not specified.
     Format string supports these format variables:
     * {asset} - full name of the asset, for example 'BTC/USDT'.
diff --git a/freqtrade/freqtradebot.py b/freqtrade/freqtradebot.py
index bdc438c9a..b79916639 100644
--- a/freqtrade/freqtradebot.py
+++ b/freqtrade/freqtradebot.py
@@ -83,10 +83,12 @@ class FreqtradeBot(LoggingMixin):
 
         self.dataprovider = DataProvider(self.config, self.exchange, self.pairlists)
 
-        # Attach Dataprovider to Strategy baseclass
-        IStrategy.dp = self.dataprovider
-        # Attach Wallets to Strategy baseclass
-        IStrategy.wallets = self.wallets
+        # Attach Dataprovider to strategy instance
+        self.strategy.dp = self.dataprovider
+        # Attach Wallets to strategy instance
+        self.strategy.wallets = self.wallets
+        # Late initialization (may depend on dp/wallets)
+        self.strategy._initialize()
 
         # Initializing Edge only if enabled
         self.edge = Edge(self.config, self.exchange, self.strategy) if \
diff --git a/freqtrade/optimize/backtesting.py b/freqtrade/optimize/backtesting.py
index 3e06bfa1b..ef491ae5e 100644
--- a/freqtrade/optimize/backtesting.py
+++ b/freqtrade/optimize/backtesting.py
@@ -154,11 +154,12 @@ 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
         self.strategy.order_types['stoploss_on_exchange'] = False
+        strategy._initialize()
 
     def _load_protections(self, strategy: IStrategy):
         if self.config.get('enable_protections', False):
diff --git a/freqtrade/optimize/edge_cli.py b/freqtrade/optimize/edge_cli.py
index 417faa685..abb5ca635 100644
--- a/freqtrade/optimize/edge_cli.py
+++ b/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,8 @@ 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)
+        self.strategy._initialize()
 
         validate_config_consistency(self.config)
 
diff --git a/freqtrade/strategy/interface.py b/freqtrade/strategy/interface.py
index 0546deb01..951979212 100644
--- a/freqtrade/strategy/interface.py
+++ b/freqtrade/strategy/interface.py
@@ -137,9 +137,13 @@ class IStrategy(ABC, HyperStrategyMixin):
         self._last_candle_seen_per_pair: Dict[str, datetime] = {}
         super().__init__(config)
 
+    def _initialize(self):
+        """
+        Late initialization tasks, which may depend on availability of dataprovider/wallets/etc.
+        """
         # Gather informative pairs from @informative-decorated methods.
         self._ft_informative: Dict[
-            Tuple[str, str], Tuple[InformativeData, PopulateIndicators]] = {}
+            Tuple[str, str], List[Tuple[InformativeData, PopulateIndicators]]] = {}
         for attr_name in dir(self.__class__):
             cls_method = getattr(self.__class__, attr_name)
             if not callable(cls_method):
@@ -158,16 +162,19 @@ class IStrategy(ABC, HyperStrategyMixin):
                                                'strategy timeframe!')
                 if asset:
                     pair = _format_pair_name(self.config, asset)
-                    if (pair, timeframe) in self._ft_informative:
-                        raise OperationalException(f'Informative pair {pair} {timeframe} can not '
-                                                   f'be defined more than once!')
-                    self._ft_informative[(pair, timeframe)] = (informative_data, cls_method)
-                elif self.dp is not None:
+                    try:
+                        self._ft_informative[(pair, timeframe)].append(
+                            (informative_data, cls_method))
+                    except KeyError:
+                        self._ft_informative[(pair, timeframe)] = [(informative_data, cls_method)]
+                else:
                     for pair in self.dp.current_whitelist():
-                        if (pair, timeframe) in self._ft_informative:
-                            raise OperationalException(f'Informative pair {pair} {timeframe} can '
-                                                       f'not be defined more than once!')
-                        self._ft_informative[(pair, timeframe)] = (informative_data, cls_method)
+                        try:
+                            self._ft_informative[(pair, timeframe)].append(
+                                (informative_data, cls_method))
+                        except KeyError:
+                            self._ft_informative[(pair, timeframe)] = \
+                                [(informative_data, cls_method)]
 
     @abstractmethod
     def populate_indicators(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
@@ -838,11 +845,12 @@ class IStrategy(ABC, HyperStrategyMixin):
         logger.debug(f"Populating indicators for pair {metadata.get('pair')}.")
 
         # call populate_indicators_Nm() which were tagged with @informative decorator.
-        for (pair, timeframe), (informative_data, populate_fn) in self._ft_informative.items():
-            if not informative_data.asset and pair != metadata['pair']:
-                continue
-            dataframe = _create_and_merge_informative_pair(
-                self, dataframe, metadata, informative_data, populate_fn)
+        for (pair, timeframe), informatives in self._ft_informative.items():
+            for (informative_data, populate_fn) in informatives:
+                if not informative_data.asset and pair != metadata['pair']:
+                    continue
+                dataframe = _create_and_merge_informative_pair(
+                    self, dataframe, metadata, informative_data, populate_fn)
 
         if self._populate_fun_len == 2:
             warnings.warn("deprecated - check out the Sample strategy to see "
diff --git a/freqtrade/strategy/strategy_helper.py b/freqtrade/strategy/strategy_helper.py
index 64d9bdea8..a4023f953 100644
--- a/freqtrade/strategy/strategy_helper.py
+++ b/freqtrade/strategy/strategy_helper.py
@@ -139,9 +139,9 @@ def informative(timeframe: str, asset: str = '',
     :param fmt: Column format (str) or column formatter (callable(name, asset, timeframe)). When not
     specified, defaults to:
     * {base}_{column}_{timeframe} if asset is specified and quote currency does match stake
-    curerncy.
+    currency.
     * {base}_{quote}_{column}_{timeframe} if asset is specified and quote currency does not match
-    stake curerncy.
+    stake currency.
     * {column}_{timeframe} if asset is not specified.
     Format string supports these format variables:
     * {asset} - full name of the asset, for example 'BTC/USDT'.
@@ -203,11 +203,10 @@ def _create_and_merge_informative_pair(strategy, dataframe: DataFrame,
     # fmt='{base}_{quote}_{column}_{timeframe}' format or similar.
     if not fmt:
         fmt = '{column}_{timeframe}'                # Informatives of current pair
-        if asset != metadata['pair']:
-            if quote == config['stake_currency']:
-                fmt = '{base}_' + fmt               # Informatives of other pair
-            else:
-                fmt = '{base}_{quote}_' + fmt       # Informatives of different quote currency
+        if quote != config['stake_currency']:
+            fmt = '{quote}_' + fmt                  # Informatives of different quote currency
+        if informative_data.asset:
+            fmt = '{base}_' + fmt                   # Informatives of other pair
 
     inf_metadata = {'pair': asset, 'timeframe': timeframe}
     inf_dataframe = dp.get_pair_dataframe(asset, timeframe)
diff --git a/tests/strategy/test_strategy_helpers.py b/tests/strategy/test_strategy_helpers.py
index 7784f3f77..0ee554ede 100644
--- a/tests/strategy/test_strategy_helpers.py
+++ b/tests/strategy/test_strategy_helpers.py
@@ -155,11 +155,12 @@ def test_informative_decorator(mocker, default_conf):
     }
     from .strats.informative_decorator_strategy import InformativeDecoratorTest
     default_conf['stake_currency'] = 'USDT'
-    InformativeDecoratorTest.dp = DataProvider({}, None, None)
-    mocker.patch.object(InformativeDecoratorTest.dp, 'current_whitelist', return_value=[
-        'XRP/USDT', 'LTC/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'
+    ])
+    strategy._initialize()
 
     assert len(strategy._ft_informative) == 8
     informative_pairs = [('XRP/USDT', '1h'), ('LTC/USDT', '1h'), ('XRP/USDT', '30m'),

From f81df19b934b738bf148f51fdb5a9c7ab1dfb34f Mon Sep 17 00:00:00 2001
From: Rokas Kupstys <rokups@zoho.com>
Date: Tue, 7 Sep 2021 15:53:12 +0300
Subject: [PATCH 19/34] [TMP] Make tests not fail for now.

---
 freqtrade/strategy/interface.py | 18 ++++++++++--------
 1 file changed, 10 insertions(+), 8 deletions(-)

diff --git a/freqtrade/strategy/interface.py b/freqtrade/strategy/interface.py
index 951979212..6e312e15d 100644
--- a/freqtrade/strategy/interface.py
+++ b/freqtrade/strategy/interface.py
@@ -424,7 +424,8 @@ class IStrategy(ABC, HyperStrategyMixin):
         Internal method which gathers all informative pairs (user or automatically defined).
         """
         informative_pairs = self.informative_pairs()
-        informative_pairs += list(self._ft_informative.keys())
+        if hasattr(self, '_ft_informative'):
+            informative_pairs += list(self._ft_informative.keys())
         return list(set(informative_pairs))
 
     def get_strategy_name(self) -> str:
@@ -844,13 +845,14 @@ class IStrategy(ABC, HyperStrategyMixin):
         """
         logger.debug(f"Populating indicators for pair {metadata.get('pair')}.")
 
-        # call populate_indicators_Nm() which were tagged with @informative decorator.
-        for (pair, timeframe), informatives in self._ft_informative.items():
-            for (informative_data, populate_fn) in informatives:
-                if not informative_data.asset and pair != metadata['pair']:
-                    continue
-                dataframe = _create_and_merge_informative_pair(
-                    self, dataframe, metadata, informative_data, populate_fn)
+        if hasattr(self, '_ft_informative'):
+            # call populate_indicators_Nm() which were tagged with @informative decorator.
+            for (pair, timeframe), informatives in self._ft_informative.items():
+                for (informative_data, populate_fn) in informatives:
+                    if not informative_data.asset and pair != metadata['pair']:
+                        continue
+                    dataframe = _create_and_merge_informative_pair(
+                        self, dataframe, metadata, informative_data, populate_fn)
 
         if self._populate_fun_len == 2:
             warnings.warn("deprecated - check out the Sample strategy to see "

From 5dc78a0c66f385edd14db16a806e1f75bd453e83 Mon Sep 17 00:00:00 2001
From: Rokas Kupstys <rokups@zoho.com>
Date: Fri, 10 Sep 2021 09:36:52 +0300
Subject: [PATCH 20/34] [SQUASH] Get rid of _initialize() and fix informatives
 for dynamic pairlists.

---
 freqtrade/freqtradebot.py               |  2 -
 freqtrade/optimize/backtesting.py       |  1 -
 freqtrade/optimize/edge_cli.py          |  1 -
 freqtrade/strategy/interface.py         | 56 ++++++++-----------------
 freqtrade/strategy/strategy_helper.py   | 17 ++++----
 tests/strategy/test_strategy_helpers.py |  3 +-
 6 files changed, 27 insertions(+), 53 deletions(-)

diff --git a/freqtrade/freqtradebot.py b/freqtrade/freqtradebot.py
index b79916639..1cb8988ff 100644
--- a/freqtrade/freqtradebot.py
+++ b/freqtrade/freqtradebot.py
@@ -87,8 +87,6 @@ class FreqtradeBot(LoggingMixin):
         self.strategy.dp = self.dataprovider
         # Attach Wallets to strategy instance
         self.strategy.wallets = self.wallets
-        # Late initialization (may depend on dp/wallets)
-        self.strategy._initialize()
 
         # Initializing Edge only if enabled
         self.edge = Edge(self.config, self.exchange, self.strategy) if \
diff --git a/freqtrade/optimize/backtesting.py b/freqtrade/optimize/backtesting.py
index ef491ae5e..79c861ee8 100644
--- a/freqtrade/optimize/backtesting.py
+++ b/freqtrade/optimize/backtesting.py
@@ -159,7 +159,6 @@ class Backtesting:
         # since a "perfect" stoploss-sell is assumed anyway
         # And the regular "stoploss" function would not apply to that case
         self.strategy.order_types['stoploss_on_exchange'] = False
-        strategy._initialize()
 
     def _load_protections(self, strategy: IStrategy):
         if self.config.get('enable_protections', False):
diff --git a/freqtrade/optimize/edge_cli.py b/freqtrade/optimize/edge_cli.py
index abb5ca635..f211da750 100644
--- a/freqtrade/optimize/edge_cli.py
+++ b/freqtrade/optimize/edge_cli.py
@@ -35,7 +35,6 @@ class EdgeCli:
         self.exchange = ExchangeResolver.load_exchange(self.config['exchange']['name'], self.config)
         self.strategy = StrategyResolver.load_strategy(self.config)
         self.strategy.dp = DataProvider(config, None)
-        self.strategy._initialize()
 
         validate_config_consistency(self.config)
 
diff --git a/freqtrade/strategy/interface.py b/freqtrade/strategy/interface.py
index 6e312e15d..00c56f5df 100644
--- a/freqtrade/strategy/interface.py
+++ b/freqtrade/strategy/interface.py
@@ -121,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: DataProvider
     wallets: Optional[Wallets] = None
     # Filled from configuration
     stake_currency: str
@@ -137,44 +137,23 @@ class IStrategy(ABC, HyperStrategyMixin):
         self._last_candle_seen_per_pair: Dict[str, datetime] = {}
         super().__init__(config)
 
-    def _initialize(self):
-        """
-        Late initialization tasks, which may depend on availability of dataprovider/wallets/etc.
-        """
         # Gather informative pairs from @informative-decorated methods.
-        self._ft_informative: Dict[
-            Tuple[str, str], List[Tuple[InformativeData, PopulateIndicators]]] = {}
+        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
-            ft_informative = getattr(cls_method, '_ft_informative', None)
-            if not isinstance(ft_informative, list):
+            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 ft_informative:
-                asset = informative_data.asset
-                timeframe = informative_data.timeframe
-                if timeframe_to_minutes(timeframe) < strategy_timeframe_minutes:
+            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!')
-                if asset:
-                    pair = _format_pair_name(self.config, asset)
-                    try:
-                        self._ft_informative[(pair, timeframe)].append(
-                            (informative_data, cls_method))
-                    except KeyError:
-                        self._ft_informative[(pair, timeframe)] = [(informative_data, cls_method)]
-                else:
-                    for pair in self.dp.current_whitelist():
-                        try:
-                            self._ft_informative[(pair, timeframe)].append(
-                                (informative_data, cls_method))
-                        except KeyError:
-                            self._ft_informative[(pair, timeframe)] = \
-                                [(informative_data, cls_method)]
+                self._ft_informative.append((informative_data, cls_method))
 
     @abstractmethod
     def populate_indicators(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
@@ -424,8 +403,13 @@ class IStrategy(ABC, HyperStrategyMixin):
         Internal method which gathers all informative pairs (user or automatically defined).
         """
         informative_pairs = self.informative_pairs()
-        if hasattr(self, '_ft_informative'):
-            informative_pairs += list(self._ft_informative.keys())
+        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:
+                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:
@@ -845,14 +829,10 @@ class IStrategy(ABC, HyperStrategyMixin):
         """
         logger.debug(f"Populating indicators for pair {metadata.get('pair')}.")
 
-        if hasattr(self, '_ft_informative'):
-            # call populate_indicators_Nm() which were tagged with @informative decorator.
-            for (pair, timeframe), informatives in self._ft_informative.items():
-                for (informative_data, populate_fn) in informatives:
-                    if not informative_data.asset and pair != metadata['pair']:
-                        continue
-                    dataframe = _create_and_merge_informative_pair(
-                        self, dataframe, metadata, informative_data, populate_fn)
+        # 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 "
diff --git a/freqtrade/strategy/strategy_helper.py b/freqtrade/strategy/strategy_helper.py
index a4023f953..15c6d8a69 100644
--- a/freqtrade/strategy/strategy_helper.py
+++ b/freqtrade/strategy/strategy_helper.py
@@ -171,14 +171,13 @@ def _format_pair_name(config, pair: str) -> str:
                        stake=config['stake_currency']).upper()
 
 
-def _create_and_merge_informative_pair(strategy, dataframe: DataFrame,
-                                       metadata: dict, informative_data: InformativeData,
-                                       populate_indicators: Callable[[Any, DataFrame, dict],
-                                                                     DataFrame]):
-    asset = informative_data.asset or ''
-    timeframe = informative_data.timeframe
-    fmt = informative_data.fmt
-    ffill = informative_data.ffill
+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
+    ffill = inf_data.ffill
     config = strategy.config
     dp = strategy.dp
 
@@ -205,7 +204,7 @@ def _create_and_merge_informative_pair(strategy, dataframe: DataFrame,
         fmt = '{column}_{timeframe}'                # Informatives of current pair
         if quote != config['stake_currency']:
             fmt = '{quote}_' + fmt                  # Informatives of different quote currency
-        if informative_data.asset:
+        if inf_data.asset:
             fmt = '{base}_' + fmt                   # Informatives of other pair
 
     inf_metadata = {'pair': asset, 'timeframe': timeframe}
diff --git a/tests/strategy/test_strategy_helpers.py b/tests/strategy/test_strategy_helpers.py
index 0ee554ede..95ca0416f 100644
--- a/tests/strategy/test_strategy_helpers.py
+++ b/tests/strategy/test_strategy_helpers.py
@@ -160,9 +160,8 @@ def test_informative_decorator(mocker, default_conf):
     mocker.patch.object(strategy.dp, 'current_whitelist', return_value=[
         'XRP/USDT', 'LTC/USDT', 'BTC/USDT'
     ])
-    strategy._initialize()
 
-    assert len(strategy._ft_informative) == 8
+    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')]

From bb6ae682fc7d82175196741e31723c5f797ffd2f Mon Sep 17 00:00:00 2001
From: Matthias <xmatthias@outlook.com>
Date: Sun, 12 Sep 2021 09:59:10 +0200
Subject: [PATCH 21/34] Small simplifications

---
 docs/strategy-customization.md        | 2 +-
 freqtrade/strategy/strategy_helper.py | 6 ++----
 2 files changed, 3 insertions(+), 5 deletions(-)

diff --git a/docs/strategy-customization.md b/docs/strategy-customization.md
index a994d9acd..800dd9326 100644
--- a/docs/strategy-customization.md
+++ b/docs/strategy-customization.md
@@ -783,7 +783,7 @@ for more information.
     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).
 
-!!! Warning
+!!! 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!
diff --git a/freqtrade/strategy/strategy_helper.py b/freqtrade/strategy/strategy_helper.py
index 15c6d8a69..746d656df 100644
--- a/freqtrade/strategy/strategy_helper.py
+++ b/freqtrade/strategy/strategy_helper.py
@@ -177,9 +177,7 @@ def _create_and_merge_informative_pair(strategy, dataframe: DataFrame, metadata:
     asset = inf_data.asset or ''
     timeframe = inf_data.timeframe
     fmt = inf_data.fmt
-    ffill = inf_data.ffill
     config = strategy.config
-    dp = strategy.dp
 
     if asset:
         # Insert stake currency if needed.
@@ -208,7 +206,7 @@ def _create_and_merge_informative_pair(strategy, dataframe: DataFrame, metadata:
             fmt = '{base}_' + fmt                   # Informatives of other pair
 
     inf_metadata = {'pair': asset, 'timeframe': timeframe}
-    inf_dataframe = dp.get_pair_dataframe(asset, timeframe)
+    inf_dataframe = strategy.dp.get_pair_dataframe(asset, timeframe)
     inf_dataframe = populate_indicators(strategy, inf_dataframe, inf_metadata)
 
     formatter: Any = None
@@ -233,6 +231,6 @@ def _create_and_merge_informative_pair(strategy, dataframe: DataFrame, metadata:
         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=ffill, append_timeframe=False,
+                                       ffill=inf_data.ffill, append_timeframe=False,
                                        date_column=date_column)
     return dataframe

From e88c4701bb2c321ed7cd5d6fed7fa6db6f4f41f6 Mon Sep 17 00:00:00 2001
From: Rokas Kupstys <rokups@zoho.com>
Date: Sun, 12 Sep 2021 18:26:41 +0300
Subject: [PATCH 22/34] [SQUASH] Address PR comments.

---
 docs/strategy-customization.md              |  19 ++-
 freqtrade/strategy/__init__.py              |   5 +-
 freqtrade/strategy/informative_decorator.py | 134 ++++++++++++++++++++
 freqtrade/strategy/interface.py             |  11 +-
 freqtrade/strategy/strategy_helper.py       | 132 -------------------
 5 files changed, 152 insertions(+), 149 deletions(-)
 create mode 100644 freqtrade/strategy/informative_decorator.py

diff --git a/docs/strategy-customization.md b/docs/strategy-customization.md
index 800dd9326..671768bfa 100644
--- a/docs/strategy-customization.md
+++ b/docs/strategy-customization.md
@@ -652,9 +652,7 @@ In some situations it may be confusing to deal with stops relative to current ra
 
 ??? Example "Returning a stoploss using absolute price from the custom stoploss function"
 
-    Say the open price was $100, and `current_price` is $121 (`current_profit` will be `0.21`).
-
-    If we want a stop price at $107 price we can call `stoploss_from_absolute(107, current_rate)` which will return `0.1157024793`.  11.57% below $121 is $107, which is the same as 7% above $100.
+    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
 
@@ -664,18 +662,17 @@ In some situations it may be confusing to deal with stops relative to current ra
 
     class AwesomeStrategy(IStrategy):
 
-        # ... populate_* methods
-
         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:
-
-            # once the profit has risen above 10%, keep the stoploss at 7% above the open price
-            if current_profit > 0.10:
-                return stoploss_from_absolute(trade.open_rate * 1.07, current_rate)
-
-            return 1
+            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)
 
     ```
 
diff --git a/freqtrade/strategy/__init__.py b/freqtrade/strategy/__init__.py
index a7de34916..2ea0ad2b4 100644
--- a/freqtrade/strategy/__init__.py
+++ b/freqtrade/strategy/__init__.py
@@ -3,6 +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 (informative, merge_informative_pair,
-                                                stoploss_from_absolute, stoploss_from_open)
+from freqtrade.strategy.strategy_helper import (merge_informative_pair, stoploss_from_absolute,
+                                                stoploss_from_open)
diff --git a/freqtrade/strategy/informative_decorator.py b/freqtrade/strategy/informative_decorator.py
new file mode 100644
index 000000000..f09e634b0
--- /dev/null
+++ b/freqtrade/strategy/informative_decorator.py
@@ -0,0 +1,134 @@
+from typing import Any, Callable, NamedTuple, Optional, Union
+
+from mypy_extensions import KwArg
+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[[KwArg(str)], str], None]
+    ffill: bool
+
+
+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}_{column}_{timeframe} if asset is specified and quote currency does match stake
+    currency.
+    * {base}_{quote}_{column}_{timeframe} if asset is specified and quote currency does not match
+    stake currency.
+    * {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, None
+        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 quote != config['stake_currency']:
+            fmt = '{quote}_' + fmt                  # Informatives of different quote currency
+        if inf_data.asset:
+            fmt = '{base}_' + fmt                   # Informatives of other pair
+
+    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
diff --git a/freqtrade/strategy/interface.py b/freqtrade/strategy/interface.py
index 00c56f5df..7420bd9fd 100644
--- a/freqtrade/strategy/interface.py
+++ b/freqtrade/strategy/interface.py
@@ -19,9 +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.strategy_helper import (InformativeData, PopulateIndicators,
-                                                _create_and_merge_informative_pair,
-                                                _format_pair_name)
+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
 
@@ -121,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: DataProvider
+    dp: Optional[DataProvider]
     wallets: Optional[Wallets] = None
     # Filled from configuration
     stake_currency: str
@@ -408,6 +408,9 @@ class IStrategy(ABC, HyperStrategyMixin):
                 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))
diff --git a/freqtrade/strategy/strategy_helper.py b/freqtrade/strategy/strategy_helper.py
index 746d656df..f813b39c5 100644
--- a/freqtrade/strategy/strategy_helper.py
+++ b/freqtrade/strategy/strategy_helper.py
@@ -1,23 +1,8 @@
-from typing import Any, Callable, NamedTuple, Optional, Union
-
 import pandas as pd
-from mypy_extensions import KwArg
-from pandas import DataFrame
 
-from freqtrade.exceptions import OperationalException
 from freqtrade.exchange import timeframe_to_minutes
 
 
-PopulateIndicators = Callable[[Any, DataFrame, dict], DataFrame]
-
-
-class InformativeData(NamedTuple):
-    asset: Optional[str]
-    timeframe: str
-    fmt: Union[str, Callable[[KwArg(str)], str], None]
-    ffill: bool
-
-
 def merge_informative_pair(dataframe: pd.DataFrame, informative: pd.DataFrame,
                            timeframe: str, timeframe_inf: str, ffill: bool = True,
                            append_timeframe: bool = True,
@@ -117,120 +102,3 @@ def stoploss_from_absolute(stop_rate: float, current_rate: float) -> float:
     :return: Positive stop loss value relative to current price
     """
     return 1 - (stop_rate / current_rate)
-
-
-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}_{column}_{timeframe} if asset is specified and quote currency does match stake
-    currency.
-    * {base}_{quote}_{column}_{timeframe} if asset is specified and quote currency does not match
-    stake currency.
-    * {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, None
-        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 quote != config['stake_currency']:
-            fmt = '{quote}_' + fmt                  # Informatives of different quote currency
-        if inf_data.asset:
-            fmt = '{base}_' + fmt                   # Informatives of other pair
-
-    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

From 7e6aa9390ae9c970f8b22afb591161492f833807 Mon Sep 17 00:00:00 2001
From: Rokas Kupstys <rokups@zoho.com>
Date: Sat, 18 Sep 2021 10:17:50 +0300
Subject: [PATCH 23/34] [SQUASH] Unconditionally include quote currency when
 asset is explicitly specified. Added docs suggesting to use string formatting
 to make strategy independent of configured stake currency.

---
 docs/strategy-customization.md              | 26 +++++++++++++++++----
 freqtrade/strategy/informative_decorator.py | 11 +++------
 tests/strategy/test_strategy_helpers.py     |  2 +-
 3 files changed, 25 insertions(+), 14 deletions(-)

diff --git a/docs/strategy-customization.md b/docs/strategy-customization.md
index 671768bfa..2b22dd274 100644
--- a/docs/strategy-customization.md
+++ b/docs/strategy-customization.md
@@ -698,10 +698,7 @@ def informative(timeframe: str, asset: str = '',
     current pair.
     :param fmt: Column format (str) or column formatter (callable(name, asset, timeframe)). When not
     specified, defaults to:
-    * {base}_{column}_{timeframe} if asset is specified and quote currency does match stake
-    currency. 
-    * {base}_{quote}_{column}_{timeframe} if asset is specified and quote currency does not match 
-    stake currency. 
+    * {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'.
@@ -746,7 +743,7 @@ for more information.
         # 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_rsi_1h'.
+        # 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)
@@ -780,6 +777,25 @@ for more information.
     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
diff --git a/freqtrade/strategy/informative_decorator.py b/freqtrade/strategy/informative_decorator.py
index f09e634b0..c8ebf5989 100644
--- a/freqtrade/strategy/informative_decorator.py
+++ b/freqtrade/strategy/informative_decorator.py
@@ -36,10 +36,7 @@ def informative(timeframe: str, asset: str = '',
     current pair.
     :param fmt: Column format (str) or column formatter (callable(name, asset, timeframe)). When not
     specified, defaults to:
-    * {base}_{column}_{timeframe} if asset is specified and quote currency does match stake
-    currency.
-    * {base}_{quote}_{column}_{timeframe} if asset is specified and quote currency does not match
-    stake currency.
+    * {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'.
@@ -88,7 +85,7 @@ def _create_and_merge_informative_pair(strategy, dataframe: DataFrame, metadata:
         base, quote = asset.split('/')
     else:
         # When futures are supported this may need reevaluation.
-        # base, quote = asset, None
+        # base, quote = asset, ''
         raise OperationalException('Not implemented.')
 
     # Default format. This optimizes for the common case: informative pairs using same stake
@@ -98,10 +95,8 @@ def _create_and_merge_informative_pair(strategy, dataframe: DataFrame, metadata:
     # fmt='{base}_{quote}_{column}_{timeframe}' format or similar.
     if not fmt:
         fmt = '{column}_{timeframe}'                # Informatives of current pair
-        if quote != config['stake_currency']:
-            fmt = '{quote}_' + fmt                  # Informatives of different quote currency
         if inf_data.asset:
-            fmt = '{base}_' + fmt                   # Informatives of other pair
+            fmt = '{base}_{quote}_' + fmt           # Informatives of other pairs
 
     inf_metadata = {'pair': asset, 'timeframe': timeframe}
     inf_dataframe = strategy.dp.get_pair_dataframe(asset, timeframe)
diff --git a/tests/strategy/test_strategy_helpers.py b/tests/strategy/test_strategy_helpers.py
index 95ca0416f..d4206ba8c 100644
--- a/tests/strategy/test_strategy_helpers.py
+++ b/tests/strategy/test_strategy_helpers.py
@@ -177,7 +177,7 @@ def test_informative_decorator(mocker, default_conf):
         {p: data[(p, strategy.timeframe)] for p in ('XRP/USDT', 'LTC/USDT')})
     expected_columns = [
         'rsi_1h', 'rsi_30m',                    # Stacked informative decorators
-        'btc_rsi_1h',                           # BTC 1h informative
+        '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

From e4ca42faec580a3c336298d42402fec0d8e56f93 Mon Sep 17 00:00:00 2001
From: Rokas Kupstys <rokups@zoho.com>
Date: Sat, 18 Sep 2021 10:18:33 +0300
Subject: [PATCH 24/34] [SQUASH] Update stoploss_from_absolute to behave more
 like stoploss_from_open and add a test for it.

---
 freqtrade/strategy/strategy_helper.py   | 16 +++++++++++++++-
 tests/strategy/test_strategy_helpers.py | 11 ++++++++++-
 2 files changed, 25 insertions(+), 2 deletions(-)

diff --git a/freqtrade/strategy/strategy_helper.py b/freqtrade/strategy/strategy_helper.py
index f813b39c5..175bcaccb 100644
--- a/freqtrade/strategy/strategy_helper.py
+++ b/freqtrade/strategy/strategy_helper.py
@@ -97,8 +97,22 @@ 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
     """
-    return 1 - (stop_rate / current_rate)
+
+    # 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)
diff --git a/tests/strategy/test_strategy_helpers.py b/tests/strategy/test_strategy_helpers.py
index d4206ba8c..9132382fa 100644
--- a/tests/strategy/test_strategy_helpers.py
+++ b/tests/strategy/test_strategy_helpers.py
@@ -5,7 +5,8 @@ import pandas as pd
 import pytest
 
 from freqtrade.data.dataprovider import DataProvider
-from freqtrade.strategy import merge_informative_pair, stoploss_from_open, timeframe_to_minutes
+from freqtrade.strategy import (merge_informative_pair, stoploss_from_open, timeframe_to_minutes,
+                                stoploss_from_absolute)
 
 
 def generate_test_data(timeframe: str, size: int):
@@ -135,6 +136,14 @@ def test_stoploss_from_open():
                         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)

From 216f75bbb91b8d72790f386dfc8b05340ade3c3d Mon Sep 17 00:00:00 2001
From: Sam Germain <sam.germain@usask.ca>
Date: Sat, 18 Sep 2021 02:53:34 -0600
Subject: [PATCH 25/34] parametrized test_sell_profit_only ,
 test__safe_exit_amount, test_order_book_bid_strategy1

---
 tests/test_freqtradebot.py | 244 ++++++++++---------------------------
 1 file changed, 65 insertions(+), 179 deletions(-)

diff --git a/tests/test_freqtradebot.py b/tests/test_freqtradebot.py
index eb3c77cc7..5268d40ec 100644
--- a/tests/test_freqtradebot.py
+++ b/tests/test_freqtradebot.py
@@ -3128,16 +3128,28 @@ def test_execute_trade_exit_insufficient_funds_error(default_conf, ticker, fee,
     assert mock_insuf.call_count == 1
 
 
-def test_sell_profit_only_enable_profit(default_conf, limit_buy_order, limit_buy_order_open,
-                                        fee, mocker) -> None:
+@pytest.mark.parametrize('profit_only,bid,ask,handle_first,handle_second,sell_type', [
+    # Enable profit
+    (True, 0.00001172, 0.00001173, False, True, SellType.SELL_SIGNAL.value),
+    # Disable profit
+    (False, 0.00002172, 0.00002173, True,  False, SellType.SELL_SIGNAL.value),
+    # Enable loss
+    # * Shouldn't this be SellType.STOP_LOSS.value
+    (True, 0.00000172, 0.00000173, False, False, None),
+    # Disable loss
+    (False, 0.00000172, 0.00000173, True, False, SellType.SELL_SIGNAL.value),
+])
+def test_sell_profit_only_enable_profit(
+        default_conf, limit_buy_order, limit_buy_order_open,
+        fee, mocker, profit_only, bid, ask, handle_first, handle_second, sell_type) -> None:
     patch_RPCManager(mocker)
     patch_exchange(mocker)
     mocker.patch.multiple(
         'freqtrade.exchange.Exchange',
         fetch_ticker=MagicMock(return_value={
-            'bid': 0.00001172,
-            'ask': 0.00001173,
-            'last': 0.00001172
+            'bid': bid,
+            'ask': ask,
+            'last': bid
         }),
         create_order=MagicMock(side_effect=[
             limit_buy_order_open,
@@ -3147,128 +3159,29 @@ def test_sell_profit_only_enable_profit(default_conf, limit_buy_order, limit_buy
     )
     default_conf.update({
         'use_sell_signal': True,
-        'sell_profit_only': True,
+        'sell_profit_only': profit_only,
         'sell_profit_offset': 0.1,
     })
     freqtrade = FreqtradeBot(default_conf)
     patch_get_signal(freqtrade)
-    freqtrade.strategy.min_roi_reached = MagicMock(return_value=False)
-
+    if sell_type == SellType.SELL_SIGNAL.value:
+        freqtrade.strategy.min_roi_reached = MagicMock(return_value=False)
+    else:
+        freqtrade.strategy.stop_loss_reached = MagicMock(return_value=SellCheckTuple(
+            sell_type=SellType.NONE))
     freqtrade.enter_positions()
 
     trade = Trade.query.first()
     trade.update(limit_buy_order)
     freqtrade.wallets.update()
     patch_get_signal(freqtrade, value=(False, True, None))
-    assert freqtrade.handle_trade(trade) is False
+    assert freqtrade.handle_trade(trade) is handle_first
 
-    freqtrade.strategy.sell_profit_offset = 0.0
-    assert freqtrade.handle_trade(trade) is True
+    if handle_second:
+        freqtrade.strategy.sell_profit_offset = 0.0
+        assert freqtrade.handle_trade(trade) is True
 
-    assert trade.sell_reason == SellType.SELL_SIGNAL.value
-
-
-def test_sell_profit_only_disable_profit(default_conf, limit_buy_order, limit_buy_order_open,
-                                         fee, mocker) -> None:
-    patch_RPCManager(mocker)
-    patch_exchange(mocker)
-    mocker.patch.multiple(
-        'freqtrade.exchange.Exchange',
-        fetch_ticker=MagicMock(return_value={
-            'bid': 0.00002172,
-            'ask': 0.00002173,
-            'last': 0.00002172
-        }),
-        create_order=MagicMock(side_effect=[
-            limit_buy_order_open,
-            {'id': 1234553382},
-        ]),
-        get_fee=fee,
-    )
-    default_conf.update({
-        'use_sell_signal': True,
-        'sell_profit_only': False,
-    })
-    freqtrade = FreqtradeBot(default_conf)
-    patch_get_signal(freqtrade)
-    freqtrade.strategy.min_roi_reached = MagicMock(return_value=False)
-    freqtrade.enter_positions()
-
-    trade = Trade.query.first()
-    trade.update(limit_buy_order)
-    freqtrade.wallets.update()
-    patch_get_signal(freqtrade, value=(False, True, None))
-    assert freqtrade.handle_trade(trade) is True
-    assert trade.sell_reason == SellType.SELL_SIGNAL.value
-
-
-def test_sell_profit_only_enable_loss(default_conf, limit_buy_order, limit_buy_order_open,
-                                      fee, mocker) -> None:
-    patch_RPCManager(mocker)
-    patch_exchange(mocker)
-    mocker.patch.multiple(
-        'freqtrade.exchange.Exchange',
-        fetch_ticker=MagicMock(return_value={
-            'bid': 0.00000172,
-            'ask': 0.00000173,
-            'last': 0.00000172
-        }),
-        create_order=MagicMock(side_effect=[
-            limit_buy_order_open,
-            {'id': 1234553382},
-        ]),
-        get_fee=fee,
-    )
-    default_conf.update({
-        'use_sell_signal': True,
-        'sell_profit_only': True,
-    })
-    freqtrade = FreqtradeBot(default_conf)
-    patch_get_signal(freqtrade)
-    freqtrade.strategy.stop_loss_reached = MagicMock(return_value=SellCheckTuple(
-        sell_type=SellType.NONE))
-    freqtrade.enter_positions()
-
-    trade = Trade.query.first()
-    trade.update(limit_buy_order)
-    patch_get_signal(freqtrade, value=(False, True, None))
-    assert freqtrade.handle_trade(trade) is False
-
-
-def test_sell_profit_only_disable_loss(default_conf, limit_buy_order, limit_buy_order_open,
-                                       fee, mocker) -> None:
-    patch_RPCManager(mocker)
-    patch_exchange(mocker)
-    mocker.patch.multiple(
-        'freqtrade.exchange.Exchange',
-        fetch_ticker=MagicMock(return_value={
-            'bid': 0.0000172,
-            'ask': 0.0000173,
-            'last': 0.0000172
-        }),
-        create_order=MagicMock(side_effect=[
-            limit_buy_order_open,
-            {'id': 1234553382},
-        ]),
-        get_fee=fee,
-    )
-    default_conf.update({
-        'use_sell_signal': True,
-        'sell_profit_only': False,
-    })
-
-    freqtrade = FreqtradeBot(default_conf)
-    patch_get_signal(freqtrade)
-    freqtrade.strategy.min_roi_reached = MagicMock(return_value=False)
-
-    freqtrade.enter_positions()
-
-    trade = Trade.query.first()
-    trade.update(limit_buy_order)
-    freqtrade.wallets.update()
-    patch_get_signal(freqtrade, value=(False, True, None))
-    assert freqtrade.handle_trade(trade) is True
-    assert trade.sell_reason == SellType.SELL_SIGNAL.value
+    assert trade.sell_reason == sell_type
 
 
 def test_sell_not_enough_balance(default_conf, limit_buy_order, limit_buy_order_open,
@@ -3306,11 +3219,15 @@ def test_sell_not_enough_balance(default_conf, limit_buy_order, limit_buy_order_
     assert trade.amount != amnt
 
 
-def test__safe_exit_amount(default_conf, fee, caplog, mocker):
+@pytest.mark.parametrize('amount_wallet,has_err', [
+    (95.29, False),
+    (91.29, True)
+])
+def test__safe_exit_amount(default_conf, fee, caplog, mocker, amount_wallet, has_err):
     patch_RPCManager(mocker)
     patch_exchange(mocker)
     amount = 95.33
-    amount_wallet = 95.29
+    amount_wallet = amount_wallet
     mocker.patch('freqtrade.wallets.Wallets.get_free', MagicMock(return_value=amount_wallet))
     wallet_update = mocker.patch('freqtrade.wallets.Wallets.update')
     trade = Trade(
@@ -3324,37 +3241,19 @@ def test__safe_exit_amount(default_conf, fee, caplog, mocker):
     )
     freqtrade = FreqtradeBot(default_conf)
     patch_get_signal(freqtrade)
-
-    wallet_update.reset_mock()
-    assert freqtrade._safe_exit_amount(trade.pair, trade.amount) == amount_wallet
-    assert log_has_re(r'.*Falling back to wallet-amount.', caplog)
-    assert wallet_update.call_count == 1
-    caplog.clear()
-    wallet_update.reset_mock()
-    assert freqtrade._safe_exit_amount(trade.pair, amount_wallet) == amount_wallet
-    assert not log_has_re(r'.*Falling back to wallet-amount.', caplog)
-    assert wallet_update.call_count == 1
-
-
-def test__safe_exit_amount_error(default_conf, fee, caplog, mocker):
-    patch_RPCManager(mocker)
-    patch_exchange(mocker)
-    amount = 95.33
-    amount_wallet = 91.29
-    mocker.patch('freqtrade.wallets.Wallets.get_free', MagicMock(return_value=amount_wallet))
-    trade = Trade(
-        pair='LTC/ETH',
-        amount=amount,
-        exchange='binance',
-        open_rate=0.245441,
-        open_order_id="123456",
-        fee_open=fee.return_value,
-        fee_close=fee.return_value,
-    )
-    freqtrade = FreqtradeBot(default_conf)
-    patch_get_signal(freqtrade)
-    with pytest.raises(DependencyException, match=r"Not enough amount to sell."):
-        assert freqtrade._safe_exit_amount(trade.pair, trade.amount)
+    if has_err:
+        with pytest.raises(DependencyException, match=r"Not enough amount to sell."):
+            assert freqtrade._safe_exit_amount(trade.pair, trade.amount)
+    else:
+        wallet_update.reset_mock()
+        assert freqtrade._safe_exit_amount(trade.pair, trade.amount) == amount_wallet
+        assert log_has_re(r'.*Falling back to wallet-amount.', caplog)
+        assert wallet_update.call_count == 1
+        caplog.clear()
+        wallet_update.reset_mock()
+        assert freqtrade._safe_exit_amount(trade.pair, amount_wallet) == amount_wallet
+        assert not log_has_re(r'.*Falling back to wallet-amount.', caplog)
+        assert wallet_update.call_count == 1
 
 
 def test_locked_pairs(default_conf, ticker, fee, ticker_sell_down, mocker, caplog) -> None:
@@ -4131,50 +4030,37 @@ def test_order_book_depth_of_market_high_delta(default_conf, ticker, limit_buy_o
     assert trade is None
 
 
-def test_order_book_bid_strategy1(mocker, default_conf, order_book_l2) -> None:
+@pytest.mark.parametrize('exception_thrown,ask,last,order_book_top,order_book', [
+    (False, 0.045, 0.046, 2, None),
+    (True,  0.042, 0.046, 1, {'bids': [[]], 'asks': [[]]})
+])
+def test_order_book_bid_strategy1(mocker, default_conf, order_book_l2, exception_thrown,
+                                  ask, last, order_book_top, order_book, caplog) -> None:
     """
-    test if function get_rate will return the order book price
-    instead of the ask rate
+    test if function get_rate will return the order book price instead of the ask rate
     """
     patch_exchange(mocker)
-    ticker_mock = MagicMock(return_value={'ask': 0.045, 'last': 0.046})
+    ticker_mock = MagicMock(return_value={'ask': ask, 'last': last})
     mocker.patch.multiple(
         'freqtrade.exchange.Exchange',
-        fetch_l2_order_book=order_book_l2,
+        fetch_l2_order_book=MagicMock(return_value=order_book) if order_book else order_book_l2,
         fetch_ticker=ticker_mock,
-
     )
     default_conf['exchange']['name'] = 'binance'
     default_conf['bid_strategy']['use_order_book'] = True
-    default_conf['bid_strategy']['order_book_top'] = 2
+    default_conf['bid_strategy']['order_book_top'] = order_book_top
     default_conf['bid_strategy']['ask_last_balance'] = 0
     default_conf['telegram']['enabled'] = False
 
     freqtrade = FreqtradeBot(default_conf)
-    assert freqtrade.exchange.get_rate('ETH/BTC', refresh=True, side="buy") == 0.043935
-    assert ticker_mock.call_count == 0
-
-
-def test_order_book_bid_strategy_exception(mocker, default_conf, caplog) -> None:
-    patch_exchange(mocker)
-    ticker_mock = MagicMock(return_value={'ask': 0.042, 'last': 0.046})
-    mocker.patch.multiple(
-        'freqtrade.exchange.Exchange',
-        fetch_l2_order_book=MagicMock(return_value={'bids': [[]], 'asks': [[]]}),
-        fetch_ticker=ticker_mock,
-
-    )
-    default_conf['exchange']['name'] = 'binance'
-    default_conf['bid_strategy']['use_order_book'] = True
-    default_conf['bid_strategy']['order_book_top'] = 1
-    default_conf['bid_strategy']['ask_last_balance'] = 0
-    default_conf['telegram']['enabled'] = False
-
-    freqtrade = FreqtradeBot(default_conf)
-    # orderbook shall be used even if tickers would be lower.
-    with pytest.raises(PricingError):
-        freqtrade.exchange.get_rate('ETH/BTC', refresh=True, side="buy")
-    assert log_has_re(r'Buy Price at location 1 from orderbook could not be determined.', caplog)
+    if exception_thrown:
+        with pytest.raises(PricingError):
+            freqtrade.exchange.get_rate('ETH/BTC', refresh=True, side="buy")
+        assert log_has_re(
+            r'Buy Price at location 1 from orderbook could not be determined.', caplog)
+    else:
+        assert freqtrade.exchange.get_rate('ETH/BTC', refresh=True, side="buy") == 0.043935
+        assert ticker_mock.call_count == 0
 
 
 def test_check_depth_of_market_buy(default_conf, mocker, order_book_l2) -> None:

From 42a2fdc1c520c97b27cf937e25aa7bd85a581a21 Mon Sep 17 00:00:00 2001
From: Sam Germain <sam.germain@usask.ca>
Date: Sat, 18 Sep 2021 03:01:08 -0600
Subject: [PATCH 26/34] parametrized test_order_dict

---
 tests/test_freqtradebot.py | 47 ++++++++------------------------------
 1 file changed, 10 insertions(+), 37 deletions(-)

diff --git a/tests/test_freqtradebot.py b/tests/test_freqtradebot.py
index 5268d40ec..8e8ae4da2 100644
--- a/tests/test_freqtradebot.py
+++ b/tests/test_freqtradebot.py
@@ -78,11 +78,15 @@ def test_bot_cleanup(mocker, default_conf, caplog) -> None:
     assert coo_mock.call_count == 1
 
 
-def test_order_dict_dry_run(default_conf, mocker, caplog) -> None:
+@pytest.mark.parametrize('runmode', [
+    RunMode.DRY_RUN,
+    RunMode.LIVE
+])
+def test_order_dict(default_conf, mocker, runmode, caplog) -> None:
     patch_RPCManager(mocker)
     patch_exchange(mocker)
     conf = default_conf.copy()
-    conf['runmode'] = RunMode.DRY_RUN
+    conf['runmode'] = runmode
     conf['order_types'] = {
         'buy': 'market',
         'sell': 'limit',
@@ -92,45 +96,14 @@ def test_order_dict_dry_run(default_conf, mocker, caplog) -> None:
     conf['bid_strategy']['price_side'] = 'ask'
 
     freqtrade = FreqtradeBot(conf)
+    if runmode == RunMode.LIVE:
+        assert not log_has_re(".*stoploss_on_exchange .* dry-run", caplog)
     assert freqtrade.strategy.order_types['stoploss_on_exchange']
 
     caplog.clear()
     # is left untouched
     conf = default_conf.copy()
-    conf['runmode'] = RunMode.DRY_RUN
-    conf['order_types'] = {
-        'buy': 'market',
-        'sell': 'limit',
-        'stoploss': 'limit',
-        'stoploss_on_exchange': False,
-    }
-    freqtrade = FreqtradeBot(conf)
-    assert not freqtrade.strategy.order_types['stoploss_on_exchange']
-    assert not log_has_re(".*stoploss_on_exchange .* dry-run", caplog)
-
-
-def test_order_dict_live(default_conf, mocker, caplog) -> None:
-    patch_RPCManager(mocker)
-    patch_exchange(mocker)
-
-    conf = default_conf.copy()
-    conf['runmode'] = RunMode.LIVE
-    conf['order_types'] = {
-        'buy': 'market',
-        'sell': 'limit',
-        'stoploss': 'limit',
-        'stoploss_on_exchange': True,
-    }
-    conf['bid_strategy']['price_side'] = 'ask'
-
-    freqtrade = FreqtradeBot(conf)
-    assert not log_has_re(".*stoploss_on_exchange .* dry-run", caplog)
-    assert freqtrade.strategy.order_types['stoploss_on_exchange']
-
-    caplog.clear()
-    # is left untouched
-    conf = default_conf.copy()
-    conf['runmode'] = RunMode.LIVE
+    conf['runmode'] = runmode
     conf['order_types'] = {
         'buy': 'market',
         'sell': 'limit',
@@ -3139,7 +3112,7 @@ def test_execute_trade_exit_insufficient_funds_error(default_conf, ticker, fee,
     # Disable loss
     (False, 0.00000172, 0.00000173, True, False, SellType.SELL_SIGNAL.value),
 ])
-def test_sell_profit_only_enable_profit(
+def test_sell_profit_only(
         default_conf, limit_buy_order, limit_buy_order_open,
         fee, mocker, profit_only, bid, ask, handle_first, handle_second, sell_type) -> None:
     patch_RPCManager(mocker)

From 518a59ad41daa50c51deb8d7e70e75b3b9a8bad0 Mon Sep 17 00:00:00 2001
From: Sam Germain <sam.germain@usask.ca>
Date: Sat, 18 Sep 2021 03:20:00 -0600
Subject: [PATCH 27/34] parametrized test_edge_overrides_stoploss

---
 tests/test_freqtradebot.py | 60 ++++++++++----------------------------
 1 file changed, 15 insertions(+), 45 deletions(-)

diff --git a/tests/test_freqtradebot.py b/tests/test_freqtradebot.py
index 8e8ae4da2..debe2bee0 100644
--- a/tests/test_freqtradebot.py
+++ b/tests/test_freqtradebot.py
@@ -192,8 +192,14 @@ def test_edge_overrides_stake_amount(mocker, edge_conf) -> None:
         'LTC/BTC', freqtrade.edge) == (999.9 * 0.5 * 0.01) / 0.21
 
 
-def test_edge_overrides_stoploss(limit_buy_order, fee, caplog, mocker, edge_conf) -> None:
-
+@pytest.mark.parametrize('buy_price_mult,ignore_strat_sl', [
+    # Override stoploss
+    (0.79, False),
+    # Override strategy stoploss
+    (0.85, True)
+])
+def test_edge_overrides_stoploss(limit_buy_order, fee, caplog, mocker,
+                                 buy_price_mult, ignore_strat_sl, edge_conf) -> None:
     patch_RPCManager(mocker)
     patch_exchange(mocker)
     patch_edge(mocker)
@@ -207,9 +213,9 @@ def test_edge_overrides_stoploss(limit_buy_order, fee, caplog, mocker, edge_conf
     mocker.patch.multiple(
         'freqtrade.exchange.Exchange',
         fetch_ticker=MagicMock(return_value={
-            'bid': buy_price * 0.79,
-            'ask': buy_price * 0.79,
-            'last': buy_price * 0.79
+            'bid': buy_price * buy_price_mult,
+            'ask': buy_price * buy_price_mult,
+            'last': buy_price * buy_price_mult,
         }),
         get_fee=fee,
     )
@@ -226,46 +232,10 @@ def test_edge_overrides_stoploss(limit_buy_order, fee, caplog, mocker, edge_conf
     #############################################
 
     # stoploss shoud be hit
-    assert freqtrade.handle_trade(trade) is True
-    assert log_has('Executing Sell for NEO/BTC. Reason: stop_loss', caplog)
-    assert trade.sell_reason == SellType.STOP_LOSS.value
-
-
-def test_edge_should_ignore_strategy_stoploss(limit_buy_order, fee,
-                                              mocker, edge_conf) -> None:
-    patch_RPCManager(mocker)
-    patch_exchange(mocker)
-    patch_edge(mocker)
-    edge_conf['max_open_trades'] = float('inf')
-
-    # Strategy stoploss is -0.1 but Edge imposes a stoploss at -0.2
-    # Thus, if price falls 15%, stoploss should not be triggered
-    #
-    # mocking the ticker: price is falling ...
-    buy_price = limit_buy_order['price']
-    mocker.patch.multiple(
-        'freqtrade.exchange.Exchange',
-        fetch_ticker=MagicMock(return_value={
-            'bid': buy_price * 0.85,
-            'ask': buy_price * 0.85,
-            'last': buy_price * 0.85
-        }),
-        get_fee=fee,
-    )
-    #############################################
-
-    # Create a trade with "limit_buy_order" price
-    freqtrade = FreqtradeBot(edge_conf)
-    freqtrade.active_pair_whitelist = ['NEO/BTC']
-    patch_get_signal(freqtrade)
-    freqtrade.strategy.min_roi_reached = MagicMock(return_value=False)
-    freqtrade.enter_positions()
-    trade = Trade.query.first()
-    trade.update(limit_buy_order)
-    #############################################
-
-    # stoploss shoud not be hit
-    assert freqtrade.handle_trade(trade) is False
+    assert freqtrade.handle_trade(trade) is not ignore_strat_sl
+    if not ignore_strat_sl:
+        assert log_has('Executing Sell for NEO/BTC. Reason: stop_loss', caplog)
+        assert trade.sell_reason == SellType.STOP_LOSS.value
 
 
 def test_total_open_trades_stakes(mocker, default_conf, ticker, fee) -> None:

From 713e7819f7e534a36984f9f4c76a11bbfd948896 Mon Sep 17 00:00:00 2001
From: Rokas Kupstys <rokups@zoho.com>
Date: Sat, 18 Sep 2021 15:27:58 +0300
Subject: [PATCH 28/34] [SQUASH] Remove mypy import.

---
 freqtrade/strategy/informative_decorator.py | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/freqtrade/strategy/informative_decorator.py b/freqtrade/strategy/informative_decorator.py
index c8ebf5989..4c5f21108 100644
--- a/freqtrade/strategy/informative_decorator.py
+++ b/freqtrade/strategy/informative_decorator.py
@@ -1,6 +1,5 @@
 from typing import Any, Callable, NamedTuple, Optional, Union
 
-from mypy_extensions import KwArg
 from pandas import DataFrame
 
 from freqtrade.exceptions import OperationalException
@@ -13,12 +12,12 @@ PopulateIndicators = Callable[[Any, DataFrame, dict], DataFrame]
 class InformativeData(NamedTuple):
     asset: Optional[str]
     timeframe: str
-    fmt: Union[str, Callable[[KwArg(str)], str], None]
+    fmt: Union[str, Callable[[Any], str], None]
     ffill: bool
 
 
 def informative(timeframe: str, asset: str = '',
-                fmt: Optional[Union[str, Callable[[KwArg(str)], str]]] = None,
+                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

From eab7f8f6944e77fa7ae69bf99fe885aa76aea5a5 Mon Sep 17 00:00:00 2001
From: Rokas Kupstys <rokups@zoho.com>
Date: Sat, 18 Sep 2021 15:44:21 +0300
Subject: [PATCH 29/34] [SQUASH] Doh.

---
 tests/strategy/test_strategy_helpers.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/tests/strategy/test_strategy_helpers.py b/tests/strategy/test_strategy_helpers.py
index 9132382fa..a01b55050 100644
--- a/tests/strategy/test_strategy_helpers.py
+++ b/tests/strategy/test_strategy_helpers.py
@@ -5,8 +5,8 @@ import pandas as pd
 import pytest
 
 from freqtrade.data.dataprovider import DataProvider
-from freqtrade.strategy import (merge_informative_pair, stoploss_from_open, timeframe_to_minutes,
-                                stoploss_from_absolute)
+from freqtrade.strategy import (merge_informative_pair, stoploss_from_absolute, stoploss_from_open,
+                                timeframe_to_minutes)
 
 
 def generate_test_data(timeframe: str, size: int):

From c1895a0fc230f14e9de79a3042d77d3379a61c1f Mon Sep 17 00:00:00 2001
From: Matthias <xmatthias@outlook.com>
Date: Sat, 18 Sep 2021 15:30:33 +0200
Subject: [PATCH 30/34] Remove warning related to legacy hyperopt

---
 docs/strategy-customization.md | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/docs/strategy-customization.md b/docs/strategy-customization.md
index 2b22dd274..725252b30 100644
--- a/docs/strategy-customization.md
+++ b/docs/strategy-customization.md
@@ -801,9 +801,6 @@ for more information.
     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)
 
 The strategy provides access to the `Wallets` object. This contains the current balances on the exchange.

From ec9dbc550e66c2694bfe32a43c3442952d8b685c Mon Sep 17 00:00:00 2001
From: Sam Germain <sam.germain@usask.ca>
Date: Sat, 18 Sep 2021 19:19:53 -0600
Subject: [PATCH 31/34] parametrized test_create_trade_minimal_amount

---
 tests/test_freqtradebot.py | 93 +++++++++++---------------------------
 1 file changed, 26 insertions(+), 67 deletions(-)

diff --git a/tests/test_freqtradebot.py b/tests/test_freqtradebot.py
index debe2bee0..209c8a2a2 100644
--- a/tests/test_freqtradebot.py
+++ b/tests/test_freqtradebot.py
@@ -319,8 +319,16 @@ def test_create_trade_no_stake_amount(default_conf, ticker, limit_buy_order,
         freqtrade.create_trade('ETH/BTC')
 
 
-def test_create_trade_minimal_amount(default_conf, ticker, limit_buy_order_open,
-                                     fee, mocker) -> None:
+@pytest.mark.parametrize('stake_amount,create,amount_enough,max_open_trades', [
+    (0.0005, True, True, 99),
+    (0.000000005, True, False, 99),
+    (0, False, True, 99),
+    (UNLIMITED_STAKE_AMOUNT, False, True, 0),
+])
+def test_create_trade_minimal_amount(
+    default_conf, ticker, limit_buy_order_open, fee, mocker,
+    stake_amount, create, amount_enough, max_open_trades, caplog
+) -> None:
     patch_RPCManager(mocker)
     patch_exchange(mocker)
     buy_mock = MagicMock(return_value=limit_buy_order_open)
@@ -330,74 +338,25 @@ def test_create_trade_minimal_amount(default_conf, ticker, limit_buy_order_open,
         create_order=buy_mock,
         get_fee=fee,
     )
-    default_conf['stake_amount'] = 0.0005
+    default_conf['max_open_trades'] = max_open_trades
     freqtrade = FreqtradeBot(default_conf)
+    freqtrade.config['stake_amount'] = stake_amount
     patch_get_signal(freqtrade)
 
-    freqtrade.create_trade('ETH/BTC')
-    rate, amount = buy_mock.call_args[1]['rate'], buy_mock.call_args[1]['amount']
-    assert rate * amount <= default_conf['stake_amount']
-
-
-def test_create_trade_too_small_stake_amount(default_conf, ticker, limit_buy_order_open,
-                                             fee, mocker, caplog) -> None:
-    patch_RPCManager(mocker)
-    patch_exchange(mocker)
-    buy_mock = MagicMock(return_value=limit_buy_order_open)
-    mocker.patch.multiple(
-        'freqtrade.exchange.Exchange',
-        fetch_ticker=ticker,
-        create_order=buy_mock,
-        get_fee=fee,
-    )
-
-    freqtrade = FreqtradeBot(default_conf)
-    freqtrade.config['stake_amount'] = 0.000000005
-
-    patch_get_signal(freqtrade)
-
-    assert freqtrade.create_trade('ETH/BTC')
-    assert log_has_re(r"Stake amount for pair .* is too small.*", caplog)
-
-
-def test_create_trade_zero_stake_amount(default_conf, ticker, limit_buy_order_open,
-                                        fee, mocker) -> None:
-    patch_RPCManager(mocker)
-    patch_exchange(mocker)
-    buy_mock = MagicMock(return_value=limit_buy_order_open)
-    mocker.patch.multiple(
-        'freqtrade.exchange.Exchange',
-        fetch_ticker=ticker,
-        create_order=buy_mock,
-        get_fee=fee,
-    )
-
-    freqtrade = FreqtradeBot(default_conf)
-    freqtrade.config['stake_amount'] = 0
-
-    patch_get_signal(freqtrade)
-
-    assert not freqtrade.create_trade('ETH/BTC')
-
-
-def test_create_trade_limit_reached(default_conf, ticker, limit_buy_order_open,
-                                    fee, mocker) -> None:
-    patch_RPCManager(mocker)
-    patch_exchange(mocker)
-    mocker.patch.multiple(
-        'freqtrade.exchange.Exchange',
-        fetch_ticker=ticker,
-        create_order=MagicMock(return_value=limit_buy_order_open),
-        get_fee=fee,
-    )
-    default_conf['max_open_trades'] = 0
-    default_conf['stake_amount'] = UNLIMITED_STAKE_AMOUNT
-
-    freqtrade = FreqtradeBot(default_conf)
-    patch_get_signal(freqtrade)
-
-    assert not freqtrade.create_trade('ETH/BTC')
-    assert freqtrade.wallets.get_trade_stake_amount('ETH/BTC', freqtrade.edge) == 0
+    if create:
+        assert freqtrade.create_trade('ETH/BTC')
+        if amount_enough:
+            rate, amount = buy_mock.call_args[1]['rate'], buy_mock.call_args[1]['amount']
+            assert rate * amount <= default_conf['stake_amount']
+        else:
+            assert log_has_re(
+                r"Stake amount for pair .* is too small.*",
+                caplog
+            )
+    else:
+        assert not freqtrade.create_trade('ETH/BTC')
+        if not max_open_trades:
+            assert freqtrade.wallets.get_trade_stake_amount('ETH/BTC', freqtrade.edge) == 0
 
 
 def test_enter_positions_no_pairs_left(default_conf, ticker, limit_buy_order_open, fee,

From cee4ed541b8e4bec16ce8a23598531fb4d64ec57 Mon Sep 17 00:00:00 2001
From: Sam Germain <sam.germain@usask.ca>
Date: Sat, 18 Sep 2021 19:46:46 -0600
Subject: [PATCH 32/34] parametrized test_update_trade_state_withorderdict

---
 tests/test_freqtradebot.py | 104 +++++++++++++------------------------
 1 file changed, 35 insertions(+), 69 deletions(-)

diff --git a/tests/test_freqtradebot.py b/tests/test_freqtradebot.py
index 209c8a2a2..72d1f6150 100644
--- a/tests/test_freqtradebot.py
+++ b/tests/test_freqtradebot.py
@@ -359,8 +359,12 @@ def test_create_trade_minimal_amount(
             assert freqtrade.wallets.get_trade_stake_amount('ETH/BTC', freqtrade.edge) == 0
 
 
+@pytest.mark.parametrize('whitelist,positions', [
+    (["ETH/BTC"], 1),  # No pairs left
+    ([], 0),  # No pairs in whitelist
+])
 def test_enter_positions_no_pairs_left(default_conf, ticker, limit_buy_order_open, fee,
-                                       mocker, caplog) -> None:
+                                       whitelist, positions, mocker, caplog) -> None:
     patch_RPCManager(mocker)
     patch_exchange(mocker)
     mocker.patch.multiple(
@@ -369,36 +373,20 @@ def test_enter_positions_no_pairs_left(default_conf, ticker, limit_buy_order_ope
         create_order=MagicMock(return_value=limit_buy_order_open),
         get_fee=fee,
     )
-
-    default_conf['exchange']['pair_whitelist'] = ["ETH/BTC"]
+    default_conf['exchange']['pair_whitelist'] = whitelist
     freqtrade = FreqtradeBot(default_conf)
     patch_get_signal(freqtrade)
 
     n = freqtrade.enter_positions()
-    assert n == 1
-    assert not log_has_re(r"No currency pair in active pair whitelist.*", caplog)
-    n = freqtrade.enter_positions()
-    assert n == 0
-    assert log_has_re(r"No currency pair in active pair whitelist.*", caplog)
-
-
-def test_enter_positions_no_pairs_in_whitelist(default_conf, ticker, limit_buy_order, fee,
-                                               mocker, caplog) -> None:
-    patch_RPCManager(mocker)
-    patch_exchange(mocker)
-    mocker.patch.multiple(
-        'freqtrade.exchange.Exchange',
-        fetch_ticker=ticker,
-        create_order=MagicMock(return_value={'id': limit_buy_order['id']}),
-        get_fee=fee,
-    )
-    default_conf['exchange']['pair_whitelist'] = []
-    freqtrade = FreqtradeBot(default_conf)
-    patch_get_signal(freqtrade)
-
-    n = freqtrade.enter_positions()
-    assert n == 0
-    assert log_has("Active pair whitelist is empty.", caplog)
+    assert n == positions
+    if positions:
+        assert not log_has_re(r"No currency pair in active pair whitelist.*", caplog)
+        n = freqtrade.enter_positions()
+        assert n == 0
+        assert log_has_re(r"No currency pair in active pair whitelist.*", caplog)
+    else:
+        assert n == 0
+        assert log_has("Active pair whitelist is empty.", caplog)
 
 
 @pytest.mark.usefixtures("init_persistence")
@@ -1555,30 +1543,27 @@ def test_tsl_on_exchange_compatible_with_edge(mocker, edge_conf, fee, caplog,
                                                 stop_price=0.00002346 * 0.99)
 
 
-def test_enter_positions(mocker, default_conf, caplog) -> None:
+@pytest.mark.parametrize('return_value,side_effect,log_message', [
+    (False, None, 'Found no buy signals for whitelisted currencies. Trying again...'),
+    (None, DependencyException, 'Unable to create trade for ETH/BTC: ')
+])
+def test_enter_positions(mocker, default_conf, return_value, side_effect,
+                         log_message, caplog) -> None:
     caplog.set_level(logging.DEBUG)
     freqtrade = get_patched_freqtradebot(mocker, default_conf)
 
-    mock_ct = mocker.patch('freqtrade.freqtradebot.FreqtradeBot.create_trade',
-                           MagicMock(return_value=False))
-    n = freqtrade.enter_positions()
-    assert n == 0
-    assert log_has('Found no buy signals for whitelisted currencies. Trying again...', caplog)
-    # create_trade should be called once for every pair in the whitelist.
-    assert mock_ct.call_count == len(default_conf['exchange']['pair_whitelist'])
-
-
-def test_enter_positions_exception(mocker, default_conf, caplog) -> None:
-    freqtrade = get_patched_freqtradebot(mocker, default_conf)
-
     mock_ct = mocker.patch(
         'freqtrade.freqtradebot.FreqtradeBot.create_trade',
-        MagicMock(side_effect=DependencyException)
+        MagicMock(
+            return_value=return_value,
+            side_effect=side_effect
+        )
     )
     n = freqtrade.enter_positions()
     assert n == 0
+    assert log_has(log_message, caplog)
+    # create_trade should be called once for every pair in the whitelist.
     assert mock_ct.call_count == len(default_conf['exchange']['pair_whitelist'])
-    assert log_has('Unable to create trade for ETH/BTC: ', caplog)
 
 
 def test_exit_positions(mocker, default_conf, limit_buy_order, caplog) -> None:
@@ -1672,8 +1657,13 @@ def test_update_trade_state(mocker, default_conf, limit_buy_order, caplog) -> No
     assert log_has_re('Found open order for.*', caplog)
 
 
+@pytest.mark.parametrize('initial_amount,has_rounding_fee', [
+    (90.99181073 + 1e-14, True),
+    (8.0, False)
+])
 def test_update_trade_state_withorderdict(default_conf, trades_for_order, limit_buy_order, fee,
-                                          mocker):
+                                          mocker, initial_amount, has_rounding_fee, caplog):
+    trades_for_order[0]['amount'] = initial_amount
     mocker.patch('freqtrade.exchange.Exchange.get_trades_for_order', return_value=trades_for_order)
     # fetch_order should not be called!!
     mocker.patch('freqtrade.exchange.Exchange.fetch_order', MagicMock(side_effect=ValueError))
@@ -1694,32 +1684,8 @@ def test_update_trade_state_withorderdict(default_conf, trades_for_order, limit_
     freqtrade.update_trade_state(trade, '123456', limit_buy_order)
     assert trade.amount != amount
     assert trade.amount == limit_buy_order['amount']
-
-
-def test_update_trade_state_withorderdict_rounding_fee(default_conf, trades_for_order, fee,
-                                                       limit_buy_order, mocker, caplog):
-    trades_for_order[0]['amount'] = limit_buy_order['amount'] + 1e-14
-    mocker.patch('freqtrade.exchange.Exchange.get_trades_for_order', return_value=trades_for_order)
-    # fetch_order should not be called!!
-    mocker.patch('freqtrade.exchange.Exchange.fetch_order', MagicMock(side_effect=ValueError))
-    patch_exchange(mocker)
-    amount = sum(x['amount'] for x in trades_for_order)
-    freqtrade = get_patched_freqtradebot(mocker, default_conf)
-    trade = Trade(
-        pair='LTC/ETH',
-        amount=amount,
-        exchange='binance',
-        open_rate=0.245441,
-        fee_open=fee.return_value,
-        fee_close=fee.return_value,
-        open_order_id='123456',
-        is_open=True,
-        open_date=arrow.utcnow().datetime,
-    )
-    freqtrade.update_trade_state(trade, '123456', limit_buy_order)
-    assert trade.amount != amount
-    assert trade.amount == limit_buy_order['amount']
-    assert log_has_re(r'Applying fee on amount for .*', caplog)
+    if has_rounding_fee:
+        assert log_has_re(r'Applying fee on amount for .*', caplog)
 
 
 def test_update_trade_state_exception(mocker, default_conf,

From ab88217186afa23718421ad67867a9d624024878 Mon Sep 17 00:00:00 2001
From: Matthias <xmatthias@outlook.com>
Date: Sun, 19 Sep 2021 13:16:30 +0200
Subject: [PATCH 33/34] Improve /balance output to include starting balance and
 percentual change

closes #5503
---
 freqtrade/rpc/api_server/api_schemas.py |  7 +++++++
 freqtrade/rpc/rpc.py                    | 24 ++++++++++++++++++++----
 freqtrade/rpc/telegram.py               | 23 +++++++++++++++--------
 tests/rpc/test_rpc_apiserver.py         | 14 ++++++++++----
 tests/rpc/test_rpc_telegram.py          |  2 ++
 5 files changed, 54 insertions(+), 16 deletions(-)

diff --git a/freqtrade/rpc/api_server/api_schemas.py b/freqtrade/rpc/api_server/api_schemas.py
index 3adbebc16..eb6082087 100644
--- a/freqtrade/rpc/api_server/api_schemas.py
+++ b/freqtrade/rpc/api_server/api_schemas.py
@@ -46,6 +46,13 @@ class Balances(BaseModel):
     value: float
     stake: str
     note: str
+    starting_capital: float
+    starting_capital_ratio: float
+    starting_capital_pct: float
+    starting_capital_fiat: float
+    starting_capital_fiat_ratio: float
+    starting_capital_fiat_pct: float
+
 
 
 class Count(BaseModel):
diff --git a/freqtrade/rpc/rpc.py b/freqtrade/rpc/rpc.py
index b7b1fe603..12a444b80 100644
--- a/freqtrade/rpc/rpc.py
+++ b/freqtrade/rpc/rpc.py
@@ -458,6 +458,9 @@ class RPC:
             raise RPCException('Error getting current tickers.')
 
         self._freqtrade.wallets.update(require_update=False)
+        starting_capital = self._freqtrade.wallets.get_starting_balance()
+        starting_capital_fiat = self._fiat_converter.convert_amount(
+            starting_capital, stake_currency, fiat_display_currency) if self._fiat_converter else 0
 
         for coin, balance in self._freqtrade.wallets.get_all_balances().items():
             if not balance.total:
@@ -493,15 +496,28 @@ class RPC:
             else:
                 raise RPCException('All balances are zero.')
 
-        symbol = fiat_display_currency
-        value = self._fiat_converter.convert_amount(total, stake_currency,
-                                                    symbol) if self._fiat_converter else 0
+        value = self._fiat_converter.convert_amount(
+            total, stake_currency, fiat_display_currency) if self._fiat_converter else 0
+
+        starting_capital_ratio = 0.0
+        starting_capital_fiat_ratio = 0.0
+        if starting_capital:
+            starting_capital_ratio = (total / starting_capital) - 1
+        if starting_capital_fiat:
+            starting_capital_fiat_ratio = (value / starting_capital_fiat) - 1
+
         return {
             'currencies': output,
             'total': total,
-            'symbol': symbol,
+            'symbol': fiat_display_currency,
             'value': value,
             'stake': stake_currency,
+            'starting_capital': starting_capital,
+            'starting_capital_ratio': starting_capital_ratio,
+            'starting_capital_pct': round(starting_capital_ratio * 100, 2),
+            'starting_capital_fiat': starting_capital_fiat,
+            'starting_capital_fiat_ratio': starting_capital_fiat_ratio,
+            'starting_capital_fiat_pct': round(starting_capital_fiat_ratio * 100, 2),
             'note': 'Simulated balances' if self._freqtrade.config['dry_run'] else ''
         }
 
diff --git a/freqtrade/rpc/telegram.py b/freqtrade/rpc/telegram.py
index a988d2b60..ffb7385da 100644
--- a/freqtrade/rpc/telegram.py
+++ b/freqtrade/rpc/telegram.py
@@ -603,12 +603,15 @@ class Telegram(RPCHandler):
 
             output = ''
             if self._config['dry_run']:
-                output += (
-                    f"*Warning:* Simulated balances in Dry Mode.\n"
-                    "This mode is still experimental!\n"
-                    "Starting capital: "
-                    f"`{self._config['dry_run_wallet']}` {self._config['stake_currency']}.\n"
-                )
+                output += "*Warning:* Simulated balances in Dry Mode.\n"
+
+            output += ("Starting capital: "
+                       f"`{result['starting_capital']}` {self._config['stake_currency']}"
+                       )
+            output += (f" `{result['starting_capital_fiat']}` "
+                       f"{self._config['fiat_display_currency']}.\n"
+                       ) if result['starting_capital_fiat'] > 0 else '.\n'
+
             total_dust_balance = 0
             total_dust_currencies = 0
             for curr in result['currencies']:
@@ -641,9 +644,13 @@ class Telegram(RPCHandler):
                     f"{round_coin_value(total_dust_balance, result['stake'], False)}`\n")
 
             output += ("\n*Estimated Value*:\n"
-                       f"\t`{result['stake']}: {result['total']: .8f}`\n"
+                       f"\t`{result['stake']}: "
+                       f"{round_coin_value(result['total'], result['stake'], False)}`"
+                       f" `({result['starting_capital_pct']}%)`\n"
                        f"\t`{result['symbol']}: "
-                       f"{round_coin_value(result['value'], result['symbol'], False)}`\n")
+                       f"{round_coin_value(result['value'], result['symbol'], False)}`"
+                       f" `({result['starting_capital_fiat_pct']}%)`\n"
+            )
             self._send_msg(output, reload_able=True, callback_path="update_balance",
                            query=update.callback_query)
         except RPCException as e:
diff --git a/tests/rpc/test_rpc_apiserver.py b/tests/rpc/test_rpc_apiserver.py
index 43eb70938..7c98b2df7 100644
--- a/tests/rpc/test_rpc_apiserver.py
+++ b/tests/rpc/test_rpc_apiserver.py
@@ -422,20 +422,22 @@ def test_api_stopbuy(botclient):
     assert ftbot.config['max_open_trades'] == 0
 
 
-def test_api_balance(botclient, mocker, rpc_balance):
+def test_api_balance(botclient, mocker, rpc_balance, tickers):
     ftbot, client = botclient
 
     ftbot.config['dry_run'] = False
     mocker.patch('freqtrade.exchange.Exchange.get_balances', return_value=rpc_balance)
+    mocker.patch('freqtrade.exchange.Exchange.get_tickers', tickers)
     mocker.patch('freqtrade.exchange.Exchange.get_valid_pair_combination',
                  side_effect=lambda a, b: f"{a}/{b}")
     ftbot.wallets.update()
 
     rc = client_get(client, f"{BASE_URI}/balance")
     assert_response(rc)
-    assert "currencies" in rc.json()
-    assert len(rc.json()["currencies"]) == 5
-    assert rc.json()['currencies'][0] == {
+    response = rc.json()
+    assert "currencies" in response
+    assert len(response["currencies"]) == 5
+    assert response['currencies'][0] == {
         'currency': 'BTC',
         'free': 12.0,
         'balance': 12.0,
@@ -443,6 +445,10 @@ def test_api_balance(botclient, mocker, rpc_balance):
         'est_stake': 12.0,
         'stake': 'BTC',
     }
+    assert 'starting_capital' in response
+    assert 'starting_capital_fiat' in response
+    assert 'starting_capital_pct' in response
+    assert 'starting_capital_ratio' in response
 
 
 def test_api_count(botclient, mocker, ticker, fee, markets):
diff --git a/tests/rpc/test_rpc_telegram.py b/tests/rpc/test_rpc_telegram.py
index 2013dad7d..21f1cd000 100644
--- a/tests/rpc/test_rpc_telegram.py
+++ b/tests/rpc/test_rpc_telegram.py
@@ -576,6 +576,8 @@ def test_balance_handle_too_large_response(default_conf, update, mocker) -> None
         'total': 100.0,
         'symbol': 100.0,
         'value': 1000.0,
+        'starting_capital': 1000,
+        'starting_capital_fiat': 1000,
     })
 
     telegram, freqtradebot, msg_mock = get_telegram_testobject(mocker, default_conf)

From ec03531771904a3a20dc31e4c64d0f13156fdcce Mon Sep 17 00:00:00 2001
From: Matthias <xmatthias@outlook.com>
Date: Sun, 19 Sep 2021 13:29:09 +0200
Subject: [PATCH 34/34] Improve naming of variables

---
 freqtrade/rpc/api_server/api_schemas.py |  1 -
 freqtrade/rpc/rpc.py                    | 15 ++++++---------
 freqtrade/rpc/telegram.py               |  3 +--
 3 files changed, 7 insertions(+), 12 deletions(-)

diff --git a/freqtrade/rpc/api_server/api_schemas.py b/freqtrade/rpc/api_server/api_schemas.py
index eb6082087..46187f571 100644
--- a/freqtrade/rpc/api_server/api_schemas.py
+++ b/freqtrade/rpc/api_server/api_schemas.py
@@ -54,7 +54,6 @@ class Balances(BaseModel):
     starting_capital_fiat_pct: float
 
 
-
 class Count(BaseModel):
     current: int
     max: int
diff --git a/freqtrade/rpc/rpc.py b/freqtrade/rpc/rpc.py
index 12a444b80..f6599b429 100644
--- a/freqtrade/rpc/rpc.py
+++ b/freqtrade/rpc/rpc.py
@@ -459,7 +459,7 @@ class RPC:
 
         self._freqtrade.wallets.update(require_update=False)
         starting_capital = self._freqtrade.wallets.get_starting_balance()
-        starting_capital_fiat = self._fiat_converter.convert_amount(
+        starting_cap_fiat = self._fiat_converter.convert_amount(
             starting_capital, stake_currency, fiat_display_currency) if self._fiat_converter else 0
 
         for coin, balance in self._freqtrade.wallets.get_all_balances().items():
@@ -500,11 +500,8 @@ class RPC:
             total, stake_currency, fiat_display_currency) if self._fiat_converter else 0
 
         starting_capital_ratio = 0.0
-        starting_capital_fiat_ratio = 0.0
-        if starting_capital:
-            starting_capital_ratio = (total / starting_capital) - 1
-        if starting_capital_fiat:
-            starting_capital_fiat_ratio = (value / starting_capital_fiat) - 1
+        starting_capital_ratio = (total / starting_capital) - 1 if starting_capital else 0.0
+        starting_cap_fiat_ratio = (value / starting_cap_fiat) - 1 if starting_cap_fiat else 0.0
 
         return {
             'currencies': output,
@@ -515,9 +512,9 @@ class RPC:
             'starting_capital': starting_capital,
             'starting_capital_ratio': starting_capital_ratio,
             'starting_capital_pct': round(starting_capital_ratio * 100, 2),
-            'starting_capital_fiat': starting_capital_fiat,
-            'starting_capital_fiat_ratio': starting_capital_fiat_ratio,
-            'starting_capital_fiat_pct': round(starting_capital_fiat_ratio * 100, 2),
+            'starting_capital_fiat': starting_cap_fiat,
+            'starting_capital_fiat_ratio': starting_cap_fiat_ratio,
+            'starting_capital_fiat_pct': round(starting_cap_fiat_ratio * 100, 2),
             'note': 'Simulated balances' if self._freqtrade.config['dry_run'] else ''
         }
 
diff --git a/freqtrade/rpc/telegram.py b/freqtrade/rpc/telegram.py
index ffb7385da..19c58b63d 100644
--- a/freqtrade/rpc/telegram.py
+++ b/freqtrade/rpc/telegram.py
@@ -649,8 +649,7 @@ class Telegram(RPCHandler):
                        f" `({result['starting_capital_pct']}%)`\n"
                        f"\t`{result['symbol']}: "
                        f"{round_coin_value(result['value'], result['symbol'], False)}`"
-                       f" `({result['starting_capital_fiat_pct']}%)`\n"
-            )
+                       f" `({result['starting_capital_fiat_pct']}%)`\n")
             self._send_msg(output, reload_able=True, callback_path="update_balance",
                            query=update.callback_query)
         except RPCException as e: