xarray-spatial 0.10.7__tar.gz → 0.10.8__tar.gz

{xarray_spatial-0.10.7 → xarray_spatial-0.10.8}/CHANGELOG.md

@@ -2,6 +2,20 @@
 -----------
 
 
+### Version 0.10.8 - 2026-06-14
+
+#### Bug fixes and improvements
+- geotiff: gate dict gdal_metadata behind the experimental rich-tag opt-in (#3327)
+- name dask tasks for remaining xrspatial tool modules (#3326)
+- geotiff: don't flip masked_nodata True on a caller dtype= cast of an unmasked buffer (#3325)
+- to_geotiff: type-check compression_level (#3324)
+- rasterize: burn all_touched lines with the supercover walk (#3322)
+- focal: handle empty rasters consistently across backends (#3319)
+- reproject: promote large-output in-memory cupy inputs to dask (#3318)
+- reproject: serialize all parallel=True kernel launches behind one lock (#3317)
+- docs: add an examples-and-data getting-started page and landing index (#3316)
+
+
 ### Version 0.10.7 - 2026-06-13
 
 #### New features

{xarray_spatial-0.10.7/xarray_spatial.egg-info → xarray_spatial-0.10.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xarray-spatial
-Version: 0.10.7
+Version: 0.10.8
 Summary: xarray-based spatial analysis tools
 Home-page: https://github.com/xarray-contrib/xarray-spatial
 Author: Xarray-Spatial Developers

{xarray_spatial-0.10.7 → xarray_spatial-0.10.8/xarray_spatial.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xarray-spatial
-Version: 0.10.7
+Version: 0.10.8
 Summary: xarray-based spatial analysis tools
 Home-page: https://github.com/xarray-contrib/xarray-spatial
 Author: Xarray-Spatial Developers

{xarray_spatial-0.10.7 → xarray_spatial-0.10.8}/xarray_spatial.egg-info/SOURCES.txt

@@ -582,6 +582,7 @@ xrspatial/tests/test_rasterize_gpu_callable_warn_3057.py
 xrspatial/tests/test_rasterize_gpu_race_2167.py
 xrspatial/tests/test_rasterize_int_precision_3056.py
 xrspatial/tests/test_rasterize_linearring_3055.py
+xrspatial/tests/test_rasterize_lines_all_touched_3102.py
 xrspatial/tests/test_rasterize_merge_dedup_3304.py
 xrspatial/tests/test_rasterize_mixed_type_ordered_merge_3296.py
 xrspatial/tests/test_rasterize_nan_int_fill_2504.py
@@ -600,8 +601,10 @@ xrspatial/tests/test_rechunk_no_shuffle.py
 xrspatial/tests/test_reproject.py
 xrspatial/tests/test_reproject_coverage_2026_05_27.py
 xrspatial/tests/test_reproject_cupy_gate_2564.py
+xrspatial/tests/test_reproject_cupy_promotion_3281.py
 xrspatial/tests/test_reproject_inverse_kernels_3274.py
 xrspatial/tests/test_reproject_itrf_scale_3276.py
+xrspatial/tests/test_reproject_parallel_kernels_3141.py
 xrspatial/tests/test_reproject_pyproj_warning_3242.py
 xrspatial/tests/test_reproject_sphere_ellipsoid_guard_3275.py
 xrspatial/tests/test_reproject_streaming_3101.py

{xarray_spatial-0.10.7 → xarray_spatial-0.10.8}/xrspatial/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.10.7'
-__version_tuple__ = version_tuple = (0, 10, 7)
+__version__ = version = '0.10.8'
+__version_tuple__ = version_tuple = (0, 10, 8)
 
-__commit_id__ = commit_id = 'g9c1a81aac'
+__commit_id__ = commit_id = 'ge2c258bf7'

{xarray_spatial-0.10.7 → xarray_spatial-0.10.8}/xrspatial/classify.py

@@ -26,6 +26,7 @@ import numpy as np
 
 from xrspatial.utils import (
     ArrayTypeFunctionMapping,
+    _dask_task_name_kwargs,
     _validate_raster,
     _validate_scalar,
     cuda_args,
@@ -74,7 +75,7 @@ def _run_numpy_binary(data, values):
 
 def _run_dask_numpy_binary(data, values):
     _func = partial(_run_numpy_binary, values=values)
-    out = data.map_blocks(_func)
+    out = data.map_blocks(_func, **_dask_task_name_kwargs('xrspatial.binary'))
     return out
 
 
@@ -104,7 +105,8 @@ def _run_cupy_binary(data, values):
 
 
 def _run_dask_cupy_binary(data, values_cupy):
-    out = data.map_blocks(lambda da: _run_cupy_binary(da, values_cupy), meta=cupy.array(()))
+    out = data.map_blocks(lambda da: _run_cupy_binary(da, values_cupy), meta=cupy.array(()),
+                          **_dask_task_name_kwargs('xrspatial.binary'))
     return out
 
 
@@ -224,7 +226,7 @@ def _run_dask_numpy_bin(data, bins, new_values):
                     bins=bins,
                     new_values=new_values)
 
-    out = data.map_blocks(_func)
+    out = data.map_blocks(_func, **_dask_task_name_kwargs('xrspatial.reclassify'))
     return out
 
 
@@ -281,7 +283,8 @@ def _run_cupy_bin(data, bins, new_values):
 def _run_dask_cupy_bin(data, bins_cupy, new_values_cupy):
     out = data.map_blocks(lambda da:
                           _run_cupy_bin(da, bins_cupy, new_values_cupy),
-                          meta=cupy.array(()))
+                          meta=cupy.array(()),
+                          **_dask_task_name_kwargs('xrspatial.reclassify'))
     return out
 
 

{xarray_spatial-0.10.7 → xarray_spatial-0.10.8}/xrspatial/cost_distance.py

@@ -49,6 +49,7 @@ except ImportError:
         ndarray = False
 
 from xrspatial.utils import (
+    _dask_task_name_kwargs,
     _validate_raster,
     cuda_args, get_dataarray_resolution, ngjit,
     has_cuda_and_cupy, is_cupy_array, is_dask_cupy,
@@ -506,6 +507,7 @@ def _cost_distance_dask_cupy(source_da, friction_da,
             boundary=np.nan,
             dtype=np.float32,
             meta=cp.array((), dtype=cp.float32),
+            **_dask_task_name_kwargs('xrspatial.cost_distance'),
         )
 
     # Unbounded or padding too large: convert to dask+numpy, use CPU path
@@ -1187,6 +1189,7 @@ def _cost_distance_dask(source_da, friction_da, cellsize_x, cellsize_y,
         boundary=np.nan,
         dtype=np.float32,
         meta=np.array((), dtype=np.float32),
+        **_dask_task_name_kwargs('xrspatial.cost_distance'),
     )
     return out
 

{xarray_spatial-0.10.7 → xarray_spatial-0.10.8}/xrspatial/dasymetric.py

@@ -52,6 +52,7 @@ except ImportError:
 
 from xrspatial.utils import (
     ArrayTypeFunctionMapping,
+    _dask_task_name_kwargs,
     has_cuda_and_cupy,
     has_dask_array,
     is_cupy_array,
@@ -293,6 +294,7 @@ def _disaggregate_dask_numpy(zones_da, weight_da, values_dict, method,
         method=method,
         nodata_zone=nodata_zone,
         dtype=np.float64,
+        **_dask_task_name_kwargs('xrspatial.disaggregate'),
     )
     return result
 

{xarray_spatial-0.10.7 → xarray_spatial-0.10.8}/xrspatial/diffusion.py

@@ -33,6 +33,7 @@ except ImportError:
 from xrspatial.utils import (
     ArrayTypeFunctionMapping,
     _boundary_to_dask,
+    _dask_task_name_kwargs,
     _pad_array,
     _validate_boundary,
     _validate_raster,
@@ -267,6 +268,7 @@ def _diffuse_dask_numpy(data, alpha, steps, dt_over_dx2, boundary):
                 depth=(1, 1),
                 boundary=_boundary_to_dask(boundary),
                 meta=np.array(()),
+                **_dask_task_name_kwargs('xrspatial.diffuse'),
             )
         else:
             # Pass alpha as a second dask argument to map_overlap
@@ -278,6 +280,7 @@ def _diffuse_dask_numpy(data, alpha, steps, dt_over_dx2, boundary):
                 meta=np.array(()),
                 steps=1,
                 dt_over_dx2=dt_over_dx2,
+                **_dask_task_name_kwargs('xrspatial.diffuse'),
             )
     return u
 
@@ -318,6 +321,7 @@ def _diffuse_dask_cupy(data, alpha, steps, dt_over_dx2, boundary):
                 depth=(1, 1),
                 boundary=_boundary_to_dask(boundary, is_cupy=True),
                 meta=cp.array(()),
+                **_dask_task_name_kwargs('xrspatial.diffuse'),
             )
         else:
             u = da.map_overlap(
@@ -327,6 +331,7 @@ def _diffuse_dask_cupy(data, alpha, steps, dt_over_dx2, boundary):
                 boundary=_boundary_to_dask(boundary, is_cupy=True),
                 meta=cp.array(()),
                 dt_over_dx2=dt_over_dx2,
+                **_dask_task_name_kwargs('xrspatial.diffuse'),
             )
     return u
 

{xarray_spatial-0.10.7 → xarray_spatial-0.10.8}/xrspatial/emerging_hotspots.py

@@ -30,6 +30,7 @@ from xrspatial.focal import (
 )
 from xrspatial.utils import (
     ArrayTypeFunctionMapping,
+    _dask_task_name_kwargs,
     _validate_boundary,
     ngjit,
     not_implemented_func,
@@ -608,6 +609,7 @@ def _emerging_hotspots_dask_numpy(raster, kernel, boundary='nan'):
         gi_zscore,
         dtype=np.int8,
         meta=np.array((), dtype=np.int8),
+        **_dask_task_name_kwargs('xrspatial.emerging_hotspots.gi_bin'),
     )
 
     # Pass 3: Mann-Kendall + classification via map_blocks
@@ -620,6 +622,7 @@ def _emerging_hotspots_dask_numpy(raster, kernel, boundary='nan'):
         drop_axis=0,
         new_axis=0,
         meta=np.array((), dtype=np.float32),
+        **_dask_task_name_kwargs('xrspatial.emerging_hotspots.mk_classify'),
     )
 
     return gi_zscore, gi_bin, mk_result
@@ -690,6 +693,7 @@ def _emerging_hotspots_dask_cupy(raster, kernel, boundary='nan'):
         gi_zscore,
         dtype=np.int8,
         meta=cupy.array((), dtype=cupy.int8),
+        **_dask_task_name_kwargs('xrspatial.emerging_hotspots.gi_bin'),
     )
 
     # Pass 3: Mann-Kendall + classification via map_blocks
@@ -701,6 +705,7 @@ def _emerging_hotspots_dask_cupy(raster, kernel, boundary='nan'):
         drop_axis=0,
         new_axis=0,
         meta=cupy.array((), dtype=cupy.float32),
+        **_dask_task_name_kwargs('xrspatial.emerging_hotspots.mk_classify'),
     )
 
     return gi_zscore, gi_bin, mk_result

{xarray_spatial-0.10.7 → xarray_spatial-0.10.8}/xrspatial/fire.py

@@ -26,6 +26,7 @@ from numba import cuda
 from xrspatial.dataset_support import supports_dataset
 from xrspatial.utils import (
     ArrayTypeFunctionMapping,
+    _dask_task_name_kwargs,
     _validate_raster,
     _validate_scalar,
     cuda_args,
@@ -165,7 +166,8 @@ def _dnbr_gpu(pre_data, post_data, out):
 
 
 def _dnbr_dask(pre_data, post_data):
-    return da.map_blocks(_dnbr_cpu, pre_data, post_data, meta=np.array(()))
+    return da.map_blocks(_dnbr_cpu, pre_data, post_data, meta=np.array(()),
+                         **_dask_task_name_kwargs('xrspatial.dnbr'))
 
 
 def _dnbr_cupy(pre_data, post_data):
@@ -178,7 +180,8 @@ def _dnbr_cupy(pre_data, post_data):
 
 def _dnbr_dask_cupy(pre_data, post_data):
     return da.map_blocks(_dnbr_cupy, pre_data, post_data,
-                         dtype=cupy.float32, meta=cupy.array(()))
+                         dtype=cupy.float32, meta=cupy.array(()),
+                         **_dask_task_name_kwargs('xrspatial.dnbr'))
 
 
 def dnbr(pre_nbr_agg: xr.DataArray,
@@ -256,7 +259,8 @@ def _rdnbr_gpu(dnbr_data, pre_data, out):
 
 
 def _rdnbr_dask(dnbr_data, pre_data):
-    return da.map_blocks(_rdnbr_cpu, dnbr_data, pre_data, meta=np.array(()))
+    return da.map_blocks(_rdnbr_cpu, dnbr_data, pre_data, meta=np.array(()),
+                         **_dask_task_name_kwargs('xrspatial.rdnbr'))
 
 
 def _rdnbr_cupy(dnbr_data, pre_data):
@@ -269,7 +273,8 @@ def _rdnbr_cupy(dnbr_data, pre_data):
 
 def _rdnbr_dask_cupy(dnbr_data, pre_data):
     return da.map_blocks(_rdnbr_cupy, dnbr_data, pre_data,
-                         dtype=cupy.float32, meta=cupy.array(()))
+                         dtype=cupy.float32, meta=cupy.array(()),
+                         **_dask_task_name_kwargs('xrspatial.rdnbr'))
 
 
 def rdnbr(dnbr_agg: xr.DataArray,
@@ -382,7 +387,8 @@ def _bsc_gpu(data, out):
 
 
 def _bsc_dask(data):
-    return da.map_blocks(_bsc_cpu, data, dtype=np.int8, meta=np.array(()))
+    return da.map_blocks(_bsc_cpu, data, dtype=np.int8, meta=np.array(()),
+                         **_dask_task_name_kwargs('xrspatial.burn_severity_class'))
 
 
 def _bsc_cupy(data):
@@ -394,7 +400,8 @@ def _bsc_cupy(data):
 
 def _bsc_dask_cupy(data):
     return da.map_blocks(_bsc_cupy, data,
-                         dtype=np.int8, meta=cupy.array(()))
+                         dtype=np.int8, meta=cupy.array(()),
+                         **_dask_task_name_kwargs('xrspatial.burn_severity_class'))
 
 
 @supports_dataset
@@ -464,7 +471,8 @@ def _fli_gpu(fuel_data, spread_data, heat_content, out):
 
 def _fli_dask(fuel_data, spread_data, heat_content):
     return da.map_blocks(_fli_cpu, fuel_data, spread_data, heat_content,
-                         meta=np.array(()))
+                         meta=np.array(()),
+                         **_dask_task_name_kwargs('xrspatial.fireline_intensity'))
 
 
 def _fli_cupy(fuel_data, spread_data, heat_content):
@@ -477,7 +485,8 @@ def _fli_cupy(fuel_data, spread_data, heat_content):
 
 def _fli_dask_cupy(fuel_data, spread_data, heat_content):
     return da.map_blocks(_fli_cupy, fuel_data, spread_data, heat_content,
-                         dtype=cupy.float32, meta=cupy.array(()))
+                         dtype=cupy.float32, meta=cupy.array(()),
+                         **_dask_task_name_kwargs('xrspatial.fireline_intensity'))
 
 
 def fireline_intensity(fuel_consumed_agg: xr.DataArray,
@@ -562,7 +571,8 @@ def _fl_gpu(intensity_data, out):
 
 
 def _fl_dask(intensity_data):
-    return da.map_blocks(_fl_cpu, intensity_data, meta=np.array(()))
+    return da.map_blocks(_fl_cpu, intensity_data, meta=np.array(()),
+                         **_dask_task_name_kwargs('xrspatial.flame_length'))
 
 
 def _fl_cupy(intensity_data):
@@ -575,7 +585,8 @@ def _fl_cupy(intensity_data):
 
 def _fl_dask_cupy(intensity_data):
     return da.map_blocks(_fl_cupy, intensity_data,
-                         dtype=cupy.float32, meta=cupy.array(()))
+                         dtype=cupy.float32, meta=cupy.array(()),
+                         **_dask_task_name_kwargs('xrspatial.flame_length'))
 
 
 @supports_dataset
@@ -733,6 +744,7 @@ def _ros_dask(slope_data, wind_data, moisture_data,
         w_0, h, M_x, beta, rho_b, Gamma, eta_s, xi, epsilon,
         C_w, B_w, E_w,
         meta=np.array(()),
+        **_dask_task_name_kwargs('xrspatial.rate_of_spread'),
     )
 
 
@@ -758,6 +770,7 @@ def _ros_dask_cupy(slope_data, wind_data, moisture_data,
         w_0, h, M_x, beta, rho_b, Gamma, eta_s, xi, epsilon,
         C_w, B_w, E_w,
         dtype=cupy.float32, meta=cupy.array(()),
+        **_dask_task_name_kwargs('xrspatial.rate_of_spread'),
     )
 
 
@@ -907,6 +920,7 @@ def _kbdi_dask(kbdi_prev_data, max_temp_data, precip_data, annual_precip):
     return da.map_blocks(
         _kbdi_cpu, kbdi_prev_data, max_temp_data, precip_data, annual_precip,
         meta=np.array(()),
+        **_dask_task_name_kwargs('xrspatial.kbdi'),
     )
 
 
@@ -926,6 +940,7 @@ def _kbdi_dask_cupy(kbdi_prev_data, max_temp_data, precip_data,
         _kbdi_cupy, kbdi_prev_data, max_temp_data, precip_data,
         annual_precip,
         dtype=cupy.float32, meta=cupy.array(()),
+        **_dask_task_name_kwargs('xrspatial.kbdi'),
     )
 
 

{xarray_spatial-0.10.7 → xarray_spatial-0.10.8}/xrspatial/flood.py

@@ -29,6 +29,7 @@ except ImportError:
     da = None
 
 from xrspatial.utils import (
+    _dask_task_name_kwargs,
     _validate_raster,
     has_cuda_and_cupy,
     is_cupy_array,
@@ -627,6 +628,7 @@ def _veg_roughness_nlcd_dask(data, lut):
     return _da.map_blocks(
         _apply_lut, data, dtype=np.float64,
         meta=np.array((), dtype=np.float64),
+        **_dask_task_name_kwargs('xrspatial.vegetation_roughness_nlcd'),
     )
 
 
@@ -669,6 +671,7 @@ def _veg_roughness_ndvi_dask(data):
     return _da.map_blocks(
         _apply, data, dtype=np.float64,
         meta=np.array((), dtype=np.float64),
+        **_dask_task_name_kwargs('xrspatial.vegetation_roughness_ndvi'),
     )
 
 
@@ -795,6 +798,7 @@ def _veg_cn_dask(lc, sg, lut):
     return _da.map_blocks(
         _apply, lc, sg, dtype=np.float64,
         meta=np.array((), dtype=np.float64),
+        **_dask_task_name_kwargs('xrspatial.vegetation_curve_number'),
     )
 
 

{xarray_spatial-0.10.7 → xarray_spatial-0.10.8}/xrspatial/focal.py

@@ -28,9 +28,22 @@ except ImportError:
 from xrspatial.convolution import (_available_memory_bytes, _promote_float, convolve_2d,
                                    custom_kernel)
 from xrspatial.dataset_support import supports_dataset
-from xrspatial.utils import (ArrayTypeFunctionMapping, _boundary_to_dask, _pad_array,
-                             _validate_boundary, _validate_raster, _validate_scalar, cuda_args,
-                             is_cupy_array, is_dask_cupy, ngjit)
+from xrspatial.utils import (ArrayTypeFunctionMapping, _boundary_to_dask, _dask_task_name_kwargs,
+                             _pad_array, _validate_boundary, _validate_raster, _validate_scalar,
+                             cuda_args, is_cupy_array, is_dask_cupy, ngjit)
+
+
+def _is_empty_raster(agg):
+    """True if *agg* has a degenerate spatial axis (0 rows or 0 cols).
+
+    An empty raster has no cells to filter, but the GPU and dask paths
+    crash on it rather than no-op: ``cuda_args`` hands ``cuLaunchKernel``
+    a zero-sized grid, and ``map_overlap`` rejects a depth that exceeds
+    the (zero-length) axis. The numpy path already returns an empty
+    result with the input shape preserved, so the focal APIs short
+    circuit empty input to match it on every backend (issue #3225).
+    """
+    return agg.shape[-2] == 0 or agg.shape[-1] == 0
 
 
 def _validate_binary_kernel(kernel, func_name):
@@ -210,7 +223,8 @@ def _mean_dask_numpy(data, excludes, boundary='nan'):
     out = data.map_overlap(_func,
                            depth=(1, 1),
                            boundary=_boundary_to_dask(boundary),
-                           meta=np.array((), dtype=data.dtype))
+                           meta=np.array((), dtype=data.dtype),
+                           **_dask_task_name_kwargs('xrspatial.mean'))
     return out
 
 
@@ -220,7 +234,8 @@ def _mean_dask_cupy(data, excludes, boundary='nan'):
     out = data.map_overlap(_func,
                            depth=(1, 1),
                            boundary=_boundary_to_dask(boundary, is_cupy=True),
-                           meta=cupy.array((), dtype=data.dtype))
+                           meta=cupy.array((), dtype=data.dtype),
+                           **_dask_task_name_kwargs('xrspatial.mean'))
     return out
 
 
@@ -441,6 +456,16 @@ def mean(agg, passes=1, excludes=None, name='mean', boundary='nan'):
         return _apply_per_band(mean, agg, passes=passes, excludes=excludes,
                                name=name, boundary=boundary)
 
+    if _is_empty_raster(agg):
+        # No cells to filter; return an empty result of the input shape
+        # and dtype contract, matching the numpy path on every backend
+        # (issue #3225).
+        return DataArray(agg.data.astype(_promote_float(agg.dtype)),
+                         name=name,
+                         dims=agg.dims,
+                         coords=agg.coords,
+                         attrs=agg.attrs)
+
     # Preserve the input float dtype, promoting ints to float32 -- the same
     # contract as apply() / focal_stats() (#2769) and convolve_2d() (#1096).
     # Cast excludes to the working dtype so value matching behaves the same
@@ -565,7 +590,8 @@ def _apply_dask_numpy(data, kernel, func, boundary='nan'):
     out = data.map_overlap(_func,
                            depth=(pad_h, pad_w),
                            boundary=_boundary_to_dask(boundary),
-                           meta=np.array((), dtype=data.dtype))
+                           meta=np.array((), dtype=data.dtype),
+                           **_dask_task_name_kwargs('xrspatial.apply'))
     return out
 
 
@@ -595,7 +621,8 @@ def _apply_dask_cupy(data, kernel, func, boundary='nan'):
     out = data.map_overlap(_func,
                            depth=(pad_h, pad_w),
                            boundary=_boundary_to_dask(boundary, is_cupy=True),
-                           meta=cupy.array((), dtype=data.dtype))
+                           meta=cupy.array((), dtype=data.dtype),
+                           **_dask_task_name_kwargs('xrspatial.apply'))
     return out
 
 
@@ -759,6 +786,15 @@ def apply(agg=None, kernel=None, func=None, name='focal_apply',
                                    chunks=getattr(agg.data, 'chunks', None),
                                    itemsize=itemsize)
 
+    if _is_empty_raster(agg):
+        # No cells to filter; return an empty result of the input shape,
+        # matching the numpy path on every backend (issue #3225).
+        return DataArray(agg.data.astype(_promote_float(agg.dtype)),
+                         name=name,
+                         coords=agg.coords,
+                         dims=agg.dims,
+                         attrs=agg.attrs)
+
     # apply kernel to raster values
     # if agg is a numpy or dask with numpy backed data array,
     # the function func must be a @ngjit
@@ -1246,7 +1282,8 @@ def _focal_stats_dask_cupy(agg, kernel, stats_funcs, boundary='nan'):
         data = agg.data.astype(_promote_float(agg.data.dtype))
         stats_data = data.map_overlap(
             _func, depth=(pad_h, pad_w),
-            boundary=dask_bnd, meta=cupy.array((), dtype=data.dtype))
+            boundary=dask_bnd, meta=cupy.array((), dtype=data.dtype),
+            **_dask_task_name_kwargs('xrspatial.focal_stats'))
         stats_agg = xr.DataArray(
             stats_data, dims=agg.dims, coords=agg.coords, attrs=agg.attrs)
         stats_aggs.append(stats_agg)
