forkairos 0.1.0__tar.gz

forkairos-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Cristóbal Sardá
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

forkairos-0.1.0/PKG-INFO

@@ -0,0 +1,60 @@
+Metadata-Version: 2.4
+Name: forkairos
+Version: 0.1.0
+Summary: Operational pipeline for meteorological forcing data in CF-compliant NetCDF
+Author-email: Cristóbal Reyes <cristobal.sarda@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2026 Cristóbal Sardá
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Project-URL: Homepage, https://github.com/Jano01/forkairos
+Project-URL: Documentation, https://forkairos.readthedocs.io
+Project-URL: Repository, https://github.com/Jano01/forkairos
+Project-URL: Issues, https://github.com/Jano01/forkairos/issues
+Keywords: hydrology,meteorology,NWP,forcing,NetCDF,ERA5,GFS,ECMWF
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Atmospheric Science
+Classifier: Topic :: Scientific/Engineering :: Hydrology
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: xarray>=2024.1.0
+Requires-Dist: geopandas>=0.14.0
+Requires-Dist: netcdf4>=1.6.0
+Requires-Dist: requests>=2.31.0
+Requires-Dist: tqdm>=4.66.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: openmeteo-requests>=1.1.0
+Requires-Dist: requests-cache>=1.1.0
+Requires-Dist: retry-requests>=2.0.0
+Requires-Dist: cdsapi>=0.6.0
+Requires-Dist: cfgrib>=0.9.10
+Requires-Dist: scipy>=1.12.0
+Requires-Dist: numpy>=1.26.0
+Requires-Dist: pandas>=2.2.0
+Requires-Dist: ecmwf-opendata>=0.3.0
+Dynamic: license-file
+
+# snowops
+Operational data pipeline for snow hydrology — NWP forcings and satellite observations in CF-compliant NetCDF

forkairos-0.1.0/README.md

@@ -0,0 +1,2 @@
+# snowops
+Operational data pipeline for snow hydrology — NWP forcings and satellite observations in CF-compliant NetCDF

forkairos-0.1.0/forkairos/__init__.py

@@ -0,0 +1,6 @@
+# forkairos/__init__.py
+from forkairos.domain import Domain
+from forkairos.pipeline import run, get_provider
+
+__version__ = "0.1.0"
+__all__ = ["Domain", "run", "get_provider"]

forkairos-0.1.0/forkairos/domain.py

@@ -0,0 +1,45 @@
+# forkairos/domain.py
+from pathlib import Path
+import geopandas as gpd
+
+class Domain:
+    """
+    Represents a watershed domain derived from a shapefile.
+    Computes a bounding box with an optional buffer for data download.
+    """
+
+    def __init__(self, shapefile: str | Path, buffer_km: float = 10.0):
+        """
+        Parameters
+        ----------
+        shapefile : path to the basin shapefile (any CRS)
+        buffer_km : buffer around the basin in kilometers
+        """
+        self.shapefile = Path(shapefile)
+        self.buffer_km = buffer_km
+
+        # Read and reproject to WGS84
+        gdf = gpd.read_file(self.shapefile).to_crs("EPSG:4326")
+        self.geometry = gdf.union_all()
+
+        # Compute bbox with buffer
+        gdf_proj = gdf.to_crs(gdf.estimate_utm_crs())
+        gdf_buffered = gdf_proj.buffer(buffer_km * 1000)
+        bbox_buffered = gdf_buffered.to_crs("EPSG:4326").total_bounds
+
+        self.west  = round(float(bbox_buffered[0]), 4)
+        self.south = round(float(bbox_buffered[1]), 4)
+        self.east  = round(float(bbox_buffered[2]), 4)
+        self.north = round(float(bbox_buffered[3]), 4)
+
+    @property
+    def bbox(self) -> tuple[float, float, float, float]:
+        """Returns (west, south, east, north) in WGS84."""
+        return (self.west, self.south, self.east, self.north)
+
+    def __repr__(self) -> str:
+        return (
+            f"Domain(shapefile={self.shapefile.name!r}, "
+            f"buffer_km={self.buffer_km}, "
+            f"bbox=({self.west}, {self.south}, {self.east}, {self.north}))"
+        )

forkairos-0.1.0/forkairos/pipeline.py

@@ -0,0 +1,70 @@
+# forkairos/pipeline.py
+import xarray as xr
+from pathlib import Path
+from forkairos.domain import Domain
+from forkairos.providers.base import BaseProvider
+from forkairos.providers.open_meteo import OpenMeteoProvider
+from forkairos.providers.era5 import ERA5Provider
+from forkairos.providers.gfs import GFSProvider
+from forkairos.providers.ecmwf_open import ECMWFOpenProvider
+
+PROVIDERS = {
+    "open_meteo": OpenMeteoProvider,
+    "era5":       ERA5Provider,
+    "gfs":        GFSProvider,
+    "ecmwf_open": ECMWFOpenProvider,
+}
+
+def get_provider(name: str) -> BaseProvider:
+    """
+    Returns an instance of the requested provider.
+
+    Parameters
+    ----------
+    name : provider name. Available: "open_meteo"
+    """
+    if name not in PROVIDERS:
+        raise ValueError(f"Unknown provider '{name}'. Available: {list(PROVIDERS)}")
+    return PROVIDERS[name]()
+
+
+def run(
+    shapefile: str | Path,
+    provider_name: str,
+    variables: list[str],
+    start: str,
+    end: str,
+    freq: str = "1h",
+    buffer_km: float = 10.0,
+    output_path: str | Path = "output.nc",
+) -> xr.Dataset:
+    """
+    Full pipeline: shapefile → download → NetCDF.
+
+    Parameters
+    ----------
+    shapefile     : path to basin shapefile
+    provider_name : e.g. "open_meteo"
+    variables     : list of variable names
+    start         : start date "YYYY-MM-DD"
+    end           : end date "YYYY-MM-DD"
+    freq          : temporal resolution e.g. "1h", "6h", "1d"
+    buffer_km     : buffer around basin in km
+    output_path   : path for the output NetCDF file
+    """
+    print(f"[forkairos] Loading domain from {shapefile}")
+    domain = Domain(shapefile, buffer_km=buffer_km)
+    print(f"[forkairos] {domain}")
+
+    print(f"[forkairos] Provider: {provider_name}")
+    provider = get_provider(provider_name)
+
+    print(f"[forkairos] Downloading {variables} | {start} → {end} | {freq}")
+    ds = provider.download(domain, variables, start, end, freq)
+
+    output_path = Path(output_path)
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    ds.to_netcdf(output_path)
+    print(f"[forkairos] Saved → {output_path}")
+
+    return ds

