linters are happy, and .zgroup file writing is more robust

Author: vreuter

illumifix/__init__.py

@@ -1,12 +1,26 @@
 """Project root"""
 
+import json
 from pathlib import Path
-from ome_zarr.format import FormatV02
 
-# Make the __version__ attribute of the project available at the top level.
-from ._version import __version__
+from ome_zarr.format import FormatV02  # type: ignore[import-untyped]
 
+# Make the __version__ attribute of the project available at the top level.
+from ._version import __version__  # noqa: F401
 
 PROJECT_NAME = Path(__file__).resolve().parent.name
 
+
+class JsonEncoderForZarrFormat(json.JSONEncoder):
+    """Allow encoding of a zarr.Format value as JSON."""
+
+    def default(self, o) -> object:  # type: ignore[no-untyped-def] # noqa: ANN001
+        """Attempt to encode the given object as JSON."""
+        match o:
+            case FormatV02():
+                return {"zarr_format": 2}
+            case _:
+                return super().default(o)
+
+
 ZARR_FORMAT = FormatV02()

illumifix/expression_utilities.py

@@ -11,6 +11,19 @@
 
 
 def separate(results: Iterable[Result[_TSource, _TError]]) -> tuple[list[_TError], list[_TSource]]:
+    """Separate the given collection into errors and Oks.
+
+    Args:
+        results (Iterable[Result[_TSource, _TError]]): the collection of wrapped values to split into errors and Oks.
+
+    Raises:
+        TypeError: if any element in the given collection isn't a result.Result
+
+    Returns:
+        tuple[list[_TError], list[_TSource]]: a pair of lists,
+        the first of which is the errors and the second of which is the Oks
+
+    """
     bads: list[_TError] = []
     goods: list[_TSource] = []
     for i, res in enumerate(results):
@@ -29,6 +42,16 @@ def separate(results: Iterable[Result[_TSource, _TError]]) -> tuple[list[_TError
 def sequence_accumulate_errors(
     results: Iterable[Result[_TSource, _TError]],
 ) -> Result[list[_TSource], list[_TError]]:
+    """Return a result.Error wrapping all such values if any exists, otherwise a result.Ok wrapping all Ok-wrapped values
+
+    Args:
+        results (Iterable[Result[_TSource, _TError]]): the collection of values to process
+
+    Returns:
+        Result[list[_TSource], list[_TError]]: a result.Ok wrapping all values if every one is a result.Ok,
+        otherwise a result.Error wrapping a list of all result.Error-wrapped values
+
+    """
     bads, goods = separate(results)
     return Result.Error(bads) if bads else Result.Ok(goods)
 
@@ -38,4 +61,15 @@ def traverse_accumulate_errors(
     inputs: Iterable[_TInput],
     func: Callable[[_TInput], Result[_TSource, _TError]],
 ) -> Result[list[_TSource], list[_TError]]:
+    """Apply the given function to each element, returning a result.Ok-wrapped collection of resulting values if every application succeeds, otherwise a result.Error wrapping all error values.
+
+    Args:
+        inputs (Iterable[_TInput]): the elements to input to the given function
+        func (Callable[[_TInput], Result[_TSource, _TError]]): the function to apply to each element
+
+    Returns:
+        Result[list[_TSource], list[_TError]]: either a result.Ok-wrapped collection of resulting values
+        of every application succeeds, otherwise a result.Error wrapping all error values
+
+    """
     return sequence_accumulate_errors(map(func, inputs))