resolutiontree 0.1.1__tar.gz → 0.2__tar.gz

{resolutiontree-0.1.1 → resolutiontree-0.2}/PKG-INFO

@@ -1,11 +1,10 @@
 Metadata-Version: 2.4
 Name: resolutiontree
-Version: 0.1.1
+Version: 0.2
 Summary: Systematic exploration of clustering resolutions in single-cell analysis
 Author-email: Joe Hou <joseph.houjue@gmail.com>
 License: MIT
 Project-URL: Homepage, https://github.com/joe-jhou2/resolutiontree
-Project-URL: Documentation, https://resolutiontree.readthedocs.io/
 Project-URL: Repository, https://github.com/joe-jhou2/resolutiontree
 Project-URL: Bug Tracker, https://github.com/joe-jhou2/resolutiontree/issues
 Keywords: single-cell,clustering,resolution,scanpy,leiden,visualization
@@ -14,12 +13,25 @@ Classifier: Intended Audience :: Science/Research
 Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
-Requires-Python: >=3.8
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
+Requires-Dist: numpy>=1.26
+Requires-Dist: pandas>=2.1
+Requires-Dist: scipy>=1.11
+Requires-Dist: matplotlib>=3.8
+Requires-Dist: seaborn>=0.13
+Requires-Dist: scanpy>=1.9.8
+Requires-Dist: anndata>=0.10
+Requires-Dist: igraph>=0.11
+Requires-Dist: networkx>=3.2
+Requires-Dist: leidenalg>=0.10
+Requires-Dist: umap-learn>=0.5.5
+Requires-Dist: spatialdata
+Requires-Dist: spatialdata[extra]
 
 # ResolutionTree
 
@@ -56,7 +68,7 @@ ResolutionTree provides:
 ### From GitHub Release (Recommended)
 
 ```bash
-pip install resolutiontree
+pip install resolutiontree==0.2
 ```
 
 ### From Source

{resolutiontree-0.1.1 → resolutiontree-0.2}/README.md

@@ -33,7 +33,7 @@ ResolutionTree provides:
 ### From GitHub Release (Recommended)
 
 ```bash
-pip install resolutiontree
+pip install resolutiontree==0.2
 ```
 
 ### From Source

{resolutiontree-0.1.1 → resolutiontree-0.2}/pyproject.toml

@@ -1,33 +1,60 @@
 [build-system]
-requires = ["setuptools>=45", "wheel"]
+requires = ["setuptools>=68", "wheel"]
 build-backend = "setuptools.build_meta"
 
 [project]
 name = "resolutiontree"
-version = "0.1.1"
+version = "0.2"
 description = "Systematic exploration of clustering resolutions in single-cell analysis"
 readme = "README.md"
-requires-python = ">=3.8"
+requires-python = ">=3.9"
+
 license = {text = "MIT"}
+
 authors = [
     {name = "Joe Hou", email = "joseph.houjue@gmail.com"},
 ]
-keywords = ["single-cell", "clustering", "resolution", "scanpy", "leiden", "visualization"]
+
+keywords = [
+    "single-cell",
+    "clustering",
+    "resolution",
+    "scanpy",
+    "leiden",
+    "visualization"
+]
+
 classifiers = [
     "Development Status :: 4 - Beta",
     "Intended Audience :: Science/Research",
     "Topic :: Scientific/Engineering :: Bio-Informatics",
     "License :: OSI Approved :: MIT License",
+
     "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.8",
     "Programming Language :: Python :: 3.9",
     "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12"
+]
+
+dependencies = [
+    "numpy>=1.26",
+    "pandas>=2.1",
+    "scipy>=1.11",
+    "matplotlib>=3.8",
+    "seaborn>=0.13",
+    "scanpy>=1.9.8",
+    "anndata>=0.10",
+    "igraph>=0.11",
+    "networkx>=3.2",
+    "leidenalg>=0.10",
+    "umap-learn>=0.5.5",
+    "spatialdata",
+    "spatialdata[extra]"
 ]
 
 [project.urls]
 Homepage = "https://github.com/joe-jhou2/resolutiontree"
