Merge pull request #29 from CMCC-Foundation/version-2025.06

Update Geokube to version 2025.06

Author: gtramonte

.dockerignore

@@ -1 +1,3 @@
-*.nc
+*.nc
+*.zarr
+data

.github/workflows/build-push-docker_release.yml

@@ -1,9 +1,8 @@
 name: Build on release a geokube Docker image and push to the geokube container registry
 
 on:
-  push:
-    tags:        
-      - 'v*'
+  release:
+    types: [published]
   workflow_dispatch:
 jobs:
   build:

.gitignore

@@ -120,4 +120,5 @@ Dockerfile.dev
 nuts_shape
 *.png
 *.zarr
-.DS_Store
+.DS_Store
+data

Dockerfile

@@ -1,6 +1,4 @@
-#FROM rg.fr-par.scw.cloud/geokube/geokube-base:2024.05.03.08.14
-#new version with Zarr support
-FROM rg.fr-par.scw.cloud/geokube/geokube-base:2025.01.09.14.31
+FROM rg.fr-par.scw.cloud/geokube/geokube-base:2025.06.12.14.52
 
 ADD . /opt/geokube
 RUN pip install /opt/geokube --break-system-packages

Dockerfile.base

@@ -19,7 +19,7 @@ RUN make -j4
 
 ENV ESMFMKFILE=/opt/esmf/lib/libO/Linux.gfortran.64.mpiuni.default/esmf.mk
 
-RUN pip install numpy setuptools==75.8.0 --break-system-packages
+RUN pip install numpy setuptools==80.9.0 --break-system-packages
 
 WORKDIR /opt/esmf/src/addon/esmpy
 RUN pip install . --break-system-packages

geokube/core/datacube.py

@@ -517,12 +517,21 @@ def to_xarray(self, encoding=True):
     def to_netcdf(self, path, encoding: bool = True):
         self.to_xarray(encoding=encoding).to_netcdf(path=path)
 
-    def to_zarr(self, path, encoding: bool = True, **kwargs):
+    @geokube_logging
+    def _find_best_chunking(self, ds: xr.Dataset):
+        chunks = {name: 1000 if name.lower() in ['time', 'xtime'] else 100 for name in ds.dims}
+        self._LOG.info(f"Best chunking: {chunks}")
+        return chunks
+
+    @geokube_logging
+    def to_zarr(self, path, encoding: bool = True, chunks: dict = None, **kwargs):
         kube = self.to_xarray(encoding=encoding)
         for var in kube:
             if 'chunks' in kube[var].encoding.keys():
                 del kube[var].encoding['chunks']
-        kube.unify_chunks().chunk('auto').to_zarr(path,**kwargs)
+        if chunks is None:
+            chunks = self._find_best_chunking(kube)
+        kube.chunk(chunks).to_zarr(path,**kwargs)
 
     @geokube_logging
     def to_csv(self, path, encoding: bool = True):

geokube/core/domain.py

