from google.cloud import bigquery

client = bigquery.Client()

record_query = """
WITH tagged AS (
  SELECT game_id, game_date, team, decision, position_group,
    CASE
      WHEN game_date BETWEEN '2022-10-01' AND '2023-06-30' THEN '2022-23'
      WHEN game_date BETWEEN '2023-10-01' AND '2024-06-30' THEN '2023-24'
      WHEN game_date BETWEEN '2024-10-01' AND '2025-06-30' THEN '2024-25'
      WHEN game_date BETWEEN '2025-10-01' AND '2026-06-30' THEN '2025-26'
    END AS season,
    CAST(SUBSTR(CAST(game_id AS STRING), 5, 2) AS INT64) AS game_type
  FROM `maydaystats.nhl_stats.boxscores`
  WHERE team IN ('NSH', 'COL')
)
SELECT team, season,
  COUNTIF(decision = 'W') AS wins,
  COUNTIF(decision = 'L') AS losses
FROM tagged
WHERE season IS NOT NULL AND game_type = 2 AND position_group = 'goalie' AND decision IS NOT NULL
GROUP BY team, season
ORDER BY team, season
"""

nsh_col_record = client.query(record_query).to_dataframe()
nsh_col_record_tbl = nsh_col_record.reset_index(drop=True)
nsh_col_record_tbl.index += 1
nsh_col_record_tbl

import pandas as pd

additions_query = """
WITH tagged AS (
  SELECT *,
    CASE
      WHEN game_date BETWEEN '2022-10-01' AND '2023-06-30' THEN '2022-23'
      WHEN game_date BETWEEN '2023-10-01' AND '2024-06-30' THEN '2023-24'
      WHEN game_date BETWEEN '2024-10-01' AND '2025-06-30' THEN '2024-25'
      WHEN game_date BETWEEN '2025-10-01' AND '2026-06-30' THEN '2025-26'
    END AS season,
    CAST(SUBSTR(CAST(game_id AS STRING), 5, 2) AS INT64) AS game_type,
    CAST(SPLIT(toi, ':')[OFFSET(0)] AS FLOAT64) + CAST(SPLIT(toi, ':')[OFFSET(1)] AS FLOAT64)/60 AS toi_min
  FROM `maydaystats.nhl_stats.boxscores`
  WHERE player_name IN (
    'M. Bourque', 'I. Lyubushkin', 'J. Drury', 'R. Colton', 'N. Hoglander',
    'A. Edstrom', 'A. Kerfoot', 'J. Ahcan', 'H. Skinner'
  )
  AND position_group != 'goalie'
)
SELECT player_name, season,
  STRING_AGG(DISTINCT team, '/') AS team,
  COUNT(DISTINCT game_id) AS games,
  SUM(goals) AS goals, SUM(assists) AS assists, SUM(points) AS points,
  ROUND(SAFE_DIVIDE(SUM(points), COUNT(DISTINCT game_id)), 2) AS pts_per_gp,
  SUM(shots_on_goal) AS shots, SUM(hits) AS hits, SUM(blocked_shots) AS blocked,
  ROUND(AVG(toi_min), 2) AS avg_toi
FROM tagged
WHERE season IS NOT NULL AND game_type IN (2, 3)
GROUP BY player_name, season
ORDER BY player_name, season
"""

additions = client.query(additions_query).to_dataframe()

TEAM_NAMES = {
    "DAL": "Dallas Stars", "COL": "Colorado Avalanche", "VAN": "Vancouver Canucks",
    "BUF": "Buffalo Sabres", "TOR": "Toronto Maple Leafs", "ANA": "Anaheim Ducks",
    "ARI": "Arizona Coyotes", "UTA": "Utah Hockey Club/Mammoth", "CAR": "Carolina Hurricanes",
    "TBL": "Tampa Bay Lightning", "STL": "St. Louis Blues", "NYR": "New York Rangers",
    "NSH": "Nashville Predators",
}

from google.cloud import bigquery
import pandas as pd

client = bigquery.Client()

monthly_query = """
SELECT
  FORMAT_DATE('%Y-%m', CAST(game_date AS DATE)) AS month,
  ROUND(SUM(woba_value)/SUM(woba_denom), 3) AS lg_woba,
  ROUND(SAFE_DIVIDE(COUNTIF(events = 'strikeout'), COUNTIF(events IS NOT NULL)), 3) AS k_rate,
  ROUND(SAFE_DIVIDE(COUNTIF(events = 'home_run'), COUNTIF(events IS NOT NULL)), 4) AS hr_rate,
  ROUND(AVG(IF(pitch_type IN ('FF', 'SI'), release_speed, NULL)), 1) AS avg_fastball_velo,
  ROUND(SAFE_DIVIDE(COUNTIF(description IN ('swinging_strike', 'swinging_strike_blocked')), COUNTIF(description IS NOT NULL)), 3) AS whiff_rate
FROM `maydaystats.mlb_statcast.pitches`
WHERE game_type = 'R'
GROUP BY month
ORDER BY month
"""

monthly = client.query(monthly_query).to_dataframe()
monthly_tbl = monthly.reset_index(drop=True)
monthly_tbl.index += 1
monthly_tbl

import matplotlib.pyplot as plt

fig, ax = plt.subplots(figsize=(8, 5))
ax.bar(monthly["month"], monthly["hr_rate"], color="#2c3e50")
ax.set_xlabel("Month")
ax.set_ylabel("Home runs per plate appearance")
ax.set_title("League HR Rate by Month, 2026 First Half")
ax.spines[["top", "right"]].set_visible(False)
plt.tight_layout()
plt.show()

