Code Examples

# Install: pip install nfl_data_py
import nfl_data_py as nfl
import pandas as pd

# Load single season
pbp_2023 = nfl.import_pbp_data([2023])

# Load multiple seasons
pbp_multi = nfl.import_pbp_data([2021, 2022, 2023])

# View structure
print(pbp_2023.info())

# Quick summary
print(f"Total plays: {len(pbp_2023)}")
print(f"Columns: {len(pbp_2023.columns)}")

import nfl_data_py as nfl
import pandas as pd

# Load current rosters
rosters = nfl.import_rosters([2023])

# Load historical rosters
rosters_multi = nfl.import_rosters([2020, 2021, 2022, 2023])

# Filter to specific position
qbs = rosters[rosters["position"] == "QB"][
    ["player_name", "team", "age", "years_exp", "draft_number"]
]

print(qbs.head())

import nfl_data_py as nfl
import pandas as pd

# Load Next Gen Stats - Passing
ngs_passing = nfl.import_ngs_data(
    stat_type="passing",
    years=[2023]
)

# Load Next Gen Stats - Rushing
ngs_rushing = nfl.import_ngs_data(
    stat_type="rushing",
    years=[2023]
)

# Load Next Gen Stats - Receiving
ngs_receiving = nfl.import_ngs_data(
    stat_type="receiving",
    years=[2023]
)

# View top passers by avg air yards (season totals)
season_totals = ngs_passing[ngs_passing["week"] == 0]
top_passers = season_totals.nlargest(10, "avg_air_yards_to_sticks")[
    ["player_display_name", "team_abbr", "avg_air_yards_to_sticks",
     "completion_percentage_above_expectation"]
]
print(top_passers)

import nfl_data_py as nfl
import pandas as pd

# Load combine data
combine = nfl.import_combine_data()

# Filter recent years
combine_recent = combine[combine["draft_year"] >= 2020]

# Top 40-yard dash times by position
top_forty = (combine_recent[combine_recent["forty"].notna()]
    .groupby("pos")
    .apply(lambda x: x.nsmallest(3, "forty"))
    .reset_index(drop=True)
    [["draft_year", "player_name", "pos", "forty", "vertical", "broad_jump"]]
)
print(top_forty)

import nfl_data_py as nfl
import pandas as pd

# Load schedules with results
schedules = nfl.import_schedules([2020, 2021, 2022, 2023])

# Filter to completed games
completed = schedules[schedules["result"].notna()]

# Calculate home win percentage
home_wins = (completed["result"] > 0).sum()
away_wins = (completed["result"] < 0).sum()
ties = (completed["result"] == 0).sum()
home_win_pct = home_wins / len(completed)

print(f"Home Win %: {home_win_pct:.1%}")

# Spread analysis
with_spread = completed[completed["spread_line"].notna()]
with_spread["home_covered"] = with_spread["result"] + with_spread["spread_line"] > 0

print(f"Home Cover Rate: {with_spread['home_covered'].mean():.1%}")
print(f"Avg Spread: {with_spread['spread_line'].mean():.1f}")
print(f"Avg Margin: {with_spread['result'].abs().mean():.1f}")

import nfl_data_py as nfl
import pandas as pd

# Load participation data
participation = nfl.import_participation([2023])

# View structure
print(participation.info())

# Count offensive snaps (simplified)
# Note: participation data structure varies
print(f"Total plays with participation: {len(participation)}")
print(participation.head())

import nfl_data_py as nfl
import pandas as pd

# Load injuries data
injuries = nfl.import_injuries([2023])

# View structure
print(injuries.info())

# Count injuries by status
if "report_status" in injuries.columns:
    status_counts = injuries["report_status"].value_counts()
    print("Injury Status Distribution:")
    print(status_counts)

# Most common injuries
if "report_primary_injury" in injuries.columns:
    injury_types = injuries["report_primary_injury"].value_counts().head(10)
    print("\nMost Common Injuries:")
    print(injury_types)

import nfl_data_py as nfl
import pandas as pd

# Load draft picks
draft = nfl.import_draft_picks()

# Filter to recent years
recent_draft = draft[draft["season"] >= 2020]

# First round picks by position
first_round = recent_draft[recent_draft["round"] == 1]
position_counts = first_round["position"].value_counts()
print("First Round Picks by Position (2020+):")
print(position_counts)

# Top 10 picks
top_picks = recent_draft[recent_draft["pick"] <= 10][
    ["season", "pick", "team", "pfr_player_name", "position"]
].sort_values(["season", "pick"])
print("\nTop 10 Picks:")
print(top_picks)

import nfl_data_py as nfl
import pandas as pd

# Load snap counts
snaps = nfl.import_snap_counts([2023])

# View structure
print(snaps.info())

# Top offensive snap leaders
off_snaps = (snaps.groupby(["player", "position", "team"])
    .agg(
        games=("week", "count"),
        total_off_snaps=("offense_snaps", "sum"),
        avg_off_snaps=("offense_snaps", "mean"),
        avg_off_pct=("offense_pct", "mean")
    )
    .reset_index())

off_snaps = off_snaps[off_snaps["games"] >= 10].sort_values(
    "total_off_snaps", ascending=False)

print("Top Offensive Snap Leaders:")
print(off_snaps.head(20))

import nfl_data_py as nfl
import pandas as pd

# Load schedules
schedules = nfl.import_schedules([2023])

# Filter to completed games
completed = schedules[schedules["result"].notna()]

# Calculate wins for home teams
home_wins = completed.groupby("home_team").apply(
    lambda x: (x["result"] > 0).sum() + (x["result"] == 0).sum() * 0.5
).reset_index(name="home_wins")

# Calculate wins for away teams
away_wins = completed.groupby("away_team").apply(
    lambda x: (x["result"] < 0).sum() + (x["result"] == 0).sum() * 0.5
).reset_index(name="away_wins")

# Combine
wins = home_wins.merge(away_wins, left_on="home_team", right_on="away_team")
wins["total_wins"] = wins["home_wins"] + wins["away_wins"]
wins = wins[["home_team", "total_wins"]].rename(columns={"home_team": "team"})
wins = wins.sort_values("total_wins", ascending=False)

print("Team Win Totals:")
print(wins)

import nfl_data_py as nfl
import pandas as pd

# Load multiple data sources
pbp = nfl.import_pbp_data([2023])
rosters = nfl.import_rosters([2023])

# Get passer stats
passer_stats = (pbp[pbp["passer_player_id"].notna()]
    .groupby(["passer_player_id", "passer_player_name"])
    .agg(
        attempts=("play_id", "count"),
        completions=("complete_pass", "sum"),
        yards=("passing_yards", "sum"),
        tds=("pass_touchdown", "sum"),
        ints=("interception", "sum"),
        epa=("epa", "sum")
    )
    .reset_index())

# Merge with roster data
passer_with_roster = passer_stats.merge(
    rosters[["gsis_id", "player_name", "team", "age", "college"]],
    left_on="passer_player_id",
    right_on="gsis_id",
    how="left"
)

# View combined data
result = (passer_with_roster[passer_with_roster["attempts"] >= 100]
    .sort_values("epa", ascending=False)
    [["passer_player_name", "team", "age", "college", "attempts", "yards", "tds", "epa"]])
print(result)

import nfl_data_py as nfl
import pandas as pd

# Load QBR data
qbr = nfl.import_qbr([2023])

# View structure
print(qbr.info())

# Top QBs by QBR (if available)
if "qbr_total" in qbr.columns:
    top_qbr = qbr.nlargest(15, "qbr_total")[
        ["name_display", "team_abb", "qbr_total", "pts_added", "pass_rating"]
    ]
    print("Top QBs by Total QBR:")
    print(top_qbr)
else:
    print("Available columns:", qbr.columns.tolist())
    print(qbr.head())

import nfl_data_py as nfl
import pandas as pd

# Load data
pbp = nfl.import_pbp_data([2023])

# Filter to pass and rush plays
plays = pbp[(pbp["epa"].notna()) &
            (pbp["play_type"].isin(["pass", "run"]))]

# Calculate offensive EPA/play
offense_epa = (plays.groupby("posteam")
    .agg(
        plays=("epa", "count"),
        total_epa=("epa", "sum"),
        epa_per_play=("epa", "mean"),
        success_rate=("success", "mean")
    )
    .sort_values("epa_per_play", ascending=False)
    .reset_index())

# Calculate defensive EPA/play
defense_epa = (plays.groupby("defteam")
    .agg(epa_allowed=("epa", "mean"))
    .sort_values("epa_allowed")
    .reset_index())

print("Offensive EPA/Play:")
print(offense_epa.head(10))
print("\nDefensive EPA/Play:")
print(defense_epa.head(10))

import nfl_data_py as nfl
import pandas as pd

pbp = nfl.import_pbp_data([2023])

# Filter to pass plays with QB identified
pass_plays = pbp[(pbp["epa"].notna()) &
                 (pbp["passer_player_id"].notna())]

# QB EPA analysis
qb_epa = (pass_plays.groupby(["passer_player_id", "passer_player_name"])
    .agg(
        dropbacks=("epa", "count"),
        total_epa=("epa", "sum"),
        epa_per_dropback=("epa", "mean"),
        cpoe=("cpoe", "mean"),
        success_rate=("success", "mean"),
        avg_air_yards=("air_yards", "mean")
    )
    .reset_index())

# Filter min dropbacks and rank
qb_epa = (qb_epa[qb_epa["dropbacks"] >= 200]
    .sort_values("epa_per_dropback", ascending=False)
    .reset_index(drop=True))
qb_epa["rank"] = range(1, len(qb_epa) + 1)

print(qb_epa.head(20))

import nfl_data_py as nfl
import pandas as pd
import numpy as np

pbp = nfl.import_pbp_data([2023])

# EPA by down
plays = pbp[(pbp["epa"].notna()) & (pbp["down"] <= 4)]
epa_by_down = (plays.groupby("down")
    .agg(
        plays=("epa", "count"),
        avg_epa=("epa", "mean"),
        success_rate=("success", "mean")
    )
    .reset_index())
print("EPA by Down:")
print(epa_by_down)

# EPA by field position
def get_field_zone(yard):
    if yard >= 80: return "Own 1-20"
    elif yard >= 60: return "Own 21-40"
    elif yard >= 40: return "Midfield"
    elif yard >= 20: return "Opp 21-40"
    else: return "Red Zone"

plays["field_zone"] = plays["yardline_100"].apply(get_field_zone)
epa_by_field = (plays.groupby("field_zone")
    .agg(
        plays=("epa", "count"),
        avg_epa=("epa", "mean"),
        td_rate=("touchdown", "mean")
    )
    .reset_index())
print("\nEPA by Field Position:")
print(epa_by_field)

import nfl_data_py as nfl
import pandas as pd

pbp = nfl.import_pbp_data([2023])

# Game-level EPA
game_epa = (pbp[pbp["epa"].notna()]
    .groupby(["game_id", "posteam", "week"])
    .agg(epa_per_play=("epa", "mean"))
    .reset_index())

# Calculate 4-game rolling average
game_epa = game_epa.sort_values(["posteam", "week"])
game_epa["rolling_4_epa"] = (game_epa.groupby("posteam")
    ["epa_per_play"].transform(lambda x: x.rolling(4).mean()))

# Find teams that improved most
early = game_epa[game_epa["week"] == 5][["posteam", "rolling_4_epa"]]
late = game_epa[game_epa["week"] == 17][["posteam", "rolling_4_epa"]]

improvement = early.merge(late, on="posteam", suffixes=("_early", "_late"))
improvement["change"] = improvement["rolling_4_epa_late"] - improvement["rolling_4_epa_early"]
improvement = improvement.sort_values("change", ascending=False)

print(improvement)

import nfl_data_py as nfl
import pandas as pd

pbp = nfl.import_pbp_data([2023])

# Filter valid plays
plays = pbp[(pbp["epa"].notna()) &
            (pbp["play_type"].isin(["pass", "run"])) &
            (pbp["qtr"] <= 4)]

# EPA by quarter and play type
epa_by_qtr = (plays.groupby(["qtr", "play_type"])
    .agg(
        plays=("epa", "count"),
        avg_epa=("epa", "mean"),
        success_rate=("success", "mean")
    )
    .reset_index())

print("EPA by Quarter and Play Type:")
print(epa_by_qtr)

# Pass vs Run comparison
pivot = epa_by_qtr.pivot(index="qtr", columns="play_type", values="avg_epa")
pivot["pass_advantage"] = pivot["pass"] - pivot["run"]
print("\nPass EPA Advantage by Quarter:")
print(pivot)

import nfl_data_py as nfl
import pandas as pd

pbp = nfl.import_pbp_data([2023])

# Red zone plays (inside opponent 20)
red_zone = pbp[(pbp["epa"].notna()) &
               (pbp["yardline_100"] <= 20) &
               (pbp["play_type"].isin(["pass", "run"]))]

# Team red zone efficiency
team_rz = (red_zone.groupby("posteam")
    .agg(
        rz_plays=("epa", "count"),
        rz_epa=("epa", "mean"),
        rz_td_rate=("touchdown", "mean"),
        rz_success_rate=("success", "mean")
    )
    .reset_index()
    .sort_values("rz_td_rate", ascending=False))

print("Team Red Zone Efficiency:")
print(team_rz)

# Red zone vs outside comparison
outside_rz = pbp[(pbp["epa"].notna()) & (pbp["yardline_100"] > 20)]
print(f"\nRed Zone EPA: {red_zone['epa'].mean():.3f}")
print(f"Outside RZ EPA: {outside_rz['epa'].mean():.3f}")

import nfl_data_py as nfl
import pandas as pd
import numpy as np

pbp = nfl.import_pbp_data([2023])

# Third down plays
third_down = pbp[(pbp["epa"].notna()) & (pbp["down"] == 3)]

# Distance buckets
def dist_bucket(ydstogo):
    if ydstogo <= 3: return "Short (1-3)"
    elif ydstogo <= 6: return "Medium (4-6)"
    elif ydstogo <= 10: return "Long (7-10)"
    else: return "Very Long (11+)"

third_down["dist_bucket"] = third_down["ydstogo"].apply(dist_bucket)

# Analysis by distance
third_by_dist = (third_down.groupby("dist_bucket")
    .agg(
        attempts=("epa", "count"),
        conversion_rate=("first_down", "mean"),
        avg_epa=("epa", "mean")
    )
    .reset_index())

print("Third Down by Distance:")
print(third_by_dist)

# Team rankings
team_3rd = (third_down.groupby("posteam")
    .agg(
        attempts=("epa", "count"),
        conv_rate=("first_down", "mean"),
        epa_per_play=("epa", "mean")
    )
    .reset_index()
    .sort_values("conv_rate", ascending=False))

print("\nTeam Third Down Rankings:")
print(team_3rd.head(10))

import nfl_data_py as nfl
import pandas as pd

pbp = nfl.import_pbp_data([2023])

# Filter valid plays
plays = pbp[pbp["epa"].notna()].copy()

# Define garbage time
plays["garbage_time"] = (
    ((plays["qtr"] == 4) & ((plays["wp"] < 0.10) | (plays["wp"] > 0.90))) |
    ((plays["qtr"] == 4) & (plays["score_differential"].abs() > 21))
)

# Compare with and without garbage time
plays_filtered = plays[plays["play_type"].isin(["pass", "run"])]

# EPA without garbage time
clean_epa = (plays_filtered[~plays_filtered["garbage_time"]]
    .groupby("posteam")["epa"].mean())

# EPA with garbage time
all_epa = plays_filtered.groupby("posteam")["epa"].mean()

# Compare
comparison = pd.DataFrame({
    "clean_epa": clean_epa,
    "all_epa": all_epa
})
comparison["garbage_inflation"] = comparison["all_epa"] - comparison["clean_epa"]
comparison = comparison.sort_values("garbage_inflation", ascending=False)

print("Garbage Time EPA Inflation:")
print(comparison.head(10))

import nfl_data_py as nfl
import pandas as pd

# Load two consecutive seasons
pbp_2022 = nfl.import_pbp_data([2022])
pbp_2023 = nfl.import_pbp_data([2023])

def get_team_epa(pbp):
    plays = pbp[(pbp["epa"].notna()) &
                (pbp["play_type"].isin(["pass", "run"]))]
    return plays.groupby("posteam")["epa"].mean()

epa_2022 = get_team_epa(pbp_2022)
epa_2023 = get_team_epa(pbp_2023)

# Combine
combined = pd.DataFrame({
    "epa_2022": epa_2022,
    "epa_2023": epa_2023
}).dropna()

# Calculate correlation
correlation = combined["epa_2022"].corr(combined["epa_2023"])
print(f"Year-over-Year EPA Correlation: {correlation:.3f}")

# Show biggest changes
combined["change"] = combined["epa_2023"] - combined["epa_2022"]
print("\nBiggest Improvements:")
print(combined.nlargest(5, "change"))
print("\nBiggest Declines:")
print(combined.nsmallest(5, "change"))

import nfl_data_py as nfl
import pandas as pd

pbp = nfl.import_pbp_data([2023])

# Filter valid plays
plays = pbp[(pbp["epa"].notna()) &
            (pbp["play_type"].isin(["pass", "run"]))].copy()

# Define explosive plays
plays["explosive"] = plays["yards_gained"] >= 20

# Team explosive play analysis
team_explosive = (plays.groupby("posteam")
    .agg(
        total_plays=("epa", "count"),
        explosive_plays=("explosive", "sum"),
        total_epa=("epa", "sum")
    )
    .reset_index())

team_explosive["explosive_rate"] = (team_explosive["explosive_plays"] /
                                     team_explosive["total_plays"] * 100)
team_explosive = team_explosive.sort_values("explosive_rate", ascending=False)

print("Team Explosive Play Rates:")
print(team_explosive)

# EPA comparison
explosive_epa = plays[plays["explosive"]]["epa"].mean()
non_explosive_epa = plays[~plays["explosive"]]["epa"].mean()
print(f"\nAverage EPA on explosive plays: {explosive_epa:.3f}")
print(f"Average EPA on non-explosive plays: {non_explosive_epa:.3f}")

