From 8a66805ca0295afcfb0fc6f72f35e04796751e04 Mon Sep 17 00:00:00 2001 From: hrodmn Date: Sat, 23 May 2026 06:39:30 -0500 Subject: [PATCH 1/5] feat: autoresolves nodata and dtype if not provided resolves #36 --- ARCHITECTURE.md | 20 +- README.md | 28 +- dev-docs/specs/auto-detect-dtype-nodata.md | 392 ++++++++++++--------- src/lazycogs/_core.py | 331 +++++++++++------ src/lazycogs/_mosaic_methods.py | 8 + tests/benchmarks/conftest.py | 8 + tests/benchmarks/test_regressions.py | 234 ++++++++++++ tests/test_core.py | 210 ++++++++--- tests/test_mosaic_methods.py | 13 + 9 files changed, 910 insertions(+), 334 deletions(-) create mode 100644 tests/benchmarks/test_regressions.py diff --git a/ARCHITECTURE.md b/ARCHITECTURE.md index 6227b6d..dbcd809 100644 --- a/ARCHITECTURE.md +++ b/ARCHITECTURE.md @@ -14,17 +14,17 @@ For large pre-existing STAC archives stored as hive-partitioned parquet director Work is split sharply into two phases. -**Phase 0 — open time** runs at `open()` call time. It does the minimum needed to build a fully-described lazy DataArray: one DuckDB query to discover bands, one DuckDB query to build the time axis, a small object-store access smoketest, and a grid computation. No pixel I/O happens. No dask task graph is built. A single `MultiBandStacBackendArray` is wrapped in an xarray `LazilyIndexedArray`. +**Phase 0 — open time** runs at `open()` call time. It does the minimum needed to build a fully-described lazy DataArray: one DuckDB query to inspect the first matching item, one DuckDB query to build the time axis, concurrent COG metadata opens for the requested bands, and a grid computation. No pixel windows are read. No dask task graph is built. A single `MultiBandStacBackendArray` is wrapped in an xarray `LazilyIndexedArray`. **Phase 1 — compute time** runs inside a dask worker when a chunk is actually computed. `MultiBandStacBackendArray.__getitem__` receives the exact `(band, time, y, x)` index for the chunk, derives the chunk's spatial footprint, queries DuckDB for only the COGs that overlap that footprint and time step, reads and reprojects all selected bands concurrently with `asyncio`, and mosaics the results. -This split means that `open()` is nearly instant even for large queries, and the DuckDB spatial filter runs once per chunk rather than over the entire bbox at open time. The one exception to the "metadata-only" story is the storage smoketest: `open()` issues a single `head()` against one representative asset so authentication and object-store wiring fail early with a clear error. +This split means that `open()` is nearly instant even for large queries, and the DuckDB spatial filter runs once per chunk rather than over the entire bbox at open time. The startup inspection is still deliberately small: one representative item and one `GeoTIFF.open(...)` per requested band, just enough to validate store access and infer the output dtype/nodata contract. ## Module overview ``` src/lazycogs/ - _core.py Entry point. open(), band discovery, time-step building. + _core.py Entry point. open(), representative-item inspection, dtype/nodata resolution, time-step building. _backend.py MultiBandStacBackendArray — xarray BackendArray implementation that bridges xarray indexing to chunk reads. _chunk_reader.py Async mosaic logic: open COGs, select overviews, read windows, reproject, mosaic. _executor.py Shared background loop and bounded executors. Exposes run_on_loop(). @@ -44,13 +44,17 @@ src/lazycogs/ 1. Resolves `duckdb_client`: if not provided, creates a plain `DuckdbClient()`. Validates that `href` ends in `.parquet`/`.geoparquet` when no client is supplied (a directory path is accepted when a custom client is passed). 2. Parses `time_period` into a `_TemporalGrouper` (see `_temporal.py`). 3. Converts `bbox` from the target CRS to EPSG:4326 using `pyproj.Transformer`. -4. Calls `_discover_bands()`: queries the parquet source via `duckdb_client.search(..., max_items=1)` to find asset keys. Assets with role `"data"` or media type `"image/tiff"` are returned first. -5. Calls `_smoketest_store()`: fetches one sample item from the parquet, resolves the store for a representative data asset HREF, and calls `GeoTIFF.open(path, store=...)` to confirm that the configured store satisfies the same read contract the real chunk reader uses. Raises `RuntimeError` immediately with a clear message if the store cannot reach the asset, so misconfiguration is surfaced at `open()` time rather than deferred to the first chunk read. +4. Calls `_inspect_first_item()`: queries the parquet source via `duckdb_client.search(..., max_items=1)` to fetch one representative item, resolves preferred data assets (or caller-requested `bands=`), and opens one COG per requested band concurrently through `run_on_loop(...)`. +5. Resolves the output contract from that inspection result: + - `bands`: explicit `bands=` wins, otherwise the inspected preferred-band order + - `dtype`: explicit `dtype=` wins, otherwise `_promote_dtypes(...)` + - `nodata`: explicit `nodata=` wins, otherwise `_resolve_output_nodata(...)` + - float-only mosaic methods (`MeanMethod`, `MedianMethod`, `StdevMethod`) fail early unless the resolved dtype is floating 6. Calls `_build_time_steps()`: queries the parquet source via `duckdb_client.search_to_arrow(...)` to obtain an Arrow table containing only the `datetime` and `start_datetime` columns (plus any filter/sort fields). Extracts timestamps from the Arrow columns without Python-level dict walking, buckets them with the `_TemporalGrouper`, deduplicates, and returns sorted `(filter_strings, time_coords)` pairs. Only groups with at least one item produce a time step. 7. Calls `compute_output_grid()` to get the output affine transform and dimensions (width, height). No eager coordinate arrays are produced. 8. Creates a single `MultiBandStacBackendArray` (a dataclass) with shape `(band, time, y, x)` holding all the parameters needed to materialise any chunk later, then wraps it in one `xarray.core.indexing.LazilyIndexedArray`. This avoids `xr.concat` (used internally by `ds.to_array()`), which would eagerly load `LazilyIndexedArray`-backed objects. 9. Uses `rasterix.RasterIndex` for spatial indexing, but materialises the x/y coordinate variables eagerly as numpy arrays so chunked scalar spatial selections compute reliably. -10. Constructs the `xr.DataArray` directly from the 4-D variable. If `chunks` is provided, calls `.chunk(chunks)` to convert to a dask-backed array; otherwise the `LazilyIndexedArray` remains in play so narrow slices (e.g. a single pixel) translate to minimal I/O. +10. Constructs the `xr.DataArray` directly from the 4-D variable. If `chunks` is provided, calls `.chunk(chunks)` to convert to a dask-backed array; otherwise the `LazilyIndexedArray` remains in play so narrow slices (e.g. a single pixel) translate to minimal I/O. When output nodata is known, the returned array advertises it via `attrs["nodata"]`, `attrs["_FillValue"]`, and `attrs["missing_value"]`; when unknown, none of those attrs are attached. 11. Stores `_stac_backend` (the `MultiBandStacBackendArray` instance) and `_stac_time_coords` (the full time coordinate array) in `da.attrs` so that `da.lazycogs.explain()` can reconstruct the explain plan without re-specifying `open()` parameters. ## Explain: dry-run read estimator @@ -143,7 +147,7 @@ There are two load-bearing concurrency layers in a chunk read, plus dask as an o **Dask (optional, chunk level).** When a dask-backed DataArray is computed, dask dispatches chunk tasks to worker threads. Each worker thread calls `_sync_getitem()` in `_backend.py`, which uses `run_on_loop(_async_getitem(...))` to submit the chunk read to lazycogs' shared persistent background loop. Dask controls how many chunk tasks run at once; it does not create extra lazycogs event loops. -**One shared asyncio loop (I/O fan-out).** A single background event loop is created lazily and reused for every sync caller. Startup is only considered ready once that loop is actually running, so first-use sync bridge calls do not depend on thread scheduling luck. Inside `_async_getitem`, `asyncio.gather` fans out one `_run_one_date` coroutine per requested time step, and each time step uses `read_chunk_async` to fan out item reads under `asyncio.Semaphore(max_concurrent_reads)`. COG header reads and tile fetches from `async-geotiff` are all awaitable, so the loop multiplexes network I/O without blocking. DuckDB work never runs on the loop thread: `_search_items_async` and `_explain_async` both route queries through `run_duckdb(...)`, a small internal helper that applies a private submission bound before dispatching onto the DuckDB executor. The executor is still bounded (`max_workers=1` today), so DuckDB yields the event loop but still matches the effective single-connection serialization of the current client model. The current local benchmark fixture keeps DuckDB well below the U4 threshold for a separate client pool (1.9% of per-date chunk wall time on a small-bbox / many-time-step workload, 0.2% on a large-bbox / few-time-step workload), so the single-worker executor remains the intended design for now. +**One shared asyncio loop (I/O fan-out).** A single background event loop is created lazily and reused for every sync caller. Startup is only considered ready once that loop is actually running, so first-use sync bridge calls do not depend on thread scheduling luck. Inside `_async_getitem`, `asyncio.gather` fans out one `_run_one_date` coroutine per requested time step, and each time step uses `read_chunk_async` to fan out item reads under `asyncio.Semaphore(max_concurrent_reads)`. COG header reads and tile fetches from `async-geotiff` are all awaitable, so the loop multiplexes network I/O without blocking. DuckDB work never runs on the loop thread: `_search_items_async` and `_explain_async` both route queries through `run_duckdb(...)`, a small internal helper that applies a private submission bound before dispatching onto the DuckDB executor. The executor is still bounded (`max_workers=1` today), so DuckDB yields the event loop but still matches the effective single-connection serialization of the current client model. The current local benchmark fixture keeps DuckDB well below the U4 threshold for a separate client pool (1.9% of per-date chunk wall time on a small-bbox / many-time-step workload, 0.2% on a large-bbox / few-time-step workload), so the single-worker executor remains the intended design for now. That same prepared benchmark dataset also backs offline regression coverage in `tests/benchmarks/`, which keeps dtype/nodata contract tests off the network while exercising real local COGs. **One bounded reprojection thread pool (CPU work).** `_apply_bands_with_warp_cache` is synchronous CPU-bound work that processes all bands for one item together. `_read_item_band` dispatches it via `loop.run_in_executor(get_reproject_pool(), ...)`, so the event loop stays free while reprojections run on a shared bounded thread pool. The default bound is `min(os.cpu_count() or 1, 4)`, configurable before first use via `LAZYCOGS_REPROJECT_WORKERS`. That environment variable is read once when the pool is first created; later changes are ignored. The `warp_cache` is shared across coroutines; `compute_warp_map` is deterministic, so duplicate concurrent writes are safe. @@ -207,7 +211,7 @@ Each grouper provides three methods: `group_key()` maps a datetime string to a s - `FirstMethod`: Returns the first valid pixel seen. Short-circuits when all pixels are filled. - `HighestMethod` / `LowestMethod`: Tracks the running max / min across items. -- `MeanMethod` / `MedianMethod` / `StdevMethod`: Accumulates all arrays and reduces at the end. +- `MeanMethod` / `MedianMethod` / `StdevMethod`: Accumulates all arrays and reduces at the end. These methods advertise `requires_float = True`, so `open()` rejects inferred integer outputs unless the caller opts into a floating `dtype=`. - `CountMethod`: Counts valid (non-masked) observations per pixel. These are copied from `rio-tiler` (MIT licence, zero GDAL imports) to avoid pulling in rasterio as a transitive dependency. diff --git a/README.md b/README.md index fdd69e9..9606c37 100644 --- a/README.md +++ b/README.md @@ -72,8 +72,9 @@ await rustac.search_to( ) # Open a fully lazy (band, time, y, x) DataArray. No pixel data is read yet. -# lazycogs does perform a small storage-access smoketest here so auth or -# object-store misconfiguration fails early instead of on the first chunk read. +# lazycogs does inspect one representative item here: it picks preferred data +# assets, opens one COG per requested band concurrently, infers a default +# dtype, and advertises nodata only when the sampled bands agree on one. da = lazycogs.open( "items.parquet", bbox=dst_bbox, @@ -104,6 +105,26 @@ reading many chunks inside an already-running loop. `lazycogs.open(..., store=...)` accepts any store object that satisfies `async_geotiff.Store`. For most users, the recommended path is still obstore: leave `store=None` to auto-resolve per-asset stores, or call `lazycogs.store_for()` to build one explicitly. +## Dtype and nodata semantics + +When you omit `dtype=`, `lazycogs.open()` samples one representative COG per +requested band and infers one safe output dtype instead of defaulting to +`float32`. + +When you omit `nodata=`: + +- if sampled bands all agree on one scalar nodata sentinel, the returned + `DataArray` gets `attrs["nodata"]`, `attrs["_FillValue"]`, and + `attrs["missing_value"]` +- if sampled bands disagree, `open()` raises `ValueError` and asks you to pass + `nodata=` explicitly +- if sampled bands have no nodata sentinel, no nodata attrs are attached and + `0` remains only an implementation fill value for uncovered regions + +Float-only mosaic methods such as `MeanMethod`, `MedianMethod`, and +`StdevMethod` require a floating output dtype. If inference stays integer, +pass `dtype="float32"` or `dtype="float64"` explicitly. + ### Concurrency notes - Sync callers submit work to one shared persistent lazycogs event loop. @@ -116,6 +137,9 @@ For most users, the recommended path is still obstore: leave `store=None` to aut thread. On the local benchmark fixture, DuckDB stayed under 2% of per-date chunk wall time, so there is no separate per-thread DuckDB client pool today. +- `scripts/prepare_benchmark_data.py` also powers offline regression coverage + under `tests/benchmarks/`, so the contract tests run on local cached files + instead of live network reads. - If you need to construct a loop-bound resource for lazycogs internals, use `lazycogs.run_on_loop(...)`. - Low-level callers should use `await lazycogs.read_chunk_async(...)`. diff --git a/dev-docs/specs/auto-detect-dtype-nodata.md b/dev-docs/specs/auto-detect-dtype-nodata.md index 017c871..04c61e9 100644 --- a/dev-docs/specs/auto-detect-dtype-nodata.md +++ b/dev-docs/specs/auto-detect-dtype-nodata.md @@ -1,111 +1,139 @@ -# Spec: Auto-Detect dtype and nodata from Sample COGs in `lazycogs.open()` +# Spec: Auto-detect dtype and define nodata semantics in `lazycogs.open()` ## Context -Currently `lazycogs.open()` defaults to `float32` for both output `dtype` and `None` for `nodata`. The actual COG's internal nodata is used at chunk-read time if the user doesn't provide one, but the output DataArray is still `float32`. This is wasteful when all requested bands are integer types (e.g. `uint8` or `int16`). Users can override these defaults, but they must inspect the collection manually. +The concurrency refactor described in `TECH_DEBT.md` has landed. `open()` no longer needs to invent a short-lived event loop for startup inspection work; sync callers can reuse the shared lazycogs loop via `run_on_loop(...)`. -The library already queries the first matching item for band discovery (`_discover_bands`) and storage smoketesting (`_smoketest_store`). We can piggyback on this by opening one COG per requested band via `GeoTIFF.open` and extracting its dtype and nodata metadata with minimal overhead. +That makes it a good time to revisit `dtype` and `nodata` defaults together. -This spec replaces the internal `_discover_bands` / `_smoketest_store` split with a unified inspection helper and defines deterministic dtype promotion rules for multi-band reads. +Today `lazycogs.open()` still defaults the output array dtype to `float32` and the output `nodata` to `None` unless the caller overrides them. At chunk-read time, lazycogs already consults the COG's internal `geotiff.nodata` when `ctx.nodata` is `None`, so internal masking is often more correct than the output array contract. The gap is at the xarray boundary: callers cannot reliably inspect the returned `DataArray` and know what dtype or nodata semantics it represents. + +This spec does two things: + +1. Auto-detect the default output dtype from sample COGs. +2. Make the output nodata contract explicit and testable. ## Goals -- Automatically infer the output `dtype` from sample COGs when the caller does not explicitly pass `dtype=`. -- Automatically infer the output `nodata` value from sample COGs when the caller does not explicitly pass `nodata=`. -- Choose a single output dtype that can represent all requested bands without overflowing or losing precision. -- Keep `open()` latency acceptable (the sample hit should be done concurrently per-band from a single item). -- Reject incompatible configurations (`MeanMethod` / `MedianMethod` / `StdevMethod` paired with an integer dtype) with a clear `ValueError`. +- Infer the output `dtype` from sample COGs when the caller does not pass `dtype=`. +- Infer a single output `nodata` value when the caller does not pass `nodata=` and the sampled bands support a coherent scalar sentinel. +- Keep `open()` latency acceptable by sampling one matching item and opening one COG per requested band concurrently. +- Reject incompatible configurations such as float-required mosaic methods with an inferred integer dtype. +- Document exactly what the returned `DataArray` means when nodata is known, conflicting, or unknown. -## Non-Goals +## Non-goals -- Per-band dtype in the output DataArray (xarray requires a single dtype). -- Changing the existing explicit `dtype=` or `nodata=` behaviour (these remain user overrides). -- Sampling multiple items statistically (one item per band is enough for 99% of collections). +- Per-band dtype in the returned `DataArray`. +- Per-band nodata metadata in the returned `DataArray`. +- Returning masked xarray arrays instead of plain numeric arrays. +- Changing explicit `dtype=` or `nodata=` overrides. +- Solving semantic cloud masking or QA masking. -## Constraints & Assumptions +## Current behavior -- `async_geotiff.GeoTIFF.open` is available and fast enough for metadata-only access (no pixel reads). -- The first matching STAC item is representative of the collection's data types. Mixed-dtype collections are rare enough that sampling one item is sufficient. -- The asyncio event loop isn't running inside the main thread at `open()` time, so we'll need either synchronous metadata helpers or a short-lived event loop. -- The existing `_smoketest_store` and `_discover_bands` calls already hit the first item; we should merge these into a single helper to avoid redundant queries. +The current implementation has three different nodata layers: -## Architecture Overview +1. `open()` stores one scalar `nodata` value on the backend plan, defaulting to `None`. +2. `_chunk_reader.py` computes `effective_nodata = ctx.nodata if ctx.nodata is not None else geotiff.nodata` per asset read. +3. Internal mosaic methods operate on `MaskedArray`s built from `effective_nodata`. -``` -open() - └── _inspect_first_item() [replaces _discover_bands + _smoketest_store] - ├── DuckDB: first item query - ├── per-band: _resolve_store + GeoTIFF.open (concurrent) - └── returns _ItemInspection - ├── dtype inference - │ └── _promote_dtypes() - ├── nodata inference - ├── mosaic method / dtype validation - ├── _build_time_steps() - └── return DataArray -``` +A few consequences matter here: -A single inspection call yields: +- Source COG nodata is already respected for internal masking when the caller does not override it. +- Empty chunks and out-of-bounds reprojection pixels are filled with `ctx.nodata` when known, otherwise `0`. +- The returned `DataArray` does not currently expose a clear nodata contract. +- `float32` remains the output dtype default even for obviously integer collections. -1. Band order (data bands first, restricted by caller-provided `bands=`). -2. Sampled dtype per band. -3. Sampled nodata per band. -4. A store-connectivity flag. +## Proposed output contract -This replaces two separate internal helpers (`_discover_bands` and `_smoketest_store`) with one coherent pass, eliminating a redundant DuckDB query. +### 1. Returned arrays stay plain numeric arrays -## API / Interface Design +`lazycogs.open()` should continue to return a normal numeric `xr.DataArray`, not a masked array. Internal masking remains an implementation detail used while mosaicking overlapping inputs. -### Public API — `lazycogs.open()` +### 2. Nodata is a single scalar output sentinel when it is knowable -No signature changes. The `dtype` and `nodata` parameters remain optional: +When lazycogs can determine one scalar output nodata value, that value means: -```python -def open( - parquet_path: str, - *, - bbox: list[float] | None = None, - datetime: str | None = None, - filter: str | dict[str, Any] | None = None, - ids: list[str] | None = None, - bands: list[str] | None = None, - sortby: str | list[str | dict[str, str]] | None = None, - dtype: str | None = None, # still optional; now auto-detected when None - nodata: float | None = None, # still optional; now auto-detected when None - tilesize: int = 512, - resolution: float | None = None, - resolution_unit: str = "meters", - store: ObjectStore | None = None, - path_from_href: Callable[[str], str] | None = None, - mosaic_filter: MosaicFilter | None = None, - mosaic_method: type[MosaicMethodBase] = FirstMethod, - overviews: list[int] | None = None, - max_items: int = 100, - groupby_solar_day: bool = False, -) -> xr.DataArray: - ... -``` +- uncovered pixels in empty chunks +- out-of-bounds pixels introduced by reprojection +- pixels that remain invalid after mosaicking because every contributing input pixel was nodata + +When nodata is known, the returned `DataArray` should advertise it in attrs: + +- `nodata` +- `_FillValue` +- `missing_value` + +This is intentionally boring. It gives callers one obvious place to inspect and gives future serialization work a clear contract. + +### 3. Auto-detected nodata must be coherent, not guessed + +If the caller omits `nodata=`: + +- If all sampled non-`None` nodata values are identical, use that value. +- If all sampled nodata values are `None`, keep output nodata as `None`. +- If sampled bands disagree on non-`None` nodata values, raise `ValueError` and require the caller to pass `nodata=` explicitly. + +Do not silently pick the first nodata value. The output array only has room for one scalar sentinel, so conflicting sampled values are a real contract problem, not a warning-level detail. + +### 4. `nodata=None` remains allowed, but its meaning is narrow + +If output nodata is `None`, lazycogs is saying: + +- it does not know a scalar nodata sentinel for the returned array +- no nodata metadata is attached to the `DataArray` +- `0` may still appear in uncovered regions as an implementation fill value + +That last bullet is ugly but honest. In this mode, `0` is **not** declared as semantic nodata. If callers need a stable sentinel for downstream analysis, they must pass `nodata=` explicitly. + +This keeps the current runtime behavior while finally documenting it clearly. + +## Proposed dtype contract -Behavioural contract: +### Explicit override wins -- If `dtype` is passed, it is used exactly as before (user override). -- If `dtype` is omitted, `open()` samples one COG per requested band, extracts each band's native dtype, and promotes them to a single safe dtype via `_promote_dtypes()`. -- If `nodata` is passed, it is authoritative. -- If `nodata` is omitted, `open()` uses the first non-`None` nodata found among the sampled band COGs. If all sampled COGs report `None`, the DataArray's nodata stays `None`. +If the caller passes `dtype=`, lazycogs uses it exactly as today. -### Internal Data Model +### Auto-detect when omitted + +If `dtype` is omitted, `open()` samples one COG per requested band from the first matching item and promotes the sampled dtypes to one safe output dtype. + +### Promotion rules + +`_promote_dtypes()` should obey these rules in order: + +1. All identical -> return that dtype. +2. Any float present -> return `float32`, or `float64` if any sampled dtype is `float64`. +3. Mixed integer widths -> use the wider width when one dtype can safely contain the other. +4. Mixed unsigned/signed integers -> promote to the smallest signed dtype that can represent both ranges. +5. `uint64 + int64` -> raise `ValueError` because there is no wider integer type. + +Selected examples: + +| Unsigned | Signed | Promoted | +|---|---|---| +| `uint8` | `int8` | `int16` | +| `uint8` | `int16` | `int16` | +| `uint16` | `int16` | `int32` | +| `uint32` | `int32` | `int64` | +| `uint64` | `int64` | `ValueError` | + +## Startup inspection design + +The existing `_discover_bands` and `_smoketest_store` split should be replaced by one coherent inspection helper. + +### Internal model ```python @dataclass(frozen=True) class _ItemInspection: bands: list[str] - dtypes: dict[str, np.dtype] # per-band sample dtype - nodata_values: dict[str, float | None] # per-band sample nodata - store_check_passed: bool + dtypes: dict[str, np.dtype] + nodata_values: dict[str, float | None] item_found: bool ``` -### Internal Helpers +### Async helper ```python async def _inspect_first_item_async( @@ -118,148 +146,188 @@ async def _inspect_first_item_async( ids: list[str] | None = None, bands: list[str] | None = None, sortby: str | list[str | dict[str, str]] | None = None, - store: ObjectStore | None = None, + store: Store | None = None, path_from_href: Callable[[str], str] | None = None, ) -> _ItemInspection: ... +``` +### Sync wrapper -def _promote_dtypes(dtypes: list[np.dtype]) -> np.dtype: - """Return a single dtype that can safely hold all input dtypes.""" - ... +`open()` remains sync, so it should call a thin sync wrapper that uses `run_on_loop(...)` to execute `_inspect_first_item_async(...)` on the shared background loop. + +Do not use `asyncio.run` here. That was reasonable before the concurrency cleanup, but it is the wrong fit for the current architecture. + +### Inspection steps + +1. Query DuckDB for the first matching item. +2. If no item matches, return `item_found=False`. +3. Determine band order using the same current preference for `roles=["data"]` or TIFF-like assets. +4. Restrict to caller-provided `bands=` when present. +5. Resolve one asset HREF per requested band. +6. Resolve the store/path for each HREF. +7. Concurrently `await GeoTIFF.open(path, store=resolved_store)` for all requested bands. +8. Extract `geotiff.dtype` and `geotiff.nodata`. +9. Return `_ItemInspection`. + +This preserves the current fail-early store validation while eliminating redundant startup queries. + +## `open()` flow after the change + +```text +open() + └── _inspect_first_item() # replaces _discover_bands + _smoketest_store + ├── one DuckDB first-item query + └── concurrent GeoTIFF metadata opens on the shared loop + ├── resolve output bands + ├── resolve output dtype + ├── resolve output nodata + ├── validate mosaic method vs dtype + ├── _build_time_steps() + └── _build_dataarray() ``` -`_inspect_first_item_async` runs these steps: +Resolution rules inside `open()`: -1. Query DuckDB for the first item (same as `_discover_bands`). -2. If no items found, return an empty inspection (`item_found=False`). -3. Build band order (data bands first, fallback to all keys). -4. If `bands` is provided, restrict to the intersection. -5. For each requested band, resolve the asset `href`. -6. Call `_resolve_store(href, store, path_from_href)` for each band. -7. Concurrently `await GeoTIFF.open(path, store=resolved_store)` for each band. -8. Extract `geotiff.dtype` and `geotiff.nodata` from each result. -9. Return an `_ItemInspection` with all metadata. +- `bands` + - explicit `bands=` wins + - otherwise use `inspection.bands` +- `dtype` + - explicit `dtype=` wins + - otherwise `out_dtype = _promote_dtypes(...)` +- `nodata` + - explicit `nodata=` wins + - otherwise `out_nodata = _resolve_output_nodata(inspection.nodata_values)` -### Mosaic Method Contract +## Mosaic-method validation + +Some mosaic methods only make sense with floating-point output. + +Add a class attribute: ```python class MosaicMethodBase(ABC): requires_float: bool = False - ... ``` -`MeanMethod`, `MedianMethod`, and `StdevMethod` override `requires_float = True`. +Set `requires_float = True` on: + +- `MeanMethod` +- `MedianMethod` +- `StdevMethod` -During `open()`, after dtype is resolved: +Validation in `open()`: ```python -if mosaic_method_cls.requires_float and not np.issubdtype(out_dtype, np.floating): +if method_cls.requires_float and not np.issubdtype(out_dtype, np.floating): raise ValueError( - f"{mosaic_method_cls.__name__} requires a floating-point dtype, " - f"but got {out_dtype}. Pass dtype='float32' or dtype='float64' explicitly." + f"{method_cls.__name__} requires a floating-point dtype, " + f"but got {out_dtype}. Pass dtype='float32' or dtype='float64'." ) ``` -### Dtype Promotion Rules +## Integration with current chunk-read behavior -`_promote_dtypes` must obey these rules, in order: +The chunk-read path does not need a semantic rewrite. -1. **All identical** -> return that dtype (zero overhead). -2. **Any float present** -> return `float32`, or `float64` if `float64` is present. -3. **Mixed unsigned/signed integers** -> promote to signed with one extra bit when necessary. -4. **Mixed integer widths** -> use the wider width. +This line stays the source of truth for per-asset masking: -Promotion table (selected cases): +```python +effective_nodata = ctx.nodata if ctx.nodata is not None else geotiff.nodata +``` -| Unsigned | Signed | Promoted | -|----------|--------|----------| -| uint8 | int8 | int16 | -| uint8 | int16 | int16 | -| uint16 | int16 | int32 | -| uint32 | int32 | int64 | -| uint64 | int64 | `ValueError` (overflow) | -| uint8 | int64 | int64 | -| uint16 | uint32 | uint32 | -| int8 | int16 | int16 | +That means: -Rationale for blocking `uint64 + int64`: there is no wider signed integer type. Promoting to `float64` silently would lose integer semantics. We raise `ValueError` so the caller must explicitly opt into `float64` or choose a different representation. +- explicit user `nodata=` remains authoritative +- otherwise per-COG nodata still drives internal masking +- the new output-level nodata contract simply makes the xarray boundary honest -## Integration Points +What changes is the startup contract and metadata, not the basic masking algorithm. -### `_chunk_reader.py` +## DataArray attrs -The existing fallback logic remains unchanged: +When output nodata is known, `_build_dataarray()` should attach: ```python -effective_nodata = ctx.nodata if ctx.nodata is not None else geotiff.nodata +attrs["nodata"] = out_nodata +attrs["_FillValue"] = out_nodata +attrs["missing_value"] = out_nodata ``` -When the user provides `nodata`, it is authoritative at read time. When they don't, the per-COG nodata is consulted. The DataArray default nodata (now auto-detected) is used as the initial fill value in `_raw_getitem` and `async_mosaic_chunk`. +When output nodata is `None`, none of those attrs should be set. -Note: `async_mosaic_chunk` fills uncovered chunks with `0` when `nodata is None`. This is still safe because those pixels represent "no items covered this chunk," not "the COG declared these as nodata." +This spec does not require xarray encoding changes yet. -### DuckDB Client +## Failure modes -The inspection helper reuses the same DuckDB search pattern as `_discover_bands`. No query format changes. +Raise `ValueError` when: -### `async_geotiff` +- no matching STAC items exist +- sampled dtypes cannot be promoted safely (`uint64 + int64`) +- sampled nodata values conflict across requested bands and the caller did not pass `nodata=` +- a float-required mosaic method is paired with a non-floating output dtype -Metadata-only reads via `GeoTIFF.open` + reading `.dtype` and `.nodata`. No pixel buffers are fetched. +## Testing strategy -## Migration Path +### Unit tests -This is an internal refactor. `_discover_bands` and `_smoketest_store` are replaced by `_inspect_first_item` (sync wrapper) and deleted from the codebase. Callers of `open()` see no breaking change: explicit `dtype=` and `nodata=` behave exactly as before. Callers who previously relied on defaults will now see integer dtypes when the sampled COGs are integer, and more accurate nodata values. +Add focused unit coverage for: -## Testing Strategy +- `_promote_dtypes()` across integer and float combinations +- `_resolve_output_nodata()` for: + - all `None` + - one repeated scalar value + - conflicting scalar values +- `_inspect_first_item_async()` with mocked DuckDB + mocked `GeoTIFF.open` +- sync wrapper using `run_on_loop(...)` -### Unit Tests — `test_dtype_promotion.py` +### Integration tests -- `_promote_dtypes` for every pairwise combination of `uint8/16/32/64`, `int8/16/32/64`, `float32`, `float64`. -- Edge cases: single dtype list, empty list, overflowing `uint64 + int64`. +Add integration coverage for: -### Unit Tests — `_inspect_first_item` +- integer collection -> inferred integer dtype +- inferred nodata attached to `da.attrs` +- conflicting sampled nodata -> `ValueError` unless `nodata=` is passed +- `MeanMethod` with inferred integer dtype -> `ValueError` +- explicit `dtype="float32"` still works with float-required methods -- Mock DuckDB response + mock `GeoTIFF.open` coroutines. -- Verify concurrent opens (one per band). -- Verify `store_check_passed` flag. -- Verify empty result when no items match. +### Regression expectations -### Integration Tests +Existing behavior should remain true for: -- `open(..., mosaic_method=MeanMethod)` with auto-detected `int16` raises `ValueError`. -- `open(..., mosaic_method=FirstMethod)` with auto-detected `int16` succeeds. -- Real-world parquet: open a COG collection without passing `dtype` or `nodata`; assert the resulting DataArray has the expected dtype and nodata. -- Update existing tests that assert `dtype="float32"` to accept the new auto-detected values or pass `dtype="float32"` explicitly. +- per-COG nodata masking during mosaicking +- empty-chunk fill behavior +- reprojection fill behavior +- explicit caller overrides -### Regression Tests +## Decision log -- All existing tests continue to pass. +| Decision | Rationale | +|---|---| +| Use `run_on_loop(...)` instead of `asyncio.run(...)` | Matches the post-refactor concurrency model and avoids nested-loop nonsense. | +| Replace `_discover_bands` + `_smoketest_store` with one inspection helper | One startup query, one coherent control point. | +| Raise on conflicting sampled nodata values | One output array cannot honestly advertise multiple scalar sentinels. | +| Keep returning plain numeric arrays | Preserves the current API and avoids forcing xarray masked-array semantics into the public contract. | +| Treat `0` as implementation fill when output nodata is unknown | Matches current behavior without pretending it is semantic nodata. | -## Decision Log +## Open questions -| Decision | Options Considered | Rationale | -|----------|-------------------|-----------| -| Merge band discovery, smoketest, and metadata sampling into one helper (Option B) | Option A: extend `_smoketest_store` only | Avoids redundant DuckDB round-trips and keeps the flow coherent. `_smoketest_store` only touched one band anyway. | -| Custom integer promotion instead of `numpy.result_type` | Use `np.result_type` directly | Numpy promotes `uint16 + int16 -> float64`, which is overly conservative. A custom table preserves integer semantics in more cases. | -| Raise `ValueError` on `uint64 + int64` overflow | Silently promote to `float64` | Losing integer semantics silently is dangerous. The error forces an explicit `dtype=` override. | -| One item per band is sufficient | Statistical sampling across many items | Metadata-only COG opens are fast. Mixed-dtype collections within one band are extremely rare. One sample is the right latency/accuracy trade-off. | -| `requires_float` class attribute on `MosaicMethodBase` | Method-specific validation inside `open()` | A declarative attribute keeps `open()` logic generic and makes it easy for users to write custom mosaic methods that self-declare float requirements. | -| `asyncio.run` inside `open()` for concurrent metadata opens | Sequential sync opens | Concurrent opens cut latency linearly with band count. `open()` is typically a top-level call with no pre-existing event loop. | +- Should `CountMethod` force an integer output dtype when `dtype` is omitted, or should it continue to respect the generic promotion result? For now this spec leaves `CountMethod` alone. +- Should future serialization work move `_FillValue` / `missing_value` into xarray encoding as well as attrs? Probably yes, but that is out of scope here. +- If a collection has no source nodata and the user omits `nodata=`, should lazycogs eventually promote integer outputs to float and use `NaN` for uncovered pixels? That would be a larger behavioral change and is not part of this pass. -## Open Questions +## Recommended next implementation order -- **Jupyter event loop**: `asyncio.run` inside `open()` may clash with Jupyter's running event loop. If this surfaces, we may need to detect `get_running_loop()` and fall back to sequential opens or a thread-pool wrapper. -- **Per-item dtype variance**: If the first item is `uint8` but later items in the same collection are `int16`, the DataArray may overflow. This is documented as an assumed risk; users can override with `dtype=`. -- **Inspection caching**: Should repeated `open()` calls on the same parquet (different bboxes) cache the `_ItemInspection` result? Out of scope for the initial implementation, but a potential future optimization. +1. Add `_ItemInspection`, `_inspect_first_item_async`, and the sync wrapper. +2. Add `_promote_dtypes()` and `_resolve_output_nodata()`. +3. Wire startup inspection into `open()`. +4. Add `requires_float` validation to mosaic methods. +5. Set nodata attrs in `_build_dataarray()`. +6. Update `README.md` and `ARCHITECTURE.md` once behavior lands. ## Status -- [ ] Designing -- [ ] Approved -- ready to plan +- [x] Designing +- [x] Approved -- ready to implement - [ ] Implementing - [ ] Implemented - -## References - -- Plan document: `dev-docs/plans/dtypes.md` diff --git a/src/lazycogs/_core.py b/src/lazycogs/_core.py index e65b224..c320396 100644 --- a/src/lazycogs/_core.py +++ b/src/lazycogs/_core.py @@ -2,8 +2,10 @@ from __future__ import annotations +import asyncio import logging import time +from dataclasses import dataclass from typing import TYPE_CHECKING, Any, Self import numpy as np @@ -29,6 +31,7 @@ from async_geotiff import Store logger = logging.getLogger(__name__) +_INT_WIDTHS = (8, 16, 32, 64) class _CompactDateArray(np.ndarray): @@ -48,52 +51,40 @@ def __repr__(self) -> str: return self.__str__() -def _discover_bands( - parquet_path: str, - *, - duckdb_client: DuckdbClient, - bbox: list[float] | None = None, - datetime: str | None = None, - filter: str | dict[str, Any] | None = None, - ids: list[str] | None = None, - sortby: str | list[str | dict[str, str]] | None = None, -) -> list[str]: - """Return the asset keys present in the first matching item of the parquet file. +@dataclass(frozen=True) +class _ItemInspection: + """Sampled startup metadata from one representative STAC item.""" - Asset keys whose media type contains ``"image/tiff"`` or whose roles - include ``"data"`` are returned first; all others follow. + bands: list[str] + dtypes: dict[str, np.dtype] + nodata_values: dict[str, float | int | None] + item_found: bool - Args: - parquet_path: Path to a geoparquet file or hive-partitioned directory. - duckdb_client: ``DuckdbClient`` used to query the parquet source. - bbox: Bounding box ``[minx, miny, maxx, maxy]`` in EPSG:4326 to - filter the parquet before selecting a representative item. - datetime: RFC 3339 datetime or range to filter items. - filter: CQL2 filter expression (text string or JSON dict). - ids: List of STAC item IDs to restrict results to. - sortby: Sort keys forwarded to the DuckDB query. - Returns: - Ordered list of asset key strings. +class _StoreInspectionError(RuntimeError): + """Internal error carrying the HREF that failed startup inspection.""" - Raises: - ValueError: If no matching STAC items are found in the parquet file. + def __init__(self, href: str, original: BaseException) -> None: + super().__init__(str(original)) + self.href = href + self.original = original - """ - items = duckdb_client.search( - parquet_path, - max_items=1, - bbox=bbox, - datetime=datetime, - sortby=sortby, - filter=filter, - ids=ids, - include=list({"assets"}.union(_sortby_fields(sortby))), - ) - if not items: - raise ValueError(f"No STAC items found in {parquet_path!r}") - assets: dict[str, Any] = items[0].get("assets", {}) +def _ordered_bands( + assets: dict[str, Any], + *, + bands: list[str] | None = None, +) -> list[str]: + """Return asset keys in caller or preferred inspection order.""" + if bands is not None: + missing = [band for band in bands if band not in assets] + if missing: + raise ValueError( + "Requested bands " + f"{missing!r} were not present on the first matching item.", + ) + return bands + data_bands: list[str] = [] other_bands: list[str] = [] for key, asset in assets.items(): @@ -107,12 +98,7 @@ def _discover_bands( return data_bands or other_bands or list(assets) -async def _open_store_sample(path: str, *, store: Store) -> None: - """Open one representative asset through ``GeoTIFF.open`` for validation.""" - await GeoTIFF.open(path, store=store) - - -def _smoketest_store( +async def _inspect_first_item_async( parquet_path: str, *, duckdb_client: DuckdbClient, @@ -121,62 +107,99 @@ def _smoketest_store( filter: str | dict[str, Any] | None = None, ids: list[str] | None = None, bands: list[str] | None = None, + sortby: str | list[str | dict[str, str]] | None = None, store: Store | None = None, path_from_href: Callable[[str], str] | None = None, -) -> None: - """Verify the configured store can open a sample asset from the parquet. - - Fetches one item, resolves the store for a representative data asset HREF, - and validates it by calling ``GeoTIFF.open`` on the resolved path. Raises - ``RuntimeError`` if the store cannot reach the asset so misconfiguration is - caught at :func:`open` time rather than deferred to the first chunk read. - """ +) -> _ItemInspection: + """Inspect one representative item and sample metadata for requested bands.""" + filter_fields = _extract_filter_fields(filter) if filter else set() items = duckdb_client.search( parquet_path, max_items=1, bbox=bbox, datetime=datetime, + sortby=sortby, filter=filter, ids=ids, - include=["assets"], + include=list({"assets"}.union(filter_fields).union(_sortby_fields(sortby))), ) if not items: - return + return _ItemInspection( + bands=[], + dtypes={}, + nodata_values={}, + item_found=False, + ) assets: dict[str, Any] = items[0].get("assets", {}) - if not assets: - return - - href: str | None = None - if bands: - for key in bands: - h = assets.get(key, {}).get("href", "") - if h: - href = h - break - if not href: - data_keys = [ - k - for k, v in assets.items() - if "data" in v.get("roles", []) or "image/tiff" in v.get("type", "") - ] - key = data_keys[0] if data_keys else next(iter(assets)) - href = assets[key].get("href", "") - - if not href: - return - - resolved_store, path = resolve(href, store=store, path_fn=path_from_href) + resolved_bands = _ordered_bands(assets, bands=bands) + if not resolved_bands: + return _ItemInspection( + bands=[], + dtypes={}, + nodata_values={}, + item_found=True, + ) + + async def _inspect_band( + band: str, + ) -> tuple[str, np.dtype, float | int | None]: + href = assets[band].get("href", "") + if not href: + raise ValueError( + f"Asset {band!r} on the first matching item does not have an href.", + ) + resolved_store, path = resolve(href, store=store, path_fn=path_from_href) + try: + geotiff = await GeoTIFF.open(path, store=resolved_store) + except Exception as exc: + raise _StoreInspectionError(href, exc) from exc + return band, np.dtype(geotiff.dtype), geotiff.nodata + + results = await asyncio.gather(*[_inspect_band(band) for band in resolved_bands]) + return _ItemInspection( + bands=resolved_bands, + dtypes={band: dtype for band, dtype, _ in results}, + nodata_values={band: nodata for band, _, nodata in results}, + item_found=True, + ) + + +def _inspect_first_item( + parquet_path: str, + *, + duckdb_client: DuckdbClient, + bbox: list[float] | None = None, + datetime: str | None = None, + filter: str | dict[str, Any] | None = None, + ids: list[str] | None = None, + bands: list[str] | None = None, + sortby: str | list[str | dict[str, str]] | None = None, + store: Store | None = None, + path_from_href: Callable[[str], str] | None = None, +) -> _ItemInspection: + """Run representative-item inspection on the shared lazycogs event loop.""" try: - run_on_loop(_open_store_sample(path, store=resolved_store)) - except Exception as e: + return run_on_loop( + _inspect_first_item_async( + parquet_path, + duckdb_client=duckdb_client, + bbox=bbox, + datetime=datetime, + filter=filter, + ids=ids, + bands=bands, + sortby=sortby, + store=store, + path_from_href=path_from_href, + ), + ) + except _StoreInspectionError as exc: raise RuntimeError( - f"Store cannot open {href!r} through GeoTIFF.open: {e}. " + f"Store cannot open {exc.href!r} through GeoTIFF.open: {exc.original}. " "Pass a configured store= argument to lazycogs.open() to authenticate. " "See the cloud storage guide for examples.", - ) from e - - logger.debug("Storage smoketest passed for %r", href) + ) from exc.original def _arrow_col(table: Table, name: str) -> list: @@ -186,6 +209,68 @@ def _arrow_col(table: Table, name: str) -> list: return [None] * len(table) +def _promote_integer_dtypes(dtypes: list[np.dtype]) -> np.dtype: + """Resolve sampled integer dtypes to one safe integer dtype.""" + signed = [dtype for dtype in dtypes if np.issubdtype(dtype, np.signedinteger)] + unsigned = [dtype for dtype in dtypes if np.issubdtype(dtype, np.unsignedinteger)] + + if not signed: + return max(unsigned, key=lambda dtype: dtype.itemsize) + if not unsigned: + return max(signed, key=lambda dtype: dtype.itemsize) + + max_signed_bits = max(dtype.itemsize * 8 for dtype in signed) + max_unsigned_bits = max(dtype.itemsize * 8 for dtype in unsigned) + required_bits = max(max_signed_bits, max_unsigned_bits + 1) + if required_bits > max(_INT_WIDTHS): + raise ValueError( + "Cannot safely promote sampled dtypes containing both uint64 and int64.", + ) + + for candidate_bits in _INT_WIDTHS: + if candidate_bits >= required_bits: + return np.dtype(f"int{candidate_bits}") + + raise ValueError(f"Cannot safely promote sampled dtypes: {dtypes!r}") + + +def _promote_dtypes(dtypes: list[np.dtype]) -> np.dtype: + """Resolve sampled dtypes to one safe output dtype.""" + normalized = [np.dtype(dtype) for dtype in dtypes] + if not normalized: + raise ValueError("Cannot infer dtype without at least one sampled band.") + if len(set(normalized)) == 1: + return normalized[0] + + if any(np.issubdtype(dtype, np.floating) for dtype in normalized): + if any(dtype == np.dtype("float64") for dtype in normalized): + return np.dtype("float64") + return np.dtype("float32") + + if not all(np.issubdtype(dtype, np.integer) for dtype in normalized): + raise ValueError(f"Unsupported sampled dtypes: {normalized!r}") + + return _promote_integer_dtypes(normalized) + + +def _resolve_output_nodata( + nodata_values: list[float | int | None], +) -> float | int | None: + """Resolve sampled nodata values to one scalar output sentinel.""" + seen = { + value.item() if isinstance(value, np.generic) else value + for value in nodata_values + if value is not None + } + if not seen: + return None + if len(seen) == 1: + return next(iter(seen)) + raise ValueError( + f"Conflicting sampled nodata values {sorted(seen)!r}; pass nodata= explicitly.", + ) + + def _build_time_steps( parquet_path: str, *, @@ -444,6 +529,11 @@ def _build_dataarray( "_stac_time_coords": _CompactDateArray(time_coord), } + if nodata is not None: + attributes["nodata"] = nodata + attributes["_FillValue"] = nodata + attributes["missing_value"] = nodata + # Zarr geo-proj convention epsg = dst_crs.to_epsg() if epsg is not None: @@ -500,8 +590,8 @@ def open( # noqa: A001 filter: CQL2 filter expression (text string or JSON dict) forwarded to DuckDB queries, e.g. ``"eo:cloud_cover < 20"``. ids: STAC item IDs to restrict the search to. - bands: Asset keys to include. If ``None``, auto-detected from the - first matching item. + bands: Asset keys to include. If ``None``, inferred from the first + matching item's preferred data assets. chunks: Chunk sizes passed to ``DataArray.chunk()``. If ``None`` (default), returns a ``LazilyIndexedArray``-backed DataArray where only the requested pixels are fetched on each access — @@ -509,8 +599,11 @@ def open( # noqa: A001 to convert to a dask-backed array for parallel computation over larger regions. sortby: Sort keys forwarded to DuckDB queries. - nodata: No-data fill value for output arrays. - dtype: Output array dtype. Defaults to ``float32``. + nodata: No-data fill value for output arrays. When omitted, + lazycogs advertises a scalar nodata sentinel only when sampled + bands agree on one. + dtype: Output array dtype. When omitted, inferred from sampled asset + dtypes on the first matching item. mosaic_method: Mosaic method class (not instance) to use. Defaults to :class:`~lazycogs._mosaic_methods.FirstMethod`. time_period: ISO 8601 duration string controlling how items are @@ -612,26 +705,8 @@ def strip_bucket(href: str) -> str: ) bbox_4326 = [float(min(xs)), float(min(ys)), float(max(xs)), float(max(ys))] - if bands is not None: - resolved_bands = bands - else: - t0 = time.perf_counter() - resolved_bands = _discover_bands( - href, - duckdb_client=duckdb_client, - bbox=bbox_4326, - datetime=datetime, - filter=filter, - ids=ids, - sortby=sortby, - ) - logger.debug( - "_discover_bands took %.3fs, found %d bands", - time.perf_counter() - t0, - len(resolved_bands), - ) - - _smoketest_store( + t0 = time.perf_counter() + inspection = _inspect_first_item( href, duckdb_client=duckdb_client, bbox=bbox_4326, @@ -639,9 +714,23 @@ def strip_bucket(href: str) -> str: filter=filter, ids=ids, bands=bands, + sortby=sortby, store=store, path_from_href=path_from_href, ) + logger.debug( + "_inspect_first_item took %.3fs, found %d bands", + time.perf_counter() - t0, + len(inspection.bands), + ) + + if not inspection.item_found: + raise ValueError( + f"No STAC items matched the query in {href!r} " + f"(bbox={bbox_4326}, datetime={datetime}).", + ) + + resolved_bands = bands if bands is not None else inspection.bands t0 = time.perf_counter() filter_strings, time_coords = _build_time_steps( @@ -666,15 +755,31 @@ def strip_bucket(href: str) -> str: f"(bbox={bbox_4326}, datetime={datetime}).", ) + out_dtype = ( + np.dtype(dtype) + if dtype is not None + else _promote_dtypes([inspection.dtypes[band] for band in resolved_bands]) + ) + resolved_nodata = ( + nodata + if nodata is not None + else _resolve_output_nodata( + [inspection.nodata_values[band] for band in resolved_bands], + ) + ) + method_cls = mosaic_method if mosaic_method is not None else FirstMethod + if method_cls.requires_float and not np.issubdtype(out_dtype, np.floating): + raise ValueError( + f"{method_cls.__name__} requires a floating-point dtype, " + f"but got {out_dtype}. Pass dtype='float32' or dtype='float64'.", + ) + logger.info( "Discovered %d bands and %d time steps.", len(resolved_bands), len(filter_strings), ) - out_dtype = np.dtype(dtype) if dtype is not None else np.dtype("float32") - method_cls = mosaic_method if mosaic_method is not None else FirstMethod - return _build_dataarray( parquet_path=href, duckdb_client=duckdb_client, @@ -688,7 +793,7 @@ def strip_bucket(href: str) -> str: sortby=sortby, filter=filter, ids=ids, - nodata=nodata, + nodata=resolved_nodata, out_dtype=out_dtype, method_cls=method_cls, chunks=chunks, diff --git a/src/lazycogs/_mosaic_methods.py b/src/lazycogs/_mosaic_methods.py index 068573d..6880b4a 100644 --- a/src/lazycogs/_mosaic_methods.py +++ b/src/lazycogs/_mosaic_methods.py @@ -19,6 +19,8 @@ class MosaicMethodBase(ABC): """Abstract base class for pixel-selection mosaic methods.""" + requires_float: bool = False + def __init__(self) -> None: """Initialise an empty mosaic accumulator.""" self._mosaic: ma.MaskedArray | None = None @@ -117,6 +119,8 @@ def feed(self, arr: ma.MaskedArray) -> None: class MeanMethod(MosaicMethodBase): """Use the mean of all valid pixel values across tiles.""" + requires_float = True + def __init__(self) -> None: """Initialise accumulators for incremental mean computation.""" super().__init__() @@ -161,6 +165,8 @@ def data(self) -> np.ndarray: class MedianMethod(MosaicMethodBase): """Use the median of all valid pixel values across tiles.""" + requires_float = True + def __init__(self) -> None: """Initialise the tile stack.""" super().__init__() @@ -201,6 +207,8 @@ def data(self) -> np.ndarray: class StdevMethod(MosaicMethodBase): """Use the standard deviation of all valid pixel values across tiles.""" + requires_float = True + def __init__(self) -> None: """Initialise the tile stack.""" super().__init__() diff --git a/tests/benchmarks/conftest.py b/tests/benchmarks/conftest.py index 6fb7103..d793ac8 100644 --- a/tests/benchmarks/conftest.py +++ b/tests/benchmarks/conftest.py @@ -4,8 +4,10 @@ """ from pathlib import Path +from typing import Any import pytest +import rustac _DATA_DIR = Path(__file__).parents[2] / ".benchmark_data" _PARQUET = _DATA_DIR / "benchmark_items.parquet" @@ -59,3 +61,9 @@ def expanded_benchmark_parquet() -> str: "Run `uv run python scripts/prepare_benchmark_data.py` first.", ) return str(_EXPANDED_PARQUET) + + +@pytest.fixture(scope="session") +def benchmark_items(benchmark_parquet: str) -> list[dict[str, Any]]: + """Load the local benchmark STAC items used by offline regression tests.""" + return rustac.search_sync(benchmark_parquet, use_duckdb=True) diff --git a/tests/benchmarks/test_regressions.py b/tests/benchmarks/test_regressions.py new file mode 100644 index 0000000..0958f31 --- /dev/null +++ b/tests/benchmarks/test_regressions.py @@ -0,0 +1,234 @@ +"""Offline regression tests backed by the local benchmark dataset.""" + +from __future__ import annotations + +from copy import deepcopy +from pathlib import Path +from shutil import copy2 +from typing import Any +from urllib.parse import urlparse + +import numpy as np +import pytest +import rasterio +import rustac +from pyproj import Transformer +from rasterio.windows import Window + +import lazycogs +from lazycogs import LowestMethod + +from .conftest import ( + BENCHMARK_BBOX, + BENCHMARK_CRS, + BENCHMARK_MULTIBAND, + BENCHMARK_NATIVE_CRS, + BENCHMARK_SINGLE_BAND, +) + + +def _path_from_href(href: str) -> Path: + """Return the local filesystem path for a ``file://`` benchmark asset HREF.""" + return Path(urlparse(href).path) + + +def _write_asset_variant( + source_href: str, + dest: Path, + *, + nodata: float | None, + pixel_updates: list[tuple[int, int, int]] | None = None, +) -> str: + """Copy one benchmark GeoTIFF and apply metadata/data tweaks in place.""" + dest.parent.mkdir(parents=True, exist_ok=True) + copy2(_path_from_href(source_href), dest) + + with rasterio.open(dest, "r+", IGNORE_COG_LAYOUT_BREAK="YES") as dataset: + dataset.nodata = nodata + if pixel_updates: + for row, col, value in pixel_updates: + patch = np.array([[value]], dtype=dataset.dtypes[0]) + dataset.write(patch, 1, window=Window(col, row, 1, 1)) + + return dest.as_uri() + + +def _write_items_parquet(path: Path, items: list[dict[str, Any]]) -> str: + """Write a temporary local parquet file for a derived benchmark scenario.""" + rustac.write_sync(str(path), items) + return str(path) + + +def _pixel_bbox( + source_href: str, + *, + row: int, + col: int, +) -> tuple[float, float, float, float]: + """Return the bounding box of one source pixel in the asset's native CRS.""" + with rasterio.open(_path_from_href(source_href)) as dataset: + left, top = dataset.transform * (col, row) + right, bottom = dataset.transform * (col + 1, row + 1) + return (left, bottom, right, top) + + +def _item_center_pixel(item: dict[str, Any], band: str) -> tuple[int, int]: + """Project the STAC item's bbox center into the asset grid and return row/col.""" + source_href = item["assets"][band]["href"] + with rasterio.open(_path_from_href(source_href)) as dataset: + transformer = Transformer.from_crs("EPSG:4326", dataset.crs, always_xy=True) + minx, miny, maxx, maxy = item["bbox"] + center_x = (minx + maxx) / 2 + center_y = (miny + maxy) / 2 + x_native, y_native = transformer.transform(center_x, center_y) + return dataset.index(x_native, y_native) + + +def test_open_infers_uint16_and_coherent_nodata_from_benchmark_data( + benchmark_parquet: str, +) -> None: + """The local benchmark parquet exercises the inferred dtype/nodata contract.""" + da = lazycogs.open( + benchmark_parquet, + bbox=BENCHMARK_BBOX, + crs=BENCHMARK_CRS, + resolution=60.0, + bands=BENCHMARK_MULTIBAND, + ) + + assert da.dtype == np.dtype("uint16") + assert da.attrs["nodata"] == 0 + assert da.attrs["_FillValue"] == 0 + assert da.attrs["missing_value"] == 0 + + +def test_open_explicit_overrides_win_over_benchmark_inference( + benchmark_parquet: str, +) -> None: + """Caller-supplied dtype and nodata stay authoritative on local data.""" + da = lazycogs.open( + benchmark_parquet, + bbox=BENCHMARK_BBOX, + crs=BENCHMARK_CRS, + resolution=60.0, + bands=BENCHMARK_SINGLE_BAND, + dtype="float32", + nodata=-9999, + ) + + assert da.dtype == np.dtype("float32") + assert da.attrs["nodata"] == -9999 + assert da.attrs["_FillValue"] == -9999 + assert da.attrs["missing_value"] == -9999 + + +def test_open_rejects_conflicting_sampled_nodata_on_local_benchmark_copy( + tmp_path: Path, + benchmark_items: list[dict[str, Any]], +) -> None: + """A derived offline parquet with band conflicts fails fast at ``open()``.""" + item = deepcopy(benchmark_items[0]) + item["assets"]["nir08"]["href"] = _write_asset_variant( + item["assets"]["nir08"]["href"], + tmp_path / "conflict" / "nir08-conflict.tif", + nodata=-9999, + ) + parquet_path = _write_items_parquet(tmp_path / "conflict.parquet", [item]) + + with pytest.raises(ValueError, match="Conflicting sampled nodata values"): + lazycogs.open( + parquet_path, + bbox=BENCHMARK_BBOX, + crs=BENCHMARK_CRS, + resolution=60.0, + bands=BENCHMARK_MULTIBAND, + ) + + +def test_open_accepts_conflicting_sampled_nodata_with_explicit_override( + tmp_path: Path, + benchmark_items: list[dict[str, Any]], +) -> None: + """The same offline conflict opens successfully when ``nodata=`` is explicit.""" + item = deepcopy(benchmark_items[0]) + item["assets"]["nir08"]["href"] = _write_asset_variant( + item["assets"]["nir08"]["href"], + tmp_path / "override" / "nir08-conflict.tif", + nodata=-9999, + ) + parquet_path = _write_items_parquet(tmp_path / "override.parquet", [item]) + + da = lazycogs.open( + parquet_path, + bbox=BENCHMARK_BBOX, + crs=BENCHMARK_CRS, + resolution=60.0, + bands=BENCHMARK_MULTIBAND, + nodata=-9999, + ) + + assert da.attrs["nodata"] == -9999 + assert da.attrs["_FillValue"] == -9999 + assert da.attrs["missing_value"] == -9999 + + +def test_chunk_reads_still_mask_per_cog_nodata_when_output_nodata_is_unknown( + tmp_path: Path, + benchmark_items: list[dict[str, Any]], +) -> None: + """Chunk reads still honor per-COG nodata. + + This still works even when no output nodata is advertised. + """ + base_item = deepcopy(benchmark_items[0]) + first_href = base_item["assets"]["red"]["href"] + test_row, test_col = _item_center_pixel(base_item, "red") + pixel_bbox = _pixel_bbox(first_href, row=test_row, col=test_col) + + item_without_output_nodata = deepcopy(base_item) + item_without_output_nodata["id"] = f"{base_item['id']}-no-output-nodata" + item_without_output_nodata["assets"] = { + "red": { + **base_item["assets"]["red"], + "href": _write_asset_variant( + first_href, + tmp_path / "masking" / "red-no-output-nodata.tif", + nodata=None, + pixel_updates=[(test_row, test_col, 10)], + ), + }, + } + + masked_source_item = deepcopy(base_item) + masked_source_item["id"] = f"{base_item['id']}-masked-source" + masked_source_item["assets"] = { + "red": { + **base_item["assets"]["red"], + "href": _write_asset_variant( + first_href, + tmp_path / "masking" / "red-source-nodata.tif", + nodata=0, + pixel_updates=[(test_row, test_col, 0)], + ), + }, + } + + parquet_path = _write_items_parquet( + tmp_path / "masking.parquet", + [item_without_output_nodata, masked_source_item], + ) + + da = lazycogs.open( + parquet_path, + bbox=pixel_bbox, + crs=BENCHMARK_NATIVE_CRS, + resolution=10.0, + bands=BENCHMARK_SINGLE_BAND, + mosaic_method=LowestMethod, + ) + value = da.compute().item() + + assert "nodata" not in da.attrs + assert "_FillValue" not in da.attrs + assert "missing_value" not in da.attrs + assert value == 10 diff --git a/tests/test_core.py b/tests/test_core.py index 77a81ca..0a4ee80 100644 --- a/tests/test_core.py +++ b/tests/test_core.py @@ -13,7 +13,13 @@ import lazycogs from lazycogs._backend import MultiBandStacBackendArray -from lazycogs._core import _build_time_steps, _smoketest_store +from lazycogs._core import ( + _build_time_steps, + _inspect_first_item, + _promote_dtypes, + _resolve_output_nodata, +) +from lazycogs._mosaic_methods import MeanMethod from lazycogs._temporal import _DayGrouper, _FixedDayGrouper, _MonthGrouper @@ -312,8 +318,12 @@ def opened_dataarray(tmp_path): table = _items_to_arrow([{"properties": {"datetime": "2023-01-15T10:00:00Z"}}]) + class _FakeGeoTIFF: + dtype = np.dtype("uint16") + nodata = 0 + async def fake_open(path: str, *, store): - return object() + return _FakeGeoTIFF() with ( patch("rustac.DuckdbClient.search", return_value=[_fake_open_item()]), @@ -361,6 +371,12 @@ def test_open_sets_expected_dataarray_attributes(opened_dataarray): assert "spatial:" in names assert "proj:" in names + # Inferred output contract + assert da.dtype == np.dtype("uint16") + assert da.attrs["nodata"] == 0 + assert da.attrs["_FillValue"] == 0 + assert da.attrs["missing_value"] == 0 + # Internal bookkeeping attributes assert isinstance(da.attrs["_stac_backend"], MultiBandStacBackendArray) assert da.attrs["_stac_time_coords"].dtype == np.dtype("datetime64[D]") @@ -393,7 +409,7 @@ def test_chunked_spatial_selection_full_compute_succeeds(opened_dataarray): # --------------------------------------------------------------------------- -# _smoketest_store +# Startup inspection and output contract helpers # --------------------------------------------------------------------------- @@ -407,66 +423,169 @@ async def get_ranges_async(self, starts_ends): return [b"" for _ in starts_ends] -_SMOKETEST_ITEM = { +_INSPECTION_ITEM = { "id": "smoke-item", "stac_extensions": [], "properties": {"datetime": "2023-06-01T00:00:00Z"}, "assets": { + "preview": {"href": "s3://my-bucket/preview.jpg", "type": "image/jpeg"}, "B04": { "href": "s3://my-bucket/B04.tif", "type": "image/tiff; application=geotiff; profile=cloud-optimized", "roles": ["data"], }, + "B08": { + "href": "s3://my-bucket/B08.tif", + "type": "image/tiff; application=geotiff; profile=cloud-optimized", + "roles": ["data"], + }, }, } -def test_smoketest_passes_when_geotiff_open_succeeds(): - """_smoketest_store does not raise when GeoTIFF.open succeeds.""" +@pytest.mark.parametrize( + ("sampled", "expected"), + [ + ([np.dtype("uint16")], np.dtype("uint16")), + ([np.dtype("uint8"), np.dtype("int16")], np.dtype("int16")), + ([np.dtype("uint16"), np.dtype("int16")], np.dtype("int32")), + ([np.dtype("float32"), np.dtype("uint16")], np.dtype("float32")), + ([np.dtype("float64"), np.dtype("uint16")], np.dtype("float64")), + ], +) +def test_promote_dtypes(sampled, expected): + """Sampled dtypes promote to the expected output dtype.""" + assert _promote_dtypes(sampled) == expected + + +def test_promote_dtypes_rejects_uint64_plus_int64(): + """The unsupported uint64 + int64 case fails explicitly.""" + with pytest.raises(ValueError, match="uint64 and int64"): + _promote_dtypes([np.dtype("uint64"), np.dtype("int64")]) + + +@pytest.mark.parametrize( + ("sampled", "expected"), + [([None, None], None), ([0, np.int16(0)], 0), ([-9999, -9999], -9999)], +) +def test_resolve_output_nodata(sampled, expected): + """Coherent sampled nodata values resolve to one scalar or None.""" + assert _resolve_output_nodata(sampled) == expected + + +def test_resolve_output_nodata_rejects_conflicts(): + """Conflicting sampled nodata values raise instead of guessing.""" + with pytest.raises(ValueError, match="Conflicting sampled nodata values"): + _resolve_output_nodata([0, -9999]) + + +def test_inspect_first_item_returns_dtype_and_nodata_metadata(): + """Representative-item inspection returns ordered bands and sampled metadata.""" store = MemoryStore() store.put("B04.tif", b"dummy") + store.put("B08.tif", b"dummy") + + class _FakeGeoTIFF: + def __init__(self, dtype: str, nodata: int | None) -> None: + self.dtype = np.dtype(dtype) + self.nodata = nodata async def fake_open(path: str, *, store): - assert path == "B04.tif" - assert store is store_obj - return object() + if path == "B04.tif": + return _FakeGeoTIFF("uint16", 0) + if path == "B08.tif": + return _FakeGeoTIFF("int16", 0) + raise AssertionError(path) - store_obj = store with ( - patch("rustac.DuckdbClient.search", return_value=[_SMOKETEST_ITEM]), + patch("rustac.DuckdbClient.search", return_value=[_INSPECTION_ITEM]), patch("lazycogs._core.GeoTIFF.open", side_effect=fake_open), ): - _smoketest_store( + inspection = _inspect_first_item( "items.parquet", duckdb_client=DuckdbClient(), store=store, path_from_href=lambda href: href.split("/", 3)[-1], ) + assert inspection.item_found is True + assert inspection.bands == ["B04", "B08"] + assert inspection.dtypes["B04"] == np.dtype("uint16") + assert inspection.dtypes["B08"] == np.dtype("int16") + assert inspection.nodata_values["B04"] == 0 + assert inspection.nodata_values["B08"] == 0 + -def test_smoketest_raises_runtime_error_on_geotiff_open_failure(): - """_smoketest_store raises RuntimeError when GeoTIFF.open fails.""" +def test_inspect_first_item_includes_filter_fields_in_probe_query(): + """Representative-item inspection includes filter fields needed by rustac.""" store = MemoryStore() + store.put("B04.tif", b"dummy") + + class _FakeGeoTIFF: + dtype = np.dtype("uint16") + nodata = 0 + + async def fake_open(path: str, *, store): + assert path == "B04.tif" + return _FakeGeoTIFF() + + def fake_search(*args, **kwargs): + assert "proj:epsg" in kwargs["include"] + return [_fake_open_item()] + + with ( + patch("rustac.DuckdbClient.search", side_effect=fake_search), + patch("lazycogs._core.GeoTIFF.open", side_effect=fake_open), + ): + inspection = _inspect_first_item( + "items.parquet", + duckdb_client=DuckdbClient(), + filter={"op": "=", "args": [{"property": "proj:epsg"}, "32615"]}, + bands=["B04"], + store=store, + path_from_href=lambda href: href.split("/", 3)[-1], + ) + + assert inspection.item_found is True + assert inspection.bands == ["B04"] + + +def test_inspect_first_item_returns_no_item_without_opening_geotiff(): + """No matching items returns item_found=False and skips GeoTIFF.open.""" + with ( + patch("rustac.DuckdbClient.search", return_value=[]), + patch("lazycogs._core.GeoTIFF.open") as mock_open, + ): + inspection = _inspect_first_item("items.parquet", duckdb_client=DuckdbClient()) + + assert inspection.item_found is False + assert inspection.bands == [] + mock_open.assert_not_called() + + +def test_inspect_first_item_wraps_store_open_failures(): + """Store-open failures keep the public authentication guidance.""" async def fake_open(path: str, *, store): raise FileNotFoundError(path) with ( - patch("rustac.DuckdbClient.search", return_value=[_SMOKETEST_ITEM]), + patch("rustac.DuckdbClient.search", return_value=[_INSPECTION_ITEM]), patch("lazycogs._core.GeoTIFF.open", side_effect=fake_open), pytest.raises(RuntimeError, match=r"GeoTIFF\.open"), ): - _smoketest_store( + _inspect_first_item( "items.parquet", duckdb_client=DuckdbClient(), - store=store, + bands=["B04"], + store=MemoryStore(), path_from_href=lambda href: href.split("/", 3)[-1], ) -def test_smoketest_accepts_protocol_store_without_head(tmp_path): +def test_open_accepts_protocol_store_without_head(tmp_path): """A custom protocol store without head() still passes startup validation.""" parquet = tmp_path / "items.parquet" @@ -474,10 +593,14 @@ def test_smoketest_accepts_protocol_store_without_head(tmp_path): store = _ProtocolStore() table = _items_to_arrow([{"properties": {"datetime": "2023-01-15T10:00:00Z"}}]) + class _FakeGeoTIFF: + dtype = np.dtype("uint16") + nodata = 0 + async def fake_open(path: str, *, store): assert path == "B04.tif" assert store is protocol_store - return object() + return _FakeGeoTIFF() protocol_store = store with ( @@ -497,43 +620,32 @@ async def fake_open(path: str, *, store): assert da.attrs["_stac_backend"].store is store -def test_smoketest_no_op_when_no_items(): - """_smoketest_store does nothing when the query returns no items.""" - with patch("rustac.DuckdbClient.search", return_value=[]): - _smoketest_store("items.parquet", duckdb_client=DuckdbClient()) - - -def test_smoketest_prefers_specified_band(): - """_smoketest_store uses the first specified band when bands= is given.""" +def test_open_rejects_float_required_method_with_inferred_integer_dtype(tmp_path): + """Float-only mosaic methods fail early when dtype inference stays integer.""" - store = MemoryStore() - - item = { - "id": "multi-band-item", - "stac_extensions": [], - "properties": {"datetime": "2023-06-01T00:00:00Z"}, - "assets": { - "B04": {"href": "s3://bucket/B04.tif", "roles": ["data"]}, - "B08": {"href": "s3://bucket/B08.tif", "roles": ["data"]}, - }, - } + parquet = tmp_path / "items.parquet" + parquet.write_bytes(b"") + table = _items_to_arrow([{"properties": {"datetime": "2023-01-15T10:00:00Z"}}]) - seen: list[str] = [] + class _FakeGeoTIFF: + dtype = np.dtype("uint16") + nodata = 0 async def fake_open(path: str, *, store): - seen.append(path) - return object() + return _FakeGeoTIFF() with ( - patch("rustac.DuckdbClient.search", return_value=[item]), + patch("rustac.DuckdbClient.search", return_value=[_fake_open_item()]), + patch("rustac.DuckdbClient.search_to_arrow", return_value=table), patch("lazycogs._core.GeoTIFF.open", side_effect=fake_open), + pytest.raises(ValueError, match="requires a floating-point dtype"), ): - _smoketest_store( - "items.parquet", - duckdb_client=DuckdbClient(), - bands=["B08"], - store=store, + lazycogs.open( + str(parquet), + bbox=(0.0, 0.0, 100.0, 100.0), + crs="EPSG:32632", + resolution=10.0, + mosaic_method=MeanMethod, + store=MemoryStore(), path_from_href=lambda href: href.split("/", 3)[-1], ) - - assert seen == ["B08.tif"] diff --git a/tests/test_mosaic_methods.py b/tests/test_mosaic_methods.py index 95d0eb4..b5b585c 100644 --- a/tests/test_mosaic_methods.py +++ b/tests/test_mosaic_methods.py @@ -11,6 +11,7 @@ LowestMethod, MeanMethod, MedianMethod, + MosaicMethodBase, StdevMethod, ) @@ -204,3 +205,15 @@ def test_count_always_done(): m = CountMethod() m.feed(ma.MaskedArray(np.ones((1, 2, 2), dtype=np.uint16), mask=False)) assert m.is_done + + +def test_requires_float_flags(): + """Only float-valued aggregation methods advertise float-only output.""" + assert MosaicMethodBase.requires_float is False + assert FirstMethod.requires_float is False + assert HighestMethod.requires_float is False + assert LowestMethod.requires_float is False + assert CountMethod.requires_float is False + assert MeanMethod.requires_float is True + assert MedianMethod.requires_float is True + assert StdevMethod.requires_float is True From c3606dfa22b368a483caf43d7e68cb84211de1d6 Mon Sep 17 00:00:00 2001 From: hrodmn Date: Sat, 23 May 2026 07:20:06 -0500 Subject: [PATCH 2/5] refactor: enforce auto-inferred dtype at runtime --- ARCHITECTURE.md | 5 +- README.md | 13 +- src/lazycogs/_backend.py | 20 ++- src/lazycogs/_chunk_reader.py | 142 +++++++++++++++---- src/lazycogs/_core.py | 47 ++++-- tests/benchmarks/test_regressions.py | 204 +++++++++++++++++++++++++-- tests/test_core.py | 28 +++- 7 files changed, 402 insertions(+), 57 deletions(-) diff --git a/ARCHITECTURE.md b/ARCHITECTURE.md index dbcd809..528c71d 100644 --- a/ARCHITECTURE.md +++ b/ARCHITECTURE.md @@ -18,7 +18,7 @@ Work is split sharply into two phases. **Phase 1 — compute time** runs inside a dask worker when a chunk is actually computed. `MultiBandStacBackendArray.__getitem__` receives the exact `(band, time, y, x)` index for the chunk, derives the chunk's spatial footprint, queries DuckDB for only the COGs that overlap that footprint and time step, reads and reprojects all selected bands concurrently with `asyncio`, and mosaics the results. -This split means that `open()` is nearly instant even for large queries, and the DuckDB spatial filter runs once per chunk rather than over the entire bbox at open time. The startup inspection is still deliberately small: one representative item and one `GeoTIFF.open(...)` per requested band, just enough to validate store access and infer the output dtype/nodata contract. +This split means that `open()` is nearly instant even for large queries, and the DuckDB spatial filter runs once per chunk rather than over the entire bbox at open time. The startup inspection is still deliberately small: one representative item and one `GeoTIFF.open(...)` per requested band, just enough to validate store access and infer the output dtype/nodata contract. That contract is enforced later during chunk reads unless the caller passed `dtype=` or `nodata=` explicitly. ## Module overview @@ -50,6 +50,7 @@ src/lazycogs/ - `dtype`: explicit `dtype=` wins, otherwise `_promote_dtypes(...)` - `nodata`: explicit `nodata=` wins, otherwise `_resolve_output_nodata(...)` - float-only mosaic methods (`MeanMethod`, `MedianMethod`, `StdevMethod`) fail early unless the resolved dtype is floating + - inferred `dtype` and `nodata` are runtime-validated during chunk reads so later heterogeneous assets fail loudly instead of truncating or silently remapping nodata 6. Calls `_build_time_steps()`: queries the parquet source via `duckdb_client.search_to_arrow(...)` to obtain an Arrow table containing only the `datetime` and `start_datetime` columns (plus any filter/sort fields). Extracts timestamps from the Arrow columns without Python-level dict walking, buckets them with the `_TemporalGrouper`, deduplicates, and returns sorted `(filter_strings, time_coords)` pairs. Only groups with at least one item produce a time step. 7. Calls `compute_output_grid()` to get the output affine transform and dimensions (width, height). No eager coordinate arrays are produced. 8. Creates a single `MultiBandStacBackendArray` (a dataclass) with shape `(band, time, y, x)` holding all the parameters needed to materialise any chunk later, then wraps it in one `xarray.core.indexing.LazilyIndexedArray`. This avoids `xr.concat` (used internally by `ds.to_array()`), which would eagerly load `LazilyIndexedArray`-backed objects. @@ -109,7 +110,7 @@ A `rasterix.RasterIndex` is attached to every DataArray returned by `open()`. Th ## Per-chunk read and resample pipeline -Each call to `_read_item_band()` in `_chunk_reader.py` follows a four-step pipeline to turn a remote COG into a correctly-sized, correctly-projected numpy array for one destination chunk. +Each call to `_read_item_band()` in `_chunk_reader.py` first validates the source asset against the inferred output contract, then follows a four-step pipeline to turn a remote COG into a correctly-sized, correctly-projected numpy array for one destination chunk. ### 1. Overview selection diff --git a/README.md b/README.md index 9606c37..c641def 100644 --- a/README.md +++ b/README.md @@ -73,8 +73,8 @@ await rustac.search_to( # Open a fully lazy (band, time, y, x) DataArray. No pixel data is read yet. # lazycogs does inspect one representative item here: it picks preferred data -# assets, opens one COG per requested band concurrently, infers a default -# dtype, and advertises nodata only when the sampled bands agree on one. +# assets, opens one COG per requested band concurrently, and infers a default +# dtype/nodata contract from that representative sample. da = lazycogs.open( "items.parquet", bbox=dst_bbox, @@ -109,7 +109,9 @@ For most users, the recommended path is still obstore: leave `store=None` to aut When you omit `dtype=`, `lazycogs.open()` samples one representative COG per requested band and infers one safe output dtype instead of defaulting to -`float32`. +`float32`. That inferred dtype is then enforced at chunk-read time: if a later +asset has a source dtype that cannot be safely represented, compute raises and +asks you to pass `dtype=` explicitly. When you omit `nodata=`: @@ -120,6 +122,11 @@ When you omit `nodata=`: `nodata=` explicitly - if sampled bands have no nodata sentinel, no nodata attrs are attached and `0` remains only an implementation fill value for uncovered regions +- if later chunk reads encounter a conflicting source nodata value, compute + raises and asks you to pass `nodata=` explicitly + +Explicit `dtype=` and `nodata=` stay authoritative even when source assets are +heterogeneous. Float-only mosaic methods such as `MeanMethod`, `MedianMethod`, and `StdevMethod` require a floating output dtype. If inference stays integer, diff --git a/src/lazycogs/_backend.py b/src/lazycogs/_backend.py index 6790aec..0c40c48 100644 --- a/src/lazycogs/_backend.py +++ b/src/lazycogs/_backend.py @@ -58,6 +58,9 @@ class _ChunkReadPlan: chunk_width: Chunk width in pixels. chunk_height: Chunk height in pixels. nodata: No-data fill value, or ``None``. + out_dtype: Output array dtype for the chunk. + dtype_was_explicit: Whether the caller passed ``dtype=`` explicitly. + nodata_was_explicit: Whether the caller passed ``nodata=`` explicitly. mosaic_method_cls: Mosaic method class, or ``None`` for the default. store: Pre-configured :class:`async_geotiff.Store` accepted by ``GeoTIFF.open``, or ``None``. @@ -80,7 +83,10 @@ class _ChunkReadPlan: dst_crs: CRS chunk_width: int chunk_height: int - nodata: float | None + nodata: float | int | None + out_dtype: np.dtype + dtype_was_explicit: bool + nodata_was_explicit: bool mosaic_method_cls: type[MosaicMethodBase] | None store: Store | None max_concurrent_reads: int @@ -256,6 +262,9 @@ async def _run_one_date( chunk_width=plan.chunk_width, chunk_height=plan.chunk_height, nodata=plan.nodata, + out_dtype=plan.out_dtype, + dtype_was_explicit=plan.dtype_was_explicit, + nodata_was_explicit=plan.nodata_was_explicit, mosaic_method_cls=plan.mosaic_method_cls, store=plan.store, max_concurrent_reads=plan.max_concurrent_reads, @@ -330,6 +339,8 @@ class MultiBandStacBackendArray(BackendArray): dst_height: Full output grid height in pixels. dtype: NumPy dtype of the output array. nodata: No-data fill value, or ``None``. + dtype_was_explicit: Whether the caller passed ``dtype=`` explicitly. + nodata_was_explicit: Whether the caller passed ``nodata=`` explicitly. mosaic_method_cls: Mosaic method class instantiated per chunk, or ``None`` to use the default :class:`~lazycogs._mosaic_methods.FirstMethod`. @@ -365,7 +376,9 @@ class MultiBandStacBackendArray(BackendArray): dst_width: int dst_height: int dtype: np.dtype - nodata: float | None + nodata: float | int | None + dtype_was_explicit: bool + nodata_was_explicit: bool mosaic_method_cls: type[MosaicMethodBase] | None = field(default=None) store: Store | None = field(default=None) max_concurrent_reads: int = field(default=32) @@ -556,6 +569,9 @@ async def _async_getitem(self, key: tuple[Any, ...]) -> np.ndarray: chunk_width=win.chunk_width, chunk_height=win.chunk_height, nodata=self.nodata, + out_dtype=self.dtype, + dtype_was_explicit=self.dtype_was_explicit, + nodata_was_explicit=self.nodata_was_explicit, mosaic_method_cls=self.mosaic_method_cls, store=self.store, max_concurrent_reads=self.max_concurrent_reads, diff --git a/src/lazycogs/_chunk_reader.py b/src/lazycogs/_chunk_reader.py index 490521f..6d0764c 100644 --- a/src/lazycogs/_chunk_reader.py +++ b/src/lazycogs/_chunk_reader.py @@ -45,7 +45,10 @@ class _ChunkContext: dst_crs: CRS chunk_width: int chunk_height: int - nodata: float | None + nodata: float | int | None + out_dtype: np.dtype + dtype_was_explicit: bool + nodata_was_explicit: bool store: Store | None path_fn: Callable[[str], str] | None warp_cache: dict[tuple[tuple[float, ...], CRS], WarpMap] | None @@ -68,6 +71,95 @@ def _log_read_failure( ) +def _dtype_is_compatible(source: np.dtype, resolved: np.dtype) -> bool: + """Return True when *source* can be represented safely by *resolved*.""" + return bool(np.can_cast(source, resolved, casting="safe")) + + +def _nodata_matches( + source: float | None, + resolved: float | None, +) -> bool: + """Return True when source and resolved nodata agree, including NaN.""" + if source is None or resolved is None: + return source is None and resolved is None + + source_scalar = source.item() if isinstance(source, np.generic) else source + resolved_scalar = resolved.item() if isinstance(resolved, np.generic) else resolved + + source_is_nan = isinstance(source_scalar, float) and np.isnan(source_scalar) + resolved_is_nan = isinstance(resolved_scalar, float) and np.isnan(resolved_scalar) + if source_is_nan or resolved_is_nan: + return source_is_nan and resolved_is_nan + return bool(source_scalar == resolved_scalar) + + +def _validate_source_contract( + item: dict, + band: str, + geotiff: GeoTIFF, + ctx: _ChunkContext, +) -> float | int | None: + """Validate one source asset against the resolved output contract.""" + source_dtype = np.dtype(geotiff.dtype) + if not ctx.dtype_was_explicit and not _dtype_is_compatible( + source_dtype, + ctx.out_dtype, + ): + raise ValueError( + "Auto-inferred output dtype " + f"{ctx.out_dtype} from representative assets, but encountered " + f"{source_dtype} in asset {band!r} for item " + f"{item.get('id', '')!r}. Pass dtype='float32', " + "dtype='float64', or another explicit dtype if mixed source " + "dtypes are expected.", + ) + + source_nodata = geotiff.nodata + if not ctx.nodata_was_explicit and not _nodata_matches( + source_nodata, + ctx.nodata, + ): + raise ValueError( + "Auto-inferred output nodata " + f"{ctx.nodata!r} from representative assets, but encountered " + f"conflicting nodata {source_nodata!r} in asset {band!r} for " + f"item {item.get('id', '')!r}. Pass nodata= explicitly " + "if mixed source nodata values are expected.", + ) + + return ctx.nodata if ctx.nodata is not None else source_nodata + + +def _build_band_read_entry( + band: str, + geotiff: GeoTIFF, + ctx: _ChunkContext, + effective_nodata: float | None, +) -> tuple[str, GeoTIFF, GeoTIFF | Overview, Window, float | None, CRS] | None: + """Build the read plan entry for one band, or ``None`` if no overlap.""" + src_crs = geotiff.crs + target_res_native, transformer = _target_res_and_transformer( + ctx.chunk_affine, + ctx.chunk_width, + ctx.chunk_height, + ctx.dst_crs, + src_crs, + ) + overview = _select_overview(geotiff, target_res_native) + reader = overview if overview is not None else geotiff + bbox_native = _chunk_bbox_native( + ctx.chunk_affine, + ctx.chunk_width, + ctx.chunk_height, + transformer, + ) + window = _native_window(reader, bbox_native, reader.width, reader.height) + if window is None: + return None + return (band, geotiff, reader, window, effective_nodata, src_crs) + + def _target_res_and_transformer( chunk_affine: Affine, chunk_width: int, @@ -391,33 +483,13 @@ async def _open_band( # Each band is handled independently so differing native resolutions or # extents are handled correctly. band_read_plan: list[ - tuple[str, GeoTIFF, GeoTIFF | Overview, Window, float | None, CRS] + tuple[str, GeoTIFF, GeoTIFF | Overview, Window, float | int | None, CRS] ] = [] for band, geotiff, _ in open_results: - effective_nodata = ctx.nodata if ctx.nodata is not None else geotiff.nodata - src_crs = geotiff.crs - target_res_native, t = _target_res_and_transformer( - ctx.chunk_affine, - ctx.chunk_width, - ctx.chunk_height, - ctx.dst_crs, - src_crs, - ) - overview = _select_overview(geotiff, target_res_native) - reader = overview if overview is not None else geotiff - bbox_native = _chunk_bbox_native( - ctx.chunk_affine, - ctx.chunk_width, - ctx.chunk_height, - t, - ) - window = _native_window(reader, bbox_native, reader.width, reader.height) - if window is None: - continue - - band_read_plan.append( - (band, geotiff, reader, window, effective_nodata, src_crs), - ) + effective_nodata = _validate_source_contract(item, band, geotiff, ctx) + plan_entry = _build_band_read_entry(band, geotiff, ctx, effective_nodata) + if plan_entry is not None: + band_read_plan.append(plan_entry) if not band_read_plan: return None @@ -514,14 +586,18 @@ async def _drain_in_order( await asyncio.gather(*tasks, return_exceptions=True) -async def read_chunk_async( +async def read_chunk_async( # noqa: C901 items: list[dict], bands: list[str], chunk_affine: Affine, dst_crs: CRS, chunk_width: int, chunk_height: int, + *, nodata: float | None = None, + out_dtype: np.dtype | None = None, + dtype_was_explicit: bool = False, + nodata_was_explicit: bool = False, mosaic_method_cls: type[MosaicMethodBase] | None = None, store: Store | None = None, max_concurrent_reads: int = 32, @@ -546,6 +622,9 @@ async def read_chunk_async( chunk_width: Width of the destination chunk in pixels. chunk_height: Height of the destination chunk in pixels. nodata: No-data fill value. + out_dtype: Output array dtype inferred or supplied at ``open()`` time. + dtype_was_explicit: Whether the caller passed ``dtype=`` explicitly. + nodata_was_explicit: Whether the caller passed ``nodata=`` explicitly. mosaic_method_cls: Mosaic method class instantiated once per band. Defaults to :class:`~lazycogs._mosaic_methods.FirstMethod`. store: Optional pre-configured :class:`async_geotiff.Store` @@ -566,12 +645,19 @@ async def read_chunk_async( if mosaic_method_cls is None: mosaic_method_cls = FirstMethod + resolved_out_dtype = ( + np.dtype(out_dtype) if out_dtype is not None else np.dtype("float32") + ) + ctx = _ChunkContext( chunk_affine=chunk_affine, dst_crs=dst_crs, chunk_width=chunk_width, chunk_height=chunk_height, nodata=nodata, + out_dtype=resolved_out_dtype, + dtype_was_explicit=dtype_was_explicit, + nodata_was_explicit=nodata_was_explicit, store=store, path_fn=path_fn, warp_cache=warp_cache, @@ -604,6 +690,8 @@ def _done() -> bool: return all(m.is_done for m in mosaic_methods.values()) def _error(idx: int, exc: BaseException) -> None: + if isinstance(exc, ValueError): + raise exc _log_read_failure("bands", bands, items[idx].get("id", ""), exc) await _drain_in_order(task_list, _feed, _done, _error) diff --git a/src/lazycogs/_core.py b/src/lazycogs/_core.py index c320396..32a0f2a 100644 --- a/src/lazycogs/_core.py +++ b/src/lazycogs/_core.py @@ -253,21 +253,36 @@ def _promote_dtypes(dtypes: list[np.dtype]) -> np.dtype: return _promote_integer_dtypes(normalized) +def _dtype_is_compatible(source: np.dtype, resolved: np.dtype) -> bool: + """Return True when *source* can be represented safely by *resolved*.""" + return bool(np.can_cast(source, resolved, casting="safe")) + + def _resolve_output_nodata( nodata_values: list[float | int | None], ) -> float | int | None: """Resolve sampled nodata values to one scalar output sentinel.""" - seen = { - value.item() if isinstance(value, np.generic) else value - for value in nodata_values - if value is not None - } - if not seen: + saw_nan = False + scalars: set[float | int] = set() + + for value in nodata_values: + if value is None: + continue + scalar = value.item() if isinstance(value, np.generic) else value + if isinstance(scalar, float) and np.isnan(scalar): + saw_nan = True + continue + scalars.add(scalar) + + if not scalars and not saw_nan: return None - if len(seen) == 1: - return next(iter(seen)) + if not scalars and saw_nan: + return np.nan + if len(scalars) == 1 and not saw_nan: + return next(iter(scalars)) + raise ValueError( - f"Conflicting sampled nodata values {sorted(seen)!r}; pass nodata= explicitly.", + "Conflicting sampled nodata values; pass nodata= explicitly.", ) @@ -389,6 +404,8 @@ def _build_dataarray( ids: list[str] | None, nodata: float | None, out_dtype: np.dtype, + dtype_was_explicit: bool, + nodata_was_explicit: bool, method_cls: type[MosaicMethodBase], chunks: dict[str, int] | None, store: Store | None = None, @@ -419,6 +436,8 @@ def _build_dataarray( ids: STAC item IDs forwarded to per-chunk DuckDB queries. nodata: No-data fill value. out_dtype: Output array dtype. + dtype_was_explicit: Whether the caller passed ``dtype=`` explicitly. + nodata_was_explicit: Whether the caller passed ``nodata=`` explicitly. method_cls: Mosaic method class. chunks: Passed to ``DataArray.chunk()`` if not ``None``. store: Pre-configured :class:`async_geotiff.Store` accepted by @@ -454,6 +473,8 @@ def _build_dataarray( dst_height=dst_height, dtype=out_dtype, nodata=nodata, + dtype_was_explicit=dtype_was_explicit, + nodata_was_explicit=nodata_was_explicit, mosaic_method_cls=method_cls, store=store, max_concurrent_reads=max_concurrent_reads, @@ -755,14 +776,16 @@ def strip_bucket(href: str) -> str: f"(bbox={bbox_4326}, datetime={datetime}).", ) + dtype_was_explicit = dtype is not None + nodata_was_explicit = nodata is not None out_dtype = ( np.dtype(dtype) - if dtype is not None + if dtype_was_explicit else _promote_dtypes([inspection.dtypes[band] for band in resolved_bands]) ) resolved_nodata = ( nodata - if nodata is not None + if nodata_was_explicit else _resolve_output_nodata( [inspection.nodata_values[band] for band in resolved_bands], ) @@ -795,6 +818,8 @@ def strip_bucket(href: str) -> str: ids=ids, nodata=resolved_nodata, out_dtype=out_dtype, + dtype_was_explicit=dtype_was_explicit, + nodata_was_explicit=nodata_was_explicit, method_cls=method_cls, chunks=chunks, store=store, diff --git a/tests/benchmarks/test_regressions.py b/tests/benchmarks/test_regressions.py index 0958f31..a2468f0 100644 --- a/tests/benchmarks/test_regressions.py +++ b/tests/benchmarks/test_regressions.py @@ -38,16 +38,32 @@ def _write_asset_variant( *, nodata: float | None, pixel_updates: list[tuple[int, int, int]] | None = None, + dtype: str | None = None, ) -> str: """Copy one benchmark GeoTIFF and apply metadata/data tweaks in place.""" dest.parent.mkdir(parents=True, exist_ok=True) - copy2(_path_from_href(source_href), dest) - with rasterio.open(dest, "r+", IGNORE_COG_LAYOUT_BREAK="YES") as dataset: + if dtype is None: + copy2(_path_from_href(source_href), dest) + with rasterio.open(dest, "r+", IGNORE_COG_LAYOUT_BREAK="YES") as dataset: + dataset.nodata = nodata + if pixel_updates: + for row, col, value in pixel_updates: + patch = np.array([[value]], dtype=dataset.dtypes[0]) + dataset.write(patch, 1, window=Window(col, row, 1, 1)) + return dest.as_uri() + + with rasterio.open(_path_from_href(source_href)) as source: + profile = source.profile.copy() + profile.update(dtype=dtype, tiled=True) + data = source.read().astype(dtype) + + with rasterio.open(dest, "w", **profile) as dataset: + dataset.write(data) dataset.nodata = nodata if pixel_updates: for row, col, value in pixel_updates: - patch = np.array([[value]], dtype=dataset.dtypes[0]) + patch = np.array([[value]], dtype=dtype) dataset.write(patch, 1, window=Window(col, row, 1, 1)) return dest.as_uri() @@ -172,14 +188,181 @@ def test_open_accepts_conflicting_sampled_nodata_with_explicit_override( assert da.attrs["missing_value"] == -9999 -def test_chunk_reads_still_mask_per_cog_nodata_when_output_nodata_is_unknown( +def test_compute_raises_on_later_incompatible_auto_inferred_dtype( tmp_path: Path, benchmark_items: list[dict[str, Any]], ) -> None: - """Chunk reads still honor per-COG nodata. + """Compute fails loudly when a later item violates inferred dtype.""" + first_item = deepcopy(benchmark_items[0]) + row, col = _item_center_pixel(first_item, "red") + pixel_bbox = _pixel_bbox(first_item["assets"]["red"]["href"], row=row, col=col) + first_item["assets"]["red"]["href"] = _write_asset_variant( + first_item["assets"]["red"]["href"], + tmp_path / "dtype-conflict" / "red-masked-first.tif", + nodata=0, + pixel_updates=[(row, col, 0)], + ) + + second_item = deepcopy(first_item) + second_item["id"] = f"{first_item['id']}-float32" + second_item["assets"]["red"]["href"] = _write_asset_variant( + benchmark_items[0]["assets"]["red"]["href"], + tmp_path / "dtype-conflict" / "red-float32.tif", + nodata=0, + dtype="float32", + ) + + parquet_path = _write_items_parquet( + tmp_path / "dtype-conflict.parquet", + [first_item, second_item], + ) + + da = lazycogs.open( + parquet_path, + bbox=pixel_bbox, + crs=BENCHMARK_NATIVE_CRS, + resolution=10.0, + bands=BENCHMARK_SINGLE_BAND, + ) + + with pytest.raises(ValueError, match="Auto-inferred output dtype"): + da.compute() + + +def test_compute_accepts_mixed_dtypes_with_explicit_dtype( + tmp_path: Path, + benchmark_items: list[dict[str, Any]], +) -> None: + """Explicit output dtype remains authoritative for mixed source dtypes.""" + first_item = deepcopy(benchmark_items[0]) + row, col = _item_center_pixel(first_item, "red") + pixel_bbox = _pixel_bbox(first_item["assets"]["red"]["href"], row=row, col=col) + first_item["assets"]["red"]["href"] = _write_asset_variant( + first_item["assets"]["red"]["href"], + tmp_path / "dtype-explicit" / "red-masked-first.tif", + nodata=0, + pixel_updates=[(row, col, 0)], + ) + + second_item = deepcopy(first_item) + second_item["id"] = f"{first_item['id']}-float32" + second_item["assets"]["red"]["href"] = _write_asset_variant( + benchmark_items[0]["assets"]["red"]["href"], + tmp_path / "dtype-explicit" / "red-float32.tif", + nodata=0, + dtype="float32", + pixel_updates=[(row, col, 5)], + ) + + parquet_path = _write_items_parquet( + tmp_path / "dtype-explicit.parquet", + [first_item, second_item], + ) + + da = lazycogs.open( + parquet_path, + bbox=pixel_bbox, + crs=BENCHMARK_NATIVE_CRS, + resolution=10.0, + bands=BENCHMARK_SINGLE_BAND, + dtype="float32", + ) + + data = da.compute() + + assert data.dtype == np.dtype("float32") + assert data.item() == pytest.approx(5.0) + + +def test_compute_raises_on_later_conflicting_auto_inferred_nodata( + tmp_path: Path, + benchmark_items: list[dict[str, Any]], +) -> None: + """Compute fails loudly when a later item violates inferred nodata.""" + first_item = deepcopy(benchmark_items[0]) + row, col = _item_center_pixel(first_item, "red") + pixel_bbox = _pixel_bbox(first_item["assets"]["red"]["href"], row=row, col=col) + first_item["assets"]["red"]["href"] = _write_asset_variant( + first_item["assets"]["red"]["href"], + tmp_path / "nodata-conflict" / "red-masked-first.tif", + nodata=0, + pixel_updates=[(row, col, 0)], + ) + + second_item = deepcopy(first_item) + second_item["id"] = f"{first_item['id']}-nodata-conflict" + second_item["assets"]["red"]["href"] = _write_asset_variant( + benchmark_items[0]["assets"]["red"]["href"], + tmp_path / "nodata-conflict" / "red-nodata-conflict.tif", + nodata=-9999, + pixel_updates=[(row, col, 7)], + ) + + parquet_path = _write_items_parquet( + tmp_path / "nodata-conflict.parquet", + [first_item, second_item], + ) + + da = lazycogs.open( + parquet_path, + bbox=pixel_bbox, + crs=BENCHMARK_NATIVE_CRS, + resolution=10.0, + bands=BENCHMARK_SINGLE_BAND, + ) + + with pytest.raises(ValueError, match="Auto-inferred output nodata"): + da.compute() - This still works even when no output nodata is advertised. - """ + +def test_compute_accepts_conflicting_nodata_with_explicit_override( + tmp_path: Path, + benchmark_items: list[dict[str, Any]], +) -> None: + """Explicit output nodata remains authoritative for mixed source nodata.""" + first_item = deepcopy(benchmark_items[0]) + row, col = _item_center_pixel(first_item, "red") + pixel_bbox = _pixel_bbox(first_item["assets"]["red"]["href"], row=row, col=col) + first_item["assets"]["red"]["href"] = _write_asset_variant( + first_item["assets"]["red"]["href"], + tmp_path / "nodata-explicit" / "red-masked-first.tif", + nodata=0, + pixel_updates=[(row, col, 0)], + ) + + second_item = deepcopy(first_item) + second_item["id"] = f"{first_item['id']}-nodata-conflict" + second_item["assets"]["red"]["href"] = _write_asset_variant( + benchmark_items[0]["assets"]["red"]["href"], + tmp_path / "nodata-explicit" / "red-nodata-conflict.tif", + nodata=-9999, + pixel_updates=[(row, col, 7)], + ) + + da = lazycogs.open( + _write_items_parquet( + tmp_path / "nodata-explicit.parquet", + [first_item, second_item], + ), + bbox=pixel_bbox, + crs=BENCHMARK_NATIVE_CRS, + resolution=10.0, + bands=BENCHMARK_SINGLE_BAND, + nodata=0, + ) + + data = da.compute() + + assert data.shape == (1, 1, 1, 1) + assert data.item() == 7 + assert da.attrs["nodata"] == 0 + + +def test_chunk_reads_still_mask_per_cog_nodata_with_explicit_override( + tmp_path: Path, + benchmark_items: list[dict[str, Any]], +) -> None: + """Chunk reads still honor masked source pixels with explicit nodata.""" base_item = deepcopy(benchmark_items[0]) first_href = base_item["assets"]["red"]["href"] test_row, test_col = _item_center_pixel(base_item, "red") @@ -225,10 +408,11 @@ def test_chunk_reads_still_mask_per_cog_nodata_when_output_nodata_is_unknown( resolution=10.0, bands=BENCHMARK_SINGLE_BAND, mosaic_method=LowestMethod, + nodata=0, ) value = da.compute().item() - assert "nodata" not in da.attrs - assert "_FillValue" not in da.attrs - assert "missing_value" not in da.attrs + assert da.attrs["nodata"] == 0 + assert da.attrs["_FillValue"] == 0 + assert da.attrs["missing_value"] == 0 assert value == 10 diff --git a/tests/test_core.py b/tests/test_core.py index 0a4ee80..d00c3a7 100644 --- a/tests/test_core.py +++ b/tests/test_core.py @@ -15,6 +15,7 @@ from lazycogs._backend import MultiBandStacBackendArray from lazycogs._core import ( _build_time_steps, + _dtype_is_compatible, _inspect_first_item, _promote_dtypes, _resolve_output_nodata, @@ -466,11 +467,21 @@ def test_promote_dtypes_rejects_uint64_plus_int64(): @pytest.mark.parametrize( ("sampled", "expected"), - [([None, None], None), ([0, np.int16(0)], 0), ([-9999, -9999], -9999)], + [ + ([None, None], None), + ([0, np.int16(0)], 0), + ([-9999, -9999], -9999), + ([np.nan, np.nan], np.nan), + ], ) def test_resolve_output_nodata(sampled, expected): """Coherent sampled nodata values resolve to one scalar or None.""" - assert _resolve_output_nodata(sampled) == expected + resolved = _resolve_output_nodata(sampled) + if isinstance(expected, float) and np.isnan(expected): + assert isinstance(resolved, float) + assert np.isnan(resolved) + return + assert resolved == expected def test_resolve_output_nodata_rejects_conflicts(): @@ -478,6 +489,19 @@ def test_resolve_output_nodata_rejects_conflicts(): with pytest.raises(ValueError, match="Conflicting sampled nodata values"): _resolve_output_nodata([0, -9999]) + with pytest.raises(ValueError, match="Conflicting sampled nodata values"): + _resolve_output_nodata([0, np.nan]) + + +def test_dtype_is_compatible_accepts_equal_dtype(): + """A dtype is always compatible with itself.""" + assert _dtype_is_compatible(np.dtype("uint16"), np.dtype("uint16")) is True + + +def test_dtype_is_compatible_rejects_unsafe_cast(): + """Unsafe inferred output dtypes are rejected.""" + assert _dtype_is_compatible(np.dtype("float32"), np.dtype("uint16")) is False + def test_inspect_first_item_returns_dtype_and_nodata_metadata(): """Representative-item inspection returns ordered bands and sampled metadata.""" From d23021aca4621b7e54dddc877d76abbd68661af5 Mon Sep 17 00:00:00 2001 From: hrodmn Date: Mon, 25 May 2026 05:19:49 -0500 Subject: [PATCH 3/5] fix: account for mosaic method when auto-resolving dtype --- ARCHITECTURE.md | 6 ++-- README.md | 5 ++-- src/lazycogs/_core.py | 46 ++++++++++++++++++++++--------- tests/test_core.py | 64 ++++++++++++++++++++++++++++++++++++++++--- 4 files changed, 99 insertions(+), 22 deletions(-) diff --git a/ARCHITECTURE.md b/ARCHITECTURE.md index 528c71d..68046e5 100644 --- a/ARCHITECTURE.md +++ b/ARCHITECTURE.md @@ -47,9 +47,9 @@ src/lazycogs/ 4. Calls `_inspect_first_item()`: queries the parquet source via `duckdb_client.search(..., max_items=1)` to fetch one representative item, resolves preferred data assets (or caller-requested `bands=`), and opens one COG per requested band concurrently through `run_on_loop(...)`. 5. Resolves the output contract from that inspection result: - `bands`: explicit `bands=` wins, otherwise the inspected preferred-band order - - `dtype`: explicit `dtype=` wins, otherwise `_promote_dtypes(...)` + - `dtype`: explicit `dtype=` wins unless it is an integer paired with a float-only mosaic method; otherwise lazycogs infers from `_promote_dtypes(...)` and auto-promotes integer inference to `float32` for float-only methods - `nodata`: explicit `nodata=` wins, otherwise `_resolve_output_nodata(...)` - - float-only mosaic methods (`MeanMethod`, `MedianMethod`, `StdevMethod`) fail early unless the resolved dtype is floating + - float-only mosaic methods (`MeanMethod`, `MedianMethod`, `StdevMethod`) fail early only when the caller explicitly forces an integer dtype - inferred `dtype` and `nodata` are runtime-validated during chunk reads so later heterogeneous assets fail loudly instead of truncating or silently remapping nodata 6. Calls `_build_time_steps()`: queries the parquet source via `duckdb_client.search_to_arrow(...)` to obtain an Arrow table containing only the `datetime` and `start_datetime` columns (plus any filter/sort fields). Extracts timestamps from the Arrow columns without Python-level dict walking, buckets them with the `_TemporalGrouper`, deduplicates, and returns sorted `(filter_strings, time_coords)` pairs. Only groups with at least one item produce a time step. 7. Calls `compute_output_grid()` to get the output affine transform and dimensions (width, height). No eager coordinate arrays are produced. @@ -212,7 +212,7 @@ Each grouper provides three methods: `group_key()` maps a datetime string to a s - `FirstMethod`: Returns the first valid pixel seen. Short-circuits when all pixels are filled. - `HighestMethod` / `LowestMethod`: Tracks the running max / min across items. -- `MeanMethod` / `MedianMethod` / `StdevMethod`: Accumulates all arrays and reduces at the end. These methods advertise `requires_float = True`, so `open()` rejects inferred integer outputs unless the caller opts into a floating `dtype=`. +- `MeanMethod` / `MedianMethod` / `StdevMethod`: Accumulates all arrays and reduces at the end. These methods advertise `requires_float = True`, so `open()` auto-promotes inferred integer outputs to `float32` and rejects explicit integer `dtype=` overrides. - `CountMethod`: Counts valid (non-masked) observations per pixel. These are copied from `rio-tiler` (MIT licence, zero GDAL imports) to avoid pulling in rasterio as a transitive dependency. diff --git a/README.md b/README.md index c641def..47ec079 100644 --- a/README.md +++ b/README.md @@ -129,8 +129,9 @@ Explicit `dtype=` and `nodata=` stay authoritative even when source assets are heterogeneous. Float-only mosaic methods such as `MeanMethod`, `MedianMethod`, and -`StdevMethod` require a floating output dtype. If inference stays integer, -pass `dtype="float32"` or `dtype="float64"` explicitly. +`StdevMethod` auto-promote inferred integer outputs to `float32`. If you pass +an explicit integer `dtype=` with one of those methods, `open()` raises and +asks for `dtype="float32"` or `dtype="float64"` instead. ### Concurrency notes diff --git a/src/lazycogs/_core.py b/src/lazycogs/_core.py index 32a0f2a..f3c7b98 100644 --- a/src/lazycogs/_core.py +++ b/src/lazycogs/_core.py @@ -253,6 +253,30 @@ def _promote_dtypes(dtypes: list[np.dtype]) -> np.dtype: return _promote_integer_dtypes(normalized) +def _resolve_output_dtype( + sampled_dtypes: list[np.dtype], + *, + dtype: str | np.dtype | None, + method_cls: type[MosaicMethodBase], +) -> tuple[np.dtype, bool]: + """Resolve the output dtype, auto-promoting to float when required.""" + if dtype is not None: + resolved = np.dtype(dtype) + if method_cls.requires_float and not np.issubdtype(resolved, np.floating): + raise ValueError( + f"{method_cls.__name__} requires a floating-point dtype, " + f"but got explicit dtype {resolved}. " + "Pass dtype='float32' or dtype='float64', or omit dtype= to " + "let lazycogs choose a float dtype automatically.", + ) + return resolved, True + + resolved = _promote_dtypes(sampled_dtypes) + if method_cls.requires_float and not np.issubdtype(resolved, np.floating): + return np.dtype("float32"), False + return resolved, False + + def _dtype_is_compatible(source: np.dtype, resolved: np.dtype) -> bool: """Return True when *source* can be represented safely by *resolved*.""" return bool(np.can_cast(source, resolved, casting="safe")) @@ -624,7 +648,9 @@ def open( # noqa: A001 lazycogs advertises a scalar nodata sentinel only when sampled bands agree on one. dtype: Output array dtype. When omitted, inferred from sampled asset - dtypes on the first matching item. + dtypes on the first matching item. Float-only mosaic methods may + auto-promote inferred integer outputs to ``float32``. Explicit + integer ``dtype=`` still raises for those methods. mosaic_method: Mosaic method class (not instance) to use. Defaults to :class:`~lazycogs._mosaic_methods.FirstMethod`. time_period: ISO 8601 duration string controlling how items are @@ -776,13 +802,13 @@ def strip_bucket(href: str) -> str: f"(bbox={bbox_4326}, datetime={datetime}).", ) - dtype_was_explicit = dtype is not None - nodata_was_explicit = nodata is not None - out_dtype = ( - np.dtype(dtype) - if dtype_was_explicit - else _promote_dtypes([inspection.dtypes[band] for band in resolved_bands]) + method_cls = mosaic_method if mosaic_method is not None else FirstMethod + out_dtype, dtype_was_explicit = _resolve_output_dtype( + [inspection.dtypes[band] for band in resolved_bands], + dtype=dtype, + method_cls=method_cls, ) + nodata_was_explicit = nodata is not None resolved_nodata = ( nodata if nodata_was_explicit @@ -790,12 +816,6 @@ def strip_bucket(href: str) -> str: [inspection.nodata_values[band] for band in resolved_bands], ) ) - method_cls = mosaic_method if mosaic_method is not None else FirstMethod - if method_cls.requires_float and not np.issubdtype(out_dtype, np.floating): - raise ValueError( - f"{method_cls.__name__} requires a floating-point dtype, " - f"but got {out_dtype}. Pass dtype='float32' or dtype='float64'.", - ) logger.info( "Discovered %d bands and %d time steps.", diff --git a/tests/test_core.py b/tests/test_core.py index d00c3a7..37c53f4 100644 --- a/tests/test_core.py +++ b/tests/test_core.py @@ -18,9 +18,10 @@ _dtype_is_compatible, _inspect_first_item, _promote_dtypes, + _resolve_output_dtype, _resolve_output_nodata, ) -from lazycogs._mosaic_methods import MeanMethod +from lazycogs._mosaic_methods import MeanMethod, MedianMethod from lazycogs._temporal import _DayGrouper, _FixedDayGrouper, _MonthGrouper @@ -465,6 +466,28 @@ def test_promote_dtypes_rejects_uint64_plus_int64(): _promote_dtypes([np.dtype("uint64"), np.dtype("int64")]) +def test_resolve_output_dtype_auto_promotes_integer_inference_for_float_method(): + """Float-only methods auto-promote inferred integer outputs to float32.""" + resolved, was_explicit = _resolve_output_dtype( + [np.dtype("uint16")], + dtype=None, + method_cls=MedianMethod, + ) + + assert resolved == np.dtype("float32") + assert was_explicit is False + + +def test_resolve_output_dtype_rejects_explicit_integer_for_float_method(): + """Explicit integer output dtypes stay authoritative and fail loudly.""" + with pytest.raises(ValueError, match="explicit dtype uint16"): + _resolve_output_dtype( + [np.dtype("uint16")], + dtype="uint16", + method_cls=MeanMethod, + ) + + @pytest.mark.parametrize( ("sampled", "expected"), [ @@ -644,8 +667,40 @@ async def fake_open(path: str, *, store): assert da.attrs["_stac_backend"].store is store -def test_open_rejects_float_required_method_with_inferred_integer_dtype(tmp_path): - """Float-only mosaic methods fail early when dtype inference stays integer.""" +def test_open_auto_promotes_inferred_integer_dtype_for_float_method(tmp_path): + """Float-only mosaic methods auto-resolve inferred integer dtypes to float32.""" + + parquet = tmp_path / "items.parquet" + parquet.write_bytes(b"") + table = _items_to_arrow([{"properties": {"datetime": "2023-01-15T10:00:00Z"}}]) + + class _FakeGeoTIFF: + dtype = np.dtype("uint16") + nodata = 0 + + async def fake_open(path: str, *, store): + return _FakeGeoTIFF() + + with ( + patch("rustac.DuckdbClient.search", return_value=[_fake_open_item()]), + patch("rustac.DuckdbClient.search_to_arrow", return_value=table), + patch("lazycogs._core.GeoTIFF.open", side_effect=fake_open), + ): + da = lazycogs.open( + str(parquet), + bbox=(0.0, 0.0, 100.0, 100.0), + crs="EPSG:32632", + resolution=10.0, + mosaic_method=MeanMethod, + store=MemoryStore(), + path_from_href=lambda href: href.split("/", 3)[-1], + ) + + assert da.dtype == np.dtype("float32") + + +def test_open_rejects_explicit_integer_dtype_for_float_method(tmp_path): + """Float-only mosaic methods reject explicit integer output dtypes.""" parquet = tmp_path / "items.parquet" parquet.write_bytes(b"") @@ -662,13 +717,14 @@ async def fake_open(path: str, *, store): patch("rustac.DuckdbClient.search", return_value=[_fake_open_item()]), patch("rustac.DuckdbClient.search_to_arrow", return_value=table), patch("lazycogs._core.GeoTIFF.open", side_effect=fake_open), - pytest.raises(ValueError, match="requires a floating-point dtype"), + pytest.raises(ValueError, match="explicit dtype uint16"), ): lazycogs.open( str(parquet), bbox=(0.0, 0.0, 100.0, 100.0), crs="EPSG:32632", resolution=10.0, + dtype="uint16", mosaic_method=MeanMethod, store=MemoryStore(), path_from_href=lambda href: href.split("/", 3)[-1], From 84eb9fefc7ed8757d6532fe1405669631ae12623 Mon Sep 17 00:00:00 2001 From: hrodmn Date: Tue, 26 May 2026 11:00:42 -0500 Subject: [PATCH 4/5] fix: pass fill value to mosaic methods --- src/lazycogs/_chunk_reader.py | 4 +- src/lazycogs/_core.py | 13 ++++--- src/lazycogs/_mosaic_methods.py | 33 +++++++++------- tests/benchmarks/test_regressions.py | 57 +++++++++++++++++++++++----- tests/test_backend.py | 4 ++ tests/test_core.py | 35 +++++++++++++++-- tests/test_explain.py | 2 + 7 files changed, 114 insertions(+), 34 deletions(-) diff --git a/src/lazycogs/_chunk_reader.py b/src/lazycogs/_chunk_reader.py index 6d0764c..1bfb86c 100644 --- a/src/lazycogs/_chunk_reader.py +++ b/src/lazycogs/_chunk_reader.py @@ -664,13 +664,14 @@ async def read_chunk_async( # noqa: C901 ) semaphore = asyncio.Semaphore(max_concurrent_reads) + fill = nodata if nodata is not None else 0 async def _guarded(item: dict) -> dict[str, tuple[np.ndarray, float | None]] | None: async with semaphore: return await _read_item_band(item, bands, ctx) mosaic_methods: dict[str, MosaicMethodBase] = { - b: mosaic_method_cls() for b in bands + b: mosaic_method_cls(fill_value=fill) for b in bands } task_list: list[asyncio.Task] = [ @@ -696,7 +697,6 @@ def _error(idx: int, exc: BaseException) -> None: await _drain_in_order(task_list, _feed, _done, _error) - fill = nodata if nodata is not None else 0 output: dict[str, np.ndarray] = {} for band in bands: try: diff --git a/src/lazycogs/_core.py b/src/lazycogs/_core.py index f3c7b98..3035f79 100644 --- a/src/lazycogs/_core.py +++ b/src/lazycogs/_core.py @@ -574,11 +574,6 @@ def _build_dataarray( "_stac_time_coords": _CompactDateArray(time_coord), } - if nodata is not None: - attributes["nodata"] = nodata - attributes["_FillValue"] = nodata - attributes["missing_value"] = nodata - # Zarr geo-proj convention epsg = dst_crs.to_epsg() if epsg is not None: @@ -586,7 +581,7 @@ def _build_dataarray( else: attributes["proj:wkt2"] = dst_crs.to_wkt() - return DataArray( + data_array = DataArray( var, coords=Coordinates( {"band": resolved_bands, "time": time_coord, "spatial_ref": spatial_ref}, @@ -595,6 +590,12 @@ def _build_dataarray( attrs=attributes, ) + if nodata is not None: + data_array.attrs["_FillValue"] = nodata + data_array.encoding["_FillValue"] = nodata + + return data_array + def open( # noqa: A001 href: str, diff --git a/src/lazycogs/_mosaic_methods.py b/src/lazycogs/_mosaic_methods.py index 6880b4a..ba9eee3 100644 --- a/src/lazycogs/_mosaic_methods.py +++ b/src/lazycogs/_mosaic_methods.py @@ -21,9 +21,16 @@ class MosaicMethodBase(ABC): requires_float: bool = False - def __init__(self) -> None: - """Initialise an empty mosaic accumulator.""" + def __init__(self, *, fill_value: float = 0) -> None: + """Initialise an empty mosaic accumulator. + + Args: + fill_value: Value used when materialising still-masked output + pixels into a plain ndarray. + + """ self._mosaic: ma.MaskedArray | None = None + self._fill_value = fill_value @property def is_done(self) -> bool: @@ -36,11 +43,11 @@ def is_done(self) -> bool: def data(self) -> np.ndarray: """Return the filled mosaic as a plain numpy array. - Remaining masked pixels are filled with zero. + Remaining masked pixels are filled with the configured fill value. """ if self._mosaic is None: raise ValueError("No data has been fed to the mosaic method.") - return ma.filled(self._mosaic, 0) + return ma.filled(self._mosaic, self._fill_value) @abstractmethod def feed(self, arr: ma.MaskedArray) -> None: @@ -121,9 +128,9 @@ class MeanMethod(MosaicMethodBase): requires_float = True - def __init__(self) -> None: + def __init__(self, *, fill_value: float = 0) -> None: """Initialise accumulators for incremental mean computation.""" - super().__init__() + super().__init__(fill_value=fill_value) self._count: np.ndarray | None = None def feed(self, arr: ma.MaskedArray) -> None: @@ -159,7 +166,7 @@ def data(self) -> np.ndarray: """ if self._mosaic is None: raise ValueError("No data has been fed to the mosaic method.") - return ma.filled(self._mosaic, 0) + return ma.filled(self._mosaic, self._fill_value) class MedianMethod(MosaicMethodBase): @@ -167,9 +174,9 @@ class MedianMethod(MosaicMethodBase): requires_float = True - def __init__(self) -> None: + def __init__(self, *, fill_value: float = 0) -> None: """Initialise the tile stack.""" - super().__init__() + super().__init__(fill_value=fill_value) self._stack: list[ma.MaskedArray] = [] def feed(self, arr: ma.MaskedArray) -> None: @@ -201,7 +208,7 @@ def data(self) -> np.ndarray: if not self._stack: raise ValueError("No data has been fed to the mosaic method.") stacked = ma.array(self._stack) - return ma.filled(ma.median(stacked, axis=0), 0) + return ma.filled(ma.median(stacked, axis=0), self._fill_value) class StdevMethod(MosaicMethodBase): @@ -209,9 +216,9 @@ class StdevMethod(MosaicMethodBase): requires_float = True - def __init__(self) -> None: + def __init__(self, *, fill_value: float = 0) -> None: """Initialise the tile stack.""" - super().__init__() + super().__init__(fill_value=fill_value) self._stack: list[ma.MaskedArray] = [] def feed(self, arr: ma.MaskedArray) -> None: @@ -243,7 +250,7 @@ def data(self) -> np.ndarray: if not self._stack: raise ValueError("No data has been fed to the mosaic method.") stacked = ma.array(self._stack) - return ma.filled(stacked.std(axis=0), 0) + return ma.filled(stacked.std(axis=0), self._fill_value) class CountMethod(MosaicMethodBase): diff --git a/tests/benchmarks/test_regressions.py b/tests/benchmarks/test_regressions.py index a2468f0..9b9402b 100644 --- a/tests/benchmarks/test_regressions.py +++ b/tests/benchmarks/test_regressions.py @@ -113,9 +113,10 @@ def test_open_infers_uint16_and_coherent_nodata_from_benchmark_data( ) assert da.dtype == np.dtype("uint16") - assert da.attrs["nodata"] == 0 + assert "nodata" not in da.attrs + assert "missing_value" not in da.attrs assert da.attrs["_FillValue"] == 0 - assert da.attrs["missing_value"] == 0 + assert da.encoding["_FillValue"] == 0 def test_open_explicit_overrides_win_over_benchmark_inference( @@ -133,9 +134,10 @@ def test_open_explicit_overrides_win_over_benchmark_inference( ) assert da.dtype == np.dtype("float32") - assert da.attrs["nodata"] == -9999 + assert "nodata" not in da.attrs + assert "missing_value" not in da.attrs assert da.attrs["_FillValue"] == -9999 - assert da.attrs["missing_value"] == -9999 + assert da.encoding["_FillValue"] == -9999 def test_open_rejects_conflicting_sampled_nodata_on_local_benchmark_copy( @@ -183,9 +185,10 @@ def test_open_accepts_conflicting_sampled_nodata_with_explicit_override( nodata=-9999, ) - assert da.attrs["nodata"] == -9999 + assert "nodata" not in da.attrs + assert "missing_value" not in da.attrs assert da.attrs["_FillValue"] == -9999 - assert da.attrs["missing_value"] == -9999 + assert da.encoding["_FillValue"] == -9999 def test_compute_raises_on_later_incompatible_auto_inferred_dtype( @@ -355,7 +358,42 @@ def test_compute_accepts_conflicting_nodata_with_explicit_override( assert data.shape == (1, 1, 1, 1) assert data.item() == 7 - assert da.attrs["nodata"] == 0 + assert "nodata" not in da.attrs + assert "missing_value" not in da.attrs + assert da.attrs["_FillValue"] == 0 + assert da.encoding["_FillValue"] == 0 + + +def test_compute_preserves_explicit_nodata_for_fully_masked_pixels( + tmp_path: Path, + benchmark_items: list[dict[str, Any]], +) -> None: + """Fully masked pixels materialize as the explicit nodata value, not zero.""" + item = deepcopy(benchmark_items[0]) + row, col = _item_center_pixel(item, "red") + pixel_bbox = _pixel_bbox(item["assets"]["red"]["href"], row=row, col=col) + item["assets"]["red"]["href"] = _write_asset_variant( + item["assets"]["red"]["href"], + tmp_path / "nodata-fill" / "red-nodata-255.tif", + nodata=255, + pixel_updates=[(row, col, 255)], + ) + + da = lazycogs.open( + _write_items_parquet(tmp_path / "nodata-fill.parquet", [item]), + bbox=pixel_bbox, + crs=BENCHMARK_NATIVE_CRS, + resolution=10.0, + bands=BENCHMARK_SINGLE_BAND, + nodata=255, + ) + + data = da.compute() + + assert data.shape == (1, 1, 1, 1) + assert data.dtype == np.dtype("uint16") + assert data.item() == 255 + assert da.encoding["_FillValue"] == 255 def test_chunk_reads_still_mask_per_cog_nodata_with_explicit_override( @@ -412,7 +450,8 @@ def test_chunk_reads_still_mask_per_cog_nodata_with_explicit_override( ) value = da.compute().item() - assert da.attrs["nodata"] == 0 + assert "nodata" not in da.attrs + assert "missing_value" not in da.attrs assert da.attrs["_FillValue"] == 0 - assert da.attrs["missing_value"] == 0 + assert da.encoding["_FillValue"] == 0 assert value == 10 diff --git a/tests/test_backend.py b/tests/test_backend.py index c8e006f..2ee0e36 100644 --- a/tests/test_backend.py +++ b/tests/test_backend.py @@ -66,6 +66,8 @@ def _make_array( dtype=np.dtype("float32"), nodata=-9999.0, mosaic_method_cls=FirstMethod, + dtype_was_explicit=True, + nodata_was_explicit=True, ) @@ -207,6 +209,8 @@ def _make_multiband_array( dtype=np.dtype("float32"), nodata=-9999.0, mosaic_method_cls=FirstMethod, + dtype_was_explicit=True, + nodata_was_explicit=True, ) diff --git a/tests/test_core.py b/tests/test_core.py index 37c53f4..831c49d 100644 --- a/tests/test_core.py +++ b/tests/test_core.py @@ -21,7 +21,7 @@ _resolve_output_dtype, _resolve_output_nodata, ) -from lazycogs._mosaic_methods import MeanMethod, MedianMethod +from lazycogs._mosaic_methods import FirstMethod, MeanMethod, MedianMethod from lazycogs._temporal import _DayGrouper, _FixedDayGrouper, _MonthGrouper @@ -375,9 +375,9 @@ def test_open_sets_expected_dataarray_attributes(opened_dataarray): # Inferred output contract assert da.dtype == np.dtype("uint16") - assert da.attrs["nodata"] == 0 - assert da.attrs["_FillValue"] == 0 - assert da.attrs["missing_value"] == 0 + assert "nodata" not in da.attrs + assert "missing_value" not in da.attrs + assert da.encoding["_FillValue"] == da.attrs["_FillValue"] == 0 # Internal bookkeeping attributes assert isinstance(da.attrs["_stac_backend"], MultiBandStacBackendArray) @@ -526,6 +526,33 @@ def test_dtype_is_compatible_rejects_unsafe_cast(): assert _dtype_is_compatible(np.dtype("float32"), np.dtype("uint16")) is False +def test_first_method_fills_masked_pixels_with_configured_fill_value(): + """Masked mosaic output uses the resolved fill value, not a hard-coded zero.""" + method = FirstMethod(fill_value=255) + method.feed( + np.ma.MaskedArray( + np.array([[[255]]], dtype=np.uint8), + mask=np.array([[[True]]]), + ), + ) + + assert method.data.dtype == np.dtype("uint8") + assert method.data.item() == 255 + + +def test_median_method_fills_masked_pixels_with_configured_fill_value(): + """Statistical mosaic methods also honor the configured fill value.""" + method = MedianMethod(fill_value=255) + method.feed( + np.ma.MaskedArray( + np.array([[[255]]], dtype=np.uint8), + mask=np.array([[[True]]]), + ), + ) + + assert method.data.item() == 255 + + def test_inspect_first_item_returns_dtype_and_nodata_metadata(): """Representative-item inspection returns ordered bands and sampled metadata.""" diff --git a/tests/test_explain.py b/tests/test_explain.py index 6e8afd3..7da60f4 100644 --- a/tests/test_explain.py +++ b/tests/test_explain.py @@ -70,6 +70,8 @@ def _make_backend( dtype=np.dtype("float32"), nodata=-9999.0, mosaic_method_cls=FirstMethod, + dtype_was_explicit=True, + nodata_was_explicit=True, ) From 6d0c932dda06e5f7d00d42dceaf2885aeb8159ef Mon Sep 17 00:00:00 2001 From: hrodmn Date: Tue, 26 May 2026 11:00:59 -0500 Subject: [PATCH 5/5] docs: add dtype/nodata guide, HLS masking example notebook --- ARCHITECTURE.md | 5 +- README.md | 12 +- dev-docs/specs/auto-detect-dtype-nodata.md | 19 +- docs/api/open.md | 2 +- docs/guides/dtype-nodata.md | 108 + docs/index.md | 2 +- docs/notebooks/hls-analysis.ipynb | 4537 ++++++++++++++++++++ mkdocs.yml | 2 + 8 files changed, 4669 insertions(+), 18 deletions(-) create mode 100644 docs/guides/dtype-nodata.md create mode 100644 docs/notebooks/hls-analysis.ipynb diff --git a/ARCHITECTURE.md b/ARCHITECTURE.md index 68046e5..6c2ea76 100644 --- a/ARCHITECTURE.md +++ b/ARCHITECTURE.md @@ -55,7 +55,7 @@ src/lazycogs/ 7. Calls `compute_output_grid()` to get the output affine transform and dimensions (width, height). No eager coordinate arrays are produced. 8. Creates a single `MultiBandStacBackendArray` (a dataclass) with shape `(band, time, y, x)` holding all the parameters needed to materialise any chunk later, then wraps it in one `xarray.core.indexing.LazilyIndexedArray`. This avoids `xr.concat` (used internally by `ds.to_array()`), which would eagerly load `LazilyIndexedArray`-backed objects. 9. Uses `rasterix.RasterIndex` for spatial indexing, but materialises the x/y coordinate variables eagerly as numpy arrays so chunked scalar spatial selections compute reliably. -10. Constructs the `xr.DataArray` directly from the 4-D variable. If `chunks` is provided, calls `.chunk(chunks)` to convert to a dask-backed array; otherwise the `LazilyIndexedArray` remains in play so narrow slices (e.g. a single pixel) translate to minimal I/O. When output nodata is known, the returned array advertises it via `attrs["nodata"]`, `attrs["_FillValue"]`, and `attrs["missing_value"]`; when unknown, none of those attrs are attached. +10. Constructs the `xr.DataArray` directly from the 4-D variable. If `chunks` is provided, calls `.chunk(chunks)` to convert to a dask-backed array; otherwise the `LazilyIndexedArray` remains in play so narrow slices (e.g. a single pixel) translate to minimal I/O. When output nodata is known, the returned array sets `da.attrs["_FillValue"]` and `da.encoding["_FillValue"]` for downstream serialization. When unknown, no `_FillValue` metadata is attached. 11. Stores `_stac_backend` (the `MultiBandStacBackendArray` instance) and `_stac_time_coords` (the full time coordinate array) in `da.attrs` so that `da.lazycogs.explain()` can reconstruct the explain plan without re-specifying `open()` parameters. ## Explain: dry-run read estimator @@ -215,6 +215,8 @@ Each grouper provides three methods: `group_key()` maps a datetime string to a s - `MeanMethod` / `MedianMethod` / `StdevMethod`: Accumulates all arrays and reduces at the end. These methods advertise `requires_float = True`, so `open()` auto-promotes inferred integer outputs to `float32` and rejects explicit integer `dtype=` overrides. - `CountMethod`: Counts valid (non-masked) observations per pixel. +For nodata-aware methods, any pixels that remain masked after mosaicking are materialized with the resolved output nodata sentinel when one is known, or with `0` only when output nodata is unknown. + These are copied from `rio-tiler` (MIT licence, zero GDAL imports) to avoid pulling in rasterio as a transitive dependency. ## Temporal compositing @@ -282,5 +284,6 @@ The documentation site is built with [mkdocs-material](https://squidfunk.github. - **Introduction**: rendered from `README.md` (symlinked as `docs/index.md`) - **Examples**: two Jupyter notebooks rendered by `mkdocs-jupyter` — `docs/demo_midwest_daily.ipynb` (daily Sentinel-2 array over the Midwest US) and `docs/demo_southwest_monthly.ipynb` (monthly low-cloud composite over the US Southwest) - **API Reference**: auto-generated from docstrings by `mkdocstrings[python]` +- **Guides**: focused docs for topics like STAC queries, chunking, cloud storage, and dtype/nodata handling To preview locally: `uv run mkdocs serve` diff --git a/README.md b/README.md index 47ec079..4ffc11c 100644 --- a/README.md +++ b/README.md @@ -107,6 +107,8 @@ For most users, the recommended path is still obstore: leave `store=None` to aut ## Dtype and nodata semantics +See also: [docs guide on dtype and nodata handling](docs/guides/dtype-nodata.md). + When you omit `dtype=`, `lazycogs.open()` samples one representative COG per requested band and infers one safe output dtype instead of defaulting to `float32`. That inferred dtype is then enforced at chunk-read time: if a later @@ -116,12 +118,13 @@ asks you to pass `dtype=` explicitly. When you omit `nodata=`: - if sampled bands all agree on one scalar nodata sentinel, the returned - `DataArray` gets `attrs["nodata"]`, `attrs["_FillValue"]`, and - `attrs["missing_value"]` + `DataArray` sets `attrs["_FillValue"]` and `encoding["_FillValue"]`, and + masked mosaic output materializes with that same sentinel instead of zero - if sampled bands disagree, `open()` raises `ValueError` and asks you to pass `nodata=` explicitly -- if sampled bands have no nodata sentinel, no nodata attrs are attached and - `0` remains only an implementation fill value for uncovered regions +- if sampled bands have no nodata sentinel, no `_FillValue` encoding is + attached and `0` remains only an implementation fill value for uncovered + regions - if later chunk reads encounter a conflicting source nodata value, compute raises and asks you to pass `nodata=` explicitly @@ -157,5 +160,6 @@ asks for `dtype="float32"` or `dtype="float64"` instead. - [Home](https://developmentseed.github.io/lazycogs/) — quickstart and full usage guide - [Example: Midwest US daily Sentinel-2 array](https://developmentseed.org/lazycogs/notebooks/demo_midwest_daily/) - [Example: Southwest US monthly low-cloud Sentinel-2 array](https://developmentseed.org/lazycogs/notebooks/demo_southwest_monthly/) +- [Guide: dtype and nodata handling](https://developmentseed.org/lazycogs/guides/dtype-nodata/) - [Architecture](https://developmentseed.org/lazycogs/architecture/) - [Contributing](CONTRIBUTING.md) diff --git a/dev-docs/specs/auto-detect-dtype-nodata.md b/dev-docs/specs/auto-detect-dtype-nodata.md index 04c61e9..a2d7515 100644 --- a/dev-docs/specs/auto-detect-dtype-nodata.md +++ b/dev-docs/specs/auto-detect-dtype-nodata.md @@ -58,13 +58,12 @@ When lazycogs can determine one scalar output nodata value, that value means: - out-of-bounds pixels introduced by reprojection - pixels that remain invalid after mosaicking because every contributing input pixel was nodata -When nodata is known, the returned `DataArray` should advertise it in attrs: +When nodata is known, the returned `DataArray` should advertise it via: -- `nodata` -- `_FillValue` -- `missing_value` +- `attrs["_FillValue"]` +- `encoding["_FillValue"]` -This is intentionally boring. It gives callers one obvious place to inspect and gives future serialization work a clear contract. +This keeps the contract lean and aligns with downstream serialization tools such as rioxarray. ### 3. Auto-detected nodata must be coherent, not guessed @@ -249,12 +248,10 @@ What changes is the startup contract and metadata, not the basic masking algorit When output nodata is known, `_build_dataarray()` should attach: ```python -attrs["nodata"] = out_nodata -attrs["_FillValue"] = out_nodata -attrs["missing_value"] = out_nodata +da.encoding["_FillValue"] = out_nodata ``` -When output nodata is `None`, none of those attrs should be set. +When output nodata is `None`, no `_FillValue` encoding should be set. This spec does not require xarray encoding changes yet. @@ -286,7 +283,7 @@ Add focused unit coverage for: Add integration coverage for: - integer collection -> inferred integer dtype -- inferred nodata attached to `da.attrs` +- inferred nodata attached to `da.encoding["_FillValue"]` - conflicting sampled nodata -> `ValueError` unless `nodata=` is passed - `MeanMethod` with inferred integer dtype -> `ValueError` - explicit `dtype="float32"` still works with float-required methods @@ -313,7 +310,7 @@ Existing behavior should remain true for: ## Open questions - Should `CountMethod` force an integer output dtype when `dtype` is omitted, or should it continue to respect the generic promotion result? For now this spec leaves `CountMethod` alone. -- Should future serialization work move `_FillValue` / `missing_value` into xarray encoding as well as attrs? Probably yes, but that is out of scope here. +- Should lazycogs eventually offer an explicit nodata decoding mode for in-memory analysis, rather than only advertising `_FillValue` for downstream serialization? - If a collection has no source nodata and the user omits `nodata=`, should lazycogs eventually promote integer outputs to float and use `NaN` for uncovered pixels? That would be a larger behavioral change and is not part of this pass. ## Recommended next implementation order diff --git a/docs/api/open.md b/docs/api/open.md index f99e7cc..51faaf4 100644 --- a/docs/api/open.md +++ b/docs/api/open.md @@ -1,6 +1,6 @@ # open !!! tip "See also" - [Quickstart](../notebooks/quickstart.ipynb) · [STAC item queries guide](../guides/stac-search.md) · [Temporal grouping guide](../guides/temporal-grouping.md) · [Cloud storage guide](../guides/cloud-storage.md) · [Chunking guide](../guides/chunking.md) · [Inspecting read plans](../notebooks/explain.ipynb) + [Quickstart](../notebooks/quickstart.ipynb) · [STAC item queries guide](../guides/stac-search.md) · [Temporal grouping guide](../guides/temporal-grouping.md) · [Dtype and nodata guide](../guides/dtype-nodata.md) · [Cloud storage guide](../guides/cloud-storage.md) · [Chunking guide](../guides/chunking.md) · [Inspecting read plans](../notebooks/explain.ipynb) ::: lazycogs.open diff --git a/docs/guides/dtype-nodata.md b/docs/guides/dtype-nodata.md new file mode 100644 index 0000000..d28d9da --- /dev/null +++ b/docs/guides/dtype-nodata.md @@ -0,0 +1,108 @@ +# Dtype and nodata handling + +`lazycogs.open()` returns a plain numeric `xarray.DataArray`. It does not return a masked array. + +That means lazycogs has to make two output-level decisions: + +- `dtype`: the numeric type of the returned array +- `nodata`: one scalar sentinel value for missing pixels, when that sentinel is knowable + +Internal masking still happens while reading and mosaicking COGs, but the public contract is always the numeric array you get back. + + +## Default behavior + +When you omit `dtype=` and `nodata=`, lazycogs inspects the first matching STAC item and opens one representative COG per requested band. + +From that sample it resolves: + +- one safe output `dtype` +- one output `nodata` value, if the sampled bands agree on one + +### Dtype inference + +The sampled band dtypes are promoted to one safe output dtype. + +Examples: + +- all `uint16` -> `uint16` +- `uint8` + `int16` -> `int16` +- any `float32` present -> `float32` +- any `float64` present -> `float64` + +If lazycogs cannot promote the sampled dtypes safely, `open()` raises and asks you to pass `dtype=` explicitly. + +### Nodata inference + +When you omit `nodata=`: + +- if sampled bands all agree on one scalar nodata value, lazycogs uses it +- if sampled bands all have `nodata=None`, lazycogs leaves output nodata unknown +- if sampled bands disagree, `open()` raises and asks you to pass `nodata=` explicitly + +When nodata is known, the returned `DataArray` advertises it in both: + +- `da.attrs["_FillValue"]` +- `da.encoding["_FillValue"]` + +## What output nodata means + +When lazycogs knows one scalar nodata value, that value applies to: + +- uncovered pixels +- out-of-bounds pixels introduced by reprojection +- pixels where every contributing source pixel was nodata + +When nodata is unknown, lazycogs does **not** attach `_FillValue` metadata. In that mode, `0` may still appear in uncovered regions as an implementation fill value, but `0` is not declared as semantic nodata. + +If you need a stable sentinel for downstream analysis or export, pass `nodata=` explicitly. + +## Mosaic-method interaction + +`MeanMethod`, `MedianMethod`, and `StdevMethod` require floating-point output. + +If you omit `dtype=`, lazycogs will auto-promote an inferred integer dtype to `float32` for those methods. If you pass an explicit integer `dtype=`, `open()` raises. + +```python +from lazycogs import MeanMethod + +da = lazycogs.open( + "items.parquet", + bbox=dst_bbox, + crs=dst_crs, + resolution=10.0, + mosaic_method=MeanMethod, +) +``` + +## Explicit overrides win + +Caller-provided `dtype=` and `nodata=` are authoritative. + +```python +da = lazycogs.open( + "items.parquet", + bbox=dst_bbox, + crs=dst_crs, + resolution=10.0, + dtype="float32", + nodata=-9999, +) +``` + +Use explicit overrides when you need a fixed contract across heterogeneous assets. + +## Runtime validation + +The startup inspection samples only one representative item. Later chunk reads still validate what they encounter. + +If a later asset conflicts with the inferred output contract, compute raises instead of silently truncating values or remapping nodata. + +## Quick checks + +```python +da.dtype +da.encoding.get("_FillValue") +``` + +Those two values tell you most of what lazycogs has promised about the returned array. diff --git a/docs/index.md b/docs/index.md index 4ecd7fc..0a77152 100644 --- a/docs/index.md +++ b/docs/index.md @@ -87,4 +87,4 @@ event loop. Multiple concurrent chunk reads overlap naturally, so the async path can be faster than the synchronous `da.compute()` when reading many chunks inside an already-running loop. -Get started with the [Quickstart](notebooks/quickstart.ipynb). Evaluating lazycogs against alternatives? See [Performance](performance.md). +Get started with the [Quickstart](notebooks/quickstart.ipynb). Need details on inferred output contracts? See the [dtype and nodata guide](guides/dtype-nodata.md). Evaluating lazycogs against alternatives? See [Performance](performance.md). diff --git a/docs/notebooks/hls-analysis.ipynb b/docs/notebooks/hls-analysis.ipynb new file mode 100644 index 0000000..63b9aad --- /dev/null +++ b/docs/notebooks/hls-analysis.ipynb @@ -0,0 +1,4537 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "9143c8d1-8c22-48f8-a808-73a760733dea", + "metadata": {}, + "source": [ + "# HLS NDVI Analysis\n", + "\n", + "This notebook shows how to use lazycogs with NASA HLS to build an NDVI time series while relying on auto-detected dtype and nodata metadata and masking invalid pixels with the `Fmask` QA band.\n", + "\n", + "We open the spectral bands and the `Fmask` band separately because they have different source dtypes and play different roles in the workflow: the reflectance bands stay integer on open, while `Fmask` is a QA bitfield that we inspect with bitwise operations.\n", + "\n", + "**Note:** This tutorial shows how to access the HLS granules using https links. If you are able to run your compute in the AWS us-west-2 region, try the access method outlined in [HLS Example (us-west-2 only)](./hls-s3.ipynb)." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "9da22a4e-91b1-47d3-9bb6-849aa616d4c5", + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "\n", + "import requests\n", + "import rustac\n", + "from obstore.store import HTTPStore\n", + "from pyproj import Transformer\n", + "\n", + "import lazycogs\n", + "\n", + "HLS_STAC_GEOPARQUET_PREFIX = \"s3://nasa-maap-data-store/file-staging/nasa-map\"\n", + "HLS_STAC_GEOPARQUET_PATH_FORMAT = (\n", + " \"hls-stac-geoparquet-archive/v2/{collection}\"\n", + " \"/year={year}/month={month}/{collection}-{year}-{month}.parquet\"\n", + ")\n", + "HLS_STAC_GEOPARQUET_HREF = (\n", + " HLS_STAC_GEOPARQUET_PREFIX + \"/\" + HLS_STAC_GEOPARQUET_PATH_FORMAT\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "7ce944e0-0b9e-4e02-b8ff-a663c35a2e87", + "metadata": {}, + "source": [ + "### Define the array's spatial extent\n", + "\n", + "The HLS granules are projected in UTM coordinate reference systems. To access the underlying data in an undistorted efficient manner the best way is to build an array for a single UTM coordinate system that is aligned with the grid of the COGs themselves.\n", + "\n", + "We can define an AOI for an entire UTM zone like this:" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "9b5daa41-efd2-4581-9051-8f07a10fb7a6", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(-96, 0, -90, 84)\n", + "(166021.44308053772, 0.0, 833978.5569194595, 9329005.182447437)\n" + ] + } + ], + "source": [ + "epsg_code = \"32615\"\n", + "utm_zone = 15\n", + "dst_crs = f\"epsg:{epsg_code}\"\n", + "\n", + "east_edge = (utm_zone * 6) - 180\n", + "west_edge = east_edge - 6\n", + "bbox_4326 = (west_edge, 0, east_edge, 84)\n", + "\n", + "# transform to epsg:4326 for STAC search\n", + "transformer = Transformer.from_crs(\"epsg:4326\", dst_crs, always_xy=True)\n", + "dst_bbox = transformer.transform_bounds(*bbox_4326)\n", + "\n", + "print(bbox_4326)\n", + "print(dst_bbox)" + ] + }, + { + "cell_type": "markdown", + "id": "8c0e9d1d-51f8-47bb-8f4f-03b8b147332c", + "metadata": {}, + "source": [ + "Retrieve a single STAC item so we can snap our approximate bounding box to the HLS granule grid." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "288ddc23-b002-47e6-84d4-bab7675eeecb", + "metadata": {}, + "outputs": [], + "source": [ + "hls_parquet_href = HLS_STAC_GEOPARQUET_HREF.format(\n", + " collection=\"HLSS30_2.0\",\n", + " year=\"2025\",\n", + " month=\"7\",\n", + ")\n", + "\n", + "sample_item = rustac.search_sync(\n", + " hls_parquet_href,\n", + " bbox=bbox_4326,\n", + " filter={\"op\": \"=\", \"args\": [{\"property\": \"proj:epsg\"}, epsg_code]},\n", + " fields=[\"proj:transform\", \"proj:epsg\"],\n", + " max_items=1,\n", + ")[0]" + ] + }, + { + "cell_type": "markdown", + "id": "8b5259e0-47aa-4467-889a-fbc7afddea53", + "metadata": {}, + "source": [ + "Use the `proj:transform` property to align our rough bounding box with the HLS grid" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "4fe3b41a-1c46-47d7-a546-20e3e679710e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "aligned bbox: (166020.0, 0.0, 834000.0, 9329010.0)\n" + ] + } + ], + "source": [ + "dst_bbox_aligned = lazycogs.align_bbox(\n", + " sample_item[\"properties\"][\"proj:transform\"],\n", + " dst_bbox,\n", + ")\n", + "\n", + "print(f\"aligned bbox: {dst_bbox_aligned}\")" + ] + }, + { + "cell_type": "markdown", + "id": "82b9b6d1-245b-4008-a84b-29199082a32d", + "metadata": {}, + "source": [ + "### Configure access to the HLS COGs over HTTP\n", + "\n", + "The STAC assets in the stac-geoparquet file contain `https` hrefs but they require an EDL token to access. obstore's `HTTPStore` allows you to provide the `Authorization: Bearer ` header via `default_headers` in the `client_options` dict.\n", + "\n", + "This will work for you if you have your NASA Earthdata credentials stored in the `EARTHDATA_USERNAME` and `EARTHDATA_PASSWORD` environment variables." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "8d4fcbd6-81cc-4db0-808d-47fbe9fc0c6d", + "metadata": {}, + "outputs": [], + "source": [ + "def get_earthdata_token(username: str, password: str) -> str:\n", + " r = requests.post(\n", + " \"https://urs.earthdata.nasa.gov/api/users/find_or_create_token\",\n", + " auth=(username, password),\n", + " timeout=10,\n", + " )\n", + " r.raise_for_status()\n", + " return r.json()[\"access_token\"]\n", + "\n", + "\n", + "token = get_earthdata_token(\n", + " os.getenv(\"EARTHDATA_USERNAME\"),\n", + " os.getenv(\"EARTHDATA_PASSWORD\"),\n", + ")\n", + "\n", + "store_prefix = \"https://data.lpdaac.earthdatacloud.nasa.gov\"\n", + "\n", + "store = HTTPStore(\n", + " store_prefix,\n", + " client_options={\n", + " \"default_headers\": {\n", + " \"Authorization\": f\"Bearer {token}\",\n", + " },\n", + " },\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "ab6a8765-e006-40e1-b88a-3d2883310a65", + "metadata": {}, + "source": [ + "### Open spectral data array\n", + "\n", + "For NDVI we need the NIR and red bands so we will open an array that targets just those bands. We open these spectral bands separately from `Fmask` because the reflectance data and QA bitfield have different dtypes, and keeping them separate makes both the data model and the later analysis clearer. Since we are going to do some array masking and math, it is safest to specify a dask chunking scheme to avoid eagerly computing any massive arrays.\n", + "\n", + "In the array repr below, note that lazycogs auto-detects an integer dtype for the spectral data and attaches the inferred `_FillValue` metadata instead of requiring us to hard-code either one." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "0870266e-1c3e-4b57-b197-19e69e7631f9", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.DataArray (band: 2, time: 31, y: 310967, x: 22266)> Size: 859GB\n",
+       "dask.array<array, shape=(2, 31, 310967, 22266), dtype=int16, chunksize=(2, 1, 1024, 1024), chunktype=numpy.ndarray>\n",
+       "Coordinates:\n",
+       "  * band         (band) <U3 24B 'B08' 'B04'\n",
+       "  * time         (time) datetime64[s] 248B 2025-07-01 2025-07-02 ... 2025-07-31\n",
+       "  * y            (y) float64 2MB 9.329e+06 9.329e+06 9.329e+06 ... 45.0 15.0\n",
+       "  * x            (x) float64 178kB 1.66e+05 1.661e+05 ... 8.34e+05 8.34e+05\n",
+       "    spatial_ref  int64 8B 0\n",
+       "Indexes:\n",
+       "  ┌ x        RasterIndex (crs=EPSG:32615)\n",
+       "  └ y\n",
+       "Attributes:\n",
+       "    grid_mapping:            spatial_ref\n",
+       "    zarr_conventions:        [{'schema_url': 'https://raw.githubusercontent.c...\n",
+       "    spatial:dimensions:      ['y', 'x']\n",
+       "    spatial:bbox:            (166020.0, 0.0, 834000.0, 9329010.0)\n",
+       "    spatial:transform_type:  affine\n",
+       "    spatial:transform:       [30.0, 0.0, 166020.0, 0.0, -30.0, 9329010.0]\n",
+       "    spatial:shape:           [310967, 22266]\n",
+       "    spatial:registration:    pixel\n",
+       "    _stac_backend:           MultiBandStacBackendArray(bands=['B08', 'B04'], ...\n",
+       "    _stac_time_coords:       2025-07-01 … 2025-07-31 (n=31)\n",
+       "    proj:code:               EPSG:32615\n",
+       "    _FillValue:              -9999.0
" + ], + "text/plain": [ + " Size: 859GB\n", + "dask.array\n", + "Coordinates:\n", + " * band (band) \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.DataArray (time: 31, y: 310967, x: 22266)> Size: 215GB\n",
+       "dask.array<getitem, shape=(31, 310967, 22266), dtype=uint8, chunksize=(1, 1024, 1024), chunktype=numpy.ndarray>\n",
+       "Coordinates:\n",
+       "  * time         (time) datetime64[s] 248B 2025-07-01 2025-07-02 ... 2025-07-31\n",
+       "  * y            (y) float64 2MB 9.329e+06 9.329e+06 9.329e+06 ... 45.0 15.0\n",
+       "  * x            (x) float64 178kB 1.66e+05 1.661e+05 ... 8.34e+05 8.34e+05\n",
+       "    band         <U5 20B 'Fmask'\n",
+       "    spatial_ref  int64 8B 0\n",
+       "Indexes:\n",
+       "  ┌ x        RasterIndex (crs=EPSG:32615)\n",
+       "  └ y\n",
+       "Attributes:\n",
+       "    grid_mapping:            spatial_ref\n",
+       "    zarr_conventions:        [{'schema_url': 'https://raw.githubusercontent.c...\n",
+       "    spatial:dimensions:      ['y', 'x']\n",
+       "    spatial:bbox:            (166020.0, 0.0, 834000.0, 9329010.0)\n",
+       "    spatial:transform_type:  affine\n",
+       "    spatial:transform:       [30.0, 0.0, 166020.0, 0.0, -30.0, 9329010.0]\n",
+       "    spatial:shape:           [310967, 22266]\n",
+       "    spatial:registration:    pixel\n",
+       "    _stac_backend:           MultiBandStacBackendArray(bands=['Fmask'], shape...\n",
+       "    _stac_time_coords:       2025-07-01 … 2025-07-31 (n=31)\n",
+       "    proj:code:               EPSG:32615\n",
+       "    _FillValue:              255.0
" + ], + "text/plain": [ + " Size: 215GB\n", + "dask.array\n", + "Coordinates:\n", + " * time (time) datetime64[s] 248B 2025-07-01 2025-07-02 ... 2025-07-31\n", + " * y (y) float64 2MB 9.329e+06 9.329e+06 9.329e+06 ... 45.0 15.0\n", + " * x (x) float64 178kB 1.66e+05 1.661e+05 ... 8.34e+05 8.34e+05\n", + " band \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.DataArray (time: 31, y: 310967, x: 22266)> Size: 215GB\n",
+       "dask.array<eq, shape=(31, 310967, 22266), dtype=bool, chunksize=(1, 1024, 1024), chunktype=numpy.ndarray>\n",
+       "Coordinates:\n",
+       "  * time         (time) datetime64[s] 248B 2025-07-01 2025-07-02 ... 2025-07-31\n",
+       "  * y            (y) float64 2MB 9.329e+06 9.329e+06 9.329e+06 ... 45.0 15.0\n",
+       "  * x            (x) float64 178kB 1.66e+05 1.661e+05 ... 8.34e+05 8.34e+05\n",
+       "    band         <U5 20B 'Fmask'\n",
+       "    spatial_ref  int64 8B 0\n",
+       "Indexes:\n",
+       "  ┌ x        RasterIndex (crs=EPSG:32615)\n",
+       "  └ y\n",
+       "Attributes:\n",
+       "    grid_mapping:            spatial_ref\n",
+       "    zarr_conventions:        [{'schema_url': 'https://raw.githubusercontent.c...\n",
+       "    spatial:dimensions:      ['y', 'x']\n",
+       "    spatial:bbox:            (166020.0, 0.0, 834000.0, 9329010.0)\n",
+       "    spatial:transform_type:  affine\n",
+       "    spatial:transform:       [30.0, 0.0, 166020.0, 0.0, -30.0, 9329010.0]\n",
+       "    spatial:shape:           [310967, 22266]\n",
+       "    spatial:registration:    pixel\n",
+       "    _stac_backend:           MultiBandStacBackendArray(bands=['Fmask'], shape...\n",
+       "    _stac_time_coords:       2025-07-01 … 2025-07-31 (n=31)\n",
+       "    proj:code:               EPSG:32615\n",
+       "    _FillValue:              255.0
" + ], + "text/plain": [ + " Size: 215GB\n", + "dask.array\n", + "Coordinates:\n", + " * time (time) datetime64[s] 248B 2025-07-01 2025-07-02 ... 2025-07-31\n", + " * y (y) float64 2MB 9.329e+06 9.329e+06 9.329e+06 ... 45.0 15.0\n", + " * x (x) float64 178kB 1.66e+05 1.661e+05 ... 8.34e+05 8.34e+05\n", + " band " + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "valid_mask_sample = valid_mask.sel(\n", + " x=slice(447063, 515442),\n", + " y=slice(5146127, 5098771),\n", + " method=\"nearest\",\n", + ").isel(time=3)\n", + "\n", + "(\n", + " valid_mask_sample.plot.imshow(\n", + " aspect=valid_mask_sample.shape[1] / valid_mask_sample.shape[0],\n", + " size=6,\n", + " )\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "8e8e105f-33ce-4038-ac13-1f6a8399a7ed", + "metadata": {}, + "source": [ + "## Calculate daily NDVI values for valid pixels\n", + "\n", + "Convert the spectral `DataArray` to a `Dataset` for easier band math operations, then use `xr.where` to apply the mask from the previous step. The source reflectance bands remain integer, but the NDVI calculation itself is floating-point math, so this is also the point where the analysis naturally moves from source storage semantics to derived-value semantics." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "58432497-3946-4dcf-bb47-da237d33a18f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.DataArray (time: 31, y: 310967, x: 22266)> Size: 859GB\n",
+       "dask.array<truediv, shape=(31, 310967, 22266), dtype=float32, chunksize=(1, 1024, 1024), chunktype=numpy.ndarray>\n",
+       "Coordinates:\n",
+       "  * time         (time) datetime64[s] 248B 2025-07-01 2025-07-02 ... 2025-07-31\n",
+       "  * y            (y) float64 2MB 9.329e+06 9.329e+06 9.329e+06 ... 45.0 15.0\n",
+       "  * x            (x) float64 178kB 1.66e+05 1.661e+05 ... 8.34e+05 8.34e+05\n",
+       "    spatial_ref  int64 8B 0\n",
+       "    band         <U4 16B 'NDVI'\n",
+       "Indexes:\n",
+       "  ┌ x        RasterIndex (crs=EPSG:32615)\n",
+       "  └ y
" + ], + "text/plain": [ + " Size: 859GB\n", + "dask.array\n", + "Coordinates:\n", + " * time (time) datetime64[s] 248B 2025-07-01 2025-07-02 ... 2025-07-31\n", + " * y (y) float64 2MB 9.329e+06 9.329e+06 9.329e+06 ... 45.0 15.0\n", + " * x (x) float64 178kB 1.66e+05 1.661e+05 ... 8.34e+05 8.34e+05\n", + " spatial_ref int64 8B 0\n", + " band \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.DataArray (time: 31, y: 447, x: 644)> Size: 36MB\n",
+       "dask.array<getitem, shape=(31, 447, 644), dtype=float32, chunksize=(1, 447, 384), chunktype=numpy.ndarray>\n",
+       "Coordinates:\n",
+       "  * time         (time) datetime64[s] 248B 2025-07-01 2025-07-02 ... 2025-07-31\n",
+       "  * y            (y) float64 4kB 5.178e+06 5.178e+06 ... 5.164e+06 5.164e+06\n",
+       "  * x            (x) float64 5kB 5.269e+05 5.269e+05 ... 5.461e+05 5.462e+05\n",
+       "    spatial_ref  int64 8B 0\n",
+       "    band         <U4 16B 'NDVI'\n",
+       "Indexes:\n",
+       "  ┌ x        RasterIndex (crs=EPSG:32615)\n",
+       "  └ y
" + ], + "text/plain": [ + " Size: 36MB\n", + "dask.array\n", + "Coordinates:\n", + " * time (time) datetime64[s] 248B 2025-07-01 2025-07-02 ... 2025-07-31\n", + " * y (y) float64 4kB 5.178e+06 5.178e+06 ... 5.164e+06 5.164e+06\n", + " * x (x) float64 5kB 5.269e+05 5.269e+05 ... 5.461e+05 5.462e+05\n", + " spatial_ref int64 8B 0\n", + " band " + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "(\n", + " subset.isel(time=slice(0, 4)).plot.imshow(\n", + " row=\"time\",\n", + " vmin=-1,\n", + " vmax=1,\n", + " cmap=\"RdYlGn\",\n", + " aspect=subset.shape[2] / subset.shape[1],\n", + " )\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "07fb3b26-34ae-494e-b09b-1a59b5c1283d", + "metadata": {}, + "source": [ + "Calculate the maximum NDVI value for the month of July and plot it. This reduction is useful because it surfaces the strongest cloud-free vegetation signal observed during the month, and correct nodata handling keeps uncovered areas from being mistaken for real low values." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "6fff22f8-3c01-402d-acc9-0b8920690702", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "subset.max(dim=\"time\").plot.imshow(\n", + " vmin=-1,\n", + " vmax=1,\n", + " cmap=\"RdYlGn\",\n", + " aspect=subset.shape[2] / subset.shape[1],\n", + " size=6,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "bdf6d1ff-42cb-4dc2-997c-8da56203a88e", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.13.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/mkdocs.yml b/mkdocs.yml index 87a2d71..a76b45b 100644 --- a/mkdocs.yml +++ b/mkdocs.yml @@ -24,6 +24,7 @@ nav: - STAC item queries: guides/stac-search.md - Mosaic methods: guides/mosaic-methods.md - Temporal grouping: guides/temporal-grouping.md + - dtype and nodata handling: guides/dtype-nodata.md - Inspecting read plans: notebooks/explain.ipynb - Cloud storage: guides/cloud-storage.md - Chunking and concurrency: guides/chunking.md @@ -33,6 +34,7 @@ nav: - NASA HLS: - notebooks/hls-https.ipynb - notebooks/hls-s3.ipynb + - notebooks/hls-analysis.ipynb - CMR STAC example: notebooks/cmr-lpcloud-fix-assets.ipynb - Experimental async workflow: notebooks/async-workflow.ipynb - lazycogs vs odc-stac: notebooks/lazycogs-odc-stac.ipynb