pdmt5 0.1.4__tar.gz → 0.1.5__tar.gz

{pdmt5-0.1.4 → pdmt5-0.1.5}/.claude/settings.json

@@ -6,10 +6,10 @@
         "hooks": [
           {
             "type": "command",
-            "command": "uv run ruff check --fix . && uv run ruff format . && uv run pyright . && uv run pytest"
+            "command": "uv run ruff format . && uv run ruff check --fix . && uv run pyright . && uv run pytest"
           }
         ]
       }
     ]
   }
-}
+}

{pdmt5-0.1.4 → pdmt5-0.1.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pdmt5
-Version: 0.1.4
+Version: 0.1.5
 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>
@@ -29,7 +29,6 @@ Pandas-based data handler for MetaTrader 5
 [![Python Version](https://img.shields.io/badge/python-3.11%2B-blue.svg)](https://www.python.org/downloads/)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 [![Platform](https://img.shields.io/badge/platform-Windows-blue.svg)](https://www.microsoft.com/windows)
-[![Version](https://img.shields.io/badge/version-0.1.4-green.svg)](https://github.com/dceoy/pdmt5)
 
 ## Overview
 
@@ -195,10 +194,12 @@ Advanced trading operations client that extends Mt5DataClient:
   - `dry_run` - Test mode flag for simulating trades without execution
 - **Position Management**:
   - `close_open_positions()` - Close all positions for specified symbol(s)
-  - `send_or_check_order()` - Execute or validate orders based on dry_run mode
+  - `place_market_order()` - Place market orders with configurable side, volume, and execution modes
+  - `update_open_position_sltp()` - Modify stop loss and take profit levels for open positions
 - **Market Analysis**:
   - `calculate_minimum_order_margins()` - Calculate minimum required margins for buy/sell orders
   - `calculate_spread_ratio()` - Calculate normalized bid-ask spread ratio
+  - `calculate_new_position_margin_ratio()` - Calculate margin ratio for potential new positions
 - **Simplified Data Access**:
   - `fetch_latest_rates_as_df()` - Get recent OHLC data with timeframe strings (e.g., "M1", "H1", "D1")
   - `fetch_latest_ticks_as_df()` - Get tick data for specified seconds around last tick
@@ -288,18 +289,54 @@ from pdmt5 import Mt5TradingClient
 
 # Create trading client with specific order filling mode
 with Mt5TradingClient(config=config, order_filling_mode="IOC") as trader:
+    # Place a market buy order
+    order_result = trader.place_market_order(
+        symbol="EURUSD",
+        volume=0.1,
+        order_side="BUY",
+        order_filling_mode="IOC",  # Immediate or Cancel
+        order_time_mode="GTC"      # Good Till Cancelled
+    )
+    print(f"Order placed: {order_result['retcode']}")
+
+    # Update stop loss and take profit for an open position
+    if positions := trader.positions_get_as_df(symbol="EURUSD"):
+        position_ticket = positions.iloc[0]['ticket']
+        update_result = trader.update_open_position_sltp(
+            symbol="EURUSD",
+            position_ticket=position_ticket,
+            sl=1.0950,  # New stop loss
+            tp=1.1050   # New take profit
+        )
+        print(f"Position updated: {update_result['retcode']}")
+
+    # Calculate margin ratio for a new position
+    margin_ratio = trader.calculate_new_position_margin_ratio(
+        symbol="EURUSD",
+        new_side="SELL",
+        new_volume=0.2
+    )
+    print(f"New position margin ratio: {margin_ratio:.2%}")
+
     # Close all EURUSD positions
     results = trader.close_open_positions(symbols="EURUSD")
 
     if results:
-        for result in results:
-            print(f"Closed position {result['position']} with result: {result['retcode']}")
+        for symbol, close_results in results.items():
+            for result in close_results:
+                print(f"Closed position {result.get('position')} with result: {result['retcode']}")
 
     # Using dry run mode for testing
     trader_dry = Mt5TradingClient(config=config, dry_run=True)
     with trader_dry:
-        # Test closing positions without actual execution
-        test_results = trader_dry.close_open_positions(symbols=["EURUSD", "GBPUSD"])
+        # Test placing an order without actual execution
+        test_order = trader_dry.place_market_order(
+            symbol="GBPUSD",
+            volume=0.1,
+            order_side="SELL",
+            dry_run=True  # Override instance setting
+        )
+        print(f"Test order validation: {test_order['retcode']}")
 ```
 
 ### Market Analysis with Mt5TradingClient

{pdmt5-0.1.4 → pdmt5-0.1.5}/README.md

@@ -6,7 +6,6 @@ Pandas-based data handler for MetaTrader 5
 [![Python Version](https://img.shields.io/badge/python-3.11%2B-blue.svg)](https://www.python.org/downloads/)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 [![Platform](https://img.shields.io/badge/platform-Windows-blue.svg)](https://www.microsoft.com/windows)
-[![Version](https://img.shields.io/badge/version-0.1.4-green.svg)](https://github.com/dceoy/pdmt5)
 
 ## Overview
 
@@ -172,10 +171,12 @@ Advanced trading operations client that extends Mt5DataClient:
   - `dry_run` - Test mode flag for simulating trades without execution
 - **Position Management**:
   - `close_open_positions()` - Close all positions for specified symbol(s)
-  - `send_or_check_order()` - Execute or validate orders based on dry_run mode
+  - `place_market_order()` - Place market orders with configurable side, volume, and execution modes
+  - `update_open_position_sltp()` - Modify stop loss and take profit levels for open positions
 - **Market Analysis**:
   - `calculate_minimum_order_margins()` - Calculate minimum required margins for buy/sell orders
   - `calculate_spread_ratio()` - Calculate normalized bid-ask spread ratio
+  - `calculate_new_position_margin_ratio()` - Calculate margin ratio for potential new positions
 - **Simplified Data Access**:
   - `fetch_latest_rates_as_df()` - Get recent OHLC data with timeframe strings (e.g., "M1", "H1", "D1")
   - `fetch_latest_ticks_as_df()` - Get tick data for specified seconds around last tick
@@ -265,18 +266,54 @@ from pdmt5 import Mt5TradingClient
 
 # Create trading client with specific order filling mode
 with Mt5TradingClient(config=config, order_filling_mode="IOC") as trader:
+    # Place a market buy order
+    order_result = trader.place_market_order(
+        symbol="EURUSD",
+        volume=0.1,
+        order_side="BUY",
+        order_filling_mode="IOC",  # Immediate or Cancel
+        order_time_mode="GTC"      # Good Till Cancelled
+    )
+    print(f"Order placed: {order_result['retcode']}")
+
+    # Update stop loss and take profit for an open position
+    if positions := trader.positions_get_as_df(symbol="EURUSD"):
+        position_ticket = positions.iloc[0]['ticket']
+        update_result = trader.update_open_position_sltp(
+            symbol="EURUSD",
+            position_ticket=position_ticket,
+            sl=1.0950,  # New stop loss
+            tp=1.1050   # New take profit
+        )
+        print(f"Position updated: {update_result['retcode']}")
+
+    # Calculate margin ratio for a new position
+    margin_ratio = trader.calculate_new_position_margin_ratio(
+        symbol="EURUSD",
+        new_side="SELL",
+        new_volume=0.2
+    )
+    print(f"New position margin ratio: {margin_ratio:.2%}")
+
     # Close all EURUSD positions
     results = trader.close_open_positions(symbols="EURUSD")
 
     if results:
-        for result in results:
-            print(f"Closed position {result['position']} with result: {result['retcode']}")
+        for symbol, close_results in results.items():
+            for result in close_results:
+                print(f"Closed position {result.get('position')} with result: {result['retcode']}")
 
     # Using dry run mode for testing
     trader_dry = Mt5TradingClient(config=config, dry_run=True)
     with trader_dry:
-        # Test closing positions without actual execution
-        test_results = trader_dry.close_open_positions(symbols=["EURUSD", "GBPUSD"])
+        # Test placing an order without actual execution
+        test_order = trader_dry.place_market_order(
+            symbol="GBPUSD",
+            volume=0.1,
+            order_side="SELL",
+            dry_run=True  # Override instance setting
+        )
+        print(f"Test order validation: {test_order['retcode']}")
 ```
 
 ### Market Analysis with Mt5TradingClient

{pdmt5-0.1.4 → pdmt5-0.1.5}/pdmt5/trading.py

@@ -31,12 +31,11 @@ class Mt5TradingClient(Mt5DataClient):
         description="Order filling mode: 'IOC' (Immediate or Cancel), "
         "'FOK' (Fill or Kill), 'RETURN' (Return if not filled)",
     )
-    dry_run: bool = Field(default=False, description="Enable dry run mode for testing.")
 
     def close_open_positions(
         self,
         symbols: str | list[str] | tuple[str, ...] | None = None,
-        dry_run: bool | None = None,
+        dry_run: bool = False,
         **kwargs: Any,  # noqa: ANN401
     ) -> dict[str, list[dict[str, Any]]]:
         """Close all open positions for specified symbols.
@@ -44,8 +43,7 @@ class Mt5TradingClient(Mt5DataClient):
         Args:
             symbols: Optional symbol or list of symbols to filter positions.
                 If None, all symbols will be considered.
-            dry_run: Optional flag to enable dry run mode. If None, uses the instance's
-                `dry_run` attribute.
+            dry_run: If True, only check the order without sending it.
             **kwargs: Additional keyword arguments for request parameters.
 
         Returns:
@@ -67,15 +65,14 @@ class Mt5TradingClient(Mt5DataClient):
     def _fetch_and_close_position(
         self,
         symbol: str | None = None,
-        dry_run: bool | None = None,
+        dry_run: bool = False,
         **kwargs: Any,  # noqa: ANN401
     ) -> list[dict[str, Any]]:
         """Close all open positions for a specific symbol.
 
         Args:
             symbol: Optional symbol filter.
-            dry_run: Optional flag to enable dry run mode. If None, uses the instance's
-                `dry_run` attribute.
+            dry_run: If True, only check the order without sending it.
             **kwargs: Additional keyword arguments for request parameters.
 
         Returns:
@@ -92,7 +89,7 @@ class Mt5TradingClient(Mt5DataClient):
                 f"ORDER_FILLING_{self.order_filling_mode}",
             )
             return [
-                self.send_or_check_order(
+                self._send_or_check_order(
                     request={
                         "action": self.mt5.TRADE_ACTION_DEAL,
                         "symbol": p["symbol"],
@@ -112,17 +109,16 @@ class Mt5TradingClient(Mt5DataClient):
                 for p in positions_dict
             ]
 
-    def send_or_check_order(
+    def _send_or_check_order(
         self,
         request: dict[str, Any],
-        dry_run: bool | None = None,
+        dry_run: bool = False,
     ) -> 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.
+            dry_run: If True, only check the order without sending it.
 
         Returns:
             Dictionary with operation result.
@@ -131,17 +127,15 @@ class Mt5TradingClient(Mt5DataClient):
             Mt5TradingError: If the order operation fails.
         """
         self.logger.debug("request: %s", request)
-        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:
+        if 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 is_dry_run) and retcode == self.mt5.TRADE_RETCODE_DONE) or (
-            is_dry_run and retcode == 0
+        if ((not dry_run) and retcode == self.mt5.TRADE_RETCODE_DONE) or (
+            dry_run and retcode == 0
         ):
             self.logger.info("response: %s", response)
             return response
@@ -159,6 +153,116 @@ class Mt5TradingClient(Mt5DataClient):
             error_message = f"{order_func}() failed and aborted. <= `{comment}`"
             raise Mt5TradingError(error_message)
 
+    def place_market_order(
+        self,
+        symbol: str,
+        volume: float,
+        order_side: Literal["BUY", "SELL"],
+        order_filling_mode: Literal["IOC", "FOK", "RETURN"] = "IOC",
+        order_time_mode: Literal["GTC", "DAY", "SPECIFIED", "SPECIFIED_DAY"] = "GTC",
+        dry_run: bool = False,
+        **kwargs: Any,  # noqa: ANN401
+    ) -> dict[str, Any]:
+        """Send or check an order request to place a market order.
+
+        Args:
+            symbol: Symbol for the order.
+            volume: Volume of the order.
+            order_side: Side of the order, either "BUY" or "SELL".
+            order_filling_mode: Order filling mode, either "IOC", "FOK", or "RETURN".
+            order_time_mode: Order time mode, either "GTC", "DAY", "SPECIFIED",
+                or "SPECIFIED_DAY".
+            dry_run: If True, only check the order without sending it.
+            **kwargs: Additional keyword arguments for request parameters.
+
+        Returns:
+            Dictionary with operation result.
+        """
+        return self._send_or_check_order(
+            request={
+                "action": self.mt5.TRADE_ACTION_DEAL,
+                "symbol": symbol,
+                "volume": volume,
+                "type": getattr(self.mt5, f"ORDER_TYPE_{order_side.upper()}"),
+                "type_filling": getattr(
+                    self.mt5, f"ORDER_FILLING_{order_filling_mode.upper()}"
+                ),
+                "type_time": getattr(self.mt5, f"ORDER_TIME_{order_time_mode.upper()}"),
+                **kwargs,
+            },
+            dry_run=dry_run,
+        )
+
+    def update_sltp_for_open_positions(
+        self,
+        symbol: str,
+        stop_loss: float | None = None,
+        take_profit: float | None = None,
+        tickets: list[int] | None = None,
+        dry_run: bool = False,
+        **kwargs: Any,  # noqa: ANN401
+    ) -> list[dict[str, Any]]:
+        """Change Stop Loss and Take Profit for open positions.
+
+        Args:
+            symbol: Symbol for the position.
+            stop_loss: New Stop Loss price. If None, it will not be changed.
+            take_profit: New Take Profit price. If None, it will not be changed.
+            tickets: List of position tickets to filter positions. If None, all open
+                positions for the symbol will be considered.
+            dry_run: If True, only check the order without sending it.
+            **kwargs: Additional keyword arguments for request parameters.
+
+        Returns:
+            List of dictionaries with operation results for each updated position.
+        """
+        positions_df = self.positions_get_as_df(symbol=symbol)
+        if positions_df.empty:
+            self.logger.warning("No open positions found for symbol: %s", symbol)
+            return []
+        elif tickets:
+            filtered_positions_df = positions_df.pipe(
+                lambda d: d[d["ticket"].isin(tickets)]
+            )
+        else:
+            filtered_positions_df = positions_df
+        if filtered_positions_df.empty:
+            self.logger.warning(
+                "No open positions found for symbol: %s with specified tickets: %s",
+                symbol,
+                tickets,
+            )
+            return []
+        else:
+            symbol_info = self.symbol_info_as_dict(symbol=symbol)
+            sl = round(stop_loss, symbol_info["digits"]) if stop_loss else None
+            tp = round(take_profit, symbol_info["digits"]) if take_profit else None
+            order_requests = [
+                {
+                    "action": self.mt5.TRADE_ACTION_SLTP,
+                    "symbol": p["symbol"],
+                    "position": p["ticket"],
+                    "sl": (sl or p["sl"]),
+                    "tp": (tp or p["tp"]),
+                    **kwargs,
+                }
+                for _, p in filtered_positions_df.iterrows()
+                if sl != p["sl"] or tp != p["tp"]
+            ]
+            if order_requests:
+                return [
+                    self._send_or_check_order(request=r, dry_run=dry_run)
+                    for r in order_requests
+                ]
+            else:
+                self.logger.info(
+                    "No positions to update for symbol: %s with SL: %s and TP: %s",
+                    symbol,
+                    sl,
+                    tp,
+                )
+                return []
+
     def calculate_minimum_order_margins(self, symbol: str) -> dict[str, float]:
         """Calculate minimum order margins for a given symbol.
 
@@ -369,3 +473,50 @@ class Mt5TradingClient(Mt5DataClient):
                 )
                 .drop(columns=["buy_i", "sell_i", "sign", "underlier_increase_ratio"])
             )
+
+    def calculate_new_position_margin_ratio(
+        self,
+        symbol: str,
+        new_side: Literal["BUY", "SELL"] | None = None,
+        new_volume: float = 0,
+    ) -> float:
+        """Calculate the margin ratio for a new position.
+
+        Args:
+            symbol: Symbol for which to calculate the margin ratio.
+            new_side: Side of the new position, either "BUY" or "SELL".
+            new_volume: Volume of the new position.
+
+        Returns:
+            float: Margin ratio for the new position as a fraction of account equity.
+        """
+        account_info = self.account_info_as_dict()
+        if not account_info["equity"]:
+            return 0.0
+        else:
+            positions_df = self.fetch_positions_with_metrics_as_df(symbol=symbol)
+            current_signed_margin = (
+                positions_df["signed_margin"].sum() if positions_df.size else 0
+            )
+            symbol_info_tick = self.symbol_info_tick_as_dict(symbol=symbol)
+            if new_volume == 0:
+                new_signed_margin = 0
+            elif new_side == "BUY":
+                new_signed_margin = self.order_calc_margin(
+                    action=self.mt5.ORDER_TYPE_BUY,
+                    symbol=symbol,
+                    volume=new_volume,
+                    price=symbol_info_tick["ask"],
+                )
+            elif new_side == "SELL":
+                new_signed_margin = -self.order_calc_margin(
+                    action=self.mt5.ORDER_TYPE_SELL,
+                    symbol=symbol,
+                    volume=new_volume,
+                    price=symbol_info_tick["bid"],
+                )
+            else:
+                new_signed_margin = 0
+            return abs(
+                (new_signed_margin + current_signed_margin) / account_info["equity"]
+            )

{pdmt5-0.1.4 → pdmt5-0.1.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pdmt5"
-version = "0.1.4"
+version = "0.1.5"
 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.1.4 → pdmt5-0.1.5}/test/test_trading.py

@@ -183,17 +183,14 @@ class TestMt5TradingClient:
         """Test client initialization with default parameters."""
         client = Mt5TradingClient(mt5=mock_mt5_import)
         assert client.order_filling_mode == "IOC"
-        assert client.dry_run is False
 
     def test_client_initialization_custom(self, mock_mt5_import: ModuleType) -> None:
         """Test client initialization with custom parameters."""
         client = Mt5TradingClient(
             mt5=mock_mt5_import,
             order_filling_mode="FOK",
-            dry_run=True,
         )
         assert client.order_filling_mode == "FOK"
-        assert client.dry_run is True
 
     def test_client_initialization_invalid_filling_mode(
         self, mock_mt5_import: ModuleType
@@ -250,7 +247,7 @@ class TestMt5TradingClient:
         mock_position_buy: MockPositionInfo,
     ) -> None:
         """Test close_position with existing positions in dry run mode."""
-        client = Mt5TradingClient(mt5=mock_mt5_import, dry_run=True)
+        client = Mt5TradingClient(mt5=mock_mt5_import)
         mock_mt5_import.initialize.return_value = True
         client.initialize()
 
@@ -263,7 +260,7 @@ class TestMt5TradingClient:
             "result": "check_success",
         }
 
-        result = client.close_open_positions("EURUSD")
+        result = client.close_open_positions("EURUSD", dry_run=True)
 
         assert len(result["EURUSD"]) == 1
         assert result["EURUSD"][0]["retcode"] == 0
@@ -276,8 +273,8 @@ class TestMt5TradingClient:
         mock_position_buy: MockPositionInfo,
     ) -> None:
         """Test close_position with dry_run parameter override."""
-        # Client initialized with dry_run=False
-        client = Mt5TradingClient(mt5=mock_mt5_import, dry_run=False)
+        # Client initialized without dry_run
+        client = Mt5TradingClient(mt5=mock_mt5_import)
         mock_mt5_import.initialize.return_value = True
         client.initialize()
 
@@ -305,8 +302,8 @@ class TestMt5TradingClient:
         mock_position_buy: MockPositionInfo,
     ) -> None:
         """Test close_position with real mode override."""
-        # Client initialized with dry_run=True
-        client = Mt5TradingClient(mt5=mock_mt5_import, dry_run=True)
+        # Client initialized without dry_run
+        client = Mt5TradingClient(mt5=mock_mt5_import)
         mock_mt5_import.initialize.return_value = True
         client.initialize()
 
@@ -425,7 +422,7 @@ class TestMt5TradingClient:
         mock_position_buy: MockPositionInfo,
     ) -> None:
         """Test close_open_positions with additional kwargs and dry_run override."""
-        client = Mt5TradingClient(mt5=mock_mt5_import, dry_run=False)
+        client = Mt5TradingClient(mt5=mock_mt5_import)
         mock_mt5_import.initialize.return_value = True
         client.initialize()
 
@@ -456,8 +453,8 @@ class TestMt5TradingClient:
         self,
         mock_mt5_import: ModuleType,
     ) -> None:
