sharpapi 0.1.0__py3-none-any.whl

sharpapi/__init__.py

@@ -0,0 +1,93 @@
+"""SharpAPI Python SDK — Real-time sports betting odds, +EV, and arbitrage detection.
+
+Example::
+
+    from sharpapi import SharpAPI
+
+    client = SharpAPI("sk_live_xxx")
+
+    # Arbitrage opportunities
+    arbs = client.arbitrage.get(min_profit=1.0)
+    for arb in arbs.data:
+        print(f"{arb.profit_percent}% — {arb.event_name}")
+
+    # +EV opportunities
+    evs = client.ev.get(min_ev=3.0, league="nba")
+    for opp in evs.data:
+        print(f"+{opp.ev_percent}% on {opp.selection} @ {opp.sportsbook}")
+"""
+
+from .async_client import AsyncSharpAPI
+from .client import SharpAPI
+from .exceptions import (
+    AuthenticationError,
+    RateLimitedError,
+    SharpAPIError,
+    StreamError,
+    TierRestrictedError,
+    ValidationError,
+)
+from .models import (
+    APIResponse,
+    AccountInfo,
+    ArbitrageLeg,
+    ArbitrageOpportunity,
+    EVOpportunity,
+    Event,
+    GameState,
+    League,
+    LowHoldOpportunity,
+    LowHoldSide,
+    MiddleOpportunity,
+    MiddleSide,
+    OddsLine,
+    OddsValue,
+    Pagination,
+    RateLimitInfo,
+    ResponseMeta,
+    Sport,
+    Sportsbook,
+)
+from .streaming import EventStream
+from ._utils import american_to_decimal, american_to_probability, decimal_to_american
+
+__version__ = "0.1.0"
+
+__all__ = [
+    # Clients
+    "SharpAPI",
+    "AsyncSharpAPI",
+    # Models
+    "APIResponse",
+    "AccountInfo",
+    "ArbitrageLeg",
+    "ArbitrageOpportunity",
+    "EVOpportunity",
+    "Event",
+    "GameState",
+    "League",
+    "LowHoldOpportunity",
+    "LowHoldSide",
+    "MiddleOpportunity",
+    "MiddleSide",
+    "OddsLine",
+    "OddsValue",
+    "Pagination",
+    "RateLimitInfo",
+    "ResponseMeta",
+    "Sport",
+    "Sportsbook",
+    # Streaming
+    "EventStream",
+    # Exceptions
+    "AuthenticationError",
+    "RateLimitedError",
+    "SharpAPIError",
+    "StreamError",
+    "TierRestrictedError",
+    "ValidationError",
+    # Utilities
+    "american_to_decimal",
+    "american_to_probability",
+    "decimal_to_american",
+]

sharpapi/_base.py

@@ -0,0 +1,121 @@
+"""Shared logic for sync and async clients."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import httpx
+
+from .exceptions import (
+    AuthenticationError,
+    RateLimitedError,
+    SharpAPIError,
+    TierRestrictedError,
+    ValidationError,
+)
+from .models import APIResponse, RateLimitInfo, ResponseMeta
+
+DEFAULT_BASE_URL = "https://api.sharpapi.io"
+DEFAULT_TIMEOUT = 30.0
+USER_AGENT = "sharpapi-python/0.1.0"
+
+
+def parse_response(raw: dict, model_class: type) -> APIResponse:
+    """Parse raw API JSON into a typed APIResponse."""
+    data_raw = raw.get("data", [])
+    if isinstance(data_raw, list):
+        items = [model_class.model_validate(item) for item in data_raw]
+    else:
+        items = [model_class.model_validate(data_raw)]
+
+    meta = None
+    meta_raw = raw.get("meta")
+    if meta_raw:
+        meta = ResponseMeta.model_validate(meta_raw)
+
+    return APIResponse(
+        success=raw.get("success"),
+        data=items,
+        meta=meta,
+        timestamp=raw.get("timestamp"),
+        tier=raw.get("tier"),
+    )
+
+
+def parse_rate_limit(response: httpx.Response) -> RateLimitInfo:
+    """Extract rate limit info from response headers."""
+    headers = response.headers
+    return RateLimitInfo(
+        limit=_int_or_none(headers.get("x-ratelimit-limit")),
+        remaining=_int_or_none(headers.get("x-ratelimit-remaining")),
+        reset=_float_or_none(headers.get("x-ratelimit-reset")),
+        tier=headers.get("x-tier"),
+    )
+
+
+def handle_errors(response: httpx.Response) -> None:
+    """Raise typed exceptions for error responses."""
+    if response.is_success:
+        return
+
+    try:
+        body = response.json()
+    except Exception:
+        body = {}
+
+    error_obj = body.get("error", body)
+    if isinstance(error_obj, dict):
+        error_msg = error_obj.get("message", error_obj.get("error", f"HTTP {response.status_code}"))
+        code = error_obj.get("code", body.get("code", "unknown_error"))
+    else:
+        error_msg = str(error_obj) if error_obj else f"HTTP {response.status_code}"
+        code = body.get("code", "unknown_error")
+    status = response.status_code
+
+    if status == 401:
+        raise AuthenticationError(error_msg, code=code, status=status)
+    elif status == 403:
+        raise TierRestrictedError(
+            error_msg,
+            code=code,
+            status=status,
+            required_tier=body.get("required_tier"),
+        )
+    elif status == 429:
+        raise RateLimitedError(
+            error_msg,
+            code=code,
+            status=status,
+            retry_after=body.get("retry_after"),
+        )
+    elif status == 400:
+        raise ValidationError(error_msg, code=code, status=status)
+    else:
+        raise SharpAPIError(error_msg, code=code, status=status)
+
+
+def make_headers(api_key: str) -> dict[str, str]:
+    """Build default request headers."""
+    return {
+        "X-API-Key": api_key,
+        "Content-Type": "application/json",
+        "User-Agent": USER_AGENT,
+    }
+
+
+def _int_or_none(value: str | None) -> int | None:
+    if value is None:
+        return None
+    try:
+        return int(value)
+    except (ValueError, TypeError):
+        return None
+
+
+def _float_or_none(value: str | None) -> float | None:
+    if value is None:
+        return None
+    try:
+        return float(value)
+    except (ValueError, TypeError):
+        return None

sharpapi/_utils.py

@@ -0,0 +1,39 @@
+"""Internal utilities."""
+
+from __future__ import annotations
+
+
+def american_to_decimal(american: int | float) -> float:
+    """Convert American odds to decimal odds."""
+    if american > 0:
+        return american / 100 + 1
+    return 100 / abs(american) + 1
+
+
+def decimal_to_american(decimal: float) -> int:
+    """Convert decimal odds to American odds."""
+    if decimal >= 2.0:
+        return round((decimal - 1) * 100)
+    return round(-100 / (decimal - 1))
+
+
+def american_to_probability(american: int | float) -> float:
+    """Convert American odds to implied probability (0-1)."""
+    if american > 0:
+        return 100 / (american + 100)
+    return abs(american) / (abs(american) + 100)
+
+
+def _clean_params(params: dict) -> dict:
+    """Remove None values and join lists with commas."""
+    cleaned = {}
+    for key, value in params.items():
+        if value is None:
+            continue
+        if isinstance(value, bool):
+            cleaned[key] = str(value).lower()
+        elif isinstance(value, list):
+            cleaned[key] = ",".join(str(v) for v in value)
+        else:
+            cleaned[key] = value
+    return cleaned