bbstrader 0.3.0__py3-none-any.whl → 0.3.2__py3-none-any.whl

bbstrader/metatrader/copier.py

@@ -1,14 +1,15 @@
-import multiprocessing
+import multiprocessing as mp
 import time
 from datetime import datetime
+from multiprocessing.synchronize import Event
 from pathlib import Path
 from typing import Dict, List, Literal, Tuple
 
-from loguru import logger
+from loguru import logger as log
 
 from bbstrader.config import BBSTRADER_DIR
 from bbstrader.metatrader.account import Account, check_mt5_connection
-from bbstrader.metatrader.trade import Trade
+from bbstrader.metatrader.trade import FILLING_TYPE
 from bbstrader.metatrader.utils import TradeOrder, TradePosition, trade_retcode_message
 
 try:
@@ -17,15 +18,34 @@ except ImportError:
     import bbstrader.compat  # noqa: F401
 
 
-__all__ = ["TradeCopier", "RunCopier", "RunMultipleCopier", "config_copier"]
+__all__ = [
+    "TradeCopier",
+    "copier_worker_process",
+    "RunCopier",
+    "RunMultipleCopier",
+    "config_copier",
+]
 
-
-logger.add(
+log.add(
     f"{BBSTRADER_DIR}/logs/copier.log",
     enqueue=True,
     level="INFO",
     format="{time:YYYY-MM-DD HH:mm:ss} | {level} | {name} | {message}",
 )
+global logger
+logger = log
+
+
+ORDER_TYPE = {
+    0: (Mt5.ORDER_TYPE_BUY, "BUY"),
+    1: (Mt5.ORDER_TYPE_SELL, "SELL"),
+    2: (Mt5.ORDER_TYPE_BUY_LIMIT, "BUY LIMIT"),
+    3: (Mt5.ORDER_TYPE_SELL_LIMIT, "SELL LIMIT"),
+    4: (Mt5.ORDER_TYPE_BUY_STOP, "BUY STOP"),
+    5: (Mt5.ORDER_TYPE_SELL_STOP, "SELL STOP"),
+    6: (Mt5.ORDER_TYPE_BUY_STOP_LIMIT, "BUY STOP LIMIT"),
+    7: (Mt5.ORDER_TYPE_SELL_STOP_LIMIT, "SELL STOP LIMIT"),
+}
 
 
 def fix_lot(fixed):
@@ -113,34 +133,58 @@ def calculate_copy_lot(
         raise ValueError("Invalid mode selected")
 
 
-def get_copy_symbols(destination: dict = None):
+def get_symbols_from_string(symbols_string: str):
+    if not symbols_string:
+        raise ValueError("Input Error", "Tickers string cannot be empty.")
+    string = (
+        symbols_string.strip().replace("\n", "").replace(" ", "").replace('"""', "")
+    )
+    if ":" in string and "," in string:
+        if string.endswith(","):
+            string = string[:-1]
+        return dict(item.split(":") for item in string.split(","))
+    elif ":" in string and "," not in string:
+        raise ValueError("Each key pairs value must be separeted by ','")
+    elif "," in string and ":" not in string:
+        return string.split(",")
+    else:
+        raise ValueError("""
+        Invalid symbols format.
+        You can use comma separated symbols in one line or multiple lines using triple quotes.
+        You can also use a dictionary to map source symbols to destination symbols as shown below.
+        Or if you want to copy all symbols, use "all" or "*".
+
+        symbols = EURUSD,GBPUSD,USDJPY (comma separated)
+        symbols = EURUSD.s:EURUSD_i, GBPUSD.s:GBPUSD_i, USDJPY.s:USDJPY_i (dictionary) 
+        symbols = all (copy all symbols)
+        symbols = * (copy all symbols) """)
+
+
+def get_copy_symbols(destination: dict, source: dict) -> List[str] | Dict[str, str]:
     symbols = destination.get("symbols", "all")
-    account = Account(**destination)
+    src_account = Account(**source)
+    dest_account = Account(**destination)
     if symbols == "all" or symbols == "*":
-        return account.get_symbols()
+        src_symbols = src_account.get_symbols()
+        dest_symbols = dest_account.get_symbols()
+        for s in src_symbols:
+            if s not in dest_symbols:
+                err_msg = (
+                    f"To use 'all' or '*', Source account@{src_account.number} "
+                    f"and destination account@{dest_account.number} "
+                    f"must be the same type and have the same symbols"
+                    f"If not Use a dictionary to map source symbols to destination symbols "
+                    f"(e.g., EURUSD.s:EURUSD_i, GBPUSD.s:GBPUSD_i, USDJPY.s:USDJPY_i"
+                    f"Where EURUSD.s is the source symbols and EURUSD_i is the corresponding symbol"
+                )
+                raise ValueError(err_msg)
+        return dest_symbols
     elif isinstance(symbols, (list, dict)):
         return symbols
     elif isinstance(symbols, str):
-        if "," in symbols:
-            return symbols.split(",")
-        if " " in symbols:
-            return symbols.split()
-
-
-def get_copy_symbol(symbol, destination: dict = None, type="destination"):
-    symbols = get_copy_symbols(destination)
-    if isinstance(symbols, list):
-        if symbol in symbols:
-            return symbol
-    if isinstance(symbols, dict):
-        if type == "destination":
-            if symbol in symbols.keys():
-                return symbols[symbol]
-        if type == "source":
-            for k, v in symbols.items():
-                if v == symbol:
-                    return k
-    raise ValueError(f"Symbol {symbol} not found in {type} account")
+        return get_symbols_from_string(symbols)
+    else:
+        raise ValueError("Invalide symbols provided")
 
 
 class TradeCopier(object):
@@ -154,20 +198,39 @@ class TradeCopier(object):
 
     __slots__ = (
         "source",
+        "source_id",
+        "source_isunique",
         "destinations",
         "errors",
         "sleeptime",
         "start_time",
         "end_time",
+        "shutdown_event",
+        "custom_logger",
+        "log_queue",
+        "_last_session",
+        "_running",
     )
 
+    source: Dict
+    source_id: int
+    source_isunique: bool
+    destinations: List[dict]
+    shutdown_event: Event
+    log_queue: mp.Queue
+
     def __init__(
         self,
         source: Dict,
         destinations: List[dict],
+        /,
         sleeptime: float = 0.1,
         start_time: str = None,
         end_time: str = None,
+        *,
+        custom_logger=None,
+        shutdown_event=None,
+        log_queue=None,
     ):
         """
         Initializes the ``TradeCopier`` instance, setting up the source and destination trading accounts for trade copying.
@@ -183,7 +246,12 @@ class TradeCopier(object):
                     - `password`: The account password (string).
                     - `server`:  The server address (string), e.g., "Broker-Demo".
                     - `path`:  The path to the MetaTrader 5 installation directory (string).
-                    - ``portable``:  A boolean indicating whether to open MetaTrader 5 installation in portable mode.
+                    - `portable`:  A boolean indicating whether to open MetaTrader 5 installation in portable mode.
+                    - `id`: A unique identifier for all trades opened buy the source source account.
+                        This Must be a positive number greater than 0 and less than 2^32 / 2.
+                    - `unique`: A boolean indication whehter to allow destination accounts to copy from other sources.
+                        If Set to True, all destination accounts won't be allow to accept trades from other accounts even
+                        manually opened positions or orders will be removed.
 
             destinations (List[dict]):
                 A list of dictionaries, where each dictionary represents a destination trading account to which
@@ -235,23 +303,109 @@ class TradeCopier(object):
             sleeptime (float, optional):
                 The time interval in seconds between each iteration of the trade copying process.
                 Defaults to 0.1 seconds. It can be useful if you know the frequency of new trades on the source account.
+
+            start_time (str, optional): The time (HH:MM) from which the copier start copying from the source.
+            end_time (str, optional): The time (HH:MM) from which the copier stop copying from the source.
+            sleeptime (float, optional): The delay between each check from the source account.
+            custom_logger (Any, Optional): Used to set a cutum logger (default is ``loguru.logger``)
+            shutdown_event (Any, Otional): Use to terminal the copy process when runs in a custum environment like web App or GUI.
+            log_queue (multiprocessing.Queue, Optional): Use to send log to an external program, usefule in GUI apps
+
         Note:
             The source account and the destination accounts must be connected to different MetaTrader 5 platforms.
             you can copy the initial installation of MetaTrader 5 to a different directory and rename it to create a new instance
             Then you can connect destination accounts to the new instance while the source account is connected to the original instance.
         """
         self.source = source
+        self.source_id = source.get("id", 0)
+        self.source_isunique = source.get("unique", True)
         self.destinations = destinations
         self.sleeptime = sleeptime
         self.start_time = start_time
         self.end_time = end_time
         self.errors = set()
+        self.log_queue = log_queue
+        self._add_logger(custom_logger)
+        self._validate_source()
         self._add_copy()
+        self.shutdown_event = (
+            shutdown_event if shutdown_event is not None else mp.Event()
+        )
+        self._last_session = datetime.now().date()
+        self._running = True
+
+    @property
+    def running(self):
+        """Check if the Trade Copier is running."""
+        return self._running
+
+    def _add_logger(self, custom_logger):
+        if custom_logger:
+            global logger
+            logger = custom_logger
 
     def _add_copy(self):
-        self.source["copy"] = True
+        self.source["copy"] = self.source.get("copy", True)
         for destination in self.destinations:
+            destination["copy"] = destination.get("copy", True)
+
+    def _log_message(self, message, type="info"):
+        if self.log_queue:
+            try:
+                now = datetime.now()
+                formatted = (
+                    now.strftime("%Y-%m-%d %H:%M:%S.")
+                    + f"{int(now.microsecond / 1000):03d}"
+                )
+                space = len("warning") # longest log name
+                self.log_queue.put(
+                    f"{formatted} |{type.upper()} {' '*(space - len(type))}|  - {message}"
+                )
+            except Exception:
+                pass
+        else:
+            logmethod = logger.info if type == "info" else logger.error
+            logmethod(message)
+
+    def log_error(self, e, symbol=None):
+        if datetime.now().date() > self._last_session:
+            self._last_session = datetime.now().date()
+            self.errors.clear()
+        error_msg = repr(e)
+        if error_msg not in self.errors:
+            self.errors.add(error_msg)
+            add_msg = f"SYMBOL={symbol}" if symbol else ""
+            message = f"Error encountered: {error_msg}, {add_msg}"
+            self._log_message(message, type="error")
+
+    def _validate_source(self):
+        if not self.source_isunique:
+            try:
+                assert self.source_id >= 1
+            except AssertionError:
+                raise ValueError(
+                    "Non Unique source account must have a valide ID , (e.g., source['id'] = 1234)"
+                )
+
+    def add_destinations(self, destination_accounts: List[dict]):
+        self.stop()
+        destinations = destination_accounts.copy()
+        for destination in destinations:
             destination["copy"] = True
+            self.destinations.append(destination)
+        self.run()
+
+    def _get_magic(self, ticket: int) -> int:
+        return int(str(self.source_id) + str(ticket)) if self.source_id >= 1 else ticket
+
+    def _select_symbol(self, symbol: str, destination: dict):
+        selected = Mt5.symbol_select(symbol, True)
+        if not selected:
+            self._log_message(
+                f"Failed to select {destination.get('login')}::{symbol}, error code =",
+                Mt5.last_error(),
+                type="error",
+            )
 
     def source_orders(self, symbol=None):
         check_mt5_connection(**self.source)
@@ -269,8 +423,23 @@ class TradeCopier(object):
         check_mt5_connection(**destination)
         return Account(**destination).get_positions(symbol=symbol)
 
+    def get_copy_symbol(self, symbol, destination: dict = None, type="destination"):
+        symbols = get_copy_symbols(destination, self.source)
+        if isinstance(symbols, list):
+            if symbol in symbols:
+                return symbol
+        if isinstance(symbols, dict):
+            if type == "destination":
+                if symbol in symbols.keys():
+                    return symbols[symbol]
+            if type == "source":
+                for k, v in symbols.items():
+                    if v == symbol:
+                        return k
+        raise ValueError(f"Symbol {symbol} not found in {type} account")
+
     def isorder_modified(self, source: TradeOrder, dest: TradeOrder):
-        if source.type == dest.type and source.ticket == dest.magic:
+        if source.type == dest.type and self._get_magic(source.ticket) == dest.magic:
             return (
                 source.sl != dest.sl
                 or source.tp != dest.tp
@@ -280,7 +449,7 @@ class TradeCopier(object):
         return False
 
     def isposition_modified(self, source: TradePosition, dest: TradePosition):
-        if source.type == dest.type and source.ticket == dest.magic:
+        if source.type == dest.type and self._get_magic(source.ticket) == dest.magic:
             return source.sl != dest.sl or source.tp != dest.tp
         return False
 
@@ -308,14 +477,24 @@ class TradeCopier(object):
                 return True
             return False
 
-    def copy_new_trade(
-        self, trade: TradeOrder | TradePosition, action_type: dict, destination: dict
-    ):
+    def _update_filling_type(self, request, result):
+        new_result = result
+        if result.retcode == Mt5.TRADE_RETCODE_INVALID_FILL:
+            for fill in FILLING_TYPE:
+                request["type_filling"] = fill
+                new_result = Mt5.order_send(request)
+                if new_result.retcode == Mt5.TRADE_RETCODE_DONE:
+                    break
+        return new_result
+
+    def copy_new_trade(self, trade: TradeOrder | TradePosition, destination: dict):
         if not self.iscopy_time():
             return
         check_mt5_connection(**destination)
+        symbol = self.get_copy_symbol(trade.symbol, destination)
+        self._select_symbol(symbol, destination)
+
         volume = trade.volume if hasattr(trade, "volume") else trade.volume_initial
-        symbol = get_copy_symbol(trade.symbol, destination)
         lot = calculate_copy_lot(
             volume,
             symbol,
@@ -325,51 +504,56 @@ class TradeCopier(object):
             source_eqty=Account(**self.source).get_account_info().margin_free,
             dest_eqty=Account(**destination).get_account_info().margin_free,
         )
-
-        trade_instance = Trade(symbol=symbol, **destination, max_risk=100.0, logger=None)
-        try:
-            action = action_type[trade.type]
-        except KeyError:
-            return
+        trade_action = (
+            Mt5.TRADE_ACTION_DEAL if trade.type in [0, 1] else Mt5.TRADE_ACTION_PENDING
+        )
+        action = ORDER_TYPE[trade.type][1]
+        tick = Mt5.symbol_info_tick(symbol)
+        price = tick.ask if trade.type == 0 else tick.bid
         try:
-            if trade_instance.open_position(
-                action,
+            request = dict(
+                symbol=symbol,
+                action=trade_action,
                 volume=lot,
+                price=price,
                 sl=trade.sl,
                 tp=trade.tp,
-                id=trade.ticket,
-                symbol=symbol,
-                mm=trade.sl != 0 and trade.tp != 0,
-                price=trade.price_open if trade.type not in [0, 1] else None,
-                stoplimit=trade.price_stoplimit if trade.type in [6, 7] else None,
+                type=ORDER_TYPE[trade.type][0],
+                magic=self._get_magic(trade.ticket),
+                deviation=Mt5.symbol_info(symbol).spread,
                 comment=destination.get("comment", trade.comment + "#Copied"),
-            ):
-                logger.info(
+                type_time=Mt5.ORDER_TIME_GTC,
+                type_filling=Mt5.ORDER_FILLING_FOK,
+            )
+            if trade.type not in [0, 1]:
+                request["price"] = trade.price_open
+
+            if trade.type in [6, 7]:
+                request["stoplimit"] = trade.price_stoplimit
+
+            result = Mt5.order_send(request)
+            if result.retcode != Mt5.TRADE_RETCODE_DONE:
+                result = self._update_filling_type(request, result)
+            if result.retcode == Mt5.TRADE_RETCODE_DONE:
+                self._log_message(
                     f"Copy {action} Order #{trade.ticket} from @{self.source.get('login')}::{trade.symbol} "
-                    f"to @{destination.get('login')}::{symbol}"
+                    f"to @{destination.get('login')}::{symbol}",
                 )
-            else:
-                logger.error(
+            if result.retcode != Mt5.TRADE_RETCODE_DONE:
+                self._log_message(
                     f"Error copying {action} Order #{trade.ticket} from @{self.source.get('login')}::{trade.symbol} "
-                    f"to @{destination.get('login')}::{symbol}"
+                    f"to @{destination.get('login')}::{symbol}, {trade_retcode_message(result.retcode)}",
+                    type="error",
                 )
         except Exception as e:
             self.log_error(e, symbol=symbol)
 
     def copy_new_order(self, order: TradeOrder, destination: dict):
-        action_type = {
-            2: "BLMT",
-            3: "SLMT",
-            4: "BSTP",
-            5: "SSTP",
-            6: "BSTPLMT",
-            7: "SSTPLMT",
-        }
-        self.copy_new_trade(order, action_type, destination)
+        self.copy_new_trade(order, destination)
 
     def modify_order(self, ticket, symbol, source_order: TradeOrder, destination: dict):
         check_mt5_connection(**destination)
-        account = Account(**destination)
+        self._select_symbol(symbol, destination)
         request = {
             "action": Mt5.TRADE_ACTION_MODIFY,
             "order": ticket,
@@ -379,42 +563,51 @@ class TradeCopier(object):
             "tp": source_order.tp,
             "stoplimit": source_order.price_stoplimit,
         }
-        result = account.send_order(request)
+        result = Mt5.order_send(request)
         if result.retcode != Mt5.TRADE_RETCODE_DONE:
-            msg = trade_retcode_message(result.retcode)
-            logger.error(
-                f"Error modifying Order #{ticket} on @{destination.get('login')}::{symbol}, {msg}, "
-                f"SOURCE=@{self.source.get('login')}::{source_order.symbol}"
-            )
+            result = self._update_filling_type(request, result)
         if result.retcode == Mt5.TRADE_RETCODE_DONE:
-            logger.info(
-                f"Modify Order #{ticket} on @{destination.get('login')}::{symbol}, "
+            self._log_message(
+                f"Modify {ORDER_TYPE[source_order.type][1]} Order #{ticket} on @{destination.get('login')}::{symbol}, "
                 f"SOURCE=@{self.source.get('login')}::{source_order.symbol}"
             )
+        if result.retcode != Mt5.TRADE_RETCODE_DONE:
+            self._log_message(
+                f"Error modifying {ORDER_TYPE[source_order.type][1]} Order #{ticket} on @{destination.get('login')}::{symbol},"
+                f"SOURCE=@{self.source.get('login')}::{source_order.symbol},  {trade_retcode_message(result.retcode)}",
+                type="error",
+            )
 
     def remove_order(self, src_symbol, order: TradeOrder, destination: dict):
         check_mt5_connection(**destination)
-        trade = Trade(symbol=order.symbol, **destination, logger=None)
-        if trade.close_order(order.ticket, id=order.magic):
-            logger.info(
-                f"Close Order #{order.ticket} on @{destination.get('login')}::{order.symbol}, "
+        self._select_symbol(order.symbol, destination)
+        request = {
+            "action": Mt5.TRADE_ACTION_REMOVE,
+            "order": order.ticket,
+        }
+        result = Mt5.order_send(request)
+        if result.retcode != Mt5.TRADE_RETCODE_DONE:
+            result = self._update_filling_type(request, result)
+        if result.retcode == Mt5.TRADE_RETCODE_DONE:
+            self._log_message(
+                f"Close {ORDER_TYPE[order.type][1]} Order #{order.ticket}  on @{destination.get('login')}::{order.symbol}, "
                 f"SOURCE=@{self.source.get('login')}::{src_symbol}"
             )
-        else:
-            logger.error(
-                f"Error closing Order #{order.ticket} on @{destination.get('login')}::{order.symbol}, "
-                f"SOURCE=@{self.source.get('login')}::{src_symbol}"
+        if result.retcode != Mt5.TRADE_RETCODE_DONE:
+            self._log_message(
+                f"Error closing {ORDER_TYPE[order.type][1]} Order #{order.ticket} on @{destination.get('login')}::{order.symbol}, "
+                f"SOURCE=@{self.source.get('login')}::{src_symbol}, {trade_retcode_message(result.retcode)}",
+                type="error",
             )
 
     def copy_new_position(self, position: TradePosition, destination: dict):
-        action_type = {0: "BMKT", 1: "SMKT"}
-        self.copy_new_trade(position, action_type, destination)
+        self.copy_new_trade(position, destination)
 
     def modify_position(
         self, ticket, symbol, source_pos: TradePosition, destination: dict
     ):
         check_mt5_connection(**destination)
-        account = Account(**destination)
+        self._select_symbol(symbol, destination)
         request = {
             "action": Mt5.TRADE_ACTION_SLTP,
             "position": ticket,
@@ -422,31 +615,54 @@ class TradeCopier(object):
             "sl": source_pos.sl,
             "tp": source_pos.tp,
         }
-        result = account.send_order(request)
+        result = Mt5.order_send(request)
         if result.retcode != Mt5.TRADE_RETCODE_DONE:
-            msg = trade_retcode_message(result.retcode)
-            logger.error(
-                f"Error modifying Position #{ticket} on @{destination.get('login')}::{symbol},  {msg}, "
-                f"SOURCE=@{self.source.get('login')}::{source_pos.symbol}"
-            )
+            result = self._update_filling_type(request, result)
         if result.retcode == Mt5.TRADE_RETCODE_DONE:
-            logger.info(
-                f"Modify Position #{ticket} on @{destination.get('login')}::{symbol}, "
+            self._log_message(
+                f"Modify {ORDER_TYPE[source_pos.type][1]} Position #{ticket} on @{destination.get('login')}::{symbol}, "
                 f"SOURCE=@{self.source.get('login')}::{source_pos.symbol}"
             )
+        if result.retcode != Mt5.TRADE_RETCODE_DONE:
+            self._log_message(
+                f"Error modifying {ORDER_TYPE[source_pos.type][1]} Position #{ticket} on @{destination.get('login')}::{symbol}, "
+                f"SOURCE=@{self.source.get('login')}::{source_pos.symbol}, {trade_retcode_message(result.retcode)}",
+                type="error",
+            )
 
     def remove_position(self, src_symbol, position: TradePosition, destination: dict):
         check_mt5_connection(**destination)
-        trade = Trade(symbol=position.symbol, **destination, logger=None)
-        if trade.close_position(position.ticket, id=position.magic):
-            logger.info(
-                f"Close Position #{position.ticket} on @{destination.get('login')}::{position.symbol}, "
+        self._select_symbol(position.symbol, destination)
+        position_type = (
+            Mt5.ORDER_TYPE_SELL if position.type == 0 else Mt5.ORDER_TYPE_BUY
+        )
+        request = {
+            "action": Mt5.TRADE_ACTION_DEAL,
+            "symbol": position.symbol,
+            "volume": position.volume,
+            "type": position_type,
+            "position": position.ticket,
+            "price": position.price_current,
+            "deviation": int(Mt5.symbol_info(position.symbol).spread),
+            "type_time": Mt5.ORDER_TIME_GTC,
+            "type_filling": Mt5.ORDER_FILLING_FOK,
+        }
+        result = Mt5.order_send(request)
+        if result.retcode != Mt5.TRADE_RETCODE_DONE:
+            result = self._update_filling_type(request, result)
+
+        if result.retcode == Mt5.TRADE_RETCODE_DONE:
+            self._log_message(
+                f"Close {ORDER_TYPE[position.type][1]} Position #{position.ticket} "
+                f"on @{destination.get('login')}::{position.symbol}, "
                 f"SOURCE=@{self.source.get('login')}::{src_symbol}"
             )
-        else:
-            logger.error(
-                f"Error closing Position #{position.ticket} on @{destination.get('login')}::{position.symbol}, "
-                f"SOURCE=@{self.source.get('login')}::{src_symbol}"
+        if result.retcode != Mt5.TRADE_RETCODE_DONE:
+            self._log_message(
+                f"Error closing {ORDER_TYPE[position.type][1]} Position #{position.ticket} "
+                f"on @{destination.get('login')}::{position.symbol}, "
+                f"SOURCE=@{self.source.get('login')}::{src_symbol},  {trade_retcode_message(result.retcode)}",
+                type="error",
             )
 
     def filter_positions_and_orders(self, pos_or_orders, symbols=None):
@@ -461,9 +677,11 @@ class TradeCopier(object):
                 if pos.symbol in symbols.keys() or pos.symbol in symbols.values()
             ]
 
-    def get_positions(self, destination: dict):
+    def get_positions(
+        self, destination: dict
+    ) -> Tuple[List[TradePosition], List[TradePosition]]:
         source_positions = self.source_positions() or []
-        dest_symbols = get_copy_symbols(destination)
+        dest_symbols = get_copy_symbols(destination, self.source)
         dest_positions = self.destination_positions(destination) or []
         source_positions = self.filter_positions_and_orders(
             source_positions, symbols=dest_symbols
@@ -473,9 +691,11 @@ class TradeCopier(object):
         )
         return source_positions, dest_positions
 
-    def get_orders(self, destination: dict):
+    def get_orders(
+        self, destination: dict
+    ) -> Tuple[List[TradeOrder], List[TradeOrder]]:
         source_orders = self.source_orders() or []
-        dest_symbols = get_copy_symbols(destination)
+        dest_symbols = get_copy_symbols(destination, self.source)
         dest_orders = self.destination_orders(destination) or []
         source_orders = self.filter_positions_and_orders(
             source_orders, symbols=dest_symbols
@@ -485,12 +705,27 @@ class TradeCopier(object):
         )
         return source_orders, dest_orders
 
+    def _copy_what(self, destination):
+        if not destination.get("copy", False):
+            raise ValueError("Destination account not set to copy mode")
+        return destination.get("copy_what", "all")
+
+    def _isvalide_magic(self, magic):
+        ticket = str(magic)
+        id = str(self.source_id)
+        return (
+            ticket != id
+            and ticket.startswith(id)
+            and ticket[: len(id)] == id
+            and int(ticket[: len(id)]) == self.source_id
+        )
+
     def _copy_new_orders(self, destination):
         source_orders, destination_orders = self.get_orders(destination)
         # Check for new orders
         dest_ids = [order.magic for order in destination_orders]
         for source_order in source_orders:
-            if source_order.ticket not in dest_ids:
+            if self._get_magic(source_order.ticket) not in dest_ids:
                 if not self.slippage(source_order, destination):
                     self.copy_new_order(source_order, destination)
 
@@ -499,7 +734,7 @@ class TradeCopier(object):
         source_orders, destination_orders = self.get_orders(destination)
         for source_order in source_orders:
             for destination_order in destination_orders:
-                if source_order.ticket == destination_order.magic:
+                if self._get_magic(source_order.ticket) == destination_order.magic:
                     if self.isorder_modified(source_order, destination_order):
                         ticket = destination_order.ticket
                         symbol = destination_order.symbol
@@ -508,27 +743,16 @@ class TradeCopier(object):
     def _copy_closed_orders(self, destination):
         # Check for closed orders
         source_orders, destination_orders = self.get_orders(destination)
-        source_ids = [order.ticket for order in source_orders]
+        source_ids = [self._get_magic(order.ticket) for order in source_orders]
         for destination_order in destination_orders:
             if destination_order.magic not in source_ids:
-                src_symbol = get_copy_symbol(
-                    destination_order.symbol, destination, type="source"
-                )
-                self.remove_order(src_symbol, destination_order, destination)
-
-    def _sync_positions(self, what, destination):
-        # Update postions
-        source_positions, _ = self.get_positions(destination)
-        _, destination_orders = self.get_orders(destination)
-        for source_position in source_positions:
-            for destination_order in destination_orders:
-                if source_position.ticket == destination_order.magic:
-                    self.remove_order(
-                        source_position.symbol, destination_order, destination
+                if self.source_isunique or self._isvalide_magic(
+                    destination_order.magic
+                ):
+                    src_symbol = self.get_copy_symbol(
+                        destination_order.symbol, destination, type="source"
                     )
-                    if what in ["all", "positions"]:
-                        if not self.slippage(source_position, destination):
-                            self.copy_new_position(source_position, destination)
+                    self.remove_order(src_symbol, destination_order, destination)
 
     def _sync_orders(self, destination):
         # Update orders
@@ -536,18 +760,13 @@ class TradeCopier(object):
         source_orders, _ = self.get_orders(destination)
         for destination_position in destination_positions:
             for source_order in source_orders:
-                if destination_position.magic == source_order.ticket:
+                if destination_position.magic == self._get_magic(source_order.ticket):
                     self.remove_position(
                         source_order.symbol, destination_position, destination
                     )
                     if not self.slippage(source_order, destination):
                         self.copy_new_order(source_order, destination)
 
-    def _copy_what(self, destination):
-        if not destination.get("copy", False):
-            raise ValueError("Destination account not set to copy mode")
-        return destination.get("copy_what", "all")
-    
     def copy_orders(self, destination: dict):
         what = self._copy_what(destination)
         if what not in ["all", "orders"]:
@@ -564,7 +783,7 @@ class TradeCopier(object):
         # Check for new positions
         dest_ids = [pos.magic for pos in destination_positions]
         for source_position in source_positions:
-            if source_position.ticket not in dest_ids:
+            if self._get_magic(source_position.ticket) not in dest_ids:
                 if not self.slippage(source_position, destination):
                     self.copy_new_position(source_position, destination)
 
@@ -573,7 +792,10 @@ class TradeCopier(object):
         source_positions, destination_positions = self.get_positions(destination)
         for source_position in source_positions:
             for destination_position in destination_positions:
-                if source_position.ticket == destination_position.magic:
+                if (
+                    self._get_magic(source_position.ticket)
+                    == destination_position.magic
+                ):
                     if self.isposition_modified(source_position, destination_position):
                         ticket = destination_position.ticket
                         symbol = destination_position.symbol
@@ -584,13 +806,30 @@ class TradeCopier(object):
     def _copy_closed_position(self, destination):
         # Check for closed positions
         source_positions, destination_positions = self.get_positions(destination)
-        source_ids = [pos.ticket for pos in source_positions]
+        source_ids = [self._get_magic(pos.ticket) for pos in source_positions]
         for destination_position in destination_positions:
             if destination_position.magic not in source_ids:
-                src_symbol = get_copy_symbol(
-                    destination_position.symbol, destination, type="source"
-                )
-                self.remove_position(src_symbol, destination_position, destination)
+                if self.source_isunique or self._isvalide_magic(
+                    destination_position.magic
+                ):
+                    src_symbol = self.get_copy_symbol(
+                        destination_position.symbol, destination, type="source"
+                    )
+                    self.remove_position(src_symbol, destination_position, destination)
+
+    def _sync_positions(self, what, destination):
+        # Update postions
+        source_positions, _ = self.get_positions(destination)
+        _, destination_orders = self.get_orders(destination)
+        for source_position in source_positions:
+            for destination_order in destination_orders:
+                if self._get_magic(source_position.ticket) == destination_order.magic:
+                    self.remove_order(
+                        source_position.symbol, destination_order, destination
+                    )
+                    if what in ["all", "positions"]:
+                        if not self.slippage(source_position, destination):
+                            self.copy_new_position(source_position, destination)
 
     def copy_positions(self, destination: dict):
         what = self._copy_what(destination)
@@ -601,50 +840,224 @@ class TradeCopier(object):
         self._copy_modified_positions(destination)
         self._copy_closed_position(destination)
 
-    def log_error(self, e, symbol=None):
-        error_msg = repr(e)
-        if error_msg not in self.errors:
-            self.errors.add(error_msg)
-            add_msg = f"SYMBOL={symbol}" if symbol else ""
-            logger.error(f"Error encountered: {error_msg}, {add_msg}")
+    def start_copy_process(self, destination: dict):
+        """
+        Worker process: copy orders and positions for a single destination account.
+        """
+        if destination.get("path") == self.source.get("path"):
+            self._log_message(
+                f"Source and destination accounts are on the same  "
+                f"MetaTrader 5 installation {self.source.get('path')} which is not allowed."
+            )
+            return
 
-    def run(self):
-        logger.info("Trade Copier Running ...")
-        logger.info(f"Source Account: {self.source.get('login')}")
-        while True:
+        self._log_message(
+            f"Copy started for source @{self.source.get('login')} "
+            f" and destination @{destination.get('login')}"
+        )
+        while not self.shutdown_event.is_set():
             try:
-                for destination in self.destinations:
-                    if destination.get("path") == self.source.get("path"):
-                        err_msg = "Source and destination accounts are on the same \
-                            MetaTrader 5 installation which is not allowed."
-                        logger.error(err_msg)
-                        continue
-                    self.copy_orders(destination)
-                    self.copy_positions(destination)
-                    Mt5.shutdown()
-                    time.sleep(0.1)
+                self.copy_positions(destination)
+                self.copy_orders(destination)
             except KeyboardInterrupt:
-                logger.info("Stopping the Trade Copier ...")
-                exit(0)
+                self._log_message(
+                    "KeyboardInterrupt received, stopping the Trade Copier ..."
+                )
+                self.stop()
             except Exception as e:
                 self.log_error(e)
-            time.sleep(self.sleeptime)
+
+        self._log_message(
+            f"Process exiting for destination @{destination.get('login')} due to shutdown event."
+        )
+
+    def run(self):
+        """
+        Entry point to start the copier.
+        This will loop through the destinations it was given and process them.
+        """
+        self._log_message(
+            f"Copier instance started for source @{self.source.get('login')}"
+        )
+        try:
+            while not self.shutdown_event.is_set():
+                for destination in self.destinations:
+                    if self.shutdown_event.is_set():
+                        break
+
+                    if destination.get("path") == self.source.get("path"):
+                        self._log_message(
+                            f"Source and destination accounts are on the same "
+                            f"MetaTrader 5 installation {self.source.get('path')} which is not allowed."
+                        )
+                        continue
+                    try:
+                        self.copy_positions(destination)
+                        self.copy_orders(destination)
+                    except Exception as e:
+                        self.log_error(e)
+                time.sleep(self.sleeptime)
+
+        except KeyboardInterrupt:
+            self._log_message(
+                "KeyboardInterrupt received, stopping the copier instance..."
+            )
+            self.shutdown_event.set()
+
+        self._log_message(
+            f"Copier instance for source @{self.source.get('login')} is shutting down."
+        )
+
+    def stop(self):
+        """
+        Stop the Trade Copier gracefully by setting the shutdown event.
+        """
+        if self._running:
+            self._log_message(
+                f"Signaling stop for Trade Copier on source account @{self.source.get('login')}..."
+            )
+            self._running = False
+            self.shutdown_event.set()
+        self._log_message("Trade Copier stopped successfully.")
+
+
+def copier_worker_process(
+    source_config: dict,
+    destination_config: dict,
+    sleeptime: float,
+    start_time: str,
+    end_time: str,
+    /,
+    custom_logger=None,
+    shutdown_event=None,
+    log_queue=None,
+):
+    """A top-level worker function for handling a single source-to-destination copy task.
+
+    This function is the cornerstone of the robust, multi-process architecture. It is
+    designed to be the `target` of a `multiprocessing.Process`. By being a top-level
+    function, it avoids pickling issues on Windows and ensures that each copy task
+    runs in a completely isolated process.
+
+    A controller (like a GUI or a master script) should spawn one process with this
+    target for each destination account it needs to manage.
+
+    Args:
+        source_config (dict): Configuration dictionary for the source account.
+            Must contain 'login', 'password', 'server', and 'path'.
+        destination_config (dict): Configuration dictionary for a *single*
+            destination account.
+        sleeptime (float): The time in seconds to wait between copy cycles.
+        start_time (str): The time of day to start copying (e.g., "08:00").
+        end_time (str): The time of day to stop copying (e.g., "22:00").
+        custom_logger: An optional custom logger instance.
+        shutdown_event (multiprocessing.Event): An event object that, when set,
+            will signal this process to terminate gracefully.
+        log_queue (multiprocessing.Queue): A queue for sending log messages back
+            to the parent process in a thread-safe manner.
+    """
+    copier = TradeCopier(
+        source_config,
+        [destination_config],
+        sleeptime=sleeptime,
+        start_time=start_time,
+        end_time=end_time,
+        custom_logger=custom_logger,
+        shutdown_event=shutdown_event,
+        log_queue=log_queue,
+    )
+    copier.start_copy_process(destination_config)
 
 
 def RunCopier(
-    source: dict, destinations: list, sleeptime: float, start_time: str, end_time: str
+    source: dict,
+    destinations: list,
+    sleeptime: float,
+    start_time: str,
+    end_time: str,
+    /,
+    custom_logger=None,
+    shutdown_event=None,
+    log_queue=None,
 ):
-    copier = TradeCopier(source, destinations, sleeptime, start_time, end_time)
+    """Initializes and runs a TradeCopier instance in a single process.
+
+    This function serves as a straightforward wrapper to start a copying session
+    that handles one source account and one or more destination accounts
+    *sequentially* within the same thread. It does not create any new processes itself.
+
+    This is useful for:
+    - Simpler, command-line based use cases.
+    - Scenarios where parallelism is not required.
+    - As the target for `RunMultipleCopier`, where each process handles a
+      full source-to-destinations session.
+
+    Args:
+        source (dict): Configuration dictionary for the source account.
+        destinations (list): A list of configuration dictionaries, one for each
+            destination account to be processed sequentially.
+        sleeptime (float): The time in seconds to wait after completing a full
+            cycle through all destinations.
+        start_time (str): The time of day to start copying (e.g., "08:00").
+        end_time (str): The time of day to stop copying (e.g., "22:00").
+        custom_logger: An optional custom logger instance.
+        shutdown_event (multiprocessing.Event): An event to signal shutdown.
+        log_queue (multiprocessing.Queue): A queue for log messages.
+    """
+    copier = TradeCopier(
+        source,
+        destinations,
+        sleeptime=sleeptime,
+        start_time=start_time,
+        end_time=end_time,
+        custom_logger=custom_logger,
+        shutdown_event=shutdown_event,
+        log_queue=log_queue,
+    )
     copier.run()
 
 
 def RunMultipleCopier(
     accounts: List[dict],
-    sleeptime: float = 0.1,
+    sleeptime: float = 0.01,
     start_delay: float = 1.0,
     start_time: str = None,
     end_time: str = None,
+    shutdown_event=None,
+    custom_logger=None,
+    log_queue=None,
 ):
+    """Manages multiple, independent trade copying sessions in parallel.
+
+    This function acts as a high-level manager that takes a list of account
+    setups and creates a separate, dedicated process for each one. Each process
+    is responsible for copying from one source account to its associated list of
+    destination accounts.
+
+    The parallelism occurs at the **source account level**. Within each spawned
+    process, the destinations for that source are handled sequentially by `RunCopier`.
+
+    Example `accounts` structure:
+    [
+        { "source": {...}, "destinations": [{...}, {...}] },  # -> Process 1
+        { "source": {...}, "destinations": [{...}] }          # -> Process 2
+    ]
+
+    Args:
+        accounts (List[dict]): A list of account configurations. Each item in the
+            list must be a dictionary with a 'source' key and a 'destinations' key.
+        sleeptime (float): The sleep time passed down to each `RunCopier` process.
+        start_delay (float): A delay in seconds between starting each new process.
+            This helps prevent resource contention by staggering the initialization
+            of multiple MetaTrader 5 terminals.
+        start_time (str): The start time passed down to each `RunCopier` process.
+        end_time (str): The end time passed down to each `RunCopier` process.
+        shutdown_event (multiprocessing.Event): An event to signal shutdown to all
+            child processes.
+        custom_logger: An optional custom logger instance.
+        log_queue (multiprocessing.Queue): A queue for aggregating log messages
+            from all child processes.
+    """
     processes = []
 
     for account in accounts:
@@ -655,16 +1068,26 @@ def RunMultipleCopier(
             logger.warning("Skipping account due to missing source or destinations.")
             continue
         paths = set([source.get("path")] + [dest.get("path") for dest in destinations])
-        if len(paths) == 1:
+        if len(paths) == 1 and len(destinations) >= 1:
             logger.warning(
-                "Skipping account due to same MetaTrader 5 installation path."
+                "Skipping account: source and destination cannot share the same MetaTrader 5 terminal path."
             )
             continue
         logger.info(f"Starting process for source account @{source.get('login')}")
-
-        process = multiprocessing.Process(
+        process = mp.Process(
             target=RunCopier,
-            args=(source, destinations, sleeptime, start_time, end_time),
+            args=(
+                source,
+                destinations,
+                sleeptime,
+                start_time,
+                end_time,
+            ),
+            kwargs=dict(
+                custom_logger=custom_logger,
+                shutdown_event=shutdown_event,
+                log_queue=log_queue,
+            ),
         )
         processes.append(process)
         process.start()
@@ -672,42 +1095,18 @@ def RunMultipleCopier(
         if start_delay:
             time.sleep(start_delay)
 
-    # Wait for all processes to complete
     for process in processes:
         process.join()
 
 
-def _strtodict(string: str) -> dict:
-    string = string.strip().replace("\n", "").replace(" ", "").replace('"""', "")
-    return dict(item.split(":") for item in string.split(","))
-
-
 def _parse_symbols(section):
     symbols: str = section.get("symbols")
     symbols = symbols.strip().replace("\n", " ").replace('"""', "")
     if symbols in ["all", "*"]:
         section["symbols"] = symbols
-    elif ":" in symbols:
-        symbols = _strtodict(symbols)
-        section["symbols"] = symbols
-    elif " " in symbols and "," not in symbols:
-        symbols = symbols.split()
-        section["symbols"] = symbols
-    elif "," in symbols:
-        symbols = symbols.replace(" ", "").split(",")
-        section["symbols"] = symbols
     else:
-        raise ValueError("""
-        Invalid symbols format.
-        You can use space or comma separated symbols in one line or multiple lines using triple quotes.
-        You can also use a dictionary to map source symbols to destination symbols as shown below.
-        Or if you want to copy all symbols, use "all" or "*".
-
-        symbols = EURUSD, GBPUSD, USDJPY (space separated)
-        symbols = EURUSD,GBPUSD,USDJPY (comma separated)
-        symbols = EURUSD.s:EURUSD_i, GBPUSD.s:GBPUSD_i, USDJPY.s:USDJPY_i (dictionary) 
-        symbols = all (copy all symbols)
-        symbols = * (copy all symbols) """)
+        symbols = get_symbols_from_string(symbols)
+        section["symbols"] = symbols
 
 
 def config_copier(