novigapi 0.1.0__py3-none-any.whl

novigapi/__init__.py

@@ -0,0 +1,61 @@
+"""novigapi: Python client for novigapi.com, a read-only Novig market data API.
+
+Independent. Not affiliated with, endorsed by or sponsored by Novig.
+"""
+
+__version__ = "0.1.0"
+
+from .client import DEFAULT_BASE_URL, NovigAPI, NovigAPIError, RateLimitError  # noqa: E402
+from .devig import (  # noqa: E402
+    METHODS,
+    additive,
+    american_to_prob,
+    decimal_to_prob,
+    devig,
+    hold,
+    multiplicative,
+    overround,
+    power,
+    prob_to_american,
+    prob_to_decimal,
+    shin,
+)
+
+
+def taker_fee(price: float, contracts: float = 1.0, coefficient: float = 0.06) -> float:
+    """Novig taker fee in dollars: coefficient x p x (1 - p) per $1 of payout.
+
+    ``contracts`` counts dollars of payout. Novig's v3 API quotes contracts that
+    pay 1 cent each, so divide a raw v3 quantity by 100 before passing it here.
+    Per docs.novig.com (checked 12 Nov 2026) the coefficient is 0.06 on straight
+    contracts. Game markets charge it only while the event is live (pregame
+    fills are fee-free); futures markets charge it in every phase. The maker
+    pays nothing and earns a credit of 0.25 of the taker fee on game markets
+    (0.5 on futures) since 22 Oct 2026. Read the market's fee object when you
+    have it.
+    """
+    if not 0.0 < price < 1.0:
+        raise ValueError("price must be between 0 and 1")
+    return coefficient * price * (1.0 - price) * contracts
+
+
+__all__ = [
+    "__version__",
+    "NovigAPI",
+    "NovigAPIError",
+    "RateLimitError",
+    "DEFAULT_BASE_URL",
+    "taker_fee",
+    "METHODS",
+    "devig",
+    "multiplicative",
+    "additive",
+    "power",
+    "shin",
+    "american_to_prob",
+    "decimal_to_prob",
+    "prob_to_american",
+    "prob_to_decimal",
+    "overround",
+    "hold",
+]

novigapi/client.py

