Initial commit

app.py

@@ -0,0 +1,329 @@
+import gradio as gr
+from df.PaperCentral import PaperCentral
+from gradio_calendar import Calendar
+from datetime import datetime, timedelta
+from typing import Union, List
+
+# Initialize the PaperCentral class instance
+paper_central_df = PaperCentral()
+
+# Create the Gradio Blocks app with custom CSS
+with gr.Blocks(css="style.css") as demo:
+    gr.Markdown("# Paper Central")
+
+    # Create a row for navigation buttons and calendar
+    with gr.Row():
+        with gr.Column(scale=1):
+            # Define the 'Next Day' and 'Previous Day' buttons
+            next_day_btn = gr.Button("Next Day")
+            prev_day_btn = gr.Button("Previous Day")
+        with gr.Column(scale=4):
+            # Define the calendar component for date selection
+            calendar = Calendar(
+                type="datetime",
+                label="Select a date",
+                info="Click the calendar icon to bring up the calendar.",
+                value=datetime.today().strftime('%Y-%m-%d')  # Default to today's date
+            )
+
+    # Create a row for Hugging Face options and Conference options
+    with gr.Row():
+        with gr.Column():
+            # Define the checkbox group for Hugging Face options
+            cat_options = gr.CheckboxGroup(
+                label="Category",
+                choices=[
+                    'cs.*',
+                    'eess.*',
+                    'econ.*',
+                    'math.*',
+                    'astro-ph.*',
+                    'cond-mat.*',
+                    'gr-qc',
+                    'hep-ex',
+                    'hep-lat',
+                    'hep-ph',
+                    'hep-th',
+                    'math-ph',
+                    'nlin.*',
+                    'nucl-ex',
+                    'nucl-th',
+                    'physics.*',
+                    'quant-ph',
+                    'q-bio.*',
+                    'q-fin.*',
+                    'stat.*',
+                ],
+                value=["cs.*"]
+            )
+            hf_options = gr.CheckboxGroup(
+                label="Hugging Face options",
+                choices=["show_details", "datasets", "models", "spaces"]
+            )
+
+        with gr.Column():
+            # Define the checkbox group for Conference options
+            conference_options = gr.CheckboxGroup(
+                label="Conference options",
+                choices=["In proceedings"] + PaperCentral.CONFERENCES
+            )
+
+    # Define the Dataframe component to display paper data
+    # List of columns in your DataFrame
+    columns = paper_central_df.COLUMNS_START_PAPER_PAGE
+
+    paper_central_component = gr.Dataframe(
+        label="Paper Data",
+        value=paper_central_df.df_prettified[columns],
+        datatype=[
+            paper_central_df.DATATYPES[column]
+            for column in columns
+        ],
+        row_count=(0, "dynamic"),
+        interactive=False,
+        height=1000,
+        elem_id="table",
+    )
+
+
+    # Define function to move to the next day
+    def go_to_next_day(
+            date: Union[str, datetime],
+            cat_options_list: List[str],
+            hf_options_list: List[str],
+            conference_options_list: List[str]
+    ) -> tuple:
+        """
+        Moves the selected date to the next day and updates the data.
+
+        Args:
+            date (Union[str, datetime]): The current date selected in the calendar.
+            cat_options_list (List[str]): List of selected Category options.
+            hf_options_list (List[str]): List of selected Hugging Face options.
+            conference_options_list (List[str]): List of selected Conference options.
+
+        Returns:
+            tuple: The new date as a string and the updated Dataframe component.
+        """
+        # Ensure the date is in string format
+        if isinstance(date, datetime):
+            date_str = date.strftime('%Y-%m-%d')
+        else:
+            date_str = date
+
+        # Parse the date string and add one day
+        new_date = datetime.strptime(date_str, '%Y-%m-%d') + timedelta(days=1)
+        new_date_str = new_date.strftime('%Y-%m-%d')
+
+        # Update the Dataframe
+        updated_data = paper_central_df.filter(
+            selected_date=new_date_str,
+            cat_options=cat_options_list,
+            hf_options=hf_options_list,
+            conference_options=conference_options_list
+        )
+
+        # Return the new date and updated Dataframe
+        return new_date_str, updated_data
+
+
+    # Define function to move to the previous day
+    def go_to_previous_day(
+            date: Union[str, datetime],
+            cat_options_list: List[str],
+            hf_options_list: List[str],
+            conference_options_list: List[str]
+    ) -> tuple:
+        """
+        Moves the selected date to the previous day and updates the data.
+
+        Args:
+            date (Union[str, datetime]): The current date selected in the calendar.
+            cat_options_list (List[str]): List of selected Category options.
+            hf_options_list (List[str]): List of selected Hugging Face options.
+            conference_options_list (List[str]): List of selected Conference options.
+
+        Returns:
+            tuple: The new date as a string and the updated Dataframe component.
+        """
+        # Ensure the date is in string format
+        if isinstance(date, datetime):
+            date_str = date.strftime('%Y-%m-%d')
+        else:
+            date_str = date
+
+        # Parse the date string and subtract one day
+        new_date = datetime.strptime(date_str, '%Y-%m-%d') - timedelta(days=1)
+        new_date_str = new_date.strftime('%Y-%m-%d')
+
+        # Update the Dataframe
+        updated_data = paper_central_df.filter(
+            selected_date=new_date_str,
+            cat_options=cat_options_list,
+            hf_options=hf_options_list,
+            conference_options=conference_options_list
+        )
+
+        # Return the new date and updated Dataframe
+        return new_date_str, updated_data
+
+
+    # Define function to update data when date or options change
+    def update_data(
+            date: Union[str, datetime],
+            cat_options_list: List[str],
+            hf_options_list: List[str],
+            conference_options_list: List[str]
+    ):
+        """
+        Updates the data displayed in the Dataframe based on the selected date and options.
+
+        Args:
+            date (Union[str, datetime]): The selected date.
+            cat_options_list (List[str]): List of selected Category options.
+            hf_options_list (List[str]): List of selected Hugging Face options.
+            conference_options_list (List[str]): List of selected Conference options.
+
+        Returns:
+            gr.Dataframe.update: An update object for the Dataframe component.
+        """
+        return paper_central_df.filter(
+            selected_date=date,
+            cat_options=cat_options_list,
+            hf_options=hf_options_list,
+            conference_options=conference_options_list
+        )
+
+
+    # Function to handle conference options change
+    def on_conference_options_change(
+            date: Union[str, datetime],
+            cat_options_list: List[str],
+            hf_options_list: List[str],
+            conference_options_list: List[str]
+    ):
+
+        cat_options_update = gr.update()
+        paper_central_component_update = gr.update()
+        visible = True
+
+        # Some conference options are selected
+        # Update cat_options to empty list
+        if conference_options_list:
+            cat_options_update = gr.update(value=[])
+            paper_central_component_update = update_data(
+                date,
+                [],
+                hf_options_list,
+                conference_options_list,
+            )
+            visible = False
+
+        calendar_update = gr.update(visible=visible)
+        next_day_btn_update = gr.update(visible=visible)
+        prev_day_btn_update = gr.update(visible=visible)
+
+        return paper_central_component_update, cat_options_update, calendar_update, next_day_btn_update, prev_day_btn_update
+
+
+    # Function to handle category options change
+    def on_cat_options_change(
+            date: Union[str, datetime],
+            cat_options_list: List[str],
+            hf_options_list: List[str],
+            conference_options_list: List[str]
+    ):
+        conference_options_update = gr.update()
+        paper_central_component_update = gr.update()
+        visible = False
+
+        # Some category options are selected
+        # Update conference_options to empty list
+        if cat_options_list:
+            conference_options_update = gr.update(value=[])
+            paper_central_component_update = update_data(
+                date,
+                cat_options_list,
+                hf_options_list,
+                [],
+            )
+            visible = True
+
+        calendar_update = gr.update(visible=visible)
+        next_day_btn_update = gr.update(visible=visible)
+        prev_day_btn_update = gr.update(visible=visible)
+
+        return paper_central_component_update, conference_options_update, calendar_update, next_day_btn_update, prev_day_btn_update
+
+
+
+    # Set up the event listener for the 'Next Day' button
+    next_day_btn.click(
+        fn=go_to_next_day,
+        inputs=[calendar, cat_options, hf_options, conference_options],
+        outputs=[calendar, paper_central_component],
+    )
+
+    # Set up the event listener for the 'Previous Day' button
+    prev_day_btn.click(
+        fn=go_to_previous_day,
+        inputs=[calendar, cat_options, hf_options, conference_options],
+        outputs=[calendar, paper_central_component],
+    )
+
+    # Define the inputs for the filter function
+    inputs = [
+        calendar,
+        cat_options,
+        hf_options,
+        conference_options,
+    ]
+
+    # Set up the event listener for the calendar date change
+    calendar.change(
+        fn=update_data,
+        inputs=inputs,
+        outputs=paper_central_component,
+    )
+
+    # Set up the event listener for the Hugging Face options change
+    hf_options.change(
+        fn=update_data,
+        inputs=inputs,
+        outputs=paper_central_component,
+    )
+
+    # Event chaining for conference options change
+    conference_options.change(
+        fn=on_conference_options_change,
+        inputs=inputs,
+        outputs=[paper_central_component, cat_options, calendar, next_day_btn, prev_day_btn],
+    )
+
+    # Event chaining for category options change
+    cat_options.change(
+        fn=on_cat_options_change,
+        inputs=inputs,
+        outputs=[paper_central_component, conference_options, calendar, next_day_btn, prev_day_btn],
+    )
+
+    # Load the initial data when the app starts
+    demo.load(
+        fn=update_data,
+        inputs=inputs,
+        outputs=paper_central_component,
+        api_name=False,
+    )
+
+
+# Define the main function to launch the app
+def main():
+    """
+    Launches the Gradio app.
+    """
+    demo.launch()
+
+
+# Run the main function when the script is executed
+if __name__ == "__main__":
+    main()

