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

iplotx/cascades.py

@@ -2,6 +2,7 @@ from typing import (
     Any,
     Optional,
 )
+import warnings
 import numpy as np
 import pandas as pd
 
@@ -38,7 +39,7 @@ class CascadeCollection(mpl.collections.PatchCollection):
 
         # NOTE: there is a weird bug in pandas when using generic Hashable-s
         # with .loc. Seems like doing .T[...] works for individual index
-        # elements only though
+        # elements only though (i.e. using __getitem__ a la dict)
         def get_node_coords(node):
             return layout.T[node].values
 
@@ -54,9 +55,19 @@ class CascadeCollection(mpl.collections.PatchCollection):
         # These patches need at least a facecolor (usually) or an edgecolor
         # so it's safe to make a list from these
         nodes_unordered = set()
-        for prop in ("facecolor", "edgecolor"):
+        for prop in ("facecolor", "edgecolor", "linewidth", "linestyle"):
             if prop in style:
-                nodes_unordered |= set(style[prop].keys())
+                value = style[prop]
+                if isinstance(value, dict):
+                    nodes_unordered |= set(value.keys())
+
+        if len(nodes_unordered) == 0:
+            warnings.warn(
+                "No nodes found in the style for the cascading patches. "
+                "Please provide a style with at least one dict-like "
+                "specification among the following properties: 'facecolor', "
+                "'edgecolor', 'color', 'linewidth', or 'linestyle'.",
+            )
 
         # Draw the patches from the closest to the root (earlier drawing)
         # to the closer to the leaves (later drawing).
@@ -70,32 +81,15 @@ class CascadeCollection(mpl.collections.PatchCollection):
                 f"Cascading patches not implemented for layout: {layout_name}.",
             )
 
-        nleaves = sum(1 for leaf in provider(tree).get_leaves())
-        extend_mode = style.get("extend", False)
-        if extend_mode and (extend_mode != "leaf_labels"):
-            if layout_name == "horizontal":
-                if orientation == "right":
-                    maxdepth = layout.values[:, 0].max()
-                else:
-                    maxdepth = layout.values[:, 0].min()
-            elif layout_name == "vertical":
-                if orientation == "descending":
-                    maxdepth = layout.values[:, 1].min()
-                else:
-                    maxdepth = layout.values[:, 1].max()
-            elif layout_name == "radial":
-                # layout values are: r, theta
-                maxdepth = layout.values[:, 0].max()
         self._maxdepth = maxdepth
 
         cascading_patches = []
+        nleaves = sum(1 for leaf in provider(tree).get_leaves())
         for node in drawing_order:
             stylei = rotate_style(style, key=node)
             stylei.pop("extend", None)
             # Default alpha is 0.5 for simple colors
-            if isinstance(stylei.get("facecolor", None), str) and (
-                "alpha" not in stylei
-            ):
+            if isinstance(stylei.get("facecolor", None), str) and ("alpha" not in stylei):
                 stylei["alpha"] = 0.5
 
             provider_node = provider(node)
@@ -137,9 +131,7 @@ class CascadeCollection(mpl.collections.PatchCollection):
                 rmax = maxdepth if extend else leaves_coords[:, 0].max()
                 thetamin = leaves_coords[:, 1].min() - 0.5 * dtheta
                 thetamax = leaves_coords[:, 1].max() + 0.5 * dtheta
