sclab 0.1.7__py3-none-any.whl → 0.3.4__py3-none-any.whl

sclab/examples/processor_steps/_gene_expression.py

@@ -0,0 +1,125 @@
+import numpy as np
+import pandas as pd
+import plotly.colors as pc
+import plotly.express as px
+from ipywidgets import Combobox, Dropdown
+
+from sclab.dataset.processor import Processor
+from sclab.dataset.processor.step import ProcessorStepBase
+
+colorscales = list(
+    filter(lambda s: "swatch" not in s and not s.startswith("_"), dir(pc.sequential))
+)
+
+
+class GeneExpression(ProcessorStepBase):
+    parent: Processor
+    name: str = "gene_expression"
+    description: str = "Gene Expression"
+
+    run_button_description = "Plot Expression"
+
+    def __init__(self, parent: Processor) -> None:
+        df = parent.dataset.metadata.select_dtypes("number")
+        df = parent.dataset.metadata
+        axis_key_options = {"": None, **{c: c for c in df.columns}}
+
+        gene_input_options = parent.dataset.adata.var_names
+        genes_df = parent.dataset.adata.var
+        info_cols = ["name", "symbol", "description"]
+        for col in [
+            c for c in genes_df.columns if any([s.lower() in c for s in info_cols])
+        ]:
+            new_info = genes_df[col].astype(str).str.replace("nan", "")
+            gene_input_options = gene_input_options + " - " + new_info
+
+        variable_controls = dict(
+            gene_input=Combobox(
+                placeholder="Type gene name",
+                options=gene_input_options.to_list(),
+                description="Gene",
+                ensure_option=True,
+            ),
+            layer=Dropdown(
+                options=tuple(parent.dataset.adata.layers.keys()),
+                value=None,
+                description="Layer",
+            ),
+            time_key=Dropdown(
+                options=axis_key_options,
+                value=None,
+                description="Horiz. axis",
+            ),
+            colorscale=Dropdown(
+                options=colorscales, value="Oryel", description="Col. scale"
+            ),
+        )
+
+        super().__init__(
+            parent=parent,
+            fixed_params={},
+            variable_controls=variable_controls,
+        )
+
+        self.variable_controls["gene_input"].observe(self.send_plot, names="value")
+        self.variable_controls["layer"].observe(self.send_plot, names="value")
+        self.variable_controls["time_key"].observe(self.send_plot, names="value")
+        self.variable_controls["colorscale"].observe(self.send_plot, names="value")
+
+    def function(self, *pargs, **kwargs):
+        self.send_plot({})
+
+    def send_plot(self, change: dict):
+        adata = self.parent.dataset.adata
+        metadata = self.parent.dataset.metadata
+        selected_cells = self.parent.dataset.selected_rows
+
+        gene_input: str = self.variable_controls["gene_input"].value
+        layer: str = self.variable_controls["layer"].value
+        time_key: str = self.variable_controls["time_key"].value
+        colorscale: str = self.variable_controls["colorscale"].value
+
+        if gene_input is None or gene_input == "":
+            self.update_output("")
+            return
+
+        if layer is None or layer == "":
+            self.update_output("")
+            return
+
+        gene_id = gene_input.split(" ")[0]
+
+        if layer == "X":
+            X = adata[:, gene_id].X
+        else:
+            X = adata[:, gene_id].layers[layer]
+
+        E = np.asarray(X.sum(axis=1)).flatten()
+
+        self.update_output(f"Showing gene: {gene_id}")
+        # self.variable_controls["gene_input"].value = ""
+
+        df = pd.DataFrame({gene_id: E}, index=adata.obs.index)
+        metadata = metadata.join(df)
+        if selected_cells.size > 0:
+            metadata = metadata.loc[selected_cells]
+
+        if time_key is None:
+            self.broker.publish(
+                "dplt_plot_figure_request",
+                metadata=metadata,
+                colorby=gene_id,
+                color_continuous_scale=colorscale,
+            )
+            return
+
+        fig = px.scatter(
+            metadata,
+            x=time_key,
+            y=gene_id,
+            color=gene_id,
+            color_continuous_scale=colorscale,
+            hover_name=adata.obs.index,
+            title=f"Gene: {gene_id}, Layer: {layer}",
+        )
+        self.broker.publish("dplt_plot_figure_request", figure=fig)

