@pikaa-ai/pikaa 0.3.1 → 0.3.4

package/skills/scanpy/references/standard_workflow.md

@@ -1,223 +0,0 @@
-# Standard Scanpy Workflow for Single-Cell Analysis
-
-This document outlines the standard workflow for analyzing single-cell RNA-seq data using scanpy.
-
-## Complete Analysis Pipeline
-
-### 1. Data Loading and Initial Setup
-
-```python
-import scanpy as sc
-import pandas as pd
-import numpy as np
-
-# Configure scanpy settings
-sc.settings.verbosity = 3  # verbosity: errors (0), warnings (1), info (2), hints (3)
-sc.settings.set_figure_params(dpi=80, facecolor='white')
-
-# Load data (various formats)
-adata = sc.read_10x_mtx('path/to/data/')  # For 10X data
-# adata = sc.read_h5ad('path/to/data.h5ad')  # For h5ad format
-# adata = sc.read_csv('path/to/data.csv')  # For CSV format
-```
-
-### 2. Quality Control (QC)
-
-```python
-# Calculate QC metrics
-sc.pp.calculate_qc_metrics(adata, qc_vars=['mt'], percent_top=None, log1p=False, inplace=True)
-
-# Common filtering thresholds (adjust based on dataset)
-sc.pp.filter_cells(adata, min_genes=200)
-sc.pp.filter_genes(adata, min_cells=3)
-
-# Remove cells with high mitochondrial content
-adata = adata[adata.obs.pct_counts_mt < 5, :]
-
-# Optional: doublet detection (run on raw counts before normalization)
-# sc.pp.scrublet(adata)
-# adata = adata[~adata.obs['predicted_doublet'], :].copy()
-
-# Visualize QC metrics
-sc.pl.violin(adata, ['n_genes_by_counts', 'total_counts', 'pct_counts_mt'],
-             jitter=0.4, multi_panel=True)
-sc.pl.scatter(adata, x='total_counts', y='pct_counts_mt')
-sc.pl.scatter(adata, x='total_counts', y='n_genes_by_counts')
-```
-
-### 3. Normalization
-
-```python
-# Normalize to 10,000 counts per cell
-sc.pp.normalize_total(adata, target_sum=1e4)
-
-# Log-transform the data
-sc.pp.log1p(adata)
-
-# Store normalized data in raw for later use
-adata.raw = adata
-```
-
-### 4. Feature Selection
-
-```python
-# Identify highly variable genes
-sc.pp.highly_variable_genes(adata, min_mean=0.0125, max_mean=3, min_disp=0.5)
-
-# Visualize highly variable genes
-sc.pl.highly_variable_genes(adata)
-
-# Subset to highly variable genes
-adata = adata[:, adata.var.highly_variable]
-```
-
-### 5. Scaling and Regression
-
-```python
-# Regress out effects of total counts per cell and percent mitochondrial genes
-sc.pp.regress_out(adata, ['total_counts', 'pct_counts_mt'])
-
-# Scale data to unit variance and zero mean
-sc.pp.scale(adata, max_value=10)
-```
-
-### 6. Dimensionality Reduction
-
-```python
-# Principal Component Analysis (PCA)
-sc.tl.pca(adata, svd_solver='arpack')
-
-# Visualize PCA results
-sc.pl.pca(adata, color='CST3')
-sc.pl.pca_variance_ratio(adata, log=True)
-
-# Computing neighborhood graph
-sc.pp.neighbors(adata, n_neighbors=10, n_pcs=40)
-
-# UMAP for visualization
-sc.tl.umap(adata)
-
-# t-SNE (alternative to UMAP)
-# sc.tl.tsne(adata)
-```
-
-### 7. Clustering
-
-```python
-# Leiden clustering
-sc.tl.leiden(adata, resolution=0.5)
-
-# Visualize clustering results
-sc.pl.umap(adata, color=['leiden'], legend_loc='on data')
-```
-
-### 8. Marker Gene Identification
-
-`rank_genes_groups` is appropriate for exploratory cluster markers. Per-cell tests produce inflated p-values; for rigorous DE between conditions, pseudobulk with `sc.get.aggregate()` and use pydeseq2.
-
-```python
-# Find marker genes for each cluster (exploratory)
-sc.tl.rank_genes_groups(adata, 'leiden', method='wilcoxon')
-
-# Visualize top marker genes
-sc.pl.rank_genes_groups(adata, n_genes=25, sharey=False)
-
-# Get marker gene dataframe
-marker_genes = sc.get.rank_genes_groups_df(adata, group='0')
-
-# Visualize specific markers
-sc.pl.umap(adata, color=['leiden', 'CST3', 'NKG7'])
-```
-
-### 9. Cell Type Annotation
-
-```python
-# Manual annotation based on marker genes
-cluster_annotations = {
-    '0': 'CD4 T cells',
-    '1': 'CD14+ Monocytes',
-    '2': 'B cells',
-    '3': 'CD8 T cells',
-    # ... add more annotations
-}
-adata.obs['cell_type'] = adata.obs['leiden'].map(cluster_annotations)
-
-# Visualize annotated cell types
-sc.pl.umap(adata, color='cell_type', legend_loc='on data')
-```
-
-### 10. Saving Results
-
-```python
-# Save the processed AnnData object
-adata.write('results/processed_data.h5ad')
-
-# Export results to CSV
-adata.obs.to_csv('results/cell_metadata.csv')
-adata.var.to_csv('results/gene_metadata.csv')
-```
-
-## Additional Analysis Options
-
-### Trajectory Inference
-
-```python
-# PAGA (Partition-based graph abstraction)
-sc.tl.paga(adata, groups='leiden')
-sc.pl.paga(adata, color=['leiden'])
-
-# Diffusion pseudotime (DPT)
-adata.uns['iroot'] = np.flatnonzero(adata.obs['leiden'] == '0')[0]
-sc.tl.dpt(adata)
-sc.pl.umap(adata, color=['dpt_pseudotime'])
-```
-
-### Differential Expression Between Conditions
-
-Pseudobulk by sample and cell type, then run proper DE (e.g., pydeseq2):
-
-```python
-pb = sc.get.aggregate(
-    adata,
-    by=['sample', 'cell_type'],
-    func='sum',
-    layer='counts',
-)
-# Export pb and use pydeseq2 for condition comparisons
-```
-
-For quick exploratory comparisons only:
-
-```python
-sc.tl.rank_genes_groups(adata, groupby='condition', groups=['treated'],
-                         reference='control', method='wilcoxon')
-sc.pl.rank_genes_groups(adata, groups=['treated'])
-```
-
-### Gene Set Scoring
-
-```python
-# Score cells for gene set expression
-gene_set = ['CD3D', 'CD3E', 'CD3G']
-sc.tl.score_genes(adata, gene_set, score_name='T_cell_score')
-sc.pl.umap(adata, color='T_cell_score')
-```
-
-## Common Parameters to Adjust
-
-- **QC thresholds**: `min_genes`, `min_cells`, `pct_counts_mt` - depends on dataset quality
-- **Normalization target**: Usually 1e4, but can be adjusted
-- **HVG parameters**: Affects feature selection stringency
-- **PCA components**: Check variance ratio plot to determine optimal number
-- **Clustering resolution**: Higher values give more clusters (typically 0.4-1.2)
-- **n_neighbors**: Affects granularity of UMAP and clustering (typically 10-30)
-
-## Best Practices
-
-1. Always visualize QC metrics before filtering
-2. Save raw counts before normalization (`adata.raw = adata`)
-3. Use Leiden clustering (`sc.tl.louvain` deprecated in scanpy 1.12)
-4. Try multiple clustering resolutions to find optimal granularity
-5. Validate cell type annotations with known marker genes
-6. Pseudobulk for rigorous DE; treat `rank_genes_groups` p-values as exploratory
-7. Save intermediate results at key steps

