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

bbstrader/metatrader/copier.py

@@ -1,7 +1,10 @@
-import multiprocessing
+import concurrent.futures as cf
+import multiprocessing as mp
 import threading
 import time
 from datetime import datetime
+from enum import Enum
+from multiprocessing.synchronize import Event
 from pathlib import Path
 from typing import Dict, List, Literal, Tuple
 
@@ -9,7 +12,7 @@ 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:
@@ -18,8 +21,14 @@ except ImportError:
     import bbstrader.compat  # noqa: F401
 
 
-__all__ = ["TradeCopier", "RunCopier", "RunMultipleCopier", "config_copier"]
-
+__all__ = [
+    "TradeCopier",
+    "RunCopier",
+    "RunMultipleCopier",
+    "config_copier",
+    "copier_worker_process",
+    "get_symbols_from_string",
+]
 
 log.add(
     f"{BBSTRADER_DIR}/logs/copier.log",
@@ -31,6 +40,29 @@ 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"),
+}
+
+
+class OrderAction(Enum):
+    COPY_NEW = "COPY_NEW"
+    MODIFY = "MODIFY"
+    CLOSE = "CLOSE"
+    SYNC_REMOVE = "SYNC_REMOVE"
+    SYNC_ADD = "SYNC_ADD"
+
+
+CopyMode = Literal["fix", "multiply", "percentage", "dynamic", "replicate"]
+
+
 def fix_lot(fixed):
     if fixed == 0 or fixed is None:
         raise ValueError("Fixed lot must be a number")
@@ -86,15 +118,11 @@ def fixed_lot(lot, symbol, destination) -> float:
     else:
         return _check_lot(round(lot), s_info)
 
-
-Mode = Literal["fix", "multiply", "percentage", "dynamic", "replicate"]
-
-
 def calculate_copy_lot(
     source_lot,
     symbol: str,
     destination: dict,
-    mode: Mode = "dynamic",
+    mode: CopyMode = "dynamic",
     value=None,
     source_eqty: float = None,
     dest_eqty: float = None,
@@ -116,12 +144,39 @@ def calculate_copy_lot(
         raise ValueError("Invalid mode selected")
 
 
-def get_copy_symbols(destination: dict, source: dict):
+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")
-    src_account = Account(**source)
-    dest_account = Account(**destination)
-    if symbols == "all" or symbols == "*":
+    if symbols == "all" or symbols == "*" or  isinstance(symbols, list) :
+        src_account = Account(**source)
         src_symbols = src_account.get_symbols()
+        dest_account = Account(**destination)
         dest_symbols = dest_account.get_symbols()
         for s in src_symbols:
             if s not in dest_symbols:
@@ -129,15 +184,18 @@ def get_copy_symbols(destination: dict, source: dict):
                     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()
+        return get_symbols_from_string(symbols)
+    else:
+        raise ValueError("Invalide symbols provided")
 
 
 class TradeCopier(object):
@@ -151,6 +209,8 @@ class TradeCopier(object):
 
     __slots__ = (
         "source",
+        "source_id",
+        "source_isunique",
         "destinations",
         "errors",
         "sleeptime",
@@ -158,18 +218,30 @@ class TradeCopier(object):
         "end_time",
         "shutdown_event",
         "custom_logger",
+        "log_queue",
+        "_last_session",
+        "_running",
     )
-    shutdown_event: threading.Event
+
+    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,
-        shutdown_event=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.
@@ -185,7 +257,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
@@ -237,20 +314,41 @@ 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 terminate 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.shutdown_event = shutdown_event
+        self.errors = set()
+        self.log_queue = log_queue
         self._add_logger(custom_logger)
+        self._validate_source()
         self._add_copy()
-        self.errors = set()
+        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:
@@ -258,9 +356,57 @@ class TradeCopier(object):
             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"] = True
+            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("exception")  # longest log name
+                self.log_queue.put(
+                    f"{formatted} |{type.upper()} {' '*(space - len(type))} | - {message}"
+                )
+            except Exception:
+                pass
+        else:
+            getattr(logger, type)(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 _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)
@@ -294,7 +440,7 @@ class TradeCopier(object):
         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
@@ -304,7 +450,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
 
@@ -332,14 +478,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)
-        volume = trade.volume if hasattr(trade, "volume") else trade.volume_initial
         symbol = self.get_copy_symbol(trade.symbol, destination)
+        self._select_symbol(symbol, destination)
+
+        volume = trade.volume if hasattr(trade, "volume") else trade.volume_initial
         lot = calculate_copy_lot(
             volume,
             symbol,
@@ -349,53 +505,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
+        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.bid if trade.type == 0 else tick.ask
         try:
-            action = action_type[trade.type]
-        except KeyError:
-            return
-        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,
@@ -405,42 +564,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,
@@ -448,31 +616,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):
@@ -487,7 +678,9 @@ 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, self.source)
         dest_positions = self.destination_positions(destination) or []