sclab/examples/processor_steps/_integration.py

@@ -0,0 +1,116 @@
+from ipywidgets import Dropdown, IntText
+
+from sclab.dataset.processor import Processor
+from sclab.dataset.processor.step import ProcessorStepBase
+
+
+class Integration(ProcessorStepBase):
+    parent: Processor
+    name: str = "integration"
+    description: str = "Integration"
+
+    def __init__(self, parent: Processor) -> None:
+        cat_metadata = parent.dataset._metadata.select_dtypes(
+            include=["object", "category"]
+        )
+        cat_options = {"": None, **{c: c for c in cat_metadata.columns}}
+
+        variable_controls = dict(
+            use_rep=Dropdown(
+                options=tuple(parent.dataset.adata.obsm.keys()),
+                value=None,
+                description="Use rep.",
+            ),
+            group_by=Dropdown(
+                options=cat_options,
+                value="batch" if "batch" in cat_options else None,
+                description="GroupBy",
+            ),
+            reference_batch=Dropdown(
+                description="Reference Batch",
+            ),
+            flavor=Dropdown(
+                options=["cca", "harmony", "scanorama"],
+                value="cca",
+                description="Flavor",
+            ),
+            max_iters=IntText(
+                value=20,
+                description="Max iters",
+            ),
+        )
+
+        def update_reference_batch(*args, **kwargs):
+            group_by = variable_controls["group_by"].value
+            options = {
+                "": None,
+                **{
+                    c: c
+                    for c in self.parent.dataset.adata.obs[group_by]
+                    .sort_values()
+                    .unique()
+                },
+            }
+            variable_controls["reference_batch"].options = options
+
+        variable_controls["group_by"].observe(update_reference_batch, names="value")
+
+        super().__init__(
+            parent=parent,
+            fixed_params={},
+            variable_controls=variable_controls,
+        )
+
+    def function(
+        self,
+        use_rep: str | None,
+        group_by: str,
+        flavor: str,
+        reference_batch: str | None,
+        max_iters: int,
+    ):
+        adata = self.parent.dataset.adata
+
+        if use_rep is None:
+            use_rep = "X"
+
+        key_added = f"{use_rep}_{flavor}"
+        kvargs = {
+            "adata": adata,
+            "key": group_by,
+            "basis": use_rep,
+            "adjusted_basis": key_added,
+        }
+
+        self.broker.std_output.clear_output(wait=False)
+        with self.broker.std_output:
+            match flavor:
+                case "cca":
+                    from sclab.preprocess import cca_integrate
+
+                    cca_integrate(
+                        **kvargs,
+                        reference_batch=reference_batch,
+                    )
+
+                case "harmony":
+                    from sclab.preprocess import harmony_integrate
+
+                    harmony_integrate(
+                        **kvargs,
+                        reference_batch=reference_batch,
+                        max_iter_harmony=max_iters,
+                    )
+
+                case "scanorama":
+                    from scanpy.external.pp import scanorama_integrate
+
+                    scanorama_integrate(**kvargs)
+                case _:
+                    raise ValueError(f"Unknown flavor: {flavor}")
+
+        self.broker.publish(
+            "dset_data_dict_change",
+            self.parent.dataset.data_dict,
+            key_added,
+        )

sclab/examples/processor_steps/_neighbors.py

@@ -1,4 +1,4 @@
-from ipywidgets import Dropdown, IntText
+from ipywidgets import Dropdown, IntRangeSlider, IntText
 
 from sclab.dataset.processor import Processor
 from sclab.dataset.processor.step import ProcessorStepBase
@@ -6,6 +6,8 @@ from sclab.dataset.processor.step import ProcessorStepBase
 
 class Neighbors(ProcessorStepBase):
     parent: Processor
