Update app.py

app.py

@@ -11,6 +11,7 @@ from ragatouille import RAGPretrainedModel
 import gradio as gr
 from gradio_calendar import Calendar
 import datasets
+import requests
 
 # --- Data Loading and Processing ---
 
@@ -40,6 +41,7 @@ def update_abstract_index() -> None:
     abstract_retriever.search("LLM")
 
 
+# Scheduler for updating abstract index every hour
 scheduler_abstract = BackgroundScheduler()
 scheduler_abstract.add_job(
     func=update_abstract_index,
@@ -58,7 +60,7 @@ def get_df() -> pd.DataFrame:
         on="arxiv_id",
     )
     df = df[::-1].reset_index(drop=True)
-    df["date"] = df["date"].dt.strftime("%Y-%m-%d")
+    df["date"] = pd.to_datetime(df["date"]).dt.strftime("%Y-%m-%d")
 
     paper_info = []
     for _, row in tqdm.auto.tqdm(df.iterrows(), total=len(df)):
@@ -164,6 +166,7 @@ class PaperList:
         return df_prettified
 
 
+# Initialize PaperList
 paper_list = PaperList(get_df())
 
 
@@ -172,6 +175,7 @@ def update_paper_list() -> None:
     paper_list = PaperList(get_df())
 
 
