revolut-x-python 1.0.0__tar.gz → 1.0.1__tar.gz

{revolut_x_python-1.0.0 → revolut_x_python-1.0.1}/.agents/skills/revolut-x-library/SKILL.md

@@ -136,10 +136,11 @@ book = client.get_order_book("BTC-EUR")            # → OrderBook
 candles = client.get_candles("BTC-EUR", Interval.HOUR_1)
 
 # Public trades — single page + cursor.
-# start_date / end_date are Unix MILLISECONDS (int), never date strings —
-# a string like "2024-01-01" raises ValueError.
-import time
-day_ago = int(time.time() * 1000) - 86_400_000
+# start_date / end_date accept a datetime, a date, an ISO-8601 string, or a Unix
+# timestamp in MILLISECONDS. Numbers are never rescaled, so a seconds timestamp
+# silently means 1970 — prefer a datetime when you are not sure.
+from datetime import datetime, timedelta, timezone
+day_ago = datetime.now(timezone.utc) - timedelta(days=1)
 trades, next_cursor = client.get_trades("BTC-EUR", start_date=day_ago, limit=100)
 
 # Auto-paginating trade iterator
@@ -170,7 +171,10 @@ Each candle is a dict — **not** a list or tuple:
 - `start` — candle **open** time, `int` Unix **milliseconds**, always **UTC**
 - `open` / `high` / `low` / `close` / `volume` — **strings**; `volume` is in the
   base currency. Wrap in `Decimal`, never `float`.
-- `since` / `until` are also Unix **milliseconds** (`int`), inclusive on both ends.
+- `since` / `until` are inclusive on both ends and accept a `datetime`, a `date`,
+  an ISO-8601 string, or an `int` of Unix **milliseconds**. Naive `datetime`s and
+  strings are read as **UTC**; raw numbers are taken as milliseconds as-is
+  (`revolut_x.to_timestamp_ms` does the conversion if you need it yourself).
 
 Three things that make naive candle code wrong:
 