+    name: str = "neighbors"
+    description: str = "Neighbors"
 
     def __init__(self, parent: Processor) -> None:
         try:
@@ -20,7 +22,12 @@ class Neighbors(ProcessorStepBase):
                 description="Use rep.",
             ),
             n_neighbors=IntText(value=20, description="N neighbors"),
-            n_dims=IntText(value=10, description="N Dims"),
+            dims=IntRangeSlider(
+                min=1,
+                max=30,
+                value=(1, 10),
+                description="Use dims",
+            ),
             metric=Dropdown(
                 options=["euclidean", "cosine"],
                 value="euclidean",
@@ -29,10 +36,16 @@ class Neighbors(ProcessorStepBase):
             **parent.make_groupbybatch_checkbox(),
         )
 
+        def update_dims_range(*args, **kwargs):
+            adata = self.parent.dataset.adata
+            use_rep = variable_controls["use_rep"].value
+            max_dim = adata.obsm[use_rep].shape[1]
+            variable_controls["dims"].max = max_dim
+
+        variable_controls["use_rep"].observe(update_dims_range, names="value")
+
         super().__init__(
             parent=parent,
-            name="neighbors",
-            description="Neighbors",
             fixed_params={},
             variable_controls=variable_controls,
         )
@@ -41,13 +54,20 @@ class Neighbors(ProcessorStepBase):
         self,
         n_neighbors: int = 20,
         use_rep: str = "X_pca",
-        n_dims: int = 10,
+        dims: tuple[int, int] = (1, 10),
         metric: str = "euclidean",
         group_by_batch: bool = False,
     ):
         import scanpy as sc
 
         adata = self.parent.dataset.adata
+        min_dim, max_dim = dims
+        min_dim = min_dim - 1
+
+        if min_dim > 0:
+            adata.obsm[use_rep + "_trimmed"] = adata.obsm[use_rep][:, min_dim:max_dim]
+            use_rep = use_rep + "_trimmed"
+        n_dims = max_dim - min_dim
 
         if group_by_batch and self.parent.batch_key:
             group_by = self.parent.batch_key
@@ -58,7 +78,7 @@ class Neighbors(ProcessorStepBase):
                 n_pcs=n_dims,
                 use_annoy=False,
                 metric=metric,
-                pynndescent_n_neighbors=n_neighbors,
+                neighbors_within_batch=n_neighbors,
             )
         else:
             sc.pp.neighbors(

sclab/examples/processor_steps/_pca.py

@@ -1,7 +1,6 @@
-import numpy as np
 import pandas as pd
 import plotly.express as px
-from ipywidgets import Button, Dropdown, IntText
+from ipywidgets import Button, Checkbox, Dropdown, IntText
 
 from sclab.dataset.processor import Processor
 from sclab.dataset.processor.step import ProcessorStepBase
@@ -9,6 +8,8 @@ from sclab.dataset.processor.step import ProcessorStepBase
 
 class PCA(ProcessorStepBase):
     parent: Processor
+    name: str = "pca"
+    description: str = "PCA"
 
     def __init__(self, parent: Processor) -> None:
         try:
@@ -25,12 +26,11 @@ class PCA(ProcessorStepBase):
             n_comps=IntText(value=30, description="N comps."),
             mask_var=Dropdown(options=mask_var_options, description="Genes mask"),
             **parent.make_selectbatch_drowpdown(description="Reference Batch"),
+            zero_center=Checkbox(value=False, description="Zero center"),
         )
 
         super().__init__(
             parent=parent,
-            name="pca",
-            description="PCA",
             fixed_params={},
             variable_controls=variable_controls,
         )
@@ -57,6 +57,7 @@ class PCA(ProcessorStepBase):
         n_comps: int = 30,
         mask_var: str | None = None,
         reference_batch: str | None = None,
+        zero_center: bool = False,
     ):
         import scanpy as sc
 
@@ -64,7 +65,9 @@ class PCA(ProcessorStepBase):
         counts_layer = self.parent.dataset.counts_layer
 
         if reference_batch:
