Merge pull request #181 from biggraph/darabos-multi-output

examples/Multi-output demo.lynxkite.json

@@ -0,0 +1,290 @@
+{
+  "edges": [
+    {
+      "id": "Multi-output example 1 one View tables 1 bundle",
+      "source": "Multi-output example 1",
+      "sourceHandle": "one",
+      "target": "View tables 1",
+      "targetHandle": "bundle"
+    },
+    {
+      "id": "Multi-output example 1 two View tables 2 bundle",
+      "source": "Multi-output example 1",
+      "sourceHandle": "two",
+      "target": "View tables 2",
+      "targetHandle": "bundle"
+    }
+  ],
+  "env": "LynxKite Graph Analytics",
+  "nodes": [
+    {
+      "data": {
+        "__execution_delay": 0.0,
+        "collapsed": false,
+        "display": null,
+        "error": null,
+        "input_metadata": [],
+        "meta": {
+          "color": "orange",
+          "doc": [
+            {
+              "kind": "text",
+              "value": "Returns two outputs. Also demonstrates Numpy-style docstrings."
+            },
+            {
+              "kind": "parameters",
+              "value": [
+                {
+                  "annotation": "int",
+                  "description": "Number of elements in output \"one\".",
+                  "name": "a_limit"
+                },
+                {
+                  "annotation": "int",
+                  "description": "Number of elements in output \"two\".",
+                  "name": "b_limit"
+                }
+              ]
+            },
+            {
+              "kind": "returns",
+              "value": [
+                {
+                  "annotation": "A dict with two DataFrames in it.",
+                  "description": "",
+                  "name": ""
+                }
+              ]
+            }
+          ],
+          "inputs": [],
+          "name": "Multi-output example",
+          "outputs": [
+            {
+              "name": "one",
+              "position": "right",
+              "type": {
+                "type": "None"
+              }
+            },
+            {
+              "name": "two",
+              "position": "right",
+              "type": {
+                "type": "None"
+              }
+            }
+          ],
+          "params": [
+            {
+              "default": 4,
+              "name": "a_limit",
+              "type": {
+                "type": "<class 'int'>"
+              }
+            },
+            {
+              "default": 10,
+              "name": "b_limit",
+              "type": {
+                "type": "<class 'int'>"
+              }
+            }
+          ],
+          "type": "basic"
+        },
+        "params": {
+          "a_limit": "2",
+          "b_limit": "10"
+        },
+        "status": "done",
+        "title": "Multi-output example"
+      },
+      "dragHandle": ".bg-primary",
+      "height": 275.0,
+      "id": "Multi-output example 1",
+      "position": {
+        "x": 86.0,
+        "y": 33.0
+      },
+      "type": "basic",
+      "width": 200.0
+    },
+    {
+      "data": {
+        "display": {
+          "dataframes": {
+            "df": {
+              "columns": [
+                "a"
+              ],
+              "data": [
+                [
+                  0
+                ],
+                [
+                  1
+                ]
+              ]
+            }
+          },
+          "other": {},
+          "relations": []
+        },
+        "error": null,
+        "input_metadata": [
+          {
+            "dataframes": {
+              "df": {
+                "columns": [
+                  "a"
+                ]
+              }
+            },
+            "other": {},
+            "relations": []
+          }
+        ],
+        "meta": {
+          "color": "orange",
+          "doc": null,
+          "inputs": [
+            {
+              "name": "bundle",
+              "position": "left",
+              "type": {
+                "type": "<class 'lynxkite_graph_analytics.core.Bundle'>"
+              }
+            }
+          ],
+          "name": "View tables",
+          "outputs": [],
+          "params": [
+            {
+              "default": 100,
+              "name": "limit",
+              "type": {
+                "type": "<class 'int'>"
+              }
+            }
+          ],
+          "type": "table_view"
+        },
+        "params": {
+          "limit": 100.0
+        },
+        "status": "done",
+        "title": "View tables"
+      },
+      "dragHandle": ".bg-primary",
+      "height": 200.0,
+      "id": "View tables 1",
+      "position": {
+        "x": 485.0,
+        "y": -31.0
+      },
+      "type": "table_view",
+      "width": 200.0
+    },
+    {
+      "data": {
+        "display": {
+          "dataframes": {
+            "df": {
+              "columns": [
+                "b"
+              ],
+              "data": [
+                [
+                  0
+                ],
+                [
+                  1
+                ],
+                [
+                  2
+                ],
+                [
+                  3
+                ],
+                [
+                  4
+                ],
+                [
+                  5
+                ],
+                [
+                  6
+                ],
+                [
+                  7
+                ],
+                [
+                  8
+                ],
+                [
+                  9
+                ]
+              ]
+            }
+          },
+          "other": {},
+          "relations": []
+        },
+        "error": null,
+        "input_metadata": [
+          {
+            "dataframes": {
+              "df": {
+                "columns": [
+                  "b"
+                ]
+              }
+            },
+            "other": {},
+            "relations": []
+          }
+        ],
+        "meta": {
+          "color": "orange",
+          "doc": null,
+          "inputs": [
+            {
+              "name": "bundle",
+              "position": "left",
+              "type": {
+                "type": "<class 'lynxkite_graph_analytics.core.Bundle'>"
+              }
+            }
+          ],
+          "name": "View tables",
+          "outputs": [],
+          "params": [
+            {
+              "default": 100,
+              "name": "limit",
+              "type": {
+                "type": "<class 'int'>"
+              }
+            }
+          ],
+          "type": "table_view"
+        },
+        "params": {
+          "limit": 100.0
+        },
+        "status": "done",
+        "title": "View tables"
+      },
+      "dragHandle": ".bg-primary",
+      "height": 215.0,
+      "id": "View tables 2",
+      "position": {
+        "x": 480.0,
+        "y": 191.0
+      },
+      "type": "table_view",
+      "width": 225.0
+    }
+  ]
+}