constants.py

@@ -0,0 +1,6 @@
+NEURIPS_ICO = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAAeFBMVEVHcExoRIuHYZ5oRItoRItoRItoRItoRItSN2loRItoRIuDXpxoRItoRIuSbKWRa6SRa6QCAAsAAAAAAAAAAAAAAAAAAAAAAAAAAACRa6SRa6QAAAAAAAAAAACRa6SRa6SRa6QAAAAAAAAAAACRa6QAAACRa6SRa6TWTNGBAAAAKHRSTlMAQBVQ9mKR0AgzfiGvcypL4BBmP11VbIQvd5JKcSFaOv95io2qjsjs/SKIogAAAT9JREFUeAHMwbUBAzAMBMB/C2wLAvsvmyYMfe7wZ8gh+E3Np6lMfLV0h+bwHFLEJ90lEFGZvcUcH6ayIri5ucLF8Iq6AZl0aROAKcSzw8G3NFYJbohnx+3Ybbbxw+msBHJfqp2DHAdhGAqgX1khRSKY2GAwJtBhOve/4aTNoisO0GfJ9srfGDOLYGKaSfGxpBWNbVtmr20cDR9xL6iydpp9ooncoCKZjNRRHf0eOkBsPI3xOPVnlhlmjG0WVDEMJQLmnuHmlMndO8+v3dqFUK6AipjFTUXZXyWiag5g2VO5egA+8cZgwekmWSz/TmTAMqThwrD26PA+zLzZWOdJhEwAwrPfhxLCAZjpaIY8+eMUIzTLMy7laiECVYaKqrf85u/CuuOIuLOGNSUUpB53jvpFisOFe8d+rCHgXkQK+Fb/W30Y/tu4vyAAAAAASUVORK5CYII="
+DATASET_ARXIV_SCAN_PAPERS = "IAMJB/scanned-arxiv-papers-id"
+DATASET_CONFERENCE_PAPERS = "IAMJB/paper_conference_aggregate"
+DATASET_DAILY_PAPERS = "hysts-bot-data/daily-papers"
+DATASET_DAILY_PAPERS_STATS = "hysts-bot-data/daily-papers-stats"
+DATASET_COMMUNITY_SCIENCE = "huggingface/community-science-paper-v2"

