Merge pull request #5243 from freqtrade/feat/webservermode_progress

Introduce webserver mode subcommand

freqtrade/optimize/backtesting.py

@@ -17,10 +17,11 @@ from freqtrade.data import history
 from freqtrade.data.btanalysis import trade_list_to_dataframe
 from freqtrade.data.converter import trim_dataframes
 from freqtrade.data.dataprovider import DataProvider
-from freqtrade.enums import SellType
+from freqtrade.enums import BacktestState, SellType
 from freqtrade.exceptions import DependencyException, OperationalException
 from freqtrade.exchange import timeframe_to_minutes, timeframe_to_seconds
 from freqtrade.mixins import LoggingMixin
+from freqtrade.optimize.bt_progress import BTProgress
 from freqtrade.optimize.optimize_reports import (generate_backtest_stats, show_backtest_results,
                                                  store_backtest_stats)
 from freqtrade.persistence import LocalTrade, PairLocks, Trade
@@ -57,6 +58,7 @@ class Backtesting:
 
         LoggingMixin.show_output = False
         self.config = config
+        self.results: Optional[Dict[str, Any]] = None
 
         # Reset keys for backtesting
         remove_credentials(self.config)
@@ -118,6 +120,9 @@ class Backtesting:
         self.required_startup = max([strat.startup_candle_count for strat in self.strategylist])
         self.exchange.validate_required_startup_candles(self.required_startup, self.timeframe)
 
+        self.progress = BTProgress()
+        self.abort = False
+
     def __del__(self):
         LoggingMixin.show_output = True
         PairLocks.use_db = True
@@ -147,6 +152,8 @@ class Backtesting:
         Loads backtest data and returns the data combined with the timerange
         as tuple.
         """
+        self.progress.init_step(BacktestState.DATALOAD, 1)
+
         timerange = TimeRange.parse_timerange(None if self.config.get(
             'timerange') is None else str(self.config.get('timerange')))
 
@@ -170,6 +177,7 @@ class Backtesting:
         timerange.adjust_start_if_necessary(timeframe_to_seconds(self.timeframe),
                                             self.required_startup, min_date)
 
+        self.progress.set_new_value(1)
         return data, timerange
 
     def prepare_backtest(self, enable_protections):
@@ -184,6 +192,15 @@ class Backtesting:
         self.rejected_trades = 0
         self.dataprovider.clear_cache()
 
+    def check_abort(self):
+        """
+        Check if abort was requested, raise DependencyException if that's the case
+        Only applies to Interactive backtest mode (webserver mode)
+        """
+        if self.abort:
+            self.abort = False
+            raise DependencyException("Stop requested")
+
     def _get_ohlcv_as_lists(self, processed: Dict[str, DataFrame]) -> Dict[str, Tuple]:
         """
         Helper function to convert a processed dataframes into lists for performance reasons.
@@ -194,8 +211,12 @@ class Backtesting:
         # and eventually change the constants for indexes at the top
         headers = ['date', 'buy', 'open', 'close', 'sell', 'low', 'high']
         data: Dict = {}
+        self.progress.init_step(BacktestState.CONVERT, len(processed))
+
         # Create dict with data
         for pair, pair_data in processed.items():
+            self.check_abort()
+            self.progress.increment()
             if not pair_data.empty:
                 pair_data.loc[:, 'buy'] = 0  # cleanup if buy_signal is exist
                 pair_data.loc[:, 'sell'] = 0  # cleanup if sell_signal is exist
@@ -417,10 +438,13 @@ class Backtesting:
         open_trades: Dict[str, List[LocalTrade]] = defaultdict(list)
         open_trade_count = 0
 
+        self.progress.init_step(BacktestState.BACKTEST, int(
+            (end_date - start_date) / timedelta(minutes=self.timeframe_min)))
+
         # Loop timerange and get candle for each pair at that point in time
         while tmp <= end_date:
             open_trade_count_start = open_trade_count
-
+            self.check_abort()
             for i, pair in enumerate(data):
                 row_index = indexes[pair]
                 try:
@@ -476,6 +500,7 @@ class Backtesting:
                             self.protections.global_stop(tmp)
 
             # Move time one configured time_interval ahead.
+            self.progress.increment()
             tmp += timedelta(minutes=self.timeframe_min)
 
         trades += self.handle_left_open(open_trades, data=data)
@@ -491,6 +516,8 @@ class Backtesting:
         }
 
     def backtest_one_strategy(self, strat: IStrategy, data: Dict[str, Any], timerange: TimeRange):
+        self.progress.init_step(BacktestState.ANALYZE, 0)
+
         logger.info("Running backtesting for Strategy %s", strat.get_strategy_name())
         backtest_start_time = datetime.now(timezone.utc)
         self._set_strategy(strat)
@@ -517,6 +544,7 @@ class Backtesting:
                 "No data left after adjusting for startup candles.")
 
         min_date, max_date = history.get_timerange(preprocessed)
+
         logger.info(f'Backtesting with data from {min_date.strftime(DATETIME_PRINT_FORMAT)} '
                     f'up to {max_date.strftime(DATETIME_PRINT_FORMAT)} '
                     f'({(max_date - min_date).days} days).')
@@ -551,11 +579,12 @@ class Backtesting:
         for strat in self.strategylist:
             min_date, max_date = self.backtest_one_strategy(strat, data, timerange)
         if len(self.strategylist) > 0:
-            stats = generate_backtest_stats(data, self.all_results,
-                                            min_date=min_date, max_date=max_date)
+
+            self.results = generate_backtest_stats(data, self.all_results,
+                                                   min_date=min_date, max_date=max_date)
 
             if self.config.get('export', 'none') == 'trades':
-                store_backtest_stats(self.config['exportfilename'], stats)
+                store_backtest_stats(self.config['exportfilename'], self.results)
 
             # Show backtest results
-            show_backtest_results(self.config, stats)
+            show_backtest_results(self.config, self.results)

freqtrade/optimize/bt_progress.py

@@ -0,0 +1,33 @@
+from freqtrade.enums import BacktestState
+
+
+class BTProgress:
+    _action: BacktestState = BacktestState.STARTUP
+    _progress: float = 0
+    _max_steps: float = 0
+
+    def __init__(self):
+        pass
+
+    def init_step(self, action: BacktestState, max_steps: float):
+        self._action = action
+        self._max_steps = max_steps
+        self._proress = 0
+
+    def set_new_value(self, new_value: float):
+        self._progress = new_value
+
+    def increment(self):
+        self._progress += 1
+
+    @property
+    def progress(self):
+        """
+        Get progress as ratio, capped to be between 0 and 1 (to avoid small calculation errors).
+        """
+        return max(min(round(self._progress / self._max_steps, 5)
+                       if self._max_steps > 0 else 0, 1), 0)
+
+    @property
+    def action(self):
+        return str(self._action)