bbstrader 0.1.6__tar.gz → 0.1.8__tar.gz

{bbstrader-0.1.6 → bbstrader-0.1.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: bbstrader
-Version: 0.1.6
+Version: 0.1.8
 Summary: Simplified Investment & Trading Toolkit
 Home-page: https://github.com/bbalouki/bbstrader
 Download-URL: https://pypi.org/project/bbstrader/
@@ -36,6 +36,9 @@ Requires-Dist: matplotlib
 Requires-Dist: filterpy
 Requires-Dist: pytest
 Requires-Dist: CurrencyConverter
+Requires-Dist: tabulate
+Requires-Dist: ipython
+Requires-Dist: quantstats
 Requires-Dist: Metatrader5
 
 # Simplified Investment & Trading Toolkit
@@ -43,6 +46,8 @@ Requires-Dist: Metatrader5
 
 [![Documentation Status](https://readthedocs.org/projects/bbstrader/badge/?version=latest)](https://bbstrader.readthedocs.io/en/latest/?badge=latest)
 
+[Dcoumentation](https://bbstrader.readthedocs.io/en/latest/index.html)
+
 ## Overview
 
 BBSTrader is a trading system suite developed for MetaTrader 5 (MT5) and IBKR platforms (comming soon), designed to offer a comprehensive set of tools for developping, backtesting, executing, and managing a wide array of trading strategies. With an emphasis on algorithmic and quantitative trading to provide traders with a robust platform for exploring and deploying sophisticated trading strategies.
@@ -50,7 +55,7 @@ BBSTrader is a trading system suite developed for MetaTrader 5 (MT5) and IBKR pl
 `bbstrader` is comprised of several key modules, each focus on specific aspects of trading strategy development and execution:
 
 - **Backtesting Module (btengine)** : Enables traders to rigorously test their trading strategies using historical data to evaluate performance before live deployment.
-- **Trading Strategies Module**: A collection of predefined trading strategies, including ARIMA+GARCH models, Kalman Filters, Ornstein-Uhlenbeck processes, and Simple Moving Averages, equipped with risk management through Hidden Markov Models.
+- **Trading Strategies Module**: A collection of predefined trading strategies, including ARIMA+GARCH models, Kalman Filters, and Simple Moving Averages, equipped with risk management through Hidden Markov Models.
 - **MetaTrader5 Module (metatrader)**: Facilitates the direct execution of trading strategies on the MetaTrader 5 platform, supporting real-time trading across multiple financial instruments.
 - **Modles Module**: Serves as a framework for implementing various types of financial models (risk managment models, Machine learing models etc).
 - **Time serie Module (tseries)** designed for conducting advanced time series analysis in financial markets. 
@@ -78,18 +83,22 @@ Then, you can install `bbstrader` using pip:
 pip install bbstrader
 ```
 
-
 ## Examples
 ### Backtesting Module
 ```python
-from bbstrader.btengine.backtest  import run_backtest
+from bbstrader.trading.strategies import test_strategy
 
 if __name__ == '__main__':
-    # KLF IEI TLT Event Driven backtest using Kalman Filter pairs trading strategy integrating with # Hidden Markov Model (HMM) for risk management on `IEI` and  `TLT`.
-    run_backtest(test_strategy='klf')
+    # Run backtesting for Stock Index Short Term Buy Only Strategy
+    test_strategy(strategy='sistbo')
+    
 ```
 ### Backtesting Results
-![Backtesting Results](https://github.com/bbalouki/bbstrader/blob/main/assets/backtest_results.jpg?raw=true)
+![Backtesting Results 1](https://github.com/bbalouki/bbstrader/blob/main/assets/bbs_.png?raw=true)
+![Backtesting Results 2](https://github.com/bbalouki/bbstrader/blob/main/assets/qs_metrics_1.png?raw=true)
+![Backtesting Results 3](https://github.com/bbalouki/bbstrader/blob/main/assets/qs_metrics_2.png?raw=true)
+![Backtesting Results 4](https://github.com/bbalouki/bbstrader/blob/main/assets/qs_plots_1_.png?raw=true)
+![Backtesting Results 5](https://github.com/bbalouki/bbstrader/blob/main/assets/qs_plots_2_.png?raw=true)
 
 ## Customization and Contribution
 

{bbstrader-0.1.6 → bbstrader-0.1.8}/README.md

@@ -3,6 +3,8 @@
 
 [![Documentation Status](https://readthedocs.org/projects/bbstrader/badge/?version=latest)](https://bbstrader.readthedocs.io/en/latest/?badge=latest)
 
+[Dcoumentation](https://bbstrader.readthedocs.io/en/latest/index.html)
+
 ## Overview
 
 BBSTrader is a trading system suite developed for MetaTrader 5 (MT5) and IBKR platforms (comming soon), designed to offer a comprehensive set of tools for developping, backtesting, executing, and managing a wide array of trading strategies. With an emphasis on algorithmic and quantitative trading to provide traders with a robust platform for exploring and deploying sophisticated trading strategies.
@@ -10,7 +12,7 @@ BBSTrader is a trading system suite developed for MetaTrader 5 (MT5) and IBKR pl
 `bbstrader` is comprised of several key modules, each focus on specific aspects of trading strategy development and execution:
 
 - **Backtesting Module (btengine)** : Enables traders to rigorously test their trading strategies using historical data to evaluate performance before live deployment.
-- **Trading Strategies Module**: A collection of predefined trading strategies, including ARIMA+GARCH models, Kalman Filters, Ornstein-Uhlenbeck processes, and Simple Moving Averages, equipped with risk management through Hidden Markov Models.
+- **Trading Strategies Module**: A collection of predefined trading strategies, including ARIMA+GARCH models, Kalman Filters, and Simple Moving Averages, equipped with risk management through Hidden Markov Models.
 - **MetaTrader5 Module (metatrader)**: Facilitates the direct execution of trading strategies on the MetaTrader 5 platform, supporting real-time trading across multiple financial instruments.
 - **Modles Module**: Serves as a framework for implementing various types of financial models (risk managment models, Machine learing models etc).
 - **Time serie Module (tseries)** designed for conducting advanced time series analysis in financial markets. 
@@ -38,18 +40,22 @@ Then, you can install `bbstrader` using pip:
 pip install bbstrader
 ```
 
-
 ## Examples
 ### Backtesting Module
 ```python
-from bbstrader.btengine.backtest  import run_backtest
+from bbstrader.trading.strategies import test_strategy
 
 if __name__ == '__main__':
-    # KLF IEI TLT Event Driven backtest using Kalman Filter pairs trading strategy integrating with # Hidden Markov Model (HMM) for risk management on `IEI` and  `TLT`.
-    run_backtest(test_strategy='klf')
+    # Run backtesting for Stock Index Short Term Buy Only Strategy
+    test_strategy(strategy='sistbo')
+    
 ```
 ### Backtesting Results
-![Backtesting Results](https://github.com/bbalouki/bbstrader/blob/main/assets/backtest_results.jpg?raw=true)
+![Backtesting Results 1](https://github.com/bbalouki/bbstrader/blob/main/assets/bbs_.png?raw=true)
+![Backtesting Results 2](https://github.com/bbalouki/bbstrader/blob/main/assets/qs_metrics_1.png?raw=true)
+![Backtesting Results 3](https://github.com/bbalouki/bbstrader/blob/main/assets/qs_metrics_2.png?raw=true)
+![Backtesting Results 4](https://github.com/bbalouki/bbstrader/blob/main/assets/qs_plots_1_.png?raw=true)
+![Backtesting Results 5](https://github.com/bbalouki/bbstrader/blob/main/assets/qs_plots_2_.png?raw=true)
 
 ## Customization and Contribution
 

{bbstrader-0.1.6 → bbstrader-0.1.8}/bbstrader/__ini__.py

@@ -13,5 +13,4 @@ from bbstrader import btengine
 from bbstrader import metatrader
 from bbstrader import models
 from bbstrader import trading
-from bbstrader import strategies
 from bbstrader import tseries

{bbstrader-0.1.6 → bbstrader-0.1.8}/bbstrader/btengine/__init__.py

@@ -12,7 +12,6 @@ Features
 
 - **Event-Driven Architecture**: Processes market data, generates signals, executes orders, and manages portfolio updates in response to events, closely mimicking live trading environments.
 - **Historical Market Data Support**: Utilizes historical OHLCV data from CSV files, Yahoo finance and MT5 terminal allowing for the testing of strategies over various market conditions and time frames.
-- **Strategy Implementation Flexibility**: Abstract base classes for strategies and other components enable users to define custom trading logic and data handling processes.
 - **Performance Metrics Calculation**: Includes tools for calculating key performance indicators, such as `Sharpe Ratio`, `Sortino Ratio`, and `drawdowns`, to evaluate the effectiveness of trading strategies.
 - **Visualization**: Generates plots of the `equity curve`, `returns`, `drawdowns`, and other metrics for comprehensive strategy `performance analysis`.
 
@@ -22,29 +21,34 @@ Components
 - **Backtest**: Orchestrates the backtesting process, managing events and invoking components.
 - **Event**: Abstract class for events, with implementations for market data, signals, fill and order events.
 - **DataHandler**: Abstract class for market data handling, with an implementation for `HistoricalCSVHandler`, `MT5HistoricDataHandler`, `YFHistoricDataHandler`. We will add another data handling in the future such as MacroEconomic Data, Fundamental Data, TICK Data and Real-time Data.
-- **Strategy**: Abstract class for trading strategies, allowing for custom signal generation logic.
 - **Portfolio**: Manages positions and calculates performance metrics, responding to market data and signals.
 - **ExecutionHandler**: Abstract class for order execution, with a simulated execution handler provided with an implementation for `SimulatedExecutionHandler`.
 - **Performance**: Utility functions for calculating performance metrics and visualizing strategy performance.
 
-Examples:
->>> from bbstrader.btengine import run_backtest
->>> run_backtest(test_mode=True, test_strategy='ou', test_quantity=2000)
+Examples
+========
 
+>>> from bbstrader.btengine import run_backtest
+>>> from datetime import datetime
 >>> run_backtest(
 ...     symbol_list=['AAPL', 'GOOG'],
 ...     start_date=datetime(2020, 1, 1),
-...     data_handler=CustomDataHandler(),
-...     strategy=MovingAverageStrategy(),
-...     exc_handler=CustomExecutionHandler(),
+...     data_handler=DataHandler,
+...     strategy=Strategy,
+...     exc_handler=ExecutionHandler,
 ...     initial_capital=500000.0,
 ...     heartbeat=1.0
 ... )
+
+Notes
+=====
+
+See `bbstrader.btengine.backtest.run_backtest` for more details on the backtesting process and its parameters.
 """
 from bbstrader.btengine.data import *
 from bbstrader.btengine.event import *
 from bbstrader.btengine.execution import *
 from bbstrader.btengine.performance import *
 from bbstrader.btengine.backtest import *
-from bbstrader.btengine.portfolio import Portfolio
 from bbstrader.btengine.strategy import Strategy
+from bbstrader.btengine.portfolio import Portfolio

bbstrader-0.1.8/bbstrader/btengine/backtest.py

@@ -0,0 +1,300 @@
+import pprint
+import queue
+import time
+import yfinance as yf
+from queue import Queue
+from datetime import datetime
+from bbstrader.btengine.data import *
+from bbstrader.btengine.execution import *
+from bbstrader.btengine.portfolio import Portfolio
+from bbstrader.btengine.event import SignalEvent
+from bbstrader.btengine.strategy import Strategy
+from typing import Literal, Optional, List
+from tabulate import tabulate
+
+__all__ = [
+    "Backtest",
+    "BacktestEngine",
+    "run_backtest"
+]
+
+class Backtest(object):
+    """
+    The `Backtest()` object encapsulates the event-handling logic and essentially 
+    ties together all of the other classes.
+
+    The Backtest object is designed to carry out a nested while-loop event-driven system 
+    in order to handle the events placed on the `Event` Queue object. 
+    The outer while-loop is known as the "heartbeat loop" and decides the temporal resolution of 
+    the backtesting system. In a live environment this value will be a positive number, 
+    such as 600 seconds (every ten minutes). Thus the market data and positions 
+    will only be updated on this timeframe.
+
+    For the backtester described here the "heartbeat" can be set to zero, 
+    irrespective of the strategy frequency, since the data is already available by virtue of 
+    the fact it is historical! We can run the backtest at whatever speed we like, 
+    since the event-driven system is agnostic to when the data became available, 
+    so long as it has an associated timestamp. 
+
+    The inner while-loop actually processes the signals and sends them to the correct 
+    component depending upon the event type. Thus the Event Queue is continually being 
+    populated and depopulated with events. This is what it means for a system to be event-driven.
+
+    The initialisation of the Backtest object requires the full `symbol list` of traded symbols, 
+    the `initial capital`, the `heartbeat` time in milliseconds, the `start datetime` stamp 
+    of the backtest as well as the `DataHandler`, `ExecutionHandler`, `Strategy` objects
+    and additionnal `kwargs` based on the `ExecutionHandler`, the `DataHandler`, and the `Strategy` used.
+
+    A Queue is used to hold the events. The signals, orders and fills are counted.
+    For a `MarketEvent`, the `Strategy` object is told to recalculate new signals, 
+    while the `Portfolio` object is told to reindex the time. If a `SignalEvent` 
+    object is received the `Portfolio` is told to handle the new signal and convert it into a 
+    set of `OrderEvents`, if appropriate. If an `OrderEvent` is received the `ExecutionHandler` 
+    is sent the order to be transmitted to the broker (if in a real trading setting). 
+    Finally, if a `FillEvent` is received, the Portfolio will update itself to be aware of 
+    the new positions.
+
+    """
+
+    def __init__(
+        self,
+        symbol_list: List[str],
+        initial_capital: float,
+        heartbeat: float,
+        start_date: datetime,
+        data_handler: DataHandler,
+        execution_handler: ExecutionHandler,
+        strategy: Strategy,
+        /,
+        **kwargs
+    ):
+        """
+        Initialises the backtest.
+
+        Args:
+            symbol_list (List[str]): The list of symbol strings.
+            intial_capital (float): The starting capital for the portfolio.
+            heartbeat (float): Backtest "heartbeat" in seconds
+            start_date (datetime): The start datetime of the strategy.
+            data_handler (DataHandler) : Handles the market data feed.
+            execution_handler (ExecutionHandler) : Handles the orders/fills for trades.
+            strategy (Strategy): Generates signals based on market data.
+            kwargs : Additional parameters based on the `ExecutionHandler`, 
+                the `DataHandler`, the `Strategy` used and the `Portfolio`.
+        """
+        self.symbol_list = symbol_list
+        self.initial_capital = initial_capital
+        self.heartbeat = heartbeat
+        self.start_date = start_date
+
+        self.dh_cls = data_handler
+        self.eh_cls = execution_handler
+        self.strategy_cls = strategy
+        self.kwargs = kwargs
+
+        self.events = queue.Queue()
+
+        self.signals = 0
+        self.orders = 0
+        self.fills = 0
+
+        self._generate_trading_instances()
+        self.show_equity = kwargs.get("show_equity", False)
+
+    def _generate_trading_instances(self):
+        """
+        Generates the trading instance objects from
+        their class types.
+        """
+        print(
+            f"\nStarting Backtest on {self.symbol_list} "
+            f"with ${self.initial_capital} Initial Capital\n"
+        )
+        self.data_handler: DataHandler = self.dh_cls(
+            self.events, self.symbol_list, **self.kwargs
+        )
+        self.strategy: Strategy = self.strategy_cls(
+            bars=self.data_handler, events=self.events, **self.kwargs
+        )
+        self.portfolio = Portfolio(
+            self.data_handler,
+            self.events,
+            self.start_date,
+            self.initial_capital, **self.kwargs
+        )
+        self.execution_handler: ExecutionHandler = self.eh_cls(
+            self.events, **self.kwargs)
+
+    def _run_backtest(self):
+        """
+        Executes the backtest.
+        """
+        i = 0
+        while True:
+            i += 1
+            print(i)
+            # Update the market bars
+            if self.data_handler.continue_backtest == True:
+                self.data_handler.update_bars()
+            else:
+                break
+
+            # Handle the events
+            while True:
+                try:
+                    event = self.events.get(False)
+                except queue.Empty:
+                    break
+                else:
+                    if event is not None:
+                        if event.type == 'MARKET':
+                            self.strategy.calculate_signals(event)
+                            self.portfolio.update_timeindex(event)
+
+                        elif event.type == 'SIGNAL':
+                            self.signals += 1
+                            self.portfolio.update_signal(event)
+
+                        elif event.type == 'ORDER':
+                            self.orders += 1
+                            self.execution_handler.execute_order(event)
+
+                        elif event.type == 'FILL':
+                            self.fills += 1
+                            self.portfolio.update_fill(event)
+
+            time.sleep(self.heartbeat)
+
+    def _output_performance(self):
+        """
+        Outputs the strategy performance from the backtest.
+        """
+        self.portfolio.create_equity_curve_dataframe()
+
+        print("\nCreating summary stats...")
+        stats = self.portfolio.output_summary_stats()
+        print("[======= Summary Stats =======]")
+        stat2 = {}
+        stat2['Signals'] = self.signals
+        stat2['Orders'] = self.orders
+        stat2['Fills'] = self.fills
+        stats.extend(stat2.items())
+        print(
+            tabulate(
+                stats, 
+                headers=["Metric", "Value"], 
+                tablefmt="outline"), 
+                "\n"
+            )
+
+        if self.show_equity:
+            print("\nCreating equity curve...")
+            print("\n[======= EQUITY CURVE =======]")
+            print(
+                tabulate(
+                    self.portfolio.equity_curve.tail(10), 
+                    headers="keys", 
+                    tablefmt="outline"), 
+                    "\n"
+                )
+    
+    def simulate_trading(self):
+        """
+        Simulates the backtest and outputs portfolio performance.
+        """
+        self._run_backtest()
+        self._output_performance()
+
+BacktestEngine = Backtest
+
+def run_backtest(
+    symbol_list: List[str],
+    start_date: datetime,
+    data_handler: DataHandler,
+    strategy: Strategy,
+    exc_handler: Optional[ExecutionHandler] = None,
+    initial_capital: float = 100000.0,
+    heartbeat: float = 0.0,
+    **kwargs
+):
+    """
+    Runs a backtest simulation based on a `DataHandler`, `Strategy`, and `ExecutionHandler`.
+
+    Args:
+        symbol_list (List[str]): List of symbol strings for the assets to be backtested.
+        
+        start_date (datetime): Start date of the backtest.
+        
+        data_handler (DataHandler): An instance of the `DataHandler` class, responsible for managing 
+            and processing market data. Available options include `HistoricCSVDataHandler`, 
+            `MT5HistoricDataHandler`, and `YFHistoricDataHandler`. Ensure that the `DataHandler` 
+            instance is initialized before passing it to the function.
+
+        strategy (Strategy): The trading strategy to be employed during the backtest.
+            The strategy must be an instance of `Strategy` and should include the following attributes:
+            - `bars` (DataHandler): The `DataHandler` instance for the strategy.
+            - `events` (Queue): Queue instance for managing events.
+            - `symbol_list` (List[str]): List of symbols to trade.
+            - `mode` (str): 'live' or 'backtest'.
+
+            Additional parameters specific to the strategy should be passed in `**kwargs`.
+            The strategy class must implement a `calculate_signals` method to generate `SignalEvent`.
+
+        exc_handler (ExecutionHandler, optional): The execution handler for managing order executions. 
+            If not provided, a `SimulatedExecutionHandler` will be used by default. This handler must
+            implement an `execute_order` method to process `OrderEvent` in the `Backtest` class.
+
+        initial_capital (float, optional): The initial capital for the portfolio in the backtest. 
+            Default is 100,000.
+
+        heartbeat (float, optional): Time delay (in seconds) between iterations of the event-driven 
+            backtest loop. Default is 0.0, allowing the backtest to run as fast as possible. This could 
+            also be used as a time frame in live trading (e.g., 1m, 5m, 15m) with a live `DataHandler`.
+
+        **kwargs: Additional parameters passed to the `Backtest` instance, which may include strategy-specific,
+            data handler, portfolio, or execution handler options.
+
+    Notes:
+        This function generates three outputs:
+            - A performance summary saved as an HTML file.
+            - An equity curve of the portfolio saved as a CSV file.
+            - Monthly returns saved as a PNG image.
+
+    Example:
+        >>> from bbstrader.trading.strategies import StockIndexSTBOTrading
+        >>> from bbstrader.metatrader.utils import config_logger
+        >>> from bbstrader.datahandlers import MT5HistoricDataHandler
+        >>> from bbstrader.execution import MT5ExecutionHandler
+        >>> from datetime import datetime
+        >>> 
+        >>> logger = config_logger('index_trade.log', console_log=True)
+        >>> symbol_list = ['[SP500]', 'GERMANY40', '[DJI30]', '[NQ100]']
+        >>> start = datetime(2010, 6, 1, 2, 0, 0)
+        >>> kwargs = {
+        ...     'expected_returns': {'[NQ100]': 1.5, '[SP500]': 1.5, '[DJI30]': 1.0, 'GERMANY40': 1.0},
+        ...     'quantities': {'[NQ100]': 15, '[SP500]': 30, '[DJI30]': 5, 'GERMANY40': 10},
+        ...     'max_trades': {'[NQ100]': 3, '[SP500]': 3, '[DJI30]': 3, 'GERMANY40': 3},
+        ...     'mt5_start': start,
+        ...     'time_frame': '15m',
+        ...     'strategy_name': 'SISTBO',
+        ... }
+        >>> run_backtest(
+        ...     symbol_list=symbol_list,
+        ...     start_date=start,
+        ...     data_handler=MT5HistoricDataHandler(),
+        ...     strategy=StockIndexSTBOTrading(),
+        ...     exc_handler=MT5ExecutionHandler(),
+        ...     initial_capital=100000.0,
+        ...     heartbeat=0.0,
+        ...     **kwargs
+        ... )
+    """
+    if exc_handler is None:
+        execution_handler = SimulatedExecutionHandler
+    else:
+        execution_handler = exc_handler
+    engine = BacktestEngine(
+        symbol_list, initial_capital, heartbeat, start_date,
+        data_handler, execution_handler, strategy, **kwargs
+    )
+    engine.simulate_trading()

{bbstrader-0.1.6 → bbstrader-0.1.8}/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-0.1.6 → bbstrader-0.1.8}/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'