Update app.py

app.py

@@ -1,40 +1,76 @@
 import gradio as gr
 import requests
 from datetime import datetime, timezone
+import logging
+
+# Configure logging for debugging purposes
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 
 API_URL = "https://huggingface.co/api/daily_papers"
 
 class PaperManager:
-    def __init__(self, papers_per_page=10):
+    def __init__(self, papers_per_page=10, max_papers=100):
         self.papers_per_page = papers_per_page
+        self.max_papers = max_papers
         self.cache = []
         self.last_fetch_date = None
         self.total_pages = 1
 
     def fetch_papers(self):
         """
-        Fetch papers from the API if not already fetched today.
+        Fetch the first 100 most recent papers from the API, sorted by upvotes descending.
+        Caches the result and fetches only once a day.
         Returns:
             tuple: (success: bool, data: list, error_message: str)
         """
         today = datetime.now(timezone.utc).date()
         if self.last_fetch_date == today and self.cache:
-            print("Using cached papers.")
+            logging.info("Using cached papers.")
             return True, self.cache, ""
         else:
             try:
-                # Attempt to fetch all papers at once. Adjust 'limit' as per API's capability.
-                response = requests.get(f"{API_URL}?page=1&limit=1000")
+                # Fetch up to max_papers; adjust 'limit' as per API's capability
+                response = requests.get(f"{API_URL}?page=1&limit={self.max_papers}")
                 response.raise_for_status()
                 data = response.json()
-                self.cache = sorted(data, key=lambda x: x.get('paper', {}).get('upvotes', 0), reverse=True)
+
+                if not isinstance(data, list):
+                    raise ValueError("API response is not a list of papers.")
+
+                # Sort papers by upvotes descending
+                sorted_papers = sorted(
+                    data,
+                    key=lambda x: x.get('paper', {}).get('upvotes', 0),
+                    reverse=True
+                )
+
+                # Limit to max_papers
+                self.cache = sorted_papers[:self.max_papers]
                 self.last_fetch_date = today
                 self.total_pages = (len(self.cache) + self.papers_per_page - 1) // self.papers_per_page
-                print(f"Fetched {len(self.cache)} papers. Total pages: {self.total_pages}")
+
+                logging.info(f"Fetched {len(self.cache)} papers. Total pages: {self.total_pages}")
                 return True, self.cache, ""
-            except requests.RequestException as e:
-                print(f"Error fetching papers: {e}")
-                return False, [], str(e)
+            except requests.HTTPError as http_err:
+                error_message = f"HTTP error occurred: {http_err}"
+                logging.error(error_message)
+                return False, [], error_message
+            except requests.ConnectionError as conn_err:
+                error_message = f"Connection error occurred: {conn_err}"
+                logging.error(error_message)
+                return False, [], error_message
+            except requests.Timeout as timeout_err:
+                error_message = f"Timeout error occurred: {timeout_err}"
+                logging.error(error_message)
+                return False, [], error_message
+            except requests.RequestException as req_err:
+                error_message = f"An error occurred: {req_err}"
+                logging.error(error_message)
+                return False, [], error_message
+            except ValueError as val_err:
+                error_message = f"Data format error: {val_err}"
+                logging.error(error_message)
+                return False, [], error_message
 
     def format_paper(self, paper):
         """
@@ -47,6 +83,7 @@ class PaperManager:
         upvotes = paper.get('paper', {}).get('upvotes', 0)
         comments = paper.get('numComments', 0)
         published_at = paper.get('publishedAt', datetime.now(timezone.utc).isoformat())
+
         try:
             published_time = datetime.fromisoformat(published_at.replace('Z', '+00:00'))
             time_ago = (datetime.now(timezone.utc) - published_time).days
@@ -54,11 +91,11 @@ class PaperManager:
             time_ago = "Unknown"
 
         return f"""<div style='border-bottom: 1px solid #eee; padding: 10px 0;'>
