parlayx 3.2.2__tar.gz → 3.2.3__tar.gz

{parlayx-3.2.2 → parlayx-3.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: parlayx
-Version: 3.2.2
+Version: 3.2.3
 Summary: Official Python client for the ParlayX public API.
 Project-URL: Homepage, https://docs.parlayx.com
 Project-URL: Documentation, https://docs.parlayx.com
@@ -222,6 +222,90 @@ Set `time_in_force={"type": "FOK"}` for the venue's fill-or-kill, where an order
 
 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.
 
+## Connections
+
+From 3.2.3 the client keeps its connection to the API open between requests, so
+an order sent after a few seconds of quiet does not pay for a new TLS handshake. Create
+one client when your process starts and reuse it.
+
+Close it when your work is done, or use it as a context manager:
+
+```python
+with ParlayX() as client:
+    client.whoami()
+```
+
+Supplying your own `transport` replaces the pool, and with it the setting that
+holds the connection open.
+
+## Migrating to 3.2.3
+
+Kalshi orders and positions are now described the way Kalshi describes them, and
+every field below changed shape. Nothing else changed; the connection behaviour
+above is separate and needs nothing from you.
+
+A Kalshi order carries one `side`, either `"BID"` or `"ASK"`, in place of the old
+`side` (`"YES"` / `"NO"`) and `action` (`"BUY"` / `"SELL"`) pair. A `BID` buys YES
+contracts and profits if the market resolves YES; an `ASK` sells them and profits
+if it resolves NO. Selling YES and buying NO are the same order on Kalshi's book,
+so both are `"ASK"`.
+
+```python
+# 3.2.2
+order = KalshiOrderRequest(ticker=ticker, side="YES", action="BUY", count=10, price_cents=38)
+# 3.2.3
+order = KalshiOrderRequest(ticker=ticker, side="BID", count="10", price="0.38")
+```
+
+The old pair maps across like this:
+
+| 3.2.2 `side` + `action` | 3.2.3 `side` | 3.2.3 `price`                 |
+| ----------------------- | ------------ | ----------------------------- |
+| `YES` + `BUY`           | `BID`        | the YES price you sent        |
+| `YES` + `SELL`          | `ASK`        | the YES price you sent        |
+| `NO` + `BUY`            | `ASK`        | 1 minus the NO price you sent |
+| `NO` + `SELL`           | `BID`        | 1 minus the NO price you sent |
+
+`count` and `price` are decimal strings rather than numbers. `price` is dollars
+per contract on the market's YES book, replacing `price_cents`; `"0.38"` is what
+`price_cents=38` used to mean. Contracts trade in steps of 0.01 and prices go as
+fine as $0.0001, so sizes and prices Kalshi accepts are no longer refused before
+they reach it. Each market publishes its own grid of valid prices, and a price
+off that grid is refused rather than moved to the nearest one.
+
+Order and fill reads changed to match: `side` reads `"BID"` or `"ASK"`, `count`
+and `price` are decimal strings on the YES book, and `average_price` replaces
+`average_price_cents`. Orders placed before the upgrade read back in the new
+vocabulary, including ones placed on the NO leg. Amend and decrease take the same
+decimal strings, and their `previous` block reports `price` and `count` the same
+way.
+
+Positions changed with them. A Kalshi position is keyed by ticker alone, because
+the venue nets a market into one holding, and `side` is gone from the row.
+`contracts` is a decimal string on the market's YES side and its sign says which
+way the holding leans: positive is long YES, and negative is long NO, which is
+the same holding as short YES. It is a decimal because contracts trade in steps
+of 0.01. A ticker you hold both ways is one row now rather
+than two you have to net yourself.
+
+```python
+from decimal import Decimal
+
+# 3.2.2: two rows for one holding, netted by hand, as integers
+long, short = (p for p in positions if p.ticker == ticker)
+net = long.contracts - short.contracts
+# 3.2.3: one row, and the venue's own number
+(position,) = (p for p in positions if p.ticker == ticker)
+net = Decimal(position.contracts)
+```
+
+`average_price` and `mark` replace `average_price_cents` and `mark_cents`, as
+dollar strings from 0 to 1 on that same YES side, which is the frame you submit a
+price in. They are no longer rounded to a whole cent, so a market quoting in
+tenths of a cent reports the price it actually trades at. `average_price` reads
+`None` when the holding has no single entry price, and `value_usd` and
+`unrealized_pnl_usd` compose from the two published figures.
+
 ## License
 
 MIT. See [LICENSE](./LICENSE).

{parlayx-3.2.2 → parlayx-3.2.3}/README.md

@@ -202,6 +202,90 @@ Set `time_in_force={"type": "FOK"}` for the venue's fill-or-kill, where an order
 
 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.
 
+## Connections
+
+From 3.2.3 the client keeps its connection to the API open between requests, so
+an order sent after a few seconds of quiet does not pay for a new TLS handshake. Create
+one client when your process starts and reuse it.
+
+Close it when your work is done, or use it as a context manager:
+
+```python
+with ParlayX() as client:
+    client.whoami()
+```
+
+Supplying your own `transport` replaces the pool, and with it the setting that
+holds the connection open.
+
+## Migrating to 3.2.3
+
+Kalshi orders and positions are now described the way Kalshi describes them, and
+every field below changed shape. Nothing else changed; the connection behaviour
+above is separate and needs nothing from you.
+
+A Kalshi order carries one `side`, either `"BID"` or `"ASK"`, in place of the old
+`side` (`"YES"` / `"NO"`) and `action` (`"BUY"` / `"SELL"`) pair. A `BID` buys YES
+contracts and profits if the market resolves YES; an `ASK` sells them and profits
+if it resolves NO. Selling YES and buying NO are the same order on Kalshi's book,
+so both are `"ASK"`.
+
+```python
+# 3.2.2
+order = KalshiOrderRequest(ticker=ticker, side="YES", action="BUY", count=10, price_cents=38)
+# 3.2.3
+order = KalshiOrderRequest(ticker=ticker, side="BID", count="10", price="0.38")
+```
+
+The old pair maps across like this:
+
+| 3.2.2 `side` + `action` | 3.2.3 `side` | 3.2.3 `price`                 |
+| ----------------------- | ------------ | ----------------------------- |
+| `YES` + `BUY`           | `BID`        | the YES price you sent        |
+| `YES` + `SELL`          | `ASK`        | the YES price you sent        |
+| `NO` + `BUY`            | `ASK`        | 1 minus the NO price you sent |
+| `NO` + `SELL`           | `BID`        | 1 minus the NO price you sent |
+
+`count` and `price` are decimal strings rather than numbers. `price` is dollars
+per contract on the market's YES book, replacing `price_cents`; `"0.38"` is what
+`price_cents=38` used to mean. Contracts trade in steps of 0.01 and prices go as
+fine as $0.0001, so sizes and prices Kalshi accepts are no longer refused before
+they reach it. Each market publishes its own grid of valid prices, and a price
+off that grid is refused rather than moved to the nearest one.
+
+Order and fill reads changed to match: `side` reads `"BID"` or `"ASK"`, `count`
+and `price` are decimal strings on the YES book, and `average_price` replaces
+`average_price_cents`. Orders placed before the upgrade read back in the new
+vocabulary, including ones placed on the NO leg. Amend and decrease take the same
+decimal strings, and their `previous` block reports `price` and `count` the same
+way.
+
+Positions changed with them. A Kalshi position is keyed by ticker alone, because
+the venue nets a market into one holding, and `side` is gone from the row.
+`contracts` is a decimal string on the market's YES side and its sign says which
+way the holding leans: positive is long YES, and negative is long NO, which is
+the same holding as short YES. It is a decimal because contracts trade in steps
+of 0.01. A ticker you hold both ways is one row now rather
+than two you have to net yourself.
+
+```python
+from decimal import Decimal
+
+# 3.2.2: two rows for one holding, netted by hand, as integers
+long, short = (p for p in positions if p.ticker == ticker)
+net = long.contracts - short.contracts
+# 3.2.3: one row, and the venue's own number
+(position,) = (p for p in positions if p.ticker == ticker)
+net = Decimal(position.contracts)
+```
+
+`average_price` and `mark` replace `average_price_cents` and `mark_cents`, as
+dollar strings from 0 to 1 on that same YES side, which is the frame you submit a
+price in. They are no longer rounded to a whole cent, so a market quoting in
+tenths of a cent reports the price it actually trades at. `average_price` reads
+`None` when the holding has no single entry price, and `value_usd` and
+`unrealized_pnl_usd` compose from the two published figures.
+
 ## License
 
 MIT. See [LICENSE](./LICENSE).

{parlayx-3.2.2 → parlayx-3.2.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "parlayx"
-version = "3.2.2"
+version = "3.2.3"
 description = "Official Python client for the ParlayX public API."
 readme = "README.md"
 requires-python = ">=3.11"

{parlayx-3.2.2 → parlayx-3.2.3}/src/parlayx/__init__.py

@@ -39,21 +39,23 @@ from ._generated.models import (
     GetLimitlessOrderFillsResponse,
     GetPolymarketOrderFillsResponse,
     GetProphetXOrderFillsResponse,
-    KalshiAction,
     KalshiBalance,
+    KalshiBatchOrder,
     KalshiFillView,
     KalshiListing,
+    KalshiOrderQueuePosition,
     KalshiOrderRequest,
+    KalshiOrderSide,
     KalshiOrderType,
     KalshiOrderView,
     KalshiPosition,
-    KalshiSide,
     LimitlessBalance,
     LimitlessOrderRequest,
     LimitlessOrderView,
     ListCompetitionsResponse,
     ListEventMarketsResponse,
     ListEventsResponse,
+    ListKalshiOrderQueuePositionsResponse,
     ListKalshiOrdersResponse,
     ListKalshiPositionsResponse,
     ListLimitlessMarketsResponse,
@@ -67,6 +69,7 @@ from ._generated.models import (
     LookupMarketResponse,
     Outcome,
     PolymarketBalance,
+    PolymarketBatchOrderResult,
     PolymarketCancelFailureCode,
     PolymarketCancellationReason,
     PolymarketFillView,
@@ -78,13 +81,17 @@ from ._generated.models import (
     PolymarketSide,
     PolymarketUncancelledOrder,
     ProphetXBalance,
+    ProphetXBatchOrder,
+    ProphetXFailedOrder,
     ProphetXFillView,
     ProphetXFokTimeInForce,
+    ProphetXGtdTimeInForce,
     ProphetXLadder,
     ProphetXListing,
     ProphetXOrderRequest,
     ProphetXOrderView,
     ProphetXPosition,
+    ProphetXSucceededOrder,
     ReplaceLimitlessOrderRequest,
     ReplaceLimitlessOrderResponse,
     ReplaceLimitlessOrdersRequest,
@@ -92,9 +99,15 @@ from ._generated.models import (
     ServerTimeResponse,
     Sport,
     SubmitKalshiOrderResponse,
+    SubmitKalshiOrdersRequest,
+    SubmitKalshiOrdersResponse,
     SubmitLimitlessOrderResponse,
     SubmitPolymarketOrderResponse,
+    SubmitPolymarketOrdersRequest,
+    SubmitPolymarketOrdersResponse,
     SubmitProphetXOrderResponse,
+    SubmitProphetXOrdersRequest,
+    SubmitProphetXOrdersResponse,
     TradingOrderStatus,
     TradingOrderType,
     WhoamiResponse,
@@ -138,16 +151,17 @@ __all__ = [
     "GetLimitlessOrderFillsResponse",
     "GetPolymarketOrderFillsResponse",
     "GetProphetXOrderFillsResponse",
-    "KalshiAction",
     "KalshiBalance",
+    "KalshiBatchOrder",
     "KalshiFillView",
     "KalshiListing",
+    "KalshiOrderQueuePosition",
     "KalshiOrderRequest",
+    "KalshiOrderSide",
     "KalshiOrderType",
     "KalshiOrderView",
     "KalshiPosition",
     "KalshiResource",
-    "KalshiSide",
     "LimitlessBalance",
     "LimitlessOrderRequest",
     "LimitlessOrderView",
@@ -155,6 +169,7 @@ __all__ = [
     "ListCompetitionsResponse",
     "ListEventMarketsResponse",
     "ListEventsResponse",
+    "ListKalshiOrderQueuePositionsResponse",
     "ListKalshiOrdersResponse",
     "ListKalshiPositionsResponse",
     "ListLimitlessMarketsResponse",
@@ -169,6 +184,7 @@ __all__ = [
     "Outcome",
     "ParlayX",
     "PolymarketBalance",
+    "PolymarketBatchOrderResult",
     "PolymarketCancelFailureCode",
     "PolymarketCancellationReason",
     "PolymarketFillView",
@@ -182,14 +198,18 @@ __all__ = [
     "PolymarketSide",
     "PolymarketUncancelledOrder",
     "ProphetXBalance",
+    "ProphetXBatchOrder",
+    "ProphetXFailedOrder",
     "ProphetXFillView",
     "ProphetXFokTimeInForce",
+    "ProphetXGtdTimeInForce",
     "ProphetXLadder",
     "ProphetXListing",
     "ProphetXOrderRequest",
     "ProphetXOrderView",
     "ProphetXPosition",
     "ProphetXResource",
+    "ProphetXSucceededOrder",
     "ReplaceLimitlessOrderRequest",
     "ReplaceLimitlessOrderResponse",
     "ReplaceLimitlessOrdersRequest",
@@ -198,9 +218,15 @@ __all__ = [
     "ServerTimeResponse",
     "Sport",
     "SubmitKalshiOrderResponse",
+    "SubmitKalshiOrdersRequest",
+    "SubmitKalshiOrdersResponse",
     "SubmitLimitlessOrderResponse",
     "SubmitPolymarketOrderResponse",
+    "SubmitPolymarketOrdersRequest",
+    "SubmitPolymarketOrdersResponse",
     "SubmitProphetXOrderResponse",
+    "SubmitProphetXOrdersRequest",
+    "SubmitProphetXOrdersResponse",
     "TradingOrderStatus",
     "TradingOrderType",
     "WhoamiResponse",

{parlayx-3.2.2 → parlayx-3.2.3}/src/parlayx/_async_client.py

@@ -34,6 +34,7 @@ from ._generated.models import (
     ListCompetitionsResponse,
     ListEventMarketsResponse,
     ListEventsResponse,
+    ListKalshiOrderQueuePositionsResponse,
     ListKalshiOrdersResponse,
     ListKalshiPositionsResponse,
     ListLimitlessMarketsResponse,
@@ -57,13 +58,20 @@ from ._generated.models import (
     ReplaceLimitlessOrdersResponse,
     ServerTimeResponse,
     SubmitKalshiOrderResponse,
+    SubmitKalshiOrdersRequest,
+    SubmitKalshiOrdersResponse,
     SubmitLimitlessOrderResponse,
     SubmitPolymarketOrderResponse,
+    SubmitPolymarketOrdersRequest,
+    SubmitPolymarketOrdersResponse,
     SubmitProphetXOrderResponse,
+    SubmitProphetXOrdersRequest,
+    SubmitProphetXOrdersResponse,
     WhoamiResponse,
 )
 from ._transport import (
     DEFAULT_BASE_URL,
+    KEEPALIVE_LIMITS,
     ModelT,
     build_signed_request,
     new_idempotency_key,
@@ -97,6 +105,28 @@ class AsyncPolymarketResource:
             idempotency_key=new_idempotency_key(idempotency_key),
         )
 
+    async def submit_orders(
+        self, request: SubmitPolymarketOrdersRequest, *, idempotency_key: str | None = None
+    ) -> SubmitPolymarketOrdersResponse:
+        """Submit up to 15 orders in one request under one idempotency key.
+
+        The key defaults to a fresh value per call, so an unkeyed retry submits the
+        batch AGAIN. Pass your own and re-send the identical batch to retry safely.
+        Each order gets its own outcome, so a refused entry does not discard its
+        siblings. ``orders[i]`` answers request entry ``i``: ``success`` is true when
+        it was accepted, which is not confirmation at the venue and not a fill,
+        otherwise ``error`` says why. A ``success: false`` entry with an
+        ``ORDER_RECONCILIATION_REQUIRED`` error is not proof nothing was placed: its
+        outcome is unknown, so read it back by the entry's ``order_id``.
+        """
+        return await self._client._request(
+            "POST",
+            "/v1/polymarket/orders/batch",
+            SubmitPolymarketOrdersResponse,
+            body=request,
+            idempotency_key=new_idempotency_key(idempotency_key),
+        )
+
     async def list_orders(
         self,
         *,
@@ -293,6 +323,45 @@ class AsyncKalshiResource:
             body=request,
         )
 
+    async def submit_orders(
+        self, request: SubmitKalshiOrdersRequest, *, idempotency_key: str | None = None
+    ) -> SubmitKalshiOrdersResponse:
+        """Submit up to 20 orders in one request under one idempotency key.
+
+        The key covers the whole batch, is attached for you and defaults to a fresh value
+        per call, so an unkeyed retry submits the batch a SECOND time. Pass your own and
+        resend the identical batch under it to make a retry safe. Each order gets its own
+        outcome, so one refused order does not fail the others: ``orders[i]`` answers
+        order ``i`` as one flat record, and ``error`` None means it was accepted, not
+        confirmed at the venue, and is not a fill. An ``error`` coded
+        ``ORDER_RECONCILIATION_REQUIRED`` means the outcome is unknown and the order may
+        be live, so read back the order at the entry's ``order_id``. ``INTERNAL_ERROR``
+        means the outcome is unknown and no order id is known, so resend the identical
+        batch under the same key. Never resend either under a new key.
+        """
+        return await self._client._request(
+            "POST",
+            "/v1/kalshi/orders/batch",
+            SubmitKalshiOrdersResponse,
+            body=request,
+            idempotency_key=new_idempotency_key(idempotency_key),
+        )
+
+    async def list_order_queue_positions(
+        self, *, page_size: int | None = None, page_token: str | None = None
+    ) -> ListKalshiOrderQueuePositionsResponse:
+        """Queue positions for a page of your resting orders.
+
+        ``queue_position`` is the contracts ahead of the order in price-time priority, or
+        None when unavailable. A snapshot, not an execution guarantee.
+        """
+        return await self._client._request(
+            "GET",
+            "/v1/kalshi/orders/queue-positions",
+            ListKalshiOrderQueuePositionsResponse,
+            params={"pageSize": page_size, "pageToken": page_token},
+        )
+
     async def get_order_fills(self, order_id: str) -> GetKalshiOrderFillsResponse:
         """List the fills recorded against an order."""
         return await self._client._request(
@@ -344,6 +413,33 @@ class AsyncProphetXResource:
             idempotency_key=new_idempotency_key(idempotency_key),
         )
 
+    async def submit_orders(
+        self, request: SubmitProphetXOrdersRequest, *, idempotency_key: str | None = None
+    ) -> SubmitProphetXOrdersResponse:
+        """Submit up to 20 orders in one request.
+
+        The whole batch carries one idempotency key. Resending the same orders
+        under the same key returns each order's recorded outcome and places nothing
+        twice; the same key with different orders is refused with a 422. The key
+        defaults to a fresh value per call, so pass your own to make a retry safe.
+
+        Once a request is accepted, each order gets its own outcome, so an order the
+        venue refuses does not discard its siblings; a request that fails validation
+        is refused whole, with a 400 and no order placed. Accepted orders come back in
+        ``succeeded_orders``, accepted but not confirmed at the venue; refused or
+        unconfirmed ones come back in ``failed_orders``. A failed entry with code
+        ORDER_RECONCILIATION_REQUIRED may still have been placed, so read its
+        ``order_id`` before re-sending. Every order must be GTC: a ``timeInForce`` of
+        FOK or GTD is supported on ``submit_order`` only.
+        """
+        return await self._client._request(
+            "POST",
+            "/v1/prophetx/orders/batch",
+            SubmitProphetXOrdersResponse,
+            body=request,
+            idempotency_key=new_idempotency_key(idempotency_key),
+        )
+
     async def list_orders(
         self,
         *,
@@ -607,7 +703,12 @@ class AsyncParlayX:
         PARLAYX_KEY_ID and PARLAYX_PRIVATE_KEY_HEX when you do not.
         """
         self._credentials = resolve_credentials(key_id, private_key_hex)
-        self._http = httpx.AsyncClient(base_url=base_url, timeout=timeout, transport=transport)
+        self._http = httpx.AsyncClient(
+            base_url=base_url,
+            timeout=timeout,
+            transport=transport,
+            limits=KEEPALIVE_LIMITS,
+        )
         self.polymarket = AsyncPolymarketResource(self)
         self.limitless = AsyncLimitlessResource(self)
         self.kalshi = AsyncKalshiResource(self)