nrt-data 0.0.1__py3-none-any.whl → 0.0.2__py3-none-any.whl

nrt/data/__init__.py

@@ -1,22 +1,26 @@
-# Copyright (C) 2024 European Union (Joint Research Centre)
-#
-# Licensed under the EUPL, Version 1.2 or - as soon they will be approved by
-# the European Commission - subsequent versions of the EUPL (the "Licence");
-# You may not use this work except in compliance with the Licence.
-# You may obtain a copy of the Licence at:
-#
-#   https://joinup.ec.europa.eu/software/page/eupl
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the Licence is distributed on an "AS IS" basis,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the Licence for the specific language governing permissions and
-# limitations under the Licence.
+# Copyright (C) 2024 European Union
+# 
+# This program is free software: you can redistribute it and/or modify it under
+# the terms of the EUROPEAN UNION PUBLIC LICENCE v. 1.2 as published by
+# the European Union.
+# 
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+# or FITNESS FOR A PARTICULAR PURPOSE.
+# See the EUROPEAN UNION PUBLIC LICENCE v. 1.2 for further details.
+# 
+# You should have received a copy of the EUROPEAN UNION PUBLIC LICENCE v. 1.2.
+# along with this program.
+# If not, see <https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12 >
+
+__path__ = __import__('pkgutil').extend_path(__path__, __name__)
 
 import os
 import json
 import warnings
+import sqlite3
 
+import pandas as pd
 import xarray as xr
 import rasterio
 import fiona
@@ -31,14 +35,15 @@ from .simulate import make_cube as _make_cube
 DATA_DIR = os.path.abspath(os.path.dirname(__file__))
 
 GOODBOY = pooch.create(
-    path=pooch.os_cache("nrt-validate"),
+    path=pooch.os_cache("nrt-data"),
     base_url="https://jeodpp.jrc.ec.europa.eu/ftp/jrc-opendata/FOREST/NRT/NRT-DATA/VER1-0/",
     registry={
-        "sentinel2_cube_subset_romania_10m.nc": None,
-        "sentinel2_cube_subset_romania_20m.nc": None,
-        "tree_cover_density_2018_romania.tif": None,
-        "germany_stratification.tif": None,
-        "germany_sample_points.fgb": None
+        "sentinel2_cube_subset_romania_10m.nc": "sha256:f88716ff11353fa46990c59c57f31b4c9a8dfd4a950a845e073e41f6beb0ac07",
+        "sentinel2_cube_subset_romania_20m.nc": "sha256:5e6858fc0e31555e8de44bac57b989bb9a3c10117f4fddead943eb45b8c1be17",
+        "tree_cover_density_2018_romania.tif": "sha256:0d6a445b112de8ba44729df26c063650198e6214bc9d9349c3b4c86ee43894bb",
+        "germany_stratification.tif": "sha256:149d0c36b9f5d933ca12c4ea976f866e74c205ab708ac3bc4dd7062c74c4968c",
+        "germany_sample_points.fgb": "sha256:068cbda19fcfbd2dd1cf9a1d18f032685c971d6d22cb7bef1415109030753ace",
+        "germany_temporal_segments.sqlite": "sha256:248fc9ffd020764b4a5a1ece40976dc5f0622c68de6e9ae3005ad192d0233a14"
     }
 )
 
@@ -53,8 +58,8 @@ def _load(f, return_meta=False, **kwargs):
         **kwargs: Keyword arguments for xarray when loading nc files
 
     Returns:
