From 4a01ef39e166be2a2706e81289a2da5a125ee540 Mon Sep 17 00:00:00 2001 From: "MD. Mohiuddin Ahmed" Date: Mon, 5 Oct 2026 01:31:15 +0600 Subject: [PATCH 1/5] Add Pangeo CMIP6 ArchiveIndex accessor Adds packages/third_party/pangeo_site_archive with PangeoCMIP6, an ArchiveIndex that reads CMIP6 variables from the Pangeo ARCO cloud archive, plus offline unit tests, CI install/coverage entries and a docs section. Closes #284. Co-Authored-By: Claude Sonnet 5.5 Claude-Session: https://claude.ai/code/session_01Unqqtp91DWVC8ro9Y724iN --- .github/workflows/python-app.yml | 2 +- docs/data.md | 14 ++ .../third_party/pangeo_site_archive/README.md | 3 + .../pangeo_site_archive/pyproject.toml | 43 +++++ .../src/site_archive_pangeo/__init__.py | 21 +++ .../src/site_archive_pangeo/pangeo_cmip6.py | 175 ++++++++++++++++++ .../tests/data/mini_catalog.csv | 8 + .../tests/test_pangeo_cmip6.py | 149 +++++++++++++++ requirements_cicd.txt | 1 + 9 files changed, 415 insertions(+), 1 deletion(-) create mode 100644 packages/third_party/pangeo_site_archive/README.md create mode 100644 packages/third_party/pangeo_site_archive/pyproject.toml create mode 100644 packages/third_party/pangeo_site_archive/src/site_archive_pangeo/__init__.py create mode 100644 packages/third_party/pangeo_site_archive/src/site_archive_pangeo/pangeo_cmip6.py create mode 100644 packages/third_party/pangeo_site_archive/tests/data/mini_catalog.csv create mode 100644 packages/third_party/pangeo_site_archive/tests/test_pangeo_cmip6.py 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/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..f8a32efd --- /dev/null +++ b/packages/third_party/pangeo_site_archive/src/site_archive_pangeo/pangeo_cmip6.py @@ -0,0 +1,175 @@ +""" +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 +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 = pandas.read_csv(self._catalog_src, usecols=_CATALOG_COLUMNS) + 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, or exists on several grids and no ``grid_label`` was given. + + 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." + ) + stores[variable] = str(rows.sort_values("version").iloc[-1]["zstore"]) + 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 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..5a3fa5c2 --- /dev/null +++ b/packages/third_party/pangeo_site_archive/tests/data/mini_catalog.csv @@ -0,0 +1,8 @@ +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 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..1adcbab4 --- /dev/null +++ b/packages/third_party/pangeo_site_archive/tests/test_pangeo_cmip6.py @@ -0,0 +1,149 @@ +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 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] From 5ae0b9651a59cec4f9e90a05e8d2292ba10a5a36 Mon Sep 17 00:00:00 2001 From: "MD. Mohiuddin Ahmed" Date: Sat, 10 Oct 2026 03:02:21 +0600 Subject: [PATCH 2/5] Add PangeoCMIP6.catalog() static method Returns the Pangeo CMIP6 catalogue as a pandas.DataFrame so users can discover available data. Includes a unit test. --- .../src/site_archive_pangeo/pangeo_cmip6.py | 15 ++++++++++++++- .../tests/test_pangeo_cmip6.py | 9 +++++++++ 2 files changed, 23 insertions(+), 1 deletion(-) 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 index f8a32efd..94719e62 100644 --- 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 @@ -107,7 +107,7 @@ def __init__( 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 = pandas.read_csv(self._catalog_src, usecols=_CATALOG_COLUMNS) + 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] @@ -159,6 +159,19 @@ def load(self, files: dict[str, str], **kwargs) -> xarray.Dataset: datasets = [xarray.open_zarr(url, **open_args)[[variable]] for variable, url in files.items()] return xarray.merge(datasets, join="exact", compat="minimal") + @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: 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 index 1adcbab4..e53dac58 100644 --- a/packages/third_party/pangeo_site_archive/tests/test_pangeo_cmip6.py +++ b/packages/third_party/pangeo_site_archive/tests/test_pangeo_cmip6.py @@ -147,3 +147,12 @@ def fake(url, **kwargs): 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) == 7 From 8eff7520af5007bc4d0040e48a1e4e8063b7f358 Mon Sep 17 00:00:00 2001 From: "MD. Mohiuddin Ahmed" Date: Sun, 11 Oct 2026 00:42:53 +0600 Subject: [PATCH 3/5] Add `PangeoCMIP6` demo notebook Demonstrate catalogue discovery, lazy `retrieve`, global map, annual global mean and multiple variables with `PangeoCMIP6`, derived from `ArchiveIndex`. Link notebook from `Gallery.ipynb`. Refs #285 --- docs/notebooks/Gallery.ipynb | 3 +- docs/notebooks/data/Pangeo_CMIP6.ipynb | 2422 ++++++++++++++++++++++++ 2 files changed, 2424 insertions(+), 1 deletion(-) create mode 100644 docs/notebooks/data/Pangeo_CMIP6.ipynb diff --git a/docs/notebooks/Gallery.ipynb b/docs/notebooks/Gallery.ipynb index f56b6e2a..9415d1c2 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 | Demontsrates 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..72684cf1 --- /dev/null +++ b/docs/notebooks/data/Pangeo_CMIP6.ipynb @@ -0,0 +1,2422 @@ +{ + "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-10T18:24:10.205951Z", + "iopub.status.busy": "2026-10-10T18:24:10.205951Z", + "iopub.status.idle": "2026-10-10T18:24:13.987172Z", + "shell.execute_reply": "2026-10-10T18:24:13.986145Z" + } + }, + "outputs": [], + "source": [ + "import matplotlib.pyplot\n", + "import cartopy.crs\n", + "import numpy\n", + "\n", + "import pyearthtools.data\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-10T18:24:13.991318Z", + "iopub.status.busy": "2026-10-10T18:24:13.991318Z", + "iopub.status.idle": "2026-10-10T18:24:50.434078Z", + "shell.execute_reply": "2026-10-10T18:24:50.433034Z" + } + }, + "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-10T18:24:50.438084Z", + "iopub.status.busy": "2026-10-10T18:24:50.437084Z", + "iopub.status.idle": "2026-10-10T18:24:50.473522Z", + "shell.execute_reply": "2026-10-10T18:24:50.472424Z" + } + }, + "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-10T18:24:50.477528Z", + "iopub.status.busy": "2026-10-10T18:24:50.477528Z", + "iopub.status.idle": "2026-10-10T18:24:50.492819Z", + "shell.execute_reply": "2026-10-10T18:24:50.491691Z" + } + }, + "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-10T18:24:50.496824Z", + "iopub.status.busy": "2026-10-10T18:24:50.496824Z", + "iopub.status.idle": "2026-10-10T18:25:32.519026Z", + "shell.execute_reply": "2026-10-10T18:25:32.517018Z" + } + }, + "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": [ + "## Visualise the data\n", + "\n", + "Plot the near-surface air temperature of January 2000 on a map. CMIP6 temperatures are in kelvin, so we convert to degrees Celsius. The model longitudes run from 0 to 360, so the map is centred on 180 degrees." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "a1000013", + "metadata": { + "execution": { + "iopub.execute_input": "2026-10-10T18:25:32.523233Z", + "iopub.status.busy": "2026-10-10T18:25:32.522232Z", + "iopub.status.idle": "2026-10-10T18:25:35.418947Z", + "shell.execute_reply": "2026-10-10T18:25:35.417935Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "temperature = data['tas'].squeeze() - 273.15\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': 'Near-surface air temperature (degrees C)'},\n", + ")\n", + "ax.coastlines()\n", + "ax.set_title('CanESM5 historical, January 2000');" + ] + }, + { + "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": 7, + "id": "a1000015", + "metadata": { + "execution": { + "iopub.execute_input": "2026-10-10T18:25:35.423219Z", + "iopub.status.busy": "2026-10-10T18:25:35.423219Z", + "iopub.status.idle": "2026-10-10T18:25:35.432298Z", + "shell.execute_reply": "2026-10-10T18:25:35.431287Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "{'tas': 'gs://cmip6/CMIP6/CMIP/CCCma/CanESM5/historical/r1i1p1f1/Amon/tas/gn/v20190429/'}" + ] + }, + "execution_count": 7, + "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 use it to plot the area-weighted global mean temperature of the whole historical run, averaged over each year. Only the `tas` data is downloaded, which takes a short while." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "a1000017", + "metadata": { + "execution": { + "iopub.execute_input": "2026-10-10T18:25:35.436415Z", + "iopub.status.busy": "2026-10-10T18:25:35.435418Z", + "iopub.status.idle": "2026-10-10T18:25:55.616436Z", + "shell.execute_reply": "2026-10-10T18:25:55.615426Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "full = 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')) - 273.15\n", + "\n", + "annual_mean = global_mean.groupby('time.year').mean().drop_vars('height', errors='ignore')\n", + "annual_mean.plot()\n", + "matplotlib.pyplot.ylabel('Global mean near-surface air temperature (degrees C)');" + ] + }, + { + "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": 9, + "id": "a1000019", + "metadata": { + "execution": { + "iopub.execute_input": "2026-10-10T18:25:55.620441Z", + "iopub.status.busy": "2026-10-10T18:25:55.620441Z", + "iopub.status.idle": "2026-10-10T18:26:37.364115Z", + "shell.execute_reply": "2026-10-10T18:26:37.363100Z" + } + }, + "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",
+       "    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
" + ], + "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", + " tas (time, latitude, longitude) float32 33kB dask.array\n", + " pr (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": 9, + "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 +} From cdbc2ac6ea4b06adfe905953c45d0261be496fc9 Mon Sep 17 00:00:00 2001 From: "MD. Mohiuddin Ahmed" Date: Wed, 14 Oct 2026 00:43:51 +0600 Subject: [PATCH 4/5] Use ConvertUnits transform and pipeline in Pangeo CMIP6 demo --- docs/notebooks/Gallery.ipynb | 2 +- docs/notebooks/data/Pangeo_CMIP6.ipynb | 2190 +++++++++++++++++++++++- 2 files changed, 2113 insertions(+), 79 deletions(-) diff --git a/docs/notebooks/Gallery.ipynb b/docs/notebooks/Gallery.ipynb index 9415d1c2..4f706bd5 100644 --- a/docs/notebooks/Gallery.ipynb +++ b/docs/notebooks/Gallery.ipynb @@ -176,7 +176,7 @@ "| 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 index 72684cf1..96153724 100644 --- a/docs/notebooks/data/Pangeo_CMIP6.ipynb +++ b/docs/notebooks/data/Pangeo_CMIP6.ipynb @@ -28,10 +28,10 @@ "id": "a1000003", "metadata": { "execution": { - "iopub.execute_input": "2026-10-10T18:24:10.205951Z", - "iopub.status.busy": "2026-10-10T18:24:10.205951Z", - "iopub.status.idle": "2026-10-10T18:24:13.987172Z", - "shell.execute_reply": "2026-10-10T18:24:13.986145Z" + "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": [], @@ -41,6 +41,8 @@ "import numpy\n", "\n", "import pyearthtools.data\n", + "import pyearthtools.data.transforms.coordinates\n", + "import pyearthtools.pipeline\n", "from site_archive_pangeo import PangeoCMIP6" ] }, @@ -60,10 +62,10 @@ "id": "a1000005", "metadata": { "execution": { - "iopub.execute_input": "2026-10-10T18:24:13.991318Z", - "iopub.status.busy": "2026-10-10T18:24:13.991318Z", - "iopub.status.idle": "2026-10-10T18:24:50.434078Z", - "shell.execute_reply": "2026-10-10T18:24:50.433034Z" + "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": [ @@ -198,10 +200,10 @@ "id": "a1000007", "metadata": { "execution": { - "iopub.execute_input": "2026-10-10T18:24:50.438084Z", - "iopub.status.busy": "2026-10-10T18:24:50.437084Z", - "iopub.status.idle": "2026-10-10T18:24:50.473522Z", - "shell.execute_reply": "2026-10-10T18:24:50.472424Z" + "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": [ @@ -250,10 +252,10 @@ "id": "a1000009", "metadata": { "execution": { - "iopub.execute_input": "2026-10-10T18:24:50.477528Z", - "iopub.status.busy": "2026-10-10T18:24:50.477528Z", - "iopub.status.idle": "2026-10-10T18:24:50.492819Z", - "shell.execute_reply": "2026-10-10T18:24:50.491691Z" + "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": [ @@ -658,7 +660,7 @@ "\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']"}" + "\t\t Trim {'__args': '()', 'variables': "['tas']"}" ], "text/plain": [ "PangeoCMIP6\n", @@ -705,10 +707,10 @@ "id": "a1000011", "metadata": { "execution": { - "iopub.execute_input": "2026-10-10T18:24:50.496824Z", - "iopub.status.busy": "2026-10-10T18:24:50.496824Z", - "iopub.status.idle": "2026-10-10T18:25:32.519026Z", - "shell.execute_reply": "2026-10-10T18:25:32.517018Z" + "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": [ @@ -1279,8 +1281,8 @@ " variable_id: tas\n", " variant_label: r1i1p1f1\n", " version: v20190429\n", - " status: 2019-10-25;created;by nhn2@columbia.edu