package/skills/scanpy/scripts/_common.py

@@ -1,127 +0,0 @@
-#!/usr/bin/env python3
-"""
-Shared helpers for the scanpy script toolkit.
-
-Every CLI script in this directory imports from this module so that data
-loading, saving, figure configuration, and logging behave consistently.
-This file is NOT a CLI itself; import it:
-
-    from _common import load_anndata, save_anndata, configure_scanpy, info
-"""
-
-import os
-import sys
-
-
-def info(msg):
-    """Print a progress message to stderr-friendly stdout with a marker."""
-    print(f"[scanpy] {msg}", flush=True)
-
-
-def die(msg, code=1):
-    """Print an error and exit."""
-    print(f"Error: {msg}", file=sys.stderr, flush=True)
-    sys.exit(code)
-
-
-def _import_scanpy():
-    try:
-        import scanpy as sc  # noqa: F401
-        return sc
-    except ImportError:
-        die('scanpy not installed. Install with: uv pip install "scanpy[leiden]"')
-
-
-def configure_scanpy(figdir="figures", dpi=120, verbosity=1, autosave=False,
-                     file_format="png"):
-    """Apply consistent scanpy settings and return the scanpy module.
-
-    Note: autosave is left off by default because the toolkit scripts pass
-    explicit ``save=`` suffixes to plotting calls for predictable filenames.
-    """
-    sc = _import_scanpy()
-    sc.settings.verbosity = verbosity
-    sc.settings.set_figure_params(dpi=dpi, facecolor="white")
-    sc.settings.figdir = figdir
-    sc.settings.file_format_figs = file_format
-    if autosave:
-        sc.settings.autosave = True
-    os.makedirs(figdir, exist_ok=True)
-    return sc
-
-
-def load_anndata(path, var_names="gene_symbols"):
-    """Load an AnnData object, dispatching on the file extension / layout.
-
-    Supported inputs:
-      * ``.h5ad``                  -> sc.read_h5ad
-      * ``.h5`` (10x CellRanger)   -> sc.read_10x_h5
-      * ``.csv`` / ``.tsv`` / ``.txt`` -> sc.read_csv / read_text
-      * ``.loom``                  -> sc.read_loom
-      * ``.mtx``                   -> sc.read (matrix market)
-      * a directory                -> sc.read_10x_mtx (10x mtx folder)
-    """
-    sc = _import_scanpy()
-    if not os.path.exists(path):
-        die(f"input not found: {path}")
-
-    lower = path.lower()
-    if os.path.isdir(path):
-        info(f"Reading 10x mtx directory: {path}")
-        return sc.read_10x_mtx(path, var_names=var_names)
-    if lower.endswith(".h5ad"):
-        return sc.read_h5ad(path)
-    if lower.endswith(".h5"):
-        info("Reading 10x HDF5 (.h5)")
-        return sc.read_10x_h5(path)
-    if lower.endswith(".loom"):
-        return sc.read_loom(path)
-    if lower.endswith(".csv"):
-        return sc.read_csv(path)
-    if lower.endswith((".tsv", ".txt")):
-        return sc.read_text(path)
-    if lower.endswith(".mtx") or lower.endswith(".mtx.gz"):
-        return sc.read(path)
-    die(f"unrecognized input format: {path}")
-
-
-def save_anndata(adata, path):
-    """Write an AnnData object to .h5ad, creating parent dirs as needed."""
-    parent = os.path.dirname(os.path.abspath(path))
-    os.makedirs(parent, exist_ok=True)
-    adata.write_h5ad(path)
-    info(f"Wrote {path}  ({adata.n_obs} cells x {adata.n_vars} genes)")
-
-
-def add_io_args(parser, default_output=None):
-    """Attach the standard input/output/figdir arguments to an argparse parser."""
-    parser.add_argument("input", help="Input file (.h5ad, .h5, .csv, .loom, or 10x mtx dir)")
-    parser.add_argument("-o", "--output", default=default_output,
-                        help="Output .h5ad path" +
-                             (f" (default: {default_output})" if default_output else ""))
-    parser.add_argument("--figdir", default="figures",
-                        help="Directory for saved figures (default: figures)")
-    return parser
-
-
-def _named_keys(mapping):
-    """Named keys of an AnnData mapping, in order.
-
-    anndata >= 0.13 reports an unnamed `None` key on `.layers` standing for X
-    itself. Joining that into a string raises TypeError, so filter it out.
-    """
-    return [key for key in mapping.keys() if isinstance(key, str)]
-
-
-def summarize(adata):
-    """Return a short human-readable summary string of an AnnData object."""
-    lines = [f"{adata.n_obs} cells x {adata.n_vars} genes"]
-    if len(adata.obs.columns):
-        lines.append("obs: " + ", ".join(adata.obs.columns[:20]))
-    obsm = _named_keys(adata.obsm)
-    if obsm:
-        lines.append("obsm: " + ", ".join(obsm))
-    layers = _named_keys(adata.layers)
-    if layers:
-        lines.append("layers: " + ", ".join(layers))
-    return "\n".join(lines)