forkairos-0.1.0/forkairos/processing.py

@@ -0,0 +1,175 @@
+# forkairos/processing.py
+import numpy as np
+import xarray as xr
+from scipy.interpolate import RegularGridInterpolator
+
+
+# Resoluciones sugeridas según DEM
+DEM_RESOLUTION_GUIDE = {
+    "SRTM 90m":    0.001,
+    "SRTM 30m":    0.0003,
+    "ALOS 12.5m":  0.0001,
+    "TanDEM 12m":  0.0001,
+    "COP-DEM 30m": 0.0003,
+}
+
+
+def resolution_guide() -> None:
+    """Print suggested regridding resolutions based on common DEMs."""
+    print("Suggested regridding resolutions by DEM:")
+    for dem, res in DEM_RESOLUTION_GUIDE.items():
+        print(f"  {dem:20s} → {res}° (~{res * 111:.0f} km)")
+    print()
+    print("Note: bilinear interpolation does not account for topographic")
+    print("effects on temperature or precipitation. Use with caution")
+    print("at resolutions finer than 0.01° (~1 km).")
+
+
+def bias_correct(
+    ds: xr.Dataset,
+    reference: xr.Dataset,
+    method: str = "qdm",
+    variables: list[str] | None = None,
+) -> xr.Dataset:
+    """
+    Apply bias correction to a Dataset using a reference Dataset.
+
+    Parameters
+    ----------
+    ds        : Dataset to correct (e.g. from a NWP provider)
+    reference : Observational reference Dataset (e.g. CR2MET, ERA5-Land)
+    method    : Correction method — currently supported: "qdm"
+    variables : Variables to correct. If None, corrects all common variables.
+
+    Returns
+    -------
+    Bias-corrected Dataset with same structure as input.
+    """
+    if method == "qdm":
+        return _qdm(ds, reference, variables)
+    else:
+        raise ValueError(f"Unknown method '{method}'. Available: ['qdm']")
+
+
+def _qdm(
+    ds: xr.Dataset,
+    ref: xr.Dataset,
+    variables: list[str] | None,
+) -> xr.Dataset:
+    """
+    Quantile Delta Mapping (Cannon et al. 2015).
+
+    Preserves the model's relative changes while correcting systematic bias.
+    Applied independently per variable and per grid cell.
+    """
+    if variables is None:
+        variables = [v for v in ds.data_vars if v in ref.data_vars]
+
+    if not variables:
+        raise ValueError("No common variables found between ds and reference.")
+
+    ds_out = ds.copy(deep=True)
+    n_quantiles = 100
+    quantiles = np.linspace(0, 1, n_quantiles)
+
+    for var in variables:
+        if var not in ref.data_vars:
+            print(f"[forkairos] Warning: '{var}' not in reference — skipping.")
+            continue
+
+        print(f"[forkairos] Bias correcting '{var}' with QDM...")
+
+        mod = ds[var]
+        obs = ref[var]
+
+        # Interpolate reference to model grid if needed
+        if not (obs.lat.values == mod.lat.values).all() or \
+           not (obs.lon.values == mod.lon.values).all():
+            obs = obs.interp(lat=mod.lat, lon=mod.lon, method="linear")
+
+        # Apply QDM per grid cell
+        corrected = mod.copy(deep=True)
+
+        for i in range(len(mod.lat)):
+            for j in range(len(mod.lon)):
+                mod_cell = mod.isel(lat=i, lon=j).values
+                obs_cell = obs.isel(lat=i, lon=j).values
+
+                # Remove NaNs for quantile computation
+                mod_clean = mod_cell[~np.isnan(mod_cell)]
+                obs_clean = obs_cell[~np.isnan(obs_cell)]
+
+                if len(mod_clean) == 0 or len(obs_clean) == 0:
+                    continue
+
+                # Compute quantile mapping
+                mod_quantiles = np.quantile(mod_clean, quantiles)
+                obs_quantiles = np.quantile(obs_clean, quantiles)
+
+                # For each model value, find its quantile and apply delta
+                for t in range(len(mod_cell)):
+                    if np.isnan(mod_cell[t]):
+                        continue
+                    # Find quantile of current value in model distribution
+                    q = np.interp(mod_cell[t], mod_quantiles, quantiles)
+                    # Get observed value at same quantile
+                    obs_val = np.interp(q, quantiles, obs_quantiles)
+                    # Apply delta (QDM preserves relative change)
+                    delta = mod_cell[t] - np.interp(q, quantiles, mod_quantiles)
+                    corrected.values[i, j, t] = obs_val + delta
+
+        ds_out[var] = corrected
+
+    ds_out.attrs["bias_correction"] = f"QDM — reference: user-provided"
+    return ds_out
+
+
+def regrid(
+    ds: xr.Dataset,
+    resolution: float,
+    method: str = "bilinear",
+    variables: list[str] | None = None,
+) -> xr.Dataset:
+    """
+    Regrid a Dataset to a finer resolution using interpolation.
+
+    Parameters
+    ----------
+    ds         : Input Dataset with lat/lon dimensions
+    resolution : Target resolution in degrees
+    method     : Interpolation method — currently supported: "bilinear"
+    variables  : Variables to regrid. If None, regrids all.
+
+    Returns
+    -------
+    Regridded Dataset at target resolution.
+
+    Notes
+    -----
+    Bilinear interpolation does not account for topographic effects.
+    For guidance on appropriate resolutions, call forkairos.processing.resolution_guide().
+    """
+    if method != "bilinear":
+        raise ValueError(f"Unknown method '{method}'. Available: ['bilinear']")
+
+    if variables is None:
+        variables = list(ds.data_vars)
+
+    # Build target grid
+    west  = float(ds.lon.min())
+    east  = float(ds.lon.max())
+    south = float(ds.lat.min())
+    north = float(ds.lat.max())
+
+    new_lats = np.arange(south, north + resolution, resolution).round(6)
+    new_lons = np.arange(west,  east  + resolution, resolution).round(6)
+
+    ds_out = ds.interp(
+        lat=new_lats,
+        lon=new_lons,
+        method="linear",
+        kwargs={"fill_value": "extrapolate"},
+    )
+
+    ds_out.attrs["regridding"] = f"bilinear interpolation → {resolution}°"
+    return ds_out

