diff --git a/.github/workflows/test-integration.yaml b/.github/workflows/test-integration.yaml new file mode 100644 index 00000000..f33a4500 --- /dev/null +++ b/.github/workflows/test-integration.yaml @@ -0,0 +1,63 @@ +name: Integration tests + +on: + push: + branches: [ "beam-refactor" ] # FIXME: change to default branch post-merge + pull_request: + branches: [ "beam-refactor" ] # FIXME: change to default branch post-merge + types: [ opened, reopened, synchronize, labeled ] + +env: + PYTEST_ADDOPTS: "--color=yes" + +jobs: + prepare-env: + # run on: + # - all pushes to specified branch(es) + # - a PR was just labeled 'test-integration' + # - a PR with 'test-integration' label was opened, reopened, or synchronized + if: | + github.event_name == 'push' || + github.event.label.name == 'test-integration' || + contains( github.event.pull_request.labels.*.name, 'test-integration') + uses: ./.github/workflows/prepare-env.yaml + integration-tests: + needs: prepare-env + runs-on: ubuntu-latest + strategy: + fail-fast: false + matrix: + python-version: ["3.9", "3.10"] + dependencies: ["releases-only", "upstream-dev"] + steps: + - uses: actions/checkout@v2 + + # generic steps to load env from cache + - name: 🎯 Set cache number + id: cache-number + # cache will last 3 days by default + run: echo CACHE_NUMBER=`expr $(date +'%j') / 3` >> $GITHUB_ENV + - name: 🎯 Set environment file + id: env-file + run: echo "env_file=ci/py${{ matrix.python-version }}.yml" >> $GITHUB_ENV + - uses: actions/cache@v2 + name: 🗃 Loaded Cached environment + with: + path: /usr/share/miniconda3/envs/pangeo-forge-recipes + key: ${{ runner.os }}-conda-${{ matrix.python-version }}-${{ hashFiles( env.env_file ) }}-${{ matrix.dependencies }}-${{ env.CACHE_NUMBER }} + id: conda-cache + - name: 🤿 Bail out if no cache hit + if: steps.conda-cache.outputs.cache-hit != 'true' + run: false + - name: 🎯 Set path to include conda python + run: echo "/usr/share/miniconda3/envs/pangeo-forge-recipes/bin" >> $GITHUB_PATH + + # custom testing steps unique to this workflow + - name: 🌈 Install pangeo-forge-recipes package + shell: bash -l {0} + run: | + python -m pip install --no-deps -e . + - name: 🏄‍♂️ Run Tests + shell: bash -l {0} + run: | + pytest --timeout=600 tests-integration/ -v diff --git a/.readthedocs.yml b/.readthedocs.yml index c8d9b25f..f9d2e023 100644 --- a/.readthedocs.yml +++ b/.readthedocs.yml @@ -3,8 +3,14 @@ version: 2 sphinx: configuration: docs/conf.py -# Optionally set the version of Python and requirements required to build your docs +build: + os: ubuntu-22.04 + tools: + python: "3.9" + python: - version: 3.8 install: + # Install package too, so autodoc works + - method: pip + path: . - requirements: docs/requirements.txt diff --git a/ci/py3.10.yml b/ci/py3.10.yml index 75fcf02e..987629c7 100644 --- a/ci/py3.10.yml +++ b/ci/py3.10.yml @@ -7,7 +7,7 @@ dependencies: - apache-beam - black - boto3 - - cfgrib<0.9.9.0 + - cfgrib - cftime - codecov - dask @@ -20,7 +20,7 @@ dependencies: - hdf5 - intake - intake-xarray - - kerchunk>=0.0.6 + - kerchunk>=0.1.1 - lxml # Optional dep of pydap - matplotlib # needed for building tutorial notebooks - netcdf4 diff --git a/ci/py3.9.yml b/ci/py3.9.yml index a3c7f27b..ee60a47e 100644 --- a/ci/py3.9.yml +++ b/ci/py3.9.yml @@ -7,7 +7,7 @@ dependencies: - apache-beam - black - boto3 - - cfgrib<0.9.9.0 + - cfgrib - cftime - codecov - dask @@ -20,7 +20,7 @@ dependencies: - hdf5 - intake - intake-xarray - - kerchunk>=0.0.6 + - kerchunk>=0.1.1 - lxml # Optional dep of pydap - matplotlib # needed for building tutorial notebooks - netcdf4 diff --git a/docs/pangeo_forge_recipes/recipe_user_guide/recipes.md b/docs/pangeo_forge_recipes/recipe_user_guide/recipes.md index 241039fa..e80b4dd0 100644 --- a/docs/pangeo_forge_recipes/recipe_user_guide/recipes.md +++ b/docs/pangeo_forge_recipes/recipe_user_guide/recipes.md @@ -93,13 +93,37 @@ All recipes need a place to store the target dataset. Refer to {doc}`storage` fo Once your recipe is defined and has its storage targets assigned, you're ready to move on to {doc}`execution`. -### HDF Reference Recipes +### Reference Recipes -Like the Xarray to Zarr recipes, this category allows us to more efficiently access data from a bunch of NetCDF / HDF files. -However, such a recipe does not actually copy the original source data. -Instead, it generates metadata files which reference and index the original data, allowing it to be accessed more quickly and easily. -For more background, see [this blog post](https://medium.com/pangeo/fake-it-until-you-make-it-reading-goes-netcdf4-data-on-aws-s3-as-zarr-for-rapid-data-access-61e33f8fe685). +Like the Xarray to Zarr recipes, this category of recipes allows us to efficiently access data from a +collection of source files. Unlike the standard Zarr recipes, these reference recipes utilize +[kerchunk](https://fsspec.github.io/kerchunk/) to generate metadata files which reference and index the +original data, allowing it to be accessed more quickly and easily, without duplicating it. -There is currently one tutorial for this recipe: +Whereas the standard Zarr recipe creates a copy of the original dataset in the Zarr format, the +kerchunk-based reference recipe does not copy the data and instead creates a Kerchunk mapping, which +allows archival formats (including NetCDF, GRIB2, etc.) to be read as if they were Zarr datasets. +More details about how Kerchunk works can be found in the +[kerchunk docs](https://fsspec.github.io/kerchunk/detail.html) +and [this blog post](https://medium.com/pangeo/fake-it-until-you-make-it-reading-goes-netcdf4-data-on-aws-s3-as-zarr-for-rapid-data-access-61e33f8fe685). + +There are currently two tutorials for reference recipes: - {doc}`../tutorials/hdf_reference/reference_cmip6` +- {doc}`../tutorials/grib_reference/reference_HRRR` + +When choosing whether to create a reference recipe, it is important to consider questions such as: + +_**Where are the archival (i.e. source) files for this dataset currently stored?**_ If the original data +are not already in the cloud (or some other high-bandwidth storage device, such as an on-prem data +center), the performance benefits of using a reference recipe may be limited, because network speeds +to access the original data will constrain I/O throughput. + +_**Does this dataset require preprocessing?**_ With reference recipes, modification of the underlying +data is not possible. For example, the chunking schema of a dataset cannot be modified with Kerchunk, so +you are limited to the chunk schema of the archival data. If you need to optimize your datasets chunking +schema for space or time, the standard Zarr recipe is the only option. While you cannot modify chunking +in a reference recipe, changes in the metadata (attributes, encoding, etc.) can be applied. + +These caveats aside, for archival data stored on highly-throughput storage devices, for which +preprocessing is not required, reference recipes are an ideal and storage-efficient option. diff --git a/docs/pangeo_forge_recipes/tutorials/grib_reference/reference_HRRR.ipynb b/docs/pangeo_forge_recipes/tutorials/grib_reference/reference_HRRR.ipynb new file mode 100644 index 00000000..d6e3b2fd --- /dev/null +++ b/docs/pangeo_forge_recipes/tutorials/grib_reference/reference_HRRR.ipynb @@ -0,0 +1,1577 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# GRIB2 Reference Recipe for HRRR (High-Resolution Rapid Refresh)\n", + "\n", + "In this notebook, we will demonstrate how to create a reference recipe using GRIB2 files. As with all reference recipes, the original data is not duplicated, instead a reference/index of the dataset is built so the dataset can be read as if it were a Zarr store.\n", + "\n", + "The input files for this recipe are GRIB2 files provided by NOAA and stored in Amazon S3 ([HRRR AWS Open Data Page](https://registry.opendata.aws/noaa-hrrr-pds/)).\n", + "\n", + "This Pangeo-Forge tutorial is an adaptation of the [Kerchunk GRIB2 Project Pythia Cookbook](https://projectpythia.org/kerchunk-cookbook/notebooks/case_studies/HRRR.html). " + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Define the FilePattern\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import fsspec\n", + "import xarray as xr\n", + "from pangeo_forge_recipes.patterns import pattern_from_file_sequence\n", + "\n", + "fs = fsspec.filesystem(\"s3\", anon=True, skip_instance_cache=True)\n", + "\n", + "# retrieve list of available days in archive\n", + "days_available = fs.glob(\"s3://noaa-hrrr-bdp-pds/hrrr.*\")\n", + "\n", + "# Read HRRR GRIB2 files from latest day, the select the first 2\n", + "files = fs.glob(f\"s3://{days_available[-1]}/conus/*wrfsfcf01.grib2\")[0:2]\n", + "\n", + "# Create a filepattern object from input file paths\n", + "pattern = pattern_from_file_sequence(['s3://' + path for path in files], 'time', file_type='grib')\n", + "pattern\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Optional: Examine an input file" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# import s3fs\n", + "# import xarray as xr \n", + "# url = f'simplecache::s3://{files[0]}'\n", + "# file = fsspec.open_local(url, s3={'anon': True}, filecache={'cache_storage':'/tmp/files'})\n", + "\n", + "# ds = xr.open_dataset(file, engine=\"cfgrib\", backend_kwargs={'filter_by_keys': grib_filters})" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Write the Recipe\n", + "\n", + "Now that we have created our `FilePattern`, we can build our `beam` pipeline. A beam pipeline is a chained together list of (Apache Beam transformations)[https://beam.apache.org/documentation/programming-guide/#transforms].\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Specify where our target data should be written\n", + "Here, we are creating a temporary directory to store the written reference files. If we wanted these reference files to persist locally, we would want to specify another file path. \n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "from tempfile import TemporaryDirectory\n", + "td = TemporaryDirectory()\n", + "target_root = td.name" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Specify additional args\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "grib_filters = {\"typeOfLevel\": \"heightAboveGround\", \"level\": [2, 10]}\n", + "storage_options = {\"anon\": True}\n", + "remote_protocol = \"s3\"" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Construct a Pipeline\n", + "Next, we will construct a beam pipeline. This should look similar to the other standard Zarr examples, but will involve a few different transforms. " + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "import apache_beam as beam\n", + "from pangeo_forge_recipes.transforms import OpenWithKerchunk, CombineReferences, WriteCombinedReference\n", + "\n", + "store_name = \"grib2-reference\"\n", + "transforms = (\n", + " # Create a beam PCollection from our input file pattern\n", + " beam.Create(pattern.items())\n", + " # Open with Kerchunk and create references for each file\n", + " | OpenWithKerchunk(\n", + " file_type=pattern.file_type,\n", + " remote_protocol=remote_protocol,\n", + " storage_options=storage_options,\n", + " kerchunk_open_kwargs={\"filter\": grib_filters},\n", + " )\n", + " # Use Kerchunk's `MultiZarrToZarr` functionality to combine the reference files into a single\n", + " # reference file. *Note*: Setting the correct contact_dims and identical_dims is important.\n", + " | CombineReferences(\n", + " concat_dims=[\"valid_time\"],\n", + " identical_dims=[\"latitude\", \"longitude\", \"heightAboveGround\", \"step\"],\n", + " mzz_kwargs={\"remote_protocol\": remote_protocol},\n", + " # GRIB2 input files may generate > 1 kerchunk reference per input file,\n", + " # therefore we must precombine each input's references with itself, before\n", + " # adding them to the aggregate dataset. This is accomplished by setting the\n", + " # `precombine_inputs` option to `True`.\n", + " precombine_inputs=True,\n", + " )\n", + " # Write the combined Kerchunk reference to file\n", + " | WriteCombinedReference(target_root=target_root, store_name=store_name)\n", + ")" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Execute the Recipe" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING:apache_beam.runners.interactive.interactive_environment:Dependencies required for Interactive Beam PCollection visualization are not available, please use: `pip install apache-beam[interactive]` to install necessary dependencies to enable all data visualization features.\n" + ] + }, + { + "data": { + "application/javascript": "\n if (typeof window.interactive_beam_jquery == 'undefined') {\n var jqueryScript = document.createElement('script');\n jqueryScript.src = 'https://code.jquery.com/jquery-3.4.1.slim.min.js';\n jqueryScript.type = 'text/javascript';\n jqueryScript.onload = function() {\n var datatableScript = document.createElement('script');\n datatableScript.src = 'https://cdn.datatables.net/1.10.20/js/jquery.dataTables.min.js';\n datatableScript.type = 'text/javascript';\n datatableScript.onload = function() {\n window.interactive_beam_jquery = jQuery.noConflict(true);\n window.interactive_beam_jquery(document).ready(function($){\n \n });\n }\n document.head.appendChild(datatableScript);\n };\n document.head.appendChild(jqueryScript);\n } else {\n window.interactive_beam_jquery(document).ready(function($){\n \n });\n }" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/charlesstern/miniconda3/envs/pangeo-forge-recipes/lib/python3.9/site-packages/kerchunk/combine.py:260: UserWarning: Concatenated coordinate 'valid_time' contains less than expectednumber of values across the datasets: [1682643600]\n", + " warnings.warn(\n", + "/Users/charlesstern/miniconda3/envs/pangeo-forge-recipes/lib/python3.9/site-packages/kerchunk/combine.py:260: UserWarning: Concatenated coordinate 'valid_time' contains less than expectednumber of values across the datasets: [1682647200]\n", + " warnings.warn(\n" + ] + } + ], + "source": [ + "with beam.Pipeline() as p:\n", + " p | transforms" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Examine the Result\n", + "\n", + "Here we are creating an fsspec mapper of the reference file and then passing it to Xarray's `open_dataset` to be read as if it were a Zarr store." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.Dataset>\n",
+       "Dimensions:            (valid_time: 2, y: 1059, x: 1799, heightAboveGround: 1,\n",
+       "                        step: 1, time: 1)\n",
+       "Coordinates:\n",
+       "  * heightAboveGround  (heightAboveGround) int64 2\n",
+       "  * step               (step) timedelta64[ns] 01:00:00\n",
+       "  * time               (time) datetime64[ns] 2023-04-28\n",
+       "  * valid_time         (valid_time) datetime64[ns] 2023-04-28T01:00:00 2023-0...\n",
+       "Dimensions without coordinates: y, x\n",
+       "Data variables:\n",
+       "    d2m                (valid_time, y, x) float64 dask.array<chunksize=(1, 1059, 1799), meta=np.ndarray>\n",
+       "    latitude           (y, x) float64 dask.array<chunksize=(1059, 1799), meta=np.ndarray>\n",
+       "    longitude          (y, x) float64 dask.array<chunksize=(1059, 1799), meta=np.ndarray>\n",
+       "    pt                 (valid_time, y, x) float64 dask.array<chunksize=(1, 1059, 1799), meta=np.ndarray>\n",
+       "    r2                 (valid_time, y, x) float64 dask.array<chunksize=(1, 1059, 1799), meta=np.ndarray>\n",
+       "    sh2                (valid_time, y, x) float64 dask.array<chunksize=(1, 1059, 1799), meta=np.ndarray>\n",
+       "    si10               (valid_time, y, x) float64 dask.array<chunksize=(1, 1059, 1799), meta=np.ndarray>\n",
+       "    t2m                (valid_time, y, x) float64 dask.array<chunksize=(1, 1059, 1799), meta=np.ndarray>\n",
+       "    u10                (valid_time, y, x) float64 dask.array<chunksize=(1, 1059, 1799), meta=np.ndarray>\n",
+       "    unknown            (valid_time, y, x) float64 dask.array<chunksize=(1, 1059, 1799), meta=np.ndarray>\n",
+       "    v10                (valid_time, y, x) float64 dask.array<chunksize=(1, 1059, 1799), meta=np.ndarray>\n",
+       "Attributes:\n",
+       "    centre:             kwbc\n",
+       "    centreDescription:  US National Weather Service - NCEP\n",
+       "    edition:            2\n",
+       "    subCentre:          0
" + ], + "text/plain": [ + "\n", + "Dimensions: (valid_time: 2, y: 1059, x: 1799, heightAboveGround: 1,\n", + " step: 1, time: 1)\n", + "Coordinates:\n", + " * heightAboveGround (heightAboveGround) int64 2\n", + " * step (step) timedelta64[ns] 01:00:00\n", + " * time (time) datetime64[ns] 2023-04-28\n", + " * valid_time (valid_time) datetime64[ns] 2023-04-28T01:00:00 2023-0...\n", + "Dimensions without coordinates: y, x\n", + "Data variables:\n", + " d2m (valid_time, y, x) float64 dask.array\n", + " latitude (y, x) float64 dask.array\n", + " longitude (y, x) float64 dask.array\n", + " pt (valid_time, y, x) float64 dask.array\n", + " r2 (valid_time, y, x) float64 dask.array\n", + " sh2 (valid_time, y, x) float64 dask.array\n", + " si10 (valid_time, y, x) float64 dask.array\n", + " t2m (valid_time, y, x) float64 dask.array\n", + " u10 (valid_time, y, x) float64 dask.array\n", + " unknown (valid_time, y, x) float64 dask.array\n", + " v10 (valid_time, y, x) float64 dask.array\n", + "Attributes:\n", + " centre: kwbc\n", + " centreDescription: US National Weather Service - NCEP\n", + " edition: 2\n", + " subCentre: 0" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# open dataset as zarr object using fsspec reference file system and Xarray\n", + "full_path = os.path.join(target_root, store_name, \"reference.json\")\n", + "fs = fsspec.filesystem(\"reference\", fo=full_path)\n", + "ds = xr.open_dataset(\n", + " fs.get_mapper(\"\"), engine=\"zarr\", backend_kwargs=dict(consolidated=False), chunks={\"valid_time\": 1}\n", + ")\n", + "ds\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Make a Map" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ds[\"t2m\"][-1].plot()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "pangeo-forge-recipes", + "language": "python", + "name": "python3" + }, + "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.9.15" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "6b8a746a12f29aa2c546c85b48de78550232bc5612f99eafab965bc70842be27" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/docs/pangeo_forge_recipes/tutorials/hdf_reference/reference_cmip6.ipynb b/docs/pangeo_forge_recipes/tutorials/hdf_reference/reference_cmip6.ipynb index 835d4b30..1aee14d8 100644 --- a/docs/pangeo_forge_recipes/tutorials/hdf_reference/reference_cmip6.ipynb +++ b/docs/pangeo_forge_recipes/tutorials/hdf_reference/reference_cmip6.ipynb @@ -1,21 +1,21 @@ { "cells": [ { + "attachments": {}, "cell_type": "markdown", "id": "49caf2b2", "metadata": {}, "source": [ "# HDF Reference Recipe for CMIP6\n", "\n", - "This example illustrates how to create a {class}`pangeo_forge_recipes.recipes.HDFReferenceRecipe`.\n", + "This example illustrates how to create a Reference Recipe using CMIP6 data.\n", "This recipe does not actually copy the original source data.\n", - "Instead, it generates metadata files which reference and index the original data, allowing it to be accessed more efficiently.\n", - "For more background, see [this blog post](https://medium.com/pangeo/fake-it-until-you-make-it-reading-goes-netcdf4-data-on-aws-s3-as-zarr-for-rapid-data-access-61e33f8fe685).\n", + "Instead, it generates metadata files which reference and index the original data, allowing it to be accessed more efficiently. It does this by using the Python library, [Kerchunk](https://fsspec.github.io/kerchunk/) under the hood. Pangeo-Forge is acting as a runner for Kerchunk to generate reference files. \n", "\n", "As the input for this recipe, we will use some CMIP6 NetCDF4 files provided by ESGF and stored in Amazon S3 ([CMIP6 AWS Open Data Page](https://registry.opendata.aws/cmip6/)).\n", "Many CMIP6 simulations spread their outputs over many HDF5/ NetCDF4 files, in order to limit the individual file size.\n", "This can be inconvenient for analysis.\n", - "In this recipe, we will see how to virtually concatentate many HDF5 files into one big viritual Zarr dataset." + "In this recipe, we will see how to virtually concatenate many HDF5 files into one big virtual Zarr dataset." ] }, { @@ -106,8 +106,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 613 ms, sys: 154 ms, total: 767 ms\n", - "Wall time: 5.32 s\n" + "CPU times: user 713 ms, sys: 324 ms, total: 1.04 s\n", + "Wall time: 4.41 s\n" ] }, { @@ -144,6 +144,7 @@ "}\n", "\n", "html[theme=dark],\n", + "body[data-theme=dark],\n", "body.vscode-dark {\n", " --xr-font-color0: rgba(255, 255, 255, 1);\n", " --xr-font-color2: rgba(255, 255, 255, 0.54);\n", @@ -373,6 +374,11 @@ " grid-column: 4;\n", "}\n", "\n", + ".xr-index-preview {\n", + " grid-column: 2 / 5;\n", + " color: var(--xr-font-color2);\n", + "}\n", + "\n", ".xr-var-name,\n", ".xr-var-dims,\n", ".xr-var-dtype,\n", @@ -394,14 +400,16 @@ "}\n", "\n", ".xr-var-attrs,\n", - ".xr-var-data {\n", + ".xr-var-data,\n", + ".xr-index-data {\n", " display: none;\n", " background-color: var(--xr-background-color) !important;\n", " padding-bottom: 5px !important;\n", "}\n", "\n", ".xr-var-attrs-in:checked ~ .xr-var-attrs,\n", - ".xr-var-data-in:checked ~ .xr-var-data {\n", + ".xr-var-data-in:checked ~ .xr-var-data,\n", + ".xr-index-data-in:checked ~ .xr-index-data {\n", " display: block;\n", "}\n", "\n", @@ -411,13 +419,16 @@ "\n", ".xr-var-name span,\n", ".xr-var-data,\n", + ".xr-index-name div,\n", + ".xr-index-data,\n", ".xr-attrs {\n", " padding-left: 25px !important;\n", "}\n", "\n", ".xr-attrs,\n", ".xr-var-attrs,\n", - ".xr-var-data {\n", + ".xr-var-data,\n", + ".xr-index-data {\n", " grid-column: 1 / -1;\n", "}\n", "\n", @@ -455,7 +466,8 @@ "}\n", "\n", ".xr-icon-database,\n", - ".xr-icon-file-text2 {\n", + ".xr-icon-file-text2,\n", + ".xr-no-icon {\n", " display: inline-block;\n", " vertical-align: middle;\n", " width: 1em;\n", @@ -491,7 +503,7 @@ " variable_id: thetao\n", " variant_info: N/A\n", " references: see further_info_url attribute\n", - " variant_label: r1i1p1f1