movers_query = """
WITH pa AS (
  SELECT
    batter,
    CAST(game_date AS DATE) AS game_date,
    woba_value, woba_denom
  FROM `maydaystats.mlb_statcast.pitches`
  WHERE game_type = 'R' AND woba_denom IS NOT NULL
),
max_date AS (SELECT MAX(game_date) AS d FROM pa),
splits AS (
  SELECT
    batter,
    SUM(IF(game_date < DATE_SUB((SELECT d FROM max_date), INTERVAL 45 DAY), woba_value, 0)) AS early_val,
    SUM(IF(game_date < DATE_SUB((SELECT d FROM max_date), INTERVAL 45 DAY), woba_denom, 0)) AS early_pa,
    SUM(IF(game_date >= DATE_SUB((SELECT d FROM max_date), INTERVAL 45 DAY), woba_value, 0)) AS recent_val,
    SUM(IF(game_date >= DATE_SUB((SELECT d FROM max_date), INTERVAL 45 DAY), woba_denom, 0)) AS recent_pa
  FROM pa
  GROUP BY batter
)
SELECT
  b.player_name, b.team_name,
  s.early_pa, ROUND(s.early_val / s.early_pa, 3) AS early_woba,
  s.recent_pa, ROUND(s.recent_val / s.recent_pa, 3) AS recent_woba,
  ROUND(s.recent_val / s.recent_pa - s.early_val / s.early_pa, 3) AS woba_delta
FROM splits s
JOIN `maydaystats.mlb_season_stats.batting_latest` b ON b.player_id = s.batter
WHERE s.early_pa >= 100 AND s.recent_pa >= 100
ORDER BY woba_delta DESC
"""

movers = client.query(movers_query).to_dataframe()
risers = movers.head(5).reset_index(drop=True)
risers.index += 1
fallers = movers.tail(5).sort_values("woba_delta").reset_index(drop=True)
fallers.index += 1

risers[["player_name", "team_name", "early_woba", "recent_woba", "woba_delta"]]

fallers[["player_name", "team_name", "early_woba", "recent_woba", "woba_delta"]]

pitcher_movers_query = """
WITH pa AS (
  SELECT
    pitcher,
    CAST(game_date AS DATE) AS game_date,
    woba_value, woba_denom
  FROM `maydaystats.mlb_statcast.pitches`
  WHERE game_type = 'R' AND woba_denom IS NOT NULL
),
max_date AS (SELECT MAX(game_date) AS d FROM pa),
splits AS (
  SELECT
    pitcher,
    SUM(IF(game_date < DATE_SUB((SELECT d FROM max_date), INTERVAL 45 DAY), woba_value, 0)) AS early_val,
    SUM(IF(game_date < DATE_SUB((SELECT d FROM max_date), INTERVAL 45 DAY), woba_denom, 0)) AS early_bf,
    SUM(IF(game_date >= DATE_SUB((SELECT d FROM max_date), INTERVAL 45 DAY), woba_value, 0)) AS recent_val,
    SUM(IF(game_date >= DATE_SUB((SELECT d FROM max_date), INTERVAL 45 DAY), woba_denom, 0)) AS recent_bf
  FROM pa
  GROUP BY pitcher
)
SELECT
  p.player_name, p.team_name,
  IF(SAFE_DIVIDE(p.gamesStarted, p.gamesPitched) >= 0.5, 'Starter', 'Reliever') AS role,
  s.early_bf, ROUND(s.early_val / s.early_bf, 3) AS early_woba_against,
  s.recent_bf, ROUND(s.recent_val / s.recent_bf, 3) AS recent_woba_against,
  ROUND(s.recent_val / s.recent_bf - s.early_val / s.early_bf, 3) AS woba_against_delta
FROM splits s
JOIN `maydaystats.mlb_season_stats.pitching_latest` p ON p.player_id = s.pitcher
WHERE s.early_bf >= 60 AND s.recent_bf >= 60
ORDER BY woba_against_delta ASC
"""

pitcher_movers = client.query(pitcher_movers_query).to_dataframe()
cols = ["player_name", "team_name", "early_woba_against", "recent_woba_against", "woba_against_delta"]

starters = pitcher_movers[pitcher_movers["role"] == "Starter"].sort_values("woba_against_delta")
starter_movers = pd.concat([starters.head(4), starters.tail(4)])[cols].reset_index(drop=True)
starter_movers.index += 1

relievers = pitcher_movers[pitcher_movers["role"] == "Reliever"].sort_values("woba_against_delta")
reliever_movers = pd.concat([relievers.head(4), relievers.tail(4)])[cols].reset_index(drop=True)
reliever_movers.index += 1

starter_movers

reliever_movers

team_trend_query = """
WITH games AS (
  SELECT
    game_pk,
    CAST(ANY_VALUE(game_date) AS DATE) AS game_date,
    ANY_VALUE(home_team) AS home_team,
    ANY_VALUE(away_team) AS away_team,
    MAX(post_home_score) AS home_final,
    MAX(post_away_score) AS away_final
  FROM `maydaystats.mlb_statcast.pitches`
  WHERE game_type = 'R'
  GROUP BY game_pk
),
team_games AS (
  SELECT game_pk, game_date, home_team AS team,
    IF(home_final > away_final, 1, 0) AS win
  FROM games
  UNION ALL
  SELECT game_pk, game_date, away_team AS team,
    IF(away_final > home_final, 1, 0) AS win
  FROM games
),
max_date AS (SELECT MAX(game_date) AS d FROM team_games),
records AS (
  SELECT
    team,
    ROUND(SAFE_DIVIDE(SUM(IF(game_date < DATE_SUB((SELECT d FROM max_date), INTERVAL 45 DAY), win, 0)),
      SUM(IF(game_date < DATE_SUB((SELECT d FROM max_date), INTERVAL 45 DAY), 1, 0))), 3) AS early_wpct,
    ROUND(SAFE_DIVIDE(SUM(IF(game_date >= DATE_SUB((SELECT d FROM max_date), INTERVAL 45 DAY), win, 0)),
      SUM(IF(game_date >= DATE_SUB((SELECT d FROM max_date), INTERVAL 45 DAY), 1, 0))), 3) AS recent_wpct
  FROM team_games
  GROUP BY team
),
pa AS (
  SELECT
    CAST(game_date AS DATE) AS game_date,
    IF(inning_topbot = 'Top', away_team, home_team) AS bat_team,
    IF(inning_topbot = 'Top', home_team, away_team) AS pit_team,
    woba_value, woba_denom
  FROM `maydaystats.mlb_statcast.pitches`
  WHERE game_type = 'R' AND woba_denom IS NOT NULL
),
max_pa_date AS (SELECT MAX(game_date) AS d FROM pa),
off AS (
  SELECT bat_team AS team,
    ROUND(SAFE_DIVIDE(SUM(IF(game_date < DATE_SUB((SELECT d FROM max_pa_date), INTERVAL 45 DAY), woba_value, 0)),
      SUM(IF(game_date < DATE_SUB((SELECT d FROM max_pa_date), INTERVAL 45 DAY), woba_denom, 0))), 3) AS off_early,
    ROUND(SAFE_DIVIDE(SUM(IF(game_date >= DATE_SUB((SELECT d FROM max_pa_date), INTERVAL 45 DAY), woba_value, 0)),
      SUM(IF(game_date >= DATE_SUB((SELECT d FROM max_pa_date), INTERVAL 45 DAY), woba_denom, 0))), 3) AS off_recent
  FROM pa GROUP BY bat_team
),
def AS (
  SELECT pit_team AS team,
    ROUND(SAFE_DIVIDE(SUM(IF(game_date < DATE_SUB((SELECT d FROM max_pa_date), INTERVAL 45 DAY), woba_value, 0)),
      SUM(IF(game_date < DATE_SUB((SELECT d FROM max_pa_date), INTERVAL 45 DAY), woba_denom, 0))), 3) AS def_early,
    ROUND(SAFE_DIVIDE(SUM(IF(game_date >= DATE_SUB((SELECT d FROM max_pa_date), INTERVAL 45 DAY), woba_value, 0)),
      SUM(IF(game_date >= DATE_SUB((SELECT d FROM max_pa_date), INTERVAL 45 DAY), woba_denom, 0))), 3) AS def_recent
  FROM pa GROUP BY pit_team
)
SELECT
  r.team, r.early_wpct, r.recent_wpct,
  ROUND(r.recent_wpct - r.early_wpct, 3) AS wpct_delta,
  o.off_early, o.off_recent, ROUND(o.off_recent - o.off_early, 3) AS off_delta,
  d.def_early, d.def_recent, ROUND(d.def_recent - d.def_early, 3) AS def_delta
FROM records r
JOIN off o ON o.team = r.team
JOIN def d ON d.team = r.team
ORDER BY wpct_delta DESC
"""