forkairos-0.1.0/forkairos/providers/base.py

@@ -0,0 +1,68 @@
+# forkairos/providers/base.py
+from abc import ABC, abstractmethod
+from typing import Any
+import xarray as xr
+from forkairos.domain import Domain
+
+
+class BaseProvider(ABC):
+    """
+    Abstract base class for all NWP providers.
+    Every provider must implement these four methods.
+    """
+
+    name: str          # e.g. "era5", "gfs"
+    mode: str          # "forecast", "reanalysis", or "both"
+
+    @abstractmethod
+    def available_variables(self) -> dict[str, str]:
+        """
+        Returns a dictionary of available variables.
+
+        Returns
+        -------
+        dict where key = variable name, value = description
+        e.g. {"temperature_2m": "Air temperature at 2m (°C)"}
+        """
+
+    @abstractmethod
+    def available_date_range(self) -> tuple[str, str]:
+        """
+        Returns the available date range for this provider.
+
+        Returns
+        -------
+        tuple (start_date, end_date) as strings "YYYY-MM-DD"
+        end_date can be "present" for operational providers
+        """
+
+    @abstractmethod
+    def available_frequencies(self) -> list[str]:
+        """
+        Returns the temporal resolutions available.
+
+        Returns
+        -------
+        list e.g. ["1h", "3h", "6h", "1d"]
+        """
+
+    @abstractmethod
+    def download(
+        self,
+        domain: Domain,
+        variables: list[str],
+        start: str,
+        end: str,
+        freq: str,
+    ) -> xr.Dataset:
+        """
+        Download data and return a CF-compliant xarray Dataset.
+
+        Parameters
+        ----------
+        domain    : Domain object with bbox
+        variables : list of variable names from available_variables()
+        start     : start date "YYYY-MM-DD"
+        end       : end date "YYYY-MM-DD"
+        freq      : temporal resolution from available_frequencies()
+        """

forkairos-0.1.0/forkairos/providers/ecmwf_open.py

@@ -0,0 +1,126 @@
+# forkairos/providers/ecmwf_open.py
+import openmeteo_requests
+import requests_cache
+import pandas as pd
+import xarray as xr
+import numpy as np
+from retry_requests import retry
+from forkairos.providers.base import BaseProvider
+from forkairos.domain import Domain
+
+
+class ECMWFOpenProvider(BaseProvider):
+
+    name = "ecmwf_open"
+    mode = "forecast"
+
+    VARIABLES = {
+        "temperature_2m":      "Air temperature at 2m (°C)",
+        "precipitation":       "Total precipitation (mm)",
+        "snowfall":            "Snowfall (cm)",
+        "surface_pressure":    "Surface pressure (hPa)",
+        "wind_speed_10m_u":    "U-component of wind at 10m (km/h)",
+        "wind_speed_10m_v":    "V-component of wind at 10m (km/h)",
+        "shortwave_radiation": "Surface solar radiation downwards (W/m²)",
+        "snow_depth":          "Snow depth (m)",
+        "relative_humidity_2m": "Relative humidity at 2m (%)",
+    }
+
+    OPENMETEO_NAMES = {
+        "temperature_2m":       "temperature_2m",
+        "precipitation":        "precipitation",
+        "snowfall":             "snowfall",
+        "surface_pressure":     "surface_pressure",
+        "wind_speed_10m_u":     "wind_u_component_10m",
+        "wind_speed_10m_v":     "wind_v_component_10m",
+        "shortwave_radiation":  "shortwave_radiation",
+        "snow_depth":           "snow_depth",
+        "relative_humidity_2m": "relative_humidity_2m",
+    }
+
+    FREQUENCIES = ["1h", "3h", "6h"]
+    FORECAST_URL = "https://api.open-meteo.com/v1/ecmwf"
+
+    def available_variables(self) -> dict[str, str]:
+        return self.VARIABLES
+
+    def available_date_range(self) -> tuple[str, str]:
+        start = pd.Timestamp.today().strftime("%Y-%m-%d")
+        return (start, "present+10days")
+
+    def available_frequencies(self) -> list[str]:
+        return self.FREQUENCIES
+
+    def download(
+        self,
+        domain: Domain,
+        variables: list[str],
+        start: str,
+        end: str,
+        freq: str = "1h",
+    ) -> xr.Dataset:
+
+        for v in variables:
+            if v not in self.VARIABLES:
+                raise ValueError(f"Variable '{v}' not available. Choose from: {list(self.VARIABLES)}")
+        if freq not in self.FREQUENCIES:
+            raise ValueError(f"Frequency '{freq}' not available. Choose from: {self.FREQUENCIES}")
+
+        om_vars = [self.OPENMETEO_NAMES[v] for v in variables]
+
+        west, south, east, north = domain.bbox
+        lats = np.arange(south, north + 0.25, 0.25).round(4)
+        lons = np.arange(west,  east  + 0.25, 0.25).round(4)
+
+        cache_session = requests_cache.CachedSession(".cache_ecmwf_om", expire_after=3600)
+        retry_session = retry(cache_session, retries=5, backoff_factor=0.2)
+        client = openmeteo_requests.Client(session=retry_session)
+
+        rows = []
+        for lat in lats:
+            cols = []
+            for lon in lons:
+                params = {
+                    "latitude":   lat,
+                    "longitude":  lon,
+                    "hourly":     om_vars,
+                    "start_date": start,
+                    "end_date":   end,
+                    "timezone":   "UTC",
+                }
+                responses = client.weather_api(self.FORECAST_URL, params=params)
+                r = responses[0]
+                hourly = r.Hourly()
+
+                times = pd.date_range(
+                    start=pd.to_datetime(hourly.Time(), unit="s", utc=True),
+                    end=pd.to_datetime(hourly.TimeEnd(), unit="s", utc=True),
+                    freq=pd.Timedelta(seconds=hourly.Interval()),
+                    inclusive="left",
+                ).tz_localize(None)
+
+                data_vars = {}
+                for i, v in enumerate(variables):
+                    data_vars[v] = (["time"], hourly.Variables(i).ValuesAsNumpy())
+
+                ds_point = xr.Dataset(
+                    data_vars,
+                    coords={"time": times},
+                ).expand_dims(lat=[lat], lon=[lon])
+
+                cols.append(ds_point)
+            rows.append(xr.concat(cols, dim="lon"))
+
+        ds = xr.concat(rows, dim="lat")
+
+        ds["lat"].attrs  = {"units": "degrees_north", "standard_name": "latitude"}
+        ds["lon"].attrs  = {"units": "degrees_east",  "standard_name": "longitude"}
+        ds["time"].attrs = {"standard_name": "time"}
+        ds.attrs = {
+            "source":      "ECMWF IFS forecast via Open-Meteo API",
+            "provider":    self.name,
+            "domain":      repr(domain),
+            "Conventions": "CF-1.8",
+        }
+
+        return ds

