182 lines
7.2 KiB
Python
182 lines
7.2 KiB
Python
import sqlite3
|
|
from datetime import datetime, timedelta
|
|
|
|
def process_record(record):
|
|
if record == "N/A":
|
|
return "N/A"
|
|
else:
|
|
parts = record.split("-")
|
|
formatted_parts = [part.zfill(2) for part in parts]
|
|
return "-".join(formatted_parts)
|
|
|
|
def extract_game_info(scoreboard_data):
|
|
if not scoreboard_data:
|
|
return []
|
|
|
|
extracted_info = []
|
|
for game in scoreboard_data.get("games", []):
|
|
game_state = convert_game_state(game["gameState"])
|
|
extracted_info.append({
|
|
"Home Team": game["homeTeam"]["name"]["default"],
|
|
"Home Score": game["homeTeam"]["score"] if game_state != "PRE" else "N/A",
|
|
"Away Team": game["awayTeam"]["name"]["default"],
|
|
"Away Score": game["awayTeam"]["score"] if game_state != "PRE" else "N/A",
|
|
"Home Logo": game["homeTeam"]["logo"],
|
|
"Away Logo": game["awayTeam"]["logo"],
|
|
"Game State": game_state,
|
|
"Period": process_period(game),
|
|
"Time Remaining": process_time_remaining(game),
|
|
"Time Running": game["clock"]["running"] if game_state == "LIVE" else "N/A",
|
|
"Intermission": game["clock"]["inIntermission"] if game_state == "LIVE" else "N/A",
|
|
"Priority": calculate_game_priority(game),
|
|
"Start Time": process_start_time(game),
|
|
"Home Record": process_record(game["homeTeam"]["record"]) if game["gameState"] in ["PRE", "FUT"] else "N/A",
|
|
"Away Record": process_record(game["awayTeam"]["record"]) if game["gameState"] in ["PRE", "FUT"] else "N/A",
|
|
"Home Shots": game["homeTeam"]["sog"] if game["gameState"] not in ["PRE", "FUT"] else 0,
|
|
"Away Shots": game["awayTeam"]["sog"] if game["gameState"] not in ["PRE", "FUT"] else 0,
|
|
"Home Power Play": get_power_play_info(game, game["homeTeam"]["name"]["default"]),
|
|
"Away Power Play": get_power_play_info(game, game["awayTeam"]["name"]["default"]),
|
|
"Last Period Type": get_game_outcome(game, game_state)
|
|
})
|
|
|
|
# Sort games based on priority
|
|
return sorted(extracted_info, key=lambda x: x["Priority"], reverse=True)
|
|
|
|
def convert_game_state(game_state):
|
|
state_mapping = {"OFF": "FINAL", "CRIT": "LIVE", "FUT": "PRE"}
|
|
return state_mapping.get(game_state, game_state)
|
|
|
|
def process_period(game):
|
|
if game["gameState"] in ["PRE", "FUT"]:
|
|
return 0
|
|
elif game["gameState"] in ["FINAL", "OFF"]:
|
|
return "N/A"
|
|
else:
|
|
return game["periodDescriptor"]["number"]
|
|
|
|
def process_time_remaining(game):
|
|
if game["gameState"] in ["PRE", "FUT"]:
|
|
return "20:00"
|
|
elif game["gameState"] in ["FINAL", "OFF"]:
|
|
return "00:00"
|
|
else:
|
|
time_remaining = game["clock"]["timeRemaining"]
|
|
return "END" if time_remaining == "00:00" else time_remaining
|
|
|
|
def process_start_time(game):
|
|
if game["gameState"] in ["PRE", "FUT"]:
|
|
utc_time = game["startTimeUTC"]
|
|
est_time = utc_to_est_time(utc_time)
|
|
# Check if the hour starts with a zero
|
|
if est_time.startswith("0"):
|
|
est_time = est_time[1:] # Drop the leading zero
|
|
return est_time
|
|
else:
|
|
return "N/A"
|
|
|
|
def get_power_play_info(game, team_name):
|
|
if "situation" in game and "situationDescriptions" in game["situation"]:
|
|
for situation in game["situation"]["situationDescriptions"]:
|
|
if situation == "PP" and game["awayTeam"]["name"]["default"] == team_name:
|
|
return f"PP {game['situation']['timeRemaining']}"
|
|
elif situation == "PP" and game["homeTeam"]["name"]["default"] == team_name:
|
|
return f"PP {game['situation']['timeRemaining']}"
|
|
return ""
|
|
|
|
def get_game_outcome(game, game_state):
|
|
return game["gameOutcome"]["lastPeriodType"] if game_state == "FINAL" else "N/A"
|
|
|
|
def calculate_game_priority(game):
|
|
# Return 0 if game is in certain states
|
|
if game["gameState"] in ["FINAL", "OFF", "PRE", "FUT"]:
|
|
return 0
|
|
|
|
# Get period, time remaining, scores, and other relevant data
|
|
period = game.get("periodDescriptor", {}).get("number", 0)
|
|
time_remaining = game.get("clock", {}).get("secondsRemaining", 0)
|
|
home_score = game["homeTeam"]["score"]
|
|
away_score = game["awayTeam"]["score"]
|
|
score_difference = abs(home_score - away_score)
|
|
score_total = (home_score + away_score) * 20
|
|
|
|
# Get standings for home and away teams
|
|
home_team_standings = get_team_standings(game["homeTeam"]["name"]["default"])
|
|
away_team_standings = get_team_standings(game["awayTeam"]["name"]["default"])
|
|
|
|
# Calculate total values of leagueSequence + leagueL10Sequence for each team
|
|
home_total = home_team_standings["league_sequence"] + home_team_standings["league_l10_sequence"]
|
|
away_total = away_team_standings["league_sequence"] + away_team_standings["league_l10_sequence"]
|
|
|
|
# Calculate the matchup adjustment factor
|
|
matchup_multiplier = {5: 1, 4: 1, 3: 1.50, 2: 1.65, 1: 2}.get(period)
|
|
matchup_adjustment = (home_total + away_total) * matchup_multiplier
|
|
|
|
# Calculate the base priority based on period
|
|
base_priority = {5: 650, 4: 600, 3: 300, 2: 200}.get(period, 150)
|
|
|
|
# Adjust base priority based on score difference
|
|
score_differential_adjustment = 0
|
|
|
|
if score_difference > 3:
|
|
score_differential_adjustment += 500
|
|
elif score_difference > 2:
|
|
score_differential_adjustment += 350
|
|
elif score_difference > 1:
|
|
score_differential_adjustment += 100
|
|
|
|
if period == 3 and time_remaining <= 300:
|
|
score_differential_adjustment = score_differential_adjustment * 2
|
|
|
|
base_priority -= score_differential_adjustment
|
|
|
|
# Adjust base priority based on certain conditions
|
|
if period == 3 and time_remaining <= 720:
|
|
if score_difference == 0:
|
|
base_priority += 100
|
|
elif score_difference == 1:
|
|
base_priority += 60
|
|
|
|
if period == 3 and time_remaining <= 360:
|
|
if score_difference == 0:
|
|
base_priority += 50
|
|
elif score_difference == 1:
|
|
base_priority += 30
|
|
|
|
|
|
# Calculate time priority
|
|
time_multiplier = {4: 2, 3: 2, 2: 1.5}.get(period, 0.75)
|
|
|
|
time_priority = ((1200 - time_remaining) / 20) * time_multiplier
|
|
|
|
print(base_priority)
|
|
print(time_priority)
|
|
print(matchup_adjustment)
|
|
print(score_total)
|
|
|
|
# Calculate the final priority
|
|
final_priority = int(base_priority + time_priority - matchup_adjustment + score_total)
|
|
|
|
# Pushes the games that are in intermission to the bottom, but retains their sort
|
|
if game["clock"]["inIntermission"]:
|
|
return (-2000 - time_remaining)
|
|
|
|
return final_priority
|
|
|
|
def get_team_standings(team_name):
|
|
conn = sqlite3.connect("app/data/nhl_standings.db")
|
|
cursor = conn.cursor()
|
|
cursor.execute("""
|
|
SELECT league_sequence, league_l10_sequence
|
|
FROM standings
|
|
WHERE team_common_name = ?
|
|
""", (team_name,))
|
|
result = cursor.fetchone()
|
|
conn.close()
|
|
return {"league_sequence": result[0] if result else 0, "league_l10_sequence": result[1] if result else 0}
|
|
|
|
def utc_to_est_time(utc_time):
|
|
utc_datetime = datetime.strptime(utc_time, "%Y-%m-%dT%H:%M:%SZ")
|
|
est_offset = timedelta(hours=-4)
|
|
est_datetime = utc_datetime + est_offset
|
|
return est_datetime.strftime("%#I:%M %p")
|