change football logic from days to games.

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).

config/config.json

@@ -176,8 +176,8 @@
         "live_update_interval": 30,
         "live_odds_update_interval": 3600,
         "odds_update_interval": 3600,
-        "past_fetch_days": 7,
+        "fetch_past_games": 1,
-        "future_fetch_days": 7,
+        "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,
+        "fetch_past_games": 1,
-        "future_fetch_days": 7,
+        "fetch_future_games": 1,
         "favorite_teams": ["UGA", "AUB"],
         "logo_dir": "assets/sports/ncaa_fbs_logos",
         "show_records": true,

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.fetch_past_games = self.ncaa_fb_config.get("fetch_past_games", 1)
-        self.future_fetch_days = self.ncaa_fb_config.get("future_fetch_days", 7)
+        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]:
+    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."""
+        """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
+            # For game-based fetching, we need to fetch a wider window to ensure we get enough games
-            params = {}
+            # Use a 30-day window to ensure we capture enough games
-            if date_str:
+            today = datetime.now(self._get_timezone()).date()
-                params['dates'] = date_str
+            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)
+            BaseNCAAFBManager.logger.info(f"[NCAAFB] Fetching data for 30-day window to find {fetch_past_games} past and {fetch_future_games} future games")
-            response.raise_for_status()
-            data = response.json()
-            BaseNCAAFBManager.logger.info(f"[NCAAFB] Successfully fetched data from ESPN API")
 
-            BaseNCAAFBManager.cache_manager.set(cache_key, data)
+            all_events = []
-            BaseNCAAFBManager._shared_data = data
+            # Fetch data for each date
-            BaseNCAAFBManager._last_shared_update = current_time
+            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:
+                url = ESPN_NCAAFB_SCOREBOARD_URL
-                today = datetime.now(self._get_timezone()).date()
+                params = {'dates': fetch_date}
-                dates_to_fetch = []
+                
-                # Generate dates from past_days ago to future_days ahead
+                response = requests.get(url, params=params)
-                for i in range(-past_days, future_days + 1):
+                response.raise_for_status()
-                     fetch_dt = today + timedelta(days=i)
+                date_data = response.json()
-                     dates_to_fetch.append(fetch_dt.strftime('%Y%m%d'))
+                
+                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}")
+            # Now filter events based on game counts
-
+            if all_events:
-                all_events = []
+                # Sort events by date
-                # Fetch data for each date (excluding today if already fetched)
+                all_events.sort(key=lambda x: x.get('date', ''))
-                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
+                # 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
+                # Take the specified number of games
-                    cached_date_data = BaseNCAAFBManager.cache_manager.get(date_cache_key, max_age=300)
+                selected_past_events = past_events[-fetch_past_games:] if past_events else []
-                    if cached_date_data:
+                selected_future_events = future_events[:fetch_future_games] if future_events else []
-                        BaseNCAAFBManager.logger.info(f"[NCAAFB] Using cached data for date {fetch_date}")
+                
-                        if "events" in cached_date_data:
+                # Combine selected events
-                            all_events.extend(cached_date_data["events"])
+                selected_events = selected_past_events + selected_future_events
-                        continue
+                
+                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."""

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.fetch_past_games = self.nfl_config.get("fetch_past_games", 1)
-        self.future_fetch_days = self.nfl_config.get("future_fetch_days", 7)
+        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]:
+    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."""
+        """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
+            # For game-based fetching, we need to fetch a wider window to ensure we get enough games
-            params = {}
+            # Use a 30-day window to ensure we capture enough games
-            if date_str:
+            today = datetime.now(self._get_timezone()).date()
-                params['dates'] = date_str
+            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)
+            BaseNFLManager.logger.info(f"[NFL] Fetching data for 30-day window to find {fetch_past_games} past and {fetch_future_games} future games")
-            response.raise_for_status()
-            data = response.json()
-            BaseNFLManager.logger.info(f"[NFL] Successfully fetched data from ESPN API")
 
-            BaseNFLManager.cache_manager.set(cache_key, data)
+            all_events = []
-            BaseNFLManager._shared_data = data
+            # Fetch data for each date
-            BaseNFLManager._last_shared_update = current_time
+            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:
+                url = ESPN_NFL_SCOREBOARD_URL
-                today = datetime.now(self._get_timezone()).date()
+                params = {'dates': fetch_date}
-                dates_to_fetch = []
+                
-                # Generate dates from past_days ago to future_days ahead
+                response = requests.get(url, params=params)
-                for i in range(-past_days, future_days + 1):
+                response.raise_for_status()
-                     fetch_dt = today + timedelta(days=i)
+                date_data = response.json()
-                     dates_to_fetch.append(fetch_dt.strftime('%Y%m%d'))
+                
+                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}")
+            # Now filter events based on game counts
-
+            if all_events:
-                all_events = []
+                # Sort events by date
-                # Fetch data for each date (excluding today if already fetched)
+                all_events.sort(key=lambda x: x.get('date', ''))
-                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
+                # 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"
+                # Take the specified number of games
-                    cached_date_data = BaseNFLManager.cache_manager.get(date_cache_key, max_age=300)
+                selected_past_events = past_events[-fetch_past_games:] if past_events else []
-                    if cached_date_data:
+                selected_future_events = future_events[:fetch_future_games] if future_events else []
-                        BaseNFLManager.logger.info(f"[NFL] Using cached data for date {fetch_date}")
+                
-                        if "events" in cached_date_data:
+                # Combine selected events
-                            all_events.extend(cached_date_data["events"])
+                selected_events = selected_past_events + selected_future_events
-                        continue
+                
+                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."""