Try automatically creating an op for every NetworkX function.

server/basic_ops.py

@@ -15,11 +15,9 @@ def create_scale_free_graph(*, nodes: int = 10):
   return nx.scale_free_graph(nodes)
 
 @ops.op("Compute PageRank")
+@ops.nx_node_attribute_func('pagerank')
 def compute_pagerank(graph: nx.Graph, *, damping=0.85, iterations=3):
-  graph = graph.copy()
-  pr = nx.pagerank(graph, alpha=damping, max_iter=iterations)
-  nx.set_node_attributes(graph, pr, 'pagerank')
-  return graph
+  return nx.pagerank(graph, alpha=damping, max_iter=iterations)
 
 
 def _map_color(value):
@@ -28,8 +26,8 @@ def _map_color(value):
   rgba = cmap(value)
   return ['#{:02x}{:02x}{:02x}'.format(int(r*255), int(g*255), int(b*255)) for r, g, b in rgba[:, :3]]
 
-@ops.op("Visualize graph")
-def visualize_graph(graph: ops.Bundle, *, color_nodes_by: 'node_attribute' = None) -> 'graph_view':
+@ops.op("Visualize graph", view="graph_view")
+def visualize_graph(graph: ops.Bundle, *, color_nodes_by: 'node_attribute' = None):
   nodes = graph.dfs['nodes'].copy()
   node_attributes = sorted(nodes.columns)
   if color_nodes_by:
@@ -53,8 +51,8 @@ def visualize_graph(graph: ops.Bundle, *, color_nodes_by: 'node_attribute' = Non
   }
   return v
 
-@ops.op("View tables")
-def view_tables(dfs: ops.Bundle) -> 'table_view':
+@ops.op("View tables", view="table_view")
+def view_tables(dfs: ops.Bundle):
   v = {
     'dataframes': { name: {
       'columns': [str(c) for c in df.columns],

server/main.py

@@ -7,6 +7,7 @@ import pydantic
 import traceback
 from . import ops
 from . import basic_ops
+from . import networkx_ops
 
 class BaseConfig(pydantic.BaseModel):
     model_config = pydantic.ConfigDict(

server/networkx_ops.py

@@ -0,0 +1,44 @@
+"""Automatically wraps all NetworkX functions as LynxKite operations."""
+from . import ops
+import functools
+import inspect
+import networkx as nx
+
+
+def wrapped(func):
+  @functools.wraps(func)
+  def wrapper(*args, **kwargs):
+    for k, v in kwargs.items():
+      if v == 'None':
+        kwargs[k] = None
+    res = func(*args, **kwargs)
+    if isinstance(res, nx.Graph):
+      return res
+    # Otherwise it's a node attribute.
+    graph = args[0].copy()
+    nx.set_node_attributes(graph, 'attr', name)
+    return graph
+  return wrapper
+
+
+for (name, func) in nx.__dict__.items():
+  if type(func) == nx.utils.backends._dispatch:
+    sig = inspect.signature(func)
+    inputs = {'G': nx.Graph} if 'G' in sig.parameters else {}
+    params = {
+      name:
+        str(param.default)
+        if type(param.default) in [str, int, float]
+        else None
+      for name, param in sig.parameters.items()
+      if name not in ['G', 'backend', 'backend_kwargs']}
+    for k, v in params.items():
+      if sig.parameters[k].annotation is inspect._empty and v is None:
+        # No annotation, no default — we must guess the type.
+        if len(k) == 1:
+          params[k] = 1
+    if name == 'ladder_graph':
+      print(params)
+    name = "NX › " + name.replace('_', ' ').title()
+    op = ops.Op(wrapped(func), name, params=params, inputs=inputs, outputs={'output': 'yes'}, type='basic')
+    ops.ALL_OPS[name] = op

server/ops.py

@@ -1,5 +1,6 @@
 '''API for implementing LynxKite operations.'''
 import dataclasses
+import functools
 import inspect
 import networkx as nx
 import pandas as pd
@@ -22,7 +23,7 @@ class Op:
       if p in self.params:
         t = sig.parameters[p].annotation
         if t is inspect._empty:
-          t = type(sig.parameters[p].default)
+          t = type(self.params[p])
         if t == int:
           params[p] = int(params[p])
         elif t == float:
@@ -56,7 +57,8 @@ class Bundle:
   @classmethod
   def from_nx(cls, graph: nx.Graph):
     edges = nx.to_pandas_edgelist(graph)
-    nodes = pd.DataFrame.from_dict(dict(graph.nodes(data=True)), orient='index')
+    d = dict(graph.nodes(data=True))
+    nodes = pd.DataFrame(d.values(), index=d.keys())
     nodes['id'] = nodes.index
     return cls(
       dfs={'edges': edges, 'nodes': nodes},
@@ -79,10 +81,22 @@ class Bundle:
     return graph
 
 
-def op(name):
+def nx_node_attribute_func(name):
+  '''Decorator for wrapping a function that adds a NetworkX node attribute.'''
+  def decorator(func):
+    @functools.wraps(func)
+    def wrapper(graph: nx.Graph, **kwargs):
+      graph = graph.copy()
+      attr = func(graph, **kwargs)
+      nx.set_node_attributes(graph, attr, name)
+      return graph
+    return wrapper
+  return decorator
+
+
+def op(name, *, view='basic'):
   '''Decorator for defining an operation.'''
   def decorator(func):
-    type = func.__annotations__.get('return') or 'basic'
     sig = inspect.signature(func)
     # Positional arguments are inputs.
     inputs = {
@@ -93,8 +107,8 @@ def op(name):
       name: param.default if param.default is not inspect._empty else None
       for name, param in sig.parameters.items()
       if param.kind == param.KEYWORD_ONLY}
-    outputs = {'output': 'yes'} if type == 'basic' else {} # Maybe more fancy later.
-    op = Op(func, name, params=params, inputs=inputs, outputs=outputs, type=type)
+    outputs = {'output': 'yes'} if view == 'basic' else {} # Maybe more fancy later.
+    op = Op(func, name, params=params, inputs=inputs, outputs=outputs, type=view)
     ALL_OPS[name] = op
     return func
   return decorator

web/src/LynxKiteNode.svelte

@@ -60,8 +60,8 @@
   .lynxkite-node {
     box-shadow: 0px 5px 50px 0px rgba(0, 0, 0, 0.3);
     background: white;
-    min-width: 170px;
-    max-width: 300px;
+    min-width: 200px;
+    max-width: 400px;
     max-height: 400px;
     overflow-y: auto;
     border-radius: 1px;