package/skills/scanpy/scripts/annotate.py

@@ -1,84 +0,0 @@
-#!/usr/bin/env python3
-"""
-Annotate clusters with cell-type labels from a mapping file.
-
-Maps a cluster column (e.g. leiden) to cell-type names using a JSON or CSV
-mapping, writes the labels into a new obs column, and saves a UMAP and dotplot.
-
-The mapping file is one of:
-  * JSON  : {"0": "CD4 T cells", "1": "B cells", ...}
-  * CSV    : two columns ``cluster,cell_type``
-
-Optionally provide a marker-gene JSON to draw a reference dotplot that helps
-decide the mapping:
-  {"T cells": ["CD3D","CD3E"], "B cells": ["MS4A1","CD79A"]}
-
-Examples:
-    python annotate.py clustered.h5ad -o annotated.h5ad --mapping celltypes.json
-    python annotate.py clustered.h5ad -o annotated.h5ad --mapping map.csv --cluster-key leiden
-    python annotate.py clustered.h5ad --markers markers.json --cluster-key leiden   # dotplot only
-"""
-
-import argparse
-import json
-import os
-
-from _common import add_io_args, configure_scanpy, die, info, load_anndata, save_anndata
-
-
-def load_mapping(path):
-    if path.lower().endswith(".json"):
-        with open(path) as fh:
-            return {str(k): v for k, v in json.load(fh).items()}
-    import pandas as pd
-    df = pd.read_csv(path)
-    if df.shape[1] < 2:
-        die("CSV mapping needs at least two columns: cluster,cell_type")
-    return {str(k): v for k, v in zip(df.iloc[:, 0], df.iloc[:, 1])}
-
-
-def main():
-    p = argparse.ArgumentParser(description=__doc__,
-                                formatter_class=argparse.RawDescriptionHelpFormatter)
-    add_io_args(p, default_output="annotated.h5ad")
-    p.add_argument("--cluster-key", default="leiden", help="obs column with clusters (default leiden)")
-    p.add_argument("--mapping", default=None, help="JSON or CSV cluster->cell_type mapping")
-    p.add_argument("--label-key", default="cell_type", help="New obs column name (default cell_type)")
-    p.add_argument("--markers", default=None,
-                   help="JSON of {cell_type: [genes]} to draw a reference dotplot")
-    p.add_argument("--no-plots", action="store_true", help="Skip plots")
-    args = p.parse_args()
-
-    sc = configure_scanpy(figdir=args.figdir)
-    adata = load_anndata(args.input)
-    if args.cluster_key not in adata.obs.columns:
-        die(f"cluster key '{args.cluster_key}' not in obs: {list(adata.obs.columns)}")
-
-    if args.markers:
-        with open(args.markers) as fh:
-            marker_dict = json.load(fh)
-        present = {ct: [g for g in genes if g in (adata.raw.var_names if adata.raw is not None else adata.var_names)]
-                   for ct, genes in marker_dict.items()}
-        present = {ct: g for ct, g in present.items() if g}
-        if present and not args.no_plots:
-            sc.pl.dotplot(adata, present, groupby=args.cluster_key,
-                          use_raw=adata.raw is not None, show=False, save="_marker_reference.png")
-            info("Wrote marker reference dotplot")
-
-    if args.mapping:
-        mapping = load_mapping(args.mapping)
-        adata.obs[args.label_key] = (
-            adata.obs[args.cluster_key].astype(str).map(mapping).fillna("Unknown").astype("category")
-        )
-        info(f"Annotated '{args.label_key}': "
-             + ", ".join(f"{k}={v}" for k, v in adata.obs[args.label_key].value_counts().items()))
-        if not args.no_plots:
-            sc.pl.umap(adata, color=args.label_key, legend_loc="on data",
-                       show=False, save="_celltypes.png")
-        save_anndata(adata, args.output)
-    elif not args.markers:
-        die("provide --mapping (to annotate) and/or --markers (for a reference dotplot)")
-
-
-if __name__ == "__main__":
-    main()

