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

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

@@ -255,13 +255,9 @@ class TreeDataProvider(Protocol):
         layout: str | LayoutType,
         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 | bool
-        ] = 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.
 
@@ -344,17 +340,13 @@ class TreeDataProvider(Protocol):
                     # 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
-            ]
+            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.
@@ -386,8 +378,7 @@ class TreeDataProvider(Protocol):
             # 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/network.py

@@ -104,7 +104,8 @@ class NetworkArtist(mpl.artist.Artist):
         """
         self = cls.from_edgecollection(other._edges)
         self.network = other.network
-        self._ipx_internal_data = other._ipx_internal_data
+        if hasattr(other, "_ipx_internal_data"):
+            self._ipx_internal_data = other._ipx_internal_data
         return self
 
     @classmethod
@@ -200,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
 
@@ -249,9 +248,7 @@ class NetworkArtist(mpl.artist.Artist):
         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 = []

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] = (),

iplotx/style/__init__.py

@@ -1,8 +1,10 @@
 from typing import (
     Any,
+    Iterable,
     Optional,
     Sequence,
 )
+from collections import defaultdict
 from collections.abc import Hashable
 from contextlib import contextmanager
 import numpy as np
@@ -16,53 +18,8 @@ from .leaf_info import (
 )
 
 
-default = {
-    "vertex": {
-        "size": 20,
-        "facecolor": "black",
-        "marker": "o",
-        "label": {
-            "color": "white",
-            "horizontalalignment": "center",
-            "verticalalignment": "center",
-            "hpadding": 18,
-            "vpadding": 12,
-        },
-    },
-    "edge": {
-        "linewidth": 1.5,
-        "linestyle": "-",
-        "color": "black",
-        "curved": False,
-        "tension": 1,
-        "looptension": 4,
-        "loopmaxangle": 60,
-        "paralleloffset": 3,
-        "label": {
-            "horizontalalignment": "center",
-            "verticalalignment": "center",
-            "rotate": False,
-            "bbox": {
-                "boxstyle": "round",
-                "facecolor": "white",
-                "edgecolor": "none",
-            },
-        },
-        "arrow": {
-            "marker": "|>",
-            "width": 8,
-        },
-    },
-    "grouping": {
-        "facecolor": ["grey", "steelblue", "tomato"],
-        "edgecolor": "black",
-        "linewidth": 1.5,
-        "alpha": 0.5,
-        "vertexpadding": 18,
-    },
-}
-
-
+# Prepopulate default style, it's used later as a backbone for everything else
+default = style_library["default"]
 styles = {
     "default": default,
 }
@@ -115,36 +72,33 @@ def get_style(name: str = "", *args) -> dict[str, Any]:
     return style
 
 
-# The following is inspired by matplotlib's style library
-# https://github.com/matplotlib/matplotlib/blob/v3.10.3/lib/matplotlib/style/core.py#L45
-def use(style: Optional[str | dict | Sequence] = None, **kwargs):
-    """Use iplotx style setting for a style specification.
-
-    The style name of 'default' is reserved for reverting back to
-    the default style settings.
+def merge_styles(
+    styles: Sequence[str | dict[str, Any]] | Iterable[str | dict[str, Any]],
+) -> dict[str, Any]:
+    """Merge a sequence of styles into a single one.
 
     Parameters:
-        style: A style specification, currently either a name of an existing style
-            or a dict with specific parts of the style to override. The string
-            "default" resets the style to the default one. If this is a sequence,
-            each style is applied in order.
-        **kwargs: Additional style changes to be applied at the end of any style.
+        styles: Sequence (list, tuple, etc.) of styles, each either the name of an internal
+            style or a dict-like with custom properties.
+    Returns:
+        The composite style as a dict.
     """
     try:
         import networkx as nx
     except ImportError:
         nx = None
 
-    global current
-
     def _sanitize_leaves(style: dict):
         for key, value in style.items():
             if key in style_leaves:
+                # Networkx has a few lazy data structures
+                # TODO: move this code to provider
                 if nx is not None:
                     if isinstance(value, nx.classes.reportviews.NodeView):
                         style[key] = dict(value)
                     elif isinstance(value, nx.classes.reportviews.EdgeViewABC):
                         style[key] = [v for *e, v in value]
+
             elif isinstance(value, dict):
                 _sanitize_leaves(value)
 
@@ -154,37 +108,97 @@ def use(style: Optional[str | dict | Sequence] = None, **kwargs):
                 current[key] = value
                 continue
 
-            # Style leaves are by definition not to be recurred into
-            if isinstance(value, dict) and (key not in style_leaves):
-                _update(value, current[key])
-            elif value is None:
-                del current[key]
+            # Style non-leaves are either recurred into or deleted
+            if key not in style_leaves:
+                if isinstance(value, dict):
+                    _update(value, current[key])
+                elif value is None:
+                    del current[key]
+                else:
+                    raise ValueError(
+                        f"Setting non-leaf style value to a non-dict: {key}, {value}",
+                    )
             else:
