SPORT = 'basketball_nba'

url = f'https://api.the-odds-api.com/v4/sports/{SPORT}/odds/'
params = {
    'apiKey': API_KEY,
    'regions': 'us',
    'markets': 'h2h,spreads,totals',
    'oddsFormat': 'american',
}

resp = requests.get(url, params=params)
resp.raise_for_status()
events = resp.json()

print(f'Got {len(events)} upcoming games')
print(f'Quota used: {resp.headers.get("x-requests-used", "?")} | Remaining: {resp.headers.get("x-requests-remaining", "?")}')

df = flatten_odds(events)
print(f'{len(df)} rows across {df["game"].nunique()} games and {df["bookmaker"].nunique()} bookmakers')
df.head()

# Filter to moneyline odds only
h2h = df[df['market'] == 'h2h'].copy()

# Pivot: game + team as rows, bookmakers as columns
pivot = h2h.pivot_table(
    index=['game', 'outcome'],
    columns='bookmaker',
    values='price',
    aggfunc='first',
)

# Build a Plotly table with best odds highlighted in green
books = pivot.columns.tolist()
row_labels = [f"{game} — {team}" for game, team in pivot.index]

cell_values = []
cell_colors = []
for col in books:
    col_vals, col_colors = [], []
    for (game, team), row in pivot.iterrows():
        val = row[col]
        if pd.notna(val):
            col_vals.append(f"{val:.0f}")
            col_colors.append('#2ecc71' if val == row.max() else 'white')
        else:
            col_vals.append('-')
            col_colors.append('white')
    cell_values.append(col_vals)
    cell_colors.append(col_colors)

fig = go.Figure(data=[go.Table(
    header=dict(
        values=['Game / Team'] + books,
        fill_color='#34495e',
        font=dict(color='white', size=12),
        align='left',
    ),
    cells=dict(
        values=[row_labels] + cell_values,
        fill_color=[['#f8f9fa'] * len(row_labels)] + cell_colors,
        align='left',
        font=dict(size=11),
    )
)])

fig.update_layout(
    height=max(300, len(row_labels) * 35 + 80),
    margin=dict(l=0, r=0, t=20, b=0),
)
fig.show()

best_lines = []

for (game, outcome), row in pivot.iterrows():
    best_book = row.idxmax()
    best_price = row.max()
    second_best = row.nlargest(2).iloc[-1] if len(row.dropna()) > 1 else best_price
    
    best_lines.append({
        'Game': game,
        'Team': outcome,
        'Best Book': best_book,
        'Best Odds': int(best_price) if pd.notna(best_price) else None,
        '2nd Best': int(second_best) if pd.notna(second_best) else None,
        'Edge': int(best_price - second_best) if pd.notna(best_price) and pd.notna(second_best) else 0,
    })

best_df = pd.DataFrame(best_lines)
best_df.sort_values('Edge', ascending=False)

# Average odds across bookmakers for each team (consensus line)
consensus = h2h.groupby(['game', 'outcome'])['price'].mean().reset_index()
consensus['implied_prob'] = consensus['price'].apply(american_to_implied_prob)
consensus['prob_pct'] = (consensus['implied_prob'] * 100).round(1)

consensus[['game', 'outcome', 'price', 'prob_pct']].head()

# Build the stacked bar chart
games = consensus['game'].unique()

fig = go.Figure()

for game in games:
    game_data = consensus[consensus['game'] == game]
    for _, row in game_data.iterrows():
        prob = row['prob_pct']
        fig.add_trace(go.Bar(
            y=[game],
            x=[prob],
            name=row['outcome'],
            orientation='h',
            text=f"{row['outcome']}: {prob:.1f}%",
            textposition='inside',
            showlegend=False,
            marker_color='#2ecc71' if prob >= 50 else '#e74c3c',
        ))

fig.update_layout(
    barmode='stack',
    xaxis_title='Implied Probability (%)',
    yaxis_title='',
    height=max(400, len(games) * 60),
    title='Implied Win Probabilities (Consensus Odds)',
)

fig.show()

