improved logic for checking last and next X games, will check up to one year

src/ncaa_fb_managers.py

@@ -179,21 +179,40 @@ class BaseNCAAFBManager: # Renamed class
                 BaseNCAAFBManager._last_shared_update = current_time
                 return cached_data
 
-            # For game-based fetching, we need to fetch a wider window to ensure we get enough games
+            # Smart game-based fetching: fetch incrementally until we have 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'))
-
-            BaseNCAAFBManager.logger.info(f"[NCAAFB] Fetching data for 30-day window to find {fetch_past_games} past and {fetch_future_games} future games")
-
             all_events = []
+            past_events = []
+            future_events = []
+            
+            # Start with today and expand outward until we have enough games
+            days_to_check = 0
+            max_days_to_check = 365  # Limit to 1 year to prevent infinite loops
+            
+            while (len(past_events) < fetch_past_games or len(future_events) < fetch_future_games) and days_to_check <= max_days_to_check:
+                # Check dates in both directions
+                dates_to_check = []
+                
+                # Check past dates
+                if len(past_events) < fetch_past_games:
+                    for i in range(1, days_to_check + 1):
+                        past_date = today - timedelta(days=i)
+                        dates_to_check.append(past_date.strftime('%Y%m%d'))
+                
+                # Check future dates
+                if len(future_events) < fetch_future_games:
+                    for i in range(1, days_to_check + 1):
+                        future_date = today + timedelta(days=i)
+                        dates_to_check.append(future_date.strftime('%Y%m%d'))
+                
+                # Also check today if we haven't already
+                if days_to_check == 0:
+                    dates_to_check.append(today.strftime('%Y%m%d'))
+                
+                BaseNCAAFBManager.logger.info(f"[NCAAFB] Checking {len(dates_to_check)} dates (day {days_to_check}) to find {fetch_past_games} past and {fetch_future_games} future games")
+                
                 # Fetch data for each date
-            for fetch_date in dates_to_fetch:
+                for fetch_date in dates_to_check:
                     date_cache_key = f"{fetch_date}_ncaafb"
                     cached_date_data = BaseNCAAFBManager.cache_manager.get(date_cache_key, max_age=300)
                     
@@ -215,7 +234,7 @@ class BaseNCAAFBManager: # Renamed class
                         BaseNCAAFBManager.logger.info(f"[NCAAFB] Fetched {len(date_data['events'])} events for date {fetch_date}")
                         BaseNCAAFBManager.cache_manager.set(date_cache_key, date_data)
                 
-            # Now filter events based on game counts
+                # Process newly fetched events
                 if all_events:
                     # Sort events by date
                     all_events.sort(key=lambda x: x.get('date', ''))
@@ -240,6 +259,8 @@ class BaseNCAAFBManager: # Renamed class
                             BaseNCAAFBManager.logger.warning(f"[NCAAFB] Could not parse event date: {e}")
                             continue
                 
+                days_to_check += 1
+            
             # 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 []
@@ -247,7 +268,7 @@ class BaseNCAAFBManager: # Renamed class
             # 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")
+            BaseNCAAFBManager.logger.info(f"[NCAAFB] Selected {len(selected_past_events)} past games and {len(selected_future_events)} future games after checking {days_to_check} days")
             
             # Create the final data structure
             data = {"events": selected_events}
@@ -255,9 +276,6 @@ class BaseNCAAFBManager: # Renamed class
             BaseNCAAFBManager._last_shared_update = current_time
             
             return data
-            else:
-                BaseNCAAFBManager.logger.warning("[NCAAFB] No events found in the fetched data")
-                return None
 
         except requests.exceptions.RequestException as e:
             BaseNCAAFBManager.logger.error(f"[NCAAFB] Error fetching data from ESPN: {e}")

src/nfl_managers.py

@@ -179,21 +179,40 @@ class BaseNFLManager: # Renamed class
                 BaseNFLManager._last_shared_update = current_time
                 return cached_data
 
-            # For game-based fetching, we need to fetch a wider window to ensure we get enough games
+            # Smart game-based fetching: fetch incrementally until we have 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'))
-
-            BaseNFLManager.logger.info(f"[NFL] Fetching data for 30-day window to find {fetch_past_games} past and {fetch_future_games} future games")
-
             all_events = []
+            past_events = []
+            future_events = []
+            
+            # Start with today and expand outward until we have enough games
+            days_to_check = 0
+            max_days_to_check = 365  # Limit to 1 year to prevent infinite loops
+            
+            while (len(past_events) < fetch_past_games or len(future_events) < fetch_future_games) and days_to_check <= max_days_to_check:
+                # Check dates in both directions
+                dates_to_check = []
+                
+                # Check past dates
+                if len(past_events) < fetch_past_games:
+                    for i in range(1, days_to_check + 1):
+                        past_date = today - timedelta(days=i)
+                        dates_to_check.append(past_date.strftime('%Y%m%d'))
+                
+                # Check future dates
+                if len(future_events) < fetch_future_games:
+                    for i in range(1, days_to_check + 1):
+                        future_date = today + timedelta(days=i)
+                        dates_to_check.append(future_date.strftime('%Y%m%d'))
+                
+                # Also check today if we haven't already
+                if days_to_check == 0:
+                    dates_to_check.append(today.strftime('%Y%m%d'))
+                
+                BaseNFLManager.logger.info(f"[NFL] Checking {len(dates_to_check)} dates (day {days_to_check}) to find {fetch_past_games} past and {fetch_future_games} future games")
+                
                 # Fetch data for each date
-            for fetch_date in dates_to_fetch:
+                for fetch_date in dates_to_check:
                     date_cache_key = f"{fetch_date}_nfl"
                     cached_date_data = BaseNFLManager.cache_manager.get(date_cache_key, max_age=300)
                     
@@ -215,7 +234,7 @@ class BaseNFLManager: # Renamed class
                         BaseNFLManager.logger.info(f"[NFL] Fetched {len(date_data['events'])} events for date {fetch_date}")
                         BaseNFLManager.cache_manager.set(date_cache_key, date_data)
                 
-            # Now filter events based on game counts
+                # Process newly fetched events
                 if all_events:
                     # Sort events by date
                     all_events.sort(key=lambda x: x.get('date', ''))
@@ -240,6 +259,8 @@ class BaseNFLManager: # Renamed class
                             BaseNFLManager.logger.warning(f"[NFL] Could not parse event date: {e}")
                             continue
                 
+                days_to_check += 1
+            
             # 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 []
@@ -247,7 +268,7 @@ class BaseNFLManager: # Renamed class
             # 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")
+            BaseNFLManager.logger.info(f"[NFL] Selected {len(selected_past_events)} past games and {len(selected_future_events)} future games after checking {days_to_check} days")
             
             # Create the final data structure
             data = {"events": selected_events}
@@ -255,9 +276,6 @@ class BaseNFLManager: # Renamed class
             BaseNFLManager._last_shared_update = current_time
             
             return data
-            else:
-                BaseNFLManager.logger.warning("[NFL] No events found in the fetched data")
-                return None
 
         except requests.exceptions.RequestException as e:
             BaseNFLManager.logger.error(f"[NFL] Error fetching data from ESPN: {e}")