Rename members ...

Author: kernc

backtesting/backtesting.py

@@ -344,17 +344,17 @@ def __bool__(self):
     @property
     def size(self) -> float:
         """Position size in units of asset. Negative if position is short."""
-        return self.__broker._open_trade_size_sum
+        return self.__broker._position_size
 
     @property
     def pl(self) -> float:
         """Profit (positive) or loss (negative) of the current position in cash units."""
-        return self.__broker.unrealized_pl
+        return self.__broker._position_unrealized_pl
 
     @property
     def pl_pct(self) -> float:
         """Profit (positive) or loss (negative) of the current position in percent."""
-        total_invested = self.__broker._open_trade_entry_abs_value_sum
+        total_invested = self.__broker._position_initial_value
         return (self.pl / total_invested) * 100 if total_invested else 0
 
     @property
@@ -812,28 +812,22 @@ def new_order(self,
         return order
 
     @cached_property
-    def _open_trade_size_sum(self) -> int:
+    def _position_size(self) -> int:
         return sum(int(trade.size) for trade in self.trades)
 
     @cached_property
-    def _open_trade_entry_value_sum(self) -> float:
-        return sum(trade.size * trade.entry_price for trade in self.trades)
+    def _position_initial_value(self) -> float:
+        return sum(abs(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 _position_unrealized_pl(self) -> float:
+        return (self.last_price * self._position_size -
+                sum(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 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
+    def _trades_cache_clear(self) -> None:
+        self.__dict__.pop(self.__class__._position_size.func.__name__, None)
+        self.__dict__.pop(self.__class__._position_initial_value.func.__name__, None)
+        self.__dict__.pop(self.__class__._position_unrealized_pl.func.__name__, None)
 
     @property
     def last_price(self) -> float:
@@ -849,7 +843,7 @@ def _adjusted_price(self, size=None, price=None) -> float:
 
     @property
     def equity(self) -> float:
-        return self._cash + self.unrealized_pl
+        return self._cash + self._position_unrealized_pl
 
     @property
     def margin_available(self) -> float:
@@ -858,6 +852,9 @@ def margin_available(self) -> float:
         return max(0, self.equity - margin_used)
 
     def next(self):
+        # Reset cached value here due to price change on every bar
+        self.__dict__.pop(self.__class__._position_unrealized_pl.func.__name__, None)
+
         i = self._i = len(self._data) - 1
         self._process_orders()
 
@@ -1054,7 +1051,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._clear_trade_caches()
+        self._trades_cache_clear()
 
         size_left = trade.size + size
         assert size_left * trade.size >= 0
@@ -1075,7 +1072,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._clear_trade_caches()
+        self._trades_cache_clear()
         self.trades.remove(trade)
         if trade._sl_order:
             self.orders.remove(trade._sl_order)
@@ -1097,9 +1094,9 @@ def _open_trade(self, price: float, size: int,
                     sl: Optional[float], tp: Optional[float], time_index: int, tag):
         trade = Trade(self, size, price, time_index, tag)
         self.trades.append(trade)
+        self._trades_cache_clear()
         # Apply broker commission at trade open
         self._cash -= self._commission(size, price)
-        self._clear_trade_caches()
         # Create SL/TP (bracket) orders.
         if tp:
             trade.tp = tp