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

sclab/dataset/processor/_results_panel.py

@@ -0,0 +1,94 @@
+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(VBox, EventClient):
+    available_results: Dropdown
+    results_stack: Stack
+
+    events: list[str] = [
+        # "rslt_add_result",
+        # "rslt_remove_result",
+    ]
+
+    def __init__(
+        self,
+        broker: EventBroker,
+    ):
+        EventClient.__init__(self, broker)
+
+        self.available_results = Dropdown(options={}, description="Category")
+        self.results_stack = Stack([])
+
+        link(
+            (self.available_results, "value"),
+            (self.results_stack, "selected_index"),
+        )
+
+        VBox.__init__(
+            self,
+            [
+                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):
+        current_stack = list(self.results_stack.children)
+        namespace = results.namespace
+
+        options: dict[str, int] = self.available_results.options
+        options = options.copy()
+        idx = options.get(namespace, len(options))
+        options[namespace] = idx
+
+        if len(current_stack) < idx + 1:
+            current_stack.append(results)
+        else:
+            current_stack[idx] = results
+
+        self.results_stack.children = tuple(current_stack)
+        self.available_results.options = options
+
+    def remove_result(self, name: str):
+        options: dict[str, int] = self.available_results.options
+        options = options.copy()
+        idx = options.pop(name)
+
+        current_stack = list(self.results_stack.children)
+        current_stack.pop(idx)
+
+        current_selection = self.results_stack.selected_index
+        if (
+            current_selection is not None
+            and current_selection > 0
+            and current_selection == idx
+        ):
+            idx = current_selection - 1
+            self.results_stack.selected_index = idx
+
+        self.results_stack.children = tuple(current_stack)
+        self.available_results.options = options
+        self.available_results.value = idx

sclab/dataset/processor/step/_processor_step_base.py

@@ -8,33 +8,36 @@ from ipywidgets.widgets.widget_description import DescriptionWidget
 
 from ....event import EventClient
 from .._processor import Processor
+from .._results_panel import _Results
 
 
 class ProcessorStepBase(EventClient):
     events: list[str] = None
     parent: Processor
-    name: str
-    description: str
+    name: str = None
+    description: str = None
     fixed_params: dict[str, Any]
     variable_controls: dict[str, DescriptionWidget | ValueWidget]
     output: Output
     run_button: Button
     controls_list: list[DescriptionWidget | ValueWidget | Button]
     controls: VBox
+    results: _Results | None
+    order: int = 1000
 
     run_button_description = "Run"
 
     def __init__(
         self,
         parent: Processor,
-        name: str,
-        description: str,
         fixed_params: dict[str, Any],
         variable_controls: dict[str, DescriptionWidget | ValueWidget],
+        results: _Results | None = None,
     ):
+        assert self.name
+        assert self.description
+
         self.parent = parent
-        self.name = name
-        self.description = description
         self.fixed_params = fixed_params
         self.variable_controls = variable_controls
 
@@ -56,6 +59,9 @@ class ProcessorStepBase(EventClient):
         ]
         self.make_controls()
 
+        if results is not None:
+            self.results = results
+            parent.results_panel.add_result(self.results)
         super().__init__(parent.broker)
 
     def make_controls(self):

sclab/examples/processor_steps/__init__.py

@@ -1,4 +1,8 @@
 from ._cluster import Cluster
+from ._differential_expression import DifferentialExpression
+from ._doublet_detection import DoubletDetection
+from ._gene_expression import GeneExpression
+from ._integration import Integration
 from ._neighbors import Neighbors
 from ._pca import PCA
 from ._preprocess import Preprocess
@@ -9,7 +13,11 @@ __all__ = [
     "QC",
     "Preprocess",
     "PCA",
+    "Integration",
     "Neighbors",
     "UMAP",
     "Cluster",
+    "DoubletDetection",
+    "GeneExpression",
+    "DifferentialExpression",
 ]

sclab/examples/processor_steps/_cluster.py

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

sclab/examples/processor_steps/_differential_expression.py

