Implemented code task

actions.py

@@ -38,24 +38,40 @@ def execute_task(task_id: int, active_index: int, error_value, *args):
         - args: Other variables that will be decomposed.
     """
     n_avail_tasks = len(Task.available_tasks)
-    error_update = gr.HighlightedText.update(
-        value=error_value, visible=error_value is not None
-    )
     # We need to return outputs for all tasks in the row.
     outputs = [""] * n_avail_tasks
 
     if active_index is None:  # Active index could be 0 == not active_index
-        return outputs + [error_update]
+        return outputs + [
+            gr.HighlightedText.update(
+                value=error_value, visible=error_value is not None
+            )
+        ]
 
     task_id = int(task_id)
     active_index = int(active_index)
+    inner_n_inputs = all_tasks[task_id].inner_n_inputs
 
-    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 :]
+    start_inputs = 0
+    end_inputs = 0
+    end_all_inputs = sum(inner_n_inputs)
+    for i, n in enumerate(inner_n_inputs):
+        if i == active_index:
+            end_inputs = start_inputs + n
+            break
+        start_inputs += n
+    task_inputs = args[start_inputs:end_inputs]
+    prev_active_indexes = args[end_all_inputs : end_all_inputs + task_id]
+    prev_task_outputs = args[end_all_inputs + task_id :]
+    non_empty_inputs = [i for i in task_inputs if i]
 
-    if not task_input:
-        return outputs + [error_update]
+    if len(non_empty_inputs) < len(task_inputs):
+        return outputs + [
+            gr.HighlightedText.update(
+                value=[(f"Missing inputs for Task: {task_id}", "ERROR")],
+                visible=True,
+            )
+        ]
 
     vars_in_scope = {}
     for i, prev_active_index in enumerate(prev_active_indexes):
@@ -63,7 +79,7 @@ def execute_task(task_id: int, active_index: int, error_value, *args):
             i * n_avail_tasks + int(prev_active_index)
         ]
     # Get all variables referenced within the task input
-    prompt_vars = re.findall("{(.*?)}", task_input)
+    prompt_vars = [v for ti in non_empty_inputs for v in re.findall("{(.*?)}", ti)]
 
     # If there is an undefined variable referenced, HighlightedText will signal the error.
     undefined_vars = prompt_vars - vars_in_scope.keys()
@@ -73,7 +89,7 @@ def execute_task(task_id: int, active_index: int, error_value, *args):
             gr.HighlightedText.update(
                 value=[
                     (
-                        f"The following variables are being used before being defined :: {undefined_vars}. Please check your tasks.",
+                        f"The variables in Task :: {task_id} are being used before being defined :: {undefined_vars}. Please check your tasks.",
                         "ERROR",
                     )
                 ],
@@ -81,18 +97,21 @@ def execute_task(task_id: int, active_index: int, error_value, *args):
             )
         ]
 
-    formatted_input = task_input.format(**vars_in_scope)
     try:
         # Task logic gets inserted into the right index
         outputs[active_index] = all_tasks[task_id].execute(
-            active_index, formatted_input
+            active_index, *non_empty_inputs, vars_in_scope=vars_in_scope
         )
-        return outputs + [error_update]
+        return outputs + [
+            gr.HighlightedText.update(
+                value=error_value, visible=error_value is not None
+            )
+        ]
     except Exception as e:
-        outputs[active_index] = "ERROR"
+        raise e
         return outputs + [
             gr.HighlightedText.update(
-                value=[(str(e), "ERROR")],
+                value=[(f"Error in Task {task_id} :: {e}", "ERROR")],
                 visible=True,
             )
         ]

app.py

@@ -51,10 +51,10 @@ with gr.Blocks() as demo:
         execution_event = execution_event.then(
             a.execute_task,
             inputs=[task.component_id, task.active_index, error_message]
-            + task.inputs()
+            + 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],
+            + [o for t in prev_tasks for o in t.outputs],
+            outputs=task.outputs + [error_message],
         )
         prev_tasks.append(task)
 

components.py

@@ -1,6 +1,6 @@
 from abc import ABC, abstractmethod
 from concurrent.futures import ThreadPoolExecutor
-from typing import Dict, List, Union
+from typing import Any, Dict, List, Union
 
 import gradio as gr
 
@@ -56,12 +56,21 @@ class TaskComponent(ABC):
     def render(self, id_: int) -> None:
         self.gr_component = self._render(id_)
 
+    @property
+    @abstractmethod
+    def inputs(self) -> List[gr.Textbox]:
+        ...
+
+    @property
+    def n_inputs(self) -> int:
+        return len(self.inputs)
+
     @abstractmethod
     def _render(self, id_) -> gr.Box:
         ...
 
     @abstractmethod
-    def execute(self, input):
+    def execute(self, *args, vars_in_scope: Dict[str, Any]):
         ...
 
 
@@ -85,8 +94,13 @@ class AITask(TaskComponent):
                 )
             return gr_component
 
-    def execute(self, prompt: str) -> str:
-        return ai.llm.next([{"role": "user", "content": prompt}])
+    @property
+    def inputs(self) -> List[gr.Textbox]:
+        return [self.input]
+
+    def execute(self, prompt: str, vars_in_scope: Dict[str, Any]) -> str:
+        formatted_prompt = prompt.format(**vars_in_scope)
+        return ai.llm.next([{"role": "user", "content": formatted_prompt}])
 
 
 class CodeTask(TaskComponent):
@@ -119,9 +133,8 @@ class CodeTask(TaskComponent):
                         error_message = gr.HighlightedText(value=None, visible=False)
 
                     self.input = gr.Textbox(
+                        label="Input to the code",
                         interactive=True,
-                        placeholder="Input to the code",
-                        show_label=False,
                     )
                 with gr.Column():
                     self.output = gr.Textbox(
@@ -158,6 +171,7 @@ class CodeTask(TaskComponent):
                 error_message,
             )
 
+        print(f"Generating code.")
         try:
             raw_prompt_output = ai.llm.next(
                 [
@@ -168,7 +182,7 @@ class CodeTask(TaskComponent):
                         {code_prompt}
 
                         Do't save anything to disk. Instead, the function should return the necessary data.
-                        Include all the necessary imports but put them inside the function itself.
+                        Include all the necessary imports.
                         """,
                     }
                 ],
