iplotx 0.2.1__py3-none-any.whl → 0.3.0__py3-none-any.whl

iplotx/tree.py

@@ -3,12 +3,14 @@ from typing import (
     Sequence,
 )
 from collections.abc import Hashable
+from collections import defaultdict
 
 import numpy as np
 import pandas as pd
 import matplotlib as mpl
 
 from .style import (
+    context,
     get_style,
     rotate_style,
 )
@@ -19,6 +21,7 @@ from .utils.matplotlib import (
 )
 from .ingest import (
     ingest_tree_data,
+    data_providers,
 )
 from .vertex import (
     VertexCollection,
@@ -30,6 +33,9 @@ from .edge import (
 from .label import (
     LabelCollection,
 )
+from .cascades import (
+    CascadeCollection,
+)
 from .network import (
     _update_from_internal,
 )
@@ -51,13 +57,14 @@ class TreeArtist(mpl.artist.Artist):
     def __init__(
         self,
         tree,
-        layout="horizontal",
-        orientation="right",
+        layout: Optional[str] = "horizontal",
+        orientation: Optional[str] = None,
         directed: bool | str = False,
         vertex_labels: Optional[
             bool | list[str] | dict[Hashable, str] | pd.Series
         ] = None,
-        edge_labels: Optional[Sequence] = 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(),
         offset_transform: Optional[mpl.transforms.Transform] = None,
     ):
@@ -73,6 +80,11 @@ class TreeArtist(mpl.artist.Artist):
                 following choices: "parent" or "child".
             vertex_labels: Labels for the vertices. Can be a list, dictionary, or pandas Series.
             edge_labels: Labels for the edges. Can be a sequence of strings.
+            leaf_labels: Labels for the leaves. Can be a sequence of strings or a pandas Series.
+                These labels are positioned at the depth of the deepest leaf. If you want to
+                label leaves next to each leaf independently of how deep they are, use
+                the "vertex_labels" parameter instead - usually as a dict with the leaves
+                as keys and the labels as values.
             transform: The transform to apply to the tree artist. This is usually the identity.
             offset_transform: The offset transform to apply to the tree artist. This is
                 usually `ax.transData`.
@@ -84,8 +96,10 @@ class TreeArtist(mpl.artist.Artist):
             layout,
             orientation=orientation,
             directed=directed,
+            layout_style=get_style(".layout", {}),
             vertex_labels=vertex_labels,
             edge_labels=edge_labels,
+            leaf_labels=leaf_labels,
         )
 
         super().__init__()
@@ -101,6 +115,12 @@ class TreeArtist(mpl.artist.Artist):
 
         self._add_vertices()
         self._add_edges()
+        self._add_leaf_vertices()
+
+        # NOTE: cascades need to be created after leaf vertices in case
+        # they are requested to wrap around them.
+        if "cascade" in self.get_vertices().get_style():
+            self._add_cascades()
 
     def get_children(self) -> tuple[mpl.artist.Artist]:
         """Get the children of this artist.
@@ -108,7 +128,12 @@ class TreeArtist(mpl.artist.Artist):
         Returns:
             The artists for vertices and edges.
         """
-        return (self._vertices, self._edges)
+        children = [self._vertices, self._edges]
+        if hasattr(self, "_leaf_vertices"):
+            children.append(self._leaf_vertices)
+        if hasattr(self, "_cascades"):
+            children.append(self._cascades)
+        return tuple(children)
 
     def set_figure(self, fig) -> None:
         """Set the figure for this artist and its children.
@@ -120,6 +145,23 @@ class TreeArtist(mpl.artist.Artist):
         for child in self.get_children():
             child.set_figure(fig)
 
+        # At the end, if there are cadcades with extent depending on
+        # leaf edges, we should update them
+        self._update_cascades_extent()
+
+    def _update_cascades_extent(self) -> None:
+        """Update cascades if extent depends on leaf labels."""
+        if not hasattr(self, "_cascades"):
+            return
+
+        style_cascade = self.get_vertices().get_style()["cascade"]
+        extend_to_labels = style_cascade.get("extend", False) == "leaf_labels"
+        if not extend_to_labels:
+            return
+
+        maxdepth = self._get_maxdepth_leaf_labels()
+        self._cascades.set_maxdepth(maxdepth)
+
     def get_offset_transform(self):
         """Get the offset transform (for vertices/edges)."""
         return self._offset_transform
@@ -137,6 +179,16 @@ class TreeArtist(mpl.artist.Artist):
         if kind == "vertex":
             layout = self._ipx_internal_data["vertex_df"][layout_columns]
             return layout
+        elif kind == "leaf":
+            leaves = self._ipx_internal_data["leaf_df"].index
+            layout = self._ipx_internal_data["vertex_df"][layout_columns]
+            # NOTE: workaround for a pandas bug
+            idxs = []
+            for i, vid in enumerate(layout.index):
+                if vid in leaves:
+                    idxs.append(i)
+            layout = layout.iloc[idxs]
+            return layout
 
         elif kind == "edge":
             return self._ipx_internal_data["edge_df"][layout_columns]
@@ -161,6 +213,14 @@ class TreeArtist(mpl.artist.Artist):
         edge_bbox = self._edges.get_datalim(transData)
         bbox = mpl.transforms.Bbox.union([bbox, edge_bbox])
 
+        if hasattr(self, "_cascades"):
+            cascades_bbox = self._cascades.get_datalim(transData)
+            bbox = mpl.transforms.Bbox.union([bbox, cascades_bbox])
+
+        if hasattr(self, "_leaf_vertices"):
+            leaf_labels_bbox = self._leaf_vertices.get_datalim(transData)
+            bbox = mpl.transforms.Bbox.union([bbox, leaf_labels_bbox])
+
         bbox = bbox.expanded(sw=(1.0 + pad), sh=(1.0 + pad))
         return bbox
 
@@ -178,6 +238,12 @@ class TreeArtist(mpl.artist.Artist):
         """Get EdgeCollection artist."""
         return self._edges
 
+    def get_leaf_vertices(self) -> Optional[VertexCollection]:
+        """Get leaf VertexCollection artist."""
+        if hasattr(self, "_leaf_vertices"):
+            return self._leaf_vertices
+        return None
+
     def get_vertex_labels(self) -> LabelCollection:
         """Get list of vertex label artists."""
         return self._vertices.get_labels()
@@ -186,6 +252,11 @@ class TreeArtist(mpl.artist.Artist):
         """Get list of edge label artists."""
         return self._edges.get_labels()
 
+    def get_leaf_labels(self) -> Optional[LabelCollection]:
+        if hasattr(self, "_leaf_vertices"):
+            return self._leaf_vertices.get_labels()
+        return None
+
     def _add_vertices(self) -> None:
         """Add vertices to the tree."""
         self._vertices = VertexCollection(
@@ -200,6 +271,101 @@ class TreeArtist(mpl.artist.Artist):
             offset_transform=self.get_offset_transform(),
         )
 
+    def _add_leaf_vertices(self) -> None:
+        """Add invisible deep vertices as leaf label anchors."""
+        leaf_layout = self.get_layout("leaf").copy()
+        # Set all to max depth
+        depth_idx = int(self._ipx_internal_data["layout_name"] == "vertical")
+        leaf_layout.iloc[:, depth_idx] = leaf_layout.iloc[:, depth_idx].max()
+
+        # Set invisible vertices with visible labels
+        layout_name = self._ipx_internal_data["layout_name"]
+        orientation = self._ipx_internal_data["orientation"]
+        if layout_name == "radial":
+            ha = "auto"
+        elif orientation in ("left", "ascending"):
+            ha = "right"
+        else:
+            ha = "left"
+
+        leaf_vertex_style = {
+            "size": 0,
+            "label": {
+                "verticalalignment": "center",
+                "horizontalalignment": ha,
+                "hmargin": 5,
+                "bbox": {
+                    "facecolor": (1, 1, 1, 0),
+                },
+            },
+        }
+        with context({"vertex": leaf_vertex_style}):
+            leaf_vertex_style = get_style(".vertex")
+            self._leaf_vertices = VertexCollection(
+                layout=leaf_layout,
+                layout_coordinate_system=self._ipx_internal_data.get(
+                    "layout_coordinate_system",
+                    "catesian",
+                ),
+                style=leaf_vertex_style,
+                labels=self._get_label_series("leaf"),
+                transform=self.get_transform(),
+                offset_transform=self.get_offset_transform(),
+            )
+
+    def _add_cascades(self) -> None:
+        """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
+        style_cascade = self.get_vertices().get_style()["cascade"]
+        extend_to_labels = style_cascade.get("extend", False) == "leaf_labels"
+        has_leaf_labels = self.get_leaf_labels() is not None
+        if extend_to_labels and not has_leaf_labels:
+            raise ValueError("Cannot extend cascades: no leaf labels.")
+
+        if extend_to_labels and has_leaf_labels:
+            maxdepth = self._get_maxdepth_leaf_labels()
+
+        self._cascades = CascadeCollection(
+            tree=self.tree,
+            layout=self.get_layout(),
+            layout_name=self._ipx_internal_data["layout_name"],
+            orientation=self._ipx_internal_data["orientation"],
+            style=style_cascade,
+            provider=data_providers["tree"][self._ipx_internal_data["tree_library"]],
+            transform=self.get_offset_transform(),
+            maxdepth=maxdepth,
+        )
+
+    def _get_maxdepth_leaf_labels(self):
+        layout_name = self.get_layout_name()
+        if layout_name == "radial":
+            maxdepth = 0
+            # These are the text boxes, they must all be included
+            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])
+                r3 = np.linalg.norm([bbox.xmin, bbox.ymax])
+                r4 = np.linalg.norm([bbox.xmin, bbox.ymin])
+                maxdepth = max(maxdepth, r1, r2, r3, r4)
+        else:
+            orientation = self.get_orientation()
+            bbox = self.get_leaf_labels().get_datalim(self.get_offset_transform())
+            if (layout_name, orientation) == ("horizontal", "right"):
+                maxdepth = bbox.xmax
+            elif layout_name == "horizontal":
+                maxdepth = bbox.xmin
+            elif (layout_name, orientation) == ("vertical", "descending"):
+                maxdepth = bbox.ymin
+            elif layout_name == "vertical":
+                maxdepth = bbox.ymax
+
+        return maxdepth
+
     def _add_edges(self) -> None:
         """Add edges to the network artist.
 
@@ -259,7 +425,7 @@ class TreeArtist(mpl.artist.Artist):
                 if layout_name == "horizontal":
                     waypointsi = "x0y1"
                 elif layout_name == "vertical":
-                    waypointsi = "y0y0"
+                    waypointsi = "y0x1"
                 elif layout_name == "radial":
                     waypointsi = "r0a1"
                 else:
@@ -296,17 +462,32 @@ class TreeArtist(mpl.artist.Artist):
         if "cmap" in edge_style:
             self._edges.set_array(colorarray)
 
+    def get_layout_name(self) -> str:
+        """Get the layout name."""
+        return self._ipx_internal_data["layout_name"]
+
+    def get_orientation(self) -> Optional[str]:
+        """Get the orientation of the tree layout."""
+        return self._ipx_internal_data.get("orientation", None)
+
     @_stale_wrapper
     def draw(self, renderer) -> None:
         """Draw each of the children, with some buffering mechanism."""
         if not self.get_visible():
             return
 
-        # FIXME: Callbacks on stale vertices/edges??
+        # At the end, if there are cadcades with extent depending on
+        # leaf edges, we should update them
+        self._update_cascades_extent()
 
         # NOTE: looks like we have to manage the zorder ourselves
-        # this is kind of funny actually
+        # this is kind of funny actually. Btw we need to ensure
+        # that cascades are drawn behind (earlier than) vertices
+        # and edges at equal zorder because it looks better that way.
+        z_suborder = defaultdict(int)
+        if hasattr(self, "_cascades"):
+            z_suborder[self._cascades] = -1
         children = list(self.get_children())
-        children.sort(key=lambda x: x.zorder)
+        children.sort(key=lambda x: (x.zorder, z_suborder[x]))
         for art in children:
             art.draw(renderer)

iplotx/version.py

@@ -2,4 +2,4 @@
 iplotx version information module.
 """
 
