Initial validate support, with --strict option

.isort.cfg

@@ -1,5 +1,5 @@
 [settings]
-known_third_party = dask,numpy,pytest,scipy,setuptools,skimage,zarr
+known_third_party = dask,jsonschema,numpy,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,8 +8,11 @@
 import dask.array as da
 import numpy as np
 from dask import delayed
+from jsonschema import validate
+from jsonschema.validators import validator_for
 
 from .io import ZarrLocation
+from .schemas import LocalRefResolver, get_schema, get_strict_schema
 from .types import JSONDict
 
 LOGGER = logging.getLogger("ome_zarr.reader")
@@ -104,6 +107,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,
@@ -175,6 +184,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
@@ -315,6 +328,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", "0.1")
+        print("Validating Multiscales spec at", self.zarr)
+        print("Using Multiscales schema version", 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
+        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_strict_schema(version)
+            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):
+                print("WARNING", error.message)
+
 
 class OMERO(Spec):
     @staticmethod

ome_zarr/schemas.py

@@ -0,0 +1,43 @@
+import json
+import os
+from typing import Dict
+
+from jsonschema import RefResolver
+
+
+class LocalRefResolver(RefResolver):
+    def resolve_remote(self, url: str) -> Dict:
+        # Use remote URL to generate local path
+        rel_path = url.replace("https://ngff.openmicroscopy.org/", "../schemas/")
+        curr_dir = os.path.dirname(__file__)
+        path = os.path.join(curr_dir, rel_path)
+        path = os.path.normpath(path)
+        # Load local document and cache it
+        document = load_json(path)
+        self.store[url] = document
+        return document
+
+
+def load_json(path: str) -> Dict:
+    with open(path) as f:
+        document = json.loads(f.read())
+    return document
+
+
+def get_schema(version: str) -> Dict:
+    curr_dir = os.path.dirname(__file__)
+    # The paths here match the paths in the ngff repo (and public schemas)
+    path = os.path.join(
+        curr_dir, f"../schemas/{version}/schemas/json_schema/image.schema"
+    )
+    path = os.path.normpath(path)
+    return load_json(path)
+
+
+def get_strict_schema(version: str) -> Dict:
+    curr_dir = os.path.dirname(__file__)
+    path = os.path.join(
+        curr_dir, f"../schemas/{version}/schemas/json_schema/strict_image.schema"
+    )
+    path = os.path.normpath(path)
+    return load_json(path)

ome_zarr/utils.py

@@ -46,6 +46,26 @@ def info(path: str, stats: bool = False) -> Iterator[Node]:
         yield node
 
 
+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.
+    """
+    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
+
+        if hasattr(node, "validate"):
+            node.validate(warnings)
+        yield node
+
+
 def download(input_path: str, output_dir: str = ".") -> None:
     """Download an OME-Zarr from the given path.
 

schemas/0.1/schemas/json_schema/image.schema

@@ -0,0 +1,112 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://ngff.openmicroscopy.org/0.1/schemas/json_schema/image.schema",
+  "title": "NGFF Image",
+  "description": "JSON from OME-NGFF .zattrs",
+  "type": "object",
+  "properties": {
+    "multiscales": {
+      "description": "The multiscale datasets for this image",
+      "type": "array",
+      "items": {
+        "type": "object",
+        "properties": {
+          "name": {
+            "type": "string"
+          },
+          "datasets": {
+            "type": "array",
+            "minItems": 1,
+            "items": {
+              "type": "object",
+              "properties": {
+                "path": {
+                  "type": "string"
+                }
+              },
+              "required": ["path"]
+            }
+          },
+          "version": {
+            "type": "string",
+            "enum": [
+              "0.1"
+            ]
+          },
+          "metadata": {
+            "type": "object",
+            "properties": {
+              "method": {
+                "type": "string"
+              },
+              "version": {
+                "type": "string"
+              }
+            }
+          }
+        },
+        "required": [
+          "datasets"
+        ]
+      },
+      "minItems": 1,
+      "uniqueItems": true
+    },
+    "omero": {
+      "type": "object",
+      "properties": {
+        "channels": {
+          "type": "array",
+          "items": {
+            "type": "object",
+            "properties": {
+              "window": {
+                "type": "object",
+                "properties": {
+                  "end": {
+                    "type": "number"
+                  },
+                  "max": {
+                    "type": "number"
+                  },
+                  "min": {
+                    "type": "number"
+                  },
+                  "start": {
+                    "type": "number"
+                  }
+                },
+                "required": [
+                  "start",
+                  "min",
+                  "end",
+                  "max"
+                ]
+              },
+              "label": {
+                "type": "string"
+              },
+              "family": {
+                "type": "string"
+              },
+              "color": {
+                "type": "string"
+              },
+              "active": {
+                "type": "boolean"
+              }
+            },
+            "required": [
+              "window",
+              "color"
+            ]
+          }
+        }
+      },
+      "required": [
+        "channels"
+      ]
+    }
+  },
+  "required": [ "multiscales" ]
+}