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

iplotx/ingest/providers/tree/biopython.py

@@ -21,8 +21,9 @@ class BiopythonDataProvider(TreeDataProvider):
 
     preorder = partialmethod(_traverse, order="preorder")
     postorder = partialmethod(_traverse, order="postorder")
+    levelorder = partialmethod(_traverse, order="level")
 
-    def get_leaves(self) -> Sequence[Any]:
+    def _get_leaves(self) -> Sequence[Any]:
         return self.tree.get_terminals()
 
     @staticmethod

iplotx/ingest/providers/tree/cogent3.py

@@ -16,7 +16,10 @@ class Cogent3DataProvider(TreeDataProvider):
     def postorder(self) -> Sequence[Any]:
         return self.tree.postorder()
 
-    def get_leaves(self) -> Sequence[Any]:
+    def levelorder(self) -> Sequence[Any]:
+        return self.tree.levelorder()
+
+    def _get_leaves(self) -> Sequence[Any]:
         return self.tree.tips()
 
     @staticmethod

iplotx/ingest/providers/tree/dendropy.py

@@ -36,7 +36,16 @@ class DendropyDataProvider(TreeDataProvider):
             return self.tree.postorder_node_iter()
         return self.tree.postorder_iter()
 
-    def get_leaves(self) -> Sequence[Any]:
+    def levelorder(self) -> Any:
+        """Levelorder traversal of the tree.
+
+        NOTE: This will work on both entire Trees and Nodes (which means a subtree including self).
+        """
+        if hasattr(self.tree, "levelorder_node_iter"):
+            return self.tree.levelorder_node_iter()
+        return self.tree.levelorder_iter()
+
+    def _get_leaves(self) -> Sequence[Any]:
         """Get a list of leaves."""
         return self.tree.leaf_nodes()
 

iplotx/ingest/providers/tree/ete4.py

@@ -18,8 +18,9 @@ class Ete4DataProvider(TreeDataProvider):
 
     preorder = partialmethod(_traverse, order="preorder")
     postorder = partialmethod(_traverse, order="postorder")
+    levelorder = partialmethod(_traverse, order="levelorder")
 
-    def get_leaves(self) -> Sequence[Any]:
+    def _get_leaves(self) -> Sequence[Any]:
         return self.tree.leaves()
 
     @staticmethod

iplotx/ingest/providers/tree/simple.py

@@ -64,7 +64,17 @@ class SimpleTreeDataProvider(TreeDataProvider):
 
         yield from _recur(self.tree)
 
-    def get_leaves(self) -> Sequence[Any]:
+    def levelorder(self) -> Iterable[dict[dict | str, Any]]:
+        from collections import deque
+
+        queue = deque([self.get_root()])
+        while queue:
+            node = queue.popleft()
+            for child in self.get_children(node):
+                queue.append(child)
+            yield node
+
+    def _get_leaves(self) -> Sequence[Any]:
         def _recur(node):
             if len(node.children) == 0:
                 yield node

iplotx/ingest/providers/tree/skbio.py

@@ -16,7 +16,10 @@ class SkbioDataProvider(TreeDataProvider):
     def postorder(self) -> Sequence[Any]:
         return self.tree.postorder()
 
-    def get_leaves(self) -> Sequence[Any]:
+    def levelorder(self) -> Sequence[Any]:
+        return self.tree.levelorder()
+
+    def _get_leaves(self) -> Sequence[Any]:
         return self.tree.tips()
 
     @staticmethod

iplotx/ingest/typing.py

@@ -12,6 +12,7 @@ from typing import (
     Any,
     Iterable,
 )
+
 # NOTE: __init__ in Protocols has had a difficult gestation
 # https://github.com/python/cpython/issues/88970
 if sys.version_info < (3, 11):
@@ -156,8 +157,32 @@ class TreeDataProvider(Protocol):
                 return root_attr
         return self.tree.get_root()
 
-    def get_leaves(self) -> Sequence[Any]:
-        """Get the tree leaves/tips in a provider-specific data structure.
+    def get_subtree(self, node: TreeType):
+        """Get the subtree rooted at the given node.
+
+        Parameters:
+            node: The node to get the subtree from.
+        Returns:
+            The subtree rooted at the given node.
+        """
+        return self.__class__(node)
+
+    def get_leaves(self, node: Optional[TreeType] = None) -> Sequence[Any]:
+        """Get the leaves of the entire tree or a subtree.
+
+        Parameters:
+            node: The node to get the leaves from. If None, get from the entire
+                tree.
+        Returns:
+            The leaves or tips of the tree or node-anchored subtree.
+        """
+        if node is None:
+            return self._get_leaves()
+        else:
+            return self.get_subtree(node)._get_leaves()
+
+    def _get_leaves(self) -> Sequence[Any]:
+        """Get the whole tree leaves/tips in a provider-specific data structure.
 
         Returns:
             The leaves or tips of the tree.
