APIs de Odds Grátis: Como Puxar Dados de Apostas em Tempo Real

import os
import time
import json
import requests
import hashlib
from pathlib import Path
from datetime import datetime, timedelta
from typing import Optional
from dotenv import load_dotenv

load_dotenv()

class OddsAPIClient:
    """
    Cliente completo para The Odds API.
    Inclui retry, cache e formatação de dados.
    """
    
    BASE_URL = 'https://api.the-odds-api.com/v4'
    CACHE_DIR = Path('.odds_cache')
    CACHE_TTL_MINUTES = 5  # Cache de 5 minutos para odds ao vivo
    
    def __init__(self, api_key: str, max_retries: int = 3):
        self.api_key = api_key
        self.max_retries = max_retries
        self.requests_remaining = None
        self.requests_used = None
        self.CACHE_DIR.mkdir(exist_ok=True)
    
    def _get_cache_key(self, endpoint: str, params: dict) -> str:
        key = f"{endpoint}:{json.dumps(params, sort_keys=True)}"
        return hashlib.md5(key.encode()).hexdigest()
    
    def _get_from_cache(self, cache_key: str) -> Optional[dict]:
        cache_file = self.CACHE_DIR / f"{cache_key}.json"
        if not cache_file.exists():
            return None
        
        data = json.loads(cache_file.read_text())
        cached_at = datetime.fromisoformat(data['cached_at'])
        if datetime.now() - cached_at > timedelta(minutes=self.CACHE_TTL_MINUTES):
            return None
        return data['payload']
    
    def _save_to_cache(self, cache_key: str, payload: dict) -> None:
        cache_file = self.CACHE_DIR / f"{cache_key}.json"
        cache_file.write_text(json.dumps({
            'cached_at': datetime.now().isoformat(),
            'payload': payload,
        }))
    
    def _request(self, endpoint: str, params: dict = {}) -> list | dict:
        cache_key = self._get_cache_key(endpoint, params)
        cached = self._get_from_cache(cache_key)
        if cached is not None:
            return cached
        
        url = f'{self.BASE_URL}/{endpoint}'
        all_params = {'apiKey': self.api_key, **params}
        
        for attempt in range(self.max_retries):
            try:
                response = requests.get(url, params=all_params, timeout=15)
                
                # Atualiza counters de uso
                self.requests_remaining = response.headers.get('x-requests-remaining')
                self.requests_used = response.headers.get('x-requests-used')
                
                response.raise_for_status()
                data = response.json()
                self._save_to_cache(cache_key, data)
                return data
            
            except requests.exceptions.HTTPError as e:
                if e.response.status_code == 429:
                    wait = 2 ** attempt  # Backoff exponencial
                    print(f'Rate limit atingido. Aguardando {wait}s...')
                    time.sleep(wait)
                elif e.response.status_code == 401:
                    raise ValueError('API key inválida. Verifique o .env') from e
                else:
                    raise
            except requests.exceptions.Timeout:
                if attempt == self.max_retries - 1:
                    raise
                time.sleep(1)
        
        raise RuntimeError('Máximo de tentativas atingido')
    
    def get_sports(self) -> list[dict]:
        """Lista todos os esportes disponíveis."""
        return self._request('sports')
    
    def get_odds(
        self,
        sport: str,
        regions: str = 'eu,uk',
        markets: str = 'h2h',
        bookmakers: Optional[str] = None,
    ) -> list[dict]:
        """Busca odds ao vivo para um esporte."""
        params = {
            'regions': regions,
            'markets': markets,
            'oddsFormat': 'decimal',
        }
        if bookmakers:
            params['bookmakers'] = bookmakers
        return self._request(f'sports/{sport}/odds', params)
    
    def get_historical_odds(
        self,
        sport: str,
        event_id: str,
        date: str,  # ISO 8601
    ) -> dict:
        """Busca odds históricas para um evento específico."""
        params = {'date': date, 'oddsFormat': 'decimal', 'regions': 'eu'}
        return self._request(f'historical/sports/{sport}/events/{event_id}/odds', params)
    
    def get_scores(self, sport: str, days_from: int = 1) -> list[dict]:
        """Busca resultados recentes."""
        return self._request(f'sports/{sport}/scores', {'daysFrom': days_from})
    
    def print_usage(self) -> None:
        print(f'Requests usados: {self.requests_used} | Restantes: {self.requests_remaining}')


# Uso
client = OddsAPIClient(api_key=os.getenv('ODDS_API_KEY'))
odds = client.get_odds('soccer_epl', regions='eu,uk', markets='h2h,totals')
client.print_usage()

for game in odds[:3]:
    print(f"\n{game['home_team']} vs {game['away_team']}")
    print(f"Começa em: {game['commence_time']}")
    for book in game['bookmakers'][:2]:
        print(f"  {book['title']}:")
        for market in book['markets']:
            outcomes = {o['name']: o['price'] for o in market['outcomes']}
            print(f"    {market['key']}: {outcomes}")