bbstrader 0.0.1__py3-none-any.whl

bbstrader/btengine/performance.py

@@ -0,0 +1,309 @@
+import numpy as np
+import pandas as pd
+import seaborn as sns
+import yfinance as yf
+
+from scipy.stats import mstats
+import matplotlib.pyplot as plt
+from matplotlib.ticker import MaxNLocator
+
+import warnings
+warnings.filterwarnings("ignore")
+sns.set_theme()
+
+__all__ = [
+    "create_drawdowns",
+    "plot_performance",
+    "create_sharpe_ratio",
+    "create_sortino_ratio",
+    "plot_returns_and_dd",
+    "plot_monthly_yearly_returns"
+]
+
+
+def create_sharpe_ratio(returns, periods=252):
+    """
+    Create the Sharpe ratio for the strategy, based on a
+    benchmark of zero (i.e. no risk-free rate information).
+
+    Args:
+        returns : A pandas Series representing period percentage returns.
+        periods (int): Daily (252), Hourly (252*6.5), Minutely(252*6.5*60) etc.
+
+    Returns:
+        S (float): Sharpe ratio
+    """
+    if np.std(returns) != 0:
+        return np.sqrt(periods) * (np.mean(returns)) / np.std(returns)
+    else:
+        return 0.0
+
+# Define a function to calculate the Sortino Ratio
+
+
+def create_sortino_ratio(returns, periods=252):
+    """
+    Create the Sortino ratio for the strategy, based on a
+    benchmark of zero (i.e. no risk-free rate information).
+
+    Args:
+        returns : A pandas Series representing period percentage returns.
+        periods (int): Daily (252), Hourly (252*6.5), Minutely(252*6.5*60) etc.
+
+    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
+
+
+def create_drawdowns(pnl):
+    """
+    Calculate the largest peak-to-trough drawdown of the PnL curve
+    as well as the duration of the drawdown. Requires that the
+    pnl_returns is a pandas Series.
+
+    Args:
+        pnl : A pandas Series representing period percentage returns.
+
+    Returns:
+        (tuple): drawdown, duration - high-water mark, duration.
+    """
+    # Calculate the cumulative returns curve
+    # and set up the High Water Mark
+    hwm = pd.Series(index=pnl.index)
+    hwm.iloc[0] = 0
+
+    # Create the drawdown and duration series
+    idx = pnl.index
+    drawdown = pd.Series(index=idx)
+    duration = pd.Series(index=idx)
+
+    # Loop over the index range
+    for t in range(1, len(idx)):
+        hwm.iloc[t] = max(hwm.iloc[t-1], pnl.iloc[t])
+        drawdown.iloc[t] = (hwm.iloc[t] - pnl.iloc[t])
+        duration.iloc[t] = (0 if drawdown.iloc[t] ==
+                            0 else duration.iloc[t-1]+1)
+
+    return drawdown, drawdown.max(), duration.max()
+
+
+def plot_performance(df, title):
+    """
+    Plot the performance of the strategy:
+        - (Portfolio value,  %)
+        - (Period returns, %)
+        - (Drawdowns, %)
+
+    Args:
+        df (pd.DataFrame):
+        The DataFrame containing the strategy returns and drawdowns.
+        title (str): The title of the plot.
+
+    Note:
+    The DataFrame should contain the following columns
+    - Datetime: The timestamp of the data
+    - Equity Curve: The portfolio value
+    - Returns: The period returns
+    - Drawdown: The drawdowns
+    - Total : The total returns
+    """
+    data = df.copy()
+    data = data.sort_values(by='Datetime')
+    # Plot three charts: Equity curve,
+    # period returns, drawdowns
+    fig = plt.figure(figsize=(14, 8))
+    fig.suptitle(f'{title} Strategy Performance', fontsize=16)
+
+    # Set the outer colour to white
+    sns.set_theme()
+
+    # Plot the equity curve
+    ax1 = fig.add_subplot(311, ylabel='Portfolio value, %')
+    data['Equity Curve'].plot(ax=ax1, color="blue", lw=2.)
+    ax1.set_xlabel('')
+    plt.grid(True)
+
+    # Plot the returns
+    ax2 = fig.add_subplot(312, ylabel='Period returns, %')
+    data['Returns'].plot(ax=ax2, color="black", lw=2.)
+    ax2.set_xlabel('')
+    plt.grid(True)
+
+    # Plot Drawdown
+    ax3 = fig.add_subplot(313, ylabel='Drawdowns, %')
+    data['Drawdown'].plot(ax=ax3, color="red", lw=2.)
+    ax3.set_xlabel('')
+    plt.grid(True)
+
+    # Plot the figure
+    plt.tight_layout()
+    plt.show()
+
+
+def plot_returns_and_dd(df, benchmark: str, title):
+    """
+    Plot the returns and drawdowns of the strategy
+    compared to a benchmark.
+
+    Args:
+        df (pd.DataFrame): 
+            The DataFrame containing the strategy returns and drawdowns.
+        benchmark (str): 
+            The ticker symbol of the benchmark to compare the strategy to.
+        title (str): The title of the plot.
+
+    Note:
+    The DataFrame should contain the following columns:
+    - Datetime : The timestamp of the data
+    - Equity Curve : The portfolio value
+    - Returns : The period returns
+    - Drawdown : The drawdowns
+    - Total : The total returns
+    """
+    # Ensure data is sorted by Datetime
+    data = df.copy()
+    data.reset_index(inplace=True)
+    data = data.sort_values(by='Datetime')
+    data.sort_values(by='Datetime', inplace=True)
+
+    # Get the first and last Datetime values
+    first_date = data['Datetime'].iloc[0]
+    last_date = data['Datetime'].iloc[-1]
+
+    # Download benchmark data from Yahoo Finance
+    # To avoid errors, we use the try-except block
+    # in case the benchmark is not available
+    try:
+        bm = yf.download(benchmark, start=first_date, end=last_date)
+        bm['log_return'] = np.log(bm['Close'] / bm['Close'].shift(1))
+        # Use exponential to get cumulative returns
+        bm_returns = np.exp(np.cumsum(bm['log_return'].fillna(0)))
+
+        # Normalize bm series to start at 1.0
+        bm_returns_normalized = bm_returns / bm_returns.iloc[0]
+    except Exception:
+        bm = None
+
+    # Create figure and plot space
+    fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(
+        14, 8), gridspec_kw={'height_ratios': [3, 1]})
+
+   # Plot the Equity Curve for the strategy
+    ax1.plot(data['Datetime'], data['Equity Curve'],
+             label='Backtest', color='green', lw=2.5)
+    # Check benchmarck an Plot the Returns for the benchmark
+    if bm is not None:
+        ax1.plot(bm.index, bm_returns_normalized,
+                 label='benchmark', color='gray', lw=2.5)
+        ax1.set_title(f'{title} Strategy vs. Benchmark ({benchmark})')
+    else:
+        ax1.set_title(f'{title} Strategy Returns')
+    ax1.set_xlabel('Date')
+    ax1.set_ylabel('Cumulative Returns')
+    ax1.grid(True)
+    ax1.legend(loc='upper left')
+
+    # Plot the Drawdown
+    ax2.fill_between(data['Datetime'], data['Drawdown'],
+                     0, color='red', step="pre", alpha=0.5)
+    ax2.plot(data['Datetime'], data['Drawdown'], color='red',
+             alpha=0.6, lw=2.5)  # Overlay the line
+    ax2.set_title('Drawdown (%)')
+    ax2.set_xlabel('Date')
+    ax2.set_ylabel('Drawdown')
+    ax2.grid(True)
+
+    # Display the plot
+    plt.tight_layout()
+    plt.show()
+
+
+def plot_monthly_yearly_returns(df, title):
+    """
+    Plot the monthly and yearly returns of the strategy.
+
+    Args:
+        df (pd.DataFrame): 
+        The DataFrame containing the strategy returns and drawdowns.
+        title (str): The title of the plot.
+
+    Note:
+    The DataFrame should contain the following columns:
+    - Datetime : The timestamp of the data
+    - Equity Curve : The portfolio value
+    - Returns : The period returns
+    - Drawdown : The drawdowns
+    - Total : The total returns
+    """
+    equity_df = df.copy()
+    equity_df.reset_index(inplace=True)
+    equity_df['Datetime'] = pd.to_datetime(equity_df['Datetime'])
+    equity_df.set_index('Datetime', inplace=True)
+
+    # Calculate daily returns
+    equity_df['Daily Returns'] = equity_df['Total'].pct_change()
+
+    # Group by year and month to get monthly returns
+    monthly_returns = equity_df['Daily Returns'].groupby(
+        [equity_df.index.year, equity_df.index.month]
+    ).apply(lambda x: (1 + x).prod() - 1)
+
+    # 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'))
+
+    # Calculate and prepare yearly returns DataFrame
+    yearly_returns_df = equity_df['Total'].resample(
+        'YE').last().pct_change().to_frame(name='Yearly Returns') * 100
+
+    # Set the aesthetics for the plots
+    sns.set_theme(style="darkgrid")
+
+    # Initialize the matplotlib figure,
+    # adjust the height_ratios to give more space to the yearly returns
+    f, (ax1, ax2) = plt.subplots(2, 1, figsize=(
+        12, 8), gridspec_kw={'height_ratios': [2, 1]})
+    f.suptitle(f'{title} Strategy Monthly and Yearly Returns')
+    # Find the min and max values in the data to set the color scale range.
+    vmin = monthly_returns_df.min().min()
+    vmax = monthly_returns_df.max().max()
+    # Define the color palette for the heatmap
+    cmap = sns.diverging_palette(10, 133, sep=3, n=256, center="light")
+
+    # Create the heatmap with the larger legend
+    sns.heatmap(monthly_returns_df, annot=True, fmt=".1f",
+                linewidths=.5, ax=ax1, cbar_kws={"shrink": .8},
+                cmap=cmap, center=0, vmin=vmin, vmax=vmax)
+
+    # Rotate the year labels on the y-axis to vertical
+    ax1.set_yticklabels(ax1.get_yticklabels(), rotation=0)
+    ax1.set_ylabel('')
+    ax1.set_xlabel('')
+
+    # Create the bar plot
+    yearly_returns_df.plot(kind='bar', ax=ax2, legend=None, color='skyblue')
+
+    # Set plot titles and labels
+    ax1.set_title('Monthly Returns (%)')
+    ax2.set_title('Yearly Returns (%)')
+
+    # Rotate the x labels for the yearly returns bar plot
+    ax2.set_xticklabels(yearly_returns_df.index.strftime('%Y'), rotation=45)
+    ax2.set_xlabel('')
+
+    # Adjust layout spacing
+    plt.tight_layout()
+
+    # Show the plot
+    plt.show()

bbstrader/btengine/portfolio.py

@@ -0,0 +1,326 @@
+import pandas as pd
+from queue import Queue
+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
+)
+
+
+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 eventdriven 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.
+
+    In addition to the positions and holdings management the portfolio must also be aware of 
+    risk factors and position sizing techniques in order to optimise orders that are sent 
+    to a brokerage or other form of market access.
+
+    Unfortunately, Portfolio and `Order Management Systems (OMS)` can become rather complex!
+    So let's keep the `Portfolio` object relatively straightforward  anf improve it foward.
+
+    Continuing in the vein of the Event class hierarchy a Portfolio object must be able 
+    to handle `SignalEvent` objects, generate `OrderEvent` objects and interpret `FillEvent` 
+    objects to update positions. Thus it is no surprise that the Portfolio objects are often 
+    the largest component of event-driven systems, in terms of lines of code (LOC).
+
+    The initialisation of the Portfolio object requires access to the bars `DataHandler`, 
+    the  `Event Queue`, a `start datetime stamp` and an `initial capital` 
+    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.
+
+    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. 
+    A position is simply the quantity of the asset held. Negative positions mean the asset has been shorted.
+
+    The latter current_positions dictionary stores contains the current positions 
+    for the last market bar update, for each symbol.
+
+    In addition to the positions data the portfolio stores `holdings`, 
+    which describe the current market value of the positions held. "Current market value" 
+    in this instance means the closing price obtained from the current market bar, 
+    which is clearly an approximation, but is reasonable enough for the time being. 
+    `all_holdings` stores the historical list of all symbol holdings, while current_holdings 
+    stores the most up to date dictionary of all symbol holdings values.
+    """
+
+    def __init__(self,
+                 bars: DataHandler,
+                 events: Queue,
+                 start_date: datetime,
+                 initial_capital=100000.0,
+                 **kwargs
+                 ):
+        """
+        Initialises the portfolio with bars and an event queue.
+        Also includes a starting datetime index and initial capital
+        (USD unless otherwise stated).
+
+        Args:
+            bars (DataHandler): The DataHandler object with current market data.
+            events (Queue): The Event Queue object.
+            start_date (datetime): The start date (bar) of the portfolio.
+            initial_capital (float): The starting capital in USD.
+
+            kwargs (dict): Additional arguments
+                - `time_frame`: The time frame of the bars.
+                - `trading_hours`: 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).    
+        """
+        self.bars = bars
+        self.events = events
+        self.symbol_list = self.bars.symbol_list
+        self.start_date = start_date
+        self.initial_capital = initial_capital
+
+        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')
+        if self.timeframe not in self._tf_mapping():
+            raise ValueError(
+                f"Timeframe not supported,"
+                f"please choose one of the following: "
+                f"{', '.join(list(self._tf_mapping().keys()))}"
+            )
+        else:
+            self.tf = self._tf_mapping()[self.timeframe]
+
+        self.all_positions = self.construct_all_positions()
+        self.current_positions = 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()
+
+    def _tf_mapping(self):
+        """
+        Returns a dictionary mapping the time frames
+        to the number of bars in a year.
+        """
+        th = self.trading_hours
+        time_frame_mapping = {}
+        for minutes in [1, 2, 3, 4, 5, 6, 10, 12, 15, 20,
+                        30, 60, 120, 180, 240, 360, 480, 720]:
+            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):
+        """
+        Constructs the positions list using the start_date
+        to determine when the time index will begin.
+        """
+        d = dict((k, v) for k, v in [(s, 0) for s in self.symbol_list])
+        d['Datetime'] = self.start_date
+        return [d]
+
+    def construct_all_holdings(self):
+        """
+        Constructs the holdings list using the start_date
+        to determine when the time index will begin.
+        """
+        d = dict((k, v) for k, v in [(s, 0.0) for s in self.symbol_list])
+        d['Datetime'] = self.start_date
+        d['Cash'] = self.initial_capital
+        d['Commission'] = 0.0
+        d['Total'] = self.initial_capital
+        return [d]
+
+    def construct_current_holdings(self):
+        """
+        This constructs the dictionary which will hold the instantaneous
+        value of the portfolio across all symbols.
+        """
+        d = dict((k, v) for k, v in [(s, 0.0) for s in self.symbol_list])
+        d['Cash'] = self.initial_capital
+        d['Commission'] = 0.0
+        d['Total'] = self.initial_capital
+        return d
+
+    def update_timeindex(self, event: MarketEvent):
+        """
+        Adds a new record to the positions matrix for the current
+        market data bar. This reflects the PREVIOUS bar, i.e. all
+        current market data at this stage is known (OHLCV).
+        Makes use of a MarketEvent from the events queue.
+        """
+        latest_datetime = self.bars.get_latest_bar_datetime(
+            self.symbol_list[0]
+        )
+        # Update positions
+        # ================
+        dp = dict((k, v) for k, v in [(s, 0) for s in self.symbol_list])
+        dp['Datetime'] = latest_datetime
+        for s in self.symbol_list:
+            dp[s] = self.current_positions[s]
+        # Append the current positions
+        self.all_positions.append(dp)
+
+        # Update holdings
+        # ===============
+        dh = dict((k, v) for k, v in [(s, 0) for s in self.symbol_list])
+        dh['Datetime'] = latest_datetime
+        dh['Cash'] = self.current_holdings['Cash']
+        dh['Commission'] = self.current_holdings['Commission']
+        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")
+            dh[s] = market_value
+            dh['Total'] += market_value
+
+        # Append the current holdings
+        self.all_holdings.append(dh)
+
+    def update_positions_from_fill(self, fill: FillEvent):
+        """
+        Takes a Fill object and updates the position matrix to
+        reflect the new position.
+
+        Args:
+            fill (FillEvent): The Fill object to update the positions with.
+        """
+        # Check whether the fill is a buy or sell
+        fill_dir = 0
+        if fill.direction == 'BUY':
+            fill_dir = 1
+        if fill.direction == 'SELL':
+            fill_dir = -1
+
+        # Update positions list with new quantities
+        self.current_positions[fill.symbol] += fill_dir*fill.quantity
+
+    def update_holdings_from_fill(self, fill: FillEvent):
+        """
+        Takes a Fill object and updates the holdings matrix to
+        reflect the holdings value.
+
+        Args:
+            fill (FillEvent): The Fill object to update the holdings with.
+        """
+        # Check whether the fill is a buy or sell
+        fill_dir = 0
+        if fill.direction == 'BUY':
+            fill_dir = 1
+        if fill.direction == 'SELL':
+            fill_dir = -1
+
+        # Update holdings list with new quantities
+        fill_cost = self.bars.get_latest_bar_value(
+            fill.symbol, "Adj Close"
+        )
+        cost = fill_dir * fill_cost * fill.quantity
+        self.current_holdings[fill.symbol] += cost
+        self.current_holdings['Commission'] += fill.commission
+        self.current_holdings['Cash'] -= (cost + fill.commission)
+        self.current_holdings['Total'] -= (cost + fill.commission)
+
+    def update_fill(self, event: FillEvent):
+        """
+        Updates the portfolio current positions and holdings
+        from a FillEvent.
+        """
+        if event.type == 'FILL':
+            self.update_positions_from_fill(event)
+            self.update_holdings_from_fill(event)
+
+    def generate_naive_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.
+
+        Args:
+            signal (SignalEvent): The tuple containing Signal information.
+        """
+        order = None
+
+        symbol = signal.symbol
+        direction = signal.signal_type
+        quantity = signal.quantity
+        strength = signal.strength
+        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')
+        if direction == 'SHORT' and cur_quantity == 0:
+            order = OrderEvent(symbol, order_type, mkt_quantity, 'SELL')
+
+        if direction == 'EXIT' and cur_quantity > 0:
+            order = OrderEvent(symbol, order_type, abs(cur_quantity), 'SELL')
+        if direction == 'EXIT' and cur_quantity < 0:
+            order = OrderEvent(symbol, order_type, abs(cur_quantity), 'BUY')
+
+        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)
+            self.events.put(order_event)
+
+    def create_equity_curve_dataframe(self):
+        """
+        Creates a pandas DataFrame from the all_holdings
+        list of dictionaries.
+        """
+        curve = pd.DataFrame(self.all_holdings)
+        curve.set_index('Datetime', inplace=True)
+        curve['Returns'] = curve['Total'].pct_change(fill_method=None)
+        curve['Equity Curve'] = (1.0+curve['Returns']).cumprod()
+        self.equity_curve = curve
+
+    def output_summary_stats(self):
+        """
+        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']
+
+        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)
+        self.equity_curve['Drawdown'] = drawdown
+
+        stats = [
+            ("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}%"),
+            ("Drawdown Duration", f"{dd_duration}")
+        ]
+        self.equity_curve.to_csv('equity.csv')
+        plot_performance(self.equity_curve, self.strategy_name)
+        plot_returns_and_dd(self.equity_curve,
+                            self.benchmark, self.strategy_name)
+        plot_monthly_yearly_returns(self.equity_curve, self.strategy_name)
+
+        return stats

