bbstrader 0.1.92__tar.gz → 0.1.94__tar.gz

{bbstrader-0.1.92/bbstrader.egg-info → bbstrader-0.1.94}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: bbstrader
-Version: 0.1.92
+Version: 0.1.94
 Summary: Simplified Investment & Trading Toolkit
 Home-page: https://github.com/bbalouki/bbstrader
 Download-URL: https://pypi.org/project/bbstrader/
@@ -47,6 +47,8 @@ Requires-Dist: scikit-learn
 Requires-Dist: notify-py
 Requires-Dist: python-telegram-bot
 Requires-Dist: pyportfolioopt
+Requires-Dist: eodhd
+Requires-Dist: financetoolkit
 Provides-Extra: mt5
 Requires-Dist: MetaTrader5; extra == "mt5"
 

{bbstrader-0.1.92 → bbstrader-0.1.94}/bbstrader/btengine/backtest.py

@@ -85,6 +85,8 @@ class BacktestEngine(Backtest):
             strategy (Strategy): Generates signals based on market data.
             kwargs : Additional parameters based on the `ExecutionHandler`, 
                 the `DataHandler`, the `Strategy` used and the `Portfolio`.
+                - show_equity (bool): Show the equity curve of the portfolio.
+                - stats_file (str): File to save the summary stats.
         """
         self.symbol_list = symbol_list
         self.initial_capital = initial_capital
@@ -104,6 +106,7 @@ class BacktestEngine(Backtest):
 
         self._generate_trading_instances()
         self.show_equity = kwargs.get("show_equity", False)
+        self.stats_file = kwargs.get("stats_file", None)
 
     def _generate_trading_instances(self):
         """
@@ -137,14 +140,21 @@ class BacktestEngine(Backtest):
         i = 0
         while True:
             i += 1
-            # Update the market bars
+            value = self.portfolio.all_holdings[-1]['Total']
             if self.data_handler.continue_backtest == True:
+                # Update the market bars
                 self.data_handler.update_bars()
                 self.strategy.check_pending_orders()
+                self.strategy.get_update_from_portfolio(
+                    self.portfolio.current_positions,
+                    self.portfolio.current_holdings
+                )
+                self.strategy.cash = value
             else:
                 print("\n[======= BACKTEST COMPLETED =======]")
-                print(f"END DATE: {self.data_handler.get_latest_bar_datetime()}")
+                print(f"END DATE: {self.data_handler.get_latest_bar_datetime(self.symbol_list[0])}")
                 print(f"TOTAL BARS: {i} ")
+                print(f"PORFOLIO VALUE: {round(value, 2)}")
                 break
 
             # Handle the events
@@ -171,10 +181,6 @@ class BacktestEngine(Backtest):
                             self.fills += 1
                             self.portfolio.update_fill(event)
                             self.strategy.update_trades_from_fill(event)
-                            self.strategy.get_update_from_portfolio(
-                                self.portfolio.current_positions,
-                                self.portfolio.current_holdings
-                            )
 
             time.sleep(self.heartbeat)
 
@@ -192,13 +198,13 @@ class BacktestEngine(Backtest):
         stat2['Orders'] = self.orders
         stat2['Fills'] = self.fills
         stats.extend(stat2.items())
-        print(
-            tabulate(
-                stats, 
-                headers=["Metric", "Value"], 
-                tablefmt="outline"), 
-                "\n"
-            )
+        tab_stats = tabulate(stats, headers=["Metric", "Value"], tablefmt="outline")
+        print(tab_stats, "\n")
+        if self.stats_file:
+            with open(self.stats_file, 'a') as f:
+                f.write("\n[======= Summary Stats =======]\n")
+                f.write(tab_stats)
+                f.write("\n")
 
         if self.show_equity:
             print("\nCreating equity curve...")
@@ -336,7 +342,7 @@ def run_backtest_with(engine: Literal["bbstrader", "cerebro", "zipline"], **kwar
             data_handler=kwargs.get("data_handler"),
             strategy=kwargs.get("strategy"),
             exc_handler=kwargs.get("exc_handler"),
-            initial_capital=kwargs.get("initial_capital"),
+            initial_capital=kwargs.get("initial_capital", 100000.0),
             heartbeat=kwargs.get("heartbeat", 0.0),
             **kwargs
         )

{bbstrader-0.1.92 → bbstrader-0.1.94}/bbstrader/btengine/data.py