@@ -0,0 +1,287 @@
+"""HTTP client for the novigapi.com REST API (read-only Novig market data).
+
+Standard library only: urllib for HTTP, json for parsing.
+
+Every method returns the parsed JSON envelope, a dict shaped like
+
+    {"data": [...] or {...}, "meta": {"next_cursor": ..., "limit": ..., "count": ...}}
+
+List endpoints page with ``cursor``: pass ``meta["next_cursor"]`` from the
+previous page, or use ``iter_rows`` to walk every page.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import urllib.error
+import urllib.parse
+import urllib.request
+from typing import Any, Dict, Iterator, Optional
+
+from . import __version__
+
+DEFAULT_BASE_URL = "https://novigapi.com/api/v1"
+Json = Dict[str, Any]
+
+__all__ = ["NovigAPI", "NovigAPIError", "RateLimitError", "DEFAULT_BASE_URL"]
+
+
+class NovigAPIError(Exception):
+    """Any non-2xx response. Carries the API's error code, message and HTTP status."""
+
+    def __init__(self, status: int, code: str, message: str, body: Optional[Json] = None, headers: Optional[Dict[str, str]] = None) -> None:
+        super().__init__("{} {}: {}".format(status, code, message))
+        self.status = status
+        self.code = code
+        self.message = message
+        self.body = body or {}
+        self.headers = headers or {}
+
+
+class RateLimitError(NovigAPIError):
+    """HTTP 429: the per-minute rate limit (RATE_LIMITED) or the monthly credits (QUOTA_EXCEEDED).
+
+    Fields from the 429 body are copied onto the exception:
+    plan, limit, reset_at (ISO 8601), upgrade_url, and retry_after (seconds, from the
+    Retry-After header, set on RATE_LIMITED only).
+    """
+
+    def __init__(self, status: int, code: str, message: str, body: Optional[Json] = None, headers: Optional[Dict[str, str]] = None) -> None:
+        super().__init__(status, code, message, body, headers)
+        err = (body or {}).get("error", {}) if isinstance(body, dict) else {}
+        self.plan: Optional[str] = err.get("plan")
+        self.limit: Optional[int] = err.get("limit")
+        self.reset_at: Optional[str] = err.get("reset_at")
+        self.upgrade_url: Optional[str] = err.get("upgrade_url")
+        retry = (headers or {}).get("retry-after")
+        self.retry_after: Optional[int] = int(retry) if retry and retry.isdigit() else None
+
+    def __str__(self) -> str:
+        parts = [super().__str__()]
+        if self.plan:
+            parts.append("plan={}".format(self.plan))
+        if self.limit is not None:
+            parts.append("limit={}".format(self.limit))
+        if self.reset_at:
+            parts.append("reset_at={}".format(self.reset_at))
+        if self.retry_after is not None:
+            parts.append("retry_after={}s".format(self.retry_after))
+        if self.upgrade_url:
+            parts.append("upgrade_url={}".format(self.upgrade_url))
+        return " ".join(parts)
+
+
+class NovigAPI:
+    """Client for https://novigapi.com/api/v1.
+
+    >>> api = NovigAPI()                      # reads NOVIGAPI_KEY from the environment
+    >>> page = api.markets(league="NFL", status="open", limit=50)
+    >>> for market in page["data"]:
+    ...     print(market["market_id"], market.get("description"))
+    """
+
+    def __init__(self, api_key: Optional[str] = None, base_url: str = DEFAULT_BASE_URL, timeout: float = 30.0) -> None:
+        key = api_key or os.environ.get("NOVIGAPI_KEY")
+        if not key:
+            raise ValueError("No API key. Set NOVIGAPI_KEY or pass api_key='nv_...'. Free keys: https://novigapi.com/sign-up")
+        if not key.startswith("nv_"):
+            raise ValueError("novigapi.com keys start with nv_")
+        self.api_key = key
+        self.base_url = base_url.rstrip("/")
+        self.timeout = timeout
+
+    # ----- transport -------------------------------------------------------
+
+    def get(self, path: str, **params: Any) -> Json:
+        """GET a path under the base URL. None-valued params are dropped."""
+        query = {k: _param(v) for k, v in params.items() if v is not None}
+        url = self.base_url + "/" + path.lstrip("/")
+        if query:
+            url += "?" + urllib.parse.urlencode(query)
+        req = urllib.request.Request(url, headers={
+            "Authorization": "Bearer " + self.api_key,
+            "Accept": "application/json",
+            "User-Agent": "novigapi-python/" + __version__,
+        })
+        try:
+            with urllib.request.urlopen(req, timeout=self.timeout) as resp:
+                raw = resp.read()
+                return json.loads(raw.decode("utf-8")) if raw else {}
+        except urllib.error.HTTPError as exc:
+            raise _error_from(exc) from None
+
+    def _raw(self, path: str) -> str:
+        req = urllib.request.Request(self.base_url + "/" + path, headers={
+            "Authorization": "Bearer " + self.api_key, "Accept": "text/csv", "User-Agent": "novigapi-python/" + __version__,
+        })
+        try:
+            with urllib.request.urlopen(req, timeout=self.timeout) as resp:
+                return resp.read().decode("utf-8")
+        except urllib.error.HTTPError as exc:
+            raise _error_from(exc) from None
+
+    def iter_rows(self, path: str, max_pages: Optional[int] = None, **params: Any) -> Iterator[Json]:
+        """Yield every row of a list endpoint, following meta.next_cursor."""
+        cursor = params.pop("cursor", None)
+        pages = 0
+        while True:
+            page = self.get(path, cursor=cursor, **params)
+            data = page.get("data") or []
+            for row in data if isinstance(data, list) else [data]:
+                yield row
+            pages += 1
+            cursor = (page.get("meta") or {}).get("next_cursor")
+            if not cursor or (max_pages is not None and pages >= max_pages):
+                return
+
+    # ----- markets and events ---------------------------------------------
+
+    def markets(self, league: Optional[str] = None, event_id: Optional[str] = None, market_type: Optional[str] = None,
+                player: Optional[str] = None, team: Optional[str] = None, status: Optional[str] = None,
+                limit: Optional[int] = None, cursor: Optional[str] = None) -> Json:
+        """GET /markets. status: open, closed, settled, suspended or all."""
+        return self.get("markets", league=league, event_id=event_id, market_type=market_type, player=player,
+                        team=team, status=status, limit=limit, cursor=cursor)
+
+    def events(self, league: Optional[str] = None, status: Optional[str] = None,
+               limit: Optional[int] = None, cursor: Optional[str] = None) -> Json:
+        """GET /events."""
+        return self.get("events", league=league, status=status, limit=limit, cursor=cursor)
+
+    def market(self, market_id: str) -> Json:
+        """GET /markets/{id}: one market with its outcomes."""
+        return self.get("markets/" + _path_id(market_id))
+
+    def orderbook(self, market_id: str) -> Json:
+        """GET /orderbook/{id}: the current book. Novig holds bids only; the ask on an
+        outcome is 1 minus the best bid on the other outcome."""
+        return self.get("orderbook/" + _path_id(market_id))
+
+    # ----- prices and history ---------------------------------------------
+
+    def trades(self, market_id: Optional[str] = None, since: Optional[str] = None,
+               limit: Optional[int] = None, cursor: Optional[str] = None) -> Json:
+        """GET /trades. since: ISO 8601 date or time."""
+        return self.get("trades", market_id=market_id, since=since, limit=limit, cursor=cursor)
+
+    def ohlc_daily(self, market_id: Optional[str] = None, date: Optional[str] = None,
+                   limit: Optional[int] = None, cursor: Optional[str] = None) -> Json:
+        """GET /ohlc/daily. Send market_id, date (YYYY-MM-DD) or both."""
+        if not market_id and not date:
+            raise ValueError("send market_id or date")
+        return self.get("ohlc/daily", market_id=market_id, date=date, limit=limit, cursor=cursor)
+
+    def fair_price(self, market_id: str) -> Json:
+        """GET /fair-price: the two-sided mid, fair_yes = (bid_yes + (1 - bid_no)) / 2."""
+        return self.get("fair-price", market_id=market_id)
+
+    def line_history(self, market_id: Optional[str] = None, outcome_id: Optional[str] = None,
+                     since: Optional[str] = None, until: Optional[str] = None,
+                     limit: Optional[int] = None, cursor: Optional[str] = None) -> Json:
+        """GET /line-history: intraday price ticks for a market or one outcome."""
+        if not market_id and not outcome_id:
+            raise ValueError("send market_id or outcome_id")
+        return self.get("line-history", market_id=market_id, outcome_id=outcome_id, since=since, until=until,
+                        limit=limit, cursor=cursor)
+
+    def line_moves(self, league: Optional[str] = None, market_id: Optional[str] = None, kind: Optional[str] = None,
+                   since: Optional[str] = None, min_delta_pp: Optional[float] = None, limit: Optional[int] = None,
+                   cursor: Optional[str] = None) -> Json:
+        """GET /line-moves. kind: move or steam. min_delta_pp: smallest move to return, in percentage points."""
+        return self.get("line-moves", league=league, market_id=market_id, kind=kind, since=since,
+                        min_delta_pp=min_delta_pp, limit=limit, cursor=cursor)
+
+    def clv(self, market_id: Optional[str] = None, player: Optional[str] = None, league: Optional[str] = None,
+            date: Optional[str] = None, settled: Optional[bool] = None, since: Optional[str] = None,
+            until: Optional[str] = None, limit: Optional[int] = None, cursor: Optional[str] = None) -> Json:
+        """GET /clv: each outcome's open_fair and close_fair before the start, clv_pp, and won once graded."""
+        if not any([market_id, player, league, date]):
+            raise ValueError("send market_id, player, league or date")
+        return self.get("clv", market_id=market_id, player=player, league=league, date=date, settled=settled,
+                        since=since, until=until, limit=limit, cursor=cursor)
+
+    def results(self, league: Optional[str] = None, market_id: Optional[str] = None, graded: Optional[bool] = None,
+                since: Optional[str] = None, limit: Optional[int] = None, cursor: Optional[str] = None) -> Json:
+        """GET /results: settled markets with the winning outcome where known."""
+        return self.get("results", league=league, market_id=market_id, graded=graded, since=since, limit=limit, cursor=cursor)
+
+    def market_summary(self, date: Optional[str] = None, since: Optional[str] = None, league: Optional[str] = None,
+                       market_type: Optional[str] = None, kind: Optional[str] = None,
+                       limit: Optional[int] = None, cursor: Optional[str] = None) -> Json:
+        """GET /market-summary/daily: straight markets and parlays (COMBO) per day from Novig's daily files."""
+        return self.get("market-summary/daily", date=date, since=since, league=league, market_type=market_type,
+                        kind=kind, limit=limit, cursor=cursor)
+
+    # ----- cross-venue: FanDuel and DraftKings against the Novig fair price ------
+
+    def ev(self, league: Optional[str] = None, market_type: Optional[str] = None, min_edge: Optional[float] = None,
+           books: Optional[str] = None, min_prob: Optional[float] = None, alt_lines: Optional[bool] = None,
+           confidence: Optional[str] = None, sort: Optional[str] = None, player: Optional[str] = None,
+           market_id: Optional[str] = None, limit: Optional[int] = None, cursor: Optional[str] = None) -> Json:
+        """GET /ev: book prices that pay more than the Novig fair probability. ev_pct = (fair x decimal - 1) x 100."""
+        return self.get("ev", league=league, market_type=market_type, min_edge=min_edge, books=books, min_prob=min_prob,
+                        alt_lines=alt_lines, confidence=confidence, sort=sort, player=player, market_id=market_id,
+                        limit=limit, cursor=cursor)
+
+    def arbitrage(self, type: Optional[str] = None, league: Optional[str] = None, market_type: Optional[str] = None,
+                  min_profit: Optional[float] = None, limit: Optional[int] = None, cursor: Optional[str] = None) -> Json:
+        """GET /arbitrage: two-way arbitrage across Novig, FanDuel and DraftKings, or type="middles". Production and up."""
+        return self.get("arbitrage", type=type, league=league, market_type=market_type, min_profit=min_profit,
+                        limit=limit, cursor=cursor)
+
+    def compare(self, market_id: str) -> Json:
+        """GET /compare/{market_id}: one Novig market beside each book on exactly the same line."""
+        return self.get("compare/" + _path_id(market_id))
+
+    def bulk_csv(self, dataset: str, market_id: Optional[str] = None, league: Optional[str] = None,
+                 since: Optional[str] = None, date: Optional[str] = None, limit: Optional[int] = None,
+                 cursor: Optional[str] = None) -> str:
+        """GET /bulk/csv: CSV text for a dataset such as line_moves. Production and up."""
+        query = {k: _param(v) for k, v in dict(dataset=dataset, market_id=market_id, league=league, since=since,
+                                                date=date, limit=limit, cursor=cursor).items() if v is not None}
+        return self._raw("bulk/csv?" + urllib.parse.urlencode(query))
+
+    # ----- names ----------------------------------------------------------
+
+    def player_props(self, league: str, player: str, limit: Optional[int] = None, cursor: Optional[str] = None) -> Json:
+        """GET /player-props. player is a slug, such as lebron-james."""
+        return self.get("player-props", league=league, player=player, limit=limit, cursor=cursor)
+
+    def players(self, league: Optional[str] = None, q: Optional[str] = None,
+                limit: Optional[int] = None, cursor: Optional[str] = None) -> Json:
+        """GET /players. q: name search, up to 80 characters."""
+        return self.get("players", league=league, q=q, limit=limit, cursor=cursor)
+
+    def teams(self, league: Optional[str] = None, limit: Optional[int] = None, cursor: Optional[str] = None) -> Json:
+        """GET /teams."""
+        return self.get("teams", league=league, limit=limit, cursor=cursor)
+
+    def leagues(self, limit: Optional[int] = None, cursor: Optional[str] = None) -> Json:
+        """GET /leagues."""
+        return self.get("leagues", limit=limit, cursor=cursor)
+
+
+def _param(value: Any) -> str:
+    if isinstance(value, bool):
+        return "true" if value else "false"
+    return str(value)
+
+
+def _path_id(value: str) -> str:
+    if not value:
+        raise ValueError("id is required")
+    return urllib.parse.quote(value, safe="")
+
+
+def _error_from(exc: urllib.error.HTTPError) -> NovigAPIError:
+    headers = {k.lower(): v for k, v in (exc.headers.items() if exc.headers else [])}
+    try:
+        body = json.loads(exc.read().decode("utf-8"))
+    except (ValueError, UnicodeDecodeError):
+        body = {}
+    err = body.get("error", {}) if isinstance(body, dict) else {}
+    code = str(err.get("code") or "HTTP_{}".format(exc.code))
+    message = str(err.get("message") or exc.reason or "request failed")
+    cls = RateLimitError if exc.code == 429 else NovigAPIError
+    return cls(exc.code, code, message, body if isinstance(body, dict) else {}, headers)

