bbstrader 0.1.94__py3-none-any.whl → 0.2.1__py3-none-any.whl

bbstrader/metatrader/trade.py

@@ -1,36 +1,22 @@
 import os
-import csv
 import time
-import numpy as np
-import pandas as pd
 from datetime import datetime
-import MetaTrader5 as Mt5
 from logging import Logger
+from typing import Any, Callable, Dict, List, Literal, Optional, Tuple
+
+import MetaTrader5 as Mt5
+import pandas as pd
 from tabulate import tabulate
-from typing import (
-    List, 
-    Tuple, 
-    Dict, 
-    Any, 
-    Optional,
-    Literal, 
-    Callable
-)
+
 from bbstrader.btengine.performance import create_sharpe_ratio
+from bbstrader.config import BBSTRADER_DIR, config_logger
+from bbstrader.metatrader.account import INIT_MSG, check_mt5_connection
 from bbstrader.metatrader.risk import RiskManagement
-from bbstrader.metatrader.account import(
-    check_mt5_connection, 
-    INIT_MSG
-)
 from bbstrader.metatrader.utils import (
-    TimeFrame, 
-    TradePosition, 
-    TickInfo,
-    raise_mt5_error, 
-    trade_retcode_message
+    TradePosition,
+    raise_mt5_error,
+    trade_retcode_message,
 )
-from bbstrader.config import config_logger, BBSTRADER_DIR
-
 
 __all__ = [
     'Trade',
@@ -168,13 +154,14 @@ class Trade(RiskManagement):
             ":")
         self.ending_time_hour, self.ending_time_minutes = self.end.split(":")
 
-        self.buy_positions      = []
-        self.sell_positions     = []
-        self.opened_positions   = []
-        self.opened_orders      = []
-        self.break_even_status  = []
-        self.break_even_points  = {}
+        self.buy_positions = []
+        self.sell_positions = []
+        self.opened_positions = []
+        self.opened_orders = []
+        self.break_even_status = []
+        self.break_even_points = {}
         self.trail_after_points = []
+        self._retcodes = []
 
         self.initialize(**kwargs)
         self.select_symbol(**kwargs)
@@ -188,14 +175,19 @@ class Trade(RiskManagement):
             print(
                 f">>> Everything is OK, @{self.expert_name} is Running ...>>>\n")
 
-    def  _get_logger(self, logger: str | Logger, consol_log: bool) -> Logger:
+    @property
+    def retcodes(self) -> List[int]:
+        """Return all the retcodes"""
+        return self._retcodes
+    
+    def _get_logger(self, logger: str | Logger, consol_log: bool) -> Logger:
         """Get the logger object"""
         if isinstance(logger, str):
             log_path = BBSTRADER_DIR / 'logs'
             log_path.mkdir(exist_ok=True)
             return config_logger(f'{log_path}/{logger}', consol_log)
         return logger
