Support optional inputs in simple executor.

lynxkite-core/pyproject.toml

@@ -11,3 +11,6 @@ dependencies = [
 dev = [
     "pytest",
 ]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"

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

@@ -42,7 +42,11 @@ async def execute(ws: workspace.Workspace, catalog: ops.Catalog):
                 if i.name in edges and edges[i.name] in outputs:
                     inputs.append(outputs[edges[i.name]])
                 else:
-                    missing.append(i.name)
+                    opt_type = ops.get_optional_type(i.type)
+                    if opt_type is not None:
+                        inputs.append(None)
+                    else:
+                        missing.append(i.name)
             if missing:
                 node.publish_error(f"Missing input: {', '.join(missing)}")
                 continue

lynxkite-core/src/lynxkite/core/ops.py

@@ -149,6 +149,16 @@ def basic_outputs(*names):
     return {name: Output(name=name, type=None) for name in names}
 
 
+def get_optional_type(type):
+    """For a type like `int | None`, returns `int`. Returns `None` otherwise."""
+    if isinstance(type, types.UnionType):
+        match type.__args__:
+            case (types.NoneType, type):
+                return type
+            case (type, types.NoneType):
+                return type
+
+
 def _param_to_type(name, value, type):
     value = value or ""
     if type is int:
@@ -160,12 +170,9 @@ def _param_to_type(name, value, type):
     if isinstance(type, enum.EnumMeta):
         assert value in type.__members__, f"{value} is not an option for {name}."
         return type[value]
-    if isinstance(type, types.UnionType):
-        match type.__args__:
-            case (types.NoneType, type):
-                return None if value == "" else _param_to_type(name, value, type)
-            case (type, types.NoneType):
-                return None if value == "" else _param_to_type(name, value, type)
+    opt_type = get_optional_type(type)
+    if opt_type:
+        return None if value == "" else _param_to_type(name, value, opt_type)
     if isinstance(type, typeof) and issubclass(type, pydantic.BaseModel):
         try:
             return type.model_validate_json(value)

lynxkite-core/src/lynxkite/core/workspace.py

@@ -125,7 +125,7 @@ class Workspace(BaseConfig):
         return self.env in ops.EXECUTORS
 
     async def execute(self):
-        await ops.EXECUTORS[self.env](self)
+        return await ops.EXECUTORS[self.env](self)
 
     def save(self, path: str):
         """Persist the workspace to a local file in JSON format."""
@@ -201,3 +201,35 @@ class Workspace(BaseConfig):
                 if "data" not in nc:
                     nc["data"] = pycrdt.Map()
                 np._crdt = nc
+
+    def add_node(self, func):
+        """For convenience in e.g. tests."""
+        node = WorkspaceNode(
+            id=func.__name__,
+            type=func.__op__.type,
+            data=WorkspaceNodeData(
+                title=func.__op__.name,
+                params={},
+                display=None,
+                input_metadata=None,
+                error=None,
+                status=NodeStatus.planned,
+            ),
+            position=Position(x=0, y=0),
+        )
+        self.nodes.append(node)
+        return node
+
+    def add_edge(
+        self, source: WorkspaceNode, sourceHandle: str, target: WorkspaceNode, targetHandle: str
+    ):
+        """For convenience in e.g. tests."""
+        edge = WorkspaceEdge(
+            id=f"{source.id} {sourceHandle} to {target.id} {targetHandle}",
+            source=source.id,
+            target=target.id,
+            sourceHandle=sourceHandle,
+            targetHandle=targetHandle,
+        )
+        self.edges.append(edge)
+        return edge

lynxkite-core/tests/test_simple.py

@@ -0,0 +1,26 @@
+from lynxkite.core import ops, workspace
+from lynxkite.core.executors import simple
+
+
+async def test_optional_inputs():
+    @ops.op("test", "one")
+    def one():
+        return 1
+
+    @ops.op("test", "maybe add")
+    def maybe_add(a: int, b: int | None = None):
+        return a + (b or 0)
+
+    assert maybe_add.__op__.inputs == [
+        ops.Input(name="a", type=int, position="left"),
+        ops.Input(name="b", type=int | None, position="left"),
+    ]
+    simple.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, "output"] == 1