-Documentation = "https://resolutiontree.readthedocs.io/"
 Repository = "https://github.com/joe-jhou2/resolutiontree"
 "Bug Tracker" = "https://github.com/joe-jhou2/resolutiontree/issues"
 

resolutiontree-0.2/src/resolutiontree/__init__.py

@@ -0,0 +1,14 @@
+"""
+ResolutionTree: Systematic exploration of clustering resolutions in single-cell analysis
+"""
+
+__version__ = "0.2"
+__author__ = "Joe Hou"
+
+from .utils import cluster_resolution_finder
+from .core import cluster_decision_tree
+
+__all__ = [
+    "cluster_resolution_finder",
+    "cluster_decision_tree",
+]

{resolutiontree-0.1.1 → resolutiontree-0.2}/src/resolutiontree/core.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import math
 from typing import TYPE_CHECKING, TypedDict, cast
-
+# import sys
 import igraph as ig
 import matplotlib.colors as mcolors
 import matplotlib.pyplot as plt
@@ -14,6 +14,7 @@ if TYPE_CHECKING:
 import networkx as nx
 import pandas as pd
 from anndata import AnnData
+import spatialdata as sd
 
 
 class OutputSettings(TypedDict):
@@ -112,8 +113,17 @@ class ClusterTreePlotter:
         clustering_settings
             Clustering settings (prefix).
         """
+        if isinstance(adata, sd.SpatialData):
+            if "table" not in adata.tables:
+                raise ValueError("SpatialData must contain 'table'")
+            adata = adata.tables["table"]
+
+        if not isinstance(adata, AnnData):
+            raise TypeError("ClusterTreePlotter requires AnnData")
+        
         self.adata = adata
         self.resolutions = resolutions
+
         self.output_settings = self._merge_with_default(
             output_settings, self.default_output_settings()
         )
@@ -564,6 +574,10 @@ class ClusterTreePlotter:
         data = settings["data"]
         prefix = settings["prefix"]
 
+        # in_jupyter = 'ipykernel' in sys.modules
+        # if in_jupyter:
+        #     print("🔄 Running latest code from editable install")
+
         # Step 1: Compute Cluster Sizes, Node Sizes, and Node Colors
         cluster_sizes = self._compute_cluster_sizes(data, prefix, self.resolutions)
         node_sizes = self._scale_node_sizes(
@@ -579,16 +593,18 @@ class ClusterTreePlotter:
         node_colors = self._assign_node_colors(
             data, prefix, self.resolutions, settings["node_color"], color_schemes
         )
-
-        plt.ioff() # Disable interactive mode
-
         # Step 2: Set up the plot figure and axis
+        plt.close('all')
+        plt.ioff()
+
         self.fig = plt.figure(figsize=settings["figsize"], dpi=settings["dpi"])
         self.ax = self.fig.add_subplot(111)
+
         # Step 3: Compute Edge Weights, Edge Colors
         edges, weights, edge_colors = self._compute_edge_weights_colors(
             self.G, settings["edge_threshold"], settings["edge_color"], node_colors
         )
+
         # Step 4: Draw Nodes and Node Labels
         node_styles = {"colors": node_colors, "sizes": node_sizes}
         node_labels, gene_labels = self._draw_nodes_and_labels(
@@ -610,6 +626,7 @@ class ClusterTreePlotter:
             font_size=int(settings["node_label_fontsize"]),
             font_color="black",
         )
+
         # Step 5: Draw Gene Labels
         gene_label_bottoms = {}
         if settings["show_gene_labels"] and gene_labels:
@@ -622,6 +639,7 @@ class ClusterTreePlotter:
                 offset=settings["gene_label_offset"],
                 fontsize=settings["gene_label_fontsize"],
             )
+
         # Step 6: Build and Draw Edge Labels
         edge_labels = self._build_edge_labels(
             self.G, settings["edge_threshold"], settings["edge_label_threshold"]
@@ -642,6 +660,7 @@ class ClusterTreePlotter:
             edge_labels=edge_labels,
             edge_label_style=edge_label_style,
         )
+
         # Step 7: Draw Level Labels
         self._draw_level_labels(
             resolutions=self.resolutions,
@@ -651,15 +670,17 @@ class ClusterTreePlotter:
             level_label_offset=settings["level_label_offset"],
             level_label_fontsize=settings["level_label_fontsize"],
         )
+
         # Step 8: Final Plot Settings
         self.ax.set_title(settings["title"], fontsize=settings["title_fontsize"])
         self.ax.axis("off")
+
         # Save or show the plot
         if settings["output_path"]:
             plt.savefig(settings["output_path"], bbox_inches="tight")
         if settings["draw"]:
+            self.fig.canvas.draw()
             plt.show()
-            
         plt.ion()
 
     def _get_draw_settings(self) -> dict:
@@ -879,7 +900,7 @@ class ClusterTreePlotter:
                     pos,
                     nodelist=[node],
                     node_size=size,
-                    node_color=color,
+                    node_color=[color],
                     edgecolors="none",
                 )
                 node_labels[node] = str(cluster)
@@ -1237,6 +1258,14 @@ class ClusterTreePlotter:
         Directed graph representing the hierarchical clustering.
 
         """