novigapi/devig.py

@@ -0,0 +1,202 @@
+"""Devig (remove the vig from) a set of mutually exclusive prices.
+
+Every function takes implied probabilities that sum to more than 1 (a book with
+a margin) and returns fair probabilities that sum to 1. All functions are pure:
+no I/O, no global state, standard library only.
+
+Novig quotes prices as probabilities shown as percentages (54% = 0.54). A
+sportsbook quotes American or decimal odds; convert those first with
+``american_to_prob`` or ``decimal_to_prob``.
+
+Methods:
+
+- ``multiplicative``: divide each probability by the total. The default most
+  calculators use.
+- ``additive``: subtract an equal share of the margin from each outcome.
+- ``power``: find k so that the sum of q_i ** k is 1. Takes more margin from
+  longshots than from favourites.
+- ``shin``: Shin's (1993) model, which assumes a share z of the money is
+  informed. Also shifts margin toward longshots.
+"""
+
+from __future__ import annotations
+
+import math
+from typing import Callable, Dict, List, Sequence
+
+__all__ = [
+    "american_to_prob",
+    "decimal_to_prob",
+    "prob_to_american",
+    "prob_to_decimal",
+    "overround",
+    "hold",
+    "multiplicative",
+    "additive",
+    "power",
+    "shin",
+    "devig",
+    "METHODS",
+]
+
+
+def american_to_prob(odds: float) -> float:
+    """Implied probability of American odds, margin included.
+
+    -110 -> 0.5238..., +150 -> 0.4.
+    """
+    if odds == 0 or -100 < odds < 100:
+        raise ValueError("American odds must be <= -100 or >= +100")
+    if odds < 0:
+        return -odds / (-odds + 100.0)
+    return 100.0 / (odds + 100.0)
+
+
+def decimal_to_prob(odds: float) -> float:
+    """Implied probability of decimal odds. 2.50 -> 0.4."""
+    if odds <= 1.0:
+        raise ValueError("decimal odds must be greater than 1")
+    return 1.0 / odds
+
+
+def prob_to_american(p: float) -> float:
+    """American odds for a probability. 0.4 -> +150, 0.6 -> -150, 0.5 -> +100."""
+    _check_prob(p)
+    if p > 0.5:
+        return -100.0 * p / (1.0 - p)
+    return 100.0 * (1.0 - p) / p
+
+
+def prob_to_decimal(p: float) -> float:
+    """Decimal odds for a probability. 0.4 -> 2.5."""
+    _check_prob(p)
+    return 1.0 / p
+
+
+def overround(probs: Sequence[float]) -> float:
+    """Sum of implied probabilities minus 1. -110/-110 -> 0.047619..."""
+    return math.fsum(probs) - 1.0
+
+
+def hold(probs: Sequence[float]) -> float:
+    """Theoretical hold: the share of total stake the book keeps on a balanced book.
+
+    hold = 1 - 1 / sum(probs). -110/-110 -> 0.04545...
+    """
+    return 1.0 - 1.0 / math.fsum(probs)
+
+
+def multiplicative(probs: Sequence[float]) -> List[float]:
+    """Normalise: p_i = q_i / sum(q).
+
+    Keeps the ratio between outcomes. Also called the proportional or basic method.
+    """
+    qs = _validate(probs)
+    total = math.fsum(qs)
+    return [q / total for q in qs]
+
+
+def additive(probs: Sequence[float]) -> List[float]:
+    """Subtract an equal share of the margin: p_i = q_i - (sum(q) - 1) / n.
+
+    On a lopsided market this can push a longshot to zero or below; when that
+    happens the outcome is floored at 0 and the rest are renormalised, and the
+    result should be treated with suspicion.
+    """
+    qs = _validate(probs)
+    margin = (math.fsum(qs) - 1.0) / len(qs)
+    out = [q - margin for q in qs]
+    if min(out) <= 0.0:
+        out = [max(p, 0.0) for p in out]
+        total = math.fsum(out)
+        out = [p / total for p in out]
+    return out
+
+
+def power(probs: Sequence[float], tol: float = 1e-12, max_iter: int = 200) -> List[float]:
+    """Solve for k with sum(q_i ** k) = 1, then p_i = q_i ** k.
+
+    With a positive margin k > 1, which shrinks small probabilities faster than
+    large ones, so longshots carry more of the margin.
+    """
+    qs = _validate(probs)
+    f: Callable[[float], float] = lambda k: math.fsum(q ** k for q in qs) - 1.0
+    lo, hi = 1e-6, 1.0
+    # sum(q^k) falls as k grows; widen the bracket until it straddles zero.
+    while f(hi) > 0.0:
+        hi *= 2.0
+        if hi > 1e6:
+            raise ValueError("power method did not converge")
+    k = _bisect(f, lo, hi, tol, max_iter, decreasing=True)
+    out = [q ** k for q in qs]
+    total = math.fsum(out)
+    return [p / total for p in out]
+
+
+def shin(probs: Sequence[float], tol: float = 1e-12, max_iter: int = 200) -> List[float]:
+    """Shin's method.
+
+    For a share z of insider money, the fair probability of outcome i is
+
+        p_i(z) = (sqrt(z^2 + 4 (1 - z) q_i^2 / S) - z) / (2 (1 - z))
+
+    where q_i are the implied probabilities and S is their sum. z is chosen so
+    the p_i sum to 1. On a book with no margin z = 0 and p_i = q_i.
+    """
+    qs = _validate(probs)
+    total = math.fsum(qs)
+    if total <= 1.0:
+        return [q / total for q in qs]
+
+    def fair(z: float) -> List[float]:
+        return [(math.sqrt(z * z + 4.0 * (1.0 - z) * q * q / total) - z) / (2.0 * (1.0 - z)) for q in qs]
+
+    f = lambda z: math.fsum(fair(z)) - 1.0
+    z = _bisect(f, 0.0, 0.999, tol, max_iter, decreasing=True)
+    out = fair(z)
+    s = math.fsum(out)
+    return [p / s for p in out]
+
+
+METHODS: Dict[str, Callable[[Sequence[float]], List[float]]] = {
+    "multiplicative": multiplicative,
+    "additive": additive,
+    "power": power,
+    "shin": shin,
+}
+
+
+def devig(probs: Sequence[float], method: str = "multiplicative") -> List[float]:
+    """Devig with the named method: multiplicative, additive, power or shin."""
+    try:
+        fn = METHODS[method]
+    except KeyError:
+        raise ValueError("method must be one of: " + ", ".join(METHODS)) from None
+    return fn(probs)
+
+
+def _check_prob(p: float) -> None:
+    if not 0.0 < p < 1.0:
+        raise ValueError("probability must be between 0 and 1 (exclusive)")
+
+
+def _validate(probs: Sequence[float]) -> List[float]:
+    qs = [float(q) for q in probs]
+    if len(qs) < 2:
+        raise ValueError("need at least two outcomes")
+    for q in qs:
+        _check_prob(q)
+    return qs
+
+
+def _bisect(f: Callable[[float], float], lo: float, hi: float, tol: float, max_iter: int, decreasing: bool) -> float:
+    for _ in range(max_iter):
+        mid = (lo + hi) / 2.0
+        v = f(mid)
+        if abs(v) < tol:
+            return mid
+        if (v > 0.0) == decreasing:
+            lo = mid
+        else:
+            hi = mid
+    return (lo + hi) / 2.0

