sclab 0.1.8__py3-none-any.whl → 0.2.2__py3-none-any.whl

sclab/__init__.py

@@ -1,7 +1,9 @@
+from . import methods
 from ._sclab import SCLabDashboard
 
 __all__ = [
+    "methods",
     "SCLabDashboard",
 ]
 
-__version__ = "0.1.8"
+__version__ = "0.2.2"

sclab/_io.py

@@ -1,26 +1,25 @@
+from io import BytesIO
 from pathlib import Path
+from urllib.parse import urlparse
 
-import anndata as ad
+import requests
+from anndata import AnnData, read_h5ad
+from tqdm.auto import tqdm
 
 
-def read_adata(path: str | Path, var_names: str = "gene_ids") -> ad.AnnData:
-    path = Path(path)
+def read_adata(path: str | Path, var_names: str = "gene_ids") -> AnnData:
+    from .scanpy.readwrite import read_10x_h5, read_10x_mtx
 
-    match path.suffix:
-        case ".h5" | "":
-            try:
-                import scanpy as sc
-            except ImportError:
-                raise ImportError("Please install scanpy: `pip install scanpy`")
+    path = Path(path)
 
     match path.suffix:
         case ".h5":
-            adata = sc.read_10x_h5(path)
+            adata = read_10x_h5(path)
         case ".h5ad":
-            adata = ad.read_h5ad(path)
+            adata = read_h5ad(path)
         case "":
             assert path.is_dir()
