cytocommunity2 1.0.4__tar.gz → 1.0.6__tar.gz

{cytocommunity2-1.0.4/src/cytocommunity2.egg-info → cytocommunity2-1.0.6}/PKG-INFO

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

{cytocommunity2-1.0.4 → cytocommunity2-1.0.6}/pyproject.toml

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

{cytocommunity2-1.0.4 → cytocommunity2-1.0.6}/src/cytocommunity2/__init__.py

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

cytocommunity2-1.0.6/src/cytocommunity2/_io.py

@@ -0,0 +1,94 @@
+"""Shared input readers with explicit cell-row and condition-label contracts."""
+
+from pathlib import Path
+
+import numpy as np
+
+
+def read_nonempty_lines(path):
+    """Read a list such as ImageNameList, allowing blank separator lines."""
+    return [
+        line.strip()
+        for line in Path(path).read_text(encoding="utf-8-sig").splitlines()
+        if line.strip()
+    ]
+
+
+def read_cell_type_labels(path, *, expected_count=None):
+    """Read one label per cell, preserving literal labels such as ``NA``.
+
+    Cell rows cannot be removed: an empty label would shift every subsequent
+    label relative to the coordinates and CN assignments, so it is an error.
+    """
+    path = Path(path)
+    labels = [line.strip() for line in path.read_text(encoding="utf-8-sig").splitlines()]
+    if not labels:
+        raise ValueError(f"{path}: no cell-type labels found")
+    for row, label in enumerate(labels, start=1):
+        if not label:
+            raise ValueError(f"{path}: empty cell-type label at row {row}")
+    if expected_count is not None and len(labels) != expected_count:
+        raise ValueError(
+            f"{path}: cell-type labels={len(labels)}, expected cell rows={expected_count}"
+        )
+    return labels
+
+
+def validate_coordinates(coordinates, *, source="Coordinates", expected_count=None):
+    """Require a nonempty, finite x/y coordinate matrix with one row per cell."""
+    coordinates = np.asarray(coordinates, dtype=np.float64)
+    if coordinates.ndim != 2 or coordinates.shape[1] != 2 or not len(coordinates):
+        raise ValueError(f"{source}: coordinates must have at least one row and exactly 2 columns")
+    if not np.isfinite(coordinates).all():
+        raise ValueError(f"{source}: coordinates must contain only finite values")
+    if expected_count is not None and len(coordinates) != expected_count:
+        raise ValueError(
+            f"{source}: coordinates={len(coordinates)}, expected cell rows={expected_count}"
+        )
+    return coordinates
+
+
+def read_coordinates(path, *, expected_count=None):
+    """Read tab-delimited coordinates and validate their shape and cell count."""
+    path = Path(path)
+    coordinates = np.loadtxt(
+        path, dtype=np.float64, delimiter="\t", ndmin=2, encoding="utf-8-sig"
+    )
+    return validate_coordinates(coordinates, source=path, expected_count=expected_count)
+
+
+def read_graph_labels(input_dir, samples=None, *, allow_missing=False):
+    """Read original integer condition labels, without training-label remapping.
+
+    Every sample must have a GraphLabel file, or all files must be absent.
+    An all-missing dataset is assigned condition 0 only when the caller permits
+    single-condition data; a partially labelled dataset is always rejected.
+    """
+    input_dir = Path(input_dir)
+    samples = list(samples) if samples is not None else read_nonempty_lines(
+        input_dir / "ImageNameList.txt"
+    )
+    if not samples:
+        raise ValueError(f"{input_dir}: no samples found")
+    files = {sample: input_dir / f"{sample}_GraphLabel.txt" for sample in samples}
+    present = {sample: path.is_file() for sample, path in files.items()}
+    if not any(present.values()):
+        if allow_missing:
+            return dict.fromkeys(samples, 0)
+        raise FileNotFoundError(f"{input_dir}: GraphLabel files are required for this analysis")
+    if not all(present.values()):
+        missing = ", ".join(sample for sample in samples if not present[sample])
+        raise ValueError(
+            "GraphLabel files must be provided for either all or no samples; "
+            f"missing: {missing}"
+        )
+    labels = {}
+    for sample, path in files.items():
+        values = read_nonempty_lines(path)
+        try:
+            if len(values) != 1:
+                raise ValueError
+            labels[sample] = int(values[0])
+        except ValueError as error:
+            raise ValueError(f"{path}: expected exactly one integer GraphLabel") from error
+    return labels