@@ -1402,6 +1439,16 @@ def focal_stats(agg,
                                    chunks=getattr(agg.data, 'chunks', None),
                                    itemsize=itemsize)
 
+    if _is_empty_raster(agg):
+        # No cells to filter; build the empty stacked result the same way
+        # the real paths do, reusing apply()'s empty short circuit so the
+        # output matches the numpy path on every backend (issue #3225).
+        stats_aggs = [apply(agg, kernel, boundary=boundary) for _ in stats_funcs]
+        result = xr.concat(stats_aggs,
+                           pd.Index(stats_funcs, name='stats', dtype=object))
+        result.name = name
+        return result
+
     mapper = ArrayTypeFunctionMapping(
         numpy_func=partial(_focal_stats_cpu, boundary=boundary),
         cupy_func=partial(_focal_stats_cupy_boundary, boundary=boundary),
@@ -1587,9 +1634,11 @@ def _hotspots_dask_numpy(raster, kernel, boundary='nan'):
     # all-NaN / single-valid-cell rasters raise at compute time instead of
     # classifying to a silent all-zeros raster (issue #2843).
     z_array = da.map_blocks(_gistar_validate_lazy, z_array, global_std, n,
-                            dtype=z_array.dtype, meta=z_array._meta)
+                            dtype=z_array.dtype, meta=z_array._meta,
+                            **_dask_task_name_kwargs('xrspatial.hotspots.validate'))
     out = z_array.map_blocks(_calc_hotspots_numpy,
-                             meta=np.array((), dtype=np.int8))
+                             meta=np.array((), dtype=np.int8),
+                             **_dask_task_name_kwargs('xrspatial.hotspots'))
     return out
 
 