-            adata = sc.read_10x_mtx(path)
+            adata = read_10x_mtx(path)
         case _:
             raise ValueError(
                 "Input file must be a 10x h5, h5ad or a folder of 10x mtx files"
@@ -30,3 +29,81 @@ def read_adata(path: str | Path, var_names: str = "gene_ids") -> ad.AnnData:
         adata.var = adata.var.set_index(var_names)
 
     return adata
+
+
+def load_adata_from_url(
+    url: str,
+    var_names: str = "gene_ids",
+    progress: bool = True,
+) -> AnnData:
+    """
+    Load an AnnData object from a URL to an .h5ad file.
+
+    Parameters:
+    -----------
+    url : str
+        URL to the .h5ad file
+    var_names : str
+        Name of the variable column in the .h5ad file
+    progress : bool
+        Whether to show a progress bar
+
+    Returns:
+    --------
+    anndata.AnnData
+        Loaded AnnData object
+    """
+    from .scanpy.readwrite import read_10x_h5
+
+    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":
+            adata = read_10x_h5(file_content)
+        case ".h5ad":
+            adata = read_h5ad(file_content)
+        case _:
+            raise ValueError("Input file must be a 10x h5 or h5ad file")
+
+    if var_names in adata.var:
+        adata.var = adata.var.set_index(var_names)
+
+    return adata
+
+
+def fetch_file(url: str, progress: bool = True) -> BytesIO:
+    response = requests.get(url, stream=True)
+    response.raise_for_status()
+
+    total_size_in_bytes = int(response.headers.get("content-length", 0))
+    block_size = 1024  # 1 Kibibyte
+
+    if progress:
+        progress_bar = tqdm(total=total_size_in_bytes, unit="iB", unit_scale=True)
+
+    result = BytesIO()
+    for data in response.iter_content(block_size):
+        result.write(data)
+        if progress:
+            progress_bar.update(len(data))
+
+    if progress:
+        progress_bar.close()
+
+    return result
+
+
+def is_valid_url(url: str) -> bool:
+    if not isinstance(url, str):
+        return False
+
+    result = urlparse(url)
+    return all([result.scheme, result.netloc])

sclab/_methods_registry.py

@@ -0,0 +1,65 @@
+from typing import Callable, Type
+
+
+# full class definition is in .dataset/processor/step/_processor_step_base.py
+class ProcessorStepBase:
+    name: str
+    description: str
+
+
+methods_registry: dict[str, list[ProcessorStepBase]] = {}
+
+
+def register_sclab_method(
+    category: str,
+    name: str | None = None,
+    description: str | None = None,
+    order: int | None = None,
+) -> Callable:
+    """
+    Decorator to register a class as a sclab method.
+
+    Args:
+        category: The category to register the method under (e.g., "Processing")
+        name: Optional display name for the method. If None, uses the class name.
+        description: Optional description of the method.
+        order: Optional ordering within the category. Lower numbers appear first.
+
+    Returns:
+        Decorated class
+    """
+
+    def decorator(cls: Type[ProcessorStepBase]) -> Type[ProcessorStepBase]:
+        if name:
+            cls.name = name
+
+        if description:
+            cls.description = description
+
+        if order is not None:
+            cls.order = order
+
+        # Initialize the category in the registry if it doesn't exist
+        if category not in methods_registry:
+            methods_registry[category] = []
+
+        methods_list = methods_registry[category]
+
+        # Add the class to the registry
+        methods_list.append(cls)
+
+        # Sort the methods by order
+        methods_registry[category] = sorted(methods_list, key=lambda x: x.order)
+
+        return cls
+
+    return decorator
+
+
+def get_sclab_methods():
+    methods = {}
+
+    for category, methods_list in methods_registry.items():
+        methods[category] = sorted(methods_list, key=lambda x: x.order)
+
+    return methods

sclab/_sclab.py

@@ -1,9 +1,24 @@
+import inspect
+from io import BytesIO
 from pathlib import Path
 
 from anndata import AnnData
-from ipywidgets.widgets import GridBox, Layout, Tab
+from IPython.display import display
+from ipywidgets.widgets import (
+    Button,
+    FileUpload,
+    GridBox,
+    HBox,
+    Label,
+    Layout,
+    Output,
+    Tab,
+    Text,
+    ToggleButtons,
+    VBox,
+)
 
-from ._io import read_adata
+from ._io import is_valid_url, load_adata_from_url, read_adata
 from .dataset import SCLabDataset
 from .dataset.plotter import Plotter
 from .dataset.processor import Processor
@@ -12,60 +27,106 @@ from .event import EventBroker
 
 class SCLabDashboard(GridBox):
     broker: EventBroker
+    dataset: SCLabDataset
+    plotter: Plotter
+    processor: Processor
+    main_content: Tab
 
     def __init__(
         self,
-        adata: AnnData | None = None,
-        filepath: str | Path | None = None,
+        adata_or_filepath_or_url: AnnData | str | None = None,
         name: str = "SCLab Dashboard",
         counts_layer: str = "counts",
         batch_key: str | None = None,
-        copy: bool = True,
+        copy: bool = False,
     ):
-        if adata is None and filepath is None:
-            raise ValueError("Either adata or filepath must be provided")
+        if adata_or_filepath_or_url is None:
+            adata = None
 
-        if adata is None:
+        elif isinstance(adata_or_filepath_or_url, AnnData):
+            adata = adata_or_filepath_or_url
+
+        elif is_valid_url(adata_or_filepath_or_url):
+            url = adata_or_filepath_or_url
+            adata = load_adata_from_url(url)
+
+        elif isinstance(adata_or_filepath_or_url, str):
+            filepath = adata_or_filepath_or_url
             adata = read_adata(filepath)
 
+        self.name = name
+        self.counts_layer = counts_layer
+        self.batch_key = batch_key
+
         self.broker = EventBroker()
+
+        self.dataset = None
+        self.plotter = None
+        self.processor = None
+        self.main_content = None
+
+        self.data_loader_layout = Layout(
+            width="100%",
+            height="500px",
+            grid_template_columns="auto",
+            grid_template_areas=""" "data_loader" """,
+            border="0px solid black",
+        )
+
+        self.dashboard_layout = Layout(
+            width="100%",
+            height="100%",
+            grid_template_columns="350px auto",
+            grid_template_areas=""" "processor plotter" """,
+            border="0px solid black",
+        )
+
+        self.data_loader = DataLoader(self)
+
+        GridBox.__init__(self)
+        if adata is not None:
+            self._load(adata, copy=copy)
+        else:
+            self.children = (self.data_loader,)
+            self.layout = self.data_loader_layout
+
+    def _load(self, adata: AnnData, copy: bool = False):
         self.dataset = SCLabDataset(
-            adata, name=name, counts_layer=counts_layer, copy=copy, broker=self.broker
+            adata,
+            name=self.name,
+            counts_layer=self.counts_layer,
+            copy=copy,
+            broker=self.broker,
         )
         self.plotter = Plotter(self.dataset)
         self.processor = Processor(
             self.dataset,
             self.plotter,
-            batch_key=batch_key,
+            batch_key=self.batch_key,
         )
 
         self.main_content = Tab(
             children=[
                 self.plotter,
+                self.processor.results_panel,
                 self.dataset.obs_table,
                 self.dataset.var_table,
                 self.broker.logs_tab,
             ],
             titles=[
                 "Main graph",
+                "Results",
                 "Observations",
                 "Genes",
                 "Logs",
             ],
         )
 
-        super().__init__(
-            [
-                self.processor.main_accordion,
-                self.main_content,
-            ],
-            layout=Layout(
-                width="100%",
-                grid_template_columns="350px auto",
-                grid_template_areas=""" "processor plotter" """,
-                border="0px solid black",
-            ),
+        self.children = (
+            self.processor.main_accordion,
+            self.main_content,
         )
+        self.layout = self.dashboard_layout
 
     @property
     def ds(self):
@@ -78,3 +139,150 @@ class SCLabDashboard(GridBox):
     @property
     def pl(self):
         return self.plotter
+
+
+class DataLoader(VBox):
+    dashboard: SCLabDashboard
+    adata: AnnData
+
+    upload: FileUpload
+    upload_info: Output
+    upload_row: HBox
+    upload_row_label: Label
+
+    url: Text
+    load_button: Button
+    url_row: HBox
+    url_row_label: Label
+
+    defined_adatas_dict: dict[str, AnnData]
+    defined_adatas: ToggleButtons
+    defined_adatas_row: HBox
+    defined_adatas_label: Label
+
+    progress_output: Output
+    continue_button: Button
+
+    def __init__(self, dashboard: SCLabDashboard):
+        self.dashboard = dashboard
+
+        self.upload_row_label = Label("Load from file:", layout=Layout(width="120px"))
+        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],
+            layout=Layout(width="100%"),
+        )
+        self.upload.observe(self.on_upload, "value")
+
+        self.url_row_label = Label("Load from URL:", layout=Layout(width="120px"))
+        self.url = Text(placeholder="https://...", layout=Layout(width="100%"))
+        self.load_button = Button(description="Load", layout=Layout(width="200px"))
+        self.url_row = HBox(
+            [self.url_row_label, self.url, self.load_button],
+            layout=Layout(width="100%"),
+        )
+        self.load_button.on_click(self.on_load_url)
+
+        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:
+                self.defined_adatas_dict[name] = user_f_locals[name]
+
+        self.defined_adatas_label = Label(
+            "Defined datasets:", layout=Layout(width="120px")
+        )
+        self.defined_adatas = ToggleButtons(
+            options=list(self.defined_adatas_dict.keys()),
+            value=None,
+            layout=Layout(width="100%"),
+        )
+        self.defined_adatas_row = HBox(
+            [self.defined_adatas_label, self.defined_adatas],
+            layout=Layout(width="100%"),
+        )
+        self.defined_adatas.observe(self.on_defined_adatas_toggle, "value")
+
+        self.progress_output = Output(layout=Layout(width="95%"))
+        self.continue_button = Button(
+            description="Continue", layout=Layout(width="100%"), button_style="success"
+        )
+        self.continue_button.on_click(self.on_continue)
+
+        VBox.__init__(
+            self,
+            [
+                self.url_row,
+                self.upload_row,
+                self.defined_adatas_row,
+                self.progress_output,
+            ],
+            layout=Layout(width="100%"),
+        )
+
+    def on_defined_adatas_toggle(self, *args, **kwargs):
+        adata = self.defined_adatas_dict[self.defined_adatas.value]
+
+        self.progress_output.clear_output()
+        with self.progress_output:
+            print(f"Loaded {adata.shape[0]} observations and {adata.shape[1]} genes\n")
+            print(adata)
+            display(self.continue_button)
+
+        self.adata = adata
+
+    def on_upload(self, *args, **kwargs):
+        from .scanpy.readwrite import read_10x_h5, read_h5ad
+
+        files = self.upload.value
+        if len(files) == 0:
+            return
+
+        file = files[0]
+
+        self.upload_info.clear_output()
+        with self.upload_info:
+            for k, v in file.items():
+                if k == "content":
+                    continue
+                print(f"{k}: {v}")
+
+        filename = file["name"]
+        contents = BytesIO(file["content"].tobytes())
+        var_names = "gene_ids"
+
+        path = Path(filename)
+
+        match path.suffix:
+            case ".h5":
+                adata = read_10x_h5(contents)
+            case ".h5ad":
+                adata = read_h5ad(contents)
+            case _:
+                self.upload_info.clear_output()
+                with self.upload_info:
+                    print(f"`{filename}` is not valid")
+                    print("Please upload a 10x h5 or h5ad file")
+                return
+
+        if var_names in adata.var:
+            adata.var = adata.var.set_index(var_names)
+
+        with self.progress_output:
+            print(f"Loaded {adata.shape[0]} observations and {adata.shape[1]} genes\n")
+            print(adata)
+            display(self.continue_button)
+
+        self.adata = adata
+
+    def on_load_url(self, *args, **kwargs):
+        self.progress_output.clear_output()
+        with self.progress_output:
+            self.adata = load_adata_from_url(self.url.value)
+            display(self.continue_button)
+
+    def on_continue(self, *args, **kwargs):
+        self.dashboard._load(self.adata)
+        self.adata = None
+        self.defined_adatas_dict = {}

