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

{xarray_spatial-0.10.4 → xarray_spatial-0.10.6}/.claude/commands/deep-sweep.md

@@ -120,8 +120,8 @@ with path.open() as f:
     header = reader.fieldnames
     rows = [r for r in reader if r["module"] != "{module}"]
 def _oneline(v):
-    # merge=union is line-based: a newline inside a quoted field splits
-    # the record on parallel-agent merges. Force one physical line per
+    # Git merges these CSVs line by line, so a newline inside a quoted
+    # field splits the record on a merge. Force one physical line per
     # record by collapsing embedded newlines to " | ".
     return "" if v is None else str(v).replace("\r\n", " | ").replace("\r", " | ").replace("\n", " | ")
 
@@ -421,11 +421,12 @@ inspect or push them.
   per-sweep worktrees via the subagents.
 - The deliverable from the parent is: validated module, dispatch table,
   parallel agents, results table. Keep parent output concise.
-- Each sweep's state CSV is registered with `merge=union` in
-  `.gitattributes`, so the N concurrent state updates auto-merge cleanly
-  even though they all touch the same module's row in different worktrees
-  -- the last write per row wins, which is the read-update-write semantics
-  the sweep templates already use.
+- Each sweep's state CSV uses git's default 3-way text merge (no
+  `merge=union`; see issue #2754). N concurrent state updates that touch
+  the same row surface a normal conflict rather than silently unioning
+  duplicate rows. Resolve by keeping one row per module (last write per
+  row wins), which is the read-update-write semantics the sweep templates
+  already use.
 - If a sweep template later changes its state-file schema or its audit
   categories, deep-sweep picks up the change automatically the next time
   it runs, because each subagent re-reads its sweep file on dispatch.

{xarray_spatial-0.10.4 → xarray_spatial-0.10.6}/.claude/commands/sweep-accuracy.md

@@ -67,11 +67,13 @@ slope,2026-03-28,1042,HIGH,1;3,"optional single-line notes"
 - `notes` is CSV-quoted; newlines must be flattened to spaces on write so
   every module stays exactly one line.
 
-The file is registered with `merge=union` in `.gitattributes`, so two
-parallel sweeps touching different modules auto-merge without conflict.
-A transient duplicate-row state can occur after a merge if both branches
-modified the same module; the read-update-write cycle in step 5 keys rows
-by `module` and last-write-wins, so the next write cleans up.
+The file uses git's default 3-way text merge (no `merge=union`; see
+issue #2754). Two parallel sweeps that touch the CSV surface a normal
+merge conflict rather than silently unioning duplicate rows. Resolve a
+conflict by keeping one row per `module` (latest `last_inspected` wins),
+a single header, and one physical line per record -- or just re-run the
+read-update-write cycle in step 5, which rewrites the whole canonical
+file.
 
 ## Step 3 -- Score each module
 
@@ -264,8 +266,8 @@ If CUDA_AVAILABLE is false:
    }
 
    def _oneline(v):
-       # merge=union is line-based: a newline inside a quoted field splits
-       # the record on parallel-agent merges. Force one physical line per
+       # Git merges these CSVs line by line, so a newline inside a quoted
+       # field splits the record on a merge. Force one physical line per
        # record by collapsing embedded newlines to " | ".
        return "" if v is None else str(v).replace("\r\n", " | ").replace("\r", " | ").replace("\n", " | ")
 
@@ -324,10 +326,11 @@ To reset all tracking: `/sweep-accuracy --reset-state`
 - Do NOT modify any source files directly. Subagents handle fixes via /rockout.
 - Keep the output concise -- the table and agent dispatch are the deliverables.
 - If $ARGUMENTS is empty, use defaults: top 3, no category filter, no exclusions.
