iplotx 0.4.0__py3-none-any.whl → 0.5.1__py3-none-any.whl

iplotx/tree.py

@@ -14,6 +14,7 @@ from .style import (
     context,
     get_style,
     rotate_style,
+    merge_styles,
 )
 from .utils.matplotlib import (
     _stale_wrapper,
@@ -63,9 +64,7 @@ class TreeArtist(mpl.artist.Artist):
         tree,
         layout: Optional[str] = "horizontal",
         directed: bool | str = False,
-        vertex_labels: Optional[
-            bool | list[str] | dict[Hashable, str] | pd.Series
-        ] = None,
+        vertex_labels: Optional[bool | list[str] | dict[Hashable, str] | pd.Series] = None,
         edge_labels: Optional[Sequence | dict[Hashable, str] | pd.Series] = None,
         leaf_labels: Optional[Sequence | dict[Hashable, str]] | pd.Series = None,
         transform: mpl.transforms.Transform = mpl.transforms.IdentityTransform(),
@@ -193,9 +192,7 @@ class TreeArtist(mpl.artist.Artist):
 
     def get_layout(self, kind="vertex"):
         """Get vertex or edge layout."""
-        layout_columns = [
-            f"_ipx_layout_{i}" for i in range(self._ipx_internal_data["ndim"])
-        ]
+        layout_columns = [f"_ipx_layout_{i}" for i in range(self._ipx_internal_data["ndim"])]
 
         if kind == "vertex":
             layout = self._ipx_internal_data["vertex_df"][layout_columns]
@@ -264,9 +261,7 @@ class TreeArtist(mpl.artist.Artist):
 
     def get_leaf_vertices(self) -> Optional[VertexCollection]:
         """Get leaf VertexCollection artist."""
-        if hasattr(self, "_leaf_vertices"):
-            return self._leaf_vertices
-        return None
+        return self._leaf_vertices
 
     def get_leaf_edges(self) -> Optional[LeafEdgeCollection]:
         """Get LeafEdgeCollection artist if present."""
@@ -284,12 +279,11 @@ class TreeArtist(mpl.artist.Artist):
 
     def get_leaf_labels(self) -> Optional[LabelCollection]:
         """Get the leaf label artist if present."""
-        if hasattr(self, "_leaf_vertices"):
-            return self._leaf_vertices.get_labels()
-        return None
+        return self._leaf_vertices.get_labels()
 
     def get_leaf_edge_labels(self) -> Optional[LabelCollection]:
         """Get the leaf edge label artist if present."""
+        # TODO: leaf edge labels are basically unsupported as of now
         if hasattr(self, "_leaf_edges"):
             return self._leaf_edges.get_labels()
         return None
@@ -312,8 +306,6 @@ class TreeArtist(mpl.artist.Artist):
         """Add edges from the leaf to the max leaf depth."""
         # If there are no leaves, no leaf labels, or leaves are not deep,
         # skip leaf edges
-        if not hasattr(self, "_leaf_vertices"):
-            return
         leaf_style = get_style(".leaf", {})
         if ("deep" not in leaf_style) and self.get_leaf_labels() is None:
             return
@@ -397,16 +389,14 @@ class TreeArtist(mpl.artist.Artist):
         if user_leaf_style.get("deep", True):
             if layout_name == "radial":
                 leaf_layout.iloc[:, 0] = leaf_layout.iloc[:, 0].max()
-            elif layout_name == "horizontal":
-                if orientation == "right":
-                    leaf_layout.iloc[:, 0] = leaf_layout.iloc[:, 0].max()
-                else:
-                    leaf_layout.iloc[:, 0] = leaf_layout.iloc[:, 0].min()
-            elif layout_name == "vertical":
-                if orientation == "descending":
-                    leaf_layout.iloc[:, 1] = leaf_layout.iloc[:, 1].min()
-                else:
-                    leaf_layout.iloc[:, 1] = leaf_layout.iloc[:, 1].max()
+            elif (layout_name, orientation) == ("horizontal", "right"):
+                leaf_layout.iloc[:, 0] = leaf_layout.iloc[:, 0].max()
+            elif (layout_name, orientation) == ("horizontal", "left"):
+                leaf_layout.iloc[:, 0] = leaf_layout.iloc[:, 0].min()
+            elif (layout_name, orientation) == ("vertical", "descending"):
+                leaf_layout.iloc[:, 1] = leaf_layout.iloc[:, 1].min()
+            elif (layout_name, orientation) == ("vertical", "ascending"):
+                leaf_layout.iloc[:, 1] = leaf_layout.iloc[:, 1].max()
             else:
                 raise ValueError(
                     f"Layout and orientation not supported: {layout_name}, {orientation}."
@@ -471,7 +461,24 @@ class TreeArtist(mpl.artist.Artist):
         """Add cascade patches."""
         # NOTE: If leaf labels are present and the cascades are requested to wrap around them,
         # we have to compute the max extend of the cascades from the leaf labels.
-        maxdepth = None
+        layout = self.get_layout()
+        layout_name = self._ipx_internal_data["layout_name"]
+        orientation = self._ipx_internal_data["orientation"]
+        maxdepth = 1e-10
+        if layout_name == "horizontal":
+            if orientation == "right":
+                maxdepth = layout.values[:, 0].max()
+            else:
+                maxdepth = layout.values[:, 0].min()
+        elif layout_name == "vertical":
+            if orientation == "descending":
+                maxdepth = layout.values[:, 1].min()
+            else:
+                maxdepth = layout.values[:, 1].max()
+        elif layout_name == "radial":
+            # layout values are: r, theta
+            maxdepth = layout.values[:, 0].max()
+
         style_cascade = get_style(".cascade")
         extend_to_labels = style_cascade.get("extend", False) == "leaf_labels"
         has_leaf_labels = self.get_leaf_labels() is not None
@@ -483,9 +490,9 @@ class TreeArtist(mpl.artist.Artist):
 
         self._cascades = CascadeCollection(
             tree=self.tree,
-            layout=self.get_layout(),
-            layout_name=self._ipx_internal_data["layout_name"],
-            orientation=self._ipx_internal_data["orientation"],
+            layout=layout,
+            layout_name=layout_name,
+            orientation=orientation,
             style=style_cascade,
             provider=data_providers["tree"][self._ipx_internal_data["tree_library"]],
             transform=self.get_offset_transform(),
@@ -496,9 +503,7 @@ class TreeArtist(mpl.artist.Artist):
         layout_name = self.get_layout_name()
         if layout_name == "radial":
             maxdepth = 0
-            bboxes = self.get_leaf_labels().get_datalims_children(
-                self.get_offset_transform()
-            )
+            bboxes = self.get_leaf_labels().get_datalims_children(self.get_offset_transform())
             for bbox in bboxes:
                 r1 = np.linalg.norm([bbox.xmax, bbox.ymax])
                 r2 = np.linalg.norm([bbox.xmax, bbox.ymin])
@@ -541,9 +546,7 @@ class TreeArtist(mpl.artist.Artist):
         else:
             cmap_fun = None
 
-        edge_df = self._ipx_internal_data["edge_df"].set_index(
-            ["_ipx_source", "_ipx_target"]
-        )
+        edge_df = self._ipx_internal_data["edge_df"].set_index(["_ipx_source", "_ipx_target"])
 
         if "cmap" in edge_style:
             colorarray = []
@@ -551,7 +554,7 @@ class TreeArtist(mpl.artist.Artist):
         adjacent_vertex_ids = []
         waypoints = []
         for i, (vid1, vid2) in enumerate(edge_df.index):
-            edge_stylei = rotate_style(edge_style, index=i, key=(vid1, vid2))
+            edge_stylei = rotate_style(edge_style, index=i, key=vid2)
 
             # FIXME:: Improve this logic. We have three layers of priority:
             # 1. Explicitely set in the style of "plot"
@@ -573,6 +576,8 @@ class TreeArtist(mpl.artist.Artist):
 
             # Tree layout determines waypoints
             waypointsi = edge_stylei.pop("waypoints", None)
+            if isinstance(waypointsi, (bool, np.bool)):
+                waypointsi = ["none", None][int(waypointsi)]
             if waypointsi is None:
                 layout_name = self._ipx_internal_data["layout_name"]
                 if layout_name == "horizontal":
@@ -582,7 +587,9 @@ class TreeArtist(mpl.artist.Artist):
                 elif layout_name == "radial":
                     waypointsi = "r0a1"
                 else:
-                    waypointsi = "none"
+                    raise ValueError(
+                        f"Layout not supported: {layout_name}. ",
+                    )
             waypoints.append(waypointsi)
 
             # These are not the actual edges drawn, only stubs to establish
@@ -630,6 +637,7 @@ class TreeArtist(mpl.artist.Artist):
         self,
         nodes: Sequence[Hashable],
         style: Optional[dict[str, Any] | Sequence[str | dict[str, Any]]] = None,
+        **kwargs,
     ) -> None:
         """Style a subtree of the tree.
 
@@ -639,21 +647,26 @@ class TreeArtist(mpl.artist.Artist):
             style: Style or sequence of styles to apply to the subtree. Each style can
                 be either a string, referring to an internal `iplotx` style, or a dictionary
                 with custom styling elements.
+            kwargs: Additional flat style elements. If both style and kwargs are provided,
+                kwargs is applied last.
         """
+        styles = []
+        if isinstance(style, (str, dict)):
+            styles = [style]
+        elif style is not None:
+            styles = list(style)
+        style = merge_styles(styles + [kwargs])
+
         provider = data_providers["tree"][self._ipx_internal_data["tree_library"]]
 
         # Get last (deepest) common ancestor of the requested nodes
         root = provider(self.tree).get_lca(nodes)
 
         # Populate a DataFrame with the array of properties to update
-        vertex_idx = {
-            node: i for i, node in enumerate(self._ipx_internal_data["vertex_df"].index)
-        }
+        vertex_idx = {node: i for i, node in enumerate(self._ipx_internal_data["vertex_df"].index)}
         edge_idx = {
             node: i
-            for i, node in enumerate(
-                self._ipx_internal_data["edge_df"]["_ipx_target"].values
-            )
+            for i, node in enumerate(self._ipx_internal_data["edge_df"]["_ipx_target"].values)
         }
         vertex_props = {}
         edge_props = {}

iplotx/typing.py

@@ -32,12 +32,14 @@ LayoutType = Union[
     Sequence[Sequence[float]],
     np.ndarray,
     pd.DataFrame,
+    dict[Hashable, Sequence[float] | tuple[float, float]],
     # igraph.Layout,
 ]
 GroupingType = Union[
     Sequence[set],
     Sequence[int],
     Sequence[str],
+    dict[str, set],
     # igraph.clustering.Clustering,
     # igraph.clustering.VertexClustering,
     # igraph.clustering.Cover,

iplotx/utils/geometry.py

@@ -1,5 +1,9 @@
+from typing import (
+    Sequence,
+)
 from math import atan2
 import numpy as np
+import matplotlib as mpl
 
 
 # See also this link for the general answer (using scipy to compute coefficients):
@@ -13,28 +17,7 @@ def _evaluate_squared_bezier(points, t):
 def _evaluate_cubic_bezier(points, t):
     """Evaluate a cubic Bezier curve at t."""
     p0, p1, p2, p3 = points
-    return (
-        (1 - t) ** 3 * p0
-        + 3 * (1 - t) ** 2 * t * p1
-        + 3 * (1 - t) * t**2 * p2
-        + t**3 * p3
-    )
-
-
-def _evaluate_cubic_bezier_derivative(points, t):
-    """Evaluate the derivative of a cubic Bezier curve at t."""
-    p0, p1, p2, p3 = points
-    # (dx / dt, dy / dt) is the parametric gradient
-    # to get the angle from this, one can just atanh(dy/dt, dx/dt)
-    # This is equivalent to computing the actual bezier curve
-    # at low t, of course, which is the geometric interpretation
-    # (obviously, division by t is irrelenant)
-    return (
-        3 * p0 * (1 - t) ** 2
-        + 3 * p1 * (1 - t) * (-3 * t + 1)
-        + 3 * p2 * t * (2 - 3 * t)
-        + 3 * p3 * t**2
-    )
+    return (1 - t) ** 3 * p0 + 3 * (1 - t) ** 2 * t * p1 + 3 * (1 - t) * t**2 * p2 + t**3 * p3
 
 
 def convex_hull(points):
@@ -90,9 +73,7 @@ def _convex_hull_Graham_scan(points):
     pivot_idx = miny_idx[points[miny_idx, 0].argmin()]
 
     # Compute angles against that pivot, ensuring the pivot itself last
-    angles = np.arctan2(
-        points[:, 1] - points[pivot_idx, 1], points[:, 0] - points[pivot_idx, 0]
-    )
+    angles = np.arctan2(points[:, 1] - points[pivot_idx, 1], points[:, 0] - points[pivot_idx, 0])
     angles[pivot_idx] = np.inf
 
     # Sort points by angle
@@ -169,22 +150,36 @@ def _convex_hull_Graham_scan(points):
 
 
 def _compute_group_path_with_vertex_padding(
-    hull,
-    points,
-    transform,
-    vertexpadding=10,
-    points_per_curve=30,
+    hull: np.ndarray | Sequence[int],
+    points: np.ndarray,
+    transform: mpl.transforms.Transform,
+    vertexpadding: int = 10,
     # TODO: check how dpi affects this
-    dpi=72.0,
-):
+    dpi: float = 72.0,
+) -> np.ndarray:
     """Offset path for a group based on vertex padding.
 
-    At the input, the structure is [v1, v1, v1, ..., vn, vn, vn, v1]
-
-    # NOTE: this would look better as a cubic Bezier, but ok for now.
+    Parameters:
+        hull: The coordinates (not indices!) of the convex hull.
+        points: This is the np.ndarray where the coordinates will be written to (output).
+            The length is some integer ppc * len(hull) + 1 because for each vertex, this
+            function wraps around it using a certain fixed ppc number of points, plus the
+            final point for CLOSEPOLY.
+        transform: The transform of the hull points.
+        vertexpadding: The padding to apply to the vertices, in figure coordinates.
+        dpi (WIP): The dpi of the figure renderer.
+
+    Returns:
+        None. The output is written to the `points` array in place. This ensures that the
+        length of this array is unchanged, which is important to ensure that the vertices
+        and SVG codes are in sync.
     """
-    # Short form
-    ppc = points_per_curve
+    if len(hull) == 0:
+        return
+
+    # Short form for point per curve
+    ppc = (len(points) - 1) // len(hull)
+    assert len(points) % ppc == 1
 
     # No padding, set degenerate path
     if vertexpadding == 0:
@@ -196,11 +191,9 @@ def _compute_group_path_with_vertex_padding(
     # Transform into figure coordinates
     trans = transform.transform
     trans_inv = transform.inverted().transform
-    points = trans(points)
 
     # Singleton: draw a circle around it
     if len(hull) == 1:
-
         # NOTE: linspace is double inclusive, which covers CLOSEPOLY
         thetas = np.linspace(
             -np.pi,
@@ -213,7 +206,6 @@ def _compute_group_path_with_vertex_padding(
 
     # Doublet: draw two semicircles
     if len(hull) == 2:
-
         # Unit vector connecting the two points
         dv = trans(hull[0]) - trans(hull[1])
         dv = dv / np.sqrt((dv**2).sum())

iplotx/utils/matplotlib.py

@@ -127,32 +127,35 @@ def _get_label_width_height(text, hpadding=18, vpadding=12, dpi=72.0, **kwargs):
 
 def _compute_mid_coord_and_rot(path, trans):
     """Compute mid point of an edge, straight or curved."""
-    # Distinguish between straight and curved paths
+    # Straight path
     if path.codes[-1] == mpl.path.Path.LINETO:
         coord = path.vertices.mean(axis=0)
-        vtr = trans(path.vertices)
-        rot = atan2(
-            vtr[-1, 1] - vtr[0, 1],
-            vtr[-1, 0] - vtr[0, 0],
-        )
+        v1 = path.vertices[0]
+        v2 = path.vertices[-1]
 
     # Cubic Bezier
     elif path.codes[-1] == mpl.path.Path.CURVE4:
         coord = _evaluate_cubic_bezier(path.vertices, 0.5)
-        # TODO:
-        rot = 0
+        v1 = _evaluate_cubic_bezier(path.vertices, 0.475)
+        v2 = _evaluate_cubic_bezier(path.vertices, 0.525)
 
     # Square Bezier
     elif path.codes[-1] == mpl.path.Path.CURVE3:
         coord = _evaluate_squared_bezier(path.vertices, 0.5)
-        # TODO:
-        rot = 0
+        v1 = _evaluate_squared_bezier(path.vertices, 0.475)
+        v2 = _evaluate_squared_bezier(path.vertices, 0.525)
 
     else:
         raise ValueError(
             "Curve type not straight and not squared/cubic Bezier, cannot compute mid point."
         )
 
+    v1 = trans(v1)
+    v2 = trans(v2)
+    rot = atan2(
+        v2[1] - v1[1],
+        v2[0] - v1[0],
+    )
     return coord, rot
 
 

iplotx/utils/style.py

@@ -1,9 +1,14 @@
 import copy
+from collections import defaultdict
 
 
 def copy_with_deep_values(style):
     """Make a deep copy of the style dict but do not create copies of the keys."""
-    newdict = {}
+    # Defaultdict should be respected
+    if hasattr(style, "default_factory"):
+        newdict = defaultdict(lambda: style.default_factory())
+    else:
+        newdict = {}
     for key, value in style.items():
         if isinstance(value, dict):
             newdict[key] = copy_with_deep_values(value)

iplotx/version.py

@@ -2,4 +2,4 @@
 iplotx version information module.
 """
 
-__version__ = "0.4.0"
+__version__ = "0.5.1"

iplotx/vertex.py

@@ -55,7 +55,7 @@ class VertexCollection(PatchCollection):
         *args,
         layout_coordinate_system: str = "cartesian",
         style: Optional[dict[str, Any]] = None,
-        labels: Optional[Sequence[str]] = None,
+        labels: Optional[Sequence[str] | pd.Series] = None,
         **kwargs,
     ):
         """Initialise the VertexCollection.
@@ -69,10 +69,13 @@ class VertexCollection(PatchCollection):
 
         self._index = layout.index
         self._style = style
-        self._labels = labels
         self._layout = layout
         self._layout_coordinate_system = layout_coordinate_system
 
+        if (labels is not None) and (not isinstance(labels, pd.Series)):
+            labels = pd.Series(labels, index=self._layout.index)
+        self._labels = labels
+
         # Create patches from structured data
         patches, sizes, kwargs2 = self._init_vertex_patches()
 
@@ -91,6 +94,10 @@ class VertexCollection(PatchCollection):
         if self._labels is not None:
             self._compute_label_collection()
 
+    def __len__(self):
+        """Return the number of vertices in the collection."""
+        return len(self.get_paths())
+
     def get_children(self) -> tuple[mpl.artist.Artist]:
         """Get the children artists.
 
@@ -227,9 +234,7 @@ class VertexCollection(PatchCollection):
 
         if style.get("size", 20) == "label":
             if self._labels is None:
-                warnings.warn(
-                    "No labels found, cannot resize vertices based on labels."
-                )
+                warnings.warn("No labels found, cannot resize vertices based on labels.")
                 style["size"] = get_style("default.vertex")["size"]
 
         if "cmap" in style:
@@ -265,9 +270,7 @@ class VertexCollection(PatchCollection):
         transform = self.get_offset_transform()
 
         style = (
-            copy_with_deep_values(self._style.get("label", None))
-            if self._style is not None
-            else {}
+            copy_with_deep_values(self._style.get("label", None)) if self._style is not None else {}
         )
         forbidden_props = ["hpadding", "vpadding"]
         for prop in forbidden_props:
@@ -380,9 +383,7 @@ def make_patch(
     elif marker in ("s", "square", "r", "rectangle"):
         art = Rectangle((-size[0] / 2, -size[1] / 2), size[0], size[1], **kwargs)
     elif marker in ("^", "triangle"):
-        art = RegularPolygon(
-            (0, 0), numVertices=3, radius=size[0] / np.sqrt(2), **kwargs
-        )
+        art = RegularPolygon((0, 0), numVertices=3, radius=size[0] / np.sqrt(2), **kwargs)
     elif marker in ("v", "triangle_down"):
         art = RegularPolygon(
             (0, 0),
@@ -408,21 +409,13 @@ def make_patch(
             **kwargs,
         )
     elif marker in ("d", "diamond"):
-        art = RegularPolygon(
-            (0, 0), numVertices=4, radius=size[0] / np.sqrt(2), **kwargs
-        )
+        art = RegularPolygon((0, 0), numVertices=4, radius=size[0] / np.sqrt(2), **kwargs)
     elif marker in ("p", "pentagon"):
-        art = RegularPolygon(
-            (0, 0), numVertices=5, radius=size[0] / np.sqrt(2), **kwargs
-        )
+        art = RegularPolygon((0, 0), numVertices=5, radius=size[0] / np.sqrt(2), **kwargs)
     elif marker in ("h", "hexagon"):
-        art = RegularPolygon(
-            (0, 0), numVertices=6, radius=size[0] / np.sqrt(2), **kwargs
-        )
+        art = RegularPolygon((0, 0), numVertices=6, radius=size[0] / np.sqrt(2), **kwargs)
     elif marker in ("8", "octagon"):
-        art = RegularPolygon(
-            (0, 0), numVertices=8, radius=size[0] / np.sqrt(2), **kwargs
-        )
+        art = RegularPolygon((0, 0), numVertices=8, radius=size[0] / np.sqrt(2), **kwargs)
     elif marker in ("e", "ellipse"):
         art = Ellipse((0, 0), size[0], size[1], **kwargs)
     elif marker in ("*", "star"):

{iplotx-0.4.0.dist-info → iplotx-0.5.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iplotx
-Version: 0.4.0
+Version: 0.5.1
 Summary: Plot networkx from igraph and networkx.
 Project-URL: Homepage, https://github.com/fabilab/iplotx
 Project-URL: Documentation, https://readthedocs.org/iplotx
@@ -39,12 +39,29 @@ Description-Content-Type: text/markdown
 ![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
-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
@@ -71,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.1.dist-info/RECORD

@@ -0,0 +1,38 @@
+iplotx/__init__.py,sha256=MKb9UCXKgDHHkeATuJWxYdM-AotfBo2fbWy-Rkbn9Is,509
+iplotx/artists.py,sha256=Bpn6NS8S_B_E4OW88JYW6aEu2bIuIQJmbs2paTmBAoY,522
+iplotx/cascades.py,sha256=OPqF7Huls-HFmDA5MCF6DEZlUeRVaXsbQcHBoKAgNJs,8182
+iplotx/groups.py,sha256=_9KdIiTAi1kXtd2mDywgBJCbqoRq2z-5fzOPf76Wgb8,6287
+iplotx/label.py,sha256=i107wE-9kC_MVWsgWeYG6sRy_ZmyvITNm2laIij9SR0,8761
+iplotx/layout.py,sha256=KxmRLqjo8AYCBAmXez8rIiLU2sM34qhb6ox9AHYwRyE,4839
+iplotx/network.py,sha256=SlmDgc4tbCfvO08QWk-jUXrUfaz6S3xoXQVg6rP1910,11345
+iplotx/plotting.py,sha256=RZj-E_2R8AbXoJmxr_qAC-g_nOudqep-TDSIV4QB9BM,7408
+iplotx/tree.py,sha256=iILQRKUZzcDKIiwI1LheSuixi5y_3PAQrz61vdwi6DU,27448
+iplotx/typing.py,sha256=QLdzV358IiD1CFe88MVp0D77FSx5sSAVUmM_2WPPE8I,1463
+iplotx/version.py,sha256=dsB8xhRODrwa4OXOSbePgoZzy41j_DudRu80QRgFkpw,66
+iplotx/vertex.py,sha256=OjDIkJCNU-IhZUVeZTSzGwTlHLrxu27lUThiUuEb6Qs,14497
+iplotx/edge/__init__.py,sha256=0w-BDZpVyR4qM908PM5DzlNVXwwfxAeDNyHNXPWPgcc,26237
+iplotx/edge/arrow.py,sha256=y8xMZY1eR5BXBmkX0_aDIn-3CeqaL6jwGGLw-ndUf50,12867
+iplotx/edge/geometry.py,sha256=g9_z7nwlQhQm9Tvj2tme9dGboxkN-4jeUUg02gU-vOk,13285
+iplotx/edge/leaf.py,sha256=SyGMv2PIOoH0pey8-aMVaZheK3hNe1Qz_okcyWbc4E4,4268
+iplotx/edge/ports.py,sha256=BpkbiEhX4mPBBAhOv4jcKFG4Y8hxXz5GRtVLCC0jbtI,1235
+iplotx/ingest/__init__.py,sha256=tsXDoa7Rs6Y1ulWtjCcUsO4tQIigeQ6ZMiU2PQDyhwQ,4751
+iplotx/ingest/heuristics.py,sha256=715VqgfKek5LOJnu1vTo7RqPgCl-Bb8Cf6o7_Tt57fA,5797
+iplotx/ingest/typing.py,sha256=pi-mn4ULkFjTo_fFdJPUjTHrWzbny4MNgoMylN4mNKM,13940
+iplotx/ingest/providers/network/igraph.py,sha256=8dWeaQ_ZNdltC098V2YeLXsGdJHQnBa6shF1GAfl0Zg,2973
+iplotx/ingest/providers/network/networkx.py,sha256=FIXMI3hXU1WtAzPVlQZcz47b-4V2omeHttnNTgS2gQw,4328
+iplotx/ingest/providers/network/simple.py,sha256=yKILiE3-ZhBUGSs7eYuhV8tQDyueCosbbgovZZYpSPQ,3664
+iplotx/ingest/providers/tree/biopython.py,sha256=4N_54cVyHHPcASJZGr6pHKE2p5R3i8Cm307SLlSLHLA,1480
+iplotx/ingest/providers/tree/cogent3.py,sha256=JmELbDK7LyybiJzFNbmeqZ4ySJoDajvFfJebpNfFKWo,1073
+iplotx/ingest/providers/tree/ete4.py,sha256=D7usSq0MOjzrk3EoLi834IlaDGwv7_qG6Qt0ptfKqfI,928
+iplotx/ingest/providers/tree/simple.py,sha256=vOAlQbkm2HdlBTQab6s7mjAnLibVmeNOfc6y6UpBqzw,2533
+iplotx/ingest/providers/tree/skbio.py,sha256=O1KUr8tYi28pZ3VVjapgO4Uj-YpMuix3GhOH5je8Lv4,822
+iplotx/style/__init__.py,sha256=4K6EtAKOFth3zS_jdaDCvOEMeZxIgnMM_rtpH_G74io,12253
+iplotx/style/leaf_info.py,sha256=2XckYhvE3FvNYUaQj_CY2HwtYfZA8FUQ7uBXe_ukaWU,938
+iplotx/style/library.py,sha256=yryxQUSHMIwGgeS0Iq1BediVRRaFguJcjhXMj_vsHo8,8007
+iplotx/utils/geometry.py,sha256=UH2gAcM5rYW7ADnJEm7HIJTpPF4UOm8P3vjSVCOGjqM,9192
+iplotx/utils/internal.py,sha256=WWfcZDGK8Ut1y_tOHRGg9wSqY1bwSeLQO7dHM_8Tvwo,107
+iplotx/utils/matplotlib.py,sha256=KpkuwXuSqpYbPVKbrlP8u_1Ry5gy5q60ZBrFiR-do_Q,5284
+iplotx/utils/style.py,sha256=wMWxJykxBD-JmcN8-rSKlWcV6pMfwKgR4EzSpk_NX8k,547
+iplotx-0.5.1.dist-info/METADATA,sha256=P1TOV3nMA2ihSTdEFQLNdRztBrKUmpVcIpxNFYPcOQE,4889
+iplotx-0.5.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+iplotx-0.5.1.dist-info/RECORD,,