pdmt5 0.1.0__tar.gz → 0.1.2__tar.gz

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

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

@@ -29,7 +29,6 @@ class Mt5Config(BaseModel):
     timeout: int | None = Field(
         default=None, description="Connection timeout in milliseconds"
     )
-    portable: bool | None = Field(default=None, description="Use portable mode")
 
 
 class Mt5DataClient(Mt5Client):
@@ -51,14 +50,13 @@ class Mt5DataClient(Mt5Client):
         description="Number of retry attempts for connection initialization",
     )
 
-    def initialize_mt5(
+    def initialize_and_login_mt5(
         self,
         path: str | None = None,
         login: int | None = None,
         password: str | None = None,
         server: str | None = None,
         timeout: int | None = None,
-        portable: bool | None = None,
     ) -> None:
         """Initialize MetaTrader5 connection with retry logic.
 
@@ -70,18 +68,16 @@ class Mt5DataClient(Mt5Client):
             password: Account password (overrides config).
             server: Server name (overrides config).
             timeout: Connection timeout (overrides config).
-            portable: Use portable mode (overrides config).
 
         Raises:
             Mt5RuntimeError: If initialization fails after retries.
         """
-        initialize_kwargs = {
-            "path": path or self.config.path,
+        path = path or self.config.path
+        login_kwargs = {
             "login": login or self.config.login,
             "password": password or self.config.password,
             "server": server or self.config.server,
             "timeout": timeout or self.config.timeout,
-            "portable": portable if portable is not None else self.config.portable,
         }
         for i in range(1 + max(0, self.retry_count)):
             if i:
@@ -91,11 +87,12 @@ class Mt5DataClient(Mt5Client):
                     self.retry_count,
                 )
                 time.sleep(i)
-            if self.initialize(**initialize_kwargs):  # type: ignore[reportArgumentType]
-                self.logger.info("MT5 initialization successful.")
+            if self.initialize(path=path, **login_kwargs) and (
+                (not login_kwargs["login"]) or self.login(**login_kwargs)
+            ):
                 return
         error_message = (
-            f"MT5 initialization failed after {self.retry_count} retries:"
+            f"MT5 initialize and login failed after {self.retry_count} retries:"
             f" {self.last_error()}"
         )
         raise Mt5RuntimeError(error_message)

{pdmt5-0.1.0 → pdmt5-0.1.2}/pdmt5/mt5.py

@@ -106,7 +106,6 @@ class Mt5Client(BaseModel):
         password: str | None = None,
         server: str | None = None,
         timeout: int | None = None,
-        portable: bool | None = None,
     ) -> bool:
         """Establish a connection with the MetaTrader 5 terminal.
 
@@ -116,7 +115,6 @@ class Mt5Client(BaseModel):
             password: Trading account password.
             server: Trade server address.
             timeout: Connection timeout in milliseconds.
-            portable: Use portable mode.
 
         Returns:
             True if successful, False otherwise.
@@ -135,7 +133,6 @@ class Mt5Client(BaseModel):
                         "password": password,
                         "server": server,
                         "timeout": timeout,
-                        "portable": portable,
                     }.items()
                     if v is not None
                 },

{pdmt5-0.1.0 → 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.0 → pdmt5-0.1.2}/pyproject.toml

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

@@ -397,7 +397,6 @@ class TestMt5Config:
         assert config.password is None
         assert config.server is None
         assert config.timeout is None
-        assert config.portable is None
 
     def test_custom_config(self) -> None:
         """Test custom configuration."""
@@ -406,13 +405,11 @@ class TestMt5Config:
             password="secret",
             server="Demo-Server",
             timeout=30000,
-            portable=True,
         )
         assert config.login == 123456
         assert config.password == "secret"  # noqa: S105
         assert config.server == "Demo-Server"
         assert config.timeout == 30000
-        assert config.portable is True
 
     def test_config_immutable(self) -> None:
         """Test that config is immutable."""
@@ -478,11 +475,11 @@ class TestMt5DataClient:
 
         client = Mt5DataClient(mt5=mock_mt5_import, retry_count=0)
         pattern = (
-            r"MT5 initialization failed after 0 retries: "
+            r"MT5 initialize and login failed after 0 retries: "
             r"\(1, 'Connection failed'\)"
         )
         with pytest.raises(Mt5RuntimeError, match=pattern):
-            client.initialize_mt5()
+            client.initialize_and_login_mt5()
 
     def test_initialize_already_initialized(
         self, mock_mt5_import: ModuleType | None
@@ -1864,7 +1861,7 @@ class TestMt5DataClientRetryLogic:
         mock_mt5_import.last_error.return_value = (1, "Test error")
 
         # Should succeed on third attempt
-        client.initialize_mt5()
+        client.initialize_and_login_mt5()
 
         assert mock_mt5_import.initialize.call_count == 3
 
@@ -1884,7 +1881,7 @@ class TestMt5DataClientRetryLogic:
         mock_sleep = mocker.patch("pdmt5.dataframe.time.sleep")
 
         # Should succeed on second attempt
-        client.initialize_mt5()
+        client.initialize_and_login_mt5()
 
         assert mock_mt5_import.initialize.call_count == 2
         mock_sleep.assert_called_once_with(1)
@@ -1905,9 +1902,9 @@ class TestMt5DataClientRetryLogic:
         mock_sleep = mocker.patch("pdmt5.dataframe.time.sleep")
 
         with pytest.raises(Mt5RuntimeError) as exc_info:
-            client.initialize_mt5()
+            client.initialize_and_login_mt5()
 
-        assert "MT5 initialization failed after" in str(exc_info.value)
+        assert "MT5 initialize and login failed after" in str(exc_info.value)
         assert mock_mt5_import.initialize.call_count == 3  # All attempts made
         # Check that sleep was called for retries
         assert mock_sleep.call_count == 2

{pdmt5-0.1.0 → pdmt5-0.1.2}/test/test_mt5.py

@@ -88,7 +88,6 @@ class TestMt5Client:
             password="secret",
             server="Demo",
             timeout=60000,
-            portable=True,
         )
 
         assert result is True
@@ -98,7 +97,6 @@ class TestMt5Client:
             password="secret",
             server="Demo",
             timeout=60000,
-            portable=True,
         )
 
     def test_initialize_failure(self, client: Mt5Client, mock_mt5: Mock) -> None:

{pdmt5-0.1.0 → 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.0 → pdmt5-0.1.2}/uv.lock

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