Introduce state and update adding/removing

actions.py

@@ -3,29 +3,7 @@ from typing import List
 
 import gradio as gr
 
-from components import all_tasks, Input, MAX_INPUTS, MAX_TASKS, Task
-
-
-def add_input(*visibility):
-    for i, visible in enumerate(visibility, 1):
-        if not bool(visible):
-            return (
-                [gr.Textbox.update(visible=True)] * i
-                + [gr.Textbox.update(visible=False, value="")] * (MAX_INPUTS - i)
-                + [1] * i
-                + [0] * (MAX_INPUTS - i)
-            )
-
-
-def remove_input(*visibility):
-    for i, visible in reversed(list(enumerate(visibility, 1))):
-        if bool(visible):
-            return (
-                [gr.Textbox.update(visible=True)] * (i - 1)
-                + [gr.Textbox.update(visible=False, value="")] * (MAX_INPUTS - i + 1)
-                + [1] * (i - 1)
-                + [0] * (MAX_INPUTS - i + 1)
-            )
+from components import Input, State as s, Task
 
 
 def _is_task_row_fully_invisible(row: List[int]) -> bool:
@@ -37,9 +15,9 @@ def _is_task_row_fully_invisible(row: List[int]) -> bool:
 
 def add_task(index, *visibility):
     visibility = list(visibility)
-    n_avail_tasks = len(Task.AVAILABLE_TASKS)
+    n_avail_tasks = len(Task.available_tasks)
 
-    for i in range(MAX_TASKS):
+    for i in range(s.MAX_TASKS):
         start_row = i * n_avail_tasks
         is_row_invisible = _is_task_row_fully_invisible(
             visibility[start_row : start_row + n_avail_tasks]
@@ -54,13 +32,14 @@ def add_task(index, *visibility):
                 + [1]
                 + [gr.Number.update()] * (len(visibility) - unchanged_up_to - 1)
             )
+    return [gr.Box.update()] * len(visibility) + [gr.Number.update()] * len(visibility)
 
 
 def remove_task(*visibility):
     visibility = list(visibility)
-    n_avail_tasks = len(Task.AVAILABLE_TASKS)
+    n_avail_tasks = len(Task.available_tasks)
 
-    for i in range(MAX_TASKS):
+    for i in range(s.MAX_TASKS):
         start_row = i * n_avail_tasks
         is_row_invisible = _is_task_row_fully_invisible(
             visibility[start_row : start_row + n_avail_tasks]
@@ -73,6 +52,12 @@ def remove_task(*visibility):
                 + [gr.Number.update()] * unchanged_up_to
                 + [0] * (len(visibility) - unchanged_up_to)
             )
+    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)
+    )
 
 
 def execute_task(id_: int, prev_error_value, n_task_inputs, *vars_in_scope):
@@ -85,16 +70,12 @@ def execute_task(id_: int, prev_error_value, n_task_inputs, *vars_in_scope):
     """
     n_task_inputs = int(n_task_inputs)
     task_inputs = vars_in_scope[:n_task_inputs]
-    input_vars = vars_in_scope[n_task_inputs:MAX_INPUTS]
-    task_outputs = vars_in_scope[n_task_inputs + MAX_INPUTS :]
+    task_outputs = vars_in_scope[n_task_inputs:]
     non_empty_task_inputs = [ti for ti in task_inputs if ti]
 
     # Put all defined variables into a dict, with names (except task inputs)
-    vars = {
-        f"{Input.VNAME}{i}": input_ for i, input_ in enumerate(input_vars) if input_
-    }
     vars.update(
-        {f"{Task.VNAME}{i}": task_output for i, task_output in enumerate(task_outputs)}
+        {f"{Task.vname}{i}": task_output for i, task_output in enumerate(task_outputs)}
     )
     # Get all variables referenced within the task inputs
     prompt_vars = {v for ti in non_empty_task_inputs for v in re.findall("{(.*?)}", ti)}
@@ -118,9 +99,9 @@ def execute_task(id_: int, prev_error_value, n_task_inputs, *vars_in_scope):
     if non_empty_task_inputs:
         # Execute the task logic
         return (
-            all_tasks[id_].execute(*non_empty_task_inputs, vars),
+            s.all_tasks[id_].execute(*non_empty_task_inputs, vars),
             error_update,
         )
     else:
-        # There is no actionf or this task.
+        # There is no actionf for this task.
         return None, error_update

app.py

@@ -1,13 +1,11 @@
 import gradio as gr
 
 import actions as a
-from components import AITask, all_inputs, all_tasks, VisitURL
+from components import AITask, State as s, VisitURL
 
 
 def _get_all_vars_up_to(to: int):
-    return [in_.output for in_ in all_inputs.values()] + [
-        t.output for i, t in all_tasks.items() if i < to
-    ]
+    return [t.output for i, t in s.all_tasks.items() if i < to]
 
 
 with gr.Blocks() as demo:
@@ -25,16 +23,11 @@ with gr.Blocks() as demo:
     <br>Example prompt: "Translate the following text into spanish and add {v0} more sentences: {t0}".
     """
     )
