PythonMetaTrader5 1.0.8__py3-none-any.whl → 2.0__py3-none-any.whl

PythonMetaTrader5/__init__.py

@@ -1,57 +1,77 @@
-# internal order send
 import time
 from MetaTrader5 import *
-import colorama
+from loguru import logger
+import pyautogui
 
-colorama.init()
-
-def SpacerStart():
-    print(colorama.Style.RESET_ALL + "//////////////////////////////")
-
-def SpacerEnd():
-    print(colorama.Style.RESET_ALL + "//////////////////////////////")
-    print()
 
 class Broker:
-    RetCodes = {10027: "Enable Algo Trading in MetaTrader5 app", 10018: "Market closed", 10016: "Wrong SL"}
+    RetCodes = {
+        10027: "Enable Algo Trading in MetaTrader5 app",
+        10018: "Market closed",
+        10016: "Wrong SL",
+    }
+
     log = None
     password = None
     server = None
+
     def __init__(self, log, password, server):
+        self.log = log
+        self.password = str(password)
+        self.server = str(server)
+
         initialize()
-        if login(log, str(password), server=str(server)):
-            print(colorama.Fore.GREEN + "Login succes")
+        if login(self.log, self.password, server=self.server):
+            logger.success("Login succes")
             acc_info = account_info()
-            print(colorama.Style.RESET_ALL + str(acc_info))
-            self.log = log
-            self.password = str(password)
-            self.server = str(server)
-
+            logger.info(str(acc_info))
         else:
-            print(colorama.Fore.RED + "Login failed: ", str(self.log))
+            logger.error(f"Login failed: {self.log}")
 
-    def login(self, ToEffect = False):
+    def login(self, ToEffect=False):
         while True:
-            print(colorama.Fore.YELLOW + "Login on: ", str(self.log))
-            print(self.log)
+            logger.info(f"Login on: {self.log}")
             if login(self.log, self.password, server=self.server):
-                print(colorama.Fore.GREEN + "OK")
+                logger.success("OK")
                 time.sleep(0.5)
                 return True
-            if ToEffect==False:
-                print(colorama.Fore.RED + "ERROR")
+            if ToEffect is False:
+                logger.error("ERROR")
                 return False
 
+    # -------------------- Symbol meta & normalization --------------------
+
+    def _symbol_meta(self, symbol):
+        """
+        Returns (point, digits).
+        point  -> minimal price step (MT5)
+        digits -> number of decimal places
+        """
+        info = symbol_info(symbol)
+        if info is None:
+            logger.error(f"{self.log}: symbol_info({symbol}) returned None")
+            return None, None
+        point = float(info.point)
+        digits = int(info.digits)
+        return point, digits
+
+    def _normalize(self, price, digits):
+        if price is None:
+            return None
+        step = 10 ** (-digits)
+        return round(float(price) / step) * step
+
+    # -------------------- Low-level senders --------------------
 
     def _RawOrderClose(self, order_type, symbol, volume, price, comment=None, ticket=None):
         order = {
             "action": TRADE_ACTION_DEAL,
             "symbol": symbol,
-            "volume": volume,
+            "volume": float(volume),
             "type": order_type,
-            "price": price,
+            "price": float(price),
             "deviation": 10,
-            "type_filling": ORDER_FILLING_IOC
+            "type_filling": ORDER_FILLING_IOC,
         }
         if comment is not None:
             order["comment"] = comment
@@ -59,9 +79,17 @@ class Broker:
             order["position"] = ticket
         return order_send(order)
 
-
-    def _RawOrder(self, order_type, symbol, volume, price, sl=None, comment=None, ticket=None):
+    def _RawOrder(self, order_type, symbol, volume, price, sl=None, tp=None, comment=None, ticket=None):
         volume = float(volume)
+
+        # normalize prices to instrument digits before sending
+        info = symbol_info(symbol)
+        if info:
+            digits = int(info.digits)
+            price = self._normalize(price, digits)
+            sl = self._normalize(sl, digits) if sl is not None else None
+            tp = self._normalize(tp, digits) if tp is not None else None
+
         order = {
             "action": TRADE_ACTION_DEAL,
             "symbol": symbol,
@@ -69,362 +97,439 @@ class Broker:
             "type": order_type,
             "price": price,
             "deviation": 10,
-            "type_filling": ORDER_FILLING_IOC
+            "type_filling": ORDER_FILLING_FOK,
         }
         if comment is not None:
             order["comment"] = comment
         if ticket is not None:
             order["position"] = ticket
-
         if sl is not None:
-            sl = float(sl)
-            order["sl"] = sl
-
+            order["sl"] = float(sl)
+        if tp is not None:
+            order["tp"] = float(tp)
         return order_send(order)
 
-
     def _RawOrderLimit(self, order_type, symbol, volume, price, limit, comment=None, ticket=None):
