bbstrader 0.1.7__py3-none-any.whl → 0.1.9__py3-none-any.whl

bbstrader/metatrader/utils.py

@@ -4,6 +4,38 @@ import logging
 from typing import List, NamedTuple, Optional
 from enum import Enum
 
+
+__all__ = [
+    "TIMEFRAMES",
+    "TimeFrame",
+    "TerminalInfo",
+    "AccountInfo",
+    "SymbolInfo",
+    "TickInfo",
+    "TradeRequest",
+    "OrderCheckResult",
+    "OrderSentResult",
+    "TradeOrder",
+    "TradePosition",
+    "TradeDeal",
+    "InvalidBroker",
+    "GenericFail",
+    "InvalidParams",
+    "HistoryNotFound",
+    "InvalidVersion",
+    "AuthFailed",
+    "UnsupportedMethod",
+    "AutoTradingDisabled",
+    "InternalFailSend",
+    "InternalFailReceive",
+    "InternalFailInit",
+    "InternalFailConnect",
+    "InternalFailTimeout",
+    "trade_retcode_message",
+    "raise_mt5_error",
+    "config_logger",
+]
+
 def config_logger(log_file: str, console_log=True):
     # Configure the logger
     logger = logging.getLogger(__name__)
@@ -55,34 +87,6 @@ class LogLevelFilter(logging.Filter):
         return record.levelno in self.levels
 
 
-__all__ = [
-    "TIMEFRAMES",
-    "TimeFrame",
-    "TerminalInfo",
-    "AccountInfo",
-    "SymbolInfo",
-    "TickInfo",
-    "TradeRequest",
-    "OrderCheckResult",
-    "OrderSentResult",
-    "TradeOrder",
-    "TradePosition",
-    "TradeDeal",
-    "GenericFail",
-    "InvalidParams",
-    "HistoryNotFound",
-    "InvalidVersion",
-    "AuthFailed",
-    "UnsupportedMethod",
-    "AutoTradingDisabled",
-    "InternalFailSend",
-    "InternalFailReceive",
-    "InternalFailInit",
-    "InternalFailConnect",
-    "InternalFailTimeout",
-    "trade_retcode_message",
-    "raise_mt5_error",
-]
 
 # TIMEFRAME is an enumeration with possible chart period values
 # See https://www.mql5.com/en/docs/python_metatrader5/mt5copyratesfrom_py#timeframe
@@ -137,7 +141,6 @@ class TimeFrame(Enum):
     W1 = "W1"
     MN1 = "MN1"
 
