bbstrader 0.3.5__py3-none-any.whl → 0.3.7__py3-none-any.whl

bbstrader/btengine/execution.py

@@ -1,5 +1,6 @@
 from abc import ABCMeta, abstractmethod
 from queue import Queue
+from typing import Any, Union
 
 from loguru import logger
 
@@ -39,7 +40,7 @@ class ExecutionHandler(metaclass=ABCMeta):
     """
 
     @abstractmethod
-    def execute_order(self, event: OrderEvent):
+    def execute_order(self, event: OrderEvent) -> None:
         """
         Takes an Order event and executes it, producing
         a Fill event that gets placed onto the Events queue.
@@ -47,7 +48,7 @@ class ExecutionHandler(metaclass=ABCMeta):
         Args:
             event (OrderEvent): Contains an Event object with order information.
         """
-        pass
+        raise NotImplementedError("Should implement execute_order()")
 
 
 class SimExecutionHandler(ExecutionHandler):
@@ -61,7 +62,12 @@ class SimExecutionHandler(ExecutionHandler):
     handler.
     """
 
-    def __init__(self, events: Queue, data: DataHandler, **kwargs):
+    def __init__(
+        self,
+        events: "Queue[Union[FillEvent, OrderEvent]]",
+        data: DataHandler,
+        **kwargs: Any,
+    ) -> None:
         """
         Initialises the handler, setting the event queues
         up internally.
@@ -75,7 +81,7 @@ class SimExecutionHandler(ExecutionHandler):
         self.commissions = kwargs.get("commission")
         self.exchange = kwargs.get("exchange", "ARCA")
 
-    def execute_order(self, event: OrderEvent):
+    def execute_order(self, event: OrderEvent) -> None:
         """
         Simply converts Order objects into Fill objects naively,
         i.e. without any latency, slippage or fill ratio problems.
@@ -86,7 +92,7 @@ class SimExecutionHandler(ExecutionHandler):
         if event.type == Events.ORDER:
             dtime = self.bardata.get_latest_bar_datetime(event.symbol)
             fill_event = FillEvent(
-                timeindex=dtime,
+                timeindex=dtime,  # type: ignore
                 symbol=event.symbol,
                 exchange=self.exchange,
                 quantity=event.quantity,
@@ -96,9 +102,10 @@ class SimExecutionHandler(ExecutionHandler):
                 order=event.signal,
             )
             self.events.put(fill_event)
+            price = event.price or 0.0
             self.logger.info(
                 f"{event.direction} ORDER FILLED: SYMBOL={event.symbol}, "
-                f"QUANTITY={event.quantity}, PRICE @{round(event.price, 5)} EXCHANGE={fill_event.exchange}",
+                f"QUANTITY={event.quantity}, PRICE @{round(price, 5)} EXCHANGE={fill_event.exchange}",
                 custom_time=fill_event.timeindex,
             )
 
@@ -128,7 +135,12 @@ class MT5ExecutionHandler(ExecutionHandler):
         This class only works with `bbstrader.metatrader.data.MT5DataHandler` class.
     """
 
-    def __init__(self, events: Queue, data: DataHandler, **kwargs):
+    def __init__(
+        self,
+        events: "Queue[Union[FillEvent, OrderEvent]]",
+        data: DataHandler,
+        **kwargs: Any,
+    ) -> None:
         """
         Initialises the handler, setting the event queues up internally.
 
@@ -142,14 +154,16 @@ class MT5ExecutionHandler(ExecutionHandler):
         self.exchange = kwargs.get("exchange", "MT5")
         self.__account = Account(**kwargs)
 
-    def _calculate_lot(self, symbol, quantity, price):
+    def _calculate_lot(
+        self, symbol: str, quantity: Union[int, float], price: Union[int, float]
+    ) -> float:
         symbol_type = self.__account.get_symbol_type(symbol)
         symbol_info = self.__account.get_symbol_info(symbol)
         contract_size = symbol_info.trade_contract_size
 
         lot = (quantity * price) / (contract_size * price)
         if contract_size == 1:
-            lot = quantity
+            lot = float(quantity)
         if (
             symbol_type
             in (SymbolType.COMMODITIES, SymbolType.FUTURES, SymbolType.CRYPTO)
@@ -157,18 +171,24 @@ class MT5ExecutionHandler(ExecutionHandler):
         ):
             lot = quantity / contract_size
         if symbol_type == SymbolType.FOREX:
-            lot = quantity * price / contract_size
+            lot = float(quantity * price / contract_size)
         return self._check_lot(symbol, lot)
 
-    def _check_lot(self, symbol, lot):
+    def _check_lot(self, symbol: str, lot: float) -> float:
         symbol_info = self.__account.get_symbol_info(symbol)
         if lot < symbol_info.volume_min:
-            return symbol_info.volume_min
+            return float(symbol_info.volume_min)
         elif lot > symbol_info.volume_max:
-            return symbol_info.volume_max
+            return float(symbol_info.volume_max)
         return round(lot, 2)
 
-    def _estimate_total_fees(self, symbol, lot, qty, price):
+    def _estimate_total_fees(
+        self,
+        symbol: str,
+        lot: float,
+        qty: Union[int, float],
+        price: Union[int, float],
+    ) -> float:
         symbol_type = self.__account.get_symbol_type(symbol)
         if symbol_type in (SymbolType.STOCKS, SymbolType.ETFs):
             return self._estimate_stock_commission(symbol, qty, price)
@@ -185,7 +205,9 @@ class MT5ExecutionHandler(ExecutionHandler):
         else:
             return 0.0
 
-    def _estimate_stock_commission(self, symbol, qty, price):
+    def _estimate_stock_commission(
+        self, symbol: str, qty: Union[int, float], price: Union[int, float]
+    ) -> float:
         # https://admiralmarkets.com/start-trading/contract-specifications?regulator=jsc
         min_com = 1.0
         min_aud = 8.0
@@ -220,22 +242,22 @@ class MT5ExecutionHandler(ExecutionHandler):
             else:
                 return max(min_com, qty * price * eu_asia_cm)
 
-    def _estimate_forex_commission(self, lot):
+    def _estimate_forex_commission(self, lot: float) -> float:
         return 3.0 * lot
 
-    def _estimate_commodity_commission(self, lot):
+    def _estimate_commodity_commission(self, lot: float) -> float:
         return 3.0 * lot
 
-    def _estimate_index_commission(self, lot):
+    def _estimate_index_commission(self, lot: float) -> float:
         return 0.25 * lot
 
-    def _estimate_futures_commission(self):
+    def _estimate_futures_commission(self) -> float:
         return 0.0
 
-    def _estimate_crypto_commission(self):
+    def _estimate_crypto_commission(self) -> float:
         return 0.0
 
-    def execute_order(self, event: OrderEvent):
+    def execute_order(self, event: OrderEvent) -> None:
         """
         Executes an Order event by converting it into a Fill event.
 
@@ -247,12 +269,14 @@ class MT5ExecutionHandler(ExecutionHandler):
             direction = event.direction
             quantity = event.quantity
             price = event.price
+            if price is None:
+                price = self.bardata.get_latest_bar_value(symbol, "close")
             lot = self._calculate_lot(symbol, quantity, price)
             fees = self._estimate_total_fees(symbol, lot, quantity, price)
             dtime = self.bardata.get_latest_bar_datetime(symbol)
             commission = self.commissions or fees
             fill_event = FillEvent(
-                timeindex=dtime,
+                timeindex=dtime,  # type: ignore
                 symbol=symbol,
                 exchange=self.exchange,
                 quantity=quantity,
@@ -262,11 +286,14 @@ class MT5ExecutionHandler(ExecutionHandler):
                 order=event.signal,
             )
             self.events.put(fill_event)
+            log_price = event.price or 0.0
             self.logger.info(
                 f"{direction} ORDER FILLED: SYMBOL={symbol}, QUANTITY={quantity}, "
-                f"PRICE @{round(event.price, 5)} EXCHANGE={fill_event.exchange}",
+                f"PRICE @{round(log_price, 5)} EXCHANGE={fill_event.exchange}",
                 custom_time=fill_event.timeindex,
             )
 
 
-class IBExecutionHandler(ExecutionHandler): ...
+class IBExecutionHandler(ExecutionHandler):
+    def execute_order(self, event: OrderEvent) -> None:
+        raise NotImplementedError("Should implement execute_order()")

bbstrader/btengine/performance.py

@@ -1,4 +1,4 @@
-from typing import Dict, List
+from typing import Dict, List, Optional, Tuple
 import warnings
 
 import matplotlib.pyplot as plt
@@ -24,8 +24,12 @@ __all__ = [
     "get_perfbased_weights",
 ]
 
+
 def get_asset_performances(
-    portfolio: pd.DataFrame, assets: List[str], plot=True, strategy=""
+    portfolio: pd.DataFrame,
+    assets: List[str],
+    plot: bool = True,
+    strategy: str = "",
 ) -> pd.Series:
     """
     Calculate the performance of the assets in the portfolio.