import nfl_data_py as nfl
import pandas as pd

pbp = nfl.import_pbp_data([2023])

# Win probability columns: wp, vegas_wp, home_wp, away_wp
# View key WP columns
wp_cols = ["game_id", "qtr", "time", "posteam", "wp", "wpa"]
key_plays = pbp[pbp["wp"].notna()][wp_cols].head(20)
print("Sample Win Probability Data:")
print(key_plays)

# Average WP by score differential
wp_by_score = (pbp[pbp["wp"].notna() & pbp["score_differential"].notna()]
    .groupby("score_differential")
    .agg(avg_wp=("wp", "mean"), plays=("wp", "count"))
    .reset_index())

wp_by_score = wp_by_score[
    (wp_by_score["plays"] >= 100) &
    (wp_by_score["score_differential"].abs() <= 21)
]
print("\nAverage WP by Score Differential:")
print(wp_by_score)

import nfl_data_py as nfl
import pandas as pd

pbp = nfl.import_pbp_data([2023])

# QB WPA leaders
qb_plays = pbp[pbp["wpa"].notna() & pbp["passer_player_id"].notna()]
qb_wpa = (qb_plays.groupby(["passer_player_id", "passer_player_name"])
    .agg(
        dropbacks=("wpa", "count"),
        total_wpa=("wpa", "sum"),
        positive_plays=("wpa", lambda x: (x > 0).sum()),
        negative_plays=("wpa", lambda x: (x < 0).sum())
    )
    .reset_index())

qb_wpa = qb_wpa[qb_wpa["dropbacks"] >= 200].sort_values("total_wpa", ascending=False)
print("QB WPA Leaders:")
print(qb_wpa)

# Biggest WPA plays
biggest_plays = (pbp[pbp["wpa"].notna()]
    .assign(abs_wpa=lambda x: x["wpa"].abs())
    .nlargest(10, "abs_wpa")
    [["game_id", "posteam", "qtr", "desc", "wpa"]])
print("\nBiggest WPA Plays:")
print(biggest_plays)

import nfl_data_py as nfl
import pandas as pd

pbp = nfl.import_pbp_data([2023])

# Define clutch situations
clutch_plays = pbp[
    (pbp["epa"].notna()) &
    (pbp["qtr"] == 4) &
    (pbp["wp"] >= 0.25) &
    (pbp["wp"] <= 0.75)
]

# QB clutch performance
qb_clutch = (clutch_plays[clutch_plays["passer_player_id"].notna()]
    .groupby(["passer_player_id", "passer_player_name"])
    .agg(
        clutch_plays=("epa", "count"),
        clutch_epa=("epa", "sum"),
        clutch_wpa=("wpa", "sum"),
        clutch_success=("success", "mean")
    )
    .reset_index())

qb_clutch = qb_clutch[qb_clutch["clutch_plays"] >= 30].sort_values(
    "clutch_wpa", ascending=False)

print("QB Clutch Performance (4Q, WP 25-75%):")
print(qb_clutch)

import nfl_data_py as nfl
import pandas as pd

pbp = nfl.import_pbp_data([2023])

# Find biggest swing plays
swing_plays = pbp[pbp["wpa"].notna()].copy()
swing_plays["abs_wpa"] = swing_plays["wpa"].abs()
swing_plays = swing_plays.nlargest(50, "abs_wpa")[
    ["game_id", "week", "posteam", "qtr", "time", "down",
     "ydstogo", "desc", "wpa", "wp"]
]

print("Biggest Swing Plays:")
print(swing_plays.head(20))

# Game-changing interceptions
ints = (pbp[(pbp["interception"] == 1) & (pbp["wpa"].notna())]
    .assign(abs_wpa=lambda x: x["wpa"].abs())
    .nlargest(10, "abs_wpa")
    [["game_id", "passer_player_name", "interception_player_name", "wpa", "wp"]])

print("\nBiggest Interceptions by WPA:")
print(ints)

import nfl_data_py as nfl
import pandas as pd

pbp = nfl.import_pbp_data([2023])

# Filter to 4th quarter plays
q4 = pbp[pbp["qtr"] == 4].copy()

# Get start and end WP for each game
game_wp = (q4.groupby(["game_id", "home_team", "away_team"])
    .agg(
        start_wp_home=("home_wp", "first"),
        end_wp_home=("home_wp", "last"),
        home_score=("total_home_score", "last"),
        away_score=("total_away_score", "last")
    )
    .reset_index())

game_wp["home_won"] = game_wp["home_score"] > game_wp["away_score"]
game_wp["comeback"] = (
    ((game_wp["start_wp_home"] < 0.25) & game_wp["home_won"]) |
    ((game_wp["start_wp_home"] > 0.75) & ~game_wp["home_won"])
)
game_wp["wp_swing"] = (game_wp["end_wp_home"] - game_wp["start_wp_home"]).abs()

comebacks = game_wp[game_wp["comeback"]].sort_values("wp_swing", ascending=False)
print("4th Quarter Comebacks:")
print(comebacks)

import nfl_data_py as nfl
import pandas as pd
import matplotlib.pyplot as plt

pbp = nfl.import_pbp_data([2023])

# Select a specific game
game = pbp[(pbp["week"] == 1) & (pbp["home_team"] == "KC")]
game = game[game["wp"].notna()].copy()

# Calculate game time and home WP
game["game_time"] = 3600 - game["game_seconds_remaining"]
game["home_wp"] = game.apply(
    lambda x: x["wp"] if x["posteam"] == x["home_team"] else 1 - x["wp"],
    axis=1
)

# Create plot
fig, ax = plt.subplots(figsize=(12, 6))
ax.plot(game["game_time"], game["home_wp"], color="#E31837", linewidth=2)
ax.axhline(y=0.5, color="gray", linestyle="--", alpha=0.5)

ax.set_xlim(0, 3600)
ax.set_ylim(0, 1)
ax.set_xticks([0, 900, 1800, 2700, 3600])
ax.set_xticklabels(["Q1", "Q2", "Q3", "Q4", "End"])
ax.set_ylabel("Home Win Probability")
ax.set_title(f"{game['away_team'].iloc[0]} @ {game['home_team'].iloc[0]}")

plt.tight_layout()
plt.savefig("wp_chart.png", dpi=300)
plt.show()

import nfl_data_py as nfl
import pandas as pd
import numpy as np

pbp = nfl.import_pbp_data([2023])

# Filter plays with both EPA and WPA
plays = pbp[(pbp["epa"].notna()) & (pbp["wpa"].notna())]

# Overall correlation
correlation = plays["epa"].corr(plays["wpa"])
print(f"EPA vs WPA Correlation: {correlation:.3f}")

# By game situation
def get_situation(row):
    if row["qtr"] <= 2:
        return "First Half"
    elif row["wp"] > 0.75 or row["wp"] < 0.25:
        return "Blowout"
    else:
        return "Competitive"

plays["situation"] = plays.apply(get_situation, axis=1)

situation_comparison = (plays.groupby("situation")
    .agg(
        plays=("epa", "count"),
        avg_epa=("epa", "mean"),
        avg_wpa=("wpa", "mean")
    )
    .reset_index())

print("\nEPA vs WPA by Situation:")
print(situation_comparison)

import nfl_data_py as nfl
import pandas as pd

pbp = nfl.import_pbp_data([2023])

# Fourth down decisions in close 4th quarter games
late_4th = pbp[
    (pbp["down"] == 4) &
    (pbp["qtr"] == 4) &
    (pbp["wp"] >= 0.20) &
    (pbp["wp"] <= 0.80) &
    (pbp["fourth_down_decision"].notna())
]

# Decision distribution
print("4th Down Decision Distribution:")
print(late_4th["fourth_down_decision"].value_counts())

# WP impact by decision
decision_impact = (late_4th.groupby("fourth_down_decision")
    .agg(
        attempts=("wpa", "count"),
        avg_wpa=("wpa", "mean"),
        avg_wp_before=("wp", "mean")
    )
    .reset_index())

print("\nDecision Impact:")
print(decision_impact)

# Team aggressiveness
team_decisions = (late_4th.groupby("posteam")
    .agg(fourth_downs=("down", "count"))
    .reset_index())

go_counts = late_4th[late_4th["fourth_down_decision"] == "go"].groupby("posteam").size()
team_decisions = team_decisions.merge(
    go_counts.reset_index(name="go_for_it"),
    on="posteam", how="left"
).fillna(0)
team_decisions["go_rate"] = team_decisions["go_for_it"] / team_decisions["fourth_downs"]

print("\nTeam Aggressiveness:")
print(team_decisions.sort_values("go_rate", ascending=False))

import nfl_data_py as nfl
import pandas as pd
import matplotlib.pyplot as plt
import numpy as np

pbp = nfl.import_pbp_data([2023])

# Calculate team EPA
plays = pbp[(pbp["epa"].notna()) &
            (pbp["play_type"].isin(["pass", "run"]))]

off_epa = plays.groupby("posteam")["epa"].mean().reset_index()
off_epa.columns = ["team", "off_epa"]

def_epa = plays.groupby("defteam")["epa"].mean().reset_index()
def_epa.columns = ["team", "def_epa"]

team_epa = off_epa.merge(def_epa, on="team")

# Create scatter plot
fig, ax = plt.subplots(figsize=(12, 10))

ax.scatter(team_epa["off_epa"], team_epa["def_epa"], s=100, alpha=0.7)

# Add team labels
for idx, row in team_epa.iterrows():
    ax.annotate(row["team"], (row["off_epa"], row["def_epa"]),
                fontsize=9, ha="center", va="bottom")

# Add mean lines
ax.axhline(y=team_epa["def_epa"].mean(), color="gray",
           linestyle="--", alpha=0.5)
ax.axvline(x=team_epa["off_epa"].mean(), color="gray",
           linestyle="--", alpha=0.5)

ax.set_xlabel("Offensive EPA/Play (higher is better)", fontsize=12)
ax.set_ylabel("Defensive EPA/Play (lower is better)", fontsize=12)
ax.set_title("NFL Team Efficiency (2023)", fontsize=16, fontweight="bold")
ax.invert_yaxis()  # Lower def EPA is better

plt.tight_layout()
plt.savefig("epa_scatter.png", dpi=300)
plt.show()

import nfl_data_py as nfl
import pandas as pd
import matplotlib.pyplot as plt

pbp = nfl.import_pbp_data([2023])

# Get weekly EPA for specific teams
teams = ["KC", "SF", "BAL", "DET"]
team_colors = {"KC": "#E31837", "SF": "#AA0000",
               "BAL": "#241773", "DET": "#0076B6"}

plays = pbp[(pbp["epa"].notna()) & (pbp["posteam"].isin(teams))]
weekly_epa = plays.groupby(["posteam", "week"])["epa"].mean().reset_index()

# Create line chart
fig, ax = plt.subplots(figsize=(12, 6))

for team in teams:
    team_data = weekly_epa[weekly_epa["posteam"] == team]
    ax.plot(team_data["week"], team_data["epa"],
            color=team_colors[team], label=team,
            linewidth=2, marker="o", markersize=5)

ax.axhline(y=0, color="gray", linestyle="--", alpha=0.5)
ax.set_xlabel("Week", fontsize=12)
ax.set_ylabel("EPA/Play", fontsize=12)
ax.set_title("Weekly EPA/Play Trends (2023)", fontsize=14, fontweight="bold")
ax.legend(loc="lower right")

plt.tight_layout()
plt.savefig("weekly_epa.png", dpi=300)
plt.show()

import nfl_data_py as nfl
import pandas as pd
import matplotlib.pyplot as plt

pbp = nfl.import_pbp_data([2023])

# Get pass data for a specific QB
qb_passes = pbp[
    (pbp["passer_player_name"] == "P.Mahomes") &
    (pbp["air_yards"].notna()) &
    (pbp["pass_location"].notna())
].copy()

# Map pass location to x coordinate
location_map = {"left": -10, "middle": 0, "right": 10}
qb_passes["x"] = qb_passes["pass_location"].map(location_map)
qb_passes["y"] = qb_passes["air_yards"]

# Determine result
def get_result(row):
    if row["interception"] == 1: return "INT"
    elif row["complete_pass"] == 1: return "Complete"
    else: return "Incomplete"

qb_passes["result"] = qb_passes.apply(get_result, axis=1)

# Create pass chart
fig, ax = plt.subplots(figsize=(8, 10))

colors = {"Complete": "#00AA00", "Incomplete": "#AA0000", "INT": "#000000"}
for result, color in colors.items():
    data = qb_passes[qb_passes["result"] == result]
    ax.scatter(data["x"], data["y"], c=color, label=result,
               alpha=0.6, s=30)

ax.axhline(y=0, color="darkgreen", linewidth=3)
ax.set_xlim(-20, 20)
ax.set_ylim(-5, 40)
ax.set_xlabel("Field Width")
ax.set_ylabel("Air Yards")
ax.set_title("Patrick Mahomes Pass Chart (2023)", fontweight="bold")
ax.legend()

plt.tight_layout()
plt.savefig("pass_chart.png", dpi=300)
plt.show()

import nfl_data_py as nfl
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
import numpy as np

pbp = nfl.import_pbp_data([2023])

# Filter valid plays
plays = pbp[(pbp["epa"].notna()) & (pbp["down"] <= 4) & (pbp["ydstogo"].notna())]

# Create distance buckets
def distance_bucket(yd):
    if yd <= 3: return "1-3"
    elif yd <= 6: return "4-6"
    elif yd <= 10: return "7-10"
    else: return "10+"

plays["distance_bucket"] = plays["ydstogo"].apply(distance_bucket)

# Calculate EPA by down and distance
heatmap_data = plays.groupby(["down", "distance_bucket"])["epa"].mean().reset_index()
pivot_data = heatmap_data.pivot(index="down", columns="distance_bucket", values="epa")

# Reorder columns
col_order = ["1-3", "4-6", "7-10", "10+"]
pivot_data = pivot_data[[c for c in col_order if c in pivot_data.columns]]

# Create heatmap
fig, ax = plt.subplots(figsize=(10, 6))
sns.heatmap(pivot_data, annot=True, fmt=".3f", cmap="RdYlGn", center=0,
            linewidths=0.5, ax=ax, cbar_kws={"label": "EPA/Play"})

ax.set_xlabel("Yards to Go")
ax.set_ylabel("Down")
ax.set_title("EPA by Down and Distance (2023)", fontweight="bold")

plt.tight_layout()
plt.savefig("epa_heatmap.png", dpi=300)
plt.show()

import nfl_data_py as nfl
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from math import pi

pbp = nfl.import_pbp_data([2023])

# Calculate QB metrics
passes = pbp[(pbp["passer_player_id"].notna()) & (pbp["play_type"] == "pass")]

qb_metrics = (passes.groupby("passer_player_name")
    .agg(
        attempts=("play_id", "count"),
        epa_play=("epa", "mean"),
        cpoe=("cpoe", "mean"),
        avg_air=("air_yards", "mean"),
        deep_pct=("air_yards", lambda x: (x >= 20).mean() * 100),
        sack_rate=("sack", "mean")
    )
    .reset_index())

qb_metrics = qb_metrics[qb_metrics["attempts"] >= 300]

# Normalize to 0-100
def normalize(col):
    return (col - col.min()) / (col.max() - col.min()) * 100

for col in ["epa_play", "cpoe", "avg_air", "deep_pct"]:
    qb_metrics[col + "_norm"] = normalize(qb_metrics[col])

# Invert sack rate (lower is better)
qb_metrics["sack_norm"] = 100 - normalize(qb_metrics["sack_rate"] * 100)

# Create radar chart for top QBs
categories = ["EPA/Play", "CPOE", "Air Yards", "Deep%", "Sack Avoidance"]
qbs = ["P.Mahomes", "J.Allen", "L.Jackson"]

fig, ax = plt.subplots(figsize=(8, 8), subplot_kw=dict(polar=True))
angles = [n / float(len(categories)) * 2 * pi for n in range(len(categories))]
angles += angles[:1]

for qb in qbs:
    data = qb_metrics[qb_metrics["passer_player_name"] == qb]
    if not data.empty:
        values = [data["epa_play_norm"].iloc[0], data["cpoe_norm"].iloc[0],
                  data["avg_air_norm"].iloc[0], data["deep_pct_norm"].iloc[0],
                  data["sack_norm"].iloc[0]]
        values += values[:1]
        ax.plot(angles, values, linewidth=2, label=qb)
        ax.fill(angles, values, alpha=0.1)

ax.set_xticks(angles[:-1])
ax.set_xticklabels(categories)
ax.set_title("QB Comparison Radar Chart", fontweight="bold")
ax.legend(loc="upper right", bbox_to_anchor=(1.3, 1.0))
plt.tight_layout()
plt.savefig("qb_radar.png", dpi=300)
plt.show()

import nfl_data_py as nfl
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns

pbp = nfl.import_pbp_data([2023])

# Filter plays with EPA
plays = pbp[(pbp["epa"].notna()) & (pbp["play_type"].isin(["pass", "run"]))]

# Create box plot by play type
fig, axes = plt.subplots(1, 2, figsize=(14, 6))

# Plot 1: By play type
sns.boxplot(data=plays, x="play_type", y="epa", ax=axes[0],
            palette={"pass": "#1E90FF", "run": "#228B22"},
            showfliers=False)
axes[0].set_ylim(-3, 3)
axes[0].set_xlabel("Play Type")
axes[0].set_ylabel("EPA")
axes[0].set_title("EPA Distribution by Play Type (2023)")

# Plot 2: By down
plays_by_down = plays[(plays["down"].notna()) & (plays["down"] <= 4)]
sns.boxplot(data=plays_by_down, x="down", y="epa", ax=axes[1],
            palette="viridis", showfliers=False)
axes[1].set_ylim(-2, 2)
axes[1].set_xlabel("Down")
axes[1].set_ylabel("EPA")
axes[1].set_title("EPA Distribution by Down (2023)")

plt.tight_layout()
plt.savefig("epa_boxplots.png", dpi=300)
plt.show()

