feat: add io and cli

examples/zarr_arr.py

@@ -8,7 +8,7 @@
 except ImportError:
     raise ImportError("Please `pip install zarr aiohttp` to run this example")
 
-
+# url = "https://uk1s3.embassy.ebi.ac.uk/idr/zarr/v0.4/idr0062A/6001240.zarr"
 URL = "https://s3.embl.de/i2k-2020/ngff-example-data/v0.4/tczyx.ome.zarr"
 zarr_arr = zarr.open(URL, mode="r")
 

pyproject.toml

@@ -35,12 +35,21 @@ classifiers = [
 ]
 dependencies = ["qtpy", "numpy", "superqt[cmap,iconify]"]
 
+[project.scripts]
+ndv = "ndv.cli:main"
+
 # https://peps.python.org/pep-0621/#dependencies-optional-dependencies
 [project.optional-dependencies]
 pyqt = ["pyqt6"]
 vispy = ["vispy", "pyopengl"]
 pyside = ["pyside6"]
 pygfx = ["pygfx"]
+io = [
+    "aicsimageio[all]",
+    "bioformats_jar",
+    "readlif",
+    "aicspylibczi",
+]
 third_party_arrays = [
     "aiohttp",                                 # for zarr example
     "jax[cpu]",

src/ndv/cli.py

@@ -0,0 +1,20 @@
+"""command-line program."""
+
+import argparse
+
+from ndv.util import imshow
+
+
+def _parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="ndv: ndarray viewer")
+    parser.add_argument("path", type=str, help="The filename of the numpy file to view")
+    return parser.parse_args()
+
+
+def main() -> None:
+    """Run the command-line program."""
+    from ndv import io
+
+    args = _parse_args()
+
+    imshow(io.imread(args.path))

src/ndv/io.py

@@ -0,0 +1,43 @@
+"""All the io we can think of."""
+
+from __future__ import annotations
+
+from textwrap import indent, wrap
+from typing import TYPE_CHECKING, Any
+
+import numpy as np
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+    import xarray as xr
+
+
+def imread(path: str | Path) -> Any:
+    """Just read the thing already."""
+    path_str = str(path)
+    if path_str.endswith(".npy"):
+        return np.load(path_str)
+    errors = {}
+    try:
+        return _read_aicsimageio(path)
+    except Exception as e:
+        errors["aicsimageio"] = e
+
+    raise ValueError(_format_error_message(errors))
+
+
+def _format_error_message(errors: dict[str, Exception]) -> str:
+    lines = ["Could not read file. Here are all the things we tried", ""]
+    for _key, value in errors.items():
+        lines.append(f"{_key}:")
+        wrapped = wrap(str(value), width=120)
+        indented = indent("\n".join(wrapped), "    ")
+        lines.append(indented)
+    return "\n".join(lines)
+
+
+def _read_aicsimageio(path: str | Path) -> xr.DataArray:
+    from aicsimageio import AICSImage
+
+    return AICSImage(str(path)).xarray_dask_data

src/ndv/viewer/_data_wrapper.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import json
 import logging
 import sys
 from abc import abstractmethod
@@ -97,9 +98,10 @@
         # be automatically detected (assuming they have been imported by this point)
         for subclass in sorted(_recurse_subclasses(cls), key=lambda x: x.PRIORITY):
             with suppress(Exception):
-                if subclass.supports(data):
-                    logging.debug(f"Using {subclass.__name__} to wrap {type(data)}")
-                    return subclass(data)
+                if not subclass.supports(data):
+                    continue
+            logging.debug(f"Using {subclass.__name__} to wrap {type(data)}")
+            return subclass(data)
         raise NotImplementedError(f"Don't know how to wrap type {type(data)}")
 
     def __init__(self, data: ArrayT) -> None:
@@ -219,10 +221,27 @@
         super().__init__(data)
         import tensorstore as ts
 
+        spec = self.data.spec().to_json()
+        labels: Sequence[Hashable] | None = None
         self._ts = ts
+        if (tform := spec.get("transform")) and ("input_labels" in tform):
+            labels = [str(x) for x in tform["input_labels"]]
+        elif (
+            str(spec.get("driver")).startswith("zarr")
+            and (zattrs := self.data.kvstore.read(".zattrs").result().value)
+            and isinstance((zattr_dict := json.loads(zattrs)), dict)
+            and "_ARRAY_DIMENSIONS" in zattr_dict
+        ):
+            labels = zattr_dict["_ARRAY_DIMENSIONS"]
+
+        if isinstance(labels, Sequence) and len(labels) == len(self._data.domain):
+            self._labels: list[Hashable] = [str(x) for x in labels]
+            self._data = self.data[ts.d[:].label[self._labels]]
+        else:
+            self._labels = list(range(len(self._data.domain)))
 
     def sizes(self) -> Mapping[Hashable, int]:
-        return {dim.label: dim.size for dim in self._data.domain}
+        return dict(zip(self._labels, self._data.domain.shape))
 
     def isel(self, indexers: Indices) -> np.ndarray:
         result = (

src/ndv/viewer/_viewer.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import logging
 from collections import defaultdict
 from itertools import cycle
 from typing import TYPE_CHECKING, Literal, cast
@@ -258,7 +259,6 @@
         """
         # store the data
         self._data_wrapper = DataWrapper.create(data)
-
         # set channel axis
         self._channel_axis = self._data_wrapper.guess_channel_axis()
 
@@ -458,6 +458,10 @@
         if future.cancelled():
             return
 
+        if exc := future.exception():
+            logging.error(f"Error getting data: {exc}")
+            return
+
         for idx, datum in future.result():
             self._update_canvas_data(datum, idx)
         self._canvas.refresh()