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

bbstrader/trading/scripts.py

@@ -0,0 +1,57 @@
+import asyncio
+from telegram import Bot
+from notifypy import Notify
+from telegram.error import TelegramError
+
+__all__ = ['send_telegram_message', 'send_notification', 'send_message']
+
+async def send_telegram_message(token, chat_id, text=''):
+    """
+    Send a message to a telegram chat
+
+    Args:
+        token: str: Telegram bot token
+        chat_id: int or str or list: Chat id or list of chat ids
+        text: str: Message to send
+    """
+    try:
+        bot = Bot(token=token)
+        if isinstance(chat_id, (int, str)):
+            chat_id = [chat_id]
+        for id in chat_id:
+            await bot.send_message(chat_id=id, text=text)
+    except TelegramError as e:
+        print(f"Error sending message: {e}")
+
+def send_notification(title, message=''):
+    """
+    Send a desktop notification
+
+    Args:
+        title: str: Title of the notification
+        message: str: Message of the notification
+    """
+    notification = Notify(default_notification_application_name='bbstrading')
+    notification.title = title
+    notification.message = message
+    notification.send()
+    
+def send_message(title='SIGNAL', message='New signal', 
+                notify_me=False, telegram=False, token=None, chat_id=None):
+    """
+    Send a message to the user
+
+    Args:
+        title: str: Title of the message
+        message: str: Message of the message
+        notify_me: bool: Send a desktop notification
+        telegram: bool: Send a telegram message
+        token: str: Telegram bot token
+        chat_id: int or str or list: Chat id or list of chat ids
+    """
+    if notify_me:
+        send_notification(title, message=message)
+    if telegram:
+        if token is None or chat_id is None:
+            raise ValueError('Token and chat_id must be provided')
+        asyncio.run(send_telegram_message(token, chat_id, text=message))

bbstrader/trading/strategies.py

@@ -7,7 +7,6 @@ import pandas as pd
 from queue import Queue
 import yfinance as yf
 from datetime import datetime
-from typing import List, Literal, Dict, Union, Optional
 from bbstrader.metatrader.rates import Rates
 from bbstrader.metatrader.account import Account
 from bbstrader.btengine.event import SignalEvent
@@ -16,26 +15,29 @@ from bbstrader.models.risk import HMMRiskManager
 from bbstrader.models.risk import build_hmm_models
 from bbstrader.btengine.backtest import BacktestEngine
 from bbstrader.btengine.strategy import Strategy
+from bbstrader.btengine.strategy import MT5Strategy
 from bbstrader.btengine.execution import *
 from bbstrader.btengine.data import *
-from bbstrader.tseries import (
-    KalmanFilterModel, ArimaGarchModel)
+from bbstrader.tseries import KalmanFilterModel, ArimaGarchModel
+from typing import Union, Optional, Literal, Dict, List
 
 __all__ = [
     'SMAStrategy', 
     'ArimaGarchStrategy', 
     'KalmanFilterStrategy',
     'StockIndexSTBOTrading',
-    'test_strategy'
+    'test_strategy',
+    'get_quantities'
 ]
 
 
-def _get_quantities(quantities, symbol_list):
+def get_quantities(quantities, symbol_list):
     if isinstance(quantities, dict):
         return quantities
     elif isinstance(quantities, int):
         return {symbol: quantities for symbol in symbol_list}
     
+
 class SMAStrategy(Strategy):
     """
     Carries out a basic Moving Average Crossover strategy bactesting with a
@@ -75,16 +77,13 @@ class SMAStrategy(Strategy):
         """
         self.bars = bars
         self.events = events
-        if symbol_list is not None:
-            self.symbol_list = symbol_list
-        else:
-            self.symbol_list = self.bars.symbol_list
+        self.symbol_list = symbol_list or self.bars.symbol_list
         self.mode = mode
 
         self.short_window = kwargs.get("short_window", 50)
         self.long_window = kwargs.get("long_window", 200)
         self.tf = kwargs.get("time_frame", 'D1')
