polymarket-apis 0.2.2__py3-none-any.whl → 0.2.4__py3-none-any.whl

polymarket_apis/clients/clob_client.py

@@ -48,6 +48,7 @@ from ..utilities.endpoints import (
     DELETE_API_KEY,
     DERIVE_API_KEY,
     GET_API_KEYS,
+    GET_FEE_RATE,
     GET_LAST_TRADE_PRICE,
     GET_LAST_TRADES_PRICES,
     GET_MARKET,
@@ -70,6 +71,7 @@ from ..utilities.endpoints import (
     TRADES,
 )
 from ..utilities.exceptions import (
+    InvalidFeeRateError,
     InvalidPriceError,
     InvalidTickSizeError,
     LiquidityError,
@@ -111,6 +113,7 @@ class PolymarketClobClient:
         # local cache
         self.__tick_sizes = {}
         self.__neg_risk = {}
+        self.__fee_rates = {}
 
     def _build_url(self, endpoint: str) -> str:
         return urljoin(self.base_url, endpoint)
@@ -183,6 +186,18 @@ class PolymarketClobClient:
 
         return self.__neg_risk[token_id]
 
+    def get_fee_rate_bps(self, token_id: str) -> int:
+        if token_id in self.__fee_rates:
+            return self.__fee_rates[token_id]
+
+        params = {"token_id": token_id}
+        response = self.client.get(self._build_url(GET_FEE_RATE), params=params)
+        response.raise_for_status()
+        fee_rate = response.json().get("base_fee") or 0
+        self.__fee_rates[token_id] = fee_rate
+
+        return fee_rate
+
     def __resolve_tick_size(
             self, token_id: str, tick_size: TickSize = None,
     ) -> TickSize:
@@ -195,6 +210,17 @@ class PolymarketClobClient:
             tick_size = min_tick_size
         return tick_size
 
+    def __resolve_fee_rate(
+            self, token_id: str, user_fee_rate: Optional[int] = None,
+    ) -> int:
+        market_fee_rate_bps = self.get_fee_rate_bps(token_id)
+        # If both fee rate on the market and the user supplied fee rate are non-zero, validate that they match
+        # else return the market fee rate
+        if market_fee_rate_bps > 0 and user_fee_rate is not None and user_fee_rate > 0 and user_fee_rate != market_fee_rate_bps:
+            msg = f"invalid user provided fee rate: ({user_fee_rate}), fee rate for the market must be {market_fee_rate_bps}"
+            raise InvalidFeeRateError(msg)
+        return market_fee_rate_bps
+
     def get_midpoint(self, token_id: str) -> Midpoint:
         """Get the mid-market price for the given token."""
         params = {"token_id": token_id}
@@ -406,6 +432,10 @@ class PolymarketClobClient:
             else self.get_neg_risk(order_args.token_id)
         )
 
+        # fee rate
+        fee_rate_bps = self.__resolve_fee_rate(order_args.token_id, order_args.fee_rate_bps)
+        order_args.fee_rate_bps = fee_rate_bps
+
         return self.builder.create_order(
             order_args,
             CreateOrderOptions(
@@ -416,7 +446,7 @@ class PolymarketClobClient:
 
     def post_order(self, order: SignedOrder, order_type: OrderType = OrderType.GTC) -> Optional[OrderPostResponse]:
         """Posts a SignedOrder."""
-        body = order_to_json(order, self.creds.api_key, order_type)
+        body = order_to_json(order, self.creds.key, order_type)
         headers = create_level_2_headers(
             self.signer,
             self.creds,
@@ -444,7 +474,7 @@ class PolymarketClobClient:
 
     def post_orders(self, args: list[PostOrdersArgs]):
         """Posts multiple SignedOrders at once."""
-        body = [order_to_json(arg.order, self.creds.api_key, arg.order_type) for arg in args]
+        body = [order_to_json(arg.order, self.creds.key, arg.order_type) for arg in args]
         headers = create_level_2_headers(
             self.signer,
             self.creds,
@@ -526,6 +556,10 @@ class PolymarketClobClient:
             else self.get_neg_risk(order_args.token_id)
         )
 
+        # fee rate
+        fee_rate_bps = self.__resolve_fee_rate(order_args.token_id, order_args.fee_rate_bps)
+        order_args.fee_rate_bps = fee_rate_bps
+
         return self.builder.create_market_order(
             order_args,
             CreateOrderOptions(
@@ -614,7 +648,7 @@ class PolymarketClobClient:
 
     def get_trades(
             self,
-            condition_id: Keccak256 | None = None,
+            condition_id: Optional[Keccak256] = None,
             token_id: Optional[str] = None,
             trade_id: Optional[str] = None,
             before: Optional[datetime] = None,

polymarket_apis/clients/gamma_client.py

@@ -1,11 +1,19 @@
 import json
+import random
+import string
 from datetime import datetime
-from typing import Optional, Union
+from typing import Literal, Optional, Union
 from urllib.parse import urljoin
 
 import httpx
 
-from ..types.gamma_types import Event, GammaMarket, QueryEvent
+from ..types.gamma_types import Event, EventList, GammaMarket
+
+
+def generate_random_id(length=16):
+    characters = string.ascii_letters + string.digits
+    random_id = "".join(random.choices(characters, k=length))
+    return random_id
 
 
 class PolymarketGammaClient:
@@ -227,82 +235,94 @@ class PolymarketGammaClient:
 
         return events
 
-    def search_events(self, query: str, active: bool = True) -> list[QueryEvent]:
-        """Search for events by query."""
-        params = {"q": query, "events_status": "active" if active else "resolved"}
-        response = self.client.get("https://polymarket.com/api/events/global", params=params)
+    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
+    ) -> 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"}
+        if sort:
+            params["sort"] = sort
+        if sort == "end_date":
+            params["ascending"] = "true"
+        response = self.client.get(self._build_url("/public-search"), params=params)
         response.raise_for_status()
-        return [QueryEvent(**event) for event in response.json()["events"]]
+        return EventList(**response.json())
 
-    def grok_market_summary(self, condition_id: str):
-        market = self.get_markets(condition_ids=[condition_id])[0]
+    def grok_event_summary(self, event_slug: str):
+        json_payload = {
+            "id": generate_random_id(),
+            "messages": [{"role": "user", "content": "", "parts": []}],
+        }
 
         params = {
-            "marketName": market.group_item_title,
-            "eventTitle": market.question,
-            "odds": market.outcome_prices[0],
-            "marketDescription": market.description,
-            "isNegRisk": market.neg_risk,
+            "prompt": event_slug,
         }
 
-        with self.client.stream(method="GET", url="https://polymarket.com/api/grok/market-explanation", params=params) as stream:
+        with self.client.stream(
+            method="POST",
+            url="https://polymarket.com/api/grok/event-summary",
+            params=params,
+            json=json_payload,
+        ) as stream:
             messages = []
             citations = []
-            for line in stream.iter_lines():
-                if line:
-                    line_str = line
-                    if line_str.startswith("data: "):
-                        json_part = line_str[len("data: "):]
-                        try:
-                            data = json.loads(json_part)
-                            # Extract content if present
-                            content = data.get("choices", [{}])[0].get("delta", {}).get("content", "")
-                            if content:
-                                messages.append(content)
-                                print(content, end="")  # Stream content
-                            # Extract citations if present
-                            if "citations" in data:
-                                citations.extend(data["citations"])
-                        except json.JSONDecodeError:
-                            pass
+            seen_urls = set()
+
+            for line_bytes in stream.iter_lines():
+                line = (
+                    line_bytes.decode() if isinstance(line_bytes, bytes) else line_bytes
+                )
+                if line.startswith("__SOURCES__:"):
+                    sources_json_str = line[len("__SOURCES__:") :]
+                    try:
+                        sources_obj = json.loads(sources_json_str)
+                        for source in sources_obj.get("sources", []):
+                            url = source.get("url")
+                            if url and url not in seen_urls:
+                                citations.append(source)
+                                seen_urls.add(url)
+                    except json.JSONDecodeError:
+                        pass
+                else:
+                    messages.append(line)
+                    print(line, end="")  # or handle message text as needed
 
-        # After streaming, print citations if any
+        # After reading streamed lines:
         if citations:
-            print("\n\nCitations:")
-            for cite in citations:
-                print(f"- {cite}")
+            print("\n\nSources:")
+            for source in citations:
+                print(f"- {source.get('url', 'Unknown URL')}")
 
-    def grok_event_summary(self, event_slug: str):
-        params = {
-            "prompt": event_slug,
+    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(),
+            "messages": [
+                {
+                    "role": "user",
+                    "content": text,
+                    "parts": [{"type": "text", "text": text}],
+                },
+            ],
         }
 
-        with self.client.stream(method="GET", url="https://polymarket.com/api/grok/event-summary", params=params) as stream:
-            messages = []
-            citations = []
-            for line in stream.iter_lines():
-                if line:
-                    line_str = line
-                    if line_str.startswith("data: "):
-                        json_part = line_str[len("data: "):]
-                        try:
-                            data = json.loads(json_part)
-                            # Extract content if present
-                            content = data.get("choices", [{}])[0].get("delta", {}).get("content", "")
-                            if content:
-                                messages.append(content)
-                                print(content, end="")  # Stream content
-                            # Extract citations if present
-                            if "citations" in data:
-                                citations.extend(data["citations"])
-                        except json.JSONDecodeError:
-                            pass
+        response = self.client.post(
+            url="https://polymarket.com/api/grok/election-market-explanation",
+            json=json_payload,
+        )
+        response.raise_for_status()
 
-        # After streaming, print citations if any
-        if citations:
-            print("\n\nCitations:")
-            for cite in citations:
-                print(f"- {cite}")
+        parts = [p.strip() for p in response.text.split("**") if p.strip()]
+        for i, part in enumerate(parts):
+            if ":" in part and i != 0:
+                print()
+            print(part)
 
     def __enter__(self):
         return self

polymarket_apis/clients/graphql_client.py

@@ -0,0 +1,182 @@
+from typing import Literal, Optional
+
+from gql import Client, gql
+from gql.transport.httpx import HTTPXAsyncTransport
+from graphql import GraphQLInputObjectType, GraphQLObjectType
+
+from ..utilities.config import GRAPHQL_ENDPOINTS
+
+
+class PolymarketGraphQLClient:
+    def __init__(self,
+                endpoint_name: Literal[
+                    "activity_subgraph",
+                    "fpmm_subgraph",
+                    "open_interest_subgraph",
+                    "orderbook_subgraph",
+                    "pnl_subgraph",
+                    "positions_subgraph",
+                    "sports_oracle_subgraph",
+                    "wallet_subgraph",
+                ]):
+        if endpoint_name not in GRAPHQL_ENDPOINTS:
+            msg = f"Invalid endpoint name: {endpoint_name}. Must be one of {list(GRAPHQL_ENDPOINTS.keys())}"
+            raise ValueError(msg)
+        endpoint_url = GRAPHQL_ENDPOINTS[endpoint_name]
+        self.transport = HTTPXAsyncTransport(url=endpoint_url)
+        self.client = Client(transport=self.transport, fetch_schema_from_transport=True)
+        self.schema = None
+        self.object_types = []
+        self.query_fields = []
+        self.subscription_fields = []
+        self.filter_input_types = []
+
+    async def _init_schema(self):
+        async with self.client as session:
+            self.schema = session.schema
+
+    async def _get_query_fields(self):
+        if self.query_fields:
+            return self.query_fields
+        if not self.schema:
+            await self._init_schema()
+        self.query_fields = [field for field in self.schema.type_map["Query"].fields if not field.startswith("_")]
+
+        return self.query_fields
+
+    async def _get_subscription_fields(self):
+        if self.subscription_fields:
+            return self.subscription_fields
+        if not self.schema:
+            await self._init_schema()
+        if "Subscription" in self.schema.type_map:
+            self.subscription_fields = [field for field in self.schema.type_map["Subscription"].fields if not field.startswith("_")]
+        else:
+            self.subscription_fields = []
+        return self.subscription_fields
+
+    async def _get_object_types(self):
+        if self.object_types:
+            return self.object_types
+        if not self.schema:
+            await self._init_schema()
+        for object_name, object in self.schema.type_map.items():
+            if type(object) is GraphQLObjectType and not object_name.startswith("_"):
+                self.object_types.append(object_name)
+        return self.object_types
+
+    async def _get_filter_input_types(self):
+        if self.filter_input_types:
+            return self.filter_input_types
+        if not self.schema:
+            await self._init_schema()
+        for object_name, object in self.schema.type_map.items():
+            if isinstance(object, GraphQLInputObjectType) and not object_name.startswith("_"):
+                self.filter_input_types.append(object_name)
+        return self.filter_input_types
+
+    async def list_queries(self):
+        if self.query_fields:
+            return self.query_fields
+        return await self._get_query_fields()
+
+    async def list_subscriptions(self):
+        if self.subscription_fields:
+            return self.subscription_fields
+        return await self._get_subscription_fields()
+
+    async def list_object_types(self):
+        if self.object_types:
+            return self.object_types
+        return await self._get_object_types()
+
+    async def list_filter_input_types(self):
+        if self.filter_input_types:
+            return self.filter_input_types
+        return await self._get_filter_input_types()
+
+    async def get_fields(self, object_name: str):
+        if self.schema is None:
+            await self._init_schema()
+        if object_name not in self.schema.type_map:
+            msg = "Invalid object name"
+            raise ValueError(msg)
+        return list(self.schema.type_map[object_name].fields.keys())
+
+    async def query(
+        self,
+        endpoint: str,
+        fields: list[str],
+        filters: Optional[dict] = None,
+        relationships: Optional[dict] = None,
+    ):
+        if not self.schema:
+            await self._init_schema()
+        if not self.query_fields:
+            await self._get_query_fields()
+        if not self.object_types:
+            await self._get_object_types()
+
+        if endpoint not in self.query_fields:
+            msg = f"Invalid endpoint: {endpoint}"
+            raise ValueError(msg)
+
+        endpoint_field = self.schema.type_map["Query"].fields[endpoint]
+        required_args = [
+            arg_name for arg_name, arg in endpoint_field.args.items()
+            if arg.type.to_kwargs().get("required", False)
+        ]
+        missing_args = [arg for arg in required_args if not (filters and arg in filters)]
+        if missing_args:
+            msg = f"Missing required argument(s) for '{endpoint}': {', '.join(missing_args)}"
+            raise ValueError(msg)
+
+        def build_selection(fields, relationships):
+            selections = []
+            for field in fields:
+                if relationships and field in relationships:
+                    subfields = relationships[field]
+                    selections.append(f"{field} {{ {' '.join(subfields)} }}")
+                else:
+                    selections.append(field)
+            return " ".join(selections)
+
+        def build_args(filters):
+            """Build GraphQL arguments, handling both simple and complex where clauses."""
+            if not filters:
+                return ""
+
+            arg_strs = []
+            for k, v in filters.items():
+                if k == "where" and isinstance(v, dict):
+                    # Handle complex where clause
+                    where_conditions = []
+                    for where_key, where_value in v.items():
+                        if isinstance(where_value, str):
+                            where_conditions.append(f"{where_key}: {where_value}")
+                        else:
+                            where_conditions.append(f"{where_key}: {where_value}")
+                    where_str = "{" + ", ".join(where_conditions) + "}"
+                    arg_strs.append(f"{k}: {where_str}")
+                # Handle simple key-value filters
+                elif isinstance(v, str):
+                    arg_strs.append(f'{k}: "{v}"')
+                else:
+                    arg_strs.append(f"{k}: {v}")
+
+            return "(" + ", ".join(arg_strs) + ")"
+
+        selection_set = build_selection(fields, relationships)
+        args = build_args(filters)
+
+        query_str = f"""
+        query {{
+            {endpoint}{args} {{
+                {selection_set}
+            }}
+        }}
+        """
+        print(query_str)
+        async with self.client as session:
+            result = await session.execute(gql(query_str))
+        return result

polymarket_apis/clients/web3_client.py

@@ -77,7 +77,7 @@ class PolymarketWeb3Client:
             abi_element_identifier="redeemPositions",
             args=[condition_id, amounts],
         )
-    def _encode_convert(self, neg_risk_market_id: Keccak256, index_set: int, amount: int):
+    def _encode_convert(self, neg_risk_market_id: Keccak256, index_set: int, amount: int) -> str:
         return self.neg_risk_adapter.encode_abi(
             abi_element_identifier="convertPositions",
             args=[neg_risk_market_id, index_set, amount],