bbstrader 0.1.8__tar.gz → 0.1.91__tar.gz

bbstrader-0.1.91/MANIFEST.in

@@ -0,0 +1 @@
+include requirements.txt

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: bbstrader
-Version: 0.1.8
+Version: 0.1.91
 Summary: Simplified Investment & Trading Toolkit
 Home-page: https://github.com/bbalouki/bbstrader
 Download-URL: https://pypi.org/project/bbstrader/
@@ -34,12 +34,20 @@ Requires-Dist: seaborn
 Requires-Dist: statsmodels
 Requires-Dist: matplotlib
 Requires-Dist: filterpy
+Requires-Dist: pykalman
 Requires-Dist: pytest
 Requires-Dist: CurrencyConverter
 Requires-Dist: tabulate
+Requires-Dist: python-dotenv
 Requires-Dist: ipython
-Requires-Dist: quantstats
-Requires-Dist: Metatrader5
+Requires-Dist: QuantStats
+Requires-Dist: exchange-calendars
+Requires-Dist: tqdm
+Requires-Dist: scikit-learn
+Requires-Dist: notify-py
+Requires-Dist: python-telegram-bot
+Provides-Extra: mt5
+Requires-Dist: MetaTrader5; extra == "mt5"
 
 # Simplified Investment & Trading Toolkit
 ![bbstrader](https://github.com/bbalouki/bbstrader/blob/main/assets/bbstrader_logo.png?raw=true)

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

@@ -7,10 +7,12 @@ __author__      = "Bertin Balouki SIMYELI"
 __copyright__   = "2023-2024 Bertin Balouki SIMYELI"
 __email__       = "bbalouki@outlook.com"
 __license__     = "MIT"
-__version__     = "1.0.0"
+__version__     = '0.1.91'
+
 
 from bbstrader import btengine
 from bbstrader import metatrader
 from bbstrader import models
 from bbstrader import trading
-from bbstrader import tseries
+from bbstrader import tseries
+from .config import config_logger

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

@@ -18,11 +18,11 @@ Features
 Components
 ==========
 
-- **Backtest**: Orchestrates the backtesting process, managing events and invoking components.
+- **BacktestEgine**: 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.
+- **DataHandler**: Abstract class for market data handling, with an implementation for `CSVDataHandler`, `MT5DataHandler`, `YFDataHandler`. We will add another data handling in the future such as MacroEconomic Data, Fundamental Data, TICK Data and Real-time Data.
 - **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`.
+- **ExecutionHandler**: Abstract class for order execution, with a simulated execution handler provided with an implementation for `SimExecutionHandler`.
 - **Performance**: Utility functions for calculating performance metrics and visualizing strategy performance.
 
 Examples
@@ -50,5 +50,5 @@ from bbstrader.btengine.event import *
 from bbstrader.btengine.execution import *
 from bbstrader.btengine.performance import *
 from bbstrader.btengine.backtest import *
-from bbstrader.btengine.strategy import Strategy
-from bbstrader.btengine.portfolio import Portfolio
+from bbstrader.btengine.strategy import *
+from bbstrader.btengine.portfolio import *

{bbstrader-0.1.8 → bbstrader-0.1.91}/bbstrader/btengine/backtest.py

@@ -55,7 +55,11 @@ class Backtest(object):
     the new positions.
 
     """
+    pass
 
+
+class BacktestEngine(Backtest):
+    __doc__ = Backtest.__doc__
     def __init__(
         self,
         symbol_list: List[str],
@@ -123,7 +127,7 @@ class Backtest(object):
             self.initial_capital, **self.kwargs
         )
         self.execution_handler: ExecutionHandler = self.eh_cls(
-            self.events, **self.kwargs)
+            self.events, self.data_handler,  **self.kwargs)
 
     def _run_backtest(self):
         """
@@ -132,11 +136,13 @@ class Backtest(object):
         i = 0
         while True:
             i += 1
-            print(i)
             # Update the market bars
             if self.data_handler.continue_backtest == True:
                 self.data_handler.update_bars()
+                self.strategy.check_pending_orders()
             else:
+                print("\n[======= BACKTEST COMPLETE =======]\n")
+                print(f"Total bars: {i} ")
                 break
 
             # Handle the events
@@ -189,7 +195,7 @@ class Backtest(object):
 
         if self.show_equity:
             print("\nCreating equity curve...")
-            print("\n[======= EQUITY CURVE =======]")
+            print("\n[======= PORTFOLIO SUMMARY =======]")
             print(
                 tabulate(
                     self.portfolio.equity_curve.tail(10), 
@@ -201,11 +207,14 @@ class Backtest(object):
     def simulate_trading(self):
         """
         Simulates the backtest and outputs portfolio performance.
+        
+        Returns:
+            pd.DataFrame: The portfilio values over time (capital, equity, returns etc.)
         """
         self._run_backtest()
         self._output_performance()
+        return self.portfolio.equity_curve
 
-BacktestEngine = Backtest
 
 def run_backtest(
     symbol_list: List[str],
@@ -226,8 +235,8 @@ def run_backtest(
         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` 
+            and processing market data. Available options include `CSVDataHandler`, 
+            `MT5DataHandler`, and `YFDataHandler`. Ensure that the `DataHandler` 
             instance is initialized before passing it to the function.
 
         strategy (Strategy): The trading strategy to be employed during the backtest.
@@ -253,6 +262,9 @@ def run_backtest(
 
         **kwargs: Additional parameters passed to the `Backtest` instance, which may include strategy-specific,
             data handler, portfolio, or execution handler options.
+        
+    Returns:
+        pd.DataFrame: The portfolio values over time (capital, equities, returns etc.).
 
     Notes:
         This function generates three outputs:
@@ -263,7 +275,7 @@ def run_backtest(
     Example:
         >>> from bbstrader.trading.strategies import StockIndexSTBOTrading
         >>> from bbstrader.metatrader.utils import config_logger
-        >>> from bbstrader.datahandlers import MT5HistoricDataHandler
+        >>> from bbstrader.datahandlers import MT5DataHandler
         >>> from bbstrader.execution import MT5ExecutionHandler
         >>> from datetime import datetime
         >>> 
@@ -281,7 +293,7 @@ def run_backtest(
         >>> run_backtest(
         ...     symbol_list=symbol_list,
         ...     start_date=start,
-        ...     data_handler=MT5HistoricDataHandler(),
+        ...     data_handler=MT5DataHandler(),
         ...     strategy=StockIndexSTBOTrading(),
         ...     exc_handler=MT5ExecutionHandler(),
         ...     initial_capital=100000.0,
@@ -290,11 +302,40 @@ def run_backtest(
         ... )
     """
     if exc_handler is None:
-        execution_handler = SimulatedExecutionHandler
+        execution_handler = SimExecutionHandler
     else:
         execution_handler = exc_handler
     engine = BacktestEngine(
         symbol_list, initial_capital, heartbeat, start_date,
         data_handler, execution_handler, strategy, **kwargs
     )
-    engine.simulate_trading()
+    portfolio = engine.simulate_trading()
+    return portfolio
+
+
+class CerebroEngine:...
+
+
+class ZiplineEngine:...
+
+
+def run_backtest_with(engine: Literal["bbstrader", "cerebro", "zipline"], **kwargs):
+    """
+    """
+    if engine == "bbstrader":
+        return run_backtest(
+            symbol_list=kwargs.get("symbol_list"),
+            start_date=kwargs.get("start_date"),
+            data_handler=kwargs.get("data_handler"),
+            strategy=kwargs.get("strategy"),
+            exc_handler=kwargs.get("exc_handler"),
+            initial_capital=kwargs.get("initial_capital"),
+            heartbeat=kwargs.get("heartbeat", 0.0),
+            **kwargs
+        )
+    elif engine == "cerebro":
+        #TODO: 
+        pass
+    elif engine == "zipline":
+        #TODO: 
+        pass

{bbstrader-0.1.8 → bbstrader-0.1.91}/bbstrader/btengine/data.py

@@ -3,20 +3,20 @@ import numpy as np
 import pandas as pd
 import yfinance as yf
 from pathlib import Path
-from typing import List
+from typing import List, Dict
 from queue import Queue
 from abc import ABCMeta, abstractmethod
-from bbstrader.metatrader.rates import Rates
+from bbstrader.metatrader.rates import download_historical_data
 from bbstrader.btengine.event import MarketEvent
+from bbstrader.config import BBSTRADER_DIR
 from datetime import datetime
 
 
 __all__ = [
     "DataHandler",
-    "BaseCSVDataHandler",
-    "HistoricCSVDataHandler",
-    "MT5HistoricDataHandler",
-    "YFHistoricDataHandler"
+    "CSVDataHandler",
+    "MT5DataHandler",
+    "YFDataHandler"
 ]
 
 
@@ -39,9 +39,21 @@ class DataHandler(metaclass=ABCMeta):
     Specific example subclasses could include `HistoricCSVDataHandler`, 
     `YFinanceDataHandler`, `FMPDataHandler`, `IBMarketFeedDataHandler` etc.
     """
+    @property
+    def symbols(self) -> List[str]:
+        pass
+    @property
+    def data(self) -> Dict[str, pd.DataFrame]:
+        pass
+    @property
+    def labels(self) -> List[str]:
+        pass
+    @property
+    def index(self) -> str | List[str]:
+        pass
 
     @abstractmethod
-    def get_latest_bar(self, symbol):
+    def get_latest_bar(self, symbol) -> pd.Series:
         """
         Returns the last bar updated.
         """
@@ -50,7 +62,7 @@ class DataHandler(metaclass=ABCMeta):
         )
 
     @abstractmethod
-    def get_latest_bars(self, symbol, N=1):
+    def get_latest_bars(self, symbol, N=1, df=True) -> pd.DataFrame | List[pd.Series]:
         """
         Returns the last N bars updated.
         """
@@ -59,7 +71,7 @@ class DataHandler(metaclass=ABCMeta):
         )
 
     @abstractmethod
-    def get_latest_bar_datetime(self, symbol):
+    def get_latest_bar_datetime(self, symbol) -> datetime | pd.Timestamp:
         """
         Returns a Python datetime object for the last bar.
         """
@@ -68,7 +80,7 @@ class DataHandler(metaclass=ABCMeta):
         )
 
     @abstractmethod
-    def get_latest_bar_value(self, symbol, val_type):
+    def get_latest_bar_value(self, symbol, val_type) -> float:
         """
         Returns one of the Open, High, Low, Close, Adj Close, Volume or Returns
         from the last bar.
@@ -78,7 +90,7 @@ class DataHandler(metaclass=ABCMeta):
         )
 
     @abstractmethod
-    def get_latest_bars_values(self, symbol, val_type, N=1):
+    def get_latest_bars_values(self, symbol, val_type, N=1) -> np.ndarray:
         """
         Returns the last N bar values from the
         latest_symbol list, or N-k if less available.
@@ -102,40 +114,78 @@ class DataHandler(metaclass=ABCMeta):
 class BaseCSVDataHandler(DataHandler):
     """
     Base class for handling data loaded from CSV files.
+
     """
 
-    def __init__(self, events: Queue, symbol_list: List[str], csv_dir: str):
+    def __init__(self, events: Queue, 
+                 symbol_list: List[str], 
+                 csv_dir: str, 
+                 columns: List[str]=None,
+                 index_col: str | int | List[str] | List[int] = 0):
+        
+        """
+        Initialises the data handler by requesting the location of the CSV files
+        and a list of symbols.
+        
+        Args:
+            events : The Event Queue.
+            symbol_list : A list of symbol strings.
+            csv_dir : Absolute directory path to the CSV files.
+            columns : List of column names to use for the data.
+            index_col : Column to use as the index.
+        """
         self.events = events
         self.symbol_list = symbol_list
         self.csv_dir = csv_dir
+        self.columns = columns
+        self.index_col = index_col
         self.symbol_data = {}
         self.latest_symbol_data = {}
         self.continue_backtest = True
+        self._index = None
         self._load_and_process_data()
 
+    @property
+    def symbols(self)-> List[str]:
+        return self.symbol_list
+    @property
+    def data(self)-> Dict[str, pd.DataFrame]:
+        return self.symbol_data
+    @property
+    def labels(self)-> List[str]:
+        return self.columns
+    @property
+    def index(self)-> str | List[str]:
+        return self._index
+    
     def _load_and_process_data(self):
         """
         Opens the CSV files from the data directory, converting
         them into pandas DataFrames within a symbol dictionary.
         """
+        default_names = pd.read_csv(
+                os.path.join(self.csv_dir, f'{self.symbol_list[0]}.csv')
+                ).columns.to_list()
+        new_names = self.columns or default_names
+        new_names = [name.lower().replace(' ', '_') for name in new_names]
+        self.columns = new_names
+        assert 'adj_close' in new_names or 'close' in new_names, \
+            "Column names must contain 'Adj Close' and 'Close' or adj_close and close"
         comb_index = None
         for s in self.symbol_list:
             # Load the CSV file with no header information,
             # indexed on date
             self.symbol_data[s] = pd.read_csv(
                 os.path.join(self.csv_dir, f'{s}.csv'),
-                header=0, index_col=0, parse_dates=True,
-                names=[
-                    'Datetime', 'Open', 'High',
-                    'Low', 'Close', 'Adj Close', 'Volume'
-                ]
+                header=0, index_col=self.index_col, parse_dates=True,
+                names=new_names
             )
             self.symbol_data[s].sort_index(inplace=True)
             # Combine the index to pad forward values
             if comb_index is None:
                 comb_index = self.symbol_data[s].index
-            else:
-                comb_index.union(self.symbol_data[s].index)
+            elif len(self.symbol_data[s].index) > len(comb_index):
+                comb_index = self.symbol_data[s].index
             # Set the latest symbol_data to None
             self.latest_symbol_data[s] = []
 
@@ -144,10 +194,12 @@ class BaseCSVDataHandler(DataHandler):
             self.symbol_data[s] = self.symbol_data[s].reindex(
                 index=comb_index, method='pad'
             )
-            self.symbol_data[s]["Returns"] = self.symbol_data[s][
-                "Adj Close"
+            self.symbol_data[s]['returns'] = self.symbol_data[s][
+                'adj_close' if 'adj_close' in new_names else 'close'
             ].pct_change().dropna()
-            self.symbol_data[s] = self.symbol_data[s].iterrows()
+            self._index = self.symbol_data[s].index.name
+            if self.events is not None:
+                self.symbol_data[s] = self.symbol_data[s].iterrows()
 
     def _get_new_bar(self, symbol: str):
         """
@@ -156,7 +208,7 @@ class BaseCSVDataHandler(DataHandler):
         for b in self.symbol_data[symbol]:
             yield b
 
-    def get_latest_bar(self, symbol: str):
+    def get_latest_bar(self, symbol: str) -> pd.Series:
         """
         Returns the last bar from the latest_symbol list.
         """
@@ -168,7 +220,7 @@ class BaseCSVDataHandler(DataHandler):
         else:
             return bars_list[-1]
 
-    def get_latest_bars(self, symbol: str, N=1):
+    def get_latest_bars(self, symbol: str, N=1, df=True) -> pd.DataFrame | List[pd.Series]:
         """
         Returns the last N bars from the latest_symbol list,
         or N-k if less available.
@@ -179,9 +231,13 @@ class BaseCSVDataHandler(DataHandler):
             print("Symbol not available in the historical data set.")
             raise
         else:
+            if df:
+                df = pd.DataFrame([bar[1] for bar in bars_list[-N:]])
+                df.index.name = self._index
+                return df
             return bars_list[-N:]
 
-    def get_latest_bar_datetime(self, symbol: str):
+    def get_latest_bar_datetime(self, symbol: str) -> datetime | pd.Timestamp:
         """
         Returns a Python datetime object for the last bar.
         """
@@ -193,7 +249,19 @@ class BaseCSVDataHandler(DataHandler):
         else:
             return bars_list[-1][0]
 
-    def get_latest_bar_value(self, symbol: str, val_type: str):
+    def get_latest_bars_datetime(self, symbol: str, N=1) -> List[datetime | pd.Timestamp]:
+        """
+        Returns a list of Python datetime objects for the last N bars.
+        """
+        try:
+            bars_list = self.get_latest_bars(symbol, N)
+        except KeyError:
+            print("Symbol not available in the historical data set.")
+            raise
+        else:
+            return [b[0] for b in bars_list]
+
+    def get_latest_bar_value(self, symbol: str, val_type: str) -> float:
         """
         Returns one of the Open, High, Low, Close, Volume or OI
         values from the pandas Bar series object.
@@ -206,13 +274,13 @@ class BaseCSVDataHandler(DataHandler):
         else:
             return getattr(bars_list[-1][1], val_type)
 
-    def get_latest_bars_values(self, symbol: str, val_type: str, N=1):
+    def get_latest_bars_values(self, symbol: str, val_type: str, N=1) -> np.ndarray:
         """
         Returns the last N bar values from the
         latest_symbol list, or N-k if less available.
         """
         try:
-            bars_list = self.get_latest_bars(symbol, N)
+            bars_list = self.get_latest_bars(symbol, N, df=False)
         except KeyError:
             print("That symbol is not available in the historical data set.")
             raise
@@ -235,9 +303,9 @@ class BaseCSVDataHandler(DataHandler):
         self.events.put(MarketEvent())
 
 
-class HistoricCSVDataHandler(BaseCSVDataHandler):
+class CSVDataHandler(BaseCSVDataHandler):
     """
-    `HistoricCSVDataHandler` is designed to read CSV files for
+    `CSVDataHandler` is designed to read CSV files for
     each requested symbol from disk and provide an interface
     to obtain the "latest" bar in a manner identical to a live
     trading interface.
@@ -255,14 +323,19 @@ class HistoricCSVDataHandler(BaseCSVDataHandler):
 
         Args:
             events (Queue): The Event Queue.
-            csv_dir (str): Absolute directory path to the CSV files.
             symbol_list (List[str]): A list of symbol strings.
+            csv_dir (str): Absolute directory path to the CSV files.
+        
+        NOTE:
+        All csv fille can be strored in 'Home/.bbstrader/csv_data'
+
         """
         csv_dir = kwargs.get("csv_dir")
+        csv_dir =  csv_dir or BBSTRADER_DIR / 'csv_data'
         super().__init__(events, symbol_list, csv_dir)
 
 
-class MT5HistoricDataHandler(BaseCSVDataHandler):
+class MT5DataHandler(BaseCSVDataHandler):
     """
     Downloads historical data from MetaTrader 5 (MT5) and provides 
     an interface for accessing this data bar-by-bar, simulating 
@@ -284,27 +357,39 @@ class MT5HistoricDataHandler(BaseCSVDataHandler):
                 time_frame (str): MT5 time frame (e.g., 'D1' for daily).
                 mt5_start (datetime): Start date for historical data.
                 mt5_end (datetime): End date for historical data.
-                mt5_data (str): Directory for storing data (default: 'mt5_data').
+                data_dir (str): Directory for storing data .
 
         Note:
             Requires a working connection to an MT5 terminal.
+            See `bbstrader.metatrader.rates.Rates` for other arguments.
+            See `bbstrader.btengine.data.BaseCSVDataHandler` for other arguments.
         """
         self.tf = kwargs.get('time_frame', 'D1')
-        self.start = kwargs.get('mt5_start')
+        self.start = kwargs.get('mt5_start', datetime(2000, 1, 1))
         self.end = kwargs.get('mt5_end', datetime.now())
-        self.data_dir = kwargs.get('mt5_data', 'mt5_data')
+        self.use_utc = kwargs.get('use_utc', False)
+        self.filer = kwargs.get('filter', False)
+        self.fill_na = kwargs.get('fill_na', False)
+        self.lower_cols = kwargs.get('lower_cols', True)
+        self.data_dir = kwargs.get('data_dir')
         self.symbol_list = symbol_list
         csv_dir = self._download_data(self.data_dir)
         super().__init__(events, symbol_list, csv_dir)
 
     def _download_data(self, cache_dir: str):
-        data_dir = Path() / cache_dir
+        data_dir = cache_dir or BBSTRADER_DIR /  'mt5_data' / self.tf 
         data_dir.mkdir(parents=True, exist_ok=True)
         for symbol in self.symbol_list:
             try:
-                rate = Rates(symbol=symbol, time_frame=self.tf)
-                data = rate.get_historical_data(
-                    date_from=self.start, date_to=self.end
+                data = download_historical_data(
+                    symbol=symbol,
+                    time_frame=self.tf,
+                    date_from=self.start, 
+                    date_to=self.end, 
+                    utc=self.use_utc,
+                    filter=self.filer,
+                    fill_na=self.fill_na,
+                    lower_colnames=self.lower_cols
                 )
                 if data is None:
                     raise ValueError(f"No data found for {symbol}")
@@ -314,7 +399,7 @@ class MT5HistoricDataHandler(BaseCSVDataHandler):
         return data_dir
 
 
-class YFHistoricDataHandler(BaseCSVDataHandler):
+class YFDataHandler(BaseCSVDataHandler):
     """
     Downloads historical data from Yahoo Finance and provides 
     an interface for accessing this data bar-by-bar, simulating
@@ -333,40 +418,47 @@ class YFHistoricDataHandler(BaseCSVDataHandler):
             symbol_list (list[str]): List of symbols to download data for.
             yf_start (str): Start date for historical data (YYYY-MM-DD).
             yf_end (str): End date for historical data (YYYY-MM-DD).
-            cache_dir (str, optional): Directory for caching data (default: 'yf_cache').
+            data_dir (str, optional): Directory for caching data .
+
+        Note:
+            See `bbstrader.btengine.data.BaseCSVDataHandler` for other arguments.
         """
         self.symbol_list = symbol_list
-        self.start_date = kwargs.get('yf_start')
-        self.end_date = kwargs.get('yf_end')
-        self.cache_dir = kwargs.get('yf_cache', 'yf_cache')
+        self.start_date = kwargs.get('yf_start', '2000-01-01')
+        self.end_date = kwargs.get('yf_end', datetime.now().strftime('%Y-%m-%d'))
+        self.cache_dir = kwargs.get('data_dir')
         csv_dir = self._download_and_cache_data(self.cache_dir)
         super().__init__(events, symbol_list, csv_dir)
 
     def _download_and_cache_data(self, cache_dir: str):
         """Downloads and caches historical data as CSV files."""
+        cache_dir = cache_dir or BBSTRADER_DIR / 'yf_data' / 'daily'
         os.makedirs(cache_dir, exist_ok=True)
         for symbol in self.symbol_list:
             filepath = os.path.join(cache_dir, f"{symbol}.csv")
-            if not os.path.exists(filepath):
-                try:
-                    data = yf.download(
-                        symbol, start=self.start_date, end=self.end_date)
-                    if data.empty:
-                        raise ValueError(f"No data found for {symbol}")
-                    data.to_csv(filepath)  # Cache the data
-                except Exception as e:
-                    raise ValueError(f"Error downloading {symbol}: {e}")
+            try:
+                data = yf.download(
+                    symbol, start=self.start_date, end=self.end_date, multi_level_index=False)
+                if data.empty:
+                    raise ValueError(f"No data found for {symbol}")
+                data.to_csv(filepath)  # Cache the data
+            except Exception as e:
+                raise ValueError(f"Error downloading {symbol}: {e}")
         return cache_dir
 
 
 # TODO # Get data from EODHD
 # https://eodhd.com/
-class EODHDHistoricDataHandler(BaseCSVDataHandler):
+class EODHDataHandler(BaseCSVDataHandler):
     ...
 
 # TODO # Get data from FMP using Financialtoolkit API
 # https://github.com/bbalouki/FinanceToolkit
-class FMPHistoricDataHandler(BaseCSVDataHandler):
+class FMPDataHandler(BaseCSVDataHandler):
+    ...
+
+
+class AlgoseekDataHandler(BaseCSVDataHandler):
     ...
 
 

{bbstrader-0.1.8 → bbstrader-0.1.91}/bbstrader/btengine/event.py

@@ -57,7 +57,8 @@ class SignalEvent(Event):
                  signal_type: Literal['LONG', 'SHORT', 'EXIT'],
                  quantity: int | float = 100,
                  strength: int | float = 1.0,
-                 price: int | float = None
+                 price: int | float = None,
+                 stoplimit: int | float = None
                  ):
         """
         Initialises the SignalEvent.
@@ -73,6 +74,7 @@ class SignalEvent(Event):
             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.
+            stoplimit (int | float): An optional stop-limit price for the signal
         """
         self.type = 'SIGNAL'
         self.strategy_id = strategy_id
@@ -82,6 +84,7 @@ class SignalEvent(Event):
         self.quantity = quantity
         self.strength = strength
         self.price = price
+        self.stoplimit = stoplimit
 
 
 class OrderEvent(Event):