-- State file (`.claude/sweep-accuracy-state.csv`) is tracked in git, with
-  `merge=union` set in `.gitattributes` so parallel sweeps touching
-  different modules auto-merge. Subagents must `git add` and commit it so
-  the state update lands in the PR.
+- State file (`.claude/sweep-accuracy-state.csv`) is tracked in git and uses git's
+  default 3-way text merge (no `merge=union`; see issue #2754), so a
+  concurrent change surfaces a conflict instead of silently unioning
+  duplicate rows. Subagents must `git add` and commit it so the state
+  update lands in the PR.
 - For subpackage modules (geotiff, reproject, hydro), the subagent should read
   ALL `.py` files in the subpackage directory, not just `__init__.py`.
 - Only flag patterns that are ACTUALLY present in the code. Do not report

{xarray_spatial-0.10.4 → xarray_spatial-0.10.6}/.claude/commands/sweep-api-consistency.md

@@ -62,7 +62,10 @@ module,last_inspected,issue,severity_max,categories_found,notes
 slope,2026-05-01,1042,HIGH,1;3,"optional single-line notes"
 ```
 
-The file is registered with `merge=union` in `.gitattributes`.
+This file uses git's default 3-way text merge (no `merge=union`; see
+issue #2754), so a concurrent change surfaces a normal conflict instead
+of silently unioning duplicate rows. Keep one row per `module`, a single
+header, and one physical line per record when resolving.
 
 ## Step 3 -- Score each module
 
@@ -239,8 +242,8 @@ If CUDA_AVAILABLE is false:
    }
 
    def _oneline(v):
-       # merge=union is line-based: a newline inside a quoted field splits
-       # the record on parallel-agent merges. Force one physical line per
+       # Git merges these CSVs line by line, so a newline inside a quoted
+       # field splits the record on a merge. Force one physical line per
        # record by collapsing embedded newlines to " | ".
        return "" if v is None else str(v).replace("\r\n", " | ").replace("\r", " | ").replace("\n", " | ")
 
@@ -285,7 +288,9 @@ To reset: `/sweep-api-consistency --reset-state`
 - If $ARGUMENTS is empty, use defaults: top 3, no category filter, no
   exclusions.
 - State file (`.claude/sweep-api-consistency-state.csv`) is tracked in
-  git with `merge=union`.
+  git and uses git's default 3-way text merge (no `merge=union`; see
+  issue #2754), so a concurrent change surfaces a conflict instead of
+  silently unioning duplicate rows.
 - Renames are breaking. The fix path is a deprecation shim, not a
   hard rename, unless the function has a clearly orphan/private status.
 - False positives are worse than missed issues.

{xarray_spatial-0.10.4 → xarray_spatial-0.10.6}/.claude/commands/sweep-metadata.md

@@ -68,11 +68,13 @@ slope,2026-05-01,1042,HIGH,1;3,"optional single-line notes"
 - `notes` is CSV-quoted; newlines must be flattened to spaces on write so
   every module stays exactly one line.
 
-The file is registered with `merge=union` in `.gitattributes`, so two
-parallel sweeps touching different modules auto-merge without conflict.
-A transient duplicate-row state can occur after a merge if both branches
-modified the same module; the read-update-write cycle in step 5 keys rows
-by `module` and last-write-wins, so the next write cleans up.
+The file uses git's default 3-way text merge (no `merge=union`; see
+issue #2754). Two parallel sweeps that touch the CSV surface a normal
+merge conflict rather than silently unioning duplicate rows. Resolve a
+conflict by keeping one row per `module` (latest `last_inspected` wins),
+a single header, and one physical line per record -- or just re-run the
+read-update-write cycle in step 5, which rewrites the whole canonical
+file.
 
 ## Step 3 -- Score each module
 
@@ -267,8 +269,8 @@ If CUDA_AVAILABLE is false:
    }
 
    def _oneline(v):
-       # merge=union is line-based: a newline inside a quoted field splits
-       # the record on parallel-agent merges. Force one physical line per
+       # Git merges these CSVs line by line, so a newline inside a quoted
+       # field splits the record on a merge. Force one physical line per
        # record by collapsing embedded newlines to " | ".
        return "" if v is None else str(v).replace("\r\n", " | ").replace("\r", " | ").replace("\n", " | ")
 
@@ -325,9 +327,10 @@ To reset all tracking: `/sweep-metadata --reset-state`
   the deliverables.
 - If $ARGUMENTS is empty, use defaults: top 3, no category filter, no
   exclusions.
-- State file (`.claude/sweep-metadata-state.csv`) is tracked in git, with
-  `merge=union` set in `.gitattributes` so parallel sweeps touching
-  different modules auto-merge.
+- State file (`.claude/sweep-metadata-state.csv`) is tracked in git and uses
+  git's default 3-way text merge (no `merge=union`; see issue #2754), so a
+  concurrent change surfaces a conflict instead of silently unioning
+  duplicate rows.
 - For subpackage modules (geotiff, reproject, hydro), the subagent should
   read ALL `.py` files in the subpackage directory, not just `__init__.py`.
 - Only flag patterns that are ACTUALLY present in the code.

{xarray_spatial-0.10.4 → xarray_spatial-0.10.6}/.claude/commands/sweep-performance.md

@@ -89,11 +89,13 @@ slope,2026-04-15,SAFE,compute-bound,0,,"optional single-line notes"
 - `notes` is CSV-quoted; newlines must be flattened to spaces on write so
   every module stays exactly one line.
 
-The file is registered with `merge=union` in `.gitattributes`, so two
-parallel sweeps touching different modules auto-merge without conflict.
-A transient duplicate-row state can occur after a merge if both branches
-modified the same module; the read-update-write cycle in the agent prompt
-keys rows by `module` and last-write-wins, so the next write cleans up.
+The file uses git's default 3-way text merge (no `merge=union`; see
+issue #2754). Two parallel sweeps that touch the CSV surface a normal
+merge conflict rather than silently unioning duplicate rows. Resolve a
+conflict by keeping one row per `module` (latest `last_inspected` wins),
+a single header, and one physical line per record -- or just re-run the
+read-update-write cycle in the agent prompt, which rewrites the whole
+canonical file.
 
 ### Compute scores
 
@@ -290,8 +292,8 @@ If CUDA_AVAILABLE is false:
    }
 
    def _oneline(v):
-       # merge=union is line-based: a newline inside a quoted field splits
-       # the record on parallel-agent merges. Force one physical line per
+       # Git merges these CSVs line by line, so a newline inside a quoted
+       # field splits the record on a merge. Force one physical line per
        # record by collapsing embedded newlines to " | ".
        return "" if v is None else str(v).replace("\r\n", " | ").replace("\r", " | ").replace("\n", " | ")
 
@@ -353,10 +355,11 @@ To reset all tracking: `/sweep-performance --reset-state`
   the deliverables.
 - If $ARGUMENTS is empty, use defaults: top 3, no category filter, no
   exclusions.
-- State file (`.claude/sweep-performance-state.csv`) is tracked in git, with
-  `merge=union` set in `.gitattributes` so parallel sweeps touching
-  different modules auto-merge. Subagents must `git add` and commit it so
-  the state update lands in the PR.
+- State file (`.claude/sweep-performance-state.csv`) is tracked in git and uses git's
+  default 3-way text merge (no `merge=union`; see issue #2754), so a
+  concurrent change surfaces a conflict instead of silently unioning
+  duplicate rows. Subagents must `git add` and commit it so the state
+  update lands in the PR.
 - For subpackage modules (geotiff, reproject, hydro), the subagent reads ALL
   `.py` files in the subpackage directory, not just `__init__.py`.
 - Only flag patterns that are ACTUALLY present in the code. Do not report

{xarray_spatial-0.10.4 → xarray_spatial-0.10.6}/.claude/commands/sweep-security.md

@@ -71,11 +71,13 @@ cost_distance,2026-04-10,1150,HIGH,1;2,,"optional single-line notes"
 - `notes` is CSV-quoted; newlines must be flattened to spaces on write so
   every module stays exactly one line.
 
-The file is registered with `merge=union` in `.gitattributes`, so two
-parallel sweeps touching different modules auto-merge without conflict.
-A transient duplicate-row state can occur after a merge if both branches
-modified the same module; the read-update-write cycle in step 5 keys rows
-by `module` and last-write-wins, so the next write cleans up.
+The file uses git's default 3-way text merge (no `merge=union`; see
+issue #2754). Two parallel sweeps that touch the CSV surface a normal
+merge conflict rather than silently unioning duplicate rows. Resolve a
+conflict by keeping one row per `module` (latest `last_inspected` wins),
+a single header, and one physical line per record -- or just re-run the
+read-update-write cycle in step 5, which rewrites the whole canonical
+file.
 
 ## Step 3 -- Score each module
 
@@ -265,8 +267,8 @@ If CUDA_AVAILABLE is false:
    }
 
    def _oneline(v):
-       # merge=union is line-based: a newline inside a quoted field splits
-       # the record on parallel-agent merges. Force one physical line per
+       # Git merges these CSVs line by line, so a newline inside a quoted
+       # field splits the record on a merge. Force one physical line per
        # record by collapsing embedded newlines to " | ".
        return "" if v is None else str(v).replace("\r\n", " | ").replace("\r", " | ").replace("\n", " | ")
 
@@ -323,10 +325,11 @@ To reset all tracking: `/sweep-security --reset-state`
 - Do NOT modify any source files directly. Subagents handle fixes via /rockout.
 - Keep the output concise -- the table and agent dispatch are the deliverables.
 - If $ARGUMENTS is empty, use defaults: top 3, no category filter, no exclusions.
-- State file (`.claude/sweep-security-state.csv`) is tracked in git, with
-  `merge=union` set in `.gitattributes` so parallel sweeps touching
-  different modules auto-merge. Subagents must `git add` and commit it so
-  the state update lands in the PR.
+- State file (`.claude/sweep-security-state.csv`) is tracked in git and uses
+  git's default 3-way text merge (no `merge=union`; see issue #2754), so a
+  concurrent change surfaces a conflict instead of silently unioning
+  duplicate rows. Subagents must `git add` and commit it so the state
+  update lands in the PR.
 - For subpackage modules (geotiff, reproject, hydro), the subagent should read
   ALL `.py` files in the subpackage directory, not just `__init__.py`.
 - Only flag patterns that are ACTUALLY present in the code. Do not report

{xarray_spatial-0.10.4 → xarray_spatial-0.10.6}/.claude/commands/sweep-style.md

@@ -58,12 +58,13 @@ slope,2026-05-01,1042,MEDIUM,1;4,"optional single-line notes"
 - `notes` is CSV-quoted; newlines must be flattened to spaces on write so
   every module stays exactly one line.
 
-The file is covered by the `.claude/sweep-*-state.csv merge=union` rule in
-`.gitattributes`, so two parallel sweeps touching different modules
-auto-merge without conflict. A transient duplicate-row state can occur
-after a merge if both branches modified the same module; the
-read-update-write cycle in step 5 keys rows by `module` and last-write-wins,
-so the next write cleans up.
+The file uses git's default 3-way text merge (no `merge=union`; see
+issue #2754). Two parallel sweeps that touch the CSV surface a normal
+merge conflict rather than silently unioning duplicate rows. Resolve a
+conflict by keeping one row per `module` (latest `last_inspected` wins),
+a single header, and one physical line per record -- or just re-run the
+read-update-write cycle in step 5, which rewrites the whole canonical
+file.
 
 ## Step 3 -- Score each module
 
@@ -302,10 +303,11 @@ To reset all tracking: `/sweep-style --reset-state`
 - Do NOT modify any source files directly. Subagents handle fixes via /rockout.
 - Keep the output concise -- the table and agent dispatch are the deliverables.
 - If $ARGUMENTS is empty, use defaults: top 3, no category filter, no exclusions.
-- State file (`.claude/sweep-style-state.csv`) is tracked in git, covered by
-  the `.claude/sweep-*-state.csv merge=union` rule in `.gitattributes` so
-  parallel sweeps touching different modules auto-merge. Subagents must
-  `git add` and commit it so the state update lands in the PR.
+- State file (`.claude/sweep-style-state.csv`) is tracked in git and uses
+  git's default 3-way text merge (no `merge=union`; see issue #2754), so a
+  concurrent change surfaces a conflict instead of silently unioning
+  duplicate rows. Subagents must `git add` and commit it so the state
+  update lands in the PR.
 - For subpackage modules (geotiff, reproject, hydro), the subagent should run
   flake8 + isort across ALL `.py` files in the subpackage directory, not
   just `__init__.py`.

{xarray_spatial-0.10.4 → xarray_spatial-0.10.6}/.claude/commands/sweep-test-coverage.md

@@ -63,7 +63,10 @@ module,last_inspected,issue,severity_max,categories_found,notes
 slope,2026-05-01,1042,HIGH,1;3,"optional single-line notes"
 ```
 
-`merge=union` is set in `.gitattributes`.
+This file uses git's default 3-way text merge (no `merge=union`; see
+issue #2754), so a concurrent change surfaces a normal conflict instead
+of silently unioning duplicate rows. Keep one row per `module`, a single
+header, and one physical line per record when resolving.
 
 ## Step 3 -- Score each module
 
@@ -240,8 +243,8 @@ If CUDA_AVAILABLE is false:
    }
 
    def _oneline(v):
