sclab 0.2.3__tar.gz → 0.2.4__tar.gz

{sclab-0.2.3 → sclab-0.2.4}/PKG-INFO

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

{sclab-0.2.3 → sclab-0.2.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sclab"
-version = "0.2.3"
+version = "0.2.4"
 description = "sclab"
 readme = "README.md"
 authors = [
@@ -48,6 +48,9 @@ build-backend = "flit_core.buildapi"
 name = "sclab"
 source = "src/sclab"
 
+[tool.uv.sources]
+sclab-tools = { path = "../sclab-tools" }
+
 [dependency-groups]
 dev = [
     "bump-my-version>=0.31.1",
@@ -60,4 +63,5 @@ dev = [
     "mkdocs-jupyter>=0.25.1",
     "scanpy[leiden]>=1.10.4",
     "jupyterlab>=4.3.6",
+    "sclab-tools",
 ]

{sclab-0.2.3 → sclab-0.2.4}/src/sclab/__init__.py

@@ -6,4 +6,4 @@ __all__ = [
     "SCLabDashboard",
 ]
 
-__version__ = "0.2.3"
+__version__ = "0.2.4"

{sclab-0.2.3 → sclab-0.2.4}/src/sclab/_io.py

@@ -58,12 +58,6 @@ def load_adata_from_url(
     assert is_valid_url(url), "URL is not valid"
     url_path = Path(urlparse(url).path)
 
-    if url_path.suffix == ".h5":
-        try:
-            import scanpy as sc
-        except ImportError:
-            raise ImportError("Please install scanpy: `pip install scanpy`")
-
     file_content = fetch_file(url, progress=progress)
     match url_path.suffix:
         case ".h5":

{sclab-0.2.3 → sclab-0.2.4}/src/sclab/_sclab.py

@@ -187,7 +187,7 @@ class DataLoader(VBox):
         user_f_locals = inspect.stack()[2].frame.f_locals
         self.defined_adatas_dict = {}
         for name, variable_type in [(k, type(v)) for k, v in user_f_locals.items()]:
-            if variable_type is AnnData:
+            if variable_type is AnnData and not name.startswith("_"):
                 self.defined_adatas_dict[name] = user_f_locals[name]
 
         self.defined_adatas_label = Label(

{sclab-0.2.3 → sclab-0.2.4}/src/sclab/examples/processor_steps/__init__.py

@@ -1,5 +1,7 @@
 from ._cluster import Cluster
 from ._differential_expression import DifferentialExpression
+from ._gene_expression import GeneExpression
+from ._integration import Integration
 from ._neighbors import Neighbors
 from ._pca import PCA
 from ._preprocess import Preprocess
@@ -10,8 +12,10 @@ __all__ = [
     "QC",
     "Preprocess",
     "PCA",
+    "Integration",
     "Neighbors",
     "UMAP",
     "Cluster",
+    "GeneExpression",
     "DifferentialExpression",
 ]

sclab-0.2.4/src/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-0.2.4/src/sclab/examples/processor_steps/_integration.py

@@ -0,0 +1,86 @@
+from ipywidgets import Dropdown
+
+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:
+        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"]
+        )
+        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",
+            ),
+            flavor=Dropdown(
+                options=["harmony", "scanorama"],
+                value="harmony",
+                description="Flavor",
+            ),
+        )
+
+        super().__init__(
+            parent=parent,
+            fixed_params={},
+            variable_controls=variable_controls,
+        )
+
+    def function(self, use_rep: str, group_by: str, flavor: str):
+        adata = self.parent.dataset.adata
+
+        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 "harmony":
+                    from scanpy.external.pp import harmony_integrate
+
+                    harmony_integrate(**kvargs)
+
+                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-0.2.3 → sclab-0.2.4}/src/sclab/examples/processor_steps/_preprocess.py

@@ -129,7 +129,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 +137,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 +152,13 @@ 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()
+
+        adata.layers[new_layer] = adata.X.copy()
 
         pbar.update(10)
 

{sclab-0.2.3 → sclab-0.2.4}/src/sclab/methods/__init__.py

@@ -5,6 +5,8 @@ from ..examples.processor_steps import (
     UMAP,
     Cluster,
     DifferentialExpression,
+    GeneExpression,
+    Integration,
     Neighbors,
     Preprocess,
 )
@@ -13,16 +15,20 @@ __all__ = [
     "QC",
     "Preprocess",
     "PCA",
+    "Integration",
     "Neighbors",
     "UMAP",
     "Cluster",
+    "GeneExpression",
     "DifferentialExpression",
 ]
 
 register_sclab_method("Processing")(QC)
 register_sclab_method("Processing")(Preprocess)
 register_sclab_method("Processing")(PCA)
+register_sclab_method("Processing")(Integration)
 register_sclab_method("Processing")(Neighbors)
 register_sclab_method("Processing")(UMAP)
 register_sclab_method("Processing")(Cluster)
+register_sclab_method("Analysis")(GeneExpression)
 register_sclab_method("Analysis")(DifferentialExpression)