-            obs_mask = adata.obs[self.parent.batch_key] == reference_batch
+            batch_key = self.parent.batch_key
+
+            obs_mask = adata.obs[batch_key] == reference_batch
             adata_ref = adata[obs_mask].copy()
             if mask_var == "highly_variable":
                 sc.pp.highly_variable_genes(
@@ -85,13 +88,15 @@ class PCA(ProcessorStepBase):
             uns_pca = adata_ref.uns["pca"]
             uns_pca["reference_batch"] = reference_batch
             PCs = adata_ref.varm["PCs"]
-            X_pca: np.ndarray = adata.X.dot(PCs)
-            X_pca = X_pca - X_pca.mean(axis=0, keepdims=True)
-            adata.obsm["X_pca"] = X_pca
+            adata.obsm["X_pca"] = adata.X.dot(PCs)
             adata.uns["pca"] = uns_pca
             adata.varm["PCs"] = PCs
         else:
             sc.pp.pca(adata, n_comps=n_comps, mask_var=mask_var, svd_solver="arpack")
+            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)
 
         self.plot_variance_ratio_button.disabled = False
         self.broker.publish(

sclab/examples/processor_steps/_preprocess.py

@@ -1,4 +1,7 @@
+import warnings
+
 import numpy as np
+from anndata import ImplicitModificationWarning
 from ipywidgets import Checkbox, Dropdown
 from tqdm.auto import tqdm
 
@@ -8,6 +11,8 @@ from sclab.dataset.processor.step import ProcessorStepBase
 
 class Preprocess(ProcessorStepBase):
     parent: Processor
+    name: str = "preprocess"
+    description: str = "Preprocess"
 
     def __init__(self, parent: Processor) -> None:
         try:
@@ -50,8 +55,6 @@ class Preprocess(ProcessorStepBase):
 
         super().__init__(
             parent=parent,
-            name="preprocess",
-            description="Preprocess",
             fixed_params={},
             variable_controls=variable_controls,
         )
@@ -103,25 +106,41 @@ class Preprocess(ProcessorStepBase):
         )
         pbar.update(10)
 
-        sc.pp.highly_variable_genes(
-            adata,
-            layer=f"{layer}_log1p",
-            flavor="seurat",
-            batch_key=group_by,
-        )
-        hvg_seurat = adata.var["highly_variable"]
-        sc.pp.highly_variable_genes(
-            adata,
-            layer=layer,
-            flavor="seurat_v3_paper",
-            batch_key=group_by,
-            n_top_genes=hvg_seurat.sum(),
-        )
-        hvg_seurat_v3 = adata.var["highly_variable"]
+        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"{layer}_log1p",
+                    flavor="seurat",
+                    inplace=False,
+                )["highly_variable"]
+
+                hvg_seurat_v3 = sc.pp.highly_variable_genes(
+                    adata[idx],
+                    layer=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"{layer}_log1p", flavor="seurat")
+            hvg_seurat = adata.var["highly_variable"]
+
+            sc.pp.highly_variable_genes(
+                adata,
+                layer=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
 
-        adata.var["highly_variable"] = hvg_seurat | hvg_seurat_v3
-        adata.var["highly_variable_seurat"] = hvg_seurat
-        adata.var["highly_variable_seurat_v3"] = hvg_seurat_v3
         pbar.update(10)
         pbar.update(10)
 
@@ -129,7 +148,6 @@ class Preprocess(ProcessorStepBase):
         if normalize_total:
             new_layer += "_normt"
             sc.pp.normalize_total(adata, target_sum=1e4)
-            adata.layers[new_layer] = adata.X.copy()
 
         pbar.update(10)
         pbar.update(10)
@@ -138,7 +156,6 @@ class Preprocess(ProcessorStepBase):
             new_layer += "_log1p"
             adata.uns.pop("log1p", None)
             sc.pp.log1p(adata)
-            adata.layers[new_layer] = adata.X.copy()
         pbar.update(10)
 
         vars_to_regress = []
@@ -154,13 +171,23 @@ class Preprocess(ProcessorStepBase):
         if vars_to_regress:
             new_layer += "_regr"
             sc.pp.regress_out(adata, keys=vars_to_regress, n_jobs=1)
-            adata.layers[new_layer] = adata.X.copy()
         pbar.update(10)
 
         if scale:
             new_layer += "_scale"
-            sc.pp.scale(adata, zero_center=False)
-            adata.layers[new_layer] = adata.X.copy()
+            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)
 