-    
+
     def initialize(self, **kwargs):
         """
         Initializes the MetaTrader 5 (MT5) terminal for trading operations. 
@@ -266,12 +258,16 @@ class Trade(RiskManagement):
             ["Expert | Strategy ID", self.expert_id],
             ["Trading Symbol", self.symbol],
             ["Trading Time Frame", self.tf],
-            ["Start Trading Time", f"{self.start_time_hour}:{self.start_time_minutes}"],
-            ["Finishing Trading Time", f"{self.finishing_time_hour}:{self.finishing_time_minutes}"],
-            ["Closing Position After", f"{self.ending_time_hour}:{self.ending_time_minutes}"],
+            ["Start Trading Time",
+                f"{self.start_time_hour}:{self.start_time_minutes}"],
+            ["Finishing Trading Time",
+                f"{self.finishing_time_hour}:{self.finishing_time_minutes}"],
+            ["Closing Position After",
+                f"{self.ending_time_hour}:{self.ending_time_minutes}"],
         ]
         # Custom table format
-        summary_table = tabulate(summary_data, headers=["Summary", "Values"], tablefmt="outline")
+        summary_table = tabulate(summary_data, headers=[
+                                 "Summary", "Values"], tablefmt="outline")
 
         # Print the table
         print("\n[======= Trade Account Summary =======]")
@@ -299,10 +295,12 @@ class Trade(RiskManagement):
             ["Account Margin", f"{round(account_info.margin, 2)} {currency}"],
             ["Account Free Margin", f"{account_info.margin_free} {currency}"],
             ["Maximum Drawdown", f"{self.max_risk}%"],
-            ["Risk Allowed", f"{round((self.max_risk - self.risk_level()), 2)}%"],
+            ["Risk Allowed",
+                f"{round((self.max_risk - self.risk_level()), 2)}%"],
             ["Volume", f"{self.volume()} {marging_currency}"],
             ["Risk Per trade", f"{-self.get_currency_risk()} {currency}"],
-            ["Profit Expected Per trade", f"{self.expected_profit()} {currency}"],
+            ["Profit Expected Per trade",
+                f"{self.expected_profit()} {currency}"],
             ["Lot Size", f"{self.get_lot()} Lots"],
             ["Stop Loss", f"{self.get_stop_loss()} Points"],
             ["Loss Value Per Tick", f"{round(loss, 5)} {currency}"],
@@ -316,7 +314,8 @@ class Trade(RiskManagement):
         ]
         # Custom table format
         print("\n[======= Account Risk Management Overview =======]")
-        table = tabulate(account_data, headers=["Risk Metrics", "Values"], tablefmt="outline")
+        table = tabulate(account_data, headers=[
+                         "Risk Metrics", "Values"], tablefmt="outline")
 
         # Print the table
         print(table)
@@ -338,7 +337,6 @@ class Trade(RiskManagement):
         currency = self.get_account_info().currency
         net_profit = round((profit + total_fees), 2)
         trade_risk = round(self.get_currency_risk() * -1, 2)
-        expected_profit = round((trade_risk * self.rr * -1), 2)
 
         # Formatting the statistics output
         session_data = [
@@ -350,7 +348,8 @@ class Trade(RiskManagement):
             ["Average Fees", f"{average_fee} {currency}"],
             ["Net Profit", f"{net_profit} {currency}"],
             ["Risk per Trade", f"{trade_risk} {currency}"],
-            ["Expected Profit per Trade", f"{self.expected_profit()} {currency}"],
+            ["Expected Profit per Trade",
+                f"{self.expected_profit()} {currency}"],
             ["Risk Reward Ratio", self.rr],
             ["Win Rate", f"{win_rate}%"],
             ["Sharpe Ratio", self.sharpe()],
@@ -384,6 +383,7 @@ class Trade(RiskManagement):
             self.logger.info(f"Session statistics saved to {filepath}")
 
     Buys = Literal['BMKT', 'BLMT', 'BSTP', 'BSTPLMT']
+
     def open_buy_position(
         self,
         action: Buys = 'BMKT',
@@ -416,7 +416,6 @@ class Trade(RiskManagement):
                     "You need to set a price for pending orders")
         else:
             _price = self.get_tick_info(self.symbol).ask
-        digits = self.get_symbol_info(self.symbol).digits
 
         lot = self.get_lot()
         stop_loss = self.get_stop_loss()
@@ -468,6 +467,7 @@ class Trade(RiskManagement):
         return type
 
     Sells = Literal['SMKT', 'SLMT', 'SSTP', 'SSTPLMT']
+
     def open_sell_position(
         self,
         action: Sells = 'SMKT',
@@ -500,7 +500,6 @@ class Trade(RiskManagement):
                     "You need to set a price for pending orders")
         else:
             _price = self.get_tick_info(self.symbol).bid
-        digits = self.get_symbol_info(self.symbol).digits
 
         lot = self.get_lot()
         stop_loss = self.get_stop_loss()
@@ -553,7 +552,8 @@ class Trade(RiskManagement):
             self.logger.info(f"Not Trading time, SYMBOL={self.symbol}")
             return False
         elif not self.is_risk_ok():
-            self.logger.error(f"Risk not allowed, SYMBOL={self.symbol}")
+            self.logger.error(
+                f"Account Risk not allowed, SYMBOL={self.symbol}")
             self._check(comment)
             return False
         elif self.profit_target():
@@ -561,9 +561,9 @@ class Trade(RiskManagement):
         return True
 
     def _check(self, txt: str = ""):
-        if (self.positive_profit(id=self.expert_id) 
-            or self.get_current_positions() is None
-            ):
+        if (self.positive_profit(id=self.expert_id)
+                or self.get_current_positions() is None
+                ):
             self.close_positions(position_type='all')
             self.logger.info(txt)
             time.sleep(5)
@@ -582,7 +582,7 @@ class Trade(RiskManagement):
             price (float): Price for opening the position
             request (Dict[str, Any]): A trade request to sent to Mt5.order_sent() 
             all detail in request can be found here https://www.mql5.com/en/docs/python_metatrader5/mt5ordersend_py
-            
+
             type (str): The type of the order `(BMKT, SMKT, BLMT, SLMT, BSTP, SSTP, BSTPLMT, SSTPLMT)` 
         """
         # Send a trading request