-        """Test send_or_check_order in dry run mode with success."""
-        client = Mt5TradingClient(mt5=mock_mt5_import, dry_run=True)
+        """Test _send_or_check_order in dry run mode with success."""
+        client = Mt5TradingClient(mt5=mock_mt5_import)
         mock_mt5_import.initialize.return_value = True
         client.initialize()
 
@@ -475,7 +472,7 @@ class TestMt5TradingClient:
             "result": "check_success",
         }
 
-        result = client.send_or_check_order(request)
+        result = client._send_or_check_order(request, dry_run=True)
 
         assert result["retcode"] == 0
         assert result["result"] == "check_success"
@@ -485,8 +482,8 @@ class TestMt5TradingClient:
         self,
         mock_mt5_import: ModuleType,
     ) -> None:
-        """Test send_or_check_order in real mode with success."""
-        client = Mt5TradingClient(mt5=mock_mt5_import, dry_run=False)
+        """Test _send_or_check_order in real mode with success."""
+        client = Mt5TradingClient(mt5=mock_mt5_import)
         mock_mt5_import.initialize.return_value = True
         client.initialize()
 
@@ -504,7 +501,7 @@ class TestMt5TradingClient:
             "result": "send_success",
         }
 
-        result = client.send_or_check_order(request)
+        result = client._send_or_check_order(request)
 
         assert result["retcode"] == 10009
         assert result["result"] == "send_success"
