rick/LEDMatrix
1
0
Fork 0
mirror of https://github.com/ChuckBuilds/LEDMatrix.git synced 2026-04-11 13:23:00 +00:00
Code Issues Packages Projects Releases Wiki Activity

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

Browse Source
This commit is contained in:
Chuck
2025-07-21 17:18:25 -05:00
parent e9cf2829da
commit 8feddb3a82
2 changed files with 172 additions and 136 deletions
Download Patch File Download Diff File Expand all files Collapse all files

144
src/ncaa_fb_managers.py
View File

@@ -179,85 +179,103 @@ class BaseNCAAFBManager: # Renamed class
BaseNCAAFBManager._last_shared_update = current_time BaseNCAAFBManager._last_shared_update = current_time
return cached_data 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() 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 = [] all_events = []
# Fetch data for each date past_events = []
for fetch_date in dates_to_fetch: future_events = []
date_cache_key = f"{fetch_date}_ncaafb"
cached_date_data = BaseNCAAFBManager.cache_manager.get(date_cache_key, max_age=300)
if cached_date_data: # Start with today and expand outward until we have enough games
BaseNCAAFBManager.logger.info(f"[NCAAFB] Using cached data for date {fetch_date}") days_to_check = 0
if "events" in cached_date_data: max_days_to_check = 365 # Limit to 1 year to prevent infinite loops
all_events.extend(cached_date_data["events"])
continue
url = ESPN_NCAAFB_SCOREBOARD_URL while (len(past_events) < fetch_past_games or len(future_events) < fetch_future_games) and days_to_check <= max_days_to_check:
params = {'dates': fetch_date} # Check dates in both directions
dates_to_check = []
response = requests.get(url, params=params) # Check past dates
response.raise_for_status() if len(past_events) < fetch_past_games:
date_data = response.json() 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'))
if date_data and "events" in date_data: # Check future dates
all_events.extend(date_data["events"]) if len(future_events) < fetch_future_games:
BaseNCAAFBManager.logger.info(f"[NCAAFB] Fetched {len(date_data['events'])} events for date {fetch_date}") for i in range(1, days_to_check + 1):
BaseNCAAFBManager.cache_manager.set(date_cache_key, date_data) future_date = today + timedelta(days=i)
dates_to_check.append(future_date.strftime('%Y%m%d'))
# Now filter events based on game counts # Also check today if we haven't already
if all_events: if days_to_check == 0:
# Sort events by date dates_to_check.append(today.strftime('%Y%m%d'))
all_events.sort(key=lambda x: x.get('date', ''))
# Separate past and future events 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")
now = datetime.now(self._get_timezone())
past_events = []
future_events = []
for event in all_events: # Fetch data for each date
try: for fetch_date in dates_to_check:
event_time = datetime.fromisoformat(event['date'].replace('Z', '+00:00')) date_cache_key = f"{fetch_date}_ncaafb"
if event_time.tzinfo is None: cached_date_data = BaseNCAAFBManager.cache_manager.get(date_cache_key, max_age=300)
event_time = event_time.replace(tzinfo=pytz.UTC)
event_time = event_time.astimezone(self._get_timezone())
if event_time < now: if cached_date_data:
past_events.append(event) BaseNCAAFBManager.logger.info(f"[NCAAFB] Using cached data for date {fetch_date}")
else: if "events" in cached_date_data:
future_events.append(event) all_events.extend(cached_date_data["events"])
except Exception as e:
BaseNCAAFBManager.logger.warning(f"[NCAAFB] Could not parse event date: {e}")
continue continue
# Take the specified number of games url = ESPN_NCAAFB_SCOREBOARD_URL
selected_past_events = past_events[-fetch_past_games:] if past_events else [] params = {'dates': fetch_date}
selected_future_events = future_events[:fetch_future_games] if future_events else []
# Combine selected events response = requests.get(url, params=params)
selected_events = selected_past_events + selected_future_events response.raise_for_status()
date_data = response.json()
BaseNCAAFBManager.logger.info(f"[NCAAFB] Selected {len(selected_past_events)} past games and {len(selected_future_events)} future games") 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)
# Create the final data structure # Process newly fetched events
data = {"events": selected_events} if all_events:
BaseNCAAFBManager._shared_data = data # Sort events by date
BaseNCAAFBManager._last_shared_update = current_time all_events.sort(key=lambda x: x.get('date', ''))
return data # Separate past and future events
else: now = datetime.now(self._get_timezone())
BaseNCAAFBManager.logger.warning("[NCAAFB] No events found in the fetched data") past_events = []
return None 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
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 []
# 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 after checking {days_to_check} days")
# Create the final data structure
data = {"events": selected_events}
BaseNCAAFBManager._shared_data = data
BaseNCAAFBManager._last_shared_update = current_time
return data
except requests.exceptions.RequestException as e: except requests.exceptions.RequestException as e:
BaseNCAAFBManager.logger.error(f"[NCAAFB] Error fetching data from ESPN: {e}") BaseNCAAFBManager.logger.error(f"[NCAAFB] Error fetching data from ESPN: {e}")

