osp-sc 0.1.0__tar.gz

osp_sc-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 chansigit
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

osp_sc-0.1.0/PKG-INFO

@@ -0,0 +1,105 @@
+Metadata-Version: 2.4
+Name: osp-sc
+Version: 0.1.0
+Summary: One-sample-pipeline: per-sample scRNA-seq QC, clustering, DEG and self-contained HTML report
+Author: chansigit
+License-Expression: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: scanpy
+Requires-Dist: igraph
+Requires-Dist: pandas
+Requires-Dist: numpy
+Requires-Dist: scipy
+Requires-Dist: matplotlib
+Requires-Dist: scikit-learn
+Provides-Extra: agent
+Requires-Dist: claude-agent-sdk; extra == "agent"
+Dynamic: license-file
+
+# osp — one-sample-pipeline
+
+Single-sample scRNA-seq QC → clustering/DEG → self-contained HTML report, with
+an optional Claude-agent step that proposes cell-type annotations and QC
+actions from the report and the cluster marker tables.
+
+Strictly single-sample by design — one sample per run, no cross-sample batch
+integration. Loop over samples in an outer driver (e.g. a Slurm job array);
+treat integration as a separate downstream step.
+
+## Install
+
+```bash
+pip install osp-sc                     # PyPI name; `import osp` / `python -m osp`
+# with the optional annotation agent (needs claude-agent-sdk + claude CLI credentials):
+pip install "osp-sc[agent]"            # + claude-agent-sdk for --annotate
+```
+
+## Quick usage
+
+```python
+from osp import run_one_sample_pipeline, generate_report
+
+ad_fo = adata[adata.obs["sample"] == "FO"]
+run_one_sample_pipeline(ad_fo, sample_label="FO", outdir="osp_out/FO")
+generate_report("osp_out/FO")
+```
+
+Stepwise calls, if you want more control:
+
+```python
+from osp import qc_one_sample, cluster_and_deg, deg_two_groups
+```
+
+- `qc_one_sample` — QC only (flags cells, drops nothing)
+- `cluster_and_deg` — clustering/DEG/PAGA on QC-passed data
+- `deg_two_groups` — Wilcoxon DEG between any two cell groups, for ad hoc comparisons outside the main pipeline
+
+## Command line
+
+```bash
+python -m osp data.h5ad --sample FO --outdir osp_out          # full pipeline + report
+python -m osp data.h5ad --sample FO --outdir osp_out --annotate --model claude-sonnet-5
+python -m osp.report osp_out                                   # rebuild the report only
+```
+
+See `examples/run_one_sample.py` for a driver that loads a large h5ad in
+backed mode and pulls out one sample (for per-sample Slurm array tasks), and
+`examples/submit_array.sbatch` for the job-array template.
+
+## Conventions
+
+- **Raw counts convention**: if `adata.layers["counts"]` exists, `X` is swapped
+  for it at the start of both the QC and clustering stages — this makes the
+  pipeline robust to inputs where `X` already holds normalized values with
+  raw counts kept in a layer (common in released h5ad files).
+- **QC is flag-only**: `qc_one_sample` never drops cells; `low_quality` is a
+  column, filtering is the caller's decision.
+- **DecontX degeneracy guard**: DecontX's own UMAP+DBSCAN init can collapse on
+  samples where the dominant cell lineage's transcriptome resembles the
+  ambient RNA pool (all contamination pinned near 1, or the init shattering
+  into 100+ tiny clusters). When detected, `qc_one_sample` automatically
+  re-runs DecontX with an explicit coarse-leiden clustering; check
+  `summary["decontx_z_source"]` (`"internal"` vs `"leiden_fallback"`) and the
+  Ambient Contamination section of the report.
+- **MAD-outlier assumption**: the adaptive per-sample QC thresholds (`nmads`
+  MADs around the median) assume a roughly regular within-sample
+  distribution. On samples with unusually shallow depth or heavy ambient
+  contamination this assumption can break — a naturally low-complexity but
+  perfectly healthy population (e.g. neutrophils, dominated by a handful of
+  granule genes) can get its `pct_counts_in_top_20_genes` MAD range squeezed
+  and be flagged en masse. The QC report's "MAD keep-ranges" table exists
+  specifically so this is visible instead of silent — a suspiciously tight
+  range, or one metric dominating the fail counts, is a signal to check which
+  cell types are being flagged before trusting the calls.
+
+## Sherlock / HPC notes
+
+- Never run the pipeline on a login node — submit through Slurm or use an
+  interactive allocation.
+- For large h5ad files, load in backed mode and subset to one sample before
+  bringing it into memory (see `examples/run_one_sample.py`).
+- `osp.annotate` is intentionally not imported by `osp/__init__.py` — it
+  depends on the optional `claude-agent-sdk`; import it explicitly
+  (`from osp.annotate import propose_annotation`) only when you need it.

