iplotx 0.5.0__tar.gz → 0.5.2.dev0__tar.gz

{iplotx-0.5.0 → iplotx-0.5.2.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iplotx
-Version: 0.5.0
+Version: 0.5.2.dev0
 Summary: Plot networkx from igraph and networkx.
 Project-URL: Homepage, https://github.com/fabilab/iplotx
 Project-URL: Documentation, https://readthedocs.org/iplotx
@@ -43,9 +43,25 @@ Description-Content-Type: text/markdown
 ![pylint](assets/pylint.svg)
 
 # iplotx
-Plotting networks from igraph and networkx.
+[![Banner](docs/source/_static/banner.png)](https://iplotx.readthedocs.io/en/latest/gallery/index.html).
 
-**NOTE**: This is currently beta quality software. The API and functionality are settling in and might break occasionally.
+Visualise networks and trees in Python, with style.
+
+Supports:
+- **networks**:
+  - [networkx](https://networkx.org/)
+  - [igraph](igraph.readthedocs.io/)
+  - [minimal network data structure](https://iplotx.readthedocs.io/en/latest/gallery/plot_simplenetworkdataprovider.html#sphx-glr-gallery-plot-simplenetworkdataprovider-py) (for educational purposes)
+- **trees**:
+  - [ETE4](https://etetoolkit.github.io/ete/)
+  - [cogent3](https://cogent3.org/)
+  - [Biopython](https://biopython.org/)
+  - [scikit-bio](https://scikit.bio)
+  - [minimal tree data structure](https://iplotx.readthedocs.io/en/latest/gallery/tree/plot_simpletreedataprovider.html#sphx-glr-gallery-tree-plot-simpletreedataprovider-py) (for educational purposes)
+
+In addition to the above, *any* network or tree analysis library can register an [entry point](https://iplotx.readthedocs.io/en/latest/providers.html#creating-a-custom-data-provider) to gain compatibility with `iplotx` with no intervention from our side.
+
+**NOTE**: This is currently late beta quality software. The API and functionality might break rarely.
 
 ## Installation
 ```bash
@@ -72,19 +88,20 @@ See [readthedocs](https://iplotx.readthedocs.io/en/latest/) for the full documen
 ## Gallery
 See [gallery](https://iplotx.readthedocs.io/en/latest/gallery/index.html).
 
-## Roadmap
-- Plot networks from igraph and networkx interchangeably, using matplotlib as a backend. ✅
-- Support interactive plotting, e.g. zooming and panning after the plot is created. ✅
-- Support storing the plot to disk thanks to the many matplotlib backends (SVG, PNG, PDF, etc.). ✅
-- Support flexible yet easy styling. ✅
+## Features
+- Plot networks from multiple libraries including networkx and igraph, using matplotlib as a backend. ✅
+- Plot trees from multiple libraries such as cogent3, ETE4, skbio, and biopython. ✅
+- Flexible yet easy styling, including an internal library of styles ✅
+- Interactive plotting, e.g. zooming and panning after the plot is created. ✅
+- Store the plot to disk thanks to the many matplotlib backends (SVG, PNG, PDF, etc.). ✅
 - Efficient plotting of large graphs using matplotlib's collection functionality. ✅
-- Support editing plotting elements after the plot is created, e.g. changing node colors, labels, etc. ✅
-- Support animations, e.g. showing the evolution of a network over time. ✅
-- Support mouse interaction, e.g. hovering over or clicking on nodes and edges to get information about them. ✅
-- Support trees from special libraries such as ete3, biopython, etc. This will need a dedicated function and layouting. ✅
-- Support uni- and bi-directional communication between graph object and plot object.🏗️
-
-**NOTE:** The last item can probably be achieved already by using `matplotlib`'s existing callback functionality. It is currently untested, but if you manage to get it to work on your graph let me know and I'll add it to the examples (with credit).
+- Edit plotting elements after the plot is created, e.g. changing node colors, labels, etc. ✅
+- Animations, e.g. showing the evolution of a network over time. ✅
+- Mouse and keyboard interaction, e.g. hovering over nodes/edges to get information about them. ✅
+- Node clustering and covers, e.g. showing communities in a network. ✅
+- Choice of tree layouts and orientations. ✅
+- Tree-specific options: cascades, subtree styling, split edges, etc. ✅
+- (WIP) Support uni- and bi-directional communication between graph object and plot object.🏗️
 
 ## Authors
 Fabio Zanini (https://fabilab.org)

iplotx-0.5.2.dev0/README.md

@@ -0,0 +1,69 @@
+![Github Actions](https://github.com/fabilab/iplotx/actions/workflows/test.yml/badge.svg)
+![PyPI - Version](https://img.shields.io/pypi/v/iplotx)
+![RTD](https://readthedocs.org/projects/iplotx/badge/?version=latest)
+[![Coverage Status](https://coveralls.io/repos/github/fabilab/iplotx/badge.svg?branch=main)](https://coveralls.io/github/fabilab/iplotx?branch=main)
+![pylint](assets/pylint.svg)
+
+# iplotx
+[![Banner](docs/source/_static/banner.png)](https://iplotx.readthedocs.io/en/latest/gallery/index.html).
+
+Visualise networks and trees in Python, with style.
+
+Supports:
+- **networks**:
+  - [networkx](https://networkx.org/)
+  - [igraph](igraph.readthedocs.io/)
+  - [minimal network data structure](https://iplotx.readthedocs.io/en/latest/gallery/plot_simplenetworkdataprovider.html#sphx-glr-gallery-plot-simplenetworkdataprovider-py) (for educational purposes)
+- **trees**:
+  - [ETE4](https://etetoolkit.github.io/ete/)
+  - [cogent3](https://cogent3.org/)
+  - [Biopython](https://biopython.org/)
+  - [scikit-bio](https://scikit.bio)
+  - [minimal tree data structure](https://iplotx.readthedocs.io/en/latest/gallery/tree/plot_simpletreedataprovider.html#sphx-glr-gallery-tree-plot-simpletreedataprovider-py) (for educational purposes)
+
+In addition to the above, *any* network or tree analysis library can register an [entry point](https://iplotx.readthedocs.io/en/latest/providers.html#creating-a-custom-data-provider) to gain compatibility with `iplotx` with no intervention from our side.
+
+**NOTE**: This is currently late beta quality software. The API and functionality might break rarely.
+
+## Installation
+```bash
+pip install iplotx
+```
+
+## Quick Start
+```python
+import networkx as nx
+import matplotlib.pyplot as plt
+import iplotx as ipx
+
+g = nx.Graph([(0, 1), (1, 2), (2, 3), (3, 4), (4, 0)])
+layout = nx.layout.circular_layout(g)
+fig, ax = plt.subplots(figsize=(3, 3))
+ipx.plot(g, ax=ax, layout=layout)
+```
+
+![Quick start image](docs/source/_static/graph_basic.png)
+
+## Documentation
+See [readthedocs](https://iplotx.readthedocs.io/en/latest/) for the full documentation.
+
+## Gallery
+See [gallery](https://iplotx.readthedocs.io/en/latest/gallery/index.html).
+
+## Features
+- Plot networks from multiple libraries including networkx and igraph, using matplotlib as a backend. ✅
+- Plot trees from multiple libraries such as cogent3, ETE4, skbio, and biopython. ✅
+- Flexible yet easy styling, including an internal library of styles ✅
+- Interactive plotting, e.g. zooming and panning after the plot is created. ✅
+- Store the plot to disk thanks to the many matplotlib backends (SVG, PNG, PDF, etc.). ✅
+- Efficient plotting of large graphs using matplotlib's collection functionality. ✅
+- Edit plotting elements after the plot is created, e.g. changing node colors, labels, etc. ✅
+- Animations, e.g. showing the evolution of a network over time. ✅
+- Mouse and keyboard interaction, e.g. hovering over nodes/edges to get information about them. ✅
+- Node clustering and covers, e.g. showing communities in a network. ✅
+- Choice of tree layouts and orientations. ✅
+- Tree-specific options: cascades, subtree styling, split edges, etc. ✅
+- (WIP) Support uni- and bi-directional communication between graph object and plot object.🏗️
+
+## Authors
+Fabio Zanini (https://fabilab.org)

{iplotx-0.5.0 → iplotx-0.5.2.dev0}/docs/source/api/complete_style_specification.md

@@ -69,6 +69,13 @@
         # unless the "norm" option is used.
         "color": str | float | Any,
 
+        # How to cap the edge line. Should be "butt" (default), "round", or "projecting".
+        "capstyle": str,
+
+        # Whether to leave any space between edge cap and vertex border. This is
+        # in figure points and autoscales correctly with dpi.
+        "padding": float,
+
         # Matplotlib color map used to map floating numbers into RGBA colors. Only
         # used when the previous option "color" is set to floats.
         "cmap": str | matplotlib.colors.Colormap,
@@ -138,10 +145,15 @@
             # |/
             # |\\ (double slash needed to avoid character escaping)
             # >
+            # <
             # >>
             # )>
             # )
+            # (
+            # ]
+            # [
             # |
+            # x (or X)
             # s
             # d
             # p
@@ -180,6 +192,17 @@
             "bbox": dict,  # Bounding box properties for the label (see vertex labels)
 
         },
+
+        ############################################################################
+        # The following edge properties are only valid for trees via `iplotx.tree`
+        "split": {
+            # NOTE: This takes any properties of "edge" except for itself (i.e. no
+            # "nested" split) and applies it to the last segment of split edges.
+            "color": str | Any,  # Color of the split edge
+
+            # ...
+        },
+
     },
 
     # The following entry is used by networks ONLY (not trees as plotted by `iplotx.tree`)

{iplotx-0.5.0 → iplotx-0.5.2.dev0}/docs/source/sg_execution_times.rst

@@ -6,7 +6,7 @@
 
 Computation times
 =================
-**00:01.263** total execution time for 51 files **from all galleries**:
+**00:00.045** total execution time for 59 files **from all galleries**:
 
 .. container::
 
@@ -32,12 +32,15 @@ Computation times
    * - Example
      - Time
      - Mem (MB)
-   * - :ref:`sphx_glr_gallery_tree_plot_split_edges.py` (``../../gallery/tree/plot_split_edges.py``)
-     - 00:01.263
+   * - :ref:`sphx_glr_gallery_plot_feedbacks.py` (``../../gallery/plot_feedbacks.py``)
+     - 00:00.045
      - 0.0
    * - :ref:`sphx_glr_gallery_plot_animation.py` (``../../gallery/plot_animation.py``)
      - 00:00.000
      - 0.0
+   * - :ref:`sphx_glr_gallery_plot_arrowlawn.py` (``../../gallery/plot_arrowlawn.py``)
+     - 00:00.000
+     - 0.0
    * - :ref:`sphx_glr_gallery_plot_arrows.py` (``../../gallery/plot_arrows.py``)
      - 00:00.000
      - 0.0
@@ -68,9 +71,15 @@ Computation times
    * - :ref:`sphx_glr_gallery_plot_directed.py` (``../../gallery/plot_directed.py``)
      - 00:00.000
      - 0.0
+   * - :ref:`sphx_glr_gallery_plot_edgepadding.py` (``../../gallery/plot_edgepadding.py``)
+     - 00:00.000
+     - 0.0
    * - :ref:`sphx_glr_gallery_plot_edit_artists.py` (``../../gallery/plot_edit_artists.py``)
      - 00:00.000
      - 0.0
+   * - :ref:`sphx_glr_gallery_plot_elements.py` (``../../gallery/plot_elements.py``)
+     - 00:00.000
+     - 0.0
    * - :ref:`sphx_glr_gallery_plot_four_grids.py` (``../../gallery/plot_four_grids.py``)
      - 00:00.000
      - 0.0
@@ -113,6 +122,9 @@ Computation times
    * - :ref:`sphx_glr_gallery_plot_ports.py` (``../../gallery/plot_ports.py``)
      - 00:00.000
      - 0.0
+   * - :ref:`sphx_glr_gallery_plot_redblack.py` (``../../gallery/plot_redblack.py``)
+     - 00:00.000
+     - 0.0
    * - :ref:`sphx_glr_gallery_plot_shortest_path.py` (``../../gallery/plot_shortest_path.py``)
      - 00:00.000
      - 0.0
@@ -140,6 +152,9 @@ Computation times
    * - :ref:`sphx_glr_gallery_plot_voronoi.py` (``../../gallery/plot_voronoi.py``)
      - 00:00.000
      - 0.0
+   * - :ref:`sphx_glr_gallery_plot_waypoints.py` (``../../gallery/plot_waypoints.py``)
+     - 00:00.000
+     - 0.0
    * - :ref:`sphx_glr_gallery_plot_with_colorbar.py` (``../../gallery/plot_with_colorbar.py``)
      - 00:00.000
      - 0.0
@@ -158,6 +173,9 @@ Computation times
    * - :ref:`sphx_glr_gallery_tree_plot_cogent3_tree.py` (``../../gallery/tree/plot_cogent3_tree.py``)
      - 00:00.000
      - 0.0
+   * - :ref:`sphx_glr_gallery_tree_plot_elements_tree.py` (``../../gallery/tree/plot_elements_tree.py``)
+     - 00:00.000
+     - 0.0
    * - :ref:`sphx_glr_gallery_tree_plot_ete4.py` (``../../gallery/tree/plot_ete4.py``)
      - 00:00.000
      - 0.0
@@ -173,6 +191,12 @@ Computation times
    * - :ref:`sphx_glr_gallery_tree_plot_skbio_tree.py` (``../../gallery/tree/plot_skbio_tree.py``)
      - 00:00.000
      - 0.0
+   * - :ref:`sphx_glr_gallery_tree_plot_split_edges.py` (``../../gallery/tree/plot_split_edges.py``)
+     - 00:00.000
+     - 0.0
+   * - :ref:`sphx_glr_gallery_tree_plot_style_tree.py` (``../../gallery/tree/plot_style_tree.py``)
+     - 00:00.000
+     - 0.0
    * - :ref:`sphx_glr_gallery_tree_plot_support.py` (``../../gallery/tree/plot_support.py``)
      - 00:00.000
      - 0.0

iplotx-0.5.2.dev0/gallery/plot_arrowlawn.py

@@ -0,0 +1,81 @@
+"""
+Arrow lawn
+==========
+
+This example demonstrates the visualisation of a network with 1,000 nodes and a few thousand
+edges, using a custom layout that resembles a lawn of arrows.
+"""
+
+import numpy as np
+import iplotx as ipx
+import matplotlib.pyplot as plt
+
+n = 1000  # Number of nodes
+k = 3
+layout = np.random.rand(n, 2)
+nodes = np.arange(n)
+edges = []
+for i, v1 in enumerate(layout):
+    found = 0
+    dv = layout - v1
+    for j in (dv**2).sum(axis=1).argsort()[1:]:
+        angle = 180 / np.pi * np.arctan2(dv[j, 1], dv[j, 0])
+        # Only make an edge for neighbors towards the north-east
+        if 10 < angle < 80:
+            edges.append((i, j))
+            found += 1
+            if found == k:
+                break
+
+# Plot the network using iplotx
+fig, ax = plt.subplots(figsize=(7, 7))
+ipx.network(
+    {'nodes': nodes, 'edges': edges, 'directed': True},
+    layout=layout,
+    ax=ax,
+    vertex_size=5,
+    vertex_alpha=0.8,
+    vertex_facecolor="seagreen",
+    vertex_edgecolor="none",
+    edge_arrow_width=3,
+    edge_alpha=0.5,
+)
+fig.tight_layout()
+
+
+# %%
+# If you want to start pushing the scalability of iplotx, you can try with 10,000 nodes and
+# ~30,000 edges. This takes ~14 seconds on a modern laptop, of which 5 are spent on building
+# the network and 9 are spent inside of ``iplotx`` visualising it:
+
+n = 10000  # Number of nodes
+k = 3
+layout = np.random.rand(n, 2)
+nodes = np.arange(n)
+edges = []
+for i, v1 in enumerate(layout):
+    found = 0
+    dv = layout - v1
+    for j in (dv**2).sum(axis=1).argsort()[1:]:
+        angle = 180 / np.pi * np.arctan2(dv[j, 1], dv[j, 0])
+        # Only make an edge for neighbors towards the north-east
+        if 10 < angle < 80:
+            edges.append((i, j))
+            found += 1
+            if found == k:
+                break
+
+# Plot the network using iplotx
+fig, ax = plt.subplots(figsize=(9, 9))
+ipx.network(
+    {'nodes': nodes, 'edges': edges, 'directed': True},
+    layout=layout,
+    ax=ax,
+    vertex_size=5,
+    vertex_alpha=0.8,
+    vertex_facecolor="seagreen",
+    vertex_edgecolor="none",
+    edge_arrow_width=3,
+    edge_alpha=0.5,
+)
+fig.tight_layout()

{iplotx-0.5.0 → iplotx-0.5.2.dev0}/gallery/plot_arrows.py

@@ -9,14 +9,15 @@ import networkx as nx
 import matplotlib.pyplot as plt
 import iplotx as ipx
 
-arrow_markers = ["|>", "|/", "|\\", ">", ">>", ")>", ")", "|", "s", "d", "p", "q"]
+arrow_markers = ["|>", "|/", "|\\", ">", "<", ">>", ")>", ")", "(", "]", "[", "|",
+                 "x", "s", "d", "p", "q"]
 n = len(arrow_markers)
 G = nx.DiGraph()
 G.add_edges_from([(f"l{i}", f"r{i}") for i in range(n)])
 layout = {f"l{i}": (0, -i) for i in range(n)}
 layout.update({f"r{i}": (1, -i) for i in range(n)})
 
-fig, ax = plt.subplots(figsize=(3, 7.5))
+fig, ax = plt.subplots(figsize=(3, 8.5))
 ipx.network(
     G,
     layout=layout,
@@ -24,8 +25,10 @@ ipx.network(
     vertex_size=12,
     edge_arrow_marker=arrow_markers,
     edge_arrow_height="width",
+    edge_padding=8,
     edge_color="steelblue",
     title="Arrow markers",
 )
 ax.set_yticks(list(range(-n + 1, 1))[::-1])
 ax.set_yticklabels(arrow_markers)
+ax.yaxis.set_tick_params(length=0)

iplotx-0.5.2.dev0/gallery/plot_edgepadding.py

@@ -0,0 +1,37 @@
+"""
+Edge padding
+============
+
+This example illustrates how to pad edges, i.e. leave a bit of empty space between
+edge cap (end) and the border of its source/target vertices.
+"""
+
+import iplotx as ipx
+
+graph = {
+    "edges": [
+        ("A", "B"),
+        ("B", "C"),
+        ("C", "D"),
+        ("C", "E"),
+        ("E", "Bingo"),
+    ],
+    "directed": True,
+}
+layout = {
+    "A": (0, 0),
+    "B": (1, 0),
+    "C": (1, 1),
+    "D": (-1, 1),
+    "E": (-0.5, 2),
+    "Bingo": (0, 3),
+}
+
+ipx.network(
+    graph,
+    layout,
+    style="rededge",
+    edge_padding=5,
+    vertex_labels=True,
+    vertex_size={"A": 20, "B": 20, "C": 20, "D": 20, "E": 20, "Bingo": 50},
+)

iplotx-0.5.2.dev0/gallery/plot_elements.py

@@ -0,0 +1,43 @@
+"""
+Network element showroom
+========================
+
+This example showcases various plot elements that can be styled in ``iplotx``.
+"""
+
+import matplotlib.pyplot as plt
+import iplotx as ipx
+
+network = {
+    "edges": [(0, 1), (1, 2), (2, 3), (3, 0), (2, 2)],
+    "directed": True,
+}
+layout = [(0, 0), (1, 0), (1, 1), (0, 1)]
+
+fig, ax = plt.subplots(figsize=(4.3, 4.3))
+ipx.network(
+    network,
+    layout,
+    ax=ax,
+    vertex_labels=["Vertex\nlabel"] + [""] * 3,
+    edge_labels=["", "", "Edge\nlabel", "", ""],
+    vertex_label_bbox_edgecolor="k",
+    vertex_label_bbox_linewidth=1.5,
+    vertex_label_bbox_facecolor="steelblue",
+    vertex_label_bbox_alpha=0.5,
+    edge_label_bbox_edgecolor="k",
+    edge_label_bbox_linewidth=1.5,
+    edge_label_bbox_facecolor="tomato",
+    edge_color=["k", "tomato", "k", "k", "k"],
+    edge_arrow_color=["k", "darkred", "k", "k", "k"],
+    edge_linewidth=[2, 4, 2, 2, 2],
+    vertex_facecolor=["w"] * 3 + ["steelblue"],
+    vertex_edgecolor="k",
+    vertex_linewidth=2,
+    vertex_size=[50, 25, 25, 50],
+    vertex_marker="o",
+    vertex_label_color="k",
+    edge_curved=True,
+    edge_tension=[0, 1.25, 0, 3.5],
+    margins=(0, 0.08),
+)

iplotx-0.5.2.dev0/gallery/plot_feedbacks.py

@@ -0,0 +1,54 @@
+"""
+Feedback loops
+==============
+
+Graphs with arrows and bars are commonly used to represent feedback loops in systems.
+This example shows how to obtain that effect in ``iplotx``.
+"""
+
+import numpy as np
+import matplotlib.pyplot as plt
+import iplotx as ipx
+
+graph = {
+    "edges": [
+        ("A", "B"),
+        ("B", "C"),
+        ("C", "A"),
+    ],
+    "directed": True,
+}
+layout = {
+    "A": (0, 0),
+    "B": (1, 0),
+    "C": (0.5, 0.5 * 1.73),
+}
+
+fig, ax = plt.subplots()
+ipx.network(
+    graph,
+    layout,
+    ax=ax,
+    vertex_size=50,
+    edge_linewidth=5,
+    edge_arrow_width=30,
+    edge_arrow_height=40,
+    edge_arrow_marker=[")>", "|", "|"],
+    edge_padding=15,
+    edge_curved=True,
+    edge_tension=[2, 2, 2],
+    vertex_facecolor=["#26677FFF", "#635C72FF", "#89374FFF"],
+    vertex_edgecolor="black",
+    vertex_linewidth=5,
+    aspect=1.0,
+    margins=0.1,
+)
+
+# Add a parametric spiral
+t = np.linspace(0, 4 * np.pi, 400)
+ax.plot(
+    0.5 + np.cos(t + np.pi) * t / 40,
+    0.31 + np.sin(t + np.pi) * t / 40,
+    color="grey",
+    lw=4,
+)

iplotx-0.5.2.dev0/gallery/plot_redblack.py

@@ -0,0 +1,71 @@
+"""
+The red and the black
+=====================
+
+This example demonstrates how to overlay an ``iplotx`` artist with plain matplotlib patches.
+"""
+
+
+import numpy as np
+import iplotx as ipx
+import matplotlib.pyplot as plt
+
+# We will use a network laid out onto a square grid
+gsize = 5  # Grid size
+layout = [(i % gsize, i // gsize) for i in range(gsize**2)]
+
+# Two possible colors
+colorlist = np.array(["tomato", "#111"])
+
+# Assign node colors at random
+node_colors = colorlist[np.random.randint(2, size=gsize**2)]
+
+# Connect two neighboring nodes if they have the same color
+edges = []
+for inode in range(gsize**2):
+    i = inode // gsize
+    j = inode % gsize
+    # Four possible edges
+    cands = []
+    if i != 0:
+        cands.append(inode - gsize)
+    if j != 0:
+        cands.append(inode - 1)
+    if i != gsize - 1:
+        cands.append(inode + gsize)
+    if j != gsize - 1:
+        cands.append(inode + 1)
+    for inode2 in cands:
+        if node_colors[inode] == node_colors[inode2]:
+            if (inode2, inode) not in edges:
+                edges.append((inode, inode2))
+
+# Build the network using our zero-dependency data structure
+network = {
+    "edges": edges,
+    "nodes": list(range(gsize**2)),
+}
+
+# Visualise the network
+fig, ax = plt.subplots(figsize=(5, 5))
+ipx.network(
+    network,
+    layout=layout,
+    ax=ax,
+    vertex_size=8,
+    vertex_marker='d',
+)
+
+# Add square patches centered on each node
+for i in range(gsize):
+    for j in range(gsize):
+        inode = i * gsize + j
+        ax.add_patch(plt.Rectangle(
+            (j-0.5, i-0.5),
+            1,
+            1,
+            facecolor=node_colors[inode],
+            edgecolor="none",
+            alpha=0.4,
+            zorder=0,
+        ))

iplotx-0.5.2.dev0/gallery/plot_waypoints.py

@@ -0,0 +1,40 @@
+"""
+Edge waypoints
+==============
+
+This example demonstrates the use of edge waypoints.
+"""
+
+import matplotlib.pyplot as plt
+import numpy as np
+import iplotx as ipx
+
+g = {
+    "edges": [
+        ("A", "B"),
+        ("B", "C"),
+        ("B", "D"),
+        ("A", "E"),
+    ],
+}
+layout = {
+    "A": (0, 0),
+    "B": (0, 1),
+    "C": (1, 2),
+    "D": (0, 2),
+    "E": (-1, 1),
+}
+
+fig, ax = plt.subplots()
+ipx.network(
+    g,
+    layout=layout,
+    ax=ax,
+    vertex_labels=True,
+    edge_waypoints=["none", [(1, 1), (0.5, 1.5), (1, 1.5)], "none", "none"],
+)
+plt.ion(); plt.show()
+
+# %%
+# .. note::
+#   Edge waypoints are not currently compatible with curved edges.

{iplotx-0.5.0 → iplotx-0.5.2.dev0}/gallery/tree/plot_cladeedges.py

@@ -1,6 +1,6 @@
 """
-Styling clades
-==============
+Subtrees and cascades
+=====================
 
 This Biopython-inspired example shows how to style clade edges for a
 node and its descendants.