Spaces:
Sleeping
Sleeping
| import gradio as gr | |
| import requests | |
| def map_teams_roof_surface(df): | |
| # --- Fixed team mapping (stable across all datasets) --- | |
| team_map = { | |
| "ARI": 1, "ATL": 2, "BAL": 3, "BUF": 4, | |
| "CAR": 5, "CHI": 6, "CIN": 7, "CLE": 8, | |
| "DAL": 9, "DEN": 10, "DET": 11, "GB": 12, | |
| "HOU": 13, "IND": 14, "JAX": 15, "KC": 16, | |
| "LV": 17, "LAC": 18, "LAR": 19, "MIA": 20, | |
| "MIN": 21, "NE": 22, "NO": 23, "NYG": 24, | |
| "NYJ": 25, "PHI": 26, "PIT": 27, "SEA": 28, | |
| "SF": 29, "TB": 30, "TEN": 31, "WAS": 32 | |
| } | |
| # --- Aliases for older team abbreviations --- | |
| alias_map = { | |
| "OAK": "LV", | |
| "SD": "LAC", | |
| "STL": "LAR", | |
| "WSH": "WAS" | |
| } | |
| # --- Surface mapping --- | |
| surface_map = { | |
| "a_turf": 1, | |
| "grass": 2, | |
| "sportturf": 3, | |
| "fieldturf": 4, | |
| "matrixturf": 5, | |
| "astroturf": 6, | |
| "0": 0 # unknown/missing | |
| } | |
| import json | |
| import ast | |
| # Load player mappings with fallback for single-quoted JSON | |
| try: | |
| with open("receiver_to_player_id.json", 'r') as f: | |
| content = f.read() | |
| try: | |
| # Try normal JSON first | |
| receiver_to_player_id = json.loads(content) | |
| except json.JSONDecodeError: | |
| # Fallback: treat as Python dict literal | |
| receiver_to_player_id = ast.literal_eval(content) | |
| with open("passer_to_player_id.json", 'r') as f: | |
| content = f.read() | |
| try: | |
| passer_to_player_id = json.loads(content) | |
| except json.JSONDecodeError: | |
| passer_to_player_id = ast.literal_eval(content) | |
| print(f"✓ Loaded {len(receiver_to_player_id)} receivers and {len(passer_to_player_id)} passers") | |
| except Exception as e: | |
| print(f"Error loading player mappings: {e}") | |
| receiver_to_player_id = {} | |
| passer_to_player_id = {} | |
| receiver_choices = sorted(list(receiver_to_player_id.keys())) | |
| passer_choices = sorted(list(receiver_to_player_id.keys())) | |
| import requests | |
| from datetime import datetime, timedelta | |
| # Stadium coordinates | |
| STADIUM_COORDS = { | |
| "ARI": {"lat": 33.5276, "lon": -112.2626, "name": "State Farm Stadium"}, | |
| "ATL": {"lat": 33.7554, "lon": -84.4008, "name": "Mercedes-Benz Stadium"}, | |
| "BAL": {"lat": 39.2780, "lon": -76.6227, "name": "M&T Bank Stadium"}, | |
| "BUF": {"lat": 42.7738, "lon": -78.7870, "name": "Highmark Stadium"}, | |
| "CAR": {"lat": 35.2258, "lon": -80.8528, "name": "Bank of America Stadium"}, | |
| "CHI": {"lat": 41.8623, "lon": -87.6167, "name": "Soldier Field"}, | |
| "CIN": {"lat": 39.0954, "lon": -84.5160, "name": "Paycor Stadium"}, | |
| "CLE": {"lat": 41.5061, "lon": -81.6995, "name": "FirstEnergy Stadium"}, | |
| "DAL": {"lat": 32.7473, "lon": -97.0945, "name": "AT&T Stadium"}, | |
| "DEN": {"lat": 39.7439, "lon": -105.0201, "name": "Empower Field at Mile High"}, | |
| "DET": {"lat": 42.3400, "lon": -83.0456, "name": "Ford Field"}, | |
| "GB": {"lat": 44.5013, "lon": -88.0622, "name": "Lambeau Field"}, | |
| "HOU": {"lat": 29.6847, "lon": -95.4107, "name": "NRG Stadium"}, | |
| "IND": {"lat": 39.7601, "lon": -86.1639, "name": "Lucas Oil Stadium"}, | |
| "JAX": {"lat": 30.3239, "lon": -81.6373, "name": "EverBank Stadium"}, | |
| "KC": {"lat": 39.0489, "lon": -94.4839, "name": "Arrowhead Stadium"}, | |
| "LV": {"lat": 36.0908, "lon": -115.1833, "name": "Allegiant Stadium"}, | |
| "LAC": {"lat": 33.9535, "lon": -118.3390, "name": "SoFi Stadium"}, | |
| "LAR": {"lat": 33.9535, "lon": -118.3390, "name": "SoFi Stadium"}, | |
| "MIA": {"lat": 25.9580, "lon": -80.2389, "name": "Hard Rock Stadium"}, | |
| "MIN": {"lat": 44.9738, "lon": -93.2577, "name": "U.S. Bank Stadium"}, | |
| "NE": {"lat": 42.0909, "lon": -71.2643, "name": "Gillette Stadium"}, | |
| "NO": {"lat": 29.9511, "lon": -90.0812, "name": "Caesars Superdome"}, | |
| "NYG": {"lat": 40.8128, "lon": -74.0742, "name": "MetLife Stadium"}, | |
| "NYJ": {"lat": 40.8128, "lon": -74.0742, "name": "MetLife Stadium"}, | |
| "PHI": {"lat": 39.9008, "lon": -75.1675, "name": "Lincoln Financial Field"}, | |
| "PIT": {"lat": 40.4468, "lon": -80.0158, "name": "Acrisure Stadium"}, | |
| "SF": {"lat": 37.4032, "lon": -121.9698, "name": "Levi's Stadium"}, | |
| "SEA": {"lat": 47.5952, "lon": -122.3316, "name": "Lumen Field"}, | |
| "TB": {"lat": 27.9759, "lon": -82.5033, "name": "Raymond James Stadium"}, | |
| "TEN": {"lat": 36.1665, "lon": -86.7713, "name": "Nissan Stadium"}, | |
| "WAS": {"lat": 38.9076, "lon": -76.8645, "name": "FedEx Field"} | |
| } | |
| def get_weather_forecast(home_team, game_datetime): | |
| """ | |
| Get weather forecast for a stadium at game time. | |
| Uses Open-Meteo API (free, no API key needed) | |
| """ | |
| coords = STADIUM_COORDS.get(home_team) | |
| if not coords: | |
| return None | |
| # Open-Meteo API (free, no key required) | |
| url = "https://api.open-meteo.com/v1/forecast" | |
| params = { | |
| "latitude": coords["lat"], | |
| "longitude": coords["lon"], | |
| "hourly": "temperature_2m,relative_humidity_2m,wind_speed_10m,weather_code", | |
| "temperature_unit": "fahrenheit", | |
| "wind_speed_unit": "mph", | |
| "timezone": "America/New_York" | |
| } | |
| try: | |
| response = requests.get(url, params=params, timeout=10) | |
| response.raise_for_status() | |
| data = response.json() | |
| # Find the closest time to game time | |
| hourly = data.get("hourly", {}) | |
| times = hourly.get("time", []) | |
| # Find index closest to game time | |
| game_time_str = game_datetime.strftime("%Y-%m-%dT%H:%M") | |
| closest_idx = 0 | |
| for i, time_str in enumerate(times): | |
| if time_str >= game_time_str: | |
| closest_idx = i | |
| break | |
| temp = hourly["temperature_2m"][closest_idx] | |
| humidity = hourly["relative_humidity_2m"][closest_idx] | |
| wind = hourly["wind_speed_10m"][closest_idx] | |
| weather_code = hourly["weather_code"][closest_idx] | |
| # Interpret weather codes | |
| # https://open-meteo.com/en/docs | |
| is_rain = weather_code in [51, 53, 55, 61, 63, 65, 80, 81, 82] | |
| is_snow = weather_code in [71, 73, 75, 77, 85, 86] | |
| is_clear = weather_code in [0, 1, 2] | |
| return { | |
| "temp_f": temp, | |
| "humidity_pct": humidity, | |
| "wind_mph": wind, | |
| "is_rain": int(is_rain), | |
| "is_snow": int(is_snow), | |
| "is_clear": int(is_clear), | |
| "weather_code": weather_code | |
| } | |
| except Exception as e: | |
| print(f"Weather API error: {e}") | |
| return None | |
| # Example usage: | |
| game_time = datetime(2025, 10, 13, 13, 0) # Sunday 1pm ET | |
| weather = get_weather_forecast("ARI", game_time) | |
| print(weather) | |
| import requests | |
| from datetime import datetime | |
| def get_game_info_espn(home_team, away_team, week): | |
| """ | |
| Get game time, spread, and total from ESPN API. | |
| Free, no API key required. | |
| Args: | |
| home_team: Home team abbreviation | |
| away_team: Away team abbreviation | |
| week: NFL week number | |
| Returns: | |
| dict with game_datetime, pregame_spread, pregame_total | |
| """ | |
| result = { | |
| "game_datetime": None, | |
| "pregame_spread": 0, | |
| "pregame_total": 0 | |
| } | |
| try: | |
| url = f"https://site.api.espn.com/apis/site/v2/sports/football/nfl/scoreboard?seasontype=2&week={week}" | |
| response = requests.get(url, timeout=10) | |
| response.raise_for_status() | |
| data = response.json() | |
| for event in data.get('events', []): | |
| competition = event.get('competitions', [{}])[0] | |
| competitors = competition.get('competitors', []) | |
| if len(competitors) < 2: | |
| continue | |
| # ESPN puts home team first | |
| h_team = competitors[0]['team']['abbreviation'] | |
| a_team = competitors[1]['team']['abbreviation'] | |
| if h_team == home_team and a_team == away_team: | |
| # Get game time | |
| game_date_str = event.get('date') | |
| if game_date_str: | |
| result["game_datetime"] = datetime.fromisoformat(game_date_str.replace('Z', '+00:00')) | |
| # Get odds from competition | |
| odds_data = competition.get('odds', []) | |
| if odds_data and len(odds_data) > 0: | |
| spread = odds_data[0].get('spread') | |
| total = odds_data[0].get('overUnder') | |
| # ESPN's spread is from home team perspective | |
| result["pregame_spread"] = float(spread) if spread is not None else 0 | |
| result["pregame_total"] = float(total) if total is not None else 0 | |
| print(f"✓ Found game info from ESPN") | |
| print(f" {a_team} @ {h_team}") | |
| print(f" Game time: {result['game_datetime']}") | |
| print(f" Spread: {result['pregame_spread']}, Total: {result['pregame_total']}") | |
| return result | |
| print(f"⚠ Game not found: {away_team} @ {home_team} (Week {week})") | |
| except Exception as e: | |
| print(f"⚠ ESPN API error: {e}") | |
| return result | |
| def get_all_game_data(home_team, away_team, week): | |
| """ | |
| Get complete game data: time, odds, and weather forecast. | |
| Uses ESPN for odds/time and weather API for forecast. | |
| Completely free, no API keys needed. | |
| Args: | |
| home_team: Home team abbreviation | |
| away_team: Away team abbreviation | |
| week: NFL week number | |
| Returns: | |
| Complete game data dictionary | |
| """ | |
| # Get game time and odds from ESPN | |
| game_info = get_game_info_espn(home_team, away_team, week) | |
| # Get weather forecast if we have game time | |
| weather = None | |
| if game_info["game_datetime"]: | |
| weather = get_weather_forecast(home_team, game_info["game_datetime"]) | |
| # Check if dome | |
| dome_teams = ["ARI", "ATL", "DAL", "DET", "HOU", "IND", "LV", "LAR", "LAC", "MIN", "NO"] | |
| is_dome = home_team in dome_teams | |
| # Combine all data | |
| if weather: | |
| game_data = { | |
| "game_datetime": game_info["game_datetime"], | |
| "pregame_spread": game_info["pregame_spread"], | |
| "pregame_total": game_info["pregame_total"], | |
| "temp_f": weather["temp_f"], | |
| "humidity_pct": weather["humidity_pct"], | |
| "wind_mph": weather["wind_mph"], | |
| "is_dome": int(is_dome), | |
| "is_rain": weather["is_rain"] if not is_dome else 0, | |
| "is_snow": weather["is_snow"] if not is_dome else 0, | |
| "is_clear": weather["is_clear"] if not is_dome else 0 | |
| } | |
| else: | |
| # Defaults if no weather available | |
| game_data = { | |
| "game_datetime": game_info["game_datetime"], | |
| "pregame_spread": game_info["pregame_spread"], | |
| "pregame_total": game_info["pregame_total"], | |
| "temp_f": 72 if is_dome else 70, | |
| "humidity_pct": 50, | |
| "wind_mph": 0 if is_dome else 5, | |
| "is_dome": int(is_dome), | |
| "is_rain": 0, | |
| "is_snow": 0, | |
| "is_clear": 0 if is_dome else 1 | |
| } | |
| print(f"\n✓ Complete game data assembled") | |
| return game_data | |
| # Example usage - no API key needed! | |
| game_data = get_all_game_data( | |
| home_team="JAX", | |
| away_team="KC", | |
| week=5 | |
| ) | |
| print("\nFinal game data:") | |
| for key, value in game_data.items(): | |
| print(f" {key}: {value}") | |
| NFL_TEAMS = [ | |
| "ARI", "ATL", "BAL", "BUF", "CAR", "CHI", "CIN", "CLE", | |
| "DAL", "DEN", "DET", "GB", "HOU", "IND", "JAX", "KC", | |
| "LV", "LAC", "LAR", "MIA", "MIN", "NE", "NO", "NYG", | |
| "NYJ", "PHI", "PIT", "SEA", "SF", "TB", "TEN", "WAS" | |
| ] | |
| def create_model_input(home_team, away_team, receiver_on_home_team, | |
| receiver_name, passer_name, week, season): | |
| """ | |
| Create model input from user selections. | |
| """ | |
| try: | |
| # Determine which team the receiver is on | |
| receiver_team = home_team if receiver_on_home_team else away_team | |
| opponent_team = away_team if receiver_on_home_team else home_team | |
| # Normalize player names | |
| def normalize_name(name): | |
| parts = name.strip().split() | |
| if len(parts) == 0: | |
| return "" | |
| if len(parts) > 1: | |
| first_initial = parts[0][0].upper() + "." | |
| last_name = parts[-1] | |
| return f"{first_initial}{last_name}" | |
| return parts[0].title() | |
| wr_key = normalize_name(receiver_name) | |
| qb_key = normalize_name(passer_name) | |
| # Get player IDs | |
| receiver_id = receiver_to_player_id.get(wr_key) | |
| passer_id = passer_to_player_id.get(qb_key) | |
| if receiver_id is None: | |
| return f"Error: Could not find receiver '{wr_key}' in database" | |
| if passer_id is None: | |
| return f"Error: Could not find passer '{qb_key}' in database" | |
| # Get game data (weather, odds, time) | |
| game_data = get_all_game_data(home_team, away_team, week) | |
| if not game_data.get("game_datetime"): | |
| return f"Warning: Game not found for Week {week}. Using default values." | |
| # Team mappings | |
| team_map = { | |
| "ARI": 1, "ATL": 2, "BAL": 3, "BUF": 4, | |
| "CAR": 5, "CHI": 6, "CIN": 7, "CLE": 8, | |
| "DAL": 9, "DEN": 10, "DET": 11, "GB": 12, | |
| "HOU": 13, "IND": 14, "JAX": 15, "KC": 16, | |
| "LV": 17, "LAC": 18, "LAR": 19, "MIA": 20, | |
| "MIN": 21, "NE": 22, "NO": 23, "NYG": 24, | |
| "NYJ": 25, "PHI": 26, "PIT": 27, "SEA": 28, | |
| "SF": 29, "TB": 30, "TEN": 31, "WAS": 32 | |
| } | |
| # Surface mapping | |
| home_team_surface_map = { | |
| "ARI": "grass", "ATL": "fieldturf", "BAL": "grass", "BUF": "fieldturf", | |
| "CAR": "fieldturf", "CHI": "grass", "CIN": "fieldturf", "CLE": "grass", | |
| "DAL": "fieldturf", "DEN": "grass", "DET": "fieldturf", "GB": "grass", | |
| "HOU": "fieldturf", "IND": "fieldturf", "JAX": "grass", "KC": "grass", | |
| "LV": "grass", "LAC": "fieldturf", "LAR": "fieldturf", "MIA": "grass", | |
| "MIN": "fieldturf", "NE": "fieldturf", "NO": "fieldturf", "NYG": "fieldturf", | |
| "NYJ": "fieldturf", "PHI": "grass", "PIT": "grass", "SF": "grass", | |
| "SEA": "fieldturf", "TB": "grass", "TEN": "fieldturf", "WAS": "grass" | |
| } | |
| surface_map = { | |
| "a_turf": 1, "grass": 2, "sportturf": 3, | |
| "fieldturf": 4, "matrixturf": 5, "astroturf": 6, "0": 0 | |
| } | |
| # Get IDs | |
| posteam_id = team_map.get(receiver_team, 0) | |
| defteam_id = team_map.get(opponent_team, 0) | |
| home_team_id = team_map.get(home_team, 0) | |
| away_team_id = team_map.get(away_team, 0) | |
| # Get surface | |
| surface_type = home_team_surface_map.get(home_team, "grass") | |
| surface_id = surface_map.get(surface_type, 2) | |
| # Create model input | |
| model_input = { | |
| "receiver_player_id": receiver_id, | |
| "passer_player_id": passer_id, | |
| "posteam": posteam_id, | |
| "defteam": defteam_id, | |
| "surface": surface_id, | |
| "is_dome": game_data.get("is_dome", 0), | |
| "is_rain": game_data.get("is_rain", 0), | |
| "is_snow": game_data.get("is_snow", 0), | |
| "is_clear": game_data.get("is_clear", 1), | |
| "temp_f": game_data.get("temp_f", 70), | |
| "humidity_pct": game_data.get("humidity_pct", 50), | |
| "wind_mph": game_data.get("wind_mph", 5), | |
| "pregame_spread": game_data.get("pregame_spread", 0), | |
| "pregame_total": game_data.get("pregame_total", 0), | |
| "home_team": home_team_id, | |
| "away_team": away_team_id, | |
| } | |
| # Format output for display | |
| output = f""" | |
| 🏈 Model Input Created Successfully! | |
| 📋 Game Information: | |
| • Matchup: {away_team} @ {home_team} (Week {week}, {season}) | |
| • Game Time: {game_data.get('game_datetime', 'Unknown')} | |
| • Venue: {home_team} ({surface_type}, {'Indoor' if game_data.get('is_dome') else 'Outdoor'}) | |
| 👤 Players: | |
| • Receiver: {receiver_name} ({wr_key}) - ID: {receiver_id} | |
| • Passer: {passer_name} ({qb_key}) - ID: {passer_id} | |
| • Team: {receiver_team} vs {opponent_team} | |
| 🌤️ Weather Conditions: | |
| • Temperature: {game_data.get('temp_f', 70)}°F | |
| • Humidity: {game_data.get('humidity_pct', 50)}% | |
| • Wind: {game_data.get('wind_mph', 5)} mph | |
| • Conditions: {'Dome' if game_data.get('is_dome') else 'Rain' if game_data.get('is_rain') else 'Snow' if game_data.get('is_snow') else 'Clear'} | |
| 💰 Betting Lines: | |
| • Spread: {game_data.get('pregame_spread', 0)} | |
| • Total: {game_data.get('pregame_total', 0)} | |
| 📊 Model Input Dictionary: | |
| {model_input} | |
| """ | |
| return output, model_input | |
| except Exception as e: | |
| return f"Error: {str(e)}", None | |
| # Create Gradio interface | |
| def gradio_interface(home_team, away_team, receiver_on_home, receiver_name, passer_name, week, season): | |
| output_text, model_input = create_model_input( | |
| home_team, away_team, receiver_on_home, | |
| receiver_name, passer_name, week, season | |
| ) | |
| return output_text | |
| with gr.Blocks(title="NFL Receiver Prediction Input Generator") as app: | |
| gr.Markdown("# 🏈 NFL Receiver Prediction Input Generator") | |
| gr.Markdown("Generate model inputs for NFL receiver predictions with automatic weather and odds data.") | |
| with gr.Row(): | |
| with gr.Column(): | |
| home_team = gr.Dropdown( | |
| choices=NFL_TEAMS, | |
| label="Home Team", | |
| value="KC" | |
| ) | |
| away_team = gr.Dropdown( | |
| choices=NFL_TEAMS, | |
| label="Away Team", | |
| value="NO" | |
| ) | |
| with gr.Column(): | |
| week = gr.Number( | |
| label="Week", | |
| value=6, | |
| precision=0 | |
| ) | |
| season = gr.Number( | |
| label="Season", | |
| value=2025, | |
| precision=0 | |
| ) | |
| with gr.Row(): | |
| receiver_on_home = gr.Checkbox( | |
| label="Receiver is on Home Team", | |
| value=True | |
| ) | |
| with gr.Row(): | |
| with gr.Column(): | |
| receiver_name = gr.Dropdown( | |
| choices = receiver_choices, | |
| label="Receiver Name", | |
| value="" | |
| ) | |
| with gr.Column(): | |
| passer_name = gr.Dropdown( | |
| choices = passer_choices, | |
| label="Passer Name", | |
| value="" | |
| ) | |
| generate_btn = gr.Button("Generate Model Input", variant="primary") | |
| output = gr.Textbox( | |
| label="Model Input", | |
| lines=25, | |
| max_lines=30 | |
| ) | |
| generate_btn.click( | |
| fn=gradio_interface, | |
| inputs=[home_team, away_team, receiver_on_home, receiver_name, passer_name, week, season], | |
| outputs=output | |
| ) | |
| gr.Markdown(""" | |
| ### Instructions: | |
| 1. Select the home and away teams | |
| 2. Enter the week number and season | |
| 3. Check the box if the receiver plays for the home team | |
| 4. Enter the receiver and passer names (First Last format) | |
| 5. Click "Generate Model Input" | |
| The app will automatically fetch: | |
| - Weather forecast for the game | |
| - Betting lines (spread and total) | |
| - Stadium surface information | |
| - Player IDs from your database | |
| """) | |
| # Launch the app | |
| if __name__ == "__main__": | |
| app.launch() |