{
  "data": [
    {
      "id": "28265-17233-24-44:pinnacle:1st_half_moneyline:philadelphia_eagles",
      "fixture_id": "A69FA4D64518",
      "game_id": "28265-17233-24-44",
      "sport": "football",
      "league": "NFL",
      "sportsbook": "Pinnacle",
      "market": "1st Half Moneyline",
      "name": "Philadelphia Eagles",
      "selection": "Philadelphia Eagles",
      "selection_line": "",
      "is_main": true,
      "is_live": false,
      "price": -230,
      "points": null,
      "timestamp": 1730079534.7125728,
      "player_id": "",
      "team_id": "EDCC2866B795",
      "grouping_key": "default",
      "limits": { "max_stake": 1000 },
      "deep_link": {
        "desktop": "https://www.pinnacle.com/...",
        "ios": "https://www.pinnacle.com/...",
        "android": "https://www.pinnacle.com/..."
      }
    }
  ],
  "entry_id": "1730079534820-2",
  "type": "odds"
}

{
  "data": {
    "fixture_id": "FB0D30DCDD6C",
    "game_id": "88067-26534-2024-35",
    "sport": "tennis",
    "league": "ATP",
    "old_start_date": "2024-08-28T20:20:00+00:00",
    "new_start_date": "2024-08-28T20:30:00+00:00",
    "old_status": null,
    "new_status": null,
    "fixture": {
      "id": "FB0D30DCDD6C",
      "home_team_display": "Miomir Kecmanovic",
      "away_team_display": "Lorenzo Musetti",
      "start_date": "2024-08-28T20:30:00+00:00"
    },
    "timestamp": 1724871720.2406485
  },
  "entry_id": "1724871720243-0"
}

{
  "data": {
    "fixture_id": "E145B23767E0",
    "sport": "tennis",
    "league": "WTA",
    "old_status": "unplayed",
    "new_status": "cancelled",
    "old_start_date": null,
    "new_start_date": null,
    "timestamp": 1724761586.2172334
  },
  "entry_id": "1724761586216-0"
}

{
  "data": {
    "fixture_id": "B176303C982E",
    "is_live": true,
    "score": { ... },
    "player_results": [ ... ]
  },
  "entry_id": "1722523617827-0"
}

import requests
from requests.exceptions import ChunkedEncodingError
import json
import sseclient  # pip install sseclient-py
import time

API_KEY = "YOUR_API_KEY"
BASE_URL = "https://api.opticodds.com/api/v3"


def stream_odds(sport, sportsbooks, leagues=None, markets=None,
                odds_format="AMERICAN", on_odds=None, on_locked=None,
                on_fixture_status=None):
    """
    Connect to the OpticOdds SSE odds stream with automatic reconnection.

    Args:
        sport: Sport to stream (e.g., "basketball", "football", "politics")
        sportsbooks: List of sportsbook names
        leagues: Optional list of league names
        markets: Optional list of market names
        odds_format: Odds format (AMERICAN, DECIMAL, PROBABILITY, etc.)
        on_odds: Callback for odds events
        on_locked: Callback for locked-odds events
        on_fixture_status: Callback for fixture-status events
    """
    last_entry_id = None
    reconnect_delay = 1  # Start with 1 second

    while True:
        try:
            params = {
                "key": API_KEY,
                "sportsbook": sportsbooks,
                "odds_format": odds_format,
                "include_fixture_updates": "true",
            }

            if leagues:
                params["league"] = leagues
            if markets:
                params["market"] = markets
            if last_entry_id:
                params["last_entry_id"] = last_entry_id

            response = requests.get(
                f"{BASE_URL}/stream/odds/{sport}",
                params=params,
                stream=True,
            )

            if response.status_code != 200:
                print(f"HTTP {response.status_code}: {response.text}")
                time.sleep(reconnect_delay)
                reconnect_delay = min(reconnect_delay * 2, 60)
                continue

            # Reset reconnect delay on successful connection
            reconnect_delay = 1

            client = sseclient.SSEClient(response)

            for event in client.events():
                if event.event == "connected":
                    print("Connected to stream")

                elif event.event == "ping":
                    pass  # Keepalive, no action needed

                elif event.event == "odds":
                    data = json.loads(event.data)
                    last_entry_id = data.get("entry_id")
                    if on_odds:
                        on_odds(data)

                elif event.event == "locked-odds":
                    data = json.loads(event.data)
                    last_entry_id = data.get("entry_id")
                    if on_locked:
                        on_locked(data)

                elif event.event == "fixture-status":
                    data = json.loads(event.data)
                    last_entry_id = data.get("entry_id")
                    if on_fixture_status:
                        on_fixture_status(data)

        except ChunkedEncodingError:
            print("Disconnected, reconnecting...")
            time.sleep(reconnect_delay)
            reconnect_delay = min(reconnect_delay * 2, 60)

        except KeyboardInterrupt:
            print("Stream stopped by user")
            break

        except Exception as e:
            print(f"Error: {e}")
            time.sleep(reconnect_delay)
            reconnect_delay = min(reconnect_delay * 2, 60)


