Merge branch 'dev' into playwright

Author: vedansh-5

README.md

@@ -297,6 +297,7 @@ The following API is currently supported:
 - [`vis.contour`](#viscontour)  : contour plots
 - [`vis.quiver`](#visquiver)   : quiver plots
 - [`vis.mesh`](#vismesh)     : mesh plots
+- [`vis.sankey`](#vissankey)   : sankey (flow) diagrams
 - [`vis.dual_axis_lines`](#visdual_axis_lines)     : double y axis line plots
 - [`vis.graph`](#visgraph)    : network graphs
 
@@ -696,6 +697,27 @@ The following `opts` are supported:
 - `opts.opacity`: opacity of polygons (`number` between 0 and 1)
 - `opts.layoutopts`  : `dict` of any additional options that the graph backend accepts for a layout. For example `layoutopts = {'plotly': {'legend': {'x':0, 'y':0}}}`.
 
+#### vis.sankey
+This function draws a Sankey (flow) diagram. Flows are defined by three
+equal-length arrays:
+
+- `source`: source node index of each link (`N` array of ints)
+- `target`: target node index of each link (`N` array of ints)
+- `value` : magnitude of each link (`N` array of non-negative numbers)
+
+`labels` is an optional list of node names. If omitted, nodes are referenced
+by their index alone.
+
+The following `opts` are supported:
+
+- `opts.labels`     : list of node labels (alternative to the `labels` arg)
+- `opts.pad`        : node padding in px (`number`; default = 15)
+- `opts.thickness`  : node thickness in px (`number`; default = 20)
+- `opts.orientation`: `'h'` (default) or `'v'`
+- `opts.nodecolor`  : node color(s) (`string` or list of strings)
+- `opts.linkcolor`  : link color(s) (`string` or list of strings)
+- `opts.layoutopts` : `dict` of any additional options that the graph backend accepts for a layout.
+
 #### vis.dual_axis_lines
 This function will create a line plot using plotly with different Y-Axis.
 

cypress/integration/pane.js

@@ -14,6 +14,7 @@ const basic_examples = [
   ['Violin Plot', 'plot_violin_basic'],
   // ["Mesh Plot", "plot_special_mesh"], // disabled due to webgl
   ['Graph Plot', 'plot_special_graph'],
+  ['Sankey Plot', 'plot_special_sankey'],
   ['Matplotlib Plot', 'misc_plot_matplot'],
   ['Latex Plot', 'misc_plot_latex'],
   ['Video Pane', 'misc_video_tensor'],

example/components/plot_special.py

@@ -59,3 +59,20 @@ def plot_special_graph(viz, env, args):
         },
         env=env,
     )
+
+
+# sankey (flow) diagram
+def plot_special_sankey(viz, env, args):
+    title = args[0] if len(args) > 0 else None
+    labels = ["raw", "cleaned", "labeled", "train", "val", "test"]
+    source = [0, 1, 2, 2, 2]
+    target = [1, 2, 3, 4, 5]
+    value = [1000, 900, 720, 144, 36]
+    viz.sankey(
+        source=source,
+        target=target,
+        value=value,
+        labels=labels,
+        opts=dict(title=title),
+        env=env,
+    )

example/demo.py

@@ -80,6 +80,7 @@
     plot_special_mesh,
     plot_special_sunburst,
     plot_special_graph,
+    plot_special_sankey,
 )
 from components.properties import properties_basic, properties_callbacks
 from components.misc import (
@@ -188,6 +189,7 @@ def run_demo(viz, env, args):
     plot_special_mesh(viz, env, args)
     plot_special_sunburst(viz, env, args)
     plot_special_graph(viz, env, args)
+    plot_special_sankey(viz, env, args)
 
     # ============ #
     # violin plots #

js/main.js

@@ -442,21 +442,26 @@ const App = () => {
     });
 
     setStoreMeta((prev) => {
-      const layoutLists = new Map(storeMeta.layoutLists);
+      const layoutLists = new Map(prev.layoutLists);
       layoutLists.delete(env2delete);
-      let EnvIds = selection.envIDs.filter((env) => env !== env2delete);
+      let EnvIds = prev.envList.filter((env) => env !== env2delete);
       return {
         ...prev,
         envList: EnvIds,
         layoutLists: layoutLists,
       };
     });
 
-    setStoreData((prev) => ({
-      ...prev,
-      panes: {},
-      layout: [],
-    }));
+    setStoreData((prev) => {
+      if (selection.envIDs.includes(env2delete)) {
+        return {
+          ...prev,
+          panes: {},
+          layout: [],
+        };
+      }
+      return prev;
+    });
 
     sendEnvDelete(env2delete, previousEnv);
   };

js/panes/PlotPane.js

@@ -197,8 +197,7 @@ var PlotPane = (props) => {
         layout.title = { text: layout.title };
       }
       if (layout.title.text) {
-        layout.margin.t = 65;
-        layout.title.y = 0.9;
+        layout.margin.t = 85;
       } else {
         layout.margin.t = 30;
       }

js/topbar/EnvControls.js

@@ -76,6 +76,7 @@ function EnvControls(props) {
     });
   });
 