team_trend = client.query(team_trend_query).to_dataframe()

TEAM_NAMES = {
    "ATH": "Athletics", "ATL": "Atlanta Braves", "AZ": "Arizona Diamondbacks",
    "BAL": "Baltimore Orioles", "BOS": "Boston Red Sox", "CHC": "Chicago Cubs",
    "CIN": "Cincinnati Reds", "CLE": "Cleveland Guardians", "COL": "Colorado Rockies",
    "CWS": "Chicago White Sox", "DET": "Detroit Tigers", "HOU": "Houston Astros",
    "KC": "Kansas City Royals", "LAA": "Los Angeles Angels", "LAD": "Los Angeles Dodgers",
    "MIA": "Miami Marlins", "MIL": "Milwaukee Brewers", "MIN": "Minnesota Twins",
    "NYM": "New York Mets", "NYY": "New York Yankees", "PHI": "Philadelphia Phillies",
    "PIT": "Pittsburgh Pirates", "SD": "San Diego Padres", "SEA": "Seattle Mariners",
    "SF": "San Francisco Giants", "STL": "St. Louis Cardinals", "TB": "Tampa Bay Rays",
    "TEX": "Texas Rangers", "TOR": "Toronto Blue Jays", "WSH": "Washington Nationals",
}
team_trend["team_name"] = team_trend["team"].map(TEAM_NAMES)

movers_teams = pd.concat([team_trend.head(5), team_trend.tail(5)])

fig, ax = plt.subplots(figsize=(8, 6))
plot_teams = movers_teams.iloc[::-1]
colors = ["#2c3e50" if v > 0 else "#c0392b" for v in plot_teams["wpct_delta"]]
ax.barh(plot_teams["team_name"], plot_teams["wpct_delta"], color=colors)
ax.set_xlabel("Win rate change (recent 45 days minus early season)")
ax.set_title("Biggest Team Win-Rate Swings")
ax.spines[["top", "right"]].set_visible(False)
ax.axvline(0, color="#888888", linewidth=0.8)
plt.tight_layout()
plt.show()

trend_tbl = movers_teams[["team_name", "wpct_delta", "off_delta", "def_delta"]].rename(
    columns={"off_delta": "batting_woba_delta", "def_delta": "pitching_woba_allowed_delta"}
).reset_index(drop=True)
trend_tbl.index += 1
trend_tbl

standings_query = """
WITH games AS (
  SELECT
    game_pk,
    ANY_VALUE(home_team) AS home_team,
    ANY_VALUE(away_team) AS away_team,
    MAX(post_home_score) AS home_final,
    MAX(post_away_score) AS away_final
  FROM `maydaystats.mlb_statcast.pitches`
  WHERE game_type = 'R'
  GROUP BY game_pk
),
team_games AS (
  SELECT home_team AS team, IF(home_final > away_final, 1, 0) AS win FROM games
  UNION ALL
  SELECT away_team AS team, IF(away_final > home_final, 1, 0) AS win FROM games
)
SELECT team, COUNT(*) AS games, SUM(win) AS wins, COUNT(*) - SUM(win) AS losses,
  ROUND(SAFE_DIVIDE(SUM(win), COUNT(*)), 3) AS win_pct
FROM team_games
WHERE team IN ('MIL', 'CHC', 'STL', 'PIT', 'CIN')
GROUP BY team
ORDER BY win_pct DESC
"""

standings = client.query(standings_query).to_dataframe()
standings["team"] = standings["team"].map(TEAM_NAMES)
standings_tbl = standings.reset_index(drop=True)
standings_tbl.index += 1
standings_tbl

