Release v0.16.5: CI: docker build fix with cellpose without deepcell and arm64/amd64 build

Author: victorjonathanibanez

CHANGELOG.md

@@ -10,7 +10,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Changed
 
-  - fixed new docker build distribution, where cellpose does not include deepcell + proper arm64/amd64 build
+  - fixed new docker build distribution, where cellpose does not include deepcell, added lazy loading + proper arm64/amd64 build
+  
 
 ## [0.16.4] - 2026-03-26
 

steinbock/_cli/_cli.py

@@ -9,7 +9,6 @@
 from ..utils._cli import utils_cmd_group
 from .apps import apps_cmd_group
 from .utils import OrderedClickGroup
-from .visualization import view_cmd
 
 
 @click.group(name="steinbock", cls=OrderedClickGroup)
@@ -18,6 +17,14 @@ def steinbock_cmd_group():
     pass
 
 
+@click.command(name="view")
+@click.pass_context
+def view_cmd(ctx, *args, **kwargs):
+    from .visualization import view_cmd as _view_cmd
+
+    return ctx.invoke(_view_cmd, *args, **kwargs)
+
+
 steinbock_cmd_group.add_command(preprocess_cmd_group)
 steinbock_cmd_group.add_command(classify_cmd_group)
 steinbock_cmd_group.add_command(segment_cmd_group)

steinbock/_cli/visualization.py

@@ -6,7 +6,6 @@
 from .. import io
 from .._steinbock import SteinbockException
 from .._steinbock import logger as steinbock_logger
-from ..visualization import view
 from .utils import catch_exception
 
 
@@ -48,13 +47,13 @@
 @click_log.simple_verbosity_option(logger=steinbock_logger)
 @catch_exception(handle=SteinbockException)
 def view_cmd(img_dir, mask_dirs, panel_file, pixel_size_um, img_file_name):
+    from ..visualization import view
+
     img = io.read_image(Path(img_dir) / img_file_name, native_dtype=True)
     masks = None
     if len(mask_dirs) > 0:
         masks = {
-            f"Mask ({Path(mask_dir).name})": io.read_mask(
-                Path(mask_dir) / img_file_name, native_dtype=True
-            )
+            f"Mask ({Path(mask_dir).name})": io.read_mask(Path(mask_dir) / img_file_name, native_dtype=True)
             for mask_dir in mask_dirs
         }
     channel_names = None

steinbock/segmentation/_cli/cellpose.py

@@ -8,14 +8,32 @@
 from ..._cli.utils import catch_exception, logger
 from ..._steinbock import SteinbockException
 from ..._steinbock import logger as steinbock_logger
-from .. import cellpose
 
-cellpose_cli_available = cellpose.cellpose_available
 
+def _get_cellpose_module():
+    try:
+        from .. import cellpose as cellpose_module
+    except ImportError as e:
+        raise click.ClickException("The 'cellpose' command requires the optional Cellpose dependencies.") from e
 