osp_sc-0.1.0/README.md

@@ -0,0 +1,85 @@
+# osp — one-sample-pipeline
+
+Single-sample scRNA-seq QC → clustering/DEG → self-contained HTML report, with
+an optional Claude-agent step that proposes cell-type annotations and QC
+actions from the report and the cluster marker tables.
+
+Strictly single-sample by design — one sample per run, no cross-sample batch
+integration. Loop over samples in an outer driver (e.g. a Slurm job array);
+treat integration as a separate downstream step.
+
+## Install
+
+```bash
+pip install osp-sc                     # PyPI name; `import osp` / `python -m osp`
+# with the optional annotation agent (needs claude-agent-sdk + claude CLI credentials):
+pip install "osp-sc[agent]"            # + claude-agent-sdk for --annotate
+```
+
+## Quick usage
+
+```python
+from osp import run_one_sample_pipeline, generate_report
+
+ad_fo = adata[adata.obs["sample"] == "FO"]
+run_one_sample_pipeline(ad_fo, sample_label="FO", outdir="osp_out/FO")
+generate_report("osp_out/FO")
+```
+
+Stepwise calls, if you want more control:
+
+```python
+from osp import qc_one_sample, cluster_and_deg, deg_two_groups
+```
+
+- `qc_one_sample` — QC only (flags cells, drops nothing)
+- `cluster_and_deg` — clustering/DEG/PAGA on QC-passed data
+- `deg_two_groups` — Wilcoxon DEG between any two cell groups, for ad hoc comparisons outside the main pipeline
+
+## Command line
+
+```bash
+python -m osp data.h5ad --sample FO --outdir osp_out          # full pipeline + report
+python -m osp data.h5ad --sample FO --outdir osp_out --annotate --model claude-sonnet-5
+python -m osp.report osp_out                                   # rebuild the report only
+```
+
+See `examples/run_one_sample.py` for a driver that loads a large h5ad in
+backed mode and pulls out one sample (for per-sample Slurm array tasks), and
+`examples/submit_array.sbatch` for the job-array template.
+
+## Conventions
+
+- **Raw counts convention**: if `adata.layers["counts"]` exists, `X` is swapped
+  for it at the start of both the QC and clustering stages — this makes the
+  pipeline robust to inputs where `X` already holds normalized values with
+  raw counts kept in a layer (common in released h5ad files).
+- **QC is flag-only**: `qc_one_sample` never drops cells; `low_quality` is a
+  column, filtering is the caller's decision.
+- **DecontX degeneracy guard**: DecontX's own UMAP+DBSCAN init can collapse on
+  samples where the dominant cell lineage's transcriptome resembles the
+  ambient RNA pool (all contamination pinned near 1, or the init shattering
+  into 100+ tiny clusters). When detected, `qc_one_sample` automatically
+  re-runs DecontX with an explicit coarse-leiden clustering; check
+  `summary["decontx_z_source"]` (`"internal"` vs `"leiden_fallback"`) and the
+  Ambient Contamination section of the report.
+- **MAD-outlier assumption**: the adaptive per-sample QC thresholds (`nmads`
+  MADs around the median) assume a roughly regular within-sample
+  distribution. On samples with unusually shallow depth or heavy ambient
+  contamination this assumption can break — a naturally low-complexity but
+  perfectly healthy population (e.g. neutrophils, dominated by a handful of
+  granule genes) can get its `pct_counts_in_top_20_genes` MAD range squeezed
+  and be flagged en masse. The QC report's "MAD keep-ranges" table exists
+  specifically so this is visible instead of silent — a suspiciously tight
+  range, or one metric dominating the fail counts, is a signal to check which
+  cell types are being flagged before trusting the calls.
+
+## Sherlock / HPC notes
+
+- Never run the pipeline on a login node — submit through Slurm or use an
+  interactive allocation.
+- For large h5ad files, load in backed mode and subset to one sample before
+  bringing it into memory (see `examples/run_one_sample.py`).
+- `osp.annotate` is intentionally not imported by `osp/__init__.py` — it
+  depends on the optional `claude-agent-sdk`; import it explicitly
+  (`from osp.annotate import propose_annotation`) only when you need it.

