iplotx 0.3.1__py3-none-any.whl → 0.5.0__py3-none-any.whl

iplotx/ingest/providers/tree/ete4.py

@@ -3,6 +3,7 @@ from typing import (
     Optional,
     Sequence,
 )
+import importlib
 from functools import partialmethod
 
 from ...typing import (
@@ -31,11 +32,7 @@ class Ete4DataProvider(TreeDataProvider):
 
     @staticmethod
     def check_dependencies() -> bool:
-        try:
-            from ete4 import Tree
-        except ImportError:
-            return False
-        return True
+        return importlib.util.find_spec("ete4") is not None
 
     @staticmethod
     def tree_type():

iplotx/ingest/providers/tree/simple.py

@@ -0,0 +1,97 @@
+from typing import (
+    Any,
+    Optional,
+    Sequence,
+    Iterable,
+    Self,
+)
+
+from ...typing import (
+    TreeDataProvider,
+)
+
+
+class SimpleTree:
+    """A simple tree class for educational purposes.
+
+    Properties:
+        children: Children SimpleTree objects.
+        branch_length: Length of the branch leading to this node/tree.
+    """
+
+    children: Sequence[Self] = []
+    branch_length: float = 1
+
+    @classmethod
+    def from_dict(cls, data: dict) -> Self:
+        """Create a SimpleTree from a dictionary.
+
+        Parameters:
+            data: A dictionary representation of the tree, with "children" as a list offset_transform
+                child nodes and an optional "branch_length" property (float).
+
+        Returns:
+            An instance of SimpleTree constructed from the provided dictionary.
+        """
+        tree = cls()
+        tree.branch_length = data.get("branch_length", 1)
+        tree.children = [cls.from_dict(child) for child in data.get("children", [])]
+        return tree
+
+
+class SimpleTreeDataProvider(TreeDataProvider):
+    def is_rooted(self) -> bool:
+        return True
+
+    def get_root(self) -> Any:
+        """Get the root node of the tree."""
+        return self.tree
+
+    def preorder(self) -> Iterable[dict[dict | str, Any]]:
+        def _recur(node):
+            yield node
+            for child in node.children:
+                yield from _recur(child)
+
+        yield from _recur(self.tree)
+
+    def postorder(self) -> Iterable[dict[dict | str, Any]]:
+        def _recur(node):
+            for child in node.children:
+                yield from _recur(child)
+            yield node
+
+        yield from _recur(self.tree)
+
+    def get_leaves(self) -> Sequence[Any]:
+        def _recur(node):
+            if len(node.children) == 0:
+                yield node
+            else:
+                for child in node.children:
+                    yield from _recur(child)
+
+        return list(_recur(self.tree))
+
+    @staticmethod
+    def get_children(node: Any) -> Sequence[Any]:
+        return node.children
+
+    @staticmethod
+    def get_branch_length(node: Any) -> Optional[float]:
+        return node.branch_length
+
+    @staticmethod
+    def check_dependencies() -> bool:
+        return True
+
+    @staticmethod
+    def tree_type():
+        return SimpleTree
+
+    def get_support(self):
+        """Get support/confidence values for all nodes."""
+        support_dict = {}
+        for node in self.preorder():
+            support_dict[node] = None
+        return support_dict

iplotx/ingest/providers/tree/skbio.py

@@ -3,6 +3,7 @@ from typing import (
     Optional,
     Sequence,
 )
+import importlib
 from ...typing import (
     TreeDataProvider,
 )
@@ -28,11 +29,7 @@ class SkbioDataProvider(TreeDataProvider):
 
     @staticmethod
     def check_dependencies() -> bool:
-        try:
-            from skbio import TreeNode
-        except ImportError:
-            return False
-        return True
+        return importlib.util.find_spec("skbio") is not None
 
     @staticmethod
     def tree_type():

iplotx/ingest/typing.py

@@ -40,9 +40,19 @@ class NetworkData(TypedDict):
 class NetworkDataProvider(Protocol):
     """Protocol for network data ingestion provider for iplotx."""
 
-    def __call__(
+    def __init__(
         self,
         network: GraphType,
+    ) -> None:
+        """Initialise network data provider.
+
+        Parameters:
+            network: The network to ingest.
+        """
+        self.network = network
+
+    def __call__(
+        self,
         layout: Optional[LayoutType] = None,
         vertex_labels: Optional[Sequence[str] | dict[Hashable, str] | pd.Series] = None,
         edge_labels: Optional[Sequence[str] | dict] = None,
@@ -60,6 +70,14 @@ class NetworkDataProvider(Protocol):
         """Return the graph type from this provider to check for instances."""
         raise NotImplementedError("Network data providers must implement this method.")
 
+    def is_directed(self):
+        """Check whether the network is directed."""
+        raise NotImplementedError("Network data providers must implement this method.")
+
+    def number_of_vertices(self):
+        """The number of vertices/nodes in the network."""
+        raise NotImplementedError("Network data providers must implement this method.")
+
 
 class TreeData(TypedDict):
     """Tree data structure for iplotx."""
@@ -190,23 +208,66 @@ class TreeDataProvider(Protocol):
         branch_length = self.get_branch_length(node)
         return branch_length if branch_length is not None else 1.0
 
+    def get_lca(
+        self,
+        nodes: Sequence[Hashable],
+    ) -> Hashable:
+        """Find the last common ancestor of a sequence of nodes.
+
+        Parameters:
+            nodes: The nodes to find a common ancestor for.
+
+        Returns:
+            The node that is the last (deepest) common ancestor of the nodes.
+
+        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:
+            # NOTE: get_leaves excludes the node itself...
+            if len(self.get_children(node)) == 0:
+                leaves.add(node)
+            else:
+                leaves |= set(provider(node).get_leaves())
+
+        # Look for nodes with the same set of leaves, starting from the bottom
+        # and stopping at the first (i.e. lowest) hit.
+        for node in self.postorder():
+            # NOTE: As above, get_leaves excludes the node itself
+            if len(self.get_children(node)) == 0:
+                leaves_node = {node}
+            else:
+                leaves_node = set(provider(node).get_leaves())
+            if leaves <= leaves_node:
+                root = node
+                break
+        else:
+            raise ValueError(f"Common ancestor not found for nodes: {nodes}")
+
+        return root
+
     def __call__(
         self,
         layout: str | LayoutType,
-        orientation: Optional[str],
         layout_style: Optional[dict[str, int | float | str]] = None,
         directed: bool | str = False,
-        vertex_labels: Optional[
-            Sequence[str] | dict[Hashable, str] | pd.Series | bool
-        ] = None,
+        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] = 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 ete4.core.tre.Tree classes.
+
+        NOTE: This function needs NOT be implemented by individual providers.
+        """
 
         if layout_style is None:
             layout_style = {}
 
+        orientation = layout_style.pop("orientation", None)
         if orientation is None:
             if layout == "horizontal":
                 orientation = "right"
@@ -240,6 +301,15 @@ class TreeDataProvider(Protocol):
         else:
             tree_data["layout_coordinate_system"] = "cartesian"
 
+        # Add leaf_df
+        # NOTE: Sometimes (e.g. cogent3) the leaves convert into a pd.Index
+        # in a strange way, whereby their name disappears upon printing the
+        # index but is actually visible (and kept) when inspecting the
+        # individual elements (leaves). Seems ok functionally, though a little
+        # awkward visually during debugging.
+        tree_data["leaf_df"] = pd.DataFrame(index=self.get_leaves())
+        leaf_name_attrs = ("name",)
+
         # Add edge_df
         edge_data = {"_ipx_source": [], "_ipx_target": []}
         for node in self.preorder():
@@ -253,16 +323,30 @@ class TreeDataProvider(Protocol):
         edge_df = pd.DataFrame(edge_data)
         tree_data["edge_df"] = edge_df
 
-        # Add leaf_df
-        tree_data["leaf_df"] = pd.DataFrame(index=self.get_leaves())
+        # Add branch support
+        if hasattr(self, "get_support"):
+            support = self.get_support()
+
+            for key, value in support.items():
+                # Leaves never show support, it's not a branching point
+                if key in tree_data["leaf_df"].index:
+                    support[key] = ""
+                elif value is None:
+                    support[key] = ""
+                elif np.isscalar(value):
+                    # Assume support is in percentage and round it to nearest integer.
+                    support[key] = str(int(np.round(value, 0)))
+                else:
+                    # Apparently multiple supports are accepted in some XML format
+                    support[key] = "/".join(str(int(np.round(v, 0))) for v in value)
+
+            tree_data["vertex_df"]["support"] = pd.Series(support).loc[tree_data["vertex_df"].index]
 
         # Add vertex labels
         if vertex_labels is None:
             vertex_labels = False
         if np.isscalar(vertex_labels) and vertex_labels:
-            tree_data["vertex_df"]["label"] = [
-                x.name for x in tree_data["vertex_df"].index
-            ]
+            tree_data["vertex_df"]["label"] = [x.name for x in tree_data["vertex_df"].index]
         elif not np.isscalar(vertex_labels):
             # If a dict-like object is passed, it can be incomplete (e.g. only the leaves):
             # we fill the rest with empty strings which are not going to show up in the plot.
@@ -278,17 +362,23 @@ class TreeDataProvider(Protocol):
         if leaf_labels is None:
             leaf_labels = False
         if np.isscalar(leaf_labels) and leaf_labels:
-            tree_data["leaf_labels"]["label"] = [
-                # FIXME: this is likely broken
-                x.name
-                for x in tree_data["leaf_df"].index
-            ]
+            leaf_labels = []
+            for leaf in tree_data["leaf_df"].index:
+                for name_attr in leaf_name_attrs:
+                    if hasattr(leaf, name_attr):
+                        label = getattr(leaf, name_attr)
+                        break
+                else:
+                    raise ValueError(
+                        "Could not find leaf name attribute.",
+                    )
+                leaf_labels.append(label)
+            tree_data["leaf_df"]["label"] = leaf_labels
         elif not np.isscalar(leaf_labels):
             # Leaves are already in the dataframe in a certain order, so sequences are allowed
             if isinstance(leaf_labels, (list, tuple, np.ndarray)):
                 leaf_labels = {
-                    leaf: label
-                    for leaf, label in zip(tree_data["leaf_df"].index, leaf_labels)
+                    leaf: label for leaf, label in zip(tree_data["leaf_df"].index, leaf_labels)
                 }
             # If a dict-like object is passed, it can be incomplete (e.g. only the leaves):
             # we fill the rest with empty strings which are not going to show up in the plot.

iplotx/label.py

@@ -17,6 +17,7 @@ from .style import (
 from .utils.matplotlib import (
     _stale_wrapper,
     _forwarder,
+    _get_label_width_height,
 )
 
 
@@ -108,12 +109,13 @@ class LabelCollection(mpl.artist.Artist):
                 self._offsets[i][1],
                 label,
                 transform=transform,
+                rotation_mode="anchor",
                 **stylei,
             )
             arts.append(art)
         self._labelartists = arts
         self._margins = np.array(margins)
-        self._rotations = np.zeros(len(self._labels))
+        self._rotations = np.array([np.pi / 180 * art.get_rotation() for art in arts])
 
     def _update_offsets(self, dpi: float = 72.0) -> None:
         """Update offsets including margins."""
@@ -134,10 +136,11 @@ class LabelCollection(mpl.artist.Artist):
             transform = self.get_transform()
             trans = transform.transform
             trans_inv = transform.inverted().transform
-            rotations = self.get_rotations()
-            vrot = [np.cos(rotations), np.sin(rotations)]
 
+            # Add margins *before* applying the rotation
             margins_rot = np.empty_like(margins)
+            rotations = self.get_rotations()
+            vrot = [np.cos(rotations), np.sin(rotations)]
             margins_rot[:, 0] = margins[:, 0] * vrot[0] - margins[:, 1] * vrot[1]
             margins_rot[:, 1] = margins[:, 0] * vrot[1] + margins[:, 1] * vrot[0]
             offsets = trans_inv(trans(offsets) + margins_rot)
@@ -170,12 +173,12 @@ class LabelCollection(mpl.artist.Artist):
             rot_deg = 180.0 / np.pi * rotation
             # Force the font size to be upwards
             if ha == "auto":
-                if -90 <= rot_deg < 90:
+                if -90 <= np.round(rot_deg, 3) < 90:
                     art.set_horizontalalignment("left")
                 else:
                     art.set_horizontalalignment("right")
-            rot_deg = ((rot_deg + 90) % 180) - 90
-            art.set_rotation(rot_deg)
+            rot_deg_new = ((rot_deg + 90) % 180) - 90
+            art.set_rotation(rot_deg_new)
 
     def get_datalim(self, transData=None) -> mpl.transforms.Bbox:
         """Get the data limits of the labels."""
@@ -184,15 +187,42 @@ class LabelCollection(mpl.artist.Artist):
         return bbox
 
     def get_datalims_children(self, transData=None) -> Sequence[mpl.transforms.Bbox]:
-        """Get the data limits of the children of this artist."""
+        """Get the data limits  of the children of this artist."""
+        dpi = self.figure.dpi if self.figure is not None else 72.0
         if transData is None:
             transData = self.get_transform()
-        trans_inv = transData.inverted().transform_bbox
+        trans = transData.transform
+        trans_inv = transData.inverted().transform
         bboxes = []
-        for art in self._labelartists:
-            bbox_fig = art.get_bbox_patch().get_extents()
-            bbox_data = trans_inv(bbox_fig)
-            bboxes.append(bbox_data)
+        for art, rot in zip(self._labelartists, self.get_rotations()):
+            # These are in figure points
+            textprops = ("text", "fontsize")
+            props = art.properties()
+            props = {key: props[key] for key in textprops}
+            props["dpi"] = dpi
+            props["hpadding"] = 12
+            props["vpadding"] = 12
+            width, height = _get_label_width_height(**props)
+
+            # Positions are in data coordinates
+            # and include the margins (it's the actual position of the
+            # text anchor)
+            pos_data = art.get_position()
+
+            # Four corners
+            dh = width / 2 * np.array([-np.sin(rot), np.cos(rot)])
+            dw = height * np.array([np.cos(rot), np.sin(rot)])
+            c1 = trans_inv(trans(pos_data) + dh)
+            c2 = trans_inv(trans(pos_data) - dh)
+            if art.get_horizontalalignment() == "right":
+                c3 = trans_inv(trans(pos_data) - dw + dh)
+                c4 = trans_inv(trans(pos_data) - dw - dh)
+            else:
+                c3 = trans_inv(trans(pos_data) + dw + dh)
+                c4 = trans_inv(trans(pos_data) + dw - dh)
+            bbox = mpl.transforms.Bbox.null()
+            bbox.update_from_data_xy([c1, c2, c3, c4], ignore=True)
+            bboxes.append(bbox)
         return bboxes
 
     @_stale_wrapper

iplotx/layout.py

@@ -24,7 +24,7 @@ def compute_tree_layout(
     """Compute the layout for a tree.
 
     Parameters:
-        layout: The name of the layout, e.g. "horizontal", "vertial", or "radial".
+        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".
 
@@ -38,6 +38,10 @@ def compute_tree_layout(
     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":

iplotx/network.py

@@ -1,4 +1,8 @@
-from typing import Optional, Sequence
+from typing import (
+    Optional,
+    Sequence,
+    Self,
+)
 import numpy as np
 import pandas as pd
 import matplotlib as mpl
@@ -62,12 +66,6 @@ class NetworkArtist(mpl.artist.Artist):
 
         """
         self.network = network
-        self._ipx_internal_data = ingest_network_data(
-            network,
-            layout,
-            vertex_labels=vertex_labels,
-            edge_labels=edge_labels,
-        )
 
         super().__init__()
 
@@ -80,8 +78,66 @@ class NetworkArtist(mpl.artist.Artist):
         zorder = get_style(".network").get("zorder", 1)
         self.set_zorder(zorder)
 
-        self._add_vertices()
-        self._add_edges()
+        if network is not None:
+            self._ipx_internal_data = ingest_network_data(
+                network,
+                layout,
+                vertex_labels=vertex_labels,
+                edge_labels=edge_labels,
+            )
+
+            self._add_vertices()
+            self._add_edges()
+
+    @classmethod
+    def from_other(
+        cls: "NetworkArtist",  # NOTE: This is fixed in Python 3.14
+        other: Self,
+    ) -> Self:
+        """Create a NetworkArtist as a copy of another one.
+
+        Parameters:
+            other: The other NetworkArtist.
+
+        Returns:
+            An instantiated NetworkArtist.
+        """
+        self = cls.from_edgecollection(other._edges)
+        self.network = other.network
+        if hasattr(other, "_ipx_internal_data"):
+            self._ipx_internal_data = other._ipx_internal_data
+        return self
+
+    @classmethod
+    def from_edgecollection(
+        cls: "NetworkArtist",  # NOTE: This is fixed in Python 3.14
+        edge_collection: EdgeCollection,
+    ) -> Self:
+        """Create a NetworkArtist from iplotx artists.
+
+        Parameters:
+            edge_collection: The edge collection to use to initialise the artist. Vertices will
+              be obtained automatically.
+
+        Returns:
+            The initialised NetworkArtist.
+        """
+        vertex_collection = edge_collection._vertex_collection
+        layout = vertex_collection._layout
+        transform = vertex_collection.get_transform()
+        offset_transform = edge_collection.get_transform()
+
+        # Follow the steps in the normal constructor
+        self = cls(
+            network=None,
+            layout=layout,
+            transform=transform,
+            offset_transform=offset_transform,
+        )
+        self._vertices = vertex_collection
+        self._edges = edge_collection
+
+        return self
 
     def get_children(self):
         return (self._vertices, self._edges)
@@ -145,9 +201,7 @@ class NetworkArtist(mpl.artist.Artist):
         self.axes.autoscale_view(tight=tight)
 
     def get_layout(self):
-        layout_columns = [
-            f"_ipx_layout_{i}" for i in range(self._ipx_internal_data["ndim"])
-        ]
+        layout_columns = [f"_ipx_layout_{i}" for i in range(self._ipx_internal_data["ndim"])]
         vertex_layout_df = self._ipx_internal_data["vertex_df"][layout_columns]
         return vertex_layout_df
 
@@ -189,13 +243,12 @@ class NetworkArtist(mpl.artist.Artist):
             cmap_fun = _build_cmap_fun(
                 edge_style["color"],
                 edge_style["cmap"],
+                edge_style.get("norm", None),
             )
         else:
             cmap_fun = None
 
-        edge_df = self._ipx_internal_data["edge_df"].set_index(
-            ["_ipx_source", "_ipx_target"]
-        )
+        edge_df = self._ipx_internal_data["edge_df"].set_index(["_ipx_source", "_ipx_target"])
 
         if "cmap" in edge_style:
             colorarray = []
@@ -231,7 +284,7 @@ class NetworkArtist(mpl.artist.Artist):
             edgepatches.append(patch)
             adjacent_vertex_ids.append((vid1, vid2))
 
-        if "cmap" in edge_style:
+        if ("cmap" in edge_style) and ("norm" not in edge_style):
             vmin = np.min(colorarray)
             vmax = np.max(colorarray)
             norm = mpl.colors.Normalize(vmin=vmin, vmax=vmax)
@@ -259,8 +312,6 @@ class NetworkArtist(mpl.artist.Artist):
         if not self.get_visible():
             return
 
-        # FIXME: Callbacks on stale vertices/edges??
-
         # NOTE: looks like we have to manage the zorder ourselves
         # this is kind of funny actually
         children = list(self.get_children())

iplotx/plotting.py

@@ -21,7 +21,7 @@ def network(
     network: Optional[GraphType] = None,
     layout: Optional[LayoutType] = None,
     grouping: Optional[GroupingType] = None,
-    vertex_labels: Optional[list | dict | pd.Series] = None,
+    vertex_labels: Optional[list | dict | pd.Series | bool] = None,
     edge_labels: Optional[Sequence] = None,
     ax: Optional[mpl.axes.Axes] = None,
     style: str | dict | Sequence[str | dict] = (),
@@ -53,7 +53,7 @@ def network(
             used as a quick fix when some vertex shapes reach beyond the plot edge. This is
             a fraction of the data limits, so 0.1 means 10% of the data limits will be left
             as margin.
-        **kwargs: Additional arguments are treated as an alternate way to specify style. If
+        kwargs: Additional arguments are treated as an alternate way to specify style. If
             both "style" and additional **kwargs are provided, they are both applied in that
             order (style, then **kwargs).
 
@@ -123,10 +123,10 @@ def network(
 def tree(
     tree: Optional[TreeType] = None,
     layout: str | LayoutType = "horizontal",
-    orientation: Optional[str] = None,
     directed: bool | str = False,
-    vertex_labels: Optional[list | dict | pd.Series] = None,
-    leaf_labels: Optional[list | dict | pd.Series] = None,
+    vertex_labels: Optional[list | dict | pd.Series | bool] = None,
+    leaf_labels: Optional[list | dict | pd.Series | bool] = None,
+    show_support: bool = False,
     ax: Optional[mpl.axes.Axes] = None,
     style: str | dict | Sequence[str | dict] = "tree",
     title: Optional[str] = None,
@@ -139,11 +139,11 @@ def tree(
     Parameters:
         tree: The tree to plot. Can be a BioPython.Phylo.Tree object.
         layout: The layout to use for plotting.
-        orientation: The orientation of the layout. Can be "right" or "left". Defaults to
-            "right" for horizontal layout, "descending" or "ascending" for vertical layout,
-            and "clockwise" or "anticlockwise" for radial layout.
         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.
+        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.
 
     Returns:
         A TreeArtist object, set as a direct child of the matplotlib Axes.
@@ -157,12 +157,12 @@ def tree(
         artist = TreeArtist(
             tree=tree,
             layout=layout,
-            orientation=orientation,
             directed=directed,
             transform=mpl.transforms.IdentityTransform(),
             offset_transform=ax.transData,
             vertex_labels=vertex_labels,
             leaf_labels=leaf_labels,
+            show_support=show_support,
         )
         ax.add_artist(artist)