-                current[key] = value
+                # Style leaves could be incomplete, ensure a sensible default
+                if value is None:
+                    del current[key]
+                    continue
 
-    old_style = copy_with_deep_values(current)
+                if not isinstance(value, dict):
+                    current[key] = value
+                    continue
 
-    try:
-        if style is None:
-            styles = []
-        elif isinstance(style, (dict, str)):
-            styles = [style]
+                if hasattr(value, "default_factory"):
+                    current[key] = value
+                    continue
+
+                if hasattr(current[key], "default_factory"):
+                    default_value = current[key].default_factory()
+                else:
+                    default_value = current[key]
+                current[key] = defaultdict(
+                    lambda: default_value,
+                    value,
+                )
+
+    merged = {}
+    for style in styles:
+        if isinstance(style, str):
+            style = get_style(style)
         else:
-            styles = list(style)
+            _sanitize_leaves(style)
+            unflatten_style(style)
+        _update(style, merged)
 
-        if kwargs:
-            styles.append(kwargs)
+    return merged
 
-        for style in styles:
-            if style == "default":
-                reset()
-            else:
-                if isinstance(style, str):
-                    current = get_style(style)
-                else:
-                    _sanitize_leaves(style)
-                    unflatten_style(style)
-                    _update(style, current)
+
+# The following is inspired by matplotlib's style library
+# https://github.com/matplotlib/matplotlib/blob/v3.10.3/lib/matplotlib/style/core.py#L45
+def use(
+    style: Optional[
+        str | dict[str, Any] | Sequence[str | dict[str, Any]] | Iterable[str | dict[str, Any]]
+    ] = None,
+    **kwargs,
+):
+    """Use iplotx style setting for a style specification.
+
+    The style name of 'default' is reserved for reverting back to
+    the default style settings.
+
+    Parameters:
+        style: A style specification, currently either a name of an existing style
+            or a dict with specific parts of the style to override. The string
+            "default" resets the style to the default one. If this is a sequence,
+            each style is applied in order.
+        **kwargs: Additional style changes to be applied at the end of any style.
+    """
+    global current
+
+    styles = []
+    if isinstance(style, (dict, str)):
+        styles.append(style)
+    elif style is not None:
+        styles.extend(list(style))
+    if kwargs:
+        styles.append(kwargs)
+
+    # Discard empty styles for speed
+    styles = [style for style in styles if style]
+
+    if len(styles) == 0:
+        return
+
+    # If the first style is a string (internal style), apply it cold. If it's a
+    # dict, apply it hot (on top of the current style(. Any style after the first
+    # is always applied hot - otherwise it would invalidate previous styles.
+    if not isinstance(styles[0], str):
+        # hot insertion on top of current
+        styles.insert(0, current)
+
+    old_style = copy_with_deep_values(current)
+    try:
+        current = merge_styles(styles)
     except:
         current = old_style
         raise
@@ -197,7 +211,12 @@ def reset() -> None:
 
 
 @contextmanager
-def context(style: Optional[str | dict | Sequence] = None, **kwargs):
+def context(
+    style: Optional[
+        str | dict[str, Any] | Sequence[str | dict[str, Any]] | Iterable[str | dict[str, Any]]
+    ] = None,
+    **kwargs,
+):
     """Create a style context for iplotx.
 
     Parameters:
@@ -257,9 +276,7 @@ def unflatten_style(
 
     # top-level adjustments
     if "zorder" in style_flat:
-        style_flat["network_zorder"] = style_flat["grouping_zorder"] = style_flat.pop(
-            "zorder"
-        )
+        style_flat["network_zorder"] = style_flat["grouping_zorder"] = style_flat.pop("zorder")
 
     # Begin recursion
     _inner(style_flat)
@@ -269,6 +286,7 @@ def rotate_style(
     style: dict[str, Any],
     index: Optional[int] = None,
     key: Optional[Hashable] = None,
+    key2: Optional[Hashable] = None,
     props: Optional[Sequence[str]] = None,
 ) -> dict[str, Any]:
     """Rotate leaves of a style for a certain index or key.