@@ -194,7 +198,7 @@ regardless of who runs it.
 
 ```python
 import time
-from datetime import datetime, timezone, time as dtime
+from datetime import datetime, timedelta, timezone, time as dtime
 from decimal import Decimal
 from revolut_x import RevolutXClient, Interval
 
@@ -205,10 +209,10 @@ interval = Interval.HOUR_1
 # otherwise the row set shifts with the machine's local timezone.
 day = datetime.now(timezone.utc).date()                      # or date(2026, 10, 10)
 midnight = datetime.combine(day, dtime.min, tzinfo=timezone.utc)
-since = int(midnight.timestamp() * 1000)
-until = min(since + 86_400_000 - 1, int(time.time() * 1000))
+until = min(midnight + timedelta(days=1) - timedelta(milliseconds=1),
+            datetime.now(timezone.utc))
 
-candles = client.get_candles("BTC-EUR", interval, since=since, until=until)
+candles = client.get_candles("BTC-EUR", interval, since=midnight, until=until)
 
 interval_ms = int(interval) * 60_000
 now_ms = int(time.time() * 1000)

{revolut_x_python-1.0.0 → revolut_x_python-1.0.1}/.agents/skills/revolut-x-library/references/types.md

@@ -39,7 +39,9 @@ class Interval(int, Enum):
 ## TypedDicts (API Responses)
 
 > All numeric values are **strings** (not floats) to preserve decimal precision.
-> Timestamps are `int` (Unix milliseconds).
+> Timestamps in responses are `int` (Unix milliseconds). On the way *in*, time
+> range arguments are typed `TimeLike` — a `datetime`, a `date`, an ISO-8601
+> string, or an `int` of milliseconds.
 
 ### Candle
 

{revolut_x_python-1.0.0 → revolut_x_python-1.0.1}/CHANGELOG.md

@@ -7,6 +7,30 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ---
 
+## [Unreleased]
+
+### Added
+- **`datetime` support for time ranges**: `since` / `until` on `get_candles()`
+  and `iter_candles()`, and `start_date` / `end_date` on `get_trades()` and
+  `iter_trades()`, now accept a `datetime`, a `date`, an ISO-8601 string
+  (trailing `Z` included), a digits-only string of 12+ digits (milliseconds, for
+  values arriving from JSON or query parameters) or the millisecond `int` they
+  always took. A shorter run of digits — `'2024'`, `'20240101'` — raises
+  `ValueError` instead of silently resolving to 1970 or to a date, because it is
+  ambiguous between the two; note this also makes `'20240101'` behave the same
+  on every supported interpreter, where `datetime.fromisoformat` accepted it as
+  a basic-format date on 3.11+ but rejected it on 3.10. Naive
+  `datetime`s and strings are interpreted as **UTC** rather than the machine's
+  local timezone, so the same code selects the same window everywhere. Raw
+  numbers are still passed through untouched — seconds are deliberately *not*
+  auto-detected, because inferring the unit from the magnitude would silently
+  change the meaning of the caller's input.
+- **`to_timestamp_ms()`** (exported from `revolut_x`, together with the
+  `TimeLike` type alias) performs that conversion and is reusable in
+  application code.
+
+Existing millisecond integers keep working unchanged.
+
 ## [1.0.0] - 2026-10-11
 
 First release published to **PyPI**. Versions `0.0.1` – `0.1.0` were only ever

{revolut_x_python-1.0.0 → revolut_x_python-1.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: revolut-x-python
-Version: 1.0.0
+Version: 1.0.1
 Summary: Python SDK for the Revolut X Crypto Exchange REST API (v1.0)
 Author: Jan Přikryl
 License-Expression: MIT
@@ -10,20 +10,6 @@ Project-URL: Repository, https://github.com/janprikryl1/revolut-x-python
 Project-URL: Changelog, https://github.com/janprikryl1/revolut-x-python/blob/main/CHANGELOG.md
 Project-URL: Issues, https://github.com/janprikryl1/revolut-x-python/issues
 Keywords: revolut,revolut-x,crypto,exchange,trading,api,sdk,bitcoin
-Classifier: Development Status :: 5 - Production/Stable
-Classifier: Intended Audience :: Developers
-Classifier: Intended Audience :: Financial and Insurance Industry
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3 :: Only
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Classifier: Programming Language :: Python :: 3.14
-Classifier: Topic :: Office/Business :: Financial :: Investment
-Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Classifier: Typing :: Typed
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE

{revolut_x_python-1.0.0 → revolut_x_python-1.0.1}/pyproject.toml

@@ -15,22 +15,6 @@ authors = [
     { name = "Jan Přikryl" },
 ]
 keywords = ["revolut", "revolut-x", "crypto", "exchange", "trading", "api", "sdk", "bitcoin"]
-classifiers = [
-    "Development Status :: 5 - Production/Stable",
-    "Intended Audience :: Developers",
-    "Intended Audience :: Financial and Insurance Industry",
-    "Operating System :: OS Independent",
-    "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3 :: Only",
-    "Programming Language :: Python :: 3.10",
-    "Programming Language :: Python :: 3.11",
-    "Programming Language :: Python :: 3.12",
-    "Programming Language :: Python :: 3.13",
-    "Programming Language :: Python :: 3.14",
-    "Topic :: Office/Business :: Financial :: Investment",
-    "Topic :: Software Development :: Libraries :: Python Modules",
-    "Typing :: Typed",
-]
 dependencies = [
     "requests>=2.31.0",
     "cryptography>=41.0.0",

{revolut_x_python-1.0.0 → revolut_x_python-1.0.1}/src/revolut_x/__init__.py

@@ -39,6 +39,7 @@ from revolut_x.types import (
     OrderResponse,
     PairConfig,
     Ticker,
+    TimeLike,
     Trade,
 )
 from revolut_x.helpers import (
@@ -51,6 +52,7 @@ from revolut_x.helpers import (
     build_order,
     calculate_maker_price,
     normalize_symbol,
+    to_timestamp_ms,
 )
 from revolut_x.exceptions import (
     ApiError,
@@ -76,6 +78,7 @@ __all__ = [
     "FeeCalculator",
     "FeeEstimate",
     "normalize_symbol",
+    "to_timestamp_ms",
     "calculate_maker_price",
     "build_order",
     "build_market_order",
@@ -92,6 +95,7 @@ __all__ = [
     "OrderResponse",
     "PairConfig",
     "Ticker",
+    "TimeLike",
     "Trade",
     # Exceptions
     "RevolutXError",

{revolut_x_python-1.0.0 → revolut_x_python-1.0.1}/src/revolut_x/_version.py

@@ -7,4 +7,4 @@ three used to be maintained by hand and had drifted apart (0.0.6 / 0.0.8 /
 0.1.0 simultaneously).
 """
 
-__version__ = "1.0.0"
+__version__ = "1.0.1"

{revolut_x_python-1.0.0 → revolut_x_python-1.0.1}/src/revolut_x/helpers.py

@@ -1,10 +1,11 @@
 from __future__ import annotations
 import uuid
 from dataclasses import dataclass
+from datetime import date, datetime, time, timezone
 from decimal import Decimal, InvalidOperation, ROUND_HALF_UP
 from typing import Any
 
-from revolut_x.types import OrderSide, OrderType, TimeInForce
+from revolut_x.types import OrderSide, OrderType, TimeInForce, TimeLike
 from revolut_x.exceptions import OrderValidationError
 
 
@@ -35,6 +36,96 @@ def normalize_symbol(symbol: str) -> str:
     return symbol.replace("/", "-").upper()
 
 
+#: Minimum number of digits a digits-only string needs before it is read as a
+#: millisecond timestamp.  12 digits reach back to 1973 and real timestamps have
+#: had 13 since 2001, so anything shorter is almost certainly a date that lost
+#: its separators (``'2024'``, ``'20240101'``) rather than an instant in 1970.
+MIN_MS_DIGITS = 12
+
+
+def to_timestamp_ms(value: TimeLike) -> int:
+    """Converts a point in time to a Unix timestamp in milliseconds.
+
+    Used by the market data methods so that time ranges can be expressed with
+    ``datetime`` objects instead of raw millisecond integers.
+
+    Args:
+        value: One of
+
+            * ``int`` / ``float`` — already a Unix timestamp in
+              **milliseconds**; returned as an int (floats are truncated).
+              Seconds are *not* auto-detected — multiply by 1000 yourself.
+            * :class:`~datetime.datetime` — timezone-aware values use their own
+              offset, naive values are interpreted as **UTC**.
+            * :class:`~datetime.date` — midnight UTC on that day.
+            * ``str`` — an ISO-8601 timestamp (a trailing ``'Z'`` is accepted);
+              naive strings are again interpreted as UTC.  A digits-only string
+              of at least :data:`MIN_MS_DIGITS` digits is read as milliseconds
+              instead, for values arriving from JSON or query parameters.
+
+    Returns:
+        int: The Unix timestamp in milliseconds.
+
+    Raises:
+        TypeError: If the value is not one of the supported types.
+        ValueError: If a string is neither a valid ISO-8601 timestamp nor a
+            long enough run of digits.
+
+    Example:
+        >>> from datetime import datetime, timezone
+        >>> to_timestamp_ms(datetime(2024, 1, 1, tzinfo=timezone.utc))
+        1704067200000
+        >>> to_timestamp_ms("2024-01-01")
+        1704067200000
+        >>> to_timestamp_ms(1704067200000)
+        1704067200000
+        >>> to_timestamp_ms("1704067200000")
+        1704067200000
+    """
+    if isinstance(value, bool):
+        raise TypeError("Timestamp must be a number, datetime, date, or ISO-8601 string")
+
+    if isinstance(value, (int, float)):
+        return int(value)
+
+    if isinstance(value, str):
+        text = value.strip()
+
+        digits = text[1:] if text[:1] in "+-" else text
+        # str.isdigit() also accepts non-ASCII digits that int() cannot parse.
+        if digits.isascii() and digits.isdigit():
+            if len(digits) >= MIN_MS_DIGITS:
+                return int(text)
+            raise ValueError(
+                f"Ambiguous numeric timestamp string: {value!r}. A digits-only string is "
+                f"read as Unix milliseconds and needs at least {MIN_MS_DIGITS} digits — "
+                f"anything shorter lands in 1970 and is far more likely a date that lost "
+                f"its separators. Pass an int for milliseconds, or a date like "
+                f"'2024-01-01'."
+            )
+
+        if text.endswith(("Z", "z")):
+            text = f"{text[:-1]}+00:00"
+        try:
+            value = datetime.fromisoformat(text)
+        except ValueError as exc:
+            raise ValueError(f"Invalid ISO-8601 timestamp: {value!r}") from exc
+
+    # datetime is a subclass of date, so it has to be checked first.
+    if isinstance(value, datetime):
+        if value.tzinfo is None:
+            value = value.replace(tzinfo=timezone.utc)
+        return int(value.timestamp() * 1000)
+
+    if isinstance(value, date):
+        return int(datetime.combine(value, time.min, tzinfo=timezone.utc).timestamp() * 1000)
+
+    raise TypeError(
+        f"Timestamp must be a number, datetime, date, or ISO-8601 string, "
+        f"got {type(value).__name__}"
+    )
+
+
 class OrderPayloadBuilder:
     """Builder and validator for Revolut X API order payloads."""
 

{revolut_x_python-1.0.0 → revolut_x_python-1.0.1}/src/revolut_x/market.py

@@ -19,9 +19,11 @@ from revolut_x.types import (
     OrderBook,
     PairConfig,
     Ticker,
+    TimeLike,
     Trade,
 )
 from revolut_x.helpers import normalize_symbol as _normalize_symbol
+from revolut_x.helpers import to_timestamp_ms as _to_ms
 
 if TYPE_CHECKING:
     from revolut_x._http import HttpClient
@@ -232,8 +234,8 @@ class MarketMixin:
         symbol: str,
         interval: Interval | int = Interval.HOUR_1,
         *,
-        since: int | None = None,
-        until: int | None = None,
+        since: TimeLike | None = None,
+        until: TimeLike | None = None,
     ) -> list[Candle]:
         """Fetch up to 1000 OHLCV candlesticks for a trading pair.
 
@@ -242,8 +244,11 @@ class MarketMixin:
             interval: Candle interval — use the :class:`~revolut_x.types.Interval`
                 enum (e.g. ``Interval.MIN_1``, ``Interval.HOUR_1``) or an integer
                 number of minutes.
-            since: Start time as Unix timestamp in **milliseconds** (inclusive).
-            until: End time as Unix timestamp in **milliseconds** (inclusive).
+            since: Start time, inclusive — a Unix timestamp in
+                **milliseconds**, a :class:`~datetime.datetime` /
+                :class:`~datetime.date`, or an ISO-8601 string (see
+                :func:`~revolut_x.helpers.to_timestamp_ms`).
+            until: End time, inclusive — same accepted formats as ``since``.
 
         Returns:
             A list of :class:`~revolut_x.types.Candle` dictionaries with keys:
@@ -263,20 +268,21 @@ class MarketMixin:
 
         Example::
 
+            >>> from datetime import datetime, timedelta, timezone
             >>> from revolut_x import Interval
             >>> # last 500 hours — comfortably inside the 1000-candle limit
-            >>> now_ms = int(time.time() * 1000)
+            >>> start = datetime.now(timezone.utc) - timedelta(hours=500)
             >>> candles = client.get_candles("BTC-EUR", Interval.HOUR_1,
-            ...                              since=now_ms - 500 * 3_600_000)
+            ...                              since=start)
             >>> for c in candles[:3]:
             ...     print(f"{c['start']}: O={c['open']} H={c['high']}")
         """
         api_symbol = _normalize_symbol(symbol)
         params: dict[str, Any] = {"interval": int(interval)}
         if since is not None:
-            params["since"] = int(since)
+            params["since"] = _to_ms(since)
         if until is not None:
-            params["until"] = int(until)
+            params["until"] = _to_ms(until)
 
         _status, data = self._http.request(
             "GET",
@@ -293,8 +299,8 @@ class MarketMixin:
         symbol: str,
         interval: Interval | int = Interval.HOUR_1,
         *,
-        since: int | None = None,
-        until: int | None = None,
+        since: TimeLike | None = None,
+        until: TimeLike | None = None,
     ) -> Iterator[Candle]:
         """Iterate over all candles in a time range, automatically paginating.
 
@@ -305,8 +311,10 @@ class MarketMixin:
         Args:
             symbol: Trading pair (e.g. ``'BTC-EUR'``).
             interval: Candle interval (see :meth:`get_candles`).
-            since: Start time as Unix timestamp in **milliseconds**.
-            until: End time as Unix timestamp in **milliseconds**.
+            since: Start time — Unix timestamp in **milliseconds**,
+                :class:`~datetime.datetime` / :class:`~datetime.date`, or an
+                ISO-8601 string.
+            until: End time — same accepted formats as ``since``.
 
         Yields:
             :class:`~revolut_x.types.Candle` dictionaries in chronological
@@ -316,7 +324,7 @@ class MarketMixin:
         Example::
 
             >>> for candle in client.iter_candles("BTC-EUR", Interval.MIN_1,
-            ...                                   since=1700000000000):
+            ...                                   since="2024-01-01"):
             ...     process(candle)  # each candle is a dict
         """
         interval_ms = int(interval) * 60 * 1000  # interval in milliseconds
@@ -324,19 +332,22 @@ class MarketMixin:
         # window is inclusive on both ends — so 999 intervals == 1000 candles.
         max_batch_ms = 999 * interval_ms
 
-        if since is None:
+        since_ms = _to_ms(since) if since is not None else None
+        until_ms = _to_ms(until) if until is not None else None
+
+        if since_ms is None:
             # Without a start there is nothing to paginate: a single request
             # already returns the most recent batch.
-            yield from self.get_candles(symbol, interval, until=until)
+            yield from self.get_candles(symbol, interval, until=until_ms)
             return
 
-        current_since = since
+        current_since = since_ms
 
         while True:
             # Walk fixed-size windows forward rather than chaining off the last
             # returned candle, so that gaps in the series (illiquid pairs with
             # no trades in an interval) cannot cut the iteration short.
-            hard_end = until if until is not None else int(time.time() * 1000)
+            hard_end = until_ms if until_ms is not None else int(time.time() * 1000)
             batch_until = min(current_since + max_batch_ms, hard_end)
             # The API rejects a window where 'until' equals 'since', which is
             # what a final single-candle window would produce. Always ask for
@@ -346,8 +357,8 @@ class MarketMixin:
             batch = self.get_candles(
                 symbol, interval, since=current_since, until=batch_until
             )
-            if until is not None:
-                batch = [c for c in batch if int(c.get("start", 0)) <= until]
+            if until_ms is not None:
+                batch = [c for c in batch if int(c.get("start", 0)) <= until_ms]
 
             yield from batch
 
@@ -364,8 +375,8 @@ class MarketMixin:
         self,
         symbol: str,
         *,
-        start_date: int | None = None,
-        end_date: int | None = None,
+        start_date: TimeLike | None = None,
+        end_date: TimeLike | None = None,
         cursor: str | None = None,
         limit: int = MAX_TRADES_PER_PAGE,
     ) -> tuple[list[Trade], str | None]:
@@ -373,8 +384,11 @@ class MarketMixin:
 
         Args:
             symbol: Trading pair (e.g. ``'BTC-EUR'``).
-            start_date: Start time as Unix timestamp in **milliseconds**.
-            end_date: End time as Unix timestamp in **milliseconds**.
+            start_date: Start time — Unix timestamp in **milliseconds**,
+                :class:`~datetime.datetime` / :class:`~datetime.date`, or an
+                ISO-8601 string (see
+                :func:`~revolut_x.helpers.to_timestamp_ms`).
+            end_date: End time — same accepted formats as ``start_date``.
             cursor: Pagination cursor from a previous response's
                 ``metadata.next_cursor`` field.
             limit: Maximum number of trades to return.  The exchange accepts
@@ -401,9 +415,9 @@ class MarketMixin:
             "limit": max(1, min(limit, MAX_TRADES_PER_PAGE)),
         }
         if start_date is not None:
-            params["start_date"] = int(start_date)
+            params["start_date"] = _to_ms(start_date)
         if end_date is not None:
-            params["end_date"] = int(end_date)
+            params["end_date"] = _to_ms(end_date)
         if cursor:
             params["cursor"] = cursor
 
@@ -424,8 +438,8 @@ class MarketMixin:
         self,
         symbol: str,
         *,
-        start_date: int | None = None,
-        end_date: int | None = None,
+        start_date: TimeLike | None = None,
+        end_date: TimeLike | None = None,
         limit: int = MAX_TRADES_PER_PAGE,
     ) -> Iterator[Trade]:
         """Iterate over all public trades in a time range, automatically paginating.
@@ -435,8 +449,10 @@ class MarketMixin:
 
         Args:
             symbol: Trading pair (e.g. ``'BTC-EUR'``).
-            start_date: Start time as Unix timestamp in **milliseconds**.
-            end_date: End time as Unix timestamp in **milliseconds**.
+            start_date: Start time — Unix timestamp in **milliseconds**,
+                :class:`~datetime.datetime` / :class:`~datetime.date`, or an
+                ISO-8601 string.
+            end_date: End time — same accepted formats as ``start_date``.
             limit: Page size per request (1–100, clamped into that range).
 
         Yields:
@@ -444,17 +460,23 @@ class MarketMixin:
 
         Example::
 
-            >>> for trade in client.iter_trades("BTC-EUR",
-            ...                                 start_date=1700000000000):
+            >>> from datetime import datetime, timezone
+            >>> start = datetime(2024, 1, 1, tzinfo=timezone.utc)
+            >>> for trade in client.iter_trades("BTC-EUR", start_date=start):
             ...     print(f"{trade['price']} EUR x {trade['quantity']} BTC")
         """
+        # Convert once so every page sends the same window and a bad value
+        # fails on the first iteration rather than halfway through.
+        start_ms = _to_ms(start_date) if start_date is not None else None
+        end_ms = _to_ms(end_date) if end_date is not None else None
+
         cursor: str | None = None
 
         while True:
             trades, next_cursor = self.get_trades(
                 symbol,
-                start_date=start_date,
-                end_date=end_date,
+                start_date=start_ms,
+                end_date=end_ms,
                 cursor=cursor,
                 limit=limit,
             )

{revolut_x_python-1.0.0 → revolut_x_python-1.0.1}/src/revolut_x/types.py

@@ -7,11 +7,26 @@ This module provides:
 * **TypedDicts** — :class:`Candle`, :class:`Trade`, :class:`Ticker`,
   :class:`Balance`, :class:`PairConfig`, etc. for IDE autocompletion
   on API response data.
+* **Type aliases** — :data:`TimeLike` for time range parameters.
 """
 
 from __future__ import annotations
+from datetime import date, datetime
 from enum import Enum
-from typing import TypedDict
+from typing import TypedDict, Union
+
+
+# ---------------------------------------------------------------------------
+# Type aliases
+# ---------------------------------------------------------------------------
+
+TimeLike = Union[int, float, datetime, date, str]
+"""Anything accepted where the API expects a Unix timestamp in milliseconds.
+
+Numbers are taken as milliseconds as-is; :class:`~datetime.datetime` and
+:class:`~datetime.date` objects and ISO-8601 strings are converted by
+:func:`~revolut_x.helpers.to_timestamp_ms`.
+"""
 
 
 # ---------------------------------------------------------------------------

{revolut_x_python-1.0.0 → revolut_x_python-1.0.1}/src/revolut_x_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: revolut-x-python
-Version: 1.0.0
+Version: 1.0.1
 Summary: Python SDK for the Revolut X Crypto Exchange REST API (v1.0)
 Author: Jan Přikryl
 License-Expression: MIT
@@ -10,20 +10,6 @@ Project-URL: Repository, https://github.com/janprikryl1/revolut-x-python
 Project-URL: Changelog, https://github.com/janprikryl1/revolut-x-python/blob/main/CHANGELOG.md
 Project-URL: Issues, https://github.com/janprikryl1/revolut-x-python/issues
 Keywords: revolut,revolut-x,crypto,exchange,trading,api,sdk,bitcoin
-Classifier: Development Status :: 5 - Production/Stable
-Classifier: Intended Audience :: Developers
-Classifier: Intended Audience :: Financial and Insurance Industry
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3 :: Only
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Classifier: Programming Language :: Python :: 3.14
-Classifier: Topic :: Office/Business :: Financial :: Investment
-Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Classifier: Typing :: Typed
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE

{revolut_x_python-1.0.0 → revolut_x_python-1.0.1}/src/revolut_x_python.egg-info/SOURCES.txt

@@ -1,6 +1,5 @@
 CHANGELOG.md
 LICENSE
-MANIFEST.in
 README.md
 pyproject.toml
 requirements.txt

{revolut_x_python-1.0.0 → revolut_x_python-1.0.1}/tests/test_helpers.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+from datetime import date, datetime, timedelta, timezone
 from decimal import Decimal
 from typing import Any, Dict
 
@@ -16,6 +17,7 @@ from revolut_x.helpers import (
     build_market_order,
     build_order,
     normalize_symbol,
+    to_timestamp_ms,
     validate_against_pair_rules,
 )
 from revolut_x.types import OrderSide, OrderType, TimeInForce
@@ -297,3 +299,73 @@ def test_fee_calculator_taker() -> None:
     # Trade value 1000.00 * 0.0009 = 0.9000 EUR
     assert estimate.fee_amount == Decimal("0.9000")
     assert estimate.fee_currency == "EUR"
+
+
+# ---------------------------------------------------------------------------
+# to_timestamp_ms
+# ---------------------------------------------------------------------------
+
+#: 2024-01-01T00:00:00Z
+EPOCH_2024_MS = 1_704_067_200_000
+
+
+def test_to_timestamp_ms_passes_numbers_through() -> None:
+    """Integers are already milliseconds — seconds must not be auto-detected."""
+    assert to_timestamp_ms(EPOCH_2024_MS) == EPOCH_2024_MS
+    assert to_timestamp_ms(EPOCH_2024_MS / 1000) == EPOCH_2024_MS // 1000
+    assert to_timestamp_ms(1_704_067_200_123.9) == 1_704_067_200_123
+
+
+def test_to_timestamp_ms_converts_aware_datetime() -> None:
+    assert to_timestamp_ms(datetime(2024, 1, 1, tzinfo=timezone.utc)) == EPOCH_2024_MS
+    # A +02:00 wall clock of 02:00 is the same instant as 00:00 UTC.
+    offset = timezone(timedelta(hours=2))
+    assert to_timestamp_ms(datetime(2024, 1, 1, 2, tzinfo=offset)) == EPOCH_2024_MS
+
+
+def test_to_timestamp_ms_treats_naive_datetime_as_utc() -> None:
+    """Naive values must not depend on the machine's local timezone."""
+    assert to_timestamp_ms(datetime(2024, 1, 1)) == EPOCH_2024_MS
+
+
+def test_to_timestamp_ms_converts_date_to_midnight_utc() -> None:
+    assert to_timestamp_ms(date(2024, 1, 1)) == EPOCH_2024_MS
+
+
+def test_to_timestamp_ms_parses_iso_strings() -> None:
+    assert to_timestamp_ms("2024-01-01") == EPOCH_2024_MS
+    assert to_timestamp_ms("2024-01-01T00:00:00") == EPOCH_2024_MS
+    assert to_timestamp_ms("2024-01-01T00:00:00+00:00") == EPOCH_2024_MS
+    # A trailing 'Z' is not accepted by fromisoformat before Python 3.11.
+    assert to_timestamp_ms("2024-01-01T00:00:00Z") == EPOCH_2024_MS
+    assert to_timestamp_ms("  2024-01-01T00:00:00Z  ") == EPOCH_2024_MS
+    assert to_timestamp_ms("2024-01-01T00:00:00.500Z") == EPOCH_2024_MS + 500
+
+
+def test_to_timestamp_ms_rejects_bad_input() -> None:
+    with pytest.raises(ValueError):
+        to_timestamp_ms("last tuesday")
+    with pytest.raises(TypeError):
+        to_timestamp_ms(None)  # type: ignore[arg-type]
+    with pytest.raises(TypeError):
+        to_timestamp_ms(True)  # type: ignore[arg-type]
+
+
+def test_to_timestamp_ms_accepts_long_digit_strings_as_milliseconds() -> None:
+    """Values arriving from JSON or query parameters are strings."""
+    assert to_timestamp_ms("1704067200000") == EPOCH_2024_MS
+    assert to_timestamp_ms("-1704067200000") == -EPOCH_2024_MS
+    # Exactly at the threshold: 1973-03-03, the oldest value still read as ms.
+    assert to_timestamp_ms("100000000000") == 100_000_000_000
+
+
+@pytest.mark.parametrize("value", ["2024", "20240101", "0", "1704067200", "-500"])
+def test_to_timestamp_ms_rejects_short_digit_strings(value: str) -> None:
+    """A separatorless date must not be read as an instant in 1970.
+
+    ``'20240101'`` is valid ISO-8601 basic format, so on Python 3.11+ it used to
+    parse as 2024-01-01 here while the PHP SDK read it as 20240101 ms — a silent
+    cross-SDK discrepancy, and on Python 3.10 it raised. Both SDKs now refuse it.
+    """
+    with pytest.raises(ValueError, match="Ambiguous numeric timestamp string"):
+        to_timestamp_ms(value)

{revolut_x_python-1.0.0 → revolut_x_python-1.0.1}/tests/test_market.py

@@ -1,6 +1,7 @@
 """Unit tests for MarketMixin in revolut_x.market."""
 
 from __future__ import annotations
+from datetime import date, datetime, timedelta, timezone
 from typing import Any
 from unittest.mock import MagicMock
 
@@ -189,3 +190,71 @@ def test_get_ticker_matches_slash_and_dash_symbols() -> None:
     for requested in ("BTC-EUR", "BTC/EUR", "btc-eur"):
         client._http.request.return_value = (200, {"data": [{"symbol": "ETH/EUR"}, btc]})
         assert client.get_ticker(requested) == btc
+
+
+# ---------------------------------------------------------------------------
+# datetime-friendly time ranges
+# ---------------------------------------------------------------------------
+
+def test_get_candles_accepts_datetime_bounds() -> None:
+    """datetime/str bounds must reach the API as millisecond integers."""
+    client = DummyMarketClient()
+    client._http.request.return_value = (200, {"data": []})
+
+    client.get_candles(
+        "BTC-EUR",
+        INTERVAL_MIN,
+        since=datetime(2024, 1, 1, tzinfo=timezone.utc),
+        until="2024-01-02",
+    )
+
+    params = client._http.request.call_args.kwargs["params"]
+    assert params["since"] == 1_704_067_200_000
+    assert params["until"] == 1_704_153_600_000
+    assert all(isinstance(params[k], int) for k in ("since", "until"))
+
+
+def test_get_trades_accepts_datetime_bounds() -> None:
+    client = DummyMarketClient()
+    client._http.request.return_value = (200, {"data": [], "metadata": {}})
+
+    client.get_trades(
+        "BTC-EUR",
+        start_date=date(2024, 1, 1),
+        end_date=datetime(2024, 1, 2, tzinfo=timezone.utc),
+    )
+
+    params = client._http.request.call_args.kwargs["params"]
+    assert params["start_date"] == 1_704_067_200_000
+    assert params["end_date"] == 1_704_153_600_000
+
+
+def test_iter_candles_paginates_from_a_datetime() -> None:
+    """Pagination arithmetic must run on the converted value, not the object."""
+    base = 1_704_067_200_000  # 2024-01-01T00:00:00Z
+    client = FakeCandleClient(base, 3000)
+    since = datetime(2024, 1, 1, tzinfo=timezone.utc)
+    until = since + timedelta(minutes=1500)
+
+    got = _starts(list(client.iter_candles("BTC-EUR", INTERVAL_MIN, since=since, until=until)))
+
+    assert len(got) == 1501
+    assert got[0] == base
+    assert got[-1] == base + 1500 * INTERVAL_MS
+    assert len(client.requests) > 1, "a 1501-candle range must span several pages"
+
+
+def test_iter_trades_converts_bounds_once_for_every_page() -> None:
+    client = DummyMarketClient()
+    pages = [
+        (200, {"data": [{"timestamp": 1}], "metadata": {"next_cursor": "c2"}}),
+        (200, {"data": [{"timestamp": 2}], "metadata": {}}),
+    ]
+    client._http.request.side_effect = pages
+
+    got = list(client.iter_trades("BTC-EUR", start_date="2024-01-01T00:00:00Z"))
+
+    assert len(got) == 2
+    sent = [c.kwargs["params"] for c in client._http.request.call_args_list]
+    assert [p["start_date"] for p in sent] == [1_704_067_200_000] * 2
+    assert sent[1]["cursor"] == "c2"

revolut_x_python-1.0.0/MANIFEST.in

@@ -1,18 +0,0 @@
-include LICENSE
-include README.md
-include CHANGELOG.md
-include requirements.txt
-
-# The AI agent skill is an advertised feature of the package, so it travels
-# with the sdist instead of being GitHub-only.
-recursive-include .agents *.md
-
-recursive-include tests *.py
-recursive-include examples *.py *.md
-
-global-exclude *.py[cod]
-global-exclude .DS_Store
-prune docs
-prune site
-prune dist
-prune venv