Arbitragem Esportiva com IA: Guia Completo para Iniciantes

import requests
import os
from itertools import product
from dataclasses import dataclass
from typing import Optional

API_KEY = os.getenv('ODDS_API_KEY')

@dataclass
class ArbOpportunity:
    home_team: str
    away_team: str
    sport: str
    # {outcome: {bookmaker: odd}}
    best_odds: dict
    arb_percentage: float  # Quanto de lucro garantido (%)
    stakes: dict  # Como distribuir R$1000 entre os outcomes

def calculate_arb(odds_by_outcome: dict[str, float]) -> Optional[tuple[float, dict]]:
    """
    Recebe {outcome: melhor_odd} e calcula se existe arb.
    Retorna (lucro_percentual, stakes_para_100_de_retorno) ou None.
    """
    implied_probs = {outcome: 1 / odd for outcome, odd in odds_by_outcome.items()}
    total_prob = sum(implied_probs.values())
    
    if total_prob >= 1.0:
        return None  # Não é arb
    
    # Lucro garantido
    arb_profit = (1 - total_prob) / total_prob * 100
    
    # Stakes para retorno de R$100
    stakes = {}
    for outcome, odd in odds_by_outcome.items():
        # stake = (1/odd) / soma_probabilidades * 100
        stakes[outcome] = round((implied_probs[outcome] / total_prob) * 100, 2)
    
    return arb_profit, stakes

def find_best_odds_per_outcome(game: dict) -> dict[str, dict]:
    """
    Para cada outcome, encontra a melhor odd e qual casa oferece.
    Retorna {outcome: {'odd': float, 'bookmaker': str}}
    """
    best: dict[str, dict] = {}
    home = game['home_team']
    away = game['away_team']
    
    for bookmaker in game.get('bookmakers', []):
        for market in bookmaker.get('markets', []):
            if market['key'] != 'h2h':
                continue
            for outcome in market['outcomes']:
                name = outcome['name']
                price = outcome['price']
                
                # Normaliza nome do outcome
                if name == home:
                    key = 'home'
                elif name == away:
                    key = 'away'
                elif name == 'Draw':
                    key = 'draw'
                else:
                    continue
                
                if key not in best or price > best[key]['odd']:
                    best[key] = {'odd': price, 'bookmaker': bookmaker['title']}
    
    return best

def scan_for_arbitrage(sport: str = 'soccer_epl') -> list[ArbOpportunity]:
    """Escaneia um esporte e retorna lista de oportunidades de arbitragem."""
    url = f'https://api.the-odds-api.com/v4/sports/{sport}/odds'
    params = {
        'apiKey': API_KEY,
        'regions': 'eu,uk,us',
        'markets': 'h2h',
        'oddsFormat': 'decimal',
    }
    
    response = requests.get(url, params=params, timeout=15)
    response.raise_for_status()
    games = response.json()
    
    opportunities = []
    
    for game in games:
        best_by_outcome = find_best_odds_per_outcome(game)
        
        if len(best_by_outcome) < 2:
            continue
        
        odds_values = {k: v['odd'] for k, v in best_by_outcome.items()}
        result = calculate_arb(odds_values)
        
        if result is None:
            continue
        
        arb_profit, stakes = result
        
        opportunities.append(ArbOpportunity(
            home_team=game['home_team'],
            away_team=game['away_team'],
            sport=sport,
            best_odds=best_by_outcome,
            arb_percentage=round(arb_profit, 2),
            stakes=stakes,
        ))
    
    return sorted(opportunities, key=lambda x: x.arb_percentage, reverse=True)

# Roda o scanner
arbs = scan_for_arbitrage('soccer_epl')

if not arbs:
    print('Nenhuma oportunidade de arbitragem encontrada agora.')
else:
    for arb in arbs:
        print(f"\n[ARB +{arb.arb_percentage:.2f}%] {arb.home_team} vs {arb.away_team}")
        for outcome, info in arb.best_odds.items():
            stake = arb.stakes.get(outcome, 0)
            print(f"  {outcome.upper()}: odd {info['odd']} @ {info['bookmaker']} | stake: R${stake:.2f}")
        print(f"  Retorno garantido: R${100 + arb.arb_percentage:.2f} para cada R$100 apostado")