Update app.py

app.py

@@ -142,211 +142,95 @@ def load_query(request: gr.Request):
     query = request.query_params.get("query") or ""
     return query
 
+leaderboard_df = filter_models(
+    df=leaderboard_df,
+    type_query=[t.to_str(" : ") for t in ModelType],
+    size_query=list(NUMERIC_INTERVALS.keys()),
+    precision_query=[i.value.name for i in Precision],
+    show_deleted=False,
+)
 
-demo = gr.Blocks(css=custom_css)
-with demo:
-    gr.HTML(TITLE)
-    gr.Markdown(INTRODUCTION_TEXT, elem_classes="markdown-text")
-
-    with gr.Tabs(elem_classes="tab-buttons") as tabs:
-        with gr.TabItem("Hallucinations Benchmark",
-                        elem_id="llm-benchmark-tab-table",
-                        id=0):
-            with gr.Row():
-                with gr.Column():
-                    with gr.Row():
-                        search_bar = gr.Textbox(placeholder=" 🔍 Model search (separate multiple queries with `;`)",
-                                                show_label=False,
-                                                elem_id="search-bar")
-                    with gr.Row():
-                        shown_columns = gr.CheckboxGroup(
-                            choices=[
-                                c.name
-                                for c in fields(AutoEvalColumn)
-                                if not c.hidden and not c.never_hidden and not c.dummy
-                            ],
-                            value=[
-                                c.name
-                                for c in fields(AutoEvalColumn)
-                                if c.displayed_by_default and not c.hidden and not c.never_hidden
-                            ],
-                            label="Select columns to show",
-                            elem_id="column-select",
-                            interactive=True)
-
-                with gr.Column(min_width=320):
-                    filter_columns_type = gr.CheckboxGroup(
-                        label="Model types",
-                        choices=[t.to_str() for t in ModelType],
-                        value=[t.to_str() for t in ModelType],
-                        interactive=True,
-                        elem_id="filter-columns-type")
-
-                    filter_columns_precision = gr.CheckboxGroup(
-                        label="Precision",
-                        choices=[i.value.name for i in Precision],
-                        value=[i.value.name for i in Precision],
-                        interactive=True,
-                        elem_id="filter-columns-precision")
-
-                    filter_columns_size = gr.CheckboxGroup(
-                        label="Model sizes (in billions of parameters)",
-                        choices=list(NUMERIC_INTERVALS.keys()),
-                        value=list(NUMERIC_INTERVALS.keys()),
-                        interactive=True,
-                        elem_id="filter-columns-size")
-
-            leaderboard_table = gr.components.Dataframe(
-                value=leaderboard_df[
-                    [c.name for c in fields(AutoEvalColumn) if c.never_hidden] + shown_columns.value + [AutoEvalColumn.dummy.name]
-                ] if leaderboard_df.empty is False else leaderboard_df,
-                headers=[c.name for c in fields(AutoEvalColumn) if c.never_hidden] + shown_columns.value,
-                datatype=TYPES,
-                elem_id="leaderboard-table",
-                interactive=False,
-                visible=True)
-
-            # Dummy leaderboard for handling the case when the user uses backspace key
-            hidden_leaderboard_table_for_search = gr.components.Dataframe(
-                value=original_df[COLS] if original_df.empty is False else original_df,
-                headers=COLS,
-                datatype=TYPES,
-                visible=False)
-
-            search_bar.submit(
-                update_table,
-                [
-                    hidden_leaderboard_table_for_search,
-                    shown_columns,
-                    filter_columns_type,
-                    filter_columns_precision,
-                    filter_columns_size,
-                    search_bar,
-                ],
-                leaderboard_table)
-
-            # Check query parameter once at startup and update search bar
-            demo.load(load_query, inputs=[], outputs=[search_bar])
-
-            for selector in [shown_columns, filter_columns_type, filter_columns_precision, filter_columns_size]:
-                selector.change(
-                    update_table,
-                    [
-                        hidden_leaderboard_table_for_search,
-                        shown_columns,
-                        filter_columns_type,
-                        filter_columns_precision,
-                        filter_columns_size,
-                        search_bar,
-                    ],
-                    leaderboard_table,
-                    queue=True)
-
-        with gr.TabItem("📝 About", elem_id="llm-benchmark-tab-table", id=2):
-            gr.Markdown(LLM_BENCHMARKS_TEXT, elem_classes="markdown-text")
-            print(f'dataset df columns: {list(dataset_df.columns)}')
-            dataset_table = gr.components.Dataframe(
-                value=dataset_df,
-                headers=list(dataset_df.columns),
-                datatype=['str', 'markdown', 'str', 'str', 'str'],
-                elem_id="dataset-table",
-                interactive=False,
-                visible=True,
-                column_widths=["15%", "20%"]
-            )
-            gr.Markdown(LLM_BENCHMARKS_DETAILS, elem_classes="markdown-text")
-            gr.Markdown(FAQ_TEXT, elem_classes="markdown-text")
-
-        with gr.TabItem("Submit a model ", elem_id="llm-benchmark-tab-table", id=3):
-            with gr.Column():
-                with gr.Row():
-                    gr.Markdown(EVALUATION_QUEUE_TEXT, elem_classes="markdown-text")
-
-                with gr.Column():
-                    with gr.Accordion(f"✅ Finished Evaluations ({len(finished_eval_queue_df)})", open=False):
-                        with gr.Row():
-                            finished_eval_table = gr.components.Dataframe(
-                                value=finished_eval_queue_df,
-                                headers=EVAL_COLS,
-                                datatype=EVAL_TYPES,
-                                row_count=5)
-
-                    with gr.Accordion(f"🔄 Running Evaluation Queue ({len(running_eval_queue_df)})", open=False):
-                        with gr.Row():
-                            running_eval_table = gr.components.Dataframe(
-                                value=running_eval_queue_df,
-                                headers=EVAL_COLS,
-                                datatype=EVAL_TYPES,
-                                row_count=5)
-
-                    with gr.Accordion(f"⏳ Scheduled Evaluation Queue ({len(pending_eval_queue_df)})", open=False):
-                        with gr.Row():
-                            pending_eval_table = gr.components.Dataframe(
-                                value=pending_eval_queue_df,
-                                headers=EVAL_COLS,
-                                datatype=EVAL_TYPES,
-                                row_count=5)
-
-            with gr.Row():
-                gr.Markdown("# Submit your model here", elem_classes="markdown-text")
-
-            with gr.Row():
-                with gr.Column():
-                    model_name_textbox = gr.Textbox(label="Model name")
-                    revision_name_textbox = gr.Textbox(label="Revision commit", placeholder="main")
-                    private = gr.Checkbox(False, label="Private", visible=not IS_PUBLIC)
-                    model_type = gr.Dropdown(
-                        choices=[t.to_str(" : ") for t in ModelType if t != ModelType.Unknown],
-                        label="Model type",
-                        multiselect=False,
-                        value=None,
-                        interactive=True)
-
-                with gr.Column():
-                    precision = gr.Dropdown(
-                        choices=[i.value.name for i in Precision if i != Precision.Unknown],
-                        label="Precision",
-                        multiselect=False,
-                        value="float32",
-                        interactive=True)
-
-                    weight_type = gr.Dropdown(
-                        choices=[i.value.name for i in WeightType],
-                        label="Weights type",
-                        multiselect=False,
-                        value="Original",
-                        interactive=True)
-
-                    base_model_name_textbox = gr.Textbox(label="Base model (for delta or adapter weights)")
-
-            submit_button = gr.Button("Submit Eval")
-            submission_result = gr.Markdown()
-            submit_button.click(
-                add_new_eval,
-                [
-                    model_name_textbox,
-                    base_model_name_textbox,
-                    revision_name_textbox,
-                    precision,
-                    private,
-                    weight_type,
-                    model_type,
-                ],
-                submission_result)
-
-    with gr.Row():
-        with gr.Accordion("Citing this leaderboard", open=False):
-            citation_button = gr.Textbox(
-                value=CITATION_BUTTON_TEXT,
-                label=CITATION_BUTTON_LABEL,
-                lines=20,
-                elem_id="citation-button",
-                show_copy_button=True)
+import unicodedata
 
