pdmt5 0.0.8__tar.gz → 0.0.9__tar.gz

{pdmt5-0.0.8 → pdmt5-0.0.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pdmt5
-Version: 0.0.8
+Version: 0.0.9
 Summary: Pandas-based data handler for MetaTrader 5
 Project-URL: Repository, https://github.com/dceoy/pdmt5.git
 Author-email: dceoy <dceoy@users.noreply.github.com>

{pdmt5-0.0.8 → pdmt5-0.0.9}/pdmt5/dataframe.py

@@ -86,16 +86,16 @@ class Mt5DataClient(Mt5Client):
         for i in range(1 + max(0, self.retry_count)):
             if i:
                 self.logger.warning(
-                    "Retrying MetaTrader5 initialization (%d/%d)...",
+                    "Retrying MT5 initialization (%d/%d)...",
                     i,
                     self.retry_count,
                 )
                 time.sleep(i)
             if self.initialize(**initialize_kwargs):  # type: ignore[reportArgumentType]
-                self.logger.info("MetaTrader5 initialization successful.")
+                self.logger.info("MT5 initialization successful.")
                 return
         error_message = (
-            f"MetaTrader5 initialization failed after {self.retry_count} retries:"
+            f"MT5 initialization failed after {self.retry_count} retries:"
             f" {self.last_error()}"
         )
         raise Mt5RuntimeError(error_message)

{pdmt5-0.0.8 → pdmt5-0.0.9}/pdmt5/mt5.py

@@ -59,16 +59,20 @@ class Mt5Client(BaseModel):
         @wraps(func)
         def wrapper(self: Any, *args: Any, **kwargs: Any) -> Any:
             try:
-                result = func(self, *args, **kwargs)
+                response = func(self, *args, **kwargs)
             except Exception as e:
-                error_message = f"Mt5Client operation failed: {func.__name__}"
-                self.logger.exception(error_message)
+                error_message = f"MT5 {func.__name__} failed with error: {e}"
                 raise Mt5RuntimeError(error_message) from e
             else:
-                return result
+                self.logger.info(
+                    "MT5 %s returned a response: %s",
+                    func.__name__,
+                    response,
+                )
+                return response
             finally:
                 last_error_response = self.mt5.last_error()
-                message = f"MetaTrader5 last status: {last_error_response}"
+                message = f"MT5 last status: {last_error_response}"
                 if last_error_response[0] != self.mt5.RES_S_OK:
                     self.logger.warning(message)
                 else:
@@ -119,7 +123,7 @@ class Mt5Client(BaseModel):
         """
         if path is not None:
             self.logger.info(
-                "Initializing MetaTrader5 connection with path: %s",
+                "Initializing MT5 connection with path: %s",
                 path,
             )
             self._is_initialized = self.mt5.initialize(
@@ -137,7 +141,7 @@ class Mt5Client(BaseModel):
                 },
             )
         else:
-            self.logger.info("Initializing MetaTrader5 connection.")
+            self.logger.info("Initializing MT5 connection.")
             self._is_initialized = self.mt5.initialize()
         return self._is_initialized
 
@@ -161,7 +165,7 @@ class Mt5Client(BaseModel):
             True if successful, False otherwise.
         """
         self._initialize_if_needed()
-        self.logger.info("Logging in to MetaTrader5 account: %d", login)
+        self.logger.info("Logging in to MT5 account: %d", login)
         return self.mt5.login(
             login,
             **{
@@ -178,7 +182,7 @@ class Mt5Client(BaseModel):
     @_log_mt5_last_status_code
     def shutdown(self) -> None:
         """Close the previously established connection to the MetaTrader 5 terminal."""
-        self.logger.info("Shutting down MetaTrader5 connection.")
+        self.logger.info("Shutting down MT5 connection.")
         response = self.mt5.shutdown()
         self._is_initialized = False
         return response
@@ -191,16 +195,17 @@ class Mt5Client(BaseModel):
             Tuple of (terminal_version, build, release_date).
         """
         self._initialize_if_needed()
-        self.logger.info("Retrieving MetaTrader5 version information.")
+        self.logger.info("Retrieving MT5 version information.")
         return self.mt5.version()
 
+    @_log_mt5_last_status_code
     def last_error(self) -> tuple[int, str]:
         """Return data on the last error.
 
         Returns:
             Tuple of (error_code, error_description).
         """
-        self.logger.info("Retrieving last MetaTrader5 error")
+        self.logger.info("Retrieving last MT5 error")
         return self.mt5.last_error()
 
     @_log_mt5_last_status_code
@@ -985,10 +990,8 @@ class Mt5Client(BaseModel):
             Mt5RuntimeError: With error details from MetaTrader5.
         """
         if response is None:
-            last_error_response = self.mt5.last_error()
             error_message = (
-                f"MetaTrader5 {operation} returned {response}:"
-                f" last_error={last_error_response}"
+                f"MT5 {operation} returned {response}:"
+                f" last_error={self.mt5.last_error()}"
             ) + (f" context={context}" if context else "")
-            self.logger.error(error_message)
             raise Mt5RuntimeError(error_message)

{pdmt5-0.0.8 → pdmt5-0.0.9}/pdmt5/trading.py

@@ -31,7 +31,7 @@ class Mt5TradingClient(Mt5DataClient):
 
     def close_open_positions(
         self,
-        symbols: str | list[str] | tuple[str] | None = None,
+        symbols: str | list[str] | tuple[str, ...] | None = None,
         **kwargs: Any,  # noqa: ANN401
     ) -> dict[str, list[dict[str, Any]]]:
         """Close all open positions for specified symbols.
@@ -51,6 +51,7 @@ class Mt5TradingClient(Mt5DataClient):
             symbol_list = symbols
         else:
             symbol_list = self.symbols_get()
+        self.logger.info("Fetching and closing positions for symbols: %s", symbol_list)
         return {
             s: self._fetch_and_close_position(symbol=s, **kwargs) for s in symbol_list
         }
@@ -99,11 +100,17 @@ class Mt5TradingClient(Mt5DataClient):
                 for p in positions_dict
             ]
 
-    def send_or_check_order(self, request: dict[str, Any]) -> dict[str, Any]:
+    def send_or_check_order(
+        self,
+        request: dict[str, Any],
+        dry_run: bool | None = None,
+    ) -> dict[str, Any]:
         """Send or check an order request.
 
         Args:
             request: Order request dictionary.
+            dry_run: Optional flag to enable dry run mode. If None, uses the instance's
+                `dry_run` attribute.
 
         Returns:
             Dictionary with operation result.
@@ -112,29 +119,66 @@ class Mt5TradingClient(Mt5DataClient):
             Mt5TradingError: If the order operation fails.
         """
         self.logger.debug("request: %s", request)
-        if self.dry_run:
+        is_dry_run = dry_run if dry_run is not None else self.dry_run
+        self.logger.debug("is_dry_run: %s", is_dry_run)
+        if is_dry_run:
             response = self.order_check_as_dict(request=request)
             order_func = "order_check"
         else:
             response = self.order_send_as_dict(request=request)
             order_func = "order_send"
         retcode = response.get("retcode")
-        if ((not self.dry_run) and retcode == self.mt5.TRADE_RETCODE_DONE) or (
-            self.dry_run and retcode == 0
+        if ((not is_dry_run) and retcode == self.mt5.TRADE_RETCODE_DONE) or (
+            is_dry_run and retcode == 0
         ):
-            self.logger.info("retcode: %s, response: %s", retcode, response)
+            self.logger.info("response: %s", response)
             return response
         elif retcode in {
             self.mt5.TRADE_RETCODE_TRADE_DISABLED,
             self.mt5.TRADE_RETCODE_MARKET_CLOSED,
         }:
-            self.logger.info("retcode: %s, response: %s", retcode, response)
+            self.logger.info("response: %s", response)
             comment = response.get("comment", "Unknown error")
             self.logger.warning("%s() failed and skipped. <= `%s`", order_func, comment)
             return response
         else:
-            self.logger.error("retcode: %s, response: %s", retcode, response)
+            self.logger.error("response: %s", response)
             comment = response.get("comment", "Unknown error")
             error_message = f"{order_func}() failed and aborted. <= `{comment}`"
-            self.logger.error(error_message)
+            raise Mt5TradingError(error_message)
+
+    def calculate_minimum_order_margins(self, symbol: str) -> dict[str, float]:
+        """Calculate minimum order margins for a given symbol.
+
+        Args:
+            symbol: Symbol for which to calculate minimum order margins.
+
+        Returns:
+            Dictionary with margin information.
+
+        Raises:
+            Mt5TradingError: If margin calculation fails.
+        """
+        symbol_info = self.symbol_info_as_dict(symbol=symbol)
+        symbol_info_tick = self.symbol_info_tick_as_dict(symbol=symbol)
+        min_ask_order_margin = self.mt5.order_calc_margin(
+            action=self.mt5.ORDER_TYPE_BUY,
+            symbol=symbol,
+            volume=symbol_info["volume_min"],
+            price=symbol_info_tick["ask"],
+        )
+        min_bid_order_margin = self.mt5.order_calc_margin(
+            action=self.mt5.ORDER_TYPE_SELL,
+            symbol=symbol,
+            volume=symbol_info["volume_min"],
+            price=symbol_info_tick["bid"],
+        )
+        min_order_margins = {"ask": min_ask_order_margin, "bid": min_bid_order_margin}
+        self.logger.info("Minimum order margins for %s: %s", symbol, min_order_margins)
+        if all(min_order_margins.values()):
+            return min_order_margins
+        else:
+            error_message = (
+                f"Failed to calculate minimum order margins for symbol: {symbol}."
+            )
             raise Mt5TradingError(error_message)

{pdmt5-0.0.8 → pdmt5-0.0.9}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pdmt5"
-version = "0.0.8"
+version = "0.0.9"
 description = "Pandas-based data handler for MetaTrader 5"
 authors = [{name = "dceoy", email = "dceoy@users.noreply.github.com"}]
 maintainers = [{name = "dceoy", email = "dceoy@users.noreply.github.com"}]

{pdmt5-0.0.8 → pdmt5-0.0.9}/test/test_dataframe.py

@@ -478,7 +478,7 @@ class TestMt5DataClient:
 
         client = Mt5DataClient(mt5=mock_mt5_import, retry_count=0)
         pattern = (
-            r"MetaTrader5 initialization failed after 0 retries: "
+            r"MT5 initialization failed after 0 retries: "
             r"\(1, 'Connection failed'\)"
         )
         with pytest.raises(Mt5RuntimeError, match=pattern):
@@ -933,7 +933,7 @@ class TestMt5DataClient:
         client = Mt5DataClient(mt5=mock_mt5_import)
         client.initialize()
         with pytest.raises(
-            Mt5RuntimeError, match=r"Mt5Client operation failed: order_calc_margin"
+            Mt5RuntimeError, match=r"MT5 order_calc_margin returned None"
         ):
             client.order_calc_margin(0, "EURUSD", 0.0, 1.1300)
 
@@ -949,7 +949,7 @@ class TestMt5DataClient:
         client = Mt5DataClient(mt5=mock_mt5_import)
         client.initialize()
         with pytest.raises(
-            Mt5RuntimeError, match=r"Mt5Client operation failed: order_calc_margin"
+            Mt5RuntimeError, match=r"MT5 order_calc_margin returned None"
         ):
             client.order_calc_margin(0, "EURUSD", 0.1, 0.0)
 
@@ -964,7 +964,7 @@ class TestMt5DataClient:
         client.initialize()
         with pytest.raises(
             Mt5RuntimeError,
-            match=r"Mt5Client operation failed: order_calc_margin",
+            match=r"MT5 order_calc_margin returned None",
         ):
             client.order_calc_margin(0, "EURUSD", 0.1, 1.1300)
 
@@ -992,7 +992,7 @@ class TestMt5DataClient:
         client = Mt5DataClient(mt5=mock_mt5_import)
         client.initialize()
         with pytest.raises(
-            Mt5RuntimeError, match=r"Mt5Client operation failed: order_calc_profit"
+            Mt5RuntimeError, match=r"MT5 order_calc_profit returned None"
         ):
             client.order_calc_profit(0, "EURUSD", 0.0, 1.1300, 1.1400)
 
@@ -1008,7 +1008,7 @@ class TestMt5DataClient:
         client = Mt5DataClient(mt5=mock_mt5_import)
         client.initialize()
         with pytest.raises(
-            Mt5RuntimeError, match=r"Mt5Client operation failed: order_calc_profit"
+            Mt5RuntimeError, match=r"MT5 order_calc_profit returned None"
         ):
             client.order_calc_profit(0, "EURUSD", 0.1, 0.0, 1.1400)
 
@@ -1024,7 +1024,7 @@ class TestMt5DataClient:
         client = Mt5DataClient(mt5=mock_mt5_import)
         client.initialize()
         with pytest.raises(
-            Mt5RuntimeError, match=r"Mt5Client operation failed: order_calc_profit"
+            Mt5RuntimeError, match=r"MT5 order_calc_profit returned None"
         ):
             client.order_calc_profit(0, "EURUSD", 0.1, 1.1300, 0.0)
 
@@ -1039,7 +1039,7 @@ class TestMt5DataClient:
         client.initialize()
         with pytest.raises(
             Mt5RuntimeError,
-            match=r"Mt5Client operation failed: order_calc_profit",
+            match=r"MT5 order_calc_profit returned None",
         ):
             client.order_calc_profit(0, "EURUSD", 0.1, 1.1300, 1.1400)
 
@@ -1126,9 +1126,7 @@ class TestMt5DataClient:
 
         client = Mt5DataClient(mt5=mock_mt5_import)
         client.initialize()
-        with pytest.raises(
-            Mt5RuntimeError, match=r"Mt5Client operation failed: symbol_select"
-        ):
+        with pytest.raises(Mt5RuntimeError, match=r"MT5 symbol_select returned None"):
             client.symbol_select("EURUSD")
 
     def test_market_book_add(self, mock_mt5_import: ModuleType | None) -> None:
@@ -1152,9 +1150,7 @@ class TestMt5DataClient:
 
         client = Mt5DataClient(mt5=mock_mt5_import)
         client.initialize()
-        with pytest.raises(
-            Mt5RuntimeError, match=r"Mt5Client operation failed: market_book_add"
-        ):
+        with pytest.raises(Mt5RuntimeError, match=r"MT5 market_book_add returned None"):
             client.market_book_add("EURUSD")
 
     def test_market_book_release(self, mock_mt5_import: ModuleType | None) -> None:
@@ -1182,7 +1178,7 @@ class TestMt5DataClient:
         client.initialize()
         with pytest.raises(
             Mt5RuntimeError,
-            match=r"Mt5Client operation failed: market_book_release",
+            match=r"MT5 market_book_release returned None",
         ):
             client.market_book_release("EURUSD")
 
@@ -1485,9 +1481,7 @@ class TestMt5DataClient:
 
         client = Mt5DataClient(mt5=mock_mt5_import)
         client.initialize()
-        with pytest.raises(
-            Mt5RuntimeError, match=r"Mt5Client operation failed: market_book_get"
-        ):
+        with pytest.raises(Mt5RuntimeError, match=r"MT5 market_book_get returned None"):
             client.market_book_get("EURUSD")
 
     def test_shutdown_when_not_initialized(
@@ -1913,7 +1907,7 @@ class TestMt5DataClientRetryLogic:
         with pytest.raises(Mt5RuntimeError) as exc_info:
             client.initialize_mt5()
 
-        assert "MetaTrader5 initialization failed after" in str(exc_info.value)
+        assert "MT5 initialization failed after" in str(exc_info.value)
         assert mock_mt5_import.initialize.call_count == 3  # All attempts made
         # Check that sleep was called for retries
         assert mock_sleep.call_count == 2

{pdmt5-0.0.8 → pdmt5-0.0.9}/test/test_mt5.py

@@ -119,10 +119,12 @@ class TestMt5Client:
 
     def test_last_error(self, client: Mt5Client, mock_mt5: Mock) -> None:
         """Test last_error method."""
+        mock_mt5.last_error.return_value = (1001, "Test error")
         error = client.last_error()
 
         assert error == (1001, "Test error")
-        mock_mt5.last_error.assert_called_once()
+        # last_error is called twice: once by the method, once by the decorator
+        assert mock_mt5.last_error.call_count == 2
 
     def test_initialize_if_needed_calls_initialize(
         self, client: Mt5Client, mock_mt5: Mock
@@ -211,7 +213,7 @@ class TestMt5Client:
         with pytest.raises(Mt5RuntimeError) as exc_info:
             initialized_client.symbols_get()
 
-        assert "Mt5Client operation failed: symbols_get" in str(exc_info.value)
+        assert "MT5 symbols_get returned None" in str(exc_info.value)
 
     def test_symbol_info(
         self,
@@ -645,7 +647,7 @@ class TestMt5Client:
             initialized_client.symbol_info("EURUSD")
 
         error_msg = str(exc_info.value)
-        assert "Mt5Client operation failed: symbol_info" in error_msg
+        assert "MT5 symbol_info returned None" in error_msg
 
     def test_default_mt5_import(self, mock_metatrader5_import: MockerFixture) -> None:
         """Test default MetaTrader5 module import."""

{pdmt5-0.0.8 → pdmt5-0.0.9}/test/test_trading.py

@@ -49,9 +49,11 @@ def mock_mt5_import(
         mock_mt5.terminal_info = mocker.MagicMock()  # type: ignore[attr-defined]
         mock_mt5.symbols_get = mocker.MagicMock()  # type: ignore[attr-defined]
         mock_mt5.symbol_info = mocker.MagicMock()  # type: ignore[attr-defined]
+        mock_mt5.symbol_info_tick = mocker.MagicMock()  # type: ignore[attr-defined]
         mock_mt5.positions_get = mocker.MagicMock()  # type: ignore[attr-defined]
         mock_mt5.order_check = mocker.MagicMock()  # type: ignore[attr-defined]
         mock_mt5.order_send = mocker.MagicMock()  # type: ignore[attr-defined]
+        mock_mt5.order_calc_margin = mocker.MagicMock()  # type: ignore[attr-defined]
 
         # Trading-specific constants
         mock_mt5.TRADE_ACTION_DEAL = 1
@@ -265,6 +267,58 @@ class TestMt5TradingClient:
         assert "EURUSD" in result
         assert result["EURUSD"] == []
 
+    def test_close_open_positions_tuple_input(
+        self,
+        mock_mt5_import: ModuleType,
+    ) -> None:
+        """Test close_open_positions with tuple input."""
+        client = Mt5TradingClient(mt5=mock_mt5_import)
+        mock_mt5_import.initialize.return_value = True
+        client.initialize()
+
+        # Mock empty positions
+        mock_mt5_import.positions_get.return_value = []
+
+        result = client.close_open_positions(("EURUSD", "GBPUSD"))
+
+        assert len(result) == 2
+        assert "EURUSD" in result
+        assert "GBPUSD" in result
+        assert result["EURUSD"] == []
+        assert result["GBPUSD"] == []
+
+    def test_close_open_positions_with_kwargs(
+        self,
+        mock_mt5_import: ModuleType,
+        mock_position_buy: MockPositionInfo,
+    ) -> None:
+        """Test close_open_positions with additional kwargs."""
+        client = Mt5TradingClient(mt5=mock_mt5_import)
+        mock_mt5_import.initialize.return_value = True
+        client.initialize()
+
+        # Mock positions
+        mock_mt5_import.positions_get.return_value = [mock_position_buy]
+
+        mock_mt5_import.order_send.return_value.retcode = 10009
+        mock_mt5_import.order_send.return_value._asdict.return_value = {
+            "retcode": 10009,
+            "result": "success",
+        }
+
+        # Pass custom kwargs
+        result = client.close_open_positions(
+            "EURUSD", comment="custom_close", magic=12345
+        )
+
+        assert len(result["EURUSD"]) == 1
+        assert result["EURUSD"][0]["retcode"] == 10009
+
+        # Check that kwargs were passed through
+        call_args = mock_mt5_import.order_send.call_args[0][0]
+        assert call_args["comment"] == "custom_close"
+        assert call_args["magic"] == 12345
+
     def test_send_or_check_order_dry_run_success(
         self,
         mock_mt5_import: ModuleType,
@@ -431,6 +485,72 @@ class TestMt5TradingClient:
         ):
             client.send_or_check_order(request)
 
+    def test_send_or_check_order_dry_run_override(
+        self,
+        mock_mt5_import: ModuleType,
+    ) -> None:
+        """Test send_or_check_order with dry_run parameter override."""
+        # Client initialized with dry_run=False
+        client = Mt5TradingClient(mt5=mock_mt5_import, dry_run=False)
+        mock_mt5_import.initialize.return_value = True
+        client.initialize()
+
+        request = {
+            "action": 1,
+            "symbol": "EURUSD",
+            "volume": 0.1,
+            "type": 1,
+        }
+
+        # Mock successful order check
+        mock_mt5_import.order_check.return_value.retcode = 0
+        mock_mt5_import.order_check.return_value._asdict.return_value = {
+            "retcode": 0,
+            "result": "check_success",
+        }
+
+        # Override with dry_run=True
+        result = client.send_or_check_order(request, dry_run=True)
+
+        assert result["retcode"] == 0
+        assert result["result"] == "check_success"
+        # Should call order_check, not order_send
+        mock_mt5_import.order_check.assert_called_once_with(request)
+        mock_mt5_import.order_send.assert_not_called()
+
+    def test_send_or_check_order_real_mode_override(
+        self,
+        mock_mt5_import: ModuleType,
+    ) -> None:
+        """Test send_or_check_order with real mode override."""
+        # Client initialized with dry_run=True
+        client = Mt5TradingClient(mt5=mock_mt5_import, dry_run=True)
+        mock_mt5_import.initialize.return_value = True
+        client.initialize()
+
+        request = {
+            "action": 1,
+            "symbol": "EURUSD",
+            "volume": 0.1,
+            "type": 1,
+        }
+
+        # Mock successful order send
+        mock_mt5_import.order_send.return_value.retcode = 10009
+        mock_mt5_import.order_send.return_value._asdict.return_value = {
+            "retcode": 10009,
+            "result": "send_success",
+        }
+
+        # Override with dry_run=False
+        result = client.send_or_check_order(request, dry_run=False)
+
+        assert result["retcode"] == 10009
+        assert result["result"] == "send_success"
+        # Should call order_send, not order_check
+        mock_mt5_import.order_send.assert_called_once_with(request)
+        mock_mt5_import.order_check.assert_not_called()
+
     def test_order_filling_mode_constants(
         self,
         mock_mt5_import: ModuleType,
@@ -490,3 +610,139 @@ class TestMt5TradingClient:
         # Sell position should result in buy order
         call_args = mock_mt5_import.order_send.call_args[0][0]
         assert call_args["type"] == mock_mt5_import.ORDER_TYPE_BUY
+
+    def test_calculate_minimum_order_margins_success(
+        self,
+        mock_mt5_import: ModuleType,
+    ) -> None:
+        """Test successful calculation of minimum order margins."""
+        client = Mt5TradingClient(mt5=mock_mt5_import)
+        mock_mt5_import.initialize.return_value = True
+        client.initialize()
+
+        # Mock symbol info
+        mock_mt5_import.symbol_info.return_value._asdict.return_value = {
+            "volume_min": 0.01,
+            "name": "EURUSD",
+        }
+
+        # Mock symbol tick info
+        mock_mt5_import.symbol_info_tick.return_value._asdict.return_value = {
+            "ask": 1.1000,
+            "bid": 1.0998,
+        }
+
+        # Mock order_calc_margin to return successful results
+        mock_mt5_import.order_calc_margin.side_effect = [100.5, 99.8]
+
+        result = client.calculate_minimum_order_margins("EURUSD")
+
+        assert result == {"ask": 100.5, "bid": 99.8}
+        assert mock_mt5_import.order_calc_margin.call_count == 2
+
+        # Verify first call (buy order)
+        first_call = mock_mt5_import.order_calc_margin.call_args_list[0]
+        assert first_call[1]["action"] == mock_mt5_import.ORDER_TYPE_BUY
+        assert first_call[1]["symbol"] == "EURUSD"
+        assert first_call[1]["volume"] == 0.01
+        assert first_call[1]["price"] == 1.1000
+
+        # Verify second call (sell order)
+        second_call = mock_mt5_import.order_calc_margin.call_args_list[1]
+        assert second_call[1]["action"] == mock_mt5_import.ORDER_TYPE_SELL
+        assert second_call[1]["symbol"] == "EURUSD"
+        assert second_call[1]["volume"] == 0.01
+        assert second_call[1]["price"] == 1.0998
+
+    def test_calculate_minimum_order_margins_failure_ask(
+        self,
+        mock_mt5_import: ModuleType,
+    ) -> None:
+        """Test failed calculation of minimum order margins - ask margin fails."""
+        client = Mt5TradingClient(mt5=mock_mt5_import)
+        mock_mt5_import.initialize.return_value = True
+        client.initialize()
+
+        # Mock symbol info
+        mock_mt5_import.symbol_info.return_value._asdict.return_value = {
+            "volume_min": 0.01,
+            "name": "EURUSD",
+        }
+
+        # Mock symbol tick info
+        mock_mt5_import.symbol_info_tick.return_value._asdict.return_value = {
+            "ask": 1.1000,
+            "bid": 1.0998,
+        }
+
+        # Mock order_calc_margin to return None for ask margin
+        mock_mt5_import.order_calc_margin.side_effect = [None, 99.8]
+
+        with pytest.raises(Mt5TradingError) as exc_info:
+            client.calculate_minimum_order_margins("EURUSD")
+
+        assert "Failed to calculate minimum order margins for symbol: EURUSD" in str(
+            exc_info.value
+        )
+
+    def test_calculate_minimum_order_margins_failure_bid(
+        self,
+        mock_mt5_import: ModuleType,
+    ) -> None:
+        """Test failed calculation of minimum order margins - bid margin fails."""
+        client = Mt5TradingClient(mt5=mock_mt5_import)
+        mock_mt5_import.initialize.return_value = True
+        client.initialize()
+
+        # Mock symbol info
+        mock_mt5_import.symbol_info.return_value._asdict.return_value = {
+            "volume_min": 0.01,
+            "name": "EURUSD",
+        }
+
+        # Mock symbol tick info
+        mock_mt5_import.symbol_info_tick.return_value._asdict.return_value = {
+            "ask": 1.1000,
+            "bid": 1.0998,
+        }
+
+        # Mock order_calc_margin to return None for bid margin
+        mock_mt5_import.order_calc_margin.side_effect = [100.5, None]
+
+        with pytest.raises(Mt5TradingError) as exc_info:
+            client.calculate_minimum_order_margins("EURUSD")
+
+        assert "Failed to calculate minimum order margins for symbol: EURUSD" in str(
+            exc_info.value
+        )
+
+    def test_calculate_minimum_order_margins_failure_both(
+        self,
+        mock_mt5_import: ModuleType,
+    ) -> None:
+        """Test failed calculation of minimum order margins - both margins fail."""
+        client = Mt5TradingClient(mt5=mock_mt5_import)
+        mock_mt5_import.initialize.return_value = True
+        client.initialize()
+
+        # Mock symbol info
+        mock_mt5_import.symbol_info.return_value._asdict.return_value = {
+            "volume_min": 0.01,
+            "name": "EURUSD",
+        }
+
+        # Mock symbol tick info
+        mock_mt5_import.symbol_info_tick.return_value._asdict.return_value = {
+            "ask": 1.1000,
+            "bid": 1.0998,
+        }
+
+        # Mock order_calc_margin to return None for both margins
+        mock_mt5_import.order_calc_margin.side_effect = [None, None]
+
+        with pytest.raises(Mt5TradingError) as exc_info:
+            client.calculate_minimum_order_margins("EURUSD")
+
+        assert "Failed to calculate minimum order margins for symbol: EURUSD" in str(
+            exc_info.value
+        )

{pdmt5-0.0.8 → pdmt5-0.0.9}/uv.lock

@@ -613,7 +613,7 @@ wheels = [
 
 [[package]]
 name = "pdmt5"
-version = "0.0.8"
+version = "0.0.9"
 source = { editable = "." }
 dependencies = [
     { name = "metatrader5", marker = "sys_platform == 'win32'" },