lotsofcells 0.3.0__py3-none-any.whl

lotsofcells/entropy.py

@@ -0,0 +1,354 @@
+"""Symmetric divergence (KL-based) entropy score, plus the 1-class abundance test."""
+from __future__ import annotations
+
+from typing import Optional, Sequence
+
+import numpy as np
+import pandas as pd
+
+from ._stats import (
+    _ensure_cols,
+    _ensure_rows,
+    _table,
+    geom_mean,
+    pseudo_count_arcsin,
+)
+from ._utils import get_metadata
+
+
+def _proportions_arcsin(
+    tab: pd.DataFrame, label_order: Sequence[str], indexes: Sequence[str]
+) -> np.ndarray:
+    """Per-group proportions across covariables (each row sums to 1).
+
+    Mirrors the R `entropyScore` normalisation. Note: in R the *random*
+    contig table is built from `data.frame(covariable, groups)` (covariable
+    first) so `table()` produces shape (ncov, ngroups) and the code applies
+    `apply(., 2, row/sum(row))` followed by `t()` — which is mathematically
+    equivalent to row-normalising on a (ngroups, ncov) matrix. Since
+    `pd.crosstab(groups, covariable)` already returns (ngroups, ncov) here,
+    a single function works for both observed and random tables.
+    """
+    tab = _ensure_rows(tab, label_order)
+    tab = _ensure_cols(tab, indexes)
+    vals = pseudo_count_arcsin(tab.values.astype(float))
+    row_sums = vals.sum(axis=1, keepdims=True)
+    return vals / row_sums
+
+
+def _distance_surprise(p: np.ndarray, q: np.ndarray) -> float:
+    return geom_mean(np.abs(p * np.log2(p / q))) + geom_mean(np.abs(q * np.log2(q / p)))
+
+
+def entropy_score(
+    sc_object,
+    main_variable: str,
+    subtype_variable: str,
+    label_order: Sequence[str],
+    sample_id: Optional[str] = None,
+    permutations: int = 1000,
+    seed: Optional[int] = None,
+    table: Optional[str] = None,
+    plot: bool = True,
+    verbose: bool = True,
+    pdf_file: Optional[str] = None,
+):
+    """Symmetric divergence score for global proportion dysregulation between 2 groups.
+
+    Returns a `pandas.Series` with per-covariable relative entropies plus the
+    summary fields (``entropy_score``, ``p.val``, ``mean.random.entropy``,
+    ``sd.random.entropy``).
+
+    If ``len(label_order) == 1``, runs the 1-class permutation test on
+    ``sample_id`` (analogue of the R `oneClassTest`) and returns a small
+    summary dict instead.
+    """
+    metadata = get_metadata(sc_object, table=table)
+
+    main_vals = metadata[main_variable].astype(str).to_numpy()
+    if not all(l in np.unique(main_vals) for l in label_order):
+        missing = [l for l in label_order if l not in np.unique(main_vals)]
+        raise ValueError(f"Some groups in label_order not in data: {missing}")
+
+    metadata = metadata.loc[np.isin(main_vals, list(label_order))].copy()
+    groups = metadata[main_variable].astype(str).to_numpy()
+    covariable = metadata[subtype_variable].astype(str).to_numpy()
+    rng = np.random.default_rng(seed)
+
+    if len(label_order) == 0:
+        raise ValueError("label_order must be specified.")
+
+    if len(label_order) == 1:
+        if sample_id is None:
+            raise ValueError("In 1-class mode you must specify `sample_id`.")
+        return _one_class_test(
+            metadata,
+            sample_id,
+            covariable,
+            permutations,
+            rng,
+            plot=plot,
+            verbose=verbose,
+            pdf_file=pdf_file,
+        )
+
+    if len(label_order) > 2:
+        raise ValueError(
+            f"Only 2 labels are allowed for entropy estimation, got "
+            f"{len(label_order)}: {label_order}"
+        )
+
+    if verbose:
+        print(
+            "Computing entropy proportion over covariables for groups: "
+            f"{label_order[0]} vs {label_order[1]}"
+        )
+    obs_tab = _table(groups, covariable)
+    indexes = list(obs_tab.columns)
+    contig = _proportions_arcsin(obs_tab, label_order, indexes)
+
+    # Per-covariable relative entropies (matches R apply over rows... in the R it's
+    # apply(contig_tab, 1, function(x) abs(log2((x[1]*log2(x[2]))/(x[1]*log2(x[1])))));
+    # since R contig_tab is rows=labels, columns=covariables, apply over rows iterates
+    # COLUMNS — so we replicate by iterating columns here)
+    rel_entropies = np.empty(len(indexes))
+    for j in range(len(indexes)):
+        x = contig[:, j]
+        with np.errstate(divide="ignore", invalid="ignore"):
+            rel_entropies[j] = np.abs(
+                np.log2((x[0] * np.log2(x[1])) / (x[0] * np.log2(x[0])))
+            )
+
+    obs_score = _distance_surprise(contig[0], contig[1])
+
+    # Build cell-crowd for null sampling
+    if sample_id is not None:
+        samples = metadata[sample_id].astype(str).to_numpy()
+        n_per_sample = (
+            pd.crosstab(pd.Series(groups), pd.Series(samples)).reindex(label_order)
+        )
+        n_per_sample = np.sqrt(n_per_sample)
+        cell_crowd = {}
+        for cond in label_order:
+            row = n_per_sample.loc[cond]
+            cell_crowd[cond] = list(row[row != 0].astype(int).to_numpy())
+    else:
+        counts = pd.Series(groups).value_counts().to_dict()
+        cell_crowd = {l: int(round(np.sqrt(counts.get(l, 0)))) for l in label_order}
+
+    if verbose:
+        print(f"Starting Monte-Carlo simulation with n. permutations: {permutations}")
+
+    null_scores = np.empty(permutations)
+    for i in range(permutations):
+        pieces_cov, pieces_grp = [], []
+        for label in label_order:
+            crowd = cell_crowd[label]
+            if isinstance(crowd, list):
+                for n in crowd:
+                    s = rng.choice(covariable, size=int(n), replace=True)
+                    pieces_cov.append(s)
+                    pieces_grp.append(np.repeat(label, len(s)))
+            else:
+                s = rng.choice(covariable, size=int(crowd), replace=True)
+                pieces_cov.append(s)
+                pieces_grp.append(np.repeat(label, len(s)))
+        cov = np.concatenate(pieces_cov)
+        grp = np.concatenate(pieces_grp)
+        rand_tab = _table(grp, cov)
+        p = _proportions_arcsin(rand_tab, label_order, indexes)
+        null_scores[i] = _distance_surprise(p[0], p[1])
+
+    p_val = float((null_scores >= obs_score).sum() / permutations)
+
+    if plot:
+        try:
+            _plot_entropy(
+                contig=contig,
+                indexes=indexes,
+                label_order=label_order,
+                obs_score=obs_score,
+                null_scores=null_scores,
+                p_val=p_val,
+                subtype_variable=subtype_variable,
+                pdf_file=pdf_file,
+            )
+        except Exception as e:  # noqa: BLE001
+            if verbose:
+                print(f"(Plot skipped: {e})")
+
+    out = pd.Series(rel_entropies, index=indexes)
+    out["entropy_score"] = obs_score
+    out["p.val"] = p_val
+    out["mean.random.entropy"] = float(null_scores.mean())
+    out["sd.random.entropy"] = float(null_scores.std(ddof=1))
+    return out
+
+
+def _plot_entropy(
+    contig, indexes, label_order, obs_score, null_scores, p_val,
+    subtype_variable, pdf_file=None,
+):
+    import matplotlib.pyplot as plt
+    from ._utils import save_to_pdf
+
+    fig, axes = plt.subplots(1, 2, figsize=(12, 5), gridspec_kw={"width_ratios": [3, 1]})
+    ax = axes[0]
+    n = len(indexes)
+    width = 0.35
+    x = np.arange(n)
+    palette = ["#9ECAE1", "#3182BD"]
+    for i, label in enumerate(label_order):
+        ax.bar(x + (i - 0.5) * width, contig[i], width, label=label, color=palette[i])
+    ax.set_xticks(x)
+    ax.set_xticklabels(indexes, rotation=45, ha="right")
+    ax.set_ylabel("proportion")
+    ax.set_title(
+        f"Symmetric Divergence Score: {obs_score:.3f} | p.val.adj: {p_val:.3f}"
+    )
+    ax.legend(title=f"Class: {subtype_variable}")
+
+    ax2 = axes[1]
+    rng = np.random.default_rng(0)
+    jitter = rng.uniform(-0.1, 0.1, size=len(null_scores))
+    ax2.scatter(jitter, null_scores, color="#D5BADB", alpha=0.5, s=15)
+    ax2.axhline(np.median(null_scores), color="#86608E", lw=1)
+    ax2.scatter([0], [obs_score], color="#F08080", s=80, zorder=5)
+    ax2.set_xticks([])
+    ax2.set_ylabel("symmetric divergence")
+    plt.tight_layout()
+    save_to_pdf(fig, pdf_file)
+
+
+def _one_class_test(
+    metadata,
+    sample_id,
+    covariable,
+    permutations,
+    rng,
+    plot=True,
+    verbose=True,
+    pdf_file=None,
+):
+    """Permutation test for sample-level proportion variation in a single condition.
+
+    Departs from R's `oneClassTest` in one important way: the null draws each
+    sample's cells from THAT SAMPLE'S own covariable distribution, not from
+    the global pool. The R version sampled every cell from the global pool,
+    which collapses both random pseudo-groups onto the same global
+    distribution and produces a null that is essentially zero — so the user
+    never observes any spread no matter how heterogeneous the real samples
+    are. Drawing from per-sample pools preserves real per-sample structure
+    and lets random partitions of those samples yield a null distribution
+    whose spread reflects across-sample heterogeneity, which is what this
+    test is meant to assess.
+    """
+    samples = metadata[sample_id].astype(str).to_numpy()
+    obs_tab = _table(samples, covariable)
+    indexes = list(obs_tab.columns)
+    n_per_sample = pd.Series(samples).value_counts()
+    sqrt_n = np.sqrt(n_per_sample)
+    sqrt_n[sqrt_n == 0] = 10
+    cell_crowd = sqrt_n.to_dict()
+
+    # Build a per-sample pool of covariable values (preserves the real cell
+    # composition of each sample for the null draw).
+    sample_pools = {
+        s: covariable[samples == s] for s in n_per_sample.index
+    }
+    unique_samples = list(n_per_sample.index)
+    if len(unique_samples) < 2:
+        raise ValueError(
+            "1-class entropy test needs at least 2 samples in `sample_id`."
+        )
+    n_g1 = max(1, round(len(unique_samples) / 2))
+
+    # Mirror R's iteration count: seq(100) * seq(permutations/10) = 10*perms.
+    n_iter = max(int(permutations) * 10, 100)
+    null_scores = np.empty(n_iter)
+    if verbose:
+        print(f"Starting 1-class Monte-Carlo simulation: {n_iter} iterations")
+
+    for i in range(n_iter):
+        perm = rng.permutation(len(unique_samples))
+        g1 = [unique_samples[k] for k in perm[:n_g1]]
+        g2 = [unique_samples[k] for k in perm[n_g1:]]
+        pieces_cov, pieces_grp = [], []
+        for s in g1:
+            n = max(int(cell_crowd[s]), 1)
+            pool = sample_pools[s]
+            if len(pool) == 0:
+                continue
+            draw = rng.choice(pool, size=n, replace=True)
+            pieces_cov.append(draw)
+            pieces_grp.append(np.repeat("group1", n))
+        for s in g2:
+            n = max(int(cell_crowd[s]), 1)
+            pool = sample_pools[s]
+            if len(pool) == 0:
+                continue
+            draw = rng.choice(pool, size=n, replace=True)
+            pieces_cov.append(draw)
+            pieces_grp.append(np.repeat("group2", n))
+        cov = np.concatenate(pieces_cov)
+        grp = np.concatenate(pieces_grp)
+        rand_tab = _table(grp, cov)
+        p = _proportions_arcsin(rand_tab, ["group1", "group2"], indexes)
+        null_scores[i] = _distance_surprise(p[0], p[1])
+
+    mean_null = float(null_scores.mean())
+    sd_null = float(null_scores.std(ddof=1))
+    median_null = float(np.median(null_scores))
+    cv = float(sd_null / mean_null * 100) if mean_null > 0 else float("inf")
+    if median_null > 0:
+        relative_iqr = float(
+            (np.percentile(null_scores, 75) - np.percentile(null_scores, 25))
+            / median_null
+        )
+    else:
+        relative_iqr = float("nan")
+    if cv <= 35:
+        variation = "Low"
+    elif cv <= 50:
+        variation = "Medium"
+    else:
+        variation = "High"
+
+    if verbose:
+        print(f"Coefficient of Variation: {cv:.2f} %")
+        print(f"Variation across samples is considered: {variation}")
+        print(f"Relative IQR: {relative_iqr:.3f}")
+
+    if plot:
+        try:
+            import matplotlib.pyplot as plt
+            from ._utils import save_to_pdf
+
+            fig, ax = plt.subplots(figsize=(3.5, 5))
+            jitter = rng.uniform(-0.1, 0.1, size=len(null_scores))
+            ax.scatter(jitter, null_scores, color="#D5BADB", alpha=0.5, s=15)
+            ax.axhline(median_null, color="#86608E", lw=1)
+            ax.set_xlim(-0.5, 0.5)
+            lo = float(min(0.0, null_scores.min()))
+            hi = float(null_scores.max())
+            pad = max(1e-3, 0.1 * (hi - lo))
+            ax.set_ylim(lo, hi + pad)
+            ax.set_xticks([])
+            ax.set_ylabel("symmetric divergence (null)")
+            ax.set_title(
+                f"1-class null distribution\n"
+                f"median={median_null:.4f}  CV={cv:.1f}%  ({variation})"
+            )
+            plt.tight_layout()
+            save_to_pdf(fig, pdf_file)
+        except Exception:
+            pass
+
+    return {
+        "cv": cv,
+        "variation": variation,
+        "relative_iqr": relative_iqr,
+        "mean.random.entropy": mean_null,
+        "sd.random.entropy": sd_null,
+        "median.random.entropy": median_null,
+    }