-    for i in all_inputs.values():
-        i.render()
-    with gr.Row():
-        add_input_btn = gr.Button("Add input variable")
-        remove_input_btn = gr.Button("Remove input variable")
-    for t in all_tasks.values():
+    for t in s.all_tasks.values():
         t.render()
     task_picker = gr.Dropdown(
-        [AITask.NAME, VisitURL.NAME],
-        value=AITask.NAME,
+        [AITask.name, VisitURL.name],
+        value=AITask.name,
         label="Pick a new Task",
         type="index",
     )
@@ -45,38 +38,22 @@ with gr.Blocks() as demo:
     execute_btn = gr.Button("Execute")
 
     # Edit layout
-    add_input_btn.click(
-        a.add_input,
-        inputs=[i.visible for i in all_inputs.values()],
-        outputs=[i.gr_component for i in all_inputs.values()]  # type: ignore
-        + [i.visible for i in all_inputs.values()],
-    )
-    remove_input_btn.click(
-        a.remove_input,
-        inputs=[i.visible for i in all_inputs.values()],
-        outputs=[i.gr_component for i in all_inputs.values()]  # type: ignore
-        + [i.visible for i in all_inputs.values()],
-    )
     add_task_btn.click(
         a.add_task,
-        inputs=[task_picker] + [v for t in all_tasks.values() for v in t.visibilities],  # type: ignore
-        outputs=[c for t in all_tasks.values() for c in t.gr_components]  # type: ignore
-        + [v for t in all_tasks.values() for v in t.visibilities],
+        inputs=[task_picker] + s.task_visibilities(),  # type: ignore
+        outputs=s.task_rows(),
     )
     remove_task_btn.click(
-        a.remove_task,
-        inputs=[v for t in all_tasks.values() for v in t.visibilities],  # type: ignore
-        outputs=[c for t in all_tasks.values() for c in t.gr_components]  # type: ignore
-        + [v for t in all_tasks.values() for v in t.visibilities],
+        a.remove_task, inputs=s.task_visibilities(), outputs=s.task_rows()
     )
 
     # Sequential execution
     execution_event = execute_btn.click(
-        lambda _: gr.HighlightedText.update(value=None, visible=False),
+        lambda: gr.HighlightedText.update(value=None, visible=False),
         inputs=[],
         outputs=[error_message],
     )
-    for i, task in all_tasks.items():
+    for i, task in s.all_tasks.items():
         execution_event = execution_event.then(
             a.execute_task,
             inputs=[task.component_id, error_message, task.n_inputs]

components.py

@@ -1,5 +1,5 @@
 from abc import ABC, abstractmethod
-from typing import Dict, List, Optional
+from typing import Dict, List, Optional, Tuple
 
 import gradio as gr
 import requests
@@ -8,7 +8,7 @@ import ai
 
 
 class Component(ABC):
-    VNAME = None
+    vname = None
 
     def __init__(self, id_: int, visible: bool = False):
         # Internal state
@@ -33,11 +33,11 @@ class Component(ABC):
 
 
 class Input(Component):
-    VNAME = "v"
+    vname = "v"
 
     def _render(self, id_: int, visible: bool) -> gr.Textbox:
         self.output = gr.Textbox(
-            label=f"Input: {{{self.VNAME}{id_}}}",
+            label=f"Input: {{{self.vname}{id_}}}",
             interactive=True,
             placeholder="Variable value",
             visible=visible,
@@ -46,7 +46,7 @@ class Input(Component):
 
 
 class TaskComponent(Component, ABC):
-    VNAME = "t"
+    vname = "t"
 
     @abstractmethod
     def inputs(self) -> List:
@@ -66,13 +66,13 @@ class TaskComponent(Component, ABC):
 
 
 class AITask(TaskComponent):
-    NAME = "AI Task"
+    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}
+            {self.name}
             <br> Use this Task to give instructions to ChatGPT.
             """
             )
@@ -84,7 +84,7 @@ class AITask(TaskComponent):
                     placeholder="Example - summarize this text: {v1}",
                 )
                 self.output = gr.Textbox(
-                    label=f"Output: {{{self.VNAME}{id_}}}",
+                    label=f"Output: {{{self.vname}{id_}}}",
                     lines=10,
                     interactive=False,
                 )
@@ -93,7 +93,7 @@ class AITask(TaskComponent):
     def execute(self, prompt: str, vars_in_scope: Dict[str, str]) -> Optional[str]:
         if prompt:
             formatted_prompt = prompt.format(**vars_in_scope)
-            print(f"Executing {self.NAME} with prompt :: {formatted_prompt}")
+            print(f"Executing {self.name} with prompt :: {formatted_prompt}")
             return ai.llm.next([{"role": "user", "content": formatted_prompt}])
 
     def inputs(self) -> List[gr.Textbox]:
@@ -101,13 +101,13 @@ class AITask(TaskComponent):
 
 
 class VisitURL(TaskComponent):
-    NAME = "Visit URL"
+    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}
+            {self.name}
             <br> Use this Task to visit an URL and get its content.
             """
             )