@@ -499,7 +692,9 @@ 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, self.source)
         dest_orders = self.destination_orders(destination) or []
@@ -511,177 +706,417 @@ class TradeCopier(object):
         )
         return source_orders, dest_orders
 
-    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]
+    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 _get_new_orders(
+        self, source_orders, destination_orders, destination
+    ) -> List[Tuple]:
+        actions = []
+        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)
+                    actions.append((OrderAction.COPY_NEW, source_order, destination))
+        return actions
+
+    def _get_modified_orders(
+        self, source_orders, destination_orders, destination
+    ) -> List[Tuple]:
+        actions = []
+        dest_order_map = {order.magic: order for order in destination_orders}
 
-    def _copy_modified_orders(self, destination):
-        # Check for modified orders
-        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.isorder_modified(source_order, destination_order):
-                        ticket = destination_order.ticket
-                        symbol = destination_order.symbol
-                        self.modify_order(ticket, symbol, source_order, destination)
-
-    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]
+            magic_id = self._get_magic(source_order.ticket)
+            if magic_id in dest_order_map:
+                destination_order = dest_order_map[magic_id]
+                if self.isorder_modified(source_order, destination_order):
+                    ticket = destination_order.ticket
+                    symbol = destination_order.symbol
+                    actions.append(
+                        (OrderAction.MODIFY, ticket, symbol, source_order, destination)
+                    )
+        return actions
+
+    def _get_closed_orders(
+        self, source_orders, destination_orders, destination
+    ) -> List[Tuple]:
+        actions = []
+        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 = self.get_copy_symbol(
-                    destination_order.symbol, destination, type="source"
-                )
-                self.remove_order(src_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"
+                    )
+                    actions.append(
+                        (OrderAction.CLOSE, src_symbol, destination_order, destination)
+                    )
+        return actions
+
+    def _get_orders_to_sync(
+        self, source_orders, destination_positions, destination
+    ) -> List[Tuple]:
+        actions = []
+        source_order_map = {
+            self._get_magic(order.ticket): order for order in source_orders
+        }
 
-    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
+        for dest_pos in destination_positions:
+            if dest_pos.magic in source_order_map:
+                source_order = source_order_map[dest_pos.magic]
+                actions.append(
+                    (
+                        OrderAction.SYNC_REMOVE,
+                        source_order.symbol,
+                        dest_pos,
+                        destination,
                     )
-                    if what in ["all", "positions"]:
-                        if not self.slippage(source_position, destination):
-                            self.copy_new_position(source_position, destination)
+                )
+                if not self.slippage(source_order, destination):
+                    actions.append((OrderAction.SYNC_ADD, source_order, destination))
+        return actions
+
+    def _execute_order_action(self, action_item: Tuple):
+        action_type, *args = action_item
+        try:
+            if action_type == OrderAction.COPY_NEW:
+                self.copy_new_order(*args)
+            elif action_type == OrderAction.MODIFY:
+                self.modify_order(*args)
+            elif action_type == OrderAction.CLOSE:
+                self.remove_order(*args)
+            elif action_type == OrderAction.SYNC_REMOVE:
+                self.remove_position(*args)
+            elif action_type == OrderAction.SYNC_ADD:
+                self.copy_new_order(*args)
+            else:
+                self.log_message(f"Warning: Unknown action type '{action_type.value}'")
+        except Exception as e:
+            self.log_error(
+                f"Error executing action {action_type.value} with args {args}: {e}"
+            )
 
