iplotx 1.3.0__py3-none-any.whl → 1.4.1__py3-none-any.whl

iplotx/edge/__init__.py

@@ -370,6 +370,9 @@ class EdgeCollection(mpl.collections.PatchCollection):
             if edge_stylei.get("curved", False):
                 tension = edge_stylei.get("tension", 5)
                 ports = edge_stylei.get("ports", (None, None))
+            elif edge_stylei.get("arc", False):
+                tension = edge_stylei.get("tension", 1)
+                ports = None
             else:
                 tension = 0
                 ports = None
@@ -391,6 +394,8 @@ class EdgeCollection(mpl.collections.PatchCollection):
             if waypoints != "none":
                 ports = edge_stylei.get("ports", (None, None))
 
+            arc = edge_stylei.get("arc", False)
+
             # Compute actual edge path
             path, angles = _compute_edge_path(
                 vcoord_data,
@@ -401,6 +406,7 @@ class EdgeCollection(mpl.collections.PatchCollection):
                 tension=tension,
                 waypoints=waypoints,
                 ports=ports,
+                arc=arc,
                 layout_coordinate_system=self._vertex_collection.get_layout_coordinate_system(),
                 shrink=shrink,
             )
@@ -447,7 +453,7 @@ class EdgeCollection(mpl.collections.PatchCollection):
         # If none found, empty the dictionary already
         if (len(parallel_edges) == 0) or (max(parallel_edges.values(), key=len) == 1):
             parallel_edges = {}
-        if not self._style.get("curved", False):
+        if (not self._style.get("curved", False)) and (not self._style.get("arc", False)):
             while len(parallel_edges) > 0:
                 (v1, v2), indices = parallel_edges.popitem()
                 indices_inv = parallel_edges.pop((v2, v1), [])
@@ -712,6 +718,7 @@ def make_stub_patch(**kwargs):
         "split",
         "shrink",
         "depthshade",
+        "arc",
         # DEPRECATED
         "padding",
     ]

iplotx/edge/geometry.py

