polymarklib 0.1.0__tar.gz

polymarklib-0.1.0/PKG-INFO

@@ -0,0 +1,5 @@
+Metadata-Version: 2.4
+Name: polymarklib
+Version: 0.1.0
+Requires-Python: >=3.10
+Requires-Dist: requests>=2.31.0

polymarklib-0.1.0/pyproject.toml

@@ -0,0 +1,12 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "polymarklib"
+version = "0.1.0"
+requires-python = ">=3.10"
+dependencies = ["requests>=2.31.0"]
+
+[tool.setuptools.packages.find]
+where = ["src"]

polymarklib-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

polymarklib-0.1.0/src/polymarklib/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

polymarklib-0.1.0/src/polymarklib/config.py

@@ -0,0 +1,20 @@
+import os
+from dataclasses import dataclass
+
+# API ENDPOINTS
+@dataclass(frozen=True)
+class Endpoints:
+    """
+    Endpoints dataclass - containing all the polymarket API endpoints
+    such as GAMMA, CLOB, etc.
+    """
+    gamma: str = os.getenv(
+        "POLYMARKET_GAMMA_API",
+        "https://gamma-api.polymarket.com",
+    )
+    clob: str = os.getenv(
+        "POLYMARKET_CLOB_API",
+        "https://clob.polymarket.com"
+    )
+
+ENDPOINTS = Endpoints()

polymarklib-0.1.0/src/polymarklib/markets.py

@@ -0,0 +1,140 @@
+import requests
+import json
+from typing import Tuple, Any
+from dataclasses import dataclass
+
+from config import ENDPOINTS
+
+@dataclass(frozen=True)
+class Market:
+    slug: str
+    question: str | None
+    outcomes: tuple[str, ...]
+    clob_token_ids: tuple[str, ...]
+    raw: dict[str, Any]
+
+    @property
+    def token_map(self) -> dict[str, str]:
+        # validates lengths via zip truncation, and returns token_map
+        if len(self.outcomes) != len(self.clob_token_ids):
+            raise ValueError(
+                f"Outcome/token length mismatch: "
+                f"{len(self.outcomes)} vs {len(self.clob_token_ids)}"
+            )
+
+        return dict(zip(self.outcomes, self.clob_token_ids))
+
+    def fetch_quotes(self) -> dict[str, dict[str, float]]:
+        token_map = self.token_map
+        quotes = {}
+        for outcome, token in token_map.items():
+            bid, ask = fetch_quote(token)
+            quotes[outcome] = {"bid": bid, "ask": ask}
+
+        return quotes
+
+    @staticmethod
+    def from_gamma(gamma_resp: dict) -> "Market":
+        try:
+            outcomes_raw = gamma_resp["outcomes"]
+            clob_tokens_raw = gamma_resp["clobTokenIds"]
+        except KeyError as e:
+            raise KeyError(f"Missing expected Gamma field: {e}") from e
+
+        try:
+            outcomes = json.loads(outcomes_raw)
+            clob_tokens = json.loads(clob_tokens_raw)
+        except json.JSONDecodeError as e:
+            raise ValueError("JSON fields malformed") from e
+
+        if len(outcomes) != len(clob_tokens):
+            raise ValueError(
+                f"Outcome/token length mismatch: "
+                f"{len(outcomes)} vs {len(clob_tokens)}"
+            )
+
+        return Market(
+            slug=str(gamma_resp.get("slug", "")),
+            question=gamma_resp.get("question"),
+            outcomes=tuple(str(x) for x in outcomes),
+            clob_token_ids=tuple(str(x) for x in clob_tokens),
+            raw=gamma_resp,
+        )
+
+
+
+def fetch_market_by_slug(slug: str, timeout: float = 15.0) -> Market:
+    """
+    Fetch a market by its unique slug.
+
+    Args:
+        timeout: seconds timeout allowed
+        slug: the slug of the market
+
+    Returns:
+        Parsed JSON response
+
+    Raises:
+        requests.HTTPError: if non-200 response
+        requests.RequestException: on network failure
+        ValueError: if response is not valid JSON
+
+    """
+    url = f"{ENDPOINTS.gamma}/markets/slug/{slug}"
+
+    resp = requests.get(url, timeout=timeout)
+    resp.raise_for_status()
+
+    data = resp.json()
+
+    return Market.from_gamma(data)
+
+
+
+def fetch_quote(token_id: str, timeout: float = 15.0) -> Tuple[float, float]:
+    """
+    Fetches a price quote for a specific token ID
+
+    Arguments
+        token_id: the CLOB token representing the market position
+        timeout: timeout for the http request
+
+    Returns
+        (bid, ask) for that token
+
+    Raises
+        requests.HTTPError: if non-200 response
+        requests.RequestException: on network failure
+        ValueError: if response is not valid JSON
+        KeyError: if price key not in JSON response
+    """
+    base = f"{ENDPOINTS.clob}/price"
+
+    bid_resp = requests.get(base, params={"token_id": token_id, "side": "sell"}, timeout=timeout)
+    ask_resp = requests.get(base, params={"token_id": token_id, "side": "buy"},  timeout=timeout)
+
+    bid_resp.raise_for_status()
+    ask_resp.raise_for_status()
+
+    try:
+        bid_json = bid_resp.json()
+        ask_json = ask_resp.json()
+    except json.JSONDecodeError as e:
+        raise ValueError(f"Response was not valid JSON") from e
+
+    try:
+        bid_raw = bid_json["price"]
+        ask_raw = ask_json["price"]
+    except KeyError as e:
+        raise KeyError(f"Missing price field: {e}") from e
+
+    if bid_raw is None or ask_raw is None:
+        raise ValueError(f"Price was null (bid={bid_raw}, ask={ask_raw})")
+
+    try:
+        bid = float(bid_raw)
+        ask = float(ask_raw)
+    except (TypeError, ValueError) as e:
+        raise ValueError(f"Price was not numeric (bid={bid_raw}, ask={ask_raw})") from e
+
+    return bid, ask

