mywebapi-sdk 0.3.3__tar.gz → 0.3.4__tar.gz

{mywebapi_sdk-0.3.3 → mywebapi_sdk-0.3.4}/CHANGELOG.md

@@ -2,6 +2,24 @@
 
 All notable changes to `mywebapi-sdk` (import name `cplugin_webapi_sdk`). The package follows [semver](https://semver.org/); while it is at `0.x`, a minor release may contain breaking changes.
 
+## 0.3.4
+
+MT5 chart and tick history, ticks on the MT5 real-time hub, and batched ticks on both real-time hubs. Versions move together with the JavaScript, .NET and PowerShell SDKs.
+
+### Added
+
+- Generated MT5 history calls, from the new tag `MT5 v2 :: History Data`:
+  - `GET /api/v2/MT5/{tradePlatform}/ChartRequest/{symbol}` — OHLC bars of a symbol for a time window, ordered by time ascending. `period` is one of `M1`, `M5`, `M15`, `M30`, `H1`, `H4`, `D1`, `W1`, `MN1` (default `M1`); `from` and `to` are trading times of the trade server, both optional — the beginning of the history and the current server time respectively; `limit` caps the number of bars, `0` (the default) returns the whole window. The answer is `MT5ChartBarPage` — `bars`, `total`, `truncated`.
+  - `GET /api/v2/MT5/{tradePlatform}/TicksHistory/{symbol}` — historical ticks of a symbol for a time window, filtered by the symbol's tick filters, ordered by time ascending. `from` and `to` are optional in the same way, `limit` works as it does for bars. The answer is `MT5TickPage` — `ticks`, `total`, `truncated`; there is no pagination, so read further by moving `from` past the last returned tick.
+  - Models `MT5ChartBarV2`, `MT5ChartBarPage`, `MT5ChartBarPageApiResponse`, `MT5ChartPeriod`, `MT5TickV2`, `MT5TickPage`, `MT5TickPageApiResponse`.
+- MT5 real-time (`/hubs/mt5/v2`): `on_tick()` (`OnTick` events), `subscribe_to_ticks(symbol)` / `unsubscribe_from_ticks(symbol)` and `stream_ticks(symbol=None)`, where the symbol of the stream is optional — omit it to receive every symbol subscribed on the connection. Each tick carries `symbol`, `bid`, `ask`, `last`, `lastTime`, `volumeExt` and `flags`.
+- Batched ticks on both real-time hubs: `on_ticks_batch()` (`OnTicksBatch` events), `subscribe_to_ticks_batch(symbol, interval_ms=200, max_batch_size=200)` and `unsubscribe_from_ticks_batch(symbol)`. The payload is `{"symbol": …, "ticks": [...]}`. `interval_ms` is 20–60000 and `max_batch_size` is 1–10000; out-of-range values are refused by the server. A symbol subscribed to batches receives no per-tick `OnTick` events until it is subscribed the plain way again, and the subscriptions last until the connection closes.
+
+### Changed
+
+- The vendored `spec/v2.json` is the specification of 30.10.2026 (174 paths): the two MT5 history operations above are added to the previous document, and every operation it already had is unchanged.
+- `scripts/fetch_spec.py` reads a local main-service document when `WEBAPI_SPEC_FILE` is set, without a network call; in that mode the previous vendored file supplies the MT4 x86 sidecar routes, which the x64 document does not contain. The merge keeps the document-level keys of that previous union as well.
+
 ## 0.3.3
 
 Regenerated from the WebAPI v2 specification of 05.10.2026; no change to the API surface or to the generated models' fields and types.

{mywebapi_sdk-0.3.3 → mywebapi_sdk-0.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: mywebapi-sdk
-Version: 0.3.3
+Version: 0.3.4
 Summary: Python SDK for CPlugin WebAPI: REST and WebSocket client that works with MetaTrader 4 and MetaTrader 5 servers - accounts, positions, deposits, trade history, groups and symbols for brokers. MetaTrader is a trademark of MetaQuotes Ltd.; not affiliated with MetaQuotes.
 Project-URL: Homepage, https://mywebapi.com
 Project-URL: Documentation, https://cplugin.com/docs/webapi

{mywebapi_sdk-0.3.3 → mywebapi_sdk-0.3.4}/pyproject.toml

@@ -4,9 +4,10 @@ build-backend = "hatchling.build"
 
 [project]
 # * PyPI distribution name (https://pypi.org/project/mywebapi-sdk/), first released as
-#   0.3.0 on 30.09.2026; versions move together with the JS, .NET and PowerShell SDKs.
+#   0.3.0 on 30.09.2026, 0.3.4 on 30.10.2026; versions move together with the
+#   JS, .NET and PowerShell SDKs.
 name = "mywebapi-sdk"
-version = "0.3.3"
+version = "0.3.4"
 description = "Python SDK for CPlugin WebAPI: REST and WebSocket client that works with MetaTrader 4 and MetaTrader 5 servers - accounts, positions, deposits, trade history, groups and symbols for brokers. MetaTrader is a trademark of MetaQuotes Ltd.; not affiliated with MetaQuotes."
 readme = "README.md"
 requires-python = ">=3.10"

mywebapi_sdk-0.3.4/scripts/fetch_spec.py

@@ -0,0 +1,70 @@
+"""Fetch the v2 OpenAPI document from STAGING and write the vendored spec.
+
+Staging is the reliable source. The main app and the x86 sidecar each expose a
+swagger document; we union their `paths` and `components.schemas` into one
+canonical file, matching the union the TS SDK performs.
+
+Offline use: set ``WEBAPI_SPEC_FILE`` to a local x64 (main app) document and no
+HTTP request is made. The sidecar routes are compiled out of that build, so the
+previous vendored document is unioned in as the sidecar source — the same union
+the online run performs against pre-x86.
+
+Usage: python scripts/fetch_spec.py
+       WEBAPI_SPEC_FILE=/path/to/swagger-v2.json python scripts/fetch_spec.py
+"""
+from __future__ import annotations
+
+import json
+import os
+import sys
+from pathlib import Path
+
+import httpx
+
+MAIN_URL = "https://pre.mywebapi.com/swagger/v2/swagger.json"
+SIDECAR_URL = "https://pre-x86.mywebapi.com/swagger/v2/swagger.json"
+OUT = Path(__file__).resolve().parent.parent / "src" / "cplugin_webapi_sdk" / "spec" / "v2.json"
+# * Local main-app document: skips the network entirely (CI-less rebuilds).
+LOCAL_SPEC_ENV = "WEBAPI_SPEC_FILE"
+
+
+def _merge(base: dict, extra: dict) -> dict:
+    base.setdefault("paths", {})
+    base.setdefault("components", {}).setdefault("schemas", {})
+    # * A local x64 document carries no `servers`; keep the top-level keys of the
+    # *   previous union so an offline rebuild does not drop them.
+    for key, value in extra.items():
+        if key not in ("paths", "components"):
+            base.setdefault(key, value)
+    for path, item in extra.get("paths", {}).items():
+        base["paths"].setdefault(path, item)
+    for name, schema in extra.get("components", {}).get("schemas", {}).items():
+        base["components"]["schemas"].setdefault(name, schema)
+    return base
+
+
+def main() -> int:
+    local_spec = os.environ.get(LOCAL_SPEC_ENV)
+    if local_spec:
+        main_doc = json.loads(Path(local_spec).read_text(encoding="utf-8"))
+        # * The local build is x64-only and lacks the MT4 x86 sidecar routes;
+        # *   keep them from the previous union rather than dropping operations.
+        previous = json.loads(OUT.read_text(encoding="utf-8")) if OUT.exists() else {}
+        merged = _merge(main_doc, previous)
+    else:
+        with httpx.Client(timeout=30) as http:
+            main_doc = http.get(MAIN_URL).raise_for_status().json()
+            sidecar_doc = http.get(SIDECAR_URL).raise_for_status().json()
+        merged = _merge(main_doc, sidecar_doc)
+    path_count = len(merged["paths"])
+    OUT.parent.mkdir(parents=True, exist_ok=True)
+    OUT.write_text(json.dumps(merged, indent=2) + "\n", encoding="utf-8")
+    print(f"wrote {OUT} ({path_count} paths)")
+    if path_count < 174:
+        print(f"! expected >= 174 paths, got {path_count}", file=sys.stderr)
+        return 1
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

mywebapi_sdk-0.3.4/src/cplugin_webapi_sdk/_generated/api/mt5_v_2_history_data/get_api_v_2_mt5_trade_platform_chart_request_symbol.py

@@ -0,0 +1,427 @@
+from http import HTTPStatus
+from typing import Any, cast
+from urllib.parse import quote
+
+import httpx
+
+from ...client import AuthenticatedClient, Client
+from ...types import Response, UNSET
+from ... import errors
+
+from ...models.mt5_chart_bar_page_api_response import MT5ChartBarPageApiResponse
+from ...models.mt5_chart_period import MT5ChartPeriod
+from ...types import UNSET, Unset
+from typing import cast
+from uuid import UUID
+import datetime
+
+
+
+def _get_kwargs(
+    trade_platform: UUID,
+    symbol: str,
+    *,
+    period: MT5ChartPeriod | Unset = MT5ChartPeriod.M1,
+    from_: datetime.datetime | Unset = UNSET,
+    to: datetime.datetime | Unset = UNSET,
+    limit: int | Unset = 0,
+    x_request_timeout: float | Unset = UNSET,
+
+) -> dict[str, Any]:
+    headers: dict[str, Any] = {}
+    if not isinstance(x_request_timeout, Unset):
+        headers["X-Request-Timeout"] = str(x_request_timeout)
+
+
+
+
+    
+
+    params: dict[str, Any] = {}
+
+    json_period: str | Unset = UNSET
+    if not isinstance(period, Unset):
+        json_period = period.value
+
+    params["period"] = json_period
+
+    json_from_: str | Unset = UNSET
+    if not isinstance(from_, Unset):
+        json_from_ = from_.isoformat()
+    params["from"] = json_from_
+
+    json_to: str | Unset = UNSET
+    if not isinstance(to, Unset):
+        json_to = to.isoformat()
+    params["to"] = json_to
+
+    params["limit"] = limit
+
+
+    params = {k: v for k, v in params.items() if v is not UNSET and v is not None}
+
+
+    _kwargs: dict[str, Any] = {
+        "method": "get",
+        "url": "/api/v2/MT5/{trade_platform}/ChartRequest/{symbol}".format(trade_platform=quote(str(trade_platform), safe=""),symbol=quote(str(symbol), safe=""),),
+        "params": params,
+    }
+
+
+    _kwargs["headers"] = headers
+    return _kwargs
+
+
+
+def _parse_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> MT5ChartBarPageApiResponse | None:
+    if response.status_code == 200:
+        response_200 = MT5ChartBarPageApiResponse.from_dict(response.json())
+
+
+
+        return response_200
+
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Response[MT5ChartBarPageApiResponse]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    trade_platform: UUID,
+    symbol: str,
+    *,
+    client: AuthenticatedClient | Client,
+    period: MT5ChartPeriod | Unset = MT5ChartPeriod.M1,
+    from_: datetime.datetime | Unset = UNSET,
+    to: datetime.datetime | Unset = UNSET,
+    limit: int | Unset = 0,
+    x_request_timeout: float | Unset = UNSET,
+
+) -> Response[MT5ChartBarPageApiResponse]:
+    """ Get chart bars
+
+     <br>
+                OHLC bars of a symbol for a time window, ordered by time ascending. The trade
+                server keeps history as minutes; bars of a coarser `period` are aggregated
+                from those minutes on the boundaries of the server's trading time, so a day
+                starts at 00:00 of the server clock. A bar opens with the first minute of the
+                bucket and closes with the last one, its high and low are the extremes of the
+                bucket, tick volume and real volume are summed, and spread is the lowest of the
+                bucket. Buckets without minutes are not produced.
+
+    <br>
+                Times are the trading times of the trade server, not UTC: `time` repeats the
+                seconds-from-1970 value the platform uses, `dateTime` is the same moment
+                without an offset. Prices are returned as the platform holds them, without
+                rescaling.
+
+    <br>
+      `from` and `to` are optional: without `from` the window starts at
+                the beginning of the history, without `to` it ends at the current server
+                time. `limit` is 0 by default and returns the whole window; a positive value
+                caps the returned bars and sets `truncated`. There is no pagination: to read
+                further, repeat the request with `from` moved past the last returned bar.
+
+    <br>
+                The call only reads and changes nothing. When the platform has not received the
+                requested history yet, the call fails with the platform code `MT_RET_OK_NONE`
+                and a message saying the history is not synchronized — such a request may be
+                repeated later. `W1` and `MN1` are rejected: such bars are not built.
+
+
+    **Timeout:** 30 s by default, adjustable per request with the `X-Request-Timeout` header. When the
+    trade server does not answer in time: Nothing was changed; the request is safe to repeat.
+
+    Args:
+        trade_platform (UUID):
+        symbol (str):
+        period (MT5ChartPeriod | Unset): Bar period of a chart history request. Coarser bars than
+            a minute are built by the
+            service from the minute history of the trade server, on the boundaries of the trade
+            server's trading time — a day therefore starts at 00:00 of the server clock. Default:
+            MT5ChartPeriod.M1.
+        from_ (datetime.datetime | Unset):
+        to (datetime.datetime | Unset):
+        limit (int | Unset):  Default: 0.
+        x_request_timeout (float | Unset):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[MT5ChartBarPageApiResponse]
+     """
+
+
+    kwargs = _get_kwargs(
+        trade_platform=trade_platform,
+symbol=symbol,
+period=period,
+from_=from_,
+to=to,
+limit=limit,
+x_request_timeout=x_request_timeout,
+
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+def sync(
+    trade_platform: UUID,
+    symbol: str,
+    *,
+    client: AuthenticatedClient | Client,
+    period: MT5ChartPeriod | Unset = MT5ChartPeriod.M1,
+    from_: datetime.datetime | Unset = UNSET,
+    to: datetime.datetime | Unset = UNSET,
+    limit: int | Unset = 0,
+    x_request_timeout: float | Unset = UNSET,
+
+) -> MT5ChartBarPageApiResponse | None:
+    """ Get chart bars
+
+     <br>
+                OHLC bars of a symbol for a time window, ordered by time ascending. The trade
+                server keeps history as minutes; bars of a coarser `period` are aggregated
+                from those minutes on the boundaries of the server's trading time, so a day
+                starts at 00:00 of the server clock. A bar opens with the first minute of the
+                bucket and closes with the last one, its high and low are the extremes of the
+                bucket, tick volume and real volume are summed, and spread is the lowest of the
+                bucket. Buckets without minutes are not produced.
+
+    <br>
+                Times are the trading times of the trade server, not UTC: `time` repeats the
+                seconds-from-1970 value the platform uses, `dateTime` is the same moment
+                without an offset. Prices are returned as the platform holds them, without
+                rescaling.
+
+    <br>
+      `from` and `to` are optional: without `from` the window starts at
+                the beginning of the history, without `to` it ends at the current server
+                time. `limit` is 0 by default and returns the whole window; a positive value
+                caps the returned bars and sets `truncated`. There is no pagination: to read
+                further, repeat the request with `from` moved past the last returned bar.
+
+    <br>
+                The call only reads and changes nothing. When the platform has not received the
+                requested history yet, the call fails with the platform code `MT_RET_OK_NONE`
+                and a message saying the history is not synchronized — such a request may be
+                repeated later. `W1` and `MN1` are rejected: such bars are not built.
+
+
+    **Timeout:** 30 s by default, adjustable per request with the `X-Request-Timeout` header. When the
+    trade server does not answer in time: Nothing was changed; the request is safe to repeat.
+
+    Args:
+        trade_platform (UUID):
+        symbol (str):
+        period (MT5ChartPeriod | Unset): Bar period of a chart history request. Coarser bars than
+            a minute are built by the
+            service from the minute history of the trade server, on the boundaries of the trade
+            server's trading time — a day therefore starts at 00:00 of the server clock. Default:
+            MT5ChartPeriod.M1.
+        from_ (datetime.datetime | Unset):
+        to (datetime.datetime | Unset):
+        limit (int | Unset):  Default: 0.
+        x_request_timeout (float | Unset):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        MT5ChartBarPageApiResponse
+     """
+
+
+    return sync_detailed(
+        trade_platform=trade_platform,
+symbol=symbol,
+client=client,
+period=period,
+from_=from_,
+to=to,
+limit=limit,
+x_request_timeout=x_request_timeout,
+
+    ).parsed
+
+async def asyncio_detailed(
+    trade_platform: UUID,
+    symbol: str,
+    *,
+    client: AuthenticatedClient | Client,
+    period: MT5ChartPeriod | Unset = MT5ChartPeriod.M1,
+    from_: datetime.datetime | Unset = UNSET,
+    to: datetime.datetime | Unset = UNSET,
+    limit: int | Unset = 0,
+    x_request_timeout: float | Unset = UNSET,
+
+) -> Response[MT5ChartBarPageApiResponse]:
+    """ Get chart bars
+
+     <br>
+                OHLC bars of a symbol for a time window, ordered by time ascending. The trade
+                server keeps history as minutes; bars of a coarser `period` are aggregated
+                from those minutes on the boundaries of the server's trading time, so a day
+                starts at 00:00 of the server clock. A bar opens with the first minute of the
+                bucket and closes with the last one, its high and low are the extremes of the
+                bucket, tick volume and real volume are summed, and spread is the lowest of the
+                bucket. Buckets without minutes are not produced.
+
+    <br>
+                Times are the trading times of the trade server, not UTC: `time` repeats the
+                seconds-from-1970 value the platform uses, `dateTime` is the same moment
+                without an offset. Prices are returned as the platform holds them, without
+                rescaling.
+
+    <br>
+      `from` and `to` are optional: without `from` the window starts at
+                the beginning of the history, without `to` it ends at the current server
+                time. `limit` is 0 by default and returns the whole window; a positive value
+                caps the returned bars and sets `truncated`. There is no pagination: to read
+                further, repeat the request with `from` moved past the last returned bar.
+
+    <br>
+                The call only reads and changes nothing. When the platform has not received the
+                requested history yet, the call fails with the platform code `MT_RET_OK_NONE`
+                and a message saying the history is not synchronized — such a request may be
+                repeated later. `W1` and `MN1` are rejected: such bars are not built.
+
+
+    **Timeout:** 30 s by default, adjustable per request with the `X-Request-Timeout` header. When the
+    trade server does not answer in time: Nothing was changed; the request is safe to repeat.
+
+    Args:
+        trade_platform (UUID):
+        symbol (str):
+        period (MT5ChartPeriod | Unset): Bar period of a chart history request. Coarser bars than
+            a minute are built by the
+            service from the minute history of the trade server, on the boundaries of the trade
+            server's trading time — a day therefore starts at 00:00 of the server clock. Default:
+            MT5ChartPeriod.M1.
+        from_ (datetime.datetime | Unset):
+        to (datetime.datetime | Unset):
+        limit (int | Unset):  Default: 0.
+        x_request_timeout (float | Unset):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[MT5ChartBarPageApiResponse]
+     """
+
+
+    kwargs = _get_kwargs(
+        trade_platform=trade_platform,
+symbol=symbol,
+period=period,
+from_=from_,
+to=to,
+limit=limit,
+x_request_timeout=x_request_timeout,
+
+    )
+
+    response = await client.get_async_httpx_client().request(
+        **kwargs
+    )
+
+    return _build_response(client=client, response=response)
+
+async def asyncio(
+    trade_platform: UUID,
+    symbol: str,
+    *,
+    client: AuthenticatedClient | Client,
+    period: MT5ChartPeriod | Unset = MT5ChartPeriod.M1,
+    from_: datetime.datetime | Unset = UNSET,
+    to: datetime.datetime | Unset = UNSET,
+    limit: int | Unset = 0,
+    x_request_timeout: float | Unset = UNSET,
+
+) -> MT5ChartBarPageApiResponse | None:
+    """ Get chart bars
+
+     <br>
+                OHLC bars of a symbol for a time window, ordered by time ascending. The trade
+                server keeps history as minutes; bars of a coarser `period` are aggregated
+                from those minutes on the boundaries of the server's trading time, so a day
+                starts at 00:00 of the server clock. A bar opens with the first minute of the
+                bucket and closes with the last one, its high and low are the extremes of the
+                bucket, tick volume and real volume are summed, and spread is the lowest of the
+                bucket. Buckets without minutes are not produced.
+
+    <br>
+                Times are the trading times of the trade server, not UTC: `time` repeats the
+                seconds-from-1970 value the platform uses, `dateTime` is the same moment
+                without an offset. Prices are returned as the platform holds them, without
+                rescaling.
+
+    <br>
+      `from` and `to` are optional: without `from` the window starts at
+                the beginning of the history, without `to` it ends at the current server
+                time. `limit` is 0 by default and returns the whole window; a positive value
+                caps the returned bars and sets `truncated`. There is no pagination: to read
+                further, repeat the request with `from` moved past the last returned bar.
+
+    <br>
+                The call only reads and changes nothing. When the platform has not received the
+                requested history yet, the call fails with the platform code `MT_RET_OK_NONE`
+                and a message saying the history is not synchronized — such a request may be
+                repeated later. `W1` and `MN1` are rejected: such bars are not built.
+
+
+    **Timeout:** 30 s by default, adjustable per request with the `X-Request-Timeout` header. When the
+    trade server does not answer in time: Nothing was changed; the request is safe to repeat.
+
+    Args:
+        trade_platform (UUID):
+        symbol (str):
+        period (MT5ChartPeriod | Unset): Bar period of a chart history request. Coarser bars than
+            a minute are built by the
+            service from the minute history of the trade server, on the boundaries of the trade
+            server's trading time — a day therefore starts at 00:00 of the server clock. Default:
+            MT5ChartPeriod.M1.
+        from_ (datetime.datetime | Unset):
+        to (datetime.datetime | Unset):
+        limit (int | Unset):  Default: 0.
+        x_request_timeout (float | Unset):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        MT5ChartBarPageApiResponse
+     """
+
+
+    return (await asyncio_detailed(
+        trade_platform=trade_platform,
+symbol=symbol,
+client=client,
+period=period,
+from_=from_,
+to=to,
+limit=limit,
+x_request_timeout=x_request_timeout,
+
+    )).parsed