pmt4api 1.0.0__py3-none-any.whl

pmt4api/__init__.py

@@ -0,0 +1,32 @@
+"""pmt4api — Python access to the wmt4api MetaTrader 4 client library.
+
+A typed, translated layer over every public capability of the licensed C# core (loaded in-process): the protocol,
+licensing and trading logic stay in the core; this package adds a Pythonic surface — plain data types, a small error
+hierarchy, context managers, sync and async streams, bars, sizing and order entry.
+"""
+from ._coverage import COVERAGE, TYPES
+from .bars import Bar, QuoteHistoryEvent, TIMEFRAMES
+from .client import Client
+from .diagnostics import enable_core_logging
+from .errors import (BusyError, ConnectError, ConnectionLostError, CoreNotFoundError, InvalidRequestError,
+                     InvestorModeError, LicenseError, LoginRejectedError, NoQuoteError, NotConnectedError,
+                     ProtocolError, RequestCancelled, RequestTimeout, RequoteError, RuntimeNotFoundError,
+                     ServerError, TokenServiceError, TRADE_CODES, WmtError)
+from .frames import to_frame
+from .models import (AccountInfo, AccountSummary, ConnectEvent, EquityPoint, LotSizing, Order, OrderProgress,
+                     OrderUpdate, Quote, ServerRecord, SymbolGroup, SymbolInfo)
+from .servers import load_servers_ini, save_servers_ini
+
+__version__ = "1.0.0"
+
+__all__ = [
+    "Client",
+    "Quote", "SymbolInfo", "SymbolGroup", "AccountInfo", "AccountSummary", "EquityPoint", "LotSizing", "Order",
+    "OrderUpdate", "OrderProgress", "ConnectEvent", "QuoteHistoryEvent", "ServerRecord",
+    "Bar", "TIMEFRAMES", "to_frame",
+    "load_servers_ini", "save_servers_ini", "enable_core_logging",
+    "WmtError", "LicenseError", "TokenServiceError", "ConnectError", "ConnectionLostError", "NotConnectedError",
+    "ServerError", "LoginRejectedError", "RequoteError", "InvestorModeError", "RequestTimeout", "NoQuoteError",
+    "RequestCancelled", "InvalidRequestError", "BusyError", "ProtocolError", "CoreNotFoundError",
+    "RuntimeNotFoundError", "TRADE_CODES", "COVERAGE", "TYPES", "__version__",
+]

pmt4api/__main__.py

@@ -0,0 +1,78 @@
+"""``python -m pmt4api`` — what is installed, and whether it works on this machine.
+
+    python -m pmt4api                 offline: versions, the core, the .NET runtime, this platform
+    python -m pmt4api --connect       also connect read-only using PMT4_LOGIN, PMT4_PASSWORD, PMT4_HOST[, PMT4_PORT]
+                                      and WMT4API_KEY, and print the account's currency, leverage and symbol count
+
+The output contains no secrets; it is what to send when asking for help.
+"""
+from __future__ import annotations
+
+import argparse
+import os
+import platform
+import sys
+from typing import List, Optional
+
+from . import __version__, _runtime
+from .errors import WmtError
+
+
+def _key_hint() -> str:
+    key = os.environ.get("WMT4API_KEY", "")
+    if not key:
+        return "not set (WMT4API_KEY)"
+    return "set (%s…, %d characters)" % (key[:3], len(key))
+
+
+def main(argv: Optional[List[str]] = None) -> int:
+    ap = argparse.ArgumentParser(prog="python -m pmt4api", description=__doc__.split("\n\n")[0])
+    ap.add_argument("--connect", action="store_true", help="also connect read-only and read the account")
+    args = ap.parse_args(argv)
+    ok = True
+
+    print("pmt4api %s" % __version__)
+    print("python  %s on %s" % (sys.version.split()[0], platform.platform()))
+    try:
+        _runtime.load()
+    except WmtError as e:
+        print("core    NOT LOADED: %s: %s" % (type(e).__name__, e))
+        return 1
+    print("core    %s" % _runtime.loaded_dll())
+    root = _runtime.runtime_root()
+    bundled = root is not None and "_dotnet" in str(root)
+    print("runtime %s%s" % (root, " (bundled in the wheel)" if bundled else ""))
+    print("icu     %s; invariant globalization %s" % (
+        "present" if _runtime._icu_present() else "absent",
+        os.environ.get("DOTNET_SYSTEM_GLOBALIZATION_INVARIANT", "off")))
+    print("key     %s" % _key_hint())
+    docs = _runtime.loaded_dll().parent / "docs" if _runtime.loaded_dll() is not None else None
+    if docs is not None and docs.is_dir():
+        print("docs    %s (LICENSING.md, SECURITY.md, ERRORS.md)" % docs)
+
+    from .client import Client
+    c = Client(1, "x", "127.0.0.1", 1)
+    print("offline construct client: ok (core version %s)" % c.core_version)
+
+    if args.connect:
+        try:
+            login, password, host = (int(os.environ["PMT4_LOGIN"]), os.environ["PMT4_PASSWORD"],
+                                     os.environ["PMT4_HOST"])
+        except KeyError as e:
+            print("connect SKIPPED: environment variable %s is not set" % e)
+            return 0
+        port = int(os.environ.get("PMT4_PORT", "443"))
+        try:
+            with Client(login, password, host, port, connect_timeout=45) as live:
+                a = live.account()
+                print("connect ok: %s, %s, leverage 1:%d, %d symbols, %s account, trading %s"
+                      % (live.company, a.currency, a.leverage, len(live.symbols()), a.account_type,
+                         "allowed" if live.can_trade else "not allowed (investor password)"))
+        except WmtError as e:
+            ok = False
+            print("connect FAILED: %s: %s" % (type(e).__name__, e))
+    return 0 if ok else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