-       # merge=union is line-based: a newline inside a quoted field splits
-       # the record on parallel-agent merges. Force one physical line per
+       # Git merges these CSVs line by line, so a newline inside a quoted
+       # field splits the record on a merge. Force one physical line per
        # record by collapsing embedded newlines to " | ".
        return "" if v is None else str(v).replace("\r\n", " | ").replace("\r", " | ").replace("\n", " | ")
 
@@ -287,7 +290,9 @@ To reset: `/sweep-test-coverage --reset-state`
 - Keep parent output concise.
 - Default: top 3, no filter.
 - State file `.claude/sweep-test-coverage-state.csv` is tracked in git
-  with `merge=union`.
+  and uses git's default 3-way text merge (no `merge=union`; see issue
+  #2754), so a concurrent change surfaces a conflict instead of silently
+  unioning duplicate rows.
 - The "fix" is *tests, not source*. If a test reveals a bug, file a
   separate issue — do not change source in this sweep's PRs.
 - False positives are worse than missed issues.

xarray_spatial-0.10.6/.claude/sweep-style-state.csv

@@ -0,0 +1,15 @@
+module,last_inspected,issue,severity_max,categories_found,notes
+aspect,2026-05-29,2683,MEDIUM,1,E402+E305 line 38: from xrspatial.geodesic import block sat below _geodesic_cuda_dims; moved up with top-of-file imports. E501 lines 219/263: wrapped two _run_gpu_geodesic_aspect kernel-launch calls (101/109 chars). Cat 4 isort reviewed but NOT applied: slope.py/curvature.py use one-import-per-line for xrspatial.utils so raw isort would make aspect inconsistent. Cat 2/3/5 grep clean. PR #2740. 82 aspect+geodesic tests pass.
+contour,2026-05-29,2698,HIGH,3,"F821 line 557: contours() return annotation ""gpd.GeoDataFrame"" referenced gpd not bound at module scope (only imported inside _to_geopandas). Fixed via TYPE_CHECKING-guarded import geopandas as gpd, matching polygonize.py. No runtime change; geopandas stays optional. isort clean. Cat 1/2/4/5 clean. 24 contour tests pass. PR open."
+focal,2026-05-29,2731,HIGH,3;4;5,"F401 not_implemented_func (import line 36, unused, not re-exported). isort: stdlib reorder (import math before from-imports), dropped stray blank lines in import groups, alphabetised+rewrapped convolution/utils from-imports, moved dataset_support import into order. Cat 5: mutable default excludes=[np.nan] in mean() (line 238) -> None sentinel, resolved to [np.nan] in body; never mutated so behaviour preserved; regression test test_mean_default_excludes_does_not_leak added. Cat 1/2 clean. 115 focal tests pass. PR pending."
+geotiff,2026-05-27,2481,HIGH,1;3;4,"Bundled 387 flake8 + ~30 isort fixes since #2285/#2430. F401 x9, F811 x6, F841 x3. E501 x250 (mostly wrapped, 3 file-scope imports keep noqa: E402+E501). E252 x62, blank-line cluster, E128/E127 indents. importorskip imports use # noqa: E402. Cat 5 grep clean."
+hydro-d8,2026-05-29,2705,HIGH,1;3;4,"flake8+isort over the 13 D8 files only (dinf/mfd out of scope). Cat 3 HIGH: F401 x2 (flow_length_d8 function-local _compute_accum_seeds never called; snap_pour_point_d8 module-level cuda_args unused) - both confirmed dead, no re-export. Cat 1: E127/E128 continuation-indent x90 (mostly multi-line def signatures); E302/E303 blank-line cluster in watershed_d8; E501 x4 (flow_path_d8 + snap_pour_point_d8, wrapped ternaries). Cat 4: isort import-block reordering on all 13 files. No Cat 2 (W-codes), no Cat 5 (grep clean: no bare except, mutable defaults, ==None/==True, or shadowed builtins). flake8+isort clean after fix; 385 D8 tests pass. flow_direction_d8 needed manual blank-line placement to satisfy both isort and E302."
+interpolate-kriging,2026-06-04,2916,MEDIUM,1;4,"flake8 E128 x2: continuation-line under-indent at the _chunk_var kriging-predict calls in _kriging_dask_numpy (L234) and _kriging_dask_cupy (L324); re-indented to visual-indent column. Cat 4 isort: 5-line from xrspatial.utils (...) block collapses to one 88-char line under line_length=100. Cat 2/3/5 grep clean (no W-codes, F-codes, bare except, mutable defaults, ==None/True, or shadowed builtins). flake8+isort clean after fix; 14 kriging tests pass. PR open."
+polygonize,2026-05-27,2534,HIGH,1;3;4,"F401 line 58 (is_cupy_array unused, not re-exported). E127 lines 83/88 (overload continuation indent in generated_jit). isort: 5-line .utils import block collapses to one line at 100-char limit. Cat 2 clean. Cat 5 grep clean."
+proximity,2026-05-29,2725,HIGH,1;3;4;5,"F841 line 1274 original_chunks dead local in unbounded dask+cupy branch (refactor leftover). Cat 5 mutable default target_values: list = [] in proximity/allocation/direction -> None sentinel, normalized to [] in body (never mutated, behaviour preserved). E128 line 291 np.where continuation under-indent in _vectorized_calc_direction. isort: re-sorted xrspatial import block + blank line after inline import cupy as cp. flake8+isort clean after fix; 69 proximity tests pass + new parametrized regression test. Pre-existing E127 (test_proximity.py 726/752) + test-file isort drift left untouched (out of module scope)."
+rasterize,2026-05-27,2503,HIGH,1;3,F401 line 15 + F811 line 1193 (paired: local import warnings shadowed unused module-level import); E306 line 1775 (nested @cuda.jit). isort clean. Cat 5 grep clean. Fix in PR #2507.
+reproject,2026-06-08,3049,HIGH,1;2;3;4,"flake8 baseline 57 across the 10 reproject files. Cat 3 HIGH: F401 'numpy as np' unused in _projections_cuda.py; F841 nine dead locals in _projections.py (e12, m2 chained-assign, phi_approx, a, two half_e, t_90, south_f, Q) - all assigned-never-read, math unchanged. Cat 1: E702 semicolon statements split (_projections.py + _projections_cuda.py Clenshaw loops); E127/E128 continuation indents fixed across both files; E302 blank line added in _itrf.py and _projections.py; E501 x3 wrapped. Two dense polynomial-coefficient continuation lines in _projections.py keep noqa: E128 (visual-indent alignment hits col 60 -> E501). Cat 2: W391 trailing blank removed from _projections.py. Cat 4 isort: _grid.py/_merge.py blank-line trim + deferred-import re-sort in _projections_cuda.py. Cat 5 grep clean (d: dict annotation is not a shadow; no bare except / mutable defaults / ==None,True,False). flake8+isort clean after fix; 435 reproject tests pass on numpy/dask/cupy. PR open."
+resample,2026-05-27,2543,MEDIUM,4,isort drift only: 4 multi-line parenthesised imports collapsed to single/one-per-line under line_length=100 (top-of-file scipy.ndimage + xrspatial.utils; local cupyx imports in _nan_aware_interp_cupy and _interp_block_cupy); two blank-line nits after import math in _run_dask_numpy/_run_dask_cupy. flake8 clean. Cat 5 grep clean. 169 resample tests pass.
+slope,2026-05-29,2685,HIGH,1;3;4,"F401 line 26 (VALID_BOUNDARY_MODES unused, not re-exported). E402+E305 line 48 (geodesic import block sat after _geodesic_cuda_dims; moved up to top-of-file imports). E501 line 260 (cupy kernel launch, 108 chars) wrapped. isort: consolidated/regrouped xrspatial imports (dataset_support, geodesic, utils). Cat 2 clean. Cat 5 grep clean. 41 slope + 21 geodesic_slope tests pass."
+viewshed,2026-05-29,2690,HIGH,1;4;5,"flake8 E127 x2 (L2013-2014 _viewshed_distance_sweep sig); isort .utils import reflow; shadowed builtin id->node_id (L1409,1474). Fixed via /rockout PR. No behavioural change."
+zonal,2026-05-27,2522,HIGH,1;3;4,"F401 not_implemented_func (line 42, only present on import line). E501 line 455 (dd.concat one-liner, 117 chars) wrapped across 3 lines. isort: consolidated xrspatial.utils block (merged has_dask_array, dropped not_implemented_func, alphabetised, trimmed extra blank line). Cat 5 grep clean. 125 zonal tests pass."

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