-scheduler = BackgroundScheduler()
+def is_valid_unicode(char):
+    try:
+        unicodedata.name(char)
+        return True  # Valid Unicode character
+    except ValueError:
+        return False  # Invalid Unicode character
+
+def remove_invalid_unicode(input_string):
+    if isinstance(input_string, str):
+        valid_chars = [char for char in input_string if is_valid_unicode(char)]
+        return ''.join(valid_chars)
+    else:
+        return input_string  # Return non-string values as is
+
+dummy1 = gr.Textbox(visible=False)
+
+hidden_leaderboard_table_for_search = gr.components.Dataframe(
+    headers=COLS,
+    datatype=TYPES,
+    visible=False,
+    line_breaks=False,
+    interactive=False
+)
 
-scheduler.add_job(restart_space, "interval", seconds=6 * 60 * 60)
+def display(x, y):
+    # Assuming df is your DataFrame
+    for column in leaderboard_df.columns:
+        if leaderboard_df[column].dtype == 'object':
+            leaderboard_df[column] = leaderboard_df[column].apply(remove_invalid_unicode)
+
+    subset_df = leaderboard_df[COLS]
+    return subset_df
+
+INTRODUCTION_TEXT = """
+This is a copied space from LLM Trustworthy Leaderboard. Instead of displaying
+the results as table this space was modified to simply provides a gradio API interface. 
+Using the following python script below, users can access the full leaderboard data easily.
+Python on how to access the data:
+```python
+# Import dependencies
+from gradio_client import Client
+# Initialize the Gradio client with the API URL
+client = Client("https://rodrigomasini-data-only-llm-trustworthy-leaderboard.hf.space/")
+try:
+    # Perform the API call
+    response = client.predict("","", api_name='/predict')
+    # Check if response it's directly accessible
+    if len(response) > 0:
+        print("Response received!")
+        headers = response.get('headers', [])
+        data = response.get('data', [])
+        print(headers)
+        # Remove commenst if you want to download the dataset and save in csv format
+        # Specify the path to your CSV file
+        #csv_file_path = 'llm-trustworthy-benchmark.csv'
+        # Open the CSV file for writing
+        #with open(csv_file_path, mode='w', newline='', encoding='utf-8') as file:
+        #    writer = csv.writer(file)
+            # Write the headers
+        #    writer.writerow(headers)
+            # Write the data
+        #    for row in data:
+        #        writer.writerow(row)
+        #print(f"Results saved to {csv_file_path}")
+    # If the above line prints a string that looks like JSON, you can parse it with json.loads(response)
+    # Otherwise, you might need to adjust based on the actual structure of `response`
+except Exception as e:
+    print(f"An error occurred: {e}")
+```
+"""
+
+interface = gr.Interface(
+    fn=display,
+    inputs=[gr.Markdown(INTRODUCTION_TEXT, elem_classes="markdown-text"), dummy1],
+    outputs=[hidden_leaderboard_table_for_search]
+)
 
+scheduler = BackgroundScheduler()
+scheduler.add_job(restart_space, "interval", seconds=1800)
 
 def launch_backend():
     import subprocess
@@ -354,8 +238,6 @@ def launch_backend():
     if DEVICE not in {'cpu'}:
         _ = subprocess.run(["python", "backend-cli.py"])
 
-
-# scheduler.add_job(launch_backend, "interval", seconds=120)
-
 scheduler.start()
-demo.queue(default_concurrency_limit=40).launch()
+
+interface.launch()