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

bbstrader/metatrader/copier.py

@@ -51,6 +51,31 @@ ORDER_TYPE = {
     7: (Mt5.ORDER_TYPE_SELL_STOP_LIMIT, "SELL STOP LIMIT"),
 }
 
+STOP_RETCODES = [
+    Mt5.TRADE_RETCODE_TRADE_DISABLED,
+    Mt5.TRADE_RETCODE_NO_MONEY,
+    Mt5.TRADE_RETCODE_SERVER_DISABLES_AT,
+    Mt5.TRADE_RETCODE_CLIENT_DISABLES_AT,
+    Mt5.TRADE_RETCODE_ONLY_REAL,
+]
+
+RETURN_RETCODE = [
+    Mt5.TRADE_RETCODE_MARKET_CLOSED,
+    Mt5.TRADE_RETCODE_CONNECTION,
+    Mt5.TRADE_RETCODE_LIMIT_ORDERS,
+    Mt5.TRADE_RETCODE_LIMIT_VOLUME,
+    Mt5.TRADE_RETCODE_LIMIT_POSITIONS,
+    Mt5.TRADE_RETCODE_LONG_ONLY,
+    Mt5.TRADE_RETCODE_SHORT_ONLY,
+    Mt5.TRADE_RETCODE_CLOSE_ONLY,
+    Mt5.TRADE_RETCODE_FIFO_CLOSE,
+    Mt5.TRADE_RETCODE_INVALID_VOLUME,
+    Mt5.TRADE_RETCODE_INVALID_PRICE,
+    Mt5.TRADE_RETCODE_INVALID_STOPS,
+    Mt5.TRADE_RETCODE_NO_CHANGES
+]
+
+
 
 class OrderAction(Enum):
     COPY_NEW = "COPY_NEW"
@@ -65,25 +90,23 @@ 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")
+        raise ValueError("Fixed lot must be a number > 0")
     return fixed
 
 
 def multiply_lot(lot, multiplier):
     if multiplier == 0 or multiplier is None:
-        raise ValueError("Multiplier lot must be a number")
+        raise ValueError("Multiplier lot must be a number > 0")
     return lot * multiplier
 
 
 def percentage_lot(lot, percentage):
     if percentage == 0 or percentage is None:
-        raise ValueError("Percentage lot must be a number")
+        raise ValueError("Percentage lot must be a number > 0")
     return round(lot * percentage / 100, 2)
 
 
 def dynamic_lot(source_lot, source_eqty: float, dest_eqty: float):
-    if source_eqty == 0 or dest_eqty == 0:
-        raise ValueError("Source or destination account equity is zero")
     try:
         ratio = dest_eqty / source_eqty
         return round(source_lot * ratio, 2)
@@ -118,6 +141,7 @@ def fixed_lot(lot, symbol, destination) -> float:
     else:
         return _check_lot(round(lot), s_info)
 
+
 def calculate_copy_lot(
     source_lot,
     symbol: str,
@@ -173,7 +197,7 @@ def get_symbols_from_string(symbols_string: str):
 
 def get_copy_symbols(destination: dict, source: dict) -> List[str] | Dict[str, str]:
     symbols = destination.get("symbols", "all")
-    if symbols == "all" or symbols == "*" or  isinstance(symbols, list) :
+    if symbols == "all" or symbols == "*" or isinstance(symbols, list):
         src_account = Account(**source)
         src_symbols = src_account.get_symbols()
         dest_account = Account(**destination)
@@ -360,7 +384,10 @@ class TradeCopier(object):
         for destination in self.destinations:
             destination["copy"] = destination.get("copy", True)
 
-    def log_message(self, message, type="info"):
+    def log_message(
+        self, message, type: Literal["info", "error", "debug", "warning"] = "info"
+    ):
+        logger.trace
         if self.log_queue:
             try:
                 now = datetime.now()
@@ -370,7 +397,7 @@ class TradeCopier(object):
                 )
                 space = len("exception")  # longest log name
                 self.log_queue.put(
-                    f"{formatted} |{type.upper()} {' '*(space - len(type))} | - {message}"
+                    f"{formatted} |{type.upper()} {' ' * (space - len(type))} | - {message}"
                 )
             except Exception:
                 pass
