geotiff: cover symbology sidecars on dask, dask+GPU, 3D single-band, color_ramp_range (#3545)

.claude/sweep-test-coverage-state.csv

@@ -9,7 +9,7 @@ diffusion,2026-06-20,3422,HIGH,1;2;3;4,"Pass 1 (2026-06-20, deep-sweep test-cove
 fire,2026-06-25,,HIGH,2,"Deep-sweep 2026-06-25 test-coverage on a CUDA host. Backend matrix already complete: all 7 public funcs (dnbr/rdnbr/burn_severity_class/fireline_intensity/flame_length/rate_of_spread/kbdi) x 4 backends present and green (Cat 1 no gap). NaN covered (per-func nan_propagation + #3394 dtype parity). Cat 4 covered: rate_of_spread tests all 13 fuel models + invalid 0/14; kbdi annual_precip invalid 0/-100; fireline heat_content default+custom. Cat 5 covered via general_output_checks on every func. Found one gap: Cat 2 +Inf/-Inf inputs were untested on every function. Probed all 4 backends live: behavior is fully consistent and well-defined (no divergence, no bug) -- e.g. dnbr inf-inf->nan, burn_severity_class +inf->7/-inf->1, kbdi prev=inf clamps to 800, rate_of_spread slope=inf->nan. Added test-only regression: per-func numpy Inf contract (locks exact values) + 4-backend Inf parity (28 new tests, all RAN and PASSED on GPU). No source change; the kernels' only finite guard is v!=v so these lock that contract. Cat 3 1x1/strip: per-pixel kernels (no neighborhood window) so no degeneracy risk, and 1x1/1xN already exercised by kbdi/rdnbr/flame tests -> LOW, not added."
 flood,2026-06-25,,MEDIUM,1,"Deep-sweep 2026-06-25 test-coverage on a CUDA host. Module is densely tested (1051 test LOC vs 966 source). Backend matrix nearly complete: all 7 public funcs x 4 backends present and green EXCEPT vegetation_roughness mode='ndvi' on dask+cupy -- _veg_roughness_ndvi_dask_cupy was dispatched (flood.py:585) but never invoked by any test (nlcd dask+cupy, ndvi cupy, ndvi dask all tested). Cat 1 MEDIUM: added TestVegRoughnessDaskCuPy::test_ndvi_numpy_equals_dask_cupy mirroring the nlcd case; GPU-validated locally (passed, full file 89 passed). Cat 2 NaN well covered per-func incl #1104 (NaN curve_number) and #1437 (mannings_n DataArray) regressions; Inf inputs untested but low-risk (HAND/rainfall Inf -> NaN), not flagged. Cat 3 1xN strips + 1x1 covered for several funcs. Cat 5 metadata preserved is asserted on every backend test via general_output_checks (verify_attrs defaults True), so inundation/curve_number_runoff lacking a dedicated coords test is NOT a real gap. No source bugs found."
 focal,2026-06-10,3220;3219;3225,HIGH,1;2;3;4,"Deep-sweep 2026-06-10 on CUDA host, all 4 backends executed. Filed #3220 (coverage) and added 36 tests in PR branch: Inf inputs for mean/focal_stats (HIGH Cat2 - no Inf test existed anywhere), mean NaN input (HIGH Cat2 - default excludes=[nan] semantics never asserted), 1x1 + 1xN/Nx1 strips (HIGH Cat3), empty 0-row raster numpy-only (MEDIUM Cat3), mean passes=2 == mean(mean) and excludes sentinel -9999 behavioral tests (MEDIUM Cat4), dask+cupy non-default boundary modes for mean/apply/focal_stats (MEDIUM Cat1/4). Bugs surfaced, filed separately (NOT fixed here): #3219 hotspots silently returns all zeros on Inf input (nan global std passes the std==0 guard, all 4 backends); #3225 empty raster works on numpy but crashes cupy (raw CudaAPIError) and dask (map_overlap depth ValueError). hotspots+Inf and non-numpy empty behavior left unpinned until those are fixed. Backend matrix for the 4 public funcs was already solid (all 4 backends + parity); boundary modes covered except dask+cupy. Siblings filed #3214-3217 same day (dtype/docstring/apply-default-func) - no overlap."
-geotiff,2026-06-25,3518,MEDIUM,1,"Pass 23 (2026-06-25, deep-sweep test-coverage, CUDA host): delta audit of the ~15 geotiff commits since pass 22 (06-12..06-24): #3483 categorical PAM sidecar, #3375/#3376/#3380 xarray backend engine, #3373/#3374 chunked GPU read-once, #3371/#3372 reject predictor+lossy codec, #3331/#3332 reject zero/non-finite ModelPixelScale, #3327 gate dict gdal_metadata behind rich-tag opt-in, #3323/#3325 masked_nodata dtype-cast, #3277 pack nodata native width. Filed #3518 (tests). Cat 1 MEDIUM: the #3483 categorical PAM sidecar (_pam.py + _write_category_sidecar in _writers/eager.py) is round-trip tested only on the eager numpy write path (xrspatial/tests/test_rasterize_categorical_3482.py); the dask streaming (eager.py:1063) and GPU/nvCOMP (eager.py:880) write branches each have their own sidecar emit call that no test touches. Live probe on this CUDA host: dask + GPU categorical round-trips both emit the sidecar and read back names+RGBA colors today (no source bug, pure coverage gap). Added geotiff/tests/write/test_category_sidecar_backends_3483.py: dask write round-trip + GPU write round-trip (requires_gpu, RAN+passing locally) + names-only (category_colors=None build branch + names-only read path, never hit by the existing colors-always suite). 3 tests pass. Verified NOT gaps this pass: #3327 dict gdal_metadata gate has 43-line test_contract.py coverage; #3331/#3332 zero pixel scale covered by unit/test_degenerate_pixel_size_3331.py; #3371/#3372 predictor+lossy-codec reject has 2 test files; #3375/#3376/#3380 xarray engine covered by test_xarray_backend_3365.py + coregister 3376/3379; #3277 pack native width has 3 test files. LOW (carried, documented not fixed): Inf as the declared nodata sentinel still never tested. || Pass 22 (2026-06-12, deep-sweep test-coverage): delta audit of the ~20 commits since pass 21 (06-09..06-12, mostly pack/unpack fixes + #3241 GPU streaming writer + coregister #3254/#3248). Filed #3266 (tests). Cat 1 MEDIUM: pack=True gained working gpu/dask+gpu support in #3240, but three pack features were tested numpy+dask only: float32 width preservation (#3080, test_pack_float_width_3080.py), nodata kwarg fill (#3168, test_pack_nodata_kwarg_3168.py), band-subset per-band SCALE/OFFSET rewrite (#3161, test_pack_band_subset_3161.py). Live probe on this CUDA host: all six gpu/dask+gpu legs pass today (no source bug, pure coverage gap). Added one gpu/dask-gpu parametrized round-trip test per file (6 tests, requires_gpu, RUN+passing locally) and fixed two stale docstrings claiming unpack/pack is CPU-only (wrong since #3075/#3240). Verified NOT gaps this pass: #3128 int64 sentinel tests cover eager+dask+gpu; #3241 streaming writer landed with byte-identical band-first/band-last/BytesIO/small-buffer tests; #3104 scale-zero rejection has gpu legs; #3169 revived the dead compression-corpus oracle gate. Out of scope: coregister=True lives in accessor.py (excluded module); its multi-band + polar gaps are documented as experimental caveats in docs/source/reference/geotiff.rst (#3248). LOW (carried, documented not fixed): Inf as the declared nodata sentinel never tested. || PREVIOUS: Pass 21 (2026-06-09, deep-sweep test-coverage): filed #3114 (tests) + #3112 (source bug). Cat 1 HIGH: to_geotiff(pack=True) round-trip was tested only on numpy and dask+numpy (write/test_pack_3064.py); #3075 made unpack=True work on gpu and dask+gpu reads, but no test packed a GPU-read array back. Live probe on this CUDA host: BOTH GPU legs crash today -- eager gpu raises AttributeError (cupy has no astype, the known cupy 13.6/xarray 2025.12 where/astype incompat) and dask+gpu raises TypeError (numpy fill value inside cupy.where) -- both from _pack's out.fillna(nodata) in _attrs.py; _writers/gpu.py says the pre-dispatch re-pack is supposed to make every write path work. Source bug filed as #3112; test-only PR adds test_pack_round_trip_gpu (gpu + dask-gpu params, requires_gpu, xfail(strict=True) on #3112 so the fix flips them loudly) and fixes the stale module docstring claiming GPU rejects mask_and_scale. Ran on CUDA host: 13 passed, 2 xfailed. Verified NOT gaps this pass (probed before flagging): empty/zero-band writer guard is covered (test_basic.py 2075/2095 blocks incl. gpu + dask + streaming entry points); degenerate shapes covered on all 4 read backends (read/test_degenerate_shapes.py); overview_resampling all 7 modes parametrized; missing_sources raise/warn + invalid, band_nodata first/invalid, unpack on all 4 backends, masked/parse_coordinates/lock/cache/default_name/name-deprecation all exercised; attrs contract per-backend (attrs/test_contract.py). LOW (documented, not fixed): Inf as the declared nodata sentinel is never tested (only one nan+inf data round-trip in test_edge_cases.py). || PREVIOUS: Pass 20 (2026-06-06, deep-sweep test-coverage): filed #2984 and added test_writer.py degenerate-shape GPU write coverage (Cat 1 backend + Cat 3 geometric edge). Read side already covers 1x1/1xN/Nx1 on all 4 backends (read/test_degenerate_shapes.py) and the dask streaming writer covers them (integration/test_dask_pipeline.py); the GPU write path was the gap (smallest shape in gpu/test_writer.py was 2x2). Added test_write_geotiff_gpu_degenerate_round_trip (1x1/1xN/Nx1 x none/deflate) + test_to_geotiff_dask_gpu_degenerate_round_trip (dask+cupy via gpu=True). 9 new tests RUN+passing on a CUDA host. Verified paths work first (not a source bug); transform supplied explicitly via attrs. Wider tree audit (~92k test LOC vs ~33k source): rioxarray-compat (#2961), bbox NaN/Inf/rotated, 8-backend parity matrix, codec round-trips already covered -- no other real gaps. | Pass (2026-06-05 test-coverage sweep): mature module (~31k src / ~124k test LOC, 9 test dirs). Exhaustive existing coverage -- parity/test_backend_matrix.py runs all 4 backends + VRT + HTTP + fsspec; golden_corpus full-manifest parity; read_rioxarray_compat_2961 covers masked/mask_and_scale/parse_coordinates/default_name on eager+dask. Cat1+Cat3 gap found (MEDIUM): degenerate-shape READS (1x1/1xN/Nx1) were tested only on the eager numpy reader (test_edge_cases.py) and the dask streaming WRITE path (integration/test_dask_pipeline.py); the windowed dask READ (chunks=) and GPU READ (gpu=True) on a single-pixel dimension were never exercised (smallest dask-read source in read/test_tiling is 8x8/2x32, parity fixtures 32x32/64x64). Probed: paths work today, no source bug -- pure coverage gap. Added read/test_degenerate_shapes.py (18 tests): dask read x{chunks 1,3,4} x{1x1,1xN,Nx1} + coord/transform/crs parity + GPU read + dask+gpu read. GPU cells RAN and PASSED on this CUDA host (grid-size-1 launch validated). Fixture supplies explicit attrs['transform'] (writer cannot infer pixel size from a 1-element coord axis). Branch deep-sweep-test-coverage-geotiff-degenerate-read-01. NOTE: pre-existing union-merge CRLF/duplicate-record corruption in this CSV left untouched -- appended one clean record; DictReader last-write-wins picks this one."
+geotiff,2026-06-26,3545,MEDIUM,1;4,"Pass 24 (2026-06-26, deep-sweep test-coverage, CUDA host): delta audit of the geotiff commits since pass 23 (06-25): #3537/#3538 continuous-symbology sidecars (_symbology.py + color_ramp/color_ramp_range wired into the shared _write_sidecars closure in _writers/eager.py), #3522 short-row/non-well-formed PAM RAT crash fix, #3521 docstring, #3517 isort. Filed #3545 (tests). MEDIUM Cat 1/Cat 4: #3537's emit is covered on eager numpy but four branches had no test driving them -- color_ramp_range asserted bounds only on numpy (its documented purpose is the dask escape hatch that skips _finite_stats; the dask test only checked file existence); dask+cupy write emission (gpu=True over a dask array) untested; _is_single_band 3D length-1-band branch untested (only 2D + multiband-skip covered); attrs['nodata'] exclusion verified only in the _finite_stats unit, never end-to-end through to_geotiff. Live-probed all four on this CUDA host: correct behaviour (coverage gaps, not bugs). Added 4 tests to write/test_symbology_sidecar_3537.py (test_dask_gpu_write_emits_sidecars [requires_gpu, RAN+passing], test_dask_color_ramp_range_sets_bounds, test_3d_single_band_emits_sidecars, test_nodata_attr_excluded_from_ramp_bounds); full file 25 passed incl. GPU legs. Verified NOT gaps this pass: #3522 short-row + non-well-formed XML RAT covered by test_rasterize_categorical_3482.py (40-line block); #3518/#3519 categorical sidecar dask/GPU added in pass 23. LOW (carried, documented not fixed): Inf as the declared nodata sentinel still never tested."
 idw,2026-06-04,2919,HIGH,1;4,"cupy/dask+cupy backends untested (Cat1 HIGH); GPU k-reject error path untested (Cat4 MED). Added 6 GPU tests, validated on CUDA host. Inf-in-points (Cat2) and attrs-preservation (Cat5) are LOW, documented not fixed."
 interpolate,2026-06-12,3290,MEDIUM,2;3;4;5,"Deep-sweep 2026-06-12 on CUDA host. Backend coverage already complete: all 4 backends exercised for idw/kriging/spline incl. cross-backend equivalence and variance paths; no Cat 1 gaps. Filed #3290 for MEDIUM gaps, all verified correct-by-probe before filing (test-only fix): idw fill_value zero-weight branch (deterministic via 1e200 distance weight underflow; added numpy+dask+cupy, cupy RAN+PASSED), idw power only tested at default (exact oracle 10/(2^p+1)), spline collinear lstsq fallback, kriging duplicate points + all-equal-z (zero-variance variogram) + exactly-singular K regularisation retry (unit test on _build_kriging_matrix with all-zero variogram), spline/kriging 1x1 template, Inf/-Inf point filtering (only NaN was tested), lat/lon dim-name propagation (parametrized all 3 funcs), idw attrs preservation, 0-column template. Remaining minor untested: _build_kriging_matrix warn-then-NaN branch (needs mocked LinAlgError on retry). LOW documented not fixed: no asv benchmarks, non-uniform cell spacing unasserted. Full file 82 passed 0 skipped locally."
 interpolate-kriging,2026-06-04,2920;2921,HIGH,1;2;3;4;5,"Single public fn kriging(); all 4 backends already had cross-backend parity tests (numpy/cupy/dask+numpy/dask+cupy) incl. cupy & dask+cupy variance -- ran green on CUDA host. Gaps closed (test-only, #2921): Cat1 dask+numpy return_variance branch (_chunk_var) was untested -> added test_dask_return_variance_matches_numpy (atol=1e-12, var ~1e-14). Cat4 nlags only default(15) tested -> added non-default nlags=5 + invalid paths (nlags=0/-1 ValueError, nlags=2.5 TypeError). Cat2/3 two-point <3-lag-bins UserWarning branch -> test_two_point_warns_few_lag_bins. Cat2 all-NaN kriging input -> test_kriging_all_nan_points (only idw covered before). Cat5 output metadata (coords/dims/attrs/name) untested -> added test_output_metadata. Single-point kriging CRASHES (zero-size array reduction in _experimental_variogram, N=1) -- real source bug filed #2920; added xfail(strict, raises=ValueError) test_single_point documenting expected graceful behavior; source fix left to #2920 (test-only PR). LOW/not filed: singular-matrix K_inv-is-None all-NaN branch is defensive and unreachable via public API. GPU-validated."

xrspatial/geotiff/tests/write/test_symbology_sidecar_3537.py

@@ -94,6 +94,19 @@ def test_gpu_write_emits_sidecars(tmp_path):
     assert os.path.exists(path + ".aux.xml")
 
 
+@requires_gpu
+def test_dask_gpu_write_emits_sidecars(tmp_path):
+    """dask+cupy (gpu=True over a dask array) hits the shared sidecar emit."""
+    import cupy
+    import dask.array as dsa
+
+    path = str(tmp_path / "dgpu.tif")
+    to_geotiff(_continuous_da(dsa.from_array(cupy.asarray(_BASE), chunks=(8, 8))),
+               path, gpu=True, color_ramp="magma")
+    assert os.path.exists(str(tmp_path / "dgpu.qml"))
+    assert os.path.exists(path + ".aux.xml")
+
+
 def test_finite_stats_backend_parity():
     """Stats agree across numpy / dask / cupy / dask+cupy."""
     import dask.array as dsa
@@ -284,3 +297,45 @@ def test_color_ramp_range_sets_bounds(tmp_path):
     # range escape hatch writes only min/max stats (no mean/stddev pass).
     aux = open(path + ".aux.xml").read()
     assert "STATISTICS_MINIMUM" in aux and "STATISTICS_MEAN" not in aux
+
+
+def test_dask_color_ramp_range_sets_bounds(tmp_path):
+    """The range escape hatch exists for large dask graphs; assert its bounds
+    and the skipped mean/stddev pass land on a dask-backed write."""
+    import dask.array as dsa
+
+    path = str(tmp_path / "dk_rng.tif")
+    to_geotiff(_continuous_da(dsa.from_array(_BASE, chunks=(8, 8))), path,
+               color_ramp="viridis", color_ramp_range=(0.0, 50.0))
+    rr = _qml_renderer(str(tmp_path / "dk_rng.qml"))
+    assert float(rr.get("classificationMin")) == pytest.approx(0.0)
+    assert float(rr.get("classificationMax")) == pytest.approx(50.0)
+    aux = open(path + ".aux.xml").read()
+    assert "STATISTICS_MINIMUM" in aux and "STATISTICS_MEAN" not in aux
+
+
+def test_3d_single_band_emits_sidecars(tmp_path):
+    """A 3D raster with a length-1 band dim is single-band -> emit symbology."""
+    band1 = xr.DataArray(
+        _BASE.reshape(1, 16, 16),
+        dims=("band", "y", "x"),
+        coords={"band": [1], "y": np.arange(16.0), "x": np.arange(16.0)},
+        attrs={"crs": 4326},
+    )
+    path = str(tmp_path / "b1.tif")
+    to_geotiff(band1, path, color_ramp="viridis")
+    assert os.path.exists(str(tmp_path / "b1.qml"))
+    assert os.path.exists(path + ".aux.xml")
+
+
+def test_nodata_attr_excluded_from_ramp_bounds(tmp_path):
+    """attrs['nodata'] (no explicit nodata= kwarg) is excluded from the ramp
+    stretch end-to-end, not just in the _finite_stats unit."""
+    arr = np.array([[1.0, 2.0], [3.0, -9999.0]], dtype="float32")
+    da = _continuous_da(arr)
+    da.attrs["nodata"] = -9999.0
+    path = str(tmp_path / "nd.tif")
+    to_geotiff(da, path, color_ramp="viridis")
+    rr = _qml_renderer(str(tmp_path / "nd.qml"))
+    assert float(rr.get("classificationMin")) == pytest.approx(1.0)
+    assert float(rr.get("classificationMax")) == pytest.approx(3.0)