Added variables to scope

app.py

@@ -1,72 +1,58 @@
-from typing import NamedTuple, Optional, Type, Union
+from typing import Dict, Optional, Union
 
 import gradio as gr
 
 import ai
-from utils.io import print_system
 
 
 MAX_INPUTS = 10
-MAX_TASKS = 50
+MAX_TASKS = 10
 
 
 class Input:
-    def render(self, visible: bool) -> gr.Row:
-        with gr.Row(visible=visible) as gr_component:
-            self.output_name = gr.Textbox(
-                label="Input name (can be referenced with {})",
-                interactive=True,
-                placeholder="Variable name",
-            )
-            self.output = gr.Textbox(
-                label="Input value",
-                interactive=True,
-                placeholder="Variable value",
-            )
-            return gr_component
+    vname = "v"
+
+    def render(self, id_: int, visible: bool) -> gr.Textbox:
+        self.output = gr.Textbox(
+            label=f"Input: {{{self.vname}{id_}}}",
+            interactive=True,
+            placeholder="Variable value",
+            visible=visible,
+        )
+        return self.output
 
     def execute(self) -> None:
         pass
 
 
 class AITask:
-    @property
-    def vars(self):
-        return [self.prompt]
+    vname = "t"
 
-    def render(self, visible: bool) -> gr.Box:
+    def render(self, id_: int, visible: bool) -> gr.Box:
         with gr.Box(visible=visible) as gr_component:
             gr.Markdown(f"AI task")
             with gr.Row():
-                with gr.Column():
-                    self.prompt = gr.Textbox(
-                        label="Instructions",
-                        lines=13,
-                        interactive=True,
-                        placeholder="What is the AI assistant meant to do?",
-                    )
-                with gr.Column():
-                    self.output_name = gr.Textbox(
-                        label="Output name (can be referenced with {})",
-                        interactive=True,
-                        placeholder="Variable name",
-                    )
-                    self.output = gr.Textbox(
-                        show_label=False,
-                        lines=10,
-                        interactive=False,
-                    )
+                self.prompt = gr.Textbox(
+                    label="Instructions",
+                    lines=10,
+                    interactive=True,
+                    placeholder="What is the AI assistant meant to do?",
+                )
+                self.output = gr.Textbox(
+                    label=f"Output: {{{self.vname}{id_}}}",
+                    lines=10,
+                    interactive=False,
+                )
             return gr_component
 
-    def execute(self, prompt: str) -> Optional[str]:
+    def execute(self, prompt: str, prompt_vars: Dict[str, str]) -> Optional[str]:
         if prompt:
-            return ai.llm.next([{"role": "user", "content": prompt}])
+            formatted_prompt = prompt.format(**prompt_vars)
+            return ai.llm.next([{"role": "user", "content": formatted_prompt}])
 
 
 class Component:
-    def __init__(
-        self, id_: float, internal: Union[Input, AITask], visible: bool = False
-    ):
+    def __init__(self, id_: int, internal: Union[Input, AITask], visible: bool = False):
         # Internal state
         self._id = id_
         self.internal = internal
@@ -75,45 +61,40 @@ class Component:
 
         # Gradio state
         self.component_id: gr.Number
-        self.source: gr.Textbox
         self.visible: gr.Number
         self.gr_component = gr.Box
-        self.output_name: gr.Textbox
         self.output: gr.Textbox
 
     def render(self) -> None:
         self.component_id = gr.Number(value=self._id, visible=False)
-        self.source = gr.Textbox(value=self._source, visible=False)
         self.visible = gr.Number(int(self._initial_visibility), visible=False)
-        self.gr_component = self.internal.render(self._initial_visibility)
-        self.output_name = self.internal.output_name
+        self.gr_component = self.internal.render(self._id, self._initial_visibility)
         self.output = self.internal.output
 
     def execute(self, *args):