sclab/dataset/_dataset.py

@@ -120,7 +120,6 @@ class SCLabDataset(EventClient):
                         },
                         "copyHtml5",
                         {"extend": "csvHtml5", "title": f"{self.name}_cells"},
-                        {"extend": "excelHtml5", "title": f"{self.name}_cells"},
                     ],
                     columnDefs=[
                         {"visible": True, "targets": [0]},
@@ -128,7 +127,7 @@ class SCLabDataset(EventClient):
                     ],
                     style="width:100%",
                     classes="display cell-border",
-                    stateSave=True,
+                    stateSave=False,
                 )
 
         def update_var_table(incoming_change: pd.DataFrame | dict, *args, **kvargs):
@@ -154,7 +153,6 @@ class SCLabDataset(EventClient):
                         },
                         "copyHtml5",
                         {"extend": "csvHtml5", "title": f"{self.name}_genes"},
-                        {"extend": "excelHtml5", "title": f"{self.name}_genes"},
                     ],
                     columnDefs=[
                         {"visible": True, "targets": [0]},
@@ -162,7 +160,7 @@ class SCLabDataset(EventClient):
                     ],
                     style="width:100%",
                     classes="display cell-border",
-                    stateSave=True,
+                    stateSave=False,
                 )
 
         update_obs_table(self.adata.obs)