-        Dataset, array, dictionary, or tuple depending on the file
-        type and options.
+        Dataset, array, dictionary, sqlite3 connection, or tuple depending on
+        the file type and options.
     """
     file_path = GOODBOY.fetch(f)
     if f.endswith('.nc'):
@@ -73,6 +78,8 @@ def _load(f, return_meta=False, **kwargs):
                 meta = src.meta
                 return data, meta
             return data
+    elif f.endswith('.sqlite'):
+        return sqlite3.connect(file_path)
 
 
 def romania_10m(**kwargs):
@@ -124,7 +131,12 @@ def germany_zarr(**kwargs):
     also automatically converted to ``np.nan``
 
     Args:
-        **kwargs: Additional keyword arguments passed to ``xarray.open_zarr()``
+        **kwargs: Additional keyword arguments passed to ``xarray.open_zarr()``.
+            A common option useful, when working on a corporate network and
+            accessing the internet via a proxy is
+            ``storage_options={"client_kwargs": {"trust_env": True}}``. This
+            ensures that the proxy settings are automatically picked up from the
+            environment variables.
 
     Examples:
         >>> import sys
@@ -232,6 +244,63 @@ def germany_sample_points(return_meta=False):
     return _load('germany_sample_points.fgb', return_meta=return_meta)
 
 
+def germany_temporal_segments():
+    """Visually interpreted temporal segments for 300 sample locations in Germany.
+
+    This function loads temporal segmentation data, which has been visually
+    interpreted using the ``SegmentLabellingInterface`` of the ``nrt-data`` package.
+    The data corresponds to the sample locations from ``nrt.data.germany_sample_points()``
+    and can be joined with it using the ``fid`` or ``feature_id`` keys.
+
+    Each segment is labeled with one of three possible categories:
+
+        - Non-treed
+        - Stable tree cover
+        - Dieback
+
+    A common disturbance trajectory in this region, which has been heavily
+    affected by bark beetle activity, follows the pattern "Stable tree cover",
+    "Dieback", and then "Non-treed." For some sample locations, no label could be
+    confidently assigned, and these are represented with a single segment labeled `None`.
+
+    Additional information about the dataset:
+
+        - Temporal segmentation is valid for the period between 2019-01-01 and 2021-12-31.
+        - Each segment has a ``begin`` and ``end`` time represented as days since epoch.
+        - The segmentation data may contain errors for ambiguous samples, particularly
+          near edges, in mixed or sparse forests, or for shrub-like vegetation easily
+          mistaken for trees.
+        - Temporal precision may vary, especially in cases where gradual processes like
+          canopy dieback are difficult to date accurately.
+
+    Examples:
+        >>> from nrt import data
+        >>> data.germany_temporal_segments()
+              id  begin    end              label  feature_id
+        0      1  17916  18981          Non-treed           0
+        1      2  17916  18981          Non-treed           1
+        2      3  17916  18981          Non-treed           2
+        3      4  17916  18981          Non-treed           3
+        4      5  17916  18981  Stable tree cover           4
+        ..   ...    ...    ...                ...         ...
+        413  414  17916  18981          Non-treed         295
+        414  415  17916  18981  Stable tree cover         296
+        415  416  17916  18981          Non-treed         297
+        416  417  17916  18981          Non-treed         298
+        417  418  17916  18981  Stable tree cover         299
+
+        [418 rows x 5 columns]
+
+    Returns:
+        pandas.DataFrame: A data-frame containing 418 rows and 5 columns, with each
+        row representing a temporal segment for a sample location.
+    """
+    con = _load('germany_temporal_segments.sqlite')
+    df = pd.read_sql('SELECT * FROM segments;', con=con)
+    con.close()
+    return df
+
+
 def romania_forest_cover_percentage(return_meta=False):
     """Subset of Copernicus HR layer tree cover percentage - 20 m - Romania
 

nrt/data/simulate.py

@@ -1,20 +1,24 @@
-# Copyright (C) 2024 European Union (Joint Research Centre)
-#
-# Licensed under the EUPL, Version 1.2 or - as soon they will be approved by
-# the European Commission - subsequent versions of the EUPL (the "Licence");
-# You may not use this work except in compliance with the Licence.
-# You may obtain a copy of the Licence at:
-#
-#   https://joinup.ec.europa.eu/software/page/eupl
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the Licence is distributed on an "AS IS" basis,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the Licence for the specific language governing permissions and
-# limitations under the Licence.
+# Copyright (C) 2024 European Union
+# 
+# This program is free software: you can redistribute it and/or modify it under
+# the terms of the EUROPEAN UNION PUBLIC LICENCE v. 1.2 as published by
+# the European Union.
+# 
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+# or FITNESS FOR A PARTICULAR PURPOSE.
+# See the EUROPEAN UNION PUBLIC LICENCE v. 1.2 for further details.
+# 
+# You should have received a copy of the EUROPEAN UNION PUBLIC LICENCE v. 1.2.
+# along with this program.
+# If not, see <https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12 >
+
+import datetime
+from typing import Tuple, Optional
 
 import numpy as np
 import xarray as xr
+from scipy.ndimage import gaussian_filter
 
 
 def make_ts(dates, break_idx=-1, intercept=0.7, amplitude=0.15, magnitude=0.25,
@@ -268,6 +272,276 @@ def make_cube(dates, params_ds, outlier_value=0.1, name='ndvi'):
                           name=name)
     return xr_cube
 
