Introduce task groupings and fix adding/removing task

actions.py

@@ -1,8 +1,9 @@
 import re
+from typing import List
 
 import gradio as gr
 
-from components import all_inputs, all_tasks, Input, MAX_INPUTS, MAX_TASKS, Task
+from components import all_tasks, Input, MAX_INPUTS, MAX_TASKS, Task
 
 
 def add_input(*visibility):
@@ -27,34 +28,56 @@ def remove_input(*visibility):
             )
 
 
-def add_task(*visibility):
-    for i, visible in enumerate(visibility, 1):
-        if not bool(visible):
+def _is_task_row_fully_invisible(row: List[int]) -> bool:
+    print(row)
+    for visible in row:
+        if bool(visible):
+            return False
+    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
             return (
-                [gr.Box.update(visible=True)] * i
-                + [gr.Box.update(visible=False)] * (MAX_TASKS - i)
-                + [1] * i
-                + [0] * (MAX_TASKS - i)
+                [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)
             )
 
 
 def remove_task(*visibility):
-    for i, visible in reversed(list(enumerate(visibility, 1))):
-        if bool(visible):
+    visibility = list(visibility)
+    n_avail_tasks = len(Task.AVAILABLE_TASKS)
+    print(visibility, n_avail_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]
+        )
+        print(start_row, start_row + n_avail_tasks, is_row_invisible)
+        if is_row_invisible:
+            unchanged_up_to = start_row - n_avail_tasks
             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)
+                [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)
             )
 
 
-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
-    ]
-
-
 def _clear_error():
     return gr.HighlightedText.update(value=None, visible=False)
 
@@ -75,11 +98,9 @@ def execute_task(id_: int, prev_error_value, n_inputs, *vars_in_scope):
 
     # 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_
+        f"{Input.VNAME}{i}": input_ for i, input_ in enumerate(input_vars) if input_
     }
-    vars.update(
-        {f"{Task.vname}{i}": task for i, task in enumerate(task_outputs)}
-    )
+    vars.update({f"{Task.VNAME}{i}": task for i, task 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)}
 

app.py

@@ -1,7 +1,13 @@
 import gradio as gr
 
 import actions as a
-from components import all_inputs, all_tasks
+from components import AITask, all_inputs, all_tasks, 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
+    ]
 
 
 with gr.Blocks() as demo:
@@ -11,6 +17,7 @@ with gr.Blocks() as demo:
     # Toolkit
     Define input variables to be used in your tasks.
     <br>Task outputs can be used in subsequent tasks.
+    <br>5 input variables and 10 tasks allowed (for now).
     <br>
     <br>AI tasks call into ChatGPT to perform actions.
     <br>Chain inputs and tasks to build an E2E application.
@@ -25,6 +32,12 @@ with gr.Blocks() as demo:
         remove_input_btn = gr.Button("Remove input variable")
     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")
@@ -46,15 +59,15 @@ with gr.Blocks() as demo:
     )
     add_task_btn.click(
         a.add_task,
-        inputs=[i.visible for i in all_tasks.values()],
-        outputs=[i.gr_component for i in all_tasks.values()]  # type: ignore
-        + [i.visible for i in all_tasks.values()],
+        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],
     )
     remove_task_btn.click(
         a.remove_task,
-        inputs=[i.visible for i in all_tasks.values()],
-        outputs=[i.gr_component for i in all_tasks.values()]  # type: ignore
-        + [i.visible for i in all_tasks.values()],
+        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],
     )
 
     # Sequential execution
@@ -64,7 +77,9 @@ with gr.Blocks() as demo:
     for i, task in all_tasks.items():
         execution_event = execution_event.then(
             a.execute_task,
-            inputs=[task.component_id, error_message, task.n_inputs] + task.inputs() + a._get_all_vars_up_to(i),  # type: ignore
+            inputs=[task.component_id, error_message, task.n_inputs]
+            + task.inputs
+            + _get_all_vars_up_to(i),
             outputs=[task.output, error_message],
         )
 

components.py

@@ -2,12 +2,13 @@ from abc import ABC, abstractmethod
 from typing import Dict, List, Optional
 
 import gradio as gr
