Update app.py

app.py

@@ -1,251 +1,183 @@
-#!/usr/bin/env python
-
-import datetime
-import pandas as pd
-import tqdm.auto
-from apscheduler.schedulers.background import BackgroundScheduler
-from huggingface_hub import HfApi
-
 import gradio as gr
-import datasets  # Ensure the datasets library is imported
-
-from datetime import timezone
-import atexit  # To gracefully shut down the scheduler
-import logging  # For logging purposes
-
-# --- Logging Configuration ---
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-# --- Data Loading and Processing ---
-
-api = HfApi()
-
-def get_df() -> pd.DataFrame:
-    """
-    Loads and merges the papers and stats datasets, preprocesses the data by removing unnecessary columns,
-    and adds a 'paper_page' link for each paper.
-    """
-    try:
-        # Load datasets
-        logger.info("Loading 'daily-papers' dataset.")
-        df_papers = datasets.load_dataset("hysts-bot-data/daily-papers", split="train").to_pandas()
-        logger.info("Loading 'daily-papers-stats' dataset.")
-        df_stats = datasets.load_dataset("hysts-bot-data/daily-papers-stats", split="train").to_pandas()
-        
-        # Merge datasets on 'arxiv_id'
-        logger.info("Merging datasets on 'arxiv_id'.")
-        df = pd.merge(left=df_papers, right=df_stats, on="arxiv_id", suffixes=('_papers', '_stats'))
-        
-        # Reverse the DataFrame to have the latest papers first
-        df = df[::-1].reset_index(drop=True)
-        
-        # Ensure 'date' is in datetime format and handle missing dates
-        logger.info("Processing 'date' column.")
-        df["date"] = pd.to_datetime(df["date"], errors='coerce')
-        df["date"] = df["date"].dt.strftime("%Y-%m-%d").fillna(datetime.datetime.now(timezone.utc).strftime("%Y-%m-%d"))
-        
-        # Prepare the DataFrame by removing 'abstract'
-        logger.info("Removing 'abstract' column if present.")
-        if 'abstract' in df.columns:
-            df = df.drop(columns=['abstract'])
-        
-        # Add 'paper_page' links
-        logger.info("Adding 'paper_page' links.")
-        df["paper_page"] = df["arxiv_id"].apply(lambda x: f"https://huggingface.co/papers/{x}")
-        
-        # Verify that 'date' column exists
-        if 'date' not in df.columns:
-            logger.error("'date' column is missing from the DataFrame. Filling with current date.")
-            df["date"] = datetime.datetime.now(timezone.utc).strftime("%Y-%m-%d")
-        
-        logger.info("DataFrame preparation complete.")
-        return df
-    except Exception as e:
-        logger.error(f"Error in get_df: {e}")
-        return pd.DataFrame()  # Return empty DataFrame on error
-
-
-class Prettifier:
-    """
-    Converts raw DataFrame rows into a prettified format suitable for display.
-    """
-    REQUIRED_COLUMNS = ["arxiv_id", "date_display", "date", "paper_page", "title", "github", "👍", "💬"]
-    
-    @staticmethod
-    def get_github_link(link: str) -> str:
-        if not link:
-            return ""
-        return Prettifier.create_link("github", link)
-
-    @staticmethod
-    def create_link(text: str, url: str) -> str:
-        return f'<a href="{url}" target="_blank">{text}</a>'
-
-    def __call__(self, df: pd.DataFrame) -> pd.DataFrame:
-        new_rows = []
-        for _, row in df.iterrows():
-            # Handle date_display as a clickable link
-            date_display = Prettifier.create_link(row.get("date", ""), f"https://huggingface.co/papers?date={row.get('date', '')}")
-            
-            new_row = {
-                "arxiv_id": row.get("arxiv_id", ""),  # Include arxiv_id
-                "date_display": date_display,         # For display
-                "date": row.get("date", datetime.datetime.now(timezone.utc).strftime("%Y-%m-%d")),  # For internal calculations
-                "paper_page": Prettifier.create_link(row.get("arxiv_id", ""), row.get("paper_page", "#")),
-                "title": row.get("title", "No title"),
-                "github": Prettifier.get_github_link(row.get("github", "")),
-                "👍": row.get("upvotes", 0),
-                "💬": row.get("num_comments", 0),
-            }
-            new_rows.append(new_row)
-        
-        # If no rows, return empty DataFrame with required columns to prevent KeyError
-        if not new_rows:
-            return pd.DataFrame(columns=self.REQUIRED_COLUMNS)
-        
-        return pd.DataFrame(new_rows)
-
-
-class PaperList:
-    """
-    Manages the list of papers.
-    """
-    COLUMN_INFO = [
-        ["arxiv_id", "str"],          # Added arxiv_id
-        ["date_display", "markdown"], # For display
-        ["date", "str"],              # For internal use
-        ["paper_page", "markdown"],
-        ["title", "str"],
-        ["github", "markdown"],
-        ["👍", "number"],
-        ["💬", "number"],
-    ]
-
-    def __init__(self, df: pd.DataFrame):
-        self.df_raw = df
-        self._prettifier = Prettifier()
-        self.df_prettified = self._prettifier(df).loc[:, self.column_names]
-
-    @property
-    def column_names(self):
-        return [col[0] for col in self.COLUMN_INFO]
-
-    @property
-    def column_datatype(self):
-        return [col[1] for col in self.COLUMN_INFO]
-
-    def get_prettified_df(self) -> pd.DataFrame:
-        """
-        Returns the prettified DataFrame.
-        """
-        return self.df_prettified
+import requests
+from datetime import datetime, timezone
+from concurrent.futures import ThreadPoolExecutor, as_completed
 