@@ -393,6 +393,108 @@ def _compute_edge_path_waypoints(
     return path, angles
 
 
+def _compute_edge_path_arc(
+    tension,
+    vcoord_data,
+    vpath_fig,
+    vsize_fig,
+    trans,
+    trans_inv,
+    ports: Pair[Optional[str]] = (None, None),
+    shrink: float = 0,
+):
+    """Shorten the edge path along an arc.
+
+    Parameters:
+        tension: the tension of the arc. This is defined, for this function, as the tangent
+            of the angle spanning the arc. For instance, for a semicircle, the angle is
+            180 degrees, so the tension is +-1 (depending on the orientation).
+    """
+
+    # Coordinates in figure (default) coords
+    vcoord_fig = trans(vcoord_data)
+
+    dv = vcoord_fig[1] - vcoord_fig[0]
+
+    # Tension is the fraction of the semicircle covered by the
+    # arc. Values are clipped between -1 (left-hand semicircle)
+    # and 1 (right-hand semicircle). 0 means a straight line,
+    # which is a (degenerate) arc too.
+    if tension == 0:
+        vs = [None, None]
+        thetas = [atan2(dv[1], dv[0])]
+        thetas.append(-thetas[0])
+        for i in range(2):
+            vs[i] = (
+                _get_shorter_edge_coords(vpath_fig[i], vsize_fig[i], thetas[i], shrink)
+                + vcoord_fig[i]
+            )
+        auxs = []
+
+    else:
+        edge_straight_length = np.sqrt((dv**2).sum())
+        theta_straight = atan2(dv[1], dv[0])
+        theta_tension = 4 * np.arctan(tension)
+        # print(f"theta_straight: {np.degrees(theta_straight):.2f}")
+        # print(f"theta_tension: {np.degrees(theta_tension):.2f}")
+        # NOTE: positive tension means an arc shooting off to the right of the straight
+        # line, same convensio as for tension elsewhere in the codebase.
+        thetas = [theta_straight - theta_tension / 2, np.pi + theta_straight + theta_tension / 2]
+        # This is guaranteed to be finite because tension == 0 is taken care of above,
+        # and tension = np.inf is not allowed.
+        mid = vcoord_fig.mean(axis=0)
+        # print(f"theta_s: {thetas}")
+        # print(f"mid: {mid}")
+        theta_offset = theta_straight + np.pi / 2
+        if np.abs(tension) <= 1:
+            offset_length = edge_straight_length / 2 / np.tan(theta_tension / 2)
+        else:
+            # print("Large tension arc")
+            offset_length = -edge_straight_length / 2 * np.tan(theta_tension / 2 - np.pi / 2)
+        # print(f"theta_offset: {np.degrees(theta_offset):.2f}")
+        offset = offset_length * np.array([np.cos(theta_offset), np.sin(theta_offset)])
+        # print(f"offset: {offset}")
+        center = mid + offset
+        # print(f"center: {center}")
+
+        # Compute shorter start and end points
+        vs = [None, None]
+        for i in range(2):
+            vs[i] = (
+                _get_shorter_edge_coords(vpath_fig[i], vsize_fig[i], thetas[i], shrink)
+                + vcoord_fig[i]
+            )
+        angle_start = atan2(*(vs[0] - center)[::-1])
+        angle_end = atan2(*(vs[1] - center)[::-1])
+        if (np.abs(tension) > 1) and (np.abs(angle_end - angle_start) < np.pi):
+            if angle_end > angle_start:
+                angle_start += 2 * np.pi
+            else:
+                angle_end += 2 * np.pi
+        # print(f"angle_start: {np.degrees(angle_start):.2f}")
+        # print(f"angle_end: {np.degrees(angle_end):.2f}")
+
+        naux = 30
+        angles = np.linspace(angle_start, angle_end, naux + 2)[1:-1]
+        auxs = center + np.array([np.cos(angles), np.sin(angles)]).T * np.linalg.norm(
+            vs[0] - center
+        )
+
+    path = {
+        "vertices": [vs[0]] + list(auxs) + [vs[1]],
+        "codes": ["MOVETO"] + ["LINETO"] * (len(auxs) + 1),
+    }
+
+    path = mpl.path.Path(
+        path["vertices"],
+        codes=[getattr(mpl.path.Path, x) for x in path["codes"]],
+    )
+
+    # Return to data transform
+    path.vertices = trans_inv(path.vertices)
+    return path, tuple(thetas)
+
+
 def _compute_edge_path_curved(
     tension,
     vcoord_data,
@@ -483,12 +585,15 @@ def _compute_edge_path(
     tension: float = 0,
     waypoints: str | tuple[float, float] | Sequence[tuple[float, float]] | np.ndarray = "none",
     ports: Pair[Optional[str]] = (None, None),
+    arc: bool = False,
     layout_coordinate_system: str = "cartesian",
     **kwargs,
 ):
     """Compute the edge path in a few different ways."""
     if (waypoints != "none") and (tension != 0):
         raise ValueError("Waypoints not supported for curved edges.")
+    if (waypoints != "none") and arc:
+        raise ValueError("Waypoint not supported for arc edges.")
 
     if waypoints != "none":
         return _compute_edge_path_waypoints(
@@ -506,6 +611,14 @@ def _compute_edge_path(
             **kwargs,
         )
 
+    if arc:
+        return _compute_edge_path_arc(
+            tension,
+            *args,
+            ports=ports,
+            **kwargs,
+        )
+
     return _compute_edge_path_curved(
         tension,
         *args,

iplotx/layout/tree/unrooted.py

@@ -74,13 +74,15 @@ def _equalangle_tree_layout(
         for child in children:
             nleaves_child = props["nleaves"][child]
             alpha = nleaves_child / nleaves * total_angle
+            if orientation in ("left", "counterclockwise"):
+                alpha = -alpha
             beta = start + alpha / 2
 
             props["layout"][child] = [
                 cur_x + branch_length_fun(child) * np.cos(np.radians(beta)),
                 cur_y + branch_length_fun(child) * np.sin(np.radians(beta)),
             ]
-            props["angle"][child] = -90 - beta * np.sign(beta - 180)
+            # props["angle"][child] = -90 - beta * np.sign(beta - 180)
             props["start"][child] = start
             props["end"][child] = start + alpha
             start += alpha
@@ -101,7 +103,8 @@ def _daylight_tree_layout(
     start: float = 180,
     span: float = 360,
     max_iter: int = 5,
-    dampening: float = 0.3,
+    dampening: float = 0.33,
+    max_correction: float = 10.0,
     **kwargs,
 ) -> dict[Hashable, list[float]]:
     """Daylight unrooted tree layout.
@@ -154,16 +157,34 @@ def _daylight_tree_layout(
         ninternal = 0
         parents = [None] + list(levelorder_fun())
         for parent in parents:
-            children = children_fun(parent) if parent is not None else [root]
+            if parent is None:
+                # If the root has only two children, it's a passthrough node, skip it
+                if len(children_fun(root)) < 3:
+                    continue
+                # Else, include it
+                children = [root]
+            else:
+                children = children_fun(parent)
+
             for node in children:
+                grandchildren = children_fun(node)
+                # Exclude leaves, since they have no children subtrees
+                # that can be adjusted. Exclude also passthrough nodes with
+                # a single child, because they are rotating rigidly when their
+                # parent does so or tells them to do so.
+                if len(grandchildren) < 2:
+                    continue
+
                 res = _apply_daylight_single_node(
                     node,
                     parent,
+                    grandchildren,
                     all_leaves,
                     layout,
                     leaves_fun,
                     children_fun,
                     dampening,
+                    max_correction,
                 )
                 change_sum += res
                 ninternal += 1
@@ -182,11 +203,13 @@ def _daylight_tree_layout(
 def _apply_daylight_single_node(
     node: Any,
     parent: Any,
+    children: list[Any],
     all_leaves: list[Any],
     layout: dict[Hashable, np.ndarray],
     leaves_fun: Callable,
     children_fun: Callable,
     dampening: float,
+    max_correction: float,
 ) -> float:
     """Apply daylight adjustment to a single internal node.
 
@@ -208,9 +231,9 @@ def _apply_daylight_single_node(
 
     print = _print if DEBUG_DAYLIGHT else lambda *a, **k: None
 
-    children = children_fun(node)
-
-    # 1. Find boundary leaves for each child and for the parent
+    # 1. Find daylight boundary leaves for each subtree. There are always at least two subtrees,
+    # the first child and the parent (this function is not called for leaves, and the root hopefully
+    # has at least two children).
     p0 = layout[node]
     bounds = {}
 
@@ -224,99 +247,137 @@ def _apply_daylight_single_node(
 
     # Check the parent first if there is one
     if parent is not None:
+        leaves_parent_subtree = [leaf for leaf in all_leaves if leaf not in leaves_below]
         vec1 = layout[parent] - p0
         print("parent side leaves:")
         print(parent)
-        print(f"  node to parent vector: {vec1[0]:.2f}, {vec1[1]:.2f}")
+        print(
+            f"  node to parent vector: {vec1[0]:.2f}, {vec1[1]:.2f}, angle: {np.degrees(np.arctan2(vec1[1], vec1[0])):.2f}"
+        )
         lower_angle, upper_angle = 2 * np.pi, -2 * np.pi
-        for leaf in all_leaves:
-            # Skip subtree leaves
-            if leaf in leaves_below:
-                continue
+        for leaf in leaves_parent_subtree:
             vec2 = layout[leaf] - p0
             angle = _anticlockwise_angle(vec1, vec2)
             print("  parent side leaf:")
             print(leaf)
-            print(f"  node to leaf vector: {vec2[0]:.2f}, {vec2[1]:.2f}")
-            print(f"  angle: {angle:.2f}")
+            print(
+                f"  node to leaf vector: {vec2[0]:.2f}, {vec2[1]:.2f}, angle: {np.degrees(np.arctan2(vec2[1], vec2[0])):.2f}"
+            )
+            print(f"  angle: {np.degrees(angle):.2f}")
             if angle < lower_angle:
+                print("lowering lower angle")
                 lower_angle = angle
                 lower = leaf
+            else:
+                print("not lowering lower angle")
             if angle > upper_angle:
+                print("raising upper angle")
                 upper_angle = angle
                 upper = leaf
+            else:
+                print("not raising upper angle")
         bounds[parent] = (lower, upper, lower_angle, upper_angle)
 
     # Repeat the exact same thing for each child rather than the parent
     print("subtree leaves:")
     for child in children:
         vec1 = layout[child] - p0
-        print(f"  node to child vector: {vec1[0]:.2f}, {vec1[1]:.2f}")
+        print(
+            f"  node to child vector: {vec1[0]:.2f}, {vec1[1]:.2f}, angle: {np.degrees(np.arctan2(vec1[1], vec1[0])):.2f}"
+        )
         lower_angle, upper_angle = 2 * np.pi, -2 * np.pi
 
         for leaf in leaves_fun(child):
             vec2 = layout[leaf] - p0
             angle = _anticlockwise_angle(vec1, vec2)
-            print(f"  node to leaf vector: {vec2[0]:.2f}, {vec2[1]:.2f}")
+            print(
+                f"  node to leaf vector: {vec2[0]:.2f}, {vec2[1]:.2f}, angle: {np.degrees(np.arctan2(vec2[1], vec2[0])):.2f}"
+            )
             print(leaf)
-            print(f"  angle: {angle:.2f}")
+            print(f"  angle: {np.degrees(angle):.2f}")
             if angle < lower_angle:
+                print("lowering lower angle")
                 lower_angle = angle
                 lower = leaf
+            else:
+                print("not lowering lower angle")
             if angle > upper_angle:
+                print("raising upper angle")
                 upper_angle = angle
                 upper = leaf
+            else:
+                print("not raising upper angle")
         bounds[child] = (lower, upper, lower_angle, upper_angle)
 
-    print("final boundary leaves:")
-    print(bounds)
+    for subtree, bound in bounds.items():
+        vec1 = layout[bound[0]] - p0
+        vec2 = layout[bound[1]] - p0
+        angle = _anticlockwise_angle(vec1, vec2)
+        print("subtree angles:")
+        print(f"  lower {np.degrees(np.arctan2(vec1[1], vec1[0])):.2f}")
+        print(f"  upper {np.degrees(np.arctan2(vec2[1], vec2[0])):.2f}")
+        print(f"  angle {np.degrees(angle):.2f}")
 
     # 2. Compute daylight angles
     # NOTE: Since Python 3.6, python keys are ordered by insertion order.
     daylight = {}
-    daylight_sum = 0.0
-    # TODO: Mayvbe optimise this by avoiding creating all these lists
-    prev_leaves = [bound[1] for bound in bounds.values()]
-    leaves = [bound[0] for bound in bounds.values()]
-    leaves = leaves[1:] + [leaves[0]]  # cycle left
-    subtrees = children + ([parent] if parent is not None else [])
-    for subtree, prev_leaf, leaf in zip(subtrees, prev_leaves, leaves):
-        vec1 = layout[prev_leaf] - p0
-        vec2 = layout[leaf] - p0
+    subtrees = list(bounds.keys())
+    subtrees += [subtrees[0]]  # Repeat first subtree
+
+    for i in range(len(subtrees) - 1):
+        subtree = subtrees[i + 1]
+        old_subtree = subtrees[i]
+        lower = bounds[subtree][0]
+        old_upper = bounds[old_subtree][1]
+        vec1 = layout[old_upper] - p0
+        vec2 = layout[lower] - p0
         angle = _anticlockwise_angle(vec1, vec2)
-
-        daylight_sum += angle
-        if leaf != parent:
-            # daylight[leaf] = float(angle)
-            daylight[subtree] = float(angle)
-
-    print("daylight")
-    print(daylight)
-    print(f"daylight sum: {daylight_sum:.2f}")
-
-    # 3. Compute *excess* daylight, and correct it
-    # NOTE: There seems to be this notion that you rotate a node by the accumulated daylight
-    # correction (to fill the space on the left) plus its own correction (to fill the space on the right).
-    # It reads funny and this is within a BFS iteration anyway so it's probably ok, but it's
-    # curious.
-    # NOTE: The average adjustment is divided by children + 1 (the parent) bc this is unrooted.
-    daylight_avg = daylight_sum / (len(children) + 1)
-    daylight_cum_corr = 0.0
-    daylight_changes = 0
-    for leaf in daylight:
-        daylight_cum_corr += daylight_avg - daylight[leaf]
-        _rotate_subtree_around_point(
+        daylight[subtree] = float(angle)
+        print("daylight angle:")
+        print(f"  previous upper {np.degrees(np.arctan2(vec1[1], vec1[0])):.2f}")
+        print(f"  new lower      {np.degrees(np.arctan2(vec2[1], vec2[0])):.2f}")
+        print(f"  angle: {np.degrees(angle):.2f}")
+
+    daylight_avg = sum(daylight.values()) / len(daylight)
+    print(f"daylight average angle: {np.degrees(daylight_avg):.2f}")
+
+    # 3. Compute *excess* daylight and corrections
+    daylight_correction = {}
+    corr_cum = 0.0
+    print("daylight correction:")
+    for subtree, angle in daylight.items():
+        # Correction is negative of the residue
+        corr_cum -= angle - daylight_avg
+        daylight_correction[subtree] = corr_cum
+        print(f"  daylight angle: {np.degrees(angle):.2f}, correction: {np.degrees(corr_cum):.2f}")
+
+    # NOTE: the last daylight correction must be 0, otherwise we are just rotating the entire tree.
+    # In most cases, this will be the parent which cannot rotate anyway (for the same reason).
+    # However, when applied to the root node with 3+ children, the nonrotating one will be the first
+    # child, which is arbitrary but correct: even in this case, we do not want a merry-go-round.
+
+    # 4. Correct (the last one is dumb)
+    daylight_corrections_abs = 0.0
+    for subtree, correction in daylight_correction.items():
+        correction *= dampening
+        correction = np.clip(correction, np.radians(-max_correction), np.radians(max_correction))
+        print(f"Applying correction to subtree {subtree}: {np.degrees(correction):.2f}")
+        _rotate_subtree_anticlockwise(
             leaf,
             children_fun,
             layout,
             p0,
-            dampening * daylight_cum_corr,
+            correction,
             recur=True,
         )
-        daylight_changes += abs(dampening * daylight_cum_corr)
+        daylight_corrections_abs += abs(correction)
+
+    # __import__("ipdb").set_trace()
 
     # Caller wants degrees
-    return np.degrees(daylight_changes / len(leaves))
+    # NOTE: The denominator is -1 because the last correction is always zero anyway, so the
+    # actually possible corrections are #subtrees - 1.
+    return np.degrees(daylight_corrections_abs / (len(daylight_correction) - 1))
 
 
 # see: https://stackoverflow.com/questions/14066933/direct-way-of-computing-the-clockwise-angle-between-two-vectors
@@ -334,7 +395,7 @@ def _anticlockwise_angle(v1, v2):
     return np.arctan2(determinant, dot)
 
 
-def _rotate_subtree_around_point(
+def _rotate_subtree_anticlockwise(
     node,
     children_fun: Callable,
     layout: dict[Hashable, list[float]],
@@ -344,7 +405,7 @@ def _rotate_subtree_around_point(
 ):
     point = np.asarray(layout[node])
     pivot = np.asarray(pivot)
-    layout[node] = _rotate_around_point(
+    layout[node] = _rotate_anticlockwise(
         point,
         pivot,
         angle,
@@ -352,7 +413,7 @@ def _rotate_subtree_around_point(
     if not recur:
         return
     for child in children_fun(node):
-        _rotate_subtree_around_point(
+        _rotate_subtree_anticlockwise(
             child,
             children_fun,
             layout,
@@ -361,7 +422,7 @@ def _rotate_subtree_around_point(
         )
 
 
-def _rotate_around_point(
+def _rotate_anticlockwise(
     point,
     pivot,
     angle,
@@ -379,5 +440,5 @@ def _rotate_around_point(
     pivot = np.asarray(pivot)
     cos = np.cos(angle)
     sin = np.sin(angle)
-    rot = np.array([[cos, sin], [-sin, cos]])
+    rot = np.array([[cos, -sin], [sin, cos]])
     return pivot + (point - pivot) @ rot

iplotx/style/leaf_info.py

@@ -41,6 +41,7 @@ nonrotating_leaves = (
     "deep",
     "angular",
     "curved",
+    "arc",
     "capstyle",
     "depthshade",
 )

iplotx/version.py

@@ -2,4 +2,4 @@
 iplotx version information module.
 """
 
-__version__ = "1.3.0"
+__version__ = "1.4.1"

{iplotx-1.3.0.dist-info → iplotx-1.4.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iplotx
-Version: 1.3.0
+Version: 1.4.1
 Summary: Plot networkx from igraph and networkx.
 Project-URL: Homepage, https://github.com/fabilab/iplotx
 Project-URL: Documentation, https://readthedocs.org/iplotx

{iplotx-1.3.0.dist-info → iplotx-1.4.1.dist-info}/RECORD

@@ -3,15 +3,15 @@ iplotx/artists.py,sha256=2dBDT240zGwKb6tIc_y9pXeyU3LuYeF9wjj2tvi4KJo,730
 iplotx/label.py,sha256=7eS8ByadrhdIFOZz19U4VrS-oXY_ndFYNB-D4RZbFqI,9573
 iplotx/plotting.py,sha256=RyAdvaHSpuyJkf8DF3SJBvEXBrPmJEdovUyAlBWQvqU,16228
 iplotx/typing.py,sha256=QLdzV358IiD1CFe88MVp0D77FSx5sSAVUmM_2WPPE8I,1463
-iplotx/version.py,sha256=k2KjblHRw7cpH2h7LRTJqlcSXCjDH-WN6aCDQlzMEH4,66
+iplotx/version.py,sha256=pDHOlKcY4NkjVyT63s4sF7EXMk_RlMLYxzkdejRQNr8,66
 iplotx/vertex.py,sha256=_yYyvusn4vYvi6RBEW6CHa3vnbv43GnZylnMIaK4bG0,16040
 iplotx/art3d/vertex.py,sha256=Xf8Um30X2doCd8KdNN7332F6BxC4k72Mb_GeRAuzQfQ,2545
 iplotx/art3d/edge/__init__.py,sha256=uw1U_mMXqcZAvea-7JbU1PUKULQD1CMMrbwY02tiWRQ,8529
 iplotx/art3d/edge/arrow.py,sha256=14BFXY9kDOUGPZl2fMD9gRVGyaaN5kyd-l6ikBg6WHU,3601
 iplotx/art3d/edge/geometry.py,sha256=76VUmpPG-4Mls7x_994dMwdDPrWWnjT7nHJsHfwK_hA,2467
-iplotx/edge/__init__.py,sha256=GlY_CmlMVD1DWJeOb5cFQEP_4K1pPneS_fRLqAxNGMk,26573
+iplotx/edge/__init__.py,sha256=8iHtkrEaxseh308VWlTgbZ7OJECqkRwSq-oJzejxH5U,26837
 iplotx/edge/arrow.py,sha256=ymup2YT_0GVYMtZw_DSKrZqFHG_ysYteEhmoL6T8Mu4,17563
-iplotx/edge/geometry.py,sha256=jkTMvQC5425GjB_fmGLIPJeSDAr_7NZF8zZDLTrSj34,15541
+iplotx/edge/geometry.py,sha256=dczXCLCn5vlFm_SwXXh_gwf0h7irILSCdNIDKTuuqmA,19646
 iplotx/edge/leaf.py,sha256=SyGMv2PIOoH0pey8-aMVaZheK3hNe1Qz_okcyWbc4E4,4268
 iplotx/edge/ports.py,sha256=BpkbiEhX4mPBBAhOv4jcKFG4Y8hxXz5GRtVLCC0jbtI,1235
 iplotx/ingest/__init__.py,sha256=k1Q-7lSdotMR4RkF1x0t19RFsTknohX0L507Dw69WyU,5035
@@ -30,11 +30,11 @@ iplotx/ingest/providers/tree/skbio.py,sha256=T3IbOBut98A2GoGJzo6Tzp108uFa9n485mV
 iplotx/layout/__init__.py,sha256=7on7I9CcbByz4X4hNJGsCc0GDFr3ul1K2UvTyvcGAWo,107
 iplotx/layout/tree/__init__.py,sha256=hxASc8uXMWbpxnEHnChMzb3VQTTIyU4ww7SQRez1hK0,2000
 iplotx/layout/tree/rooted.py,sha256=j3Y_Yd3YCWJRnhfE1qwEX5xCyUgvOJCX9Qfkc81B5BM,4215
-iplotx/layout/tree/unrooted.py,sha256=AH_8f4runflAs1bqXECeTDjtGDmFfO4afJf5JllS1lA,11716
+iplotx/layout/tree/unrooted.py,sha256=7iWLcQLwPsZgJpNlAnVKnEj-XI3twpYZhe4WztU9gEc,14668
 iplotx/network/__init__.py,sha256=cJ6m6s157AOCqg-znUAlsumuZ2jiE9QsVQ3-GCK01wo,13543
 iplotx/network/groups.py,sha256=E_eYVXRHjv1DcyA4RupTkMa-rRFrIKkt9Rxn_Elw9Nc,6796
 iplotx/style/__init__.py,sha256=rf1GutrE8hHUhCoe4FGKYX-aNtHuu_U-kYQnqUxZNrY,10282
-iplotx/style/leaf_info.py,sha256=3xBn7xv9Uy2KAqdhM9S6ew5ZBJrGRTXRL3xXb8atfLw,1018
+iplotx/style/leaf_info.py,sha256=oBiOH-fHt_D2Nic2eYeE5nG5nLIE_0gSDNbLAYe5g2w,1029
 iplotx/style/library.py,sha256=58Y8BlllGLsR4pQM7_PVCP5tH6_4GkchXZvJpqGHlcg,8534
 iplotx/tree/__init__.py,sha256=sxVrxZcsDIZddBdtI-TxOs37FyeYbHBLYqkLPWs6c8M,31199
 iplotx/tree/cascades.py,sha256=Wwqhy46QGeb4LNGUuz_-bgNWUMz6PFzs_dIxIb1dtqc,8394
@@ -43,6 +43,6 @@ iplotx/utils/geometry.py,sha256=6RrC6qaB0-1vIk1LhGA4CfsiMd-9JNniSPyL_l9mshE,9245
 iplotx/utils/internal.py,sha256=WWfcZDGK8Ut1y_tOHRGg9wSqY1bwSeLQO7dHM_8Tvwo,107
 iplotx/utils/matplotlib.py,sha256=p_53Oamof0RI4mtV8HrdDtZbgVqUxeUZ_KDvLZSiBUQ,8604
 iplotx/utils/style.py,sha256=vyNP80nDYVinqm6_9ltCJCtjK35ZcGlHvOskNv3eQBc,4225
-iplotx-1.3.0.dist-info/METADATA,sha256=laDlBsyQ5RwK1WeA4Hm_3uusbpJGxNifWJZu_0JHYYI,5407
-iplotx-1.3.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-iplotx-1.3.0.dist-info/RECORD,,
+iplotx-1.4.1.dist-info/METADATA,sha256=8ZAla76ojuZ1bfzsj3gTS-agA44OIz0Ze18Hc-p3Gcg,5407
+iplotx-1.4.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+iplotx-1.4.1.dist-info/RECORD,,