import nfl_data_py as nfl
import pandas as pd
import plotly.express as px
import plotly.graph_objects as go

pbp = nfl.import_pbp_data([2023])

# Calculate team stats
plays = pbp[(pbp["epa"].notna()) & (pbp["play_type"].isin(["pass", "run"]))]

off_stats = (plays.groupby("posteam")
    .agg(
        off_epa=("epa", "mean"),
        pass_rate=("play_type", lambda x: (x == "pass").mean() * 100),
        plays=("epa", "count")
    )
    .reset_index())

def_stats = (plays.groupby("defteam")
    .agg(def_epa=("epa", "mean"))
    .reset_index())

team_stats = off_stats.merge(def_stats, left_on="posteam", right_on="defteam")

# Create interactive scatter with Plotly
fig = px.scatter(
    team_stats,
    x="off_epa",
    y="def_epa",
    text="posteam",
    hover_data={"off_epa": ":.3f", "def_epa": ":.3f", "pass_rate": ":.1f"},
    title="NFL Team Efficiency (2023)"
)

fig.update_traces(textposition="top center", marker=dict(size=12))
fig.update_yaxes(autorange="reversed")  # Lower def EPA is better
fig.update_layout(
    xaxis_title="Offensive EPA/Play (higher is better)",
    yaxis_title="Defensive EPA/Play (lower is better)"
)

fig.write_html("team_efficiency.html")
fig.show()

import nfl_data_py as nfl
import pandas as pd
import matplotlib.pyplot as plt

pbp = nfl.import_pbp_data([2023])

# EPA histogram by play type
plays = pbp[(pbp["epa"].notna()) & (pbp["play_type"].isin(["pass", "run"]))]

fig, axes = plt.subplots(1, 2, figsize=(14, 5))

# Plot 1: EPA distribution
for play_type, color in [("pass", "#1E90FF"), ("run", "#228B22")]:
    data = plays[plays["play_type"] == play_type]["epa"]
    axes[0].hist(data, bins=50, alpha=0.6, color=color, label=play_type.capitalize())

axes[0].axvline(x=0, color="black", linestyle="--")
axes[0].set_xlim(-5, 5)
axes[0].set_xlabel("EPA")
axes[0].set_ylabel("Count")
axes[0].set_title("Distribution of EPA by Play Type (2023)")
axes[0].legend()

# Plot 2: Air yards distribution
air_data = pbp[(pbp["air_yards"].notna()) & (pbp["play_type"] == "pass")]
axes[1].hist(air_data["air_yards"], bins=40, color="#1E90FF", alpha=0.7)
mean_air = air_data["air_yards"].mean()
axes[1].axvline(x=mean_air, color="red", linestyle="--", label=f"Mean: {mean_air:.1f}")
axes[1].set_xlabel("Air Yards")
axes[1].set_ylabel("Count")
axes[1].set_title("Distribution of Air Yards (2023)")
axes[1].legend()

plt.tight_layout()
plt.savefig("histograms.png", dpi=300)
plt.show()

import nfl_data_py as nfl
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
import numpy as np

pbp = nfl.import_pbp_data([2023])

# Calculate team metrics
plays = pbp[(pbp["epa"].notna()) & (pbp["play_type"].isin(["pass", "run"]))]

def calculate_metrics(group):
    return pd.Series({
        "off_epa": group["epa"].mean(),
        "pass_rate": (group["play_type"] == "pass").mean() * 100,
        "pass_epa": group[group["play_type"] == "pass"]["epa"].mean(),
        "run_epa": group[group["play_type"] == "run"]["epa"].mean(),
        "success_rate": group["success"].mean() * 100,
        "explosive_rate": (group["epa"] > 2).mean() * 100
    })

team_metrics = plays.groupby("posteam").apply(calculate_metrics).reset_index()

# Calculate correlation matrix
metrics_only = team_metrics.drop("posteam", axis=1)
cor_matrix = metrics_only.corr()

# Create heatmap
fig, ax = plt.subplots(figsize=(10, 8))
mask = np.triu(np.ones_like(cor_matrix, dtype=bool))

sns.heatmap(cor_matrix, mask=mask, annot=True, fmt=".2f",
            cmap="coolwarm", center=0, square=True,
            linewidths=0.5, ax=ax)

ax.set_title("Team Offensive Metrics Correlation", fontweight="bold")
plt.tight_layout()
plt.savefig("correlation_matrix.png", dpi=300)
plt.show()

import nfl_data_py as nfl
import pandas as pd
import matplotlib.pyplot as plt

pbp = nfl.import_pbp_data([2023])

# Calculate rolling EPA for SF
sf_plays = pbp[(pbp["posteam"] == "SF") &
               (pbp["epa"].notna()) &
               (pbp["play_type"].isin(["pass", "run"]))].copy()

sf_plays = sf_plays.sort_values(["game_id", "play_id"])
sf_plays["play_num"] = range(1, len(sf_plays) + 1)
sf_plays["rolling_epa"] = sf_plays["epa"].rolling(window=50).mean()

# Get key week markers
key_weeks = [1, 8, 18]
annotations = []
for week in key_weeks:
    week_data = sf_plays[sf_plays["week"] == week]
    if not week_data.empty:
        annotations.append({
            "week": week,
            "play_num": week_data["play_num"].max(),
            "rolling_epa": week_data["rolling_epa"].dropna().iloc[-1] if not week_data["rolling_epa"].dropna().empty else 0
        })

# Create plot
fig, ax = plt.subplots(figsize=(12, 6))

ax.plot(sf_plays["play_num"], sf_plays["rolling_epa"],
        color="#AA0000", linewidth=1.5, label="Rolling EPA")
ax.axhline(y=0, color="gray", linestyle="--", alpha=0.7)

# Add annotations
for ann in annotations:
    ax.scatter(ann["play_num"], ann["rolling_epa"], color="black", s=50, zorder=5)
    ax.annotate(f"Week {ann[\"week\"]}", (ann["play_num"], ann["rolling_epa"]),
                textcoords="offset points", xytext=(0, 10), ha="center")

ax.set_xlabel("Play Number")
ax.set_ylabel("Rolling EPA/Play (50-play average)")
ax.set_title("San Francisco 49ers - Rolling EPA/Play (2023)", fontweight="bold")

plt.tight_layout()
plt.savefig("rolling_epa.png", dpi=300)
plt.show()

import nfl_data_py as nfl
import pandas as pd
import matplotlib.pyplot as plt
import numpy as np

pbp = nfl.import_pbp_data([2023])

# Get drive starting positions and outcomes
drives = pbp[(pbp["drive"].notna()) & (pbp["yardline_100"].notna())]

drive_summary = (drives.groupby(["game_id", "drive"])
    .agg(
        start_yard=("yardline_100", "first"),
        result=("fixed_drive_result", "last")
    )
    .reset_index())

drive_summary = drive_summary[drive_summary["result"].notna()]

# Assign field zones
def get_zone(yard):
    if yard >= 80: return "Own 0-20"
    elif yard >= 60: return "Own 20-40"
    elif yard >= 40: return "Midfield"
    elif yard >= 20: return "Opp 20-40"
    else: return "Red Zone"

drive_summary["zone"] = drive_summary["start_yard"].apply(get_zone)
drive_summary["scored"] = drive_summary["result"] == "Touchdown"

# Calculate TD rate by zone
zone_stats = (drive_summary.groupby("zone")
    .agg(
        drives=("scored", "count"),
        tds=("scored", "sum"),
        td_rate=("scored", "mean")
    )
    .reset_index())

zone_stats["td_rate_pct"] = zone_stats["td_rate"] * 100
zone_stats = zone_stats.sort_values("td_rate_pct", ascending=False)

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

colors = plt.cm.RdYlGn(zone_stats["td_rate"])
bars = ax.bar(zone_stats["zone"], zone_stats["td_rate_pct"], color=colors)

for bar, rate in zip(bars, zone_stats["td_rate_pct"]):
    ax.text(bar.get_x() + bar.get_width()/2, bar.get_height() + 0.5,
            f"{rate:.1f}%", ha="center", va="bottom")

ax.set_xlabel("Starting Field Position")
ax.set_ylabel("TD Rate (%)")
ax.set_title("Touchdown Rate by Starting Field Position", fontweight="bold")

plt.tight_layout()
plt.savefig("field_position.png", dpi=300)
plt.show()

import nfl_data_py as nfl
import pandas as pd
import matplotlib.pyplot as plt
from matplotlib.animation import FuncAnimation
import matplotlib.animation as animation

pbp = nfl.import_pbp_data([2023])

# Calculate cumulative EPA by week
plays = pbp[(pbp["epa"].notna()) & (pbp["play_type"].isin(["pass", "run"]))]

weekly_epa = (plays.groupby(["posteam", "week"])["epa"]
    .mean()
    .reset_index()
    .sort_values(["posteam", "week"]))

# Calculate cumulative average
weekly_epa["cumulative_epa"] = weekly_epa.groupby("posteam")["epa"].expanding().mean().reset_index(drop=True)

# Get rankings per week
weekly_epa["rank"] = weekly_epa.groupby("week")["cumulative_epa"].rank(ascending=False)

# Create static snapshot for a specific week (animation requires extra setup)
final_week = weekly_epa["week"].max()
final_data = weekly_epa[weekly_epa["week"] == final_week].sort_values("cumulative_epa", ascending=True)

fig, ax = plt.subplots(figsize=(10, 12))

colors = plt.cm.RdYlGn((final_data["cumulative_epa"] - final_data["cumulative_epa"].min()) /
                        (final_data["cumulative_epa"].max() - final_data["cumulative_epa"].min()))

bars = ax.barh(final_data["posteam"], final_data["cumulative_epa"], color=colors)

ax.set_xlabel("Cumulative EPA/Play")
ax.set_title(f"NFL EPA Rankings Through Week {final_week}", fontweight="bold")
ax.axvline(x=0, color="gray", linestyle="--", alpha=0.5)

for bar, epa in zip(bars, final_data["cumulative_epa"]):
    ax.text(epa + 0.005, bar.get_y() + bar.get_height()/2,
            f"{epa:.3f}", va="center", fontsize=8)

plt.tight_layout()
plt.savefig("epa_rankings.png", dpi=300)
plt.show()

print("Note: For true animation, use matplotlib FuncAnimation or plotly")

import nfl_data_py as nfl
import pandas as pd

pbp = nfl.import_pbp_data([2023])

# QB air yards analysis
passes = pbp[(pbp["passer_player_id"].notna()) & (pbp["air_yards"].notna())]

qb_air_yards = (passes.groupby(["passer_player_id", "passer_player_name"])
    .agg(
        attempts=("air_yards", "count"),
        total_air_yards=("air_yards", "sum"),
        avg_air_yards=("air_yards", "mean"),
        deep_pct=("air_yards", lambda x: (x >= 20).mean() * 100)
    )
    .reset_index())

qb_air_yards = qb_air_yards[qb_air_yards["attempts"] >= 200].sort_values(
    "avg_air_yards", ascending=False)

print("QB Air Yards Analysis:")
print(qb_air_yards)

import nfl_data_py as nfl
import pandas as pd

pbp = nfl.import_pbp_data([2023])

# CPOE analysis
passes = pbp[(pbp["passer_player_id"].notna()) & (pbp["cpoe"].notna())]

qb_cpoe = (passes.groupby(["passer_player_id", "passer_player_name"])
    .agg(
        attempts=("cpoe", "count"),
        completion_pct=("complete_pass", lambda x: x.mean() * 100),
        cpoe=("cpoe", "mean")
    )
    .reset_index())

qb_cpoe = qb_cpoe[qb_cpoe["attempts"] >= 200].sort_values("cpoe", ascending=False)

print("QB CPOE Rankings:")
print(qb_cpoe)

import nfl_data_py as nfl
import pandas as pd

pbp = nfl.import_pbp_data([2023])

# Filter pass plays with air yards
passes = pbp[(pbp["air_yards"].notna()) & (pbp["play_type"] == "pass")]

# Depth zones
def get_depth_zone(ay):
    if ay < 0: return "Behind LOS"
    elif ay < 5: return "Short (0-4)"
    elif ay < 10: return "Intermediate (5-9)"
    elif ay < 15: return "Medium (10-14)"
    elif ay < 20: return "Deep (15-19)"
    else: return "Bomb (20+)"

passes["depth_zone"] = passes["air_yards"].apply(get_depth_zone)

depth_analysis = (passes.groupby("depth_zone")
    .agg(
        attempts=("air_yards", "count"),
        comp_pct=("complete_pass", lambda x: x.mean() * 100),
        avg_epa=("epa", "mean"),
        td_rate=("pass_touchdown", lambda x: x.mean() * 100)
    )
    .reset_index())

print("Passing Efficiency by Depth:")
print(depth_analysis)

import nfl_data_py as nfl
import pandas as pd

pbp = nfl.import_pbp_data([2023])

# QB pressure analysis
passes = pbp[(pbp["passer_player_id"].notna()) & (pbp["play_type"] == "pass")]

qb_pressure = (passes.groupby(["passer_player_id", "passer_player_name"])
    .agg(
        dropbacks=("sack", "count"),
        sacks=("sack", "sum"),
        sack_rate=("sack", lambda x: x.mean() * 100)
    )
    .reset_index())

qb_pressure = qb_pressure[qb_pressure["dropbacks"] >= 200].sort_values("sack_rate")

print("QB Sack Rates (lowest is best):")
print(qb_pressure)

import nfl_data_py as nfl
import pandas as pd
import matplotlib.pyplot as plt

pbp = nfl.import_pbp_data([2023])

# Pass location analysis
passes = pbp[
    (pbp["play_type"] == "pass") &
    (pbp["air_yards"].notna()) &
    (pbp["pass_location"].notna())
]

# Team passing tendencies
team_tendencies = (passes.groupby(["posteam", "pass_location"])
    .agg(
        attempts=("epa", "count"),
        epa=("epa", "mean")
    )
    .reset_index())

# Calculate percentages
team_totals = team_tendencies.groupby("posteam")["attempts"].transform("sum")
team_tendencies["pct"] = team_tendencies["attempts"] / team_totals * 100

print("Team Pass Location Tendencies:")
print(team_tendencies[team_tendencies["posteam"] == "KC"])

import nfl_data_py as nfl
import pandas as pd

pbp = nfl.import_pbp_data([2023])

# Dropback success rate
dropbacks = pbp[(pbp["passer_player_id"].notna()) & (pbp["qb_dropback"] == 1)]

qb_dropback = (dropbacks.groupby(["passer_player_id", "passer_player_name"])
    .agg(
        dropbacks=("success", "count"),
        success_rate=("success", lambda x: x.mean() * 100),
        epa_per_dropback=("epa", "mean"),
        sack_rate=("sack", lambda x: x.mean() * 100)
    )
    .reset_index())

qb_dropback = qb_dropback[qb_dropback["dropbacks"] >= 200].sort_values(
    "success_rate", ascending=False)

print("QB Dropback Success Rate:")
print(qb_dropback)

import nfl_data_py as nfl
import pandas as pd

pbp = nfl.import_pbp_data([2023])

# Play action analysis
passes = pbp[(pbp["play_type"] == "pass") & (pbp["epa"].notna())].copy()
passes["play_action"] = passes["play_action"].fillna(False)

# Overall comparison
pa_comparison = (passes.groupby("play_action")
    .agg(
        attempts=("epa", "count"),
        avg_epa=("epa", "mean"),
        success_rate=("success", lambda x: x.mean() * 100)
    )
    .reset_index())

print("Play Action vs Standard Passing:")
print(pa_comparison)

# Team play action effectiveness
team_pa = (passes.groupby("posteam")
    .apply(lambda x: pd.Series({
        "pa_rate": x["play_action"].mean() * 100,
        "pa_epa": x[x["play_action"]]["epa"].mean(),
        "no_pa_epa": x[~x["play_action"]]["epa"].mean()
    }))
    .reset_index())

team_pa["pa_advantage"] = team_pa["pa_epa"] - team_pa["no_pa_epa"]
print("\nTeam Play Action Effectiveness:")
print(team_pa.sort_values("pa_advantage", ascending=False))

import nfl_data_py as nfl
import pandas as pd

pbp = nfl.import_pbp_data([2023])

# QB scramble analysis
qb_plays = pbp[pbp["passer_player_id"].notna()]

qb_scrambles = (qb_plays.groupby(["passer_player_id", "passer_player_name"])
    .agg(
        dropbacks=("qb_dropback", "sum"),
        scrambles=("qb_scramble", "sum"),
        scramble_rate=("qb_scramble", lambda x: x.mean() * 100)
    )
    .reset_index())

qb_scrambles = qb_scrambles[
    (qb_scrambles["dropbacks"] >= 200) &
    (qb_scrambles["scrambles"] >= 10)
].sort_values("scramble_rate", ascending=False)

print("QB Scramble Rates:")
print(qb_scrambles)

import nfl_data_py as nfl
import pandas as pd

pbp = nfl.import_pbp_data([2023])

# Receiver target analysis
passes = pbp[(pbp["receiver_player_id"].notna()) & (pbp["play_type"] == "pass")]

receiver_targets = (passes.groupby(["receiver_player_id", "receiver_player_name", "posteam"])
    .agg(
        targets=("epa", "count"),
        receptions=("complete_pass", "sum"),
        yards=("yards_gained", "sum"),
        tds=("pass_touchdown", "sum"),
        epa=("epa", "sum"),
        avg_depth=("air_yards", "mean")
    )
    .reset_index()
    .sort_values("targets", ascending=False))

# Add target share
team_targets = receiver_targets.groupby("posteam")["targets"].transform("sum")
receiver_targets["target_share"] = receiver_targets["targets"] / team_targets * 100

print("Top Receivers by Targets:")
print(receiver_targets.head(30))

import nfl_data_py as nfl
import pandas as pd

pbp = nfl.import_pbp_data([2023])

# Receiver YAC analysis
completions = pbp[(pbp["complete_pass"] == 1) & (pbp["yards_after_catch"].notna())]

