Include final-bar open trades in results

Author: bm1016bm-svg

backtesting/_stats.py

@@ -61,9 +61,9 @@ def compute_stats(
         trades_df = pd.DataFrame({
             'Size': [t.size for t in trades],
             'EntryBar': [t.entry_bar for t in trades],
-            'ExitBar': [t.exit_bar for t in trades],
+            'ExitBar': [t.exit_bar if t.exit_bar is not None else np.nan for t in trades],
             'EntryPrice': [t.entry_price for t in trades],
-            'ExitPrice': [t.exit_price for t in trades],
+            'ExitPrice': [t.exit_price if t.exit_price is not None else np.nan for t in trades],
             'SL': [t.sl for t in trades],
             'TP': [t.tp for t in trades],
             'PnL': [t.pl for t in trades],
@@ -72,7 +72,10 @@ def compute_stats(
             'EntryTime': [t.entry_time for t in trades],
             'ExitTime': [t.exit_time for t in trades],
         })
-        trades_df['Duration'] = trades_df['ExitTime'] - trades_df['EntryTime']
+        trades_df['Duration'] = [
+            exit_time - entry_time if pd.notna(exit_time) else pd.NaT
+            for entry_time, exit_time in zip(trades_df['EntryTime'], trades_df['ExitTime'])
+        ]
         trades_df['Tag'] = [t.tag for t in trades]
 
         # Add indicator values
@@ -82,7 +85,10 @@ def compute_stats(
                 for i, values in enumerate(ind):  # multi-d indicators
                     suffix = f'_{i}' if len(ind) > 1 else ''
                     trades_df[f'Entry_{ind.name}{suffix}'] = values[trades_df['EntryBar'].values]
-                    trades_df[f'Exit_{ind.name}{suffix}'] = values[trades_df['ExitBar'].values]
+                    trades_df[f'Exit_{ind.name}{suffix}'] = [
+                        values[int(exit_bar)] if pd.notna(exit_bar) else np.nan
+                        for exit_bar in trades_df['ExitBar']
+                    ]
 
         commissions = sum(t._commissions for t in trades)
     del trades
@@ -104,7 +110,8 @@ def _round_timedelta(value, _period=_data_period(index)):
 
     have_position = np.repeat(0, len(index))
     for t in trades_df[['EntryBar', 'ExitBar']].itertuples(index=False):
-        have_position[t.EntryBar:t.ExitBar + 1] = 1
+        exit_bar = len(index) - 1 if pd.isna(t.ExitBar) else int(t.ExitBar)
+        have_position[t.EntryBar:exit_bar + 1] = 1
 
     s['Exposure Time [%]'] = have_position.mean() * 100  # In "n bars" time, not index time
     s['Equity Final [$]'] = equity[-1]

backtesting/backtesting.py

@@ -1184,6 +1184,8 @@ class Backtest:
     If `finalize_trades` is `True`, the trades that are still
     [active and ongoing] at the end of the backtest will be closed on
     the last bar and will contribute to the computed backtest statistics.
+    Otherwise, they remain open and are included in the trade history with
+    missing exit values.
 
     .. tip:: Fractional trading
         See also `backtesting.lib.FractionalBacktest` if you want to trade
@@ -1353,28 +1355,31 @@ def run(self, **kwargs) -> pd.Series:
                 # Next tick, a moment before bar close
                 strategy.next()
             else:
+                # HACK: Re-run broker one last time to handle orders placed in the last
+                # strategy iteration. Use the same OHLC values as in the last broker iteration.
+                if start < len(self._data):
+                    try_(broker.next, exception=_OutOfMoneyError)
+
                 if self._finalize_trades is True:
                     # Close any remaining open trades so they produce some stats
                     for trade in reversed(broker.trades):
                         trade.close()
 
-                    # HACK: Re-run broker one last time to handle close orders placed in the last
-                    #  strategy iteration. Use the same OHLC values as in the last broker iteration.
                     if start < len(self._data):
                         try_(broker.next, exception=_OutOfMoneyError)
                 elif len(broker.trades):
                     warnings.warn(
                         'Some trades remain open at the end of backtest. Use '
-                        '`Backtest(..., finalize_trades=True)` to close them and '
-                        'include them in stats.', stacklevel=2)
+                        '`Backtest(..., finalize_trades=True)` to close them.',
+                        stacklevel=2)
 
             # Set data back to full length
             # for future `indicator._opts['data'].index` calls to work
             data._set_length(len(self._data))
 
             equity = pd.Series(broker._equity).bfill().fillna(broker._cash).values
             self._results = compute_stats(
-                trades=broker.closed_trades,
+                trades=[*broker.closed_trades, *broker.trades],
                 equity=equity,
                 ohlc_data=self._data,
                 risk_free_rate=0.0,

backtesting/test/_test.py

@@ -473,10 +473,28 @@ def next(self):
                 elif len(self.data) == len(SHORT_DATA):
                     self.position.close()
 
-        with self.assertWarnsRegex(UserWarning, 'finalize_trades'):
-            self.assertTrue(Backtest(SHORT_DATA, S, finalize_trades=False).run()._trades.empty)
+        self.assertFalse(Backtest(SHORT_DATA, S, finalize_trades=False).run()._trades.empty)
         self.assertFalse(Backtest(SHORT_DATA, S, finalize_trades=True).run()._trades.empty)
 
+    def test_open_orders_from_last_strategy_iteration(self):
+        class S(_S):
+            def init(self):
+                self.price = self.I(lambda values: values, self.data.Close, name='Price')
+
+            def next(self):
+                if len(self.data) == len(SHORT_DATA):
+                    self.buy()
+
+        with self.assertWarnsRegex(UserWarning, 'finalize_trades'):
+            stats = Backtest(SHORT_DATA, S, finalize_trades=False).run()
+
+        trade = stats._trades.iloc[0]
+        self.assertEqual(trade.EntryBar, len(SHORT_DATA) - 1)
+        self.assertTrue(np.isnan(trade.ExitBar))
+        self.assertTrue(np.isnan(trade.ExitPrice))
+        self.assertTrue(np.isnan(trade.Exit_Price))
+        self.assertTrue(pd.isna(trade.ExitTime))
+
     def test_check_adjusted_price_when_placing_order(self):
         class S(_S):
             def next(self):
@@ -1018,7 +1036,7 @@ def init(self):
 
         with self.assertWarnsRegex(UserWarning, 'margin'):
             stats = Backtest(GOOG, S).run()
-        self.assertIn(stats['# Trades'], (1179, 1182))  # varies on different archs?
+        self.assertIn(stats['# Trades'], (1180, 1183))  # varies on different archs?
 
     def test_TrailingStrategy(self):
         class S(TrailingStrategy):