mt5cli 1.3.0__tar.gz → 1.3.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mt5cli
-Version: 1.3.0
+Version: 1.3.2
 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.2}/docs/api/trading.md

@@ -255,9 +255,10 @@ The offset is never inferred from `latest_tick_time - now` alone. Each
 calibration sample fetches the live `symbol_info_tick()` value **and** recent
 UTC-labeled `copy_ticks_range()` data, then searches every recent copied row
 (not just the newest) for one that matches the live tick on its shared
-`bid`/`ask`/`last`/`volume` fields (with at least one agreeing positive price
-field); the newest matching row sets the resulting offset, which must align
-to a 30-minute increment within the realistic UTC-14..UTC+14 range.
+positive `bid`/`ask`/`last` fields. Volume is not used as event identity
+because latest-tick and copied-tick views can represent OTC quote volume
+differently. The newest matching row sets the resulting offset, which must
+align to a 30-minute increment within the realistic UTC-14..UTC+14 range.
 `time_msc` is preferred over second-resolution `time` on both sides when
 available.
 
@@ -269,6 +270,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
@@ -294,11 +305,12 @@ symbols and calls. A cached offset is recomputed in three cases:
   future — evidence that the broker offset grew, e.g. a UTC+2 to UTC+3
   transition.
 - Periodically, at most once per `revalidation_interval_seconds` (default 5
-  minutes), a single confirming sample is taken against the still-cached
-  offset; a disagreement forces full recalibration. This is what catches a
-  broker offset _decrease_ (e.g. UTC+3 to UTC+2): the resulting normalized
-  time looks stale rather than future, which a future-skew check alone
-  cannot distinguish from ordinary quiet-market staleness.
+  minutes), configured symbols are sampled until one confirms the
+  still-cached offset. Closed or inconclusive symbols are skipped; a detected
+  disagreement forces full recalibration. This is what catches a broker
+  offset _decrease_ (e.g. UTC+3 to UTC+2): the resulting normalized time
+  looks stale rather than future, which a future-skew check alone cannot
+  distinguish from ordinary quiet-market staleness.
 
 If recalibration still cannot validate the timestamp, the snapshot fails
 closed. Failed calibrations are recorded for diagnostics but never reused;

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

@@ -1028,18 +1028,25 @@ def _match_value(value: object) -> float | None:
 def _ticks_match(live: Mapping[str, object], copied: Mapping[str, object]) -> bool:
     """Decide whether a live tick and a copied tick are the same market event.
 
-    Every field present on both sides (``bid``, ``ask``, ``last``,
-    ``volume``) must agree, and at least one positive price field must supply
-    evidence; volume agreement or all-zero prices alone are insufficient.
+    Every positive price field present on both sides must agree, and at least
+    one such field must supply evidence. ``volume`` is deliberately excluded:
+    MT5's latest-tick snapshot and copied-tick history can expose different
+    volume representations for the same quote event, especially for OTC
+    instruments whose meaningful fields are Bid and Ask.
 
     Returns:
         True when the two ticks plausibly describe the same market event.
     """
     matched_price_field = False
-    for field in (*_TICK_MATCH_PRICE_FIELDS, "volume"):
+    for field in _TICK_MATCH_PRICE_FIELDS:
         live_value = _match_value(live.get(field))
         copied_value = _match_value(copied.get(field))
-        if live_value is None or copied_value is None:
+        if (
+            live_value is None
+            or copied_value is None
+            or live_value <= 0
+            or copied_value <= 0
+        ):
             continue
         tolerance = _PRICE_MATCH_RELATIVE_TOLERANCE * max(
             1.0,
@@ -1048,8 +1055,7 @@ def _ticks_match(live: Mapping[str, object], copied: Mapping[str, object]) -> bo
         )
         if abs(live_value - copied_value) > tolerance:
             return False
-        if field in _TICK_MATCH_PRICE_FIELDS and live_value > 0:
-            matched_price_field = True
+        matched_price_field = True
     return matched_price_field
 
 
@@ -1060,7 +1066,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 +1082,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,
             ),
         )
