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

bbstrader/btengine/strategy.py

@@ -1,5 +1,24 @@
 from abc import ABCMeta, abstractmethod
-from typing import Dict, Union
+import pytz
+import math
+import pandas as pd
+import numpy as np
+from queue import Queue
+from datetime import datetime
+from bbstrader.config import config_logger
+from bbstrader.btengine.event import SignalEvent
+from bbstrader.btengine.data import DataHandler
+from bbstrader.metatrader.account import Account
+from bbstrader.metatrader.rates import Rates
+from typing import (
+    Dict,
+    Union,
+    Any,
+    List,
+    Literal
+)
+
+__all__ = ['Strategy', 'MT5Strategy']
 
 class Strategy(metaclass=ABCMeta):
     """
@@ -22,11 +41,452 @@ class Strategy(metaclass=ABCMeta):
     """
 
     @abstractmethod
-    def calculate_signals(self, *args, **kwargs) -> Dict[str, Union[str, None]]:
+    def calculate_signals(self, *args, **kwargs) -> Any:
+        raise NotImplementedError(
+            "Should implement calculate_signals()"
+        )
+
+    def check_pending_orders(self): ...
+
+
+class MT5Strategy(Strategy):
+    """
+    A `MT5Strategy()` object is a subclass of `Strategy` that is used to 
+    calculate signals for the MetaTrader 5 trading platform. The signals
+    are generated by the `MT5Strategy` object and sent to the the `MT5ExecutionEngine`
+    for live trading and `MT5BacktestEngine` objects for backtesting.
+    """
+
+    def __init__(self, events: Queue=None, symbol_list: List[str]=None,
+                 bars: DataHandler=None, mode: str=None, **kwargs):
+        """
+        Initialize the `MT5Strategy` object.
+
+        Args:
+            events : The event queue.
+            symbol_list : The list of symbols for the strategy.
+            bars : The data handler object.
+            mode : The mode of operation for the strategy (backtest or live).
+            **kwargs : Additional keyword arguments for other classes (e.g, Portfolio, ExecutionHandler).
         """
-        Provides the mechanisms to calculate the list of signals.
+        self.events = events
+        self.data = bars
+        self.symbols = symbol_list
+        self.mode = mode
+        self.volume = kwargs.get("volume")
+        self.logger = kwargs.get("logger", config_logger("mt5_strategy.log"))
+        self._construct_positions_and_orders()
+
+    def _construct_positions_and_orders(self):
+        self.positions: Dict[str, Dict[str, int]] = {}
+        self.orders: Dict[str, Dict[str, List[SignalEvent]]] = {}
+        positions = ['LONG', 'SHORT']
+        orders = ['BLMT', 'BSTP', 'BSTPLMT', 'SLMT', 'SSTP', 'SSTPLMT']
+        for symbol in self.symbols:
+            self.positions[symbol] = {position: 0 for position in positions}
+            self.orders[symbol] = {order: [] for order in orders}
+
+    def calculate_signals(self, *args, **kwargs
+                          ) -> Dict[str, Union[str, dict, None]] | None:
+        """
+        Provides the mechanisms to calculate signals for the strategy.
         This methods should return a dictionary of symbols and their respective signals.
+        The returned signals should be either string or dictionary objects.
+
+        If a string is used, it should be:
+        - ``LONG`` , ``BMKT``, ``BLMT``, ``BSTP``, ``BSTPLMT`` for a long signal (market, limit, stop, stop-limit).
+        - ``SHORT``, ``SMKT``, ``SLMT``, ``SSTP``, ``SSTPLMT`` for a short signal (market, limit, stop, stop-limit).
+        - ``EXIT``, ``EXIT_LONG``, ``EXIT_LONG_STOP``, ``EXIT_LONG_LIMIT``, ``EXIT_LONG_STOP_LIMIT`` for an exit signal (long).
+        - ``EXIT_SHORT``, ``EXIT_SHORT_STOP``, ``EXIT_SHORT_LIMIT``, ``EXIT_SHORT_STOP_LIMIT`` for an exit signal (short).
+        - ``EXIT_ALL_ORDERS`` for cancelling all orders.
+        - ``EXIT_ALL_POSITIONS`` for exiting all positions.
+        - ``EXIT_PROFITABLES`` for exiting all profitable positions.
+        - ``EXIT_LOSINGS`` for exiting all losing positions.
+
+        The signals could also be ``EXIT_STOP``, ``EXIT_LIMIT``, ``EXIT_STOP_LIMIT`` for exiting a position.
+
+        If a dictionary is used, it should be:
+        for each symbol, a dictionary with the following keys
+        - ``action``: The action to take for the symbol (LONG, SHORT, EXIT, etc.)
+        - ``price``: The price at which to execute the action.
+        - ``stoplimit``: The stop-limit price for STOP-LIMIT orders.
+
+        The dictionary can be use for pending orders (limit, stop, stop-limit) where the price is required.
         """
