diff --git a/.github/ci-config.yml b/.github/ci-config.yml new file mode 100644 index 0000000..a1f0911 --- /dev/null +++ b/.github/ci-config.yml @@ -0,0 +1,10 @@ +dependencies: | + ecmwf/ecbuild + MathisRosenhauer/libaec@refs/tags/v1.1.3 + ecmwf/eccodes + ecmwf/eckit + ecmwf/atlas + ecmwf/mir +dependency_branch: develop +parallelism_factor: 8 +self_build: false # Only for python packages diff --git a/.github/ci-hpc-config.yml b/.github/ci-hpc-config.yml index 2e20c20..6507efa 100644 --- a/.github/ci-hpc-config.yml +++ b/.github/ci-hpc-config.yml @@ -1,3 +1,16 @@ build: python: 3.10 - parallel: 1 + dependencies: + - ecmwf/ecbuild@develop + - MathisRosenhauer/libaec@refs/tags/v1.1.3 + - ecmwf/eccodes@develop + - ecmwf/eckit@feature/eckit-geo + - ecmwf/atlas@develop + - ecmwf/mir@feature/eckit-geo + python_dependencies: + - ecmwf/eccodes-python@develop + - ecmwf/earthkit-data@develop + parallel: 64 + pytest_cmd: | + pytest --cov=./ --cov-report=xml + python -m coverage report diff --git a/.github/workflows/cd-pypi.yml b/.github/workflows/cd-pypi.yml index bd03198..44b14e9 100644 --- a/.github/workflows/cd-pypi.yml +++ b/.github/workflows/cd-pypi.yml @@ -2,7 +2,7 @@ name: cd on: push: tags: - - '**' + - '**' jobs: pypi: uses: ecmwf/reusable-workflows/.github/workflows/cd-pypi.yml@v2 diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index ad93595..9ed1e9b 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -3,26 +3,26 @@ on: # Trigger the workflow on push to master or develop, except tag creation push: branches: - - 'main' - - 'develop' + - 'main' + - 'develop' tags-ignore: - - '**' + - '**' paths-ignore: - - "docs/**" - - "README.md" + - "docs/**" + - "README.md" # Trigger the workflow on pull request pull_request: paths-ignore: - - "docs/**" - - "README.md" + - "docs/**" + - "README.md" # Trigger the workflow manually workflow_dispatch: # Trigger after public PR approved for CI pull_request_target: types: [labeled] paths-ignore: - - "docs/**" - - "README.md" + - "docs/**" + - "README.md" jobs: # Run CI including downstream packages on self-hosted runners downstream-ci: diff --git a/.github/workflows/legacy-ci.yml b/.github/workflows/legacy-ci.yml deleted file mode 100644 index 09b98ad..0000000 --- a/.github/workflows/legacy-ci.yml +++ /dev/null @@ -1,59 +0,0 @@ -name: legacy-ci -on: - push: - branches: - - main - - develop - tags: - - "*" - pull_request: - branches: - - main - - develop - pull_request_target: - types: [labeled] - workflow_dispatch: -concurrency: - group: ${{ github.workflow }}-${{ github.ref }} - cancel-in-progress: true -defaults: - run: - shell: bash -l {0} -jobs: - pre-commit: - if: ${{ !github.event.pull_request.head.repo.fork && github.event.action != 'labeled' || github.event.label.name == 'approved-for-ci' }} - runs-on: ubuntu-latest - steps: - - uses: actions/checkout@v3 - with: - ref: ${{ github.event.pull_request.head.sha || github.ref }} - - uses: actions/setup-python@v4 - with: - python-version: 3.x - - uses: pre-commit/action@v3.0.0 - documentation: - if: ${{ !github.event.pull_request.head.repo.fork && github.event.action != 'labeled' || github.event.label.name == 'approved-for-ci' }} - runs-on: ubuntu-latest - defaults: - run: - shell: bash -l {0} - steps: - - uses: actions/checkout@v3 - with: - ref: ${{ github.event.pull_request.head.sha || github.ref }} - - name: Install Conda environment with Micromamba - uses: mamba-org/setup-micromamba@v1 - with: - environment-file: tests/environment-unit-tests.yml - environment-name: DEVELOP - channels: conda-forge - cache-env: true - cache-env-key: ubuntu-latest-3.10 - extra-specs: | - python=3.10 - - name: Install package - run: | - python -m pip install --no-deps -e . - - name: Build documentation - run: | - make docs-build diff --git a/.github/workflows/notify-new-issue.yml b/.github/workflows/notify-new-issue.yml index 3593edc..4896baa 100644 --- a/.github/workflows/notify-new-issue.yml +++ b/.github/workflows/notify-new-issue.yml @@ -2,12 +2,12 @@ name: Notify new issue on: issues: types: - - "opened" + - "opened" jobs: notify: runs-on: ubuntu-latest steps: - - name: Notify new issue - uses: ecmwf/notify-teams-issue@v1 - with: - incoming_webhook: ${{ secrets.MS_TEAMS_INCOMING_WEBHOOK }} + - name: Notify new issue + uses: ecmwf/notify-teams-issue@v1 + with: + incoming_webhook: ${{ secrets.MS_TEAMS_INCOMING_WEBHOOK }} diff --git a/.github/workflows/notify-new-pr.yml b/.github/workflows/notify-new-pr.yml index af5dd82..2c22eba 100644 --- a/.github/workflows/notify-new-pr.yml +++ b/.github/workflows/notify-new-pr.yml @@ -2,12 +2,12 @@ name: Notify new PR on: pull_request_target: types: - - "opened" + - "opened" jobs: notify: runs-on: ubuntu-latest steps: - - name: Notify new PR - uses: ecmwf/notify-teams-pr@v1 - with: - incoming_webhook: ${{ secrets.MS_TEAMS_INCOMING_WEBHOOK }} + - name: Notify new PR + uses: ecmwf/notify-teams-pr@v1 + with: + incoming_webhook: ${{ secrets.MS_TEAMS_INCOMING_WEBHOOK }} diff --git a/.github/workflows/python-pull-request.yml b/.github/workflows/python-pull-request.yml new file mode 100644 index 0000000..8f32929 --- /dev/null +++ b/.github/workflows/python-pull-request.yml @@ -0,0 +1,10 @@ +name: Code Quality checks for PRs +on: + push: + pull_request: + types: [opened, synchronize, reopened] +jobs: + quality: + uses: ecmwf/reusable-workflows/.github/workflows/qa-precommit-run.yml@v2 + with: + skip-hooks: "no-commit-to-branch" diff --git a/.gitignore b/.gitignore index 4c3211e..7728be8 100644 --- a/.gitignore +++ b/.gitignore @@ -360,3 +360,11 @@ tags # local code _dev + + +# data and precomputed weights +*.grib +*.grib1 +*.grib2 +*.json +*.npz diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index 986d81b..804d502 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -1,54 +1,41 @@ repos: - - repo: https://github.com/pre-commit/pre-commit-hooks - rev: v5.0.0 - hooks: - - id: trailing-whitespace # Trailing whitespace checker - - id: end-of-file-fixer # Ensure files end in a newline - - id: check-json - - id: check-yaml # Check YAML files for syntax errors only - args: [--unsafe, --allow-multiple-documents] - - id: check-toml - # - id: check-added-large-files - - id: debug-statements # Check for debugger imports and py37+ breakpoint() - - id: mixed-line-ending - - id: no-commit-to-branch # Prevent committing to main / master - - id: check-merge-conflict # Check for files that contain merge conflict - exclude: /README\.rst$|^docs/.*\.rst$ - - repo: https://github.com/psf/black - rev: 24.8.0 - hooks: - - id: black - args: [--line-length=120] - - repo: https://github.com/keewis/blackdoc - rev: v0.3.8 - hooks: - - id: blackdoc - additional_dependencies: [black==23.3.0] - exclude: xr_engine_profile_rst\.py - - repo: https://github.com/astral-sh/ruff-pre-commit - rev: v0.6.9 - hooks: - - id: ruff - exclude: '(dev/.*|.*_)\.py$' - args: - - --line-length=120 - - --fix - - --exit-non-zero-on-fix - - --preview - - repo: https://github.com/executablebooks/mdformat - rev: 0.7.14 - hooks: - - id: mdformat - exclude: cruft-update-template.md - - repo: https://github.com/google/yamlfmt - rev: v0.13.0 - hooks: - - id: yamlfmt - - repo: https://github.com/sphinx-contrib/sphinx-lint - rev: v1.0.0 - hooks: - - id: sphinx-lint - - repo: https://github.com/tox-dev/pyproject-fmt - rev: "v2.5.0" - hooks: - - id: pyproject-fmt +- repo: https://github.com/pre-commit/pre-commit-hooks + rev: v5.0.0 + hooks: + - id: trailing-whitespace # Trailing whitespace checker + - id: end-of-file-fixer # Ensure files end in a newline + - id: check-json + - id: check-yaml # Check YAML files for syntax errors only + args: [--unsafe, --allow-multiple-documents] + - id: check-toml + # - id: check-added-large-files + - id: debug-statements # Check for debugger imports and py37+ breakpoint() + - id: mixed-line-ending + - id: no-commit-to-branch # Prevent committing to main / master + - id: check-merge-conflict # Check for files that contain merge conflict + exclude: /README\.rst$|^docs/.*\.rst$ +- repo: https://github.com/astral-sh/ruff-pre-commit + rev: v0.15.4 + hooks: + - id: ruff-check + exclude: '(docs/conf|dev/.*|.*_)\.py$|docs/experimental/.*\.ipynb$' + args: + - --fix + - --exit-non-zero-on-fix + - id: ruff-format +- repo: https://github.com/executablebooks/mdformat + rev: 0.7.14 + hooks: + - id: mdformat + exclude: cruft-update-template.md +- repo: https://github.com/macisamuele/language-formatters-pre-commit-hooks + rev: v2.16.0 + hooks: + - id: pretty-format-yaml + args: [--autofix, --preserve-quotes] + - id: pretty-format-toml + args: [--autofix] +- repo: https://github.com/sphinx-contrib/sphinx-lint + rev: v1.0.0 + hooks: + - id: sphinx-lint diff --git a/.readthedocs.yml b/.readthedocs.yml index 5a61cc6..900dcb4 100644 --- a/.readthedocs.yml +++ b/.readthedocs.yml @@ -3,9 +3,11 @@ formats: [] build: os: "ubuntu-22.04" tools: - python: "3.9" + python: "3.10" python: install: - - requirements: docs/requirements.txt + - requirements: docs/requirements.txt + - method: pip + path: . sphinx: configuration: docs/conf.py diff --git a/docs/_static/custom.css b/docs/_static/custom.css new file mode 100644 index 0000000..6ad9797 --- /dev/null +++ b/docs/_static/custom.css @@ -0,0 +1,145 @@ +@import url("https://fonts.googleapis.com/css2?family=Nunito:ital,wght@0,200..1000;1,200..1000&display=swap"); + +:root { + --font-stack: "Nunito", sans-serif; + --font-stack--monospace: "Nunito", sans-serif; +} + +body { + font-family: "Nunito", sans-serif; +} + +h1, h2, h3, h4, h5, h6 { + font-family: "Nunito", sans-serif; +} + +/* Sidebar solid background colour */ +.sidebar-drawer { + background: #262640; +} + +/* SVG overlay – absolute on mobile so it collapses with the drawer */ +.sidebar-drawer::before { + content: ""; + position: absolute; + top: 0; + left: 0; + width: 100%; + height: 100%; + background: url("octahedral-grid.svg") no-repeat top center / auto 150vh; + opacity: 0.08; + pointer-events: none; + z-index: 0; +} + +/* + On desktop, switch the overlay to position: fixed so it stays in place + while scrolling (avoids background-attachment:fixed Safari flicker). + Width values mirror Furo's own sidebar-drawer widths at each breakpoint. +*/ +@media screen and (min-width: 63em) { + .sidebar-drawer::before { + position: fixed; + top: 0; + left: 0; + width: calc(50% - 18.5em); + min-width: 15em; + height: 100vh; + } +} + +@media screen and (min-width: 82em) { + .sidebar-drawer::before { + width: calc(50% - 26em); + } +} + +/* ── xarray dark-mode fix for Furo "auto" theme ────────────────────── + xarray's inline
<xarray.Dataset> Size: 44kB\n",
+       "Dimensions:    (step: 2, latitude: 37, longitude: 72)\n",
+       "Coordinates:\n",
+       "  * step       (step) timedelta64[ns] 16B 00:00:00 12:00:00\n",
+       "  * latitude   (latitude) float64 296B 90.0 85.0 80.0 75.0 ... -80.0 -85.0 -90.0\n",
+       "  * longitude  (longitude) float64 576B 0.0 5.0 10.0 15.0 ... 345.0 350.0 355.0\n",
+       "Data variables:\n",
+       "    2t         (step, latitude, longitude) float64 43kB ...\n",
+       "Attributes:\n",
+       "    Conventions:  CF-1.8\n",
+       "    institution:  ECMWF
" + ], + "text/plain": [ + " Size: 44kB\n", + "Dimensions: (step: 2, latitude: 37, longitude: 72)\n", + "Coordinates:\n", + " * step (step) timedelta64[ns] 16B 00:00:00 12:00:00\n", + " * latitude (latitude) float64 296B 90.0 85.0 80.0 75.0 ... -80.0 -85.0 -90.0\n", + " * longitude (longitude) float64 576B 0.0 5.0 10.0 15.0 ... 345.0 350.0 355.0\n", + "Data variables:\n", + " 2t (step, latitude, longitude) float64 43kB ...\n", + "Attributes:\n", + " Conventions: CF-1.8\n", + " institution: ECMWF" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "r.to_xarray()" + ] + }, + { + "cell_type": "markdown", + "id": "5a6380b4-03b6-497f-b1d2-e36860830830", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "source": [ + "#### Writing the results to disk" + ] + }, + { + "cell_type": "markdown", + "id": "3b206f6d-7a17-4128-818d-f12262d8f5ed", + "metadata": {}, + "source": [ + "Write the resulting fieldlist to disk:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "9c6b8bb6-a734-4930-b322-7c362c915a51", + "metadata": {}, + "outputs": [], + "source": [ + "out_file = \"_res_H8_nested_to_5x5.grib\"\n", + "r.to_target(\"file\", out_file)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "dev", + "language": "python", + "name": "dev" + }, + "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.13.1" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/examples/mir/mir_interpolation_types.ipynb b/docs/examples/mir/mir_interpolation_types.ipynb new file mode 100644 index 0000000..07bc520 --- /dev/null +++ b/docs/examples/mir/mir_interpolation_types.ipynb @@ -0,0 +1,228 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "27b6be13-d0a5-41e1-9479-f1028b01610f", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "source": [ + "# MIR: using different interpolations" + ] + }, + { + "cell_type": "raw", + "id": "1f8af122-f127-437b-bf14-e867acdce44d", + "metadata": { + "editable": true, + "raw_mimetype": "text/restructuredtext", + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "source": [ + "This example compares different interpolation methods using the :ref:`mir ` backend.\n", + "\n", + "To make this notebook work :xref:`earthkit-data` and :xref:`earthkit-plots` have to be installed. The data will be represented as an `earthkit-data GRIB FieldList `_." + ] + }, + { + "cell_type": "markdown", + "id": "630902ad-c821-47b4-9140-f04cc9a53976", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "source": [ + "#### Regridding" + ] + }, + { + "cell_type": "raw", + "id": "51f5470d-3ead-403d-900c-1150b9f8bb67", + "metadata": { + "editable": true, + "raw_mimetype": "text/restructuredtext", + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "source": [ + "We perform the regridding with the :ref:`regrid() ` method." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "8c1cff92-971e-4494-b847-b2df7e7ee53c", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "import earthkit.data as ekd\n", + "\n", + "from earthkit.geo import regrid\n", + "\n", + "# Get octahedral reduced Gaussian GRIB data containing two fields.\n", + "ds = ekd.from_source(\"sample\", \"O32_t2.grib2\").to_fieldlist()\n", + "\n", + "# the target grid is a global 1x1 degree regular latitude-longitude grid\n", + "grid = {\"grid\": [1, 1]}\n", + "\n", + "# Regrid the fieldlist using various interpolations and\n", + "# gather results in a dict\n", + "res = {}\n", + "for i_type in [\"linear\", \"nearest-neighbour\", \"grid-box-average\"]:\n", + " res[i_type] = regrid(ds, grid=grid, interpolation=i_type)" + ] + }, + { + "cell_type": "markdown", + "id": "42eadd3a-1d4a-46c4-a34a-9fbf8ba15f88", + "metadata": {}, + "source": [ + "#### Plotting the results" + ] + }, + { + "cell_type": "raw", + "id": "f3bd0750-2bc5-4abd-9066-c7e9de5172af", + "metadata": { + "editable": true, + "raw_mimetype": "text/restructuredtext", + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "source": [ + "We use :xref:`earthkit-plots` to visualise the results together with the locations of the original (O32) gridpoints." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "91b54b7a-a8dc-4699-b60b-8923231f451a", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/93/w0p869rx17q98wxk83gn9ys40000gn/T/ipykernel_37559/181199985.py:6: DeprecationWarning: The 'auto_style' parameter is deprecated and will be removed in a future version. Please use style='auto' instead.\n", + " chart.grid_cells(ds_res[0], units=\"celsius\", auto_style=True)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/93/w0p869rx17q98wxk83gn9ys40000gn/T/ipykernel_37559/181199985.py:6: DeprecationWarning: The 'auto_style' parameter is deprecated and will be removed in a future version. Please use style='auto' instead.\n", + " chart.grid_cells(ds_res[0], units=\"celsius\", auto_style=True)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/93/w0p869rx17q98wxk83gn9ys40000gn/T/ipykernel_37559/181199985.py:6: DeprecationWarning: The 'auto_style' parameter is deprecated and will be removed in a future version. Please use style='auto' instead.\n", + " chart.grid_cells(ds_res[0], units=\"celsius\", auto_style=True)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import earthkit.plots as ekp\n", + "\n", + "for i_type, ds_res in res.items():\n", + " chart = ekp.Map(domain=[\"Europe\"])\n", + " # we only plot the first field from the result\n", + " chart.grid_cells(ds_res[0], units=\"celsius\", auto_style=True)\n", + " # plot the original grid points\n", + " chart.grid_points(ds[0])\n", + " chart.title(f\"interpolation={i_type}\")\n", + " chart.coastlines()\n", + " chart.gridlines()\n", + " chart.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "28e76042-a0f0-4794-8a4b-d6594556b15f", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "dev", + "language": "python", + "name": "dev" + }, + "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.13.1" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/examples/mir/mir_numpy_array.ipynb b/docs/examples/mir/mir_numpy_array.ipynb new file mode 100644 index 0000000..cc6ac78 --- /dev/null +++ b/docs/examples/mir/mir_numpy_array.ipynb @@ -0,0 +1,168 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "cd110cd9-f40e-4ccf-b702-b40d611f60bf", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "source": [ + "# MIR: regridding numpy arrays" + ] + }, + { + "cell_type": "raw", + "id": "e6004fb6-603c-4671-977c-3ce72e16a42d", + "metadata": { + "editable": true, + "raw_mimetype": "text/restructuredtext", + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "source": [ + "This example shows how to interpolate numpy arrays using the :ref:`mir ` backend." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "5854d65c-ef1e-4c99-8c09-fa8e7612f399", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "\n", + "from earthkit.geo.regrid.array import regrid" + ] + }, + { + "cell_type": "markdown", + "id": "de55e418-ffa0-4609-b6dc-a9b23ebe77b8", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "source": [ + "First, we generate random data matching the size of an O32 octahedral reduced Gaussian grid." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "a71db0be-2233-4133-b03f-9219dc84e3f3", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "values = np.random.random(5248)" + ] + }, + { + "cell_type": "raw", + "id": "c1a951b8-f550-45f1-aef4-3bed884a7bdf", + "metadata": { + "editable": true, + "raw_mimetype": "text/restructuredtext", + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "source": [ + "Next, interpolate the array onto a 1x1 degree global regular latitude-longitude grid using :ref:`regrid() `. The input and output grids are defined by a :ref:`gridspec `. Both the input and the output values are numpy arrays." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "24ccc6b5-90c2-4e4d-8175-677c5d0f12ed", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "((181, 360), {'grid': [1, 1]})" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "res, res_grid = regrid(values, in_grid={\"grid\": \"O32\"}, out_grid={\"grid\": [1, 1]})\n", + "res.shape, res_grid" + ] + }, + { + "cell_type": "raw", + "id": "537e772f-d965-42dc-b395-62a3be7eb7f5", + "metadata": { + "editable": true, + "raw_mimetype": "text/restructuredtext", + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "source": [ + ":ref:`regrid() ` returns a tuple with the regridded array and the resulting gridspec. This latter might be different than the one specified in ``out_grid`` because MIR can perform normalisation and other adjustments on it. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "13cac978-b11a-463d-a877-9b3bdfb9b7b0", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "dev", + "language": "python", + "name": "dev" + }, + "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.13.1" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/examples/mir/mir_octahedral_fieldlist.ipynb b/docs/examples/mir/mir_octahedral_fieldlist.ipynb new file mode 100644 index 0000000..f20e7d2 --- /dev/null +++ b/docs/examples/mir/mir_octahedral_fieldlist.ipynb @@ -0,0 +1,742 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "27b6be13-d0a5-41e1-9479-f1028b01610f", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "source": [ + "# MIR: regridding octahedral GRIB fieldlist" + ] + }, + { + "cell_type": "raw", + "id": "1f8af122-f127-437b-bf14-e867acdce44d", + "metadata": { + "editable": true, + "raw_mimetype": "text/restructuredtext", + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "source": [ + "This example shows how to interpolate GRIB data defined on an octahedral reduced Gaussian grid using the :ref:`mir ` backend. We will also see how to inspect and plot the resulting data and how to convert it to xarray.\n", + "\n", + "To make this notebook work :xref:`earthkit-data` and :xref:`earthkit-plots` have to be installed. The data will be represented as an `earthkit-data GRIB FieldList `_." + ] + }, + { + "cell_type": "markdown", + "id": "630902ad-c821-47b4-9140-f04cc9a53976", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "source": [ + "#### Regridding" + ] + }, + { + "cell_type": "raw", + "id": "b2d1244c-70da-4300-94be-19621099cd2a", + "metadata": { + "editable": true, + "raw_mimetype": "text/restructuredtext", + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "source": [ + "We perform the regridding with the :ref:`regrid() ` method." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "8c1cff92-971e-4494-b847-b2df7e7ee53c", + "metadata": {}, + "outputs": [], + "source": [ + "import earthkit.data as ekd\n", + "\n", + "from earthkit.geo import regrid\n", + "\n", + "# Get octahedral reduced Gaussian GRIB data containing two fields.\n", + "ds = ekd.from_source(\"sample\", \"O32_t2.grib2\").to_fieldlist()\n", + "\n", + "# the target grid is a global 5x5 degree regular latitude-longitude grid\n", + "grid = {\"grid\": [5, 5]}\n", + "\n", + "# perform interpolation for each field and add results\n", + "# to a new fieldlist stored in memory\n", + "r = regrid(ds, grid=grid, interpolation=\"linear\")" + ] + }, + { + "cell_type": "markdown", + "id": "42eadd3a-1d4a-46c4-a34a-9fbf8ba15f88", + "metadata": {}, + "source": [ + "#### Plotting the results" + ] + }, + { + "cell_type": "raw", + "id": "f3bd0750-2bc5-4abd-9066-c7e9de5172af", + "metadata": { + "editable": true, + "raw_mimetype": "text/restructuredtext", + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "source": [ + "We use :xref:`earthkit-plots` to visualise the results." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "91b54b7a-a8dc-4699-b60b-8923231f451a", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import earthkit.plots as ekp\n", + "\n", + "ekp.quickplot(r)" + ] + }, + { + "cell_type": "markdown", + "id": "2d465f73-7848-49b5-adc3-697a68760520", + "metadata": {}, + "source": [ + "#### Converting the results to xarray" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "44543f10-44df-4e35-b5a3-33a7a4240b13", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.Dataset> Size: 44kB\n",
+       "Dimensions:    (step: 2, latitude: 37, longitude: 72)\n",
+       "Coordinates:\n",
+       "  * step       (step) timedelta64[ns] 16B 00:00:00 12:00:00\n",
+       "  * latitude   (latitude) float64 296B 90.0 85.0 80.0 75.0 ... -80.0 -85.0 -90.0\n",
+       "  * longitude  (longitude) float64 576B 0.0 5.0 10.0 15.0 ... 345.0 350.0 355.0\n",
+       "Data variables:\n",
+       "    2t         (step, latitude, longitude) float64 43kB ...\n",
+       "Attributes:\n",
+       "    Conventions:  CF-1.8\n",
+       "    institution:  ECMWF
" + ], + "text/plain": [ + " Size: 44kB\n", + "Dimensions: (step: 2, latitude: 37, longitude: 72)\n", + "Coordinates:\n", + " * step (step) timedelta64[ns] 16B 00:00:00 12:00:00\n", + " * latitude (latitude) float64 296B 90.0 85.0 80.0 75.0 ... -80.0 -85.0 -90.0\n", + " * longitude (longitude) float64 576B 0.0 5.0 10.0 15.0 ... 345.0 350.0 355.0\n", + "Data variables:\n", + " 2t (step, latitude, longitude) float64 43kB ...\n", + "Attributes:\n", + " Conventions: CF-1.8\n", + " institution: ECMWF" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "r.to_xarray()" + ] + }, + { + "cell_type": "markdown", + "id": "97c2e3e3-6deb-4df0-a498-168643b1e70e", + "metadata": {}, + "source": [ + "#### Writing the results to disk" + ] + }, + { + "cell_type": "markdown", + "id": "ed089b30-03f7-430a-9f41-17520d5206cd", + "metadata": {}, + "source": [ + "Write the resulting fieldlist to disk:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "ad36951e-9118-46f2-933c-ce5b852341f0", + "metadata": {}, + "outputs": [], + "source": [ + "out_file = \"_res_O32_to_5x5.grib\"\n", + "r.to_target(\"file\", out_file)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "28e76042-a0f0-4794-8a4b-d6594556b15f", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "dev", + "language": "python", + "name": "dev" + }, + "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.13.1" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/examples/misc/cache.ipynb b/docs/examples/misc/cache.ipynb new file mode 100644 index 0000000..976b741 --- /dev/null +++ b/docs/examples/misc/cache.ipynb @@ -0,0 +1,549 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "65c27cc6-55b9-4d36-af83-c35cbd00caf3", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "source": [ + "# Matrix disk cache" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "64c27d94-7d5b-4a0f-9e72-708be1609527", + "metadata": {}, + "outputs": [], + "source": [ + "from earthkit.geo import cache, config" + ] + }, + { + "attachments": {}, + "cell_type": "raw", + "id": "232699ed-fd27-426c-8b6b-93091b72d68d", + "metadata": { + "editable": true, + "raw_mimetype": "text/restructuredtext", + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "source": [ + "earthkit-geo uses a dedicated **directory** to store files downloaded from remote sources. This includes the interpolation matrices and the related index files when using :func:`regrid` with ``backend=\"precomputed\"``. \n", + "\n", + "By default this directory serves a :ref:`cache ` and is **managed** (its size is checked/limited). It means if we run :func:`regrid` again with the same input and output grid it will load the matrix from the cache instead of downloading it again. Additionally, caching offers **monitoring and disk space management**. When the cache is full, cached data is deleted according to the configuration (i.e. oldest data is deleted first). " + ] + }, + { + "cell_type": "markdown", + "id": "3d93c85a-3c9b-4496-990d-8612fcb82fcf", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "source": [ + "In the examples below we will change the configuration multiple times. First we ensure all the changes are temporary and no options are saved into the configuration file. We also reset the configuration to the defaults." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "71214b97-2b64-442d-bd23-98f831b064d0", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "config.autosave = False\n", + "config.reset()" + ] + }, + { + "cell_type": "markdown", + "id": "df5b047f-a34e-4a70-82d7-b7bb1fcc2fc2", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "source": [ + "#### User defined cache directory (default)" + ] + }, + { + "attachments": {}, + "cell_type": "raw", + "id": "8c9988a4-5760-456b-9b72-d3eecb955d7d", + "metadata": { + "editable": true, + "raw_mimetype": "text/restructuredtext", + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "source": [ + "The primary key to control the cache in the configuration is :ref:`cache-policy `. The default value is :ref:`\"user\" `, which means that the cache location is defined by the :ref:`user-cache-directory ` config option. By default it is set to ``\"~/.cache/earthkit-regrid\"``. \n", + "\n", + "The user cache directory is **not cleaned up on exit**. So next time you start earthkit-regrid it will be there again unless it is deleted manually or it is set in way that on each startup a different path is assigned to it. Also, when you run multiple sessions of earthkit-regrid under the same user they will share the same cache. " + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "da6e1e1c-c248-4301-ab89-fea50b73bf57", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "source": [ + "The configuration tells us all the details about the cache policy and location:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "4c2afb82-c630-451f-88e5-f80c8aa404ac", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "user\n", + "/Users/cgr/.cache/earthkit-geo\n" + ] + } + ], + "source": [ + "config.set(\"cache-policy\", \"user\")\n", + "print(config.get(\"cache-policy\"))\n", + "print(config.get(\"user-cache-directory\"))" + ] + }, + { + "cell_type": "raw", + "id": "743bb32a-f1bf-4b1d-94e9-f8a17516b19a", + "metadata": { + "editable": true, + "raw_mimetype": "text/restructuredtext", + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "source": [ + "The path to the current cache directory can also be queried through the :ref:`cache object `:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "44583d41-f1d3-4c28-8af5-90d659cdae31", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "'/Users/cgr/.cache/earthkit-geo'" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "cache.directory()" + ] + }, + { + "cell_type": "markdown", + "id": "f6665b3b-5176-4161-9671-b20eb3bcc483", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "source": [ + "We are free to change the user cache directory to another path:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "ea59e447-084e-4bf4-8635-744c769a92e2", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'/Users/cgr/earthkit-regrid-demo-cache'" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "config.set(\"user-cache-directory\", \"~/earthkit-regrid-demo-cache\")\n", + "cache.directory()" + ] + }, + { + "cell_type": "markdown", + "id": "8d0ede62-77d4-4914-86c8-12bc6846d16a", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "source": [ + "#### Temporary cache directory" + ] + }, + { + "attachments": {}, + "cell_type": "raw", + "id": "943e6bcc-6110-4930-a346-194a28731123", + "metadata": { + "editable": true, + "raw_mimetype": "text/restructuredtext", + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "source": [ + "When the :ref:`cache-policy ` is :ref:`\"temporary\" ` the cache will be located in a temporary directory created by *tempfile.TemporaryDirectory*. This directory will be **unique** for each earthkit-regrid session. When the directory object goes out of scope (at the latest on exit) the cache is **cleaned up**." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "36aa1fad-2594-4a43-b115-60ac0e602a9a", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "temporary\n" + ] + } + ], + "source": [ + "config.set(\"cache-policy\", \"temporary\")\n", + "print(config.get(\"cache-policy\"))" + ] + }, + { + "cell_type": "raw", + "id": "808e10da-a8ff-4757-88ce-b408e423cd50", + "metadata": { + "editable": true, + "raw_mimetype": "text/restructuredtext", + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "source": [ + "The path to the cache directory has to be queried through the :ref:`cache object `:" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "df3dd753-7f61-40c9-986f-5cfca5e4713e", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "'/var/folders/93/w0p869rx17q98wxk83gn9ys40000gn/T/tmpwrnl24xy'" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "cache.directory()" + ] + }, + { + "attachments": {}, + "cell_type": "raw", + "id": "cd723cc6-204e-4114-9567-f7f5dd4d169e", + "metadata": { + "editable": true, + "raw_mimetype": "text/restructuredtext", + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "source": [ + "We can specify the parent directory for the the temporary cache by using the :ref:`temporary-cache-directory-root ` config option. By default it is set to None (no parent directory specified)." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "7b057350-7fed-4204-b825-e782f93883b6", + "metadata": { + "editable": true, + "scrolled": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "'/Users/cgr/my_demo_regrid_cache/tmpuuu3mu5v'" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "s = {\"cache-policy\": \"temporary\", \"temporary-cache-directory-root\": \"~/my_demo_regrid_cache\"}\n", + "config.set(s)\n", + "cache.directory()" + ] + }, + { + "cell_type": "markdown", + "id": "e0df8e80-7dec-4bcf-8a72-09bce1d0983a", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "source": [ + "#### No caching" + ] + }, + { + "cell_type": "raw", + "id": "f77edd13-6ffc-44e6-9d2a-0c29d914e028", + "metadata": { + "editable": true, + "raw_mimetype": "text/restructuredtext", + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "source": [ + "When the :ref:`cache-policy ` is :ref:`\"off\" ` no disk based caching is available. \n", + "\n", + "In this case all files are downloaded into an **unmanaged** temporary directory created by *tempfile.TemporaryDirectory*. Since caching is disabled all calls to :func:`regrid` for remote services and URLSs will download the data again! This temporary directory will be unique for each earthkit-geo session. When the directory object goes out of scope (at the latest on exit) the directory will be **cleaned up**. " + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "aaf1ab3b-2e62-4598-8bbc-323476be5844", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "off\n" + ] + } + ], + "source": [ + "config.set(\"cache-policy\", \"off\")\n", + "print(config.get(\"cache-policy\"))" + ] + }, + { + "cell_type": "raw", + "id": "d289ec22-a153-45ad-b29d-2c1d4780b7f2", + "metadata": { + "editable": true, + "raw_mimetype": "text/restructuredtext", + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "source": [ + "The path to the temporary directory has to be queried through the :ref:`cache object `:" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "3e219366-2ba7-479b-b4b3-8a097dd24bda", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "'/var/folders/93/w0p869rx17q98wxk83gn9ys40000gn/T/tmp5bct2nsn'" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "cache.directory()" + ] + }, + { + "cell_type": "raw", + "id": "7ce6fb62-6da5-4047-a6ea-ce8597fd6b1f", + "metadata": { + "editable": true, + "raw_mimetype": "text/restructuredtext", + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "source": [ + "We can specify the parent directory for the temporary directory by using the :ref:`temporary-directory-root ` config option. By default it is set to None (no parent directory specified)." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "36b04aa0-f925-4754-bb0e-b0a539950197", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "'/var/folders/93/w0p869rx17q98wxk83gn9ys40000gn/T/tmp3py0o9ri'" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "s = {\"cache-policy\": \"off\", \"temporary-directory-root\": \"~/my_demo_regrid_tmp\"}\n", + "config.set(s)\n", + "cache.directory()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0e18b9b0-4234-4f79-8f1b-6e9087052d33", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "dev", + "language": "python", + "name": "dev" + }, + "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.13.1" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/examples/misc/config.ipynb b/docs/examples/misc/config.ipynb new file mode 100644 index 0000000..3e4924f --- /dev/null +++ b/docs/examples/misc/config.ipynb @@ -0,0 +1,532 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "53d7b7af-fc34-450c-9c39-493f3d881c49", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "source": [ + "# Configuration" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "55715969-c15d-4b7f-bf0f-459591359d76", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "from earthkit.geo import config" + ] + }, + { + "cell_type": "markdown", + "id": "01b48692-a39d-4cfd-99dd-4047501edb54", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "source": [ + "#### Config basics" + ] + }, + { + "attachments": {}, + "cell_type": "raw", + "id": "492ab3b0-edf8-421f-8b77-c508447d391c", + "metadata": { + "editable": true, + "raw_mimetype": "text/restructuredtext", + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "source": [ + "The :ref:`config` object is loaded from the ``~/.config/earthkit/geo/config.yaml`` file. Changes are immediately saved back into this file unless we explicitly disable it with ``config.autosave`` or use a :ref:`temporary configuration `." + ] + }, + { + "cell_type": "markdown", + "id": "bb06b2f7-5552-4247-843e-2e328beaabe9", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "source": [ + "For the rest of this notebook we disable the configuration autosave so the changes will not be written into our configuration file." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "c5d47016-6f5b-4cbc-ac15-1d231546ac10", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "config.autosave = False" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "27d1d708-8090-43af-8be8-5d81eec4791b", + "metadata": {}, + "source": [ + "We can display the current configuration and the default values with:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "953cdbe7-e159-47cf-bb27-613f1ec3fba3", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/html": [ + "
NameValueDefault
cache-policy'user''user'
check-out-of-date-urlsFalseFalse
download-out-of-date-urlsFalseFalse
maximum-cache-disk-usageNoneNone
maximum-cache-size'5GB''5GB'
maximum-weights-memory-cache-size'500MB''500MB'
temporary-cache-directory-rootNoneNone
temporary-directory-rootNoneNone
url-download-timeout'30s''30s'
user-cache-directory'/Users/cgr/.cache/earthkit-geo''/Users/cgr/.cache/earthkit-geo'
version'0.5.2.dev118+g382d2cd13.d20260302'''
weights-memory-cache-policy'largest''largest'
weights-memory-cache-strict-modeFalseFalse
" + ], + "text/plain": [ + "cache-policy: (user, user)\n", + "check-out-of-date-urls: (False, False)\n", + "download-out-of-date-urls: (False, False)\n", + "maximum-cache-disk-usage: (None, None)\n", + "maximum-cache-size: (5GB, 5GB)\n", + "maximum-weights-memory-cache-size: (500MB, 500MB)\n", + "temporary-cache-directory-root: (None, None)\n", + "temporary-directory-root: (None, None)\n", + "url-download-timeout: (30s, 30s)\n", + "user-cache-directory: (/Users/cgr/.cache/earthkit-geo, /Users/cgr/.cache/earthkit-geo)\n", + "version: (0.5.2.dev118+g382d2cd13.d20260302, )\n", + "weights-memory-cache-policy: (largest, largest)\n", + "weights-memory-cache-strict-mode: (False, False)" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "config" + ] + }, + { + "cell_type": "raw", + "id": "23b0893d-f6cd-42bc-b030-0917684b7786", + "metadata": { + "editable": true, + "raw_mimetype": "text/restructuredtext", + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "source": [ + "We can use :ref:`get() ` to access the config values." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "c477d8a3-eef8-4f73-86f1-64bdbabd13d5", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "30" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "config.get(\"url-download-timeout\")" + ] + }, + { + "cell_type": "raw", + "id": "c61b5316-04cc-455a-a51a-66717af22bfd", + "metadata": { + "editable": true, + "raw_mimetype": "text/restructuredtext", + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "source": [ + "We can use :ref:`set() ` to change the values." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "373e772d-52ac-4166-94a5-b7f501a4490f", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "5" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "config.set(\"url-download-timeout\", 5)\n", + "config.get(\"url-download-timeout\")" + ] + }, + { + "cell_type": "markdown", + "id": "27182b2a-f49b-406d-af81-bbd77bef3b1b", + "metadata": {}, + "source": [ + "Multiple values can be set together. The argument list can be a dictionary:" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "f2c4e61b-5e91-4986-8987-21a3deeed750", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "10\n", + "True\n" + ] + } + ], + "source": [ + "config.set({\"url-download-timeout\": 10, \"check-out-of-date-urls\": True})\n", + "print(config.get(\"url-download-timeout\"))\n", + "print(config.get(\"check-out-of-date-urls\"))" + ] + }, + { + "cell_type": "markdown", + "id": "2b0e80b7-cc1d-47df-ac9c-8815581f2b87", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "source": [ + "Alternatively, we can use keyword arguments. However, because the \"-\" character is not allowed in variable names in Python we have to replace \"-\" with \"_\" in all the keyword arguments:" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "ea398b6b-5d51-42fd-ae59-76b6140f7456", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "10\n", + "True\n" + ] + } + ], + "source": [ + "config.set(url_download_timeout=10, check_out_of_date_urls=True)\n", + "print(config.get(\"url-download-timeout\"))\n", + "print(config.get(\"check-out-of-date-urls\"))" + ] + }, + { + "cell_type": "markdown", + "id": "b7c8edff-9355-4144-aee9-e0a2a55f8eba", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "source": [ + "#### Temporary configuration" + ] + }, + { + "attachments": {}, + "cell_type": "raw", + "id": "08bca9e3-65f3-4557-8be0-be2c79f98fb7", + "metadata": { + "editable": true, + "raw_mimetype": "text/restructuredtext", + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "source": [ + "We can create a :ref:`temporary configuration ` (as a context manager) as a copy of the original configuration. We will still refer to it as \"config\", but it is completely independent from the original object and changes are not saved into the yaml file (even when *config.auto_save* is True)." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "5f63aca8-b609-4436-91d8-5e9b0e56a7c0", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "10\n", + "12\n" + ] + } + ], + "source": [ + "with config.temporary():\n", + " print(config.get(\"url-download-timeout\"))\n", + " config.set(\"url-download-timeout\", 12)\n", + " print(config.get(\"url-download-timeout\"))" + ] + }, + { + "cell_type": "markdown", + "id": "b1f883bd-c63b-45dd-b333-de6ed682a62f", + "metadata": {}, + "source": [ + "When we leave the context the config is reverted to the original one:" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "f44da09d-4d5e-4ee1-babc-943e901aeb69", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "10" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "config.get(\"url-download-timeout\")" + ] + }, + { + "cell_type": "markdown", + "id": "2670d106-7e09-42ba-bc66-335d84c38905", + "metadata": {}, + "source": [ + "A temporary configuration can also be created with arguments:" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "15870fd7-e2a1-4674-a701-f85861e6eb8a", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "12\n", + "10\n" + ] + } + ], + "source": [ + "with config.temporary(\"url-download-timeout\", 12):\n", + " print(config.get(\"url-download-timeout\"))\n", + "\n", + "print(config.get(\"url-download-timeout\"))" + ] + }, + { + "cell_type": "markdown", + "id": "313fbf8f-a540-449e-b340-5c46014d931c", + "metadata": {}, + "source": [ + "#### Reset to defaults" + ] + }, + { + "attachments": {}, + "cell_type": "raw", + "id": "323f7e0b-9126-4af5-9197-be98c60e2e1c", + "metadata": { + "editable": true, + "raw_mimetype": "text/restructuredtext", + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "source": [ + "The :ref:`reset() ` method resets the config to the defaults. We demonstrate it on a temporary configuration:" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "2cc244ba-e80f-4111-b309-6ea7bf1b8119", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "12\n", + "30\n" + ] + } + ], + "source": [ + "with config.temporary():\n", + " config.set(\"url-download-timeout\", 12)\n", + " print(config.get(\"url-download-timeout\"))\n", + " config.reset()\n", + " print(config.get(\"url-download-timeout\"))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "13f10d70-de59-4086-82d5-8d04d4c0907c", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "dev", + "language": "python", + "name": "dev" + }, + "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.13.1" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/examples/misc/config_env_vars.ipynb b/docs/examples/misc/config_env_vars.ipynb new file mode 100644 index 0000000..55a0ad5 --- /dev/null +++ b/docs/examples/misc/config_env_vars.ipynb @@ -0,0 +1,377 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "1273fa5f-9ab5-4a4c-857a-0f212e759f12", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "source": [ + "# Configuration environment variables" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "75bffc4a-24e8-4d2d-948d-2cb84bc11020", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "from earthkit.geo import config" + ] + }, + { + "cell_type": "raw", + "id": "022b7ed2-29f2-49fb-a619-ff86f45d7a48", + "metadata": { + "editable": true, + "raw_mimetype": "text/restructuredtext", + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "source": [ + "For the rest of this notebook we disable the :ref:`config` autosave so the changes will not be written into our configuration file." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "2072ae67-13df-4e8a-a1a4-d54a56639569", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "config.autosave = False" + ] + }, + { + "cell_type": "raw", + "id": "0c497859-6d2a-4fb7-bfb0-0979eb0d2279", + "metadata": { + "editable": true, + "raw_mimetype": "text/restructuredtext", + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "source": [ + "Each :ref:`config` parameter has a corresponding environment variable (see the full list :ref:`here `). When an environment variable is set, it takes precedence over the settings parameter as the following example demonstrates it." + ] + }, + { + "cell_type": "markdown", + "id": "2888d0b6-beea-4178-9c01-5a08a5be7ad2", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "source": [ + "Assuming no environmental variable is set the value is read form the config file." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "21f853d3-c961-4ad2-b200-c24f7b03a54e", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "30" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "config.get(\"url-download-timeout\")" + ] + }, + { + "cell_type": "raw", + "id": "95036166-0eec-437b-9988-771e522ada2e", + "metadata": { + "editable": true, + "raw_mimetype": "text/restructuredtext", + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "source": [ + "When the environment variable is set :func:`get ` returns its value." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "d4a8c3bd-19ca-454a-8f39-07de7a2d318c", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "env: EARTHKIT_GEO_URL_DOWNLOAD_TIMEOUT=26\n" + ] + } + ], + "source": [ + "%env EARTHKIT_GEO_URL_DOWNLOAD_TIMEOUT=26" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "dbc54f27-7b5e-467b-bcba-28daea0e3c46", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "26" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "config.get(\"url-download-timeout\")" + ] + }, + { + "cell_type": "raw", + "id": "4d784930-1a1e-482c-ae2d-7491a4066b47", + "metadata": { + "editable": true, + "raw_mimetype": "text/restructuredtext", + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "source": [ + "Setting the value generates a warning. The new value is saved into the config file, but :func:`get ` still returns the value of the environment variable." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "8ee6f835-ae42-4eae-bc96-a53c47f3ce06", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/cgr/git/earthkit-geo/src/earthkit/geo/utils/config.py:337: UserWarning: Config option 'url-download-timeout' is also set by environment variable 'EARTHKIT_GEO_URL_DOWNLOAD_TIMEOUT'.The environment variable takes precedence and its value is returned when calling get().\n", + " warnings.warn(msg)\n" + ] + }, + { + "data": { + "text/plain": [ + "26" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "config.set(\"url-download-timeout\", 10)\n", + "config.get(\"url-download-timeout\")" + ] + }, + { + "cell_type": "raw", + "id": "0a24b839-a4d1-4340-bd87-7d690f0511f7", + "metadata": { + "editable": true, + "raw_mimetype": "text/restructuredtext", + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "source": [ + "The :func:`env` method gives details about the set environment variables." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "9c56e84d-ff1e-4415-b924-b461d62ddbbd", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "{'url-download-timeout': ('EARTHKIT_GEO_URL_DOWNLOAD_TIMEOUT', '26')}" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "config.env()" + ] + }, + { + "cell_type": "markdown", + "id": "d3e74276-cf79-42f0-9b66-b59ac15829d3", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "source": [ + "When we dump the configuration the values set via environment variables are clearly indicated." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "89a92e24-f7f5-4f04-bc9a-1d0d00f7c8cf", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/html": [ + "
NameValueDefault
cache-policy'user''user'
check-out-of-date-urlsFalseFalse
download-out-of-date-urlsFalseFalse
maximum-cache-disk-usageNoneNone
maximum-cache-size'5GB''5GB'
temporary-cache-directory-rootNoneNone
temporary-directory-rootNoneNone
url-download-timeoutEARTHKIT_GEO_URL_DOWNLOAD_TIMEOUT='26'
(10)
'30s'
user-cache-directory'/Users/cgr/.cache/earthkit-geo''/Users/cgr/.cache/earthkit-geo'
version'0.5.2.dev114+g40cc1015b.d20260219'''
" + ], + "text/plain": [ + "cache-policy: (user, user)\n", + "check-out-of-date-urls: (False, False)\n", + "download-out-of-date-urls: (False, False)\n", + "maximum-cache-disk-usage: (None, None)\n", + "maximum-cache-size: (5GB, 5GB)\n", + "temporary-cache-directory-root: (None, None)\n", + "temporary-directory-root: (None, None)\n", + "url-download-timeout: (EARTHKIT_GEO_URL_DOWNLOAD_TIMEOUT=26, 10, 30s)\n", + "user-cache-directory: (/Users/cgr/.cache/earthkit-geo, /Users/cgr/.cache/earthkit-geo)\n", + "version: (0.5.2.dev114+g40cc1015b.d20260219, )" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "config" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "943ec49a-b11f-490f-9c58-7b942eaaeaa9", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "dev", + "language": "python", + "name": "dev" + }, + "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.13.1" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/examples/misc/index.rst b/docs/examples/misc/index.rst new file mode 100644 index 0000000..ec55679 --- /dev/null +++ b/docs/examples/misc/index.rst @@ -0,0 +1,12 @@ +.. _examples_misc: + + +Miscellaneous +++++++++++++++++++++++++++++++ + +.. toctree:: + :maxdepth: 1 + + config.ipynb + config_env_vars.ipynb + cache.ipynb diff --git a/docs/examples/precomputed/index.rst b/docs/examples/precomputed/index.rst new file mode 100644 index 0000000..cafcea1 --- /dev/null +++ b/docs/examples/precomputed/index.rst @@ -0,0 +1,13 @@ +.. _examples_precomputed: + + +Regridding with precomputed weights ++++++++++++++++++++++++++++++++++++++ + +.. toctree:: + :maxdepth: 1 + + precomp_numpy_array.ipynb + precomp_octahedral_fieldlist.ipynb + precomp_healpix_fieldlist.ipynb + memory_cache.ipynb diff --git a/docs/examples/precomputed/memory_cache.ipynb b/docs/examples/precomputed/memory_cache.ipynb new file mode 100644 index 0000000..3a9fb1c --- /dev/null +++ b/docs/examples/precomputed/memory_cache.ipynb @@ -0,0 +1,364 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "a57bee67-d094-4ec8-9175-33465f46e1d0", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "source": [ + "# Matrix memory cache" + ] + }, + { + "cell_type": "raw", + "id": "ac1d768f-b386-4229-90c9-a5cc7c550643", + "metadata": { + "editable": true, + "raw_mimetype": "text/restructuredtext", + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "source": [ + "This notebook demonstrates the usage of the in-memory precomputed interpolation weights cache. Please note this is only available for the :ref:`precomputed ` backend (for both the high-level and and array-level :func:`regrid` methods). By default this cache is enabled, for details see :ref:`mem_cache`. " + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "3f3c0324-708c-4ea9-8eac-406cabc0a1e8", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "\n", + "import earthkit.geo as ekg\n", + "from earthkit.geo.regrid.array import regrid\n", + "\n", + "# create input data array for an O1280 grid\n", + "in_data = np.ones(6599680)\n", + "\n", + "\n", + "# helper method for regrid\n", + "def _run(n=10):\n", + " for _ in range(n):\n", + " regrid(in_data, {\"grid\": \"O1280\"}, {\"grid\": [0.1, 0.1]}, backend=\"precomputed\")" + ] + }, + { + "cell_type": "markdown", + "id": "a3b773e5-4378-43ba-a706-428ffb8b3c5f", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "source": [ + "In the examples below we will change the configuration multiple times. First we ensure all the changes are temporary and no options are saved into the configuration file. We also reset the configuration to the defaults." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "e0377623-20b8-4935-9614-eb937ae34b3e", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "ekg.config.autosave = False\n", + "ekg.config.reset()" + ] + }, + { + "cell_type": "markdown", + "id": "2aeaea49-cb22-42b0-8e34-65f2abf90ce3", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "source": [ + "#### The \"off\" cache policy" + ] + }, + { + "cell_type": "raw", + "id": "4c2772b6-de75-4ec4-ae7d-5ff78a49a51c", + "metadata": { + "editable": true, + "raw_mimetype": "text/restructuredtext", + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "source": [ + "We can control the in-memory weights cache via the :ref:`config`. In this example we turn off the in-memory cache." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "5b0734b7-272e-47a5-859f-2af38da13cc3", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "ekg.config.set(weights_memory_cache_policy=\"off\")" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "22333b87-6005-43ec-9e86-d39833e7de35", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 3.86 s, sys: 679 ms, total: 4.54 s\n", + "Wall time: 4.7 s\n" + ] + } + ], + "source": [ + "%time _run()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "44c806ab-88f0-4364-a1c9-8d8a217a7295", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "CacheInfo(hits=0, misses=0, maxsize=0, currsize=0, count=0, policy='off')" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ekg.memory_cache_info()" + ] + }, + { + "cell_type": "markdown", + "id": "3485ddee-56fa-4346-8946-669286ef954d", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "source": [ + "#### The \"largest\" (default) cache policy" + ] + }, + { + "cell_type": "raw", + "id": "e06d0739-ef6f-4a4e-b2de-7b141fcdb0c9", + "metadata": { + "editable": true, + "raw_mimetype": "text/restructuredtext", + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "source": [ + "Now we will use the default memory cache policy, which is \"largest\". For details see: :ref:`largest_mem_cache_policy`. Notice the roughly x9 speed-up we achieved with the caching." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "7c8d2977-befc-47aa-a894-aab195aaf4db", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "ekg.config.set(weights_memory_cache_policy=\"largest\")" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "74152589-4085-4c73-baef-d0c109f5e158", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 492 ms, sys: 75.2 ms, total: 568 ms\n", + "Wall time: 568 ms\n" + ] + } + ], + "source": [ + "%time _run()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "59137910-dfb2-4334-beb0-f5590b56d47e", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "CacheInfo(hits=9, misses=1, maxsize=524288000, currsize=259170724, count=1, policy='largest')" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ekg.memory_cache_info()" + ] + }, + { + "cell_type": "markdown", + "id": "a857e482-d056-4b21-b66d-0b08ff29720a", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "source": [ + "#### Clearing the cache" + ] + }, + { + "cell_type": "raw", + "id": "4abb400b-f5a7-4dad-a802-a0a1ccc05e4b", + "metadata": { + "editable": true, + "raw_mimetype": "text/restructuredtext", + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "source": [ + "We can clear the cache with :func:`clear_memory_cache`." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "767f7420-0a80-4c3e-ac33-d8dfcd5c4cf7", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "CacheInfo(hits=0, misses=0, maxsize=524288000, currsize=0, count=0, policy='largest')" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ekg.clear_memory_cache()\n", + "ekg.memory_cache_info()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "dev", + "language": "python", + "name": "dev" + }, + "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.13.1" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/examples/precomputed/precomp_healpix_fieldlist.ipynb b/docs/examples/precomputed/precomp_healpix_fieldlist.ipynb new file mode 100644 index 0000000..da56211 --- /dev/null +++ b/docs/examples/precomputed/precomp_healpix_fieldlist.ipynb @@ -0,0 +1,763 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "27b6be13-d0a5-41e1-9479-f1028b01610f", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "source": [ + "# Precomputed: regridding HEALPix GRIB fieldlist" + ] + }, + { + "cell_type": "raw", + "id": "4cf645d5-c3bb-46a3-afd9-60446adf40ba", + "metadata": { + "editable": true, + "raw_mimetype": "text/restructuredtext", + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "source": [ + "This example shows how to interpolate GRIB data defined on a HEALPix nested grid using the :ref:`precomputed ` backend. We will also see how to inspect and plot the resulting data and how to convert it to xarray.\n", + "\n", + "To make this notebook work :xref:`earthkit-data` and :xref:`earthkit-plots` have to be installed. The data will be represented as an `earthkit-data GRIB FieldList `_." + ] + }, + { + "cell_type": "markdown", + "id": "68d978ff-0c55-47d5-983b-829467675af0", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "source": [ + "#### Regridding" + ] + }, + { + "cell_type": "raw", + "id": "f7156fb5-6b4d-4589-b9b2-e0d5df4a524a", + "metadata": { + "editable": true, + "raw_mimetype": "text/x-rst", + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "source": [ + "We perform the regridding with the :ref:`regrid() ` method." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "8c1cff92-971e-4494-b847-b2df7e7ee53c", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "((37, 72), (37, 72), (2, 37, 72))" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from earthkit.data import from_source\n", + "\n", + "from earthkit.geo import regrid\n", + "\n", + "# Get HEALPix nested GRIB data containing two fields.\n", + "ds = from_source(\"sample\", \"H8_nested_t2.grib2\").to_fieldlist()\n", + "\n", + "# the target grid is a global 5x5 degree regular latitude-longitude grid\n", + "out_grid = {\"grid\": [5, 5]}\n", + "\n", + "# perform interpolation for each field and add results\n", + "# to a new fieldlist stored in memory\n", + "r = regrid(ds, grid=out_grid, interpolation=\"linear\", backend=\"precomputed\")\n", + "\n", + "d = r.data()\n", + "lat = d[0]\n", + "lon = d[1]\n", + "vals = d[2:]\n", + "lat.shape, lon.shape, vals.shape" + ] + }, + { + "cell_type": "raw", + "id": "916918ad-c592-4dee-9d44-90095a83a9d5", + "metadata": { + "editable": true, + "raw_mimetype": "text/restructuredtext", + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "source": [ + "Please note that regridding with the :ref:`precomputed ` backend only works between a predefined set of global grids. See the :ref:`precomputed_inventory` for details." + ] + }, + { + "cell_type": "markdown", + "id": "e8e4e384-0e99-4609-8869-3d5a6783a344", + "metadata": {}, + "source": [ + "#### Plotting the results" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "91b54b7a-a8dc-4699-b60b-8923231f451a", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import earthkit.plots as ekp\n", + "\n", + "ekp.quickplot(r)" + ] + }, + { + "cell_type": "markdown", + "id": "4eee7b1e-fbe3-43d9-b185-867c7d8946aa", + "metadata": {}, + "source": [ + "#### Converting the results to xarray" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "8fd12a93-6cf9-4d6e-83e2-0efd9e545a48", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.Dataset> Size: 44kB\n",
+       "Dimensions:    (step: 2, latitude: 37, longitude: 72)\n",
+       "Coordinates:\n",
+       "  * step       (step) timedelta64[ns] 16B 00:00:00 12:00:00\n",
+       "  * latitude   (latitude) float64 296B 90.0 85.0 80.0 75.0 ... -80.0 -85.0 -90.0\n",
+       "  * longitude  (longitude) float64 576B 0.0 5.0 10.0 15.0 ... 345.0 350.0 355.0\n",
+       "Data variables:\n",
+       "    2t         (step, latitude, longitude) float64 43kB ...\n",
+       "Attributes:\n",
+       "    Conventions:  CF-1.8\n",
+       "    institution:  ECMWF
" + ], + "text/plain": [ + " Size: 44kB\n", + "Dimensions: (step: 2, latitude: 37, longitude: 72)\n", + "Coordinates:\n", + " * step (step) timedelta64[ns] 16B 00:00:00 12:00:00\n", + " * latitude (latitude) float64 296B 90.0 85.0 80.0 75.0 ... -80.0 -85.0 -90.0\n", + " * longitude (longitude) float64 576B 0.0 5.0 10.0 15.0 ... 345.0 350.0 355.0\n", + "Data variables:\n", + " 2t (step, latitude, longitude) float64 43kB ...\n", + "Attributes:\n", + " Conventions: CF-1.8\n", + " institution: ECMWF" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "r.to_xarray()" + ] + }, + { + "cell_type": "markdown", + "id": "5a6380b4-03b6-497f-b1d2-e36860830830", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "source": [ + "#### Writing the results to disk" + ] + }, + { + "cell_type": "markdown", + "id": "3b206f6d-7a17-4128-818d-f12262d8f5ed", + "metadata": {}, + "source": [ + "Write the resulting fieldlist to disk:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "9c6b8bb6-a734-4930-b322-7c362c915a51", + "metadata": {}, + "outputs": [], + "source": [ + "out_file = \"_res_H8_nested_to_5x5.grib\"\n", + "r.to_target(\"file\", out_file)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "dev", + "language": "python", + "name": "dev" + }, + "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.13.1" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/examples/precomputed/precomp_numpy_array.ipynb b/docs/examples/precomputed/precomp_numpy_array.ipynb new file mode 100644 index 0000000..5a3d014 --- /dev/null +++ b/docs/examples/precomputed/precomp_numpy_array.ipynb @@ -0,0 +1,168 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "44a202c1-ec83-4d8b-b232-6f69d7d55ace", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "source": [ + "# Precomputed: regridding numpy arrays" + ] + }, + { + "cell_type": "raw", + "id": "ff059052-b505-4ff3-896a-f0ed48800f8d", + "metadata": { + "editable": true, + "raw_mimetype": "text/restructuredtext", + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "source": [ + "This example shows how to interpolate numpy arrays using the :ref:`precomputed ` backend. " + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "5854d65c-ef1e-4c99-8c09-fa8e7612f399", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "\n", + "from earthkit.geo.regrid.array import regrid" + ] + }, + { + "cell_type": "markdown", + "id": "de55e418-ffa0-4609-b6dc-a9b23ebe77b8", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "source": [ + "First, we generate random data matching the size of an O32 octahedral reduced Gaussian grid." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "a71db0be-2233-4133-b03f-9219dc84e3f3", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "values = np.random.random(5248)" + ] + }, + { + "cell_type": "raw", + "id": "c1a951b8-f550-45f1-aef4-3bed884a7bdf", + "metadata": { + "editable": true, + "raw_mimetype": "text/restructuredtext", + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "source": [ + "Interpolate the array onto a 1x1 degree global regular latitude-longitude grid using :ref:`regrid() `. The input and output grids are defined by a :ref:`gridspec `. Both the input and the output values are numpy arrays." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "24ccc6b5-90c2-4e4d-8175-677c5d0f12ed", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "((181, 360), {'grid': [1, 1]})" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "res, res_grid = regrid(values, in_grid={\"grid\": \"O32\"}, out_grid={\"grid\": [1, 1]}, backend=\"precomputed\")\n", + "res.shape, res_grid" + ] + }, + { + "cell_type": "raw", + "id": "2199e309-305e-46e6-b6db-747fcc3a1930", + "metadata": { + "editable": true, + "raw_mimetype": "text/restructuredtext", + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "source": [ + ":ref:`regrid() ` returns a tuple with the regridded array and the resulting gridspec." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3b00a3f6-5ce3-4175-8776-8c0331f82130", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "dev", + "language": "python", + "name": "dev" + }, + "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.13.1" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/examples/precomputed/precomp_octahedral_fieldlist.ipynb b/docs/examples/precomputed/precomp_octahedral_fieldlist.ipynb new file mode 100644 index 0000000..3dad52f --- /dev/null +++ b/docs/examples/precomputed/precomp_octahedral_fieldlist.ipynb @@ -0,0 +1,785 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "27b6be13-d0a5-41e1-9479-f1028b01610f", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "source": [ + "# Precomputed: regridding octahedral GRIB fieldlist" + ] + }, + { + "cell_type": "raw", + "id": "1f8af122-f127-437b-bf14-e867acdce44d", + "metadata": { + "editable": true, + "raw_mimetype": "text/restructuredtext", + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "source": [ + "This example shows how to interpolate GRIB data defined on an octahedral reduced Gaussian grid using the :ref:`precomputed ` backend. We will also see how to inspect and plot the resulting data and how to convert it to xarray.\n", + "\n", + "To make this notebook work :xref:`earthkit-data` and :xref:`earthkit-plots` have to be installed. The data will be represented as an `earthkit-data GRIB FieldList `_." + ] + }, + { + "cell_type": "markdown", + "id": "630902ad-c821-47b4-9140-f04cc9a53976", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "source": [ + "#### Regridding" + ] + }, + { + "cell_type": "raw", + "id": "d60b58a0-1d72-412a-884c-f9e7d2622cb1", + "metadata": { + "editable": true, + "raw_mimetype": "text/restructuredtext", + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "source": [ + "We perform the regridding with the :ref:`regrid() ` method." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "8c1cff92-971e-4494-b847-b2df7e7ee53c", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "((37, 72), (37, 72), (2, 37, 72))" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import earthkit.data as ekd\n", + "\n", + "from earthkit.geo import regrid\n", + "\n", + "# Get octahedral reduced Gaussian GRIB data containing two fields.\n", + "ds = ekd.from_source(\"sample\", \"O32_t2.grib2\").to_fieldlist()\n", + "\n", + "# the target grid is a global 5x5 degree regular latitude-longitude grid\n", + "out_grid = {\"grid\": [5, 5]}\n", + "\n", + "# perform interpolation for each field and add results\n", + "# to a new fieldlist stored in memory\n", + "r = regrid(ds, grid=out_grid, interpolation=\"linear\", backend=\"precomputed\")\n", + "\n", + "d = r.data()\n", + "lat = d[0]\n", + "lon = d[1]\n", + "vals = d[2:]\n", + "lat.shape, lon.shape, vals.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "f2ce1d60-0d06-40ba-9c45-e716467972c3", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(array([90., 85., 80.]),\n", + " array([0., 0., 0.]),\n", + " array([251.78068542, 250.66488784, 248.92256676]))" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "lat[:3, 0], lon[:3, 0], vals[0, :3, 0]" + ] + }, + { + "cell_type": "raw", + "id": "916918ad-c592-4dee-9d44-90095a83a9d5", + "metadata": { + "editable": true, + "raw_mimetype": "text/restructuredtext", + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "source": [ + "Please note that regridding with the :ref:`precomputed ` backend only works between a predefined set of global grids. See the :ref:`precomputed_inventory` for details." + ] + }, + { + "cell_type": "markdown", + "id": "42eadd3a-1d4a-46c4-a34a-9fbf8ba15f88", + "metadata": {}, + "source": [ + "#### Plotting the results" + ] + }, + { + "cell_type": "raw", + "id": "d2bdaf2a-5bad-4fbf-b1d4-e002860d2d0a", + "metadata": { + "editable": true, + "raw_mimetype": "text/restructuredtext", + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "source": [ + "We use :xref:`earthkit-plots` to visualise the results." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "91b54b7a-a8dc-4699-b60b-8923231f451a", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import earthkit.plots as ekp\n", + "\n", + "ekp.quickplot(r).show()" + ] + }, + { + "cell_type": "markdown", + "id": "2d465f73-7848-49b5-adc3-697a68760520", + "metadata": {}, + "source": [ + "#### Converting the results to xarray" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "44543f10-44df-4e35-b5a3-33a7a4240b13", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.Dataset> Size: 44kB\n",
+       "Dimensions:    (step: 2, latitude: 37, longitude: 72)\n",
+       "Coordinates:\n",
+       "  * step       (step) timedelta64[ns] 16B 00:00:00 12:00:00\n",
+       "  * latitude   (latitude) float64 296B 90.0 85.0 80.0 75.0 ... -80.0 -85.0 -90.0\n",
+       "  * longitude  (longitude) float64 576B 0.0 5.0 10.0 15.0 ... 345.0 350.0 355.0\n",
+       "Data variables:\n",
+       "    2t         (step, latitude, longitude) float64 43kB ...\n",
+       "Attributes:\n",
+       "    Conventions:  CF-1.8\n",
+       "    institution:  ECMWF
" + ], + "text/plain": [ + " Size: 44kB\n", + "Dimensions: (step: 2, latitude: 37, longitude: 72)\n", + "Coordinates:\n", + " * step (step) timedelta64[ns] 16B 00:00:00 12:00:00\n", + " * latitude (latitude) float64 296B 90.0 85.0 80.0 75.0 ... -80.0 -85.0 -90.0\n", + " * longitude (longitude) float64 576B 0.0 5.0 10.0 15.0 ... 345.0 350.0 355.0\n", + "Data variables:\n", + " 2t (step, latitude, longitude) float64 43kB ...\n", + "Attributes:\n", + " Conventions: CF-1.8\n", + " institution: ECMWF" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "r.to_xarray()" + ] + }, + { + "cell_type": "markdown", + "id": "97c2e3e3-6deb-4df0-a498-168643b1e70e", + "metadata": {}, + "source": [ + "#### Writing the results to disk" + ] + }, + { + "cell_type": "markdown", + "id": "ed089b30-03f7-430a-9f41-17520d5206cd", + "metadata": {}, + "source": [ + "Write the resulting fieldlist to disk:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "ad36951e-9118-46f2-933c-ce5b852341f0", + "metadata": {}, + "outputs": [], + "source": [ + "out_file = \"_res_O32_to_5x5.grib\"\n", + "r.to_target(\"file\", out_file)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "dev", + "language": "python", + "name": "dev" + }, + "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.13.1" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/guide/index.rst b/docs/guide/index.rst new file mode 100644 index 0000000..082a1f1 --- /dev/null +++ b/docs/guide/index.rst @@ -0,0 +1,23 @@ +.. _guide: + +Concepts +============= + + +Regrid +++++++++++++++++++++++ + +.. toctree:: + :maxdepth: 2 + + mir/index + precomputed/index + + +Miscellaneous +++++++++++++++++++++++ + +.. toctree:: + :maxdepth: 1 + + misc/index diff --git a/docs/guide/mir/gridspec.rst b/docs/guide/mir/gridspec.rst new file mode 100644 index 0000000..6a59ffa --- /dev/null +++ b/docs/guide/mir/gridspec.rst @@ -0,0 +1,124 @@ +.. _gridspec: + +Gridspecs (for MIR) +==================================== + +A grid_spec describes spatial grids in the form a dict. + +.. warning:: + + The gridspec format is not finalised yet and may change in future releases. Subarea specification is not yet supported. + +The gridspecs supported by the ``in_grid`` and ``out_grid`` options in :ref:`regrid() ` with the (default) MIR backend are summarised below: + + +Global octahedral reduced Gaussian grid +------------------------------------------ + +The ``grid`` format is:: + + [Oo]XXX + +where *XXX* is the number of latitude lines between the pole and equator. For details about this grid, see `here `_. + +Example: + +.. code-block:: + + {"grid": "O320"} + {"grid": "o320"} + + +Global (non-octahedral) reduced Gaussian grid +------------------------------------------------ + +The ``grid`` format is:: + + [Nn]XXX + +where *XXX* is the number of latitude lines between the pole and equator. For details about this grid, see `here `_. + +Example: + +.. code-block:: + + {"grid": "N320"} + {"grid": "n320"} + + +Global regular (full) Gaussian grid +---------------------------------------- + +The ``grid`` format is:: + + [Ff]XXX + +where *XXX* is the number of latitude lines between the pole and equator. For details about this grid, see `here `_. + + +Global regular latitude-longitude grid +---------------------------------------- + +The ``grid`` format is:: + + [DLON, DLAT] + +where *DLON* and *DLAT* are the increments in degrees in longitudes and latitudes, respectively. This grid definition uses the default scanning mode used at ECMWF: values start at North-West and follow in consecutive rows from West to East, where West is always the 0° meridian. + +Example: + +.. code-block:: + + {"grid": [1, 1]} + + + +HEALPix nested grid +------------------------------------------ + +The ``grid`` format is:: + + [Hh]XXX + +The ``order`` must be set to ``"nested"``. For details about this grid, see `here `_. + +Example: + +.. code-block:: + + {"grid": "H512", "order": "nested"} + {"grid": "h512", "order": "nested"} + + +HEALPix ring grid +------------------------------------------ + +The ``grid`` format is:: + + [Hh]XXX + +The ``order`` can be omitted or set to ``"ring"``. For details about this grid, see `here `_. + +Example: + +.. code-block:: + + {"grid": "H512", "order": "ring"} + {"grid": "H512"} + {"grid": "h512"} + + +.. ORCA grid +.. ------------------------------------------ + +.. The ``grid`` format is:: + +.. eORCAXXX_subtype + +.. The ``subtype`` must be "T", "U", "V" or "W". + +.. Example: + +.. .. code-block:: + +.. {"grid": "eORCA025_T"} diff --git a/docs/guide/mir/index.rst b/docs/guide/mir/index.rst new file mode 100644 index 0000000..a83c4aa --- /dev/null +++ b/docs/guide/mir/index.rst @@ -0,0 +1,11 @@ +.. _mir-backend: + +MIR +================ + +.. toctree:: + :maxdepth: 1 + + regrid_high + regrid_array + gridspec diff --git a/docs/guide/mir/regrid_array.rst b/docs/guide/mir/regrid_array.rst new file mode 100644 index 0000000..fa80af7 --- /dev/null +++ b/docs/guide/mir/regrid_array.rst @@ -0,0 +1,38 @@ +.. _mir-regrid-array: + +regrid (array-level) with MIR +=============================================== + +*New in version 1.0.0.* + +.. py:function:: regrid(data, in_grid=None, out_grid=None, *, interpolation='linear', backend="mir") + :noindex: + + Regrid array ``data`` using **MIR** (Meteorological Interpolation and Regridding). + + The ``backend`` parameter is set to "mir" by default so it is not necessary to specify it explicitly. + + :param data: array representing a single field defined on the ``in_grid``. + :type data: ndarray + :param in_grid: the :ref:`gridspec ` describing the grid that ``data`` are defined on. Ignored when ``data`` is not an ndarray. + :type in_grid: dict, str, :obj:`Grid ` + :param out_grid: the :ref:`gridspec ` describing the target grid that ``data`` will be interpolated onto + :type out_grid: dict, str, :obj:`Grid ` + :param interpolation: the interpolation method. There is a high degree of customisation available to parametrise the available interpolation methods. Please note ot all the interpolation methods support all possible grid types. The possible values are as follows: + + - "linear": Finite Element based interpolation with linear base functions with supporting triangular mesh + - "grid-box-average": input/output grid box (see [model_grid_box]_) intersections interpolation preserving input value integrals (conservative interpolation). + - "nearest-neighbour": choose a nearest neighbouring input point to define output point value + + :type interpolation: str + + :return: Return a tuple with the interpolated values and the :ref:`gridspec ` of the output grid. + :rtype: tuple of ndarray and dict + +Examples +-------- + +- :ref:`/examples/mir/mir_numpy_array.ipynb` +- :ref:`/examples/mir/mir_healpix_fieldlist.ipynb` +- :ref:`/examples/mir/mir_octahedral_fieldlist.ipynb` +- :ref:`/examples/mir/mir_interpolation_types.ipynb` diff --git a/docs/guide/mir/regrid_high.rst b/docs/guide/mir/regrid_high.rst new file mode 100644 index 0000000..88fae54 --- /dev/null +++ b/docs/guide/mir/regrid_high.rst @@ -0,0 +1,40 @@ +.. _mir-regrid-high: + +regrid (high-level) with MIR +=============================================== + +*New in version 1.0.0.* + +.. py:function:: regrid(data, grid=None, *, interpolation='linear', backend="mir") + :noindex: + + Regrid the high-level ``data`` object (with geography information) using **MIR** (Meteorological Interpolation and Regridding). + + The ``backend`` parameter is set to "mir" by default so it is not necessary to specify it explicitly. + + :param data: the following input data types are supported: + + - an earthkit-data GRIB :xref:`fieldlist` (requires :xref:`earthkit-data` >= 1.0.0). + - an earthkit-data GRIB :xref:`field` (requires :xref:`earthkit-data` >= 1.0.0). + - a GRIB message as a bytes or :class:`io.BytesIO` object + - an :class:`xarray.DataArray` or :class:`xarray.Dataset` + + :type data: :xref:`fieldlist`, :xref:`field`, bytes, or :class:`io.BytesIO` + :param grid: the :ref:`grid_spec ` describing the target grid that ``data`` will be interpolated onto + :type grid: dict, str, :class:`Grid` + :param interpolation: the interpolation method. There is a high degree of customisation available to parametrise the available interpolation methods. Please note ot all the interpolation methods support all possible grid types. The possible values are as follows: + + - "linear": Finite Element based interpolation with linear base functions with supporting triangular mesh + - "grid-box-average": input/output grid box (see [model_grid_box]_) intersections interpolation preserving input value integrals (conservative interpolation). + - "nearest-neighbour": choose a nearest neighbouring input point to define output point value + + :type interpolation: str + + +Examples +-------- + +- :ref:`/examples/mir/mir_numpy_array.ipynb` +- :ref:`/examples/mir/mir_healpix_fieldlist.ipynb` +- :ref:`/examples/mir/mir_octahedral_fieldlist.ipynb` +- :ref:`/examples/mir/mir_interpolation_types.ipynb` diff --git a/docs/guide/misc/caching.rst b/docs/guide/misc/caching.rst new file mode 100644 index 0000000..32bf18c --- /dev/null +++ b/docs/guide/misc/caching.rst @@ -0,0 +1,266 @@ +.. _caching: + +Disk-based precomputed weights caching +========================================== + + +.. note:: + + At the moment this configuration is only related to the :ref:`precomputed ` + backends in :func:`regrid`. + + + +Purpose +------- + +earthkit-geo uses a dedicated **directory** to store interpolation matrices and the related index file downloaded from the remote inventory. By default this directory serves a **cache** and is **managed** (its size is checked/limited). It means if we run :func:`regrid` again with the same input and output grid it will load the matrix from the cache instead of downloading it again. Additionally, caching offers **monitoring and disk space management**. When the cache is full, cached data is deleted according to the configuration (i.e. oldest data is deleted first). The cache is implemented by using a sqlite database running in a separate thread. + +Please note that the earthkit-geo cache configuration is managed through the :doc:`config`. + +.. warning:: + + The earthkit-geo cache is intended to be used by a single user. + Sharing cache with **multiple users is not recommended**. + Downloading a local copy of data on a shared disk to have multiple + users working is a different use case and should be supported + through using mirrors. + +.. _cache_location: +.. _cache_policies: + +Cache policies +------------------------------ + +The primary config option to control the cache is ``cache-policy``, which can take the following values: + + - :ref:`user ` (default) + - :ref:`temporary ` + - :ref:`off ` + +The cache location can be read and modified with Python (see the details below). + +.. tip:: + + See the :ref:`/examples/misc/cache.ipynb` notebook for examples. + +.. note:: + + It is recommended to restart your Jupyter kernels after changing + the cache policy or location. + +.. _user_cache_policy: + +User cache policy ++++++++++++++++++++ + +When the ``cache-policy`` is "user" the **cache will be active** and created in a **managed directory** defined by the ``user-cache-directory`` config option. This is the **default** value. + +.. note:: + + The default location of the user cache directory is ``"~/.cache/earthkit-geo"`` and its maximum size is 5 GB. + +The user cache directory is **not cleaned up on exit**. So next time you start earthkit-geo it will be there again unless it is deleted manually or it is set in way that on each startup a different path is assigned to it. Also, when you run multiple sessions of earthkit-geo under the same user they will share the same cache. + +We can query the directory path via the :doc:`config` and also by calling the :meth:`~earthkit.geo.caching.Cache.directory` :ref:`cache method `. + +.. code-block:: python + + >>> from earthkit.geo import cache, config + >>> config.set("cache-policy", "user") + >>> config.get("user-cache-directory") + '/Users/username/.cache/earthkit-geo' + >>> cache.directory() + '/Users/username/.cache/earthkit-geo' + + +The following code shows how to change the ``user-cache-directory`` config option: + +.. code:: python + + >>> from earthkit.geo import config + >>> config.get("user-cache-directory") # Find the current cache directory + '/Users/username/.cache/earthkit-geo' + >>> # Change the value of the setting + >>> config.set("user-cache-directory", "/big-disk/earthkit-geo-cache") + + # Python kernel restarted + + >>> from earthkit.geo import config + >>> config.get("user-cache-directory") # Cache directory has been modified + '/big-disk/earthkit-geo-cache' + +More generally, the earthkit-geo config options can be read, modified, reset +to their default values from Python, +see the :doc:`Configs documentation `. + +.. _temporary_cache_policy: + +Temporary cache policy +++++++++++++++++++++++++ + +When the ``cache-policy`` is "temporary" the **cache will be active and located in a managed** temporary directory created by ``tempfile.TemporaryDirectory``. This directory will be unique for each earthkit-geo session. When the directory object goes out of scope (at the latest on exit) the cache is **cleaned up**. + +Due to the temporary nature of this directory path it cannot be queried via the :doc:`config`, but we need to call the :meth:`~earthkit.geo.caching.Cache.directory` :ref:`cache method `. + +.. code-block:: python + + >>> from earthkit.geo import cache, config + >>> config.set("cache-policy", "temporary") + >>> cache.directory() + '/var/folders/ng/g0zkhc2s42xbslpsywwp_26m0000gn/T/tmp_5bf5kq8' + +We can specify the parent directory for the the temporary cache by using the ``temporary-cache-directory-root`` config option. By default it is set to None (no parent directory specified). + +.. code-block:: python + + >>> from earthkit.geo import cache, config + >>> s = { + ... "cache-policy": "temporary", + ... "temporary-cache-directory-root": "~/my_demo_cache", + ... } + >>> config.set(s) + >>> cache.directory() + '~/my_demo_cache/tmp0iiuvsz5' + + +.. _off_cache_policy: + +Off cache policy +++++++++++++++++++++++++ + +When the ``cache-policy`` is "off" no disk-based caching is available. In this case all files are downloaded into an **unmanaged** temporary directory created by ``tempfile.TemporaryDirectory``. Since caching is disabled, all repeated calls to :func:`regrid` will download the interpolation matrix again! This temporary directory will be unique for each earthkit-geo session. When the directory object goes out of scope (at the latest on exit) the directory will be **cleaned up**. + +Due to the temporary nature of this directory path it cannot be queried via the :doc:`config`, but we need to call the :meth:`~earthkit.geo.caching.Cache.directory` :ref:`cache method `. + +.. code-block:: python + + >>> from earthkit.geo import cache, config + >>> config.set("cache-policy", "off") + >>> cache.directory() + '/var/folders/ng/g0zkhc2s42xbslpsywwp_26m0000gn/T/tmp_5bf5kq8' + +We can specify the parent directory for the the temporary directory by using the ``temporary-directory-root`` config. By default it is set to None (no parent directory specified). + +.. code-block:: python + + >>> from earthkit.geo import cache, config + >>> s = { + ... "cache-policy": "off", + ... "temporary-directory-root": "~/my_demo_tmp", + ... } + >>> config.set(s) + >>> cache.directory() + '~/my_demo_tmp/tmp0iiuvsz5' + + +.. _cache_object: +.. _cache_methods: + +Cache methods +------------------------- + +The cache is controlled by a global object, which we can access as ``earthkit.geo.cache``. + +.. code:: python + + >>> from earthkit.geo import cache + >>> cache + + + +When ``cache-policy`` is :ref:`user ` or :ref:`temporary ` +there are a set of methods available on this object to manage and interact with the cache. + +.. list-table:: Methods/properties of the cache object + :header-rows: 1 + + * - Methods + - Description + + * - :attr:`~earthkit.geo.caching.Cache.policy` + - Get the current cache policy object. + * - :meth:`~earthkit.geo.caching.Cache.directory` + - Return the path to the current cache directory + * - :meth:`~earthkit.geo.caching.Cache.size` + - Return the total number of bytes stored in the cache + * - :meth:`~earthkit.geo.caching.Cache.check_size` + - Check the cache size and trim it down when needed. + * - :meth:`~earthkit.geo.caching.Cache.entries` + - Dump the entries stored in the cache + * - :meth:`~earthkit.geo.caching.Cache.summary_dump_database` + - Return the number of items and total size of the cache + * - :meth:`~earthkit.geo.caching.Cache.purge` + - Delete entries from the cache + +.. warning:: + + :meth:`~earthkit.geo.caching.Cache.check_size` automatically runs when a new + entry is added to the cache or any of the :ref:`cache_config` changes. + +Examples: + +.. code:: python + + >>> from earthkit.geo import cache + >>> cache.policy.name + 'user' + >>> cache.directory() + '/Users/username/.cache/earthkit-geo/'' + >>> cache.size() + 846785699 + >>> cache.summary_dump_database() + (40, 846785699) + >>> d = cache.entries() + >>> len(d) + 40 + >>> d[0].get("creation_date") + '2023-10-30 14:48:31.320322' + + +Cache limits +------------ + +.. warning:: + + These config options do not work when ``cache-policy`` is :ref:`off `. + + + +Maximum-cache-size + The ``maximum-cache-size`` setting ensures that earthkit-geo does not + use to much disk space. Its value sets + the maximum disk space used by earthkit-geo cache. When earthkit-geo cache disk + usage goes above this limit, earthkit-geo triggers its cache cleaning mechanism before + downloading additional data. The value of cache-maximum-size is + absolute (such as "10G", "10M", "1K"). To disable it use None. + +Maximum-cache-disk-usage + The ``maximum-cache-disk-usage`` setting ensures that earthkit-geo + does not fill your disk. It specifies the maximum disk usage (as a percentage) on the filesystem + containing the cache directory. When the total disk usage (so this is not the cache usage alone) goes above + this limit, earthkit-geo triggers its cache cleaning mechanism to free up space before + downloading additional data. + The value of maximum-cache-disk-usage is relative (such as "90%" or "100%"). + To disable it use None. + +.. warning:: + If your disk is filled by another application, earthkit-geo will happily + delete its cached data to make room for the other application as soon + as it has a chance. + + +.. .. note:: +.. When tweaking the cache config, it is recommended to set the +.. ``maximum-cache-size`` to a value below the user disk quota (if applicable) +.. and ``maximum-cache-disk-usage`` to ``None``. + + +.. _cache_config: + +Cache config parameters +------------------------------- + +.. module-output:: generate_config_rst cache-policy maximum-cache-disk-usage maximum-cache-size temporary-cache-directory-root user-cache-directory + +Other earthkit-geo config options can be found :ref:`here `. diff --git a/docs/guide/misc/config.rst b/docs/guide/misc/config.rst new file mode 100644 index 0000000..f206ba4 --- /dev/null +++ b/docs/guide/misc/config.rst @@ -0,0 +1,171 @@ +.. _config: + +Configuration +============= + +*New in version 1.0.0.* + + +.. note:: + + At the moment this configuration is only related to the :ref:`precomputed ` + backends in :func:`regrid`. + + +*earthkit-geo* maintains a global configuration. + +The configuration is automatically loaded from and saved into a yaml file located at ``~/.config/earthkit/geo/config.yaml``. An alternative path can be specified via the ``EARTHKIT_GEO_CONFIG_FILE`` environmental variable (it is only read at startup). + +The configuration can be accessed and modified from Python. The configuration options can also be defined as :ref:`environment variables `, which take precedence over the config file. + +See the following notebooks for examples: + + - :ref:`/examples/misc/config.ipynb` + - :ref:`/examples/misc/config_env_vars.ipynb` + + +.. _config_get: + +Accessing configuration options +-------------------------------- + +The earthkit-geo configuration can be accessed using the python API: + +.. literalinclude:: include/config-get.py + +.. warning:: + + When an :ref:`environment variable ` is set, it takes precedence over the config parameter, and its value is returned from :func:`get() `. + +.. _config_set: + +Changing configuration +------------------------- + +.. note:: + + It is recommended to restart your Jupyter kernels after changing + or resetting config options. + +The earthkit-geo configuration can be modified using the python API: + +.. literalinclude:: include/config-set.py + +.. warning:: + + When an :ref:`environment variable ` is set, the new value provided for :func:`set() ` is saved into the config file but :func:`get() ` wil still return the value of the environment variable. A warning is also generated. + + +.. _config_temporary: + +Temporary configuration +------------------------ + +We can create a temporary configuration (as a context manager) as a copy of the original configuration. We will still refer to it as “config”, but it is completely independent from the original object and changes are not saved into the yaml file (even when ``config.autosave`` is True). + +.. literalinclude:: include/config-temporary.py + +Output:: + + 30 + 5 + 11 + +.. warning:: + + When an :ref:`environment variable ` is set, the same rules applies as for :func:`set() `. + + +.. _config_reset: + +Resetting configuration +------------------------ + +.. note:: + + It is recommended to restart your Jupyter kernels after changing + or resetting the configuration. + +The earthkit-geo configuration can be reset using the python API: + +.. literalinclude:: include/config-reset.py + +.. warning:: + + When an :ref:`environment variable ` is set, the same rules applies as for :func:`set() `. + + +.. _config_env: + +Environment variables +---------------------- + +Each configuration parameter has a corresponding environment variable (see the full list :ref:`here `). When an environment variable is set, it takes precedence over the config parameter as the following examples show. + +First, let us assume that the value of ``url-download-timeout`` is 30 in the config file and no environment variable is set. + +.. code-block:: python + + >>> from earthkit.geo import config + >>> config.get("url-download-timeout") + 30 + +Then, set the environment variable ``EARTHKIT_GEO_URL_DOWNLOAD_TIMEOUT``. + +.. code-block:: bash + + export EARTHKIT_GEO_URL_DOWNLOAD_TIMEOUT=5 + + +.. code-block:: python + + >>> from earthkit.geo import config + >>> config.get("url-download-timeout") + 5 + >>> config.env() + {'url-download-timeout': ('EARTHKIT_GEO_URL_DOWNLOAD_TIMEOUT', '5')} + >>> config.set("url-download-timeout", 10) + UserWarning: Config option 'url-download-timeout' is also set by environment variable + 'EARTHKIT_GEO_URL_DOWNLOAD_TIMEOUT'.The environment variable takes precedence and + its value is returned when calling get(). Still, the value set here will be + saved to the config file. + >>> config.get("url-download-timeout") + 5 + +Finally, unset the environment variable and check the config value again, which is now the value from the config file. + +.. code-block:: bash + + unset EARTHKIT_GEO_URL_DOWNLOAD_TIMEOUT + + +.. code-block:: python + + >>> from earthkit.geo import config + >>> config.get("url-download-timeout") + 10 + + +See also the following notebook: + + - :ref:`/examples/misc/config_env_vars.ipynb` + + +.. _config_table: + +List of configuration parameters +----------------------------------- + +This is the list of all the config parameters: + +.. module-output:: generate_config_rst + + +.. _config_env_table: + +List of environment variables +--------------------------------- + +This is the list of the config environment variables: + +.. module-output:: generate_config_env_rst diff --git a/docs/guide/misc/include/config-get.py b/docs/guide/misc/include/config-get.py new file mode 100644 index 0000000..1072a46 --- /dev/null +++ b/docs/guide/misc/include/config-get.py @@ -0,0 +1,9 @@ +import earthkit.regrid + +# Access one of the config options +cache_path = earthkit.regrid.config.get("user-cache-directory") +print(cache_path) + +# If this is the last line of a Notebook cell, this +# will display a table with all the current configuration +earthkit.regrid.config diff --git a/docs/guide/misc/include/config-reset.py b/docs/guide/misc/include/config-reset.py new file mode 100644 index 0000000..d1b58dd --- /dev/null +++ b/docs/guide/misc/include/config-reset.py @@ -0,0 +1,7 @@ +import earthkit.regrid + +# Reset a named config option to its default value +earthkit.regrid.config.reset("user-cache-directory") + +# Reset all the config options to their default values +earthkit.regrid.config.reset() diff --git a/docs/guide/misc/include/config-set.py b/docs/guide/misc/include/config-set.py new file mode 100644 index 0000000..f0edba7 --- /dev/null +++ b/docs/guide/misc/include/config-set.py @@ -0,0 +1,16 @@ +import earthkit.regrid + +# Change the location of the user defined cache: +earthkit.regrid.config.set("user-cache-directory", "/big-disk/earthkit-regrid-cache") + +# Change the download timeout +earthkit.regrid.config.set("url-download-timeout", "1m") + +# Multiple values can be set together. The argument list +# can be a dictionary: +earthkit.regrid.config.set({"url-download-timeout": "1m", "check-out-of-date-urls": True}) + +# Alternatively, we can use keyword arguments. However, because +# the “-” character is not allowed in variable names in Python we have +# to replace “-” with “_” in all the keyword arguments: +earthkit.regrid.config.set(url_download_timeout="1m", check_out_of_date_urls=True) diff --git a/docs/guide/misc/include/config-temporary.py b/docs/guide/misc/include/config-temporary.py new file mode 100644 index 0000000..e653ff0 --- /dev/null +++ b/docs/guide/misc/include/config-temporary.py @@ -0,0 +1,11 @@ +import earthkit.regrid + +print(earthkit.regrid.config.get("url-download-timeout")) + +with earthkit.regrid.config.temporary(): + earthkit.regrid.config.set("url-download-timeout", 5) + print(earthkit.regrid.config.get("url-download-timeout")) + +# Temporary config can also be created with arguments: +with earthkit.regrid.config.temporary("url-download-timeout", 11): + print(earthkit.regrid.config.get("url-download-timeout")) diff --git a/docs/guide/misc/index.rst b/docs/guide/misc/index.rst new file mode 100644 index 0000000..b0c21d3 --- /dev/null +++ b/docs/guide/misc/index.rst @@ -0,0 +1,6 @@ + +.. toctree:: + :maxdepth: 1 + + config.rst + caching.rst diff --git a/docs/guide/misc/local/index.rst b/docs/guide/misc/local/index.rst new file mode 100644 index 0000000..1364114 --- /dev/null +++ b/docs/guide/misc/local/index.rst @@ -0,0 +1,9 @@ +.. _precomputed-local-backend: + +precomputed-local +=================== + +.. toctree:: + :maxdepth: 1 + + regrid diff --git a/docs/guide/misc/local/regrid.rst b/docs/guide/misc/local/regrid.rst new file mode 100644 index 0000000..4f4a959 --- /dev/null +++ b/docs/guide/misc/local/regrid.rst @@ -0,0 +1,38 @@ +.. _precomputed-local-regrid: + +regrid +=========================================== + +*New in version 0.5.0.* + + +.. py:function:: regrid(values, in_grid=None, out_grid=None, interpolation='linear', output="values_gridspec", backend="precomputed-local", inventory_path=None) + :noindex: + + Regrid the ``values`` using precomputed weights stored at a local path. + + :param values: the following input data types are supported: + + - an ndarray representing a single field defined on the ``in_grid``. A valid ``in_grid`` must be specified. + - an earthkit-data GRIB :xref:`fieldlist` (requires :xref:`earthkit-data` >= 0.6.0). The input grid is automatically detected from the data (``in_grid`` is ignored). It only works when the ``out_grid`` is a regular latitude-longitude grid. + - an earthkit-data GRIB :xref:`field` (requires :xref:`earthkit-data` >= 0.6.0). The input grid is automatically detected from the data (``in_grid`` is ignored). It only works when the ``out_grid`` is a regular latitude-longitude grid. + + :type values: ndarray, :xref:`fieldlist`, :xref:`field` + :param in_grid: the :ref:`gridspec ` describing the grid that ``values`` are defined on. Ignored when ``values`` is not an ndarray. + :type in_grid: dict + :param out_grid: the :ref:`gridspec ` describing the target grid that ``values`` will be interpolated onto + :type out_grid: dict + :param interpolation: the interpolation method. Possible values are ``linear`` and ``nearest-neighbour``. For ``nearest-neighbour`` the following aliases are also supported: ``nn``, ``nearest-neighbor``. + :type interpolation: str + :param output: define what is returned when the input is an array, ignored otherwise. Possible values are as follows: + + - "values_gridpec": return a tuple with the interpolated values and the :ref:`gridspec ` of the output grid. This is the default option. + - "values": return the interpolated values only + - "gridpec": return the :ref:`gridspec ` of the output grid only + + :type output: str + :return: see the ``output`` parameter for details + + The interpolation only works when a pre-computed interpolation weights are available for the given ``in_grid``, ``out_grid`` and ``interpolation`` combination in the local inventory specified by ``inventory_path``. + + If the weights are available the interpolation is performed by multiplying the ``values`` vector with it (matrix-vector multiplication). diff --git a/docs/guide/precomputed/gridspec.rst b/docs/guide/precomputed/gridspec.rst new file mode 100644 index 0000000..bbce8a7 --- /dev/null +++ b/docs/guide/precomputed/gridspec.rst @@ -0,0 +1,114 @@ +.. _gridspec-precomputed: + +Gridspecs (for precomputed weights) +===================================== + +A gridspec describes spatial grids in the form a dict. + +.. warning:: + + The gridspec format is not finalised yet and may change in future releases. Subarea specification is not yet supported. + +The gridspecs supported by the ``in_grid`` and ``out_grid`` options in ``regrid()`` with the :ref:`precomputed ` and the :ref:`precomputed-local ` backends are summarised below: + + +Global octahedral reduced Gaussian grid +------------------------------------------ + +The ``grid`` format is:: + + [Oo]XXX + +where *XXX* is the number of latitude lines between the pole and equator. For details about this grid, see `here `_. + +Example: + +.. code-block:: + + {"grid": "O320"} + {"grid": "o320"} + + +Global (non-octahedral) reduced Gaussian grid +------------------------------------------------ + +The ``grid`` format is:: + + [Nn]XXX + +where *XXX* is the number of latitude lines between the pole and equator. For details about this grid, see `here `_. + +Example: + +.. code-block:: + + {"grid": "N320"} + {"grid": "n320"} + + +Global regular latitude-longitude grid +---------------------------------------- + +The ``grid`` format is:: + + [DLON, DLAT] + +where *DLON* and *DLAT* are the increments in degrees in longitudes and latitudes, respectively. This grid definition uses the default scanning mode used at ECMWF: values start at North-West and follow in consecutive rows from West to East, where West is always the 0° meridian. + +Example: + +.. code-block:: + + {"grid": [1, 1]} + + + +HEALPix nested grid +------------------------------------------ + +The ``grid`` format is:: + + [Hh]XXX + +The ``order`` must be set to ``"nested"``. For details about this grid, see `here `_. + +Example: + +.. code-block:: + + {"grid": "H512", "order": "nested"} + {"grid": "h512", "order": "nested"} + + +HEALPix ring grid +------------------------------------------ + +The ``grid`` format is:: + + [Hh]XXX + +The ``order`` can be omitted or set to ``"ring"``. For details about this grid, see `here `_. + +Example: + +.. code-block:: + + {"grid": "H512", "order": "ring"} + {"grid": "H512"} + {"grid": "h512"} + + +ORCA grid +------------------------------------------ + +The ``grid`` format is:: + + eORCAXXX_subtype + +The ``subtype`` must be "T", "U", "V" or "W". + +Example: + +.. code-block:: + + {"grid": "eORCA025_T"} diff --git a/docs/guide/precomputed/index.rst b/docs/guide/precomputed/index.rst new file mode 100644 index 0000000..d690ea6 --- /dev/null +++ b/docs/guide/precomputed/index.rst @@ -0,0 +1,12 @@ +.. _precomputed-backend: + +precomputed +================ + +.. toctree:: + :maxdepth: 1 + + regrid_high + regrid_array + gridspec + inventory/index diff --git a/docs/guide/precomputed/inventory/healpix_nested.rst b/docs/guide/precomputed/inventory/healpix_nested.rst new file mode 100644 index 0000000..a8d94fd --- /dev/null +++ b/docs/guide/precomputed/inventory/healpix_nested.rst @@ -0,0 +1,4 @@ +healpix (nested) +========================= + +.. module-output:: generate_inventory_rst healpix_nested "HELAPix nested" diff --git a/docs/guide/precomputed/inventory/healpix_ring.rst b/docs/guide/precomputed/inventory/healpix_ring.rst new file mode 100644 index 0000000..1b26b2f --- /dev/null +++ b/docs/guide/precomputed/inventory/healpix_ring.rst @@ -0,0 +1,4 @@ +healpix (ring) +========================= + +.. module-output:: generate_inventory_rst healpix_ring "HEALPix ring" diff --git a/docs/guide/precomputed/inventory/index.rst b/docs/guide/precomputed/inventory/index.rst new file mode 100644 index 0000000..e815761 --- /dev/null +++ b/docs/guide/precomputed/inventory/index.rst @@ -0,0 +1,18 @@ +.. _precomputed_inventory: + +Precomputed weights +======================= + +.. include:: pre_gen_warn.rst + +The pages below contain all the **source and target gridspec** combinations for which precomputed weights are available. The information is grouped by source grid type. + +.. toctree:: + :maxdepth: 1 + + reduced_gg_o + reduced_gg + healpix_ring + healpix_nested + regular_ll + orca diff --git a/docs/guide/precomputed/inventory/orca.rst b/docs/guide/precomputed/inventory/orca.rst new file mode 100644 index 0000000..e9c6dac --- /dev/null +++ b/docs/guide/precomputed/inventory/orca.rst @@ -0,0 +1,9 @@ +.. _orca_inventory: + +orca +============== + +.. note:: + Currently, only the ``linear`` and ``nearest-neighbour`` interpolation methods are supported for ORCA grids. + +.. module-output:: generate_inventory_rst orca "ORCA" diff --git a/docs/guide/precomputed/inventory/pre_gen_warn.rst b/docs/guide/precomputed/inventory/pre_gen_warn.rst new file mode 100644 index 0000000..d1ff36c --- /dev/null +++ b/docs/guide/precomputed/inventory/pre_gen_warn.rst @@ -0,0 +1,6 @@ +.. warning:: + + With the :ref:`precomputed ` backend we can only perform the regridding if the pre-generated interpolation weights for the given source and target gridspec combination are available. At the moment, the support is limited to the following cases: + + - only global grids are supported + - for regular latitude-longitude grids only the default scanning mode used at ECMWF is supported (values start at North-West and follow in consecutive rows from West to East) diff --git a/docs/guide/precomputed/inventory/reduced_gg.rst b/docs/guide/precomputed/inventory/reduced_gg.rst new file mode 100644 index 0000000..6a8e5f4 --- /dev/null +++ b/docs/guide/precomputed/inventory/reduced_gg.rst @@ -0,0 +1,4 @@ +reduced_gg +============== + +.. module-output:: generate_inventory_rst reduced_gg "reduced gaussian" diff --git a/docs/guide/precomputed/inventory/reduced_gg_o.rst b/docs/guide/precomputed/inventory/reduced_gg_o.rst new file mode 100644 index 0000000..c9bef30 --- /dev/null +++ b/docs/guide/precomputed/inventory/reduced_gg_o.rst @@ -0,0 +1,4 @@ +reduced_gg (octahedral) +========================= + +.. module-output:: generate_inventory_rst reduced_gg_o "octahedral reduced gaussian" diff --git a/docs/guide/precomputed/inventory/regular_ll.rst b/docs/guide/precomputed/inventory/regular_ll.rst new file mode 100644 index 0000000..c718429 --- /dev/null +++ b/docs/guide/precomputed/inventory/regular_ll.rst @@ -0,0 +1,4 @@ +regular_ll +============== + +.. module-output:: generate_inventory_rst regular_ll "global regular latitude-longitude" diff --git a/docs/guide/precomputed/memory_cache.rst b/docs/guide/precomputed/memory_cache.rst new file mode 100644 index 0000000..c47a8fc --- /dev/null +++ b/docs/guide/precomputed/memory_cache.rst @@ -0,0 +1,197 @@ +.. _mem_cache: + +In-memory weights caching +=========================== + +.. note:: + + This caching is only related to the :ref:`precomputed ` + and :ref:`precomputed-local ` backends in :func:`regrid`. + + +Purpose +------- + +earthkit-geo provides an **in-memory cache** for interpolation pre-computed interpolation weights. When it is enabled, weights loaded from the disk are stored in memory and when we call :func:`regrid` with the same grids they do not have to be loaded from disk again. The cache can be configured to have a maximum size and eviction policy. + +.. note:: + + Please note that the earthkit-geo in-memory cache configuration is managed through the :doc:`config`. + +.. _mem_cache_policies: + +In-memory cache policies +---------------------------- + +The primary config option to control the in-memory cache is ``weights-memory-cache-policy``, which can take the following values: + + - :ref:`largest ` (default) + - :ref:`lru ` + - :ref:`unlimited ` + - :ref:`off ` + + +.. _largest_mem_cache_policy: + +Largest cache policy +++++++++++++++++++++++ + +When the ``weights-memory-cache-policy`` is "largest" first evicts the largest matrices from the in-memory cache (default). The cache eviction policy is applied before loading the weights to ensure that it will fit into the cache. When it is not possible the behaviour depends on the :ref:`weights-memory-cache-strict-mode ` option. The maximum memory size of the in-memory cache is defined by the :ref:`maximum-weights-memory-cache-size ` option. The default is 500 MB. + +.. code-block:: python + + >>> from earthkit.geo import cache, config + >>> config.set("weights-memory-cache-policy", "user") + >>> config.get("weights-memory-cache-policy") + 'user' + >>> config.get("maximum-weights-memory-cache-size") + 524288000 + >>> config.get("weights-memory-cache-strict-mode") + False + + +.. _lru_mem_cache_policy: + +LRU cache policy +++++++++++++++++++++++ + +When the ``weights-memory-cache-policy`` is "lru" first evicts the least recently used matrices from the in-memory cache. The cache eviction policy is applied before loading the weights to ensure that it will fit into the cache. When it is not possible the behaviour depends on the :ref:`weights-memory-cache-strict-mode ` option. The maximum memory size of the in-memory cache is defined by the :ref:`maximum-weights-memory-cache-size ` option. The default is 500 MB. + +.. code-block:: python + + >>> from earthkit.geo import cache, config + >>> config.set("weights-memory-cache-policy", "lru") + >>> config.get("weights-memory-cache-policy") + 'lru' + >>> config.get("maximum-weights-memory-cache-size") + 524288000 + >>> config.get("weights-memory-cache-strict-mode") + False + + +.. _unlimited_mem_cache_policy: + +Unlimited cache policy +++++++++++++++++++++++ + +When the ``weights-memory-cache-policy`` is "unlimited" will keep all matrices in memory. + +.. code-block:: python + + >>> from earthkit.geo import cache, config + >>> config.set("weights-memory-cache-policy", "unlimited") + >>> config.get("weights-memory-cache-policy") + 'unlimited' + + +.. _off_mem_cache_policy: + +Off cache policy +++++++++++++++++++++++ + +When the ``weights-memory-cache-policy`` is "off" there is no cache, the matrices are always loaded from disk. + + +.. code-block:: python + + >>> from earthkit.geo import cache, config + >>> config.set("weights-memory-cache-policy", "off") + >>> config.get("weights-memory-cache-policy") + 'off' + +.. _mem_cache_state: + +Getting the state of the in-memory cache +------------------------------------------ + +The current status of the in-memory cache can be retrieved using the :func:`memory_cache_info` function. It returns a namedtuple with fields ``hits``, ``misses``, ``maxsize``, ``currsize``, ``count`` and ``policy``. + +.. code:: python + + >>> from earthkit.geo import memory_cache_info + >>> memory_cache_info() + CacheInfo(hits=9, misses=1, maxsize=524288000, currsize=259170724, count=1, policy='largest') + + +.. _mem_cache_clear: + +Clearing the in-memory cache +----------------------------- + +The in-memory cache can be cleared using the :func:`clear_memory_cache` function. + +.. code:: python + + >>> from earthkit.geo import clear_memory_cache + >>> clear_memory_cache() + >>> memory_cache_info() + CacheInfo(hits=0, misses=0, maxsize=524288000, currsize=0, count=0, policy='largest') + +.. _mem_cache_limits: + +In-memory cache limits +---------------------------- + +.. warning:: + + These config options are only used when ``weights-memory-cache-policy`` is :ref:`largest ` or :ref:`lru `. + +maximum-weights-memory-cache-size + The ``maximum-weights-memory-cache-size`` option defines the maximum memory size of the in-memory cache in bytes. The default is 500 MB. + +weights-memory-cache-strict-mode + When the ``weights-memory-cache-strict-mode`` option is ``True``, raises ValueError if the weights cannot be fitted into the cache. If ``False`` and the weights cannot be fitted into the cache it simply does not load the weights into the cache. The default is ``False``. + + + +.. _mem_cache_config: + +In-memory cache config parameters +------------------------------------ + +.. module-output:: generate_config_rst weights-memory-cache-policy maximum-weights-memory-cache-size weights-memory-cache-strict-mode + +Other earthkit-geo config options can be found :ref:`here `. + + + +Notebooks +--------- + +- :ref:`/examples/precomputed/memory_cache.ipynb` + + +Examples +-------- + +.. code-block:: python + + import numpy as np + from earthkit.geo import regrid, config + + # set memory cache with a maximum size of 100 MB to evict the largest matrices first + config.set( + weights_memory_cache_policy="largest", + maximum_weights_memory_cache_size=100 * 1024**2, + ) + print(memory_cache_info()) + + # create a random data array and regrid it + data = np.random.rand(5248) + interpolated_data = regrid( + data, in_grid={"grid": "O32"}, out_grid={"grid": [5, 5]}, backend="precomputed" + ) + print(memory_cache_info()) + + # repeat interpolation, this time the weights are loaded from the cache + data = np.random.rand(5248) + interpolated_data = regrid( + data, in_grid={"grid": "O32"}, out_grid={"grid": [5, 5]}, backend="precomputed" + ) + print(memory_cache_info()) + +output: :: + + CacheInfo(hits=0, misses=0, maxsize=104857600, currsize=0, count=0, policy='largest') + CacheInfo(hits=0, misses=1, maxsize=104857600, currsize=102340, count=1, policy='largest') + CacheInfo(hits=1, misses=1, maxsize=104857600, currsize=102340, count=1, policy='largest') diff --git a/docs/guide/precomputed/regrid_array.rst b/docs/guide/precomputed/regrid_array.rst new file mode 100644 index 0000000..8050a47 --- /dev/null +++ b/docs/guide/precomputed/regrid_array.rst @@ -0,0 +1,31 @@ +.. _precomputed-regrid-array: + +regrid (array-level) with precomputed weights +======================================================== + +*New in version 0.5.0.* + +.. py:function:: regrid(date, in_grid=None, out_grid=None, *, interpolation='linear', backend="precomputed", inventory="ecmwf") + :noindex: + + Regrid array ``data`` using precomputed weights. + + :param data: array representing a single field defined on the ``in_grid``. + :type data: ndarray + :param in_grid: the :ref:`gridspec ` describing the grid that ``data`` are defined on. + :type in_grid: dict + :param out_grid: the :ref:`gridspec ` describing the target grid that ``data`` will be interpolated onto + :type out_grid: dict + :param interpolation: the interpolation method. Possible values are ``linear`` and ``nearest-neighbour``. For ``nearest-neighbour`` the following aliases are also supported: ``nn``, ``nearest-neighbor``. + :type interpolation: str + :param inventory: the path to the inventory of the precomputed weights. The interpolation only works when the weights are available for the given ``in_grid``, ``out_grid`` and ``interpolation`` combination. At present, two inventory types are available: + + - If ``inventory`` is "ecmwf" on None, the remote inventory managed by ECMWF is used. In this case the weights are automatically downloaded and stored in a local cache (at ``"~/.cache/earthkit-regrid"``) and when it is needed again the cached version is used. See the :ref:`inventory ` for the list of supported grid to grid combinations with this backend. + - If ``inventory`` is a local path, a local inventory is used. Please note this in experimental feature only used for development purposes. + :type inventory: str + :return: Return a tuple with the interpolated values and the :ref:`gridspec ` of the output grid. + :rtype: tuple of ndarray and dict + :raises ValueError: if the precomputed weights are not available + + + The regridding is performed by multiplying the ``values`` vector with the interpolation weights, which forms a sparse matrix (sparse matrix) -vector multiplication). diff --git a/docs/guide/precomputed/regrid_high.rst b/docs/guide/precomputed/regrid_high.rst new file mode 100644 index 0000000..b778f82 --- /dev/null +++ b/docs/guide/precomputed/regrid_high.rst @@ -0,0 +1,33 @@ +.. _precomputed-regrid-high : + +regrid (high-level) with precomputed weights +============================================================= + +*New in version 0.5.0.* + +.. py:function:: regrid(data, grid=None, *, interpolation='linear', backend="precomputed", inventory="ecmwf") + :noindex: + + Regrid the high-level ``data`` object (with geography information) using precomputed weights. + + :param data: the input data. The following types are supported: + + - an earthkit-data GRIB :xref:`fieldlist` (requires :xref:`earthkit-data` >= 0.6.0). + - an earthkit-data GRIB :xref:`field` (requires :xref:`earthkit-data` >= 0.6.0). + - an :class:`xarray.DataArray` or :class:`xarray.Dataset` + :type data: :xref:`fieldlist`, :xref:`field` + :param grid: the :ref:`gridspec ` describing the target grid that ``data`` will be interpolated onto + :type grid: dict + :param interpolation: the interpolation method. Possible values are ``linear`` and ``nearest-neighbour``. For ``nearest-neighbour`` the following aliases are also supported: ``nn``, ``nearest-neighbor``. + :type interpolation: str + :param inventory: the path to the inventory of the precomputed weights. The interpolation only works when the weights are available for the given input grid (automatically determined from the data), target ``grid`` and ``interpolation`` combination. At present, two inventory types are available: + + - If ``inventory`` is "ecmwf" on None, the remote inventory managed by ECMWF is used. In this case the weights are automatically downloaded and stored in a local cache (at ``"~/.cache/earthkit-regrid"``) and when it is needed again the cached version is used. See the :ref:`inventory ` for the list of supported grid to grid combinations with this backend. + - If ``inventory`` is a local path, a local inventory is used. Please note this in experimental feature only used for development purposes. + :type inventory: str + :return: The same type of data as ``data`` containing the interpolated values. + :rtype: :xref:`fieldlist`, :xref:`field` + :raises ValueError: if the precomputed weights are not available + + + The regridding is performed by multiplying the ``data`` vector with the interpolation weights, which forms a sparse matrix (sparse matrix) -vector multiplication). diff --git a/docs/guide/regrid/index.rst b/docs/guide/regrid/index.rst new file mode 100644 index 0000000..13052b9 --- /dev/null +++ b/docs/guide/regrid/index.rst @@ -0,0 +1,10 @@ +.. _regrid-overview: + +Overview +================ + +.. toctree:: + :maxdepth: 1 + + regrid_high + regrid_array diff --git a/docs/guide/regrid/regrid_array.rst b/docs/guide/regrid/regrid_array.rst new file mode 100644 index 0000000..9cea568 --- /dev/null +++ b/docs/guide/regrid/regrid_array.rst @@ -0,0 +1,21 @@ +.. _regrid-array-overview: + +regrid (array-level) +=============================== + +.. py:function:: regrid(data, in_grid=None, out_grid=None, *, interpolation="linear", backend="mir", **kwargs) + + Regrid the array ``data`` with the given ``backend`` and options. To see the available ``**kwargs`` please refer to the documentation of the specific backend. The default backend is :ref:`mir `. + + The following ``backends``\ s are available: + + .. list-table:: + :widths: 25 75 + :header-rows: 1 + + * - Backend + - Description + * - :ref:`mir ` + - use ECMWF's **Meteorological Interpolation and Regridding library (MIR)** to perform the regridding + * - :ref:`precomputed ` + - use precomputed interpolation weights diff --git a/docs/guide/regrid/regrid_high.rst b/docs/guide/regrid/regrid_high.rst new file mode 100644 index 0000000..123132a --- /dev/null +++ b/docs/guide/regrid/regrid_high.rst @@ -0,0 +1,29 @@ +.. _regrid-high-overview: + +regrid (high-level) +=============================== + +.. py:function:: regrid(data, grid=None, *, interpolation="linear", backend="mir", **kwargs) + + Regrid the high-level ``data`` object (with geography information) using the given ``backend`` and options. The ``data`` can be one of the following types: + + - an earthkit-data :xref:`fieldlist` + - an earthkit-data :xref:`field` + - a GRIB message as a bytes or :class:`io.BytesIO` object (for ``backend="mir"`` only) + - an :class:`xarray.DataArray` or :class:`xarray.Dataset` + + + To see the available ``**kwargs`` please refer to the documentation of the specific backend. The default backend is :ref:`mir `. + + The following ``backends``\ s are available: + + .. list-table:: + :widths: 25 75 + :header-rows: 1 + + * - Backend + - Description + * - :ref:`mir ` + - use ECMWF's **Meteorological Interpolation and Regridding library (MIR)** to perform the regridding. This is the default backend. + * - :ref:`precomputed ` + - use precomputed interpolation weights diff --git a/docs/index.rst b/docs/index.rst index d4ff1a8..fa966cf 100644 --- a/docs/index.rst +++ b/docs/index.rst @@ -21,42 +21,82 @@ Welcome to earthkit-geo's documentation **earthkit-geo** is a Python package providing geospatial computations. It is part of the :xref:`earthkit` ecosystem. +The API features the :func:`regrid` function taking inputs of Numpy arrays, earthkit-data GRIB :xref:`field` or :xref:`fieldlist` objects, and Xarray DataArrays or Datasets. It is implemented with various backends, the :ref:`default backend ` uses ECMWF's **MIR (Meteorological Interpolation and Regridding)** library to perform the regridding. + + +Quick start +----------- + +A different interface is available depending on the input data type. + +High-level interface +////////////////////// + +Use it for data containing geographical information, e.g. earthkit-data :xref:`fieldlist` objects, Xarray DataArrays or Datasets. + +.. code-block:: python + + import earthkit.data as ekd + from earthkit.geo.regrid import regrid + + # get fieldlist from a sample GRIB file + ds = ekd.from_source("sample", "O32_t2.grib2") + + # the target is a regular latitude-longitude grid + grid = {"grid": [5, 5]} + + ds_res = regrid(ds, grid=grid) + + +Array-level interface +//////////////////////// + +Use it for raw data arrays, e.g. Numpy ndarrays. + + +.. code-block:: python + + from earthkit.geo.regrid.array import regrid + import numpy as np + + vals = np.random.rand(320, 640) + in_grid = {"grid": [0.25, 0.25]} # regular latitude-longitude grid + out_grid = {"grid": "O320"} # octahedral reduced Gaussian grid + + res_vals, res_grid = regrid(vals, in_grid=in_grid, out_grid=out_grid) + + .. toctree:: :maxdepth: 1 - :caption: Examples + :caption: User guide + install examples/index + guide/index + references.rst + API Reference .. toctree:: :maxdepth: 1 - :caption: Documentation + :caption: Developer guide + + development - API Reference - references.rst .. toctree:: :maxdepth: 1 - :caption: Installation + :caption: Extra - install release_notes/index - development licence + :ref:`genindex` + .. toctree:: :maxdepth: 1 :caption: Projects earthkit - - - -Indices and tables -================== - -* :ref:`genindex` - -.. * :ref:`modindex` -.. * :ref:`search` + earthkit-data diff --git a/docs/release_notes/version_0.2_updates.rst b/docs/release_notes/version_0.2_updates.rst index edf0d5f..137060e 100644 --- a/docs/release_notes/version_0.2_updates.rst +++ b/docs/release_notes/version_0.2_updates.rst @@ -7,7 +7,7 @@ Version 0.2.0 New features ++++++++++++++++ -- added methods :py:meth:`earthkit.geo.rotate.rotate` and :py:meth:`earthkit.geo.rotate.unrotate` to perform spehrical rotation. See the notebook example: :ref:`/examples/rotate.ipynb` +- added methods :py:meth:`earthkit.geo.rotate.rotate` and :py:meth:`earthkit.geo.rotate.unrotate` to perform spehrical rotation. See the notebook example: :ref:`/examples/geo/rotate.ipynb` - added methods :py:meth:`earthkit.geo.rotate.rotate_vector` and :py:meth:`earthkit.geo.rotate.unrotate_vector` to perform local rotation of vectors. - added methods :py:meth:`earthkit.geo.coord.latlon_to_xyz` and :py:meth:`earthkit.geo.coord.xyz_to_latlon` to convert between [ECEF]_ and geodetic coordinates. - renamed :py:attr:`earthkit.geo.constants.NORTH` to :py:attr:`earthkit.geo.constants.NORTH_POLE_LAT` and added :py:attr:`earthkit.geo.constants.SOUTH_POLE_LAT` diff --git a/docs/release_notes/version_0.3_updates.rst b/docs/release_notes/version_0.3_updates.rst index 52f6469..c368dca 100644 --- a/docs/release_notes/version_0.3_updates.rst +++ b/docs/release_notes/version_0.3_updates.rst @@ -7,5 +7,5 @@ Version 0.3.0 New features ++++++++++++++++ -- added :py:meth:`earthkit.geo.cartography.country_polygons` to get the combined geometry of one or more countries by name from Natural Earth's shapefiles. See the notebook example: :ref:`/examples/country_polygons.ipynb` +- added :py:meth:`earthkit.geo.cartography.country_polygons` to get the combined geometry of one or more countries by name from Natural Earth's shapefiles. See the notebook example: :ref:`/examples/geo/country_polygons.ipynb` - added :py:meth:`earthkit.geo.cartography.multipolygon_to_coordinates` to convert a shapely MultiPolygon object to a list of coordinates. diff --git a/docs/requirements.txt b/docs/requirements.txt index 932c823..c960f47 100644 --- a/docs/requirements.txt +++ b/docs/requirements.txt @@ -1,11 +1,14 @@ # These are the requirements for readthedoc +multiurl +filelock ipykernel docutils Pygments>=2.6.1 Sphinx>=7.3.7 -sphinx-rtd-theme nbsphinx setuptools sphinx-autoapi sphinx-issues sphinx-copybutton +scipy +furo diff --git a/environment.yml b/environment.yml index 4f9b2dd..af58a19 100644 --- a/environment.yml +++ b/environment.yml @@ -1,22 +1,28 @@ name: earthkit-geo channels: - - conda-forge - - nodefaults +- conda-forge +- nodefaults dependencies: - - pyproj - - cartopy - - shapely - - scipy - - requests - - make - - mypy - - myst-parser - - pre-commit - - pytest - - pytest-cov - - sphinx>=7.2.6 - - pip: - - sphinx-autoapi>=3.0.0 - - sphinx_rtd_theme - - sphinxcontrib-apidoc - - nbsphinx +- pip +- multiurl +- filelock +- pyproj +- cartopy +- shapely +- scipy +- requests +- pyyaml +- make +- mypy +- myst-parser +- pre-commit +- pytest +- pytest-cov +- sphinx>=7.2.6 +- pip: + - sphinx-autoapi>=3.0.0 +- sphinx_rtd_theme +- sphinxcontrib-apidoc +- nbsphinx +- pip: + - mir-python>=1.28.0.13 diff --git a/pyproject.toml b/pyproject.toml index ee34b4b..033dfdb 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,64 +1,87 @@ [build-system] -requires = [ "setuptools>=61", "setuptools-scm>=8" ] +requires = ["setuptools>=61", "setuptools-scm>=8"] [project] -name = "earthkit-geo" -description = "Geospatial computations" -readme = "README.md" -license = { text = "Apache License Version 2.0" } authors = [ - { name = "European Centre for Medium-Range Weather Forecasts (ECMWF)", email = "software.support@ecmwf.int" }, + {name = "European Centre for Medium-Range Weather Forecasts (ECMWF)", email = "software.support@ecmwf.int"} ] -requires-python = ">=3.8" - classifiers = [ "Development Status :: 2 - Pre-Alpha", "Intended Audience :: Developers", "License :: OSI Approved :: Apache Software License", "Operating System :: OS Independent", "Programming Language :: Python :: 3 :: Only", - "Programming Language :: Python :: 3.8", - "Programming Language :: Python :: 3.9", "Programming Language :: Python :: 3.10", "Programming Language :: Python :: 3.11", "Programming Language :: Python :: 3.12", "Programming Language :: Python :: 3.13", "Programming Language :: Python :: Implementation :: CPython", - "Programming Language :: Python :: Implementation :: PyPy", + "Programming Language :: Python :: Implementation :: PyPy" ] -dynamic = [ "version" ] dependencies = [ + "eckit", + "mir-python>=1.28.0.13", + "multiurl", "pyproj", + "pyyaml", "requests", - "scipy", + "scipy" ] -optional-dependencies.all = [ "cartopy" ] -optional-dependencies.cartography = [ "cartopy" ] +description = "Geospatial computations" +dynamic = ["version"] +license = {text = "Apache License Version 2.0"} +name = "earthkit-geo" +readme = "README.md" +requires-python = ">=3.10" +optional-dependencies.all = ["cartopy"] +optional-dependencies.cartography = ["cartopy"] optional-dependencies.test = [ + "earthkit-data", "pytest", "pytest-cov", + "requests" ] urls.Documentation = "https://earthkit-geo.readthedocs.io/" urls.Homepage = "https://github.com/ecmwf/earthkit-geo/" urls.Issues = "https://github.com/ecmwf/earthkit-geo/issues" urls.Repository = "https://github.com/ecmwf/earthkit-geo/" -[tool.setuptools.packages.find] -include = [ "earthkit.geo" ] -where = [ "src/" ] +[tool.coverage.run] +branch = "true" -[tool.setuptools_scm] -version_file = "src/earthkit/geo/_version.py" +[tool.pydocstyle] +add_ignore = ["D1", "D200", "D205", "D400", "D401"] +convention = "numpy" [tool.ruff] line-length = 120 +preview = true +lint.ignore = [ + "D1", # pydocstyle: Missing Docstrings + "D107", # pydocstyle: numpy convention + "D203", + "D205", + "D212", + "D213", + "D400", + "D401", + "D402", + "D413", + "D415", + "D416", + "D417" +] +lint.select = [ + "D", # pydocstyle + "E", # pycodestyle + "F", # pyflakes + "I", # isort + "W" # pycodestyle warnings +] -lint.select = [ "E", "F", "I" ] -lint.isort.force-single-line = true - -[tool.coverage.run] -branch = "true" +[tool.setuptools.packages.find] +include = ["earthkit.geo"] +where = ["src/"] -[tool.pydocstyle] -add_ignore = [ "D1", "D200", "D205", "D400", "D401" ] -convention = "numpy" +[tool.setuptools_scm] +version_file = "src/earthkit/geo/_version.py" diff --git a/pytest.ini b/pytest.ini index d276e0f..11abd50 100644 --- a/pytest.ini +++ b/pytest.ini @@ -1,3 +1,7 @@ [pytest] addopts=-s --verbose testpaths = tests +markers = + download: a test downloading GRIB data and/or matrices from the ECMWF download server + tmp_cache: a test using a freshly created temporary cache + cache: a test using the internal caching mechanism diff --git a/src/earthkit/geo/__init__.py b/src/earthkit/geo/__init__.py index fa205cb..c82cd3e 100644 --- a/src/earthkit/geo/__init__.py +++ b/src/earthkit/geo/__init__.py @@ -15,6 +15,7 @@ # Local copy or not installed with setuptools __version__ = "999" +from eckit.geo import Grid from earthkit.geo.distance import GeoKDTree from earthkit.geo.distance import haversine_distance @@ -22,13 +23,24 @@ from earthkit.geo.distance import nearest_point_kdtree from earthkit.geo.figure import IFS_SPHERE from earthkit.geo.figure import UNIT_SPHERE +from earthkit.geo.regrid import regrid +from earthkit.geo.utils.caching import CACHE as cache +from earthkit.geo.utils.config import CONFIG as config +from earthkit.geo.utils.memcache import clear_memory_cache +from earthkit.geo.utils.memcache import memory_cache_info __all__ = [ "GeoKDTree", + "Grid", "haversine_distance", IFS_SPHERE, "nearest_point_haversine", "nearest_point_kdtree", + "regrid", + "cache", + "config", + "clear_memory_cache", + "memory_cache_info", UNIT_SPHERE, "__version__", ] diff --git a/src/earthkit/geo/cartography.py b/src/earthkit/geo/cartography.py index b99f9b7..a8aa28c 100644 --- a/src/earthkit/geo/cartography.py +++ b/src/earthkit/geo/cartography.py @@ -119,7 +119,7 @@ def country_polygons(country_names, resolution=110e6): if name not in [record.attributes.get(attribute).lower() for record in reader.records()] ] if missing_countries: - raise ValueError(f"No countries or states named {missing_countries} found in Natural " "Earth's shapefiles") + raise ValueError(f"No countries or states named {missing_countries} found in Natural Earth's shapefiles") combined_geometry = unary_union(geometries) diff --git a/src/earthkit/geo/conf/css/table.css b/src/earthkit/geo/conf/css/table.css new file mode 100644 index 0000000..2acdf91 --- /dev/null +++ b/src/earthkit/geo/conf/css/table.css @@ -0,0 +1,9 @@ +table.ek td { + vertical-align: top; + text-align: left !important; +} + +table.ek th { + vertical-align: top; + text-align: left !important; +} diff --git a/src/earthkit/geo/constants.py b/src/earthkit/geo/constants.py index 1772329..0be073c 100644 --- a/src/earthkit/geo/constants.py +++ b/src/earthkit/geo/constants.py @@ -7,18 +7,16 @@ # nor does it submit to any jurisdiction. # -""" -Collection of constants in SI units. -""" +"""Collection of constants in SI units.""" NORTH_POLE_LAT = 90 -r"""Latitude of the north pole in degrees""" +r"""Latitude of the north pole in degrees.""" SOUTH_POLE_LAT = -90 r"""Latitude of the south pole in degrees""" FULL_ANGLE = 360.0 -r"""Full angle in degrees""" +r"""Full angle in degrees.""" STRAIGHT_ANGLE = 180.0 r"""Half angle in degrees""" diff --git a/src/earthkit/geo/distance.py b/src/earthkit/geo/distance.py index 0d587af..4746282 100644 --- a/src/earthkit/geo/distance.py +++ b/src/earthkit/geo/distance.py @@ -11,8 +11,7 @@ from . import constants from .coord import latlon_to_xyz -from .figure import IFS_SPHERE -from .figure import UNIT_SPHERE +from .figure import IFS_SPHERE, UNIT_SPHERE def _regulate_lat(lat): diff --git a/src/earthkit/geo/gisco.py b/src/earthkit/geo/gisco.py index 744988f..2411110 100644 --- a/src/earthkit/geo/gisco.py +++ b/src/earthkit/geo/gisco.py @@ -22,7 +22,7 @@ "points": "LB", } -GISCO_URL_TEMPLATE = "https://gisco-services.ec.europa.eu" "/distribution/v2/{category}/shp" +GISCO_URL_TEMPLATE = "https://gisco-services.ec.europa.eu/distribution/v2/{category}/shp" AVAILABLE_YEARS = { "nuts": [2024, 2021, 2016, 2013, 2010, 2006, 2003], @@ -67,7 +67,7 @@ def _download_and_cache_gisco(name, category, geometry_type, resolution, suffix= geometry_type = GISCO_GEOMETRY_TYPES[geometry_type] except KeyError: raise ValueError( - f"Invalid geometry type '{geometry_type}'. " f"Valid types are: {list(GISCO_GEOMETRY_TYPES.keys())}" + f"Invalid geometry type '{geometry_type}'. Valid types are: {list(GISCO_GEOMETRY_TYPES.keys())}" ) # Validate year diff --git a/src/earthkit/geo/regrid/__init__.py b/src/earthkit/geo/regrid/__init__.py new file mode 100644 index 0000000..92121cf --- /dev/null +++ b/src/earthkit/geo/regrid/__init__.py @@ -0,0 +1,35 @@ +# (C) Copyright 2023 ECMWF. +# +# This software is licensed under the terms of the Apache Licence Version 2.0 +# which can be obtained at http://www.apache.org/licenses/LICENSE-2.0. +# In applying this licence, ECMWF does not waive the privileges and immunities +# granted to it by virtue of its status as an intergovernmental organisation +# nor does it submit to any jurisdiction. +# + +# try: +# # NOTE: the `version.py` file must not be present in the git repository +# # as it is generated by setuptools at install time +# from ._version import __version__ +# except ImportError: # pragma: no cover +# # Local copy or not installed with setuptools +# __version__ = "999" + + +# from .interpolate import interpolate +from .regrid import regrid + +# from .utils.caching import CACHE as cache +# from .utils.config import CONFIG as config +# from .utils.memcache import clear_memory_cache +# from .utils.memcache import memory_cache_info + +__all__ = [ + # "cache", + # "clear_memory_cache", + # "config", + # "interpolate", + # "memory_cache_info", + "regrid", + # "__version__", +] diff --git a/src/earthkit/geo/regrid/array/__init__.py b/src/earthkit/geo/regrid/array/__init__.py new file mode 100644 index 0000000..344ddfb --- /dev/null +++ b/src/earthkit/geo/regrid/array/__init__.py @@ -0,0 +1,11 @@ +# (C) Copyright 2023 ECMWF. +# +# This software is licensed under the terms of the Apache Licence Version 2.0 +# which can be obtained at http://www.apache.org/licenses/LICENSE-2.0. +# In applying this licence, ECMWF does not waive the privileges and immunities +# granted to it by virtue of its status as an intergovernmental organisation +# nor does it submit to any jurisdiction. +# +# + +from .regrid import regrid diff --git a/src/earthkit/geo/regrid/array/regrid.py b/src/earthkit/geo/regrid/array/regrid.py new file mode 100644 index 0000000..70beb71 --- /dev/null +++ b/src/earthkit/geo/regrid/array/regrid.py @@ -0,0 +1,18 @@ +# (C) Copyright 2023 ECMWF. +# +# This software is licensed under the terms of the Apache Licence Version 2.0 +# which can be obtained at http://www.apache.org/licenses/LICENSE-2.0. +# In applying this licence, ECMWF does not waive the privileges and immunities +# granted to it by virtue of its status as an intergovernmental organisation +# nor does it submit to any jurisdiction. +# +# + + +def regrid(data, in_grid=None, out_grid=None, *, interpolation="linear", backend="mir", **kwargs): + r"""Array interface.""" + from earthkit.geo.regrid.data.numpy import handler + + h = handler() + kwargs = kwargs.copy() + return h.regrid(data, in_grid=in_grid, out_grid=out_grid, interpolation=interpolation, backend=backend, **kwargs) diff --git a/src/earthkit/geo/regrid/backends/__init__.py b/src/earthkit/geo/regrid/backends/__init__.py new file mode 100644 index 0000000..d4f6a19 --- /dev/null +++ b/src/earthkit/geo/regrid/backends/__init__.py @@ -0,0 +1,113 @@ +# (C) Copyright 2023 ECMWF. +# +# This software is licensed under the terms of the Apache Licence Version 2.0 +# which can be obtained at http://www.apache.org/licenses/LICENSE-2.0. +# In applying this licence, ECMWF does not waive the privileges and immunities +# granted to it by virtue of its status as an intergovernmental organisation +# nor does it submit to any jurisdiction. +# + +import logging +import os +from abc import ABCMeta +from abc import abstractmethod + +# from collections import namedtuple +from importlib import import_module + +LOG = logging.getLogger(__name__) + + +class Backend(metaclass=ABCMeta): + name = None + path_config_key = None + enabled = True + + def __init__(self, *args, **kwargs): + pass + + @abstractmethod + def regrid(self, values, in_grid, out_grid, method, **kwargs): + pass + + +class BackendLoader: + kind = "backend" + + def load_module(self, module): + return import_module(module, package=__name__).backend + + def load_entry(self, entry): + entry = entry.load() + if callable(entry): + return entry + return entry.backend + + def load_remote(self, name): + return None + + +class BackendMaker: + BACKENDS = {} + BACKEND_OBJECTS = {} + + def __init__(self): + self.BACKENDS = self._builtins() + + def _make_key(self, name, *args, **kwargs): + if args or kwargs: + key = [name, *args, *list(kwargs.items())] + return tuple(key) + else: + return name + + def __call__(self, name, *args, **kwargs): + loader = BackendLoader() + + key = self._make_key(name, *args, **kwargs) + if key in self.BACKEND_OBJECTS: + return self.BACKEND_OBJECTS[key] + + if name in self.BACKENDS: + klass = self.BACKENDS[name] + else: + # TODO: implement a plugin loader + raise ValueError(f"Unknown backend: {name}") + + backend = klass(*args, **kwargs) + self.BACKEND_OBJECTS[key] = backend + + return backend + + def _builtins(self): + """Scan for built-in backend classes.""" + r = {} + here = os.path.dirname(__file__) + for path in sorted(os.listdir(here)): + if path[0] in ("_", "."): + continue + + if path.endswith(".py") or os.path.isdir(os.path.join(here, path)): + name, _ = os.path.splitext(path) + try: + module = import_module(f".{name}", package=__name__) + if hasattr(module, "backend"): + w = getattr(module, "backend") + if isinstance(w, dict): + for k, v in w.items(): + r[k] = v + else: + r[name] = w + except Exception: + LOG.exception("Error loading backend %s", name) + + LOG.debug(f"built-in backend classes: {r}") + return r + + +MAKER = BackendMaker() + + +def get_backend(name, *args, **kwargs): + """Get a backend by name.""" + return MAKER(name, *args, **kwargs) diff --git a/src/earthkit/geo/regrid/backends/db.py b/src/earthkit/geo/regrid/backends/db.py new file mode 100644 index 0000000..2561b2d --- /dev/null +++ b/src/earthkit/geo/regrid/backends/db.py @@ -0,0 +1,565 @@ +# (C) Copyright 2023 ECMWF. +# +# This software is licensed under the terms of the Apache Licence Version 2.0 +# which can be obtained at http://www.apache.org/licenses/LICENSE-2.0. +# In applying this licence, ECMWF does not waive the privileges and immunities +# granted to it by virtue of its status as an intergovernmental organisation +# nor does it submit to any jurisdiction. +# + +import json +import logging +import os +from abc import ABCMeta, abstractmethod + +from scipy.sparse import load_npz + +from earthkit.geo.regrid.gridspec import GridSpec +from earthkit.geo.utils import no_progress_bar +from earthkit.geo.utils.download import download_and_cache + +LOG = logging.getLogger(__name__) + +VERSION = 1 + +_SYSTEM_URL = "https://sites.ecmwf.int/repository/earthkit/regrid/db/1/" +_INDEX_FILENAME = "index.json" +_INDEX_SHA_FILENAME = "index.json.sha256" +_INDEX_GZ_FILENAME = "index.json.gz" +_METHOD_ALIAS = {"nearest-neighbour": ("nn", "nearest-neighbor")} + +_GRIDBOX_DEFAULT = { + "type": "grid-box-average", + "nonLinear": [{"type": "missing-if-heaviest-missing"}], + "solver": {"type": "multiply"}, + "cropping": False, + "lsmWeightAdjustment": 0.2, + "pruneEpsilon": 1e-10, + "poleDisplacement": 0, +} + + +def is_gridbox_default(inter): + """Check if the interpolation method is the default grid-box-average. + + In this case it should be just the string "grid-box-average" but now it + is a dictionary. Until it is fixed in MIR we need this check. + """ + method = inter["method"] + if isinstance(method, dict): + return method == _GRIDBOX_DEFAULT + elif isinstance(method, str): + return method == "grid-box-average" + else: + return False + + +def make_sha(data): + import hashlib + + m = hashlib.sha256() + if isinstance(data, str): + m.update(data.encode("utf-8")) + else: + m.update(json.dumps(data, sort_keys=True).encode("utf-8")) + return m.hexdigest() + + +class MatrixAccessor(metaclass=ABCMeta): + @abstractmethod + def path(self): + pass + + @abstractmethod + def is_local(self): + pass + + @abstractmethod + def index_path(self): + pass + + @abstractmethod + def matrix_path(self, name): + pass + + @abstractmethod + def reload(self, strict=False): + pass + + def checked_remote(self): + return False + + @abstractmethod + def reset(self): + pass + + +class UrlAccessor(MatrixAccessor): + def __init__(self, url): + self._url = url + self._index_path = None + self._checked_remote = False + + def path(self): + return self._url + + def is_local(self): + False + + def checked_remote(self): + return self._checked_remote + + def reset(self): + self._index_path = None + self._checked_remote = False + + def reload(self, force=False): + self._index_path = self._get_index(check_remote=True, force=force) + + def index_path(self): + if self._index_path is None or not os.path.exists(self._index_path): + self._index_path = self._get_index() + return self._index_path + + def _get_index(self, check_remote=False, force=False): + from earthkit.geo.utils.caching import cache_file + + url = os.path.join(self._url, _INDEX_FILENAME) + + def _compare_sha(args, path, owner_data): + """Decide if the index file should be downloaded and cached again.""" + LOG.info("UrlAccessor: compare local and remote index file checksums") + LOG.info(f"UrlAccessor: cached entry {owner_data=}") + if owner_data is None: + return True + local_sha = owner_data.get("sha256", None) + LOG.info(f"UrlAccessor: local (cached) checksum={local_sha}") + if local_sha is None: + return True + + remote_sha = self._remote_sha() + self._checked_remote = True + + if local_sha != remote_sha: + LOG.info( + ( + f"UrlAccessor: remote checksum={remote_sha} differs from " + "local (cached) checksum. Downloading new index file." + ) + ) + return True + else: + LOG.info( + ( + f"UrlAccessor: remote checksum={remote_sha} is the same as " + "local (cached) checksum. Use cached index file." + ) + ) + return False + + def _force_download(args, path, owner_data): + """Decide if the index file should be downloaded and cached again.""" + LOG.info("UrlAccessor: forcefully download remote checksum and new index file") + self._remote_sha() + self._checked_remote = True + return True + + def _create(target, args): + """Download and cache gzipped index file, uncompress it and generate + checksum from contents + """ + path_gz = self._gzip_file() + LOG.info(f"UrlAccessor: uncompress gzipped index file={path_gz}") + import gzip + + with gzip.open(path_gz, "rb") as f: + data = f.read() + with open(target, "wb") as f_out: + f_out.write(data) + + with open(target, "r") as f: + data = f.read() + sha = make_sha(data) + + # the returned data will be stored in the cache in the entry's owner_data + LOG.info(f"UrlAccessor: index file checksum={sha}") + return {"sha256": sha} + + if force: + force = _force_download + elif check_remote: + force = _compare_sha + else: + LOG.info("UrlAccessor: check if cached index file is available") + force = None + + path = cache_file( + "regrid", + _create, + (url,), + force=force, + extension=".cache", + ) + + LOG.info(f"UrlAccessor: index file={path}") + return path + + def _remote_sha(self): + try: + url = os.path.join(self._url, _INDEX_SHA_FILENAME) + path = download_and_cache( + url, + owner="url", + verify=True, + force=True, + chunk_size=1024 * 1024, + http_headers=None, + update_if_out_of_date=True, + progress_bar=no_progress_bar, + maximum_retries=0, + retry_after=10, + ) + except Exception: + LOG.error(f"UrlAccessor: could not download index checksum file={url}") + raise + + with open(path, "r") as f: + sha = f.read().strip() + return sha + + def _gzip_file(self): + try: + url = os.path.join(self._url, _INDEX_GZ_FILENAME) + LOG.info(f"Download gzipped index file={url}") + path = download_and_cache( + url, + owner="url", + verify=True, + force=True, + chunk_size=1024 * 1024, + http_headers=None, + update_if_out_of_date=True, + progress_bar=no_progress_bar, + maximum_retries=0, + retry_after=10, + ) + except Exception: + LOG.error(f"Could not download index file={url}") + raise + + return path + + def matrix_path(self, name): + try: + url = os.path.join(self._url, name) + path = download_and_cache( + url, + owner="url", + verify=True, + force=None, + chunk_size=1024 * 1024, + http_headers=None, + update_if_out_of_date=False, + maximum_retries=5, + retry_after=10, + ) + except Exception: + LOG.error(f"Could not download matrix file={url}") + raise + + return path + + +class LocalAccessor(MatrixAccessor): + def __init__(self, path): + self._path = path + + def path(self): + return self._path + + def is_local(self): + True + + def index_path(self): + return os.path.join(self._path, _INDEX_FILENAME) + + def matrix_path(self, name): + return os.path.join(self._path, name) + + def reload(self, strict=False): + pass + + def reset(self): + pass + + +class SystemAccessor(UrlAccessor): + def __init__(self): + super().__init__(_SYSTEM_URL) + + +class MatrixIndex(dict): + def load(self, path): + with open(path, "r") as f: + index = json.load(f) + version = index.get("version", None) + if version != VERSION: + raise ValueError(f"Invalid index file version: expected {VERSION}, got {version}") + for name, entry in index["matrix"].items(): + # it is possible that the inventory is already updated with a new + # gridspecs type, but a given earthkit-geo version is not + # yet supporting it. In this case loading the index should not crash. + try: + in_gs = GridSpec.from_dict(entry["input"]) + out_gs = GridSpec.from_dict(entry["output"]) + raw = entry + entry = dict(**entry) + entry["input"] = in_gs + entry["output"] = out_gs + entry["_name"] = name + entry["_raw"] = raw + self[name] = entry + except Exception as e: + LOG.exception(f"Could not load matrix inventory entry {name}: {e}") + + @staticmethod + def interpolation_method_name(item): + inter = item["interpolation"] + method = inter["method"] + if isinstance(method, str): + return method + if isinstance(method, dict): + return method["type"] + + raise ValueError(f"Invalid interpolation method: {method}") + + @staticmethod + def interpolation_method(item): + return item["interpolation"]["method"] + + @staticmethod + def make_interpolation_uid(item): + inter = item["interpolation"] + method = MatrixIndex.interpolation_method_name(item) + # TODO: remove this when MIR is fixed + if method == "grid-box-average" and is_gridbox_default(inter): + uid = method + elif isinstance(MatrixIndex.interpolation_method(item), dict): + uid = make_sha(inter) + elif set(inter.keys()) == {"method", "engine", "version"}: + uid = method + else: + uid = make_sha(inter) + return uid + + @staticmethod + def matrix_dir_name(item): + # TODO: review this logic when non-default interpolation options will + # be available for a given method + inter = item["interpolation"] + engine = inter["engine"] + version = inter["version"] + method_name = MatrixIndex.interpolation_method_name(item) + # uid = inter.get("_uid", method_name) + # uid = inter.get("_uid", inter["method"]) + return f"{engine}_{version}_{method_name}" + + @staticmethod + def matrix_path(item): + return os.path.join(MatrixIndex.matrix_dir_name(item), item["_name"] + ".npz") + + def find(self, gridspec_in, gridspec_out, method): + gridspec_in = GridSpec.from_any(gridspec_in) + gridspec_out = GridSpec.from_any(gridspec_out) + + if gridspec_in is None or gridspec_out is None: + return None + + for _, entry in self.items(): + if MatrixIndex.match(entry, gridspec_in, gridspec_out, method): + return entry + return None + + @staticmethod + def match(item, gs_in, gs_out, method): + if ( + MatrixIndex.interpolation_method_name(item) == method + and item["input"] == gs_in + and item["output"] == gs_out + ): + return True + return False + + @staticmethod + def matrix_filename(item): + return item["_name"] + ".npz" + + def subset(self, filters, fail_on_missing=True, raw=False): + res = MatrixIndex() + + for i, item in enumerate(filters): + gs_in = item["input"] + gs_out = item["output"] + method = item.get("method", "linear") + LOG.info(f"ITEM[{i}]: {gs_in=} {gs_out=} {method=}") + entry = self.find(gs_in, gs_out, method) + if entry is not None: + LOG.info(" found DB entry:" + entry["_name"]) + if raw: + res[entry["_name"]] = entry["_raw"] + else: + res[entry["_name"]] = entry + else: + if fail_on_missing: + raise ValueError("No DB entry found!") + else: + LOG.warning(" no DB entry found!") + return res + + def to_raw(self): + res = dict(version=VERSION, matrix={}) + for _, entry in self.items(): + res["matrix"][entry["_name"]] = entry["_raw"] + return res + + +class MatrixDb: + def __init__(self, accessor): + self._index = None + self._accessor = accessor + + @property + def index(self): + if self._index is None: + self._load_index() + return self._index + + def _load_index(self): + self._index = MatrixIndex() + path = self._accessor.index_path() + self._index.load(path) + + def _method_alias(self, method): + for k, v in _METHOD_ALIAS.items(): + if method in v: + return k + return method + + def find( + self, + gridspec_in, + gridspec_out, + method, + **kwargs, + ): + + try: + gridspec_in = GridSpec.from_any(gridspec_in) + gridspec_out = GridSpec.from_any(gridspec_out) + except Exception as e: + LOG.warning(f"Cannot parse gridspecs with eckit.geo: {e}") + gridspec_in = None + gridspec_out = None + + if gridspec_in is None or gridspec_out is None: + return None, None + + from earthkit.geo.utils.memcache import MEMORY_CACHE + + return MEMORY_CACHE.get( + gridspec_in, + gridspec_out, + method, + create=self._create_matrix, + find_entry=self.find_entry, + create_from_entry=self._create_matrix_from_entry, + **kwargs, + ) + + def _create_matrix(self, gridspec_in, gridspec_out, method): + return self._create_matrix_from_entry(self.find_entry(gridspec_in, gridspec_out, method)) + + def _create_matrix_from_entry(self, entry): + if entry is not None: + z = self.load_matrix(entry) + return z, entry["output"].shape + return None, None + + def find_entry(self, gridspec_in, gridspec_out, method): + method = self._method_alias(method) + entry = self.index.find(gridspec_in, gridspec_out, method) + if entry is None and not self._accessor.is_local() and not self._accessor.checked_remote(): + LOG.info(f"Matrix not found in DB for {gridspec_in=} {gridspec_out=} {method=}") + LOG.info("Try to fetch remote index file to check for updates") + self._accessor.reload() + self._load_index() + entry = self.index.find(gridspec_in, gridspec_out, method) + + return entry + + def load_matrix(self, entry): + path = self._matrix_fs_path(entry) + z = load_npz(path) + return z + + def _matrix_index_filename(self, entry): + return self.index.matrix_filename(entry) + + def _matrix_index_path(self, entry): + return self.index.matrix_path(entry) + + def _matrix_fs_path(self, entry): + return self._accessor.matrix_path(self._matrix_index_path(entry)) + + def subset_index(self, filters, **kwargs): + return self.index.subset(filters, **kwargs) + + def copy_matrix_file(self, entry, out_dir, exist_ok=False, dry_run=False): + import shutil + + matrix_index_path = self._matrix_index_path(entry) + src_file = self._matrix_fs_path(entry) + target_file = os.path.join(out_dir, matrix_index_path) + + if not exist_ok and os.path.exists(target_file): + if not dry_run: + raise FileExistsError(f"target file already exists! {target_file}") + else: + LOG.warning("target file already exists! {target_file}") + + target_dir = os.path.dirname(target_file) + + if not dry_run: + os.makedirs(target_dir, exist_ok=True) + shutil.copyfile(src_file, target_file) + + return target_file + + def index_file_path(self): + return self._accessor.index_path() + + def matrix_source(self): + return self._accessor.path() + + @staticmethod + def from_path(path): + return MatrixDb(LocalAccessor(path)) + + @staticmethod + def from_url(url): + return MatrixDb(UrlAccessor(url)) + + def __len__(self): + return len(self.index) + + def _clear_index(self): + """For testing only""" + self._index = None + + def _reset(self): + """For testing only""" + self._index = None + self._accessor.reset() + + +SYS_DB = MatrixDb(SystemAccessor()) diff --git a/src/earthkit/geo/regrid/backends/mir.py b/src/earthkit/geo/regrid/backends/mir.py new file mode 100644 index 0000000..346884d --- /dev/null +++ b/src/earthkit/geo/regrid/backends/mir.py @@ -0,0 +1,106 @@ +# (C) Copyright 2025- ECMWF. +# +# This software is licensed under the terms of the Apache Licence Version 2.0 +# which can be obtained at http://www.apache.org/licenses/LICENSE-2.0. +# In applying this licence, ECMWF does not waive the privileges and immunities +# granted to it by virtue of its status as an intergovernmental organisation +# nor does it submit to any jurisdiction. +# + +from warnings import warn + +from . import Backend + + +class MirBackend(Backend): + name = "mir" + + @staticmethod + def normalise_area(area): + if isinstance(area, str): + return area + if isinstance(area, (list, tuple)): + if len(area) == 4: + return "/".join(map(str, area)) + + raise ValueError(f"Invalid area format: {area}") + + @staticmethod + def adjust_options(grid, kwargs): + # TODO: remove this once we have a better way to handle area in gridspec + if "area" in grid: + warn( + "The area key is a temporary workaround for area in gridspec", + DeprecationWarning, + stacklevel=2, + ) + grid = grid.copy() + kwargs = kwargs.copy() + area = grid.pop("area") + kwargs["area"] = MirBackend.normalise_area(area) + return grid, kwargs + + def regrid( + self, + data, + in_grid, + out_grid, + interpolation="linear", + ): + import mir + + kwargs = { + "interpolation": interpolation, + } + + out_grid, kwargs = self.adjust_options(out_grid, {}) + + input = mir.ArrayInput(data, in_grid) + out = mir.ArrayOutput() + + job = mir.Job() + job.set("grid", out_grid) + job.set("interpolation", interpolation) # NOTE: needs generalisation + for k, v in kwargs.items(): + job.set(k, v) + + job.execute(input, out) + + return out.values(), out.spec + + # TODO: remove this once the gridspec can be written into the GRIB message + def regrid_grib( + self, + message, + grid, + interpolation="linear", + ): + from io import BytesIO + + import mir + + kwargs = { + "interpolation": interpolation, + } + + # no 'automatic' necessary + kremove = [k for k, v in kwargs.items() if v == "automatic"] + for k in kremove: + del kwargs[k] + + out_grid, kwargs = self.adjust_options(grid, kwargs) + + in_data = mir.GribMemoryInput(message) + out = BytesIO() + + job = mir.Job() + job.set("grid", out_grid) + for k, v in kwargs.items(): + job.set(k, v) + + job.execute(in_data, out) + + return out.getvalue() + + +backend = MirBackend diff --git a/src/earthkit/geo/regrid/backends/precomputed.py b/src/earthkit/geo/regrid/backends/precomputed.py new file mode 100644 index 0000000..84fd544 --- /dev/null +++ b/src/earthkit/geo/regrid/backends/precomputed.py @@ -0,0 +1,57 @@ +# (C) Copyright 2023 ECMWF. +# +# This software is licensed under the terms of the Apache Licence Version 2.0 +# which can be obtained at http://www.apache.org/licenses/LICENSE-2.0. +# In applying this licence, ECMWF does not waive the privileges and immunities +# granted to it by virtue of its status as an intergovernmental organisation +# nor does it submit to any jurisdiction. +# + + +from . import Backend + + +class MatrixBackend(Backend): + name = "precomputed" + system_inventory_id = "ecmwf" + + def __init__(self, inventory=None): + self.path_or_url = inventory + self.db = self.get_db(inventory) + + def regrid(self, data, in_grid, out_grid, interpolation): + from earthkit.geo.regrid.gridspec import GridSpec + + _out_grid = GridSpec.from_any(out_grid) + + z, shape = self.db.find(in_grid, _out_grid, interpolation) + + if z is None: + raise ValueError(f"No precomputed weights found! {in_grid=} {out_grid=} {interpolation=}") + + # This should check for 1D (GG) and 2D (LL) matrices + data = data.reshape(-1, 1) + + data = z @ data + data = data.reshape(shape) + + return data, _out_grid.spec + + def get_db(self, path_or_url): + if path_or_url is None or path_or_url == self.system_inventory_id: + from .db import SYS_DB + + return SYS_DB + elif path_or_url.startswith("http://") or path_or_url.startswith("https://"): + from .db import MatrixDb + + return MatrixDb.from_url(path_or_url) + elif path_or_url: + from .db import MatrixDb + + return MatrixDb.from_path(path_or_url) + else: + raise ValueError(f"Invalid path_or_url={path_or_url} for backend={self.name}") + + +backend = MatrixBackend diff --git a/src/earthkit/geo/regrid/data/__init__.py b/src/earthkit/geo/regrid/data/__init__.py new file mode 100644 index 0000000..bb8282b --- /dev/null +++ b/src/earthkit/geo/regrid/data/__init__.py @@ -0,0 +1,34 @@ +# (C) Copyright 2023 ECMWF. +# +# This software is licensed under the terms of the Apache Licence Version 2.0 +# which can be obtained at http://www.apache.org/licenses/LICENSE-2.0. +# In applying this licence, ECMWF does not waive the privileges and immunities +# granted to it by virtue of its status as an intergovernmental organisation +# nor does it submit to any jurisdiction. +# + + +from importlib import import_module + +_modules = [ + "fieldlist", + "grib", + "xarray", +] + + +DATA_HANDLERS = [] +for name in _modules: + module = import_module(f".{name}", package=__name__) + lst = getattr(module, "handler", []) + if not isinstance(lst, list): + lst = [lst] + assert isinstance(lst, list), f"Expected a list of handlers in {module.__name__}" + DATA_HANDLERS.extend(lst) + + +def get_data_handler(values): + for h in DATA_HANDLERS: + if h.match(values): + # TODO: rethink if we need to create a new handler instance each time + return h() diff --git a/src/earthkit/geo/regrid/data/fieldlist.py b/src/earthkit/geo/regrid/data/fieldlist.py new file mode 100644 index 0000000..a251ed8 --- /dev/null +++ b/src/earthkit/geo/regrid/data/fieldlist.py @@ -0,0 +1,137 @@ +# (C) Copyright 2023 ECMWF. +# +# This software is licensed under the terms of the Apache Licence Version 2.0 +# which can be obtained at http://www.apache.org/licenses/LICENSE-2.0. +# In applying this licence, ECMWF does not waive the privileges and immunities +# granted to it by virtue of its status as an intergovernmental organisation +# nor does it submit to any jurisdiction. +# + +import logging + +from .handler import DataHandler + +LOG = logging.getLogger(__name__) + + +class FieldListDataHandler(DataHandler): + @staticmethod + def match(data): + from earthkit.geo.utils import is_module_loaded + + if not is_module_loaded("earthkit.data"): + return False + + try: + import earthkit.data + + return isinstance(data, earthkit.data.FieldList) and hasattr(data, "get") + except Exception: + return False + + @staticmethod + def input_gridspec(field, index): + try: + in_grid = field.geography.grid_spec() + except Exception as e: + LOG.exception(f"Cannot get input grid_spec from metadata for field[{index}]: {e}") + raise + if in_grid is None: + raise ValueError(f"Cannot get input grid_spec from metadata for field[{index}]") + + return in_grid + + def regrid(self, data, **kwargs): + backend = self.backend_from_kwargs(kwargs) + + grid = kwargs.pop("grid", None) + if grid is None: + raise ValueError("Missing 'grid' argument") + + if hasattr(backend, "regrid_grib"): + # TODO: remove this when ecCodes supports setting the gridSpec on a GRIB handle + return self._regrid_grib(data, backend, grid, **kwargs) + else: + return self._regrid_array(data, backend, grid, **kwargs) + + def _regrid_array(self, data, backend, grid, **kwargs): + import earthkit.data + + ds = data + assert grid is not None + + # TODO: refactor this when this limitation is removed + from earthkit.geo.regrid.gridspec import GridSpec + + out_grid = GridSpec.from_any(grid) + + fields = [] + for i, f in enumerate(ds): + vv = f.to_numpy(flatten=True) + + in_grid = self.input_gridspec(f, i) + + v_res, out_grid = backend.regrid( + vv, + in_grid, + out_grid, + **kwargs, + ) + + out_grid = GridSpec.from_any(out_grid).grid + + fields.append(f.set({"values": v_res, "geography.grid_spec": out_grid})) + + r = earthkit.data.create_fieldlist(fields) + + return r + + def _regrid_grib(self, values, backend, grid, **kwargs): + # TODO: remove this when ecCodes supports setting the gridSpec on a GRIB handle + from earthkit.data.encoders.grib import GribEncoder + from earthkit.data.field.grib.create import create_grib_field_from_buffer + + assert hasattr(backend, "regrid_grib") + + ds = values + assert grid is not None + + encoder = GribEncoder() + + r = [] + for i, f in enumerate(ds): + if f._get_grib(): + d = encoder.encode(f) + message = d.to_bytes() + if message is None: + raise ValueError(f"field at index={i} type={type(f)} is not supported in regrid!") + + v_res = backend.regrid_grib(message, grid, **kwargs) + r.append(create_grib_field_from_buffer(v_res)) + + return ds.from_fields(r) + + +class FieldDataHandler(DataHandler): + @staticmethod + def match(data): + from earthkit.geo.utils import is_module_loaded + + if not is_module_loaded("earthkit.data"): + return False + + try: + import earthkit.data + + return isinstance(data, earthkit.data.Field) and hasattr(data, "get") + except Exception: + return False + + def regrid(self, data, **kwargs): + from earthkit.data import FieldList + + ds = FieldList.from_fields([data]) + return FieldListDataHandler().regrid(ds, **kwargs)[0] + + +handler = [FieldListDataHandler, FieldDataHandler] diff --git a/src/earthkit/geo/regrid/data/grib.py b/src/earthkit/geo/regrid/data/grib.py new file mode 100644 index 0000000..116d6c8 --- /dev/null +++ b/src/earthkit/geo/regrid/data/grib.py @@ -0,0 +1,44 @@ +# (C) Copyright 2023 ECMWF. +# +# This software is licensed under the terms of the Apache Licence Version 2.0 +# which can be obtained at http://www.apache.org/licenses/LICENSE-2.0. +# In applying this licence, ECMWF does not waive the privileges and immunities +# granted to it by virtue of its status as an intergovernmental organisation +# nor does it submit to any jurisdiction. +# + +import logging + +from earthkit.geo.regrid.data.handler import DataHandler + +LOG = logging.getLogger(__name__) + + +class GribMessageDataHandler(DataHandler): + @staticmethod + def match(values): + if isinstance(values, bytes): + return True + else: + from io import BytesIO + + # TODO: add further checks to see if the object is a GRIB message + if isinstance(values, BytesIO): + return True + return False + + def regrid(self, values, **kwargs): + backend = self.backend_from_kwargs(kwargs) + if hasattr(backend, "regrid_grib"): + if not isinstance(values, bytes): + from io import BytesIO + + if isinstance(values, BytesIO): + values = values.getvalue() + + return backend.regrid_grib(values, **kwargs) + else: + raise ValueError(f"regrid() does not support GRIB message input for {backend=}!") + + +handler = GribMessageDataHandler diff --git a/src/earthkit/geo/regrid/data/handler.py b/src/earthkit/geo/regrid/data/handler.py new file mode 100644 index 0000000..02e1ad1 --- /dev/null +++ b/src/earthkit/geo/regrid/data/handler.py @@ -0,0 +1,43 @@ +# (C) Copyright 2023 ECMWF. +# +# This software is licensed under the terms of the Apache Licence Version 2.0 +# which can be obtained at http://www.apache.org/licenses/LICENSE-2.0. +# In applying this licence, ECMWF does not waive the privileges and immunities +# granted to it by virtue of its status as an intergovernmental organisation +# nor does it submit to any jurisdiction. +# + +import logging +from abc import ABCMeta, abstractmethod + +LOG = logging.getLogger(__name__) + + +OPTIONAL_BACKENDS_KWARGS = ["inventory"] + + +class DataHandler(metaclass=ABCMeta): + @abstractmethod + def regrid(self, values, **kwargs): + pass + + def backend_from_kwargs(self, kwargs): + backend = kwargs.pop("backend", None) + if backend is None: + raise ValueError("Missing 'backend' keyword argument") + + b_kwargs = {} + for k in OPTIONAL_BACKENDS_KWARGS: + if k in kwargs: + b_kwargs[k] = kwargs.pop(k) + return self.get_backend(backend, **b_kwargs) + + def get_backend(self, backend, **backend_kwargs): + from earthkit.geo.regrid.backends import get_backend + + backend = get_backend(backend, **backend_kwargs) + + if not backend: + raise ValueError(f"No backend={backend} found") + + return backend diff --git a/src/earthkit/geo/regrid/data/numpy.py b/src/earthkit/geo/regrid/data/numpy.py new file mode 100644 index 0000000..15d317c --- /dev/null +++ b/src/earthkit/geo/regrid/data/numpy.py @@ -0,0 +1,31 @@ +# (C) Copyright 2023 ECMWF. +# +# This software is licensed under the terms of the Apache Licence Version 2.0 +# which can be obtained at http://www.apache.org/licenses/LICENSE-2.0. +# In applying this licence, ECMWF does not waive the privileges and immunities +# granted to it by virtue of its status as an intergovernmental organisation +# nor does it submit to any jurisdiction. +# + +import logging + +from .handler import DataHandler + +LOG = logging.getLogger(__name__) + + +class NumpyDataHandler(DataHandler): + @staticmethod + def match(data): + import numpy as np + + return isinstance(data, np.ndarray) + + def regrid(self, data, **kwargs): + in_grid = kwargs.pop("in_grid") + out_grid = kwargs.pop("out_grid") + backend = self.backend_from_kwargs(kwargs) + return backend.regrid(data, in_grid, out_grid, **kwargs) + + +handler = NumpyDataHandler diff --git a/src/earthkit/geo/regrid/data/xarray.py b/src/earthkit/geo/regrid/data/xarray.py new file mode 100644 index 0000000..4b4ec6d --- /dev/null +++ b/src/earthkit/geo/regrid/data/xarray.py @@ -0,0 +1,357 @@ +# (C) Copyright 2023 ECMWF. +# +# This software is licensed under the terms of the Apache Licence Version 2.0 +# which can be obtained at http://www.apache.org/licenses/LICENSE-2.0. +# In applying this licence, ECMWF does not waive the privileges and immunities +# granted to it by virtue of its status as an intergovernmental organisation +# nor does it submit to any jurisdiction. +# + +import functools +import logging + +from earthkit.geo.utils import ensure_list + +from .handler import DataHandler + +LOG = logging.getLogger(__name__) + + +# TODO: This is a temporary wrapper to use the grid interface +class GridWrapper: + def __init__(self, grid_spec): + from eckit.geo import Grid + + self._grid = Grid(**grid_spec) + self._grid_spec = grid_spec + + def __getattr__(self, name): + return getattr(self._grid, name) + + def to_latlons(self): + import numpy as np + + lat, lon = self._grid.to_latlons() + return np.array(lat), np.array(lon) + + @property + def grid_spec(self): + # TODO: for grid specs like {'grid': 'O32', 'area': [87.863799, 0.0, -87.863799, 357.5]} + # The Grid.spec is not correct so we cannot return self.spec + return self._grid_spec + + def is_spectral(self): + return False + + def to_distinct_latlons(self, field_shape): + if len(self._grid.shape) == 2: + lat, lon = self.to_latlons() + lat = lat.reshape(self._grid.shape) + lon = lon.reshape(self._grid.shape) + d_lat = self._distinct_lats(lat) + if d_lat is not None: + d_lon = self._distinct_lons(lon) + if d_lon is not None and len(d_lat) == field_shape[0] and len(d_lon) == field_shape[1]: + return d_lat, d_lon + + return None, None + + @staticmethod + def _distinct_lats(lats): + import numpy as np + + assert len(lats.shape) == 2 + rows = lats.shape[0] + r = np.ones(rows) + if rows > 0: + for i in range(rows): + vals = lats[i, :] + delta = np.diff(vals) + if np.allclose(delta, delta[0]): + r[i] = vals[0] + else: + return None + return r + return None + + @staticmethod + def _distinct_lons(lons): + import numpy as np + + assert len(lons.shape) == 2 + cols = lons.shape[1] + r = np.ones(cols) + if cols > 0: + for i in range(cols): + vals = lons[:, i] + delta = np.diff(vals) + if np.allclose(delta, delta[0]): + r[i] = vals[0] + else: + return None + return r + return None + + +# TODO: move this code to earthkit-geo +class XarrrayGeographyBuilder: + def __init__(self, grid_spec): + self.grid = GridWrapper(grid_spec) + self.grid_spec = grid_spec + + @property + def shape(self): + return self.grid.shape + + def geo_dims(self): + """Determine the geographical dimensions of the dataset.""" + num = len(self.shape) + if num >= 2: + return ["latitude", "longitude"] + if num == 1: + return ["values"] + + raise ValueError("Geography is not supported.") + + def coords(self): + import math + + field_shape = self.grid.shape + + coords = {} + dims = {} + coords_dim = {} + + if self.grid.is_spectral(): + if len(field_shape) == 1: + dims["values"] = field_shape[0] + else: + if len(field_shape) == 1: + dims["values"] = field_shape[0] + try: + lat, lon = self.grid.to_latlons() + if lat is not None and lon is not None: + coords["latitude"] = lat + coords["longitude"] = lon + coords_dim = {k: ("values",) for k in coords} + except Exception: + pass + elif len(field_shape) == 2: + try: + lat, lon = self.grid.to_distinct_latlons(field_shape) + if ( + lat is not None + and lon is not None + and len(lat) == field_shape[0] + and len(lon) == field_shape[1] + ): + coords["latitude"] = lat + coords["longitude"] = lon + coords_dim["latitude"] = ("latitude",) + coords_dim["longitude"] = ("longitude",) + dims["latitude"] = lat.size + dims["longitude"] = lon.size + assert coords["latitude"].size == field_shape[0] + assert coords["longitude"].size == field_shape[1] + assert dims["latitude"] == field_shape[0] + assert dims["longitude"] == field_shape[1] + except Exception as e: + print(e) + pass + + if not coords or not dims: + lat, lon = self.grid.to_latlons() + # print("to_latlons:", type(lat), type(lon)) + if lat is not None and lon is not None: + lat = lat.reshape(field_shape) + lon = lon.reshape(field_shape) + coords["latitude"] = lat + coords["longitude"] = lon + coords_dim = {k: ("y", "x") for k in coords} + dims["y"] = field_shape[0] + dims["x"] = field_shape[1] + # print("field_shape:", field_shape, lat.shape, lon.shape) + assert coords["latitude"].shape == field_shape + assert coords["longitude"].shape == field_shape + else: + raise ValueError(f"Unsupported field shape {field_shape}") + + for k, v in coords.items(): + assert k in coords_dim, f"{k=}, {coords_dim=}" + assert all(x in dims for x in coords_dim[k]), f"{k=}, {coords_dim=} {dims=}" + assert v.size == math.prod([dims[x] for x in coords_dim[k]]) + + return dims, coords, coords_dim + + +def xr_geo_dims(ds): + """Determine the geographical dimensions of the dataset/dataarray.""" + dims = list(ds.sizes.keys()) + if len(ds.dims) >= 1: + if dims[-1] == "values": + return ["values"] + if len(dims) >= 2: + if dims[-2] == "latitude" and dims[-1] == "longitude": + return ["latitude", "longitude"] + + raise ValueError("Dataset geography is not supported.") + + +class XarrayDataHandler(DataHandler): + @staticmethod + def match(values): + from earthkit.geo.utils import is_module_loaded + + if not is_module_loaded("xarray"): + return False + + try: + import xarray as xr + + return isinstance(values, (xr.DataArray, xr.Dataset)) + except Exception: + return False + + @staticmethod + def get_in_grid(ds, kwargs): + """Get the input grid from the dataset or from the kwargs.""" + # TODO: ensure the grid_spec is always available on an Xarray. + # This probably should be implemented in earthkit-geo. + + def _convert(grid_spec): + if grid_spec is None: + return None + res = None + if isinstance(grid_spec, dict) and grid_spec: + res = grid_spec + elif isinstance(grid_spec, str): + import json + + res = json.loads(grid_spec) + + if res: + return res + else: + raise None + + try: + in_grid = _convert(ds.attrs.get("ek_grid_spec", None)) + if in_grid is None: + in_grid = _convert(kwargs.pop("grid_spec", None)) + if in_grid is None: + in_grid = _convert(ds.earthkit.grid_spec) + except AttributeError: + pass + + if in_grid is None: + raise ValueError("in_grid must be provided") + + return GridWrapper(in_grid) + + @staticmethod + def get_out_geo(grid): + """Get the output geography from the out_grid.""" + out_grid = grid + if out_grid is None: + raise ValueError("grid must be provided") + + out_geo = XarrrayGeographyBuilder(out_grid) + return out_geo + + @staticmethod + def add_geo_coords(ds, out_geo): + """Add the geographical coordinates to the dataset.""" + dims, coords, coords_dim = out_geo.coords() + + import xarray as xr + + for k, v in coords.items(): + c_dims = {x: dims[x] for x in coords_dim[k]} + ds.coords[k] = xr.Variable(c_dims, v) + + return ds + + def regrid(self, values, grid=None, **kwargs): + from .numpy import NumpyDataHandler + + kwargs = kwargs.copy() + + in_grid = self.get_in_grid(values, kwargs) + out_geo = self.get_out_geo(grid) + + in_dims = kwargs.pop("in_dims", None) + if in_dims is None: + in_dims = xr_geo_dims(values) + + if in_dims is None: + raise ValueError(f"Could not determine geography related input dimensions: {values.dims}") + + out_dims = kwargs.pop("out_dims", None) + if out_dims is None: + out_dims = out_geo.geo_dims() + + if out_dims is None: + raise ValueError(f"Could not determine geography related output dimensions: {values.dims}") + + in_dims = ensure_list(in_dims) + out_dims = ensure_list(out_dims) + + import xarray as xr + + exclude_dims = set() + if set(in_dims) == set(out_dims): + exclude_dims = set(in_dims) + + # regrid can change the specified output gridspec. + # This is a workaround to get the returned output gridscpec from regrid. + class _RegridMethod: + def __init__(self, in_grid, out_grid, **kwargs): + self.out_grid = out_grid + self.method = functools.partial( + NumpyDataHandler().regrid, + in_grid=in_grid, + out_grid=out_grid, + **kwargs, + ) + + def __call__(self, vals): + # TODO: ensure it is thread safe + vals, self.out_grid = self.method(vals) + return vals + + method = _RegridMethod(in_grid.grid_spec, out_geo.grid_spec, **kwargs) + + def _regrid(da): + return xr.apply_ufunc( + method, + da, + input_core_dims=[in_dims], + output_core_dims=[out_dims], + exclude_dims=exclude_dims, + vectorize=True, + dask="parallelized", + dask_gufunc_kwargs={ + "output_sizes": {dim: out_geo.shape[i] for i, dim in enumerate(out_dims)}, + "allow_rechunk": True, + }, + output_dtypes=[da.dtype], + ) + + if isinstance(values, xr.Dataset): + ds_out = xr.Dataset() + for var_name, var in values.data_vars.items(): + ds_out[var_name] = _regrid(var) + + else: + ds_out = _regrid(values) + + # The output geography might have changed, so we need to create a new geography builder + # with the new grid spec + out_geo = XarrrayGeographyBuilder(method.out_grid) + + self.add_geo_coords(ds_out, out_geo) + + return ds_out + + +handler = XarrayDataHandler diff --git a/src/earthkit/geo/regrid/gridspec.py b/src/earthkit/geo/regrid/gridspec.py new file mode 100644 index 0000000..b90a540 --- /dev/null +++ b/src/earthkit/geo/regrid/gridspec.py @@ -0,0 +1,132 @@ +# (C) Copyright 2023 ECMWF. +# +# This software is licensed under the terms of the Apache Licence Version 2.0 +# which can be obtained at http://www.apache.org/licenses/LICENSE-2.0. +# In applying this licence, ECMWF does not waive the privileges and immunities +# granted to it by virtue of its status as an intergovernmental organisation +# nor does it submit to any jurisdiction. +# + +import logging +import re +from abc import abstractmethod + +LOG = logging.getLogger(__name__) + +HEALPIX_PATTERN = re.compile(r"[Hh]\d+") + + +class ShapeDoesNotMatchError(Exception): + pass + + +# Wrapper around eckit.geo.Grid so that matrix inventory can be used. +# TODO: add logic here to support custom gridspecs that cannot be parsed by eckit.geo. +class GridSpec(dict): + @staticmethod + def from_dict(d): + return EckitGridSpec(d) + + @staticmethod + def from_any(d): + if isinstance(d, GridSpec): + return d + elif isinstance(d, dict): + return GridSpec.from_dict(d) + + return EckitGridSpec(d) + + @property + @abstractmethod + def grid(self): + pass + + @property + @abstractmethod + def shape(self): + pass + + def __eq__(self, o): + if self.grid is not None and o.grid is not None: + return self.grid.uid == o.grid.uid + + return False + + +class EckitGridSpec(GridSpec): + def __init__(self, gs_in): + from eckit.geo import Grid + + expected_shape = None + if isinstance(gs_in, Grid): + try: + self._grid = gs_in + spec = gs_in.spec + except Exception as e: + raise ValueError(f"Cannot parse gridspec with eckit.geo: {e}") + else: + if isinstance(gs_in, dict): + gs = gs_in.copy() + self._patch(gs) + expected_shape = gs.pop("shape", None) + if gs.pop("global", None) in ("1", 1, True): + gs.pop("area", None) + else: + gs = gs_in + + try: + self._grid = Grid(gs) + spec = self._grid.spec + except Exception as e: + raise ValueError(f"Cannot parse gridspec with eckit.geo: {e}") + + if expected_shape is not None: + shape = expected_shape + if not isinstance(shape, (list, tuple)): + shape = [shape] + if isinstance(shape, list): + shape = tuple(shape) + if self._grid.shape != shape: + raise ShapeDoesNotMatchError( + f"Grid shape {self._grid.shape} does not match expected shape in {gs_in}" + ) + + super().__init__(spec) + + def _patch(self, d): + grid = d.get("grid", "") + if isinstance(grid, str): + # the offical key is "order" in HEALPix, we still support "ordering" for compatibility + if HEALPIX_PATTERN.match(grid): + if "ordering" in d: + d["order"] = d.pop("ordering") + # in the matrix inventory this orca grid has a 1D shape, but eckit.geo.Grid + # generates a 2D shape for it, so we patch it here + elif grid == "eORCA025_T": + d["shape"] = (1442, 1207) + + @property + def grid(self): + return self._grid + + @property + def shape(self): + return self._grid.shape + + @property + def spec(self): + return self._grid.spec + + +class CustomGridSpec(GridSpec): + @property + def grid(self): + return None + + @property + def shape(self): + return None + + @property + def spec(self): + return dict(self) diff --git a/src/earthkit/geo/regrid/regrid.py b/src/earthkit/geo/regrid/regrid.py new file mode 100644 index 0000000..d693f6c --- /dev/null +++ b/src/earthkit/geo/regrid/regrid.py @@ -0,0 +1,29 @@ +# (C) Copyright 2023 ECMWF. +# +# This software is licensed under the terms of the Apache Licence Version 2.0 +# which can be obtained at http://www.apache.org/licenses/LICENSE-2.0. +# In applying this licence, ECMWF does not waive the privileges and immunities +# granted to it by virtue of its status as an intergovernmental organisation +# nor does it submit to any jurisdiction. +# + + +def _is_array(values): # IGNORE + import numpy as np + + return isinstance(values, np.ndarray) # IGNORE + + +def regrid(data, grid=None, *, interpolation="linear", backend="mir", **kwargs): + from earthkit.geo.regrid.data import get_data_handler + + h = get_data_handler(data) + if h is None: + if _is_array(data): + txt = f"Unsupported data type={type(data)}. Use earthkit.geo.regrid.array.regrid.regrid() for arrays" + else: + txt = f"Unsupported type={type(data)}" + raise ValueError(txt) + + kwargs = kwargs.copy() + return h.regrid(data, grid=grid, interpolation=interpolation, backend=backend, **kwargs) diff --git a/src/earthkit/geo/rotate.py b/src/earthkit/geo/rotate.py index 351e15c..9f9c7d7 100644 --- a/src/earthkit/geo/rotate.py +++ b/src/earthkit/geo/rotate.py @@ -8,9 +8,7 @@ # from . import constants -from .coord import _normalise_lon -from .coord import latlon_to_xyz -from .coord import xyz_to_latlon +from .coord import _normalise_lon, latlon_to_xyz, xyz_to_latlon def _normalise(x): @@ -18,9 +16,7 @@ def _normalise(x): def _rotation_matrix(south_pole_lat, south_pole_lon): - """ - Define matrix for spherical rotation. - """ + """Define matrix for spherical rotation.""" import numpy as np theta = -np.deg2rad(south_pole_lat - constants.SOUTH_POLE_LAT) @@ -76,7 +72,7 @@ def rotate(lat, lon, south_pole_lat, south_pole_lon): (array([-20.]), array([-40.])) For more examples, see: - - :ref:`/examples/rotate.ipynb` + - :ref:`/examples/geo/rotate.ipynb` """ import numpy as np diff --git a/src/earthkit/geo/sphinxext/__init__.py b/src/earthkit/geo/sphinxext/__init__.py new file mode 100644 index 0000000..95c06dc --- /dev/null +++ b/src/earthkit/geo/sphinxext/__init__.py @@ -0,0 +1,8 @@ +# (C) Copyright 2020 ECMWF. +# +# This software is licensed under the terms of the Apache Licence Version 2.0 +# which can be obtained at http://www.apache.org/licenses/LICENSE-2.0. +# In applying this licence, ECMWF does not waive the privileges and immunities +# granted to it by virtue of its status as an intergovernmental organisation +# nor does it submit to any jurisdiction. +# diff --git a/src/earthkit/geo/sphinxext/generate_config_env_rst.py b/src/earthkit/geo/sphinxext/generate_config_env_rst.py new file mode 100644 index 0000000..8098f3d --- /dev/null +++ b/src/earthkit/geo/sphinxext/generate_config_env_rst.py @@ -0,0 +1,36 @@ +#!/usr/bin/env python3 + +# (C) Copyright 2020 ECMWF. +# +# This software is licensed under the terms of the Apache Licence Version 2.0 +# which can be obtained at http://www.apache.org/licenses/LICENSE-2.0. +# In applying this licence, ECMWF does not waive the privileges and immunities +# granted to it by virtue of its status as an intergovernmental organisation +# nor does it submit to any jurisdiction. +# + +import re + +from earthkit.geo.utils.config import CONFIG_AND_HELP, env_var_name + + +def execute(*args): + print() + print(".. list-table::") + print(" :header-rows: 1") + print(" :widths: 40 60") + print() + print(" * - Config option name") + print(" - Environment variable") + print() + for k, v in sorted(CONFIG_AND_HELP.items()): + if len(args) and not any(re.match(arg, k) for arg in args): + continue + + print(" * - ", k.replace("-", "\u2011")) # Non-breaking hyphen + print(" - ", f"{env_var_name(k)}") + print() + + +if __name__ == "__main__": + execute() diff --git a/src/earthkit/geo/sphinxext/generate_config_rst.py b/src/earthkit/geo/sphinxext/generate_config_rst.py new file mode 100644 index 0000000..acaa3cd --- /dev/null +++ b/src/earthkit/geo/sphinxext/generate_config_rst.py @@ -0,0 +1,64 @@ +#!/usr/bin/env python3 + +# (C) Copyright 2020 ECMWF. +# +# This software is licensed under the terms of the Apache Licence Version 2.0 +# which can be obtained at http://www.apache.org/licenses/LICENSE-2.0. +# In applying this licence, ECMWF does not waive the privileges and immunities +# granted to it by virtue of its status as an intergovernmental organisation +# nor does it submit to any jurisdiction. +# + +import getpass +import os +import re + +from earthkit.geo.utils.config import CONFIG_AND_HELP + +HOME = os.path.expanduser("~/") +USER = getpass.getuser() + + +def tidy(x): + if isinstance(x, (list, tuple)): + return [tidy(y) for y in x] + + if isinstance(x, dict): + d = {} + for k, v in x.items(): + d[k] = tidy(v) + return d + + if isinstance(x, str): + if x.startswith(HOME): + n = len(HOME) + return tidy("~/{}".format(x[n:])) + + if "-" + USER in x: + return tidy(x.replace("-" + USER, "-${USER}")) + + return x + + +def execute(*args): + print() + print(".. list-table::") + print(" :header-rows: 1") + print(" :widths: 10 10 70") + print() + print(" * - Name") + print(" - Default") + print(" - Description") + print() + for k, v in sorted(CONFIG_AND_HELP.items()): + if len(args) and not any(re.match(arg, k) for arg in args): + continue + + print(" * - ", k.replace("-", "\u2011")) # Non-breaking hyphen + print(" - ", repr(tidy(v.docs_default)).replace("-", "\u2011")) + print(" - ", v.docs_description) + print() + + +if __name__ == "__main__": + execute() diff --git a/src/earthkit/geo/sphinxext/generate_inventory_rst.py b/src/earthkit/geo/sphinxext/generate_inventory_rst.py new file mode 100644 index 0000000..ba44e9b --- /dev/null +++ b/src/earthkit/geo/sphinxext/generate_inventory_rst.py @@ -0,0 +1,190 @@ +# (C) Copyright 2023 ECMWF. +# +# This software is licensed under the terms of the Apache Licence Version 2.0 +# which can be obtained at http://www.apache.org/licenses/LICENSE-2.0. +# In applying this licence, ECMWF does not waive the privileges and immunities +# granted to it by virtue of its status as an intergovernmental organisation +# nor does it submit to any jurisdiction. +# + +import hashlib +import json +from collections import defaultdict, namedtuple + +from earthkit.geo.regrid.backends.db import SYS_DB as DB +from earthkit.geo.regrid.gridspec import GridSpec + +Specs = namedtuple("Specs", ["source", "target"]) + + +BLOCK_COL_NUM = 3 + + +def sort_key_gridspec(gs): + grid = gs["grid"] + if isinstance(grid, str): + return (1000, grid) + elif isinstance(grid, list) and grid: + return (grid[0], grid[1]) + + return (0, 0) + + +def to_str(gs): + if isinstance(gs, str): + return gs + + grid = gs["grid"] + if isinstance(grid, str) and grid.startswith("H"): + return {"grid": gs["grid"], "order": gs["order"]} + else: + return {"grid": gs["grid"]} + + +def make_gs_block(source, target): + while len(target) % BLOCK_COL_NUM != 0: + target.append("") + + step = len(target) // BLOCK_COL_NUM + + source_grid = source["grid"] + + CODE_LINE = " {}" + FIRST_COL = """ + * - .. code-block:: python + +""" + + OTHER_COL = """ + - .. code-block:: python + +""" + + txt = rf""" + +{source_grid} ++++++++++++++++++++++++++ + +Source :ref:`gridspec `: + +.. code-block:: python + + {to_str(source)} + + +Target :ref:`gridspec `\s available for source: + +.. list-table:: + :header-rows: 0 + +""" + + for k in range(BLOCK_COL_NUM): + txt += FIRST_COL if k == 0 else OTHER_COL + for i in range(k * step, (k + 1) * step): + txt += CODE_LINE.format(to_str(target[i])) + "\n" + + return txt + + +def match(gs, grid): + for name, val in grid.items(): + if name == "type": + continue + if hasattr(gs, name): + if getattr(gs, name) != val: + return False + else: + return False + return True + + +def build_gs_page(specs, grid, long_name): + txt = f""" + +.. include:: pre_gen_warn.rst + +This page contains all the available target gridspecs for a given +**{long_name}** source :ref:`gridspec `. + +""" + + # print(f"{grid=}\n") + for _, v in specs.items(): + source = v.source + target = v.target + + if source["type"] != grid["type"]: + continue + + if match(source, grid): + # print(f"->{source=}\n") + # for t in target: + # print(f" {t=}\n") + txt += make_gs_block(source, target) + + return txt + + +def load_matrix_index_file(): + specs = defaultdict(Specs) + + for _, entry in DB.index.items(): + gs_in = GridSpec.from_dict(entry["input"]) + gs_out = GridSpec.from_dict(entry["output"]) + + # only entires available for interpolation will + # be considered for the inventory + if entry["interpolation"]["method"] == "linear": + # key = dict(grid=gs_in["grid"]) + key = dict(gs_in) + m = hashlib.sha256() + m.update(json.dumps(key).encode("utf-8")) + gs_id = m.hexdigest() + + if gs_id not in specs: + specs[gs_id] = Specs(gs_in, [gs_out]) + else: + specs[gs_id].target.append(gs_out) + + for k in specs: + target = sorted(specs[k].target, key=sort_key_gridspec) + specs[k] = Specs(specs[k].source, target) + + return specs + + +def execute(*args): + specs = load_matrix_index_file() + + grid_type = args[0] + + gs = {} + if grid_type == "reduced_gg_o": + gs["type"] = "reduced_gg" + gs["octahedral"] = True + elif grid_type == "reduced_gg": + gs["type"] = "reduced_gg" + gs["octahedral"] = False + elif grid_type == "healpix_ring": + gs["type"] = "healpix" + gs["order"] = "ring" + elif grid_type == "healpix_nested": + gs["type"] = "healpix" + gs["order"] = "nested" + else: + gs["type"] = grid_type + + if len(args) >= 2: + long_name = " ".join(args[1:]) + long_name = long_name.replace('"', "") + else: + long_name = grid_type + + # print(f"{gs=}\n") + txt = build_gs_page(specs, gs, long_name) + print(txt) + + +if __name__ == "__main__": + execute() diff --git a/src/earthkit/geo/sphinxext/module_output.py b/src/earthkit/geo/sphinxext/module_output.py new file mode 100644 index 0000000..f1f6be5 --- /dev/null +++ b/src/earthkit/geo/sphinxext/module_output.py @@ -0,0 +1,63 @@ +# (C) Copyright 2020 ECMWF. +# +# This software is licensed under the terms of the Apache Licence Version 2.0 +# which can be obtained at http://www.apache.org/licenses/LICENSE-2.0. +# In applying this licence, ECMWF does not waive the privileges and immunities +# granted to it by virtue of its status as an intergovernmental organisation +# nor does it submit to any jurisdiction. +# + +import sys +import traceback +from importlib import import_module +from io import StringIO + +from docutils import statemachine +from docutils.parsers.rst import Directive + +# Examples at https://github.com/docutils-mirror/docutils + + +class ModuleOutput(Directive): + has_content = True + + def run(self): + self.assert_has_content() + + save = sys.stdout + try: + # Get current file + current_rst_file = self.state_machine.input_lines.source(self.lineno - self.state_machine.input_offset - 1) + + args = [x for x in self.content if x != ""][0].split(" ") + name = args.pop(0) + + module = import_module("..%s" % (name.replace("-", "_"),), package=__name__) + + # from earthkit.geo.sphinxext import generate_settings_rst as module + + sys.stdout = StringIO() + module.execute(*args) + out = sys.stdout.getvalue() + + # Parse output + rst_lines = statemachine.string2lines(out) + # Insert in place + self.state_machine.insert_input(rst_lines, current_rst_file) + + except Exception: + # rst_lines = statemachine.string2lines(str(e)) + rst_lines = statemachine.string2lines(name + "\n" + traceback.format_exc()) + self.state_machine.insert_input(rst_lines, current_rst_file) + finally: + sys.stdout = save + return [] + + +def setup(app): + app.add_directive("module-output", ModuleOutput) + return { + "version": "0.1", + "parallel_read_safe": True, + "parallel_write_safe": True, + } diff --git a/docs/_ext/xref.py b/src/earthkit/geo/sphinxext/xref.py similarity index 100% rename from docs/_ext/xref.py rename to src/earthkit/geo/sphinxext/xref.py diff --git a/src/earthkit/geo/utils/__init__.py b/src/earthkit/geo/utils/__init__.py new file mode 100644 index 0000000..f3965e0 --- /dev/null +++ b/src/earthkit/geo/utils/__init__.py @@ -0,0 +1,76 @@ +# (C) Copyright 2023 ECMWF. +# +# This software is licensed under the terms of the Apache Licence Version 2.0 +# which can be obtained at http://www.apache.org/licenses/LICENSE-2.0. +# In applying this licence, ECMWF does not waive the privileges and immunities +# granted to it by virtue of its status as an intergovernmental organisation +# nor does it submit to any jurisdiction. +# +import sys + +try: + # There is a bug in tqdm that expects ipywidgets + # to be installed if running in a notebook + import ipywidgets # noqa F401 + from tqdm.auto import tqdm # noqa F401 +except ImportError: + from tqdm import tqdm # noqa F401 + + +def progress_bar(*, total=None, iterable=None, initial=0, desc=None): + return tqdm( + iterable=iterable, + total=total, + initial=initial, + unit_scale=True, + unit_divisor=1024, + unit="B", + disable=False, + leave=False, + desc=desc, + # dynamic_ncols=True, # make this the default? + ) + + +class NoBar: + def __init__(self, *args, **kwargs): + pass + + def __enter__(self): + return self + + def __exit__(self, *args, **kwargs): + pass + + def update(self, *args, **kwargs): + pass + + def close(self, *args, **kwargs): + pass + + +def no_progress_bar(total, initial=0, desc=None): + return NoBar( + total=total, + initial=initial, + unit_scale=True, + unit_divisor=1024, + unit="B", + disable=False, + leave=False, + desc=desc, + ) + + +def is_module_loaded(module_name): + return module_name in sys.modules + + +def ensure_list(obj): + """Ensure that the input is a list.""" + if isinstance(obj, list): + return obj + elif isinstance(obj, tuple): + return list(obj) + else: + return [obj] diff --git a/src/earthkit/geo/utils/builder.py b/src/earthkit/geo/utils/builder.py new file mode 100644 index 0000000..025afdc --- /dev/null +++ b/src/earthkit/geo/utils/builder.py @@ -0,0 +1,151 @@ +# (C) Copyright 2023 ECMWF. +# +# This software is licensed under the terms of the Apache Licence Version 2.0 +# which can be obtained at http://www.apache.org/licenses/LICENSE-2.0. +# In applying this licence, ECMWF does not waive the privileges and immunities +# granted to it by virtue of its status as an intergovernmental organisation +# nor does it submit to any jurisdiction. +# + +import hashlib +import json +import os + +from scipy.sparse import load_npz + +from earthkit.geo.regrid.backends.db import VERSION, MatrixIndex + +from .matrix import matrix_memory_size +from .mir import mir_cached_matrix_to_file + + +def regular_ll(entry): + bb = entry["bbox"] + d = { + "grid": [entry["increments"][x] for x in ("west_east", "south_north")], + "shape": [entry["nj"], entry["ni"]], + "area": [bb["north"], bb["west"], bb["south"], bb["east"]], + } + if "global" in entry: + d["global"] = entry["global"] + return d + + +def reduced_gg(entry): + pl = entry["pl"] + G = "O" if pl[1] - pl[0] == 4 else "N" + N = entry["N"] + bb = entry["bbox"] + + d = { + "grid": f"{G}{N}", + "shape": [sum(pl)], + "area": [bb["north"], bb["west"], bb["south"], bb["east"]], + } + + if "global" in entry: + d["global"] = entry["global"] + + return d + + +def healpix(entry): + d = {"grid": entry["grid"], "order": entry["order"]} + return d + + +def orca(entry): + d = {"grid": entry["unstructuredGridType"] + "_" + entry["unstructuredGridSubtype"]} + return d + + +def make_sha(d): + m = hashlib.sha256() + m.update(json.dumps(d, sort_keys=True).encode("utf-8")) + return m.hexdigest() + + +def get_method_name(entry): + method = entry["interpolation"]["method"] + if isinstance(method, dict): + method = method["type"] + return method + + +def make_matrix(input_path, output_path, index_file=None, global_input=None, global_output=None): + + with open(input_path) as f: + entry = json.load(f) + + inter_ori = dict(entry["interpolation"]) + method_name = MatrixIndex.interpolation_method_name(entry) + + uid = MatrixIndex.make_interpolation_uid(entry) + if uid != method_name: + entry["interpolation"]["_uid"] = uid + else: + entry["interpolation"]["method"] = method_name + + # create output folder + matrix_output_path = os.path.join( + output_path, + MatrixIndex.matrix_dir_name(entry), + # f"{inter_engine}_{inter_version}_{inter_uid}" + ) + os.makedirs(matrix_output_path, exist_ok=True) + + # create matrix + cache_file = entry["matrix"].pop("cache_file") + m = {} + m["input"] = entry["input"] + m["output"] = entry["output"] + m["interpolation"] = inter_ori + + key = make_sha(m) + name = key + + print(f"entry={entry}") + npz_file = os.path.join(matrix_output_path, f"{name}.npz") + mir_cached_matrix_to_file(cache_file, npz_file) + + if index_file is None: + index_file = os.path.join(output_path, "index.json") + + if os.path.exists(index_file): + with open(index_file) as f: + index = json.load(f) + if index.get("version", None) != VERSION: + raise ValueError(f"{index_file=} version must be {VERSION}") + else: + index = {} + index["version"] = VERSION + index["matrix"] = {} + + def convert(x): + proc = globals()[x["type"]] + return proc(x) + + if global_input is not None and "global" not in entry["input"]: + entry["input"]["global"] = 1 if global_input else 0 + + if global_output is not None and "global" not in entry["output"]: + entry["output"]["global"] = 1 if global_output else 0 + + # get matrix size + z = load_npz(npz_file) + mem_size = matrix_memory_size(z) + z = None + + index["matrix"][key] = dict( + input=convert(entry["input"]), + output=convert(entry["output"]), + interpolation=entry["interpolation"], + nnz=entry["matrix"]["nnz"], + memory=mem_size, + ) + + with open(index_file, "w") as f: + json.dump(index, f, indent=4) + + print("Written", npz_file) + print("Written", index_file) diff --git a/src/earthkit/geo/utils/caching.py b/src/earthkit/geo/utils/caching.py new file mode 100644 index 0000000..0c8d3d1 --- /dev/null +++ b/src/earthkit/geo/utils/caching.py @@ -0,0 +1,1075 @@ +# (C) Copyright 2023 ECMWF. +# +# This software is licensed under the terms of the Apache Licence Version 2.0 +# which can be obtained at http://www.apache.org/licenses/LICENSE-2.0. +# In applying this licence, ECMWF does not waive the privileges and immunities +# granted to it by virtue of its status as an intergovernmental organisation +# nor does it submit to any jurisdiction. +# + +import ctypes +import datetime +import hashlib +import json +import logging +import os +import platform +import shutil +import sqlite3 +import threading +import time +from abc import ABCMeta, abstractmethod +from copy import deepcopy +from random import randrange + +from earthkit.geo.utils import humanize +from earthkit.geo.utils.config import CONFIG +from earthkit.geo.utils.html import css +from earthkit.geo.utils.temporary import temp_directory + +VERSION = 2 +CACHE_DB = f"cache-{VERSION}.db" + +LOG = logging.getLogger(__name__) + + +CONNECTION = None +CACHE = None + + +class DiskUsage: + def __init__(self, path): + path = os.path.realpath(path) + self.path = path + + if platform.system() == "Windows": + avail = ctypes.c_ulonglong() + total = ctypes.c_ulonglong() + free = ctypes.c_ulonglong() + + ctypes.windll.kernel32.GetDiskFreeSpaceExW( + ctypes.c_wchar_p(path), + ctypes.pointer(avail), + ctypes.pointer(total), + ctypes.pointer(free), + ) + self.avail = avail.value + self.total = total.value + self.free = free.value + else: + st = os.statvfs(path) + self.free = st.f_bfree * st.f_frsize + self.total = st.f_blocks * st.f_frsize + self.avail = st.f_bavail * st.f_frsize + + self.percent = int(float(self.total - self.avail) / float(self.total) * 100 + 0.5) + + def __repr__(self): + return ( + f"DiskUsage(total={self.total},free={self.free},avail={self.avail},percent={self.percent},path={self.path})" + ) + + +def disk_usage(path): + return DiskUsage(path) + + +def default_serialiser(o): + import pandas as pd + + if isinstance(o, (datetime.date, datetime.datetime)): + return o.isoformat() + if isinstance(o, (pd.Timestamp)): + return o.isoformat() + if isinstance(o, (pd.DatetimeIndex)): + return [_.isoformat() for _ in o] + return json.JSONEncoder.default(o) + + +class Future: + def __init__(self, func, args, kwargs): + self.func = func + self.args = args + self.kwargs = kwargs + self._condition = threading.Condition() + self._ready = False + self._result = None + + def execute(self): + try: + self._result = self.func(*self.args, **self.kwargs) + except Exception as e: + LOG.error(e) + self._result = e + with self._condition: + self._ready = True + self._condition.notify_all() + + def result(self): + with self._condition: + while not self._ready: + self._condition.wait() + if isinstance(self._result, Exception): + raise self._result + return self._result + + +class CacheManager(threading.Thread): + def __init__(self): + super().__init__(daemon=True) + self._connection = None + self._queue = [] + self._condition = threading.Condition() + self._policy = EmptyCachePolicy() + + def run(self): + while True: + with self._condition: + while len(self._queue) == 0: + self._condition.wait() + s = self._queue.pop(0) + self._condition.notify_all() + s.execute() + + @property + def connection(self): + if self._policy.managed() and self._connection is None: + self._connection = self.new_connection() + + return self._connection + + def new_connection(self): + assert self._policy.managed() + cache_dir = self._policy.directory() + cache_db = os.path.join(cache_dir, CACHE_DB) + LOG.debug("Cache database is %s", cache_db) + connection = sqlite3.connect(cache_db) + # So we can use rows as dictionaries + connection.row_factory = sqlite3.Row + + # If you change the schema, change VERSION above + connection.execute( + """ + CREATE TABLE IF NOT EXISTS cache ( + path TEXT PRIMARY KEY, + owner TEXT NOT NULL, + args TEXT NOT NULL, + creation_date TEXT NOT NULL, + flags INTEGER DEFAULT 0, + owner_data TEXT, + last_access TEXT NOT NULL, + type TEXT, + parent TEXT, + replaced TEXT, + extra TEXT, + expires INTEGER, + accesses INTEGER, + size INTEGER);""" + ) + return connection + + def enqueue(self, func, *args, **kwargs): + with self._condition: + s = Future(func, args, kwargs) + self._queue.append(s) + self._condition.notify_all() + return s + + def _ensure_in_cache(self, path): + assert self._policy.file_in_cache_directory(path), f"File not in cache {path}" + + def _config_changed(self, policy): + LOG.debug("Config changed") + self._policy = policy + self._connection = None # The user may have changed the cache directory + self._check_cache_size() + + def _latest_date(self): + """Returns the latest date to be used when purging the cache. + So we do not purge files being downloaded. + """ + with self.connection as db: + # TODO; this is not perfect, since it is not guaranteed that an empty file is actually being + # downloaded. So an old empty file will block removing the files by _decache when the cache + # limit is exceeded. Must be improved by at least adding a time margin + latest = db.execute("SELECT MIN(creation_date) FROM cache WHERE size IS NULL").fetchone()[0] + if latest is None: + latest = db.execute("SELECT MAX(creation_date) FROM cache WHERE size IS NOT NULL").fetchone()[0] + if latest is None: + latest = datetime.datetime.now() + return latest + + def _purge_cache(self, matcher=None): + if matcher is None: + self._housekeeping(clean=True) + # _update_cache(clean=True) + self._decache(self._cache_size(), purge=True) + return + + dump = self._dump_cache_database(matcher) + for entry in dump: + self._delete_entry(entry) + + def _cache_entries(self): + result = [] + with self.connection as db: + for n in db.execute("SELECT * FROM cache").fetchall(): + n = dict(n) + n["args"] = json.loads(n["args"]) + try: + n["owner_data"] = json.loads(n["owner_data"]) + except Exception: + pass + if os.path.exists(n["path"]): + result.append(n) + return result + + def _update_entry(self, path, owner_data=None): + self._ensure_in_cache(path) + + if os.path.isdir(path): + kind = "directory" + size = 0 + for root, _, files in os.walk(path): + for f in files: + size += os.path.getsize(os.path.join(root, f)) + else: + kind = "file" + size = os.path.getsize(path) + + with self.connection as db: + db.execute( + "UPDATE cache SET size=?, type=?, owner_data=? WHERE path=?", + ( + size, + kind, + json.dumps(owner_data, default=default_serialiser), + path, + ), + ) + + def _update_cache(self, clean=False): + """Update cache size and size of each file in the database .""" + with self.connection as db: + update = [] + commit = False + for n in db.execute("SELECT path FROM cache WHERE size IS NULL"): + try: + path = n[0] + if os.path.isdir(path): + kind = "directory" + size = 0 + for root, _, files in os.walk(path): + for f in files: + size += os.path.getsize(os.path.join(root, f)) + else: + kind = "file" + size = os.path.getsize(path) + update.append((size, kind, path)) + except Exception: + if clean: + db.execute("DELETE from cache WHERE path=?", (path,)) + commit = True + + if update: + db.executemany("UPDATE cache SET size=?, type=? WHERE path=?", update) + + if update or commit: + db.commit() + + def _housekeeping(self, clean=False): + top = self._policy.directory() + with self.connection as db: + for name in os.listdir(top): + if name == CACHE_DB: + continue + + full = os.path.join(top, name) + count = db.execute("SELECT count(*) FROM cache WHERE path=?", (full,)).fetchone()[0] + + if count > 0: + continue + + parent = None + start = full.split(".")[0] + "%" + for n in db.execute( + "SELECT path FROM cache WHERE parent IS NULL and path LIKE ?", + (start,), + ).fetchall(): + if full.startswith(n["path"]): + parent = n["path"] + break + + try: + s = os.stat(full) + if time.time() - s.st_mtime < 120: # Two minutes + continue + except OSError: + pass + + if parent is None: + LOG.debug(f"earthkit-geo cache: orphan found: {full}") + else: + LOG.debug(f"earthkit-geo cache: orphan found: {full} with parent {parent}") + + self._register_cache_file( + full, + "orphans", + None, + parent, + ) + self._update_cache(clean=clean) + + def _delete_file(self, path): + self._ensure_in_cache(path) + + try: + if os.path.isdir(path) and not os.path.islink(path): + shutil.rmtree(path) + else: + os.unlink(path) + except Exception as e: + LOG.exception(f"Deleting {path}", e) + + def _entry_to_dict(self, entry): + n = dict(entry) + for k in ("args", "owner_data"): + if k in n and isinstance(n[k], str): + try: + n[k] = json.loads(n[k]) + except Exception: + LOG.debug("Cannot decode JSON %s", n[k]) + pass + return n + + def _delete_entry(self, entry): + if isinstance(entry, str): + entry = dict( + path=entry, + size=0, + owner=None, + args=None, + ) + try: + entry["size"] = os.path.getsize(entry["path"]) + except OSError: + pass + + if entry["size"] is None: + if not isinstance(entry, dict): + entry = self._entry_to_dict(entry) + entry["size"] = 0 + + path, size, owner, args = ( + entry["path"], + entry["size"], + entry["owner"], + entry["args"], + ) + + if logging.DEBUG >= LOG.getEffectiveLevel(): + LOG.debug( + "Deleting entry %s", + json.dumps(self._entry_to_dict(entry), indent=4, default=default_serialiser), + ) + + total = 0 + + # First, delete child files, e.g. unzipped data + with self.connection as db: + for child in db.execute("SELECT * FROM cache WHERE parent = ?", (path,)): + total += self._delete_entry(child) + + if not os.path.exists(path): + LOG.warning(f"cache file lost: {path}") + with self.connection as db: + db.execute("DELETE FROM cache WHERE path=?", (path,)) + return total + + LOG.debug(f"earthkit-geo cache: deleting {path} ({humanize.bytes(size)})") + LOG.debug(f"earthkit-geo cache: {owner} {args}") + + self._delete_file(path) + + with self.connection as db: + db.execute("DELETE FROM cache WHERE path=?", (path,)) + + return total + size + + def _decache(self, bytes, purge=False): + # _find_orphans() + # _update_cache(clean=True) + + if bytes <= 0: + return 0 + + LOG.warning("earthkit-geo cache: trying to free %s", humanize.bytes(bytes)) + + total = 0 + + with self.connection as db: + latest = datetime.datetime.now() if purge else self._latest_date() + + for stmt in ( + "SELECT * FROM cache WHERE size IS NOT NULL AND owner='orphans' AND creation_date < ?", + "SELECT * FROM cache WHERE size IS NOT NULL AND creation_date < ? ORDER BY last_access ASC", + ): + for entry in db.execute(stmt, (latest,)): + total += self._delete_entry(entry) + if total >= bytes: + LOG.warning( + "earthkit-geo cache: freed %s from cache", + humanize.bytes(bytes), + ) + return total + + LOG.warning("earthkit-geo cache: could not free %s", humanize.bytes(bytes)) + + def _register_cache_file(self, path, owner, args, parent=None): + """Register a file in the cache + + Parameters + ---------- + path : str + Cache file to register + owner : str + Owner of the cache file (generally a source or a dataset) + args : dict + Dictionary to save with the file in the database, as json string. + + Returns + ------- + changes : + None or False if database does not need to be updated. TODO: clarify. + """ + self._ensure_in_cache(path) + + with self.connection as db: + now = datetime.datetime.now() + + args = json.dumps(args, default=default_serialiser) + + db.execute( + """ + UPDATE cache + SET accesses = accesses + 1, + last_access = ? + WHERE path=?""", + (now, path), + ) + + changes = db.execute("SELECT changes()").fetchone()[0] + + if not changes: + db.execute( + """ + INSERT INTO cache( + path, + owner, + args, + creation_date, + last_access, + accesses, + parent) + VALUES(?,?,?,?,?,?,?)""", + (path, owner, args, now, now, 1, parent), + ) + + return dict(db.execute("SELECT * FROM cache WHERE path=?", (path,)).fetchone()) + + def _cache_size(self): + LOG.debug("cache_size") + with self.connection as db: + size = db.execute("SELECT SUM(size) FROM cache").fetchone()[0] + if size is None: + size = 0 + return size + + def _decache_file(self, path): + self._delete_entry(path) + + def _check_cache_size(self): + if self._policy.managed(): + # Check absolute limit + maximum = self._policy.maximum_cache_size() + if maximum is not None: + size = self._cache_size() + if size > maximum: + self._housekeeping() + LOG.warning( + ( + f"earthkit-geo cache: cache size({humanize.bytes(size)}) exceeds limit" + f" ({humanize.bytes(maximum)}) set by 'maximum-cache-size' config option" + ) + ) + self._decache(size - maximum) + + # Check relative limit + usage = self._policy.maximum_cache_disk_usage() + if usage is not None: + size = self._cache_size() + df = disk_usage(self._policy.directory()) + if df.percent > usage: + self._housekeeping() + delta = (df.percent - usage) * df.total * 0.01 + LOG.warning( + ( + f"earthkit-geo cache: filesystem usage ({df.percent}%) exceeds limit ({usage}%)" + f" set by 'maximum-cache-disk-usage' config option" + ) + ) + self._decache(delta) + + def _repr_html_(self): + """Return a html representation of the cache . + + Returns + ------- + str + HTML status of the cache. + """ + html = [css("table")] + with self.new_connection() as db: + for n in db.execute("SELECT * FROM cache"): + n = dict(n) + n["missing"] = not os.path.exists(n["path"]) + n["temporary"] = os.path.exists(n["path"] + ".tmp") or os.path.exists( + n["path"] + ".tmp.download" + ) # TODO: decide how to handle temporary extension + if n["size"] is None: + n["size"] = 0 + html.append("") + html.append("" % (n["path"],)) + + for k in [x for x in n.keys() if x not in ("path", "owner_data")]: + v = humanize.bytes(n[k]) if k == "size" else n[k] + html.append("" % (k, v)) + html.append("
%s
%s%s
") + html.append("
") + return "".join(html) + + def _dump_cache_database(self, matcher=lambda x: True): + result = [] + with self.connection as db: + for d in db.execute("SELECT * FROM cache"): + n = dict(d) + for k in ("args", "owner_data"): + if n[k] is not None: + n[k] = json.loads(n[k]) + if matcher(n): + result.append(n) + return result + + def _summary_dump_cache_database(self, matcher=lambda x: True): + result = self._dump_cache_database(matcher=matcher) + count = len(result) + size = 0 + for r in result: + size += r.get("size", 0) + return count, size + + +class CachePolicy(metaclass=ABCMeta): + CACHE_KEYS = [ + "cache-policy", + "user-cache-directory", + "temporary-cache-directory-root", + "maximum-cache-disk-usage", + "maximum-cache-size", + ] + + OUTDATED_CHECK_KEYS = None + _name = None + + def __init__(self): + self._config = {k: CONFIG.get(k) for k in self.CACHE_KEYS} + + @property + def name(self): + return self._name + + @staticmethod + def from_config(): + name = CONFIG.get("cache-policy") + p = _cache_policies.get(name, None) + if p is not None: + return p() + else: + raise NotImplementedError(f"Unknown cache policy={name}") + + def outdated(self): + return any(self._config.get(k) != CONFIG.get(k) for k in self.OUTDATED_CHECK_KEYS) + + def update(self): + changed = False + for k in self.CACHE_KEYS: + if self._config.get(k) != CONFIG.get(k): + changed = True + if k not in self.OUTDATED_CHECK_KEYS: + self._config[k] = CONFIG.get(k) + return changed + + @abstractmethod + def managed(self): + pass + + @abstractmethod + def directory(self): + pass + + @abstractmethod + def use_message_position_index_cache(self): + pass + + @abstractmethod + def is_cache_size_managed(self): + pass + + @abstractmethod + def maximum_cache_size(self): + pass + + @abstractmethod + def maximum_cache_disk_usage(self): + pass + + def file_in_cache_directory(self, path): + return path.startswith(self.directory()) + + @staticmethod + def _expand_path(path): + if path is not None: + path = os.path.expanduser(path) + return path + + +class EmptyCachePolicy(CachePolicy): + _name = "empty" + + def managed(self): + return False + + def directory(self): + return None + + def use_message_position_index_cache(self): + return False + + def is_cache_size_managed(self): + return False + + def maximum_cache_size(self): + return None + + def maximum_cache_disk_usage(self): + return None + + def __repr__(self): + return self.__class__.__name__ + + +class NoCachePolicy(CachePolicy): + OUTDATED_CHECK_KEYS = ["cache-policy", "temporary-directory-root"] + _name = "off" + _dir = None + + def managed(self): + return False + + def directory(self): + if self._dir is None: + if self._dir is None: + root_dir = self._expand_path(self._config.get("temporary-directory-root")) + self._dir = temp_directory(dir=root_dir) + return self._dir.path + + def use_message_position_index_cache(self): + return False + + def is_cache_size_managed(self): + return False + + def maximum_cache_size(self): + return None + + def maximum_cache_disk_usage(self): + return None + + def __repr__(self): + return self.__class__.__name__ + + +class UserCachePolicy(CachePolicy): + OUTDATED_CHECK_KEYS = ["cache-policy", "user-cache-directory"] + _name = "user" + + def __init__(self): + super().__init__() + self._path = self._expand_path(self._config.get("user-cache-directory")) + if not os.path.exists(self._path): + os.makedirs(self._path, exist_ok=True) + + def managed(self): + return True + + def directory(self): + return self._path + + def use_message_position_index_cache(self): + return self._config.get("use-message-position-index-cache") + + def is_cache_size_managed(self): + return self.maximum_cache_size() is not None or self.maximum_cache_disk_usage() is not None + + def maximum_cache_size(self): + return self._config.get("maximum-cache-size") + + def maximum_cache_disk_usage(self): + return self._config.get("maximum-cache-disk-usage") + + def __repr__(self): + r = ( + f"{self.__class__.__name__}[" + f"user-cache-directory={self.directory()}" + f", maximum-cache-size={self.maximum_cache_size()}" + f", maximum-cache-disk-usage={self.maximum_cache_disk_usage()}" + "]" + ) + return r + + +class TmpCachePolicy(UserCachePolicy): + OUTDATED_CHECK_KEYS = ["cache-policy", "temporary-cache-directory-root"] + _name = "temporary" + + def __init__(self): + super().__init__() + root_dir = self._expand_path(self._config.get("temporary-cache-directory-root")) + self._dir = temp_directory(dir=root_dir) + + def directory(self): + return self._dir.path + + +_cache_policies = { + "off": NoCachePolicy, + "temporary": TmpCachePolicy, + "user": UserCachePolicy, +} + + +class Cache: + """Class controlling the cache. + + See :ref:`caching` for details. + """ + + _created = False + + def __init__(self): + if Cache._created: + raise RuntimeError("Cannot create multiple instances of Cache") + self._manager = None + self._policy = None + self._policy_lock = threading.Lock() + self._manager_lock = threading.Lock() + Cache._created = True + + @property + def policy(self): + r"""CachePolicy: Get the current cache policy.""" + with self._policy_lock: + if self._policy is None: + self._make_policy() + return self._policy + + def _make_policy(self): + if self._policy is None: + self._policy = CachePolicy.from_config() + LOG.debug(f"Cache: created cache policy={self._policy}") + if self._policy.managed(): + with self._manager_lock: + if self._manager is None: + self._manager = CacheManager() + self._manager.start() + self._call_manager_config_changed() + + def _config_changed(self): + LOG.debug("Cache: config_changed, cache-policy=" + CONFIG.get("cache-policy")) + if self.policy.outdated(): + with self._policy_lock: + # Check again, another thread/process may have modified the policy + if self._policy.outdated(): + self._policy = None + self._make_policy() + elif self.policy.update() and self.policy.managed(): + with self._manager_lock: + self._call_manager_config_changed() + + def _call_manager(self, forget, name, *args, **kwargs): + if self.policy.managed() and self._manager is not None: + with self._manager_lock: + name = "_" + name + func = getattr(self._manager, name) + if forget: + self._manager.enqueue(func, *args, **kwargs) + return None + else: + s = self._manager.enqueue(func, *args, **kwargs) + return s.result() + + def _call_manager_config_changed(self): + s = self._manager.enqueue(self._manager._config_changed, deepcopy(self._policy)) + return s.result() + + def _dump_database(self, *args, **kwargs): + return self._call_manager(False, "dump_cache_database", *args, **kwargs) + + def summary_dump_database(self, *args, **kwargs): + """Return the number of items and total size of the cache. + + Does not work when the ``cache-policy`` is "off". + + Returns + ------- + num: int + number of items in the cache + size: int + total number of bytes stored in the cache + + Examples + -------- + >>> from earthkit.geo import cache + >>> cache.summary_dump_database() + (40, 846785699) + """ + return self._call_manager(False, "summary_dump_cache_database", *args, **kwargs) + + def _register_cache_file(self, *args, **kwargs): + return self._call_manager(False, "register_cache_file", *args, **kwargs) + + def _update_entry(self, *args, **kwargs): + return self._call_manager(False, "update_entry", *args, **kwargs) + + def _decache_file(self, *args, **kwargs): + return self._call_manager(False, "decache_file", *args, **kwargs) + + def check_size(self, *args, **kwargs): + """Check the cache size and trim it down when needed. + + Automatically runs when a new entry is added to the cache or the + :ref:`cache_config` change. Does not work when the + ``cache-policy`` is "off". + + The algorithm includes three steps: + + - first, the cache size is determined + - next, if the size is larger than the limit defined by + the ``maximum-cache-size`` config the oldest cache entries are + removed until the desired size reached + - finally, if the size is larger than the limit defined by the + ``maximum-cache-disk-usage`` config the oldest cache entries are + removed until the desired size reached + + """ + return self._call_manager(True, "check_cache_size", *args, **kwargs) + + def size(self, *args, **kwargs): + """Return the total number of bytes stored in the cache. + + Does not work when the ``cache-policy`` is "off". + """ + return self._call_manager(False, "cache_size", *args, **kwargs) + + def entries(self, *args, **kwargs): + """Dump the entries stored in the cache. + + Does not work when the ``cache-policy`` is "off". + + Returns + ------- + list of dict: + One dict per cache entry. + """ + return self._call_manager(False, "cache_entries", *args, **kwargs) + + def purge(self, *args, **kwargs): + """Delete entries from the cache. + + Does not work when the ``cache-policy`` is "off". + + Parameters + ---------- + **kwargs: dict, optional + Other keyword arguments: + + * matcher: callable + Method to match the cache entries to delete. Its only argument + is a cache entry and should return True if the entry is to be + deleted. + + Examples + -------- + Delete all entries. + + >>> from earthkit.geo import cache + >>> cache.purge() + + Delete all entries where the "owner" is "test_cache". + + >>> from earthkit.geo import cache + >>> cache.purge(matcher=lambda e: ["owner"] == "test_cache") + + """ + return self._call_manager(False, "purge_cache", *args, **kwargs) + + def _housekeeping(self, *args, **kwargs): + return self._call_manager(False, "housekeeping", *args, **kwargs) + + def directory(self): + """Return the path to the current (cache) directory. + + Returns + ------- + str: + The cache directory when ``cache-policy`` is "user" or "temporary". + The temporary directory when ``cache-policy`` is "off". + """ + return self.policy.directory() + + +CACHE = Cache() + + +def cache_file( + owner: str, + create, + args, + hash_extra=None, + extension: str = ".cache", + force=None, + replace=None, +): + """Create a cache or temporary file in the folder specified by the cache-policy. + + Parameters + ---------- + owner: str + The owner of the cache file is generally the name of the source that + called :func:`cache_file`. + create: callable + The method to create the contents of the cache file. + args: list-like + The parameters used to generate the cache key, which is also encoded into the + file name and stored in the cache entry. + extension: str + Extension filename (such as ".nc" for NetCDF, etc.), by default ".cache". + force: callable, bool + Method or flag to decide whether an already existing cache file should + be regenerated. + + Returns + ------- + path: str + Full path to the cache file. + + Notes + ----- + The behaviour depends on the cache policy: + + - If the cache-policy is ``user`` or ``temporary`` the file is created in the + cache-directory and the relevant entries are added to the cache database + using :py:meth:`Cache._register_cache_file`. + + - If the cache-policy is ``off`` the file is created in the temporary directory. + No cache database and monitoring is available. The cache directory is merely + serving as a temporary space. + + """ + managed = CACHE.policy.managed() and CACHE.directory() is not None + + if managed: + m = hashlib.sha256() + m.update(owner.encode("utf-8")) + + m.update(json.dumps(args, sort_keys=True, default=default_serialiser).encode("utf-8")) + m.update(json.dumps(hash_extra, sort_keys=True).encode("utf-8")) + m.update(json.dumps(extension, sort_keys=True).encode("utf-8")) + + if replace is not None: + # Don't replace files that are not in the cache + if not CACHE.policy.file_in_cache_directory(replace): + replace = None + + path = os.path.join( + CACHE.directory(), + "{}-{}{}".format( + owner.lower(), + m.hexdigest(), + extension, + ), + ) + + record = CACHE._register_cache_file(path, owner, args) + if os.path.exists(path): + if callable(force): + owner_data = record["owner_data"] + if owner_data is not None: + owner_data = json.loads(owner_data) + force = force(args, path, owner_data) + + if force: + LOG.info(f"decache file by force: {path=}") + CACHE._decache_file(path) + record = CACHE._register_cache_file(path, owner, args) + + if not os.path.exists(path): + from filelock import FileLock + + lock = path + ".lock" + with FileLock(lock): + if not os.path.exists(path): # Check again, another thread/process may have created the file + owner_data = create(path + ".tmp", args) + os.rename(path + ".tmp", path) + LOG.info(f"cache file created: {path=}") + CACHE._update_entry(path, owner_data) + CACHE.check_size() + + try: + os.unlink(lock) + except OSError: + pass + + else: + # path can be a file or a directory. We have to make the name unique. + m = hashlib.sha256() + m.update(datetime.datetime.now().isoformat().encode("utf-8")) + m.update(str(randrange(10000000)).encode("utf-8")) + + path = os.path.join( + CACHE.directory(), + "{}-{}{}".format( + owner.lower(), + m.hexdigest(), + extension, + ), + ) + + if not os.path.exists(path): + from filelock import FileLock + + lock = path + ".lock" + with FileLock(lock): + if not os.path.exists(path): # Check again, another thread/process may have created the file + owner_data = create(path + ".tmp", args) + os.rename(path + ".tmp", path) + try: + os.unlink(lock) + except OSError: + pass + + return path + + +# housekeeping() +CONFIG.on_change(CACHE._config_changed) diff --git a/src/earthkit/geo/utils/config.py b/src/earthkit/geo/utils/config.py new file mode 100644 index 0000000..f6a7a18 --- /dev/null +++ b/src/earthkit/geo/utils/config.py @@ -0,0 +1,683 @@ +# (C) Copyright 2020 ECMWF. +# +# This software is licensed under the terms of the Apache Licence Version 2.0 +# which can be obtained at http://www.apache.org/licenses/LICENSE-2.0. +# In applying this licence, ECMWF does not waive the privileges and immunities +# granted to it by virtue of its status as an intergovernmental organisation +# nor does it submit to any jurisdiction. +# + +import functools +import logging +import os +import warnings +from abc import ABCMeta, abstractmethod +from contextlib import contextmanager +from typing import Callable + +import yaml + +from earthkit.geo import __version__ as VERSION +from earthkit.geo.utils.html import css +from earthkit.geo.utils.humanize import as_bytes, as_percent, as_seconds, list_to_human + +LOG = logging.getLogger(__name__) + +OLD_CONFIG_FILE = os.path.expanduser("~/.earthkit_geo/settings.yaml") +CONFIG_DIR = os.path.expanduser("~/.config/earthkit/geo") +CONFIG_FILE_NAME = "config.yaml" +CONFIG_FILE_ENV_NAME = "CONFIG_FILE" +ENV_PREFIX = "EARTHKIT_GEO_" + + +class Validator(metaclass=ABCMeta): + @abstractmethod + def check(self, value): + pass + + # + @abstractmethod + def explain(self): + pass + + +class ValuesValidator(Validator): + """Check if value is in a list of valid values""" + + def __init__(self, values): + self.values = values + + def check(self, value): + return value in self.values + + def explain(self): + return f"Valid values: {list_to_human(self.values)}." + + +class ListValidator(Validator): + """Check if a list of values is in a list of valid values""" + + def __init__(self, values): + self.values = values + + def check(self, value): + return value in self.values + + def explain(self): + return f"Valid values: {list_to_human(self.values)}." + + +class ConfigOption: + def __init__( + self, + default, + description, + getter=None, + none_ok=False, + kind=None, + docs_default=None, + validator=None, + ): + self.default = default + self.description = description + self.getter = getter + self.none_ok = none_ok + self.kind = kind if kind is not None else type(default) + self.docs_default = docs_default if docs_default is not None else self.default + self.validator = validator + + def kind(self): + return type(self.default) + + def save(self, name, value, f): + for n in self.docs_description.split("\n"): + print(f"# {n.strip()}", file=f) + print(file=f) + comment = yaml.dump({name: self.default}, default_flow_style=False) + for n in comment.split("\n"): + if n: + print(f"# {n}", file=f) + if value != self.default: + print(file=f) + yaml.dump({name: value}, f, default_flow_style=False) + + @property + def docs_description(self): + d = self.description + t = "" + if self.validator: + t = self.validator.explain() + + return d.replace("{validator}", t) + + def validate(self, name, value): + if self.validator is not None and not self.validator.check(value): + raise ValueError(f"Config option '{name}' cannot be set to {value}. {self.validator.explain()}") + + +_ = ConfigOption + + +CONFIG_AND_HELP = { + "user-cache-directory": _( + os.path.join(os.path.expanduser("~"), ".cache", "earthkit-geo"), + """Cache directory used when ``cache-policy`` is ``user``. + See :doc:`/guide/misc/caching` for more information.""", + ), + "temporary-cache-directory-root": _( + None, + """Parent of the cache directory when ``cache-policy`` is ``temporary``. + See :doc:`/guide/misc/caching` for more information.""", + getter="_as_str", + none_ok=True, + ), + "temporary-directory-root": _( + None, + """Parent of the temporary directory when ``cache-policy`` is ``off``. + See :doc:`/guide/misc/caching` for more information.""", + getter="_as_str", + none_ok=True, + ), + "cache-policy": _( + "user", + """Caching policy. {validator} + See :doc:`/guide/misc/caching` for more information. """, + validator=ValuesValidator(["off", "temporary", "user"]), + ), + "maximum-cache-size": _( + "5GB", + """Maximum disk space used by the earthkit-geo cache (e.g.: 100G or 2T). + When exceeded, earthkit-geo evicts older cached entries until the usage + is below the specified limit. Can be set to None. + Ignored when ``cache-policy`` is ``off``. + See :ref:`caching` for more information.""", + getter="_as_bytes", + none_ok=True, + ), + "maximum-cache-disk-usage": _( + None, + """Specify maximum disk usage as a percentage of the full disk capacity on the filesystem the + cache is located (e.g.: 90%). When the total disk usage exceeds this limit (it's not limited to the + cache usage alone), earthkit-geo evicts older cached entries until the usage is below the + specified limit. Can be set to None. Ignored when ``cache-policy`` is ``off``. + See :ref:`caching` for more information.""", + getter="_as_percent", + none_ok=True, + ), + "url-download-timeout": _( + "30s", + """Timeout when downloading from an url.""", + getter="_as_seconds", + ), + "check-out-of-date-urls": _( + False, + "Perform a HTTP request to check if the remote version of a cache file has changed", + ), + "download-out-of-date-urls": _( + False, + "Re-download URLs when the remote version of a cached file as been changed", + ), + "maximum-weights-memory-cache-size": _( + "500MB", + """The maximum memory size of the in-memory precomputed weight cache in bytes. + Only used when ``weights-memory-cache-policy`` is ``"largest"`` or ``"lru"``. Can be + set to None. + See :ref:`mem_cache` for more information.""", + getter="_as_bytes", + none_ok=True, + ), + "weights-memory-cache-policy": _( + "largest", + """The in-memory precomputed weights cache policy. {validator} + See :ref:`mem_cache` for more information.""", + validator=ValuesValidator(["off", "unlimited", "largest", "lru"]), + ), + "weights-memory-cache-strict-mode": _( + False, + """Raise exception if the weights cannot be fitted into the in-memory cache. + Only used when ``weights-memory-cache-policy`` is ``"largest"`` or ``"lru"``. + See :ref:`mem_cache` for more information.""", + ), +} + + +NONE = object() +DEFAULTS = {} +for k, v in CONFIG_AND_HELP.items(): + DEFAULTS[k] = v.default + + +@contextmanager +def new_config(s): + """Context manager to create new config""" + CONFIG._stack.append(s) + CONFIG._notify() + try: + yield None + finally: + CONFIG._stack.pop() + CONFIG._notify() + + +def forward(func): + @functools.wraps(func) + def wrapped(self, *args, **kwargs): + if self._stack: + return func(self._stack[-1], *args, **kwargs) + return func(self, *args, **kwargs) + + return wrapped + + +def save_config(path, config): + LOG.debug("Saving config") + from filelock import FileLock + + lock = path + ".lock" + with FileLock(lock): + with open(path, "w") as f: + print("# This file is automatically generated", file=f) + print(file=f) + + for k, v in sorted(config.items()): + h = CONFIG_AND_HELP.get(k) + if h: + print(file=f) + print("#", "-" * 76, file=f) + h.save(k, v, f) + + print(file=f) + print("#", "-" * 76, file=f) + print("# Version of earthkit-geo", file=f) + print(file=f) + yaml.dump({"version": VERSION}, f, default_flow_style=False) + print(file=f) + try: + os.unlink(lock) + except OSError: + pass + + +def env_var_name(name): + return ENV_PREFIX + name.upper().replace("-", "_") + + +class Config: + _auto_save_config = True + _notify_enabled = True + + def __init__(self, config_yaml: str, defaults: dict, callbacks=[]): + self._defaults = defaults + self._config = dict(**defaults) + self._callbacks = [c for c in callbacks] + self._config_yaml = config_yaml + self._pytest = None + self._stack = [] + + @forward + def get(self, name: str, default=NONE): + """[summary] + + Parameters + ---------- + name: str + [description] + default: [type] + [description]. Defaults to NONE. + + Returns + ------- + [type]: [description] + """ + if name not in CONFIG_AND_HELP: + raise KeyError("No config name '%s'" % (name,)) + + config_item = CONFIG_AND_HELP[name] + + getter, none_ok = ( + config_item.getter, + config_item.none_ok, + ) + if getter is None: + getter = lambda name, value, none_ok: value # noqa: E731 + else: + getter = getattr(self, getter) + + st, value, _ = self._env(name) + if not st: + if default is NONE: + value = self._config[name] + else: + value = self._config.get(name, default) + + return getter(name, value, none_ok) + + @forward + def set(self, *args, **kwargs): + """[summary] + + Parameters + ---------- + name: str + [description] + value: [type] + [description] + """ + if len(args) == 0: + assert len(kwargs) > 0 + for k, v in kwargs.items(): + self._set(k.replace("_", "-"), v) + self._changed() + else: + if len(args) == 1 and isinstance(args[0], dict): + for k, v in args[0].items(): + self._set(k, v) + else: + self._set(*args, **kwargs) + self._changed() + + def _set(self, name: str, *args, **kwargs): + """[summary] + + Parameters + ---------- + name: str + [description] + value: [type] + [description] + """ + if name not in CONFIG_AND_HELP: + raise KeyError("No config option '%s'" % (name,)) + + if self._has_env(name): + msg = ( + f"Config option '{name}' is also set by environment variable '{env_var_name(name)}'." + "The environment variable takes precedence and its value is returned when calling get()." + ) + if self._auto_save_config: + msg += " Still, the value set here will be saved to the config file." + warnings.warn(msg) + + config_item = CONFIG_AND_HELP[name] + + klass = config_item.kind + + if klass in (bool, int, float, str): + # TODO: Proper exceptions + assert len(args) == 1 + assert len(kwargs) == 0 + value = args[0] + if value is not None: + if klass is bool: + try: + value = klass(value) + except Exception as e: + raise ValueError(f"Invalid value for config option '{name}': {value}") from e + + if klass is list: + assert len(args) > 0 + assert len(kwargs) == 0 + value = list(args) + if len(args) == 1 and isinstance(args[0], list): + value = args[0] + + if klass is dict: + assert len(args) <= 1 + if len(args) == 0: + assert len(kwargs) > 0 + value = kwargs + + if len(args) == 1: + assert len(kwargs) == 0 + value = args[0] + + getter, none_ok = ( + config_item.getter, + config_item.none_ok, + ) + if getter is not None: + assert len(args) == 1 + assert len(kwargs) == 0 + value = args[0] + # Check if value is properly formatted for getter + getattr(self, getter)(name, value, none_ok) + else: + if not isinstance(value, klass): + raise TypeError("Config option '%s' must be of type '%s'" % (name, klass)) + + config_item.validate(name, value) + self._config[name] = value + + LOG.debug(f"_set {name}={value} stack_size={len(self._stack)}") + + @forward + def reset(self, name: str = None): + """Reset config to default values. + + Parameters + ---------- + name: str, optional + The name of the config option to reset to default. If it + does not have a default, it is removed. If `None` is passed, all config options are + reset to their default values. Defaults to None. + """ + if name is None: + self._config = dict(**DEFAULTS) + else: + if name not in DEFAULTS: + raise KeyError("No config option name '%s'" % (name,)) + + self._config.pop(name, None) + if name in DEFAULTS: + if self._has_env(name): + msg = ( + f"Config option '{name}' is also set by environment variable" + f" '{env_var_name(name)}'." + "The environment variable takes precedence and its value is returned" + " when calling get()." + ) + if self._auto_save_config: + msg += " Still, the value reset here will be saved to the config file." + warnings.warn(msg) + self._config[name] = DEFAULTS[name] + self._changed() + + @forward + def __repr__(self): + r = [] + env = self.env() + for k, v in sorted(self._config.items()): + config = CONFIG_AND_HELP.get(k, None) + default = config.default if config else "" + if k in env: + r.append(f"{k}: ({env[k][0]}={env[k][1]}, {v}, {default})") + else: + r.append(f"{k}: ({v}, {default})") + return "\n".join(r) + + @forward + def _repr_html_(self): + html = [css("table")] + html.append("") + + env = self.env() + columns = ["Name", "Value", "Default"] + html.append("" % ("" % (k, env[k][0], env[k][1], v, default) + ) + else: + html.append("" % (k, v, default)) + + html.append("
%s
".join(columns))) + + for k, v in sorted(self._config.items()): + config = CONFIG_AND_HELP.get(k, None) + default = config.default if config else "" + if k in env: + html.append( + "
%s%s=%r
(%r)
%r
%s%r%r
") + return "".join(html) + + @forward + def dump(self): + for k, v in sorted(self._config.items()): + yield ((k, v, CONFIG_AND_HELP.get(k))) + + def _changed(self): + if self._auto_save_config: + self._save() + self._notify() + + def _notify(self): + if self._notify_enabled: + for cb in self._callbacks: + cb() + + def on_change(self, callback: Callable[[], None]): + self._callbacks.append(callback) + + def _save(self): + if self._config_yaml is None: + return + + try: + save_config(self._config_yaml, self._config) + except Exception: + LOG.error( + "Cannot save earthkit-geo config (%s)", + self._config_yaml, + exc_info=True, + ) + + @forward + def save_as(self, path): + try: + save_config(path, self._config) + except Exception: + LOG.error( + f"Cannot save earthkit-geo config ({path})", + exc_info=True, + ) + + def _as_bytes(self, name, value, none_ok): + return as_bytes(value, name=name, none_ok=none_ok) + + def _as_percent(self, name, value, none_ok): + return as_percent(value, name=name, none_ok=none_ok) + + def _as_seconds(self, name, value, none_ok): + return as_seconds(value, name=name, none_ok=none_ok) + + def _as_str(self, name, value, none_ok): + if value is None and none_ok: + return None + return str(value) + + def _as_int(self, name, value, none_ok): + if value is None and none_ok: + return None + if isinstance(value, str): + value = value.replace('"', "").replace("'", "").strip() + return int(value) + + def _as_list(self, name, value, none_ok): + if value is None and none_ok: + return [] + if isinstance(value, str): + value = value.replace('"', "").replace("'", "").strip() + return value.split(",") + return list(value) + + @forward + def temporary(self, *args, config_yaml=None, **kwargs): + tmp = Config(config_yaml, self._config) + # until the tmp object is at the top of the stack we do not want + # notify the observers + if len(args) > 0 or len(kwargs) > 0: + # tmp does not have any callbacks so it will not broadcast the changes + tmp.set(*args, **kwargs) + tmp._callbacks = self._callbacks + return new_config(tmp) + + @property + def autosave(self): + return Config._auto_save_config + + @autosave.setter + def autosave(self, v): + Config._auto_save_config = v + + def env(self): + r = {} + for k in sorted(self._config.keys()): + st, value, name = self._env(k) + if st: + r[k] = (name, value) + return r + + @staticmethod + def _has_env(name): + return env_var_name(name) in os.environ + + @staticmethod + def _env(name): + name = env_var_name(name) + if name in os.environ: + return (True, os.environ.get(name), name) + return (False, None, None) + + +# TODO: remove this function when the old config (aka settings) is not used anymore +def _migrate_old_config(config_file): + old_config_file = os.path.expanduser(OLD_CONFIG_FILE) + if os.path.exists(old_config_file): + config = dict(**DEFAULTS) + try: + with open(old_config_file) as f: + s = yaml.load(f, Loader=yaml.SafeLoader) + if not isinstance(s, dict): + return False + + config.update(s) + save_config(config_file, config) + return True + except Exception: + LOG.error( + f"Cannot migrate old settings to earthkit-geo config file={config_file}", + exc_info=True, + ) + return False + + +def _init_config_file(): + config_file = None + + name = env_var_name(CONFIG_FILE_ENV_NAME) + if name in os.environ: + config_file = os.environ[name] + if not config_file: + config_file = os.path.expanduser(os.path.join(CONFIG_DIR, CONFIG_FILE_NAME)) + + if config_file is None: + LOG.error("Cannot construct earthkit-geo config file path") + return None + + try: + config_dir = os.path.dirname(config_file) + if not os.path.exists(config_dir): + ori_mask = os.umask(0o077) + os.makedirs(config_dir, 0o700) + os.umask(ori_mask) + except Exception: + LOG.error( + f"Cannot create earthkit-geo config directory={config_dir}", + exc_info=True, + ) + + if os.path.exists(config_dir): + try: + if not os.path.exists(config_file): + if not _migrate_old_config(config_file): + save_config(config_file, DEFAULTS) + except Exception: + LOG.error( + f"Cannot save settings to earthkit-geo config file={config_file}", + exc_info=True, + ) + + return config_file + + +def _init_config(config_yaml): + save = False + config = dict(**DEFAULTS) + try: + with open(config_yaml) as f: + s = yaml.load(f, Loader=yaml.SafeLoader) + if not isinstance(s, dict): + s = {} + + config.update(s) + + # if s != config: + # save = True + + if config.get("version") < VERSION: + save = True + + except Exception: + LOG.error( + "Cannot load earthkit-geo config (%s), reverting to defaults", + config_yaml, + exc_info=True, + ) + + return config, save + + +save = False +config_yaml = _init_config_file() +config, save = _init_config(config_yaml) + +CONFIG = Config(config_yaml, config) +if save: + CONFIG._save() diff --git a/src/earthkit/geo/utils/download.py b/src/earthkit/geo/utils/download.py new file mode 100644 index 0000000..8937717 --- /dev/null +++ b/src/earthkit/geo/utils/download.py @@ -0,0 +1,106 @@ +# (C) Copyright 2020 ECMWF. +# +# This software is licensed under the terms of the Apache Licence Version 2.0 +# which can be obtained at http://www.apache.org/licenses/LICENSE-2.0. +# In applying this licence, ECMWF does not waive the privileges and immunities +# granted to it by virtue of its status as an intergovernmental organisation +# nor does it submit to any jurisdiction. +# + + +import logging + +from multiurl import Downloader + +from earthkit.geo.utils import progress_bar +from earthkit.geo.utils.caching import cache_file +from earthkit.geo.utils.config import CONFIG + +LOG = logging.getLogger(__name__) + + +def download_and_cache( + url, + *, + owner="url", + parts=None, + verify=True, + force=None, + chunk_size=1024 * 1024, + range_method="auto", + http_headers=None, + update_if_out_of_date=False, + fake_headers=None, # When HEAD is not allowed but you know the size + progress_bar=progress_bar, + maximum_retries=0, + retry_after=10, + **kwargs, +): + # TODO: re-enable this feature + extension = None + + LOG.debug("URL %s", url) + + downloader = Downloader( + url, + chunk_size=chunk_size, + timeout=CONFIG.get("url-download-timeout"), + verify=verify, + parts=parts, + range_method=range_method, + http_headers=http_headers, + fake_headers=fake_headers, + # statistics_gatherer=record_statistics, + # progress_bar=progress_bar, + progress_bar=progress_bar, + resume_transfers=True, + override_target_file=False, + download_file_extension=".download", + maximum_retries=maximum_retries, + retry_after=retry_after, + ) + + if extension and extension[0] != ".": + extension = "." + extension + + if extension is None: + extension = downloader.extension() + + path = downloader.local_path() + if path is not None: + return + + def out_of_date(url, path, cache_data): + if CONFIG.get("check-out-of-date-urls") is False: + return False + + if downloader.out_of_date(path, cache_data): + if CONFIG.get("download-out-of-date-urls") or update_if_out_of_date: + LOG.warning( + "Invalidating cache version and re-downloading %s", + url, + ) + return True + else: + LOG.warning( + "To enable automatic downloading of updated URLs set the 'download-out-of-date-urls'" + " setting to True", + ) + return False + + if force is None: + force = out_of_date + + def download(target, _): + downloader.download(target) + return downloader.cache_data() + + path = cache_file( + owner, + download, + dict(url=url, parts=parts), + extension=extension, + force=force, + ) + + return path diff --git a/src/earthkit/geo/utils/hash.py b/src/earthkit/geo/utils/hash.py new file mode 100644 index 0000000..044bdeb --- /dev/null +++ b/src/earthkit/geo/utils/hash.py @@ -0,0 +1,22 @@ +# (C) Copyright 2023 ECMWF. +# +# This software is licensed under the terms of the Apache Licence Version 2.0 +# which can be obtained at http://www.apache.org/licenses/LICENSE-2.0. +# In applying this licence, ECMWF does not waive the privileges and immunities +# granted to it by virtue of its status as an intergovernmental organisation +# nor does it submit to any jurisdiction. +# + +import hashlib +import json + + +def make_sha(data): + m = hashlib.sha256() + if isinstance(data, str): + m.update(data.encode("utf-8")) + elif hasattr(data, "grid") and data.grid is not None: + m.update(data.grid.uid.encode("utf-8")) + else: + m.update(json.dumps(data, sort_keys=True).encode("utf-8")) + return m.hexdigest() diff --git a/src/earthkit/geo/utils/html.py b/src/earthkit/geo/utils/html.py new file mode 100644 index 0000000..0147577 --- /dev/null +++ b/src/earthkit/geo/utils/html.py @@ -0,0 +1,16 @@ +# (C) Copyright 2023 ECMWF. +# +# This software is licensed under the terms of the Apache Licence Version 2.0 +# which can be obtained at http://www.apache.org/licenses/LICENSE-2.0. +# In applying this licence, ECMWF does not waive the privileges and immunities +# granted to it by virtue of its status as an intergovernmental organisation +# nor does it submit to any jurisdiction. +# + +import os + + +def css(name): + path = os.path.join(os.path.dirname(os.path.dirname(__file__)), "conf", "css", name) + with open(path + ".css") as f: + return """""" % (f.read(),) diff --git a/src/earthkit/geo/utils/humanize.py b/src/earthkit/geo/utils/humanize.py new file mode 100644 index 0000000..5b8a4f8 --- /dev/null +++ b/src/earthkit/geo/utils/humanize.py @@ -0,0 +1,111 @@ +# (C) Copyright 2023 ECMWF. +# +# This software is licensed under the terms of the Apache Licence Version 2.0 +# which can be obtained at http://www.apache.org/licenses/LICENSE-2.0. +# In applying this licence, ECMWF does not waive the privileges and immunities +# granted to it by virtue of its status as an intergovernmental organisation +# nor does it submit to any jurisdiction. +# + +import re + + +def bytes(n): + """>>> bytes(4096) + '4 KiB' + >>> bytes(4000) + '3.9 KiB' + """ + if n < 0: + sign = "-" + n -= 0 + else: + sign = "" + + u = ["", " KiB", " MiB", " GiB", " TiB", " PiB", " EiB", " ZiB", " YiB"] + i = 0 + while n >= 1024: + n /= 1024.0 + i += 1 + return "%s%g%s" % (sign, int(n * 10 + 0.5) / 10.0, u[i]) + + +def string_distance(s, t): + import numpy as np + + m = len(s) + n = len(t) + d = np.zeros((m + 1, n + 1), dtype=int) + + one = int(1) + zero = int(0) + + d[:, 0] = np.arange(m + 1) + d[0, :] = np.arange(n + 1) + + for i in range(1, m + 1): + for j in range(1, n + 1): + cost = zero if s[i - 1] == t[j - 1] else one + d[i, j] = min( + d[i - 1, j] + one, + d[i, j - 1] + one, + d[i - 1, j - 1] + cost, + ) + + return d[m, n] + + +def did_you_mean(word, vocabulary): + distance, best = min((string_distance(word, w), w) for w in vocabulary) # noqa F841 + # if distance < min(len(word), len(best)): + return best + + +def list_to_human(lst, conjunction="and"): + if not lst: + return "??" + + if len(lst) > 2: + lst = [", ".join(lst[:-1]), lst[-1]] + + return f" {conjunction} ".join(lst) + + +def as_number(value, name, units, none_ok): + if value is None and none_ok: + return None + + value = str(value) + # TODO: support floats + m = re.search(r"^\s*(\d+)\s*([%\w]+)?\s*$", value) + if m is None: + raise ValueError(f"{name}: invalid number/unit {value}") + value = int(m.group(1)) + if m.group(2) is None: + return value + unit = m.group(2)[0] + if unit not in units: + valid = ", ".join(units.keys()) + raise ValueError(f"{name}: invalid unit '{unit}', valid values are {valid}") + return value * units[unit] + + +def as_seconds(value, name=None, none_ok=False): + units = dict(s=1, m=60, h=3600, d=86400, w=86400 * 7) + return as_number(value, name, units, none_ok) + + +def as_percent(value, name=None, none_ok=False): + units = {"%": 1} + return as_number(value, name, units, none_ok) + + +def as_bytes(value, name=None, none_ok=False): + units = {} + n = 1 + for u in "KMGTP": + n *= 1024 + units[u] = n + units[u.lower()] = n + + return as_number(value, name, units, none_ok) diff --git a/src/earthkit/geo/utils/matrix.py b/src/earthkit/geo/utils/matrix.py new file mode 100644 index 0000000..03a1d71 --- /dev/null +++ b/src/earthkit/geo/utils/matrix.py @@ -0,0 +1,19 @@ +# (C) Copyright 2023 ECMWF. +# +# This software is licensed under the terms of the Apache Licence Version 2.0 +# which can be obtained at http://www.apache.org/licenses/LICENSE-2.0. +# In applying this licence, ECMWF does not waive the privileges and immunities +# granted to it by virtue of its status as an intergovernmental organisation +# nor does it submit to any jurisdiction. +# + + +def matrix_memory_size(m): + # see: https://stackoverflow.com/questions/11173019/determining-the-byte-size-of-a-scipy-sparse-matrix + try: + # TODO: This works for bsr, csc and csr matrices but not for other types. + return m.data.nbytes + m.indptr.nbytes + m.indices.nbytes + + except Exception as e: + print(e) + return 0 diff --git a/src/earthkit/geo/utils/memcache.py b/src/earthkit/geo/utils/memcache.py new file mode 100644 index 0000000..8b0d267 --- /dev/null +++ b/src/earthkit/geo/utils/memcache.py @@ -0,0 +1,375 @@ +# (C) Copyright 2023 ECMWF. +# +# This software is licensed under the terms of the Apache Licence Version 2.0 +# which can be obtained at http://www.apache.org/licenses/LICENSE-2.0. +# In applying this licence, ECMWF does not waive the privileges and immunities +# granted to it by virtue of its status as an intergovernmental organisation +# nor does it submit to any jurisdiction. +# + +import logging +import threading +import time +from abc import ABCMeta, abstractmethod +from collections import OrderedDict, namedtuple + +from earthkit.geo.utils.config import CONFIG +from earthkit.geo.utils.hash import make_sha +from earthkit.geo.utils.matrix import matrix_memory_size + +LOG = logging.getLogger(__name__) + + +_MemoryItem = namedtuple("MemoryItem", ["data", "size", "last"]) +_CacheInfo = namedtuple("CacheInfo", ["hits", "misses", "maxsize", "currsize", "count", "policy"]) + + +def matrix_size(m): + from earthkit.geo.utils.builder import matrix_memory_size + + m = m[0] + try: + return matrix_memory_size(m) + except Exception as e: + LOG.warning("Could not compute weights memory size", e) + return 0 + + +def estimate_matrix_size(entry): + """Estimate the size of a matrix entry""" + try: + return entry["_raw"]["memory"] + except Exception as e: + LOG.warning(f"Could not estimate weights memory size from entry={entry}. {e}") + return 0 + + +class MemoryCachePolicy(metaclass=ABCMeta): + name = None + + def __init__(self, cache): + self.cache = cache + self.check() + + @abstractmethod + def check(self): + pass + + @abstractmethod + def reduce(self, *args, **kwargs): + pass + + @staticmethod + def make(name): + if name not in CACHE_POLICIES: + raise ValueError(f"Unknown cache policy: {name}") + return CACHE_POLICIES[name] + + @abstractmethod + def has_cache(self): + pass + + @abstractmethod + def has_limit(self): + pass + + +class NoPolicy(MemoryCachePolicy): + name = "off" + + def check(self): + self.cache.max_mem = 0 + self.cache.strict = False + + def reduce(self, *args, **kwargs): + self.cache._clear() + + def has_cache(self): + return False + + def has_limit(self): + return False + + +class UnlimitedPolicy(MemoryCachePolicy): + name = "unlimited" + + def check(self): + self.cache.max_mem = None + self.cache.strict = False + + def reduce(self, *args, **kwargs): + # must be called within a lock + self.cache.curr_mem = self.cache._curr_mem() + + def has_cache(self): + return True + + def has_limit(self): + return False + + +class LRUPolicy(MemoryCachePolicy): + name = "lru" + + def check(self): + if self.cache.max_mem <= 0: + raise ValueError(f"Cannot use {self.name} policy with max_mem<=0") + if self.cache.max_mem is None: + raise ValueError(f"Cannot use {self.name} policy with max_mem=None") + + def reduce(self, target_size): + # must be called within a lock + if not self.cache.items: + return + + while self.cache.curr_mem >= target_size: + _, item = self.cache.items.popitem(0) + self.cache.curr_mem -= item.size + del item + if not self.cache.items: + break + + def has_cache(self): + return True + + def has_limit(self): + return True + + +class LargestPolicy(MemoryCachePolicy): + name = "largest" + + def check(self): + if self.cache.max_mem <= 0: + raise ValueError(f"Cannot use {self.name} policy with max_mem<=0") + if self.cache.max_mem is None: + raise ValueError(f"Cannot use {self.name} policy with max_mem=None") + + def reduce(self, target_size): + # must be called within a lock + if not self.cache.items: + return + + while self.cache.curr_mem >= target_size: + _, largest = max((v.size, k) for k, v in self.cache.items.items()) + self.cache.curr_mem -= self.cache.items[largest].size + if self.cache.curr_mem < 0: + self.cache.curr_mem = 0 + # LOG.debug(f"evicting={self.cache.items[largest]} curr_mem={self.cache.curr_mem}") + del self.cache.items[largest] + if not self.cache.items: + break + + def has_cache(self): + return True + + def has_limit(self): + return True + + +CACHE_POLICIES = {p.name: p for p in [NoPolicy, UnlimitedPolicy, LRUPolicy, LargestPolicy]} + + +class MemoryCache: + MAX_SIZE_KEY = "maximum-weights-memory-cache-size" + POLICY_KEY = "weights-memory-cache-policy" + STRICT_KEY = "weights-memory-cache-strict-mode" + + def __init__( + self, + max_mem=300 * 1024 * 1024, + size_fn=None, + policy="largest", + strict=False, + ): + """ + Memory bound in-memory cache for interpolation matrices. + + Parameters + ---------- + max_mem: int + Maximum memory size in bytes. 0 means no cache. None means no limit. + size_fn: callable + Function that returns the size of an item in the cache. + size_settings_key: str + Key in the settings that holds the maximum memory size. + policy_settings_key: str + Key in the settings that holds the cache policy. + """ + self.items = OrderedDict() + self.max_mem = max_mem + self.curr_mem = 0 + self.hits = 0 + self.misses = 0 + + if size_fn is None: + raise ValueError("size_fn must be provided") + self.size_fn = size_fn + self.strict = strict + + self.policy = MemoryCachePolicy.make("largest" if policy is None else policy)(self) + + self._has_settings = True + + # register for config changes + + CONFIG.on_change(self.update) + + self.lock = threading.Lock() + self.update() + + def get(self, *args, create=None, find_entry=None, create_from_entry=None): + if not self.policy.has_cache(): + return create(*args) + + with self.lock: + if not self.policy.has_cache(): + return create(*args) + + key = make_sha(args) + if key in self.items: + item = self.items[key] + # TODO: move_to_end is only required for the "lru" policy + self.items.move_to_end(key) + self.hits += 1 + return item.data + + if self.policy.has_limit(): + data = self._create_with_pre_check(find_entry, create_from_entry, *args) + else: + data = self._create(create, *args) + + self.misses += 1 + + if data[0] is not None: + self.items[key] = _MemoryItem(data, self.size_fn(data[0]), time.time()) + self.curr_mem += self.items[key].size + self._reduce() + + return data + + def _create(self, create, *args): + if create is None: + raise ValueError("create must be provided") + return create(*args) + + def _create_with_pre_check(self, find_entry, create_from_entry, *args): + if find_entry is None: + raise ValueError("find_entry must be provided") + if create_from_entry is None: + raise ValueError("create_from_entry must be provided") + + entry = find_entry(*args) + if entry is not None: + capacity = self._capacity() + estimated_memory = estimate_matrix_size(entry) + target_size = self.max_mem - estimated_memory + # LOG.debug(f"{capacity=} {estimated_memory=} {target_size=}") + if estimated_memory > capacity and estimated_memory <= self.max_mem: + assert target_size >= 0 + self._reduce(target_size=target_size) + + if self.strict and self._capacity() < estimated_memory: + raise ValueError( + ( + "Weights too large to fit in memory cache. " + f"Estimated size: {estimated_memory} bytes > capacity: {self._capacity()} bytes" + ) + ) + + return create_from_entry(entry) + + def update(self): + """Called when settings change""" + if self._has_settings: + from earthkit.geo.utils.config import CONFIG + + assert self.policy + + def _update(name, key): + current = getattr(self, name) + value = CONFIG.get(key, current) + if current != value: + setattr(self, name, value) + return True + return False + + def _update_policy(): + policy = CONFIG.get(self.POLICY_KEY, self.policy.name) + if self.policy.name != policy: + self.policy = MemoryCachePolicy.make(policy)(self) + return True + return False + + with self.lock: + if any([ + _update("max_mem", self.MAX_SIZE_KEY), + _update("strict", self.STRICT_KEY), + _update_policy(), + ]): + self._reduce() + + def _reduce(self, target_size=None): + # must be called within a lock + self.policy.check() + + if not self.policy.has_cache(): + self._clear() + else: + if target_size is None: + target_size = self.max_mem + self.curr_mem = self._curr_mem() + self.policy.reduce(target_size=target_size) + + def clear(self): + """Clear the cache""" + with self.lock: + self._clear() + + def _clear(self): + # must be called within a lock + self.items.clear() + self.hits = 0 + self.misses = 0 + self.curr_mem = 0 + + def _curr_mem(self): + # must be called within a lock + return sum(v.size for v in self.items.values()) + + def info(self): + """Report cache statistics""" + with self.lock: + return _CacheInfo( + self.hits, + self.misses, + self.max_mem, + self.curr_mem, + len(self.items), + self.policy.name, + ) + + def _capacity(self): + # must be called within a lock + return self.max_mem - self.curr_mem + + +class MatrixMemoryCache(MemoryCache): + def __init__(self, *args, **kwargs): + super().__init__( + *args, + size_fn=matrix_memory_size, + **kwargs, + ) + + +MEMORY_CACHE = MatrixMemoryCache() + + +def clear_memory_cache(): + MEMORY_CACHE.clear() + + +def memory_cache_info(): + return MEMORY_CACHE.info() diff --git a/src/earthkit/geo/utils/mir.py b/src/earthkit/geo/utils/mir.py new file mode 100644 index 0000000..4314bfc --- /dev/null +++ b/src/earthkit/geo/utils/mir.py @@ -0,0 +1,177 @@ +#!/usr/bin/env python + +# (C) Copyright 2025- ECMWF. +# +# This software is licensed under the terms of the Apache Licence Version 2.0 +# which can be obtained at http://www.apache.org/licenses/LICENSE-2.0. +# In applying this licence, ECMWF does not waive the privileges and immunities +# granted to it by virtue of its status as an intergovernmental organisation +# nor does it submit to any jurisdiction. +# + +from pathlib import Path +from typing import Dict, List, Optional + +import numpy as np +from scipy.sparse import csr_array, save_npz + +from .stream import Stream + + +def dtype_uint(little_endian, size): + order = "<" if little_endian else ">" + return np.dtype({4: np.uint32}[size]).newbyteorder(order) + + +def dtype_float(little_endian, size): + order = "<" if little_endian else ">" + return np.dtype({4: np.float32, 8: np.float64}[size]).newbyteorder(order) + + +def mir_cached_matrix_to_array(path): + with open(path, "rb") as f: + s = Stream(f) + rows = s.read_unsigned_long() # rows + cols = s.read_unsigned_long() # cols + s.read_unsigned_long() # non-zeros, ignored + + little_endian = s.read_int() != 0 # little_endian + index_item_size = s.read_unsigned_long() # sizeof(index) + scalar_item_size = s.read_unsigned_long() # sizeof(scalar) + s.read_unsigned_long() # sizeof(size), ignored + + outer = s.read_large_blob() # outer + inner = s.read_large_blob() # inner + data = s.read_large_blob() # data + + outer = np.frombuffer( + outer, + dtype=dtype_uint(little_endian, index_item_size), + ) + + inner = np.frombuffer( + inner, + dtype=dtype_uint(little_endian, index_item_size), + ) + + data = np.frombuffer( + data, + dtype=dtype_float(little_endian, scalar_item_size), + ) + + return csr_array((data, inner, outer), shape=(rows, cols)) + + +def mir_cached_matrix_to_file(path, target): + if not target.suffix == ".npz": + raise ValueError("target must end with .npz") + + z = mir_cached_matrix_to_array(path) + save_npz(target, z) + + +def mir_write_latlon_to_griddef(path, lats, lons): + count = len(lats) + if count != len(lons) or count == 0: + raise ValueError("Latitudes and longitudes must be non-empty and have the same length.") + + version = 1 + with open(path, "wb") as f: + s = Stream(f) + s.write_unsigned_long(version) + s.write_unsigned_long(count) + for lat, lon in zip(lats, lons): + s.write_double(lat) + s.write_double(lon) + + +def _yaml_from_dict(d): + import yaml + + return yaml.dump(d, default_flow_style=True).strip() + + +def _griddef_from_latlon(lat, lon, dir=None): + import hashlib + + version = 1 + coord = str(version) + str(lat) + str(lon) + hash = hashlib.md5(coord.encode()).hexdigest() + + name = Path(hash + ".griddef") + if dir: + name = dir / name + + if not name.exists(): + mir_write_latlon_to_griddef(name, lat, lon) + + return str(name) + + +def mir_make_matrix( + in_grid: Optional[Dict] = None, + in_lat: Optional[List] = None, + in_lon: Optional[List] = None, + out_grid: Optional[Dict] = None, + out_lat: Optional[List] = None, + out_lon: Optional[List] = None, + output=None, + **kwargs, +): + import mir + + ext = Path(output).suffix if output is not None else None + if output is not None and ext not in (".mat", ".npz"): + raise ValueError("mir_make_matrix: output must have extension .mat or .npz") + + job = mir.Job() + + if in_grid is not None and in_lat is None and in_lon is None: + input = mir.GridSpecInput(_yaml_from_dict(in_grid)) + elif in_grid is None and in_lat is not None and in_lon is not None: + input = mir.GriddefInput(_griddef_from_latlon(in_lat, in_lon, mir.cache())) + else: + raise ValueError("mir_make_matrix: input grid or lats/lons must be provided.") + + if out_grid is not None and out_lat is None and out_lon is None: + job.set("grid", _yaml_from_dict(out_grid)) + elif out_grid is None and out_lat is not None and out_lon is not None: + job.set("griddef", _griddef_from_latlon(out_lat, out_lon, mir.cache())) + else: + raise ValueError("mir_make_matrix: output grid or lats/lons must be provided.") + + mat = Path(output) + if ext == ".mat": + job.set("interpolation-matrix", str(mat)) + elif ext == ".npz": + mat = mat.with_name(mat.name + ".mat") # later unlinked + job.set("interpolation-matrix", str(mat)) + + for key, val in kwargs.items(): + job.set(key, val) + + try: + job.execute(input, mir.EmptyOutput()) + except Exception as e: + raise RuntimeError(f"mir_make_matrix: error: {e}.") from e + + if ext and not mat.exists(): + raise FileNotFoundError(f"mir_make_matrix: matrix file '{mat}' not found.") + + if ext == ".npz": + mir_cached_matrix_to_file(str(mat), output) + mat.unlink() + assert Path(output).exists() + elif not ext: + return mir_cached_matrix_to_array(mat) + + +if __name__ == "__main__": + import argparse + + parser = argparse.ArgumentParser(description="Convert MIR matrix to npz") + parser.add_argument("input", help="Path to MIR matrix", type=Path) + parser.add_argument("output", help="Path to output npz file", type=Path) + args = parser.parse_args() + + mir_cached_matrix_to_file(args.input, args.output) diff --git a/src/earthkit/geo/utils/stream.py b/src/earthkit/geo/utils/stream.py new file mode 100644 index 0000000..91e0e61 --- /dev/null +++ b/src/earthkit/geo/utils/stream.py @@ -0,0 +1,234 @@ +# (C) Copyright 2023 ECMWF. +# +# This software is licensed under the terms of the Apache Licence Version 2.0 +# which can be obtained at http://www.apache.org/licenses/LICENSE-2.0. +# In applying this licence, ECMWF does not waive the privileges and immunities +# granted to it by virtue of its status as an intergovernmental organisation +# nor does it submit to any jurisdiction. +# + + +from struct import pack, unpack + +TAG_ZERO = 0 +TAG_START_OBJ = 1 +TAG_END_OBJ = 2 +TAG_CHAR = 3 +TAG_UNSIGNED_CHAR = 4 +TAG_INT = 5 +TAG_UNSIGNED_INT = 6 +TAG_SHORT = 7 +TAG_UNSIGNED_SHORT = 8 +TAG_LONG = 9 +TAG_UNSIGNED_LONG = 10 +TAG_LONG_LONG = 11 +TAG_UNSIGNED_LONG_LONG = 12 +TAG_FLOAT = 13 +TAG_DOUBLE = 14 +TAG_STRING = 15 +TAG_BLOB = 16 +TAG_EXCEPTION = 17 +TAG_START_REC = 18 +TAG_END_REC = 19 +TAG_EOF = 20 +TAG_LARGE_BLOB = 21 # For blobs >= 2Gb +LAST_TAG = 22 + +TAG_NAME = ( + "0", + "start of object", + "end of object", + "char", + "unsigned char", + "int", + "unsigned int", + "short", + "unsigned short", + "long", + "unsigned long", + "long long", + "unsigned long long", + "float", + "double", + "string", + "blob", + "exception", + "start of record", + "end of record", +) + + +class Stream: + def __init__(self, stream): + self.stream = stream + + def _read(self, n): + return self.stream.read(n) + + def _write(self, n, nbytes=None): + assert not nbytes or nbytes == len(n) + return self.stream.write(n) + + def read_tag(self, expected_tag): + tag = self._read(1) + tag = ord(tag) + + while tag == TAG_END_OBJ: + tag = self._read(1) + if tag: + tag = ord(tag) + + # TODO There is some suspicious code on the perl side for the following. + # TODO Maybe worth having a look at it sometime. + if tag != expected_tag: + if tag < len(TAG_NAME): + raise RuntimeError("Unexpected tag: %s, wanted %s" % (TAG_NAME[tag], TAG_NAME[expected_tag])) + else: + raise RuntimeError("Invalid tag with id: '%s'" % tag) + + return tag + + def write_tag(self, tag): + self._write(pack("b", tag), 1) + + def next_object(self): + while 1: + tag = self.stream.recv(1) + if tag == "": + return 0 + + tag = unpack("b", tag)[0] + + if tag == TAG_START_OBJ: + return 1 + else: + if tag < len(TAG_NAME): + raise RuntimeError("Unexpected tag: '%s', wanted '%s'" % (TAG_NAME[tag], TAG_NAME[TAG_START_OBJ])) + else: + raise RuntimeError("Invalid tag with id: '%d'" % tag) + + def write_char(self, c): + self.write_tag(TAG_CHAR) + self._write(c, 1) + + def write_unsigned_char(self, c): + self.write_tag(TAG_UNSIGNED_CHAR) + self._write(c, 1) + + def write_int(self, n): + self.write_tag(TAG_INT) + self._write(pack("!L", n), 4) + + def write_unsigned_int(self, n): + self.write_tag(TAG_UNSIGNED_INT) + self._write(pack("!L", n), 4) + + def write_long(self, n): + self.write_tag(TAG_LONG) + self._write(pack("!L", n), 4) + + def write_double(self, n): + self.write_tag(TAG_DOUBLE) + x, y = unpack("!II", pack("!d", n)) + self.stream.write(pack("!L", y)) + self.stream.write(pack("!L", x)) + + def write_unsigned_long(self, n): + self.write_tag(TAG_UNSIGNED_LONG) + self._write(pack("!L", n), 4) + + def write_long_long(self, n): + self.write_tag(TAG_LONG_LONG) + + # TODO Error handling when the number is too long. + # TODO See the perl. + + self._write(pack("!L", n), 4) + + def write_unsigned_long_long(self, n): + self.write_tag(TAG_UNSIGNED_LONG_LONG) + + # TODO Error handling when input value too big. + + self._write(pack("!L", 0), 4) + self._write(pack("!L", n), 4) + + def write_string(self, s): + self.write_tag(TAG_STRING) + n = len(s) + self._write(pack("!L", n), 4) + self._write(s, n) + + def read_char(self): + self.read_tag(TAG_CHAR) + return self._read(1) + + def read_unsigned_char(self): + self.read_tag(TAG_UNSIGNED_CHAR) + return self._read(1) + + def read_int(self): + self.read_tag(TAG_INT) + return unpack("!L", self._read(4))[0] + + def read_unsigned_int(self): + self.read_tag(TAG_UNSIGNED_INT) + return unpack("!L", self._read(4))[0] + + def read_long(self): + self.read_tag(TAG_LONG) + return unpack("!L", self._read(4))[0] + + def read_double(self): + self.read_tag(TAG_DOUBLE) + raise RuntimeError("read_double") + + def read_unsigned_long(self): + self.read_tag(TAG_UNSIGNED_LONG) + return unpack("!L", self._read(4))[0] + + def read_long_long(self): + self.read_tag(TAG_LONG_LONG) + raise RuntimeError("read_long_long") + + def _read_long_long(self): + return unpack("!Q", self._read(8))[0] + # TODO: use 'Q' instead of 'L' for 64-bit ints + x = unpack("!L", self._read(4))[0] + y = unpack("!L", self._read(4))[0] + + return (x << 32) | y + + def read_unsigned_long_long(self): + self.read_tag(TAG_UNSIGNED_LONG_LONG) + return unpack("!Q", self._read(8))[0] + + def read_string(self): + self.read_tag(TAG_STRING) + n = unpack("!L", self._read(4))[0] + return self._read(n) + + def read_large_blob(self): + self.read_tag(TAG_LARGE_BLOB) + len = unpack("!Q", self._read(8))[0] + return self._read(len) + + def start_object(self): + self.write_tag(TAG_START_OBJ) + + def end_object(self): + self.write_tag(TAG_END_OBJ) + + def read_object(self): + if not self.next_object(): + return None + klass = self.read_string() + return klass + + def write_object(self, name, ref): + self.start_object() + + self.write_string(name) + self.write_string(ref) + + self.end_object() diff --git a/src/earthkit/geo/utils/temporary.py b/src/earthkit/geo/utils/temporary.py new file mode 100644 index 0000000..70db7c2 --- /dev/null +++ b/src/earthkit/geo/utils/temporary.py @@ -0,0 +1,75 @@ +# (C) Copyright 2023 ECMWF. +# +# This software is licensed under the terms of the Apache Licence Version 2.0 +# which can be obtained at http://www.apache.org/licenses/LICENSE-2.0. +# In applying this licence, ECMWF does not waive the privileges and immunities +# granted to it by virtue of its status as an intergovernmental organisation +# nor does it submit to any jurisdiction. +# + +import os +import tempfile + + +class TmpFile: + """The TmpFile objects are designed to be used for temporary files. + It ensures that the file is unlinked when the object is + out-of-scope (with __del__). + + Parameters + ---------- + path : str + Actual path of the file. + """ + + def __init__(self, path: str): + self.path = path + + def __del__(self): + self.cleanup() + + def __enter__(self): + return self.path + + def __exit__(self, *args, **kwargs): + self.cleanup() + + def cleanup(self): + if self.path is not None: + os.unlink(self.path) + self.path = None + + +def temp_file(extension=".tmp") -> TmpFile: + """Create a temporary file with the given extension . + + Parameters + ---------- + extension : str, optional + By default ".tmp" + + Returns + ------- + TmpFile + """ + fd, path = tempfile.mkstemp(suffix=extension) + os.close(fd) + return TmpFile(path) + + +class TmpDirectory(tempfile.TemporaryDirectory): + def __init__(self, *args, **kwargs): + d = kwargs.get("dir", None) + if d == "": + raise ValueError("TmpDirectory: dir option cannot be an empty str!") + if d is not None and not os.path.exists(d): + os.makedirs(d) + super().__init__(*args, **kwargs) + + @property + def path(self): + return self.name + + +def temp_directory(dir=None): + return TmpDirectory(dir=dir) diff --git a/src/earthkit/geo/utils/testing.py b/src/earthkit/geo/utils/testing.py new file mode 100644 index 0000000..5299077 --- /dev/null +++ b/src/earthkit/geo/utils/testing.py @@ -0,0 +1,160 @@ +# (C) Copyright 2023 ECMWF. +# +# This software is licensed under the terms of the Apache Licence Version 2.0 +# which can be obtained at http://www.apache.org/licenses/LICENSE-2.0. +# In applying this licence, ECMWF does not waive the privileges and immunities +# granted to it by virtue of its status as an intergovernmental organisation +# nor does it submit to any jurisdiction. + +import os +from importlib import import_module + +import numpy as np + +PATH = os.path.dirname(__file__) + +URL_ROOT = "https://sites.ecmwf.int/repository/earthkit-geo/test-data" + +_ROOT_DIR = top = os.path.dirname(os.path.dirname(os.path.dirname(os.path.dirname(os.path.dirname(__file__))))) +if not os.path.exists(os.path.join(_ROOT_DIR, "tests", "data")): + _ROOT_DIR = "./" + + +def earthkit_file(*args): + return os.path.join(_ROOT_DIR, *args) + + +def earthkit_test_data_path(*args): + return os.path.join(_ROOT_DIR, "tests", "data", *args) + + +def simple_download(url, target): + import requests + + r = requests.get(url, allow_redirects=True) + r.raise_for_status() + open(target, "wb").write(r.content) + + +def get_test_data_path(filename, subfolder="global_0_360"): + return os.path.join(URL_ROOT, subfolder, filename) + + +def get_test_data(filename, subfolder="global_0_360"): + if not isinstance(filename, list): + filename = [filename] + + res = [] + for fn in filename: + d_path = earthkit_test_data_path(subfolder) + os.makedirs(d_path, exist_ok=True) + f_path = os.path.join(d_path, fn) + if not os.path.exists(f_path): + simple_download(url=f"{URL_ROOT}/{subfolder}/{fn}", target=f_path) + res.append(f_path) + + if len(res) == 1: + return res[0] + else: + return res + + +def modules_installed(*modules): + from os import environ + + for module in modules: + try: + import_module(module) + except Exception as e: + print(environ) + print(f"earthkit-geo testing: {module=} is not installed: {e}") + return False + return True + + +NO_EKD = not modules_installed("earthkit.data") + +try: + NO_MIR = not modules_installed("mir") +except Exception: + NO_MIR = True + +# TODO: remove these constants when the backend names are finalized +LOCAL_MATRIX_BACKEND_NAME = "precomputed" +SYSTEM_MATRIX_BACKEND_NAME = "precomputed" +REMOTE_MATRIX_BACKEND_NAME = "precomputed" + + +def compare_global_ll_results(v_res, v_ref, interpolation, **kwargs): + """Compare the results of the regrid operation with the reference values.""" + import numpy as np + + if interpolation in ("nearest-neighbour", "nn", "nearest-neighbor"): + v_ref = v_ref.reshape(v_res.shape) + + np.testing.assert_allclose(v_res[0].flatten(), v_ref[0].flatten(), rtol=10, verbose=False) + np.testing.assert_allclose(v_res[-1].flatten(), v_ref[0].flatten(), rtol=10, verbose=False) + np.testing.assert_allclose(v_res[1:-1].flatten(), v_ref[1:-1].flatten(), verbose=False, **kwargs) + else: + np.testing.assert_allclose(v_res.flatten(), v_ref.flatten(), verbose=False, **kwargs) + + +def compare_dims(ds, ref_coords, order_ref_var=None, sizes=False): + compare_dim_order(ds, ref_coords, order_ref_var=order_ref_var) + if not sizes: + for k, v in ref_coords.items(): + compare_coord(ds, k, v, mode="dim") + else: + compare_dim_size(ds, ref_coords) + + +def compare_coords(ds, ref_coords): + for k, v in ref_coords.items(): + compare_coord(ds, k, v, mode="coord") + + +def compare_coord(ds, name, ref_vals, mode="coord"): + assert name in ds.coords, f"{name=} not in {ds.coords}" + if mode == "dim": + assert name in ds.sizes, f"{name=} not in {ds.sizes}" + assert ds.sizes[name] == len(ref_vals), f"{name=} {ds.sizes[name]} != {len(ref_vals)}" + + vals = ds.coords[name].values + if isinstance(ref_vals[0], str): + assert vals.tolist() == ref_vals, f"{name=} {vals.tolist()} != {ref_vals}" + else: + vals = np.asarray(vals).flatten() + ref_vals = np.asarray(ref_vals).flatten() + + assert vals.shape == ref_vals.shape, f"{name=} {vals.shape} != {ref_vals.shape}" + # datetime/timedelta 64 + if np.issubdtype(vals.dtype, np.datetime64) or np.issubdtype(vals.dtype, np.timedelta64): + for i in range(len(ref_vals)): + assert vals[i] == ref_vals[i], f"{name=} {vals[i]} != {ref_vals[i]}" + # other arrays + else: + assert np.allclose(ds.coords[name].values, vals), f"{name=} {ds.coords[name].values} != {vals}" + + +def compare_dim_order(ds, dims, order_ref_var, check_coord=True): + if order_ref_var is None: + return + + dim_order = [] + + for d in ds[order_ref_var].dims: + if d in dims: + dim_order.append(d) + if check_coord: + assert d in ds.coords, f"{d} not in {ds.coords}" + + if isinstance(dims, dict): + assert dim_order == list(dims.keys()), f"{dim_order=} != {list(dims.keys())}" + else: + assert dim_order == dims, f"{dim_order=} != {dims}" + + +def compare_dim_size(ds, dims): + for name, v in dims.items(): + assert name in ds.sizes, f"{name=} not in {ds.sizes}" + assert ds.sizes[name] == v, f"{name=} {ds.sizes[name]} != {v}" diff --git a/tests/conftest.py b/tests/conftest.py new file mode 100644 index 0000000..3b035b6 --- /dev/null +++ b/tests/conftest.py @@ -0,0 +1,34 @@ +# (C) Copyright 2023 ECMWF. +# +# This software is licensed under the terms of the Apache Licence Version 2.0 +# which can be obtained at http://www.apache.org/licenses/LICENSE-2.0. +# In applying this licence, ECMWF does not waive the privileges and immunities +# granted to it by virtue of its status as an intergovernmental organisation +# nor does it submit to any jurisdiction. + + +def pytest_runtest_setup(item): + # print(f"config {item.config.option}") + + marks_in_items = list([m.name for m in item.iter_markers()]) + + from earthkit.geo.regrid.backends.db import SYS_DB + + SYS_DB._clear_index() + + tmp_cache = "tmp_cache" in marks_in_items + + # settings + from earthkit.geo import config + + # ensure settings are not saved automatically + config.autosave = False + + # ensure all the tests use the default settings + if tmp_cache: + # ensure these tests use a temporary cache + config.reset() + config.set("cache-policy", "temporary") + else: + config.reset() + config.set("cache-policy", "user") diff --git a/tests/data/local/.gitignore b/tests/data/local/.gitignore new file mode 100644 index 0000000..c2c59e4 --- /dev/null +++ b/tests/data/local/.gitignore @@ -0,0 +1,2 @@ +!*.json +!*.npz diff --git a/tests/data/local/db/index.json b/tests/data/local/db/index.json new file mode 100644 index 0000000..1ce015e --- /dev/null +++ b/tests/data/local/db/index.json @@ -0,0 +1,572 @@ +{ + "version": 1, + "matrix": { + "8d0fbe91fd547ad49d86acd6f31b339163f35cdfd183689367f6864d98d3328d": { + "input": { + "grid": [ + 5, + 5 + ], + "shape": [ + 37, + 72 + ], + "area": [ + 90, + 0, + -90, + 355 + ], + "global": 1 + }, + "output": { + "grid": [ + 10, + 10 + ], + "shape": [ + 19, + 36 + ], + "area": [ + 90, + 0, + -90, + 350 + ], + "global": 1 + }, + "interpolation": { + "engine": "mir", + "version": 16, + "method": "linear" + } + }, + "2800f6a28606667ff1e20b82b067e6cf94670b854651601f6ee15683e80e4933": { + "input": { + "grid": "O32", + "shape": [ + 5248 + ], + "area": [ + 87.8638, + 0, + -87.8638, + 357.5 + ], + "global": 1 + }, + "output": { + "grid": [ + 10, + 10 + ], + "shape": [ + 19, + 36 + ], + "area": [ + 90, + 0, + -90, + 350 + ], + "global": 1 + }, + "interpolation": { + "engine": "mir", + "version": 16, + "method": "linear" + } + }, + "82ef0fa6d7c834016fe52e93f6cd4185a044e0a900c02906f146998c09c2e22e": { + "input": { + "grid": "N32", + "shape": [ + 6114 + ], + "area": [ + 87.8638, + 0, + -87.8638, + 357.188 + ], + "global": 1 + }, + "output": { + "grid": [ + 10, + 10 + ], + "shape": [ + 19, + 36 + ], + "area": [ + 90, + 0, + -90, + 350 + ], + "global": 1 + }, + "interpolation": { + "engine": "mir", + "version": 16, + "method": "linear" + } + }, + "0efb7cc6060e3365bd2a0c0037e6a339fd2fd71fdba607cd9b6aa13683d01523": { + "input": { + "grid": "H4", + "ordering": "ring" + }, + "output": { + "grid": [ + 10, + 10 + ], + "shape": [ + 19, + 36 + ], + "area": [ + 90, + 0, + -90, + 350 + ], + "global": 1 + }, + "interpolation": { + "engine": "mir", + "version": 16, + "method": "linear" + } + }, + "4b7e0a8bb9dee07acc5822ad0caa72f0e5fae26e956b981aa707f2dba9bab915": { + "input": { + "grid": "H4", + "ordering": "nested" + }, + "output": { + "grid": [ + 10, + 10 + ], + "shape": [ + 19, + 36 + ], + "area": [ + 90, + 0, + -90, + 350 + ], + "global": 1 + }, + "interpolation": { + "engine": "mir", + "version": 16, + "method": "linear" + } + }, + "f330f076443c96111fab1e6df633ac3c9e605ffec35b4a1a78bc952e6a5925b6": { + "input": { + "grid": [ + 5, + 5 + ], + "shape": [ + 37, + 72 + ], + "area": [ + 90, + 0, + -90, + 355 + ], + "global": 1 + }, + "output": { + "grid": [ + 10, + 10 + ], + "shape": [ + 19, + 36 + ], + "area": [ + 90, + 0, + -90, + 350 + ], + "global": 1 + }, + "interpolation": { + "engine": "mir", + "version": 16, + "method": "nearest-neighbour" + } + }, + "bed78a06d90a74c03bd9b7d9dff94ea3c6436ab99bf182f92ac1e5c9b0977708": { + "input": { + "grid": "O32", + "shape": [ + 5248 + ], + "area": [ + 87.8638, + 0, + -87.8638, + 357.5 + ], + "global": 1 + }, + "output": { + "grid": [ + 10, + 10 + ], + "shape": [ + 19, + 36 + ], + "area": [ + 90, + 0, + -90, + 350 + ], + "global": 1 + }, + "interpolation": { + "engine": "mir", + "version": 16, + "method": "nearest-neighbour" + } + }, + "c0de1f0a5e662a9392c06416df2e0124a75d8a97c497b19360f7bea1e3ab694b": { + "input": { + "grid": "N32", + "shape": [ + 6114 + ], + "area": [ + 87.8638, + 0, + -87.8638, + 357.188 + ], + "global": 1 + }, + "output": { + "grid": [ + 10, + 10 + ], + "shape": [ + 19, + 36 + ], + "area": [ + 90, + 0, + -90, + 350 + ], + "global": 1 + }, + "interpolation": { + "engine": "mir", + "version": 16, + "method": "nearest-neighbour" + } + }, + "96b820068578d6b778b0e1359d34e0dfa8c65417b6fbe3e3725fb1bc7a90b3c6": { + "input": { + "grid": "H4", + "ordering": "ring" + }, + "output": { + "grid": [ + 10, + 10 + ], + "shape": [ + 19, + 36 + ], + "area": [ + 90, + 0, + -90, + 350 + ], + "global": 1 + }, + "interpolation": { + "engine": "mir", + "version": 16, + "method": "nearest-neighbour" + } + }, + "e0a86032fae661b1de48828084ab32c3aee40b50871f0f8cd4b9c1b919991525": { + "input": { + "grid": "H4", + "ordering": "nested" + }, + "output": { + "grid": [ + 10, + 10 + ], + "shape": [ + 19, + 36 + ], + "area": [ + 90, + 0, + -90, + 350 + ], + "global": 1 + }, + "interpolation": { + "engine": "mir", + "version": 16, + "method": "nearest-neighbour" + } + }, + "_nonexisting_gridspec": { + "input": { + "grid": "_nonexisting" + }, + "output": { + "grid": [ + 1, + 1 + ], + "shape": [ + 181, + 360 + ], + "area": [ + 90, + 0, + -90, + 359 + ], + "global": 1 + }, + "interpolation": { + "engine": "mir", + "version": 16, + "method": "linear" + } + }, + "cbacaaaea92d359ae4871bba749efc065d5e82120cfe5913b55c301b721a28ca": { + "input": { + "grid": [ + 5, + 5 + ], + "shape": [ + 37, + 72 + ], + "area": [ + 90, + 0, + -90, + 355 + ], + "global": 1 + }, + "output": { + "grid": [ + 10, + 10 + ], + "shape": [ + 19, + 36 + ], + "area": [ + 90, + 0, + -90, + 350 + ], + "global": 1 + }, + "interpolation": { + "engine": "mir", + "version": 16, + "method": "grid-box-average" + } + }, + "c8674db3eefc03c3585882ea19701cba805302ce9dfd4793056ebe8397823dc9": { + "input": { + "grid": "N32", + "shape": [ + 6114 + ], + "area": [ + 87.8638, + 0, + -87.8638, + 357.188 + ], + "global": 1 + }, + "output": { + "grid": [ + 10, + 10 + ], + "shape": [ + 19, + 36 + ], + "area": [ + 90, + 0, + -90, + 350 + ], + "global": 1 + }, + "interpolation": { + "engine": "mir", + "version": 16, + "method": "grid-box-average" + } + }, + "81c23fef9d6ec78d5d1ea6dca11a1efed4baa1f30a7e4acaecb4f749b302ebd3": { + "input": { + "grid": "O32", + "shape": [ + 5248 + ], + "area": [ + 87.8638, + 0, + -87.8638, + 357.5 + ], + "global": 1 + }, + "output": { + "grid": [ + 10, + 10 + ], + "shape": [ + 19, + 36 + ], + "area": [ + 90, + 0, + -90, + 350 + ], + "global": 1 + }, + "interpolation": { + "engine": "mir", + "version": 16, + "method": "grid-box-average" + } + }, + "866c6b1ab08188f5aff1e4f4970bc645db96221efd00eb2c39a09e41358d336f": { + "input": { + "grid": "H4", + "ordering": "ring" + }, + "output": { + "grid": [ + 10, + 10 + ], + "shape": [ + 19, + 36 + ], + "area": [ + 90, + 0, + -90, + 350 + ], + "global": 1 + }, + "interpolation": { + "engine": "mir", + "version": 16, + "method": "grid-box-average" + } + }, + "8657a45f767860b06a1a4fd5d31f2c96b4a77b75f12868fa6d190ae334342a64": { + "input": { + "grid": "H4", + "ordering": "nested" + }, + "output": { + "grid": [ + 10, + 10 + ], + "shape": [ + 19, + 36 + ], + "area": [ + 90, + 0, + -90, + 350 + ], + "global": 1 + }, + "interpolation": { + "engine": "mir", + "version": 16, + "method": "grid-box-average" + } + }, + "df20c8b83afc369370e615d3380482d384cedf033af66d3962b40292c83cbb9f": { + "input": { + "grid": "eORCA025_T", + "shape": [ + 1740494 + ], + "global": 1 + }, + "output": { + "grid": "O96", + "shape": [ + 40320 + ], + "area": [ + 89.2842, + 0, + -89.2842, + 359.1 + ], + "global": 1 + }, + "interpolation": { + "engine": "mir", + "version": 16, + "method": "linear" + } + } + } +} diff --git a/tests/data/local/db/mir_16_grid-box-average/81c23fef9d6ec78d5d1ea6dca11a1efed4baa1f30a7e4acaecb4f749b302ebd3.npz b/tests/data/local/db/mir_16_grid-box-average/81c23fef9d6ec78d5d1ea6dca11a1efed4baa1f30a7e4acaecb4f749b302ebd3.npz new file mode 100644 index 0000000..c18c056 Binary files /dev/null and b/tests/data/local/db/mir_16_grid-box-average/81c23fef9d6ec78d5d1ea6dca11a1efed4baa1f30a7e4acaecb4f749b302ebd3.npz differ diff --git a/tests/data/local/db/mir_16_grid-box-average/8657a45f767860b06a1a4fd5d31f2c96b4a77b75f12868fa6d190ae334342a64.npz b/tests/data/local/db/mir_16_grid-box-average/8657a45f767860b06a1a4fd5d31f2c96b4a77b75f12868fa6d190ae334342a64.npz new file mode 100644 index 0000000..de5596e Binary files /dev/null and b/tests/data/local/db/mir_16_grid-box-average/8657a45f767860b06a1a4fd5d31f2c96b4a77b75f12868fa6d190ae334342a64.npz differ diff --git a/tests/data/local/db/mir_16_grid-box-average/866c6b1ab08188f5aff1e4f4970bc645db96221efd00eb2c39a09e41358d336f.npz b/tests/data/local/db/mir_16_grid-box-average/866c6b1ab08188f5aff1e4f4970bc645db96221efd00eb2c39a09e41358d336f.npz new file mode 100644 index 0000000..5f2b561 Binary files /dev/null and b/tests/data/local/db/mir_16_grid-box-average/866c6b1ab08188f5aff1e4f4970bc645db96221efd00eb2c39a09e41358d336f.npz differ diff --git a/tests/data/local/db/mir_16_grid-box-average/c8674db3eefc03c3585882ea19701cba805302ce9dfd4793056ebe8397823dc9.npz b/tests/data/local/db/mir_16_grid-box-average/c8674db3eefc03c3585882ea19701cba805302ce9dfd4793056ebe8397823dc9.npz new file mode 100644 index 0000000..fc30520 Binary files /dev/null and b/tests/data/local/db/mir_16_grid-box-average/c8674db3eefc03c3585882ea19701cba805302ce9dfd4793056ebe8397823dc9.npz differ diff --git a/tests/data/local/db/mir_16_grid-box-average/cbacaaaea92d359ae4871bba749efc065d5e82120cfe5913b55c301b721a28ca.npz b/tests/data/local/db/mir_16_grid-box-average/cbacaaaea92d359ae4871bba749efc065d5e82120cfe5913b55c301b721a28ca.npz new file mode 100644 index 0000000..61568a1 Binary files /dev/null and b/tests/data/local/db/mir_16_grid-box-average/cbacaaaea92d359ae4871bba749efc065d5e82120cfe5913b55c301b721a28ca.npz differ diff --git a/tests/data/local/db/mir_16_linear/0efb7cc6060e3365bd2a0c0037e6a339fd2fd71fdba607cd9b6aa13683d01523.npz b/tests/data/local/db/mir_16_linear/0efb7cc6060e3365bd2a0c0037e6a339fd2fd71fdba607cd9b6aa13683d01523.npz new file mode 100644 index 0000000..921f337 Binary files /dev/null and b/tests/data/local/db/mir_16_linear/0efb7cc6060e3365bd2a0c0037e6a339fd2fd71fdba607cd9b6aa13683d01523.npz differ diff --git a/tests/data/local/db/mir_16_linear/2800f6a28606667ff1e20b82b067e6cf94670b854651601f6ee15683e80e4933.npz b/tests/data/local/db/mir_16_linear/2800f6a28606667ff1e20b82b067e6cf94670b854651601f6ee15683e80e4933.npz new file mode 100644 index 0000000..39f88f1 Binary files /dev/null and b/tests/data/local/db/mir_16_linear/2800f6a28606667ff1e20b82b067e6cf94670b854651601f6ee15683e80e4933.npz differ diff --git a/tests/data/local/db/mir_16_linear/4b7e0a8bb9dee07acc5822ad0caa72f0e5fae26e956b981aa707f2dba9bab915.npz b/tests/data/local/db/mir_16_linear/4b7e0a8bb9dee07acc5822ad0caa72f0e5fae26e956b981aa707f2dba9bab915.npz new file mode 100644 index 0000000..438e6e4 Binary files /dev/null and b/tests/data/local/db/mir_16_linear/4b7e0a8bb9dee07acc5822ad0caa72f0e5fae26e956b981aa707f2dba9bab915.npz differ diff --git a/tests/data/local/db/mir_16_linear/82ef0fa6d7c834016fe52e93f6cd4185a044e0a900c02906f146998c09c2e22e.npz b/tests/data/local/db/mir_16_linear/82ef0fa6d7c834016fe52e93f6cd4185a044e0a900c02906f146998c09c2e22e.npz new file mode 100644 index 0000000..c6fd835 Binary files /dev/null and b/tests/data/local/db/mir_16_linear/82ef0fa6d7c834016fe52e93f6cd4185a044e0a900c02906f146998c09c2e22e.npz differ diff --git a/tests/data/local/db/mir_16_linear/8d0fbe91fd547ad49d86acd6f31b339163f35cdfd183689367f6864d98d3328d.npz b/tests/data/local/db/mir_16_linear/8d0fbe91fd547ad49d86acd6f31b339163f35cdfd183689367f6864d98d3328d.npz new file mode 100644 index 0000000..42a2a35 Binary files /dev/null and b/tests/data/local/db/mir_16_linear/8d0fbe91fd547ad49d86acd6f31b339163f35cdfd183689367f6864d98d3328d.npz differ diff --git a/tests/data/local/db/mir_16_linear/df20c8b83afc369370e615d3380482d384cedf033af66d3962b40292c83cbb9f.npz b/tests/data/local/db/mir_16_linear/df20c8b83afc369370e615d3380482d384cedf033af66d3962b40292c83cbb9f.npz new file mode 100644 index 0000000..31264cc Binary files /dev/null and b/tests/data/local/db/mir_16_linear/df20c8b83afc369370e615d3380482d384cedf033af66d3962b40292c83cbb9f.npz differ diff --git a/tests/data/local/db/mir_16_nearest-neighbour/96b820068578d6b778b0e1359d34e0dfa8c65417b6fbe3e3725fb1bc7a90b3c6.npz b/tests/data/local/db/mir_16_nearest-neighbour/96b820068578d6b778b0e1359d34e0dfa8c65417b6fbe3e3725fb1bc7a90b3c6.npz new file mode 100644 index 0000000..2cd3287 Binary files /dev/null and b/tests/data/local/db/mir_16_nearest-neighbour/96b820068578d6b778b0e1359d34e0dfa8c65417b6fbe3e3725fb1bc7a90b3c6.npz differ diff --git a/tests/data/local/db/mir_16_nearest-neighbour/bed78a06d90a74c03bd9b7d9dff94ea3c6436ab99bf182f92ac1e5c9b0977708.npz b/tests/data/local/db/mir_16_nearest-neighbour/bed78a06d90a74c03bd9b7d9dff94ea3c6436ab99bf182f92ac1e5c9b0977708.npz new file mode 100644 index 0000000..5f6160f Binary files /dev/null and b/tests/data/local/db/mir_16_nearest-neighbour/bed78a06d90a74c03bd9b7d9dff94ea3c6436ab99bf182f92ac1e5c9b0977708.npz differ diff --git a/tests/data/local/db/mir_16_nearest-neighbour/c0de1f0a5e662a9392c06416df2e0124a75d8a97c497b19360f7bea1e3ab694b.npz b/tests/data/local/db/mir_16_nearest-neighbour/c0de1f0a5e662a9392c06416df2e0124a75d8a97c497b19360f7bea1e3ab694b.npz new file mode 100644 index 0000000..0b4d7ac Binary files /dev/null and b/tests/data/local/db/mir_16_nearest-neighbour/c0de1f0a5e662a9392c06416df2e0124a75d8a97c497b19360f7bea1e3ab694b.npz differ diff --git a/tests/data/local/db/mir_16_nearest-neighbour/e0a86032fae661b1de48828084ab32c3aee40b50871f0f8cd4b9c1b919991525.npz b/tests/data/local/db/mir_16_nearest-neighbour/e0a86032fae661b1de48828084ab32c3aee40b50871f0f8cd4b9c1b919991525.npz new file mode 100644 index 0000000..3a13993 Binary files /dev/null and b/tests/data/local/db/mir_16_nearest-neighbour/e0a86032fae661b1de48828084ab32c3aee40b50871f0f8cd4b9c1b919991525.npz differ diff --git a/tests/data/local/db/mir_16_nearest-neighbour/f330f076443c96111fab1e6df633ac3c9e605ffec35b4a1a78bc952e6a5925b6.npz b/tests/data/local/db/mir_16_nearest-neighbour/f330f076443c96111fab1e6df633ac3c9e605ffec35b4a1a78bc952e6a5925b6.npz new file mode 100644 index 0000000..3f5aba0 Binary files /dev/null and b/tests/data/local/db/mir_16_nearest-neighbour/f330f076443c96111fab1e6df633ac3c9e605ffec35b4a1a78bc952e6a5925b6.npz differ diff --git a/tests/data/local/in_5x5.npz b/tests/data/local/in_5x5.npz new file mode 100644 index 0000000..c387c23 Binary files /dev/null and b/tests/data/local/in_5x5.npz differ diff --git a/tests/data/local/in_H4_nested.npz b/tests/data/local/in_H4_nested.npz new file mode 100644 index 0000000..a581036 Binary files /dev/null and b/tests/data/local/in_H4_nested.npz differ diff --git a/tests/data/local/in_H4_ring.npz b/tests/data/local/in_H4_ring.npz new file mode 100644 index 0000000..7c7bf31 Binary files /dev/null and b/tests/data/local/in_H4_ring.npz differ diff --git a/tests/data/local/in_N32.npz b/tests/data/local/in_N32.npz new file mode 100644 index 0000000..d251c09 Binary files /dev/null and b/tests/data/local/in_N32.npz differ diff --git a/tests/data/local/in_O32.npz b/tests/data/local/in_O32.npz new file mode 100644 index 0000000..a0b4d88 Binary files /dev/null and b/tests/data/local/in_O32.npz differ diff --git a/tests/data/local/out_5x5_10x10_grid-box-average.npz b/tests/data/local/out_5x5_10x10_grid-box-average.npz new file mode 100644 index 0000000..5266a00 Binary files /dev/null and b/tests/data/local/out_5x5_10x10_grid-box-average.npz differ diff --git a/tests/data/local/out_5x5_10x10_linear.npz b/tests/data/local/out_5x5_10x10_linear.npz new file mode 100644 index 0000000..bd215fc Binary files /dev/null and b/tests/data/local/out_5x5_10x10_linear.npz differ diff --git a/tests/data/local/out_5x5_10x10_nearest-neighbour.npz b/tests/data/local/out_5x5_10x10_nearest-neighbour.npz new file mode 100644 index 0000000..bd215fc Binary files /dev/null and b/tests/data/local/out_5x5_10x10_nearest-neighbour.npz differ diff --git a/tests/data/local/out_H4_nested_10x10_grid-box-average.npz b/tests/data/local/out_H4_nested_10x10_grid-box-average.npz new file mode 100644 index 0000000..97b41e5 Binary files /dev/null and b/tests/data/local/out_H4_nested_10x10_grid-box-average.npz differ diff --git a/tests/data/local/out_H4_nested_10x10_linear.npz b/tests/data/local/out_H4_nested_10x10_linear.npz new file mode 100644 index 0000000..8af5fd7 Binary files /dev/null and b/tests/data/local/out_H4_nested_10x10_linear.npz differ diff --git a/tests/data/local/out_H4_nested_10x10_nearest-neighbour.npz b/tests/data/local/out_H4_nested_10x10_nearest-neighbour.npz new file mode 100644 index 0000000..250b1d3 Binary files /dev/null and b/tests/data/local/out_H4_nested_10x10_nearest-neighbour.npz differ diff --git a/tests/data/local/out_H4_ring_10x10_grid-box-average.npz b/tests/data/local/out_H4_ring_10x10_grid-box-average.npz new file mode 100644 index 0000000..97b41e5 Binary files /dev/null and b/tests/data/local/out_H4_ring_10x10_grid-box-average.npz differ diff --git a/tests/data/local/out_H4_ring_10x10_linear.npz b/tests/data/local/out_H4_ring_10x10_linear.npz new file mode 100644 index 0000000..e9e6178 Binary files /dev/null and b/tests/data/local/out_H4_ring_10x10_linear.npz differ diff --git a/tests/data/local/out_H4_ring_10x10_nearest-neighbour.npz b/tests/data/local/out_H4_ring_10x10_nearest-neighbour.npz new file mode 100644 index 0000000..2a25dc2 Binary files /dev/null and b/tests/data/local/out_H4_ring_10x10_nearest-neighbour.npz differ diff --git a/tests/data/local/out_N32_10x10_grid-box-average.npz b/tests/data/local/out_N32_10x10_grid-box-average.npz new file mode 100644 index 0000000..f8b5632 Binary files /dev/null and b/tests/data/local/out_N32_10x10_grid-box-average.npz differ diff --git a/tests/data/local/out_N32_10x10_linear.npz b/tests/data/local/out_N32_10x10_linear.npz new file mode 100644 index 0000000..cd92f18 Binary files /dev/null and b/tests/data/local/out_N32_10x10_linear.npz differ diff --git a/tests/data/local/out_N32_10x10_nearest-neighbour.npz b/tests/data/local/out_N32_10x10_nearest-neighbour.npz new file mode 100644 index 0000000..540b50c Binary files /dev/null and b/tests/data/local/out_N32_10x10_nearest-neighbour.npz differ diff --git a/tests/data/local/out_O32_10x10_grid-box-average.npz b/tests/data/local/out_O32_10x10_grid-box-average.npz new file mode 100644 index 0000000..c8bddcb Binary files /dev/null and b/tests/data/local/out_O32_10x10_grid-box-average.npz differ diff --git a/tests/data/local/out_O32_10x10_linear.npz b/tests/data/local/out_O32_10x10_linear.npz new file mode 100644 index 0000000..069ae98 Binary files /dev/null and b/tests/data/local/out_O32_10x10_linear.npz differ diff --git a/tests/data/local/out_O32_10x10_nearest-neighbour.npz b/tests/data/local/out_O32_10x10_nearest-neighbour.npz new file mode 100644 index 0000000..5bda1f5 Binary files /dev/null and b/tests/data/local/out_O32_10x10_nearest-neighbour.npz differ diff --git a/tests/data/local/out_eORCA025_T_O96_linear.npz b/tests/data/local/out_eORCA025_T_O96_linear.npz new file mode 100644 index 0000000..69aed25 Binary files /dev/null and b/tests/data/local/out_eORCA025_T_O96_linear.npz differ diff --git a/tests/data/o32.grib2 b/tests/data/o32.grib2 new file mode 100644 index 0000000..58d0dde Binary files /dev/null and b/tests/data/o32.grib2 differ diff --git a/tests/downstream-ci-requirements.txt b/tests/downstream-ci-requirements.txt index 21ac768..be43850 100644 --- a/tests/downstream-ci-requirements.txt +++ b/tests/downstream-ci-requirements.txt @@ -1,3 +1,4 @@ +earthkit-data pyproj scipy requests diff --git a/tests/environment-unit-tests.yml b/tests/environment-unit-tests.yml index 4ff7442..cfdc7c7 100644 --- a/tests/environment-unit-tests.yml +++ b/tests/environment-unit-tests.yml @@ -1,23 +1,29 @@ -name: earthkit-data +name: earthkit-geo channels: - - conda-forge - - nodefaults +- conda-forge +- nodefaults dependencies: - - pyproj - - scipy - - requests - - make - - myst-parser - - pre-commit - - pydata-sphinx-theme - - pytest - - pytest-cov - - pytest-forked - - pytest-timeout - - sphinx>=7.3.7 - - sphinx-autoapi - - sphinx_rtd_theme - - sphinxcontrib-apidoc - - nbsphinx - - sphinx-issues - - sphinx-copybutton +- pip +- deprecation +- multiurl +- filelock +- pyproj +- scipy +- requests +- make +- myst-parser +- pre-commit +- pydata-sphinx-theme +- pytest +- pytest-cov +- pytest-forked +- pytest-timeout +- sphinx>=7.3.7 +- sphinx-autoapi +- sphinx_rtd_theme +- sphinxcontrib-apidoc +- nbsphinx +- sphinx-issues +- sphinx-copybutton +- pip: + - mir-python>=1.28.0.13 diff --git a/tests/regrid/inventory/test_gridspec.py b/tests/regrid/inventory/test_gridspec.py new file mode 100644 index 0000000..0d58489 --- /dev/null +++ b/tests/regrid/inventory/test_gridspec.py @@ -0,0 +1,152 @@ +# (C) Copyright 2023 ECMWF. +# +# This software is licensed under the terms of the Apache Licence Version 2.0 +# which can be obtained at http://www.apache.org/licenses/LICENSE-2.0. +# In applying this licence, ECMWF does not waive the privileges and immunities +# granted to it by virtue of its status as an intergovernmental organisation +# nor does it submit to any jurisdiction. + +import pytest + +from earthkit.geo.regrid.backends.db import SYS_DB + + +@pytest.mark.parametrize( + "gs_in, gs_out", + [ + ({"grid": [5, 5]}, {"grid": [10, 10]}), + ({"grid": [5, 5], "area": [90, 0, -90, 360]}, {"grid": [10, 10]}), + ({"grid": [5, 5], "area": [90, 0, -90, 355]}, {"grid": [10, 10]}), + ({"grid": [5, 5]}, {"grid": [10, 10], "area": [90, 0, -90, 360]}), + ({"grid": [5, 5]}, {"grid": [10, 10], "area": [90, 0, -90, 350]}), + ( + {"grid": [5, 5], "area": [90, 0, -90, 360]}, + {"grid": [10, 10], "area": [90, 0, -90, 360]}, + ), + ({"grid": [5, 5], "shape": [37, 72]}, {"grid": [10, 10], "shape": [19, 36]}), + ({"grid": [5, 5], "shape": [37, 72]}, {"grid": [10, 10]}), + ({"grid": [5, 5]}, {"grid": [10, 10], "shape": [19, 36]}), + ({"grid": "O32"}, {"grid": [0.1, 0.1]}), + ({"grid": "O32"}, {"grid": [0.125, 0.125]}), + ({"grid": "O32"}, {"grid": [0.15, 0.15]}), + ({"grid": "O32"}, {"grid": [0.2, 0.2]}), + ({"grid": "O32"}, {"grid": [0.25, 0.25]}), + ({"grid": "O32"}, {"grid": [0.3, 0.3]}), + ({"grid": "O32"}, {"grid": [0.4, 0.4]}), + ({"grid": "O32"}, {"grid": [0.5, 0.5]}), + ({"grid": "O32"}, {"grid": [0.6, 0.6]}), + ({"grid": "O32"}, {"grid": [0.7, 0.7]}), + ({"grid": "O32"}, {"grid": [0.75, 0.75]}), + ({"grid": "O32"}, {"grid": [0.8, 0.8]}), + ({"grid": "O32"}, {"grid": [0.9, 0.9]}), + ({"grid": "O32"}, {"grid": [1, 1]}), + ({"grid": "O32"}, {"grid": [1.2, 1.2]}), + ({"grid": "O32"}, {"grid": [1.25, 1.25]}), + ({"grid": "O32"}, {"grid": [1.4, 1.4]}), + ({"grid": "O32"}, {"grid": [1.5, 1.5]}), + ({"grid": "O32"}, {"grid": [1.6, 1.6]}), + ({"grid": "O32"}, {"grid": [1.8, 1.8]}), + ({"grid": "O32"}, {"grid": [2, 2]}), + ({"grid": "O32"}, {"grid": [2.5, 2.5]}), + ({"grid": "O32"}, {"grid": [5, 5]}), + ({"grid": "O32"}, {"grid": [10, 10]}), + ({"grid": "O32", "shape": [5248]}, {"grid": [10, 10]}), + ({"grid": "O32", "area": [90, 0, -90, 360]}, {"grid": [10, 10]}), + # ({"grid": "O32", "area": [87.8638, 0, -87.8638, 357.5]}, {"grid": [10, 10]}), + # ( + # {"grid": "O32", "area": [87.8638, 0.01, -87.8638, 357.5]}, + # {"grid": [10, 10]}, + # ), + # ( + # {"grid": "O32", "area": [87.8638, 0, -87.8638, 357.6]}, + # {"grid": [10, 10]}, + # ), + ({"grid": "O32", "global": 1}, {"grid": [10, 10]}), + ( + {"grid": "O32", "global": 1, "area": [87.8638, 0, -87.8638, 357.5]}, + {"grid": [10, 10]}, + ), + ({"grid": "N32"}, {"grid": [10, 10]}), + ({"grid": "N32", "shape": [6114]}, {"grid": [10, 10]}), + ({"grid": "N32", "area": [90, 0, -90, 360]}, {"grid": [10, 10]}), + # ({"grid": "N32", "area": [87.8638, 0, -87.8638, 357.188]}, {"grid": [10, 10]}), + # ({"grid": "N32", "area": [87.8638, 0, -87.8638, 357.189]}, {"grid": [10, 10]}), + # ( + # {"grid": "N32", "area": [87.8638, 0.01, -87.8638, 357.188]}, + # {"grid": [10, 10]}, + # ), + ({"grid": "N32", "global": 1}, {"grid": [10, 10]}), + ( + {"grid": "N32", "global": 1, "area": [87.8638, 0, -87.8638, 357.188]}, + {"grid": [10, 10]}, + ), + ({"grid": "H128"}, {"grid": [1, 1]}), + ({"grid": "H128", "order": "ring"}, {"grid": [1, 1]}), + ({"grid": "H128", "ordering": "ring"}, {"grid": [1, 1]}), + ({"grid": "H128", "order": "nested"}, {"grid": [1, 1]}), + ({"grid": "H128", "ordering": "nested"}, {"grid": [1, 1]}), + # ({"grid": (5, 5)}, {"grid": (10, 10)}), + ({"grid": "eORCA025_T"}, {"grid": "O96"}), + ], +) +def test_gridspec_ok(gs_in, gs_out): + r = SYS_DB.find_entry(gs_in, gs_out, "linear") + assert r, f"gs_in={gs_in} gs_out={gs_out}" + + +@pytest.mark.parametrize( + "gs_in, gs_out, order", + [ + ({"grid": "H128"}, {"grid": [1, 1]}, None), + ({"grid": "H128", "order": "ring"}, {"grid": [1, 1]}, None), + ({"grid": "H128", "ordering": "ring"}, {"grid": [1, 1]}, None), + ({"grid": "H128", "order": "nested"}, {"grid": [1, 1]}, "nested"), + ({"grid": "H128", "ordering": "nested"}, {"grid": [1, 1]}, "nested"), + ], +) +def test_gridspec_healpix(gs_in, gs_out, order): + r = SYS_DB.find_entry(gs_in, gs_out, "linear") + assert r, f"gs_in={gs_in} gs_out={gs_out}" + assert r["input"].spec.get("order") == order + + +@pytest.mark.parametrize( + "gs_in,gs_out,err", + [ + ({"grid": [1, 1]}, {"grid": [2, 2]}, None), + ({"grid": [5, 5], "area": [90, 0, -90, 350]}, {"grid": [10, 10]}, None), + # ({"grid": [5, 5], "area": [90.001, 0, -90, 360]}, {"grid": [10, 10]}, None), + # ({"grid": [5, 5], "area": [90, 0, -89.0001, 360]}, {"grid": [10, 10]}, None), + ({"grid": [5, 5], "area": [90, 0.001, -90, 360]}, {"grid": [10, 10]}, None), + # ({"grid": [5, 5], "area": [90, 0, -90, 359.999]}, {"grid": [10, 10]}, None), + ({"grid": [5, 5], "area": [90, 10, -90, 370]}, {"grid": [10, 10]}, None), + ({"grid": "G1280", "shape": 6599680}, {"grid": [10, 10]}, ValueError), + # ({"grid": "O32", "shape": 6599680}, {"grid": [10, 10]}, None), + ({"grid": "O32", "area": [90, 0, -90, 359.999]}, {"grid": [10, 10]}, None), + ({"grid": "O32", "area": [90, -0.1, -90, 360]}, {"grid": [10, 10]}, None), + ( + {"grid": "O32", "area": [87.8638, 0, -87.8638, 357.7]}, + {"grid": [10, 10]}, + None, + ), + ( + {"grid": "O32", "area": [87.8638, 0.2, -87.8638, 357.5]}, + {"grid": [10, 10]}, + None, + ), + # ({"grid": "N32", "shape": 6599680}, {"grid": [10, 10]}, None), + ({"grid": "N32", "area": [90, 0, -90, 359.999]}, {"grid": [10, 10]}, None), + ({"grid": "N32", "area": [90, -0.1, -90, 360]}, {"grid": [10, 10]}, None), + ({"grid": "ORCA025_T"}, {"grid": "O96"}, None), + ({"grid": "eORCA025_U"}, {"grid": "O96"}, None), + ({"grid": "bORCA025_T"}, {"grid": "O96"}, ValueError), + ({"grid": "ORCA025_TU"}, {"grid": "O96"}, ValueError), + ], +) +def test_gridspec_bad(gs_in, gs_out, err): + if err: + with pytest.raises(err): + r = SYS_DB.find_entry(gs_in, gs_out, "linear") + else: + r = SYS_DB.find_entry(gs_in, gs_out, "linear") + assert r is None, f"gs_in={gs_in} gs_out={gs_out}" diff --git a/tests/regrid/regrid_backends/test_backend_local_matrix.py b/tests/regrid/regrid_backends/test_backend_local_matrix.py new file mode 100644 index 0000000..b798ca6 --- /dev/null +++ b/tests/regrid/regrid_backends/test_backend_local_matrix.py @@ -0,0 +1,306 @@ +# (C) Copyright 2023 ECMWF. +# +# This software is licensed under the terms of the Apache Licence Version 2.0 +# which can be obtained at http://www.apache.org/licenses/LICENSE-2.0. +# In applying this licence, ECMWF does not waive the privileges and immunities +# granted to it by virtue of its status as an intergovernmental organisation +# nor does it submit to any jurisdiction. + +import os + +import numpy as np +import pytest +from eckit.geo import Grid + +from earthkit.geo.regrid.array import regrid as array_regrid +from earthkit.geo.utils.testing import LOCAL_MATRIX_BACKEND_NAME, earthkit_test_data_path, get_test_data + +DB_PATH = earthkit_test_data_path("local", "db") +DATA_PATH = earthkit_test_data_path("local") +INTERPOLATIONS = ["linear", "nearest-neighbour", "grid-box-average"] + + +def file_in_testdir(filename): + return os.path.join(DATA_PATH, filename) + + +def get_local_db(): + from earthkit.geo.regrid.backends.db import MatrixDb + + return MatrixDb.from_path(DB_PATH) + + +def run_regrid(v_in, in_grid, out_grid, interpolation): + return array_regrid( + v_in, + in_grid, + out_grid, + interpolation=interpolation, + backend=LOCAL_MATRIX_BACKEND_NAME, + inventory=DB_PATH, + ) + + +def test_regrid_local_matrix_index(): + DB = get_local_db() + # we have an extra unsupported entry in the index file. We have + # to be sure the DB is loaded correctly bypassing the unsupported + # entry. + import json + + interpolation = "linear" + + index_path = DB.index_file_path() + with open(index_path, "r") as f: + d = json.load(f) + assert len(d["matrix"]) == 17 + + assert len(DB) == 16 + + # r = DB.find_entry({"grid": [5, 5]}, {"grid": [10, 10]}, interpolation) + # assert r + + r = DB.find_entry({"grid": "O32"}, {"grid": [10, 10]}, interpolation) + assert r + + r = DB.find_entry({"grid": "N32"}, {"grid": [10, 10]}, interpolation) + assert r + + r = DB.find_entry({"grid": "O64"}, {"grid": [10, 10]}, interpolation) + assert r is None + + r = DB.find_entry({"grid": "eORCA025_T"}, {"grid": "O96"}, interpolation) + assert r + + +@pytest.mark.parametrize("interpolation", INTERPOLATIONS) +@pytest.mark.parametrize("out_grid", [{"grid": [10, 10]}, Grid({"grid": [10, 10]}), "'grid': [10, 10]"]) +def test_regrid_local_matrix_ll_to_ll(interpolation, out_grid): + v_in = np.load(file_in_testdir("in_5x5.npz"))["arr_0"] + v_ref = np.load(file_in_testdir(f"out_5x5_10x10_{interpolation}.npz"))["arr_0"] + v_res, grid_res = run_regrid(v_in, in_grid={"grid": [5, 5]}, out_grid=out_grid, interpolation=interpolation) + + assert isinstance(grid_res, dict) + grid_ref = Grid({"grid": [10, 10]}).spec + + assert v_res.shape == (19, 36) + assert grid_res == grid_ref + assert np.allclose(v_res.flatten(), v_ref) + + +@pytest.mark.parametrize("interpolation", INTERPOLATIONS) +@pytest.mark.parametrize("out_grid", [{"grid": [10, 10]}, Grid({"grid": [10, 10]}), "'grid': [10, 10]"]) +def test_regrid_local_matrix_ogg_to_ll(interpolation, out_grid): + v_in = np.load(file_in_testdir("in_O32.npz"))["arr_0"] + v_ref = np.load(file_in_testdir(f"out_O32_10x10_{interpolation}.npz"))["arr_0"] + v_res, grid_res = run_regrid(v_in, in_grid={"grid": "O32"}, out_grid=out_grid, interpolation=interpolation) + + assert isinstance(grid_res, dict) + grid_ref = Grid({"grid": [10, 10]}).spec + + assert v_res.shape == (19, 36) + assert grid_res == grid_ref + assert np.allclose(v_res.flatten(), v_ref) + + +@pytest.mark.parametrize("interpolation", INTERPOLATIONS) +def test_regrid_local_matrix_ngg_to_ll(interpolation): + v_in = np.load(file_in_testdir("in_N32.npz"))["arr_0"] + v_ref = np.load(file_in_testdir(f"out_N32_10x10_{interpolation}.npz"))["arr_0"] + out_grid = {"grid": [10, 10]} + v_res, grid_res = run_regrid( + v_in, + in_grid={"grid": "N32"}, + out_grid=out_grid, + interpolation=interpolation, + ) + + assert v_res.shape == (19, 36) + assert grid_res == out_grid + assert np.allclose(v_res.flatten(), v_ref) + + +@pytest.mark.parametrize("interpolation", INTERPOLATIONS) +@pytest.mark.parametrize("out_grid", [{"grid": [10, 10]}, Grid({"grid": [10, 10]}), "'grid': [10, 10]"]) +def test_regrid_local_matrix_healpix_ring_to_ll(interpolation, out_grid): + v_in = np.load(file_in_testdir("in_H4_ring.npz"))["arr_0"] + v_ref = np.load(file_in_testdir(f"out_H4_ring_10x10_{interpolation}.npz"))["arr_0"] + + v_res, grid_res = run_regrid( + v_in, + in_grid={"grid": "H4", "order": "ring"}, + out_grid=out_grid, + interpolation=interpolation, + ) + + assert isinstance(grid_res, dict) + grid_ref = Grid({"grid": [10, 10]}).spec + + assert v_res.shape == (19, 36) + assert grid_res == grid_ref + assert np.allclose(v_res.flatten(), v_ref) + + +@pytest.mark.parametrize("interpolation", INTERPOLATIONS) +@pytest.mark.parametrize("out_grid", [{"grid": [10, 10]}, Grid({"grid": [10, 10]}), "'grid': [10, 10]"]) +def test_regrid_local_matrix_nested_to_ll(interpolation, out_grid): + v_in = np.load(file_in_testdir("in_H4_nested.npz"))["arr_0"] + v_ref = np.load(file_in_testdir(f"out_H4_nested_10x10_{interpolation}.npz"))["arr_0"] + + v_res, grid_res = run_regrid( + v_in, + in_grid={"grid": "H4", "order": "nested"}, + out_grid=out_grid, + interpolation=interpolation, + ) + + assert isinstance(grid_res, dict) + grid_ref = Grid({"grid": [10, 10]}).spec + + assert v_res.shape == (19, 36) + assert grid_res == grid_ref + assert np.allclose(v_res.flatten(), v_ref) + + +@pytest.mark.parametrize("interpolation", ["linear"]) +def test_regrid_local_matrix_orca_to_ogg(interpolation): + f_in = get_test_data("in_eORCA025_T.npz", subfolder="orca") + f_out = get_test_data(f"out_eORCA025_T_O96_{interpolation}.npz", subfolder="local") + + v_in = np.load(f_in)["arr_0"] + v_ref = np.load(f_out)["arr_0"] + + out_grid = {"grid": "O96"} + v_res, grid_res = run_regrid( + v_in, + in_grid={ + "grid": "eORCA025_T", + }, + out_grid=out_grid, + interpolation=interpolation, + ) + + assert isinstance(grid_res, dict) + grid_ref = Grid({"grid": "O96"}).spec + + assert v_res.shape == (40320,) + assert grid_res == grid_ref + np.testing.assert_allclose(v_res, v_ref, verbose=False) + + +# TODO: implement this test +# @pytest.mark.parametrize("interpolation", ["linear", "nearest-neighbour"]) +# def test_regrid_local_matrix_orca_to_ll(interpolation): +# v_in = np.load(file_in_testdir("in_eorca025_t.npz"))["arr_0"] +# v_ref = np.load(file_in_testdir(f"out_eorca025_t_10x10_{interpolation}.npz"))["arr_0"] +# v_res = regrid( +# v_in, +# {"grid": "eORCA025_T"}, +# {"grid": [10, 10]}, +# inventory_path=DB_PATH, +# interpolation=interpolation, +# ) + +# assert v_res.shape == (19, 36) +# assert np.allclose(v_res.flatten(), v_ref) + + +@pytest.mark.parametrize( + "gs_in, gs_out", + [ + ({"grid": [5, 5]}, {"grid": [10, 10]}), + ({"grid": [5, 5], "area": [90, 0, -90, 360]}, {"grid": [10, 10]}), + ({"grid": [5, 5], "area": [90, 0, -90, 355]}, {"grid": [10, 10]}), + ({"grid": [5, 5]}, {"grid": [10, 10], "area": [90, 0, -90, 360]}), + ({"grid": [5, 5]}, {"grid": [10, 10], "area": [90, 0, -90, 350]}), + ( + {"grid": [5, 5], "area": [90, 0, -90, 360]}, + {"grid": [10, 10], "area": [90, 0, -90, 360]}, + ), + ({"grid": [5, 5], "shape": [37, 72]}, {"grid": [10, 10], "shape": [19, 36]}), + ({"grid": [5, 5], "shape": [37, 72]}, {"grid": [10, 10]}), + ({"grid": [5, 5]}, {"grid": [10, 10], "shape": [19, 36]}), + ({"grid": "O32"}, {"grid": [10, 10]}), + ({"grid": "O32", "shape": [5248]}, {"grid": [10, 10]}), + ({"grid": "O32", "area": [90, 0, -90, 360]}, {"grid": [10, 10]}), + # ({"grid": "O32", "area": [87.8638, 0, -87.8638, 357.5]}, {"grid": [10, 10]}), + # ({"grid": "O32", "area": [87.8638, 0.01, -87.8638, 357.5]}, {"grid": [10, 10]}), + ({"grid": "O32", "global": 1}, {"grid": [10, 10]}), + ( + {"grid": "O32", "global": 1, "area": [87.8638, 0, -87.8638, 357.5]}, + {"grid": [10, 10]}, + ), + ({"grid": "N32"}, {"grid": [10, 10]}), + ({"grid": "N32", "shape": [6114]}, {"grid": [10, 10]}), + ({"grid": "N32", "area": [90, 0, -90, 360]}, {"grid": [10, 10]}), + # ({"grid": "N32", "area": [87.8638, 0, -87.8638, 357.188]}, {"grid": [10, 10]}), + # ({"grid": "N32", "area": [87.8638, 0, -87.8638, 357.189]}, {"grid": [10, 10]}), + # ( + # {"grid": "N32", "area": [87.8638, 0.01, -87.8638, 357.188]}, + # {"grid": [10, 10]}, + # ), + # ( + # {"grid": "O32", "area": [87.8638, 0, -87.8638, 357.6]}, + # {"grid": [10, 10]}, + # ), + ({"grid": "N32", "global": 1}, {"grid": [10, 10]}), + ( + {"grid": "N32", "global": 1, "area": [87.8638, 0, -87.8638, 357.188]}, + {"grid": [10, 10]}, + ), + ({"grid": "H4"}, {"grid": [10, 10]}), + ({"grid": "H4", "ordering": "ring"}, {"grid": [10, 10]}), + ({"grid": "eORCA025_T"}, {"grid": "O96"}), + ({"grid": "n32"}, {"grid": [10, 10]}), + ({"grid": "h4"}, {"grid": [10, 10]}), + ], +) +def test_local_matrix_gridspec_ok(gs_in, gs_out): + DB = get_local_db() + r = DB.find_entry(gs_in, gs_out, "linear") + assert r, f"gs_in={gs_in} gs_out={gs_out}" + + +@pytest.mark.parametrize( + "gs_in,gs_out,err", + [ + ({"grid": [1, 1]}, {"grid": [2, 2]}, None), + ({"grid": [5, 5], "area": [90, 0, -90, 350]}, {"grid": [10, 10]}, None), + # ({"grid": [5, 5], "area": [90.001, 0, -90, 360]}, {"grid": [10, 10]}, None), + # ({"grid": [5, 5], "area": [90, 0, -89.0001, 360]}, {"grid": [10, 10]}, None), + ({"grid": [5, 5], "area": [90, 0.001, -90, 360]}, {"grid": [10, 10]}, None), + # ({"grid": [5, 5], "area": [90, 0, -90, 359.999]}, {"grid": [10, 10]}, None), + ({"grid": [5, 5], "area": [90, 10, -90, 370]}, {"grid": [10, 10]}, None), + ({"grid": "G1280", "shape": 6599680}, {"grid": [10, 10]}, ValueError), + ({"grid": "O32", "shape": 6599680}, {"grid": [10, 10]}, Exception), + ({"grid": "O32", "area": [90, 0, -90, 359.999]}, {"grid": [10, 10]}, None), + ({"grid": "O32", "area": [90, -0.1, -90, 360]}, {"grid": [10, 10]}, None), + ( + {"grid": "O32", "area": [87.8638, 0, -87.8638, 357.7]}, + {"grid": [10, 10]}, + None, + ), + ( + {"grid": "O32", "area": [87.8638, 0.2, -87.8638, 357.5]}, + {"grid": [10, 10]}, + None, + ), + ({"grid": "N32", "shape": 6599680}, {"grid": [10, 10]}, Exception), + ({"grid": "N32", "area": [90, 0, -90, 359.999]}, {"grid": [10, 10]}, None), + ({"grid": "N32", "area": [90, -0.1, -90, 360]}, {"grid": [10, 10]}, None), + ({"grid": "H4", "ordering": "any"}, {"grid": [10, 10]}, ValueError), + # ({"grid": "ORCA025_T"}, {"grid": "O96"}, None), + # ({"grid": "eORCA025_U"}, {"grid": "O96"}, None), + ({"grid": "bORCA025_T"}, {"grid": "O96"}, ValueError), + ({"grid": "ORCA025_TU"}, {"grid": "O96"}, ValueError), + # ({"grid": "eorca025_t"}, {"grid": "O96"}, ValueError), + ], +) +def test_local_matrix_gridspec_bad(gs_in, gs_out, err): + DB = get_local_db() + if err: + with pytest.raises(err): + r = DB.find_entry(gs_in, gs_out, "linear") + else: + r = DB.find_entry(gs_in, gs_out, "linear") + assert r is None, f"gs_in={gs_in} gs_out={gs_out}" diff --git a/tests/regrid/regrid_backends/test_backend_matrix.py b/tests/regrid/regrid_backends/test_backend_matrix.py new file mode 100644 index 0000000..2a639ff --- /dev/null +++ b/tests/regrid/regrid_backends/test_backend_matrix.py @@ -0,0 +1,206 @@ +# (C) Copyright 2023 ECMWF. +# +# This software is licensed under the terms of the Apache Licence Version 2.0 +# which can be obtained at http://www.apache.org/licenses/LICENSE-2.0. +# In applying this licence, ECMWF does not waive the privileges and immunities +# granted to it by virtue of its status as an intergovernmental organisation +# nor does it submit to any jurisdiction. + +import numpy as np +import pytest +from eckit.geo import Grid + +from earthkit.geo.regrid.array import regrid as regrid_array +from earthkit.geo.utils.testing import SYSTEM_MATRIX_BACKEND_NAME, get_test_data + +INTERPOLATIONS = ["linear", "nearest-neighbour"] + + +@pytest.mark.download +@pytest.mark.tmp_cache +@pytest.mark.parametrize( + "_kwarg,interpolation", + [ + ({}, "linear"), + ({"interpolation": "linear"}, "linear"), + ({"interpolation": "nearest-neighbour"}, "nearest-neighbour"), + ({"interpolation": "nn"}, "nearest-neighbour"), + ({"interpolation": "nearest-neighbor"}, "nearest-neighbour"), + # ({"interpolation": "grid-box-average"}, "grid-box-average"), + ], +) +@pytest.mark.parametrize("out_grid", [{"grid": [10, 10]}, Grid({"grid": [10, 10]}), "'grid': [10, 10]"]) +def test_regrid_matrix_interpolation_kwarg(_kwarg, interpolation, out_grid): + f_in, f_out = get_test_data(["in_O32.npz", f"out_O32_10x10_{interpolation}.npz"]) + + v_in = np.load(f_in)["arr_0"] + v_ref = np.load(f_out)["arr_0"] + v_res, grid_res = regrid_array( + v_in, {"grid": "O32"}, out_grid=out_grid, backend=SYSTEM_MATRIX_BACKEND_NAME, **_kwarg + ) + + assert isinstance(grid_res, dict) + grid_ref = Grid({"grid": [10, 10]}).spec + + assert v_res.shape == (19, 36) + assert grid_res == grid_ref + assert np.allclose(v_res.flatten(), v_ref) + + +def _ll_to_ll(interpolation): + f_in, f_out = get_test_data(["in_5x5.npz", f"out_5x5_10x10_{interpolation}.npz"]) + + v_in = np.load(f_in)["arr_0"] + v_ref = np.load(f_out)["arr_0"] + out_grid = {"grid": [10, 10]} + v_res, res_grid = regrid_array( + v_in, + {"grid": [5, 5]}, + out_grid=out_grid, + interpolation=interpolation, + backend=SYSTEM_MATRIX_BACKEND_NAME, + ) + + assert v_res.shape == (19, 36), 1 + assert res_grid == out_grid, 1 + assert np.allclose(v_res.flatten(), v_ref), 1 + + # repeated use + v_res, grid_res = regrid_array( + v_in, + {"grid": [5, 5]}, + out_grid=out_grid, + interpolation=interpolation, + backend=SYSTEM_MATRIX_BACKEND_NAME, + ) + + assert v_res.shape == (19, 36), 2 + assert grid_res == out_grid, 2 + assert np.allclose(v_res.flatten(), v_ref), 2 + + +@pytest.mark.download +@pytest.mark.tmp_cache +@pytest.mark.parametrize("interpolation", INTERPOLATIONS) +def test_regrid_matrix_ll_to_ll(interpolation): + _ll_to_ll(interpolation) + + +@pytest.mark.download +@pytest.mark.parametrize("interpolation", INTERPOLATIONS) +def test_regrid_matrix_ll_to_ll_user_cache(interpolation): + _ll_to_ll(interpolation) + + +@pytest.mark.download +@pytest.mark.tmp_cache +@pytest.mark.parametrize("interpolation", INTERPOLATIONS) +def test_regrid_matrix_ogg_to_ll(interpolation): + f_in, f_out = get_test_data(["in_O32.npz", f"out_O32_10x10_{interpolation}.npz"]) + + v_in = np.load(f_in)["arr_0"] + v_ref = np.load(f_out)["arr_0"] + out_grid = {"grid": [10, 10]} + v_res, grid_res = regrid_array( + v_in, + {"grid": "O32"}, + out_grid=out_grid, + interpolation=interpolation, + backend=SYSTEM_MATRIX_BACKEND_NAME, + ) + + assert v_res.shape == (19, 36) + assert grid_res == out_grid + assert np.allclose(v_res.flatten(), v_ref) + + +@pytest.mark.download +@pytest.mark.tmp_cache +@pytest.mark.parametrize("interpolation", INTERPOLATIONS) +def test_regrid_matrix_ngg_to_ll(interpolation): + f_in, f_out = get_test_data(["in_N32.npz", f"out_N32_10x10_{interpolation}.npz"]) + + v_in = np.load(f_in)["arr_0"] + v_ref = np.load(f_out)["arr_0"] + out_grid = {"grid": [10, 10]} + v_res, grid_res = regrid_array( + v_in, + {"grid": "N32"}, + out_grid=out_grid, + interpolation=interpolation, + backend=SYSTEM_MATRIX_BACKEND_NAME, + ) + + assert v_res.shape == (19, 36) + assert grid_res == out_grid + assert np.allclose(v_res.flatten(), v_ref) + + +@pytest.mark.download +@pytest.mark.tmp_cache +@pytest.mark.parametrize("interpolation", INTERPOLATIONS) +def test_regrid_matrix_healpix_ring_to_ll(interpolation): + f_in, f_out = get_test_data(["in_H4_ring.npz", f"out_H4_ring_10x10_{interpolation}.npz"]) + + v_in = np.load(f_in)["arr_0"] + v_ref = np.load(f_out)["arr_0"] + out_grid = {"grid": [10, 10]} + v_res, grid_res = regrid_array( + v_in, + {"grid": "H4", "order": "ring"}, + out_grid=out_grid, + interpolation=interpolation, + backend=SYSTEM_MATRIX_BACKEND_NAME, + ) + + assert v_res.shape == (19, 36) + assert grid_res == out_grid + assert np.allclose(v_res.flatten(), v_ref) + + +@pytest.mark.download +@pytest.mark.tmp_cache +@pytest.mark.parametrize("interpolation", INTERPOLATIONS) +def test_regrid_matrix_healpix_nested_to_ll(interpolation): + f_in, f_out = get_test_data(["in_H4_nested.npz", f"out_H4_nested_10x10_{interpolation}.npz"]) + + v_in = np.load(f_in)["arr_0"] + v_ref = np.load(f_out)["arr_0"] + out_grid = {"grid": [10, 10]} + v_res, grid_res = regrid_array( + v_in, + {"grid": "H4", "order": "nested"}, + out_grid=out_grid, + interpolation=interpolation, + backend=SYSTEM_MATRIX_BACKEND_NAME, + ) + + assert v_res.shape == (19, 36) + assert grid_res == out_grid + assert np.allclose(v_res.flatten(), v_ref) + + +@pytest.mark.tmp_cache +def test_regrid_matrix_unsupported_input_grid() -> None: + a = np.ones(91 * 180) + with pytest.raises(ValueError): + _ = regrid_array( + a, + {"grid": [2.2333424, 2]}, + {"grid": [1, 1]}, + interpolation="linear", + backend=SYSTEM_MATRIX_BACKEND_NAME, + ) + + +@pytest.mark.tmp_cache +def test_regrid_matrix_unsupported_output_grid() -> None: + a = np.ones(181 * 360) + with pytest.raises(ValueError): + _ = regrid_array( + a, + {"grid": [1.11323424, 1]}, + {"grid": [5, 5]}, + interpolation="linear", + backend=SYSTEM_MATRIX_BACKEND_NAME, + ) diff --git a/tests/regrid/regrid_backends/test_backend_matrix_memcache.py b/tests/regrid/regrid_backends/test_backend_matrix_memcache.py new file mode 100644 index 0000000..236b668 --- /dev/null +++ b/tests/regrid/regrid_backends/test_backend_matrix_memcache.py @@ -0,0 +1,395 @@ +# (C) Copyright 2023 ECMWF. +# +# This software is licensed under the terms of the Apache Licence Version 2.0 +# which can be obtained at http://www.apache.org/licenses/LICENSE-2.0. +# In applying this licence, ECMWF does not waive the privileges and immunities +# granted to it by virtue of its status as an intergovernmental organisation +# nor does it submit to any jurisdiction. + +import os + +import numpy as np +import pytest + +from earthkit.geo.regrid.array import regrid as regrid_array +from earthkit.geo.utils.testing import earthkit_test_data_path + +DB_PATH = earthkit_test_data_path("local", "db") +DATA_PATH = earthkit_test_data_path("local") + +# TODO: these tests cannot be run in parallel as they modify the global settings. +# We should refactor the tests once the settings are properly implemented. + +# NOTE: The tests are skipped for now as it is not yet decided if the weights +# based interpolation will be used in the future. + + +def file_in_testdir(filename): + return os.path.join(DATA_PATH, filename) + + +def run_regrid(mode): + v_in = np.load(file_in_testdir("in_N32.npz"))["arr_0"] + np.load(file_in_testdir(f"out_N32_10x10_{mode}.npz"))["arr_0"] + regrid_array( + v_in, + {"grid": "N32"}, + {"grid": [10, 10]}, + interpolation=mode, + backend="precomputed", + inventory=DB_PATH, + ) + + +@pytest.fixture +def patch_estimate_matrix_memory(monkeypatch): + from earthkit.geo.regrid.backends.db import MatrixIndex + + def patched_estimate_memory(self): + return 200000 + + monkeypatch.setattr(MatrixIndex, "estimate_memory", patched_estimate_memory) + + +@pytest.mark.parametrize( + "policy,adjust_to, evict", + [("lru", "second", "first"), ("largest", "second", "first")], +) +def test_local_memcache_core_1(policy, adjust_to, evict): + """The cache is large enough to hold two matrices. The first matrix is larger than the second one.""" + from earthkit.geo import config + from earthkit.geo.utils.memcache import MEMORY_CACHE + + max_mem = 300 * 1024 * 1024 + + with config.temporary(): + config.set("weights-memory-cache-policy", policy) + config.set("maximum-weights-memory-cache-size", max_mem) + + MEMORY_CACHE.clear() + + assert MEMORY_CACHE.max_mem == max_mem + assert MEMORY_CACHE.hits == 0 + assert MEMORY_CACHE.misses == 0 + assert MEMORY_CACHE.info() == (0, 0, max_mem, 0, 0, policy) + + run_regrid("linear") + assert MEMORY_CACHE.max_mem == max_mem + assert MEMORY_CACHE.hits == 0 + assert MEMORY_CACHE.misses == 1 + info = MEMORY_CACHE.info() + assert info.hits == 0 + assert info.misses == 1 + assert info.maxsize == max_mem + assert info.currsize > 0 + assert info.count == 1 + mem_first = MEMORY_CACHE.curr_mem + + run_regrid("linear") + assert MEMORY_CACHE.max_mem == max_mem + assert MEMORY_CACHE.hits == 1 + assert MEMORY_CACHE.misses == 1 + assert MEMORY_CACHE.info() == (1, 1, max_mem, mem_first, 1, policy) + + run_regrid("nearest-neighbour") + assert MEMORY_CACHE.max_mem == max_mem + assert MEMORY_CACHE.hits == 1 + assert MEMORY_CACHE.misses == 2 + mem_second = MEMORY_CACHE.curr_mem - mem_first + MEMORY_CACHE.info() == (1, 2, max_mem, MEMORY_CACHE.curr_mem, 2, policy) + + run_regrid("nearest-neighbour") + assert MEMORY_CACHE.max_mem == max_mem + assert MEMORY_CACHE.hits == 2 + assert MEMORY_CACHE.misses == 2 + assert MEMORY_CACHE.info() == (2, 2, max_mem, MEMORY_CACHE.curr_mem, 2, policy) + + # We rely on the first weights being larger than the second one. + assert mem_first > mem_second + + # reduce max size so that the weights specified by "evict" should be evicted. + if adjust_to == "first": + max_mem = mem_first + 10 + elif adjust_to == "second": + max_mem = mem_second + 10 + else: + raise ValueError(f"Invalid adjust_to value: {adjust_to}") + + config.set("maximum-weights-memory-cache-size", max_mem) + + if evict == "first": + assert MEMORY_CACHE.info() == (2, 2, max_mem, mem_second, 1, policy) + elif evict == "second": + assert MEMORY_CACHE.info() == (2, 2, max_mem, mem_first, 1, policy) + else: + raise ValueError(f"Invalid evict value: {evict}") + + +@pytest.mark.parametrize( + "policy,adjust_to, evict", + [("lru", "second", "first"), ("largest", "first", "second")], +) +def test_local_memcache_core_2(policy, adjust_to, evict): + """The cache is large enough to hold two matrices. The first weights is smaller than the second one.""" + from earthkit.geo import config + from earthkit.geo.utils.memcache import MEMORY_CACHE + + max_mem = 300 * 1024 * 1024 + with config.temporary(): + config.set("weights-memory-cache-policy", policy) + config.set("maximum-weights-memory-cache-size", max_mem) + + MEMORY_CACHE.clear() + + assert MEMORY_CACHE.max_mem == max_mem + assert MEMORY_CACHE.hits == 0 + assert MEMORY_CACHE.misses == 0 + assert MEMORY_CACHE.info() == (0, 0, max_mem, 0, 0, policy) + + run_regrid("nearest-neighbour") + assert MEMORY_CACHE.hits == 0 + assert MEMORY_CACHE.misses == 1 + info = MEMORY_CACHE.info() + assert info.hits == 0 + assert info.misses == 1 + assert info.maxsize == max_mem + assert info.currsize > 0 + assert info.count == 1 + mem_first = MEMORY_CACHE.curr_mem + + run_regrid("nearest-neighbour") + assert MEMORY_CACHE.max_mem == max_mem + assert MEMORY_CACHE.hits == 1 + assert MEMORY_CACHE.misses == 1 + assert MEMORY_CACHE.info() == (1, 1, max_mem, mem_first, 1, policy) + + run_regrid("linear") + assert MEMORY_CACHE.max_mem == max_mem + assert MEMORY_CACHE.hits == 1 + assert MEMORY_CACHE.misses == 2 + mem_second = MEMORY_CACHE.curr_mem - mem_first + MEMORY_CACHE.info() == (1, 2, max_mem, MEMORY_CACHE.curr_mem, 2, policy) + + run_regrid("linear") + assert MEMORY_CACHE.max_mem == max_mem + assert MEMORY_CACHE.hits == 2 + assert MEMORY_CACHE.misses == 2 + assert MEMORY_CACHE.info() == (2, 2, max_mem, MEMORY_CACHE.curr_mem, 2, policy) + + # We rely on the first weights being smaller than the second one. + assert mem_second > mem_first + + # reduce max size so that the weights specified by "evict" should be evicted. + if adjust_to == "first": + max_mem = mem_first + 10 + elif adjust_to == "second": + max_mem = mem_second + 10 + else: + raise ValueError(f"Invalid adjust_to value: {adjust_to}") + + config.set("maximum-weights-memory-cache-size", max_mem) + + if evict == "first": + assert MEMORY_CACHE.info() == (2, 2, max_mem, mem_second, 1, policy) + elif evict == "second": + assert MEMORY_CACHE.info() == (2, 2, max_mem, mem_first, 1, policy) + else: + raise ValueError(f"Invalid evict value: {evict}") + + +@pytest.mark.parametrize("policy", ["largest", "lru"]) +def test_local_memcache_small(policy): + """Test the cache with such a small memory limit that no weights fits in""" + from earthkit.geo import config + from earthkit.geo.utils.memcache import MEMORY_CACHE + + max_mem = 1 + with config.temporary(): + config.set("weights-memory-cache-policy", policy) + config.set("maximum-weights-memory-cache-size", max_mem) + + MEMORY_CACHE.clear() + + assert MEMORY_CACHE.max_mem == max_mem + assert MEMORY_CACHE.hits == 0 + assert MEMORY_CACHE.misses == 0 + assert MEMORY_CACHE.info() == (0, 0, max_mem, 0, 0, policy) + + run_regrid("linear") + assert MEMORY_CACHE.max_mem == max_mem + assert MEMORY_CACHE.hits == 0 + assert MEMORY_CACHE.misses == 1 + info = MEMORY_CACHE.info() + assert info.hits == 0 + assert info.misses == 1 + assert info.maxsize == 1 + assert info.currsize == 0 + assert info.count == 0 + + run_regrid("linear") + assert MEMORY_CACHE.max_mem == max_mem + assert MEMORY_CACHE.hits == 0 + assert MEMORY_CACHE.misses == 2 + assert MEMORY_CACHE.info() == (0, 2, max_mem, 0, 0, policy) + + +def test_local_memcache_off_policy(): + from earthkit.geo import config + from earthkit.geo.utils.memcache import MEMORY_CACHE + + policy = "off" + max_mem = 0 + + with config.temporary(): + config.set("weights-memory-cache-policy", policy) + config.set("maximum-weights-memory-cache-size", max_mem) + + MEMORY_CACHE.clear() + + assert MEMORY_CACHE.info() + + assert MEMORY_CACHE.max_mem == max_mem + assert MEMORY_CACHE.hits == 0 + assert MEMORY_CACHE.misses == 0 + assert MEMORY_CACHE.info() == (0, 0, 0, 0, 0, policy) + + run_regrid("linear") + assert MEMORY_CACHE.max_mem == max_mem + assert MEMORY_CACHE.hits == 0 + assert MEMORY_CACHE.misses == 0 + info = MEMORY_CACHE.info() + assert info.hits == 0 + assert info.misses == 0 + assert info.maxsize == 0 + assert info.currsize == 0 + assert info.count == 0 + + run_regrid("linear") + assert MEMORY_CACHE.max_mem == 0 + assert MEMORY_CACHE.hits == 0 + assert MEMORY_CACHE.misses == 0 + assert MEMORY_CACHE.info() == (0, 0, 0, 0, 0, policy) + + +def test_local_memcache_unlimited(): + from earthkit.geo import config + from earthkit.geo.utils.memcache import MEMORY_CACHE + + policy = "unlimited" + max_mem = None + + with config.temporary(): + config.set("weights-memory-cache-policy", policy) + config.set("maximum-weights-memory-cache-size", max_mem) + + MEMORY_CACHE.clear() + + assert MEMORY_CACHE.max_mem is None + assert MEMORY_CACHE.hits == 0 + assert MEMORY_CACHE.misses == 0 + assert MEMORY_CACHE.info() == (0, 0, None, 0, 0, policy) + + run_regrid("linear") + assert MEMORY_CACHE.max_mem is None + assert MEMORY_CACHE.hits == 0 + assert MEMORY_CACHE.misses == 1 + info = MEMORY_CACHE.info() + assert info.hits == 0 + assert info.misses == 1 + assert info.maxsize is None + assert info.currsize > 0 + assert info.count == 1 + + run_regrid("linear") + assert MEMORY_CACHE.max_mem is None + assert MEMORY_CACHE.hits == 1 + assert MEMORY_CACHE.misses == 1 + assert MEMORY_CACHE.info() == (1, 1, None, MEMORY_CACHE.curr_mem, 1, policy) + + +def test_local_memcache_ensure_strict_1(monkeypatch): + """Test the cache with a memory limit that is too small to hold any estimated weights size""" + from earthkit.geo import config + from earthkit.geo.utils.memcache import MEMORY_CACHE + + policy = "largest" + max_mem = 300 * 1024 * 1024 + + with config.temporary(): + config.set("weights-memory-cache-policy", policy) + config.set("maximum-weights-memory-cache-size", max_mem) + config.set("weights-memory-cache-strict-mode", True) + + MEMORY_CACHE.clear() + + assert MEMORY_CACHE.max_mem == max_mem + assert MEMORY_CACHE.hits == 0 + assert MEMORY_CACHE.misses == 0 + assert MEMORY_CACHE.info() == (0, 0, max_mem, 0, 0, policy) + + def _estimate_memory(entry): + return max_mem + 1 + + from earthkit.geo.utils import memcache + + monkeypatch.setattr(memcache, "estimate_matrix_size", _estimate_memory) + + with pytest.raises(ValueError) as excinfo: + run_regrid("linear") + + assert "Weights too large" in str(excinfo.value) + + +def test_local_memcache_strict_2(monkeypatch): + """Test the cache with a memory limit that can only hold one estimated weights size""" + from earthkit.geo import config + from earthkit.geo.utils.memcache import MEMORY_CACHE + + policy = "largest" + max_mem = 300 * 1024 * 1024 + + with config.temporary(): + config.set("weights-memory-cache-policy", policy) + config.set("maximum-weights-memory-cache-size", max_mem) + config.set("weights-memory-cache-strict-mode", True) + + MEMORY_CACHE.clear() + + assert MEMORY_CACHE.max_mem == max_mem + assert MEMORY_CACHE.hits == 0 + assert MEMORY_CACHE.misses == 0 + assert MEMORY_CACHE.info() == (0, 0, max_mem, 0, 0, policy) + + def _estimate_memory(entry): + return max_mem - 1 + + from earthkit.geo.utils import memcache + + monkeypatch.setattr(memcache, "estimate_matrix_size", _estimate_memory) + + run_regrid("linear") + assert MEMORY_CACHE.max_mem == max_mem + assert MEMORY_CACHE.hits == 0 + assert MEMORY_CACHE.misses == 1 + info = MEMORY_CACHE.info() + assert info.hits == 0 + assert info.misses == 1 + assert info.maxsize == max_mem + assert info.currsize > 0 + assert info.count == 1 + mem_first = info.currsize + + run_regrid("linear") + assert MEMORY_CACHE.max_mem == max_mem + assert MEMORY_CACHE.hits == 1 + assert MEMORY_CACHE.misses == 1 + assert MEMORY_CACHE.info() == (1, 1, max_mem, MEMORY_CACHE.curr_mem, 1, policy) + + # The first weights should be evicted + run_regrid("nearest-neighbour") + assert MEMORY_CACHE.max_mem == max_mem + assert MEMORY_CACHE.hits == 1 + assert MEMORY_CACHE.misses == 2 + info = MEMORY_CACHE.info() + assert info.currsize < mem_first + assert MEMORY_CACHE.info() == (1, 2, max_mem, MEMORY_CACHE.curr_mem, 1, policy) diff --git a/tests/regrid/regrid_backends/test_matrix_fieldlist.py b/tests/regrid/regrid_backends/test_matrix_fieldlist.py new file mode 100644 index 0000000..582700b --- /dev/null +++ b/tests/regrid/regrid_backends/test_matrix_fieldlist.py @@ -0,0 +1,137 @@ +# (C) Copyright 2023 ECMWF. +# +# This software is licensed under the terms of the Apache Licence Version 2.0 +# which can be obtained at http://www.apache.org/licenses/LICENSE-2.0. +# In applying this licence, ECMWF does not waive the privileges and immunities +# granted to it by virtue of its status as an intergovernmental organisation +# nor does it submit to any jurisdiction. + + +import numpy as np +import pytest +from eckit.geo import Grid + +from earthkit.geo.regrid import regrid +from earthkit.geo.utils.testing import ( + NO_EKD, # noqa: E402 + SYSTEM_MATRIX_BACKEND_NAME, # noqa: E402 + get_test_data, # noqa: E402 + get_test_data_path, # noqa: E402 +) + +if not NO_EKD: + from earthkit.data import from_source # noqa + + +def _create_fieldlist(filename, field_type): + ds = from_source("url", get_test_data_path(filename)).to_fieldlist() + if field_type == "array": + return ds.to_fieldlist() + elif field_type == "grib": + return ds + else: + raise ValueError(f"Unknown field type: {field_type}") + + +@pytest.mark.download +@pytest.mark.tmp_cache +@pytest.mark.skipif(NO_EKD, reason="No access to earthkit-data") +@pytest.mark.parametrize( + "_kwarg,interpolation", + [ + ({}, "linear"), + ({"interpolation": "linear"}, "linear"), + ({"interpolation": "nearest-neighbour"}, "nearest-neighbour"), + ({"interpolation": "nn"}, "nearest-neighbour"), + ({"interpolation": "nearest-neighbor"}, "nearest-neighbour"), + ], +) +@pytest.mark.parametrize("field_type", ["grib", "array"]) +@pytest.mark.parametrize("out_grid", [{"grid": [10, 10]}, Grid({"grid": [10, 10]}), "'grid': [10, 10]"]) +def test_regrid_matrix_fieldlist_reg_ll(_kwarg, interpolation, field_type, out_grid): + ds = _create_fieldlist("5x5.grib", field_type) + + f_ref = get_test_data(f"out_5x5_10x10_{interpolation}.npz") + v_ref = np.load(f_ref)["arr_0"] + metadata_ref = ds.metadata(["param", "level", "date", "time"]) + + r = regrid(ds, grid=out_grid, backend=SYSTEM_MATRIX_BACKEND_NAME, **_kwarg) + + assert len(r) == 1 + assert r[0].geography.shape() == (19, 36) + assert np.allclose(r[0].values, v_ref) + assert r.metadata(["param", "level", "date", "time"]) == metadata_ref + + grid_ref = Grid({"grid": [10, 10]}).spec + + for f in r: + assert f.geography.grid().spec == grid_ref + + +@pytest.mark.download +@pytest.mark.tmp_cache +@pytest.mark.skipif(NO_EKD, reason="No access to earthkit-data") +@pytest.mark.parametrize( + "_kwarg,interpolation", + [ + ({}, "linear"), + ({"interpolation": "linear"}, "linear"), + ({"interpolation": "nearest-neighbour"}, "nearest-neighbour"), + ({"interpolation": "nn"}, "nearest-neighbour"), + ({"interpolation": "nearest-neighbor"}, "nearest-neighbour"), + ], +) +@pytest.mark.parametrize("field_type", ["grib", "array"]) +@pytest.mark.parametrize("out_grid", [{"grid": [10, 10]}, Grid({"grid": [10, 10]}), "'grid': [10, 10]"]) +def test_regrid_matrix_fieldlist_gg(_kwarg, interpolation, field_type, out_grid): + ds = _create_fieldlist("O32.grib", field_type) + + f_ref = get_test_data(f"out_O32_10x10_{interpolation}.npz") + v_ref = np.load(f_ref)["arr_0"] + metadata_ref = ds.metadata(["param", "level", "date", "time"]) + + r = regrid(ds, grid=out_grid, backend=SYSTEM_MATRIX_BACKEND_NAME, **_kwarg) + + assert len(r) == 1 + assert r[0].geography.shape() == (19, 36) + assert np.allclose(r[0].values, v_ref) + assert r.metadata(["param", "level", "date", "time"]) == metadata_ref + + grid_ref = Grid({"grid": [10, 10]}).spec + + for f in r: + assert f.geography.grid().spec == grid_ref + + +@pytest.mark.download +@pytest.mark.tmp_cache +@pytest.mark.skipif(NO_EKD, reason="No access to earthkit-data") +@pytest.mark.parametrize( + "_kwarg,interpolation", + [ + ({}, "linear"), + ({"interpolation": "linear"}, "linear"), + ({"interpolation": "nearest-neighbour"}, "nearest-neighbour"), + ({"interpolation": "nn"}, "nearest-neighbour"), + ({"interpolation": "nearest-neighbor"}, "nearest-neighbour"), + ], +) +@pytest.mark.parametrize("field_type", ["grib", "array"]) +@pytest.mark.parametrize("out_grid", [{"grid": [10, 10]}, Grid({"grid": [10, 10]}), "'grid': [10, 10]"]) +def test_regrid_matrix_single_field(_kwarg, interpolation, field_type, out_grid): + ds = _create_fieldlist("5x5.grib", field_type) + + f_ref = get_test_data(f"out_5x5_10x10_{interpolation}.npz") + v_ref = np.load(f_ref)["arr_0"] + field = ds[0] + metadata_ref = field.metadata(["param", "level", "date", "time"]) + + r = regrid(field, grid=out_grid, backend=SYSTEM_MATRIX_BACKEND_NAME, **_kwarg) + + assert r.geography.shape() == (19, 36) + assert np.allclose(r.values, v_ref) + assert r.metadata(["param", "level", "date", "time"]) == metadata_ref + + grid_ref = Grid({"grid": [10, 10]}).spec + + assert r.geography.grid().spec == grid_ref diff --git a/tests/regrid/regrid_backends/test_matrix_xarray.py b/tests/regrid/regrid_backends/test_matrix_xarray.py new file mode 100644 index 0000000..2bfbdfd --- /dev/null +++ b/tests/regrid/regrid_backends/test_matrix_xarray.py @@ -0,0 +1,58 @@ +# (C) Copyright 2023 ECMWF. +# +# This software is licensed under the terms of the Apache Licence Version 2.0 +# which can be obtained at http://www.apache.org/licenses/LICENSE-2.0. +# In applying this licence, ECMWF does not waive the privileges and immunities +# granted to it by virtue of its status as an intergovernmental organisation +# nor does it submit to any jurisdiction. + + +import pytest + +from earthkit.geo.regrid import regrid +from earthkit.geo.utils.testing import ( + NO_EKD, # noqa: E402 + NO_MIR, # noqa: E402 + compare_dims, +) + +if not NO_EKD: + from earthkit.data import from_source # noqa + + +@pytest.mark.skipif(NO_EKD, reason="No earthkit.data available") +@pytest.mark.skipif(NO_MIR, reason="No mir available") +@pytest.mark.parametrize( + "out_grid,dims", + [ + ({"grid": [10, 10]}, {"step": 2, "latitude": 19, "longitude": 36}), + ], +) +def test_regrid_matrix_xarray_from_ogg(out_grid, dims): + + ds_in = from_source("sample", "O32_t2.grib2").to_fieldlist() + assert len(ds_in) == 2 + ds = ds_in.to_xarray() + + r = regrid(ds["2t"], grid=out_grid, interpolation="linear", backend="precomputed") + + compare_dims(r, dims, sizes=True) + + +@pytest.mark.skipif(NO_EKD, reason="No earthkit.data available") +@pytest.mark.skipif(NO_MIR, reason="No mir available") +@pytest.mark.parametrize( + "out_grid,dims", + [ + ({"grid": [10, 10]}, {"step": 2, "latitude": 19, "longitude": 36}), + ], +) +def test_regrid_matrix_xarray_from_h_nested(out_grid, dims): + + ds_in = from_source("sample", "H8_nested_t2.grib2").to_fieldlist() + assert len(ds_in) == 2 + ds = ds_in.to_xarray() + + r = regrid(ds["2t"], grid=out_grid, interpolation="linear", backend="precomputed") + + compare_dims(r, dims, sizes=True) diff --git a/tests/regrid/regrid_backends/test_remote_index.py b/tests/regrid/regrid_backends/test_remote_index.py new file mode 100644 index 0000000..6d220d1 --- /dev/null +++ b/tests/regrid/regrid_backends/test_remote_index.py @@ -0,0 +1,78 @@ +# (C) Copyright 2023 ECMWF. +# +# This software is licensed under the terms of the Apache Licence Version 2.0 +# which can be obtained at http://www.apache.org/licenses/LICENSE-2.0. +# In applying this licence, ECMWF does not waive the privileges and immunities +# granted to it by virtue of its status as an intergovernmental organisation +# nor does it submit to any jurisdiction. + +import os +import time + +import numpy as np +import pytest + +from earthkit.geo.regrid.array import regrid as regrid_array +from earthkit.geo.utils.testing import SYSTEM_MATRIX_BACKEND_NAME + + +@pytest.mark.download +@pytest.mark.tmp_cache +def test_regrid_remote_matrix_index_handling(): + from earthkit.geo.regrid.backends.db import SYS_DB + + interpolation = "linear" + + db = SYS_DB + + # we need to reset the db to ensure to simulate a fresh start + db._reset() + + # initial state + # the index file should be downloaded into the local cache if it is not yet there + assert not db._accessor.checked_remote() + path_ori = db._accessor.index_path() + st = os.stat(path_ori) + m_time_ref = st.st_mtime_ns + + # this should use the index file in the local cache + v_in = np.ones(5248) + out_grid = {"grid": [10, 10]} + v_res, grid_res = regrid_array( + v_in, + {"grid": "O32"}, + out_grid=out_grid, + interpolation=interpolation, + backend=SYSTEM_MATRIX_BACKEND_NAME, + ) + assert v_res.shape == (19, 36) + assert grid_res == out_grid + assert db._accessor.index_path() == path_ori + st = os.stat(path_ori) + m_time = st.st_mtime_ns + assert m_time == m_time_ref, (m_time, m_time_ref) + + # this should trigger a check between the local and remote index file sha and + # download the remote index file if they are different + with pytest.raises(ValueError): + regrid_array( + v_in, + {"grid": "O32"}, + {"grid": [10, 20]}, + interpolation=interpolation, + backend=SYSTEM_MATRIX_BACKEND_NAME, + ) + + assert db._accessor.checked_remote() + + # forcefully download the index file + path = db._accessor.index_path() + st = os.stat(path) + m_time_ref = st.st_mtime_ns + time.sleep(0.001) + db._accessor.reload(force=True) + assert db._accessor.checked_remote() + path = db._accessor.index_path() + st = os.stat(path) + m_time = st.st_mtime_ns + assert m_time > m_time_ref, (m_time, m_time_ref) diff --git a/tests/regrid/regrid_mir/test_mir_grid.py b/tests/regrid/regrid_mir/test_mir_grid.py new file mode 100644 index 0000000..38a606b --- /dev/null +++ b/tests/regrid/regrid_mir/test_mir_grid.py @@ -0,0 +1,86 @@ +# (C) Copyright 2025- ECMWF. +# +# This software is licensed under the terms of the Apache Licence Version 2.0 +# which can be obtained at http://www.apache.org/licenses/LICENSE-2.0. +# In applying this licence, ECMWF does not waive the privileges and immunities +# granted to it by virtue of its status as an intergovernmental organisation +# nor does it submit to any jurisdiction. + +import numpy as np +import pytest + +from earthkit.geo.regrid.array import regrid as regrid_array +from earthkit.geo.utils.testing import NO_MIR # noqa: E402 + +INTERPOLATIONS = ["linear", "nearest-neighbour", "grid-box-average"] + + +@pytest.mark.skipif(NO_MIR, reason="No mir available") +@pytest.mark.parametrize( + "gs_in, gs_out", + [ + ({"grid": [5, 5]}, {"grid": [10, 10]}), + ({"grid": [5, 5], "area": [90, 0, -90, 360]}, {"grid": [10, 10]}), + ({"grid": [5, 5], "area": [90, 0, -90, 355]}, {"grid": [10, 10]}), + ({"grid": [5, 5]}, {"grid": [10, 10], "area": [90, 0, -90, 360]}), + ({"grid": [5, 5]}, {"grid": [10, 10], "area": [90, 0, -90, 350]}), + ( + {"grid": [5, 5], "area": [90, 0, -90, 360]}, + {"grid": [10, 10], "area": [90, 0, -90, 360]}, + ), + ({"grid": [5, 5]}, {"grid": [10, 10]}), + ({"grid": [5, 5]}, {"grid": [10, 10]}), + ({"grid": [5, 5]}, {"grid": [10, 10]}), + ({"grid": "O32"}, {"grid": [10, 10]}), + ({"grid": "o32"}, {"grid": [10, 10]}), + ({"grid": "O32"}, {"grid": [10, 10]}), + ({"grid": "O32", "area": [90, 0, -90, 360]}, {"grid": [10, 10]}), + ({"grid": "O32", "area": [87.8638, 0, -87.8638, 357.5]}, {"grid": [10, 10]}), + # ({"grid": "O32", "area": [87.8638, 0.01, -87.8638, 357.5]}, {"grid": [10, 10]}), + ({"grid": "O32", "global": 1}, {"grid": [10, 10]}), + ( + {"grid": "O32", "global": 1, "area": [87.8638, 0, -87.8638, 357.5]}, + {"grid": [10, 10]}, + ), + ({"grid": "N32"}, {"grid": [10, 10]}), + ({"grid": "N32"}, {"grid": [10, 10]}), + ({"grid": "N32", "area": [90, 0, -90, 360]}, {"grid": [10, 10]}), + ({"grid": "N32", "area": [87.8638, 0, -87.8638, 357.188]}, {"grid": [10, 10]}), + ({"grid": "N32", "area": [87.8638, 0, -87.8638, 357.189]}, {"grid": [10, 10]}), + # ( + # {"grid": "N32", "area": [87.8638, 0.01, -87.8638, 357.188]}, + # {"grid": [10, 10]}, + # ), + ( + {"grid": "O32", "area": [87.8638, 0, -87.8638, 357.6]}, + {"grid": [10, 10]}, + ), + ({"grid": "N32", "global": 1}, {"grid": [10, 10]}), + ({"grid": "n32"}, {"grid": [10, 10]}), + ( + {"grid": "N32", "global": 1, "area": [87.8638, 0, -87.8638, 357.188]}, + {"grid": [10, 10]}, + ), + ({"grid": "H4"}, {"grid": [10, 10]}), + ({"grid": "H4", "order": "ring"}, {"grid": [10, 10]}), + # ({"grid": "eORCA025_T"}, {"grid": "O96"}), + # --- + ({"grid": "H4", "order": "nested"}, {"grid": [10, 10]}), + ({"grid": "h4", "order": "nested"}, {"grid": [10, 10]}), + ], +) +def test_regrid_with_mir_gridspec(gs_in, gs_out): + from mir import Grid + + in_grid = Grid(**gs_in) + values = np.random.rand(in_grid.size()) + + for interpolation in INTERPOLATIONS: + if gs_in["grid"] == "eORCA025_T" and interpolation == "grid-box-average": + continue + + # TODO: make this code work + values_res, _ = regrid_array(values, gs_in, gs_out, interpolation=interpolation) + + result_grid = Grid(gs_out) # NOTE: not necessarily true + assert values_res.shape == result_grid.shape diff --git a/tests/regrid/regrid_mir/test_regrid_fieldlist.py b/tests/regrid/regrid_mir/test_regrid_fieldlist.py new file mode 100644 index 0000000..4f76487 --- /dev/null +++ b/tests/regrid/regrid_mir/test_regrid_fieldlist.py @@ -0,0 +1,135 @@ +# (C) Copyright 2023 ECMWF. +# +# This software is licensed under the terms of the Apache Licence Version 2.0 +# which can be obtained at http://www.apache.org/licenses/LICENSE-2.0. +# In applying this licence, ECMWF does not waive the privileges and immunities +# granted to it by virtue of its status as an intergovernmental organisation +# nor does it submit to any jurisdiction. + + +import numpy as np +import pytest + +from earthkit.geo.regrid import regrid +from earthkit.geo.utils.testing import ( + NO_EKD, # noqa: E402 + NO_MIR, # noqa: E402 + compare_global_ll_results, + get_test_data, # noqa: E402 + get_test_data_path, # noqa: E402 +) + +if not NO_EKD: + from earthkit.data import from_source # noqa + + +def _create_fieldlist(filename, field_type): + ds = from_source("url", get_test_data_path(filename)).to_fieldlist() + if field_type == "array": + return ds.to_fieldlist() + elif field_type == "grib": + return ds + else: + raise ValueError(f"Unknown field type: {field_type}") + + +@pytest.mark.skipif(NO_MIR, reason="No mir available") +@pytest.mark.skipif(NO_EKD, reason="No access to earthkit-data") +@pytest.mark.parametrize( + "_kwarg,interpolation", + [ + ({}, "linear"), + ({"interpolation": "linear"}, "linear"), + ({"interpolation": "nearest-neighbour"}, "nearest-neighbour"), + ({"interpolation": "nn"}, "nearest-neighbour"), + ({"interpolation": "nearest-neighbor"}, "nearest-neighbour"), + ], +) +@pytest.mark.parametrize("field_type", ["grib", "array"]) +def test_regrid_fieldlist_reg_ll(_kwarg, interpolation, field_type): + ds = _create_fieldlist("5x5.grib", field_type) + + f_ref = get_test_data(f"out_5x5_10x10_{interpolation}.npz") + v_ref = np.load(f_ref)["arr_0"] + metadata_ref = ds.metadata(["param", "level", "date", "time", "gridType"]) + + r = regrid(ds, grid={"grid": [10, 10]}, **_kwarg) + + assert len(r) == 1 + assert r[0].shape == (19, 36) + compare_global_ll_results(r[0].to_numpy(), v_ref, interpolation, rtol=1e-4) + assert r.metadata(["param", "level", "date", "time", "gridType"]) == metadata_ref + + grid_ref = {"iDirectionIncrementInDegrees": 10.0, "jDirectionIncrementInDegrees": 10.0} + for f in r: + for k, v in grid_ref.items(): + assert np.isclose(f.metadata(k), v), k + + +@pytest.mark.skipif(NO_MIR, reason="No mir available") +@pytest.mark.skipif(NO_EKD, reason="No access to earthkit-data") +@pytest.mark.parametrize( + "_kwarg,interpolation", + [ + ({}, "linear"), + ({"interpolation": "linear"}, "linear"), + ({"interpolation": "nearest-neighbour"}, "nearest-neighbour"), + ({"interpolation": "nn"}, "nearest-neighbour"), + ({"interpolation": "nearest-neighbor"}, "nearest-neighbour"), + ], +) +@pytest.mark.parametrize("field_type", ["grib", "array"]) +def test_regrid_fieldlist_gg(_kwarg, interpolation, field_type): + ds = _create_fieldlist("O32.grib", field_type) + + f_ref = get_test_data(f"out_O32_10x10_{interpolation}.npz") + v_ref = np.load(f_ref)["arr_0"] + metadata_ref = ds.metadata(["param", "level", "date", "time"]) + + r = regrid(ds, grid={"grid": [10, 10]}, **_kwarg) + + assert len(r) == 1 + assert r[0].shape == (19, 36) + compare_global_ll_results(r[0].to_numpy(), v_ref, interpolation, rtol=1e-4) + assert r.metadata(["param", "level", "date", "time"]) == metadata_ref + + grid_ref = {"iDirectionIncrementInDegrees": 10.0, "jDirectionIncrementInDegrees": 10.0} + for f in r: + for k, v in grid_ref.items(): + assert np.isclose(f.metadata(k), v), k + + assert r.metadata("gridType") == ["regular_ll"] + + +@pytest.mark.skipif(NO_MIR, reason="No mir available") +@pytest.mark.skipif(NO_EKD, reason="No access to earthkit-data") +@pytest.mark.parametrize( + "_kwarg,interpolation", + [ + ({}, "linear"), + ({"interpolation": "linear"}, "linear"), + ({"interpolation": "nearest-neighbour"}, "nearest-neighbour"), + ({"interpolation": "nn"}, "nearest-neighbour"), + ({"interpolation": "nearest-neighbor"}, "nearest-neighbour"), + ], +) +@pytest.mark.parametrize("field_type", ["grib", "array"]) +def test_regrid_single_field(_kwarg, interpolation, field_type): + ds = _create_fieldlist("O32.grib", field_type) + field = ds[0] + + f_ref = get_test_data(f"out_O32_10x10_{interpolation}.npz") + v_ref = np.load(f_ref)["arr_0"] + metadata_ref = field.metadata(["param", "level", "date", "time"]) + + r = regrid(field, grid={"grid": [10, 10]}, **_kwarg) + + assert r.shape == (19, 36) + compare_global_ll_results(r.to_numpy(), v_ref, interpolation, rtol=1e-4) + assert r.metadata(["param", "level", "date", "time"]) == metadata_ref + + grid_ref = {"iDirectionIncrementInDegrees": 10.0, "jDirectionIncrementInDegrees": 10.0} + for k, v in grid_ref.items(): + assert np.isclose(r.metadata(k), v), k + + assert r.metadata("gridType") == "regular_ll" diff --git a/tests/regrid/regrid_mir/test_regrid_grib_message.py b/tests/regrid/regrid_mir/test_regrid_grib_message.py new file mode 100644 index 0000000..24806aa --- /dev/null +++ b/tests/regrid/regrid_mir/test_regrid_grib_message.py @@ -0,0 +1,43 @@ +# (C) Copyright 2023 ECMWF. +# +# This software is licensed under the terms of the Apache Licence Version 2.0 +# which can be obtained at http://www.apache.org/licenses/LICENSE-2.0. +# In applying this licence, ECMWF does not waive the privileges and immunities +# granted to it by virtue of its status as an intergovernmental organisation +# nor does it submit to any jurisdiction. + +import pytest + +from earthkit.geo.regrid import regrid +from earthkit.geo.utils.testing import ( + NO_EKD, # noqa: E402 + NO_MIR, # noqa: E402 + earthkit_test_data_path, +) + +INTERPOLATIONS = ["linear", "nearest-neighbour", "grid-box-average"] + + +@pytest.mark.skipif(NO_MIR, reason="No mir available") +@pytest.mark.skipif(NO_EKD, reason="No access to earthkit-data") +@pytest.mark.parametrize("input_format", ["BytesIO", "bytes"]) +@pytest.mark.parametrize("interpolation", INTERPOLATIONS) +def test_regrid_grib_message(input_format, interpolation): + from io import BytesIO + + from earthkit.data.field.grib.create import create_grib_field_from_buffer + + def check_header(contents): + assert contents.startswith(b"GRIB") and contents.endswith(b"7777") + + with open(earthkit_test_data_path("o32.grib2"), "rb") as fh: + in_grib = BytesIO(fh.read()) + check_header(in_grib.getvalue()) + if input_format == "bytes": + in_grib = in_grib.getvalue() + + out = regrid(in_grib, grid={"grid": [30, 30]}, interpolation=interpolation) + + field = create_grib_field_from_buffer(out) + assert field.metadata("gridType") == "regular_ll" + assert field.shape == (7, 12) diff --git a/tests/regrid/regrid_mir/test_regrid_numpy.py b/tests/regrid/regrid_mir/test_regrid_numpy.py new file mode 100644 index 0000000..16b1041 --- /dev/null +++ b/tests/regrid/regrid_mir/test_regrid_numpy.py @@ -0,0 +1,342 @@ +# (C) Copyright 2023 ECMWF. +# +# This software is licensed under the terms of the Apache Licence Version 2.0 +# which can be obtained at http://www.apache.org/licenses/LICENSE-2.0. +# In applying this licence, ECMWF does not waive the privileges and immunities +# granted to it by virtue of its status as an intergovernmental organisation +# nor does it submit to any jurisdiction. + +import numpy as np +import pytest + +from earthkit.geo.regrid.array import regrid as regrid_array +from earthkit.geo.utils.testing import ( + NO_MIR, # noqa: E402 + compare_global_ll_results, + get_test_data, +) + +BASE_INTERPOLATIONS = ["linear", "nearest-neighbour"] +INTERPOLATIONS = BASE_INTERPOLATIONS + ["grid-box-average"] + + +LATLON_REFS_FULL = [ + (0.05, (3601, 7200)), + (0.1, (1801, 3600)), + (0.125, (1441, 2880)), + (0.15, (1201, 2400)), + (0.2, (901, 1800)), + (0.25, (721, 1440)), + (0.3, (601, 1200)), + (0.35, (515, 1029)), + (0.4, (451, 900)), + (0.5, (361, 720)), + (0.6, (301, 600)), + (0.7, (257, 515)), + (0.8, (225, 450)), + (0.9, (201, 400)), + (1, (181, 360)), + (1.2, (151, 300)), + (1.25, (145, 288)), + (1.4, (129, 258)), + (1.5, (121, 240)), + (1.6, (113, 225)), + (1.8, (101, 200)), + (2, (91, 180)), + (2.5, (73, 144)), + (5, (37, 72)), + (10, (19, 36)), +] + +LATLON_REFS = [ + (0.5, (361, 720)), +] + +RED_GG_O_REFS = [ + ("O48", (10944,)), + # ("O1280", (6599680,)), +] + +RED_GG_N_REFS = [ + ("N48", (13280,)), + # ("N320", (542080,)), +] + +REG_GG_REFS = [ + ("F32", (64, 128)), +] + +H_RING_REFS = [ + ("H4", (192,)), +] + +H_NESTED_REFS = [ + ("H4", (192,)), +] + +# These tests are too slow for now +ORCA_REFS = [] +# ORCA_REFS = [ +# ("eORCA025_T", (1442, 1207)), +# ] + + +def make_refs(): + """Create references for the tests.""" + refs = [] + for res_dx, res_shape in LATLON_REFS: + refs.append(({"grid": [res_dx, res_dx]}, res_shape)) + + for out_grid, res_shape in RED_GG_O_REFS: + refs.append(({"grid": out_grid}, res_shape)) + + for out_grid, res_shape in RED_GG_N_REFS: + refs.append(({"grid": out_grid}, res_shape)) + + for out_grid, res_shape in REG_GG_REFS: + refs.append(({"grid": out_grid}, res_shape)) + + for out_grid, res_shape in H_RING_REFS: + refs.append(({"grid": out_grid, "order": "ring"}, res_shape)) + + for out_grid, res_shape in H_NESTED_REFS: + refs.append(({"grid": out_grid, "order": "nested"}, res_shape)) + + for out_grid, res_shape in ORCA_REFS: + refs.append(({"grid": out_grid}, res_shape)) + + return refs + + +REFS = make_refs() + + +@pytest.mark.skipif(NO_MIR, reason="No mir available") +@pytest.mark.parametrize( + "_kwarg,interpolation", + [ + ({}, "linear"), + ({"interpolation": "linear"}, "linear"), + ({"interpolation": "nearest-neighbour"}, "nearest-neighbour"), + ({"interpolation": "nn"}, "nearest-neighbour"), + ({"interpolation": "nearest-neighbor"}, "nearest-neighbour"), + # ({"interpolation": "grid-box-average"}, "grid-box-average"), + ], +) +def test_regrid_numpy_kwarg(_kwarg, interpolation): + f_in, f_out = get_test_data(["in_O32.npz", f"out_O32_10x10_{interpolation}.npz"]) + + v_in = np.load(f_in)["arr_0"] + v_ref = np.load(f_out)["arr_0"] + v_res, _ = regrid_array(v_in, {"grid": "O32"}, {"grid": [10, 10]}, **_kwarg) + + assert v_res.shape == (19, 36), 1 + compare_global_ll_results(v_res, v_ref, interpolation, rtol=1e-4) + + +def _ll_to_ll(interpolation): + f_in, f_out = get_test_data(["in_5x5.npz", f"out_5x5_10x10_{interpolation}.npz"]) + + v_in = np.load(f_in)["arr_0"] + v_ref = np.load(f_out)["arr_0"] + v_res, _ = regrid_array(v_in, {"grid": [5, 5]}, {"grid": [10, 10]}, interpolation=interpolation) + + assert v_res.shape == (19, 36), 1 + assert np.allclose(v_res.flatten(), v_ref), 1 + + # repeated use + v_res, _ = regrid_array(v_in, {"grid": [5, 5]}, {"grid": [10, 10]}, interpolation=interpolation) + + assert v_res.shape == (19, 36), 1 + assert np.allclose(v_res.flatten(), v_ref), 1 + + +@pytest.mark.skipif(NO_MIR, reason="No mir available") +@pytest.mark.parametrize("interpolation", BASE_INTERPOLATIONS) +def test_regrid_numpy_ll_to_ll_1(interpolation): + _ll_to_ll(interpolation) + + +@pytest.mark.skipif(NO_MIR, reason="No mir available") +@pytest.mark.parametrize("interpolation", ["linear"]) +@pytest.mark.parametrize("res_dx,res_shape", LATLON_REFS_FULL) +def test_regrid_numpy_ll_to_ll_2(res_dx, res_shape, interpolation): + values = np.random.random((37, 72)) + res_v, _ = regrid_array( + values, + in_grid={"grid": [5, 5]}, + out_grid={"grid": [res_dx, res_dx]}, + interpolation=interpolation, + ) + assert res_v.shape == res_shape + + +@pytest.mark.skipif(NO_MIR, reason="No mir available") +@pytest.mark.parametrize("interpolation", BASE_INTERPOLATIONS) +def test_regrid_numpy_ogg_to_ll_1(interpolation): + f_in, f_out = get_test_data(["in_O32.npz", f"out_O32_10x10_{interpolation}.npz"]) + + v_in = np.load(f_in)["arr_0"] + v_ref = np.load(f_out)["arr_0"] + v_res, _ = regrid_array(v_in, {"grid": "O32"}, {"grid": [10, 10]}, interpolation=interpolation) + + assert v_res.shape == (19, 36) + compare_global_ll_results(v_res, v_ref, interpolation, rtol=1e-4) + + +@pytest.mark.skipif(NO_MIR, reason="No mir available") +@pytest.mark.parametrize("interpolation", INTERPOLATIONS) +@pytest.mark.parametrize("in_grid", ["O32", "o32"]) +def test_regrid_numpy_ogg_to_ll_2(interpolation, in_grid): + values_in = np.load(get_test_data("in_O32.npz"))["arr_0"] + + values, gridspec = regrid_array( + values_in, + {"grid": in_grid}, + {"grid": [30, 30]}, + interpolation=interpolation, + ) + + assert values.shape == (7, 12) + assert gridspec == dict(grid=[30, 30]) + + +@pytest.mark.skipif(NO_MIR, reason="No mir available") +@pytest.mark.parametrize( + "interpolation", + [ + "linear", + "nearest-neighbour", + "grid-box-average", + "grid-box-statistics", + "nn", + "bilinear", + "k-nearest-neighbours", + ], +) +def test_regrid_numpy_ogg_to_ll_interpolations(interpolation): + # O32 + values = np.random.random(5248) + res_v, _ = regrid_array( + values, + in_grid={"grid": "O32"}, + out_grid={"grid": [10, 10]}, + interpolation=interpolation, + ) + assert res_v.shape == (19, 36), f"{interpolation=} failed" + + +@pytest.mark.skipif(NO_MIR, reason="No mir available") +@pytest.mark.parametrize("interpolation", BASE_INTERPOLATIONS) +def test_regrid_numpy_ngg_to_ll(interpolation): + f_in, f_out = get_test_data(["in_N32.npz", f"out_N32_10x10_{interpolation}.npz"]) + + v_in = np.load(f_in)["arr_0"] + v_ref = np.load(f_out)["arr_0"] + v_res, _ = regrid_array(v_in, {"grid": "N32"}, {"grid": [10, 10]}, interpolation=interpolation) + + assert v_res.shape == (19, 36) + + # Compare only the valid values (FIXME inaccurate reference results, ingnore first and last row) + mask = np.ones_like(v_res, dtype=bool) + mask[0] = False + mask[-1] = False + compare_global_ll_results(v_res[mask], v_ref[mask.flatten()], interpolation) + + +@pytest.mark.skipif(NO_MIR, reason="No mir available") +@pytest.mark.parametrize("interpolation", BASE_INTERPOLATIONS) +@pytest.mark.parametrize("in_grid", ["H4", "h4"]) +def test_regrid_healpix_ring_to_ll(interpolation, in_grid): + f_in, f_out = get_test_data(["in_H4_ring.npz", f"out_H4_ring_10x10_{interpolation}.npz"]) + + v_in = np.load(f_in)["arr_0"] + v_ref = np.load(f_out)["arr_0"] + v_res, _ = regrid_array( + v_in, + {"grid": in_grid, "order": "ring"}, + {"grid": [10, 10]}, + interpolation=interpolation, + ) + + assert v_res.shape == (19, 36) + np.testing.assert_allclose(v_res.flatten(), v_ref, verbose=False) + + v_ref = v_ref.reshape(v_res.shape) + + +@pytest.mark.skip(reason="This test is currently failing, the reference has to be updated") +@pytest.mark.skipif(NO_MIR, reason="No mir available") +@pytest.mark.parametrize("interpolation", BASE_INTERPOLATIONS) +def test_regrid_healpix_nested_to_ll(interpolation): + f_in, f_out = get_test_data(["in_H4_nested.npz", f"out_H4_nested_10x10_{interpolation}.npz"]) + + v_in = np.load(f_in)["arr_0"] + v_ref = np.load(f_out)["arr_0"] + v_res, _ = regrid_array( + v_in, + {"grid": "H4", "order": "nested"}, + {"grid": [10, 10]}, + interpolation=interpolation, + ) + + assert v_res.shape == (19, 36) + v_ref = v_ref.reshape(v_res.shape) + + # print(v_res[0, :20] - v_ref[0, :20]) + # print(v_res[1, :20] - v_ref[1, :20]) + # print(v_res[2, :20] - v_ref[2, :20]) + + np.testing.assert_allclose(v_res.flatten(), v_ref.flatten(), verbose=False) + + +@pytest.mark.skip(reason="This test is too slow for now") +@pytest.mark.skipif(NO_MIR, reason="No mir available") +# @pytest.mark.skipif(True, reason="No ORCA support for numpy in MIR") +@pytest.mark.parametrize("interpolation", ["linear"]) +def test_regrid_orca_to_ogg(interpolation): + f_in = get_test_data("in_eORCA025_T.npz", subfolder="orca") + f_out = get_test_data(f"out_eORCA025_T_O96_{interpolation}.npz", subfolder="local") + + v_in = np.load(f_in)["arr_0"] + v_ref = np.load(f_out)["arr_0"] + + out_grid = {"grid": "O96"} + v_res, grid_res = regrid_array( + v_in, + { + "grid": "eORCA025_T", + }, + out_grid, + interpolation=interpolation, + ) + + assert v_res.shape == (40320,) + assert grid_res == out_grid + + # Compare only the valid values (FIXME inaccurate reference results) + # assert not np.any(np.isnan(v_res) ^ np.isnan(v_ref)), + # "Mismatch of missing values between result and reference" + mask = ~np.isnan(v_res) & ~np.isnan(v_ref) + np.testing.assert_allclose(v_res[mask], v_ref[mask], atol=5e-1, rtol=5e-3, verbose=False) + + +@pytest.mark.skipif(NO_MIR, reason="No mir available") +@pytest.mark.parametrize("interpolation", ["linear"]) +@pytest.mark.parametrize( + "in_grid,in_shape", + [ + ({"grid": [5, 5]}, (37, 72)), + ({"grid": "O32"}, (5248,)), + ({"grid": "N32"}, (6114,)), + ({"grid": "F48"}, (96, 192)), + ({"grid": "H8", "order": "ring"}, (768,)), + ({"grid": "H8", "order": "nested"}, (768,)), + # ({"grid": "eORCA025_T"}, (1442, 1207)), # this test is too slow for now + ], +) +@pytest.mark.parametrize("out_grid,res_shape", REFS) +def test_regrid_numpy_any_to_any(interpolation, in_grid, in_shape, out_grid, res_shape): + values = np.random.random(in_shape) + res_v, _ = regrid_array(values, in_grid=in_grid, out_grid=out_grid, interpolation=interpolation) + assert res_v.shape == res_shape, f"Expected shape {res_shape}, got {res_v.shape}" diff --git a/tests/regrid/regrid_mir/test_regrid_xarray.py b/tests/regrid/regrid_mir/test_regrid_xarray.py new file mode 100644 index 0000000..cccea2c --- /dev/null +++ b/tests/regrid/regrid_mir/test_regrid_xarray.py @@ -0,0 +1,117 @@ +# (C) Copyright 2023 ECMWF. +# +# This software is licensed under the terms of the Apache Licence Version 2.0 +# which can be obtained at http://www.apache.org/licenses/LICENSE-2.0. +# In applying this licence, ECMWF does not waive the privileges and immunities +# granted to it by virtue of its status as an intergovernmental organisation +# nor does it submit to any jurisdiction. + + +import numpy as np +import pytest + +from earthkit.geo.regrid import regrid +from earthkit.geo.utils.testing import ( + NO_EKD, # noqa: E402 + NO_MIR, # noqa: E402 + compare_dims, +) + +if not NO_EKD: + from earthkit.data import from_source # noqa + + +REFS = [ + ({"grid": [10, 10]}, {"step": 2, "latitude": 19, "longitude": 36}), + ({"grid": "N32"}, {"step": 2, "values": 6114}), + ({"grid": "H4", "order": "nested"}, {"step": 2, "values": 192}), + ({"grid": "H4", "order": "ring"}, {"step": 2, "values": 192}), +] + +REFS_SUBAREA = [ + ( + {"grid": [10, 10], "area": [80, -20, -10, 60]}, + {"step": 2, "latitude": 10, "longitude": 9}, + [80, -20, -10, 60], + ), + ( + {"grid": [10, 10], "area": [85, -25, -10, 60]}, + {"step": 2, "latitude": 10, "longitude": 9}, + [80, -20, -10, 60], + ), +] + + +@pytest.mark.skipif(NO_MIR, reason="No mir available") +@pytest.mark.skipif(NO_EKD, reason="No earthkit.data available") +@pytest.mark.parametrize("out_grid,dims", REFS) +def test_regrid_xarray_from_ogg(out_grid, dims): + + ds_in = from_source("sample", "O32_t2.grib2").to_fieldlist() + assert len(ds_in) == 2 + ds = ds_in.to_xarray() + + r = regrid(ds["2t"], grid=out_grid, interpolation="linear") + + compare_dims(r, dims, sizes=True) + + +@pytest.mark.skip(reason="This test is currently failing") +@pytest.mark.skipif(NO_MIR, reason="No mir available") +@pytest.mark.skipif(NO_EKD, reason="No earthkit.data available") +@pytest.mark.parametrize("out_grid,dims,area_ref", REFS_SUBAREA) +def test_regrid_xarray_from_ogg_to_subarea(out_grid, dims, area_ref): + + ds_in = from_source("sample", "O32_t2.grib2").to_fieldlist() + assert len(ds_in) == 2 + ds = ds_in.to_xarray() + + r = regrid(ds["2t"], grid=out_grid, interpolation="linear") + + compare_dims(r, dims, sizes=True) + + lat = r["latitude"].values + lon = r["longitude"].values + north = lat.max() + south = lat.min() + east = lon.max() + west = lon.min() + + assert np.isclose(north, area_ref[0]) + assert np.isclose(south, area_ref[2]) + assert np.isclose(east, area_ref[3]) + assert np.isclose(west, area_ref[1]) + + +@pytest.mark.skipif(NO_MIR, reason="No mir available") +@pytest.mark.skipif(NO_EKD, reason="No earthkit.data available") +@pytest.mark.parametrize( + "out_grid,dims", + REFS, +) +def test_regrid_xarray_from_h_nested(out_grid, dims): + + ds_in = from_source("sample", "H8_nested_t2.grib2").to_fieldlist() + assert len(ds_in) == 2 + ds = ds_in.to_xarray() + + r = regrid(ds["2t"], grid=out_grid, interpolation="linear") + + compare_dims(r, dims, sizes=True) + + +@pytest.mark.skipif(NO_MIR, reason="No mir available") +@pytest.mark.skipif(NO_EKD, reason="No earthkit.data available") +@pytest.mark.parametrize( + "out_grid,dims", + REFS, +) +def test_regrid_xarray_dataset_from_h_nested(out_grid, dims): + + ds_in = from_source("sample", "H8_nested_t2.grib2").to_fieldlist() + assert len(ds_in) == 2 + ds = ds_in.to_xarray() + + r = regrid(ds, grid=out_grid, interpolation="linear") + + compare_dims(r, dims, sizes=True) diff --git a/tests/test_cartography.py b/tests/test_cartography.py index 21fe965..916f1d9 100644 --- a/tests/test_cartography.py +++ b/tests/test_cartography.py @@ -9,12 +9,9 @@ import pytest -from shapely.geometry import MultiPolygon -from shapely.geometry import Polygon +from shapely.geometry import MultiPolygon, Polygon -from earthkit.geo.cartography import _closest_resolution -from earthkit.geo.cartography import country_polygons -from earthkit.geo.cartography import multipolygon_to_coordinates +from earthkit.geo.cartography import _closest_resolution, country_polygons, multipolygon_to_coordinates @pytest.mark.parametrize( diff --git a/tests/test_coord.py b/tests/test_coord.py index 88978ee..cba6104 100644 --- a/tests/test_coord.py +++ b/tests/test_coord.py @@ -12,8 +12,7 @@ import numpy as np import pytest -from earthkit.geo.coord import latlon_to_xyz -from earthkit.geo.coord import xyz_to_latlon +from earthkit.geo.coord import latlon_to_xyz, xyz_to_latlon from .testing import normalise_lon diff --git a/tests/test_distance.py b/tests/test_distance.py index 491c185..1f6fa84 100644 --- a/tests/test_distance.py +++ b/tests/test_distance.py @@ -12,10 +12,7 @@ import numpy as np import pytest -from earthkit.geo import UNIT_SPHERE -from earthkit.geo import haversine_distance -from earthkit.geo import nearest_point_haversine -from earthkit.geo import nearest_point_kdtree +from earthkit.geo import UNIT_SPHERE, haversine_distance, nearest_point_haversine, nearest_point_kdtree def get_nearest_method(mode): @@ -110,7 +107,7 @@ def test_haversine_distance_with_radius(): # lat is out of range -@pytest.mark.parametrize("p_ref", [((90.00001, 0)), (((-90.00001, 0)))]) +@pytest.mark.parametrize("p_ref", [((90.00001, 0)), ((-90.00001, 0))]) def test_haversine_distance_invalid(p_ref): p = (-48, 12) d = haversine_distance(p_ref, p) diff --git a/tests/test_grid.py b/tests/test_grid.py new file mode 100644 index 0000000..3824311 --- /dev/null +++ b/tests/test_grid.py @@ -0,0 +1,24 @@ +# (C) Copyright 2025- ECMWF. +# +# This software is licensed under the terms of the Apache Licence Version 2.0 +# which can be obtained at http://www.apache.org/licenses/LICENSE-2.0. +# +# In applying this licence, ECMWF does not waive the privileges and immunities +# granted to it by virtue of its status as an intergovernmental organisation nor +# does it submit to any jurisdiction. + + +import pytest + +from earthkit.geo import Grid + + +@pytest.mark.parametrize( + "spec, shape", + [ + (dict(grid=[1, 1]), (181, 360)), + ], +) +def test_grid(spec, shape): + grid = Grid(spec) + assert grid.shape == shape diff --git a/tests/test_rotate.py b/tests/test_rotate.py index 1b9246d..69189a8 100644 --- a/tests/test_rotate.py +++ b/tests/test_rotate.py @@ -12,13 +12,9 @@ import numpy as np import pytest -from earthkit.geo.rotate import rotate -from earthkit.geo.rotate import rotate_vector -from earthkit.geo.rotate import unrotate -from earthkit.geo.rotate import unrotate_vector +from earthkit.geo.rotate import rotate, rotate_vector, unrotate, unrotate_vector -from .testing import earthkit_test_data_file -from .testing import normalise_lon +from .testing import earthkit_test_data_file, normalise_lon def _make_proj(name): diff --git a/tests/utils/test_cache.py b/tests/utils/test_cache.py new file mode 100644 index 0000000..123c830 --- /dev/null +++ b/tests/utils/test_cache.py @@ -0,0 +1,257 @@ +#!/usr/bin/env python3 + +# (C) Copyright 2020 ECMWF. +# +# This software is licensed under the terms of the Apache Licence Version 2.0 +# which can be obtained at http://www.apache.org/licenses/LICENSE-2.0. +# In applying this licence, ECMWF does not waive the privileges and immunities +# granted to it by virtue of its status as an intergovernmental organisation +# nor does it submit to any jurisdiction. +# + +import os + +import pytest + +from earthkit.geo import cache, config +from earthkit.geo.utils.caching import cache_file +from earthkit.geo.utils.temporary import temp_directory + + +def _make_zeros_cache_file(force=False, **kwargs): + def _generate_file(target, size=1024 * 1024, chunk_size=1024 * 1024, **kwargs): + chunk_size = min(chunk_size, size) + zeros = bytes(chunk_size) + + with open(target, "wb") as f: + while size > 0: + bufsize = min(size, chunk_size) + f.write(zeros[:bufsize]) + size -= bufsize + + def _generate(target, args): + return _generate_file(target, **args) + + path = cache_file( + "cache-test", + _generate, + kwargs, + hash_extra="zeros", + extension=".zeros", + force=force, + ) + + return path + + +def check_cache_files(dir_path, managed=True): + def touch(target, args): + assert args["foo"] in (1, 2) + with open(target, "w"): + pass + + path1 = cache_file( + "test_cache", + touch, + {"foo": 1}, + extension=".test", + ) + + path2 = cache_file( + "test_cache", + touch, + {"foo": 2}, + extension=".test", + ) + + assert os.path.exists(path1) + assert os.path.exists(path2) + assert os.path.dirname(path1) == dir_path + assert os.path.dirname(path1) == dir_path + assert path1 != path2 + + if managed: + cnt = 0 + for f in cache.entries(): + if f["owner"] == "test_cache": + cnt += 1 + + assert cnt == 2 + + +@pytest.mark.cache +def test_cache_1(): + with config.temporary(): + config.set("maximum-cache-disk-usage", "99%") + cache.purge(matcher=lambda e: ["owner"] == "test_cache") + check_cache_files(config.get("user-cache-directory")) + + +def test_cache_policy(): + with temp_directory() as user_dir: + # cache = user dir + with config.temporary(): + config.set({"cache-policy": "user", "user-cache-directory": user_dir}) + assert config.get("cache-policy") == "user" + assert config.get("user-cache-directory") == user_dir + assert cache.policy.managed() is True + cache_dir = cache.policy.directory() + assert cache_dir == user_dir + assert os.path.exists(cache_dir) + check_cache_files(cache_dir) + + # cache = temporary with auto generated path + with config.temporary({"cache-policy": "temporary", "temporary-cache-directory-root": None}): + assert config.get("cache-policy") == "temporary" + assert config.get("temporary-cache-directory-root") is None + assert cache.policy.managed() is True + cache_dir = cache.policy.directory() + assert os.path.exists(cache_dir) + check_cache_files(cache_dir) + + # cache = user dir (again) + assert config.get("cache-policy") == "user" + assert config.get("user-cache-directory") == user_dir + assert cache.policy.managed() is True + cache_dir = cache.policy.directory() + assert cache_dir == user_dir + assert os.path.exists(cache_dir) + check_cache_files(cache_dir) + + # cache = temporary with user defined root path + with temp_directory() as root_dir: + with config.temporary({ + "cache-policy": "temporary", + "temporary-cache-directory-root": root_dir, + }): + assert config.get("cache-policy") == "temporary" + assert config.get("temporary-cache-directory-root") == root_dir + assert cache.policy.managed() is True + cache_dir = cache.policy.directory() + assert os.path.exists(cache_dir) + os.path.dirname(cache_dir) == root_dir + check_cache_files(cache_dir) + + # cache = off + with config.temporary("cache-policy", "off"): + assert config.get("cache-policy") == "off" + assert config.get("user-cache-directory") == user_dir + assert cache.policy.managed() is False + + cache_dir = cache.policy.directory() + assert os.path.exists(cache_dir) + check_cache_files(cache_dir, managed=False) + + # cache = user dir (again) + assert config.get("cache-policy") == "user" + assert config.get("user-cache-directory") == user_dir + assert cache.policy.managed() is True + cache_dir = cache.policy.directory() + assert cache_dir == user_dir + assert os.path.exists(cache_dir) + check_cache_files(cache_dir) + + +@pytest.mark.parametrize("policy", ["user", "temporary"]) +def test_cache_management(policy): + with temp_directory() as tmp_dir_path: + with config.temporary(): + if policy == "user": + config.set({"cache-policy": "user", "user-cache-directory": tmp_dir_path}) + assert cache.directory() == tmp_dir_path + elif policy == "temporary": + config.set({ + "cache-policy": "temporary", + "temporary-cache-directory-root": tmp_dir_path, + }) + assert os.path.dirname(cache.directory()) == tmp_dir_path + else: + assert False + + data_size = 10 * 1024 + + # create 3 files existing only in the cache + r = [] + for n in range(3): + r.append(_make_zeros_cache_file(size=data_size, n=n)) + + for path in r: + assert os.path.exists(path) + assert os.path.dirname(path) == cache.directory() + + # check cache contents + num, size = cache.summary_dump_database() + assert num == 3 + assert size == 3 * data_size + assert len(cache.entries()) == 3 + + for i, x in enumerate(cache.entries()): + assert x["size"] == data_size + assert x["owner"] == "cache-test" + assert x["args"] == {"size": data_size, "n": i} + latest_path = x["path"] + + # limit cache size so that only one file should remain + config.set({"maximum-cache-size": "12K", "maximum-cache-disk-usage": None}) + + num, size = cache.summary_dump_database() + assert num == 1 + assert size == data_size + assert len(cache.entries()) == 1 + for x in cache.entries(): + assert x["size"] == data_size + assert x["owner"] == "cache-test" + assert x["args"] == {"size": data_size, "n": 2} + x["path"] == latest_path + break + + # purge the cache + r = None + cache.purge() + num, size = cache.summary_dump_database() + assert num == 0 + assert size == 0 + assert len(cache.entries()) == 0 + + +@pytest.mark.cache +def test_cache_force(): + import time + + def _force_true(args, path, owner_data): + time.sleep(0.001) + return True + + def _force_false(args, path, owner_data): + time.sleep(0.001) + return False + + data_size = 10 * 1024 + path = _make_zeros_cache_file(size=data_size, n=0) + st = os.stat(path) + m_time_ref = st.st_mtime_ns + + path1 = _make_zeros_cache_file(size=data_size, n=0) + assert path1 == path + st = os.stat(path1) + m_time = st.st_mtime_ns + assert m_time == m_time_ref + + path2 = _make_zeros_cache_file(force=_force_false, size=data_size, n=0) + assert path2 == path + st = os.stat(path2) + m_time = st.st_mtime_ns + assert m_time == m_time_ref + + path3 = _make_zeros_cache_file(force=_force_true, size=data_size, n=0) + assert path3 == path + st = os.stat(path3) + m_time = st.st_mtime_ns + assert m_time != m_time_ref + m_time_ref = m_time + + path4 = _make_zeros_cache_file(size=data_size, n=0) + assert path4 == path + st = os.stat(path4) + m_time = st.st_mtime_ns + assert m_time == m_time_ref diff --git a/tests/utils/test_config.py b/tests/utils/test_config.py new file mode 100644 index 0000000..230a6b5 --- /dev/null +++ b/tests/utils/test_config.py @@ -0,0 +1,250 @@ +#!/usr/bin/env python3 + +# (C) Copyright 2023 ECMWF. +# +# This software is licensed under the terms of the Apache Licence Version 2.0 +# which can be obtained at http://www.apache.org/licenses/LICENSE-2.0. +# In applying this licence, ECMWF does not waive the privileges and immunities +# granted to it by virtue of its status as an intergovernmental organisation +# nor does it submit to any jurisdiction. +# + +import os + +import pytest + +from earthkit.geo import config +from earthkit.geo.utils.temporary import temp_directory, temp_file + + +def read_config_yaml(path=os.path.expanduser("~/.config/earthkit/regrid/config.yaml")): + try: + with open(path) as f: + import yaml + + s = yaml.load(f, Loader=yaml.SafeLoader) + if not isinstance(s, dict): + s = {} + return s + except Exception: + return {} + + +@pytest.mark.parametrize( + "param,default_value,new_value", + [ + ("url-download-timeout", 30, 5), + ], +) +def test_configs_params_set_reset(param, default_value, new_value): + ori_value = config.get(param) + + with config.temporary(): + config.reset() + + assert config.get(param) == default_value + config.set(param, new_value) + assert config.get(param) == new_value + config.reset() + assert config.get(param) == default_value + + assert config.get(param) == ori_value + + +def test_config_invalid(): + # invalid param + with pytest.raises(KeyError): + config.get("_invalid_") + + with pytest.raises(KeyError): + config.set("_invalid_", 1) + + # invalid value + with pytest.raises(ValueError): + config.set("url-download-timeout", "A") + + +@pytest.mark.parametrize( + "param,set_value,stored_value,raise_error", + [ + ("url-download-timeout", "A", "A", ValueError), + ("url-download-timeout", 30, 30, None), + ("url-download-timeout", "30", 30, None), + ("url-download-timeout", "2m", 120, None), + ("url-download-timeout", "10h", 36000, None), + ("url-download-timeout", "7d", 7 * 24 * 3600, None), + ("url-download-timeout", "1x", None, ValueError), + ("url-download-timeout", "1M", 60, ValueError), + ], +) +def test_config_set_numbers(param, set_value, stored_value, raise_error): + with config.temporary(): + if raise_error is None: + config.set(param, set_value) + assert config.get(param) == stored_value + else: + with pytest.raises(raise_error): + config.set(param, set_value) + + +def test_config_set_cache_numbers(): + with temp_directory() as tmpdir: + with config.temporary({"cache-policy": "user", "user-cache-directory": tmpdir}): + data = [ + ("maximum-cache-size", "1", 1, None), + ("maximum-cache-size", "1k", 1024, None), + ("maximum-cache-size", "1kb", 1024, None), + ("maximum-cache-size", "1k", 1024, None), + ("maximum-cache-size", "1kb", 1024, None), + ("maximum-cache-size", "1K", 1024, None), + ("maximum-cache-size", "1M", 1024 * 1024, None), + ("maximum-cache-size", "1G", 1024 * 1024 * 1024, None), + ("maximum-cache-size", "1T", 1024 * 1024 * 1024 * 1024, None), + ("maximum-cache-size", "1P", 1024 * 1024 * 1024 * 1024 * 1024, None), + ("maximum-cache-size", None, None, None), + ("maximum-cache-size", "-1", None, ValueError), + ("maximum-cache-disk-usage", "2%", 2, None), + ("maximum-cache-disk-usage", None, None, None), + ("maximum-cache-disk-usage", "-2%", None, ValueError), + ("maximum-cache-disk-usage", "102%", 102, None), + ("maximum-cache-disk-usage", "0%", 0, None), + ] + + for param, set_value, stored_value, raise_error in data: + if raise_error is None: + config.set(param, set_value) + if stored_value is not None: + assert config.get(param) == stored_value + else: + assert config.get(param) is None + else: + with pytest.raises(raise_error): + config.set(param, set_value) + + +def test_config_set_multi(): + with config.temporary(): + config.set("url-download-timeout", 7) + assert config.get("url-download-timeout") == 7 + + config.set({"url-download-timeout": 2, "check-out-of-date-urls": False}) + assert config.get("url-download-timeout") == 2 + assert not config.get("check-out-of-date-urls") + + config.set(url_download_timeout=11, check_out_of_date_urls=False) + assert config.get("url-download-timeout") == 11 + assert not config.get("check-out-of-date-urls") + + with pytest.raises(KeyError): + config.set({"url-download-timeout": 2, "-invalid-": 21}) + + with pytest.raises(KeyError): + config.set(url_download_timeout=3, __invalid__=11) + + +def test_config_temporary_single(): + with config.temporary("url-download-timeout", 7): + assert config.get("url-download-timeout") == 7 + + with config.temporary({"url-download-timeout": 7}): + assert config.get("url-download-timeout") == 7 + + with config.temporary(url_download_timeout=7): + assert config.get("url-download-timeout") == 7 + + +def test_config_temporary_multi(): + with config.temporary({"url-download-timeout": 2, "check-out-of-date-urls": False}): + assert config.get("url-download-timeout") == 2 + assert not config.get("check-out-of-date-urls") + + with config.temporary(url_download_timeout=3, check_out_of_date_urls=False): + assert config.get("url-download-timeout") == 3 + assert not config.get("check-out-of-date-urls") + + +def test_config_temporary_nested(): + with config.temporary("url-download-timeout", 7): + assert config.get("url-download-timeout") == 7 + with config.temporary("url-download-timeout", 10): + assert config.get("url-download-timeout") == 10 + assert config.get("url-download-timeout") == 7 + + +def test_config_temporary_autosave_1(): + with temp_file() as config_file: + with config.temporary(config_yaml=config_file): + # now config should contain the default values + # we ensure that the configs are saved into the file + config.save_as(config_file) + + key = "url-download-timeout" + + v_ori = config.autosave + config.autosave = False + + # when a key has a default value, it is not saved into the config file + s = read_config_yaml(config_file) + assert key not in s + + v = config.get(key) + config.set(key, v + 10) + assert config.get(key) == v + 10 + + # the config file should be the same + s = read_config_yaml(config_file) + assert key not in s + + config.autosave = v_ori + + +def test_config_temporary_autosave_2(): + with temp_file() as config_file: + with config.temporary(config_yaml=config_file): + # now config should contain the default values + # we ensure that the config is saved into the file + config.save_as(config_file) + + key = "url-download-timeout" + + v_ori = config.autosave + config.autosave = True + + # when a key has a default value, it is not saved into the config file + s = read_config_yaml(config_file) + assert key not in s + + v = config.get(key) + v_new = v + 10 + config.set(key, v_new) + assert config.get(key) == v_new + + # the file changed + s = read_config_yaml(config_file) + assert s[key] == v_new + + config.autosave = False + config.set(key, v) + assert config.get(key) == v + s = read_config_yaml(config_file) + assert s[key] == v_new + + config.autosave = v_ori + + +@pytest.mark.parametrize("value,error", [("10000", None), (10000, None), ("1b", ValueError), ("A", ValueError)]) +def test_config_env(monkeypatch, value, error): + env_key = "EARTHKIT_GEO_URL_DOWNLOAD_TIMEOUT" + monkeypatch.setenv(env_key, value) + + # v_ori = config.autosave + # config.autosave = True + + if error is None: + v = config.get("url-download-timeout") + assert v == 10000 + else: + with pytest.raises(error): + config.get("url-download-timeout") + + # config.autosave = v_ori diff --git a/tests/utils/test_make_matrix.py b/tests/utils/test_make_matrix.py new file mode 100644 index 0000000..8efc372 --- /dev/null +++ b/tests/utils/test_make_matrix.py @@ -0,0 +1,150 @@ +# (C) Copyright 2025- ECMWF. +# +# This software is licensed under the terms of the Apache Licence Version 2.0 +# which can be obtained at http://www.apache.org/licenses/LICENSE-2.0. +# In applying this licence, ECMWF does not waive the privileges and immunities +# granted to it by virtue of its status as an intergovernmental organisation +# nor does it submit to any jurisdiction. + +from pathlib import Path + +import pytest +from scipy.sparse import load_npz + +from earthkit.geo.utils.mir import mir_cached_matrix_to_array, mir_make_matrix + +L1 = [1.0, 2.0, 3.0, 4.0] +L2 = [1.1, 1.9, 3.1, 3.9] +L3 = [5.0] + + +@pytest.mark.skip(reason="This test is disabled until further integration.") +@pytest.mark.parametrize( + "input_grid, output_grid, interpolation, shape", + [ + (dict(grid="1/1"), dict(grid="H2", ordering="nested"), "nn", (48, 360 * 181)), + (dict(grid=[2, 2]), dict(grid="o2"), "linear", (88, 180 * 91)), + ( + dict(grid=[3, 3]), + dict(grid="3/3"), + "linear", + (120 * 61, 120 * 61), + ), # identity + (dict(grid=[1, 1]), dict(grid="H2", ordering="nested"), "nn", (48, 360 * 181)), + (dict(grid="2/2"), dict(grid="o2"), "linear", (88, 180 * 91)), + ( + dict(grid="3/3"), + dict(grid=[3, 3]), + "linear", + (120 * 61, 120 * 61), + ), # identity + ], +) +def test_make_matrix_gridspec_to_gridspec(tmp_path, input_grid, output_grid, interpolation, shape): + mat = Path(tmp_path) / "matrix.npz" + + mir_make_matrix( + in_grid=input_grid, + out_grid=output_grid, + output=mat, + interpolation=interpolation, + ) + + assert mat.exists() + array = load_npz(mat) + assert array.shape == shape + mat.unlink() + + +@pytest.mark.skip(reason="This test is disabled until further integration.") +def test_make_matrix_unstructured_to_gridspec(tmp_path): + mat = Path(tmp_path) / "matrix.npz" + + mir_make_matrix( + in_lat=L1, + in_lon=L2, + out_grid=dict(grid="h2"), + output=mat, + interpolation="nn", + ) + + assert mat.exists() + array = load_npz(mat) + assert array.shape == (48, 4) + mat.unlink() + + +@pytest.mark.skip(reason="This test is disabled until further integration.") +def test_make_matrix_gridspec_to_unstructured(tmp_path): + mat = Path(tmp_path) / "matrix.npz" + + mir_make_matrix( + in_grid=dict(grid="h2"), + out_lat=L2, + out_lon=L1, + output=mat, + interpolation="nn", + ) + + assert mat.exists() + array = load_npz(mat) + assert array.shape == (4, 48) + mat.unlink() + + +@pytest.mark.skip(reason="This test is disabled until further integration.") +def test_make_matrix_unstructured_to_unstructured(tmp_path): + mat = Path(tmp_path) / "matrix.npz" + + mir_make_matrix( + in_lat=L1, + in_lon=L2, + out_lat=L2, + out_lon=L1, + output=mat, + interpolation="nn", + ) + + assert mat.exists() + array = load_npz(mat) + assert array.shape == (4, 4) + mat.unlink() + + +@pytest.mark.skip(reason="This test is disabled until further integration.") +@pytest.mark.parametrize( + "in_lat, in_lon, out_lat, out_lon", + [ + (L1, L1, L1 + L3, L2 + L3), + (L1, L1, L2 + L3, L1 + L3), + (L1, L1, L2 + L3, L2 + L3), + (L1, L2, L1 + L3, L1 + L3), + (L1, L2, L2 + L3, L1 + L3), + (L1, L2, L2 + L3, L2 + L3), + (L2 + L3, L1 + L3, L1, L1), + (L2 + L3, L1 + L3, L1, L2), + (L2 + L3, L1 + L3, L2, L2), + (L2 + L3, L2 + L3, L1, L1), + (L2 + L3, L2 + L3, L1, L2), + (L2 + L3, L2 + L3, L2, L1), + ], +) +def test_make_matrix_unstructured_to_unstructured_alternate(tmp_path, in_lat, in_lon, out_lat, out_lon): + mat = Path(tmp_path) / "matrix.mat" + + mir_make_matrix( + in_lat=in_lat, + in_lon=in_lon, + out_lat=out_lat, + out_lon=out_lon, + output=mat, + interpolation="nn", + ) + assert mat.exists() + + array = mir_cached_matrix_to_array(mat) + assert array.shape == (len(out_lat), len(in_lat)) + + +if __name__ == "__main__": + pytest.main([__file__]) diff --git a/tools/.gitignore b/tools/.gitignore new file mode 100644 index 0000000..6c26206 --- /dev/null +++ b/tools/.gitignore @@ -0,0 +1,62 @@ +# setuptools-scm +version.py +_version.py + +# Sphinx automatic generation of API +docs/_api/ + +_* +*.yaml +*.yml +grib* +matrices* +index* +local* + +# data and matrix files +*.grib +*.grib1 +*.grib2 +*.json +*.npz + + +### VisualStudioCode ### +.vscode/ +# .vscode/* +# !.vscode/settings.json +# !.vscode/tasks.json +# !.vscode/launch.json +# !.vscode/extensions.json +# !.vscode/*.code-snippets + +# Local History for Visual Studio Code +.history/ + +# Built Visual Studio Code Extensions +*.vsix + +### VisualStudioCode Patch ### +# Ignore all local history of files +.history +.ionide + +# Support for Project snippet scope +.vscode/*.code-snippets + +# Ignore code-workspaces +*.code-workspace + +# Ignore cruft update files +*.rej + +# mac +.DS_Store + +# local code +_dev + + +# exceptions +!subset/subset_db_conf.yaml +!subset/eccharts_subset_db_conf.yaml diff --git a/tools/make-matrix.sh b/tools/make-matrix.sh new file mode 100644 index 0000000..62f6723 --- /dev/null +++ b/tools/make-matrix.sh @@ -0,0 +1,93 @@ +#!/bin/bash + +# (C) Copyright 2023 ECMWF. +# +# This software is licensed under the terms of the Apache Licence Version 2.0 +# which can be obtained at http://www.apache.org/licenses/LICENSE-2.0. +# In applying this licence, ECMWF does not waive the privileges and immunities +# granted to it by virtue of its status as an intergovernmental organisation +# nor does it submit to any jurisdiction. + +set -eux + +echo "-------------------------------------------------" + +input=$1 +output=$2 + +method="" + +if [[ ${input:0:1} == "H" ]] ; then + if [[ ${input} == *nested ]] ; then + method="--interpolation=nearest-neighbor" + fi +else + input=$(echo $1 | tr 'onf/' 'ONFx' ) +fi + +if [[ ${output:0:1} != "H" ]] ; then + output=$(echo $2 | tr 'onf/' 'ONFx' ) +fi + + + +output_dir=${3:="matrices"} +index_file=${4:="${output_dir}/index.json"} +index_dir=$(dirname $index_file) +[[ ! -d $index_dir ]] && mkdir $index_dir + +output="$input-$output" +use_mars_cli=0 + +input_dir="grib" + +[[ ! -d $input_dir ]] && mkdir $input_dir +[[ ! -d $output_dir ]] && mkdir $output_dir + + +# get mir version +version=$(~/build/mir/release/bin/mir --version x x 2>/dev/null | grep mir | cut -d ' ' -f 2) + +input_grib=$input_dir/${input}.grib +output_json=$output_dir/${output}-${version}.json + +# retrieve sameple grib file +if [[ ! -f ${input_grib} ]] ; then + + if [[ $use_mars_cli -ne 1 ]] ; then + if [[ $input == "N2560" || $input == "O2560" ]] ; then + class="rd" + expver="i4ql" + else + class="od" + expver="1" + fi + + python3 -c "from earthkit.data import from_source; ds=from_source('mars', {'levtype': 'sfc', 'param': '2t', 'grid': '$1', 'class': '$class', 'expver': '$expver', 'type': 'fc', 'time': '0'}); ds.save('$input_grib')" + else + echo 2 +# mars< 1/1 +# O_rgg: 32 -> O32 +# N_rgg: 32 -> N32 +# H_ring: 32 -> H32_ring +# H_nested: 32 -> H32_nested + +gg_res = [1280, 1024, 640, 512, 400, 320, 256, 200, 160, 128, 96, 80, 64, 48, 32] + +in_grids_ll = [] +in_grids_O_gg = [2560] + gg_res +in_grids_N_gg = gg_res + +in_grids = { + "ll": [], + # "O_rgg": [2560] + gg_res, + # "N_rgg": gg_res, + # "H_ring": [1024, 512, 256, 128, 64, 32, 16, 8, 4, 2], + "H_nested": [1024, 512, 256, 128, 64, 32, 16, 8, 4, 2], +} +out_grids = { + "ll": [ + 0.1, + 0.125, + 0.15, + 0.2, + 0.25, + 0.3, + 0.4, + 0.5, + 0.6, + 0.7, + 0.75, + 0.8, + 0.9, + 1, + 1.2, + 1.25, + 1.4, + 1.5, + 1.6, + 1.8, + 2, + 2.5, + 5, + 10, + ] +} + +in_grids = {"orca": ["eORCA025_T"]} + +out_grids = { + # "O_rgg": [96], + "N_rgg": [320], +} + +build_root_dir = "_build_20241208" +build_dir = os.path.join(build_root_dir, "db") + +# extra = [["0.25x0.25", "N320"], ["O1280", "N320"], ["5x5", "10x10"]] +extra = [] + +in_grids = make_grid_id(in_grids) +out_grids = make_grid_id(out_grids) +LOG.debug(f"{in_grids=}") +LOG.debug(f"{out_grids=}") + +index_file = os.path.join(build_dir, "index.json") + +for method in ["linear", "nn", "grid-box-average"]: + matrix_dir = os.path.join(build_dir, f"matrices_{method}") + + for g_in in in_grids: + for g_out in out_grids: + if g_in != g_out: + make_matrix( + g_in, + g_out, + method, + matrix_dir, + index_file=index_file, + download_index=False, + delete_tmp_json=False, + ) + + for g_in, g_out in extra: + make_matrix( + g_in, + g_out, + method, + matrix_dir, + index_file=index_file, + download_index=False, + delete_tmp_json=False, + ) diff --git a/tools/manage/build_local_test_db.py b/tools/manage/build_local_test_db.py new file mode 100644 index 0000000..af51694 --- /dev/null +++ b/tools/manage/build_local_test_db.py @@ -0,0 +1,46 @@ +# (C) Copyright 2023 ECMWF. +# +# This software is licensed under the terms of the Apache Licence Version 2.0 +# which can be obtained at http://www.apache.org/licenses/LICENSE-2.0. +# In applying this licence, ECMWF does not waive the privileges and immunities +# granted to it by virtue of its status as an intergovernmental organisation +# nor does it submit to any jurisdiction. +# + +import logging +import os +import sys + +here = os.path.dirname(__file__) +sys.path.insert(0, os.path.dirname(here)) + +from utils.matrix import make_matrix # noqa + +logging.basicConfig(level=logging.DEBUG) + +grids = [ + ["5/5", "10/10"], + ["N32", "10/10"], + ["O32", "10/10"], + ["H4_ring", "10/10"], + ["H4_nested", "10/10"], +] + + +# methods = ["linear", "nearest-neighbour"] +methods = ["grid-box-average"] +build_dir = "_test_local_data_20241021" + +index_file = os.path.join(build_dir, "index.json") + +for method in methods: + for g_in, g_out in grids: + make_matrix( + g_in, + g_out, + method, + build_dir, + index_file=index_file, + download_index=False, + delete_tmp_json=True, + ) diff --git a/tools/manage/merge_index.py b/tools/manage/merge_index.py new file mode 100644 index 0000000..4a2fbde --- /dev/null +++ b/tools/manage/merge_index.py @@ -0,0 +1,124 @@ +import argparse +import json +import logging +import os +import sys + +here = os.path.dirname(__file__) +sys.path.insert(0, os.path.dirname(here)) + +from utils.matrix import download_index_file # noqa + +LOG = logging.getLogger(__name__) +logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s") + +""" +This script merges multiple index.json files into a single index.json file. +""" + + +def to_file(d, target): + with open(target, "w") as f: + json.dump(d, f, indent=4) + + +def check_file(target, ref_num): + with open(target) as f: + db = json.load(f) + assert len(db["matrix"]) == ref_num, f"{len(db['matrix'])} != {ref_num}" + + +def merge(input_dir, result_file, system_file=None, dry_run=False): + db_res = {} + total_num = 0 + if system_file is not None: + with open(system_file) as f: + db_res = json.load(f) + total_num = len(db_res["matrix"]) + LOG.info(f"system index file: {system_file} number of entries={total_num}") + + LOG.info("load index file") + # for f in os.scandir(input_dir): + # if f.is_dir() and f.name.startswith("matrices_"): + # index_file = os.path.join(f.path, "index.json") + # with open(index_file) as f: + # db = json.load(f) + # n = len(db["matrix"]) + # total_num += n + # if not db_res: + # db_res = db + # else: + # db_res["matrix"].update(db["matrix"]) + # LOG.info(f" loaded index file: {index_file} number of entries={n}") + + index_file = os.path.join(input_dir, "index.json") + with open(index_file) as f: + db = json.load(f) + n = len(db["matrix"]) + total_num += n + if not db_res: + db_res = db + else: + db_res["matrix"].update(db["matrix"]) + LOG.info(f" loaded index file: {index_file} number of entries={n}") + + LOG.info(f"final index file: {result_file} number of entries={total_num}") + if not dry_run: + to_file(db_res, result_file) + check_file(result_file, total_num) + + +def main(): + parser = argparse.ArgumentParser() + + parser.add_argument( + "--mode", + choices=["local", "system"], + default="local", + help="merge mode", + ) + + parser.add_argument("--input-dir", default="", type=str, help="input root directory path") + parser.add_argument("--output-dir", default="", type=str, help="output directory path") + + parser.add_argument( + "--dry-run", + action="store_true", + help="perform test run without data processing", + ) + + # get args + args = parser.parse_args() + LOG.info(f"args={args}") + + if args.dry_run: + LOG.warn("Running in dry-run mode!") + + if args.mode not in ["local", "system"]: + raise ValueError(f"Invalid mode: {args.mode}") + + if not os.path.exists(args.input_dir): + raise ValueError(f"input directory: {args.input_dir} doest not exist!") + + if args.output_dir == "": + raise ValueError(f"Invalid output directory: {args.output_dir}") + + result_file = os.path.join(args.output_dir, "index.json") + os.makedirs(os.path.dirname(result_file), exist_ok=True) + + if args.mode == "local": + merge(args.input_dir, result_file, dry_run=args.dry_run) + + elif args.mode == "system": + # fetch remote system index.json + system_file = os.path.join(args.output_dir, "index.json.remote") + download_index_file(system_file) + merge(args.input_dir, result_file, system_file=system_file, dry_run=args.dry_run) + + +if __name__ == "__main__": + try: + main() + except KeyboardInterrupt: + LOG.debug("Exception=KeyboardInterrupt") + sys.exit(0) diff --git a/tools/manage/test_db.py b/tools/manage/test_db.py new file mode 100644 index 0000000..782d630 --- /dev/null +++ b/tools/manage/test_db.py @@ -0,0 +1,83 @@ +# (C) Copyright 2023 ECMWF. +# +# This software is licensed under the terms of the Apache Licence Version 2.0 +# which can be obtained at http://www.apache.org/licenses/LICENSE-2.0. +# In applying this licence, ECMWF does not waive the privileges and immunities +# granted to it by virtue of its status as an intergovernmental organisation +# nor does it submit to any jurisdiction. +# + +import glob +import logging +import os +import shutil +import sys + +import earthkit.regrid +import numpy as np + +here = os.path.dirname(__file__) +sys.path.insert(0, os.path.dirname(here)) + +logging.basicConfig(level=logging.DEBUG) + +""" +FOR MAINTENANCE ONLY!!! +----------------------- + +This script generates and runs tests for newly built (partial) matrix inventory. +""" + +build_root_dir = "_build_20241208" +db_dir = os.path.join(build_root_dir, "db") +index_file = os.path.join(build_root_dir, "index", "index.json") +test_dir = os.path.join(build_root_dir, "test") + +methods = ["linear", "nearest-neighbour"] +build_matrix_dirs = ["matrices_linear", "matrices_nn"] + +# methods = ["grid-box-average"] +# build_matrix_dirs = ["matrices_grid-box-average"] + + +def build_test_dir(): + # the target dir must not exist + os.makedirs(test_dir, exist_ok=True) + + # copy matrices + count = 0 + for m_dir in build_matrix_dirs: + m_dir = os.path.join(db_dir, m_dir) + print(f"Looking for matrices in {m_dir}") + for d in glob.glob(m_dir + "/*"): + if os.path.isdir(d): + print(f"Linking {d}") + name = os.path.basename(d) + d_target = os.path.join(test_dir, name) + os.symlink(os.path.abspath(d), d_target) + count += 1 + # os.symlink(os.path.abspath(d), os.path.abspath(d_target) + + if count == 0: + raise RuntimeError("No matrices found!") + + print(f"Linked {count} matrix directories") + + # copy index file + shutil.copy(index_file, os.path.join(test_dir, "index.json")) + + +if not os.path.exists(test_dir): + build_test_dir() + +# TODO: make the tests automatic +gs_in = {"grid": "eORCA025_T"} +gs_out = {"grid": "O96"} +cnt = 0 +for method in methods: + v = np.ones(1740494) + r = earthkit.regrid.interpolate(v, gs_in, gs_out, matrix_source=test_dir, method=method) + assert len(r) == 40320 + cnt += 1 + +print(f"Tests passed: {cnt}") diff --git a/tools/subset/eccharts_subset_db_conf.yaml b/tools/subset/eccharts_subset_db_conf.yaml new file mode 100644 index 0000000..6dd37ab --- /dev/null +++ b/tools/subset/eccharts_subset_db_conf.yaml @@ -0,0 +1,40 @@ +- input: + grid: "O1280" + output: + grid: [0.1, 0.1] + method: linear +- input: + grid: "O1280" + output: + grid: [0.125, 0.125] + method: linear +- input: + grid: "O1280" + output: + grid: [0.25, 0.25] + method: linear +- input: + grid: "O1280" + output: + grid: "N320" + method: linear +- input: + grid: "O1280" + output: + grid: [0.1, 0.1] + method: nearest-neighbour +- input: + grid: "O1280" + output: + grid: [0.125, 0.125] + method: nearest-neighbour +- input: + grid: "O1280" + output: + grid: [0.25, 0.25] + method: nearest-neighbour +- input: + grid: "O1280" + output: + grid: "N320" + method: nearest-neighbour diff --git a/tools/subset/subset_db_conf.yaml b/tools/subset/subset_db_conf.yaml new file mode 100644 index 0000000..6dd37ab --- /dev/null +++ b/tools/subset/subset_db_conf.yaml @@ -0,0 +1,40 @@ +- input: + grid: "O1280" + output: + grid: [0.1, 0.1] + method: linear +- input: + grid: "O1280" + output: + grid: [0.125, 0.125] + method: linear +- input: + grid: "O1280" + output: + grid: [0.25, 0.25] + method: linear +- input: + grid: "O1280" + output: + grid: "N320" + method: linear +- input: + grid: "O1280" + output: + grid: [0.1, 0.1] + method: nearest-neighbour +- input: + grid: "O1280" + output: + grid: [0.125, 0.125] + method: nearest-neighbour +- input: + grid: "O1280" + output: + grid: [0.25, 0.25] + method: nearest-neighbour +- input: + grid: "O1280" + output: + grid: "N320" + method: nearest-neighbour diff --git a/tools/subset/subset_remote_db.py b/tools/subset/subset_remote_db.py new file mode 100644 index 0000000..57b5b9c --- /dev/null +++ b/tools/subset/subset_remote_db.py @@ -0,0 +1,128 @@ +# (C) Copyright 2023 ECMWF. +# +# This software is licensed under the terms of the Apache Licence Version 2.0 +# which can be obtained at http://www.apache.org/licenses/LICENSE-2.0. +# In applying this licence, ECMWF does not waive the privileges and immunities +# granted to it by virtue of its status as an intergovernmental organisation +# nor does it submit to any jurisdiction. +# + +import argparse +import json +import logging +import os +import sys + +import yaml +from earthkit.regrid.db import SYS_DB as DB + +LOG = logging.getLogger(__name__) + + +"""Build a local matrix inventory by subsetting the default (remotely hosted) inventory.""" + + +def subset_remote_db(conf_file, out_dir, strict=True, fail_on_missing=True, dry_run=False): + index_file = os.path.join(out_dir, "index.json") + + if not dry_run: + os.makedirs(out_dir, exist_ok=True) + if strict: + if len(os.listdir(out_dir)) > 0: + raise Exception("out_dir must be empty when strict=True") + + with open(conf_file) as f: + items = yaml.safe_load(f) + + # res = dict(matrix={}) + # entries = [] + # inter = {} + + index = DB.subset_index(items, fail_on_missing=fail_on_missing) + + # copy matrices + for _, entry in index.items(): + matrix_path = DB.copy_matrix_file(entry, out_dir, exist_ok=(not strict), dry_run=dry_run) + + LOG.info(f" matrix_file: {os.path.relpath(matrix_path, out_dir)}") + LOG.info(" matrix copied to out_dir") + + # save index file + index_file = os.path.join(out_dir, "index.json") + if not dry_run: + with open(index_file, "w") as f: + json.dump(index.to_raw(), f, indent=4) + + LOG.info(f"Index data saved to {index_file}") + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument("--conf", default="", type=str, help="configuration file path") + parser.add_argument("--out-dir", default="", type=str, help="output directory path") + + parser.add_argument( + "--allow-missing", + action="store_true", + help="do not fail when a required grid combination is not supported", + ) + + parser.add_argument( + "--strict", + action="store_true", + help="fail when out_dir is not empty", + ) + parser.add_argument( + "--dry-run", + action="store_true", + help="perform test run without data processing", + ) + + parser.add_argument( + "--log-level", + dest="log_level", + choices=["debug", "info", "warn", "error", "critical"], + default="info", + help="set the logging level (default=info)", + ) + + # get args + args = parser.parse_args() + + log_levels = { + "debug": logging.DEBUG, + "info": logging.INFO, + "warn": logging.WARN, + "error": logging.ERROR, + "critical": logging.CRITICAL, + } + logging.basicConfig(level=log_levels[args.log_level], format="%(levelname)s: %(message)s") + + # basic checks + if not os.path.exists(args.conf): + LOG.error(f"Config file path={args.conf} cannot be accessed! Use --conf to specify a valid path!") + sys.exit(1) + + if args.out_dir == "": + LOG.error("No output directory specified! Use --out-dir to specify a path!") + sys.exit(1) + + LOG.info(f"args={args}") + + subset_remote_db( + args.conf, + args.out_dir, + strict=args.strict, + fail_on_missing=not args.allow_missing, + dry_run=args.dry_run, + ) + + LOG.info("DONE") + + +if __name__ == "__main__": + try: + main() + except KeyboardInterrupt: + LOG.debug("Exception=KeyboardInterrupt") + sys.exit(0) diff --git a/tools/utils/__init__.py b/tools/utils/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/tools/utils/grid.py b/tools/utils/grid.py new file mode 100644 index 0000000..b36e0f3 --- /dev/null +++ b/tools/utils/grid.py @@ -0,0 +1,44 @@ +# (C) Copyright 2023 ECMWF. +# +# This software is licensed under the terms of the Apache Licence Version 2.0 +# which can be obtained at http://www.apache.org/licenses/LICENSE-2.0. +# In applying this licence, ECMWF does not waive the privileges and immunities +# granted to it by virtue of its status as an intergovernmental organisation +# nor does it submit to any jurisdiction. +# + + +def make_ll(g): + return f"{g}/{g}" + + +def make_O_rgg(g): + return f"O{g}" + + +def make_N_rgg(g): + return f"N{g}" + + +def make_H_ring(g): + return f"H{g}_ring" + + +def make_H_nested(g): + return f"H{g}_nested" + + +def make_other(g): + return f"{g}" + + +makers = {k: globals()[f"make_{k}"] for k in ["ll", "O_rgg", "N_rgg", "H_ring", "H_nested"]} + + +def make_grid_id(grids): + r = [] + for k, v in grids.items(): + m = makers.get(k, make_other) + for x in v: + r.append(m(x)) + return r diff --git a/tools/utils/matrix.py b/tools/utils/matrix.py new file mode 100644 index 0000000..9917d59 --- /dev/null +++ b/tools/utils/matrix.py @@ -0,0 +1,184 @@ +# (C) Copyright 2023 ECMWF. +# +# This software is licensed under the terms of the Apache Licence Version 2.0 +# which can be obtained at http://www.apache.org/licenses/LICENSE-2.0. +# In applying this licence, ECMWF does not waive the privileges and immunities +# granted to it by virtue of its status as an intergovernmental organisation +# nor does it submit to any jurisdiction. +# + +import logging +import os +import re +from functools import cache + +LOG = logging.getLogger(__name__) + +GRIB_DIR = "grib" +MIR_PATH = os.path.expanduser("~/build/mir/release/bin/mir") +MIR_INTERPOLATE_OPTION = "interpolation" + + +def download_index_file(target): + import requests + from earthkit.regrid.db import _INDEX_GZ_FILENAME, _SYSTEM_URL + + path = os.path.join(_SYSTEM_URL, _INDEX_GZ_FILENAME) + requests.get(path) + r = requests.get(path, allow_redirects=True) + target_gz = target + ".gz" + open(target_gz, "wb").write(r.content) + import gzip + + with gzip.open(target_gz, "rb") as f: + data = f.read() + with open(target, "wb") as f_out: + f_out.write(data) + + +def adjust_grid_name(name): + d = {"n": "N", "o": "O", "f": "F", "/": "x"} + for k, v in d.items(): + name = name.replace(k, v) + return name + + +@cache +def get_mir_version(): + import subprocess + + res = subprocess.run( + [MIR_PATH, "--version", "x", "x"], + stdout=subprocess.PIPE, + ) + for line in res.stdout.decode("utf-8").split("\n"): + if line.lower().startswith("mir"): + return line.split(" ")[1] + + +def get_grib_file(grid, grib_file): + if not os.path.exists(grib_file): + from earthkit.data import from_source + + _class = "od" + expver = "1" + if grid in ["N2560", "O2560"]: + _class = "rd" + expver = "i4ql" + + ds = from_source( + "mars", + { + "levtype": "sfc", + "param": "2t", + "grid": grid, + "class": _class, + "expver": expver, + "type": "fc", + "time": "0", + }, + ) + ds.save(grib_file) + + +def create_matrix_files( + matrix_dir, + src_grid_label, + target_grid_label, + target_grid, + options, + grib_file, + index_file, + add_to_index=True, + delete_tmp_json=False, +): + # generate interpolation matrix + if options: + kwargs = " ".join([f"--{k}={v}" for k, v in options.items()]) + else: + kwargs = "" + + matrix_json = f"{target_grid_label}-{src_grid_label}" + if MIR_INTERPOLATE_OPTION in options: + matrix_json += "-" + options[MIR_INTERPOLATE_OPTION] + matrix_json = os.path.join(matrix_dir, f"{matrix_json}.json") + + if not os.path.exists(matrix_json): + cmd = f"{MIR_PATH} --grid={target_grid} {kwargs} --dump-weights-info={matrix_json} {grib_file} /dev/null" + LOG.debug(f" {cmd=}") + os.system(cmd) + + if not os.path.exists(matrix_json): + print(f"{matrix_json} does not exist!") + + if add_to_index: + # process matrix and add it to index json file + from earthkit.regrid.utils.builder import make_matrix + + make_matrix( + matrix_json, + matrix_dir, + index_file=index_file, + global_input=True, + global_output=True, + ) + + if delete_tmp_json: + os.remove(matrix_json) + + +def make_matrix( + src_grid, + target_grid, + method, + matrix_dir, + index_file=None, + download_index=False, + delete_tmp_json=False, +): + LOG.debug(f"{src_grid=} {target_grid=} {matrix_dir=} {index_file=}") + + options = {} + + src_grid_label = src_grid + target_grid_label = target_grid + + options[MIR_INTERPOLATE_OPTION] = method + + if not re.match(r"[Hh]\d+_[A-z]+", src_grid): + # if src_grid.endswith("_nested"): + # options[MIR_INTERPOLATE_OPTION] = "nearest-neighbor" + # else: + src_grid_label = adjust_grid_name(src_grid) + + if not re.match(r"[Hh]\d+_[A-z]+", target_grid): + target_grid_label = adjust_grid_name(target_grid) + + os.makedirs(matrix_dir, exist_ok=True) + if index_file is None: + index_file = os.path.join(matrix_dir, "index.json") + + assert os.path.exists(GRIB_DIR) + assert os.path.exists(matrix_dir) + assert index_file is not None + + if download_index: + download_index_file(index_file) + assert os.path.exists(index_file) + + grib_file = os.path.join(GRIB_DIR, f"{src_grid_label}.grib") + get_grib_file(src_grid, grib_file) + + # version = get_mir_version() + + create_matrix_files( + matrix_dir, + src_grid_label, + target_grid_label, + target_grid, + options, + grib_file, + index_file, + add_to_index=True, + delete_tmp_json=delete_tmp_json, + )