fix: pin fill value based on data type instead of relying on xarray

Author: d-v-b

src/eopf_geozarr/conversion/geozarr.py

@@ -1479,7 +1479,14 @@ def _create_encoding(
             else:
                 chunking = (min(spatial_chunk, data_shape[-1]),)
 
-        encoding[var] = {"compressors": [compressor], "chunks": chunking}
+        var_encoding: XarrayEncodingJSON = {
+            "compressors": [compressor],
+            "chunks": chunking,
+        }
+        fv = utils.explicit_fill_value(ds[var])
+        if fv is not utils.UNSET:
+            var_encoding["fill_value"] = fv
+        encoding[var] = var_encoding
 
     # Add coordinate encoding
     for coord in ds.coords:
@@ -1565,11 +1572,15 @@ def _create_geozarr_encoding(
                             axis=i,
                         )
 
-            encoding[var] = {
+            var_encoding: XarrayEncodingJSON = {
                 "chunks": chunks,
                 "compressors": compressor,
                 "shards": shards,
             }
+            fv = utils.explicit_fill_value(ds[var])
+            if fv is not utils.UNSET:
+                var_encoding["fill_value"] = fv
+            encoding[var] = var_encoding
 
     # Add coordinate encoding
     for coord in ds.coords:

src/eopf_geozarr/conversion/utils.py

@@ -1,5 +1,7 @@
 """Utility functions for GeoZarr conversion."""
 
+from typing import Any
+
 import numpy as np
 import rasterio  # noqa: F401  # Import to enable .rio accessor
 import structlog
@@ -8,6 +10,39 @@
 log = structlog.get_logger()
 
 
+# Sentinel: distinguish "no explicit fill_value" from a legitimate `None`.
+UNSET: Any = object()
+
+
+def explicit_fill_value(var: xr.DataArray) -> Any:
+    """Pick a zarr-level `fill_value` for `var` based on its source `_FillValue`.
+
+    Different xarray versions infer different on-disk fill values when the
+    encoding dict doesn't pin it: older xarray defaults floats to 0.0; newer
+    xarray honours the source `_FillValue`. Setting `fill_value` explicitly
+    via this helper removes that degree of freedom so the on-disk metadata is
+    stable across xarray versions.
+
+    Returns
+    -------
+    object
+        The value to assign to `encoding["fill_value"]`. The sentinel `UNSET`
+        is returned when the source has no `_FillValue` (caller should leave
+        the encoding entry alone). For non-finite floats, returns the
+        JSON-canonical string form (`"NaN"` / `"Infinity"` / `"-Infinity"`)
+        that zarr-python serialises.
+    """
+    source_fill = var.encoding.get("_FillValue")
+    if source_fill is None:
+        return UNSET
+    fill_arr = np.asarray(source_fill)
+    if np.issubdtype(fill_arr.dtype, np.floating) and not np.isfinite(fill_arr):
+        if np.isnan(fill_arr):
+            return "NaN"
+        return "Infinity" if fill_arr > 0 else "-Infinity"
+    return source_fill
+
+
 def downsample_2d_array(
     source_data: np.ndarray,
     target_height: int,

src/eopf_geozarr/s2_optimization/s2_multiscale.py

@@ -20,6 +20,7 @@
 from zarr_cm import multiscales as multiscales_cm
 from zarr_cm import spatial as spatial_cm
 
+from eopf_geozarr.conversion import utils
 from eopf_geozarr.conversion.fs_utils import sanitize_dataset_attributes
 from eopf_geozarr.conversion.geozarr import (
     _create_tile_matrix_limits,
@@ -862,9 +863,15 @@ def create_original_encoding(dataset: xr.Dataset) -> dict[str, XarrayDataArrayEn
         var_data = dataset.data_vars[var_name]
         var_encoding: XarrayDataArrayEncoding = {}
         var_encoding["compressors"] = (compressor,)
-        for key in XARRAY_ENCODING_KEYS - {"compressors"}:
+        for key in XARRAY_ENCODING_KEYS - {"compressors", "fill_value"}:
             if key in var_data.encoding:
                 var_encoding[key] = var_data.encoding[key]  # type: ignore[literal-required]
+        # Set the zarr-level `fill_value` explicitly rather than letting xarray
+        # decide — different xarray versions infer different defaults from the
+        # variable's `_FillValue`. See `explicit_fill_value` for the rationale.
+        fv = utils.explicit_fill_value(var_data)
+        if fv is not utils.UNSET:
+            var_encoding["fill_value"] = fv
         if len(set(var_data.encoding.keys()) - XARRAY_ENCODING_KEYS) > 0:
             log.warning(
                 "Unknown encoding keys in %s: %s",

src/eopf_geozarr/types.py

@@ -12,6 +12,7 @@ class TileMatrixLimitJSON(TypedDict):
 
 
 class XarrayEncodingJSON(TypedDict):
+    fill_value: NotRequired[object]
     chunks: NotRequired[tuple[int, ...]]
     compressors: Any
     shards: NotRequired[Any]