# Pick the first game
event_id = events[0]['id']
game_name = f"{events[0]['away_team']} @ {events[0]['home_team']}"
print(f'Fetching props for: {game_name}')

props_url = f'https://api.the-odds-api.com/v4/sports/{SPORT}/events/{event_id}/odds/'
props_params = {
    'apiKey': API_KEY,
    'regions': 'us',
    'markets': 'player_points,player_rebounds,player_assists',
    'oddsFormat': 'american',
}

props_resp = requests.get(props_url, params=props_params)
props_resp.raise_for_status()
props_data = props_resp.json()

print(f'Quota used: {props_resp.headers.get("x-requests-used", "?")} | Remaining: {props_resp.headers.get("x-requests-remaining", "?")}')

props_df = flatten_props(props_data)
print(f'{len(props_df)} prop lines across {props_df["player"].nunique()} players')
props_df.head()

# Scatter plot: points props, Over side only
points = props_df[(props_df['market'] == 'player_points') & (props_df['side'] == 'Over')].copy()

if not points.empty:
    fig = px.scatter(
        points,
        x='line',
        y='price',
        color='bookmaker',
        hover_data=['player', 'bookmaker', 'line', 'price'],
        text='player',
        title=f'Points Props — {game_name}',
    )

    fig.update_traces(textposition='top center', textfont_size=9)
    fig.update_layout(
        xaxis_title='Points Line',
        yaxis_title='Odds (American)',
        height=600,
    )
    fig.show()
else:
    print('No points props available for this game yet.')

import cfbd
import pandas as pd
import matplotlib.pyplot as plt

# Configure API key - Replace 'YOUR_API_KEY_HERE' with your actual key
configuration = cfbd.Configuration()
configuration.api_key['Authorization'] = 'YOUR_API_KEY_HERE'  # Get your free key at collegefootballdata.com
configuration.api_key_prefix['Authorization'] = 'Bearer'

# Create API instance
api_instance = cfbd.GamesApi(cfbd.ApiClient(configuration))

# Get 2025 season games
games_2025 = api_instance.get_games(year=2025)
df_2025 = pd.DataFrame.from_records([g.to_dict() for g in games_2025])

print(f"Total games in 2025: {len(df_2025)}")
df_2025.head()

# Filter for just Oklahoma games (both home and away)
oklahoma_games_2025 = df_2025[(df_2025['home_team'] == 'Oklahoma') | (df_2025['away_team'] == 'Oklahoma')]

print(f"Oklahoma played {len(oklahoma_games_2025)} games in 2025")
oklahoma_games_2025[['week', 'home_team', 'away_team', 'home_points', 'away_points']].head(10)

# Figure out if Oklahoma was home or away
oklahoma_games_2025['is_home'] = oklahoma_games_2025['home_team'] == 'Oklahoma'
oklahoma_games_2025['points_scored'] = oklahoma_games_2025.apply(
    lambda row: row['home_points'] if row['is_home'] else row['away_points'], axis=1
)
oklahoma_games_2025['points_allowed'] = oklahoma_games_2025.apply(
    lambda row: row['away_points'] if row['is_home'] else row['home_points'], axis=1
)

# Let's see what we got
oklahoma_games_2025[['week', 'home_team', 'away_team', 'is_home', 'points_scored', 'points_allowed']].head(10)

# Get data for 2020-2025 seasons
years = [2020, 2021, 2022, 2023, 2024, 2025]
all_seasons = {}

