iplotx 1.2.1__tar.gz → 1.4.0__tar.gz

{iplotx-1.2.1 → iplotx-1.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iplotx
-Version: 1.2.1
+Version: 1.4.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 → iplotx-1.4.0}/README.md

@@ -1,6 +1,6 @@
-![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)
@@ -51,6 +51,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 → iplotx-1.4.0}/docs/source/api/complete_style_specification.md

@@ -102,9 +102,14 @@
 
         "curved": bool,  # Whether the edge is curved (True) or straight (False)
 
-        # Tension for curved edges (0.0 for straight, higher values position the
-        # Bezier control points further away from the nodes, creating more wiggly lines)
+        # Tension for curved edges and arcs.
+        # For Bezier (curved) edges, 0.0 means straight, higher values position the
+        # Bezier control points further away from the nodes, creating more wiggly lines.
         # Negative values bend the curve on the other side of the straight line.
+        # For arc edges, 0.0 means straight, higher values draw larger arcs. 1.0
+        # means a semicircle, and numbers above 5 create very large arcs, almost full
+        # circles. The exact definition of tension for arcs is the tangent of a
+        # quarter of the angle spanned by the arc.
         "tension": float,
 
         # Tension for self-loops (higher values create more bigger loops).
@@ -281,7 +286,7 @@
         # For horizontal and vertical layouts:
         #   start: Starting position in data units (tuple of two floats)
         #   span: Breadth in data units (float)
-        "start": float | tuple[float, float],
+        "start": float | tuple[float            margins=0.2,
         "span": float,
     },
     ############################################################################

{iplotx-1.2.1 → iplotx-1.4.0}/docs/source/code_of_conduct.rst

@@ -1,6 +1,6 @@
 .. _scipy-coc:
 
-ilpotx Code of Conduct
+iplotx Code of Conduct
 ======================
 
 

{iplotx-1.2.1 → iplotx-1.4.0}/docs/source/sg_execution_times.rst

@@ -6,7 +6,7 @@
 
 Computation times
 =================
-**00:00.565** total execution time for 77 files **from all galleries**:
+**00:00.117** total execution time for 79 files **from all galleries**:
 
 .. container::
 
@@ -32,8 +32,8 @@ Computation times
    * - Example
      - Time
      - Mem (MB)
-   * - :ref:`sphx_glr_gallery_tree_plot_double_tree.py` (``../../gallery/tree/plot_double_tree.py``)
-     - 00:00.565
+   * - :ref:`sphx_glr_gallery_basic_plot_arcs.py` (``../../gallery/basic/plot_arcs.py``)
+     - 00:00.117
      - 0.0
    * - :ref:`sphx_glr_gallery_basic_plot_3d.py` (``../../gallery/basic/plot_3d.py``)
      - 00:00.000
@@ -221,9 +221,15 @@ Computation times
    * - :ref:`sphx_glr_gallery_tree_plot_dendropy.py` (``../../gallery/tree/plot_dendropy.py``)
      - 00:00.000
      - 0.0
+   * - :ref:`sphx_glr_gallery_tree_plot_double_tree.py` (``../../gallery/tree/plot_double_tree.py``)
+     - 00:00.000
+     - 0.0
    * - :ref:`sphx_glr_gallery_tree_plot_elements_tree.py` (``../../gallery/tree/plot_elements_tree.py``)
      - 00:00.000
      - 0.0
+   * - :ref:`sphx_glr_gallery_tree_plot_equalangle.py` (``../../gallery/tree/plot_equalangle.py``)
+     - 00:00.000
+     - 0.0
    * - :ref:`sphx_glr_gallery_tree_plot_ete4.py` (``../../gallery/tree/plot_ete4.py``)
      - 00:00.000
      - 0.0

iplotx-1.4.0/gallery/basic/plot_arcs.py

@@ -0,0 +1,42 @@
+"""
+Arcs
+====
+
+This example showcases the ability of `iplotx` to curve edges into arcs, using tension to define the angular span of the arc.
+"""
+
+import igraph as ig
+import matplotlib.pyplot as plt
+import iplotx as ipx
+
+
+g = ig.Graph.Full(4)
+layout = [[0, 0], [1, 0], [2, 0], [3, 0]]
+
+fig, ax = plt.subplots()
+ipx.plot(
+    g,
+    layout=layout,
+    ax=ax,
+    edge_arc=True,
+    edge_tension=-1,
+)
+
+# %%
+# ..tip::
+#   Specifically, tension is defined as the tangent of the quarter of the angle spanned by the arc. A tension of 0 gives
+#   a straight line, a tension of 1 gives a semicircle, and higher tensions give increasingly larger arcs. A tension of
+#   infinity would give you a straight line away from the target vertex, but is not accepted by the library. Negative
+#   tensions result in arcs curving in the opposite direction.
+
+fig, axs = plt.subplots(2, 2, figsize=(8, 8))
+for tension, ax in zip([0.5, 2.5, -0.5, -2.5], axs.ravel()):
+    ipx.plot(
+        g,
+        layout=layout,
+        ax=ax,
+        edge_arc=True,
+        edge_tension=tension,
+        margins=0.15,
+        title=f"Edge tension = {tension:.2f}",
+    )

iplotx-1.4.0/gallery/tree/plot_equalangle.py

@@ -0,0 +1,35 @@
+"""
+Equal angle layout
+==================
+
+This example showcases the "equal angle" layout. This layout is inspired by the `ggtree <https://yulab-smu.top/treedata-book/chapter4.html>`_ layout with the same name, which originally comes from Joseph Felsenstein's book "Inferring Phylogenies".
+"""
+
+from cogent3.phylo import nj
+import numpy as np
+import iplotx as ipx
+import matplotlib.pyplot as plt
+
+nleaves = 14
+distance_dict = {}
+for i in range(nleaves):
+    for j in range(i):
+        distance_dict[(str(i), str(j))] = np.random.rand()
+tree = nj.nj(distance_dict)
+
+ipx.plotting.tree(
+    tree,
+    layout="equalangle",
+)
+
+
+# %%
+# The "equal daylight" layout is an adjustment of the equal angle layout that attempts to spread out leaves more evenly
+# for imbalanced trees. ``iplotx`` has an experimental implementation of this layout.
+#
+# .. warning:: "Experimental" means you can use it but the API and resulting layout may change in future releases.
+
+ipx.plotting.tree(
+    tree,
+    layout="daylight",
+)

{iplotx-1.2.1 → iplotx-1.4.0}/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,
             )
@@ -712,6 +718,7 @@ def make_stub_patch(**kwargs):
         "split",
         "shrink",
         "depthshade",
+        "arc",
         # DEPRECATED
         "padding",
     ]

{iplotx-1.2.1 → iplotx-1.4.0}/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-1.2.1 → iplotx-1.4.0}/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-1.2.1 → iplotx-1.4.0}/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-1.2.1 → iplotx-1.4.0}/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-1.2.1 → iplotx-1.4.0}/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-1.2.1 → iplotx-1.4.0}/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-1.2.1 → iplotx-1.4.0}/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-1.2.1 → iplotx-1.4.0}/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-1.4.0/iplotx/layout/__init__.py

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

iplotx-1.4.0/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