iplotx 0.5.0__py3-none-any.whl → 0.5.2.dev0__py3-none-any.whl

iplotx/edge/__init__.py

@@ -105,6 +105,10 @@ class EdgeCollection(mpl.collections.PatchCollection):
         # NOTE: This should also set the transform
         super().__init__(patches, transform=transform, *args, **kwargs)
 
+        # Apparenyly capstyle is lost upon collection creation
+        if "capstyle" in self._style:
+            self.set_capstyle(self._style["capstyle"])
+
         # This is important because it prepares the right flags for scalarmappable
         self.set_facecolor("none")
 
@@ -158,6 +162,10 @@ class EdgeCollection(mpl.collections.PatchCollection):
             **kwargs,
         )
 
+        # Apparently capstyle is lost upon collection creation
+        if "capstyle" in style:
+            self._subedges.set_capstyle(style["capstyle"])
+
     def get_children(self) -> tuple:
         children = []
         if hasattr(self, "_subedges"):
@@ -188,7 +196,7 @@ class EdgeCollection(mpl.collections.PatchCollection):
         return self._directed
 
     @directed.setter
-    def directed(self, value) -> None:
+    def directed(self, value: bool) -> None:
         """Setter for the directed property.
 
         Changing this property triggers the addition/removal of arrows from the plot.
@@ -230,7 +238,11 @@ class EdgeCollection(mpl.collections.PatchCollection):
         # NOTE: The superclass also sets stale = True
         super().update_scalarmappable()
         # Now self._edgecolors has the correct colorspace values
-        if hasattr(self, "_arrows"):
+        # NOTE: The following line should include a condition on
+        # whether the arrows are allowing color matching to the
+        # edges. For now, we assume that if the edges are colormapped
+        # we would want the arrows to be as well.
+        if hasattr(self, "_arrows") and (self._A is not None):
             self._arrows.set_colors(self.get_edgecolor())
 
     def get_labels(self) -> Optional[LabelCollection]:
@@ -337,6 +349,10 @@ class EdgeCollection(mpl.collections.PatchCollection):
                 tension = 0
                 ports = None
 
+            # Scale padding by dpi
+            dpi = self.figure.dpi if hasattr(self, "figure") else 72.0
+            padding = dpi / 72.0 * edge_stylei.pop("padding", 0)
+
             # False is a synonym for "none"
             waypoints = edge_stylei.get("waypoints", "none")
             if waypoints is False or waypoints is np.False_:
@@ -348,9 +364,6 @@ class EdgeCollection(mpl.collections.PatchCollection):
             if waypoints != "none":
                 ports = edge_stylei.get("ports", (None, None))
 
-            if not isinstance(waypoints, str):
-                __import__("ipdb").set_trace()
-
             # Compute actual edge path
             path, angles = _compute_edge_path(
                 vcoord_data,
@@ -362,6 +375,7 @@ class EdgeCollection(mpl.collections.PatchCollection):
                 waypoints=waypoints,
                 ports=ports,
                 layout_coordinate_system=self._vertex_collection.get_layout_coordinate_system(),
+                padding=padding,
             )
 
             offset = edge_stylei.get("offset", 0)
@@ -375,7 +389,6 @@ class EdgeCollection(mpl.collections.PatchCollection):
                     offset = offset * vrot
             offset = np.asarray(offset, dtype=float)
             # Scale by dpi
-            dpi = self.figure.dpi if hasattr(self, "figure") else 72.0
             offset *= dpi / 72.0
             if (offset != 0).any():
                 path.vertices[:] = trans_inv(trans(path.vertices) + offset)
@@ -702,6 +715,7 @@ def make_stub_patch(**kwargs):
         "cmap",
         "norm",
         "split",
+        "padding",
     ]
     for prop in forbidden_props:
         if prop in kwargs:

iplotx/edge/arrow.py

@@ -220,6 +220,16 @@ def make_arrow_patch(marker: str = "|>", width: float = 8, **kwargs):
             codes=[getattr(mpl.path.Path, x) for x in codes],
             closed=False,
         )
+    elif marker == "<":
+        kwargs["facecolor"] = "none"
+        if "color" in kwargs:
+            kwargs["edgecolor"] = kwargs.pop("color")
+        codes = ["MOVETO", "LINETO", "LINETO"]
+        path = mpl.path.Path(
+            np.array([[height, width * 0.5], [0, 0], [height, -width * 0.5]]),
+            codes=[getattr(mpl.path.Path, x) for x in codes],
+            closed=False,
+        )
     elif marker == ">>":
         if "color" in kwargs:
             kwargs["facecolor"] = kwargs["edgecolor"] = kwargs.pop("color")
@@ -272,13 +282,80 @@ def make_arrow_patch(marker: str = "|>", width: float = 8, **kwargs):
             codes=[getattr(mpl.path.Path, x) for x in codes],
             closed=False,
         )
+    elif marker == "(":
+        kwargs["facecolor"] = "none"
+        if "color" in kwargs:
+            kwargs["edgecolor"] = kwargs.pop("color")
+        codes = ["MOVETO", "CURVE3", "CURVE3"]
+        path = mpl.path.Path(
+            np.array(
+                [
+                    [height * 0.5, width * 0.5],
+                    [-height * 0.5, 0],
+                    [height * 0.5, -width * 0.5],
+                ]
+            ),
+            codes=[getattr(mpl.path.Path, x) for x in codes],
+            closed=False,
+        )
+    elif marker == "]":
+        kwargs["facecolor"] = "none"
+        if "color" in kwargs:
+            kwargs["edgecolor"] = kwargs.pop("color")
+        codes = ["MOVETO", "LINETO", "LINETO", "LINETO"]
+        path = mpl.path.Path(
+            np.array(
+                [
+                    [-height, width * 0.5],
+                    [0, width * 0.5],
+                    [0, -width * 0.5],
+                    [-height, -width * 0.5],
+                ]
+            ),
+            codes=[getattr(mpl.path.Path, x) for x in codes],
+            closed=False,
+        )
+    elif marker == "[":
+        kwargs["facecolor"] = "none"
+        if "color" in kwargs:
+            kwargs["edgecolor"] = kwargs.pop("color")
+        codes = ["MOVETO", "LINETO", "LINETO", "LINETO"]
+        path = mpl.path.Path(
+            np.array(
+                [
+                    [height, width * 0.5],
+                    [0, width * 0.5],
+                    [0, -width * 0.5],
+                    [height, -width * 0.5],
+                ]
+            ),
+            codes=[getattr(mpl.path.Path, x) for x in codes],
+            closed=False,
+        )
     elif marker == "|":
         kwargs["facecolor"] = "none"
         if "color" in kwargs:
             kwargs["edgecolor"] = kwargs.pop("color")
         codes = ["MOVETO", "LINETO"]
         path = mpl.path.Path(
-            np.array([[-height, width * 0.5], [-height, -width * 0.5]]),
+            np.array([[0, width * 0.5], [0, -width * 0.5]]),
+            codes=[getattr(mpl.path.Path, x) for x in codes],
+            closed=False,
+        )
+    elif marker in ("x", "X"):
+        kwargs["facecolor"] = "none"
+        if "color" in kwargs:
+            kwargs["edgecolor"] = kwargs.pop("color")
+        codes = ["MOVETO", "LINETO", "MOVETO", "LINETO"]
+        path = mpl.path.Path(
+            np.array(
+                [
+                    [height * 0.5, width * 0.5],
+                    [-height * 0.5, -width * 0.5],
+                    [-height * 0.5, width * 0.5],
+                    [height * 0.5, -width * 0.5],
+                ]
+            ),
             codes=[getattr(mpl.path.Path, x) for x in codes],
             closed=False,
         )
@@ -370,4 +447,5 @@ def make_arrow_patch(marker: str = "|>", width: float = 8, **kwargs):
         path,
         **kwargs,
     )
+
     return patch, size_max

iplotx/edge/geometry.py

@@ -2,7 +2,10 @@
 Support module with geometry- and path-related functions for edges.
 """
 