@@ -0,0 +1,16 @@
+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-06-08,2704;2710;3044,MEDIUM,1;2,"Pass 2 (2026-06-08, deep-sweep test-coverage): re-swept on a CUDA host. Verified issue #2704 is CLOSED (fixed 2026-06-01 via #2749, kernel now uses np.isfinite at contour.py:73-74); the two prior xfail(strict) #2704 pins were already flipped to plain passing assertions in TestInfHandling (test_inf_corner_no_nan_coords / test_neg_inf_corner_no_nan_coords) -- no stale xfail remained. Found one MEDIUM Cat 1+2 gap: no cross-backend parity test fed NaN input -- TestBackendEquivalence uses elevation_raster_no_nans and test_partial_nan is numpy-only, so numpy-interior NaN-skip vs dask NaN-halo (da.overlap) parity at chunk edges was unpinned. Filed #3044, added TestNaNBackendParity (3 tests: dask, cupy, dask+cupy each assert _segments_by_level equality vs numpy on a partial-NaN ramp with a NaN edge row + interior NaN cell inside a non-edge chunk). All 3 RAN and PASSED on a CUDA host; full file 89 passed, 0 skipped. Probed and verified now-resolved: the prior-pass LOW items are no longer real gaps -- the levels=None all-NaN early-return IS asserted (result==[]) on all 4 backends (numpy L148/dask L163/cupy L178/dask+cupy L194) plus geopandas (test_geopandas_all_nan_keeps_crs). LOW (documented, NOT fixed): non-square cellsize (res[0]!=res[1]) still never exercised -- all tests use create_test_raster res (0.5,0.5); probed live that anisotropic coords transform correctly (y scaled 2.0, x scaled 0.5 -> crossing x=1.25, y spans 0..8), works, so it is a LOW coverage gap not a bug. Cat 3 1x1/Nx1/1xN remain rejected by the >=2x2 guard (tested). Test-only PR for #3044; contour.py untouched. | 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
+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-06-08,2618;3050,HIGH,3;4,"Pass 2026-06-08 (deep-sweep test-coverage): #3050 closes the one live gap found this pass. reproject()'s dask+cupy backend was parity-tested only with resampling='cubic' (TestCupyPyprojFallbackParity::test_projected_to_projected_dask_cupy_match); nearest/bilinear were covered on numpy (end-to-end) and eager cupy (parametrized test_projected_to_projected_numpy_cupy_match) but never on the dask+cupy chunk-assembly path. Parametrized that test over ['nearest','bilinear','cubic']; all 3 RUN+PASS on a CUDA host. Cat 4 MEDIUM (resampling-mode parameter coverage on the dask+cupy backend). Test-only, source untouched. Re-confirmed _merge.merge() has NO genuine cupy/dask+cupy backend (_merge_inmemory/_merge_dask use _merge_arrays_numpy + raster.values; _merge_arrays_cupy is imported but never dispatched = dead code, not a test gap) matching the prior pass's observation. reproject() otherwise saturated across all 4 backends, NaN/Inf/all-NaN, degenerate shapes, metadata, vertical, bounds_policy, integer nodata. LOW (documented, not filed): dask+cupy resampling-mode parity is the only per-mode-per-backend cell that had been missing. || PREVIOUS: 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.6/.cursor/rules/backend-parity.mdc

