xarray-spatial 0.10.4__tar.gz → 0.10.5__tar.gz

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

@@ -0,0 +1,17 @@
+module,last_inspected,issue,severity_max,categories_found,notes
+aspect,2026-06-02,2742;2829,HIGH,3;4,"#2742: degenerate shapes (1x1/Nx1/1xN) + geodesic boundary modes; tests added all 4 backends, GPU-validated. #2829: northness/eastness method='geodesic' branch was untested (planar only); added correctness (diagonal surface where planar!=geodesic) + 4-backend parity, GPU-validated. all-NaN planar/geodesic returns all-NaN (correct). Inf input -> silent -1/flat on spike cell: possible source bug, out of scope for test-only sweep, not filed. Dedup: rectangular-cell oracle #2781 + cell-size #2780 already merged, not duplicated."
+contour,2026-05-29,2704;2710,HIGH,2;5,"Pass 1 (2026-05-29): added TestInfHandling, TestCRSPropagation, TestNonDefaultDims to test_contour.py (5 passed + 2 strict-xfail on a CUDA host; full file 29 passed, 2 xfailed). All four backends (numpy / cupy / dask+numpy / dask+cupy) were already exercised with cross-backend segment-equality assertions (TestBackendEquivalence), and ran green locally on the CUDA host -- Cat 1 well covered, no new backend tests needed. Cat 2 HIGH (Inf): the marching-squares NaN-skip guard at contour.py:67 uses x!=x which does not catch infinity, so a finite level near a +/-inf corner leaks NaN coordinates into the output. Filed source bug #2704 and added two xfail(strict=True) tests pinning it (+inf and -inf) plus test_inf_far_level_no_crossing covering the safe path where the inf quad classifies as all-above (idx 15) and is skipped before any interpolation. Cat 5 MEDIUM: no test asserted gdf.crs propagation from agg.attrs['crs'] (contour.py:660) -- added test_geopandas_crs_from_attrs (to_epsg()==5070) + test_geopandas_no_crs_attr. Cat 5 MEDIUM: the index-to-coordinate transform (contour.py:644-654) reads agg.dims[0]/[1] coords but no test used non-y/x dims -- added test_lat_lon_dims_coordinate_transform + test_lat_lon_matches_yx_equivalent. PR #2710 (test-only, source untouched). LOW (documented, not fixed): non-square cellsize (cellsize_x != cellsize_y) never exercised -- all tests use res (0.5,0.5); levels=None early-return on all-NaN/all-equal works (probed) but only the explicit-levels all-NaN path is asserted. Cat 3 1x1/Nx1/1xN are rejected by the >=2x2 validation guard and that rejection is already tested (test_too_small, test_minimum_raster)."
+focal,2026-05-29,2732,HIGH,1,"Pass (2026-05-29): added test_hotspots_dask_cupy to test_focal.py closing Cat 1 HIGH backend-coverage gap. hotspots() registers dask_cupy_func=_hotspots_dask_cupy (focal.py L1414) but no test invoked it, while mean/apply/focal_stats each have a dedicated dask+cupy test. New test compares dask+cupy vs numpy on chunk interior (matches test_apply_dask_cupy/test_focal_stats_dask_cupy style). RUN on CUDA host: passes; spy confirmed routing through _hotspots_dask_cupy; path matches numpy exactly so no source fix needed. LOW (documented not fixed): Inf/-Inf inputs untested across focal funcs; 1x1 raster not explicitly tested for mean/apply/hotspots (focal_stats 1x1 covered by test_variety_single_cell). Issue #2732."
+geotiff,2026-06-06,2984,MEDIUM,1;3,"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."
+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-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."
+interpolate_spline,2026-06-04,,HIGH,1;3;5,scope=spline-only; cupy+dask_cupy spline backends untested (_tps_cuda_kernel) | n==2 affine branch + metadata untested | added 4 tests to TestSpline all pass on CUDA host | issue-create denied by classifier no GH issue
+module,last_inspected,issue,severity_max,categories_found,notes
+polygonize,2026-05-29,2623,MEDIUM,4,"Pass 3 (2026-05-29): added test_polygonize_mask_dtype_coverage_2026_05_29.py (41 passed, 8 xfailed on a CUDA host). Closes Cat 4 MEDIUM parameter-coverage gap: mask= is documented to accept bool/integer/float values but every prior test passed only a bool mask. Integer masks (int32/int64) now pinned against the same-backend bool-mask output on all four backends x both raster dtypes x connectivity 4/8; float-mask-on-integer-raster also pinned. Each backend is compared to its OWN bool reference to isolate mask-dtype from the unrelated numpy-vs-dask hole-vs-single-ring representation difference. Mutation (drop the not-mask[ij] exclusion in _calculate_regions) flips 11 tests red incl. the pixel-exclusion sanity anchor; clean md5 restore. Surfaced source bug #2623: a float-dtype mask on a float-dtype raster raises TypeError at polygonize.py:918 (mask & nan_mask; bitwise_and undefined for float&bool; cupy/dask route floats through _polygonize_numpy so they crash too; int masks coerce fine). 8 float-mask cases marked xfail(strict, raises=TypeError) referencing #2623. Test-only; source untouched. | Pass 2 (2026-05-27): added test_polygonize_atol_rtol_backend_coverage_2026_05_27.py with 15 tests, all passing on a CUDA host. Closes Cat 4 MEDIUM parameter-coverage gap on atol/rtol forwarding through the cupy and dask+cupy backends. atol/rtol were exposed by #2173 / #2194 and thread through _polygonize_cupy (polygonize.py:808) and _polygonize_dask (polygonize.py:1719); the dask path further plumbs them into dask.delayed(_polygonize_chunk)(...) at lines 1748-1754 and into _bucket_key_for_value for cross-chunk merge bucketing at lines 1757-1758. Pre-existing tests covered non-default atol/rtol only on numpy and dask+numpy. The cupy and dask+cupy dispatchers were untested -- a regression dropping the kwargs there would silently change the float polygon count and would not be caught. Same dispatcher-silently-drops-kwarg pattern fixed by #1561 / #1605 / #1685 / #1810 / #1974 on adjacent GeoTIFF surfaces. 15 tests: cupy strict-equality + default-tolerance pin on _REPRO_2173, dask+cupy strict-equality single-chunk + multi-chunk (engages cross-chunk merge bucket) + default-tolerance multi-chunk pin, cupy intermediate-atol small/large pair, dask+cupy intermediate-atol single/multi-chunk small + single-chunk large, cupy integer atol-ignored matrix, dask+cupy integer atol-ignored single-chunk + multi-chunk, cupy rtol-only large/small matrix. Mutation against _polygonize_cupy float branch (drop atol/rtol kwargs in the _polygonize_numpy forward call at polygonize.py:823-825) flips 3 of 5 cupy tests red; mutation against dask.delayed(_polygonize_chunk)(...) at polygonize.py:1748-1754 (drop atol, rtol args) flips 2 of 6 dask+cupy tests red. Confirmed clean restore via md5sum. Source untouched. Filed issue #2537 (test-only). Cat 4 MEDIUM (parameter coverage on cupy + dask+cupy atol/rtol forwarding). Pass 1 (2026-05-19): added test_polygonize_coverage_2026_05_19.py with 58 tests, all passing on a CUDA host. Closes Cat 3 HIGH 1x1 / Nx1 single-column geometric gaps (Nx1 exercises the nx==1 padding path at polygonize.py:565 and the cupy nx==1 numpy-fallback at polygonize.py:671), Cat 3 MEDIUM 1xN single-row and all-equal-value rasters on all four backends. Closes Cat 2 HIGH NaN parity for cupy + dask+cupy (numpy/dask were already covered by test_polygonize_nan_pixels_excluded*), Cat 2 MEDIUM all-NaN raster on all four backends, Cat 2 HIGH +/-Inf pins on all four backends. Filed source-bug issue #2155: numpy/dask/dask+cupy backends silently absorb Inf cells into adjacent finite polygons because _is_close reduces abs(inf-inf) to nan; cupy backend handles Inf correctly. Pins lock the asymmetric behaviour so the fix is visible. Closes Cat 1 MEDIUM simplify_tolerance + mask= parity gaps on dask+cupy backend (numpy/cupy/dask were already covered). Closes Cat 4 MEDIUM column_name non-default value across geopandas/spatialpandas/geojson return types and Cat 4 MEDIUM validation error paths (bad connectivity, bad transform length, mask shape mismatch, mask underlying-type mismatch). Cat 5 N/A: polygonize returns lists/dataframes, not a DataArray with attrs to propagate."
+proximity,2026-06-02,2692,HIGH,1;2;3;4;5,"Pass 2 (2026-06-02): added 18 tests to test_proximity.py closing the two MEDIUM gaps Pass 1 left open, all RUN and passing on a CUDA host across numpy/cupy/dask+numpy/dask+cupy (15 cross-backend + 3 error-path). Source untouched. Cat 4 MEDIUM (error path): _process raises ValueError when raster.dims != (y, x) (proximity.py:1043) but no test exercised the swapped x/y guard; test_wrong_dim_order_raises pins it for proximity/allocation/direction. Cat 2 MEDIUM (all-NaN input): Pass 1 noted all-NaN/all-zero on eager numpy+cupy was unpinned; test_all_nan_raster_all_nan_output pins an all-NaN 6x6 raster -> all-NaN float32 output on all four backends x three functions. Remaining LOW (documented): invalid distance_metric string silently falls back to EUCLIDEAN (proximity.py:1049-1051). || PREVIOUS: Pass 1 (2026-05-29): added 65 tests to test_proximity.py closing three coverage gaps, all RUN and passing on a CUDA host (numpy/cupy/dask+numpy/dask+cupy). Issue #2692, PR opened. Source untouched. Cat 3 HIGH: degenerate raster shapes (1x1 single pixel, Nx1 column strip, 1xN row strip) had zero coverage for proximity/allocation/direction on any backend; they stress the line-sweep kernel boundaries (_process_proximity_line) and the GPU brute-force kernel grid sizing (_proximity_cuda_kernel via cuda_args). Pinned all three shapes x three functions x four backends against hand-checked expected values; mutation of a pinned direction expectation confirms teeth. Cat 1/4 HIGH: allocation and direction only ran EUCLIDEAN across backends; MANHATTAN and GREAT_CIRCLE were cross-backend-tested for proximity only. Pinned both metrics x two functions x four backends against the numpy baseline (all match). Cat 5 MEDIUM: no test set non-empty res/crs attrs so the attrs-preservation assertion in general_output_checks compared two empty dicts. proximity reads attrs['res'] via get_dataarray_resolution for bounded-dask chunk padding, so added attrs round-trip tests on four backends plus a bounded-dask test where a res attr matching the coordinate spacing must equal the numpy baseline. A res attr that lies about the spacing mis-sizes the map_overlap depth; source fragility, not a test gap, left for a separate accuracy issue. Cat 2 (NaN/Inf input) already covered by the shared test_raster fixture (embeds np.inf and np.nan, runs on four backends). Remaining LOW: all-NaN / all-zero input on eager numpy+cupy not directly pinned."
+rasterize,2026-05-29,2614,MEDIUM,4,"Pass 4 (2026-05-29): added test_rasterize_coverage_2026_05_29.py with 11 tests, all passing (pure-Python validation paths, no CUDA needed); filed issue #2614 and opened a test-only PR. Closes Cat 4 MEDIUM error-path gaps that all three prior passes left untouched. (1) Partial width/height: the (width is None) != (height is None) guard in rasterize() raises ValueError naming the given and missing dimension, documented in the docstring, but neither the width-only nor height-only branch had a test; pin both directions plus the width-only+resolution case proving the guard fires before the resolution branch. (2) resolution= input type/shape validation: the type/shape branches (non-number/non-sequence string|dict; wrong-ndim numpy array; wrong-length sequence len 1|3|4; non-numeric elements) had no coverage -- test_rasterize.py's test_invalid_resolution_scalar/tuple only exercise non-finite/non-positive VALUES, not these type/shape guards, so a regression loosening or reordering them would ship silently; pin each branch to its message plus a positive control that a 1-D length-2 numpy array is still accepted. Source untouched."
+reproject,2026-05-29,2618,HIGH,3,"Pass 2026-05-29: reproject already has a deep suite (369 tests in test_reproject.py + coverage/gate files) covering all 4 backends, NaN/Inf/all-NaN/all-Inf, 1x1/2x2, metadata, vertical shift, bounds_policy x backends, integer nodata x backends. Gaps found: Cat 3 HIGH single-row (1xN) and single-col (Nx1) strip rasters never tested (hit size<2 branch of _validate_regular_axis + degenerate resampling axis); Cat 3 MEDIUM constant-value/zero-gradient raster never reprojected. Added TestDegenerateShapeReproject (12 tests): 1xN+Nx1 strips x numpy/dask/cupy/dask+cupy, constant raster numpy value-preservation + cross-backend parity. All 12 executed and passed on a CUDA host. Test-only, no source change (#2618). LOW (documented only): _merge._merge_arrays_cupy imported but never called by merge() (host-bounces via _merge_arrays_numpy) - dead-code source observation not a test gap; non-square cellsize reproject only covered via resolution-tuple validation errors not a successful anisotropic run."
+resample,2026-05-29,2547;2615,HIGH,1;2;3;5,"Pass 2 (2026-05-29): added test_resample_cupy_agg_fallback_2615.py (6 tests, all passing on CUDA host). Closes Cat 1 MEDIUM backend-coverage gap: the cupy eager aggregate CPU fallback for average/min/max at a NON-integer downsample factor (_run_cupy fy==int(fy) branch in resample.py ~L957-973) was never exercised; existing TestCuPyParity used 12x12 scale 0.5 (integer factor 2 -> GPU reshape path) and only median/mode hit the host fallback. New tests use 10x10 scale 0.3 (factor 3.33) for average/min/max parity vs numpy plus a NaN-masked variant. Issue #2615. Module is otherwise very thoroughly covered (test_resample.py + 3 supplementary files); no remaining HIGH gaps found. Pass 1 (2026-05-27): added test_resample_coverage_2026_05_27.py with 70 tests (68 passing, 2 skipped). Closes Cat 3 HIGH Nx1 single-column gap across numpy/cupy/dask+numpy/dask+cupy x 8 methods (nearest/bilinear/cubic/average/min/max/median/mode) plus Nx1 upsample-nearest parity and Nx1 cross-backend aggregate parity. Closes Cat 2 MEDIUM NaN-parity gap on cupy and dask+cupy (existing TestCuPyParity/TestDaskCuPyParity used random data without NaN; the weight-mask gate and spline-prepad had no GPU NaN coverage). Closes Cat 3 MEDIUM all-equal-value raster across 8 methods (downsample) and 3 interp methods (upsample) plus a constant-with-NaN aggregate variant. Closes Cat 5 MEDIUM non-default dim-name propagation: lat/lon, latitude/longitude, and (channel, lat, lon) 3D round-trip without being renamed to y/x; per-dim attrs (units) preserved. Closes Cat 3 MEDIUM empty-raster behaviour pin: 0-row and 0-col rasters raise (currently IndexError) -- contract covered. Filed source-bug issue #2547: cubic on dask backends fails for Nx1 / arrays smaller than depth=16; the 2 skipped tests in this file gate on that fix landing. Source untouched."
+slope,2026-05-29,2697,MEDIUM,3,"PR #2703: added degenerate-shape tests (1x1/1xN/Nx1) for all 4 planar backends + geodesic; no live bug, pins all-NaN+shape contract. CUDA host: cupy/dask+cupy ran. Backend/NaN/param/metadata coverage already complete."
+viewshed,2026-05-29,2693,HIGH,1;2;5,"Pass 1 (2026-05-29): added 4 new test groups to test_viewshed.py (13 new tests + 1 xfail, all passing/xfailing on a CUDA+RTX host). Closes Cat 1 HIGH backend-coverage gap: the dask+cupy dispatch path in _viewshed_dask (Tier B) and _viewshed_windowed (max_distance) was registered but never invoked by any test -- added test_viewshed_dask_cupy_flat (analytical-angle parity, atol 0.03) and test_viewshed_dask_cupy_max_distance (windowed GPU run; observer cell 180, corners INVISIBLE). Both use non-zero flat terrain (1.3) because the RTX mesh builder rejects an all-zero raster (#1378). Closes Cat 5 HIGH metadata-preservation gap: only the numpy test_viewshed called general_output_checks; the cupy/dask/dask+cupy and max_distance paths never asserted attrs/coords/dims/array-type preservation. Added parametrised test_viewshed_metadata_preserved over {numpy,cupy,dask+numpy,dask+cupy} x {full, max_distance=2.0}: asserts attrs==, dims==, shape==, x/y coords allclose; runs general_output_checks (full type parity) for all backends except dask+cupy. Closes Cat 2 HIGH NaN-input gap and surfaced source bug #2693: viewshed on a numpy raster crashes with ValueError 'node not found' from _delete_from_tree when a NaN cell sits at certain positions (e.g. (2,4) in a 5x5 with observer at (2,2)), while NaN at (1,1)/(0,0)/(4,4) runs fine. Added test_viewshed_nan_input_supported_positions (parametrised working positions, asserts observer=180 and NaN cell is INVISIBLE/NaN) plus test_viewshed_nan_input_crashing_position (xfail strict, raises, links #2693). Noted but NOT fixed (source change out of scope for test sweep): the dask+cupy backend does not preserve the cupy backing -- _viewshed_dask computes then rewraps via da.from_array(result_np), so the output computes to numpy not cupy; general_output_checks is skipped for dask+cupy for that reason (candidate for the metadata/backend-parity sweep). LOW (documented only): non-square cell sizes; 1x1 and 1xN geometry covered behaviourally by probing (run without error). Test-only PR; viewshed.py untouched."
+zonal,2026-05-29,2619,MEDIUM,1,"Pass 2 (2026-05-29): one Cat 1 MEDIUM backend-coverage gap remained after pass 1 -- 3D crosstab on cupy / dask+cupy. The 3D GPU paths (_crosstab_cupy / _crosstab_dask_cupy with a 3D categorical values array, layer=, agg='count') were reachable and correct but untested; the existing 3D crosstab tests (test_crosstab_3d_count, test_crosstab_3d_agg_method, test_nodata_values_crosstab_3d) only parametrize numpy / dask+numpy. Added 3 parity tests to test_zonal_backend_coverage_2026_05_27.py (test_crosstab_3d_count_cupy_matches_numpy, test_crosstab_3d_count_dask_cupy_matches_numpy, test_crosstab_3d_nodata_cupy_matches_numpy) asserting cupy and dask+cupy results match numpy for agg='count' including a nodata_values case. All passed live on a CUDA host. Issue #2619, PR #2625. Test-only, no source change. Remaining LOW (documented, not fixed): get_full_extent has no direct unit test (exercised indirectly via suggest_zonal_canvas); non-square cellsize handling not exercised. Pass 1 (2026-05-27): added test_zonal_backend_coverage_2026_05_27.py with 32 tests, all passing on a CUDA host. Closes Cat 1 HIGH backend-coverage gaps: crosstab cupy + dask+cupy (_crosstab_cupy / _crosstab_dask_cupy were dispatched but never invoked by tests), regions cupy + dask+cupy (_regions_cupy via cupyx.scipy.ndimage + _regions_dask_cupy), trim dask+numpy + cupy + dask+cupy (_trim_bounds_dask isnan path and cupy data.get() path), crop dask+numpy + cupy + dask+cupy (_crop_bounds_dask + cupy data.get() path), apply 3D cupy + dask+cupy (per-layer kernel launch over the third axis in _apply_cupy and _apply_dask_cupy). Existing test_zonal.py covered only numpy + dask+numpy for crosstab/regions/trim/crop and 2D-only for cupy apply. Closes Cat 3 MEDIUM 1x1 / 1xN / Nx1 strip edge cases for trim, crop, and regions. Closes Cat 4 LOW pins: regions(neighborhood=6) ValueError, suggest_zonal_canvas(crs='Geographic') aspect-ratio pin and invalid-crs KeyError, crosstab cupy zone_ids/cat_ids filter, crosstab cupy agg='percentage'. Closes Cat 5 MEDIUM: regions coords/attrs propagation across numpy + dask+numpy, trim/crop name='trim'/'crop' default + attrs preservation. Also pins the documented numpy-vs-dask trim asymmetry on NaN sentinel (numpy _trim does equality which never matches NaN; dask _trim_bounds_dask has dedicated isnan branch). Mutation against the cupy.asnumpy() conversion in _crosstab_cupy flipped test_crosstab_cupy_matches_numpy red. Source untouched."