@@ -118,7 +118,7 @@ class VisitURL(TaskComponent):
                     show_label=False,
                 )
                 self.output = gr.Textbox(
-                    label=f"Output: {{{self.VNAME}{id_}}}",
+                    label=f"Output: {{{self.vname}{id_}}}",
                     lines=10,
                     interactive=False,
                 )
@@ -127,7 +127,7 @@ class VisitURL(TaskComponent):
     def execute(self, url: str, vars_in_scope: Dict[str, str]) -> Optional[str]:
         if url:
             formatted_url = url.format(**vars_in_scope)
-            print(f"Executing {self.NAME} with url :: {formatted_url}")
+            print(f"Executing {self.name} with url :: {formatted_url}")
             return requests.get(formatted_url).text
 
     def inputs(self) -> List[gr.Textbox]:
@@ -135,13 +135,13 @@ class VisitURL(TaskComponent):
 
 
 class Task:
-    AVAILABLE_TASKS = [AITask, VisitURL]
-    VNAME = "t"
+    available_tasks = [AITask, VisitURL]
+    vname = "t"
 
     def __init__(self, id_: int):
         self._id = id_
-        self._active_index = 0  # Default
-        self._inner_tasks = [t(self._id, False) for t in self.AVAILABLE_TASKS]
+        self._active_index = -1  # Nothing
+        self._inner_tasks = [t(self._id, False) for t in self.available_tasks]
 
     def render(self) -> None:
         self.active_index = gr.Number(self._active_index, visible=False)
@@ -153,12 +153,12 @@ class Task:
         return self._inner_tasks[self._active_index].component_id
 
     @property
-    def visibilities(self) -> List[gr.Number]:
-        return [t.visible for t in self._inner_tasks]
+    def gr_component(self) -> gr.Box:
+        return self._inner_tasks[self._active_index].gr_component
 
     @property
-    def gr_components(self) -> List[gr.Box]:
-        return [t.gr_component for t in self._inner_tasks]
+    def visible(self) -> gr.Number:
+        return self._inner_tasks[self._active_index].visible
 
     @property
     def output(self) -> gr.Textbox:
@@ -178,11 +178,20 @@ class Task:
         return inner_task.execute(*args)
 
 
-MAX_INPUTS = 5
-MAX_TASKS = 10
+class State:
+    MAX_TASKS = 10
 
+    all_tasks = {i: Task(i) for i in range(MAX_TASKS)}
 
-all_inputs = {i: Input(i) for i in range(MAX_INPUTS)}
-all_tasks = {i: Task(i) for i in range(MAX_TASKS)}
+    @classmethod
+    def task_visibilities(cls) -> List:
+        return [it.visible for t in cls.all_tasks.values() for it in t._inner_tasks]
 
-all_inputs[0]._initial_visibility = True
+    @classmethod
+    def task_rows(cls) -> List:
+        return [
+            it.gr_component for t in cls.all_tasks.values() for it in t._inner_tasks
+        ] + [it.visible for t in cls.all_tasks.values() for it in t._inner_tasks]
+
+
+tasks = State()