@@ -514,8 +511,8 @@ class TestMt5TradingClient:
         self,
         mock_mt5_import: ModuleType,
     ) -> None:
-        """Test send_or_check_order with trade disabled."""
-        client = Mt5TradingClient(mt5=mock_mt5_import, dry_run=False)
+        """Test _send_or_check_order with trade disabled."""
+        client = Mt5TradingClient(mt5=mock_mt5_import)
         mock_mt5_import.initialize.return_value = True
         client.initialize()
 
@@ -533,7 +530,7 @@ class TestMt5TradingClient:
             "comment": "Trade disabled",
         }
 
-        result = client.send_or_check_order(request)
+        result = client._send_or_check_order(request)
 
         assert result["retcode"] == 10017
 
@@ -541,8 +538,8 @@ class TestMt5TradingClient:
         self,
         mock_mt5_import: ModuleType,
     ) -> None:
-        """Test send_or_check_order with market closed."""
-        client = Mt5TradingClient(mt5=mock_mt5_import, dry_run=False)
+        """Test _send_or_check_order with market closed."""
+        client = Mt5TradingClient(mt5=mock_mt5_import)
         mock_mt5_import.initialize.return_value = True
         client.initialize()
 
@@ -560,7 +557,7 @@ class TestMt5TradingClient:
             "comment": "Market closed",
         }
 
