Support optional inputs in one-by-one executor.

lynxkite-core/src/lynxkite/core/executors/one_by_one.py

@@ -131,12 +131,22 @@ async def execute(ws: workspace.Workspace, catalog: ops.Catalog, cache=None):
             for task in ts:
                 try:
                     inputs = []
+                    missing = []
                     for i in op.inputs:
                         if i.position.is_vertical():
-                            assert (n, i.name) in batch_inputs, f"{i.name} is missing"
-                            inputs.append(batch_inputs[(n, i.name)])
+                            if (n, i.name) in batch_inputs:
+                                inputs.append(batch_inputs[(n, i.name)])
+                            else:
+                                opt_type = ops.get_optional_type(i.type)
+                                if opt_type is not None:
+                                    inputs.append(None)
+                                else:
+                                    missing.append(i.name)
                         else:
                             inputs.append(task)
+                    if missing:
+                        node.publish_error(f"Missing input: {', '.join(missing)}")
+                        break
                     if cache is not None:
                         key = make_cache_key((inputs, params))
                         if key not in cache:

lynxkite-core/tests/test_one_by_one.py

@@ -0,0 +1,27 @@
+from lynxkite.core import ops, workspace
+from lynxkite.core.executors import one_by_one
+
+
+async def test_optional_inputs():
+    @ops.op("test", "one")
+    def one():
+        return 1
+
+    @ops.input_position(a="bottom", b="bottom")
+    @ops.op("test", "maybe add")
+    def maybe_add(a: list[int], b: list[int] | None = None):
+        return [a + b for a, b in zip(a, b)] if b else a
+
+    assert maybe_add.__op__.inputs == [
+        ops.Input(name="a", type=list[int], position="bottom"),
+        ops.Input(name="b", type=list[int] | None, position="bottom"),
+    ]
+    one_by_one.register("test")
+    ws = workspace.Workspace(env="test", nodes=[], edges=[])
+    a = ws.add_node(one)
+    b = ws.add_node(maybe_add)
+    outputs = await ws.execute()
+    assert b.data.error == "Missing input: a"
+    ws.add_edge(a, "output", b, "a")
+    outputs = await ws.execute()
+    assert outputs[b.id].last_result == [1]