pmt5api 1.0.0__tar.gz → 1.1.2__tar.gz

pmt5api-1.1.2/CHANGELOG.md

@@ -0,0 +1,79 @@
+# Changelog — pmt5api
+
+## [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.
+
+### Fixed
+- A `bars()` timeout says the budget of the call (`not complete within 0.5 s`), not what was left for the last block.
+- `Order` and `Deal` money fields (profit, swap, commission, fee) carry no binary noise (`1.3900000000000001` is `1.39`).
+- README: a connect to an unreachable licence service waits about twice `token_timeout`.
+
+## [1.1.1] — 2026-10-14
+
+From the Windows re-test of 1.1.0 (13 notes, one S2). Bundles wmt5api 3.1.2.
+
+### Fixed
+- **`equity_history()` returned `[]` for a window with no deal** (an idle account): the balance curve is now a flat line
+  at the current balance (core `wmt5api 3.1.2`). A script that read `eq[-1]` on an idle account raised `IndexError`.
+- Account money figures carry no binary noise (`1635341.7899999998` is `1635341.79`).
+- A bars timeout states a sub-second wait as it is (`0.5 s`, not `0 s`).
+- A missing .NET runtime on a **32-bit** Python says that 32-bit Python needs the 32-bit runtime.
+- `SymbolInfo` has a meaning for every field in the reference.
+- README: ticks and their `time`, that the server enforces volume min/step, the minute rounding of an expiry, Ctrl+C
+  during `connect()`, the licence request retry.
+
+## [1.1.0] — 2026-10-13
+
+Found by a customer-style test on Windows Server 2022 / Python 3.10 (28 findings); every one is addressed. Bundles
+wmt5api 3.1.1. Additive: nothing that worked in 1.0.0 is removed.
+
+### Fixed
+- **Two packages could not start the .NET runtime from two threads at once** (`RuntimeNotFoundError` in one of them,
+  every time, on Linux as well). One lock now covers every `pmt*api` package in the process.
+- **`bars()` re-aggregated the whole series after every block** (MT5): a deep request was quadratic and timed out
+  (`D1` × 1000 took over two minutes of CPU). It counts as the blocks arrive and aggregates once; the default budget
+  is `bars_timeout` plus a second per two weeks of one-minute bars the request needs.
+- **A closed client left a thread behind** for every client that had used callbacks or `quotes()`: the callback
+  thread now ends at `disconnect()` (and when the client is dropped) and returns with the next event.
+- **Type checkers saw every method as `(*Any, **Any) -> Any`**: the decorator that translates errors now keeps the
+  signature.
+- Messages: a missing .NET runtime names the runtime and where to get it; the no-key text speaks `api_key=`; a bars
+  timeout states its real wait; a trade refusal names its code.
+- `python -m pmt4api --connect` / `pmt5api --connect` accept `host:port` in `PMT*_HOST`.
+- The reference gains a meaning for every field of the main data types.
+- `close()`, `modify()` and `cancel()` return the order they acted on, the same on both packages (`pmt5api`: `close()` returned an empty record and `modify()` `None`; `pmt4api`: `cancel()` returned `None`).
+- The core fixes: see wmt5api 3.1.1 — **`Deal.price` / `Deal.open_price` were swapped on a closing deal**, a pending sell order reported `DealBuy`, and `history()` omitted cancelled and expired pending orders.
+
+### Added
+- `lots_for_risk(..., side="buy" | "sell")`: a stop on the wrong side of the entry is refused instead of being sized by its distance.
+- `LoginRejectedError` (a `ServerError`): the broker refused the login — `connect()` raises it for a wrong account or password instead of a bare `ServerError`; a dial that times out is a `ConnectError`, as on MT4.
+
+## [1.0.0] — 2026-10-12
+
+First release. `pmt5api` exposes every public capability of the wmt5api 3.x C# library to Python.
+
+### Capabilities
+- Connection and session: licensing, failover, `auto_reconnect`, proxies (SOCKS4/SOCKS5/HTTPS), client certificate,
+  all timeouts, connect-progress events, server time and account mode.
+- Market data: symbols with trading rules and sessions, commissions, quotes and subscriptions (callbacks, iterators,
+  asyncio), bars M1–D1 with tick volume, tick value and contract size.
+- Account: balances and margins (with and without swap/commission), orders, positions, closed orders, history and
+  deal history (blocking and event-driven), realized summary, balance/equity curve.
+- Sizing and risk: money-scale calibration, lots-for-risk with evidence, required margin, order profit.
+- Order entry: market, pending (limit, stop, stop-limit), expiration, fill policy, modify, partial close, close-by,
+  cancel — synchronous, with request ids and progress events, and awaitable; magic number on orders and deals.
+- Offline helpers and administration: `servers.dat` read and write, demo account request, password change.
+- Diagnostics: the core's log into Python `logging`.
+- Parity manifest `pmt5api.COVERAGE`, checked against the DLL by the test suite; generated API reference and a
+  C#-to-Python table.
+
+### Packaging
+- Linux x86-64 wheel carrying the core and the .NET 9 runtime (`manylinux_2_28`); a pure wheel carrying the core;
+  an sdist.
+
+### Verified
+Against real demo accounts, from clean containers without .NET (Python 3.9, 3.12, 3.13; glibc 2.28 and 2.41):
+read-only and trading suites, reconnects (drops, a refused window, a silent link), every shipped example, and a
+three-hour unattended run (4 recovered drops, no errors, memory flat after warm-up).
+Not verified: Windows, macOS, arm64, musl; netting accounts; client certificates.

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: pmt5api
-Version: 1.0.0
+Version: 1.1.2
 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
