pdmt5 0.1.2__tar.gz → 0.1.3__tar.gz

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

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

@@ -2,13 +2,17 @@
 
 from __future__ import annotations
 
-from typing import Any, Literal
+from datetime import timedelta
+from typing import TYPE_CHECKING, Any, Literal
 
 from pydantic import ConfigDict, Field
 
 from .dataframe import Mt5DataClient
 from .mt5 import Mt5RuntimeError
 
+if TYPE_CHECKING:
+    import pandas as pd
+
 
 class Mt5TradingError(Mt5RuntimeError):
     """MetaTrader5 trading error."""
@@ -190,3 +194,84 @@ class Mt5TradingClient(Mt5DataClient):
                 f"Failed to calculate minimum order margins for symbol: {symbol}."
             )
             raise Mt5TradingError(error_message)
+
+    def calculate_spread_ratio(
+        self,
+        symbol: str,
+    ) -> float:
+        """Calculate the spread ratio for a given symbol.
+
+        Args:
+            symbol: Symbol for which to calculate the spread ratio.
+
+        Returns:
+            Spread ratio as a float.
+        """
+        symbol_info_tick = self.symbol_info_tick_as_dict(symbol=symbol)
+        return (
+            (symbol_info_tick["ask"] - symbol_info_tick["bid"])
+            / (symbol_info_tick["ask"] + symbol_info_tick["bid"])
+            * 2
+        )
+
+    def copy_latest_rates_as_df(
+        self,
+        symbol: str,
+        granularity: str = "M1",
+        count: int = 1440,
+        index_keys: str | None = "time",
+    ) -> pd.DataFrame:
+        """Fetch rate (OHLC) data as a DataFrame.
+
+        Args:
+            symbol: Symbol to fetch data for.
+            granularity: Time granularity as a timeframe suffix (e.g., "M1", "H1").
+            count: Number of bars to fetch.
+            index_keys: Optional index keys for the DataFrame.
+
+        Returns:
+            pd.DataFrame: OHLC data with time index.
+
+        Raises:
+            Mt5TradingError: If the granularity is not supported by MetaTrader5.
+        """
+        try:
+            timeframe = getattr(self.mt5, f"TIMEFRAME_{granularity.upper()}")
+        except AttributeError as e:
+            error_message = (
+                f"MetaTrader5 does not support the given granularity: {granularity}"
+            )
+            raise Mt5TradingError(error_message) from e
+        else:
+            return self.copy_rates_from_pos_as_df(
+                symbol=symbol,
+                timeframe=timeframe,
+                start_pos=0,
+                count=count,
+                index_keys=index_keys,
+            )
+
+    def copy_latest_ticks_as_df(
+        self,
+        symbol: str,
+        seconds: int = 300,
+        index_keys: str | None = "time_msc",
+    ) -> pd.DataFrame:
+        """Fetch tick data as a DataFrame.
+
+        Args:
+            symbol: Symbol to fetch tick data for.
+            seconds: Time range in seconds to fetch ticks around the last tick time.
+            index_keys: Optional index keys for the DataFrame.
+
+        Returns:
+            pd.DataFrame: Tick data with time index.
+        """
+        last_tick_time = self.symbol_info_tick_as_dict(symbol=symbol)["time"]
+        return self.copy_ticks_range_as_df(
+            symbol=symbol,
+            date_from=(last_tick_time - timedelta(seconds=seconds)),
+            date_to=(last_tick_time + timedelta(seconds=seconds)),
+            flags=self.mt5.COPY_TICKS_ALL,
+            index_keys=index_keys,
+        )

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

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

@@ -7,6 +7,7 @@ from collections.abc import Generator
 from types import ModuleType
 from typing import NamedTuple
 
+import numpy as np
 import pytest
 from pydantic import ValidationError
 from pytest_mock import MockerFixture
