bbstrader 0.1.91__py3-none-any.whl → 0.1.93__py3-none-any.whl

bbstrader/btengine/backtest.py

@@ -85,6 +85,8 @@ class BacktestEngine(Backtest):
             strategy (Strategy): Generates signals based on market data.
             kwargs : Additional parameters based on the `ExecutionHandler`, 
                 the `DataHandler`, the `Strategy` used and the `Portfolio`.
+                - show_equity (bool): Show the equity curve of the portfolio.
+                - stats_file (str): File to save the summary stats.
         """
         self.symbol_list = symbol_list
         self.initial_capital = initial_capital
@@ -104,6 +106,7 @@ class BacktestEngine(Backtest):
 
         self._generate_trading_instances()
         self.show_equity = kwargs.get("show_equity", False)
+        self.stats_file = kwargs.get("stats_file", None)
 
     def _generate_trading_instances(self):
         """
@@ -111,8 +114,9 @@ class BacktestEngine(Backtest):
         their class types.
         """
         print(
-            f"\nStarting Backtest on {self.symbol_list} "
-            f"with ${self.initial_capital} Initial Capital\n"
+            f"\n[=======   STARTING BACKTEST   =======]\n"
+            f"START DATE: {self.start_date} \n"
+            f"INITIAL CAPITAL: {self.initial_capital}\n"
         )
         self.data_handler: DataHandler = self.dh_cls(
             self.events, self.symbol_list, **self.kwargs
@@ -136,13 +140,21 @@ class BacktestEngine(Backtest):
         i = 0
         while True:
             i += 1
-            # Update the market bars
+            value = self.portfolio.all_holdings[-1]['Total']
             if self.data_handler.continue_backtest == True:
+                # Update the market bars
                 self.data_handler.update_bars()
                 self.strategy.check_pending_orders()
+                self.strategy.get_update_from_portfolio(
+                    self.portfolio.current_positions,
+                    self.portfolio.current_holdings
+                )
+                self.strategy.cash = value
             else:
-                print("\n[======= BACKTEST COMPLETE =======]\n")
-                print(f"Total bars: {i} ")
+                print("\n[======= BACKTEST COMPLETED =======]")
+                print(f"END DATE: {self.data_handler.get_latest_bar_datetime(self.symbol_list[0])}")
+                print(f"TOTAL BARS: {i} ")
+                print(f"PORFOLIO VALUE: {round(value, 2)}")
                 break
 
             # Handle the events
@@ -168,6 +180,7 @@ class BacktestEngine(Backtest):
                         elif event.type == 'FILL':
                             self.fills += 1
                             self.portfolio.update_fill(event)
+                            self.strategy.update_trades_from_fill(event)
 
             time.sleep(self.heartbeat)
 
@@ -185,13 +198,13 @@ class BacktestEngine(Backtest):
         stat2['Orders'] = self.orders
         stat2['Fills'] = self.fills
         stats.extend(stat2.items())
-        print(
-            tabulate(
-                stats, 
-                headers=["Metric", "Value"], 
-                tablefmt="outline"), 
-                "\n"
-            )
+        tab_stats = tabulate(stats, headers=["Metric", "Value"], tablefmt="outline")
+        print(tab_stats, "\n")
+        if self.stats_file:
+            with open(self.stats_file, 'a') as f:
+                f.write("\n[======= Summary Stats =======]\n")
+                f.write(tab_stats)
+                f.write("\n")
 
         if self.show_equity:
             print("\nCreating equity curve...")
@@ -329,7 +342,7 @@ def run_backtest_with(engine: Literal["bbstrader", "cerebro", "zipline"], **kwar
             data_handler=kwargs.get("data_handler"),
             strategy=kwargs.get("strategy"),
             exc_handler=kwargs.get("exc_handler"),
-            initial_capital=kwargs.get("initial_capital"),
+            initial_capital=kwargs.get("initial_capital", 100000.0),
             heartbeat=kwargs.get("heartbeat", 0.0),
             **kwargs
         )

bbstrader/btengine/data.py

@@ -272,7 +272,11 @@ class BaseCSVDataHandler(DataHandler):
             print("Symbol not available in the historical data set.")
             raise
         else:
-            return getattr(bars_list[-1][1], val_type)
+            try:
+                return getattr(bars_list[-1][1], val_type)
+            except AttributeError:
+                print(f"Value type {val_type} not available in the historical data set.")
+                raise
 
     def get_latest_bars_values(self, symbol: str, val_type: str, N=1) -> np.ndarray:
         """
