polymarket-client 0.1.0__py3-none-any.whl

polymarket/__init__.py

@@ -0,0 +1,416 @@
+from polymarket.auth import BuilderApiKey, RelayerApiKey
+from polymarket.calls import TransactionCall
+from polymarket.clients import AsyncPublicClient, AsyncSecureClient, PublicClient, SecureClient
+from polymarket.environments import PRODUCTION, Environment
+from polymarket.errors import (
+    CancelledSigningError,
+    ConnectionLostError,
+    InsufficientAllowanceError,
+    InsufficientLiquidityError,
+    PolymarketError,
+    RateLimitError,
+    RequestRejectedError,
+    SigningError,
+    TimeoutError,
+    TransactionFailedError,
+    TransportError,
+    UnexpectedResponseError,
+    UserInputError,
+)
+from polymarket.models import (
+    AcceptedOrder,
+    Activity,
+    ActivityType,
+    ApiKeyCreds,
+    AssetType,
+    BalanceAllowance,
+    BuilderApiKeyInfo,
+    BuilderFeeRates,
+    BuilderTrade,
+    BuilderVolumeEntry,
+    BuilderVolumeTimePeriod,
+    CancelOrdersResponse,
+    ClobTrade,
+    ClosedPosition,
+    ComboActivity,
+    ComboActivityId,
+    ComboActivityType,
+    ComboCompressActivity,
+    ComboConditionId,
+    ComboConvertActivity,
+    ComboMarket,
+    ComboMarketOutcome,
+    ComboMarketOutcomes,
+    ComboMergeActivity,
+    ComboPosition,
+    ComboPositionLeg,
+    ComboPositionMarket,
+    ComboPositionMarketEvent,
+    ComboPositionOutcome,
+    ComboPositionStatus,
+    ComboRedeemActivity,
+    ComboSplitActivity,
+    ComboTradeActivity,
+    ComboUnwrapActivity,
+    ComboWrapActivity,
+    Comment,
+    CommentId,
+    ConditionId,
+    ConversionActivity,
+    CtfConditionId,
+    CurrentReward,
+    CurrentRewardConfig,
+    EarningBreakdown,
+    Event,
+    EventId,
+    GaslessTransaction,
+    Holder,
+    LastTradePrice,
+    LastTradePriceForToken,
+    LeaderboardCategory,
+    LeaderboardEntry,
+    LeaderboardOrderBy,
+    LeaderboardTimePeriod,
+    LiveVolume,
+    MakerOrder,
+    MakerRebateActivity,
+    Market,
+    MarketId,
+    MarketOrderType,
+    MarketPosition,
+    MarketReward,
+    MarketRewardConfig,
+    MarketRewardToken,
+    MarketVolume,
+    MergeActivity,
+    MetaHolder,
+    MetaMarketPosition,
+    Notification,
+    OpenInterest,
+    OpenOrder,
+    OrderBook,
+    OrderBookLevel,
+    OrderId,
+    OrderPostStatus,
+    OrderResponse,
+    OrderResponseErrorCode,
+    OrderSide,
+    OrderType,
+    PerpsBalance,
+    PerpsBook,
+    PerpsCandle,
+    PerpsCredentials,
+    PerpsDeposit,
+    PerpsFeeScheduleEntry,
+    PerpsFill,
+    PerpsFundingPayment,
+    PerpsFundingRate,
+    PerpsInstrument,
+    PerpsOrder,
+    PerpsOrderPlacement,
+    PerpsOrderRequest,
+    PerpsPlacedTpSlOrder,
+    PerpsPlacedTpSlOrders,
+    PerpsPortfolio,
+    PerpsPosition,
+    PerpsPositionTpSlTrigger,
+    PerpsTicker,
+    PerpsTpSlTrigger,
+    PerpsTrade,
+    PerpsWithdrawal,
+    PortfolioValue,
+    Position,
+    PositionId,
+    PriceHistoryInterval,
+    PriceHistoryPoint,
+    PriceRequest,
+    Profile,
+    PublicProfile,
+    QuestionId,
+    RedeemActivity,
+    ReferralRewardActivity,
+    RejectedOrder,
+    RelatedTag,
+    RelayerTransactionState,
+    ResolutionRequestId,
+    RewardActivity,
+    RewardsPercentages,
+    SearchResults,
+    SearchTag,
+    Series,
+    SeriesId,
+    SignedOrder,
+    SplitActivity,
+    SportsMarketTypes,
+    SportsMetadata,
+    Tag,
+    TagId,
+    TagReference,
+    Team,
+    TickSize,
+    TokenId,
+    TotalUserEarning,
+    Trade,
+    TradeActivity,
+    TradedMarketCount,
+    TraderLeaderboardEntry,
+    TransactionOutcome,
+    UnknownActivity,
+    UserEarning,
+    UserRewardsConfig,
+    UserRewardsEarning,
+    YieldActivity,
+    to_combo_condition_id,
+    to_ctf_condition_id,
+)
+from polymarket.pagination import AsyncPaginator, Page, Paginator
+from polymarket.rfq import (
+    RfqCancelQuoteAck,
+    RfqCancelQuoteRejectedError,
+    RfqConfirmationAck,
+    RfqConfirmationDecision,
+    RfqConfirmationRejectedError,
+    RfqConfirmationRequestEvent,
+    RfqDirection,
+    RfqErrorCode,
+    RfqEvent,
+    RfqExecutionStatus,
+    RfqExecutionUpdateEvent,
+    RfqId,
+    RfqQuoteId,
+    RfqQuoteReference,
+    RfqQuoteRejectedError,
+    RfqQuoteRequestEvent,
+    RfqQuoteSource,
+    RfqRequestedSize,
+    RfqRequestedSizeUnit,
+    RfqRequestorPublicId,
+    RfqSession,
+    RfqSide,
+    RfqTradeEvent,
+)
+from polymarket.transactions import (
+    EoaTransactionHandle,
+    GaslessTransactionHandle,
+    MergeComboPositionRequest,
+    MergeMarketConditionRequest,
+    MergeMarketIdRequest,
+    MergeMarketPositionRequest,
+    MergePositionRequest,
+    SyncEoaTransactionHandle,
+    SyncGaslessTransactionHandle,
+    SyncTransactionHandle,
+    TransactionHandle,
+)
+from polymarket.types import EvmAddress, HexString, TransactionHash
+from polymarket.version import __version__
+
+__all__ = [
+    "PRODUCTION",
+    "AcceptedOrder",
+    "Activity",
+    "ActivityType",
+    "ApiKeyCreds",
+    "AssetType",
+    "AsyncPaginator",
+    "AsyncPublicClient",
+    "AsyncSecureClient",
+    "BalanceAllowance",
+    "BuilderApiKey",
+    "BuilderApiKeyInfo",
+    "BuilderFeeRates",
+    "BuilderTrade",
+    "BuilderVolumeEntry",
+    "BuilderVolumeTimePeriod",
+    "CancelOrdersResponse",
+    "CancelledSigningError",
+    "ConnectionLostError",
+    "ClobTrade",
+    "ClosedPosition",
+    "ComboActivity",
+    "ComboActivityId",
+    "ComboActivityType",
+    "ComboCompressActivity",
+    "ComboConvertActivity",
+    "ComboPosition",
+    "Comment",
+    "ComboPositionLeg",
+    "ComboPositionMarket",
+    "ComboPositionMarketEvent",
+    "ComboPositionOutcome",
+    "ComboPositionStatus",
+    "ComboRedeemActivity",
+    "ComboSplitActivity",
+    "ComboTradeActivity",
+    "ComboUnwrapActivity",
+    "ComboWrapActivity",
+    "CommentId",
+    "ComboConditionId",
+    "ComboMarket",
+    "ComboMarketOutcome",
+    "ComboMarketOutcomes",
+    "ConditionId",
+    "CtfConditionId",
+    "ConversionActivity",
+    "CurrentReward",
+    "CurrentRewardConfig",
+    "EarningBreakdown",
+    "EoaTransactionHandle",
+    "Environment",
+    "Event",
+    "EventId",
+    "EvmAddress",
+    "GaslessTransaction",
+    "GaslessTransactionHandle",
+    "HexString",
+    "Holder",
+    "InsufficientAllowanceError",
+    "InsufficientLiquidityError",
+    "LastTradePrice",
+    "LastTradePriceForToken",
+    "LeaderboardCategory",
+    "LeaderboardEntry",
+    "LeaderboardOrderBy",
+    "LeaderboardTimePeriod",
+    "LiveVolume",
+    "MakerOrder",
+    "MakerRebateActivity",
+    "Market",
+    "MarketId",
+    "MarketOrderType",
+    "MarketPosition",
+    "MarketReward",
+    "MarketRewardConfig",
+    "MarketRewardToken",
+    "MarketVolume",
+    "MergeActivity",
+    "ComboMergeActivity",
+    "MergeComboPositionRequest",
+    "MergeMarketConditionRequest",
+    "MergeMarketIdRequest",
+    "MergeMarketPositionRequest",
+    "MergePositionRequest",
+    "MetaHolder",
+    "MetaMarketPosition",
+    "Notification",
+    "OpenInterest",
+    "OpenOrder",
+    "OrderBook",
+    "OrderBookLevel",
+    "OrderId",
+    "OrderPostStatus",
+    "OrderResponse",
+    "OrderResponseErrorCode",
+    "OrderSide",
+    "OrderType",
+    "Page",
+    "Paginator",
+    "PerpsBalance",
+    "PerpsBook",
+    "PerpsCandle",
+    "PerpsCredentials",
+    "PerpsDeposit",
+    "PerpsFeeScheduleEntry",
+    "PerpsFill",
+    "PerpsFundingPayment",
+    "PerpsFundingRate",
+    "PerpsInstrument",
+    "PerpsOrder",
+    "PerpsOrderPlacement",
+    "PerpsOrderRequest",
+    "PerpsPlacedTpSlOrder",
+    "PerpsPlacedTpSlOrders",
+    "PerpsPortfolio",
+    "PerpsPosition",
+    "PerpsPositionTpSlTrigger",
+    "PerpsTicker",
+    "PerpsTpSlTrigger",
+    "PerpsTrade",
+    "PerpsWithdrawal",
+    "PolymarketError",
+    "PortfolioValue",
+    "Position",
+    "PositionId",
+    "PriceHistoryInterval",
+    "PriceHistoryPoint",
+    "PriceRequest",
+    "Profile",
+    "PublicClient",
+    "PublicProfile",
+    "QuestionId",
+    "RateLimitError",
+    "RedeemActivity",
+    "ReferralRewardActivity",
+    "RejectedOrder",
+    "RelatedTag",
+    "RelayerApiKey",
+    "RelayerTransactionState",
+    "RequestRejectedError",
+    "ResolutionRequestId",
+    "RewardActivity",
+    "RewardsPercentages",
+    "RfqCancelQuoteAck",
+    "RfqCancelQuoteRejectedError",
+    "RfqConfirmationAck",
+    "RfqConfirmationDecision",
+    "RfqConfirmationRejectedError",
+    "RfqConfirmationRequestEvent",
+    "RfqDirection",
+    "RfqErrorCode",
+    "RfqEvent",
+    "RfqExecutionStatus",
+    "RfqExecutionUpdateEvent",
+    "RfqId",
+    "RfqQuoteId",
+    "RfqQuoteReference",
+    "RfqQuoteRejectedError",
+    "RfqQuoteRequestEvent",
+    "RfqQuoteSource",
+    "RfqRequestedSize",
+    "RfqRequestedSizeUnit",
+    "RfqRequestorPublicId",
+    "RfqSession",
+    "RfqSide",
+    "RfqTradeEvent",
+    "SearchResults",
+    "SearchTag",
+    "SecureClient",
+    "Series",
+    "SeriesId",
+    "SignedOrder",
+    "SigningError",
+    "SplitActivity",
+    "SportsMarketTypes",
+    "SportsMetadata",
+    "SyncEoaTransactionHandle",
+    "SyncGaslessTransactionHandle",
+    "SyncTransactionHandle",
+    "Tag",
+    "TagId",
+    "TagReference",
+    "Team",
+    "TickSize",
+    "TimeoutError",
+    "TokenId",
+    "TotalUserEarning",
+    "to_combo_condition_id",
+    "to_ctf_condition_id",
+    "Trade",
+    "TradeActivity",
+    "TradedMarketCount",
+    "TraderLeaderboardEntry",
+    "TransactionCall",
+    "TransactionFailedError",
+    "TransactionHandle",
+    "TransactionHash",
+    "TransactionOutcome",
+    "TransportError",
+    "UnexpectedResponseError",
+    "UnknownActivity",
+    "UserEarning",
+    "UserInputError",
+    "UserRewardsConfig",
+    "UserRewardsEarning",
+    "YieldActivity",
+    "__version__",
+]

