Add jsonschema_dingus

Author: clbarnes

README.md

@@ -13,22 +13,26 @@ The built documentation including contribution hints can be found **[here](https
 
 Conformance can be tested at several levels.
 
-1. Validating a single zarr attributes object (i.e. containing OME-Zarr metadata)
+1. Validating that individual fields of a zarr attributes object are valid.
+2. Validating a single zarr attributes object (i.e. containing OME-Zarr metadata)
 
     - Validates that correct data can be represented, and that internally inconsistent data can be caught
     - Cannot validate references to other objects in the zarr hierarchy
     - Cannot validate conformance to other zarr metadata e.g. array data type, dimensionality
 
-2. Validating a metadata-only zarr hierarchy
+3. Validating a metadata-only zarr hierarchy
 
     - Can validate references to other objects and other zarr metadata
     - Cannot validate values e.g. the invertibility of an affine matrix defined as a zarr array
 
-3. Validating a zarr hierarchy with data
+4. Validating a zarr hierarchy with data
+
+This repository contains
+
+- JSON schemas which handle level 1
+- a set of test zarr attributes JSON for level 2 ([`./tests/attributes`](./tests/attributes/))
+- a set of metadata-only zarr hierarchies for level 3 ([`./tests/zarr`](./tests/zarr/))
 
-This repository contains a set of test cases for levels
-1 ([`./tests/attributes`](./tests/attributes/)) and
-2 ([`./tests/zarr`](./tests/zarr/)),
 as well as a tool for feeding these test cases into an external validator.
 
 ### Testing tool
@@ -47,7 +51,7 @@ which takes as its last argument the path to either
 The dingus should print to STDOUT a JSON object with the keys:
 
 - `"valid"`: boolean, whether this is valid
-- optionally `"message"`: str, free text describing the success/ failure
+- optionally `"message"`: string, free text describing the success/ failure
 
 Call the tool like
 
@@ -66,3 +70,13 @@ Each call to the dingus will then look like
 `ome_zarr_conformance.py` will parse the JSON output and format the results of all requested tests in a tab-separated table.
 
 Full usage information is available with `./ome_zarr_conformance.py --help`.
+
+### JSON Schema tests
+
+You can use the conformance testing tool to test JSON Schema-based validation with
+
+```sh
+>>> ./ome_zarr_conformance.py attributes -- uv run jsonschema_dingus.py attributes
+```
+
+Some failures are expected as JSON Schema can only handle level 1 validation.

jsonschema_dingus.py

@@ -0,0 +1,96 @@
+#!/usr/bin/env python3
+# /// script
+# dependencies = [
+#   "jsonschema",
+#   "referencing",
+# ]
+# ///
+from __future__ import annotations
+from dataclasses import dataclass
+from pathlib import Path
+import json
+from argparse import ArgumentParser
+from typing import Any, Self
+
+from referencing import Registry, Resource
+from jsonschema import Draft202012Validator as Validator
+from jsonschema.exceptions import ValidationError
+
+HERE = Path(__file__).resolve().parent
+SCHEMA_DIR = HERE / "ngff_spec" / "schemas"
+
+
+@dataclass
+class SchemasInfo:
+    generic_id: str
+    base_url: str
+    registry: Registry
+
+    @classmethod
+    def load(cls) -> Self:
+        """Get the ID of the top-level schema, and the mapping of schema IDs to objects"""
+        registry = Registry()
+        generic = None
+        base_url = None
+        for p in SCHEMA_DIR.glob("*.schema*"):
+            schema = json.loads(p.read_text())
+            resource = Resource.from_contents(schema)
+            registry = resource @ registry
+
+            schema_id = resource.id()
+            if schema_id is None:
+                raise RuntimeError("schema has no ID")
+            if p.stem == "ome_zarr":
+                generic = schema_id
+                base_url = generic.split("/schemas/")[0]
+
+        if generic is None or base_url is None:
+            raise RuntimeError("Could not find generic ome_zarr schema")
+
+        return cls(generic, base_url, registry)
+
+
+def main(raw_args=None):
+    parser = ArgumentParser()
+    parser.add_argument("mode", choices=["attributes", "zarr"])
+    parser.add_argument("path", type=Path)
+
+    args = parser.parse_args(raw_args)
+
+    p: Path = args.path
+    attrs: None | dict[str, Any] = None
+    match args.mode:
+        case "attributes":
+            attrs = json.loads(p.read_text())
+        case "zarr":
+            attrs = json.loads(p.joinpath("zarr.json").read_text())["attributes"]
+        case _:
+            raise RuntimeError("unreachable")
+
+    if attrs is None:
+        raise RuntimeError("unreachable")
+
+    schemas = SchemasInfo.load()
+
+    generic_schema = schemas.registry.get(schemas.generic_id)
+    if generic_schema is None:
+        raise RuntimeError("could not find generic schema")
+
+    validator = Validator(
+        generic_schema.contents,
+        registry=schemas.registry,
+    )
+
+    result = dict()
+    try:
+        validator.validate(attrs)
+        result["valid"] = True
+    except ValidationError as e:
+        result["valid"] = False
+        result["message"] = str(e)
+
+    print(json.dumps(result))
+
+
+if __name__ == "__main__":
+    main()

tests/test_validation.py

@@ -63,11 +63,6 @@ def pytest_generate_tests(metafunc):
 
     suites: List[Suite] = []
     ids: List[str] = []
-    schema_store = {}
-    for filename in glob.glob("ngff_spec/schemas/*.schema"):
-        with open(filename) as o:
-            schema = json.load(o)
-        schema_store[schema["$id"]] = schema
 
     # Validation
     for filename in glob.glob("tests/*.json"):