try fix again

main.py

@@ -421,36 +421,40 @@ def main():
         gr.Markdown("## 🏆 TabArena Leaderboards")
         lb_matrix = LBMatrix()
 
-        # LIST TO STORE DEFERRED EVENT BINDINGS
-        # Tuples of (ParentComponent, ChildTriggerState)
-        deferred_bindings = []
-
-        # --- TABS LOGIC ---
         with gr.Tabs(elem_classes="tab-buttons") as t_impute_tabs:
             for impute_id, impute_t in enumerate(lb_matrix.imputation):
                 impute_t_name = lb_matrix.get_name_for_lb("imputation", impute_t)
-
-                with gr.TabItem(impute_t_name, id=impute_id) as t_impute:
+                # Capture the imputation tab object
+                with gr.TabItem(
+                    impute_t_name,
+                    elem_id="llm-benchmark-tab-table",
+                    id=impute_id,
+                ) as t_impute:
+                    # Splits
                     with gr.Tabs(elem_classes="tab-buttons"):
                         for splits_id, splits_t in enumerate(lb_matrix.splits):
                             splits_t_label = lb_matrix.get_name_for_lb(
                                 "splits", splits_t
                             )
-
+                            # Capture the splits tab object
                             with gr.TabItem(
                                 splits_t_label,
+                                elem_id="llm-benchmark-tab-table",
                                 id=f"{impute_id}_{splits_id}",
                             ) as t_splits:
+                                # Tasks
                                 with gr.Tabs(elem_classes="tab-buttons"):
                                     for tasks_id, tasks_t in enumerate(lb_matrix.tasks):
                                         tasks_t_name = lb_matrix.get_name_for_lb(
                                             "tasks", tasks_t
                                         )
-
+                                        # Capture the tasks tab object
                                         with gr.TabItem(
                                             tasks_t_name,
+                                            elem_id="llm-benchmark-tab-table",
                                             id=f"{impute_id}_{splits_id}_{tasks_id}",
                                         ) as t_tasks:
+                                            # Datasets
                                             with gr.Tabs(elem_classes="tab-buttons"):
                                                 for (
                                                     datasets_id,
@@ -462,11 +466,14 @@ def main():
                                                         )
                                                     )
 
+                                                    # Capture the final dataset tab object
                                                     with gr.TabItem(
                                                         datasets_t_name,
+                                                        elem_id="llm-benchmark-tab-table",
                                                         id=f"{impute_id}_{splits_id}_{tasks_id}_{datasets_id}",
                                                     ) as t_dataset:
-                                                        # 1. Determine if Absolute First (Load immediately)
+                                                        # --- LOGIC ---
+                                                        # Check if this is the absolute first tab
                                                         is_absolute_first = (
                                                             impute_id == 0
                                                             and splits_id == 0
@@ -474,63 +481,82 @@ def main():
                                                             and datasets_id == 0
                                                         )
 
-                                                        # 2. State Trigger (True if first, False otherwise)
-                                                        load_trigger = gr.State(
-                                                            value=is_absolute_first
-                                                        )
+                                                        if is_absolute_first:
+                                                            # Immediate Render
+                                                            render_details(
+                                                                impute_t,
+                                                                splits_t,
+                                                                tasks_t,
+                                                                datasets_t,
+                                                                lb_matrix,
+                                                            )
+                                                        else:
+                                                            # Lazy Loading
+                                                            load_trigger = gr.State(
+                                                                False
+                                                            )
 
-                                                        # 3. Self-Click Trigger
-                                                        t_dataset.select(
-                                                            lambda: True,
-                                                            None,
-                                                            load_trigger,
-                                                        )
+                                                            # Helper to set trigger to True
+                                                            def activate_trigger():
+                                                                return True
 
-                                                        # 4. Store Parent->Child Triggers for LATER application (avoids recursion error)
-                                                        if datasets_id == 0:
-                                                            deferred_bindings.append(
-                                                                (t_tasks, load_trigger)
+                                                            # 1. Always trigger if the USER clicks this specific tab
+                                                            t_dataset.select(
+                                                                activate_trigger,
+                                                                None,
+                                                                load_trigger,
                                                             )
-                                                            if tasks_id == 0:
-                                                                deferred_bindings.append(
-                                                                    (
-                                                                        t_splits,
+
+                                                            # 2. Cascading Triggers:
+                                                            # If this is the DEFAULT (first) child tab, it should also trigger
+                                                            # when its parent is clicked.
+                                                            if datasets_id == 0:
+                                                                t_tasks.select(
+                                                                    activate_trigger,
+                                                                    None,
+                                                                    load_trigger,
+                                                                )
+
+                                                                # Continue up the chain:
+                                                                # If this Task is also a default, clicking Split should trigger it.
+                                                                if tasks_id == 0:
+                                                                    t_splits.select(
+                                                                        activate_trigger,
+                                                                        None,
                                                                         load_trigger,
                                                                     )
-                                                                )
-                                                                if splits_id == 0:
-                                                                    deferred_bindings.append(
-                                                                        (
-                                                                            t_impute,
+
+                                                                    # If this Split is also a default, clicking Imputation should trigger it.
+                                                                    if splits_id == 0:
+                                                                        t_impute.select(
+                                                                            activate_trigger,
+                                                                            None,
                                                                             load_trigger,
                                                                         )
-                                                                    )
 
-                                                        # 5. Render Logic
-                                                        renderer = partial(
-                                                            render_details,
-                                                            imputation=impute_t,
-                                                            splits=splits_t,
-                                                            tasks=tasks_t,
-                                                            datasets=datasets_t,
-                                                            lb_matrix=lb_matrix,
-                                                        )
+                                                            renderer = partial(
+                                                                render_details,
+                                                                imputation=impute_t,
+                                                                splits=splits_t,
+                                                                tasks=tasks_t,
+                                                                datasets=datasets_t,
+                                                                lb_matrix=lb_matrix,
+                                                            )
 
-                                                        @gr.render(inputs=load_trigger)
-                                                        def lazy_load(triggered):
-                                                            if triggered:
-                                                                renderer()
-                                                            else:
-                                                                gr.Markdown("Loading...")
+                                                            @gr.render(
+                                                                inputs=load_trigger
+                                                            )
+                                                            def lazy_load(triggered):
+                                                                if triggered:
+                                                                    renderer()
+                                                                else:
+                                                                    gr.Markdown("<i>Loading results...</i>")
 
-        # --- APPLY DEFERRED BINDINGS ---
-        # Now that the block dictionary is stable, we can safely add cross-component events
-        for parent_tab, child_trigger in deferred_bindings:
-            parent_tab.select(lambda: True, None, child_trigger)
 
         with gr.Row(), gr.Accordion("📂 Version History", open=False):
             gr.Markdown(VERSION_HISTORY_BUTTON_TEXT, elem_classes="markdown-text")
 
+    demo.queue(default_concurrency_limit=40)
     demo.launch()