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

iplotx/edge/leaf.py

@@ -0,0 +1,117 @@
+"""
+Module containing leaf edges, i.e. special edges of tree visualisations
+that connect leaf vertices to the deepest leaf (typically for labeling).
+"""
+
+from typing import (
+    Sequence,
+    Optional,
+    Any,
+)
+import numpy as np
+import pandas as pd
+import matplotlib as mpl
+
+from ..utils.matplotlib import (
+    _forwarder,
+)
+from ..vertex import VertexCollection
+from iplotx.edge import EdgeCollection
+
+
+@_forwarder(
+    (
+        "set_clip_path",
+        "set_clip_box",
+        "set_snap",
+        "set_sketch_params",
+        "set_animated",
+        "set_picker",
+    )
+)
+class LeafEdgeCollection(EdgeCollection):
+    """Artist for leaf edges in tree visualisations."""
+
+    def __init__(
+        self,
+        patches: Sequence[mpl.patches.Patch],
+        vertex_leaf_ids: Sequence[tuple],
+        vertex_collection: VertexCollection,
+        leaf_collection: VertexCollection,
+        *args,
+        transform: mpl.transforms.Transform = mpl.transforms.IdentityTransform(),
+        arrow_transform: mpl.transforms.Transform = mpl.transforms.IdentityTransform(),
+        directed: bool = False,
+        style: Optional[dict[str, Any]] = None,
+        **kwargs,
+    ) -> None:
+        """Initialise a LeafEdgeCollection.
+
+        Parameters:
+            patches: A sequence (usually, list) of matplotlib `Patch`es describing the edges.
+            vertex_ids: A sequence of pairs `(v1, v2)`, each defining the ids of vertices at the
+                end of an edge.
+            vertex_collection: The VertexCollection instance containing the Artist for the
+                vertices. This is needed to compute vertex borders and adjust edges accordingly.
+            transform: The matplotlib transform for the edges, usually transData.
+            arrow_transform: The matplotlib transform for the arrow patches. This is not the
+                *offset_transform* of arrows, which is set equal to the edge transform (previous
+                parameter). Instead, it specifies how arrow size scales, similar to vertex size.
+                This is usually the identity transform.
+            directed: Whether the graph is directed (in which case arrows are drawn, possibly
+                with zero size or opacity to obtain an "arrowless" effect).
+            style: The edge style (subdictionary: "edge") to use at creation.
+        """
+        self._leaf_collection = leaf_collection
+        super().__init__(
+            patches=patches,
+            vertex_ids=vertex_leaf_ids,
+            vertex_collection=vertex_collection,
+            *args,
+            transform=transform,
+            arrow_transform=arrow_transform,
+            directed=directed,
+            style=style,
+            **kwargs,
+        )
+
+    def _get_adjacent_vertices_info(self):
+        lindex = self._leaf_collection.get_index()
+        lindex = pd.Series(
+            np.arange(len(lindex)),
+            index=lindex,
+        )
+        vindex = self._vertex_collection.get_index()
+        vindex = pd.Series(
+            np.arange(len(vindex)),
+            index=vindex,
+        ).loc[lindex.index]
+
+        voffsets = []
+        vpaths = []
+        vsizes = []
+        for vid in self._vertex_ids:
+            # NOTE: these are in the original layout coordinate system
+            # not cartesianised yet.
+            offset1 = self._vertex_collection.get_layout().values[vindex[vid]]
+            offset2 = self._leaf_collection.get_layout().values[lindex[vid]]
+            voffsets.append((offset1, offset2))
+
+            path1 = self._vertex_collection.get_paths()[vindex[vid]]
+            path2 = self._leaf_collection.get_paths()[lindex[vid]]
+            vpaths.append((path1, path2))
+
+            # NOTE: This needs to be computed here because the
+            # VertexCollection._transforms are reset each draw in order to
+            # accomodate for DPI changes on the canvas
+            size1 = self._vertex_collection.get_sizes_dpi()[vindex[vid]]
+            size2 = self._leaf_collection.get_sizes_dpi()[lindex[vid]]
+            vsizes.append((size1, size2))
+
+        return {
+            "ids": [(vid, vid) for vid in self._vertex_ids],
+            "offsets": voffsets,
+            "paths": vpaths,
+            "sizes": vsizes,
+            "loops": False,
+        }

iplotx/edge/ports.py