+  const validEnvIDs = envIDs.filter((env) => slist.indexOf(env) !== -1);
   const currentIdx = envIDs.length > 0 ? slist.indexOf(envIDs[0]) : -1;
   const hasSingleSelectedEnv = envIDs.length === 1 && currentIdx !== -1;
   const onPrevEnv = () => {
@@ -112,11 +113,10 @@ function EnvControls(props) {
               wordBreak: 'break-all',
             }}
             placeholder={<i>Select environment(s)</i>}
-            searchPlaceholder="search"
             treeLine
             maxTagTextLength={1000}
             inputValue={null}
-            value={envIDs}
+            value={validEnvIDs}
             treeData={env_options2}
             treeNodeFilterProp="title"
             treeDataSimpleMode={{ id: 'key', rootPId: 0 }}

py/visdom/__init__.py

@@ -2933,6 +2933,109 @@ def mesh(self, X, Y=None, win=None, env=None, opts=None):
             }
         )
 
+    @pytorch_wrap
+    def sankey(self, source, target, value, labels=None, win=None, env=None, opts=None):
+        """
+        This function draws a Sankey (flow) diagram. Flows are defined by three
+        equal-length arrays:
+
+        - `source`: source node index of each link (`N` array of ints)
+        - `target`: target node index of each link (`N` array of ints)
+        - `value` : magnitude of each link (`N` array of non-negative numbers)
+
+        `labels` is an optional list of node names. If omitted, nodes are
+        referenced by their index alone.
+
+        The following `opts` are supported:
+
+        - `opts.labels`     : list of node labels (alternative to the `labels` arg)
+        - `opts.pad`        : node padding in px (`number`; default = 15)
+        - `opts.thickness`  : node thickness in px (`number`; default = 20)
+        - `opts.orientation`: `'h'` (default) or `'v'`
+        - `opts.nodecolor`  : node color(s) (`string` or list of strings)
+        - `opts.linkcolor`  : link color(s) (`string` or list of strings)
+        - `opts.layoutopts` : `dict` of additional backend layout options, e.g.
+          `layoutopts = {'plotly': {'font': {'size': 10}}}`.
+        """
+        opts = {} if opts is None else opts
+        _title2str(opts)
+        _assert_opts(opts)
+
+        source = np.asarray(source)
+        target = np.asarray(target)
+        value = np.asarray(value)
+        for name, arr in (("source", source), ("target", target), ("value", value)):
+            assert arr.ndim <= 1, "sankey {} must be 1-D, got shape {}".format(
+                name, arr.shape
+            )
+        source = source.ravel()
+        target = target.ravel()
+        value = value.ravel()
+        assert (
+            len(source) == len(target) == len(value)
+        ), "source, target and value must have the same length"
+        assert (source >= 0).all(), "sankey source indices must be non-negative"
+        assert (target >= 0).all(), "sankey target indices must be non-negative"
+        assert (
+            source == source.astype(int)
+        ).all(), "sankey source indices must be integers"
+        assert (
+            target == target.astype(int)
+        ).all(), "sankey target indices must be integers"
+        assert (value >= 0).all(), "sankey link values must be non-negative"
+
+        labels = labels if labels is not None else opts.get("labels")
+        if labels is not None and len(source) > 0:
+            num_nodes = max(int(source.max()), int(target.max())) + 1
+            assert len(labels) >= num_nodes, (
+                "labels must cover every referenced node "
+                "({} labels for {} nodes)".format(len(labels), num_nodes)
+            )
+
+        pad = opts.get("pad", 15)
+        thickness = opts.get("thickness", 20)
+        orientation = opts.get("orientation", "h")
+        assert (
+            isinstance(pad, numbers.Number) and pad >= 0
+        ), "opts.pad must be a non-negative number"
+        assert (
+            isinstance(thickness, numbers.Number) and thickness > 0
+        ), "opts.thickness must be a positive number"
+        assert orientation in ("h", "v"), "opts.orientation must be 'h' or 'v'"
+
+        node = {"pad": pad, "thickness": thickness}
+        if labels is not None:
+            node["label"] = list(labels)
+        if opts.get("nodecolor") is not None:
+            node["color"] = opts.get("nodecolor")
+
+        link = {
+            "source": source.astype(int).tolist(),
+            "target": target.astype(int).tolist(),
+            "value": value.tolist(),
+        }
+        if opts.get("linkcolor") is not None:
+            link["color"] = opts.get("linkcolor")
+
+        data = [
+            {
+                "type": "sankey",
+                "orientation": orientation,
+                "node": node,
+                "link": link,
+            }
+        ]
+
+        return self._send(
+            {
+                "data": data,
+                "win": win,
+                "eid": env,
+                "layout": _opts2layout(opts),
+                "opts": opts,
+            }
+        )
+
     @pytorch_wrap
     def dual_axis_lines(self, X=None, Y1=None, Y2=None, opts=None, win=None, env=None):
         """

py/visdom/__init__.pyi

@@ -224,6 +224,16 @@ class Visdom:
         env: _OptStr = ...,
         opts: _OptOps = ...,
     ) -> _SendReturn: ...
+    def sankey(
+        self,
+        source: Tensor,
+        target: Tensor,
+        value: Tensor,
+        labels: Optional[List] = ...,
+        win: _OptStr = ...,
+        env: _OptStr = ...,
+        opts: _OptOps = ...,
+    ) -> _SendReturn: ...
     def graph(
         self,
         edges: List,