osp_sc-0.1.0/osp/__init__.py

@@ -0,0 +1,63 @@
+"""OSP (one-sample-pipeline): single-sample scRNA-seq QC → clustering/DEG →
+self-contained HTML report.
+
+Strictly single-sample by design — one sample per run, no cross-sample batch
+integration; loop over samples in an outer driver, and treat integration as a
+separate downstream step.
+
+Entry points:
+    from osp import run_one_sample_pipeline, generate_report
+
+    ad_fo = adata[adata.obs["sample"] == "FO"]
+    run_one_sample_pipeline(ad_fo, sample_label="FO", outdir="osp_out/FO")
+    generate_report("osp_out/FO")
+
+Stepwise calls / utilities:
+    qc_one_sample     QC only (flags cells, drops nothing) — see osp.qc
+    cluster_and_deg   clustering/DEG/PAGA on QC-passed data — see osp.cluster
+    deg_two_groups    wilcoxon DEG between any two cell groups — see osp.cluster
+
+Command line:
+    python -m osp data.h5ad --sample FO --outdir osp_out   # full pipeline + report
+    python -m osp.qc data.h5ad --sample FO                 # QC only
+    python -m osp.report osp_out                           # report only
+    python -m osp.annotate osp_out --species mouse --tissue "bone marrow"
+                                                           # Claude annotation agent
+                                                           # (needs claude-agent-sdk)
+
+osp.annotate is intentionally not imported here — it depends on the optional
+claude-agent-sdk; use `from osp.annotate import propose_annotation` when
+needed.
+"""
+
+from .qc import (
+    DISSOCIATION_GENES_HS,
+    SPECIES_GENE_PATTERNS,
+    assert_single_sample,
+    cluster_order,
+    decontx_top_genes,
+    qc_one_sample,
+)
+from .cluster import (
+    DEFAULT_QC_PCA_COVARIATES,
+    QC_OVERLAY_COLS,
+    cluster_and_deg,
+    deg_two_groups,
+    run_one_sample_pipeline,
+)
+from .report import generate_report
+
+__all__ = [
+    "DEFAULT_QC_PCA_COVARIATES",
+    "DISSOCIATION_GENES_HS",
+    "QC_OVERLAY_COLS",
+    "SPECIES_GENE_PATTERNS",
+    "assert_single_sample",
+    "cluster_and_deg",
+    "cluster_order",
+    "decontx_top_genes",
+    "deg_two_groups",
+    "generate_report",
+    "qc_one_sample",
+    "run_one_sample_pipeline",
+]

osp_sc-0.1.0/osp/__main__.py