forkairos-0.1.0/forkairos/providers/era5.py

@@ -0,0 +1,183 @@
+# forkairos/providers/era5.py
+import cdsapi
+import xarray as xr
+import numpy as np
+from pathlib import Path
+from forkairos.providers.base import BaseProvider
+from forkairos.domain import Domain
+
+
+class ERA5Provider(BaseProvider):
+
+    name = "era5"
+    mode = "reanalysis"
+
+    VARIABLES = {
+        "temperature_2m":        "Air temperature at 2m (°C)",
+        "precipitation":         "Total precipitation (m)",
+        "snowfall":              "Snowfall (m of water equivalent)",
+        "snow_depth":            "Snow depth (m of water equivalent)",
+        "surface_pressure":      "Surface pressure (Pa)",
+        "wind_speed_10m_u":      "U-component of wind at 10m (m/s)",
+        "wind_speed_10m_v":      "V-component of wind at 10m (m/s)",
+        "relative_humidity":     "Relative humidity (%)",
+        "shortwave_radiation":   "Surface solar radiation downwards (J/m²)",
+        "longwave_radiation":    "Surface thermal radiation downwards (J/m²)",
+        "snow_cover":            "Fraction of snow cover (0-1)",
+    }
+
+    # Mapping forkairos variable names → CDS parameter names
+    CDS_NAMES = {
+        "temperature_2m":      "2m_temperature",
+        "precipitation":       "total_precipitation",
+        "snowfall":            "snowfall",
+        "snow_depth":          "snow_depth",
+        "surface_pressure":    "surface_pressure",
+        "wind_speed_10m_u":    "10m_u_component_of_wind",
+        "wind_speed_10m_v":    "10m_v_component_of_wind",
+        "relative_humidity":   "relative_humidity",
+        "shortwave_radiation": "surface_solar_radiation_downwards",
+        "longwave_radiation":  "surface_thermal_radiation_downwards",
+        "snow_cover":          "fraction_of_snow_cover",
+    }
+
+    # Mapping CDS short names (what ERA5 actually returns) → forkairos names
+    CDS_SHORT_NAMES = {
+        "t2m":   "temperature_2m",
+        "tp":    "precipitation",
+        "sf":    "snowfall",
+        "sd":    "snow_depth",
+        "sp":    "surface_pressure",
+        "u10":   "wind_speed_10m_u",
+        "v10":   "wind_speed_10m_v",
+        "r":     "relative_humidity",
+        "ssrd":  "shortwave_radiation",
+        "strd":  "longwave_radiation",
+        "fscov": "snow_cover",
+    }
+
+    FREQUENCIES = ["1h"]
+
+    def available_variables(self) -> dict[str, str]:
+        return self.VARIABLES
+
+    def available_date_range(self) -> tuple[str, str]:
+        import pandas as pd
+        end = (pd.Timestamp.today() - pd.DateOffset(months=3)).strftime("%Y-%m-%d")
+        return ("1940-01-01", end)
+    
+    def available_frequencies(self) -> list[str]:
+        return self.FREQUENCIES
+
+    def download(
+        self,
+        domain: Domain,
+        variables: list[str],
+        start: str,
+        end: str,
+        freq: str = "1h",
+        cache_dir: str | Path = ".cache_era5",
+    ) -> xr.Dataset:
+
+        # Validate inputs
+        for v in variables:
+            if v not in self.VARIABLES:
+                raise ValueError(f"Variable '{v}' not available. Choose from: {list(self.VARIABLES)}")
+
+        # Translate to CDS names
+        cds_vars = [self.CDS_NAMES[v] for v in variables]
+
+        # Build date range
+        import pandas as pd
+        dates = pd.date_range(start, end, freq="D")
+        years  = list(dict.fromkeys(str(d.year) for d in dates))
+        months = list(dict.fromkeys(f"{d.month:02d}" for d in dates))
+        days   = list(dict.fromkeys(f"{d.day:02d}" for d in dates))
+
+        # Bbox: CDS expects [north, west, south, east]
+        west, south, east, north = domain.bbox
+        area = [north, west, south, east]
+
+        # Download
+        cache_dir = Path(cache_dir)
+        cache_dir.mkdir(exist_ok=True)
+        zip_file   = cache_dir / f"era5_{'_'.join(variables)}_{start}_{end}.zip"
+        output_file = cache_dir / f"era5_{'_'.join(variables)}_{start}_{end}.nc"
+
+        if not output_file.exists():
+            client = cdsapi.Client()
+            partial_files = []
+
+            for var_name, cds_var in zip(variables, cds_vars):
+                var_zip  = cache_dir / f"era5_{var_name}_{start}_{end}.zip"
+                var_nc   = cache_dir / f"era5_{var_name}_{start}_{end}.nc"
+                partial_files.append(var_nc)
+
+                if not var_nc.exists():
+                    client.retrieve(
+                        "reanalysis-era5-single-levels",
+                        {
+                            "product_type": "reanalysis",
+                            "variable":     [cds_var],
+                            "year":         years,
+                            "month":        months,
+                            "day":          days,
+                            "time":         [f"{h:02d}:00" for h in range(24)],
+                            "area":         area,
+                            "format":       "netcdf",
+                        },
+                        str(var_zip),
+                    )
+                    import zipfile
+                    if zipfile.is_zipfile(var_zip):
+                        with zipfile.ZipFile(var_zip, "r") as z:
+                            names = z.namelist()
+                            nc_name = next(n for n in names if n.endswith(".nc"))
+                            z.extract(nc_name, cache_dir)
+                            (cache_dir / nc_name).rename(var_nc)
+                        var_zip.unlink()
+                    else:
+                        # Already a NetCDF
+                        var_zip.rename(var_nc)
+                else:
+                    print(f"[era5] Using cached file: {var_nc}")
+
+            # Merge all variables into one dataset
+            datasets = [xr.open_dataset(f) for f in partial_files]
+            merged = xr.merge(datasets, compat="override")
+            merged.to_netcdf(output_file)
+            for ds_tmp in datasets:
+                ds_tmp.close()
+
+        else:
+            print(f"[era5] Using cached file: {output_file}")
+
+        # Load and rename short CDS names → forkairos names
+        ds = xr.open_dataset(output_file)
+        rename_dict = {var: self.CDS_SHORT_NAMES[var] for var in ds.data_vars if var in self.CDS_SHORT_NAMES}
+        ds = ds.rename(rename_dict)
+
+        # Rename coordinates to match forkairos convention
+        coord_map = {}
+        if "valid_time" in ds.coords:
+            coord_map["valid_time"] = "time"
+        if "latitude" in ds.coords:
+            coord_map["latitude"] = "lat"
+        if "longitude" in ds.coords:
+            coord_map["longitude"] = "lon"
+        if coord_map:
+            ds = ds.rename(coord_map)
+
+        # Drop auxiliary coords not needed
+        for c in ["expver", "number"]:
+            if c in ds.coords:
+                ds = ds.drop_vars(c)
+
+        ds.attrs = {
+            "source":      "ERA5 reanalysis (Copernicus CDS)",
+            "provider":    self.name,
+            "domain":      repr(domain),
+            "Conventions": "CF-1.8",
+        }
+
+        return ds