polymarket/_frames_bridge.py

@@ -0,0 +1,14 @@
+"""Lazy, type-erased lookup of :mod:`polymarket.frames` functions for non-frames modules."""
+
+from __future__ import annotations
+
+from typing import Any, Literal
+
+
+def frames_func(name: Literal["to_arrow", "to_pandas", "to_polars"]) -> Any:
+    from polymarket import frames
+
+    return getattr(frames, name)
+
+
+__all__ = ["frames_func"]

polymarket/_internal/actions/_cursor.py

@@ -0,0 +1,41 @@
+from polymarket.errors import UnexpectedResponseError, UserInputError
+
+END_CURSOR = "LTE="
+
+
+def validate_cursor(value: str | None) -> str | None:
+    if value is None:
+        return None
+    if not value:
+        raise UserInputError("cursor must be a non-empty string when provided.")
+    return value
+
+
+def next_cursor_or_none(raw: object) -> str | None:
+    if raw is None:
+        return None
+    if not isinstance(raw, str):
+        raise UnexpectedResponseError(
+            f"expected next_cursor to be a string, got {type(raw).__name__}"
+        )
+    if raw == END_CURSOR:
+        return None
+    if not raw:
+        raise UnexpectedResponseError(
+            "expected next_cursor to be non-empty or the END_CURSOR sentinel"
+        )
+    return raw
+
+
+def optional_int(payload: dict[str, object], key: str) -> int | None:
+    if key not in payload:
+        return None
+    value = payload[key]
+    if value is None:
+        return None
+    if isinstance(value, bool) or not isinstance(value, int):
+        raise UnexpectedResponseError(f"expected '{key}' to be an int, got {type(value).__name__}")
+    return value
+
+
+__all__ = ["END_CURSOR", "next_cursor_or_none", "optional_int", "validate_cursor"]

