Updated interface to pick tasks

actions.py

@@ -13,58 +13,28 @@ def _is_task_row_fully_invisible(row: List[int]) -> bool:
     return True
 
 
-def add_task(index, *visibility):
-    visibility = list(visibility)
-    n_avail_tasks = len(Task.available_tasks)
-
-    for i in range(MAX_TASKS):
-        start_row = i * n_avail_tasks
-        is_row_invisible = _is_task_row_fully_invisible(
-            visibility[start_row : start_row + n_avail_tasks]
-        )
-        if is_row_invisible:
-            unchanged_up_to = start_row + index
+def add_task(*visibilities):
+    for i, visible in enumerate(visibilities, 1):
+        if not bool(visible):
             return (
-                [gr.Number.update()] * i
-                + [index]
-                + [gr.Number.update()] * (MAX_TASKS - i - 1)
-                + [gr.Box.update()] * unchanged_up_to
-                + [gr.Box.update(visible=True)]
-                + [gr.Box.update()] * (len(visibility) - unchanged_up_to - 1)
-                + [gr.Number.update()] * unchanged_up_to
-                + [1]
-                + [gr.Number.update()] * (len(visibility) - unchanged_up_to - 1)
+                [gr.Box.update(visible=True)] * i
+                + [gr.Box.update(visible=False)] * (MAX_TASKS - i)
+                + [1] * i
+                + [0] * (MAX_TASKS - i)
             )
-    return (
-        [gr.Number.update()] * MAX_TASKS
-        + [gr.Box.update()] * len(visibility)
-        + [gr.Number.update()] * len(visibility)
-    )
+    return [gr.Box.update()] * MAX_TASKS + [gr.Number.update()] * MAX_TASKS
 
 
-def remove_task(*visibility):
-    visibility = list(visibility)
-    n_avail_tasks = len(Task.available_tasks)
-
-    for i in range(MAX_TASKS):
-        start_row = i * n_avail_tasks
-        is_row_invisible = _is_task_row_fully_invisible(
-            visibility[start_row : start_row + n_avail_tasks]
-        )
-        if is_row_invisible:
-            unchanged_up_to = start_row - n_avail_tasks
+def remove_task(*visibilities):
+    for i, visible in reversed(list(enumerate(visibilities))):
+        if bool(visible):
             return (
-                [gr.Box.update()] * unchanged_up_to
-                + [gr.Box.update(visible=False)] * (len(visibility) - unchanged_up_to)
-                + [gr.Number.update()] * unchanged_up_to
-                + [0] * (len(visibility) - unchanged_up_to)
+                [gr.Box.update(visible=True)] * i
+                + [gr.Box.update(visible=False)] * (MAX_TASKS - i)
+                + [1] * i
+                + [0] * (MAX_TASKS - i)
             )
-    return (
-        [gr.Box.update()] * (len(visibility) - n_avail_tasks)
-        + [gr.Box.update(visible=False)] * n_avail_tasks
-        + [gr.Number.update()] * (len(visibility) - n_avail_tasks)
-        + [0] * (len(visibility) - n_avail_tasks)
-    )
+    return [gr.Box.update()] * MAX_TASKS + [gr.Number.update()] * MAX_TASKS
 
 
 def execute_task(task_id: int, active_index: int, error_value, *args):

app.py

@@ -1,7 +1,7 @@
 import gradio as gr
 
 import actions as a
-from components import AITask, all_tasks, Tasks, VisitURL
+from components import all_tasks, Tasks
 
 
 with gr.Blocks() as demo:
@@ -21,12 +21,6 @@ with gr.Blocks() as demo:
     )
     for t in all_tasks.values():
         t.render()
-    task_picker = gr.Dropdown(
-        [AITask.name, VisitURL.name],
-        value=AITask.name,
-        label="Pick a new Task",
-        type="index",
-    )
     with gr.Row():
         add_task_btn = gr.Button("Add task")
         remove_task_btn = gr.Button("Remove task")
