Cache calculations for pnl, total position size etc. when we are not changing positions at all. ~13% time saving

Author: ChadThackray

backtesting/backtesting.py

@@ -362,17 +362,21 @@ def __bool__(self):
     @property
     def size(self) -> float:
         """Position size in units of asset. Negative if position is short."""
-        return sum(trade.size for trade in self.__broker.trades)
+        if self.__broker._trade_sums_dirty:
+            self.__broker._recalculate_trade_sums()
+        return self.__broker._open_trade_size_sum
 
     @property
     def pl(self) -> float:
         """Profit (positive) or loss (negative) of the current position in cash units."""
-        return sum(trade.pl for trade in self.__broker.trades)
+        return self.__broker.unrealized_pl
 
     @property
     def pl_pct(self) -> float:
         """Profit (positive) or loss (negative) of the current position in percent."""
-        total_invested = sum(trade.entry_price * abs(trade.size) for trade in self.__broker.trades)
+        if self.__broker._trade_sums_dirty:
+            self.__broker._recalculate_trade_sums()
+        total_invested = self.__broker._open_trade_entry_abs_value_sum
         return (self.pl / total_invested) * 100 if total_invested else 0
 
     @property
@@ -772,6 +776,10 @@ def __init__(self, *, data, cash, spread, commission, margin,
         self.trades: List[Trade] = []
         self.position = Position(self)
         self.closed_trades: List[Trade] = []
+        self._trade_sums_dirty = True
+        self._open_trade_size_sum = 0
+        self._open_trade_entry_value_sum = 0.0
+        self._open_trade_entry_abs_value_sum = 0.0
 
     def _commission_func(self, order_size, price):
         return self._commission_fixed + abs(order_size) * price * self._commission_relative
@@ -829,6 +837,28 @@ def new_order(self,
 
         return order
 
+    def _mark_trade_sums_dirty(self) -> None:
+        self._trade_sums_dirty = True
+
+    def _recalculate_trade_sums(self) -> None:
+        self._open_trade_size_sum = sum(int(trade.size) for trade in self.trades)
+        self._open_trade_entry_value_sum = sum(
+            trade.size * trade.entry_price for trade in self.trades
+        )
+        self._open_trade_entry_abs_value_sum = sum(
+            abs(trade.size) * trade.entry_price for trade in self.trades
+        )
+        self._trade_sums_dirty = False
+
+    @property
+    def unrealized_pl(self) -> float:
+        if self._trade_sums_dirty:
+            self._recalculate_trade_sums()
+        if not self.trades:
+            return 0.0
+        current_price = float(self._data.current_value("Close"))
+        return current_price * self._open_trade_size_sum - self._open_trade_entry_value_sum
+
     @property
     def last_price(self) -> float:
         """ Price at the last (current) close. """
@@ -843,7 +873,7 @@ def _adjusted_price(self, size=None, price=None) -> float:
 
     @property
     def equity(self) -> float:
-        return self._cash + sum(trade.pl for trade in self.trades)
+        return self._cash + self.unrealized_pl
 
     @property
     def margin_available(self) -> float:
@@ -1071,6 +1101,7 @@ def _process_orders(self):
     def _reduce_trade(self, trade: Trade, price: float, size: float, time_index: int):
         assert trade.size * size < 0
         assert abs(trade.size) >= abs(size)
+        self._mark_trade_sums_dirty()
 
         size_left = trade.size + size
         assert size_left * trade.size >= 0
@@ -1091,6 +1122,7 @@ def _reduce_trade(self, trade: Trade, price: float, size: float, time_index: int
         self._close_trade(close_trade, price, time_index)
 
     def _close_trade(self, trade: Trade, price: float, time_index: int):
+        self._mark_trade_sums_dirty()
         self.trades.remove(trade)
         if trade._sl_order:
             self.orders.remove(trade._sl_order)
@@ -1114,6 +1146,7 @@ def _open_trade(self, price: float, size: int,
         self.trades.append(trade)
         # Apply broker commission at trade open
         self._cash -= self._commission(size, price)
+        self._mark_trade_sums_dirty()
         # Create SL/TP (bracket) orders.
         if tp:
             trade.tp = tp