-        self.qty = _get_quantities(
+        self.qty = get_quantities(
             kwargs.get('quantities', 100), self.symbol_list)
         self.sd = kwargs.get("session_duration", 23.0)
         self.risk_models = build_hmm_models(self.symbol_list, **kwargs)
@@ -101,12 +100,13 @@ class SMAStrategy(Strategy):
     def get_backtest_data(self):
         symbol_data = {symbol: None for symbol in self.symbol_list}
         for s in self.symbol_list:
+            latest_bars = self.bars.get_latest_bars(s, N=self.long_window)
             bar_date = self.bars.get_latest_bar_datetime(s)
             bars = self.bars.get_latest_bars_values(
-                s, "Adj Close", N=self.long_window
+                s, "adj_close", N=self.long_window
             )
             returns_val = self.bars.get_latest_bars_values(
-                s, "Returns", N=self.risk_window
+                s, "returns", N=self.risk_window
             )
             if len(bars) >= self.long_window and len(returns_val) >= self.risk_window:
                 regime = self.risk_models[s].which_trade_allowed(returns_val)
@@ -123,7 +123,7 @@ class SMAStrategy(Strategy):
         for s, data in symbol_data.items():
             signal = None
             if data is not None:
-                price = self.bars.get_latest_bar_value(s, "Adj Close")
+                price = self.bars.get_latest_bar_value(s, "adj_close")
                 short_sma, long_sma, regime, bar_date = data
                 dt = bar_date
                 if regime == "LONG":
@@ -158,8 +158,8 @@ class SMAStrategy(Strategy):
         symbol_data = {symbol: None for symbol in self.symbol_list}
         for symbol in self.symbol_list:
             sig_rate = Rates(symbol, self.tf, 0, self.risk_window)
-            hmm_data = sig_rate.get_returns.values
-            prices = sig_rate.get_close.values
+            hmm_data = sig_rate.returns.values
+            prices = sig_rate.close.values
             current_regime = self.risk_models[symbol].which_trade_allowed(hmm_data)
             assert len(prices) >= self.long_window and len(hmm_data) >= self.risk_window
             short_sma = np.mean(prices[-self.short_window:])
@@ -240,13 +240,10 @@ class ArimaGarchStrategy(Strategy):
         """
         self.bars = bars
         self.events = events
-        if symbol_list is not None:
-            self.symbol_list = symbol_list
-        else:
-            self.symbol_list = self.bars.symbol_list
+        self.symbol_list = symbol_list or self.bars.symbol_list
         self.mode = mode
         
-        self.qty =  _get_quantities(
+        self.qty =  get_quantities(
             kwargs.get('quantities', 100), self.symbol_list)
         self.arima_window = kwargs.get('arima_window', 252)
         self.tf = kwargs.get('time_frame', 'D1')
@@ -258,7 +255,6 @@ class ArimaGarchStrategy(Strategy):
         self.long_market = {s : False for s in self.symbol_list}
         self.short_market = {s : False for s in self.symbol_list}
 
-
     def _build_arch_models(self, **kwargs) -> Dict[str, ArimaGarchModel]:
         arch_models = {symbol: None for symbol in self.symbol_list}
         for symbol in self.symbol_list:
@@ -279,10 +275,10 @@ class ArimaGarchStrategy(Strategy):
             N = self.risk_window
             dt = self.bars.get_latest_bar_datetime(symbol)
             bars = self.bars.get_latest_bars_values(
-                symbol, "Close", N=self.arima_window
+                symbol, "close", N=self.arima_window
             )
             returns = self.bars.get_latest_bars_values(
-                symbol, 'Returns', N=self.risk_window
+                symbol, 'returns', N=self.risk_window
             )
             df = pd.DataFrame()
             df['Close'] = bars[-M:]
@@ -302,7 +298,7 @@ class ArimaGarchStrategy(Strategy):
                 signal = None
                 prediction = self.arima_models[symbol].get_prediction(data)
                 regime = self.risk_models[symbol].which_trade_allowed(returns)
-                price = self.bars.get_latest_bar_value(symbol, "Adj Close")
+                price = self.bars.get_latest_bar_value(symbol, "adj_close")
 
                 # If we are short the market, check for an exit
                 if prediction > 0 and self.short_market[symbol]:
@@ -341,14 +337,15 @@ class ArimaGarchStrategy(Strategy):
             rates = arch_data.get_rates_from_pos()
             arch_returns = self.arima_models[symbol].load_and_prepare_data(rates)
             window_data = arch_returns['diff_log_return'].iloc[-self.arima_window:]
-            hmm_returns = arch_data.get_returns.values[-self.risk_window:]
+            hmm_returns = arch_data.returns.values[-self.risk_window:]
             symbol_data[symbol] = (window_data, hmm_returns)
         return symbol_data
     
     def create_live_signals(self):
         signals = {symbol: None for symbol in self.symbol_list}
+        data = self.get_live_data()
         for symbol in self.symbol_list:
-            symbol_data = self.get_live_data()[symbol]
+            symbol_data = data[symbol]
             if symbol_data is not None:
                 window_data, hmm_returns = symbol_data
                 prediction = self.arima_models[symbol].get_prediction(window_data)
@@ -402,14 +399,12 @@ class KalmanFilterStrategy(Strategy):
         """
         self.bars = bars
         self.events_queue = events
-        if symbol_list is not None:
-            self.symbol_list = symbol_list
-        else:
-            self.symbol_list = self.bars.symbol_list
+        self.symbol_list = symbol_list or self.bars.symbol_list
         self.mode = mode
 
         self.hmm_tiker = kwargs.get("hmm_tiker")
         self._assert_tikers()
+        self.account = Account()
         self.hmm_window = kwargs.get("hmm_window", 50)
         self.qty = kwargs.get("quantity", 100)
         self.tf = kwargs.get("time_frame", "D1")
@@ -436,8 +431,8 @@ class KalmanFilterStrategy(Strategy):
             return
         et, sqrt_Qt = etqt
         theta = self.kl_model.theta
-        p1 = self.bars.get_latest_bar_value(self.tickers[1], "Adj Close")
-        p0 = self.bars.get_latest_bar_value(self.tickers[0], "Adj Close")
+        p1 = self.bars.get_latest_bar_value(self.tickers[1], "adj_close")
+        p0 = self.bars.get_latest_bar_value(self.tickers[0], "adj_close")
         if et >= -sqrt_Qt and self.long_market:
             print("CLOSING LONG: %s" % dt)
             y_signal = SignalEvent(1, self.tickers[1], dt, "EXIT", price=p1)
@@ -480,14 +475,9 @@ class KalmanFilterStrategy(Strategy):
 
     def calculate_livexy(self):
         signals = {symbol: None for symbol in self.symbol_list}
-        p0_ = Rates(self.tickers[0], self.tf, 0, 10)
-        p1_ = Rates(self.tickers[1], self.tf, 0, 10)
-
-        p0_data = p0_.get_close
-        p1_data = p1_.get_close
-        prices = np.array(
-            [p0_data.values[-1], p1_data.values[-1]]
-        )
+        p0_price = self.account.get_tick_info(self.tickers[0]).ask
+        p1_price = self.account.get_tick_info(self.tickers[1]).ask
+        prices = np.array([p0_price, p1_price])
         et_std = self.kl_model.calculate_etqt(prices)
         if et_std is not None:
             et, std = et_std
@@ -513,19 +503,15 @@ class KalmanFilterStrategy(Strategy):
     def calculate_backtest_signals(self):
         p0, p1 = self.tickers[0], self.tickers[1]
         dt = self.bars.get_latest_bar_datetime(p0)
-        _x = self.bars.get_latest_bars_values(
-            p0, "Close", N=1
-        )
-        _y = self.bars.get_latest_bars_values(
-            p1, "Close", N=1
-        )
+        x = self.bars.get_latest_bar_value(p0, "close")
+        y = self.bars.get_latest_bar_value(p1, "close")
         returns = self.bars.get_latest_bars_values(
-            self.hmm_tiker, "Returns", N=self.hmm_window
+            self.hmm_tiker, "returns", N=self.hmm_window
         )
         latest_prices = np.array([-1.0, -1.0])
         if len(returns) >= self.hmm_window:
-            latest_prices[0] = _x[-1]
-            latest_prices[1] = _y[-1]
+            latest_prices[0] = x
+            latest_prices[1] = y
             et_qt = self.kl_model.calculate_etqt(latest_prices)
             regime = self.risk_model[
                 self.hmm_tiker].which_trade_allowed(returns)
@@ -536,7 +522,7 @@ class KalmanFilterStrategy(Strategy):
         signals = {symbol: None for symbol in self.symbol_list}
         initial_signals = self.calculate_livexy()
         hmm_data = Rates(self.hmm_ticker, self.tf, 0, self.hmm_window)
-        returns = hmm_data.get_returns.values
+        returns = hmm_data.returns.values
         current_regime = self.risk_model[
             self.hmm_tiker].which_trade_allowed(returns)
         for symbol in self.symbol_list:
@@ -557,6 +543,7 @@ class KalmanFilterStrategy(Strategy):
                 self.calculate_backtest_signals()
         elif self.mode == 'live':
             return self.calculate_live_signals()
+        
 
 class StockIndexSTBOTrading(Strategy):
     """
@@ -590,10 +577,7 @@ class StockIndexSTBOTrading(Strategy):
         """
         self.bars = bars
         self.events = events
-        if symbol_list is not None:
-            self.symbol_list = symbol_list
-        else:
-            self.symbol_list = self.bars.symbol_list
+        self.symbol_list = symbol_list or self.bars.symbol_list
         self.mode = mode
 
         self.account = Account()
@@ -617,7 +601,7 @@ class StockIndexSTBOTrading(Strategy):
         self.lowerst_price = {index: None for index in symbols}
         
         if self.mode == 'backtest':
-            self.qty = _get_quantities(quantities, symbols)
+            self.qty = get_quantities(quantities, symbols)
             self.num_buys = {index: 0 for index in symbols}
             self.buy_prices = {index: [] for index in symbols}
 
@@ -668,7 +652,7 @@ class StockIndexSTBOTrading(Strategy):
     def calculate_backtest_signals(self):
         for index in self.symbol_list.copy():
             dt = self.bars.get_latest_bar_datetime(index)
-            last_price = self.bars.get_latest_bars_values(index, 'Close', N=1)
+            last_price = self.bars.get_latest_bars_values(index, 'close', N=1)
 
             current_price = last_price[-1]
             if self.last_price[index] is None:
@@ -691,7 +675,6 @@ class StockIndexSTBOTrading(Strategy):
                 and self.num_buys[index] <= self.max_trades[index]):
                 signal = SignalEvent(100, index, dt, 'LONG', 
                                      quantity=self.qty[index], price=current_price)