receiver_yac = (completions.groupby(["receiver_player_id", "receiver_player_name"])
    .agg(
        receptions=("yards_after_catch", "count"),
        total_yac=("yards_after_catch", "sum"),
        avg_yac=("yards_after_catch", "mean")
    )
    .reset_index())

receiver_yac = receiver_yac[receiver_yac["receptions"] >= 40].sort_values(
    "avg_yac", ascending=False)

print("Top Receivers by YAC:")
print(receiver_yac.head(20))

# Team YAC analysis
team_yac = (completions.groupby("posteam")
    .agg(
        avg_air_yards=("air_yards", "mean"),
        avg_yac=("yards_after_catch", "mean")
    )
    .reset_index()
    .sort_values("avg_yac", ascending=False))

print("\nTeam YAC Rankings:")
print(team_yac)

import nfl_data_py as nfl
import pandas as pd

pbp = nfl.import_pbp_data([2023])

# Team rushing analysis
rushes = pbp[(pbp["play_type"] == "run") & (pbp["epa"].notna())]

team_rushing = (rushes.groupby("posteam")
    .agg(
        rush_attempts=("epa", "count"),
        avg_yards=("yards_gained", "mean"),
        rush_epa=("epa", "mean"),
        success_rate=("success", lambda x: x.mean() * 100)
    )
    .reset_index()
    .sort_values("rush_epa", ascending=False))

print("Team Rushing Rankings:")
print(team_rushing)

import nfl_data_py as nfl
import pandas as pd

pbp = nfl.import_pbp_data([2023])

# Run direction analysis
rushes = pbp[(pbp["play_type"] == "run") &
             (pbp["run_location"].notna()) &
             (pbp["run_gap"].notna())]

run_direction = (rushes.groupby(["run_location", "run_gap"])
    .agg(
        attempts=("epa", "count"),
        avg_yards=("yards_gained", "mean"),
        epa=("epa", "mean"),
        success_rate=("success", lambda x: x.mean() * 100)
    )
    .reset_index()
    .sort_values("epa", ascending=False))

print("Run Efficiency by Direction:")
print(run_direction)

import nfl_data_py as nfl
import pandas as pd

pbp = nfl.import_pbp_data([2023])

# Box count analysis
rushes = pbp[(pbp["play_type"] == "run") &
             (pbp["defenders_in_box"].notna()) &
             (pbp["epa"].notna())]

box_analysis = (rushes.groupby("defenders_in_box")
    .agg(
        attempts=("epa", "count"),
        avg_yards=("yards_gained", "mean"),
        epa=("epa", "mean"),
        success_rate=("success", lambda x: x.mean() * 100)
    )
    .reset_index())

box_analysis = box_analysis[box_analysis["attempts"] >= 100]
print("Rushing by Defenders in Box:")
print(box_analysis)

import nfl_data_py as nfl
import pandas as pd

pbp = nfl.import_pbp_data([2023])

# Goal line rushing
goal_line = pbp[(pbp["play_type"] == "run") &
                (pbp["yardline_100"] <= 5) &
                (pbp["epa"].notna())]

# Team goal line rushing
team_goal_line = (goal_line.groupby("posteam")
    .agg(
        attempts=("rush_touchdown", "count"),
        touchdowns=("rush_touchdown", "sum"),
        td_rate=("rush_touchdown", lambda x: x.mean() * 100),
        success_rate=("success", lambda x: x.mean() * 100)
    )
    .reset_index())

team_goal_line = team_goal_line[team_goal_line["attempts"] >= 10].sort_values(
    "td_rate", ascending=False)

print("Goal Line Rushing Efficiency:")
print(team_goal_line)

import nfl_data_py as nfl
import pandas as pd

pbp = nfl.import_pbp_data([2023])

# RB rushing stats
rushes = pbp[(pbp["rusher_player_id"].notna()) & (pbp["play_type"] == "run")]
rb_rush = (rushes.groupby("rusher_player_id")
    .agg(
        rush_att=("epa", "count"),
        rush_yards=("yards_gained", "sum"),
        rush_epa=("epa", "sum")
    )
    .reset_index())

# RB receiving stats
receptions = pbp[(pbp["receiver_player_id"].notna()) & (pbp["play_type"] == "pass")]
rb_rec = (receptions.groupby("receiver_player_id")
    .agg(
        targets=("epa", "count"),
        receptions=("complete_pass", "sum"),
        rec_epa=("epa", "sum")
    )
    .reset_index())

# Combine
rb_combined = rb_rush.merge(rb_rec, left_on="rusher_player_id",
                             right_on="receiver_player_id", how="inner")
rb_combined = rb_combined[rb_combined["rush_att"] >= 50]
rb_combined["total_epa"] = rb_combined["rush_epa"] + rb_combined["rec_epa"]

print("RB Total EPA (Rush + Receiving):")
print(rb_combined.sort_values("total_epa", ascending=False).head(20))

import nfl_data_py as nfl
import pandas as pd

pbp = nfl.import_pbp_data([2023])

# Rush success by formation
rushes = pbp[(pbp["play_type"] == "run") &
             (pbp["epa"].notna()) &
             (pbp["offense_formation"].notna())]

formation_rush = (rushes.groupby("offense_formation")
    .agg(
        attempts=("epa", "count"),
        avg_yards=("yards_gained", "mean"),
        epa=("epa", "mean"),
        success_rate=("success", lambda x: x.mean() * 100)
    )
    .reset_index())

formation_rush = formation_rush[formation_rush["attempts"] >= 100].sort_values(
    "epa", ascending=False)

print("Rushing Efficiency by Formation:")
print(formation_rush)

import nfl_data_py as nfl
import pandas as pd

pbp = nfl.import_pbp_data([2023])

# Defensive EPA rankings
plays = pbp[(pbp["epa"].notna()) & (pbp["play_type"].isin(["pass", "run"]))]

def_epa = (plays.groupby("defteam")
    .agg(
        plays=("epa", "count"),
        epa_allowed=("epa", "mean"),
        success_allowed=("success", lambda x: x.mean() * 100)
    )
    .reset_index()
    .sort_values("epa_allowed"))  # Lower is better

print("Defensive EPA Rankings (lower is better):")
print(def_epa)

import nfl_data_py as nfl
import pandas as pd

pbp = nfl.import_pbp_data([2023])

# Pass rush metrics
pass_plays = pbp[(pbp["play_type"] == "pass") & (pbp["epa"].notna())]

pass_rush = (pass_plays.groupby("defteam")
    .agg(
        pass_plays=("epa", "count"),
        sacks=("sack", "sum"),
        sack_rate=("sack", lambda x: x.mean() * 100),
        epa_allowed=("epa", "mean")
    )
    .reset_index()
    .sort_values("sack_rate", ascending=False))

print("Team Pass Rush Effectiveness:")
print(pass_rush)

import nfl_data_py as nfl
import pandas as pd

pbp = nfl.import_pbp_data([2023])

# Red zone defense
rz_plays = pbp[(pbp["yardline_100"] <= 20) & (pbp["epa"].notna())]

rz_defense = (rz_plays.groupby("defteam")
    .agg(
        rz_plays=("epa", "count"),
        rz_epa_allowed=("epa", "mean"),
        td_allowed_rate=("touchdown", lambda x: x.mean() * 100)
    )
    .reset_index()
    .sort_values("rz_epa_allowed"))

print("Red Zone Defense Rankings:")
print(rz_defense)

import nfl_data_py as nfl
import pandas as pd

pbp = nfl.import_pbp_data([2023])

# Third down defense
third_down = pbp[(pbp["down"] == 3) & (pbp["epa"].notna())]

third_down_def = (third_down.groupby("defteam")
    .agg(
        third_downs=("epa", "count"),
        conv_rate_allowed=("first_down", lambda x: x.mean() * 100),
        epa_allowed=("epa", "mean")
    )
    .reset_index()
    .sort_values("conv_rate_allowed"))

print("Third Down Defense (lower is better):")
print(third_down_def)

import nfl_data_py as nfl
import pandas as pd

pbp = nfl.import_pbp_data([2023])

# Turnover analysis
plays = pbp[pbp["defteam"].notna()]

turnovers = (plays.groupby("defteam")
    .agg(
        plays=("epa", "count"),
        interceptions=("interception", "sum"),
        fumbles=("fumble_lost", "sum")
    )
    .reset_index())

turnovers["total_turnovers"] = turnovers["interceptions"] + turnovers["fumbles"]
turnovers["turnover_rate"] = turnovers["total_turnovers"] / turnovers["plays"] * 100
turnovers = turnovers.sort_values("total_turnovers", ascending=False)

print("Defensive Turnovers Created:")
print(turnovers)

import nfl_data_py as nfl
import pandas as pd

pbp = nfl.import_pbp_data([2023])

# YAC allowed
completions = pbp[(pbp["complete_pass"] == 1) & (pbp["yards_after_catch"].notna())]

yac_allowed = (completions.groupby("defteam")
    .agg(
        completions=("yards_after_catch", "count"),
        total_yac=("yards_after_catch", "sum"),
        avg_yac=("yards_after_catch", "mean")
    )
    .reset_index()
    .sort_values("avg_yac"))

print("YAC Allowed by Defense (lower is better):")
print(yac_allowed)

import nfl_data_py as nfl
import pandas as pd

pbp = nfl.import_pbp_data([2023])

# Field goal analysis
fgs = pbp[(pbp["play_type"] == "field_goal") & (pbp["kick_distance"].notna())]

def distance_bucket(d):
    if d < 30: return "Under 30"
    elif d < 40: return "30-39"
    elif d < 50: return "40-49"
    else: return "50+"

fgs["distance_bucket"] = fgs["kick_distance"].apply(distance_bucket)

fg_analysis = (fgs.groupby("distance_bucket")
    .agg(
        attempts=("field_goal_result", "count"),
        makes=("field_goal_result", lambda x: (x == "made").sum()),
        pct=("field_goal_result", lambda x: (x == "made").mean() * 100)
    )
    .reset_index())

print("Field Goal Accuracy by Distance:")
print(fg_analysis)

import nfl_data_py as nfl
import pandas as pd

pbp = nfl.import_pbp_data([2023])

# Punt analysis
punts = pbp[(pbp["play_type"] == "punt") & (pbp["kick_distance"].notna())]

punt_analysis = (punts.groupby("punter_player_name")
    .agg(
        punts=("kick_distance", "count"),
        avg_gross=("kick_distance", "mean"),
        touchbacks=("touchback", "sum")
    )
    .reset_index())

punt_analysis = punt_analysis[punt_analysis["punts"] >= 20].sort_values(
    "avg_gross", ascending=False)

print("Punter Rankings:")
print(punt_analysis)

import nfl_data_py as nfl
import pandas as pd

pbp = nfl.import_pbp_data([2023])

# Kickoff return analysis
kickoffs = pbp[(pbp["play_type"] == "kickoff") & (pbp["return_yards"].notna())]

ko_returns = (kickoffs.groupby("posteam")
    .agg(
        returns=("return_yards", "count"),
        total_yards=("return_yards", "sum"),
        avg_return=("return_yards", "mean"),
        tds=("return_touchdown", "sum")
    )
    .reset_index()
    .sort_values("avg_return", ascending=False))

print("Kickoff Return Rankings:")
print(ko_returns)

import nfl_data_py as nfl
import pandas as pd

pbp = nfl.import_pbp_data([2023])

# Punt return analysis
punt_returns = pbp[(pbp["play_type"] == "punt") &
                   (pbp["return_yards"].notna()) &
                   (pbp["return_yards"] > 0)]

pr_analysis = (punt_returns.groupby("posteam")
    .agg(
        returns=("return_yards", "count"),
        total_yards=("return_yards", "sum"),
        avg_return=("return_yards", "mean")
    )
    .reset_index()
    .sort_values("avg_return", ascending=False))

print("Punt Return Rankings:")
print(pr_analysis)

import nfl_data_py as nfl
import pandas as pd

pbp = nfl.import_pbp_data([2023])

# Filter special teams plays
st_plays = pbp[(pbp["special_teams_play"] == 1) & (pbp["epa"].notna())]

# Map play types
def st_type(play):
    if play == "kickoff": return "Kickoff"
    elif play == "punt": return "Punt"
    elif play == "field_goal": return "Field Goal"
    elif play == "extra_point": return "Extra Point"
    else: return "Other"

st_plays["st_play_type"] = st_plays["play_type"].apply(st_type)

# Team special teams EPA
team_st_epa = (st_plays.groupby("posteam")
    .agg(
        total_st_epa=("epa", "sum"),
        avg_st_epa=("epa", "mean"),
        st_plays=("epa", "count")
    )
    .reset_index()
    .sort_values("total_st_epa", ascending=False))

print("Special Teams EPA Rankings:")
print(team_st_epa)

import nfl_data_py as nfl
import pandas as pd

pbp = nfl.import_pbp_data([2020, 2021, 2022, 2023])

# Find blocked kicks
st_plays = pbp[pbp["play_type"].isin(["field_goal", "punt", "extra_point"])]
blocked = st_plays[st_plays["desc"].str.lower().str.contains("block", na=False)]

# Blocked kicks by blocking team
team_blocks = (blocked.groupby(["defteam", "play_type"])
    .size()
    .reset_index(name="blocks"))

# Pivot to get blocks by type
blocks_pivot = team_blocks.pivot_table(
    index="defteam",
    columns="play_type",
    values="blocks",
    fill_value=0
).reset_index()

blocks_pivot["total_blocks"] = blocks_pivot.select_dtypes(include="number").sum(axis=1)
blocks_pivot = blocks_pivot.sort_values("total_blocks", ascending=False)

print("Teams with Most Blocked Kicks (2020-2023):")
print(blocks_pivot.head(10))

import nfl_data_py as nfl
import pandas as pd
import numpy as np

# Load data
pbp = nfl.import_pbp_data([2023])
schedules = nfl.import_schedules([2023])

# Calculate team ratings
plays = pbp[pbp["epa"].notna()]

off_epa = plays.groupby("posteam")["epa"].mean().reset_index()
off_epa.columns = ["team", "off_epa"]

def_epa = plays.groupby("defteam")["epa"].mean().reset_index()
def_epa.columns = ["team", "def_epa"]

team_ratings = off_epa.merge(def_epa, on="team")
team_ratings["net_epa"] = team_ratings["off_epa"] - team_ratings["def_epa"]
team_ratings["power_rating"] = team_ratings["net_epa"] * 3.5

# Create matchup predictions
games = schedules[schedules["result"].notna()].copy()
games = games.merge(
    team_ratings[["team", "power_rating"]],
    left_on="home_team", right_on="team"
).rename(columns={"power_rating": "home_power"})
games = games.merge(
    team_ratings[["team", "power_rating"]],
    left_on="away_team", right_on="team"
).rename(columns={"power_rating": "away_power"})

games["pred_spread"] = games["away_power"] - games["home_power"] - 2.5
games["actual_spread"] = -games["result"]
games["error"] = games["pred_spread"] - games["actual_spread"]
games["correct_side"] = ((games["pred_spread"] > 0) & (games["result"] < 0)) | \
                        ((games["pred_spread"] < 0) & (games["result"] > 0))

print(f"Mean Absolute Error: {games['error'].abs().mean():.2f}")
print(f"Correct Side %: {games['correct_side'].mean() * 100:.1f}%")

import nfl_data_py as nfl
import pandas as pd
import numpy as np

pbp = nfl.import_pbp_data([2023])
schedules = nfl.import_schedules([2023])

# Calculate team scoring metrics
plays = pbp[pbp["epa"].notna()]

game_scoring = (plays.groupby(["game_id", "posteam"])
    .agg(
        plays=("epa", "count"),
        touchdowns=("touchdown", "sum")
    )
    .reset_index())
game_scoring["points_approx"] = game_scoring["touchdowns"] * 7

team_scoring = (game_scoring.groupby("posteam")
    .agg(
        avg_plays=("plays", "mean"),
        avg_points=("points_approx", "mean")
    )
    .reset_index())
team_scoring["pace"] = team_scoring["avg_plays"] / 60

# Create totals predictions
games = schedules[schedules["result"].notna() & schedules["total"].notna()].copy()
games = games.merge(
    team_scoring[["posteam", "avg_points", "pace"]],
    left_on="home_team", right_on="posteam"
).rename(columns={"avg_points": "home_points", "pace": "home_pace"})
games = games.merge(
    team_scoring[["posteam", "avg_points", "pace"]],
    left_on="away_team", right_on="posteam"
).rename(columns={"avg_points": "away_points", "pace": "away_pace"})

games["pred_total"] = (games["home_points"] + games["away_points"]) * \
                      ((games["home_pace"] + games["away_pace"]) / 2)
games["actual_total"] = games["home_score"] + games["away_score"]
games["correct"] = (games["pred_total"] > games["total"]) == \
                   (games["actual_total"] > games["total"])

print(f"Correct %: {games['correct'].mean() * 100:.1f}%")
print(f"MAE: {(games['pred_total'] - games['actual_total']).abs().mean():.1f}")

import nfl_data_py as nfl
import pandas as pd

pbp = nfl.import_pbp_data([2023])

# Calculate receiver baseline stats
pass_plays = pbp[(pbp["receiver_player_id"].notna()) &
                 (pbp["play_type"] == "pass")]

receiver_stats = (pass_plays.groupby(
    ["receiver_player_id", "receiver_player_name", "posteam"])
    .agg(
        targets=("play_id", "count"),
        receptions=("complete_pass", "sum"),
        yards=("yards_gained", "sum"),
        tds=("touchdown", "sum"),
        avg_depth=("air_yards", "mean")
    )
    .reset_index())

receiver_stats = receiver_stats[receiver_stats["targets"] >= 50]
receiver_stats["catch_rate"] = receiver_stats["receptions"] / receiver_stats["targets"]
receiver_stats["yards_per_target"] = receiver_stats["yards"] / receiver_stats["targets"]

# Calculate team target rates
team_targets = (pass_plays.groupby("posteam")
    .size().reset_index(name="team_targets"))

receiver_share = receiver_stats.merge(team_targets, on="posteam")
receiver_share["target_share"] = receiver_share["targets"] / receiver_share["team_targets"]