@@ -1114,7 +1128,7 @@ def _matching_ticks_newest_first(
     live-vs-copied comparison is in flight, so every recent copied row is
     searched for the same market event as ``live`` instead of assuming the
     newest copied row is the relevant one. A newer row can also
-    coincidentally share ``live``'s price/volume fields without being the
+    coincidentally share ``live``'s price fields without being the
     same event, so every match is returned for offset-plausibility
     evaluation rather than only the newest.
 
@@ -1136,7 +1150,7 @@ def _sample_clock_offset(
     """Compare one live tick against recent copied UTC ticks.
 
     Every field-matching copied tick is evaluated, newest first, so a newer
-    row that coincidentally shares the live tick's price/volume fields
+    row that coincidentally shares the live tick's price fields
     cannot shadow a plausible offset from an older exact match; recency
     only breaks ties among candidates that are themselves plausible.
 
@@ -1242,17 +1256,21 @@ 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).
             revalidation_interval_seconds: Minimum time between opportunistic
-                single-sample checks of an otherwise still-fresh cached
-                calibration. A disagreeing sample forces full recalibration,
-                which catches an offset decrease (for example a UTC+3 to
-                UTC+2 transition) well before ``max_calibration_age_seconds``
-                would; an inconclusive or agreeing sample keeps the cached
-                calibration.
+                checks of an otherwise still-fresh cached calibration.
+                Configured symbols are sampled until one confirms the cache;
+                a disagreeing sample forces full recalibration only when none
+                confirms it. This catches an offset decrease (for example a
+                UTC+3 to UTC+2 transition) well before
+                ``max_calibration_age_seconds`` would, while a closed symbol
+                cannot hide fresh evidence from another active symbol.
             failed_calibration_retry_seconds: Minimum time between full
                 recalibration attempts after a failed calibration, so a
                 closed or illiquid market does not retry on every call.
@@ -1440,36 +1458,40 @@ class TickClockNormalizer:
         *,
         now_epoch: float,
     ) -> TickClockCalibration | None:
-        """Confirm or replace a still-fresh cached calibration with one sample.
+        """Confirm or replace a still-fresh cached calibration with live symbols.
 
         A future-skew check alone never catches a broker offset *decrease*
         (e.g. a UTC+3 to UTC+2 transition): the resulting normalized time
         looks stale rather than future, and staleness is also the expected
-        symptom of a quiet market. This periodic single-sample check is
-        symmetric evidence that also detects that case. An inconclusive
-        sample (closed market, no matching event) leaves the cached
-        calibration in place rather than discarding a still-working offset.
+        symptom of a quiet market. This periodic check probes the configured
+        symbols until one confirms the cached offset. Inconclusive samples
+        from closed markets are skipped, so one regional symbol cannot hide
+        fresh evidence from another active symbol.
 
         Returns:
             A freshly recalibrated :class:`TickClockCalibration` when the
             fresh sample disagreed with ``cached``, or ``None`` when the
             cached calibration should be kept as-is.
         """
-        sample = _sample_clock_offset(
-            self._client,
-            symbol,
-            window_seconds=self._copied_window_seconds,
-        )
         self._last_attempt_at = now_epoch
-        if (
-            sample.offset_seconds is None
-            or sample.offset_seconds == cached.offset_seconds
-        ):
+        changed_sample: tuple[str, _OffsetSample] | None = None
+        for candidate in self._symbols or (symbol,):
+            sample = _sample_clock_offset(
+                self._client,
+                candidate,
+                window_seconds=self._copied_window_seconds,
+            )
+            if sample.offset_seconds == cached.offset_seconds:
+                return None
+            if sample.offset_seconds is not None and changed_sample is None:
+                changed_sample = (candidate, sample)
+        if changed_sample is None:
             return None
+        candidate, sample = changed_sample
         _logger.warning(
             "MT5 server clock offset for %s appears to have changed from"
             " %.0f to %.0f seconds; recalibrating.",
-            symbol,
+            candidate,
             cached.offset_seconds,
             sample.offset_seconds,
         )

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

@@ -1,6 +1,6 @@
 [project]
 name = "mt5cli"
-version = "1.3.0"
+version = "1.3.2"
 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.2}/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,
@@ -4690,6 +4795,88 @@ class TestTickClockNormalizer:
         _assert_close(calibration.calibrated_at, _CLOCK_NOW_EPOCH)
         assert client.copy_ticks_range.call_count == 3
 
+    def test_revalidation_uses_active_configured_symbol_when_one_is_closed(
+        self,
+        mocker: MockerFixture,
+    ) -> None:
+        """One closed symbol cannot hide fresh connection-wide evidence."""
+        mock_dt, _ = _freeze_clock(mocker)
+        event_1 = _CLOCK_NOW_EPOCH - 2
+        event_2 = _CLOCK_NOW_EPOCH - 1
+        later = datetime.fromtimestamp(_CLOCK_NOW_EPOCH + 61.0, tz=UTC)
+        later_event = later.timestamp() - 1
+        client = _clock_client(
+            [
+                _live_tick(event_1 + _UTC_PLUS_3),
+                _live_tick(event_2 + _UTC_PLUS_3, bid=150.0, ask=150.1),
+                _live_tick(event_1 + _UTC_PLUS_3),  # closed revalidation sample
+                _live_tick(later_event + _UTC_PLUS_3, bid=150.0, ask=150.1),
+                _live_tick(later_event + _UTC_PLUS_3, bid=150.0, ask=150.1),
+            ],
+            [
+                _copied_frame(event_1),
+                _copied_frame(event_2, bid=150.0, ask=150.1),
+                pd.DataFrame(),
+                _copied_frame(later_event, bid=150.0, ask=150.1),
+            ],
+        )
+        normalizer = TickClockNormalizer(
+            client,
+            ["CLOSED", "ACTIVE"],
+            samples_per_symbol=1,
+            revalidation_interval_seconds=60.0,
+        )
+        assert normalizer.calibrate().status == "calibrated"
+
+        mock_dt.now.return_value = later
+        snapshot = normalizer.get_normalized_tick_snapshot("ACTIVE")
+
+        assert snapshot["clock_status"] == "calibrated"
+        assert snapshot["time_utc"] == datetime.fromtimestamp(later_event, tz=UTC)
+        _assert_close(snapshot["server_clock_offset_seconds"], _UTC_PLUS_3)
+        assert [
+            call.kwargs["symbol"]
+            for call in client.symbol_info_tick_as_dict.call_args_list
+        ] == ["CLOSED", "ACTIVE", "CLOSED", "ACTIVE", "ACTIVE"]
+
+    def test_inconclusive_revalidation_keeps_cached_offset(
+        self,
+        mocker: MockerFixture,
+    ) -> None:
+        """A closed market does not discard a still-valid cached offset."""
+        mock_dt, _ = _freeze_clock(mocker)
+        event_1 = _CLOCK_NOW_EPOCH - 2
+        event_2 = _CLOCK_NOW_EPOCH - 1
+        later = datetime.fromtimestamp(_CLOCK_NOW_EPOCH + 61.0, tz=UTC)
+        client = _clock_client(
+            [
+                _live_tick(event_1 + _UTC_PLUS_3),
+                _live_tick(event_2 + _UTC_PLUS_3),
+                _live_tick(event_2 + _UTC_PLUS_3),
+                _live_tick(event_2 + _UTC_PLUS_3),
+            ],
+            [
+                _copied_frame(event_1),
+                _copied_frame(event_2),
+                pd.DataFrame(),
+            ],
+        )
+        normalizer = TickClockNormalizer(
+            client,
+            ["SING30"],
+            samples_per_symbol=2,
+            revalidation_interval_seconds=60.0,
+        )
+        first = normalizer.calibrate()
+        _assert_close(first.offset_seconds, _UTC_PLUS_3)
+
+        mock_dt.now.return_value = later
+        snapshot = normalizer.get_normalized_tick_snapshot("SING30")
+
+        assert snapshot["clock_status"] == "calibrated"
+        _assert_close(snapshot["server_clock_offset_seconds"], _UTC_PLUS_3)
+        assert client.copy_ticks_range.call_count == 3
+
     def test_offset_decrease_is_caught_by_periodic_revalidation(
         self,
         mocker: MockerFixture,
@@ -4808,14 +4995,12 @@ class TestTickClockNormalizer:
         [
             ({"bid": None, "ask": None, "last": None}, {}),
             ({"bid": 0.0, "ask": None, "last": None}, {"bid": 0.0}),
-            ({"volume": 6}, {}),
             ({"bid": "1.1", "ask": None, "last": None}, {}),
             ({"bid": float("nan"), "ask": None, "last": None}, {}),
         ],
         ids=[
             "volume-only",
             "zero-price-only",
-            "volume-mismatch",
             "string-price",
             "nan-price",
         ],
@@ -4843,6 +5028,57 @@ class TestTickClockNormalizer:
 
         assert normalizer.calibrate().status == "no_matching_event"
 
+    def test_volume_difference_does_not_hide_matching_quote_event(
+        self,
+        mocker: MockerFixture,
+    ) -> None:
+        """Bid/ask identity remains usable when live and copied volumes differ."""
+        _freeze_clock(mocker)
+        event = _CLOCK_NOW_EPOCH - 1
+        client = _clock_client(
+            [_live_tick(event + _UTC_PLUS_3, volume=6)],
+            _copied_frame(event, volume=5),
+        )
+        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)
+
+    def test_half_hour_delayed_feed_is_not_inferred_from_host_clock(
+        self,
+        mocker: MockerFixture,
+    ) -> None:
+        """Advancing stale ticks cannot become fresh through host-time rounding."""
+        _freeze_clock(mocker)
+        delayed_event_1 = _CLOCK_NOW_EPOCH - 1802
+        delayed_event_2 = _CLOCK_NOW_EPOCH - 1801
+        copied = _copied_frame(delayed_event_1, delayed_event_2)
+        client = _clock_client(
+            [
+                _live_tick(delayed_event_1 + _UTC_PLUS_3),
+                _live_tick(delayed_event_2 + _UTC_PLUS_3),
+            ],
+            pd.DataFrame(),
+        )
+        client.copy_ticks_range.side_effect = _windowed_copy_ticks_range(copied)
+        normalizer = TickClockNormalizer(
+            client,
+            ["SING30"],
+            samples_per_symbol=2,
+        )
+
+        calibration = normalizer.calibrate()
+
+        assert calibration.status == "no_copied_ticks"
+        assert calibration.offset_seconds is None
+
     def test_copied_time_msc_datetime_and_time_fallbacks(
         self,
         mocker: MockerFixture,

{mt5cli-1.3.0 → mt5cli-1.3.2}/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.2"
 source = { editable = "." }
 dependencies = [
     { name = "pandas" },