pmt5api 1.1.2__tar.gz → 1.2.0__tar.gz

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

@@ -1,5 +1,59 @@
 # Changelog — pmt5api
 
+## [1.2.0] — 2026-11-06
+
+Bundles **wmt5api 3.2.1**. 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 read every deal since 1970 for it, on every call). A
+  missing or reversed window raises `InvalidRequestError` before anything is sent; `request_history(start, end)`
+  likewise.
+- **One call covers at most `max_history_days` (366 by default).** A longer window raises `InvalidRequestError`
+  before anything is sent. 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)` and `calibrate_money_scale(start)` run to now, so their start is at most that long ago (an
+  older one makes `calibrate_money_scale` return `False`, the reason in `money_scale_evidence`).
+- What to change: `c.summary()` → `c.summary(start, end)`; `c.history()` → `c.history(start, end)` (for "up to now",
+  `end = c.server_time`); a calibration over two years → over at most one.
+
+### Added
+- `Client.max_history_days` (read and write) and the constructor argument of the same name.
+- `Client.server_name`: the name of the trade server the session logged in to (for example `ICMarketsSC-Demo`).
+
+### Changed (core wmt5api 3.2.0 / 3.2.1)
+- `history()` asks the server for your window only (the server answers in whole calendar months; before, three more
+  months were asked for on every call). A position closed in the window but held longer than three months before it
+  is now listed in `orders` (up to a year back); a position whose deals arrived in different pages is no longer
+  dropped.
+- Two `history()` calls at once on one client run one after the other instead of failing with `BusyError`.
+
+### 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 wmt5api 3.2.0 / 3.2.1)
+- **Events could reach callbacks out of order** — an order's close before its open, an older price after a newer one,
+  a disconnect before the connect. Quotes, order updates, order progress, connect progress and history chunks now
+  arrive in the order the client received them; a throwing handler no longer drops the rest of a batch.
+- **A market order or close with the default fill policy could use a filling mode the symbol does not accept**, and
+  the broker refused it (`UNSUPPORTED_FILLING_MODE`): the symbol's declared modes are a bit mask and were read as one
+  value. The default now picks a declared mode (fill-or-kill if declared, else immediate-or-cancel, else return on an
+  exchange).
+- `Order.fill_policy` of a market order filled immediate-or-cancel read fill-or-kill; it reports the mode the server
+  confirmed.
+- `equity_history()`: the documentation no longer says "empty" for a window with no deal (it is a flat line).
+
+### Security (core wmt5api 3.2.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.

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: pmt5api
-Version: 1.1.2
+Version: 1.2.0
 Summary: Complete Python interface to the wmt5api MetaTrader 5 client library (market data, account, sizing, order entry, events).
 Project-URL: Homepage, https://mtapi.one
 Author: Sen Trading
@@ -202,9 +202,9 @@ Do not size a trade from a one-line formula: what a price unit is worth depends
 from your own closed deals and refuses to size without that evidence:
 
 ```python
-from datetime import datetime
+from datetime import timedelta
 
-if c.calibrate_money_scale(datetime(2025, 1, 1)):                 # read-only; places no order
+if c.calibrate_money_scale(c.server_time - timedelta(days=365)):  # read-only; places no order; at most a year back
     r = c.lots_for_risk("EURUSD", entry_price=1.1000, stop_price=1.0950, risk_amount=50.0, side="buy")
     for w in r.warnings:
         print("warning:", w)              # read these: ok can still be True with a caveat
@@ -228,12 +228,29 @@ to be checked. Also: `required_margin(symbol, lots)`, `order_profit(symbol, open
 | `account(refresh=True)` | `AccountInfo` — balance, equity, floating P/L (with and without swap/commission), margin, free margin, margin level, leverage, account mode, contact details |
 | `orders()` / `positions()` / `closed_orders()` | `list[Order]` — working / open positions only / what this session saw close |
 | `history(start, end)` / `deal_history(year, month)` | `History` — `.orders` and `.deals` (the ledger, including deposits and withdrawals) |
-| `summary(start=None, end=None)` | `AccountSummary` — realized profit, deposits, withdrawals, from the deal ledger |
+| `summary(start, end)` | `AccountSummary` — realized profit, deposits, withdrawals, from the deal ledger |
 | `equity_history(start, "D1")` | `list[EquityPoint]` — balance (exact) and equity (reconstructed) curve with drawdowns |
 | `request_history(...)`, `request_bars(...)` | without waiting; the data arrives through `on_history` / `on_quote_history` |
 
 Times are naive `datetime` values in the **broker's server time**, as the server reports them; 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()` and