@@ -37,19 +37,25 @@ No MetaTrader terminal is needed — the core talks to your broker directly.
 
 **Parity with the C# library is measured, not claimed:** `pmt5api.COVERAGE` maps every public member of the C#
 `MT5API` class to its Python counterpart (or states why it has none), and the test suite fails if the core gains a
-member that is not accounted for. [`docs/FROM-CSHARP.md`](src/pmt5api/docs/FROM-CSHARP.md) is that table;
-[`docs/API.md`](src/pmt5api/docs/API.md) is the reference.
+member that is not accounted for. `pmt5api/docs/FROM-CSHARP.md` (inside the installed package) is that table;
+`pmt5api/docs/API.md` (inside the installed package; `python -m pmt5api` prints its folder) is the reference.
 
 ## Install
 
-The **Linux x86-64 wheel** carries everything — the core and a .NET runtime — so there is nothing else to install:
-
 ```
-pip install pmt5api-<version>-py3-none-manylinux_2_28_x86_64.whl
+pip install pmt5api
 ```
 
-On any other platform use the `py3-none-any` wheel, which carries the core and needs a .NET 8 (or later) runtime on
-the machine (`dotnet --list-runtimes` should list `Microsoft.NETCore.App`).
+pip chooses the wheel for your platform. The **Linux x86-64 wheel** carries everything — the core and a .NET runtime —
+so there is nothing else to install. On any other platform the `py3-none-any` wheel carries the core and needs a .NET 8
+(or later) runtime on the machine (`dotnet --list-runtimes` should list `Microsoft.NETCore.App`). From a downloaded
+file: `pip install pmt5api-<version>-py3-none-<platform>.whl`.
+
+**Windows (x64).** Install the .NET 8 runtime once (`winget install Microsoft.DotNet.Runtime.8`, or the installer from
+https://dotnet.microsoft.com/download/dotnet/8.0), then `pip install pmt5api`. Check it with `python -m pmt5api`: it prints
+the versions, finds the runtime and constructs a client offline. Set the key in the shell that runs your program —
+PowerShell: `$env:WMTAPI_KEY = "wk_..."`, cmd: `set WMTAPI_KEY=wk_...`. A string the broker sent can hold characters your
+console's code page cannot print: set `PYTHONUTF8=1` (or run `chcp 65001`) to avoid a `UnicodeEncodeError`.
 
 You also need your **API key** (`wk_…`, the same key you use with wmt5api):
 
@@ -101,6 +107,16 @@ bars; higher timeframes are built from them, aligned to the server's calendar (a
 bar at 00, 04, 08, … server time, a week on Sunday, a month on the 1st), with `tick_volume` summed. Minutes after
 `end` are not used; the last bar may still be forming. `spread` is present on M1 bars only.
 
+**What a request costs.** The server hands the one-minute bars over in blocks of about two weeks, so the time of a
+`bars()` call grows with how far back it reaches, not with the timeframe. Measured from a datacentre against a
+broker's demo server: 5 000 one-minute bars 0.4 s; 100 `D1` bars 3 s; 5 000 `H1` bars 9 s; 500 `D1` bars 16 s;
+1 000 `D1` bars 32 s (your link and your broker will differ). The default budget is `bars_timeout` plus a second per
+block the request needs, so these finish without a `timeout=`; pass one to bound the call yourself.
+
+**MT4 and MT5 differ here.** On MT5 `end=` includes the bar stamped exactly `end` and the bar that is still forming; the
+MT4 package returns completed bars only and excludes a bar that opens at `end`. Code that runs on both has to drop
+the forming MT5 bar itself.
+
 ### Live quotes
 
 ```python
@@ -123,19 +139,25 @@ c.subscribe("EURUSD")
 remove()
 ```
 
-Callbacks are delivered by **one dispatcher thread per client**, one at a time, in arrival order — you need no locks
+Callbacks are delivered by **one dispatcher thread per client**, one at a time, in the order the events arrived — you need no locks
 between callbacks, and a slow callback does not stall the connection. If a callback falls more than 20,000 events
 behind, the oldest events are dropped, a warning is logged and `c.events_dropped` counts them. An exception raised
 inside a callback is logged (`logging.getLogger("pmt5api")`) and swallowed. Order updates keep the state they had at
 the moment they arrived (they are snapshots). The iterators attach when you create them, drop the oldest item when the
 consumer falls behind, and detach on `close()` / `async with` / garbage collection.
 