@@ -2,6 +2,7 @@
 Module for handling edge ports in iplotx.
 """
 
+from collections.abc import Callable
 import numpy as np
 
 sq2 = np.sqrt(2) / 2
@@ -19,8 +20,8 @@ port_dict = {
 
 
 def _get_port_unit_vector(
-    portstring,
-    trans_inv,
+    portstring: str,
+    trans_inv: Callable,
 ):
     """Get the tangent unit vector from a port string."""
     # The only tricky bit is if the port says e.g. north but the y axis is inverted, in which

iplotx/groups.py

@@ -130,14 +130,12 @@ class GroupingArtist(PatchCollection):
         return patches, grouping, coords_hulls
 
     def _compute_paths(self, dpi: float = 72.0) -> None:
-        ppc = self._points_per_curve
         for i, hull in enumerate(self._coords_hulls):
-            self._paths[i].vertices = _compute_group_path_with_vertex_padding(
+            _compute_group_path_with_vertex_padding(
                 hull,
                 self._paths[i].vertices,
                 self.get_transform(),
                 vertexpadding=self.get_vertexpadding_dpi(dpi),
-                points_per_curve=ppc,
             )
 
     def _process(self) -> None:

iplotx/ingest/__init__.py

@@ -32,15 +32,11 @@ provider_protocols = {
 }
 
 # Internally supported data providers
-data_providers: dict[str, dict[str, Protocol]] = {
-    kind: {} for kind in provider_protocols
-}
+data_providers: dict[str, dict[str, Protocol]] = {kind: {} for kind in provider_protocols}
 for kind in data_providers:
     providers_path = pathlib.Path(__file__).parent.joinpath("providers").joinpath(kind)
     for importer, module_name, _ in pkgutil.iter_modules([providers_path]):
-        module = importlib.import_module(
-            f"iplotx.ingest.providers.{kind}.{module_name}"
-        )
+        module = importlib.import_module(f"iplotx.ingest.providers.{kind}.{module_name}")
         for key, val in module.__dict__.items():
             if key == provider_protocols[kind].__name__:
                 continue
@@ -95,8 +91,7 @@ def ingest_network_data(
             f"Currently installed supported libraries: {sup}."
         )
 
-    result = provider()(
-        network=network,
+    result = provider(network)(
         layout=layout,
         vertex_labels=vertex_labels,
         edge_labels=edge_labels,
@@ -108,7 +103,6 @@ def ingest_network_data(
 def ingest_tree_data(
     tree: TreeType,
     layout: Optional[str] = "horizontal",
-    orientation: Optional[str] = None,
     directed: bool | str = False,
     layout_style: Optional[dict[str, str | int | float]] = None,
     vertex_labels: Optional[Sequence[str] | dict[Hashable, str] | pd.Series] = None,
@@ -125,15 +119,13 @@ def ingest_tree_data(
     else:
         sup = ", ".join(data_providers["tree"].keys())
         raise ValueError(
-            f"Tree library '{tl}' is not installed. "
-            f"Currently installed supported libraries: {sup}."
+            f"Tree library '{tl}' is not installed. Currently installed supported libraries: {sup}."
         )
 
     result = provider(
         tree=tree,
     )(
         layout=layout,
-        orientation=orientation,
         directed=directed,
         layout_style=layout_style,
         vertex_labels=vertex_labels,
@@ -142,22 +134,16 @@ def ingest_tree_data(
     )
     result["tree_library"] = tl
 
-    # TODO: cascading thing here
-
     return result
 
 
 # INTERNAL FUNCTIONS
 def _update_data_providers(kind):
     """Update data provieders dynamically from external packages."""
-    discovered_providers = importlib.metadata.entry_points(
-        group=f"iplotx.{kind}_data_providers"
-    )
+    discovered_providers = importlib.metadata.entry_points(group=f"iplotx.{kind}_data_providers")
     for entry_point in discovered_providers:
         if entry_point.name not in data_providers["network"]:
             try:
                 data_providers[kind][entry_point.name] = entry_point.load()
             except Exception as e:
-                warnings.warn(
-                    f"Failed to load {kind} data provider '{entry_point.name}': {e}"
-                )
+                warnings.warn(f"Failed to load {kind} data provider '{entry_point.name}': {e}")

iplotx/ingest/heuristics.py

@@ -3,7 +3,6 @@ Heuristics module to funnel certain variable inputs (e.g. layouts) into a standa
 """
 
 from typing import (
-    Optional,
     Any,
 )
 from collections.abc import Hashable
@@ -13,42 +12,13 @@ import pandas as pd
 
 from ..layout import compute_tree_layout
 from ..typing import (
-    GraphType,
     GroupingType,
     LayoutType,
 )
 
 