@@ -384,8 +411,8 @@ class TradeCopier(object):
         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}"
+            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):
@@ -487,6 +514,14 @@ class TradeCopier(object):
                 if new_result.retcode == Mt5.TRADE_RETCODE_DONE:
                     break
         return new_result
+    
+    def handle_retcode(self, retcode) -> int:
+        if retcode in STOP_RETCODES:
+            msg = trade_retcode_message(retcode)
+            self.log_error(f"Critical Error on @{self.source['login']}: {msg} ")
+            self.stop()
+        if retcode in RETURN_RETCODE:
+            return 1
 
     def copy_new_trade(self, trade: TradeOrder | TradePosition, destination: dict):
         if not self.iscopy_time():
@@ -508,7 +543,6 @@ class TradeCopier(object):
         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:
@@ -535,14 +569,18 @@ class TradeCopier(object):
             result = Mt5.order_send(request)
             if result.retcode != Mt5.TRADE_RETCODE_DONE:
                 result = self._update_filling_type(request, result)
+            action = ORDER_TYPE[trade.type][1]
+            copy_action = "Position" if trade.type in [0, 1] else "Order"
             if result.retcode == Mt5.TRADE_RETCODE_DONE:
                 self.log_message(
-                    f"Copy {action} Order #{trade.ticket} from @{self.source.get('login')}::{trade.symbol} "
+                    f"Copy {action} {copy_action} #{trade.ticket} from @{self.source.get('login')}::{trade.symbol} "
                     f"to @{destination.get('login')}::{symbol}",
                 )
             if result.retcode != Mt5.TRADE_RETCODE_DONE:
+                if self.handle_retcode(result.retcode) == 1:
+                    return
                 self.log_message(
-                    f"Error copying {action} Order #{trade.ticket} from @{self.source.get('login')}::{trade.symbol} "
+                    f"Error copying {action} {copy_action} #{trade.ticket} from @{self.source.get('login')}::{trade.symbol} "
                     f"to @{destination.get('login')}::{symbol}, {trade_retcode_message(result.retcode)}",
                     type="error",
                 )
@@ -572,9 +610,9 @@ class TradeCopier(object):
                 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_NO_CHANGES:
-            return
         if result.retcode != Mt5.TRADE_RETCODE_DONE:
+            if self.handle_retcode(result.retcode) == 1:
+                    return
             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)}",
@@ -597,6 +635,8 @@ class TradeCopier(object):
                 f"SOURCE=@{self.source.get('login')}::{src_symbol}"
             )
         if result.retcode != Mt5.TRADE_RETCODE_DONE:
+            if self.handle_retcode(result.retcode) == 1:
+                    return
             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)}",
@@ -626,9 +666,9 @@ class TradeCopier(object):
                 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_NO_CHANGES:
-            return
         if result.retcode != Mt5.TRADE_RETCODE_DONE:
+            if self.handle_retcode(result.retcode) == 1:
+                    return
             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)}",
@@ -663,6 +703,8 @@ class TradeCopier(object):
                 f"SOURCE=@{self.source.get('login')}::{src_symbol}"
             )
         if result.retcode != Mt5.TRADE_RETCODE_DONE:
+            if self.handle_retcode(result.retcode) == 1:
+                    return
             self.log_message(
                 f"Error closing {ORDER_TYPE[position.type][1]} Position #{position.ticket} "
                 f"on @{destination.get('login')}::{position.symbol}, "
@@ -1023,7 +1065,8 @@ class TradeCopier(object):
             self.destinations
         ):
             self.log_message(
-                "Two or more destination accounts have the same Terminal path, which is not allowed."
+                "Two or more destination accounts have the same Terminal path, which is not allowed.",
+                type="error",
             )
             return
 
@@ -1134,29 +1177,45 @@ def RunCopier(
     shutdown_event=None,
     log_queue=None,
 ):