+A tick's `time` is the server's: on some brokers about one tick in a hundred carries a time slightly earlier than the
+previous tick of the same symbol (the feed is merged from several sources). Delivery order is arrival order; sort by
+`time` if you need the market's order.
+
 ## Trading
 
 ```python
+from datetime import datetime
+
 o = c.buy("EURUSD", 0.10, sl=1.0950, tp=1.1100, magic=424242)   # market order at the ask; sell() at the bid
-c.modify(o.ticket, sl=1.0970)                     # change stops; what you leave out keeps its value
-c.close(o.ticket, 0.05)                           # close half; close(ticket) closes it all
+c.modify(o.ticket, sl=1.0970)                     # change stops (returns the order as the server holds it)
+c.close(o.ticket, 0.05)                           # close half (returns the closing record); close(ticket) closes it all
 
 p = c.place_order("EURUSD", "buy_stop_limit", 0.10, 1.1200, stop_limit=1.1190,
                   expiration=datetime(2026, 12, 31, 23, 0))   # also buy_limit sell_limit buy_stop sell_stop
@@ -159,6 +181,12 @@ rid = c.buy_async("EURUSD", 0.10)
 `aclose`, `acancel`, `aquote`. Cancelling the `await` (a `wait_for` timeout, a cancelled task) does not recall a request
 that is already on its way: the order may still be sent, so check `orders()` afterwards.
 
+**The server, not the library, enforces volume rules.** A volume below the minimum or off the step is sent and refused
+(`ServerError` `INVALID_VOLUME`); `symbol(name)` has `min_lots`, `max_lots` and `lots_step` to check against first. A
+pending order's expiration is stored to the minute (rounded **down**), so an order can expire up to a minute before the
+time you asked for. Pressing Ctrl+C while `connect()` is dialling is honoured when the dial ends (up to
+`connect_timeout`), not at once.
+
 **Test on a demo account first.** Nothing here is ever retried or resent for you: if the server does not confirm in
 time the call raises `RequestTimeout` and the order **may have been accepted** — look at `orders()` before sending
 again. `NoQuoteError` is different: no price was available, so nothing was sent. `orders()` can lag a moment behind
@@ -174,8 +202,10 @@ 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
+
 if c.calibrate_money_scale(datetime(2025, 1, 1)):                 # read-only; places no order
-    r = c.lots_for_risk("EURUSD", entry_price=1.1000, stop_price=1.0950, risk_amount=50.0)
+    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
     if r.ok and r.expected_loss_at_stop <= 50.0 * 1.05:
@@ -228,8 +258,8 @@ subscriptions are restored, cached snapshots are not.
 | API key | `api_key=` | `WMTAPI_KEY` |
 | Licence service URL (leave at its default) | `token_url=` | `WMTAPI_TOKEN_URL` |
 | Core library (only if you do not use a wheel that carries it) | `dll_path=` | `WMTAPI_DLL` |
-| Timeouts (seconds, each > 0) | `connect_timeout` (one attempt on one server), `cluster_member_timeout` (per server while failing over), `token_timeout`, `execution_timeout`, `quote_timeout` / `history_timeout` / `bars_timeout` (the defaults of `quote`, `history`, `bars`), `ping_interval`, `no_message_timeout` | — |
-| Reconnect | `auto_reconnect`, `reconnect_backoff`, `reconnect_max_backoff`, `reconnect_max_attempts` | — |
+| Timeouts (seconds, each > 0) | `connect_timeout` (the whole connect; default 30), `cluster_member_timeout` (per server while failing over; 10), `token_timeout` (10), `execution_timeout` (a trade confirmation; 30), `quote_timeout` (10) / `history_timeout` (30) / `bars_timeout` (10, plus a second per two weeks of one-minute bars a `bars()` call needs) — the defaults of `quote`, `history`, `bars`, `ping_interval` (20), `no_message_timeout` (30) | — |
+| 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=` | — |
 | .NET runtime location | — | `DOTNET_ROOT` |
@@ -252,6 +282,10 @@ pmt5api.enable_core_logging()          # the core's own messages -> logging.getL
 `request_demo_account(DemoAccountRequest(...), host, port)` asks a broker for a demo account (it creates a real
 account at that broker: use it deliberately); `c.change_password(new, investor=False)`.
 
+`python -m pmt5api` prints what is installed and whether it works here (`--connect` also reads an account, using
+`PMT5_LOGIN`, `PMT5_PASSWORD`, `PMT5_HOST` — a bare host, or `host:port`, or the port in `PMT5_PORT` — and the key in
+`WMTAPI_KEY`); the output holds no secrets and is what to send when asking for help.
+
 ## Errors
 
 Everything the core raises reaches you as one of these, all subclasses of `pmt5api.WmtError`; the original
@@ -260,7 +294,7 @@ exception stays available as `__cause__`.
 | Exception | Meaning |
 |---|---|
 | `LicenseError` | The licence service refused the key. `.reason` is one of `NoKey`, `Invalid`, `Expired`, `Revoked`, `RateLimited`, `LoginNotAllowed`, `AccountLimitReached`, `Unknown`. |
