iplotx 0.12.0__py3-none-any.whl → 1.0.1__py3-none-any.whl

iplotx/artists.py

@@ -3,19 +3,21 @@ All artists defined in iplotx.
 """
 
 from .network import NetworkArtist
-from .tree import TreeArtist
+from .network.groups import GroupingCollection
 from .vertex import VertexCollection
 from .edge import EdgeCollection
 from .label import LabelCollection
 from .edge.arrow import EdgeArrowCollection
 from .edge.leaf import LeafEdgeCollection
-from .cascades import CascadeCollection
 from .art3d.vertex import Vertex3DCollection
 from .art3d.edge import Edge3DCollection
+from .tree import TreeArtist
+from .tree.cascades import CascadeCollection
 
 
 ___all__ = (
     NetworkArtist,
+    GroupingCollection,
     TreeArtist,
     VertexCollection,
     EdgeCollection,

iplotx/ingest/providers/network/graph_tool.py

@@ -0,0 +1,100 @@
+from typing import (
+    Optional,
+    Sequence,
+)
+from collections.abc import Hashable
+import importlib
+import numpy as np
+import pandas as pd
+
+from ....typing import (
+    LayoutType,
+)
+from ...heuristics import (
+    normalise_layout,
+)
+from ...typing import (
+    NetworkDataProvider,
+    NetworkData,
+)
+from ....utils.internal import (
+    _make_layout_columns,
+)
+
+
+class GraphToolDataProvider(NetworkDataProvider):
+    def __call__(
+        self,
+        layout: Optional[LayoutType] = None,
+        vertex_labels: Optional[Sequence[str] | dict[Hashable, str] | pd.Series] = None,
+        edge_labels: Optional[Sequence[str] | dict[str]] = None,
+    ) -> NetworkData:
+        """Create network data object for iplotx from an igraph object."""
+
+        # Get layout
+        vertex_df = normalise_layout(
+            layout,
+            network=self.network,
+            nvertices=self.number_of_vertices(),
+        )
+        ndim = vertex_df.shape[1]
+        vertex_df.columns = _make_layout_columns(ndim)
+
+        # Vertices are ordered integers, no gaps
+
+        # Vertex labels
+        # Recast vertex_labels=False as vertex_labels=None
+        if np.isscalar(vertex_labels) and (not vertex_labels):
+            vertex_labels = None
+        if vertex_labels is not None:
+            if np.isscalar(vertex_labels):
+                vertex_df["label"] = vertex_df.index.astype(str)
+            elif len(vertex_labels) != len(vertex_df):
+                raise ValueError("Vertex labels must be the same length as the number of vertices.")
+            else:
+                vertex_df["label"] = vertex_labels
+
+        # Edges are a list of tuples, because of multiedges
+        tmp = []
+        for edge in self.network.edges():
+            row = {"_ipx_source": edge.source(), "_ipx_target": edge.target()}
+            # TODO: add graph-tool edge attributes
+            # row.update(edge.attributes())
+            tmp.append(row)
+        if len(tmp):
+            edge_df = pd.DataFrame(tmp)
+        else:
+            edge_df = pd.DataFrame(columns=["_ipx_source", "_ipx_target"])
+        del tmp
+
+        # Edge labels
+        if edge_labels is not None:
+            if len(edge_labels) != len(edge_df):
+                raise ValueError("Edge labels must be the same length as the number of edges.")
+            edge_df["label"] = edge_labels
+
+        network_data = {
+            "vertex_df": vertex_df,
+            "edge_df": edge_df,
+            "directed": self.is_directed(),
+            "ndim": ndim,
+        }
+        return network_data
+
+    @staticmethod
+    def check_dependencies() -> bool:
+        return importlib.util.find_spec("graph_tool") is not None
+
+    @staticmethod
+    def graph_type():
+        import graph_tool.all as gt
+
+        return gt.Graph
+
+    def is_directed(self):
+        """Whether the network is directed."""
+        return self.network.is_directed()
+
+    def number_of_vertices(self):
+        """The number of vertices/nodes in the network."""
+        return self.network.num_vertices()

iplotx/{network.py → network/__init__.py}

@@ -7,33 +7,33 @@ import numpy as np
 import pandas as pd
 import matplotlib as mpl
 
-from .typing import (
+from ..typing import (
     GraphType,
     LayoutType,
 )
-from .style import (
+from ..style import (
     get_style,
     rotate_style,
 )
-from .utils.matplotlib import (
+from ..utils.matplotlib import (
     _stale_wrapper,
     _forwarder,
     _build_cmap_fun,
 )
-from .ingest import (
+from ..ingest import (
     ingest_network_data,
 )
-from .vertex import (
+from ..vertex import (
     VertexCollection,
 )
-from .edge import (
+from ..edge import (
     EdgeCollection,
     make_stub_patch as make_undirected_edge_patch,
 )
-from .art3d.vertex import (
+from ..art3d.vertex import (
     vertex_collection_2d_to_3d,
 )
-from .art3d.edge import (
+from ..art3d.edge import (
     Edge3DCollection,
     edge_collection_2d_to_3d,
 )

iplotx/{groups.py → network/groups.py}

@@ -1,5 +1,5 @@
 """
