Merge branch 'release/1.8'

Author: gbeced

CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## 1.8
+
+### Features
+
+* Backtesting `OrderInfo` now includes pair and order fills.
+* Backtesting exchange returns a full `OrderInfo` when creating an order.
+* Backtesting exchange support for immediate order processing.
+
+### Bug fixes
+
+* Backtesting margin level calculations were wrong. `margin_requirement` was moved from `MarginLoanConditions` into `MarginLoans`
+
 ## 1.7.1
 
 ### Bug fixes
@@ -47,7 +59,7 @@
 
 ## 1.5.0
 
-* `basana.backtesting.fees.Percentage` now supports a minimum fee.
+* `backtesting.fees.Percentage` now supports a minimum fee.
 
 ## 1.4.1
 

README.md

@@ -26,7 +26,7 @@ $ pip install basana[charts] talipp pandas statsmodels
 
 ### Backtest a pairs trading strategy
 
-1. Download and unzip [samples](https://github.com/gbeced/basana/releases/download/1.7.1/samples.zip).
+1. Download and unzip [samples](https://github.com/gbeced/basana/releases/download/1.8/samples.zip).
 
 2. Download historical data for backtesting
 

basana/backtesting/account_balances.py

@@ -25,12 +25,18 @@
 
 class UpdateRule(metaclass=abc.ABCMeta):
     @abc.abstractmethod
-    def check(self, updated_balances: ValueMap, updated_holds: ValueMap, updated_borrowed: ValueMap):
+    def check(
+            self, updated_balances: ValueMap, updated_holds: ValueMap, updated_borrowed: ValueMap,
+            delta_balances: ValueMap, delta_holds: ValueMap, delta_borrowed: ValueMap
+    ):
         raise NotImplementedError()
 
 
 class NonZero(UpdateRule):
-    def check(self, updated_balances: ValueMap, updated_holds: ValueMap, updated_borrowed: ValueMap):
+    def check(
+            self, updated_balances: ValueMap, updated_holds: ValueMap, updated_borrowed: ValueMap,
+            delta_balances: ValueMap, delta_holds: ValueMap, delta_borrowed: ValueMap
+    ):
         # balance >= 0
         for symbol, value in updated_balances.items():
             if value < Decimal(0):
@@ -47,7 +53,10 @@ def check(self, updated_balances: ValueMap, updated_holds: ValueMap, updated_bor
 
 class ValidHold(UpdateRule):
     # * hold <= balance
-    def check(self, updated_balances: ValueMap, updated_holds: ValueMap, updated_borrowed: ValueMap):
+    def check(
+            self, updated_balances: ValueMap, updated_holds: ValueMap, updated_borrowed: ValueMap,
+            delta_balances: ValueMap, delta_holds: ValueMap, delta_borrowed: ValueMap
+    ):
         symbols = set(itertools.chain(updated_holds.keys(), updated_balances.keys()))
         for symbol in symbols:
             updated_hold = updated_holds.get(symbol, Decimal(0))
@@ -82,7 +91,10 @@ def update(
         updated_borrowed = self.borrowed + borrowed_updates
 
         for rule in self._update_rules:
-            rule.check(updated_balances, updated_holds, updated_borrowed)
+            rule.check(
+                updated_balances, updated_holds, updated_borrowed,
+                ValueMap(balance_updates), ValueMap(hold_updates), ValueMap(borrowed_updates)
+            )
 
         # Update if no error ocurred.
         self.balances = updated_balances

basana/backtesting/charts.py

@@ -166,8 +166,8 @@ async def _on_any_event(self, event: event.Event):
 
 
 class PortfolioValueLineChart(LineChart):
-    def __init__(self, symbol: str, exchange: Exchange, precision: int = 2):
-        self._symbol = symbol
+    def __init__(self, quote_symbol: str, exchange: Exchange, precision: int = 2):
+        self._quote_symbol = quote_symbol
         self._exchange = exchange
         self._ts = TimeSeries()
         self._precision = precision
@@ -177,12 +177,12 @@ def __init__(self, symbol: str, exchange: Exchange, precision: int = 2):
         exchange._get_dispatcher().subscribe_all(self._on_any_event)
 
     def get_title(self) -> str:
-        return f"Portfolio value in {self._symbol}"
+        return f"Portfolio value in {self._quote_symbol}"
 
     def add_traces(self, figure: go.Figure, row: int):
         # Add a trace with the portfolio values.
         x, y = self._ts.get_x_y()
-        figure.add_trace(go.Scatter(x=x, y=y, name=f"Portfolio ({self._symbol})"), row=row, col=1)
+        figure.add_trace(go.Scatter(x=x, y=y, name=f"Portfolio ({self._quote_symbol})"), row=row, col=1)
 
     async def _on_any_event(self, event: event.Event):
         portfolio_value = Decimal(0)
@@ -192,10 +192,11 @@ async def _on_any_event(self, event: event.Event):
                 continue
 
             try:
-                rate: Decimal = Decimal(1)
-                if symbol != self._symbol:
-                    rate, _ = await self._exchange.get_bid_ask(Pair(symbol, self._symbol))
-                portfolio_value += rate * balance.total
+                price = Decimal(1)
+                if symbol != self._quote_symbol:
+                    bid, ask = await self._exchange.get_bid_ask(Pair(symbol, self._quote_symbol))
+                    price = bid if balance.total > 0 else ask
+                portfolio_value += balance.total * price
             except errors.Error as e:
                 logger.debug(str(e))
 

basana/backtesting/errors.py

@@ -29,7 +29,3 @@ class NotEnoughBalance(Error):
 
 class NotFound(Error):
     pass
-
-
-class NoPrice(Error):
-    pass

basana/backtesting/exchange.py

@@ -14,6 +14,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from collections import defaultdict
 from decimal import Decimal
 from typing import cast, Callable, Dict, List, Optional, Sequence, Tuple
 import dataclasses
@@ -31,6 +32,7 @@
 
 BarEventHandler = bar.BarEventHandler
 Error = errors.Error
+Fill = orders.Fill
 LiquidityStrategyFactory = Callable[[], liquidity.LiquidityStrategy]
 OrderEvent = order_mgr.OrderEvent
 OrderEventHandler = order_mgr.OrderEventHandler
@@ -53,10 +55,8 @@ def __post_init__(self):
         self.total = self.available + self.hold - self.borrowed
 
 
-@dataclasses.dataclass
-class CreatedOrder:
-    #: The order id.
-    id: str
+class CreatedOrder(OrderInfo):
+    pass
 
 
 @dataclasses.dataclass
@@ -92,6 +92,8 @@ class Exchange:
         :meth:`Exchange.set_pair_info`.
     :param bid_ask_spread: The spread to use for :meth:`Exchange.get_bid_ask`.
     :param lending_strategy: The strategy to use for managing loans.
+    :param immediate_order_processing: If True, orders will be processed immediately after being added,
+        using the closing price of the last bar available. If False, orders will be processed in the next bar event.
     """
     def __init__(
             self,
@@ -101,11 +103,12 @@ def __init__(
             fee_strategy: fees.FeeStrategy = fees.NoFee(),
             default_pair_info: Optional[PairInfo] = PairInfo(base_precision=0, quote_precision=2),
             bid_ask_spread: Decimal = Decimal("0.5"),
-            lending_strategy: lending.LendingStrategy = lending.NoLoans()
+            lending_strategy: lending.LendingStrategy = lending.NoLoans(),
+            immediate_order_processing: bool = False
     ):
         self._dispatcher = dispatcher
         self._balances = account_balances.AccountBalances(initial_balances)
-        self._bar_event_source: Dict[Pair, event.FifoQueueEventSource] = {}
+        self._bar_event_source: Dict[Pair, event.FifoQueueEventSource] = defaultdict(event.FifoQueueEventSource)
         self._config = config.Config(None, default_pair_info)
         self._prices = prices.Prices(bid_ask_spread, self._config)
         self._loan_mgr = loan_mgr.LoanManager(
@@ -122,7 +125,8 @@ def __init__(
                 dispatcher=dispatcher, account_balances=self._balances, prices=self._prices,
                 fee_strategy=fee_strategy, liquidity_strategy_factory=liquidity_strategy_factory,
                 loan_mgr=self._loan_mgr, config=self._config
-            )
+            ),
+            immediate_order_processing=immediate_order_processing
         )
 
     async def get_balance(self, symbol: str) -> Balance:
@@ -161,7 +165,14 @@ async def create_order(self, order_request: requests.ExchangeOrder) -> CreatedOr
         order = order_request.create_order(uuid.uuid4().hex)
         self._order_mgr.add_order(order)
         logger.debug(logs.StructuredMessage("Request accepted", order_id=order.id))
-        return CreatedOrder(id=order.id)
+        order_info = order.get_order_info()
+        return CreatedOrder(
+            id=order_info.id, pair=order_info.pair, is_open=order_info.is_open, operation=order_info.operation,
+            amount=order_info.amount, amount_filled=order_info.amount_filled,
+            amount_remaining=order_info.amount_remaining, quote_amount_filled=order_info.quote_amount_filled,
+            fees=order_info.fees, limit_price=order_info.limit_price, stop_price=order_info.stop_price,
+            loan_ids=order_info.loan_ids, fills=order_info.fills,
+        )
 
     async def create_market_order(
             self, operation: OrderOperation, pair: Pair, amount: Decimal, auto_borrow: bool = False,
@@ -340,10 +351,7 @@ def subscribe_to_bar_events(self, pair: Pair, event_handler: BarEventHandler):
         :param event_handler: An async callable that receives a basana.BarEvent.
         """
         # Get/create the event source for the given pair.
-        event_source = self._bar_event_source.get(pair)
-        if event_source is None:
-            event_source = event.FifoQueueEventSource()
-            self._bar_event_source[pair] = event_source
+        event_source = self._bar_event_source[pair]
         self._dispatcher.subscribe(event_source, cast(dispatcher.EventHandler, event_handler))
 
     def subscribe_to_order_events(self, event_handler: OrderEventHandler):

basana/backtesting/lending/margin.py

@@ -36,8 +36,6 @@ class MarginLoanConditions:
     interest_period: datetime.timedelta
     #: The minimum interest to charge.
     min_interest: Decimal
-    # Minimum threshold for the value of the collateral relative to the loan amount + outstanding interests.
-    margin_requirement: Decimal
 
 
 class MarginLoan(base.Loan):
@@ -73,10 +71,17 @@ class MarginLoans(base.LendingStrategy):
     This strategy will use the accounts assets as collateral for the loans.
 
     :param quote_symbol: The symbol to use to normalize balances.
+    :param margin_requirement: Minimum threshold for the value of the collateral relative to the total position.
     :param default_conditions: The default margin loan conditions.
     """
-    def __init__(self, quote_symbol: str, default_conditions: Optional[MarginLoanConditions] = None):
+    def __init__(
+            self, quote_symbol: str, margin_requirement: Decimal,
+            default_conditions: Optional[MarginLoanConditions] = None
+    ):
+        assert margin_requirement > 0, "Margin requirement must be greater than zero"
+
         self._quote_symbol = quote_symbol
+        self._margin_requirement = margin_requirement
         self._conditions: Dict[str, MarginLoanConditions] = {}
         self._default_conditions = default_conditions
         self._loan_mgr: Optional[loan_mgr.LoanManager] = None
@@ -118,56 +123,47 @@ def margin_level(self) -> Decimal:
         """
         assert self._exchange_ctx, "Not yet connected with the exchange"
         acc_balances = self._exchange_ctx.account_balances
-        return self._calculate_margin_level(
+        return self.calculate_margin_level(
             acc_balances.balances, acc_balances.holds, acc_balances.borrowed
         )
 
-    def _calculate_margin_level(
+    def calculate_margin_level(
             self, updated_balances: ValueMapDict, updated_holds: ValueMapDict, updated_borrowed: ValueMapDict
     ) -> Decimal:
         assert self._exchange_ctx and self._loan_mgr, "Not yet connected with the exchange"
 
-        # Calculate used margin.
-        margin_requirements = ValueMap(
-            {symbol: self.get_conditions(symbol).margin_requirement for symbol in updated_borrowed}
-        )
-        used_margin_by_symbol = margin_requirements * updated_borrowed
-        used_margin = self._exchange_ctx.prices.convert_value_map(used_margin_by_symbol, self._quote_symbol)
-        if used_margin == Decimal(0):
-            return Decimal(0)
+        # If we haven't borrowed anything yet, the margin level is infinite.
+        if all(v == Decimal(0) for v in updated_borrowed.values()):
+            # used_margin = 0,  margin_level = Infinity
+            return Decimal("Infinity")
 
         # Calculate outstanding interest.
-        interest_by_symbol = ValueMap()
+        outstanding_interest = ValueMap()
         for loan in self._loan_mgr.get_loans(is_open=True):
-            interest_by_symbol += loan.outstanding_interest
-        interest = self._exchange_ctx.prices.convert_value_map(interest_by_symbol, self._quote_symbol)
-
-        # Calculate equity.
-        equity = Decimal(0)
-        for symbol, balance in updated_balances.items():
-            borrowed = updated_borrowed.get(symbol, Decimal(0))
-            net = balance - borrowed
-            if net <= Decimal(0):
-                continue
-
-            if symbol != self._quote_symbol:
-                net = self._exchange_ctx.prices.convert(net, symbol, self._quote_symbol)
+            outstanding_interest += loan.outstanding_interest
+        outstanding_interest = self._exchange_ctx.prices.convert_value_map(outstanding_interest, self._quote_symbol)
 
-            equity += net
-
-        return equity / (used_margin + interest) * Decimal(100)
-
-    def _check_margin_level(
-            self, updated_balances: ValueMapDict, updated_holds: ValueMapDict, updated_borrowed: ValueMapDict
-    ):
-        margin_level = self._calculate_margin_level(updated_balances, updated_holds, updated_borrowed)
-        if margin_level > Decimal(0) and margin_level < Decimal(100):
-            raise errors.NotEnoughBalance(f"Margin level too low {margin_level}")
+        # Calculate margin level.
+        borrowed = self._exchange_ctx.prices.convert_value_map(updated_borrowed, self._quote_symbol)
+        total_position_size = self._exchange_ctx.prices.convert_value_map(updated_balances, self._quote_symbol)
+        total_position_size -= outstanding_interest
+        equity = total_position_size - borrowed
+        used_margin = Decimal(sum(total_position_size.values())) * self._margin_requirement
+        margin_level = Decimal(sum(equity.values())) / used_margin * Decimal(100)
+        return margin_level
 
 
 class CheckMarginLevel(account_balances.UpdateRule):
     def __init__(self, margin_loans: MarginLoans):
         self._margin_loans = margin_loans
+        self._threshold = Decimal(100)
 
-    def check(self, updated_balances: ValueMapDict, updated_holds: ValueMapDict, updated_borrowed: ValueMapDict):
-        self._margin_loans._check_margin_level(updated_balances, updated_holds, updated_borrowed)
+    def check(
+            self, updated_balances: ValueMap, updated_holds: ValueMap, updated_borrowed: ValueMap,
+            delta_balances: ValueMap, delta_holds: ValueMap, delta_borrowed: ValueMap
+    ):
+        # If we're increasing any borrowed amount we need to check the margin level.
+        if any(v > 0 for v in delta_borrowed.values()):
+            margin_level = self._margin_loans.calculate_margin_level(updated_balances, updated_holds, updated_borrowed)
+            if margin_level < self._threshold:
+                raise errors.NotEnoughBalance(f"Margin level too low {margin_level}")