# Project yards (35 passes per game assumption)
receiver_share["proj_targets"] = receiver_share["target_share"] * 35
receiver_share["proj_yards"] = receiver_share["proj_targets"] * receiver_share["yards_per_target"]

result = receiver_share.nlargest(20, "proj_yards")[
    ["receiver_player_name", "target_share", "yards_per_target", "proj_yards"]
]
print(result)

import nfl_data_py as nfl
import pandas as pd
import numpy as np

schedules = nfl.import_schedules([2020, 2021, 2022, 2023])

# Initialize Elo ratings
teams = pd.concat([schedules["home_team"], schedules["away_team"]]).unique()
elo = {team: 1500 for team in teams}
k_factor = 20

def expected(r1, r2):
    return 1 / (1 + 10**((r2 - r1)/400))

def update_elo(winner_rating, loser_rating, margin):
    exp_win = expected(winner_rating, loser_rating)
    mov_mult = np.log(abs(margin) + 1) * 2.2 / ((winner_rating - loser_rating) * 0.001 + 2.2)
    change = k_factor * mov_mult * (1 - exp_win)
    return change

# Process games
games = schedules[schedules["result"].notna()].sort_values("game_id")

for _, g in games.iterrows():
    home_elo = elo[g["home_team"]] + 55  # Home field advantage
    away_elo = elo[g["away_team"]]

    if g["result"] > 0:  # Home win
        change = update_elo(home_elo, away_elo, g["result"])
        elo[g["home_team"]] += change
        elo[g["away_team"]] -= change
    else:  # Away win
        change = update_elo(away_elo, home_elo, -g["result"])
        elo[g["away_team"]] += change
        elo[g["home_team"]] -= change

# Current Elo rankings
elo_df = pd.DataFrame({"team": list(elo.keys()), "elo": list(elo.values())})
elo_df = elo_df.sort_values("elo", ascending=False).reset_index(drop=True)
print("Current Elo Rankings:")
print(elo_df)

import nfl_data_py as nfl
import pandas as pd
import numpy as np

pbp = nfl.import_pbp_data([2023])
schedules = nfl.import_schedules([2023])

# Calculate team metrics
plays = pbp[(pbp["epa"].notna()) & (pbp["play_type"].isin(["pass", "run"]))]

off_stats = plays.groupby("posteam").agg(
    off_epa=("epa", "mean"),
    success_rate=("success", lambda x: x.mean() * 100)
).reset_index()

def_stats = plays.groupby("defteam").agg(
    def_epa=("epa", "mean")
).reset_index()

team_metrics = off_stats.merge(def_stats, left_on="posteam", right_on="defteam")

# Get win-loss records
games = schedules[schedules["result"].notna()]
home_wins = games[games["result"] > 0].groupby("home_team").size()
away_wins = games[games["result"] < 0].groupby("away_team").size()
total_games = games.groupby("home_team").size() + games.groupby("away_team").size()
total_wins = home_wins.add(away_wins, fill_value=0)
win_pct = (total_wins / total_games).reset_index()
win_pct.columns = ["team", "win_pct"]

# Combine
power_rankings = team_metrics.merge(win_pct, left_on="posteam", right_on="team")

# Normalize
def normalize(col):
    return (col - col.min()) / (col.max() - col.min()) * 100

power_rankings["off_score"] = normalize(power_rankings["off_epa"])
power_rankings["def_score"] = 100 - normalize(power_rankings["def_epa"])
power_rankings["win_score"] = power_rankings["win_pct"] * 100
power_rankings["power_rating"] = (power_rankings["off_score"] * 0.4 +
                                   power_rankings["def_score"] * 0.4 +
                                   power_rankings["win_score"] * 0.2)

power_rankings = power_rankings.sort_values("power_rating", ascending=False).reset_index(drop=True)
power_rankings["rank"] = range(1, len(power_rankings) + 1)

print(power_rankings[["posteam", "rank", "power_rating", "off_epa", "def_epa", "win_pct"]])

import nfl_data_py as nfl
import pandas as pd

schedules = nfl.import_schedules([2019, 2020, 2021, 2022, 2023])

# Overall HFA
games = schedules[schedules["result"].notna()]

hfa_overall = {
    "games": len(games),
    "home_wins": (games["result"] > 0).sum(),
    "away_wins": (games["result"] < 0).sum(),
    "home_win_pct": (games["result"] > 0).mean() * 100,
    "avg_home_margin": games["result"].mean()
}

print("Overall Home Field Advantage:")
print(pd.DataFrame([hfa_overall]))

# HFA by team
team_hfa = (games.groupby("home_team")
    .agg(
        home_games=("result", "count"),
        home_wins=("result", lambda x: (x > 0).sum()),
        home_win_pct=("result", lambda x: (x > 0).mean() * 100),
        avg_margin=("result", "mean")
    )
    .reset_index()
    .sort_values("home_win_pct", ascending=False))

print("\nHFA by Stadium:")
print(team_hfa)

# HFA by season
hfa_by_season = (games.groupby("season")
    .agg(
        home_win_pct=("result", lambda x: (x > 0).mean() * 100),
        avg_margin=("result", "mean")
    )
    .reset_index())

print("\nHFA Trend by Season:")
print(hfa_by_season)

import nfl_data_py as nfl
import pandas as pd

schedules = nfl.import_schedules([2018, 2019, 2020, 2021, 2022, 2023])

# Calculate margin distribution
games = schedules[schedules["result"].notna()].copy()
games["margin"] = games["result"].abs()

margins = (games.groupby("margin")
    .size()
    .reset_index(name="games")
    .sort_values("games", ascending=False))

margins["pct"] = margins["games"] / margins["games"].sum() * 100
margins["cumulative_pct"] = margins["pct"].cumsum()

print("Top 15 Final Margins:")
print(margins.head(15))

# Key number analysis
games["on_3"] = games["margin"] == 3
games["on_7"] = games["margin"] == 7
games["on_key"] = games["margin"].isin([3, 7, 10, 14])

key_summary = {
    "total_games": len(games),
    "on_3": games["on_3"].sum(),
    "on_7": games["on_7"].sum(),
    "on_3_pct": games["on_3"].mean() * 100,
    "on_7_pct": games["on_7"].mean() * 100,
    "any_key_pct": games["on_key"].mean() * 100
}

print("\nKey Number Summary:")
print(pd.DataFrame([key_summary]))

import nfl_data_py as nfl
import pandas as pd
import numpy as np

schedules = nfl.import_schedules([2023])

# Analyze spread patterns
games = schedules[(schedules["result"].notna()) & (schedules["spread_line"].notna())].copy()

games["home_covered"] = games["result"] + games["spread_line"] > 0
games["favorite"] = np.where(games["spread_line"] < 0, "Home", "Away")

def spread_bucket(s):
    s = abs(s)
    if s <= 3: return "Pick/FG"
    elif s <= 7: return "4-7 pts"
    elif s <= 10: return "8-10 pts"
    else: return "10+ pts"

games["spread_bucket"] = games["spread_line"].apply(spread_bucket)

# ATS performance by spread size
ats_by_spread = (games.groupby("spread_bucket")
    .agg(
        games=("home_covered", "count"),
        home_cover_pct=("home_covered", lambda x: x.mean() * 100),
        avg_margin=("result", lambda x: (x + games.loc[x.index, "spread_line"]).mean())
    )
    .reset_index())

print("ATS Performance by Spread Size:")
print(ats_by_spread)

# Favorite vs underdog
games["favorite_covered"] = ((games["favorite"] == "Home") & games["home_covered"]) | \
                            ((games["favorite"] == "Away") & ~games["home_covered"])

fav_cover_pct = games["favorite_covered"].mean() * 100
print(f"\nFavorite cover %: {fav_cover_pct:.1f}%")
print(f"Underdog cover %: {100 - fav_cover_pct:.1f}%")

import nfl_data_py as nfl
import pandas as pd

pbp = nfl.import_pbp_data([2023])
schedules = nfl.import_schedules([2023])

# Calculate first half scores
first_half = (pbp[pbp["qtr"] <= 2]
    .groupby("game_id")
    .agg(
        home_1h=("home_score", "last"),
        away_1h=("away_score", "last")
    )
    .reset_index())

# Get final scores
final_scores = schedules[schedules["result"].notna()][
    ["game_id", "home_score", "away_score", "spread_line", "result"]
]

# Combine
game_halves = final_scores.merge(first_half, on="game_id")
game_halves["home_2h"] = game_halves["home_score"] - game_halves["home_1h"]
game_halves["away_2h"] = game_halves["away_score"] - game_halves["away_1h"]
game_halves["result_1h"] = game_halves["home_1h"] - game_halves["away_1h"]
game_halves["result_2h"] = game_halves["home_2h"] - game_halves["away_2h"]

game_halves["same_winner"] = (game_halves["result_1h"] > 0) == (game_halves["result"] > 0)
game_halves["home_stronger_2h"] = game_halves["result_2h"] > game_halves["result_1h"]

# Analysis
half_analysis = {
    "games": len(game_halves),
    "avg_1h_margin": game_halves["result_1h"].mean(),
    "avg_2h_margin": game_halves["result_2h"].mean(),
    "same_winner_pct": game_halves["same_winner"].mean() * 100,
    "home_stronger_2h_pct": game_halves["home_stronger_2h"].mean() * 100
}

print("First Half vs Second Half Analysis:")
print(pd.DataFrame([half_analysis]))

import nfl_data_py as nfl
import pandas as pd

schedules = nfl.import_schedules([2019, 2020, 2021, 2022, 2023])

# Define divisions
divisions = {
    "AFC_East": ["BUF", "MIA", "NE", "NYJ"],
    "AFC_North": ["BAL", "CIN", "CLE", "PIT"],
    "AFC_South": ["HOU", "IND", "JAX", "TEN"],
    "AFC_West": ["DEN", "KC", "LV", "LAC"],
    "NFC_East": ["DAL", "NYG", "PHI", "WAS"],
    "NFC_North": ["CHI", "DET", "GB", "MIN"],
    "NFC_South": ["ATL", "CAR", "NO", "TB"],
    "NFC_West": ["ARI", "LAR", "SF", "SEA"]
}

def get_division(team):
    for div, teams in divisions.items():
        if team in teams:
            return div
    return None

# Analyze division games
games = schedules[(schedules["result"].notna()) & (schedules["spread_line"].notna())].copy()
games["home_div"] = games["home_team"].apply(get_division)
games["away_div"] = games["away_team"].apply(get_division)
games["is_division_game"] = games["home_div"] == games["away_div"]

# Compare division vs non-division
div_comparison = (games.groupby("is_division_game")
    .agg(
        games=("result", "count"),
        home_win_pct=("result", lambda x: (x > 0).mean() * 100),
        home_cover_pct=("result", lambda x: ((x + games.loc[x.index, "spread_line"]) > 0).mean() * 100),
        avg_total=("home_score", lambda x: (x + games.loc[x.index, "away_score"]).mean()),
        avg_margin=("result", lambda x: x.abs().mean())
    )
    .reset_index())

div_comparison["is_division_game"] = div_comparison["is_division_game"].map({True: "Division", False: "Non-Division"})
print("Division vs Non-Division Game Analysis:")
print(div_comparison)

import nfl_data_py as nfl
import pandas as pd

pbp = nfl.import_pbp_data([2023])

# QB Fantasy Points
qb_plays = pbp[pbp["passer_player_id"].notna()]
qb_fantasy = (qb_plays.groupby(["passer_player_id", "passer_player_name"])
    .agg(
        pass_yards=("passing_yards", "sum"),
        pass_tds=("pass_touchdown", "sum"),
        ints=("interception", "sum")
    )
    .reset_index())
qb_fantasy["fantasy_pts"] = (qb_fantasy["pass_yards"] * 0.04 +
                              qb_fantasy["pass_tds"] * 4 -
                              qb_fantasy["ints"] * 2)
qb_fantasy = qb_fantasy.sort_values("fantasy_pts", ascending=False)

# Skill position fantasy points (simplified)
rush_plays = pbp[pbp["rusher_player_id"].notna()]
rush_pts = (rush_plays.groupby(["rusher_player_id", "rusher_player_name"])
    .agg(
        rush_yards=("rushing_yards", "sum"),
        rush_tds=("rush_touchdown", "sum")
    )
    .reset_index())
rush_pts.columns = ["player_id", "player_name", "rush_yards", "rush_tds"]

rec_plays = pbp[pbp["receiver_player_id"].notna()]
rec_pts = (rec_plays.groupby(["receiver_player_id", "receiver_player_name"])
    .agg(
        receptions=("complete_pass", "sum"),
        rec_yards=("receiving_yards", "sum"),
        rec_tds=("pass_touchdown", "sum")
    )
    .reset_index())
rec_pts.columns = ["player_id", "player_name", "receptions", "rec_yards", "rec_tds"]

# Combine
skill_fantasy = rush_pts.merge(rec_pts, on=["player_id", "player_name"], how="outer").fillna(0)
skill_fantasy["fantasy_pts"] = (skill_fantasy["rush_yards"] * 0.1 +
                                 skill_fantasy["rush_tds"] * 6 +
                                 skill_fantasy["receptions"] * 1 +
                                 skill_fantasy["rec_yards"] * 0.1 +
                                 skill_fantasy["rec_tds"] * 6)
skill_fantasy = skill_fantasy[skill_fantasy["fantasy_pts"] > 50].sort_values("fantasy_pts", ascending=False)

print(skill_fantasy.head(30))

import nfl_data_py as nfl
import pandas as pd

pbp = nfl.import_pbp_data([2023])

# Filter to pass plays with receiver
pass_plays = pbp[(pbp["play_type"] == "pass") &
                 (pbp["receiver_player_id"].notna())]

# Team totals
team_targets = pass_plays.groupby("posteam").agg(
    team_targets=("play_id", "count"),
    team_air_yards=("air_yards", "sum")
).reset_index()

# Player stats
player_stats = (pass_plays.groupby(
    ["posteam", "receiver_player_id", "receiver_player_name"])
    .agg(
        targets=("play_id", "count"),
        air_yards=("air_yards", "sum"),
        receptions=("complete_pass", "sum"),
        yards=("yards_gained", "sum")
    )
    .reset_index())

# Calculate shares
target_share = player_stats.merge(team_targets, on="posteam")
target_share["target_share"] = target_share["targets"] / target_share["team_targets"]
target_share["air_yard_share"] = target_share["air_yards"] / target_share["team_air_yards"]
target_share["wopr"] = target_share["target_share"] * 1.5 + target_share["air_yard_share"] * 0.7

result = target_share.nlargest(25, "wopr")[
    ["receiver_player_name", "posteam", "target_share", "air_yard_share", "wopr"]
]
print(result)

import nfl_data_py as nfl
import pandas as pd

# Load participation data
participation = nfl.import_snap_counts([2023])
rosters = nfl.import_rosters([2023])

# Aggregate by player
season_snaps = (participation.groupby("pfr_player_id")
    .agg(
        games=("week", "nunique"),
        total_off_snaps=("offense_snaps", "sum"),
        avg_off_snaps=("offense_snaps", "mean"),
        total_def_snaps=("defense_snaps", "sum")
    )
    .reset_index())

# Join with roster data
roster_subset = rosters[["pfr_id", "player_name", "position", "team"]].drop_duplicates()
season_snaps = season_snaps.merge(roster_subset, left_on="pfr_player_id",
                                   right_on="pfr_id", how="left")

# Filter skill positions
skill_snaps = season_snaps[season_snaps["position"].isin(["RB", "WR", "TE"])]
skill_snaps = skill_snaps.sort_values("total_off_snaps", ascending=False)

print("Top Snap Count Leaders (Skill Positions):")
print(skill_snaps.head(30))

import nfl_data_py as nfl
import pandas as pd

pbp = nfl.import_pbp_data([2023])

# Calculate TD rate analysis
pass_plays = pbp[(pbp["play_type"] == "pass") & (pbp["receiver_player_id"].notna())]

td_analysis = (pass_plays.groupby(["receiver_player_id", "receiver_player_name"])
    .agg(
        targets=("play_id", "count"),
        rz_targets=("yardline_100", lambda x: (x <= 20).sum()),
        tds=("pass_touchdown", "sum")
    )
    .reset_index())

td_analysis = td_analysis[td_analysis["targets"] >= 50]
td_analysis["rz_rate"] = td_analysis["rz_targets"] / td_analysis["targets"]
td_analysis["expected_td_rate"] = 0.10 * td_analysis["rz_rate"]
td_analysis["actual_td_rate"] = td_analysis["tds"] / td_analysis["targets"]
td_analysis["td_diff"] = td_analysis["actual_td_rate"] - td_analysis["expected_td_rate"]

# Positive regression candidates
positive = td_analysis[td_analysis["td_diff"] < -0.03].sort_values("td_diff")
print("Positive Regression Candidates (Due for more TDs):")
print(positive[["receiver_player_name", "targets", "tds", "td_diff"]].head(10))

# Negative regression candidates
negative = td_analysis[td_analysis["td_diff"] > 0.03].sort_values("td_diff", ascending=False)
print("\nNegative Regression Candidates (TD rate unsustainable):")
print(negative[["receiver_player_name", "targets", "tds", "td_diff"]].head(10))

import nfl_data_py as nfl
import pandas as pd

pbp = nfl.import_pbp_data([2023])

# Red zone targets
rz_plays = pbp[(pbp["play_type"] == "pass") &
               (pbp["yardline_100"] <= 20) &
               (pbp["receiver_player_id"].notna())]

rz_targets = (rz_plays.groupby(["receiver_player_id", "receiver_player_name", "posteam"])
    .agg(
        rz_targets=("play_id", "count"),
        rz_receptions=("complete_pass", "sum"),
        rz_tds=("pass_touchdown", "sum"),
        avg_depth=("air_yards", "mean")
    )
    .reset_index())

rz_targets["rz_catch_rate"] = rz_targets["rz_receptions"] / rz_targets["rz_targets"] * 100
rz_targets["rz_td_rate"] = rz_targets["rz_tds"] / rz_targets["rz_targets"] * 100