xarray_spatial-0.10.5/.kilo/command/backend-parity.md

@@ -0,0 +1,159 @@
+# Backend Parity: Cross-Backend Consistency Audit
+
+Verify that all implemented backends produce consistent results for a given
+function or set of functions. The prompt is: {{ARGUMENTS}}
+
+---
+
+## Step 1 -- Identify targets
+
+1. If {{ARGUMENTS}} names specific functions (e.g. `slope`, `aspect`), use those.
+2. If {{ARGUMENTS}} names a category (e.g. `hydrology`, `surface`, `focal`), read
+   `README.md` to find all functions in that category.
+3. If {{ARGUMENTS}} is empty or says "all", scan the full feature matrix in `README.md`
+   and test every function that claims support for 2+ backends.
+4. For each function, read its source file and find the `ArrayTypeFunctionMapping`
+   call to determine which backends are actually implemented (not just what the
+   README claims).
+
+## Step 2 -- Build test inputs
+
+For each target function, create test rasters at three scales:
+
+| Name    | Size    | Purpose                                         |
+|---------|---------|--------------------------------------------------|
+| tiny    | 8x6     | Fast, easy to inspect cell-by-cell               |
+| medium  | 64x64   | Catches chunk-boundary artifacts in dask          |
+| large   | 256x256 | Stress test, exposes numerical accumulation drift |
+
+For each size, generate two variants:
+- **Clean:** no NaN, realistic value range for the function
+  (e.g. 0-5000m for elevation, 0-1 for NDVI inputs)
+- **Dirty:** 5-10% random NaN, some extreme values near dtype limits
+
+Use `np.random.default_rng(42)` for reproducibility. For functions that require
+specific input structure (e.g. `flow_direction` needs a DEM with drainage, not
+random noise), use the project's `perlin` module or a synthetic cone/valley.
+
+Also test with at least two dtypes: `float32` and `float64`.
+
+## Step 3 -- Run every backend
+
+For each function, input variant, and dtype:
+
+1. **NumPy:** `create_test_raster(data, backend='numpy')` -- always the baseline.
+2. **Dask+NumPy:** test with two chunk configurations:
+   - `chunks=(size//2, size//2)` -- even split
+   - `chunks=(size//3, size//3)` -- ragged remainder
+3. **CuPy:** `create_test_raster(data, backend='cupy')` -- skip if CUDA unavailable.
+4. **Dask+CuPy:** `create_test_raster(data, backend='dask+cupy')` -- skip if CUDA
+   unavailable.
+
+If the function has parameter variants (e.g. `boundary`, `method`), test the
+default parameters first. If {{ARGUMENTS}} includes "thorough", also sweep all
+parameter combinations.
+
+## Step 4 -- Pairwise comparison
+
+For every non-NumPy result, compare against the NumPy baseline. Extract data using
+the project conventions:
+- Dask: `.data.compute()`
+- CuPy: `.data.get()`
+- Dask+CuPy: `.data.compute().get()`
+
+For each pair, compute and record:
+
+### 4a. Value agreement
+```python
+abs_diff = np.abs(result - baseline)
+max_abs = np.nanmax(abs_diff)
+rel_diff = abs_diff / (np.abs(baseline) + 1e-30)  # avoid div-by-zero
+max_rel = np.nanmax(rel_diff)
+mean_abs = np.nanmean(abs_diff)
+```
+
+### 4b. NaN mask agreement
+```python
+nan_match = np.array_equal(np.isnan(result), np.isnan(baseline))
+nan_only_in_result = np.sum(np.isnan(result) & ~np.isnan(baseline))
+nan_only_in_baseline = np.sum(np.isnan(baseline) & ~np.isnan(result))
+```
+
+### 4c. Metadata preservation
+Using `general_output_checks` from `general_checks.py`:
+- Output type matches input type (DataArray backed by the same array type)
+- Shape, dims, coords, attrs preserved
+
+### 4d. Pass/fail thresholds
+
+| Comparison            | rtol     | atol     |
+|-----------------------|----------|----------|
+| NumPy vs Dask+NumPy   | 1e-5     | 0        |
+| NumPy vs CuPy         | 1e-6     | 1e-6     |
+| NumPy vs Dask+CuPy    | 1e-6     | 1e-6     |
+
+A comparison **fails** if `max_abs > atol` AND `max_rel > rtol`, or if NaN masks
+disagree.
+
+## Step 5 -- Chunk boundary analysis
+
+Dask backends are the most likely source of parity issues due to `map_overlap`
+boundary handling. For any Dask comparison that fails or is borderline:
+
+1. Identify which cells diverge from the NumPy result.
+2. Map those cells to chunk boundaries (cells within `depth` pixels of a chunk edge).
+3. Report what percentage of divergent cells are at chunk boundaries vs interior.
+4. If all divergence is at boundaries, the issue is likely in the `map_overlap`
+   `depth` or `boundary` parameter. Say so explicitly.
+
+## Step 6 -- Generate the report
+
+```
+## Backend Parity Report
+
+### Functions tested
+| Function            | Backends implemented       | Source file              |
+|---------------------|---------------------------|--------------------------|
+| slope               | numpy, cupy, dask, dask+cupy | xrspatial/slope.py    |
+| ...                 | ...                        | ...                      |
+
+### Parity Matrix
+
+#### <function_name>
+| Comparison            | Input       | Dtype   | Max |Δ|   | Max |Δ/ref| | NaN match | Metadata | Status |
+|-----------------------|-------------|---------|----------|------------|-----------|----------|--------|
+| NumPy vs Dask+NumPy   | tiny clean  | float32 | ...      | ...        | yes       | ok       | PASS   |
+| NumPy vs Dask+NumPy   | medium dirty| float64 | ...      | ...        | yes       | ok       | PASS   |
+| NumPy vs CuPy         | tiny clean  | float32 | ...      | ...        | no (3)    | ok       | FAIL   |
+| ...                   | ...         | ...     | ...      | ...        | ...       | ...      | ...    |
+
+### Failures
+For each FAIL row:
+- Which cells diverged
+- Whether divergence correlates with chunk boundaries (Dask) or specific
+  input values (CuPy)
+- Likely root cause
+- Suggested fix
+
+### Summary
+- Functions tested: N
+- Total comparisons: N
+- Passed: N
+- Failed: N
+- Skipped (no CUDA): N
+```
+
+---
+
+## General rules
+
+- Do not modify any source or test files. This command is read-only.
+- Use `create_test_raster` from `general_checks.py` for all raster construction.
+- Any temporary files must include the function name for uniqueness.
+- If CUDA is unavailable, skip CuPy and Dask+CuPy gracefully. Report them
+  as SKIPPED, not FAIL.
+- If {{ARGUMENTS}} includes "fix", still do not auto-fix. Report the issue and ask.
+- If a function is not in `ArrayTypeFunctionMapping` (e.g. it only has a numpy
+  path), note it as "single-backend only" and skip parity checks for it.
+- If {{ARGUMENTS}} includes a specific tolerance (e.g. `rtol=1e-3`), override the
+  defaults in the threshold table.