-        raise NotImplementedError(
-            "Should implement calculate_signals()"
-        )
+        pass
+
+    def get_quantity(self, symbol) -> int:
+        """
+        Calculate the quantity to buy or sell for a given symbol based on the dollar value provided.
+        The quantity calculated can be used to evalute a strategy's performance for each symbol
+        given the fact that the dollar value is the same for all symbols.
+
+        Args:
+            symbol : The symbol for the trade.
+
+        Returns:
+            qty : The quantity to buy or sell for the symbol.
+        """
+        if self.volume is None:
+            raise ValueError("Volume must be provided for the method.")
+        current_price = self.data.get_latest_bar_value(symbol, 'close')
+        qty = math.ceil(self.volume / current_price)
+        return max(qty, 1)
+    
+    def get_quantities(self, quantities: Union[None, dict, int]) -> dict:
+        """
+        Get the quantities to buy or sell for the symbols in the strategy.
+        This method is used when whe need to assign different quantities to the symbols.
+
+        Args:
+            quantities : The quantities for the symbols in the strategy.
+        """
+        if quantities is None:
+            return {symbol: None for symbol in self.symbols}
+        if isinstance(quantities, dict):
+            return quantities
+        elif isinstance(quantities, int):
+            return {symbol: quantities for symbol in self.symbols}
+    
+    def _send_order(self, id,  symbol: str, signal: str, strength: float, price: float,
+                    quantity: int, dtime: datetime | pd.Timestamp):
+
+        position = SignalEvent(id, symbol, dtime, signal,
+                               quantity=quantity, strength=strength, price=price)
+        self.events.put(position)
+        self.logger.info(
+            f"{signal} ORDER EXECUTED: SYMBOL={symbol}, QUANTITY={quantity}, PRICE @{price}", custom_time=dtime)
+
+    def buy(self, id: int, symbol: str, price: float, quantity: int, 
+            strength: float=1.0, dtime: datetime | pd.Timestamp=None):
+        """
+        Open a long position
+
+        See `bbstrader.btengine.event.SignalEvent` for more details on arguments.
+        """
+        self._send_order(id, symbol, 'LONG', strength, price, quantity, dtime)
+        self.positions[symbol]['LONG'] += quantity
+
+    def sell(self, id, symbol, price, quantity, strength=1.0, dtime=None):
+        """
+        Open a short position
+
+        See `bbstrader.btengine.event.SignalEvent` for more details on arguments.
+        """
+        self._send_order(id, symbol, 'SHORT', strength,  price, quantity, dtime)
+        self.positions[symbol]['SHORT'] += quantity
+
+    def close(self, id, symbol, price, quantity, strength=1.0, dtime=None):
+        """
+        Close a position
+
+        See `bbstrader.btengine.event.SignalEvent` for more details on arguments.
+        """
+        self._send_order(id, symbol, 'EXIT', strength, price, quantity, dtime)
+        self.positions[symbol]['LONG'] -= quantity
+
+    def buy_stop(self, id, symbol, price, quantity, strength=1.0, dtime=None):
+        """
+        Open a pending order to buy at a stop price
+
+        See `bbstrader.btengine.event.SignalEvent` for more details on arguments.
+        """
+        current_price = self.data.get_latest_bar_value(symbol, 'close')
+        if price <= current_price:
+            raise ValueError(
+                "The buy_stop price must be greater than the current price.")
+        order = SignalEvent(id, symbol, dtime, 'LONG',
+                            quantity=quantity, strength=strength, price=price)
+        self.orders[symbol]['BSTP'].append(order)
+
+    def sell_stop(self, id, symbol, price, quantity, strength=1.0, dtime=None):
+        """
+        Open a pending order to sell at a stop price
+
+        See `bbstrader.btengine.event.SignalEvent` for more details on arguments.
+        """
+        current_price = self.data.get_latest_bar_value(symbol, 'close')
+        if price >= current_price:
+            raise ValueError(
+                "The sell_stop price must be less than the current price.")
+        order = SignalEvent(id, symbol, dtime, 'SHORT',
+                            quantity=quantity, strength=strength, price=price)
+        self.orders[symbol]['SSTP'].append(order)
+
+    def buy_limit(self, id, symbol, price, quantity, strength=1.0, dtime=None):
+        """
+        Open a pending order to buy at a limit price
+
+        See `bbstrader.btengine.event.SignalEvent` for more details on arguments.
+        """
+        current_price = self.data.get_latest_bar_value(symbol, 'close')
+        if price >= current_price:
+            raise ValueError(
+                "The buy_limit price must be less than the current price.")
+        order = SignalEvent(id, symbol, dtime, 'LONG',
+                            quantity=quantity, strength=strength, price=price)
+        self.orders[symbol]['BLMT'].append(order)
+
+    def sell_limit(self, id, symbol, price, quantity, strength=1.0, dtime=None):
+        """
+        Open a pending order to sell at a limit price
+
+        See `bbstrader.btengine.event.SignalEvent` for more details on arguments.
+        """
+        current_price = self.data.get_latest_bar_value(symbol, 'close')
+        if price <= current_price:
+            raise ValueError(
+                "The sell_limit price must be greater than the current price.")
+        order = SignalEvent(id, symbol, dtime, 'SHORT',
+                            quantity=quantity, strength=strength, price=price)
+        self.orders[symbol]['SLMT'].append(order)
+
+    def buy_stop_limit(self, id: int, symbol: str, price: float, stoplimit: float, 
+                       quantity: int, strength: float=1.0, dtime: datetime | pd.Timestamp = None):
+        """
+        Open a pending order to buy at a stop-limit price
+
+        See `bbstrader.btengine.event.SignalEvent` for more details on arguments.
+        """
+        current_price = self.data.get_latest_bar_value(symbol, 'close')
+        if price <= current_price:
+            raise ValueError(
+                f"The stop price {price} must be greater than the current price {current_price}.")
+        if price >= stoplimit:
+            raise ValueError(
+                f"The stop-limit price {stoplimit} must be greater than the price {price}.")
+        order = SignalEvent(id, symbol, dtime, 'LONG',
+                            quantity=quantity, strength=strength, price=price, stoplimit=stoplimit)
+        self.orders[symbol]['BSTPLMT'].append(order)
+
+    def sell_stop_limit(self, id, symbol, price, stoplimit, quantity, strength=1.0, dtime=None):
+        """
+        Open a pending order to sell at a stop-limit price
+
+        See `bbstrader.btengine.event.SignalEvent` for more details on arguments.
+        """
+        current_price = self.data.get_latest_bar_value(symbol, 'close')
+        if price >= current_price:
+            raise ValueError(
+                f"The stop price {price} must be less than the current price {current_price}.")
+        if price <= stoplimit:
+            raise ValueError(
+                f"The stop-limit price {stoplimit} must be less than the price {price}.")
+        order = SignalEvent(id, symbol, dtime, 'SHORT',
+                            quantity=quantity, strength=strength, price=price, stoplimit=stoplimit)
+        self.orders[symbol]['SSTPLMT'].append(order)
+
+    def check_pending_orders(self):
+        """
+        Check for pending orders and handle them accordingly.
+        """
+        for symbol in self.symbols:
+            dtime = self.data.get_latest_bar_datetime(symbol)
+            for order in self.orders[symbol]['BLMT'].copy():
+                if self.data.get_latest_bar_value(symbol, 'close') <= order.price:
+                    self.buy(order.strategy_id, symbol,
+                             order.price, order.quantity, dtime)
+                    self.logger.info(
+                        f"BUY LIMIT ORDER EXECUTED: SYMBOL={symbol}, QUANTITY={order.quantity}, "
+                        f"PRICE @ {order.price}", custom_time=dtime)
+                    self.orders[symbol]['BLMT'].remove(order)
+            for order in self.orders[symbol]['SLMT'].copy():
+                if self.data.get_latest_bar_value(symbol, 'close') >= order.price:
+                    self.sell(order.strategy_id, symbol,
+                              order.price, order.quantity, dtime)
+                    self.logger.info(
+                        f"SELL LIMIT ORDER EXECUTED: SYMBOL={symbol}, QUANTITY={order.quantity}, "
+                        f"PRICE @ {order.price}", custom_time=dtime)
+                    self.orders[symbol]['SLMT'].remove(order)
+            for order in self.orders[symbol]['BSTP'].copy():
+                if self.data.get_latest_bar_value(symbol, 'close') >= order.price:
+                    self.buy(order.strategy_id, symbol,
+                             order.price, order.quantity, dtime)
+                    self.logger.info(
+                        f"BUY STOP ORDER EXECUTED: SYMBOL={symbol}, QUANTITY={order.quantity}, "
+                        f"PRICE @ {order.price}", custom_time=dtime)
+                    self.orders[symbol]['BSTP'].remove(order)
+            for order in self.orders[symbol]['SSTP'].copy():
+                if self.data.get_latest_bar_value(symbol, 'close') <= order.price:
+                    self.sell(order.strategy_id, symbol,
+                              order.price, order.quantity, dtime)
+                    self.logger.info(
+                        f"SELL STOP ORDER EXECUTED: SYMBOL={symbol}, QUANTITY={order.quantity}, "
+                        f"PRICE @ {order.price}", custom_time=dtime)
+                    self.orders[symbol]['SSTP'].remove(order)
+            for order in self.orders[symbol]['BSTPLMT'].copy():
+                if self.data.get_latest_bar_value(symbol, 'close') >= order.price:
+                    self.buy_limit(order.strategy_id, symbol,
+                                   order.stoplimit, order.quantity, dtime)
+                    self.logger.info(
+                        f"BUY STOP LIMIT ORDER EXECUTED: SYMBOL={symbol}, QUANTITY={order.quantity}, "
+                        f"PRICE @ {order.price}", custom_time=dtime)
+                    self.orders[symbol]['BSTPLMT'].remove(order)
+            for order in self.orders[symbol]['SSTPLMT'].copy():
+                if self.data.get_latest_bar_value(symbol, 'close') <= order.price:
+                    self.sell_limit(order.strategy_id, symbol,
+                                    order.stoplimit, order.quantity, dtime)
+                    self.logger.info(
+                        f"SELL STOP LIMIT ORDER EXECUTED: SYMBOL={symbol}, QUANTITY={order.quantity}, "
+                        f"PRICE @ {order.price}", custom_time=dtime)
+                    self.orders[symbol]['SSTPLMT'].remove(order)
+
+    def get_asset_values(self,
+                          symbol_list: List[str],
+                          window: int,
+                          value_type: str = 'returns',
+                          array: bool = True,
+                          bars: DataHandler = None,
+                          mode: Literal['backtest', 'live'] = 'backtest',
+                          tf: str = 'D1'
+                          ) -> Dict[str, np.ndarray | pd.Series] | None:
+        """
+        Get the historical OHLCV value or returns or custum value 
+        based on the DataHandker of the assets in the symbol list.
+
+        Args:
+            bars : DataHandler for market data handling, required for backtest mode.
+            symbol_list : List of ticker symbols for the pairs trading strategy.
+            value_type : The type of value to get (e.g., returns, open, high, low, close, adjclose, volume).
+            array : If True, return the values as numpy arrays, otherwise as pandas Series.
+            mode : Mode of operation for the strategy.
+            window : The lookback period for resquesting the data.
+            tf : The time frame for the strategy.
+
+        Returns:
+            asset_values : Historical values of the assets in the symbol list.
+        
+        Note:
+            In Live mode, the `bbstrader.metatrader.rates.Rates` class is used to get the historical data
+            so the value_type must be 'returns', 'open', 'high', 'low', 'close', 'adjclose', 'volume'.
+        """
+        if mode not in ['backtest', 'live']:
+            raise ValueError('Mode must be either backtest or live.')
+        asset_values = {}
+        if mode == 'backtest':
+            if bars is None:
+                raise ValueError('DataHandler is required for backtest mode.')
+            for asset in symbol_list:
+                if array:
+                    values = bars.get_latest_bars_values(
+                        asset, value_type, N=window)
+                    asset_values[asset] = values[~np.isnan(values)]
+                else:
+                    values = bars.get_latest_bars(asset, N=window)
+                    asset_values[asset] = getattr(values, value_type)    
+        elif mode == 'live':
+            for asset in symbol_list:
+                rates = Rates(symbol=asset, time_frame=tf, count=window + 1)
+                if array:
+                    values = getattr(rates, value_type).values
+                    asset_values[asset] = values[~np.isnan(values)]
+                else:
+                    values = getattr(rates, value_type)
+                    asset_values[asset] = values
+        if all(len(values) >= window for values in asset_values.values()):
+            return {a: v[-window:] for a, v in asset_values.items()}
+        else:
+            return None
+
+    def is_signal_time(self, period_count, signal_inverval) -> bool:
+        """
+        Check if we can generate a signal based on the current period count.
+        We use the signal interval as a form of periodicity or rebalancing period.
+
+        Args:
+            period_count : The current period count (e.g., number of bars).
+            signal_inverval : The signal interval for generating signals (e.g., every 5 bars).
+
+        Returns:
+            bool : True if we can generate a signal, False otherwise
+        """
+        if period_count == 0 or period_count is None:
+            return True
+        return period_count % signal_inverval == 0
+
+    def ispositions(self, symbol, strategy_id, position, max_trades, one_true=False, account=None) -> bool:
+        """
+        This function is use for live trading to check if there are open positions
+        for a given symbol and strategy. It is used to prevent opening more trades
+        than the maximum allowed trades per symbol.
+
+        Args:
+            symbol : The symbol for the trade.
+            strategy_id : The unique identifier for the strategy.
+            position : The position type (1: short, 0: long).
+            max_trades : The maximum number of trades allowed per symbol.
+            one_true : If True, return True if there is at least one open position.
+            account : The `bbstrader.metatrader.Account` object for the strategy.
+
+        Returns:
+            bool : True if there are open positions, False otherwise
+        """
+        account = account or Account()
+        positions = account.get_positions(symbol=symbol)
+        if positions is not None:
+            open_positions = [
+                pos for pos in positions if pos.type == position
+                and pos.magic == strategy_id
+            ]
+            if one_true:
+                return len(open_positions) in range(1, max_trades + 1)
+            return len(open_positions) >= max_trades
+        return False
+
+    def get_positions_prices(self, symbol, strategy_id, position, account=None):
+        """
+        Get the buy or sell prices for open positions of a given symbol and strategy.
+
+        Args:
+            symbol : The symbol for the trade.
+            strategy_id : The unique identifier for the strategy.
+            position : The position type (1: short, 0: long).
+            account : The `bbstrader.metatrader.Account` object for the strategy.
+
+        Returns:
+            prices : numpy array of buy or sell prices for open positions if any or an empty array.
+        """
+        account = account or Account()
+        positions = account.get_positions(symbol=symbol)
+        if positions is not None:
+            prices = np.array([
+                pos.price_open for pos in positions
+                if pos.type == position and pos.magic == strategy_id
+            ])
+            return prices
+        return np.array([])
+
+    def get_current_dt(self, time_zone: str = 'US/Eastern') -> datetime:
+        return datetime.now(pytz.timezone(time_zone))
+
+    def convert_time_zone(self, dt: datetime | int | pd.Timestamp,
+                          from_tz: str = 'UTC',
+                          to_tz: str = 'US/Eastern'
+                          ) -> pd.Timestamp:
+        """
+        Convert datetime from one timezone to another.
+
+        Args:
+            dt : The datetime to convert.
+            from_tz : The timezone to convert from.
+            to_tz : The timezone to convert to.
+
+        Returns:
+            dt_to : The converted datetime.
+        """
+        from_tz = pytz.timezone(from_tz)
+        if isinstance(dt, datetime):
+            dt = pd.to_datetime(dt, unit='s')
+        elif isinstance(dt, int):
+            dt = pd.to_datetime(dt, unit='s')
+        if dt.tzinfo is None:
+            dt = dt.tz_localize(from_tz)
+        else:
+            dt = dt.tz_convert(from_tz)
+
+        dt_to = dt.tz_convert(pytz.timezone(to_tz))
+        return dt_to
+
+
+class TWSStrategy(Strategy):
+    ...