-    """Initializes and runs a TradeCopier instance in a single process.
+    """
+    Initialize and run 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.
+    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
+    Use Cases
+    ---------
+    * 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.
+    Parameters
+    ----------
+    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 : logging.Logger, optional
+        An optional custom logger instance.
+    shutdown_event : multiprocessing.Event, optional
+        An event to signal shutdown.
+    log_queue : multiprocessing.Queue, optional
+        A queue for log messages.
+
+    Returns
+    -------
+    None
+        Runs until stopped via ``shutdown_event`` or external interruption.
     """
     copier = TradeCopier(
         source,
@@ -1181,7 +1240,8 @@ def RunMultipleCopier(
     custom_logger=None,
     log_queue=None,
 ):
-    """Manages multiple, independent trade copying sessions in parallel.
+    """
+    Manage 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
@@ -1189,28 +1249,46 @@ def RunMultipleCopier(
     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.
+    process, the destinations for that source are handled sequentially by
+    ``RunCopier``.
+
+    Example
+    -------
+    An example ``accounts`` structure:
+
+    .. code-block:: python
+
+        accounts = [
+            {"source": {...}, "destinations": [{...}, {...}]},  # -> Process 1
+            {"source": {...}, "destinations": [{...}]}          # -> Process 2
+        ]
+
+    Parameters
+    ----------
+    accounts : list of dict
+        A list of account configurations. Each item must be a dictionary with
+        a ``source`` key and a ``destinations`` key.
+    sleeptime : float, optional
+        The sleep time passed down to each ``RunCopier`` process.
+    start_delay : float, optional
+        A delay in seconds between starting each new process.
+        Helps prevent resource contention by staggering the initialization of
+        multiple MetaTrader 5 terminals.
+    start_time : str, optional
+        The start time passed down to each ``RunCopier`` process.
+    end_time : str, optional
+        The end time passed down to each ``RunCopier`` process.
+    shutdown_event : multiprocessing.Event, optional
+        An event to signal shutdown to all child processes.
+    custom_logger : logging.Logger, optional
+        An optional custom logger instance.
+    log_queue : multiprocessing.Queue, optional
+        A queue for aggregating log messages from all child processes.
+
+    Returns
+    -------
+    None
+        Runs until stopped via ``shutdown_event`` or external interruption.
     """
     processes = []
 

bbstrader/metatrader/trade.py

@@ -95,27 +95,16 @@ class TradeSignal:
     """
     Represents a trading signal generated by a trading system or strategy.
 
+    Notes
+    -----
     Attributes:
-        id (int):
-            A unique identifier for the trade signal or the strategy.
 
-        symbol (str):
-            The trading symbol (e.g., stock ticker, forex pair, crypto asset)
-            related to the signal.
-
-        action (TradeAction):
-            The trading action to perform.
-            Must be an instance of the `TradeAction` enum (e.g., BUY, SELL).
-
-        price (float, optional):
-            The price at which the trade should be executed.
-
-        stoplimit (float, optional):
-            A stop-limit price for the trade.
-            Must not be set without specifying a price.
-
-        comment (str, optional):
-            An optional comment or description related to the trade signal.
+    - id (int): A unique identifier for the trade signal or the strategy.
+    - symbol (str): The trading symbol (e.g., stock ticker, forex pair, crypto asset).
+    - action (TradeAction): The trading action to perform. Must be an instance of the ``TradeAction`` enum (e.g., BUY, SELL).
+    - price (float, optional): The price at which the trade should be executed.
+    - stoplimit (float, optional): A stop-limit price for the trade. Must not be set without specifying a price.
+    - comment (str, optional): An optional comment or description related to the trade signal.
     """
 
     id: int
@@ -776,18 +765,19 @@ class Trade(RiskManagement):
         # Check the execution result
         pos = self._order_type()[type][1]
         addtionnal = f", SYMBOL={self.symbol}"
+        result = None
         try:
             self.check_order(request)
             result = self.send_order(request)
         except Exception as e:
-            msg = trade_retcode_message(result.retcode)
+            msg = trade_retcode_message(result.retcode) if result else "N/A"
             LOGGER.error(f"Trade Order Request, {msg}{addtionnal}, {e}")
-        if result.retcode != Mt5.TRADE_RETCODE_DONE:
+        if result and result.retcode != Mt5.TRADE_RETCODE_DONE:
             if result.retcode == Mt5.TRADE_RETCODE_INVALID_FILL:  # 10030
                 for fill in FILLING_TYPE:
                     request["type_filling"] = fill
                     result = self.send_order(request)