+
+def make_landscape(
+    shape: Tuple[int, int] = (5000, 5000),
+    year: int = 2020,
+    forest_pct: float = 0.70,
+    loss_pct: float = 0.03,
+    forest_compactness: float = 60.0,
+    disturbance_clustering: float = 30.0,
+    disturbance_roughness: float = 3.0,
+    disturbance_roughness_share: float = 0.1,
+    seed: Optional[int] = None
+) -> Tuple[np.ndarray, np.ndarray]:
+    """Generates a synthetic landscape with spatio-temporally correlated forest loss.
+
+    Uses Gaussian filtering of white noise to create spatially autocorrelated
+    structures for both forest cover and disturbance patches.
+    Temporal dates are assigned using a gradient from patch center (early) to
+    edge (late).
+
+    Args:
+        shape (tuple): Dimensions of the output array (rows, cols). Defaults to (5000, 5000).
+        year (int): The year to simulate. Dates will be returned as days since
+            1970-01-01, starting from Jan 1st of this year. Defaults to 2020.
+        forest_pct (float): Target percentage of forest cover (0.0 to 1.0).
+            Defaults to 0.70.
+        loss_pct (float): Target percentage of forest loss relative to the total
+            landscape area. Defaults to 0.03.
+        forest_compactness (float): Sigma for forest smoothing. Higher values create
+            larger, smoother contiguous forest blocks. Defaults to 60.0.
+        disturbance_clustering (float): Sigma for disturbance structure. Higher values
+            create larger, fewer disturbance patches. Defaults to 30.0.
+        disturbance_roughness (float): Sigma for disturbance texture. Lower values
+            create jagged, scattered pixel edges. Defaults to 3.0.
+        disturbance_roughness_share (float): Weight (0.0 to 1.0) of roughness vs
+            clustering. Higher values add more salt-and-pepper noise.
+            Defaults to 0.1.
+        seed: Random seed for reproducibility. Defaults to None.
+
+    Examples:
+        >>> import numpy as np
+        >>> from nrt.data import simulate
+        >>> from matplotlib import pyplot as plt
+
+        >>> mask, disturbance = simulate.make_landscape(shape=(2000,2000),
+        ...                                             forest_pct=0.60,
+        ...                                             loss_pct=0.02,
+        ...                                             seed=42)
+
+        >>> # For mask plot make green forests and magenta disturbances
+        >>> # For disturbance plot use a colormap that goes from jan 2020 to dec 2020 (in days since 1970)
+        >>> fig, ax = plt.subplots(1, 2, figsize=(16, 8))
+        >>> # 1. Land Cover Map
+        >>> cmap_lc = plt.cm.colors.ListedColormap(['#eecfa1', '#228b22', '#ff00ff'])
+        >>> ax[0].imshow(mask, cmap=cmap_lc, interpolation='none')
+        >>> ax[0].set_title("Mask")
+        >>> ax[0].axis('off')
+        >>> # 2. Date of Disturbance Map
+        >>> masked_disturbance = np.ma.masked_where(disturbance == 0, disturbance)
+        >>> im = ax[1].imshow(masked_disturbance, cmap='jet_r', interpolation='none')
+        >>> ax[1].set_title("Disturbance date (Temporally Correlated)")
+        >>> ax[1].axis('off')
+        >>> plt.colorbar(im, ax=ax[1], label="Day since 1970", fraction=0.046, pad=0.04)
+        >>> plt.tight_layout()
+        >>> plt.show()
+
+    Returns:
+        A tuple (land_cover, loss_dates) where:
+
+        * **land_cover** (np.ndarray): int8 array where 0=Non-Forest,
+          1=Forest, 2=Loss.
+        * **loss_dates** (np.ndarray): int32 array representing the date of
+          loss as days since 1970-01-01. Pixels with no loss are 0.
+    """
+    if seed is not None:
+        np.random.seed(seed)
+    # 1. Generate Forest Cover
+    # High sigma creates large contiguous 'continents'
+    noise_forest = np.random.rand(*shape)
+    smooth_forest = gaussian_filter(noise_forest, sigma=forest_compactness)
+    forest_threshold = np.percentile(smooth_forest, (1 - forest_pct) * 100)
+    is_forest = smooth_forest >= forest_threshold
+
+    # 2. Generate Disturbance Potential
+    # Mix large blobs (structure) with fine grain noise (roughness/texture)
+    noise_struct = gaussian_filter(np.random.rand(*shape), sigma=disturbance_clustering)
+    noise_text = gaussian_filter(np.random.rand(*shape), sigma=disturbance_roughness)
+
+    # Weighted composition
+    w_struct = 1.0 - disturbance_roughness_share
+    loss_potential = (w_struct * noise_struct) + (disturbance_roughness_share * noise_text)
+
+    # 3. Apply Loss Threshold (Strictly inside Forest)
+    valid_potential = loss_potential[is_forest]
+    # Calculate how many pixels we need relative to the forest area
+    target_px = shape[0] * shape[1] * loss_pct
+
+    # Safety check for 0 loss
+    if target_px > 0 and len(valid_potential) > 0:
+        relative_pct = target_px / len(valid_potential)
+        loss_cutoff = np.percentile(valid_potential, (1 - relative_pct) * 100)
+        is_loss = (loss_potential >= loss_cutoff) & is_forest
+    else:
+        is_loss = np.zeros(shape, dtype=bool)
+
+    # 4. Temporal Attribution (Gradient Method)
+    # Use int32 for absolute dates (days since 1970 can exceed int16 limit)
+    loss_dates = np.zeros(shape, dtype=np.int32)
+
+    if np.any(is_loss):
+        # Calculate start offset (Days from 1970-01-01 to Year-01-01)
+        start_date = datetime.date(year, 1, 1)
+        epoch = datetime.date(1970, 1, 1)
+        start_offset = (start_date - epoch).days
+
+        loss_values = loss_potential[is_loss]
+        v_min, v_max = loss_values.min(), loss_values.max()
+
+        # Normalize 0..1
+        norm_values = (loss_values - v_min) / (v_max - v_min)
+
+        # Invert: Center (High Pot) -> Day 1, Edge (Low Pot) -> Day 365
+        # We assume loss spans the full year (1-365)
+        doy_values = 1 + ((1 - norm_values) * 364).astype(np.int32)
+
+        # Add jitter
+        jitter = np.random.randint(-3, 4, size=doy_values.shape)
+        doy_values = np.clip(doy_values + jitter, 1, 365)
+
+        # Convert to Days since 1970
+        # date = start_offset + doy - 1
+        loss_dates[is_loss] = start_offset + doy_values - 1
+
+    # 5. Assemble Land Cover
+    land_cover = np.zeros(shape, dtype=np.int8)
+    land_cover[is_forest] = 1
+    land_cover[is_loss] = 2  # Overwrite forest with loss
+
+    return land_cover, loss_dates
+
+
+def make_prediction(
+    ref_lc: np.ndarray,
+    ref_dates: np.ndarray,
+    omission_rate: float = 0.10,
+    commission_rate: float = 0.01,
+    lag_mean: float = 15.0,
+    lag_std: float = 10.0,
+    seed: Optional[int] = None
+) -> Tuple[np.ndarray, np.ndarray]:
+    """Simulates a monitoring algorithm's output by degrading reference data.
+
+    Adds omission errors, spatially correlated commission errors, and temporal
+    detection lag. Detection lag is modeled using a Gamma distribution to
+    simulate the 'long tail' of delayed detections often seen in satellite
+    alerts.
+    This function is ideally used in combination with ``inrt.data.simulate.make_landscape``.
+
+    Args:
+        ref_lc (np.ndarray): Reference land cover array (0=Non, 1=Forest, 2=Loss).
+        ref_dates (np.ndarray): Reference dates of loss (days since 1970).
+        omission_rate (float): Probability (0.0 to 1.0) of missing a true loss pixel.
+            Defaults to 0.10.
+        commission_rate (float): Probability (0.0 to 1.0) of falsely flagging a
+            stable pixel as loss. Applied to the Total Stable Area.
+            Defaults to 0.01.
+        lag_mean (float): Mean delay in days between event and detection.
+            Defaults to 15.0.
+        lag_std (float): Standard deviation of the delay in days. Defaults to 10.0.
+        seed (int): Random seed for reproducibility. Defaults to None.
+
+    Examples:
+        >>> import numpy as np
+        >>> import matplotlib.pyplot as plt
+        >>> from nrt.data import simulate
+
+        >>> # 1. Generate Reference and Prediction
+        >>> mask, dates = make_landscape(shape=(1000, 1000), seed=42)
+        >>> pred_mask, pred_dates = make_prediction(mask, dates, seed=42)
+
+        >>> # 2. Compute Accuracy
+        >>> # Find ALL spatial matches (Intersection of Reference and Prediction)
+        >>> spatial_match = (mask == 2) & (pred_mask == 1)
+        >>>
+        >>> # Calculate lags for all matches
+        >>> all_lags = pred_dates[spatial_match].astype(float) - dates[spatial_match].astype(float)
+        >>>
+        >>> # Apply Temporal Rules: Valid if lag is within [-5, +30] days
+        >>> valid_window = (all_lags >= -5) & (all_lags <= 30)
+        >>> tp_count = np.count_nonzero(valid_window)
+        >>>
+        >>> ua = tp_count / np.count_nonzero(pred_mask == 1)
+        >>> pa = tp_count / np.count_nonzero(mask == 2)
+        >>> print(f"UA: {ua:.1%}, PA: {pa:.1%}")
+        UA: 74.0%, PA: 83.4%
+
+        >>> # 3. Visualize Lag Distribution (All Matches)
+        >>> plt.figure(figsize=(7, 4))
+        >>> # Plot all matches in grey (background)
+        >>> plt.hist(all_lags, bins=range(-20, 60), color='lightgrey', label='Rejected Matches')
+        >>> # Overlay True Positives in teal
+        >>> plt.hist(all_lags[valid_window], bins=range(-20, 60), color='teal', label='True Positives')
+        >>>
+        >>> # Add Tolerance Lines
+        >>> plt.axvline(x=-5, color='red', linestyle='--', linewidth=1, label='Tolerance (-5, +30)')
+        >>> plt.axvline(x=30, color='red', linestyle='--', linewidth=1)
+        >>>
+        >>> plt.xlabel('Detection Lag (days)')
+        >>> plt.ylabel('Pixel Count')
+        >>> plt.title(f'Temporal Accuracy Analysis (N={len(all_lags)})')
+        >>> plt.legend()
+        >>> plt.show()
+
+    Returns:
+        A tuple (pred_lc, pred_dates) where:
+
+        * **pred_lc** (np.ndarray): int8 array where 0=Stable, 1=Loss.
+        * **pred_dates** (np.ndarray): int32 array representing detection
+          dates as days since 1970-01-01.
+    """
+    if seed is not None:
+        np.random.seed(seed)
+    shape = ref_lc.shape
+    # --- 1. Handle True Positives (TP) ---
+    # TP must be Class 2 (Loss) AND have a valid date (>0)
+    true_loss_mask = (ref_lc == 2) & (ref_dates > 0)
+    omission_mask = np.random.random(shape) < omission_rate
+    detected_tp_mask = true_loss_mask & (~omission_mask)
+
+    # --- 2. Handle False Positives (FP) ---
+    # RESTRICTION: Commission errors only allowed in STABLE FOREST (Class 1)
+    # Class 0 (Non-Forest) is excluded.
+    stable_forest_mask = (ref_lc == 1)
+    noise_fp = gaussian_filter(np.random.rand(*shape), sigma=10)
+    valid_fp_noise = noise_fp[stable_forest_mask]
+
+    if len(valid_fp_noise) > 0:
+        # Rate applies to the Stable Forest area
+        fp_cutoff = np.percentile(valid_fp_noise, (1 - commission_rate) * 100)
+        detected_fp_mask = (noise_fp >= fp_cutoff) & stable_forest_mask
+    else:
+        detected_fp_mask = np.zeros(shape, dtype=bool)
+
+    # --- 3. Assemble Output ---
+    pred_lc = np.zeros(shape, dtype=np.int8)
+    pred_lc[detected_tp_mask | detected_fp_mask] = 1
+    pred_dates = np.zeros(shape, dtype=np.int32)
+
+    # A. Dates for TPs (Reference + Lag)
+    if np.any(detected_tp_mask):
+        real_dates = ref_dates[detected_tp_mask]
+        theta = (lag_std ** 2) / lag_mean
+        k = lag_mean / theta
+        lags = np.random.gamma(k, theta, size=np.count_nonzero(detected_tp_mask))
+        lags = np.round(lags).astype(np.int32)
+        pred_dates[detected_tp_mask] = real_dates + lags
+
+    # B. Dates for FPs (Random within context)
+    if np.any(detected_fp_mask):
+        # Infer context year from reference data
+        if np.any(ref_dates > 0):
+            min_d, max_d = ref_dates[ref_dates > 0].min(), ref_dates[ref_dates > 0].max()
+        else:
+            min_d, max_d = 18262, 18627 # 2020 fallback
+
+        fp_dates = np.random.randint(min_d, max_d + 1, size=np.count_nonzero(detected_fp_mask))
+        pred_dates[detected_fp_mask] = fp_dates
+
+    return pred_lc, pred_dates
+
+
 if __name__ == "__main__":
     import doctest
     doctest.testmod()