rz_targets = rz_targets.sort_values("rz_targets", ascending=False)

print("Top Red Zone Target Leaders:")
print(rz_targets.head(25))

# Goal line targets
gl_plays = pbp[(pbp["play_type"] == "pass") &
               (pbp["yardline_100"] <= 10) &
               (pbp["receiver_player_id"].notna())]

goalline = (gl_plays.groupby("receiver_player_name")
    .agg(gl_targets=("play_id", "count"), gl_tds=("pass_touchdown", "sum"))
    .reset_index()
    .sort_values("gl_targets", ascending=False))

print("\nGoal Line Target Leaders:")
print(goalline.head(15))

import nfl_data_py as nfl
import pandas as pd
import numpy as np

pbp = nfl.import_pbp_data([2023])

# Calculate weekly fantasy points
skill_plays = pbp[(pbp["receiver_player_id"].notna()) | (pbp["rusher_player_id"].notna())].copy()
skill_plays["player_id"] = skill_plays["receiver_player_id"].fillna(skill_plays["rusher_player_id"])
skill_plays["player_name"] = skill_plays["receiver_player_name"].fillna(skill_plays["rusher_player_name"])

weekly = (skill_plays.groupby(["player_id", "player_name", "week"])
    .agg(
        rush_yards=("rushing_yards", "sum"),
        rush_tds=("rush_touchdown", "sum"),
        receptions=("complete_pass", "sum"),
        rec_yards=("receiving_yards", "sum"),
        rec_tds=("pass_touchdown", "sum")
    )
    .reset_index())

weekly["fantasy_pts"] = (weekly["rush_yards"] * 0.1 + weekly["rush_tds"] * 6 +
                          weekly["receptions"] * 1 + weekly["rec_yards"] * 0.1 +
                          weekly["rec_tds"] * 6)

# Consistency metrics
consistency = (weekly.groupby(["player_id", "player_name"])
    .agg(
        games=("fantasy_pts", "count"),
        avg_pts=("fantasy_pts", "mean"),
        std_pts=("fantasy_pts", "std"),
        floor=("fantasy_pts", lambda x: x.quantile(0.1)),
        ceiling=("fantasy_pts", lambda x: x.quantile(0.9)),
        boom_rate=("fantasy_pts", lambda x: (x > 15).mean() * 100),
        bust_rate=("fantasy_pts", lambda x: (x < 5).mean() * 100)
    )
    .reset_index())

consistency = consistency[consistency["games"] >= 8]
consistency["consistency_score"] = consistency["avg_pts"] / (consistency["std_pts"] + 1)

consistency = consistency.sort_values("consistency_score", ascending=False)
print("Most Consistent Fantasy Performers:")
print(consistency[["player_name", "avg_pts", "boom_rate", "bust_rate", "consistency_score"]].head(20))

import nfl_data_py as nfl
import pandas as pd

pbp = nfl.import_pbp_data([2023])

# Get opportunity metrics
skill_plays = pbp[(pbp["receiver_player_id"].notna()) | (pbp["rusher_player_id"].notna())].copy()
skill_plays["player_id"] = skill_plays["receiver_player_id"].fillna(skill_plays["rusher_player_id"])
skill_plays["player_name"] = skill_plays["receiver_player_name"].fillna(skill_plays["rusher_player_name"])
skill_plays["is_target"] = skill_plays["receiver_player_id"].notna()
skill_plays["is_carry"] = (skill_plays["rusher_player_id"].notna()) & (skill_plays["play_type"] == "run")

opportunities = (skill_plays.groupby(["player_id", "player_name", "posteam"])
    .agg(
        games=("game_id", "nunique"),
        targets=("is_target", "sum"),
        carries=("is_carry", "sum"),
        rush_yards=("rushing_yards", "sum"),
        rush_tds=("rush_touchdown", "sum"),
        receptions=("complete_pass", "sum"),
        rec_yards=("receiving_yards", "sum"),
        rec_tds=("pass_touchdown", "sum")
    )
    .reset_index())

opportunities["touches"] = opportunities["targets"] + opportunities["carries"]
opportunities["fantasy_pts"] = (opportunities["rush_yards"] * 0.1 +
                                 opportunities["rush_tds"] * 6 +
                                 opportunities["receptions"] * 1 +
                                 opportunities["rec_yards"] * 0.1 +
                                 opportunities["rec_tds"] * 6)
opportunities["pts_per_game"] = opportunities["fantasy_pts"] / opportunities["games"]
opportunities["games_remaining"] = 17 - opportunities["games"]
opportunities["projected_ros_pts"] = opportunities["pts_per_game"] * opportunities["games_remaining"]

opportunities = opportunities[(opportunities["games"] >= 5) & (opportunities["touches"] >= 30)]
opportunities = opportunities.sort_values("projected_ros_pts", ascending=False)

print("Rest of Season Fantasy Rankings:")
print(opportunities[["player_name", "games", "pts_per_game", "games_remaining", "projected_ros_pts"]].head(30))

import nfl_data_py as nfl
import pandas as pd
import numpy as np

pbp = nfl.import_pbp_data([2023])

# Calculate player values
skill_plays = pbp[(pbp["receiver_player_id"].notna()) | (pbp["rusher_player_id"].notna())].copy()
skill_plays["player_id"] = skill_plays["receiver_player_id"].fillna(skill_plays["rusher_player_id"])
skill_plays["player_name"] = skill_plays["receiver_player_name"].fillna(skill_plays["rusher_player_name"])

player_values = (skill_plays.groupby(["player_id", "player_name", "posteam"])
    .agg(
        games=("game_id", "nunique"),
        rush_yards=("rushing_yards", "sum"),
        rush_tds=("rush_touchdown", "sum"),
        receptions=("complete_pass", "sum"),
        rec_yards=("receiving_yards", "sum"),
        rec_tds=("pass_touchdown", "sum")
    )
    .reset_index())

player_values["fantasy_pts"] = (player_values["rush_yards"] * 0.1 +
                                 player_values["rush_tds"] * 6 +
                                 player_values["receptions"] * 1 +
                                 player_values["rec_yards"] * 0.1 +
                                 player_values["rec_tds"] * 6)
player_values["ppg"] = player_values["fantasy_pts"] / player_values["games"]

player_values = player_values[player_values["games"] >= 5]

# Create trade value scale
player_values["value_percentile"] = player_values["ppg"].rank(pct=True)
player_values["trade_value"] = (player_values["value_percentile"] * 100).round()

def get_tier(val):
    if val >= 90: return "Elite (Tier 1)"
    elif val >= 75: return "Star (Tier 2)"
    elif val >= 60: return "Starter (Tier 3)"
    elif val >= 40: return "Flex (Tier 4)"
    else: return "Bench (Tier 5)"

player_values["tier"] = player_values["trade_value"].apply(get_tier)
player_values = player_values.sort_values("trade_value", ascending=False)

print("Fantasy Trade Values:")
print(player_values[["player_name", "ppg", "trade_value", "tier"]].head(40))

import nfl_data_py as nfl
import pandas as pd

pbp = nfl.import_pbp_data([2023])
schedules = nfl.import_schedules([2023])

# Defense vs RB
rushes = pbp[(pbp["play_type"] == "run") & (pbp["epa"].notna())]
def_vs_rb = (rushes.groupby("defteam")
    .agg(
        plays=("epa", "count"),
        rush_epa_allowed=("epa", "mean"),
        rush_ypc=("yards_gained", "mean"),
        rush_td=("rush_touchdown", "sum")
    )
    .reset_index())
def_vs_rb["rb_rank"] = def_vs_rb["rush_epa_allowed"].rank()

# Defense vs WR
passes = pbp[(pbp["play_type"] == "pass") & (pbp["epa"].notna())]
def_vs_wr = (passes.groupby("defteam")
    .agg(
        plays=("epa", "count"),
        pass_epa_allowed=("epa", "mean"),
        ypa=("yards_gained", "mean"),
        pass_td=("pass_touchdown", "sum")
    )
    .reset_index())
def_vs_wr["wr_rank"] = def_vs_wr["pass_epa_allowed"].rank()

# Combine
def_rankings = def_vs_rb[["defteam", "rush_epa_allowed", "rb_rank"]].merge(
    def_vs_wr[["defteam", "pass_epa_allowed", "wr_rank"]], on="defteam")

def rb_matchup(rank):
    if rank <= 8: return "Tough"
    elif rank <= 24: return "Average"
    else: return "Favorable"

def_rankings["rb_matchup"] = def_rankings["rb_rank"].apply(rb_matchup)
def_rankings["wr_matchup"] = def_rankings["wr_rank"].apply(rb_matchup)

print("Defensive Matchup Rankings:")
print(def_rankings.sort_values("rb_rank"))

import nfl_data_py as nfl
import pandas as pd

pbp = nfl.import_pbp_data([2023])

# Get weekly touches
skill_plays = pbp[(pbp["receiver_player_id"].notna()) | (pbp["rusher_player_id"].notna())].copy()
skill_plays["player_id"] = skill_plays["receiver_player_id"].fillna(skill_plays["rusher_player_id"])
skill_plays["player_name"] = skill_plays["receiver_player_name"].fillna(skill_plays["rusher_player_name"])

weekly = (skill_plays.groupby(["player_id", "player_name", "week", "posteam"])
    .agg(
        touches=("play_id", "count"),
        rush_yards=("rushing_yards", "sum"),
        rush_tds=("rush_touchdown", "sum"),
        receptions=("complete_pass", "sum"),
        rec_yards=("receiving_yards", "sum"),
        rec_tds=("pass_touchdown", "sum")
    )
    .reset_index())

weekly["fantasy_pts"] = (weekly["rush_yards"] * 0.1 + weekly["rush_tds"] * 6 +
                          weekly["receptions"] * 1 + weekly["rec_yards"] * 0.1 +
                          weekly["rec_tds"] * 6)

# Calculate trends
max_week = weekly["week"].max()
early = weekly[weekly["week"] <= 3].groupby(["player_id", "player_name"]).agg(
    avg_touches_early=("touches", "mean"),
    avg_pts_early=("fantasy_pts", "mean")
).reset_index()

recent = weekly[weekly["week"] >= max_week - 2].groupby(["player_id", "player_name"]).agg(
    avg_touches_recent=("touches", "mean"),
    avg_pts_recent=("fantasy_pts", "mean")
).reset_index()

trending = early.merge(recent, on=["player_id", "player_name"])
trending["touch_trend"] = trending["avg_touches_recent"] - trending["avg_touches_early"]
trending["pts_trend"] = trending["avg_pts_recent"] - trending["avg_pts_early"]

# Filter out established stars
trending = trending[trending["avg_pts_recent"] < 15]
trending = trending.sort_values("touch_trend", ascending=False)

print("Waiver Wire Gems (Increasing Opportunity):")
print(trending[["player_name", "avg_touches_early", "avg_touches_recent", "touch_trend", "pts_trend"]].head(15))

import nfl_data_py as nfl
import pandas as pd
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score, brier_score_loss

pbp = nfl.import_pbp_data([2023])

# Prepare data
model_data = pbp[
    pbp["score_differential"].notna() &
    pbp["wp"].notna()
][["home_team", "posteam", "game_seconds_remaining",
   "score_differential", "down", "ydstogo", "yardline_100",
   "posteam_timeouts_remaining", "wp"]].dropna()

model_data["is_home"] = (model_data["posteam"] == model_data["home_team"]).astype(int)

# Features and target
features = ["score_differential", "game_seconds_remaining", "is_home",
            "down", "ydstogo", "yardline_100", "posteam_timeouts_remaining"]
X = model_data[features]
y = (model_data["wp"] > 0.5).astype(int)

# Train/test split
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

# Fit model
model = LogisticRegression(max_iter=1000)
model.fit(X_train, y_train)

# Evaluate
y_pred = model.predict(X_test)
y_prob = model.predict_proba(X_test)[:, 1]

print(f"Accuracy: {accuracy_score(y_test, y_pred) * 100:.1f}%")
print(f"Brier Score: {brier_score_loss(y_test, y_prob):.4f}")

import nfl_data_py as nfl
import pandas as pd
from sklearn.cluster import KMeans
from sklearn.preprocessing import StandardScaler

pbp = nfl.import_pbp_data([2023])

# Create receiver profiles
pass_plays = pbp[(pbp["receiver_player_id"].notna()) &
                 (pbp["play_type"] == "pass")]

receiver_profiles = (pass_plays.groupby(
    ["receiver_player_id", "receiver_player_name"])
    .agg(
        targets=("play_id", "count"),
        catch_rate=("complete_pass", "mean"),
        avg_depth=("air_yards", "mean"),
        yac_per_rec=("yards_after_catch", lambda x: x[pass_plays.loc[x.index, "complete_pass"] == 1].mean())
    )
    .reset_index()
    .dropna())

receiver_profiles = receiver_profiles[receiver_profiles["targets"] >= 40]

# Scale features
features = receiver_profiles[["catch_rate", "avg_depth", "yac_per_rec"]]
scaler = StandardScaler()
scaled_features = scaler.fit_transform(features)

# K-means clustering
kmeans = KMeans(n_clusters=4, random_state=42, n_init=25)
receiver_profiles["cluster"] = kmeans.fit_predict(scaled_features)

# Analyze clusters
cluster_summary = (receiver_profiles.groupby("cluster")
    .agg(
        n_players=("receiver_player_name", "count"),
        avg_catch_rate=("catch_rate", "mean"),
        avg_depth=("avg_depth", "mean"),
        avg_yac=("yac_per_rec", "mean")
    )
    .reset_index())

print(cluster_summary)

import nfl_data_py as nfl
import pandas as pd
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score, classification_report

pbp = nfl.import_pbp_data([2023])

# Prepare data
model_data = pbp[
    (pbp["play_type"].isin(["pass", "run"])) &
    (pbp["down"].notna())
].copy()

model_data["is_pass"] = (model_data["play_type"] == "pass").astype(int)
model_data["is_home"] = (model_data["posteam"] == model_data["home_team"]).astype(int)

features = ["down", "ydstogo", "yardline_100", "score_differential",
            "game_seconds_remaining", "is_home"]
model_data = model_data[features + ["is_pass"]].dropna()

# Split data
X = model_data[features]
y = model_data["is_pass"]
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Train model
rf = RandomForestClassifier(n_estimators=100, random_state=42)
rf.fit(X_train, y_train)

# Evaluate
y_pred = rf.predict(X_test)
print(f"Accuracy: {accuracy_score(y_test, y_pred) * 100:.1f}%")
print("\nFeature Importance:")
importance = pd.DataFrame({
    "feature": features,
    "importance": rf.feature_importances_
}).sort_values("importance", ascending=False)
print(importance)

import nfl_data_py as nfl
import pandas as pd
import xgboost as xgb
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

pbp = nfl.import_pbp_data([2020, 2021, 2022, 2023])
schedules = nfl.import_schedules([2020, 2021, 2022, 2023])

# Calculate team metrics
plays = pbp[(pbp["epa"].notna()) & (pbp["play_type"].isin(["pass", "run"]))]

team_off = (plays.groupby(["season", "posteam"])
    .agg(off_epa=("epa", "mean"), pass_rate=("play_type", lambda x: (x == "pass").mean()))
    .reset_index())

team_def = (plays.groupby(["season", "defteam"])
    .agg(def_epa=("epa", "mean"))
    .reset_index())

team_metrics = team_off.merge(team_def, left_on=["season", "posteam"],
                               right_on=["season", "defteam"])

# Create game features
games = schedules[schedules["result"].notna()].copy()
games = games.merge(team_metrics[["season", "posteam", "off_epa", "def_epa", "pass_rate"]],
                    left_on=["season", "home_team"], right_on=["season", "posteam"])
games = games.rename(columns={"off_epa": "home_off", "def_epa": "home_def", "pass_rate": "home_pass"})
games = games.merge(team_metrics[["season", "posteam", "off_epa", "def_epa", "pass_rate"]],
                    left_on=["season", "away_team"], right_on=["season", "posteam"])
games = games.rename(columns={"off_epa": "away_off", "def_epa": "away_def", "pass_rate": "away_pass"})

games["home_win"] = (games["result"] > 0).astype(int)
features = ["home_off", "home_def", "home_pass", "away_off", "away_def", "away_pass"]
games = games[features + ["home_win"]].dropna()

# Train XGBoost
X_train, X_test, y_train, y_test = train_test_split(
    games[features], games["home_win"], test_size=0.2, random_state=42)

model = xgb.XGBClassifier(n_estimators=100, use_label_encoder=False, eval_metric="logloss")
model.fit(X_train, y_train)

y_pred = model.predict(X_test)
print(f"Accuracy: {accuracy_score(y_test, y_pred) * 100:.1f}%")
print("\nFeature Importance:")
print(pd.DataFrame({"feature": features, "importance": model.feature_importances_}).sort_values("importance", ascending=False))

import nfl_data_py as nfl
import pandas as pd
import numpy as np

pbp = nfl.import_pbp_data([2023])

# Create advanced features
plays = pbp[(pbp["epa"].notna()) & (pbp["play_type"].isin(["pass", "run"]))].copy()

# Situational features
plays["is_neutral"] = plays["score_differential"].abs() <= 7
plays["is_garbage_time"] = (
    ((plays["qtr"] == 4) & (plays["score_differential"].abs() > 21)) |
    ((plays["qtr"] >= 4) & (plays["game_seconds_remaining"] < 120) &
     (plays["score_differential"].abs() > 14))
)
plays["is_two_minute"] = (plays["game_seconds_remaining"] <= 120) & (plays["qtr"].isin([2, 4]))
plays["is_redzone"] = plays["yardline_100"] <= 20
plays["is_third_or_fourth"] = plays["down"] >= 3

# Distance buckets
def distance_bucket(yd):
    if yd <= 3: return "short"
    elif yd <= 7: return "medium"
    elif yd <= 10: return "long"
    else: return "very_long"

plays["distance_bucket"] = plays["ydstogo"].apply(distance_bucket)