-                    if result.retcode == Mt5.TRADE_RETCODE_DONE:
+                    if result and result.retcode == Mt5.TRADE_RETCODE_DONE:
                         break
             elif result.retcode == Mt5.TRADE_RETCODE_INVALID_VOLUME:  # 10014
                 new_volume = int(request["volume"])
@@ -811,13 +801,13 @@ class Trade(RiskManagement):
                         self.check_order(request)
                         result = self.send_order(request)
                     except Exception as e:
-                        msg = trade_retcode_message(result.retcode)
+                        msg = trade_retcode_message(result.retcode) if result else "N/A"
                         LOGGER.error(f"Trade Order Request, {msg}{addtionnal}, {e}")
-                    if result.retcode == Mt5.TRADE_RETCODE_DONE:
+                    if result and result.retcode == Mt5.TRADE_RETCODE_DONE:
                         break
                     tries += 1
         # Print the result
-        if result.retcode == Mt5.TRADE_RETCODE_DONE:
+        if result and result.retcode == Mt5.TRADE_RETCODE_DONE:
             msg = trade_retcode_message(result.retcode)
             LOGGER.info(f"Trade Order {msg}{addtionnal}")
             if type != "BMKT" or type != "SMKT":
@@ -854,7 +844,7 @@ class Trade(RiskManagement):
                             LOGGER.info(pos_info)
             return True
         else:
-            msg = trade_retcode_message(result.retcode)
+            msg = trade_retcode_message(result.retcode) if result else "N/A"
             LOGGER.error(
                 f"Unable to Open Position, RETCODE={result.retcode}: {msg}{addtionnal}"
             )
@@ -1325,14 +1315,15 @@ class Trade(RiskManagement):
             request (dict): The request to set the stop loss to break even.
         """
         addtionnal = f", SYMBOL={self.symbol}"
+        result = None
         time.sleep(0.1)
         try:
             self.check_order(request)
             result = self.send_order(request)
         except Exception as e:
-            msg = trade_retcode_message(result.retcode)
+            msg = trade_retcode_message(result.retcode) if result else "N/A"
             LOGGER.error(f"Break-Even Order Request, {msg}{addtionnal}, Error: {e}")
-        if result.retcode != Mt5.TRADE_RETCODE_DONE:
+        if result and result.retcode != Mt5.TRADE_RETCODE_DONE:
             msg = trade_retcode_message(result.retcode)
             if result.retcode != Mt5.TRADE_RETCODE_NO_CHANGES:
                 LOGGER.error(
@@ -1348,14 +1339,14 @@ class Trade(RiskManagement):
                         self.check_order(request)
                         result = self.send_order(request)
                     except Exception as e:
-                        msg = trade_retcode_message(result.retcode)
+                        msg = trade_retcode_message(result.retcode) if result else "N/A"
                         LOGGER.error(
                             f"Break-Even Order Request, {msg}{addtionnal}, Error: {e}"
                         )
-                    if result.retcode == Mt5.TRADE_RETCODE_DONE:
+                    if result and result.retcode == Mt5.TRADE_RETCODE_DONE:
                         break
                 tries += 1
-        if result.retcode == Mt5.TRADE_RETCODE_DONE:
+        if result and result.retcode == Mt5.TRADE_RETCODE_DONE:
             msg = trade_retcode_message(result.retcode)
             LOGGER.info(f"Break-Even Order {msg}{addtionnal}")
             info = f"Stop loss set to Break-even, Position: #{tiket}, Symbol: {self.symbol}, Price: @{round(price, 5)}"
@@ -1432,15 +1423,17 @@ class Trade(RiskManagement):
         """
         ticket = request[type]
         addtionnal = f", SYMBOL={self.symbol}"
+        result = None
         try:
             self.check_order(request)
             result = self.send_order(request)
         except Exception as e:
-            msg = trade_retcode_message(result.retcode)
+            msg = trade_retcode_message(result.retcode) if result else "N/A"
             LOGGER.error(
-                f"Closing {type.capitalize()} Request, {msg}{addtionnal}, Error: {e}"
+                f"Closing {type.capitalize()} Request, RETCODE={msg}{addtionnal}, Error: {e}"
             )
-        if result.retcode != Mt5.TRADE_RETCODE_DONE:
+
+        if result and result.retcode != Mt5.TRADE_RETCODE_DONE:
             if result.retcode == Mt5.TRADE_RETCODE_INVALID_FILL:  # 10030
                 for fill in FILLING_TYPE:
                     request["type_filling"] = fill