-def number_of_vertices(network: GraphType) -> int:
-    """Get the number of vertices in the network."""
-    from . import network_library
-
-    if network_library(network) == "igraph":
-        return network.vcount()
-    if network_library(network) == "networkx":
-        return network.number_of_nodes()
-    raise TypeError("Unsupported graph type. Supported types are igraph and networkx.")
-
-
-def detect_directedness(
-    network: GraphType,
-) -> bool:
-    """Detect if the network is directed or not."""
-    from . import network_library
-
-    nl = network_library(network)
-
-    if nl == "igraph":
-        return network.is_directed()
-    if nl == "networkx":
-        import networkx as nx
-
-        if isinstance(network, (nx.DiGraph, nx.MultiDiGraph)):
-            return True
-    return False
-
-
-def normalise_layout(layout, network=None):
+# TODO: some of this logic should be moved into individual providers
+def normalise_layout(layout, network=None, nvertices=None):
     """Normalise the layout to a pandas.DataFrame."""
     from . import network_library
 
@@ -58,7 +28,7 @@ def normalise_layout(layout, network=None):
         ig = None
 
     if layout is None:
-        if (network is not None) and (number_of_vertices(network) == 0):
+        if (network is not None) and (nvertices == 0):
             return pd.DataFrame(np.zeros((0, 2)))
         return None
     if (network is not None) and isinstance(layout, str):