+# Scheduler for updating paper list every hour
 scheduler_data = BackgroundScheduler()
 scheduler_data.add_job(
     func=update_paper_list,
@@ -182,6 +186,7 @@ scheduler_data.add_job(
 )
 scheduler_data.start()
 
+
 # --- Gradio App ---
 
 DESCRIPTION = "# [Daily Papers](https://huggingface.co/papers)"
@@ -193,99 +198,442 @@ Related useful Spaces:
 - [Paper Q&A](https://huggingface.co/spaces/chansung/paper_qa) by [chansung](https://huggingface.co/chansung)
 """
 
-
-def update_df() -> pd.DataFrame:
-    return paper_list.df_prettified
-
-
-def update_num_papers(df: pd.DataFrame) -> str:
-    return f"{len(df)} / {len(paper_list.df_raw)}"
-
-
-def search(
+# --- Sorting and Pagination Management ---
+
+class PaperManager:
+    def __init__(self, paper_list: PaperList, papers_per_page=30):
+        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
+
+    def calculate_score(self, paper):
+        """
+        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())
+        try:
+            published_time = datetime.datetime.fromisoformat(published_at_str.replace('Z', '+00:00'))
+        except ValueError:
+            # If parsing fails, use current time to minimize the impact on sorting
+            published_time = datetime.datetime.now(datetime.timezone.utc)
+
+        time_diff = datetime.datetime.now(datetime.timezone.utc) - published_time
+        time_diff_hours = time_diff.total_seconds() / 3600  # Convert time difference to hours
+
+        # Avoid division by zero and apply the hotness formula
+        score = upvotes / ((time_diff_hours + 2) ** 1.5)
+        return score
+
+    def sort_papers(self):
+        df = self.paper_list.df_raw.copy()
+
+        if self.sort_method == "hot":
+            df['score'] = df.apply(self.calculate_score, axis=1)
+            df_sorted = df.sort_values(by='score', ascending=False).drop(columns=['score'])
+        elif self.sort_method == "new":
+            df_sorted = df.sort_values(by='date', ascending=False)
+        else:
+            df_sorted = df
+
+        self.paper_list.df_raw = df_sorted.reset_index(drop=True)
+        self.paper_list.df_prettified = self.paper_list._prettifier(self.paper_list.df_raw).loc[:, self.paper_list.column_names]
+        self.total_pages = max((len(self.paper_list.df_raw) + self.papers_per_page - 1) // self.papers_per_page, 1)
+        self.current_page = 1
+
+    def set_sort_method(self, method):
+        if method not in ["hot", "new"]:
+            method = "hot"
+        print(f"Setting sort method to: {method}")
+        self.sort_method = method
+        self.sort_papers()
+        return True  # Assume success
+
+    def get_current_page_papers(self):
+        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 self.current_page < self.total_pages:
+            self.current_page += 1
+        return self.get_current_page_papers()
+
+    def prev_page(self):
+        if self.current_page > 1:
+            self.current_page -= 1
+        return self.get_current_page_papers()
+
+    def refresh(self):
+        self.sort_papers()
+        return self.get_current_page_papers()
+
+
+# Initialize PaperManager
+paper_manager = PaperManager(paper_list)
+
+
+def refresh_paper_manager():
+    global paper_manager
+    paper_manager = PaperManager(paper_list)
+    if paper_manager.sort_method:
+        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:
-    return paper_list.search(start_date, end_date, search_title, search_abstract, max_num_to_retrieve)
+    # 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()
+
+    return paper_manager.get_current_page_papers()
+
+
+def change_sort_method(method: str) -> pd.DataFrame:
+    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()
+
+
+# --- CSS Styling ---
+
+css = """
+/* Existing CSS remains unchanged */
+body {
+    background-color: white;
+    font-family: Verdana, Geneva, sans-serif;
+    margin: 0;
+    padding: 0;
+}
+
+a {
+    color: #0000ff;
+    text-decoration: none;
+}
+
+a:visited {
+    color: #551A8B;
+}
+
+.container {
+    width: 85%;
+    margin: auto;
+}
+
+table {
+    width: 100%;
+}
+
+.header-table {
+    width: 100%;
+    background-color: #ff6600;
+    padding: 2px 10px;
+}
+
+.header-table a {
+    color: black;
+    font-weight: bold;
+    font-size: 14pt;
+    text-decoration: none;
+}
+
+.itemlist .athing {
+    background-color: #f6f6ef;
+}
+
+.rank {
+    font-size: 14pt;
+    color: #828282;
+    padding-right: 5px;
+}
+
+.storylink {
+    font-size: 10pt;
+}
+
+.subtext {
+    font-size: 8pt;
+    color: #828282;
+    padding-left: 40px;
+}
+
+.subtext a {
+    color: #828282;
+    text-decoration: none;
+}
+
+#refresh-button {
+    background: none;
+    border: none;
+    color: black;
+    font-weight: bold;
+    font-size: 14pt;
+    cursor: pointer;
+}
+
+.no-papers {
+    text-align: center;
+    color: #828282;
+    padding: 1rem;
+    font-size: 14pt;
+}
+
+@media (max-width: 640px) {
+    .header-table a {
+        font-size: 12pt;
+    }
+
+    .storylink {
+        font-size: 9pt;
+    }
+
+    .subtext {
+        font-size: 7pt;
+    }
+}
+
+/* Dark mode */
+@media (prefers-color-scheme: dark) {
+    body {
+        background-color: #121212;
+        color: #e0e0e0;
+    }
+
+    a {
+        color: #add8e6;
+    }
+
+    a:visited {
+        color: #9370db;
+    }
+
+    .header-table {
+        background-color: #ff6600;
+    }
+
+    .header-table a {
+        color: black;
+    }
+
+    .itemlist .athing {
+        background-color: #1e1e1e;
+    }
+
+    .rank {
+        color: #b0b0b0;
+    }
+
+    .subtext {
+        color: #b0b0b0;
+    }
+
+    .subtext a {
+        color: #b0b0b0;
+    }
+
+    #refresh-button {
+        color: #e0e0e0;
+    }
+
+    .no-papers {
+        color: #b0b0b0;
+    }
+}
+"""
+
+# --- Initialize Gradio Blocks ---
+
+demo = gr.Blocks(css=css)
+
+with demo:
+    with gr.Column(elem_classes=["container"]):
+        # Accordion for Submission Instructions
+        with gr.Accordion("How to Submit a Paper", open=False):
+            gr.Markdown("""
+            **Submit the paper to Daily Papers:**
+            [https://huggingface.co/papers/submit](https://huggingface.co/papers/submit)
 
+            Once your paper is submitted, it will automatically appear in this demo.
+            """)
 
-with gr.Blocks(css="style.css") as demo:
-    gr.Markdown(DESCRIPTION)
-    with gr.Group():
-        search_title = gr.Textbox(label="Search title")
+        # Header with Refresh Button
         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=len(paper_list.df_raw),
-                    step=1,
-                    value=100,
-                )
+            gr.HTML("""
+            <table border="0" cellpadding="0" cellspacing="0" class="header-table">
+                <tr>
+                    <td>
+                        <span class="pagetop">
+                            <b class="hnname"><a href="#">Daily Papers</a></b>
+                        </span>
+                    </td>
+                    <td align="right">
+                        <button id="refresh-button">Refresh</button>
+                    </td>
+                </tr>
+            </table>
+            """)
+
+        # Sorting Options
         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"))
-
-    num_papers = gr.Textbox(label="Number of papers", value=update_num_papers(paper_list.df_raw), interactive=False)
-    df = gr.Dataframe(
-        value=paper_list.df_prettified,
-        datatype=paper_list.column_datatype,
-        type="pandas",
-        interactive=False,
-        height=1000,
-        elem_id="table",
-        column_widths=["10%", "10%", "60%", "10%", "5%", "5%"],
-        wrap=True,
-    )
+            sort_radio = gr.Radio(
+                choices=["Hot", "New"],
+                value="Hot",
+                label="Sort By",
+                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,
+        )
 
-    gr.Markdown(FOOT_NOTE)
-
-    # Define the triggers and corresponding functions
-    search_event = gr.Button("Search")
-    search_event.click(
-        fn=search,
-        inputs=[start_date, end_date, search_title, search_abstract, max_num_to_retrieve],
-        outputs=df,
-    ).then(
-        fn=update_num_papers,
-        inputs=df,
-        outputs=num_papers,
-        queue=False,
-    )
+        # Pagination 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,
+        )
 
-    # Automatically trigger search when inputs change
-    for trigger in [start_date, end_date, search_title, search_abstract, max_num_to_retrieve]:
-        trigger.change(
-            fn=search,
-            inputs=[start_date, end_date, search_title, search_abstract, max_num_to_retrieve],
-            outputs=df,
+        # Sort Radio Change
+        sort_radio.change(
+            fn=change_sort_method,
+            inputs=[sort_radio],
+            outputs=[df_display],
         ).then(
             fn=update_num_papers,
-            inputs=df,
+            inputs=df_display,
             outputs=num_papers,
             queue=False,
         )
 
-    # Load the initial dataframe and number of papers
-    demo.load(
-        fn=update_df,
-        outputs=df,
-        queue=False,
-    ).then(
-        fn=update_num_papers,
-        inputs=df,
-        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,
+        )
+
+# --- Launch the App ---
 
 if __name__ == "__main__":
-    demo.queue(api_open=False).launch(show_api=False)
+    demo.launch()