Replace hand-rolled cache with @cached_property

Author: ChadThackray

backtesting/backtesting.py

@@ -13,7 +13,7 @@
 from abc import ABCMeta, abstractmethod
 from copy import copy
 from difflib import get_close_matches
-from functools import lru_cache, partial
+from functools import cached_property, lru_cache, partial
 from itertools import chain, product, repeat
 from math import copysign
 from numbers import Number
@@ -344,8 +344,6 @@ def __bool__(self):
     @property
     def size(self) -> float:
         """Position size in units of asset. Negative if position is short."""
-        if self.__broker._trade_sums_dirty:
-            self.__broker._recalculate_trade_sums()
         return self.__broker._open_trade_size_sum
 
     @property
@@ -356,8 +354,6 @@ def pl(self) -> float:
     @property
     def pl_pct(self) -> float:
         """Profit (positive) or loss (negative) of the current position in percent."""
-        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
 
@@ -758,10 +754,6 @@ 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
@@ -819,23 +811,25 @@ def new_order(self,
 
         return order
 
-    def _mark_trade_sums_dirty(self) -> None:
-        self._trade_sums_dirty = True
+    @cached_property
+    def _open_trade_size_sum(self) -> int:
+        return sum(int(trade.size) for trade in self.trades)
 
-    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
+    @cached_property
+    def _open_trade_entry_value_sum(self) -> float:
+        return sum(trade.size * trade.entry_price for trade in self.trades)
+
+    @cached_property
+    def _open_trade_entry_abs_value_sum(self) -> float:
+        return sum(abs(trade.size) * trade.entry_price for trade in self.trades)
+
+    def _clear_trade_caches(self) -> None:
+        self.__dict__.pop('_open_trade_size_sum', None)
+        self.__dict__.pop('_open_trade_entry_value_sum', None)
+        self.__dict__.pop('_open_trade_entry_abs_value_sum', None)
 
     @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"))
@@ -1086,7 +1080,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()
+        self._clear_trade_caches()
 
         size_left = trade.size + size
         assert size_left * trade.size >= 0
@@ -1107,7 +1101,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._clear_trade_caches()
         self.trades.remove(trade)
         if trade._sl_order:
             self.orders.remove(trade._sl_order)
@@ -1131,7 +1125,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()
+        self._clear_trade_caches()
         # Create SL/TP (bracket) orders.
         if tp:
             trade.tp = tp