Feat/netcdf write (#57)

* feat: add writing to netcdf files

* feat: add zarr writing

* fix: remove histogram and md5 data

* fix: write zarrs without computing data

Avoids ever storing the full dataset in memory.

* fix: write netcdfs without computing dask arrays

* fix: move zarr to shard not split

Requires updating Dask and zarr libaries (this is a recent Dask addition)

* fix: make zarr chunks and shards align

* docs: simplify comments in zarr/_writer.py

* fix: make zarr units match OME spec

* perf: collect and write split netcdf in parallel

* perf: default to uncompressed netcdf

Also document that NetCDF compression level 0 is no compression.

* style: refactor netcdf/_writer.py nested if

* style: use nectdf setncatts where appropriate

* fix: remove erronious inclusion of zarr in deps

* feat: expose zarr create_array kwargs

Also removes the hardcoded compression level keyword arg.

* refactor: prepare for multiple OME Zarr versions

* feat: add direct access to zarr shards and chunks

* fix: Dask Zarr write chunk warnings

* fix: netcdf/_writer.py indentation issue

* fix: mistakes in CHANGELOG.md

* fix: netcdf/writer.py indentation mistake

Author: omdowley

CHANGELOG.md

@@ -7,7 +7,16 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Added
+
+- Add netcdf writing via the `anu_ctlab_io.netcdf.dataset_to_netcdf()` function
+- Add zarr writing via the `anu_ctlab_io.zarr.dataset_to_zarr()` function (defaults to OME-Zarr format)
+- Add `Dataset.to_path()` to write to both zarr and netcdf formats
 - Add badges to docs/introduction.rst
+- Add `py312-dask-dev` test environment to test against fixed Dask warning logic
+- Added warning suppression for false-positive Dask PerformanceWarning when writing Zarr arrays
+
+### Changed
 
 ## [1.1.0] - 2025-12-15
 

src/anu_ctlab_io/_dataset.py

@@ -19,6 +19,10 @@ def from_path(
     ) -> Self:
         pass
 
+    @abstractmethod
+    def to_path(self, path: Path, *, filetype: str = "auto", **kwargs: Any) -> None:
+        pass
+
     @property
     @abstractmethod
     def voxel_size(self) -> tuple[np.float32, np.float32, np.float32]: ...
@@ -159,6 +163,65 @@ def from_path(
             )
         )
 
+    def to_path(
+        self,
+        path: Path | str,
+        *,
+        filetype: str = "auto",
+        **kwargs: Any,
+    ) -> None:
+        """Writes the :any:`Dataset` to the given ``path``.
+
+        The data will be written in one of the ANU mass data storage formats, and the optional extras required for the specific
+        file format must be installed.
+
+        :param path: The ``path`` to write data to.
+        :param filetype: The format to write ("NetCDF", "zarr", or "auto"). If "auto", format is inferred from path extension.
+            When inferring, NetCDF is assumed for paths ending in ``.nc`` or ``_nc``, and Zarr for paths ending in ``.zarr``.
+            If datatype is present in filename (e.g., "tomo_output"), NetCDF is assumed.
+        :param kwargs: Additional keyword arguments passed to the format-specific writer.
+        """
+        if isinstance(path, str):
+            path = Path(path)
+
+        match filetype:
+            case "NetCDF":
+                netcdf_mod = self._import_with_extra("anu_ctlab_io.netcdf", "netcdf")
+                netcdf_mod.dataset_to_netcdf(self, path, **kwargs)
+                return
+            case "zarr":
+                zarr_mod = self._import_with_extra("anu_ctlab_io.zarr", "zarr")
+                zarr_mod.dataset_to_zarr(self, path, **kwargs)
+                return
+            case "auto":
+                # Check for explicit extensions
+                if path.name.endswith(".nc") or path.name.endswith("_nc"):
+                    netcdf_mod = self._import_with_extra(
+                        "anu_ctlab_io.netcdf", "netcdf"
+                    )
+                    netcdf_mod.dataset_to_netcdf(self, path, **kwargs)
+                    return
+
+                if path.name.endswith(".zarr"):
+                    zarr_mod = self._import_with_extra("anu_ctlab_io.zarr", "zarr")
+                    zarr_mod.dataset_to_zarr(self, path, **kwargs)
+                    return
+
+                # Check if datatype is in filename (Mango convention)
+                if self._datatype is not None:
+                    datatype_str = str(self._datatype)
+                    if datatype_str in path.name:
+                        netcdf_mod = self._import_with_extra(
+                            "anu_ctlab_io.netcdf", "netcdf"
+                        )
+                        netcdf_mod.dataset_to_netcdf(self, path, **kwargs)
+                        return
+
+        raise ValueError(
+            "Unable to determine output format from given `path`, perhaps specify `filetype`?",
+            path,
+        )
+
     @property
     def voxel_size(self) -> tuple[np.float32, np.float32, np.float32]:
         """The voxel size of the data in the dataset's native unit."""

src/anu_ctlab_io/_voxel_properties.py

@@ -59,6 +59,25 @@ def __hash__(self) -> int:
     def __str__(self) -> str:
         return self.value
 
+    def to_full_name(self) -> str:
+        """Return the full unit name for OME-Zarr metadata.
+
+        OME-Zarr specification requires full unit names (e.g., "millimeter")
+        rather than abbreviated forms (e.g., "mm").
+
+        :return: Full unit name as string.
+        """
+        full_names = {
+            VoxelUnit.M: "meter",
+            VoxelUnit.CM: "centimeter",
+            VoxelUnit.MM: "millimeter",
+            VoxelUnit.UM: "micrometer",
+            VoxelUnit.NM: "nanometer",
+            VoxelUnit.ANGSTROM: "angstrom",
+            VoxelUnit.VOXEL: "voxel",
+        }
+        return full_names[self]
+
     def _conversion_factor(self, target_unit: Self) -> float:
         """Get the conversion factor from this unit to the target unit.
 

src/anu_ctlab_io/netcdf/__init__.py

@@ -1,4 +1,4 @@
-"""Read data from the ANU CTLab netcdf data format.
+"""Read and write data from/to the ANU CTLab netcdf data format.
 
 This is an optional extra module, and must be explicitly installed to be used (e.g., ``pip install anu_ctlab_io[netcdf]``)."""
 
@@ -21,7 +21,9 @@
 ):
     raise ImportError("Neither netCDF4 nor h5netcdf could be imported.")
 
-__all__ = ["dataset_from_netcdf"]
+from anu_ctlab_io.netcdf._writer import dataset_to_netcdf
+
+__all__ = ["dataset_from_netcdf", "dataset_to_netcdf"]
 
 
 def dataset_from_netcdf(
@@ -42,7 +44,9 @@ def dataset_from_netcdf(
     dataset.attrs = _update_attrs(dataset.attrs, parse_history)
     return Dataset(
         data=dataset.data.data,
-        dimension_names=tuple(map(str, dataset.dims)),
+        dimension_names=tuple(
+            map(str, dataset.data.dims)
+        ),  # Use dims from data var only
         datatype=datatype,
         voxel_unit=VoxelUnit.from_str(dataset.attrs["voxel_unit"]),
         voxel_size=dataset.attrs["voxel_size"],