-        limit = float(limit)
-        volume = float(volume)
+        # MT5 uses 'price' for the pending level; keep signature consistent
+        info = symbol_info(symbol)
+        digits = int(info.digits) if info else 5
+        limit = self._normalize(limit, digits)
+
         order = {
             "action": TRADE_ACTION_PENDING,
             "symbol": symbol,
-            "volume": volume,
+            "volume": float(volume),
             "type": order_type,
-            "price": limit,
+            "price": float(limit),
             "deviation": 10,
-            "type_filling": ORDER_FILLING_IOC
+            "type_filling": ORDER_FILLING_IOC,
         }
         if comment is not None:
             order["comment"] = comment
         if ticket is not None:
             order["position"] = ticket
-
         return order_send(order)
 
-    # Close all specific orders
+    # -------------------- Positions I/O --------------------
+
+    def _pos_to_dict(self, p):
+        """Serialize MT5 position to a dict (for as_dict=True)."""
+        if p is None:
+            return None
+        return {
+            "ticket": p.ticket,
+            "symbol": p.symbol,
+            "type": p.type,                 # ORDER_TYPE_BUY / ORDER_TYPE_SELL
+            "volume": float(p.volume),
+            "price_open": float(p.price_open),
+            "sl": float(p.sl) if p.sl else None,
+            "tp": float(p.tp) if p.tp else None,
+            "price_current": float(p.price_current),
+            "profit": float(p.profit),
+            "time": int(p.time),            # epoch
+            "magic": int(p.magic),
+            "comment": p.comment,
+        }
+
+    # -------------------- Positions by symbol --------------------
+
+    def GetPositionsBySymbol(self, symbol: str, as_dict: bool = False):
+        """
+        Return all open positions for the given symbol.
+        If as_dict=True -> list of dictionaries.
+        """
+        try:
+            positions = positions_get(symbol=symbol)
+        except Exception as e:
+            logger.error(f"{self.log}: GetPositionsBySymbol exception: {e}")
+            return []
+
+        positions = list(positions) if positions else []
+        if as_dict:
+            return [self._pos_to_dict(p) for p in positions]
+        return positions
+
+    def GetPositions(self, symbol=None, *, ticket=None, as_dict: bool = False):
+        """
+        Return positions with the same filtering semantics as Close():
+        - if ticket is provided -> only that position
+        - elif symbol is provided -> all positions for that symbol
+        - else -> all open positions
+        """
+        try:
+            if ticket is not None:
+                pos = positions_get(ticket=ticket)
+            elif symbol is not None:
+                pos = positions_get(symbol=symbol)
+            else:
+                pos = positions_get()
+        except Exception as e:
+            logger.error(f"{self.log}: GetPositions exception: {e}")
+            return []
+
+        pos = list(pos) if pos else []
+        if as_dict:
+            return [self._pos_to_dict(p) for p in pos]
+        return pos
+
+    def GetPosition(self, symbol=None, *, ticket=None, as_dict: bool = False):
+        """
+        Return the first matching position or None.
+        Convenient when you expect at most one.
+        """
+        pos_list = self.GetPositions(symbol=symbol, ticket=ticket, as_dict=False)
+        if not pos_list:
+            return None if not as_dict else None
+        return self._pos_to_dict(pos_list[0]) if as_dict else pos_list[0]
+
+    # -------------------- SL/TP computation: absolute or offset IN POINTS --------------------
+
+    def _compute_sl_tp(self, order_type, symbol, sl, tp, sl_type: str, tp_type: str):
+        """
+        Return (sl_val, tp_val) as absolute prices.
+        - 'absolute' -> values are prices (e.g., 1.12345), only normalized
+        - 'offset'   -> values are POINTS away from the current price:
+                        BUY : SL = ask - |sl|*point,  TP = ask + |tp|*point
+                        SELL: SL = bid + |sl|*point,  TP = bid - |tp|*point
+        """
+        sl_val = float(sl) if sl is not None else None
+        tp_val = float(tp) if tp is not None else None
+        sl_type = (sl_type or "absolute").lower()
+        tp_type = (tp_type or "absolute").lower()
+
+        info_tick = symbol_info_tick(symbol)
+        if info_tick is None:
+            logger.error(f"{self.log}: symbol_info_tick({symbol}) returned None (SL/TP compute)")
+            return None, None
+
+        point, digits = self._symbol_meta(symbol)
+        if point is None:
+            return None, None
+
+        is_buy = (order_type == ORDER_TYPE_BUY)
+        ref_price = info_tick.ask if is_buy else info_tick.bid
+
+        if sl_val is not None:
+            if sl_type == "absolute":
+                pass
+            elif sl_type == "offset":
+                sl_val = ref_price - abs(sl_val) * point if is_buy else ref_price + abs(sl_val) * point
+            else:
+                logger.error(f"{self.log}: invalid sl_type '{sl_type}' (use 'absolute'|'offset')")
+                return None, None
+
+        if tp_val is not None:
+            if tp_type == "absolute":
+                pass
+            elif tp_type == "offset":
+                tp_val = ref_price + abs(tp_val) * point if is_buy else ref_price - abs(tp_val) * point
+            else:
+                logger.error(f"{self.log}: invalid tp_type '{tp_type}' (use 'absolute'|'offset')")
+                return None, None
+
+        sl_val = self._normalize(sl_val, digits) if sl_val is not None else None
+        tp_val = self._normalize(tp_val, digits) if tp_val is not None else None
+        return sl_val, tp_val
+
+    # -------------------- Single market-entry function --------------------
+
+    def OpenPosition(
+        self,
+        symbol,
+        side,
+        volume,
+        *,
+        sl=None,
+        tp=None,
+        price=None,
+        comment=None,
+        ticket=None,
+        sl_type: str = "absolute",  # 'absolute' (price) or 'offset' (POINTS)
+        tp_type: str = "absolute",  # 'absolute' (price) or 'offset' (POINTS)
+    ):
+        """
+        Open a market position.
+        side: "buy"/"sell" (also accepts "long"/"short")
+        SL/TP:
+          - sl_type/tp_type == 'absolute': pass absolute prices
+          - sl_type/tp_type == 'offset'  : pass POINTS from current price
+        price: if None -> use current ask/bid and retry on known transient errors
+        """
+        side = str(side).lower()
+        if side not in ("buy", "sell", "long", "short"):
+            logger.error(f"{self.log}: invalid side '{side}' (use 'buy'/'sell')")
+            return None
+
+        order_type = ORDER_TYPE_BUY if side in ("buy", "long") else ORDER_TYPE_SELL
+
+        sl_val, tp_val = self._compute_sl_tp(order_type, symbol, sl, tp, sl_type, tp_type)
+
+        # direct-price mode
+        if price is not None:
+            return self._RawOrder(order_type, symbol, volume, price, sl_val, tp_val, comment, ticket)
+
+        # current-tick mode with retries
+        while True:
+            info = symbol_info_tick(symbol)
+            if info is None:
+                logger.error(f"{self.log}: symbol_info_tick({symbol}) returned None")
+                return None
+
+            curr_price = info.ask if order_type == ORDER_TYPE_BUY else info.bid
+            r = self._RawOrder(order_type, symbol, volume, curr_price, sl_val, tp_val, comment, ticket)
+
+            if r is None:
+                logger.error(f"{self.log}: order_send returned None")
+                return None
+
+            if r.retcode == TRADE_RETCODE_DONE or r.retcode == 10009:
+                action = "long" if order_type == ORDER_TYPE_BUY else "short"
+                details = []
+                if sl_val is not None:
+                    details.append(f"SL {sl_val}")
+                if tp_val is not None:
+                    details.append(f"TP {tp_val}")
+                suffix = f" ({', '.join(details)})" if details else ""
+                logger.success(f"{self.log}: {action} {symbol}{suffix}")
+                return r
+
+            if r.retcode in self.RetCodes:
+                action = "long" if order_type == ORDER_TYPE_BUY else "short"
+                logger.error(f"ERROR CAN NOT OPEN {self.log}: {action} {symbol}")
+                logger.error(self.RetCodes[r.retcode])
+                if r.retcode == 10027:
+                    logger.info(f"Enabling algotrading {self.log} {symbol}")
+                    time.sleep(1)
+                    pyautogui.hotkey("ctrl", "e")
+                if r.retcode == 10016:
+                    return r
+                time.sleep(0.5)
+            else:
+                action = "long" if order_type == ORDER_TYPE_BUY else "short"
+                logger.error(f"ERROR CAN NOT OPEN TRYING AGAIN {self.log}: {action} {symbol}")
+                logger.info(f"RetCode: {r.retcode}")
+                logger.info(f"Comment: {r.comment}")
+                time.sleep(0.5)
+
+    # -------------------- Backward-compat wrappers --------------------
+
+    def Buy(self, symbol, volume, price=None, *, comment=None, ticket=None):
+        return self.OpenPosition(symbol, "buy", volume, price=price, comment=comment, ticket=ticket)
+
+    def BuySL(self, symbol, volume, sl, price=None, *, comment=None, ticket=None, sl_type: str = "absolute"):
+        return self.OpenPosition(
+            symbol, "buy", volume, sl=sl, price=price, comment=comment, ticket=ticket, sl_type=sl_type
+        )
+
+    def Sell(self, symbol, volume, price=None, *, comment=None, ticket=None):
+        return self.OpenPosition(symbol, "sell", volume, price=price, comment=comment, ticket=ticket)
+
+    def SellSL(self, symbol, volume, sl, price=None, *, comment=None, ticket=None, sl_type: str = "absolute"):
+        return self.OpenPosition(
+            symbol, "sell", volume, sl=sl, price=price, comment=comment, ticket=ticket, sl_type=sl_type
+        )
+
+    # -------------------- Closing logic --------------------
+
     def Close(self, symbol, *, comment=None, ticket=None):
         close = False
         if ticket is not None:
             positions = positions_get(ticket=ticket)
         else:
             positions = positions_get(symbol=symbol)