# Field position buckets
def field_bucket(yd):
    if yd >= 80: return "own_deep"
    elif yd >= 50: return "own_side"
    elif yd >= 20: return "opponent"
    else: return "redzone"

plays["field_bucket"] = plays["yardline_100"].apply(field_bucket)

# Time features
plays["game_pct_complete"] = 1 - (plays["game_seconds_remaining"] / 3600)
plays["half"] = np.where(plays["qtr"] <= 2, 1, 2)

# Show feature distribution
feature_dist = (plays.groupby(["distance_bucket", "field_bucket"])
    .agg(
        plays=("epa", "count"),
        pass_rate=("play_type", lambda x: (x == "pass").mean()),
        avg_epa=("epa", "mean")
    )
    .reset_index())

print(feature_dist)

import nfl_data_py as nfl
import pandas as pd
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score
from sklearn.model_selection import TimeSeriesSplit

pbp = nfl.import_pbp_data([2020, 2021, 2022, 2023])

# Prepare data
model_data = pbp[
    (pbp["play_type"].isin(["pass", "run"])) &
    (pbp["down"].notna()) &
    (pbp["epa"].notna())
].copy()

model_data["is_pass"] = (model_data["play_type"] == "pass").astype(int)
features = ["down", "ydstogo", "yardline_100", "score_differential", "game_seconds_remaining"]
model_data = model_data[["season", "week"] + features + ["is_pass"]].dropna()

# Time-series cross-validation (train on past, test on future)
results = []
for test_year in [2021, 2022, 2023]:
    train = model_data[model_data["season"] < test_year]
    test = model_data[model_data["season"] == test_year]

    X_train, y_train = train[features], train["is_pass"]
    X_test, y_test = test[features], test["is_pass"]

    model = LogisticRegression(max_iter=1000)
    model.fit(X_train, y_train)
    y_pred = model.predict(X_test)

    accuracy = accuracy_score(y_test, y_pred)
    results.append(accuracy)
    print(f"Test Year: {test_year} - Accuracy: {accuracy * 100:.1f}%")

print(f"\nAverage Accuracy: {sum(results) / len(results) * 100:.1f}%")

# Alternative: sklearn TimeSeriesSplit
print("\nTimeSeriesSplit (3-fold):")
tscv = TimeSeriesSplit(n_splits=3)
X = model_data[features]
y = model_data["is_pass"]

for i, (train_idx, test_idx) in enumerate(tscv.split(X)):
    X_train, X_test = X.iloc[train_idx], X.iloc[test_idx]
    y_train, y_test = y.iloc[train_idx], y.iloc[test_idx]

    model = LogisticRegression(max_iter=1000)
    model.fit(X_train, y_train)
    acc = accuracy_score(y_test, model.predict(X_test))
    print(f"Fold {i+1}: {acc * 100:.1f}%")

import nfl_data_py as nfl
import pandas as pd
import numpy as np
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import (brier_score_loss, log_loss, roc_auc_score,
                             accuracy_score, confusion_matrix)

pbp = nfl.import_pbp_data([2023])
schedules = nfl.import_schedules([2023])

# Prepare data
model_data = pbp[
    (pbp["wp"].notna()) &
    (pbp["score_differential"].notna())
][["game_id", "wp", "score_differential", "game_seconds_remaining", "posteam"]].dropna()

# Get actual outcomes
outcomes = schedules[schedules["result"].notna()][["game_id", "home_team", "result"]].copy()
outcomes["home_win"] = outcomes["result"] > 0

model_data = model_data.merge(outcomes, on="game_id")
model_data["actual_win"] = (
    ((model_data["posteam"] == model_data["home_team"]) & model_data["home_win"]) |
    ((model_data["posteam"] != model_data["home_team"]) & ~model_data["home_win"])
).astype(int)

# Simple model
X = model_data[["score_differential", "game_seconds_remaining"]]
y = model_data["actual_win"]

model = LogisticRegression(max_iter=1000)
model.fit(X, y)
pred_wp = model.predict_proba(X)[:, 1]

# Evaluation metrics
print("Model Evaluation Metrics:")
print(f"Brier Score: {brier_score_loss(y, pred_wp):.4f}")
print(f"Log Loss: {log_loss(y, pred_wp):.4f}")
print(f"AUC-ROC: {roc_auc_score(y, pred_wp):.4f}")
print(f"Accuracy: {accuracy_score(y, (pred_wp > 0.5).astype(int)) * 100:.1f}%")

# Calibration
model_data["pred_wp"] = pred_wp
model_data["wp_bucket"] = pd.cut(pred_wp, bins=np.arange(0, 1.1, 0.1))

calibration = (model_data.groupby("wp_bucket")
    .agg(n=("actual_win", "count"),
         predicted=("pred_wp", "mean"),
         actual=("actual_win", "mean"))
    .reset_index())

print("\nCalibration by Probability Bucket:")
print(calibration)

import nfl_data_py as nfl
import pandas as pd
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import GridSearchCV, cross_val_score
from sklearn.metrics import make_scorer, roc_auc_score

pbp = nfl.import_pbp_data([2023])

# Prepare data
model_data = pbp[
    (pbp["play_type"].isin(["pass", "run"])) &
    (pbp["down"].notna())
].copy()

model_data["is_pass"] = (model_data["play_type"] == "pass").astype(int)
features = ["down", "ydstogo", "yardline_100", "score_differential", "game_seconds_remaining"]
model_data = model_data[features + ["is_pass"]].dropna()

# Subsample for speed
model_data = model_data.sample(n=min(10000, len(model_data)), random_state=42)
X = model_data[features]
y = model_data["is_pass"]

# Define hyperparameter grid
param_grid = {
    "n_estimators": [50, 100, 200],
    "max_depth": [5, 10, 15, None],
    "min_samples_split": [2, 5, 10],
    "min_samples_leaf": [1, 2, 4]
}

# Smaller grid for faster demo
small_grid = {
    "n_estimators": [50, 100],
    "max_depth": [5, 10],
    "min_samples_split": [2, 5]
}

# Grid search with cross-validation
rf = RandomForestClassifier(random_state=42)
grid_search = GridSearchCV(
    rf,
    small_grid,
    cv=5,
    scoring="roc_auc",
    n_jobs=-1,
    verbose=1
)

grid_search.fit(X, y)

# Results
print(f"\nBest Parameters: {grid_search.best_params_}")
print(f"Best CV Score (AUC): {grid_search.best_score_:.4f}")

# All results
results = pd.DataFrame(grid_search.cv_results_)
print("\nTop 5 Parameter Combinations:")
print(results.nsmallest(5, "rank_test_score")[["params", "mean_test_score", "std_test_score"]])

import nfl_data_py as nfl
import pandas as pd
import numpy as np
from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier, VotingClassifier, StackingClassifier
from sklearn.neighbors import KNeighborsClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

pbp = nfl.import_pbp_data([2023])

# Prepare data
model_data = pbp[
    (pbp["play_type"].isin(["pass", "run"])) &
    (pbp["down"].notna())
].copy()

model_data["is_pass"] = (model_data["play_type"] == "pass").astype(int)
features = ["down", "ydstogo", "yardline_100", "score_differential", "game_seconds_remaining"]
model_data = model_data[features + ["is_pass"]].dropna()
model_data = model_data.sample(n=min(5000, len(model_data)), random_state=42)

X = model_data[features]
y = model_data["is_pass"]
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Individual models
lr = LogisticRegression(max_iter=1000)
rf = RandomForestClassifier(n_estimators=100, random_state=42)
knn = KNeighborsClassifier(n_neighbors=5)

# Train and evaluate individually
results = []
for name, model in [("Logistic", lr), ("Random Forest", rf), ("KNN", knn)]:
    model.fit(X_train, y_train)
    acc = accuracy_score(y_test, model.predict(X_test))
    results.append({"Model": name, "Accuracy": acc})

# Voting Ensemble
voting = VotingClassifier(
    estimators=[("lr", lr), ("rf", rf), ("knn", knn)],
    voting="soft"
)
voting.fit(X_train, y_train)
results.append({"Model": "Voting Ensemble", "Accuracy": accuracy_score(y_test, voting.predict(X_test))})

# Stacking Ensemble
stacking = StackingClassifier(
    estimators=[("lr", LogisticRegression(max_iter=1000)),
                ("rf", RandomForestClassifier(n_estimators=50))],
    final_estimator=LogisticRegression()
)
stacking.fit(X_train, y_train)
results.append({"Model": "Stacking Ensemble", "Accuracy": accuracy_score(y_test, stacking.predict(X_test))})

print("Model Comparison:")
print(pd.DataFrame(results).sort_values("Accuracy", ascending=False))

import nfl_data_py as nfl
import pandas as pd
import numpy as np
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split
from sklearn.neural_network import MLPRegressor
from sklearn.metrics import mean_absolute_error, mean_squared_error

pbp = nfl.import_pbp_data([2020, 2021, 2022, 2023])
schedules = nfl.import_schedules([2020, 2021, 2022, 2023])

# Calculate team features
plays = pbp[(pbp["epa"].notna()) & (pbp["play_type"].isin(["pass", "run"]))]

team_off = (plays.groupby(["season", "posteam"])
    .agg(off_epa=("epa", "mean"), pass_rate=("play_type", lambda x: (x == "pass").mean()))
    .reset_index())

team_def = (plays.groupby(["season", "defteam"])
    .agg(def_epa=("epa", "mean"))
    .reset_index())

team_features = team_off.merge(team_def, left_on=["season", "posteam"],
                                right_on=["season", "defteam"])

# Create game dataset
games = schedules[(schedules["result"].notna()) & (schedules["spread_line"].notna())].copy()
games = games.merge(team_features[["season", "posteam", "off_epa", "def_epa"]],
                    left_on=["season", "home_team"], right_on=["season", "posteam"])
games = games.rename(columns={"off_epa": "home_off", "def_epa": "home_def"})
games = games.merge(team_features[["season", "posteam", "off_epa", "def_epa"]],
                    left_on=["season", "away_team"], right_on=["season", "posteam"])
games = games.rename(columns={"off_epa": "away_off", "def_epa": "away_def"})

games["spread_error"] = games["result"] + games["spread_line"]
features = ["home_off", "home_def", "away_off", "away_def"]
games = games[features + ["spread_error"]].dropna()

# Scale and split
X = games[features]
y = games["spread_error"]
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

X_train, X_test, y_train, y_test = train_test_split(X_scaled, y, test_size=0.2, random_state=42)

# Train neural network
nn = MLPRegressor(hidden_layer_sizes=(16, 8), max_iter=500, random_state=42, early_stopping=True)
nn.fit(X_train, y_train)

# Evaluate
predictions = nn.predict(X_test)
mae = mean_absolute_error(y_test, predictions)
rmse = np.sqrt(mean_squared_error(y_test, predictions))
correct_side = ((predictions > 0) == (y_test > 0)).mean()

print(f"MAE: {mae:.2f}")
print(f"RMSE: {rmse:.2f}")
print(f"Correct Side %: {correct_side * 100:.1f}%")

import nfl_data_py as nfl
import pandas as pd

pbp = nfl.import_pbp_data([2023])

# Play type distribution
play_types = (pbp[pbp["play_type"].notna()]
    .groupby("play_type")
    .size()
    .reset_index(name="count")
    .sort_values("count", ascending=False))

play_types["pct"] = play_types["count"] / play_types["count"].sum() * 100
print("Play Type Distribution:")
print(play_types)

# Play type by down
by_down = (pbp[(pbp["play_type"].isin(["pass", "run"])) & (pbp["down"].notna())]
    .groupby("down")
    .agg(
        plays=("play_type", "count"),
        pass_rate=("play_type", lambda x: (x == "pass").mean() * 100)
    )
    .reset_index())

print("\nPass Rate by Down:")
print(by_down)

import nfl_data_py as nfl
import pandas as pd

pbp = nfl.import_pbp_data([2023])

# Formation usage
plays = pbp[(pbp["offense_formation"].notna()) & (pbp["play_type"].isin(["pass", "run"]))]

formation_usage = (plays.groupby("offense_formation")
    .agg(
        plays=("epa", "count"),
        pass_rate=("play_type", lambda x: (x == "pass").mean() * 100),
        epa=("epa", "mean"),
        success_rate=("success", lambda x: x.mean() * 100)
    )
    .reset_index())

formation_usage = formation_usage[formation_usage["plays"] >= 100].sort_values("plays", ascending=False)
print("Formation Usage:")
print(formation_usage)

import nfl_data_py as nfl
import pandas as pd

pbp = nfl.import_pbp_data([2023])

# Personnel grouping analysis
plays = pbp[(pbp["offense_personnel"].notna()) & (pbp["play_type"].isin(["pass", "run"]))]

personnel = (plays.groupby("offense_personnel")
    .agg(
        plays=("epa", "count"),
        pass_rate=("play_type", lambda x: (x == "pass").mean() * 100),
        epa=("epa", "mean")
    )
    .reset_index())

personnel = personnel[personnel["plays"] >= 200].sort_values("plays", ascending=False)
print("Personnel Grouping Usage:")
print(personnel)

import nfl_data_py as nfl
import pandas as pd

pbp = nfl.import_pbp_data([2023])

# Game script analysis
plays = pbp[(pbp["play_type"].isin(["pass", "run"])) & (pbp["score_differential"].notna())].copy()

def get_script(diff):
    if diff >= 14: return "Up 14+"
    elif diff >= 7: return "Up 7-13"
    elif diff >= 1: return "Up 1-6"
    elif diff == 0: return "Tied"
    elif diff >= -6: return "Down 1-6"
    elif diff >= -13: return "Down 7-13"
    else: return "Down 14+"

plays["script"] = plays["score_differential"].apply(get_script)

game_script = (plays.groupby("script")
    .agg(
        plays=("epa", "count"),
        pass_rate=("play_type", lambda x: (x == "pass").mean() * 100),
        epa=("epa", "mean")
    )
    .reset_index())

# Order properly
order = ["Down 14+", "Down 7-13", "Down 1-6", "Tied", "Up 1-6", "Up 7-13", "Up 14+"]
game_script["script"] = pd.Categorical(game_script["script"], categories=order, ordered=True)
game_script = game_script.sort_values("script")

print("Game Script Analysis:")
print(game_script)

import nfl_data_py as nfl
import pandas as pd

pbp = nfl.import_pbp_data([2023])

# No-huddle analysis
plays = pbp[(pbp["play_type"].isin(["pass", "run"])) & (pbp["no_huddle"].notna())].copy()
plays["huddle_type"] = plays["no_huddle"].apply(lambda x: "No-Huddle" if x == 1 else "Huddle")

no_huddle = (plays.groupby("huddle_type")
    .agg(
        plays=("epa", "count"),
        pass_rate=("play_type", lambda x: (x == "pass").mean() * 100),
        epa=("epa", "mean"),
        success_rate=("success", lambda x: x.mean() * 100)
    )
    .reset_index())

print("No-Huddle vs Huddle:")
print(no_huddle)

# Team usage
team_nh = (plays[plays["no_huddle"] == 1]
    .groupby("posteam")
    .agg(plays=("epa", "count"), epa=("epa", "mean"))
    .reset_index()
    .sort_values("plays", ascending=False))

print("\nTop No-Huddle Teams:")
print(team_nh.head(10))

import nfl_data_py as nfl
import pandas as pd

pbp = nfl.import_pbp_data([2023])

# Shotgun analysis
plays = pbp[(pbp["play_type"].isin(["pass", "run"])) & (pbp["shotgun"].notna())].copy()
plays["formation"] = plays["shotgun"].apply(lambda x: "Shotgun" if x == 1 else "Under Center")

shotgun_analysis = (plays.groupby("formation")
    .agg(
        plays=("epa", "count"),
        pass_rate=("play_type", lambda x: (x == "pass").mean() * 100),
        epa=("epa", "mean"),
        success_rate=("success", lambda x: x.mean() * 100)
    )
    .reset_index())

shotgun_analysis["pct"] = shotgun_analysis["plays"] / shotgun_analysis["plays"].sum() * 100
print("Shotgun vs Under Center:")
print(shotgun_analysis)

# By play type
by_type = (plays.groupby(["formation", "play_type"])
    .agg(plays=("epa", "count"), epa=("epa", "mean"))
    .reset_index())

print("\nBy Play Type:")
print(by_type)

import nfl_data_py as nfl
import pandas as pd

pbp = nfl.import_pbp_data([2023])

# Motion analysis
plays = pbp[(pbp["play_type"].isin(["pass", "run"]))].copy()

motion = plays[plays["is_motion"] == 1]
no_motion = plays[(plays["is_motion"] != 1) | (plays["is_motion"].isna())]

print("Motion Impact on Play Success:")
print(f"With Motion: {len(motion)} plays, EPA: {motion[\"epa\"].mean():.3f}")
print(f"No Motion: {len(no_motion)} plays, EPA: {no_motion[\"epa\"].mean():.3f}")

# Team motion usage
def calc_motion_stats(group):
    motion_plays = group[group["is_motion"] == 1]
    return pd.Series({
        "total_plays": len(group),
        "motion_plays": len(motion_plays),
        "motion_rate": len(motion_plays) / len(group) * 100 if len(group) > 0 else 0,
        "motion_epa": motion_plays["epa"].mean() if len(motion_plays) > 0 else 0
    })

team_motion = plays.groupby("posteam").apply(calc_motion_stats).reset_index()
team_motion = team_motion.sort_values("motion_rate", ascending=False)

print("\nTeam Motion Usage:")
print(team_motion.head(10))

import nfl_data_py as nfl
import pandas as pd

pbp = nfl.import_pbp_data([2023])

# Filter and sort
plays = pbp[pbp["play_type"].isin(["pass", "run"])].copy()
plays = plays.sort_values(["game_id", "play_id"])

# Add previous play info
plays["prev_play"] = plays.groupby(["game_id", "posteam"])["play_type"].shift(1)
plays["prev_success"] = plays.groupby(["game_id", "posteam"])["success"].shift(1)

plays = plays[plays["prev_play"].notna()]

# After success/failure
plays["prev_result"] = plays["prev_success"].apply(
    lambda x: "After Success" if x == 1 else "After Failure")