forkairos-0.1.0/forkairos/providers/gfs.py

@@ -0,0 +1,139 @@
+# forkairos/providers/gfs.py
+import requests
+import pandas as pd
+import xarray as xr
+import numpy as np
+from pathlib import Path
+from forkairos.providers.base import BaseProvider
+from forkairos.domain import Domain
+
+
+class GFSProvider(BaseProvider):
+
+    name = "gfs"
+    mode = "forecast"
+
+    VARIABLES = {
+        "temperature_2m":       "Air temperature at 2m (°C)",
+        "precipitation":        "Total precipitation (kg/m²)",
+        "snowfall":             "Snowfall (kg/m²)",
+        "surface_pressure":     "Surface pressure (Pa)",
+        "wind_speed_10m_u":     "U-component of wind at 10m (m/s)",
+        "wind_speed_10m_v":     "V-component of wind at 10m (m/s)",
+        "relative_humidity":    "Relative humidity at 2m (%)",
+        "shortwave_radiation":  "Downward shortwave radiation (W/m²)",
+        "snow_depth":           "Snow depth (m)",
+    }
+
+    # Mapping forkairos names → Open-Meteo GFS variable names
+    OPENMETEO_NAMES = {
+        "temperature_2m":      "temperature_2m",
+        "precipitation":       "precipitation",
+        "snowfall":            "snowfall",
+        "surface_pressure":    "surface_pressure",
+        "wind_speed_10m_u":    "wind_u_component_10m",
+        "wind_speed_10m_v":    "wind_v_component_10m",
+        "relative_humidity":   "relative_humidity_2m",
+        "shortwave_radiation": "shortwave_radiation",
+        "snow_depth":          "snow_depth",
+    }
+
+    FREQUENCIES = ["1h", "3h", "6h", "1d"]
+
+    # GFS via Open-Meteo forecast endpoint
+    FORECAST_URL  = "https://api.open-meteo.com/v1/gfs"
+
+    def available_variables(self) -> dict[str, str]:
+        return self.VARIABLES
+
+    def available_date_range(self) -> tuple[str, str]:
+        start = pd.Timestamp.today().strftime("%Y-%m-%d")
+        end   = (pd.Timestamp.today() + pd.Timedelta(days=15)).strftime("%Y-%m-%d")
+        return (start, "present+16days")
+
+    def available_frequencies(self) -> list[str]:
+        return self.FREQUENCIES
+
+    def download(
+        self,
+        domain: Domain,
+        variables: list[str],
+        start: str,
+        end: str,
+        freq: str = "1h",
+    ) -> xr.Dataset:
+
+        import openmeteo_requests
+        import requests_cache
+        from retry_requests import retry
+
+        # Validate inputs
+        for v in variables:
+            if v not in self.VARIABLES:
+                raise ValueError(f"Variable '{v}' not available. Choose from: {list(self.VARIABLES)}")
+        if freq not in self.FREQUENCIES:
+            raise ValueError(f"Frequency '{freq}' not available. Choose from: {self.FREQUENCIES}")
+
+        # Translate variable names
+        om_vars = [self.OPENMETEO_NAMES[v] for v in variables]
+
+        # Build grid of points covering the bbox
+        west, south, east, north = domain.bbox
+        lats = np.arange(south, north + 0.25, 0.25).round(4)
+        lons = np.arange(west,  east  + 0.25, 0.25).round(4)
+
+        # Setup client
+        cache_session = requests_cache.CachedSession(".cache_gfs", expire_after=3600)
+        retry_session = retry(cache_session, retries=5, backoff_factor=0.2)
+        client = openmeteo_requests.Client(session=retry_session)
+
+        # Download grid
+        rows = []
+        for lat in lats:
+            cols = []
+            for lon in lons:
+                params = {
+                    "latitude":   lat,
+                    "longitude":  lon,
+                    "hourly":     om_vars,
+                    "start_date": start,
+                    "end_date":   end,
+                    "timezone":   "UTC",
+                }
+                responses = client.weather_api(self.FORECAST_URL, params=params)
+                r = responses[0]
+                hourly = r.Hourly()
+
+                times = pd.date_range(
+                    start=pd.to_datetime(hourly.Time(), unit="s", utc=True),
+                    end=pd.to_datetime(hourly.TimeEnd(), unit="s", utc=True),
+                    freq=pd.Timedelta(seconds=hourly.Interval()),
+                    inclusive="left",
+                ).tz_localize(None)
+
+                data_vars = {}
+                for i, v in enumerate(variables):
+                    data_vars[v] = (["time"], hourly.Variables(i).ValuesAsNumpy())
+
+                ds_point = xr.Dataset(
+                    data_vars,
+                    coords={"time": times},
+                ).expand_dims(lat=[lat], lon=[lon])
+
+                cols.append(ds_point)
+            rows.append(xr.concat(cols, dim="lon"))
+
+        ds = xr.concat(rows, dim="lat")
+
+        # CF-compliant metadata
+        ds["lat"].attrs  = {"units": "degrees_north", "standard_name": "latitude"}
+        ds["lon"].attrs  = {"units": "degrees_east",  "standard_name": "longitude"}
+        ds["time"].attrs = {"standard_name": "time"}
+        ds.attrs = {
+            "source":      "GFS forecast via Open-Meteo API",
+            "provider":    self.name,
+            "domain":      repr(domain),
+            "Conventions": "CF-1.8",
+        }
+
+        return ds