-        tried = 0
-        done = 0
+
         lenpositions = len(positions)
         if positions:
             while True:
                 for pos in positions:
-                    # process only simple buy, sell, without limit or stop
                     if pos.type == ORDER_TYPE_BUY or pos.type == ORDER_TYPE_SELL:
-                        tried += 1
-                        for tries in range(10):
+                        for _ in range(10):
                             info = symbol_info_tick(symbol)
                             if info is None:
                                 return None
                             if pos.type == ORDER_TYPE_BUY:
-                                r = self._RawOrderClose(ORDER_TYPE_SELL, symbol, pos.volume, info.bid, comment, pos.ticket)
+                                r = self._RawOrderClose(
+                                    ORDER_TYPE_SELL, symbol, pos.volume, info.bid, comment, pos.ticket
+                                )
                                 close = True
                             else:
-                                r = self._RawOrderClose(ORDER_TYPE_BUY, symbol, pos.volume, info.ask, comment, pos.ticket)
+                                r = self._RawOrderClose(
+                                    ORDER_TYPE_BUY, symbol, pos.volume, info.ask, comment, pos.ticket
+                                )
                                 close = True
-                            # check results
                             if r is None:
                                 return None
                             if r.retcode != TRADE_RETCODE_REQUOTE and r.retcode != TRADE_RETCODE_PRICE_OFF:
                                 if r.retcode == TRADE_RETCODE_DONE:
-                                    SpacerStart()
-                                    print(colorama.Fore.BLUE + str(self.log), ": closing all ", symbol)
-                                    SpacerEnd()
-                                    done += 1
+                                    logger.info(f"{self.log}: closing all {symbol}")
                                     lenpositions -= 1
                                     break
                         if r.retcode in self.RetCodes:
-                            print(colorama.Fore.RED + "ERROR CAN NOT CLOSE", str(self.log), symbol)
-                            print(self.RetCodes[r.retcode])
-                            print(colorama.Style.RESET_ALL)
+                            logger.error(f"ERROR CAN NOT CLOSE {self.log} {symbol}")
+                            logger.error(self.RetCodes[r.retcode])
                             time.sleep(0.5)
-                if not(lenpositions) or r.retcode == 10027:
+                if not lenpositions:
                     break
+                if r.retcode == 10027:
+                    logger.info(f"Enabling algotrading {self.log} {symbol}")
+                    time.sleep(1)
+                    pyautogui.hotkey("ctrl", "e")
 
         if not close:
-            SpacerStart()
-            print(str(self.log), ": there is no orders to close")
-            SpacerEnd()
+            logger.info(f"{self.log}: there is no orders to close")
         return False
 
-
-    # Buy order
-    def Buy(self, symbol, volume, price=None, *, comment=None, ticket=None):
-        # with direct call
-        if price is not None:
-            return self._RawOrder(ORDER_TYPE_BUY, symbol, volume, price, comment, ticket)
-        # no price, we try several times with current price
-        while True:
-            info = symbol_info_tick(symbol)
-            r = r = self._RawOrder(ORDER_TYPE_BUY, symbol, volume, info.ask, comment, ticket)
-            if r.retcode  == 10009:
-                SpacerStart()
-                print(colorama.Fore.GREEN + str(self.log), ": long ", symbol)
-                SpacerEnd()
-                break
-
-            else:
-                if r.retcode in self.RetCodes:
-                    print(colorama.Fore.RED + "ERROR CAN NOT OPEN", str(self.log), ": long ", symbol)
-                    print(self.RetCodes[r.retcode])
-                    print(colorama.Style.RESET_ALL)
-                    if r.retcode == 10027:
-                        break
-                    time.sleep(0.5)
-
-
-                else:
-                    print(colorama.Fore.RED + "ERROR CAN NOT OPEN TRYING AGAIN", str(self.log), ": long ", symbol)
-                    print("RetCode: ", r.retcode)
-                    print("Comment: ", r.comment)
-                    print(colorama.Style.RESET_ALL)
-                    time.sleep(0.5)
-
-
-    def BuySL(self, symbol, volume, sl, price=None, *, comment=None, ticket=None):
-        # with direct call
-        if price is not None:
-            return self._RawOrder(ORDER_TYPE_BUY, symbol, volume, price, sl, comment, ticket)
-        # no price, we try several times with current price
-        while True:
-            info = symbol_info_tick(symbol)
-            r = self._RawOrder(ORDER_TYPE_BUY, symbol, volume, info.ask, sl, comment, ticket)
-            if r.retcode  == 10009:
-                SpacerStart()
-                print(colorama.Fore.GREEN + str(self.log), ": long ", symbol, "sl: ", sl)
-                SpacerEnd()
-                break
-
-            else:
-                if r.retcode in self.RetCodes:
-                    print(colorama.Fore.RED + "ERROR CAN NOT OPEN", str(self.log), ": long ", symbol)
-                    print(self.RetCodes[r.retcode])
-                    print(colorama.Style.RESET_ALL)
-                    if r.retcode == 10027 or r.retcode == 10016:
-                        break
-                    time.sleep(0.5)
-
-
-                else:
-                    print(colorama.Fore.RED + "ERROR CAN NOT OPEN TRYING AGAIN", str(self.log), ": long ", symbol)
-                    print("RetCode: ", r.retcode)
-                    print("Comment: ", r.comment)
-                    print(colorama.Style.RESET_ALL)
-                    time.sleep(0.5)
-        return r
-
-
-    # Sell order
-    def Sell(self, symbol, volume, price=None, *, comment=None, ticket=None):
-        # with direct call
-        if price is not None:
-            return self._RawOrder(ORDER_TYPE_SELL, symbol, volume, price, comment, ticket)
-        # no price, we try several times with current price
-        while True:
-            info = symbol_info_tick(symbol)
-            r = self._RawOrder(ORDER_TYPE_SELL, symbol, volume, info.bid, comment, ticket)
-            if r.retcode  == 10009:
-                SpacerStart()
-                print(colorama.Fore.RED + str(self.log), ": short ", symbol)
-                SpacerEnd()
-                break
-
-            else:
-                if r.retcode in self.RetCodes:
-                    print(colorama.Fore.RED + "ERROR CAN NOT OPEN", str(self.log), " short ", symbol)
-                    print(self.RetCodes[r.retcode])
-                    print(colorama.Style.RESET_ALL)
-                    if r.retcode == 10027:
-                        break
-                    time.sleep(0.5)
-
-
-                else:
-                    print(colorama.Fore.RED + "ERROR CAN NOT OPEN TRYING AGAIN", str(self.log), ": short ", symbol)
-                    print("RetCode: ", r.retcode)
-                    print("Comment: ", r.comment)
-                    print(colorama.Style.RESET_ALL)
-                    time.sleep(0.5)
-
-
-    def SellSL(self, symbol, volume, sl, price=None, *, comment=None, ticket=None):
-
-        # with direct call
-        if price is not None:
-            return self._RawOrder(ORDER_TYPE_SELL, symbol, volume, price, float(sl), comment, ticket)
-        # no price, we try several times with current price
-        while True:
-            info = symbol_info_tick(symbol)
-            r = self._RawOrder(ORDER_TYPE_SELL, symbol, volume, info.bid, float(sl), comment, ticket)
-            if r.retcode  == 10009:
-                SpacerStart()
-                print(colorama.Fore.RED + str(self.log), ": short ", symbol, " sl ", sl)
-                SpacerEnd()
-                break
-
-            else:
-                if r.retcode in self.RetCodes:
-                    print(colorama.Fore.RED + "ERROR CAN NOT OPEN", str(self.log), " short ", symbol, " sl ", sl)
-                    print(self.RetCodes[r.retcode])
-                    print(colorama.Style.RESET_ALL)
-                    if r.retcode == 10027 or r.retcode == 10016:
-                        break
-                    time.sleep(0.5)
-
-
-                else:
-                    print(colorama.Fore.RED + "ERROR CAN NOT OPEN TRYING AGAIN", str(self.log), ": short ", symbol, " sl ", sl)
-                    print("RetCode: ", r.retcode)
-                    print("Comment: ", r.comment)
-                    print(colorama.Style.RESET_ALL)
-                    time.sleep(0.5)
-
-        return r
-
+    # -------------------- Pending orders --------------------
 
     def SellLimit(self, symbol, volume, stoplimit, price=None, comment=None, ticket=None):
         OpenedInstantly = False
