isoends 1.0.0__py3-none-any.whl

isoends/R/limma_moderated_t.R

@@ -0,0 +1,30 @@
+#!/usr/bin/env Rscript
+# limma moderated t-test, one value per unit of replication.
+#
+# Usage: Rscript limma_moderated_t.R values.tsv out.tsv ROBUST [GROUPS]
+#   values.tsv  features x units, first column "feature"; NA for missing
+#   ROBUST      TRUE or FALSE (eBayes robust = ...)
+#   GROUPS      optional, one 0 (control) or 1 (treated) per unit, comma-separated: tests treated - control;
+#               without it, tests each feature's mean against zero
+suppressPackageStartupMessages(library(limma))
+args <- commandArgs(trailingOnly = TRUE)
+X <- as.matrix(read.delim(args[1], row.names = 1, check.names = FALSE))
+robust <- toupper(args[3]) == "TRUE"
+if (length(args) >= 4) {
+  design <- cbind(control = 1, treated = as.numeric(strsplit(args[4], ",")[[1]]))
+  coef <- 2
+} else {
+  design <- matrix(1, ncol(X), 1, dimnames = list(colnames(X), "mean"))
+  coef <- 1
+}
+fit <- eBayes(lmFit(X, design), robust = robust)
+res <- topTable(fit, coef = coef, number = Inf, sort.by = "none")
+res$n_units <- rowSums(!is.na(X))
+res$df_residual <- fit$df.residual
+res$df_prior <- rep_len(fit$df.prior, nrow(X))
+res$df_total <- fit$df.total
+res$s2_prior <- rep_len(fit$s2.prior, nrow(X))
+res$s2_post <- fit$s2.post
+write.table(data.frame(feature = rownames(res), res, check.names = FALSE), args[2], sep = "\t", quote = FALSE,
+            row.names = FALSE)
+cat(sprintf("%s (%s)", as.character(packageVersion("limma")), R.version.string))

isoends/__init__.py

@@ -0,0 +1,12 @@
+"""IsoEnds: poly(A) tail length, alternative polyadenylation and transcription start sites from IsoForge runs,
+tested over biological replicates.
+
+    import isoends as ie
+    res = ie.load("isoends_out")
+    res.volcano("tandem")
+"""
+__version__ = "1.0.0"
+
+from .api import ANALYSES, Experiment, Results, load  # noqa: E402
+
+__all__ = ["ANALYSES", "Experiment", "Results", "load", "__version__"]

isoends/annotation.py