@@ -235,8 +260,6 @@ class TreeDataProvider(Protocol):
         NOTE: individual providers may implement more efficient versions of
         this function if desired.
         """
-        provider = self.__class__
-
         # Find leaves of the selected nodes
         leaves = set()
         for node in nodes:
@@ -244,7 +267,7 @@ class TreeDataProvider(Protocol):
             if len(self.get_children(node)) == 0:
                 leaves.add(node)
             else:
-                leaves |= set(provider(node).get_leaves())
+                leaves |= set(self.get_leaves(node))
 
         # Look for nodes with the same set of leaves, starting from the bottom
         # and stopping at the first (i.e. lowest) hit.
@@ -253,7 +276,7 @@ class TreeDataProvider(Protocol):
             if len(self.get_children(node)) == 0:
                 leaves_node = {node}
             else:
-                leaves_node = set(provider(node).get_leaves())
+                leaves_node = set(self.get_leaves(node))
             if leaves <= leaves_node:
                 root = node
                 break
@@ -285,9 +308,26 @@ class TreeDataProvider(Protocol):
                 orientation = "right"
             elif layout == "vertical":
                 orientation = "descending"
-            elif layout == "radial":
+            elif layout in ("radial", "equalangle", "daylight"):
                 orientation = "clockwise"
 
+        # Validate orientation
+        valid = (layout == "horizontal") and (orientation in ("right", "left"))
+        valid |= (layout == "vertical") and (orientation in ("ascending", "descending"))
+        valid |= (layout == "radial") and (
+            orientation in ("clockwise", "counterclockwise", "left", "right")
+        )
+        valid |= (layout == "equalangle") and (
+            orientation in ("clockwise", "counterclockwise", "left", "right")
+        )
+        valid |= (layout == "daylight") and (
+            orientation in ("clockwise", "counterclockwise", "left", "right")
+        )
+        if not valid:
+            raise ValueError(
+                f"Orientation '{orientation}' is not valid for layout '{layout}'.",
+            )
+
         tree_data = {
             "root": self.get_root(),
             "rooted": self.is_rooted(),
@@ -304,8 +344,10 @@ class TreeDataProvider(Protocol):
             root=tree_data["root"],
             preorder_fun=self.preorder,
             postorder_fun=self.postorder,
+            levelorder_fun=self.levelorder,
             children_fun=self.get_children,
             branch_length_fun=self.get_branch_length_default_to_one,
+            leaves_fun=self.get_leaves,
             **layout_style,
         )
         if layout in ("radial",):

iplotx/layout/__init__.py

@@ -0,0 +1,9 @@
+"""
+Layout functions.
+"""
+
+from .tree import compute_tree_layout
+
+__all__ = [
+    "compute_tree_layout",
+]

iplotx/layout/tree/__init__.py

@@ -0,0 +1,72 @@
+"""
+Tree layout algorithms.
+"""
+
+from typing import (
+    Any,
+)
+from collections.abc import (
+    Hashable,
+    Callable,
+)
+
+from .rooted import (
+    _horizontal_tree_layout,
+    _vertical_tree_layout,
+    _radial_tree_layout,
+)
+from .unrooted import (
+    _equalangle_tree_layout,
+    _daylight_tree_layout,
+)
+
+
+def compute_tree_layout(
+    layout: str,
+    orientation: str,
+    root: Any,
+    preorder_fun: Callable,
+    postorder_fun: Callable,
+    levelorder_fun: Callable,
+    children_fun: Callable,
+    branch_length_fun: Callable,
+    leaves_fun: Callable,
+    **kwargs,
+) -> dict[Hashable, list[float]]:
+    """Compute the layout for a tree.
+
+    Parameters:
+        layout: The name of the layout, e.g. "horizontal", "vertical", or "radial".
+        orientation: The orientation of the layout, e.g. "right", "left", "descending",
+            "ascending", "clockwise", "anticlockwise".
+
+    Returns:
+        A layout dictionary with node positions.
+    """
+    kwargs["root"] = root
+    kwargs["preorder_fun"] = preorder_fun
+    kwargs["postorder_fun"] = postorder_fun
+    kwargs["levelorder_fun"] = levelorder_fun
+    kwargs["children_fun"] = children_fun
+    kwargs["orientation"] = orientation
+    kwargs["branch_length_fun"] = branch_length_fun
+    kwargs["leaves_fun"] = leaves_fun
+
+    # Angular or not, the vertex layout is unchanged. Since we do not
+    # currently compute an edge layout here, we can ignore the option.
+    kwargs.pop("angular", None)
+
+    if layout == "radial":
+        layout_dict = _radial_tree_layout(**kwargs)
+    elif layout == "horizontal":
+        layout_dict = _horizontal_tree_layout(**kwargs)
+    elif layout == "vertical":
+        layout_dict = _vertical_tree_layout(**kwargs)
+    elif layout == "equalangle":
+        layout_dict = _equalangle_tree_layout(**kwargs)
+    elif layout == "daylight":
+        layout_dict = _daylight_tree_layout(**kwargs)
+    else:
+        raise ValueError(f"Tree layout not available: {layout}")
+
+    return layout_dict

iplotx/{layout.py → layout/tree/rooted.py}

@@ -1,5 +1,5 @@
 """