-| `TokenServiceError` | The licence service could not be reached or answered unusably — retry, don't re-prompt for a key. |
+| `TokenServiceError` | The licence service could not be reached or answered unusably — retry, don't re-prompt for a key. (`token_timeout` bounds one request and a failed request is tried again once, so a connect to an unreachable licence service can wait about twice that.) |
 | `ConnectError` | The broker's access server (or the network, or a proxy) could not be reached. |
 | `ConnectionLostError` | An established connection dropped (the core's `Disconnected`). |
 | `ServerError` / `InvestorModeError` | The broker refused the request (wrong login or password, a rejected order / a read-only login tried to trade). `.code` is the server's return code by name (`REQUOTE`, `NO_MONEY`, `INVALID_PRICE`, …). |
@@ -304,6 +338,10 @@ moved by 4 MB), threads and file descriptors stayed flat. Every shipped example
 
 ## Known limitations
 
+- **Sizing needs evidence from the account's own closed deals.** On an account whose deals all carry swap or
+  commission, or whose deals do not have the shape the calibration can read (a Tickmill demo, for one), `calibrate_money_scale`
+  finds no symbol to measure from and `lots_for_risk` refuses: that is the intended answer, not an error. `tick_value()`
+  and `required_margin()` still work, and the refusal says what was missing.
 - **Linux x86-64 is the verified platform.** Windows, macOS, arm64 and musl-based Linux have not been verified.
 - Netting accounts have not been verified (the available demo accounts are all hedging).
 - Client certificates (`certificate=`), `common_key=` and `request_demo_account` have been unit-tested but not run

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

@@ -10,19 +10,25 @@ No MetaTrader terminal is needed — the core talks to your broker directly.
 
 **Parity with the C# library is measured, not claimed:** `pmt5api.COVERAGE` maps every public member of the C#
 `MT5API` class to its Python counterpart (or states why it has none), and the test suite fails if the core gains a
-member that is not accounted for. [`docs/FROM-CSHARP.md`](src/pmt5api/docs/FROM-CSHARP.md) is that table;
-[`docs/API.md`](src/pmt5api/docs/API.md) is the reference.
+member that is not accounted for. `pmt5api/docs/FROM-CSHARP.md` (inside the installed package) is that table;
+`pmt5api/docs/API.md` (inside the installed package; `python -m pmt5api` prints its folder) is the reference.
 
 ## Install
 
-The **Linux x86-64 wheel** carries everything — the core and a .NET runtime — so there is nothing else to install:
-
 ```
-pip install pmt5api-<version>-py3-none-manylinux_2_28_x86_64.whl
+pip install pmt5api
 ```
 
-On any other platform use the `py3-none-any` wheel, which carries the core and needs a .NET 8 (or later) runtime on
-the machine (`dotnet --list-runtimes` should list `Microsoft.NETCore.App`).
+pip chooses the wheel for your platform. The **Linux x86-64 wheel** carries everything — the core and a .NET runtime —
+so there is nothing else to install. On any other platform the `py3-none-any` wheel carries the core and needs a .NET 8
+(or later) runtime on the machine (`dotnet --list-runtimes` should list `Microsoft.NETCore.App`). From a downloaded
+file: `pip install pmt5api-<version>-py3-none-<platform>.whl`.
+
+**Windows (x64).** Install the .NET 8 runtime once (`winget install Microsoft.DotNet.Runtime.8`, or the installer from
+https://dotnet.microsoft.com/download/dotnet/8.0), then `pip install pmt5api`. Check it with `python -m pmt5api`: it prints
+the versions, finds the runtime and constructs a client offline. Set the key in the shell that runs your program —
+PowerShell: `$env:WMTAPI_KEY = "wk_..."`, cmd: `set WMTAPI_KEY=wk_...`. A string the broker sent can hold characters your
+console's code page cannot print: set `PYTHONUTF8=1` (or run `chcp 65001`) to avoid a `UnicodeEncodeError`.
 
 You also need your **API key** (`wk_…`, the same key you use with wmt5api):
 
@@ -74,6 +80,16 @@ bars; higher timeframes are built from them, aligned to the server's calendar (a
 bar at 00, 04, 08, … server time, a week on Sunday, a month on the 1st), with `tick_volume` summed. Minutes after
 `end` are not used; the last bar may still be forming. `spread` is present on M1 bars only.
 
+**What a request costs.** The server hands the one-minute bars over in blocks of about two weeks, so the time of a
+`bars()` call grows with how far back it reaches, not with the timeframe. Measured from a datacentre against a
+broker's demo server: 5 000 one-minute bars 0.4 s; 100 `D1` bars 3 s; 5 000 `H1` bars 9 s; 500 `D1` bars 16 s;
+1 000 `D1` bars 32 s (your link and your broker will differ). The default budget is `bars_timeout` plus a second per
+block the request needs, so these finish without a `timeout=`; pass one to bound the call yourself.
+
+**MT4 and MT5 differ here.** On MT5 `end=` includes the bar stamped exactly `end` and the bar that is still forming; the
+MT4 package returns completed bars only and excludes a bar that opens at `end`. Code that runs on both has to drop
+the forming MT5 bar itself.
+
 ### Live quotes
 
 ```python
@@ -96,19 +112,25 @@ c.subscribe("EURUSD")
 remove()
 ```
 
