refactor

main.py

@@ -42,7 +42,6 @@ class LBContainer:
     def _base_path(self):
         return Path(__file__).parent / "data" / self.base_path_to_results
 
-
     def load_df_leaderboard(self) -> pd.DataFrame:
         df = pd.read_csv(self._base_path.resolve() / "website_leaderboard.csv")
         df = df.rename(columns={"1#": "#"})
@@ -222,7 +221,6 @@ def make_leaderboard(lb: LBContainer) -> Leaderboard:
             )
         )
 
-
     return Leaderboard(
         elem_id=f"lb_for_{lb.name}",
         value=df_leaderboard,
@@ -363,9 +361,11 @@ def render_details(imputation, splits, tasks, datasets, lb_matrix):
         show_share_button=True,
     )
 
+
 def render_func(evt: gr.SelectData):
     print(f"Tab Selected: {evt.value} (Type: {evt.index})")
 
+
 def main():
     css = """
     .markdown-text-box {
@@ -428,110 +428,60 @@ def main():
         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):
+        with gr.Tabs(elem_classes="tab-buttons") as impute_tabs:
+            for impute_t in lb_matrix.imputation:
                 with gr.TabItem(
                     lb_matrix.get_name_for_lb("imputation", impute_t),
-                    id=impute_id,
+                    id=impute_t,
                 ) as t_impute:
                     t_impute.select(lambda x=impute_t: x, outputs=impute_state)
-                    splits_state = gr.State(lb_matrix.splits[0])
-                    tasks_state = gr.State(lb_matrix.tasks[0])
-                    datasets_state = gr.State(lb_matrix.datasets[0])
-
-                    # Splits
-                    with gr.Tabs(elem_classes="tab-buttons"):
-                        for splits_id, splits_t in enumerate(lb_matrix.splits):
-                            with gr.TabItem(
-                                lb_matrix.get_name_for_lb("splits", splits_t),
-                                id=f"{impute_id}_{splits_id}",
-                            ) as t_splits:
-                                t_splits.select(lambda x=splits_t: x, outputs=splits_state)
-                                tasks_state = gr.State(lb_matrix.tasks[0])
-                                datasets_state = gr.State(lb_matrix.datasets[0])
-
-                                # 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),
-                                            id=f"{impute_id}_{splits_id}_{tasks_id}",
-                                        ) as t_tasks:
-                                            t_tasks.select(lambda x=tasks_t: x, outputs=tasks_state)
-                                            datasets_state = gr.State(lb_matrix.datasets[0])
-
-                                            # Datasets
-                                            with gr.Tabs(elem_classes="tab-buttons"):
-                                                for (
-                                                    datasets_id,
-                                                    datasets_t,
-                                                ) in enumerate(lb_matrix.datasets):
-                                                    with gr.TabItem(
-                                                        lb_matrix.get_name_for_lb(
-                                                            "datasets", datasets_t
-                                                        ),
-                                                        id=f"{impute_id}_{splits_id}_{tasks_id}_{datasets_id}",
-                                                    ) as t_dataset:
-                                                        # 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,
-                                                                ],
-                                                                trigger_mode="once",
-                                                                concurrency_limit=1,
-                                                                concurrency_id=f"{context_i}_{context_s}_{context_t}_{context_d}"
-                                                            )
-                                                            def reactive_render(
-                                                                sel_i,
-                                                                sel_s,
-                                                                sel_t,
-                                                                sel_d,
-                                                            ):
-                                                                
-                                                                if (
-                                                                    sel_i == context_i
-                                                                    and sel_s
-                                                                    == context_s
-                                                                    and sel_t
-                                                                    == context_t
-                                                                    and sel_d
-                                                                    == context_d
-                                                                ):
-                                                                    print(sel_i, sel_s, sel_t, sel_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)
+        # Splits
+        with gr.Tabs(elem_classes="tab-buttons") as split_tabs:
+            for splits_t in lb_matrix.splits:
+                with gr.TabItem(
+                    lb_matrix.get_name_for_lb("splits", splits_t),
+                    id=f"{impute_t}_{splits_t}",
+                ) as t_splits:
+                    t_splits.select(lambda x=splits_t: x, outputs=splits_state)
+        # Tasks
+        with gr.Tabs(elem_classes="tab-buttons") as task_tabs:
+            for tasks_t in lb_matrix.tasks:
+                with gr.TabItem(
+                    lb_matrix.get_name_for_lb("tasks", tasks_t),
+                    id=f"{impute_t}_{splits_t}_{tasks_t}",
+                ) as t_tasks:
+                    t_tasks.select(lambda x=tasks_t: x, outputs=tasks_state)
+        # Datasets
+        with gr.Tabs(elem_classes="tab-buttons") as dataset_tabs:
+            for datasets_t in lb_matrix.datasets:
+                with gr.TabItem(
+                    lb_matrix.get_name_for_lb("datasets", datasets_t),
+                    id=f"{impute_t}_{splits_t}_{tasks_t}_{datasets_t}",
+                ) as t_dataset:
+                    t_dataset.select(
+                        lambda x=datasets_t: x,
+                        outputs=datasets_state,
+                    )
+
+        @gr.render(inputs=[impute_state, splits_state, tasks_state, datasets_state])
+        def reactive_render(sel_i, sel_s, sel_t, sel_d):
+            # Since we are outside the loop, we don't need to check contexts.
+            # We simply render whatever the current state dictates.
+            print(f"Rendering: {sel_i}, {sel_s}, {sel_t}, {sel_d}")
+
+            with gr.Group():
+                render_details(
+                    imputation=sel_i,
+                    splits=sel_s,
+                    tasks=sel_t,
+                    datasets=sel_d,
+                    lb_matrix=lb_matrix,
+                )
 
         with gr.Row(), gr.Accordion("📂 Version History", open=False):
             gr.Markdown(VERSION_HISTORY_BUTTON_TEXT, elem_classes="markdown-text")
 
-    demo.queue(default_concurrency_limit=200)
-    demo.launch()
+    demo.launch(show_error=True)
 
 
 if __name__ == "__main__":