@@ -285,7 +289,11 @@ class BaseCSVDataHandler(DataHandler):
             print("That symbol is not available in the historical data set.")
             raise
         else:
-            return np.array([getattr(b[1], val_type) for b in bars_list])
+            try:
+                return np.array([getattr(b[1], val_type) for b in bars_list])
+            except AttributeError:
+                print(f"Value type {val_type} not available in the historical data set.")
+                raise
 
     def update_bars(self):
         """

bbstrader/btengine/event.py

@@ -102,14 +102,15 @@ class OrderEvent(Event):
 
     def __init__(self,
                  symbol: str,
-                 order_type: Literal['MKT', 'LMT'],
+                 order_type: Literal['MKT', 'LMT', 'STP', 'STPLMT'],
                  quantity: int | float,
                  direction: Literal['BUY', 'SELL'],
-                 price: int | float = None
+                 price: int | float = None,
+                 signal: str = None
                  ):
         """
         Initialises the order type, setting whether it is
-        a Market order ('MKT') or Limit order ('LMT'), has
+        a Market order ('MKT') or Limit order ('LMT'), or Stop order ('STP').
         a quantity (integral or float) and its direction ('BUY' or 'SELL').
 
         Args:
@@ -118,6 +119,7 @@ class OrderEvent(Event):
             quantity (int | float): Non-negative number for quantity.            
             direction (str): 'BUY' or 'SELL' for long or short.
             price (int | float): The price at which to order.
+            signal (str): The signal that generated the order.
         """
         self.type = 'ORDER'
         self.symbol = symbol
@@ -125,6 +127,7 @@ class OrderEvent(Event):
         self.quantity = quantity
         self.direction = direction
         self.price = price
+        self.signal = signal
 
         def print_order(self):
             """
@@ -162,7 +165,8 @@ class FillEvent(Event):
                  quantity: int | float,
                  direction: Literal['BUY', 'SELL'],
                  fill_cost: int | float | None,
-                 commission: float | None = None
+                 commission: float | None = None,
+                 order: str = None
                  ):
         """
         Initialises the FillEvent object. Sets the symbol, exchange,
@@ -181,6 +185,7 @@ class FillEvent(Event):
             direction (str): The direction of fill `('LONG', 'SHORT', 'EXIT')`
             fill_cost (int | float): Price of the shares when filled.
             commission (float | None): An optional commission sent from IB.
+            order (str): The order that this fill is related
         """
         self.type = 'FILL'
         self.timeindex = timeindex
@@ -194,6 +199,7 @@ class FillEvent(Event):
             self.commission = self.calculate_ib_commission()
         else:
             self.commission = commission
+        self.order = order
 
     def calculate_ib_commission(self):
         """

bbstrader/btengine/execution.py

@@ -4,7 +4,6 @@ from abc import ABCMeta, abstractmethod
 from bbstrader.btengine.event import FillEvent, OrderEvent
 from bbstrader.btengine.data import DataHandler
 from bbstrader.metatrader.account import Account
-from bbstrader.config import config_logger
 
 __all__ = [
     "ExecutionHandler",
@@ -26,7 +25,8 @@ class ExecutionHandler(metaclass=ABCMeta):
 
     The ExecutionHandler described here is exceedingly simple, 
     since it fills all orders at the current market price. 
-    This is highly unrealistic, but serves as a good baseline for improvement.
+    This is highly unrealistic, for other markets thant ``CFDs`` 
+    but serves as a good baseline for improvement.
     """
 
     @abstractmethod
@@ -64,7 +64,7 @@ class SimExecutionHandler(ExecutionHandler):
         """
         self.events = events
         self.bardata = data
-        self.logger = kwargs.get("logger", config_logger("execution.log"))
+        self.logger = kwargs.get("logger")
 
     def execute_order(self, event: OrderEvent):
         """
