Actually fix adding/removing

app.py

@@ -1,4 +1,4 @@
-from typing import Dict, List, Optional, NamedTuple, Type, Union
+from typing import NamedTuple, Type, Union
 
 
 import gradio as gr
@@ -21,7 +21,7 @@ class Input:
                 interactive=True,
                 placeholder="Variable value",
             )
-        return gr_component
+            return gr_component
 
 
 class AITask:
@@ -59,11 +59,12 @@ class Component:
         # Internal state
         self._id = id_
         self.internal = internal
-        self.visible = visible
+        self._initial_visibility = visible
 
         # Gradio state
         self.component_id: gr.Textbox
         self.source: gr.Textbox
+        self.visible: gr.Number
         self.gr_component = gr.Box
         self.output_name: gr.Textbox
         self.output: gr.Textbox
@@ -71,7 +72,8 @@ class Component:
     def render(self) -> None:
         self.component_id = gr.Textbox(value=str(self._id), visible=False)
         self.source = gr.Textbox(value=self.internal.__class__.__name__, visible=False)
-        self.gr_component = self.internal.render(bool(self.visible))
+        self.visible = gr.Number(int(self._initial_visibility), visible=False)
+        self.gr_component = self.internal.render(self._initial_visibility)
         self.output_name = self.internal.output_name
         self.output = self.internal.output
 
@@ -86,44 +88,54 @@ class Variable(NamedTuple):
 all_inputs = {i: Component(i, Input()) for i in range(MAX_INPUTS)}
 all_tasks = {i: Component(i, AITask()) for i in range(MAX_TASKS)}
 
-all_inputs[0].visible = True
-all_tasks[0].visible = True
+all_inputs[0]._initial_visibility = True
+all_tasks[0]._initial_visibility = True
 
 
-def add_input() -> Optional[List[Dict]]:
-    for i, input_ in all_inputs.items():
-        if not input_.visible:
-            input_.visible = True
-            return [gr.Row.update(visible=True)] * (i + 1) + [
-                gr.Row.update(visible=False)
-            ] * (MAX_INPUTS - i)
+def add_input(*visibility):
+    for i, visible in enumerate(visibility, 1):
+        if not bool(visible):
+            return (
+                [gr.Row.update(visible=True)] * i
+                + [gr.Row.update(visible=False)] * (MAX_INPUTS - i)
+                + [1] * i
+                + [0] * (MAX_INPUTS - i)
+            )
 
 
-def remove_input() -> Optional[List[Dict]]:
-    for i, input_ in reversed(all_inputs.items()):
-        if input_.visible:
-            input_.visible = False
-            return [gr.Row.update(visible=True)] * i + [
-                gr.Row.update(visible=False)
-            ] * (MAX_INPUTS - i + 1)
+def remove_input(*visibility):
+    for i, visible in reversed(list(enumerate(visibility, 1))):
+        print(i, visible)
+        if bool(visible):
+            return (
+                [gr.Row.update(visible=True)] * (i - 1)
+                + [gr.Row.update(visible=False)] * (MAX_INPUTS - i + 1)
+                + [1] * (i - 1)
+                + [0] * (MAX_INPUTS - i + 1)
+            )
 
 
-def add_task() -> Optional[List[Dict]]:
-    for i, task in all_tasks.items():
-        if not task.visible:
-            task.visible = True
-            return [gr.Box.update(visible=True)] * (i + 1) + [
-                gr.Box.update(visible=False)
-            ] * (MAX_TASKS - i)
+def add_task(*visibility):
+    for i, visible in enumerate(visibility, 1):
+        if not bool(visible):
+            return (
+                [gr.Box.update(visible=True)] * i
+                + [gr.Box.update(visible=False)] * (MAX_TASKS - i)
+                + [1] * i
+                + [0] * (MAX_TASKS - i)
+            )
 
 
-def remove_task() -> Optional[List[Dict]]:
-    for i, task in reversed(all_tasks.items()):
-        if task.visible:
-            task.visible = False
-            return [gr.Box.update(visible=True)] * i + [
-                gr.Box.update(visible=False)
-            ] * (MAX_TASKS - i + 1)
+def remove_task(*visibility):
+    for i, visible in reversed(list(enumerate(visibility, 1))):
+        print(i, visible)
+        if bool(visible):
+            return (
+                [gr.Box.update(visible=True)] * (i - 1)
+                + [gr.Box.update(visible=False)] * (MAX_TASKS - i + 1)
+                + [1] * (i - 1)
+                + [0] * (MAX_TASKS - i + 1)
+            )
 
 
 with gr.Blocks() as demo:
@@ -153,23 +165,27 @@ with gr.Blocks() as demo:
     # Layout editing
     add_input_btn.click(
         add_input,
-        inputs=[],
-        outputs=[i.gr_component for i in all_inputs.values()],
+        inputs=[i.visible for i in all_inputs.values()],
+        outputs=[i.gr_component for i in all_inputs.values()]
+        + [i.visible for i in all_inputs.values()],
     )
     remove_input_btn.click(
         remove_input,
-        inputs=[],
-        outputs=[i.gr_component for i in all_inputs.values()],
+        inputs=[i.visible for i in all_inputs.values()],
+        outputs=[i.gr_component for i in all_inputs.values()]
+        + [i.visible for i in all_inputs.values()],
     )
     add_task_btn.click(
         add_task,
-        inputs=[],
-        outputs=[t.gr_component for t in all_tasks.values()],
+        inputs=[i.visible for i in all_tasks.values()],
+        outputs=[i.gr_component for i in all_tasks.values()]
+        + [i.visible for i in all_tasks.values()],
     )
     remove_task_btn.click(
         remove_task,
-        inputs=[],
-        outputs=[t.gr_component for t in all_tasks.values()],
+        inputs=[i.visible for i in all_tasks.values()],
+        outputs=[i.gr_component for i in all_tasks.values()]
+        + [i.visible for i in all_tasks.values()],
     )
 
 demo.launch()