Fix website

actions.py

@@ -3,7 +3,7 @@ from typing import List
 
 import gradio as gr
 
-from components import Input, State as s, Task
+from components import MAX_TASKS, all_tasks, Task
 
 
 def _is_task_row_fully_invisible(row: List[int]) -> bool:
@@ -17,7 +17,7 @@ def add_task(index, *visibility):
     visibility = list(visibility)
     n_avail_tasks = len(Task.available_tasks)
 
-    for i in range(s.MAX_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]
@@ -25,21 +25,28 @@ def add_task(index, *visibility):
         if is_row_invisible:
             unchanged_up_to = start_row + index
             return (
-                [gr.Box.update()] * unchanged_up_to
+                [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)
             )
-    return [gr.Box.update()] * len(visibility) + [gr.Number.update()] * len(visibility)
+    return (
+        [gr.Number.update()] * MAX_TASKS
+        + [gr.Box.update()] * len(visibility)
+        + [gr.Number.update()] * len(visibility)
+    )
 
 
 def remove_task(*visibility):
     visibility = list(visibility)
     n_avail_tasks = len(Task.available_tasks)
 
-    for i in range(s.MAX_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]
@@ -60,48 +67,55 @@ def remove_task(*visibility):
     )
 
 
-def execute_task(id_: int, prev_error_value, n_task_inputs, *vars_in_scope):
+def execute_task(task_id: int, active_index: int, error_value, *args):
     """
     Params:
-        - id_: This will tell us which task to execute.
+        - task_id: This will tell us which task to execute.
+        - active_index: The index of the actual task that is visible.
         - prev_error_value: I carry around whether there is an error in the execution, to be displayed at the end.
-        - n_task_inputs: How many inputs does this task have?
-        - vars_in_scope: All variables in scope. This can be a) input varaibles, b) task inputs or c) previous task outputs.
+        - args: Other variables that will be decomposed.
     """