@@ -0,0 +1,54 @@
+"""python -m osp: single-sample QC → clustering → DEG → HTML report, end to end.
+
+With --annotate, the Claude annotation agent (osp.annotate, needs the
+optional claude-agent-sdk) runs afterwards and its proposal is folded into
+the report.
+"""
+
+import argparse
+
+import scanpy as sc
+
+from .cluster import run_one_sample_pipeline
+from .report import generate_report, write_report_context
+
+parser = argparse.ArgumentParser(prog="osp", description=__doc__)
+parser.add_argument("h5ad_path")
+parser.add_argument("--sample-col", default="sample")
+parser.add_argument("--sample", required=True, help="sample name to run on its own")
+parser.add_argument("--outdir", default="osp_out")
+parser.add_argument("--no-scrublet", action="store_true")
+parser.add_argument("--resolution", type=float, default=1.0)
+parser.add_argument("--annotate", action="store_true",
+                    help="after the pipeline, run the Claude annotation agent and refresh the report")
+parser.add_argument("--species", default=None, help="context passed to --annotate")
+parser.add_argument("--tissue", default=None, help="context passed to --annotate")
+parser.add_argument("--language", default="English", help='annotation output language (default "English")')
+parser.add_argument("--model", default=None, help='model for --annotate, e.g. "claude-fable-5" / "claude-sonnet-5"')
+parser.add_argument("--effort", default=None, choices=["low", "medium", "high", "xhigh", "max"],
+                    help="reasoning effort for --annotate (models that support it)")
+parser.add_argument("--report-context", default=None, metavar="TEXT",
+                    help="where this sample sits, for the report title (e.g. the analysis unit name)")
+args = parser.parse_args()
+write_report_context(args.outdir, args.report_context)
+
+adata = sc.read_h5ad(args.h5ad_path)
+sub = adata[adata.obs[args.sample_col] == args.sample]
+_, _, cluster_summary, *_ = run_one_sample_pipeline(
+    sub,
+    sample_label=args.sample,
+    sample_col=args.sample_col,
+    qc_kwargs={"run_scrublet": not args.no_scrublet},
+    cluster_kwargs={"resolutions": (args.resolution,), "primary_resolution": args.resolution},
+    outdir=args.outdir,
+)
+print(cluster_summary)
+print(f"report: {generate_report(args.outdir)}")
+
+if args.annotate:
+    from .annotate import propose_annotation
+
+    propose_annotation(
+        args.outdir, species=args.species, tissue=args.tissue, language=args.language,
+        model=args.model, effort=args.effort,
+    )

osp_sc-0.1.0/osp/_decontx/__init__.py

@@ -0,0 +1,38 @@
+"""osp._decontx -- vendored DecontX implementation.
+
+Vendored (not an external dependency) from ``pydecontx`` /
+``py-decontx`` (https://github.com/omicverse/py-decontx), itself a
+pure-Python port of the Bioconductor ``decontX`` package (Yang et al.,
+*Genome Biology* 2020). Licensed Apache License 2.0 -- see
+../../THIRD_PARTY_NOTICES.md for the full license text and attribution.
+
+DecontX models each cell's observed UMI counts as a Bayesian
+two-component multinomial mixture of a *native* gene distribution
+``phi`` and a *contamination* distribution ``eta`` (a weighted blend of
+every other population). Inference is by variational EM and yields a
+per-cell contamination fraction and a decontaminated count matrix.
+
+Internal to osp -- only :func:`decontx_one_sample.qc_one_sample` (via
+``osp.qc``) calls into this subpackage; it is not part of the public
+osp API.
+"""
+from __future__ import annotations
+
+from ._core import (
+    calculate_native_matrix,
+    decontx_em,
+    decontx_initialize,
+    decontx_loglik,
+)
+from ._dirichlet import fit_dirichlet
+from .decontx import DecontXResult, decontx
+
+__all__ = [
+    "decontx",
+    "DecontXResult",
+    "decontx_initialize",
+    "decontx_em",
+    "decontx_loglik",
+    "calculate_native_matrix",
+    "fit_dirichlet",
+]

osp_sc-0.1.0/osp/_decontx/_core.py