{cytocommunity2-1.0.4 → cytocommunity2-1.0.6}/src/cytocommunity2/downstream/communication/between.py

@@ -3,17 +3,21 @@
 from pathlib import Path
 
 import pandas as pd
-from scipy.stats import spearmanr
 
 from ...config import CytoCommunityConfig
 from ...paths import build_paths
+from .utils import (
+    build_score_tables,
+    normalize_scores_long,
+    read_scores_long,
+    safe_spearman,
+)
 
 
-def normalize_scores_long(scores_long):
-    frame = scores_long.copy()
-    for column in ["Sample", "CN", "CellType"]:
-        frame[column] = frame[column].astype(str).str.strip()
-    return frame
+_RESULT_COLUMNS = [
+    "CN_A", "CN_B", "Top_CellType_A", "Top_CellType_B",
+    "Spearman_rho", "Spearman_p", "N_overlap"
+]
 
 
 def select_cca_pairs(cca_pairs, top_n):
@@ -31,6 +35,8 @@ def analyze_between_cn(
     """Calculate between-CN correlations without filesystem access."""
     scores = normalize_scores_long(scores_long)
     pairs = select_cca_pairs(cca_pairs, top_n_cca_pairs)
+    selected_cns = pd.concat([pairs["CN_A"], pairs["CN_B"]]).drop_duplicates()
+    matrices = build_score_tables(scores, selected_cns, duplicate_policy="raise")
     rows = []
     for _, pair in pairs.iterrows():
         cn_a, cn_b = str(pair["CN_A"]), str(pair["CN_B"])
@@ -42,15 +48,14 @@ def analyze_between_cn(
         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"],
-        ].rename(columns={"Score": "Score_A"})
-        scores_b = scores.loc[
-            (scores["CN"] == cn_b) & (scores["CellType"] == top_b),
-            ["Sample", "Score"],
-        ].rename(columns={"Score": "Score_B"})
-        merged = pd.merge(scores_a, scores_b, on="Sample", how="inner")
+        merged = pd.concat(
+            [
+                matrices[cn_a][top_a].rename("Score_A"),
+                matrices[cn_b][top_b].rename("Score_B"),
+            ],
+            axis=1,
+            join="inner",
+        ).dropna()
         if len(merged) < minimum_samples:
             raise ValueError(
                 f"Too few overlapping samples for CN{cn_a}({top_a}) vs CN{cn_b}({top_b})"
@@ -59,7 +64,9 @@ def analyze_between_cn(
             raise ValueError(
                 f"Constant enrichment scores for CN{cn_a}({top_a}) vs CN{cn_b}({top_b})"
             )
-        rho, p_value = spearmanr(merged["Score_A"], merged["Score_B"], nan_policy="omit")
+        rho, p_value = safe_spearman(
+            merged["Score_A"], merged["Score_B"], minimum_samples
+        )
         rows.append(
             {
                 "CN_A": cn_a,
@@ -72,23 +79,28 @@ def analyze_between_cn(
                 "N_overlap": len(merged),
             }
         )
-    result = pd.DataFrame(rows)
+    result = pd.DataFrame(rows, columns=_RESULT_COLUMNS + ["rho1_CCA"])
     if not result.empty:
         result = result.sort_values(
             "rho1_CCA", key=lambda values: values.abs(), ascending=False
-        ).drop(columns="rho1_CCA")
-    return result
+        )
+    return result.drop(columns="rho1_CCA")
 
 
 def run_between_cn_statistics(config_dir, minimum_samples, top_n_cca_pairs):
     """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_results.csv")
+    scores = read_scores_long(
+        config_dir / "EnrichScoreMatrix_long.csv", require_condition=False
+    )
+    pairs = pd.read_csv(
+        config_dir / "CCA_results.csv", dtype={"CN_A": str, "CN_B": str}
+    )
     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_loadings_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",
+            converters={"CellType": str.strip},
         )
         for row in selected.itertuples(index=False)
     }

{cytocommunity2-1.0.4 → cytocommunity2-1.0.6}/src/cytocommunity2/downstream/communication/cca.py

@@ -9,7 +9,22 @@ from sklearn.cross_decomposition import CCA
 
 from ...config import CytoCommunityConfig
 from ...paths import build_paths
-from .utils import condition_sort_key
+from .utils import (
+    build_score_tables,
+    condition_sort_key,
+    normalize_scores_long,
+    prune_csv_outputs,
+    read_scores_long,
+)
+
+
+def _result_columns(n_components, *, by_condition=False):
+    columns = ["CN_A", "CN_B", "n_samples"]
+    if by_condition:
+        columns.append("Condition")
+    for component in range(1, n_components + 1):
+        columns.extend([f"rho{component}", f"pval{component}", f"invalid_perm{component}"])
+    return columns
 
 
 def pair_rng(base_seed, condition, cn_a, cn_b):
@@ -46,18 +61,8 @@ def clean_cca_data(x, y, minimum_common_samples, min_std):
 
 
 def build_score_list(frame, cn_list):
-    """Build one sample-by-cell-type score matrix per CN."""
-    matrices = {}
-    for cn in cn_list:
-        subset = frame[frame["CN"].astype(str) == str(cn)]
-        if subset.empty:
-            continue
-        matrix = subset.pivot_table(
-            index="Sample", columns="CellType", values="Score", aggfunc="mean"
-        )
-        if not matrix.empty:
-            matrices[str(cn)] = matrix.astype(float)
-    return matrices
+    """Build score matrices with the established duplicate-mean aggregation."""
+    return build_score_tables(frame, cn_list, duplicate_policy="mean")
 
 
 def select_top_features(matrix, top_n=5):
@@ -180,7 +185,12 @@ def run_cca_for_scores(
             "Y_mat": y_matrix,
         }
 
-    results = pd.DataFrame(result_rows)
+    results = pd.DataFrame(
+        result_rows,
+        columns=_result_columns(
+            communication_params["cca_n_components"], by_condition=condition is not None
+        ),
+    )
     if not results.empty:
         results = results.sort_values(
             "rho1", key=lambda values: values.abs(), ascending=False, na_position="last"
@@ -210,7 +220,11 @@ def cca_loading_tables(
         ]
         data = {"CellType": all_celltypes}
         maximum = min(n_components, entry["X_scores"].shape[1])
-        for component in range(maximum):
+        for component in range(n_components):
+            if component >= maximum:
+                data[f"CN_A_loading{component + 1}"] = [np.nan] * len(all_celltypes)
+                data[f"CN_B_loading{component + 1}"] = [np.nan] * len(all_celltypes)
+                continue
             x_score = entry["X_scores"][:, component]
             y_score = entry["Y_scores"][:, component]
             x_loadings = {
@@ -250,10 +264,7 @@ def write_cca_loadings(
 
 
 def _normalize_scores(frame):
-    frame = frame.copy()
-    for column in ["Sample", "Condition", "CN", "CellType"]:
-        frame[column] = frame[column].astype(str)
-    return frame
+    return normalize_scores_long(frame, require_condition=True)
 
 
 def run_cca_analysis(
@@ -264,24 +275,15 @@ def run_cca_analysis(
     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 = read_scores_long(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(
         build_score_list(frame, cn_list), cn_list, params, config.random_seed
     )
-    pooled["results"].to_csv(output_dir / "CCA_results.csv", index=False)
-    write_cca_loadings(
-        pooled["results"],
-        pooled["cache"],
-        output_dir,
-        celltype_order,
-        params["cca_n_components"],
-    )
     condition_results = []
+    fitted_conditions = []
     for condition in conditions:
         subset = frame[frame["Condition"] == condition]
         result = run_cca_for_scores(
@@ -291,19 +293,14 @@ def run_cca_analysis(
             config.random_seed,
             condition,
         )
-        write_cca_loadings(
-            result["results"],
-            result["cache"],
-            output_dir,
-            celltype_order,
-            params["cca_n_components"],
-            condition,
-        )
         condition_results.append(result["results"])
+        fitted_conditions.append((condition, result))
     by_condition = (
         pd.concat(condition_results, ignore_index=True)
         if condition_results
-        else pd.DataFrame()
+        else pd.DataFrame(
+            columns=_result_columns(params["cca_n_components"], by_condition=True)
+        )
     )
     if not by_condition.empty:
         by_condition["Condition"] = pd.Categorical(
@@ -314,7 +311,24 @@ def run_cca_analysis(
             key=lambda values: abs(values) if values.name == "rho1" else values,
             ascending=[True, False],
         )
+    # Retain only loadings from the completed pooled/condition analyses. A CN pair
+    # that disappeared on this run must not survive as an apparently current file.
+    current_loadings = []
+    for condition, result in [(None, pooled), *fitted_conditions]:
+        tables = write_cca_loadings(
+            result["results"], result["cache"], output_dir, celltype_order,
+            params["cca_n_components"], condition,
+        )
+        prefix = f"{condition}_" if condition is not None else ""
+        current_loadings.extend(
+            f"CCA_loadings_{prefix}CN{cn_a}_vs_CN{cn_b}.csv"
+            for cn_a, cn_b in tables
+        )
+    pooled["results"].to_csv(output_dir / "CCA_results.csv", index=False)
     by_condition.to_csv(output_dir / "CCA_results_by_condition.csv", index=False)
+    prune_csv_outputs(
+        output_dir, "CCA_loadings_*CN*_vs_CN*.csv", current_loadings
+    )
     return {"pooled": pooled["results"], "by_condition": by_condition}
 
 

cytocommunity2-1.0.6/src/cytocommunity2/downstream/communication/utils.py

@@ -0,0 +1,140 @@
+"""Shared communication table and statistical utilities."""
+
+import itertools
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+from scipy.stats import spearmanr
+
+
+def normalize_scores_long(scores_long, *, require_condition=False):
+    """Validate score columns and normalize identifiers without losing NA labels."""
+    identifiers = ["Sample", "CN", "CellType"]
+    if require_condition or "Condition" in scores_long:
+        identifiers.insert(1, "Condition")
+    required = identifiers + ["Score"]
+    missing = [column for column in required if column not in scores_long]
+    if missing:
+        raise ValueError(f"Enrichment scores are missing columns: {', '.join(missing)}")
+    frame = scores_long.copy()
+    for column in identifiers:
+        if frame[column].isna().any():
+            raise ValueError(f"Enrichment score identifiers cannot be missing: {column}")
+        frame[column] = frame[column].astype(str).str.strip()
+        if frame[column].eq("").any():
+            raise ValueError(f"Enrichment score identifiers cannot be blank: {column}")
+    frame["Score"] = pd.to_numeric(frame["Score"].replace("", np.nan), errors="raise")
+    return frame
+
+
+def read_scores_long(path, *, require_condition=True):
+    """Read score tables while preserving literal identifiers such as ``NA``."""
+    frame = pd.read_csv(
+        path,
+        dtype={column: str for column in ["Sample", "Condition", "CN", "CellType"]},
+        keep_default_na=False,
+        na_values={"Score": ["", "NaN", "nan", "NA"]},
+    )
+    return normalize_scores_long(frame, require_condition=require_condition)
+
+
+def build_score_tables(
+    scores_long, cn_order, *, index_columns=("Sample",), duplicate_policy="raise"
+):
+    """Build CN score matrices with an explicit reject-or-mean duplicate policy."""
+    if duplicate_policy not in {"raise", "mean"}:
+        raise ValueError(f"Unknown score duplicate policy: {duplicate_policy}")
+    frame = normalize_scores_long(
+        scores_long, require_condition="Condition" in index_columns
+    )
+    index_columns = list(index_columns)
+    tables = {}
+    for cn in cn_order:
+        subset = frame[frame["CN"] == str(cn)]
+        if subset.empty:
+            continue
+        if duplicate_policy == "raise":
+            if subset.duplicated(index_columns + ["CellType"]).any():
+                raise ValueError(f"Duplicate enrichment score rows for CN{cn}")
+            matrix = subset.pivot(
+                index=index_columns, columns="CellType", values="Score"
+            )
+        else:
+            matrix = subset.pivot_table(
+                index=index_columns,
+                columns="CellType",
+                values="Score",
+                aggfunc="mean",
+            )
+        if not matrix.empty:
+            tables[str(cn)] = matrix.astype(float)
+    return tables
+
+
+def prune_csv_outputs(output_dir, pattern, current_names):
+    """Remove only obsolete files from one analysis-owned CSV filename pattern."""
+    current_names = set(current_names)
+    for path in Path(output_dir).glob(pattern):
+        if path.is_file() and path.name not in current_names:
+            path.unlink()
+
+
+def condition_label(condition):
+    condition = str(condition)
+    return condition if condition == "rest" else f"label{condition}"
+
+
+def condition_pair_label(condition_a, condition_b):
+    return f"{condition_label(condition_a)}_vs_{condition_label(condition_b)}"
+
+
+def condition_sort_key(value):
+    value = str(value)
+    try:
+        return (0, int(value), value)
+    except ValueError:
+        return (1, value)
+
+
+def available_conditions(values):
+    present = pd.Series(values).dropna().astype(str).str.strip()
+    present = present[present.ne("")].unique().tolist()
+    return sorted(present, key=condition_sort_key)
+
+
+def condition_pairs(values):
+    return list(itertools.combinations(available_conditions(values), 2))
+
+
+def stable_seed(base_seed, *parts):
+    return int(base_seed) + sum(ord(character) for character in "_".join(map(str, parts)))
+
+
+def safe_spearman(x, y, min_samples):
+    x = np.asarray(x, dtype=float)
+    y = np.asarray(y, dtype=float)
+    valid = (~np.isnan(x)) & (~np.isnan(y))
+    x = x[valid]
+    y = y[valid]
+    if len(x) < min_samples or len(np.unique(x)) < 2 or len(np.unique(y)) < 2:
+        return np.nan, np.nan
+    rho, p_value = spearmanr(x, y)
+    if np.isnan(rho):
+        return np.nan, np.nan
+    return float(rho), float(p_value) if np.isfinite(p_value) else np.nan
+
+
+__all__ = [
+    "available_conditions",
+    "build_score_tables",
+    "condition_label",
+    "condition_pair_label",
+    "condition_pairs",
+    "condition_sort_key",
+    "normalize_scores_long",
+    "prune_csv_outputs",
+    "read_scores_long",
+    "safe_spearman",
+    "stable_seed",
+]

{cytocommunity2-1.0.4 → cytocommunity2-1.0.6}/src/cytocommunity2/downstream/communication/within.py

@@ -5,24 +5,31 @@ from pathlib import Path
 
 import numpy as np
 import pandas as pd
-from scipy.stats import spearmanr
 
 from ...config import CytoCommunityConfig
 from ...paths import build_paths
 from .utils import (
     available_conditions,
+    build_score_tables,
     condition_pair_label,
+    prune_csv_outputs,
+    read_scores_long,
     safe_spearman,
     stable_seed,
 )
 
 
+_POOLED_COLUMNS = ["CN", "CellType1", "CellType2", "rho", "p", "n"]
+_COMPARISON_COLUMNS = [
+    "CN", "CellType1", "CellType2", "rho_A", "p_A", "rho_B", "p_B", "perm_p"
+]
+
+
 def compute_pooled_within_cn(scores_long, num_cn, min_samples):
     """Compute pooled within-CN Spearman correlations."""
     rows = []
-    for cn in range(1, num_cn + 1):
-        subset = scores_long[scores_long["CN"].astype(str) == str(cn)]
-        matrix = subset.pivot(index="Sample", columns="CellType", values="Score")
+    cn_order = [str(cn) for cn in range(1, num_cn + 1)]
+    for cn, matrix in build_score_tables(scores_long, cn_order).items():
         valid_columns = [
             cell_type
             for cell_type in matrix.columns
@@ -32,41 +39,37 @@ def compute_pooled_within_cn(scores_long, num_cn, min_samples):
         matrix = matrix[valid_columns]
         if matrix.shape[1] < 2:
             continue
-        correlation, p_value = spearmanr(matrix.values, axis=0, nan_policy="omit")
-        if np.isscalar(correlation):
-            correlation = np.array([[1.0, correlation], [correlation, 1.0]])
-            p_value = np.array([[0.0, p_value], [p_value, 0.0]])
         for left, right in itertools.combinations(range(matrix.shape[1]), 2):
             cell_type_a = matrix.columns[left]
             cell_type_b = matrix.columns[right]
+            paired = matrix[[cell_type_a, cell_type_b]].dropna()
+            rho, p_value = safe_spearman(
+                paired[cell_type_a], paired[cell_type_b], min_samples
+            )
             rows.append(
                 {
                     "CN": str(cn),
                     "CellType1": cell_type_a,
                     "CellType2": cell_type_b,
-                    "rho": correlation[left, right],
-                    "p": p_value[left, right],
-                    "n": len(matrix[[cell_type_a, cell_type_b]].dropna()),
+                    "rho": rho,
+                    "p": p_value,
+                    "n": len(paired),
                 }
             )
-    return pd.DataFrame(rows)
+    return pd.DataFrame(rows, columns=_POOLED_COLUMNS)
 
 
 def prepare_wide_tables(scores_long, cn_order):
-    tables = {}
-    for cn in cn_order:
-        subset = scores_long[scores_long["CN"].astype(str) == str(cn)]
-        if subset.empty:
-            continue
-        tables[str(cn)] = (
-            subset.pivot_table(
-                index=["Sample", "Condition"],
-                columns="CellType",
-                values="Score",
-                aggfunc="mean",
-            ).reset_index()
-        )
-    return tables
+    """Build condition tables, retaining the established duplicate-mean policy."""
+    return {
+        cn: matrix.reset_index()
+        for cn, matrix in build_score_tables(
+            scores_long,
+            cn_order,
+            index_columns=("Sample", "Condition"),
+            duplicate_policy="mean",
+        ).items()
+    }
 
 
 def permutation_pvalue(
@@ -208,9 +211,7 @@ def compute_condition_comparison_stats(
                     "perm_p": permutation_p,
                 }
             )
-    if not rows:
-        return pd.DataFrame()
-    return pd.DataFrame(rows).sort_values(
+    return pd.DataFrame(rows, columns=_COMPARISON_COLUMNS).sort_values(
         ["CN", "CellType1", "CellType2"]
     ).reset_index(drop=True)
 
@@ -224,7 +225,7 @@ def run_within_cn_analysis(
     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 = read_scores_long(input_file)
     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)]
@@ -232,7 +233,6 @@ def run_within_cn_analysis(
     outputs = {
         "pooled": compute_pooled_within_cn(scores, num_cn, params["minimum_samples"])
     }
-    outputs["pooled"].to_csv(output_dir / "SpearmanWithinCNs.csv", index=False)
     for comparison in build_condition_comparisons(
         scores["Condition"], config.downstream["comparison_mode"]
     ):
@@ -249,11 +249,19 @@ def run_within_cn_analysis(
             max_attempt_multiplier=params["permutation_max_attempt_multiplier"],
             base_seed=config.random_seed,
         )
-        if result.empty:
-            continue
         label = condition_pair_label(comparison["cond_a"], comparison["cond_b"])
-        result.to_csv(output_dir / f"CommunicationPair_{label}.csv", index=False)
         outputs[label] = result
+    # Publish only after all comparisons compute; retired comparison modes and
+    # conditions must not leave tables that a later run can mistake for current.
+    outputs["pooled"].to_csv(output_dir / "SpearmanWithinCNs.csv", index=False)
+    current_names = []
+    for label, result in outputs.items():
+        if label == "pooled":
+            continue
+        name = f"CommunicationPair_{label}.csv"
+        result.to_csv(output_dir / name, index=False)
+        current_names.append(name)
+    prune_csv_outputs(output_dir, "CommunicationPair_label*_vs_*.csv", current_names)
     return outputs