clutchapi 0.1.0__py3-none-any.whl

clutchapi/__init__.py

@@ -0,0 +1,184 @@
+"""Official Python client for the CLUTCH API (https://api.clutchbets.online).
+
+Standard library only. Python 3.8+.
+
+    from clutchapi import Clutch
+    clutch = Clutch("ck_live_...")        # or set CLUTCH_API_KEY
+    nfl = clutch.odds("nfl")
+"""
+
+import hashlib
+import hmac
+import json
+import os
+import urllib.error
+import urllib.parse
+import urllib.request
+
+__version__ = "0.1.0"
+__all__ = ["Clutch", "ClutchError", "verify_webhook"]
+
+DEFAULT_BASE = "https://api.clutchbets.online"
+
+
+class ClutchError(Exception):
+    def __init__(self, message, status=None, body=None):
+        super().__init__(message)
+        self.status = status
+        self.body = body
+
+
+class _Alerts:
+    def __init__(self, client):
+        self._c = client
+
+    def list(self):
+        return self._c.get("/api/v1/alerts")["alerts"]
+
+    def create(self, **rule):
+        """channel='webhook'|'email', url=, book=, sport=, player=, market=,
+        min_move=1, min_odds_move=, event='line_move'|'sheet_drop', name=.
+        Returns {'rule': ..., 'secret': 'whsec_...'} — the secret is shown once."""
+        return self._c.request("POST", "/api/v1/alerts", body=rule)
+
+    def update(self, alert_id, **patch):
+        return self._c.request("PATCH", f"/api/v1/alerts/{alert_id}", body=patch)["alert"]
+
+    def delete(self, alert_id):
+        return self._c.request("DELETE", f"/api/v1/alerts/{alert_id}")
+
+    def test(self, alert_id):
+        return self._c.request("POST", f"/api/v1/alerts/{alert_id}/test")
+
+    def deliveries(self, alert_id):
+        return self._c.get(f"/api/v1/alerts/{alert_id}/deliveries")["deliveries"]
+
+
+class Clutch:
+    def __init__(self, api_key=None, base_url=DEFAULT_BASE, timeout=30):
+        self.api_key = api_key or os.environ.get("CLUTCH_API_KEY")
+        self.base_url = base_url.rstrip("/")
+        self.timeout = timeout
+        #: rate-limit / quota headers from the most recent response
+        self.last_limits = None
+        self.alerts = _Alerts(self)
+
+    def request(self, method, path, params=None, body=None):
+        query = {}
+        for k, v in (params or {}).items():
+            if v is None or v == "":
+                continue
+            query[k] = ",".join(map(str, v)) if isinstance(v, (list, tuple)) else str(v)
+        url = self.base_url + path + ("?" + urllib.parse.urlencode(query) if query else "")
+        headers = {"Accept": "application/json", "User-Agent": f"clutchapi-python/{__version__}"}
+        if self.api_key:
+            headers["Authorization"] = f"Bearer {self.api_key}"
+        data = None
+        if body is not None:
+            data = json.dumps(body).encode()
+            headers["Content-Type"] = "application/json"
+        req = urllib.request.Request(url, data=data, headers=headers, method=method)
+        try:
+            with urllib.request.urlopen(req, timeout=self.timeout) as res:
+                self._limits(res.headers)
+                text = res.read().decode()
+        except urllib.error.HTTPError as e:
+            self._limits(e.headers)
+            raw = e.read().decode(errors="replace")
+            try:
+                parsed = json.loads(raw)
+            except ValueError:
+                parsed = {"raw": raw}
+            raise ClutchError(parsed.get("message") or parsed.get("error") or f"HTTP {e.code}", e.code, parsed) from None
+        return json.loads(text) if text else {}
+
+    def get(self, path, params=None):
+        return self.request("GET", path, params=params)
+
+    def _limits(self, h):
+        n = lambda k: int(h[k]) if h and h.get(k) not in (None, "") else None
+        self.last_limits = {
+            "limit": n("X-RateLimit-Limit"), "remaining": n("X-RateLimit-Remaining"),
+            "quota_limit": n("X-Quota-Limit"), "quota_remaining": n("X-Quota-Remaining"),
+        }
+
+    # ── catalog + health ──
+    def status(self): return self.get("/api/v1/status")
+    def book_status(self, days=90): return self.get("/api/v1/status/books", {"days": days})
+    def sports(self): return self.get("/api/v1/sports")
+
+    # ── odds ──
+    def odds(self, sport, **params):
+        """Game lines (moneyline / spread / total) for a sport, every book."""
+        return self.get(f"/api/v1/{sport}/odds", params)
+
+    def props(self, sport, **params):
+        """Player props for a sport, every book."""
+        return self.get(f"/api/v1/{sport}/props", params)
+
+    def board(self, **params): return self.get("/api/v1/board", params)
+    def ev(self, sport, **params): return self.get(f"/api/v1/{sport}/ev", params)
+    def arbitrage(self, sport=None, **params):
+        return self.get(f"/api/v1/{sport}/arbitrage" if sport else "/api/v1/arbitrage", params)
+    def signals(self, sport, **params): return self.get(f"/api/v1/{sport}/signals", params)
+
+    # ── movement + history ──
+    def movements(self, **params): return self.get("/api/v1/movements", params)
+    def steam(self, **params): return self.get("/api/v1/movements/steam", params)
+    def prop_movements(self, **params): return self.get("/api/v1/props/movements", params)
+    def history_games(self, **params): return self.get("/api/v1/history/games", params)
+    def history_odds(self, game_key, **params): return self.get("/api/v1/history/odds", {"game_key": game_key, **params})
+    def history_props(self, **params): return self.get("/api/v1/history/props", params)
+
+    def closing(self, **params):
+        """The closing line for a game market."""
+        return self.get("/api/v1/closing", params)
+
+    def clv(self, **params):
+        """Grade a bet's price against the close (closing-line value)."""
+        return self.get("/api/v1/clv", params)
+
+    # ── stats + context ──
+    def injuries(self, sport): return self.get(f"/api/v1/{sport}/injuries")
+    def results(self, sport, **params): return self.get(f"/api/v1/{sport}/results", params)
+    def averages(self, sport, **params): return self.get(f"/api/v1/{sport}/stats/averages", params)
+    def player_log(self, player_id, **params): return self.get(f"/api/v1/player/{player_id}/log", params)
+
+    # ── prediction markets ──
+    def kalshi(self, sport): return self.get(f"/api/v2/kalshi/{sport}/leagues")
+    def polymarket(self, sport="all"):
+        return self.get("/api/v2/polymarket/all/markets" if sport == "all" else f"/api/v2/polymarket/{sport}/leagues")
+
+    def stream(self, sport=None):
+        """Live odds over Server-Sent Events. Yields (event_type, data) forever."""
+        q = "?" + urllib.parse.urlencode({"sport": sport}) if sport else ""
+        headers = {"Accept": "text/event-stream"}
+        if self.api_key:
+            headers["Authorization"] = f"Bearer {self.api_key}"
+        req = urllib.request.Request(self.base_url + "/api/v1/stream/odds" + q, headers=headers)
+        with urllib.request.urlopen(req) as res:
+            kind, data = "message", ""
+            for raw in res:
+                line = raw.decode().rstrip("\n").rstrip("\r")
+                if not line:
+                    if data:
+                        try:
+                            yield kind, json.loads(data)
+                        except ValueError:
+                            yield kind, data
+                    kind, data = "message", ""
+                elif line.startswith("event:"):
+                    kind = line[6:].strip()
+                elif line.startswith("data:"):
+                    data += line[5:].strip()
+
+
+def verify_webhook(raw_body, signature_header, secret):
+    """Check a CLUTCH webhook. Pass the RAW body (bytes or str), the
+    X-Clutch-Signature header, and the whsec_... secret from the dashboard."""
+    if not signature_header or not secret:
+        return False
+    if isinstance(raw_body, str):
+        raw_body = raw_body.encode()
+    expected = "sha256=" + hmac.new(secret.encode(), raw_body, hashlib.sha256).hexdigest()
+    return hmac.compare_digest(expected, str(signature_header))