package/skills/scanpy/scripts/batch_correct.py

@@ -1,65 +0,0 @@
-#!/usr/bin/env python3
-"""
-Batch correction / integration across samples.
-
-Supports three methods:
-  * harmony  : corrects the PCA embedding -> writes obsm['X_pca_harmony'].
-               Fast, recommended default. Needs harmonypy (uv pip install harmonypy).
-               Follow with: reduce_dimensions.py --use-rep X_pca_harmony
-  * bbknn     : batch-balanced kNN graph (replaces sc.pp.neighbors). Then cluster directly.
-               Needs bbknn (uv pip install bbknn).
-  * combat    : corrects the expression matrix in place (sc.pp.combat). Built into scanpy.
-
-Run on a normalized object that already has PCA (harmony/bbknn) computed.
-
-Examples:
-    python batch_correct.py reduced.h5ad -o integrated.h5ad --method harmony --batch-key sample
-    python batch_correct.py reduced.h5ad -o integrated.h5ad --method bbknn --batch-key sample
-    python batch_correct.py normalized.h5ad -o integrated.h5ad --method combat --batch-key batch
-"""
-
-import argparse
-
-from _common import add_io_args, configure_scanpy, die, info, load_anndata, save_anndata
-
-
-def main():
-    p = argparse.ArgumentParser(description=__doc__,
-                                formatter_class=argparse.RawDescriptionHelpFormatter)
-    add_io_args(p, default_output="integrated.h5ad")
-    p.add_argument("--method", default="harmony", choices=["harmony", "bbknn", "combat"])
-    p.add_argument("--batch-key", required=True, help="obs column identifying batches")
-    args = p.parse_args()
-
-    sc = configure_scanpy(figdir=args.figdir)
-    adata = load_anndata(args.input)
-    if args.batch_key not in adata.obs.columns:
-        die(f"batch key '{args.batch_key}' not in obs: {list(adata.obs.columns)}")
-
-    if args.method == "harmony":
-        if "X_pca" not in adata.obsm:
-            sc.tl.pca(adata, svd_solver="arpack")
-        try:
-            sc.external.pp.harmony_integrate(adata, args.batch_key)
-        except ImportError:
-            die("harmonypy not installed. Install with: uv pip install harmonypy")
-        info("Wrote obsm['X_pca_harmony']. Next: "
-             "reduce_dimensions.py --use-rep X_pca_harmony")
-    elif args.method == "bbknn":
-        if "X_pca" not in adata.obsm:
-            sc.tl.pca(adata, svd_solver="arpack")
-        try:
-            sc.external.pp.bbknn(adata, batch_key=args.batch_key)
-        except ImportError:
-            die("bbknn not installed. Install with: uv pip install bbknn")
-        sc.tl.umap(adata)
-        info("Built batch-balanced graph + UMAP. Next: cluster.py")
-    elif args.method == "combat":
-        sc.pp.combat(adata, key=args.batch_key)
-        info("Corrected expression matrix with ComBat. Re-run reduce_dimensions.py.")
-
-    save_anndata(adata, args.output)
-
-
-if __name__ == "__main__":
-    main()

