ensure displays share config file

src/display_controller.py

@@ -16,6 +16,7 @@ from src.clock import Clock
 from src.weather_manager import WeatherManager
 from src.display_manager import DisplayManager
 from src.config_manager import ConfigManager
+from src.cache_manager import CacheManager
 from src.stock_manager import StockManager
 from src.stock_news_manager import StockNewsManager
 from src.odds_ticker_manager import OddsTickerManager
@@ -45,6 +46,7 @@ class DisplayController:
         
         self.config_manager = ConfigManager()
         self.config = self.config_manager.load_config()
+        self.cache_manager = CacheManager()
         logger.info("Config loaded in %.3f seconds", time.time() - start_time)
         
         config_time = time.time()
@@ -101,9 +103,9 @@ class DisplayController:
         nhl_display_modes = self.config.get('nhl_scoreboard', {}).get('display_modes', {})
         
         if nhl_enabled:
-            self.nhl_live = NHLLiveManager(self.config, self.display_manager) if nhl_display_modes.get('nhl_live', True) else None
+            self.nhl_live = NHLLiveManager(self.config, self.display_manager, self.cache_manager) if nhl_display_modes.get('nhl_live', True) else None
-            self.nhl_recent = NHLRecentManager(self.config, self.display_manager) if nhl_display_modes.get('nhl_recent', True) else None
+            self.nhl_recent = NHLRecentManager(self.config, self.display_manager, self.cache_manager) if nhl_display_modes.get('nhl_recent', True) else None
-            self.nhl_upcoming = NHLUpcomingManager(self.config, self.display_manager) if nhl_display_modes.get('nhl_upcoming', True) else None
+            self.nhl_upcoming = NHLUpcomingManager(self.config, self.display_manager, self.cache_manager) if nhl_display_modes.get('nhl_upcoming', True) else None
         else:
             self.nhl_live = None
             self.nhl_recent = None
@@ -116,9 +118,9 @@ class DisplayController:
         nba_display_modes = self.config.get('nba_scoreboard', {}).get('display_modes', {})
         
         if nba_enabled:
-            self.nba_live = NBALiveManager(self.config, self.display_manager) if nba_display_modes.get('nba_live', True) else None
+            self.nba_live = NBALiveManager(self.config, self.display_manager, self.cache_manager) if nba_display_modes.get('nba_live', True) else None
-            self.nba_recent = NBARecentManager(self.config, self.display_manager) if nba_display_modes.get('nba_recent', True) else None
+            self.nba_recent = NBARecentManager(self.config, self.display_manager, self.cache_manager) if nba_display_modes.get('nba_recent', True) else None
-            self.nba_upcoming = NBAUpcomingManager(self.config, self.display_manager) if nba_display_modes.get('nba_upcoming', True) else None
+            self.nba_upcoming = NBAUpcomingManager(self.config, self.display_manager, self.cache_manager) if nba_display_modes.get('nba_upcoming', True) else None
         else:
             self.nba_live = None
             self.nba_recent = None
@@ -131,9 +133,9 @@ class DisplayController:
         mlb_display_modes = self.config.get('mlb', {}).get('display_modes', {})
         
         if mlb_enabled:
-            self.mlb_live = MLBLiveManager(self.config, self.display_manager) if mlb_display_modes.get('mlb_live', True) else None
+            self.mlb_live = MLBLiveManager(self.config, self.display_manager, self.cache_manager) if mlb_display_modes.get('mlb_live', True) else None
-            self.mlb_recent = MLBRecentManager(self.config, self.display_manager) if mlb_display_modes.get('mlb_recent', True) else None
+            self.mlb_recent = MLBRecentManager(self.config, self.display_manager, self.cache_manager) if mlb_display_modes.get('mlb_recent', True) else None
-            self.mlb_upcoming = MLBUpcomingManager(self.config, self.display_manager) if mlb_display_modes.get('mlb_upcoming', True) else None
+            self.mlb_upcoming = MLBUpcomingManager(self.config, self.display_manager, self.cache_manager) if mlb_display_modes.get('mlb_upcoming', True) else None
         else:
             self.mlb_live = None
             self.mlb_recent = None
@@ -146,9 +148,9 @@ class DisplayController:
         milb_display_modes = self.config.get('milb', {}).get('display_modes', {})
         
         if milb_enabled:
-            self.milb_live = MiLBLiveManager(self.config, self.display_manager) if milb_display_modes.get('milb_live', True) else None
+            self.milb_live = MiLBLiveManager(self.config, self.display_manager, self.cache_manager) if milb_display_modes.get('milb_live', True) else None
-            self.milb_recent = MiLBRecentManager(self.config, self.display_manager) if milb_display_modes.get('milb_recent', True) else None
+            self.milb_recent = MiLBRecentManager(self.config, self.display_manager, self.cache_manager) if milb_display_modes.get('milb_recent', True) else None
-            self.milb_upcoming = MiLBUpcomingManager(self.config, self.display_manager) if milb_display_modes.get('milb_upcoming', True) else None
+            self.milb_upcoming = MiLBUpcomingManager(self.config, self.display_manager, self.cache_manager) if milb_display_modes.get('milb_upcoming', True) else None
         else:
             self.milb_live = None
             self.milb_recent = None
@@ -161,9 +163,9 @@ class DisplayController:
         soccer_display_modes = self.config.get('soccer_scoreboard', {}).get('display_modes', {})
         
         if soccer_enabled:
-            self.soccer_live = SoccerLiveManager(self.config, self.display_manager) if soccer_display_modes.get('soccer_live', True) else None
+            self.soccer_live = SoccerLiveManager(self.config, self.display_manager, self.cache_manager) if soccer_display_modes.get('soccer_live', True) else None
-            self.soccer_recent = SoccerRecentManager(self.config, self.display_manager) if soccer_display_modes.get('soccer_recent', True) else None
+            self.soccer_recent = SoccerRecentManager(self.config, self.display_manager, self.cache_manager) if soccer_display_modes.get('soccer_recent', True) else None
-            self.soccer_upcoming = SoccerUpcomingManager(self.config, self.display_manager) if soccer_display_modes.get('soccer_upcoming', True) else None
+            self.soccer_upcoming = SoccerUpcomingManager(self.config, self.display_manager, self.cache_manager) if soccer_display_modes.get('soccer_upcoming', True) else None
         else:
             self.soccer_live = None
             self.soccer_recent = None
@@ -176,9 +178,9 @@ class DisplayController:
         nfl_display_modes = self.config.get('nfl_scoreboard', {}).get('display_modes', {})
         
         if nfl_enabled:
-            self.nfl_live = NFLLiveManager(self.config, self.display_manager) if nfl_display_modes.get('nfl_live', True) else None
+            self.nfl_live = NFLLiveManager(self.config, self.display_manager, self.cache_manager) if nfl_display_modes.get('nfl_live', True) else None
-            self.nfl_recent = NFLRecentManager(self.config, self.display_manager) if nfl_display_modes.get('nfl_recent', True) else None
+            self.nfl_recent = NFLRecentManager(self.config, self.display_manager, self.cache_manager) if nfl_display_modes.get('nfl_recent', True) else None
-            self.nfl_upcoming = NFLUpcomingManager(self.config, self.display_manager) if nfl_display_modes.get('nfl_upcoming', True) else None
+            self.nfl_upcoming = NFLUpcomingManager(self.config, self.display_manager, self.cache_manager) if nfl_display_modes.get('nfl_upcoming', True) else None
         else:
             self.nfl_live = None
             self.nfl_recent = None
@@ -191,9 +193,9 @@ class DisplayController:
         ncaa_fb_display_modes = self.config.get('ncaa_fb_scoreboard', {}).get('display_modes', {})
         
         if ncaa_fb_enabled:
-            self.ncaa_fb_live = NCAAFBLiveManager(self.config, self.display_manager) if ncaa_fb_display_modes.get('ncaa_fb_live', True) else None
+            self.ncaa_fb_live = NCAAFBLiveManager(self.config, self.display_manager, self.cache_manager) if ncaa_fb_display_modes.get('ncaa_fb_live', True) else None
-            self.ncaa_fb_recent = NCAAFBRecentManager(self.config, self.display_manager) if ncaa_fb_display_modes.get('ncaa_fb_recent', True) else None
+            self.ncaa_fb_recent = NCAAFBRecentManager(self.config, self.display_manager, self.cache_manager) if ncaa_fb_display_modes.get('ncaa_fb_recent', True) else None
-            self.ncaa_fb_upcoming = NCAAFBUpcomingManager(self.config, self.display_manager) if ncaa_fb_display_modes.get('ncaa_fb_upcoming', True) else None
+            self.ncaa_fb_upcoming = NCAAFBUpcomingManager(self.config, self.display_manager, self.cache_manager) if ncaa_fb_display_modes.get('ncaa_fb_upcoming', True) else None
         else:
             self.ncaa_fb_live = None
             self.ncaa_fb_recent = None
@@ -206,9 +208,9 @@ class DisplayController:
         ncaa_baseball_display_modes = self.config.get('ncaa_baseball_scoreboard', {}).get('display_modes', {})
         
         if ncaa_baseball_enabled:
-            self.ncaa_baseball_live = NCAABaseballLiveManager(self.config, self.display_manager) if ncaa_baseball_display_modes.get('ncaa_baseball_live', True) else None
+            self.ncaa_baseball_live = NCAABaseballLiveManager(self.config, self.display_manager, self.cache_manager) if ncaa_baseball_display_modes.get('ncaa_baseball_live', True) else None
-            self.ncaa_baseball_recent = NCAABaseballRecentManager(self.config, self.display_manager) if ncaa_baseball_display_modes.get('ncaa_baseball_recent', True) else None
+            self.ncaa_baseball_recent = NCAABaseballRecentManager(self.config, self.display_manager, self.cache_manager) if ncaa_baseball_display_modes.get('ncaa_baseball_recent', True) else None
-            self.ncaa_baseball_upcoming = NCAABaseballUpcomingManager(self.config, self.display_manager) if ncaa_baseball_display_modes.get('ncaa_baseball_upcoming', True) else None
+            self.ncaa_baseball_upcoming = NCAABaseballUpcomingManager(self.config, self.display_manager, self.cache_manager) if ncaa_baseball_display_modes.get('ncaa_baseball_upcoming', True) else None
         else:
             self.ncaa_baseball_live = None
             self.ncaa_baseball_recent = None
@@ -221,9 +223,9 @@ class DisplayController:
         ncaam_basketball_display_modes = self.config.get('ncaam_basketball_scoreboard', {}).get('display_modes', {})
         
         if ncaam_basketball_enabled:
-            self.ncaam_basketball_live = NCAAMBasketballLiveManager(self.config, self.display_manager) if ncaam_basketball_display_modes.get('ncaam_basketball_live', True) else None
+            self.ncaam_basketball_live = NCAAMBasketballLiveManager(self.config, self.display_manager, self.cache_manager) if ncaam_basketball_display_modes.get('ncaam_basketball_live', True) else None
-            self.ncaam_basketball_recent = NCAAMBasketballRecentManager(self.config, self.display_manager) if ncaam_basketball_display_modes.get('ncaam_basketball_recent', True) else None
+            self.ncaam_basketball_recent = NCAAMBasketballRecentManager(self.config, self.display_manager, self.cache_manager) if ncaam_basketball_display_modes.get('ncaam_basketball_recent', True) else None
-            self.ncaam_basketball_upcoming = NCAAMBasketballUpcomingManager(self.config, self.display_manager) if ncaam_basketball_display_modes.get('ncaam_basketball_upcoming', True) else None
+            self.ncaam_basketball_upcoming = NCAAMBasketballUpcomingManager(self.config, self.display_manager, self.cache_manager) if ncaam_basketball_display_modes.get('ncaam_basketball_upcoming', True) else None
         else:
             self.ncaam_basketball_live = None
             self.ncaam_basketball_recent = None
@@ -1141,4 +1143,4 @@ def main():
     controller.run()
 
 if __name__ == "__main__":
-    main() 
+    main()

src/milb_manager.py

@@ -17,13 +17,13 @@ logger = logging.getLogger(__name__)
 
 class BaseMiLBManager:
     """Base class for MiLB managers with common functionality."""
-    def __init__(self, config: Dict[str, Any], display_manager):
+    def __init__(self, config: Dict[str, Any], display_manager, cache_manager: CacheManager):
         self.config = config
         self.display_manager = display_manager
         self.milb_config = config.get('milb', {})
         self.favorite_teams = self.milb_config.get('favorite_teams', [])
         self.show_records = self.milb_config.get('show_records', False)
-        self.cache_manager = CacheManager()
+        self.cache_manager = cache_manager
         self.logger = logging.getLogger(__name__)
         self.logger.setLevel(logging.INFO)  # Set logger level to INFO
         
@@ -610,8 +610,8 @@ class BaseMiLBManager:
 
 class MiLBLiveManager(BaseMiLBManager):
     """Manager for displaying live MiLB games."""
-    def __init__(self, config: Dict[str, Any], display_manager):
+    def __init__(self, config: Dict[str, Any], display_manager, cache_manager: CacheManager):
-        super().__init__(config, display_manager)
+        super().__init__(config, display_manager, cache_manager)
         self.logger.info("Initialized MiLB Live Manager")
         self.live_games = []
         self.current_game = None  # Initialize current_game to None
@@ -1021,8 +1021,8 @@ class MiLBLiveManager(BaseMiLBManager):
 
 class MiLBRecentManager(BaseMiLBManager):
     """Manager for displaying recent MiLB games."""
-    def __init__(self, config: Dict[str, Any], display_manager):
+    def __init__(self, config: Dict[str, Any], display_manager, cache_manager: CacheManager):
-        super().__init__(config, display_manager)
+        super().__init__(config, display_manager, cache_manager)
         self.logger.info("Initialized MiLB Recent Manager")
         self.recent_games = []
         self.current_game = None
@@ -1177,8 +1177,8 @@ class MiLBRecentManager(BaseMiLBManager):
 
 class MiLBUpcomingManager(BaseMiLBManager):
     """Manager for upcoming MiLB games."""
-    def __init__(self, config: Dict[str, Any], display_manager):
+    def __init__(self, config: Dict[str, Any], display_manager, cache_manager: CacheManager):
-        super().__init__(config, display_manager)
+        super().__init__(config, display_manager, cache_manager)
         self.logger = logging.getLogger(__name__)
         self.upcoming_games = []
         self.current_game = None

src/mlb_manager.py

@@ -18,14 +18,14 @@ logger = logging.getLogger(__name__)
 
 class BaseMLBManager:
     """Base class for MLB managers with common functionality."""
-    def __init__(self, config: Dict[str, Any], display_manager):
+    def __init__(self, config: Dict[str, Any], display_manager, cache_manager: CacheManager):
         self.config = config
         self.display_manager = display_manager
         self.mlb_config = config.get('mlb', {})
         self.show_odds = self.mlb_config.get("show_odds", False)
         self.favorite_teams = self.mlb_config.get('favorite_teams', [])
         self.show_records = self.mlb_config.get('show_records', False)
-        self.cache_manager = CacheManager()
+        self.cache_manager = cache_manager
         self.odds_manager = OddsManager(self.cache_manager, self.config)
         self.logger = logging.getLogger(__name__)
         
@@ -704,8 +704,8 @@ class BaseMLBManager:
 
 class MLBLiveManager(BaseMLBManager):
     """Manager for displaying live MLB games."""
-    def __init__(self, config: Dict[str, Any], display_manager):
+    def __init__(self, config: Dict[str, Any], display_manager, cache_manager: CacheManager):
-        super().__init__(config, display_manager)
+        super().__init__(config, display_manager, cache_manager)
         self.logger.info("Initialized MLB Live Manager")
         self.live_games = []
         self.current_game = None  # Initialize current_game to None
@@ -1120,8 +1120,8 @@ class MLBLiveManager(BaseMLBManager):
 
 class MLBRecentManager(BaseMLBManager):
     """Manager for displaying recent MLB games."""
-    def __init__(self, config: Dict[str, Any], display_manager):
+    def __init__(self, config: Dict[str, Any], display_manager, cache_manager: CacheManager):
-        super().__init__(config, display_manager)
+        super().__init__(config, display_manager, cache_manager)
         self.logger.info("Initialized MLB Recent Manager")
         self.recent_games = []
         self.current_game = None
@@ -1261,8 +1261,8 @@ class MLBRecentManager(BaseMLBManager):
 
 class MLBUpcomingManager(BaseMLBManager):
     """Manager for displaying upcoming MLB games."""
-    def __init__(self, config: Dict[str, Any], display_manager):
+    def __init__(self, config: Dict[str, Any], display_manager, cache_manager: CacheManager):
-        super().__init__(config, display_manager)
+        super().__init__(config, display_manager, cache_manager)
         self.logger.info("Initialized MLB Upcoming Manager")
         self.upcoming_games = []
         self.current_game = None

src/nba_managers.py

@@ -32,14 +32,14 @@ class BaseNBAManager:
     _last_log_times = {}
     _shared_data = None
     _last_shared_update = 0
-    cache_manager = CacheManager()  # Make cache_manager a class attribute
-    odds_manager = OddsManager(cache_manager, ConfigManager())
-    logger = logging.getLogger('NBA')  # Make logger a class attribute
     
-    def __init__(self, config: Dict[str, Any], display_manager: DisplayManager):
+    def __init__(self, config: Dict[str, Any], display_manager: DisplayManager, cache_manager: CacheManager):
         self.display_manager = display_manager
         self.config_manager = ConfigManager()
         self.config = config
+        self.cache_manager = cache_manager
+        self.odds_manager = OddsManager(self.cache_manager, self.config)
+        self.logger = logging.getLogger(__name__)
         self.nba_config = config.get("nba_scoreboard", {})
         self.is_enabled = self.nba_config.get("enabled", False)
         self.show_odds = self.nba_config.get("show_odds", False)
@@ -658,8 +658,8 @@ class BaseNBAManager:
 
 class NBALiveManager(BaseNBAManager):
     """Manager for live NBA games."""
-    def __init__(self, config: Dict[str, Any], display_manager: DisplayManager):
+    def __init__(self, config: Dict[str, Any], display_manager: DisplayManager, cache_manager: CacheManager):
-        super().__init__(config, display_manager)
+        super().__init__(config, display_manager, cache_manager)
         self.update_interval = self.nba_config.get("live_update_interval", 30)
         self.no_data_interval = 300
         self.last_update = 0
@@ -714,8 +714,8 @@ class NBALiveManager(BaseNBAManager):
 
 class NBARecentManager(BaseNBAManager):
     """Manager for recently completed NBA games."""
-    def __init__(self, config: Dict[str, Any], display_manager: DisplayManager):
+    def __init__(self, config: Dict[str, Any], display_manager: DisplayManager, cache_manager: CacheManager):
-        super().__init__(config, display_manager)
+        super().__init__(config, display_manager, cache_manager)
         self.recent_games = []
         self.current_game_index = 0
         self.last_update = 0
@@ -790,8 +790,8 @@ class NBARecentManager(BaseNBAManager):
 
 class NBAUpcomingManager(BaseNBAManager):
     """Manager for upcoming NBA games."""
-    def __init__(self, config: Dict[str, Any], display_manager: DisplayManager):
+    def __init__(self, config: Dict[str, Any], display_manager: DisplayManager, cache_manager: CacheManager):
-        super().__init__(config, display_manager)
+        super().__init__(config, display_manager, cache_manager)
         self.upcoming_games = []
         self.current_game_index = 0
         self.last_update = 0

src/ncaa_baseball_managers.py

@@ -21,14 +21,14 @@ ESPN_NCAABB_SCOREBOARD_URL = "https://site.api.espn.com/apis/site/v2/sports/base
 
 class BaseNCAABaseballManager:
     """Base class for NCAA Baseball managers with common functionality."""
-    def __init__(self, config: Dict[str, Any], display_manager):
+    def __init__(self, config: Dict[str, Any], display_manager, cache_manager: CacheManager):
         self.config = config
         self.display_manager = display_manager
         self.ncaa_baseball_config = config.get('ncaa_baseball_scoreboard', {})
         self.show_odds = self.ncaa_baseball_config.get('show_odds', False)
         self.show_records = self.ncaa_baseball_config.get('show_records', False)
         self.favorite_teams = self.ncaa_baseball_config.get('favorite_teams', [])
-        self.cache_manager = CacheManager()
+        self.cache_manager = cache_manager
         self.odds_manager = OddsManager(self.cache_manager, self.config)
         self.logger = logging.getLogger(__name__)
         self.logger.setLevel(logging.DEBUG)  # Set logger level to DEBUG
@@ -542,8 +542,8 @@ class BaseNCAABaseballManager:
 
 class NCAABaseballLiveManager(BaseNCAABaseballManager):
     """Manager for displaying live NCAA Baseball games."""
-    def __init__(self, config: Dict[str, Any], display_manager):
+    def __init__(self, config: Dict[str, Any], display_manager, cache_manager: CacheManager):
-        super().__init__(config, display_manager)
+        super().__init__(config, display_manager, cache_manager)
         self.logger.info("Initialized NCAA Baseball Live Manager")
         self.live_games = []
         self.current_game = None
@@ -836,8 +836,8 @@ class NCAABaseballLiveManager(BaseNCAABaseballManager):
 
 class NCAABaseballRecentManager(BaseNCAABaseballManager):
     """Manager for displaying recent NCAA Baseball games."""
-    def __init__(self, config: Dict[str, Any], display_manager):
+    def __init__(self, config: Dict[str, Any], display_manager, cache_manager: CacheManager):
-        super().__init__(config, display_manager)
+        super().__init__(config, display_manager, cache_manager)
         self.logger.info("Initialized NCAA Baseball Recent Manager")
         self.recent_games = []
         self.current_game = None
@@ -943,8 +943,8 @@ class NCAABaseballRecentManager(BaseNCAABaseballManager):
 
 class NCAABaseballUpcomingManager(BaseNCAABaseballManager):
     """Manager for displaying upcoming NCAA Baseball games."""
-    def __init__(self, config: Dict[str, Any], display_manager):
+    def __init__(self, config: Dict[str, Any], display_manager, cache_manager: CacheManager):
-        super().__init__(config, display_manager)
+        super().__init__(config, display_manager, cache_manager)
         self.logger.info("Initialized NCAA Baseball Upcoming Manager")
         self.upcoming_games = []
         self.current_game = None

src/ncaam_basketball_managers.py

@@ -32,14 +32,14 @@ class BaseNCAAMBasketballManager:
     _last_log_times = {}
     _shared_data = None
     _last_shared_update = 0
-    cache_manager = CacheManager()  # Make cache_manager a class attribute
-    odds_manager = OddsManager(cache_manager, ConfigManager())
-    logger = logging.getLogger('NCAAMBasketball')  # Make logger a class attribute
     
-    def __init__(self, config: Dict[str, Any], display_manager: DisplayManager):
+    def __init__(self, config: Dict[str, Any], display_manager: DisplayManager, cache_manager: CacheManager):
         self.display_manager = display_manager
         self.config_manager = ConfigManager()
         self.config = config
+        self.cache_manager = cache_manager
+        self.odds_manager = OddsManager(self.cache_manager, self.config)
+        self.logger = logging.getLogger(__name__)
         self.ncaam_basketball_config = config.get("ncaam_basketball_scoreboard", {})
         self.is_enabled = self.ncaam_basketball_config.get("enabled", False)
         self.show_odds = self.ncaam_basketball_config.get("show_odds", False)
@@ -600,8 +600,8 @@ class BaseNCAAMBasketballManager:
 
 class NCAAMBasketballLiveManager(BaseNCAAMBasketballManager):
     """Manager for live NCAA MB games."""
-    def __init__(self, config: Dict[str, Any], display_manager: DisplayManager):
+    def __init__(self, config: Dict[str, Any], display_manager: DisplayManager, cache_manager: CacheManager):
-        super().__init__(config, display_manager)
+        super().__init__(config, display_manager, cache_manager)
         self.update_interval = self.ncaam_basketball_config.get("live_update_interval", 15)  # 15 seconds for live games
         self.no_data_interval = 300  # 5 minutes when no live games
         self.last_update = 0
@@ -777,8 +777,8 @@ class NCAAMBasketballLiveManager(BaseNCAAMBasketballManager):
 
 class NCAAMBasketballRecentManager(BaseNCAAMBasketballManager):
     """Manager for recently completed NCAA MB games."""
-    def __init__(self, config: Dict[str, Any], display_manager: DisplayManager):
+    def __init__(self, config: Dict[str, Any], display_manager: DisplayManager, cache_manager: CacheManager):
-        super().__init__(config, display_manager)
+        super().__init__(config, display_manager, cache_manager)
         self.recent_games = []
         self.current_game_index = 0
         self.last_update = 0
@@ -912,8 +912,8 @@ class NCAAMBasketballRecentManager(BaseNCAAMBasketballManager):
 
 class NCAAMBasketballUpcomingManager(BaseNCAAMBasketballManager):
     """Manager for upcoming NCAA MB games."""
-    def __init__(self, config: Dict[str, Any], display_manager: DisplayManager):
+    def __init__(self, config: Dict[str, Any], display_manager: DisplayManager, cache_manager: CacheManager):
-        super().__init__(config, display_manager)
+        super().__init__(config, display_manager, cache_manager)
         self.upcoming_games = []
         self.current_game_index = 0
         self.last_update = 0

src/nfl_managers.py

@@ -34,14 +34,14 @@ class BaseNFLManager: # Renamed class
     _warning_cooldown = 60  # Only log warnings once per minute
     _shared_data = None
     _last_shared_update = 0
-    cache_manager = CacheManager()
+    
-    odds_manager = OddsManager(cache_manager, ConfigManager())
+    def __init__(self, config: Dict[str, Any], display_manager: DisplayManager, cache_manager: CacheManager):
-    logger = logging.getLogger('NFL') # Changed logger name
-
-    def __init__(self, config: Dict[str, Any], display_manager: DisplayManager):
         self.display_manager = display_manager
         self.config_manager = ConfigManager()
         self.config = config
+        self.cache_manager = cache_manager
+        self.odds_manager = OddsManager(self.cache_manager, self.config)
+        self.logger = logging.getLogger(__name__)
         self.nfl_config = config.get("nfl_scoreboard", {}) # Changed config key
         self.is_enabled = self.nfl_config.get("enabled", False)
         self.show_odds = self.nfl_config.get("show_odds", False)
@@ -482,8 +482,8 @@ class BaseNFLManager: # Renamed class
 
 class NFLLiveManager(BaseNFLManager): # Renamed class
     """Manager for live NFL games."""
-    def __init__(self, config: Dict[str, Any], display_manager: DisplayManager):
+    def __init__(self, config: Dict[str, Any], display_manager: DisplayManager, cache_manager: CacheManager):
-        super().__init__(config, display_manager)
+        super().__init__(config, display_manager, cache_manager)
         self.update_interval = self.nfl_config.get("live_update_interval", 15)
         self.no_data_interval = 300
         self.last_update = 0
@@ -799,8 +799,8 @@ class NFLLiveManager(BaseNFLManager): # Renamed class
 
 class NFLRecentManager(BaseNFLManager): # Renamed class
     """Manager for recently completed NFL games."""
-    def __init__(self, config: Dict[str, Any], display_manager: DisplayManager):
+    def __init__(self, config: Dict[str, Any], display_manager: DisplayManager, cache_manager: CacheManager):
-        super().__init__(config, display_manager)
+        super().__init__(config, display_manager, cache_manager)
         self.recent_games = [] # Store all fetched recent games initially
         self.games_list = [] # Filtered list for display (favorite teams)
         self.current_game_index = 0
@@ -1014,8 +1014,8 @@ class NFLRecentManager(BaseNFLManager): # Renamed class
 
 class NFLUpcomingManager(BaseNFLManager): # Renamed class
     """Manager for upcoming NFL games."""
-    def __init__(self, config: Dict[str, Any], display_manager: DisplayManager):
+    def __init__(self, config: Dict[str, Any], display_manager: DisplayManager, cache_manager: CacheManager):
-        super().__init__(config, display_manager)
+        super().__init__(config, display_manager, cache_manager)
         self.upcoming_games = [] # Store all fetched upcoming games initially
         self.games_list = [] # Filtered list for display (favorite teams)
         self.current_game_index = 0

src/nhl_managers.py

@@ -23,56 +23,6 @@ logging.basicConfig(
     datefmt='%Y-%m-%d %H:%M:%S'
 )
 
-class CacheManager:
-    """Manages caching of ESPN API responses."""
-    _instance = None
-    _cache = {}
-    _cache_timestamps = {}
-    
-    def __new__(cls):
-        if cls._instance is None:
-            cls._instance = super(CacheManager, cls).__new__(cls)
-        return cls._instance
-    
-    @classmethod
-    def get(cls, key: str, max_age: int = 60) -> Optional[Dict]:
-        """
-        Get data from cache if it exists and is not stale.
-        Args:
-            key: Cache key (usually the date string)
-            max_age: Maximum age of cached data in seconds
-        Returns:
-            Cached data if valid, None if missing or stale
-        """
-        if key not in cls._cache:
-            return None
-            
-        timestamp = cls._cache_timestamps.get(key, 0)
-        if time.time() - timestamp > max_age:
-            # Data is stale, remove it
-            del cls._cache[key]
-            del cls._cache_timestamps[key]
-            return None
-            
-        return cls._cache[key]
-    
-    @classmethod
-    def set(cls, key: str, data: Dict) -> None:
-        """
-        Store data in cache with current timestamp.
-        Args:
-            key: Cache key (usually the date string)
-            data: Data to cache
-        """
-        cls._cache[key] = data
-        cls._cache_timestamps[key] = time.time()
-    
-    @classmethod
-    def clear(cls) -> None:
-        """Clear all cached data."""
-        cls._cache.clear()
-        cls._cache_timestamps.clear()
-
 class BaseNHLManager:
     """Base class for NHL managers with common functionality."""
     # Class variables for warning tracking
@@ -81,14 +31,14 @@ class BaseNHLManager:
     _warning_cooldown = 60  # Only log warnings once per minute
     _shared_data = None
     _last_shared_update = 0
-    cache_manager = CacheManager()  # Make cache_manager a class attribute
-    odds_manager = OddsManager(cache_manager, ConfigManager())
-    logger = logging.getLogger('NHL')  # Make logger a class attribute
     
-    def __init__(self, config: Dict[str, Any], display_manager: DisplayManager):
+    def __init__(self, config: Dict[str, Any], display_manager: DisplayManager, cache_manager: CacheManager):
         self.display_manager = display_manager
         self.config_manager = ConfigManager()
         self.config = config
+        self.cache_manager = cache_manager
+        self.odds_manager = OddsManager(self.cache_manager, self.config)
+        self.logger = logging.getLogger(__name__)
         self.nhl_config = config.get("nhl_scoreboard", {})
         self.is_enabled = self.nhl_config.get("enabled", False)
         self.show_odds = self.nhl_config.get("show_odds", False)
@@ -554,8 +504,8 @@ class BaseNHLManager:
 
 class NHLLiveManager(BaseNHLManager):
     """Manager for live NHL games."""
-    def __init__(self, config: Dict[str, Any], display_manager: DisplayManager):
+    def __init__(self, config: Dict[str, Any], display_manager: DisplayManager, cache_manager: CacheManager):
-        super().__init__(config, display_manager)
+        super().__init__(config, display_manager, cache_manager)
         self.update_interval = self.nhl_config.get("live_update_interval", 15)  # 15 seconds for live games
         self.no_data_interval = 300  # 5 minutes when no live games
         self.last_update = 0
@@ -689,8 +639,8 @@ class NHLLiveManager(BaseNHLManager):
 
 class NHLRecentManager(BaseNHLManager):
     """Manager for recently completed NHL games."""
-    def __init__(self, config: Dict[str, Any], display_manager: DisplayManager):
+    def __init__(self, config: Dict[str, Any], display_manager: DisplayManager, cache_manager: CacheManager):
-        super().__init__(config, display_manager)
+        super().__init__(config, display_manager, cache_manager)
         self.recent_games = []
         self.current_game_index = 0
         self.last_update = 0
@@ -784,8 +734,8 @@ class NHLRecentManager(BaseNHLManager):
 
 class NHLUpcomingManager(BaseNHLManager):
     """Manager for upcoming NHL games."""
-    def __init__(self, config: Dict[str, Any], display_manager: DisplayManager):
+    def __init__(self, config: Dict[str, Any], display_manager: DisplayManager, cache_manager: CacheManager):
-        super().__init__(config, display_manager)
+        super().__init__(config, display_manager, cache_manager)
         self.upcoming_games = []
         self.current_game_index = 0
         self.last_update = 0

src/soccer_managers.py

@@ -37,56 +37,6 @@ logging.basicConfig(
     datefmt='%Y-%m-%d %H:%M:%S'
 )
 
-class CacheManager:
-    """Manages caching of ESPN API responses."""
-    _instance = None
-    _cache = {}
-    _cache_timestamps = {}
-    
-    def __new__(cls):
-        if cls._instance is None:
-            cls._instance = super(CacheManager, cls).__new__(cls)
-        return cls._instance
-    
-    @classmethod
-    def get(cls, key: str, max_age: int = 60) -> Optional[Dict]:
-        """
-        Get data from cache if it exists and is not stale.
-        Args:
-            key: Cache key (usually the date string or league)
-            max_age: Maximum age of cached data in seconds
-        Returns:
-            Cached data if valid, None if missing or stale
-        """
-        if key not in cls._cache:
-            return None
-            
-        timestamp = cls._cache_timestamps.get(key, 0)
-        if time.time() - timestamp > max_age:
-            # Data is stale, remove it
-            del cls._cache[key]
-            del cls._cache_timestamps[key]
-            return None
-            
-        return cls._cache[key]
-    
-    @classmethod
-    def set(cls, key: str, data: Dict) -> None:
-        """
-        Store data in cache with current timestamp.
-        Args:
-            key: Cache key
-            data: Data to cache
-        """
-        cls._cache[key] = data
-        cls._cache_timestamps[key] = time.time()
-    
-    @classmethod
-    def clear(cls) -> None:
-        """Clear all cached data."""
-        cls._cache.clear()
-        cls._cache_timestamps.clear()
-
 class BaseSoccerManager:
     """Base class for Soccer managers with common functionality."""
     # Class variables for warning tracking
@@ -95,21 +45,18 @@ class BaseSoccerManager:
     _warning_cooldown = 60  # Only log warnings once per minute
     _shared_data = {}  # Dictionary to hold shared data per league/date
     _last_shared_update = {} # Dictionary for update times per league/date
-    cache_manager = CacheManager()
-    odds_manager = OddsManager(cache_manager, ConfigManager())
-    logger = logging.getLogger('Soccer') # Use 'Soccer' logger
-    
-    # Class attribute to store soccer_config for shared access
     _soccer_config_shared = {} 
     _team_league_map = {} # In-memory cache for the map
     _map_last_updated = 0
 
-    def __init__(self, config: Dict[str, Any], display_manager: DisplayManager):
+    def __init__(self, config: Dict[str, Any], display_manager: DisplayManager, cache_manager: CacheManager):
         self.display_manager = display_manager
         self.config = config
         self.soccer_config = config.get("soccer_scoreboard", {}) # Use 'soccer_scoreboard' config
         BaseSoccerManager._soccer_config_shared = self.soccer_config # Store for class methods
-        
+        self.cache_manager = cache_manager
+        self.odds_manager = OddsManager(self.cache_manager, self.config)
+        self.logger = logging.getLogger(__name__)
         self.is_enabled = self.soccer_config.get("enabled", False)
         self.show_odds = self.soccer_config.get("show_odds", False)
         self.test_mode = self.soccer_config.get("test_mode", False)
@@ -701,8 +648,8 @@ class BaseSoccerManager:
 
 class SoccerLiveManager(BaseSoccerManager):
     """Manager for live Soccer games."""
-    def __init__(self, config: Dict[str, Any], display_manager: DisplayManager):
+    def __init__(self, config: Dict[str, Any], display_manager: DisplayManager, cache_manager: CacheManager):
-        super().__init__(config, display_manager)
+        super().__init__(config, display_manager, cache_manager)
         self.update_interval = self.soccer_config.get("live_update_interval", 20) # Slightly longer for soccer?
         self.no_data_interval = 300
         self.last_update = 0
@@ -855,8 +802,8 @@ class SoccerLiveManager(BaseSoccerManager):
 
 class SoccerRecentManager(BaseSoccerManager):
     """Manager for recently completed Soccer games."""
-    def __init__(self, config: Dict[str, Any], display_manager: DisplayManager):
+    def __init__(self, config: Dict[str, Any], display_manager: DisplayManager, cache_manager: CacheManager):
-        super().__init__(config, display_manager)
+        super().__init__(config, display_manager, cache_manager)
         self.recent_games = [] # Holds all fetched recent games matching criteria
         self.games_list = []   # Holds games filtered by favorite teams (if applicable)
         self.current_game_index = 0
@@ -958,8 +905,8 @@ class SoccerRecentManager(BaseSoccerManager):
 
 class SoccerUpcomingManager(BaseSoccerManager):
     """Manager for upcoming Soccer games."""
-    def __init__(self, config: Dict[str, Any], display_manager: DisplayManager):
+    def __init__(self, config: Dict[str, Any], display_manager: DisplayManager, cache_manager: CacheManager):
-        super().__init__(config, display_manager)
+        super().__init__(config, display_manager, cache_manager)
         self.upcoming_games = [] # Filtered list for display
         self.current_game_index = 0
         self.last_update = 0