-
         if price is not None:
-            return print("Price have to be none")
-        # no price, we try several times with current price
+            logger.error("Price have to be none")
+            return
+
         while True:
             info = symbol_info_tick(symbol)
-
-            if (float(info.bid) >= float(stoplimit)):
-                r = self._RawOrder(ORDER_TYPE_SELL, symbol, float(volume), info.bid, comment, ticket)
-
+            if float(info.bid) >= float(stoplimit):
+                r = self._RawOrder(ORDER_TYPE_SELL, symbol, float(volume), info.bid, comment=comment, ticket=ticket)
                 OpenedInstantly = True
             else:
-                r = self._RawOrderLimit(ORDER_TYPE_SELL_LIMIT, symbol, float(volume), info.bid, float(stoplimit),
-                                        comment,
-                                        ticket)
+                r = self._RawOrderLimit(
+                    ORDER_TYPE_SELL_LIMIT, symbol, float(volume), info.bid, float(stoplimit), comment, ticket
+                )
                 OpenedInstantly = False
 
-            if r.retcode  == 10009:
+            if r.retcode == 10009:
                 if OpenedInstantly:
-                    SpacerStart()
-                    print(colorama.Fore.RED + str(self.log), ": opened short on: ", symbol,
-                          "beacues of ask is > or = limit price")
-                    SpacerEnd()
+                    logger.success(f"{self.log}: opened short on: {symbol} beacues of ask is > or = limit price")
                 else:
-                    SpacerStart()
-                    print(colorama.Fore.RED + str(self.log), ": opened short limit on: ", symbol, " price: ", stoplimit)
-                    SpacerEnd()
+                    logger.success(f"{self.log}: opened short limit on: {symbol}  price: {stoplimit}")
                 break
-
             else:
                 if r.retcode in self.RetCodes:
-                    print(colorama.Fore.RED + "ERROR CAN NOT OPEN", str(self.log), " sell limit on: ", symbol, " price: ", stoplimit)
-                    print(self.RetCodes[r.retcode])
-                    print(colorama.Style.RESET_ALL)
+                    logger.error(f"ERROR CAN NOT OPEN {self.log}  sell limit on: {symbol}  price: {stoplimit}")
+                    logger.error(self.RetCodes[r.retcode])
                     if r.retcode == 10027:
-                        break
+                        logger.info(f"Enabling algotrading {self.log} {symbol}")
+                        time.sleep(1)
+                        pyautogui.hotkey("ctrl", "e")
                     time.sleep(0.5)
-
                 else:
-                    print(colorama.Fore.RED + "ERROR CAN NOT OPEN TRYING AGAIN", str(self.log), " sell limit on: ", symbol, " price: ", stoplimit)
-                    print("RetCode: ", r.retcode)
-                    print("Comment: ", r.comment)
-                    print(colorama.Style.RESET_ALL)
+                    logger.error(
+                        f"ERROR CAN NOT OPEN TRYING AGAIN {self.log}  sell limit on: {symbol}  price: {stoplimit}"
+                    )
+                    logger.info(f"RetCode: {r.retcode}")
+                    logger.info(f"Comment: {r.comment}")
                     time.sleep(0.5)
         return r
 
-
     def BuyLimit(self, symbol, volume, stoplimit, price=None, comment=None, ticket=None):
         OpenedInstantly = False
         if price is not None:
-            return print("Price have to be none")
-        # no price, we try several times with current price
+            logger.error("Price have to be none")
+            return
+
         while True:
             info = symbol_info_tick(symbol)
-
-            if (float(info.ask) <= float(stoplimit)):
-                r = self._RawOrder(ORDER_TYPE_BUY, symbol, float(volume), info.ask, comment, ticket)
+            if float(info.ask) <= float(stoplimit):
+                r = self._RawOrder(ORDER_TYPE_BUY, symbol, float(volume), info.ask, comment=comment, ticket=ticket)
                 OpenedInstantly = True
             else:
-                r = self._RawOrderLimit(ORDER_TYPE_BUY_LIMIT, symbol, float(volume), info.ask, float(stoplimit), comment, ticket)
+                r = self._RawOrderLimit(
+                    ORDER_TYPE_BUY_LIMIT, symbol, float(volume), info.ask, float(stoplimit), comment, ticket
+                )
                 OpenedInstantly = False
 
-            if r.retcode  == 10009:
+            if r.retcode == 10009:
                 if OpenedInstantly:
-                    SpacerStart()
-                    print(colorama.Fore.GREEN + str(self.log), ": opened long on: ", symbol, "beacues of ask is < or = limit price")
-                    SpacerEnd()
+                    logger.success(f"{self.log}: opened long on: {symbol} beacues of ask is < or = limit price")
                 else:
-                    SpacerStart()
-                    print(colorama.Fore.GREEN + str(self.log), ": opened long limit on: ", symbol, " price: ", stoplimit)
-                    SpacerEnd()
+                    logger.success(f"{self.log}: opened long limit on: {symbol}  price: {stoplimit}")
                 break
-
             else:
                 if r.retcode in self.RetCodes:
-                    print(colorama.Fore.RED + "ERROR CAN NOT OPEN", str(self.log), " long limit on: ", symbol, " price: ", stoplimit)
-                    print(self.RetCodes[r.retcode])
-                    print(colorama.Style.RESET_ALL)
+                    logger.error(f"ERROR CAN NOT OPEN {self.log}  long limit on: {symbol}  price: {stoplimit}")
+                    logger.error(self.RetCodes[r.retcode])
                     if r.retcode == 10027:
-                        break
+                        logger.info(f"Enabling algotrading {self.log} {symbol}")
+                        time.sleep(1)
+                        pyautogui.hotkey("ctrl", "e")
                     time.sleep(0.5)
-
-
                 else:
-                    print(colorama.Fore.RED + "ERROR CAN NOT OPEN TRYING AGAIN", str(self.log), " long limit on: ", symbol, " price: ", stoplimit)
-                    print("RetCode: ", r.retcode)
-                    print("Comment: ", r.comment)
-                    print(colorama.Style.RESET_ALL)
+                    logger.error(
+                        f"ERROR CAN NOT OPEN TRYING AGAIN {self.log}  long limit on: {symbol}  price: {stoplimit}"
+                    )
+                    logger.info(f"RetCode: {r.retcode}")
+                    logger.info(f"Comment: {r.comment}")
                     time.sleep(0.5)
         return r
 