forkairos-0.1.0/forkairos/providers/open_meteo.py

@@ -0,0 +1,125 @@
+# forkairos/providers/open_meteo.py
+import openmeteo_requests
+import requests_cache
+import pandas as pd
+import xarray as xr
+import numpy as np
+from retry_requests import retry
+from forkairos.providers.base import BaseProvider
+from forkairos.domain import Domain
+
+
+class OpenMeteoProvider(BaseProvider):
+
+    name = "open_meteo"
+    mode = "both"
+
+    VARIABLES = {
+        "temperature_2m":             "Air temperature at 2m (°C)",
+        "precipitation":              "Total precipitation (mm)",
+        "snowfall":                   "Snowfall (cm)",
+        "snow_depth":                 "Snow depth (m)",
+        "surface_pressure":           "Surface pressure (hPa)",
+        "wind_speed_10m":             "Wind speed at 10m (km/h)",
+        "wind_direction_10m":         "Wind direction at 10m (°)",
+        "relative_humidity_2m":       "Relative humidity at 2m (%)",
+        "shortwave_radiation":        "Shortwave solar radiation (W/m²)",
+        "et0_fao_evapotranspiration": "ET0 FAO evapotranspiration (mm)",
+    }
+
+    FREQUENCIES = ["1h", "3h", "6h", "1d"]
+
+    def available_variables(self) -> dict[str, str]:
+        return self.VARIABLES
+
+    def available_date_range(self) -> tuple[str, str]:
+        return ("1940-01-01", "present")
+
+    def available_frequencies(self) -> list[str]:
+        return self.FREQUENCIES
+
+    def download(
+        self,
+        domain: Domain,
+        variables: list[str],
+        start: str,
+        end: str,
+        freq: str = "1h",
+    ) -> xr.Dataset:
+
+        # Validate inputs
+        for v in variables:
+            if v not in self.VARIABLES:
+                raise ValueError(f"Variable '{v}' not available. Choose from: {list(self.VARIABLES)}")
+        if freq not in self.FREQUENCIES:
+            raise ValueError(f"Frequency '{freq}' not available. Choose from: {self.FREQUENCIES}")
+
+        # Build grid of points covering the bbox
+        west, south, east, north = domain.bbox
+        lats = np.arange(south, north + 0.25, 0.25).round(4)
+        lons = np.arange(west,  east  + 0.25, 0.25).round(4)
+
+        # Setup Open-Meteo client with cache and retry
+        cache_session = requests_cache.CachedSession(".cache_openmeteo", expire_after=-1)
+        retry_session = retry(cache_session, retries=5, backoff_factor=0.2)
+        client = openmeteo_requests.Client(session=retry_session)
+
+        # Choose endpoint: reanalysis vs forecast
+        today = pd.Timestamp.today().normalize()
+        end_dt = pd.Timestamp(end)
+        if end_dt < today - pd.Timedelta(days=7):
+            url = "https://archive-api.open-meteo.com/v1/archive"
+        else:
+            url = "https://api.open-meteo.com/v1/forecast"
+
+        # Download one point per grid cell
+        rows = []
+        for lat in lats:
+            cols = []
+            for lon in lons:
+                params = {
+                    "latitude":   lat,
+                    "longitude":  lon,
+                    "hourly":     variables,
+                    "start_date": start,
+                    "end_date":   end,
+                    "timezone":   "UTC",
+                }
+                responses = client.weather_api(url, params=params)
+                r = responses[0]
+                hourly = r.Hourly()
+
+                times = pd.date_range(
+                    start=pd.to_datetime(hourly.Time(), unit="s", utc=True),
+                    end=pd.to_datetime(hourly.TimeEnd(), unit="s", utc=True),
+                    freq=pd.Timedelta(seconds=hourly.Interval()),
+                    inclusive="left",
+                ).tz_localize(None)
+
+                data_vars = {}
+                for i, v in enumerate(variables):
+                    data_vars[v] = (["time"], hourly.Variables(i).ValuesAsNumpy())
+
+                ds_point = xr.Dataset(
+                    data_vars,
+                    coords={"time": times},
+                ).expand_dims(lat=[lat], lon=[lon])
+
+                cols.append(ds_point)
+
+            rows.append(xr.concat(cols, dim="lon"))
+
+        ds = xr.concat(rows, dim="lat")
+
+        # CF-compliant metadata
+        ds["lat"].attrs  = {"units": "degrees_north", "standard_name": "latitude"}
+        ds["lon"].attrs  = {"units": "degrees_east",  "standard_name": "longitude"}
+        ds["time"].attrs = {"standard_name": "time"}
+        ds.attrs = {
+            "source":      "Open-Meteo API",
+            "provider":    self.name,
+            "domain":      repr(domain),
+            "Conventions": "CF-1.8",
+        }
+
+        return ds