@@ -36,8 +30,8 @@ with gr.Blocks() as demo:
     # Edit layout
     add_task_btn.click(
         a.add_task,
-        inputs=[task_picker] + Tasks.visibilities(),
-        outputs=Tasks.active_indexes() + Tasks.gr_components() + Tasks.visibilities(),
+        inputs=Tasks.visibilities(),
+        outputs=Tasks.gr_components() + Tasks.visibilities(),
     )
     remove_task_btn.click(
         a.remove_task,

components.py

@@ -1,5 +1,5 @@
 from abc import ABC, abstractmethod
-from typing import List
+from typing import List, Union
 
 import gradio as gr
 import requests
@@ -8,50 +8,57 @@ import ai
 
 
 class Component(ABC):
-    vname = None
-
     def __init__(self, id_: int, visible: bool = False):
         # Internal state
         self._id = id_
         self._source = self.__class__.__name__
-        self._initial_visibility = visible
+        self.vname: str
 
         # Gradio state
         self.component_id: gr.Number
-        self.visible: gr.Number
-        self.gr_component = gr.Box
+        self.gr_component: Union[gr.Box, gr.Textbox]
         self.output: gr.Textbox
-
-    @abstractmethod
-    def _render(self, id_: int, visible: bool):
-        ...
+        self.visible: gr.Number
 
     def render(self) -> None:
         self.component_id = gr.Number(value=self._id, visible=False)
-        self.visible = gr.Number(int(self._initial_visibility), visible=False)
-        self.gr_component = self._render(self._id, self._initial_visibility)
+        self.visible = gr.Number(0, visible=False)
+        self.gr_component = self._render(self._id)
+
+    @abstractmethod
+    def _render(self, id_: int) -> Union[gr.Box, gr.Textbox]:
+        ...
 
 
 class Input(Component):
     vname = "v"
 
-    def _render(self, id_: int, visible: bool) -> gr.Textbox:
+    def _render(self, id_: int) -> gr.Textbox:
         self.output = gr.Textbox(
             label=f"Input: {{{self.vname}{id_}}}",
             interactive=True,
             placeholder="Variable value",
-            visible=visible,
+            visible=False,
         )
         return self.output
 
 
-class TaskComponent(Component, ABC):
+class TaskComponent(ABC):
     vname = "t"
 
-    def __init__(self, id_: int, visible: bool = False):
-        super().__init__(id_, visible)
+    def __init__(self):
         self.name: str
+        self.gr_component: gr.Box
         self.input: gr.Textbox
+        self.output: gr.Textbox
+
+    def render(self, id_: int) -> None:
+        self.gr_component = self._render(id_)
+        self.gr_component.visible = False
+
+    @abstractmethod
+    def _render(self, id_) -> gr.Box:
+        ...
 
     @abstractmethod
     def execute(self, input):
@@ -61,20 +68,15 @@ class TaskComponent(Component, ABC):
 class AITask(TaskComponent):
     name = "AI Task"
 
-    def _render(self, id_: int, visible: bool) -> gr.Box:
-        with gr.Box(visible=visible) as gr_component:
-            gr.Markdown(
-                f"""
-            {self.name}
-            <br> Use this Task to give instructions to ChatGPT.
-            """
-            )
+    def _render(self, id_: int) -> gr.Box:
+        with gr.Box() as gr_component:
+            gr.Markdown("Give instructions to ChatGPT to do something.")
             with gr.Row():
                 self.input = gr.Textbox(
                     label="Instructions",
                     lines=10,
                     interactive=True,
-                    placeholder="Example - summarize this text: {v1}",
+                    placeholder="Example: summarize this text: {v0}",
                 )
                 self.output = gr.Textbox(
                     label=f"Output: {{{self.vname}{id_}}}",
@@ -90,14 +92,9 @@ class AITask(TaskComponent):
 class VisitURL(TaskComponent):
     name = "Visit URL"
 
-    def _render(self, id_: int, visible: bool) -> gr.Box:
-        with gr.Box(visible=visible) as gr_component:
-            gr.Markdown(
-                f"""
-            {self.name}
-            <br> Use this Task to visit an URL and get its content.
-            """
-            )
+    def _render(self, id_: int) -> gr.Box:
+        with gr.Box() as gr_component:
+            gr.Markdown("Visit an URL and get its content.")
             with gr.Row():
                 self.input = gr.Textbox(
                     interactive=True,
@@ -109,28 +106,45 @@ class VisitURL(TaskComponent):
                     lines=10,
                     interactive=False,
                 )
-            return gr_component
+        return gr_component
 
     def execute(self, url: str) -> str:
         return requests.get(url).text
 
 
-class Task:
+class Task(Component):
     available_tasks = [AITask, VisitURL]
     vname = "t"
 
-    def __init__(self, id_: int):
-        self._id = id_
-        self._inner_tasks = [t(self._id, False) for t in self.available_tasks]
-
-    def render(self) -> None:
-        self.active_index = gr.Number(-1, visible=False)
-        for t in self._inner_tasks:
-            t.render()
+    def __init__(self, id_: int, visible: bool = False):
+        super().__init__(id_, visible)
+        self._inner_tasks = [t() for t in self.available_tasks]
+        self.gr_component: gr.Box
+
+    def _render(self, id_: int) -> gr.Box:
+        with gr.Box(visible=False) as gr_component:
+            self.task_picker = gr.Dropdown(
+                [AITask.name, VisitURL.name],
+                value=AITask.name,
+                label="Pick a new Task",
+                type="index",
+            )
+            self.active_index = gr.Number(-1, visible=False)
+            for t in self._inner_tasks:
+                t.render(id_)
+
+            self.task_picker.select(
+                self.pick_task,
+                inputs=[self.task_picker],
+                outputs=[t.gr_component for t in self._inner_tasks],
+            )
+        return gr_component
 
-    @property
-    def component_id(self) -> gr.Textbox:
-        return self._inner_tasks[0].component_id
+    @staticmethod
+    def pick_task(idx):
+        update = [gr.Box.update(visible=False)] * len(Task.available_tasks)
+        update[idx] = gr.Box.update(visible=True)
+        return update
 
     def inputs(self) -> List[gr.Textbox]:
         return [t.input for t in self._inner_tasks]
@@ -152,7 +166,7 @@ all_tasks = {i: Task(i) for i in range(MAX_TASKS)}
 class Tasks:
     @classmethod
     def visibilities(cls) -> List[gr.Number]:
-        return [it.visible for t in all_tasks.values() for it in t._inner_tasks]
+        return [t.visible for t in all_tasks.values()]
 
     @classmethod
     def active_indexes(cls) -> List[gr.Number]:
@@ -160,4 +174,4 @@ class Tasks:
 
     @classmethod
     def gr_components(cls) -> List[gr.Box]:
-        return [it.gr_component for t in all_tasks.values() for it in t._inner_tasks]
+        return [t.gr_component for t in all_tasks.values()]