-        result = client.send_or_check_order(request)
+        result = client._send_or_check_order(request)
 
         assert result["retcode"] == 10018
 
@@ -568,8 +565,8 @@ class TestMt5TradingClient:
         self,
         mock_mt5_import: ModuleType,
     ) -> None:
-        """Test send_or_check_order with failure."""
-        client = Mt5TradingClient(mt5=mock_mt5_import, dry_run=False)
+        """Test _send_or_check_order with failure."""
+        client = Mt5TradingClient(mt5=mock_mt5_import)
         mock_mt5_import.initialize.return_value = True
         client.initialize()
 
@@ -588,14 +585,14 @@ class TestMt5TradingClient:
         }
 
         with pytest.raises(Mt5TradingError, match=r"order_send\(\) failed and aborted"):
-            client.send_or_check_order(request)
+            client._send_or_check_order(request)
 
     def test_send_or_check_order_dry_run_failure(
         self,
         mock_mt5_import: ModuleType,
     ) -> None:
-        """Test send_or_check_order in dry run mode with failure."""
-        client = Mt5TradingClient(mt5=mock_mt5_import, dry_run=True)
+        """Test _send_or_check_order in dry run mode with failure."""
+        client = Mt5TradingClient(mt5=mock_mt5_import)
         mock_mt5_import.initialize.return_value = True
         client.initialize()
 