@@ -1462,14 +1455,14 @@ class Trade(RiskManagement):
                         self.check_order(request)
                         result = self.send_order(request)
                     except Exception as e:
-                        msg = trade_retcode_message(result.retcode)
+                        msg = trade_retcode_message(result.retcode) if result else "N/A"
                         LOGGER.error(
                             f"Closing {type.capitalize()} Request, {msg}{addtionnal}, Error: {e}"
                         )
-                    if result.retcode == Mt5.TRADE_RETCODE_DONE:
+                    if result and result.retcode == Mt5.TRADE_RETCODE_DONE:
                         break
                     tries += 1
-        if result.retcode == Mt5.TRADE_RETCODE_DONE:
+        if result and result.retcode == Mt5.TRADE_RETCODE_DONE:
             msg = trade_retcode_message(result.retcode)
             LOGGER.info(f"Closing Order {msg}{addtionnal}")
             info = (
@@ -1504,7 +1497,7 @@ class Trade(RiskManagement):
         orders = self.get_orders(ticket=ticket) or []
         if len(orders) == 0:
             LOGGER.error(
-                f"Order #{ticket} not found, SYMBOL={self.symbol}, PRICE={round(price, 5)}"
+                f"Order #{ticket} not found, SYMBOL={self.symbol}, PRICE={round(price, 5) if price else 'N/A'}"
             )
             return
         order = orders[0]
@@ -1520,8 +1513,8 @@ class Trade(RiskManagement):
         result = self.send_order(request)
         if result.retcode == Mt5.TRADE_RETCODE_DONE:
             LOGGER.info(
-                f"Order #{ticket} modified, SYMBOL={self.symbol}, PRICE={round(price, 5)},"
-                f"SL={round(sl, 5)}, TP={round(tp, 5)}, STOP_LIMIT={round(stoplimit, 5)}"
+                f"Order #{ticket} modified, SYMBOL={self.symbol}, PRICE={round(request['price'], 5)},"
+                f"SL={round(request['sl'], 5)}, TP={round(request['tp'], 5)}, STOP_LIMIT={round(request['stoplimit'], 5)}"
             )
         else:
             msg = trade_retcode_message(result.retcode)
@@ -1835,15 +1828,16 @@ class Trade(RiskManagement):
 
     def sleep_time(self, weekend=False):
         if weekend:
-            # claculate number of minute from the friday and to monday start
-            friday_time = datetime.strptime(self.current_time(), "%H:%M")
+            # calculate number of minute from now and monday start
+            multiplyer = {"friday": 3, "saturday": 2, "sunday": 1}
+            current_time = datetime.strptime(self.current_time(), "%H:%M")
             monday_time = datetime.strptime(self.start, "%H:%M")
-            intra_day_diff = (monday_time - friday_time).total_seconds() // 60
-            inter_day_diff = 3 * 24 * 60
+            intra_day_diff = (monday_time - current_time).total_seconds() // 60
+            inter_day_diff = multiplyer[datetime.now().strftime("%A").lower()] * 24 * 60
             total_minutes = inter_day_diff + intra_day_diff
             return total_minutes
         else:
-            # claculate number of minute from the end to the start
+            # calculate number of minute from the end to the start
             start = datetime.strptime(self.start, "%H:%M")
             end = datetime.strptime(self.current_time(), "%H:%M")
             minutes = (end - start).total_seconds() // 60

bbstrader/metatrader/utils.py

@@ -607,7 +607,8 @@ class AutoTradingDisabled(MT5TerminalError):
 class InternalFailError(MT5TerminalError):
     """Base exception class for internal IPC errors."""
 
-    pass
+    def __init__(self, code, message):
+        super().__init__(code, message)
 
 
 class InternalFailSend(InternalFailError):
@@ -700,9 +701,9 @@ def raise_mt5_error(message: Optional[str] = None):
     """
     if message and isinstance(message, Exception):
         message = str(message)
-    error = _ERROR_CODE_TO_EXCEPTION_.get(MT5.last_error()[0])
-    if error is not None:
-        raise Exception(f"{error(None)} {message or MT5.last_error()[1]}")
+    exception = _ERROR_CODE_TO_EXCEPTION_.get(MT5.last_error()[0])
+    if exception is not None:
+        raise exception(f"{message or MT5.last_error()[1]}")
     else:
         raise Exception(f"{message or MT5.last_error()[1]}")
 

bbstrader/models/factors.py

@@ -1,8 +1,9 @@
 from datetime import datetime
-from typing import Dict, List
+from typing import Dict, List, Literal
 
 import pandas as pd
 import yfinance as yf
+from loguru import logger
 
 from bbstrader.btengine.data import EODHDataHandler, FMPDataHandler
 from bbstrader.metatrader.rates import download_historical_data
@@ -16,6 +17,7 @@ __all__ = [
     "search_coint_candidate_pairs",
 ]
 
+
 def _download_and_process_data(source, tickers, start, end, tf, path, **kwargs):
     """Download and process data for a list of tickers from the specified source."""
     data_list = []
@@ -43,9 +45,7 @@ def _download_and_process_data(source, tickers, start, end, tf, path, **kwargs):
                 )
                 data = data.drop(columns=["adj_close"], axis=1)
             elif source in ["fmp", "eodhd"]:
-                handler_class = (
-                    FMPDataHandler if source == "fmp" else EODHDataHandler
-                )
+                handler_class = FMPDataHandler if source == "fmp" else EODHDataHandler
                 handler = handler_class(events=None, symbol_list=[ticker], **kwargs)
                 data = handler.data[ticker]
             else:
@@ -62,6 +62,7 @@ def _download_and_process_data(source, tickers, start, end, tf, path, **kwargs):
 
     return pd.concat(data_list)
 
+
 def _handle_date_range(start, end, window):
     """Handle start and end date generation."""
     if start is None or end is None:
@@ -73,6 +74,7 @@ def _handle_date_range(start, end, window):
         ).strftime("%Y-%m-%d")
     return start, end
 
+
 def _period_search(start, end, securities, candidates, window, npairs):
     if window < 3 or (pd.Timestamp(end) - pd.Timestamp(start)).days / 365 < 3:
         raise ValueError(
@@ -103,14 +105,11 @@ def _period_search(start, end, securities, candidates, window, npairs):
         )
     return top_pairs.head(npairs * 2)
 
+
 def _process_asset_data(securities, candidates, universe, rolling_window):
     """Process and select assets from the data."""
-    securities = select_assets(
-        securities, n=universe, rolling_window=rolling_window
-    )
-    candidates = select_assets(
-        candidates, n=universe, rolling_window=rolling_window
-    )
+    securities = select_assets(securities, n=universe, rolling_window=rolling_window)
+    candidates = select_assets(candidates, n=universe, rolling_window=rolling_window)
     return securities, candidates
 
 
@@ -121,7 +120,7 @@ def search_coint_candidate_pairs(
     end: str = None,
     period_search: bool = False,
     select: bool = True,
-    source: str = None,
+    source: Literal["yf", "mt5", "fmp", "eodhd"] = None,
     universe: int = 100,
     window: int = 2,
     rolling_window: int = None,
@@ -257,7 +256,9 @@ def search_coint_candidate_pairs(
         if period_search:
             start = securities.index.get_level_values("date").min()
             end = securities.index.get_level_values("date").max()
-            top_pairs = _period_search(start, end, securities, candidates, window, npairs)
+            top_pairs = _period_search(
+                start, end, securities, candidates, window, npairs
+            )
         else:
             top_pairs = find_cointegrated_pairs(
                 securities, candidates, n=npairs, coint=True
@@ -286,6 +287,10 @@ def search_coint_candidate_pairs(
         candidates_data = _download_and_process_data(
             source, candidates, start, end, tf, path, **kwargs
         )
+        if securities_data.empty or candidates_data.empty:
+            logger.error("No data found for candidates and securities")
+            return [] if select else pd.DataFrame()
+
         securities_data = securities_data.set_index(["ticker", "date"])
         candidates_data = candidates_data.set_index(["ticker", "date"])
         securities_data, candidates_data = _process_asset_data(
@@ -305,7 +310,6 @@ def search_coint_candidate_pairs(
             )
         else:
             return top_pairs
-
     else:
         msg = (
             "Invalid input. Either provide securities"