sclab 0.3.0__tar.gz → 0.3.2__tar.gz

{sclab-0.3.0 → sclab-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sclab
-Version: 0.3.0
+Version: 0.3.2
 Summary: sclab
 Author-email: Argenis Arriojas <ArriojasMaldonado001@umb.edu>
 Requires-Python: >=3.10,<3.13

{sclab-0.3.0 → sclab-0.3.2}/pyproject.toml

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

{sclab-0.3.0 → sclab-0.3.2}/src/sclab/__init__.py

@@ -6,4 +6,4 @@ __all__ = [
     "SCLabDashboard",
 ]
 
-__version__ = "0.3.0"
+__version__ = "0.3.2"

{sclab-0.3.0 → sclab-0.3.2}/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
@@ -171,7 +170,11 @@ class DataLoader(VBox):
         self.upload = FileUpload(layout=Layout(width="200px"))
         self.upload_info = Output(layout=Layout(width="95%"))
         self.upload_row = HBox(
-            [self.upload_row_label, self.upload, self.upload_info],
+            [
+                self.upload_row_label,
+                self.upload,
+                self.upload_info,
+            ],
             layout=Layout(width="100%"),
         )
         self.upload.observe(self.on_upload, "value")
@@ -214,8 +217,8 @@ class DataLoader(VBox):
         VBox.__init__(
             self,
             [
-                self.url_row,
-                self.upload_row,
+                # self.url_row,
+                # self.upload_row,
                 self.defined_adatas_row,
                 self.progress_output,
             ],
@@ -234,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.0 → sclab-0.3.2}/src/sclab/dataset/processor/_processor.py

@@ -1025,22 +1025,37 @@ class Processor(EventClient):
                 else:
                     control.value = current_value
 
-    def dset_anndata_layers_change_callback(self, layers):
-        options = {layer: layer for layer in layers}
+    def dset_anndata_layers_change_callback(self, *args, **kwargs):
+        layer_options = {key: key for key in self.dataset.adata.layers.keys()}
+        obsm_options = {key: key for key in self.dataset.adata.obsm.keys()}
+
         for control in self.all_controls_list:
             if not isinstance(control, Dropdown):
                 continue
             description: str = control.description
+
             if description.lower().strip(" :.") == "layer":
                 current_value = control.value
-                control.options = options
+                control.options = layer_options
+                if current_value not in control.options:
+                    control.value = None
+                else:
+                    control.value = current_value
+
+            if description.lower().strip(" :.") == "use rep":
+                current_value = control.value
+                control.options = {**layer_options, **obsm_options}
                 if current_value not in control.options:
                     control.value = None
                 else:
                     control.value = current_value
 
     def dset_data_dict_change_callback(self, *args, **kwargs):
-        options = {v: v for v in self.dataset.adata.obsm.keys()}
+        options = [
+            *self.dataset.adata.layers.keys(),
+            *self.dataset.adata.obsm.keys(),
+        ]
+        options = {v: v for v in options}
         for control in self.all_controls_list:
             if not isinstance(control, Dropdown):
                 continue

{sclab-0.3.0 → sclab-0.3.2}/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.0 → sclab-0.3.2}/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.0 → sclab-0.3.2}/src/sclab/examples/processor_steps/_integration.py

@@ -10,20 +10,6 @@ class Integration(ProcessorStepBase):
     description: str = "Integration"
 
     def __init__(self, parent: Processor) -> None:
-        try:
-            from scanpy.external.pp import harmony_integrate  # noqa
-        except ImportError:
-            try:
-                from scanpy.external.pp import scanorama_integrate  # noqa
-            except ImportError:
-                raise ImportError(
-                    "Integration requires scanorama or harmony to be installed.\n"
-                    "\nInstall with one of:\n"
-                    "\npip install harmony"
-                    "\npip install scanorama"
-                    "\n"
-                )
-
         cat_metadata = parent.dataset._metadata.select_dtypes(
             include=["object", "category"]
         )