runs_query = """
WITH games AS (
  SELECT
    game_pk,
    CAST(ANY_VALUE(game_date) AS DATE) AS game_date,
    ANY_VALUE(home_team) AS home_team,
    ANY_VALUE(away_team) AS away_team,
    MAX(post_home_score) AS home_final,
    MAX(post_away_score) AS away_final
  FROM `maydaystats.mlb_statcast.pitches`
  WHERE game_type = 'R'
  GROUP BY game_pk
),
team_games AS (
  SELECT game_pk, game_date, home_team AS team, home_final AS runs_scored, away_final AS runs_allowed FROM games
  UNION ALL
  SELECT game_pk, game_date, away_team AS team, away_final AS runs_scored, home_final AS runs_allowed FROM games
),
max_date AS (SELECT MAX(game_date) AS d FROM team_games)
SELECT
  team,
  ROUND(SUM(runs_scored) / COUNT(*), 2) AS rpg_season,
  ROUND(SUM(runs_allowed) / COUNT(*), 2) AS runs_allowed_pg_season,
  ROUND(SAFE_DIVIDE(SUM(IF(game_date >= DATE_SUB((SELECT d FROM max_date), INTERVAL 45 DAY), runs_scored, 0)),
    SUM(IF(game_date >= DATE_SUB((SELECT d FROM max_date), INTERVAL 45 DAY), 1, 0))), 2) AS rpg_recent,
  ROUND(SAFE_DIVIDE(SUM(IF(game_date >= DATE_SUB((SELECT d FROM max_date), INTERVAL 45 DAY), runs_allowed, 0)),
    SUM(IF(game_date >= DATE_SUB((SELECT d FROM max_date), INTERVAL 45 DAY), 1, 0))), 2) AS runs_allowed_pg_recent
FROM team_games
GROUP BY team
"""
runs_all = client.query(runs_query).to_dataframe()
lg_avg = runs_all["rpg_season"].mean()
reds_runs = runs_all[runs_all["team"] == "CIN"].copy()
reds_runs["team"] = "Cincinnati Reds"
reds_runs_tbl = reds_runs.reset_index(drop=True)
reds_runs_tbl.index += 1
reds_runs_tbl

reds_hitters_query = """
SELECT player_name, position, gamesPlayed, homeRuns, rbi,
  CAST(avg AS FLOAT64) AS avg, CAST(obp AS FLOAT64) AS obp,
  CAST(slg AS FLOAT64) AS slg, CAST(ops AS FLOAT64) AS ops, plateAppearances
FROM `maydaystats.mlb_season_stats.batting_latest`
WHERE team_name = 'Cincinnati Reds' AND plateAppearances >= 50
ORDER BY ops DESC
"""
reds_hitters = client.query(reds_hitters_query).to_dataframe()
reds_hitters_tbl = reds_hitters.reset_index(drop=True)
reds_hitters_tbl.index += 1
reds_hitters_tbl

reds_contact_query = """
SELECT b.player_name,
  ROUND(AVG(p.launch_speed), 1) AS avg_exit_velo,
  ROUND(SAFE_DIVIDE(COUNTIF(p.launch_speed >= 95), COUNTIF(p.launch_speed IS NOT NULL)), 3) AS hard_hit_rate,
  ROUND(AVG(p.bat_speed), 1) AS avg_bat_speed,
  COUNT(p.launch_speed) AS batted_balls
FROM `maydaystats.mlb_season_stats.batting_latest` b
JOIN `maydaystats.mlb_statcast.pitches` p ON p.batter = b.player_id
WHERE b.team_name = 'Cincinnati Reds' AND p.launch_speed IS NOT NULL AND p.game_type = 'R'
GROUP BY b.player_name
HAVING batted_balls >= 100
ORDER BY avg_exit_velo DESC
"""
reds_contact = client.query(reds_contact_query).to_dataframe()
reds_contact_tbl = reds_contact.reset_index(drop=True)
reds_contact_tbl.index += 1
reds_contact_tbl

reds_luck_query = """
SELECT b.player_name,
  ROUND(AVG(p.estimated_ba_using_speedangle), 3) AS xba,
  CAST(b.avg AS FLOAT64) AS actual_avg,
  ROUND(CAST(b.avg AS FLOAT64) - AVG(p.estimated_ba_using_speedangle), 3) AS avg_minus_xba,
  COUNT(*) AS batted_balls
FROM `maydaystats.mlb_season_stats.batting_latest` b
JOIN `maydaystats.mlb_statcast.pitches` p ON p.batter = b.player_id
WHERE b.team_name = 'Cincinnati Reds'
  AND p.estimated_ba_using_speedangle IS NOT NULL AND p.game_type = 'R'
GROUP BY b.player_name, b.avg
HAVING batted_balls >= 90
ORDER BY avg_minus_xba ASC
"""
reds_luck = client.query(reds_luck_query).to_dataframe()
reds_luck_tbl = reds_luck.head(5)[["player_name", "xba", "actual_avg", "avg_minus_xba"]].reset_index(drop=True)
reds_luck_tbl.index += 1
reds_luck_tbl

reds_pitching_query = """
SELECT player_name,
  IF(SAFE_DIVIDE(gamesStarted, gamesPitched) >= 0.5, 'Starter', 'Reliever') AS role,
  wins, losses, CAST(era AS FLOAT64) AS era, strikeOuts,
  CAST(whip AS FLOAT64) AS whip, CAST(inningsPitched AS FLOAT64) AS ip
FROM `maydaystats.mlb_season_stats.pitching_latest`
WHERE team_name = 'Cincinnati Reds' AND CAST(inningsPitched AS FLOAT64) >= 20
ORDER BY role, era ASC
"""
reds_pitching = client.query(reds_pitching_query).to_dataframe()
reds_pitching_tbl = reds_pitching.reset_index(drop=True)
reds_pitching_tbl.index += 1
reds_pitching_tbl

reds_pitch_trend_query = """
WITH pa AS (
  SELECT
    pitcher,
    CAST(game_date AS DATE) AS game_date,
    woba_value, woba_denom
  FROM `maydaystats.mlb_statcast.pitches`
  WHERE game_type = 'R' AND woba_denom IS NOT NULL
),
max_date AS (SELECT MAX(game_date) AS d FROM pa),
splits AS (
  SELECT
    pitcher,
    SUM(IF(game_date < DATE_SUB((SELECT d FROM max_date), INTERVAL 45 DAY), woba_value, 0)) AS early_val,
    SUM(IF(game_date < DATE_SUB((SELECT d FROM max_date), INTERVAL 45 DAY), woba_denom, 0)) AS early_bf,
    SUM(IF(game_date >= DATE_SUB((SELECT d FROM max_date), INTERVAL 45 DAY), woba_value, 0)) AS recent_val,
    SUM(IF(game_date >= DATE_SUB((SELECT d FROM max_date), INTERVAL 45 DAY), woba_denom, 0)) AS recent_bf
  FROM pa
  GROUP BY pitcher
)
SELECT
  p.player_name,
  IF(SAFE_DIVIDE(p.gamesStarted, p.gamesPitched) >= 0.5, 'Starter', 'Reliever') AS role,
  ROUND(SAFE_DIVIDE(s.early_val, s.early_bf), 3) AS early_woba_against,
  ROUND(SAFE_DIVIDE(s.recent_val, s.recent_bf), 3) AS recent_woba_against
FROM splits s
JOIN `maydaystats.mlb_season_stats.pitching_latest` p ON p.player_id = s.pitcher
WHERE p.team_name = 'Cincinnati Reds' AND s.early_bf >= 20 AND s.recent_bf >= 20
ORDER BY role, recent_woba_against ASC
"""
reds_pitch_trend = client.query(reds_pitch_trend_query).to_dataframe()
reds_pitch_trend_tbl = reds_pitch_trend.reset_index(drop=True)
reds_pitch_trend_tbl.index += 1
reds_pitch_trend_tbl

