cytocommunity2 1.0.1__tar.gz → 1.0.3__tar.gz

{cytocommunity2-1.0.1/src/cytocommunity2.egg-info → cytocommunity2-1.0.3}/PKG-INFO

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

{cytocommunity2-1.0.1 → cytocommunity2-1.0.3}/pyproject.toml

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

{cytocommunity2-1.0.1 → cytocommunity2-1.0.3}/src/cytocommunity2/__init__.py

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

cytocommunity2-1.0.3/src/cytocommunity2/_io.py

@@ -0,0 +1,11 @@
+"""Shared reader for the workflow's one-value-per-line text files."""
+
+from pathlib import Path
+
+
+def read_nonempty_lines(path):
+    return [
+        line.strip()
+        for line in Path(path).read_text(encoding="utf-8-sig").splitlines()
+        if line.strip()
+    ]

{cytocommunity2-1.0.1 → cytocommunity2-1.0.3}/src/cytocommunity2/colors.py

@@ -7,12 +7,7 @@ def celltype_color_map(celltypes):
 
     palette = []
     for name in ("tab20", "tab20b", "tab20c", "Set1", "Dark2", "Accent", "Paired"):
-        cmap = plt.get_cmap(name)
-        palette.extend(
-            list(cmap.colors)
-            if hasattr(cmap, "colors")
-            else [cmap(index / 255) for index in range(256)]
-        )
+        palette.extend(plt.get_cmap(name).colors)
     return {
         celltype: palette[index]
         for index, celltype in enumerate(celltypes)

{cytocommunity2-1.0.1 → cytocommunity2-1.0.3}/src/cytocommunity2/config.py

@@ -9,11 +9,10 @@ from typing import Any, Mapping
 
 DEFAULT_CONFIG_FILE = "hyperparameters.json"
 
-# Established analysis rules stay stable across runs; only experimental choices
-# belong in hyperparameters.json.
-FIXED_DOWNSTREAM = {
+# Statistical thresholds and numerical settings for downstream analyses.
+DOWNSTREAM_PARAMETERS = {
     "dominant_cell_type": {"frequency_threshold": 0.5},
-    "differential_composed": {"p_value_threshold": 0.05},
+    "differential_composition": {"p_value_threshold": 0.05, "minimum_samples": 3},
     "moran": {
         "minimum_positive_count": 2,
         "minimum_cn_cells": 10,
@@ -27,9 +26,9 @@ FIXED_DOWNSTREAM = {
         "cca_p_threshold": 0.05,
         "cca_minimum_common_samples": 3,
         "cca_minimum_abs_rho": 0.0,
-        "cca_sd_epsilon": 1e-8,
+        "cca_min_std": 1e-8,
         "cca_max_iterations": 1000,
-        "cca_canonical_components": 2,
+        "cca_n_components": 2,
     },
 }
 
@@ -40,7 +39,7 @@ class MainConfig:
     cn_num_min: int
     cn_num_max: int
     final_num_runs: int
-    num_epoch: int
+    num_epochs: int
     embedding_dimension: int
     learning_rate: float
     mini_batch_size: int
@@ -82,17 +81,10 @@ class CytoCommunityConfig:
         return _load_config(config_file, config_class=cls)
 
 
-def _require_keys(values, required, section):
-    missing = [key for key in required if key not in values]
-    if missing:
-        raise ValueError(f"Missing configuration keys in {section}: {missing}")
-
-
 def _load_config(config_file=None, config_class=CytoCommunityConfig):
     """Load one configuration file and resolve its configured input folder."""
     config_file = Path(config_file or DEFAULT_CONFIG_FILE).expanduser().resolve()
     raw = json.loads(config_file.read_text(encoding="utf-8"))
-    _require_keys(raw, ["input_dir", "random_seed", "main", "downstream"], "root")
 
     project_root = config_file.parent
     input_dir = Path(raw["input_dir"]).expanduser()
@@ -104,14 +96,14 @@ def _load_config(config_file=None, config_class=CytoCommunityConfig):
     recurrence = RecurrenceConfig()
     visualization = VisualizationConfig(**raw.get("visualization", {}))
     downstream = dict(raw["downstream"])
-    for section, fixed_values in FIXED_DOWNSTREAM.items():
-        downstream[section] = {**downstream.get(section, {}), **fixed_values}
+    for section, parameters in DOWNSTREAM_PARAMETERS.items():
+        downstream[section] = {**downstream.get(section, {}), **parameters}
 
     if main.knn_k < 1:
         raise ValueError("main.knn_k must be positive")
     if main.cn_num_min < 1 or main.cn_num_min > main.cn_num_max:
         raise ValueError("Require 1 <= main.cn_num_min <= main.cn_num_max")
-    if main.final_num_runs < 1 or main.num_epoch < 1:
+    if main.final_num_runs < 1 or main.num_epochs < 1:
         raise ValueError("Run and epoch counts must be positive")
     if main.embedding_dimension < 1 or main.mini_batch_size < 1:
         raise ValueError("Embedding dimension and mini-batch size must be positive")

{cytocommunity2-1.0.1 → cytocommunity2-1.0.3}/src/cytocommunity2/downstream/__init__.py

@@ -1,8 +1,4 @@
-"""Reusable downstream analyses for CytoCommunity2 results.
-
-The top-level :mod:`cytocommunity2` API intentionally remains small.  These
-functions live in a dedicated namespace because downstream analyses are
-optional and evolve independently from model training.
+"""Downstream analyses of learned cellular neighborhoods.
 """
 
 from .coherence import run_coherence_analysis

{cytocommunity2-1.0.1 → cytocommunity2-1.0.3}/src/cytocommunity2/downstream/coherence.py

@@ -20,15 +20,10 @@ class CoherenceMetrics:
     pas: float
 
 
-def _coherence_inputs(cluster_labels, coordinates):
-    labels = np.asarray(cluster_labels)
-    locations = np.asarray(coordinates, dtype=float)
-    return labels, locations
-
-
 def compute_chaos(cluster_labels, coordinates):
     """Compute the normalized sum of within-CN nearest-neighbor distances."""
-    labels, locations = _coherence_inputs(cluster_labels, coordinates)
+    labels = np.asarray(cluster_labels)
+    locations = np.asarray(coordinates, dtype=float)
     locations = StandardScaler().fit_transform(locations)
     distances = []
     for label in np.unique(labels):
@@ -43,7 +38,8 @@ def compute_chaos(cluster_labels, coordinates):
 
 def compute_pas(cluster_labels, coordinates, *, k=10):
     """Compute the percentage of abnormal spots (PAS) metric."""
-    labels, locations = _coherence_inputs(cluster_labels, coordinates)
+    labels = np.asarray(cluster_labels)
+    locations = np.asarray(coordinates, dtype=float)
     if not 1 <= k < len(labels):
         raise ValueError("k must satisfy 1 <= k < number of cells")
     neighbors = NearestNeighbors(n_neighbors=k + 1, algorithm="kd_tree").fit(
@@ -93,5 +89,5 @@ def run_coherence_analysis(config: CytoCommunityConfig, *, output_dir=None, pas_
     output_dir = Path(output_dir or paths.downstream_data / "Coherence")
     output_dir.mkdir(parents=True, exist_ok=True)
     result = analyze_result_tables(paths.result_tables, pas_k=pas_k)
-    result.to_csv(output_dir / "config.csv", index=False)
+    result.to_csv(output_dir / "CoherenceMetrics.csv", index=False)
     return result

{cytocommunity2-1.0.1 → cytocommunity2-1.0.3}/src/cytocommunity2/downstream/communication/between.py

@@ -2,7 +2,6 @@
 
 from pathlib import Path
 
-import numpy as np
 import pandas as pd
 from scipy.stats import spearmanr
 
@@ -27,26 +26,22 @@ def select_cca_pairs(cca_pairs, top_n):
 
 
 def analyze_between_cn(
-    scores_long, cca_pairs, coordinate_tables, *, minimum_samples, top_n_cca_pairs
+    scores_long, cca_pairs, loading_tables, *, minimum_samples, top_n_cca_pairs
 ):
-    """Calculate between-CN correlations without filesystem access.
-
-    ``coordinate_tables`` maps ``(CN_A, CN_B)`` string tuples to coordinate
-    DataFrames returned by :func:`cca_coordinate_tables`.
-    """
+    """Calculate between-CN correlations without filesystem access."""
     scores = normalize_scores_long(scores_long)
     pairs = select_cca_pairs(cca_pairs, top_n_cca_pairs)
     rows = []
     for _, pair in pairs.iterrows():
         cn_a, cn_b = str(pair["CN_A"]), str(pair["CN_B"])
-        coordinates = coordinate_tables[(cn_a, cn_b)].copy()
-        coordinates["CellType"] = coordinates["CellType"].astype(str).str.strip()
-        coordinates_a = coordinates.dropna(subset=["CN_A_coord_can1"])
-        coordinates_b = coordinates.dropna(subset=["CN_B_coord_can1"])
-        top_a_index = coordinates_a["CN_A_coord_can1"].abs().idxmax()
-        top_b_index = coordinates_b["CN_B_coord_can1"].abs().idxmax()
-        top_a = coordinates_a.loc[top_a_index, "CellType"]
-        top_b = coordinates_b.loc[top_b_index, "CellType"]
+        loadings = loading_tables[(cn_a, cn_b)].copy()
+        loadings["CellType"] = loadings["CellType"].astype(str).str.strip()
+        loadings_a = loadings.dropna(subset=["CN_A_loading1"])
+        loadings_b = loadings.dropna(subset=["CN_B_loading1"])
+        top_a_index = loadings_a["CN_A_loading1"].abs().idxmax()
+        top_b_index = loadings_b["CN_B_loading1"].abs().idxmax()
+        top_a = loadings_a.loc[top_a_index, "CellType"]
+        top_b = loadings_b.loc[top_b_index, "CellType"]
         scores_a = scores.loc[
             (scores["CN"] == cn_a) & (scores["CellType"] == top_a),
             ["Sample", "Score"],
@@ -70,13 +65,8 @@ def analyze_between_cn(
                 "CN_A": cn_a,
                 "CN_B": cn_b,
                 "rho1_CCA": pair["rho1"],
-                "pval1_CCA": pair["pval1"],
-                "rho2_CCA": pair["rho2"] if "rho2" in pairs else np.nan,
-                "pval2_CCA": pair["pval2"] if "pval2" in pairs else np.nan,
                 "Top_CellType_A": top_a,
                 "Top_CellType_B": top_b,
-                "TopA_coord_can1": coordinates_a.loc[top_a_index, "CN_A_coord_can1"],
-                "TopB_coord_can1": coordinates_b.loc[top_b_index, "CN_B_coord_can1"],
                 "Spearman_rho": rho,
                 "Spearman_p": p_value,
                 "N_overlap": len(merged),
@@ -86,19 +76,19 @@ def analyze_between_cn(
     if not result.empty:
         result = result.sort_values(
             "rho1_CCA", key=lambda values: values.abs(), ascending=False
-        )
+        ).drop(columns="rho1_CCA")
     return result
 
 
 def run_between_cn_statistics(config_dir, minimum_samples, top_n_cca_pairs):
-    """Compatibility workflow operating on the established communication folder."""
+    """Calculate and save Spearman statistics for top CCA pairs."""
     config_dir = Path(config_dir)
     scores = pd.read_csv(config_dir / "EnrichScoreMatrix_long.csv")
-    pairs = pd.read_csv(config_dir / "CCA_config.csv")
+    pairs = pd.read_csv(config_dir / "CCA_results.csv")
     selected = select_cca_pairs(pairs, top_n_cca_pairs)
     tables = {
         (str(row.CN_A), str(row.CN_B)): pd.read_csv(
-            config_dir / f"CCA_coordinates_CN{row.CN_A}_vs_CN{row.CN_B}.csv"
+            config_dir / f"CCA_loadings_CN{row.CN_A}_vs_CN{row.CN_B}.csv"
         )
         for row in selected.itertuples(index=False)
     }

{cytocommunity2-1.0.1 → cytocommunity2-1.0.3}/src/cytocommunity2/downstream/communication/cca.py

@@ -20,7 +20,7 @@ def pair_rng(base_seed, condition, cn_a, cn_b):
     return np.random.default_rng(seed)
 
 
-def clean_cca_data(x, y, minimum_common_samples, sd_epsilon):
+def clean_cca_data(x, y, minimum_common_samples, min_std):
     """Align two matrices and remove incomplete or near-constant variables."""
     if x is None or y is None or x.shape[1] == 0 or y.shape[1] == 0:
         return None
@@ -29,15 +29,13 @@ def clean_cca_data(x, y, minimum_common_samples, sd_epsilon):
         return None
     x = x.loc[common]
     y = y.loc[common]
-    x = x.loc[:, x.notna().sum(axis=0) > 0]
-    y = y.loc[:, y.notna().sum(axis=0) > 0]
-    x = x.loc[:, x.std(axis=0) > sd_epsilon]
-    y = y.loc[:, y.std(axis=0) > sd_epsilon]
+    x = x.loc[:, x.std(axis=0) > min_std]
+    y = y.loc[:, y.std(axis=0) > min_std]
     if x.shape[1] == 0 or y.shape[1] == 0:
         return None
     complete = x.notna().all(axis=1) & y.notna().all(axis=1)
     x, y = x.loc[complete], y.loc[complete]
-    if x.shape[0] < minimum_common_samples or x.shape[1] == 0 or y.shape[1] == 0:
+    if x.shape[0] < minimum_common_samples:
         return None
     return {
         "X": x.values,
@@ -75,7 +73,7 @@ def run_cca_for_scores(
             score_list[cn_a],
             score_list[cn_b],
             communication_params["cca_minimum_common_samples"],
-            communication_params["cca_sd_epsilon"],
+            communication_params["cca_min_std"],
         )
         if cleaned is None:
             continue
@@ -93,7 +91,7 @@ def run_cca_for_scores(
         model.fit(x_matrix, y_matrix)
         x_scores, y_scores = model.transform(x_matrix, y_matrix)
         actual_components = min(
-            communication_params["cca_canonical_components"], x_scores.shape[1]
+            communication_params["cca_n_components"], x_scores.shape[1]
         )
         correlations = [
             np.corrcoef(x_scores[:, index], y_scores[:, index])[0, 1]
@@ -111,7 +109,7 @@ def run_cca_for_scores(
                 shuffled_y = rng.permutation(y_matrix)
                 permutation_model = CCA(
                     n_components=min(
-                        communication_params["cca_canonical_components"],
+                        communication_params["cca_n_components"],
                         max_components,
                     ),
                     scale=True,
@@ -143,7 +141,7 @@ def run_cca_for_scores(
         row = {"CN_A": cn_a, "CN_B": cn_b, "n_samples": n_samples}
         if condition is not None:
             row["Condition"] = str(condition)
-        for component in range(communication_params["cca_canonical_components"]):
+        for component in range(communication_params["cca_n_components"]):
             row[f"rho{component + 1}"] = (
                 correlations[component] if component < len(correlations) else None
             )
@@ -177,8 +175,8 @@ def run_cca_for_scores(
     return {"results": results, "cache": cache}
 
 
-def cca_coordinate_tables(
-    results, cache, celltype_order, canonical_components, condition=None
+def cca_loading_tables(
+    results, cache, celltype_order, n_components, condition=None
 ):
     """Convert fitted CCA scores into per-pair cell-type loading tables."""
     tables = {}
@@ -198,47 +196,41 @@ def cca_coordinate_tables(
             if cell_type in set(entry["X_ct"]) | set(entry["Y_ct"])
         ]
         data = {"CellType": all_celltypes}
-        maximum = min(canonical_components, entry["X_scores"].shape[1])
+        maximum = min(n_components, entry["X_scores"].shape[1])
         for component in range(maximum):
             x_score = entry["X_scores"][:, component]
             y_score = entry["Y_scores"][:, component]
             x_loadings = {
                 cell_type: np.corrcoef(entry["X_mat"][:, index], x_score)[0, 1]
-                if len(x_score) > 1
-                else np.nan
                 for index, cell_type in enumerate(entry["X_ct"])
             }
             y_loadings = {
                 cell_type: np.corrcoef(entry["Y_mat"][:, index], y_score)[0, 1]
-                if len(y_score) > 1
-                else np.nan
                 for index, cell_type in enumerate(entry["Y_ct"])
             }
-            data[f"CN_A_coord_can{component + 1}"] = [
+            data[f"CN_A_loading{component + 1}"] = [
                 x_loadings.get(cell_type, np.nan) for cell_type in all_celltypes
             ]
-            data[f"CN_B_coord_can{component + 1}"] = [
+            data[f"CN_B_loading{component + 1}"] = [
                 y_loadings.get(cell_type, np.nan) for cell_type in all_celltypes
             ]
-            data[f"rho{component + 1}"] = [row.get(f"rho{component + 1}", np.nan)] * len(all_celltypes)
-            data[f"pval{component + 1}"] = [row.get(f"pval{component + 1}", np.nan)] * len(all_celltypes)
         tables[(cn_a, cn_b)] = pd.DataFrame(data)
     return tables
 
 
-def write_cca_coordinates(
-    results, cache, output_dir, celltype_order, canonical_components, condition=None
+def write_cca_loadings(
+    results, cache, output_dir, celltype_order, n_components, condition=None
 ):
-    """Write coordinate tables using the original filenames."""
+    """Write per-pair cell-type CCA loading tables."""
     output_dir = Path(output_dir)
     output_dir.mkdir(parents=True, exist_ok=True)
-    tables = cca_coordinate_tables(
-        results, cache, celltype_order, canonical_components, condition
+    tables = cca_loading_tables(
+        results, cache, celltype_order, n_components, condition
     )
     prefix = f"{condition}_" if condition is not None else ""
     for (cn_a, cn_b), table in tables.items():
         table.to_csv(
-            output_dir / f"CCA_coordinates_{prefix}CN{cn_a}_vs_CN{cn_b}.csv",
+            output_dir / f"CCA_loadings_{prefix}CN{cn_a}_vs_CN{cn_b}.csv",
             index=False,
         )
     return tables
@@ -268,13 +260,13 @@ def run_cca_analysis(
     pooled = run_cca_for_scores(
         build_score_list(frame, cn_list), cn_list, params, config.random_seed
     )
-    pooled["results"].to_csv(output_dir / "CCA_config.csv", index=False)
-    write_cca_coordinates(
+    pooled["results"].to_csv(output_dir / "CCA_results.csv", index=False)
+    write_cca_loadings(
         pooled["results"],
         pooled["cache"],
         output_dir,
         celltype_order,
-        params["cca_canonical_components"],
+        params["cca_n_components"],
     )
     condition_results = []
     for condition in conditions:
@@ -286,13 +278,12 @@ def run_cca_analysis(
             config.random_seed,
             condition,
         )
-        result["results"].to_csv(output_dir / f"CCA_config_{condition}.csv", index=False)
-        write_cca_coordinates(
+        write_cca_loadings(
             result["results"],
             result["cache"],
             output_dir,
             celltype_order,
-            params["cca_canonical_components"],
+            params["cca_n_components"],
             condition,
         )
         condition_results.append(result["results"])
@@ -310,16 +301,16 @@ def run_cca_analysis(
             key=lambda values: abs(values) if values.name == "rho1" else values,
             ascending=[True, False],
         )
-    by_condition.to_csv(output_dir / "CCA_config_by_condition.csv", index=False)
+    by_condition.to_csv(output_dir / "CCA_results_by_condition.csv", index=False)
     return {"pooled": pooled["results"], "by_condition": by_condition}
 
 
 __all__ = [
     "build_score_list",
-    "cca_coordinate_tables",
+    "cca_loading_tables",
     "clean_cca_data",
     "pair_rng",
     "run_cca_analysis",
     "run_cca_for_scores",
-    "write_cca_coordinates",
+    "write_cca_loadings",
 ]

{cytocommunity2-1.0.1 → cytocommunity2-1.0.3}/src/cytocommunity2/downstream/communication/within.py

@@ -234,7 +234,7 @@ def run_within_cn_analysis(
     }
     outputs["pooled"].to_csv(output_dir / "SpearmanWithinCNs.csv", index=False)
     for comparison in build_condition_comparisons(
-        scores["Condition"], config.downstream["ttest_mode"]
+        scores["Condition"], config.downstream["comparison_mode"]
     ):
         result = compute_condition_comparison_stats(
             wide_dict=wide,

{cytocommunity2-1.0.1 → cytocommunity2-1.0.3}/src/cytocommunity2/downstream/differential_composition.py

@@ -4,11 +4,11 @@ from pathlib import Path
 
 import numpy as np
 import pandas as pd
-from scipy import stats
 
 from ..config import CytoCommunityConfig
 from ..paths import build_paths
 from .dominant_celltype import load_enrichment_matrices
+from .wilcoxon import rank_sum_test
 
 
 def load_condition_enrichment(enrichment_dir, input_dir):
@@ -66,32 +66,26 @@ def build_label_comparisons(labels, mode):
     raise ValueError(f"Unknown comparison mode: {mode}")
 
 
-def composition_wilcoxon_tests(cell_type, target_values, reference_values):
-    """Run one-sided asymptotic Wilcoxon rank-sum tests."""
+def composition_wilcoxon_tests(
+    cell_type, target_values, reference_values, *, minimum_samples=3
+):
+    """Run one-sided Wilcoxon rank-sum tests, exact for combined N <= 30."""
     target = np.asarray(target_values, dtype=float)
     reference = np.asarray(reference_values, dtype=float)
-    if len(target) < 2 or len(reference) < 2:
+    if len(target) < minimum_samples or len(reference) < minimum_samples:
         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())
+    p_values, target_rank_sum, test_name = rank_sum_test(target, reference)
 
     rows = []
-    for alternative in ("greater", "less"):
-        test = stats.mannwhitneyu(
-            target,
-            reference,
-            alternative=alternative,
-            method="asymptotic",
-            use_continuity=True,
-        )
+    for alternative, p_value in p_values.items():
         rows.append(
             {
                 "CellType": cell_type,
                 "Alternative": alternative,
-                "p_value": float(test.pvalue),
-                "Test": "Wilcoxon rank-sum asymptotic",
+                "p_value": p_value,
+                "Test": test_name,
                 "W_statistic": target_rank_sum,
                 "N_target": len(target),
                 "N_reference": len(reference),
@@ -100,10 +94,12 @@ def composition_wilcoxon_tests(cell_type, target_values, reference_values):
     return rows
 
 
-def analyze_differential_composition(matrix_records, celltypes, *, mode):
+def analyze_differential_composition(matrix_records, celltypes, *, mode, minimum_samples=3):
     """Calculate all directional composition comparisons in memory.
 
     The result maps comparison names to maps of CN names and result tables.
+    Comparisons with fewer than ``minimum_samples`` samples on either side
+    have empty maps.
     """
     normalized_records = [
         {**record, "matrix": np.asarray(record["matrix"], dtype=float)}
@@ -114,8 +110,20 @@ def analyze_differential_composition(matrix_records, celltypes, *, mode):
     labels = sorted({record["condition"] for record in normalized_records})
     comparisons = build_label_comparisons(labels, mode)
     outputs = {comparison["name"]: {} for comparison in comparisons}
+    eligible = [
+        comparison
+        for comparison in comparisons
+        if sum(
+            record["condition"] in comparison["target_labels"]
+            for record in normalized_records
+        ) >= minimum_samples
+        and sum(
+            record["condition"] in comparison["reference_labels"]
+            for record in normalized_records
+        ) >= minimum_samples
+    ]
     for cn_index in range(expected_shape[1]):
-        for comparison in comparisons:
+        for comparison in eligible:
             rows = []
             for cell_index, cell_type in enumerate(celltypes):
                 target = [
@@ -129,7 +137,7 @@ def analyze_differential_composition(matrix_records, celltypes, *, mode):
                     if record["condition"] in comparison["reference_labels"]
                 ]
                 result = composition_wilcoxon_tests(
-                    cell_type, target, reference
+                    cell_type, target, reference, minimum_samples=minimum_samples
                 )
                 if result is not None:
                     rows.extend(result)
@@ -141,104 +149,23 @@ def analyze_differential_composition(matrix_records, celltypes, *, mode):
 def run_differential_composition_analysis(
     config: CytoCommunityConfig, *, output_dir=None
 ):
-    """Run differential composition tests and preserve legacy filenames."""
+    """Run and save condition-specific differential composition tests."""
     paths = build_paths(config)
     celltypes, records = load_condition_enrichment(
         paths.enrichment, paths.input_dir
     )
     outputs = analyze_differential_composition(
-        records, celltypes, mode=config.downstream["ttest_mode"]
+        records, celltypes, mode=config.downstream["comparison_mode"],
+        minimum_samples=config.downstream["differential_composition"]["minimum_samples"],
     )
     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)
+        if comparison_dir.exists():
+            for csv_file in comparison_dir.glob("CN*.csv"):
+                csv_file.unlink()
+        if cn_tables:
+            comparison_dir.mkdir(parents=True, exist_ok=True)
+            for cn, table in cn_tables.items():
+                table.to_csv(comparison_dir / f"{cn}_{comparison}.csv", index=False)
     return outputs
-
-
-def comparison_label(record, condition_names):
-    target = condition_names.get(record["target"], record["target"])
-    reference = record["reference"]
-    if reference == "rest":
-        return f"{target} vs. other cancers"
-    return f"{target} vs. {condition_names.get(reference, reference)}"
-
-
-def calculate_cn_variation_specificity(
-    records, celltypes, condition_names, *, p_value_threshold
-):
-    """Summarize significant differential-composition features (DCFs)."""
-    summary_rows = []
-    detail_rows = []
-    for record in records:
-        effect = np.asarray(record["effect"], dtype=float)
-        pvalues = np.asarray(record["pvalues"], dtype=float)
-        significant = np.isfinite(effect) & np.isfinite(pvalues) & (
-            pvalues < p_value_threshold
-        )
-        dcf_rows = [
-            {
-                "CellType": celltypes[celltype_index],
-                "Direction": "Up" if effect[celltype_index, cn_index] > 0 else "Down",
-                "CN": f"CN{cn_index + 1}",
-                "Significance": -np.log10(
-                    np.clip(pvalues[celltype_index, cn_index], 1e-300, 1.0)
-                ),
-            }
-            for celltype_index, cn_index in np.argwhere(significant)
-        ]
-        dcf_table = pd.DataFrame(
-            dcf_rows, columns=["CellType", "Direction", "CN", "Significance"]
-        )
-        number_dcf = len(dcf_table)
-        number_patterns = (
-            dcf_table[["CellType", "Direction"]].drop_duplicates().shape[0]
-            if number_dcf
-            else 0
-        )
-        label = comparison_label(record, condition_names)
-        summary_rows.append(
-            {
-                "Comparison": record["name"],
-                "CancerComparison": label,
-                "NumberDCF": number_dcf,
-                "NumberCellTypeDirectionPatterns": number_patterns,
-                "SpecificityOfCNVariation": (
-                    number_patterns / number_dcf if number_dcf else np.nan
-                ),
-                "MeanDCFSignificance": (
-                    dcf_table["Significance"].mean() if number_dcf else np.nan
-                ),
-            }
-        )
-        if number_dcf:
-            patterns = (
-                dcf_table.groupby(["CellType", "Direction"], sort=False)
-                .agg(
-                    NumberDCF=("CN", "size"),
-                    MeanDCFSignificance=("Significance", "mean"),
-                )
-                .reset_index()
-            )
-            patterns.insert(0, "CancerComparison", label)
-            patterns.insert(0, "Comparison", record["name"])
-            detail_rows.extend(patterns.to_dict("records"))
-    return (
-        pd.DataFrame(summary_rows),
-        pd.DataFrame(
-            detail_rows,
-            columns=[
-                "Comparison",
-                "CancerComparison",
-                "CellType",
-                "Direction",
-                "NumberDCF",
-                "MeanDCFSignificance",
-            ],
-        ),
-    )
-