bbstrader 0.1.6__py3-none-any.whl → 0.1.8__py3-none-any.whl

bbstrader/btengine/data.py

@@ -360,10 +360,12 @@ class YFHistoricDataHandler(BaseCSVDataHandler):
 
 
 # TODO # Get data from EODHD
+# https://eodhd.com/
 class EODHDHistoricDataHandler(BaseCSVDataHandler):
     ...
 
-# TODO # Get data from FinancialModelingPrep ()
+# TODO # Get data from FMP using Financialtoolkit API
+# https://github.com/bbalouki/FinanceToolkit
 class FMPHistoricDataHandler(BaseCSVDataHandler):
     ...
 

bbstrader/btengine/event.py

@@ -54,9 +54,10 @@ class SignalEvent(Event):
                  strategy_id: int,
                  symbol: str,
                  datetime: datetime,
-                 signal_type: str,
+                 signal_type: Literal['LONG', 'SHORT', 'EXIT'],
                  quantity: int | float = 100,
-                 strength: int | float = 1.0
+                 strength: int | float = 1.0,
+                 price: int | float = None
                  ):
         """
         Initialises the SignalEvent.
@@ -67,10 +68,11 @@ class SignalEvent(Event):
 
             symbol (str): The ticker symbol, e.g. 'GOOG'.
             datetime (datetime): The timestamp at which the signal was generated.
-            signal_type (str): 'LONG' or 'SHORT'.
+            signal_type (str): 'LONG' or 'SHORT' or 'EXIT'.
             quantity (int | float): An optional integer (or float) representing the order size.
             strength (int | float): An adjustment factor "suggestion" used to scale
                 quantity at the portfolio level. Useful for pairs strategies.
+            price (int | float): An optional price to be used when the signal is generated.
         """
         self.type = 'SIGNAL'
         self.strategy_id = strategy_id
@@ -79,6 +81,7 @@ class SignalEvent(Event):
         self.signal_type = signal_type
         self.quantity = quantity
         self.strength = strength
+        self.price = price
 
 
 class OrderEvent(Event):
@@ -96,9 +99,10 @@ class OrderEvent(Event):
 
     def __init__(self,
                  symbol: str,
-                 order_type: str,
+                 order_type: Literal['MKT', 'LMT'],
                  quantity: int | float,
-                 direction: str
+                 direction: Literal['BUY', 'SELL'],
+                 price: int | float = None
                  ):
         """
         Initialises the order type, setting whether it is
@@ -110,20 +114,22 @@ class OrderEvent(Event):
             order_type (str): 'MKT' or 'LMT' for Market or Limit. 
             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.
         """
         self.type = 'ORDER'
         self.symbol = symbol
         self.order_type = order_type
         self.quantity = quantity
         self.direction = direction
+        self.price = price
 
         def print_order(self):
             """
             Outputs the values within the Order.
             """
             print(
-                "Order: Symbol=%s, Type=%s, Quantity=%s, Direction=%s" %
-                (self.symbol, self.order_type, self.quantity, self.direction)
+                "Order: Symbol=%s, Type=%s, Quantity=%s, Direction=%s, Price=%s" %
+                (self.symbol, self.order_type, self.quantity, self.direction, self.price)
             )
 
 
@@ -151,7 +157,7 @@ class FillEvent(Event):
                  symbol: str,
                  exchange: str,
                  quantity: int | float,
-                 direction: Literal['LONG', 'SHORT', 'EXIT'],
+                 direction: Literal['BUY', 'SELL'],
                  fill_cost: int | float | None,
                  commission: float | None = None
                  ):
@@ -170,7 +176,7 @@ class FillEvent(Event):
             exchange (str): The exchange where the order was filled.
             quantity (int | float): The filled quantity.
             direction (str): The direction of fill `('LONG', 'SHORT', 'EXIT')`
-            fill_cost (int | float): The holdings value in dollars.
+            fill_cost (int | float): Price of the shares when filled.
             commission (float | None): An optional commission sent from IB.
         """
         self.type = 'FILL'

bbstrader/btengine/execution.py

@@ -1,11 +1,13 @@
-import datetime
+from datetime import datetime
 from queue import Queue
 from abc import ABCMeta, abstractmethod
 from bbstrader.btengine.event import FillEvent, OrderEvent
+from bbstrader.metatrader.account import Account
 
 __all__ = [
     "ExecutionHandler",
-    "SimulatedExecutionHandler"
+    "SimulatedExecutionHandler",
+    "MT5ExecutionHandler"
 ]
 
 
@@ -71,13 +73,71 @@ class SimulatedExecutionHandler(ExecutionHandler):
         """
         if event.type == 'ORDER':
             fill_event = FillEvent(
-                datetime.datetime.now(), event.symbol,
+                datetime.now(), event.symbol,
                 'ARCA', event.quantity, event.direction, None
             )
             self.events.put(fill_event)
 