from google.cloud import bigquery
import pandas as pd

client = bigquery.Client()

batting_query = """
SELECT
  league_name, player_name, team_name,
  homeRuns, CAST(ops AS FLOAT64) AS ops, CAST(avg AS FLOAT64) AS avg,
  plateAppearances,
  RANK() OVER (PARTITION BY league_name ORDER BY CAST(ops AS FLOAT64) DESC) AS ops_rank
FROM `maydaystats.mlb_season_stats.batting_latest`
WHERE plateAppearances >= 150
ORDER BY league_name, ops_rank
"""
# Every qualified hitter, ranked; used below for specific-player lookups
# (some storyline players, like Guerrero, rank well outside the top 15).
batting_all = client.query(batting_query).to_dataframe()
batting = batting_all[batting_all["ops_rank"] <= 15].copy()

pitching_query = """
SELECT
  league_name, player_name, team_name,
  CAST(era AS FLOAT64) AS era, strikeOuts, CAST(whip AS FLOAT64) AS whip,
  wins, CAST(inningsPitched AS FLOAT64) AS ip
FROM `maydaystats.mlb_season_stats.pitching_latest`
WHERE CAST(inningsPitched AS FLOAT64) >= 60
QUALIFY RANK() OVER (PARTITION BY league_name ORDER BY era ASC) <= 15
ORDER BY league_name, era ASC
"""
pitching = client.query(pitching_query).to_dataframe()

# The full announced rosters (starters, pitchers, and reserves), plus how
# each player got there. Source: MLB.com's official roster announcement
# and the subsequent replacement announcements for Vladimir Guerrero Jr.
all_stars = {
    # American League
    "Shea Langeliers": "Elected starter", "Vladimir Guerrero Jr.": "Elected starter (withdrew, injury)",
    "Ernie Clement": "Elected starter", "Junior Caminero": "Elected starter",
    "Bobby Witt Jr.": "Elected starter", "Mike Trout": "Elected starter",
    "Byron Buxton": "Elected starter", "Aaron Judge": "Elected starter",
    "Yordan Alvarez": "Elected starter",
    "Bryan Baker": "MLB's choice", "Dylan Cease": "Player-elected",
    "Aroldis Chapman": "Player-elected", "Jacob Latz": "MLB's choice",
    "Parker Messick": "Player-elected", "Drew Rasmussen": "Reserve",
    "Joe Ryan": "Player-elected", "Cam Schlittler": "Player-elected",
    "Cade Smith": "Player-elected", "Ranger Suarez": "MLB's choice",
    "Louis Varland": "Player-elected", "Michael Wacha": "MLB's choice",
    "Dillon Dingler": "Player-elected", "Adley Rutschman": "MLB's choice",
    "Travis Bazzana": "Player-elected", "Nick Kurtz": "Reserve -> now starting (Guerrero replacement)",
    "Kevin McGonigle": "Player-elected", "Ben Rice": "MLB's choice",
    "Miguel Vargas": "Player-elected", "Randy Arozarena": "Player-elected",
    "Cody Bellinger": "Player-elected", "Riley Greene": "Player-elected",
    "Yandy Díaz": "Player-elected", "Justin Verlander": "Legend Pick",
    "Willson Contreras": "Roster replacement (for Guerrero)",
    # National League
    "Drake Baldwin": "Elected starter", "Freddie Freeman": "Elected starter",
    "Ozzie Albies": "Elected starter", "Max Muncy": "Elected starter",
    "CJ Abrams": "Elected starter", "Brandon Marsh": "Elected starter",
    "Juan Soto": "Elected starter", "Andy Pages": "Elected starter",
    "Shohei Ohtani": "Elected starter",
    "Chase Burns": "Player-elected", "Jhoan Duran": "Player-elected",
    "Raisel Iglesias": "Player-elected", "Max Meyer": "MLB's choice",
    "Mason Miller": "Player-elected", "Jacob Misiorowski": "Player-elected",
    "Eduardo Rodriguez": "MLB's choice", "Chris Sale": "Player-elected",
    "Cristopher Sánchez": "Player-elected", "Paul Skenes": "Player-elected",
    "Logan Webb": "MLB's choice", "Yoshinobu Yamamoto": "MLB's choice",
    "William Contreras": "Player-elected", "Hunter Goodman": "MLB's choice",
    "Luis Arraez": "Player-elected", "Bryce Harper": "Legend Pick",
    "Otto Lopez": "Player-elected", "Matt Olson": "Player-elected",
    "Sal Stewart": "Player-elected", "Corbin Carroll": "Player-elected",
    "Pete Crow-Armstrong": "Player-elected", "Jordan Walker": "MLB's choice",
    "James Wood": "Player-elected", "Kyle Schwarber": "Player-elected",
}

batting_all["selection"] = batting_all["player_name"].map(all_stars).fillna("Not selected")
batting["selection"] = batting["player_name"].map(all_stars).fillna("Not selected")
pitching["selection"] = pitching["player_name"].map(all_stars).fillna("Not selected")

import matplotlib.pyplot as plt
from matplotlib.patches import Patch

al_bat = batting[batting["league_name"] == "AL"].head(12).iloc[::-1]
colors = ["#2c3e50" if s != "Not selected" else "#c0392b" for s in al_bat["selection"]]
legend_handles = [
    Patch(color="#2c3e50", label="On an All-Star roster"),
    Patch(color="#c0392b", label="Not selected"),
]