novigapi-0.1.0.dist-info/METADATA

@@ -0,0 +1,161 @@
+Metadata-Version: 2.4
+Name: novigapi
+Version: 0.1.0
+Summary: Python client for novigapi.com, a read-only Novig market data API, plus devig helpers. Independent; not affiliated with Novig.
+License: MIT
+Project-URL: Repository, https://github.com/novigapi/novigapi-python
+Project-URL: Issues, https://github.com/novigapi/novigapi-python/issues
+Project-URL: Homepage, https://novigapi.com
+Project-URL: Documentation, https://novigapi.com/docs
+Project-URL: Python guide, https://novigapi.com/novig-api-python
+Keywords: novig,odds,devig,no-vig,prediction-market,sports-data,closing-line-value
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Office/Business :: Financial
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Dynamic: license-file
+
+# novigapi (Python)
+
+A small Python client for [novigapi.com](https://novigapi.com), a read-only Novig market data API, plus pure-Python devig helpers and three runnable examples.
+
+Novig has an official trading API and free daily CSVs. novigapi.com is the read-only data layer on top: no account, names resolved, intraday line history, fair prices and alerts. This package talks to novigapi.com. To place orders or read a Novig account, use the official Novig API documented at [docs.novig.com](https://docs.novig.com).
+
+Independent. Not affiliated with, endorsed by or sponsored by Novig.
+
+- Standard library only (`urllib`, `json`). Python 3.8 or later. No dependencies.
+- MIT licensed.
+
+## Install
+
+```bash
+pip install novigapi
+```
+
+Not on PyPI yet: the name `novigapi` was free on 15 Nov 2026 and the package is ready to publish. Until then, from a clone: `pip install -e .`
+
+Tests need no key, no network and no pytest: `python3 tests/run.py` (pytest also works).
+
+## Quickstart
+
+Get a free key at [novigapi.com/sign-up](https://novigapi.com/sign-up) (Free plan: 100 credits a month, 20 requests a minute), then:
+
+```bash
+export NOVIGAPI_KEY=nv_...
+```
+
+```python
+from novigapi import NovigAPI, devig, prob_to_american
+
+api = NovigAPI()  # reads NOVIGAPI_KEY
+
+page = api.markets(league="NFL", status="open", limit=20)
+for market in page["data"]:
+    print(market["market_id"], market.get("description"))
+
+fair = api.fair_price(page["data"][0]["market_id"])
+print(fair["data"], fair["meta"].get("formula"))
+
+# Devig any two prices (probabilities from 0 to 1)
+print(devig([0.5238, 0.5238], "shin"))        # [0.5, 0.5]
+print(prob_to_american(0.40))                  # 150.0
+```
+
+Every method returns the JSON envelope `{"data": ..., "meta": {...}}`. List endpoints page with `cursor`; `api.iter_rows("markets", league="NBA")` follows `meta.next_cursor` for you.
+
+### Methods
+
+| Method | Endpoint |
+|---|---|
+| `markets(league, event_id, market_type, player, team, status, limit, cursor)` | `GET /markets` |
+| `events(league, status, limit, cursor)` | `GET /events` |
+| `market(market_id)` | `GET /markets/{id}` |
+| `orderbook(market_id)` | `GET /orderbook/{id}` |
+| `trades(market_id, since, limit, cursor)` | `GET /trades` |
+| `ohlc_daily(market_id, date)` | `GET /ohlc/daily` |
+| `fair_price(market_id)` | `GET /fair-price` |
+| `line_history(market_id or outcome_id, since, until)` | `GET /line-history` |
+| `player_props(league, player)` | `GET /player-props` |
+| `players(league, q)`, `teams(league)`, `leagues()` | `GET /players`, `/teams`, `/leagues` |
+| `results(league, market_id, graded, since)` | `GET /results` |
+| `market_summary(date, since, league, market_type, kind)` | `GET /market-summary/daily` |
+| `ev(league, min_edge, min_prob, books, sort, ...)` | `GET /ev` (FanDuel and DraftKings vs the Novig fair price) |
+| `arbitrage(type, league, min_profit)` | `GET /arbitrage` (Production and up) |
+| `compare(market_id)` | `GET /compare/{market_id}` |
+| `bulk_csv(dataset, ...)` | `GET /bulk/csv` (Production and up), returns CSV text |
+| `clv(market_id, player, league, date, settled, since, until)` | `GET /clv` |
+| `line_moves(league, market_id, kind, since, min_delta_pp)` | `GET /line-moves` |
+
+Base URL `https://novigapi.com/api/v1`. Auth header `Authorization: Bearer nv_...`. Full reference: [novigapi.com/docs](https://novigapi.com/docs).
+
+### Errors and limits
+
+Any non-2xx response raises `NovigAPIError` with `status`, `code` and `message`. A 429 raises `RateLimitError`, which also carries the fields from the 429 body:
+
+```python
+from novigapi import NovigAPI, RateLimitError
+import time
+
+api = NovigAPI()
+try:
+    api.markets(league="NBA")
+except RateLimitError as err:
+    print(err.code, err.plan, err.limit, err.reset_at, err.upgrade_url)
+    if err.code == "RATE_LIMITED" and err.retry_after:
+        time.sleep(err.retry_after)
+```
+
+`RATE_LIMITED` is the per-minute limit and sends `Retry-After`. `QUOTA_EXCEEDED` means the month's credits are used; there are no automatic overage charges.
+
+## Devig helpers
+
+`novigapi.devig` has four methods as pure functions with docstrings: `multiplicative`, `additive`, `power` and `shin`, plus `american_to_prob`, `prob_to_american`, `decimal_to_prob`, `prob_to_decimal`, `overround` and `hold`. `novigapi.taker_fee(price, contracts, coefficient=0.06)` returns Novig's taker fee, `coefficient x p x (1 - p) x contracts`, per [docs.novig.com](https://docs.novig.com/fees.md) (checked 12 Nov 2026).
+
+Worked example, -300 / +240 (implied 75.00% and 29.41%, 4.41% overround):
+
+| Method | Favourite | Longshot |
+|---|---|---|
+| Multiplicative | 71.83% (-255) | 28.17% (+255) |
+| Additive | 72.79% (-268) | 27.21% (+268) |
+| Power | 73.31% (-275) | 26.69% (+275) |
+| Shin | 72.79% (-268) | 27.21% (+268) |
+
+With two outcomes, Shin and additive agree. The [no-vig calculator](https://novigapi.com/no-vig-calculator) runs the same four methods in the browser.
+
+## Examples
+
+```bash
+python examples/devig_board.py --league NFL --method shin     # devig every two-sided market in a league
+python examples/arb_scanner.py --league NBA                   # combined price below $1 after the taker fee
+python examples/clv_backtest.py --start 2026-08-04 --end 2026-11-11   # no key needed
+```
+
+- `devig_board.py` lists open two-way markets for a league and prints the fair probability and fair American odds of each side.
+- `arb_scanner.py` adds the taker fee to each leg, `0.06 x p x (1 - p)` per $1 of payout (pregame game-market fills are fee-free; the default charges every leg, the conservative case), and reports any pair that costs less than $1. Pass `--other prices.csv` to pair a Novig side with a price you collected from another venue.
+- `clv_backtest.py` streams Novig's own daily `markets.csv` files from `https://data.novig.com/reporting/trade-data/<date>/markets.csv` and compares an entry price (the opening print, or yours via `--bets`) with the `close` column. It needs no API key and saves nothing to disk. Pass `--results` with `market_id,won` to score open against close with the Brier score, or `--martingale` to test, without any results, whether one day's move predicts the next day's.
+
+Tests:
+
+```bash
+pip install -e ".[test]"
+pytest tests -q
+```
+
+## Data notes
+
+- Prices are probabilities. Novig shows them as percentages: 54% is 0.54.
+- Novig's book holds bids only. The ask on an outcome is 1 minus the best bid on the other outcome.
+- REST data on paid plans is at most about 10 seconds old; the stream pushes changes within 5 to 30 seconds.
+- Novig's daily CSVs start in early August 2026 and carry no player or team names; novigapi.com joins the names.
+
+## License
+
+MIT. Copyright (c) 2026 Stunning Couches LLC.
+
+Independent. Not affiliated with, endorsed by or sponsored by Novig.

novigapi-0.1.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+novigapi/__init__.py,sha256=vAU_k2LNzTrcFVg27QTKJm7o7j17hEw2D8F3ero1LfE,1735
+novigapi/client.py,sha256=OUG-cvC18N33apCZXzHY7uy9Rs-ZJzI-sJfT4JHERF0,15378
+novigapi/devig.py,sha256=LOaxHLKYVbFcXgfBbjo03wNlXKhLvgUdEY37pdlnoDI,6263
+novigapi-0.1.0.dist-info/licenses/LICENSE,sha256=x4zI-m2lWxFFkFn_BD86vA8lXA7YD4gq45y0VrP1r2o,1077
+novigapi-0.1.0.dist-info/METADATA,sha256=1jhRDIG3kf9BUKV6UBoQM9OYW-k2kBQ27rAwOXXze0k,7769
+novigapi-0.1.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+novigapi-0.1.0.dist-info/top_level.txt,sha256=txUtRU8yEVHe2jVz2p-MM6UHRe0kHXET0G3f6z6lWgU,9
+novigapi-0.1.0.dist-info/RECORD,,

novigapi-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
+

novigapi-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Stunning Couches LLC
+
+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.

novigapi-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+novigapi