+`calibrate_money_scale()` run from their start to now, so the 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"
+h = c.history(end - timedelta(days=30), end)             # .orders and .deals
+year = c.summary(end - timedelta(days=365), end)
+```
+
+The server answers history in whole calendar months; `history()` keeps your window, and lists a position closed in it
+whose opening deal is earlier (up to a year before the window). A window with no deal in it gives a flat equity curve
+at the balance, never an empty one.
+
 `account()` first quotes each open position's symbol once and recalculates profits, so equity, profit and margin
 level are current (a cold read would otherwise show equity equal to balance). Pass `refresh=False` to skip that.
 
@@ -241,7 +258,9 @@ level are current (a cold read would otherwise show equity equal to balance). Pa
 
 `on_quote`, `on_order_update`, `on_order_progress`, `on_connect_progress`, `on_history`, `on_quote_history`,
 `on_symbols_update`, `on_symbol_update` — each returns a function that removes the callback. `quotes()` and
-`order_updates()` (and the `a…` async versions) turn a stream into an iterator.
+`order_updates()` (and the `a…` async versions) turn a stream into an iterator. Events reach you in the order the
+client received them — an order's open before its close, ticks in time order — and callbacks run one at a time on the
+client's own thread.
 
 ## Staying connected
 
@@ -262,12 +281,20 @@ subscriptions are restored, cached snapshots are not.
 | Reconnect | `auto_reconnect`, `reconnect_backoff` (3, doubling up to `reconnect_max_backoff`, 30), `reconnect_max_attempts` (0 = no limit) | — |
 | Proxy | `proxy=Proxy("socks5" \| "socks4" \| "https", host, port, user, password)` — `host` must be an IP address | — |
 | Client certificate / common key | `certificate=`, `certificate_password=`, `common_key=` | — |
+| 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 `WMTAPI_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.
 
+**These two settings decide what code runs in your process.** `WMTAPI_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

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

@@ -175,9 +175,9 @@ Do not size a trade from a one-line formula: what a price unit is worth depends
 from your own closed deals and refuses to size without that evidence:
 
 ```python
-from datetime import datetime
+from datetime import timedelta
 
-if c.calibrate_money_scale(datetime(2025, 1, 1)):                 # read-only; places no order
+if c.calibrate_money_scale(c.server_time - timedelta(days=365)):  # read-only; places no order; at most a year back
     r = c.lots_for_risk("EURUSD", entry_price=1.1000, stop_price=1.0950, risk_amount=50.0, side="buy")
     for w in r.warnings:
         print("warning:", w)              # read these: ok can still be True with a caveat
@@ -201,12 +201,29 @@ to be checked. Also: `required_margin(symbol, lots)`, `order_profit(symbol, open
 | `account(refresh=True)` | `AccountInfo` — balance, equity, floating P/L (with and without swap/commission), margin, free margin, margin level, leverage, account mode, contact details |
 | `orders()` / `positions()` / `closed_orders()` | `list[Order]` — working / open positions only / what this session saw close |
 | `history(start, end)` / `deal_history(year, month)` | `History` — `.orders` and `.deals` (the ledger, including deposits and withdrawals) |
-| `summary(start=None, end=None)` | `AccountSummary` — realized profit, deposits, withdrawals, from the deal ledger |
+| `summary(start, end)` | `AccountSummary` — realized profit, deposits, withdrawals, from the deal ledger |
 | `equity_history(start, "D1")` | `list[EquityPoint]` — balance (exact) and equity (reconstructed) curve with drawdowns |
 | `request_history(...)`, `request_bars(...)` | without waiting; the data arrives through `on_history` / `on_quote_history` |
 
 Times are naive `datetime` values in the **broker's server time**, as the server reports them; 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()` and