lotsofcells/lotsofcells.py

@@ -0,0 +1,330 @@
+"""Main `lots_of_cells` function: 2-group Monte-Carlo and >2-group Goodman & Kruskal gamma."""
+from __future__ import annotations
+
+from typing import Optional, Sequence
+
+import numpy as np
+import pandas as pd
+
+from ._stats import (
+    _proportions_from_table,
+    _table,
+    asrt,
+    cell_to_gamma,
+    cell_to_gamma_original,
+    cell_to_montecarlo,
+)
+from ._utils import get_metadata
+
+
+def _bh_fdr(pvals: np.ndarray) -> np.ndarray:
+    """Benjamini-Hochberg FDR. Equivalent to R p.adjust(., 'fdr')."""
+    p = np.asarray(pvals, dtype=float)
+    n = len(p)
+    order = np.argsort(p)
+    ranked = p[order] * n / (np.arange(n) + 1)
+    # cummin from the right
+    adj = np.minimum.accumulate(ranked[::-1])[::-1]
+    out = np.empty_like(adj)
+    out[order] = np.clip(adj, 0, 1)
+    return out
+
+
+def _gamma_godkrus(nc: np.ndarray, nd: np.ndarray, denom: float) -> np.ndarray:
+    """Goodman-Kruskal gamma: (nc - nd) / exp(mean(log(N))) — N is denom (scalar here)."""
+    return (nc - nd) / np.exp(np.log(denom))
+
+
+def lots_of_cells(
+    sc_object,
+    main_variable: str,
+    subtype_variable: str,
+    label_order: Sequence[str],
+    sample_id: Optional[str] = None,
+    permutations: int = 1000,
+    seed: Optional[int] = None,
+    table: Optional[str] = None,
+    plot: bool = True,
+    verbose: bool = True,
+    pdf_file: Optional[str] = None,
+) -> pd.DataFrame:
+    """Compute proportion tests on single-cell metadata.
+
+    Parameters
+    ----------
+    sc_object
+        AnnData / SpatialData / MuData / pandas.DataFrame.
+    main_variable
+        Column in ``.obs`` (or DataFrame) with the main grouping (e.g.
+        ``"condition"``).
+    subtype_variable
+        Column with the covariable to test (e.g. ``"cell_type"``).
+    label_order
+        Order of labels in ``main_variable`` to compare.
+        - 2 labels  → log2 fold-change of arcsin-sqrt proportions, with
+          Monte-Carlo null distribution.
+        - >2 labels → Goodman & Kruskal's gamma rank correlation.
+    sample_id
+        Optional column with sample IDs. When set, the null distribution
+        accounts for per-sample heterogeneity.
+    permutations
+        Number of Monte-Carlo permutations.
+    seed
+        Random seed for reproducibility.
+    table
+        For SpatialData/MuData with multiple tables/modalities.
+    plot
+        If True and 2 labels, show the abundance test plot.
+
+    Returns
+    -------
+    pandas.DataFrame with one row per covariable level.
+    """
+    metadata = get_metadata(sc_object, table=table)
+
+    main_vals = metadata[main_variable].astype(str).to_numpy()
+    if not all(l in np.unique(main_vals) for l in label_order):
+        missing = [l for l in label_order if l not in np.unique(main_vals)]
+        raise ValueError(f"Some groups in label_order not found in data: {missing}")
+
+    mask = np.isin(main_vals, list(label_order))
+    metadata = metadata.loc[mask].copy()
+    groups = metadata[main_variable].astype(str).to_numpy()
+    covariable = metadata[subtype_variable].astype(str).to_numpy()
+
+    rng = np.random.default_rng(seed)
+    min_cells = 10
+
+    if len(label_order) < 2:
+        raise ValueError("label_order must have at least 2 entries.")
+
+    if len(label_order) > 2:
+        return _gamma_path(
+            covariable, groups, label_order, permutations, min_cells, rng, verbose
+        )
+
+    return _montecarlo_path(
+        metadata,
+        covariable,
+        groups,
+        label_order,
+        sample_id,
+        main_variable,
+        subtype_variable,
+        permutations,
+        min_cells,
+        rng,
+        verbose,
+        plot,
+        pdf_file,
+    )
+
+
+# --- 2-condition Monte Carlo path ----------------------------------------------------
+
+def _montecarlo_path(
+    metadata,
+    covariable,
+    groups,
+    label_order,
+    sample_id,
+    main_variable,
+    subtype_variable,
+    permutations,
+    min_cells,
+    rng,
+    verbose,
+    plot,
+    pdf_file=None,
+):
+    if verbose:
+        print(f"Only 2 groups detected. Computing FC for {label_order[0]} vs {label_order[1]}")
+
+    if sample_id is not None:
+        if verbose:
+            print(f"Additional sub-level for testing: {sample_id}")
+        samples = metadata[sample_id].astype(str).to_numpy()
+        n_per_sample = pd.crosstab(pd.Series(groups), pd.Series(samples)).reindex(label_order)
+
+        # Synthetic samples (per-condition resampling) — mirrors R lotsOfCells.R
+        synth_meta = metadata[[main_variable, subtype_variable, sample_id]].copy()
+        mult_factor = 2
+        new_samples = int(round((n_per_sample != 0).sum(axis=1).mean())) * mult_factor
+        synth_rows = []
+        for i in range(1, new_samples + 1):
+            for cond in label_order:
+                row = n_per_sample.loc[cond]
+                nonzero = row[row != 0]
+                if len(nonzero) == 0:
+                    continue
+                n = int(rng.integers(int(nonzero.min()), int(nonzero.max()) + 1))
+                pool = covariable[groups == cond]
+                synth_cov = rng.choice(pool, size=n, replace=True)
+                synth_rows.append(pd.DataFrame({
+                    main_variable: cond,
+                    subtype_variable: synth_cov,
+                    sample_id: f"synthetic_sample_{cond}_{i}",
+                }))
+        if synth_rows:
+            synth_meta = pd.concat([synth_meta, *synth_rows], ignore_index=True)
+
+        groups_synth = synth_meta[main_variable].astype(str).to_numpy()
+        covariable_synth = synth_meta[subtype_variable].astype(str).to_numpy()
+
+        cell_crowd = {}
+        for cond in label_order:
+            row = n_per_sample.loc[cond]
+            nonzero = row[row != 0].to_numpy()
+            cell_crowd[cond] = list(np.maximum(np.sqrt(nonzero), min_cells).astype(int))
+    else:
+        groups_synth = groups
+        covariable_synth = covariable
+        counts_per_group = pd.Series(groups).value_counts().to_dict()
+        cell_crowd = {
+            l: int(round(max(np.sqrt(counts_per_group.get(l, 0)), min_cells)))
+            for l in label_order
+        }
+
+    # Observed fold-change
+    obs_tab = _table(groups, covariable)
+    p_obs = _proportions_from_table(obs_tab, label_order, list(obs_tab.columns), pseudo=True)
+    indexes = list(obs_tab.columns)
+    obs_fc = np.log2(asrt(p_obs[0]) / asrt(p_obs[1]))
+
+    if verbose:
+        print("- Starting Monte-Carlo simulation of fold changes")
+
+    null_fcs = np.empty((permutations, len(indexes)))
+    real_fcs = np.empty((permutations, len(indexes)))
+    for i in range(permutations):
+        m, o = cell_to_montecarlo(
+            covariable_synth, groups_synth, label_order, indexes, cell_crowd, rng
+        )
+        null_fcs[i] = m
+        real_fcs[i] = o
+
+    higher = (np.sum(null_fcs >= obs_fc, axis=0) + 1) / (permutations + 1)
+    lower = (np.sum(null_fcs <= obs_fc, axis=0) + 1) / (permutations + 1)
+    p_vals = np.where(obs_fc > 0, higher, lower)
+    p_adj = _bh_fdr(p_vals)
+    sd_mc = null_fcs.std(axis=0, ddof=1)
+    ci_low = np.quantile(real_fcs, 0.025, axis=0)
+    ci_high = np.quantile(real_fcs, 0.975, axis=0)
+
+    pct1 = np.round(p_obs[0], 3)
+    pct2 = np.round(p_obs[1], 3)
+    table_results = pd.DataFrame(
+        {
+            "groupFC": obs_fc,
+            f"percent_in_{label_order[0]}": pct1,
+            f"percent_in_{label_order[1]}": pct2,
+            "p.adj": np.round(p_adj, 5),
+            "sd.montecarlo": sd_mc,
+            "CI95low": ci_low,
+            "CI95high": ci_high,
+        },
+        index=indexes,
+    )
+
+    # Ensure CIs encompass observed
+    bad_low = ~(table_results["CI95low"] < table_results["groupFC"])
+    table_results.loc[bad_low, "CI95low"] = table_results.loc[bad_low, "groupFC"]
+    bad_high = ~(table_results["CI95high"] > table_results["groupFC"])
+    table_results.loc[bad_high, "CI95high"] = table_results.loc[bad_high, "groupFC"]
+
+    if plot:
+        try:
+            from .plots import plot_abundance_test
+            plot_abundance_test(
+                table_results,
+                subtype_variable=subtype_variable,
+                pdf_file=pdf_file,
+            )
+        except Exception as e:  # noqa: BLE001
+            if verbose:
+                print(f"(Plot skipped: {e})")
+
+    return table_results
+
+
+# --- >2-condition Goodman-Kruskal gamma path -----------------------------------------
+
+def _gamma_path(covariable, groups, label_order, permutations, min_cells, rng, verbose):
+    if verbose:
+        print(
+            "More than 2 groups detected. Computing Goodman-Kruskal gamma rank "
+            f"correlation in order: {' vs '.join(label_order)}"
+        )
+
+    counts_per_group = pd.Series(groups).value_counts().to_dict()
+    cell_crowd = {
+        l: int(round(max(np.sqrt(counts_per_group.get(l, 0)), min_cells)))
+        for l in label_order
+    }
+    kendall_denom = (len(label_order) * (len(label_order) - 1)) / 2
+    rank_index = np.arange(1, len(label_order) + 1)
+
+    obs_tab = _table(groups, covariable)
+    indexes = list(obs_tab.columns)
+
+    # Observed gamma: aggregate over `permutations` subsamplings of the original data
+    nc_orig = np.zeros(len(indexes))
+    nd_orig = np.zeros(len(indexes))
+    for _ in range(permutations):
+        nc, nd = cell_to_gamma_original(
+            covariable, groups, label_order, indexes, cell_crowd, rank_index, rng
+        )
+        nc_orig += nc
+        nd_orig += nd
+    obs_gamma = _gamma_godkrus(nc_orig, nd_orig, kendall_denom * permutations)
+
+    # Confidence interval via 10 sub-samples of size 100
+    sub_gammas = np.empty((10, len(indexes)))
+    for s in range(10):
+        nc_s = np.zeros(len(indexes))
+        nd_s = np.zeros(len(indexes))
+        for _ in range(100):
+            nc, nd = cell_to_gamma_original(
+                covariable, groups, label_order, indexes, cell_crowd, rank_index, rng
+            )
+            nc_s += nc
+            nd_s += nd
+        sub_gammas[s] = _gamma_godkrus(nc_s, nd_s, kendall_denom * 100)
+    ci_low = np.nanquantile(sub_gammas, 0.025, axis=0)
+    ci_high = np.nanquantile(sub_gammas, 0.975, axis=0)
+
+    if verbose:
+        print("- Starting gamma rank permutation analysis, this can take a while...")
+
+    n_random_observations = 10
+    null_gamma = np.empty((permutations, len(indexes)))
+    for p in range(permutations):
+        nc_p = np.zeros(len(indexes))
+        nd_p = np.zeros(len(indexes))
+        for _ in range(n_random_observations):
+            nc, nd = cell_to_gamma(
+                covariable, groups, label_order, indexes, cell_crowd, rank_index, rng
+            )
+            nc_p += nc
+            nd_p += nd
+        null_gamma[p] = _gamma_godkrus(nc_p, nd_p, kendall_denom * n_random_observations)
+
+    with np.errstate(invalid="ignore"):
+        higher = np.sum(null_gamma >= obs_gamma, axis=0) / permutations
+        lower = np.sum(null_gamma <= obs_gamma, axis=0) / permutations
+    p_vals = np.where(obs_gamma > 0, higher, lower)
+    p_adj = _bh_fdr(np.nan_to_num(p_vals, nan=1.0))
+
+    # Per-condition proportions (unnormalised contig table -> per-row proportions)
+    contig_tab = _table(groups, covariable).reindex(label_order)
+    proportions = contig_tab.div(contig_tab.sum(axis=1), axis=0).reindex(
+        index=label_order, columns=indexes
+    )
+
+    df = pd.DataFrame({"groupGammaCor": np.round(obs_gamma, 4)}, index=indexes)
+    for l in label_order:
+        df[f"percent_in_{l}"] = np.round(proportions.loc[l].values, 3)
+    df["p.adj"] = np.round(p_adj, 5)
+    df["CI95low"] = np.round(ci_low, 4)
+    df["CI95high"] = np.round(ci_high, 4)
+    return df