polymarket/_internal/actions/account.py

@@ -0,0 +1,239 @@
+from collections.abc import Sequence
+from typing import cast
+
+from pydantic import TypeAdapter, ValidationError
+
+from polymarket._internal.actions._cursor import (
+    END_CURSOR,
+    next_cursor_or_none,
+    optional_int,
+    validate_cursor,
+)
+from polymarket._internal.request import QueryParamValue
+from polymarket._internal.validation import require_nonempty
+from polymarket.errors import UnexpectedResponseError, UserInputError
+from polymarket.models.clob import (
+    AssetType,
+    BalanceAllowance,
+    ClobTrade,
+    Notification,
+    OpenOrder,
+)
+from polymarket.pagination import Page
+
+_OpenOrdersAdapter = TypeAdapter(tuple[OpenOrder, ...])
+_ClobTradesAdapter = TypeAdapter(tuple[ClobTrade, ...])
+_NotificationsAdapter = TypeAdapter(tuple[Notification, ...])
+
+_VALID_ASSET_TYPES: frozenset[str] = frozenset({"COLLATERAL", "CONDITIONAL"})
+
+
+def _validate_asset_type(asset_type: object) -> None:
+    if asset_type not in _VALID_ASSET_TYPES:
+        raise UserInputError(
+            f"asset_type must be 'COLLATERAL' or 'CONDITIONAL', got {asset_type!r}."
+        )
+
+
+def _add_optional(params: dict[str, QueryParamValue], key: str, value: object) -> None:
+    if value is None:
+        return
+    if not isinstance(value, str | int | float | bool):
+        raise UserInputError(f"{key} must be a primitive, got {type(value).__name__}.")
+    params[key] = value
+
+
+def build_closed_only_mode_request() -> tuple[str, dict[str, str]]:
+    return "/auth/ban-status/closed-only", {}
+
+
+def parse_closed_only_mode(data: object) -> bool:
+    if not isinstance(data, dict):
+        raise UnexpectedResponseError("closed-only mode response did not match expected shape")
+    raw = cast(dict[str, object], data).get("closed_only")
+    if not isinstance(raw, bool):
+        raise UnexpectedResponseError(
+            f"closed-only mode response 'closed_only' must be a bool, got {type(raw).__name__}"
+        )
+    return raw
+
+
+def build_list_open_orders_request(
+    *,
+    token_id: str | None = None,
+    id: str | None = None,
+    market: str | None = None,
+    cursor: str | None = None,
+) -> tuple[str, dict[str, QueryParamValue]]:
+    params: dict[str, QueryParamValue] = {}
+    if token_id is not None:
+        _add_optional(params, "asset_id", require_nonempty("token_id", token_id))
+    if id is not None:
+        _add_optional(params, "id", require_nonempty("id", id))
+    if market is not None:
+        _add_optional(params, "market", require_nonempty("market", market))
+    validated_cursor = validate_cursor(cursor)
+    if validated_cursor is not None:
+        _add_optional(params, "next_cursor", validated_cursor)
+    return "/data/orders", params
+
+
+def parse_open_orders_page(data: object) -> Page[OpenOrder]:
+    if not isinstance(data, dict):
+        raise UnexpectedResponseError("open orders response did not match expected shape")
+    payload = cast(dict[str, object], data)
+    try:
+        items = _OpenOrdersAdapter.validate_python(payload.get("data"))
+    except ValidationError as error:
+        raise UnexpectedResponseError("open orders response items malformed") from error
+    next_cursor = next_cursor_or_none(payload.get("next_cursor"))
+    return Page(
+        items=items,
+        has_more=next_cursor is not None,
+        next_cursor=next_cursor,
+        total_count=optional_int(payload, "count"),
+    )
+
+
+def build_get_order_request(*, order_id: str) -> tuple[str, dict[str, str]]:
+    validated = require_nonempty("order_id", order_id)
+    return f"/data/order/{validated}", {}
+
+
+def parse_open_order(data: object) -> OpenOrder:
+    return OpenOrder.parse_response(data)
+
+
+def build_list_account_trades_request(
+    *,
+    token_id: str | None = None,
+    id: str | None = None,
+    market: str | None = None,
+    maker_address: str | None = None,
+    after: str | None = None,
+    before: str | None = None,
+    cursor: str | None = None,
+) -> tuple[str, dict[str, QueryParamValue]]:
+    params: dict[str, QueryParamValue] = {}
+    if token_id is not None:
+        _add_optional(params, "asset_id", require_nonempty("token_id", token_id))
+    if id is not None:
+        _add_optional(params, "id", require_nonempty("id", id))
+    if market is not None:
+        _add_optional(params, "market", require_nonempty("market", market))
+    if maker_address is not None:
+        _add_optional(params, "maker_address", require_nonempty("maker_address", maker_address))
+    if after is not None:
+        _add_optional(params, "after", require_nonempty("after", after))
+    if before is not None:
+        _add_optional(params, "before", require_nonempty("before", before))
+    validated_cursor = validate_cursor(cursor)
+    if validated_cursor is not None:
+        _add_optional(params, "next_cursor", validated_cursor)
+    return "/data/trades", params
+
+
+def parse_account_trades_page(data: object) -> Page[ClobTrade]:
+    if not isinstance(data, dict):
+        raise UnexpectedResponseError("account trades response did not match expected shape")
+    payload = cast(dict[str, object], data)
+    try:
+        items = _ClobTradesAdapter.validate_python(payload.get("data"))
+    except ValidationError as error:
+        raise UnexpectedResponseError("account trades response items malformed") from error
+    next_cursor = next_cursor_or_none(payload.get("next_cursor"))
+    return Page(
+        items=items,
+        has_more=next_cursor is not None,
+        next_cursor=next_cursor,
+        total_count=optional_int(payload, "count"),
+    )
+
+
+def build_notifications_request(*, signature_type: int) -> tuple[str, dict[str, QueryParamValue]]:
+    return "/notifications", {"signature_type": signature_type}
+
+
+def parse_notifications(data: object) -> tuple[Notification, ...]:
+    try:
+        return _NotificationsAdapter.validate_python(data)
+    except ValidationError as error:
+        raise UnexpectedResponseError(
+            "notifications response did not match expected shape"
+        ) from error
+
+
+def build_drop_notifications_request(
+    *, ids: Sequence[int | str], signature_type: int
+) -> tuple[str, dict[str, QueryParamValue]]:
+    if isinstance(ids, str | bytes):
+        raise UserInputError("ids must be a sequence of notification ids, not a single string.")
+    if not ids:
+        raise UserInputError("ids must be a non-empty sequence.")
+    validated: list[str] = []
+    for entry in cast(Sequence[object], ids):
+        if isinstance(entry, bool) or not isinstance(entry, int | str):
+            raise UserInputError(f"ids entry must be an int or string, got {type(entry).__name__}.")
+        if isinstance(entry, str):
+            validated.append(require_nonempty("notification id", entry))
+        else:
+            validated.append(str(entry))
+    return "/notifications", {
+        "ids": ",".join(validated),
+        "signature_type": signature_type,
+    }
+
+
+def build_balance_allowance_request(
+    *,
+    asset_type: AssetType,
+    token_id: str | None,
+    signature_type: int,
+) -> tuple[str, dict[str, QueryParamValue]]:
+    _validate_asset_type(asset_type)
+    params: dict[str, QueryParamValue] = {
+        "asset_type": asset_type,
+        "signature_type": signature_type,
+    }
+    if token_id is not None:
+        params["token_id"] = require_nonempty("token_id", token_id)
+    return "/balance-allowance", params
+
+
+def parse_balance_allowance(data: object) -> BalanceAllowance:
+    return BalanceAllowance.parse_response(data)
+
+
+def build_update_balance_allowance_request(
+    *,
+    asset_type: AssetType,
+    token_id: str | None,
+    signature_type: int,
+) -> tuple[str, dict[str, QueryParamValue]]:
+    _validate_asset_type(asset_type)
+    params: dict[str, QueryParamValue] = {
+        "asset_type": asset_type,
+        "signature_type": signature_type,
+    }
+    if token_id is not None:
+        params["token_id"] = require_nonempty("token_id", token_id)
+    return "/balance-allowance/update", params
+
+
+__all__ = [
+    "END_CURSOR",
+    "build_balance_allowance_request",
+    "build_closed_only_mode_request",
+    "build_drop_notifications_request",
+    "build_get_order_request",
+    "build_list_account_trades_request",
+    "build_list_open_orders_request",
+    "build_notifications_request",
+    "build_update_balance_allowance_request",
+    "parse_account_trades_page",
+    "parse_balance_allowance",
+    "parse_closed_only_mode",
+    "parse_notifications",
+    "parse_open_order",
+    "parse_open_orders_page",
+]