@@ -0,0 +1,329 @@
+from typing import Any, Iterable, Literal
+
+import itables
+import numpy as np
+import pandas as pd
+from anndata import AnnData
+from IPython.display import Markdown, display
+from ipywidgets import Dropdown, Output, SelectMultiple, Text, ToggleButtons
+from ipywidgets.widgets.valuewidget import ValueWidget
+from ipywidgets.widgets.widget_box import VBox
+from ipywidgets.widgets.widget_description import DescriptionWidget
+from packaging.version import Version
+
+from sclab.dataset import SCLabDataset
+from sclab.dataset.processor import Processor
+from sclab.dataset.processor.step import ProcessorStepBase
+
+
+class DifferentialExpressionResults(VBox):
+    dataset: SCLabDataset
+    result_selector: Dropdown
+    group_selector: ToggleButtons
+    table_output: Output
+    namespace: str = "differential_expression"
+
+    def __init__(self, dataset: SCLabDataset):
+        self.dataset = dataset
+        self.result_selector = Dropdown(description="Analysis Name")
+        self.group_selector = ToggleButtons()
+        self.table_output = Output()
+
+        self.result_selector.observe(self._update_group_selector, "value")
+        self.result_selector.observe(self._update_table, "value")
+        self.group_selector.observe(self._update_table, "value")
+
+        super().__init__(
+            [
+                self.result_selector,
+                self.group_selector,
+                self.table_output,
+            ]
+        )
+
+        self.sync_results_list()
+
+    def sync_results_list(self, focus_result: str | None = None):
+        adata = self.dataset.adata
+        uns: dict[str, Any] = adata.uns
+        current_selection = self.result_selector.value
+        new_options = tuple(filter(lambda x: x.startswith(self.namespace), uns.keys()))
+
+        if focus_result is not None and focus_result in new_options:
+            current_selection = focus_result
+        elif current_selection not in new_options:
+            current_selection = None
+
+        self.result_selector.options = new_options
+        self.result_selector.value = current_selection
+
+    def _update_group_selector(self, *args, **kwargs):
+        selected_result = self.result_selector.value
+        uns: dict[str, Any] = self.dataset.adata.uns
+        gene_names: np.rec.recarray = uns[selected_result]["names"]
+        self.group_selector.options = ("all",) + gene_names.dtype.names
+        self.group_selector.value = "all"
+
+    def _update_table(self, *args, **kwargs):
+        selected_result = self.result_selector.value
+        selected_group = self.group_selector.value
+
+        adata = self.dataset.adata
+        params = adata.uns[selected_result]["params"]
+
+        groupby = params["groupby"]
+        reference = params["reference"]
+        table_name = f"{selected_result}_by_{groupby}_{selected_group}_vs_{reference}"
+
+        params_text = "Parameters:\n    "
+        params_text += "\n    ".join(f"{k}: {v}" for k, v in params.items())
+        params_text = f"```\n{params_text}\n```"
+
+        if "gene_name" in adata.var:
+            gene_symbols = "gene_name"
+        elif "name" in adata.var:
+            gene_symbols = "name"
+        elif "gene_symbol" in adata.var:
+            gene_symbols = "gene_symbol"
+        elif "symbol" in adata.var:
+            gene_symbols = "symbol"
+        else:
+            gene_symbols = None
+
+        group = selected_group if selected_group != "all" else None
+        df = _rank_genes_groups_df(
+            adata, group=group, key=selected_result, gene_symbols=gene_symbols
+        )
+
+        self.table_output.clear_output()
+        with self.table_output:
+            display(Markdown(f"## {table_name}"))
+            itables.show(
+                df,
+                buttons=[
+                    "pageLength",
+                    {
+                        "extend": "colvis",
+                        "collectionLayout": "fixed columns",
+                        "popoverTitle": "Column visibility control",
+                    },
+                    "copyHtml5",
+                    {"extend": "csvHtml5", "title": table_name},
+                ],
+                columnDefs=[
+                    {"visible": True, "targets": [0]},
+                    {"visible": True, "targets": "_all"},
+                ],
+                style="width:100%",
+                classes="display cell-border",
+                stateSave=False,
+            )
+            display(Markdown(params_text))
+
+
+class DifferentialExpression(ProcessorStepBase):
+    parent: Processor
+    results: DifferentialExpressionResults
+    name: str = "differential_expression"
+    description: str = "Differential Expression"
+
+    def __init__(self, parent: Processor) -> None:
+        try:
+            import scanpy as sc  # noqa: F401
+        except ImportError:
+            raise ImportError("Please install scanpy: `pip install scanpy`")
+
+        metadata = parent.dataset._metadata.select_dtypes(
+            include=["object", "category"]
+        )
+        groupby_options = (None,) + tuple(metadata.columns)
+
+        variable_controls: dict[str, DescriptionWidget | ValueWidget]
+        variable_controls = dict(
+            groupby=Dropdown(options=groupby_options, description="Group by"),
+            groups=SelectMultiple(description="Groups"),
+            reference=Dropdown(description="Reference"),
+            layer=Dropdown(
+                options=(None,) + tuple(parent.dataset.adata.layers.keys()),
+                value=None,
+                description="Layer",
+            ),
+            name=Text(description="Name", value="", continuous_update=False),
+        )
+
+        variable_controls["groupby"].observe(
+            self._update_groups_options, "value", "change"
+        )
+        variable_controls["groupby"].observe(
+            self._update_reference_options, "value", "change"
+        )
+
+        results = DifferentialExpressionResults(parent.dataset)
+        super().__init__(
+            parent=parent,
+            fixed_params={},
+            variable_controls=variable_controls,
+            results=results,
+        )
+
+    def function(
+        self,
+        groupby: str,
+        groups: Iterable[str] | Literal["all"],
+        reference: str,
+        layer: str | None,
+        name: str | None,
+    ):
+        import scanpy as sc
+
+        assert groupby
+
+        if not groups:
+            groups = "all"
+
+        key_added = "differential_expression"
+        if name:
+            key_added = f"{key_added}_{name}"
+
+        adata = self.parent.dataset.adata
+        uns: dict[str, Any] = adata.uns
+        if key_added in adata.uns:
+            related_names = list(filter(lambda x: x.startswith(key_added), uns.keys()))
+            key_added = f"{key_added}_{len(related_names) + 1}"
+
+        sc.tl.rank_genes_groups(
+            adata,
+            groupby,
+            groups=groups,
+            reference=reference,
+            layer=layer,
+            key_added=key_added,
+            pts=True,
+        )
+
+        self.results.sync_results_list(focus_result=key_added)
+
+    def _update_groups_options(self, *args, **kwargs):
+        groupby = self.variable_controls["groupby"].value
+        metadata = self.parent.dataset._metadata
+        control: Dropdown = self.variable_controls["groups"]
+
+        if groupby is None:
+            control.options = ("",)
+            return
+
+        options = tuple(metadata[groupby].sort_values().unique())
+        control.options = options
+
+    def _update_reference_options(self, *args, **kwargs):
+        groupby = self.variable_controls["groupby"].value
+        metadata = self.parent.dataset._metadata
+        control: Dropdown = self.variable_controls["reference"]
+
+        if groupby is None:
+            control.options = ("",)
+            control.value = ""
+            return
+
+        options = ("rest",)
+        options += tuple(metadata[groupby].sort_values().unique())
+
+        current_value = control.value
+        control.options = options
+        if current_value not in control.options:
+            control.value = "rest"
+        else:
+            control.value = current_value
+
+    def dset_var_dataframe_change_callback(self, *args, **kwargs):
+        var_df = self.parent.dataset.adata.var
+        df = var_df.select_dtypes(include=["bool"])
+        options = {"": None, **{c: c for c in df.columns}}
+
+        control: Dropdown = self.variable_controls["mask_var"]
+        current_value = control.value
+        control.options = options
+        if current_value not in control.options:
+            control.value = None
+        else:
+            control.value = current_value
+
+
+# from scanpy 1.10.4
+# scanpy/src/scanpy/get/get.py
+def _rank_genes_groups_df(
+    adata: AnnData,
+    group: str | Iterable[str] | None,
+    *,
+    key: str = "rank_genes_groups",
+    pval_cutoff: float | None = None,
+    log2fc_min: float | None = None,
+    log2fc_max: float | None = None,
+    gene_symbols: str | None = None,
+) -> pd.DataFrame:
+    """\
+    Params
+    ------
+    adata
+        Object to get results from.
+    group
+        Which group (as in :func:`scanpy.tl.rank_genes_groups`'s `groupby`
+        argument) to return results from. Can be a list. All groups are
+        returned if groups is `None`.
+    key
+        Key differential expression groups were stored under.
+    pval_cutoff
+        Return only adjusted p-values below the  cutoff.
+    log2fc_min
+        Minimum logfc to return.
+    log2fc_max
+        Maximum logfc to return.
+    gene_symbols
+        Column name in `.var` DataFrame that stores gene symbols. Specifying
+        this will add that column to the returned dataframe.
+
+    """
+    if isinstance(group, str):
+        group = [group]
+    if group is None:
+        group = list(adata.uns[key]["names"].dtype.names)
+    method = adata.uns[key]["params"]["method"]
+    if method == "logreg":
+        colnames = ["names", "scores"]
+    else:
+        colnames = ["names", "scores", "logfoldchanges", "pvals", "pvals_adj"]
+
+    d = [pd.DataFrame(adata.uns[key][c])[group] for c in colnames]
+    d = pd.concat(d, axis=1, names=[None, "group"], keys=colnames)
+    if Version(pd.__version__) >= Version("2.1"):
+        d = d.stack(level=1, future_stack=True).reset_index()
+    else:
+        d = d.stack(level=1).reset_index()
+    d["group"] = pd.Categorical(d["group"], categories=group)
+    d = d.sort_values(["group", "level_0"]).drop(columns="level_0")
+
+    if method != "logreg":
+        if pval_cutoff is not None:
+            d = d[d["pvals_adj"] < pval_cutoff]
+        if log2fc_min is not None:
+            d = d[d["logfoldchanges"] > log2fc_min]
+        if log2fc_max is not None:
+            d = d[d["logfoldchanges"] < log2fc_max]
+    if gene_symbols is not None:
+        d = d.join(adata.var[gene_symbols], on="names")
+
+    for pts, name in {"pts": "pct_nz_group", "pts_rest": "pct_nz_reference"}.items():
+        if pts in adata.uns[key]:
+            pts_df = (
+                adata.uns[key][pts][group]
+                .rename_axis(index="names")
+                .reset_index()
+                .melt(id_vars="names", var_name="group", value_name=name)
+            )
+            d = d.merge(pts_df)
+
+    # remove group column for backward compat if len(group) == 1
+    if len(group) == 1:
+        d.drop(columns="group", inplace=True)
+
+    return d.reset_index(drop=True)