+`calibrate_money_scale()` run from their start to now, so the 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"
+h = c.history(end - timedelta(days=30), end)             # .orders and .deals
+year = c.summary(end - timedelta(days=365), end)
+```
+
+The server answers history in whole calendar months; `history()` keeps your window, and lists a position closed in it
+whose opening deal is earlier (up to a year before the window). A window with no deal in it gives a flat equity curve
+at the balance, never an empty one.
+
 `account()` first quotes each open position's symbol once and recalculates profits, so equity, profit and margin
 level are current (a cold read would otherwise show equity equal to balance). Pass `refresh=False` to skip that.
 
@@ -214,7 +231,9 @@ level are current (a cold read would otherwise show equity equal to balance). Pa
 
 `on_quote`, `on_order_update`, `on_order_progress`, `on_connect_progress`, `on_history`, `on_quote_history`,
 `on_symbols_update`, `on_symbol_update` — each returns a function that removes the callback. `quotes()` and
-`order_updates()` (and the `a…` async versions) turn a stream into an iterator.
+`order_updates()` (and the `a…` async versions) turn a stream into an iterator. Events reach you in the order the
+client received them — an order's open before its close, ticks in time order — and callbacks run one at a time on the
+client's own thread.
 
 ## Staying connected
 
@@ -235,12 +254,20 @@ subscriptions are restored, cached snapshots are not.
 | Reconnect | `auto_reconnect`, `reconnect_backoff` (3, doubling up to `reconnect_max_backoff`, 30), `reconnect_max_attempts` (0 = no limit) | — |
 | Proxy | `proxy=Proxy("socks5" \| "socks4" \| "https", host, port, user, password)` — `host` must be an IP address | — |
 | Client certificate / common key | `certificate=`, `certificate_password=`, `common_key=` | — |
+| 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 `WMTAPI_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.
 
