iplotx 0.1.0__py3-none-any.whl → 0.2.1__py3-none-any.whl

iplotx/ingest/providers/network/igraph.py

@@ -0,0 +1,96 @@
+from typing import (
+    Optional,
+    Sequence,
+)
+from collections.abc import Hashable
+import numpy as np
+import pandas as pd
+
+from ....typing import (
+    GraphType,
+    LayoutType,
+)
+from ...heuristics import (
+    normalise_layout,
+    detect_directedness,
+)
+from ...typing import (
+    NetworkDataProvider,
+    NetworkData,
+)
+from ....utils.internal import (
+    _make_layout_columns,
+)
+
+
+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)
+
+        # 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)
+        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.es:
+            row = {"_ipx_source": edge.source, "_ipx_target": edge.target}
+            row.update(edge.attributes())
+            tmp.append(row)
+        if len(tmp):
+            edge_df = pd.DataFrame(tmp)
+        else:
+            edge_df = pd.DataFrame(columns=["_ipx_source", "_ipx_target"])
+        del tmp
+
+        # 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."
+                )
+            edge_df["label"] = edge_labels
+
+        network_data = {
+            "vertex_df": vertex_df,
+            "edge_df": edge_df,
+            "directed": directed,
+            "ndim": ndim,
+        }
+        return network_data
+
+    def check_dependencies(self) -> bool:
+        try:
+            import igraph
+        except ImportError:
+            return False
+        return True
+
+    def graph_type(self):
+        import igraph as ig
+
+        return ig.Graph

iplotx/ingest/providers/network/networkx.py

