Betting Lines

const BASE_URL = "https://api.sportsapipro.com/v1/football";
const API_KEY = "YOUR_API_KEY";
const EPL_COMPETITION_ID = 7;

// Get recent EPL results
async function getEPLResults() {
  const response = await fetch(
    `${BASE_URL}/games/results?competitions=${EPL_COMPETITION_ID}&showOdds=true`,
    { headers: { "x-api-key": API_KEY } }
  );
  const data = await response.json();
  
  return data.games.map(game => ({
    id: game.id,
    home: game.homeCompetitor.name,
    away: game.awayCompetitor.name,
    score: `${game.homeCompetitor.score}-${game.awayCompetitor.score}`,
    date: game.startTime
  }));
}

import requests

BASE_URL = "https://api.sportsapipro.com/v1/football"
API_KEY = "YOUR_API_KEY"
EPL_COMPETITION_ID = 7

def get_epl_results():
    """Get recent EPL match results with game IDs."""
    response = requests.get(
        f"{BASE_URL}/games/results",
        params={"competitions": EPL_COMPETITION_ID, "showOdds": "true"},
        headers={"x-api-key": API_KEY}
    )
    data = response.json()
    
    return [
        {
            "id": game["id"],
            "home": game["homeCompetitor"]["name"],
            "away": game["awayCompetitor"]["name"],
            "score": f"{game['homeCompetitor']['score']}-{game['awayCompetitor']['score']}",
            "date": game["startTime"]
        }
        for game in data.get("games", [])
    ]

// Fetch betting lines for multiple games
async function getBettingLines(gameIds) {
  const response = await fetch(
    `${BASE_URL}/bets/lines?games=${gameIds.join(',')}`,
    { headers: { "x-api-key": API_KEY } }
  );
  return response.json();
}

// Extract 1X2 closing lines
function extract1X2Lines(linesData) {
  return linesData.lines
    .filter(line => line.lineTypeId === 1 && line.isConcluded)
    .map(line => {
      const homeOpt = line.options.find(o => o.num === 1);
      const drawOpt = line.options.find(o => o.num === 2);
      const awayOpt = line.options.find(o => o.num === 3);
      
      return {
        gameId: line.gameId,
        home: {
          closing: homeOpt?.rate?.decimal,
          opening: homeOpt?.originalRate?.decimal,
          won: homeOpt?.isWon || false
        },
        draw: {
          closing: drawOpt?.rate?.decimal,
          opening: drawOpt?.originalRate?.decimal,
          won: drawOpt?.isWon || false
        },
        away: {
          closing: awayOpt?.rate?.decimal,
          opening: awayOpt?.originalRate?.decimal,
          won: awayOpt?.isWon || false
        }
      };
    });
}

def get_betting_lines(game_ids: list) -> dict:
    """Fetch betting lines for multiple games."""
    response = requests.get(
        f"{BASE_URL}/bets/lines",
        params={"games": ",".join(map(str, game_ids))},
        headers={"x-api-key": API_KEY}
    )
    return response.json()

def extract_1x2_lines(lines_data: dict) -> list:
    """Extract 1X2 closing lines from response."""
    results = []
    
    for line in lines_data.get("lines", []):
        if line.get("lineTypeId") != 1 or not line.get("isConcluded"):
            continue
        
        options = {opt["num"]: opt for opt in line.get("options", [])}
        
        results.append({
            "game_id": line["gameId"],
            "home": {
                "closing": options.get(1, {}).get("rate", {}).get("decimal"),
                "opening": options.get(1, {}).get("originalRate", {}).get("decimal"),
                "won": options.get(1, {}).get("isWon", False)
            },
            "draw": {
                "closing": options.get(2, {}).get("rate", {}).get("decimal"),
                "opening": options.get(2, {}).get("originalRate", {}).get("decimal"),
                "won": options.get(2, {}).get("isWon", False)
            },
            "away": {
                "closing": options.get(3, {}).get("rate", {}).get("decimal"),
                "opening": options.get(3, {}).get("originalRate", {}).get("decimal"),
                "won": options.get(3, {}).get("isWon", False)
            }
        })
    
    return results

/**
 * Calculate Closing Line Value (CLV)
 * 
 * @param {number} modelOdds - Your model's predicted odds
 * @param {number} closingOdds - The closing odds from the API
 * @returns {number} CLV percentage (positive = found value)
 */
function calculateCLV(modelOdds, closingOdds) {
  const modelProb = 1 / modelOdds;
  const closingProb = 1 / closingOdds;
  return ((modelProb - closingProb) * 100);
}

/**
 * Calculate implied probability from decimal odds
 */
function impliedProbability(decimalOdds) {
  return (1 / decimalOdds * 100);
}

/**
 * Complete EPL CLV Analysis
 */
