pdmt5 0.1.4__py3-none-any.whl → 0.1.5__py3-none-any.whl

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.dist-info → pdmt5-0.1.5.dist-info}/METADATA

@@ -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.dist-info → pdmt5-0.1.5.dist-info}/RECORD

@@ -1,9 +1,9 @@
 pdmt5/__init__.py,sha256=QbSFrsi7_bgFzb-ma4DmmUjR90UvrqKMnRZq1wPRmoI,446
 pdmt5/dataframe.py,sha256=rUWtR23hrXBdBqzJhbOlIemNy73RrjSTZZJUhwoL6io,38084
 pdmt5/mt5.py,sha256=KgxHapIrh5b4L0wIOAQIjfXNZafalihbFrh9fhYHmrI,32254
-pdmt5/trading.py,sha256=qZFORyBlSQNp_DQPeuEIqFHPAnVrCJK_6GhFRc5vDR8,13683
+pdmt5/trading.py,sha256=TJjxq2PP2eIRM8pe4G0DzxLkLjOFR-0ZV0rpzDwl-TU,19488
 pdmt5/utils.py,sha256=Ll5Q3OE5h1A_sZ_qVEnOPGniFlT6_MmHfuu0zqeLdeU,3913
-pdmt5-0.1.4.dist-info/METADATA,sha256=XFIW5O6a7bePMxnDVc7MG6mnkXwNTY_53_mVb_BJxnY,14678
-pdmt5-0.1.4.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-pdmt5-0.1.4.dist-info/licenses/LICENSE,sha256=iABrdaUGOBWLYotFupB_PGe8arV5o7rVhn-_vK6P704,1073
-pdmt5-0.1.4.dist-info/RECORD,,
+pdmt5-0.1.5.dist-info/METADATA,sha256=YjTgWZTyhoLtzbLii57WYM5UajB0pix15sM7CzhjgwY,16085
+pdmt5-0.1.5.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+pdmt5-0.1.5.dist-info/licenses/LICENSE,sha256=iABrdaUGOBWLYotFupB_PGe8arV5o7rVhn-_vK6P704,1073
+pdmt5-0.1.5.dist-info/RECORD,,