@@ -279,7 +279,7 @@ def compute_bounds(
         val = coord.values
         val_b = np.empty(shape=val.size + 1, dtype=np.float64)
         val_b[1:-1] = 0.5 * (val[:-1] + val[1:])
-        half_step = 0.5 * (val.ptp() / (val.size - 1))
+        half_step = 0.5 * (np.ptp(val) / (val.size - 1))
         # The case `val[0] > val[-1]` represents reversed order of values:
         i, j = (0, -1) if val[0] <= val[-1] else (-1, 0)
         val_b[i] = val[i] - half_step

geokube/core/field.py

@@ -827,8 +827,9 @@ def _check_and_roll_longitude(self, ds, indexers) -> xr.Dataset:
     def to_regular(self):
         # Infering latitude and longitude steps from the x and y coordinates.
         if isinstance(self.domain.crs, RotatedGeogCS):
-            lat_step = np.ptp(self.y.values) / (self.y.values.size - 1)
-            lon_step = np.ptp(self.x.values) / (self.x.values.size - 1)
+            lat_step = round(np.ptp(self.y.values) / (self.y.values.size - 1), 2)
+            lat_step = round(np.ptp(self.y.values) / (self.y.values.size - 1), 2)
+            lon_step = round(np.ptp(self.x.values) / (self.x.values.size - 1), 2)
         else:
             raise NotImplementedError(
                 f"'{type(self.domain.crs).__name__}' is not supported as a "
@@ -982,10 +983,16 @@ def regrid(
             coords_out = {"lat_b": lat_b, "lon_b": lon_b}
 
         # Regridding
-        in_ = self.to_xarray(encoding=False).rename(names_in)
+        try:
+            in_ = self.to_xarray(encoding=False).rename(names_in)
+        except:
+            in_ = self.to_xarray(encoding=False)
         if coords_in:
             in_ = in_.assign_coords(coords=coords_in)
-        out = target.to_xarray(encoding=False).to_dataset().rename(names_out)
+        try:
+            out = target.to_xarray(encoding=False).to_dataset().rename(names_out)
+        except:
+            out = target.to_xarray(encoding=False).to_dataset()
         if coords_out:
             out = out.assign_coords(coords=coords_out)
         regrid_kwa = {
@@ -1000,7 +1007,10 @@ def regrid(
         except PermissionError:
             regridder = xe.Regridder(**regrid_kwa)
         result = regridder(in_, keep_attrs=True, skipna=False)
-        result = result.rename({v: k for k, v in names_in.items()})
+        try:
+            result = result.rename({v: k for k, v in names_in.items()})
+        except:
+            pass
         result[self.name].encoding = in_[self.name].encoding
         if not isinstance(target.crs, GeogCS):
             missing_coords = {
@@ -1062,37 +1072,22 @@ def resample(
         """
         ds = self.to_xarray(encoding=False)
         encodings = ds.encoding
-        if frequency == '1D':
-            match operator:
-                case "max":
-                    ds = ds.coarsen(time=24).max()
-                case "min":
-                    ds = ds.coarsen(time=24).min()
-                case "sum":
-                    ds = ds.coarsen(time=24).sum()
-                case "mean":
-                    ds = ds.coarsen(time=24).mean()
-                case "median":
-                    ds = ds.coarsen(time=24).median()
-                case _:
-                    raise NotImplementedError(f"Operator {operator} not implemented.")
-        else:
-            ds = ds.resample(time=frequency)
-            match operator:
-                case "max":
-                    ds = ds.max(dim="time")
-                case "min":
-                    ds = ds.min(dim="time")
-                case "sum":
-                    ds = ds.sum(dim="time")
-                case "mean":
-                    ds = ds.mean(dim="time")
-                case "median":
-                    ds = ds.median(dim="time")
-                case _:
-                    raise NotImplementedError(f"Operator {operator} not implemented.")
+        ds = ds.resample(time=frequency)
+        match operator:
+            case "max":
+                ds = ds.max(dim="time")
+            case "min":
+                ds = ds.min(dim="time")
+            case "sum":
+                ds = ds.sum(dim="time")
+            case "mean":
+                ds = ds.mean(dim="time")
+            case "median":
+                ds = ds.median(dim="time")
+            case _:
+                raise NotImplementedError(f"Operator {operator} not implemented.")
         ds.encoding = encodings
-        field = Field.from_xarray(ds, ncvar=self.name)
+        field = Field.from_xarray(ds, ncvar=self.name, id_pattern=self._id_pattern, mapping=self._mapping, copy=False)
         field.domain.crs = self.domain.crs
         field.domain._type = self.domain._type
         field.domain._calculate_missing_lat_and_lon()

geokube/version.py

@@ -1 +1 @@
-__version__ = "0.2.7.10"
+__version__ = "2025.06"

requirements.txt

@@ -2,10 +2,11 @@ cf_units==3.3.0
 cartopy
 numpy==2.0.2
 pandas==2.2.3
-netCDF4
+netCDF4==1.7.2
+h5py==3.14.0
 scipy
-xarray==2025.1.2
-dask==2024.12.1
+xarray==2025.6.1
+dask==2025.5.1
 geopandas
 #esmpy==8.2.0
 #xesmf==0.7.1
@@ -16,4 +17,8 @@ dask[distributed]
 zarr==2.18.4
 rioxarray
 plotly
-pyarrow
+pyarrow
+numcodecs==0.15.1
+flox
+cf-xarray==0.10.5
+h5netcdf==1.6.1