+    # -------------------- Cancel pending orders --------------------
 
     def _RawCancelOrder(self, order_number):
-        # Create the request
         request = {
             "action": TRADE_ACTION_REMOVE,
             "order": order_number,
-            "comment": "Order Removed"
+            "comment": "Order Removed",
         }
-        # Send order to MT5
-        order_result = order_send(request)
-        return order_result
-
+        return order_send(request)
 
     def CancelOrders(self, symbol):
-        cancel = False
         orders = orders_get()
-        limit_orders = [order for order in orders if
-                        order.type == ORDER_TYPE_BUY_LIMIT or order.type == ORDER_TYPE_SELL_LIMIT]
+        limit_orders = [
+            order
+            for order in orders
+            if order.type == ORDER_TYPE_BUY_LIMIT or order.type == ORDER_TYPE_SELL_LIMIT
+        ]
         lenpositions = len(limit_orders)
+
         while True:
+            r = None
             for order in limit_orders:
                 if order.symbol == symbol:
-                    cancel = True
                     r = self._RawCancelOrder(order.ticket)
 
                     if r.retcode != TRADE_RETCODE_REQUOTE and r.retcode != TRADE_RETCODE_PRICE_OFF:
                         if r.retcode == TRADE_RETCODE_DONE:
-                            SpacerStart()
-                            print(colorama.Fore.BLUE + str(self.log), ": order have been just cancelled on: ", symbol)
-                            SpacerEnd()
+                            logger.info(f"{self.log}: order have been just cancelled on: {symbol}")
                             lenpositions -= 1
                             break
-                if r.retcode in self.RetCodes:
-                    print(colorama.Fore.RED + "ERROR CAN NOT CLOSE", str(self.log), symbol)
-                    print(self.RetCodes[r.retcode])
-                    print(colorama.Style.RESET_ALL)
-                    time.sleep(0.5)
+                    if r.retcode in self.RetCodes:
+                        logger.error(f"ERROR CAN NOT CLOSE {self.log} {symbol}")
+                        logger.error(self.RetCodes[r.retcode])
+                        time.sleep(0.5)
 
-            if not lenpositions or r.retcode == 10027:
+            if not lenpositions:
                 break
+            if r is not None and r.retcode == 10027:
+                logger.info(f"Enabling algotrading {self.log} {symbol}")
+                time.sleep(1)
+                pyautogui.hotkey("ctrl", "e")
 
         if not len(limit_orders):
-            SpacerStart()
-            print(str(self.log), ": there is no orders to cancel")
-            SpacerEnd()
+            logger.info(f"{self.log}: there is no orders to cancel")
+
+    # -------------------- Disconnect --------------------
+
     def Disconnect(self):
         shutdown()
+        logger.info("Disconnected from MT5")

pythonmetatrader5-2.0.dist-info/METADATA

