pdmt5 0.1.1__tar.gz → 0.1.2__tar.gz

{pdmt5-0.1.1 → pdmt5-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pdmt5
-Version: 0.1.1
+Version: 0.1.2
 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.1.1 → pdmt5-0.1.2}/pdmt5/trading.py

@@ -32,6 +32,7 @@ class Mt5TradingClient(Mt5DataClient):
     def close_open_positions(
         self,
         symbols: str | list[str] | tuple[str, ...] | None = None,
+        dry_run: bool | None = None,
         **kwargs: Any,  # noqa: ANN401
     ) -> dict[str, list[dict[str, Any]]]:
         """Close all open positions for specified symbols.
@@ -39,6 +40,8 @@ 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.
             **kwargs: Additional keyword arguments for request parameters.
 
         Returns:
@@ -53,18 +56,22 @@ class Mt5TradingClient(Mt5DataClient):
             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
+            s: self._fetch_and_close_position(symbol=s, dry_run=dry_run, **kwargs)
+            for s in symbol_list
         }
 
     def _fetch_and_close_position(
         self,
         symbol: str | None = None,
+        dry_run: bool | None = None,
         **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.
             **kwargs: Additional keyword arguments for request parameters.
 
         Returns:
@@ -96,6 +103,7 @@ class Mt5TradingClient(Mt5DataClient):
                         "position": p["ticket"],
                         **kwargs,
                     },
+                    dry_run=dry_run,
                 )
                 for p in positions_dict
             ]

{pdmt5-0.1.1 → pdmt5-0.1.2}/pyproject.toml

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

@@ -228,6 +228,90 @@ class TestMt5TradingClient:
         assert result["EURUSD"][0]["retcode"] == 10009
         mock_mt5_import.order_send.assert_called_once()
 
+    def test_close_position_with_positions_dry_run(
+        self,
+        mock_mt5_import: ModuleType,
+        mock_position_buy: MockPositionInfo,
+    ) -> None:
+        """Test close_position with existing positions in dry run mode."""
+        client = Mt5TradingClient(mt5=mock_mt5_import, dry_run=True)
+        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_check.return_value.retcode = 0
+        mock_mt5_import.order_check.return_value._asdict.return_value = {
+            "retcode": 0,
+            "result": "check_success",
+        }
+
+        result = client.close_open_positions("EURUSD")
+
+        assert len(result["EURUSD"]) == 1
+        assert result["EURUSD"][0]["retcode"] == 0
+        mock_mt5_import.order_check.assert_called_once()
+        mock_mt5_import.order_send.assert_not_called()
+
+    def test_close_position_with_dry_run_override(
+        self,
+        mock_mt5_import: ModuleType,
+        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)
+        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_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.close_open_positions("EURUSD", dry_run=True)
+
+        assert len(result["EURUSD"]) == 1
+        assert result["EURUSD"][0]["retcode"] == 0
+        # Should use order_check instead of order_send
+        mock_mt5_import.order_check.assert_called_once()
+        mock_mt5_import.order_send.assert_not_called()
+
+    def test_close_position_with_real_mode_override(
+        self,
+        mock_mt5_import: ModuleType,
+        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)
+        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": "send_success",
+        }
+
+        # Override with dry_run=False
+        result = client.close_open_positions("EURUSD", dry_run=False)
+
+        assert len(result["EURUSD"]) == 1
+        assert result["EURUSD"][0]["retcode"] == 10009
+        # Should use order_send instead of order_check
+        mock_mt5_import.order_send.assert_called_once()
+        mock_mt5_import.order_check.assert_not_called()
+
     def test_close_open_positions_all_symbols(
         self,
         mock_mt5_import: ModuleType,
@@ -319,6 +403,39 @@ class TestMt5TradingClient:
         assert call_args["comment"] == "custom_close"
         assert call_args["magic"] == 12345
 
+    def test_close_open_positions_with_kwargs_and_dry_run(
+        self,
+        mock_mt5_import: ModuleType,
+        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)
+        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_check.return_value.retcode = 0
+        mock_mt5_import.order_check.return_value._asdict.return_value = {
+            "retcode": 0,
+            "result": "check_success",
+        }
+
+        # Pass custom kwargs with dry_run override
+        result = client.close_open_positions(
+            "EURUSD", dry_run=True, comment="custom_close", magic=12345
+        )
+
+        assert len(result["EURUSD"]) == 1
+        assert result["EURUSD"][0]["retcode"] == 0
+
+        # Check that kwargs were passed through to order_check
+        call_args = mock_mt5_import.order_check.call_args[0][0]
+        assert call_args["comment"] == "custom_close"
+        assert call_args["magic"] == 12345
+        mock_mt5_import.order_send.assert_not_called()
+
     def test_send_or_check_order_dry_run_success(
         self,
         mock_mt5_import: ModuleType,
@@ -611,6 +728,64 @@ class TestMt5TradingClient:
         call_args = mock_mt5_import.order_send.call_args[0][0]
         assert call_args["type"] == mock_mt5_import.ORDER_TYPE_BUY
 
+    def test_fetch_and_close_position_with_dry_run(
+        self,
+        mock_mt5_import: ModuleType,
+        mock_position_buy: MockPositionInfo,
+        mock_position_sell: MockPositionInfo,
+    ) -> None:
+        """Test _fetch_and_close_position with dry_run parameter."""
+        client = Mt5TradingClient(mt5=mock_mt5_import, dry_run=False)
+        mock_mt5_import.initialize.return_value = True
+        client.initialize()
+
+        # Test with multiple positions and dry_run override
+        mock_mt5_import.positions_get.return_value = [
+            mock_position_buy,
+            mock_position_sell,
+        ]
+
+        mock_mt5_import.order_check.return_value.retcode = 0
+        mock_mt5_import.order_check.return_value._asdict.return_value = {
+            "retcode": 0,
+            "result": "check_success",
+        }
+
+        # Call internal method directly with dry_run=True
+        result = client._fetch_and_close_position(symbol="EURUSD", dry_run=True)
+
+        assert len(result) == 2
+        assert all(r["retcode"] == 0 for r in result)
+        assert mock_mt5_import.order_check.call_count == 2
+        mock_mt5_import.order_send.assert_not_called()
+
+    def test_fetch_and_close_position_inherits_instance_dry_run(
+        self,
+        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)
+        mock_mt5_import.initialize.return_value = True
+        client.initialize()
+
+        mock_mt5_import.positions_get.return_value = [mock_position_buy]
+
+        mock_mt5_import.order_check.return_value.retcode = 0
+        mock_mt5_import.order_check.return_value._asdict.return_value = {
+            "retcode": 0,
+            "result": "check_success",
+        }
+
+        # Call without specifying dry_run - should use instance's dry_run=True
+        result = client._fetch_and_close_position(symbol="EURUSD")
+
+        assert len(result) == 1
+        assert result[0]["retcode"] == 0
+        mock_mt5_import.order_check.assert_called_once()
+        mock_mt5_import.order_send.assert_not_called()
+
     def test_calculate_minimum_order_margins_success(
         self,
         mock_mt5_import: ModuleType,

{pdmt5-0.1.1 → pdmt5-0.1.2}/uv.lock

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