era5-climate

name	era5-climate
description	Download and analyze ERA5 reanalysis climate data via the Copernicus CDS API, compute anomalies, trend analysis, and produce publication-quality climate maps.
tags	["climate","era5","reanalysis","xarray","cartopy","mann-kendall"]
version	1.0.0
authors	[{"name":"awesome-rosetta-skills contributors","github":"@awesome-rosetta-skills"}]
license	MIT
platforms	["claude-code","codex","gemini-cli","cursor"]
dependencies	["cdsapi>=0.6.1","xarray>=2023.6.0","numpy>=1.24.0","scipy>=1.11.0","matplotlib>=3.7.0","cartopy>=0.22.0","pymannkendall>=1.4.3","netCDF4>=1.6.4","cfgrib>=0.9.10","pandas>=2.0.0"]
last_updated	2026-03-17

ERA5 Climate Analysis Skill

This skill covers downloading ERA5 reanalysis data from the Copernicus Climate Data Store (CDS), processing large NetCDF datasets with xarray, computing climate anomalies against a reference baseline, detecting long-term trends via the Mann-Kendall test, and producing publication-quality maps with Cartopy.

ERA5 is the fifth generation ECMWF atmospheric reanalysis of the global climate, providing hourly estimates of atmospheric, land, and oceanic climate variables from 1940 to near-present at roughly 31 km horizontal resolution.

---

Prerequisites

CDS API Key Setup

The Copernicus Climate Data Store requires registration and an API key. After registering at https://cds.climate.copernicus.eu, place your credentials in ~/.cdsapirc:

# ~/.cdsapirc
url: https://cds.climate.copernicus.eu/api/v2
key: YOUR_UID:YOUR_API_KEY
verify: 1

Replace YOUR_UID and YOUR_API_KEY with your actual CDS user ID and API key from your CDS account profile page. The file must be readable only by you (chmod 600 ~/.cdsapirc).

Install Dependencies

pip install cdsapi xarray numpy scipy matplotlib cartopy pymannkendall netCDF4 cfgrib pandas
# On conda environments, cartopy is easier to install via conda:
# conda install -c conda-forge cartopy

---

Core Functions

"""
era5_climate.py
---------------
Core utilities for ERA5 reanalysis data download, anomaly computation,
trend analysis, and visualization.
"""

import os
import warnings
from pathlib import Path
from typing import Optional, Tuple, List, Dict

import cdsapi
import numpy as np
import pandas as pd
import xarray as xr
import matplotlib.pyplot  plt
 matplotlib.colors  mcolors
 cartopy.crs  ccrs
 cartopy.feature  cfeature
 pymannkendall  mk

warnings.filterwarnings(, category=RuntimeWarning)






 () -> Path:
    
    output_dir = Path(output_dir)
    output_dir.mkdir(parents=, exist_ok=)

    region_tag =   region    
    years_tag = 
    filename = output_dir / 

     filename.exists():
        ()
         filename

    c = cdsapi.Client()

    dataset = 
    product_type = 

    request = {
        : product_type,
        : variable,
        : [(y)  y  years],
        : [  m  (, )],
        : ,
        : ,
    }

     region   :
        request[] = region  

     pressure_level   :
        dataset = 
        request[] = (pressure_level)

    ()
    c.retrieve(dataset, request, (filename))
    ()
     filename






 () -> xr.DataArray:
    
    start, end = baseline_years
    baseline = da.sel(time=da.time.dt.year.isin((start, end + )))
    climatology = baseline.groupby().mean()
    anomaly = da.groupby() - climatology
    anomaly.attrs = da.attrs.copy()
    anomaly.attrs[] = da.attrs.get(, da.name) + 
     anomaly






 () -> [, xr.DataArray]:
    

     () -> [, ]:
        
        valid = ts[~np.isnan(ts)]
         (valid) < :
             np.nan, np.nan
        result = mk.original_test(valid)
         result.slope, result.p

    spatial_dims = [d  d  da.dims  d != dim]

      spatial_dims:
        
        result = mk.original_test(da.values[~np.isnan(da.values)])
         {
            : (result.slope),
            : (result.p),
            : result.trend,
        }

    
    slope_vals = np.full(da.shape[:], np.nan)
    pval_vals = np.full(da.shape[:], np.nan)

    data_np = da.values  
    flat = data_np.reshape(data_np.shape[], -)

    slopes_flat = np.full(flat.shape[], np.nan)
    pvals_flat = np.full(flat.shape[], np.nan)

     i  (flat.shape[]):
        s, p = _mk_pixel(flat[:, i])
        slopes_flat[i] = s
        pvals_flat[i] = p

    slope_vals = slopes_flat.reshape(data_np.shape[:])
    pval_vals = pvals_flat.reshape(data_np.shape[:])

    coords = {d: da.coords[d]  d  spatial_dims}
    slope_da = xr.DataArray(slope_vals, dims=spatial_dims, coords=coords,
                            attrs={: , : })
    pval_da = xr.DataArray(pval_vals, dims=spatial_dims, coords=coords,
                           attrs={: })
     {: slope_da, : pval_da}






 () -> xr.DataArray:
    
    weights = np.cos(np.deg2rad(da[lat_dim]))
    weights = weights / weights.()
     (da * weights).([lat_dim, ])






 () -> plt.Figure:
    
    proj_map = {
        : ccrs.Robinson(),
        : ccrs.PlateCarree(),
        : ccrs.Mollweide(),
        : ccrs.NorthPolarStereo(),
        : ccrs.SouthPolarStereo(),
    }
    proj = proj_map.get(projection, ccrs.Robinson())

    fig, ax = plt.subplots(, , figsize=(, ),
                           subplot_kw={: proj})
    ax.set_global()
    ax.add_feature(cfeature.COASTLINE, linewidth=)
    ax.add_feature(cfeature.BORDERS, linewidth=, linestyle=)
    ax.add_feature(cfeature.LAND, facecolor=, alpha=)

    lons = da[].values
    lats = da[].values
    data = da.values

     vmin    vmax  :
        absmax = np.nanpercentile(np.(data), )
        vmin, vmax = -absmax, absmax

    im = ax.pcolormesh(
        lons, lats, data,
        transform=ccrs.PlateCarree(),
        cmap=cmap, vmin=vmin, vmax=vmax,
        shading=,
    )

     stipple_mask   :
        sig_lons, sig_lats = np.meshgrid(lons, lats)
        mask = stipple_mask.values.astype()
        ax.scatter(
            sig_lons[mask], sig_lats[mask],
            transform=ccrs.PlateCarree(),
            s=, c=, alpha=, linewidths=,
        )

    units_label = units  da.attrs.get(, )
    cbar = fig.colorbar(im, ax=ax, orientation=,
                        pad=, shrink=, aspect=)
    cbar.set_label(units_label, fontsize=)
    ax.set_title(title, fontsize=, pad=)
    ax.gridlines(draw_labels=, linewidth=, color=, alpha=)

     output_path:
        fig.savefig(output_path, dpi=, bbox_inches=)
        ()

     fig