test new loading if it would avoid failure

main.py

@@ -223,7 +223,7 @@ def make_leaderboard(lb: LBContainer) -> Leaderboard:
     return Leaderboard(
         elem_id=f"lb_for_{lb.name}",
         value=df_leaderboard,
-        # datatype=datatypes,
+        datatype=datatypes,
         select_columns=SelectColumns(
             default_selection=list(df_leaderboard.columns),
             cant_deselect=["Type", "Model"],
@@ -421,41 +421,36 @@ def main():
         gr.Markdown("## 🏆 TabArena Leaderboards")
         lb_matrix = LBMatrix()
 
-        # Imputation
+        # 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)
-                # 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.TabItem(impute_t_name, id=impute_id) as t_impute:
                     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,
@@ -467,14 +462,11 @@ 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:
-                                                        # --- LOGIC ---
-                                                        # Check if this is the absolute first tab
+                                                        # 1. Determine if Absolute First (Load immediately)
                                                         is_absolute_first = (
                                                             impute_id == 0
                                                             and splits_id == 0
@@ -482,77 +474,59 @@ def main():
                                                             and datasets_id == 0
                                                         )
 
-                                                        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
-                                                            )
+                                                        # 2. State Trigger (True if first, False otherwise)
+                                                        load_trigger = gr.State(
+                                                            value=is_absolute_first
+                                                        )
 
-                                                            # Helper to set trigger to True
-                                                            def activate_trigger():
-                                                                return True
+                                                        # 3. Self-Click Trigger
+                                                        t_dataset.select(
+                                                            lambda: True,
+                                                            None,
+                                                            load_trigger,
+                                                        )
 
-                                                            # 1. Always trigger if the USER clicks this specific tab
-                                                            t_dataset.select(
-                                                                activate_trigger,
-                                                                None,
-                                                                load_trigger,
+                                                        # 4. Store Parent->Child Triggers for LATER application (avoids recursion error)
+                                                        if datasets_id == 0:
+                                                            deferred_bindings.append(
+                                                                (t_tasks, load_trigger)
                                                             )
-
-                                                            # 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,
+                                                            if tasks_id == 0:
+                                                                deferred_bindings.append(
+                                                                    (
+                                                                        t_splits,
                                                                         load_trigger,
                                                                     )
-
-                                                                    # If this Split is also a default, clicking Imputation should trigger it.
-                                                                    if splits_id == 0:
-                                                                        t_impute.select(
-                                                                            activate_trigger,
-                                                                            None,
+                                                                )
+                                                                if splits_id == 0:
+                                                                    deferred_bindings.append(
+                                                                        (
+                                                                            t_impute,
                                                                             load_trigger,
                                                                         )
+                                                                    )
 
-                                                            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("<i>Loading results...</i>")
+                                                        # 5. Render Logic
+                                                        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...")
+
+        # --- 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")