-Layout functions, currently limited to trees.
+Rooted tree layout for iplotx library.
 """
 
 from typing import (
@@ -14,55 +14,13 @@ from collections.abc import (
 import numpy as np
 
 
-def compute_tree_layout(
-    layout: str,
-    orientation: str,
-    root: Any,
-    preorder_fun: Callable,
-    postorder_fun: Callable,
-    children_fun: Callable,
-    branch_length_fun: Callable,
-    **kwargs,
-) -> dict[Hashable, list[float]]:
-    """Compute the layout for a tree.
-
-    Parameters:
-        layout: The name of the layout, e.g. "horizontal", "vertical", or "radial".
-        orientation: The orientation of the layout, e.g. "right", "left", "descending",
-            "ascending", "clockwise", "anticlockwise".
-
-    Returns:
-        A layout dictionary with node positions.
-    """
-    kwargs["root"] = root
-    kwargs["preorder_fun"] = preorder_fun
-    kwargs["postorder_fun"] = postorder_fun
-    kwargs["children_fun"] = children_fun
-    kwargs["branch_length_fun"] = branch_length_fun
-    kwargs["orientation"] = orientation
-
-    # Angular or not, the vertex layout is unchanged. Since we do not
-    # currently compute an edge layout here, we can ignore the option.
-    kwargs.pop("angular", None)
-
-    if layout == "radial":
-        layout_dict = _radial_tree_layout(**kwargs)
-    elif layout == "horizontal":
-        layout_dict = _horizontal_tree_layout(**kwargs)
-    elif layout == "vertical":
-        layout_dict = _vertical_tree_layout(**kwargs)
-    else:
-        raise ValueError(f"Tree layout not available: {layout}")
-
-    return layout_dict
-
-
 def _horizontal_tree_layout_right(
     root: Any,
     preorder_fun: Callable,
     postorder_fun: Callable,
     children_fun: Callable,
     branch_length_fun: Callable,
+    **kwargs,
 ) -> dict[Hashable, list[float]]:
     """Build a tree layout horizontally, left to right.
 