@@ -54,6 +55,8 @@ def mock_mt5_import(
         mock_mt5.order_check = mocker.MagicMock()  # type: ignore[attr-defined]
         mock_mt5.order_send = mocker.MagicMock()  # type: ignore[attr-defined]
         mock_mt5.order_calc_margin = mocker.MagicMock()  # type: ignore[attr-defined]
+        mock_mt5.copy_rates_from_pos = mocker.MagicMock()  # type: ignore[attr-defined]
+        mock_mt5.copy_ticks_range = mocker.MagicMock()  # type: ignore[attr-defined]
 
         # Trading-specific constants
         mock_mt5.TRADE_ACTION_DEAL = 1
@@ -909,3 +912,146 @@ class TestMt5TradingClient:
 
         with pytest.raises(Mt5TradingError):
             client.calculate_minimum_order_margins("EURUSD")
+
+    def test_calculate_spread_ratio(
+        self,
+        mock_mt5_import: ModuleType,
+    ) -> None:
+        """Test calculation of spread ratio."""
+        client = Mt5TradingClient(mt5=mock_mt5_import)
+        mock_mt5_import.initialize.return_value = True
+        client.initialize()
+
+        # Mock symbol tick info
+        mock_mt5_import.symbol_info_tick.return_value._asdict.return_value = {
+            "ask": 1.1002,
+            "bid": 1.1000,
+        }
+
+        result = client.calculate_spread_ratio("EURUSD")
+
+        # Expected calculation: (1.1002 - 1.1000) / (1.1002 + 1.1000) * 2
+        expected = (1.1002 - 1.1000) / (1.1002 + 1.1000) * 2
+        assert result == expected
+        mock_mt5_import.symbol_info_tick.assert_called_once_with("EURUSD")
+
+    def test_copy_latest_rates_as_df_success(
+        self,
+        mock_mt5_import: ModuleType,
+    ) -> None:
+        """Test successful fetching of rate data as DataFrame."""
+        client = Mt5TradingClient(mt5=mock_mt5_import)
+        mock_mt5_import.initialize.return_value = True
+        client.initialize()
+
+        # Mock TIMEFRAME constant
+        mock_mt5_import.TIMEFRAME_M1 = 1
+
+        # Create structured array that mimics MT5 rates structure
+        rates_dtype = np.dtype([
+            ("time", "i8"),
+            ("open", "f8"),
+            ("high", "f8"),
+            ("low", "f8"),
+            ("close", "f8"),
+            ("tick_volume", "i8"),
+            ("spread", "i4"),
+            ("real_volume", "i8"),
+        ])
+
+        mock_rates_data = np.array(
+            [
+                (1234567890, 1.1000, 1.1010, 1.0990, 1.1005, 100, 2, 10000),
+            ],
+            dtype=rates_dtype,
+        )
+
+        mock_mt5_import.copy_rates_from_pos.return_value = mock_rates_data
+
+        result = client.copy_latest_rates_as_df("EURUSD", granularity="M1", count=10)
+
+        assert result is not None
+        mock_mt5_import.copy_rates_from_pos.assert_called_once_with(
+            "EURUSD",  # symbol
+            1,  # timeframe
+            0,  # start_pos
+            10,  # count
+        )
+
+    def test_copy_latest_rates_as_df_invalid_granularity(
+        self,
+        mock_mt5_import: ModuleType,
+    ) -> None:
+        """Test fetching rate data with invalid granularity."""
+        client = Mt5TradingClient(mt5=mock_mt5_import)
+        mock_mt5_import.initialize.return_value = True
+        client.initialize()
+
+        # Ensure the attribute doesn't exist for invalid granularity
+        if hasattr(mock_mt5_import, "TIMEFRAME_INVALID"):
+            delattr(mock_mt5_import, "TIMEFRAME_INVALID")
+
+        with pytest.raises(
+            Mt5TradingError,
+            match="MetaTrader5 does not support the given granularity: INVALID",
+        ):
+            client.copy_latest_rates_as_df("EURUSD", granularity="INVALID")
+
+    def test_copy_latest_ticks_as_df(
+        self,
+        mock_mt5_import: ModuleType,
+    ) -> None:
+        """Test fetching tick data as DataFrame."""
+        client = Mt5TradingClient(mt5=mock_mt5_import)
+        mock_mt5_import.initialize.return_value = True
+        client.initialize()
+
+        # Mock symbol tick info with time
+        mock_mt5_import.symbol_info_tick.return_value._asdict.return_value = {
+            "time": 1234567890,
+            "ask": 1.1002,
+            "bid": 1.1000,
+        }
+
+        # Mock copy ticks flag
+        mock_mt5_import.COPY_TICKS_ALL = 1
+
+        # Create structured array that mimics MT5 ticks structure
+        ticks_dtype = np.dtype([
+            ("time", "i8"),
+            ("bid", "f8"),
+            ("ask", "f8"),
+            ("last", "f8"),
+            ("volume", "i8"),
+            ("time_msc", "i8"),
+            ("flags", "i4"),
+            ("volume_real", "f8"),
+        ])
+
+        mock_ticks_data = np.array(
+            [
+                (1234567890, 1.1000, 1.1002, 1.1001, 100, 1234567890000, 0, 100.0),
+            ],
+            dtype=ticks_dtype,
+        )
+
+        mock_mt5_import.copy_ticks_range.return_value = mock_ticks_data
+
+        result = client.copy_latest_ticks_as_df("EURUSD", seconds=60)
+
+        assert result is not None
+        # Verify the method was called
+        mock_mt5_import.symbol_info_tick.assert_called_once_with("EURUSD")
+
+        # Verify copy_ticks_range was called with correct arguments
+        call_args = mock_mt5_import.copy_ticks_range.call_args[0]
+        assert call_args[0] == "EURUSD"  # symbol
+        assert call_args[3] == 1  # flags (COPY_TICKS_ALL)
+
+        # Verify result has the expected structure
+        assert len(result) == 1
+        # time_msc is likely the index, not a column
+        assert "bid" in result.columns
+        assert "ask" in result.columns
+        assert "last" in result.columns
+        assert "volume" in result.columns

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

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