# --- Callbacks ---

def handle_odds(data):
    for odd in data["data"]:
        print(f"[ODDS] {odd['sportsbook']:15s} | {odd['league']:10s} | "
              f"{odd['market']:20s} | {odd['name']:30s} | {odd['price']}")


def handle_locked(data):
    for odd in data["data"]:
        print(f"[LOCK] {odd['sportsbook']:15s} | {odd['league']:10s} | "
              f"{odd['market']:20s} | {odd['name']:30s} | SUSPENDED")


def handle_fixture_status(data):
    d = data["data"]
    if d.get("new_status"):
        print(f"[STATUS] {d['fixture_id']} | {d.get('old_status')} -> {d['new_status']}")
    if d.get("new_start_date"):
        print(f"[TIME]   {d['fixture_id']} | {d.get('old_start_date')} -> {d['new_start_date']}")


# --- Start Streaming ---

stream_odds(
    sport="basketball",
    sportsbooks=["DraftKings", "FanDuel", "Pinnacle"],
    leagues=["NBA"],
    markets=["Moneyline", "Spread", "Total"],
    odds_format="AMERICAN",
    on_odds=handle_odds,
    on_locked=handle_locked,
    on_fixture_status=handle_fixture_status,
)

const EventSource = require("eventsource"); // npm install eventsource

const API_KEY = "YOUR_API_KEY";
const BASE_URL = "https://api.opticodds.com/api/v3";

let lastEntryId = null;
let reconnectDelay = 1000;

function streamOdds(sport, sportsbooks, options = {}) {
  const { leagues, markets, oddsFormat = "AMERICAN" } = options;

  const params = new URLSearchParams();
  params.append("key", API_KEY);
  params.append("odds_format", oddsFormat);
  params.append("include_fixture_updates", "true");

  sportsbooks.forEach((sb) => params.append("sportsbook", sb));
  if (leagues) leagues.forEach((lg) => params.append("league", lg));
  if (markets) markets.forEach((mk) => params.append("market", mk));
  if (lastEntryId) params.append("last_entry_id", lastEntryId);

  const url = `${BASE_URL}/stream/odds/${sport}?${params.toString()}`;
  console.log(`Connecting to: ${url}`);

  const eventSource = new EventSource(url);

  // Connection opened
  eventSource.addEventListener("connected", (event) => {
    console.log("Connected to stream");
    reconnectDelay = 1000; // Reset on successful connection
  });

  // Keepalive
  eventSource.addEventListener("ping", (event) => {
    // No action needed
  });

  // Odds updates
  eventSource.addEventListener("odds", (event) => {
    const data = JSON.parse(event.data);
    lastEntryId = data.entry_id;

    for (const odd of data.data) {
      console.log(
        `[ODDS] ${odd.sportsbook.padEnd(15)} | ${odd.league.padEnd(10)} | ` +
        `${odd.market.padEnd(20)} | ${odd.name.padEnd(30)} | ${odd.price}`
      );
    }
  });

  // Locked/suspended odds
  eventSource.addEventListener("locked-odds", (event) => {
    const data = JSON.parse(event.data);
    lastEntryId = data.entry_id;

    for (const odd of data.data) {
      console.log(
        `[LOCK] ${odd.sportsbook.padEnd(15)} | ${odd.league.padEnd(10)} | ` +
        `${odd.market.padEnd(20)} | ${odd.name.padEnd(30)} | SUSPENDED`
      );
    }
  });

  // Fixture status changes
  eventSource.addEventListener("fixture-status", (event) => {
    const data = JSON.parse(event.data);
    lastEntryId = data.entry_id;
    const d = data.data;

    if (d.new_status) {
      console.log(`[STATUS] ${d.fixture_id} | ${d.old_status} -> ${d.new_status}`);
    }
    if (d.new_start_date) {
      console.log(`[TIME]   ${d.fixture_id} | ${d.old_start_date} -> ${d.new_start_date}`);
    }
  });

  // Error handling with reconnection
  eventSource.onerror = (error) => {
    console.error("Stream error, reconnecting...");
    eventSource.close();
    setTimeout(() => {
      streamOdds(sport, sportsbooks, options);
      reconnectDelay = Math.min(reconnectDelay * 2, 60000);
    }, reconnectDelay);
  };

  return eventSource;
}

