Use multipartite layout

Author: maltekuehl

CITATION.cff

@@ -8,6 +8,6 @@ authors:
     - family-names: "Puelles"
       given-names: "Victor G."
 title: "pyclustree: Visualizing cluster resolution optimization for biomedical data"
-version: 0.3.1
-date-released: 2024-10-24
+version: 0.4.0
+date-released: 2025-03-28
 url: "https://zenodo.org/records/13987570"

LICENSE

@@ -653,7 +653,7 @@ Also add information on how to contact you by electronic and paper mail.
   If the program does terminal interaction, make it output a short
 notice like this when it starts in an interactive mode:
 
-    pyclustree  Copyright (C) 2024, Malte Kuehl & Malte Hellmig
+    pyclustree  Copyright (C) 2025, Malte Kuehl & Malte Hellmig
     This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
     This is free software, and you are welcome to redistribute it
     under certain conditions; type `show c' for details.

docs/source/conf.py

@@ -13,7 +13,7 @@
 # -- Project information -----------------------------------------------------
 
 project = "pyclustree"
-copyright = "2024, Malte Kuehl"
+copyright = "2025, Malte Kuehl"
 author = "Malte Kuehl"
 
 # -- General configuration ---------------------------------------------------

docs/source/example.ipynb

@@ -1,12 +1,12 @@
 from logging import warning
-from typing import Callable, Optional, Literal, Union
+from typing import Callable, Literal, Optional, Union
 
 import networkx as nx
 import numpy as np
 from anndata import AnnData
-from numpy.typing import ArrayLike, NDArray
 from matplotlib import pyplot as plt
 from matplotlib.colors import Colormap
+from numpy.typing import ArrayLike, NDArray
 
 from pyclustree._utils import calculate_transition_matrix, order_unique_clusters
 
@@ -19,7 +19,7 @@ def clustree(
     node_colormap: Union[list[Colormap], Colormap, str] = "tab20",
     node_color_gene: Optional[str] = None,
     node_color_gene_use_raw: bool = True,
-    node_color_gene_transformer: Optional[callable] = None,
+    node_color_gene_transformer: Optional[Callable] = None,
     node_size_range: tuple[float, float] = (100, 1000),
     edge_width_range: tuple[float, float] = (0.5, 5.0),
     edge_weight_threshold: float = 0.0,
@@ -30,7 +30,10 @@ def clustree(
     show_fraction: bool = False,
     show_cluster_keys: bool = True,
     score_clustering: Optional[
-        Union[Literal["silhouette", "davies_bouldin", "calinski_harabasz"], Callable[[ArrayLike, ArrayLike], float]]
+        Union[
+            Literal["silhouette", "davies_bouldin", "calinski_harabasz"],
+            Callable[[ArrayLike, ArrayLike], float],
+        ]
     ] = None,
     score_basis: Literal["X", "raw", "pca"] = "pca",
     graph_plot_kwargs: Optional[dict] = None,
@@ -132,7 +135,8 @@ def clustree(
 
     transition_matrices = [
         calculate_transition_matrix(
-            df_cluster_assignments[cluster_keys[i]], df_cluster_assignments[cluster_keys[i + 1]]
+            df_cluster_assignments[cluster_keys[i]],
+            df_cluster_assignments[cluster_keys[i + 1]],
         )
         for i in range(len(cluster_keys) - 1)
     ]
@@ -144,17 +148,20 @@ def clustree(
         unique_clusters = order_unique_clusters(unique_clusters, transition_matrices)
 
     # Create the Graph
-    G = nx.DiGraph()
+    G: nx.Graph = nx.DiGraph()
 
     # Add the nodes for each cluster key (unique clusters)
     node_names = []
 
     for i, key in enumerate(cluster_keys):
         level_nodes = [f"{key}_{cluster_name}" for cluster_name in unique_clusters[i]]
         node_names.append(level_nodes)
-        level_nodes = reversed(level_nodes)
+        level_nodes.reverse()
 
-        G.add_nodes_from([node for nodes in node_names for node in level_nodes], layer=len(cluster_keys) - i)
+        G.add_nodes_from(
+            [node for nodes in node_names for node in level_nodes],
+            layer=len(cluster_keys) - i,
+        )
 
     # Add edges between each level and the next level
     for i, transition_matrix in enumerate(transition_matrices):
@@ -258,7 +265,7 @@ def clustree(
         gene_min, gene_max = np.min(gene_cluster_means), np.max(gene_cluster_means)
         norm_gene = plt.Normalize(vmin=gene_min, vmax=gene_max)
 
-        node_colors = [node_colormap(norm_gene(gene_cluster_mean)) for gene_cluster_mean in gene_cluster_means]
+        node_colors = [node_colormap(norm_gene(gene_cluster_mean)) for gene_cluster_mean in gene_cluster_means]  # type: ignore
 
         for i, key in enumerate(cluster_keys):
             index = sum([len(unique_clusters[k]) for k in range(i)])
@@ -271,13 +278,19 @@ def clustree(
         for cluster in unique_clusters[i]:
             node_sizes.append(np.sum(df_cluster_assignments[cluster_keys[i]] == cluster))
 
-    node_sizes = np.clip((np.array(node_sizes) * node_size_range[1]) / np.max(node_sizes), *node_size_range)
+    node_sizes = np.clip(
+        (np.array(node_sizes) * node_size_range[1]) / np.max(node_sizes),
+        *node_size_range,
+    )
 
     # Scale the edge width based on the edge weight
     edge_widths = [G.edges[edge]["weight"] for edge in G.edges]
 
     # Set the maximum edge width to be the maximum and clip the values to be within the range
-    edge_widths = np.clip((np.array(edge_widths) * edge_width_range[1]) / np.max(edge_widths), *edge_width_range)
+    edge_widths = np.clip(
+        (np.array(edge_widths) * edge_width_range[1]) / np.max(edge_widths),
+        *edge_width_range,
+    )
 
     figsize = x_spacing * len(cluster_keys), y_spacing * len(unique_clusters[0])
     fig, ax = plt.subplots(figsize=figsize, dpi=300)
@@ -301,7 +314,7 @@ def clustree(
         "with_labels": True,
         "labels": {node: node.split("_")[-1] for node in G.nodes},
         "pos": node_positions,
-        "node_color": [G.nodes[node]["color"] for node in G.nodes] if node_color_gene is not None else node_colors,
+        "node_color": ([G.nodes[node]["color"] for node in G.nodes] if node_color_gene is not None else node_colors),
         "edge_color": "black",
         "width": edge_widths,
         "font_size": 8,
@@ -351,15 +364,25 @@ def clustree(
             sm = plt.cm.ScalarMappable(cmap=node_colormap, norm=norm)
         sm.set_array([])
         label = f"{node_color_gene} expression" if node_color_gene is not None else "Cluster color"
-        colorbar = fig.colorbar(sm, ax=ax, orientation="vertical", fraction=0.02, pad=0.02, label=label, aspect=10)
+        colorbar = fig.colorbar(
+            sm,
+            ax=ax,
+            orientation="vertical",
+            fraction=0.02,
+            pad=0.02,
+            label=label,
+            aspect=10,
+        )
         colorbar.ax.yaxis.set_label_position("left")
     elif show_colorbar and isinstance(node_colormap, list):
         warning("Colorbars are not supported when providing a list of colormaps. Ignoring the argument.")
 
     if score_clustering is not None or (show_cluster_keys is True and scatter_reference is not None):
         # Position them in equal intervals along the y-axis
         y_positions_levels = np.linspace(
-            ax.get_ylim()[1], ax.get_ylim()[1] - len(cluster_keys) * 1.0, len(cluster_keys)
+            ax.get_ylim()[1],
+            ax.get_ylim()[1] - len(cluster_keys) * 1.0,
+            len(cluster_keys),
         )
 
     # Show the name of the cluster key on the left side of the plot
@@ -368,13 +391,14 @@ def clustree(
 
         if scatter_reference is not None:
             # Use the level colors for the facecolor
+            facecolor: Union[list[str], list[tuple[float, float, float, float]]] = []
             if isinstance(node_colormap, list):
                 warning("Cannot show colored cluster keys when providing a list of colormaps. Showing white keys.")
                 facecolor = ["white"] * len(cluster_keys)
             else:
                 facecolor = [node_colormap(norm(i)) for i in range(len(cluster_keys))]
         else:
-            y_positions_levels = [node_positions[node_names[i][0]][1] for i in range(len(node_names))]
+            y_positions_levels = [node_positions[node_names[i][0]][1] for i in range(len(node_names))]  # type: ignore
             facecolor = ["white"] * len(cluster_keys)
 
         for i, key in enumerate(cluster_keys):
@@ -390,7 +414,11 @@ def clustree(
                 color="black",
                 ha="center",
                 va="center",
-                bbox={"boxstyle": "round", "facecolor": facecolor[i], "edgecolor": "black"},
+                bbox={
+                    "boxstyle": "round",
+                    "facecolor": facecolor[i],
+                    "edgecolor": "black",
+                },
             )
 
     # Set the title of the plot
@@ -433,7 +461,9 @@ def clustree(
                     else:
                         raise ValueError(f"Score '{score_clustering}' not a valid scoring method")
                 elif callable(score_clustering) is True:
-                    score_array[index] = float(score_clustering(basis, adata.obs[cluster_key]))
+                    score_array[index] = float(
+                        score_clustering(basis, adata.obs[cluster_key])  # type: ignore
+                    )
 
         score_name_map = {
             "silhouette": "Silhouette score",
@@ -446,7 +476,7 @@ def clustree(
         ax.text(
             x_max,
             y=ax.get_ylim()[1],
-            s=score_name_map[score_clustering],
+            s=score_name_map[score_clustering],  # type: ignore
             fontsize=12,
             color="black",
             ha="center",
@@ -458,11 +488,15 @@ def clustree(
             ax.text(
                 x_max,
                 y=y_positions_levels[i],
-                s=str(round(score_array[i], 2)),
+                s=str(round(score_array[i], 2)),  # type: ignore
                 fontsize=12,
                 ha="center",
                 va="center",
-                bbox={"boxstyle": "round", "facecolor": facecolor[i], "edgecolor": "black"},
+                bbox={
+                    "boxstyle": "round",
+                    "facecolor": facecolor[i],
+                    "edgecolor": "black",
+                },
             )
 
     return fig

pyclustree/_clustree.py

@@ -5,7 +5,7 @@ requires = [ "flit-core>=3.4,<4" ]
 
 [project]
 name = "pyclustree"
-version = "0.3.2"
+version = "0.4.0"
 description = "Visualize cluster assignments at different resolutions"
 readme = "README.md"
 license = { file = "LICENSE" }
@@ -69,6 +69,7 @@ optional-dependencies.dev = [
   "sphinxcontrib-bibtex>=1",
   "sphinxext-opengraph",
   "twine>=4.0.2",
+  "types-networkx",
 ]
 optional-dependencies.sklearn = [ "scikit-learn" ]
 
@@ -123,7 +124,7 @@ lint.pydocstyle.convention = "google"
 log_format = "%(asctime)s %(levelname)s %(message)s"
 log_date_format = "%Y-%m-%d %H:%M:%S"
 log_level = "WARN"
-log_cli = "true"
+log_cli = true
 testpaths = [ "tests" ]
 xfail_strict = true
 addopts = [

pyproject.toml

@@ -89,4 +89,9 @@ def test_scatter_reference():
     # Testing node_color_gene when node colormap argument is provided
     with pytest.raises(AssertionError):
         cluster_keys = [f"leiden_{str(resolution).replace('.', '_')}" for resolution in [0.2, 1.0]]
-        clustree(adata, cluster_keys, node_colormap=["#FF0000"] * len(cluster_keys), node_color_gene="CD8A")
+        clustree(
+            adata,
+            cluster_keys,
+            node_colormap=["#FF0000"] * len(cluster_keys),
+            node_color_gene="CD8A",
+        )