-
-# --- Sorting and Pagination Management ---
+API_URL = "https://huggingface.co/api/daily_papers"
+REPOS_API_URL_TEMPLATE = "https://huggingface.co/api/arxiv/{arxiv_id}/repos"
 
 class PaperManager:
-    """
-    Manages sorting and pagination for the list of papers.
-    """
-    def __init__(self, paper_list: PaperList, papers_per_page=30):
-        self.paper_list = paper_list
+    def __init__(self, papers_per_page=30):
         self.papers_per_page = papers_per_page
-        self.sort_method = "hot"              # Default sort method
-        self.sort_papers()
-        # 'current_page' and 'total_pages' are set in 'sort_papers()'
+        self.current_page = 1
+        self.papers = []
+        self.total_pages = 1
+        self.sort_method = "hot"  # Default sort method
+        self.raw_papers = []  # To store fetched data
 
-    def calculate_score(self, row):
+    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 = row.get('upvotes', 0)  # Corrected from '👍' to 'upvotes'
-        date_str = row.get('date', datetime.datetime.now(timezone.utc).strftime("%Y-%m-%d"))
+        upvotes = paper.get('paper', {}).get('upvotes', 0)
+        published_at_str = paper.get('publishedAt', datetime.now(timezone.utc).isoformat())
         try:
-            published_time = datetime.datetime.strptime(date_str, "%Y-%m-%d").replace(tzinfo=timezone.utc)
+            published_time = 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(timezone.utc)
-
-        time_diff = datetime.datetime.now(timezone.utc) - published_time
+            published_time = datetime.now(timezone.utc)
+        
+        time_diff = datetime.now(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) if (time_diff_hours + 2) > 0 else 0
+        score = upvotes / ((time_diff_hours + 2) ** 1.5)
         return score
 
-    def sort_papers(self):
+    def fetch_repos_counts(self, arxiv_id):
         """
-        Sorts the papers based on the current sort method.
+        Fetch the repositories (models, datasets, Spaces) associated with a given arxiv_id.
+        Returns a dictionary with counts for each type.
         """