@@ -108,9 +78,7 @@ def normalise_tree_layout(
     if isinstance(layout, str):
         layout = compute_tree_layout(layout, **kwargs)
     else:
-        raise NotImplementedError(
-            "Only internally computed tree layout currently accepted."
-        )
+        raise NotImplementedError("Only internally computed tree layout currently accepted.")
 
     if isinstance(layout, dict):
         # Adjust vertex layout

iplotx/ingest/providers/network/igraph.py

@@ -3,16 +3,15 @@ from typing import (
     Sequence,
 )
 from collections.abc import Hashable
+import importlib
 import numpy as np
 import pandas as pd
 
 from ....typing import (
-    GraphType,
     LayoutType,
 )
 from ...heuristics import (
     normalise_layout,
-    detect_directedness,
 )
 from ...typing import (
     NetworkDataProvider,
@@ -26,21 +25,24 @@ from ....utils.internal import (
 class IGraphDataProvider(NetworkDataProvider):
     def __call__(
         self,
-        network: GraphType,
         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 any provider."""
-
-        directed = detect_directedness(network)
+        """Create network data object for iplotx from an igraph 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
-        vertex_df = normalise_layout(layout, network=network)
+        vertex_df = normalise_layout(
+            layout,
+            network=network,
+            nvertices=self.number_of_vertices(),
+        )
         ndim = vertex_df.shape[1]
         vertex_df.columns = _make_layout_columns(ndim)
 
@@ -49,9 +51,7 @@ class IGraphDataProvider(NetworkDataProvider):
             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."
-                )
+                raise ValueError("Vertex labels must be the same length as the number of vertices.")
             else:
                 vertex_df["label"] = vertex_labels
 
@@ -70,9 +70,7 @@ class IGraphDataProvider(NetworkDataProvider):
         # Edge labels
         if edge_labels is not None:
             if len(edge_labels) != len(edge_df):
-                raise ValueError(
-                    "Edge labels must be the same length as the number of edges."
-                )
+                raise ValueError("Edge labels must be the same length as the number of edges.")
             edge_df["label"] = edge_labels
 
         network_data = {
@@ -85,14 +83,18 @@ class IGraphDataProvider(NetworkDataProvider):
 
     @staticmethod
     def check_dependencies() -> bool:
-        try:
-            import igraph
-        except ImportError:
-            return False
-        return True
+        return importlib.util.find_spec("igraph") is not None
 
     @staticmethod
     def graph_type():
         import igraph as ig
 
         return ig.Graph
+
+    def is_directed(self):
+        """Whether the network is directed."""
+        return self.network.is_directed()
+
+    def number_of_vertices(self):
+        """The number of vertices/nodes in the network."""
+        return self.network.vcount()

iplotx/ingest/providers/network/networkx.py

@@ -3,16 +3,15 @@ from typing import (
     Sequence,
 )
 from collections.abc import Hashable
+import importlib
 import numpy as np
 import pandas as pd
 
 from ....typing import (
-    GraphType,
     LayoutType,
 )
 from ...heuristics import (
     normalise_layout,
-    detect_directedness,
 )
 from ...typing import (
     NetworkDataProvider,
@@ -26,16 +25,17 @@ from ....utils.internal import (
 class NetworkXDataProvider(NetworkDataProvider):
     def __call__(
         self,
-        network: GraphType,
         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 any provider."""
+        """Create network data object for iplotx from a networkx object."""
 
         import networkx as nx
 
-        directed = detect_directedness(network)
+        network = self.network
+
+        directed = self.is_directed()
 
         # Recast vertex_labels=False as vertex_labels=None
         if np.isscalar(vertex_labels) and (not vertex_labels):
@@ -45,6 +45,7 @@ class NetworkXDataProvider(NetworkDataProvider):
         vertex_df = normalise_layout(
             layout,
             network=network,
+            nvertices=self.number_of_vertices(),
         ).loc[pd.Index(network.nodes)]
         ndim = vertex_df.shape[1]
         vertex_df.columns = _make_layout_columns(ndim)
@@ -63,21 +64,13 @@ class NetworkXDataProvider(NetworkDataProvider):
             if "label" in vertex_df:
                 del vertex_df["label"]
         else:
-            if (
-                np.isscalar(vertex_labels)
-                and (not vertex_labels)
-                and ("label" in vertex_df)
-            ):
+            if np.isscalar(vertex_labels) and (not vertex_labels) and ("label" in vertex_df):
                 del vertex_df["label"]
             elif vertex_labels is True:
                 if "label" not in vertex_df:
                     vertex_df["label"] = vertex_df.index
-            elif (not np.isscalar(vertex_labels)) and (
-                len(vertex_labels) != len(vertex_df)
-            ):
-                raise ValueError(
-                    "Vertex labels must be the same length as the number of vertices."
-                )
+            elif (not np.isscalar(vertex_labels)) and (len(vertex_labels) != len(vertex_df)):
+                raise ValueError("Vertex labels must be the same length as the number of vertices.")
             elif isinstance(vertex_labels, nx.classes.reportviews.NodeDataView):
                 vertex_df["label"] = pd.Series(dict(vertex_labels))
             else:
@@ -107,9 +100,7 @@ class NetworkXDataProvider(NetworkDataProvider):
                     edge_df["label"] = [str(i) for i in edge_df.index]
             else:
                 if len(edge_labels) != len(edge_df):
-                    raise ValueError(
-                        "Edge labels must be the same length as the number of edges."
-                    )
+                    raise ValueError("Edge labels must be the same length as the number of edges.")
                 edge_df["label"] = edge_labels
 
         network_data = {
@@ -122,14 +113,19 @@ class NetworkXDataProvider(NetworkDataProvider):
 
     @staticmethod
     def check_dependencies() -> bool:
-        try:
-            import networkx
-        except ImportError:
-            return False
-        return True
+        return importlib.util.find_spec("networkx") is not None
 
     @staticmethod
     def graph_type():
         from networkx import Graph
 
         return Graph
+
+    def is_directed(self):
+        import networkx as nx
+
+        return isinstance(self.network, (nx.DiGraph, nx.MultiDiGraph))
+
+    def number_of_vertices(self):
+        """The number of vertices/nodes in the network."""
+        return self.network.number_of_nodes()

iplotx/ingest/providers/network/simple.py

@@ -0,0 +1,114 @@
+from typing import (
+    Optional,
+    Sequence,
+)
+from collections.abc import Hashable
+import numpy as np
+import pandas as pd
+
+from ....typing import (
+    LayoutType,
+)
+from ...typing import (
+    NetworkDataProvider,
+    NetworkData,
+)
+from ....utils.internal import (
+    _make_layout_columns,
+)
+
+
+class SimpleNetworkDataProvider(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

@@ -3,6 +3,7 @@ from typing import (
     Optional,
     Sequence,
 )
+import importlib
 from functools import partialmethod
 
 from ...typing import (
@@ -34,14 +35,23 @@ class BiopythonDataProvider(TreeDataProvider):
 
     @staticmethod
     def check_dependencies() -> bool:
-        try:
-            from Bio import Phylo
-        except ImportError:
-            return False
-        return True
+        return importlib.util.find_spec("Bio") is not None
 
     @staticmethod
     def tree_type():
         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

@@ -3,6 +3,7 @@ from typing import (
     Optional,
     Sequence,
 )
+import importlib
 from ...typing import (
     TreeDataProvider,
 )
@@ -28,14 +29,17 @@ class Cogent3DataProvider(TreeDataProvider):
 
     @staticmethod
     def check_dependencies() -> bool:
-        try:
-            import cogent3
-        except ImportError:
-            return False
-        return True
+        return importlib.util.find_spec("cogent3") is not None
 
     @staticmethod
     def tree_type():
         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