bbstrader 0.3.3__py3-none-any.whl → 0.3.4__py3-none-any.whl

bbstrader/btengine/strategy.py

@@ -11,10 +11,12 @@ from loguru import logger
 
 from bbstrader.btengine.data import DataHandler
 from bbstrader.btengine.event import Events, FillEvent, SignalEvent
+from bbstrader.metatrader.trade import generate_signal, TradeAction 
 from bbstrader.config import BBSTRADER_DIR
 from bbstrader.metatrader import (
     Account,
     AdmiralMarktsGroup,
+    MetaQuotes,
     PepperstoneGroupLimited,
     TradeOrder,
     Rates,
@@ -78,7 +80,16 @@ class MT5Strategy(Strategy):
     in order to avoid naming collusion.
     """
     tf: str
+    id: int
+    ID: int
+    
     max_trades: Dict[str, int]
+    risk_budget: Dict[str, float] | str | None
+
+    _orders: Dict[str, Dict[str, List[SignalEvent]]]
+    _positions: Dict[str, Dict[str, int | float]]
+    _trades: Dict[str, Dict[str, int]]
+
     def __init__(
         self,
         events: Queue = None,
@@ -104,13 +115,19 @@ class MT5Strategy(Strategy):
         self.data = bars
         self.symbols = symbol_list
         self.mode = mode
-        self._porfolio_value = None
+        if self.mode not in [TradingMode.BACKTEST, TradingMode.LIVE]:
+            raise ValueError(f"Mode must be an instance of {type(TradingMode)} not {type(self.mode)}")
+        
         self.risk_budget = self._check_risk_budget(**kwargs)
+
         self.max_trades = kwargs.get("max_trades", {s: 1 for s in self.symbols})
         self.tf = kwargs.get("time_frame", "D1")
         self.logger = kwargs.get("logger") or logger
+
         if self.mode == TradingMode.BACKTEST:
+            self._porfolio_value = None
             self._initialize_portfolio()
+
         self.kwargs = kwargs
         self.periodes = 0
 
@@ -170,19 +187,17 @@ class MT5Strategy(Strategy):
             return weights
 
     def _initialize_portfolio(self):
-        positions = ["LONG", "SHORT"]
-        orders = ["BLMT", "BSTP", "BSTPLMT", "SLMT", "SSTP", "SSTPLMT"]
-        self._orders: Dict[str, Dict[str, List[SignalEvent]]] = {}
-        self._positions: Dict[str, Dict[str, int | float]] = {}
-        self._trades: Dict[str, Dict[str, int]] = {}
+        self._orders = {}
+        self._positions = {}
+        self._trades =  {}
         for symbol in self.symbols:
             self._positions[symbol] = {}
             self._orders[symbol] = {}
             self._trades[symbol] = {}
-            for position in positions:
+            for position in ["LONG", "SHORT"]:
                 self._trades[symbol][position] = 0
                 self._positions[symbol][position] = 0.0
-            for order in orders:
+            for order in ["BLMT", "BSTP", "BSTPLMT", "SLMT", "SSTP", "SSTPLMT"]:
                 self._orders[symbol][order] = []
         self._holdings = {s: 0.0 for s in self.symbols}
 
@@ -236,6 +251,54 @@ class MT5Strategy(Strategy):
         """
         pass
 
+    def signal(self, signal: int, symbol: str) -> TradeSignal:
+        """
+        Generate a ``TradeSignal`` object based on the signal value.
+        Args:
+            signal : An integer value representing the signal type:
+                     0: BUY
+                     1: SELL
+                     2: EXIT_LONG
+                     3: EXIT_SHORT
+                     4: EXIT_ALL_POSITIONS
+                     5: EXIT_ALL_ORDERS
+                     6: EXIT_STOP
+                     7: EXIT_LIMIT
+
+            symbol : The symbol for the trade.
+
+        Returns:
+            TradeSignal : A ``TradeSignal`` object representing the trade signal.
+
+        Note:
+            This generate only common signals. For more complex signals, use `generate_signal` directly.
+
+        Raises:
+            ValueError : If the signal value is not between 0 and 7.
+        """
+        signal_id = getattr(self, "id", None) or getattr(self, "ID")
+        
+        match signal:
+            case 0:
+                return generate_signal(signal_id, symbol, TradeAction.BUY)
+            case 1:
+                return generate_signal(signal_id, symbol, TradeAction.SELL)
+            case 2:
+                return generate_signal(signal_id, symbol, TradeAction.EXIT_LONG)
+            case 3:
+                return generate_signal(signal_id, symbol, TradeAction.EXIT_SHORT)
+            case 4:
+                return generate_signal(signal_id, symbol, TradeAction.EXIT_ALL_POSITIONS)
+            case 5:
+                return generate_signal(signal_id, symbol, TradeAction.EXIT_ALL_ORDERS)
+            case 6:
+                return generate_signal(signal_id, symbol, TradeAction.EXIT_STOP)
+            case 7:
+                return generate_signal(signal_id, symbol, TradeAction.EXIT_LIMIT)
+            case _:
+                raise ValueError(f"Invalid signal value: {signal}. Must be an integer between 0 and 7.")
+
+
     def perform_period_end_checks(self, *args, **kwargs):
         """
         Some strategies may require additional checks at the end of the period,
@@ -551,75 +614,75 @@ class MT5Strategy(Strategy):
                         ]
                     logmsg(order, log_label, symbol, dtime)
 
-            for symbol in self.symbols:
-                dtime = self.data.get_latest_bar_datetime(symbol)
-                latest_close = self.data.get_latest_bar_value(symbol, "close")
-
-                process_orders(
-                    "BLMT",
-                    lambda o: latest_close <= o.price,
-                    lambda o: self.buy_mkt(
-                        o.strategy_id, symbol, o.price, o.quantity, dtime
-                    ),
-                    "BUY LIMIT",
-                    symbol,
-                    dtime,
-                )
-
-                process_orders(
-                    "SLMT",
-                    lambda o: latest_close >= o.price,
-                    lambda o: self.sell_mkt(
-                        o.strategy_id, symbol, o.price, o.quantity, dtime
-                    ),
-                    "SELL LIMIT",
-                    symbol,
-                    dtime,
-                )
-
-                process_orders(
-                    "BSTP",
-                    lambda o: latest_close >= o.price,
-                    lambda o: self.buy_mkt(
-                        o.strategy_id, symbol, o.price, o.quantity, dtime
-                    ),
-                    "BUY STOP",
-                    symbol,
-                    dtime,
-                )
-
-                process_orders(
-                    "SSTP",
-                    lambda o: latest_close <= o.price,
-                    lambda o: self.sell_mkt(
-                        o.strategy_id, symbol, o.price, o.quantity, dtime
-                    ),
-                    "SELL STOP",
-                    symbol,
-                    dtime,
-                )
-
-                process_orders(
-                    "BSTPLMT",
-                    lambda o: latest_close >= o.price,
-                    lambda o: self.buy_limit(
-                        o.strategy_id, symbol, o.stoplimit, o.quantity, dtime
-                    ),
-                    "BUY STOP LIMIT",
-                    symbol,
-                    dtime,
-                )
-
-                process_orders(
-                    "SSTPLMT",
-                    lambda o: latest_close <= o.price,
-                    lambda o: self.sell_limit(
-                        o.strategy_id, symbol, o.stoplimit, o.quantity, dtime
-                    ),
-                    "SELL STOP LIMIT",
-                    symbol,
-                    dtime,
-                )
+        for symbol in self.symbols:
+            dtime = self.data.get_latest_bar_datetime(symbol)
+            latest_close = self.data.get_latest_bar_value(symbol, "close")
+
+            process_orders(
+                "BLMT",
+                lambda o: latest_close <= o.price,
+                lambda o: self.buy_mkt(
+                    o.strategy_id, symbol, o.price, o.quantity, dtime
+                ),
+                "BUY LIMIT",
+                symbol,
+                dtime,
+            )
+
+            process_orders(
+                "SLMT",
+                lambda o: latest_close >= o.price,
+                lambda o: self.sell_mkt(
+                    o.strategy_id, symbol, o.price, o.quantity, dtime
+                ),
+                "SELL LIMIT",
+                symbol,
+                dtime,
+            )
+
+            process_orders(
+                "BSTP",
+                lambda o: latest_close >= o.price,
+                lambda o: self.buy_mkt(
+                    o.strategy_id, symbol, o.price, o.quantity, dtime
+                ),
+                "BUY STOP",
+                symbol,
+                dtime,
+            )
+
+            process_orders(
+                "SSTP",
+                lambda o: latest_close <= o.price,
+                lambda o: self.sell_mkt(
+                    o.strategy_id, symbol, o.price, o.quantity, dtime
+                ),
+                "SELL STOP",
+                symbol,
+                dtime,
+            )
+
+            process_orders(
+                "BSTPLMT",
+                lambda o: latest_close >= o.price,
+                lambda o: self.buy_limit(
+                    o.strategy_id, symbol, o.stoplimit, o.quantity, dtime
+                ),
+                "BUY STOP LIMIT",
+                symbol,
+                dtime,
+            )
+
+            process_orders(
+                "SSTPLMT",
+                lambda o: latest_close <= o.price,
+                lambda o: self.sell_limit(
+                    o.strategy_id, symbol, o.stoplimit, o.quantity, dtime
+                ),
+                "SELL STOP LIMIT",
+                symbol,
+                dtime,
+            )
 
     @staticmethod
     def calculate_pct_change(current_price, lh_price) -> float:
@@ -803,13 +866,10 @@ class MT5Strategy(Strategy):
         elif len(prices) in range(2, self.max_trades[asset] + 1):
             price = np.mean(prices)
         if price is not None:
-            if (
-                position == 0
-                and self.calculate_pct_change(ask, price) >= th
-                or position == 1
-                and abs(self.calculate_pct_change(bid, price)) >= th
-            ):
-                return True
+            if position == 0: 
+                return self.calculate_pct_change(ask, price) >= th
+            elif position == 1:
+                return self.calculate_pct_change(bid, price) <= -th
         return False
 
     @staticmethod
@@ -834,9 +894,7 @@ class MT5Strategy(Strategy):
             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):
+        if isinstance(dt, (datetime, int)):
             dt = pd.to_datetime(dt, unit="s")
         if dt.tzinfo is None:
             dt = dt.tz_localize(from_tz)
@@ -862,20 +920,35 @@ class MT5Strategy(Strategy):
         Returns:
             mt5_equivalent : The MetaTrader 5 equivalent symbols for the symbols in the list.
         """
+        
         account = Account(**kwargs)
         mt5_symbols = account.get_symbols(symbol_type=symbol_type)
         mt5_equivalent = []
-        if account.broker == AdmiralMarktsGroup():
+
+        def _get_admiral_symbols():
             for s in mt5_symbols:
                 _s = s[1:] if s[0] in string.punctuation else s
                 for symbol in symbols:
                     if _s.split(".")[0] == symbol or _s.split("_")[0] == symbol:
                         mt5_equivalent.append(s)
-        elif account.broker == PepperstoneGroupLimited():
-            for s in mt5_symbols:
+
+        def _get_pepperstone_symbols():
+             for s in mt5_symbols:
                 for symbol in symbols:
                     if s.split(".")[0] == symbol:
                         mt5_equivalent.append(s)
+
+        if account.broker == MetaQuotes():
+            if "Admiral" in account.server:
+                _get_admiral_symbols()
+            elif "Pepperstone" in account.server:
+                _get_pepperstone_symbols()
+
+        elif account.broker == AdmiralMarktsGroup():
+            _get_admiral_symbols()
+        elif account.broker == PepperstoneGroupLimited():
+            _get_pepperstone_symbols()
+
         return mt5_equivalent
 
 

bbstrader/core/utils.py

@@ -66,9 +66,11 @@ def dict_from_ini(file_path, sections: str | List[str] = None) -> Dict[str, Any]
     Returns:
         A dictionary containing the INI file contents with proper data types.
     """
-    config = configparser.ConfigParser(interpolation=None)
-    config.read(file_path)
-
+    try:
+        config = configparser.ConfigParser(interpolation=None)
+        config.read(file_path)
+    except Exception:
+        raise
     ini_dict = {}
     for section in config.sections():
         ini_dict[section] = {

bbstrader/metatrader/account.py

@@ -1,19 +1,28 @@
 import os
 import re
 import urllib.request
-from datetime import datetime, timedelta
+from datetime import datetime
 from typing import Any, Dict, List, Literal, Optional, Tuple, Union
 
+import numpy as np
 import pandas as pd
+from currency_converter import SINGLE_DAY_ECB_URL, CurrencyConverter
+from numpy.typing import NDArray
+
 from bbstrader.metatrader.utils import (
+    TIMEFRAMES,
     AccountInfo,
     BookInfo,
     InvalidBroker,
     OrderCheckResult,
     OrderSentResult,
+    RateDtype,
+    RateInfo,
     SymbolInfo,
     SymbolType,
     TerminalInfo,
+    TickDtype,
+    TickFlag,
     TickInfo,
     TradeDeal,
     TradeOrder,
@@ -21,7 +30,6 @@ from bbstrader.metatrader.utils import (
     TradeRequest,
     raise_mt5_error,
 )
-from currency_converter import SINGLE_DAY_ECB_URL, CurrencyConverter
 
 try:
     import MetaTrader5 as mt5
@@ -170,7 +178,7 @@ def check_mt5_connection(
         if account_info is not None:
             if account_info.login == login and account_info.server == server:
                 return True
-        
+
     init = False
     if path is None and (login or password or server):
         raise ValueError(
@@ -517,7 +525,7 @@ class Account(object):
         """Helper function to  print account info"""
         self._show_info(self.get_account_info, "account")
 
-    def get_terminal_info(self, show=False) -> Union[TerminalInfo, None]:
+    def get_terminal_info(self, show=False) -> TerminalInfo | None:
         """
         Get the connected MetaTrader 5 client terminal status and settings.
 
@@ -965,7 +973,7 @@ class Account(object):
                         futures_types["bonds"].append(info.name)
             return futures_types[category]
 
-    def get_symbol_info(self, symbol: str) -> Union[SymbolInfo, None]:
+    def get_symbol_info(self, symbol: str) -> SymbolInfo | None:
         """Get symbol properties
 
         Args:
@@ -998,6 +1006,14 @@ class Account(object):
             msg = self._symbol_info_msg(symbol)
             raise_mt5_error(message=f"{str(e)} {msg}")
 
+    def _symbol_info_msg(self, symbol):
+        return (
+            f"No history found for {symbol} in Market Watch.\n"
+            f"* Ensure {symbol} is selected and displayed in the Market Watch window.\n"
+            f"* See https://www.metatrader5.com/en/terminal/help/trading/market_watch\n"
+            f"* Ensure the symbol name is correct.\n"
+        )
+
     def show_symbol_info(self, symbol: str):
         """
         Print symbol properties
@@ -1007,15 +1023,7 @@ class Account(object):
         """
         self._show_info(self.get_symbol_info, "symbol", symbol=symbol)
 
-    def _symbol_info_msg(self, symbol):
-        return (
-            f"No history found for {symbol} in Market Watch.\n"
-            f"* Ensure {symbol} is selected and displayed in the Market Watch window.\n"
-            f"* See https://www.metatrader5.com/en/terminal/help/trading/market_watch\n"
-            f"* Ensure the symbol name is correct.\n"
-        )
-
-    def get_tick_info(self, symbol: str) -> Union[TickInfo, None]:
+    def get_tick_info(self, symbol: str) -> TickInfo | None:
         """Get symbol tick properties
 
         Args:
@@ -1057,7 +1065,148 @@ class Account(object):
         """
         self._show_info(self.get_tick_info, "tick", symbol=symbol)
 
-    def get_market_book(self, symbol: str) -> Union[Tuple[BookInfo], None]:
+    def get_rate_info(self, symbol: str, timeframe: str = "1m") -> RateInfo | None:
+        """Get the most recent bar for a specified symbol and timeframe.
+
+        Args:
+            symbol (str): The symbol for which to get the rate information.
+            timeframe (str): The timeframe for the rate information. Default is '1m'.
+                            See ``bbstrader.metatrader.utils.TIMEFRAMES`` for supported timeframes.
+        Returns:
+            RateInfo: The most recent bar as a RateInfo named tuple.
+            None: If no rates are found or an error occurs.
+        Raises:
+            MT5TerminalError: A specific exception based on the error code.
+        """
+        rates = mt5.copy_rates_from_pos(symbol, TIMEFRAMES[timeframe], 0, 1)
+        if rates is None or len(rates) == 0:
+            return None
+        rate = rates[0]
+        return RateInfo(*rate)
+
+    def get_rates_from_pos(
+        self, symbol: str, timeframe: str, start_pos: int = 0, bars: int = 1
+    ) -> NDArray[np.void]:
+        """
+        Get bars from the MetaTrader 5 terminal starting from the specified index.
+
+        Args:
+            symbol: Financial instrument name, for example, "EURUSD"
+            timeframe: Timeframe the bars are requested for.
+            start_pos: Initial index of the bar the data are requested from.
+            bars: Number of bars to receive.
+
+        Returns:
+            bars as the numpy array with the named time, open, high, low, close, tick_volume, spread and real_volume columns.
+            Returns an empty array in case of an error.
+        """
+        rates = mt5.copy_rates_from_pos(symbol, TIMEFRAMES[timeframe], start_pos, bars)
+        if rates is None or len(rates) == 0:
+            return np.array([], dtype=RateDtype)
+        return rates
+
+    def get_rates_from_date(
+        self,
+        symbol: str,
+        timeframe: str,
+        date_from: datetime | pd.Timestamp,
+        bars: int = 1,
+    ) -> NDArray[np.void]:
+        """
+        Get bars from the MetaTrader 5 terminal starting from the specified date.
+
+        Args:
+            symbol: Financial instrument name, for example, "EURUSD"
+            timeframe: Timeframe the bars are requested for.
+            date_from: Date of opening of the first bar from the requested sample.
+            bars: Number of bars to receive.
+
+        Returns:
+            bars as the numpy array with the named time, open, high, low, close, tick_volume, spread and real_volume columns.
+            Returns an empty array in case of an error.
+
+        """
+        rates = mt5.copy_rates_from(symbol, TIMEFRAMES[timeframe], date_from, bars)
+        if rates is None or len(rates) == 0:
+            return np.array([], dtype=RateDtype)
+        return rates
+
+    def get_rates_range(
+        self,
+        symbol: str,
+        timeframe: str,
+        date_from: datetime | pd.Timestamp,
+        date_to: datetime | pd.Timestamp = datetime.now(),
+    ) -> NDArray[np.void]:
+        """
+        Get bars in the specified date range from the MetaTrader 5 terminal.
+
+        Args:
+            symbol: Financial instrument name, for example, "EURUSD"
+            timeframe: Timeframe the bars are requested for.
+            date_from: Date the bars are requested from.
+            date_to: Date, up to which the bars are requested.
+
+        Returns:
+            bars as the numpy array with the named time, open, high, low, close, tick_volume, spread and real_volume columns.
+            Returns an empty array in case of an error.
+        """
+        rates = mt5.copy_rates_range(symbol, TIMEFRAMES[timeframe], date_from, date_to)
+        if rates is None or len(rates) == 0:
+            return np.array([], dtype=RateDtype)
+        return rates
+
+    def get_tick_from_date(
+        self,
+        symbol: str,
+        date_from: datetime | pd.Timestamp,
+        ticks: int = 1,
+        flag: Literal["all", "info", "trade"] = "all",
+    ) -> NDArray[np.void]:
+        """
+        Get ticks from the MetaTrader 5 terminal starting from the specified date.
+
+        Args:
+            symbol: Financial instrument name, for example, "EURUSD"
+            date_from: Date the ticks are requested from.
+            ticks: Number of bars to receive.
+            flag: A flag to define the type of the requested ticks ("all", "info", "trade").
+
+        Returns:
+            Returns ticks as the numpy array with the named time, bid, ask, last and flags columns.
+            Return an empty array in case of an error.
+        """
+        ticks_data = mt5.copy_ticks_from(symbol, date_from, ticks, TickFlag[flag])
+        if ticks_data is None or len(ticks_data) == 0:
+            return np.array([], dtype=TickDtype)
+        return ticks_data
+
+    def get_tick_range(
+        self,
+        symbol: str,
+        date_from: datetime | pd.Timestamp,
+        date_to: datetime | pd.Timestamp = datetime.now(),
+        flag: Literal["all", "info", "trade"] = "all",
+    ) -> NDArray[np.void]:
+        """
+        Get ticks for the specified date range from the MetaTrader 5 terminal.
+
+        Args:
+            symbol: Financial instrument name, for example, "EURUSD"
+            date_from: Date the ticks are requested from.
+            date_to: Date, up to which the ticks are requested.
+            flag: A flag to define the type of the requested ticks ("all", "info", "trade").
+
+        Returns:
+            Returns ticks as the numpy array with the named time, bid, ask, last and flags columns.
+            Return an empty array in case of an error.
+        """
+        ticks_data = mt5.copy_ticks_range(symbol, date_from, date_to, TickFlag[flag])
+        if ticks_data is None or len(ticks_data) == 0:
+            return np.array([], dtype=TickDtype)
+        return ticks_data
+
+    def get_market_book(self, symbol: str) -> Tuple[BookInfo]:
         """
         Get the Market Depth content for a specific symbol.
         Args:
@@ -1199,7 +1348,7 @@ class Account(object):
         group: Optional[str] = None,
         ticket: Optional[int] = None,
         to_df: bool = False,
-    ) -> Union[pd.DataFrame, Tuple[TradePosition], None]:
+    ) -> Union[pd.DataFrame, Tuple[TradePosition]]:
         """
         Get open positions with the ability to filter by symbol or ticket.
         There are four call options:
@@ -1229,7 +1378,6 @@ class Account(object):
         Returns:
             Union[pd.DataFrame, Tuple[TradePosition], None]:
             - `TradePosition` in the form of a named tuple structure (namedtuple) or pd.DataFrame.
-            - `None` in case of an error.
 
         Notes:
             The method allows receiving all open positions within a specified period.
@@ -1285,7 +1433,7 @@ class Account(object):
         position: Optional[int] = None,  # TradePosition.ticket
         to_df: bool = True,
         save: bool = False,
-    ) -> Union[pd.DataFrame, Tuple[TradeDeal], None]:
+    ) -> Union[pd.DataFrame, Tuple[TradeDeal]]:
         """
         Get deals from trading history within the specified interval
         with the ability to filter by `ticket` or `position`.