-# TODO # Use in live execution
-
 
 class MT5ExecutionHandler(ExecutionHandler):
-    ...
+    def __init__(self, events: Queue, **kwargs):
+        """
+        """
+        self.events = events
+        self.account = Account()
+
+    def _estimate_total_fees(self, symbol, lot):
+        # TODO: Implement the calculation of fees based on the broker's fees
+        # https://www.metatrader5.com/en/terminal/help/trading/market_watch
+        # Calculate fees based on the broker's fees , swap and commission
+        return 0.0
+
+    def _calculate_lot(self, symbol, quantity, price):
+        FX = self.account.get_symbol_type(symbol) == 'FX'
+        COMD = self.account.get_symbol_type(symbol) == 'COMD'
+        FUT = self.account.get_symbol_type(symbol) == 'FUT'
+        CRYPTO = self.account.get_symbol_type(symbol) == 'CRYPTO'
+        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
+        if COMD or FUT or CRYPTO and contract_size > 1:
+            lot = quantity  / contract_size
+        if FX:
+            lot = (quantity*price / contract_size)
+        return self._check_lot(symbol, lot)
+
+    def _check_lot(self, symbol, lot):
+        symbol_info =  self.account.get_symbol_info(symbol)
+        if lot < symbol_info.volume_min:
+            return symbol_info.volume_min
+        elif lot > symbol_info.volume_max:
+            return symbol_info.volume_max
+        return round(lot, 2)
+    
+    def execute_order(self, event: OrderEvent):
+        """
+        Executes an Order event by converting it into a Fill event.
+
+        Args:
+            event (OrderEvent): Contains an Event object with order information.
+        """
+        if event.type == 'ORDER':
+            symbol = event.symbol
+            direction = event.direction
+            quantity = event.quantity
+            price = event.price
+            lot = self._calculate_lot(symbol, quantity, price)
+            fees = self._estimate_total_fees(symbol, lot)
+            fill_event = FillEvent(
+                timeindex=datetime.now(), symbol=symbol,
+                exchange='MT5', quantity=quantity, direction=direction,
+                fill_cost=None, commission=fees
+            )
+            self.events.put(fill_event)
+
+
+class IBExecutionHandler(ExecutionHandler):
+    ...

bbstrader/btengine/performance.py

@@ -6,9 +6,11 @@ import yfinance as yf
 from scipy.stats import mstats
 import matplotlib.pyplot as plt
 from matplotlib.ticker import MaxNLocator
+import quantstats as qs
 
 import warnings
 warnings.filterwarnings("ignore")