sclab/examples/processor_steps/_doublet_detection.py

@@ -0,0 +1,68 @@
+from ipywidgets import Dropdown
+
+from sclab.dataset.processor import Processor
+from sclab.dataset.processor.step import ProcessorStepBase
+from sclab.tools.doublet_detection import scrublet
+
+# from sclab.tools.doublet_detection import doubletdetection
+# from sclab.tools.doublet_detection import scdblfinder
+
+
+class DoubletDetection(ProcessorStepBase):
+    parent: Processor
+    name: str = "doublet_detection"
+    description: str = "Doublet Detection"
+
+    def __init__(self, parent: Processor) -> None:
+        variable_controls = dict(
+            layer=Dropdown(
+                options=tuple(parent.dataset.adata.layers.keys()),
+                value=None,
+                description="Layer",
+            ),
+            flavor=Dropdown(
+                options=[
+                    "scrublet",
+                    # "doubletdetection",
+                    # "scDblFinder",
+                ],
+                description="Flavor",
+            ),
+        )
+
+        super().__init__(
+            parent=parent,
+            fixed_params={},
+            variable_controls=variable_controls,
+        )
+
+    def function(self, layer: str, flavor: str):
+        adata = self.parent.dataset.adata
+
+        kvargs = {"adata": adata, "layer": layer, "key_added": flavor}
+
+        self.broker.std_output.clear_output(wait=False)
+        with self.broker.std_output:
+            match flavor:
+                # case "scDblFinder":
+                #     scdblfinder(**kvargs, clusters_col="leiden")
+
+                # case "doubletdetection":
+                #     doubletdetection(
+                #         **kvargs,
+                #         pseudocount=1,
+                #         clustering_algorithm="leiden",
+                #         clustering_kwargs=dict(resolution=5.0),
+                #     )
+
+                case "scrublet":
+                    scrublet(**kvargs)
+
+                case _:
+                    raise ValueError(f"Unknown flavor: {flavor}")
+
+        self.broker.publish(
+            "dset_metadata_change",
+            self.parent.dataset.metadata,
+            f"{flavor}_label",
+        )