parlayx 0.0.0__py3-none-any.whl

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",
+]

parlayx/_async_client.py

@@ -0,0 +1,323 @@
+"""Asynchronous ParlayX API client.
+
+Mirrors `parlayx.client` method for method; the two differ by `await` and nothing else.
+Both sign through the same module and share one set of models.
+"""
+
+from __future__ import annotations
+
+from types import TracebackType
+from typing import Any
+
+import httpx
+from pydantic import BaseModel
+
+from ._generated.models import (
+    GetKalshiOrderFillsResponse,
+    GetPolymarketOrderFillsResponse,
+    KalshiBalance,
+    KalshiOrderRequest,
+    KalshiOrderView,
+    ListCompetitionsResponse,
+    ListEventMarketsResponse,
+    ListEventsResponse,
+    ListKalshiOrdersResponse,
+    ListKalshiPositionsResponse,
+    ListPolymarketOrdersResponse,
+    ListPolymarketPositionsResponse,
+    ListSportsResponse,
+    LookupMarketResponse,
+    PolymarketBalance,
+    PolymarketOrderView,
+    ServerTimeResponse,
+    SubmitKalshiOrderResponse,
+    SubmitPolymarketOrderResponse,
+    WhoamiResponse,
+)
+from ._transport import (
+    DEFAULT_BASE_URL,
+    Credentials,
+    ModelT,
+    build_signed_request,
+    new_idempotency_key,
+    parse,
+    path_segment,
+)
+from .client import PolymarketOrder, _credentials_from_env
+
+
+class AsyncPolymarketResource:
+    """Polymarket orders, positions and balance."""
+
+    def __init__(self, client: AsyncParlayX) -> None:
+        self._client = client
+
+    async def submit_order(
+        self, order: PolymarketOrder, *, idempotency_key: str | None = None
+    ) -> SubmitPolymarketOrderResponse:
+        """Submit an order.
+
+        An idempotency key is attached for you and defaults to a fresh value per call,
+        so an unkeyed retry submits a SECOND order. Pass your own to make a specific
+        retry safe.
+        """
+        return await self._client._request(
+            "POST",
+            "/v1/polymarket/orders",
+            SubmitPolymarketOrderResponse,
+            body=order,
+            idempotency_key=new_idempotency_key(idempotency_key),
+        )
+
+    async def list_orders(
+        self,
+        *,
+        token_id: str | None = None,
+        status: str | None = None,
+        page_size: int | None = None,
+        page_token: str | None = None,
+    ) -> ListPolymarketOrdersResponse:
+        """List orders, most recent first."""
+        return await self._client._request(
+            "GET",
+            "/v1/polymarket/orders",
+            ListPolymarketOrdersResponse,
+            params={
+                "tokenId": token_id,
+                "status": status,
+                "pageSize": page_size,
+                "pageToken": page_token,
+            },
+        )
+
+    async def get_order(self, order_id: str) -> PolymarketOrderView:
+        """Fetch a single order by id."""
+        return await self._client._request(
+            "GET", f"/v1/polymarket/orders/{path_segment(order_id)}", PolymarketOrderView
+        )
+
+    async def cancel_order(self, order_id: str) -> PolymarketOrderView:
+        """Cancel a single open order by id."""
+        return await self._client._request(
+            "DELETE", f"/v1/polymarket/orders/{path_segment(order_id)}", PolymarketOrderView
+        )
+
+    async def get_order_fills(self, order_id: str) -> GetPolymarketOrderFillsResponse:
+        """List the fills recorded against an order."""
+        return await self._client._request(
+            "GET",
+            f"/v1/polymarket/orders/{path_segment(order_id)}/fills",
+            GetPolymarketOrderFillsResponse,
+        )
+
+    async def list_positions(
+        self, *, token_id: str | None = None
+    ) -> ListPolymarketPositionsResponse:
+        """List open positions."""
+        return await self._client._request(
+            "GET",
+            "/v1/polymarket/positions",
+            ListPolymarketPositionsResponse,
+            params={"tokenId": token_id},
+        )
+
+    async def get_balance(self) -> PolymarketBalance:
+        """Read the venue balance."""
+        return await self._client._request("GET", "/v1/polymarket/balance", PolymarketBalance)
+
+
+class AsyncKalshiResource:
+    """Kalshi orders, positions and balance."""
+
+    def __init__(self, client: AsyncParlayX) -> None:
+        self._client = client
+
+    async def submit_order(
+        self, order: KalshiOrderRequest, *, idempotency_key: str | None = None
+    ) -> SubmitKalshiOrderResponse:
+        """Submit an order.
+
+        An idempotency key is attached for you and defaults to a fresh value per call,
+        so an unkeyed retry submits a SECOND order. Pass your own to make a specific
+        retry safe.
+        """
+        return await self._client._request(
+            "POST",
+            "/v1/kalshi/orders",
+            SubmitKalshiOrderResponse,
+            body=order,
+            idempotency_key=new_idempotency_key(idempotency_key),
+        )
+
+    async def list_orders(
+        self,
+        *,
+        ticker: str | None = None,
+        status: str | None = None,
+        page_size: int | None = None,
+        page_token: str | None = None,
+    ) -> ListKalshiOrdersResponse:
+        """List orders, most recent first."""
+        return await self._client._request(
+            "GET",
+            "/v1/kalshi/orders",
+            ListKalshiOrdersResponse,
+            params={
+                "ticker": ticker,
+                "status": status,
+                "pageSize": page_size,
+                "pageToken": page_token,
+            },
+        )
+
+    async def get_order(self, order_id: str) -> KalshiOrderView:
+        """Fetch a single order by id."""
+        return await self._client._request(
+            "GET", f"/v1/kalshi/orders/{path_segment(order_id)}", KalshiOrderView
+        )
+
+    async def cancel_order(self, order_id: str) -> KalshiOrderView:
+        """Cancel a single open order by id."""
+        return await self._client._request(
+            "DELETE", f"/v1/kalshi/orders/{path_segment(order_id)}", KalshiOrderView
+        )
+
+    async def get_order_fills(self, order_id: str) -> GetKalshiOrderFillsResponse:
+        """List the fills recorded against an order."""
+        return await self._client._request(
+            "GET", f"/v1/kalshi/orders/{path_segment(order_id)}/fills", GetKalshiOrderFillsResponse
+        )
+
+    async def list_positions(self, *, ticker: str | None = None) -> ListKalshiPositionsResponse:
+        """List open positions."""
+        return await self._client._request(
+            "GET",
+            "/v1/kalshi/positions",
+            ListKalshiPositionsResponse,
+            params={"ticker": ticker},
+        )
+
+    async def get_balance(self) -> KalshiBalance:
+        """Read the venue balance."""
+        return await self._client._request("GET", "/v1/kalshi/balance", KalshiBalance)
+
+
+class AsyncParlayX:
+    """Asynchronous ParlayX API client.
+
+    Every method returns its typed payload and raises `RequestError` on any non-2xx
+    response. Create one and reuse it; each instance holds a connection pool.
+    """
+
+    def __init__(
+        self,
+        *,
+        key_id: str,
+        private_key_hex: str,
+        base_url: str = DEFAULT_BASE_URL,
+        timeout: float = 30.0,
+        transport: httpx.AsyncBaseTransport | None = None,
+    ) -> None:
+        self._credentials = Credentials(key_id=key_id, private_key_hex=private_key_hex)
+        self._http = httpx.AsyncClient(base_url=base_url, timeout=timeout, transport=transport)
+        self.polymarket = AsyncPolymarketResource(self)
+        self.kalshi = AsyncKalshiResource(self)
+
+    @classmethod
+    def from_env(cls, **kwargs: Any) -> AsyncParlayX:
+        """Build a client from PARLAYX_KEY_ID and PARLAYX_PRIVATE_KEY_HEX."""
+        credentials = _credentials_from_env()
+        return cls(key_id=credentials.key_id, private_key_hex=credentials.private_key_hex, **kwargs)
+
+    async def _request(
+        self,
+        method: str,
+        path: str,
+        model: type[ModelT],
+        *,
+        params: dict[str, Any] | None = None,
+        body: BaseModel | None = None,
+        idempotency_key: str | None = None,
+    ) -> ModelT:
+        request = build_signed_request(
+            self._http,
+            self._credentials,
+            method,
+            path,
+            params=params,
+            body=body,
+            idempotency_key=idempotency_key,
+        )
+        return parse(await self._http.send(request), model)
+
+    async def whoami(self) -> WhoamiResponse:
+        """Identify the calling key: its actor, pod, scope and capabilities."""
+        return await self._request("GET", "/v1/whoami", WhoamiResponse)
+
+    async def get_time(self) -> ServerTimeResponse:
+        """Read the server clock.
+
+        Verified without a timestamp, so a host whose clock has drifted past the
+        signature window can still call it and measure the offset.
+        """
+        return await self._request("GET", "/v1/time", ServerTimeResponse)
+
+    async def list_sports(self) -> ListSportsResponse:
+        """List the sports carried by the discovery surface."""
+        return await self._request("GET", "/v1/sports", ListSportsResponse)
+
+    async def list_competitions(self, *, sport: str | None = None) -> ListCompetitionsResponse:
+        """List competitions, optionally filtered to one sport."""
+        return await self._request(
+            "GET", "/v1/sports/competitions", ListCompetitionsResponse, params={"sport": sport}
+        )
+
+    async def list_events(self, *, competition_id: str) -> ListEventsResponse:
+        """List the events in a competition."""
+        return await self._request(
+            "GET",
+            "/v1/sports/events",
+            ListEventsResponse,
+            params={"competitionId": competition_id},
+        )
+
+    async def list_event_markets(self, event_id: str) -> ListEventMarketsResponse:
+        """List the markets on an event."""
+        return await self._request(
+            "GET", f"/v1/sports/events/{path_segment(event_id)}/markets", ListEventMarketsResponse
+        )
+
+    async def lookup_market(
+        self,
+        *,
+        token_id: str | None = None,
+        ticker: str | None = None,
+        condition_id: str | None = None,
+        slug: str | None = None,
+    ) -> LookupMarketResponse:
+        """Look up a single market by one venue-native identifier."""
+        return await self._request(
+            "GET",
+            "/v1/markets",
+            LookupMarketResponse,
+            params={
+                "tokenId": token_id,
+                "ticker": ticker,
+                "conditionId": condition_id,
+                "slug": slug,
+            },
+        )
+
+    async def close(self) -> None:
+        await self._http.aclose()
+
+    async def __aenter__(self) -> AsyncParlayX:
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc: BaseException | None,
+        traceback: TracebackType | None,
+    ) -> None:
+        await self.close()