package/skills/scanpy/scripts/cluster.py

@@ -1,63 +0,0 @@
-#!/usr/bin/env python3
-"""
-Leiden clustering on a precomputed neighborhood graph.
-
-Runs Leiden at one or more resolutions and writes a UMAP colored by each
-clustering. Requires that ``sc.pp.neighbors`` has already been run
-(use reduce_dimensions.py first).
-
-Examples:
-    python cluster.py reduced.h5ad -o clustered.h5ad --resolution 0.5
-    python cluster.py reduced.h5ad -o clustered.h5ad --resolution 0.3 0.5 0.8 1.0
-    python cluster.py reduced.h5ad -o clustered.h5ad --algorithm louvain
-"""
-
-import argparse
-
-from _common import add_io_args, configure_scanpy, die, info, load_anndata, save_anndata
-
-
-def main():
-    p = argparse.ArgumentParser(description=__doc__,
-                                formatter_class=argparse.RawDescriptionHelpFormatter)
-    add_io_args(p, default_output="clustered.h5ad")
-    p.add_argument("--resolution", type=float, nargs="+", default=[0.5],
-                   help="One or more resolutions (default 0.5). Higher = more clusters")
-    p.add_argument("--algorithm", default="leiden", choices=["leiden", "louvain"],
-                   help="Clustering algorithm (default leiden)")
-    p.add_argument("--key", default=None,
-                   help="obs key for the result (single resolution only; "
-                        "default '<algorithm>'). Multiple resolutions use '<algorithm>_<res>'")
-    p.add_argument("--no-plots", action="store_true", help="Skip UMAP plots")
-    args = p.parse_args()
-
-    sc = configure_scanpy(figdir=args.figdir)
-    adata = load_anndata(args.input)
-    if "neighbors" not in adata.uns:
-        die("no neighborhood graph found. Run reduce_dimensions.py first.")
-
-    cluster_fn = sc.tl.leiden if args.algorithm == "leiden" else sc.tl.louvain
-    keys = []
-    for res in args.resolution:
-        if len(args.resolution) == 1:
-            key = args.key or args.algorithm
-        else:
-            key = f"{args.algorithm}_{res}"
-        # flavor='igraph' is the scanpy 1.12 default-recommended Leiden backend.
-        kwargs = {"resolution": res, "key_added": key}
-        if args.algorithm == "leiden":
-            kwargs.update(flavor="igraph", n_iterations=2, directed=False)
-        cluster_fn(adata, **kwargs)
-        n = adata.obs[key].nunique()
-        info(f"{key}: {n} clusters at resolution {res}")
-        keys.append(key)
-
-    if not args.no_plots:
-        sc.pl.umap(adata, color=keys, legend_loc="on data",
-                   show=False, save="_clusters.png")
-
-    save_anndata(adata, args.output)
-
-
-if __name__ == "__main__":
-    main()