pmt4api/_account.py

@@ -0,0 +1,253 @@
+"""The account: balances, positions, orders, history, and the curves derived from them."""
+from __future__ import annotations
+
+import asyncio
+import functools
+import threading
+from datetime import datetime, timedelta, timezone
+from typing import Any, List, Optional
+
+from ._base import _Base
+from ._util import enum_value, to_core_time, translated
+from .errors import NotConnectedError, RequestCancelled
+from .models import AccountInfo, AccountSummary, EquityPoint, Order, _time
+
+
+class _Cancellation:
+    """Turns a :class:`threading.Event` into the core's ``CancellationToken`` for the duration of one call."""
+
+    def __init__(self, event: Optional[threading.Event]) -> None:
+        self._event = event
+        self._done = threading.Event()
+        self._cts: Any = None
+        self.token: Any = None
+
+    def __enter__(self) -> "_Cancellation":
+        if self._event is None:
+            return self
+        from System.Threading import CancellationTokenSource  # noqa: PLC0415 — available once the runtime is up
+        self._cts = CancellationTokenSource()
+        self.token = self._cts.Token
+        if self._event.is_set():
+            self._cts.Cancel()
+            return self
+
+        def watch() -> None:
+            while not self._done.is_set():
+                if self._event.wait(0.05):               # type: ignore[union-attr]
+                    try:
+                        self._cts.Cancel()
+                    except Exception:  # noqa: BLE001 — disposed: the call has already ended
+                        pass
+                    return
+
+        threading.Thread(target=watch, name="pmt4api-cancel", daemon=True).start()
+        return self
+
+    def __exit__(self, *exc: Any) -> None:
+        self._done.set()
+
+
+class _AccountMixin(_Base):
+    # ---- the account -------------------------------------------------------------------------------------------
+
+    @translated
+    def account(self, refresh: bool = True) -> AccountInfo:
+        """Account details. With ``refresh`` (the default) every open position's symbol is quoted once first, so
+        ``equity``, ``profit``, ``margin``, ``free_margin`` and ``margin_level`` are priced from current ticks. They are
+        derived on the client (the server does not push them), as the terminal does; see :attr:`equity` for the cheap
+        read of one figure."""
+        self._require_connected()
+        api = self._api
+        if refresh:
+            api.UpdateProfits()
+            if not api.Connected:                  # never let a refresh hide a lost connection
+                raise NotConnectedError("the connection was lost while refreshing the account")
+        a = api.Account
+        oldest = None
+        for sym in {str(o.Symbol) for o in api.GetOpenedOrders() if str(o.Type) in ("Buy", "Sell")}:
+            q = api.GetQuote(sym, 1)               # the price the figures use; its time says how old it is
+            t = _time(q.Time) if q is not None else None
+            if t is not None and (oldest is None or t < oldest):
+                oldest = t
+        return AccountInfo(
+            login=int(api.User), name=str(a.UserName or ""), company=str(a.Company or ""), group=str(a.Group or ""),
+            currency=str(a.Currency or ""), leverage=int(api.AccountLeverage), balance=float(api.AccountBalance),
+            credit=float(api.AccountCredit), equity=float(api.AccountEquity), profit=float(api.AccountProfit),
+            margin=float(api.AccountMargin), free_margin=float(api.AccountFreeMargin),
+            margin_level=float(api.AccountMarginLevel), account_type=str(api.AccountType),
+            is_investor=bool(api.IsInvestor), priced_from=oldest)
+
+    @property
+    def balance(self) -> float:
+        """The account balance (closed-trade funds, floating P/L excluded); a cheap read."""
+        return float(self._api.AccountBalance)
+
+    @property
+    def credit(self) -> float:
+        """The credit the broker granted; a cheap read."""
+        return float(self._api.AccountCredit)
+
+    @property
+    def equity(self) -> float:
+        """Balance + floating P/L + credit, priced from the quotes already cached (it does not subscribe or wait: a
+        position whose symbol has not ticked yet counts 0 floating). Use :meth:`live_equity` to wait for fresh
+        quotes."""
+        return float(self._api.AccountEquity)
+
+    @property
+    def profit(self) -> float:
+        """The floating P/L of the open positions (equity − balance − credit), from cached quotes."""
+        return float(self._api.AccountProfit)
+
+    @property
+    def margin(self) -> float:
+        """The margin the open positions hold, derived on the client like the terminal (Forex by leverage, CFD by
+        the symbol's margin divider; a Futures position counts 0 until its formula is verified). May wait for a
+        conversion quote."""
+        return float(self._api.AccountMargin)
+
+    @property
+    def free_margin(self) -> float:
+        """Equity − margin."""
+        return float(self._api.AccountFreeMargin)
+
+    @property
+    def margin_level(self) -> float:
+        """Equity / margin × 100, as the terminal shows it; 0 when no margin is used."""
+        return float(self._api.AccountMarginLevel)
+
+    @property
+    def leverage(self) -> int:
+        """The account leverage (the N in 1:N)."""
+        return int(self._api.AccountLeverage)
+
+    @translated
+    def live_equity(self) -> float:
+        """Equity priced from FRESH quotes: it subscribes each open position's symbol and waits (up to the client's
+        ``quote_timeout`` per symbol) for a tick. Blocks; the cached read is :attr:`equity`."""
+        self._require_connected()
+        return float(self._api.LiveEquity())
+
+    @translated
+    def update_profits(self, symbol: Optional[str] = None) -> None:
+        """Warm the quotes the equity figures are priced from: every open position's symbol, or just ``symbol``.
+        Blocks up to ``quote_timeout`` per symbol."""
+        self._require_connected()
+        if symbol is None:
+            self._api.UpdateProfits()
+        else:
+            self._spec(symbol)
+            self._api.UpdateProfits(symbol)
+
+    @translated
+    def update_margin(self) -> None:
+        """Warm the quotes the margin figure is priced from (every open position's symbol)."""
+        self._require_connected()
+        self._api.UpdateMargin()
+
+    # ---- orders and positions ----------------------------------------------------------------------------------
+
+    @translated
+    def orders(self) -> List[Order]:
+        """Everything currently working: open positions and pending orders. Each position's ``profit`` is re-priced
+        from the live quote on every read."""
+        self._require_connected()
+        return [Order._from_core(o) for o in self._api.GetOpenedOrders()]
+
+    def positions(self) -> List[Order]:
+        """Open market positions only (``Buy`` / ``Sell``)."""
+        return [o for o in self.orders() if o.is_market]
+
+    def pending_orders(self) -> List[Order]:
+        """Pending orders only (limits and stops)."""
+        return [o for o in self.orders() if o.is_pending]
+
+    @translated
+    def order(self, ticket: int) -> Optional[Order]:
+        """One open order or position by ticket, or ``None`` when it is not open."""
+        self._require_connected()
+        o = self._api.GetOpenedOrder(int(ticket))
+        return Order._from_core(o) if o is not None else None
+
+    # ---- history -----------------------------------------------------------------------------------------------
+
+    @translated
+    def history(self, start: Optional[datetime] = None, end: Optional[datetime] = None,
+                timeout: Optional[float] = None, cancel: Optional[threading.Event] = None) -> List[Order]:
+        """Closed orders and balance / credit entries between ``start`` and ``end`` (default: the last 30 days up to
+        now), sorted by close time. Blocks until the server has sent everything, up to ``timeout`` seconds (default:
+        the client's ``history_timeout``); set the ``cancel`` event to abandon the wait early
+        (:class:`RequestCancelled`).
+
+        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.
+
+        Each call opens its own short-lived broker connection and costs one licence request, which the licence
+        service rate-limits per minute: fetch once and reuse the result rather than polling.
+        """
+        self._require_connected()
+        now = self.server_time or datetime.now(timezone.utc).replace(tzinfo=None)
+        end = self._server_naive(end)
+        start = self._server_naive(start)
+        if end is None:
+            end = now + timedelta(days=1)            # nothing the server has booked is later than this
+        if start is None:
+            start = now - timedelta(days=30)
+        ms = int(timeout * 1000) if timeout is not None else int(self._api.DownloadOrderHistoryTimeoutMs)
+        if ms <= 0:
+            raise ValueError("timeout must be positive")
+        if cancel is not None and cancel.is_set():
+            raise RequestCancelled("cancelled before the request was made")      # nothing was sent: no licence request spent
+        with _Cancellation(cancel) as c:
+            if c.token is not None:
+                rows = self._api.DownloadOrderHistory(to_core_time(start), to_core_time(end), ms, c.token)
+            else:
+                rows = self._api.DownloadOrderHistory(to_core_time(start), to_core_time(end), ms)
+        return [Order._from_core(o) for o in (rows or ())]
+
+    async def ahistory(self, start: Optional[datetime] = None, end: Optional[datetime] = None,
+                       timeout: Optional[float] = None) -> List[Order]:
+        """Awaitable :meth:`history`. Cancelling the awaiting task abandons the download (the broker connection it
+        opened is closed), so ``asyncio.wait_for(c.ahistory(...), 10)`` does not leave a request running."""
+        cancel = threading.Event()
+        loop = asyncio.get_running_loop()
+        job = loop.run_in_executor(None, functools.partial(self.history, start, end, timeout, cancel))
+        job.add_done_callback(lambda f: f.cancelled() or f.exception())     # the outcome is ours; never "unretrieved"
+        try:
+            return await asyncio.shield(job)
+        except asyncio.CancelledError:
+            cancel.set()
+            raise
+
+    # ---- realized figures and curves ---------------------------------------------------------------------------
+
+    @translated
+    def summary(self, start: Optional[datetime] = None, end: Optional[datetime] = None) -> AccountSummary:
+        """Realized trading result, deposits and withdrawals, from the closed-order ledger (all time by default).
+
+        Downloads the history, so it blocks and costs one licence request; call it off your UI thread (or use
+        ``asyncio.to_thread``).
+        """
+        self._require_connected()
+        if start is None and end is None:
+            return AccountSummary._from_core(self._api.GetAccountSummary())
+        if start is None or end is None:
+            raise ValueError("give both start and end, or neither")
+        return AccountSummary._from_core(self._api.GetAccountSummary(to_core_time(self._server_naive(start)),
+                                                                     to_core_time(self._server_naive(end))))
+
+    @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``).
+
+        ``balance`` is exact; the historical ``equity`` is a reconstruction priced from the symbols' bars. With
+        ``exclude_same_bars`` (the default, as in the C# library) consecutive points with an unchanged balance and
+        equity are dropped. Downloads the history and per-symbol bars, so it blocks and costs a licence request.
+        """
+        self._require_connected()
+        tf = enum_value(self._core.EquityTimeframe, timeframe, "equity timeframe")
+        with self._bars_lock:                    # it downloads bars through the same single-flight request as bars()
+            points = self._api.CalculateEquityHistory(to_core_time(self._server_naive(start)), tf,
+                                                      bool(exclude_same_bars))
+        return [EquityPoint._from_core(p) for p in (points or ())]

pmt4api/_base.py

@@ -0,0 +1,24 @@
+"""What every client mixin may rely on: the core object, the core's namespace, and the connection guard."""
+from __future__ import annotations
+
+from datetime import datetime, timedelta, timezone
+from typing import Any, Optional
+
+from .errors import NotConnectedError
+
+
+class _Base:
+    _api: Any      # the core's client object (MT5API / MT4API)
+    _core: Any     # the core's namespace (types and enums)
+
+    def _require_connected(self) -> None:
+        if not self._api.Connected:
+            raise NotConnectedError("not connected; call connect() first")
+
+    def _server_naive(self, value: Optional[datetime]) -> Optional[datetime]:
+        """A datetime as the naive server time the core works in. A naive value is taken to be server time already
+        (as documented); a timezone-aware one is converted: to UTC, then by the server's offset from UTC."""
+        if value is None or value.tzinfo is None:
+            return value
+        offset = getattr(self, "server_utc_offset", None) or timedelta(0)
+        return value.astimezone(timezone.utc).replace(tzinfo=None) + offset

pmt4api/_coverage.py

@@ -0,0 +1,186 @@
+"""Where every public member and type of the C# SDK went.
+
+``COVERAGE`` maps each public member name of ``MT4API`` (and of ``OrderClient``, which holds the trade timeout, the
+default placement source, the progress event and the async trade extensions) to the Python name that provides it:
+
+* ``"Client.<attr>"``       a method, property or constructor argument of :class:`pmt4api.Client`
+* ``"Client(<argument>)"``  an argument of the constructor
+* ``"pmt4api.<name>"``      a module-level function
+* ``"not applicable: …"``   deliberately has no Python counterpart, with the reason
+
+``TYPES`` does the same for the public types. The integration test ``test_coverage`` reflects the DLL it is pointed at
+and fails when a public member or type has no entry here, or when an entry names a Python attribute that does not
+exist. A new SDK release therefore cannot add API without a decision being recorded. ``NOTES`` adds a sentence where
+the mapping is not one to one.
+"""
+from __future__ import annotations
+
+from typing import Dict
+
+COVERAGE: Dict[str, str] = {
+    # ---- lifecycle and session ----
+    "Connect": "Client.connect",
+    "Disconnect": "Client.disconnect",
+    "Reconnect": "Client.reconnect",
+    "Connected": "Client.connected",
+    "User": "Client.login",
+    "Host": "Client.host",
+    "Port": "Client.port",
+    "IsInvestor": "Client.is_investor",
+    "ServerTradeBuild": "Client.trade_build",
+    "ServerTime": "Client.server_time",
+    "Servers": "Client.servers",
+    "SrvList": "Client.server_list",
+    "LastSrvRecord": "not applicable: the raw wire record the server list was parsed from; read Client.server_list",
+    "OrderClient": "not applicable: its members (timeout, placement source, progress event, async trading) are "
+                   "reached through Client(trade_timeout), Client(placed_type), Client.on_order_progress and the "
+                   "*_async methods; Client.raw gives the core object",
+    # ---- configuration ----
+    "ApiKey": "Client(api_key)",
+    "TokenServiceUrl": "Client(token_url)",
+    "TokenServiceTimeout": "Client(token_timeout)",
+    "ConnectTimeout": "Client(connect_timeout)",
+    "GetQuoteTimeoutMs": "Client(quote_timeout)",
+    "DownloadOrderHistoryTimeoutMs": "Client(history_timeout)",
+    "DownloadQuoteHistoryTimeout": "Client(bars_timeout)",
+    "NoServerMessagesTimeout": "Client(no_message_timeout)",
+    "TradeTimeout": "Client(trade_timeout)",
+    "AutoReconnect": "Client(auto_reconnect)",
+    "ReconnectBackoffMs": "Client(reconnect_backoff)",
+    "ReconnectMaxAttempts": "Client(reconnect_max_attempts)",
+    "Encoding": "Client(comment_encoding)",
+    "PlacedType": "Client(placed_type)",
+    # ---- symbols and market data ----
+    "GetSymbolNames": "Client.symbols",
+    "GetSymbolSpec": "Client.symbol",
+    "SymbolDigits": "Client.symbol",
+    "SymbolExecution": "Client.symbol",
+    "Groups": "Client.symbol_groups",
+    "Subscribe": "Client.subscribe",
+    "Unsubscribe": "Client.unsubscribe",
+    "IsSubscribed": "Client.is_subscribed",
+    "GetQuote": "Client.quote",
+    "GetTickValue": "Client.tick_value",
+    "GetAskTickValue": "Client.tick_value",
+    "GetBidTickValue": "Client.tick_value",
+    "DownloadQuoteHistory": "Client.bars",
+    # ---- account ----
+    "Account": "Client.account",
+    "AccountName": "Client.account",
+    "AccountType": "Client.account",
+    "AccountBalance": "Client.balance",
+    "AccountCredit": "Client.credit",
+    "AccountEquity": "Client.equity",
+    "AccountProfit": "Client.profit",
+    "AccountMargin": "Client.margin",
+    "AccountFreeMargin": "Client.free_margin",
+    "AccountMarginLevel": "Client.margin_level",
+    "AccountLeverage": "Client.leverage",
+    "LiveEquity": "Client.live_equity",
+    "LiveEquityCached": "Client.equity",
+    "LiveMarginCached": "Client.margin",
+    "UpdateProfits": "Client.update_profits",
+    "UpdateMargin": "Client.update_margin",
+    "GetOpenedOrders": "Client.orders",
+    "GetOpenedOrder": "Client.order",
+    "DownloadOrderHistory": "Client.history",
+    "GetAccountSummary": "Client.summary",
+    "CalculateEquityHistory": "Client.equity_history",
+    # ---- sizing and risk ----
+    "CalculateLots": "Client.lots_for_risk",
+    "RequiredMargin": "Client.required_margin",
+    "CalculateOrderProfit": "Client.order_profit",
+    # ---- trading ----
+    "OrderSend": "Client.buy",
+    "OrderModify": "Client.modify",
+    "OrderClose": "Client.close",
+    "OrderCancel": "Client.cancel",
+    "OrderCloseBy": "Client.close_by",
+    "OrderMultipleCloseBy": "Client.close_all_by",
+    "OrderSendAsync": "Client.buy_async",
+    "OrderModifyAsync": "Client.modify_async",
+    "OrderCloseAsync": "Client.close_async",
+    "OrderCancelAsync": "Client.cancel_async",
+    "OrderCloseByAsync": "Client.close_by_async",
+    "OrderMultipleCloseByAsync": "Client.close_all_by_async",
+    "OrderSendAsyncTask": "Client.abuy",
+    "OrderModifyAsyncTask": "Client.amodify",
+    "OrderCloseAsyncTask": "Client.aclose",
+    "OrderCancelAsyncTask": "Client.acancel",
+    "OrderCloseByAsyncTask": "Client.aclose_by",
+    # ---- events ----
+    "OnQuote": "Client.on_quote",
+    "OnOrderUpdate": "Client.on_order_update",
+    "OnOrderProgress": "Client.on_order_progress",
+    "OnConnect": "Client.on_connect",
+    "OnDisconnect": "Client.on_disconnect",
+    "OnQuoteHistory": "Client.on_quote_history",
+    "OnSymbolsUpdate": "Client.on_symbols_update",
+    # ---- offline ----
+    "LoadServersIni": "pmt4api.load_servers_ini",
+    "SaveServersIni": "pmt4api.save_servers_ini",
+}
+
+_DELEGATE = "not applicable: a .NET delegate type; subscribe with %s"
+
+TYPES: Dict[str, str] = {
+    "MT4API": "pmt4api.Client",
+    "OrderClient": "pmt4api.Client",
+    "OrderClientAsyncTaskExtensions": "Client.abuy",
+    "AccountInfo": "pmt4api.AccountInfo",
+    "AccountSummary": "pmt4api.AccountSummary",
+    "Bar": "pmt4api.Bar",
+    "EquityPoint": "pmt4api.EquityPoint",
+    "LotSizing": "pmt4api.LotSizing",
+    "Mt4Server": "pmt4api.ServerRecord",
+    "Order": "pmt4api.Order",
+    "OrderProgress": "pmt4api.OrderProgress",
+    "OrderUpdate": "pmt4api.OrderUpdate",
+    "Quote": "pmt4api.Quote",
+    "QuoteHistoryEventArgs": "pmt4api.QuoteHistoryEvent",
+    "SymGroup": "pmt4api.SymbolGroup",
+    "SymbolSpec": "pmt4api.SymbolInfo",
+    "ConnectEventArgs": "pmt4api.ConnectEvent",
+    "DisconnectEventArgs": "pmt4api.ConnectEvent",
+    "ConnectEventHandler": _DELEGATE % "Client.on_connect",
+    "DisconnectEventHandler": _DELEGATE % "Client.on_disconnect",
+    "OrderUpdateEventHandler": _DELEGATE % "Client.on_order_update",
+    "OrderProgressEventHandler": _DELEGATE % "Client.on_order_progress",
+    "QuoteEventHandler": _DELEGATE % "Client.on_quote",
+    "QuoteHistoryEventHandler": _DELEGATE % "Client.on_quote_history",
+    "SymbolsUpdateEventHandler": _DELEGATE % "Client.on_symbols_update",
+    "Logger": "pmt4api.enable_core_logging",
+    "Logger+OnMsgHandler": "not applicable: a .NET delegate type; enable_core_logging forwards to Python logging",
+    "Logger+OnMsgHandlerEx": "not applicable: a .NET delegate type; enable_core_logging forwards to Python logging",
+    "Diag": "pmt4api.enable_core_logging",
+    "ConnectException": "pmt4api.ConnectError",
+    "InvestorModeException": "pmt4api.InvestorModeError",
+    "LicenseException": "pmt4api.LicenseError",
+    "LoginRejectedException": "pmt4api.LoginRejectedError",
+    "RequoteException": "pmt4api.RequoteError",
+    "ServerException": "pmt4api.ServerError",
+    "TokenServiceException": "pmt4api.TokenServiceError",
+    "TradeTimeoutException": "pmt4api.RequestTimeout",
+    # enums are exposed as their member names (strings)
+    "AccountType": "enum: str", "EquityTimeframe": "enum: str", "ExecutionType": "enum: str",
+    "LicenseReason": "enum: str", "Logger+MsgType": "enum: str", "OrderType": "enum: str", "PlacedType": "enum: str",
+    "ProgressType": "enum: str", "Timeframe": "enum: str", "UpdateType": "enum: str",
+}
+
+NOTES: Dict[str, str] = {
+    "OrderSend": "`buy`, `sell` and `place_order` cover the operations; `magic` other than 0 is refused (the core "
+                 "does not transmit it); the volume must be a multiple of 0.01",
+    "OrderSendAsync": "`buy_async`, `sell_async`, `place_order_async`; the integer returned is the request id that "
+                      "`on_order_progress` reports",
+    "OrderModify": "the symbol, type, volume and the values you did not change are taken from the open order, "
+                   "including a pending order's expiration",
+    "OrderClose": "partial close with `lots=`; the price defaults to the current bid / ask",
+    "GetSymbolSpec": "also `SymbolDigits` and `SymbolExecution`: `SymbolInfo.digits` and `.execution`",
+    "GetTickValue": "`side='ask'`; `side='bid'` is `GetBidTickValue`. Raises instead of returning NaN",
+    "DownloadQuoteHistory": "`count=` bars ending at `end`, or everything since `start=`; pages past the wire's "
+                            "32767-bar limit; the server's own depth limit applies",
+    "DownloadOrderHistory": "`timeout=` and a `threading.Event` for `cancel=` replace the timeout and cancellation "
+                            "token arguments; `ahistory` cancels with the awaiting task",
+    "Servers": "give `servers=[(host, port), ...]` to the constructor or call `add_server`",
+    "Reconnect": "returns False when every server failed; with `auto_reconnect=True` the core does it by itself",
+}