@@ -0,0 +1,68 @@
+---
+description: "Verify that all implemented backends produce consistent results for a given function or set of functions"
+globs: "*.py"
+---
+
+# Backend Parity: Cross-Backend Consistency Audit
+
+Verify that all implemented backends produce consistent results for a given function or set of functions.
+
+## Step 1 -- Identify targets
+
+1. If the prompt names specific functions (e.g. `slope`, `aspect`), use those.
+2. If the prompt names a category (e.g. `hydrology`, `surface`, `focal`), read `README.md` to find all functions in that category.
+3. If the prompt is empty, 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.
+
+## 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
+- **Dirty:** 5-10% random NaN, some extreme values near dtype limits
+
+Use `np.random.default_rng(42)` for reproducibility. Test with at least `float32` and `float64`.
+
+## Step 3 -- Run every backend
+
+1. **NumPy:** `create_test_raster(data, backend='numpy')` -- always the baseline.
+2. **Dask+NumPy:** test with two chunk configurations: even split and 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.
+
+## Step 4 -- Pairwise comparison
+
+For every non-NumPy result, compare against the NumPy baseline. Extract data:
+- Dask: `.data.compute()`
+- CuPy: `.data.get()`
+- Dask+CuPy: `.data.compute().get()`
+
+Compute: absolute difference, relative difference, NaN mask agreement, metadata preservation.
+
+Pass/fail thresholds:
+- NumPy vs Dask+NumPy: rtol=1e-5, atol=0
+- NumPy vs CuPy: rtol=1e-6, atol=1e-6
+- NumPy vs Dask+CuPy: rtol=1e-6, atol=1e-6
+
+A comparison fails if max_abs > atol AND max_rel > rtol, or if NaN masks disagree.
+
+## Step 5 -- Chunk boundary analysis
+
+For any Dask comparison that fails, identify which cells diverge and map them to chunk boundaries. Report what percentage of divergent cells are at chunk boundaries vs interior.
+
+## Step 6 -- Generate the report
+
+Print a structured report with: functions tested, parity matrix table, failures with root cause analysis, and summary counts.
+
+## General rules
+
+- Do not modify any source or test files. This rule is read-only.
+- Use `create_test_raster` from `general_checks.py` for all raster construction.
+- If CUDA is unavailable, skip CuPy and Dask+CuPy gracefully. Report as SKIPPED, not FAIL.

