cytocommunity2 0.1.4__tar.gz → 0.1.6__tar.gz

{cytocommunity2-0.1.4/src/cytocommunity2.egg-info → cytocommunity2-0.1.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cytocommunity2
-Version: 0.1.4
+Version: 0.1.6
 Summary: Weakly supervised cellular-neighborhood learning for spatial omics
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown

{cytocommunity2-0.1.4 → cytocommunity2-0.1.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "cytocommunity2"
-version = "0.1.4"
+version = "0.1.6"
 description = "Weakly supervised cellular-neighborhood learning for spatial omics"
 readme = "README.md"
 requires-python = ">=3.10"

{cytocommunity2-0.1.4 → cytocommunity2-0.1.6}/src/cytocommunity2/__init__.py

@@ -10,7 +10,7 @@ from .learning import (
 )
 from .visualization import visualize_results
 
-__version__ = "0.1.4"
+__version__ = "0.1.6"
 
 __all__ = [
     "CytoCommunityConfig",

{cytocommunity2-0.1.4 → cytocommunity2-0.1.6}/src/cytocommunity2/config.py

@@ -75,12 +75,7 @@ class CytoCommunityConfig:
     visualization: VisualizationConfig
     downstream: Mapping[str, Any]
 
-    @property
-    def celltype_order(self):
-        groups = self.downstream["dominant_cell_type"]["cell_type_groups"]
-        return [cell_type for group in groups.values() for cell_type in group]
-
-    @classmethod
+    @classmethod
     def from_json(cls, config_file=None):
         """Load and validate a JSON configuration file."""
         return _load_config(config_file, config_class=cls)

{cytocommunity2-0.1.4 → cytocommunity2-0.1.6}/src/cytocommunity2/downstream/__init__.py

@@ -5,14 +5,12 @@ functions live in a dedicated namespace because downstream analyses are
 optional and evolve independently from model training.
 """
 
-from .coherence import run_coherence_analysis
-from .composition import (
-    run_differential_composition_analysis,
-    run_dominant_celltype_analysis,
-)
-
-__all__ = [
-    "run_coherence_analysis",
-    "run_differential_composition_analysis",
-    "run_dominant_celltype_analysis",
-]
+from .coherence import run_coherence_analysis
+from .differential_composition import run_differential_composition_analysis
+from .dominant_celltype import run_dominant_celltype_analysis
+
+__all__ = [
+    "run_coherence_analysis",
+    "run_differential_composition_analysis",
+    "run_dominant_celltype_analysis",
+]

{cytocommunity2-0.1.4 → cytocommunity2-0.1.6}/src/cytocommunity2/downstream/communication/cca.py

@@ -260,9 +260,10 @@ def run_cca_analysis(config, *, input_file=None, output_dir=None):
     params = config.downstream["communication"]
     output_dir = Path(output_dir or paths.communication_config)
     output_dir.mkdir(parents=True, exist_ok=True)
-    frame = _normalize_scores(
-        pd.read_csv(input_file or output_dir / "EnrichScoreMatrix_long.csv")
-    )
+    frame = _normalize_scores(
+        pd.read_csv(input_file or output_dir / "EnrichScoreMatrix_long.csv")
+    )
+    celltype_order = frame["CellType"].astype(str).drop_duplicates().tolist()
     conditions = sorted(frame["Condition"].unique(), key=condition_sort_key)
     cn_list = sorted(frame["CN"].unique(), key=condition_sort_key)
     pooled = run_cca_for_scores(
@@ -273,7 +274,7 @@ def run_cca_analysis(config, *, input_file=None, output_dir=None):
         pooled["results"],
         pooled["cache"],
         output_dir,
-        config.celltype_order,
+        celltype_order,
         params["cca_canonical_components"],
     )
     condition_results = []
@@ -291,7 +292,7 @@ def run_cca_analysis(config, *, input_file=None, output_dir=None):
             result["results"],
             result["cache"],
             output_dir,
-            config.celltype_order,
+            celltype_order,
             params["cca_canonical_components"],
             condition,
         )

{cytocommunity2-0.1.4 → cytocommunity2-0.1.6}/src/cytocommunity2/downstream/communication/within.py

@@ -224,7 +224,8 @@ def run_within_cn_analysis(config, *, input_file=None, output_dir=None):
     output_dir = Path(output_dir or paths.communication_config)
     output_dir.mkdir(parents=True, exist_ok=True)
     input_file = Path(input_file or output_dir / "EnrichScoreMatrix_long.csv")
-    scores = pd.read_csv(input_file, dtype={"Condition": str, "CN": str})
+    scores = pd.read_csv(input_file, dtype={"Condition": str, "CN": str})
+    celltype_order = scores["CellType"].astype(str).drop_duplicates().tolist()
     num_cn = int(paths.selected_cn_num.read_text(encoding="utf-8"))
     cn_order = [str(index) for index in range(1, num_cn + 1)]
     wide = prepare_wide_tables(scores, cn_order)
@@ -242,7 +243,7 @@ def run_within_cn_analysis(config, *, input_file=None, output_dir=None):
             labels_a=comparison["labels_a"],
             labels_b=comparison["labels_b"],
             cn_order=cn_order,
-            celltype_order=config.celltype_order,
+            celltype_order=celltype_order,
             min_samples=params["minimum_samples"],
             n_permutations=params["n_permutations"],
             max_attempt_multiplier=params["permutation_max_attempt_multiplier"],

cytocommunity2-0.1.4/src/cytocommunity2/downstream/composition.py → cytocommunity2-0.1.6/src/cytocommunity2/downstream/differential_composition.py

@@ -1,8 +1,5 @@
-"""Cell-type composition and CN-variation analyses."""
+"""Condition-specific differential cell-type composition analysis."""
 
-from dataclasses import dataclass
-from functools import lru_cache
-from itertools import combinations
 from pathlib import Path
 
 import numpy as np
@@ -11,135 +8,13 @@ from scipy import stats
 
 from ..config import CytoCommunityConfig
 from ..paths import build_paths
+from .dominant_celltype import load_enrichment_matrices
 
 
-SUBTYPE_NAMES = {
-    "ImmuneScore": "Immune cell-dominant",
-    "MalignantScore": "Malignant cell-dominant",
-    "StromalScore": "Stromal cell-dominant",
-}
-
-
-@dataclass(frozen=True)
-class DominantCellTypeResult:
-    """In-memory outputs of dominant-cell-type analysis."""
-
-    frequency: pd.DataFrame
-    dominant_cell_types: pd.DataFrame
-    subtype_scores: pd.DataFrame
-
-
-def load_enrichment_matrices(enrichment_dir, input_dir, celltype_order):
-    """Load and align per-sample enrichment matrices."""
-    enrichment_dir = Path(enrichment_dir)
-    input_dir = Path(input_dir)
-    source_celltypes = (
-        pd.read_csv(enrichment_dir / "CellTypeVec_List.csv")
-        .iloc[:, 0]
-        .astype(str)
-        .str.strip()
-        .tolist()
-    )
-    missing = [cell_type for cell_type in celltype_order if cell_type not in source_celltypes]
-    if missing:
-        raise ValueError(f"Cell types missing from enrichment matrices: {missing}")
-    samples = pd.read_csv(input_dir / "ImageNameList.txt", header=None).iloc[:, 0]
-    indices = [source_celltypes.index(cell_type) for cell_type in celltype_order]
-    matrices = [
-        pd.read_csv(
-            enrichment_dir / f"{sample}_EnrichScoreMatrix.csv", header=None
-        ).to_numpy(dtype=float)[indices]
-        for sample in samples
-    ]
-    if not matrices:
-        raise ValueError("ImageNameList.txt does not contain any samples")
-    return list(celltype_order), np.stack(matrices, axis=0)
-
-
-def build_subtype_scores(frequency, dominant_df, cell_type_groups):
-    """Aggregate cell-type frequencies into configured biological groups."""
-    cn_by_celltype = frequency.T
-    available_groups = {
-        score_name: [cell_type for cell_type in group if cell_type in cn_by_celltype]
-        for score_name, group in cell_type_groups.items()
-    }
-    missing_groups = [name for name, group in available_groups.items() if not group]
-    if missing_groups:
-        raise ValueError(f"No input cell types found for: {missing_groups}")
-
-    scores = pd.DataFrame(
-        {
-            score_name: cn_by_celltype[cell_types].mean(axis=1)
-            for score_name, cell_types in available_groups.items()
-        }
-    )
-    names = {**{name: name for name in available_groups}, **SUBTYPE_NAMES}
-    scores["Subtype"] = scores.idxmax(axis=1).map(names)
-    scores = scores.reset_index().rename(columns={"index": "CN"})
-    return scores.merge(dominant_df, on="CN", how="left")
-
-
-def analyze_dominant_celltypes(
-    enrichment_matrices,
-    celltypes,
-    *,
-    score_threshold,
-    frequency_threshold,
-    cell_type_groups,
-):
-    """Compute dominant cell types and subtype scores from aligned matrices."""
-    matrices = np.asarray(enrichment_matrices, dtype=float)
-    if matrices.ndim != 3:
-        raise ValueError("enrichment_matrices must have shape (samples, cell types, CNs)")
-    if matrices.shape[1] != len(celltypes):
-        raise ValueError("celltypes length does not match enrichment_matrices")
-
-    frequencies = (matrices > score_threshold).mean(axis=0)
-    cn_names = [f"CN{index}" for index in range(1, matrices.shape[2] + 1)]
-    frequency = pd.DataFrame(frequencies, index=celltypes, columns=cn_names)
-    dominant = pd.DataFrame(
-        {
-            "CN": cn_names,
-            "DominantCellTypes": [
-                ", ".join(
-                    np.asarray(celltypes)[frequencies[:, cn_index] > frequency_threshold]
-                )
-                for cn_index in range(matrices.shape[2])
-            ],
-        }
-    )
-    subtype_scores = build_subtype_scores(frequency, dominant, cell_type_groups)
-    return DominantCellTypeResult(frequency, dominant, subtype_scores)
-
-
-def run_dominant_celltype_analysis(config, *, output_dir=None):
-    """Run dominant-cell-type analysis using the established repository layout."""
-    if not isinstance(config, CytoCommunityConfig):
-        config = CytoCommunityConfig.from_json(config)
-    paths = build_paths(config)
-    params = config.downstream["dominant_cell_type"]
-    celltypes, matrices = load_enrichment_matrices(
-        paths.enrichment, paths.input_dir, config.celltype_order
-    )
-    result = analyze_dominant_celltypes(
-        matrices,
-        celltypes,
-        score_threshold=-np.log10(config.enrichment.p_value_threshold),
-        frequency_threshold=params["frequency_threshold"],
-        cell_type_groups=params["cell_type_groups"],
-    )
-    output_dir = Path(output_dir or paths.downstream_data / "DominateCT")
-    output_dir.mkdir(parents=True, exist_ok=True)
-    result.frequency.to_csv(output_dir / "CN_CT_Frequency.csv", float_format="%.4f")
-    result.dominant_cell_types.to_csv(output_dir / "DominantCT.csv", index=False)
-    result.subtype_scores.to_csv(output_dir / "CN_Subtype_Scores.csv", index=False)
-    return result
-
-
-def load_condition_enrichment(enrichment_dir, input_dir, celltype_order):
+def load_condition_enrichment(enrichment_dir, input_dir):
     """Load enrichment matrices together with each sample's graph label."""
-    celltypes, matrices = load_enrichment_matrices(
-        enrichment_dir, input_dir, celltype_order
+    celltypes, matrices = load_enrichment_matrices(
+        enrichment_dir, input_dir
     )
     input_dir = Path(input_dir)
     samples = (
@@ -161,8 +36,8 @@ def load_condition_enrichment(enrichment_dir, input_dir, celltype_order):
     return celltypes, records
 
 
-def build_label_comparisons(labels, mode):
-    """Build the directional comparisons used by composition tests."""
+def build_label_comparisons(labels, mode):
+    """Build the directional comparisons used by composition tests."""
     labels = list(labels)
     if mode == "pairwise":
         return [
@@ -191,49 +66,37 @@ def build_label_comparisons(labels, mode):
     raise ValueError(f"Unknown comparison mode: {mode}")
 
 
-@lru_cache(maxsize=None)
-def _target_index_combinations(n_total, n_target):
-    """Return all target-group allocations for an exact permutation test."""
-    return np.asarray(
-        list(combinations(range(n_total), n_target)),
-        dtype=np.int16,
-    )
-
-
 def composition_wilcoxon_tests(cell_type, target_values, reference_values):
-    """Run one-sided exact Wilcoxon rank-sum permutation tests."""
-    target = np.asarray(target_values, dtype=float)
-    reference = np.asarray(reference_values, dtype=float)
+    """Run one-sided asymptotic Wilcoxon rank-sum tests."""
+    target = np.asarray(target_values, dtype=float)
+    reference = np.asarray(reference_values, dtype=float)
     if len(target) < 2 or len(reference) < 2:
         return None
     if not np.isfinite(target).all() or not np.isfinite(reference).all():
         return None
     pooled_ranks = stats.rankdata(np.concatenate([target, reference]), method="average")
     target_rank_sum = float(pooled_ranks[: len(target)].sum())
-    allocations = _target_index_combinations(len(pooled_ranks), len(target))
-    null_rank_sums = pooled_ranks[allocations].sum(axis=1)
 
     rows = []
     for alternative in ("greater", "less"):
-        if alternative == "greater":
-            p_value = np.count_nonzero(null_rank_sums >= target_rank_sum) / len(
-                null_rank_sums
-            )
-        else:
-            p_value = np.count_nonzero(null_rank_sums <= target_rank_sum) / len(
-                null_rank_sums
-            )
+        test = stats.mannwhitneyu(
+            target,
+            reference,
+            alternative=alternative,
+            method="asymptotic",
+            use_continuity=True,
+        )
         rows.append(
             {
                 "CellType": cell_type,
                 "Alternative": alternative,
-                "p_value": float(p_value),
-                "Test": "Wilcoxon rank-sum exact permutation",
-                "W_statistic": target_rank_sum,
-                "N_target": len(target),
-                "N_reference": len(reference),
-            }
-        )
+                "p_value": float(test.pvalue),
+                "Test": "Wilcoxon rank-sum asymptotic",
+                "W_statistic": target_rank_sum,
+                "N_target": len(target),
+                "N_reference": len(reference),
+            }
+        )
     return rows
 
 
@@ -271,9 +134,9 @@ def analyze_differential_composition(matrix_records, celltypes, *, mode):
                     for record in normalized_records
                     if record["condition"] in comparison["reference_labels"]
                 ]
-                result = composition_wilcoxon_tests(
-                    cell_type, target, reference
-                )
+                result = composition_wilcoxon_tests(
+                    cell_type, target, reference
+                )
                 if result is not None:
                     rows.extend(result)
             if rows:
@@ -286,20 +149,20 @@ def run_differential_composition_analysis(config, *, output_dir=None):
     if not isinstance(config, CytoCommunityConfig):
         config = CytoCommunityConfig.from_json(config)
     paths = build_paths(config)
-    celltypes, records = load_condition_enrichment(
-        paths.enrichment, paths.input_dir, config.celltype_order
+    celltypes, records = load_condition_enrichment(
+        paths.enrichment, paths.input_dir
     )
     outputs = analyze_differential_composition(
         records, celltypes, mode=config.downstream["ttest_mode"]
     )
     output_dir = Path(output_dir or paths.downstream_data / "DifferentialComposed")
-    for comparison, cn_tables in outputs.items():
-        comparison_dir = output_dir / comparison
-        comparison_dir.mkdir(parents=True, exist_ok=True)
-        for old_file in comparison_dir.glob("CN*.csv"):
-            old_file.unlink()
-        for cn, table in cn_tables.items():
-            table.to_csv(comparison_dir / f"{cn}_{comparison}.csv", index=False)
+    for comparison, cn_tables in outputs.items():
+        comparison_dir = output_dir / comparison
+        comparison_dir.mkdir(parents=True, exist_ok=True)
+        for old_file in comparison_dir.glob("CN*.csv"):
+            old_file.unlink()
+        for cn, table in cn_tables.items():
+            table.to_csv(comparison_dir / f"{cn}_{comparison}.csv", index=False)
     return outputs
 
 

cytocommunity2-0.1.6/src/cytocommunity2/downstream/dominant_celltype.py

@@ -0,0 +1,95 @@
+"""Dominant cell-type analysis."""
+
+from dataclasses import dataclass
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+
+from ..config import CytoCommunityConfig
+from ..paths import build_paths
+
+
+@dataclass(frozen=True)
+class DominantCellTypeResult:
+    """In-memory outputs of dominant-cell-type analysis."""
+
+    frequency: pd.DataFrame
+    dominant_cell_types: pd.DataFrame
+
+
+def load_enrichment_matrices(enrichment_dir, input_dir):
+    """Load per-sample enrichment matrices in their stored cell-type order."""
+    enrichment_dir = Path(enrichment_dir)
+    input_dir = Path(input_dir)
+    source_celltypes = (
+        pd.read_csv(enrichment_dir / "CellTypeVec_List.csv")
+        .iloc[:, 0]
+        .astype(str)
+        .str.strip()
+        .tolist()
+    )
+    samples = pd.read_csv(input_dir / "ImageNameList.txt", header=None).iloc[:, 0]
+    matrices = [
+        pd.read_csv(
+            enrichment_dir / f"{sample}_EnrichScoreMatrix.csv", header=None
+        ).to_numpy(dtype=float)
+        for sample in samples
+    ]
+    if not matrices:
+        raise ValueError("ImageNameList.txt does not contain any samples")
+    return source_celltypes, np.stack(matrices, axis=0)
+
+
+def analyze_dominant_celltypes(
+    enrichment_matrices,
+    celltypes,
+    *,
+    score_threshold,
+    frequency_threshold,
+):
+    """Compute dominant cell types from aligned enrichment matrices."""
+    matrices = np.asarray(enrichment_matrices, dtype=float)
+    if matrices.ndim != 3:
+        raise ValueError("enrichment_matrices must have shape (samples, cell types, CNs)")
+    if matrices.shape[1] != len(celltypes):
+        raise ValueError("celltypes length does not match enrichment_matrices")
+
+    frequencies = (matrices > score_threshold).mean(axis=0)
+    cn_names = [f"CN{index}" for index in range(1, matrices.shape[2] + 1)]
+    frequency = pd.DataFrame(frequencies, index=celltypes, columns=cn_names)
+    dominant = pd.DataFrame(
+        {
+            "CN": cn_names,
+            "DominantCellTypes": [
+                ", ".join(
+                    np.asarray(celltypes)[frequencies[:, cn_index] > frequency_threshold]
+                )
+                for cn_index in range(matrices.shape[2])
+            ],
+        }
+    )
+    return DominantCellTypeResult(frequency, dominant)
+
+
+def run_dominant_celltype_analysis(config, *, output_dir=None):
+    """Run dominant-cell-type analysis using the established repository layout."""
+    if not isinstance(config, CytoCommunityConfig):
+        config = CytoCommunityConfig.from_json(config)
+    paths = build_paths(config)
+    params = config.downstream["dominant_cell_type"]
+    celltypes, matrices = load_enrichment_matrices(
+        paths.enrichment, paths.input_dir
+    )
+    result = analyze_dominant_celltypes(
+        matrices,
+        celltypes,
+        score_threshold=-np.log10(config.enrichment.p_value_threshold),
+        frequency_threshold=params["frequency_threshold"],
+    )
+    output_dir = Path(output_dir or paths.downstream_data / "DominateCT")
+    output_dir.mkdir(parents=True, exist_ok=True)
+    result.frequency.to_csv(output_dir / "CN_CT_Frequency.csv", float_format="%.4f")
+    result.dominant_cell_types.to_csv(output_dir / "DominantCT.csv", index=False)
+    return result
+

{cytocommunity2-0.1.4 → cytocommunity2-0.1.6}/src/cytocommunity2/downstream/plotting/communication.py

@@ -319,7 +319,7 @@ def plot_communication_results(
         figure_dir, table_dir = stack_root / "figures", stack_root / "tables"
         figure_dir.mkdir(parents=True, exist_ok=True)
         table_dir.mkdir(parents=True, exist_ok=True)
-        present_celltypes = [celltype for celltype in config.celltype_order if celltype in scores["CellType"].astype(str).unique()]
+        present_celltypes = scores["CellType"].astype(str).drop_duplicates().tolist()
         colors = _color_map(present_celltypes)
         pd.DataFrame({"CellType": list(colors), "Color": [mpl.colors.to_hex(color) for color in colors.values()]}).to_csv(table_dir / "CellType_ColorMap.csv", index=False)
         outputs["stackplot"].extend(_save_stack_legends(colors, figure_dir, params["permutation_p_threshold"]))

cytocommunity2-0.1.6/src/cytocommunity2/downstream/plotting/dominant.py

@@ -0,0 +1,78 @@
+"""Dominant-cell-type frequency heatmap."""
+
+import numpy as np
+import pandas as pd
+
+from ...paths import build_paths
+
+
+def _prepare(result):
+    frequency = result.frequency.copy()
+    frequency.columns = frequency.columns.astype(str).str.strip()
+    frequency.index = frequency.index.astype(str).str.strip()
+    frequency = frequency.apply(pd.to_numeric, errors="coerce")
+    cn_numbers = pd.to_numeric(
+        frequency.columns.to_series().str.extract(r"(\d+)", expand=False),
+        errors="coerce",
+    )
+    cn_order = cn_numbers.sort_values(kind="stable").index.tolist()
+    return frequency.loc[:, cn_order]
+
+
+def plot_dominant_celltype_results(result, config):
+    """Save the frequency heatmap and its colorbar."""
+    import matplotlib as mpl
+    import matplotlib.pyplot as plt
+
+    mpl.rcParams.update({
+        "font.family": "Arial",
+        "font.size": 12,
+        "axes.linewidth": 0.8,
+        "lines.linewidth": 1.2,
+        "xtick.labelsize": 10,
+        "ytick.labelsize": 10,
+        "pdf.fonttype": 42,
+    })
+    output_dir = build_paths(config).downstream_plot / "DominateCT"
+    output_dir.mkdir(parents=True, exist_ok=True)
+    frequency = _prepare(result)
+
+    rows, columns = frequency.shape
+    heat_height = 0.68 * 10 * rows / (8 * columns)
+    figure = plt.figure(figsize=(10, 8))
+    heat_axis = figure.add_axes([0.10, 0.10, 0.68, heat_height])
+    heat_axis.imshow(
+        frequency.to_numpy(), cmap="RdYlBu_r", vmin=0, vmax=1,
+        aspect="auto", interpolation="nearest", origin="upper",
+    )
+    heat_axis.set_xticks(np.arange(columns))
+    heat_axis.set_xticklabels(frequency.columns, rotation=90, fontsize=10)
+    heat_axis.set_yticks(np.arange(rows))
+    heat_axis.set_yticklabels(frequency.index, fontsize=10)
+    for label in heat_axis.get_yticklabels():
+        label.set_horizontalalignment("right")
+    heat_axis.tick_params(axis="x", length=0, bottom=True, top=False, labelbottom=True)
+    heat_axis.tick_params(axis="y", length=0, pad=6)
+    heat_axis.set_xticks(np.arange(-0.5, columns, 1), minor=True)
+    heat_axis.set_yticks(np.arange(-0.5, rows, 1), minor=True)
+    heat_axis.grid(which="minor", color="white", linewidth=0.35)
+    heat_axis.tick_params(which="minor", bottom=False, left=False)
+    for spine in heat_axis.spines.values():
+        spine.set_visible(False)
+    heatmap_output = output_dir / "heatmap_main.pdf"
+    figure.savefig(heatmap_output, bbox_inches="tight", dpi=1200)
+    figure.savefig(heatmap_output.with_suffix(".png"), bbox_inches="tight", dpi=300)
+    plt.close(figure)
+
+    figure = plt.figure(figsize=(1.2, 3.2))
+    axis = figure.add_axes([0.45, 0.08, 0.22, 0.84])
+    scalar_map = mpl.cm.ScalarMappable(norm=mpl.colors.Normalize(vmin=0, vmax=1), cmap="RdYlBu_r")
+    scalar_map.set_array([])
+    colorbar = figure.colorbar(scalar_map, cax=axis)
+    colorbar.set_ticks([0.0, 0.5, 1.0])
+    colorbar.ax.tick_params(labelsize=10, length=3, pad=2)
+    colorbar.outline.set_visible(False)
+    colorbar_output = output_dir / "colorbar_only.pdf"
+    figure.savefig(colorbar_output, bbox_inches="tight", dpi=1200)
+    plt.close(figure)
+    return {"heatmap": heatmap_output, "colorbar": colorbar_output}