-        df = self.paper_list.df_raw.copy()
+        try:
+            response = requests.get(REPOS_API_URL_TEMPLATE.format(arxiv_id=arxiv_id))
+            response.raise_for_status()
+            data = response.json()
+            
+            counts = {'models': 0, 'datasets': 0, 'spaces': 0}
+            for repo in data:
+                repo_type = repo.get('type', '').lower()
+                if repo_type == 'model':
+                    counts['models'] += 1
+                elif repo_type == 'dataset':
+                    counts['datasets'] += 1
+                elif repo_type == 'space':
+                    counts['spaces'] += 1
+            return counts
+        except requests.RequestException as e:
+            print(f"Error fetching repos for arxiv_id {arxiv_id}: {e}")
+            return {'models': 0, 'datasets': 0, 'spaces': 0}
+        except Exception as e:
+            print(f"Unexpected error fetching repos for arxiv_id {arxiv_id}: {e}")
+            return {'models': 0, 'datasets': 0, 'spaces': 0}
+
+    def fetch_papers(self):
+        try:
+            response = requests.get(f"{API_URL}?limit=100")
+            response.raise_for_status()
+            data = response.json()
+
+            if not data:
+                print("No data received from API.")
+                return False
+
+            # Debug: Print keys of the first paper
+            print("Keys in the first paper:", data[0].keys())
+
+            self.raw_papers = data  # Store raw data
+
+            # Fetch repos counts concurrently
+            with ThreadPoolExecutor(max_workers=20) as executor:
+                future_to_paper = {}
+                for paper in self.raw_papers:
+                    arxiv_id = paper.get('paper', {}).get('arxiv_id', '')
+                    if arxiv_id:
+                        future = executor.submit(self.fetch_repos_counts, arxiv_id)
+                        future_to_paper[future] = paper
+                    else:
+                        # If no arxiv_id, set counts to zero
+                        paper['models'] = 0
+                        paper['datasets'] = 0
+                        paper['spaces'] = 0
+
+                for future in as_completed(future_to_paper):
+                    paper = future_to_paper[future]
+                    counts = future.result()
+                    paper['models'] = counts['models']
+                    paper['datasets'] = counts['datasets']
+                    paper['spaces'] = counts['spaces']
+
+            self.sort_papers()
+            self.total_pages = max((len(self.papers) + self.papers_per_page - 1) // self.papers_per_page, 1)
+            self.current_page = 1
+            return True
+        except requests.RequestException as e:
+            print(f"Error fetching papers: {e}")
+            return False
+        except Exception as e:
+            print(f"Unexpected error: {e}")
+            return False
 
+    def sort_papers(self):
         if self.sort_method == "hot":
-            if not df.empty:
-                df = df.drop(columns=['score'], errors='ignore')  # Remove existing 'score' column if present
-                df['score'] = df.apply(self.calculate_score, axis=1)
-                df_sorted = df.sort_values(by='score', ascending=False).drop(columns=['score'])
-            else:
-                df_sorted = df
+            self.papers = sorted(
+                self.raw_papers,
+                key=lambda x: self.calculate_score(x),
+                reverse=True
+            )
         elif self.sort_method == "new":
-            df_sorted = df.sort_values(by='date', ascending=False)  # Sort by 'date'
+            self.papers = sorted(
+                self.raw_papers,
+                key=lambda x: x.get('published_at', ''),
+                reverse=True
+            )
+        elif self.sort_method == "most_models":
+            self.papers = sorted(
+                self.raw_papers,
+                key=lambda x: x.get('models', 0),
+                reverse=True
+            )
+        elif self.sort_method == "most_datasets":
+            self.papers = sorted(
+                self.raw_papers,
+                key=lambda x: x.get('datasets', 0),
+                reverse=True
+            )
+        elif self.sort_method == "most_spaces":
+            self.papers = sorted(
+                self.raw_papers,
+                key=lambda x: x.get('spaces', 0),
+                reverse=True
+            )
         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
-        logger.info(f"Papers sorted by {self.sort_method}. Total pages: {self.total_pages}")
-
-    def set_sort_method(self, method, time_frame=None):
-        """
-        Sets the sort method ('hot', 'new') and re-sorts the papers.
-        """
-        if method not in ["hot", "new"]:
+            # Default to hot if unknown sort method
+            self.papers = sorted(
+                self.raw_papers,
+                key=lambda x: self.calculate_score(x),
+                reverse=True
+            )
+
+    def set_sort_method(self, method):
+        valid_methods = ["hot", "new", "most_models", "most_datasets", "most_spaces"]
+        if method not in valid_methods:
             method = "hot"
-        logger.info(f"Setting sort method to: {method}")
+        print(f"Setting sort method to: {method}")
         self.sort_method = method
         self.sort_papers()
+        self.current_page = 1
         return True  # Assume success
 
-    def get_current_page_papers(self) -> str:
-        """
-        Retrieves the HTML string of the current page's papers.
-        """
-        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]
-
-        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):
-        """
-        Formats a single paper entry into HTML.
-        """
-        title = row.get('title', 'No title')
-        paper_id = row.get('arxiv_id', '')
+    def format_paper(self, paper, rank):
+        title = paper.get('title', 'No title')
+        paper_id = paper.get('paper', {}).get('id', '')
         url = f"https://huggingface.co/papers/{paper_id}"
