mirror of
https://github.com/ChuckBuilds/LEDMatrix.git
synced 2026-04-11 05:13:01 +00:00
570 lines
27 KiB
Python
570 lines
27 KiB
Python
import os
|
|
import time
|
|
import logging
|
|
import requests
|
|
import json
|
|
from typing import Dict, Any, Optional, List
|
|
from PIL import Image, ImageDraw, ImageFont
|
|
from pathlib import Path
|
|
from datetime import datetime, timedelta, timezone
|
|
from src.display_manager import DisplayManager
|
|
|
|
# Constants
|
|
ESPN_NHL_SCOREBOARD_URL = "https://site.api.espn.com/apis/site/v2/sports/hockey/nhl/scoreboard"
|
|
|
|
class BaseNHLManager:
|
|
"""Base class for NHL managers with common functionality."""
|
|
# Class variables for warning tracking
|
|
_no_data_warning_logged = False
|
|
_last_warning_time = 0
|
|
_warning_cooldown = 60 # Only log warnings once per minute
|
|
|
|
def __init__(self, config: Dict[str, Any], display_manager: DisplayManager):
|
|
self.display_manager = display_manager
|
|
self.config = config
|
|
self.nhl_config = config.get("nhl_scoreboard", {})
|
|
self.is_enabled = self.nhl_config.get("enabled", False)
|
|
self.test_mode = True # Force test mode to be enabled
|
|
self.logo_dir = self.nhl_config.get("logo_dir", "assets/sports/nhl_logos")
|
|
self.update_interval = self.nhl_config.get("update_interval_seconds", 60)
|
|
self.last_update = 0
|
|
self.current_game = None
|
|
self.fonts = self._load_fonts()
|
|
self.favorite_teams = self.nhl_config.get("favorite_teams", [])
|
|
self.logger = logging.getLogger('NHL')
|
|
|
|
# Set logging level to INFO to reduce noise
|
|
self.logger.setLevel(logging.INFO)
|
|
|
|
# Get display dimensions from config
|
|
display_config = config.get("display", {})
|
|
hardware_config = display_config.get("hardware", {})
|
|
cols = hardware_config.get("cols", 64)
|
|
chain = hardware_config.get("chain_length", 1)
|
|
self.display_width = int(cols * chain)
|
|
self.display_height = hardware_config.get("rows", 32)
|
|
|
|
# Cache for loaded logos
|
|
self._logo_cache = {}
|
|
|
|
self.logger.info(f"Initialized NHL manager with display dimensions: {self.display_width}x{self.display_height}")
|
|
self.logger.info(f"Logo directory: {self.logo_dir}")
|
|
|
|
def _load_fonts(self):
|
|
"""Load fonts used by the scoreboard."""
|
|
fonts = {}
|
|
try:
|
|
# Try to load the 4x6 font for scores
|
|
fonts['score'] = ImageFont.truetype("assets/fonts/4x6-font.ttf", 12)
|
|
fonts['time'] = ImageFont.truetype("assets/fonts/4x6-font.ttf", 10)
|
|
fonts['team'] = ImageFont.truetype("assets/fonts/4x6-font.ttf", 8)
|
|
fonts['status'] = ImageFont.truetype("assets/fonts/4x6-font.ttf", 9)
|
|
logging.info("[NHL] Successfully loaded 4x6 font for all text elements")
|
|
except IOError:
|
|
logging.warning("[NHL] 4x6 font not found, trying PressStart2P font.")
|
|
try:
|
|
# Try to load the PressStart2P font as a fallback
|
|
fonts['score'] = ImageFont.truetype("assets/fonts/PressStart2P-Regular.ttf", 12)
|
|
fonts['time'] = ImageFont.truetype("assets/fonts/PressStart2P-Regular.ttf", 10)
|
|
fonts['team'] = ImageFont.truetype("assets/fonts/PressStart2P-Regular.ttf", 8)
|
|
fonts['status'] = ImageFont.truetype("assets/fonts/PressStart2P-Regular.ttf", 9)
|
|
logging.info("[NHL] Successfully loaded PressStart2P font for all text elements")
|
|
except IOError:
|
|
logging.warning("[NHL] PressStart2P font not found, using default PIL font.")
|
|
# Use default PIL font as a last resort
|
|
fonts['score'] = ImageFont.load_default()
|
|
fonts['time'] = ImageFont.load_default()
|
|
fonts['team'] = ImageFont.load_default()
|
|
fonts['status'] = ImageFont.load_default()
|
|
return fonts
|
|
|
|
def _load_and_resize_logo(self, team_abbrev: str) -> Optional[Image.Image]:
|
|
"""Load and resize a team logo, with caching."""
|
|
self.logger.debug(f"Loading logo for {team_abbrev}")
|
|
|
|
if team_abbrev in self._logo_cache:
|
|
self.logger.debug(f"Using cached logo for {team_abbrev}")
|
|
return self._logo_cache[team_abbrev]
|
|
|
|
logo_path = os.path.join(self.logo_dir, f"{team_abbrev}.png")
|
|
self.logger.debug(f"Logo path: {logo_path}")
|
|
|
|
try:
|
|
# Create test logos if they don't exist
|
|
if not os.path.exists(logo_path):
|
|
self.logger.info(f"Creating test logo for {team_abbrev}")
|
|
os.makedirs(os.path.dirname(logo_path), exist_ok=True)
|
|
# Create a simple colored rectangle as a test logo
|
|
logo = Image.new('RGBA', (32, 32), (0, 0, 0, 0))
|
|
draw = ImageDraw.Draw(logo)
|
|
# Use team abbreviation to determine color
|
|
if team_abbrev == "TBL":
|
|
color = (0, 0, 255, 255) # Blue for Tampa Bay
|
|
else:
|
|
color = (255, 0, 0, 255) # Red for Dallas
|
|
draw.rectangle([4, 4, 28, 28], fill=color)
|
|
# Add team abbreviation
|
|
draw.text((8, 8), team_abbrev, fill=(255, 255, 255, 255))
|
|
logo.save(logo_path)
|
|
self.logger.info(f"Created test logo at {logo_path}")
|
|
|
|
logo = Image.open(logo_path)
|
|
self.logger.debug(f"Opened logo for {team_abbrev}, size: {logo.size}, mode: {logo.mode}")
|
|
|
|
# Convert to RGBA if not already
|
|
if logo.mode != 'RGBA':
|
|
self.logger.debug(f"Converting {team_abbrev} logo from {logo.mode} to RGBA")
|
|
logo = logo.convert('RGBA')
|
|
|
|
# Calculate max size based on display dimensions
|
|
# Make logos 150% of display width to allow them to extend off screen
|
|
max_width = int(self.display_width * 1.5)
|
|
max_height = int(self.display_height * 1.5)
|
|
|
|
# Resize maintaining aspect ratio
|
|
logo.thumbnail((max_width, max_height), Image.Resampling.LANCZOS)
|
|
self.logger.debug(f"Resized {team_abbrev} logo to {logo.size}")
|
|
|
|
# Cache the resized logo
|
|
self._logo_cache[team_abbrev] = logo
|
|
return logo
|
|
|
|
except Exception as e:
|
|
self.logger.error(f"Error loading logo for {team_abbrev}: {e}", exc_info=True)
|
|
return None
|
|
|
|
def _fetch_data(self, date_str: str = None) -> Optional[Dict]:
|
|
"""Fetch data from ESPN API or load test data."""
|
|
url = ESPN_NHL_SCOREBOARD_URL
|
|
params = {}
|
|
if date_str:
|
|
params['dates'] = date_str
|
|
|
|
try:
|
|
response = requests.get(url, params=params, timeout=10)
|
|
response.raise_for_status()
|
|
data = response.json()
|
|
logging.info(f"[NHL] Successfully fetched data from ESPN API")
|
|
return data
|
|
except requests.exceptions.RequestException as e:
|
|
logging.error(f"[NHL] Error fetching data from ESPN: {e}")
|
|
return None
|
|
|
|
def _extract_game_details(self, game_event: Dict) -> Optional[Dict]:
|
|
"""Extract relevant game details from ESPN API response."""
|
|
if not game_event:
|
|
return None
|
|
|
|
try:
|
|
competition = game_event["competitions"][0]
|
|
status = competition["status"]
|
|
competitors = competition["competitors"]
|
|
game_date_str = game_event["date"]
|
|
|
|
# Parse game date/time
|
|
try:
|
|
start_time_utc = datetime.fromisoformat(game_date_str.replace("Z", "+00:00"))
|
|
except ValueError:
|
|
logging.warning(f"[NHL] Could not parse game date: {game_date_str}")
|
|
start_time_utc = None
|
|
|
|
home_team = next(c for c in competitors if c.get("homeAway") == "home")
|
|
away_team = next(c for c in competitors if c.get("homeAway") == "away")
|
|
|
|
# Format game time and date for display
|
|
game_time = ""
|
|
game_date = ""
|
|
if start_time_utc:
|
|
# Convert to local time
|
|
local_time = start_time_utc.astimezone()
|
|
game_time = local_time.strftime("%I:%M %p")
|
|
game_date = local_time.strftime("%b %d")
|
|
|
|
details = {
|
|
"start_time_utc": start_time_utc,
|
|
"status_text": status["type"]["shortDetail"],
|
|
"period": status.get("period", 0),
|
|
"clock": status.get("displayClock", "0:00"),
|
|
"is_live": status["type"]["state"] in ("in", "halftime"),
|
|
"is_final": status["type"]["state"] == "post",
|
|
"is_upcoming": status["type"]["state"] == "pre",
|
|
"home_abbr": home_team["team"]["abbreviation"],
|
|
"home_score": home_team.get("score", "0"),
|
|
"home_logo_path": os.path.join(self.logo_dir, f"{home_team['team']['abbreviation']}.png"),
|
|
"away_abbr": away_team["team"]["abbreviation"],
|
|
"away_score": away_team.get("score", "0"),
|
|
"away_logo_path": os.path.join(self.logo_dir, f"{away_team['team']['abbreviation']}.png"),
|
|
"game_time": game_time,
|
|
"game_date": game_date
|
|
}
|
|
|
|
# Validate logo files
|
|
for team in ["home", "away"]:
|
|
logo_path = details[f"{team}_logo_path"]
|
|
if not os.path.isfile(logo_path):
|
|
logging.warning(f"[NHL] {team.title()} logo not found: {logo_path}")
|
|
details[f"{team}_logo_path"] = None
|
|
else:
|
|
try:
|
|
with Image.open(logo_path) as img:
|
|
logging.debug(f"[NHL] {team.title()} logo is valid: {img.format}, size: {img.size}")
|
|
except Exception as e:
|
|
logging.error(f"[NHL] {team.title()} logo file exists but is not valid: {e}")
|
|
details[f"{team}_logo_path"] = None
|
|
|
|
return details
|
|
except Exception as e:
|
|
logging.error(f"[NHL] Error extracting game details: {e}")
|
|
return None
|
|
|
|
def _draw_scorebug_layout(self):
|
|
"""Draw the scorebug layout for the current game."""
|
|
try:
|
|
# Create a new black image for the main display
|
|
main_img = Image.new('RGBA', (self.display_width, self.display_height), (0, 0, 0, 255))
|
|
|
|
# Load logos once
|
|
home_logo = self._load_and_resize_logo(self.current_game["home_abbr"])
|
|
away_logo = self._load_and_resize_logo(self.current_game["away_abbr"])
|
|
|
|
if not home_logo or not away_logo:
|
|
self.logger.error("Failed to load one or both team logos")
|
|
return
|
|
|
|
# Create a single overlay for both logos
|
|
overlay = Image.new('RGBA', (self.display_width, self.display_height), (0, 0, 0, 0))
|
|
|
|
# Calculate vertical center line for alignment
|
|
center_y = self.display_height // 2
|
|
|
|
# Draw home team logo (far right, extending beyond screen)
|
|
home_x = self.display_width - home_logo.width + 20 # Move 20 pixels further right
|
|
home_y = center_y - (home_logo.height // 2)
|
|
|
|
# Paste the home logo onto the overlay
|
|
overlay.paste(home_logo, (home_x, home_y), home_logo)
|
|
|
|
# Draw away team logo (far left, extending beyond screen)
|
|
away_x = -20 # Move 20 pixels further left
|
|
away_y = center_y - (away_logo.height // 2)
|
|
|
|
# Paste the away logo onto the overlay
|
|
overlay.paste(away_logo, (away_x, away_y), away_logo)
|
|
|
|
# Composite the overlay with the main image
|
|
main_img = Image.alpha_composite(main_img, overlay)
|
|
|
|
# Convert to RGB for final display
|
|
main_img = main_img.convert('RGB')
|
|
draw = ImageDraw.Draw(main_img)
|
|
|
|
# Check if this is an upcoming game
|
|
is_upcoming = self.current_game.get("is_upcoming", False)
|
|
|
|
if is_upcoming:
|
|
# For upcoming games, show date and time
|
|
game_date = self.current_game.get("game_date", "")
|
|
game_time = self.current_game.get("game_time", "")
|
|
date_time_text = f"{game_date} {game_time}"
|
|
|
|
# Calculate position for the date/time text (centered at the bottom)
|
|
date_time_width = draw.textlength(date_time_text, font=self.fonts['time'])
|
|
date_time_x = (self.display_width - date_time_width) // 2
|
|
date_time_y = self.display_height - 15
|
|
draw.text((date_time_x, date_time_y), date_time_text, font=self.fonts['time'], fill=(255, 255, 255))
|
|
|
|
# Show "Upcoming Game" at the top
|
|
status_text = "Upcoming Game"
|
|
status_width = draw.textlength(status_text, font=self.fonts['status'])
|
|
status_x = (self.display_width - status_width) // 2
|
|
status_y = 5
|
|
draw.text((status_x, status_y), status_text, font=self.fonts['status'], fill=(255, 255, 255))
|
|
else:
|
|
# For live/final games, show scores and period/time
|
|
home_score = str(self.current_game.get("home_score", "0"))
|
|
away_score = str(self.current_game.get("away_score", "0"))
|
|
score_text = f"{away_score} - {home_score}"
|
|
|
|
# Calculate position for the score text (centered at the bottom)
|
|
score_width = draw.textlength(score_text, font=self.fonts['score'])
|
|
score_x = (self.display_width - score_width) // 2
|
|
score_y = self.display_height - 15
|
|
draw.text((score_x, score_y), score_text, font=self.fonts['score'], fill=(255, 255, 255))
|
|
|
|
# Draw period and time
|
|
period = self.current_game.get("period", 0)
|
|
clock = self.current_game.get("clock", "0:00")
|
|
period_text = f"Period {period} {clock}"
|
|
|
|
# Calculate position for the period text (centered at the top)
|
|
period_width = draw.textlength(period_text, font=self.fonts['time'])
|
|
period_x = (self.display_width - period_width) // 2
|
|
period_y = 5
|
|
draw.text((period_x, period_y), period_text, font=self.fonts['time'], fill=(255, 255, 255))
|
|
|
|
# Display the image
|
|
self.display_manager.image.paste(main_img, (0, 0))
|
|
self.display_manager.update_display()
|
|
|
|
except Exception as e:
|
|
self.logger.error(f"Error displaying game: {e}", exc_info=True)
|
|
|
|
def display(self, force_clear: bool = False) -> None:
|
|
"""Common display method for all NHL managers"""
|
|
if not self.current_game:
|
|
current_time = time.time()
|
|
if not hasattr(self, '_last_warning_time'):
|
|
self._last_warning_time = 0
|
|
if current_time - self._last_warning_time > 300: # 5 minutes cooldown
|
|
self.logger.warning("[NHL] No game data available to display")
|
|
self._last_warning_time = current_time
|
|
return
|
|
|
|
self._draw_scorebug_layout()
|
|
|
|
class NHLLiveManager(BaseNHLManager):
|
|
"""Manager for live NHL games."""
|
|
def __init__(self, config: Dict[str, Any], display_manager: DisplayManager):
|
|
super().__init__(config, display_manager)
|
|
self.update_interval = self.nhl_config.get("live_update_interval", 30) # 30 seconds for live games
|
|
self.no_data_interval = 300 # 5 minutes when no live games
|
|
self.last_update = 0
|
|
self.logger.info("Initialized NHL Live Manager")
|
|
|
|
# Initialize with test game only if test mode is enabled
|
|
if self.test_mode:
|
|
self.current_game = {
|
|
"home_abbr": "TBL",
|
|
"away_abbr": "DAL",
|
|
"home_score": "3",
|
|
"away_score": "2",
|
|
"period": 2,
|
|
"clock": "12:34",
|
|
"home_logo_path": os.path.join(self.logo_dir, "TBL.png"),
|
|
"away_logo_path": os.path.join(self.logo_dir, "DAL.png"),
|
|
"game_time": "7:30 PM",
|
|
"game_date": "Apr 17"
|
|
}
|
|
logging.info("[NHL] Initialized NHLLiveManager with test game: TBL vs DAL")
|
|
else:
|
|
logging.info("[NHL] Initialized NHLLiveManager in live mode")
|
|
|
|
def update(self):
|
|
"""Update live game data."""
|
|
current_time = time.time()
|
|
# Use longer interval if no game data
|
|
interval = self.no_data_interval if not self.current_game else self.update_interval
|
|
|
|
if current_time - self.last_update >= interval:
|
|
self.logger.debug("Updating live game data")
|
|
self.last_update = current_time
|
|
if self.test_mode:
|
|
# For testing, we'll just update the clock to show it's working
|
|
if self.current_game:
|
|
minutes = int(self.current_game["clock"].split(":")[0])
|
|
seconds = int(self.current_game["clock"].split(":")[1])
|
|
seconds -= 1
|
|
if seconds < 0:
|
|
seconds = 59
|
|
minutes -= 1
|
|
if minutes < 0:
|
|
minutes = 19
|
|
if self.current_game["period"] < 3:
|
|
self.current_game["period"] += 1
|
|
else:
|
|
self.current_game["period"] = 1
|
|
self.current_game["clock"] = f"{minutes:02d}:{seconds:02d}"
|
|
logging.debug(f"[NHL] Updated test game clock: {self.current_game['clock']}")
|
|
else:
|
|
# Fetch live game data from ESPN API
|
|
data = self._fetch_data()
|
|
if data and "events" in data:
|
|
# Find the first live game involving favorite teams
|
|
for event in data["events"]:
|
|
details = self._extract_game_details(event)
|
|
if details and details["is_live"]:
|
|
if not self.favorite_teams or (
|
|
details["home_abbr"] in self.favorite_teams or
|
|
details["away_abbr"] in self.favorite_teams
|
|
):
|
|
self.current_game = details
|
|
logging.info(f"[NHL] Found live game: {details['away_abbr']} vs {details['home_abbr']}")
|
|
break
|
|
else:
|
|
# No live games found
|
|
self.current_game = None
|
|
logging.info("[NHL] No live games found")
|
|
|
|
def display(self, force_clear: bool = False):
|
|
"""Display live game information."""
|
|
if not self.current_game:
|
|
return
|
|
super().display(force_clear) # Call parent class's display method
|
|
|
|
class NHLRecentManager(BaseNHLManager):
|
|
"""Manager for recently completed NHL games."""
|
|
def __init__(self, config: Dict[str, Any], display_manager: DisplayManager):
|
|
super().__init__(config, display_manager)
|
|
self.update_interval = self.nhl_config.get("recent_update_interval", 300) # 5 minutes
|
|
self.no_data_interval = 900 # 15 minutes when no recent games
|
|
self.last_update = 0
|
|
self.logger.info("Initialized NHL Recent Manager")
|
|
self.recent_hours = self.nhl_config.get("recent_game_hours", 48) # Default 48 hours
|
|
self.current_game = None
|
|
|
|
if self.test_mode:
|
|
# Initialize with a test game
|
|
self.current_game = {
|
|
"home_abbr": "TBL",
|
|
"away_abbr": "DAL",
|
|
"home_score": "4",
|
|
"away_score": "2",
|
|
"status_text": "Final",
|
|
"home_logo_path": os.path.join(self.logo_dir, "TBL.png"),
|
|
"away_logo_path": os.path.join(self.logo_dir, "DAL.png"),
|
|
"game_time": "7:30 PM",
|
|
"game_date": "Apr 17"
|
|
}
|
|
logging.info("[NHL] Initialized NHLRecentManager with test game: TBL vs DAL")
|
|
else:
|
|
logging.info("[NHL] Initialized NHLRecentManager in live mode")
|
|
|
|
def update(self):
|
|
"""Update recent game data."""
|
|
current_time = time.time()
|
|
# Use longer interval if no game data
|
|
interval = self.no_data_interval if not self.current_game else self.update_interval
|
|
|
|
if current_time - self.last_update >= interval:
|
|
self.logger.debug("Updating recent game data")
|
|
self.last_update = current_time
|
|
if self.test_mode:
|
|
# In test mode, just keep the test game
|
|
pass
|
|
else:
|
|
# Fetch data for the last 48 hours
|
|
cutoff_time = datetime.now(timezone.utc) - timedelta(hours=self.recent_hours)
|
|
data = self._fetch_data()
|
|
|
|
if data and "events" in data:
|
|
# Find the most recent completed game involving favorite teams
|
|
most_recent_game = None
|
|
most_recent_time = None
|
|
|
|
for event in data["events"]:
|
|
details = self._extract_game_details(event)
|
|
if details and details["is_final"] and details["start_time_utc"]:
|
|
# Check if game is within our time window
|
|
if details["start_time_utc"] > cutoff_time:
|
|
# Check if it involves favorite teams (if any are configured)
|
|
if not self.favorite_teams or (
|
|
details["home_abbr"] in self.favorite_teams or
|
|
details["away_abbr"] in self.favorite_teams
|
|
):
|
|
# Keep the most recent game
|
|
if most_recent_time is None or details["start_time_utc"] > most_recent_time:
|
|
most_recent_game = details
|
|
most_recent_time = details["start_time_utc"]
|
|
|
|
self.current_game = most_recent_game
|
|
if most_recent_game:
|
|
logging.info(f"[NHL] Found recent game: {most_recent_game['away_abbr']} vs {most_recent_game['home_abbr']}")
|
|
else:
|
|
logging.info("[NHL] No recent games found")
|
|
|
|
def display(self, force_clear: bool = False):
|
|
"""Display recent game information."""
|
|
self.logger.info("NHLRecentManager.display() called")
|
|
if not self.current_game:
|
|
logging.warning("[NHL] No recent game data available to display")
|
|
return
|
|
super().display(force_clear) # Call parent class's display method
|
|
|
|
class NHLUpcomingManager(BaseNHLManager):
|
|
"""Manager for upcoming NHL games."""
|
|
def __init__(self, config: Dict[str, Any], display_manager: DisplayManager):
|
|
super().__init__(config, display_manager)
|
|
self.update_interval = self.nhl_config.get("upcoming_update_interval", 300) # 5 minutes
|
|
self.no_data_interval = 900 # 15 minutes when no upcoming games
|
|
self.last_update = 0
|
|
self.logger.info("Initialized NHL Upcoming Manager")
|
|
self.current_game = None
|
|
|
|
if self.test_mode:
|
|
# Initialize with a test game
|
|
self.current_game = {
|
|
"home_abbr": "TBL",
|
|
"away_abbr": "DAL",
|
|
"status_text": "7:30 PM ET",
|
|
"home_logo_path": os.path.join(self.logo_dir, "TBL.png"),
|
|
"away_logo_path": os.path.join(self.logo_dir, "DAL.png"),
|
|
"game_time": "7:30 PM",
|
|
"game_date": "Apr 17",
|
|
"is_upcoming": True # Set this flag to indicate it's an upcoming game
|
|
}
|
|
logging.info("[NHL] Initialized NHLUpcomingManager with test game: TBL vs DAL")
|
|
else:
|
|
logging.info("[NHL] Initialized NHLUpcomingManager in live mode")
|
|
|
|
def update(self):
|
|
"""Update upcoming game data."""
|
|
current_time = time.time()
|
|
# Use longer interval if no game data
|
|
interval = self.no_data_interval if not self.current_game else self.update_interval
|
|
|
|
if current_time - self.last_update >= interval:
|
|
self.logger.debug("Updating upcoming game data")
|
|
self.last_update = current_time
|
|
if self.test_mode:
|
|
# In test mode, just keep the test game
|
|
pass
|
|
else:
|
|
# Fetch today's and tomorrow's data
|
|
today = datetime.now(timezone.utc).date()
|
|
tomorrow = today + timedelta(days=1)
|
|
|
|
# Format dates for API (YYYYMMDD)
|
|
today_str = today.strftime('%Y%m%d')
|
|
tomorrow_str = tomorrow.strftime('%Y%m%d')
|
|
|
|
# Fetch data for both days
|
|
today_data = self._fetch_data(today_str)
|
|
tomorrow_data = self._fetch_data(tomorrow_str)
|
|
|
|
# Combine events from both days
|
|
all_events = []
|
|
if today_data and "events" in today_data:
|
|
all_events.extend(today_data["events"])
|
|
if tomorrow_data and "events" in tomorrow_data:
|
|
all_events.extend(tomorrow_data["events"])
|
|
|
|
# Find the next upcoming game involving favorite teams
|
|
next_game = None
|
|
next_game_time = None
|
|
|
|
for event in all_events:
|
|
details = self._extract_game_details(event)
|
|
if details and details["is_upcoming"] and details["start_time_utc"]:
|
|
# Check if it involves favorite teams (if any are configured)
|
|
if not self.favorite_teams or (
|
|
details["home_abbr"] in self.favorite_teams or
|
|
details["away_abbr"] in self.favorite_teams
|
|
):
|
|
# Keep the soonest upcoming game
|
|
if next_game_time is None or details["start_time_utc"] < next_game_time:
|
|
next_game = details
|
|
next_game_time = details["start_time_utc"]
|
|
|
|
self.current_game = next_game
|
|
if next_game:
|
|
logging.info(f"[NHL] Found upcoming game: {next_game['away_abbr']} vs {next_game['home_abbr']}")
|
|
else:
|
|
logging.info("[NHL] No upcoming games found")
|
|
|
|
def display(self, force_clear: bool = False):
|
|
"""Display upcoming game information."""
|
|
self.logger.info("NHLUpcomingManager.display() called")
|
|
if not self.current_game:
|
|
logging.warning("[NHL] No upcoming game data available to display")
|
|
return
|
|
super().display(force_clear) # Call parent class's display method |