bbstrader 0.2.991__py3-none-any.whl → 0.3.1__py3-none-any.whl

bbstrader/metatrader/trade.py

@@ -33,12 +33,6 @@ __all__ = [
     "create_trade_instance",
 ]
 
-FILLING_TYPE = [
-    Mt5.ORDER_FILLING_IOC,
-    Mt5.ORDER_FILLING_RETURN,
-    Mt5.ORDER_FILLING_BOC,
-]
-
 log.add(
     f"{BBSTRADER_DIR}/logs/trade.log",
     enqueue=True,
@@ -50,6 +44,13 @@ global LOGGER
 LOGGER = log
 
 
+FILLING_TYPE = [
+    Mt5.ORDER_FILLING_IOC,
+    Mt5.ORDER_FILLING_RETURN,
+    Mt5.ORDER_FILLING_BOC,
+]
+
+
 class TradeAction(Enum):
     """
     An enumeration class for trade actions.
@@ -133,10 +134,21 @@ class TradeSignal:
     def __repr__(self):
         return (
             f"TradeSignal(id={self.id}, symbol='{self.symbol}', action='{self.action.value}', "
-            f"price={self.price}, stoplimit={self.stoplimit}), comment='{self.comment}'"
+            f"price={self.price}, stoplimit={self.stoplimit}, comment='{self.comment or ''}')"
         )
 
 
+class TradingMode(Enum):
+    BACKTEST = "BACKTEST"
+    LIVE = "LIVE"
+
+    def isbacktest(self) -> bool:
+        return self == TradingMode.BACKTEST
+
+    def islive(self) -> bool:
+        return self == TradingMode.LIVE
+
+
 Buys = Literal["BMKT", "BLMT", "BSTP", "BSTPLMT"]
 Sells = Literal["SMKT", "SLMT", "SSTP", "SSTPLMT"]
 Positions = Literal["all", "buy", "sell", "profitable", "losing"]
@@ -152,6 +164,7 @@ Orders = Literal[
 
 EXPERT_ID = 98181105
 
+
 class Trade(RiskManagement):
     """
     Extends the `RiskManagement` class to include specific trading operations,
@@ -729,10 +742,8 @@ class Trade(RiskManagement):
             self.check_order(request)
             result = self.send_order(request)
         except Exception as e:
-            print(f"{self.current_datetime()} -", end=" ")
-            trade_retcode_message(
-                result.retcode, display=True, add_msg=f"{e}{addtionnal}"
-            )
+            msg = trade_retcode_message(result.retcode)
+            LOGGER.error(f"Trade Order Request, {msg}{addtionnal}, {e}")
         if result.retcode != Mt5.TRADE_RETCODE_DONE:
             if result.retcode == Mt5.TRADE_RETCODE_INVALID_FILL:  # 10030
                 for fill in FILLING_TYPE:
@@ -762,10 +773,8 @@ class Trade(RiskManagement):
                         self.check_order(request)
                         result = self.send_order(request)
                     except Exception as e:
-                        print(f"{self.current_datetime()} -", end=" ")
-                        trade_retcode_message(
-                            result.retcode, display=True, add_msg=f"{e}{addtionnal}"
-                        )
+                        msg = trade_retcode_message(result.retcode)
+                        LOGGER.error(f"Trade Order Request, {msg}{addtionnal}, {e}")
                     if result.retcode == Mt5.TRADE_RETCODE_DONE:
                         break
                     tries += 1
@@ -776,7 +785,7 @@ class Trade(RiskManagement):
             if type != "BMKT" or type != "SMKT":
                 self.opened_orders.append(result.order)
             long_msg = (
-                f"1. {pos} Order #{result.order} Sent, Symbol: {self.symbol}, Price: @{price}, "
+                f"1. {pos} Order #{result.order} Sent, Symbol: {self.symbol}, Price: @{round(price, 5)}, "
                 f"Lot(s): {result.volume}, Sl: {self.get_stop_loss()}, "
                 f"Tp: {self.get_take_profit()}"
             )
@@ -797,7 +806,7 @@ class Trade(RiskManagement):
                             profit = round(self.get_account_info().profit, 5)
                             order_info = (
                                 f"2. {order_type} Position Opened, Symbol: {self.symbol}, Price: @{round(position.price_open, 5)}, "
-                                f"Sl: @{position.sl} Tp: @{position.tp}"
+                                f"Sl: @{round(position.sl, 5)} Tp: @{round(position.tp, 5)}"
                             )
                             LOGGER.info(order_info)
                             pos_info = (
@@ -834,7 +843,7 @@ class Trade(RiskManagement):
             action (str): (`'BMKT'`, `'SMKT'`) for Market orders
                 or (`'BLMT', 'SLMT', 'BSTP', 'SSTP', 'BSTPLMT', 'SSTPLMT'`) for pending orders
             price (float): The price at which to open an order
-            stoplimit (float): A price a pending Limit order is set at 
+            stoplimit (float): A price a pending Limit order is set at
                 when the price reaches the 'price' value (this condition is mandatory).
                 The pending order is not passed to the trading system until that moment
             id (int): The strategy id or expert Id
@@ -873,30 +882,30 @@ class Trade(RiskManagement):
     @property
     def orders(self):
         """Return all opened order's tickets"""
-        if len(self.opened_orders) != 0:
-            return self.opened_orders
-        return None
+        current_orders = self.get_current_orders() or []
+        opened_orders = set(current_orders + self.opened_orders)
+        return list(opened_orders) if len(opened_orders) != 0 else None
 
     @property
     def positions(self):
         """Return all opened position's tickets"""
-        if len(self.opened_positions) != 0:
-            return self.opened_positions
-        return None
+        current_positions = self.get_current_positions() or []
+        opened_positions = set(current_positions + self.opened_positions)
+        return list(opened_positions) if len(opened_positions) != 0 else None
 
     @property
     def buypos(self):
         """Return all buy  opened position's tickets"""
-        if len(self.buy_positions) != 0:
-            return self.buy_positions
-        return None
+        buy_positions = self.get_current_buys() or []
+        buy_positions = set(buy_positions + self.buy_positions)
+        return list(buy_positions) if len(buy_positions) != 0 else None
 
     @property
     def sellpos(self):
         """Return all sell  opened position's tickets"""
-        if len(self.sell_positions) != 0:
-            return self.sell_positions
-        return None
+        sell_positions = self.get_current_sells() or []
+        sell_positions = set(sell_positions + self.sell_positions)
+        return list(sell_positions) if len(sell_positions) != 0 else None
 
     @property
     def bepos(self):
@@ -1214,7 +1223,7 @@ class Trade(RiskManagement):
         Sets the break-even level for a given trading position.
 
         Args:
-            position (TradePosition): The trading position for which the break-even is to be set. 
+            position (TradePosition): The trading position for which the break-even is to be set.
                 This is the value return by `mt5.positions_get()`.
             be (int): The break-even level in points.
             level (float): The break-even level in price, if set to None , it will be calated automaticaly.
@@ -1283,10 +1292,8 @@ class Trade(RiskManagement):
             self.check_order(request)
             result = self.send_order(request)
         except Exception as e:
-            print(f"{self.current_datetime()} -", end=" ")
-            trade_retcode_message(
-                result.retcode, display=True, add_msg=f"{e}{addtionnal}"
-            )
+            msg = trade_retcode_message(result.retcode)
+            LOGGER.error(f"Break-Even Order Request, {msg}{addtionnal}, Error: {e}")
         if result.retcode != Mt5.TRADE_RETCODE_DONE:
             msg = trade_retcode_message(result.retcode)
             if result.retcode != Mt5.TRADE_RETCODE_NO_CHANGES:
@@ -1303,17 +1310,15 @@ class Trade(RiskManagement):
                         self.check_order(request)
                         result = self.send_order(request)
                     except Exception as e:
-                        print(f"{self.current_datetime()} -", end=" ")
-                        trade_retcode_message(
-                            result.retcode, display=True, add_msg=f"{e}{addtionnal}"
-                        )
+                        msg = trade_retcode_message(result.retcode)
+                        LOGGER.error(f"Break-Even Order Request, {msg}{addtionnal}, Error: {e}")
                     if result.retcode == Mt5.TRADE_RETCODE_DONE:
                         break
                 tries += 1
         if result.retcode == Mt5.TRADE_RETCODE_DONE:
             msg = trade_retcode_message(result.retcode)
             LOGGER.info(f"Break-Even Order {msg}{addtionnal}")
-            info = f"Stop loss set to Break-even, Position: #{tiket}, Symbol: {self.symbol}, Price: @{price}"
+            info = f"Stop loss set to Break-even, Position: #{tiket}, Symbol: {self.symbol}, Price: @{round(price, 5)}"
             LOGGER.info(info)
             self.break_even_status.append(tiket)
 
@@ -1391,10 +1396,8 @@ class Trade(RiskManagement):
             self.check_order(request)
             result = self.send_order(request)
         except Exception as e:
-            print(f"{self.current_datetime()} -", end=" ")
-            trade_retcode_message(
-                result.retcode, display=True, add_msg=f"{e}{addtionnal}"
-            )
+            msg = trade_retcode_message(result.retcode)
+            LOGGER.error(f"Closing {type.capitalize()} Request, {msg}{addtionnal}, Error: {e}")
         if result.retcode != Mt5.TRADE_RETCODE_DONE:
             if result.retcode == Mt5.TRADE_RETCODE_INVALID_FILL:  # 10030
                 for fill in FILLING_TYPE:
@@ -1406,7 +1409,8 @@ class Trade(RiskManagement):
                 self._retcodes.append(result.retcode)
                 msg = trade_retcode_message(result.retcode)
                 LOGGER.error(
-                    f"Closing Order Request, {type.capitalize()}: #{ticket}, RETCODE={result.retcode}: {msg}{addtionnal}"
+                    f"Closing Order Request, {type.capitalize()}: #{ticket}, "
+                    f"RETCODE={result.retcode}: {msg}{addtionnal}"
                 )
             else:
                 tries = 0
@@ -1416,17 +1420,18 @@ class Trade(RiskManagement):
                         self.check_order(request)
                         result = self.send_order(request)
                     except Exception as e:
-                        print(f"{self.current_datetime()} -", end=" ")
-                        trade_retcode_message(
-                            result.retcode, display=True, add_msg=f"{e}{addtionnal}"
-                        )
+                        msg = trade_retcode_message(result.retcode)
+                        LOGGER.error(f"Closing {type.capitalize()} Request, {msg}{addtionnal}, Error: {e}")
                     if result.retcode == Mt5.TRADE_RETCODE_DONE:
                         break
                     tries += 1
         if result.retcode == Mt5.TRADE_RETCODE_DONE:
             msg = trade_retcode_message(result.retcode)
             LOGGER.info(f"Closing Order {msg}{addtionnal}")
-            info = f"{type.capitalize()} #{ticket} closed, Symbol: {self.symbol}, Price: @{request.get('price', 0.0)}"
+            info = (
+                f"{type.capitalize()} #{ticket} closed, Symbol: {self.symbol},"
+                f"Price: @{round(request.get('price', 0.0), 5)}"
+            )
             LOGGER.info(info)
             return True
         else:
@@ -1446,7 +1451,7 @@ class Trade(RiskManagement):
         Args:
             ticket (int): Order ticket to modify (e.g TradeOrder.ticket)
             price (float): The price at which to modify the order
-            stoplimit (float): A price a pending Limit order is set at 
+            stoplimit (float): A price a pending Limit order is set at
                 when the price reaches the 'price' value (this condition is mandatory).
                 The pending order is not passed to the trading system until that moment
             sl (float): The stop loss in points
@@ -1455,7 +1460,7 @@ class Trade(RiskManagement):
         orders = self.get_orders(ticket=ticket) or []
         if len(orders) == 0:
             LOGGER.error(
-                f"Order #{ticket} not found, SYMBOL={self.symbol}, PRICE={price}"
+                f"Order #{ticket} not found, SYMBOL={self.symbol}, PRICE={round(price, 5)}"
             )
             return
         order = orders[0]
@@ -1471,7 +1476,8 @@ class Trade(RiskManagement):
         result = self.send_order(request)
         if result.retcode == Mt5.TRADE_RETCODE_DONE:
             LOGGER.info(
-                f"Order #{ticket} modified, SYMBOL={self.symbol}, PRICE={price}, SL={sl}, TP={tp}, STOP_LIMIT={stoplimit}"
+                f"Order #{ticket} modified, SYMBOL={self.symbol}, PRICE={round(price, 5)},"
+                f"SL={round(sl, 5)}, TP={round(tp, 5)}, STOP_LIMIT={round(stoplimit, 5)}"
             )
         else:
             msg = trade_retcode_message(result.retcode)
@@ -1597,7 +1603,7 @@ class Trade(RiskManagement):
     ):
         """
         Args:
-            order_type (str): Type of orders to close 
+            order_type (str): Type of orders to close
                 ('all', 'buy_stops', 'sell_stops', 'buy_limits', 'sell_limits', 'buy_stop_limits', 'sell_stop_limits')
             id (int): The unique ID of the Expert or Strategy
             comment (str): Comment for the closing position

bbstrader/metatrader/utils.py

@@ -14,6 +14,7 @@ __all__ = [
     "TerminalInfo",
     "AccountInfo",
     "SymbolInfo",
+    "SymbolType",
     "TickInfo",
     "TradeRequest",
     "OrderCheckResult",
@@ -70,27 +71,31 @@ class TimeFrame(Enum):
     Rrepresent a time frame object
     """
 
-    M1 = "1m"
-    M2 = "2m"
-    M3 = "3m"
-    M4 = "4m"
-    M5 = "5m"
-    M6 = "6m"
-    M10 = "10m"
-    M12 = "12m"
-    M15 = "15m"
-    M20 = "20m"
-    M30 = "30m"
-    H1 = "1h"
-    H2 = "2h"
-    H3 = "3h"
-    H4 = "4h"
-    H6 = "6h"
-    H8 = "8h"
-    H12 = "12h"
-    D1 = "D1"
-    W1 = "W1"
-    MN1 = "MN1"
+    M1 = TIMEFRAMES["1m"]
+    M2 = TIMEFRAMES["2m"]
+    M3 = TIMEFRAMES["3m"]
+    M4 = TIMEFRAMES["4m"]
+    M5 = TIMEFRAMES["5m"]
+    M6 = TIMEFRAMES["6m"]
+    M10 = TIMEFRAMES["10m"]
+    M12 = TIMEFRAMES["12m"]
+    M15 = TIMEFRAMES["15m"]
+    M20 = TIMEFRAMES["20m"]
+    M30 = TIMEFRAMES["30m"]
+    H1 = TIMEFRAMES["1h"]
+    H2 = TIMEFRAMES["2h"]
+    H3 = TIMEFRAMES["3h"]
+    H4 = TIMEFRAMES["4h"]
+    H6 = TIMEFRAMES["6h"]
+    H8 = TIMEFRAMES["8h"]
+    H12 = TIMEFRAMES["12h"]
+    D1 = TIMEFRAMES["D1"]
+    W1 = TIMEFRAMES["W1"]
+    MN1 = TIMEFRAMES["MN1"]
+
+    def __str__(self):
+        """Return the string representation of the time frame."""
+        return self.name
 
 
 class TerminalInfo(NamedTuple):
@@ -263,6 +268,23 @@ class SymbolInfo(NamedTuple):
     path: str
 
 
+class SymbolType(Enum):
+    """
+    Represents the type of a symbol.
+    """
+
+    FOREX = "FOREX"  # Forex currency pairs
+    FUTURES = "FUTURES"  # Futures contracts
+    STOCKS = "STOCKS"  # Stocks and shares
+    BONDS = "BONDS"  # Bonds
+    CRYPTO = "CRYPTO"  # Cryptocurrencies
+    ETFs = "ETFs"  # Exchange-Traded Funds
+    INDICES = "INDICES"  # Market indices
+    COMMODITIES = "COMMODITIES"  # Commodities
+    OPTIONS = "OPTIONS"  # Options contracts
+    unknown = "UNKNOWN"  # Unknown or unsupported type
+
+
 class TickInfo(NamedTuple):
     """
     Represents the last tick for the specified financial instrument.
@@ -465,10 +487,12 @@ class MT5TerminalError(Exception):
         self.message = message
 
     def __str__(self) -> str:
-        if self.message is None:
-            return f"{self.__class__.__name__}"
-        else:
-            return f"{self.__class__.__name__}, {self.message}"
+        # if self.message is None:
+        #     return f"{self.__class__.__name__}"
+        # else:
+        #     return f"{self.__class__.__name__}, {self.message}"
+        msg_str = str(self.message) if self.message is not None else ""
+        return f"{self.code} - {self.__class__.__name__}: {msg_str}"
 
 
 class GenericFail(MT5TerminalError):
@@ -561,6 +585,21 @@ class InternalFailTimeout(InternalFailError):
         super().__init__(MT5.RES_E_INTERNAL_FAIL_TIMEOUT, message)
 
 
+RES_E_FAIL = 1  # Generic error
+RES_E_INVALID_PARAMS = 2  # Invalid parameters
+RES_E_NOT_FOUND = 3  # Not found
+RES_E_INVALID_VERSION = 4  # Invalid version
+RES_E_AUTH_FAILED = 5  # Authorization failed
+RES_E_UNSUPPORTED = 6  # Unsupported method
+RES_E_AUTO_TRADING_DISABLED = 7  # Autotrading disabled
+
+# Actual internal error codes from MetaTrader5
+RES_E_INTERNAL_FAIL_CONNECT = -10000
+RES_E_INTERNAL_FAIL_INIT = -10001
+RES_E_INTERNAL_FAIL_SEND = -10006
+RES_E_INTERNAL_FAIL_RECEIVE = -10007
+RES_E_INTERNAL_FAIL_TIMEOUT = -10008
+
 # Dictionary to map error codes to exception classes
 _ERROR_CODE_TO_EXCEPTION_ = {
     MT5.RES_E_FAIL: GenericFail,
@@ -575,6 +614,18 @@ _ERROR_CODE_TO_EXCEPTION_ = {
     MT5.RES_E_INTERNAL_FAIL_INIT: InternalFailInit,
     MT5.RES_E_INTERNAL_FAIL_CONNECT: InternalFailConnect,
     MT5.RES_E_INTERNAL_FAIL_TIMEOUT: InternalFailTimeout,
+    RES_E_FAIL: GenericFail,
+    RES_E_INVALID_PARAMS: InvalidParams,
+    RES_E_NOT_FOUND: HistoryNotFound,
+    RES_E_INVALID_VERSION: InvalidVersion,
+    RES_E_AUTH_FAILED: AuthFailed,
+    RES_E_UNSUPPORTED: UnsupportedMethod,
+    RES_E_AUTO_TRADING_DISABLED: AutoTradingDisabled,
+    RES_E_INTERNAL_FAIL_SEND: InternalFailSend,
+    RES_E_INTERNAL_FAIL_RECEIVE: InternalFailReceive,
+    RES_E_INTERNAL_FAIL_INIT: InternalFailInit,
+    RES_E_INTERNAL_FAIL_CONNECT: InternalFailConnect,
+    RES_E_INTERNAL_FAIL_TIMEOUT: InternalFailTimeout,
 }
 
 
@@ -588,7 +639,10 @@ def raise_mt5_error(message: Optional[str] = None):
         MT5TerminalError: A specific exception based on the error code.
     """
     error = _ERROR_CODE_TO_EXCEPTION_.get(MT5.last_error()[0])
-    raise Exception(f"{error(None)} {message or MT5.last_error()[1]}")
+    if error is not None:
+        raise Exception(f"{error(None)} {message or MT5.last_error()[1]}")
+    else:
+        raise Exception(f"{message or MT5.last_error()[1]}")
 
 
 _ORDER_FILLING_TYPE_ = "https://www.mql5.com/en/docs/constants/tradingconstants/orderproperties#enum_order_type_filling"

bbstrader/models/factors.py

@@ -28,8 +28,10 @@ def _download_and_process_data(source, tickers, start, end, tf, path, **kwargs):
                     end=end,
                     progress=False,
                     multi_level_index=False,
+                    auto_adjust=True,
                 )
-                data = data.drop(columns=["Adj Close"], axis=1)
+                if "Adj Close" in data.columns:
+                    data = data.drop(columns=["Adj Close"], axis=1)
             elif source == "mt5":
                 start, end = pd.Timestamp(start), pd.Timestamp(end)
                 data = download_historical_data(

bbstrader/models/ml.py

@@ -250,12 +250,13 @@ class LightGBModel(object):
         data = pd.concat(data)
         data = (
             data.rename(columns={s: s.lower().replace(" ", "_") for s in data.columns})
-            .drop(columns=["adj_close"])
             .set_index("symbol", append=True)
             .swaplevel()
             .sort_index()
             .dropna()
         )
+        if "adj_close" in data.columns:
+            data = data.drop(columns=["adj_close"])
         return data
 
     def download_metadata(self, tickers):