iplotx 0.2.0__py3-none-any.whl → 0.3.0__py3-none-any.whl

iplotx/ingest/heuristics.py

@@ -15,7 +15,6 @@ from ..layout import compute_tree_layout
 from ..typing import (
     GraphType,
     GroupingType,
-    TreeType,
     LayoutType,
 )
 
@@ -91,7 +90,6 @@ def normalise_layout(layout, network=None):
 
 def normalise_tree_layout(
     layout: str | Any,
-    tree: Optional[TreeType] = None,
     **kwargs,
 ) -> pd.DataFrame:
     """Normalise tree layout from a variety of inputs.
@@ -108,7 +106,7 @@ def normalise_tree_layout(
         the layout internally. This might change in the future.
     """
     if isinstance(layout, str):
-        layout = compute_tree_layout(tree, layout, **kwargs)
+        layout = compute_tree_layout(layout, **kwargs)
     else:
         raise NotImplementedError(
             "Only internally computed tree layout currently accepted."

iplotx/ingest/providers/network/igraph.py

@@ -83,14 +83,16 @@ class IGraphDataProvider(NetworkDataProvider):
         }
         return network_data
 
-    def check_dependencies(self) -> bool:
+    @staticmethod
+    def check_dependencies() -> bool:
         try:
             import igraph
         except ImportError:
             return False
         return True
 
-    def graph_type(self):
+    @staticmethod
+    def graph_type():
         import igraph as ig
 
         return ig.Graph

iplotx/ingest/providers/network/networkx.py

@@ -120,14 +120,16 @@ class NetworkXDataProvider(NetworkDataProvider):
         }
         return network_data
 
-    def check_dependencies(self) -> bool:
+    @staticmethod
+    def check_dependencies() -> bool:
         try:
             import networkx
         except ImportError:
             return False
         return True
 
-    def graph_type(self):
+    @staticmethod
+    def graph_type():
         from networkx import Graph
 
         return Graph

iplotx/ingest/providers/tree/biopython.py

@@ -1,105 +1,47 @@
 from typing import (
+    Any,
     Optional,
     Sequence,
 )
-from collections.abc import Hashable
-from operator import attrgetter
-import numpy as np
-import pandas as pd
+from functools import partialmethod
 
-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."""
+    def is_rooted(self) -> bool:
+        return self.tree.rooted
 
-        tree_data = {
-            "root": tree.root,
-            "leaves": tree.get_terminals(),
-            "rooted": tree.rooted,
-            "directed": directed,
-            "ndim": 2,
-            "layout_name": layout,
-        }
+    def _traverse(self, order: str) -> Any:
+        """Traverse the tree."""
+        return self.tree.find_clades(order=order)
 
-        # 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"
+    preorder = partialmethod(_traverse, order="preorder")
+    postorder = partialmethod(_traverse, order="postorder")
 
-        # 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
+    def get_leaves(self) -> Sequence[Any]:
+        return self.tree.get_terminals()
 
-        # 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)
+    @staticmethod
+    def get_children(node: Any) -> Sequence[Any]:
+        return node.clades
 
-        return tree_data
+    @staticmethod
+    def get_branch_length(node: Any) -> Optional[float]:
+        return node.branch_length
 
-    def check_dependencies(self) -> bool:
+    @staticmethod
+    def check_dependencies() -> bool:
         try:
             from Bio import Phylo
         except ImportError:
             return False
         return True
 
-    def tree_type(self):
+    @staticmethod
+    def tree_type():
         from Bio import Phylo
 
         return Phylo.BaseTree.Tree

iplotx/ingest/providers/tree/cogent3.py

@@ -1,112 +1,41 @@
 from typing import (
+    Any,
     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,
-        }
+    def preorder(self) -> Sequence[Any]:
+        return self.tree.preorder()
 
-        # 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"
+    def postorder(self) -> Sequence[Any]:
+        return self.tree.postorder()
 
-        # 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
+    def get_leaves(self) -> Sequence[Any]:
+        return self.tree.tips()
 
-        # 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)
+    @staticmethod
+    def get_children(node: Any) -> Sequence[Any]:
+        return node.children
 
-        return tree_data
+    @staticmethod
+    def get_branch_length(node: Any) -> Optional[float]:
+        return node.length
 
-    def check_dependencies(self) -> bool:
+    @staticmethod
+    def check_dependencies() -> bool:
         try:
             import cogent3
         except ImportError:
             return False
         return True
 
-    def tree_type(self):
+    @staticmethod
+    def tree_type():
         from cogent3.core.tree import PhyloNode
 
         return PhyloNode

iplotx/ingest/providers/tree/ete4.py

@@ -1,112 +1,44 @@
 from typing import (
+    Any,
     Optional,
     Sequence,
 )
-from collections.abc import Hashable
-from operator import attrgetter
-import numpy as np
-import pandas as pd
+from functools import partialmethod
 
-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,
-        }
+    def _traverse(self, order: str) -> Any:
+        """Traverse the tree."""
+        return self.tree.traverse(order)
 
-        # 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"
+    preorder = partialmethod(_traverse, order="preorder")
+    postorder = partialmethod(_traverse, order="postorder")
 
-        # 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
+    def get_leaves(self) -> Sequence[Any]:
+        return self.tree.leaves()
 
-        # 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)
+    @staticmethod
+    def get_children(node: Any) -> Sequence[Any]:
+        return node.children
 
-        return tree_data
+    @staticmethod
+    def get_branch_length(node: Any) -> Optional[float]:
+        return node.dist
 
-    def check_dependencies(self) -> bool:
+    @staticmethod
+    def check_dependencies() -> bool:
         try:
             from ete4 import Tree
         except ImportError:
             return False
         return True
 
-    def tree_type(self):
+    @staticmethod
+    def tree_type():
         from ete4 import Tree
 
         return Tree

iplotx/ingest/providers/tree/skbio.py

@@ -1,112 +1,41 @@
 from typing import (
+    Any,
     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,
-        }
+    def preorder(self) -> Sequence[Any]:
+        return self.tree.preorder()
 
-        # 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"
+    def postorder(self) -> Sequence[Any]:
+        return self.tree.postorder()
 
-        # 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
+    def get_leaves(self) -> Sequence[Any]:
+        return self.tree.tips()
 
-        # 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)
+    @staticmethod
+    def get_children(node: Any) -> Sequence[Any]:
+        return node.children
 
-        return tree_data
+    @staticmethod
+    def get_branch_length(node: Any) -> Optional[float]:
+        return node.length
 
-    def check_dependencies(self) -> bool:
+    @staticmethod
+    def check_dependencies() -> bool:
         try:
             from skbio import TreeNode
         except ImportError:
             return False
         return True
 
-    def tree_type(self):
+    @staticmethod
+    def tree_type():
         from skbio import TreeNode
 
         return TreeNode