bbstrader/btengine/strategy.py

@@ -0,0 +1,31 @@
+from abc import ABCMeta, abstractmethod
+
+
+class Strategy(metaclass=ABCMeta):
+    """
+    A `Strategy()` object encapsulates all calculation on market data 
+    that generate advisory signals to a `Portfolio` object. Thus all of 
+    the "strategy logic" resides within this class. We opted to separate 
+    out the `Strategy` and `Portfolio` objects for this backtester, 
+    since we believe this is more amenable to the situation of multiple 
+    strategies feeding "ideas" to a larger `Portfolio`, which then can handle 
+    its own risk (such as sector allocation, leverage). In higher frequency trading, 
+    the strategy and portfolio concepts will be tightly coupled and extremely 
+    hardware dependent.
+
+    At this stage in the event-driven backtester development there is no concept of 
+    an indicator or filter, such as those found in technical trading. These are also 
+    good candidates for creating a class hierarchy.
+
+    The strategy hierarchy is relatively simple as it consists of an abstract 
+    base class with a single pure virtual method for generating `SignalEvent` objects. 
+    """
+
+    @abstractmethod
+    def calculate_signals(self):
+        """
+        Provides the mechanisms to calculate the list of signals.
+        """
+        raise NotImplementedError(
+            "Should implement calculate_signals()"
+        )

bbstrader/metatrader/__init__.py

@@ -0,0 +1,6 @@
+
+from bbstrader.metatrader.account import Account
+from bbstrader.metatrader.rates import Rates
+from bbstrader.metatrader.risk import RiskManagement
+from bbstrader.metatrader.trade import Trade, create_trade_instance
+from bbstrader.metatrader.utils import *