df/PaperCentral.py

@@ -0,0 +1,443 @@
+import pandas as pd
+from typing import List, Dict, Optional
+from constants import (
+    DATASET_ARXIV_SCAN_PAPERS,
+    DATASET_CONFERENCE_PAPERS,
+    DATASET_COMMUNITY_SCIENCE,
+    NEURIPS_ICO,
+)
+import gradio as gr
+from utils import load_and_process
+import numpy as np
+
+
+class PaperCentral:
+    """
+    A class to manage and process paper data for display in a Gradio Dataframe component.
+    """
+
+    CONFERENCES = [
+        "ACL2023",
+        "ACL2024",
+        "COLING2024",
+        "CVPR2023",
+        "CVPR2024",
+        "ECCV2024",
+        "EMNLP2023",
+        "NAACL2023",
+        "NeurIPS2023",
+        "NeurIPS2023 D&B",
+    ]
+    CONFERENCES_ICONS = {
+        "ACL2023": 'https://aclanthology.org/aclicon.ico',
+        "ACL2024": 'https://aclanthology.org/aclicon.ico',
+        "COLING2024": 'https://aclanthology.org/aclicon.ico',
+        "CVPR2023": "https://openaccess.thecvf.com/favicon.ico",
+        "CVPR2024": "https://openaccess.thecvf.com/favicon.ico",
+        "ECCV2024": "https://openaccess.thecvf.com/favicon.ico",
+        "EMNLP2023": 'https://aclanthology.org/aclicon.ico',
+        "NAACL2023": 'https://aclanthology.org/aclicon.ico',
+        "NeurIPS2023": NEURIPS_ICO,
+        "NeurIPS2023 D&B": NEURIPS_ICO,
+    }
+
+    # Class-level constants defining columns and their data types
+    COLUMNS_START_PAPER_PAGE: List[str] = [
+        'date',
+        'arxiv_id',
+        'paper_page',
+        'title',
+    ]
+
+    COLUMNS_ORDER_PAPER_PAGE: List[str] = [
+        'date',
+        'arxiv_id',
+        'paper_page',
+        'num_models',
+        'num_datasets',
+        'num_spaces',
+        'conference_name',
+        'id',
+        'type',
+        'proceedings',
+        'title',
+        'upvotes',
+        'num_comments',
+    ]
+
+    DATATYPES: Dict[str, str] = {
+        'date': 'str',
+        'arxiv_id': 'markdown',
+        'paper_page': 'markdown',
+        'upvotes': 'str',
+        'num_comments': 'str',
+        'num_models': 'markdown',
+        'num_datasets': 'markdown',
+        'num_spaces': 'markdown',
+        'title': 'str',
+        'proceedings': 'markdown',
+        'conference_name': 'str',
+        'id': 'str',
+        'type': 'str',
+    }
+
+    # Mapping for renaming columns for display purposes
+    COLUMN_RENAME_MAP: Dict[str, str] = {
+        'num_models': 'models',
+        'num_spaces': 'spaces',
+        'num_datasets': 'datasets',
+        'conference_name': 'venue',
+    }
+
+    def __init__(self):
+        """
+        Initialize the PaperCentral class by loading and processing the datasets.
+        """
+        self.df_raw: pd.DataFrame = self.get_df()
+        self.df_prettified: pd.DataFrame = self.prettify(self.df_raw)
+
+    @staticmethod
+    def get_columns_order(columns: List[str]) -> List[str]:
+        """
+        Get columns ordered according to COLUMNS_ORDER_PAPER_PAGE.
+
+        Args:
+            columns (List[str]): List of column names to order.
+
+        Returns:
+            List[str]: Ordered list of column names.
+        """
+        return [c for c in PaperCentral.COLUMNS_ORDER_PAPER_PAGE if c in columns]
+
+    @staticmethod
+    def get_columns_datatypes(columns: List[str]) -> List[str]:
+        """
+        Get data types for the specified columns.
+
+        Args:
+            columns (List[str]): List of column names.
+
+        Returns:
+            List[str]: List of data types corresponding to the columns.
+        """
+        return [PaperCentral.DATATYPES[c] for c in columns]
+
+    @staticmethod
+    def get_df() -> pd.DataFrame:
+        """
+        Load and merge datasets to create the raw DataFrame.
+
+        Returns:
+            pd.DataFrame: The merged and processed DataFrame.
+        """
+        # Load datasets
+        arxiv_scan_papers: pd.DataFrame = load_and_process(DATASET_ARXIV_SCAN_PAPERS)[
+            ['arxiv_id', 'published_date', 'categories', 'title', 'primary_category',
+             'huggingface_urls']
+        ]
+        arxiv_scan_papers['published_date'] = pd.to_datetime(arxiv_scan_papers['published_date']) + pd.DateOffset(
+            days=1)
+
+        community_science_papers: pd.DataFrame = load_and_process(DATASET_COMMUNITY_SCIENCE)[
+            ['arxiv_id', 'date', 'upvotes', 'num_comments', 'github', 'num_models', 'num_datasets', 'num_spaces',
+             'title']
+        ]
+
+        conference_papers: pd.DataFrame = load_and_process(DATASET_CONFERENCE_PAPERS)[
+            ['id', 'proceedings', 'type', 'arxiv_id', 'title', 'conference_name']
+        ]
+
+        # Merge arxiv_scan_papers and community_science_papers on 'arxiv_id'
+        merged_df: pd.DataFrame = pd.merge(arxiv_scan_papers, community_science_papers, on='arxiv_id', how='outer')
+        merged_df['title'] = merged_df['title_x'].combine_first(merged_df['title_y'])
+        merged_df = merged_df.drop(columns=['title_x', 'title_y'])
+
+        final_merged_df: pd.DataFrame = pd.merge(
+            merged_df,
+            conference_papers,
+            on='arxiv_id',
+            how='outer'
+        )
+
+        # Combine the 'title' columns into one
+        final_merged_df['title'] = final_merged_df['title_x'].combine_first(final_merged_df['title_y'])
+
+        # Drop the redundant 'title_x' and 'title_y' columns
+        final_merged_df = final_merged_df.drop(columns=['title_x', 'title_y'])
+
+        # Use 'date' from community_science_papers if available; otherwise, use 'published_date'
+        final_merged_df['date'] = final_merged_df['date'].combine_first(final_merged_df['published_date'])
+        final_merged_df.drop(columns=['published_date'], inplace=True)
+
+        # If 'arxiv_id' is in community_science_papers, set 'paper_page' to 'arxiv_id'
+        final_merged_df.loc[
+            final_merged_df['arxiv_id'].isin(community_science_papers['arxiv_id']), 'paper_page'
+        ] = final_merged_df['arxiv_id']
+
+        # Format the 'date' column
+        final_merged_df = PaperCentral.format_df_date(final_merged_df, "date")
+        final_merged_df['date'] = final_merged_df['date'].astype(str)
+
+        print(final_merged_df.head())
+        return final_merged_df
+
+    @staticmethod
+    def format_df_date(df: pd.DataFrame, date_column: str = "date") -> pd.DataFrame:
+        """
+        Format the date column in the DataFrame to 'YYYY-MM-DD'.
+
+        Args:
+            df (pd.DataFrame): The DataFrame to format.
+            date_column (str): The name of the date column.
+
+        Returns:
+            pd.DataFrame: The DataFrame with the formatted date column.
+        """
+        df.loc[:, date_column] = pd.to_datetime(df[date_column]).dt.strftime('%Y-%m-%d')
+        return df
+
+    @staticmethod
+    def prettify(df: pd.DataFrame) -> pd.DataFrame:
+        """
+        Prettify the DataFrame by adding markdown links and sorting.
+
+        Args:
+            df (pd.DataFrame): The DataFrame to prettify.
+
+        Returns:
+            pd.DataFrame: The prettified DataFrame.
+        """
+
+        def update_row(row: pd.Series) -> pd.Series:
+            """
+            Update a row by adding markdown links to 'paper_page' and 'arxiv_id' columns.
+
+            Args:
+                row (pd.Series): A row from the DataFrame.
+
+            Returns:
+                pd.Series: The updated row.
+            """
+            # Process 'num_models' column
+            if (
+                    'num_models' in row and pd.notna(row['num_models']) and row["arxiv_id"]
+                    and float(row['num_models']) > 0
+            ):
+                num_models = int(float(row['num_models']))
+                row['num_models'] = (
+                    f"[{num_models}](https://huggingface.co/models?other=arxiv:{row['arxiv_id']})"
+                )
+
+            if (
+                    'num_datasets' in row and pd.notna(row['num_datasets']) and row["arxiv_id"]
+                    and float(row['num_datasets']) > 0
+            ):
+                num_datasets = int(float(row['num_datasets']))
+                row['num_datasets'] = (
+                    f"[{num_datasets}](https://huggingface.co/datasets?other=arxiv:{row['arxiv_id']})"
+                )
+
+            if (
+                    'num_spaces' in row and pd.notna(row['num_spaces']) and row["arxiv_id"]
+                    and float(row['num_spaces']) > 0
+            ):
+                num_spaces = int(float(row['num_spaces']))
+                row['num_spaces'] = (
+                    f"[{num_spaces}](https://huggingface.co/spaces?other=arxiv:{row['arxiv_id']})"
+                )
+
+            if 'proceedings' in row and pd.notna(row['proceedings']) and row['proceedings']:
+                image_url = PaperCentral.CONFERENCES_ICONS[row["conference_name"]]
+
+                style = "display:inline-block; vertical-align:middle; width: 16px; height:16px"
+                row['proceedings'] = (
+                    f"<img src='{image_url}' style='{style}'/>"
+                    f"<a href='{row['proceedings']}'>proc_page</a>"
+                )
+
+            ####
+            ### This should be processed last :)
+            ####
+            # Add markdown link to 'paper_page' if it exists
+            if 'paper_page' in row and pd.notna(row['paper_page']):
+                row['paper_page'] = f"🤗[paper_page](https://huggingface.co/papers/{row['paper_page']})"
+
+            # Add image and link to 'arxiv_id' if it exists
+            if 'arxiv_id' in row and pd.notna(row['arxiv_id']):
+                image_url = "https://arxiv.org/static/browse/0.3.4/images/icons/favicon-16x16.png"
+                style = "display:inline-block; vertical-align:middle;"
+                row['arxiv_id'] = (
+                    f"<img src='{image_url}' style='{style}'/>"
+                    f"<a href='https://arxiv.org/abs/{row['arxiv_id']}'>arxiv_page</a>"
+                )
+
+            return row
+
+        df = df.copy()
+
+        # Sort rows to display entries with 'paper_page' first
+        if 'paper_page' in df.columns:
+            df['has_paper_page'] = df['paper_page'].notna()
+            df.sort_values(by='has_paper_page', ascending=False, inplace=True)
+            df.drop(columns='has_paper_page', inplace=True)
+
+        # Apply the update_row function to each row
+        prettified_df: pd.DataFrame = df.apply(update_row, axis=1)
+        return prettified_df
+
+    def rename_columns_for_display(self, df: pd.DataFrame) -> pd.DataFrame:
+        """
+        Rename columns in the DataFrame according to COLUMN_RENAME_MAP for display purposes.
+
+        Args:
+            df (pd.DataFrame): The DataFrame whose columns need to be renamed.
+
+        Returns:
+            pd.DataFrame: The DataFrame with renamed columns.
+        """
+        return df.rename(columns=self.COLUMN_RENAME_MAP)
+
+    def filter(
+            self,
+            selected_date: Optional[str] = None,
+            cat_options: Optional[List[str]] = None,
+            hf_options: Optional[List[str]] = None,
+            conference_options: Optional[List[str]] = None
+    ) -> gr.update:
+        """
+        Filter the DataFrame based on selected date and options, and prepare it for display.
+
+        Args:
+            selected_date (Optional[str]): The date to filter the DataFrame.
+            hf_options (Optional[List[str]]): List of options selected by the user.
+            conference_options (Optional[List[str]]): List of conference options selected by the user.
+
+        Returns:
+            gr.Update: An update object for the Gradio Dataframe component.
+        """
+        filtered_df: pd.DataFrame = self.df_raw.copy()
+
+        # Start with the initial columns to display
+        columns_to_show: List[str] = PaperCentral.COLUMNS_START_PAPER_PAGE.copy()
+
+        if cat_options:
+            options = [o.replace(".*", "") for o in cat_options]
+            # Initialize filter series
+            conference_filter = pd.Series(False, index=filtered_df.index)
+            for option in options:
+                # Filter rows where 'conference_name' contains the conference string (case-insensitive)
+                conference_filter |= (
+                        filtered_df['primary_category'].notna() &
+                        filtered_df['primary_category'].str.contains(option, case=False)
+                )
+            filtered_df = filtered_df[conference_filter]
+
+        # Date
+        if selected_date and not conference_options:
+            selected_date = pd.to_datetime(selected_date).strftime('%Y-%m-%d')
+            filtered_df = filtered_df[filtered_df['date'] == selected_date]
+
+        # HF options
+        if hf_options:
+            if "show_details" in hf_options:
+                # Filter rows where 'paper_page' is not empty or NaN
+                filtered_df = filtered_df[
+                    (filtered_df['paper_page'] != "") & (filtered_df['paper_page'].notna())
+                    ]
+
+                # Add 'upvotes' column if not already in columns_to_show
+                if 'upvotes' not in columns_to_show:
+                    columns_to_show.append('upvotes')
+
+                # Add 'num_models' column if not already in columns_to_show
+                if 'num_models' not in columns_to_show:
+                    columns_to_show.append('num_models')
+                if 'num_datasets' not in columns_to_show:
+                    columns_to_show.append('num_datasets')
+                if 'num_spaces' not in columns_to_show:
+                    columns_to_show.append('num_spaces')
+
+            if "datasets" in hf_options:
+                if 'num_datasets' not in columns_to_show:
+                    columns_to_show.append('num_datasets')
+                filtered_df = filtered_df[filtered_df['num_datasets'] != 0]
+
+            if "models" in hf_options:
+                if 'num_models' not in columns_to_show:
+                    columns_to_show.append('num_models')
+                filtered_df = filtered_df[filtered_df['num_models'] != 0]
+            if "spaces" in hf_options:
+                if 'num_spaces' not in columns_to_show:
+                    columns_to_show.append('num_spaces')
+                filtered_df = filtered_df[filtered_df['num_spaces'] != 0]
+
+        # Apply conference filtering
+        if conference_options:
+
+            columns_to_show.remove("date")
+            columns_to_show.remove("arxiv_id")
+
+            if 'conference_name' not in columns_to_show:
+                columns_to_show.append('conference_name')
+
+            if 'proceedings' not in columns_to_show:
+                columns_to_show.append('proceedings')
+
+            if 'type' not in columns_to_show:
+                columns_to_show.append('type')
+
+            if 'id' not in columns_to_show:
+                columns_to_show.append('id')
+
+            # If "In proceedings" is selected
+            if "In proceedings" in conference_options:
+                # Filter rows where 'conference_name' is not None, not NaN, and not empty
+                filtered_df = filtered_df[
+                    filtered_df['conference_name'].notna() & (filtered_df['conference_name'] != "")
+                    ]
+
+            # For other conference options
+            other_conferences = [conf for conf in conference_options if conf != "In proceedings"]
+            if other_conferences:
+                # Initialize filter series
+                conference_filter = pd.Series(False, index=filtered_df.index)
+                for conference in other_conferences:
+                    # Filter rows where 'conference_name' contains the conference string (case-insensitive)
+                    conference_filter |= (
+                            filtered_df['conference_name'].notna() &
+                            (filtered_df['conference_name'].str.lower() == conference.lower())
+                    )
+                filtered_df = filtered_df[conference_filter]
+
+        # Prettify the DataFrame
+        filtered_df = self.prettify(filtered_df)
+
+        # Ensure columns are ordered according to COLUMNS_ORDER_PAPER_PAGE
+        columns_in_order: List[str] = [col for col in PaperCentral.COLUMNS_ORDER_PAPER_PAGE if col in columns_to_show]
+
+        # Select and reorder the columns
+        filtered_df = filtered_df[columns_in_order]
+
+        # Rename columns for display
+        filtered_df = self.rename_columns_for_display(filtered_df)
+
+        # Get the corresponding data types for the columns
+        new_datatypes: List[str] = [
+            PaperCentral.DATATYPES.get(self._get_original_column_name(col), 'str') for col in filtered_df.columns
+        ]
+
+        # Return an update object to modify the Dataframe component
+        return gr.update(value=filtered_df, datatype=new_datatypes)
+
+    def _get_original_column_name(self, display_column_name: str) -> str:
+        """
+        Retrieve the original column name given a display column name.
+
+        Args:
+            display_column_name (str): The display name of the column.
+
+        Returns:
+            str: The original name of the column.
+        """
+        inverse_map = {v: k for k, v in self.COLUMN_RENAME_MAP.items()}
+        return inverse_map.get(display_column_name, display_column_name)

requirements.txt

@@ -0,0 +1,3 @@
+gradio
+gradio_calendar
+datasets

style.css

@@ -0,0 +1,23 @@
+h1 {
+  text-align: center;
+  display: block;
+}
+
+body a,
+.contain a,
+#table a {
+  background-color: transparent;
+  color: #58a6ff;
+  text-decoration: none;
+}
+
+body a:active,
+body a:hover {
+  outline-width: 0;
+}
+
+body a:hover {
+  text-decoration: underline;
+}
+
+

utils.py

@@ -0,0 +1,16 @@
+import re
+from datasets import load_dataset
+
+
+def arxiv_remove_version_suffix(arxiv_id):
+    # Use regex to remove version suffix (e.g., v1, v2, etc.) if present
+    cleaned_id = re.sub(r'v\d+$', '', arxiv_id)
+    return cleaned_id
+
+
+# Load datasets
+def load_and_process(dataset_name):
+    data = load_dataset(dataset_name, split="train").to_pandas()
+    if 'arxiv_id' in data.columns:
+        data['arxiv_id'] = data['arxiv_id'].apply(arxiv_remove_version_suffix)
+    return data