iplotx 0.5.1__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,45 +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])
-        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(
@@ -136,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
@@ -172,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"):
@@ -200,11 +211,11 @@ def _compute_edge_path_straight(
     theta = atan2(*((vcoord_fig[1] - vcoord_fig[0])[::-1]))
 
     # 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"]
@@ -226,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
@@ -250,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
@@ -298,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)
 
@@ -345,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.
 
@@ -397,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": [
@@ -422,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.1"
+__version__ = "0.5.2-dev"

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iplotx
-Version: 0.5.1
+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

{iplotx-0.5.1.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=dsB8xhRODrwa4OXOSbePgoZzy41j_DudRu80QRgFkpw,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=g9_z7nwlQhQm9Tvj2tme9dGboxkN-4jeUUg02gU-vOk,13285
+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.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,,
+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,,