nrt_data-0.0.2.dist-info/METADATA

@@ -0,0 +1,72 @@
+Metadata-Version: 2.4
+Name: nrt-data
+Version: 0.0.2
+Summary: nrt namespace package giving access to demo and test datasets, extracted from nrt core
+Author: Jonas Viehweger, Kenji Ose
+Author-email: Loic Dutrieux <loic.dutrieux@ec.europa.eu>
+Maintainer-email: Loic Dutrieux <loic.dutrieux@ec.europa.eu>
+License: EUPL-1.2
+Project-URL: homepage, https://code.europa.eu/jrc-forest/nrt-data
+Keywords: sentinel2,xarray,zarr,netcdf
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: License :: OSI Approved :: European Union Public Licence 1.2 (EUPL 1.2)
+Requires-Python: >=3.9
+Description-Content-Type: text/x-rst
+License-File: LICENSE
+License-File: NOTICE
+Requires-Dist: numpy
+Requires-Dist: scipy
+Requires-Dist: xarray
+Requires-Dist: rasterio
+Requires-Dist: fiona
+Requires-Dist: netCDF4
+Requires-Dist: zarr
+Requires-Dist: aiohttp
+Requires-Dist: fsspec
+Requires-Dist: pooch
+Provides-Extra: docs
+Requires-Dist: sphinx; extra == "docs"
+Requires-Dist: sphinx_rtd_theme; extra == "docs"
+Dynamic: license-file
+
+********
+nrt-data
+********
+
+**nrt-data** is a companion package to `nrt <https://github.com/ec-jrc/nrt>`_, designed for near real-time monitoring of satellite image time series. It provides easy access to curated datasets for testing and demonstrating **nrt**'s capabilities.
+
+As of ``nrt==0.2.1``, the ``data`` module has been separated from the core package to simplify maintenance and keep the core **nrt** lightweight. This package is distributed as a namespace package, ensuring backward compatibility with previous versions.
+
+For more details, see the full documentation at `nrt-data.readthedocs.io <https://nrt-data.readthedocs.io/>`_.
+
+Features
+========
+
+- Access to small-sized test data in NetCDF format and associated reference data in FlatGeoBuf, managed via `Pooch <https://www.fatiando.org/pooch/latest/>`_.
+- Streaming access to larger datasets stored as cloud-optimized Zarr stores.
+- Synthetic data simulation functionalities.
+
+Installation
+============
+
+To install **nrt-data**, run:
+
+.. code-block:: bash
+
+    pip install nrt-data
+
+Please note that **nrt-data** can be installed independently of **nrt** but is incompatible with ``nrt<=0.2.1``. To check your current **nrt** version, run:
+
+.. code-block:: bash
+
+    pip freeze | grep nrt
+
+If necessary, update **nrt** by running:
+
+.. code-block:: bash
+
+    pip install -U nrt
+