examples/multi_output_demo.py

@@ -0,0 +1,24 @@
+from lynxkite.core.ops import op
+import pandas as pd
+
+
+@op("LynxKite Graph Analytics", "Multi-output example", outputs=["one", "two"])
+def multi_output(*, a_limit=4, b_limit=10):
+    """
+    Returns two outputs. Also demonstrates Numpy-style docstrings.
+
+    Parameters
+    ----------
+    a_limit : int
+        Number of elements in output "one".
+    b_limit : int
+        Number of elements in output "two".
+
+    Returns
+    -------
+    A dict with two DataFrames in it.
+    """
+    return {
+        "one": pd.DataFrame({"a": range(a_limit)}),
+        "two": pd.DataFrame({"b": range(b_limit)}),
+    }

lynxkite-app/web/src/index.css

@@ -100,6 +100,15 @@ body {
     font-size: 16px;
     font-weight: initial;
     max-width: 300px;
+
+    p {
+      margin-top: 1em;
+      line-height: normal;
+    }
+
+    p:first-child {
+      margin-top: 0;
+    }
   }
 
   .expanded .lynxkite-node {

lynxkite-app/web/src/workspace/nodes/LynxKiteNode.tsx

@@ -42,10 +42,12 @@ function getHandles(inputs: any[], outputs: any[]) {
     e.index = counts[e.position];
     counts[e.position]++;
   }
+  const simpleHorizontal =
+    counts.top === 0 && counts.bottom === 0 && counts.left <= 1 && counts.right <= 1;
+  const simpleVertical =
+    counts.left === 0 && counts.right === 0 && counts.top <= 1 && counts.bottom <= 1;
   for (const e of handles) {
     e.offsetPercentage = (100 * (e.index + 1)) / (counts[e.position] + 1);
-    const simpleHorizontal = counts.top === 0 && counts.bottom === 0 && handles.length <= 2;
-    const simpleVertical = counts.left === 0 && counts.right === 0 && handles.length <= 2;
     e.showLabel = !simpleHorizontal && !simpleVertical;
   }
   return handles;

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

@@ -440,5 +440,8 @@ def get_doc(func):
         return func.__doc__
     if func.__doc__ is None:
         return None
-    doc = griffe.Docstring(func.__doc__).parse("google")
+    if "----" in func.__doc__:
+        doc = griffe.Docstring(func.__doc__).parse("numpy")
+    else:
+        doc = griffe.Docstring(func.__doc__).parse("google")
     return json.loads(json.dumps(doc, cls=griffe.JSONEncoder))

lynxkite-graph-analytics/src/lynxkite_graph_analytics/core.py

@@ -161,11 +161,15 @@ def disambiguate_edges(ws: workspace.Workspace):
         seen.add((edge.target, edge.targetHandle))
 
 
+# Outputs are tracked by node ID and output ID.
+Outputs = dict[tuple[str, str], typing.Any]
+
+
 @ops.register_executor(ENV)
 async def execute(ws: workspace.Workspace):
-    catalog: dict[str, ops.Op] = ops.CATALOGS[ws.env]
+    catalog = ops.CATALOGS[ws.env]
     disambiguate_edges(ws)
-    outputs = {}
+    outputs: Outputs = {}
     nodes = {node.id: node for node in ws.nodes}
     todo = set(nodes.keys())
     progress = True
@@ -173,8 +177,12 @@ async def execute(ws: workspace.Workspace):
         progress = False
         for id in list(todo):
             node = nodes[id]
-            input_nodes = [edge.source for edge in ws.edges if edge.target == id]
-            if all(input in outputs for input in input_nodes):
+            inputs_done = [
+                (edge.source, edge.sourceHandle) in outputs
+                for edge in ws.edges
+                if edge.target == id
+            ]
+            if all(inputs_done):
                 # All inputs for this node are ready, we can compute the output.
                 todo.remove(id)
                 progress = True
@@ -187,7 +195,9 @@ async def await_if_needed(obj):
     return obj
 
 
-async def _execute_node(node, ws, catalog, outputs):
+async def _execute_node(
+    node: workspace.WorkspaceNode, ws: workspace.Workspace, catalog: ops.Catalog, outputs: Outputs
+):
     params = {**node.data.params}
     op = catalog.get(node.data.title)
     if not op:
@@ -196,7 +206,9 @@ async def _execute_node(node, ws, catalog, outputs):
     node.publish_started()
     # TODO: Handle multi-inputs.
     input_map = {
-        edge.targetHandle: outputs[edge.source] for edge in ws.edges if edge.target == node.id
+        edge.targetHandle: outputs[edge.source, edge.sourceHandle]
+        for edge in ws.edges
+        if edge.target == node.id
     }
     # Convert inputs types to match operation signature.
     try:
@@ -228,8 +240,12 @@ async def _execute_node(node, ws, catalog, outputs):
             traceback.print_exc()
         result = ops.Result(error=str(e))
     result.input_metadata = [_get_metadata(i) for i in inputs]
-    if result.output is not None:
-        outputs[node.id] = result.output
+    if isinstance(result.output, dict):
+        for k, v in result.output.items():
+            outputs[node.id, k] = v
+    elif result.output is not None:
+        [k] = op.outputs
+        outputs[node.id, k.name] = result.output
     node.publish_result(result)