+**These two settings decide what code runs in your process.** `WMTAPI_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

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

@@ -3,7 +3,7 @@
     PMT5_LOGIN=... PMT5_PASSWORD=... PMT5_HOST=... python pnl.py
 """
 import os
-from datetime import datetime, timedelta
+from datetime import timedelta
 
 from pmt5api import Client
 
@@ -13,10 +13,12 @@ with Client(int(os.environ["PMT5_LOGIN"]), os.environ["PMT5_PASSWORD"], os.envir
     print("balance %.2f  equity %.2f  floating %.2f  (swap %.2f, commission %.2f)"
           % (a.balance, a.equity, a.floating_pl, a.swap, a.commission))
 
-    s = c.summary()                                   # from the deal 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(datetime.now() - timedelta(days=30), "D1")
+    curve = c.equity_history(now - timedelta(days=30), "D1")
     for p in curve[-5:]:
         flag = "  (incomplete)" if p.incomplete else ""
         print("%s  balance %.2f  equity %.2f  drawdown %.2f%%%s"

{pmt5api-1.1.2 → pmt5api-1.2.0}/examples/sizing.py

@@ -4,7 +4,7 @@
 """
 import os
 import sys
-from datetime import datetime, timedelta
+from datetime import timedelta
 
 from pmt5api import Client
 
@@ -19,8 +19,8 @@ with Client(int(os.environ["PMT5_LOGIN"]), os.environ["PMT5_PASSWORD"], os.envir
     acct = c.account()
     print("account currency %s, equity %.2f" % (acct.currency, acct.equity))
 
-    # 1. measure the account's own conventions from its closed deals (read-only; places no order)
-    if not c.calibrate_money_scale(datetime.now() - timedelta(days=730)):
+    # 1. measure the account's own conventions from its closed deals of the last year (read-only; places no order)
+    if not c.calibrate_money_scale(c.server_time - timedelta(days=365)):
         sys.exit("cannot size yet: " + c.money_scale_evidence)
     print("money scale %s" % c.money_scale)
 

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

@@ -17,7 +17,7 @@ from .models import (AccountInfo, AccountSummary, BaseInfo, CommissionInfo, Comm
                      OrderUpdate, Quote, ServerRecord, SymbolInfo, SymbolSessions, TradingSession)
 from .servers import load_servers_dat, request_demo_account, save_servers_dat, tick_value_from_deal
 
-__version__ = "1.1.2"
+__version__ = "1.2.0"
 
 __all__ = [
     "Client", "Proxy",

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

@@ -1,15 +1,22 @@
 """The account: balances, positions, orders, history, and the curves derived from them."""
 from __future__ import annotations
 
-from datetime import datetime, timedelta, timezone
-from typing import List, Optional
+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
+from .errors import InvalidRequestError, NotConnectedError
 from .models import AccountInfo, AccountSummary, EquityPoint, History, Order
 
 
+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
+
+
 def _money(value) -> float:
     """A money figure without the binary noise the core's sums carry (1635341.7899999998 becomes 1635341.79)."""
     return round(float(value), 8)
@@ -82,22 +89,20 @@ class _AccountMixin(_Base):
     # ---- history -----------------------------------------------------------------------------------------------
 
     @translated
-    def history(self, start: Optional[datetime] = None, end: Optional[datetime] = None,
-                timeout: Optional[float] = None) -> History:
-        """Orders and deals between ``start`` and ``end`` (default: the last 30 days up to now). Blocks until the
-        server has sent everything, up to ``timeout`` seconds (default: the client's ``history_timeout``).
+    def history(self, start: datetime, end: datetime, timeout: Optional[float] = None) -> History:
+        """Orders and deals between ``start`` and ``end``. Blocks until the server has sent everything, up to
+        ``timeout`` seconds (default: the client's ``history_timeout``).
+
+        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``. ``orders``
+        also lists a position closed in the window whose opening deal is earlier (up to a year before the window).
 
         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. Two calls at once on one client run one after the other (the wait counts toward the second one's timeout).
         """
         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)
         return History._from_core(self._api.DownloadOrderHistory(to_core_time(start), to_core_time(end), ms))
 
@@ -110,10 +115,12 @@ class _AccountMixin(_Base):
     @translated
     def request_history(self, start: datetime, end: datetime) -> None:
         """Ask for history without waiting; it arrives through :meth:`on_history`. The server's answer is not trimmed
-        to ``start`` / ``end`` (it can hold more than you asked for, in pages): filter by time. The blocking
-        :meth:`history` does trim."""
+        to ``start`` / ``end`` (it comes in whole calendar months, in pages): filter by time. The blocking
+        :meth:`history` does trim. The window rules of :meth:`history` apply; refused while a :meth:`history`
+        download runs on this client (:class:`BusyError`), because the answers would mix."""
         self._require_connected()
-        self._api.RequestOrderHistory(to_core_time(self._server_naive(start)), to_core_time(self._server_naive(end)))
+        start, end = self._window(start, end, "request_history")
+        self._api.RequestOrderHistory(to_core_time(start), to_core_time(end))
 
     @translated
     def request_history_month(self, year: int, month: int) -> None:
@@ -121,32 +128,54 @@ class _AccountMixin(_Base):
         self._require_connected()
         self._api.RequestOrderHistory(int(year), int(month))
 
+    @property
+    def max_history_days(self) -> int:
+        """The longest window, in days, one :meth:`history`, :meth:`request_history`, :meth:`summary`,
+        :meth:`equity_history` or :meth:`calibrate_money_scale` 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 deal 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 deal 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 deal history, so it blocks; 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 bar-priced reconstruction and a point with
         ``incomplete`` set has understated floating P/L. With ``exclude_same_bars`` (the default, as in the C# library)
-        consecutive points with an unchanged balance and equity are dropped. Downloads deals and per-symbol bars, so it
-        blocks.
+        consecutive points with an unchanged balance and equity are dropped. A window with no deal in it is a flat line
+        at the balance (never empty); the last point is the live balance and equity. Downloads deals and per-symbol
+        bars, so it blocks.
         """
         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")
         points = self._api.CalculateEquityHistory(to_core_time(self._server_naive(start)), tf, bool(exclude_same_bars))
         return [EquityPoint._from_core(p) for p in (points or ())]

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

@@ -36,7 +36,7 @@ COVERAGE: Dict[str, str] = {
     "User": "Client.login",
     "Password": "Client(password)",
     "Host": "Client.host",
-    "Server": "Client.host",
+    "Server": "Client.server_name",
     "Port": "Client.port",
     "Id": "not applicable: a free-form tag for the caller's own use; keep it in your own code",
     "ProcessServerMessagesInThread": "not applicable: documented by the core as reserved and unused",
@@ -52,6 +52,7 @@ COVERAGE: Dict[str, str] = {
     "ExecutionTimeout": "Client(execution_timeout)",
     "GetQuoteTimeoutMs": "Client(quote_timeout)",
     "DownloadOrderHistoryTimeoutMs": "Client(history_timeout)",
+    "MaxHistoryDays": "Client.max_history_days",
     "DownloadQuoteHistoryTimeout": "Client(bars_timeout)",
     "PingTime": "Client(ping_interval)",
     "NoServerMessagesTimeout": "Client(no_message_timeout)",

{pmt5api-1.1.2 → pmt5api-1.2.0}/src/pmt5api/_risk.py

@@ -16,7 +16,9 @@ class _RiskMixin(_Base):
     def calibrate_money_scale(self, start: datetime, *, min_deals_per_symbol: Optional[int] = None,
                               max_self_scatter: Optional[float] = None, max_disagreement: Optional[float] = None,
                               max_snap_distance: Optional[float] = None) -> bool:
-        """Measure what a price unit is worth *on this account* from its own closed deals since ``start``.
+        """Measure what a price unit is worth *on this account* from its own closed deals from ``start`` to now;
+        ``start`` may be at most :attr:`max_history_days` ago (an older one returns ``False``, the reason in
+        :attr:`money_scale_evidence`).
 
         Read-only; places no order. Cent handling is a per-broker configuration, not a property of the currency, so
         sizing is refused until this has succeeded. Returns ``False`` when the scale cannot be established (read
@@ -42,7 +44,7 @@ class _RiskMixin(_Base):
     @property
     def money_scale_evidence(self) -> str:
         """Why the scale is what it is, or why it could not be established."""
-        return str(self._api.MoneyScaleEvidence or "")
+        return str(self._api.MoneyScaleEvidence or "").replace("MaxHistoryDays", "max_history_days")
 
     @translated
     def lots_for_risk(self, symbol: str, entry_price: float, stop_price: float, risk_amount: float, *,

{pmt5api-1.1.2 → pmt5api-1.2.0}/src/pmt5api/_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 ``WMTAPI_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("wmt5api")                # 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 (``WMTAPI_DLL``, ``DOTNET_ROOT``) chose when the core was loaded; empty if nothing."""
+    return list(_chosen_by_environment)

{pmt5api-1.1.2 → pmt5api-1.2.0}/src/pmt5api/_session.py

@@ -103,6 +103,13 @@ class _SessionMixin(_Base):
         """The access server this client was created for (it may fail over to a cluster member)."""
         return str(self._api.Host or self._host)
 
+    @property
+    def server_name(self) -> Optional[str]:
+        """The name of the trade server the session logged in to (for example ``ICMarketsSC-Demo``), as the server
+        reports it while connecting; ``None`` before the first connect. The address dialled is :attr:`host`."""
+        name = self._api.Server
+        return str(name) if name else None
+
     @property
     def port(self) -> int:
         """The access-server port."""

{pmt5api-1.1.2 → pmt5api-1.2.0}/src/pmt5api/_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.

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

@@ -61,7 +61,11 @@ class Client(_SessionMixin, _MarketMixin, _AccountMixin, _RiskMixin, _TradingMix
     or ``"expert"``; a per-call ``placed_type="manual"`` equals the default and so takes the client's value). ``all_order_updates=True`` also delivers the intermediate order states to
     :meth:`on_order_update`.
 
-    Callbacks run on the core's worker threads, not on the thread that created the client.
+    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, one at a time and in the order the events arrived — not on
+    the thread that created the client.
     """
 
     def __init__(self, login: int, password: str, host: str, port: int = 443, *,
@@ -75,7 +79,8 @@ class Client(_SessionMixin, _MarketMixin, _AccountMixin, _RiskMixin, _TradingMix
                  reconnect_max_backoff: Optional[float] = None, reconnect_max_attempts: Optional[int] = None,
                  proxy: Optional[Proxy] = None, certificate: Optional[bytes] = None,
                  certificate_password: Optional[str] = None, common_key: Optional[bytes] = None,
-                 placed_type: Optional[str] = None, all_order_updates: bool = False):
+                 placed_type: Optional[str] = None, all_order_updates: bool = False,
+                 max_history_days: Optional[int] = None):
         core = _runtime.load(dll_path)
         self._core = core
         self._login = int(login)
@@ -109,6 +114,8 @@ class Client(_SessionMixin, _MarketMixin, _AccountMixin, _RiskMixin, _TradingMix
             api.EnableAllOrderUpdates = True
         if placed_type:
             api.PlacedType = _placed(core.PlacedType, placed_type)
+        if max_history_days is not None:
+            self.max_history_days = max_history_days
         if proxy is not None:
             api.ProxyEnable = True
             api.ProxyType = enum_value(core.ProxyTypes, proxy.kind, "proxy kind")

{pmt5api-1.1.2 → pmt5api-1.2.0}/src/pmt5api/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 = "pmt5api.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

{pmt5api-1.1.2 → pmt5api-1.2.0}/src/pmt5api/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, cluster_member_timeout=None, token_timeout=None, execution_timeout=None, quote_timeout=None, history_timeout=None, bars_timeout=None, ping_interval=None, no_message_timeout=None, auto_reconnect=False, reconnect_backoff=None, reconnect_max_backoff=None, reconnect_max_attempts=None, proxy=None, certificate=None, certificate_password=None, common_key=None, placed_type=None, all_order_updates=False)
+Client(login, password, host, port=443, *, api_key=None, token_url=None, dll_path=None, connect_timeout=None, cluster_member_timeout=None, token_timeout=None, execution_timeout=None, quote_timeout=None, history_timeout=None, bars_timeout=None, ping_interval=None, no_message_timeout=None, auto_reconnect=False, reconnect_backoff=None, reconnect_max_backoff=None, reconnect_max_attempts=None, proxy=None, certificate=None, certificate_password=None, common_key=None, placed_type=None, all_order_updates=False, max_history_days=None)
 ```
 
 A connection to one MetaTrader 5 account through the licensed core.