clutchapi-0.1.0.dist-info/METADATA

@@ -0,0 +1,71 @@
+Metadata-Version: 2.4
+Name: clutchapi
+Version: 0.1.0
+Summary: Official client for the CLUTCH sports odds API: live odds and player props from 30+ books, line movement, closing lines, CLV, arbitrage and webhooks.
+Author: Cooper Tech Solutions LLC
+License: MIT
+Project-URL: Homepage, https://api.clutchbets.online
+Project-URL: Documentation, https://api.clutchbets.online/docs
+Keywords: sports betting,odds api,player props,sportsbook,nfl odds,nba odds,line movement,closing line value,arbitrage
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# clutchapi
+
+The official Python client for the [CLUTCH API](https://api.clutchbets.online): live odds and player props from 30+ sportsbooks, line movement, closing lines, CLV grading, arbitrage and webhooks. Standard library only.
+
+```bash
+pip install clutchapi
+```
+
+```python
+from clutchapi import Clutch
+
+clutch = Clutch("ck_live_...")   # or set CLUTCH_API_KEY
+
+nfl = clutch.odds("nfl")
+props = clutch.props("nba", market="points")
+steam = clutch.steam(sport="nfl")
+close = clutch.closing(sport="nfl", game_key="...", market="spread")
+```
+
+Get a key at [api.clutchbets.online/console](https://api.clutchbets.online/console).
+
+## Live stream
+
+```python
+for event, data in clutch.stream(sport="nba"):
+    print(event, data)
+```
+
+## Line-move webhooks
+
+```python
+out = clutch.alerts.create(channel="webhook", url="https://your.app/hooks/clutch",
+                           book="pinnacle", sport="nfl", min_move=1)
+secret = out["secret"]   # shown once, save it
+```
+
+Verify each delivery (Flask example, raw body):
+
+```python
+from clutchapi import verify_webhook
+
+@app.post("/hooks/clutch")
+def hook():
+    if not verify_webhook(request.get_data(), request.headers.get("X-Clutch-Signature"), SECRET):
+        return "", 401
+    moves = request.get_json()["moves"]
+    return "", 200
+```
+
+## Errors and limits
+
+Failed requests raise `ClutchError` with `.status` and `.body`. After every call, `clutch.last_limits` holds your rate-limit and monthly-quota headers.
+
+Any endpoint is reachable directly with `clutch.get("/api/v1/...", {...})`. Full reference: [api.clutchbets.online/docs](https://api.clutchbets.online/docs).
+
+MIT © Cooper Tech Solutions LLC

clutchapi-0.1.0.dist-info/RECORD

@@ -0,0 +1,5 @@
+clutchapi/__init__.py,sha256=K4v6U2tWYXBHGF9vF-mgfe1jLl4tNjKvjuBxEmcJ2Yc,7900
+clutchapi-0.1.0.dist-info/METADATA,sha256=jCjZ1ZVvDWccb6x8h4vWN2P3OCzc99yXPEtw8qg0xss,2431
+clutchapi-0.1.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+clutchapi-0.1.0.dist-info/top_level.txt,sha256=IFNYX_334-30iFUBnGlmTjw0q9g5dCGEd5JTlwkKW68,10
+clutchapi-0.1.0.dist-info/RECORD,,

clutchapi-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

clutchapi-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+clutchapi