Initial validate support, with --strict option

.gitignore

@@ -5,3 +5,5 @@ var
 build
 dist/
 target/
+*.DS_Store
+*/.DS_Store

.isort.cfg

@@ -1,5 +1,6 @@
 [settings]
-known_third_party = dask,numcodecs,numpy,pytest,scipy,setuptools,skimage,zarr
+
+known_third_party = dask,jsonschema,numcodecs,numpy,ome_ngff,pytest,scipy,setuptools,skimage,zarr
 multi_line_output = 3
 include_trailing_comma = True
 force_grid_wrap = 0

environment.yml

@@ -6,6 +6,7 @@ channels:
 dependencies:
   - flake8
   - ipython
+  - jsonschema
   - mypy
   - omero-py
   - pip

ome_zarr/cli.py

@@ -9,6 +9,7 @@
 from .scale import Scaler
 from .utils import download as zarr_download
 from .utils import info as zarr_info
+from .utils import validate as zarr_validate
 
 
 def config_logging(loglevel: int, args: argparse.Namespace) -> None:
@@ -29,6 +30,12 @@ def info(args: argparse.Namespace) -> None:
     list(zarr_info(args.path, stats=args.stats))
 
 
+def validate(args: argparse.Namespace) -> None:
+    """Wrap the :func:`~ome_zarr.utils.validate` method."""
+    config_logging(logging.WARN, args)
+    list(zarr_validate(args.path, args.warnings))
+
+
 def download(args: argparse.Namespace) -> None:
     """Wrap the :func:`~ome_zarr.utils.download` method."""
     config_logging(logging.WARN, args)
@@ -99,6 +106,12 @@ def main(args: List[str] = None) -> None:
     parser_info.add_argument("--stats", action="store_true")
     parser_info.set_defaults(func=info)
 
+    # validate
+    parser_validate = subparsers.add_parser("validate")
+    parser_validate.add_argument("path")
+    parser_validate.add_argument("--warnings", action="store_true")
+    parser_validate.set_defaults(func=validate)
+
     # download
     parser_download = subparsers.add_parser("download")
     parser_download.add_argument("path")

ome_zarr/data.py