-    n_task_inputs = int(n_task_inputs)
-    task_inputs = vars_in_scope[:n_task_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.update(
-        {f"{Task.vname}{i}": task_output for i, task_output in enumerate(task_outputs)}
+    task_id = int(task_id)
+    active_index = int(active_index)
+    n_avail_tasks = len(Task.available_tasks)
+
+    task_input = args[:n_avail_tasks][active_index]
+    prev_active_indexes = args[n_avail_tasks : n_avail_tasks + task_id]
+    prev_task_outputs = args[n_avail_tasks + task_id :]
+
+    error_update = gr.HighlightedText.update(
+        value=error_value, visible=error_value is not None
     )
-    # Get all variables referenced within the task inputs
-    prompt_vars = {v for ti in non_empty_task_inputs for v in re.findall("{(.*?)}", ti)}
+    # We need to return outputs for all tasks in the row.
+    outputs = [""] * n_avail_tasks
+
+    if not task_input:
+        return outputs + [error_update]
+
+    vars_in_scope = {}
+    for i, prev_active_index in enumerate(prev_active_indexes):
+        vars_in_scope[f"{Task.vname}{i}"] = prev_task_outputs[
+            i * n_avail_tasks + int(prev_active_index)
+        ]
+    # Get all variables referenced within the task input
+    prompt_vars = re.findall("{(.*?)}", task_input)
 
     # If there is an undefined variable referenced, HighlightedText will signal the error.
-    undefined_vars = prompt_vars - vars.keys()
+    undefined_vars = prompt_vars - vars_in_scope.keys()
     if len(undefined_vars) > 0:
-        return None, gr.HighlightedText.update(
-            value=[
-                (
-                    f"The following variables are being used before being defined :: {undefined_vars}. Please check your tasks.",
-                    "ERROR",
-                )
-            ],
-            visible=True,
-        )
-    error_update = gr.HighlightedText.update(
-        value=prev_error_value, visible=prev_error_value is not None
-    )
+        return outputs + [
+            gr.HighlightedText.update(
+                value=[
+                    (
+                        f"The following variables are being used before being defined :: {undefined_vars}. Please check your tasks.",
+                        "ERROR",
+                    )
+                ],
+                visible=True,
+            )
+        ]
 
-    if non_empty_task_inputs:
-        # Execute the task logic
-        return (
-            s.all_tasks[id_].execute(*non_empty_task_inputs, vars),
-            error_update,
-        )
-    else:
-        # There is no actionf for this task.
-        return None, error_update
+    formatted_input = task_input.format(**vars_in_scope)
+    # Task logic gets inserted into the right index
+    outputs[active_index] = all_tasks[task_id].execute(active_index, formatted_input)
+    return outputs + [error_update]

app.py

@@ -1,11 +1,7 @@
 import gradio as gr
 
 import actions as a
-from components import AITask, State as s, VisitURL
-
-
-def _get_all_vars_up_to(to: int):
-    return [t.output for i, t in s.all_tasks.items() if i < to]
+from components import AITask, all_tasks, Tasks, VisitURL
 
 
 with gr.Blocks() as demo:
@@ -23,7 +19,7 @@ with gr.Blocks() as demo:
     <br>Example prompt: "Translate the following text into spanish and add {v0} more sentences: {t0}".
     """
     )
-    for t in s.all_tasks.values():
+    for t in all_tasks.values():
         t.render()
     task_picker = gr.Dropdown(
         [AITask.name, VisitURL.name],
@@ -40,26 +36,33 @@ with gr.Blocks() as demo:
     # Edit layout
     add_task_btn.click(
         a.add_task,
-        inputs=[task_picker] + s.task_visibilities(),  # type: ignore
-        outputs=s.task_rows(),
+        inputs=[task_picker] + Tasks.visibilities(),
+        outputs=Tasks.active_indexes() + Tasks.gr_components() + Tasks.visibilities(),
     )
     remove_task_btn.click(
-        a.remove_task, inputs=s.task_visibilities(), outputs=s.task_rows()
+        a.remove_task,
+        inputs=Tasks.visibilities(),
+        outputs=Tasks.gr_components() + Tasks.visibilities(),
     )
 
     # Sequential execution
     execution_event = execute_btn.click(
+        # Clear error message
         lambda: gr.HighlightedText.update(value=None, visible=False),
         inputs=[],
         outputs=[error_message],
     )
-    for i, task in s.all_tasks.items():
+
+    prev_tasks = []
+    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
-            + _get_all_vars_up_to(i),
-            outputs=[task.output, error_message],
+            inputs=[task.component_id, task.active_index, error_message]
+            + task.inputs()
+            + [t.active_index for t in prev_tasks]
+            + [o for t in prev_tasks for o in t.outputs()],
+            outputs=task.outputs() + [error_message],
         )
+        prev_tasks.append(task)
 
 demo.launch()

components.py

@@ -1,5 +1,5 @@
 from abc import ABC, abstractmethod
-from typing import Dict, List, Optional, Tuple
+from typing import List
 
 import gradio as gr
 import requests
@@ -48,20 +48,13 @@ class Input(Component):
 class TaskComponent(Component, ABC):
     vname = "t"
 
-    @abstractmethod
-    def inputs(self) -> List:
-        ...
-
-    @property
-    def _n_inputs(self) -> int:
-        return len(self.inputs())
-
-    def render(self) -> None:
-        super().render()
-        self.n_inputs = gr.Number(value=self._n_inputs, visible=False)
+    def __init__(self, id_: int, visible: bool = False):
+        super().__init__(id_, visible)
+        self.name: str
+        self.input: gr.Textbox
 
     @abstractmethod
-    def execute(self, *vars, vars_in_scope: Dict[str, str]):
+    def execute(self, input):
         ...
 
 
@@ -77,7 +70,7 @@ class AITask(TaskComponent):
             """
             )
             with gr.Row():
-                self.prompt = gr.Textbox(
+                self.input = gr.Textbox(
                     label="Instructions",
                     lines=10,
                     interactive=True,
@@ -90,14 +83,8 @@ class AITask(TaskComponent):
                 )
             return gr_component
 
-    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}")
-            return ai.llm.next([{"role": "user", "content": formatted_prompt}])
-
-    def inputs(self) -> List[gr.Textbox]:
-        return [self.prompt]
+    def execute(self, prompt: str) -> str:
+        return ai.llm.next([{"role": "user", "content": prompt}])
 
 
 class VisitURL(TaskComponent):
@@ -112,7 +99,7 @@ class VisitURL(TaskComponent):
             """
             )
             with gr.Row():
-                self.url = gr.Textbox(
+                self.input = gr.Textbox(
                     interactive=True,
                     placeholder="URL",
                     show_label=False,
@@ -124,14 +111,8 @@ class VisitURL(TaskComponent):
                 )
             return gr_component
 
-    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}")
-            return requests.get(formatted_url).text
-
-    def inputs(self) -> List[gr.Textbox]:
-        return [self.url]
+    def execute(self, url: str) -> str:
+        return requests.get(url).text
 
 
 class Task:
@@ -140,58 +121,43 @@ class Task:
 
     def __init__(self, id_: int):
         self._id = id_
-        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)
+        self.active_index = gr.Number(-1, visible=False)
         for t in self._inner_tasks:
             t.render()
 
     @property
     def component_id(self) -> gr.Textbox:
-        return self._inner_tasks[self._active_index].component_id
+        return self._inner_tasks[0].component_id
 
-    @property
-    def gr_component(self) -> gr.Box:
-        return self._inner_tasks[self._active_index].gr_component
-
-    @property
-    def visible(self) -> gr.Number:
-        return self._inner_tasks[self._active_index].visible
-
-    @property
-    def output(self) -> gr.Textbox:
-        return self._inner_tasks[self._active_index].output
-
-    @property
     def inputs(self) -> List[gr.Textbox]:
-        return self._inner_tasks[self._active_index].inputs()
+        return [t.input for t in self._inner_tasks]
 
-    @property
-    def n_inputs(self) -> int:
-        return self._inner_tasks[self._active_index].n_inputs
+    def outputs(self) -> List[gr.Textbox]:
+        return [t.output for t in self._inner_tasks]
 
-    def execute(self, *args):
-        inner_task = self._inner_tasks[self._active_index]
+    def execute(self, active_index, input):
+        inner_task = self._inner_tasks[active_index]
         print(f"Executing {inner_task._source}: {inner_task._id}")
-        return inner_task.execute(*args)
+        return inner_task.execute(input)
 
 
-class State:
-    MAX_TASKS = 10
+MAX_TASKS = 10
 
-    all_tasks = {i: Task(i) for i in range(MAX_TASKS)}
+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]
 
+class Tasks:
     @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]
+    def visibilities(cls) -> List[gr.Number]:
+        return [it.visible for t in all_tasks.values() for it in t._inner_tasks]
 
+    @classmethod
+    def active_indexes(cls) -> List[gr.Number]:
+        return [t.active_index for t in all_tasks.values()]
 
-tasks = State()
+    @classmethod
+    def gr_components(cls) -> List[gr.Box]:
+        return [it.gr_component for t in all_tasks.values() for it in t._inner_tasks]