@@ -77,8 +77,9 @@ class SimExecutionHandler(ExecutionHandler):
         if event.type == 'ORDER':
             dtime = self.bardata.get_latest_bar_datetime(event.symbol)
             fill_event = FillEvent(
-                dtime, event.symbol,
-                'ARCA', event.quantity, event.direction, None
+                timeindex=dtime, symbol=event.symbol,
+                exchange='ARCA', quantity=event.quantity, direction=event.direction,
+                fill_cost=None, commission=None, order=event.signal
             )
             self.events.put(fill_event)
             self.logger.info(
@@ -121,7 +122,7 @@ class MT5ExecutionHandler(ExecutionHandler):
         """
         self.events = events
         self.bardata = data
-        self.logger = kwargs.get("logger", config_logger("execution.log"))
+        self.logger = kwargs.get("logger")
         self.__account = Account()
 
     def _calculate_lot(self, symbol, quantity, price):
@@ -232,7 +233,7 @@ class MT5ExecutionHandler(ExecutionHandler):
             fill_event = FillEvent(
                 timeindex=dtime, symbol=symbol,
                 exchange='MT5', quantity=quantity, direction=direction,
-                fill_cost=None, commission=fees
+                fill_cost=None, commission=fees, order=event.signal
             )
             self.events.put(fill_event)
             self.logger.info(

bbstrader/btengine/performance.py

@@ -6,6 +6,8 @@ from scipy.stats import mstats
 import matplotlib.pyplot as plt
 from matplotlib.ticker import MaxNLocator
 import quantstats as qs
+import warnings
+warnings.filterwarnings("ignore")
 
 sns.set_theme()
 

bbstrader/btengine/portfolio.py

@@ -31,8 +31,6 @@ class Portfolio(object):
     """
     This  describes a `Portfolio()` object that keeps track of the positions 
     within a portfolio and generates orders of a fixed quantity of stock based on signals. 
-    More sophisticated portfolio objects could include risk management and position 
-    sizing tools (such as the `Kelly Criterion`).
 
     The portfolio order management system is possibly the most complex component of 
     an event driven backtester. Its role is to keep track of all current market positions 
@@ -57,10 +55,9 @@ class Portfolio(object):
     value (defaulting to `100,000 USD`) and others parameter based on the `Strategy` requirement.
 
     The `Portfolio` is designed to handle position sizing and current holdings, 
-    but will carry out trading orders in a "dumb" manner by simply sending them directly 
-    to the brokerage with a predetermined fixed quantity size, irrespective of cash held. 
-    These are all unrealistic assumptions, but they help to outline how a portfolio order 
-    management system (OMS) functions in an eventdriven fashion.
+    but will carry out trading orders by simply them to the brokerage with a predetermined 
+    fixed quantity size, if the portfolio has enough cash to place the order.
+
 
     The portfolio contains the `all_positions` and `current_positions` members. 
     The former stores a list of all previous positions recorded at the timestamp of a market data event. 
@@ -96,19 +93,23 @@ class Portfolio(object):
             initial_capital (float): The starting capital in USD.
 
             kwargs (dict): Additional arguments
+                - `leverage`: The leverage to apply to the portfolio.
                 - `time_frame`: The time frame of the bars.
-                - `trading_hours`: The number of trading hours in a day.
+                - `session_duration`: The number of trading hours in a day.
                 - `benchmark`: The benchmark symbol to compare the portfolio.
-                - `strategy_name`: The name of the strategy  (the name must not include 'Strategy' in it).    
+                - `output_dir`: The directory to save the backtest results.
+                - `strategy_name`: The name of the strategy  (the name must not include 'Strategy' in it). 
+                - `print_stats`: Whether to print the backtest statistics.   
         """
         self.bars = bars
         self.events = events
         self.symbol_list = self.bars.symbol_list
         self.start_date = start_date
         self.initial_capital = initial_capital
+        self._leverage = kwargs.get('leverage', 1)
 
         self.timeframe = kwargs.get("time_frame", "D1")
-        self.trading_hours = kwargs.get("session_duration", 6.5)
+        self.trading_hours = kwargs.get("session_duration", 23)
         self.benchmark = kwargs.get('benchmark', 'SPY')
         self.output_dir = kwargs.get('output_dir', None)
         self.strategy_name = kwargs.get('strategy_name', '')
@@ -174,6 +175,23 @@ class Portfolio(object):
         d['Commission'] = 0.0
         d['Total'] = self.initial_capital
         return d
+    
+    def _get_price(self, symbol: str) -> float:
+        try:
+            price = self.bars.get_latest_bar_value(
+                symbol, "adj_close"
+            )
+            return price
+        except AttributeError:
+            try:
+                price = self.bars.get_latest_bar_value(
+                    symbol, "close"
+                )
+                return price
+            except AttributeError:
+                raise AttributeError(
+                    f"Bars object must have 'adj_close' or 'close' prices"
+                )
 
     def update_timeindex(self, event: MarketEvent):
         """
@@ -203,8 +221,8 @@ class Portfolio(object):
         dh['Total'] = self.current_holdings['Cash']
         for s in self.symbol_list:
             # Approximation to the real value
-            market_value = self.current_positions[s] * \
-                self.bars.get_latest_bar_value(s, "adj_close")
+            price = self._get_price(s)
+            market_value = self.current_positions[s] * price
             dh[s] = market_value
             dh['Total'] += market_value
 
@@ -245,9 +263,7 @@ class Portfolio(object):
             fill_dir = -1
 
         # Update holdings list with new quantities
-        price = self.bars.get_latest_bar_value(
-            fill.symbol, "adj_close"
-        )
+        price = self._get_price(fill.symbol)
         cost = fill_dir * price * fill.quantity
         self.current_holdings[fill.symbol] += cost
         self.current_holdings['Commission'] += fill.commission
@@ -263,14 +279,15 @@ class Portfolio(object):
             self.update_positions_from_fill(event)
             self.update_holdings_from_fill(event)
 
-    def generate_naive_order(self, signal: SignalEvent):
+    def generate_order(self, signal: SignalEvent):
         """
-        Simply files an Order object as a constant quantity
-        sizing of the signal object, without risk management or
-        position sizing considerations.
+        Turns a SignalEvent into an OrderEvent.
 
         Args:
             signal (SignalEvent): The tuple containing Signal information.
+        
+        Returns:
+            OrderEvent: The OrderEvent to be executed.
         """
         order = None
 
@@ -278,31 +295,36 @@ class Portfolio(object):
         direction = signal.signal_type
         quantity = signal.quantity
         strength = signal.strength
-        price = signal.price
+        price = signal.price or self._get_price(symbol)
         cur_quantity = self.current_positions[symbol]
+        mkt_quantity = round(quantity * strength, 2)
+        new_quantity = mkt_quantity * self._leverage
 
-        order_type = 'MKT'
-        mkt_quantity = round(quantity * strength)
+        if direction in ['LONG', 'SHORT', 'EXIT']:
+            order_type = 'MKT'
+        else:
+            order_type = direction
 
-        if direction == 'LONG' and cur_quantity == 0:
-            order = OrderEvent(symbol, order_type, mkt_quantity, 'BUY', price)
-        if direction == 'SHORT' and cur_quantity == 0:
-            order = OrderEvent(symbol, order_type, mkt_quantity, 'SELL', price)
+        if  direction == 'LONG' and new_quantity > 0: 
+            order = OrderEvent(symbol, order_type, new_quantity, 'BUY', price, direction)
+        if direction == 'SHORT' and new_quantity > 0:
+            order = OrderEvent(symbol, order_type, new_quantity, 'SELL', price, direction)
 
         if direction == 'EXIT' and cur_quantity > 0:
-            order = OrderEvent(symbol, order_type, abs(cur_quantity), 'SELL', price)
+            order = OrderEvent(symbol, order_type, abs(cur_quantity), 'SELL', price, direction)
         if direction == 'EXIT' and cur_quantity < 0:
-            order = OrderEvent(symbol, order_type, abs(cur_quantity), 'BUY', price)
+            order = OrderEvent(symbol, order_type, abs(cur_quantity), 'BUY', price, direction)
 
         return order
 
+
     def update_signal(self, event: SignalEvent):
         """
         Acts on a SignalEvent to generate new orders
         based on the portfolio logic.
         """
         if event.type == 'SIGNAL':
-            order_event = self.generate_naive_order(event)
+            order_event = self.generate_order(event)
             self.events.put(order_event)
 
     def create_equity_curve_dataframe(self):