-Callbacks are delivered by **one dispatcher thread per client**, one at a time, in arrival order — you need no locks
+Callbacks are delivered by **one dispatcher thread per client**, one at a time, in the order the events arrived — you need no locks
 between callbacks, and a slow callback does not stall the connection. If a callback falls more than 20,000 events
 behind, the oldest events are dropped, a warning is logged and `c.events_dropped` counts them. An exception raised
 inside a callback is logged (`logging.getLogger("pmt5api")`) and swallowed. Order updates keep the state they had at
 the moment they arrived (they are snapshots). The iterators attach when you create them, drop the oldest item when the
 consumer falls behind, and detach on `close()` / `async with` / garbage collection.
 
+A tick's `time` is the server's: on some brokers about one tick in a hundred carries a time slightly earlier than the
+previous tick of the same symbol (the feed is merged from several sources). Delivery order is arrival order; sort by
+`time` if you need the market's order.
+
 ## Trading
 
 ```python
+from datetime import datetime
+
 o = c.buy("EURUSD", 0.10, sl=1.0950, tp=1.1100, magic=424242)   # market order at the ask; sell() at the bid
-c.modify(o.ticket, sl=1.0970)                     # change stops; what you leave out keeps its value
-c.close(o.ticket, 0.05)                           # close half; close(ticket) closes it all
+c.modify(o.ticket, sl=1.0970)                     # change stops (returns the order as the server holds it)
+c.close(o.ticket, 0.05)                           # close half (returns the closing record); close(ticket) closes it all
 
 p = c.place_order("EURUSD", "buy_stop_limit", 0.10, 1.1200, stop_limit=1.1190,
                   expiration=datetime(2026, 12, 31, 23, 0))   # also buy_limit sell_limit buy_stop sell_stop
@@ -132,6 +154,12 @@ rid = c.buy_async("EURUSD", 0.10)
 `aclose`, `acancel`, `aquote`. Cancelling the `await` (a `wait_for` timeout, a cancelled task) does not recall a request
 that is already on its way: the order may still be sent, so check `orders()` afterwards.
 
+**The server, not the library, enforces volume rules.** A volume below the minimum or off the step is sent and refused
+(`ServerError` `INVALID_VOLUME`); `symbol(name)` has `min_lots`, `max_lots` and `lots_step` to check against first. A
+pending order's expiration is stored to the minute (rounded **down**), so an order can expire up to a minute before the
+time you asked for. Pressing Ctrl+C while `connect()` is dialling is honoured when the dial ends (up to
+`connect_timeout`), not at once.
+
 **Test on a demo account first.** Nothing here is ever retried or resent for you: if the server does not confirm in
 time the call raises `RequestTimeout` and the order **may have been accepted** — look at `orders()` before sending
 again. `NoQuoteError` is different: no price was available, so nothing was sent. `orders()` can lag a moment behind
@@ -147,8 +175,10 @@ 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
+
 if c.calibrate_money_scale(datetime(2025, 1, 1)):                 # read-only; places no order
-    r = c.lots_for_risk("EURUSD", entry_price=1.1000, stop_price=1.0950, risk_amount=50.0)
+    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
     if r.ok and r.expected_loss_at_stop <= 50.0 * 1.05:
@@ -201,8 +231,8 @@ subscriptions are restored, cached snapshots are not.
 | API key | `api_key=` | `WMTAPI_KEY` |
 | Licence service URL (leave at its default) | `token_url=` | `WMTAPI_TOKEN_URL` |
 | Core library (only if you do not use a wheel that carries it) | `dll_path=` | `WMTAPI_DLL` |
-| Timeouts (seconds, each > 0) | `connect_timeout` (one attempt on one server), `cluster_member_timeout` (per server while failing over), `token_timeout`, `execution_timeout`, `quote_timeout` / `history_timeout` / `bars_timeout` (the defaults of `quote`, `history`, `bars`), `ping_interval`, `no_message_timeout` | — |
-| Reconnect | `auto_reconnect`, `reconnect_backoff`, `reconnect_max_backoff`, `reconnect_max_attempts` | — |
+| Timeouts (seconds, each > 0) | `connect_timeout` (the whole connect; default 30), `cluster_member_timeout` (per server while failing over; 10), `token_timeout` (10), `execution_timeout` (a trade confirmation; 30), `quote_timeout` (10) / `history_timeout` (30) / `bars_timeout` (10, plus a second per two weeks of one-minute bars a `bars()` call needs) — the defaults of `quote`, `history`, `bars`, `ping_interval` (20), `no_message_timeout` (30) | — |
+| 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=` | — |
 | .NET runtime location | — | `DOTNET_ROOT` |
@@ -225,6 +255,10 @@ pmt5api.enable_core_logging()          # the core's own messages -> logging.getL
 `request_demo_account(DemoAccountRequest(...), host, port)` asks a broker for a demo account (it creates a real
 account at that broker: use it deliberately); `c.change_password(new, investor=False)`.
 
+`python -m pmt5api` prints what is installed and whether it works here (`--connect` also reads an account, using
+`PMT5_LOGIN`, `PMT5_PASSWORD`, `PMT5_HOST` — a bare host, or `host:port`, or the port in `PMT5_PORT` — and the key in
+`WMTAPI_KEY`); the output holds no secrets and is what to send when asking for help.
+
 ## Errors
 
 Everything the core raises reaches you as one of these, all subclasses of `pmt5api.WmtError`; the original
