polymarket-apis 0.2.2__py3-none-any.whl

polymarket_apis/clients/data_client.py

@@ -0,0 +1,234 @@
+from datetime import datetime
+from typing import Literal, Optional, Union
+from urllib.parse import urljoin
+
+import httpx
+
+from ..types.common import EthAddress, TimeseriesPoint
+from ..types.data_types import (
+    Activity,
+    HolderResponse,
+    Position,
+    Trade,
+    UserMetric,
+    UserRank,
+    ValueResponse,
+)
+
+
+class PolymarketDataClient:
+    def __init__(self, base_url: str = "https://data-api.polymarket.com"):
+        self.base_url = base_url
+        self.client = httpx.Client(http2=True, timeout=30.0)
+
+    def _build_url(self, endpoint: str) -> str:
+        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",
+    ) -> list[Position]:
+        params = {
+            "user": user,
+            "sizeThreshold": size_threshold,
+            "limit": min(limit, 500),
+            "offset": offset,
+        }
+        if isinstance(condition_id, str):
+            params["market"] = condition_id
+        if isinstance(condition_id, list):
+            params["market"] = ",".join(condition_id)
+        if redeemable is not None:
+            params["redeemable"] = redeemable
+        if mergeable is not None:
+            params["mergeable"] = mergeable
+        if title:
+            params["title"] = title
+        if sort_by:
+            params["sortBy"] = sort_by
+        if sort_direction:
+            params["sortDirection"] = sort_direction
+
+        response = self.client.get(self._build_url("/positions"), params=params)
+        response.raise_for_status()
+        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,
+    ) -> list[Trade]:
+        params = {
+            "limit": min(limit, 500),
+            "offset": offset,
+            "takerOnly": taker_only,
+        }
+        if filter_type:
+            params["filterType"] = filter_type
+        if filter_amount:
+            params["filterAmount"] = filter_amount
+        if condition_id:
+            params["market"] = condition_id
+        if user:
+            params["user"] = user
+        if side:
+            params["side"] = side
+
+        response = self.client.get(self._build_url("/trades"), params=params)
+        response.raise_for_status()
+        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",
+    ) -> list[Activity]:
+        params = {"user": user, "limit": min(limit, 500), "offset": offset}
+        if isinstance(condition_id, str):
+            params["market"] = condition_id
+        if isinstance(condition_id, list):
+            params["market"] = ",".join(condition_id)
+        if isinstance(type, str):
+            params["type"] = type
+        if isinstance(type, list):
+            params["type"] = ",".join(type)
+        if start:
+            params["start"] = int(start.timestamp())
+        if end:
+            params["end"] = int(end.timestamp())
+        if side:
+            params["side"] = side
+        if sort_by:
+            params["sortBy"] = sort_by
+        if sort_direction:
+            params["sortDirection"] = sort_direction
+
+        response = self.client.get(self._build_url("/activity"), params=params)
+        response.raise_for_status()
+        return [Activity(**activity) for activity in response.json()]
+
+    def get_holders(
+            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()
+        ]
+
+    def get_value(
+            self,
+            user: str,
+            condition_id: Optional[Union[str, list[str]]] = None,
+    ) -> ValueResponse:
+        """
+        Get the current value of a user's position in a set of markets.
+
+        Takes in condition_id as:
+            - None      --> total value of positions
+            - str       --> value of position
+            - 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)
+
+        response = self.client.get(self._build_url("/value"), params=params)
+        response.raise_for_status()
+        return ValueResponse(**response.json()[0])
+
+    # website endpoints
+
+    def get_pnl(
+            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 = {
+            "user_address": user,
+            "interval": period,
+            "fidelity": frequency,
+        }
+
+        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"):
+        """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.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"):
+        """Get a user's rank on the leaderboard by profit or volume."""
+        params = {
+            "address": user,
+            "window": window,
+            "rankType": "pnl" if metric == "profit" else "vol",
+        }
+        response = self.client.get("https://lb-api.polymarket.com/rank", params=params)
+        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):
+        """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.raise_for_status()
+        return [UserMetric(**user) for user in response.json()]
+
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.client.close()

polymarket_apis/clients/gamma_client.py

@@ -0,0 +1,311 @@
+import json
+from datetime import datetime
+from typing import Optional, Union
+from urllib.parse import urljoin
+
+import httpx
+
+from ..types.gamma_types import Event, GammaMarket, QueryEvent
+
+
+class PolymarketGammaClient:
+    def __init__(self, base_url: str = "https://gamma-api.polymarket.com"):
+        self.base_url = base_url
+        self.client = httpx.Client(http2=True, timeout=30.0)
+
+    def _build_url(self, endpoint: str) -> str:
+        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,
+    ) -> list[GammaMarket]:
+        params = {}
+        if limit:
+            params["limit"] = limit
+        if offset:
+            params["offset"] = offset
+        if order:
+            params["order"] = order
+            params["ascending"] = ascending
+        if ids:
+            params["id"] = ids
+        if slugs:
+            params["slug"] = slugs
+        if archived is not None:
+            params["archived"] = archived
+        if active is not None:
+            params["active"] = active
+        if closed is not None:
+            params["closed"] = closed
+        if token_ids:
+            params["clob_token_ids"] = token_ids
+        if condition_ids:
+            params["condition_ids"] = condition_ids
+        if liquidity_num_min:
+            params["liquidity_num_min"] = liquidity_num_min
+        if liquidity_num_max:
+            params["liquidity_num_max"] = liquidity_num_max
+        if volume_num_min:
+            params["volume_num_min"] = volume_num_min
+        if volume_num_max:
+            params["volume_num_max"] = volume_num_max
+        if start_date_min:
+            params["start_date_min"] = start_date_min.isoformat()
+        if start_date_max:
+            params["start_date_max"] = start_date_max.isoformat()
+        if end_date_min:
+            params["end_date_min"] = end_date_min.isoformat()
+        if end_date_max:
+            params["end_date_max"] = end_date_max.isoformat()
+        if tag_id:
+            params["tag_id"] = tag_id
+            if related_tags:
+                params["related_tags"] = related_tags
+
+        response = self.client.get(self._build_url("/markets"), params=params)
+        response.raise_for_status()
+        return [GammaMarket(**market) for market in response.json()]
+
+    def get_market(self, market_id: str) -> GammaMarket:
+        """Get a GammaMarket by market_id."""
+        response = self.client.get(self._build_url(f"/markets/{market_id}"))
+        response.raise_for_status()
+        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,
+    ) -> list[Event]:
+        params = {}
+        if limit:
+            params["limit"] = limit
+        if offset:
+            params["offset"] = offset
+        if order:
+            params["order"] = order
+            params["ascending"] = ascending
+        if event_ids:
+            params["id"] = event_ids
+        if slugs:
+            params["slug"] = slugs
+        if archived is not None:
+            params["archived"] = archived
+        if active is not None:
+            params["active"] = active
+        if closed is not None:
+            params["closed"] = closed
+        if liquidity_min:
+            params["liquidity_min"] = liquidity_min
+        if liquidity_max:
+            params["liquidity_max"] = liquidity_max
+        if volume_min:
+            params["volume_min"] = volume_min
+        if volume_max:
+            params["volume_max"] = volume_max
+        if start_date_min:
+            params["start_date_min"] = start_date_min.isoformat()
+        if start_date_max:
+            params["start_date_max"] = start_date_max.isoformat()
+        if end_date_min:
+            params["end_date_min"] = end_date_min.isoformat()
+        if end_date_max:
+            params["end_date_max"] = end_date_max.isoformat()
+        if tag:
+            params["tag"] = tag
+        elif tag_id:
+            params["tag_id"] = tag_id
+            if related_tags:
+                params["related_tags"] = related_tags
+        elif tag_slug:
+            params["tag_slug"] = tag_slug
+
+        response = self.client.get(self._build_url("/events"), params=params)
+        response.raise_for_status()
+        return [Event(**event) for event in response.json()]
+
+    def get_event(self, event_id: int) -> Event:
+        response = self.client.get(self._build_url(f"/events/{event_id}"))
+        response.raise_for_status()
+        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,
+    ) -> list[Event]:
+        offset = 0
+        events = []
+
+        while True:
+            part = self.get_events(
+                limit=500,
+                offset=offset,
+                order=order,
+                ascending=ascending,
+                event_ids=event_ids,
+                slugs=slugs,
+                archived=archived,
+                active=active,
+                closed=closed,
+                liquidity_min=liquidity_min,
+                liquidity_max=liquidity_max,
+                volume_min=volume_min,
+                volume_max=volume_max,
+                start_date_min=start_date_min,
+                start_date_max=start_date_max,
+                end_date_min=end_date_min,
+                end_date_max=end_date_max,
+                tag=tag,
+                tag_id=tag_id,
+                tag_slug=tag_slug,
+                related_tags=related_tags,
+            )
+            events.extend(part)
+
+            if len(part) < 500:
+                break
+
+            offset += 500
+
+        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)
+        response.raise_for_status()
+        return [QueryEvent(**event) for event in response.json()["events"]]
+
+    def grok_market_summary(self, condition_id: str):
+        market = self.get_markets(condition_ids=[condition_id])[0]
+
+        params = {
+            "marketName": market.group_item_title,
+            "eventTitle": market.question,
+            "odds": market.outcome_prices[0],
+            "marketDescription": market.description,
+            "isNegRisk": market.neg_risk,
+        }
+
+        with self.client.stream(method="GET", url="https://polymarket.com/api/grok/market-explanation", 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
+
+        # After streaming, print citations if any
+        if citations:
+            print("\n\nCitations:")
+            for cite in citations:
+                print(f"- {cite}")
+
+    def grok_event_summary(self, event_slug: str):
+        params = {
+            "prompt": event_slug,
+        }
+
+        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
+
+        # After streaming, print citations if any
+        if citations:
+            print("\n\nCitations:")
+            for cite in citations:
+                print(f"- {cite}")
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.client.close()