@@ -616,15 +613,15 @@ class TestMt5TradingClient:
         with pytest.raises(
             Mt5TradingError, match=r"order_check\(\) failed and aborted"
         ):
-            client.send_or_check_order(request)
+            client._send_or_check_order(request, dry_run=True)
 
     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)
+        """Test _send_or_check_order with dry_run parameter override."""
+        # Client initialized without dry_run
+        client = Mt5TradingClient(mt5=mock_mt5_import)
         mock_mt5_import.initialize.return_value = True
         client.initialize()
 
@@ -643,7 +640,7 @@ class TestMt5TradingClient:
         }
 
         # Override with dry_run=True
-        result = client.send_or_check_order(request, dry_run=True)
+        result = client._send_or_check_order(request, dry_run=True)
 
         assert result["retcode"] == 0
         assert result["result"] == "check_success"
@@ -655,9 +652,9 @@ class TestMt5TradingClient:
         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)
+        """Test _send_or_check_order with real mode override."""
+        # Client initialized without dry_run
+        client = Mt5TradingClient(mt5=mock_mt5_import)
         mock_mt5_import.initialize.return_value = True
         client.initialize()
 
@@ -676,7 +673,7 @@ class TestMt5TradingClient:
         }
 
         # Override with dry_run=False
-        result = client.send_or_check_order(request, dry_run=False)
+        result = client._send_or_check_order(request, dry_run=False)
 
         assert result["retcode"] == 10009
         assert result["result"] == "send_success"
@@ -684,6 +681,52 @@ class TestMt5TradingClient:
         mock_mt5_import.order_send.assert_called_once_with(request)
         mock_mt5_import.order_check.assert_not_called()
 