@@ -44,8 +30,8 @@ class Integration(ProcessorStepBase):
                 description="Reference Batch",
             ),
             flavor=Dropdown(
-                options=["harmony", "scanorama"],
-                value="harmony",
+                options=["cca", "harmony", "scanorama"],
+                value="cca",
                 description="Flavor",
             ),
             max_iters=IntText(
@@ -96,6 +82,14 @@ class Integration(ProcessorStepBase):
         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
 

{sclab-0.3.0 → sclab-0.3.2}/src/sclab/examples/processor_steps/_pca.py

@@ -1,6 +1,6 @@
 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
@@ -26,6 +26,7 @@ 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__(
@@ -56,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
 
@@ -93,6 +95,9 @@ class PCA(ProcessorStepBase):
             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(
             "dset_data_dict_change", self.parent.dataset.data_dict, "X_pca"

{sclab-0.3.0 → sclab-0.3.2}/src/sclab/gui/components/__init__.py

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

sclab-0.3.2/src/sclab/gui/components/_transfer_metadata.py

@@ -0,0 +1,186 @@
+from typing import Literal
+
+import numpy as np
+from ipywidgets import (
+    Checkbox,
+    Dropdown,
+    FloatText,
+    IntText,
+)
+from pandas.api.types import is_numeric_dtype
+
+from sclab.dataset.processor import Processor
+from sclab.dataset.processor.step import ProcessorStepBase
+
+_2PI = 2 * np.pi
+
+
+class TransferMetadata(ProcessorStepBase):
+    parent: Processor
+    name: str = "transfer_metadata"
+    description: str = "Transfer Metadata"
+
+    run_button_description = "Transfer Metadata"
+
+    def __init__(self, parent: Processor) -> None:
+        variable_controls = dict(
+            group_key=Dropdown(
+                options=[],
+                value=None,
+                description="Group Key",
+            ),
+            source_group=Dropdown(
+                options=[],
+                value=None,
+                description="Source Group",
+            ),
+            column=Dropdown(
+                options=[],
+                value=None,
+                description="Column",
+            ),
+            periodic=Checkbox(
+                value=False,
+                description="Periodic",
+            ),
+            vmin=FloatText(
+                value=0,
+                description="Vmin",
+                continuous_update=False,
+            ),
+            vmax=FloatText(
+                value=1,
+                description="Vmax",
+                continuous_update=False,
+            ),
+            min_neighs=IntText(
+                value=5,
+                min=3,
+                description="Min Neighs",
+                continuous_update=False,
+            ),
+            weight_by=Dropdown(
+                options=["connectivity", "distance", "constant"],
+                value="connectivity",
+                description="Weight By",
+            ),
+        )
+
+        super().__init__(
+            parent=parent,
+            fixed_params={},
+            variable_controls=variable_controls,
+        )
+
+        self._update_groupby_options()
+        self._update_column_options()
+        self._update_numeric_column_controls()
+
+        self.variable_controls["group_key"].observe(
+            self._update_source_group_options, "value", "change"
+        )
+        self.variable_controls["column"].observe(
+            self._update_numeric_column_controls, "value", "change"
+        )
+        self.variable_controls["periodic"].observe(
+            self._update_vmin_vmax_visibility, "value", "change"
+        )
+
+    def _update_groupby_options(self, *args, **kwargs):
+        metadata = self.parent.dataset._metadata.select_dtypes(include=["category"])
+        options = {"": None, **{c: c for c in metadata.columns}}
+        self.variable_controls["group_key"].options = options
+
+    def _update_source_group_options(self, *args, **kwargs):
+        group_key = self.variable_controls["group_key"].value
+        if group_key is None:
+            self.variable_controls["source_group"].options = ("",)
+            return
+
+        options = self.parent.dataset._metadata[group_key].sort_values().unique()
+        options = {"": None, **{c: c for c in options}}
+        self.variable_controls["source_group"].options = options
+
+    def _update_column_options(self, *args, **kwargs):
+        metadata = self.parent.dataset._metadata.select_dtypes(
+            include=["category", "bool", "number"]
+        )
+        options = {"": None, **{c: c for c in metadata.columns}}
+        self.variable_controls["column"].options = options
+
+    def _update_numeric_column_controls(self, *args, **kwargs):
+        column = self.variable_controls["column"].value
+        if column is None:
+            self._hide_control(self.variable_controls["periodic"])
+            self._hide_control(self.variable_controls["vmin"])
+            self._hide_control(self.variable_controls["vmax"])
+            return
+
+        series = self.parent.dataset._metadata[column]
+        periodic = self.variable_controls["periodic"].value
+
+        if is_numeric_dtype(series):
+            self._show_control(self.variable_controls["periodic"])
+            if periodic:
+                self._show_control(self.variable_controls["vmin"])
+                self._show_control(self.variable_controls["vmax"])
+        else:
+            self._hide_control(self.variable_controls["periodic"])
+            self._hide_control(self.variable_controls["vmin"])
+            self._hide_control(self.variable_controls["vmax"])
+
+    def _update_vmin_vmax_visibility(self, *args, **kwargs):
+        periodic = self.variable_controls["periodic"].value
+
+        if periodic:
+            self._show_control(self.variable_controls["vmin"])
+            self._show_control(self.variable_controls["vmax"])
+        else:
+            self._hide_control(self.variable_controls["vmin"])
+            self._hide_control(self.variable_controls["vmax"])
+
+    def _hide_control(self, control):
+        control.layout.visibility = "hidden"
+        control.layout.height = "0px"
+
+    def _show_control(self, control):
+        control.layout.visibility = "visible"
+        control.layout.height = "28px"
+
+    def function(
+        self,
+        group_key: str,
+        source_group: str,
+        column: str,
+        periodic: bool = False,
+        vmin: float = 0,
+        vmax: float = 1,
+        min_neighs: int = 5,
+        weight_by: Literal["connectivity", "distance", "constant"] = "connectivity",
+        **kwargs,
+    ):
+        from ...preprocess._transfer_metadata import transfer_metadata
+
+        self.output.clear_output(wait=True)
+        with self.output:
+            transfer_metadata(
+                self.parent.dataset.adata,
+                group_key=group_key,
+                source_group=source_group,
+                column=column,
+                periodic=periodic,
+                vmin=vmin,
+                vmax=vmax,
+                min_neighs=min_neighs,
+                weight_by=weight_by,
+            )
+
+        new_column = f"transferred_{column}"
+
+        self.broker.publish(
+            "dset_metadata_change", self.parent.dataset.metadata, new_column
+        )
+
+    def dset_metadata_change_callback(self, *args, **kwargs):
+        self._update_groupby_options(*args, **kwargs)
+        self._update_column_options(*args, **kwargs)

{sclab-0.3.0 → sclab-0.3.2}/src/sclab/methods/__init__.py

@@ -13,7 +13,7 @@ from ..examples.processor_steps import (
     Neighbors,
     Preprocess,
 )
-from ..gui.components import GuidedPseudotime
+from ..gui.components import GuidedPseudotime, TransferMetadata
 
 __all__ = [
     "QC",
@@ -32,17 +32,9 @@ __all__ = [
 register_sclab_method("Processing")(QC)
 register_sclab_method("Processing")(Preprocess)
 register_sclab_method("Processing")(PCA)
-
-if any(
-    [
-        find_spec("harmonypy"),
-        find_spec("scanorama"),
-    ]
-):
-    register_sclab_method("Processing")(Integration)
-
-
+register_sclab_method("Processing")(Integration)
 register_sclab_method("Processing")(Neighbors)
+register_sclab_method("Processing")(TransferMetadata)
 register_sclab_method("Processing")(UMAP)
 register_sclab_method("Processing")(Cluster)
 

{sclab-0.3.0 → sclab-0.3.2}/src/sclab/preprocess/__init__.py

@@ -1,4 +1,4 @@
-from ._cca_integrate import cca_integrate_pair
+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
@@ -7,6 +7,7 @@ from ._transfer_metadata import transfer_metadata
 from ._transform import pool_neighbors
 
 __all__ = [
+    "cca_integrate",
     "cca_integrate_pair",
     "filter_obs",
     "harmony_integrate",

{sclab-0.3.0 → sclab-0.3.2}/src/sclab/preprocess/_cca.py

@@ -19,7 +19,7 @@ def cca(
     svd_solver: Literal["full", "partial", "randomized"] = "partial",
     normalize: bool = False,
     random_state=42,
-):
+) -> tuple[NDArray, NDArray, NDArray]:
     """
     CCA-style integration for two single-cell matrices with unequal numbers of cells.
 

{sclab-0.3.0 → sclab-0.3.2}/src/sclab/preprocess/_cca_integrate.py

@@ -4,6 +4,38 @@ from anndata import AnnData
 from ._cca import cca
 
 
+def cca_integrate(
+    adata: AnnData,
+    key: str,
+    *,
+    basis: str = "X",
+    adjusted_basis: str | None = None,
+    reference_batch: str | list[str] | None = None,
+    mask_var: str | None = None,
+    n_components: int = 30,
+    svd_solver: str = "partial",
+    normalize: bool = False,
+    random_state: int | None = None,
+):
+    n_groups = adata.obs[key].nunique()
+    if n_groups == 2:
+        cca_integrate_pair(
+            adata,
+            key,
+            adata.obs[key].unique()[0],
+            adata.obs[key].unique()[1],
+            basis=basis,
+            adjusted_basis=adjusted_basis,
+            mask_var=mask_var,
+            n_components=n_components,
+            svd_solver=svd_solver,
+            normalize=normalize,
+            random_state=random_state,
+        )
+    else:
+        raise NotImplementedError
+
+
 def cca_integrate_pair(
     adata: AnnData,
     key: str,
@@ -13,7 +45,7 @@ def cca_integrate_pair(
     basis: str | None = None,
     adjusted_basis: str | None = None,
     mask_var: str | None = None,
-    n_components: int = 50,
+    n_components: int = 30,
     svd_solver: str = "partial",
     normalize: bool = False,
     random_state: int | None = None,

{sclab-0.3.0 → sclab-0.3.2}/src/sclab/preprocess/_harmony_integrate.py

@@ -17,8 +17,8 @@ Nat Biotechnol 41, 604-606 (2023). https://doi.org/10.1038/s41587-023-01733-8
 
 from collections.abc import Sequence
 
-from anndata import AnnData
 import numpy as np
+from anndata import AnnData
 
 from ._harmony import run_harmony
 
@@ -28,12 +28,15 @@ def harmony_integrate(
     key: str | Sequence[str],
     *,
     basis: str = "X_pca",
-    adjusted_basis: str = "X_pca_harmony",
+    adjusted_basis: str | None = None,
     reference_batch: str | list[str] | None = None,
     **kwargs,
 ):
     """Use harmonypy :cite:p:`Korsunsky2019` to integrate different experiments."""
 
+    if adjusted_basis is None:
+        adjusted_basis = f"{basis}_harmony"
+
     if isinstance(reference_batch, str):
         reference_batch = [reference_batch]
 

{sclab-0.3.0 → sclab-0.3.2}/src/sclab/tools/cellflow/density_dynamics/_density_dynamics.py

@@ -89,9 +89,9 @@ def density(
     )
 
     if plot_density | plot_density_fit | plot_density_fit_derivative | plot_histogram:
-        from ..utils import plot
+        from ..utils.density_nd import density_result_1d
 
-        plot.density_result_1d(
+        density_result_1d(
             rslt,
             data=times[~np.isnan(times)],
             density_fit_lam=lam,
@@ -207,9 +207,9 @@ def density_dynamics(
     )
 
     if plot_density | plot_density_fit | plot_density_fit_derivative | plot_histogram:
-        from ..utils import plot
+        from ..utils.density_nd import density_result_1d
 
-        ax = plot.density_result_1d(
+        ax = density_result_1d(
             rslt,
             data=times[~np.isnan(times)],
             density_fit_lam=lam,

{sclab-0.3.0 → sclab-0.3.2}/src/sclab/tools/cellflow/utils/density_nd.py

@@ -1,6 +1,7 @@
 from itertools import product
 from typing import Literal, NamedTuple
 
+import matplotlib.pyplot as plt
 import numpy as np
 from numpy.typing import NDArray
 from scipy.integrate import trapezoid
@@ -134,3 +135,81 @@ def fit_density_1d(
     )
 
     return rslt, bspl
+
+
+def density_result_1d(
+    rslt: DensityResult,
+    data: NDArray | None = None,
+    density_fit_lam: float = 1e-6,
+    plot_density: bool = False,
+    plot_density_fit: bool = True,
+    plot_density_fit_derivative: bool = False,
+    plot_histogram: bool = False,
+    histogram_nbins: int = 50,
+    ax: plt.Axes | None = None,
+    show: bool = True,
+):
+    if plot_density | plot_density_fit | plot_density_fit_derivative | plot_histogram:
+        pass
+    else:
+        raise ValueError("At least one of the plotting options must be True")
+
+    tmin, tmax = rslt.grid.min(), rslt.grid.max()
+    bspl = fit_smoothing_spline(
+        rslt.grid[:, 0],
+        rslt.density,
+        t_range=(tmin, tmax),
+        lam=density_fit_lam,
+        periodic=rslt.periodic,
+    )
+    if ax is None:
+        plt.figure(figsize=(10, 3))
+    else:
+        plt.sca(ax)
+
+    ax = plt.gca()
+    if plot_density:
+        ax.plot(rslt.grid.flatten(), rslt.density, color="black", linewidth=0.5)
+
+    if plot_histogram:
+        assert data is not None, "data must be provided if plot_histogram=True"
+        # we expand the time vector to make sure that the first and last point
+        # are not cut by the boundary. This also helps to avoid the problem of
+        # the first and last point having different values (should be periodic).
+        tt = np.concatenate([data - tmax, data, data + tmax])
+        bins = np.linspace(-tmax, 2 * tmax, histogram_nbins * 3 + 1)
+        dd = np.histogram(tt, bins=bins, density=True)[0]
+        # we take the middle points of the bins
+        xx = bins[:-1] + np.diff(bins) / 2
+        # we recover the original time vector and corresponding density
+        x = xx[histogram_nbins : 2 * histogram_nbins]
+        d = dd[histogram_nbins : 2 * histogram_nbins] * 3  # correct the density
+        ax.bar(x, d, width=1 / histogram_nbins, fill=False, linewidth=0.5)
+
+    x = np.linspace(tmin, tmax, 2**10 + 1)
+    if plot_density_fit:
+        plt.plot(x, bspl(x), color="blue")
+
+    ax.set_ylabel("Density", color="blue")
+    ax.set_yticks([])
+
+    ymin, ymax = plt.ylim()
+    # add a bit of padding in the y axis (about 10% of current range)
+    plt.ylim(ymin, ymax + 0.10 * (ymax - ymin))
+
+    if plot_density_fit_derivative:
+        if plot_density or histogram_nbins or plot_density_fit:
+            plt.twinx()
+        plt.plot(x, bspl.derivative()(x), color="red")
+        plt.hlines(0, tmin, tmax, linestyles="dashed", linewidth=0.5, color="black")
+        plt.ylabel("Derivative", color="red")
+        plt.gca().set_yticks([])
+
+        # add padding in the y axis to make zero be in the middle
+        ymax = np.abs(plt.ylim()).max() * 1.05
+        plt.ylim(-ymax, ymax)
+
+    if show:
+        plt.show()
+    else:
+        return plt.gca()