@@ -0,0 +1,95 @@
+"""Per-run transcript annotation: structure keys, and categories from the reference and the characterised GTF.
+
+Categories: protein coding, retained intron, lncRNA, NMD, other, unclassified.
+  Annotated models (ENST) take their reference transcript type.
+  Novel models take their SQANTI3 class from the characterised GTF of isoforge-characterize, in this order:
+  intron retention -> retained intron; predicted NMD -> NMD; coding -> protein coding; associated with a lncRNA ->
+  lncRNA; else other. Without a characterised GTF that describes this run they stay unclassified.
+
+The characterised GTF is used only when it describes this run: at least `min_present` of the reads lie on models
+present in it and at least `min_chain_agreement` of the shared models have identical exon chains.
+"""
+from __future__ import annotations
+
+import numpy as np
+import pandas as pd
+
+from . import gtf as G
+
+CATEGORIES = ("protein coding", "retained intron", "lncRNA", "NMD")
+_REFERENCE_TYPES = {"protein_coding": "protein coding", "retained_intron": "retained intron", "lncRNA": "lncRNA",
+                    "nonsense_mediated_decay": "NMD"}
+ISOFORGE_ATTRS = ["transcript_id", "gene_id", "gene_name", "transcript_type"]
+SQANTI_ATTRS = ["structural_category", "subcategory", "coding", "predicted_NMD", "is_NMD", "is_IR", "is_lncRNA",
+                "ref_transcript_type", "associated_gene", "associated_transcript", "ORF_length", "CDS_length",
+                "CDS_start", "CDS_end"]
+
+
+def _true(s: pd.Series) -> np.ndarray:
+    return s.astype("string").str.upper().isin(["TRUE", "T", "1", "YES"]).fillna(False).to_numpy(bool)
+
+
+def _is(s: pd.Series, value: str) -> np.ndarray:
+    return s.astype("string").eq(value).fillna(False).to_numpy(bool)
+
+
+def run_transcripts(isoforge_gtf, characterised_gtf=None, model_read_counts: pd.Series | None = None,
+                    min_present: float = 0.5, min_chain_agreement: float = 0.95):
+    """(transcripts, check, exons). transcripts: one row per IsoForge model with gene_id, gene_name, n_exons,
+    structure_key, category, category_source and the SQANTI3 fields. check: how well the characterised GTF describes
+    the run. exons: the models' exons. model_read_counts: reads per transcript_id, weighting the check."""
+    exons = G.model_exons(isoforge_gtf)
+    tx = G.model_attributes(isoforge_gtf, ISOFORGE_ATTRS).merge(G.structure_table(exons), on="transcript_id",
+                                                                 how="left")
+    tx["gene_id"] = G.strip_version(tx.gene_id)
+    tx["annotated"] = tx.transcript_id.astype(str).str.startswith("ENST").to_numpy()
+    check: dict = dict(characterised_gtf=str(characterised_gtf) if characterised_gtf else None)
+    char = None
+    if characterised_gtf is not None:
+        char = G.model_attributes(characterised_gtf, ["transcript_id"] + SQANTI_ATTRS)
+        chains = G.structure_table(G.model_exons(characterised_gtf))[["transcript_id", "exon_chain"]]
+        both = tx[["transcript_id", "exon_chain"]].merge(chains.rename(columns={"exon_chain": "char_chain"}),
+                                                         on="transcript_id")
+        weights = (model_read_counts if model_read_counts is not None
+                   else pd.Series(1.0, index=tx.transcript_id)).astype(float)
+        with_reads = weights[(weights > 0) & (weights.index != "")]
+        total = with_reads.sum()
+
+        def share(ids) -> float:
+            return float(with_reads[with_reads.index.isin(set(ids))].sum() / total) if len(with_reads) else np.nan
+        agree = both.exon_chain == both.char_chain
+        characterised = char.structural_category.notna()
+        check.update(
+            share_reads_on_isoforge_gtf_models=share(tx.transcript_id),
+            n_models_with_reads=int(len(with_reads)),
+            share_models_present=float(with_reads.index.isin(set(char.transcript_id)).mean())
+            if len(with_reads) else np.nan,
+            share_reads_present=share(char.transcript_id),
+            n_models_compared=int(len(both)),
+            share_chain_agreement=float(agree.mean()) if len(both) else np.nan,
+            n_models_characterised=int(characterised.sum()),
+            share_reads_characterised=share(char.transcript_id[characterised]))
+        check["in_sync"] = bool(check["share_chain_agreement"] >= min_chain_agreement
+                                and check["share_reads_present"] >= min_present)
+        check["rule"] = (f"used when >= {min_present:.0%} of reads are on models present in it and >= "
+                         f"{min_chain_agreement:.0%} of the shared models have identical exon chains")
+        char = char[~char.transcript_id.isin(set(both.transcript_id[~agree]))] if check["in_sync"] else None
+    else:
+        check.update(in_sync=False, rule="no characterised GTF: novel models unclassified")
+    if char is not None:
+        tx = tx.merge(char, on="transcript_id", how="left")
+    else:
+        for c in SQANTI_ATTRS:
+            tx[c] = pd.NA
+    reference_type = tx.ref_transcript_type.fillna(tx.transcript_type)
+    tx["reference_type"] = np.where(tx.annotated, reference_type.astype("string").fillna(""), "")
+    characterised = ~tx.annotated & tx.structural_category.notna()
+    ir = _true(tx.is_IR) | _is(tx.subcategory, "intron_retention")
+    nmd = _true(tx.predicted_NMD) | _true(tx.is_NMD)
+    coding = _is(tx.coding, "coding")
+    lnc = _is(tx.transcript_type, "lncRNA") | _is(tx.ref_transcript_type, "lncRNA") | _true(tx.is_lncRNA)
+    novel = np.select([ir, nmd, coding, lnc], ["retained intron", "NMD", "protein coding", "lncRNA"], default="other")
+    known = pd.Series(tx.reference_type).map(_REFERENCE_TYPES).fillna("other").to_numpy()
+    tx["category"] = np.where(tx.annotated, known, np.where(characterised, novel, "unclassified"))
+    tx["category_source"] = np.where(tx.annotated, "reference", np.where(characterised, "SQANTI3", "none"))
+    return tx, check, exons

isoends/apa.py