fig, ax = plt.subplots(figsize=(8, 6.5))
ax.barh(al_bat["player_name"], al_bat["ops"], color=colors)
ax.set_xlabel("OPS")
ax.set_title("AL OPS Leaders (min. 150 PA)")
ax.spines[["top", "right"]].set_visible(False)
ax.legend(
    handles=legend_handles, loc="upper center", bbox_to_anchor=(0.5, -0.1),
    ncol=2, frameon=False,
)
plt.tight_layout()
plt.show()

nl_bat = batting[batting["league_name"] == "NL"].head(12).iloc[::-1]
colors = ["#2c3e50" if s != "Not selected" else "#c0392b" for s in nl_bat["selection"]]

fig, ax = plt.subplots(figsize=(8, 6.5))
ax.barh(nl_bat["player_name"], nl_bat["ops"], color=colors)
ax.set_xlabel("OPS")
ax.set_title("NL OPS Leaders (min. 150 PA)")
ax.spines[["top", "right"]].set_visible(False)
ax.legend(
    handles=legend_handles, loc="upper center", bbox_to_anchor=(0.5, -0.1),
    ncol=2, frameon=False,
)
plt.tight_layout()
plt.show()

elected = batting[batting["selection"] == "Elected starter"].sort_values("ops", ascending=False)
top_elected = elected.head(5)

top_starters_tbl = top_elected[["player_name", "team_name", "league_name", "homeRuns", "ops", "avg"]].reset_index(drop=True)
top_starters_tbl.index += 1
top_starters_tbl

guerrero = batting_all[batting_all["player_name"] == "Vladimir Guerrero Jr."].iloc[0]
kurtz = batting_all[batting_all["player_name"] == "Nick Kurtz"].iloc[0]
contreras = batting_all[batting_all["player_name"] == "Willson Contreras"].iloc[0]

harper = batting_all[batting_all["player_name"] == "Bryce Harper"].iloc[0]

batting_snubs_tbl = batting[batting["selection"] == "Not selected"][
    ["player_name", "team_name", "league_name", "homeRuns", "ops", "avg"]
].reset_index(drop=True)
batting_snubs_tbl.index += 1
batting_snubs_tbl

pitching_snubs_tbl = pitching[pitching["selection"] == "Not selected"][
    ["player_name", "team_name", "league_name", "era", "strikeOuts", "whip", "wins"]
].reset_index(drop=True)
pitching_snubs_tbl.index += 1
pitching_snubs_tbl

from google.cloud import bigquery

client = bigquery.Client()

query = """
SELECT
  player_name,
  team,
  SUM(points) AS points,
  SUM(kills) AS kills,
  SUM(attack_attempts) AS attempts,
  SAFE_DIVIDE(SUM(kills), SUM(attack_attempts)) AS kill_pct,
  COUNT(DISTINCT schedule_event_id) AS matches
FROM `maydaystats.mlv_volleyball.boxscores`
WHERE team NOT IN ('Team Launiere', 'Team Meske')
GROUP BY player_name, team
ORDER BY points DESC
LIMIT 10
"""

leaders = client.query(query).to_dataframe()
leaders = leaders.reset_index(drop=True)
leaders.index += 1
leaders

import matplotlib.pyplot as plt

fig, ax = plt.subplots(figsize=(9, 5))
labels = leaders["player_name"] + " (" + leaders["team"] + ")"
ax.barh(labels[::-1], leaders["points"][::-1], color="#2c3e50")
ax.set_xlabel("Points")
ax.set_title("Top 10 Scorers, 2025-26 MLV Season")
ax.spines[["top", "right"]].set_visible(False)
plt.tight_layout()
plt.show()

digs_query = """
SELECT player_name, team, SUM(digs) AS total
FROM `maydaystats.mlv_volleyball.boxscores`
WHERE team NOT IN ('Team Launiere', 'Team Meske')
GROUP BY player_name, team
ORDER BY total DESC
LIMIT 1
"""
digs_leader = client.query(digs_query).to_dataframe()

assists_query = """
SELECT player_name, team, SUM(assists) AS total
FROM `maydaystats.mlv_volleyball.boxscores`
WHERE team NOT IN ('Team Launiere', 'Team Meske')
GROUP BY player_name, team
ORDER BY total DESC
LIMIT 1
"""
assists_leader = client.query(assists_query).to_dataframe()

aces_query = """
SELECT player_name, team, SUM(service_aces) AS total
FROM `maydaystats.mlv_volleyball.boxscores`
WHERE team NOT IN ('Team Launiere', 'Team Meske')
GROUP BY player_name, team
ORDER BY total DESC
LIMIT 1
"""
aces_leader = client.query(aces_query).to_dataframe()

standings_query = """
WITH regular_season AS (
  SELECT * FROM `maydaystats.mlv_volleyball.matches`
  WHERE schedule_event_id NOT IN (637, 638, 639)
),
team_results AS (
  SELECT first_team_name AS team,
    IF(first_team_score > second_team_score, 1, 0) AS win
  FROM regular_season
  UNION ALL
  SELECT second_team_name AS team,
    IF(second_team_score > first_team_score, 1, 0) AS win
  FROM regular_season
)
SELECT team, SUM(win) AS wins, COUNT(*) - SUM(win) AS losses
FROM team_results
GROUP BY team
ORDER BY wins DESC
LIMIT 5
"""

standings = client.query(standings_query).to_dataframe()
standings = standings.reset_index(drop=True)
standings.index += 1
standings

import re

playoff_query = """
SELECT schedule_event_id, game_date, first_team_name, first_team_score,
  second_team_name, second_team_score
FROM `maydaystats.mlv_volleyball.matches`
WHERE schedule_event_id IN (637, 638, 639)
ORDER BY game_date
"""
playoffs = client.query(playoff_query).to_dataframe()

# Playoff schedule-events carry a seed prefix in the raw team name
# ("No. 4 Omaha Supernovas") that the regular-season rows don't - strip
# it for display, same cleanup the pipeline itself does before matching
# team names against the PDF text (see fetch.py's _strip_seed).
seed_re = re.compile(r"^No\.\s*\d+\s+")
for col in ("first_team_name", "second_team_name"):
    playoffs[col] = playoffs[col].str.replace(seed_re, "", regex=True)

