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

iplotx/ingest/providers/network/simple.py

@@ -0,0 +1,121 @@
+from typing import (
+    Optional,
+    Sequence,
+    Any,
+)
+from collections.abc import Hashable
+import numpy as np
+import pandas as pd
+
+from ....typing import (
+    GraphType,
+    LayoutType,
+)
+from ...heuristics import (
+    normalise_layout,
+)
+from ...typing import (
+    NetworkDataProvider,
+    NetworkData,
+)
+from ....utils.internal import (
+    _make_layout_columns,
+)
+
+
+class SimpleDataProvider(NetworkDataProvider):
+    def __call__(
+        self,
+        layout: Optional[LayoutType] = None,
+        vertex_labels: Optional[Sequence[str] | dict[Hashable, str] | pd.Series] = None,
+        edge_labels: Optional[Sequence[str] | dict[str]] = None,
+    ) -> NetworkData:
+        """Create network data object for iplotx from a simple Python object."""
+        network = self.network
+        directed = self.is_directed()
+
+        # Recast vertex_labels=False as vertex_labels=None
+        if np.isscalar(vertex_labels) and (not vertex_labels):
+            vertex_labels = None
+
+        # Vertices are ordered integers, no gaps
+        for key in ["nodes", "vertices"]:
+            if key in network:
+                vertices = network[key]
+                break
+        else:
+            # Infer from edge adjacent vertices, singletons will be missed
+            vertices = set()
+            for edge in self.network.get("edges", []):
+                vertices.add(edge[0])
+                vertices.add(edge[1])
+        vertices = list(vertices)
+
+        # NOTE: This is underpowered, but it's ok for a simple educational provider
+        if isinstance(layout, pd.DataFrame):
+            vertex_df = layout.loc[vertices].copy()
+        elif isinstance(layout, dict):
+            vertex_df = pd.DataFrame(layout).T.loc[vertices]
+        else:
+            vertex_df = pd.DataFrame(
+                index=vertices,
+                data=layout,
+            )
+        ndim = vertex_df.shape[1]
+        vertex_df.columns = _make_layout_columns(ndim)
+
+        # Vertex labels
+        if vertex_labels is not None:
+            if np.isscalar(vertex_labels):
+                vertex_df["label"] = vertex_df.index.astype(str)
+            elif len(vertex_labels) != len(vertex_df):
+                raise ValueError(
+                    "Vertex labels must be the same length as the number of vertices."
+                )
+            else:
+                vertex_df["label"] = vertex_labels
+
+        # Edges are a list of tuples, because of multiedges
+        tmp = []
+        for edge in network.get("edges", []):
+            row = {"_ipx_source": edge[0], "_ipx_target": edge[1]}
+            tmp.append(row)
+        if len(tmp):
+            edge_df = pd.DataFrame(tmp)
+        else:
+            edge_df = pd.DataFrame(columns=["_ipx_source", "_ipx_target"])
+        del tmp
+
+        network_data = {
+            "vertex_df": vertex_df,
+            "edge_df": edge_df,
+            "directed": directed,
+            "ndim": ndim,
+        }
+        return network_data
+
+    @staticmethod
+    def check_dependencies() -> bool:
+        """Check dependencies. Returns True since this provider has no dependencies."""
+        return True
+
+    @staticmethod
+    def graph_type():
+        return dict
+
+    def is_directed(self):
+        """Whether the network is directed."""
+        return self.network.get("directed", False)
+
+    def number_of_vertices(self):
+        """The number of vertices/nodes in the network."""
+        for key in ("nodes", "vertices"):
+            if key in self.network:
+                return len(self.network[key])
+
+        # Default to unique edge adjacent nodes (this will ignore singletons)
+        nodes = set()
+        for edge in self.network.get("edges", []):
+            nodes.add(edge[0])
+            nodes.add(edge[1])
+        return len(nodes)

iplotx/ingest/providers/tree/biopython.py

@@ -45,3 +45,16 @@ class BiopythonDataProvider(TreeDataProvider):
         from Bio import Phylo
 
         return Phylo.BaseTree.Tree
+
+    def get_support(self):
+        """Get support/confidence values for all nodes."""
+        support_dict = {}
+        for node in self.preorder():
+            if hasattr(node, "confidences"):
+                support = node.confidences
+            elif hasattr(node, "confidence"):
+                support = node.confidence
+            else:
+                support = None
+            support_dict[node] = support
+        return support_dict

iplotx/ingest/providers/tree/cogent3.py

@@ -39,3 +39,10 @@ class Cogent3DataProvider(TreeDataProvider):
         from cogent3.core.tree import PhyloNode
 
         return PhyloNode
+
+    def get_support(self):
+        """Get support values for all nodes."""
+        support_dict = {}
+        for node in self.preorder():
+            support_dict[node] = node.params.get("support", None)
+        return support_dict

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,70 @@ 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,
         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 +305,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,8 +327,26 @@ 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:
@@ -278,11 +370,18 @@ 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)):

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,65 @@ 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
+        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)
@@ -189,6 +244,7 @@ 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
@@ -231,7 +287,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 +315,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

@@ -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)