parlayx 0.0.0__tar.gz

parlayx-0.0.0/.gitignore

@@ -0,0 +1,7 @@
+.venv/
+__pycache__/
+*.py[cod]
+.pytest_cache/
+.ruff_cache/
+.mypy_cache/
+dist/

parlayx-0.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ParlayX, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

parlayx-0.0.0/PKG-INFO

@@ -0,0 +1,156 @@
+Metadata-Version: 2.5
+Name: parlayx
+Version: 0.0.0
+Summary: Official Python client for the ParlayX public API.
+Project-URL: Homepage, https://docs.parlayx.com
+Project-URL: Documentation, https://docs.parlayx.com
+License-Expression: MIT
+License-File: LICENSE
+Requires-Python: >=3.11
+Requires-Dist: cryptography<51,>=45
+Requires-Dist: httpx<1,>=0.28
+Requires-Dist: pydantic<3,>=2.9
+Provides-Extra: stream
+Requires-Dist: websockets<18,>=15; extra == 'stream'
+Description-Content-Type: text/markdown
+
+# parlayx
+
+Official Python client for the [ParlayX](https://parlayx.com) public API, a single trading interface over aggregated prediction markets.
+
+## Documentation
+
+Full guides, authentication, and API reference live at **[docs.parlayx.com](https://docs.parlayx.com)**.
+
+## Install
+
+```sh
+pip install parlayx
+```
+
+Requires Python 3.11 or newer. Requests are signed with your Ed25519 key, so the client runs server-side: the private key stays in your own process and only the key id, a timestamp, and the signature go on the wire.
+
+## Usage
+
+```python
+from parlayx import ParlayX
+
+with ParlayX.from_env() as client:
+    who = client.whoami()
+    competitions = client.list_competitions(sport="spt_baseball")
+    balance = client.kalshi.get_balance()
+```
+
+`from_env()` reads `PARLAYX_KEY_ID` and `PARLAYX_PRIVATE_KEY_HEX`; pass them to `ParlayX(...)` directly if you load them another way.
+
+Orders, positions and balances are venue-scoped, because the venues address markets differently:
+
+```python
+from parlayx import KalshiOrderRequest
+
+order = client.kalshi.submit_order(
+    KalshiOrderRequest(
+        ticker="KXMLBGAME-26SEP01-NYY",
+        side="YES",
+        action="BUY",
+        count=10,
+        price_cents=45,
+    )
+)
+print(order.order_id, order.status)
+```
+
+Fields accept either spelling: `price_cents` or `priceCents`. The wire always carries the API's own camelCase.
+
+Each of `client.polymarket` and `client.kalshi` carries the same seven methods: `submit_order`, `list_orders`, `get_order`, `cancel_order`, `get_order_fills`, `list_positions` and `get_balance`.
+
+### Idempotency
+
+`submit_order` attaches a fresh idempotency key per call, so retrying a call that failed submits a **second order**. Pass your own key to make a specific retry safe:
+
+```python
+client.kalshi.submit_order(order, idempotency_key="my-retry-key")
+```
+
+### Errors
+
+Every non-2xx response raises `RequestError`, carrying a stable `code`, the HTTP `status`, a `message` and the parsed `body`:
+
+```python
+from parlayx import ApiErrorCode, RequestError
+
+try:
+    client.polymarket.get_balance()
+except RequestError as error:
+    if error.code == ApiErrorCode.insufficient_balance:
+        ...
+```
+
+### Pagination
+
+Order listings are cursored. The paginators follow `nextPageToken` to exhaustion:
+
+```python
+from parlayx import paginate_kalshi_orders
+
+for order in paginate_kalshi_orders(client, status="OPEN"):
+    print(order.order_id, order.status)
+```
+
+Positions and fills are not cursored and return their full result in one call.
+
+### Async
+
+`AsyncParlayX` is the same surface with `await`, and `apaginate_kalshi_orders` and `apaginate_polymarket_orders` are the async paginators:
+
+```python
+from parlayx import AsyncParlayX
+
+async with AsyncParlayX.from_env() as client:
+    who = await client.whoami()
+```
+
+### Market data stream
+
+The stream is a separate import and needs the extra:
+
+```sh
+pip install "parlayx[stream]"
+```
+
+It authenticates with the same signing key, re-signing the handshake on every connect, and replays your subscriptions across reconnects so you subscribe once:
+
+```python
+from parlayx.stream import StreamClient
+
+async with StreamClient.from_env() as stream:
+    await stream.subscribe([{"venue": "polymarket", "tokenId": "97840505..."}])
+    async for frame in stream:
+        if frame.type == "snapshot":
+            print(frame.seq, frame.bids[:3], frame.asks[:3])
+        elif frame.type == "delta":
+            for change in frame.changes:
+                ...  # size 0 removes the level, anything else sets it
+```
+
+`channels` defaults to `["book"]`; pass `["book", "trade"]` for the trade tape as well.
+
+Connection lifecycle is reported through callbacks rather than frames, because it describes the connection rather than the market:
+
+```python
+StreamClient.from_env(
+    on_reconnecting=lambda event: log.info("reconnecting, attempt %s", event.attempt),
+    on_terminated=lambda event: log.warning("stream stopped: %s", event.reason),
+    on_unparseable=lambda raw: log.warning("dropped an unrecognised frame: %s", raw),
+)
+```
+
+A terminated stream does not reconnect; build a new client to resume.
+
+### One inconsistency worth knowing
+
+Discovery listings report `venue` in uppercase (`KALSHI`, `POLYMARKET`), while the order and streaming surfaces take it lowercase. The client passes the value through unchanged in both directions rather than quietly rewriting it.
+
+## License
+
+MIT. See [LICENSE](./LICENSE).

parlayx-0.0.0/README.md

@@ -0,0 +1,140 @@
+# parlayx
+
+Official Python client for the [ParlayX](https://parlayx.com) public API, a single trading interface over aggregated prediction markets.
+
+## Documentation
+
+Full guides, authentication, and API reference live at **[docs.parlayx.com](https://docs.parlayx.com)**.
+
+## Install
+
+```sh
+pip install parlayx
+```
+
+Requires Python 3.11 or newer. Requests are signed with your Ed25519 key, so the client runs server-side: the private key stays in your own process and only the key id, a timestamp, and the signature go on the wire.
+
+## Usage
+
+```python
+from parlayx import ParlayX
+
+with ParlayX.from_env() as client:
+    who = client.whoami()
+    competitions = client.list_competitions(sport="spt_baseball")
+    balance = client.kalshi.get_balance()
+```
+
+`from_env()` reads `PARLAYX_KEY_ID` and `PARLAYX_PRIVATE_KEY_HEX`; pass them to `ParlayX(...)` directly if you load them another way.
+
+Orders, positions and balances are venue-scoped, because the venues address markets differently:
+
+```python
+from parlayx import KalshiOrderRequest
+
+order = client.kalshi.submit_order(
+    KalshiOrderRequest(
+        ticker="KXMLBGAME-26SEP01-NYY",
+        side="YES",
+        action="BUY",
+        count=10,
+        price_cents=45,
+    )
+)
+print(order.order_id, order.status)
+```
+
+Fields accept either spelling: `price_cents` or `priceCents`. The wire always carries the API's own camelCase.
+
+Each of `client.polymarket` and `client.kalshi` carries the same seven methods: `submit_order`, `list_orders`, `get_order`, `cancel_order`, `get_order_fills`, `list_positions` and `get_balance`.
+
+### Idempotency
+
+`submit_order` attaches a fresh idempotency key per call, so retrying a call that failed submits a **second order**. Pass your own key to make a specific retry safe:
+
+```python
+client.kalshi.submit_order(order, idempotency_key="my-retry-key")
+```
+
+### Errors
+
+Every non-2xx response raises `RequestError`, carrying a stable `code`, the HTTP `status`, a `message` and the parsed `body`:
+
+```python
+from parlayx import ApiErrorCode, RequestError
+
+try:
+    client.polymarket.get_balance()
+except RequestError as error:
+    if error.code == ApiErrorCode.insufficient_balance:
+        ...
+```
+
+### Pagination
+
+Order listings are cursored. The paginators follow `nextPageToken` to exhaustion:
+
+```python
+from parlayx import paginate_kalshi_orders
+
+for order in paginate_kalshi_orders(client, status="OPEN"):
+    print(order.order_id, order.status)
+```
+
+Positions and fills are not cursored and return their full result in one call.
+
+### Async
+
+`AsyncParlayX` is the same surface with `await`, and `apaginate_kalshi_orders` and `apaginate_polymarket_orders` are the async paginators:
+
+```python
+from parlayx import AsyncParlayX
+
+async with AsyncParlayX.from_env() as client:
+    who = await client.whoami()
+```
+
+### Market data stream
+
+The stream is a separate import and needs the extra:
+
+```sh
+pip install "parlayx[stream]"
+```
+
+It authenticates with the same signing key, re-signing the handshake on every connect, and replays your subscriptions across reconnects so you subscribe once:
+
+```python
+from parlayx.stream import StreamClient
+
+async with StreamClient.from_env() as stream:
+    await stream.subscribe([{"venue": "polymarket", "tokenId": "97840505..."}])
+    async for frame in stream:
+        if frame.type == "snapshot":
+            print(frame.seq, frame.bids[:3], frame.asks[:3])
+        elif frame.type == "delta":
+            for change in frame.changes:
+                ...  # size 0 removes the level, anything else sets it
+```
+
+`channels` defaults to `["book"]`; pass `["book", "trade"]` for the trade tape as well.
+
+Connection lifecycle is reported through callbacks rather than frames, because it describes the connection rather than the market:
+
+```python
+StreamClient.from_env(
+    on_reconnecting=lambda event: log.info("reconnecting, attempt %s", event.attempt),
+    on_terminated=lambda event: log.warning("stream stopped: %s", event.reason),
+    on_unparseable=lambda raw: log.warning("dropped an unrecognised frame: %s", raw),
+)
+```
+
+A terminated stream does not reconnect; build a new client to resume.
+
+### One inconsistency worth knowing
+
+Discovery listings report `venue` in uppercase (`KALSHI`, `POLYMARKET`), while the order and streaming surfaces take it lowercase. The client passes the value through unchanged in both directions rather than quietly rewriting it.
+
+## License
+
+MIT. See [LICENSE](./LICENSE).

parlayx-0.0.0/pyproject.toml

@@ -0,0 +1,78 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "parlayx"
+version = "0.0.0"
+description = "Official Python client for the ParlayX public API."
+readme = "README.md"
+requires-python = ">=3.11"
+license = "MIT"
+license-files = ["LICENSE"]
+dependencies = ["cryptography>=45,<51", "httpx>=0.28,<1", "pydantic>=2.9,<3"]
+
+# The stream client is the only part that needs a WebSocket library, so a REST-only
+# consumer does not pull it in.
+[project.optional-dependencies]
+stream = ["websockets>=15,<18"]
+
+[project.urls]
+Homepage = "https://docs.parlayx.com"
+Documentation = "https://docs.parlayx.com"
+
+[dependency-groups]
+# datamodel-code-generator is pinned exactly, not ranged. Its output is committed, so a
+# patch release that changed formatting would show up as an unexplained diff on a branch
+# that touched nothing.
+dev = [
+  "datamodel-code-generator==0.76.1",
+  "parlayx[stream]",
+  "mypy>=1.14,<2",
+  "pytest>=8,<10",
+  "pytest-timeout>=2.3,<3",
+  "pytest-asyncio>=0.24,<2",
+  "ruff>=0.14,<1",
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/parlayx"]
+
+# Kept out of the source distribution. The test suite reads fixtures from outside
+# this directory and so cannot run standalone; shipping it would hand a reader a
+# suite that only fails. The rest is build wiring that means nothing on its own.
+[tool.hatch.build.targets.sdist]
+exclude = [".gitignore", ".python-version", "project.json", "uv.lock", "tests"]
+
+[tool.ruff]
+line-length = 100
+target-version = "py311"
+# The generated models are formatted by the generator (black + isort, pinned in the
+# py:generate flags) and carry the spec's own field descriptions verbatim, some of which
+# exceed the line length. Linting or reformatting them here would fight the drift gate:
+# any fix is reverted by the next regeneration.
+extend-exclude = ["src/parlayx/_generated"]
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "N", "UP", "B", "SIM", "RUF"]
+
+[tool.mypy]
+python_version = "3.11"
+strict = true
+files = ["src", "tests"]
+
+# The generator writes a dict literal as the default for a model-typed field. Pydantic
+# coerces it to the model at runtime because the field carries validate_default=True, so
+# the value is never a dict, but mypy reads the literal as a bad assignment. Everything
+# else in the generated models stays checked.
+[[tool.mypy.overrides]]
+module = "parlayx._generated.*"
+disable_error_code = ["assignment"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+# A broken stream client hangs rather than failing: the consumer waits on a queue that
+# will never receive another frame. Without a deadline that reads as a stuck CI job
+# instead of a red test.
+timeout = 30
+asyncio_mode = "auto"

parlayx-0.0.0/src/parlayx/__init__.py

@@ -0,0 +1,122 @@
+"""Official Python client for the ParlayX public API.
+
+    from parlayx import ParlayX
+
+    with ParlayX.from_env() as client:
+        who = client.whoami()
+        balance = client.kalshi.get_balance()
+
+`AsyncParlayX` is the same surface with `await`. Every method returns its typed payload
+and raises `RequestError` on any non-2xx response.
+"""
+
+from ._async_client import AsyncKalshiResource, AsyncParlayX, AsyncPolymarketResource
+from ._generated import models
+from ._generated.models import (
+    ApiErrorCode,
+    Competition,
+    Event,
+    EventMarket,
+    GetKalshiOrderFillsResponse,
+    GetPolymarketOrderFillsResponse,
+    KalshiAction,
+    KalshiBalance,
+    KalshiFillView,
+    KalshiListing,
+    KalshiOrderRequest,
+    KalshiOrderType,
+    KalshiOrderView,
+    KalshiPosition,
+    KalshiSide,
+    ListCompetitionsResponse,
+    ListEventMarketsResponse,
+    ListEventsResponse,
+    ListKalshiOrdersResponse,
+    ListKalshiPositionsResponse,
+    ListPolymarketOrdersResponse,
+    ListPolymarketPositionsResponse,
+    ListSportsResponse,
+    LookupMarketResponse,
+    Outcome,
+    PolymarketBalance,
+    PolymarketFillView,
+    PolymarketLimitOrder,
+    PolymarketListing,
+    PolymarketMarketOrder,
+    PolymarketOrderView,
+    PolymarketPosition,
+    PolymarketSide,
+    ProphetXListing,
+    ServerTimeResponse,
+    Sport,
+    SubmitKalshiOrderResponse,
+    SubmitPolymarketOrderResponse,
+    TradingOrderStatus,
+    TradingOrderType,
+    WhoamiResponse,
+)
+from .client import KalshiResource, ParlayX, PolymarketOrder, PolymarketResource
+from .errors import RequestError
+from .pagination import (
+    apaginate_kalshi_orders,
+    apaginate_polymarket_orders,
+    paginate_kalshi_orders,
+    paginate_polymarket_orders,
+)
+
+__all__ = [
+    "ApiErrorCode",
+    "AsyncKalshiResource",
+    "AsyncParlayX",
+    "AsyncPolymarketResource",
+    "Competition",
+    "Event",
+    "EventMarket",
+    "GetKalshiOrderFillsResponse",
+    "GetPolymarketOrderFillsResponse",
+    "KalshiAction",
+    "KalshiBalance",
+    "KalshiFillView",
+    "KalshiListing",
+    "KalshiOrderRequest",
+    "KalshiOrderType",
+    "KalshiOrderView",
+    "KalshiPosition",
+    "KalshiResource",
+    "KalshiSide",
+    "ListCompetitionsResponse",
+    "ListEventMarketsResponse",
+    "ListEventsResponse",
+    "ListKalshiOrdersResponse",
+    "ListKalshiPositionsResponse",
+    "ListPolymarketOrdersResponse",
+    "ListPolymarketPositionsResponse",
+    "ListSportsResponse",
+    "LookupMarketResponse",
+    "Outcome",
+    "ParlayX",
+    "PolymarketBalance",
+    "PolymarketFillView",
+    "PolymarketLimitOrder",
+    "PolymarketListing",
+    "PolymarketMarketOrder",
+    "PolymarketOrder",
+    "PolymarketOrderView",
+    "PolymarketPosition",
+    "PolymarketResource",
+    "PolymarketSide",
+    "ProphetXListing",
+    "RequestError",
+    "ServerTimeResponse",
+    "Sport",
+    "SubmitKalshiOrderResponse",
+    "SubmitPolymarketOrderResponse",
+    "TradingOrderStatus",
+    "TradingOrderType",
+    "WhoamiResponse",
+    "apaginate_kalshi_orders",
+    "apaginate_polymarket_orders",
+    "models",
+    "paginate_kalshi_orders",
+    "paginate_polymarket_orders",
+]