-        print_system(f"Executing component :: {self._source}.{self._id}")
+        print(f"Executing component :: {self._source}.{self._id}")
         return self.internal.execute(*args)
 
 
-class Variable(NamedTuple):
-    source: Type[Union[Input, AITask]]
-    id_: int
-    name: str
-    value: str
-
-
-all_inputs = {float(i): Component(i, Input()) for i in range(MAX_INPUTS)}
-all_tasks = {float(i): Component(i, AITask()) for i in range(MAX_TASKS)}
+all_inputs = {i: Component(i, Input()) for i in range(MAX_INPUTS)}
+all_tasks = {i: Component(i, AITask()) for i in range(MAX_TASKS)}
 
 all_inputs[0]._initial_visibility = True
 all_tasks[0]._initial_visibility = True
 
 
+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 add_input(*visibility):
     for i, visible in enumerate(visibility, 1):
         if not bool(visible):
             return (
-                [gr.Row.update(visible=True)] * i
-                + [gr.Row.update(visible=False)] * (MAX_INPUTS - i)
+                [gr.Textbox.update(visible=True)] * i
+                + [gr.Textbox.update(visible=False, value="")] * (MAX_INPUTS - i)
                 + [1] * i
                 + [0] * (MAX_INPUTS - i)
             )
@@ -123,8 +104,8 @@ def remove_input(*visibility):
     for i, visible in reversed(list(enumerate(visibility, 1))):
         if bool(visible):
             return (
-                [gr.Row.update(visible=True)] * (i - 1)
-                + [gr.Row.update(visible=False)] * (MAX_INPUTS - i + 1)
+                [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)
             )
@@ -152,9 +133,19 @@ def remove_task(*visibility):
             )
 
 
-def execute_task(id_: float, prompt: str):
+def execute_task(id_: int, prompt: str, *vars):
+    inputs = vars[:MAX_INPUTS]
+    task_outputs = vars[MAX_INPUTS:]
+
+    prompt_vars = {
+        f"{Input.vname}{i}": input_ for i, input_ in enumerate(inputs) if input_
+    }
+    prompt_vars.update(
+        {f"{AITask.vname}{i}": task for i, task in enumerate(task_outputs)}
+    )
+
     if prompt:
-        return all_tasks[id_].execute(prompt)
+        return all_tasks[id_].execute(prompt, prompt_vars)
 
 
 with gr.Blocks() as demo:
@@ -181,7 +172,7 @@ with gr.Blocks() as demo:
         add_task_btn = gr.Button("Add task")
         remove_task_btn = gr.Button("Remove task")
 
-    # Layout editing
+    # Edit layout
     add_input_btn.click(
         add_input,
         inputs=[i.visible for i in all_inputs.values()],
@@ -210,13 +201,13 @@ with gr.Blocks() as demo:
     # Sequential execution
     execution_event = execute_btn.click(
         execute_task,
-        inputs=[all_tasks[0].component_id, all_tasks[0].internal.prompt],  # type: ignore
+        inputs=[all_tasks[0].component_id, all_tasks[0].internal.prompt] + _get_all_vars_up_to(0),  # type: ignore
         outputs=[all_tasks[0].output],
     )
-    for task in list(all_tasks.values())[1:]:
+    for i, task in list(all_tasks.items())[1:]:
         execution_event = execution_event.then(
             execute_task,
-            inputs=[task.component_id, task.internal.prompt],  # type: ignore
+            inputs=[task.component_id, task.internal.prompt] + _get_all_vars_up_to(i),  # type: ignore
             outputs=[task.output],
         )
 

utils/io.py

@@ -1,12 +0,0 @@
-def print_system(message) -> str:
-    print(f"\033[0;0m{message}")
-    return message
-
-
-def print_assistant(message) -> str:
-    print(f"\033[92m{message}")
-    return message
-
-
-def user_input(message: str = "") -> str:
-    return input(f"\033[1;34m{message}")