-                thetas = np.linspace(
-                    thetamin, thetamax, max(30, (thetamax - thetamin) // 3)
-                )
+                thetas = np.linspace(thetamin, thetamax, max(30, (thetamax - thetamin) // 3))
                 xs = list(rmin * np.cos(thetas)) + list(rmax * np.cos(thetas[::-1]))
                 ys = list(rmin * np.sin(thetas)) + list(rmax * np.sin(thetas[::-1]))
                 points = list(zip(xs, ys))
@@ -200,9 +192,8 @@ class CascadeCollection(mpl.collections.PatchCollection):
             for path in self.get_paths():
                 # Old radii
                 r2old = np.linalg.norm(path.vertices[-2])
-                path.vertices[(len(path.vertices) - 1) // 2 :] *= (
-                    self.get_maxdepth() / r2old
-                )
+                # Update the outer part of the wedge patch
+                path.vertices[(len(path.vertices) - 1) // 2 :] *= self.get_maxdepth() / r2old
             return
 
         if (layout_name, orientation) == ("horizontal", "right"):

iplotx/edge/__init__.py

@@ -121,8 +121,47 @@ class EdgeCollection(mpl.collections.PatchCollection):
                 transform=transform,
             )
 
+        if "split" in self._style:
+            self._add_subedges(
+                len(patches),
+                self._style["split"],
+            )
+
+    def _add_subedges(
+        self,
+        nedges,
+        style,
+    ):
+        """Add subedges to shadow the current edges."""
+        segments = [np.zeros((2, 2)) for i in range(nedges)]
+        kwargs = {
+            "linewidths": [],
+            "edgecolors": [],
+            "linestyles": [],
+        }
+        for i in range(nedges):
+            vids = self._vertex_ids[i]
+            stylei = rotate_style(style, index=i, key=vids, key2=vids[-1])
+            for key, values in kwargs.items():
+                # iplotx uses singular style properties
+                key = key.rstrip("s")
+                # "color" has higher priority than "edgecolor"
+                if (key == "edgecolor") and ("color" in stylei):
+                    val = stylei["color"]
+                else:
+                    val = stylei.get(key.rstrip("s"), getattr(self, f"get_{key}")()[i])
+                values.append(val)
+
+        self._subedges = mpl.collections.LineCollection(
+            segments,
+            transform=self.get_transform(),
+            **kwargs,
+        )
+
     def get_children(self) -> tuple:
         children = []
+        if hasattr(self, "_subedges"):
+            children.append(self._subedges)
         if hasattr(self, "_arrows"):
             children.append(self._arrows)
         if hasattr(self, "_label_collection"):
@@ -209,7 +248,7 @@ class EdgeCollection(mpl.collections.PatchCollection):
         index = pd.Series(
             np.arange(len(index)),
             index=index,
-        )
+        ).to_dict()
 
         voffsets = []
         vpaths = []
@@ -298,10 +337,20 @@ class EdgeCollection(mpl.collections.PatchCollection):
                 tension = 0
                 ports = None
 
+            # False is a synonym for "none"
             waypoints = edge_stylei.get("waypoints", "none")
+            if waypoints is False or waypoints is np.False_:
+                waypoints = "none"
+            elif waypoints is True or waypoints is np.True_:
+                raise ValueError(
+                    "Could not determine automatically type of edge waypoints.",
+                )
             if waypoints != "none":
                 ports = edge_stylei.get("ports", (None, None))
 
+            if not isinstance(waypoints, str):
+                __import__("ipdb").set_trace()
+
             # Compute actual edge path
             path, angles = _compute_edge_path(
                 vcoord_data,
@@ -331,6 +380,17 @@ class EdgeCollection(mpl.collections.PatchCollection):
             if (offset != 0).any():
                 path.vertices[:] = trans_inv(trans(path.vertices) + offset)
 
+            # If splitting is active, split the path here, shedding off the last straight
+            # segment but only if waypoints were used
+            if hasattr(self, "_subedges") and waypoints != "none":
+                # NOTE: we are already in the middle of a redraw, so we can happily avoid
+                # causing stale of the subedges. They are already scheduled to be redrawn
+                # at the end of this function.
+                self._subedges._paths[i].vertices[:] = path.vertices[-2:].copy()
+                # NOTE: instead of shortening the path, we just make the last bit invisible
+                # that makes it easier on memory management etc.
+                path.vertices[-1] = path.vertices[-2]
+
             # Collect angles for this vertex, to be used for loops plotting below
             if vinfo.get("loops", True):
                 if v1 in loop_vertex_dict:
@@ -399,6 +459,9 @@ class EdgeCollection(mpl.collections.PatchCollection):
                         idx += 1
 
         self._paths = paths
+        # FIXME:??
+        # if hasattr(self, "_subedges"):
+        #    self._subedges.stale = True
 
     def _update_labels(self):
         if self._labels is None:
@@ -463,13 +526,13 @@ class EdgeCollection(mpl.collections.PatchCollection):
         if not self.get_visible():
             return
 
+        # This includes the subedges if present
         self._update_paths()
         # This sets the arrow offsets
         self._update_children()
 
         super().draw(renderer)
         for child in self.get_children():
-            # This sets the arrow sizes with dpi scaling
             child.draw(renderer)
 
     def get_ports(self) -> Optional[LeafProperty[Pair[Optional[str]]]]:
@@ -489,7 +552,8 @@ class EdgeCollection(mpl.collections.PatchCollection):
                 edge end.
         """
         if ports is None:
-            del self._style["ports"]
+            if "ports" in self._style:
+                del self._style["ports"]
         else:
             self._style["ports"] = ports
         self.stale = True
@@ -523,7 +587,8 @@ class EdgeCollection(mpl.collections.PatchCollection):
 
         """
         if tension is None:
-            del self._style["tension"]
+            if "tension" in self._style:
+                del self._style["tension"]
         else:
             self._style["tension"] = tension
         self.stale = True
@@ -583,7 +648,8 @@ class EdgeCollection(mpl.collections.PatchCollection):
             looptension: The tension to use for loops. If None, the default is 2.5.
         """
         if looptension is None:
-            del self._style["looptension"]
+            if "looptension" in self._style:
+                del self._style["looptension"]
         else:
             self._style["looptension"] = looptension
         self.stale = True
@@ -603,7 +669,8 @@ class EdgeCollection(mpl.collections.PatchCollection):
             offset: The offset in points for parallel straight edges. If None, the default is 3.
         """
         if offset is None:
-            del self._style["offset"]
+            if "offset" in self._style:
+                del self._style["offset"]
         else:
             self._style["offset"] = offset
         self.stale = True
@@ -634,6 +701,7 @@ def make_stub_patch(**kwargs):
         "paralleloffset",
         "cmap",
         "norm",
+        "split",
     ]
     for prop in forbidden_props:
         if prop in kwargs:

iplotx/edge/arrow.py

@@ -2,6 +2,8 @@
 Module for edge arrows in iplotx.
 """
 
+from typing import Never
+
 import numpy as np
 import matplotlib as mpl
 from matplotlib.patches import PathPatch
@@ -124,12 +126,17 @@ class EdgeArrowCollection(mpl.collections.PatchCollection):
 
         return patches, sizes
 
-    def set_array(self, A):
+    def set_array(self, A: np.ndarray) -> Never:
         """Set the array for cmap/norm coloring, but keep the facecolors as set (usually 'none')."""
         raise ValueError("Setting an array for arrows directly is not supported.")
 
-    def set_colors(self, colors):
-        """Set arrow colors (edge and/or face) based on a colormap."""
+    def set_colors(self, colors: np.ndarray) -> None:
+        """Set arrow colors (edge and/or face) based on a colormap.
+
+        Parameters:
+            colors: Color array to apply. This must be an Nx3 or Nx4 vector of RGB or RGBA colors.
+                This function will NOT attempt to convert other color descriptions to RGB/RGBA.
+        """
         # NOTE: facecolors is always an array because we come from patches
         # It can have zero alpha (i.e. if we choose "none", or a hollow marker)
         self.set_edgecolor(colors)

iplotx/edge/geometry.py

@@ -204,9 +204,7 @@ def _compute_edge_path_straight(
     points.append(vs)
 
     # Shorten at end vertex
-    ve = (
-        _get_shorter_edge_coords(vpath_fig[1], vsize_fig[1], theta + pi) + vcoord_fig[1]
-    )
+    ve = _get_shorter_edge_coords(vpath_fig[1], vsize_fig[1], theta + pi) + vcoord_fig[1]
     points.append(ve)
 
     codes = ["MOVETO", "LINETO"]
@@ -230,7 +228,6 @@ def _compute_edge_path_waypoints(
     ports: Pair[Optional[str]] = (None, None),
     **kwargs,
 ):
-
     if waypoints in ("x0y1", "y0x1"):
         assert layout_coordinate_system == "cartesian"
 
@@ -253,8 +250,7 @@ def _compute_edge_path_waypoints(
 
             # Shorten at vertex border
             vshorts[i] = (
-                _get_shorter_edge_coords(vpath_fig[i], vsize_fig[i], thetas[i])
-                + vcoord_fig[i]
+                _get_shorter_edge_coords(vpath_fig[i], vsize_fig[i], thetas[i]) + vcoord_fig[i]
             )
 
         # Shorten waypoints to keep the angles right
@@ -302,10 +298,7 @@ def _compute_edge_path_waypoints(
                 theta = atan2(*(_get_port_unit_vector(ports[i], trans_inv)[::-1]))
 
             # Shorten at vertex border
-            vshort = (
-                _get_shorter_edge_coords(vpath_fig[i], vsize_fig[i], theta)
-                + vcoord_fig[i]
-            )
+            vshort = _get_shorter_edge_coords(vpath_fig[i], vsize_fig[i], theta) + vcoord_fig[i]
             thetas.append(theta)
             vshorts.append(vshort)
 
@@ -324,9 +317,7 @@ def _compute_edge_path_waypoints(
 
         betas = np.linspace(alpha0, alpha1, points_per_curve)
         waypoints = [r0, r1][idx_inner] * np.vstack([np.cos(betas), np.sin(betas)]).T
-        endpoint = [r0, r1][idx_outer] * np.array(
-            [np.cos(alpha_outer), np.sin(alpha_outer)]
-        )
+        endpoint = [r0, r1][idx_outer] * np.array([np.cos(alpha_outer), np.sin(alpha_outer)])
         points = np.array(list(waypoints) + [endpoint])
         points = trans(points)
         codes = ["MOVETO"] + ["LINETO"] * len(waypoints)
@@ -406,10 +397,7 @@ def _compute_edge_path_curved(
     thetas = [None, None]
     for i in range(2):
         thetas[i] = atan2(*((auxs[i] - vcoord_fig[i])[::-1]))
-        vs[i] = (
-            _get_shorter_edge_coords(vpath_fig[i], vsize_fig[i], thetas[i])
-            + vcoord_fig[i]
-        )
+        vs[i] = _get_shorter_edge_coords(vpath_fig[i], vsize_fig[i], thetas[i]) + vcoord_fig[i]
 
     path = {
         "vertices": [

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
@@ -123,8 +119,7 @@ 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(
@@ -145,14 +140,10 @@ def ingest_tree_data(
 # 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
@@ -79,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,11 +3,11 @@ 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 (
@@ -51,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
 
@@ -72,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 = {
@@ -87,11 +83,7 @@ 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():

iplotx/ingest/providers/network/networkx.py

@@ -3,11 +3,11 @@ 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 (
@@ -64,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:
@@ -108,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 = {
@@ -123,11 +113,7 @@ 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():

iplotx/ingest/providers/network/simple.py

@@ -1,19 +1,14 @@
 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,
@@ -23,7 +18,7 @@ from ....utils.internal import (
 )
 
 
-class SimpleDataProvider(NetworkDataProvider):
+class SimpleNetworkDataProvider(NetworkDataProvider):
     def __call__(
         self,
         layout: Optional[LayoutType] = None,
@@ -69,9 +64,7 @@ class SimpleDataProvider(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
 

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,11 +35,7 @@ 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():

iplotx/ingest/providers/tree/cogent3.py

@@ -3,6 +3,7 @@ from typing import (
     Optional,
     Sequence,
 )
+import importlib
 from ...typing import (
     TreeDataProvider,
 )
@@ -28,11 +29,7 @@ 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():

iplotx/ingest/providers/tree/ete4.py

@@ -3,6 +3,7 @@ from typing import (
     Optional,
     Sequence,
 )
+import importlib
 from functools import partialmethod
 
 from ...typing import (
@@ -31,11 +32,7 @@ class Ete4DataProvider(TreeDataProvider):
 
     @staticmethod
     def check_dependencies() -> bool:
-        try:
-            from ete4 import Tree
-        except ImportError:
-            return False
-        return True
+        return importlib.util.find_spec("ete4") is not None
 
     @staticmethod
     def tree_type():