xarray_spatial-0.10.6/.cursor/rules/bench.mdc

@@ -0,0 +1,51 @@
+---
+description: "Run ASV benchmarks for the current branch against main and report regressions and improvements"
+globs: "benchmarks/**/*.py"
+---
+
+# Bench: Local Performance Comparison
+
+Run ASV benchmarks for the current branch against main and report regressions and improvements.
+
+## Step 1 -- Identify what changed
+
+1. If the prompt names specific benchmark classes or functions, use those directly.
+2. If the prompt 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/`.
+3. If no benchmark exists for the changed code, note this 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.
+2. Verify the benchmarks directory exists at `benchmarks/`.
+3. Read `benchmarks/asv.conf.json` to confirm the project name and branch settings.
+
+## 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.
+
+## Step 4 -- Parse and interpret results
+
+Classify each result:
+- REGRESSION: Ratio > 1.2x
+- IMPROVED: Ratio < 0.8x
+- UNCHANGED: Between 0.8x and 1.2x
+
+## Step 5 -- Generate the report
+
+Print a table with benchmark name, main time, HEAD time, ratio, and status. List regressions with likely causes, improvements, missing benchmarks, and a recommendation.
+
+## Step 6 -- Suggest benchmark additions
+
+If changed functions have no benchmark coverage, describe what a new benchmark should test and ask the user whether to write it.
+
+## General rules
+
+- Always run benchmarks from the `benchmarks/` directory.
+- The regression threshold is 1.2x, matching `.github/workflows/benchmarks.yml`.
+- Do not modify any source, test, or benchmark files unless explicitly asked to write a benchmark.

xarray_spatial-0.10.6/.cursor/rules/dask-notebook.mdc

@@ -0,0 +1,58 @@
+---
+description: "Create a Jupyter notebook that sets up a Dask distributed LocalCluster and walks through an ETL workflow"
+globs: "*.ipynb"
+---
+
+# Dask ETL Notebook
+
+Create a Jupyter notebook that sets up a Dask distributed LocalCluster and walks through an ETL (Extract, Transform, Load) workflow.
+
+## Notebook structure
+
+1. Title + one-line description
+2. Overview (what the pipeline does, what you'll learn)
+3. Imports
+4. Cluster Setup -- create and inspect a LocalCluster + Client
+5. Extract -- load or generate source data as lazy Dask arrays
+6. Transform -- apply transformations (filtering, rechunking, computation)
+7. Load -- write results to disk (Zarr, Parquet, GeoTIFF)
+8. Cleanup -- close the client and cluster
+9. Summary + next steps
+
+## Cluster Setup
+
+Always use this pattern:
+```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 noting the dashboard link and that n_workers/memory_limit should be tuned.
+
+## Code conventions
+
+- **Lazy by default**: build the computation graph before calling .compute().
+- **Chunking**: explain chunk choices. Use explicit chunks=.
+- **Avoid full materialization mid-pipeline**: no .values or .compute() until the Load phase.
+- **Persist when reused**: if an intermediate result is used in multiple downstream steps, call client.persist().
+- **Cleanup**: always close the client and cluster at the end.
+
+## Data handling
+
+- Generate or load data lazily. Wrap numpy arrays with da.from_array(..., chunks=...).
+- For file-based sources, prefer xr.open_dataset with explicit chunks=.
+- For Load phase, prefer Zarr (to_zarr()) as default output format.
+
+## Checklist
+
+1. Pick a data domain from the prompt (or default to geospatial raster).
+2. Write the full cell sequence following the structure.
+3. Verify all code cells are syntactically correct and self-contained.
+4. Ensure the notebook cleans up after itself (cluster closed, temp files noted).