@@ -147,19 +147,19 @@ def create_zarr(
             "channels": [
                 {
                     "color": "FF0000",
-                    "window": {"start": 0, "end": 255},
+                    "window": {"start": 0, "end": 255, "min": 0, "max": 255},
                     "label": "Red",
                     "active": True,
                 },
                 {
                     "color": "00FF00",
-                    "window": {"start": 0, "end": 255},
+                    "window": {"start": 0, "end": 255, "min": 0, "max": 255},
                     "label": "Green",
                     "active": True,
                 },
                 {
                     "color": "0000FF",
-                    "window": {"start": 0, "end": 255},
+                    "window": {"start": 0, "end": 255, "min": 0, "max": 255},
                     "label": "Blue",
                     "active": True,
                 },

ome_zarr/reader.py

@@ -8,9 +8,12 @@
 import dask.array as da
 import numpy as np
 from dask import delayed
+from jsonschema import validate as jsonschema_validate
+from jsonschema.validators import validator_for
+from ome_ngff.schemas import LocalRefResolver, get_schema
 
 from .axes import Axes
-from .format import format_from_version
+from .format import CurrentFormat, format_from_version
 from .io import ZarrLocation
 from .types import JSONDict
 
@@ -106,6 +109,12 @@ def load(self, spec_type: Type["Spec"]) -> Optional["Spec"]:
                 return spec
         return None
 
+    def validate(self, warnings: bool) -> None:
+        # Validation for a node is delegated to each spec
+        # e.g. Labels may have spec for multiscales and labels
+        for spec in self.specs:
+            spec.validate(warnings)
+
     def add(
         self,
         zarr: ZarrLocation,
@@ -177,6 +186,10 @@ def __init__(self, node: Node) -> None:
     def lookup(self, key: str, default: Any) -> Any:
         return self.zarr.root_attrs.get(key, default)
 
+    def validate(self, warnings: bool = False) -> None:
+        # If not implemented, ignore for now
+        pass
+
 
 class Labels(Spec):
     """Relatively small specification for the well-known "labels" group which only
@@ -324,6 +337,30 @@ def array(self, resolution: str, version: str) -> da.core.Array:
         # data.shape is (t, c, z, y, x) by convention
         return self.zarr.load(resolution)
 
+    def validate(self, warnings: bool = False) -> None:
+        multiscales = self.lookup("multiscales", [])
+        version = multiscales[0].get("version", CurrentFormat().version)
+        LOGGER.info("Validating Multiscales spec at: %s" % self.zarr)
+        LOGGER.info("Using Multiscales schema version: %s" % version)
+        image_schema = get_schema(version)
+
+        # Always do a validation with the MUST rules
+        # Will throw ValidationException if it fails
+        json_data = self.zarr.root_attrs
+        jsonschema_validate(instance=json_data, schema=image_schema)
+
+        # If we're also checking for SHOULD rules,
+        # we want to iterate all errors and show as "Warnings"
+        if warnings:
+            strict_schema = get_schema(version, strict=True)
+            cls = validator_for(strict_schema)
+            cls.check_schema(strict_schema)
+            # Use our local resolver subclass to resolve local documents
+            localResolver = LocalRefResolver.from_schema(strict_schema)
+            validator = cls(strict_schema, resolver=localResolver)
+            for error in validator.iter_errors(json_data):
+                LOGGER.warn(error.message)
+
 
 class OMERO(Spec):
     @staticmethod

ome_zarr/utils.py

@@ -3,7 +3,7 @@
 import json
 import logging
 from pathlib import Path
-from typing import Iterator, List
+from typing import Callable, Iterator, List
 
 import dask
 import dask.array as da
@@ -17,21 +17,26 @@
 LOGGER = logging.getLogger("ome_zarr.utils")
 
 
-def info(path: str, stats: bool = False) -> Iterator[Node]:
-    """Print information about an OME-Zarr fileset.
-
-    All :class:`Nodes <ome_utils.reader.Node>` that are found from the given path will
-    be visited recursively.
-    """
+def visit(path: str, func: Callable) -> Iterator[Node]:
+    """Call func(node) for each node read from path."""
     zarr = parse_url(path)
     assert zarr, f"not a zarr: {zarr}"
     reader = Reader(zarr)
     for node in reader():
-
         if not node.specs:
             print(f"not an ome-zarr node: {node}")
             continue
+        yield func(node)
 
+
+def info(path: str, stats: bool = False) -> Iterator[Node]:
+    """Print information about an OME-Zarr fileset.
+
+    All :class:`Nodes <ome_utils.reader.Node>` that are found from the given path will
+    be visited recursively.
+    """
+
+    def func(node: Node) -> Node:
         print(node)
         print(" - metadata")
         for spec in node.specs:
@@ -43,7 +48,25 @@ def info(path: str, stats: bool = False) -> Iterator[Node]:
                 minmax = f" minmax={dask.compute(array.min(), array.max())}"
             print(f"   - {array.shape}{minmax}")
         LOGGER.debug(node.data)
-        yield node
+        return node
+
+    return visit(path, func)
+
+
+def validate(path: str, warnings: bool) -> Iterator[Node]:
+    """
+    Validate OME-NGFF data
+
+    All :class:`Nodes <ome_utils.reader.Node>` that are found from the given path will
+    be visited recursively.
+    """
+
+    def func(node: Node) -> Node:
+        if hasattr(node, "validate"):
+            node.validate(warnings)
+        return node
+
+    return visit(path, func)
 
 
 def download(input_path: str, output_dir: str = ".") -> None:

setup.py

@@ -24,6 +24,8 @@ def read(fname):
 install_requires += (["requests"],)
 install_requires += (["scikit-image"],)
 install_requires += (["toolz"],)
+install_requires += (["jsonschema"],)
+install_requires += (["ome_ngff"],)
 
 
 setup(

tests/test_cli.py

@@ -33,6 +33,15 @@ def test_astronaut_info(self):
         main(["create", "--method=astronaut", filename])
         main(["info", filename])
 
+    @pytest.mark.parametrize("warnings", [False, True])
+    def test_astronaut_validation(self, warnings):
+        filename = str(self.path) + "-2"
+        main(["create", "--method=astronaut", filename])
+        if warnings:
+            main(["validate", "--warnings", filename])
+        else:
+            main(["validate", filename])
+
     def test_astronaut_download(self, tmpdir):
         out = str(tmpdir / "out")
         filename = str(self.path) + "-3"