-        upvotes = row.get('👍', 0)
-        comments = row.get('💬', 0)
-        date_str = row.get('date', datetime.datetime.now(timezone.utc).strftime("%Y-%m-%d"))
+        authors = ', '.join([author.get('name', '') for author in paper.get('paper', {}).get('authors', [])]) or 'Unknown'
+        upvotes = paper.get('paper', {}).get('upvotes', 0)
+        comments = paper.get('numComments', 0)
+        published_time_str = paper.get('published_at', datetime.now(timezone.utc).isoformat())
         try:
-            published_time = datetime.datetime.strptime(date_str, "%Y-%m-%d").replace(tzinfo=timezone.utc)
+            published_time = datetime.fromisoformat(published_time_str.replace('Z', '+00:00'))
         except ValueError:
-            published_time = datetime.datetime.now(timezone.utc)
-        time_diff = datetime.datetime.now(timezone.utc) - published_time
+            published_time = datetime.now(timezone.utc)
+        time_diff = datetime.now(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"
 
+        models = paper.get('models', 0)
+        datasets = paper.get('datasets', 0)
+        spaces = paper.get('spaces', 0)
+
         return f"""
         <tr class="athing">
             <td align="right" valign="top" class="title"><span class="rank">{rank}.</span></td>
@@ -257,126 +189,64 @@ class PaperManager:
             <td colspan="1"></td>
             <td class="subtext">
                 <span class="score">{upvotes} upvotes</span><br>
-                {time_ago} | <a href="#">{comments} comments</a>
+                authors: {authors} | {time_ago} | <a href="#">{comments} comments</a><br>
+                Models: {models} | Datasets: {datasets} | Spaces: {spaces}
             </td>
         </tr>
         <tr style="height:5px"></tr>
         """
 
-    def next_page(self) -> str:
-        """
-        Navigates to the next page if possible.
+    def render_papers(self):
+        start = (self.current_page - 1) * self.papers_per_page
+        end = start + self.papers_per_page
+        current_papers = self.papers[start:end]
+
+        if not current_papers:
+            return "<div class='no-papers'>No papers available for this page.</div>"
+
+        papers_html = "".join([self.format_paper(paper, idx + start + 1) for idx, paper in enumerate(current_papers)])
+        return f"""
+        <table border="0" cellpadding="0" cellspacing="0" class="itemlist">
+            {papers_html}
+        </table>
         """
+
+    def next_page(self):
         if self.current_page < self.total_pages:
             self.current_page += 1
-            logger.info(f"Navigated to page {self.current_page}.")
-        else:
-            logger.info("Already on the last page.")
-        return self.get_current_page_papers()
+        return self.render_papers()
 
-    def prev_page(self) -> str:
-        """
-        Navigates to the previous page if possible.
-        """
+    def prev_page(self):
         if self.current_page > 1:
             self.current_page -= 1
-            logger.info(f"Navigated to page {self.current_page}.")
-        else:
-            logger.info("Already on the first page.")
-        return self.get_current_page_papers()
+        return self.render_papers()
 
-    def refresh(self) -> str:
-        """
-        Refreshes the current list of papers.
-        """
-        logger.info("Refreshing papers.")
-        self.sort_papers()
-        return self.get_current_page_papers()
-
-
-# Initialize PaperList and PaperManager
-def initialize_paper_manager() -> str:
-    """
-    Initializes the PaperList and PaperManager with the current DataFrame.
-    """
-    df = get_df()
-    if df.empty:
-        logger.warning("Initialized with an empty DataFrame.")
-    paper_list = PaperList(df)
-    manager = PaperManager(paper_list)
-    logger.info("PaperManager initialized.")
-    return manager.get_current_page_papers()  # Return HTML string instead of the manager object
-
-
-paper_manager = None  # Initialize globally
-
-def setup_paper_manager():
-    """
-    Sets up the global PaperManager instance.
-    """
-    global paper_manager
-    df = get_df()
-    paper_list = PaperList(df)
-    paper_manager = PaperManager(paper_list)
-    logger.info("PaperManager setup complete.")
-
-
-# Initialize PaperManager at the start
-setup_paper_manager()
-
-
-def update_paper_manager() -> str:
-    """
-    Updates the global PaperManager with the latest DataFrame.
-    """
-    global paper_manager
-    logger.info("Updating PaperManager with latest data.")
-    df = get_df()
-    if df.empty:
-        logger.warning("DataFrame is empty. Skipping update.")
-        return paper_manager.get_current_page_papers()
-    paper_manager.paper_list = PaperList(df)
-    paper_manager.sort_papers()
-    logger.info("PaperManager updated successfully.")
-    return paper_manager.get_current_page_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()
-logger.info("BackgroundScheduler started.")
-
-# Ensure the scheduler shuts down gracefully on exit
-atexit.register(lambda: scheduler_data.shutdown())
-logger.info("Scheduler shutdown registered.")
-
-
-# --- Gradio Interface Functions ---
-
-def change_sort_method_ui(method: str) -> str:
-    """
-    Changes the sort method based on user selection.
-    """
-    logger.info(f"Changing sort method to: {method}")
-    success = paper_manager.set_sort_method(method.lower())
-    if success:
-        return paper_manager.get_current_page_papers()
-    else:
-        return "<div class='no-papers'>Failed to change sort method.</div>"
+paper_manager = PaperManager()
 
+def initialize_app():
+    if paper_manager.fetch_papers():
+        return paper_manager.render_papers()
+    else:
+        return "<div class='no-papers'>Failed to fetch papers. Please try again later.</div>"
 
-# --- CSS Styling ---
+def refresh_papers():
+    if paper_manager.fetch_papers():
+        return paper_manager.render_papers()
+    else:
+        return "<div class='no-papers'>Failed to refresh papers. Please try again later.</div>"
+
+def change_sort_method(method):
+    method_lower = method.lower().replace(" ", "_")
+    print(f"Changing sort method to: {method_lower}")
+    if paper_manager.set_sort_method(method_lower):
+        print("Sort method set successfully.")
+        return paper_manager.render_papers()
+    else:
+        print("Failed to set sort method.")
+        return "<div class='no-papers'>Failed to sort papers. Please try again later.</div>"
 
 css = """
-/* Hacker News-like CSS */
-
+/* Existing CSS remains unchanged */
 body {
     background-color: white;
     font-family: Verdana, Geneva, sans-serif;
@@ -415,20 +285,6 @@ table {
     text-decoration: none;
 }
 
-.header-table .sort-buttons button {
-    background: none;
-    border: none;
-    color: #0000ff;
-    cursor: pointer;
-    font-size: 14pt;
-    text-decoration: underline;
-    padding: 0 10px;
-}
-
-.header-table .sort-buttons button:hover {
-    color: #551A8B;
-}
-
 .itemlist .athing {
     background-color: #f6f6ef;
 }
@@ -466,11 +322,6 @@ table {
         font-size: 12pt;
     }
 
-    .sort-buttons button {
-        font-size: 12pt;
-        padding: 0 5px;
-    }
-
     .storylink {
         font-size: 9pt;
     }
@@ -503,14 +354,6 @@ table {
         color: black;
     }
 
-    .header-table .sort-buttons button {
-        color: #add8e6;
-    }
-
-    .header-table .sort-buttons button:hover {
-        color: #9370db;
-    }
-
     .itemlist .athing {
         background-color: #1e1e1e;
     }
@@ -533,9 +376,6 @@ table {
 }
 """
 
-
-# --- Initialize Gradio Blocks ---
-
 demo = gr.Blocks(css=css)
 
 with demo:
@@ -548,72 +388,46 @@ with demo:
 
             Once your paper is submitted, it will automatically appear in this demo.
             """)
-        
-        # Hacker News-like Header with "Hot" and "New" sort options
+        # Header without Refresh Button
         with gr.Row():
-            # Left side: Site title
-            gr.Markdown("""
-                <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" class="sort-buttons">
-                            <!-- Removed custom HTML buttons -->
-                        </td>
-                    </tr>
-                </table>
-            """, show_label=False)
-            # Right side: Gradio Buttons for "Hot" and "New"
-            with gr.Column(elem_classes=["sort-buttons"]):
-                hot_button = gr.Button("Hot", elem_id="hot_button")
-                new_button = gr.Button("New", elem_id="new_button")
-        
+            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>
+                </tr>
+            </table>
+            """)
+        # Sort Options
+        with gr.Row():
+            sort_radio = gr.Radio(
+                choices=["Hot", "New", "Most Models", "Most Datasets", "Most Spaces"],
+                value="Hot",
+                label="Sort By",
+                interactive=True
+            )
         # Paper list
         paper_list = gr.HTML()
-        
         # Navigation Buttons
         with gr.Row():
             prev_button = gr.Button("Prev")
             next_button = gr.Button("Next")
-    
+
     # Load papers on app start
-    demo.load(
-        fn=lambda: paper_manager.get_current_page_papers(),
-        outputs=[paper_list]
-    )
-    
+    demo.load(initialize_app, outputs=[paper_list])
+
     # Button clicks for pagination
-    prev_button.click(
-        fn=lambda: paper_manager.prev_page(),
-        inputs=[],
-        outputs=[paper_list]
-    )
-    next_button.click(
-        fn=lambda: paper_manager.next_page(),
-        inputs=[],
-        outputs=[paper_list]
-    )
-    
-    # Gradio Buttons trigger sort methods directly
-    hot_button.click(
-        fn=lambda: change_sort_method_ui("hot"),
-        inputs=[],
-        outputs=[paper_list]
-    )
-    new_button.click(
-        fn=lambda: change_sort_method_ui("new"),
-        inputs=[],
+    prev_button.click(paper_manager.prev_page, outputs=[paper_list])
+    next_button.click(paper_manager.next_page, outputs=[paper_list])
+
+    # Sort option change
+    sort_radio.change(
+        fn=change_sort_method,
+        inputs=[sort_radio],
         outputs=[paper_list]
     )
-    
-    # Footer - Removed as per request
-    # Removed the footer markdown section
-
-
-# --- Launch the App ---
 
-if __name__ == "__main__":
-    demo.launch()
+demo.launch()