@@ -187,13 +201,13 @@ class CodeTask(TaskComponent):
                         The following text should have a python function with some imports that might need to be installed:
                         {raw_prompt_output}
 
-                        Extract all the python packages, nothing else. Print them in a single python list what can be used with eval().
+                        Extract all the python packages, nothing else. Print them in a single python list that can be used with eval().
                         """,
                             f"""
-                        The following text should have a python function:
+                        The following text should have a python function and some imports:
                         {raw_prompt_output}
 
-                        Exclusively extract the function, nothing else.
+                        Exclusively extract the function and the imports, nothing else, so that it can be used with exec().
                         """,
                         ],
                     )
@@ -209,15 +223,31 @@ class CodeTask(TaskComponent):
             error_message,
         )
 
-    def execute(self, url: str) -> str:
-        ...
+    @property
+    def inputs(self) -> List[gr.Textbox]:
+        return [self.packages, self.function, self.input]
+
+    def execute(
+        self, packages: str, function: str, input: str, vars_in_scope: Dict[str, Any]
+    ):
+        import subprocess
+        import sys
+
+        for p in eval(packages):
+            subprocess.check_call([sys.executable, "-m", "pip", "install", p])
+            __import__(p)
+        exec(function, locals())
+        self._toolkit_func = list(locals().items())[-1][1]
+
+        formatted_input = input.format(**vars_in_scope)
+        return self._toolkit_func(formatted_input)
 
 
 class Task(Component):
     available_tasks = [AITask, CodeTask]
     vname = "t"
 
-    def __init__(self, id_: int, visible: bool = False):
+    def __init__(self, id_: int):
         super().__init__(id_)
         self._inner_tasks = [t() for t in self.available_tasks]
         self.gr_component: gr.Box
@@ -245,16 +275,22 @@ class Task(Component):
         update[idx] = gr.Box.update(visible=True)
         return update
 
+    @property
     def inputs(self) -> List[gr.Textbox]:
-        return [t.input for t in self._inner_tasks]
+        return [i for t in self._inner_tasks for i in t.inputs]
 
+    @property
     def outputs(self) -> List[gr.Textbox]:
         return [t.output for t in self._inner_tasks]
 
-    def execute(self, active_index, input):
+    @property
+    def inner_n_inputs(self) -> List[int]:
+        return [t.n_inputs for t in self._inner_tasks]
+
+    def execute(self, active_index, *args, vars_in_scope: Dict[str, Any]):
         inner_task = self._inner_tasks[active_index]
         print(f"Executing {self._source}: {self._id}")
-        return inner_task.execute(input)
+        return inner_task.execute(*args, vars_in_scope)
 
 
 MAX_TASKS = 10