playoffs = playoffs.reset_index(drop=True)
playoffs.index += 1
playoffs

from google.cloud import bigquery

client = bigquery.Client()

query = """
SELECT
  pitch_type,
  COUNT(*) AS n_pitches,
  AVG(release_speed) AS avg_release_speed,
  AVG(release_spin_rate) AS avg_spin_rate
FROM `maydaystats.mlb_statcast.pitches`
WHERE pitch_type IS NOT NULL
GROUP BY pitch_type
ORDER BY n_pitches DESC
"""

df = client.query(query).to_dataframe()
df = df.reset_index(drop=True)
df.index += 1
df

import matplotlib.pyplot as plt

fig, ax = plt.subplots(figsize=(8, 5))
ax.bar(df["pitch_type"], df["avg_release_speed"], color="#2c3e50")
ax.set_xlabel("Pitch type")
ax.set_ylabel("Average release speed (mph)")
ax.set_title("Average Release Speed by Pitch Type")
ax.spines[["top", "right"]].set_visible(False)
plt.tight_layout()
plt.show()

from google.cloud import bigquery

client = bigquery.Client()

query = """
SELECT
  player_name,
  team,
  SUM(goals) AS goals,
  SUM(assists) AS assists,
  SUM(points) AS points,
  COUNT(DISTINCT game_id) AS games_played
FROM `maydaystats.nhl_stats.boxscores`
WHERE CAST(SUBSTR(CAST(game_id AS STRING), 5, 2) AS INT64) IN (2, 3)
  AND position_group != 'goalie'
GROUP BY player_name, team
ORDER BY points DESC
LIMIT 10
"""

scorers = client.query(query).to_dataframe()
scorers = scorers.reset_index(drop=True)
scorers.index += 1
scorers

import matplotlib.pyplot as plt

fig, ax = plt.subplots(figsize=(9, 5))
labels = scorers["player_name"] + " (" + scorers["team"] + ")"
ax.barh(labels[::-1], scorers["points"][::-1], color="#2c3e50")
ax.set_xlabel("Points")
ax.set_title("Top 10 Scorers, 2025-26 Season")
ax.spines[["top", "right"]].set_visible(False)
plt.tight_layout()
plt.show()

standings_query = """
SELECT
  team,
  COUNTIF(decision = 'W') AS wins,
  COUNTIF(decision = 'L') AS losses
FROM `maydaystats.nhl_stats.boxscores`
WHERE CAST(SUBSTR(CAST(game_id AS STRING), 5, 2) AS INT64) = 2
  AND position_group = 'goalie'
  AND decision IS NOT NULL
GROUP BY team
ORDER BY wins DESC
LIMIT 5
"""

standings = client.query(standings_query).to_dataframe()
standings = standings.reset_index(drop=True)
standings.index += 1
standings

col_series_query = """
SELECT game_id, team, SUM(goals) AS goals
FROM `maydaystats.nhl_stats.boxscores`
WHERE game_id IN (2025030321, 2025030322, 2025030323, 2025030324)
GROUP BY game_id, team
ORDER BY game_id, team
"""
col_series = client.query(col_series_query).to_dataframe()
col_series = col_series.reset_index(drop=True)
col_series.index += 1
col_series

goalie_query = """
SELECT game_id, team, player_name, save_pctg
FROM `maydaystats.nhl_stats.boxscores`
WHERE game_id IN (2025030321, 2025030322, 2025030323, 2025030324)
  AND position_group = 'goalie'
  AND save_pctg IS NOT NULL
ORDER BY game_id, team
"""
goalies = client.query(goalie_query).to_dataframe()
goalies = goalies.reset_index(drop=True)
goalies.index += 1
goalies

mackinnon_query = """
SELECT COUNT(DISTINCT game_id) AS games, SUM(goals) AS goals,
  SUM(assists) AS assists, SUM(points) AS points
FROM `maydaystats.nhl_stats.boxscores`
WHERE player_name = 'N. MacKinnon' AND team = 'COL'
  AND game_id IN (2025030321, 2025030322, 2025030323, 2025030324)
"""
mackinnon_series = client.query(mackinnon_query).to_dataframe()
mackinnon_series = mackinnon_series.reset_index(drop=True)
mackinnon_series.index += 1
mackinnon_series

final_query = """
WITH final_games AS (
  SELECT game_id, game_date, team, SUM(goals) AS team_goals
  FROM `maydaystats.nhl_stats.boxscores`
  WHERE CAST(SUBSTR(CAST(game_id AS STRING), 5, 2) AS INT64) = 3
    AND team IN ('CAR', 'VGK')
  GROUP BY game_id, game_date, team
)
SELECT
  game_date,
  MAX(IF(team = 'CAR', team_goals, NULL)) AS car_goals,
  MAX(IF(team = 'VGK', team_goals, NULL)) AS vgk_goals
FROM final_games
GROUP BY game_date
HAVING car_goals IS NOT NULL AND vgk_goals IS NOT NULL
ORDER BY game_date
"""

final = client.query(final_query).to_dataframe()
final = final.reset_index(drop=True)
final.index += 1
final

from google.cloud import bigquery

client = bigquery.Client()

# NCAA's API returns team as its own 6-character code (e.g. "PEPPER"), not
# a school name. Tables and charts below keep the raw code as-is (matches
# how the hockey post's chart also uses raw team codes); this mapping is
# only used to spell out real school names in the prose. A code not in
# this dict falls back to showing the raw abbreviation rather than
# failing, in case a future re-render surfaces a school not covered yet.
TEAM_NAMES = {
    "PEPPER": "Pepperdine",
    "UC IRV": "UC Irvine",
    "BALLST": "Ball State",
    "CATAWB": "Catawba",
    "PENNST": "Penn State",
    "MCKEND": "McKendree",
    "EMMAN": "Emmanuel (Ga.)",
    "LEWIS": "Lewis",
    "HAWAII": "Hawaii",
    "UCLA": "UCLA",
    "USC": "USC",
}


def team_name(code):
    return TEAM_NAMES.get(code, code)