@@ -1627,9 +1676,11 @@ def _hotspots_dask_cupy(raster, kernel, boundary='nan'):
     # all-NaN / single-valid-cell rasters raise at compute time instead of
     # classifying to a silent all-zeros raster (issue #2843).
     z_array = da.map_blocks(_gistar_validate_lazy, z_array, global_std, n,
-                            dtype=z_array.dtype, meta=z_array._meta)
+                            dtype=z_array.dtype, meta=z_array._meta,
+                            **_dask_task_name_kwargs('xrspatial.hotspots.validate'))
     out = z_array.map_blocks(_calc_hotspots_cupy,
-                             meta=cupy.array((), dtype=cupy.int8))
+                             meta=cupy.array((), dtype=cupy.int8),
+                             **_dask_task_name_kwargs('xrspatial.hotspots'))
     return out
 
 
@@ -1805,6 +1856,15 @@ def hotspots(agg=None, kernel=None, name='hotspots', boundary='nan', *,
     _check_kernel_vs_raster_memory(kernel, rows, cols, func_name='hotspots',
                                    chunks=getattr(agg.data, 'chunks', None))
 
+    if _is_empty_raster(agg):
+        # An empty raster has no valid cells, so Gi* is undefined. Raise the
+        # same clear error the numpy path already raises, before the cupy and
+        # dask backends crash on a zero-sized reduction or overlap (#3225).
+        raise ValueError(
+            "hotspots() needs at least 2 valid (non-NaN) cells to "
+            "compute the Getis-Ord Gi* statistic."
+        )
+
     mapper = ArrayTypeFunctionMapping(
         numpy_func=partial(_hotspots_numpy, boundary=boundary),
         cupy_func=partial(_hotspots_cupy, boundary=boundary),

{xarray_spatial-0.10.7 → xarray_spatial-0.10.8}/xrspatial/geotiff/_attrs.py

@@ -531,6 +531,11 @@ def _validate_write_rich_tag_optin(
     triggered: list[str] = []
     if attrs.get('gdal_metadata_xml') is not None:
         triggered.append("attrs['gdal_metadata_xml']")
+    # ``_extract_rich_tags`` only builds GDAL XML from ``gdal_metadata``
+    # when it is a dict (and ``gdal_metadata_xml`` is absent); a non-dict
+    # value is ignored by the writer, so it does not need gating.
+    if isinstance(attrs.get('gdal_metadata'), dict):
+        triggered.append("attrs['gdal_metadata']")
     if attrs.get('extra_tags') is not None:
         triggered.append("attrs['extra_tags']")
     if gdal_metadata_xml_kwarg is not None:
@@ -2211,6 +2216,11 @@ def _finalize_eager_read(
     # ``_validation``; local import keeps ``_attrs`` free of a top-level
     # validation dependency for parity with ``_validate_read_geo_info``.
     dtype_cast_attr: str | None = None
+    # Capture float-ness BEFORE the caller's ``dtype=`` cast so ``masked``
+    # below reflects masking-promotion, not the cast (issue #3323). A
+    # caller casting an unmasked int buffer to float must not flip
+    # ``masked_nodata`` to True.
+    pre_cast_is_float = np.dtype(str(arr.dtype)).kind == 'f'
     if dtype is not None:
         from ._validation import _validate_dtype_cast
         target = np.dtype(dtype)
@@ -2219,16 +2229,18 @@ def _finalize_eager_read(
         dtype_cast_attr = target.name
 
     # Stamp the nodata lifecycle attrs. ``masked`` is True iff
-    # the caller opted into masking AND the final buffer dtype is float.
+    # the caller opted into masking AND the pre-cast buffer dtype is float.
     # ``_apply_eager_nodata_mask`` promotes a maskable integer source to
     # float64 whenever masking is on (issue #2990), so an ``int`` buffer +
     # ``mask_nodata=True`` here means the sentinel was unmaskable
     # (out-of-range / non-finite / fractional) and could never match, not
     # that masking was disabled. Either way ``masked`` is correctly False
-    # because the literal sentinel still occupies its integer slot.
+    # because the literal sentinel still occupies its integer slot. Using
+    # the pre-cast dtype keeps a caller ``dtype=<float>`` cast from
+    # flipping ``masked`` True on that unmasked int buffer (issue #3323).
     _set_nodata_attrs(
         attrs, nodata,
-        masked=(effective_mask and np.dtype(str(arr.dtype)).kind == 'f'),
+        masked=(effective_mask and pre_cast_is_float),
         pixels_present=nodata_pixels_present,
         dtype_cast=dtype_cast_attr,
     )

{xarray_spatial-0.10.7 → xarray_spatial-0.10.8}/xrspatial/geotiff/_backends/dask.py

@@ -521,10 +521,15 @@ def _read_geotiff_dask(source: str, *,
     # Share the validate-then-populate-then-stamp
     # block with the dask+GPU backend via ``_finalize_lazy_read_attrs``.
     #
-    # ``graph_dtype`` is the resolved dask graph dtype so
-    # ``masked_nodata`` reflects whether the per-chunk mask actually
-    # ran (masking on an int source auto-promotes to float64; an
-    # un-promoted int graph means masking didn't run).
+    # ``graph_dtype`` is ``effective_dtype`` -- the pre-cast graph dtype
+    # after the masking-induced int->float64 auto-promotion but BEFORE
+    # the caller's ``dtype=`` cast -- so ``masked_nodata`` reflects
+    # whether the per-chunk mask actually ran (masking on a maskable int
+    # source auto-promotes to float64; an un-promoted int graph means the
+    # sentinel was unmaskable and masking didn't run). Passing the
+    # post-cast ``target_dtype`` would let a caller ``dtype=<float>`` cast
+    # flip ``masked_nodata`` True on an unmasked int graph (issue #3323);
+    # the VRT path already threads its pre-cast dtype for the same reason.
     # ``caller_dtype`` is the caller's ``dtype=`` kwarg verbatim so
     # ``nodata_dtype_cast`` records caller intent rather than the
     # masking-induced auto-promotion.
@@ -538,7 +543,7 @@ def _read_geotiff_dask(source: str, *,
         geo_info=geo_info,
         nodata=nodata_attr,
         mask_nodata=(mask_nodata or mask_and_scale),
-        graph_dtype=target_dtype,
+        graph_dtype=effective_dtype,
         caller_dtype=dtype,
         window=window,
         allow_rotated=allow_rotated,