polymarklib-0.1.0/src/polymarklib/order.py

@@ -0,0 +1,63 @@
+import os
+
+from py_clob_client import ClobClient
+from py_clob_client.clob_types import *
+from py_clob_client.exceptions import PolyApiException
+from py_clob_client.order_builder.constants import BUY, SELL
+
+from config import ENDPOINTS
+
+class Spender:
+    def __init__(self, *, wallet_address: str, signature_type: int, private_key: str | None = None, allow_live: bool = False):
+        if not allow_live:
+            raise RuntimeError(
+                "Live trading disabled. Pass allow_live=True to enable"
+            )
+
+        if private_key is None:
+            private_key = os.getenv("POLYMARKET_PRIVATE_KEY")
+
+        if not private_key:
+            raise ValueError("No private key provided")
+
+        self.auth_client = ClobClient(
+            ENDPOINTS.clob,
+            key=private_key,
+            chain_id=137,
+            signature_type=signature_type,
+            funder=wallet_address
+        )
+
+        creds = self.auth_client.derive_api_key()
+        self.auth_client.set_api_creds(creds)
+
+    def get_balance(self):
+        balance = self.auth_client.get_balance_allowance(BalanceAllowanceParams(asset_type=AssetType.COLLATERAL))
+        usdc_balance = int(balance['balance']) / 1e6
+        return usdc_balance
+
+
+    def place_order(self, * token_id: str, amount: float, order_type: OrderType, side: str) -> dict[str, Any]:
+        """
+        Places a real polymarket bet
+        :param order_type: e.g FOK
+        :param token_id: the order ID
+        :param amount: the amount in USDC
+        :return:
+        """
+        if side not in (BUY, SELL):
+            raise ValueError("Side must be BUY or SELL")
+
+        market_order = MarketOrderArgs(
+            token_id=token_id,
+            amount=amount,
+            side=side,
+            order_type=order_type
+        )
+        signed = self.auth_client.create_market_order(market_order)
+
+        try:
+            resp = self.auth_client.post_order(signed, order_type)
+            return {"ok": True, "resp": resp}
+        except PolyApiException as e:
+            return {"ok": False, "reason": "", "error": str(e)}

polymarklib-0.1.0/src/polymarklib/users.py

@@ -0,0 +1,57 @@
+import requests
+from dataclasses import dataclass
+from typing import Any
+
+@dataclass(frozen=True)
+class Action:
+    user_id: str
+    event_type: str
+    usdc_size: float
+    price: float
+    side: str
+    asset: str
+    title: str
+    slug: str
+    timestamp: int
+
+class UsersClient:
+    def __init__(self, session=None):
+        self.session = session
+
+    def fetch_activity(self, user_id: str, limit: int = 100, timeout: int = 15) -> tuple[Action, ...]:
+        """
+        """
+        s = self.session or requests
+
+        url = "https://data-api.polymarket.com/activity"
+        params = {
+            "user": user_id,
+            "limit": limit,
+            "sortBy": "TIMESTAMP",
+            "sortDirection": "DESC"
+        }
+        resp = s.get(url, params=params, timeout=timeout)
+        resp.raise_for_status()
+
+        try:
+            data: list[dict] = resp.json()
+        except ValueError as e:
+            raise ValueError("Response was not valid JSON") from e
+
+        activity: list[Action] = []
+        for entry in data:
+            action: Action = Action(
+                user_id=user_id,
+                event_type=entry["type"],
+                usdc_size=float(entry["size"]),
+                price=float(entry["price"]),
+                side=entry["side"],
+                asset=entry["asset"],
+                title=entry["title"],
+                slug=entry["slug"],
+                timestamp=int(entry["timestamp"])
+            )
+            activity.append(action)
+
+        return tuple(activity)
+

polymarklib-0.1.0/src/polymarklib.egg-info/PKG-INFO

@@ -0,0 +1,5 @@
+Metadata-Version: 2.4
+Name: polymarklib
+Version: 0.1.0
+Requires-Python: >=3.10
+Requires-Dist: requests>=2.31.0

polymarklib-0.1.0/src/polymarklib.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+README.md
+pyproject.toml
+src/polymarklib/__init__.py
+src/polymarklib/config.py
+src/polymarklib/markets.py
+src/polymarklib/order.py
+src/polymarklib/users.py
+src/polymarklib.egg-info/PKG-INFO
+src/polymarklib.egg-info/SOURCES.txt
+src/polymarklib.egg-info/dependency_links.txt
+src/polymarklib.egg-info/requires.txt
+src/polymarklib.egg-info/top_level.txt

polymarklib-0.1.0/src/polymarklib.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

polymarklib-0.1.0/src/polymarklib.egg-info/requires.txt

@@ -0,0 +1 @@
+requests>=2.31.0

polymarklib-0.1.0/src/polymarklib.egg-info/top_level.txt

@@ -0,0 +1 @@
+polymarklib