// Start streaming
streamOdds("basketball", ["DraftKings", "FanDuel", "Pinnacle"], {
  leagues: ["NBA"],
  markets: ["Moneyline", "Spread", "Total"],
  oddsFormat: "AMERICAN",
});

last_entry_id = None  # Track outside the connection loop

while True:
    try:
        params = {"key": API_KEY, "sportsbook": ["DraftKings"]}
        if last_entry_id:
            params["last_entry_id"] = last_entry_id

        # Connect and process events...
        for event in client.events():
            data = json.loads(event.data)
            last_entry_id = data.get("entry_id")  # Always update
            process(data)

    except ChunkedEncodingError:
        print("Disconnected, reconnecting with last_entry_id:", last_entry_id)
        time.sleep(1)

reconnect_delay = 1  # seconds

while True:
    try:
        connect_and_stream()
        reconnect_delay = 1  # Reset on success
    except Exception:
        time.sleep(reconnect_delay)
        reconnect_delay = min(reconnect_delay * 2, 60)  # Cap at 60s

from collections import defaultdict

# Cache structure: {odd_id: odd_data}
odds_cache = {}
locked_set = set()


def build_cache_key(odd):
    """Build a unique key for an odd."""
    return odd["id"]


def handle_odds_event(data):
    """Process an odds event — add/update odds in cache."""
    for odd in data["data"]:
        key = build_cache_key(odd)
        odds_cache[key] = odd
        locked_set.discard(key)  # Unlock if previously locked


def handle_locked_event(data):
    """Process a locked-odds event — mark odds as suspended."""
    for odd in data["data"]:
        key = build_cache_key(odd)
        locked_set.add(key)


def get_active_odds(fixture_id=None, sportsbook=None, market=None):
    """Query the local cache for active (non-locked) odds."""
    results = []
    for key, odd in odds_cache.items():
        if key in locked_set:
            continue
        if fixture_id and odd["fixture_id"] != fixture_id:
            continue
        if sportsbook and odd["sportsbook"] != sportsbook:
            continue
        if market and odd["market"] != market:
            continue
        results.append(odd)
    return results


def get_best_price(fixture_id, market, selection):
    """Find the best available price across all sportsbooks."""
    active = get_active_odds(fixture_id=fixture_id, market=market)
    matching = [o for o in active if o["normalized_selection"] == selection]
    if not matching:
        return None
    return max(matching, key=lambda o: o["price"])

def hydrate_cache(sport, sportsbooks, leagues):
    """Pull a full snapshot to initialize the local cache."""
    response = requests.get(
        f"{BASE_URL}/fixtures/odds",
        headers={"X-Api-Key": API_KEY},
        params={
            "sport": sport,
            "sportsbook": sportsbooks,
            "league": leagues,
            "is_live": "false",
        }
    )

    for fixture in response.json()["data"]:
        for odd in fixture.get("odds", []):
            key = build_cache_key(odd)
            odds_cache[key] = odd

    print(f"Cache hydrated with {len(odds_cache)} odds")


# 1. Hydrate cache
hydrate_cache("basketball", ["DraftKings", "FanDuel"], ["NBA"])

# 2. Start streaming (updates flow into the same cache)
stream_odds("basketball", ["DraftKings", "FanDuel"], leagues=["NBA"],
            on_odds=handle_odds_event, on_locked=handle_locked_event)

import threading

def start_stream(sport, sportsbooks, leagues):
    """Start a stream in a background thread."""
    thread = threading.Thread(
        target=stream_odds,
        args=(sport, sportsbooks),
        kwargs={"leagues": leagues, "on_odds": handle_odds_event,
                "on_locked": handle_locked_event},
        daemon=True,
    )
    thread.start()
    return thread

# Launch multiple streams
threads = [
    start_stream("basketball", ["DraftKings", "FanDuel", "Pinnacle"], ["NBA", "NCAAB"]),
    start_stream("football", ["DraftKings", "FanDuel", "Pinnacle"], ["NFL"]),
    start_stream("politics", ["Kalshi", "Polymarket"], None),
]

# Keep main thread alive
for t in threads:
    t.join()