polysimulator 0.4.0__tar.gz → 0.4.1__tar.gz

{polysimulator-0.4.0 → polysimulator-0.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: polysimulator
-Version: 0.4.0
+Version: 0.4.1
 Summary: Python SDK for the PolySimulator paper-trading API, with py-clob-client v1 drop-in parity (not py-clob-client-v2) and a polysim_polymarket paper-mode mirror of Polymarket's unified py-sdk (polymarket-client 0.1.0b8).
 Project-URL: Homepage, https://polysimulator.com
 Project-URL: Documentation, https://docs.polysimulator.com
@@ -236,6 +236,39 @@ network, tolerant of missing fields): `seconds_to_expiry`, `is_window_open`,
 `INTERVALS` vocab tuples. For a **streaming** tap on the underlying, see
 [SSE: live underlying spot](#sse-live-underlying-spot) below.
 
+### New-market warm-up: retry order placement on a 404
+
+A **brand-new** market — especially the 5m Up/Down windows that roll every few
+minutes — has a short window after creation before it enters the
+order-validation catalog. An order placed in that window transiently fails with
+a `404` (`code="MARKET_NOT_FOUND"`). The window is short — on the order of ~30s,
+the Up/Down roll cadence — but it is a cadence, **not** a guarantee.
+
+The SDK does **not** auto-retry 404s (by design — a 404 is normally permanent),
+so a bot trading freshly-rolled markets should catch and retry that one signal
+with backoff. The native client ships a small opt-in helper that retries **only**
+the warm-up 404 and re-raises everything else (and the 404 itself once the budget
+is spent):
+
+```python
+from polysim_sdk import PolySimClient, retry_on_market_warmup
+
+with PolySimClient() as client:
+    fill = retry_on_market_warmup(
+        lambda: client.place_order(
+            market_id=cid, side="BUY", outcome="Up", amount="10", price="0.99",
+        ),
+        attempts=6, base_delay=2.0,   # ~2,4,8,16,30s capped backoff between tries
+    )
+```
+
+It wraps any zero-argument callable, so the same helper works with a
+`polysim_clob_client` drop-in call (e.g.
+`retry_on_market_warmup(lambda: clob.create_and_post_order(args))`); the drop-in
+surfaces the same condition as a `PolyApiException` with `status_code == 404`.
+See [Errors](#errors) for the standalone retry-on-404 pattern if you'd rather
+roll your own.
+
 ---
 
 ## Polymarket compatibility
@@ -802,11 +835,14 @@ Every method maps by one of three strategies:
 `py-clob-client` addresses a single outcome token by `token_id`; PolySimulator
 addresses a **market plus an outcome**. The seam: a bare `token_id` is treated as
 the market id with outcome `YES`. Append `":NO"` or `":YES"` to target the other
-side explicitly.
+side explicitly. **Up/Down markets** carry `Up`/`Down` outcomes, so the same
+colon form also accepts `":UP"` / `":DOWN"` (case-insensitive); the backend
+matches the order outcome case-insensitively, so either case is accepted.
 
 ```python
 client.create_order(OrderArgs(token_id="0xMARKET",     ...))  # → market 0xMARKET, YES
 client.create_order(OrderArgs(token_id="0xMARKET:NO",  ...))  # → market 0xMARKET, NO
+client.create_order(OrderArgs(token_id="0xUPDOWN:UP",  ...))  # → Up/Down market, UP
 ```
 
 **Reads are true-token-parity; writes use the market+outcome model.** This is an
@@ -829,8 +865,9 @@ intentional asymmetry:
   order loudly — it never silently places a different one.
 
 If you only ever pass real outcome-token ids (the `py-clob-client` norm), reads
-"just work" with full parity. The `:YES`/`:NO` suffix exists for callers who
-prefer to address PolySimulator markets by condition id directly.
+"just work" with full parity. The `:YES`/`:NO` suffix (and `:UP`/`:DOWN` for
+Up/Down markets) exists for callers who prefer to address PolySimulator markets
+by condition id directly.
 
 ### Orders are never signed
 
@@ -947,6 +984,66 @@ The client paces itself (a 50 ms floor between requests) and backs off on
 `429`/`425`/`5xx` using `Retry-After`. Opt out with `floor_interval=0.0` and
 `max_retries=0` to handle pacing yourself.
 
+### New-market warm-up `404` (retry-on-404)
+
+The SDK auto-retries `429`/`5xx` but **never** a `404` — a 404 is normally
+permanent. The one benign exception is a **freshly-created market** (most often
+a 5m Up/Down window): for a short window after creation — on the order of ~30s,
+the Up/Down roll cadence, though not a guarantee — it is not yet in the
+order-validation catalog and order placement transiently fails with
+`ApiError(status_code=404, code="MARKET_NOT_FOUND")`. Retry **only** that signal,
+with backoff; re-raise any other error (including a 404 with a different `code`,
+which is a real "not found").
+
+Use the shipped helper (recommended) …
+
+```python
+from polysim_sdk import PolySimClient, retry_on_market_warmup
+
+with PolySimClient() as client:
+    fill = retry_on_market_warmup(
+        lambda: client.place_order(
+            market_id=cid, side="BUY", outcome="Up", amount="10", price="0.99",
+        ),
+        attempts=6, base_delay=2.0,
+    )
+```
+
+… or roll your own on the native `ApiError`:
+
+```python
+import time
+from polysim_sdk import ApiError
+
+for i in range(6):
+    try:
+        fill = client.place_order(market_id=cid, side="BUY", outcome="Up",
+                                  amount="10", price="0.99")
+        break
+    except ApiError as exc:
+        if exc.status_code == 404 and exc.code == "MARKET_NOT_FOUND" and i < 5:
+            time.sleep(min(2.0 * 2**i, 30.0))   # capped backoff, then retry
+            continue
+        raise   # any other error — and the final 404 — propagates
+```
+
+With the **`polysim_clob_client` drop-in**, the same condition surfaces as a
+`PolyApiException` with `status_code == 404`; catch it and retry the same way (or
+pass your drop-in call to `retry_on_market_warmup(lambda: clob.create_and_post_order(...))`,
+which works with any callable):
+
+```python
+from polysim_clob_client.exceptions import PolyApiException
+
+try:
+    resp = clob.create_and_post_order(order_args)
+except PolyApiException as exc:
+    if exc.status_code == 404 and getattr(exc, "code", None) == "MARKET_NOT_FOUND":
+        ...  # warm-up — retry with backoff
+    else:
+        raise   # any other error — including a 404 with a different code — propagates
+```
+
 ### Troubleshooting: `error code: 1010` / blocked User-Agent
 
 If a raw HTTP call returns **HTTP 403** with the body `error code: 1010`, the

{polysimulator-0.4.0 → polysimulator-0.4.1}/README.md

@@ -201,6 +201,39 @@ network, tolerant of missing fields): `seconds_to_expiry`, `is_window_open`,
 `INTERVALS` vocab tuples. For a **streaming** tap on the underlying, see
 [SSE: live underlying spot](#sse-live-underlying-spot) below.
 
+### New-market warm-up: retry order placement on a 404
+
+A **brand-new** market — especially the 5m Up/Down windows that roll every few
+minutes — has a short window after creation before it enters the
+order-validation catalog. An order placed in that window transiently fails with
+a `404` (`code="MARKET_NOT_FOUND"`). The window is short — on the order of ~30s,
+the Up/Down roll cadence — but it is a cadence, **not** a guarantee.
+
+The SDK does **not** auto-retry 404s (by design — a 404 is normally permanent),
+so a bot trading freshly-rolled markets should catch and retry that one signal
+with backoff. The native client ships a small opt-in helper that retries **only**
+the warm-up 404 and re-raises everything else (and the 404 itself once the budget
+is spent):
+
+```python
+from polysim_sdk import PolySimClient, retry_on_market_warmup
+
+with PolySimClient() as client:
+    fill = retry_on_market_warmup(
+        lambda: client.place_order(
+            market_id=cid, side="BUY", outcome="Up", amount="10", price="0.99",
+        ),
+        attempts=6, base_delay=2.0,   # ~2,4,8,16,30s capped backoff between tries
+    )
+```
+
+It wraps any zero-argument callable, so the same helper works with a
+`polysim_clob_client` drop-in call (e.g.
+`retry_on_market_warmup(lambda: clob.create_and_post_order(args))`); the drop-in
+surfaces the same condition as a `PolyApiException` with `status_code == 404`.
+See [Errors](#errors) for the standalone retry-on-404 pattern if you'd rather
+roll your own.
+
 ---
 
 ## Polymarket compatibility
@@ -767,11 +800,14 @@ Every method maps by one of three strategies:
 `py-clob-client` addresses a single outcome token by `token_id`; PolySimulator
 addresses a **market plus an outcome**. The seam: a bare `token_id` is treated as
 the market id with outcome `YES`. Append `":NO"` or `":YES"` to target the other
-side explicitly.
+side explicitly. **Up/Down markets** carry `Up`/`Down` outcomes, so the same
+colon form also accepts `":UP"` / `":DOWN"` (case-insensitive); the backend
+matches the order outcome case-insensitively, so either case is accepted.
 
 ```python
 client.create_order(OrderArgs(token_id="0xMARKET",     ...))  # → market 0xMARKET, YES
 client.create_order(OrderArgs(token_id="0xMARKET:NO",  ...))  # → market 0xMARKET, NO
+client.create_order(OrderArgs(token_id="0xUPDOWN:UP",  ...))  # → Up/Down market, UP
 ```
 
 **Reads are true-token-parity; writes use the market+outcome model.** This is an
@@ -794,8 +830,9 @@ intentional asymmetry:
   order loudly — it never silently places a different one.
 
 If you only ever pass real outcome-token ids (the `py-clob-client` norm), reads
-"just work" with full parity. The `:YES`/`:NO` suffix exists for callers who
-prefer to address PolySimulator markets by condition id directly.
+"just work" with full parity. The `:YES`/`:NO` suffix (and `:UP`/`:DOWN` for
+Up/Down markets) exists for callers who prefer to address PolySimulator markets
+by condition id directly.
 
 ### Orders are never signed
 
@@ -912,6 +949,66 @@ The client paces itself (a 50 ms floor between requests) and backs off on
 `429`/`425`/`5xx` using `Retry-After`. Opt out with `floor_interval=0.0` and
 `max_retries=0` to handle pacing yourself.
 
+### New-market warm-up `404` (retry-on-404)
+
+The SDK auto-retries `429`/`5xx` but **never** a `404` — a 404 is normally
+permanent. The one benign exception is a **freshly-created market** (most often
+a 5m Up/Down window): for a short window after creation — on the order of ~30s,
+the Up/Down roll cadence, though not a guarantee — it is not yet in the
+order-validation catalog and order placement transiently fails with
+`ApiError(status_code=404, code="MARKET_NOT_FOUND")`. Retry **only** that signal,
+with backoff; re-raise any other error (including a 404 with a different `code`,
+which is a real "not found").
+
+Use the shipped helper (recommended) …
+
+```python
+from polysim_sdk import PolySimClient, retry_on_market_warmup
+
+with PolySimClient() as client:
+    fill = retry_on_market_warmup(
+        lambda: client.place_order(
+            market_id=cid, side="BUY", outcome="Up", amount="10", price="0.99",
+        ),
+        attempts=6, base_delay=2.0,
+    )
+```
+
+… or roll your own on the native `ApiError`:
+
+```python
+import time
+from polysim_sdk import ApiError
+
+for i in range(6):
+    try:
+        fill = client.place_order(market_id=cid, side="BUY", outcome="Up",
+                                  amount="10", price="0.99")
+        break
+    except ApiError as exc:
+        if exc.status_code == 404 and exc.code == "MARKET_NOT_FOUND" and i < 5:
+            time.sleep(min(2.0 * 2**i, 30.0))   # capped backoff, then retry
+            continue
+        raise   # any other error — and the final 404 — propagates
+```
+
+With the **`polysim_clob_client` drop-in**, the same condition surfaces as a
+`PolyApiException` with `status_code == 404`; catch it and retry the same way (or
+pass your drop-in call to `retry_on_market_warmup(lambda: clob.create_and_post_order(...))`,
+which works with any callable):
+
+```python
+from polysim_clob_client.exceptions import PolyApiException
+
+try:
+    resp = clob.create_and_post_order(order_args)
+except PolyApiException as exc:
+    if exc.status_code == 404 and getattr(exc, "code", None) == "MARKET_NOT_FOUND":
+        ...  # warm-up — retry with backoff
+    else:
+        raise   # any other error — including a 404 with a different code — propagates
+```
+
 ### Troubleshooting: `error code: 1010` / blocked User-Agent
 
 If a raw HTTP call returns **HTTP 403** with the body `error code: 1010`, the

{polysimulator-0.4.0 → polysimulator-0.4.1}/polysim_clob_client/client.py

@@ -149,7 +149,9 @@ class ClobClient:
 
         Thin wrapper over :func:`polysim_sdk._shared._split_token` (the shared
         parity seam): a bare ``token_id`` is the market id with outcome
-        ``YES``; ``":NO"`` / ``":YES"`` targets the other outcome explicitly.
+        ``YES``; ``":NO"`` / ``":YES"`` targets the other outcome explicitly,
+        and ``":UP"`` / ``":DOWN"`` targets an UpDown market's outcomes (the
+        backend matches the outcome case-insensitively).
         """
         return _split_token_shared(token_id)
 
@@ -161,9 +163,10 @@ class ClobClient:
         condition ids. For those it reverse-resolves via
         ``GET /v1/markets-by-token/{token_id}`` (result cached per token), so an
         order placed with a genuine Polymarket token id lands on the right
-        market + outcome. The ``condition_id:YES``/``:NO`` colon form and short
-        / non-numeric ids resolve **locally with no network call** via
-        :meth:`_split_token` (preserving the parity seam).
+        market + outcome. The ``condition_id:YES``/``:NO`` colon form (plus
+        ``:UP``/``:DOWN`` for UpDown markets) and short / non-numeric ids
+        resolve **locally with no network call** via :meth:`_split_token`
+        (preserving the parity seam).
         """
         tid = str(token_id)
         # Colon form is our own convenience extension — always resolve locally.
@@ -191,15 +194,16 @@ class ClobClient:
         ``GET /v1/book?token_id=...`` endpoint — this is what gives genuine
         parity with Polymarket's CLOB book reads, where py-clob-client always
         passes a real outcome-token id. The ``condition_id:YES`` / ``:NO``
-        **colon form** is our own convenience extension; it keeps condition-id
-        routing and threads the outcome through as a query param so ``:NO``
-        actually reads the NO book.
+        **colon form** (plus ``:UP`` / ``:DOWN`` for UpDown markets) is our own
+        convenience extension; it keeps condition-id routing and threads the
+        outcome through as a query param so e.g. ``:NO`` reads the NO book and
+        ``:UP`` reads the UP book.
         """
         tid = str(token_id)
         if ":" in tid:
             market_id, _, outcome = tid.rpartition(":")
             outcome = outcome.upper()
-            if outcome in ("YES", "NO") and market_id:
+            if outcome in ("YES", "NO", "UP", "DOWN") and market_id:
                 return self._client.get_book(market_id, outcome=outcome)
         return self._client.get_book_by_token(tid)
 

{polysimulator-0.4.0 → polysimulator-0.4.1}/polysim_polymarket/clients/async_public.py

@@ -165,14 +165,16 @@ class AsyncPublicClient:
 
         Same routing as the sync client's ``_book_for_token``: a bare token id
         routes to the token-native ``GET /v1/book?token_id=`` endpoint; the
-        ``condition_id:YES`` / ``:NO`` colon form keeps condition-id routing and
-        threads the outcome through as a query param.
+        ``condition_id:YES`` / ``:NO`` colon form (plus ``:UP`` / ``:DOWN`` for
+        UpDown markets) keeps condition-id routing and threads the outcome
+        through as a query param so ``:NO`` reads the NO book and ``:UP`` reads
+        the UP book.
         """
         tid = str(token_id)
         if ":" in tid:
             market_id, _, outcome = tid.rpartition(":")
             outcome = outcome.upper()
-            if outcome in ("YES", "NO") and market_id:
+            if outcome in ("YES", "NO", "UP", "DOWN") and market_id:
                 return await self._client.get_book(market_id, outcome=outcome)
         return await self._client.get_book_by_token(tid)
 

{polysimulator-0.4.0 → polysimulator-0.4.1}/polysim_polymarket/clients/public.py

@@ -113,15 +113,16 @@ class PublicClient:
 
         A **bare** token id routes to the token-native ``GET /v1/book?token_id=``
         endpoint — the parity path, since py-sdk always passes a real
-        outcome-token id. The ``condition_id:YES`` / ``:NO`` **colon form** is
-        our convenience extension: it keeps condition-id routing and threads the
-        outcome through as a query param so ``:NO`` reads the NO book.
+        outcome-token id. The ``condition_id:YES`` / ``:NO`` **colon form** (plus
+        ``:UP`` / ``:DOWN`` for UpDown markets) is our convenience extension: it
+        keeps condition-id routing and threads the outcome through as a query
+        param so ``:NO`` reads the NO book and ``:UP`` reads the UP book.
         """
         tid = str(token_id)
         if ":" in tid:
             market_id, _, outcome = tid.rpartition(":")
             outcome = outcome.upper()
-            if outcome in ("YES", "NO") and market_id:
+            if outcome in ("YES", "NO", "UP", "DOWN") and market_id:
                 return self._client.get_book(market_id, outcome=outcome)
         return self._client.get_book_by_token(tid)
 

{polysimulator-0.4.0 → polysimulator-0.4.1}/polysim_sdk/__init__.py

@@ -36,6 +36,7 @@ from polysim_sdk.exceptions import (
     RateLimitError,
     ValidationError,
 )
+from polysim_sdk.retry import retry_on_market_warmup
 
 __all__ = [
     "PolySimClient",
@@ -47,6 +48,7 @@ __all__ = [
     "PolySimError",
     "RateLimitError",
     "ValidationError",
+    "retry_on_market_warmup",
 ]
 
 __version__ = "0.2.2"

{polysimulator-0.4.0 → polysimulator-0.4.1}/polysim_sdk/_http.py

@@ -159,6 +159,16 @@ def raise_for_status(resp: httpx.Response) -> None:
     code = payload.get("code") or payload.get("error")
     if isinstance(code, dict):
         code = code.get("code") or code.get("error")
+    # The authoritative, docs-promised machine code rides in the
+    # ``X-Polysim-Code`` response header (always exposed). The body's ``error``
+    # field is the PM single-field shape — a human sentence, not a stable code
+    # — so the header wins when present. We only fall back to the body-derived
+    # value (the back-compat ``{error: <CODE>, message: <text>}`` inline shape)
+    # when the header is absent. Header lookup is case-insensitive (httpx
+    # ``Headers``); strip stray whitespace and ignore an empty value.
+    header_code = (resp.headers.get("X-Polysim-Code") or "").strip()
+    if header_code:
+        code = header_code
     request_id = resp.headers.get("x-request-id")
 
     if resp.status_code in (400, 422):

{polysimulator-0.4.0 → polysimulator-0.4.1}/polysim_sdk/_shared.py

@@ -103,15 +103,22 @@ def _split_token(token_id: str) -> tuple[str, str]:
     """Map a py-clob ``token_id`` onto PolySim ``(market_id, outcome)``.
 
     py-clob-client addresses a single outcome token; PolySim addresses a
-    market plus an outcome (YES/NO). The parity seam: a bare ``token_id``
-    is treated as the market id with outcome ``YES``; append ``":NO"`` /
-    ``":YES"`` to target the other outcome explicitly.
+    market plus an outcome. The parity seam: a bare ``token_id`` is treated
+    as the market id with outcome ``YES``; append ``":NO"`` / ``":YES"`` to
+    target the other outcome explicitly. UpDown markets carry ``Up`` / ``Down``
+    outcomes, so the same colon form also accepts ``":UP"`` / ``":DOWN"``
+    (case-insensitive, returned uppercase). The backend matches the outcome
+    case-insensitively, so ``"UP"`` / ``"DOWN"`` are accepted as written.
+
+    The colon form is the drop-in's own convenience extension (it is **not**
+    py-clob-client parity, where a real outcome-token id is always passed), so
+    accepting the extra UpDown outcomes leaves the v1 parity contract intact.
     """
     tid = str(token_id)
     if ":" in tid:
         market_id, _, outcome = tid.rpartition(":")
         outcome = outcome.upper()
-        if outcome in ("YES", "NO") and market_id:
+        if outcome in ("YES", "NO", "UP", "DOWN") and market_id:
             return market_id, outcome
     return tid, "YES"
 

polysimulator-0.4.1/polysim_sdk/retry.py

@@ -0,0 +1,89 @@
+"""Opt-in retry helpers for transient, well-understood failure windows.
+
+The SDK deliberately does **not** auto-retry ``404`` responses — a 404 is
+normally permanent (unknown market / order id), and silently retrying it would
+hide real bugs behind a long backoff. There is, however, one benign 404: a
+brand-new market (especially the BTC/ETH UpDown 5m windows that roll every few
+minutes) has a short warm-up window after creation before it enters the
+order-validation catalog, during which order placement transiently 404s with
+``code="MARKET_NOT_FOUND"``.
+
+:func:`retry_on_market_warmup` is a small, explicit opt-in wrapper for exactly
+that case: it retries a callable **only** on a ``MARKET_NOT_FOUND`` 404 with
+capped exponential backoff, re-raising any other error immediately and the 404
+itself once the attempt budget is spent. It wraps any zero-argument callable, so
+it works with both the native ``polysim_sdk`` client and the ``polysim_clob_client``
+drop-in.
+"""
+
+from __future__ import annotations
+
+import time
+from collections.abc import Callable
+from typing import TypeVar
+
+from polysim_sdk.exceptions import ApiError
+
+T = TypeVar("T")
+
+# The server's ``error.code`` for an order placed against a market that is not
+# (yet) in the validation catalog. The drop-in's PolyApiException carries the
+# same status code; callers using it can wrap on status_code == 404 themselves.
+MARKET_WARMUP_CODE = "MARKET_NOT_FOUND"
+
+
+def _is_market_warmup_404(exc: BaseException) -> bool:
+    """True iff ``exc`` is the transient "market not in catalog yet" 404."""
+    return (
+        isinstance(exc, ApiError)
+        and exc.status_code == 404
+        and exc.code == MARKET_WARMUP_CODE
+    )
+
+
+def retry_on_market_warmup(
+    fn: Callable[[], T],
+    *,
+    attempts: int = 6,
+    base_delay: float = 2.0,
+    max_delay: float = 30.0,
+    sleep: Callable[[float], None] = time.sleep,
+) -> T:
+    """Call ``fn`` and retry it through a market's warm-up 404.
+
+    Retries **only** when ``fn`` raises an :class:`~polysim_sdk.exceptions.ApiError`
+    with ``status_code == 404`` and ``code == "MARKET_NOT_FOUND"`` — the transient
+    signal that a freshly-created market has not yet entered the order-validation
+    catalog (typically clears within ~30s, the UpDown roll cadence; this is a
+    cadence, not a guarantee). Any other exception — including a 404 with a
+    different ``code`` — is re-raised immediately, and the warm-up 404 itself is
+    re-raised once ``attempts`` is exhausted.
+
+    Backoff is exponential (``base_delay * 2**i``) capped at ``max_delay``; the
+    sleep happens **between** attempts only (never after the final one). ``fn``
+    is a zero-argument callable, so wrap your call site in a ``lambda`` /
+    ``functools.partial`` — e.g.
+    ``retry_on_market_warmup(lambda: client.place_order(...))``. It works with
+    both the native client and the ``polysim_clob_client`` drop-in.
+
+    :param attempts: total number of calls to ``fn`` (must be >= 1).
+    :param base_delay: first backoff, in seconds.
+    :param max_delay: ceiling for the per-attempt backoff, in seconds.
+    :param sleep: injection seam for the backoff sleep (defaults to
+        :func:`time.sleep`); override in tests to avoid real waits.
+    """
+    if attempts < 1:
+        raise ValueError("attempts must be >= 1")
+    for i in range(attempts):
+        try:
+            return fn()
+        except ApiError as exc:
+            if not _is_market_warmup_404(exc) or i == attempts - 1:
+                raise
+            sleep(min(base_delay * (2**i), max_delay))
+    # Unreachable: the final iteration either returns or re-raises above. Present
+    # only so static checkers see every path returns a value or raises.
+    raise AssertionError("unreachable")  # pragma: no cover
+
+
+__all__ = ["retry_on_market_warmup", "MARKET_WARMUP_CODE"]

{polysimulator-0.4.0 → polysimulator-0.4.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "polysimulator"
-version = "0.4.0"
+version = "0.4.1"
 description = "Python SDK for the PolySimulator paper-trading API, with py-clob-client v1 drop-in parity (not py-clob-client-v2) and a polysim_polymarket paper-mode mirror of Polymarket's unified py-sdk (polymarket-client 0.1.0b8)."
 readme = "README.md"
 requires-python = ">=3.10"