query = """
SELECT
  player_name,
  team,
  SUM(CAST(kills AS INT64)) AS kills,
  SUM(CAST(attack_attempts AS INT64)) AS attempts,
  SAFE_DIVIDE(
    SUM(CAST(kills AS INT64)) - SUM(CAST(attack_errors AS INT64)),
    SUM(CAST(attack_attempts AS INT64))
  ) AS hitting_pct,
  COUNT(DISTINCT game_id) AS games
FROM `maydaystats.ncaa_volleyball_men.boxscores`
WHERE player_name != ''
GROUP BY player_name, team
HAVING attempts >= 200
ORDER BY kills DESC
LIMIT 10
"""

leaders = client.query(query).to_dataframe()
leaders = leaders.reset_index(drop=True)
leaders.index += 1
leaders

import matplotlib.pyplot as plt

fig, ax = plt.subplots(figsize=(9, 5))
labels = leaders["player_name"] + " (" + leaders["team"] + ")"
ax.barh(labels[::-1], leaders["kills"][::-1], color="#2c3e50")
ax.set_xlabel("Kills")
ax.set_title("Top 10 Kills Leaders, 2025-26 Men's Season")
ax.spines[["top", "right"]].set_visible(False)
plt.tight_layout()
plt.show()

digs_query = """
SELECT player_name, team, SUM(CAST(digs AS INT64)) AS total
FROM `maydaystats.ncaa_volleyball_men.boxscores`
WHERE player_name != ''
GROUP BY player_name, team
ORDER BY total DESC
LIMIT 1
"""
digs_leader = client.query(digs_query).to_dataframe()

blocks_query = """
SELECT player_name, team, SUM(CAST(total_blocks AS FLOAT64)) AS total
FROM `maydaystats.ncaa_volleyball_men.boxscores`
WHERE player_name != ''
GROUP BY player_name, team
ORDER BY total DESC
LIMIT 1
"""
blocks_leader = client.query(blocks_query).to_dataframe()

aces_query = """
SELECT player_name, team, SUM(CAST(service_aces AS INT64)) AS total
FROM `maydaystats.ncaa_volleyball_men.boxscores`
WHERE player_name != ''
GROUP BY player_name, team
ORDER BY total DESC
LIMIT 1
"""
aces_leader = client.query(aces_query).to_dataframe()

final_query = """
SELECT player_name, team, kills, attack_attempts, hitting_percentage, total_blocks
FROM `maydaystats.ncaa_volleyball_men.boxscores`
WHERE game_id = '6598557'
  AND CAST(kills AS INT64) > 0
ORDER BY team, CAST(kills AS INT64) DESC
"""
final_box = client.query(final_query).to_dataframe()
final_box = final_box.reset_index(drop=True)
final_box.index += 1
final_box

from google.cloud import bigquery

client = bigquery.Client()

# NCAA's API returns team as its own code (e.g. "STFRPA"), not a school
# name. Tables and charts below keep the raw code as-is (matches how the
# hockey post's chart also uses raw team codes); this mapping is only
# used to spell out real school names in the prose. A code not in this
# dict falls back to showing the raw abbreviation rather than failing,
# in case a future re-render surfaces a school not covered yet.
TEAM_NAMES = {
    "MIAMI": "Miami",
    "PITT": "Pittsburgh",
    "PENNST": "Penn State",
    "JMU": "James Madison",
    "WISC": "Wisconsin",
    "STFRPA": "Saint Francis (PA)",
    "PURDUE": "Purdue",
    "SAC ST": "Sacramento State",
    "UK": "Kentucky",
    "TCU": "TCU",
    "UALR": "Little Rock",
    "UT VAL": "Utah Valley",
    "TX A&M": "Texas A&M",
}


def team_name(code):
    return TEAM_NAMES.get(code, code)


query = """
SELECT
  player_name,
  team,
  SUM(CAST(kills AS INT64)) AS kills,
  SUM(CAST(attack_attempts AS INT64)) AS attempts,
  SAFE_DIVIDE(
    SUM(CAST(kills AS INT64)) - SUM(CAST(attack_errors AS INT64)),
    SUM(CAST(attack_attempts AS INT64))
  ) AS hitting_pct,
  COUNT(DISTINCT game_id) AS games
FROM `maydaystats.ncaa_volleyball_women.boxscores`
WHERE player_name != ''
GROUP BY player_name, team
HAVING attempts >= 200
ORDER BY kills DESC
LIMIT 10
"""

leaders = client.query(query).to_dataframe()
leaders = leaders.reset_index(drop=True)
leaders.index += 1
leaders

import matplotlib.pyplot as plt

fig, ax = plt.subplots(figsize=(9, 5))
labels = leaders["player_name"] + " (" + leaders["team"] + ")"
ax.barh(labels[::-1], leaders["kills"][::-1], color="#2c3e50")
ax.set_xlabel("Kills")
ax.set_title("Top 10 Kills Leaders, 2025 Women's Season")
ax.spines[["top", "right"]].set_visible(False)
plt.tight_layout()
plt.show()

digs_query = """
SELECT player_name, team, SUM(CAST(digs AS INT64)) AS total
FROM `maydaystats.ncaa_volleyball_women.boxscores`
WHERE player_name != ''
GROUP BY player_name, team
ORDER BY total DESC
LIMIT 1
"""
digs_leader = client.query(digs_query).to_dataframe()

blocks_query = """
SELECT player_name, team, SUM(CAST(total_blocks AS FLOAT64)) AS total
FROM `maydaystats.ncaa_volleyball_women.boxscores`
WHERE player_name != ''
GROUP BY player_name, team
ORDER BY total DESC
LIMIT 1
"""
blocks_leader = client.query(blocks_query).to_dataframe()

aces_query = """
SELECT player_name, team, SUM(CAST(service_aces AS INT64)) AS total
FROM `maydaystats.ncaa_volleyball_women.boxscores`
WHERE player_name != ''
GROUP BY player_name, team
ORDER BY total DESC
LIMIT 1
"""
aces_leader = client.query(aces_query).to_dataframe()

final_query = """
SELECT player_name, team, kills, attack_attempts, hitting_percentage, digs
FROM `maydaystats.ncaa_volleyball_women.boxscores`
WHERE game_id = '6500718'
  AND CAST(kills AS INT64) > 0
ORDER BY team, CAST(kills AS INT64) DESC
"""
final_box = client.query(final_query).to_dataframe()
final_box = final_box.reset_index(drop=True)
final_box.index += 1
final_box