forkairos-0.1.0/forkairos.egg-info/PKG-INFO

@@ -0,0 +1,60 @@
+Metadata-Version: 2.4
+Name: forkairos
+Version: 0.1.0
+Summary: Operational pipeline for meteorological forcing data in CF-compliant NetCDF
+Author-email: Cristóbal Reyes <cristobal.sarda@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2026 Cristóbal Sardá
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Project-URL: Homepage, https://github.com/Jano01/forkairos
+Project-URL: Documentation, https://forkairos.readthedocs.io
+Project-URL: Repository, https://github.com/Jano01/forkairos
+Project-URL: Issues, https://github.com/Jano01/forkairos/issues
+Keywords: hydrology,meteorology,NWP,forcing,NetCDF,ERA5,GFS,ECMWF
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Atmospheric Science
+Classifier: Topic :: Scientific/Engineering :: Hydrology
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: xarray>=2024.1.0
+Requires-Dist: geopandas>=0.14.0
+Requires-Dist: netcdf4>=1.6.0
+Requires-Dist: requests>=2.31.0
+Requires-Dist: tqdm>=4.66.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: openmeteo-requests>=1.1.0
+Requires-Dist: requests-cache>=1.1.0
+Requires-Dist: retry-requests>=2.0.0
+Requires-Dist: cdsapi>=0.6.0
+Requires-Dist: cfgrib>=0.9.10
+Requires-Dist: scipy>=1.12.0
+Requires-Dist: numpy>=1.26.0
+Requires-Dist: pandas>=2.2.0
+Requires-Dist: ecmwf-opendata>=0.3.0
+Dynamic: license-file
+
+# snowops
+Operational data pipeline for snow hydrology — NWP forcings and satellite observations in CF-compliant NetCDF

forkairos-0.1.0/forkairos.egg-info/SOURCES.txt

@@ -0,0 +1,21 @@
+LICENSE
+README.md
+pyproject.toml
+forkairos/__init__.py
+forkairos/domain.py
+forkairos/export.py
+forkairos/pipeline.py
+forkairos/processing.py
+forkairos.egg-info/PKG-INFO
+forkairos.egg-info/SOURCES.txt
+forkairos.egg-info/dependency_links.txt
+forkairos.egg-info/requires.txt
+forkairos.egg-info/top_level.txt
+forkairos/providers/__init__.py
+forkairos/providers/base.py
+forkairos/providers/ecmwf_open.py
+forkairos/providers/era5.py
+forkairos/providers/gfs.py
+forkairos/providers/open_meteo.py
+tests/test_domain.py
+tests/test_processing.py

forkairos-0.1.0/forkairos.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

forkairos-0.1.0/forkairos.egg-info/requires.txt

@@ -0,0 +1,15 @@
+xarray>=2024.1.0
+geopandas>=0.14.0
+netcdf4>=1.6.0
+requests>=2.31.0
+tqdm>=4.66.0
+pydantic>=2.0.0
+openmeteo-requests>=1.1.0
+requests-cache>=1.1.0
+retry-requests>=2.0.0
+cdsapi>=0.6.0
+cfgrib>=0.9.10
+scipy>=1.12.0
+numpy>=1.26.0
+pandas>=2.2.0
+ecmwf-opendata>=0.3.0

forkairos-0.1.0/forkairos.egg-info/top_level.txt

@@ -0,0 +1 @@
+forkairos

forkairos-0.1.0/pyproject.toml