@@ -173,7 +131,7 @@ def _radial_tree_layout(
             360, it leaves a small gap at the end to ensure the first and last leaf
             are not overlapping.
     Returns:
-        A dictionary with the radial layout.
+        A dictionary with the layout.
     """
     # Short form
     th = start * np.pi / 180

iplotx/layout/tree/unrooted.py

@@ -0,0 +1,383 @@
+"""
+Unrooted tree layout for iplotx.
+"""
+
+from typing import (
+    Any,
+)
+from collections.abc import (
+    Hashable,
+    Callable,
+)
+import numpy as np
+
+
+def _equalangle_tree_layout(
+    root: Any,
+    preorder_fun: Callable,
+    postorder_fun: Callable,
+    children_fun: Callable,
+    branch_length_fun: Callable,
+    leaves_fun: Callable,
+    orientation: str = "right",
+    start: float = 180,
+    span: float = 360,
+    **kwargs,
+) -> dict[Hashable, list[float]]:
+    """Equal angle unrooted tree layout.
+
+    Parameters:
+        orientation: Whether the layout fans out towards the right (clockwise) or left
+            (anticlockwise).
+        start: The starting angle in degrees, default is -180 (left).
+        span: The angular span in degrees, default is 360 (full circle). When this is
+            360, it leaves a small gap at the end to ensure the first and last leaf
+            are not overlapping.
+    Returns:
+        A dictionary with the layout.
+
+    Reference: "Inferring Phylogenies" by Joseph Felsenstein, ggtree.
+    """
+
+    props = {
+        "layout": {},
+        "nleaves": {},
+        "start": {},
+        "end": {},
+        "angle": {},
+    }
+
+    props["layout"][root] = [0.0, 0.0]
+    props["start"][root] = 0.0
+    props["end"][root] = 360.0
+    props["angle"][root] = 0.0
+
+    # Count the number of leaves in each subtree
+    for node in postorder_fun():
+        props["nleaves"][node] = sum(props["nleaves"][child] for child in children_fun(node)) or 1
+
+    # Set the layout of everyone except the root
+    # NOTE: In ggtree, it says "postorder", but I cannot quite imagine how that would work,
+    # given that in postorder the root is visited last but it's also the only node about
+    # which we know anything at this point.
+    for node in preorder_fun():
+        nleaves = props["nleaves"][node]
+        children = children_fun(node)
+
+        # Get current node props
+        start = props["start"].get(node, 0)
+        end = props["end"].get(node, 0)
+        cur_x, cur_y = props["layout"].get(node, [0.0, 0.0])
+
+        total_angle = end - start
+
+        for child in children:
+            nleaves_child = props["nleaves"][child]
+            alpha = nleaves_child / nleaves * total_angle
+            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["start"][child] = start
+            props["end"][child] = start + alpha
+            start += alpha
+
+    # FIXME: figure out how to tell the caller about "angle"
+    return props["layout"]
+
+
+def _daylight_tree_layout(
+    root: Any,
+    preorder_fun: Callable,
+    postorder_fun: Callable,
+    levelorder_fun: Callable,
+    children_fun: Callable,
+    branch_length_fun: Callable,
+    leaves_fun: Callable,
+    orientation: str = "right",
+    start: float = 180,
+    span: float = 360,
+    max_iter: int = 5,
+    dampening: float = 0.3,
+    **kwargs,
+) -> dict[Hashable, list[float]]:
+    """Daylight unrooted tree layout.
+
+    Parameters:
+        orientation: Whether the layout fans out towards the right (clockwise) or left
+            (anticlockwise).
+        start: The starting angle in degrees, default is -180 (left).
+        span: The angular span in degrees, default is 360 (full circle). When this is
+            360, it leaves a small gap at the end to ensure the first and last leaf
+            are not overlapping.
+        max_iter: Maximum number of iterations to perform.
+        dampening: Dampening factor for angle adjustments. 1.0 means full adjustment.
+            The number must be strictily positive (usually between 0 excluded and 1
+            included).
+    Returns:
+        A dictionary with the layout.
+
+    Reference: "Inferring Phylogenies" by Joseph Felsenstein, ggtree.
+    """
+
+    delta_angle_min = 9.0
+
+    layout = _equalangle_tree_layout(
+        root,
+        preorder_fun,
+        postorder_fun,
+        children_fun,
+        branch_length_fun,
+        leaves_fun,
+        orientation,
+        start,
+        span,
+        **kwargs,
+    )
+
+    if len(layout) <= 2:
+        return layout
+
+    # Make all arrays for easier manipulation
+    orig_class = next(iter(layout.values())).__class__
+    for key, value in layout.items():
+        layout[key] = np.asarray(value)
+
+    all_leaves = list(leaves_fun(root))
+
+    change_avg = 1.0
+    for it in range(max_iter):
+        change_sum = 0
+        ninternal = 0
+        parents = [None] + list(levelorder_fun())
+        for parent in parents:
+            children = children_fun(parent) if parent is not None else [root]
+            for node in children:
+                res = _apply_daylight_single_node(
+                    node,
+                    parent,
+                    all_leaves,
+                    layout,
+                    leaves_fun,
+                    children_fun,
+                    dampening,
+                )
+                change_sum += res
+                ninternal += 1
+
+        change_avg = change_sum / ninternal
+        if change_avg < delta_angle_min:
+            break
+
+    # Make all lists again
+    for key, value in layout.items():
+        layout[key] = orig_class(value)
+
+    return layout
+
+
+def _apply_daylight_single_node(
+    node: Any,
+    parent: Any,
+    all_leaves: list[Any],
+    layout: dict[Hashable, np.ndarray],
+    leaves_fun: Callable,
+    children_fun: Callable,
+    dampening: float,
+) -> float:
+    """Apply daylight adjustment to a single internal node.
+
+    Parameters:
+        node: The internal node to adjust.
+    Returns:
+        The total change in angle applied.
+
+    NOTE: The layout is also changed in place.
+
+    # Inspired from:
+    # https://github.com/thomasp85/ggraph/blob/6c4ce81e460c50a16f9cd97e0b3a089f36901316/src/unrooted.cpp#L122
+    """
+
+    import os
+    from builtins import print as _print
+
+    DEBUG_DAYLIGHT = os.getenv("IPLOTX_DEBUG_DAYLIGHT", "0") == "1"
+
+    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
+    p0 = layout[node]
+    bounds = {}
+
+    print("node")
+    print(node)
+    print(float(p0[0]), float(p0[1]))
+
+    # To find the parent side leaves, we take all leaves and skip the ones
+    # downstream of this node
+    leaves_below = leaves_fun(node)
+
+    # Check the parent first if there is one
+    if parent is not None:
+        vec1 = layout[parent] - p0
+        print("parent side leaves:")
+        print(parent)
+        print(f"  node to parent vector: {vec1[0]:.2f}, {vec1[1]:.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
+            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}")
+            if angle < lower_angle:
+                lower_angle = angle
+                lower = leaf
+            if angle > upper_angle:
+                upper_angle = angle
+                upper = leaf
+        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}")
+        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(leaf)
+            print(f"  angle: {angle:.2f}")
+            if angle < lower_angle:
+                lower_angle = angle
+                lower = leaf
+            if angle > upper_angle:
+                upper_angle = angle
+                upper = leaf
+        bounds[child] = (lower, upper, lower_angle, upper_angle)
+
+    print("final boundary leaves:")
+    print(bounds)
+
+    # 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
+        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(
+            leaf,
+            children_fun,
+            layout,
+            p0,
+            dampening * daylight_cum_corr,
+            recur=True,
+        )
+        daylight_changes += abs(dampening * daylight_cum_corr)
+
+    # Caller wants degrees
+    return np.degrees(daylight_changes / len(leaves))
+
+
+# see: https://stackoverflow.com/questions/14066933/direct-way-of-computing-the-clockwise-angle-between-two-vectors
+def _anticlockwise_angle(v1, v2):
+    """Compute the anticlockwise angle between two 2D vectors.
+
+    Parameters:
+        v1: First vector.
+        v2: Second vector.
+    Returns:
+        The angle in radians.
+    """
+    dot = v1[0] * v2[0] + v1[1] * v2[1]
+    determinant = v1[0] * v2[1] - v1[1] * v2[0]
+    return np.arctan2(determinant, dot)
+
+
+def _rotate_subtree_around_point(
+    node,
+    children_fun: Callable,
+    layout: dict[Hashable, list[float]],
+    pivot,
+    angle,
+    recur: bool = True,
+):
+    point = np.asarray(layout[node])
+    pivot = np.asarray(pivot)
+    layout[node] = _rotate_around_point(
+        point,
+        pivot,
+        angle,
+    )
+    if not recur:
+        return
+    for child in children_fun(node):
+        _rotate_subtree_around_point(
+            child,
+            children_fun,
+            layout,
+            pivot,
+            angle,
+        )
+
+
+def _rotate_around_point(
+    point,
+    pivot,
+    angle,
+):
+    """Rotate a point around a piviot by angle (in radians).
+
+    Parameters:
+        point: The point to rotate.
+        pivot: The piviot point.
+        angle: The angle in radians.
+    Returns:
+        The rotated point.
+    """
+    point = np.asarray(point)
+    pivot = np.asarray(pivot)
+    cos = np.cos(angle)
+    sin = np.sin(angle)
+    rot = np.array([[cos, sin], [-sin, cos]])
+    return pivot + (point - pivot) @ rot

iplotx/tree/__init__.py

@@ -445,7 +445,7 @@ class TreeArtist(mpl.artist.Artist):
         leaf_layout = self.get_layout("leaf").copy()
 
         # Set all to max depth
-        if user_leaf_style.get("deep", True):
+        if user_leaf_style.get("deep", False):
             if layout_name == "radial":
                 leaf_layout.iloc[:, 0] = leaf_layout.iloc[:, 0].max()
             elif (layout_name, orientation) == ("horizontal", "right"):
@@ -666,7 +666,10 @@ class TreeArtist(mpl.artist.Artist):
             norm = mpl.colors.Normalize(vmin=vmin, vmax=vmax)
             edge_style["norm"] = norm
 
-        if get_style(".layout", {}).get("angular", False):
+        angular_layout = get_style(".layout", {}).get("angular", False)
+        if self._ipx_internal_data["layout_name"] in ("equalangle", "daylight"):
+            angular_layout = True
+        if angular_layout:
             edge_style.pop("waypoints", None)
         else:
             edge_style["waypoints"] = waypoints

iplotx/version.py

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iplotx
-Version: 1.2.1
+Version: 1.3.0
 Summary: Plot networkx from igraph and networkx.
 Project-URL: Homepage, https://github.com/fabilab/iplotx
 Project-URL: Documentation, https://readthedocs.org/iplotx
@@ -36,9 +36,9 @@ Provides-Extra: networkx
 Requires-Dist: networkx>=2.0.0; extra == 'networkx'
 Description-Content-Type: text/markdown
 
-![Github Actions](https://github.com/fabilab/iplotx/actions/workflows/test.yml/badge.svg)
-![PyPI - Version](https://img.shields.io/pypi/v/iplotx)
-![RTD](https://readthedocs.org/projects/iplotx/badge/?version=latest)
+[![Github Actions](https://github.com/fabilab/iplotx/actions/workflows/test.yml/badge.svg)](https://github.com/fabilab/iplotx/actions/workflows/test.yml)
+[![PyPI - Version](https://img.shields.io/pypi/v/iplotx)](https://pypi.org/project/iplotx/)
+[![RTD](https://readthedocs.org/projects/iplotx/badge/?version=latest)](https://iplotx.readthedocs.io/en/latest/)
 [![Coverage Status](https://coveralls.io/repos/github/fabilab/iplotx/badge.svg?branch=main)](https://coveralls.io/github/fabilab/iplotx?branch=main)
 ![pylint](assets/pylint.svg)
 [![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.16599333.svg)](https://doi.org/10.5281/zenodo.16599333)
@@ -89,6 +89,13 @@ See [readthedocs](https://iplotx.readthedocs.io/en/latest/) for the full documen
 ## Gallery
 See [gallery](https://iplotx.readthedocs.io/en/latest/gallery/index.html).
 
+## Citation
+If you use `iplotx` for publication figures, please cite the [zenodo preprint](https://doi.org/10.5281/zenodo.16599333):
+
+```
+F. Zanini. (2025). Unified network visualisation in Python. Zenodo [PREPRINT]. https://doi.org/10.5281/zenodo.16599333
+```
+
 ## Features
 - Plot networks from multiple libraries including networkx, igraph and graph-tool, using Matplotlib. ✅
 - Plot trees from multiple libraries such as cogent3, ETE4, skbio, biopython, and dendropy. ✅

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

@@ -1,10 +1,9 @@
 iplotx/__init__.py,sha256=RKlRSSEAv2qECd6rCiovdLDu-4k1eXMGCOCPt0xwpFA,523
 iplotx/artists.py,sha256=2dBDT240zGwKb6tIc_y9pXeyU3LuYeF9wjj2tvi4KJo,730
 iplotx/label.py,sha256=7eS8ByadrhdIFOZz19U4VrS-oXY_ndFYNB-D4RZbFqI,9573
-iplotx/layout.py,sha256=S-iFxHaIOzhBDG2JUzl9_oDBRP5TYY1hXnEOs0h1Rck,5588
 iplotx/plotting.py,sha256=RyAdvaHSpuyJkf8DF3SJBvEXBrPmJEdovUyAlBWQvqU,16228
 iplotx/typing.py,sha256=QLdzV358IiD1CFe88MVp0D77FSx5sSAVUmM_2WPPE8I,1463
-iplotx/version.py,sha256=2CsPuf8-y4qmmHpnn5_1DZwxypX8SRHYrsqTTmN1h5A,66
+iplotx/version.py,sha256=k2KjblHRw7cpH2h7LRTJqlcSXCjDH-WN6aCDQlzMEH4,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
@@ -17,29 +16,33 @@ iplotx/edge/leaf.py,sha256=SyGMv2PIOoH0pey8-aMVaZheK3hNe1Qz_okcyWbc4E4,4268
 iplotx/edge/ports.py,sha256=BpkbiEhX4mPBBAhOv4jcKFG4Y8hxXz5GRtVLCC0jbtI,1235
 iplotx/ingest/__init__.py,sha256=k1Q-7lSdotMR4RkF1x0t19RFsTknohX0L507Dw69WyU,5035
 iplotx/ingest/heuristics.py,sha256=715VqgfKek5LOJnu1vTo7RqPgCl-Bb8Cf6o7_Tt57fA,5797
-iplotx/ingest/typing.py,sha256=nk0UTqTuZoa9YE7F8RlOTqhxPw4OEYFTqrFFRWQs0jI,14488
+iplotx/ingest/typing.py,sha256=VYWlNGwn047J0i10vC_F3Lfnx2CSiX6IeH_NtAgHLQg,16089
 iplotx/ingest/providers/network/graph_tool.py,sha256=iTCf4zHe4Zmdd8Tlz6j7Xfo_FwfsIiK5JkQfH3uq7TM,3028
 iplotx/ingest/providers/network/igraph.py,sha256=WL9Yx2IF5QhUIoKMlozdyq5HWIZ-IJmNoeS8GOhL0KU,2945
 iplotx/ingest/providers/network/networkx.py,sha256=ehCg4npL073HX-eAG-VoP6refLPsMb3lYG51xt_rNjA,4636
 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/dendropy.py,sha256=uRMe46PfDPUTeNInUO2Gbp4pVr-WIFIZQvrND2tovsg,1548
-iplotx/ingest/providers/tree/ete4.py,sha256=D7usSq0MOjzrk3EoLi834IlaDGwv7_qG6Qt0ptfKqfI,928
-iplotx/ingest/providers/tree/simple.py,sha256=-T7Kf-G4F4niggy_tNZ8AafDf8fpDdthC-vlkjbEZso,2569
-iplotx/ingest/providers/tree/skbio.py,sha256=O1KUr8tYi28pZ3VVjapgO4Uj-YpMuix3GhOH5je8Lv4,822
+iplotx/ingest/providers/tree/biopython.py,sha256=si-ncMVHrdbwDVspznFbO7ajTaa37gqSfYGKdx9eoQ8,1538
+iplotx/ingest/providers/tree/cogent3.py,sha256=6omk0cDSmb2k2J1BQ9depcSPWcfamSyS0eIlRpLRgoM,1156
+iplotx/ingest/providers/tree/dendropy.py,sha256=MRmPdlrPwqCQWLkKM4vJLN4hpqLY7qGtNrBYs5pLP9E,1891
+iplotx/ingest/providers/tree/ete4.py,sha256=JT0Zv-nzHKTSJ0h4I7SxkwFafww_siDZ06Krvz-BT1U,991
+iplotx/ingest/providers/tree/simple.py,sha256=hin38l9ZAnuDGwZAPctxNhIBrmIkQYIkBMFPt9uALuE,2877
+iplotx/ingest/providers/tree/skbio.py,sha256=T3IbOBut98A2GoGJzo6Tzp108uFa9n485mV4M9J5xFk,905
+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/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/library.py,sha256=58Y8BlllGLsR4pQM7_PVCP5tH6_4GkchXZvJpqGHlcg,8534
-iplotx/tree/__init__.py,sha256=nV2iWrtpPhpGZnkEJqK8ydimMi7pJtRQ1Eqn5dgqUyA,31043
+iplotx/tree/__init__.py,sha256=sxVrxZcsDIZddBdtI-TxOs37FyeYbHBLYqkLPWs6c8M,31199
 iplotx/tree/cascades.py,sha256=Wwqhy46QGeb4LNGUuz_-bgNWUMz6PFzs_dIxIb1dtqc,8394
 iplotx/tree/scalebar.py,sha256=Yxt_kF8JdTwKGa8Jzqt3qVePPK5ZBG8P0EiONrsh3E8,11863
 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.2.1.dist-info/METADATA,sha256=DVxutHflrg2vXCJfyzmPR83ywc4_5DfGdrViUMvV43E,5001
-iplotx-1.2.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-iplotx-1.2.1.dist-info/RECORD,,
+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,,