+warnings.simplefilter(action='ignore', category=FutureWarning)
 sns.set_theme()
 
 __all__ = [
@@ -17,11 +19,12 @@ __all__ = [
     "create_sharpe_ratio",
     "create_sortino_ratio",
     "plot_returns_and_dd",
-    "plot_monthly_yearly_returns"
+    "plot_monthly_yearly_returns",
+    "show_qs_stats"
 ]
 
 
-def create_sharpe_ratio(returns, periods=252):
+def create_sharpe_ratio(returns, periods=252) -> float:
     """
     Create the Sharpe ratio for the strategy, based on a
     benchmark of zero (i.e. no risk-free rate information).
@@ -33,15 +36,10 @@ def create_sharpe_ratio(returns, periods=252):
     Returns:
         S (float): Sharpe ratio
     """
-    if np.std(returns) != 0:
-        return np.sqrt(periods) * (np.mean(returns)) / np.std(returns)
-    else:
-        return 0.0
+    return qs.stats.sharpe(returns, periods=periods)
 
 # Define a function to calculate the Sortino Ratio
-
-
-def create_sortino_ratio(returns, periods=252):
+def create_sortino_ratio(returns, periods=252) -> float:
     """
     Create the Sortino ratio for the strategy, based on a
     benchmark of zero (i.e. no risk-free rate information).
@@ -53,17 +51,7 @@ def create_sortino_ratio(returns, periods=252):
     Returns:
         S (float): Sortino ratio
     """
-    # Calculate the annualized return
-    annualized_return = np.power(1 + np.mean(returns), periods) - 1
-    # Calculate the downside deviation
-    downside_returns = returns.copy()
-    downside_returns[returns > 0] = 0
-    annualized_downside_std = np.std(downside_returns) * np.sqrt(periods)
-    if annualized_downside_std != 0:
-        return annualized_return / annualized_downside_std
-    else:
-        return 0.0
-
+    return qs.stats.sortino(returns, periods=periods)
 
 def create_drawdowns(pnl):
     """
@@ -307,3 +295,27 @@ def plot_monthly_yearly_returns(df, title):
 
     # Show the plot
     plt.show()
+
+def show_qs_stats(returns, benchmark, strategy_name, save_dir=None):
+    """
+    Generate the full quantstats report for the strategy.
+
+    Args:
+        returns (pd.Serie): 
+            The DataFrame containing the strategy returns and drawdowns.
+        benchmark (str): 
+            The ticker symbol of the benchmark to compare the strategy to.
+        strategy_name (str): The name of the strategy.
+    """
+    # Load the returns data
+    returns = returns.copy()
+
+    # Drop duplicate index entries
+    returns = returns[~returns.index.duplicated(keep='first')]
+
+    # Extend pandas functionality with quantstats
+    qs.extend_pandas()
+
+    # Generate the full report with a benchmark
+    qs.reports.full(returns, mode='full', benchmark=benchmark)
+    qs.reports.html(returns, benchmark=benchmark, output=save_dir, title=strategy_name)

bbstrader/btengine/portfolio.py

@@ -1,15 +1,17 @@
 import pandas as pd
 from queue import Queue
+from pathlib import Path
 from datetime import datetime
 from bbstrader.btengine.event import (
     OrderEvent, FillEvent, MarketEvent, SignalEvent
 )
 from bbstrader.btengine.data import DataHandler
 from bbstrader.btengine.performance import (
-    create_drawdowns, plot_performance,
-    create_sharpe_ratio, create_sortino_ratio,
-    plot_returns_and_dd, plot_monthly_yearly_returns
+    create_drawdowns, create_sharpe_ratio, create_sortino_ratio, 
+    plot_performance, show_qs_stats,plot_returns_and_dd, 
+    plot_monthly_yearly_returns
 )
+import quantstats as qs
 
 
 class Portfolio(object):
@@ -20,7 +22,7 @@ class Portfolio(object):
     sizing tools (such as the `Kelly Criterion`).
 
     The portfolio order management system is possibly the most complex component of 
-    an eventdriven backtester.  Its role is to keep track of all current market positions 
+    an event driven backtester. Its role is to keep track of all current market positions 
     as well as the market value of the positions (known as the "holdings"). 
     This is simply an estimate of the liquidation value of the position and is derived in part 
     from the data handling facility of the backtester.
@@ -95,7 +97,7 @@ class Portfolio(object):
         self.timeframe = kwargs.get("time_frame", "D1")
         self.trading_hours = kwargs.get("session_duration", 6.5)
         self.benchmark = kwargs.get('benchmark', 'SPY')
-        self.strategy_name = kwargs.get('strategy_name', 'Strategy')
+        self.strategy_name = kwargs.get('strategy_name', '')
         if self.timeframe not in self._tf_mapping():
             raise ValueError(
                 f"Timeframe not supported,"
@@ -227,10 +229,10 @@ class Portfolio(object):
             fill_dir = -1
 
         # Update holdings list with new quantities
-        fill_cost = self.bars.get_latest_bar_value(
+        price = self.bars.get_latest_bar_value(
             fill.symbol, "Adj Close"
         )
-        cost = fill_dir * fill_cost * fill.quantity
+        cost = fill_dir * price * fill.quantity
         self.current_holdings[fill.symbol] += cost
         self.current_holdings['Commission'] += fill.commission
         self.current_holdings['Cash'] -= (cost + fill.commission)
@@ -260,20 +262,21 @@ class Portfolio(object):
         direction = signal.signal_type
         quantity = signal.quantity
         strength = signal.strength
+        price = signal.price
         cur_quantity = self.current_positions[symbol]
 
         order_type = 'MKT'
         mkt_quantity = round(quantity * strength)
 
         if direction == 'LONG' and cur_quantity == 0:
-            order = OrderEvent(symbol, order_type, mkt_quantity, 'BUY')
+            order = OrderEvent(symbol, order_type, mkt_quantity, 'BUY', price)
         if direction == 'SHORT' and cur_quantity == 0:
-            order = OrderEvent(symbol, order_type, mkt_quantity, 'SELL')
+            order = OrderEvent(symbol, order_type, mkt_quantity, 'SELL', price)
 
         if direction == 'EXIT' and cur_quantity > 0:
-            order = OrderEvent(symbol, order_type, abs(cur_quantity), 'SELL')
+            order = OrderEvent(symbol, order_type, abs(cur_quantity), 'SELL', price)
         if direction == 'EXIT' and cur_quantity < 0:
-            order = OrderEvent(symbol, order_type, abs(cur_quantity), 'BUY')
+            order = OrderEvent(symbol, order_type, abs(cur_quantity), 'BUY', price)
 
         return order
 
@@ -307,7 +310,10 @@ class Portfolio(object):
 
         sharpe_ratio = create_sharpe_ratio(returns, periods=self.tf)
         sortino_ratio = create_sortino_ratio(returns, periods=self.tf)
-        drawdown, max_dd, dd_duration = create_drawdowns(pnl)
+        drawdown, _, _ = create_drawdowns(pnl)
+        max_dd = qs.stats.max_drawdown(returns)
+        dd_details = qs.stats.drawdown_details(drawdown)
+        dd_duration = dd_details['days'].max()
         self.equity_curve['Drawdown'] = drawdown
 
         stats = [
@@ -317,10 +323,22 @@ class Portfolio(object):
             ("Max Drawdown", f"{max_dd * 100.0:.2f}%"),
             ("Drawdown Duration", f"{dd_duration}")
         ]
-        self.equity_curve.to_csv('equity.csv')
+        now = datetime.now().strftime('%Y%m%d%H%M%S')
+        strategy_name = self.strategy_name.replace(' ', '_')
+        results_dir = Path('Backtest_Results') / strategy_name
+        results_dir.mkdir(parents=True, exist_ok=True)
+        
+        csv_file =  f"{strategy_name}_{now}_equity.csv"
+        png_file = f'{strategy_name}_{now}_returns_heatmap.png'
+        html_file = f"{strategy_name}_{now}_report.html"
+        self.equity_curve.to_csv(results_dir / csv_file)
+        
         plot_performance(self.equity_curve, self.strategy_name)
-        plot_returns_and_dd(self.equity_curve,
-                            self.benchmark, self.strategy_name)
+        plot_returns_and_dd(self.equity_curve, self.benchmark, self.strategy_name)
+        qs.plots.monthly_heatmap(returns, savefig=f"{results_dir}/{png_file}")
         plot_monthly_yearly_returns(self.equity_curve, self.strategy_name)
+        show_qs_stats(returns, self.benchmark, self.strategy_name, 
+                      save_dir=f"{results_dir}/{html_file}")
 
         return stats
+

bbstrader/btengine/strategy.py

@@ -1,7 +1,6 @@
 from abc import ABCMeta, abstractmethod
 from typing import Dict, Union
 
-
 class Strategy(metaclass=ABCMeta):
     """
     A `Strategy()` object encapsulates all calculation on market data 
@@ -30,4 +29,4 @@ class Strategy(metaclass=ABCMeta):
         """
         raise NotImplementedError(
             "Should implement calculate_signals()"
-        )
+        )

bbstrader/metatrader/account.py

@@ -6,10 +6,9 @@ from datetime import datetime
 import MetaTrader5 as mt5
 from currency_converter import SINGLE_DAY_ECB_URL, CurrencyConverter
 from bbstrader.metatrader.utils import (
-    raise_mt5_error, AccountInfo, TerminalInfo,
+    raise_mt5_error, AccountInfo, TerminalInfo, InvalidBroker,
     SymbolInfo, TickInfo, TradeRequest, OrderCheckResult,
-    OrderSentResult, TradePosition, TradeOrder, TradeDeal,
-)
+    OrderSentResult, TradePosition, TradeOrder, TradeDeal,)
 from typing import Tuple, Union, List, Dict, Any, Optional, Literal
 
 
@@ -18,6 +17,13 @@ __BROKERS__ = {
     'JGM': "Just Global Markets Ltd.",
     'FTMO': "FTMO S.R.O."
 }
+
+BROKERS_TIMEZONES = {
+    'AMG': 'Europe/Helsinki',
+    'JGM': 'Europe/Helsinki',
+    'FTMO': 'Europe/Helsinki'
+}
+
 _ADMIRAL_MARKETS_URL_ = "https://cabinet.a-partnership.com/visit/?bta=35537&brand=admiralmarkets"
 _ADMIRAL_MARKETS_PRODUCTS_ = ["Stocks", "ETFs",
                             "Indices", "Commodities", "Futures", "Forex"]
@@ -93,13 +99,14 @@ class Account(object):
         supported = __BROKERS__.copy()
         broker = self.get_terminal_info().company
         if broker not in supported.values():
-            raise ValueError(
+            msg = (
                 f"{broker} is not currently supported broker for the Account() class\n"
                 f"Currently Supported brokers are: {', '.join(supported.values())}\n"
                 f"For {supported['AMG']}, See [{amg_url}]\n"
                 f"For {supported['JGM']}, See [{jgm_url}]\n"
                 f"For {supported['FTMO']}, See [{ftmo_url}]\n"
             )
+            raise InvalidBroker(message=msg)
 
     def get_account_info(
         self,
@@ -782,7 +789,7 @@ class Account(object):
         else:
             positions = mt5.positions_get()
 
-        if positions is None:
+        if positions is None or len(positions) == 0:
             return None
         if to_df:
             df = pd.DataFrame(list(positions), columns=positions[0]._asdict())
@@ -885,7 +892,7 @@ class Account(object):
         else:
             position_deals = mt5.history_deals_get(date_from, date_to)
 
-        if position_deals is None:
+        if position_deals is None or len(position_deals) == 0:
             return None
 
         df = pd.DataFrame(list(position_deals),
@@ -961,7 +968,7 @@ class Account(object):
         else:
             orders = mt5.orders_get()
 
-        if orders is None:
+        if orders is None or len(orders) == 0:
             return None
 
         if to_df:
@@ -1064,7 +1071,7 @@ class Account(object):
         else:
             history_orders = mt5.history_orders_get(date_from, date_to)
 
-        if history_orders is None:
+        if history_orders is None or len(history_orders) == 0:
             return None
 
         df = pd.DataFrame(list(history_orders),

bbstrader/metatrader/rates.py

@@ -3,8 +3,7 @@ import MetaTrader5 as Mt5
 from datetime import datetime
 from typing import Union, Optional
 from bbstrader.metatrader.utils import (
-    raise_mt5_error, TimeFrame, TIMEFRAMES
-)
+    raise_mt5_error, TimeFrame, TIMEFRAMES)
 from bbstrader.metatrader.account import INIT_MSG
 from pandas.tseries.offsets import CustomBusinessDay
 from pandas.tseries.holiday import USFederalHolidayCalendar
@@ -22,8 +21,13 @@ class Rates(object):
     and count of bars or by providing a specific date range.
 
     Notes:
-        The `get_open, get_high, get_low, get_close, get_adj_close, get_returns,
-        get_volume` properties return data in  Broker's timezone.
+        1. Befor using this class, ensure that the `Max bars in chart` in you terminal
+        is set to a value that is greater than the number of bars you want to retrieve
+        or just set it to Unlimited.
+        In your MT5 terminal, go to `Tools` -> `Options` -> `Charts` -> `Max bars in chart`.
+        
+        2. The `get_open, get_high, get_low, get_close, get_adj_close, get_returns,
+        get_volume` properties returns data in  Broker's timezone.
 
     Example:
         >>> rates = Rates("EURUSD", "1h")
@@ -221,7 +225,7 @@ class Rates(object):
     
     @property
     def get_volume(self):
-        return self.data['Volume']
+        return self.__data['Volume']
 
     def get_historical_data(
         self,
@@ -247,7 +251,7 @@ class Rates(object):
             ValueError: If the starting date is greater than the ending date.
         
         Notes:
-            The Datetime for this method is in UTC timezone.
+            The Datetime for this method is in Local timezone.
         """
         df = self._fetch_data(date_from, date_to)
         if save_csv and df is not None:

bbstrader/metatrader/risk.py

@@ -7,8 +7,7 @@ import MetaTrader5 as Mt5
 from bbstrader.metatrader.account import Account
 from bbstrader.metatrader.rates import Rates
 from bbstrader.metatrader.utils import (
-    TIMEFRAMES, raise_mt5_error, TimeFrame
-)
+    TIMEFRAMES, raise_mt5_error, TimeFrame)
 from typing import List, Dict, Optional, Literal, Union, Any