@@ -0,0 +1,25 @@
+Metadata-Version: 2.4
+Name: PythonMetaTrader5
+Version: 2.0
+Summary: Connect MT5 with Python
+Author-email: Wiktor Jelen <wiktorjn@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/Akinzou/MetaTrader5-Python
+Project-URL: Bug Tracker, https://github.com/Akinzou/MetaTrader5-Python/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+Requires-Dist: MetaTrader5
+Requires-Dist: loguru
+Requires-Dist: pyautogui
+
+# Python Library for MetaTrader 5 Connection [![PyPI Downloads](https://static.pepy.tech/badge/pythonmetatrader5)](https://pepy.tech/projects/pythonmetatrader5)
+[![Discord](https://img.shields.io/badge/Join_us_on-Discord-5865F2?logo=discord&logoColor=white&style=for-the-badge)](https://discord.gg/BARYa55KS8)
+
+
+MetaTrader 5
+This Python library enables you to connect with the MetaTrader 5 trading platform and interact with its features using Python. It allows executing trading operations, fetching market data, receiving notifications, and more.
+
+Soon -> huge update

pythonmetatrader5-2.0.dist-info/RECORD

@@ -0,0 +1,5 @@
+PythonMetaTrader5/__init__.py,sha256=FQYk4BheVnCjEDqIKFw_i5bR6tTOquydzNtxbKkO9F8,21318
+pythonmetatrader5-2.0.dist-info/METADATA,sha256=HPvd0qanr03u89e1dbgxaooqJkMpMtSuSWrtt_jSjHs,1155
+pythonmetatrader5-2.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pythonmetatrader5-2.0.dist-info/top_level.txt,sha256=r8xFh3BXAc7RVgR1j6wCYfyk_mm_DaDoGUYFk2IqBLE,18
+pythonmetatrader5-2.0.dist-info/RECORD,,

{PythonMetaTrader5-1.0.8.dist-info → pythonmetatrader5-2.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.41.2)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

PythonMetaTrader5-1.0.8.dist-info/METADATA

@@ -1,111 +0,0 @@
-Metadata-Version: 2.1
-Name: PythonMetaTrader5
-Version: 1.0.8
-Summary: Connect MT5 with Python
-Home-page: https://github.com/Akinzou/MetaTrader5-Python
-Author: Wiktor Jelen
-Author-email: wiktorjn@gmail.com
-Project-URL: Bug Tracker, https://github.com/Akinzou/MetaTrader5-Python/issues
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.6
-Description-Content-Type: text/markdown
-
-# Python Library for MetaTrader 5 Connection
-
-![MetaTrader 5]
-This Python library enables you to connect with the MetaTrader 5 trading platform and interact with its features using Python. It allows executing trading operations, fetching market data, receiving notifications, and more.
-
-## Requirements
-
-To use this library, you need:
-
-Python 3.x
-MetaTrader 5 trading platform installed
-MetaTrader 5 Python API (MetaTrader5 module)
-colorama
-
-## Installation
-
-To install the library, use `pip`:
-
-```bash
-pip install MetaTrader5
-pip install PythonMetaTrader5
-```
-# Getting Started
-
-Import the library in your Python script:
-
-```
-from MetaTrader5 import *
-```
-
-Initialize the MetaTrader 5 library by calling the initialize() function.
-
-Create an instance of the Broker class by providing your MetaTrader 5 login credentials and server:
-
-```
-broker = Broker(log=your_mt5_login, password="your_mt5_password", server="your_mt5_server")
-```
-### After successful login, you can perform trading operations such as placing orders and managing positions.
-
-
-## Available Functions:
-### Placing Orders:
-
-``Buy(symbol, volume, price=None, *, comment=None, ticket=None):`` Places a Buy market order or limit order if price is specified.
-
-``BuySL(symbol, volume, sl, price=None, *, comment=None, ticket=None):`` Places a Buy market order or limit order with a Stop Loss (SL) price if price is specified.
-
-``Sell(symbol, volume, price=None, *, comment=None, ticket=None):`` Places a Sell market order or limit order if price is specified.
-
-``SellSL(symbol, volume, sl, price=None, *, comment=None, ticket=None):`` Places a Sell market order or limit order with a Stop Loss (SL) price if price is specified.
-
-``BuyLimit(symbol, volume, stoplimit, price=None, comment=None, ticket=None):`` Places a Buy limit order with the specified stoplimit price.
-
-``SellLimit(symbol, volume, stoplimit, price=None, comment=None, ticket=None):`` Places a Sell limit order with the specified stoplimit price.
-
-
-### Managing Positions:
-``Close(symbol, *, comment=None, ticket=None):`` Closes all positions for the specified symbol or a specific position indicated by ticket.
-
-``CancelOrders(symbol):`` Cancels all pending orders for the specified symbol.
-
-
-### Miscellaneous:
-``Disconnect():`` Closes the connection to the MetaTrader 5 trading platform.
-
-
-## Example Usage:
-```
-from MetaTrader5 import *
-
-# Initialize the MetaTrader 5 library
-initialize()
-
-# Create a broker instance and log in
-broker = Broker(log=your_mt5_login, password="your_mt5_password", server="your_mt5_server")
-
-# Place a Buy market order for 0.1 lot of EURUSD
-broker.Buy("EURUSD", 0.1)
-
-# Place a limit order for gold (if price is lower than 1900 it will be execute immediately
-broker.BuyLimit("XAUUSD", 0.01, 1900)
-
-# Close all positions for EURUSD
-broker.Close("EURUSD")
-
-# Cancel all pending orders for EURUSD
-broker.CancelOrders("EURUSD")
-
-# Disconnect from the MetaTrader 5 platform
-broker.Disconnect()
-```
-
-
-## Note:
-It is important to have the MetaTrader 5 trading platform running and logged in with the provided credentials before using this library.
-This library is provided "as is" without any warranty. Use it at your own risk.
-Before using this library in a live trading environment, thoroughly test it on a demo account to ensure its correctness and reliability.

PythonMetaTrader5-1.0.8.dist-info/RECORD

@@ -1,5 +0,0 @@
-PythonMetaTrader5/__init__.py,sha256=C3juNy9lgYU8oSqGfoJZlzRDOINmavCVCc0GT3X4btE,17118
-PythonMetaTrader5-1.0.8.dist-info/METADATA,sha256=bqG717yH7WTYzLJXixGcH79JGDCxPc4VmUN7kgRyVf4,3925
-PythonMetaTrader5-1.0.8.dist-info/WHEEL,sha256=yQN5g4mg4AybRjkgi-9yy4iQEFibGQmlz78Pik5Or-A,92
-PythonMetaTrader5-1.0.8.dist-info/top_level.txt,sha256=r8xFh3BXAc7RVgR1j6wCYfyk_mm_DaDoGUYFk2IqBLE,18
-PythonMetaTrader5-1.0.8.dist-info/RECORD,,