144
src/nfl_managers.py
View File

@@ -179,85 +179,103 @@ class BaseNFLManager: # Renamed class
BaseNFLManager._last_shared_update = current_time BaseNFLManager._last_shared_update = current_time
return cached_data 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() 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 = [] all_events = []
# Fetch data for each date past_events = []
for fetch_date in dates_to_fetch: future_events = []
date_cache_key = f"{fetch_date}_nfl"
cached_date_data = BaseNFLManager.cache_manager.get(date_cache_key, max_age=300)
if cached_date_data: # Start with today and expand outward until we have enough games
BaseNFLManager.logger.info(f"[NFL] Using cached data for date {fetch_date}") days_to_check = 0
if "events" in cached_date_data: max_days_to_check = 365 # Limit to 1 year to prevent infinite loops
all_events.extend(cached_date_data["events"])
continue
url = ESPN_NFL_SCOREBOARD_URL while (len(past_events) < fetch_past_games or len(future_events) < fetch_future_games) and days_to_check <= max_days_to_check:
params = {'dates': fetch_date} # Check dates in both directions
dates_to_check = []
response = requests.get(url, params=params) # Check past dates
response.raise_for_status() if len(past_events) < fetch_past_games:
date_data = response.json() 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'))
if date_data and "events" in date_data: # Check future dates
all_events.extend(date_data["events"]) if len(future_events) < fetch_future_games:
BaseNFLManager.logger.info(f"[NFL] Fetched {len(date_data['events'])} events for date {fetch_date}") for i in range(1, days_to_check + 1):
BaseNFLManager.cache_manager.set(date_cache_key, date_data) future_date = today + timedelta(days=i)
dates_to_check.append(future_date.strftime('%Y%m%d'))
# Now filter events based on game counts # Also check today if we haven't already
if all_events: if days_to_check == 0:
# Sort events by date dates_to_check.append(today.strftime('%Y%m%d'))
all_events.sort(key=lambda x: x.get('date', ''))
# Separate past and future events 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")
now = datetime.now(self._get_timezone())
past_events = []
future_events = []
for event in all_events: # Fetch data for each date
try: for fetch_date in dates_to_check:
event_time = datetime.fromisoformat(event['date'].replace('Z', '+00:00')) date_cache_key = f"{fetch_date}_nfl"
if event_time.tzinfo is None: cached_date_data = BaseNFLManager.cache_manager.get(date_cache_key, max_age=300)
event_time = event_time.replace(tzinfo=pytz.UTC)
event_time = event_time.astimezone(self._get_timezone())
if event_time < now: if cached_date_data:
past_events.append(event) BaseNFLManager.logger.info(f"[NFL] Using cached data for date {fetch_date}")
else: if "events" in cached_date_data:
future_events.append(event) all_events.extend(cached_date_data["events"])
except Exception as e:
BaseNFLManager.logger.warning(f"[NFL] Could not parse event date: {e}")
continue continue
# Take the specified number of games url = ESPN_NFL_SCOREBOARD_URL
selected_past_events = past_events[-fetch_past_games:] if past_events else [] params = {'dates': fetch_date}
selected_future_events = future_events[:fetch_future_games] if future_events else []
# Combine selected events response = requests.get(url, params=params)
selected_events = selected_past_events + selected_future_events response.raise_for_status()
date_data = response.json()
BaseNFLManager.logger.info(f"[NFL] Selected {len(selected_past_events)} past games and {len(selected_future_events)} future games") 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)
# Create the final data structure # Process newly fetched events
data = {"events": selected_events} if all_events:
BaseNFLManager._shared_data = data # Sort events by date
BaseNFLManager._last_shared_update = current_time all_events.sort(key=lambda x: x.get('date', ''))
return data # Separate past and future events
else: now = datetime.now(self._get_timezone())
BaseNFLManager.logger.warning("[NFL] No events found in the fetched data") past_events = []
return None 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
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 []
# 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 after checking {days_to_check} days")
# Create the final data structure
data = {"events": selected_events}
BaseNFLManager._shared_data = data
BaseNFLManager._last_shared_update = current_time
return data
except requests.exceptions.RequestException as e: except requests.exceptions.RequestException as e:
BaseNFLManager.logger.error(f"[NFL] Error fetching data from ESPN: {e}") BaseNFLManager.logger.error(f"[NFL] Error fetching data from ESPN: {e}")