@@ -10,13 +10,18 @@ from bbstrader.metatrader.rates import download_historical_data
 from bbstrader.btengine.event import MarketEvent
 from bbstrader.config import BBSTRADER_DIR
 from datetime import datetime
+from eodhd import APIClient
+from financetoolkit import Toolkit
+from pytz import timezone
 
 
 __all__ = [
     "DataHandler",
     "CSVDataHandler",
     "MT5DataHandler",
-    "YFDataHandler"
+    "YFDataHandler",
+    "EODHDataHandler",
+    "FMPDataHandler",
 ]
 
 
@@ -167,7 +172,7 @@ class BaseCSVDataHandler(DataHandler):
                 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]
+        new_names = [name.strip().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"
@@ -340,7 +345,13 @@ class CSVDataHandler(BaseCSVDataHandler):
         """
         csv_dir = kwargs.get("csv_dir")
         csv_dir =  csv_dir or BBSTRADER_DIR / 'csv_data'
-        super().__init__(events, symbol_list, csv_dir)
+        super().__init__(
+            events, 
+            symbol_list, 
+            csv_dir,
+            columns  =kwargs.get('columns'),
+            index_col=kwargs.get('index_col', 0)
+        )
 
 
 class MT5DataHandler(BaseCSVDataHandler):
@@ -372,32 +383,41 @@ class MT5DataHandler(BaseCSVDataHandler):
             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', datetime(2000, 1, 1))
-        self.end = kwargs.get('mt5_end', datetime.now())
-        self.use_utc = kwargs.get('use_utc', False)
-        self.filer = kwargs.get('filter', False)
-        self.fill_na = kwargs.get('fill_na', False)
+        self.tf         = kwargs.get('time_frame', 'D1')
+        self.start      = kwargs.get('mt5_start', datetime(2000, 1, 1))
+        self.end        = kwargs.get('mt5_end', datetime.now())
+        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.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)
+        self.kwargs = kwargs
+        
+        csv_dir = self._download_and_cache_data(self.data_dir)
+        super().__init__(
+            events,
+            symbol_list,
+            csv_dir,
+            columns  =kwargs.get('columns'),
+            index_col=kwargs.get('index_col', 0)
+        )
 
-    def _download_data(self, cache_dir: str):
-        data_dir = cache_dir or BBSTRADER_DIR /  'mt5_data' / self.tf 
+    def _download_and_cache_data(self, cache_dir: str):
+        data_dir = cache_dir or BBSTRADER_DIR /  'mt5' / self.tf 
         data_dir.mkdir(parents=True, exist_ok=True)
         for symbol in self.symbol_list:
             try:
                 data = download_historical_data(
                     symbol=symbol,
-                    time_frame=self.tf,
+                    timeframe=self.tf,
                     date_from=self.start, 
-                    date_to=self.end, 
+                    date_to=self.end,
                     utc=self.use_utc,
                     filter=self.filer,
                     fill_na=self.fill_na,
-                    lower_colnames=self.lower_cols
+                    lower_colnames=self.lower_cols,
+                    **self.kwargs
                 )
                 if data is None:
                     raise ValueError(f"No data found for {symbol}")
@@ -432,15 +452,23 @@ class YFDataHandler(BaseCSVDataHandler):
             See `bbstrader.btengine.data.BaseCSVDataHandler` for other arguments.
         """
         self.symbol_list = symbol_list
-        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')
+        self.start_date  = kwargs.get('yf_start')
+        self.end_date    = kwargs.get('yf_end', datetime.now())
+        self.cache_dir   = kwargs.get('data_dir')
+        
         csv_dir = self._download_and_cache_data(self.cache_dir)
-        super().__init__(events, symbol_list, csv_dir)
+        
+        super().__init__(
+            events,
+            symbol_list,
+            csv_dir,
+            columns  =kwargs.get('columns'),
+            index_col=kwargs.get('index_col', 0)
+        )
 
     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'
+        cache_dir = cache_dir or BBSTRADER_DIR / 'yfinance' / 'daily'
         os.makedirs(cache_dir, exist_ok=True)
         for symbol in self.symbol_list:
             filepath = os.path.join(cache_dir, f"{symbol}.csv")
@@ -449,39 +477,202 @@ class YFDataHandler(BaseCSVDataHandler):
                     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
+                data.to_csv(filepath)
             except Exception as e:
                 raise ValueError(f"Error downloading {symbol}: {e}")
         return cache_dir
 
 
-# TODO # Get data from EODHD
-# https://eodhd.com/
 class EODHDataHandler(BaseCSVDataHandler):
-    ...
+    """
+    Downloads historical data from EOD Historical Data.
+    Data is fetched using the `eodhd` library.
 
-# TODO # Get data from FMP using Financialtoolkit API
-# https://github.com/bbalouki/FinanceToolkit
-class FMPDataHandler(BaseCSVDataHandler):
-    ...
+    To use this class, you need to sign up for an API key at 
+    https://eodhistoricaldata.com/ and provide the key as an argument.
+    """
+    def __init__(self, events: Queue, symbol_list: List[str], **kwargs):
+        """
+        Args:
+            events (Queue): The Event Queue for passing market events.
+            symbol_list (list[str]): List of symbols to download data for.
+            eodhd_start (str): Start date for historical data (YYYY-MM-DD).
+            eodhd_end (str): End date for historical data (YYYY-MM-DD).
+            data_dir (str, optional): Directory for caching data .
+            eodhd_period (str, optional): Time period for historical data (e.g., 'd', 'w', 'm', '1m', '5m', '1h').
+            eodhd_api_key (str, optional): API key for EOD Historical Data.
 
+        Note:
+            See `bbstrader.btengine.data.BaseCSVDataHandler` for other arguments.
+        """
+        self.symbol_list = symbol_list
+        self.start_date  = kwargs.get('eodhd_start')
+        self.end_date    = kwargs.get('eodhd_end', datetime.now().strftime('%Y-%m-%d'))
+        self.period      = kwargs.get('eodhd_period', 'd')
+        self.cache_dir   = kwargs.get('data_dir')
+        self.__api_key   = kwargs.get('eodhd_api_key', 'demo')
 
-class AlgoseekDataHandler(BaseCSVDataHandler):
-    ...
+        csv_dir = self._download_and_cache_data(self.cache_dir)
+        
+        super().__init__(
+            events, 
+            symbol_list,
+            csv_dir,
+            columns  =kwargs.get('columns'),
+            index_col=kwargs.get('index_col', 0)
+        )
 
+    def _get_data(self, symbol: str, period) -> pd.DataFrame | List[Dict]:
+        if not self.__api_key:
+            raise ValueError("API key is required for EODHD data.")
+        client = APIClient(api_key=self.__api_key)
+        if period in ['d', 'w', 'm']:
+            return client.get_historical_data(
+                symbol=symbol,
+                interval=period, 
+                iso8601_start=self.start_date,
+                iso8601_end=self.end_date,
+            )
+        elif period in ['1m', '5m', '1h']:
+            hms = ' 00:00:00'
+            fmt = '%Y-%m-%d %H:%M:%S'
+            startdt = datetime.strptime(self.start_date + hms, fmt)
+            enddt = datetime.strptime(self.end_date + hms, fmt)
+            startdt = startdt.replace(tzinfo=timezone('UTC'))
+            enddt = enddt.replace(tzinfo=timezone('UTC'))
+            unix_start = int(startdt.timestamp())
+            unix_end = int(enddt.timestamp())
+            return client.get_intraday_historical_data(
+                symbol=symbol,
+                interval=period, 
+                from_unix_time=unix_start,
+                to_unix_time=unix_end,
+            )
+    
+    def _forma_data(self, data: List[Dict] | pd.DataFrame) -> pd.DataFrame:
+        if isinstance(data, pd.DataFrame):
+            if data.empty or len(data) == 0:
+                raise ValueError("No data found.")
+            df = data.drop(labels=['symbol', 'interval'], axis=1)
+            df = df.rename(columns={'adjusted_close': 'adj_close'})
+            return df
+        
+        elif isinstance(data, list):
+            if not data or len(data) == 0:
+                raise ValueError("No data found.")
+            df = pd.DataFrame(data)
+            df = df.drop(columns=['timestamp', 'gmtoffset'], axis=1)
+            df = df.rename(columns={'datetime': 'date'})
+            df['adj_close'] = df['close']
+            df = df[['date', 'open', 'high', 'low', 'close', 'adj_close', 'volume']]
+            df.date = pd.to_datetime(df.date)
+            df = df.set_index('date')
+            return df
+    
+    def _download_and_cache_data(self, cache_dir: str):
+        """Downloads and caches historical data as CSV files."""
+        cache_dir = cache_dir or BBSTRADER_DIR / 'eodhd' / self.period
+        os.makedirs(cache_dir, exist_ok=True)
+        for symbol in self.symbol_list:
+            filepath = os.path.join(cache_dir, f"{symbol}.csv")
+            try:
+                data = self._get_data(symbol, self.period)
+                data = self._forma_data(data)
+                data.to_csv(filepath)
+            except Exception as e:
+                raise ValueError(f"Error downloading {symbol}: {e}")
+        return cache_dir
 
-class BaseFMPDataHanler(object):
+
+class FMPDataHandler(BaseCSVDataHandler):
     """
-    This will serve as the base class for all other FMP data 
-    that is not historical data and does not have an OHLC structure.
+    Downloads historical data from Financial Modeling Prep (FMP).
+    Data is fetched using the `financetoolkit` library.
+
+    To use this class, you need to sign up for an API key at
+    https://financialmodelingprep.com/developer/docs/pricing and
+    provide the key as an argument.
+
     """
-    ...
+    def __init__(self, events: Queue, symbol_list: List[str], **kwargs):
+        """
+        Args:
+            events (Queue): The Event Queue for passing market events.
+            symbol_list (list[str]): List of symbols to download data for.
+            fmp_start (str): Start date for historical data (YYYY-MM-DD).
+            fmp_end (str): End date for historical data (YYYY-MM-DD).
+            data_dir (str, optional): Directory for caching data .
+            fmp_period (str, optional): Time period for historical data 
+                (e.g. daily, weekly, monthly, quarterly, yearly, "1min", "5min", "15min", "30min", "1hour").
+            fmp_api_key (str): API key for Financial Modeling Prep.
 
+        Note:
+            See `bbstrader.btengine.data.BaseCSVDataHandler` for other arguments.
+        """
+        self.symbol_list = symbol_list
+        self.start_date  = kwargs.get('fmp_start')
+        self.end_date    = kwargs.get('fmp_end', datetime.now().strftime('%Y-%m-%d'))
+        self.period      = kwargs.get('fmp_period', 'daily')
+        self.cache_dir   = kwargs.get('data_dir')
+        self.__api_key   = kwargs.get('fmp_api_key')
 
-class FMPFundamentalDataHandler(BaseFMPDataHanler):
-    ...
+        csv_dir = self._download_and_cache_data(self.cache_dir)
+        
+        super().__init__(
+            events,
+            symbol_list,
+            csv_dir,
+            columns  =kwargs.get('columns'),
+            index_col=kwargs.get('index_col', 0)
+        )
 
-# TODO Add other Handlers for FMP
+    def _get_data(self, symbol: str, period: str) -> pd.DataFrame:
+        if not self.__api_key:
+            raise ValueError("API key is required for FMP data.")
+        toolkit = Toolkit(
+            symbol,
+            api_key=self.__api_key,
+            start_date=self.start_date, 
+            end_date=self.end_date,
+            benchmark_ticker=None
+        )
+        if period in ['daily', 'weekly', 'monthly', 'quarterly', 'yearly']:
+            return toolkit.get_historical_data(period=period)
+        elif period in ['1min', '5min', '15min', '30min', '1hour']:
+            return toolkit.get_intraday_data(period=period)
+        
+    def _format_data(self, data: pd.DataFrame, period: str) -> pd.DataFrame:
+        if data.empty or len(data) == 0:
+            raise ValueError("No data found.")
+        if period[0].isnumeric():
+            data = data.drop(columns=['Return', 'Volatility', 'Cumulative Return'], axis=1)
+        else:
+            data = data.drop(columns=['Dividends', 'Return', 'Volatility', 
+                         'Excess Return', 'Excess Volatility', 
+                         'Cumulative Return'], axis=1)
+        data = data.reset_index()
+        if 'Adj Close' not in data.columns:
+            data['Adj Close'] = data['Close']
+        data['date'] = data['date'].dt.to_timestamp()
+        data['date'] = pd.to_datetime(data['date'])
+        data.set_index('date', inplace=True)
+        return data
+    
+    def _download_and_cache_data(self, cache_dir: str):
+        """Downloads and caches historical data as CSV files."""
+        cache_dir = cache_dir or BBSTRADER_DIR / 'fmp' / self.period
+        os.makedirs(cache_dir, exist_ok=True)
+        for symbol in self.symbol_list:
+            filepath = os.path.join(cache_dir, f"{symbol}.csv")
+            try:
+                data = self._get_data(symbol, self.period)
+                data = self._format_data(data, self.period)
+                data.to_csv(filepath)
+            except Exception as e:
+                raise ValueError(f"Error downloading {symbol}: {e}")
+        return cache_dir
 
 
 # TODO Add data Handlers for Interactive Brokers
+class TWSDataHandler(BaseCSVDataHandler):
+    ...

{bbstrader-0.1.92 → bbstrader-0.1.94}/bbstrader/btengine/execution.py

@@ -77,8 +77,9 @@ class SimExecutionHandler(ExecutionHandler):
         if event.type == 'ORDER':
             dtime = self.bardata.get_latest_bar_datetime(event.symbol)
             fill_event = FillEvent(
-                dtime, event.symbol,
-                'ARCA', event.quantity, event.direction, order=event.signal
+                timeindex=dtime, symbol=event.symbol,
+                exchange='ARCA', quantity=event.quantity, direction=event.direction,
+                fill_cost=None, commission=None, order=event.signal
             )
             self.events.put(fill_event)
             self.logger.info(

{bbstrader-0.1.92 → bbstrader-0.1.94}/bbstrader/btengine/performance.py

@@ -6,6 +6,8 @@ from scipy.stats import mstats
 import matplotlib.pyplot as plt
 from matplotlib.ticker import MaxNLocator
 import quantstats as qs
+import warnings
+warnings.filterwarnings("ignore")
 
 sns.set_theme()
 

{bbstrader-0.1.92 → bbstrader-0.1.94}/bbstrader/btengine/portfolio.py

@@ -93,16 +93,20 @@ class Portfolio(object):
             initial_capital (float): The starting capital in USD.
 
             kwargs (dict): Additional arguments
+                - `leverage`: The leverage to apply to the portfolio.
                 - `time_frame`: The time frame of the bars.
-                - `trading_hours`: The number of trading hours in a day.
+                - `session_duration`: 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).    
+                - `output_dir`: The directory to save the backtest results.
+                - `strategy_name`: The name of the strategy  (the name must not include 'Strategy' in it). 
+                - `print_stats`: Whether to print the backtest statistics.   
         """
         self.bars = bars
         self.events = events
         self.symbol_list = self.bars.symbol_list
         self.start_date = start_date
         self.initial_capital = initial_capital
+        self._leverage = kwargs.get('leverage', 1)
 
         self.timeframe = kwargs.get("time_frame", "D1")
         self.trading_hours = kwargs.get("session_duration", 23)
@@ -277,8 +281,7 @@ class Portfolio(object):
 
     def generate_order(self, signal: SignalEvent):
         """
-        Check if the portfolio has enough cash to place an order
-        and generate an OrderEvent, else return None.
+        Turns a SignalEvent into an OrderEvent.
 
         Args:
             signal (SignalEvent): The tuple containing Signal information.
@@ -294,25 +297,17 @@ class Portfolio(object):
         strength = signal.strength
         price = signal.price or self._get_price(symbol)
         cur_quantity = self.current_positions[symbol]
-        cash = self.current_holdings['Cash']
+        mkt_quantity = round(quantity * strength, 2)
+        new_quantity = mkt_quantity * self._leverage
 
         if direction in ['LONG', 'SHORT', 'EXIT']:
             order_type = 'MKT'
         else:
             order_type = direction
-        mkt_quantity = round(quantity * strength)
-        cost = mkt_quantity * price
 
-        if cash >= cost:
-            new_quantity = mkt_quantity
-        elif cash < cost and cash > 0:
-            new_quantity =  round(cash // price)
-        else:
-            new_quantity = 0
-
-        if new_quantity > 0 and direction == 'LONG':
+        if  direction == 'LONG' and new_quantity > 0: 
             order = OrderEvent(symbol, order_type, new_quantity, 'BUY', price, direction)
-        if new_quantity > 0 and direction == 'SHORT':
+        if direction == 'SHORT' and new_quantity > 0:
             order = OrderEvent(symbol, order_type, new_quantity, 'SELL', price, direction)
 
         if direction == 'EXIT' and cur_quantity > 0:
@@ -322,6 +317,7 @@ class Portfolio(object):
 
         return order
 
+
     def update_signal(self, event: SignalEvent):
         """
         Acts on a SignalEvent to generate new orders