oddspush 0.1.0__tar.gz

oddspush-0.1.0/.gitignore

@@ -0,0 +1,7 @@
+__pycache__/
+*.py[cod]
+*.egg-info/
+build/
+dist/
+.venv/
+.pytest_cache/

oddspush-0.1.0/CHANGELOG.md

@@ -0,0 +1,5 @@
+# Changelog
+
+## 0.1.0
+
+First release: `Stream`, `Client`, `AsyncClient`, `Book` and the odds helpers.

oddspush-0.1.0/LICENSE

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

oddspush-0.1.0/PKG-INFO

@@ -0,0 +1,193 @@
+Metadata-Version: 2.5
+Name: oddspush
+Version: 0.1.0
+Summary: Python client for the OddsPush API: real-time Pinnacle odds over WebSocket and REST, with no-vig, fair and closing-line (CLV) prices.
+Project-URL: Homepage, https://oddspush.com
+Project-URL: Documentation, https://oddspush.com/docs
+Project-URL: Pricing, https://oddspush.com/#pricing
+Project-URL: Source, https://github.com/oddspush/oddspush-python
+Project-URL: Issues, https://github.com/oddspush/oddspush-python/issues
+Author-email: OddsPush <support@oddspush.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: betting,closing-line,clv,fair-odds,kalshi,no-vig,odds,odds-api,pinnacle,pinnacle-api,polymarket,sports-betting,websocket
+Classifier: Development Status :: 4 - Beta
+Classifier: Framework :: AsyncIO
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: httpx>=0.24
+Requires-Dist: websockets>=12
+Provides-Extra: test
+Requires-Dist: pytest-asyncio>=0.21; extra == 'test'
+Requires-Dist: pytest>=7; extra == 'test'
+Description-Content-Type: text/markdown
+
+# oddspush
+
+Python client for the [OddsPush](https://oddspush.com) API: **real-time Pinnacle odds** over
+one WebSocket, plus a REST API, with **no-vig and fair prices** and the **closing line** for
+your CLV.
+
+- All 13 sports, live and pre-match.
+- A local price book, kept up to date for you: merged by version, closed markets and
+  periods removed.
+- Reconnects on its own with backoff, subscribes again and catches up with a snapshot.
+- Sync and asyncio REST clients.
+- Pure Python, two dependencies (`websockets`, `httpx`), Python 3.10+.
+
+You need an API token (`opk_...`). [Start a free 7-day trial](https://oddspush.com) to get
+one. Full API reference: [oddspush.com/docs](https://oddspush.com/docs).
+
+```bash
+pip install oddspush
+```
+
+## Stream live odds
+
+```python
+import asyncio
+from oddspush import Stream
+
+async def main():
+    async with Stream("opk_...", sports=[1], channels=["ld", "both"]) as stream:
+        async for msg in stream:
+            if msg["type"] == "odds" and msg["data"].get("type") == "live":
+                rec = msg["data"]["rec"]
+                for key, market in stream.book.markets(rec["id"]).items():
+                    print(rec["id"], key, [(p["designation"], p["price"]) for p in market["prices"]])
+
+asyncio.run(main())
+```
+
+`stream.book` always holds the current open markets of every event you follow:
+
+```python
+stream.book.event_ids()               # events in the book
+stream.book.event(event_id)           # league, participants, state, startTime...
+stream.book.markets(event_id)         # {"s;0;m": {...}, "s;0;ou;2.5": {...}}
+stream.book.market(event_id, "s;0;m")
+```
+
+Prices are in American odds; `oddspush.american_to_decimal(-155)` gives `1.645`.
+
+Sports: 1 Soccer, 2 Tennis, 3 Basketball, 4 Hockey, 5 American football, 6 Baseball,
+7 Rugby, 8 MMA, 9 Boxing, 10 Other (volleyball and handball), 11 Esports, 12 Golf,
+13 Cricket (`oddspush.SPORTS`).
+
+Channels: `ld` and `both` are the prices (ask for both). Add `pre` for pre-match prices.
+`dz` carries volatile moments: the book leaves it out, and with `dz` in your channels the
+stream asks for snapshots of the book's channels only. Without `channels`, live updates come
+on every channel; the book still takes only `ld` and `both`.
+
+## No-vig and fair prices
+
+```python
+async with Stream("opk_...", sports=[1], channels=["ld", "both"], fair=True) as stream:
+    async for msg in stream:
+        if msg["type"] == "fair":
+            for m in msg["data"]["markets"]:
+                print(m["key"], m["margin"], [(p["designation"], p["fair_decimal"]) for p in m["prices"]])
+```
+
+Each `fair` message follows its `odds` update with the same markets priced without the
+bookmaker's margin, two ways: `no_vig` (multiplicative) and `fair` (power method, which
+corrects the favourite-longshot bias). The book keeps them too:
+
+```python
+stream.book.fair(event_id, "s;0;m")   # {"version", "margin", "prices"} or None
+```
+
+It only returns the fair price of the very market version the book holds.
+
+## Closing line and CLV
+
+```python
+from oddspush import Client, clv
+
+with Client("opk_...") as api:
+    line = api.closing(1639824805)          # pre-match or live event id
+    ml = next(m for m in line["markets"] if m["key"] == "s;0;m")
+    home = next(p for p in ml["prices"] if p["designation"] == "home")
+    print(clv(2.10, home["fair_decimal"]))  # your price vs the fair closing price
+```
+
+Or get them as they happen with `Stream(..., closing=True)` (`closing` messages).
+
+## REST
+
+```python
+from oddspush import Client
+
+with Client("opk_...") as api:
+    api.events(sport_id=1)                          # every event, markets per channel
+    api.event(1638807209, fair=True)                # one event, ld + both merged
+    api.event(1639824805, channel="pre", fair=True) # a pre-match event
+    api.membership(sport_id=1)                      # pre-match events about to go live
+    for row in api.iter_closings(sport_id=1):       # matches with a closing line
+        print(row["event_id"], row["start_ms"])
+```
+
+`AsyncClient` has the same methods, awaitable. A `429` is retried after `retry-after`
+(`max_retries=2`), then raised as `RateLimited`. Limits: 120 requests at once, then 300 a
+minute per account.
+
+## What the stream does for you
+
+- Logs in and subscribes. After a drop it reconnects with exponential backoff (1 s, 2 s,
+  4 s... up to 30 s), restores your filter and asks for a snapshot.
+- Asks for a snapshot after `missed` (you fell behind) and after `feed: up` (the source
+  came back), and again later if the snapshot rate limit says so.
+- Yields `{"type": "disconnected", "reason": ..., "retry_in_s": ...}` each time the
+  connection drops, so you can log it.
+- Snapshots count against your plan's `snapshots_per_hour`. Pass `resync=False` to stop
+  the automatic ones.
+- Stops and raises on what retrying cannot fix: `Unauthorized`, `SubscriptionExpired`,
+  `NotInPlan` (a REST-only plan) and `TokenReplaced`.
+
+Change the subscription at any time:
+
+```python
+await stream.subscribe(sports=[2, 3])
+await stream.unsubscribe(sports=[3])
+await stream.subscribe(fair=True)     # turn fair prices on, filter unchanged, no snapshot
+await stream.request_snapshot()
+```
+
+In a bot that runs for days, `stream.book.prune(3600)` drops events that have had no update
+for an hour and have no open market left.
+
+### One machine per token
+
+A token works from one IP at a time: using it from a new IP (a stream login or a REST
+request) moves it there and closes the stream on the old one (`TokenReplaced`). Run your
+stream and your REST calls from the same machine.
+
+### Keep up
+
+Read fast and do heavy work in another task: if you fall more than 15 seconds behind, the
+server closes the connection and the stream reconnects. Host your bot close to Ireland (AWS
+`eu-west-1`) for the lowest latency.
+
+## Examples
+
+See [`examples/`](https://github.com/oddspush/oddspush-python/tree/main/examples): a live
+printer, a fair-price watcher, a pre-match tracker and a CLV report.
+
+## Links
+
+- Website and pricing: [oddspush.com](https://oddspush.com)
+- API reference: [oddspush.com/docs](https://oddspush.com/docs)
+- Source and issues: [github.com/oddspush/oddspush-python](https://github.com/oddspush/oddspush-python)
+- Support: support@oddspush.com
+
+OddsPush is not affiliated with, endorsed by or sponsored by Pinnacle. MIT licensed.

oddspush-0.1.0/README.md

@@ -0,0 +1,159 @@
+# oddspush
+
+Python client for the [OddsPush](https://oddspush.com) API: **real-time Pinnacle odds** over
+one WebSocket, plus a REST API, with **no-vig and fair prices** and the **closing line** for
+your CLV.
+
+- All 13 sports, live and pre-match.
+- A local price book, kept up to date for you: merged by version, closed markets and
+  periods removed.
+- Reconnects on its own with backoff, subscribes again and catches up with a snapshot.
+- Sync and asyncio REST clients.
+- Pure Python, two dependencies (`websockets`, `httpx`), Python 3.10+.
+
+You need an API token (`opk_...`). [Start a free 7-day trial](https://oddspush.com) to get
+one. Full API reference: [oddspush.com/docs](https://oddspush.com/docs).
+
+```bash
+pip install oddspush
+```
+
+## Stream live odds
+
+```python
+import asyncio
+from oddspush import Stream
+
+async def main():
+    async with Stream("opk_...", sports=[1], channels=["ld", "both"]) as stream:
+        async for msg in stream:
+            if msg["type"] == "odds" and msg["data"].get("type") == "live":
+                rec = msg["data"]["rec"]
+                for key, market in stream.book.markets(rec["id"]).items():
+                    print(rec["id"], key, [(p["designation"], p["price"]) for p in market["prices"]])
+
+asyncio.run(main())
+```
+
+`stream.book` always holds the current open markets of every event you follow:
+
+```python
+stream.book.event_ids()               # events in the book
+stream.book.event(event_id)           # league, participants, state, startTime...
+stream.book.markets(event_id)         # {"s;0;m": {...}, "s;0;ou;2.5": {...}}
+stream.book.market(event_id, "s;0;m")
+```
+
+Prices are in American odds; `oddspush.american_to_decimal(-155)` gives `1.645`.
+
+Sports: 1 Soccer, 2 Tennis, 3 Basketball, 4 Hockey, 5 American football, 6 Baseball,
+7 Rugby, 8 MMA, 9 Boxing, 10 Other (volleyball and handball), 11 Esports, 12 Golf,
+13 Cricket (`oddspush.SPORTS`).
+
+Channels: `ld` and `both` are the prices (ask for both). Add `pre` for pre-match prices.
+`dz` carries volatile moments: the book leaves it out, and with `dz` in your channels the
+stream asks for snapshots of the book's channels only. Without `channels`, live updates come
+on every channel; the book still takes only `ld` and `both`.
+
+## No-vig and fair prices
+
+```python
+async with Stream("opk_...", sports=[1], channels=["ld", "both"], fair=True) as stream:
+    async for msg in stream:
+        if msg["type"] == "fair":
+            for m in msg["data"]["markets"]:
+                print(m["key"], m["margin"], [(p["designation"], p["fair_decimal"]) for p in m["prices"]])
+```
+
+Each `fair` message follows its `odds` update with the same markets priced without the
+bookmaker's margin, two ways: `no_vig` (multiplicative) and `fair` (power method, which
+corrects the favourite-longshot bias). The book keeps them too:
+
+```python
+stream.book.fair(event_id, "s;0;m")   # {"version", "margin", "prices"} or None
+```
+
+It only returns the fair price of the very market version the book holds.
+
+## Closing line and CLV
+
+```python
+from oddspush import Client, clv
+
+with Client("opk_...") as api:
+    line = api.closing(1639824805)          # pre-match or live event id
+    ml = next(m for m in line["markets"] if m["key"] == "s;0;m")
+    home = next(p for p in ml["prices"] if p["designation"] == "home")
+    print(clv(2.10, home["fair_decimal"]))  # your price vs the fair closing price
+```
+
+Or get them as they happen with `Stream(..., closing=True)` (`closing` messages).
+
+## REST
+
+```python
+from oddspush import Client
+
+with Client("opk_...") as api:
+    api.events(sport_id=1)                          # every event, markets per channel
+    api.event(1638807209, fair=True)                # one event, ld + both merged
+    api.event(1639824805, channel="pre", fair=True) # a pre-match event
+    api.membership(sport_id=1)                      # pre-match events about to go live
+    for row in api.iter_closings(sport_id=1):       # matches with a closing line
+        print(row["event_id"], row["start_ms"])
+```
+
+`AsyncClient` has the same methods, awaitable. A `429` is retried after `retry-after`
+(`max_retries=2`), then raised as `RateLimited`. Limits: 120 requests at once, then 300 a
+minute per account.
+
+## What the stream does for you
+
+- Logs in and subscribes. After a drop it reconnects with exponential backoff (1 s, 2 s,
+  4 s... up to 30 s), restores your filter and asks for a snapshot.
+- Asks for a snapshot after `missed` (you fell behind) and after `feed: up` (the source
+  came back), and again later if the snapshot rate limit says so.
+- Yields `{"type": "disconnected", "reason": ..., "retry_in_s": ...}` each time the
+  connection drops, so you can log it.
+- Snapshots count against your plan's `snapshots_per_hour`. Pass `resync=False` to stop
+  the automatic ones.
+- Stops and raises on what retrying cannot fix: `Unauthorized`, `SubscriptionExpired`,
+  `NotInPlan` (a REST-only plan) and `TokenReplaced`.
+
+Change the subscription at any time:
+
+```python
+await stream.subscribe(sports=[2, 3])
+await stream.unsubscribe(sports=[3])
+await stream.subscribe(fair=True)     # turn fair prices on, filter unchanged, no snapshot
+await stream.request_snapshot()
+```
+
+In a bot that runs for days, `stream.book.prune(3600)` drops events that have had no update
+for an hour and have no open market left.
+
+### One machine per token
+
+A token works from one IP at a time: using it from a new IP (a stream login or a REST
+request) moves it there and closes the stream on the old one (`TokenReplaced`). Run your
+stream and your REST calls from the same machine.
+
+### Keep up
+
+Read fast and do heavy work in another task: if you fall more than 15 seconds behind, the
+server closes the connection and the stream reconnects. Host your bot close to Ireland (AWS
+`eu-west-1`) for the lowest latency.
+
+## Examples
+
+See [`examples/`](https://github.com/oddspush/oddspush-python/tree/main/examples): a live
+printer, a fair-price watcher, a pre-match tracker and a CLV report.
+
+## Links
+
+- Website and pricing: [oddspush.com](https://oddspush.com)
+- API reference: [oddspush.com/docs](https://oddspush.com/docs)
+- Source and issues: [github.com/oddspush/oddspush-python](https://github.com/oddspush/oddspush-python)
+- Support: support@oddspush.com
+
+OddsPush is not affiliated with, endorsed by or sponsored by Pinnacle. MIT licensed.

oddspush-0.1.0/examples/clv_report.py

@@ -0,0 +1,40 @@
+"""Closing line value of your bets, against Pinnacle's fair closing price.
+
+bets.csv has one bet per line: event_id,market_key,designation,decimal_odds
+(for example ``1639824805,s;0;m,home,2.10``). Closing lines are kept for 7 days.
+
+    ODDSPUSH_TOKEN=opk_... python clv_report.py bets.csv
+"""
+
+import csv
+import os
+import sys
+
+from oddspush import Client, NotFound, clv
+
+
+def main(path):
+    total, n = 0.0, 0
+    with Client(os.environ["ODDSPUSH_TOKEN"]) as api, open(path, newline="") as f:
+        for event_id, key, designation, odds in csv.reader(f):
+            try:
+                line = api.closing(int(event_id))
+            except NotFound:
+                print(f"{event_id}: no closing line (not started yet, or older than 7 days)")
+                continue
+            market = next((m for m in line["markets"] if m["key"] == key), None)
+            leg = next((p for p in (market or {}).get("prices", [])
+                        if p["designation"] == designation), None)
+            if leg is None:
+                print(f"{event_id} {key} {designation}: not in the closing line")
+                continue
+            value = clv(float(odds), leg["fair_decimal"])
+            total, n = total + value, n + 1
+            print(f"{line['home']} v {line['away']} {key} {designation}: "
+                  f"{float(odds):.2f} vs fair close {leg['fair_decimal']:.2f} -> CLV {value:+.2%}")
+    if n:
+        print(f"average CLV over {n} bets: {total / n:+.2%}")
+
+
+if __name__ == "__main__":
+    main(sys.argv[1])

oddspush-0.1.0/examples/fair_prices.py

@@ -0,0 +1,29 @@
+"""Watch the no-vig and fair prices of tennis moneylines, with the bookmaker's margin.
+
+    ODDSPUSH_TOKEN=opk_... python fair_prices.py
+"""
+
+import asyncio
+import os
+
+from oddspush import Stream
+
+
+async def main():
+    async with Stream(os.environ["ODDSPUSH_TOKEN"], sports=[2], channels=["ld", "both"],
+                      fair=True) as stream:
+        async for msg in stream:
+            if msg["type"] != "fair":
+                continue
+            data = msg["data"]
+            for market in data["markets"]:
+                if market["key"] != "s;0;m":
+                    continue
+                legs = ", ".join(f"{p['designation']} {p['fair_decimal']:.3f} "
+                                 f"(no-vig {p['no_vig_decimal']:.3f})"
+                                 for p in market["prices"])
+                print(f"{data['event_id']}: margin {market['margin']:.2%} | {legs}")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

oddspush-0.1.0/examples/live_odds.py

@@ -0,0 +1,34 @@
+"""Print the full-game moneyline of every soccer match as it moves.
+
+    ODDSPUSH_TOKEN=opk_... python live_odds.py
+"""
+
+import asyncio
+import os
+
+from oddspush import Stream, american_to_decimal
+
+
+def teams(event):
+    names = {p.get("alignment"): p.get("name") for p in event.get("participants") or []}
+    return f"{names.get('home', '?')} v {names.get('away', '?')}"
+
+
+async def main():
+    async with Stream(os.environ["ODDSPUSH_TOKEN"], sports=[1], channels=["ld", "both"]) as stream:
+        async for msg in stream:
+            if msg["type"] == "disconnected":
+                print("disconnected:", msg["reason"], "- retrying in", msg["retry_in_s"], "s")
+            if msg["type"] != "odds" or msg["data"].get("type") != "live":
+                continue
+            event_id = msg["data"]["rec"]["id"]
+            moneyline = stream.book.market(event_id, "s;0;m")
+            if moneyline is None:
+                continue
+            prices = {p["designation"]: round(american_to_decimal(p["price"]), 3)
+                      for p in moneyline["prices"]}
+            print(teams(stream.book.event(event_id)), prices)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

oddspush-0.1.0/examples/prematch_tracker.py

@@ -0,0 +1,69 @@
+"""Track the pre-match fair price of a few matches until each one really kicks off.
+
+Pre-match prices come on the ``pre`` channel. When a match starts (which can be later than
+its scheduled ``startTime``), its closing line is set and arrives as a ``closing`` message:
+the pre-match prices are final from then on, so the tracker prints the close and stops
+following that match.
+
+    ODDSPUSH_TOKEN=opk_... python prematch_tracker.py 1639824805 1639824811
+"""
+
+import asyncio
+import os
+import sys
+import time
+
+from oddspush import Stream
+
+GIVE_UP_S = 600     # an id that never shows up (wrong id, or already over)
+
+
+def moneyline(prices):
+    return ", ".join(f"{p['designation']} {p['fair_decimal']:.3f}" for p in prices)
+
+
+async def main(event_ids):
+    following = set(event_ids)
+    seen = set()
+    started = time.monotonic()
+    async with Stream(os.environ["ODDSPUSH_TOKEN"], events=event_ids, channels=["pre"],
+                      fair=True, closing=True) as stream:
+        async for msg in stream:
+            kind = msg["type"]
+            if kind == "closing":
+                data = msg["data"]
+                if data["event_id"] in following:
+                    ml = next((m for m in data["markets"] if m["key"] == "s;0;m"), None)
+                    print(f"{data['event_id']} kicked off ({data['reason']}); closing fair: "
+                          f"{moneyline(ml['prices']) if ml else 'no moneyline'}")
+                    following.discard(data["event_id"])
+                    await stream.unsubscribe(events=[data["event_id"]])
+            elif kind == "snapshot" and msg.get("final"):
+                # The current prices; pre-match prices can then stay still for hours.
+                for event_id in sorted(following):
+                    fair = stream.book.fair(event_id, "s;0;m")
+                    if fair:
+                        print(f"{event_id}: {moneyline(fair['prices'])}")
+            elif kind == "fair":
+                event_id = msg["data"]["event_id"]
+                fair = stream.book.fair(event_id, "s;0;m")
+                if event_id in following and fair:
+                    print(f"{event_id}: {moneyline(fair['prices'])}")
+            elif kind == "odds" and msg["data"].get("op") == "del":
+                event_id = msg["data"]["rec"].get("id")
+                if event_id in following:
+                    print(f"{event_id} removed (cancelled or withdrawn)")
+                    following.discard(event_id)
+            for event_id in following:
+                if stream.book.event(event_id) is not None:
+                    seen.add(event_id)
+            if time.monotonic() - started > GIVE_UP_S:
+                for event_id in following - seen:
+                    print(f"{event_id}: never seen, giving up")
+                following &= seen
+            if not following:
+                return
+
+
+if __name__ == "__main__":
+    asyncio.run(main([int(a) for a in sys.argv[1:]]))

oddspush-0.1.0/pyproject.toml

@@ -0,0 +1,57 @@
+[build-system]
+requires = ["hatchling>=1.27"]
+build-backend = "hatchling.build"
+
+[project]
+name = "oddspush"
+version = "0.1.0"
+description = "Python client for the OddsPush API: real-time Pinnacle odds over WebSocket and REST, with no-vig, fair and closing-line (CLV) prices."
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+requires-python = ">=3.10"
+authors = [{ name = "OddsPush", email = "support@oddspush.com" }]
+keywords = [
+    "pinnacle", "pinnacle-api", "odds", "odds-api", "sports-betting", "betting",
+    "websocket", "no-vig", "fair-odds", "clv", "closing-line", "polymarket", "kalshi",
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Framework :: AsyncIO",
+    "Intended Audience :: Developers",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Internet :: WWW/HTTP",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Typing :: Typed",
+]
+dependencies = [
+    "httpx>=0.24",
+    "websockets>=12",
+]
+
+[project.optional-dependencies]
+test = ["pytest>=7", "pytest-asyncio>=0.21"]
+
+[project.urls]
+Homepage = "https://oddspush.com"
+Documentation = "https://oddspush.com/docs"
+Pricing = "https://oddspush.com/#pricing"
+Source = "https://github.com/oddspush/oddspush-python"
+Issues = "https://github.com/oddspush/oddspush-python/issues"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/oddspush"]
+
+[tool.hatch.build.targets.sdist]
+include = ["src/oddspush", "tests", "examples", "README.md", "LICENSE", "CHANGELOG.md"]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+asyncio_default_fixture_loop_scope = "function"
+testpaths = ["tests"]

oddspush-0.1.0/src/oddspush/__init__.py

@@ -0,0 +1,29 @@
+"""Python client for the OddsPush API: real-time Pinnacle odds over WebSocket and REST,
+with no-vig, fair and closing-line prices.
+
+- :class:`Stream`: the WebSocket stream, with reconnection and a local price book.
+- :class:`Client` / :class:`AsyncClient`: the REST API.
+- :class:`Book`: the price book, if you feed it yourself.
+- :mod:`oddspush.odds`: American/decimal odds, margin, no-vig and CLV.
+
+Docs: https://oddspush.com/docs
+"""
+
+from ._constants import CHANNELS, PRICE_CHANNELS, REST_URL, SPORTS, STREAM_URL
+from ._version import __version__
+from .book import Book, channel_of
+from .errors import (BadRequest, FatalError, IpNotAllowed, NotFound, NotInPlan,
+                     OddsPushError, RateLimited, StreamClosed, SubscriptionExpired,
+                     TokenReplaced, Unauthorized, Unavailable)
+from .odds import american_to_decimal, clv, decimal_to_american, implied_probability
+from .rest import AsyncClient, Client
+from .stream import Stream
+
+__all__ = [
+    "__version__", "Stream", "Client", "AsyncClient", "Book", "channel_of",
+    "SPORTS", "CHANNELS", "PRICE_CHANNELS", "STREAM_URL", "REST_URL",
+    "american_to_decimal", "decimal_to_american", "implied_probability", "clv",
+    "OddsPushError", "FatalError", "Unauthorized", "SubscriptionExpired", "NotInPlan",
+    "IpNotAllowed", "TokenReplaced", "RateLimited", "NotFound", "BadRequest",
+    "Unavailable", "StreamClosed",
+]