+    def test_place_market_order(
+        self,
+        mock_mt5_import: ModuleType,
+    ) -> None:
+        """Test place_market_order method."""
+        client = Mt5TradingClient(mt5=mock_mt5_import)
+        mock_mt5_import.initialize.return_value = True
+        client.initialize()
+
+        # Mock MT5 constants
+        mock_mt5_import.ORDER_TYPE_BUY = 0
+        mock_mt5_import.ORDER_FILLING_IOC = 1
+        mock_mt5_import.ORDER_TIME_GTC = 0
+        mock_mt5_import.TRADE_ACTION_DEAL = 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,
+            "deal": 123456,
+            "order": 789012,
+        }
+
+        result = client.place_market_order(
+            symbol="EURUSD",
+            volume=0.1,
+            order_side="BUY",
+            order_filling_mode="IOC",
+            order_time_mode="GTC",
+        )
+
+        assert result["retcode"] == 10009
+        assert result["deal"] == 123456
+        assert result["order"] == 789012
+
+        # Verify the request was built correctly
+        expected_request = {
+            "action": 1,  # TRADE_ACTION_DEAL
+            "symbol": "EURUSD",
+            "volume": 0.1,
+            "type": 0,  # ORDER_TYPE_BUY
+            "type_filling": 1,  # ORDER_FILLING_IOC
+            "type_time": 0,  # ORDER_TIME_GTC
+        }
+        mock_mt5_import.order_send.assert_called_once_with(expected_request)
+
     def test_order_filling_mode_constants(
         self,
         mock_mt5_import: ModuleType,
@@ -751,7 +794,7 @@ class TestMt5TradingClient:
         mock_position_sell: MockPositionInfo,
     ) -> None:
         """Test _fetch_and_close_position with dry_run parameter."""
-        client = Mt5TradingClient(mt5=mock_mt5_import, dry_run=False)
+        client = Mt5TradingClient(mt5=mock_mt5_import)
         mock_mt5_import.initialize.return_value = True
         client.initialize()
 
@@ -780,9 +823,9 @@ class TestMt5TradingClient:
         mock_mt5_import: ModuleType,
         mock_position_buy: MockPositionInfo,
     ) -> None:
-        """Test _fetch_and_close_position inherits instance dry_run if not given."""
-        # Client initialized with dry_run=True
-        client = Mt5TradingClient(mt5=mock_mt5_import, dry_run=True)
+        """Test _fetch_and_close_position does not inherit dry_run from instance."""
+        # Client initialized without dry_run
+        client = Mt5TradingClient(mt5=mock_mt5_import)
         mock_mt5_import.initialize.return_value = True
         client.initialize()
 
@@ -794,8 +837,8 @@ class TestMt5TradingClient:
             "result": "check_success",
         }
 
-        # Call without specifying dry_run - should use instance's dry_run=True
-        result = client._fetch_and_close_position(symbol="EURUSD")
+        # Call with dry_run=True explicitly
+        result = client._fetch_and_close_position(symbol="EURUSD", dry_run=True)
 
         assert len(result) == 1
         assert result[0]["retcode"] == 0
@@ -1300,3 +1343,421 @@ class TestMt5TradingClient:
 
         # Verify order_calc_margin was called twice (ask and bid)
         assert mock_mt5_import.order_calc_margin.call_count == 2