@@ -590,23 +590,25 @@ class Trade(RiskManagement):
         pos = self._order_type()[type][1]
         addtionnal = f", SYMBOL={self.symbol}"
         try:
-            check = self.check_order(request)
+            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}")
         if result.retcode != Mt5.TRADE_RETCODE_DONE:
-            msg = trade_retcode_message(result.retcode)
-            self.logger.error(
-                f"Trade Order Request, RETCODE={result.retcode}: {msg}{addtionnal}")
+            if result.retcode not in self._retcodes:
+                self._retcodes.append(result.retcode)
+                msg = trade_retcode_message(result.retcode)
+                self.logger.error(
+                    f"Trade Order Request, RETCODE={result.retcode}: {msg}{addtionnal}")
             if result.retcode in [
                     Mt5.TRADE_RETCODE_CONNECTION, Mt5.TRADE_RETCODE_TIMEOUT]:
                 tries = 0
                 while result.retcode != Mt5.TRADE_RETCODE_DONE and tries < 5:
                     time.sleep(1)
                     try:
-                        check = self.check_order(request)
+                        self.check_order(request)
                         result = self.send_order(request)
                     except Exception as e:
                         print(f"{self.current_datetime()} -", end=' ')
@@ -650,7 +652,7 @@ class Trade(RiskManagement):
                             f"{self.get_account_info().currency}]\n"
                         )
                         self.logger.info(pos_info)