@@ -1323,7 +1471,6 @@ class Account(object):
         Returns:
             Union[pd.DataFrame, Tuple[TradeDeal], None]:
             - `TradeDeal` in the form of a named tuple structure (namedtuple) or pd.DataFrame().
-            - `None` in case of an error.
 
         Notes:
             The method allows receiving all history orders within a specified period.
@@ -1413,7 +1560,6 @@ class Account(object):
         Returns:
             Union[pd.DataFrame, Tuple[TradeOrder], None]:
             - `TradeOrder` in the form of a named tuple structure (namedtuple) or pd.DataFrame().
-            - `None` in case of an error.
 
         Notes:
             The method allows receiving all history orders within a specified period.
@@ -1478,7 +1624,7 @@ class Account(object):
         position: Optional[int] = None,  # position ticket
         to_df: bool = True,
         save: bool = False,
-    ) -> Union[pd.DataFrame, Tuple[TradeOrder], None]:
+    ) -> Union[pd.DataFrame, Tuple[TradeOrder]]:
         """
         Get orders from trading history within the specified interval
         with the ability to filter by `ticket` or `position`.
@@ -1516,7 +1662,6 @@ class Account(object):
         Returns:
             Union[pd.DataFrame, Tuple[TradeOrder], None]
             - `TradeOrder` in the form of a named tuple structure (namedtuple) or pd.DataFrame().
-            - `None` in case of an error.
 
         Notes:
             The method allows receiving all history orders within a specified period.
@@ -1597,16 +1742,11 @@ class Account(object):
         Returns:
             List[TradeDeal]: List of today deals
         """
-        date_from = datetime.now() - timedelta(days=2)
-        history = (
-            self.get_trades_history(date_from=date_from, group=group, to_df=False) or []
-        )
+        history = self.get_trades_history(group=group, to_df=False) or []
         positions_ids = set([deal.position_id for deal in history if deal.magic == id])
         today_deals = []
         for position in positions_ids:
-            deal = self.get_trades_history(
-                date_from=date_from, position=position, to_df=False
-            )
+            deal = self.get_trades_history(position=position, to_df=False) or []
             if deal is not None and len(deal) == 2:
                 deal_time = datetime.fromtimestamp(deal[1].time)
                 if deal_time.date() == datetime.now().date():