app.py

#!/usr/bin/env python

import gradio as gr
import polars as pl

from app_pr import demo as demo_pr
from table import df_orig

DESCRIPTION = "# ICLR 2025"

TUTORIAL = """\
#### Claiming Authorship for Papers on arXiv

If your ICLR 2025 paper is available on arXiv and listed in the table below, you can claim authorship by following these steps:

1. Find your paper in the table.
2. Click the link to the paper page in the table.
3. On that page, click your name.
4. Click **"Claim authorship"**.
    - You'll be redirected to the *Papers* section of your Settings.
5. Confirm the request on the redirected page.

The admin team will review your request shortly.
Once confirmed, your paper page will be marked as verified, and you'll be able to add a project page and a GitHub repository.

If you need further help, check out the [guide here](https://huggingface.co/docs/hub/paper-pages).


#### Updating Missing or Incorrect Information in the Table

If you notice any missing or incorrect information in the table, feel free to submit a PR via the "Open PR" page, which you can find at the top right of this page.
"""

# TODO: remove this once https://github.com/gradio-app/gradio/issues/10916 https://github.com/gradio-app/gradio/issues/11001 https://github.com/gradio-app/gradio/issues/11002 are fixed  # noqa: TD002, FIX002
NOTE = """\
Note: Sorting by upvotes or comments may not work correctly due to a known bug in Gradio.
"""


df_main = df_orig.select(
    "title",
    "authors_str",
    "openreview_md",
    "type",
    "paper_page_md",
    "upvotes",
    "num_comments",
    "project_page_md",
    "github_md",
    "Spaces",
    "Models",
    "Datasets",
    "claimed",
)

df_main = df_main.rename(
    {
        "title": "Title",
        "authors_str": "Authors",
        "openreview_md": "OpenReview",
        "type": "Type",
        "paper_page_md": "Paper page",
        "upvotes": "👍",
        "num_comments": "💬",
        "project_page_md": "Project page",
        "github_md": "GitHub",
    }
)

COLUMN_INFO = {
    "Title": ("str", "40%"),
    "Authors": ("str", "20%"),
    "Type": ("str", None),
    "Paper page": ("markdown", "135px"),
    "👍": ("number", "50px"),
    "💬": ("number", "50px"),
    "OpenReview": ("markdown", None),
    "Project page": ("markdown", None),
    "GitHub": ("markdown", None),
    "Spaces": ("markdown", None),
    "Models": ("markdown", None),
    "Datasets": ("markdown", None),
    "claimed": ("markdown", None),
}


DEFAULT_COLUMNS = [
    "Title",
    "Type",
    "Paper page",
    "👍",
    "💬",
    "OpenReview",
    "Project page",
    "GitHub",
    "Spaces",
    "Models",
]


def update_num_papers(df: pl.DataFrame) -> str:
    if "claimed" in df.columns:
        return f"{len(df)} / {len(df_main)} ({df.select(pl.col('claimed').str.contains('✅').sum()).item()} claimed)"
    return f"{len(df)} / {len(df_main)}"


def update_df(
    title_search_query: str,
    presentation_type: str,
    column_names: list[str],
    case_insensitive: bool = True,
) -> gr.Dataframe:
    df = df_main.clone()
    column_names = ["Title", *column_names]

    if title_search_query:
        if case_insensitive:
            title_search_query = f"(?i){title_search_query}"
        try:
            df = df.filter(pl.col("Title").str.contains(title_search_query))
        except pl.exceptions.ComputeError as e:
            raise gr.Error(str(e)) from e
    if presentation_type != "(ALL)":
        df = df.filter(pl.col("Type").str.contains(presentation_type))

    sorted_column_names = [col for col in COLUMN_INFO if col in column_names]
    df = df.select(sorted_column_names)
    return gr.Dataframe(
        value=df,
        datatype=[COLUMN_INFO[col][0] for col in sorted_column_names],
        column_widths=[COLUMN_INFO[col][1] for col in sorted_column_names],
    )


with gr.Blocks(css_paths="style.css") as demo:
    gr.Markdown(DESCRIPTION)
    with gr.Accordion(label="Tutorial", open=True):
        gr.Markdown(TUTORIAL)
    with gr.Group():
        search_title = gr.Textbox(label="Search title")
        presentation_type = gr.Radio(
            label="Presentation Type",
            choices=["(ALL)", "Oral", "Spotlight", "Poster"],
            value="(ALL)",
        )
        column_names = gr.CheckboxGroup(
            label="Columns",
            choices=[col for col in COLUMN_INFO if col != "Title"],
            value=[col for col in DEFAULT_COLUMNS if col != "Title"],
        )

    num_papers = gr.Textbox(label="Number of papers", value=update_num_papers(df_orig), interactive=False)

    gr.Markdown(NOTE)
    df = gr.Dataframe(
        value=df_main,
        datatype=list(COLUMN_INFO.values()),
        type="polars",
        row_count=(0, "dynamic"),
        show_row_numbers=True,
        interactive=False,
        max_height=1000,
        elem_id="table",
        column_widths=[COLUMN_INFO[col][1] for col in COLUMN_INFO],
    )

    inputs = [
        search_title,
        presentation_type,
        column_names,
    ]
    gr.on(
        triggers=[
            search_title.submit,
            presentation_type.input,
            column_names.input,
        ],
        fn=update_df,
        inputs=inputs,
        outputs=df,
        api_name=False,
    ).then(
        fn=update_num_papers,
        inputs=df,
        outputs=num_papers,
        queue=False,
        api_name=False,
    )
    demo.load(
        fn=update_df,
        inputs=inputs,
        outputs=df,
        api_name=False,
    ).then(
        fn=update_num_papers,
        inputs=df,
        outputs=num_papers,
        queue=False,
        api_name=False,
    )


with demo.route("Open PR"):
    demo_pr.render()


if __name__ == "__main__":
    demo.queue(api_open=False).launch(show_api=False)