-
 class TerminalInfo(NamedTuple):
     """
     Represents general information about the trading terminal.
@@ -467,6 +470,11 @@ class TradeDeal(NamedTuple):
     comment: str
     external_id: str
 
+class InvalidBroker(Exception):
+    """Exception raised for invalid broker errors."""
+    def __init__(self, message="Invalid broker."):
+        super().__init__(message)
+
 
 class MT5TerminalError(Exception):
     """Base exception class for trading-related errors."""

bbstrader/trading/execution.py

@@ -1,12 +1,10 @@
-from math import log
 import time
+import MetaTrader5 as mt5
 from datetime import datetime
 from bbstrader.metatrader.trade import Trade
 from bbstrader.trading.strategies import Strategy
-from typing import Optional, Literal, List, Tuple, Dict
-import MetaTrader5 as mt5
-from bbstrader.metatrader.account import INIT_MSG
-from bbstrader.metatrader.utils import raise_mt5_error
+from bbstrader.metatrader.account import check_mt5_connection
+from typing import Optional, Literal, Tuple, List,  Dict
 
 
 _TF_MAPPING = {
@@ -22,7 +20,7 @@ _TF_MAPPING = {
     'D1':  1440
 }
 
-TRADING_DAYS = [
+TradingDays = [
     'monday', 
     'tuesday', 
     'wednesday', 
@@ -30,19 +28,16 @@ TRADING_DAYS = [
     'friday'
 ]
 
-def _check_mt5_connection():
-    if not mt5.initialize():
-        raise_mt5_error(INIT_MSG)
 
 def _mt5_execution(
-    symbol_list, trades_instances, strategy_cls, /,
-        mm, time_frame, iter_time, period, trading_days,
-        comment, **kwargs
-):
+        symbol_list, trades_instances, strategy_cls, /,
+        mm, trail, stop_trail, trail_after_points, be_plus_points, 
+        time_frame, iter_time, period, period_end_action, trading_days,
+        comment, **kwargs):
     symbols = symbol_list.copy()
     STRATEGY = kwargs.get('strategy_name')
     _max_trades = kwargs.get('max_trades')
-    logger = kwargs.get('logger')
+    logger = trades_instances[symbols[0]].logger
     max_trades = {symbol: _max_trades[symbol] for symbol in symbols}
     if comment is None:
         trade = trades_instances[symbols[0]]
@@ -54,26 +49,33 @@ def _mt5_execution(
         if buys is not None:
             logger.info(
                 f"Checking for Break even, SYMBOL={symbol}...STRATEGY={STRATEGY}")
-            trades_instances[symbol].break_even(mm=mm)
+            trades_instances[symbol].break_even(
+                mm=mm, trail=trail, stop_trail=stop_trail, 
+                trail_after_points=trail_after_points, be_plus_points=be_plus_points)
         if sells is not None:
             logger.info(
                 f"Checking for Break even, SYMBOL={symbol}...STRATEGY={STRATEGY}")
-            trades_instances[symbol].break_even(mm=mm)
+            trades_instances[symbol].break_even(
+                mm=mm, trail=trail, stop_trail=stop_trail, 
+                trail_after_points=trail_after_points, be_plus_points=be_plus_points)
     num_days = 0
     time_intervals = 0
     trade_time = _TF_MAPPING[time_frame]
 
     long_market = {symbol: False for symbol in symbols}
     short_market = {symbol: False for symbol in symbols}
-
+    try:
+        check_mt5_connection()
+        strategy: Strategy = strategy_cls(symbol_list=symbols, mode='live', **kwargs)
+    except Exception as e:
+        logger.error(f"Error initializing strategy, {e}, STRATEGY={STRATEGY}")
+        return
     logger.info(
         f'Running {STRATEGY} Strategy on {symbols} in {time_frame} Interval ...')
-    strategy: Strategy = strategy_cls(
-        symbol_list=symbols, mode='live', **kwargs)
-
+    
     while True:
         try:
-            _check_mt5_connection()
+            check_mt5_connection()
             current_date = datetime.now()
             today = current_date.strftime("%A").lower()
             time.sleep(0.5)
@@ -98,13 +100,21 @@ def _mt5_execution(
                 sells[symbol]) >= max_trades[symbol] for symbol in symbols}
         except Exception as e:
             logger.error(f"{e}, STRATEGY={STRATEGY}")
+            continue
         time.sleep(0.5)
+        try:
+            check_mt5_connection()
+            signals = strategy.calculate_signals()
+        except Exception as e:
+            logger.error(f"Calculating signal, {e}, STRATEGY={STRATEGY}")
+            continue
         for symbol in symbols:
             try:
+                check_mt5_connection()
                 trade = trades_instances[symbol]
                 logger.info(
                     f"Calculating signal... SYMBOL={trade.symbol}, STRATEGY={STRATEGY}")
-                signal = strategy.calculate_signals()[symbol]
+                signal = signals[symbol]
                 if trade.trading_time() and today in trading_days:
                     if signal is not None:
                         logger.info(
@@ -148,7 +158,7 @@ def _mt5_execution(
 
             except Exception as e:
                 logger.error(f"{e}, SYMBOL={symbol}, STRATEGY={STRATEGY}")
-
+                continue
         time.sleep((60 * iter_time) - 1.0)
         if iter_time == 1:
             time_intervals += 1
@@ -160,74 +170,92 @@ def _mt5_execution(
                 f"(e.g; if time_frame is 15m, iter_time must be 1.5, 3, 3, 15 etc)"
             )
         print()
-        if period.lower() == 'day':
-            for symbol in symbols:
-                trade = trades_instances[symbol]
-                if trade.days_end():
-                    trade.close_positions(position_type='all', comment=comment)
-                    logger.info(
-                        f"End of the Day !!! SYMBOL={trade.symbol}, STRATEGY={STRATEGY}")
-                    trade.statistics(save=True)
-            if trades_instances[symbols[-1]].days_end():
-                break
+        try:
+            check_mt5_connection()
+            day_end = all(trade.days_end() for trade in trades_instances.values())
+            if period.lower() == 'day':
+                for symbol in symbols:
+                    trade = trades_instances[symbol]
+                    if trade.days_end():
+                        trade.close_positions(position_type='all', comment=comment)
+                        logger.info(
+                            f"End of the Day !!! SYMBOL={trade.symbol}, STRATEGY={STRATEGY}")
+                        trade.statistics(save=True)
+                if day_end:
+                    if period_end_action == 'break':
+                        break
+                    elif period_end_action == 'sleep':
+                        sleep_time = trades_instances[symbols[-1]].sleep_time()
+                        logger.info(f"Sleeping for {sleep_time} minutes ...\n")
+                        time.sleep(60 * sleep_time)
+                        logger.info("STARTING NEW TRADING SESSION ...\n")
 
-        elif period.lower() == 'week':
-            for symbol in symbols:
-                trade = trades_instances[symbol]
-                if trade.days_end() and today != 'friday':
-                    logger.info(
-                        f"End of the Day !!! SYMBOL={trade.symbol}, STRATEGY={STRATEGY}")
+            elif period.lower() == 'week':
+                for symbol in symbols:
+                    trade = trades_instances[symbol]
+                    if trade.days_end() and today != 'friday':
+                        logger.info(
+                            f"End of the Day !!! SYMBOL={trade.symbol}, STRATEGY={STRATEGY}")
 
-                elif trade.days_end() and today == 'friday':
-                    trade.close_positions(position_type='all', comment=comment)
-                    logger.info(
-                        f"End of the Week !!! SYMBOL={trade.symbol}, STRATEGY={STRATEGY}")
-                    trade.statistics(save=True)
-            if trades_instances[symbols[-1]].days_end() and today != 'friday':
-                sleep_time = trades_instances[symbols[-1]].sleep_time()
-                logger.info(f"Sleeping for {sleep_time} minutes ...")
-                time.sleep(60 * sleep_time)
-                logger.info("\nSTARTING NEW TRADING SESSION ...")
-            elif trades_instances[symbols[-1]].days_end() and today == 'friday':
-                break
+                    elif trade.days_end() and today == 'friday':
+                        trade.close_positions(position_type='all', comment=comment)
+                        logger.info(
+                            f"End of the Week !!! SYMBOL={trade.symbol}, STRATEGY={STRATEGY}")
+                        trade.statistics(save=True)
+                if day_end and today != 'friday':
+                    sleep_time = trades_instances[symbols[-1]].sleep_time()
+                    logger.info(f"Sleeping for {sleep_time} minutes ...\n")
+                    time.sleep(60 * sleep_time)
+                    logger.info("STARTING NEW TRADING SESSION ...\n")
+                elif day_end and today == 'friday':
+                    if period_end_action == 'break':
+                        break
+                    elif period_end_action == 'sleep':
+                        sleep_time = trades_instances[symbols[-1]].sleep_time(weekend=True)
+                        logger.info(f"Sleeping for {sleep_time} minutes ...\n")
+                        time.sleep(60 * sleep_time)
+                        logger.info("STARTING NEW TRADING SESSION ...\n")
 
-        elif period.lower() == 'month':
-            for symbol in symbols:
-                trade = trades_instances[symbol]
-                if trade.days_end() and today != 'friday':
-                    logger.info(
-                        f"End of the Day !!! SYMBOL={trade.symbol}, STRATEGY={STRATEGY}")
+            elif period.lower() == 'month':
+                for symbol in symbols:
+                    trade = trades_instances[symbol]
+                    if trade.days_end() and today != 'friday':
+                        logger.info(
+                            f"End of the Day !!! SYMBOL={trade.symbol}, STRATEGY={STRATEGY}")
 
-                elif trade.days_end() and today == 'friday':
-                    logger.info(
-                        f"End of the Week !!! SYMBOL={trade.symbol}, STRATEGY={STRATEGY}")
-                elif (
-                    trade.days_end()
-                    and today == 'friday'
-                    and num_days/len(symbols) >= 20
-                ):
-                    trade.close_positions(position_type='all', comment=comment)
-                    logger.info(
-                        f"End of the Month !!! SYMBOL={trade.symbol}, STRATEGY={STRATEGY}")
-                    trade.statistics(save=True)
-            if trades_instances[symbols[-1]].days_end() and today != 'friday':
-                sleep_time = trades_instances[symbols[-1]].sleep_time()
-                logger.info(f"Sleeping for {sleep_time} minutes ...")
-                time.sleep(60 * sleep_time)
-                logger.info("\nSTARTING NEW TRADING SESSION ...")
-                num_days += 1
-            elif trades_instances[symbols[-1]].days_end() and today == 'friday':
-                sleep_time = trades_instances[symbols[-1]
-                                              ].sleep_time(weekend=True)
-                logger.info(f"Sleeping for {sleep_time} minutes ...")
-                time.sleep(60 * sleep_time)
-                logger.info("\nSTARTING NEW TRADING SESSION ...")
-                num_days += 1
-            elif (trades_instances[symbols[-1]].days_end()
-                  and today == 'friday'
-                  and num_days/len(symbols) >= 20
-                  ):
-                break
+                    elif trade.days_end() and today == 'friday':
+                        logger.info(
+                            f"End of the Week !!! SYMBOL={trade.symbol}, STRATEGY={STRATEGY}")
+                    elif (
+                        trade.days_end()
+                        and today == 'friday'
+                        and num_days/len(symbols) >= 20
+                    ):
+                        trade.close_positions(position_type='all', comment=comment)
+                        logger.info(
+                            f"End of the Month !!! SYMBOL={trade.symbol}, STRATEGY={STRATEGY}")
+                        trade.statistics(save=True)
+                if day_end and today != 'friday':
+                    sleep_time = trades_instances[symbols[-1]].sleep_time()
+                    logger.info(f"Sleeping for {sleep_time} minutes ...\n")
+                    time.sleep(60 * sleep_time)
+                    logger.info("STARTING NEW TRADING SESSION ...\n")
+                    num_days += 1
+                elif day_end and today == 'friday':
+                    sleep_time = trades_instances[symbols[-1]
+                                                ].sleep_time(weekend=True)
+                    logger.info(f"Sleeping for {sleep_time} minutes ...\n")
+                    time.sleep(60 * sleep_time)
+                    logger.info("STARTING NEW TRADING SESSION ...\n")
+                    num_days += 1
+                elif (day_end
+                        and today == 'friday'
+                        and num_days/len(symbols) >= 20
+                    ):
+                    break
+        except Exception as e:
+            logger.error(f"Handling period end actions, {e}, STRATEGY={STRATEGY}")
+            continue
 
 
 def _tws_execution(*args, **kwargs):
@@ -317,10 +345,15 @@ class ExecutionEngine():
                  strategy_cls:       Strategy,
                  /,
                  mm:                 Optional[bool] = True,
+                 trail:              Optional[bool] = True,
+                 stop_trail:         Optional[int] = None,
+                 trail_after_points: Optional[int] = None,
+                 be_plus_points:     Optional[int] = None,
                  time_frame:         Optional[str] = '15m',
                  iter_time:          Optional[int | float] = 5,
                  period:             Literal['day', 'week', 'month'] = 'week',
-                 trading_days:       Optional[List[str]] = TRADING_DAYS,
+                 period_end_action:  Literal['break', 'sleep'] = 'break',
+                 trading_days:       Optional[List[str]] = TradingDays,
                  comment:            Optional[str] = None,
                  **kwargs
                  ):
@@ -333,18 +366,20 @@ class ExecutionEngine():
             time_frame : Time frame to trade. Defaults to '15m'.
             iter_time : Interval to check for signals and `mm`. Defaults to 5.
             period : Period to trade. Defaults to 'week'.
+            period_end_action : Action to take at the end of the period. Defaults to 'break', 
+                this only applies when period is 'day', 'week'.
             trading_days : Trading days in a week. Defaults to monday to friday.
             comment: Comment for trades. Defaults to None.
             **kwargs: Additional keyword arguments
                 - strategy_name (Optional[str]): Strategy name. Defaults to None.
                 - max_trades (Dict[str, int]): Maximum trades per symbol. Defaults to None.
-                - logger (Optional[logging.Logger]): Logger instance. Defaults to None.
 
         Note:
-            1. All Strategies must inherit from `bbstrader.btengine.strategy.Strategy` class
+            1. For `trail` , `stop_trail` , `trail_after_points` , `be_plus_points` see `bbstrader.metatrader.trade.Trade.break_even()` .
+            2. All Strategies must inherit from `bbstrader.btengine.strategy.Strategy` class
             and have a `calculate_signals` method that returns a dictionary of signals for each symbol in symbol_list.
             
-            2. All strategies must have the following arguments in their `__init__` method:
+            3. All strategies must have the following arguments in their `__init__` method:
                 - bars (DataHandler): DataHandler instance default to None
                 - events (Queue): Queue instance default to None
                 - symbol_list (List[str]): List of symbols to trade can be none for backtesting
@@ -354,16 +389,21 @@ class ExecutionEngine():
                     the `Strategy` class, the `DataHandler` class, the `Portfolio` class and the `ExecutionHandler` class.
                 - The `bars` and `events` arguments are used for backtesting only.
             
-            3. All strategies must generate signals for backtesting and live trading.
+            4. All strategies must generate signals for backtesting and live trading.
             See the `bbstrader.trading.strategies` module for more information on how to create custom strategies.
         """
         self.symbol_list = symbol_list
         self.trades_instances = trades_instances
         self.strategy_cls = strategy_cls
         self.mm = mm
