polymarket-apis 0.2.6__py3-none-any.whl → 0.3.1__py3-none-any.whl

polymarket_apis/clients/data_client.py

@@ -25,26 +25,26 @@ class PolymarketDataClient:
         return urljoin(self.base_url, endpoint)
 
     def get_positions(
-            self,
-            user: str,
-            condition_id: Optional[Union[str, list[str]]] = None,
-            size_threshold: float = 1.0,
-            redeemable: Optional[bool] = None,
-            mergeable: Optional[bool] = None,
-            title: Optional[str] = None,
-            limit: int = 100,
-            offset: int = 0,
-            sort_by: Literal[
-                "TOKENS",
-                "CURRENT",
-                "INITIAL",
-                "CASHPNL",
-                "PERCENTPNL",
-                "TITLE",
-                "RESOLVING",
-                "PRICE",
-            ] = "TOKENS",
-            sort_direction: Literal["ASC", "DESC"] = "DESC",
+        self,
+        user: str,
+        condition_id: Optional[Union[str, list[str]]] = None,
+        size_threshold: float = 1.0,
+        redeemable: Optional[bool] = None,
+        mergeable: Optional[bool] = None,
+        title: Optional[str] = None,
+        limit: int = 100,
+        offset: int = 0,
+        sort_by: Literal[
+            "TOKENS",
+            "CURRENT",
+            "INITIAL",
+            "CASHPNL",
+            "PERCENTPNL",
+            "TITLE",
+            "RESOLVING",
+            "PRICE",
+        ] = "TOKENS",
+        sort_direction: Literal["ASC", "DESC"] = "DESC",
     ) -> list[Position]:
         params = {
             "user": user,
@@ -72,17 +72,17 @@ class PolymarketDataClient:
         return [Position(**pos) for pos in response.json()]
 
     def get_trades(
-            self,
-            limit: int = 100,
-            offset: int = 0,
-            taker_only: bool = True,
-            filter_type: Optional[Literal["CASH", "TOKENS"]] = None,
-            filter_amount: Optional[float] = None,
-            condition_id: Optional[str] = None,
-            user: Optional[str] = None,
-            side: Optional[Literal["BUY", "SELL"]] = None,
+        self,
+        limit: int = 100,
+        offset: int = 0,
+        taker_only: bool = True,
+        filter_type: Optional[Literal["CASH", "TOKENS"]] = None,
+        filter_amount: Optional[float] = None,
+        condition_id: Optional[str] = None,
+        user: Optional[str] = None,
+        side: Optional[Literal["BUY", "SELL"]] = None,
     ) -> list[Trade]:
-        params = {
+        params: dict[str, int | bool | str | float] = {
             "limit": min(limit, 500),
             "offset": offset,
             "takerOnly": taker_only,
@@ -103,17 +103,24 @@ class PolymarketDataClient:
         return [Trade(**trade) for trade in response.json()]
 
     def get_activity(
-            self,
-            user: str,
-            limit: int = 100,
-            offset: int = 0,
-            condition_id: Optional[Union[str, list[str]]] = None,
-            type: Optional[Union[Literal["TRADE", "SPLIT", "MERGE", "REDEEM", "REWARD", "CONVERSION"], list[Literal["TRADE", "SPLIT", "MERGE", "REDEEM", "REWARD", "CONVERSION"]]]] = None,
-            start: Optional[datetime] = None,
-            end: Optional[datetime] = None,
-            side: Optional[Literal["BUY", "SELL"]] = None,
-            sort_by: Literal["TIMESTAMP", "TOKENS", "CASH"] = "TIMESTAMP",
-            sort_direction: Literal["ASC", "DESC"] = "DESC",
+        self,
+        user: str,
+        limit: int = 100,
+        offset: int = 0,
+        condition_id: Optional[Union[str, list[str]]] = None,
+        type: Optional[
+            Union[
+                Literal["TRADE", "SPLIT", "MERGE", "REDEEM", "REWARD", "CONVERSION"],
+                list[
+                    Literal["TRADE", "SPLIT", "MERGE", "REDEEM", "REWARD", "CONVERSION"]
+                ],
+            ]
+        ] = None,
+        start: Optional[datetime] = None,
+        end: Optional[datetime] = None,
+        side: Optional[Literal["BUY", "SELL"]] = None,
+        sort_by: Literal["TIMESTAMP", "TOKENS", "CASH"] = "TIMESTAMP",
+        sort_direction: Literal["ASC", "DESC"] = "DESC",
     ) -> list[Activity]:
         params = {"user": user, "limit": min(limit, 500), "offset": offset}
         if isinstance(condition_id, str):
@@ -140,22 +147,20 @@ class PolymarketDataClient:
         return [Activity(**activity) for activity in response.json()]
 
     def get_holders(
-            self,
-            condition_id: str,
-            limit: int = 20,
+        self,
+        condition_id: str,
+        limit: int = 20,
     ) -> list[HolderResponse]:
         """Takes in a condition_id and returns a list of at most 20 top holders for each corresponding token_id."""
         params = {"market": condition_id, "limit": limit}
         response = self.client.get(self._build_url("/holders"), params=params)
         response.raise_for_status()
-        return [
-            HolderResponse(**holder_data) for holder_data in response.json()
-        ]
+        return [HolderResponse(**holder_data) for holder_data in response.json()]
 
     def get_value(
-            self,
-            user: str,
-            condition_id: Optional[Union[str, list[str]]] = None,
+        self,
+        user: str,
+        condition_ids: Optional[Union[str, list[str]]] = None,
     ) -> ValueResponse:
         """
         Get the current value of a user's position in a set of markets.
@@ -166,10 +171,10 @@ class PolymarketDataClient:
             - list[str] --> sum of the values of positions.
         """
         params = {"user": user}
-        if isinstance(condition_id, str):
-            params["market"] = condition_id
-        if isinstance(condition_id, list):
-            params["market"] = ",".join(condition_id)
+        if isinstance(condition_ids, str):
+            params["market"] = condition_ids
+        if isinstance(condition_ids, list):
+            params["market"] = ",".join(condition_ids)
 
         response = self.client.get(self._build_url("/value"), params=params)
         response.raise_for_status()
@@ -178,10 +183,10 @@ class PolymarketDataClient:
     # website endpoints
 
     def get_pnl(
-            self,
-            user: EthAddress,
-            period: Literal["all", "1m", "1w", "1d"] = "all",
-            frequency: Literal["1h", "3h", "12h", "1d"] = "1h",
+        self,
+        user: EthAddress,
+        period: Literal["all", "1m", "1w", "1d"] = "all",
+        frequency: Literal["1h", "3h", "12h", "1d"] = "1h",
     ) -> list[TimeseriesPoint]:
         """Get a user's PnL timeseries in the last day, week, month or all with a given frequency."""
         params = {
@@ -190,22 +195,36 @@ class PolymarketDataClient:
             "fidelity": frequency,
         }
 
-        response = self.client.get("https://user-pnl-api.polymarket.com/user-pnl", params=params)
+        response = self.client.get(
+            "https://user-pnl-api.polymarket.com/user-pnl", params=params
+        )
         response.raise_for_status()
         return [TimeseriesPoint(**point) for point in response.json()]
 
-    def get_user_metric(self, user: EthAddress, metric: Literal["profit", "volume"] = "profit", window: Literal["1d", "7d", "30d", "all"] = "all"):
+    def get_user_metric(
+        self,
+        user: EthAddress,
+        metric: Literal["profit", "volume"] = "profit",
+        window: Literal["1d", "7d", "30d", "all"] = "all",
+    ):
         """Get a user's overall profit or volume in the last day, week, month or all."""
         params = {
             "address": user,
             "window": window,
             "limit": 1,
         }
-        response = self.client.get("https://lb-api.polymarket.com/" + metric, params=params)
+        response = self.client.get(
+            "https://lb-api.polymarket.com/" + metric, params=params
+        )
         response.raise_for_status()
         return UserMetric(**response.json()[0])
 
-    def get_leaderboard_user_rank(self, user: EthAddress, metric: Literal["profit", "volume"] = "profit", window: Literal["1d", "7d", "30d", "all"] = "all"):
+    def get_leaderboard_user_rank(
+        self,
+        user: EthAddress,
+        metric: Literal["profit", "volume"] = "profit",
+        window: Literal["1d", "7d", "30d", "all"] = "all",
+    ):
         """Get a user's rank on the leaderboard by profit or volume."""
         params = {
             "address": user,
@@ -216,17 +235,23 @@ class PolymarketDataClient:
         response.raise_for_status()
         return UserRank(**response.json()[0])
 
-    def get_leaderboard_top_users(self, metric: Literal["profit", "volume"] = "profit", window: Literal["1d", "7d", "30d", "all"] = "all", limit: int = 100):
+    def get_leaderboard_top_users(
+        self,
+        metric: Literal["profit", "volume"] = "profit",
+        window: Literal["1d", "7d", "30d", "all"] = "all",
+        limit: int = 100,
+    ):
         """Get the leaderboard of the top at most 100 users by profit or volume."""
         params = {
             "window": window,
             "limit": limit,
         }
-        response = self.client.get("https://lb-api.polymarket.com/" + metric, params=params)
+        response = self.client.get(
+            "https://lb-api.polymarket.com/" + metric, params=params
+        )
         response.raise_for_status()
         return [UserMetric(**user) for user in response.json()]
 
-
     def __enter__(self):
         return self
 

polymarket_apis/clients/gamma_client.py

@@ -25,28 +25,28 @@ class PolymarketGammaClient:
         return urljoin(self.base_url, endpoint)
 
     def get_markets(
-            self,
-            limit: Optional[int] = None,
-            offset: Optional[int] = None,
-            order: Optional[str] = None,
-            ascending: bool = True,
-            ids: Optional[list[int]] = None,
-            slugs: Optional[list[str]] = None,
-            archived: Optional[bool] = None,
-            active: Optional[bool] = None,
-            closed: Optional[bool] = None,
-            token_ids: Optional[list[str]] = None,
-            condition_ids: Optional[list[str]] = None,
-            liquidity_num_min: Optional[float] = None,
-            liquidity_num_max: Optional[float] = None,
-            volume_num_min: Optional[float] = None,
-            volume_num_max: Optional[float] = None,
-            start_date_min: Optional[datetime] = None,
-            start_date_max: Optional[datetime] = None,
-            end_date_min: Optional[datetime] = None,
-            end_date_max: Optional[datetime] = None,
-            tag_id: Optional[int] = None,
-            related_tags: Optional[bool] = False,
+        self,
+        limit: Optional[int] = None,
+        offset: Optional[int] = None,
+        order: Optional[str] = None,
+        ascending: bool = True,
+        archived: Optional[bool] = None,
+        active: Optional[bool] = None,
+        closed: Optional[bool] = None,
+        slugs: Optional[list[str]] = None,
+        market_ids: Optional[list[int]] = None,
+        token_ids: Optional[list[str]] = None,
+        condition_ids: Optional[list[str]] = None,
+        tag_id: Optional[int] = None,
+        related_tags: Optional[bool] = False,
+        liquidity_num_min: Optional[float] = None,
+        liquidity_num_max: Optional[float] = None,
+        volume_num_min: Optional[float] = None,
+        volume_num_max: Optional[float] = None,
+        start_date_min: Optional[datetime] = None,
+        start_date_max: Optional[datetime] = None,
+        end_date_min: Optional[datetime] = None,
+        end_date_max: Optional[datetime] = None,
     ) -> list[GammaMarket]:
         params = {}
         if limit:
@@ -56,8 +56,6 @@ class PolymarketGammaClient:
         if order:
             params["order"] = order
             params["ascending"] = ascending
-        if ids:
-            params["id"] = ids
         if slugs:
             params["slug"] = slugs
         if archived is not None:
@@ -66,6 +64,8 @@ class PolymarketGammaClient:
             params["active"] = active
         if closed is not None:
             params["closed"] = closed
+        if market_ids:
+            params["id"] = market_ids
         if token_ids:
             params["clob_token_ids"] = token_ids
         if condition_ids:
@@ -102,28 +102,28 @@ class PolymarketGammaClient:
         return GammaMarket(**response.json())
 
     def get_events(
-            self,
-            limit: Optional[int] = None,
-            offset: Optional[int] = None,
-            order: Optional[str] = None,
-            ascending: bool = True,
-            event_ids: Optional[Union[str, list[str]]] = None,
-            slugs: Optional[list[str]] = None,
-            archived: Optional[bool] = None,
-            active: Optional[bool] = None,
-            closed: Optional[bool] = None,
-            liquidity_min: Optional[float] = None,
-            liquidity_max: Optional[float] = None,
-            volume_min: Optional[float] = None,
-            volume_max: Optional[float] = None,
-            start_date_min: Optional[datetime] = None,
-            start_date_max: Optional[datetime] = None,
-            end_date_min: Optional[datetime] = None,
-            end_date_max: Optional[datetime] = None,
-            tag: Optional[str] = None,
-            tag_id: Optional[int] = None,
-            tag_slug: Optional[str] = None,
-            related_tags: bool = False,
+        self,
+        limit: Optional[int] = None,
+        offset: Optional[int] = None,
+        order: Optional[str] = None,
+        ascending: bool = True,
+        event_ids: Optional[Union[str, list[str]]] = None,
+        slugs: Optional[list[str]] = None,
+        archived: Optional[bool] = None,
+        active: Optional[bool] = None,
+        closed: Optional[bool] = None,
+        liquidity_min: Optional[float] = None,
+        liquidity_max: Optional[float] = None,
+        volume_min: Optional[float] = None,
+        volume_max: Optional[float] = None,
+        start_date_min: Optional[datetime] = None,
+        start_date_max: Optional[datetime] = None,
+        end_date_min: Optional[datetime] = None,
+        end_date_max: Optional[datetime] = None,
+        tag: Optional[str] = None,
+        tag_id: Optional[int] = None,
+        tag_slug: Optional[str] = None,
+        related_tags: bool = False,
     ) -> list[Event]:
         params = {}
         if limit:
@@ -178,26 +178,26 @@ class PolymarketGammaClient:
         return Event(**response.json())
 
     def get_all_events(
-            self,
-            order: Optional[str] = None,
-            ascending: bool = True,
-            event_ids: Optional[Union[str, list[str]]] = None,
-            slugs: Optional[list[str]] = None,
-            archived: Optional[bool] = None,
-            active: Optional[bool] = None,
-            closed: Optional[bool] = None,
-            liquidity_min: Optional[float] = None,
-            liquidity_max: Optional[float] = None,
-            volume_min: Optional[float] = None,
-            volume_max: Optional[float] = None,
-            start_date_min: Optional[datetime] = None,
-            start_date_max: Optional[datetime] = None,
-            end_date_min: Optional[datetime] = None,
-            end_date_max: Optional[datetime] = None,
-            tag: Optional[str] = None,
-            tag_id: Optional[int] = None,
-            tag_slug: Optional[str] = None,
-            related_tags: bool = False,
+        self,
+        order: Optional[str] = None,
+        ascending: bool = True,
+        event_ids: Optional[Union[str, list[str]]] = None,
+        slugs: Optional[list[str]] = None,
+        archived: Optional[bool] = None,
+        active: Optional[bool] = None,
+        closed: Optional[bool] = None,
+        liquidity_min: Optional[float] = None,
+        liquidity_max: Optional[float] = None,
+        volume_min: Optional[float] = None,
+        volume_max: Optional[float] = None,
+        start_date_min: Optional[datetime] = None,
+        start_date_max: Optional[datetime] = None,
+        end_date_min: Optional[datetime] = None,
+        end_date_max: Optional[datetime] = None,
+        tag: Optional[str] = None,
+        tag_id: Optional[int] = None,
+        tag_slug: Optional[str] = None,
+        related_tags: bool = False,
     ) -> list[Event]:
         offset = 0
         events = []
@@ -236,20 +236,39 @@ class PolymarketGammaClient:
         return events
 
     def search_events(
-            self,
-            query: str,
-            active: bool = True,
-            status: Optional[Literal["active", "resolved"]] = "active",
-            sort: Literal["volume", "volume_24hr", "liquidity", "start_date", "end_date", "competitive"] = "volume_24hr",
-            page: int = 1,
-            limit_per_type: int = 50, # max is 50
+        self,
+        query: str,
+        active: bool = True,
+        status: Optional[Literal["active", "resolved"]] = "active",
+        sort: Literal[
+            "volume",
+            "volume_24hr",
+            "liquidity",
+            "start_date",
+            "end_date",
+            "competitive",
+        ] = "volume_24hr",
+        page: int = 1,
+        limit_per_type: int = 50,  # max is 50
+        presets: Optional[
+            Literal["EventsHybrid", "EventsTitle"]
+            | list[Literal["EventsHybrid", "EventsTitle"]]
+        ] = None,
     ) -> EventList:
         """Search for events by query. Should emulate the website search function."""
-        params = {"q": query,"page": page, "limit_per_type": limit_per_type, "events_status": status, "active": active, "presets": "EventsTitle"}
+        params = {
+            "q": query,
+            "page": page,
+            "limit_per_type": limit_per_type,
+            "events_status": status,
+            "active": active,
+        }
         if sort:
             params["sort"] = sort
         if sort == "end_date":
             params["ascending"] = "true"
+        if presets:
+            params["presets"] = presets
         response = self.client.get(self._build_url("/public-search"), params=params)
         response.raise_for_status()
         return EventList(**response.json())
@@ -299,7 +318,9 @@ class PolymarketGammaClient:
             for source in citations:
                 print(f"- {source.get('url', 'Unknown URL')}")
 
-    def grok_election_market_explanation(self, candidate_name: str, election_title: str):
+    def grok_election_market_explanation(
+        self, candidate_name: str, election_title: str
+    ):
         text = f"Provide candidate information for {candidate_name} in the {election_title} on Polymarket."
         json_payload = {
             "id": generate_random_id(),

polymarket_apis/clients/graphql_client.py

@@ -0,0 +1,60 @@
+from typing import Literal
+
+from gql import Client, gql
+from gql.transport.httpx import HTTPXAsyncTransport, HTTPXTransport
+
+from ..utilities.config import GRAPHQL_ENDPOINTS
+
+
+class PolymarketGraphQLClient:
+    """Synchronous GraphQL client for Polymarket subgraphs."""
+
+    def __init__(
+        self,
+        endpoint_name: Literal[
+            "activity_subgraph",
+            "fpmm_subgraph",
+            "open_interest_subgraph",
+            "orderbook_subgraph",
+            "pnl_subgraph",
+            "positions_subgraph",
+            "sports_oracle_subgraph",
+            "wallet_subgraph",
+        ],
+    ) -> None:
+        endpoint_url = GRAPHQL_ENDPOINTS[endpoint_name]
+        self.transport = HTTPXTransport(url=endpoint_url)
+        self.client = Client(
+            transport=self.transport, fetch_schema_from_transport=False
+        )
+
+    def query(self, query_string: str) -> dict:
+        with self.client as session:
+            return session.execute(gql(query_string))
+
+
+class AsyncPolymarketGraphQLClient:
+    """Asynchronous GraphQL client for Polymarket subgraphs."""
+
+    def __init__(
+        self,
+        endpoint_name: Literal[
+            "activity_subgraph",
+            "fpmm_subgraph",
+            "open_interest_subgraph",
+            "orderbook_subgraph",
+            "pnl_subgraph",
+            "positions_subgraph",
+            "sports_oracle_subgraph",
+            "wallet_subgraph",
+        ],
+    ) -> None:
+        endpoint_url = GRAPHQL_ENDPOINTS[endpoint_name]
+        self.transport = HTTPXAsyncTransport(url=endpoint_url)
+        self.client = Client(
+            transport=self.transport, fetch_schema_from_transport=False
+        )
+
+    async def query(self, query_string: str) -> dict:
+        async with self.client as session:
+            return await session.execute(gql(query_string))