-@click.command(
-    name="cellpose", help="Run an object segmentation batch using CellposeSAM"
-)
+    if not getattr(cellpose_module, "cellpose_available", False):
+        raise click.ClickException(
+            "The 'cellpose' command is not available because Cellpose dependencies "
+            "are not installed in this environment."
+        )
+
+    return cellpose_module
+
+
+try:
+    from .. import cellpose as _cellpose_probe
+
+    cellpose_cli_available = bool(getattr(_cellpose_probe, "cellpose_available", False))
+except ImportError:
+    cellpose_cli_available = False
+
+
+@click.command(name="cellpose", help="Run an object segmentation batch using CellposeSAM")
 @click.option(
     "--img",
     "img_dir",
@@ -193,14 +211,22 @@ def cellpose_cmd(
     tile_overlap,
     mask_dir,
 ):
+    cellpose = _get_cellpose_module()
+
     channel_groups = None
     if Path(panel_file).is_file():
         panel = io.read_panel(panel_file)
         if "cellpose" in panel and panel["cellpose"].notna().any():
             channel_groups = panel["cellpose"].values
-    aggr_func = getattr(np, aggr_func_name)
+
+    try:
+        aggr_func = getattr(np, aggr_func_name)
+    except AttributeError as e:
+        raise click.ClickException(f"Invalid numpy aggregation function: {aggr_func_name}") from e
+
     img_files = io.list_image_files(img_dir)
     Path(mask_dir).mkdir(exist_ok=True)
+
     for img_file, mask, _, _ in cellpose.try_segment_objects(
         img_files,
         channelwise_minmax=channelwise_minmax,

steinbock/segmentation/_cli/deepcell.py

@@ -8,23 +8,52 @@
 from ..._cli.utils import catch_exception, logger
 from ..._steinbock import SteinbockException
 from ..._steinbock import logger as steinbock_logger
-from .. import deepcell
 
-if deepcell.deepcell_available:
-    import yaml
 
-deepcell_cli_available = deepcell.deepcell_available
+def _get_deepcell_module():
+    try:
+        from .. import deepcell as deepcell_module
+    except ImportError as e:
+        raise click.ClickException("The 'deepcell' command requires the optional DeepCell dependencies.") from e
 
-_applications = {
-    "mesmer": deepcell.Application.MESMER,
-}
+    if not getattr(deepcell_module, "deepcell_available", False):
+        raise click.ClickException(
+            "The 'deepcell' command is not available because DeepCell dependencies "
+            "are not installed in this environment."
+        )
+
+    return deepcell_module
+
+
+def _get_yaml_module():
+    try:
+        import yaml
+    except ImportError as e:
+        raise click.ClickException("The 'deepcell' command requires PyYAML.") from e
+
+    return yaml
+
+
+def _get_applications():
+    deepcell_module = _get_deepcell_module()
+    return {
+        "mesmer": deepcell_module.Application.MESMER,
+    }
+
+
+try:
+    from .. import deepcell as _deepcell_probe
+
+    deepcell_cli_available = bool(getattr(_deepcell_probe, "deepcell_available", False))
+except ImportError:
+    deepcell_cli_available = False
 
 
 @click.command(name="deepcell", help="Run an object segmentation batch using DeepCell")
 @click.option(
     "--app",
     "application_name",
-    type=click.Choice(list(_applications.keys()), case_sensitive=True),
+    type=click.Choice(["mesmer"], case_sensitive=True),
     show_choices=True,
     default="mesmer",
     show_default=True,
@@ -138,36 +167,54 @@ def deepcell_cmd(
     postprocess_file,
     mask_dir,
 ):
+    deepcell = _get_deepcell_module()
+    applications = _get_applications()
+
     channel_groups = None
     if Path(panel_file).is_file():
         panel = io.read_panel(panel_file)
         if "deepcell" in panel and panel["deepcell"].notna().any():
             channel_groups = panel["deepcell"].values
-    aggr_func = getattr(np, aggr_func_name)
+
+    try:
+        aggr_func = getattr(np, aggr_func_name)
+    except AttributeError as e:
+        raise click.ClickException(f"Invalid numpy aggregation function: {aggr_func_name}") from e
+
     img_files = io.list_image_files(img_dir)
+
     model = None
     if model_path_or_name is not None:
-        from tensorflow.keras.models import load_model  # type: ignore
-
-        if Path(model_path_or_name).exists():
-            model = load_model(model_path_or_name, compile=False)
-        elif Path(keras_model_dir).joinpath(model_path_or_name).exists():
-            model = load_model(
-                Path(keras_model_dir).joinpath(model_path_or_name),
-                compile=False,
-            )
+        try:
+            from tensorflow.keras.models import load_model  # type: ignore
+        except ImportError as e:
+            raise click.ClickException("TensorFlow/Keras is required to load a DeepCell model.") from e
+
+        model_path = Path(model_path_or_name)
+        keras_model_path = Path(keras_model_dir).joinpath(model_path_or_name)
+
+        if model_path.exists():
+            model = load_model(model_path, compile=False)
+        elif keras_model_path.exists():
+            model = load_model(keras_model_path, compile=False)
+
     preprocess_kwargs = None
     if preprocess_file is not None:
+        yaml = _get_yaml_module()
         with Path(preprocess_file).open() as f:
             preprocess_kwargs = yaml.load(f, yaml.Loader)
+
     postprocess_kwargs = None
     if postprocess_file is not None:
+        yaml = _get_yaml_module()
         with Path(postprocess_file).open() as f:
             postprocess_kwargs = yaml.load(f, yaml.Loader)
+
     Path(mask_dir).mkdir(exist_ok=True)
+
     for img_file, mask in deepcell.try_segment_objects(
         img_files,
-        _applications[application_name],
+        applications[application_name],
         model=model,
         channelwise_minmax=channelwise_minmax,
         channelwise_zscore=channelwise_zscore,

steinbock/visualization.py

@@ -1,6 +1,5 @@
 from typing import Dict, Optional, Sequence
 
-import napari
 import numpy as np
 
 
@@ -11,7 +10,9 @@ def view(
     pixel_size_um: float = 1.0,
     run: bool = True,
     **viewer_kwargs,
-) -> Optional[napari.Viewer]:
+) -> Optional["napari.Viewer"]:
+    import napari
+
     viewer = napari.Viewer(**viewer_kwargs)
     viewer.axes.visible = True
     viewer.dims.axis_labels = ("y", "x")