@@ -233,7 +267,7 @@ exception stays available as `__cause__`.
 | Exception | Meaning |
 |---|---|
 | `LicenseError` | The licence service refused the key. `.reason` is one of `NoKey`, `Invalid`, `Expired`, `Revoked`, `RateLimited`, `LoginNotAllowed`, `AccountLimitReached`, `Unknown`. |
-| `TokenServiceError` | The licence service could not be reached or answered unusably — retry, don't re-prompt for a key. |
+| `TokenServiceError` | The licence service could not be reached or answered unusably — retry, don't re-prompt for a key. (`token_timeout` bounds one request and a failed request is tried again once, so a connect to an unreachable licence service can wait about twice that.) |
 | `ConnectError` | The broker's access server (or the network, or a proxy) could not be reached. |
 | `ConnectionLostError` | An established connection dropped (the core's `Disconnected`). |
 | `ServerError` / `InvestorModeError` | The broker refused the request (wrong login or password, a rejected order / a read-only login tried to trade). `.code` is the server's return code by name (`REQUOTE`, `NO_MONEY`, `INVALID_PRICE`, …). |
@@ -277,6 +311,10 @@ moved by 4 MB), threads and file descriptors stayed flat. Every shipped example
 
 ## Known limitations
 
+- **Sizing needs evidence from the account's own closed deals.** On an account whose deals all carry swap or
+  commission, or whose deals do not have the shape the calibration can read (a Tickmill demo, for one), `calibrate_money_scale`
+  finds no symbol to measure from and `lots_for_risk` refuses: that is the intended answer, not an error. `tick_value()`
+  and `required_margin()` still work, and the refusal says what was missing.
 - **Linux x86-64 is the verified platform.** Windows, macOS, arm64 and musl-based Linux have not been verified.
 - Netting accounts have not been verified (the available demo accounts are all hedging).
 - Client certificates (`certificate=`), `common_key=` and `request_demo_account` have been unit-tested but not run

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

@@ -8,7 +8,7 @@ from ._coverage import COVERAGE, TYPES
 from .bars import Bar, QuoteHistoryEvent, TIMEFRAMES, aggregate
 from .client import Client, Proxy
 from .diagnostics import enable_core_logging