-    def _sync_orders(self, destination):
-        # Update orders
+    def process_all_orders(self, destination, max_workers=10):
+        source_orders, destination_orders = self.get_orders(destination)
         _, destination_positions = self.get_positions(destination)
-        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:
-                    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")
+        orders_actions = []
+        orders_actions.extend(
+            self._get_new_orders(source_orders, destination_orders, destination)
+        )
+        orders_actions.extend(
+            self._get_modified_orders(source_orders, destination_orders, destination)
+        )
+        orders_actions.extend(
+            self._get_closed_orders(source_orders, destination_orders, destination)
+        )
+        orders_actions.extend(
+            self._get_orders_to_sync(source_orders, destination_positions, destination)
+        )
 
-    def copy_orders(self, destination: dict):
-        what = self._copy_what(destination)
-        if what not in ["all", "orders"]:
+        if not orders_actions:
             return
-        check_mt5_connection(**destination)
-        self._copy_new_orders(destination)
-        self._copy_modified_orders(destination)
-        self._copy_closed_orders(destination)
-        self._sync_positions(what, destination)
-        self._sync_orders(destination)
-
-    def _copy_new_positions(self, destination):
-        source_positions, destination_positions = self.get_positions(destination)
-        # 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 not self.slippage(source_position, destination):
-                    self.copy_new_position(source_position, destination)
-
-    def _copy_modified_positions(self, destination):
-        # Check for modified positions
-        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.isposition_modified(source_position, destination_position):
-                        ticket = destination_position.ticket
-                        symbol = destination_position.symbol
-                        self.modify_position(
-                            ticket, symbol, source_position, destination
+        with cf.ThreadPoolExecutor(max_workers=max_workers) as executor:
+            list(executor.map(self._execute_order_action, orders_actions))
+
+    def _get_new_positions(
+        self, source_positions, destination_positions, destination
+    ) -> List[Tuple]:
+        actions = []
+        dest_ids = {pos.magic for pos in destination_positions}
+        for source_pos in source_positions:
+            if self._get_magic(source_pos.ticket) not in dest_ids:
+                if not self.slippage(source_pos, destination):
+                    actions.append((OrderAction.COPY_NEW, source_pos, destination))
+        return actions
+
+    def _get_modified_positions(
+        self, source_positions, destination_positions, destination
+    ) -> List[Tuple]:
+        actions = []
+        dest_pos_map = {pos.magic: pos for pos in destination_positions}
+
+        for source_pos in source_positions:
+            magic_id = self._get_magic(source_pos.ticket)
+            if magic_id in dest_pos_map:
+                dest_pos = dest_pos_map[magic_id]
+                if self.isposition_modified(source_pos, dest_pos):
+                    actions.append(
+                        (
+                            OrderAction.MODIFY,
+                            dest_pos.ticket,
+                            dest_pos.symbol,
+                            source_pos,
+                            destination,
                         )
+                    )
+        return actions
+
+    def _get_closed_positions(
+        self, source_positions, destination_positions, destination
+    ) -> List[Tuple]:
+        actions = []
+        source_ids = {self._get_magic(pos.ticket) for pos in source_positions}
+        for dest_pos in destination_positions:
+            if dest_pos.magic not in source_ids:
+                if self.source_isunique or self._isvalide_magic(dest_pos.magic):
+                    src_symbol = self.get_copy_symbol(
+                        dest_pos.symbol, destination, type="source"
+                    )
+                    actions.append(
+                        (OrderAction.CLOSE, src_symbol, dest_pos, destination)
+                    )
+        return actions
+
+    def _get_positions_to_sync(
+        self, source_positions, destination_orders, destination
+    ) -> List[Tuple]:
+        actions = []
+        dest_order_map = {order.magic: order for order in destination_orders}
+
+        for source_pos in source_positions:
+            magic_id = self._get_magic(source_pos.ticket)
+            if magic_id in dest_order_map:
+                dest_order = dest_order_map[magic_id]
+                # Action 1: Always remove the corresponding order
+                actions.append(
+                    (
+                        OrderAction.SYNC_REMOVE,
+                        source_pos.symbol,
+                        dest_order,
+                        destination,
+                    )
+                )
 
-    def _copy_closed_position(self, destination):
-        # Check for closed positions
+                # Action 2: Potentially copy a new position
+                if self._copy_what(destination) in ["all", "positions"]:
+                    if not self.slippage(source_pos, destination):
+                        actions.append((OrderAction.SYNC_ADD, source_pos, destination))
+        return actions
+
+    def _execute_position_action(self, action_item: Tuple):
+        """A single worker task that executes one action for either Orders or Positions."""
+        action_type, *args = action_item
+        try:
+            if action_type == OrderAction.COPY_NEW:
+                self.copy_new_position(*args)
+            elif action_type == OrderAction.MODIFY:
+                self.modify_position(*args)
+            elif action_type == OrderAction.CLOSE:
+                self.remove_position(*args)
+            elif action_type == OrderAction.SYNC_REMOVE:
+                self.remove_order(*args)
+            elif action_type == OrderAction.SYNC_ADD:
+                self.copy_new_position(*args)
+            else:
+                self.log_message(f"Warning: Unknown action type '{action_type.value}'")
+        except Exception as e:
+            self.log_error(
+                f"Error executing action {action_type.value} with args {args}: {e}"
+            )
+
+    def process_all_positions(self, destination, max_workers=20):
         source_positions, destination_positions = self.get_positions(destination)
-        source_ids = [pos.ticket for pos in source_positions]
-        for destination_position in destination_positions:
-            if destination_position.magic not in source_ids:
-                src_symbol = self.get_copy_symbol(
-                    destination_position.symbol, destination, type="source"
-                )
-                self.remove_position(src_symbol, destination_position, destination)
+        _, destination_orders = self.get_orders(destination)
+
+        positions_actions = []
+        positions_actions.extend(
+            self._get_new_positions(
+                source_positions, destination_positions, destination
+            )
+        )
+        positions_actions.extend(
+            self._get_modified_positions(
+                source_positions, destination_positions, destination
+            )
+        )
+        positions_actions.extend(
+            self._get_closed_positions(
+                source_positions, destination_positions, destination
+            )
+        )
+        positions_actions.extend(
+            self._get_positions_to_sync(
+                source_positions, destination_orders, destination
+            )
+        )
+
+        if not positions_actions:
+            return
+        with cf.ThreadPoolExecutor(max_workers=max_workers) as executor:
+            list(executor.map(self._execute_position_action, positions_actions))
+
+    def copy_orders(self, destination: dict):
+        if self._copy_what(destination) not in ["all", "orders"]:
+            return
+        check_mt5_connection(**destination)
+        self.process_all_orders(destination)
 
     def copy_positions(self, destination: dict):
-        what = self._copy_what(destination)
-        if what not in ["all", "positions"]:
+        if self._copy_what(destination) not in ["all", "positions"]:
             return
         check_mt5_connection(**destination)
-        self._copy_new_positions(destination)
-        self._copy_modified_positions(destination)
-        self._copy_closed_position(destination)
+        self.process_all_positions(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: copies orders and positions concurrently 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 MetaTrader 5 "
+                f"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:
-            if self.shutdown_event and self.shutdown_event.is_set():
-                logger.info(
-                    "Shutdown event received, stopping Trade Copier gracefully."
-                )
-                break
+        self.log_message(
+            f"Copy process 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 self.shutdown_event and self.shutdown_event.is_set():
-                        break
-                    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)
-
-                if self.shutdown_event and self.shutdown_event.is_set():
-                    logger.info(
-                        "Shutdown event received during destination processing, exiting."
-                    )
-                    break
-
+                self.copy_positions(destination)
+                self.copy_orders(destination)
             except KeyboardInterrupt:
-                logger.info("KeyboardInterrupt received, stopping the Trade Copier ...")
-                if self.shutdown_event:
-                    self.shutdown_event.set()
-                break
+                self.log_message(
+                    "KeyboardInterrupt received, stopping the Trade Copier..."
+                )
+                self.stop()
             except Exception as e:
-                self.log_error(e)
-                if self.shutdown_event and self.shutdown_event.is_set():
-                    logger.error(
-                        "Error occurred after shutdown signaled, exiting loop."
-                    )
-                    break
-
-            # Check shutdown event before sleeping
-            if self.shutdown_event and self.shutdown_event.is_set():
-                logger.info("Shutdown event checked before sleep, exiting.")
-                break
+                self.log_error(f"An error occurred during the sync cycle: {e}")
             time.sleep(self.sleeptime)
-        logger.info("Trade Copier has shut down.")
+
+        self.log_message(
+            f"Process exiting for destination @{destination.get('login')} due to shutdown event."
+        )
+
+    def run(self):
+        """
+        Entry point: Starts a dedicated worker thread for EACH destination account to run concurrently.
+        """
+        self.log_message(
+            f"Main Copier instance starting for source @{self.source.get('login')}."
+        )
+        self.log_message(
+            f"Found {len(self.destinations)} destination accounts to process in parallel."
+        )
+        if len(set([d.get("path") for d in self.destinations])) < len(
+            self.destinations
+        ):
+            self.log_message(
+                "Two or more destination accounts have the same Terminal path, which is not allowed."
+            )
+            return
+
+        worker_threads = []
+
+        for destination in self.destinations:
+            self.log_message(
+                f"Creating worker thread for destination @{destination.get('login')}"
+            )
+            try:
+                thread = threading.Thread(
+                    target=self.start_copy_process,
+                    args=(destination,),
+                    name=f"Worker-{destination.get('login')}",
+                )
+                worker_threads.append(thread)
+                thread.start()
+            except Exception as e:
+                self.log_error(
+                    f"Error executing thread Worker-{destination.get('login')} : {e}"
+                )
+
+        self.log_message(f"All {len(worker_threads)} worker threads have been started.")
+        try:
+            while not self.shutdown_event.is_set():
+                time.sleep(1)
+        except KeyboardInterrupt:
+            self.log_message(
+                "\nKeyboardInterrupt detected by main thread. Initiating shutdown..."
+            )
+        finally:
+            self.stop()
+            self.log_message("Waiting for all worker threads to complete...")
+            for thread in worker_threads:
+                thread.join()
+
+            self.log_message("All worker threads have shut down. Copier exiting.")
+
+    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(
@@ -690,30 +1125,89 @@ def RunCopier(
     sleeptime: float,
     start_time: str,
     end_time: str,
-    shutdown_event=None,
+    /,
     custom_logger=None,
+    shutdown_event=None,
+    log_queue=None,
 ):
+    """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,
-        start_time,
-        end_time,
-        shutdown_event,
-        custom_logger,
+        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:
@@ -724,13 +1218,13 @@ 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,
@@ -739,7 +1233,11 @@ def RunMultipleCopier(
                 start_time,
                 end_time,
             ),
-            kwargs=dict(shutdown_event=shutdown_event, custom_logger=custom_logger),
+            kwargs=dict(
+                custom_logger=custom_logger,
+                shutdown_event=shutdown_event,
+                log_queue=log_queue,
+            ),
         )
         processes.append(process)
         process.start()
@@ -751,39 +1249,14 @@ def RunMultipleCopier(
         process.join()
 
 
-def _strtodict(string: str) -> dict:
-    string = string.strip().replace("\n", "").replace(" ", "").replace('"""', "")
-    if string.endswith(","):
-        string = string[:-1]
-    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(