diff --git a/.github/workflows/python-app.yml b/.github/workflows/python-app.yml index 3342d752..29e48cb9 100644 --- a/.github/workflows/python-app.yml +++ b/.github/workflows/python-app.yml @@ -40,7 +40,7 @@ jobs: pip install -e packages/bundled_models/fourcastnext pip install -e .[test] - pytest -m="not noci" --cov=packages/data --cov=packages/utils --cov=packages/pipeline --cov=packages/training --cov=packages/zoo --cov=packages/bundled_models/fourcastnext --ignore=packages/nci_site_archive + pytest -m="not noci" --cov=packages/data --cov=packages/utils --cov=packages/pipeline --cov=packages/training --cov=packages/zoo --cov=packages/bundled_models/fourcastnext --cov=packages/third_party/pangeo_site_archive --ignore=packages/nci_site_archive - name: Coveralls GitHub Action uses: coverallsapp/github-action@v2.3.0 with: diff --git a/docs/data.md b/docs/data.md index f5a3cbb8..8e15c3d8 100644 --- a/docs/data.md +++ b/docs/data.md @@ -40,6 +40,20 @@ The package `site_archive_nci` (which is present in some of the tutorials) is th Additionally, you can explore the [geonetwork](https://geonetwork.nci.org.au/geonetwork/srv/eng/catalog.search#/home) to find additional data sets of interest which you might like to utilise by writing a custom PyEarthTools data accessor. +### Accessing CMIP6 climate model data from the cloud + +The package `site_archive_pangeo` (in `packages/third_party/pangeo_site_archive`) reads CMIP6 model output from the [Pangeo CMIP6 cloud archive](https://pangeo-data.github.io/pangeo-cmip6-cloud/accessing_data.html) on Google Cloud. No account, download or HPC access is needed; the data is opened lazily, so only the times you request are transferred. + +```python +import pyearthtools.data +from site_archive_pangeo import PangeoCMIP6 + +index = PangeoCMIP6(["tas", "pr"], source_id="CanESM5", experiment_id="historical") +ds = index.retrieve(pyearthtools.data.Petdt("2000-01")) +``` + +Each variable is looked up in the Pangeo catalogue and the newest version is used. If a variable exists on several grids, pass `grid_label` to choose one. Scalar coordinates that differ between variables (for example `height`, which is 2 m for `tas` but 10 m for `uas`) are dropped when the variables are combined. + ### Connecting PyEarthTools to a new dataset in any HPC facility by coding a new data accessor For on-disk data access, you will need to create a new accessor based on the [`pyearthtools.data.ArchiveIndex`](project:./api/data/data_api.md#pyearthtools.data.indexes.ArchiveIndex) class (or [`pyearthtools.data.Index`](project:./api/data/data_api.md#pyearthtools.data.indexes.Index) for some use cases). Additional instructions for this still need to be written. In the meantime, refer to the [NCI site archive source code](https://github.com/ACCESS-Community-Hub/PyEarthTools/tree/develop/packages/nci_site_archive) for examples. diff --git a/docs/notebooks/Gallery.ipynb b/docs/notebooks/Gallery.ipynb index f56b6e2a..4f706bd5 100644 --- a/docs/notebooks/Gallery.ipynb +++ b/docs/notebooks/Gallery.ipynb @@ -176,7 +176,8 @@ "| Transform-on-load | How to transform and adjust data at load-time | [Using Built-In Operations](./data/UsingTheInBuiltOperations.ipynb) | 18 Aug 2025 |\n", "| Applying data transforms | -- | [Applying Data Transforms](./data/Transforms.ipynb) | 18 Aug 2025 |\n", "| Geospatial subsetting | -- | [Region Cutting](./data/RegionCutting.ipynb) | 18 Aug 2025 |\n", - "| Remote Zarr Loading | Demontsrates loading data in a remote zarr archive | [Remote Zarr Loading](./data/Remote_Zarr_Loading.ipynb) |2 June 2026 |\n" + "| Remote Zarr Loading | Demonstrates loading data in a remote zarr archive | [Remote Zarr Loading](./data/Remote_Zarr_Loading.ipynb) |2 June 2026 |\n", + "| Pangeo CMIP6 | Demonstrates loading CMIP6 climate model data from the Pangeo cloud archive | [Pangeo CMIP6](./data/Pangeo_CMIP6.ipynb) | 11 Oct 2026 |\n" ] }, { diff --git a/docs/notebooks/data/Pangeo_CMIP6.ipynb b/docs/notebooks/data/Pangeo_CMIP6.ipynb new file mode 100644 index 00000000..96153724 --- /dev/null +++ b/docs/notebooks/data/Pangeo_CMIP6.ipynb @@ -0,0 +1,4456 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "a1000001", + "metadata": {}, + "source": [ + "# Accessing CMIP6 data from the Pangeo cloud archive\n", + "\n", + "The [Pangeo CMIP6 cloud archive](https://pangeo-data.github.io/pangeo-cmip6-cloud/accessing_data.html) hosts CMIP6 climate model output as analysis-ready, cloud-optimised (ARCO) Zarr stores on Google Cloud Storage. No account, download or HPC access is needed: PyEarthTools opens the stores lazily, so only the data you use is transferred.\n", + "\n", + "The `PangeoCMIP6` accessor, in the `site_archive_pangeo` package, is derived from the PyEarthTools `ArchiveIndex` class. It looks up each variable in the Pangeo catalogue and opens its Zarr store, so it is used like any other PyEarthTools data accessor.\n", + "\n", + "Install the package from the monorepo with `pip install -e packages/third_party/pangeo_site_archive`." + ] + }, + { + "cell_type": "markdown", + "id": "a1000002", + "metadata": {}, + "source": [ + "### Set up imports for demo" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "a1000003", + "metadata": { + "execution": { + "iopub.execute_input": "2026-10-14T18:32:47.666679Z", + "iopub.status.busy": "2026-10-14T18:32:47.665681Z", + "iopub.status.idle": "2026-10-14T18:32:52.808611Z", + "shell.execute_reply": "2026-10-14T18:32:52.807583Z" + } + }, + "outputs": [], + "source": [ + "import matplotlib.pyplot\n", + "import cartopy.crs\n", + "import numpy\n", + "\n", + "import pyearthtools.data\n", + "import pyearthtools.data.transforms.coordinates\n", + "import pyearthtools.pipeline\n", + "from site_archive_pangeo import PangeoCMIP6" + ] + }, + { + "cell_type": "markdown", + "id": "a1000004", + "metadata": {}, + "source": [ + "## Discover the available data\n", + "\n", + "The catalogue lists every variable of every model run in the archive. `PangeoCMIP6.catalog()` returns it as a pandas `DataFrame`, so the usual pandas filtering shows what is available. The catalogue is a large CSV file, so the first read takes a moment." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "a1000005", + "metadata": { + "execution": { + "iopub.execute_input": "2026-10-14T18:32:52.812756Z", + "iopub.status.busy": "2026-10-14T18:32:52.812756Z", + "iopub.status.idle": "2026-10-14T18:33:28.916808Z", + "shell.execute_reply": "2026-10-14T18:33:28.915794Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
source_idexperiment_idmember_idtable_idvariable_idgrid_labelzstoreversion
0CMCC-CM2-HR4highresSST-presentr1i1p1f1Amonpsgngs://cmip6/CMIP6/HighResMIP/CMCC/CMCC-CM2-HR4/...20170706
1CMCC-CM2-HR4highresSST-presentr1i1p1f1Amonrsdsgngs://cmip6/CMIP6/HighResMIP/CMCC/CMCC-CM2-HR4/...20170706
2CMCC-CM2-HR4highresSST-presentr1i1p1f1Amonrlusgngs://cmip6/CMIP6/HighResMIP/CMCC/CMCC-CM2-HR4/...20170706
3CMCC-CM2-HR4highresSST-presentr1i1p1f1Amonrldsgngs://cmip6/CMIP6/HighResMIP/CMCC/CMCC-CM2-HR4/...20170706
4CMCC-CM2-HR4highresSST-presentr1i1p1f1Amonpslgngs://cmip6/CMIP6/HighResMIP/CMCC/CMCC-CM2-HR4/...20170706
\n", + "
" + ], + "text/plain": [ + " source_id experiment_id member_id table_id variable_id grid_label \\\n", + "0 CMCC-CM2-HR4 highresSST-present r1i1p1f1 Amon ps gn \n", + "1 CMCC-CM2-HR4 highresSST-present r1i1p1f1 Amon rsds gn \n", + "2 CMCC-CM2-HR4 highresSST-present r1i1p1f1 Amon rlus gn \n", + "3 CMCC-CM2-HR4 highresSST-present r1i1p1f1 Amon rlds gn \n", + "4 CMCC-CM2-HR4 highresSST-present r1i1p1f1 Amon psl gn \n", + "\n", + " zstore version \n", + "0 gs://cmip6/CMIP6/HighResMIP/CMCC/CMCC-CM2-HR4/... 20170706 \n", + "1 gs://cmip6/CMIP6/HighResMIP/CMCC/CMCC-CM2-HR4/... 20170706 \n", + "2 gs://cmip6/CMIP6/HighResMIP/CMCC/CMCC-CM2-HR4/... 20170706 \n", + "3 gs://cmip6/CMIP6/HighResMIP/CMCC/CMCC-CM2-HR4/... 20170706 \n", + "4 gs://cmip6/CMIP6/HighResMIP/CMCC/CMCC-CM2-HR4/... 20170706 " + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "catalog = PangeoCMIP6.catalog()\n", + "catalog.head()" + ] + }, + { + "cell_type": "markdown", + "id": "a1000006", + "metadata": {}, + "source": [ + "Each row is one variable of one model run. Here we count, for each experiment, how many models provide monthly near-surface air temperature (`tas` in the `Amon` table)." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "a1000007", + "metadata": { + "execution": { + "iopub.execute_input": "2026-10-14T18:33:28.922064Z", + "iopub.status.busy": "2026-10-14T18:33:28.922022Z", + "iopub.status.idle": "2026-10-14T18:33:28.982717Z", + "shell.execute_reply": "2026-10-14T18:33:28.981684Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "experiment_id\n", + "piControl 64\n", + "historical 64\n", + "1pctCO2 59\n", + "abrupt-4xCO2 59\n", + "ssp585 47\n", + "amip 46\n", + "ssp245 46\n", + "ssp126 44\n", + "ssp370 42\n", + "piClim-control 19\n", + "Name: source_id, dtype: int64" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "monthly_tas = catalog[(catalog['variable_id'] == 'tas') & (catalog['table_id'] == 'Amon')]\n", + "monthly_tas.groupby('experiment_id')['source_id'].nunique().sort_values(ascending=False).head(10)" + ] + }, + { + "cell_type": "markdown", + "id": "a1000008", + "metadata": {}, + "source": [ + "## Set up the accessor\n", + "\n", + "An accessor selects one model run: the model (`source_id`), the experiment (`experiment_id`), the ensemble member (`member_id`, default `r1i1p1f1`) and the table (`table_id`, default `Amon`, monthly atmosphere). Here we use the `historical` experiment of the `CanESM5` model.\n", + "\n", + "Creating the accessor does not read the catalogue or any data." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "a1000009", + "metadata": { + "execution": { + "iopub.execute_input": "2026-10-14T18:33:28.986717Z", + "iopub.status.busy": "2026-10-14T18:33:28.985719Z", + "iopub.status.idle": "2026-10-14T18:33:29.030167Z", + "shell.execute_reply": "2026-10-14T18:33:29.029067Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
PangeoCMIP6\n",
+       "\tDescription                    Pangeo CMIP6 analysis-ready, cloud-optimised data accessor\n",
+       "\t\t Documentation                  'https://pangeo-data.github.io/pangeo-cmip6-cloud/accessing_data.html'\n",
+       "\n",
+       "\n",
+       "\tInitialisation                 \n",
+       "\t\t catalog                        'https://storage.googleapis.com/cmip6/pangeo-cmip6.csv'\n",
+       "\t\t experiment_id                  'historical'\n",
+       "\t\t grid_label                     None\n",
+       "\t\t member_id                      'r1i1p1f1'\n",
+       "\t\t source_id                      'CanESM5'\n",
+       "\t\t table_id                       'Amon'\n",
+       "\t\t variables                      ['tas']\n",
+       "\tTransforms                     \n",
+       "\t\t StandardCoordinateNames        {'latitude': "['lat', 'Latitude', 'yt_ocean', 'yt']", 'longitude': "['lon', 'Longitude', 'xt_ocean', 'xt']", 'replacement_dictionary': 'None', 'time': "['Time']"}\n",
+       "\t\t Trim                           {'__args': '()', 'variables': "['tas']"}
" + ], + "text/plain": [ + "PangeoCMIP6\n", + "\tDescription Pangeo CMIP6 analysis-ready, cloud-optimised data accessor\n", + "\t\t Documentation 'https://pangeo-data.github.io/pangeo-cmip6-cloud/accessing_data.html'\n", + "\n", + "\n", + "\tInitialisation \n", + "\t\t catalog 'https://storage.googleapis.com/cmip6/pangeo-cmip6.csv'\n", + "\t\t experiment_id 'historical'\n", + "\t\t grid_label None\n", + "\t\t member_id 'r1i1p1f1'\n", + "\t\t source_id 'CanESM5'\n", + "\t\t table_id 'Amon'\n", + "\t\t variables ['tas']\n", + "\tTransforms \n", + "\t\t StandardCoordinateNames {'latitude': \"['lat', 'Latitude', 'yt_ocean', 'yt']\", 'longitude': \"['lon', 'Longitude', 'xt_ocean', 'xt']\", 'replacement_dictionary': 'None', 'time': \"['Time']\"}\n", + "\t\t Trim {'__args': '()', 'variables': \"['tas']\"}" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "index = PangeoCMIP6(['tas'], source_id='CanESM5', experiment_id='historical')\n", + "index" + ] + }, + { + "cell_type": "markdown", + "id": "a1000010", + "metadata": {}, + "source": [ + "## Retrieve data\n", + "\n", + "`retrieve` looks up the Zarr store of each variable and selects the requested time. The result is lazy, so the values are only downloaded when they are used." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "a1000011", + "metadata": { + "execution": { + "iopub.execute_input": "2026-10-14T18:33:29.034105Z", + "iopub.status.busy": "2026-10-14T18:33:29.033100Z", + "iopub.status.idle": "2026-10-14T18:34:15.043323Z", + "shell.execute_reply": "2026-10-14T18:34:15.042279Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.Dataset> Size: 34kB\n",
+       "Dimensions:    (time: 1, latitude: 64, longitude: 128)\n",
+       "Coordinates:\n",
+       "  * time       (time) object 8B 2000-01-16 12:00:00\n",
+       "  * latitude   (latitude) float64 512B -87.86 -85.1 -82.31 ... 82.31 85.1 87.86\n",
+       "  * longitude  (longitude) float64 1kB 0.0 2.812 5.625 ... 351.6 354.4 357.2\n",
+       "    height     float64 8B ...\n",
+       "Data variables:\n",
+       "    tas        (time, latitude, longitude) float32 33kB dask.array<chunksize=(1, 64, 128), meta=np.ndarray>\n",
+       "Attributes: (12/54)\n",
+       "    CCCma_model_hash:            3dedf95315d603326fde4f5340dc0519d80d10c0\n",
+       "    CCCma_parent_runid:          rc3-pictrl\n",
+       "    CCCma_pycmor_hash:           33c30511acc319a98240633965a04ca99c26427e\n",
+       "    CCCma_runid:                 rc3.1-his01\n",
+       "    Conventions:                 CF-1.7 CMIP-6.2\n",
+       "    YMDH_branch_time_in_child:   1850:01:01:00\n",
+       "    ...                          ...\n",
+       "    title:                       CanESM5 output prepared for CMIP6\n",
+       "    tracking_id:                 hdl:21.14100/872062df-acae-499b-aa0f-9eaca76...\n",
+       "    variable_id:                 tas\n",
+       "    variant_label:               r1i1p1f1\n",
+       "    version:                     v20190429\n",
+       "    status:                      2019-10-25;created;by nhn2@columbia.edu
" + ], + "text/plain": [ + " Size: 34kB\n", + "Dimensions: (time: 1, latitude: 64, longitude: 128)\n", + "Coordinates:\n", + " * time (time) object 8B 2000-01-16 12:00:00\n", + " * latitude (latitude) float64 512B -87.86 -85.1 -82.31 ... 82.31 85.1 87.86\n", + " * longitude (longitude) float64 1kB 0.0 2.812 5.625 ... 351.6 354.4 357.2\n", + " height float64 8B ...\n", + "Data variables:\n", + " tas (time, latitude, longitude) float32 33kB dask.array\n", + "Attributes: (12/54)\n", + " CCCma_model_hash: 3dedf95315d603326fde4f5340dc0519d80d10c0\n", + " CCCma_parent_runid: rc3-pictrl\n", + " CCCma_pycmor_hash: 33c30511acc319a98240633965a04ca99c26427e\n", + " CCCma_runid: rc3.1-his01\n", + " Conventions: CF-1.7 CMIP-6.2\n", + " YMDH_branch_time_in_child: 1850:01:01:00\n", + " ... ...\n", + " title: CanESM5 output prepared for CMIP6\n", + " tracking_id: hdl:21.14100/872062df-acae-499b-aa0f-9eaca76...\n", + " variable_id: tas\n", + " variant_label: r1i1p1f1\n", + " version: v20190429\n", + " status: 2019-10-25;created;by nhn2@columbia.edu" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data = index.retrieve('2000-01')\n", + "data" + ] + }, + { + "cell_type": "markdown", + "id": "a1000012", + "metadata": {}, + "source": [ + "## Convert units with a transform and a pipeline\n", + "\n", + "CMIP6 temperatures are in kelvin. In PyEarthTools, operations on data are written as `Transform`s and chained in a `Pipeline`, rather than as one-off array arithmetic, so that they are reusable, recorded and applied the same way to every sample.\n", + "\n", + "Here a `ConvertUnits` transform takes two dictionaries, one of conversion functions and one of the new unit names, both keyed by variable name. It converts the named variables, leaves the others unchanged and updates their `units` attribute." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "a1000021", + "metadata": { + "execution": { + "iopub.execute_input": "2026-10-14T18:34:15.048329Z", + "iopub.status.busy": "2026-10-14T18:34:15.047329Z", + "iopub.status.idle": "2026-10-14T18:34:15.056519Z", + "shell.execute_reply": "2026-10-14T18:34:15.055502Z" + } + }, + "outputs": [], + "source": [ + "class ConvertUnits(pyearthtools.data.Transform):\n", + " \"\"\"\n", + " This transform converts the unit in a dataset.\n", + " \"\"\"\n", + "\n", + " def __init__(self, var_convert_dict, var_units):\n", + " self._var_convert_dict = var_convert_dict\n", + " self._var_units = var_units\n", + " if set(var_convert_dict.keys()) != set(var_units.keys()):\n", + " raise ValueError('The unit conversion function and unit names dictionaries must have the same keys.')\n", + " super().__init__()\n", + " self.record_initialisation()\n", + "\n", + " def apply(self, sample):\n", + " def map_func(da, var_lut):\n", + " try:\n", + " ret_val = var_lut[da.name](da)\n", + " except KeyError:\n", + " ret_val = da\n", + " return ret_val\n", + "\n", + " ret_sample = sample.map(map_func, var_lut=self._var_convert_dict)\n", + " for var_name, var_unit in self._var_units.items():\n", + " ret_sample[var_name].attrs['units'] = var_unit\n", + " return ret_sample" + ] + }, + { + "cell_type": "markdown", + "id": "a1000022", + "metadata": {}, + "source": [ + "A `Pipeline` takes the data accessor followed by the operations to apply. Indexing the pipeline with a time retrieves the data from the accessor and applies each operation in turn." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "a1000023", + "metadata": { + "execution": { + "iopub.execute_input": "2026-10-14T18:34:15.060657Z", + "iopub.status.busy": "2026-10-14T18:34:15.060657Z", + "iopub.status.idle": "2026-10-14T18:34:19.929526Z", + "shell.execute_reply": "2026-10-14T18:34:19.928398Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Pipeline\n",
+       "\tDescription                    `pyearthtools.pipeline` Data Pipeline\n",
+       "\n",
+       "\n",
+       "\tInitialisation                 \n",
+       "\t\t exceptions_to_ignore           None\n",
+       "\t\t iterator                       None\n",
+       "\t\t max_exception_count            -1\n",
+       "\t\t name                           None\n",
+       "\t\t sampler                        None\n",
+       "\tSteps                          \n",
+       "\t\t pangeo_cmip6.PangeoCMIP6       {'PangeoCMIP6': {'catalog': "'https://storage.googleapis.com/cmip6/pangeo-cmip6.csv'", 'experiment_id': "'historical'", 'grid_label': 'None', 'member_id': "'r1i1p1f1'", 'source_id': "'CanESM5'", 'table_id': "'Amon'", 'variables': "['tas']"}}\n",
+       "\t\t __main__.ConvertUnits          {'ConvertUnits': {'var_convert_dict': {'tas': '<function <lambda> at 0x000001A7004BBC40>'}, 'var_units': {'tas': "'degC'"}}}
" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "

Graph

" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/svg+xml": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "PangeoCMIP6_0859cda7-edb1-42ff-a8f7-533d510dedf5\n", + "\n", + "pangeo_cmip6.PangeoCMIP6\n", + "\n", + "\n", + "\n", + "ConvertUnits_9a0d5ee5-ee83-4a9a-bcc5-de00107f2f86\n", + "\n", + "__main__.ConvertUnits\n", + "\n", + "\n", + "\n", + "PangeoCMIP6_0859cda7-edb1-42ff-a8f7-533d510dedf5->ConvertUnits_9a0d5ee5-ee83-4a9a-bcc5-de00107f2f86\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "var_lut = {'tas': lambda arr1: arr1 - 273.15}\n", + "unit_lut = {'tas': 'degC'}\n", + "\n", + "convert_units = ConvertUnits(var_convert_dict=var_lut, var_units=unit_lut)\n", + "\n", + "cmip_pipe = pyearthtools.pipeline.Pipeline(\n", + " index,\n", + " convert_units,\n", + ")\n", + "cmip_pipe" + ] + }, + { + "cell_type": "markdown", + "id": "a1000024", + "metadata": {}, + "source": [ + "## Visualise the data\n", + "\n", + "Plot the near-surface air temperature of January 2000 on a map, now in degrees Celsius. The model longitudes run from 0 to 360, so the map is centred on 180 degrees." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "a1000025", + "metadata": { + "execution": { + "iopub.execute_input": "2026-10-14T18:34:19.933638Z", + "iopub.status.busy": "2026-10-14T18:34:19.932638Z", + "iopub.status.idle": "2026-10-14T18:34:19.971645Z", + "shell.execute_reply": "2026-10-14T18:34:19.970637Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.Dataset> Size: 34kB\n",
+       "Dimensions:    (latitude: 64, longitude: 128, time: 1)\n",
+       "Coordinates:\n",
+       "  * latitude   (latitude) float64 512B -87.86 -85.1 -82.31 ... 82.31 85.1 87.86\n",
+       "  * longitude  (longitude) float64 1kB 0.0 2.812 5.625 ... 351.6 354.4 357.2\n",
+       "  * time       (time) object 8B 2000-01-16 12:00:00\n",
+       "    height     float64 8B ...\n",
+       "Data variables:\n",
+       "    tas        (time, latitude, longitude) float32 33kB dask.array<chunksize=(1, 64, 128), meta=np.ndarray>\n",
+       "Attributes: (12/54)\n",
+       "    CCCma_model_hash:            3dedf95315d603326fde4f5340dc0519d80d10c0\n",
+       "    CCCma_parent_runid:          rc3-pictrl\n",
+       "    CCCma_pycmor_hash:           33c30511acc319a98240633965a04ca99c26427e\n",
+       "    CCCma_runid:                 rc3.1-his01\n",
+       "    Conventions:                 CF-1.7 CMIP-6.2\n",
+       "    YMDH_branch_time_in_child:   1850:01:01:00\n",
+       "    ...                          ...\n",
+       "    title:                       CanESM5 output prepared for CMIP6\n",
+       "    tracking_id:                 hdl:21.14100/872062df-acae-499b-aa0f-9eaca76...\n",
+       "    variable_id:                 tas\n",
+       "    variant_label:               r1i1p1f1\n",
+       "    version:                     v20190429\n",
+       "    status:                      2019-10-25;created;by nhn2@columbia.edu
" + ], + "text/plain": [ + " Size: 34kB\n", + "Dimensions: (latitude: 64, longitude: 128, time: 1)\n", + "Coordinates:\n", + " * latitude (latitude) float64 512B -87.86 -85.1 -82.31 ... 82.31 85.1 87.86\n", + " * longitude (longitude) float64 1kB 0.0 2.812 5.625 ... 351.6 354.4 357.2\n", + " * time (time) object 8B 2000-01-16 12:00:00\n", + " height float64 8B ...\n", + "Data variables:\n", + " tas (time, latitude, longitude) float32 33kB dask.array\n", + "Attributes: (12/54)\n", + " CCCma_model_hash: 3dedf95315d603326fde4f5340dc0519d80d10c0\n", + " CCCma_parent_runid: rc3-pictrl\n", + " CCCma_pycmor_hash: 33c30511acc319a98240633965a04ca99c26427e\n", + " CCCma_runid: rc3.1-his01\n", + " Conventions: CF-1.7 CMIP-6.2\n", + " YMDH_branch_time_in_child: 1850:01:01:00\n", + " ... ...\n", + " title: CanESM5 output prepared for CMIP6\n", + " tracking_id: hdl:21.14100/872062df-acae-499b-aa0f-9eaca76...\n", + " variable_id: tas\n", + " variant_label: r1i1p1f1\n", + " version: v20190429\n", + " status: 2019-10-25;created;by nhn2@columbia.edu" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data_c = cmip_pipe['2000-01']\n", + "data_c" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "a1000013", + "metadata": { + "execution": { + "iopub.execute_input": "2026-10-14T18:34:19.975727Z", + "iopub.status.busy": "2026-10-14T18:34:19.974726Z", + "iopub.status.idle": "2026-10-14T18:34:24.217147Z", + "shell.execute_reply": "2026-10-14T18:34:24.216135Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "temperature = data_c['tas'].squeeze()\n", + "\n", + "fig = matplotlib.pyplot.figure(figsize=(10, 5))\n", + "ax = matplotlib.pyplot.axes(projection=cartopy.crs.PlateCarree(central_longitude=180))\n", + "temperature.plot(\n", + " ax=ax,\n", + " transform=cartopy.crs.PlateCarree(),\n", + " cmap='RdBu_r',\n", + " cbar_kwargs={'label': f\"Near-surface air temperature ({temperature.attrs['units']})\"},\n", + ")\n", + "ax.coastlines()\n", + "ax.set_title('CanESM5 historical, January 2000');" + ] + }, + { + "cell_type": "markdown", + "id": "a1000026", + "metadata": {}, + "source": [ + "### Supplying the transform to the accessor\n", + "\n", + "Alternatively, give the transform to the accessor with `transforms=`, and every retrieval returns data with the right units." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "a1000027", + "metadata": { + "execution": { + "iopub.execute_input": "2026-10-14T18:34:24.221417Z", + "iopub.status.busy": "2026-10-14T18:34:24.221417Z", + "iopub.status.idle": "2026-10-14T18:35:02.309046Z", + "shell.execute_reply": "2026-10-14T18:35:02.308032Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.Dataset> Size: 34kB\n",
+       "Dimensions:    (latitude: 64, longitude: 128, time: 1)\n",
+       "Coordinates:\n",
+       "  * latitude   (latitude) float64 512B -87.86 -85.1 -82.31 ... 82.31 85.1 87.86\n",
+       "  * longitude  (longitude) float64 1kB 0.0 2.812 5.625 ... 351.6 354.4 357.2\n",
+       "  * time       (time) object 8B 2000-01-16 12:00:00\n",
+       "    height     float64 8B ...\n",
+       "Data variables:\n",
+       "    tas        (time, latitude, longitude) float32 33kB dask.array<chunksize=(1, 64, 128), meta=np.ndarray>\n",
+       "Attributes: (12/54)\n",
+       "    CCCma_model_hash:            3dedf95315d603326fde4f5340dc0519d80d10c0\n",
+       "    CCCma_parent_runid:          rc3-pictrl\n",
+       "    CCCma_pycmor_hash:           33c30511acc319a98240633965a04ca99c26427e\n",
+       "    CCCma_runid:                 rc3.1-his01\n",
+       "    Conventions:                 CF-1.7 CMIP-6.2\n",
+       "    YMDH_branch_time_in_child:   1850:01:01:00\n",
+       "    ...                          ...\n",
+       "    title:                       CanESM5 output prepared for CMIP6\n",
+       "    tracking_id:                 hdl:21.14100/872062df-acae-499b-aa0f-9eaca76...\n",
+       "    variable_id:                 tas\n",
+       "    variant_label:               r1i1p1f1\n",
+       "    version:                     v20190429\n",
+       "    status:                      2019-10-25;created;by nhn2@columbia.edu
" + ], + "text/plain": [ + " Size: 34kB\n", + "Dimensions: (latitude: 64, longitude: 128, time: 1)\n", + "Coordinates:\n", + " * latitude (latitude) float64 512B -87.86 -85.1 -82.31 ... 82.31 85.1 87.86\n", + " * longitude (longitude) float64 1kB 0.0 2.812 5.625 ... 351.6 354.4 357.2\n", + " * time (time) object 8B 2000-01-16 12:00:00\n", + " height float64 8B ...\n", + "Data variables:\n", + " tas (time, latitude, longitude) float32 33kB dask.array\n", + "Attributes: (12/54)\n", + " CCCma_model_hash: 3dedf95315d603326fde4f5340dc0519d80d10c0\n", + " CCCma_parent_runid: rc3-pictrl\n", + " CCCma_pycmor_hash: 33c30511acc319a98240633965a04ca99c26427e\n", + " CCCma_runid: rc3.1-his01\n", + " Conventions: CF-1.7 CMIP-6.2\n", + " YMDH_branch_time_in_child: 1850:01:01:00\n", + " ... ...\n", + " title: CanESM5 output prepared for CMIP6\n", + " tracking_id: hdl:21.14100/872062df-acae-499b-aa0f-9eaca76...\n", + " variable_id: tas\n", + " variant_label: r1i1p1f1\n", + " version: v20190429\n", + " status: 2019-10-25;created;by nhn2@columbia.edu" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "cmip_index = PangeoCMIP6(\n", + " ['tas'],\n", + " source_id='CanESM5',\n", + " experiment_id='historical',\n", + " transforms=[ConvertUnits(var_convert_dict=var_lut, var_units=unit_lut)],\n", + ")\n", + "cmip_index.retrieve('2000-01')" + ] + }, + { + "cell_type": "markdown", + "id": "a1000014", + "metadata": {}, + "source": [ + "## Load every time of a variable\n", + "\n", + "A Zarr store holds all times of a variable, so the accessor ignores the requested time when it looks the store up and selects the time afterwards. `filesystem` shows the store that is opened." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "a1000015", + "metadata": { + "execution": { + "iopub.execute_input": "2026-10-14T18:35:02.313043Z", + "iopub.status.busy": "2026-10-14T18:35:02.313043Z", + "iopub.status.idle": "2026-10-14T18:35:02.322169Z", + "shell.execute_reply": "2026-10-14T18:35:02.321154Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "{'tas': 'gs://cmip6/CMIP6/CMIP/CCCma/CanESM5/historical/r1i1p1f1/Amon/tas/gn/v20190429/'}" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "index.filesystem('2000-01')" + ] + }, + { + "cell_type": "markdown", + "id": "a1000016", + "metadata": {}, + "source": [ + "`load` opens that store lazily with all of its times. Here we apply the same `ConvertUnits` transform to it, drop the scalar `height` coordinate with the `Drop` transform, and plot the area-weighted global mean temperature of the whole historical run. Only the `tas` data is downloaded, which takes a short while." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "a1000017", + "metadata": { + "execution": { + "iopub.execute_input": "2026-10-14T18:35:02.326033Z", + "iopub.status.busy": "2026-10-14T18:35:02.326033Z", + "iopub.status.idle": "2026-10-14T18:35:22.938135Z", + "shell.execute_reply": "2026-10-14T18:35:22.937124Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "drop_height = pyearthtools.data.transforms.coordinates.Drop('height', ignore_missing=True)\n", + "full = drop_height.apply(convert_units.apply(index.load(index.filesystem('2000-01'))))\n", + "\n", + "weights = numpy.cos(numpy.deg2rad(full['lat']))\n", + "global_mean = full['tas'].weighted(weights).mean(('lat', 'lon'))\n", + "annual_mean = global_mean.groupby('time.year').mean()\n", + "\n", + "annual_mean.plot()\n", + "matplotlib.pyplot.ylabel(f\"Global mean near-surface air temperature ({full['tas'].attrs['units']})\");" + ] + }, + { + "cell_type": "markdown", + "id": "a1000018", + "metadata": {}, + "source": [ + "## Several variables and grids\n", + "\n", + "Pass a list of variables to retrieve several at once. Each variable is looked up in the catalogue and the newest version is used." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "a1000019", + "metadata": { + "execution": { + "iopub.execute_input": "2026-10-14T18:35:22.942394Z", + "iopub.status.busy": "2026-10-14T18:35:22.941389Z", + "iopub.status.idle": "2026-10-14T18:36:03.445021Z", + "shell.execute_reply": "2026-10-14T18:36:03.444006Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.Dataset> Size: 67kB\n",
+       "Dimensions:    (time: 1, latitude: 64, longitude: 128)\n",
+       "Coordinates:\n",
+       "  * time       (time) object 8B 2000-01-16 12:00:00\n",
+       "  * latitude   (latitude) float64 512B -87.86 -85.1 -82.31 ... 82.31 85.1 87.86\n",
+       "  * longitude  (longitude) float64 1kB 0.0 2.812 5.625 ... 351.6 354.4 357.2\n",
+       "    height     float64 8B ...\n",
+       "Data variables:\n",
+       "    pr         (time, latitude, longitude) float32 33kB dask.array<chunksize=(1, 64, 128), meta=np.ndarray>\n",
+       "    tas        (time, latitude, longitude) float32 33kB dask.array<chunksize=(1, 64, 128), meta=np.ndarray>\n",
+       "Attributes: (12/54)\n",
+       "    CCCma_model_hash:            3dedf95315d603326fde4f5340dc0519d80d10c0\n",
+       "    CCCma_parent_runid:          rc3-pictrl\n",
+       "    CCCma_pycmor_hash:           33c30511acc319a98240633965a04ca99c26427e\n",
+       "    CCCma_runid:                 rc3.1-his01\n",
+       "    Conventions:                 CF-1.7 CMIP-6.2\n",
+       "    YMDH_branch_time_in_child:   1850:01:01:00\n",
+       "    ...                          ...\n",
+       "    title:                       CanESM5 output prepared for CMIP6\n",
+       "    tracking_id:                 hdl:21.14100/872062df-acae-499b-aa0f-9eaca76...\n",
+       "    variable_id:                 tas\n",
+       "    variant_label:               r1i1p1f1\n",
+       "    version:                     v20190429\n",
+       "    status:                      2019-10-25;created;by nhn2@columbia.edu
" + ], + "text/plain": [ + " Size: 67kB\n", + "Dimensions: (time: 1, latitude: 64, longitude: 128)\n", + "Coordinates:\n", + " * time (time) object 8B 2000-01-16 12:00:00\n", + " * latitude (latitude) float64 512B -87.86 -85.1 -82.31 ... 82.31 85.1 87.86\n", + " * longitude (longitude) float64 1kB 0.0 2.812 5.625 ... 351.6 354.4 357.2\n", + " height float64 8B ...\n", + "Data variables:\n", + " pr (time, latitude, longitude) float32 33kB dask.array\n", + " tas (time, latitude, longitude) float32 33kB dask.array\n", + "Attributes: (12/54)\n", + " CCCma_model_hash: 3dedf95315d603326fde4f5340dc0519d80d10c0\n", + " CCCma_parent_runid: rc3-pictrl\n", + " CCCma_pycmor_hash: 33c30511acc319a98240633965a04ca99c26427e\n", + " CCCma_runid: rc3.1-his01\n", + " Conventions: CF-1.7 CMIP-6.2\n", + " YMDH_branch_time_in_child: 1850:01:01:00\n", + " ... ...\n", + " title: CanESM5 output prepared for CMIP6\n", + " tracking_id: hdl:21.14100/872062df-acae-499b-aa0f-9eaca76...\n", + " variable_id: tas\n", + " variant_label: r1i1p1f1\n", + " version: v20190429\n", + " status: 2019-10-25;created;by nhn2@columbia.edu" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "multi_index = PangeoCMIP6(['tas', 'pr'], source_id='CanESM5', experiment_id='historical')\n", + "multi_index.retrieve('2000-01')" + ] + }, + { + "cell_type": "markdown", + "id": "a1000020", + "metadata": {}, + "source": [ + "Some variables exist on more than one grid. The accessor then raises an error asking for a `grid_label`, for example `grid_label='gn'` for the native model grid or `grid_label='gr'` for a regridded one.\n", + "\n", + "Scalar coordinates that differ between variables, such as `height` (2 m for `tas`, 10 m for `uas`), are dropped when the variables are combined." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "pet_nb_cpu", + "language": "python", + "name": "pet_nb_cpu" + }, + "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.12.15" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/packages/third_party/pangeo_site_archive/README.md b/packages/third_party/pangeo_site_archive/README.md new file mode 100644 index 00000000..4a6dd9bf --- /dev/null +++ b/packages/third_party/pangeo_site_archive/README.md @@ -0,0 +1,3 @@ +# PyEarthTools archive: Pangeo CMIP6 + +Accessor for the Pangeo analysis-ready, cloud-optimised (ARCO) CMIP6 data, hosted as Zarr stores on Google Cloud. diff --git a/packages/third_party/pangeo_site_archive/pyproject.toml b/packages/third_party/pangeo_site_archive/pyproject.toml new file mode 100644 index 00000000..86db42c9 --- /dev/null +++ b/packages/third_party/pangeo_site_archive/pyproject.toml @@ -0,0 +1,43 @@ +[build-system] +requires = ["setuptools>=61", "setuptools-scm>=8.0"] + +[project] +name = "PyEarthTools-archive-Pangeo" +description = "PyEarthTools archive for the Pangeo CMIP6 analysis-ready, cloud-optimised (ARCO) data" +requires-python = ">=3.11, <3.14" +keywords = ["pyearthtools", "cmip6", "pangeo", "zarr", "climate"] +classifiers = [ + "License :: OSI Approved :: Apache Software License", + "Operating System :: OS Independent", + "Programming Language :: Python :: 3.11", + "Programming Language :: Python :: 3.12", + "Programming Language :: Python :: 3.13", +] +dependencies = [ + "pyearthtools-data>=0.6.3", + "pandas", + "xarray", + "zarr", + "gcsfs", +] +dynamic = ["version", "readme"] + +[project.optional-dependencies] +dev = ["pytest>=7.0", "pytest-cov", "black==26.3.1", "ruff"] + +[tool.setuptools.packages.find] +where = ["src"] + +[tool.setuptools.dynamic] +readme = {file = ["README.md"], content-type = "text/markdown"} + +[project.urls] +homepage = "https://pyearthtools.readthedocs.io/en/latest/" +documentation = "https://pyearthtools.readthedocs.io/en/latest/" +repository = "https://github.com/ACCESS-Community-Hub/PyEarthTools" + +[tool.isort] +profile = "black" + +[tool.black] +line-length = 120 diff --git a/packages/third_party/pangeo_site_archive/src/site_archive_pangeo/__init__.py b/packages/third_party/pangeo_site_archive/src/site_archive_pangeo/__init__.py new file mode 100644 index 00000000..247cec44 --- /dev/null +++ b/packages/third_party/pangeo_site_archive/src/site_archive_pangeo/__init__.py @@ -0,0 +1,21 @@ +""" +Pangeo CMIP6 archive for PyEarthTools. + +| Name | Description | +| :--- | ----: | +| [PangeoCMIP6][site_archive_pangeo.PangeoCMIP6] | CMIP6 analysis-ready, cloud-optimised (ARCO) data | +""" + +from pyearthtools.data.archive import register_archive + +import site_archive_pangeo +from site_archive_pangeo.pangeo_cmip6 import PangeoCMIP6 + +register_archive("pangeo")(site_archive_pangeo) + +try: + from ._version import __version__ # type: ignore +except ImportError: + __version__ = "999" + +__all__ = ["PangeoCMIP6"] diff --git a/packages/third_party/pangeo_site_archive/src/site_archive_pangeo/pangeo_cmip6.py b/packages/third_party/pangeo_site_archive/src/site_archive_pangeo/pangeo_cmip6.py new file mode 100644 index 00000000..4675d9ce --- /dev/null +++ b/packages/third_party/pangeo_site_archive/src/site_archive_pangeo/pangeo_cmip6.py @@ -0,0 +1,213 @@ +""" +Pangeo CMIP6 accessor. + +Reads the Pangeo analysis-ready, cloud-optimised (ARCO) CMIP6 data, which is published as one Zarr store +per variable and described by a single catalog CSV. +""" + +import os +import warnings +from typing import Any, ClassVar + +import pandas +import pyearthtools.data +import xarray +from pyearthtools.data import Petdt +from pyearthtools.data.archive import register_archive +from pyearthtools.data.indexes import ArchiveIndex +from pyearthtools.data.transforms import Transform, TransformCollection + +DEFAULT_CATALOG = "https://storage.googleapis.com/cmip6/pangeo-cmip6.csv" + +_CATALOG_COLUMNS = [ + "source_id", + "experiment_id", + "member_id", + "table_id", + "variable_id", + "grid_label", + "zstore", + "version", +] + + +@register_archive( + "PangeoCMIP6", + sample_kwargs={"variables": ["tas"], "source_id": "CanESM5", "experiment_id": "historical"}, +) +class PangeoCMIP6(ArchiveIndex): + """ + Data accessor for the Pangeo CMIP6 analysis-ready, cloud-optimised (ARCO) data. + + A catalog CSV lists the Zarr store of every variable of every model run. This accessor selects one + model run (``source_id``, ``experiment_id``, ``member_id``, ``table_id``) and opens the store of each + requested variable lazily, so only the parts of the data that are used are downloaded. + + A store holds all times, so ``filesystem`` ignores the requested time and the time is selected after + loading. + + Examples: + >>> index = PangeoCMIP6(["tas"], source_id="CanESM5", experiment_id="historical") + >>> index.retrieve("2000-01") + """ + + _OPEN_ARGS: ClassVar[dict[str, Any]] = {"consolidated": True, "storage_options": {"token": "anon"}} + + def __init__( + self, + variables: list[str] | str, + *, + source_id: str, + experiment_id: str, + member_id: str = "r1i1p1f1", + table_id: str = "Amon", + grid_label: str | None = None, + catalog: str | os.PathLike = DEFAULT_CATALOG, + transforms: Transform | TransformCollection | None = None, + ): + """ + Set up the Pangeo CMIP6 accessor. + + The catalog is not read here, only when data is first requested. + + Args: + variables: Variables to retrieve, e.g. ``["tas", "pr"]``. + source_id: Model name, e.g. ``"CanESM5"``. + experiment_id: Experiment, e.g. ``"historical"`` or ``"ssp585"``. + member_id: Ensemble member. Defaults to ``"r1i1p1f1"``. + table_id: Frequency and realm table, e.g. ``"Amon"`` for monthly atmosphere. Defaults to ``"Amon"``. + grid_label: Grid, e.g. ``"gn"`` (native) or ``"gr"`` (regridded). Needed when a variable exists + on more than one grid. Defaults to None. + catalog: Location of the Pangeo catalog CSV, a URL or a local path. + transforms: Extra transforms to apply after loading. + + Raises: + ValueError: If no variables are given. + """ + self._variables = [variables] if isinstance(variables, str) else list(variables) + if not self._variables: + raise ValueError("At least one variable is required.") + + self._query = { + "source_id": source_id, + "experiment_id": experiment_id, + "member_id": member_id, + "table_id": table_id, + } + self._grid_label = grid_label + self._catalog_src = catalog + self._catalog = None # read lazily, see _load_catalog + + extra_transforms = TransformCollection() if transforms is None else TransformCollection(transforms) + super().__init__( + transforms=TransformCollection([pyearthtools.data.transforms.variables.Trim(self._variables)]) + + extra_transforms, + ) + self.record_initialisation() + + def _load_catalog(self) -> pandas.DataFrame: + """Read the catalog once, keeping only the rows of the requested variables and model run.""" + if self._catalog is None: + catalog = self.catalog(self._catalog_src) + catalog = catalog[catalog["variable_id"].isin(self._variables)] + for column, value in self._query.items(): + catalog = catalog[catalog[column] == value] + self._catalog = catalog.reset_index(drop=True) + return self._catalog + + def filesystem(self, querytime: str | Petdt) -> dict[str, str]: + """ + Find the Zarr store of each variable. + + Args: + querytime: Ignored, as a store holds all times. + + Raises: + ValueError: If a variable has no store, exists on several grids and no ``grid_label`` was given, + or has several stores at its latest version. + + Returns: + Store URL of each variable, using the latest version in the catalog. + """ + catalog = self._load_catalog() + stores = {} + for variable in self._variables: + rows = catalog[catalog["variable_id"] == variable] + if self._grid_label is not None: + rows = rows[rows["grid_label"] == self._grid_label] + if rows.empty: + raise ValueError(f"No Pangeo CMIP6 store for variable {variable!r} matching {self._query}") + grids = sorted(rows["grid_label"].unique()) + if len(grids) > 1: + raise ValueError( + f"Variable {variable!r} exists on several grids {grids}; pass grid_label to choose one." + ) + latest = rows[rows["version"] == rows["version"].max()] + urls = sorted(latest["zstore"].unique()) + if len(urls) > 1: + raise ValueError( + f"Variable {variable!r} has several stores at the latest version {urls}; the run is ambiguous." + ) + stores[variable] = str(urls[0]) + return stores + + def load(self, files: dict[str, str], **kwargs) -> xarray.Dataset: + """ + Open the store of each variable lazily, keep only that variable, and merge them. + + Args: + files: Store URL of each variable, as found by ``filesystem``. + **kwargs: Passed to ``xarray.open_zarr``. + + Returns: + Dataset holding all times of all the variables. Scalar coordinates that differ between the variables + are dropped, e.g. ``height``, which is 2 m for ``tas`` but 10 m for ``uas``. + """ + open_args = {**self._OPEN_ARGS, **kwargs} + datasets = [xarray.open_zarr(url, **open_args)[[variable]] for variable, url in files.items()] + return xarray.merge(datasets, join="exact", compat="minimal") + + def retrieve(self, querytime: str | Petdt, *args, **kwargs) -> xarray.Dataset: + """ + Retrieve the data at ``querytime``. + + Raises: + DataNotFoundError: If the store holds no data at ``querytime``. Without this, the parent class + only warns and returns every time of the store. + """ + with warnings.catch_warnings(record=True) as caught: + warnings.simplefilter("always") + data = super().retrieve(querytime, *args, **kwargs) + for warning in caught: + if "Could not find time in dataset" in str(warning.message): + raise pyearthtools.data.DataNotFoundError(f"No data found at {querytime}.") + warnings.warn_explicit(warning.message, warning.category, warning.filename, warning.lineno) + return data + + @staticmethod + def catalog(catalog: str | os.PathLike = DEFAULT_CATALOG) -> pandas.DataFrame: + """Return the Pangeo CMIP6 catalogue, so the available data can be discovered. + + Args: + catalog: CSV catalogue to read. Defaults to the public Pangeo CMIP6 catalogue. + + Returns: + DataFrame with one row per variable of one model run, with the columns `source_id`, + `experiment_id`, `member_id`, `table_id`, `variable_id`, `grid_label`, `zstore` and `version`. + """ + return pandas.read_csv(catalog, usecols=_CATALOG_COLUMNS) + + def exists(self, *args, **kwargs) -> bool: + """Whether a store is found for every variable. Stores are URLs, so they are not checked on disk.""" + try: + self.search(*args) + except ValueError: + return False + return True + + @property + def _desc_(self): + return { + "singleline": "Pangeo CMIP6 analysis-ready, cloud-optimised data accessor", + "Documentation": "https://pangeo-data.github.io/pangeo-cmip6-cloud/accessing_data.html", + } diff --git a/packages/third_party/pangeo_site_archive/tests/data/mini_catalog.csv b/packages/third_party/pangeo_site_archive/tests/data/mini_catalog.csv new file mode 100644 index 00000000..6ca0c6c0 --- /dev/null +++ b/packages/third_party/pangeo_site_archive/tests/data/mini_catalog.csv @@ -0,0 +1,10 @@ +activity_id,institution_id,source_id,experiment_id,member_id,table_id,variable_id,grid_label,zstore,dcpp_init_year,version +CMIP,TEST-INST,TEST-MODEL,historical,r1i1p1f1,Amon,tas,gn,gs://test-bucket/tas/gn/v20190101/,,20190101 +CMIP,TEST-INST,TEST-MODEL,historical,r1i1p1f1,Amon,tas,gn,gs://test-bucket/tas/gn/v20200101/,,20200101 +CMIP,TEST-INST,TEST-MODEL,historical,r1i1p1f1,Amon,pr,gn,gs://test-bucket/pr/gn/v20190101/,,20190101 +CMIP,TEST-INST,TEST-MODEL,historical,r1i1p1f1,Amon,psl,gn,gs://test-bucket/psl/gn/v20190101/,,20190101 +CMIP,TEST-INST,TEST-MODEL,historical,r1i1p1f1,Amon,psl,gr,gs://test-bucket/psl/gr/v20190101/,,20190101 +ScenarioMIP,TEST-INST,TEST-MODEL,ssp585,r1i1p1f1,Amon,tas,gn,gs://test-bucket/ssp/tas/gn/v20190101/,,20190101 +CMIP,TEST-INST,TEST-MODEL,historical,r1i1p1f1,Amon,uas,gn,gs://test-bucket/uas/gn/v20190101/,,20190101 +DCPP,TEST-INST,AMBIG-MODEL,dcppA-hindcast,r1i1p1f1,Amon,tas,gn,gs://test-bucket/ambig/tas/gn/init1960/,1960,20190101 +DCPP,TEST-INST,AMBIG-MODEL,dcppA-hindcast,r1i1p1f1,Amon,tas,gn,gs://test-bucket/ambig/tas/gn/init1961/,1961,20190101 diff --git a/packages/third_party/pangeo_site_archive/tests/test_pangeo_cmip6.py b/packages/third_party/pangeo_site_archive/tests/test_pangeo_cmip6.py new file mode 100644 index 00000000..d76773f2 --- /dev/null +++ b/packages/third_party/pangeo_site_archive/tests/test_pangeo_cmip6.py @@ -0,0 +1,177 @@ +import pathlib + +import pandas +import pyearthtools.data +import pytest +import site_archive_pangeo +import xarray +from pyearthtools.data import Petdt +from site_archive_pangeo import PangeoCMIP6 + +CATALOG = str(pathlib.Path(__file__).parent / "data" / "mini_catalog.csv") +TIME = Petdt("2000-02") +TAS_URL = "gs://test-bucket/tas/gn/v20200101/" +PR_URL = "gs://test-bucket/pr/gn/v20190101/" + + +def _index(variables, **kwargs): + kwargs = {"source_id": "TEST-MODEL", "experiment_id": "historical", **kwargs} + return PangeoCMIP6(variables, catalog=CATALOG, **kwargs) + + +def _fake_open_zarr(seen): + """Stand-in for xarray.open_zarr, returning a tiny dataset for each store URL.""" + times = pandas.date_range("2000-01-01", periods=3, freq="MS") + + def fake(url, **kwargs): + seen[url] = kwargs + name = url.rstrip("/").split("/")[-3] + return xarray.Dataset( + {name: ("time", [1.0, 2.0, 3.0]), "time_bnds": ("time", [0.0, 0.0, 0.0])}, + coords={"time": times}, + ) + + return fake + + +def test_registered_in_archive(): + assert pyearthtools.data.archive.PangeoCMIP6 is PangeoCMIP6 + assert pyearthtools.data.archive.pangeo is site_archive_pangeo + + +def test_sample_construction_needs_no_network(monkeypatch): + def no_network(*args, **kwargs): + raise AssertionError("the catalog must not be read at construction") + + monkeypatch.setattr(pandas, "read_csv", no_network) + assert isinstance(PangeoCMIP6.sample(), PangeoCMIP6) + + +def test_description(): + assert "Documentation" in _index(["tas"])._desc_ + + +def test_filesystem_picks_latest_version(): + assert _index(["tas", "pr"]).filesystem(TIME) == {"tas": TAS_URL, "pr": PR_URL} + + +def test_single_variable_as_string(): + assert _index("pr").filesystem(TIME) == {"pr": PR_URL} + + +def test_experiment_is_filtered(): + stores = _index(["tas"], experiment_id="ssp585").filesystem(TIME) + assert stores == {"tas": "gs://test-bucket/ssp/tas/gn/v20190101/"} + + +def test_catalog_is_read_once(monkeypatch): + calls = [] + real_read_csv = pandas.read_csv + + def counting_read_csv(*args, **kwargs): + calls.append(args) + return real_read_csv(*args, **kwargs) + + monkeypatch.setattr(pandas, "read_csv", counting_read_csv) + index = _index(["tas"]) + index.filesystem(TIME) + index.filesystem(TIME) + assert len(calls) == 1 + + +def test_no_variables_rejected(): + with pytest.raises(ValueError, match="variable"): + _index([]) + + +def test_unknown_variable_raises(): + with pytest.raises(ValueError, match="nonsense"): + _index(["nonsense"]).filesystem(TIME) + + +def test_several_grids_need_a_grid_label(): + with pytest.raises(ValueError, match="grid_label"): + _index(["psl"]).filesystem(TIME) + assert _index(["psl"], grid_label="gr").filesystem(TIME) == {"psl": "gs://test-bucket/psl/gr/v20190101/"} + with pytest.raises(ValueError, match="psl"): + _index(["psl"], grid_label="xx").filesystem(TIME) + + +def test_exists_does_not_check_the_disk(): + assert _index(["tas"]).exists(TIME) is True + assert _index(["nonsense"]).exists(TIME) is False + + +def test_get_wraps_lookup_errors(): + with pytest.raises(pyearthtools.data.DataNotFoundError): + _index(["nonsense"]).get(TIME) + + +def test_load_merges_one_store_per_variable(monkeypatch): + seen = {} + monkeypatch.setattr(xarray, "open_zarr", _fake_open_zarr(seen)) + index = _index(["tas", "pr"]) + + dataset = index.load(index.filesystem(TIME), chunks={}) + + assert set(dataset.data_vars) == {"tas", "pr"} + assert set(seen) == {TAS_URL, PR_URL} + for kwargs in seen.values(): + assert kwargs["consolidated"] is True + assert kwargs["storage_options"] == {"token": "anon"} + assert kwargs["chunks"] == {} + + +def test_retrieve_selects_time_and_keeps_requested_variables(monkeypatch): + monkeypatch.setattr(xarray, "open_zarr", _fake_open_zarr({})) + + dataset = _index(["tas"]).retrieve("2000-02") + + assert list(dataset.data_vars) == ["tas"] + assert dataset["tas"].values.tolist() == [2.0] + + +def test_load_drops_conflicting_scalar_coordinates(monkeypatch): + """tas (2 m) and uas (10 m) carry different scalar height coordinates, which must not stop the merge.""" + heights = {"tas": 2.0, "uas": 10.0} + times = pandas.date_range("2000-01-01", periods=3, freq="MS") + + def fake(url, **kwargs): + name = url.rstrip("/").split("/")[-3] + return xarray.Dataset({name: ("time", [1.0, 2.0, 3.0])}, coords={"time": times, "height": heights[name]}) + + monkeypatch.setattr(xarray, "open_zarr", fake) + index = _index(["tas", "uas"]) + + dataset = index.load(index.filesystem(TIME)) + + assert set(dataset.data_vars) == {"tas", "uas"} + assert "height" not in dataset.coords + + +def test_catalog_lists_available_data(): + catalog = PangeoCMIP6.catalog(CATALOG) + + assert isinstance(catalog, pandas.DataFrame) + assert {"source_id", "experiment_id", "variable_id", "zstore"} <= set(catalog.columns) + assert set(catalog["variable_id"]) == {"tas", "pr", "psl", "uas"} + assert len(catalog) == 9 + + +def test_ambiguous_runs_at_latest_version_are_rejected(): + index = _index(["tas"], source_id="AMBIG-MODEL", experiment_id="dcppA-hindcast") + with pytest.raises(ValueError, match="several stores"): + index.filesystem(TIME) + + +def test_ambiguous_runs_at_latest_version_are_rejected(): + index = _index(["tas"], source_id="AMBIG-MODEL", experiment_id="dcppA-hindcast") + with pytest.raises(ValueError, match="several stores"): + index.filesystem(TIME) + + +def test_retrieve_outside_the_store_times_raises(monkeypatch): + monkeypatch.setattr(xarray, "open_zarr", _fake_open_zarr({})) + + with pytest.raises(pyearthtools.data.DataNotFoundError): + _index(["tas"]).retrieve("1990-01") diff --git a/requirements_cicd.txt b/requirements_cicd.txt index 1d7fc87e..256afc17 100644 --- a/requirements_cicd.txt +++ b/requirements_cicd.txt @@ -5,4 +5,5 @@ -e packages/tutorial -e packages/zoo -e packages/bundled_models/fourcastnext +-e packages/third_party/pangeo_site_archive -e .[test]