@@ -0,0 +1,267 @@
+"""Tests of site usage: a gene's two most used sites (tandem 3'UTR sites, or two promoters) and classes of sites
+against the reference sites.
+
+Within a unit, a paired design is tested with the Cochran-Mantel-Haenszel test on the event x condition tables of
+each replicate pair, and an unpaired design with the moderated two-sample t-test on each sample's usage. Across
+units, the per-unit change is tested with the moderated one-sample t-test. q is over the genes tested.
+"""
+from __future__ import annotations
+
+import numpy as np
+import pandas as pd
+
+from .sites import INTRONIC, as_mask, distance_from_stop, same_exon, split_by_model_intron
+from .stats import bh, cmh, mantel_haenszel_or, moderated_one_sample, moderated_two_sample
+
+APA_CLASSES = {"composite exon": ("composite exon",), "skipped exon": ("skipped exon",),
+               "internal exonic": ("internal exonic",)}
+IPA = {"intronic (all)": INTRONIC}
+
+
+def _site_counts(sites: pd.DataFrame, counts: pd.DataFrame, datasets) -> pd.DataFrame:
+    """The clusters with one read-count column per dataset and their total (reads_unit); clusters without reads in
+    these datasets are dropped."""
+    w = counts[counts.dataset.isin(datasets)].pivot_table(index="cluster", columns="dataset", values="reads",
+                                                          aggfunc="sum", fill_value=0)
+    s = sites.set_index("cluster").join(w.reindex(columns=list(datasets), fill_value=0), how="inner")
+    s["reads_unit"] = s[list(datasets)].sum(axis=1)
+    return s[s.reads_unit > 0]
+
+
+def _ratio(x, y):
+    with np.errstate(invalid="ignore", divide="ignore"):
+        return np.where(y > 0, x / np.maximum(y, 1), np.nan)
+
+
+def usage_test(event: pd.DataFrame, other: pd.DataFrame, design, params, stats_params, stem: str,
+               up: str) -> pd.DataFrame:
+    """Test the usage event / (event + other) between the conditions of one unit, one row per feature.
+
+    event, other: read counts, features x datasets. Returns reads and usage per condition, delta_<stem>, the test's
+    statistic and p, and the replicates behind it; per pair for a paired design (n_pairs_<up>, delta_<stem>_pair<k>,
+    mh_odds_ratio, chi2), per sample for an unpaired one (t, n_samples_control, n_samples_treated). The unpaired
+    test takes the samples with `min_reads_sample` reads, for features with event and other reads and two such
+    samples per condition; when the robust variance prior cannot be estimated the non-robust one is used."""
+    ctrl, trt = list(design.control), list(design.treated)
+    a, b = event[ctrl].to_numpy(float), other[ctrl].to_numpy(float)
+    c, d = event[trt].to_numpy(float), other[trt].to_numpy(float)
+    rc, rt = (a + b).sum(axis=1), (c + d).sum(axis=1)
+    out = pd.DataFrame({"event_reads_control": a.sum(axis=1), "other_reads_control": b.sum(axis=1),
+                        "event_reads_treated": c.sum(axis=1), "other_reads_treated": d.sum(axis=1),
+                        "reads_control": rc, "reads_treated": rt,
+                        f"{stem}_control": _ratio(a.sum(axis=1), rc), f"{stem}_treated": _ratio(c.sum(axis=1), rt)},
+                       index=event.index)
+    out[f"delta_{stem}"] = out[f"{stem}_treated"] - out[f"{stem}_control"]
+    out["design"] = "paired" if design.paired else "unpaired"
+    if design.paired:
+        per_pair = _ratio(c, c + d) - _ratio(a, a + b)
+        out["n_pairs"] = len(design.pairs)
+        out[f"n_pairs_{up}"] = (per_pair > 0).sum(axis=1)
+        out["pairs"] = ";".join(label for label, _, _ in design.pairs)
+        for k in range(len(design.pairs)):
+            out[f"delta_{stem}_pair{k + 1}"] = per_pair[:, k]
+        out["mh_odds_ratio"] = mantel_haenszel_or(a, b, c, d)
+        out["chi2"], out["p"] = cmh(a, b, c, d)
+        return out
+    uc = pd.DataFrame(np.where(a + b >= params.min_reads_sample, _ratio(a, a + b), np.nan), index=event.index)
+    ut = pd.DataFrame(np.where(c + d >= params.min_reads_sample, _ratio(c, c + d), np.nan), index=event.index)
+    out["n_samples_control"], out["n_samples_treated"] = uc.notna().sum(axis=1), ut.notna().sum(axis=1)
+    testable = ((out.n_samples_control >= 2) & (out.n_samples_treated >= 2)
+                & (out.event_reads_control + out.event_reads_treated > 0)
+                & (out.other_reads_control + out.other_reads_treated > 0))
+    kw = dict(backend=stats_params.limma_backend, rscript=stats_params.rscript)
+    try:
+        res = moderated_two_sample(uc[testable], ut[testable], robust=stats_params.robust, **kw)
+    except (ValueError, RuntimeError):
+        res = moderated_two_sample(uc[testable], ut[testable], robust=False, **kw)
+    out["t"], out["p"] = res.t.reindex(out.index), res.p.reindex(out.index)
+    return out
+
+
+def top_two_within_unit(unit: str, sites: pd.DataFrame, counts: pd.DataFrame, design, params, stats_params,
+                        candidates: pd.Series, gene_names: pd.Series | None = None) -> pd.DataFrame:
+    """Per gene, its two most used candidate sites in the unit (equally used sites: the lower coordinate first) and
+    the test of distal usage between the conditions.
+
+    sites: the run's classified clusters; counts: cluster, dataset, reads; candidates: boolean per cluster (indexed
+    by cluster). PDUI = distal / (proximal + distal) reads. Genes with fewer than `min_reads` reads at the two sites
+    in a condition, or without a test, are dropped."""
+    s = _site_counts(sites, counts, design.datasets)
+    s = s[candidates.reindex(s.index).fillna(False).to_numpy(bool)].copy()
+    s["order"] = np.where(s.strand == "+", s.site, -s.site)
+    n_sites = s.groupby("gene_id").size()
+    s = s[s.gene_id.isin(n_sites.index[n_sites >= 2])].reset_index()
+    if s.empty:
+        return pd.DataFrame()
+    two = (s.sort_values(["gene_id", "reads_unit", "site"], ascending=[True, False, True], kind="stable")
+           .groupby("gene_id").head(2).sort_values(["gene_id", "order"], kind="stable"))
+    prox = two.groupby("gene_id").head(1).set_index("gene_id")
+    dist = two.groupby("gene_id").tail(1).set_index("gene_id").loc[prox.index]
+    test = usage_test(dist[design.datasets], prox[design.datasets], design, params, stats_params, "pdui", "distal")
+    test = test.rename(columns={"event_reads_control": "reads_distal_control",
+                                "other_reads_control": "reads_proximal_control",
+                                "event_reads_treated": "reads_distal_treated",
+                                "other_reads_treated": "reads_proximal_treated",
+                                "mh_odds_ratio": "mh_odds_ratio_distal"})
+    out = pd.DataFrame({"unit": unit, "gene_id": prox.index, "chrom": prox.chrom.to_numpy(),
+                        "strand": prox.strand.to_numpy(), "n_utr_sites": n_sites.reindex(prox.index).to_numpy(),
+                        "proximal_cluster": prox.cluster.to_numpy(), "distal_cluster": dist.cluster.to_numpy(),
+                        "proximal_site": prox.site.to_numpy(), "distal_site": dist.site.to_numpy(),
+                        "proximal_hexamer": prox.hexamer.to_numpy(), "distal_hexamer": dist.hexamer.to_numpy()})
+    out = pd.concat([out, test.reset_index(drop=True)], axis=1)
+    out["utr_span_nt"] = (out.distal_site - out.proximal_site).abs()
+    out["length_gained_nt"] = out.delta_pdui * out.utr_span_nt
+    if gene_names is not None:
+        out.insert(2, "gene_name", out.gene_id.map(gene_names).fillna(""))
+    ok = (out.reads_control >= params.min_reads) & (out.reads_treated >= params.min_reads) & out.p.notna()
+    return out[ok].reset_index(drop=True)
+
+
+def tandem_candidates(sites: pd.DataFrame, params) -> pd.Series:
+    """The clusters a tandem 3'UTR pair is chosen from, as a boolean indexed by cluster."""
+    if params.tandem_sites == "terminal":
+        chosen = sites.site_class == "terminal"
+    elif params.tandem_sites == "three_prime_utr":
+        chosen = sites.feature == "three_prime_utr"
+    else:
+        raise ValueError(f"tandem_sites must be 'terminal' or 'three_prime_utr', not {params.tandem_sites!r}")
+    return pd.Series(chosen.to_numpy(), index=sites.cluster)
+
+
+def annotate_tandem(t: pd.DataFrame, ref: dict, model_exons: pd.DataFrame, terminal: pd.DataFrame,
+                    params) -> pd.DataFrame:
+    """Add the same-exon check (same_exon, share_distal_models_split, exclusion_reason, is_tandem), q over the
+    unit's tandem genes and each site's distance from the stop codon."""
+    if t.empty:
+        return t
+    t = t.copy()
+    q = t.rename(columns={"proximal_site": "proximal", "distal_site": "distal"})
+    t["same_exon"] = same_exon(q, ref["exons"], params.downstream_nt).array
+    t["share_distal_models_split"] = split_by_model_intron(q, model_exons, terminal, params.model_window_nt).to_numpy()
+    reason = np.select([as_mask(t.same_exon.eq(False)), as_mask(t.share_distal_models_split > 0.5)],
+                       ["no annotated exon holds both sites", "the distal-site models splice over the proximal site"],
+                       default="")
+    t["exclusion_reason"] = reason if params.same_exon_check else ""
+    t["is_tandem"] = t.exclusion_reason == ""
+    t["q"] = np.nan
+    t.loc[t.is_tandem, "q"] = bh(t.loc[t.is_tandem, "p"])
+    for side in ("proximal", "distal"):
+        t[f"{side}_from_stop_nt"] = distance_from_stop(t.gene_id, t[f"{side}_site"], ref["canonical"], ref["stop"],
+                                                       params.downstream_nt)
+    return t
+
+
+def site_models(rows: pd.DataFrame, site_cols, model_reads: pd.DataFrame, terminal: pd.DataFrame,
+                window_nt: int = 100) -> pd.DataFrame:
+    """For each row and site column: the best-supported model of the gene ending within `window_nt` of the site,
+    with its reads per condition. model_reads: gene, transcript, reads_control, reads_treated."""
+    out = pd.DataFrame(index=rows.index)
+    mr = model_reads.merge(terminal[["transcript_id", "site"]].rename(columns={"transcript_id": "transcript",
+                                                                                "site": "end3"}), on="transcript")
+    mr["total"] = mr.reads_control + mr.reads_treated
+    for col in site_cols:
+        q = rows[["gene_id", col]].rename(columns={col: "pos"}).assign(row=rows.index)
+        m = q.merge(mr, left_on="gene_id", right_on="gene")
+        m = m[(m.end3 - m.pos).abs() <= window_nt]
+        best = m.sort_values(["row", "total", "transcript"], ascending=[True, False, True]).drop_duplicates("row")
+        best = best.set_index("row")
+        stem = col.replace("_site", "")
+        out[f"{stem}_model"] = best.transcript.reindex(rows.index)
+        out[f"{stem}_model_reads_control"] = best.reads_control.reindex(rows.index)
+        out[f"{stem}_model_reads_treated"] = best.reads_treated.reindex(rows.index)
+    return out
+
+
+def match_pairs(t: pd.DataFrame, tol: int = 50, valid: str | None = None) -> pd.DataFrame:
+    """Across units: each gene's reference proximal / distal pair, the pair matched within `tol` nt at both ends by
+    the most units (ties: more reads), and same_pair for the units whose pair matches it. With `valid`, the
+    reference is chosen among the rows where that column is true."""
+    t = t.copy()
+    t["reference_proximal"] = np.nan
+    t["reference_distal"] = np.nan
+    t["same_pair"] = False
+    reads = (t.reads_control + t.reads_treated).to_numpy()
+    usable = t[valid].to_numpy(bool) if valid else np.ones(len(t), bool)
+    position = pd.Series(np.arange(len(t)), index=t.index)
+    for _, idx in t.groupby("gene_id").groups.items():
+        rows = position[idx].to_numpy()
+        p, d = t.proximal_site.to_numpy()[rows], t.distal_site.to_numpy()[rows]
+        ok = usable[rows] if usable[rows].any() else np.ones(len(rows), bool)
+        m = (np.abs(p[:, None] - p[None, :]) <= tol) & (np.abs(d[:, None] - d[None, :]) <= tol)
+        score = np.where(ok, (m & ok[None, :]).sum(axis=1), -1)
+        best = np.lexsort((-reads[rows], -score))[0]
+        t.loc[idx, "reference_proximal"] = p[best]
+        t.loc[idx, "reference_distal"] = d[best]
+        t.loc[idx, "same_pair"] = m[best]
+    return t
+
+
+def across_units(table: pd.DataFrame, value: str, min_units: int, stats_params, up_label: str, down_label: str,
+                 extra: dict | None = None) -> pd.DataFrame:
+    """Moderated one-sample t-test of one value per gene and unit over the units, for genes measured in at least
+    `min_units` units. table: gene_id, unit, `value` and optionally q_within. Returns per gene: mean_<value>, t, p,
+    q, n_units, median_<value>, the units moving each way and n_units_q_within."""
+    if table.empty:
+        return pd.DataFrame()
+    X = table.pivot_table(index="gene_id", columns="unit", values=value, aggfunc="first")
+    X = X[X.notna().sum(axis=1) >= min_units]
+    if X.empty:
+        return pd.DataFrame()
+    res = moderated_one_sample(X, robust=stats_params.robust, backend=stats_params.limma_backend,
+                               rscript=stats_params.rscript)
+    estimator = res.attrs.get("estimator", "")
+    res = res.rename(columns={"mean": f"mean_{value}"})
+    X = X.reindex(res.index)
+    res[f"median_{value}"] = X.median(axis=1)
+    res[f"n_units_{up_label}"] = (X > 0).sum(axis=1)
+    res[f"n_units_{down_label}"] = (X < 0).sum(axis=1)
+    if "q_within" in table:
+        sig = table[table.q_within < stats_params.alpha].groupby("gene_id").size()
+        res["n_units_q_within"] = sig.reindex(res.index).fillna(0).astype(int)
+    for k, v in (extra or {}).items():
+        res[k] = v.reindex(res.index)
+    res = res.rename_axis("gene_id").reset_index()
+    res.attrs["estimator"] = estimator
+    return res
+
+
+def class_within_unit(unit: str, sites: pd.DataFrame, counts: pd.DataFrame, design, label: str, in_class: pd.Series,
+                      params, stats_params, gene_names: pd.Series | None = None, reference: str = "terminal",
+                      class_column: str = "apa_class") -> pd.DataFrame:
+    """Per gene: reads at the sites of one class against reads at the `reference` sites, tested between the
+    conditions of the unit; q over the genes tested. in_class: boolean per cluster (indexed by cluster)."""
+    s = _site_counts(sites, counts, design.datasets)
+    chosen = in_class.reindex(s.index).fillna(False).to_numpy(bool)
+    s["side"] = np.where(chosen, "class", np.where(s.site_class == reference, "reference", ""))
+    s = s[s.side != ""]
+    if s.empty:
+        return pd.DataFrame()
+    by = s.groupby(["gene_id", "side"])[design.datasets].sum()
+    genes = by.index.get_level_values(0).unique()
+    by = by.reindex(pd.MultiIndex.from_product([genes, ["class", "reference"]])).fillna(0)
+    test = usage_test(by.xs("class", level=1), by.xs("reference", level=1), design, params, stats_params, "share",
+                      "up")
+    test = test.rename(columns={"event_reads_control": "class_reads_control",
+                                "other_reads_control": "reference_reads_control",
+                                "event_reads_treated": "class_reads_treated",
+                                "other_reads_treated": "reference_reads_treated",
+                                "mh_odds_ratio": "mh_odds_ratio_class"})
+    cls = s[s.side == "class"].reset_index()
+    main = (cls.sort_values(["gene_id", "reads_unit", "site"], ascending=[True, False, True])
+            .drop_duplicates("gene_id").set_index("gene_id").reindex(genes))
+    out = pd.DataFrame({"unit": unit, "gene_id": genes, class_column: label})
+    out = pd.concat([out, test.reset_index(drop=True)], axis=1)
+    out["class_reads"] = out.class_reads_control + out.class_reads_treated
+    out["n_class_sites"] = cls.groupby("gene_id").size().reindex(genes).fillna(0).astype(int).to_numpy()
+    out["main_site"] = main.site.to_numpy()
+    out["main_site_class"] = main.site_class.to_numpy()
+    out["main_site_reads"] = main.reads_unit.to_numpy()
+    out["main_site_intron"] = main.intron.to_numpy() if "intron" in main else np.nan
+    out["main_site_exon_rank"] = main.exon_rank.to_numpy() if "exon_rank" in main else np.nan
+    if gene_names is not None:
+        out.insert(2, "gene_name", out.gene_id.map(gene_names).fillna(""))
+    ok = ((out.reads_control >= params.min_reads) & (out.reads_treated >= params.min_reads) & (out.class_reads > 0)
+          & out.p.notna())
+    out = out[ok].reset_index(drop=True)
+    out["q"] = bh(out.p)
+    return out