xarray_spatial-0.10.5/.kilo/command/bench.md

@@ -0,0 +1,127 @@
+# Bench: Local Performance Comparison
+
+Run ASV benchmarks for the current branch against main and report regressions
+and improvements. The prompt is: {{ARGUMENTS}}
+
+---
+
+## Step 1 -- Identify what changed
+
+1. If {{ARGUMENTS}} names specific benchmark classes or functions (e.g. `Slope`,
+   `flow_accumulation`), use those directly.
+2. If {{ARGUMENTS}} is empty or says "auto", run `git diff origin/main --name-only`
+   to find changed source files under `xrspatial/`. Map each changed file to the
+   corresponding benchmark module in `benchmarks/benchmarks/`. Use the filename
+   and imports to match (e.g. changes to `slope.py` map to `benchmarks/benchmarks/slope.py`).
+3. If no benchmark exists for the changed code, note this in the report and
+   suggest whether one should be added.
+
+## Step 2 -- Check prerequisites
+
+1. Verify ASV is installed: `python -c "import asv"`. If missing, tell the user
+   to install it (`pip install asv`) and stop.
+2. Verify the benchmarks directory exists at `benchmarks/`.
+3. Read `benchmarks/asv.conf.json` to confirm the project name and branch settings.
+4. Check whether the ASV machine file exists (`.asv/machine.json`). If not, run
+   `cd benchmarks && asv machine --yes` to initialize it.
+
+## Step 3 -- Run the comparison
+
+Run ASV in continuous-comparison mode from the `benchmarks/` directory:
+
+```bash
+cd benchmarks && asv continuous origin/main HEAD -b "<regex>" -e
+```
+
+Where `<regex>` is a pattern matching the benchmark classes identified in Step 1
+(e.g. `Slope|Aspect` or `FlowAccumulation`). The `-e` flag shows stderr on failure.
+
+If {{ARGUMENTS}} contains "quick", add `--quick` to run each benchmark only once
+(faster but noisier).
+
+If {{ARGUMENTS}} contains "full", omit the `-b` filter to run all benchmarks.
+
+## Step 4 -- Parse and interpret results
+
+ASV continuous outputs lines like:
+```
+BENCHMARKS NOT SIGNIFICANTLY CHANGED.
+```
+or:
+```
+REGRESSION: benchmarks.slope.Slope.time_numpy  3.45ms -> 5.67ms  (1.64x)
+IMPROVED:   benchmarks.slope.Slope.time_dask   8.12ms -> 4.23ms  (0.52x)
+```
+
+Parse the output and classify each result:
+
+| Category     | Criteria                    |
+|--------------|-----------------------------|
+| REGRESSION   | Ratio > 1.2x (matches CI)   |
+| IMPROVED     | Ratio < 0.8x                |
+| UNCHANGED    | Between 0.8x and 1.2x       |
+
+## Step 5 -- Generate the report
+
+```
+## Benchmark Report: <branch> vs main
+
+### Changed files
+- <list of changed source files>
+
+### Benchmarks run
+- <list of benchmark classes/functions matched>
+
+### Results
+
+| Benchmark                          | main    | HEAD      | Ratio | Status     |
+|------------------------------------|-----------|-----------|-------|------------|
+| slope.Slope.time_numpy             | 3.45 ms   | 3.51 ms   | 1.02x | UNCHANGED  |
+| slope.Slope.time_dask_numpy        | 8.12 ms   | 4.23 ms   | 0.52x | IMPROVED   |
+| ...                                | ...       | ...       | ...   | ...        |
+
+### Regressions
+<details for each regression: which benchmark, how much slower, likely cause>
+
+### Improvements
+<details for each improvement>
+
+### Missing benchmarks
+<list any changed functions that have no benchmark coverage>
+
+### Recommendation
+- [ ] Safe to merge (no regressions)
+- [ ] Add "performance" label to PR (regressions found, CI will recheck)
+- [ ] Consider adding benchmarks for: <uncovered functions>
+```
+
+## Step 6 -- Suggest benchmark additions (if gaps found)
+
+If Step 1 found changed functions with no benchmark coverage:
+
+1. Read an existing benchmark file in `benchmarks/benchmarks/` that covers a
+   similar function (same category or same backend pattern).
+2. Describe what a new benchmark should test:
+   - Which function and parameter variants
+   - Suggested array sizes (match `common.py` conventions)
+   - Which backends to benchmark (numpy at minimum, dask if applicable)
+3. Ask the user whether they want you to write the benchmark file.
+
+Do NOT write benchmark files automatically. Report the gap and propose, then wait.
+
+---
+
+## General rules
+
+- Always run benchmarks from the `benchmarks/` directory, not the project root.
+- The regression threshold is 1.2x, matching `.github/workflows/benchmarks.yml`.
+  Do not change this unless {{ARGUMENTS}} overrides it.
+- If ASV setup or machine detection fails, report the error clearly and suggest
+  the fix. Do not retry in a loop.
+- If benchmarks take longer than 5 minutes per class, note the elapsed time so
+  the user can plan accordingly.
+- Do not modify any source, test, or benchmark files. This command is read-only
+  analysis (unless the user explicitly asks for a benchmark to be written in
+  response to Step 6).
+- If {{ARGUMENTS}} says "compare <branch1> <branch2>", run
+  `asv continuous <branch1> <branch2>` instead of the default origin/main vs HEAD.