+import requests
 
 import ai
 
 
 class Component(ABC):
-    vname = None
+    VNAME = None
 
     def __init__(self, id_: int, visible: bool = False):
         # Internal state
@@ -40,11 +41,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,
@@ -55,12 +56,8 @@ class Input(Component):
         pass
 
 
-class Task(Component, ABC):
-    vname = "t"
-
-    def __init__(self, id_: int, visible: bool = False):
-        super().__init__(id_, visible)
-        self.output: gr.Textbox
+class TaskComponent(Component, ABC):
+    VNAME = "t"
 
     @abstractmethod
     def inputs(self) -> List:
@@ -75,19 +72,26 @@ class Task(Component, ABC):
         self.n_inputs = gr.Number(value=self._n_inputs, visible=False)
 
 
-class AITask(Task):
+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"AI task")
+            gr.Markdown(
+                f"""
+            {self.NAME}
+            <br> Use this Task to give instructions to ChatGPT.
+            """
+            )
             with gr.Row():
                 self.prompt = gr.Textbox(
                     label="Instructions",
                     lines=10,
                     interactive=True,
-                    placeholder="What is the AI assistant meant to do?",
+                    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,
                 )
@@ -102,12 +106,88 @@ class AITask(Task):
         return [self.prompt]
 
 
-MAX_INPUTS = 10
+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.
+            """
+            )
+            with gr.Row():
+                self.url = gr.Textbox(
+                    interactive=True,
+                    placeholder="URL",
+                    show_label=False,
+                )
+                self.output = gr.Textbox(
+                    label=f"Output: {{{self.VNAME}{id_}}}",
+                    lines=10,
+                    interactive=False,
+                )
+            return gr_component
+
+    def _execute(self, url: str, prompt_vars: Dict[str, str]) -> Optional[str]:
+        if url:
+            formatted_url = url.format(**prompt_vars)
+            return requests.get(formatted_url).text
+
+    def inputs(self) -> List[gr.Textbox]:
+        return [self.url]
+
+
+class Task:
+    AVAILABLE_TASKS = [AITask, VisitURL]
+    VNAME = "t"
+
+    def __init__(self, id_: int):
+        self._id = id_
+        self.active_task = AITask.NAME  # Default
+        self.inner_tasks = {t.NAME: t(self._id, False) for t in self.AVAILABLE_TASKS}
+
+    def render(self) -> None:
+        for t in self.inner_tasks.values():
+            t.render()
+
+    @property
+    def component_id(self) -> gr.Textbox:
+        return self.inner_tasks[self.active_task].component_id
+
+    @property
+    def visibilities(self) -> List[gr.Number]:
+        return [t.visible for t in self.inner_tasks.values()]
+
+    @property
+    def gr_components(self) -> List[gr.Box]:
+        return [t.gr_component for t in self.inner_tasks.values()]
+
+    @property
+    def output(self) -> gr.Textbox:
+        return self.inner_tasks[self.active_task].output
+
+    @property
+    def inputs(self) -> List[gr.Textbox]:
+        return self.inner_tasks[self.active_task].inputs()
+
+    @property
+    def n_inputs(self) -> int:
+        return self.inner_tasks[self.active_task].n_inputs
+
+    def execute(self, *args):
+        inner_task = self.inner_tasks[self.active_task]
+        print(f"Executing {inner_task._source} :: {inner_task._id}")
+        return inner_task.execute(*args)
+
+
+MAX_INPUTS = 5
 MAX_TASKS = 10
 
 
 all_inputs = {i: Input(i) for i in range(MAX_INPUTS)}
-all_tasks = {i: AITask(i) for i in range(MAX_TASKS)}
+all_tasks = {i: Task(i) for i in range(MAX_TASKS)}
 
 all_inputs[0]._initial_visibility = True
-all_tasks[0]._initial_visibility = True
+all_tasks[0].inner_tasks[all_tasks[0].active_task]._initial_visibility = True

requirements.txt

@@ -1,3 +1,4 @@
 gradio
 openai
-python-dotenv
+python-dotenv
+requests==2.28.1