state based logic test

main.py

@@ -351,11 +351,7 @@ def render_details(imputation, splits, tasks, datasets, lb_matrix):
     make_overview_images(lb, subset_name=lb.name)
 
     # Render Leaderboard safely
-    try:
-        make_leaderboard(lb)
-    except Exception as e:
-        gr.Error(f"Error loading leaderboard: {e}")
-        gr.Markdown(f"⚠️ **Could not load table:** {e}")
+    make_leaderboard(lb)
 
     gr.Image(
         lb.get_path_to_winrate_matrix(),
@@ -424,6 +420,11 @@ def main():
         gr.Markdown("## 🏆 TabArena Leaderboards")
         lb_matrix = LBMatrix()
 
+        impute_state = gr.State(lb_matrix.imputation[0])
+        splits_state = gr.State(lb_matrix.splits[0])
+        tasks_state = gr.State(lb_matrix.tasks[0])
+        datasets_state = gr.State(lb_matrix.datasets[0])
+
         # Impute
         with gr.Tabs(elem_classes="tab-buttons") as t_impute_tabs:
             for impute_id, impute_t in enumerate(lb_matrix.imputation):
@@ -431,6 +432,7 @@ def main():
                     lb_matrix.get_name_for_lb("imputation", impute_t),
                     id=impute_id,
                 ) as t_impute:
+                    t_impute.select(lambda x=impute_t: x, outputs=impute_state)
 
                     # Splits
                     with gr.Tabs(elem_classes="tab-buttons"):
@@ -441,16 +443,16 @@ def main():
                                 ),
                                 id=f"{impute_id}_{splits_id}",
                             ) as t_splits:
+                                t_splits.select(lambda x=splits_t: x, outputs=splits_state)
 
                                 # Tasks
                                 with gr.Tabs(elem_classes="tab-buttons"):
                                     for tasks_id, tasks_t in enumerate(lb_matrix.tasks):
                                         with gr.TabItem(
-                                                lb_matrix.get_name_for_lb(
-                                                    "tasks", tasks_t
-                                                ),
+                                            lb_matrix.get_name_for_lb("tasks", tasks_t),
                                             id=f"{impute_id}_{splits_id}_{tasks_id}",
                                         ) as t_tasks:
+                                            t_tasks.select(lambda x=tasks_t: x, outputs=tasks_state)
 
                                             # Datasets
                                             with gr.Tabs(elem_classes="tab-buttons"):
@@ -459,19 +461,63 @@ def main():
                                                     datasets_t,
                                                 ) in enumerate(lb_matrix.datasets):
                                                     with gr.TabItem(
-                                                            lb_matrix.get_name_for_lb(
-                                                                "datasets", datasets_t
-                                                            ),
+                                                        lb_matrix.get_name_for_lb(
+                                                            "datasets", datasets_t
+                                                        ),
                                                         id=f"{impute_id}_{splits_id}_{tasks_id}_{datasets_id}",
                                                     ) as t_dataset:
-                                                        render_details(
-                                                            imputation=impute_t,
-                                                            splits=splits_t,
-                                                            tasks=tasks_t,
-                                                            datasets=datasets_t,
-                                                            lb_matrix=lb_matrix,
+                                                        # UPDATE STATE
+                                                        t_dataset.select(
+                                                            lambda x=datasets_t: x,
+                                                            outputs=datasets_state,
                                                         )
 
+                                                        # 2. DEFINE RENDER LOGIC
+                                                        # We define a helper function to bind the current loop variables
+                                                        # (context_i, context_s, etc.) so they don't get overwritten.
+                                                        def define_render(
+                                                            context_i,
+                                                            context_s,
+                                                            context_t,
+                                                            context_d,
+                                                        ):
+                                                            # This triggers whenever ANY of the 4 states change
+                                                            @gr.render(
+                                                                inputs=[
+                                                                    impute_state,
+                                                                    splits_state,
+                                                                    tasks_state,
+                                                                    datasets_state,
+                                                                ]
+                                                            )
+                                                            def reactive_render(
+                                                                sel_i,
+                                                                sel_s,
+                                                                sel_t,
+                                                                sel_d,
+                                                            ):
+                                                                # 3. CONDITIONAL CHECK
+                                                                # We only render if the Selected State matches THIS Tab's Context.
+                                                                # This ensures we don't render the wrong data in the wrong tab.
+                                                                if (
+                                                                    sel_i == context_i
+                                                                    and sel_s
+                                                                    == context_s
+                                                                    and sel_t
+                                                                    == context_t
+                                                                    and sel_d
+                                                                    == context_d
+                                                                ):
+                                                                    render_details(
+                                                                        imputation=sel_i,
+                                                                        splits=sel_s,
+                                                                        tasks=sel_t,
+                                                                        datasets=sel_d,
+                                                                        lb_matrix=lb_matrix,
+                                                                    )
+
+                                                        # Call the helper to attach the render logic to this specific tab
+                                                        define_render(impute_t, splits_t, tasks_t, datasets_t)
 
         with gr.Row(), gr.Accordion("📂 Version History", open=False):
             gr.Markdown(VERSION_HISTORY_BUTTON_TEXT, elem_classes="markdown-text")