sclab/dataset/processor/_processor.py

@@ -33,9 +33,11 @@ from pandas.api.types import (
 )
 from traitlets import TraitError
 
+from ..._methods_registry import get_sclab_methods
 from ...event import EventBroker, EventClient
 from .._dataset import SCLabDataset
 from ..plotter import Plotter
+from ._results_panel import ResultsPanel
 
 logger = logging.getLogger(__name__)
 
@@ -75,6 +77,7 @@ _ProcessorStep = BasicProcessorStep | ProcessorStepBase
 class Processor(EventClient):
     dataset: SCLabDataset
     plotter: Plotter
+    results_panel: ResultsPanel
     batch_key: str | None
     batch_values: list[str] | None
     broker: EventBroker
@@ -109,6 +112,7 @@ class Processor(EventClient):
     ):
         self.dataset = dataset
         self.plotter = plotter
+        self.results_panel = ResultsPanel(self.dataset.broker)
         self.broker = self.dataset.broker
         self.selection_controls_list = []
         self.selection_controls_dict = {}
@@ -187,6 +191,9 @@ class Processor(EventClient):
         super().__init__(self.broker)
         self.broker.subscribe("dset_metadata_change", self._make_selection_controls)
 
+        registered_methods = get_sclab_methods()
+        self.add_steps(registered_methods)
+
     @property
     def step_groups(self) -> dict[str, Accordion]:
         return dict(zip(self.main_accordion.titles, self.main_accordion.children))
@@ -277,9 +284,9 @@ class Processor(EventClient):
         for step_group_name, steps_list in steps.items():
             for i, step in enumerate(steps_list):
                 if isinstance(step, type):
-                    assert issubclass(
-                        step, ProcessorStepBase
-                    ), f"{step} must be a subclass of {ProcessorStepBase}"
+                    assert issubclass(step, ProcessorStepBase), (
+                        f"{step} must be a subclass of {ProcessorStepBase}"
+                    )
                     steps_list[i] = step(self)
 
         steps: dict[str, list[_ProcessorStep]]
@@ -288,9 +295,9 @@ class Processor(EventClient):
         # we make sure the steps have not been previously added
         for step_group_name, steps_list in steps.items():
             for step in steps_list:
-                assert (
-                    step.description not in self.steps
-                ), f"Step {step.description} already exists"
+                assert step.description not in self.steps, (
+                    f"Step {step.description} already exists"
+                )
 
         # we add the new steps
         group_steps_dict: dict[str, _ProcessorStep]
@@ -327,9 +334,9 @@ class Processor(EventClient):
     def add_step_object(
         self, step: ProcessorStepBase, accordion: Accordion | None = None
     ):
-        assert (
-            step.description not in self.steps
-        ), f"Step {step.description} already exists"
+        assert step.description not in self.steps, (
+            f"Step {step.description} already exists"
+        )
         self.steps[step.description] = step
 
         if accordion is not None:
@@ -532,12 +539,12 @@ class Processor(EventClient):
             ]
         )
 
-        self.selection_labeling_controls_dict[
-            "create_new_key_checkbox"
-        ] = create_new_key_checkbox
-        self.selection_labeling_controls_dict[
-            "existing_metadata_key"
-        ] = existing_metadata_key
+        self.selection_labeling_controls_dict["create_new_key_checkbox"] = (
+            create_new_key_checkbox
+        )
+        self.selection_labeling_controls_dict["existing_metadata_key"] = (
+            existing_metadata_key
+        )
         self.selection_labeling_controls_dict["existing_label"] = existing_label
         self.selection_labeling_controls_dict["new_medatadata_key"] = new_medatadata_key
         self.selection_labeling_controls_dict["new_label"] = new_label