+        if isinstance(adata, sd.SpatialData):
+            if "table" not in adata.tables:
+                raise ValueError("SpatialData must contain 'table'")
+            adata = adata.tables["table"]
+
+        if not isinstance(adata, AnnData):
+            raise TypeError("Expected AnnData after extraction")
+        
         # Run all validations
         ClusterTreePlotter._validate_parameters(output_settings, node_style, edge_style)
         ClusterTreePlotter._validate_clustering_data(

{resolutiontree-0.1.1 → resolutiontree-0.2}/src/resolutiontree/utils.py

@@ -5,6 +5,7 @@ from collections.abc import Sequence
 from typing import Literal
 from anndata import AnnData
 from scanpy.tools._rank_genes_groups import rank_genes_groups
+import spatialdata as sd
 
 def find_cluster_specific_genes(
     adata: AnnData,
@@ -181,8 +182,61 @@ def find_per_resolution_degs(
     return top_genes_dict
 
 
+""" def _extract_adata(obj):
+    import spatialdata as sd
+    from anndata import AnnData
+
+    if isinstance(obj, AnnData):
+        return obj
+
+    if isinstance(obj, sd.SpatialData):
+        if "table" not in obj.tables:
+            raise ValueError("SpatialData object has no 'table' in .tables")
+        return obj.tables["table"]
+
+    raise TypeError(
+        "Input must be AnnData or SpatialData (with .tables['table'])"
+    )
+ """
+
+
+def extract_adata(obj) -> AnnData:
+    """
+    Accepts either AnnData or SpatialData and returns AnnData.
+    """
+    if isinstance(obj, AnnData):
+        return obj
+
+    if isinstance(obj, sd.SpatialData):
+        if len(obj.tables) == 0:
+            raise ValueError("SpatialData has no tables")
+
+        # default convention: first table is main expression matrix
+        return obj.tables.get("table", next(iter(obj.tables.values())))
+
+    raise TypeError("Input must be AnnData or SpatialData")
+
+def write_results(obj, adata: AnnData, results: dict, prefix: str = None):
+    """
+    Write results back to either AnnData or SpatialData.
+    """
+
+    if isinstance(obj, AnnData):
+        obj.uns.update(results)
+        return obj
+
+    if isinstance(obj, sd.SpatialData):
+        table = obj.tables.get("table", None)
+        if table is None:
+            raise ValueError("SpatialData has no 'table'")
+
+        table.uns.update(results)
+        return obj
+
+    raise TypeError("Unsupported object type")
+
 def cluster_resolution_finder(
-    adata: AnnData,
+    data,
     resolutions: list[float],
     *,
     prefix: str = "leiden_res_",
@@ -255,71 +309,84 @@ def cluster_resolution_finder(
     import io
 
     from scanpy.tools import leiden
+    import warnings
+    from anndata._core.views import ImplicitModificationWarning
+
+    adata = extract_adata(data)
+
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore", category=ImplicitModificationWarning)
 
-    # Suppress prints if pytest is running
-    if "pytest" in sys.modules:
-        sys.stdout = io.StringIO()
+        # Suppress prints if pytest is running
+        if "pytest" in sys.modules:
+            sys.stdout = io.StringIO()
 
-    _validate_cluster_resolution_inputs(adata, resolutions, method, flavor)
+        _validate_cluster_resolution_inputs(adata, resolutions, method, flavor)
 
-    # Run Leiden clustering
-    for resolution in resolutions:
-        res_key = f"{prefix}{resolution}"
+        # Run Leiden clustering
+        for resolution in resolutions:
+            res_key = f"{prefix}{resolution}"
+            try:
+                leiden(
+                    adata,
+                    resolution=resolution,
+                    flavor="igraph",
+                    n_iterations=n_iterations,
+                    key_added=res_key,
+                )
+                if "pytest" not in sys.modules and not hasattr(
+                    sys, "_called_from_test"
+                ):  # Suppress print in tests
+                    print(f"Completed Leiden clustering for resolution {resolution}")
+            except ValueError as e:
+                msg = f"Leiden clustering failed at resolution {resolution} due to invalid value: {e}"
+                raise RuntimeError(msg) from None
+            except TypeError as e:
+                msg = f"Leiden clustering failed at resolution {resolution} due to incorrect type: {e}"
+                raise RuntimeError(msg) from None
+            except RuntimeError as e:
+                msg = f"Leiden clustering failed at resolution {resolution}: {e}"
+                raise RuntimeError(msg) from None
+
+        # Find cluster-specific genes
+        top_genes_dict = find_cluster_specific_genes(
+            adata=adata,
+            resolutions=resolutions,
+            prefix=prefix,
+            method=method,
+            n_top_genes=n_top_genes,
+            min_cells=min_cells,
+            deg_mode=deg_mode,
+            verbose=verbose,
+        )
+
+        # Create DataFrame for clusterDecisionTree
         try:
-            leiden(
-                adata,
-                resolution=resolution,
-                flavor="igraph",
-                n_iterations=n_iterations,
-                key_added=res_key,
+            cluster_data = pd.DataFrame(
+                {f"{prefix}{r}": adata.obs[f"{prefix}{r}"] for r in resolutions}
             )
-            if "pytest" not in sys.modules and not hasattr(
-                sys, "_called_from_test"
-            ):  # Suppress print in tests
-                print(f"Completed Leiden clustering for resolution {resolution}")
+        except KeyError as e:
+            msg = f"Failed to create cluster_data DataFrame: missing column {e}"
+            raise RuntimeError(msg) from None
         except ValueError as e:
-            msg = f"Leiden clustering failed at resolution {resolution} due to invalid value: {e}"
+            msg = f"Failed to create cluster_data DataFrame due to invalid value: {e}"
             raise RuntimeError(msg) from None
         except TypeError as e:
-            msg = f"Leiden clustering failed at resolution {resolution} due to incorrect type: {e}"
+            msg = f"Failed to create cluster_data DataFrame due to incorrect type: {e}"
             raise RuntimeError(msg) from None
-        except RuntimeError as e:
-            msg = f"Leiden clustering failed at resolution {resolution}: {e}"
-            raise RuntimeError(msg) from None
-
-    # Find cluster-specific genes
-    top_genes_dict = find_cluster_specific_genes(
-        adata=adata,
-        resolutions=resolutions,
-        prefix=prefix,
-        method=method,
-        n_top_genes=n_top_genes,
-        min_cells=min_cells,
-        deg_mode=deg_mode,
-        verbose=verbose,
-    )
 
-    # Create DataFrame for clusterDecisionTree
-    try:
-        cluster_data = pd.DataFrame(
-            {f"{prefix}{r}": adata.obs[f"{prefix}{r}"] for r in resolutions}
-        )
-    except KeyError as e:
-        msg = f"Failed to create cluster_data DataFrame: missing column {e}"
-        raise RuntimeError(msg) from None
-    except ValueError as e:
-        msg = f"Failed to create cluster_data DataFrame due to invalid value: {e}"
-        raise RuntimeError(msg) from None
-    except TypeError as e:
-        msg = f"Failed to create cluster_data DataFrame due to incorrect type: {e}"
-        raise RuntimeError(msg) from None
-
-    # Store the results in adata.uns
-    adata.uns["cluster_resolution_top_genes"] = top_genes_dict
-    # adata.uns["cluster_resolution_top_genes"] = _convert_tuple_keys(top_genes_dict)
-    adata.uns["cluster_resolution_cluster_data"] = cluster_data
-
-    # return adata
+        # Store the results in adata.uns
+        # adata.uns["cluster_resolution_top_genes"] = top_genes_dict
+        # adata.uns["cluster_resolution_cluster_data"] = cluster_data
+        # return adata
+
+        results = {
+            "cluster_resolution_top_genes": top_genes_dict,
+            "cluster_resolution_cluster_data": cluster_data,
+        }
+        data = write_results(data, adata, results)
+        return data
+    
 
 def _validate_cluster_resolution_inputs(
     adata: AnnData,

{resolutiontree-0.1.1 → resolutiontree-0.2}/src/resolutiontree.egg-info/PKG-INFO

@@ -1,11 +1,10 @@
 Metadata-Version: 2.4
 Name: resolutiontree
-Version: 0.1.1
+Version: 0.2
 Summary: Systematic exploration of clustering resolutions in single-cell analysis
 Author-email: Joe Hou <joseph.houjue@gmail.com>
 License: MIT
 Project-URL: Homepage, https://github.com/joe-jhou2/resolutiontree
-Project-URL: Documentation, https://resolutiontree.readthedocs.io/
 Project-URL: Repository, https://github.com/joe-jhou2/resolutiontree
 Project-URL: Bug Tracker, https://github.com/joe-jhou2/resolutiontree/issues
 Keywords: single-cell,clustering,resolution,scanpy,leiden,visualization
@@ -14,12 +13,25 @@ Classifier: Intended Audience :: Science/Research
 Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
-Requires-Python: >=3.8
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
+Requires-Dist: numpy>=1.26
+Requires-Dist: pandas>=2.1
+Requires-Dist: scipy>=1.11
+Requires-Dist: matplotlib>=3.8
+Requires-Dist: seaborn>=0.13
+Requires-Dist: scanpy>=1.9.8
+Requires-Dist: anndata>=0.10
+Requires-Dist: igraph>=0.11
+Requires-Dist: networkx>=3.2
+Requires-Dist: leidenalg>=0.10
+Requires-Dist: umap-learn>=0.5.5
+Requires-Dist: spatialdata
+Requires-Dist: spatialdata[extra]
 
 # ResolutionTree
 
@@ -56,7 +68,7 @@ ResolutionTree provides:
 ### From GitHub Release (Recommended)
 
 ```bash
-pip install resolutiontree
+pip install resolutiontree==0.2
 ```
 
 ### From Source

{resolutiontree-0.1.1 → resolutiontree-0.2}/src/resolutiontree.egg-info/SOURCES.txt

@@ -1,11 +1,18 @@
 README.md
 pyproject.toml
+src/resolutiontree/__init__.py
 src/resolutiontree/core.py
 src/resolutiontree/utils.py
 src/resolutiontree.egg-info/PKG-INFO
 src/resolutiontree.egg-info/SOURCES.txt
 src/resolutiontree.egg-info/dependency_links.txt
+src/resolutiontree.egg-info/requires.txt
 src/resolutiontree.egg-info/top_level.txt
 tests/test_cluster_resolution.py
 tests/test_cluster_tree.py
-tests/test_installation.py
+tests/test_install_illumina.py
+tests/test_install_pbmc3k.py
+tests/test_install_visiumhd.py
+tests/test_install_xenium.py
+tests/test_pipeline_pbmc3k.py
+tests/test_pipeline_xenium.py

resolutiontree-0.2/src/resolutiontree.egg-info/requires.txt

@@ -0,0 +1,13 @@
+numpy>=1.26
+pandas>=2.1
+scipy>=1.11
+matplotlib>=3.8
+seaborn>=0.13
+scanpy>=1.9.8
+anndata>=0.10
+igraph>=0.11
+networkx>=3.2
+leidenalg>=0.10
+umap-learn>=0.5.5
+spatialdata
+spatialdata[extra]

{resolutiontree-0.1.1 → resolutiontree-0.2}/tests/test_cluster_resolution.py

@@ -9,7 +9,7 @@ import re
 import pandas as pd
 import pytest
 import scanpy as sc
-from src import cluster_resolution_finder
+from src.resolutiontree import cluster_resolution_finder
 from testing.scanpy._helpers.data import pbmc68k_reduced
 
 
@@ -28,7 +28,7 @@ def test_cluster_resolution_finder_basic(adata_for_test):
     """Test that cluster_resolution_finder runs without errors and modifies adata."""
     adata = adata_for_test.copy()  # Create a copy to avoid modifying the fixture
     resolutions = [0.1, 0.5]
-    result = cluster_resolution_finder(
+    cluster_resolution_finder(
         adata,
         resolutions,
         prefix="leiden_res_",
@@ -42,24 +42,23 @@ def test_cluster_resolution_finder_basic(adata_for_test):
 
     # Check that clustering columns were added to adata.obs
     for res in resolutions:
-        assert f"leiden_res_{res}" in result.obs
+        assert f"leiden_res_{res}" in adata.obs
 
     # Check that top_genes_dict was added to adata.uns
-    assert "cluster_resolution_top_genes" in result.uns
-    top_genes_dict = result.uns["cluster_resolution_top_genes"]
+    assert "cluster_resolution_top_genes" in adata.uns
+    top_genes_dict = adata.uns["cluster_resolution_top_genes"]
     assert isinstance(top_genes_dict, dict)
     assert len(top_genes_dict) > 0
 
-    for k, genes in top_genes_dict.items():
-        parent, child = k.split("_", 1)  # Split the combined key back into tuple
+    for (parent, child), genes in top_genes_dict.items():
         assert isinstance(parent, str)
         assert isinstance(child, str)
         assert isinstance(genes, list)
         assert all(isinstance(g, str) for g in genes)
 
     # Check that cluster_data was added to adata.uns
-    assert "cluster_resolution_cluster_data" in result.uns
-    cluster_data = result.uns["cluster_resolution_cluster_data"]
+    assert "cluster_resolution_cluster_data" in adata.uns
+    cluster_data = adata.uns["cluster_resolution_cluster_data"]
     assert isinstance(cluster_data, pd.DataFrame)
     for res in resolutions:
         assert f"leiden_res_{res}" in cluster_data.columns
@@ -145,13 +144,13 @@ def test_cluster_resolution_finder_n_top_genes(adata_for_test, n_top_genes):
     """Test that n_top_genes bounds the number of genes stored in adata.uns."""
     adata = adata_for_test.copy()
     resolutions = [0.1, 0.5]
-    result = cluster_resolution_finder(
+    cluster_resolution_finder(
         adata,
         resolutions,
         n_top_genes=n_top_genes,
     )
 
     # Check the number of genes in adata.uns["cluster_resolution_top_genes"]
-    top_genes_dict = result.uns["cluster_resolution_top_genes"]
+    top_genes_dict = adata.uns["cluster_resolution_top_genes"]
     for genes in top_genes_dict.values():
         assert len(genes) <= n_top_genes

{resolutiontree-0.1.1 → resolutiontree-0.2}/tests/test_cluster_tree.py

@@ -7,7 +7,7 @@ sys.path.insert(0, os.path.dirname(os.path.dirname(__file__)))
 import networkx as nx
 import pytest
 from scanpy.tools import leiden
-from src import cluster_decision_tree, cluster_resolution_finder
+from src.resolutiontree import cluster_decision_tree, cluster_resolution_finder
 import scanpy as sc
 from testing.scanpy._helpers.data import pbmc68k_reduced
 
@@ -26,7 +26,7 @@ def adata_with_clusters(adata_for_test):
     """Fixture providing clustering data and top_genes_dict for cluster_decision_tree."""
     adata = adata_for_test.copy()
     resolutions = [0.0, 0.2, 0.5, 1.0, 1.5, 2.0]
-    adata = cluster_resolution_finder(
+    cluster_resolution_finder(
         adata,
         resolutions,
         prefix="leiden_res_",

resolutiontree-0.1.1/tests/test_installation.py → resolutiontree-0.2/tests/test_install_pbmc3k.py

@@ -1,10 +1,9 @@
 import scanpy as sc
-import src as rt
+import resolutiontree as rt
 
 print("Loading PBMC dataset...")
 adata = sc.datasets.pbmc3k()
 
-
 print("Running preprocessing...")
 sc.pp.normalize_total(adata, inplace=True)
 sc.pp.log1p(adata)
@@ -13,20 +12,18 @@ sc.pp.neighbors(adata)
 sc.tl.umap(adata)
 
 print("Testing cluster_resolution_finder...")
-resolutions = [0.0, 0.2, 0.5, 1.0]
 resolutions = [0.0, 0.2, 0.5, 1.0, 1.5, 2.0]
 
-adata_new = rt.cluster_resolution_finder(adata,
-                                         resolutions=resolutions,
-                                         n_top_genes=3,
-                                         min_cells=2,
-                                         deg_mode="within_parent",
-                                         inplace=False
-                                         )
+rt.cluster_resolution_finder(adata,
+                             resolutions=resolutions,
+                             n_top_genes=3,
+                             min_cells=2,
+                             deg_mode="within_parent"
+                            )
 
-rt.cluster_decision_tree(adata_new, resolutions=resolutions, 
+rt.cluster_decision_tree(adata, resolutions=resolutions, 
                         output_settings = {
-                            "output_path": "examples/test_pypi_pbmc3k.png",
+                            "output_path": "tests/results/test_pypi_pbmc3k.png",
                             "draw": False,
                             "figsize": (12, 6),
                             "dpi": 300

resolutiontree-0.2/tests/test_install_xenium.py

@@ -0,0 +1,59 @@
+import pickle as pkl
+import spatialdata as sd
+import resolutiontree as rt
+
+sdata = sd.read_zarr("data/CF_8wph_processed.zarr")
+
+resolutions = [0.0, 0.5, 1.0, 1.5, 2.0, 2.5]
+
+rt.cluster_resolution_finder(sdata['table'],
+                             resolutions=resolutions,
+                             n_top_genes=3,
+                             min_cells=2,
+                             deg_mode="within_parent")
+
+rt.cluster_decision_tree(sdata['table'], resolutions=resolutions, 
+                        output_settings = {
+                            "output_path": "tests/results/test_xenium.png",
+                            "draw": False,
+                            "figsize": (12, 6),
+                            "dpi": 300
+                            },
+                        node_style = {
+                            "node_size": 500,
+                            "node_colormap": None,
+                            "node_label_fontsize": 12
+                            },
+                        edge_style = {
+                            "edge_color": "parent",
+                            "edge_curvature": 0.01,
+                            "edge_threshold": 0.01,
+                            "show_weight": True,
+                            "edge_label_threshold": 0.05,
+                            "edge_label_position": 0.8,
+                            "edge_label_fontsize": 8
+                            },
+                        gene_label_settings = {
+                            "show_gene_labels": True,
+                            "n_top_genes": 2,
+                            "gene_label_threshold": 0.001,
+                            "gene_label_style": {"offset":0.5, "fontsize":8},
+                            },
+                        level_label_style = {
+                            "level_label_offset": 15,
+                            "level_label_fontsize": 12
+                            },
+                        title_style = {
+                            "title": "Hierarchical Leiden Clustering",
+                            "title_fontsize": 20
+                            },
+                        layout_settings = {
+                            "node_spacing": 5.0,
+                            "level_spacing": 1.5
+                            },
+                        clustering_settings = {
+                            "prefix": "leiden_res_",
+                            "edge_threshold": 0.05
+                            }
+                    )
+

resolutiontree-0.2/tests/test_pipeline_pbmc3k.py

@@ -0,0 +1,73 @@
+import sys
+import os
+sys.path.insert(0, os.path.dirname(os.path.dirname(__file__)))
+
+import scanpy as sc
+from src.resolutiontree import cluster_resolution_finder, cluster_decision_tree
+
+# Load the dataset
+adata = sc.datasets.pbmc3k()
+
+# Perform standard preprocessing
+sc.pp.normalize_total(adata)
+sc.pp.log1p(adata)
+sc.pp.pca(adata)
+sc.pp.neighbors(adata)
+sc.tl.umap(adata)
+
+resolutions = [0.0, 0.2, 0.5, 1.0, 1.5, 2.0]
+
+# Perform hierarchical clustering with different resolutions
+cluster_resolution_finder(adata,
+                          resolutions=resolutions,
+                          n_top_genes=3, 
+                          min_cells=2,
+                          deg_mode="within_parent"
+                          )
+
+cluster_decision_tree(adata, resolutions=resolutions, 
+                      output_settings = {
+                          "output_path": "tests/results/test_pipeline_pbmc3k.png",
+                          "draw": False,
+                          "figsize": (12, 8),
+                          "dpi": 300
+                          },
+                      node_style = {
+                          "node_size": 500,
+                          "node_colormap": None,
+                          "node_label_fontsize": 12
+                          },
+                      edge_style = {
+                          "edge_color": "parent",
+                          "edge_curvature": 0.01,
+                          "edge_threshold": 0.01,
+                          "show_weight": True,
+                          "edge_label_threshold": 0.05,
+                          "edge_label_position": 0.8,
+                          "edge_label_fontsize": 8
+                          },
+                      gene_label_settings = {
+                          "show_gene_labels": True,
+                          "n_top_genes": 2,
+                          "gene_label_threshold": 0.001,
+                          "gene_label_style": {"offset":0.5, "fontsize":8},
+                        },
+                      level_label_style = {
+                          "level_label_offset": 15,
+                          "level_label_fontsize": 12
+                        },
+                      title_style = {
+                          "title": "Hierarchical Leiden Clustering",
+                          "title_fontsize": 20
+                        },
+                      layout_settings = {
+                          "node_spacing": 5.0,
+                          "level_spacing": 1.5
+                        },
+                      clustering_settings = {
+                          "prefix": "leiden_res_",
+                          "edge_threshold": 0.05
+                        }
+                    )
+
+# print(adata.uns["cluster_resolution_top_genes"])

resolutiontree-0.2/tests/test_pipeline_xenium.py

@@ -0,0 +1,69 @@
+import sys
+import os
+import spatialdata as sd
+sys.path.insert(0, os.path.dirname(os.path.dirname(__file__)))
+
+import scanpy as sc
+from src.resolutiontree import cluster_resolution_finder, cluster_decision_tree
+
+# Load the dataset
+adata = sd.read_zarr("data/CF_8wph_processed.zarr")
+print(adata)
+
+# Perform standard preprocessing
+resolutions = [0.0, 0.2, 0.5, 1.0, 1.5, 2.0]
+
+# Perform hierarchical clustering with different resolutions
+cluster_resolution_finder(adata,
+                          resolutions=resolutions,
+                          n_top_genes=3, 
+                          min_cells=2,
+                          deg_mode="within_parent"
+                          )
+
+cluster_decision_tree(adata, resolutions=resolutions, 
+                      output_settings = {
+                          "output_path": "tests/results/test_pipeline_xenium.png",
+                          "draw": False,
+                          "figsize": (12, 8),
+                          "dpi": 300
+                          },
+                      node_style = {
+                          "node_size": 500,
+                          "node_colormap": None,
+                          "node_label_fontsize": 12
+                          },
+                      edge_style = {
+                          "edge_color": "parent",
+                          "edge_curvature": 0.01,
+                          "edge_threshold": 0.01,
+                          "show_weight": True,
+                          "edge_label_threshold": 0.05,
+                          "edge_label_position": 0.8,
+                          "edge_label_fontsize": 8
+                          },
+                      gene_label_settings = {
+                          "show_gene_labels": True,
+                          "n_top_genes": 2,
+                          "gene_label_threshold": 0.001,
+                          "gene_label_style": {"offset":0.5, "fontsize":8},
+                        },
+                      level_label_style = {
+                          "level_label_offset": 15,
+                          "level_label_fontsize": 12
+                        },
+                      title_style = {
+                          "title": "Hierarchical Leiden Clustering",
+                          "title_fontsize": 20
+                        },
+                      layout_settings = {
+                          "node_spacing": 5.0,
+                          "level_spacing": 1.5
+                        },
+                      clustering_settings = {
+                          "prefix": "leiden_res_",
+                          "edge_threshold": 0.05
+                        }
+                    )
+
+# print(adata['table'].uns["cluster_resolution_top_genes"])