@@ -278,6 +296,9 @@ def rotate_style(
         index: The integer to rotate the style leaves into.
         key: For dict-like leaves (e.g. vertex properties specified as a dict-like object over the
             vertices themselves), the key to use for rotation (e.g. the vertex itself).
+        key2: For dict-like leaves, a backup key in case the first key fails. If this is None
+            or also a failure (i.e. KeyError), default to the empty type constructor for the
+            first value of the dict-like style leaf.
         props: The properties to rotate, usually all leaf properties.
 
     Returns:
@@ -290,9 +311,7 @@ def rotate_style(
         {'vertex': {'size': 10}}
     """
     if (index is None) and (key is None):
-        raise ValueError(
-            "At least one of 'index' or 'key' must be provided to rotate_style."
-        )
+        raise ValueError("At least one of 'index' or 'key' must be provided to rotate_style.")
 
     if props is None:
         props = tuple(prop for prop in style_leaves if prop not in nonrotating_leaves)
@@ -304,24 +323,29 @@ def rotate_style(
         if val is None:
             continue
         # Try integer indexing for ordered types
-        if (index is not None) and isinstance(
-            val, (tuple, list, np.ndarray, pd.Index, pd.Series)
-        ):
-            style[prop] = np.asarray(val)[index % len(val)]
+        if (index is not None) and isinstance(val, (tuple, list, np.ndarray, pd.Index, pd.Series)):
+            # NOTE: cannot cast to ndarray because rotation might involve
+            # cross-type lists (e.g. ["none", False])
+            style[prop] = list(val)[index % len(val)]
         # Try key indexing for unordered, dict-like types
         if (
             (key is not None)
             and (not isinstance(val, (str, tuple, list, np.ndarray)))
             and hasattr(val, "__getitem__")
         ):
-            # If only a subset of keys is provided, default the other ones
-            # to the empty type constructor (e.g. 0 for ints, 0.0 for floats,
-            # empty strings).
+            # If only a subset of keys is provided, try the default value a la
+            # defaultdict. If that fails, use an empty constructor
             if key in val:
-                style[prop] = val[key]
+                newval = val[key]
+            elif key2 is not None and (key2 in val):
+                newval = val[key2]
             else:
-                valtype = type(next(iter(val.values())))
-                style[prop] = valtype()
+                try:
+                    newval = val[key]
+                except KeyError:
+                    valtype = type(next(iter(val.values())))
+                    newval = valtype()
+            style[prop] = newval
 
     return style
 
@@ -337,7 +361,8 @@ def add_style(name: str, style: dict[str, Any]) -> None:
         styles[name] = get_style()
 
 
-# Populate style library
+# Populate style library (default is already there)
 for name, style in style_library.items():
-    add_style(name, style)
-    del name, style
+    if name != "default":
+        add_style(name, style)
+        del name, style

iplotx/style/leaf_info.py

@@ -23,6 +23,8 @@ rotating_leaves = (
     "hmargin",
     "vmargin",
     "ports",
+    "width",
+    "height",
 )
 
 # These properties are also terminal style properties, but they cannot be rotated.
@@ -35,6 +37,7 @@ nonrotating_leaves = (
     "extend",
     "deep",
     "angular",
+    "curved",
 )
 
 # Union of all style leaves (rotating and nonrotating)

iplotx/style/library.py

@@ -1,4 +1,49 @@
 style_library = {
+    "default": {
+        "vertex": {
+            "size": 20,
+            "facecolor": "black",
+            "marker": "o",
+            "label": {
+                "color": "white",
+                "horizontalalignment": "center",
+                "verticalalignment": "center",
+                "hpadding": 18,
+                "vpadding": 12,
+            },
+        },
+        "edge": {
+            "linewidth": 1.5,
+            "linestyle": "-",
+            "color": "black",
+            "curved": False,
+            "tension": 1,
+            "looptension": 4,
+            "loopmaxangle": 60,
+            "paralleloffset": 3,
+            "label": {
+                "horizontalalignment": "center",
+                "verticalalignment": "center",
+                "rotate": False,
+                "bbox": {
+                    "boxstyle": "round",
+                    "facecolor": "white",
+                    "edgecolor": "none",
+                },
+            },
+            "arrow": {
+                "marker": "|>",
+                "width": 8,
+            },
+        },
+        "grouping": {
+            "facecolor": ["grey", "steelblue", "tomato"],
+            "edgecolor": "black",
+            "linewidth": 1.5,
+            "alpha": 0.5,
+            "vertexpadding": 18,
+        },
+    },
     # Hollow style for organization charts et similar
     "hollow": {
         "vertex": {
@@ -54,6 +99,55 @@ style_library = {
             "deep": False,
         },
     },
+    # Dashed depth tree branches
+    "dashdepth": {
+        "vertex": {
+            "size": 2,
+            "label": {
+                "color": "black",
+                "size": 10,
+                "verticalalignment": "center",
+                "bbox": {
+                    "facecolor": "none",
+                    "edgecolor": "none",
+                },
+            },
+        },
+        "edge": {
+            "linewidth": 1.5,
+            "split": {
+                "linestyle": ":",
+            },
+        },
+        "leaf": {
+            "deep": False,
+        },
+    },
+    # Dashed depth tree branches
+    "dashwidth": {
+        "vertex": {
+            "size": 2,
+            "label": {
+                "color": "black",
+                "size": 10,
+                "verticalalignment": "center",
+                "bbox": {
+                    "facecolor": "none",
+                    "edgecolor": "none",
+                },
+            },
+        },
+        "edge": {
+            "linewidth": 1.5,
+            "linestyle": ":",
+            "split": {
+                "linestyle": "-",
+            },
+        },
+        "leaf": {
+            "deep": False,
+        },
+    },
     # Greyscale style
     "greyscale": {
         "vertex": {