for year in years:
    # Get all games for this year
    games = api_instance.get_games(year=year)
    df = pd.DataFrame.from_records([g.to_dict() for g in games])

    # Filter for Oklahoma games
    oklahoma_games = df[(df['home_team'] == 'Oklahoma') | (df['away_team'] == 'Oklahoma')]

    # Add game number (1st game, 2nd game, etc.)
    oklahoma_games['game_number'] = range(1, len(oklahoma_games) + 1)

    # Figure out if home/away and calculate points
    oklahoma_games['is_home'] = oklahoma_games['home_team'] == 'Oklahoma'
    oklahoma_games['points_scored'] = oklahoma_games.apply(
        lambda row: row['home_points'] if row['is_home'] else row['away_points'], axis=1
    )
    oklahoma_games['points_allowed'] = oklahoma_games.apply(
        lambda row: row['away_points'] if row['is_home'] else row['home_points'], axis=1
    )

    # Calculate cumulative points over the season
    oklahoma_games['cumulative_scored'] = oklahoma_games['points_scored'].cumsum()
    oklahoma_games['cumulative_allowed'] = oklahoma_games['points_allowed'].cumsum()

    # Store in dictionary
    all_seasons[year] = oklahoma_games
    print(f"{year}: {len(oklahoma_games)} games, {oklahoma_games['points_scored'].sum():.0f} total points scored")

# Visualize offensive and defensive trends
fig, axs = plt.subplots(1, 2, figsize=(14, 5))

# Use a nice color palette
colors = plt.cm.tab10(range(len(years)))

for i, year in enumerate(years):
    data = all_seasons[year]

    # Plot cumulative points scored (offense)
    axs[0].plot(data['game_number'], data['cumulative_scored'],
                label=f'{year}', color=colors[i], linewidth=2)

    # Plot cumulative points allowed (defense - lower is better)
    axs[1].plot(data['game_number'], data['cumulative_allowed'],
                label=f'{year}', color=colors[i], linewidth=2, linestyle='--')

# Offensive chart
axs[0].set_xlabel('Game Number', fontsize=12)
axs[0].set_ylabel('Cumulative Points Scored', fontsize=12)
axs[0].set_title('Oklahoma Offense: Points Scored Per Season', fontsize=14, fontweight='bold')
axs[0].legend()
axs[0].grid(True, alpha=0.3)

# Defensive chart
axs[1].set_xlabel('Game Number', fontsize=12)
axs[1].set_ylabel('Cumulative Points Allowed', fontsize=12)
axs[1].set_title('Oklahoma Defense: Points Allowed Per Season', fontsize=14, fontweight='bold')
axs[1].legend()
axs[1].grid(True, alpha=0.3)

plt.tight_layout()
plt.show()

# Calculate average points per game for each season
for year in years:
    data = all_seasons[year]
    avg_scored = data['points_scored'].mean()
    avg_allowed = data['points_allowed'].mean()
    num_games = len(data)

    print(f"{year} ({num_games} games): {avg_scored:.1f} PPG scored, {avg_allowed:.1f} PPG allowed, {avg_scored - avg_allowed:+.1f} point differential")

# Create bar chart comparing PPG across seasons
fig, ax = plt.subplots(figsize=(10, 6))

ppg_scored = [all_seasons[year]['points_scored'].mean() for year in years]
ppg_allowed = [all_seasons[year]['points_allowed'].mean() for year in years]

x = range(len(years))
width = 0.35

bars1 = ax.bar([i - width/2 for i in x], ppg_scored, width, label='Points Scored', color='#841617', alpha=0.8)
bars2 = ax.bar([i + width/2 for i in x], ppg_allowed, width, label='Points Allowed', color='#FFC72C', alpha=0.8)

ax.set_xlabel('Season', fontsize=12)
ax.set_ylabel('Points Per Game', fontsize=12)
ax.set_title('Oklahoma Football: Points Per Game by Season (2020-2025)', fontsize=14, fontweight='bold')
ax.set_xticks(x)
ax.set_xticklabels(years)
ax.legend()
ax.grid(True, axis='y', alpha=0.3)

plt.tight_layout()
plt.show()

import requests
import os

# Replace with your actual API key
API_KEY = 'YOUR_API_KEY'

# Setting parameters for NBA Basketball odds and spreads
SPORT = 'basketball_nba'  # NBA sport key
REGIONS = 'us'  # Focusing on US region
MARKETS = 'spreads'  # Focusing on spreads market
ODDS_FORMAT = 'decimal'  # Using decimal format for odds
DATE_FORMAT = 'iso'  # Using ISO format for dates

