delays

deathclock/app.py

@@ -22,7 +22,9 @@ def create_app():
                 html.Div(id='weather-display')
             ], id='scores-weather-container'),
         ]),
+        
         html.Div(id='news-ticker'),
+        
         dcc.Interval(id='clock-interval', interval=60000, n_intervals=0),
         dcc.Interval(id='weather-interval', interval=150000, n_intervals=0),
         dcc.Interval(id='news-interval', interval=300000, n_intervals=0),
@@ -41,7 +43,6 @@ def create_app():
             print("ALARM TRIGGERED!")
     
     check_alarms()
-
     return app
 
 if __name__ == '__main__':

deathclock/news.py

@@ -13,16 +13,20 @@ class News:
     def __init__(self):
         self._news_dict = {}
         self._news_dict_length = 0
-        socket.setdefaulttimeout(10)  # Set default timeout for socket operations
+        socket.setdefaulttimeout(10) # Set default timeout for socket operations
         
     async def _fetch_feed(self, session, feed):
         """Fetches and parses a single feed asynchronously."""
-        max_entries = 10  # Maximum number of entries to fetch from each feed
+        max_entries = 10 # Maximum number of entries to fetch from each feed
+        
         try:
-            async with session.get(feed) as response:
+            # Add timeout to the request
+            timeout = aiohttp.ClientTimeout(total=5)
+            async with session.get(feed, timeout=timeout) as response:
                 if response.status != 200:
                     print(f"Skip feed {feed}: status {response.status}")
                     return []
+                
                 text = await response.text()
                 d = feedparser.parse(text)
                 
@@ -34,13 +38,15 @@ class News:
                 # Limit the number of entries parsed
                 for i, post in enumerate(d.entries):
                     if i >= max_entries:
-                        break  # Stop parsing if we've reached the limit
+                        break # Stop parsing if we've reached the limit
+                    
                     feed_entries.append({
                         'title': post.title,
                         'source': d.feed.title if hasattr(d.feed, 'title') else 'Unknown',
                         'publish_date': post.published if hasattr(post, 'published') else '',
                         'summary': post.summary if hasattr(post, 'summary') else ''
                     })
+                
                 print(f"Added {len(feed_entries)} entries from {feed}")
                 return feed_entries
                 
@@ -65,16 +71,20 @@ class News:
             print(f"Error reading feeds.txt: {e}")
             return {}
             
+        # Limit the number of feeds to process at once
+        if len(feeds) > 10:
+            feeds = random.sample(feeds, 10)
+            
         print("Getting news entries...")
-        async with aiohttp.ClientSession() as session:
+        timeout = aiohttp.ClientTimeout(total=15)
+        async with aiohttp.ClientSession(timeout=timeout) as session:
             tasks = [self._fetch_feed(session, feed) for feed in feeds]
-            all_feed_entries_list = await asyncio.gather(*tasks)
+            all_feed_entries_list = await asyncio.gather(*tasks, return_exceptions=True)
             
         all_entries = []
-        for feed_entries in all_feed_entries_list:
-            if feed_entries:
-                #Now just add the entries, because we are already limited
-                all_entries.extend(feed_entries)
+        for result in all_feed_entries_list:
+            if isinstance(result, list) and result:
+                all_entries.extend(result)
                 
         if not all_entries:
             print("No entries collected")

deathclock/news_module.py

@@ -9,7 +9,7 @@ class NewsModule:
         self.app = app
         self.news_obj = self.get_news_object()
         self._last_news_update = datetime.datetime(2000, 1, 1)
-        self._cached_news = self.create_loading_message()  # Initial loading message
+        self._cached_news = self.create_loading_message() # Initial loading message
         self._initial_run = True
         self.setup_callbacks()
         
@@ -29,13 +29,25 @@ class NewsModule:
                 return self._cached_news
                 
             current_time = datetime.datetime.now()
+            time_since_update = (current_time - self._last_news_update).total_seconds()
+            
+            # Only update if it's been more than 5 minutes or it's the initial run
+            if time_since_update < 300 and not self._initial_run:
+                return self._cached_news
+                
             try:
                 print("UPDATING NEWS...")
-                # Execute the async function with asyncio.run
-                headlines_dict = asyncio.run(self.news_obj.get_news())
+                # Create a new event loop for this request
+                loop = asyncio.new_event_loop()
+                asyncio.set_event_loop(loop)
+                headlines_dict = loop.run_until_complete(self.news_obj.get_news())
+                loop.close()
+                
+                if not headlines_dict:
+                    return html.Div("No news available at this time.", className="ticker")
                     
                 combined_items = " | ".join([f"{data['source']}: {headline}"
-                                           for headline, data in headlines_dict.items()])
+                                          for headline, data in headlines_dict.items()])
                 text_px = len(combined_items) * 8
                 scroll_speed = 75
                 duration = max(text_px / scroll_speed, 20)