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/.gitignore b/.gitignore index 36ff0471..79a0b424 100644 --- a/.gitignore +++ b/.gitignore @@ -180,3 +180,4 @@ src/mypy.txt .ruff_cache/ temp_dir/ +docs/notebooks/data/pangeo_cmip6_training/ 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..541f5506 100644 --- a/docs/notebooks/Gallery.ipynb +++ b/docs/notebooks/Gallery.ipynb @@ -176,7 +176,9 @@ "| 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", + "| Pangeo CMIP6 ML | Demonstrates training a small model on CMIP6 climate model data from the Pangeo cloud archive | [Pangeo CMIP6 ML](./data/Pangeo_CMIP6_ML.ipynb) | 25 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..045a5bb0 --- /dev/null +++ b/docs/notebooks/data/Pangeo_CMIP6.ipynb @@ -0,0 +1,4471 @@ +{ + "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-25T05:32:06.657022Z", + "iopub.status.busy": "2026-10-25T05:32:06.656772Z", + "iopub.status.idle": "2026-10-25T05:32:09.350626Z", + "shell.execute_reply": "2026-10-25T05:32:09.349596Z" + } + }, + "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-25T05:32:09.353650Z", + "iopub.status.busy": "2026-10-25T05:32:09.353295Z", + "iopub.status.idle": "2026-10-25T05:32:20.578980Z", + "shell.execute_reply": "2026-10-25T05:32:20.578009Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
| \n", + " | source_id | \n", + "experiment_id | \n", + "member_id | \n", + "table_id | \n", + "variable_id | \n", + "grid_label | \n", + "zstore | \n", + "version | \n", + "
|---|---|---|---|---|---|---|---|---|
| 0 | \n", + "CMCC-CM2-HR4 | \n", + "highresSST-present | \n", + "r1i1p1f1 | \n", + "Amon | \n", + "ps | \n", + "gn | \n", + "gs://cmip6/CMIP6/HighResMIP/CMCC/CMCC-CM2-HR4/... | \n", + "20170706 | \n", + "
| 1 | \n", + "CMCC-CM2-HR4 | \n", + "highresSST-present | \n", + "r1i1p1f1 | \n", + "Amon | \n", + "rsds | \n", + "gn | \n", + "gs://cmip6/CMIP6/HighResMIP/CMCC/CMCC-CM2-HR4/... | \n", + "20170706 | \n", + "
| 2 | \n", + "CMCC-CM2-HR4 | \n", + "highresSST-present | \n", + "r1i1p1f1 | \n", + "Amon | \n", + "rlus | \n", + "gn | \n", + "gs://cmip6/CMIP6/HighResMIP/CMCC/CMCC-CM2-HR4/... | \n", + "20170706 | \n", + "
| 3 | \n", + "CMCC-CM2-HR4 | \n", + "highresSST-present | \n", + "r1i1p1f1 | \n", + "Amon | \n", + "rlds | \n", + "gn | \n", + "gs://cmip6/CMIP6/HighResMIP/CMCC/CMCC-CM2-HR4/... | \n", + "20170706 | \n", + "
| 4 | \n", + "CMCC-CM2-HR4 | \n", + "highresSST-present | \n", + "r1i1p1f1 | \n", + "Amon | \n", + "psl | \n", + "gn | \n", + "gs://cmip6/CMIP6/HighResMIP/CMCC/CMCC-CM2-HR4/... | \n", + "20170706 | \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']"}<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
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 0x000002B48667C180>'}, 'var_units': {'tas': "'degC'"}}}<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
<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
<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", + " tas (time, latitude, longitude) float32 33kB dask.array<chunksize=(1, 64, 128), meta=np.ndarray>\n", + " pr (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
┏━━━┳━━━━━━┳━━━━━━━━━━━━┳━━━━━━━━┳━━━━━━━┳━━━━━━━┓\n", + "┃ ┃ Name ┃ Type ┃ Params ┃ Mode ┃ FLOPs ┃\n", + "┡━━━╇━━━━━━╇━━━━━━━━━━━━╇━━━━━━━━╇━━━━━━━╇━━━━━━━┩\n", + "│ 0 │ cnn │ Sequential │ 2.6 K │ train │ 0 │\n", + "└───┴──────┴────────────┴────────┴───────┴───────┘\n", + "\n" + ], + "text/plain": [ + "┏━━━┳━━━━━━┳━━━━━━━━━━━━┳━━━━━━━━┳━━━━━━━┳━━━━━━━┓\n", + "┃\u001b[1;35m \u001b[0m\u001b[1;35m \u001b[0m\u001b[1;35m \u001b[0m┃\u001b[1;35m \u001b[0m\u001b[1;35mName\u001b[0m\u001b[1;35m \u001b[0m┃\u001b[1;35m \u001b[0m\u001b[1;35mType \u001b[0m\u001b[1;35m \u001b[0m┃\u001b[1;35m \u001b[0m\u001b[1;35mParams\u001b[0m\u001b[1;35m \u001b[0m┃\u001b[1;35m \u001b[0m\u001b[1;35mMode \u001b[0m\u001b[1;35m \u001b[0m┃\u001b[1;35m \u001b[0m\u001b[1;35mFLOPs\u001b[0m\u001b[1;35m \u001b[0m┃\n", + "┡━━━╇━━━━━━╇━━━━━━━━━━━━╇━━━━━━━━╇━━━━━━━╇━━━━━━━┩\n", + "│\u001b[2m \u001b[0m\u001b[2m0\u001b[0m\u001b[2m \u001b[0m│ cnn │ Sequential │ 2.6 K │ train │ 0 │\n", + "└───┴──────┴────────────┴────────┴───────┴───────┘\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
Trainable params: 2.6 K \n", + "Non-trainable params: 0 \n", + "Total params: 2.6 K \n", + "Total estimated model params size (MB): 0.010 \n", + "Modules in train mode: 6 \n", + "Modules in eval mode: 0 \n", + "Total FLOPs: 0 \n", + "\n" + ], + "text/plain": [ + "\u001b[1mTrainable params\u001b[0m: 2.6 K \n", + "\u001b[1mNon-trainable params\u001b[0m: 0 \n", + "\u001b[1mTotal params\u001b[0m: 2.6 K \n", + "\u001b[1mTotal estimated model params size (MB)\u001b[0m: 0.010 \n", + "\u001b[1mModules in train mode\u001b[0m: 6 \n", + "\u001b[1mModules in eval mode\u001b[0m: 0 \n", + "\u001b[1mTotal FLOPs\u001b[0m: 0 \n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "cb0a5d2398ae4aba9b0e845565e38e4a", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Output()" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
D:\\lab\\venvs\\pet284\\Lib\\site-packages\\lightning\\pytorch\\trainer\\connectors\\data_connector.py:434: The \n", + "'val_dataloader' does not have many workers which may be a bottleneck. Consider increasing the value of the \n", + "`num_workers` argument` to `num_workers=3` in the `DataLoader` to improve performance.\n", + "\n" + ], + "text/plain": [ + "D:\\lab\\venvs\\pet284\\Lib\\site-packages\\lightning\\pytorch\\trainer\\connectors\\data_connector.py:434: The \n", + "'val_dataloader' does not have many workers which may be a bottleneck. Consider increasing the value of the \n", + "`num_workers` argument` to `num_workers=3` in the `DataLoader` to improve performance.\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
D:\\lab\\venvs\\pet284\\Lib\\site-packages\\lightning\\pytorch\\utilities\\_pytree.py:21: `isinstance(treespec, LeafSpec)` \n", + "is deprecated, use `isinstance(treespec, TreeSpec) and treespec.is_leaf()` instead.\n", + "\n" + ], + "text/plain": [ + "D:\\lab\\venvs\\pet284\\Lib\\site-packages\\lightning\\pytorch\\utilities\\_pytree.py:21: `isinstance(treespec, LeafSpec)` \n", + "is deprecated, use `isinstance(treespec, TreeSpec) and treespec.is_leaf()` instead.\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
D:\\lab\\venvs\\pet284\\Lib\\site-packages\\lightning\\pytorch\\trainer\\connectors\\data_connector.py:434: The \n", + "'train_dataloader' does not have many workers which may be a bottleneck. Consider increasing the value of the \n", + "`num_workers` argument` to `num_workers=3` in the `DataLoader` to improve performance.\n", + "\n" + ], + "text/plain": [ + "D:\\lab\\venvs\\pet284\\Lib\\site-packages\\lightning\\pytorch\\trainer\\connectors\\data_connector.py:434: The \n", + "'train_dataloader' does not have many workers which may be a bottleneck. Consider increasing the value of the \n", + "`num_workers` argument` to `num_workers=3` in the `DataLoader` to improve performance.\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
D:\\lab\\venvs\\pet284\\Lib\\site-packages\\lightning\\pytorch\\loops\\fit_loop.py:321: The number of training batches (15) \n", + "is smaller than the logging interval Trainer(log_every_n_steps=50). Set a lower value for log_every_n_steps if you \n", + "want to see logs for the training epoch.\n", + "\n" + ], + "text/plain": [ + "D:\\lab\\venvs\\pet284\\Lib\\site-packages\\lightning\\pytorch\\loops\\fit_loop.py:321: The number of training batches (15) \n", + "is smaller than the logging interval Trainer(log_every_n_steps=50). Set a lower value for log_every_n_steps if you \n", + "want to see logs for the training epoch.\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "`Trainer.fit` stopped: `max_epochs=3` reached.\n" + ] + }, + { + "data": { + "text/html": [ + "\n" + ], + "text/plain": [] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "data_module = pyearthtools.training.data.lightning.PipelineLightningDataModule(\n", + " data_preparation,\n", + " train_split=train_split,\n", + " valid_split=val_split,\n", + " batch_size=batch_size,\n", + " num_workers=0,\n", + ")\n", + "\n", + "trainer = pyearthtools.training.lightning.Train(\n", + " model,\n", + " data_module,\n", + " workdir,\n", + " max_epochs=max_epochs,\n", + " callbacks=[RichProgressBar(refresh_rate=10)],\n", + ")\n", + "trainer.fit(load=False)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Prediction\n", + "\n", + "The trained model predicts the month after the first validation month. Values are converted back to degrees Celsius for plotting. With so little training the prediction is rough, which is expected." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "execution": { + "iopub.execute_input": "2026-10-25T06:08:05.100760Z", + "iopub.status.busy": "2026-10-25T06:08:05.100324Z", + "iopub.status.idle": "2026-10-25T06:08:06.246618Z", + "shell.execute_reply": "2026-10-25T06:08:06.245417Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
Epoch 2/2 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 15/15 0:00:01 • 0:00:00 10.58it/s v_num: 0.000\n\n", + "text/plain": "Epoch 2/2 \u001b[38;2;98;6;224m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m 15/15 \u001b[2m0:00:01 • 0:00:00\u001b[0m \u001b[2;4m10.58it/s\u001b[0m \u001b[3mv_num: 0.000\u001b[0m\n" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "tabbable": null, + "tooltip": null + } + } + }, + "version_major": 2, + "version_minor": 0 + } + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} 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..e0e9015a --- /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, querytime: str | Petdt) -> bool: + """Whether a store is found for every variable. Stores are URLs, so they are not checked on disk.""" + try: + self.search(querytime) + 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..962dc0ba --- /dev/null +++ b/packages/third_party/pangeo_site_archive/tests/test_pangeo_cmip6.py @@ -0,0 +1,182 @@ +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_exists_accepts_querytime_keyword(): + assert _index(["tas"]).exists(querytime=TIME) is True + assert _index(["nonsense"]).exists(querytime=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]