xarray_spatial-0.10.5/.kilo/command/dask-notebook.md

@@ -0,0 +1,148 @@
+# Dask ETL Notebook
+
+Create a Jupyter notebook that sets up a Dask distributed LocalCluster and walks
+through an ETL (Extract, Transform, Load) workflow. The prompt is: {{ARGUMENTS}}
+
+Use the prompt to determine the data domain, transformations, and output format.
+If no prompt is given, use a geospatial raster ETL as the default domain
+(consistent with the xarray-spatial project).
+
+---
+
+## Notebook structure
+
+Every Dask ETL notebook follows this cell sequence:
+
+```
+ 0  [markdown]  # Title + one-line description of the pipeline
+ 1  [markdown]  ### Overview (what the pipeline does, what you'll learn)
+ 2  [markdown]  One-liner about the imports
+ 3  [code    ]  Imports
+ 4  [markdown]  ## Cluster Setup
+ 5  [code    ]  Create and inspect a dask.distributed LocalCluster + Client
+ 6  [markdown]  Brief note on the dashboard URL and how to read it
+ 7  [markdown]  ## Extract
+ 8  [code    ]  Load or generate source data as lazy Dask arrays
+ 9  [markdown]  Describe the raw data: shape, dtype, chunk layout
+10  [code    ]  Inspect / visualize a sample of the raw data
+11  [markdown]  ## Transform
+12  [code    ]  Apply transformations (filtering, rechunking, computation)
+13  [markdown]  Explain what the transform does and why it benefits from Dask
+14  [code    ]  (Optional) Additional transform step(s)
+15  [markdown]  ## Load
+16  [code    ]  Write results to disk (Zarr, Parquet, GeoTIFF, etc.)
+17  [markdown]  Confirm output and show summary statistics
+18  [code    ]  Read back and verify the output
+19  [markdown]  ## Cleanup
+20  [code    ]  Close the client and cluster
+21  [markdown]  ### Summary + next steps
+```
+
+Sections can be repeated or extended when the prompt calls for more transform
+steps. The core requirement is that every notebook has all five phases: Cluster
+Setup, Extract, Transform, Load, Cleanup.
+
+---
+
+## Cluster Setup cell
+
+Always use this pattern for the cluster:
+
+```python
+from dask.distributed import Client, LocalCluster
+
+cluster = LocalCluster(
+    n_workers=4,
+    threads_per_worker=2,
+    memory_limit="2GB",
+)
+client = Client(cluster)
+client
+```
+
+Include a markdown cell after the cluster cell noting:
+- The dashboard link (usually `http://localhost:8787/status`)
+- That `n_workers` and `memory_limit` should be tuned for the machine
+
+If the prompt asks for a specific cluster configuration (GPU workers, adaptive
+scaling, remote scheduler), adjust accordingly but keep the default simple.
+
+---
+
+## Code conventions
+
+### Imports
+
+Standard import block for a Dask ETL notebook:
+
+```python
+import numpy as np
+import xarray as xr
+import dask
+import dask.array as da
+from dask.distributed import Client, LocalCluster
+```
+
+Add extras only when needed (e.g. `import pandas as pd`, `import rioxarray`,
+`from xrspatial import slope`). Keep the import cell minimal.
+
+### Dask best practices to demonstrate
+
+- **Lazy by default**: build the computation graph before calling `.compute()`.
+  Show the repr of a lazy array at least once so the reader sees the task graph.
+- **Chunking**: explain chunk choices. Use `dask.array.from_array(..., chunks=)`
+  or `xr.open_dataset(..., chunks={})` depending on the source.
+- **Avoid full materialization mid-pipeline**: no `.values` or `.compute()` until
+  the Load phase unless there is a good reason (and if so, explain why).
+- **Persist when reused**: if an intermediate result is used in multiple
+  downstream steps, call `client.persist(result)` and explain why.
+- **Progress feedback**: use `dask.diagnostics.ProgressBar` or point the reader
+  to the dashboard.
+
+### Data handling
+
+- Generate or load data lazily. For synthetic data, use `dask.array.random` or
+  wrap numpy arrays with `da.from_array(..., chunks=...)`.
+- For file-based sources, prefer `xr.open_dataset` / `xr.open_mfdataset` with
+  explicit `chunks=` to get lazy Dask-backed arrays.
+- For the Load phase, prefer Zarr (`to_zarr()`) as the default output format
+  since it supports parallel writes natively. Mention Parquet or GeoTIFF as
+  alternatives when relevant.
+
+### Cleanup
+
+Always close the client and cluster at the end:
+
+```python
+client.close()
+cluster.close()
+```
+
+---
+
+## Writing rules
+
+1. **Run all markdown cells and code comments through [TOOL: humanize].**
+2. Never use em dashes.
+3. Short and direct. Technical but not sterile.
+4. Title cell (h1): describe the pipeline, e.g.
+   `Dask ETL: Raster Slope Analysis at Scale` or
+   `Dask ETL: Aggregating Sensor Readings to Parquet`.
+5. Overview cell: 2-3 sentences on what the pipeline does and what Dask concepts
+   the reader will pick up. No hype.
+6. Each phase (Extract, Transform, Load) gets a brief markdown intro (2-4
+   sentences) explaining what happens and why.
+7. Use inline comments in code cells sparingly. Let the markdown cells carry the
+   explanation.
+
+---
+
+## Checklist
+
+When creating the notebook:
+
+1. Pick a data domain from the prompt (or default to geospatial raster).
+2. Write the full cell sequence following the structure above.
+3. Verify all code cells are syntactically correct and self-contained.
+4. Run all markdown through [TOOL: humanize].
+5. Ensure the notebook cleans up after itself (cluster closed, temp files noted).