-__version__ = "0.2.1"
+__version__ = "0.3.0"

iplotx/vertex.py

@@ -104,6 +104,7 @@ class VertexCollection(PatchCollection):
         """Set the figure for this artist and all children."""
         super().set_figure(fig)
         self.set_sizes(self._sizes, self.get_figure(root=True).dpi)
+        self._update_children()
         for child in self.get_children():
             child.set_figure(fig)
 
@@ -209,6 +210,10 @@ class VertexCollection(PatchCollection):
         self._update_offsets_from_layout()
         self.stale = True
 
+    def get_style(self) -> Optional[dict[str, Any]]:
+        """Get the style dictionary for the vertices."""
+        return self._style
+
     def _init_vertex_patches(self):
         style = self._style or {}
         if "cmap" in style:
@@ -231,13 +236,11 @@ class VertexCollection(PatchCollection):
         patches = []
         sizes = []
         for i, (vid, row) in enumerate(self._layout.iterrows()):
-            if style.get("size", 20) == "label":
-                # NOTE: it's ok to overwrite the dict here
-                style["size"] = _get_label_width_height(
+            stylei = rotate_style(style, index=i, key=vid)
+            if stylei.get("size", 20) == "label":
+                stylei["size"] = _get_label_width_height(
                     str(self._labels[vid]), **style.get("label", {})
                 )
-
-            stylei = rotate_style(style, index=i, key=vid)
             if cmap_fun is not None:
                 colorarray.append(style["facecolor"])
                 stylei["facecolor"] = cmap_fun(stylei["facecolor"])
@@ -299,6 +302,30 @@ class VertexCollection(PatchCollection):
         if val and hasattr(self, "stale_callback_post"):
             self.stale_callback_post(self)
 
+    def _update_children(self) -> None:
+        """Update children before drawing and before first render."""
+        self._update_labels()
+
+    def _update_labels(self) -> None:
+        """Update labels before drawing.
+
+        NOTE: This needs to work in figure coordinates.
+        """
+        if not hasattr(self, "_label_collection"):
+            return
+
+        if self.get_layout_coordinate_system() != "polar":
+            return
+
+        transform = self.get_offset_transform()
+        trans = transform.transform
+
+        zero_fig = trans(np.array([0, 0]))
+        offsets_fig = trans(self.get_labels().get_offsets())
+        doffsets_fig = offsets_fig - zero_fig
+        rotations = np.arctan2(doffsets_fig[:, 1], doffsets_fig[:, 0])
+        self.get_labels().set_rotations(rotations)
+
     @mpl.artist.allow_rasterization
     def draw(self, renderer):
         if not self.get_visible():
@@ -311,6 +338,9 @@ class VertexCollection(PatchCollection):
 
         self.set_sizes(self._sizes, self.get_figure(root=True).dpi)
 
+        # Set the label rotations already, hopefully this is not too early
+        self._update_children()
+
         # NOTE: This draws the vertices first, then the labels.
         # The correct order would be vertex1->label1->vertex2->label2, etc.
         # We might fix if we manage to find a way to do it.
@@ -320,10 +350,12 @@ class VertexCollection(PatchCollection):
 
 
 def make_patch(
-    marker: str, size: float | Sequence[float], **kwargs
+    marker: str = "o",
+    size: float | Sequence[float] = 20,
+    **kwargs,
 ) -> tuple[Patch, float]:
     """Make a patch of the given marker shape and size."""
-    forbidden_props = ["label", "cmap", "norm"]
+    forbidden_props = ["label", "cmap", "norm", "cascade"]
     for prop in forbidden_props:
         if prop in kwargs:
             kwargs.pop(prop)

{iplotx-0.2.1.dist-info → iplotx-0.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iplotx
-Version: 0.2.1
+Version: 0.3.0
 Summary: Plot networkx from igraph and networkx.
 Project-URL: Homepage, https://github.com/fabilab/iplotx
 Project-URL: Documentation, https://readthedocs.org/iplotx
@@ -79,6 +79,7 @@ See [gallery](https://iplotx.readthedocs.io/en/latest/gallery/index.html).
 - 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.🏗️
 

iplotx-0.3.0.dist-info/RECORD

@@ -0,0 +1,32 @@
+iplotx/__init__.py,sha256=DIOWUaEo9vgmz8B6hBlurV95BEYmjmUe5BU-jRWrtG4,418
+iplotx/cascades.py,sha256=_J8kxCHJrZmPKaN10e0uROAPsdcLrw41hzozZu1hQcg,8405
+iplotx/groups.py,sha256=H3zIaqlILQaC6Iqgxrf3zSuRVgynQTLLEuuGy6lYgLI,6388
+iplotx/label.py,sha256=m2ryXMh29QFLwdstRphnOPocW_Wnqir9WQscxWN1Z2E,7347
+iplotx/layout.py,sha256=0Mqrs0odQ8Jk4nITvAYgayR6KDm3e-Lq1BY_DKeU3ok,4664
+iplotx/network.py,sha256=rLVfC52PBiTR0I-CCvFPE0dj7t-KCLZwXSSJrpPVzh8,9719
+iplotx/plotting.py,sha256=VU1LYp9peqLa1CmvHjF98BYxezkWUrcCWvd2MPB9n_8,7381
+iplotx/style.py,sha256=NtrKYhTIkf7GPpepsROUbXxbodIc8gu066CdLNAsMQM,12009
+iplotx/tree.py,sha256=YU3UoGV_Zxf_KkP4iIsi09WsL1vBvS3URkG-Uqzqyp4,18393
+iplotx/typing.py,sha256=17TS-EJshNNOdeUC9mmJALiJ3gwI1nRq6AGlVdQRp1E,1384
+iplotx/version.py,sha256=YK2iFN0pBkof4-yJ6Yzz65Uy4liSHJ30ixvRZVehhho,66
+iplotx/vertex.py,sha256=JCXv-l934jDGdS2fOigOdDKDZ-5Az-7MUqHcQk8Jl18,12715
+iplotx/edge/__init__.py,sha256=W68WienFUneWQ0iVTFGNm8KIBQGvkfXlYq2Kx1lDzU8,23076
+iplotx/edge/arrow.py,sha256=2mF_HwhHkXir3lOYOTp8HW__PQgWRxaHXZN9mvk3hLQ,11452
+iplotx/edge/geometry.py,sha256=7RwtIUOjz6pd1QTUaNwtIivnaM4ZfxVgMjTg1bIqqQA,12827
+iplotx/edge/ports.py,sha256=pno3A7QdQyZGyQJOHVLYszBBeQAh-q2-jkd-lOe31TM,1183
+iplotx/ingest/__init__.py,sha256=dEbdb3LP3QnPKpwA7y6fJl9spCWkCYYtXCQPCGA9oVk,4971
+iplotx/ingest/heuristics.py,sha256=_ZSC9EiCr-eURmhGdufdZdyERpzPrPvRj01nv0rXkiE,6579
+iplotx/ingest/typing.py,sha256=cPEvOT5yjDiXj6Y9E3ShH2uDmepn7YtPtBIZ_cOEp6g,10345
+iplotx/ingest/providers/network/igraph.py,sha256=lCWIlKd2VwxJLoc2W4nivwkrvFjhmXhG9r_sJkFXWh0,2794
+iplotx/ingest/providers/network/networkx.py,sha256=-lb_8jpq7DvoM9lWn43qL6jTqS-VqtpJEgcSJeFz7yQ,4261
+iplotx/ingest/providers/tree/biopython.py,sha256=JFuD7NWV7j-fWt-6q29ApvlKf7Mqrnr_6wSkzSK-e38,1080
+iplotx/ingest/providers/tree/cogent3.py,sha256=LHAFLronzlrlLWl79abXWOoFP-agIdzoQqj6O15xwLE,873
+iplotx/ingest/providers/tree/ete4.py,sha256=vHwfYRazruR7eZfUgEJiSyeUA7UVBsTtR998uoL5bDQ,971
+iplotx/ingest/providers/tree/skbio.py,sha256=fwlITpl71gIKDDoJKB6nmlC-J6A2fXoplX6ul5qXsYc,869
+iplotx/utils/geometry.py,sha256=K5ZBYPmz4-KNm64pDh2p0L6PF5-u57SCVaEd2eWeRv0,8956
+iplotx/utils/internal.py,sha256=WWfcZDGK8Ut1y_tOHRGg9wSqY1bwSeLQO7dHM_8Tvwo,107
+iplotx/utils/matplotlib.py,sha256=T37SMwKNSA-dRKgNkVw5H4fGr5NACtxvBPebDJGdhjk,4516
+iplotx/utils/style.py,sha256=fEi14nc37HQqHxZTPeQaTnFFwbSneY1oDCyv2UbWfKk,22
+iplotx-0.3.0.dist-info/METADATA,sha256=7wB_lF97KjI_w1UAySphid4gt1bRCr5gGZ0YoPMqBW0,3809
+iplotx-0.3.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+iplotx-0.3.0.dist-info/RECORD,,

iplotx-0.2.1.dist-info/RECORD

@@ -1,31 +0,0 @@
-iplotx/__init__.py,sha256=DIOWUaEo9vgmz8B6hBlurV95BEYmjmUe5BU-jRWrtG4,418
-iplotx/groups.py,sha256=H3zIaqlILQaC6Iqgxrf3zSuRVgynQTLLEuuGy6lYgLI,6388
-iplotx/label.py,sha256=j-OjOX1R7VHh3Ihg4bhHaauxS4fuVHhGcHKoETAnUt4,5308
-iplotx/layout.py,sha256=RLCDgG9eO3mtZH-H3ETJFpvPR0uVl-xMUsgC4mcepWE,3930
-iplotx/network.py,sha256=rLVfC52PBiTR0I-CCvFPE0dj7t-KCLZwXSSJrpPVzh8,9719
-iplotx/plotting.py,sha256=1C6wenDeUohoYVl_vAcTs2aR-5LcRHFOcNb4ghIbkLI,7152
-iplotx/style.py,sha256=CmtycJKndmh_w28s4SpBJECyaAn8pQkfP244dMsAvv0,11399
-iplotx/tree.py,sha256=pu3dyIPsdX4iPJOSk_J5-IPajkCBkmUhEhp0jXzurtw,10695
-iplotx/typing.py,sha256=17TS-EJshNNOdeUC9mmJALiJ3gwI1nRq6AGlVdQRp1E,1384
-iplotx/version.py,sha256=RKuLXcXQo3HLVM55AR--Vu2Gmk8BKgdvxPEqTMqIa1E,66
-iplotx/vertex.py,sha256=q5B2_JUsGGszUh6OJ_ddr6uBvNmrxigolI0d5C-MThc,11667
-iplotx/edge/__init__.py,sha256=uM7YTr7YDbLIhAjUjfF7xT52LuE2CMj-erPeq68roxI,22227
-iplotx/edge/arrow.py,sha256=2mF_HwhHkXir3lOYOTp8HW__PQgWRxaHXZN9mvk3hLQ,11452
-iplotx/edge/geometry.py,sha256=db-k6HFYb_h6rWWxaD32tKefvRUIb7DLi1Y2x5vhgMA,10849
-iplotx/edge/ports.py,sha256=pno3A7QdQyZGyQJOHVLYszBBeQAh-q2-jkd-lOe31TM,1183
-iplotx/ingest/__init__.py,sha256=75Pml7X65tP8b2G3qaeZUdnDgwP6dclcCEEFl0BYSdo,4707
-iplotx/ingest/heuristics.py,sha256=32AZ8iidM_uooaBKe2EMjNU_nJDbhA_28ADc0dpQy5A,6636
-iplotx/ingest/typing.py,sha256=QEgCpLyfp-0v9czn6OaJ0_nuCo1AXv3lGS3aD6w-Ezw,3134
-iplotx/ingest/providers/network/igraph.py,sha256=_J7lH-jrT0_1oSfwgT_mQMRhxNoFwHo8dyBLCbgqETQ,2766
-iplotx/ingest/providers/network/networkx.py,sha256=u7NegapWZ0gWUj5n1PUVD-zZ92lKUiv6BLNTNIrXlRk,4233
-iplotx/ingest/providers/tree/biopython.py,sha256=7ZVD_WwIaBOSl-at4r_Y4d2qHQq6BcvlV-yDxMVCWnw,3456
-iplotx/ingest/providers/tree/cogent3.py,sha256=5O92zkdA43LWQ7h6r-uG_5X76EPHo-Yx9ODLb0hd_qc,3636
-iplotx/ingest/providers/tree/ete4.py,sha256=sGm2363yLJWsWsrRn2iFx8qRiq57h_5dQWBD41xJmhY,3660
-iplotx/ingest/providers/tree/skbio.py,sha256=iNZhY_TNLpzd55cK2nybjiftUfakeOrDDJ9dMBna_io,3629
-iplotx/utils/geometry.py,sha256=K5ZBYPmz4-KNm64pDh2p0L6PF5-u57SCVaEd2eWeRv0,8956
-iplotx/utils/internal.py,sha256=WWfcZDGK8Ut1y_tOHRGg9wSqY1bwSeLQO7dHM_8Tvwo,107
-iplotx/utils/matplotlib.py,sha256=T37SMwKNSA-dRKgNkVw5H4fGr5NACtxvBPebDJGdhjk,4516
-iplotx/utils/style.py,sha256=fEi14nc37HQqHxZTPeQaTnFFwbSneY1oDCyv2UbWfKk,22
-iplotx-0.2.1.dist-info/METADATA,sha256=_xHHXy4GbmnU5phRruUTbr1XlBtCJnOOyq5PLgv-m1k,3695
-iplotx-0.2.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-iplotx-0.2.1.dist-info/RECORD,,