package/skills/scanpy/scripts/convert.py

@@ -1,43 +0,0 @@
-#!/usr/bin/env python3
-"""
-Load any supported single-cell format and write it as .h5ad.
-
-Convenience wrapper to get 10x mtx folders, 10x .h5, CSV/TSV, loom, or mtx
-files into AnnData .h5ad once, so later steps all read a single fast format.
-For R-native files (.rds / Seurat / SingleCellExperiment), see
-references/r_interop.md — those must be converted with R first.
-
-Examples:
-    python convert.py filtered_feature_bc_matrix/ -o data.h5ad
-    python convert.py raw_counts.csv -o data.h5ad --transpose
-    python convert.py matrix.h5 -o data.h5ad
-"""
-
-import argparse
-
-from _common import add_io_args, configure_scanpy, info, load_anndata, save_anndata, summarize
-
-
-def main():
-    p = argparse.ArgumentParser(description=__doc__,
-                                formatter_class=argparse.RawDescriptionHelpFormatter)
-    add_io_args(p, default_output="data.h5ad")
-    p.add_argument("--transpose", action="store_true",
-                   help="Transpose after loading (use if matrix is genes x cells)")
-    p.add_argument("--make-unique", action="store_true",
-                   help="Make var (gene) names unique")
-    args = p.parse_args()
-
-    configure_scanpy(figdir=args.figdir)
-    adata = load_anndata(args.input)
-    if args.transpose:
-        adata = adata.T
-        info(f"Transposed -> {adata.n_obs} cells x {adata.n_vars} genes")
-    if args.make_unique:
-        adata.var_names_make_unique()
-    print(summarize(adata))
-    save_anndata(adata, args.output)
-
-
-if __name__ == "__main__":
-    main()