-<a href='{url}' target='_blank' style='color: #000; text-decoration: none; font-weight: bold;'>{title}</a>
-<div style='font-size: 0.8em; color: #666; margin-top: 5px;'>
-{upvotes} upvotes | by {authors} | {time_ago} days ago | {comments} comments
-</div>
-</div>"""
+    <a href='{url}' target='_blank' style='color: #000; text-decoration: none; font-weight: bold;'>{title}</a>
+    <div style='font-size: 0.8em; color: #666; margin-top: 5px;'>
+    {upvotes} upvotes | by {authors} | {time_ago} days ago | {comments} comments
+    </div>
+    </div>"""
 
     def render_papers(self, papers, page=1):
         """
@@ -167,4 +204,123 @@ def refresh_papers(current_page, query):
             page_info_text = f"Page {new_page} of {total_pages}"
             return page_papers, new_page, total_pages, papers, page_info_text, ""
     else:
-        error_html = f"<div cla
+        error_html = f"<div class='error-message'>Error fetching papers: {error_message}</div>"
+        return error_html, current_page, paper_manager.total_pages, [], f"Page {current_page} of {paper_manager.total_pages}", error_message
+
+def search_papers(query, papers):
+    """
+    Search for papers based on the query and update the display.
+    """
+    if query:
+        filtered = paper_manager.search_papers(query)
+    else:
+        filtered = papers
+    total_pages = (len(filtered) + paper_manager.papers_per_page - 1) // paper_manager.papers_per_page if filtered else 1
+    page = 1
+    page_papers = paper_manager.render_papers(filtered, page)
+    page_info_text = f"Page {page} of {total_pages}"
+    if not filtered:
+        error_html = "<div class='error-message'>No papers match your search query.</div>"
+    else:
+        error_html = ""
+    return page_papers, page, total_pages, filtered, page_info_text, error_html
+
+def change_page(direction, current_page, total_pages, papers, query):
+    """
+    Change the current page based on the direction ('next' or 'prev').
+    """
+    if direction == "next" and current_page < total_pages:
+        new_page = current_page + 1
+    elif direction == "prev" and current_page > 1:
+        new_page = current_page - 1
+    else:
+        new_page = current_page  # No change if limits are reached
+
+    if not papers:
+        page_papers = "<div>No papers available for this page.</div>"
+    else:
+        page_papers = paper_manager.render_papers(papers, new_page)
+    page_info_text = f"Page {new_page} of {total_pages}"
+    return page_papers, new_page, total_pages, papers, page_info_text, ""
+
+def go_prev(current_page, total_pages, papers, query):
+    """
+    Handle the 'Previous Page' button click.
+    """
+    return change_page("prev", current_page, total_pages, papers, query)
+
+def go_next(current_page, total_pages, papers, query):
+    """
+    Handle the 'Next Page' button click.
+    """
+    return change_page("next", current_page, total_pages, papers, query)
+
+# Define the Gradio Blocks interface
+demo = gr.Blocks(css=css)
+
+with demo:
+    with gr.Column(elem_classes=["container"]):
+        # Title
+        gr.Markdown("# Daily Papers - HackerNews Style", elem_classes=["title"])
+        
+        # Search and Refresh Row
+        with gr.Row(elem_classes=["search-row"]):
+            search_input = gr.Textbox(label="Search papers", placeholder="Enter search term...")
+            refresh_button = gr.Button("Refresh")
+        
+        # Error Message Display
+        error_display = gr.HTML(elem_classes=["error-message"])
+        
+        # Paper List Display
+        paper_list = gr.HTML(elem_classes=["paper-list"])
+        
+        # Pagination Controls
+        with gr.Row(elem_classes=["footer"]):
+            prev_button = gr.Button("Previous Page")
+            page_info = gr.Markdown("Page 1 of 1")
+            next_button = gr.Button("Next Page")
+        
+        # Hidden States
+        current_page_state = gr.State(1)
+        total_pages_state = gr.State(1)
+        papers_state = gr.State([])
+    
+        # Initialize the app on load
+        demo.load(
+            initialize, 
+            outputs=[paper_list, current_page_state, total_pages_state, papers_state, page_info, error_display]
+        )
+    
+        # Search Functionality
+        search_input.submit(
+            search_papers, 
+            inputs=[search_input, papers_state], 
+            outputs=[paper_list, current_page_state, total_pages_state, papers_state, page_info, error_display]
+        )
+        search_input.change(
+            search_papers, 
+            inputs=[search_input, papers_state], 
+            outputs=[paper_list, current_page_state, total_pages_state, papers_state, page_info, error_display]
+        )
+    
+        # Refresh Functionality
+        refresh_button.click(
+            refresh_papers, 
+            inputs=[current_page_state, search_input], 
+            outputs=[paper_list, current_page_state, total_pages_state, papers_state, page_info, error_display]
+        )
+    
+        # Pagination Buttons
+        prev_button.click(
+            go_prev, 
+            inputs=[current_page_state, total_pages_state, papers_state, search_input], 
+            outputs=[paper_list, current_page_state, total_pages_state, papers_state, page_info, error_display]
+        )
+        next_button.click(
+            go_next, 
+            inputs=[current_page_state, total_pages_state, papers_state, search_input], 
+            outputs=[paper_list, current_page_state, total_pages_state, papers_state, page_info, error_display]
+        )
+    
+# Launch the Gradio app
+demo.launch()