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

pdmt5/trading.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 from datetime import timedelta
+from math import floor
 from typing import TYPE_CHECKING, Any, Literal
 
 from pydantic import ConfigDict, Field
@@ -31,12 +32,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 +44,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 +66,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 +90,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 +110,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 +128,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,41 +154,170 @@ class Mt5TradingClient(Mt5DataClient):
             error_message = f"{order_func}() failed and aborted. <= `{comment}`"
             raise Mt5TradingError(error_message)
 
-    def calculate_minimum_order_margins(self, symbol: str) -> dict[str, float]:
-        """Calculate minimum order margins for a given symbol.
+    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 which to calculate minimum order margins.
+            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 margin information.
+            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,
+        )
 
-        Raises:
-            Mt5TradingError: If margin calculation fails.
+    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_margin(
+        self,
+        symbol: str,
+        order_side: Literal["BUY", "SELL"],
+    ) -> dict[str, float]:
+        """Calculate the minimum order margins for a given symbol.
+
+        Args:
+            symbol: Symbol for which to calculate the minimum order margins.
+            order_side: Optional side of the order, either "BUY" or "SELL".
+
+        Returns:
+            Dictionary with minimum volume and margin for the specified order side.
         """
         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.order_calc_margin(
-            action=self.mt5.ORDER_TYPE_BUY,
+        return {
+            "volume": symbol_info["volume_min"],
+            "margin": self.order_calc_margin(
+                action=getattr(self.mt5, f"ORDER_TYPE_{order_side.upper()}"),
+                symbol=symbol,
+                volume=symbol_info["volume_min"],
+                price=(
+                    symbol_info_tick["bid"]
+                    if order_side == "SELL"
+                    else symbol_info_tick["ask"]
+                ),
+            ),
+        }
+
+    def calculate_volume_by_margin(
+        self,
+        symbol: str,
+        margin: float,
+        order_side: Literal["BUY", "SELL"],
+    ) -> float:
+        """Calculate volume based on margin for a given symbol and order side.
+
+        Args:
+            symbol: Symbol for which to calculate the volume.
+            margin: Margin amount to use for the calculation.
+            order_side: Side of the order, either "BUY" or "SELL".
+
+        Returns:
+            Calculated volume as a float.
+        """
+        min_order_margin_dict = self.calculate_minimum_order_margin(
             symbol=symbol,
-            volume=symbol_info["volume_min"],
-            price=symbol_info_tick["ask"],
+            order_side=order_side,
         )
-        min_bid_order_margin = self.order_calc_margin(
-            action=self.mt5.ORDER_TYPE_SELL,
-            symbol=symbol,
-            volume=symbol_info["volume_min"],
-            price=symbol_info_tick["bid"],
+        return (
+            floor(margin / min_order_margin_dict["margin"])
+            * min_order_margin_dict["volume"]
         )
-        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)
 
     def calculate_spread_ratio(
         self,
@@ -369,3 +493,50 @@ class Mt5TradingClient(Mt5DataClient):
                 )
                 .drop(columns=["buy_i", "sell_i", "sign", "underlier_increase_ratio"])
             )
+
+    def calculate_new_position_margin_ratio(
+        self,
+        symbol: str,
+        new_position_side: Literal["BUY", "SELL"] | None = None,
+        new_position_volume: float = 0,
+    ) -> float:
+        """Calculate the margin ratio for a new position.
+
+        Args:
+            symbol: Symbol for which to calculate the margin ratio.
+            new_position_side: Side of the new position, either "BUY" or "SELL".
+            new_position_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 not (new_position_side and new_position_volume):
+                new_signed_margin = 0
+            elif new_position_side.upper() == "BUY":
+                new_signed_margin = self.order_calc_margin(
+                    action=self.mt5.ORDER_TYPE_BUY,
+                    symbol=symbol,
+                    volume=new_position_volume,
+                    price=symbol_info_tick["ask"],
+                )
+            elif new_position_side.upper() == "SELL":
+                new_signed_margin = -self.order_calc_margin(
+                    action=self.mt5.ORDER_TYPE_SELL,
+                    symbol=symbol,
+                    volume=new_position_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.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pdmt5
-Version: 0.1.4
+Version: 0.1.6
 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
 
@@ -43,6 +42,8 @@ Pandas-based data handler for MetaTrader 5
 - 🚀 **Context Manager Support**: Clean initialization and cleanup with `with` statements
 - 📈 **Time Series Ready**: OHLCV data with proper datetime indexing
 - 🛡️ **Robust Error Handling**: Custom exceptions with detailed MT5 error information
+- 💰 **Advanced Trading Operations**: Position management, margin calculations, and risk analysis tools
+- 🧪 **Dry Run Mode**: Test trading strategies without executing real trades
 
 ## Requirements
 
@@ -195,10 +196,13 @@ 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
-- **Market Analysis**:
-  - `calculate_minimum_order_margins()` - Calculate minimum required margins for buy/sell orders
+  - `place_market_order()` - Place market orders with configurable side, volume, and execution modes
+  - `update_sltp_for_open_positions()` - Modify stop loss and take profit levels for open positions
+- **Margin Calculations**:
+  - `calculate_minimum_order_margin()` - Calculate minimum required margin for a specific order side
+  - `calculate_volume_by_margin()` - Calculate maximum volume for given margin amount
   - `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 +292,52 @@ 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 open positions
+    update_results = trader.update_sltp_for_open_positions(
+        symbol="EURUSD",
+        stop_loss=1.0950,   # New stop loss
+        take_profit=1.1050  # New take profit
+    )
+    for result in update_results:
+        print(f"Position updated: {result['retcode']}")
+
+    # Calculate margin ratio for a new position
+    margin_ratio = trader.calculate_new_position_margin_ratio(
+        symbol="EURUSD",
+        new_position_side="SELL",
+        new_position_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
@@ -310,10 +348,18 @@ with Mt5TradingClient(config=config) as trader:
     spread_ratio = trader.calculate_spread_ratio("EURUSD")
     print(f"EURUSD spread ratio: {spread_ratio:.5f}")
 
-    # Get minimum order margins
-    margins = trader.calculate_minimum_order_margins("EURUSD")
-    print(f"Minimum ask margin: {margins['ask']}")
-    print(f"Minimum bid margin: {margins['bid']}")
+    # Get minimum order margin for BUY and SELL
+    buy_margin = trader.calculate_minimum_order_margin("EURUSD", "BUY")
+    sell_margin = trader.calculate_minimum_order_margin("EURUSD", "SELL")
+    print(f"Minimum BUY margin: {buy_margin['margin']} (volume: {buy_margin['volume']})")
+    print(f"Minimum SELL margin: {sell_margin['margin']} (volume: {sell_margin['volume']})")
+    
+    # Calculate volume by margin
+    available_margin = 1000.0
+    max_buy_volume = trader.calculate_volume_by_margin("EURUSD", available_margin, "BUY")
+    max_sell_volume = trader.calculate_volume_by_margin("EURUSD", available_margin, "SELL")
+    print(f"Max BUY volume for ${available_margin}: {max_buy_volume}")
+    print(f"Max SELL volume for ${available_margin}: {max_sell_volume}")
 
     # Get recent OHLC data with custom timeframe
     rates_df = trader.fetch_latest_rates_as_df(

{pdmt5-0.1.4.dist-info → pdmt5-0.1.6.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=GOOYsbsjKtp26dw1VB6siZ1luBttD8cv-KNZi6pPUEs,20107
 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.6.dist-info/METADATA,sha256=cBYUp4lIyQuw7aRN7dphpgtejgW5jamAvYImYQiQS9o,16824
+pdmt5-0.1.6.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+pdmt5-0.1.6.dist-info/licenses/LICENSE,sha256=iABrdaUGOBWLYotFupB_PGe8arV5o7rVhn-_vK6P704,1073
+pdmt5-0.1.6.dist-info/RECORD,,