mt5cli 1.3.0__tar.gz → 1.3.1__tar.gz

{mt5cli-1.3.0 → mt5cli-1.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mt5cli
-Version: 1.3.0
+Version: 1.3.1
 Summary: Generic MT5 data and execution infrastructure for Python applications
 Project-URL: Repository, https://github.com/dceoy/mt5cli.git
 Author-email: dceoy <dceoy@users.noreply.github.com>

{mt5cli-1.3.0 → mt5cli-1.3.1}/docs/api/trading.md

@@ -269,6 +269,16 @@ updating symbol (paced by `sample_interval_seconds`) or across several
 symbols passed to the constructor. Any two matched samples that disagree
 abort the calibration (`offset_disagreement`).
 
+The `copy_ticks_range()` query backing each sample extends its upper bound
+`_MAX_FUTURE_SKEW_SECONDS` (2 minutes) past the host clock's current time, in
+addition to covering the full trailing `copied_window_seconds`. A live tick's
+true UTC event is not always at or before the host clock — feed/broker clock
+skew can put it a few seconds ahead — and without that tolerance the matching
+copied row would never be queried, so calibration would always report
+`no_matching_event`. The tolerance is bounded, not open-ended: an event
+further ahead than `_MAX_FUTURE_SKEW_SECONDS` is still excluded from the
+query and cannot be matched.
+
 ### Failure modes and fail-closed behavior
 
 When calibration cannot be established safely — closed market or weekend

{mt5cli-1.3.0 → mt5cli-1.3.1}/mt5cli/trading.py

@@ -1060,7 +1060,14 @@ def _recent_copied_ticks(
     window_seconds: float,
     now_epoch: float,
 ) -> pd.DataFrame | None:
-    """Fetch copied ticks for the trailing UTC window ending now.
+    """Fetch copied ticks for the trailing UTC window ending just past now.
+
+    The upper query bound extends ``_MAX_FUTURE_SKEW_SECONDS`` past
+    ``now_epoch`` so a live tick whose true UTC event is slightly ahead of
+    the host clock (feed/server clock skew, not a broker wall-clock label)
+    still falls inside the queried range and can be matched; that tolerance
+    matches the future-skew bound already enforced on normalized snapshots,
+    so it cannot admit an event further ahead than the supported policy.
 
     Returns:
         The copied-tick DataFrame, or ``None`` when retrieval fails or the
@@ -1069,13 +1076,14 @@ def _recent_copied_ticks(
     flags = getattr(getattr(client, "mt5", None), "COPY_TICKS_ALL", None)
     if not isinstance(flags, int):
         flags = _COPY_TICKS_ALL_FALLBACK
+    query_end_epoch = now_epoch + _MAX_FUTURE_SKEW_SECONDS
     try:
         frame = cast(
             "object",
             client.copy_ticks_range(
                 symbol,
                 datetime.fromtimestamp(now_epoch - window_seconds, tz=UTC),
-                datetime.fromtimestamp(now_epoch, tz=UTC),
+                datetime.fromtimestamp(query_end_epoch, tz=UTC),
                 flags,
             ),
         )
@@ -1242,7 +1250,10 @@ class TickClockNormalizer:
             sample_interval_seconds: Pause between consecutive samples so an
                 actively updating symbol can produce distinct tick events.
             copied_window_seconds: Trailing UTC window queried from
-                ``copy_ticks_range`` per sample.
+                ``copy_ticks_range`` per sample, ending
+                ``_MAX_FUTURE_SKEW_SECONDS`` past the host clock's current
+                time so a live tick slightly ahead of the host clock (feed
+                clock skew) remains matchable.
             max_calibration_age_seconds: Age after which a cached calibration
                 is recomputed unconditionally (bounds DST-transition
                 staleness).

{mt5cli-1.3.0 → mt5cli-1.3.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "mt5cli"
-version = "1.3.0"
+version = "1.3.1"
 description = "Generic MT5 data and execution infrastructure for Python applications"
 authors = [{name = "dceoy", email = "dceoy@users.noreply.github.com"}]
 maintainers = [{name = "dceoy", email = "dceoy@users.noreply.github.com"}]
@@ -40,6 +40,8 @@ Repository = "https://github.com/dceoy/mt5cli.git"
 
 [tool.uv]
 required-environments = ["platform_system == 'Windows'"]
+exclude-newer = "1 week"
+exclude-newer-package = { pdmt5 = false }
 
 [dependency-groups]
 dev = [

{mt5cli-1.3.0 → mt5cli-1.3.1}/tests/test_trading.py

@@ -14,12 +14,15 @@ from numpy import int64 as np_int64
 from pdmt5 import Mt5RuntimeError
 
 if TYPE_CHECKING:
+    from collections.abc import Callable
+
     from pytest_mock import MockerFixture
 
 from mt5cli import trading
 from mt5cli.client import MT5Client
 from mt5cli.exceptions import Mt5OperationError
 from mt5cli.trading import (
+    _MAX_FUTURE_SKEW_SECONDS,  # type: ignore[reportPrivateUsage]
     MarginVolume,
     OrderExecutionResult,
     OrderLimits,
@@ -4145,6 +4148,31 @@ def _clock_client(
     return client
 
 
+def _windowed_copy_ticks_range(
+    frame: pd.DataFrame,
+) -> Callable[[str, datetime, datetime, int], pd.DataFrame]:
+    """Build a ``copy_ticks_range`` fake that filters rows by query bounds.
+
+    Real MT5 only returns rows within ``[date_from, date_to]``; a plain
+    canned return value would hide a regression where the production code
+    queries too narrow a window, since the mock would return the same rows
+    regardless of the arguments it was called with.
+    """
+
+    def _copy_ticks_range(
+        _symbol: str,
+        date_from: datetime,
+        date_to: datetime,
+        _flags: int,
+    ) -> pd.DataFrame:
+        from_epoch = date_from.timestamp()
+        to_epoch = date_to.timestamp()
+        mask = (frame["time"] >= from_epoch) & (frame["time"] <= to_epoch)
+        return frame[mask].reset_index(drop=True)
+
+    return _copy_ticks_range
+
+
 class TestTickClockNormalizer:
     """Tests for TickClockNormalizer calibration and UTC normalization."""
 
@@ -4192,7 +4220,7 @@ class TestTickClockNormalizer:
         mt5_flag: int | None,
         expected_flag: int,
     ) -> None:
-        """Copied ticks are queried over a trailing UTC window ending now."""
+        """Copied ticks are queried over a window trailing and past now."""
         _freeze_clock(mocker)
         event = _CLOCK_NOW_EPOCH - 1
         client = _clock_client(
@@ -4213,10 +4241,87 @@ class TestTickClockNormalizer:
         client.copy_ticks_range.assert_called_once_with(
             "SING30",
             datetime.fromtimestamp(_CLOCK_NOW_EPOCH - 300.0, tz=UTC),
-            datetime.fromtimestamp(_CLOCK_NOW_EPOCH, tz=UTC),
+            datetime.fromtimestamp(
+                _CLOCK_NOW_EPOCH + _MAX_FUTURE_SKEW_SECONDS,
+                tz=UTC,
+            ),
             expected_flag,
         )
 
+    def test_live_tick_ahead_of_host_clock_matches_within_widened_window(
+        self,
+        mocker: MockerFixture,
+    ) -> None:
+        """A live tick ~16s ahead of the host clock still calibrates.
+
+        Reproduces the dceoy/mteor#428 production failure: the feed/server
+        clock can run slightly ahead of the host OS clock, so the true UTC
+        event backing a live tick can itself land a few seconds past
+        ``datetime.now(UTC)``. Querying ``copy_ticks_range`` with
+        ``date_to=now`` would exclude that event, leaving only an unrelated
+        older row and forcing ``no_matching_event`` on every sample.
+        """
+        _freeze_clock(mocker)
+        skew = 16.0
+        true_utc_event = _CLOCK_NOW_EPOCH + skew
+        older_unrelated_event = _CLOCK_NOW_EPOCH - 30
+        copied = pd.concat(
+            [
+                _copied_frame(older_unrelated_event, bid=9.9, ask=9.9),
+                _copied_frame(true_utc_event),
+            ],
+            ignore_index=True,
+        )
+        client = _clock_client(
+            [_live_tick(true_utc_event + _UTC_PLUS_3)],
+            pd.DataFrame(),
+        )
+        client.copy_ticks_range.side_effect = _windowed_copy_ticks_range(copied)
+        normalizer = TickClockNormalizer(
+            client,
+            ["SING30"],
+            samples_per_symbol=1,
+            min_agreeing_samples=1,
+        )
+
+        calibration = normalizer.calibrate()
+
+        assert calibration.status == "calibrated"
+        _assert_close(calibration.offset_seconds, _UTC_PLUS_3)
+        assert client.copy_ticks_range.call_count == 1
+
+    def test_copied_event_beyond_future_skew_policy_is_not_matched(
+        self,
+        mocker: MockerFixture,
+    ) -> None:
+        """An event further ahead than the tolerated skew is never queried.
+
+        The widened upper bound is bounded, not open-ended: it matches
+        ``_MAX_FUTURE_SKEW_SECONDS``, the same policy enforced on normalized
+        snapshots, so an event beyond that horizon is excluded from the
+        copied-tick query and can never be silently accepted as a match.
+        """
+        _freeze_clock(mocker)
+        beyond_skew_event = _CLOCK_NOW_EPOCH + _MAX_FUTURE_SKEW_SECONDS + 1.0
+        client = _clock_client(
+            [_live_tick(beyond_skew_event + _UTC_PLUS_3)],
+            pd.DataFrame(),
+        )
+        client.copy_ticks_range.side_effect = _windowed_copy_ticks_range(
+            _copied_frame(beyond_skew_event),
+        )
+        normalizer = TickClockNormalizer(
+            client,
+            ["SING30"],
+            samples_per_symbol=1,
+            min_agreeing_samples=1,
+        )
+
+        calibration = normalizer.calibrate()
+
+        assert calibration.status == "no_copied_ticks"
+        assert calibration.offset_seconds is None
+
     def test_matches_older_copied_row_when_newest_row_disagrees(
         self,
         mocker: MockerFixture,

{mt5cli-1.3.0 → mt5cli-1.3.1}/uv.lock

@@ -10,6 +10,13 @@ required-markers = [
     "sys_platform == 'win32'",
 ]
 
+[options]
+exclude-newer = "2026-07-13T15:37:13.721821839Z"
+exclude-newer-span = "P1W"
+
+[options.exclude-newer-package]
+pdmt5 = false
+
 [[package]]
 name = "annotated-doc"
 version = "0.0.4"
@@ -499,7 +506,7 @@ wheels = [
 
 [[package]]
 name = "mt5cli"
-version = "1.3.0"
+version = "1.3.1"
 source = { editable = "." }
 dependencies = [
     { name = "pandas" },