sclab/examples/processor_steps/_qc.py

@@ -1,3 +1,4 @@
+import numpy as np
 from ipywidgets import Dropdown, IntText
 
 from sclab.dataset.processor import Processor
@@ -6,6 +7,8 @@ from sclab.dataset.processor.step import ProcessorStepBase
 
 class QC(ProcessorStepBase):
     parent: Processor
+    name: str = "qc"
+    description: str = "QC"
 
     def __init__(self, parent: Processor) -> None:
         try:
@@ -19,6 +22,7 @@ class QC(ProcessorStepBase):
                 value="counts",
                 description="Layer",
             ),
+            min_counts=IntText(value=50, description="Min. Counts"),
             min_genes=IntText(value=5, description="Min. Genes"),
             min_cells=IntText(value=0, description="Min. Cells"),
             max_rank=IntText(value=0, description="Max. Rank"),
@@ -36,8 +40,6 @@ class QC(ProcessorStepBase):
 
         super().__init__(
             parent=parent,
-            name="qc",
-            description="QC",
             fixed_params={},
             variable_controls=variable_controls,
         )
@@ -45,8 +47,10 @@ class QC(ProcessorStepBase):
     def compute_qc_metrics(
         self,
         layer: str | None = None,
+        min_counts: int = 50,
         min_genes: int = 5,
         min_cells: int = 5,
+        max_rank: int = 0,
     ):
         import scanpy as sc
 
@@ -58,6 +62,11 @@ class QC(ProcessorStepBase):
 
         adata.layers["qc_tmp_current_X"] = adata.X
         adata.X = adata.layers[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)
@@ -68,19 +77,26 @@ class QC(ProcessorStepBase):
         # Restore original X
         adata.X = adata.layers.pop("qc_tmp_current_X")
 
+        if max_rank > 0:
+            series = self.parent.dataset.adata.obs["barcode_rank"]
+            index = series.loc[series < max_rank].index
+            self.parent.dataset.filter_rows(index)
+
     def function(
         self,
         layer: str | None = None,
+        min_counts: int = 50,
         min_genes: int = 5,
         min_cells: int = 5,
         max_rank: int = 0,
     ):
-        self.compute_qc_metrics(layer, min_genes, min_cells)
-
-        if max_rank > 0:
-            series = self.parent.dataset.adata.obs["barcode_rank"]
-            index = series.loc[series < max_rank].index
-            self.parent.dataset.filter_rows(index)
+        self.compute_qc_metrics(
+            layer,
+            min_counts,
+            min_genes,
+            min_cells,
+            max_rank,
+        )
 
         self.broker.publish("dset_metadata_change", self.parent.dataset.metadata)
         self.broker.publish(

sclab/examples/processor_steps/_umap.py

@@ -7,6 +7,8 @@ from sclab.dataset.processor.step import ProcessorStepBase
 
 class UMAP(ProcessorStepBase):
     parent: Processor
+    name: str = "umap"
+    description: str = "UMAP"
 
     def __init__(self, parent: Processor) -> None:
         try:
@@ -21,8 +23,6 @@ class UMAP(ProcessorStepBase):
 
         super().__init__(
             parent=parent,
-            name="umap",
-            description="UMAP",
             fixed_params={},
             variable_controls=variable_controls,
         )

sclab/gui/components/__init__.py

@@ -0,0 +1,7 @@
+from ._guided_pseudotime import GuidedPseudotime
+from ._transfer_metadata import TransferMetadata
+
+__all__ = [
+    "GuidedPseudotime",
+    "TransferMetadata",
+]