bbstrader/config.py

@@ -0,0 +1,111 @@
+import logging
+from typing import List
+from pathlib import Path
+from datetime import datetime
+
+def get_config_dir(name: str=".bbstrader") -> Path:
+    """
+    Get the path to the configuration directory.
+
+    Args:
+        name: The name of the configuration directory.
+
+    Returns:
+        The path to the configuration directory.
+    """
+    home_dir = Path.home() / name
+    if not home_dir.exists():
+        home_dir.mkdir()
+    return home_dir
+
+BBSTRADER_DIR = get_config_dir()
+
+
+class LogLevelFilter(logging.Filter):
+    def __init__(self, levels: List[int]):
+        """
+        Initializes the filter with specific logging levels.
+
+        Args:
+            levels: A list of logging level values (integers) to include.
+        """
+        super().__init__()
+        self.levels = levels
+
+    def filter(self, record: logging.LogRecord) -> bool:
+        """
+        Filters log records based on their level.
+
+        Args:
+            record: The log record to check.
+
+        Returns:
+            True if the record's level is in the allowed levels, False otherwise.
+        """
+        return record.levelno in self.levels
+    
+
+class CustomFormatter(logging.Formatter):
+    def formatTime(self, record, datefmt=None):
+        if hasattr(record, 'custom_time'):
+            # Use the custom time if provided
+            record.created = record.custom_time.timestamp()
+        return super().formatTime(record, datefmt)
+
+
+class CustomLogger(logging.Logger):
+    def __init__(self, name, level=logging.NOTSET):
+        super().__init__(name, level)
+
+    def _log(self, level, msg, args, exc_info=None, 
+             extra=None, stack_info=False, stacklevel=1, custom_time=None):
+        if extra is None:
+            extra = {}
+        # Add custom_time to the extra dictionary if provided
+        if custom_time:
+            extra['custom_time'] = custom_time
+        super()._log(level, msg, args, exc_info, extra, stack_info, stacklevel)
+
+    def info(self, msg, *args, custom_time=None, **kwargs):
+        self._log(logging.INFO, msg, args, custom_time=custom_time, **kwargs)
+
+    def debug(self, msg, *args, custom_time=None, **kwargs):
+        self._log(logging.DEBUG, msg, args, custom_time=custom_time, **kwargs)
+
+    def warning(self, msg, *args, custom_time=None, **kwargs):
+        self._log(logging.WARNING, msg, args, custom_time=custom_time, **kwargs)
+
+    def error(self, msg, *args, custom_time=None, **kwargs):
+        self._log(logging.ERROR, msg, args, custom_time=custom_time, **kwargs)
+
+    def critical(self, msg, *args, custom_time=None, **kwargs):
+        self._log(logging.CRITICAL, msg, args, custom_time=custom_time, **kwargs)
+
+
+def config_logger(log_file: str, console_log=True):
+
+    # Use the CustomLogger
+    logging.setLoggerClass(CustomLogger)
+    logger = logging.getLogger(__name__)
+    logger.setLevel(logging.DEBUG)
+
+    # File handler
+    file_handler = logging.FileHandler(log_file)
+    file_handler.setLevel(logging.INFO)
+
+    # Custom formatter
+    formatter = CustomFormatter(
+        '%(asctime)s - %(levelname)s: %(message)s', datefmt="%Y-%m-%d %H:%M:%S")
+    file_handler.setFormatter(formatter)
+
+    # Add the handler to the logger
+    logger.addHandler(file_handler)
+
+    if console_log:
+        # Handler for the console with a different level
+        console_handler = logging.StreamHandler()
+        console_handler.setLevel(logging.DEBUG)
+        console_handler.setFormatter(formatter)
+        logger.addHandler(console_handler)
+
+    return logger

bbstrader/metatrader/__init__.py

@@ -1,6 +1,6 @@
 
-from bbstrader.metatrader.account import Account
-from bbstrader.metatrader.rates import Rates
-from bbstrader.metatrader.risk import RiskManagement
-from bbstrader.metatrader.trade import Trade, create_trade_instance
+from bbstrader.metatrader.account import *
+from bbstrader.metatrader.rates import *
+from bbstrader.metatrader.risk import *
+from bbstrader.metatrader.trade import *
 from bbstrader.metatrader.utils import *