@@ -0,0 +1,224 @@
+"""Core variational-EM routines for DecontX.
+
+Vendored from ``pydecontx`` (Apache-2.0; see ../../THIRD_PARTY_NOTICES.md),
+itself a pure-Python / numpy / scipy port of the C++ inner loops of the
+Bioconductor ``decontX`` package (``src/DecontX.cpp``):
+
+* :func:`decontx_initialize` -- initial native (``phi``) and contamination
+  (``eta``) gene distributions from a random ``theta``.
+* :func:`decontx_em` -- one variational-EM step updating ``phi``, ``eta``,
+  ``theta`` and (optionally) the Dirichlet hyper-parameter ``delta``.
+* :func:`decontx_loglik` -- the two-component multinomial log-likelihood.
+* :func:`calculate_native_matrix` -- the decontaminated count matrix.
+
+All matrices follow the R convention: ``counts`` is genes-by-cells
+(rows = genes, columns = cells); ``phi`` / ``eta`` are genes-by-clusters.
+``z`` holds 1-based integer cluster labels (one per cell).
+"""
+from __future__ import annotations
+
+import numpy as np
+import scipy.sparse as sp
+
+from ._dirichlet import fit_dirichlet
+
+__all__ = [
+    "decontx_initialize",
+    "decontx_em",
+    "decontx_loglik",
+    "calculate_native_matrix",
+]
+
+
+def _as_csc(counts) -> sp.csc_matrix:
+    """Return ``counts`` as a float CSC sparse matrix (genes x cells)."""
+    if sp.issparse(counts):
+        return counts.tocsc().astype(float)
+    return sp.csc_matrix(np.asarray(counts, dtype=float))
+
+
+def decontx_initialize(counts, theta, z, pseudocount: float = 1e-20):
+    """Initialise the native (``phi``) and contamination (``eta``) matrices.
+
+    Port of the C++ ``decontXInitialize``. ``phi[:, k]`` accumulates
+    ``theta_j * counts`` over all cells ``j`` assigned to cluster ``k``;
+    ``eta`` is the row-sum complement (every *other* cluster's signal),
+    and both are column-normalised to proportions.
+
+    Parameters
+    ----------
+    counts : (G, C) array or sparse matrix
+        Gene-by-cell UMI counts.
+    theta : (C,) array
+        Initial native proportion for each cell.
+    z : (C,) int array
+        1-based cluster label for each cell.
+    pseudocount : float
+        Added to every cell of ``phi``/``eta`` before normalising.
+
+    Returns
+    -------
+    dict with keys ``phi`` and ``eta`` -- (G, K) numpy arrays.
+    """
+    counts = _as_csc(counts)
+    theta = np.asarray(theta, dtype=float)
+    z = np.asarray(z, dtype=int)
+    G, C = counts.shape
+    K = int(z.max())
+
+    phi = np.full((G, K), pseudocount, dtype=float)
+    indptr, indices, data = counts.indptr, counts.indices, counts.data
+    for j in range(C):
+        k = z[j] - 1
+        start, end = indptr[j], indptr[j + 1]
+        rows = indices[start:end]
+        vals = data[start:end] * theta[j]
+        np.add.at(phi[:, k], rows, vals)
+
+    phi_rowsum = phi.sum(axis=1)
+    eta = phi_rowsum[:, None] - phi
+
+    phi = phi / phi.sum(axis=0, keepdims=True)
+    eta = eta / eta.sum(axis=0, keepdims=True)
+    return {"phi": phi, "eta": eta}
+
+
+def decontx_em(counts, counts_colsums, theta, eta, phi, z,
+               estimate_eta: bool = True, estimate_delta: bool = True,
+               delta=(10.0, 10.0), pseudocount: float = 1e-20):
+    """One variational-EM update of the DecontX model.
+
+    Port of the C++ ``decontXEM``. For every observed transcript the
+    variational native/contaminant responsibility is
+
+    ``p_native  = (phi[i,k] + pc) * (theta[j] + pc)``
+    ``p_contam  = (eta[i,k] + pc) * (1 - theta[j] + pc)``
+    ``normp     = p_native / (p_native + p_contam)``
+
+    (the non-log form -- exact for a two-component mixture and what the
+    C++ code uses). The native mass ``normp * x`` is accumulated into the
+    new ``phi`` by cluster; ``eta`` is the row-sum complement. ``theta``
+    is then the posterior mean of a Beta/Dirichlet with concentration
+    ``delta``, which is itself re-estimated by :func:`fit_dirichlet`.
+
+    Returns a dict with the updated ``phi``, ``eta``, ``theta``,
+    ``delta`` and the per-cell ``contamination`` fraction.
+    """
+    counts = _as_csc(counts)
+    theta = np.asarray(theta, dtype=float)
+    counts_colsums = np.asarray(counts_colsums, dtype=float)
+    phi = np.asarray(phi, dtype=float)
+    eta = np.asarray(eta, dtype=float)
+    z = np.asarray(z, dtype=int)
+    delta = np.asarray(delta, dtype=float)
+
+    G, C = counts.shape
+    K = phi.shape[1]
+
+    new_phi = np.zeros((G, K), dtype=float)
+    native_total = np.zeros(C, dtype=float)
+
+    indptr, indices, data = counts.indptr, counts.indices, counts.data
+    for j in range(C):
+        k = z[j] - 1
+        start, end = indptr[j], indptr[j + 1]
+        if start == end:
+            continue
+        rows = indices[start:end]
+        x = data[start:end]
+        p_native = (phi[rows, k] + pseudocount) * (theta[j] + pseudocount)
+        p_contam = (eta[rows, k] + pseudocount) * (1.0 - theta[j] + pseudocount)
+        normp = p_native / (p_native + p_contam)
+        px = normp * x
+        np.add.at(new_phi[:, k], rows, px)
+        native_total[j] = px.sum()
+
+    if estimate_eta:
+        phi_rowsum = new_phi.sum(axis=1)
+        new_eta = phi_rowsum[:, None] - new_phi
+    else:
+        new_eta = eta
+
+    new_phi = new_phi / new_phi.sum(axis=0, keepdims=True)
+    if estimate_eta:
+        new_eta = new_eta / new_eta.sum(axis=0, keepdims=True)
+
+    # Update theta (and optionally its Dirichlet hyper-parameter delta).
+    contamination_prop = (counts_colsums - native_total) / counts_colsums
+    native_prop = 1.0 - contamination_prop
+    new_delta = delta
+    if estimate_delta:
+        theta_raw = np.column_stack([native_prop, contamination_prop])
+        new_delta = fit_dirichlet(theta_raw)["alpha"]
+
+    new_theta = (native_total + new_delta[0]) / (counts_colsums
+                                                 + np.sum(new_delta))
+
+    return {
+        "phi": new_phi,
+        "eta": new_eta,
+        "theta": new_theta,
+        "delta": new_delta,
+        "contamination": contamination_prop,
+    }
+
+
+def decontx_loglik(counts, theta, eta, phi, z, pseudocount: float = 1e-20):
+    """Two-component multinomial log-likelihood of the DecontX model.
+
+    Port of the C++ ``decontXLogLik``:
+    ``ll = sum_{i,j} x_{ij} * log(phi*theta + eta*(1-theta) + pc)``.
+    """
+    counts = _as_csc(counts)
+    theta = np.asarray(theta, dtype=float)
+    phi = np.asarray(phi, dtype=float)
+    eta = np.asarray(eta, dtype=float)
+    z = np.asarray(z, dtype=int)
+
+    loglik = 0.0
+    indptr, indices, data = counts.indptr, counts.indices, counts.data
+    for j in range(counts.shape[1]):
+        k = z[j] - 1
+        start, end = indptr[j], indptr[j + 1]
+        if start == end:
+            continue
+        rows = indices[start:end]
+        x = data[start:end]
+        mix = (phi[rows, k] * theta[j]
+               + eta[rows, k] * (1.0 - theta[j]) + pseudocount)
+        loglik += float(np.sum(x * np.log(mix)))
+    return loglik
+
+
+def calculate_native_matrix(counts, theta, eta, phi, z,
+                            pseudocount: float = 1e-20) -> sp.csc_matrix:
+    """Return the decontaminated (native) count matrix.
+
+    Port of the C++ ``calculateNativeMatrix``: each observed entry is
+    scaled by its variational native responsibility ``normp``. Values
+    may be non-integer; round for integer counts.
+    """
+    counts = _as_csc(counts).copy()
+    theta = np.asarray(theta, dtype=float)
+    phi = np.asarray(phi, dtype=float)
+    eta = np.asarray(eta, dtype=float)
+    z = np.asarray(z, dtype=int)
+
+    indptr, indices, data = counts.indptr, counts.indices, counts.data
+    out = data.copy()
+    for j in range(counts.shape[1]):
+        k = z[j] - 1
+        start, end = indptr[j], indptr[j + 1]
+        if start == end:
+            continue
+        rows = indices[start:end]
+        p_native = np.log(phi[rows, k] + pseudocount) + np.log(theta[j]
+                                                               + pseudocount)
+        p_contam = np.log(eta[rows, k] + pseudocount) + np.log(
+            1.0 - theta[j] + pseudocount)
+        normp = np.exp(p_native) / (np.exp(p_contam) + np.exp(p_native))
+        out[start:end] = data[start:end] * normp
+
+    native = sp.csc_matrix((out, indices.copy(), indptr.copy()),
+                           shape=counts.shape)
+    return native