@@ -38,7 +38,11 @@ require one. `placed_type` records how orders are placed (`"manual"`
 or `"expert"`; a per-call `placed_type="manual"` equals the default and so takes the client's value). `all_order_updates=True` also delivers the intermediate order states to
 `on_order_update`.
 
-Callbacks run on the core's worker threads, not on the thread that created the client.
+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, one at a time and in the order the events arrived — not on
+the thread that created the client.
 
 ## Connection and session
 
@@ -131,6 +135,11 @@ The access-server port.
 The underlying core object, for anything this layer does not wrap. Calls made on it raise the core's own
 exceptions, not pmt5api's.
 
+#### `server_name` *(property)*
+
+The name of the trade server the session logged in to (for example `ICMarketsSC-Demo`), as the server
+reports it while connecting; `None` before the first connect. The address dialled is `host`.
+
 #### `server_time` *(property)*
 
 The server's clock, kept current by incoming quotes (server time, naive); `None` before the first
@@ -273,20 +282,34 @@ One calendar month of history (a convenience over `history`).
 
 #### `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 bar-priced reconstruction and a point with
 `incomplete` set has understated floating P/L. With `exclude_same_bars` (the default, as in the C# library)
-consecutive points with an unchanged balance and equity are dropped. Downloads deals and per-symbol bars, so it
-blocks.
+consecutive points with an unchanged balance and equity are dropped. A window with no deal in it is a flat line
+at the balance (never empty); the last point is the live balance and equity. Downloads deals and per-symbol
+bars, so it blocks.
 
-#### `history(start=None, end=None, timeout=None)`
+#### `history(start, end, timeout=None)`
 
-Orders and deals between `start` and `end` (default: the last 30 days up to now). Blocks until the
-server has sent everything, up to `timeout` seconds (default: the client's `history_timeout`).
+Orders and deals between `start` and `end`. Blocks until the server has sent everything, up to
+`timeout` seconds (default: the client's `history_timeout`).
+
+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`. `orders`
+also lists a position closed in the window whose opening deal is earlier (up to a year before the window).
 
 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. Two calls at once on one client run one after the other (the wait counts toward the second one's timeout).
+
+#### `max_history_days` *(property)*
+
+The longest window, in days, one `history`, `request_history`, `summary`,
+`equity_history` or `calibrate_money_scale` 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).
 
 #### `orders()`
 
@@ -302,16 +325,19 @@ order's `state` is not used: the core can leave a freshly opened position in `St
 #### `request_history(start, end)`
 
 Ask for history without waiting; it arrives through `on_history`. The server's answer is not trimmed
-to `start` / `end` (it can hold more than you asked for, in pages): filter by time. The blocking
-`history` does trim.
+to `start` / `end` (it comes in whole calendar months, in pages): filter by time. The blocking
+`history` does trim. The window rules of `history` apply; refused while a `history`
+download runs on this client (`BusyError`), because the answers would mix.
 
 #### `request_history_month(year, month)`
 
 Ask for one calendar month of history without waiting; it arrives through `on_history`.
 
-#### `summary(start=None, end=None)`
+#### `summary(start, end)`
 
-Realized trading result, deposits and withdrawals, from the deal ledger (all time by default).
+Realized trading result, deposits and withdrawals between `start` and `end`, from the deal 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 deal history, so it blocks; call it off your UI thread (or use `asyncio.to_thread`).
 
@@ -324,7 +350,9 @@ use `account(refresh=True)`, which does both).
 
 #### `calibrate_money_scale(start, *, min_deals_per_symbol=None, max_self_scatter=None, max_disagreement=None, max_snap_distance=None)`
 
-Measure what a price unit is worth *on this account* from its own closed deals since `start`.
+Measure what a price unit is worth *on this account* from its own closed deals from `start` to now;
+`start` may be at most `max_history_days` ago (an older one returns `False`, the reason in
+`money_scale_evidence`).
 
 Read-only; places no order. Cent handling is a per-broker configuration, not a property of the currency, so
 sizing is refused until this has succeeded. Returns `False` when the scale cannot be established (read

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

@@ -66,6 +66,7 @@ Every public member of the C# `MT5API` class and where it went. Generated from `
 | `LastServerMessageTime` | `Client.last_server_message_time` |
 | `LedgerValuePerUnitLot` | `Client.ledger_value_per_lot` |
 | `LoadServersDat` | `pmt5api.load_servers_dat` |
+| `MaxHistoryDays` | `Client.max_history_days` |
 | `MoneyScale` | `Client.money_scale` |
 | `MoneyScaleEvidence` | `Client.money_scale_evidence` |
 | `MoneyScaleFromDeal` | `Client.money_scale_from_deal` |
@@ -114,7 +115,7 @@ Every public member of the C# `MT5API` class and where it went. Generated from `
 | `RequestQuoteHistoryToday` | `Client.request_bars` |
 | `RequiredMargin` | `Client.required_margin` |
 | `SaveServersDat` | `pmt5api.save_servers_dat` |
-| `Server` | `Client.host` |
+| `Server` | `Client.server_name` |
 | `ServerSymBuild` | `Client.symbol_build` |
 | `ServerTime` | `Client.server_time` |
 | `ServerTimeZoneInMinutes` | `Client.server_utc_offset` |

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

@@ -120,6 +120,17 @@ _BARE_MESSAGES = (
 _WRAPPERS = ("AggregateException", "TargetInvocationException")
 
 
+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 translate(exc: BaseException) -> Optional[WmtError]:
     """Return the pmt5api error that corresponds to a core exception, or ``None`` if it is not one of ours.
 
@@ -151,6 +162,8 @@ def translate(exc: BaseException) -> Optional[WmtError]:
             return cls(message, str(code) if code is not None else None, value)
         if cls is ConnectError and message.startswith("Disconnected"):
             return ConnectionLostError(message)
+        if cls is InvalidRequestError:
+            message = _window_words(message)
         return cls(message)
     if type(exc).__name__ == "Exception" and getattr(type(exc), "__module__", "") == "System":
         text = str(getattr(exc, "Message", None) or exc)