nrt_data-0.0.2.dist-info/RECORD

@@ -0,0 +1,9 @@
+nrt/data/__init__.py,sha256=CujJekZtW4J7foIy-L3SBdBHB9is-Latm7OzKsUT5mA,16022
+nrt/data/mreCritValTable.json,sha256=PVtAXUsZCPlPho2WQzFfvnj6BCBj8Jx64dIpLgShvl4,26151
+nrt/data/simulate.py,sha256=4w9KwKiBUQEDFM-b4_Xlcp2lnOwuRjlrgeb0yBDRDXQ,26422
+nrt_data-0.0.2.dist-info/licenses/LICENSE,sha256=b8nnCcy_4Nd_v_okJ6mDKCvi64jkexzbSfIag7TR5mU,13827
+nrt_data-0.0.2.dist-info/licenses/NOTICE,sha256=ct946s5jPzw3oyKEye9-wRyDoWjeuHpoPFzlVr5Qn8I,23032
+nrt_data-0.0.2.dist-info/METADATA,sha256=QkbMPK90AmR1RNTuii0egdUMU39GrC1p_skiK8s9J2g,2507
+nrt_data-0.0.2.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+nrt_data-0.0.2.dist-info/top_level.txt,sha256=MZT1YZNVoDJG3HQqwAmY5i310aWiOxB7GaPANWE8bfM,4
+nrt_data-0.0.2.dist-info/RECORD,,

{nrt_data-0.0.1.dist-info → nrt_data-0.0.2.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (74.0.0)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any