sclab 0.3.1__tar.gz → 0.3.3__tar.gz

{sclab-0.3.1 → sclab-0.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sclab
-Version: 0.3.1
+Version: 0.3.3
 Summary: sclab
 Author-email: Argenis Arriojas <ArriojasMaldonado001@umb.edu>
 Requires-Python: >=3.10,<3.13
@@ -65,7 +65,6 @@ Open a Jupyter Notebook and run the following:
 ```python
 from IPython.display import display
 from sclab import SCLabDashboard
-from sclab.examples.processor_steps import QC, Preprocess, PCA, Neighbors, UMAP, Cluster
 import scanpy as sc
 
 # Load your data
@@ -73,8 +72,6 @@ adata = sc.read_10x_h5("your_data.h5")
 
 # Create dashboard
 dashboard = SCLabDashboard(adata, name="My Analysis")
-# Add desired processing steps to the interface
-dashboard.pr.add_steps({"Processing": [QC, Preprocess, PCA, Neighbors, UMAP, Cluster]})
 
 # Display dashboard
 display(dashboard)
@@ -84,8 +81,10 @@ display(dashboard)
 # dashboard.pl  # Plotter
 # dashboard.pr  # Processor
 
-# the resulting AnnData object is found within the dataset object:
+# the active AnnData object is found within the dataset object:
 # dashboard.ds.adata
+
+# by default, the dashboard will update the loaded AnnData object in-place
 ```
 
 ## Components
@@ -94,6 +93,7 @@ display(dashboard)
 
 The main interface that integrates all components with a tabbed layout:
 - Main graph for visualizations
+- Results panel
 - Observations table
 - Genes table
 - Event logs

{sclab-0.3.1 → sclab-0.3.3}/README.md

@@ -24,7 +24,6 @@ Open a Jupyter Notebook and run the following:
 ```python
 from IPython.display import display
 from sclab import SCLabDashboard
-from sclab.examples.processor_steps import QC, Preprocess, PCA, Neighbors, UMAP, Cluster
 import scanpy as sc
 
 # Load your data
@@ -32,8 +31,6 @@ adata = sc.read_10x_h5("your_data.h5")
 
 # Create dashboard
 dashboard = SCLabDashboard(adata, name="My Analysis")
-# Add desired processing steps to the interface
-dashboard.pr.add_steps({"Processing": [QC, Preprocess, PCA, Neighbors, UMAP, Cluster]})
 
 # Display dashboard
 display(dashboard)
@@ -43,8 +40,10 @@ display(dashboard)
 # dashboard.pl  # Plotter
 # dashboard.pr  # Processor
 
-# the resulting AnnData object is found within the dataset object:
+# the active AnnData object is found within the dataset object:
 # dashboard.ds.adata
+
+# by default, the dashboard will update the loaded AnnData object in-place
 ```
 
 ## Components
@@ -53,6 +52,7 @@ display(dashboard)
 
 The main interface that integrates all components with a tabbed layout:
 - Main graph for visualizations
+- Results panel
 - Observations table
 - Genes table
 - Event logs

{sclab-0.3.1 → sclab-0.3.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sclab"
-version = "0.3.1"
+version = "0.3.3"
 description = "sclab"
 readme = "README.md"
 authors = [

{sclab-0.3.1 → sclab-0.3.3}/src/sclab/__init__.py

@@ -6,4 +6,4 @@ __all__ = [
     "SCLabDashboard",
 ]
 
-__version__ = "0.3.1"
+__version__ = "0.3.3"

{sclab-0.3.1 → sclab-0.3.3}/src/sclab/_sclab.py

@@ -1,7 +1,6 @@
 import inspect
 from io import BytesIO
 from pathlib import Path
-import tempfile
 
 from anndata import AnnData
 from IPython.display import display
@@ -238,6 +237,8 @@ class DataLoader(VBox):
         self.adata = adata
 
     def on_upload(self, *args, **kwargs):
+        import tempfile
+
         from .scanpy.readwrite import read_10x_h5, read_h5ad
 
         files = self.upload.value

{sclab-0.3.1 → sclab-0.3.3}/src/sclab/dataset/processor/_results_panel.py

@@ -1,14 +1,24 @@
-from ipywidgets import GridBox, Layout, Stack, ToggleButtons, link
+from ipywidgets import Box, Dropdown, Layout, Stack, VBox, link
 
 from sclab.event import EventBroker, EventClient
 
+# Create a layout with a bottom border to act as the horizontal line
+hr_layout = Layout(
+    border="1px solid black",  # 1px width, solid style, black color
+    margin="10px 0",  # Add margin for spacing above and below
+    width="100%",  # Extend the line across the full width
+)
+
+# Create a Box widget with the styled layout
+hr = Box(layout=hr_layout)
+
 
 class _Results:
     namespace: str
 
 
-class ResultsPanel(GridBox, EventClient):
-    available_results: ToggleButtons
+class ResultsPanel(VBox, EventClient):
+    available_results: Dropdown
     results_stack: Stack
 
     events: list[str] = [
@@ -22,7 +32,7 @@ class ResultsPanel(GridBox, EventClient):
     ):
         EventClient.__init__(self, broker)
 
-        self.available_results = ToggleButtons(options={})
+        self.available_results = Dropdown(options={}, description="Category")
         self.results_stack = Stack([])
 
         link(
@@ -30,15 +40,19 @@ class ResultsPanel(GridBox, EventClient):
             (self.results_stack, "selected_index"),
         )
 
-        GridBox.__init__(
+        VBox.__init__(
             self,
-            [self.available_results, self.results_stack],
-            layout=Layout(
-                width="100%",
-                grid_template_columns="150px auto",
-                grid_template_areas=""" "available-results selected-results_stack" """,
-                border="0px solid black",
-            ),
+            [
+                self.available_results,
+                hr,
+                self.results_stack,
+            ],
+            # layout=Layout(
+            #     width="100%",
+            #     grid_template_columns="150px auto",
+            #     grid_template_areas=""" "available-results selected-results_stack" """,
+            #     border="0px solid black",
+            # ),
         )
 
     def add_result(self, results: _Results):

{sclab-0.3.1 → sclab-0.3.3}/src/sclab/examples/processor_steps/_differential_expression.py

@@ -25,7 +25,7 @@ class DifferentialExpressionResults(VBox):
 
     def __init__(self, dataset: SCLabDataset):
         self.dataset = dataset
-        self.result_selector = Dropdown()
+        self.result_selector = Dropdown(description="Analysis Name")
         self.group_selector = ToggleButtons()
         self.table_output = Output()
 
@@ -198,6 +198,7 @@ class DifferentialExpression(ProcessorStepBase):
             reference=reference,
             layer=layer,
             key_added=key_added,
+            pts=True,
         )
 
         self.results.sync_results_list(focus_result=key_added)

{sclab-0.3.1 → sclab-0.3.3}/src/sclab/preprocess/__init__.py

@@ -2,6 +2,9 @@ from ._cca_integrate import cca_integrate, cca_integrate_pair
 from ._filter_obs import filter_obs
 from ._harmony_integrate import harmony_integrate
 from ._normalize_weighted import normalize_weighted
+from ._pca import pca
+from ._preprocess import preprocess
+from ._qc import qc
 from ._subset import subset_obs, subset_var
 from ._transfer_metadata import transfer_metadata
 from ._transform import pool_neighbors
@@ -12,7 +15,10 @@ __all__ = [
     "filter_obs",
     "harmony_integrate",
     "normalize_weighted",
+    "pca",
     "pool_neighbors",
+    "preprocess",
+    "qc",
     "subset_obs",
     "subset_var",
     "transfer_metadata",

{sclab-0.3.1 → sclab-0.3.3}/src/sclab/preprocess/_cca.py

@@ -1,24 +1,31 @@
 import logging
+import os
 from typing import Literal
 
 import numpy as np
+from joblib import Parallel, delayed
 from numpy import matrix
 from numpy.typing import NDArray
 from scipy.linalg import svd
 from scipy.sparse import csc_matrix, csr_matrix, issparse
+from scipy.sparse import vstack as sparse_vstack
 from scipy.sparse.linalg import svds
 from sklearn.utils.extmath import randomized_svd
 
 logger = logging.getLogger(__name__)
 
 
+N_CPUS = os.cpu_count()
+
+
 def cca(
     X: NDArray | csr_matrix | csc_matrix,
     Y: NDArray | csr_matrix | csc_matrix,
     n_components=None,
-    svd_solver: Literal["full", "partial", "randomized"] = "partial",
+    svd_solver: Literal["full", "partial", "randomized"] = "randomized",
     normalize: bool = False,
     random_state=42,
+    n_jobs: int = N_CPUS,
 ) -> tuple[NDArray, NDArray, NDArray]:
     """
     CCA-style integration for two single-cell matrices with unequal numbers of cells.
@@ -50,7 +57,7 @@ def cca(
     k = n_components or min(n1, n2)
 
     if issparse(X):
-        C = _cross_covariance_sparse(X, Y)
+        C = _cross_covariance_sparse(X, Y, n_jobs=n_jobs)
     else:
         C = _cross_covariance_dense(X, Y)
 
@@ -103,7 +110,7 @@ def _svd_decomposition(
     return Uc, s, Vct
 
 
-def _cross_covariance_sparse(X: csr_matrix, Y: csr_matrix) -> NDArray:
+def _cross_covariance_sparse(X: csr_matrix, Y: csr_matrix, n_jobs=N_CPUS) -> NDArray:
     _, p1 = X.shape
     _, p2 = Y.shape
     if p1 != p2:
@@ -118,7 +125,7 @@ def _cross_covariance_sparse(X: csr_matrix, Y: csr_matrix) -> NDArray:
     mux: matrix = X.mean(axis=0)
     muy: matrix = Y.mean(axis=0)
 
-    XYt: csr_matrix = X.dot(Y.T)
+    XYt: csr_matrix = _spmm_parallel(X, Y.T, n_jobs=n_jobs)
     Xmuyt: matrix = X.dot(muy.T)
     muxYt: matrix = Y.dot(mux.T).T
     muxmuyt: float = (mux @ muy.T)[0, 0]
@@ -152,3 +159,18 @@ def _dense_scale(A: NDArray) -> NDArray:
     A = np.asarray(A)
     eps = np.finfo(A.dtype).eps
     return A / (A.std(axis=0, ddof=1, keepdims=True) + eps)
+
+
+def _spmm_chunk(A_csr, X, start, stop):
+    return A_csr[start:stop, :] @ X
+
+
+def _spmm_parallel(A_csr: csr_matrix, X_csc: csc_matrix, n_jobs=N_CPUS):
+    n = A_csr.shape[0]
+
+    bounds = np.linspace(0, n, n_jobs + 1, dtype=int)
+    Ys = Parallel(n_jobs=n_jobs, prefer="processes")(
+        delayed(_spmm_chunk)(A_csr, X_csc, bounds[i], bounds[i + 1])
+        for i in range(n_jobs)
+    )
+    return sparse_vstack(Ys)  # result is sparse if X is sparse, dense otherwise

{sclab-0.3.1 → sclab-0.3.3}/src/sclab/preprocess/_cca_integrate.py

@@ -13,8 +13,8 @@ def cca_integrate(
     reference_batch: str | list[str] | None = None,
     mask_var: str | None = None,
     n_components: int = 30,
-    svd_solver: str = "partial",
-    normalize: bool = False,
+    svd_solver: str = "randomized",
+    normalize: bool = True,
     random_state: int | None = None,
 ):
     n_groups = adata.obs[key].nunique()
@@ -46,8 +46,8 @@ def cca_integrate_pair(
     adjusted_basis: str | None = None,
     mask_var: str | None = None,
     n_components: int = 30,
-    svd_solver: str = "partial",
-    normalize: bool = False,
+    svd_solver: str = "randomized",
+    normalize: bool = True,
     random_state: int | None = None,
 ):
     if basis is None:

{sclab-0.3.1 → sclab-0.3.3}/src/sclab/preprocess/_normalize_weighted.py

@@ -9,6 +9,7 @@ def normalize_weighted(
     adata: AnnData,
     target_scale: float | None = None,
     batch_key: str | None = None,
+    q: float = 0.99,
 ) -> None:
     if batch_key is not None:
         for _, idx in adata.obs.groupby(batch_key, observed=True).groups.items():
@@ -22,6 +23,8 @@ def normalize_weighted(
 
         return
 
+    target_scale = None
+
     X: csr_matrix
     Y: csr_matrix
     Z: csr_matrix
@@ -38,6 +41,7 @@ def normalize_weighted(
     Y.eliminate_zeros()
     Y.data = -Y.data * np.log(Y.data)
     entropy = Y.sum(axis=0)
+    entropy[:, entropy.A1 < np.quantile(entropy.A1, q)] *= 0.0
 
     Z = X.multiply(entropy)
     Z = Z.tocsr()
@@ -48,7 +52,7 @@ def normalize_weighted(
             "ignore", category=RuntimeWarning, message="divide by zero"
         )
         scale = Z.sum(axis=1)
-        Z = Z.multiply(1 / scale)
+        Z = X.multiply(1 / scale)
     Z = Z.tocsr()
 
     if target_scale is None:

sclab-0.3.3/src/sclab/preprocess/_pca.py

@@ -0,0 +1,51 @@
+from anndata import AnnData
+
+
+def pca(
+    adata: AnnData,
+    layer: str | None = None,
+    n_comps: int = 30,
+    mask_var: str | None = None,
+    batch_key: str | None = None,
+    reference_batch: str | None = None,
+    zero_center: bool = False,
+):
+    import scanpy as sc
+
+    pca_kwargs = dict(
+        n_comps=n_comps,
+        layer=layer,
+        mask_var=mask_var,
+        svd_solver="arpack",
+    )
+
+    if reference_batch:
+        obs_mask = adata.obs[batch_key] == reference_batch
+        adata_ref = adata[obs_mask].copy()
+        if mask_var == "highly_variable":
+            sc.pp.highly_variable_genes(
+                adata_ref, layer=f"{layer if layer else 'X'}_log1p", flavor="seurat"
+            )
+            hvg_seurat = adata_ref.var["highly_variable"]
+            sc.pp.highly_variable_genes(
+                adata_ref,
+                layer=layer,
+                flavor="seurat_v3_paper",
+                n_top_genes=hvg_seurat.sum(),
+            )
+            hvg_seurat_v3 = adata_ref.var["highly_variable"]
+            adata_ref.var["highly_variable"] = hvg_seurat | hvg_seurat_v3
+
+        sc.pp.pca(adata_ref, **pca_kwargs)
+        uns_pca = adata_ref.uns["pca"]
+        uns_pca["reference_batch"] = reference_batch
+        PCs = adata_ref.varm["PCs"]
+        adata.obsm["X_pca"] = adata.X.dot(PCs)
+        adata.uns["pca"] = uns_pca
+        adata.varm["PCs"] = PCs
+    else:
+        sc.pp.pca(adata, **pca_kwargs)
+        adata.obsm["X_pca"] = adata.X.dot(adata.varm["PCs"])
+
+    if zero_center:
+        adata.obsm["X_pca"] -= adata.obsm["X_pca"].mean(axis=0, keepdims=True)

sclab-0.3.3/src/sclab/preprocess/_preprocess.py

@@ -0,0 +1,155 @@
+import warnings
+from typing import Literal
+
+import numpy as np
+from anndata import AnnData, ImplicitModificationWarning
+from tqdm.auto import tqdm
+
+
+def preprocess(
+    adata: AnnData,
+    counts_layer: str = "counts",
+    group_by: str | None = None,
+    min_cells: int = 5,
+    min_genes: int = 5,
+    compute_hvg: bool = True,
+    regress_total_counts: bool = False,
+    regress_n_genes: bool = False,
+    normalization_method: Literal["library", "weighted", "none"] = "library",
+    target_scale: float = 1e4,
+    weighted_norm_quantile: float = 0.9,
+    log1p: bool = True,
+    scale: bool = True,
+):
+    import scanpy as sc
+
+    from ._normalize_weighted import normalize_weighted
+
+    with tqdm(total=100, bar_format="{percentage:3.0f}%|{bar}|") as pbar:
+        if counts_layer not in adata.layers:
+            adata.layers[counts_layer] = adata.X.copy()
+
+        if f"{counts_layer}_log1p" not in adata.layers:
+            adata.layers[f"{counts_layer}_log1p"] = sc.pp.log1p(
+                adata.layers[counts_layer].copy()
+            )
+        pbar.update(10)
+
+        adata.X = adata.layers[counts_layer].copy()
+        sc.pp.calculate_qc_metrics(
+            adata,
+            percent_top=None,
+            log1p=False,
+            inplace=True,
+        )
+        sc.pp.filter_cells(adata, min_genes=min_genes)
+        sc.pp.filter_genes(adata, min_cells=min_cells)
+        pbar.update(10)
+
+        sc.pp.calculate_qc_metrics(
+            adata,
+            percent_top=None,
+            log1p=False,
+            inplace=True,
+        )
+        pbar.update(10)
+
+        if compute_hvg:
+            if group_by is not None:
+                adata.var["highly_variable"] = False
+                for name, idx in adata.obs.groupby(
+                    group_by, observed=True
+                ).groups.items():
+                    hvg_seurat = sc.pp.highly_variable_genes(
+                        adata[idx],
+                        layer=f"{counts_layer}_log1p",
+                        flavor="seurat",
+                        inplace=False,
+                    )["highly_variable"]
+
+                    hvg_seurat_v3 = sc.pp.highly_variable_genes(
+                        adata[idx],
+                        layer=counts_layer,
+                        flavor="seurat_v3_paper",
+                        n_top_genes=hvg_seurat.sum(),
+                        inplace=False,
+                    )["highly_variable"]
+
+                    adata.var[f"highly_variable_{name}"] = hvg_seurat | hvg_seurat_v3
+                    adata.var["highly_variable"] |= adata.var[f"highly_variable_{name}"]
+
+            else:
+                sc.pp.highly_variable_genes(
+                    adata, layer=f"{counts_layer}_log1p", flavor="seurat"
+                )
+                hvg_seurat = adata.var["highly_variable"]
+
+                sc.pp.highly_variable_genes(
+                    adata,
+                    layer=counts_layer,
+                    flavor="seurat_v3_paper",
+                    n_top_genes=hvg_seurat.sum(),
+                )
+                hvg_seurat_v3 = adata.var["highly_variable"]
+
+                adata.var["highly_variable"] = hvg_seurat | hvg_seurat_v3
+
+        pbar.update(10)
+        pbar.update(10)
+
+        new_layer = counts_layer
+        if normalization_method == "library":
+            new_layer += "_normt"
+            sc.pp.normalize_total(adata, target_sum=target_scale)
+        elif normalization_method == "weighted":
+            new_layer += "_normw"
+            normalize_weighted(
+                adata,
+                target_scale=target_scale,
+                batch_key=group_by,
+                q=weighted_norm_quantile,
+            )
+
+        pbar.update(10)
+        pbar.update(10)
+
+        if log1p:
+            new_layer += "_log1p"
+            adata.uns.pop("log1p", None)
+            sc.pp.log1p(adata)
+        pbar.update(10)
+
+        vars_to_regress = []
+        if regress_n_genes:
+            vars_to_regress.append("n_genes_by_counts")
+
+        if regress_total_counts and log1p:
+            adata.obs["log1p_total_counts"] = np.log1p(adata.obs["total_counts"])
+            vars_to_regress.append("log1p_total_counts")
+        elif regress_total_counts:
+            vars_to_regress.append("total_counts")
+
+        if vars_to_regress:
+            new_layer += "_regr"
+            sc.pp.regress_out(adata, keys=vars_to_regress, n_jobs=1)
+        pbar.update(10)
+
+        if scale:
+            new_layer += "_scale"
+            if group_by is not None:
+                for _, idx in adata.obs.groupby(group_by, observed=True).groups.items():
+                    with warnings.catch_warnings():
+                        warnings.filterwarnings(
+                            "ignore",
+                            category=ImplicitModificationWarning,
+                            message="Modifying `X` on a view results in data being overridden",
+                        )
+                        adata[idx].X = sc.pp.scale(adata[idx].X, zero_center=False)
+            else:
+                sc.pp.scale(adata, zero_center=False)
+
+        adata.layers[new_layer] = adata.X.copy()
+
+        pbar.update(10)
+
+        adata.X = adata.X.astype(np.float32)

sclab-0.3.3/src/sclab/preprocess/_qc.py

@@ -0,0 +1,38 @@
+import numpy as np
+from anndata import AnnData
+
+
+def qc(
+    adata: AnnData,
+    counts_layer: str = "counts",
+    min_counts: int = 50,
+    min_genes: int = 5,
+    min_cells: int = 5,
+    max_rank: int = 0,
+):
+    import scanpy as sc
+
+    if counts_layer not in adata.layers:
+        adata.layers[counts_layer] = adata.X.copy()
+
+    adata.layers["qc_tmp_current_X"] = adata.X
+    adata.X = adata.layers[counts_layer].copy()
+    rowsums = np.asarray(adata.X.sum(axis=1)).squeeze()
+
+    obs_idx = adata.obs_names[rowsums >= min_counts]
+    adata._inplace_subset_obs(obs_idx)
+
+    sc.pp.calculate_qc_metrics(adata, percent_top=None, log1p=False, inplace=True)
+
+    sc.pp.filter_cells(adata, min_genes=min_genes)
+    sc.pp.filter_genes(adata, min_cells=min_cells)
+    sc.pp.calculate_qc_metrics(adata, percent_top=None, log1p=False, inplace=True)
+    adata.obs["barcode_rank"] = adata.obs["total_counts"].rank(ascending=False)
+
+    # Restore original X
+    adata.X = adata.layers.pop("qc_tmp_current_X")
+
+    if max_rank > 0:
+        series = adata.obs["barcode_rank"]
+        index = series.loc[series < max_rank].index
+        adata._inplace_subset_obs(index)

{sclab-0.3.1 → sclab-0.3.3}/src/sclab/preprocess/_transfer_metadata.py

@@ -23,18 +23,19 @@ def transfer_metadata(
     min_neighs: int = 5,
     weight_by: Literal["connectivity", "distance", "constant"] = "connectivity",
 ):
-    D: csr_matrix = adata.obsp["distances"]
-    C: csr_matrix = adata.obsp["connectivities"]
+    D: csr_matrix = adata.obsp["distances"].copy()
+    C: csr_matrix = adata.obsp["connectivities"].copy()
     D = D.tocsr()
+    W: csr_matrix
 
     match weight_by:
         case "connectivity":
-            W = C.tocsr()
+            W = C.tocsr().copy()
         case "distance":
-            W = D.tocsr()
+            W = D.tocsr().copy()
             W.data = 1.0 / W.data
         case "constant":
-            W = D.tocsr()
+            W = D.tocsr().copy()
             W.data[:] = 1.0
         case _:
             raise ValueError(f"Unsupported weight_by {weight_by}")

{sclab-0.3.1 → sclab-0.3.3}/src/sclab/tools/cellflow/pseudotime/_pseudotime.py

@@ -280,6 +280,7 @@ def estimate_periodic_pseudotime_start(
     time_key: str = "pseudotime",
     bandwidth: float = 1 / 64,
     show_plot: bool = False,
+    nth_root: int = 1,
 ):
     # TODO: Test implementation
     pseudotime = adata.obs[time_key].values.copy()
@@ -316,7 +317,10 @@ def estimate_periodic_pseudotime_start(
     roots = (x[idx] + x[1:][idx]) / 2
     heights = yp[idx]
 
-    max_peak_x = roots[heights.argmin()]
+    roots = roots[heights.argsort()]
+    heights = heights[heights.argsort()]
+
+    max_peak_x = roots[nth_root - 1]
 
     if show_plot:
         plt.hist(

{sclab-0.3.1 → sclab-0.3.3}/src/sclab/tools/differential_expression/__init__.py

@@ -1,5 +1,7 @@
 from ._pseudobulk_edger import pseudobulk_edger
+from ._pseudobulk_limma import pseudobulk_limma
 
 __all__ = [
     "pseudobulk_edger",
+    "pseudobulk_limma",
 ]

{sclab-0.3.1 → sclab-0.3.3}/src/sclab/tools/differential_expression/_pseudobulk_edger.py

@@ -12,9 +12,9 @@ def pseudobulk_edger(
     cell_identity_key: str | None = None,
     batch_key: str | None = None,
     layer: str | None = None,
-    replicas_per_group: int = 10,
+    replicas_per_group: int = 5,
     min_cells_per_group: int = 30,
-    bootstrap_sampling: bool = True,
+    bootstrap_sampling: bool = False,
     use_cells: dict[str, list[str]] | None = None,
     aggregate: bool = True,
     verbosity: int = 0,
@@ -134,7 +134,7 @@ def pseudobulk_edger(
 
         try:
             R(f"""
-                outs <- fit_model(aggr_adata, "{gk}", "{cell_identity_key}", "{batch_key}", verbosity = {verbosity})
+                outs <- fit_edger_model(aggr_adata, "{gk}", "{cell_identity_key}", "{batch_key}", verbosity = {verbosity})
                 fit <- outs$fit
                 y <- outs$y
             """)
@@ -214,33 +214,20 @@ suppressPackageStartupMessages({
     library(MAST)
 })
 
-fit_model <- function(adata_, group_key, cell_identity_key = "None", batch_key = "None", verbosity = 0){
+fit_edger_model <- function(adata_, group_key, cell_identity_key = "None", batch_key = "None", verbosity = 0){
 
     if (verbosity > 0){
         cat("Group key:", group_key, "\n")
         cat("Cell identity key:", cell_identity_key, "\n")
     }
 
-    # create an edgeR object with counts and grouping factor
-    y <- DGEList(assay(adata_, "X"), group = colData(adata_)[[group_key]])
-    # filter out genes with low counts
-    if (verbosity > 1){
-        cat("Dimensions before subsetting:", dim(y), "\n")
-    }
-    keep <- filterByExpr(y)
-    y <- y[keep, , keep.lib.sizes=FALSE]
-    if (verbosity > 1){
-        cat("Dimensions after subsetting:", dim(y), "\n")
-    }
-
-    # normalize
-    y <- calcNormFactors(y)
     # create a vector that is concatentation of condition and cell type that we will later use with contrasts
     if (cell_identity_key == "None"){
         group <- colData(adata_)[[group_key]]
     } else {
         group <- paste0(colData(adata_)[[group_key]], "_", colData(adata_)[[cell_identity_key]])
     }
+
     if (verbosity > 1){
         cat("Group(s):", group, "\n")
     }
@@ -255,10 +242,28 @@ fit_model <- function(adata_, group_key, cell_identity_key = "None", batch_key =
         design <- model.matrix(~ 0 + group + replica + batch)
     }
 
+    # create an edgeR object with counts and grouping factor
+    y <- DGEList(assay(adata_, "X"), group = colData(adata_)[[group_key]])
+
+    # filter out genes with low counts
+    if (verbosity > 1){
+        cat("Dimensions before subsetting:", dim(y), "\n")
+    }
+
+    keep <- filterByExpr(y)
+    y <- y[keep, , keep.lib.sizes=FALSE]
+    if (verbosity > 1){
+        cat("Dimensions after subsetting:", dim(y), "\n")
+    }
+
+    # normalize
+    y <- calcNormFactors(y)
+
     # estimate dispersion
     y <- estimateDisp(y, design = design)
     # fit the model
     fit <- glmQLFit(y, design)
+
     return(list("fit"=fit, "design"=design, "y"=y))
 }
 """
@@ -282,9 +287,7 @@ def _try_imports():
     except ModuleNotFoundError:
         message = (
             "edger_pseudobulk requires rpy2 and anndata2ri to be installed.\n"
-            "or\n"
-            "$ pip install rpy2 sclab-tools[r]\n"
-            "or\n"
+            "please install with one of the following:\n"
             "$ pip install rpy2 anndata2ri\n"
             "or\n"
             "$ conda install -c conda-forge rpy2 anndata2ri\n"

sclab-0.3.3/src/sclab/tools/differential_expression/_pseudobulk_limma.py

@@ -0,0 +1,257 @@
+import pandas as pd
+from anndata import AnnData
+
+from ._pseudobulk_helpers import aggregate_and_filter
+
+
+def pseudobulk_limma(
+    adata_: AnnData,
+    group_key: str,
+    condition_group: str | list[str] | None = None,
+    reference_group: str | None = None,
+    cell_identity_key: str | None = None,
+    batch_key: str | None = None,
+    layer: str | None = None,
+    replicas_per_group: int = 5,
+    min_cells_per_group: int = 30,
+    bootstrap_sampling: bool = False,
+    use_cells: dict[str, list[str]] | None = None,
+    aggregate: bool = True,
+    verbosity: int = 0,
+) -> dict[str, pd.DataFrame]:
+    _try_imports()
+    import anndata2ri  # noqa: F401
+    import rpy2.robjects as robjects
+    from rpy2.rinterface_lib.embedded import RRuntimeError  # noqa: F401
+    from rpy2.robjects import pandas2ri  # noqa: F401
+    from rpy2.robjects.conversion import localconverter  # noqa: F401
+
+    R = robjects.r
+
+    if aggregate:
+        aggr_adata = aggregate_and_filter(
+            adata_,
+            group_key,
+            cell_identity_key,
+            layer,
+            replicas_per_group,
+            min_cells_per_group,
+            bootstrap_sampling,
+            use_cells,
+        )
+    else:
+        aggr_adata = adata_.copy()
+
+    with localconverter(anndata2ri.converter):
+        R.assign("aggr_adata", aggr_adata)
+
+    # defines the R function for fitting the model with limma
+    R(_fit_model_r_script)
+
+    if condition_group is None:
+        condition_group_list = aggr_adata.obs[group_key].unique()
+    elif isinstance(condition_group, str):
+        condition_group_list = [condition_group]
+    else:
+        condition_group_list = condition_group
+
+    if cell_identity_key is not None:
+        cids = aggr_adata.obs[cell_identity_key].unique()
+    else:
+        cids = [""]
+
+    tt_dict = {}
+    for condition_group in condition_group_list:
+        if reference_group is not None and condition_group == reference_group:
+            continue
+
+        if verbosity > 0:
+            print(f"Fitting model for {condition_group}...")
+
+        if reference_group is not None:
+            gk = group_key
+        else:
+            gk = f"{group_key}_{condition_group}"
+
+        try:
+            R(f"""
+                outs <- fit_limma_model(aggr_adata, "{gk}", "{cell_identity_key}", verbosity = {verbosity})
+                fit <- outs$fit
+                v <- outs$v
+            """)
+
+        except RRuntimeError as e:
+            print("Error fitting model for", condition_group)
+            print("Error:", e)
+            print("Skipping...", flush=True)
+            continue
+
+        if reference_group is None:
+            new_contrasts_tuples = [
+                (
+                    condition_group,  # common prefix
+                    "",  # condition group
+                    "not",  # reference group
+                    cid,  # cell identity
+                )
+                for cid in cids
+            ]
+
+        else:
+            new_contrasts_tuples = [
+                (
+                    "",  # common prefix
+                    condition_group,  # condition group
+                    reference_group,  # reference group
+                    cid,  # cell identity
+                )
+                for cid in cids
+            ]
+
+        new_contrasts = [
+            f"group{cnd}{prefix}_{cid}".strip("_")
+            + "-"
+            + f"group{ref}{prefix}_{cid}".strip("_")
+            for prefix, cnd, ref, cid in new_contrasts_tuples
+        ]
+
+        for contrast, contrast_tuple in zip(new_contrasts, new_contrasts_tuples):
+            prefix, cnd, ref, cid = contrast_tuple
+
+            if ref == "not":
+                cnd, ref = "", "rest"
+
+            contrast_key = f"{prefix}{cnd}_vs_{ref}"
+            if cid:
+                contrast_key = f"{cell_identity_key}:{cid}|{contrast_key}"
+
+            if verbosity > 0:
+                print(f"Computing contrast: {contrast_key}... ({contrast})")
+
+            R(f"myContrast <- makeContrasts('{contrast}', levels = v$design)")
+            R("fit2 <- contrasts.fit(fit, myContrast)")
+            R("fit2 <- eBayes(fit2)")
+            R("tt <- topTable(fit2, n = Inf)")
+            tt: pd.DataFrame = pandas2ri.rpy2py(R("tt"))
+            tt.index.name = "gene_ids"
+
+            genes = tt.index
+            cnd, ref = [c[5:] for c in contrast.split("-")]
+            tt["pct_expr_cnd"] = aggr_adata.var[f"pct_expr_{cnd}"].loc[genes]
+            tt["pct_expr_ref"] = aggr_adata.var[f"pct_expr_{ref}"].loc[genes]
+            tt["num_expr_cnd"] = aggr_adata.var[f"num_expr_{cnd}"].loc[genes]
+            tt["num_expr_ref"] = aggr_adata.var[f"num_expr_{ref}"].loc[genes]
+            tt["tot_expr_cnd"] = aggr_adata.var[f"tot_expr_{cnd}"].loc[genes]
+            tt["tot_expr_ref"] = aggr_adata.var[f"tot_expr_{ref}"].loc[genes]
+            tt["mean_cnd"] = tt["tot_expr_cnd"] / tt["num_expr_cnd"]
+            tt["mean_ref"] = tt["tot_expr_ref"] / tt["num_expr_ref"]
+            tt_dict[contrast_key] = tt
+
+    return tt_dict
+
+
+_fit_model_r_script = """
+suppressPackageStartupMessages({
+    library(edgeR)
+    library(limma)
+    library(MAST)
+})
+
+fit_limma_model <- function(adata_, group_key, cell_identity_key = "None", batch_key = "None", verbosity = 0){
+
+    if (verbosity > 0){
+        cat("Group key:", group_key, "\n")
+        cat("Cell identity key:", cell_identity_key, "\n")
+    }
+
+    # create a vector that is concatentation of condition and cell type that we will later use with contrasts
+    if (cell_identity_key == "None"){
+        group <- colData(adata_)[[group_key]]
+    } else {
+        group <- paste0(colData(adata_)[[group_key]], "_", colData(adata_)[[cell_identity_key]])
+    }
+
+    if (verbosity > 1){
+        cat("Group(s):", group, "\n")
+    }
+
+    group   <- factor(group)
+    replica <- factor(colData(adata_)$replica)
+
+    # create a design matrix
+    if (batch_key == "None"){
+        design <- model.matrix(~ 0 + group + replica)
+    } else {
+        batch  <- factor(colData(adata_)[[batch_key]])
+        design <- model.matrix(~ 0 + group + replica + batch)
+    }
+    colnames(design) <- make.names(colnames(design))
+
+    # create an edgeR object with counts and grouping factor
+    y <- DGEList(assay(adata_, "X"), group = group)
+
+    # filter out genes with low counts
+    if (verbosity > 1){
+        cat("Dimensions before subsetting:", dim(y), "\n")
+    }
+
+    keep <- filterByExpr(y, design = design)
+    y <- y[keep, , keep.lib.sizes=FALSE]
+    if (verbosity > 1){
+        cat("Dimensions after subsetting:", dim(y), "\n")
+    }
+
+    # normalize
+    y <- calcNormFactors(y)
+
+    # Apply voom transformation to prepare for linear modeling
+    v <- voom(y, design, plot = verbosity > 1)
+    
+    # Fit the linear model
+    fit <- lmFit(v, design)
+    ne <- limma::nonEstimable(design)
+    if (!is.null(ne) && verbosity > 0) cat("Non-estimable:", ne, "\n")
+    fit <- eBayes(fit)
+    
+    return(list("fit"=fit, "design"=design, "v"=v))
+}
+"""
+
+
+def _try_imports():
+    try:
+        import rpy2.robjects as robjects
+        from rpy2.robjects.packages import PackageNotInstalledError, importr
+
+        robjects.r("options(warn=-1)")
+        import anndata2ri  # noqa: F401
+        from rpy2.rinterface_lib.embedded import RRuntimeError  # noqa: F401
+        from rpy2.robjects import numpy2ri, pandas2ri  # noqa: F401
+        from rpy2.robjects.conversion import localconverter  # noqa: F401
+
+        importr("edgeR")
+        importr("limma")
+        importr("MAST")
+        importr("SingleCellExperiment")
+
+    except ModuleNotFoundError:
+        message = (
+            "pseudobulk_limma requires rpy2 and anndata2ri to be installed.\n"
+            "please install with one of the following:\n"
+            "$ pip install rpy2 anndata2ri\n"
+            "or\n"
+            "$ conda install -c conda-forge rpy2 anndata2ri\n"
+        )
+        print(message)
+        raise ModuleNotFoundError(message)
+
+    except PackageNotInstalledError:
+        message = (
+            "pseudobulk_limma requires the following R packages to be installed: limma, edgeR, MAST, and SingleCellExperiment.\n"
+            "> \n"
+            "> if (!require('BiocManager', quietly = TRUE)) install.packages('BiocManager');\n"
+            "> BiocManager::install(c('limma', 'edgeR', 'MAST', 'SingleCellExperiment'));\n"
+            "> \n"
+        )
+        print(message)
+        raise ImportError(message)