@@ -48,12 +52,14 @@ def get_asset_performances(
     asset_returns.fillna(0, inplace=True)
     asset_cum_returns = (1.0 + asset_returns).cumprod()
     if plot:
-        asset_cum_returns.plot(figsize=(12, 6), title=f"{strategy} Strategy Assets Performance")
+        asset_cum_returns.plot(
+            figsize=(12, 6), title=f"{strategy} Strategy Assets Performance"
+        )
         plt.show()
     return asset_cum_returns.iloc[-1] - 1
 
 
-def get_perfbased_weights(performances) -> Dict[str, float]:
+def get_perfbased_weights(performances: pd.Series) -> Dict[str, float]:
     """
     Calculate the weights of the assets based on their performances.
 
@@ -71,7 +77,7 @@ def get_perfbased_weights(performances) -> Dict[str, float]:
     return weights
 
 
-def create_sharpe_ratio(returns, periods=252) -> float:
+def create_sharpe_ratio(returns: pd.Series, periods: int = 252) -> float:
     """
     Create the Sharpe ratio for the strategy, based on a
     benchmark of zero (i.e. no risk-free rate information).
@@ -89,7 +95,7 @@ def create_sharpe_ratio(returns, periods=252) -> float:
 # Define a function to calculate the Sortino Ratio
 
 
-def create_sortino_ratio(returns, periods=252) -> float:
+def create_sortino_ratio(returns: pd.Series, periods: int = 252) -> float:
     """
     Create the Sortino ratio for the strategy, based on a
     benchmark of zero (i.e. no risk-free rate information).
@@ -104,7 +110,7 @@ def create_sortino_ratio(returns, periods=252) -> float:
     return qs.stats.sortino(returns, periods=periods)
 
 
-def create_drawdowns(pnl):
+def create_drawdowns(pnl: pd.Series) -> Tuple[pd.Series, float, float]:
     """
     Calculate the largest peak-to-trough drawdown of the PnL curve
     as well as the duration of the drawdown. Requires that the
@@ -135,7 +141,7 @@ def create_drawdowns(pnl):
     return drawdown, drawdown.max(), duration.max()
 
 
-def plot_performance(df, title):
+def plot_performance(df: pd.DataFrame, title: str) -> None:
     """
     Plot the performance of the strategy:
         - (Portfolio value,  %)
@@ -188,7 +194,7 @@ def plot_performance(df, title):
     plt.show()
 
 
-def plot_returns_and_dd(df: pd.DataFrame, benchmark: str, title):
+def plot_returns_and_dd(df: pd.DataFrame, benchmark: str, title: str) -> None:
     """
     Plot the returns and drawdowns of the strategy
     compared to a benchmark.
@@ -271,7 +277,7 @@ def plot_returns_and_dd(df: pd.DataFrame, benchmark: str, title):
     plt.show()
 
 
-def plot_monthly_yearly_returns(df: pd.DataFrame, title):
+def plot_monthly_yearly_returns(df: pd.DataFrame, title: str) -> None:
     """
     Plot the monthly and yearly returns of the strategy.
 
@@ -306,7 +312,7 @@ def plot_monthly_yearly_returns(df: pd.DataFrame, title):
     # Prepare monthly returns DataFrame
     monthly_returns_df = monthly_returns.unstack(level=-1) * 100
     monthly_returns_df.columns = monthly_returns_df.columns.map(
-        lambda x: pd.to_datetime(x, format="%m").strftime("%b")
+        lambda x: pd.to_datetime(str(x), format="%m").strftime("%b")
     )
 
     # Calculate and prepare yearly returns DataFrame
@@ -371,7 +377,12 @@ def plot_monthly_yearly_returns(df: pd.DataFrame, title):
     plt.show()
 
 
-def show_qs_stats(returns, benchmark, strategy_name, save_dir=None):
+def show_qs_stats(
+    returns: pd.Series,
+    benchmark: str,
+    strategy_name: str,
+    save_dir: Optional[str] = None,
+) -> None:
     """
     Generate the full quantstats report for the strategy.
 

bbstrader/btengine/portfolio.py

@@ -1,12 +1,19 @@
 from datetime import datetime
 from pathlib import Path
 from queue import Queue
+from typing import Any, Dict, List, Optional, Union
 
 import pandas as pd
 import quantstats as qs
 
 from bbstrader.btengine.data import DataHandler
-from bbstrader.btengine.event import Events, FillEvent, MarketEvent, OrderEvent, SignalEvent
+from bbstrader.btengine.event import (
+    Events,
+    FillEvent,
+    MarketEvent,
+    OrderEvent,
+    SignalEvent,
+)
 from bbstrader.btengine.performance import (
     create_drawdowns,
     create_sharpe_ratio,
@@ -22,7 +29,7 @@ __all__ = [
 ]
 
 
-class Portfolio(object):
+class Portfolio:
     """
     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.
@@ -72,11 +79,11 @@ class Portfolio(object):
     def __init__(
         self,
         bars: DataHandler,
-        events: Queue,
+        events: "Queue[Union[OrderEvent, FillEvent, SignalEvent]]",
         start_date: datetime,
-        initial_capital=100000.0,
-        **kwargs,
-    ):
+        initial_capital: float = 100000.0,
+        **kwargs: Any,
+    ) -> None:
         """
         Initialises the portfolio with bars and an event queue.
         Also includes a starting datetime index and initial capital
@@ -99,7 +106,7 @@ class Portfolio(object):
         """
         self.bars = bars
         self.events = events
-        self.symbol_list = self.bars.symbol_list
+        self.symbol_list = self.bars.symbols
         self.start_date = start_date
         self.initial_capital = initial_capital
         self._leverage = kwargs.get("leverage", 1)
@@ -119,15 +126,15 @@ class Portfolio(object):
         else:
             self.tf = self._tf_mapping()[self.timeframe]
 
-        self.all_positions = self.construct_all_positions()
-        self.current_positions = dict(
+        self.all_positions: List[Dict[str, Any]] = self.construct_all_positions()
+        self.current_positions: Dict[str, Any] = dict(
             (k, v) for k, v in [(s, 0) for s in self.symbol_list]
         )
-        self.all_holdings = self.construct_all_holdings()
-        self.current_holdings = self.construct_current_holdings()
-        self.equity_curve = None
+        self.all_holdings: List[Dict[str, Any]] = self.construct_all_holdings()
+        self.current_holdings: Dict[str, Any] = self.construct_current_holdings()
+        self.equity_curve: Optional[pd.DataFrame] = None
 
-    def _tf_mapping(self):
+    def _tf_mapping(self) -> Dict[str, int]:
         """
         Returns a dictionary mapping the time frames
         to the number of bars in a year.
@@ -154,12 +161,12 @@ class Portfolio(object):
             480,
             720,
         ]:
-            key = f"{minutes//60}h" if minutes >= 60 else f"{minutes}m"
+            key = f"{minutes // 60}h" if minutes >= 60 else f"{minutes}m"
             time_frame_mapping[key] = int(252 * (60 / minutes) * th)
         time_frame_mapping["D1"] = 252
         return time_frame_mapping
 
-    def construct_all_positions(self):
+    def construct_all_positions(self) -> List[Dict[str, Any]]:
         """
         Constructs the positions list using the start_date
         to determine when the time index will begin.
@@ -168,7 +175,7 @@ class Portfolio(object):
         d["Datetime"] = self.start_date
         return [d]
 
-    def construct_all_holdings(self):
+    def construct_all_holdings(self) -> List[Dict[str, Any]]:
         """
         Constructs the holdings list using the start_date
         to determine when the time index will begin.
@@ -180,7 +187,7 @@ class Portfolio(object):
         d["Total"] = self.initial_capital
         return [d]
 
-    def construct_current_holdings(self):
+    def construct_current_holdings(self) -> Dict[str, float]:
         """
         This constructs the dictionary which will hold the instantaneous
         value of the portfolio across all symbols.
@@ -202,7 +209,7 @@ class Portfolio(object):
             except (AttributeError, KeyError, ValueError):
                 return 0.0
 
-    def update_timeindex(self, event: MarketEvent):
+    def update_timeindex(self, event: MarketEvent) -> None:
         """
         Adds a new record to the positions matrix for the current
         market data bar. This reflects the PREVIOUS bar, i.e. all
@@ -236,7 +243,7 @@ class Portfolio(object):
         # Append the current holdings
         self.all_holdings.append(dh)
 
-    def update_positions_from_fill(self, fill: FillEvent):
+    def update_positions_from_fill(self, fill: FillEvent) -> None:
         """
         Takes a Fill object and updates the position matrix to
         reflect the new position.
@@ -254,7 +261,7 @@ class Portfolio(object):
         # Update positions list with new quantities
         self.current_positions[fill.symbol] += fill_dir * fill.quantity
 
-    def update_holdings_from_fill(self, fill: FillEvent):
+    def update_holdings_from_fill(self, fill: FillEvent) -> None:
         """
         Takes a Fill object and updates the holdings matrix to
         reflect the holdings value.
@@ -277,7 +284,7 @@ class Portfolio(object):
         self.current_holdings["Cash"] -= cost + fill.commission
         self.current_holdings["Total"] -= cost + fill.commission
 
-    def update_fill(self, event: FillEvent):
+    def update_fill(self, event: FillEvent) -> None:
         """
         Updates the portfolio current positions and holdings
         from a FillEvent.
@@ -286,7 +293,7 @@ class Portfolio(object):
             self.update_positions_from_fill(event)
             self.update_holdings_from_fill(event)
 
-    def generate_order(self, signal: SignalEvent):
+    def generate_order(self, signal: SignalEvent) -> Optional[OrderEvent]:
         """
         Turns a SignalEvent into an OrderEvent.
 
@@ -304,7 +311,7 @@ class Portfolio(object):
         strength = signal.strength
         price = signal.price or self._get_price(symbol)
         cur_quantity = self.current_positions[symbol]
-        mkt_quantity = round(quantity * strength, 2)
+        mkt_quantity = round(float(quantity) * float(strength), 2)
         new_quantity = mkt_quantity * self._leverage
 
         if direction in ["LONG", "SHORT", "EXIT"]:
@@ -332,7 +339,7 @@ class Portfolio(object):
 
         return order
 
-    def update_signal(self, event: SignalEvent):
+    def update_signal(self, event: SignalEvent) -> None:
         """
         Acts on a SignalEvent to generate new orders
         based on the portfolio logic.
@@ -341,7 +348,7 @@ class Portfolio(object):
             order_event = self.generate_order(event)
             self.events.put(order_event)
 
-    def create_equity_curve_dataframe(self):
+    def create_equity_curve_dataframe(self) -> None:
         """
         Creates a pandas DataFrame from the all_holdings
         list of dictionaries.
@@ -353,13 +360,16 @@ class Portfolio(object):
         curve["Equity Curve"] = (1.0 + curve["Returns"]).cumprod()
         self.equity_curve = curve
 
-    def output_summary_stats(self):
+    def output_summary_stats(self) -> List[Any]:
         """
         Creates a list of summary statistics for the portfolio.
         """
-        total_return = self.equity_curve["Equity Curve"].iloc[-1]
-        returns = self.equity_curve["Returns"]
-        pnl = self.equity_curve["Equity Curve"]
+        if self.equity_curve is None:
+            self.create_equity_curve_dataframe()
+
+        total_return = self.equity_curve["Equity Curve"].iloc[-1]  # type: ignore
+        returns = self.equity_curve["Returns"]  # type: ignore
+        pnl = self.equity_curve["Equity Curve"]  # type: ignore
 
         sharpe_ratio = create_sharpe_ratio(returns, periods=self.tf)
         sortino_ratio = create_sortino_ratio(returns, periods=self.tf)
@@ -370,7 +380,7 @@ class Portfolio(object):
         self.equity_curve["Drawdown"] = drawdown
 
         stats = [
-            ("Total Return", f"{(total_return-1.0) * 100.0:.2f}%"),
+            ("Total Return", f"{(total_return - 1.0) * 100.0:.2f}%"),
             ("Sharpe Ratio", f"{sharpe_ratio:.2f}"),
             ("Sortino Ratio", f"{sortino_ratio:.2f}"),
             ("Max Drawdown", f"{max_dd * 100.0:.2f}%"),

bbstrader/btengine/scripts.py

@@ -3,6 +3,8 @@ import json
 import os
 import sys
 from datetime import datetime
+from types import ModuleType
+from typing import Any, Dict, List, Type
 
 from bbstrader.btengine.backtest import run_backtest
 from bbstrader.btengine.data import (
@@ -18,12 +20,13 @@ from bbstrader.btengine.execution import (
     MT5ExecutionHandler,
     SimExecutionHandler,
 )
+from bbstrader.btengine.strategy import MT5Strategy, Strategy
 from bbstrader.core.utils import load_class, load_module
 
 BACKTEST_PATH = os.path.expanduser("~/.bbstrader/backtest/backtest.py")
 CONFIG_PATH = os.path.expanduser("~/.bbstrader/backtest/backtest.json")
 
-DATA_HANDLER_MAP = {
+DATA_HANDLER_MAP: Dict[str, Type[DataHandler]] = {
     "csv": CSVDataHandler,
     "mt5": MT5DataHandler,
     "yf": YFDataHandler,
@@ -31,27 +34,25 @@ DATA_HANDLER_MAP = {
     "fmp": FMPDataHandler,
 }
 
-EXECUTION_HANDLER_MAP = {
+EXECUTION_HANDLER_MAP: Dict[str, Type[ExecutionHandler]] = {
     "sim": SimExecutionHandler,
     "mt5": MT5ExecutionHandler,
 }
 
 
-def load_exc_handler(module, handler_name):
-    return load_class(module, handler_name, ExecutionHandler)
+def load_exc_handler(module: ModuleType, handler_name: str) -> Type[ExecutionHandler]:
+    return load_class(module, handler_name, ExecutionHandler)  # type: ignore
 
 
-def load_data_handler(module, handler_name):
-    return load_class(module, handler_name, DataHandler)
+def load_data_handler(module: ModuleType, handler_name: str) -> Type[DataHandler]:
+    return load_class(module, handler_name, DataHandler)  # type: ignore
 
 
-def load_strategy(module, strategy_name):
-    from bbstrader.btengine.strategy import MT5Strategy, Strategy
+def load_strategy(module: ModuleType, strategy_name: str) -> Type[Strategy]:
+    return load_class(module, strategy_name, (Strategy, MT5Strategy))  # type: ignore
 
-    return load_class(module, strategy_name, (Strategy, MT5Strategy))
 
-
-def load_config(config_path, strategy_name):
+def load_config(config_path: str, strategy_name: str) -> Dict[str, Any]:
     if not os.path.exists(config_path):
         raise FileNotFoundError(
             f"Configuration file {config_path} not found. Please create it."
@@ -101,7 +102,7 @@ def load_config(config_path, strategy_name):
     return config
 
 
-def backtest(unknown):
+def backtest(unknown: List[str]) -> None:
     HELP_MSG = """
     Usage:
         python -m bbstrader --run backtest [options]