feat: adding the option to use returns in addition to prices

bktest/account.py

@@ -1,3 +1,4 @@
+import datetime
 import sys
 import typing
 
@@ -6,6 +7,8 @@
 from .order import CloseResult, Order, OrderResult
 from .utils import is_blank
 
+EPSILON = 1e-10
+
 
 class Account:
 
@@ -22,16 +25,25 @@ def __init__(
         self.total_short = 0
         self._holdings: typing.Dict[str, Holding] = dict()
 
+    # TODO: change value to equity
     @property
-    def value(self) -> float:
+    def equity(self) -> float:
         return sum(
             holding.market_price
             for holding in self._holdings.values()
         )
 
     @property
-    def equity(self) -> float:
-        return self.cash + self.value
+    def equity_long(self) -> float:
+        return sum(
+            holding.market_price
+            for holding in self._holdings.values()
+            if holding.market_price > 0
+        )
+
+    @property
+    def nav(self) -> float:
+        return self.cash + self.equity
 
     @property
     def symbols(self) -> typing.Set[str]:
@@ -44,75 +56,85 @@ def holdings(self) -> typing.List[Holding]:
     def find_holding(self, symbol: str):
         return self._holdings.get(symbol, None)
 
-    def place_order(self, order: Order) -> OrderResult:
+    def place_order(self, order: Order, date: datetime.date) -> OrderResult:
         result = OrderResult(order=order)
         if not order.valid:
             return result
 
         result.success = True
 
-        if order.quantity == 0:
-            return result
-
         result.fee = self.fee_model.get_order_fee(order)
 
         self._handle_cash(order, result.fee)
 
+        # Handle holdings in the account.
         holding = self.find_holding(order.symbol)
 
         if holding:
+            assert holding.last_date_updated == date, "holding price is not up-to-date"
             holding.merge(order)
 
-            if not holding.quantity:
-                del self._holdings[order.symbol]
         else:
-            self._holdings[order.symbol] = Holding.from_order(order)
-
+            self._holdings[order.symbol] = Holding(
+                order.symbol,
+                order.quantity,
+                order.price,
+                date = date
+            )
+
+        if abs(self._holdings[order.symbol].quantity) < EPSILON:  # if quantity is zero
+            del self._holdings[order.symbol]
+
         return result
 
-    def order_position(self, order: Order) -> OrderResult:
-        relative = self.to_relative_order(order)
+    def order_position(self, order: Order, date) -> OrderResult:
+        relative = self.to_relative_order(order, date)
 
-        return self.place_order(relative)
+        return self.place_order(relative, date)
 
     def close_position(self, symbol: str, price: float = None) -> CloseResult:
         order = Order(symbol, 0, price)
         result = CloseResult(order=order)
 
-        if is_blank(order.symbol):
+        if not order.valid:
+            # TODO: Should be an ERROR?
             return result
 
-        result.success = True
-
         holding = self.find_holding(order.symbol)
 
         if holding:
             order.quantity = -holding.quantity
 
+            # If the symbol is not traded on date the price is None.
             if order.price is None:
                 order.price = holding.price
-                print(f"[warning] no price available for {order.symbol}, using last price: {order.price}", file=sys.stderr)
+                print(f"[warning] in close_position no price available for {order.symbol}, using last price: {order.price}", file=sys.stderr)
 
             result.fee = self.fee_model.get_order_fee(order)
 
             self._handle_cash(order, result.fee)
 
             del self._holdings[order.symbol]
+
+            result.success = True
         else:
+            # TODO: Should be an ERROR?
             result.missing = True
 
         return result
 
-    def to_relative_order(self, order: Order):
+    def to_relative_order(self, order: Order, date: datetime.date):
         holding = self.find_holding(order.symbol)
 
         if not holding or order.quantity is None:
             return order
 
+        assert holding.last_date_updated == date
+
         return Order(
             order.symbol,
             order.quantity - holding.quantity,
-            order.price
+            order.price,
         )
 
     def _handle_cash(self, order: Order, fee: float):