@@ -0,0 +1,56 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "forkairos"
+version = "0.1.0"
+description = "Operational pipeline for meteorological forcing data in CF-compliant NetCDF"
+readme = "README.md"
+license = { file = "LICENSE" }
+authors = [
+    { name = "Cristóbal Reyes", email = "cristobal.sarda@gmail.com" }
+]
+keywords = ["hydrology", "meteorology", "NWP", "forcing", "NetCDF", "ERA5", "GFS", "ECMWF"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Scientific/Engineering :: Atmospheric Science",
+    "Topic :: Scientific/Engineering :: Hydrology",
+]
+requires-python = ">=3.12"
+dependencies = [
+    "xarray>=2024.1.0",
+    "geopandas>=0.14.0",
+    "netcdf4>=1.6.0",
+    "requests>=2.31.0",
+    "tqdm>=4.66.0",
+    "pydantic>=2.0.0",
+    "openmeteo-requests>=1.1.0",
+    "requests-cache>=1.1.0",
+    "retry-requests>=2.0.0",
+    "cdsapi>=0.6.0",
+    "cfgrib>=0.9.10",
+    "scipy>=1.12.0",
+    "numpy>=1.26.0",
+    "pandas>=2.2.0",
+    "ecmwf-opendata>=0.3.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/Jano01/forkairos"
+Documentation = "https://forkairos.readthedocs.io"
+Repository = "https://github.com/Jano01/forkairos"
+Issues = "https://github.com/Jano01/forkairos/issues"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["forkairos*"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+markers = [
+    "credentials: tests that require external API credentials (deselect with -m 'not credentials')",
+]

forkairos-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

forkairos-0.1.0/tests/test_domain.py

@@ -0,0 +1,46 @@
+# tests/test_domain.py
+import pytest
+from forkairos.domain import Domain
+
+
+def test_domain_loads(synthetic_shapefile):
+    """Domain loads from shapefile without error."""
+    domain = Domain(synthetic_shapefile, buffer_km=5.0)
+    assert domain is not None
+
+
+def test_domain_bbox_order(synthetic_domain):
+    """Bbox is in correct order: west < east, south < north."""
+    west, south, east, north = synthetic_domain.bbox
+    assert west < east
+    assert south < north
+
+
+def test_domain_bbox_wgs84(synthetic_domain):
+    """Bbox coordinates are in valid WGS84 range."""
+    west, south, east, north = synthetic_domain.bbox
+    assert -180 <= west <= 180
+    assert -180 <= east <= 180
+    assert -90  <= south <= 90
+    assert -90  <= north <= 90
+
+
+def test_domain_buffer_expands_bbox(synthetic_shapefile):
+    """Buffer increases bbox size."""
+    domain_no_buffer   = Domain(synthetic_shapefile, buffer_km=0.0)
+    domain_with_buffer = Domain(synthetic_shapefile, buffer_km=10.0)
+
+    w0, s0, e0, n0 = domain_no_buffer.bbox
+    w1, s1, e1, n1 = domain_with_buffer.bbox
+
+    assert w1 < w0
+    assert s1 < s0
+    assert e1 > e0
+    assert n1 > n0
+
+
+def test_domain_repr(synthetic_domain):
+    """Domain repr contains shapefile name and bbox."""
+    r = repr(synthetic_domain)
+    assert "test_basin.shp" in r
+    assert "bbox" in r

forkairos-0.1.0/tests/test_processing.py

@@ -0,0 +1,63 @@
+# tests/test_processing.py
+import pytest
+import numpy as np
+import xarray as xr
+from forkairos.processing import regrid, bias_correct, resolution_guide
+
+
+def test_regrid_increases_resolution(mock_dataset):
+    """Regrid produces finer grid than input."""
+    ds_fine = regrid(mock_dataset, resolution=0.1)
+    assert len(ds_fine.lat) > len(mock_dataset.lat)
+    assert len(ds_fine.lon) > len(mock_dataset.lon)
+
+
+def test_regrid_preserves_variables(mock_dataset):
+    """Regrid keeps all variables."""
+    ds_fine = regrid(mock_dataset, resolution=0.1)
+    for var in mock_dataset.data_vars:
+        assert var in ds_fine.data_vars
+
+
+def test_regrid_preserves_time(mock_dataset):
+    """Regrid does not alter time dimension."""
+    ds_fine = regrid(mock_dataset, resolution=0.1)
+    assert len(ds_fine.time) == len(mock_dataset.time)
+
+
+def test_regrid_adds_metadata(mock_dataset):
+    """Regrid adds regridding attribute to dataset."""
+    ds_fine = regrid(mock_dataset, resolution=0.1)
+    assert "regridding" in ds_fine.attrs
+
+
+def test_regrid_invalid_method(mock_dataset):
+    """Regrid raises ValueError for unknown method."""
+    with pytest.raises(ValueError, match="Unknown method"):
+        regrid(mock_dataset, resolution=0.1, method="kriging")
+
+
+def test_bias_correct_output_shape(mock_dataset, mock_reference):
+    """Bias correction preserves dataset shape."""
+    ds_corrected = bias_correct(mock_dataset, mock_reference)
+    for var in mock_dataset.data_vars:
+        assert ds_corrected[var].shape == mock_dataset[var].shape
+
+
+def test_bias_correct_adds_metadata(mock_dataset, mock_reference):
+    """Bias correction adds attribute to dataset."""
+    ds_corrected = bias_correct(mock_dataset, mock_reference)
+    assert "bias_correction" in ds_corrected.attrs
+
+
+def test_bias_correct_invalid_method(mock_dataset, mock_reference):
+    """Bias correction raises ValueError for unknown method."""
+    with pytest.raises(ValueError, match="Unknown method"):
+        bias_correct(mock_dataset, mock_reference, method="delta")
+
+
+def test_resolution_guide_runs(capsys):
+    """resolution_guide prints without error."""
+    resolution_guide()
+    captured = capsys.readouterr()
+    assert "SRTM" in captured.out