kellyiq 0.0.1__tar.gz

kellyiq-0.0.1/LICENSE

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

kellyiq-0.0.1/PKG-INFO

@@ -0,0 +1,82 @@
+Metadata-Version: 2.4
+Name: kellyiq
+Version: 0.0.1
+Summary: Size a whole sports betting slate as one portfolio: a client for the KellyIQ API.
+Author-email: KellyIQ <opensource@kellyiq.com>
+License-Expression: MIT
+Project-URL: Homepage, https://www.kellyiq.com/developers
+Project-URL: Documentation, https://www.kellyiq.com/developers/quickstart
+Project-URL: Source, https://github.com/kellyiq/kellyiq-python
+Keywords: kelly criterion,bet sizing,sports betting,portfolio optimization,bankroll
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# kellyiq
+
+Size a whole sports betting slate as one portfolio, from Python.
+
+A small client for the [KellyIQ API](https://www.kellyiq.com/developers): send your bankroll and the
+bets you have chosen, with your view of each, and get back a stake for every bet, sized across the
+slate together under per-bet and total-exposure limits. No dependencies.
+
+```bash
+pip install kellyiq
+```
+
+```python
+from kellyiq import KellyIQ
+
+client = KellyIQ()   # reads KELLYIQ_API_KEY
+
+result = client.optimize({
+    "bankroll": 1000,
+    "picks": [
+        {"sport": "baseball_mlb", "team": "Dodgers", "opponent": "Padres",
+         "odds": -145, "opponentOdds": 125, "confidence": "STRONG_EDGE"},
+        {"sport": "baseball_mlb", "team": "Cubs", "opponent": "Cardinals",
+         "odds": 120, "opponentOdds": -140, "confidence": "MODERATE_EDGE"},
+    ],
+})
+
+for stake in result["allocation"]["stakes"]:
+    print(f'{stake["team"]}: ${stake["stake"]}')
+```
+
+Create an API key in the KellyIQ app under **Settings → API**. Every plan includes API access, Free
+included, each with its own daily allowance.
+
+## What's in it
+
+| Method | Endpoint | Counts against the allowance |
+|---|---|---|
+| `optimize(slate)` | `POST /v1/optimize` | Yes |
+| `sports()` | `GET /v1/sports` | No |
+| `me()` | `GET /v1/me` | No |
+| `devig(markets)` | `POST /v1/devig` | No |
+| `implied_probability(odds)` | `POST /v1/implied-probability` | No |
+| `kelly(bets, bankroll=None, fraction=None)` | `POST /v1/kelly` | No |
+
+Responses are the API's JSON as Python dicts; the [API reference](https://www.kellyiq.com/developers/reference/optimize)
+describes every field. Errors raise `KellyIQError` with `status`, `code`, `violations`, `request_id`
+and `retry_after`.
+
+This is an early release. A fuller SDK (typed results, automatic retries) is on the way; the
+methods above will keep working.
+
+## More
+
+- [Quickstart](https://www.kellyiq.com/developers/quickstart) and [docs](https://www.kellyiq.com/developers)
+- [Examples and AI-assistant (MCP) configs](https://github.com/kellyiq/kellyiq-examples)
+- Support: support@kellyiq.com
+
+KellyIQ sizes the bets you choose; it does not choose bets or predict outcomes. Results are
+calculations, not betting advice. 21+, where legal.
+
+MIT licensed.

kellyiq-0.0.1/README.md

@@ -0,0 +1,62 @@
+# kellyiq
+
+Size a whole sports betting slate as one portfolio, from Python.
+
+A small client for the [KellyIQ API](https://www.kellyiq.com/developers): send your bankroll and the
+bets you have chosen, with your view of each, and get back a stake for every bet, sized across the
+slate together under per-bet and total-exposure limits. No dependencies.
+
+```bash
+pip install kellyiq
+```
+
+```python
+from kellyiq import KellyIQ
+
+client = KellyIQ()   # reads KELLYIQ_API_KEY
+
+result = client.optimize({
+    "bankroll": 1000,
+    "picks": [
+        {"sport": "baseball_mlb", "team": "Dodgers", "opponent": "Padres",
+         "odds": -145, "opponentOdds": 125, "confidence": "STRONG_EDGE"},
+        {"sport": "baseball_mlb", "team": "Cubs", "opponent": "Cardinals",
+         "odds": 120, "opponentOdds": -140, "confidence": "MODERATE_EDGE"},
+    ],
+})
+
+for stake in result["allocation"]["stakes"]:
+    print(f'{stake["team"]}: ${stake["stake"]}')
+```
+
+Create an API key in the KellyIQ app under **Settings → API**. Every plan includes API access, Free
+included, each with its own daily allowance.
+
+## What's in it
+
+| Method | Endpoint | Counts against the allowance |
+|---|---|---|
+| `optimize(slate)` | `POST /v1/optimize` | Yes |
+| `sports()` | `GET /v1/sports` | No |
+| `me()` | `GET /v1/me` | No |
+| `devig(markets)` | `POST /v1/devig` | No |
+| `implied_probability(odds)` | `POST /v1/implied-probability` | No |
+| `kelly(bets, bankroll=None, fraction=None)` | `POST /v1/kelly` | No |
+
+Responses are the API's JSON as Python dicts; the [API reference](https://www.kellyiq.com/developers/reference/optimize)
+describes every field. Errors raise `KellyIQError` with `status`, `code`, `violations`, `request_id`
+and `retry_after`.
+
+This is an early release. A fuller SDK (typed results, automatic retries) is on the way; the
+methods above will keep working.
+
+## More
+
+- [Quickstart](https://www.kellyiq.com/developers/quickstart) and [docs](https://www.kellyiq.com/developers)
+- [Examples and AI-assistant (MCP) configs](https://github.com/kellyiq/kellyiq-examples)
+- Support: support@kellyiq.com
+
+KellyIQ sizes the bets you choose; it does not choose bets or predict outcomes. Results are
+calculations, not betting advice. 21+, where legal.
+
+MIT licensed.

kellyiq-0.0.1/pyproject.toml

@@ -0,0 +1,29 @@
+[build-system]
+requires = ["setuptools>=69"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "kellyiq"
+version = "0.0.1"
+description = "Size a whole sports betting slate as one portfolio: a client for the KellyIQ API."
+readme = "README.md"
+requires-python = ">=3.9"
+license = "MIT"
+authors = [{ name = "KellyIQ", email = "opensource@kellyiq.com" }]
+keywords = ["kelly criterion", "bet sizing", "sports betting", "portfolio optimization", "bankroll"]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Intended Audience :: Developers",
+  "Programming Language :: Python :: 3",
+  "Operating System :: OS Independent",
+  "Topic :: Scientific/Engineering :: Mathematics",
+]
+dependencies = []
+
+[project.urls]
+Homepage = "https://www.kellyiq.com/developers"
+Documentation = "https://www.kellyiq.com/developers/quickstart"
+Source = "https://github.com/kellyiq/kellyiq-python"
+
+[tool.setuptools.packages.find]
+where = ["src"]

kellyiq-0.0.1/setup.cfg

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

kellyiq-0.0.1/src/kellyiq/__init__.py

@@ -0,0 +1,25 @@
+"""KellyIQ: size a whole sports betting slate as one portfolio.
+
+A small client for the KellyIQ API (https://www.kellyiq.com/developers). No dependencies.
+
+    from kellyiq import KellyIQ
+
+    client = KellyIQ()          # reads KELLYIQ_API_KEY
+    result = client.optimize({
+        "bankroll": 1000,
+        "picks": [
+            {"sport": "baseball_mlb", "team": "Dodgers", "opponent": "Padres",
+             "odds": -145, "opponentOdds": 125, "confidence": "STRONG_EDGE"},
+        ],
+    })
+    for stake in result["allocation"]["stakes"]:
+        print(stake["team"], stake["stake"])
+
+KellyIQ sizes the bets you choose; it does not choose bets or predict outcomes. Results are
+calculations, not betting advice.
+"""
+
+from ._client import KellyIQ, KellyIQError
+
+__all__ = ["KellyIQ", "KellyIQError", "__version__"]
+__version__ = "0.0.1"

kellyiq-0.0.1/src/kellyiq/_client.py

@@ -0,0 +1,117 @@
+import json
+import os
+import urllib.error
+import urllib.request
+from typing import Any, Dict, List, Optional
+
+DEFAULT_BASE_URL = "https://api.kellyiq.com"
+_VERSION = "0.0.1"
+
+
+class KellyIQError(Exception):
+    """An error response from the KellyIQ API.
+
+    Attributes mirror the API's error body: ``status`` (HTTP status), ``code`` (for example
+    ``VALIDATION_ERROR`` or ``DAILY_LIMIT_EXCEEDED``), ``violations`` (which field was wrong, for
+    validation errors), ``request_id`` (quote it to support@kellyiq.com) and ``retry_after``
+    (seconds, when the API asks you to wait).
+    """
+
+    def __init__(self, status: int, code: str, message: str, violations: Optional[List[str]] = None,
+                 request_id: Optional[str] = None, retry_after: Optional[int] = None,
+                 body: Optional[Dict[str, Any]] = None) -> None:
+        detail = f"{code}: {message}" + (f" ({'; '.join(violations)})" if violations else "")
+        super().__init__(f"HTTP {status} {detail}")
+        self.status = status
+        self.code = code
+        self.message = message
+        self.violations = violations or []
+        self.request_id = request_id
+        self.retry_after = retry_after
+        self.body = body or {}
+
+
+class KellyIQ:
+    """Client for the KellyIQ API.
+
+    :param api_key: your API key (``kiqa_...``); defaults to the ``KELLYIQ_API_KEY`` environment variable.
+        Create one in the KellyIQ app under Settings, API. Every plan includes API access.
+    :param base_url: defaults to ``KELLYIQ_API_BASE`` or https://api.kellyiq.com.
+    :param timeout: seconds to wait for a response (an optimize can take several seconds).
+    """
+
+    def __init__(self, api_key: Optional[str] = None, base_url: Optional[str] = None,
+                 timeout: float = 60.0) -> None:
+        key = api_key or os.environ.get("KELLYIQ_API_KEY")
+        if not key:
+            raise ValueError("Pass api_key or set the KELLYIQ_API_KEY environment variable.")
+        self._key = key
+        self._base = (base_url or os.environ.get("KELLYIQ_API_BASE") or DEFAULT_BASE_URL).rstrip("/")
+        self._timeout = timeout
+
+    def __repr__(self) -> str:   # never show the key
+        return f"KellyIQ(base_url={self._base!r})"
+
+    # ---- endpoints -------------------------------------------------------------------------
+
+    def optimize(self, slate: Dict[str, Any]) -> Dict[str, Any]:
+        """Size a slate (POST /v1/optimize). Returns the API response; stakes are in
+        ``result["allocation"]["stakes"]``. Counts against your daily optimize allowance."""
+        return self._request("POST", "/v1/optimize", slate)
+
+    def sports(self) -> List[Dict[str, Any]]:
+        """The sports you can size right now, with the key to send as each pick's ``sport``. Free."""
+        return self._request("GET", "/v1/sports")["sports"]
+
+    def me(self) -> Dict[str, Any]:
+        """Your plan, today's allowance and the settings optimize applies by default. Free."""
+        return self._request("GET", "/v1/me")
+
+    def devig(self, markets: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+        """Fair probabilities with the bookmaker's margin removed. Each market: ``{"odds": [-145, 125]}``."""
+        return self._request("POST", "/v1/devig", {"markets": markets})["results"]
+
+    def implied_probability(self, odds: List[int]) -> List[Dict[str, Any]]:
+        """The probability each American price implies, margin included."""
+        return self._request("POST", "/v1/implied-probability", {"odds": odds})["results"]
+
+    def kelly(self, bets: List[Dict[str, Any]], bankroll: Optional[float] = None,
+              fraction: Optional[float] = None) -> List[Dict[str, Any]]:
+        """Kelly stake for each bet on its own. For two or more bets placed together, use optimize()."""
+        body: Dict[str, Any] = {"bets": bets}
+        if bankroll is not None:
+            body["bankroll"] = bankroll
+        if fraction is not None:
+            body["fraction"] = fraction
+        return self._request("POST", "/v1/kelly", body)["results"]
+
+    # ---- transport -------------------------------------------------------------------------
+
+    def _request(self, method: str, path: str, body: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        data = json.dumps(body).encode("utf-8") if body is not None else None
+        req = urllib.request.Request(self._base + path, data=data, method=method)
+        req.add_header("Authorization", f"Bearer {self._key}")
+        req.add_header("Accept", "application/json")
+        # Identifies SDK traffic, so KellyIQ can tell how many calls come through this package.
+        req.add_header("User-Agent", f"kellyiq-python/{_VERSION}")
+        if data is not None:
+            req.add_header("Content-Type", "application/json")
+        try:
+            with urllib.request.urlopen(req, timeout=self._timeout) as resp:
+                return json.loads(resp.read().decode("utf-8"))
+        except urllib.error.HTTPError as e:
+            raw = e.read().decode("utf-8", "replace")
+            try:
+                err = json.loads(raw)
+            except ValueError:
+                err = {}
+            retry = e.headers.get("Retry-After")
+            raise KellyIQError(
+                status=e.code,
+                code=err.get("error", f"HTTP_{e.code}"),
+                message=err.get("message", raw[:200] or e.reason),
+                violations=err.get("violations"),
+                request_id=err.get("requestId") or e.headers.get("X-Request-Id"),
+                retry_after=int(retry) if retry and retry.isdigit() else None,
+                body=err,
+            ) from None

kellyiq-0.0.1/src/kellyiq.egg-info/PKG-INFO

@@ -0,0 +1,82 @@
+Metadata-Version: 2.4
+Name: kellyiq
+Version: 0.0.1
+Summary: Size a whole sports betting slate as one portfolio: a client for the KellyIQ API.
+Author-email: KellyIQ <opensource@kellyiq.com>
+License-Expression: MIT
+Project-URL: Homepage, https://www.kellyiq.com/developers
+Project-URL: Documentation, https://www.kellyiq.com/developers/quickstart
+Project-URL: Source, https://github.com/kellyiq/kellyiq-python
+Keywords: kelly criterion,bet sizing,sports betting,portfolio optimization,bankroll
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# kellyiq
+
+Size a whole sports betting slate as one portfolio, from Python.
+
+A small client for the [KellyIQ API](https://www.kellyiq.com/developers): send your bankroll and the
+bets you have chosen, with your view of each, and get back a stake for every bet, sized across the
+slate together under per-bet and total-exposure limits. No dependencies.
+
+```bash
+pip install kellyiq
+```
+
+```python
+from kellyiq import KellyIQ
+
+client = KellyIQ()   # reads KELLYIQ_API_KEY
+
+result = client.optimize({
+    "bankroll": 1000,
+    "picks": [
+        {"sport": "baseball_mlb", "team": "Dodgers", "opponent": "Padres",
+         "odds": -145, "opponentOdds": 125, "confidence": "STRONG_EDGE"},
+        {"sport": "baseball_mlb", "team": "Cubs", "opponent": "Cardinals",
+         "odds": 120, "opponentOdds": -140, "confidence": "MODERATE_EDGE"},
+    ],
+})
+
+for stake in result["allocation"]["stakes"]:
+    print(f'{stake["team"]}: ${stake["stake"]}')
+```
+
+Create an API key in the KellyIQ app under **Settings → API**. Every plan includes API access, Free
+included, each with its own daily allowance.
+
+## What's in it
+
+| Method | Endpoint | Counts against the allowance |
+|---|---|---|
+| `optimize(slate)` | `POST /v1/optimize` | Yes |
+| `sports()` | `GET /v1/sports` | No |
+| `me()` | `GET /v1/me` | No |
+| `devig(markets)` | `POST /v1/devig` | No |
+| `implied_probability(odds)` | `POST /v1/implied-probability` | No |
+| `kelly(bets, bankroll=None, fraction=None)` | `POST /v1/kelly` | No |
+
+Responses are the API's JSON as Python dicts; the [API reference](https://www.kellyiq.com/developers/reference/optimize)
+describes every field. Errors raise `KellyIQError` with `status`, `code`, `violations`, `request_id`
+and `retry_after`.
+
+This is an early release. A fuller SDK (typed results, automatic retries) is on the way; the
+methods above will keep working.
+
+## More
+
+- [Quickstart](https://www.kellyiq.com/developers/quickstart) and [docs](https://www.kellyiq.com/developers)
+- [Examples and AI-assistant (MCP) configs](https://github.com/kellyiq/kellyiq-examples)
+- Support: support@kellyiq.com
+
+KellyIQ sizes the bets you choose; it does not choose bets or predict outcomes. Results are
+calculations, not betting advice. 21+, where legal.
+
+MIT licensed.

kellyiq-0.0.1/src/kellyiq.egg-info/SOURCES.txt

@@ -0,0 +1,9 @@
+LICENSE
+README.md
+pyproject.toml
+src/kellyiq/__init__.py
+src/kellyiq/_client.py
+src/kellyiq.egg-info/PKG-INFO
+src/kellyiq.egg-info/SOURCES.txt
+src/kellyiq.egg-info/dependency_links.txt
+src/kellyiq.egg-info/top_level.txt

kellyiq-0.0.1/src/kellyiq.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

kellyiq-0.0.1/src/kellyiq.egg-info/top_level.txt

@@ -0,0 +1 @@
+kellyiq