-    
+
     def open_position(
         self,
         action: Buys | Sells,
@@ -682,7 +684,8 @@ class Trade(RiskManagement):
             self.open_sell_position(
                 action=action, price=price, stoplimit=stoplimit, id=id, mm=mm, comment=comment)
         else:
-            raise ValueError(f"Invalid action type '{action}', must be {', '.join(BUYS + SELLS)}")
+            raise ValueError(
+                f"Invalid action type '{action}', must be {', '.join(BUYS + SELLS)}")
 
     @property
     def orders(self):
@@ -766,7 +769,7 @@ class Trade(RiskManagement):
                         continue
                     if filter_type == 'sells' and item.type != 1:
                         continue
-                    if filter_type == 'losings' and  item.profit > 0:
+                    if filter_type == 'losings' and item.profit > 0:
                         continue
                     if filter_type == 'profitables' and not self.win_trade(item, th=th):
                         continue
@@ -791,19 +794,19 @@ class Trade(RiskManagement):
 
     def get_current_buy_stops(self, id: Optional[int] = None) -> List[int] | None:
         return self.get_filtered_tickets(id=id, filter_type='buy_stops')
-    
+
     def get_current_sell_stops(self, id: Optional[int] = None) -> List[int] | None:
         return self.get_filtered_tickets(id=id, filter_type='sell_stops')
-    
+
     def get_current_buy_limits(self, id: Optional[int] = None) -> List[int] | None:
         return self.get_filtered_tickets(id=id, filter_type='buy_limits')
-    
+
     def get_current_sell_limits(self, id: Optional[int] = None) -> List[int] | None:
         return self.get_filtered_tickets(id=id, filter_type='sell_limits')
-    
+
     def get_current_buy_stop_limits(self, id: Optional[int] = None) -> List[int] | None:
         return self.get_filtered_tickets(id=id, filter_type='buy_stop_limits')
-    
+
     def get_current_sell_stop_limits(self, id: Optional[int] = None) -> List[int] | None:
         return self.get_filtered_tickets(id=id, filter_type='sell_stop_limits')
 
@@ -842,7 +845,8 @@ class Trade(RiskManagement):
             # All open positions for a specific strategy or expert no matter the symbol
             positions = self.get_positions()
             if positions is not None:
-                positions = [position for position in positions if position.magic == id]
+                positions = [
+                    position for position in positions if position.magic == id]
         elif not account and id is None:
             # All open positions for the current symbol no matter the strategy or expert
             positions = self.get_positions(symbol=self.symbol)
@@ -850,8 +854,9 @@ class Trade(RiskManagement):
             # All open positions for the current symbol and a specific strategy or expert
             positions = self.get_positions(symbol=self.symbol)
             if positions is not None:
-                positions = [position for position in positions if position.magic == id]
-        
+                positions = [
+                    position for position in positions if position.magic == id]
+
         if positions is not None:
             profit = 0.0
             balance = self.get_account_info().balance
@@ -864,7 +869,7 @@ class Trade(RiskManagement):
             return current_profit >= th_profit
         return False
 
-    def break_even(self, mm=True, 
+    def break_even(self, mm=True,
                    id: Optional[int] = None,
                    trail: Optional[bool] = True,
                    stop_trail: Optional[int] = None,
@@ -874,8 +879,9 @@ class Trade(RiskManagement):
         """
         This function checks if it's time to set the break-even level for a trading position. 
         If it is, it sets the break-even level. If the break-even level has already been set, 
-        it checks if the price has moved in a favorable direction. If it has, and the trail parameter is set to True, 
-        it updates the break-even level based on the trail_after_points and stop_trail parameters.
+        it checks if the price has moved in a favorable direction. 
+        If it has, and the trail parameter is set to True, it updates 
+        the break-even level based on the trail_after_points and stop_trail parameters.
 
         Args:
             id (int): The strategy ID or expert ID.
@@ -883,8 +889,10 @@ class Trade(RiskManagement):
             trail (bool): Whether to trail the stop loss or not.
             stop_trail (int): Number of points to trail the stop loss by.
                 It represent the distance from the current price to the stop loss.
-            trail_after_points (int): Number of points in profit from where the strategy will start to trail the stop loss.
-            be_plus_points (int): Number of points to add to the break-even level. Represents the minimum profit to secure.
+            trail_after_points (int): Number of points in profit 
+                from where the strategy will start to trail the stop loss.
+            be_plus_points (int): Number of points to add to the break-even level. 
+                Represents the minimum profit to secure.
         """
         time.sleep(0.1)
         if not mm:
@@ -910,7 +918,8 @@ class Trade(RiskManagement):
                         if position.ticket not in self.break_even_status:
                             price = None
                             if be_plus_points is not None:
-                                price = position.price_open + (be_plus_points * point)
+                                price = position.price_open + \
+                                    (be_plus_points * point)
                             self.set_break_even(position, be, price=price)
                             self.break_even_status.append(position.ticket)
                             self.break_even_points[position.ticket] = be
@@ -919,32 +928,40 @@ class Trade(RiskManagement):
                             if not trail:
                                 continue
                             # Check if the price has moved favorably
-                            new_be = round(be * 0.10) if be_plus_points is None else be_plus_points
+                            new_be = round(
+                                be * 0.10) if be_plus_points is None else be_plus_points
                             if trail_after_points is not None:
                                 if position.ticket not in self.trail_after_points:
                                     # This ensures that the position rich the minimum points required
                                     # before the trail can be set
                                     new_be = trail_after_points - be
-                                    self.trail_after_points.append(position.ticket)
+                                    self.trail_after_points.append(
+                                        position.ticket)
                             new_be_points = self.break_even_points[position.ticket] + new_be
-                            favorable_move = float(points/point) >= new_be_points
+                            favorable_move = float(
+                                points/point) >= new_be_points
                             if favorable_move:
                                 # This allows the position to go to take profit in case of a swing trade
                                 # If is a scalping position, we can set the stop_trail close to the current price.
-                                trail_points = round(be * 0.50) if stop_trail is None else stop_trail
+                                trail_points = round(
+                                    be * 0.50) if stop_trail is None else stop_trail
                                 # Calculate the new break-even level and price
                                 if position.type == 0:
                                     # This level validate the favorable move of the price
-                                    new_level = round(position.price_open + (new_be_points * point), digits) 
-                                    # This price is set away from the current price by the trail_points                                      
-                                    new_price = round(position.price_current - (trail_points * point), digits)
+                                    new_level = round(
+                                        position.price_open + (new_be_points * point), digits)
+                                    # This price is set away from the current price by the trail_points
+                                    new_price = round(
+                                        position.price_current - (trail_points * point), digits)
                                     if new_price < position.sl:
-                                        new_price = position.sl                                      
+                                        new_price = position.sl
                                 elif position.type == 1:
-                                    new_level = round(position.price_open - (new_be_points * point), digits)                                       
-                                    new_price = round(position.price_current + (trail_points * point), digits)  
+                                    new_level = round(
+                                        position.price_open - (new_be_points * point), digits)
+                                    new_price = round(
+                                        position.price_current + (trail_points * point), digits)
                                     if new_price > position.sl:
-                                        new_price = position.sl                                     
+                                        new_price = position.sl
                                 self.set_break_even(
                                     position, be, price=new_price, level=new_level
                                 )
@@ -1024,7 +1041,7 @@ class Trade(RiskManagement):
         addtionnal = f", SYMBOL={self.symbol}"
         time.sleep(0.1)
         try:
-            check_result = self.check_order(request)
+            self.check_order(request)
             result = self.send_order(request)
         except Exception as e:
             print(f"{self.current_datetime()} -", end=' ')
@@ -1042,7 +1059,7 @@ class Trade(RiskManagement):
                 else:
                     time.sleep(1)
                     try:
-                        check_result = self.check_order(request)
+                        self.check_order(request)
                         result = self.send_order(request)
                     except Exception as e:
                         print(f"{self.current_datetime()} -", end=' ')
@@ -1075,7 +1092,6 @@ class Trade(RiskManagement):
         value = self.get_symbol_info(self.symbol).trade_tick_value
         points = position.profit * (size / value / position.volume)
 
-        spread = self.get_symbol_info(self.symbol).spread
         point = self.get_symbol_info(self.symbol).point
         fees = self.get_stats()[0]["average_fee"] * -1
         risk = self.currency_risk()["trade_profit"]
@@ -1085,7 +1101,7 @@ class Trade(RiskManagement):
             win_be = th
         else:
             win_be = max(min_be, round((0.1 * be)))
-        win_trade = float(points/point) >= be
+        win_trade = float(points/point) >= win_be
         # Check if the positon is in profit
         if win_trade:
             # Check if break-even has already been set for this position
@@ -1130,7 +1146,7 @@ class Trade(RiskManagement):
         ticket = request[type]
         addtionnal = f", SYMBOL={self.symbol}"
         try:
-            check_result = self.check_order(request)
+            self.check_order(request)
             result = self.send_order(request)
         except Exception as e:
             print(f"{self.current_datetime()} -", end=' ')
@@ -1144,7 +1160,7 @@ class Trade(RiskManagement):
             while result.retcode != Mt5.TRADE_RETCODE_DONE and tries < 5:
                 time.sleep(1)
                 try:
-                    check_result = self.check_order(request)
+                    self.check_order(request)
                     result = self.send_order(request)
                 except Exception as e:
                     print(f"{self.current_datetime()} -", end=' ')
@@ -1163,10 +1179,10 @@ class Trade(RiskManagement):
             return True
         else:
             return False
-    
-    def close_order(self, 
-                    ticket: int, 
-                    id: Optional[int] = None, 
+
+    def close_order(self,
+                    ticket: int,
+                    id: Optional[int] = None,
                     comment: Optional[str] = None):
         """
         Close an open order by it ticket
@@ -1180,14 +1196,14 @@ class Trade(RiskManagement):
         -   True if order closed, False otherwise
         """
         request = {
-                "action": Mt5.TRADE_ACTION_REMOVE,
-                "symbol": self.symbol,
-                "order": ticket,
-                "magic": id if id is not None else self.expert_id,
-                "comment": f"@{self.expert_name}" if comment is None else comment,
-            }
+            "action": Mt5.TRADE_ACTION_REMOVE,
+            "symbol": self.symbol,
+            "order": ticket,
+            "magic": id if id is not None else self.expert_id,
+            "comment": f"@{self.expert_name}" if comment is None else comment,
+        }
         return self.close_request(request, type="order")
-  
+
     def close_position(self,
                        ticket: int,
                        id: Optional[int] = None,
@@ -1212,15 +1228,13 @@ class Trade(RiskManagement):
         positions = self.get_positions(ticket=ticket)
         buy_price = self.get_tick_info(self.symbol).ask
         sell_price = self.get_tick_info(self.symbol).bid
-        digits = self.get_symbol_info(self.symbol).digits
         deviation = self.get_deviation()
         if positions is not None and len(positions) == 1:
             position = positions[0]
             if (position.ticket == ticket
-                    and position.magic == Id
-                ):
+                        and position.magic == Id
+                    ):
                 buy = position.type == 0
-                sell = position.type == 1
                 request = {
                     "action": Mt5.TRADE_ACTION_DEAL,
                     "symbol": self.symbol,
@@ -1235,15 +1249,14 @@ class Trade(RiskManagement):
                     "type_filling": Mt5.ORDER_FILLING_FOK,
                 }
                 return self.close_request(request, type="position")
-  
-    def bulk_close(self, 
-                   tickets: List, 
+
+    def bulk_close(self,
+                   tickets: List,
                    tikets_type: Literal["positions", "orders"],
-                   close_func: Callable, 
-                   order_type: str, 
+                   close_func: Callable,
+                   order_type: str,
                    id: Optional[int] = None,
                    comment: Optional[str] = None):
-        
         """
         Close multiple orders or positions at once.
 
@@ -1257,13 +1270,12 @@ class Trade(RiskManagement):
         """
         if order_type == 'all':
             order_type = 'open'
-        if len(tickets) > 0:
+        if tickets is not None and len(tickets) > 0:
             for ticket in tickets.copy():
                 if close_func(ticket, id=id, comment=comment):
                     tickets.remove(ticket)
                 time.sleep(1)
-
-            if len(tickets) == 0:
+            if tickets is not None and len(tickets) == 0:
                 self.logger.info(
                     f"ALL {order_type.upper()} {tikets_type.upper()} closed, SYMBOL={self.symbol}.")
             else:
@@ -1273,11 +1285,12 @@ class Trade(RiskManagement):
             self.logger.info(
                 f"No {order_type.upper()} {tikets_type.upper()} to close, SYMBOL={self.symbol}.")
 
-    Orders = Literal["all", "buy_stops", "sell_stops", "buy_limits", 
+    Orders = Literal["all", "buy_stops", "sell_stops", "buy_limits",
                      "sell_limits", "buy_stop_limits", "sell_stop_limits"]
-    def close_orders(self, 
-                     order_type: Orders, 
-                     id: Optional[int] = None, 
+
+    def close_orders(self,
+                     order_type: Orders,
+                     id: Optional[int] = None,
                      comment: Optional[str] = None):
         """
         Args:
@@ -1307,6 +1320,7 @@ class Trade(RiskManagement):
             orders, "orders", self.close_order, order_type, id=id, comment=comment)
 
     Positions = Literal["all", "buy", "sell", "profitable", "losing"]
+
     def close_positions(
             self,
             position_type: Positions,
@@ -1347,7 +1361,6 @@ class Trade(RiskManagement):
         loss_trades = 0
         win_trades = 0
         balance = self.get_account_info().balance
-        target = round((balance * self.target)/100)
         deals = len(self.opened_positions)
         if deals != 0:
             for position in self.opened_positions:
@@ -1474,27 +1487,28 @@ class Trade(RiskManagement):
         else:
             # claculate number of minute from the end to the start
             start = datetime.strptime(self.start, '%H:%M')
-            end =  datetime.strptime(self.current_time(), '%H:%M')
+            end = datetime.strptime(self.current_time(), '%H:%M')
             minutes = (end - start).total_seconds() // 60
             sleep_time = (24*60) - minutes
             return sleep_time
 
     def current_datetime(self):
         return datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-    
+
     def current_time(self, seconds=False):
         if seconds:
             return datetime.now().strftime("%H:%M:%S")
         return datetime.now().strftime("%H:%M")
 
+
 def create_trade_instance(
-        symbols: List[str],
-        params: Dict[str, Any],
-        daily_risk: Optional[Dict[str, float]] = None,
-        max_risk: Optional[Dict[str, float]] = None,
-        pchange_sl: Optional[Dict[str, float] | float] = None,
-        **kwargs
-    ) -> Dict[str, Trade]:
+    symbols: List[str],
+    params: Dict[str, Any],
+    daily_risk: Optional[Dict[str, float]] = None,
+    max_risk: Optional[Dict[str, float]] = None,
+    pchange_sl: Optional[Dict[str, float] | float] = None,
+    **kwargs
+) -> Dict[str, Trade]:
     """
     Creates Trade instances for each symbol provided.
 
@@ -1509,59 +1523,74 @@ def create_trade_instance(
 
     Raises:
         ValueError: If the 'symbols' list is empty or the 'params' dictionary is missing required keys.
-    
+
     Note:
         `daily_risk` and `max_risk`  can be used to manage the risk of each symbol 
         based on the importance of the symbol in the portfolio or strategy.
     """
     logger = params.get('logger', None)
+    ids = params.get('expert_id', None)
     trade_instances = {}
     if not symbols:
         raise ValueError("The 'symbols' list cannot be empty.")
     if not params:
         raise ValueError("The 'params' dictionary cannot be empty.")
-    
+
     if daily_risk is not None:
         for symbol in symbols:
             if symbol not in daily_risk:
-                raise ValueError(f"Missing daily risk weight for symbol '{symbol}'.")
+                raise ValueError(
+                    f"Missing daily risk weight for symbol '{symbol}'.")
     if max_risk is not None:
         for symbol in symbols:
             if symbol not in max_risk:
-                raise ValueError(f"Missing maximum risk percentage for symbol '{symbol}'.")
+                raise ValueError(
+                    f"Missing maximum risk percentage for symbol '{symbol}'.")
     if pchange_sl is not None:
         if isinstance(pchange_sl, dict):
             for symbol in symbols:
                 if symbol not in pchange_sl:
-                    raise ValueError(f"Missing percentage change for symbol '{symbol}'.")
-    
+                    raise ValueError(
+                        f"Missing percentage change for symbol '{symbol}'.")
+    if isinstance(ids, dict):
+        for symbol in symbols:
+            if symbol not in ids:
+                raise ValueError(f"Missing expert ID for symbol '{symbol}'.")
+
     for symbol in symbols:
         try:
             params['symbol'] = symbol
+            params['expert_id'] = (
+                ids[symbol] if ids is not None and isinstance(ids, dict) else
+                ids if ids is not None and isinstance(ids, (int, float)) else
+                params['expert_id'] if 'expert_id' in params else None
+            )
             params['pchange_sl'] = (
                 pchange_sl[symbol] if pchange_sl is not None
-                and isinstance(pchange_sl, dict) else 
-                pchange_sl if pchange_sl is not None 
-                and isinstance(pchange_sl, (int, float)) else 
+                and isinstance(pchange_sl, dict) else
+                pchange_sl if pchange_sl is not None
+                and isinstance(pchange_sl, (int, float)) else
                 params['pchange_sl'] if 'pchange_sl' in params else None
             )
             params['daily_risk'] = (
-                daily_risk[symbol] if daily_risk is not None else 
+                daily_risk[symbol] if daily_risk is not None else
                 params['daily_risk'] if 'daily_risk' in params else None
             )
             params['max_risk'] = (
-                max_risk[symbol] if max_risk is not None else 
+                max_risk[symbol] if max_risk is not None else
                 params['max_risk'] if 'max_risk' in params else 10.0
             )
             trade_instances[symbol] = Trade(**params)
         except Exception as e:
             logger.error(f"Creating Trade instance, SYMBOL={symbol} {e}")
-    
+
     if len(trade_instances) != len(symbols):
         for symbol in symbols:
             if symbol not in trade_instances:
                 if logger is not None and isinstance(logger, Logger):
-                    logger.error(f"Failed to create Trade instance for SYMBOL={symbol}")
+                    logger.error(
+                        f"Failed to create Trade instance for SYMBOL={symbol}")
                 else:
-                    raise ValueError(f"Failed to create Trade instance for SYMBOL={symbol}")
-    return trade_instances
+                    raise ValueError(
+                        f"Failed to create Trade instance for SYMBOL={symbol}")
+    return trade_instances