-from .errors import (BusyError, ConnectError, NoQuoteError, ConnectionLostError, CoreNotFoundError, InvalidRequestError, InvestorModeError,
+from .errors import (BusyError, ConnectError, NoQuoteError, ConnectionLostError, CoreNotFoundError, InvalidRequestError, InvestorModeError, LoginRejectedError,
                      LicenseError, NotConnectedError, ProxyError, RequestTimeout, RuntimeNotFoundError,
                      ServerError, TokenServiceError, WmtError)
 from .frames import to_frame
@@ -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.0.0"
+__version__ = "1.1.2"
 
 __all__ = [
     "Client", "Proxy",
@@ -28,7 +28,7 @@ __all__ = [
     "Bar", "TIMEFRAMES", "aggregate", "to_frame",
     "load_servers_dat", "save_servers_dat", "request_demo_account", "tick_value_from_deal", "enable_core_logging",
     "WmtError", "LicenseError", "TokenServiceError", "ConnectError", "ConnectionLostError", "NotConnectedError",
-    "ServerError", "InvestorModeError", "ProxyError", "RequestTimeout", "NoQuoteError", "InvalidRequestError", "BusyError",
+    "ServerError", "LoginRejectedError", "InvestorModeError", "ProxyError", "RequestTimeout", "NoQuoteError", "InvalidRequestError", "BusyError",
     "CoreNotFoundError",
     "RuntimeNotFoundError", "COVERAGE", "TYPES", "__version__",
 ]

{pmt5api-1.0.0 → pmt5api-1.1.2}/src/pmt5api/__main__.py

@@ -62,6 +62,10 @@ def main(argv: Optional[List[str]] = None) -> int:
             print("connect SKIPPED: environment variable %s is not set" % e)
             return 0
         port = int(os.environ.get("PMT5_PORT", "443"))
+        if ":" in host:                      # an account file lists "host:port"
+            host, _, given = host.rpartition(":")
+            if given.isdigit():
+                port = int(given)
         try:
             with Client(login, password, host, port, connect_timeout=45) as live:
                 a = live.account()

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

@@ -10,6 +10,11 @@ from .errors import NotConnectedError
 from .models import AccountInfo, AccountSummary, EquityPoint, History, Order
 
 
+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)
+
+
 class _AccountMixin(_Base):
     @translated
     def account(self, refresh: bool = True) -> AccountInfo:
@@ -30,13 +35,14 @@ class _AccountMixin(_Base):
                 raise NotConnectedError("the connection was lost while refreshing the account")
             api.UpdateProfits()
         a = api.Account
+        m = _money
         return AccountInfo(
             login=int(a.Login), name=str(a.UserName or ""), currency=str(api.AccountCurrency or ""),
-            leverage=int(a.Leverage), balance=float(a.Balance), credit=float(a.Credit),
-            equity=float(api.AccountEquity), profit=float(api.AccountProfit), margin=float(api.AccountMargin),
-            free_margin=float(api.AccountFreeMargin), margin_level=float(api.AccountMarginLevel),
-            floating_pl=float(api.AccountFloatingProfit), swap=float(api.AccountSwap),
-            commission=float(api.AccountCommission), fee=float(api.AccountFee), blocked=float(a.Blocked),
+            leverage=int(a.Leverage), balance=m(a.Balance), credit=m(a.Credit),
+            equity=m(api.AccountEquity), profit=m(api.AccountProfit), margin=m(api.AccountMargin),
+            free_margin=m(api.AccountFreeMargin), margin_level=m(api.AccountMarginLevel),
+            floating_pl=m(api.AccountFloatingProfit), swap=m(api.AccountSwap),
+            commission=m(api.AccountCommission), fee=m(api.AccountFee), blocked=m(a.Blocked),
             company=str(api.AccountCompanyName or ""), method=str(api.AccountMethod), account_type=str(a.Type or ""),
             trade_flags=int(a.TradeFlags), country=str(a.Country or ""), city=str(a.City or ""),
             state=str(a.State or ""), zip_code=str(a.ZipCode or ""), address=str(a.UserAddress or ""),

{pmt5api-1.0.0 → pmt5api-1.1.2}/src/pmt5api/_base.py

@@ -11,6 +11,12 @@ class _Base:
     _api: Any      # the core's client object (MT5API / MT4API)
     _core: Any     # the core's namespace (types and enums)
 
+    def _stop_events(self) -> None:
+        """End the callback thread (it restarts by itself with the next event): a closed client keeps no thread."""
+        d = getattr(self, "_dispatch", None)
+        if d is not None:
+            d.stop()
+
     def _require_connected(self) -> None:
         if not self._api.Connected:
             raise NotConnectedError("not connected; call connect() first")

{pmt5api-1.0.0 → pmt5api-1.1.2}/src/pmt5api/_events.py

@@ -7,6 +7,7 @@ to a callback that fell too far behind.
 from __future__ import annotations
 
 import logging
+import weakref
 from typing import Any, AsyncIterator, Callable, Iterator, Optional
 
 from ._base import _Base
@@ -34,6 +35,7 @@ class _EventsMixin(_Base):
             d = getattr(self, "_dispatch", None)
             if d is None:
                 d = self._dispatch = _Dispatcher()
+                weakref.finalize(self, d.stop)       # a client that is dropped without disconnect() leaves no thread
             return d
 
     @property

{pmt5api-1.0.0 → pmt5api-1.1.2}/src/pmt5api/_market.py

@@ -11,7 +11,7 @@ from typing import Any, Dict, List, Optional, Tuple, Union
 
 from ._base import _Base
 from ._util import translated
-from .bars import Bar, aggregate, timeframe_minutes
+from .bars import Bar, _bucket, aggregate, timeframe_minutes
 from .errors import InvalidRequestError, NoQuoteError, RequestTimeout, translate
 from .models import (CommissionInfo, Quote, SymbolInfo, SymbolSessions, _opt_float, _symbols_from_core, _time)
 
@@ -225,7 +225,8 @@ class _MarketMixin(_Base):
             try:
                 api.RequestQuoteHistoryMonth(symbol, day.year, day.month, day.day)
                 if not done.wait(timeout):
-                    raise RequestTimeout("no bars for %s within %.0f s" % (symbol, timeout))
+                    raise RequestTimeout("the server sent no bars for %s within %g s of asking (one block of "
+                                         "one-minute bars)" % (symbol, round(timeout, 2)))
             finally:
                 api.OnQuoteHistory -= handler
         return [Bar._from_core(b) for b in got]
@@ -252,30 +253,43 @@ class _MarketMixin(_Base):
             count = 500
         if not self._api.Symbols.Exist(symbol):
             raise InvalidRequestError("unknown symbol %r" % symbol)
-        total = float(timeout) if timeout is not None else self._api.DownloadQuoteHistoryTimeout / 1000.0
-        deadline = time.monotonic() + total
         server_now = self.server_time or datetime.now(timezone.utc).replace(tzinfo=None)
         ref = end if end is not None else server_now + timedelta(days=1)
+        if timeout is not None:
+            total = float(timeout)
+        else:
+            # The server hands over one-minute bars in blocks of about two weeks, so a deep request is many round
+            # trips: the default budget is the client's bars_timeout plus a second for every block expected.
+            span_minutes = (count * minutes * 1.4) if count is not None else \
+                max(0.0, (ref - start).total_seconds() / 60.0) if start is not None else 0.0
+            blocks = int(span_minutes / (14 * 1440)) + 1
+            total = min(self._api.DownloadQuoteHistoryTimeout / 1000.0 + blocks, 900.0)
+        deadline = time.monotonic() + total
         cursor = ref.date()
         minute_bars: Dict[datetime, Bar] = {}
+        buckets = set()                           # the bars the request would produce, counted as the blocks arrive
         earliest: Optional[datetime] = None
         for _ in range(400):                      # hard stop: a block is ~2 weeks of FX, so this is years of data
             remaining = deadline - time.monotonic()
             if remaining <= 0:
-                raise RequestTimeout("bars for %s not complete within %.0f s" % (symbol, total))
-            block = self._minute_block(symbol, cursor, remaining)
+                raise RequestTimeout("bars for %s not complete within %g s" % (symbol, round(total, 2)))
+            try:
+                block = self._minute_block(symbol, cursor, remaining)
+            except RequestTimeout:                # one block ran out of what was left: say what the CALL was given
+                raise RequestTimeout("bars for %s not complete within %g s" % (symbol, round(total, 2))) from None
             if not block:
                 break
             for b in block:
-                if end is None or b.time <= end:
-                    minute_bars.setdefault(b.time, b)
+                if (end is None or b.time <= end) and b.time not in minute_bars:
+                    minute_bars[b.time] = b
+                    buckets.add(_bucket(b.time, minutes))
             first = min(b.time for b in block)
             if earliest is not None and first >= earliest:
                 break
             earliest = first
             if start is not None and first <= start:
                 break
-            if count is not None and len(aggregate(minute_bars.values(), minutes)) > count:
+            if count is not None and len(buckets) > count:
                 break                              # one spare: the oldest bucket may be cut by the block edge
             cursor = first.date()                  # the same day: nothing before `first` on that day is skipped
         series = aggregate(minute_bars.values(), minutes)

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

@@ -48,13 +48,25 @@ class _RiskMixin(_Base):
     def lots_for_risk(self, symbol: str, entry_price: float, stop_price: float, risk_amount: float, *,
                       lot_step: Optional[float] = None, min_lot: Optional[float] = None,
                       max_ratio: Optional[float] = None, max_equity_share: Optional[float] = None,
-                      max_lot: Optional[float] = None) -> LotSizing:
+                      max_lot: Optional[float] = None, side: Optional[str] = None) -> LotSizing:
         """The volume that loses ``risk_amount`` (account currency) if ``stop_price`` is hit, with the evidence.
 
         Requires a successful :meth:`calibrate_money_scale`; without it the answer is a refusal. The volume is
-        rounded **down**. Check ``ok``: when false, ``lots`` is 0 and ``reason`` says which check failed.
+        rounded **down**. Check ``ok``: when false, ``lots`` is 0 and ``reason`` says which check failed. Give ``side``
+        (``"buy"`` or ``"sell"``) and a stop on the wrong side of the entry is refused instead of sized by its distance.
         """
         self._require_connected()
+        if side is not None:
+            key = str(side).strip().lower()
+            if key not in ("buy", "sell"):
+                raise ValueError("side must be 'buy' or 'sell'")
+            wrong = (stop_price >= entry_price) if key == "buy" else (stop_price <= entry_price)
+            if wrong:                                 # a stop on the wrong side of the entry is not a stop
+                return LotSizing(ok=False, lots=0.0, expected_loss_at_stop=0.0, risk_requested=float(risk_amount),
+                                 minimum_trade_cost=0.0, ratio=0.0,
+                                 reason="a %s needs its stop %s the entry price (entry %g, stop %g)"
+                                        % (key, "below" if key == "buy" else "above", entry_price, stop_price),
+                                 warnings=())
         kwargs = {}
         for key, value in (("lotStep", lot_step), ("minLot", min_lot), ("maxRatio", max_ratio),
                            ("maxEquityShare", max_equity_share), ("maxLot", max_lot)):

{pmt5api-1.0.0 → pmt5api-1.1.2}/src/pmt5api/_runtime.py

@@ -5,6 +5,7 @@ import glob
 import importlib
 import os
 import shutil
+import struct
 import sys
 import threading
 from pathlib import Path
@@ -17,8 +18,25 @@ ENV_DLL = "WMTAPI_DLL"
 
 _NAMESPACE = "wmt5api"      # the .NET namespace of the core; NOT the name of this Python package
 _PKG = Path(__file__).resolve().parent
+_BITNESS_HINT = (" This is a 32-bit Python: it needs the 32-bit (x86) .NET runtime, and 64-bit Python with the 64-bit "
+                 "runtime is the supported combination.")
 _BUNDLED_RUNTIME = _PKG / "_dotnet"     # present in the platform wheels: host/fxr + shared/Microsoft.NETCore.App
-_lock = threading.Lock()
+
+
+def _process_lock() -> "threading.RLock":
+    """ONE lock for every pmt*api package in the process. Each package has its own copy of this module, but the .NET
+    runtime is one per process: two packages starting it from two threads at once raced inside pythonnet. The lock
+    lives in ``sys.modules`` under a fixed name, which both copies see."""
+    holder = sys.modules.get("_pmt_runtime_lock")
+    if holder is None:
+        import types
+        fresh = types.ModuleType("_pmt_runtime_lock")
+        fresh.lock = threading.RLock()                   # type: ignore[attr-defined]
+        holder = sys.modules.setdefault("_pmt_runtime_lock", fresh)
+    return holder.lock                                   # type: ignore[attr-defined]
+
+
+_lock = _process_lock()
 _core = None
 _dll: Optional[Path] = None
 
@@ -137,7 +155,11 @@ def load(dll_path=None):
             _load("coreclr")
             import clr  # noqa: F401  (provided by pythonnet)
         except Exception as e:  # noqa: BLE001 — anything here means the runtime could not start
-            raise RuntimeNotFoundError("could not start the .NET runtime: %s" % e) from e
+            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
         import clr as _clr
         from System.Reflection import Assembly      # available once the runtime is up
         try: