Update app.py

app.py

@@ -166,38 +166,6 @@ class PaperList:
         return df_prettified
 
 
-# Initialize PaperList
-paper_list = PaperList(get_df())
-
-
-def update_paper_list() -> None:
-    global paper_list
-    paper_list = PaperList(get_df())
-
-
-# Scheduler for updating paper list every hour
-scheduler_data = BackgroundScheduler()
-scheduler_data.add_job(
-    func=update_paper_list,
-    trigger="cron",
-    minute=0,  # Every hour at minute 0
-    timezone="UTC",
-    misfire_grace_time=60,
-)
-scheduler_data.start()
-
-
-# --- Gradio App ---
-
-DESCRIPTION = "# [Daily Papers](https://huggingface.co/papers)"
-
-FOOT_NOTE = """\
-Related useful Spaces:
-- [Semantic Scholar Paper Recommender](https://huggingface.co/spaces/librarian-bots/recommend_similar_papers) by [davanstrien](https://huggingface.co/davanstrien)
-- [ArXiv CS RAG](https://huggingface.co/spaces/bishmoy/Arxiv-CS-RAG) by [bishmoy](https://huggingface.co/bishmoy)
-- [Paper Q&A](https://huggingface.co/spaces/chansung/paper_qa) by [chansung](https://huggingface.co/chansung)
-"""
-
 # --- Sorting and Pagination Management ---
 
 class PaperManager:
@@ -205,18 +173,20 @@ class PaperManager:
         self.paper_list = paper_list
         self.papers_per_page = papers_per_page
         self.current_page = 1
-        self.total_pages = max((len(self.paper_list.df_raw) + self.papers_per_page - 1) // self.papers_per_page, 1)
         self.sort_method = "hot"  # Default sort method
+        self.total_pages = max((len(self.paper_list.df_raw) + self.papers_per_page - 1) // self.papers_per_page, 1)
+        self.sort_papers()
 
-    def calculate_score(self, paper):
+    def calculate_score(self, row):
         """
         Calculate the score of a paper based on upvotes and age.
         This mimics the "hotness" algorithm used by platforms like Hacker News.
         """
-        upvotes = paper.get('upvotes', 0)
-        published_at_str = paper.get('date', datetime.datetime.now(timezone.utc).isoformat())
+        upvotes = row.get('👍', 0)
+        published_at_str = row.get('date', datetime.datetime.now(timezone.utc).isoformat())
         try:
-            published_time = datetime.datetime.fromisoformat(published_at_str.replace('Z', '+00:00'))
+            published_time = datetime.datetime.strptime(published_at_str, "%Y-%m-%d")
+            published_time = published_time.replace(tzinfo=datetime.timezone.utc)
         except ValueError:
             # If parsing fails, use current time to minimize the impact on sorting
             published_time = datetime.datetime.now(datetime.timezone.utc)
@@ -252,78 +222,109 @@ class PaperManager:
         self.sort_papers()
         return True  # Assume success
 
-    def get_current_page_papers(self):
+    def get_current_page_papers(self) -> str:
         start = (self.current_page - 1) * self.papers_per_page
         end = start + self.papers_per_page
         current_papers = self.paper_list.df_prettified.iloc[start:end]
-        return current_papers
 
-    def next_page(self):
+        if current_papers.empty:
+            return "<div class='no-papers'>No papers available for this page.</div>"
+
+        papers_html = "".join([self.format_paper(row, idx + start + 1) for idx, row in current_papers.iterrows()])
+        return f"""
+        <table border="0" cellpadding="0" cellspacing="0" class="itemlist">
+            {papers_html}
+        </table>
+        """
+
+    def format_paper(self, row, rank):
+        title = row.get('title', 'No title')
+        paper_id = row.get('arxiv_id', '')
+        url = f"https://huggingface.co/papers/{paper_id}"
+        authors = 'Unknown'  # Assuming authors are not present in the current dataset
+        upvotes = row.get('👍', 0)
+        comments = row.get('💬', 0)
+        published_time_str = row.get('date', datetime.datetime.now(timezone.utc).strftime("%Y-%m-%d"))
+        try:
+            published_time = datetime.datetime.strptime(published_time_str, "%Y-%m-%d").replace(tzinfo=datetime.timezone.utc)
+        except ValueError:
+            published_time = datetime.datetime.now(datetime.timezone.utc)
+        time_diff = datetime.datetime.now(datetime.timezone.utc) - published_time
+        time_ago_days = time_diff.days
+        time_ago = f"{time_ago_days} days ago" if time_ago_days > 0 else "today"
+
+        return f"""
+        <tr class="athing">
+            <td align="right" valign="top" class="title"><span class="rank">{rank}.</span></td>
+            <td valign="top" class="title">
+                <a href="{url}" class="storylink" target="_blank">{title}</a>
+            </td>
+        </tr>
+        <tr>
+            <td colspan="1"></td>
+            <td class="subtext">
+                <span class="score">{upvotes} upvotes</span><br>
+                authors: {authors} | {time_ago} | <a href="#">{comments} comments</a>
+            </td>
+        </tr>
+        <tr style="height:5px"></tr>
+        """
+
+    def next_page(self) -> str:
         if self.current_page < self.total_pages:
             self.current_page += 1
         return self.get_current_page_papers()
 
-    def prev_page(self):
+    def prev_page(self) -> str:
         if self.current_page > 1:
             self.current_page -= 1
         return self.get_current_page_papers()
 
-    def refresh(self):
+    def refresh(self) -> str:
         self.sort_papers()
         return self.get_current_page_papers()
 
 
-# Initialize PaperManager
-paper_manager = PaperManager(paper_list)
+# Initialize PaperList and PaperManager
+def initialize_paper_manager() -> PaperManager:
+    df = get_df()
+    paper_list = PaperList(df)
+    manager = PaperManager(paper_list)
+    return manager
+
+
+paper_manager = initialize_paper_manager()
 
 
-def refresh_paper_manager():
+def update_paper_manager() -> str:
     global paper_manager
-    paper_manager = PaperManager(paper_list)
-    if paper_manager.sort_method:
-        paper_manager.sort_papers()
+    df = get_df()
+    paper_manager.paper_list = PaperList(df)
+    paper_manager.sort_papers()
     return paper_manager.get_current_page_papers()
 
 
-# --- Gradio Interface Functions ---
-
-def update_num_papers(current_df: pd.DataFrame) -> str:
-    return f"{len(current_df)} / {len(paper_manager.paper_list.df_raw)}"
-
-
-def perform_search(
-    start_date: datetime.datetime,
-    end_date: datetime.datetime,
-    search_title: str,
-    search_abstract: str,
-    max_num_to_retrieve: int,
-    sort_method: str
-) -> pd.DataFrame:
-    # Update sort method
-    paper_manager.set_sort_method(sort_method.lower())
-
-    # Perform search
-    searched_df = paper_manager.paper_list.search(start_date, end_date, search_title, search_abstract, max_num_to_retrieve)
-    
-    # Update PaperList with searched results
-    paper_manager.paper_list.df_raw = searched_df.copy()
-    paper_manager.paper_list.df_prettified = paper_manager.paper_list._prettifier(searched_df).loc[:, paper_manager.paper_list.column_names]
-    paper_manager.total_pages = max((len(searched_df) + paper_manager.papers_per_page - 1) // paper_manager.papers_per_page, 1)
-    paper_manager.current_page = 1
-
-    # Apply sorting
-    paper_manager.sort_papers()
+# Scheduler for updating paper list every hour
+scheduler_data = BackgroundScheduler()
+scheduler_data.add_job(
+    func=update_paper_manager,
+    trigger="cron",
+    minute=0,  # Every hour at minute 0
+    timezone="UTC",
+    misfire_grace_time=60,
+)
+scheduler_data.start()
 
-    return paper_manager.get_current_page_papers()
 
+# --- Gradio Interface Functions ---
 
-def change_sort_method(method: str) -> pd.DataFrame:
+def change_sort_method_ui(method: str) -> str:
     paper_manager.set_sort_method(method.lower())
     return paper_manager.get_current_page_papers()
 
 
-def get_initial_papers() -> pd.DataFrame:
-    return paper_manager.get_current_page_papers()
+def refresh_papers_ui() -> str:
+    return paper_manager.refresh()
 
 
 # --- CSS Styling ---
@@ -504,7 +505,7 @@ with demo:
             </table>
             """)
 
-        # Sorting Options
+        # Sort Options
         with gr.Row():
             sort_radio = gr.Radio(
                 choices=["Hot", "New"],
@@ -513,125 +514,48 @@ with demo:
                 interactive=True
             )
 
-        # Search and Filter Inputs
-        with gr.Group():
-            search_title = gr.Textbox(label="Search Title")
-            with gr.Row():
-                with gr.Column(scale=4):
-                    search_abstract = gr.Textbox(
-                        label="Search Abstract",
-                        info="The result may not be accurate as the abstract does not contain all the information.",
-                    )
-                with gr.Column(scale=1):
-                    max_num_to_retrieve = gr.Slider(
-                        label="Max Number to Retrieve",
-                        info="This is used only for search on abstracts.",
-                        minimum=1,
-                        maximum=1000,  # Adjust as needed
-                        step=1,
-                        value=100,
-                    )
-            with gr.Row():
-                start_date = Calendar(label="Start Date", type="date", value="2023-05-05")
-                end_date = Calendar(label="End Date", type="date", value=datetime.datetime.utcnow().strftime("%Y-%m-%d"))
-
-            search_button = gr.Button("Search")
-
-        # Number of Papers Display
-        num_papers = gr.Textbox(label="Number of Papers", value=update_num_papers(paper_manager.get_current_page_papers()), interactive=False)
-
-        # Paper List Display
-        df_display = gr.DataFrame(
-            value=paper_manager.get_current_page_papers(),
-            datatype=paper_manager.paper_list.column_datatype,
-            type="pandas",
-            interactive=False,
-            height=600,
-            elem_id="table",
-            column_widths=["10%", "10%", "60%", "10%", "5%", "5%"],
-            wrap=True,
-        )
-
-        # Pagination Buttons
+        # Paper list
+        paper_list = gr.HTML()
+
+        # Navigation Buttons
         with gr.Row():
             prev_button = gr.Button("Prev")
             next_button = gr.Button("Next")
 
-        # Footer
-        gr.Markdown(FOOT_NOTE)
-
-        # Hidden Refresh Button
-        refresh_button = gr.Button("Refresh", visible=False, elem_id="refresh-hidden")
-        refresh_button.click(refresh_paper_manager, outputs=[df_display])
-
-        # Bind the visible Refresh button to the hidden one using JavaScript
-        gr.HTML("""
-        <script>
-        document.getElementById('refresh-button').addEventListener('click', function() {
-            document.getElementById('refresh-hidden').click();
-        });
-        </script>
-        """)
-
-        # Event Handlers
-
-        # Search Button Click
-        search_button.click(
-            fn=perform_search,
-            inputs=[start_date, end_date, search_title, search_abstract, max_num_to_retrieve, sort_radio],
-            outputs=[df_display],
-        ).then(
-            fn=update_num_papers,
-            inputs=df_display,
-            outputs=num_papers,
-            queue=False,
-        )
-
-        # Sort Radio Change
-        sort_radio.change(
-            fn=change_sort_method,
-            inputs=[sort_radio],
-            outputs=[df_display],
-        ).then(
-            fn=update_num_papers,
-            inputs=df_display,
-            outputs=num_papers,
-            queue=False,
-        )
-
-        # Pagination Buttons
-        prev_button.click(
-            fn=paper_manager.prev_page,
-            inputs=None,
-            outputs=[df_display],
-        ).then(
-            fn=update_num_papers,
-            inputs=df_display,
-            outputs=num_papers,
-            queue=False,
-        )
-
-        next_button.click(
-            fn=paper_manager.next_page,
-            inputs=None,
-            outputs=[df_display],
-        ).then(
-            fn=update_num_papers,
-            inputs=df_display,
-            outputs=num_papers,
-            queue=False,
-        )
-
-        # Initial Load
-        demo.load(
-            fn=get_initial_papers,
-            outputs=[df_display],
-        ).then(
-            fn=update_num_papers,
-            inputs=df_display,
-            outputs=num_papers,
-            queue=False,
-        )
+    # Load papers on app start
+    demo.load(initialize_paper_manager, outputs=[paper_list])
+
+    # Button clicks for pagination
+    prev_button.click(paper_manager.prev_page, outputs=[paper_list])
+    next_button.click(paper_manager.next_page, outputs=[paper_list])
+
+    # Refresh functionality
+    refresh_button = gr.Button("Refresh", visible=False, elem_id="refresh-hidden")
+    refresh_button.click(update_paper_manager, outputs=[paper_list])
+
+    # Bind the visible Refresh button to the hidden one using JavaScript
+    gr.HTML("""
+    <script>
+    document.getElementById('refresh-button').addEventListener('click', function() {
+        document.getElementById('refresh-hidden').click();
+    });
+    </script>
+    """)
+
+    # Sort option change
+    sort_radio.change(
+        fn=change_sort_method_ui,
+        inputs=[sort_radio],
+        outputs=[paper_list]
+    )
+
+    # Footer
+    gr.Markdown("""
+    Related useful Spaces:
+    - [Semantic Scholar Paper Recommender](https://huggingface.co/spaces/librarian-bots/recommend_similar_papers) by [davanstrien](https://huggingface.co/davanstrien)
+    - [ArXiv CS RAG](https://huggingface.co/spaces/bishmoy/Arxiv-CS-RAG) by [bishmoy](https://huggingface.co/bishmoy)
+    - [Paper Q&A](https://huggingface.co/spaces/chansung/paper_qa) by [chansung](https://huggingface.co/chansung)
+    """)
 
 # --- Launch the App ---