APIs de Odds Esportivas: Guia Completo pra

import requests

def get_the_odds_api(sport="soccer_brazil_serie_a"):
    """Exemplo básico de uso da The Odds API."""
    url = f"https://api.the-odds-api.com/v4/sports/{sport}/odds"
    params = {
        "apiKey": "SUA_API_KEY",
        "regions": "eu",
        "markets": "h2h",
        "oddsFormat": "decimal"
    }
    response = requests.get(url, params=params)
    data = response.json()
    
    # Mostra odds do primeiro jogo
    if data:
        game = data[0]
        print(f"{game['home_team']} vs {game['away_team']}")
        for book in game["bookmakers"]:
            outcomes = {o["name"]: o["price"] for o in book["markets"][0]["outcomes"]}
            print(f"  {book['key']}: {outcomes}")
    
    return data

from dataclasses import dataclass
from datetime import datetime
from abc import ABC, abstractmethod
import requests

@dataclass
class NormalizedOdds:
    game_id: str
    home_team: str
    away_team: str
    bookmaker: str
    home_odds: float
    draw_odds: float | None
    away_odds: float
    timestamp: datetime
    source: str

class OddsProvider(ABC):
    @abstractmethod
    def fetch_odds(self, sport: str) -> list[NormalizedOdds]:
        pass

class TheOddsAPI(OddsProvider):
    def __init__(self, api_key: str):
        self.api_key = api_key
        self.base_url = "https://api.the-odds-api.com/v4"
    
    def fetch_odds(self, sport: str = "soccer_brazil_serie_a") -> list[NormalizedOdds]:
        url = f"{self.base_url}/sports/{sport}/odds"
        params = {
            "apiKey": self.api_key,
            "regions": "eu",
            "markets": "h2h",
            "oddsFormat": "decimal"
        }
        resp = requests.get(url, params=params, timeout=10)
        resp.raise_for_status()
        
        results = []
        for game in resp.json():
            for book in game.get("bookmakers", []):
                for market in book.get("markets", []):
                    if market["key"] == "h2h":
                        outcomes = {o["name"]: o["price"] for o in market["outcomes"]}
                        results.append(NormalizedOdds(
                            game_id=game["id"],
                            home_team=game["home_team"],
                            away_team=game["away_team"],
                            bookmaker=book["key"],
                            home_odds=outcomes.get(game["home_team"], 0),
                            draw_odds=outcomes.get("Draw"),
                            away_odds=outcomes.get(game["away_team"], 0),
                            timestamp=datetime.fromisoformat(book["last_update"]),
                            source="the_odds_api"
                        ))
        return results

class OddsAggregator:
    def __init__(self, providers: list[OddsProvider]):
        self.providers = providers
    
    def fetch_all(self, sport: str) -> dict[str, list[NormalizedOdds]]:
        """Puxa odds de todos os providers e agrupa por jogo."""
        all_odds = []
        for provider in self.providers:
            try:
                all_odds.extend(provider.fetch_odds(sport))
            except Exception as e:
                print(f"Falha no provider {provider.__class__.__name__}: {e}")
        
        # Agrupa por game_id
        grouped = {}
        for odd in all_odds:
            grouped.setdefault(odd.game_id, []).append(odd)
        return grouped
    
    def consensus_odds(self, sport: str) -> dict:
        """Calcula odds de consenso (média) por jogo."""
        grouped = self.fetch_all(sport)
        consensus = {}
        for game_id, odds_list in grouped.items():
            home_avg = sum(o.home_odds for o in odds_list) / len(odds_list)
            away_avg = sum(o.away_odds for o in odds_list) / len(odds_list)
            draw_vals = [o.draw_odds for o in odds_list if o.draw_odds]
            draw_avg = sum(draw_vals) / len(draw_vals) if draw_vals else None
            consensus[game_id] = {
                "home": odds_list[0].home_team,
                "away": odds_list[0].away_team,
                "home_odds": round(home_avg, 3),
                "draw_odds": round(draw_avg, 3) if draw_avg else None,
                "away_odds": round(away_avg, 3),
                "num_books": len(odds_list)
            }
        return consensus

import sqlite3
from datetime import datetime

def save_odds(odds_list: list[NormalizedOdds], db_path: str = "odds_history.db"):
    """Salva odds coletadas em SQLite."""
    conn = sqlite3.connect(db_path)
    conn.execute("""
        CREATE TABLE IF NOT EXISTS odds (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            game_id TEXT,
            home_team TEXT,
            away_team TEXT,
            bookmaker TEXT,
            home_odds REAL,
            draw_odds REAL,
            away_odds REAL,
            source TEXT,
            collected_at TEXT
        )
    """)
    
    for odd in odds_list:
        conn.execute(
            "INSERT INTO odds VALUES (NULL, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
            (odd.game_id, odd.home_team, odd.away_team, odd.bookmaker,
             odd.home_odds, odd.draw_odds, odd.away_odds, odd.source,
             datetime.now().isoformat())
        )
    
    conn.commit()
    conn.close()