pinnradar 0.1.0__tar.gz

pinnradar-0.1.0/.github/workflows/ci.yml

@@ -0,0 +1,17 @@
+name: CI
+on:
+  push:
+  pull_request:
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python: ["3.9", "3.11", "3.13"]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python }}
+      - run: pip install pytest
+      - run: pytest -q

pinnradar-0.1.0/.github/workflows/publish.yml

@@ -0,0 +1,22 @@
+# Publishes to PyPI when a version tag (v*) is pushed. Uses PyPI trusted
+# publishing (OIDC): no token is stored anywhere. Configure once on PyPI:
+# project "pinnradar", owner "PinnRadar", repo "pinnradar-python",
+# workflow "publish.yml", environment "pypi".
+name: Publish
+on:
+  push:
+    tags: ["v*"]
+  workflow_dispatch:
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+      - run: pip install pytest build && pytest -q && python -m build
+      - uses: pypa/gh-action-pypi-publish@release/v1

pinnradar-0.1.0/.gitignore

@@ -0,0 +1,7 @@
+__pycache__/
+*.pyc
+dist/
+build/
+*.egg-info/
+.pytest_cache/
+.venv/

pinnradar-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 PinnRadar
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pinnradar-0.1.0/PKG-INFO

@@ -0,0 +1,120 @@
+Metadata-Version: 2.5
+Name: pinnradar
+Version: 0.1.0
+Summary: Python client for the PinnRadar API: real-time Pinnacle odds, live and prematch markets, dropping-odds alerts over SSE.
+Project-URL: Homepage, https://pinnradar.com
+Project-URL: Documentation, https://pinnradar.com/docs
+Project-URL: Source, https://github.com/PinnRadar/pinnradar-python
+Project-URL: Pricing, https://pinnradar.com/pinnacle-api-pricing
+Author-email: PinnRadar <info@pinnradar.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: dropping odds,live odds,no vig,odds,odds api,pinnacle,pinnacle api,sports betting,sports data
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Typing :: Typed
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# pinnradar
+
+Python client for the [PinnRadar API](https://pinnradar.com): real-time **Pinnacle odds** as JSON. Live and prematch markets (moneyline, spreads, totals, team totals, every period), dropping-odds alerts over Server-Sent Events, and no-vig helpers.
+
+- No dependencies (standard library only), Python 3.8+
+- Typed, with clear errors (`AuthError`, `RateLimitError`)
+- Streams reconnect with backoff
+
+```bash
+pip install pinnradar
+```
+
+Get a free key at [pinnradar.com](https://pinnradar.com/panel#signup) (email only, no card, no Pinnacle account).
+
+## Quick start
+
+```python
+from pinnradar import Client
+
+pr = Client("YOUR_KEY")          # or set PINNRADAR_API_KEY
+
+# Live soccer board (sport_id 1)
+board = pr.markets(sport_id=1)
+for ev in board["events"]:
+    ml = ev["periods"]["num_0"].get("money_line") or {}
+    print(ev["home"], "v", ev["away"], ml.get("home"), ml.get("draw"), ml.get("away"))
+
+# Only what changed since the last call
+board = pr.markets(sport_id=1, since=board["last"])
+```
+
+## Prematch
+
+```python
+fixtures = pr.prematch_fixtures(sport_id=3)          # basketball
+event_id = fixtures["events"][0]["event_id"]
+markets = pr.prematch_markets(event_id)               # every period and line
+totals = pr.prematch_lines(event_id, market_type="totals")
+```
+
+## Dropping odds
+
+Recent drops from the server-side buffer:
+
+```python
+for d in pr.drops(mode="live", sport_id=1, min_drop_pct=7, max_age_sec=600):
+    print(d["home"], d["market"], d["side"], d["from"], "->", d["to"], f'{d["drop_pct"]:.1f}%')
+```
+
+Or follow them live over SSE (plans with SSE: Drops, Edge, Scale):
+
+```python
+for drop in pr.stream_drops(min_drop=5):              # prematch=True for /odds-drop-prematch
+    print(drop["home"], drop["sect"], drop["outcome"], drop["from_price"], "->", drop["to_price"], "fair", drop["nvp"])
+```
+
+## No-vig (fair) odds
+
+```python
+from pinnradar import no_vig, margin
+
+margin([1.952, 1.952])                  # 0.0246 -> 2.5 % margin
+no_vig([2.10, 3.45, 3.70])              # fair 1X2 prices
+no_vig([1.25, 4.20], method="power")    # takes more margin from the longshot
+```
+
+There is also an online [no-vig calculator](https://pinnradar.com/tools/no-vig-calculator).
+
+## Sport ids
+
+| id | sport | id | sport |
+|---|---|---|---|
+| 1 | Soccer | 5 | American football |
+| 2 | Tennis | 6 | Baseball |
+| 3 | Basketball | 11 | Esports |
+| 4 | Hockey | | |
+
+## Errors and limits
+
+```python
+from pinnradar import AuthError, RateLimitError
+
+try:
+    pr.markets(1)
+except RateLimitError as e:
+    print("slow down for", e.retry_after, "seconds")
+except AuthError:
+    print("check your key or plan")
+```
+
+Rate limits depend on the plan; see [pricing](https://pinnradar.com/pinnacle-api-pricing). Any other endpoint can be called with `pr.get("/path", **params)`.
+
+## Links
+
+- API docs: https://pinnradar.com/docs
+- WebSocket feed and MCP server: https://pinnradar.com/docs
+- Node.js client: https://www.npmjs.com/package/pinnradar
+
+PinnRadar is an independent data service, not affiliated with Pinnacle. MIT licensed.

pinnradar-0.1.0/README.md

@@ -0,0 +1,99 @@
+# pinnradar
+
+Python client for the [PinnRadar API](https://pinnradar.com): real-time **Pinnacle odds** as JSON. Live and prematch markets (moneyline, spreads, totals, team totals, every period), dropping-odds alerts over Server-Sent Events, and no-vig helpers.
+
+- No dependencies (standard library only), Python 3.8+
+- Typed, with clear errors (`AuthError`, `RateLimitError`)
+- Streams reconnect with backoff
+
+```bash
+pip install pinnradar
+```
+
+Get a free key at [pinnradar.com](https://pinnradar.com/panel#signup) (email only, no card, no Pinnacle account).
+
+## Quick start
+
+```python
+from pinnradar import Client
+
+pr = Client("YOUR_KEY")          # or set PINNRADAR_API_KEY
+
+# Live soccer board (sport_id 1)
+board = pr.markets(sport_id=1)
+for ev in board["events"]:
+    ml = ev["periods"]["num_0"].get("money_line") or {}
+    print(ev["home"], "v", ev["away"], ml.get("home"), ml.get("draw"), ml.get("away"))
+
+# Only what changed since the last call
+board = pr.markets(sport_id=1, since=board["last"])
+```
+
+## Prematch
+
+```python
+fixtures = pr.prematch_fixtures(sport_id=3)          # basketball
+event_id = fixtures["events"][0]["event_id"]
+markets = pr.prematch_markets(event_id)               # every period and line
+totals = pr.prematch_lines(event_id, market_type="totals")
+```
+
+## Dropping odds
+
+Recent drops from the server-side buffer:
+
+```python
+for d in pr.drops(mode="live", sport_id=1, min_drop_pct=7, max_age_sec=600):
+    print(d["home"], d["market"], d["side"], d["from"], "->", d["to"], f'{d["drop_pct"]:.1f}%')
+```
+
+Or follow them live over SSE (plans with SSE: Drops, Edge, Scale):
+
+```python
+for drop in pr.stream_drops(min_drop=5):              # prematch=True for /odds-drop-prematch
+    print(drop["home"], drop["sect"], drop["outcome"], drop["from_price"], "->", drop["to_price"], "fair", drop["nvp"])
+```
+
+## No-vig (fair) odds
+
+```python
+from pinnradar import no_vig, margin
+
+margin([1.952, 1.952])                  # 0.0246 -> 2.5 % margin
+no_vig([2.10, 3.45, 3.70])              # fair 1X2 prices
+no_vig([1.25, 4.20], method="power")    # takes more margin from the longshot
+```
+
+There is also an online [no-vig calculator](https://pinnradar.com/tools/no-vig-calculator).
+
+## Sport ids
+
+| id | sport | id | sport |
+|---|---|---|---|
+| 1 | Soccer | 5 | American football |
+| 2 | Tennis | 6 | Baseball |
+| 3 | Basketball | 11 | Esports |
+| 4 | Hockey | | |
+
+## Errors and limits
+
+```python
+from pinnradar import AuthError, RateLimitError
+
+try:
+    pr.markets(1)
+except RateLimitError as e:
+    print("slow down for", e.retry_after, "seconds")
+except AuthError:
+    print("check your key or plan")
+```
+
+Rate limits depend on the plan; see [pricing](https://pinnradar.com/pinnacle-api-pricing). Any other endpoint can be called with `pr.get("/path", **params)`.
+
+## Links
+
+- API docs: https://pinnradar.com/docs
+- WebSocket feed and MCP server: https://pinnradar.com/docs
+- Node.js client: https://www.npmjs.com/package/pinnradar
+
+PinnRadar is an independent data service, not affiliated with Pinnacle. MIT licensed.

pinnradar-0.1.0/pyproject.toml

@@ -0,0 +1,38 @@
+[build-system]
+requires = ["hatchling>=1.24"]
+build-backend = "hatchling.build"
+
+[project]
+name = "pinnradar"
+dynamic = ["version"]
+description = "Python client for the PinnRadar API: real-time Pinnacle odds, live and prematch markets, dropping-odds alerts over SSE."
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+requires-python = ">=3.8"
+authors = [{ name = "PinnRadar", email = "info@pinnradar.com" }]
+keywords = ["pinnacle", "odds", "odds api", "pinnacle api", "sports betting", "live odds", "dropping odds", "sports data", "no vig"]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Intended Audience :: Developers",
+  "Operating System :: OS Independent",
+  "Programming Language :: Python :: 3",
+  "Topic :: Software Development :: Libraries",
+  "Typing :: Typed",
+]
+dependencies = []
+
+[project.urls]
+Homepage = "https://pinnradar.com"
+Documentation = "https://pinnradar.com/docs"
+Source = "https://github.com/PinnRadar/pinnradar-python"
+Pricing = "https://pinnradar.com/pinnacle-api-pricing"
+
+[tool.hatch.version]
+path = "src/pinnradar/__init__.py"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/pinnradar"]
+
+[tool.pytest.ini_options]
+pythonpath = ["src"]

pinnradar-0.1.0/src/pinnradar/__init__.py

@@ -0,0 +1,18 @@
+"""PinnRadar: real-time Pinnacle odds API client. https://pinnradar.com/docs"""
+
+__version__ = "0.1.0"
+
+from .client import AuthError, Client, PinnRadarError, RateLimitError, parse_sse  # noqa: E402
+from .odds import implied, margin, no_vig  # noqa: E402
+
+__all__ = [
+    "Client",
+    "PinnRadarError",
+    "AuthError",
+    "RateLimitError",
+    "parse_sse",
+    "implied",
+    "margin",
+    "no_vig",
+    "__version__",
+]

pinnradar-0.1.0/src/pinnradar/client.py

@@ -0,0 +1,265 @@
+"""HTTP client for the PinnRadar odds API. Standard library only."""
+
+from __future__ import annotations
+
+import json
+import os
+import time
+import urllib.error
+import urllib.parse
+import urllib.request
+from typing import Any, Dict, Iterable, Iterator, List, Optional, Union
+
+from . import __version__
+
+DEFAULT_BASE_URL = "https://pinnradar.com"
+Params = Dict[str, Any]
+
+
+class PinnRadarError(Exception):
+    """Any non-success answer from the API."""
+
+    def __init__(self, message: str, status: Optional[int] = None, body: Any = None):
+        super().__init__(message)
+        self.status = status
+        self.body = body
+
+
+class AuthError(PinnRadarError):
+    """401/403: the key is missing, wrong, expired, or the plan lacks this feature."""
+
+
+class RateLimitError(PinnRadarError):
+    """429: slow down. `retry_after` is the number of seconds the server asked for."""
+
+    def __init__(self, message: str, retry_after: Optional[float], status: int = 429, body: Any = None):
+        super().__init__(message, status, body)
+        self.retry_after = retry_after
+
+
+def _clean(params: Params) -> Params:
+    out: Params = {}
+    for k, v in params.items():
+        if v is None:
+            continue
+        if isinstance(v, bool):
+            v = int(v)
+        elif isinstance(v, (list, tuple, set)):
+            v = ",".join(str(x) for x in v)
+        out[k] = v
+    return out
+
+
+def _csv(v: Union[None, str, Iterable[Any]]) -> Optional[str]:
+    if v is None or isinstance(v, str):
+        return v
+    return ",".join(str(x) for x in v)
+
+
+def parse_sse(lines: Iterable[str]) -> Iterator[str]:
+    """Yield the `data` payload of each Server-Sent Event in an iterable of text lines."""
+    data: List[str] = []
+    for raw in lines:
+        line = raw.rstrip("\r\n")
+        if line == "":
+            if data:
+                yield "\n".join(data)
+                data = []
+            continue
+        if line.startswith(":"):
+            continue  # comment / keep-alive
+        field, _, value = line.partition(":")
+        if value.startswith(" "):
+            value = value[1:]
+        if field == "data":
+            data.append(value)
+    if data:
+        yield "\n".join(data)
+
+
+class Client:
+    """PinnRadar API client.
+
+    >>> from pinnradar import Client
+    >>> pr = Client("YOUR_KEY")            # or set PINNRADAR_API_KEY
+    >>> board = pr.markets(sport_id=1)       # live soccer
+    >>> for drop in pr.stream_drops(min_drop=5):
+    ...     print(drop["home"], drop["sect"], drop["from_price"], "->", drop["to_price"])
+    """
+
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        base_url: str = DEFAULT_BASE_URL,
+        timeout: float = 20.0,
+        user_agent: Optional[str] = None,
+    ):
+        self.api_key = api_key or os.environ.get("PINNRADAR_API_KEY") or os.environ.get("PINNRADAR_KEY")
+        if not self.api_key:
+            raise AuthError("No API key. Pass Client('...') or set PINNRADAR_API_KEY. Free keys: https://pinnradar.com/panel")
+        self.base_url = base_url.rstrip("/")
+        self.timeout = timeout
+        self.user_agent = user_agent or f"pinnradar-python/{__version__}"
+
+    # ------------------------------------------------------------------ core
+
+    def _url(self, path: str, params: Optional[Params] = None) -> str:
+        q = urllib.parse.urlencode(_clean(params or {}))
+        return f"{self.base_url}{path}" + (f"?{q}" if q else "")
+
+    def _request(self, path: str, params: Optional[Params] = None, auth: bool = True, stream: bool = False):
+        headers = {"user-agent": self.user_agent, "accept": "text/event-stream" if stream else "application/json"}
+        if auth:
+            headers["x-api-key"] = self.api_key  # type: ignore[assignment]
+        req = urllib.request.Request(self._url(path, params), headers=headers)
+        try:
+            return urllib.request.urlopen(req, timeout=None if stream else self.timeout)
+        except urllib.error.HTTPError as e:
+            raise self._error(e) from None
+        except urllib.error.URLError as e:
+            raise PinnRadarError(f"Connection failed: {e.reason}") from None
+
+    @staticmethod
+    def _error(e: urllib.error.HTTPError) -> PinnRadarError:
+        raw = e.read().decode("utf-8", "replace")
+        try:
+            body: Any = json.loads(raw)
+        except ValueError:
+            body = raw
+        detail = body.get("error") if isinstance(body, dict) else None
+        msg = f"HTTP {e.code}" + (f": {detail}" if detail else "")
+        if e.code == 429:
+            ra = e.headers.get("retry-after")
+            try:
+                retry = float(ra) if ra is not None else None
+            except ValueError:
+                retry = None
+            return RateLimitError(msg, retry, body=body)
+        if e.code in (401, 403):
+            return AuthError(msg, e.code, body)
+        return PinnRadarError(msg, e.code, body)
+
+    def get(self, path: str, **params: Any) -> Any:
+        """Call any GET endpoint and return the decoded JSON."""
+        with self._request(path, params) as resp:
+            return json.loads(resp.read().decode("utf-8"))
+
+    # ------------------------------------------------------------- endpoints
+
+    def markets(
+        self,
+        sport_id: int,
+        event_type: str = "live",
+        since: Optional[int] = None,
+        include_specials: Union[None, bool, str] = None,
+    ) -> Dict[str, Any]:
+        """Full board for one sport: `event_type` "live" (default) or "prematch".
+
+        Pass the `last` value of the previous answer as `since` to receive only what changed.
+        `include_specials=True` adds props, correct score and outrights ("nested" attaches them
+        under their parent event).
+        """
+        inc = 1 if include_specials is True else (include_specials or None)
+        return self.get("/kit/v1/markets", sport_id=sport_id, event_type=event_type, since=since, include_specials=inc)
+
+    def details(self, event_id: int) -> Dict[str, Any]:
+        """Every market of one live event."""
+        return self.get("/kit/v1/details", event_id=event_id)
+
+    def prematch_fixtures(self, sport_id: int, since: Optional[int] = None) -> Dict[str, Any]:
+        """Upcoming fixtures of one sport with their main prices."""
+        return self.get("/kit/v1/prematch/fixtures", sport_id=sport_id, since=since)
+
+    def prematch_markets(self, event_id: int) -> Dict[str, Any]:
+        """Complete market set of one prematch event."""
+        return self.get("/kit/v1/prematch/markets", event_id=event_id)
+
+    def prematch_lines(self, event_id: int, market_type: Optional[str] = None) -> Dict[str, Any]:
+        """Lines of one prematch event; `market_type` is money_line, spreads, totals or team_total."""
+        return self.get("/kit/v1/prematch/lines", event_id=event_id, market_type=market_type)
+
+    def drops(
+        self,
+        max_age_sec: int = 600,
+        mode: str = "live",
+        min_drop_pct: Optional[float] = None,
+        max_drop_pct: Optional[float] = None,
+        sport_id: Optional[int] = None,
+        markets: Union[None, str, Iterable[str]] = None,
+        periods: Union[None, str, Iterable[int]] = None,
+        limit: Optional[int] = None,
+    ) -> List[Dict[str, Any]]:
+        """Recent price drops from the server-side buffer (about 3 hours deep).
+
+        Returns the list of drop rows (`event_id`, `home`, `away`, `market`, `side`, `from`, `to`,
+        `nvp`, `drop_pct`, ...).
+        """
+        page = self.get(
+            "/api/drops",
+            mode=mode,
+            max_age_sec=max_age_sec,
+            min_drop_pct=min_drop_pct,
+            max_drop_pct=max_drop_pct,
+            sport_id=sport_id,
+            markets=_csv(markets),
+            periods=_csv(periods),
+            limit=limit,
+        )
+        return page.get("drops", []) if isinstance(page, dict) else page
+
+    def ping(self) -> bool:
+        """True when the API answers. Needs no key."""
+        try:
+            with self._request("/ping", auth=False) as resp:
+                return resp.status == 200
+        except PinnRadarError:
+            return False
+
+    # -------------------------------------------------------------- streams
+
+    def stream_drops(
+        self,
+        prematch: bool = False,
+        min_drop: Optional[float] = None,
+        recheck: Optional[int] = None,
+        reconnect: bool = True,
+        max_backoff: float = 30.0,
+    ) -> Iterator[Dict[str, Any]]:
+        """Follow the live (or prematch) drop alerts over Server-Sent Events.
+
+        Yields one dict per drop as soon as the detector flags it: `home`, `away`, `league`,
+        `sport`, `sect` (Moneyline, Spread, Total, TeamTotal), `outcome`, `point`, `period`,
+        `from_price`, `to_price`, `nvp` (no-vig price), `limit` and, in play, `live` (score,
+        clock, cards, corners). Reconnects with backoff
+        when the connection drops (set `reconnect=False` to stop instead). Needs a plan with
+        SSE (Drops, Edge or Scale). Only one stream of each kind per key at a time.
+        """
+        path = "/odds-drop-prematch" if prematch else "/odds-drop"
+        backoff = 1.0
+        while True:
+            try:
+                with self._request(path, {"min_drop": min_drop, "recheck": recheck}, stream=True) as resp:
+                    backoff = 1.0
+                    lines = (b.decode("utf-8", "replace") for b in resp)
+                    for payload in parse_sse(lines):
+                        try:
+                            frame = json.loads(payload)
+                        except ValueError:
+                            continue
+                        if isinstance(frame, list):
+                            for drop in frame:
+                                yield drop
+                        elif isinstance(frame, dict):
+                            if frame.get("type") == "error":
+                                raise PinnRadarError(str(frame.get("error") or "stream error"), body=frame)
+                            if "to_price" in frame or "to" in frame:
+                                yield frame
+            except (AuthError, RateLimitError):
+                raise
+            except (PinnRadarError, OSError):
+                if not reconnect:
+                    raise
+            if not reconnect:
+                return
+            time.sleep(backoff)
+            backoff = min(max_backoff, backoff * 2)

pinnradar-0.1.0/src/pinnradar/odds.py

@@ -0,0 +1,49 @@
+"""Odds helpers: implied probability, margin and no-vig (fair) prices for decimal odds."""
+
+from __future__ import annotations
+
+from typing import List, Sequence
+
+
+def implied(price: float) -> float:
+    """Implied probability of a decimal price (1 / price)."""
+    if price <= 1:
+        raise ValueError("decimal odds must be greater than 1")
+    return 1.0 / price
+
+
+def margin(prices: Sequence[float]) -> float:
+    """Bookmaker margin of a complete market: sum of implied probabilities minus 1."""
+    return sum(implied(p) for p in prices) - 1.0
+
+
+def no_vig(prices: Sequence[float], method: str = "multiplicative") -> List[float]:
+    """Fair (no-vig) decimal prices for a complete market (every outcome).
+
+    `method` is "multiplicative" (proportional, the usual default) or "power" (takes more
+    margin from longshots).
+
+    >>> [round(x, 3) for x in no_vig([1.952, 1.952])]
+    [2.0, 2.0]
+    """
+    if len(prices) < 2:
+        raise ValueError("need every outcome of the market (at least two prices)")
+    q = [implied(p) for p in prices]
+    if method == "multiplicative":
+        s = sum(q)
+        probs = [x / s for x in q]
+    elif method == "power":
+        lo, hi = 0.05, 50.0
+        for _ in range(200):
+            k = (lo + hi) / 2
+            if sum(x ** k for x in q) > 1:
+                lo = k
+            else:
+                hi = k
+        k = (lo + hi) / 2
+        probs = [x ** k for x in q]
+        t = sum(probs)
+        probs = [p / t for p in probs]
+    else:
+        raise ValueError("method must be 'multiplicative' or 'power'")
+    return [1.0 / p for p in probs]

pinnradar-0.1.0/tests/test_client.py

@@ -0,0 +1,106 @@
+import io
+import json
+import urllib.error
+import urllib.request
+
+import pytest
+
+import pinnradar
+from pinnradar import AuthError, Client, RateLimitError, no_vig, parse_sse
+
+
+class FakeResp(io.BytesIO):
+    status = 200
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *a):
+        self.close()
+
+
+def capture(monkeypatch, body=b"{}", error=None):
+    seen = {}
+
+    def fake(req, timeout=None):
+        seen["url"] = req.full_url
+        seen["headers"] = {k.lower(): v for k, v in req.header_items()}
+        if error:
+            raise error
+        return FakeResp(body)
+
+    monkeypatch.setattr(urllib.request, "urlopen", fake)
+    return seen
+
+
+def test_requires_key(monkeypatch):
+    monkeypatch.delenv("PINNRADAR_API_KEY", raising=False)
+    monkeypatch.delenv("PINNRADAR_KEY", raising=False)
+    with pytest.raises(AuthError):
+        Client()
+
+
+def test_env_key(monkeypatch):
+    monkeypatch.setenv("PINNRADAR_API_KEY", "abc")
+    assert Client().api_key == "abc"
+
+
+def test_markets_url_and_header(monkeypatch):
+    seen = capture(monkeypatch, b'{"sport_id":1,"events":[]}')
+    out = Client("k").markets(1, include_specials=True)
+    assert out["sport_id"] == 1
+    assert seen["url"] == "https://pinnradar.com/kit/v1/markets?sport_id=1&event_type=live&include_specials=1"
+    assert seen["headers"]["x-api-key"] == "k"
+    assert seen["headers"]["user-agent"].startswith("pinnradar-python/")
+
+
+def test_drops_csv_and_unwrap(monkeypatch):
+    seen = capture(monkeypatch, json.dumps({"drops": [{"from": 2.0, "to": 1.8}]}).encode())
+    rows = Client("k").drops(mode="prematch", markets=["total", "spread"], periods=[0, 1], min_drop_pct=3)
+    assert rows == [{"from": 2.0, "to": 1.8}]
+    assert "markets=total%2Cspread" in seen["url"] and "periods=0%2C1" in seen["url"] and "min_drop_pct=3" in seen["url"]
+
+
+def http_error(code, body=b"{}", headers=None):
+    import email.message
+
+    msg = email.message.Message()
+    for k, v in (headers or {}).items():
+        msg[k] = v
+    return urllib.error.HTTPError("https://pinnradar.com/x", code, "err", msg, io.BytesIO(body))
+
+
+def test_rate_limit(monkeypatch):
+    capture(monkeypatch, error=http_error(429, b'{"error":"rate_limited"}', {"Retry-After": "2"}))
+    with pytest.raises(RateLimitError) as e:
+        Client("k").markets(1)
+    assert e.value.retry_after == 2.0
+
+
+def test_auth_error(monkeypatch):
+    capture(monkeypatch, error=http_error(401, b'{"error":"invalid_key"}'))
+    with pytest.raises(AuthError) as e:
+        Client("k").details(5)
+    assert "invalid_key" in str(e.value)
+
+
+def test_parse_sse():
+    lines = [": keepalive\n", "data: [1,2]\n", "\n", "event: x\n", "data: {\"a\":\n", "data: 1}\n", "\n"]
+    assert list(parse_sse(lines)) == ["[1,2]", '{"a":\n1}']
+
+
+def test_stream_drops(monkeypatch):
+    body = b'data: [{"from":2.0,"to":1.8},{"from":3.0,"to":2.5}]\n\n: ping\n\ndata: {"from":1.9,"to":1.7}\n\n'
+    capture(monkeypatch, body)
+    got = list(Client("k").stream_drops(min_drop=3, reconnect=False))
+    assert [d["to"] for d in got] == [1.8, 2.5, 1.7]
+
+
+def test_no_vig():
+    assert [round(x, 3) for x in no_vig([1.952, 1.952])] == [2.0, 2.0]
+    fair = no_vig([2.1, 3.45, 3.7], method="power")
+    assert abs(sum(1 / x for x in fair) - 1) < 1e-9
+
+
+def test_version():
+    assert pinnradar.__version__