+
+    def test_calculate_new_position_margin_ratio_no_equity(
+        self, mock_mt5_import: ModuleType
+    ) -> None:
+        """Test calculating margin ratio when account has no equity."""
+        client = Mt5TradingClient(mt5=mock_mt5_import)
+        mock_mt5_import.initialize.return_value = True
+        client.initialize()
+
+        # Mock account info with zero equity
+        mock_mt5_import.account_info.return_value._asdict.return_value = {
+            "equity": 0.0,
+        }
+
+        result = client.calculate_new_position_margin_ratio(
+            symbol="EURUSD", new_side="BUY", new_volume=0.1
+        )
+
+        assert result == 0.0
+
+    def test_calculate_new_position_margin_ratio_buy_position(
+        self, mock_mt5_import: ModuleType, mocker: MockerFixture
+    ) -> None:
+        """Test calculating margin ratio for a new buy position."""
+        client = Mt5TradingClient(mt5=mock_mt5_import)
+        mock_mt5_import.initialize.return_value = True
+        client.initialize()
+
+        # Mock account info
+        mock_mt5_import.account_info.return_value._asdict.return_value = {
+            "equity": 10000.0,
+        }
+
+        # Mock existing positions
+        mock_position = mocker.MagicMock()
+        mock_position._asdict.return_value = {
+            "ticket": 12345,
+            "symbol": "EURUSD",
+            "volume": 0.1,
+            "type": 0,  # POSITION_TYPE_BUY
+            "time": 1234567890,
+            "price_open": 1.2,
+            "price_current": 1.205,
+            "profit": 5.0,
+            "sl": 0.0,
+            "tp": 0.0,
+            "identifier": 12345,
+            "reason": 0,
+            "swap": 0.0,
+            "magic": 0,
+            "comment": "test",
+            "external_id": "",
+        }
+        mock_mt5_import.positions_get.return_value = [mock_position]
+
+        # Mock symbol tick info
+        mock_mt5_import.symbol_info_tick.return_value._asdict.return_value = {
+            "time": pd.Timestamp("2009-02-14 00:31:30"),
+            "ask": 1.1002,
+            "bid": 1.1000,
+        }
+
+        # Mock order calc margin
+        mock_mt5_import.order_calc_margin.return_value = 1000.0
+
+        result = client.calculate_new_position_margin_ratio(
+            symbol="EURUSD", new_side="BUY", new_volume=0.1
+        )
+
+        # Should return (new_margin + current_margin) / equity
+        # current_margin = 100.0 (from position), new_margin = 1000.0
+        expected_ratio = abs((1000.0 + 100.0) / 10000.0)
+        assert result == expected_ratio
+
+    def test_calculate_new_position_margin_ratio_sell_position(
+        self, mock_mt5_import: ModuleType
+    ) -> None:
+        """Test calculating margin ratio for a new sell position."""
+        client = Mt5TradingClient(mt5=mock_mt5_import)
+        mock_mt5_import.initialize.return_value = True
+        client.initialize()
+
+        # Mock account info
+        mock_mt5_import.account_info.return_value._asdict.return_value = {
+            "equity": 10000.0,
+        }
+
+        # Mock empty positions
+        mock_mt5_import.positions_get.return_value = []
+
+        # Mock symbol tick info
+        mock_mt5_import.symbol_info_tick.return_value._asdict.return_value = {
+            "time": pd.Timestamp("2009-02-14 00:31:30"),
+            "ask": 1.1002,
+            "bid": 1.1000,
+        }
+
+        # Mock order calc margin
+        mock_mt5_import.order_calc_margin.return_value = 1000.0
+
+        result = client.calculate_new_position_margin_ratio(
+            symbol="EURUSD", new_side="SELL", new_volume=0.1
+        )
+
+        # Should return abs(-new_margin / equity) for sell
+        expected_ratio = abs(-1000.0 / 10000.0)
+        assert result == expected_ratio
+
+    def test_calculate_new_position_margin_ratio_zero_volume(
+        self, mock_mt5_import: ModuleType
+    ) -> None:
+        """Test calculating margin ratio with zero volume."""
+        client = Mt5TradingClient(mt5=mock_mt5_import)
+        mock_mt5_import.initialize.return_value = True
+        client.initialize()
+
+        # Mock account info
+        mock_mt5_import.account_info.return_value._asdict.return_value = {
+            "equity": 10000.0,
+        }
+
+        # Mock empty positions
+        mock_mt5_import.positions_get.return_value = []
+
+        # Mock symbol tick info
+        mock_mt5_import.symbol_info_tick.return_value._asdict.return_value = {
+            "time": pd.Timestamp("2009-02-14 00:31:30"),
+            "ask": 1.1002,
+            "bid": 1.1000,
+        }
+
+        result = client.calculate_new_position_margin_ratio(
+            symbol="EURUSD", new_side="BUY", new_volume=0
+        )
+
+        # Should return 0 since new_volume is 0
+        assert result == 0.0
+
+    def test_calculate_new_position_margin_ratio_invalid_side(
+        self, mock_mt5_import: ModuleType
+    ) -> None:
+        """Test calculating margin ratio with invalid side."""
+        client = Mt5TradingClient(mt5=mock_mt5_import)
+        mock_mt5_import.initialize.return_value = True
+        client.initialize()
+
+        # Mock account info
+        mock_mt5_import.account_info.return_value._asdict.return_value = {
+            "equity": 10000.0,
+        }
+
+        # Mock empty positions
+        mock_mt5_import.positions_get.return_value = []
+
+        # Mock symbol tick info
+        mock_mt5_import.symbol_info_tick.return_value._asdict.return_value = {
+            "time": pd.Timestamp("2009-02-14 00:31:30"),
+            "ask": 1.1002,
+            "bid": 1.1000,
+        }
+
+        result = client.calculate_new_position_margin_ratio(
+            symbol="EURUSD", new_side=None, new_volume=0.1
+        )
+
+        # Should return 0 since side is invalid
+        assert result == 0.0
+
+    def test_update_sltp_for_open_positions(self, mock_mt5_import: ModuleType) -> None:
+        """Test update_sltp_for_open_positions method."""
+        client = Mt5TradingClient(mt5=mock_mt5_import)
+        mock_mt5_import.initialize.return_value = True
+        client.initialize()
+
+        # Mock MT5 constants
+        mock_mt5_import.TRADE_ACTION_SLTP = 6
+
+        # Mock symbol info
+        mock_mt5_import.symbol_info.return_value._asdict.return_value = {
+            "digits": 5,
+        }
+
+        # Mock positions for the symbol
+        mock_position = MockPositionInfo(
+            ticket=123456,
+            time=123456789,
+            type=0,  # buy
+            magic=0,
+            identifier=123456,
+            reason=0,
+            volume=0.1,
+            price_open=1.1000,
+            sl=1.0900,
+            tp=1.1100,
+            price_current=1.1050,
+            swap=0.0,
+            profit=50.0,
+            symbol="EURUSD",
+            comment="test",
+            external_id="",
+        )
+        mock_mt5_import.positions_get.return_value = [mock_position]
+
+        # 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,
+            "deal": 0,
+            "order": 789012,
+        }
+
+        result = client.update_sltp_for_open_positions(
+            symbol="EURUSD",
+            tickets=[123456],
+            stop_loss=1.0950,
+            take_profit=1.1050,
+        )
+
+        # Now returns a list of dictionaries
+        assert isinstance(result, list)
+        assert len(result) == 1
+        assert result[0]["retcode"] == 10009
+        assert result[0]["order"] == 789012
+
+    def test_update_sltp_for_open_positions_no_positions(
+        self, mock_mt5_import: ModuleType
+    ) -> None:
+        """Test update_sltp_for_open_positions when no positions exist for symbol."""
+        client = Mt5TradingClient(mt5=mock_mt5_import)
+        mock_mt5_import.initialize.return_value = True
+        client.initialize()
+
+        # Mock empty positions result
+        mock_mt5_import.positions_get.return_value = []
+
+        result = client.update_sltp_for_open_positions(
+            symbol="EURUSD",
+            tickets=[123456],
+            stop_loss=1.0950,
+            take_profit=1.1050,
+        )
+
+        # Should return empty list and log warning
+        assert result == []
+        # Verify positions_get was called with correct symbol
+        mock_mt5_import.positions_get.assert_called_with(symbol="EURUSD")
+
+    def test_update_sltp_for_open_positions_no_matching_tickets(
+        self, mock_mt5_import: ModuleType
+    ) -> None:
+        """Test update_sltp_for_open_positions when positions exist but no tickets match."""  # noqa: E501
+        client = Mt5TradingClient(mt5=mock_mt5_import)
+        mock_mt5_import.initialize.return_value = True
+        client.initialize()
+
+        # Mock MT5 constants
+        mock_mt5_import.TRADE_ACTION_SLTP = 6
+
+        # Mock symbol info
+        mock_mt5_import.symbol_info.return_value._asdict.return_value = {
+            "digits": 5,
+        }
+
+        # Mock positions with different tickets
+        mock_position = MockPositionInfo(
+            ticket=999999,  # Different ticket
+            time=123456789,
+            type=0,  # buy
+            magic=0,
+            identifier=999999,
+            reason=0,
+            volume=0.1,
+            price_open=1.1000,
+            sl=1.0900,
+            tp=1.1100,
+            price_current=1.1050,
+            swap=0.0,
+            profit=50.0,
+            symbol="EURUSD",
+            comment="test",
+            external_id="",
+        )
+        mock_mt5_import.positions_get.return_value = [mock_position]
+
+        result = client.update_sltp_for_open_positions(
+            symbol="EURUSD",
+            tickets=[123456],  # This ticket doesn't exist
+            stop_loss=1.0950,
+            take_profit=1.1050,
+        )
+
+        # Should return empty list and log warning
+        assert result == []
+
+    def test_update_sltp_for_open_positions_same_sltp_values(
+        self, mock_mt5_import: ModuleType
+    ) -> None:
+        """Test update_sltp_for_open_positions when SL/TP values are already the same."""  # noqa: E501
+        client = Mt5TradingClient(mt5=mock_mt5_import)
+        mock_mt5_import.initialize.return_value = True
+        client.initialize()
+
+        # Mock MT5 constants
+        mock_mt5_import.TRADE_ACTION_SLTP = 6
+
+        # Mock symbol info
+        mock_mt5_import.symbol_info.return_value._asdict.return_value = {
+            "digits": 5,
+        }
+
+        # Mock positions with same SL/TP as requested
+        mock_position = MockPositionInfo(
+            ticket=123456,
+            time=123456789,
+            type=0,  # buy
+            magic=0,
+            identifier=123456,
+            reason=0,
+            volume=0.1,
+            price_open=1.1000,
+            sl=1.0950,  # Same as requested stop_loss
+            tp=1.1050,  # Same as requested take_profit
+            price_current=1.1050,
+            swap=0.0,
+            profit=50.0,
+            symbol="EURUSD",
+            comment="test",
+            external_id="",
+        )
+        mock_mt5_import.positions_get.return_value = [mock_position]
+
+        result = client.update_sltp_for_open_positions(
+            symbol="EURUSD",
+            tickets=[123456],
+            stop_loss=1.0950,  # Same as position's sl
+            take_profit=1.1050,  # Same as position's tp
+        )
+
+        # Should return empty list since no update is needed
+        assert result == []
+        # Verify order_send was NOT called
+        mock_mt5_import.order_send.assert_not_called()
+
+    def test_update_sltp_for_open_positions_no_tickets(
+        self, mock_mt5_import: ModuleType
+    ) -> None:
+        """Test update_sltp_for_open_positions without specifying tickets."""
+        client = Mt5TradingClient(mt5=mock_mt5_import)
+        mock_mt5_import.initialize.return_value = True
+        client.initialize()
+
+        # Mock MT5 constants
+        mock_mt5_import.TRADE_ACTION_SLTP = 6
+
+        # Mock symbol info
+        mock_mt5_import.symbol_info.return_value._asdict.return_value = {
+            "digits": 5,
+        }
+
+        # Mock positions for the symbol
+        mock_position1 = MockPositionInfo(
+            ticket=123456,
+            time=123456789,
+            type=0,  # buy
+            magic=0,
+            identifier=123456,
+            reason=0,
+            volume=0.1,
+            price_open=1.1000,
+            sl=1.0900,
+            tp=1.1100,
+            price_current=1.1050,
+            swap=0.0,
+            profit=50.0,
+            symbol="EURUSD",
+            comment="test",
+            external_id="",
+        )
+        mock_position2 = MockPositionInfo(
+            ticket=654321,
+            time=123456789,
+            type=1,  # sell
+            magic=0,
+            identifier=654321,
+            reason=0,
+            volume=0.2,
+            price_open=1.1050,
+            sl=1.1150,
+            tp=1.0950,
+            price_current=1.1050,
+            swap=0.0,
+            profit=-20.0,
+            symbol="EURUSD",
+            comment="test2",
+            external_id="",
+        )
+        mock_mt5_import.positions_get.return_value = [mock_position1, mock_position2]
+
+        # 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,
+            "deal": 0,
+            "order": 789012,
+        }
+
+        # Call without tickets to update all positions
+        result = client.update_sltp_for_open_positions(
+            symbol="EURUSD",
+            tickets=None,  # No tickets specified
+            stop_loss=1.0950,
+            take_profit=1.1050,
+        )
+
+        # Should return results for both positions
+        assert isinstance(result, list)
+        assert len(result) == 2
+        assert all(r["retcode"] == 10009 for r in result)

{pdmt5-0.1.4 → pdmt5-0.1.5}/uv.lock

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