-Module for vertex groupings code, especially the GroupingArtist class.
+Module for vertex groupings code, especially the GroupingCollection class.
 """
 
 from typing import Union
@@ -9,22 +9,22 @@ import matplotlib as mpl
 from matplotlib.collections import PatchCollection
 
 
-from .typing import (
+from ..typing import (
     GroupingType,
     LayoutType,
 )
-from .ingest.heuristics import (
+from ..ingest.heuristics import (
     normalise_layout,
     normalise_grouping,
 )
-from .style import get_style, rotate_style
-from .utils.geometry import (
+from ..style import get_style, rotate_style
+from ..utils.geometry import (
     convex_hull,
     _compute_group_path_with_vertex_padding,
 )
 
 
-class GroupingArtist(PatchCollection):
+class GroupingCollection(PatchCollection):
     """Matplotlib artist for a vertex grouping (clustering/cover).
 
     This class is used to plot patches surrounding groups of vertices in a network.

iplotx/plotting.py

@@ -13,7 +13,7 @@ from .typing import (
     TreeType,
 )
 from .network import NetworkArtist
-from .groups import GroupingArtist
+from .network.groups import GroupingCollection
 from .tree import TreeArtist
 from .style import context
 
@@ -101,7 +101,7 @@ def network(
             nwkart = None
 
         if grouping is not None:
-            grpart = GroupingArtist(
+            grpart = GroupingCollection(
                 grouping,
                 layout,
                 network=network,

iplotx/{tree.py → tree/__init__.py}

@@ -10,38 +10,41 @@ import numpy as np
 import pandas as pd
 import matplotlib as mpl
 
-from .style import (
+from ..style import (
     context,
     get_style,
     rotate_style,
     merge_styles,
 )
-from .utils.matplotlib import (
+from ..utils.matplotlib import (
     _stale_wrapper,
     _forwarder,
     _build_cmap_fun,
 )
-from .ingest import (
+from ..ingest import (
     ingest_tree_data,
     data_providers,
 )
-from .vertex import (
+from ..vertex import (
     VertexCollection,
 )
-from .edge import (
+from ..edge import (
     EdgeCollection,
     make_stub_patch as make_undirected_edge_patch,
 )
-from .edge.leaf import (
+from ..edge.leaf import (
     LeafEdgeCollection,
 )
-from .label import (
+from ..label import (
     LabelCollection,
 )
 from .cascades import (
     CascadeCollection,
 )
-from .network import (
+from .scalebar import (
+    TreeScalebarArtist,
+)
+from ..network import (
     _update_from_internal,
 )
 
@@ -663,6 +666,43 @@ class TreeArtist(mpl.artist.Artist):
         """Get the orientation of the tree layout."""
         return self._ipx_internal_data.get("orientation", None)
 
+    def scalebar(
+        self,
+        loc: str = "upper left",
+        label_format: str = ".2f",
+        **kwargs,
+    ):
+        """Create scalebar for the tree.
+
+        Parameters:
+            legth: Length of the scalebar in data units.
+            loc: Location of the scalebar. Same options as `matplotlib.legend`.
+            kwargs: Additional keyword arguments passed to `TreeScalebarArtist`. These are
+                generally the same options that you would pass to a legend, such as
+                bbox_to_anchor, bbox_transform, etc.
+        Returns:
+            The artist with the tree scale bar.
+        """
+        if self.axes is None:
+            raise RuntimeError("Cannot add a scalebar if the artist is not in an Axes.")
+
+        scalebar = TreeScalebarArtist(
+            self,
+            layout=self.get_layout_name(),
+            loc=loc,
+            label_format=label_format,
+            **kwargs,
+        )
+
+        # Remove previous scalebars if any
+        for art in self.axes._children:
+            if isinstance(art, TreeScalebarArtist) and art._treeartist == self:
+                art.remove()
+
+        self.axes.add_artist(scalebar)
+
+        return scalebar
+
     def style_subtree(
         self,
         nodes: Sequence[Hashable],

iplotx/{cascades.py → tree/cascades.py}

@@ -5,16 +5,15 @@ from typing import (
 import warnings
 import numpy as np
 import pandas as pd
+import matplotlib as mpl
 
-from .typing import (
+from ..typing import (
     TreeType,
 )
-from .ingest.typing import (
+from ..ingest.typing import (
     TreeDataProvider,
 )
-import matplotlib as mpl
-
-from .style import (
+from ..style import (
     copy_with_deep_values,
     rotate_style,
 )

iplotx/tree/scalebar.py

@@ -0,0 +1,327 @@
+from typing import (
+    Any,
+)
+import numpy as np
+from matplotlib import (
+    _api,
+)
+from matplotlib import collections as mcoll
+from matplotlib.legend import Legend
+from matplotlib.legend_handler import HandlerErrorbar
+from matplotlib.lines import Line2D
+from matplotlib.offsetbox import (
+    HPacker,
+    VPacker,
+    DrawingArea,
+    TextArea,
+)
+
+
+def _update_prop(legend_artist, orig_handle):
+    # NOTE: This is de facto a bug in mpl, because Line2D.set_linestyle()
+    # does two things: it reformats tuple-style dashing, and it sets the
+    # artist as stale. We want to do the former only here, so we reset
+    # the artist as the original stale state after calling it.
+    stale_orig = legend_artist.stale
+    legend_artist.set_linestyle(orig_handle.get_linestyle()[0])
+    legend_artist.stale = stale_orig
+
+    # These other properties can be set directly.
+    legend_artist._linewidth = orig_handle.get_linewidth()[0]
+    legend_artist._color = orig_handle.get_edgecolor()[0]
+    legend_artist._gapcolor = orig_handle._gapcolor
+
+
+class TreeScalebarArtist(Legend):
+    def __init__(
+        self,
+        treeartist,
+        layout: str = "horizontal",
+        frameon: bool = False,
+        label_format: str = ".2f",
+        **kwargs,
+    ):
+        handles = [treeartist.get_edges()]
+        labels = [""]
+        self._layout = layout
+        self._treeartist = treeartist
+        self._label_format = label_format
+
+        if layout == "vertical":
+            handler_kwargs = dict(xerr_size=0, yerr_size=1)
+        else:
+            handler_kwargs = dict(xerr_size=1)
+        handler = TreeLegendHandler(
+            update_func=_update_prop,
+            **handler_kwargs,
+        )
+
+        super().__init__(
+            treeartist.axes,
+            handles,
+            labels,
+            handler_map={handles[0]: handler},
+            frameon=frameon,
+            **kwargs,
+        )
+
+    def _init_legend_box(self, handles, labels, markerfirst=True):
+        """
+        Create the legend box.
+
+        This is a modified version of the original Legend._init_legend_box
+        method to accommodate a scale bar.
+        """
+
+        fontsize = self._fontsize
+
+        # legend_box is a HPacker, horizontally packed with columns.
+        # Each column is a VPacker, vertically packed with legend items.
+        # Each legend item is a HPacker packed with:
+        # - handlebox: a DrawingArea which contains the legend handle.
+        # - labelbox: a TextArea which contains the legend text.
+
+        text_list = []  # the list of text instances
+        handle_list = []  # the list of handle instances
+        handles_and_labels = []
+
+        # The approximate height and descent of text. These values are
+        # only used for plotting the legend handle.
+        descent = 0.35 * fontsize * (self.handleheight - 0.7)  # heuristic.
+        height = fontsize * self.handleheight - descent
+        # each handle needs to be drawn inside a box of (x, y, w, h) =
+        # (0, -descent, width, height).  And their coordinates should
+        # be given in the display coordinates.
+
+        # The transformation of each handle will be automatically set
+        # to self.get_transform(). If the artist does not use its
+        # default transform (e.g., Collections), you need to
+        # manually set their transform to the self.get_transform().
+        legend_handler_map = self.get_legend_handler_map()
+
+        for orig_handle, label in zip(handles, labels):
+            handler = self.get_legend_handler(legend_handler_map, orig_handle)
+            if handler is None:
+                _api.warn_external(
+                    "Legend does not support handles for "
+                    f"{type(orig_handle).__name__} "
+                    "instances.\nA proxy artist may be used "
+                    "instead.\nSee: https://matplotlib.org/"
+                    "stable/users/explain/axes/legend_guide.html"
+                    "#controlling-the-legend-entries"
+                )
+                # No handle for this artist, so we just defer to None.
+                handle_list.append(None)
+            else:
+                handlebox = DrawingArea(
+                    width=self.handlelength * fontsize,
+                    height=height,
+                    xdescent=0.0,
+                    ydescent=descent,
+                )
+                # Create the artist for the legend which represents the
+                # original artist/handle.
+                handle_list.append(handler.legend_artist(self, orig_handle, fontsize, handlebox))
+
+                # The scale bar line is in this handle
+                bar_handle = handle_list[-1]
+                label = self._get_label_from_bar_handle(bar_handle)
+
+                textbox = TextArea(
+                    label,
+                    multilinebaseline=True,
+                    textprops=dict(
+                        verticalalignment="baseline",
+                        horizontalalignment="left",
+                        fontproperties=self.prop,
+                    ),
+                )
+                text_list.append(textbox._text)
+
+                handles_and_labels.append((handlebox, textbox))
+
+        columnbox = []
+        # array_split splits n handles_and_labels into ncols columns, with the
+        # first n%ncols columns having an extra entry.  filter(len, ...)
+        # handles the case where n < ncols: the last ncols-n columns are empty
+        # and get filtered out.
+        for handles_and_labels_column in filter(
+            len, np.array_split(handles_and_labels, self._ncols)
+        ):
+            # pack handlebox and labelbox into itembox
+            if self._layout == "vertical":
+                itempacker = HPacker
+            else:
+                itempacker = VPacker
+            itemboxes = [
+                itempacker(
+                    pad=0,
+                    sep=self.handletextpad * fontsize,
+                    children=[h, t] if markerfirst else [t, h],
+                    align="center",
+                )
+                for h, t in handles_and_labels_column
+            ]
+            # pack columnbox
+            alignment = "baseline" if markerfirst else "right"
+            columnbox.append(
+                VPacker(
+                    pad=0, sep=self.labelspacing * fontsize, align=alignment, children=itemboxes
+                )
+            )
+
+        mode = "expand" if self._mode == "expand" else "fixed"
+        sep = self.columnspacing * fontsize
+        self._legend_handle_box = HPacker(
+            pad=0, sep=sep, align="baseline", mode=mode, children=columnbox
+        )
+        self._legend_title_box = TextArea("")
+        self._legend_box = VPacker(
+            pad=self.borderpad * fontsize,
+            sep=self.labelspacing * fontsize,
+            align=self._alignment,
+            children=[self._legend_title_box, self._legend_handle_box],
+        )
+        self._legend_box.set_figure(self.get_figure(root=False))
+        self._legend_box.axes = self.axes
+        self.texts = text_list
+        self.legend_handles = handle_list
+
+    def _get_label_from_bar_handle(self, bar_handle: Any) -> str:
+        # Extract the x coordinates of the scale bar
+        p0, p1 = bar_handle.get_segments()[0]
+
+        bar_trans = bar_handle.get_transform()
+        data_trans = self.parent.transData
+        composite_trans = data_trans.inverted() + bar_trans
+
+        p0_data = composite_trans.transform(p0)
+        p1_data = composite_trans.transform(p1)
+        distance = np.linalg.norm(p1_data - p0_data)
+        label = format(distance, self._label_format)
+        return label
+
+    def draw(self, renderer):
+        bar_handle = self.legend_handles[0]
+        label = self._get_label_from_bar_handle(bar_handle)
+
+        text_handle = (
+            self._legend_box.get_children()[1].get_children()[0].get_children()[0].get_children()[1]
+        )
+        # Bypass stale=True (we are already redrawing)
+        text_handle.set_text(label)
+
+        super().draw(renderer)
+
+
+class TreeLegendHandler(HandlerErrorbar):
+    def __init__(self, marker_size=6, **kw):
+        self.marker_size = marker_size
+        super().__init__(**kw)
+
+    def create_artists(
+        self,
+        legend,
+        orig_handle,
+        xdescent,
+        ydescent,
+        width,
+        height,
+        fontsize,
+        trans,
+    ):
+        # docstring inherited
+        plotline = orig_handle
+
+        xdata, xdata_marker = self.get_xdata(legend, xdescent, ydescent, width, height, fontsize)
+        ydata = np.full_like(xdata, (height - ydescent) / 2)
+
+        xdata_marker = np.asarray(xdata_marker)
+        ydata_marker = np.asarray(ydata[: len(xdata_marker)])
+
+        xerr_size, yerr_size = self.get_err_size(
+            legend, xdescent, ydescent, width, height, fontsize
+        )
+
+        if legend._layout == "vertical":
+            xdata, ydata = np.array(
+                [
+                    ((x, y - yerr_size), (x, y + yerr_size))
+                    for x, y in zip(xdata_marker, ydata_marker)
+                ]
+            ).T
+
+        legline = Line2D(xdata, ydata)
+
+        legline_marker = Line2D(xdata_marker, ydata_marker)
+
+        # when plotlines are None (only errorbars are drawn), we just
+        # make legline invisible.
+        if plotline is None:
+            legline.set_visible(False)
+            legline_marker.set_visible(False)
+        else:
+            self.update_prop(legline, plotline, legend)
+
+            legline.set_drawstyle("default")
+            legline.set_marker("none")
+
+            self.update_prop(legline_marker, plotline, legend)
+            legline_marker.set_linestyle("None")
+
+            if legend.markerscale != 1:
+                newsz = legline_marker.get_markersize() * legend.markerscale
+                legline_marker.set_markersize(newsz)
+
+        handle_barlinecols = []
+        handle_caplines = []
+
+        if legend._layout != "vertical":
+            verts = [
+                ((x - xerr_size, y), (x + xerr_size, y)) for x, y in zip(xdata_marker, ydata_marker)
+            ]
+            coll = mcoll.LineCollection(verts)
+            self.update_prop(coll, plotline, legend)
+            handle_barlinecols.append(coll)
+
+            # Always show the cap lines
+            if True:
+                capline_left = Line2D(xdata_marker - xerr_size, ydata_marker)
+                capline_right = Line2D(xdata_marker + xerr_size, ydata_marker)
+                self.update_prop(capline_left, plotline, legend)
+                self.update_prop(capline_right, plotline, legend)
+                capline_left.set_marker("|")
+                capline_right.set_marker("|")
+
+                handle_caplines.append(capline_left)
+                handle_caplines.append(capline_right)
+
+        else:
+            verts = [
+                ((x, y - yerr_size), (x, y + yerr_size)) for x, y in zip(xdata_marker, ydata_marker)
+            ]
+            coll = mcoll.LineCollection(verts)
+            self.update_prop(coll, plotline, legend)
+            handle_barlinecols.append(coll)
+
+            # Always show the cap lines
+            if True:
+                capline_left = Line2D(xdata_marker, ydata_marker - yerr_size)
+                capline_right = Line2D(xdata_marker, ydata_marker + yerr_size)
+                self.update_prop(capline_left, plotline, legend)
+                self.update_prop(capline_right, plotline, legend)
+                capline_left.set_marker("_")
+                capline_right.set_marker("_")
+
+                handle_caplines.append(capline_left)
+                handle_caplines.append(capline_right)
+
+        artists = [
+            *handle_barlinecols,
+            *handle_caplines,
+            legline,
+            legline_marker,
+        ]
+        for artist in artists:
+            artist.set_transform(trans)
+        return artists

iplotx/version.py

@@ -2,4 +2,4 @@
 iplotx version information module.
 """
 
-__version__ = "0.12.0"
+__version__ = "1.0.1"

{iplotx-0.12.0.dist-info → iplotx-1.0.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iplotx
-Version: 0.12.0
+Version: 1.0.1
 Summary: Plot networkx from igraph and networkx.
 Project-URL: Homepage, https://github.com/fabilab/iplotx
 Project-URL: Documentation, https://readthedocs.org/iplotx
@@ -53,14 +53,15 @@ 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) (zero dependency)
+  - [graph-tool](https://graph-tool.skewed.de/)
+  - [zero-dependency](https://iplotx.readthedocs.io/en/latest/gallery/plot_simplenetworkdataprovider.html#sphx-glr-gallery-plot-simplenetworkdataprovider-py)
 - **trees**:
   - [ETE4](https://etetoolkit.github.io/ete/)
   - [cogent3](https://cogent3.org/)
   - [Biopython](https://biopython.org/)
   - [scikit-bio](https://scikit.bio)
   - [dendropy](https://jeetsukumaran.github.io/DendroPy/index.html)
-  - [minimal tree data structure](https://iplotx.readthedocs.io/en/latest/gallery/tree/plot_simpletreedataprovider.html#sphx-glr-gallery-tree-plot-simpletreedataprovider-py) (zero dependency)
+  - [zero-dependency](https://iplotx.readthedocs.io/en/latest/gallery/tree/plot_simpletreedataprovider.html#sphx-glr-gallery-tree-plot-simpletreedataprovider-py)
 
 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.
 
@@ -81,7 +82,7 @@ fig, ax = plt.subplots(figsize=(3, 3))
 ipx.plot(g, ax=ax, layout=layout)
 ```
 
-![Quick start image](docs/source/_static/graph_basic.png)
+![Quick start image](/docs/source/_static/graph_basic.png)
 
 ## Documentation
 See [readthedocs](https://iplotx.readthedocs.io/en/latest/) for the full documentation.
@@ -90,11 +91,11 @@ See [readthedocs](https://iplotx.readthedocs.io/en/latest/) for the full documen
 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 networks from multiple libraries including networkx, igraph and graph-tool, using Matplotlib. ✅
 - Plot trees from multiple libraries such as cogent3, ETE4, skbio, biopython, and dendropy. ✅
 - 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.). ✅
+- Store the plot to disk in many formats (SVG, PNG, PDF, GIF, etc.). ✅
 - 3D network visualisation with depth shading. ✅
 - Efficient plotting of large graphs (up to ~1 million nodes on a laptop). ✅
 - Edit plotting elements after the plot is created, e.g. changing node colors, labels, etc. ✅

{iplotx-0.12.0.dist-info → iplotx-1.0.1.dist-info}/RECORD

@@ -1,14 +1,10 @@
 iplotx/__init__.py,sha256=RzSct91jO8abrxOIn33rKEnDUgYpu1oj4olbObgX_hs,489
-iplotx/artists.py,sha256=XNtRwuvQdKkZCAejILydLD3J5B87sg5xPXuZFv_Gkk8,654
-iplotx/cascades.py,sha256=OPqF7Huls-HFmDA5MCF6DEZlUeRVaXsbQcHBoKAgNJs,8182
-iplotx/groups.py,sha256=g6ahm61BSBmd2weIjr40MvPi_GcNRgvNb9YklQsiza4,6784
+iplotx/artists.py,sha256=2dBDT240zGwKb6tIc_y9pXeyU3LuYeF9wjj2tvi4KJo,730
 iplotx/label.py,sha256=7eS8ByadrhdIFOZz19U4VrS-oXY_ndFYNB-D4RZbFqI,9573
 iplotx/layout.py,sha256=KxmRLqjo8AYCBAmXez8rIiLU2sM34qhb6ox9AHYwRyE,4839
-iplotx/network.py,sha256=mhR1hwlLrATYJfCZUgk7sfmtw3yEjAE0TtE0b-1N8hE,13567
-iplotx/plotting.py,sha256=icEefWJnS2lEGLp4t1LhDSP40JuvNKgOie3FDLOnTMk,13195
-iplotx/tree.py,sha256=TxbNoBHS0CfswrcMIWCNtnOl_3e4-PwCrVo0goywC0U,28807
+iplotx/plotting.py,sha256=FvV33DCuEjJwO9ytiYJuQmfOywgF-cDANd6nEE5s8R0,13211
 iplotx/typing.py,sha256=QLdzV358IiD1CFe88MVp0D77FSx5sSAVUmM_2WPPE8I,1463
-iplotx/version.py,sha256=OAoDyBg_N0NwrLolwb2vnkue-AwN9sTDzRmDcTNfAog,67
+iplotx/version.py,sha256=V7W0rXi0DhtuwovCU4hLuXqTV7XgZp0IPed9QF9xUso,66
 iplotx/vertex.py,sha256=_yYyvusn4vYvi6RBEW6CHa3vnbv43GnZylnMIaK4bG0,16040
 iplotx/art3d/vertex.py,sha256=Xf8Um30X2doCd8KdNN7332F6BxC4k72Mb_GeRAuzQfQ,2545
 iplotx/art3d/edge/__init__.py,sha256=uw1U_mMXqcZAvea-7JbU1PUKULQD1CMMrbwY02tiWRQ,8529
@@ -22,6 +18,7 @@ iplotx/edge/ports.py,sha256=BpkbiEhX4mPBBAhOv4jcKFG4Y8hxXz5GRtVLCC0jbtI,1235
 iplotx/ingest/__init__.py,sha256=S0YfnXcFKseB7ZBQc4yRt0cNDsLlhqdom0TmSY3OY2E,4756
 iplotx/ingest/heuristics.py,sha256=715VqgfKek5LOJnu1vTo7RqPgCl-Bb8Cf6o7_Tt57fA,5797
 iplotx/ingest/typing.py,sha256=61LwNwrTHVh8eqqC778Gr81zPYcUKW61mDgGCCsuGSk,14181
+iplotx/ingest/providers/network/graph_tool.py,sha256=iTCf4zHe4Zmdd8Tlz6j7Xfo_FwfsIiK5JkQfH3uq7TM,3028
 iplotx/ingest/providers/network/igraph.py,sha256=WL9Yx2IF5QhUIoKMlozdyq5HWIZ-IJmNoeS8GOhL0KU,2945
 iplotx/ingest/providers/network/networkx.py,sha256=ehCg4npL073HX-eAG-VoP6refLPsMb3lYG51xt_rNjA,4636
 iplotx/ingest/providers/network/simple.py,sha256=e_aHhiHhN9DrMoNrt7tEMPURXGhQ1TYRPzsxDEptUlc,3766
@@ -31,13 +28,18 @@ iplotx/ingest/providers/tree/dendropy.py,sha256=uRMe46PfDPUTeNInUO2Gbp4pVr-WIFIZ
 iplotx/ingest/providers/tree/ete4.py,sha256=D7usSq0MOjzrk3EoLi834IlaDGwv7_qG6Qt0ptfKqfI,928
 iplotx/ingest/providers/tree/simple.py,sha256=aV9wGqBomJ5klM_aJQeuL_Q_J1pLCv6AFN98BPDiKUw,2593
 iplotx/ingest/providers/tree/skbio.py,sha256=O1KUr8tYi28pZ3VVjapgO4Uj-YpMuix3GhOH5je8Lv4,822
+iplotx/network/__init__.py,sha256=oEv6f8oFYrtcI_NKabr8a_oIWTc1jXXTl_yO1xox_rE,13575
+iplotx/network/groups.py,sha256=E_eYVXRHjv1DcyA4RupTkMa-rRFrIKkt9Rxn_Elw9Nc,6796
 iplotx/style/__init__.py,sha256=rf1GutrE8hHUhCoe4FGKYX-aNtHuu_U-kYQnqUxZNrY,10282
 iplotx/style/leaf_info.py,sha256=3xBn7xv9Uy2KAqdhM9S6ew5ZBJrGRTXRL3xXb8atfLw,1018
 iplotx/style/library.py,sha256=58Y8BlllGLsR4pQM7_PVCP5tH6_4GkchXZvJpqGHlcg,8534
+iplotx/tree/__init__.py,sha256=mFCgXSusB1dSMc-xN_zOc5PojpEf_XyP8yR3xeZVQMY,30065
+iplotx/tree/cascades.py,sha256=on5GyqbWasl1zgK7bYXYQE0LOSfHc1z-1hnm0GWd6aw,8184
+iplotx/tree/scalebar.py,sha256=Yxt_kF8JdTwKGa8Jzqt3qVePPK5ZBG8P0EiONrsh3E8,11863
 iplotx/utils/geometry.py,sha256=6RrC6qaB0-1vIk1LhGA4CfsiMd-9JNniSPyL_l9mshE,9245
 iplotx/utils/internal.py,sha256=WWfcZDGK8Ut1y_tOHRGg9wSqY1bwSeLQO7dHM_8Tvwo,107
 iplotx/utils/matplotlib.py,sha256=p_53Oamof0RI4mtV8HrdDtZbgVqUxeUZ_KDvLZSiBUQ,8604
 iplotx/utils/style.py,sha256=vyNP80nDYVinqm6_9ltCJCtjK35ZcGlHvOskNv3eQBc,4225
-iplotx-0.12.0.dist-info/METADATA,sha256=OcfxvA_JL2GOXYH7_67iDL1N4_U3fDm7--3nXbUHKU8,5087
-iplotx-0.12.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-iplotx-0.12.0.dist-info/RECORD,,
+iplotx-1.0.1.dist-info/METADATA,sha256=jxmMX1X7reQl_O0RJ1GtOS1kT0p8Nkkwoa7rTEwX3QQ,5053
+iplotx-1.0.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+iplotx-1.0.1.dist-info/RECORD,,