async function analyzeEPLCLV(modelPredictions) {
  // modelPredictions: [{ gameId, homeProb, drawProb, awayProb }]
  
  // Step 1: Get EPL results
  const eplMatches = await getEPLResults();
  const gameIds = eplMatches.slice(0, 20).map(m => m.id); // Last 20 matches
  
  // Step 2: Get betting lines
  const linesData = await getBettingLines(gameIds);
  const closingLines = extract1X2Lines(linesData);
  
  // Step 3: Calculate CLV for each prediction
  const clvResults = [];
  
  for (const prediction of modelPredictions) {
    const closing = closingLines.find(l => l.gameId === prediction.gameId);
    if (!closing) continue;
    
    // Convert model probabilities to implied odds
    const modelHomeOdds = 1 / prediction.homeProb;
    const modelDrawOdds = 1 / prediction.drawProb;
    const modelAwayOdds = 1 / prediction.awayProb;
    
    clvResults.push({
      gameId: prediction.gameId,
      homeCLV: calculateCLV(modelHomeOdds, closing.home.closing),
      drawCLV: calculateCLV(modelDrawOdds, closing.draw.closing),
      awayCLV: calculateCLV(modelAwayOdds, closing.away.closing),
      actualWinner: closing.home.won ? 'home' : closing.draw.won ? 'draw' : 'away'
    });
  }
  
  return clvResults;
}

// Example usage
const myPredictions = [
  { gameId: 4609055, homeProb: 0.65, drawProb: 0.20, awayProb: 0.15 }
];

analyzeEPLCLV(myPredictions).then(results => {
  console.log("CLV Analysis Results:");
  results.forEach(r => {
    console.log(`Game ${r.gameId}:`);
    console.log(`  Home CLV: ${r.homeCLV.toFixed(2)}%`);
    console.log(`  Draw CLV: ${r.drawCLV.toFixed(2)}%`);
    console.log(`  Away CLV: ${r.awayCLV.toFixed(2)}%`);
    console.log(`  Actual Winner: ${r.actualWinner}`);
  });
});

from typing import List, Dict

def calculate_clv(model_odds: float, closing_odds: float) -> float:
    """
    Calculate Closing Line Value (CLV).
    
    Args:
        model_odds: Your model's predicted odds
        closing_odds: The closing odds from the API
        
    Returns:
        CLV percentage (positive = found value)
    """
    model_prob = 1 / model_odds
    closing_prob = 1 / closing_odds
    return (model_prob - closing_prob) * 100

def implied_probability(decimal_odds: float) -> float:
    """Calculate implied probability from decimal odds."""
    return (1 / decimal_odds) * 100

def analyze_epl_clv(model_predictions: List[Dict]) -> List[Dict]:
    """
    Complete EPL CLV Analysis.
    
    Args:
        model_predictions: List of dicts with gameId, homeProb, drawProb, awayProb
        
    Returns:
        List of CLV results for each prediction
    """
    # Step 1: Get EPL results
    epl_matches = get_epl_results()
    game_ids = [m["id"] for m in epl_matches[:20]]  # Last 20 matches
    
    # Step 2: Get betting lines
    lines_data = get_betting_lines(game_ids)
    closing_lines = extract_1x2_lines(lines_data)
    closing_by_id = {cl["game_id"]: cl for cl in closing_lines}
    
    # Step 3: Calculate CLV for each prediction
    clv_results = []
    
    for prediction in model_predictions:
        game_id = prediction["gameId"]
        closing = closing_by_id.get(game_id)
        if not closing:
            continue
        
        # Convert model probabilities to implied odds
        model_home_odds = 1 / prediction["homeProb"]
        model_draw_odds = 1 / prediction["drawProb"]
        model_away_odds = 1 / prediction["awayProb"]
        
        # Determine actual winner
        if closing["home"]["won"]:
            actual_winner = "home"
        elif closing["draw"]["won"]:
            actual_winner = "draw"
        else:
            actual_winner = "away"
        
        clv_results.append({
            "game_id": game_id,
            "home_clv": calculate_clv(model_home_odds, closing["home"]["closing"]),
            "draw_clv": calculate_clv(model_draw_odds, closing["draw"]["closing"]),
            "away_clv": calculate_clv(model_away_odds, closing["away"]["closing"]),
            "actual_winner": actual_winner
        })
    
    return clv_results

# Example usage
if __name__ == "__main__":
    my_predictions = [
        {"gameId": 4609055, "homeProb": 0.65, "drawProb": 0.20, "awayProb": 0.15}
    ]
    
    results = analyze_epl_clv(my_predictions)
    
    print("CLV Analysis Results:")
    for r in results:
        print(f"\nGame {r['game_id']}:")
        print(f"  Home CLV: {r['home_clv']:.2f}%")
        print(f"  Draw CLV: {r['draw_clv']:.2f}%")
        print(f"  Away CLV: {r['away_clv']:.2f}%")
        print(f"  Actual Winner: {r['actual_winner']}")