+        self.trail = trail
+        self.stop_trail = stop_trail
+        self.trail_after_points = trail_after_points
+        self.be_plus_points = be_plus_points
         self.time_frame = time_frame
         self.iter_time = iter_time
         self.period = period
+        self.period_end_action = period_end_action
         self.trading_days = trading_days
         self.comment = comment
         self.kwargs = kwargs
@@ -372,14 +412,21 @@ class ExecutionEngine():
         if terminal not in _TERMINALS:
             raise ValueError(
                 f"Invalid terminal: {terminal}. Must be either 'MT5' or 'TWS'")
+        elif terminal == 'MT5':
+            check_mt5_connection()
         _TERMINALS[terminal](
                 self.symbol_list,
                 self.trades_instances,
                 self.strategy_cls,
                 mm=self.mm,
+                trail=self.trail,
+                stop_trail=self.stop_trail,
+                trail_after_points=self.trail_after_points,
+                be_plus_points=self.be_plus_points,
                 time_frame=self.time_frame,
                 iter_time=self.iter_time,
                 period=self.period,
+                period_end_action=self.period_end_action,
                 trading_days=self.trading_days,
                 comment=self.comment,
                 **self.kwargs

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
@@ -19,18 +18,20 @@ from bbstrader.btengine.strategy import Strategy
 from bbstrader.btengine.execution import *
 from bbstrader.btengine.data import *
 from bbstrader.tseries import (
-    KalmanFilterModel, ArimaGarchModel
-)
+    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):
@@ -84,7 +85,7 @@ class SMAStrategy(Strategy):
         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)
@@ -246,7 +247,7 @@ class ArimaGarchStrategy(Strategy):
             self.symbol_list = 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')
@@ -557,6 +558,7 @@ class KalmanFilterStrategy(Strategy):
                 self.calculate_backtest_signals()
         elif self.mode == 'live':
             return self.calculate_live_signals()
+        
 
 class StockIndexSTBOTrading(Strategy):
     """
@@ -617,7 +619,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}
 
@@ -653,13 +655,15 @@ class StockIndexSTBOTrading(Strategy):
                         position.price_open for position in positions
                         if position.type == 0 and position.magic == self.ID
                     ]
+                    if len(buy_prices) == 0:
+                        continue
                     avg_price = sum(buy_prices) / len(buy_prices)
                     if self._calculate_pct_change(
                             current_price, avg_price) >= (self.expeted_return[index]):
                         signals[index] = 'EXIT'
                 self.logger.info(
                     f"SYMBOL={index} - Hp={self.heightest_price[index]} - " 
-                    f"Lp={self.lowerst_price[index]} - Cp={current_price} - %change={down_change}"
+                    f"Lp={self.lowerst_price[index]} - Cp={current_price} - %chg={round(down_change, 2)}"
                 )
         return signals