# Fetching in-season sports (optional step, but useful for confirmation)
sports_response = requests.get(
    'https://api.the-odds-api.com/v4/sports',
    params={'api_key': API_KEY}
)

if sports_response.status_code == 200:
    print(f"List of in season sports", sports_response.json())
else:
    print(f"Failed to get sports: status_code {sports_response.status_code}, response body {sports_response.text}")

# Fetching NBA odds
odds_response = requests.get(
    f'https://api.the-odds-api.com/v4/sports/{SPORT}/odds',
    params={
        'api_key': API_KEY,
        'regions': REGIONS,
        'markets': MARKETS,
        'oddsFormat': ODDS_FORMAT,
        'dateFormat': DATE_FORMAT,
    }
)

if odds_response.status_code == 200:
    odds_json = odds_response.json()
    print("Number of NBA events:", len(odds_json))
    print(odds_json)  # This prints the fetched odds data
    # Check the usage quota
    print("Remaining requests", odds_response.headers['x-requests-remaining'])
    print("Used requests", odds_response.headers['x-requests-used'])
else:
    print(f"Failed to get odds: status_code {odds_response.status_code}, response body {odds_response.text}")

import pandas as pd

odds_data = odds_json

# Prepare lists to hold extracted data
events = []
for event in odds_data:
    event_id = event['id']
    sport_key = event['sport_key']
    sport_title = event['sport_title']
    commence_time = event['commence_time']
    home_team = event['home_team']
    away_team = event['away_team']

    for bookmaker in event['bookmakers']:
        bookmaker_key = bookmaker['key']
        bookmaker_title = bookmaker['title']

        for market in bookmaker['markets']:
            if market['key'] == 'spreads':
                for outcome in market['outcomes']:
                    team = outcome['name']
                    price = outcome['price']
                    point = outcome['point']

                    # Append each record to the events list
                    events.append((event_id, sport_key, sport_title, commence_time,
                                   bookmaker_key, bookmaker_title, team, price,
                                   point))

# Create a DataFrame from the events list
columns = ['Event ID', 'Sport Key', 'Sport Title', 'Commence Time', 'Home Team',
           'Bookmaker Key', 'Bookmaker Title', 'Team', 'Price', 'Point Spread']
df = pd.DataFrame(events, columns=columns)

# Display the DataFrame
print(df)

# Convert Game_Date to a datetime
all_seasons_logs_df['GAME_DATE'] = pd.to_datetime(all_seasons_logs_df['GAME_DATE'])

# Create Month_Year to facilitate Month/Date Analysis
all_seasons_logs_df['MONTH_YEAR'] = all_seasons_logs_df['GAME_DATE'].dt.to_period('M')

# Aggregate game level data to yearly
yearly_stats = all_seasons_logs_df.groupby('YEAR').agg({
    'FGM': 'sum',
    'FGA': 'sum',
    'FG3M': 'sum',
    'FG3A': 'sum',
    'FTM': 'sum',
    'FTA': 'sum',
}).reset_index()

# Calculate field goal percentages
yearly_stats['FG_PCT'] = yearly_stats['FGM'] / yearly_stats['FGA']
yearly_stats['FG3_PCT'] = yearly_stats['FG3M'] / yearly_stats['FG3A']
yearly_stats['FT_PCT'] = yearly_stats['FTM'] / yearly_stats['FTA']

from nba_api.stats.endpoints import leagueleaders
import pandas as pd

try:
    # Pull data for the top 500 scorers
    top_500 = leagueleaders.LeagueLeaders(
        season='2023-24',
        season_type_all_star='Regular Season',
        stat_category_abbreviation='PTS'
    ).get_data_frames()[0][:500]

    # Correct column names for grouping
    avg_stats_columns = ['MIN', 'FGM', 'FGA', 'FTM', 'FTA', 'PTS', 'FG3M', 'FG3A']
    top_500_avg = top_500.groupby(['PLAYER', 'PLAYER_ID'])[avg_stats_columns].mean()

    # Inspect the first few rows of the averaged stats
    print(top_500_avg.head())

except Exception as e:
    print(f"An error occurred: {e}")