From e9cf2829da4847d54a098086950a10668670bd9b Mon Sep 17 00:00:00 2001 From: Chuck <33324927+ChuckBuilds@users.noreply.github.com> Date: Mon, 21 Jul 2025 16:51:29 -0500 Subject: [PATCH] change football logic from days to games. --- README.md | 49 +++++++++++++++ config/config.json | 8 +-- src/ncaa_fb_managers.py | 133 ++++++++++++++++++++++++---------------- src/nfl_managers.py | 133 ++++++++++++++++++++++++---------------- 4 files changed, 211 insertions(+), 112 deletions(-) diff --git a/README.md b/README.md index d4130d12..88ca000f 100644 --- a/README.md +++ b/README.md @@ -442,6 +442,55 @@ This will: 3. Display sample games 4. Test the scrolling functionality +## Football Game-Based Configuration (NFL & NCAA FB) + +For NFL and NCAA Football, the system now uses a game-based fetch approach instead of time-based windows. This is more practical for football since games are weekly and you want to show specific numbers of games rather than arbitrary time periods. + +### Configuration Options + +Instead of using `past_fetch_days` and `future_fetch_days`, the system now uses: + +- **`fetch_past_games`**: Number of recent games to fetch (default: 1) +- **`fetch_future_games`**: Number of upcoming games to fetch (default: 1) + +### Example Configuration + +```json +{ + "nfl_scoreboard": { + "enabled": true, + "fetch_past_games": 1, + "fetch_future_games": 1, + "favorite_teams": ["TB", "DAL"] + }, + "ncaa_fb_scoreboard": { + "enabled": true, + "fetch_past_games": 1, + "fetch_future_games": 1, + "favorite_teams": ["UGA", "AUB"] + } +} +``` + +### How It Works + +- **`fetch_past_games: 1`**: Shows the most recent game for your favorite teams +- **`fetch_future_games: 1`**: Shows the next upcoming game for your favorite teams +- **`fetch_future_games: 2`**: Shows the next two upcoming games (e.g., Week 1 and Week 2 matchups) + +### Benefits + +1. **Predictable Results**: Always shows exactly the number of games you specify +2. **Season Flexibility**: Works well both during the season and in the off-season +3. **Future Planning**: Can show games far in the future (e.g., Week 1 when it's 40 days away) +4. **Efficient**: Only fetches the games you actually want to see + +### Use Cases + +- **During Season**: `fetch_future_games: 1` shows next week's game +- **Off-Season**: `fetch_future_games: 1` shows the first scheduled game (even if it's months away) +- **Planning**: `fetch_future_games: 2` shows the next two matchups for planning purposes + ## Music Display Configuration The Music Display module shows information about the currently playing track from either Spotify or YouTube Music (via the [YouTube Music Desktop App](https://ytmdesktop.app/) companion server). diff --git a/config/config.json b/config/config.json index aaa1c6cc..137d0efe 100644 --- a/config/config.json +++ b/config/config.json @@ -176,8 +176,8 @@ "live_update_interval": 30, "live_odds_update_interval": 3600, "odds_update_interval": 3600, - "past_fetch_days": 7, - "future_fetch_days": 7, + "fetch_past_games": 1, + "fetch_future_games": 1, "favorite_teams": ["TB", "DAL"], "logo_dir": "assets/sports/nfl_logos", "show_records": true, @@ -195,8 +195,8 @@ "live_update_interval": 30, "live_odds_update_interval": 3600, "odds_update_interval": 3600, - "past_fetch_days": 7, - "future_fetch_days": 7, + "fetch_past_games": 1, + "fetch_future_games": 1, "favorite_teams": ["UGA", "AUB"], "logo_dir": "assets/sports/ncaa_fbs_logos", "show_records": true, diff --git a/src/ncaa_fb_managers.py b/src/ncaa_fb_managers.py index d5d0a2cd..116ee50c 100644 --- a/src/ncaa_fb_managers.py +++ b/src/ncaa_fb_managers.py @@ -102,8 +102,8 @@ class BaseNCAAFBManager: # Renamed class self.current_game = None self.fonts = self._load_fonts() self.favorite_teams = self.ncaa_fb_config.get("favorite_teams", []) - self.past_fetch_days = self.ncaa_fb_config.get("past_fetch_days", 7) - self.future_fetch_days = self.ncaa_fb_config.get("future_fetch_days", 7) + self.fetch_past_games = self.ncaa_fb_config.get("fetch_past_games", 1) + self.fetch_future_games = self.ncaa_fb_config.get("fetch_future_games", 1) self.logger.setLevel(logging.DEBUG) @@ -163,15 +163,15 @@ class BaseNCAAFBManager: # Renamed class except Exception as e: self.logger.error(f"Error fetching odds for game {game.get('id', 'N/A')}: {e}") - def _fetch_shared_data(self, past_days: int, future_days: int, date_str: str = None) -> Optional[Dict]: - """Fetch and cache data for all managers to share.""" + def _fetch_shared_data(self, fetch_past_games: int, fetch_future_games: int, date_str: str = None) -> Optional[Dict]: + """Fetch and cache data for all managers to share, using game counts instead of days.""" current_time = time.time() if BaseNCAAFBManager._shared_data and (current_time - BaseNCAAFBManager._last_shared_update) < 300: return BaseNCAAFBManager._shared_data try: - cache_key = date_str if date_str else 'today_ncaafb' # Changed cache key prefix + cache_key = date_str if date_str else 'today_ncaafb' cached_data = BaseNCAAFBManager.cache_manager.get(cache_key, max_age=300) if cached_data: BaseNCAAFBManager.logger.info(f"[NCAAFB] Using cached data for {cache_key}") @@ -179,61 +179,86 @@ class BaseNCAAFBManager: # Renamed class BaseNCAAFBManager._last_shared_update = current_time return cached_data - url = ESPN_NCAAFB_SCOREBOARD_URL # Use NCAA FB URL - params = {} - if date_str: - params['dates'] = date_str + # For game-based fetching, we need to fetch a wider window to ensure we get enough games + # Use a 30-day window to ensure we capture enough games + today = datetime.now(self._get_timezone()).date() + dates_to_fetch = [] + + # Generate dates for a 30-day window (15 days past, 15 days future) + for i in range(-15, 16): + fetch_dt = today + timedelta(days=i) + dates_to_fetch.append(fetch_dt.strftime('%Y%m%d')) - response = requests.get(url, params=params) - response.raise_for_status() - data = response.json() - BaseNCAAFBManager.logger.info(f"[NCAAFB] Successfully fetched data from ESPN API") + BaseNCAAFBManager.logger.info(f"[NCAAFB] Fetching data for 30-day window to find {fetch_past_games} past and {fetch_future_games} future games") - BaseNCAAFBManager.cache_manager.set(cache_key, data) - BaseNCAAFBManager._shared_data = data - BaseNCAAFBManager._last_shared_update = current_time + all_events = [] + # Fetch data for each date + for fetch_date in dates_to_fetch: + date_cache_key = f"{fetch_date}_ncaafb" + cached_date_data = BaseNCAAFBManager.cache_manager.get(date_cache_key, max_age=300) + + if cached_date_data: + BaseNCAAFBManager.logger.info(f"[NCAAFB] Using cached data for date {fetch_date}") + if "events" in cached_date_data: + all_events.extend(cached_date_data["events"]) + continue - if not date_str: - today = datetime.now(self._get_timezone()).date() - dates_to_fetch = [] - # Generate dates from past_days ago to future_days ahead - for i in range(-past_days, future_days + 1): - fetch_dt = today + timedelta(days=i) - dates_to_fetch.append(fetch_dt.strftime('%Y%m%d')) + url = ESPN_NCAAFB_SCOREBOARD_URL + params = {'dates': fetch_date} + + response = requests.get(url, params=params) + response.raise_for_status() + date_data = response.json() + + if date_data and "events" in date_data: + all_events.extend(date_data["events"]) + BaseNCAAFBManager.logger.info(f"[NCAAFB] Fetched {len(date_data['events'])} events for date {fetch_date}") + BaseNCAAFBManager.cache_manager.set(date_cache_key, date_data) - BaseNCAAFBManager.logger.info(f"[NCAAFB] Fetching data for dates: {dates_to_fetch}") - - all_events = [] - # Fetch data for each date (excluding today if already fetched) - for fetch_date in dates_to_fetch: - if fetch_date == today.strftime('%Y%m%d') and cache_key == 'today_ncaafb': # Skip today if already fetched initially + # Now filter events based on game counts + if all_events: + # Sort events by date + all_events.sort(key=lambda x: x.get('date', '')) + + # Separate past and future events + now = datetime.now(self._get_timezone()) + past_events = [] + future_events = [] + + for event in all_events: + try: + event_time = datetime.fromisoformat(event['date'].replace('Z', '+00:00')) + if event_time.tzinfo is None: + event_time = event_time.replace(tzinfo=pytz.UTC) + event_time = event_time.astimezone(self._get_timezone()) + + if event_time < now: + past_events.append(event) + else: + future_events.append(event) + except Exception as e: + BaseNCAAFBManager.logger.warning(f"[NCAAFB] Could not parse event date: {e}") continue - date_cache_key = f"{fetch_date}_ncaafb" # Changed cache key suffix - cached_date_data = BaseNCAAFBManager.cache_manager.get(date_cache_key, max_age=300) - if cached_date_data: - BaseNCAAFBManager.logger.info(f"[NCAAFB] Using cached data for date {fetch_date}") - if "events" in cached_date_data: - all_events.extend(cached_date_data["events"]) - continue + # Take the specified number of games + selected_past_events = past_events[-fetch_past_games:] if past_events else [] + selected_future_events = future_events[:fetch_future_games] if future_events else [] + + # Combine selected events + selected_events = selected_past_events + selected_future_events + + BaseNCAAFBManager.logger.info(f"[NCAAFB] Selected {len(selected_past_events)} past games and {len(selected_future_events)} future games") + + # Create the final data structure + data = {"events": selected_events} + BaseNCAAFBManager._shared_data = data + BaseNCAAFBManager._last_shared_update = current_time + + return data + else: + BaseNCAAFBManager.logger.warning("[NCAAFB] No events found in the fetched data") + return None - params['dates'] = fetch_date - response = requests.get(url, params=params) - response.raise_for_status() - date_data = response.json() - if date_data and "events" in date_data: - all_events.extend(date_data["events"]) - BaseNCAAFBManager.logger.info(f"[NCAAFB] Fetched {len(date_data['events'])} events for date {fetch_date}") - BaseNCAAFBManager.cache_manager.set(date_cache_key, date_data) - - if all_events: - if "events" not in data: data["events"] = [] # Ensure 'events' key exists - data["events"].extend(all_events) - BaseNCAAFBManager.logger.info(f"[NCAAFB] Combined {len(data['events'])} total events from all dates") - BaseNCAAFBManager._shared_data = data - BaseNCAAFBManager._last_shared_update = current_time - - return data except requests.exceptions.RequestException as e: BaseNCAAFBManager.logger.error(f"[NCAAFB] Error fetching data from ESPN: {e}") return None @@ -258,7 +283,7 @@ class BaseNCAAFBManager: # Renamed class return None else: # For non-live games, use the shared cache - return self._fetch_shared_data(self.past_fetch_days, self.future_fetch_days, date_str) + return self._fetch_shared_data(self.fetch_past_games, self.fetch_future_games, date_str) def _load_fonts(self): """Load fonts used by the scoreboard.""" diff --git a/src/nfl_managers.py b/src/nfl_managers.py index ccd6a6dd..7b632d07 100644 --- a/src/nfl_managers.py +++ b/src/nfl_managers.py @@ -102,8 +102,8 @@ class BaseNFLManager: # Renamed class self.current_game = None self.fonts = self._load_fonts() self.favorite_teams = self.nfl_config.get("favorite_teams", []) - self.past_fetch_days = self.nfl_config.get("past_fetch_days", 7) - self.future_fetch_days = self.nfl_config.get("future_fetch_days", 7) + self.fetch_past_games = self.nfl_config.get("fetch_past_games", 1) + self.fetch_future_games = self.nfl_config.get("fetch_future_games", 1) self.logger.setLevel(logging.DEBUG) @@ -163,15 +163,15 @@ class BaseNFLManager: # Renamed class except Exception as e: self.logger.error(f"Error fetching odds for game {game.get('id', 'N/A')}: {e}") - def _fetch_shared_data(self, past_days: int, future_days: int, date_str: str = None) -> Optional[Dict]: - """Fetch and cache data for all managers to share.""" + def _fetch_shared_data(self, fetch_past_games: int, fetch_future_games: int, date_str: str = None) -> Optional[Dict]: + """Fetch and cache data for all managers to share, using game counts instead of days.""" current_time = time.time() if BaseNFLManager._shared_data and (current_time - BaseNFLManager._last_shared_update) < 300: return BaseNFLManager._shared_data try: - cache_key = date_str if date_str else 'today_nfl' # Changed cache key prefix + cache_key = date_str if date_str else 'today_nfl' cached_data = BaseNFLManager.cache_manager.get(cache_key, max_age=300) if cached_data: BaseNFLManager.logger.info(f"[NFL] Using cached data for {cache_key}") @@ -179,61 +179,86 @@ class BaseNFLManager: # Renamed class BaseNFLManager._last_shared_update = current_time return cached_data - url = ESPN_NFL_SCOREBOARD_URL # Use NFL URL - params = {} - if date_str: - params['dates'] = date_str + # For game-based fetching, we need to fetch a wider window to ensure we get enough games + # Use a 30-day window to ensure we capture enough games + today = datetime.now(self._get_timezone()).date() + dates_to_fetch = [] + + # Generate dates for a 30-day window (15 days past, 15 days future) + for i in range(-15, 16): + fetch_dt = today + timedelta(days=i) + dates_to_fetch.append(fetch_dt.strftime('%Y%m%d')) - response = requests.get(url, params=params) - response.raise_for_status() - data = response.json() - BaseNFLManager.logger.info(f"[NFL] Successfully fetched data from ESPN API") + BaseNFLManager.logger.info(f"[NFL] Fetching data for 30-day window to find {fetch_past_games} past and {fetch_future_games} future games") - BaseNFLManager.cache_manager.set(cache_key, data) - BaseNFLManager._shared_data = data - BaseNFLManager._last_shared_update = current_time + all_events = [] + # Fetch data for each date + for fetch_date in dates_to_fetch: + date_cache_key = f"{fetch_date}_nfl" + cached_date_data = BaseNFLManager.cache_manager.get(date_cache_key, max_age=300) + + if cached_date_data: + BaseNFLManager.logger.info(f"[NFL] Using cached data for date {fetch_date}") + if "events" in cached_date_data: + all_events.extend(cached_date_data["events"]) + continue - if not date_str: - today = datetime.now(self._get_timezone()).date() - dates_to_fetch = [] - # Generate dates from past_days ago to future_days ahead - for i in range(-past_days, future_days + 1): - fetch_dt = today + timedelta(days=i) - dates_to_fetch.append(fetch_dt.strftime('%Y%m%d')) + url = ESPN_NFL_SCOREBOARD_URL + params = {'dates': fetch_date} + + response = requests.get(url, params=params) + response.raise_for_status() + date_data = response.json() + + if date_data and "events" in date_data: + all_events.extend(date_data["events"]) + BaseNFLManager.logger.info(f"[NFL] Fetched {len(date_data['events'])} events for date {fetch_date}") + BaseNFLManager.cache_manager.set(date_cache_key, date_data) - BaseNFLManager.logger.info(f"[NFL] Fetching data for dates: {dates_to_fetch}") - - all_events = [] - # Fetch data for each date (excluding today if already fetched) - for fetch_date in dates_to_fetch: - if fetch_date == today.strftime('%Y%m%d') and cache_key == 'today_nfl': # Skip today if already fetched initially + # Now filter events based on game counts + if all_events: + # Sort events by date + all_events.sort(key=lambda x: x.get('date', '')) + + # Separate past and future events + now = datetime.now(self._get_timezone()) + past_events = [] + future_events = [] + + for event in all_events: + try: + event_time = datetime.fromisoformat(event['date'].replace('Z', '+00:00')) + if event_time.tzinfo is None: + event_time = event_time.replace(tzinfo=pytz.UTC) + event_time = event_time.astimezone(self._get_timezone()) + + if event_time < now: + past_events.append(event) + else: + future_events.append(event) + except Exception as e: + BaseNFLManager.logger.warning(f"[NFL] Could not parse event date: {e}") continue - date_cache_key = f"{fetch_date}_nfl" - cached_date_data = BaseNFLManager.cache_manager.get(date_cache_key, max_age=300) - if cached_date_data: - BaseNFLManager.logger.info(f"[NFL] Using cached data for date {fetch_date}") - if "events" in cached_date_data: - all_events.extend(cached_date_data["events"]) - continue + # Take the specified number of games + selected_past_events = past_events[-fetch_past_games:] if past_events else [] + selected_future_events = future_events[:fetch_future_games] if future_events else [] + + # Combine selected events + selected_events = selected_past_events + selected_future_events + + BaseNFLManager.logger.info(f"[NFL] Selected {len(selected_past_events)} past games and {len(selected_future_events)} future games") + + # Create the final data structure + data = {"events": selected_events} + BaseNFLManager._shared_data = data + BaseNFLManager._last_shared_update = current_time + + return data + else: + BaseNFLManager.logger.warning("[NFL] No events found in the fetched data") + return None - params['dates'] = fetch_date - response = requests.get(url, params=params) - response.raise_for_status() - date_data = response.json() - if date_data and "events" in date_data: - all_events.extend(date_data["events"]) - BaseNFLManager.logger.info(f"[NFL] Fetched {len(date_data['events'])} events for date {fetch_date}") - BaseNFLManager.cache_manager.set(date_cache_key, date_data) - - if all_events: - if "events" not in data: data["events"] = [] # Ensure 'events' key exists - data["events"].extend(all_events) - BaseNFLManager.logger.info(f"[NFL] Combined {len(data['events'])} total events from all dates") - BaseNFLManager._shared_data = data - BaseNFLManager._last_shared_update = current_time - - return data except requests.exceptions.RequestException as e: BaseNFLManager.logger.error(f"[NFL] Error fetching data from ESPN: {e}") return None @@ -258,7 +283,7 @@ class BaseNFLManager: # Renamed class return None else: # For non-live games, use the shared cache - return self._fetch_shared_data(self.past_fetch_days, self.future_fetch_days, date_str) + return self._fetch_shared_data(self.fetch_past_games, self.fetch_future_games, date_str) def _load_fonts(self): """Load fonts used by the scoreboard."""