@@ -0,0 +1,133 @@
+from typing import (
+    Optional,
+    Sequence,
+)
+from collections.abc import Hashable
+import numpy as np
+import pandas as pd
+
+from ....typing import (
+    GraphType,
+    LayoutType,
+)
+from ...heuristics import (
+    normalise_layout,
+    detect_directedness,
+)
+from ...typing import (
+    NetworkDataProvider,
+    NetworkData,
+)
+from ....utils.internal import (
+    _make_layout_columns,
+)
+
+
+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."""
+
+        import networkx as nx
+
+        directed = detect_directedness(network)
+
+        # Recast vertex_labels=False as vertex_labels=None
+        if np.isscalar(vertex_labels) and (not vertex_labels):
+            vertex_labels = None
+
+        # Vertices are indexed by node ID
+        vertex_df = normalise_layout(
+            layout,
+            network=network,
+        ).loc[pd.Index(network.nodes)]
+        ndim = vertex_df.shape[1]
+        vertex_df.columns = _make_layout_columns(ndim)
+
+        # Vertex internal properties
+        tmp = pd.DataFrame(dict(network.nodes.data())).T
+        # Arrays become a single column, which we have already anyway
+        if isinstance(layout, str) and (layout in tmp.columns):
+            del tmp[layout]
+        for col in tmp.columns:
+            vertex_df[col] = tmp[col]
+        del tmp
+
+        # Vertex labels
+        if vertex_labels is None:
+            if "label" in vertex_df:
+                del vertex_df["label"]
+        else:
+            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 isinstance(vertex_labels, nx.classes.reportviews.NodeDataView):
+                vertex_df["label"] = pd.Series(dict(vertex_labels))
+            else:
+                vertex_df["label"] = vertex_labels
+
+        # Edges are a list of tuples, because of multiedges
+        tmp = []
+        for u, v, d in network.edges.data():
+            row = {"_ipx_source": u, "_ipx_target": v}
+            row.update(d)
+            tmp.append(row)
+        if len(tmp):
+            edge_df = pd.DataFrame(tmp)
+        else:
+            edge_df = pd.DataFrame(columns=["_ipx_source", "_ipx_target"])
+        del tmp
+
+        # Edge labels
+        # Even though they could exist in the dataframe, request the to be explicitely mentioned
+        if (edge_labels is None) and ("label" in edge_df):
+            del edge_df["label"]
+        elif edge_labels is not None:
+            if np.isscalar(edge_labels):
+                if (not edge_labels) and ("label" in edge_df):
+                    del edge_df["label"]
+                if (edge_labels is True) and ("label" not in edge_df):
+                    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."
+                    )
+                edge_df["label"] = edge_labels
+
+        network_data = {
+            "vertex_df": vertex_df,
+            "edge_df": edge_df,
+            "directed": directed,
+            "ndim": ndim,
+        }
+        return network_data
+
+    def check_dependencies(self) -> bool:
+        try:
+            import networkx
+        except ImportError:
+            return False
+        return True
+
+    def graph_type(self):
+        from networkx import Graph
+
+        return Graph

iplotx/ingest/providers/tree/biopython.py

@@ -0,0 +1,105 @@
+from typing import (
+    Optional,
+    Sequence,
+)
+from collections.abc import Hashable
+from operator import attrgetter
+import numpy as np
+import pandas as pd
+
+from ....typing import (
+    TreeType,
+    LayoutType,
+)
+from ...typing import (
+    TreeDataProvider,
+    TreeData,
+)
+from ...heuristics import (
+    normalise_tree_layout,
+)
+
+
+class BiopythonDataProvider(TreeDataProvider):
+    def __call__(
+        self,
+        tree: TreeType,
+        layout: str | LayoutType,
+        orientation: str = "horizontal",
+        directed: bool | str = False,
+        vertex_labels: Optional[
+            Sequence[str] | dict[Hashable, str] | pd.Series | bool
+        ] = None,
+        edge_labels: Optional[Sequence[str] | dict] = None,
+    ) -> TreeData:
+        """Create tree data object for iplotx from BioPython.Phylo.Tree classes."""
+
+        tree_data = {
+            "root": tree.root,
+            "leaves": tree.get_terminals(),
+            "rooted": tree.rooted,
+            "directed": directed,
+            "ndim": 2,
+            "layout_name": layout,
+        }
+
+        # Add vertex_df including layout
+        tree_data["vertex_df"] = normalise_tree_layout(
+            layout,
+            tree=tree,
+            orientation=orientation,
+            root_fun=attrgetter("root"),
+            preorder_fun=lambda tree: tree.find_clades(order="preorder"),
+            postorder_fun=lambda tree: tree.find_clades(order="postorder"),
+            children_fun=attrgetter("clades"),
+            branch_length_fun=attrgetter("branch_length"),
+        )
+        if layout in ("radial",):
+            tree_data["layout_coordinate_system"] = "polar"
+        else:
+            tree_data["layout_coordinate_system"] = "cartesian"
+
+        # Add edge_df
+        edge_data = {"_ipx_source": [], "_ipx_target": []}
+        for node in tree.find_clades(order="preorder"):
+            for child in node.clades:
+                if directed == "parent":
+                    edge_data["_ipx_source"].append(child)
+                    edge_data["_ipx_target"].append(node)
+                else:
+                    edge_data["_ipx_source"].append(node)
+                    edge_data["_ipx_target"].append(child)
+        edge_df = pd.DataFrame(edge_data)
+        tree_data["edge_df"] = edge_df
+
+        # 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["vertices"].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.
+            if isinstance(vertex_labels, pd.Series):
+                vertex_labels = dict(vertex_labels)
+            if isinstance(vertex_labels, dict):
+                for vertex in tree_data["vertex_df"].index:
+                    if vertex not in vertex_labels:
+                        vertex_labels[vertex] = ""
+            tree_data["vertex_df"]["label"] = pd.Series(vertex_labels)
+
+        return tree_data
+
+    def check_dependencies(self) -> bool:
+        try:
+            from Bio import Phylo
+        except ImportError:
+            return False
+        return True
+
+    def tree_type(self):
+        from Bio import Phylo
+
+        return Phylo.BaseTree.Tree

iplotx/ingest/providers/tree/cogent3.py

@@ -0,0 +1,112 @@
+from typing import (
+    Optional,
+    Sequence,
+)
+from collections.abc import Hashable
+from operator import attrgetter
+import numpy as np
+import pandas as pd
+
+from ....typing import (
+    TreeType,
+    LayoutType,
+)
+from ...typing import (
+    TreeDataProvider,
+    TreeData,
+)
+from ...heuristics import (
+    normalise_tree_layout,
+)
+
+
+class Cogent3DataProvider(TreeDataProvider):
+    def __call__(
+        self,
+        tree: TreeType,
+        layout: str | LayoutType,
+        orientation: str = "horizontal",
+        directed: bool | str = False,
+        vertex_labels: Optional[
+            Sequence[str] | dict[Hashable, str] | pd.Series | bool
+        ] = None,
+        edge_labels: Optional[Sequence[str] | dict] = None,
+    ) -> TreeData:
+        """Create tree data object for iplotx from cogent3.core.tree.PhyloNode classes."""
+
+        root_fun = lambda tree: tree.root()
+        preorder_fun = lambda tree: tree.preorder()
+        postorder_fun = lambda tree: tree.postorder()
+        children_fun = attrgetter("children")
+        branch_length_fun = attrgetter("length")
+        leaves_fun = lambda tree: tree.tips()
+
+        tree_data = {
+            "root": root_fun(tree),
+            "leaves": leaves_fun(tree),
+            "rooted": True,
+            "directed": directed,
+            "ndim": 2,
+            "layout_name": layout,
+        }
+
+        # Add vertex_df including layout
+        tree_data["vertex_df"] = normalise_tree_layout(
+            layout,
+            tree=tree,
+            orientation=orientation,
+            root_fun=root_fun,
+            preorder_fun=preorder_fun,
+            postorder_fun=postorder_fun,
+            children_fun=children_fun,
+            branch_length_fun=branch_length_fun,
+        )
+        if layout in ("radial",):
+            tree_data["layout_coordinate_system"] = "polar"
+        else:
+            tree_data["layout_coordinate_system"] = "cartesian"
+
+        # Add edge_df
+        edge_data = {"_ipx_source": [], "_ipx_target": []}
+        for node in preorder_fun(tree):
+            for child in node.children:
+                if directed == "parent":
+                    edge_data["_ipx_source"].append(child)
+                    edge_data["_ipx_target"].append(node)
+                else:
+                    edge_data["_ipx_source"].append(node)
+                    edge_data["_ipx_target"].append(child)
+        edge_df = pd.DataFrame(edge_data)
+        tree_data["edge_df"] = edge_df
+
+        # 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["vertices"].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.
+            if isinstance(vertex_labels, pd.Series):
+                vertex_labels = dict(vertex_labels)
+            if isinstance(vertex_labels, dict):
+                for vertex in tree_data["vertex_df"].index:
+                    if vertex not in vertex_labels:
+                        vertex_labels[vertex] = ""
+            tree_data["vertex_df"]["label"] = pd.Series(vertex_labels)
+
+        return tree_data
+
+    def check_dependencies(self) -> bool:
+        try:
+            import cogent3
+        except ImportError:
+            return False
+        return True
+
+    def tree_type(self):
+        from cogent3.core.tree import PhyloNode
+
+        return PhyloNode

iplotx/ingest/providers/tree/ete4.py

@@ -0,0 +1,112 @@
+from typing import (
+    Optional,
+    Sequence,
+)
+from collections.abc import Hashable
+from operator import attrgetter
+import numpy as np
+import pandas as pd
+
+from ....typing import (
+    TreeType,
+    LayoutType,
+)
+from ...typing import (
+    TreeDataProvider,
+    TreeData,
+)
+from ...heuristics import (
+    normalise_tree_layout,
+)
+
+
+class Ete4DataProvider(TreeDataProvider):
+    def __call__(
+        self,
+        tree: TreeType,
+        layout: str | LayoutType,
+        orientation: str = "horizontal",
+        directed: bool | str = False,
+        vertex_labels: Optional[
+            Sequence[str] | dict[Hashable, str] | pd.Series | bool
+        ] = None,
+        edge_labels: Optional[Sequence[str] | dict] = None,
+    ) -> TreeData:
+        """Create tree data object for iplotx from ete4.core.tre.Tree classes."""
+
+        root_fun = attrgetter("root")
+        preorder_fun = lambda tree: tree.traverse("preorder")
+        postorder_fun = lambda tree: tree.traverse("postorder")
+        children_fun = attrgetter("children")
+        branch_length_fun = lambda node: node.dist if node.dist is not None else 1.0
+        leaves_fun = lambda tree: tree.leaves()
+
+        tree_data = {
+            "root": tree.root,
+            "leaves": leaves_fun(tree),
+            "rooted": True,
+            "directed": directed,
+            "ndim": 2,
+            "layout_name": layout,
+        }
+
+        # Add vertex_df including layout
+        tree_data["vertex_df"] = normalise_tree_layout(
+            layout,
+            tree=tree,
+            orientation=orientation,
+            root_fun=root_fun,
+            preorder_fun=preorder_fun,
+            postorder_fun=postorder_fun,
+            children_fun=children_fun,
+            branch_length_fun=branch_length_fun,
+        )
+        if layout in ("radial",):
+            tree_data["layout_coordinate_system"] = "polar"
+        else:
+            tree_data["layout_coordinate_system"] = "cartesian"
+
+        # Add edge_df
+        edge_data = {"_ipx_source": [], "_ipx_target": []}
+        for node in preorder_fun(tree):
+            for child in children_fun(node):
+                if directed == "parent":
+                    edge_data["_ipx_source"].append(child)
+                    edge_data["_ipx_target"].append(node)
+                else:
+                    edge_data["_ipx_source"].append(node)
+                    edge_data["_ipx_target"].append(child)
+        edge_df = pd.DataFrame(edge_data)
+        tree_data["edge_df"] = edge_df
+
+        # 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["vertices"].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.
+            if isinstance(vertex_labels, pd.Series):
+                vertex_labels = dict(vertex_labels)
+            if isinstance(vertex_labels, dict):
+                for vertex in tree_data["vertex_df"].index:
+                    if vertex not in vertex_labels:
+                        vertex_labels[vertex] = ""
+            tree_data["vertex_df"]["label"] = pd.Series(vertex_labels)
+
+        return tree_data
+
+    def check_dependencies(self) -> bool:
+        try:
+            from ete4 import Tree
+        except ImportError:
+            return False
+        return True
+
+    def tree_type(self):
+        from ete4 import Tree
+
+        return Tree

iplotx/ingest/providers/tree/skbio.py

@@ -0,0 +1,112 @@
+from typing import (
+    Optional,
+    Sequence,
+)
+from collections.abc import Hashable
+from operator import attrgetter
+import numpy as np
+import pandas as pd
+
+from ....typing import (
+    TreeType,
+    LayoutType,
+)
+from ...typing import (
+    TreeDataProvider,
+    TreeData,
+)
+from ...heuristics import (
+    normalise_tree_layout,
+)
+
+
+class SkbioDataProvider(TreeDataProvider):
+    def __call__(
+        self,
+        tree: TreeType,
+        layout: str | LayoutType,
+        orientation: str = "horizontal",
+        directed: bool | str = False,
+        vertex_labels: Optional[
+            Sequence[str] | dict[Hashable, str] | pd.Series | bool
+        ] = None,
+        edge_labels: Optional[Sequence[str] | dict] = None,
+    ) -> TreeData:
+        """Create tree data object for iplotx from skbio.tree.TreeNode classes."""
+
+        root_fun = lambda tree: tree.root()
+        preorder_fun = lambda tree: tree.preorder()
+        postorder_fun = lambda tree: tree.postorder()
+        children_fun = attrgetter("children")
+        branch_length_fun = attrgetter("length")
+        leaves_fun = lambda tree: tree.tips()
+
+        tree_data = {
+            "root": root_fun(tree),
+            "leaves": leaves_fun(tree),
+            "rooted": True,
+            "directed": directed,
+            "ndim": 2,
+            "layout_name": layout,
+        }
+
+        # Add vertex_df including layout
+        tree_data["vertex_df"] = normalise_tree_layout(
+            layout,
+            tree=tree,
+            orientation=orientation,
+            root_fun=root_fun,
+            preorder_fun=preorder_fun,
+            postorder_fun=postorder_fun,
+            children_fun=children_fun,
+            branch_length_fun=branch_length_fun,
+        )
+        if layout in ("radial",):
+            tree_data["layout_coordinate_system"] = "polar"
+        else:
+            tree_data["layout_coordinate_system"] = "cartesian"
+
+        # Add edge_df
+        edge_data = {"_ipx_source": [], "_ipx_target": []}
+        for node in preorder_fun(tree):
+            for child in children_fun(node):
+                if directed == "parent":
+                    edge_data["_ipx_source"].append(child)
+                    edge_data["_ipx_target"].append(node)
+                else:
+                    edge_data["_ipx_source"].append(node)
+                    edge_data["_ipx_target"].append(child)
+        edge_df = pd.DataFrame(edge_data)
+        tree_data["edge_df"] = edge_df
+
+        # 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["vertices"].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.
+            if isinstance(vertex_labels, pd.Series):
+                vertex_labels = dict(vertex_labels)
+            if isinstance(vertex_labels, dict):
+                for vertex in tree_data["vertex_df"].index:
+                    if vertex not in vertex_labels:
+                        vertex_labels[vertex] = ""
+            tree_data["vertex_df"]["label"] = pd.Series(vertex_labels)
+
+        return tree_data
+
+    def check_dependencies(self) -> bool:
+        try:
+            from skbio import TreeNode
+        except ImportError:
+            return False
+        return True
+
+    def tree_type(self):
+        from skbio import TreeNode
+
+        return TreeNode