after_result = (plays.groupby("prev_result")
    .agg(
        plays=("epa", "count"),
        pass_rate=("play_type", lambda x: (x == "pass").mean() * 100),
        epa=("epa", "mean")
    )
    .reset_index())

print("Play Calling After Success/Failure:")
print(after_result)

# Sequences
plays["sequence"] = plays["prev_play"] + " -> " + plays["play_type"]
sequences = (plays.groupby("sequence")
    .agg(
        plays=("epa", "count"),
        epa=("epa", "mean"),
        success_rate=("success", lambda x: x.mean() * 100)
    )
    .reset_index()
    .sort_values("plays", ascending=False))

print("\nPlay Sequences:")
print(sequences)

import nfl_data_py as nfl
import pandas as pd

pbp = nfl.import_pbp_data([2023])

# Fourth down decisions
fourth = pbp[(pbp["down"] == 4) & (pbp["play_type"].notna())].copy()

def get_decision(play_type):
    if play_type in ["pass", "run"]: return "Go for it"
    elif play_type == "field_goal": return "Field Goal"
    elif play_type == "punt": return "Punt"
    else: return "Other"

fourth["decision"] = fourth["play_type"].apply(get_decision)
fourth = fourth[fourth["decision"] != "Other"]

# Decision by field position
def get_zone(yd):
    if yd <= 3: return "Goal line (1-3)"
    elif yd <= 10: return "Red zone (4-10)"
    elif yd <= 40: return "Opp territory"
    elif yd <= 60: return "Midfield"
    else: return "Own territory"

fourth["zone"] = fourth["yardline_100"].apply(get_zone)

decision_analysis = (fourth.groupby(["zone", "decision"])
    .size()
    .reset_index(name="plays")
    .pivot(index="zone", columns="decision", values="plays")
    .fillna(0))

print("Fourth Down Decisions by Field Position:")
print(decision_analysis)

# Go-for-it success rate
go_for_it = fourth[fourth["decision"] == "Go for it"]
success_rate = ((go_for_it["first_down"] == 1) | (go_for_it["touchdown"] == 1)).mean() * 100
print(f"\nGo-for-it Success Rate: {success_rate:.1f}%")

import nfl_data_py as nfl
import pandas as pd

pbp = nfl.import_pbp_data([2019, 2020, 2021, 2022, 2023])

# Two-point conversions
two_point = pbp[pbp["two_point_attempt"] == 1].copy()

# Overall success rate
success = (two_point["two_point_conv_result"] == "success")
print(f"Overall 2PT Success Rate: {success.mean() * 100:.1f}% ({success.sum()}/{len(two_point)})")

# By play type
by_type = (two_point[two_point["play_type"].isin(["pass", "run"])]
    .groupby("play_type")
    .agg(
        attempts=("two_point_conv_result", "count"),
        successes=("two_point_conv_result", lambda x: (x == "success").sum()),
        success_rate=("two_point_conv_result", lambda x: (x == "success").mean() * 100)
    )
    .reset_index())

print("\nBy Play Type:")
print(by_type)

import nfl_data_py as nfl
import pandas as pd

pbp = nfl.import_pbp_data([2023])

# Late game clock management
late_game = pbp[
    (pbp["qtr"] == 4) &
    (pbp["game_seconds_remaining"] <= 300) &
    (pbp["score_differential"].abs() <= 8) &
    (pbp["play_type"].isin(["pass", "run"]))
].copy()

def get_situation(diff):
    if diff > 0: return "Leading"
    elif diff < 0: return "Trailing"
    else: return "Tied"

late_game["situation"] = late_game["score_differential"].apply(get_situation)

late_plays = (late_game.groupby("situation")
    .agg(
        plays=("epa", "count"),
        pass_rate=("play_type", lambda x: (x == "pass").mean() * 100)
    )
    .reset_index())

print("Late Game Play Selection:")
print(late_plays)

import nfl_data_py as nfl
import pandas as pd

pbp = nfl.import_pbp_data([2023])

# Filter timeouts
timeouts = pbp[pbp["timeout"] == 1].copy()
timeouts["half"] = timeouts["qtr"].apply(lambda x: "First Half" if x <= 2 else "Second Half")
timeouts["close_game"] = timeouts["score_differential"].abs() <= 8

# Distribution by quarter
timeout_dist = (timeouts.groupby(["half", "qtr"])
    .size()
    .reset_index(name="timeouts"))

print("Timeout Distribution by Quarter:")
print(timeout_dist)

# Team patterns
team_timeouts = (timeouts.groupby("timeout_team")
    .agg(
        total_timeouts=("timeout", "count"),
        first_half=("half", lambda x: (x == "First Half").sum()),
        second_half=("half", lambda x: (x == "Second Half").sum()),
        close_games=("close_game", "sum"),
        avg_time_remaining=("game_seconds_remaining", "mean")
    )
    .reset_index()
    .sort_values("total_timeouts", ascending=False))

print("\nTeam Timeout Usage:")
print(team_timeouts)

import nfl_data_py as nfl
import pandas as pd

pbp = nfl.import_pbp_data([2019, 2020, 2021, 2022, 2023])

# Replay reviews
replays = pbp[pbp["replay_or_challenge_result"].notna()].copy()
replays["overturned"] = replays["replay_or_challenge_result"] == "overturned"

# Overall success rate
total = len(replays)
overturned = replays["overturned"].sum()
print(f"Overall Challenge Success: {overturned}/{total} ({overturned/total*100:.1f}%)")

# By year
by_year = (replays.groupby("season")
    .agg(
        reviews=("overturned", "count"),
        overturned=("overturned", "sum"),
        rate=("overturned", lambda x: x.mean() * 100)
    )
    .reset_index())

print("\nChallenge Success by Year:")
print(by_year)

# By play type
by_type = (replays.groupby("play_type")
    .agg(
        reviews=("overturned", "count"),
        rate=("overturned", lambda x: x.mean() * 100)
    )
    .reset_index())

by_type = by_type[by_type["reviews"] >= 10].sort_values("rate", ascending=False)
print("\nSuccess Rate by Play Type:")
print(by_type)

import nfl_data_py as nfl
import pandas as pd

pbp = nfl.import_pbp_data([2023])

# Penalty analysis
penalties = pbp[pbp["penalty"] == 1]

# Most common
common = (penalties[penalties["penalty_type"].notna()]
    .groupby("penalty_type")
    .size()
    .reset_index(name="count")
    .sort_values("count", ascending=False)
    .head(15))

print("Most Common Penalties:")
print(common)

# Team penalty rates
plays = pbp[pbp["play_type"].isin(["pass", "run", "no_play"])].copy()

def calc_team_penalties(group):
    team = group.name
    team_penalties = group[(group["penalty"] == 1) & (group["penalty_team"] == team)]
    return pd.Series({
        "plays": len(group),
        "penalties": len(team_penalties),
        "penalty_rate": len(team_penalties) / len(group) * 100 if len(group) > 0 else 0,
        "penalty_yards": team_penalties["penalty_yards"].sum()
    })

team_penalties = plays.groupby("posteam").apply(calc_team_penalties).reset_index()
team_penalties = team_penalties.sort_values("penalty_rate", ascending=False)

print("\nTeam Penalty Rates:")
print(team_penalties)

# EPA impact
plays["had_penalty"] = plays["penalty"] == 1
penalty_impact = (plays.groupby("had_penalty")
    .agg(plays=("epa", "count"), avg_epa=("epa", "mean"))
    .reset_index())

print("\nEPA Impact of Penalties:")
print(penalty_impact)

import nfl_data_py as nfl
import pandas as pd

pbp = nfl.import_pbp_data([2023])

# Weekly EPA
plays = pbp[(pbp["epa"].notna()) & (pbp["play_type"].isin(["pass", "run"]))]

weekly_epa = (plays.groupby(["posteam", "week"])
    .agg(
        plays=("epa", "count"),
        epa_per_play=("epa", "mean"),
        success_rate=("success", lambda x: x.mean() * 100)
    )
    .reset_index())

# Compare early vs late season
early = weekly_epa[weekly_epa["week"] <= 3].groupby("posteam")["epa_per_play"].mean()
late = weekly_epa[weekly_epa["week"] >= 15].groupby("posteam")["epa_per_play"].mean()

trends = pd.DataFrame({"early_epa": early, "late_epa": late})
trends["improvement"] = trends["late_epa"] - trends["early_epa"]
trends = trends.sort_values("improvement", ascending=False).reset_index()

print("Most Improved Teams:")
print(trends.head(5))
print("\nDeclined Most:")
print(trends.tail(5))

import nfl_data_py as nfl
import pandas as pd

pbp = nfl.import_pbp_data([2023])

# Home vs Away
plays = pbp[(pbp["epa"].notna()) & (pbp["play_type"].isin(["pass", "run"]))].copy()
plays["location"] = plays.apply(lambda x: "Home" if x["posteam"] == x["home_team"] else "Away", axis=1)

home_away = (plays.groupby(["posteam", "location"])
    .agg(
        plays=("epa", "count"),
        epa=("epa", "mean"),
        success_rate=("success", lambda x: x.mean() * 100)
    )
    .reset_index())

# Pivot
home = home_away[home_away["location"] == "Home"].set_index("posteam")
away = home_away[home_away["location"] == "Away"].set_index("posteam")

comparison = pd.DataFrame({
    "Home EPA": home["epa"],
    "Away EPA": away["epa"]
})
comparison["Home Advantage"] = comparison["Home EPA"] - comparison["Away EPA"]
comparison = comparison.sort_values("Home Advantage", ascending=False).reset_index()

print("Home vs Away Performance:")
print(comparison)

import nfl_data_py as nfl
import pandas as pd

schedules = nfl.import_schedules([2023])

# Calculate for each team
games = schedules[schedules["result"].notna()].copy()

# Home games
home = games[["home_team", "home_score", "away_score"]].copy()
home.columns = ["team", "points_for", "points_against"]

# Away games
away = games[["away_team", "away_score", "home_score"]].copy()
away.columns = ["team", "points_for", "points_against"]

all_games = pd.concat([home, away])
all_games["point_diff"] = all_games["points_for"] - all_games["points_against"]
all_games["win"] = all_games["point_diff"] > 0

point_diff = (all_games.groupby("team")
    .agg(
        games=("point_diff", "count"),
        wins=("win", "sum"),
        total_pf=("points_for", "sum"),
        total_pa=("points_against", "sum"),
        total_diff=("point_diff", "sum"),
        ppg=("points_for", "mean"),
        avg_diff=("point_diff", "mean")
    )
    .reset_index()
    .sort_values("total_diff", ascending=False))

print("Point Differential Rankings:")
print(point_diff)

import nfl_data_py as nfl
import pandas as pd
import numpy as np

schedules = nfl.import_schedules([2023])
games = schedules[schedules["result"].notna()].copy()

# Home games
home = games[["home_team", "home_score", "away_score"]].copy()
home.columns = ["team", "pf", "pa"]

# Away games
away = games[["away_team", "away_score", "home_score"]].copy()
away.columns = ["team", "pf", "pa"]

all_games = pd.concat([home, away])
all_games["win"] = all_games["pf"] > all_games["pa"]

# Aggregate
team_scoring = (all_games.groupby("team")
    .agg(
        games=("win", "count"),
        actual_wins=("win", "sum"),
        points_for=("pf", "sum"),
        points_against=("pa", "sum")
    )
    .reset_index())

# Pythagorean expectation
exp = 2.37
team_scoring["pyth_exp"] = (team_scoring["points_for"]**exp /
                             (team_scoring["points_for"]**exp + team_scoring["points_against"]**exp))
team_scoring["expected_wins"] = team_scoring["pyth_exp"] * team_scoring["games"]
team_scoring["luck"] = team_scoring["actual_wins"] - team_scoring["expected_wins"]

team_scoring = team_scoring.sort_values("luck", ascending=False)

print("Pythagorean Win Expectation:")
print(team_scoring[["team", "actual_wins", "expected_wins", "luck"]].round(1))

import nfl_data_py as nfl
import pandas as pd

schedules = nfl.import_schedules([2023])
teams = nfl.import_team_desc()

# Add division info
games = schedules[schedules["result"].notna()].copy()
games = games.merge(teams[["team_abbr", "team_division"]],
                     left_on="home_team", right_on="team_abbr", how="left")
games = games.rename(columns={"team_division": "home_div"}).drop("team_abbr", axis=1)
games = games.merge(teams[["team_abbr", "team_division"]],
                     left_on="away_team", right_on="team_abbr", how="left")
games = games.rename(columns={"team_division": "away_div"}).drop("team_abbr", axis=1)
games["division_game"] = games["home_div"] == games["away_div"]

# Create team-game records
home = games[["home_team", "away_team", "home_score", "away_score", "division_game"]].copy()
home.columns = ["team", "opponent", "pf", "pa", "division_game"]

away = games[["away_team", "home_team", "away_score", "home_score", "division_game"]].copy()
away.columns = ["team", "opponent", "pf", "pa", "division_game"]

all_games = pd.concat([home, away])
all_games["win"] = all_games["pf"] > all_games["pa"]
all_games["margin"] = all_games["pf"] - all_games["pa"]

# Division vs Non-Division
div_perf = (all_games.groupby(["team", "division_game"])
    .agg(games=("win", "count"), wins=("win", "sum"),
         win_pct=("win", lambda x: x.mean() * 100), avg_margin=("margin", "mean"))
    .reset_index())

div_games = div_perf[div_perf["division_game"]].set_index("team")["win_pct"]
non_div = div_perf[~div_perf["division_game"]].set_index("team")["win_pct"]

comparison = pd.DataFrame({"Division": div_games, "Non-Division": non_div})
comparison["Advantage"] = comparison["Division"] - comparison["Non-Division"]
comparison = comparison.sort_values("Advantage", ascending=False).reset_index()

print("Division vs Non-Division Performance:")
print(comparison)

import nfl_data_py as nfl
import pandas as pd

pbp = nfl.import_pbp_data([2020, 2021, 2022, 2023])

# Filter and categorize
plays = pbp[(pbp["play_type"].isin(["pass", "run"])) & (pbp["epa"].notna())].copy()
plays["game_type"] = plays["week"].apply(lambda x: "Regular Season" if x <= 18 else "Playoffs")

# Performance by game type
perf = (plays.groupby(["posteam", "game_type"])
    .agg(
        plays=("epa", "count"),
        epa_per_play=("epa", "mean"),
        success_rate=("success", lambda x: x.mean() * 100),
        pass_rate=("play_type", lambda x: (x == "pass").mean() * 100)
    )
    .reset_index())

perf = perf[perf["plays"] >= 100]

# Teams with playoff experience
playoff_teams = perf[perf["game_type"] == "Playoffs"]["posteam"].unique()
comparison = perf[perf["posteam"].isin(playoff_teams)].copy()

# Pivot
reg = comparison[comparison["game_type"] == "Regular Season"].set_index("posteam")["epa_per_play"]
playoff = comparison[comparison["game_type"] == "Playoffs"].set_index("posteam")["epa_per_play"]

result = pd.DataFrame({"Regular Season": reg, "Playoffs": playoff})
result["Playoff Bump"] = result["Playoffs"] - result["Regular Season"]
result = result.sort_values("Playoff Bump", ascending=False).reset_index()

print("Playoff vs Regular Season EPA (2020-2023):")
print(result)

import nfl_data_py as nfl
import pandas as pd

schedules = nfl.import_schedules([2023])
games = schedules[schedules["result"].notna()].copy()

# Calculate team records
home = games[["home_team", "home_score", "away_score"]].copy()
home.columns = ["team", "pf", "pa"]
home["win"] = home["pf"] > home["pa"]

away = games[["away_team", "away_score", "home_score"]].copy()
away.columns = ["team", "pf", "pa"]
away["win"] = away["pf"] > away["pa"]

all_games = pd.concat([home, away])
records = (all_games.groupby("team")
    .agg(wins=("win", "sum"), losses=("win", lambda x: (~x).sum()),
         win_pct=("win", "mean"))
    .reset_index())

# Calculate SOS
def calc_sos(team):
    home_opps = games[games["home_team"] == team]["away_team"].tolist()
    away_opps = games[games["away_team"] == team]["home_team"].tolist()
    opponents = home_opps + away_opps
    opp_records = records[records["team"].isin(opponents)]
    return opp_records["win_pct"].mean()

records["sos"] = records["team"].apply(calc_sos)
records = records.sort_values("sos", ascending=False)
records["rank"] = range(1, len(records) + 1)

print("Strength of Schedule Rankings:")
print(records[["rank", "team", "wins", "losses", "sos"]].round(3))

import nfl_data_py as nfl
import pandas as pd

# Load two seasons
pbp_2022 = nfl.import_pbp_data([2022])
pbp_2023 = nfl.import_pbp_data([2023])

def calc_team_epa(pbp, year):
    plays = pbp[(pbp["play_type"].isin(["pass", "run"])) & (pbp["epa"].notna())]
    return (plays.groupby("posteam")
        .agg(
            plays=("epa", "count"),
            epa_per_play=("epa", "mean"),
            success_rate=("success", lambda x: x.mean() * 100),
            pass_rate=("play_type", lambda x: (x == "pass").mean() * 100)
        )
        .reset_index()
        .rename(columns={"posteam": "team"})
        .assign(season=year))

epa_2022 = calc_team_epa(pbp_2022, 2022)
epa_2023 = calc_team_epa(pbp_2023, 2023)

# Merge and compare
comparison = epa_2022[["team", "epa_per_play", "success_rate"]].merge(
    epa_2023[["team", "epa_per_play", "success_rate"]],
    on="team",
    suffixes=("_2022", "_2023")
)

comparison["epa_change"] = comparison["epa_per_play_2023"] - comparison["epa_per_play_2022"]
comparison["sr_change"] = comparison["success_rate_2023"] - comparison["success_rate_2022"]
comparison = comparison.sort_values("epa_change", ascending=False)

print("Year-over-Year EPA Change (2022 to 2023):")
print(comparison.round(3))