package/skills/scanpy/scripts/find_markers.py

@@ -1,75 +0,0 @@
-#!/usr/bin/env python3
-"""
-Rank marker genes per group and export tables + plots.
-
-Runs ``sc.tl.rank_genes_groups`` for a grouping (e.g. leiden clusters), writes
-a combined CSV of the top markers per group, per-group CSVs, and the standard
-marker plots (rank panel, heatmap, dotplot).
-
-NOTE: per-cell tests inflate significance because cells are not independent.
-Use this for EXPLORATORY cluster markers. For rigorous DE between conditions,
-use pseudobulk.py + pydeseq2.
-
-Examples:
-    python find_markers.py clustered.h5ad -o markers.h5ad
-    python find_markers.py clustered.h5ad --groupby leiden --method wilcoxon --n-genes 50
-    python find_markers.py clustered.h5ad --csv-dir results/markers --top 10
-"""
-
-import argparse
-import os
-
-from _common import add_io_args, configure_scanpy, die, info, load_anndata, save_anndata
-
-
-def main():
-    p = argparse.ArgumentParser(description=__doc__,
-                                formatter_class=argparse.RawDescriptionHelpFormatter)
-    add_io_args(p, default_output=None)
-    p.add_argument("--groupby", default="leiden", help="obs column to group by (default leiden)")
-    p.add_argument("--method", default="wilcoxon",
-                   choices=["wilcoxon", "t-test", "t-test_overestim_var", "logreg"],
-                   help="Test method (default wilcoxon)")
-    p.add_argument("--n-genes", type=int, default=25, help="Genes shown in plots (default 25)")
-    p.add_argument("--top", type=int, default=25, help="Top markers per group in CSV (default 25)")
-    p.add_argument("--use-raw", action="store_true",
-                   help="Rank on adata.raw (normalized log values) instead of X")
-    p.add_argument("--csv-dir", default="results/markers", help="Directory for marker CSVs")
-    p.add_argument("--no-plots", action="store_true", help="Skip marker plots")
-    args = p.parse_args()
-
-    sc = configure_scanpy(figdir=args.figdir)
-    adata = load_anndata(args.input)
-    if args.groupby not in adata.obs.columns:
-        die(f"groupby column '{args.groupby}' not found in obs: {list(adata.obs.columns)}")
-
-    sc.tl.rank_genes_groups(adata, args.groupby, method=args.method,
-                            use_raw=args.use_raw if adata.raw is not None else False)
-
-    os.makedirs(args.csv_dir, exist_ok=True)
-    groups = list(adata.obs[args.groupby].cat.categories) \
-        if hasattr(adata.obs[args.groupby], "cat") else sorted(adata.obs[args.groupby].unique())
-    combined = []
-    for g in groups:
-        df = sc.get.rank_genes_groups_df(adata, group=str(g)).head(args.top)
-        df.insert(0, "group", g)
-        df.to_csv(os.path.join(args.csv_dir, f"markers_{args.groupby}_{g}.csv"), index=False)
-        combined.append(df)
-    if combined:
-        import pandas as pd
-        all_path = os.path.join(args.csv_dir, f"markers_{args.groupby}_all.csv")
-        pd.concat(combined, ignore_index=True).to_csv(all_path, index=False)
-        info(f"Wrote marker tables to {args.csv_dir}/ ({len(groups)} groups)")
-
-    if not args.no_plots:
-        sc.pl.rank_genes_groups(adata, n_genes=args.n_genes, sharey=False,
-                                show=False, save="_markers.png")
-        sc.pl.rank_genes_groups_dotplot(adata, n_genes=5, show=False, save="_markers_dotplot.png")
-        sc.pl.rank_genes_groups_heatmap(adata, n_genes=10, show=False, save="_markers_heatmap.png")
-
-    if args.output:
-        save_anndata(adata, args.output)
-
-
-if __name__ == "__main__":
-    main()