-                print(f'{dt}: LONG {self.qty[index]} units of {index} at {current_price}')
                 self.events.put(signal)
                 self.num_buys[index] += 1
                 self.buy_prices[index].append(current_price)
@@ -703,12 +686,10 @@ class StockIndexSTBOTrading(Strategy):
                 if self._calculate_pct_change(
                         current_price, av_price) >= (self.expeted_return[index]):
                     signal = SignalEvent(100, index, dt, 'EXIT', quantity=qty, price=current_price)
-                    print(f'{dt}: EXIT {qty} units of {index} at {current_price}')
                     self.events.put(signal)
                     self.num_buys[index] = 0
                     self.buy_prices[index] = []
 
-
     def calculate_signals(self, event=None) -> Dict[str, Union[str, None]]:
         if self.mode == 'backtest' and event is not None:
             if event.type == 'MARKET':
@@ -728,13 +709,12 @@ def _run_backtest(
     engine = BacktestEngine(
         symbol_list, capital, 0.0, datetime.strptime(
             kwargs['yf_start'], "%Y-%m-%d"),
-        kwargs.get("data_handler", YFHistoricDataHandler), 
-        kwargs.get("exc_handler", SimulatedExecutionHandler), 
+        kwargs.get("data_handler", YFDataHandler), 
+        kwargs.get("exc_handler", SimExecutionHandler), 
         kwargs.pop('backtester_class'), **kwargs
     )
     engine.simulate_trading()
 
-
 def _run_arch_backtest(
         capital: float = 100000.0,
         quantity: int = 1000
@@ -746,11 +726,10 @@ def _run_arch_backtest(
         "yf_start": "2010-01-04",
         "hmm_data": hmm_data,
         'backtester_class': ArimaGarchStrategy,
-        "data_handler": YFHistoricDataHandler,
+        "data_handler": YFDataHandler,
     }
     _run_backtest("ARIMA+GARCH & HMM", capital, ["^GSPC"], kwargs)
 
-
 def _run_kf_backtest(
     capital: float = 100000.0,
     quantity: int = 2000
@@ -765,11 +744,10 @@ def _run_kf_backtest(
         "hmm_tiker": "TLT",
         "session_duration": 6.5,
         'backtester_class': KalmanFilterStrategy,
-        "data_handler": YFHistoricDataHandler
+        "data_handler": YFDataHandler
     }
     _run_backtest("Kalman Filter & HMM", capital, symbol_list, kwargs)
 
-
 def _run_sma_backtest(
     capital: float = 100000.0,
     quantity: int = 1
@@ -780,10 +758,10 @@ def _run_sma_backtest(
         "hmm_end":  "2009-12-31",
         "yf_start": "2010-01-04",
         "hmm_data": spx_data,
-        "mt5_start": datetime(2010, 1, 4),
-        "mt5_end": datetime(2023, 1, 1),
+        "mt5_start": datetime(2010,1,1),
+        "mt5_end": datetime(2023,1,1),
         "backtester_class": SMAStrategy,
-        "data_handler": MT5HistoricDataHandler,
+        "data_handler": MT5DataHandler,
         "exc_handler": MT5ExecutionHandler
     }
     _run_backtest("SMA & HMM", capital, ["[SP500]"], kwargs)
@@ -808,7 +786,7 @@ def _run_sistbo_backtest(
         'yf_start': start.strftime('%Y-%m-%d'),
         'time_frame': '15m',
         "backtester_class": StockIndexSTBOTrading,
-        "data_handler": MT5HistoricDataHandler,
+        "data_handler": MT5DataHandler,
         "exc_handler": MT5ExecutionHandler
     }
     _run_backtest("Stock Index Short Term Buy Only ", capital, symbol_list, kwargs)
@@ -837,4 +815,4 @@ def test_strategy(strategy: Literal['sma', 'klf', 'arch', 'sistbo'] = 'sma',
     if strategy in _BACKTESTS:
         _BACKTESTS[strategy](quantity=quantity)
     else:
-        raise ValueError(f"Unknown strategy: {strategy}")
+        raise ValueError(f"Unknown strategy: {strategy}")