-from typing import Optional
+from typing import (
+    Optional,
+    Sequence,
+)
 from math import atan2, tan, pi
 import numpy as np
 import matplotlib as mpl
@@ -61,46 +64,51 @@ def _compute_loops_per_angle(nloops, angles):
     ]
 
 
-def _get_shorter_edge_coords(vpath, vsize, theta):
+def _get_shorter_edge_coords(vpath, vsize, theta, padding=0):
     # Bound theta from -pi to pi (why is that not guaranteed?)
     theta = (theta + pi) % (2 * pi) - pi
 
     # Size zero vertices need no shortening
     if vsize == 0:
-        return np.array([0, 0])
-
-    for i in range(len(vpath)):
-        v1 = vpath.vertices[i]
-        v2 = vpath.vertices[(i + 1) % len(vpath)]
-        theta1 = atan2(*((v1)[::-1]))
-        theta2 = atan2(*((v2)[::-1]))
-
-        # atan2 ranges ]-3.14, 3.14]
-        # so it can be that theta1 is -3 and theta2 is +3
-        # therefore we need two separate cases, one that cuts at pi and one at 0
-        cond1 = theta1 <= theta <= theta2
-        cond2 = (
-            (theta1 + 2 * pi) % (2 * pi)
-            <= (theta + 2 * pi) % (2 * pi)
-            <= (theta2 + 2 * pi) % (2 * pi)
-        )
-        if cond1 or cond2:
-            break
+        ve = np.array([0, 0])
     else:
