pmt4api 1.1.2__tar.gz → 1.2.0__tar.gz

{pmt4api-1.1.2 → pmt4api-1.2.0}/CHANGELOG.md

@@ -1,5 +1,44 @@
 # Changelog — pmt4api
 
+## [1.2.0] — 2026-11-06
+
+Bundles **wmt4api 3.4.0**. A minor release with a **Breaking** section, like the core's: history is always asked for
+by a window you choose.
+
+### Breaking — history is always asked for by window
+- **`history(start, end)` and `summary(start, end)` need both ends.** `history()` no longer defaults to the last 30
+  days and `summary()` no longer means "all time" (the core downloaded every order since 1970 for it, on every call).
+  A missing or reversed window raises `InvalidRequestError` before anything is sent. `ahistory` likewise.
+- **One call covers at most `max_history_days` (366 by default).** A longer window raises `InvalidRequestError`
+  before a connection is opened or a licence request spent. Ask window by window and add the results up, or set
+  `Client(max_history_days=...)` / `c.max_history_days` when you mean one long download (`0` removes the limit; the
+  ends stay required). `equity_history(start)` runs to now, so its start is at most that long ago.
+- What to change: `c.summary()` → `c.summary(start, end)`; `c.history()` → `c.history(start, end)` (for "up to now",
+  `end = c.server_time`).
+
+### Added
+- `Client.max_history_days` (read and write) and the constructor argument of the same name.
+
+### Fixed (this package)
+- **The platform wheel could not start on a machine that also has a newer .NET installed on `PATH`** (for example a
+  system .NET 10 next to the bundled .NET 9): the loader under pythonnet asked that `dotnet` for its runtimes, took
+  the newest and looked for it in the bundled runtime — `RuntimeNotFoundError` ("needs the .NET 8 (or later)
+  runtime"), on 1.1.2 too. The runtime is now started at a version the chosen runtime folder holds, and the message
+  says which runtime it tried.
+
+### Fixed (core wmt4api 3.4.0)
+- **Order updates could reach `on_order_update` / `order_updates()` out of order** — a close before its open included
+  (seen on IC Markets: a commission modify before the open). They now arrive in the order the server sent them; the
+  same holds for quotes, order progress and connect / disconnect.
+- **`equity_history()` returned an empty list for a window with no closed order.** It is a flat line at the balance
+  (plus the floating P/L of open positions), the last point the live balance and equity — as in `pmt5api`.
+
+### Security (core wmt4api 3.4.0)
+- `token_url` must be `https` (plain `http` only for a loopback host) and carry no user information, query or
+  fragment; redirects from the licence service are not followed (they would re-send the key).
+- A login already bound to another trading account under your licence is refused with `LicenseError` reason
+  `AccountLimitReached` and a message that says so.
+
 ## [1.1.2] — 2026-10-15
 
 From the delta re-test of 1.1.1 (no S1 or S2). Python layer only: the cores are unchanged.

{pmt4api-1.1.2 → pmt4api-1.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: pmt4api
-Version: 1.1.2
+Version: 1.2.0
 Summary: Complete Python interface to the wmt4api MetaTrader 4 client library (market data, account, sizing, order entry, events).
 Project-URL: Homepage, https://mtapi.one
 Author: Sen Trading
@@ -235,22 +235,38 @@ cent-account scaling, so check the first result against your terminal. Also: `re
 | `balance`, `equity`, `margin`, `free_margin`, `margin_level`, `profit` | the same figures as cheap reads from the cache (no refresh; the margin may still wait for a conversion pair's first tick) |
 | `orders()` / `positions()` / `pending_orders()` / `order(ticket)` | `list[Order]` working / open positions / pending / one |
 | `history(start, end)` | `list[Order]` — closed orders and balance / credit entries, by close time |
-| `summary(start=None, end=None)` | `AccountSummary` — realized profit, deposits, withdrawals |
+| `summary(start, end)` | `AccountSummary` — realized profit, deposits, withdrawals |
 | `equity_history(start, "D1")` | `list[EquityPoint]` — balance (exact) and equity (reconstructed) curve with drawdowns |
 
 MT4 keeps one record for open positions, pending orders, closed orders and ledger entries: `Order.order_type` tells
 them apart (`Buy` / `Sell`, `BuyLimit` … , `Balance` / `Credit`), and `is_market`, `is_pending`, `is_capital_flow`
 say it directly. Times are naive `datetime` values in the **broker's server time**; an unset time is `None`.
 
+**History is asked for by window.** `history()` and `summary()` take a start and an end, and one call covers at most
+`max_history_days` (366 by default; set it on the client, `0` removes the limit); `equity_history()` runs from its
+start to now, so its start is at most that long ago. A missing, reversed or longer window raises
+`InvalidRequestError` before anything is sent. For a longer period, ask window by window and add the results up:
+
+```python
+from datetime import timedelta
+
+end = c.server_time                                   # server time; "up to now"
+closed = c.history(end - timedelta(days=30), end)
+year = c.summary(end - timedelta(days=365), end)
+```
+
 `history()`, `summary()` and `equity_history()` each open their own short-lived broker connection and cost one
 licence request, which the licence service rate-limits per minute: fetch once and reuse the result. `history()`
-takes a `threading.Event` as `cancel=` to abandon the wait.
+takes a `threading.Event` as `cancel=` to abandon the wait. A window with no closed order in it gives a flat equity
+curve at the balance, never an empty one.
 
 ## Events
 
 `on_quote`, `on_order_update`, `on_order_progress`, `on_connect`, `on_disconnect`, `on_quote_history`,
 `on_symbols_update` — each returns a function that removes the callback. `quotes()`, `order_updates()` and
-`order_progress()` (and the `a…` async versions) turn a stream into an iterator.
+`order_progress()` (and the `a…` async versions) turn a stream into an iterator. Events reach you in the order the
+server sent them — a ticket's open before its modifications and its close — and callbacks run one at a time on the
+client's own thread.
 
 ## Staying connected
 
@@ -274,12 +290,20 @@ restored, cached snapshots are not. `disconnect()` is final: it also stops a rec
 | Timeouts (seconds, each > 0) | `connect_timeout` (one attempt on one server; default 6), `token_timeout` (10), `trade_timeout` (30; ≥ 1), `quote_timeout` (5) / `history_timeout` (30) / `bars_timeout` (30) — the defaults of `quote`, `history`, `bars`, `no_message_timeout` (30; ≥ 10, or 0 for off) | — |
 | Reconnect | `auto_reconnect`, `reconnect_backoff` (3, doubling up to `reconnect_max_backoff`, 30), `reconnect_max_attempts` (0 = no limit), `servers=` | — |
 | Orders | `placed_type=` (`manual`, `expert`, `dealer` …), `comment_encoding=` (default `latin-1`) | — |
+| History window | `max_history_days=` (366; `0` = no limit) — also a client attribute | — |
 | .NET runtime location | — | `DOTNET_ROOT` |
 
 A core path you give (argument or `WMT4API_DLL`) is used exactly as given and is an error if it does not exist. The
 .NET runtime is taken from `DOTNET_ROOT` if you set it, else the runtime bundled in the wheel, else an installed one.
 The bundled runtime runs in invariant-culture mode on machines without ICU. The MT4 core has no proxy support.
 
+**These two settings decide what code runs in your process.** `WMT4API_DLL` (or `dll_path=`) names the library that is
+loaded, and `DOTNET_ROOT` (or, without it, the `dotnet` found on `PATH`) names the .NET runtime that is started;
+both run with your rights. Set them only from configuration you control, and do not run with an environment
+someone else can change. With `enable_core_logging()` switched on, the package logs once when either was chosen
+by the environment. The licence service URL must be `https` (plain `http` only for a loopback test service), and
+redirects from it are not followed.
+
 ### Diagnostics
 
 ```python

{pmt4api-1.1.2 → pmt4api-1.2.0}/README.md

@@ -208,22 +208,38 @@ cent-account scaling, so check the first result against your terminal. Also: `re
 | `balance`, `equity`, `margin`, `free_margin`, `margin_level`, `profit` | the same figures as cheap reads from the cache (no refresh; the margin may still wait for a conversion pair's first tick) |
 | `orders()` / `positions()` / `pending_orders()` / `order(ticket)` | `list[Order]` working / open positions / pending / one |
 | `history(start, end)` | `list[Order]` — closed orders and balance / credit entries, by close time |
-| `summary(start=None, end=None)` | `AccountSummary` — realized profit, deposits, withdrawals |
+| `summary(start, end)` | `AccountSummary` — realized profit, deposits, withdrawals |
 | `equity_history(start, "D1")` | `list[EquityPoint]` — balance (exact) and equity (reconstructed) curve with drawdowns |
 
 MT4 keeps one record for open positions, pending orders, closed orders and ledger entries: `Order.order_type` tells
 them apart (`Buy` / `Sell`, `BuyLimit` … , `Balance` / `Credit`), and `is_market`, `is_pending`, `is_capital_flow`
 say it directly. Times are naive `datetime` values in the **broker's server time**; an unset time is `None`.
 
+**History is asked for by window.** `history()` and `summary()` take a start and an end, and one call covers at most
+`max_history_days` (366 by default; set it on the client, `0` removes the limit); `equity_history()` runs from its
+start to now, so its start is at most that long ago. A missing, reversed or longer window raises
+`InvalidRequestError` before anything is sent. For a longer period, ask window by window and add the results up:
+
+```python
+from datetime import timedelta
+
+end = c.server_time                                   # server time; "up to now"
+closed = c.history(end - timedelta(days=30), end)
+year = c.summary(end - timedelta(days=365), end)
+```
+
 `history()`, `summary()` and `equity_history()` each open their own short-lived broker connection and cost one
 licence request, which the licence service rate-limits per minute: fetch once and reuse the result. `history()`
-takes a `threading.Event` as `cancel=` to abandon the wait.
+takes a `threading.Event` as `cancel=` to abandon the wait. A window with no closed order in it gives a flat equity
+curve at the balance, never an empty one.
 
 ## Events
 
 `on_quote`, `on_order_update`, `on_order_progress`, `on_connect`, `on_disconnect`, `on_quote_history`,
 `on_symbols_update` — each returns a function that removes the callback. `quotes()`, `order_updates()` and
-`order_progress()` (and the `a…` async versions) turn a stream into an iterator.
+`order_progress()` (and the `a…` async versions) turn a stream into an iterator. Events reach you in the order the
+server sent them — a ticket's open before its modifications and its close — and callbacks run one at a time on the
+client's own thread.
 
 ## Staying connected
 
@@ -247,12 +263,20 @@ restored, cached snapshots are not. `disconnect()` is final: it also stops a rec
 | Timeouts (seconds, each > 0) | `connect_timeout` (one attempt on one server; default 6), `token_timeout` (10), `trade_timeout` (30; ≥ 1), `quote_timeout` (5) / `history_timeout` (30) / `bars_timeout` (30) — the defaults of `quote`, `history`, `bars`, `no_message_timeout` (30; ≥ 10, or 0 for off) | — |
 | Reconnect | `auto_reconnect`, `reconnect_backoff` (3, doubling up to `reconnect_max_backoff`, 30), `reconnect_max_attempts` (0 = no limit), `servers=` | — |
 | Orders | `placed_type=` (`manual`, `expert`, `dealer` …), `comment_encoding=` (default `latin-1`) | — |
+| History window | `max_history_days=` (366; `0` = no limit) — also a client attribute | — |
 | .NET runtime location | — | `DOTNET_ROOT` |
 
 A core path you give (argument or `WMT4API_DLL`) is used exactly as given and is an error if it does not exist. The
 .NET runtime is taken from `DOTNET_ROOT` if you set it, else the runtime bundled in the wheel, else an installed one.
 The bundled runtime runs in invariant-culture mode on machines without ICU. The MT4 core has no proxy support.
 
+**These two settings decide what code runs in your process.** `WMT4API_DLL` (or `dll_path=`) names the library that is
+loaded, and `DOTNET_ROOT` (or, without it, the `dotnet` found on `PATH`) names the .NET runtime that is started;
+both run with your rights. Set them only from configuration you control, and do not run with an environment
+someone else can change. With `enable_core_logging()` switched on, the package logs once when either was chosen
+by the environment. The licence service URL must be `https` (plain `http` only for a loopback test service), and
+redirects from it are not followed.
+
 ### Diagnostics
 
 ```python

{pmt4api-1.1.2 → pmt4api-1.2.0}/examples/pnl.py

@@ -13,10 +13,12 @@ with Client(int(os.environ["PMT4_LOGIN"]), os.environ["PMT4_PASSWORD"], os.envir
     print("balance %.2f  equity %.2f  floating %.2f  margin %.2f  free %.2f"
           % (a.balance, a.equity, a.profit, a.margin, a.free_margin))
 
-    s = c.summary()                                   # from the closed-order ledger; blocks while it downloads
-    print("realized %.2f  deposits %.2f  withdrawals %.2f" % (s.realized_profit, s.deposit, s.withdrawal))
+    now = c.server_time                               # history windows are in the broker's server time
+    s = c.summary(now - timedelta(days=365), now)     # the last year (at most max_history_days per call); blocks
+    print("last 365 days: realized %.2f  deposits %.2f  withdrawals %.2f"
+          % (s.realized_profit, s.deposit, s.withdrawal))
 
-    curve = c.equity_history(c.server_time - timedelta(days=30), "D1")
+    curve = c.equity_history(now - timedelta(days=30), "D1")
     for p in curve[-5:]:
         print("%s  balance %.2f  equity %.2f  drawdown %.2f%%"
               % (p.time.strftime("%Y-%m-%d %H:%M"), p.balance, p.equity, p.equity_drawdown_relative * 100))

{pmt4api-1.1.2 → pmt4api-1.2.0}/src/pmt4api/__init__.py

@@ -17,7 +17,7 @@ from .models import (AccountInfo, AccountSummary, ConnectEvent, EquityPoint, Lot
                      OrderUpdate, Quote, ServerRecord, SymbolGroup, SymbolInfo)
 from .servers import load_servers_ini, save_servers_ini
 
-__version__ = "1.1.2"
+__version__ = "1.2.0"
 
 __all__ = [
     "Client",

{pmt4api-1.1.2 → pmt4api-1.2.0}/src/pmt4api/_account.py

@@ -4,15 +4,22 @@ from __future__ import annotations
 import asyncio
 import functools
 import threading
-from datetime import datetime, timedelta, timezone
+from datetime import datetime
 from typing import Any, List, Optional
 
 from ._base import _Base
 from ._util import enum_value, to_core_time, translated
-from .errors import NotConnectedError, RequestCancelled
+from .errors import InvalidRequestError, NotConnectedError, RequestCancelled
 from .models import AccountInfo, AccountSummary, EquityPoint, Order, _time
 
 
+def _history_days(days: Any) -> int:
+    """A ``max_history_days`` value: a whole number of days, 0 for no limit."""
+    if isinstance(days, bool) or not isinstance(days, int) or days < 0:
+        raise ValueError("max_history_days must be a whole number of days, or 0 for no limit (got %r)" % (days,))
+    return days
+
+
 class _Cancellation:
     """Turns a :class:`threading.Event` into the core's ``CancellationToken`` for the duration of one call."""
 
@@ -173,27 +180,24 @@ class _AccountMixin(_Base):
     # ---- history -----------------------------------------------------------------------------------------------
 
     @translated
-    def history(self, start: Optional[datetime] = None, end: Optional[datetime] = None,
-                timeout: Optional[float] = None, cancel: Optional[threading.Event] = None) -> List[Order]:
-        """Closed orders and balance / credit entries between ``start`` and ``end`` (default: the last 30 days up to
-        now), sorted by close time. Blocks until the server has sent everything, up to ``timeout`` seconds (default:
-        the client's ``history_timeout``); set the ``cancel`` event to abandon the wait early
-        (:class:`RequestCancelled`).
+    def history(self, start: datetime, end: datetime, timeout: Optional[float] = None,
+                cancel: Optional[threading.Event] = None) -> List[Order]:
+        """Closed orders and balance / credit entries between ``start`` and ``end``, sorted by close time. Blocks until
+        the server has sent everything, up to ``timeout`` seconds (default: the client's ``history_timeout``); set the
+        ``cancel`` event to abandon the wait early (:class:`RequestCancelled`).
+
+        Both ends are required and the window may be at most :attr:`max_history_days` long (366 by default): a missing,
+        reversed or longer window raises :class:`InvalidRequestError` before anything is sent. For a longer period,
+        call once per window and add the results up. For "up to now", pass ``c.server_time`` as ``end``.
 
         Naive datetimes are used exactly as given, in the broker's server time; timezone-aware ones are converted to
-        it. The default window is computed on the server's clock.
+        it.
 
         Each call opens its own short-lived broker connection and costs one licence request, which the licence
         service rate-limits per minute: fetch once and reuse the result rather than polling.
         """
         self._require_connected()
-        now = self.server_time or datetime.now(timezone.utc).replace(tzinfo=None)
-        end = self._server_naive(end)
-        start = self._server_naive(start)
-        if end is None:
-            end = now + timedelta(days=1)            # nothing the server has booked is later than this
-        if start is None:
-            start = now - timedelta(days=30)
+        start, end = self._window(start, end, "history")
         ms = int(timeout * 1000) if timeout is not None else int(self._api.DownloadOrderHistoryTimeoutMs)
         if ms <= 0:
             raise ValueError("timeout must be positive")
@@ -206,8 +210,7 @@ class _AccountMixin(_Base):
                 rows = self._api.DownloadOrderHistory(to_core_time(start), to_core_time(end), ms)
         return [Order._from_core(o) for o in (rows or ())]
 
-    async def ahistory(self, start: Optional[datetime] = None, end: Optional[datetime] = None,
-                       timeout: Optional[float] = None) -> List[Order]:
+    async def ahistory(self, start: datetime, end: datetime, timeout: Optional[float] = None) -> List[Order]:
         """Awaitable :meth:`history`. Cancelling the awaiting task abandons the download (the broker connection it
         opened is closed), so ``asyncio.wait_for(c.ahistory(...), 10)`` does not leave a request running."""
         cancel = threading.Event()
@@ -220,32 +223,55 @@ class _AccountMixin(_Base):
             cancel.set()
             raise
 
+    @property
+    def max_history_days(self) -> int:
+        """The longest window, in days, one :meth:`history`, :meth:`summary` or :meth:`equity_history` call may ask
+        for (default 366). A longer window raises :class:`InvalidRequestError` before anything is sent: split the
+        period into several calls, or raise this when you mean one long download. ``0`` removes the limit (the start
+        and end are still required)."""
+        return int(self._api.MaxHistoryDays)
+
+    @max_history_days.setter
+    def max_history_days(self, days: int) -> None:
+        self._api.MaxHistoryDays = _history_days(days)
+
+    def _window(self, start: Optional[datetime], end: Optional[datetime], what: str) -> tuple:
+        """``start`` and ``end`` in server time; both are required (the length is checked by the core)."""
+        if start is None or end is None:
+            raise InvalidRequestError("%s() needs a start and an end: history is always asked for by window "
+                             "(at most max_history_days, %d days, per call)" % (what, self.max_history_days))
+        return self._server_naive(start), self._server_naive(end)
+
     # ---- realized figures and curves ---------------------------------------------------------------------------
 
     @translated
-    def summary(self, start: Optional[datetime] = None, end: Optional[datetime] = None) -> AccountSummary:
-        """Realized trading result, deposits and withdrawals, from the closed-order ledger (all time by default).
+    def summary(self, start: datetime, end: datetime) -> AccountSummary:
+        """Realized trading result, deposits and withdrawals between ``start`` and ``end``, from the closed-order
+        ledger. Both ends are required; the window may be at most :attr:`max_history_days` long — for a longer period,
+        add up one summary per window (``balance`` is the account's current balance in each).
 
         Downloads the history, so it blocks and costs one licence request; call it off your UI thread (or use
         ``asyncio.to_thread``).
         """
         self._require_connected()
-        if start is None and end is None:
-            return AccountSummary._from_core(self._api.GetAccountSummary())
-        if start is None or end is None:
-            raise ValueError("give both start and end, or neither")
-        return AccountSummary._from_core(self._api.GetAccountSummary(to_core_time(self._server_naive(start)),
-                                                                     to_core_time(self._server_naive(end))))
+        start, end = self._window(start, end, "summary")
+        return AccountSummary._from_core(self._api.GetAccountSummary(to_core_time(start), to_core_time(end)))
 
     @translated
     def equity_history(self, start: datetime, timeframe: str = "D1", exclude_same_bars: bool = True) -> List[EquityPoint]:
-        """The balance and equity curve since ``start`` (``timeframe`` is ``H1``, ``H4`` or ``D1``).
+        """The balance and equity curve from ``start`` to now (``timeframe`` is ``H1``, ``H4`` or ``D1``); ``start``
+        may be at most :attr:`max_history_days` ago.
 
         ``balance`` is exact; the historical ``equity`` is a reconstruction priced from the symbols' bars. With
         ``exclude_same_bars`` (the default, as in the C# library) consecutive points with an unchanged balance and
-        equity are dropped. Downloads the history and per-symbol bars, so it blocks and costs a licence request.
+        equity are dropped. A window with no closed order in it is a flat line at the balance (never empty); the last
+        point is the live balance and equity. Downloads the history and per-symbol bars, so it blocks and costs a
+        licence request.
         """
         self._require_connected()
+        if start is None:
+            raise InvalidRequestError("equity_history() needs a start (at most max_history_days, %d days, ago)"
+                             % self.max_history_days)
         tf = enum_value(self._core.EquityTimeframe, timeframe, "equity timeframe")
         with self._bars_lock:                    # it downloads bars through the same single-flight request as bars()
             points = self._api.CalculateEquityHistory(to_core_time(self._server_naive(start)), tf,

{pmt4api-1.1.2 → pmt4api-1.2.0}/src/pmt4api/_coverage.py

@@ -42,6 +42,7 @@ COVERAGE: Dict[str, str] = {
     "ConnectTimeout": "Client(connect_timeout)",
     "GetQuoteTimeoutMs": "Client(quote_timeout)",
     "DownloadOrderHistoryTimeoutMs": "Client(history_timeout)",
+    "MaxHistoryDays": "Client.max_history_days",
     "DownloadQuoteHistoryTimeout": "Client(bars_timeout)",
     "NoServerMessagesTimeout": "Client(no_message_timeout)",
     "TradeTimeout": "Client(trade_timeout)",
@@ -182,6 +183,9 @@ NOTES: Dict[str, str] = {
                             "32767-bar limit; the server's own depth limit applies",
     "DownloadOrderHistory": "`timeout=` and a `threading.Event` for `cancel=` replace the timeout and cancellation "
                             "token arguments; `ahistory` cancels with the awaiting task",
+    "GetAccountSummary": "the window overload only (`summary(start, end)`); the core's all-time overload is "
+                         "obsolete and throws",
+    "MaxHistoryDays": "also a constructor argument, `Client(max_history_days=...)`",
     "Servers": "give `servers=[(host, port), ...]` to the constructor or call `add_server`",
     "Reconnect": "returns False when every server failed; with `auto_reconnect=True` the core does it by itself",
 }

{pmt4api-1.1.2 → pmt4api-1.2.0}/src/pmt4api/_runtime.py

@@ -1,15 +1,24 @@
-"""Locates the .NET runtime and the licensed core library and loads them once per process."""
+"""Locates the .NET runtime and the licensed core library and loads them once per process.
+
+Trust: whatever this module loads runs inside your Python process with your rights. The core library comes from
+``dll_path=``, else the ``WMT4API_DLL`` environment variable, else the wheel; the .NET runtime from ``DOTNET_ROOT``, else
+the wheel, else an installed one found through ``PATH``. Each of these decides which native and managed code is
+executed, so set them only from configuration you control, and do not run with an environment that someone else
+can change. ``enable_core_logging()`` reports once when the core or the runtime was chosen by the environment.
+"""
 from __future__ import annotations
 
 import glob
 import importlib
+import json
 import os
 import shutil
 import struct
 import sys
+import tempfile
 import threading
 from pathlib import Path
-from typing import Iterator, Optional
+from typing import Iterator, List, Optional
 
 from .errors import CoreNotFoundError, RuntimeNotFoundError
 
@@ -39,6 +48,8 @@ def _process_lock() -> "threading.RLock":
 _lock = _process_lock()
 _core = None
 _dll: Optional[Path] = None
+_chosen_by_environment: List[str] = []    # what the environment decided at load time (see trust_notes)
+_root_we_set: Optional[str] = None         # the DOTNET_ROOT value this module chose itself, if any
 
 
 def find_dll(explicit=None) -> Path:
@@ -94,18 +105,56 @@ def _ensure_dotnet_root() -> None:
         os.environ.setdefault("DOTNET_SYSTEM_GLOBALIZATION_INVARIANT", "1")
     if os.environ.get("DOTNET_ROOT"):
         return
+    global _root_we_set
     if (_BUNDLED_RUNTIME / "shared" / "Microsoft.NETCore.App").is_dir():
-        os.environ["DOTNET_ROOT"] = str(_BUNDLED_RUNTIME)
+        os.environ["DOTNET_ROOT"] = _root_we_set = str(_BUNDLED_RUNTIME)
         return
     for root in _dotnet_root_candidates():
         if (root / "shared" / "Microsoft.NETCore.App").is_dir():
-            os.environ["DOTNET_ROOT"] = str(root)
+            os.environ["DOTNET_ROOT"] = _root_we_set = str(root)
             return
     raise RuntimeNotFoundError(
         "No .NET runtime was found. Install the .NET 8 (or later) runtime, or set DOTNET_ROOT to its install directory."
     )
 
 
+def _runtime_version(root: Path) -> Optional[str]:
+    """The newest ``Microsoft.NETCore.App`` version installed under ``root`` (``shared/Microsoft.NETCore.App/<ver>``)."""
+    best = None
+    try:
+        entries = list((root / "shared" / "Microsoft.NETCore.App").iterdir())
+    except OSError:
+        return None
+    for d in entries:
+        try:
+            key = tuple(int(n) for n in d.name.split("-", 1)[0].split(".")[:3])
+        except ValueError:
+            continue
+        if d.is_dir() and (best is None or key > best[0]):
+            best = (key, d.name)
+    return best[1] if best else None
+
+
+def _start_coreclr(start, tmp: str) -> str:
+    """Start CoreCLR from the root in ``DOTNET_ROOT`` at a version that root holds; returns what was used.
+
+    Left to itself the loader asks a ``dotnet`` found on ``PATH`` for the installed runtimes and takes the newest — one
+    that only that other installation may have (a system .NET 10 next to the bundled 9 fails with
+    FrameworkMissingFailure). The runtime configuration written here names the root's own newest version instead.
+    """
+    root = Path(os.environ["DOTNET_ROOT"])
+    version = _runtime_version(root)
+    if version is None:                       # not a layout we can read: let the loader decide, as before
+        start("coreclr")
+        return "a runtime chosen by pythonnet"
+    cfg = Path(tmp) / "runtimeconfig.json"
+    cfg.write_text(json.dumps({"runtimeOptions": {
+        "tfm": "net" + ".".join(version.split("-", 1)[0].split(".")[:2]),
+        "framework": {"name": "Microsoft.NETCore.App", "version": version}}}), encoding="utf-8")
+    start("coreclr", runtime_config=str(cfg), dotnet_root=str(root))
+    return "Microsoft.NETCore.App %s in %s" % (version, root)
+
+
 def runtime_root() -> Optional[Path]:
     """The .NET root in use (after ``load``), or None."""
     root = os.environ.get("DOTNET_ROOT")
@@ -149,17 +198,24 @@ def load(dll_path=None):
                     "so dll_path=%s was not loaded" % (_dll, dll_path))
             return _core
         dll = find_dll(dll_path)
+        notes = []
+        if dll_path is None and os.environ.get(ENV_DLL):
+            notes.append("core library %s was named by the %s environment variable" % (dll, ENV_DLL))
+        if os.environ.get("DOTNET_ROOT") and os.environ["DOTNET_ROOT"] != _root_we_set:
+            notes.append(".NET runtime was taken from DOTNET_ROOT=%s, set by the environment" % os.environ["DOTNET_ROOT"])
         _ensure_dotnet_root()
+        tried = "the runtime in DOTNET_ROOT=%s" % os.environ.get("DOTNET_ROOT")
         try:
             from pythonnet import load as _load
-            _load("coreclr")
-            import clr  # noqa: F401  (provided by pythonnet)
+            with tempfile.TemporaryDirectory(prefix="pmt-runtime-") as tmp:
+                tried = _start_coreclr(_load, tmp)
+                import clr  # noqa: F401  (provided by pythonnet; the configuration is read by now)
         except Exception as e:  # noqa: BLE001 — anything here means the runtime could not start
             raise RuntimeNotFoundError(
                 "could not start the .NET runtime. The core needs the .NET 8 (or later) runtime, Microsoft.NETCore.App: "
                 "install it from https://dotnet.microsoft.com/download/dotnet/8.0 (`dotnet --list-runtimes` lists what "
-                "this machine has) or point DOTNET_ROOT at a folder that holds it.%s Detail: %s: %s"
-                % (_BITNESS_HINT if struct.calcsize("P") == 4 else "", type(e).__name__, str(e)[:240])) from e
+                "this machine has) or point DOTNET_ROOT at a folder that holds it.%s Tried: %s. Detail: %s: %s"
+                % (_BITNESS_HINT if struct.calcsize("P") == 4 else "", tried, type(e).__name__, str(e)[:240])) from e
         import clr as _clr
         from System.Reflection import Assembly      # available once the runtime is up
         try:
@@ -169,8 +225,14 @@ def load(dll_path=None):
         _clr.AddReference("wmt4api")                # now by name: registers the namespace for `import`
         _core = _import_namespace()
         _dll = dll
+        _chosen_by_environment[:] = notes
         return _core
 
 
 def loaded_dll() -> Optional[Path]:
     return _dll
+
+
+def trust_notes() -> List[str]:
+    """What the environment (``WMT4API_DLL``, ``DOTNET_ROOT``) chose when the core was loaded; empty if nothing."""
+    return list(_chosen_by_environment)

{pmt4api-1.1.2 → pmt4api-1.2.0}/src/pmt4api/_streams.py

@@ -1,9 +1,10 @@
 """Delivery machinery shared by the event API: one dispatcher thread per client, and the sync / async iterators.
 
-The core delivers each event on its own thread-pool task, so events can arrive concurrently and slightly out of order,
-and a slow callback would pile up threads. The client therefore converts every event to a plain value the moment it
-arrives (a snapshot — the core's objects are shared and mutable) and hands it to ONE dispatcher thread per client,
-which calls the callbacks one at a time, in arrival order. A callback may take its time; if it falls more than
+The core raises each kind of event one at a time, in the order it received them (cores before wmt4api 3.4.0 / wmt5api
+3.2.0 used one thread-pool task per event, so events could arrive concurrently and out of order). The client converts
+every event to a plain value the moment it arrives (a snapshot — the core's objects are shared and mutable) and hands it
+to ONE dispatcher thread per client, which calls the callbacks one at a time, in arrival order — so a slow callback
+never holds up the core's own delivery. A callback may take its time; if it falls more than
 ``EVENT_QUEUE`` events behind, the oldest events are dropped (a warning is logged, and ``Client.events_dropped``
 counts them). An exception raised by a callback is logged (under the package's own logger name) and swallowed so it
 cannot break the connection.

{pmt4api-1.1.2 → pmt4api-1.2.0}/src/pmt4api/client.py

@@ -80,6 +80,9 @@ class Client(_SessionMixin, _MarketMixin, _AccountMixin, _RiskMixin, _TradingMix
     ``comment_encoding`` is the codepage order comments are written in (default ``latin-1``); ``placed_type``
     records how orders are placed (``"manual"``, ``"expert"``, ``"dealer"``; a per-call ``placed_type`` overrides it).
 
+    History is always asked for by window: :meth:`history` and :meth:`summary` take a start and an end, and one call
+    covers at most ``max_history_days`` (default 366; ``0`` removes the limit).
+
     Callbacks run on a dispatcher thread of this client, not on the thread that created it.
     """
 
@@ -92,7 +95,7 @@ class Client(_SessionMixin, _MarketMixin, _AccountMixin, _RiskMixin, _TradingMix
                  auto_reconnect: bool = False, reconnect_backoff: Optional[float] = None,
                  reconnect_max_backoff: Optional[float] = None, reconnect_max_attempts: Optional[int] = None,
                  servers: Optional[Sequence[Tuple[str, int]]] = None, comment_encoding: str = "latin-1",
-                 placed_type: Optional[str] = None):
+                 placed_type: Optional[str] = None, max_history_days: Optional[int] = None):
         core = _runtime.load(dll_path)
         self._core = core
         self._login = int(login)
@@ -136,6 +139,8 @@ class Client(_SessionMixin, _MarketMixin, _AccountMixin, _RiskMixin, _TradingMix
             api.AutoReconnect = True
         if placed_type:
             self._trader.PlacedType = int(_placed(core.PlacedType, placed_type))
+        if max_history_days is not None:
+            self.max_history_days = max_history_days
         self._comment_encoding = comment_encoding
         api.Encoding = _net_encoding(comment_encoding)
         for h, p in (servers or ()):

{pmt4api-1.1.2 → pmt4api-1.2.0}/src/pmt4api/diagnostics.py

@@ -6,6 +6,8 @@ from typing import Any, Callable
 
 from . import _runtime
 
+_trust_reported = False
+
 _LEVELS = {"Trace": logging.DEBUG, "Debug": logging.DEBUG, "Info": logging.INFO, "Warn": logging.WARNING,
            "Error": logging.ERROR, "Exception": logging.ERROR}
 
@@ -27,6 +29,12 @@ def enable_core_logging(logger_name: str = "pmt4api.core") -> Callable[[], None]
         if logger.isEnabledFor(logging.DEBUG):
             logger.debug("%s", message)
 
+    global _trust_reported
+    if not _trust_reported:
+        _trust_reported = True
+        for note in _runtime.trust_notes():      # once per process: what the environment chose to load
+            logger.info("%s", note)
+
     core.Logger.OnMsgEx += on_msg
     sink = System.Action[System.String](on_diag)
     previous = core.Diag.Sink

{pmt4api-1.1.2 → pmt4api-1.2.0}/src/pmt4api/docs/API.md

@@ -5,7 +5,7 @@ Generated from the code (`tools/gen_docs.py`); do not edit by hand. Times are na
 ## Constructing a client
 
 ```python
-Client(login, password, host, port=443, *, api_key=None, token_url=None, dll_path=None, connect_timeout=None, token_timeout=None, trade_timeout=None, quote_timeout=None, history_timeout=None, bars_timeout=None, no_message_timeout=None, auto_reconnect=False, reconnect_backoff=None, reconnect_max_backoff=None, reconnect_max_attempts=None, servers=None, comment_encoding='latin-1', placed_type=None)
+Client(login, password, host, port=443, *, api_key=None, token_url=None, dll_path=None, connect_timeout=None, token_timeout=None, trade_timeout=None, quote_timeout=None, history_timeout=None, bars_timeout=None, no_message_timeout=None, auto_reconnect=False, reconnect_backoff=None, reconnect_max_backoff=None, reconnect_max_attempts=None, servers=None, comment_encoding='latin-1', placed_type=None, max_history_days=None)
 ```
 
 A connection to one MetaTrader 4 account through the licensed core.
@@ -36,6 +36,9 @@ and call `connect()` in a loop. `servers` are extra `(host, port)` access server
 `comment_encoding` is the codepage order comments are written in (default `latin-1`); `placed_type`
 records how orders are placed (`"manual"`, `"expert"`, `"dealer"`; a per-call `placed_type` overrides it).
 
+History is always asked for by window: `history` and `summary` take a start and an end, and one call
+covers at most `max_history_days` (default 366; `0` removes the limit).
+
 Callbacks run on a dispatcher thread of this client, not on the thread that created it.
 
 ## Connection and session
@@ -236,7 +239,7 @@ Account details. With `refresh` (the default) every open position's symbol is qu
 derived on the client (the server does not push them), as the terminal does; see `equity` for the cheap
 read of one figure.
 
-#### `async ahistory(start=None, end=None, timeout=None)`
+#### `async ahistory(start, end, timeout=None)`
 
 Awaitable `history`. Cancelling the awaiting task abandons the download (the broker connection it
 opened is closed), so `asyncio.wait_for(c.ahistory(...), 10)` does not leave a request running.
@@ -257,25 +260,31 @@ quotes.
 
 #### `equity_history(start, timeframe='D1', exclude_same_bars=True)`
 
-The balance and equity curve since `start` (`timeframe` is `H1`, `H4` or `D1`).
+The balance and equity curve from `start` to now (`timeframe` is `H1`, `H4` or `D1`); `start`
+may be at most `max_history_days` ago.
 
 `balance` is exact; the historical `equity` is a reconstruction priced from the symbols' bars. With
 `exclude_same_bars` (the default, as in the C# library) consecutive points with an unchanged balance and
-equity are dropped. Downloads the history and per-symbol bars, so it blocks and costs a licence request.
+equity are dropped. A window with no closed order in it is a flat line at the balance (never empty); the last
+point is the live balance and equity. Downloads the history and per-symbol bars, so it blocks and costs a
+licence request.
 
 #### `free_margin` *(property)*
 
 Equity − margin.
 
-#### `history(start=None, end=None, timeout=None, cancel=None)`
+#### `history(start, end, timeout=None, cancel=None)`
+
+Closed orders and balance / credit entries between `start` and `end`, sorted by close time. Blocks until
+the server has sent everything, up to `timeout` seconds (default: the client's `history_timeout`); set the
+`cancel` event to abandon the wait early (`RequestCancelled`).
 
-Closed orders and balance / credit entries between `start` and `end` (default: the last 30 days up to
-now), sorted by close time. Blocks until the server has sent everything, up to `timeout` seconds (default:
-the client's `history_timeout`); set the `cancel` event to abandon the wait early
-(`RequestCancelled`).
+Both ends are required and the window may be at most `max_history_days` long (366 by default): a missing,
+reversed or longer window raises `InvalidRequestError` before anything is sent. For a longer period,
+call once per window and add the results up. For "up to now", pass `c.server_time` as `end`.
 
 Naive datetimes are used exactly as given, in the broker's server time; timezone-aware ones are converted to
-it. The default window is computed on the server's clock.
+it.
 
 Each call opens its own short-lived broker connection and costs one licence request, which the licence
 service rate-limits per minute: fetch once and reuse the result rather than polling.
@@ -299,6 +308,13 @@ conversion quote.
 
 Equity / margin × 100, as the terminal shows it; 0 when no margin is used.
 
+#### `max_history_days` *(property)*
+
+The longest window, in days, one `history`, `summary` or `equity_history` call may ask
+for (default 366). A longer window raises `InvalidRequestError` before anything is sent: split the
+period into several calls, or raise this when you mean one long download. `0` removes the limit (the start
+and end are still required).
+
 #### `order(ticket)`
 
 One open order or position by ticket, or `None` when it is not open.
@@ -320,9 +336,11 @@ Open market positions only (`Buy` / `Sell`).
 
 The floating P/L of the open positions (equity − balance − credit), from cached quotes.
 
-#### `summary(start=None, end=None)`
+#### `summary(start, end)`
 
-Realized trading result, deposits and withdrawals, from the closed-order ledger (all time by default).
+Realized trading result, deposits and withdrawals between `start` and `end`, from the closed-order
+ledger. Both ends are required; the window may be at most `max_history_days` long — for a longer period,
+add up one summary per window (`balance` is the account's current balance in each).
 
 Downloads the history, so it blocks and costs one licence request; call it off your UI thread (or use
 `asyncio.to_thread`).

{pmt4api-1.1.2 → pmt4api-1.2.0}/src/pmt4api/docs/FROM-CSHARP.md

@@ -29,7 +29,7 @@ Every public member of the C# `MT4API` and `OrderClient` classes and where it we
 | `DownloadQuoteHistory` | `Client.bars` | `count=` bars ending at `end`, or everything since `start=`; pages past the wire's 32767-bar limit; the server's own depth limit applies |
 | `DownloadQuoteHistoryTimeout` | `Client(bars_timeout)` |  |
 | `Encoding` | `Client(comment_encoding)` |  |
-| `GetAccountSummary` | `Client.summary` |  |
+| `GetAccountSummary` | `Client.summary` | the window overload only (`summary(start, end)`); the core's all-time overload is obsolete and throws |
 | `GetAskTickValue` | `Client.tick_value` |  |
 | `GetBidTickValue` | `Client.tick_value` |  |
 | `GetOpenedOrder` | `Client.order` |  |
@@ -48,6 +48,7 @@ Every public member of the C# `MT4API` and `OrderClient` classes and where it we
 | `LiveEquityCached` | `Client.equity` |  |
 | `LiveMarginCached` | `Client.margin` |  |
 | `LoadServersIni` | `pmt4api.load_servers_ini` |  |
+| `MaxHistoryDays` | `Client.max_history_days` | also a constructor argument, `Client(max_history_days=...)` |
 | `NoServerMessagesTimeout` | `Client(no_message_timeout)` |  |
 | `OnConnect` | `Client.on_connect` |  |
 | `OnDisconnect` | `Client.on_disconnect` |  |

{pmt4api-1.1.2 → pmt4api-1.2.0}/src/pmt4api/errors.py

@@ -171,6 +171,17 @@ def _python_words(text: str) -> str:
                          "pass token_url= to Client(...) or set the WMT4API_TOKEN_URL environment variable"))
 
 
+def _window_words(text: str) -> str:
+    """The core names the history-window arguments as a C# program sees them; say them as this package takes them."""
+    for core, ours in (("MaxHistoryDays", "max_history_days"), ("window (from)", "window (start)"),
+                       ("window (to)", "window (end)"), ("reversed (from ", "reversed (start "),
+                       (" is after to ", " is after end ")):
+        text = text.replace(core, ours)
+    for name in ("from", "to"):                      # .NET appends the parameter name the text already gives
+        text = text.replace(" (Parameter '%s')" % name, "")
+    return text
+
+
 def _status(text: str) -> Optional[int]:
     """The number in "... rejected (status N)" of the core's bare connect-phase refusals."""
     if "(status " not in text:
@@ -227,7 +238,7 @@ def translate(exc: BaseException) -> Optional[WmtError]:
         if kind == "cancelled":
             return RequestCancelled(message)
         if kind == "invalid":
-            return InvalidRequestError(message)
+            return InvalidRequestError(_window_words(message))
     name = type(exc).__name__
     module = getattr(type(exc), "__module__", "")
     if name == "Exception" and module == "System":