-        raise ValueError("Angle for patch not found")
+        for i in range(len(vpath)):
+            v1 = vpath.vertices[i]
+            v2 = vpath.vertices[(i + 1) % len(vpath)]
+            theta1 = atan2(*((v1)[::-1]))
+            theta2 = atan2(*((v2)[::-1]))
+
+            # atan2 ranges ]-3.14, 3.14]
+            # so it can be that theta1 is -3 and theta2 is +3
+            # therefore we need two separate cases, one that cuts at pi and one at 0
+            cond1 = theta1 <= theta <= theta2
+            cond2 = (
+                (theta1 + 2 * pi) % (2 * pi)
+                <= (theta + 2 * pi) % (2 * pi)
+                <= (theta2 + 2 * pi) % (2 * pi)
+            )
+            if cond1 or cond2:
+                break
+        else:
+            raise ValueError("Angle for patch not found")
 
-    # The edge meets the patch of the vertex on the v1-v2 size,
-    # at angle theta from the center
-    mtheta = tan(theta)
-    if v2[0] == v1[0]:
-        xe = v1[0]
-    else:
-        m12 = (v2[1] - v1[1]) / (v2[0] - v1[0])
-        print(m12, mtheta)
-        xe = (v1[1] - m12 * v1[0]) / (mtheta - m12)
-    ye = mtheta * xe
-    ve = np.array([xe, ye])
-    return ve * vsize
+        # The edge meets the patch of the vertex on the v1-v2 size,
+        # at angle theta from the center
+        mtheta = tan(theta)
+        if v2[0] == v1[0]:
+            xe = v1[0]
+        else:
+            m12 = (v2[1] - v1[1]) / (v2[0] - v1[0])
+            xe = (v1[1] - m12 * v1[0]) / (mtheta - m12)
+        ye = mtheta * xe
+        ve = np.array([xe, ye])
+
+    ve = ve * vsize
+
+    # Padding (assuming dpi scaling is already applied to the padding)
+    ve += padding * np.array([np.cos(theta), np.sin(theta)])
+
+    return ve
 
 
 def _fix_parallel_edges_straight(
@@ -137,11 +145,12 @@ def _compute_loop_path(
     angle2,
     trans_inv,
     looptension,
+    padding=0,
 ):
     # Shorten at starting angle
-    start = _get_shorter_edge_coords(vpath, vsize, angle1) + vcoord_fig
+    start = _get_shorter_edge_coords(vpath, vsize, angle1, padding) + vcoord_fig
     # Shorten at end angle
-    end = _get_shorter_edge_coords(vpath, vsize, angle2) + vcoord_fig
+    end = _get_shorter_edge_coords(vpath, vsize, angle2, padding) + vcoord_fig
 
     aux1 = (start - vcoord_fig) * looptension + vcoord_fig
     aux2 = (end - vcoord_fig) * looptension + vcoord_fig
@@ -173,6 +182,7 @@ def _compute_edge_path_straight(
     trans,
     trans_inv,
     layout_coordinate_system: str = "cartesian",
+    padding: float = 0,
     **kwargs,
 ):
     if layout_coordinate_system not in ("cartesian", "polar"):
@@ -199,14 +209,13 @@ def _compute_edge_path_straight(
 
     # Angle of the straight line
     theta = atan2(*((vcoord_fig[1] - vcoord_fig[0])[::-1]))
-    print(vcoord_data_cart, vcoord_fig, theta)
 
     # Shorten at starting vertex
-    vs = _get_shorter_edge_coords(vpath_fig[0], vsize_fig[0], theta) + vcoord_fig[0]
+    vs = _get_shorter_edge_coords(vpath_fig[0], vsize_fig[0], theta, padding) + vcoord_fig[0]
     points.append(vs)
 
     # Shorten at end vertex
-    ve = _get_shorter_edge_coords(vpath_fig[1], vsize_fig[1], theta + pi) + vcoord_fig[1]
+    ve = _get_shorter_edge_coords(vpath_fig[1], vsize_fig[1], theta + pi, padding) + vcoord_fig[1]
     points.append(ve)
 
     codes = ["MOVETO", "LINETO"]
@@ -228,9 +237,41 @@ def _compute_edge_path_waypoints(
     layout_coordinate_system: str = "cartesian",
     points_per_curve: int = 30,
     ports: Pair[Optional[str]] = (None, None),
+    padding: float = 0,
     **kwargs,
 ):
-    if waypoints in ("x0y1", "y0x1"):
+    if not isinstance(waypoints, str):
+        # Only cartesian coordinates supported for numerical waypoints for now
+        assert layout_coordinate_system == "cartesian"
+
+        waypoints = trans(np.array(waypoints, ndmin=2))
+
+        # Coordinates in figure (default) coords
+        vcoord_fig = trans(vcoord_data)
+
+        # Angles of the straight lines
+        thetas = [None, None]
+        vshorts = [None, None]
+        for i in range(2):
+            # This picks always the first waypoint for i == 0,
+            # the last waypoint for i == 1. They might be the same.
+            waypoint = waypoints[-i]
+            if ports[i] is None:
+                thetas[i] = atan2(*((waypoint - vcoord_fig[i])[::-1]))
+            else:
+                thetas[i] = atan2(*(_get_port_unit_vector(ports[i], trans_inv)[::-1]))
+
+            # Shorten at vertex border
+            vshorts[i] = (
+                _get_shorter_edge_coords(vpath_fig[i], vsize_fig[i], thetas[i], padding)
+                + vcoord_fig[i]
+            )
+
+        points = [vshorts[0]] + list(waypoints) + [vshorts[1]]
+        codes = ["MOVETO"] + ["LINETO"] * len(waypoints) + ["LINETO"]
+        angles = tuple(thetas)
+
+    elif waypoints in ("x0y1", "y0x1"):
         assert layout_coordinate_system == "cartesian"
 
         # Coordinates in figure (default) coords
@@ -252,7 +293,8 @@ def _compute_edge_path_waypoints(
 
             # Shorten at vertex border
             vshorts[i] = (
-                _get_shorter_edge_coords(vpath_fig[i], vsize_fig[i], thetas[i]) + vcoord_fig[i]
+                _get_shorter_edge_coords(vpath_fig[i], vsize_fig[i], thetas[i], padding)
+                + vcoord_fig[i]
             )
 
         # Shorten waypoints to keep the angles right
@@ -300,7 +342,9 @@ def _compute_edge_path_waypoints(
                 theta = atan2(*(_get_port_unit_vector(ports[i], trans_inv)[::-1]))
 
             # Shorten at vertex border
-            vshort = _get_shorter_edge_coords(vpath_fig[i], vsize_fig[i], theta) + vcoord_fig[i]
+            vshort = (
+                _get_shorter_edge_coords(vpath_fig[i], vsize_fig[i], theta, padding) + vcoord_fig[i]
+            )
             thetas.append(theta)
             vshorts.append(vshort)
 
@@ -347,6 +391,7 @@ def _compute_edge_path_curved(
     trans,
     trans_inv,
     ports: Pair[Optional[str]] = (None, None),
+    padding: float = 0,
 ):
     """Shorten the edge path along a cubic Bezier between the vertex centres.
 
@@ -399,7 +444,9 @@ def _compute_edge_path_curved(
     thetas = [None, None]
     for i in range(2):
         thetas[i] = atan2(*((auxs[i] - vcoord_fig[i])[::-1]))
-        vs[i] = _get_shorter_edge_coords(vpath_fig[i], vsize_fig[i], thetas[i]) + vcoord_fig[i]
+        vs[i] = (
+            _get_shorter_edge_coords(vpath_fig[i], vsize_fig[i], thetas[i], padding) + vcoord_fig[i]
+        )
 
     path = {
         "vertices": [
@@ -424,7 +471,7 @@ def _compute_edge_path_curved(
 def _compute_edge_path(
     *args,
     tension: float = 0,
-    waypoints: str = "none",
+    waypoints: str | tuple[float, float] | Sequence[tuple[float, float]] | np.ndarray = "none",
     ports: Pair[Optional[str]] = (None, None),
     layout_coordinate_system: str = "cartesian",
     **kwargs,

iplotx/ingest/providers/network/simple.py

@@ -79,6 +79,10 @@ class SimpleNetworkDataProvider(NetworkDataProvider):
             edge_df = pd.DataFrame(columns=["_ipx_source", "_ipx_target"])
         del tmp
 
+        # Edge labels
+        if edge_labels is not None:
+            edge_df["label"] = edge_labels
+
         network_data = {
             "vertex_df": vertex_df,
             "edge_df": edge_df,

iplotx/ingest/providers/tree/simple.py

@@ -21,6 +21,7 @@ class SimpleTree:
 
     children: Sequence[Self] = []
     branch_length: float = 1
+    name: str = ""
 
     @classmethod
     def from_dict(cls, data: dict) -> Self:
@@ -35,6 +36,7 @@ class SimpleTree:
         """
         tree = cls()
         tree.branch_length = data.get("branch_length", 1)
+        tree.name = data.get("name", "")
         tree.children = [cls.from_dict(child) for child in data.get("children", [])]
         return tree
 

iplotx/ingest/typing.py

@@ -254,12 +254,12 @@ class TreeDataProvider(Protocol):
         self,
         layout: str | LayoutType,
         layout_style: Optional[dict[str, int | float | str]] = None,
-        directed: bool | str = False,
+        directed: bool = False,
         vertex_labels: Optional[Sequence[str] | dict[Hashable, str] | pd.Series | bool] = None,
         edge_labels: Optional[Sequence[str] | dict] = None,
         leaf_labels: Optional[Sequence[str] | dict[Hashable, str] | pd.Series | bool] = None,
     ) -> TreeData:
-        """Create tree data object for iplotx from ete4.core.tre.Tree classes.
+        """Create tree data object for iplotx from any tree provider.
 
         NOTE: This function needs NOT be implemented by individual providers.
         """
@@ -314,15 +314,17 @@ class TreeDataProvider(Protocol):
         edge_data = {"_ipx_source": [], "_ipx_target": []}
         for node in self.preorder():
             for child in self.get_children(node):
-                if directed == "parent":
-                    edge_data["_ipx_source"].append(child)
-                    edge_data["_ipx_target"].append(node)
-                else:
-                    edge_data["_ipx_source"].append(node)
-                    edge_data["_ipx_target"].append(child)
+                edge_data["_ipx_source"].append(node)
+                edge_data["_ipx_target"].append(child)
         edge_df = pd.DataFrame(edge_data)
         tree_data["edge_df"] = edge_df
 
+        # Add edge labels
+        # NOTE: Partial support only for now, only lists
+        if edge_labels is not None:
+            # Cycling sequence
+            edge_df["label"] = [edge_labels[i % len(edge_labels)] for i in range(len(edge_df))]
+
         # Add branch support
         if hasattr(self, "get_support"):
             support = self.get_support()

iplotx/label.py

@@ -77,6 +77,12 @@ class LabelCollection(mpl.artist.Artist):
             child.set_figure(fig)
         self._update_offsets(dpi=fig.dpi)
 
+    def get_texts(self):
+        """Get the texts of the labels."""
+        return [child.get_text() for child in self.get_children()]
+
+    get_text = get_texts
+
     def _get_margins_with_dpi(self, dpi: float = 72.0) -> np.ndarray:
         return self._margins * dpi / 72.0
 

iplotx/plotting.py

@@ -139,8 +139,7 @@ def tree(
     Parameters:
         tree: The tree to plot. Can be a BioPython.Phylo.Tree object.
         layout: The layout to use for plotting.
-        directed: If False, donot draw arrows. If True or "child", draw arrows from parent to child
-            node. If "parent", draw arrows the other way around.
+        directed: If False, do not draw arrows.
         show_support: If True, show the support values for the nodes (assumed to be from 0 to 100,
             rounded to nearest integer). If both this parameter and vertex_labels are set,
             show_support takes precedence and hides the vertex labels.

iplotx/style/__init__.py

@@ -60,7 +60,7 @@ def get_style(name: str = "", *args) -> dict[str, Any]:
                 style = style[namei]
             # NOTE: if asking for a nonexistent, non-leaf style
             # give the benefit of the doubt and set an empty dict
-            # which will not fail unless the uder tries to enter it
+            # which will not fail unless the user tries to enter it
             elif namei not in style_leaves:
                 style = {}
             elif len(args) > 0:

iplotx/style/leaf_info.py

@@ -22,6 +22,7 @@ rotating_leaves = (
     "vpadding",
     "hmargin",
     "vmargin",
+    "padding",
     "ports",
     "width",
     "height",
@@ -38,6 +39,7 @@ nonrotating_leaves = (
     "deep",
     "angular",
     "curved",
+    "capstyle",
 )
 
 # Union of all style leaves (rotating and nonrotating)

iplotx/style/library.py

@@ -58,6 +58,28 @@ style_library = {
             },
         }
     },
+    # Feedback, for regulatory networks
+    "feedback": {
+        "edge": {
+            "linewidth": 4,
+            "padding": 10,
+            "arrow": {
+                "marker": ")>",
+                "width": 20,
+                "height": 28,
+            },
+        },
+        "vertex": {
+            "size": 35,
+            "color": None,
+            "facecolor": "white",
+            "edgecolor": "black",
+            "linewidth": 4,
+            "label": {
+                "color": "black",
+            },
+        },
+    },
     # Tree style, with zero-size vertices
     "tree": {
         "vertex": {

iplotx/tree.py

@@ -63,7 +63,7 @@ class TreeArtist(mpl.artist.Artist):
         self,
         tree,
         layout: Optional[str] = "horizontal",
-        directed: bool | str = False,
+        directed: bool = False,
         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,
@@ -76,8 +76,7 @@ class TreeArtist(mpl.artist.Artist):
         Parameters:
             tree: The tree to plot.
             layout: The layout to use for the tree. Can be "horizontal", "vertical", or "radial".
-            directed: Whether the tree is directed. Can be a boolean or a string with the
-                following choices: "parent" or "child".
+            directed: Whether the tree is directed. Must be a boolean.
             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.
@@ -294,7 +293,7 @@ class TreeArtist(mpl.artist.Artist):
             layout=self.get_layout(),
             layout_coordinate_system=self._ipx_internal_data.get(
                 "layout_coordinate_system",
-                "catesian",
+                "cartesian",
             ),
             style=get_style(".vertex"),
             labels=self._get_label_series("vertex"),
@@ -586,10 +585,9 @@ class TreeArtist(mpl.artist.Artist):
                     waypointsi = "y0x1"
                 elif layout_name == "radial":
                     waypointsi = "r0a1"
-                else:
-                    raise ValueError(
-                        f"Layout not supported: {layout_name}. ",
-                    )
+                # NOTE: no need to catch the default case, it's caught
+                # when making the layout already. We should *never* be
+                # in an "else" case here.
             waypoints.append(waypointsi)
 
             # These are not the actual edges drawn, only stubs to establish
@@ -612,7 +610,6 @@ class TreeArtist(mpl.artist.Artist):
         else:
             edge_style["waypoints"] = waypoints
 
-        # NOTE: Trees are directed is their "directed" property is True, "child", or "parent"
         self._edges = EdgeCollection(
             edgepatches,
             vertex_ids=adjacent_vertex_ids,

iplotx/utils/matplotlib.py

@@ -90,6 +90,9 @@ def _get_label_width_height(text, hpadding=18, vpadding=12, dpi=72.0, **kwargs):
         very accurate. Yet, it is often good enough and easier to implement than a careful
         orchestration of Figure.draw_without_rendering.
     """
+    if len(text) == 0:
+        return (0, 0)
+
     if "fontsize" in kwargs:
         kwargs["size"] = kwargs.pop("fontsize")
     forbidden_props = [

iplotx/version.py

@@ -2,4 +2,4 @@
 iplotx version information module.
 """
 
-__version__ = "0.5.0"
+__version__ = "0.5.2-dev"

{iplotx-0.5.0.dist-info → iplotx-0.5.2.dev0.dist-info}/METADATA

@@ -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.0.dist-info → iplotx-0.5.2.dev0.dist-info}/RECORD

@@ -2,37 +2,37 @@ 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/label.py,sha256=6am3a0ejcW_bWEXSOODE1Ke3AyCU1lJ45RfnXNbHAQw,8923
 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/plotting.py,sha256=yACxkD6unKc5eDsAp7ZabRCAwLEXBowSMESX2oGNBDU,7291
+iplotx/tree.py,sha256=S_9tf8Mixv9P5dq616tjxuxdDYRmUXLNAcSXTxEgm_I,27310
 iplotx/typing.py,sha256=QLdzV358IiD1CFe88MVp0D77FSx5sSAVUmM_2WPPE8I,1463
-iplotx/version.py,sha256=jzr3_UVrKVs0fo73K5UioUFwKYv5i4rA--sHkaSaQkw,66
+iplotx/version.py,sha256=qs-N8bGi6RQubKakAGIJAWbOPniPVtj7B0gtM0s9tTc,70
 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=-WLdI-BVB12-Zcq1Jc4LqDFoViuOfljTax-YHI1N7cc,13359
+iplotx/edge/__init__.py,sha256=VkAsuxphQa-co79MZWzWErkRAkp97CwB20ozPEnpvrM,26888
+iplotx/edge/arrow.py,sha256=C4XoHGCYou1z2alz5Q2VhdaWYEzgebtEF70zVYY_frk,15533
+iplotx/edge/geometry.py,sha256=tiaF4PzvsNBoROrEgcCsw0YdxxZr3oBxF4ord_k4ThA,15069
 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/typing.py,sha256=hVEcAREjFFFbAWsxRkQuvpy1B4L7JEv_NRVVmrEbUVk,13984
 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/network/simple.py,sha256=e_aHhiHhN9DrMoNrt7tEMPURXGhQ1TYRPzsxDEptUlc,3766
 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/simple.py,sha256=aV9wGqBomJ5klM_aJQeuL_Q_J1pLCv6AFN98BPDiKUw,2593
 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/style/__init__.py,sha256=XMkQZ1U63wVNo98Zo5uJAn-uQgW2OTZABAizJqiuB3s,12253
+iplotx/style/leaf_info.py,sha256=JoX1cPjRM_k3f93jzUPQ3gPlVP4wY_n032nOVhrgelU,969
+iplotx/style/library.py,sha256=wO-eeY3EZfAl0v21aX9f5_MiZhHuL2kGsBYA3uJkIGs,8535
 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/matplotlib.py,sha256=TutVJ1dEWYgX_-CY6MvdhRvWYqxpByGb3TKrSByYPNM,5330
 iplotx/utils/style.py,sha256=wMWxJykxBD-JmcN8-rSKlWcV6pMfwKgR4EzSpk_NX8k,547
-iplotx-0.5.0.dist-info/METADATA,sha256=QPPJUkwVArD550-tLmUpq11Qaczb7M9xgma8bDHijVc,3958
-iplotx-0.5.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-iplotx-0.5.0.dist-info/RECORD,,
+iplotx-0.5.2.dev0.dist-info/METADATA,sha256=D_Wrepyok3RsInEki56AiTbAM63Zn4DyvfcFy8v4J0E,4894
+iplotx-0.5.2.dev0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+iplotx-0.5.2.dev0.dist-info/RECORD,,