diff --git a/.devcontainer/Dockerfile b/.devcontainer/Dockerfile index 9ce45c0a..4d5877d2 100644 --- a/.devcontainer/Dockerfile +++ b/.devcontainer/Dockerfile @@ -1,10 +1,16 @@ -FROM osgeo/gdal:ubuntu-small-3.5.0 AS base - ARG DEBIAN_FRONTEND=noninteractive ARG USERNAME=ubuntu ARG GROUPNAME=ubuntu ARG USER_UID=1000 ARG USER_GID=1000 + +FROM osgeo/gdal:ubuntu-small-3.5.0 AS devcontainer +ARG DEBIAN_FRONTEND +ARG USERNAME +ARG GROUPNAME +ARG USER_UID +ARG USER_GID + ENV TZ=Etc/GMT ENV PYTHONUNBUFFERED=1 \ @@ -24,7 +30,8 @@ RUN apt-get update -qy && \ apt-get install -qy --no-install-recommends \ # libpq-dev and build-essential are necessary for psycopg2, which is required for datacube build-essential \ - libpq-dev + libpq-dev \ + graphviz # Adapted from https://github.com/TheKevJames/tools/blob/master/docker-nox/Dockerfile RUN apt-get update -qy && \ @@ -84,3 +91,41 @@ RUN python3.6 -m pip install --user --no-cache-dir --upgrade pip && \ rm -rf /var/cache/apt/lists RUN python3.10 -m pip install --user --no-cache-dir 'nox-poetry==1.0.0' + +COPY pyproject.toml poetry.lock /home/$USERNAME/ +RUN cd /home/$USERNAME && \ + poetry install --no-root --extras 'load-save vector ml' + +# Build the wheel in an ephemeral stage to make it available to dask workers later! +FROM devcontainer as wheel-builder +ARG USERNAME + +COPY . /home/$USERNAME/ +WORKDIR /home/$USERNAME/ + +RUN poetry build --format wheel + +# Dask worker stage +FROM ghcr.io/dask/dask:2022.8.0 AS dask-worker +ARG USERNAME + +# store previous pwd +ENV DASK_WORKER_CWD="$PWD" + +COPY --from=wheel-builder /home/$USERNAME/dist /home/$USERNAME/dist + +RUN apt-get update -qy && \ + apt-get install -qy --no-install-recommends \ + # libpq-dev and build-essential are necessary for psycopg2, which is required for datacube + build-essential \ + libpq-dev + +# Find the prebuilt wheel and install its dependencies +RUN cd /home/$USERNAME/dist && \ + pattern="*.whl" && \ + files=( $pattern ) && \ + export PIP_INSTALL_WHEEL="${files[0]}[dask-worker]" && \ + pip install $PIP_INSTALL_WHEEL + +# We need only the dependencies, so get rid of +RUN pip uninstall openeo-processes -y diff --git a/.devcontainer/devcontainer.json b/.devcontainer/devcontainer.json index db327db8..2b0042dc 100644 --- a/.devcontainer/devcontainer.json +++ b/.devcontainer/devcontainer.json @@ -1,10 +1,11 @@ { "name": "openeo-processes-python", - "dockerFile": "./Dockerfile", + "dockerComposeFile": "./docker-compose.yml", - // Sets the run context to one level up instead of the .devcontainer folder. - "context": "..", + "service": "workspace", + + "workspaceFolder": "/openeo-processes-python", // Set *default* container specific settings.json values on container create. "settings": { @@ -22,8 +23,13 @@ // Add the IDs of extensions you want installed when the container is created. "extensions": [ "ms-python.python", - "ms-python.vscode-pylance" + "ms-python.vscode-pylance", + "eamodio.gitlens" ], - "postCreateCommand": "poetry install" + "postCreateCommand": "poetry install --extras 'load-save vector ml'", + + "remoteEnv": { + "GPG_TTY": "$(tty)`" + } } diff --git a/.devcontainer/docker-compose.yml b/.devcontainer/docker-compose.yml new file mode 100644 index 00000000..b4a198d4 --- /dev/null +++ b/.devcontainer/docker-compose.yml @@ -0,0 +1,33 @@ +version: "3.1" + +services: + workspace: + build: + context: .. + dockerfile: "./.devcontainer/Dockerfile" + target: devcontainer + tty: true + volumes: + - ../:/openeo-processes-python + environment: + - DASK_SCHEDULER_ADDRESS="tcp://scheduler:8786" + + scheduler: + build: + context: .. + dockerfile: "./.devcontainer/Dockerfile" + target: dask-worker + hostname: scheduler + ports: + - "8786:8786" + - "8787:8787" + command: ["dask-scheduler"] + + worker: + build: + context: .. + dockerfile: "./.devcontainer/Dockerfile" + target: dask-worker + command: ["dask-worker", "tcp://scheduler:8786"] + deploy: + replicas: 2 diff --git a/.dockerignore b/.dockerignore new file mode 100644 index 00000000..d0572e26 --- /dev/null +++ b/.dockerignore @@ -0,0 +1,35 @@ +**/.classpath +**/.dockerignore +**/.env +**/.git +**/.gitignore +**/.project +**/.settings +**/.toolstarget +**/.vs +**/.vscode +**/*.*proj.user +**/*.dbmdl +**/*.jfm +**/bin +**/charts +**/docker-compose* +**/compose* +**/Dockerfile* +**/node_modules +**/npm-debug.log +**/obj +**/secrets.dev.yaml +**/values.dev.yaml +README.md +**/.mypy_cache +**/.pytest_cache +**/venv +**/.venv +**/.eggs +**/.github +**/.scripts +**/.idea +**/.nox +**/build +**/tests/data \ No newline at end of file diff --git a/README.md b/README.md index d7cdcbef..33648229 100644 --- a/README.md +++ b/README.md @@ -11,9 +11,11 @@ TODO, will be installable through PyPI by the next release. This project uses [poetry](https://github.com/python-poetry/poetry) to manage dependencies through virtual environments. The poetry CLI can be installed easily following the instructions in the [official documentation](https://python-poetry.org/docs/master/#installing-with-the-official-installer). Note that poetry is already installed and setup on the provided devcontainer. To install this project and its dependencies into a fresh virtual environment run: -- `poetry install` to install all dependencies (core + development) -or -- `poetry install --no-dev` to install only the core dependencies +- `poetry install --extras "load-save vector ml"` to install all dependencies (core + development) +or select +- `poetry install` + +Add the `--no-dev` flag to install without the dev-dependencies. To add a dependency run `poetry add @`. Use the optional `--dev` flag to add it as a development dependency. Note: When adding new dependencies, please do not pin to specific versions unless absolutely necessary (see discussion in #91). Usage of the caret-operator is preferred for specifying versions, this will allow versions to range up to the next major version (`^1.2.3` is equivalent to `>=1.2.3 <2.0.0`, see [poetry documentation on caret requirements](https://python-poetry.org/docs/master/dependency-specification#caret-requirements) for additional examples). diff --git a/notebooks/stackstac_example.ipynb b/notebooks/stackstac_example.ipynb new file mode 100644 index 00000000..4c6ed197 --- /dev/null +++ b/notebooks/stackstac_example.ipynb @@ -0,0 +1,1552 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import dask\n", + "from dask.distributed import Client\n", + "from rasterio.enums import Resampling\n", + "import numpy as np\n", + "import dask.array as da" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/openeo-processes-python/.venv/lib/python3.8/site-packages/distributed/client.py:1274: VersionMismatchWarning: Mismatched versions found\n", + "\n", + "+---------+----------------+----------------+----------------+\n", + "| Package | client | scheduler | workers |\n", + "+---------+----------------+----------------+----------------+\n", + "| python | 3.8.10.final.0 | 3.8.13.final.0 | 3.8.13.final.0 |\n", + "+---------+----------------+----------------+----------------+\n", + " warnings.warn(version_module.VersionMismatchWarning(msg[0][\"warning\"]))\n" + ] + } + ], + "source": [ + "client = Client()" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "
\n", + "
\n", + "

Client

\n", + "

Client-2ab4843c-17dc-11ed-81db-0242ac150003

\n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "
Connection method: Direct
\n", + " Dashboard: http://scheduler:8787/status\n", + "
\n", + "\n", + " \n", + "
\n", + "

Scheduler Info

\n", + "
\n", + "
\n", + "
\n", + "
\n", + "

Scheduler

\n", + "

Scheduler-199e1721-6843-46ee-92ea-79303f3d2e6a

\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
\n", + " Comm: tcp://172.21.0.4:8786\n", + " \n", + " Workers: 2\n", + "
\n", + " Dashboard: http://172.21.0.4:8787/status\n", + " \n", + " Total threads: 24\n", + "
\n", + " Started: 3 minutes ago\n", + " \n", + " Total memory: 14.77 GiB\n", + "
\n", + "
\n", + "
\n", + "\n", + "
\n", + " \n", + "

Workers

\n", + "
\n", + "\n", + " \n", + "
\n", + "
\n", + "
\n", + "
\n", + " \n", + "

Worker: tcp://172.21.0.2:35913

\n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "
\n", + " Comm: tcp://172.21.0.2:35913\n", + " \n", + " Total threads: 12\n", + "
\n", + " Dashboard: http://172.21.0.2:37225/status\n", + " \n", + " Memory: 7.39 GiB\n", + "
\n", + " Nanny: tcp://172.21.0.2:45195\n", + "
\n", + " Local directory: /tmp/dask-worker-space/worker-fl5jkub0\n", + "
\n", + " Tasks executing: 0\n", + " \n", + " Tasks in memory: 0\n", + "
\n", + " Tasks ready: 0\n", + " \n", + " Tasks in flight: 0\n", + "
\n", + " CPU usage: 4.0%\n", + " \n", + " Last seen: Just now\n", + "
\n", + " Memory usage: 120.37 MiB\n", + " \n", + " Spilled bytes: 0 B\n", + "
\n", + " Read bytes: 286.3418922893011 B\n", + " \n", + " Write bytes: 1.07 kiB\n", + "
\n", + "
\n", + "
\n", + "
\n", + " \n", + "
\n", + "
\n", + "
\n", + "
\n", + " \n", + "

Worker: tcp://172.21.0.5:38051

\n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "
\n", + " Comm: tcp://172.21.0.5:38051\n", + " \n", + " Total threads: 12\n", + "
\n", + " Dashboard: http://172.21.0.5:34499/status\n", + " \n", + " Memory: 7.39 GiB\n", + "
\n", + " Nanny: tcp://172.21.0.5:39407\n", + "
\n", + " Local directory: /tmp/dask-worker-space/worker-r8t8ntls\n", + "
\n", + " Tasks executing: 0\n", + " \n", + " Tasks in memory: 0\n", + "
\n", + " Tasks ready: 0\n", + " \n", + " Tasks in flight: 0\n", + "
\n", + " CPU usage: 2.0%\n", + " \n", + " Last seen: Just now\n", + "
\n", + " Memory usage: 102.53 MiB\n", + " \n", + " Spilled bytes: 0 B\n", + "
\n", + " Read bytes: 286.25060468206226 B\n", + " \n", + " Write bytes: 1.07 kiB\n", + "
\n", + "
\n", + "
\n", + "
\n", + " \n", + "\n", + "
\n", + "
\n", + "
\n", + " \n", + "\n", + "
\n", + "
" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "client" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Stackstac example" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "From here: https://stackstac.readthedocs.io/en/latest/examples/cluster.html" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "import stackstac\n", + "import pystac_client" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "100" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "items = pystac_client.Client.open(\n", + " \"https://earth-search.aws.element84.com/v0\"\n", + ").search(\n", + " intersects=dict(type=\"Point\", coordinates=[-106, 35.7]),\n", + " collections=[\"sentinel-s2-l2a-cogs\"],\n", + " datetime=\"2019-01-01/2019-06-01\",\n", + " limit=10_000,\n", + ").get_all_items()\n", + "len(items)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "stack = stackstac.stack(\n", + " items,\n", + " resolution=100,\n", + " bounds_latlon=(-106.2, 35.9, -106.1, 36),\n", + " resampling=Resampling.bilinear\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.DataArray 'stackstac-04d9d191754d0029dd48e2e31a84cd24' (time: 6,\n",
+       "                                                                band: 3,\n",
+       "                                                                y: 113, x: 92)>\n",
+       "dask.array<stack, shape=(6, 3, 113, 92), dtype=float64, chunksize=(1, 3, 113, 92), chunktype=numpy.ndarray>\n",
+       "Coordinates: (12/16)\n",
+       "  * time                    (time) datetime64[ns] 2019-01-01 ... 2019-06-01\n",
+       "  * band                    (band) <U8 'B04' 'B03' 'B02'\n",
+       "  * x                       (x) float64 3.917e+05 3.918e+05 ... 4.008e+05\n",
+       "  * y                       (y) float64 3.985e+06 3.985e+06 ... 3.974e+06\n",
+       "    sentinel:utm_zone       int64 13\n",
+       "    gsd                     (band) object 10 10 10\n",
+       "    ...                      ...\n",
+       "    constellation           <U10 'sentinel-2'\n",
+       "    title                   (band) <U31 'Band 4 (red)' ... 'Band 2 (blue)'\n",
+       "    common_name             (band) object 'red' 'green' 'blue'\n",
+       "    center_wavelength       (band) object 0.6645 0.56 0.4966\n",
+       "    full_width_half_max     (band) object 0.038 0.045 0.098\n",
+       "    epsg                    int64 32613
" + ], + "text/plain": [ + "\n", + "dask.array\n", + "Coordinates: (12/16)\n", + " * time (time) datetime64[ns] 2019-01-01 ... 2019-06-01\n", + " * band (band) \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.DataArray 'stackstac-04d9d191754d0029dd48e2e31a84cd24' (time: 6,\n",
+       "                                                                band: 3,\n",
+       "                                                                y: 113, x: 92)>\n",
+       "array([[[[6994. , 6272. , 5900. , ...,  916.5,  944. ,  971. ],\n",
+       "         [6660. , 5785. , 5026. , ...,  881.5,  933. ,  970.5],\n",
+       "         [5470. , 4803. , 4201. , ...,  986. , 1001. , 1011. ],\n",
+       "         ...,\n",
+       "         [3139. , 2768. , 2542. , ..., 4499. , 4476.5, 4478. ],\n",
+       "         [2932. , 2667. , 2618. , ..., 4518.5, 4619. , 4607.5],\n",
+       "         [2579. , 2528. , 2752. , ..., 4707.5, 4792. , 4811. ]],\n",
+       "\n",
+       "        [[7085. , 6357. , 6066. , ...,  681. ,  682.5,  712. ],\n",
+       "         [6709. , 5854. , 5168. , ...,  633. ,  672. ,  705. ],\n",
+       "         [5518. , 4871. , 4282. , ...,  693. ,  692.5,  707. ],\n",
+       "         ...,\n",
+       "         [3010. , 2630. , 2471. , ..., 4496. , 4476. , 4478.5],\n",
+       "         [2851. , 2573. , 2505. , ..., 4517.5, 4638. , 4684. ],\n",
+       "         [2482. , 2439. , 2651. , ..., 4783.5, 4845.5, 4869.5]],\n",
+       "\n",
+       "        [[6923. , 6249. , 6015. , ...,  368. ,  350.5,  373.5],\n",
+       "         [6490. , 5715. , 5133. , ...,  311. ,  337.5,  362.5],\n",
+       "         [5340. , 4767. , 4198. , ...,  332. ,  328. ,  349. ],\n",
+       "         ...,\n",
+       "...\n",
+       "         ...,\n",
+       "         [1342. , 1218. , 1176. , ..., 2258. , 2296.5, 2125. ],\n",
+       "         [1760. , 1554. , 1241. , ..., 2520. , 2178. , 2036. ],\n",
+       "         [1617. , 1769. , 1467. , ..., 2553. , 2082. , 2183.5]],\n",
+       "\n",
+       "        [[ 950. ,  557. ,  327. , ..., 1411. , 1443. , 1491.5],\n",
+       "         [ 869. ,  489. ,  407. , ..., 1362. , 1370. , 1418. ],\n",
+       "         [1101. ,  595. ,  398. , ..., 1623. , 1555. , 1481.5],\n",
+       "         ...,\n",
+       "         [1132. , 1061. , 1039. , ..., 1766.5, 1809. , 1690.5],\n",
+       "         [1353. , 1257. , 1078. , ..., 1973. , 1727. , 1608. ],\n",
+       "         [1252. , 1356. , 1175. , ..., 1959.5, 1641.5, 1700. ]],\n",
+       "\n",
+       "        [[ 689. ,  407. ,  245. , ..., 1072. , 1089.5, 1145. ],\n",
+       "         [ 659. ,  373. ,  304. , ..., 1010. , 1023. , 1058. ],\n",
+       "         [ 814. ,  456. ,  299. , ..., 1182.5, 1120.5, 1082. ],\n",
+       "         ...,\n",
+       "         [ 863. ,  819. ,  794. , ..., 1320.5, 1365. , 1267.5],\n",
+       "         [ 965. ,  937. ,  829. , ..., 1506. , 1301.5, 1201. ],\n",
+       "         [ 907. ,  972. ,  871. , ..., 1478.5, 1223.5, 1258.5]]]])\n",
+       "Coordinates: (12/16)\n",
+       "  * time                    (time) datetime64[ns] 2019-01-01 ... 2019-06-01\n",
+       "  * band                    (band) <U8 'B04' 'B03' 'B02'\n",
+       "  * x                       (x) float64 3.917e+05 3.918e+05 ... 4.008e+05\n",
+       "  * y                       (y) float64 3.985e+06 3.985e+06 ... 3.974e+06\n",
+       "    sentinel:utm_zone       int64 13\n",
+       "    gsd                     (band) object 10 10 10\n",
+       "    ...                      ...\n",
+       "    constellation           <U10 'sentinel-2'\n",
+       "    title                   (band) <U31 'Band 4 (red)' ... 'Band 2 (blue)'\n",
+       "    common_name             (band) object 'red' 'green' 'blue'\n",
+       "    center_wavelength       (band) object 0.6645 0.56 0.4966\n",
+       "    full_width_half_max     (band) object 0.038 0.045 0.098\n",
+       "    epsg                    int64 32613
" + ], + "text/plain": [ + "\n", + "array([[[[6994. , 6272. , 5900. , ..., 916.5, 944. , 971. ],\n", + " [6660. , 5785. , 5026. , ..., 881.5, 933. , 970.5],\n", + " [5470. , 4803. , 4201. , ..., 986. , 1001. , 1011. ],\n", + " ...,\n", + " [3139. , 2768. , 2542. , ..., 4499. , 4476.5, 4478. ],\n", + " [2932. , 2667. , 2618. , ..., 4518.5, 4619. , 4607.5],\n", + " [2579. , 2528. , 2752. , ..., 4707.5, 4792. , 4811. ]],\n", + "\n", + " [[7085. , 6357. , 6066. , ..., 681. , 682.5, 712. ],\n", + " [6709. , 5854. , 5168. , ..., 633. , 672. , 705. ],\n", + " [5518. , 4871. , 4282. , ..., 693. , 692.5, 707. ],\n", + " ...,\n", + " [3010. , 2630. , 2471. , ..., 4496. , 4476. , 4478.5],\n", + " [2851. , 2573. , 2505. , ..., 4517.5, 4638. , 4684. ],\n", + " [2482. , 2439. , 2651. , ..., 4783.5, 4845.5, 4869.5]],\n", + "\n", + " [[6923. , 6249. , 6015. , ..., 368. , 350.5, 373.5],\n", + " [6490. , 5715. , 5133. , ..., 311. , 337.5, 362.5],\n", + " [5340. , 4767. , 4198. , ..., 332. , 328. , 349. ],\n", + " ...,\n", + "...\n", + " ...,\n", + " [1342. , 1218. , 1176. , ..., 2258. , 2296.5, 2125. ],\n", + " [1760. , 1554. , 1241. , ..., 2520. , 2178. , 2036. ],\n", + " [1617. , 1769. , 1467. , ..., 2553. , 2082. , 2183.5]],\n", + "\n", + " [[ 950. , 557. , 327. , ..., 1411. , 1443. , 1491.5],\n", + " [ 869. , 489. , 407. , ..., 1362. , 1370. , 1418. ],\n", + " [1101. , 595. , 398. , ..., 1623. , 1555. , 1481.5],\n", + " ...,\n", + " [1132. , 1061. , 1039. , ..., 1766.5, 1809. , 1690.5],\n", + " [1353. , 1257. , 1078. , ..., 1973. , 1727. , 1608. ],\n", + " [1252. , 1356. , 1175. , ..., 1959.5, 1641.5, 1700. ]],\n", + "\n", + " [[ 689. , 407. , 245. , ..., 1072. , 1089.5, 1145. ],\n", + " [ 659. , 373. , 304. , ..., 1010. , 1023. , 1058. ],\n", + " [ 814. , 456. , 299. , ..., 1182.5, 1120.5, 1082. ],\n", + " ...,\n", + " [ 863. , 819. , 794. , ..., 1320.5, 1365. , 1267.5],\n", + " [ 965. , 937. , 829. , ..., 1506. , 1301.5, 1201. ],\n", + " [ 907. , 972. , 871. , ..., 1478.5, 1223.5, 1258.5]]]])\n", + "Coordinates: (12/16)\n", + " * time (time) datetime64[ns] 2019-01-01 ... 2019-06-01\n", + " * band (band) " + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "rgb_.plot.imshow(row=\"time\", rgb=\"band\", robust=True, size=6)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.8.10 ('.venv': poetry)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.10" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "a4cbf7c8461ff0263a00f25875c21633ed63d885506bcdd19ca25102e899e656" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/noxfile.py b/noxfile.py index 5e158368..2b835106 100644 --- a/noxfile.py +++ b/noxfile.py @@ -4,7 +4,7 @@ @session(python=python_versions) def tests(session): - session.install("pytest", ".") + session.install("pytest", ".[load-save,vector,ml]") session.run("pytest") @session(python=python_versions) diff --git a/poetry.lock b/poetry.lock index ee851080..8413f142 100644 --- a/poetry.lock +++ b/poetry.lock @@ -9,9 +9,118 @@ python-versions = "*" [package.extras] test = ["pytest (>=4.6)", "pytest-cov", "pydocstyle", "flake8", "coveralls"] +[[package]] +name = "aiohttp" +version = "3.8.1" +description = "Async http client/server framework (asyncio)" +category = "main" +optional = true +python-versions = ">=3.6" + +[package.dependencies] +aiosignal = ">=1.1.2" +async-timeout = ">=4.0.0a3,<5.0" +attrs = ">=17.3.0" +charset-normalizer = ">=2.0,<3.0" +frozenlist = ">=1.1.1" +multidict = ">=4.5,<7.0" +yarl = ">=1.0,<2.0" + +[package.extras] +speedups = ["aiodns", "brotli", "cchardet"] + +[[package]] +name = "aiosignal" +version = "1.2.0" +description = "aiosignal: a list of registered asynchronous callbacks" +category = "main" +optional = true +python-versions = ">=3.6" + +[package.dependencies] +frozenlist = ">=1.1.0" + +[[package]] +name = "anyio" +version = "3.6.1" +description = "High level compatibility layer for multiple asynchronous event loop implementations" +category = "main" +optional = true +python-versions = ">=3.6.2" + +[package.dependencies] +idna = ">=2.8" +sniffio = ">=1.1" + +[package.extras] +doc = ["packaging", "sphinx-rtd-theme", "sphinx-autodoc-typehints (>=1.2.0)"] +test = ["coverage[toml] (>=4.5)", "hypothesis (>=4.0)", "pytest (>=7.0)", "pytest-mock (>=3.6.1)", "trustme", "contextlib2", "uvloop (<0.15)", "mock (>=4)", "uvloop (>=0.15)"] +trio = ["trio (>=0.16)"] + +[[package]] +name = "appnope" +version = "0.1.3" +description = "Disable App Nap on macOS >= 10.9" +category = "main" +optional = false +python-versions = "*" + +[[package]] +name = "argon2-cffi" +version = "21.3.0" +description = "The secure Argon2 password hashing algorithm." +category = "main" +optional = true +python-versions = ">=3.6" + +[package.dependencies] +argon2-cffi-bindings = "*" + +[package.extras] +dev = ["pre-commit", "cogapp", "tomli", "coverage[toml] (>=5.0.2)", "hypothesis", "pytest", "sphinx", "sphinx-notfound-page", "furo"] +docs = ["sphinx", "sphinx-notfound-page", "furo"] +tests = ["coverage[toml] (>=5.0.2)", "hypothesis", "pytest"] + +[[package]] +name = "argon2-cffi-bindings" +version = "21.2.0" +description = "Low-level CFFI bindings for Argon2" +category = "main" +optional = true +python-versions = ">=3.6" + +[package.dependencies] +cffi = ">=1.0.1" + +[package.extras] +dev = ["pytest", "cogapp", "pre-commit", "wheel"] +tests = ["pytest"] + +[[package]] +name = "asttokens" +version = "2.0.7" +description = "Annotate AST trees with source code positions" +category = "main" +optional = false +python-versions = "*" + +[package.dependencies] +six = "*" + +[package.extras] +test = ["astroid (<=2.5.3)", "pytest"] + +[[package]] +name = "async-timeout" +version = "4.0.2" +description = "Timeout context manager for asyncio programs" +category = "main" +optional = true +python-versions = ">=3.6" + [[package]] name = "atomicwrites" -version = "1.4.0" +version = "1.4.1" description = "Atomic file writes." category = "dev" optional = false @@ -19,25 +128,75 @@ python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*" [[package]] name = "attrs" -version = "21.4.0" +version = "22.1.0" description = "Classes Without Boilerplate" category = "main" optional = false -python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*" +python-versions = ">=3.5" [package.extras] -dev = ["coverage[toml] (>=5.0.2)", "hypothesis", "pympler", "pytest (>=4.3.0)", "six", "mypy", "pytest-mypy-plugins", "zope.interface", "furo", "sphinx", "sphinx-notfound-page", "pre-commit", "cloudpickle"] +dev = ["coverage[toml] (>=5.0.2)", "hypothesis", "pympler", "pytest (>=4.3.0)", "mypy (>=0.900,!=0.940)", "pytest-mypy-plugins", "zope.interface", "furo", "sphinx", "sphinx-notfound-page", "pre-commit", "cloudpickle"] docs = ["furo", "sphinx", "zope.interface", "sphinx-notfound-page"] -tests = ["coverage[toml] (>=5.0.2)", "hypothesis", "pympler", "pytest (>=4.3.0)", "six", "mypy", "pytest-mypy-plugins", "zope.interface", "cloudpickle"] -tests_no_zope = ["coverage[toml] (>=5.0.2)", "hypothesis", "pympler", "pytest (>=4.3.0)", "six", "mypy", "pytest-mypy-plugins", "cloudpickle"] +tests = ["coverage[toml] (>=5.0.2)", "hypothesis", "pympler", "pytest (>=4.3.0)", "mypy (>=0.900,!=0.940)", "pytest-mypy-plugins", "zope.interface", "cloudpickle"] +tests_no_zope = ["coverage[toml] (>=5.0.2)", "hypothesis", "pympler", "pytest (>=4.3.0)", "mypy (>=0.900,!=0.940)", "pytest-mypy-plugins", "cloudpickle"] + +[[package]] +name = "backcall" +version = "0.2.0" +description = "Specifications for callback functions passed in to an API" +category = "main" +optional = false +python-versions = "*" + +[[package]] +name = "beautifulsoup4" +version = "4.11.1" +description = "Screen-scraping library" +category = "main" +optional = true +python-versions = ">=3.6.0" + +[package.dependencies] +soupsieve = ">1.2" + +[package.extras] +html5lib = ["html5lib"] +lxml = ["lxml"] + +[[package]] +name = "bleach" +version = "5.0.1" +description = "An easy safelist-based HTML-sanitizing tool." +category = "main" +optional = true +python-versions = ">=3.7" + +[package.dependencies] +six = ">=1.9.0" +webencodings = "*" + +[package.extras] +css = ["tinycss2 (>=1.1.0,<1.2)"] +dev = ["build (==0.8.0)", "flake8 (==4.0.1)", "hashin (==0.17.0)", "pip-tools (==6.6.2)", "pytest (==7.1.2)", "Sphinx (==4.3.2)", "tox (==3.25.0)", "twine (==4.0.1)", "wheel (==0.37.1)", "black (==22.3.0)", "mypy (==0.961)"] + +[[package]] +name = "branca" +version = "0.4.2" +description = "Generate complex HTML+JS pages with Python" +category = "main" +optional = true +python-versions = ">=3.5" + +[package.dependencies] +jinja2 = "*" [[package]] name = "cachetools" -version = "5.2.0" +version = "4.2.4" description = "Extensible memoizing collections and decorators" category = "main" optional = false -python-versions = "~=3.7" +python-versions = "~=3.5" [[package]] name = "certifi" @@ -47,17 +206,39 @@ category = "main" optional = false python-versions = ">=3.6" +[[package]] +name = "cffi" +version = "1.15.1" +description = "Foreign Function Interface for Python calling C code." +category = "main" +optional = false +python-versions = "*" + +[package.dependencies] +pycparser = "*" + [[package]] name = "cftime" -version = "1.6.0" +version = "1.6.1" description = "Time-handling functionality from netcdf4-python" category = "main" optional = false -python-versions = "*" +python-versions = ">=3.7" [package.dependencies] numpy = ">1.13.3" +[[package]] +name = "charset-normalizer" +version = "2.1.0" +description = "The Real First Universal Charset Detector. Open, modern and actively maintained alternative to Chardet." +category = "main" +optional = false +python-versions = ">=3.6.0" + +[package.extras] +unicode_backport = ["unicodedata2"] + [[package]] name = "click" version = "8.1.3" @@ -81,7 +262,7 @@ python-versions = "*" click = ">=4.0" [package.extras] -dev = ["pytest (>=3.6)", "pytest-cov", "wheel", "coveralls"] +dev = ["coveralls", "wheel", "pytest-cov", "pytest (>=3.6)"] [[package]] name = "cligj" @@ -113,9 +294,17 @@ category = "main" optional = false python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*" +[[package]] +name = "cycler" +version = "0.11.0" +description = "Composable style cycles" +category = "main" +optional = true +python-versions = ">=3.6" + [[package]] name = "dask" -version = "2022.6.0" +version = "2022.8.0" description = "Parallel PyData with Task Scheduling" category = "main" optional = false @@ -132,18 +321,18 @@ toolz = ">=0.8.2" [package.extras] array = ["numpy (>=1.18)"] -complete = ["bokeh (>=2.4.2)", "distributed (==2022.6.0)", "jinja2", "numpy (>=1.18)", "pandas (>=1.0)"] +complete = ["bokeh (>=2.4.2)", "distributed (==2022.8.0)", "jinja2", "numpy (>=1.18)", "pandas (>=1.0)"] dataframe = ["numpy (>=1.18)", "pandas (>=1.0)"] diagnostics = ["bokeh (>=2.4.2)", "jinja2"] -distributed = ["distributed (==2022.6.0)"] -test = ["pytest", "pytest-rerunfailures", "pytest-xdist", "pre-commit"] +distributed = ["distributed (==2022.8.0)"] +test = ["pandas", "pytest", "pytest-rerunfailures", "pytest-xdist", "pre-commit"] [[package]] name = "dask-geopandas" version = "0.1.3" description = "Parallel GeoPandas with Dask" category = "main" -optional = false +optional = true python-versions = ">=3.7" [package.dependencies] @@ -208,9 +397,33 @@ performance = ["bottleneck", "ciso8601"] s3 = ["boto3", "botocore"] test = ["hypothesis", "moto", "pycodestyle", "pylint", "pytest", "pytest-cov", "pytest-httpserver", "pytest-timeout"] +[[package]] +name = "debugpy" +version = "1.6.2" +description = "An implementation of the Debug Adapter Protocol for Python" +category = "main" +optional = false +python-versions = ">=3.7" + +[[package]] +name = "decorator" +version = "5.1.1" +description = "Decorators for Humans" +category = "main" +optional = false +python-versions = ">=3.5" + +[[package]] +name = "defusedxml" +version = "0.7.1" +description = "XML bomb protection for Python stdlib modules" +category = "main" +optional = true +python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*" + [[package]] name = "distributed" -version = "2022.6.0" +version = "2022.8.0" description = "Distributed scheduler for Dask" category = "main" optional = false @@ -219,7 +432,7 @@ python-versions = ">=3.8" [package.dependencies] click = ">=6.6" cloudpickle = ">=1.5.0" -dask = "2022.6.0" +dask = "2022.8.0" jinja2 = "*" locket = ">=1.0.0" msgpack = ">=0.6.0" @@ -229,31 +442,43 @@ pyyaml = "*" sortedcontainers = "<2.0.0 || >2.0.0,<2.0.1 || >2.0.1" tblib = ">=1.6.0" toolz = ">=0.8.2" -tornado = ">=6.0.3" +tornado = ">=6.0.3,<6.2" urllib3 = "*" zict = ">=0.1.3" [[package]] -name = "equi7grid" -version = "0.1.0" -description = "Definition and tools for Equi7Grid and its tiling system." +name = "entrypoints" +version = "0.4" +description = "Discover and load entry points from installed packages." +category = "main" +optional = false +python-versions = ">=3.6" + +[[package]] +name = "executing" +version = "0.9.1" +description = "Get the currently executing AST node of a frame, and other information" category = "main" optional = false python-versions = "*" -[package.dependencies] -geographiclib = "*" -pytileproj = ">=0.0.16" +[[package]] +name = "fastjsonschema" +version = "2.16.1" +description = "Fastest Python implementation of JSON schema" +category = "main" +optional = true +python-versions = "*" [package.extras] -test = ["pytest-cov", "pytest", "nose"] +devel = ["colorama", "jsonschema", "json-spec", "pylint", "pytest", "pytest-benchmark", "pytest-cache", "validictory"] [[package]] name = "fiona" version = "1.8.21" description = "Fiona reads and writes spatial data files" category = "main" -optional = false +optional = true python-versions = "*" [package.dependencies] @@ -271,9 +496,39 @@ calc = ["shapely"] s3 = ["boto3 (>=1.2.4)"] test = ["pytest (>=3)", "pytest-cov", "boto3 (>=1.2.4)", "mock"] +[[package]] +name = "fonttools" +version = "4.34.4" +description = "Tools to manipulate font files" +category = "main" +optional = true +python-versions = ">=3.7" + +[package.extras] +all = ["fs (>=2.2.0,<3)", "lxml (>=4.0,<5)", "zopfli (>=0.1.4)", "lz4 (>=1.7.4.2)", "matplotlib", "sympy", "skia-pathops (>=0.5.0)", "uharfbuzz (>=0.23.0)", "brotlicffi (>=0.8.0)", "scipy", "brotli (>=1.0.1)", "munkres", "unicodedata2 (>=14.0.0)", "xattr"] +graphite = ["lz4 (>=1.7.4.2)"] +interpolatable = ["scipy", "munkres"] +lxml = ["lxml (>=4.0,<5)"] +pathops = ["skia-pathops (>=0.5.0)"] +plot = ["matplotlib"] +repacker = ["uharfbuzz (>=0.23.0)"] +symfont = ["sympy"] +type1 = ["xattr"] +ufo = ["fs (>=2.2.0,<3)"] +unicode = ["unicodedata2 (>=14.0.0)"] +woff = ["zopfli (>=0.1.4)", "brotlicffi (>=0.8.0)", "brotli (>=1.0.1)"] + +[[package]] +name = "frozenlist" +version = "1.3.1" +description = "A list-like structure which implements collections.abc.MutableSequence" +category = "main" +optional = true +python-versions = ">=3.7" + [[package]] name = "fsspec" -version = "2022.5.0" +version = "2022.7.1" description = "File-system specification" category = "main" optional = false @@ -304,29 +559,21 @@ tqdm = ["tqdm"] [[package]] name = "gdal" -version = "3.5.0.3" +version = "3.5.1" description = "GDAL: Geospatial Data Abstraction Library" category = "main" -optional = false +optional = true python-versions = ">=3.6.0" [package.extras] numpy = ["numpy (>1.0.0)"] -[[package]] -name = "geographiclib" -version = "2.0" -description = "The geodesic routines from GeographicLib" -category = "main" -optional = false -python-versions = ">=3.7" - [[package]] name = "geopandas" version = "0.10.2" description = "Geographic pandas extensions" category = "main" -optional = false +optional = true python-versions = ">=3.7" [package.dependencies] @@ -335,6 +582,19 @@ pandas = ">=0.25.0" pyproj = ">=2.2.0" shapely = ">=1.6" +[[package]] +name = "graphviz" +version = "0.20.1" +description = "Simple Python interface for Graphviz" +category = "dev" +optional = false +python-versions = ">=3.7" + +[package.extras] +dev = ["tox (>=3)", "flake8", "pep8-naming", "wheel", "twine"] +docs = ["sphinx (>=5)", "sphinx-autodoc-typehints", "sphinx-rtd-theme"] +test = ["pytest (>=7)", "pytest-mock (>=3)", "mock (>=4)", "pytest-cov", "coverage"] + [[package]] name = "greenlet" version = "1.1.2" @@ -354,9 +614,17 @@ category = "main" optional = false python-versions = "*" +[[package]] +name = "idna" +version = "3.3" +description = "Internationalized Domain Names in Applications (IDNA)" +category = "main" +optional = false +python-versions = ">=3.5" + [[package]] name = "imageio" -version = "2.19.3" +version = "2.21.1" description = "Library for reading and writing a wide range of image, video, scientific, and volumetric data formats." category = "main" optional = false @@ -385,7 +653,7 @@ tifffile = ["tifffile"] [[package]] name = "importlib-resources" -version = "5.8.0" +version = "5.9.0" description = "Read resources from Python packages" category = "main" optional = false @@ -395,8 +663,8 @@ python-versions = ">=3.7" zipp = {version = ">=3.1.0", markers = "python_version < \"3.10\""} [package.extras] -docs = ["sphinx", "jaraco.packaging (>=9)", "rst.linker (>=1.9)"] -testing = ["pytest (>=6)", "pytest-checkdocs (>=2.4)", "pytest-flake8", "pytest-cov", "pytest-enabler (>=1.0.1)", "pytest-black (>=0.3.7)", "pytest-mypy (>=0.9.1)"] +docs = ["sphinx", "jaraco.packaging (>=9)", "rst.linker (>=1.9)", "jaraco.tidelift (>=1.4)"] +testing = ["pytest (>=6)", "pytest-checkdocs (>=2.4)", "pytest-flake8", "pytest-cov", "pytest-enabler (>=1.3)", "pytest-black (>=0.3.7)", "pytest-mypy (>=0.9.1)"] [[package]] name = "iniconfig" @@ -406,6 +674,121 @@ category = "dev" optional = false python-versions = "*" +[[package]] +name = "ipykernel" +version = "6.15.1" +description = "IPython Kernel for Jupyter" +category = "main" +optional = false +python-versions = ">=3.7" + +[package.dependencies] +appnope = {version = "*", markers = "platform_system == \"Darwin\""} +debugpy = ">=1.0" +ipython = ">=7.23.1" +jupyter-client = ">=6.1.12" +matplotlib-inline = ">=0.1" +nest-asyncio = "*" +packaging = "*" +psutil = "*" +pyzmq = ">=17" +tornado = ">=6.1" +traitlets = ">=5.1.0" + +[package.extras] +test = ["flaky", "ipyparallel", "pre-commit", "pytest-cov", "pytest-timeout", "pytest (>=6.0)"] + +[[package]] +name = "ipyleaflet" +version = "0.13.6" +description = "A Jupyter widget for dynamic Leaflet maps" +category = "main" +optional = true +python-versions = "*" + +[package.dependencies] +branca = ">=0.3.1,<0.5" +ipywidgets = ">=7.6.0,<8" +shapely = "*" +traittypes = ">=0.2.1,<3" + +[[package]] +name = "ipython" +version = "8.4.0" +description = "IPython: Productive Interactive Computing" +category = "main" +optional = false +python-versions = ">=3.8" + +[package.dependencies] +appnope = {version = "*", markers = "sys_platform == \"darwin\""} +backcall = "*" +colorama = {version = "*", markers = "sys_platform == \"win32\""} +decorator = "*" +jedi = ">=0.16" +matplotlib-inline = "*" +pexpect = {version = ">4.3", markers = "sys_platform != \"win32\""} +pickleshare = "*" +prompt-toolkit = ">=2.0.0,<3.0.0 || >3.0.0,<3.0.1 || >3.0.1,<3.1.0" +pygments = ">=2.4.0" +stack-data = "*" +traitlets = ">=5" + +[package.extras] +all = ["black", "Sphinx (>=1.3)", "ipykernel", "nbconvert", "nbformat", "ipywidgets", "notebook", "ipyparallel", "qtconsole", "pytest (<7.1)", "pytest-asyncio", "testpath", "curio", "matplotlib (!=3.2.0)", "numpy (>=1.19)", "pandas", "trio"] +black = ["black"] +doc = ["Sphinx (>=1.3)"] +kernel = ["ipykernel"] +nbconvert = ["nbconvert"] +nbformat = ["nbformat"] +notebook = ["ipywidgets", "notebook"] +parallel = ["ipyparallel"] +qtconsole = ["qtconsole"] +test = ["pytest (<7.1)", "pytest-asyncio", "testpath"] +test_extra = ["pytest (<7.1)", "pytest-asyncio", "testpath", "curio", "matplotlib (!=3.2.0)", "nbformat", "numpy (>=1.19)", "pandas", "trio"] + +[[package]] +name = "ipython-genutils" +version = "0.2.0" +description = "Vestigial utilities from IPython" +category = "main" +optional = true +python-versions = "*" + +[[package]] +name = "ipywidgets" +version = "7.7.1" +description = "IPython HTML widgets for Jupyter" +category = "main" +optional = true +python-versions = "*" + +[package.dependencies] +ipykernel = ">=4.5.1" +ipython = {version = ">=4.0.0", markers = "python_version >= \"3.3\""} +ipython-genutils = ">=0.2.0,<0.3.0" +jupyterlab-widgets = {version = ">=1.0.0", markers = "python_version >= \"3.6\""} +traitlets = ">=4.3.1" +widgetsnbextension = ">=3.6.0,<3.7.0" + +[package.extras] +test = ["pytest (>=3.6.0)", "pytest-cov", "mock"] + +[[package]] +name = "jedi" +version = "0.18.1" +description = "An autocompletion tool for Python that can be used for text editors." +category = "main" +optional = false +python-versions = ">=3.6" + +[package.dependencies] +parso = ">=0.8.0,<0.9.0" + +[package.extras] +qa = ["flake8 (==3.8.3)", "mypy (==0.782)"] +testing = ["Django (<3.1)", "colorama", "docopt", "pytest (<7.0.0)"] + [[package]] name = "jinja2" version = "3.1.2" @@ -422,7 +805,7 @@ i18n = ["Babel (>=2.7)"] [[package]] name = "jsonschema" -version = "4.6.0" +version = "4.9.1" description = "An implementation of JSON Schema validation for Python" category = "main" optional = false @@ -431,6 +814,7 @@ python-versions = ">=3.7" [package.dependencies] attrs = ">=17.4.0" importlib-resources = {version = ">=1.4.0", markers = "python_version < \"3.9\""} +pkgutil-resolve-name = {version = ">=1.3.10", markers = "python_version < \"3.9\""} pyrsistent = ">=0.14.0,<0.17.0 || >0.17.0,<0.17.1 || >0.17.1,<0.17.2 || >0.17.2" [package.extras] @@ -438,56 +822,236 @@ format = ["fqdn", "idna", "isoduration", "jsonpointer (>1.13)", "rfc3339-validat format-nongpl = ["fqdn", "idna", "isoduration", "jsonpointer (>1.13)", "rfc3339-validator", "rfc3986-validator (>0.1.0)", "uri-template", "webcolors (>=1.11)"] [[package]] -name = "lark-parser" -version = "0.12.0" -description = "a modern parsing library" +name = "jupyter-client" +version = "7.3.4" +description = "Jupyter protocol implementation and client libraries" category = "main" optional = false -python-versions = "*" +python-versions = ">=3.7" + +[package.dependencies] +entrypoints = "*" +jupyter-core = ">=4.9.2" +nest-asyncio = ">=1.5.4" +python-dateutil = ">=2.8.2" +pyzmq = ">=23.0" +tornado = ">=6.0" +traitlets = "*" [package.extras] -atomic_cache = ["atomicwrites"] -nearley = ["js2py"] -regex = ["regex"] +doc = ["ipykernel", "myst-parser", "sphinx-rtd-theme", "sphinx (>=1.3.6)", "sphinxcontrib-github-alt"] +test = ["codecov", "coverage", "ipykernel (>=6.5)", "ipython", "mypy", "pre-commit", "pytest", "pytest-asyncio (>=0.18)", "pytest-cov", "pytest-timeout"] [[package]] -name = "locket" -version = "1.0.0" -description = "File-based locks for Python on Linux and Windows" +name = "jupyter-core" +version = "4.11.1" +description = "Jupyter core package. A base package on which Jupyter projects rely." category = "main" optional = false -python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*" +python-versions = ">=3.7" + +[package.dependencies] +pywin32 = {version = ">=1.0", markers = "sys_platform == \"win32\" and platform_python_implementation != \"PyPy\""} +traitlets = "*" + +[package.extras] +test = ["ipykernel", "pre-commit", "pytest", "pytest-cov", "pytest-timeout"] [[package]] -name = "markupsafe" -version = "2.1.1" -description = "Safely add untrusted strings to HTML/XML markup." +name = "jupyter-server" +version = "1.18.1" +description = "The backend—i.e. core services, APIs, and REST endpoints—to Jupyter web applications." category = "main" -optional = false +optional = true python-versions = ">=3.7" -[[package]] -name = "msgpack" -version = "1.0.4" -description = "MessagePack serializer" -category = "main" -optional = false -python-versions = "*" +[package.dependencies] +anyio = ">=3.1.0,<4" +argon2-cffi = "*" +jinja2 = "*" +jupyter-client = ">=6.1.12" +jupyter-core = ">=4.7.0" +nbconvert = ">=6.4.4" +nbformat = ">=5.2.0" +packaging = "*" +prometheus-client = "*" +pywinpty = {version = "*", markers = "os_name == \"nt\""} +pyzmq = ">=17" +Send2Trash = "*" +terminado = ">=0.8.3" +tornado = ">=6.1.0" +traitlets = ">=5.1" +websocket-client = "*" + +[package.extras] +test = ["coverage", "ipykernel", "pre-commit", "pytest-console-scripts", "pytest-cov", "pytest-mock", "pytest-timeout", "pytest-tornasync", "pytest (>=6.0)", "requests"] [[package]] -name = "munch" -version = "2.5.0" -description = "A dot-accessible dictionary (a la JavaScript objects)" +name = "jupyter-server-proxy" +version = "3.2.1" +description = "Jupyter server extension to supervise and proxy web services" category = "main" -optional = false -python-versions = "*" +optional = true +python-versions = ">=3.6" [package.dependencies] -six = "*" +aiohttp = "*" +jupyter-server = ">=1.0" +simpervisor = ">=0.4" [package.extras] -testing = ["pytest", "coverage", "astroid (>=1.5.3,<1.6.0)", "pylint (>=1.7.2,<1.8.0)", "astroid (>=2.0)", "pylint (>=2.3.1,<2.4.0)"] -yaml = ["PyYAML (>=5.1.0)"] +acceptance = ["robotframework-jupyterlibrary"] +test = ["pytest", "pytest-cov", "pytest-html"] + +[[package]] +name = "jupyterlab-pygments" +version = "0.2.2" +description = "Pygments theme using JupyterLab CSS variables" +category = "main" +optional = true +python-versions = ">=3.7" + +[[package]] +name = "jupyterlab-widgets" +version = "1.1.1" +description = "A JupyterLab extension." +category = "main" +optional = true +python-versions = ">=3.6" + +[[package]] +name = "kiwisolver" +version = "1.4.4" +description = "A fast implementation of the Cassowary constraint solver" +category = "main" +optional = true +python-versions = ">=3.7" + +[[package]] +name = "lark-parser" +version = "0.12.0" +description = "a modern parsing library" +category = "main" +optional = false +python-versions = "*" + +[package.extras] +atomic_cache = ["atomicwrites"] +nearley = ["js2py"] +regex = ["regex"] + +[[package]] +name = "locket" +version = "1.0.0" +description = "File-based locks for Python on Linux and Windows" +category = "main" +optional = false +python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*" + +[[package]] +name = "lz4" +version = "4.0.2" +description = "LZ4 Bindings for Python" +category = "main" +optional = false +python-versions = ">=3.7" + +[package.extras] +docs = ["sphinx (>=1.6.0)", "sphinx-bootstrap-theme"] +flake8 = ["flake8"] +tests = ["pytest (!=3.3.0)", "psutil", "pytest-cov"] + +[[package]] +name = "markupsafe" +version = "2.1.1" +description = "Safely add untrusted strings to HTML/XML markup." +category = "main" +optional = false +python-versions = ">=3.7" + +[[package]] +name = "matplotlib" +version = "3.5.2" +description = "Python plotting package" +category = "main" +optional = true +python-versions = ">=3.7" + +[package.dependencies] +cycler = ">=0.10" +fonttools = ">=4.22.0" +kiwisolver = ">=1.0.1" +numpy = ">=1.17" +packaging = ">=20.0" +pillow = ">=6.2.0" +pyparsing = ">=2.2.1" +python-dateutil = ">=2.7" +setuptools_scm = ">=4" + +[[package]] +name = "matplotlib-inline" +version = "0.1.3" +description = "Inline Matplotlib backend for Jupyter" +category = "main" +optional = false +python-versions = ">=3.5" + +[package.dependencies] +traitlets = "*" + +[[package]] +name = "mercantile" +version = "1.2.1" +description = "Web mercator XYZ tile utilities" +category = "main" +optional = true +python-versions = "*" + +[package.dependencies] +click = ">=3.0" + +[package.extras] +test = ["pytest", "hypothesis"] +dev = ["check-manifest"] + +[[package]] +name = "mistune" +version = "0.8.4" +description = "The fastest markdown parser in pure Python" +category = "main" +optional = true +python-versions = "*" + +[[package]] +name = "msgpack" +version = "1.0.4" +description = "MessagePack serializer" +category = "main" +optional = false +python-versions = "*" + +[[package]] +name = "multidict" +version = "6.0.2" +description = "multidict implementation" +category = "main" +optional = true +python-versions = ">=3.7" + +[[package]] +name = "munch" +version = "2.5.0" +description = "A dot-accessible dictionary (a la JavaScript objects)" +category = "main" +optional = true +python-versions = "*" + +[package.dependencies] +six = "*" + +[package.extras] +testing = ["pytest", "coverage", "astroid (>=1.5.3,<1.6.0)", "pylint (>=1.7.2,<1.8.0)", "astroid (>=2.0)", "pylint (>=2.3.1,<2.4.0)"] +yaml = ["PyYAML (>=5.1.0)"] [[package]] name = "mypy" @@ -515,9 +1079,85 @@ category = "dev" optional = false python-versions = "*" +[[package]] +name = "nbclient" +version = "0.6.6" +description = "A client library for executing notebooks. Formerly nbconvert's ExecutePreprocessor." +category = "main" +optional = true +python-versions = ">=3.7.0" + +[package.dependencies] +jupyter-client = ">=6.1.5" +nbformat = ">=5.0" +nest-asyncio = "*" +traitlets = ">=5.2.2" + +[package.extras] +sphinx = ["autodoc-traits", "mock", "moto", "myst-parser", "Sphinx (>=1.7)", "sphinx-book-theme"] +test = ["black", "check-manifest", "flake8", "ipykernel", "ipython (<8.0.0)", "ipywidgets (<8.0.0)", "mypy", "pip (>=18.1)", "pre-commit", "pytest (>=4.1)", "pytest-asyncio", "pytest-cov (>=2.6.1)", "setuptools (>=60.0)", "testpath", "twine (>=1.11.0)", "xmltodict"] + +[[package]] +name = "nbconvert" +version = "6.5.0" +description = "Converting Jupyter Notebooks" +category = "main" +optional = true +python-versions = ">=3.7" + +[package.dependencies] +beautifulsoup4 = "*" +bleach = "*" +defusedxml = "*" +entrypoints = ">=0.2.2" +jinja2 = ">=3.0" +jupyter-core = ">=4.7" +jupyterlab-pygments = "*" +MarkupSafe = ">=2.0" +mistune = ">=0.8.1,<2" +nbclient = ">=0.5.0" +nbformat = ">=5.1" +packaging = "*" +pandocfilters = ">=1.4.1" +pygments = ">=2.4.1" +tinycss2 = "*" +traitlets = ">=5.0" + +[package.extras] +all = ["pytest", "pytest-cov", "pytest-dependency", "ipykernel", "ipywidgets (>=7)", "pre-commit", "pyppeteer (>=1,<1.1)", "tornado (>=6.1)", "sphinx (>=1.5.1)", "sphinx-rtd-theme", "nbsphinx (>=0.2.12)", "ipython"] +docs = ["sphinx (>=1.5.1)", "sphinx-rtd-theme", "nbsphinx (>=0.2.12)", "ipython"] +serve = ["tornado (>=6.1)"] +test = ["pytest", "pytest-cov", "pytest-dependency", "ipykernel", "ipywidgets (>=7)", "pre-commit", "pyppeteer (>=1,<1.1)"] +webpdf = ["pyppeteer (>=1,<1.1)"] + +[[package]] +name = "nbformat" +version = "5.4.0" +description = "The Jupyter Notebook format" +category = "main" +optional = true +python-versions = ">=3.7" + +[package.dependencies] +fastjsonschema = "*" +jsonschema = ">=2.6" +jupyter-core = "*" +traitlets = ">=5.1" + +[package.extras] +test = ["check-manifest", "testpath", "pytest", "pre-commit"] + +[[package]] +name = "nest-asyncio" +version = "1.5.5" +description = "Patch asyncio to allow nested event loops" +category = "main" +optional = false +python-versions = ">=3.5" + [[package]] name = "netcdf4" -version = "1.5.8" +version = "1.6.0" description = "Provides an object-oriented python interface to the netCDF version 4 library." category = "main" optional = false @@ -529,7 +1169,7 @@ numpy = ">=1.9" [[package]] name = "networkx" -version = "2.8.4" +version = "2.8.5" description = "Python package for creating and manipulating graphs and networks" category = "main" optional = false @@ -542,13 +1182,43 @@ doc = ["sphinx (>=5)", "pydata-sphinx-theme (>=0.9)", "sphinx-gallery (>=0.10)", extra = ["lxml (>=4.6)", "pygraphviz (>=1.9)", "pydot (>=1.4.2)", "sympy (>=1.10)"] test = ["pytest (>=7.1)", "pytest-cov (>=3.0)", "codecov (>=2.1)"] +[[package]] +name = "notebook" +version = "6.4.12" +description = "A web-based notebook environment for interactive computing" +category = "main" +optional = true +python-versions = ">=3.7" + +[package.dependencies] +argon2-cffi = "*" +ipykernel = "*" +ipython-genutils = "*" +jinja2 = "*" +jupyter-client = ">=5.3.4" +jupyter-core = ">=4.6.1" +nbconvert = ">=5" +nbformat = "*" +nest-asyncio = ">=1.5" +prometheus-client = "*" +pyzmq = ">=17" +Send2Trash = ">=1.8.0" +terminado = ">=0.8.3" +tornado = ">=6.1" +traitlets = ">=4.2.1" + +[package.extras] +docs = ["sphinx", "nbsphinx", "sphinxcontrib-github-alt", "sphinx-rtd-theme", "myst-parser"] +json-logging = ["json-logging"] +test = ["pytest", "coverage", "requests", "testpath", "nbval", "selenium", "pytest-cov", "requests-unixsocket"] + [[package]] name = "numexpr" -version = "2.8.1" +version = "2.8.3" description = "Fast numerical expression evaluator for NumPy" category = "main" optional = false -python-versions = "*" +python-versions = ">=3.7" [package.dependencies] numpy = ">=1.13.3" @@ -556,7 +1226,7 @@ packaging = "*" [[package]] name = "numpy" -version = "1.23.0" +version = "1.23.1" description = "NumPy is the fundamental package for array computing with Python." category = "main" optional = false @@ -584,8 +1254,8 @@ toolz = "*" xarray = "*" [package.extras] +s3 = ["odc-cloud", "boto3"] hdstats = ["hdstats (>=0.1.7.post5)"] -s3 = ["boto3", "odc-cloud"] [[package]] name = "packaging" @@ -619,6 +1289,26 @@ pytz = ">=2020.1" [package.extras] test = ["hypothesis (>=5.5.3)", "pytest (>=6.0)", "pytest-xdist (>=1.31)"] +[[package]] +name = "pandocfilters" +version = "1.5.0" +description = "Utilities for writing pandoc filters in python" +category = "main" +optional = true +python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*" + +[[package]] +name = "parso" +version = "0.8.3" +description = "A Python Parser" +category = "main" +optional = false +python-versions = ">=3.6" + +[package.extras] +qa = ["flake8 (==3.8.3)", "mypy (==0.782)"] +testing = ["docopt", "pytest (<6.0.0)"] + [[package]] name = "partd" version = "1.2.0" @@ -632,18 +1322,37 @@ locket = "*" toolz = "*" [package.extras] -complete = ["numpy (>=1.9.0)", "pandas (>=0.19.0)", "pyzmq", "blosc"] +complete = ["blosc", "pyzmq", "pandas (>=0.19.0)", "numpy (>=1.9.0)"] + +[[package]] +name = "pexpect" +version = "4.8.0" +description = "Pexpect allows easy control of interactive console applications." +category = "main" +optional = false +python-versions = "*" + +[package.dependencies] +ptyprocess = ">=0.5" + +[[package]] +name = "pickleshare" +version = "0.7.5" +description = "Tiny 'shelve'-like database with concurrency support" +category = "main" +optional = false +python-versions = "*" [[package]] name = "pillow" -version = "9.1.1" +version = "9.2.0" description = "Python Imaging Library (Fork)" category = "main" optional = false python-versions = ">=3.7" [package.extras] -docs = ["olefile", "sphinx (>=2.4)", "sphinx-copybutton", "sphinx-issues (>=3.0.1)", "sphinx-removed-in", "sphinx-rtd-theme (>=1.0)", "sphinxext-opengraph"] +docs = ["furo", "olefile", "sphinx (>=2.4)", "sphinx-copybutton", "sphinx-issues (>=3.0.1)", "sphinx-removed-in", "sphinxext-opengraph"] tests = ["check-manifest", "coverage", "defusedxml", "markdown2", "olefile", "packaging", "pyroma", "pytest", "pytest-cov", "pytest-timeout"] [[package]] @@ -659,6 +1368,14 @@ imageio = "*" numpy = ">=1.19" slicerator = ">=0.9.8" +[[package]] +name = "pkgutil-resolve-name" +version = "1.3.10" +description = "Resolve a name to an object." +category = "main" +optional = false +python-versions = ">=3.6" + [[package]] name = "pluggy" version = "1.0.0" @@ -668,8 +1385,30 @@ optional = false python-versions = ">=3.6" [package.extras] -dev = ["pre-commit", "tox"] -testing = ["pytest", "pytest-benchmark"] +testing = ["pytest-benchmark", "pytest"] +dev = ["tox", "pre-commit"] + +[[package]] +name = "prometheus-client" +version = "0.14.1" +description = "Python client for the Prometheus monitoring system." +category = "main" +optional = true +python-versions = ">=3.6" + +[package.extras] +twisted = ["twisted"] + +[[package]] +name = "prompt-toolkit" +version = "3.0.30" +description = "Library for building powerful interactive command lines in Python" +category = "main" +optional = false +python-versions = ">=3.6.2" + +[package.dependencies] +wcwidth = "*" [[package]] name = "psutil" @@ -690,28 +1429,63 @@ category = "main" optional = false python-versions = ">=3.6" +[[package]] +name = "ptyprocess" +version = "0.7.0" +description = "Run a subprocess in a pseudo terminal" +category = "main" +optional = false +python-versions = "*" + +[[package]] +name = "pure-eval" +version = "0.2.2" +description = "Safely evaluate AST nodes without side effects" +category = "main" +optional = false +python-versions = "*" + +[package.extras] +tests = ["pytest"] + [[package]] name = "py" version = "1.11.0" description = "library with cross-python path, ini-parsing, io, code, log facilities" -category = "dev" +category = "main" optional = false python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*" +[[package]] +name = "pycparser" +version = "2.21" +description = "C parser in Python" +category = "main" +optional = false +python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*" + [[package]] name = "pygeos" version = "0.12.0" description = "GEOS wrapped in numpy ufuncs" category = "main" -optional = false +optional = true python-versions = ">=3.6" [package.dependencies] numpy = ">=1.13" [package.extras] -docs = ["sphinx", "numpydoc"] test = ["pytest"] +docs = ["numpydoc", "sphinx"] + +[[package]] +name = "pygments" +version = "2.12.0" +description = "Pygments is a syntax highlighting package written in Python." +category = "main" +optional = false +python-versions = ">=3.6" [[package]] name = "pyparsing" @@ -743,6 +1517,37 @@ category = "main" optional = false python-versions = ">=3.7" +[[package]] +name = "pystac" +version = "1.6.1" +description = "Python library for working with Spatiotemporal Asset Catalog (STAC)." +category = "main" +optional = false +python-versions = ">=3.8" + +[package.dependencies] +python-dateutil = ">=2.7.0" + +[package.extras] +orjson = ["orjson (>=3.5)"] +validation = ["jsonschema (>=4.0.1)"] + +[[package]] +name = "pystac-client" +version = "0.4.0" +description = "Python library for working with Spatiotemporal Asset Catalog (STAC)." +category = "main" +optional = false +python-versions = ">=3.7" + +[package.dependencies] +pystac = ">=1.4.0" +python-dateutil = ">=2.7.0" +requests = ">=2.25" + +[package.extras] +validation = ["jsonschema (>=4.5.1)"] + [[package]] name = "pytest" version = "7.1.2" @@ -775,17 +1580,6 @@ python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,>=2.7" [package.dependencies] six = ">=1.5" -[[package]] -name = "pytileproj" -version = "0.0.16" -description = "Class for working with TiledProjectionSystems (TPS)" -category = "main" -optional = false -python-versions = ">=3.6" - -[package.extras] -testing = ["pytest", "pytest-cov"] - [[package]] name = "pytz" version = "2022.1" @@ -805,6 +1599,22 @@ python-versions = ">=3.7" [package.dependencies] numpy = ">=1.17.3" +[[package]] +name = "pywin32" +version = "304" +description = "Python for Window Extensions" +category = "main" +optional = false +python-versions = "*" + +[[package]] +name = "pywinpty" +version = "2.0.7" +description = "Pseudo terminal support for Windows from Python." +category = "main" +optional = true +python-versions = ">=3.7" + [[package]] name = "pyyaml" version = "6.0" @@ -813,13 +1623,25 @@ category = "main" optional = false python-versions = ">=3.6" +[[package]] +name = "pyzmq" +version = "23.2.0" +description = "Python bindings for 0MQ" +category = "main" +optional = false +python-versions = ">=3.6" + +[package.dependencies] +cffi = {version = "*", markers = "implementation_name == \"pypy\""} +py = {version = "*", markers = "implementation_name == \"pypy\""} + [[package]] name = "rasterio" -version = "1.2.10" +version = "1.3.0" description = "Fast and direct raster I/O for use with Numpy and SciPy" category = "main" optional = false -python-versions = ">=3.6" +python-versions = ">=3.8" [package.dependencies] affine = "*" @@ -832,19 +1654,37 @@ numpy = "*" snuggs = ">=1.4.1" [package.extras] -all = ["numpydoc", "hypothesis", "matplotlib", "pytest-cov (>=2.2.0)", "sphinx", "ipython (>=2.0)", "boto3 (>=1.2.4)", "shapely", "pytest (>=2.8.2)", "packaging", "sphinx-rtd-theme", "ghp-import"] -docs = ["ghp-import", "numpydoc", "sphinx", "sphinx-rtd-theme"] -ipython = ["ipython (>=2.0)"] -plot = ["matplotlib"] +test = ["shapely", "pytest (>=2.8.2)", "pytest-cov (>=2.2.0)", "packaging", "hypothesis", "boto3 (>=1.2.4)"] s3 = ["boto3 (>=1.2.4)"] -test = ["boto3 (>=1.2.4)", "hypothesis", "packaging", "pytest-cov (>=2.2.0)", "pytest (>=2.8.2)", "shapely"] +plot = ["matplotlib"] +ipython = ["ipython (>=2.0)"] +docs = ["sphinx-rtd-theme", "sphinx", "numpydoc", "ghp-import"] +all = ["pytest-cov (>=2.2.0)", "pytest (>=2.8.2)", "boto3 (>=1.2.4)", "shapely", "packaging", "sphinx", "sphinx-rtd-theme", "matplotlib", "ghp-import", "ipython (>=2.0)", "numpydoc", "hypothesis"] + +[[package]] +name = "requests" +version = "2.28.1" +description = "Python HTTP for Humans." +category = "main" +optional = false +python-versions = ">=3.7, <4" + +[package.dependencies] +certifi = ">=2017.4.17" +charset-normalizer = ">=2,<3" +idna = ">=2.5,<4" +urllib3 = ">=1.21.1,<1.27" + +[package.extras] +socks = ["PySocks (>=1.5.6,!=1.5.7)"] +use_chardet_on_py3 = ["chardet (>=3.0.2,<6)"] [[package]] name = "rioxarray" version = "0.9.1" description = "rasterio xarray extension." category = "main" -optional = false +optional = true python-versions = ">=3.7" [package.dependencies] @@ -894,6 +1734,36 @@ python-versions = ">=3.7" [package.dependencies] numpy = ">=1.16.5" +[[package]] +name = "send2trash" +version = "1.8.0" +description = "Send file to trash natively under Mac OS X, Windows and Linux." +category = "main" +optional = true +python-versions = "*" + +[package.extras] +nativelib = ["pyobjc-framework-cocoa", "pywin32"] +objc = ["pyobjc-framework-cocoa"] +win32 = ["pywin32"] + +[[package]] +name = "setuptools-scm" +version = "7.0.5" +description = "the blessed package to manage your versions by scm tags" +category = "main" +optional = true +python-versions = ">=3.7" + +[package.dependencies] +packaging = ">=20.0" +tomli = ">=1.0.0" +typing-extensions = "*" + +[package.extras] +test = ["pytest (>=6.2)", "virtualenv (>20)"] +toml = ["setuptools (>=42)"] + [[package]] name = "shapely" version = "1.8.2" @@ -907,6 +1777,14 @@ all = ["pytest", "pytest-cov", "numpy"] test = ["pytest", "pytest-cov"] vectorized = ["numpy"] +[[package]] +name = "simpervisor" +version = "0.4" +description = "Simple async process supervisor" +category = "main" +optional = true +python-versions = "*" + [[package]] name = "six" version = "1.16.0" @@ -923,6 +1801,14 @@ category = "main" optional = false python-versions = "*" +[[package]] +name = "sniffio" +version = "1.2.0" +description = "Sniff out which async library your code is running under" +category = "main" +optional = true +python-versions = ">=3.5" + [[package]] name = "snuggs" version = "1.4.7" @@ -946,9 +1832,17 @@ category = "main" optional = false python-versions = "*" +[[package]] +name = "soupsieve" +version = "2.3.2.post1" +description = "A modern CSS selector implementation for Beautiful Soup." +category = "main" +optional = true +python-versions = ">=3.6" + [[package]] name = "sqlalchemy" -version = "1.4.38" +version = "1.4.40" description = "Database Abstraction Library" category = "main" optional = false @@ -962,7 +1856,7 @@ aiomysql = ["greenlet (!=0.4.17)", "aiomysql"] aiosqlite = ["typing_extensions (!=3.10.0.1)", "greenlet (!=0.4.17)", "aiosqlite"] asyncio = ["greenlet (!=0.4.17)"] asyncmy = ["greenlet (!=0.4.17)", "asyncmy (>=0.2.3,!=0.2.4)"] -mariadb_connector = ["mariadb (>=1.0.1)"] +mariadb_connector = ["mariadb (>=1.0.1,!=1.1.2)"] mssql = ["pyodbc"] mssql_pymssql = ["pymssql"] mssql_pyodbc = ["pyodbc"] @@ -978,6 +1872,50 @@ postgresql_psycopg2cffi = ["psycopg2cffi"] pymysql = ["pymysql (<1)", "pymysql"] sqlcipher = ["sqlcipher3-binary"] +[[package]] +name = "stack-data" +version = "0.3.0" +description = "Extract data from python stack frames and tracebacks for informative displays" +category = "main" +optional = false +python-versions = "*" + +[package.dependencies] +asttokens = "*" +executing = "*" +pure-eval = "*" + +[package.extras] +tests = ["cython", "littleutils", "pygments", "typeguard", "pytest"] + +[[package]] +name = "stackstac" +version = "0.4.2" +description = "Load a STAC collection into xarray with dask" +category = "main" +optional = true +python-versions = ">=3.8,<4.0" + +[package.dependencies] +aiohttp = {version = ">=3.7.4,<4.0.0", optional = true, markers = "extra == \"viz\""} +cachetools = {version = ">=4.2.2,<5.0.0", optional = true, markers = "extra == \"viz\""} +dask = {version = ">=2022.1.1,<2023.0.0", extras = ["array"]} +distributed = {version = ">=2022.1.1,<2023.0.0", optional = true, markers = "extra == \"binder\" or extra == \"viz\""} +ipyleaflet = {version = ">=0.13.6,<0.14.0", optional = true, markers = "extra == \"binder\" or extra == \"docs\" or extra == \"viz\""} +jupyter-server-proxy = {version = ">=3.2.0,<4.0.0", optional = true, markers = "extra == \"binder\" or extra == \"viz\""} +matplotlib = {version = ">=3.4.1,<4.0.0", optional = true, markers = "extra == \"binder\" or extra == \"viz\""} +mercantile = {version = ">=1.1.6,<2.0.0", optional = true, markers = "extra == \"viz\""} +Pillow = {version = ">=9.0.1,<10.0.0", optional = true, markers = "extra == \"viz\""} +pyproj = ">=3.0.0,<4.0.0" +rasterio = ">=1.3.0,<2.0.0" +scipy = {version = ">=1.6.1,<2.0.0", optional = true, markers = "extra == \"viz\""} +xarray = ">=0.18" + +[package.extras] +docs = ["sphinx-autodoc-typehints (>=1.18.3,<2.0.0)", "pandoc (>=2.2,<3.0)", "numpydoc (>=1.4.0,<2.0.0)", "nbsphinx (>=0.8.9,<0.9.0)", "jupyter-sphinx (>=0.4.0,<0.5.0)", "ipython (>=7.20.0,<8.0.0)", "ipyleaflet (>=0.13.6,<0.14.0)", "furo (>=2022.6.21,<2023.0.0)", "Sphinx (>=5.0.2,<6.0.0)"] +viz = ["scipy (>=1.6.1,<2.0.0)", "mercantile (>=1.1.6,<2.0.0)", "matplotlib (>=3.4.1,<4.0.0)", "jupyter-server-proxy (>=3.2.0,<4.0.0)", "ipyleaflet (>=0.13.6,<0.14.0)", "distributed (>=2022.1.1,<2023.0.0)", "cachetools (>=4.2.2,<5.0.0)", "aiohttp (>=3.7.4,<4.0.0)", "Pillow (>=9.0.1,<10.0.0)"] +binder = ["sat-search (>=0.3.0,<0.4.0)", "pystac-client (>=0.3,<0.4)", "planetary-computer (>=0.4.3,<1)", "matplotlib (>=3.4.1,<4.0.0)", "jupyterlab-system-monitor (>=0.8.0,<0.9.0)", "jupyterlab-geojson (>=3.1.2,<4.0.0)", "jupyter-server-proxy (>=3.2.0,<4.0.0)", "ipywidgets (>=7.6.3,<8.0.0)", "ipyleaflet (>=0.13.6,<0.14.0)", "geogif (>=0,<1)", "distributed (>=2022.1.1,<2023.0.0)", "coiled (>=0,<1)", "Bottleneck (>=1.3.2,<2.0.0)"] + [[package]] name = "tblib" version = "1.7.0" @@ -986,9 +1924,25 @@ category = "main" optional = false python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*" +[[package]] +name = "terminado" +version = "0.15.0" +description = "Tornado websocket backend for the Xterm.js Javascript terminal emulator library." +category = "main" +optional = true +python-versions = ">=3.7" + +[package.dependencies] +ptyprocess = {version = "*", markers = "os_name != \"nt\""} +pywinpty = {version = ">=1.1.0", markers = "os_name == \"nt\""} +tornado = ">=6.1.0" + +[package.extras] +test = ["pre-commit", "pytest-timeout", "pytest (>=6.0)"] + [[package]] name = "tifffile" -version = "2022.5.4" +version = "2022.8.8" description = "Read and write TIFF files" category = "main" optional = false @@ -998,19 +1952,34 @@ python-versions = ">=3.8" numpy = ">=1.19.2" [package.extras] -all = ["imagecodecs (>=2021.11.20)", "matplotlib (>=3.3)", "lxml"] +all = ["imagecodecs (>=2022.2.22)", "matplotlib (>=3.3)", "lxml"] + +[[package]] +name = "tinycss2" +version = "1.1.1" +description = "A tiny CSS parser" +category = "main" +optional = true +python-versions = ">=3.6" + +[package.dependencies] +webencodings = ">=0.4" + +[package.extras] +test = ["coverage", "pytest-isort", "pytest-flake8", "pytest-cov", "pytest"] +doc = ["sphinx-rtd-theme", "sphinx"] [[package]] name = "tomli" version = "2.0.1" description = "A lil' TOML parser" -category = "dev" +category = "main" optional = false python-versions = ">=3.7" [[package]] name = "toolz" -version = "0.11.2" +version = "0.12.0" description = "List processing tools and functional utilities" category = "main" optional = false @@ -1024,9 +1993,34 @@ category = "main" optional = false python-versions = ">= 3.5" +[[package]] +name = "traitlets" +version = "5.3.0" +description = "" +category = "main" +optional = false +python-versions = ">=3.7" + +[package.extras] +test = ["pre-commit", "pytest"] + +[[package]] +name = "traittypes" +version = "0.2.1" +description = "Scipy trait types" +category = "main" +optional = true +python-versions = "*" + +[package.dependencies] +traitlets = ">=4.2.2" + +[package.extras] +test = ["numpy", "pandas", "xarray", "pytest"] + [[package]] name = "types-pyyaml" -version = "6.0.8" +version = "6.0.11" description = "Typing stubs for PyYAML" category = "dev" optional = false @@ -1034,25 +2028,65 @@ python-versions = "*" [[package]] name = "typing-extensions" -version = "4.2.0" +version = "4.3.0" description = "Backported and Experimental Type Hints for Python 3.7+" -category = "dev" +category = "main" optional = false python-versions = ">=3.7" [[package]] name = "urllib3" -version = "1.26.9" +version = "1.26.11" description = "HTTP library with thread-safe connection pooling, file post, and more." category = "main" optional = false -python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, <4" +python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*, <4" [package.extras] brotli = ["brotlicffi (>=0.8.0)", "brotli (>=1.0.9)", "brotlipy (>=0.6.0)"] secure = ["pyOpenSSL (>=0.14)", "cryptography (>=1.3.4)", "idna (>=2.0.0)", "certifi", "ipaddress"] socks = ["PySocks (>=1.5.6,!=1.5.7,<2.0)"] +[[package]] +name = "wcwidth" +version = "0.2.5" +description = "Measures the displayed width of unicode strings in a terminal" +category = "main" +optional = false +python-versions = "*" + +[[package]] +name = "webencodings" +version = "0.5.1" +description = "Character encoding aliases for legacy web content" +category = "main" +optional = true +python-versions = "*" + +[[package]] +name = "websocket-client" +version = "1.3.3" +description = "WebSocket client for Python with low level API options" +category = "main" +optional = true +python-versions = ">=3.7" + +[package.extras] +docs = ["Sphinx (>=3.4)", "sphinx-rtd-theme (>=0.5)"] +optional = ["python-socks", "wsaccel"] +test = ["websockets"] + +[[package]] +name = "widgetsnbextension" +version = "3.6.1" +description = "IPython HTML widgets for Jupyter" +category = "main" +optional = true +python-versions = "*" + +[package.dependencies] +notebook = ">=4.4.1" + [[package]] name = "xarray" version = "2022.3.0" @@ -1079,7 +2113,7 @@ name = "xgboost" version = "1.6.1" description = "XGBoost Python Package" category = "main" -optional = false +optional = true python-versions = ">=3.7" [package.dependencies] @@ -1093,6 +2127,18 @@ pandas = ["pandas"] plotting = ["graphviz", "matplotlib"] scikit-learn = ["scikit-learn"] +[[package]] +name = "yarl" +version = "1.8.1" +description = "Yet another URL library" +category = "main" +optional = true +python-versions = ">=3.7" + +[package.dependencies] +idna = ">=2.0" +multidict = ">=4.0" + [[package]] name = "zict" version = "2.2.0" @@ -1106,997 +2152,186 @@ heapdict = "*" [[package]] name = "zipp" -version = "3.8.0" +version = "3.8.1" description = "Backport of pathlib-compatible object wrapper for zip files" category = "main" optional = false python-versions = ">=3.7" [package.extras] -docs = ["sphinx", "jaraco.packaging (>=9)", "rst.linker (>=1.9)"] -testing = ["pytest (>=6)", "pytest-checkdocs (>=2.4)", "pytest-flake8", "pytest-cov", "pytest-enabler (>=1.0.1)", "jaraco.itertools", "func-timeout", "pytest-black (>=0.3.7)", "pytest-mypy (>=0.9.1)"] +docs = ["sphinx", "jaraco.packaging (>=9)", "rst.linker (>=1.9)", "jaraco.tidelift (>=1.4)"] +testing = ["pytest (>=6)", "pytest-checkdocs (>=2.4)", "pytest-flake8", "pytest-cov", "pytest-enabler (>=1.3)", "jaraco.itertools", "func-timeout", "pytest-black (>=0.3.7)", "pytest-mypy (>=0.9.1)"] + +[extras] +dask-worker = ["datacube", "rioxarray", "PyYAML", "stackstac", "geopandas", "dask-geopandas", "xgboost"] +load-save = ["datacube", "GDAL", "rioxarray", "PyYAML", "stackstac"] +ml = ["xgboost"] +vector = ["geopandas", "dask-geopandas"] [metadata] lock-version = "1.1" python-versions = "^3.8" -content-hash = "6c254636e6e572fa0fd81cfee63fbb343d3a009a6fd6a9303ee7530d0745826b" +content-hash = "a6d7c01ea6981e81fd6ec9a86f1ad4b69312cfe41d182fea3853a7f4293e86cb" [metadata.files] -affine = [ - {file = "affine-2.3.1-py2.py3-none-any.whl", hash = "sha256:de17839ff05e965580870c3b15e14cefd7992fa05dba9202a0879bbed0c171e4"}, - {file = "affine-2.3.1.tar.gz", hash = "sha256:d676de66157ad6af99ffd94e0f54e89dfc35b0fb7252ead2ed0ad2dca431bdd0"}, -] -atomicwrites = [ - {file = "atomicwrites-1.4.0-py2.py3-none-any.whl", hash = "sha256:6d1784dea7c0c8d4a5172b6c620f40b6e4cbfdf96d783691f2e1302a7b88e197"}, - {file = "atomicwrites-1.4.0.tar.gz", hash = "sha256:ae70396ad1a434f9c7046fd2dd196fc04b12f9e91ffb859164193be8b6168a7a"}, -] -attrs = [ - {file = "attrs-21.4.0-py2.py3-none-any.whl", hash = "sha256:2d27e3784d7a565d36ab851fe94887c5eccd6a463168875832a1be79c82828b4"}, - {file = "attrs-21.4.0.tar.gz", hash = "sha256:626ba8234211db98e869df76230a137c4c40a12d72445c45d5f5b716f076e2fd"}, -] -cachetools = [ - {file = "cachetools-5.2.0-py3-none-any.whl", hash = "sha256:f9f17d2aec496a9aa6b76f53e3b614c965223c061982d434d160f930c698a9db"}, - {file = "cachetools-5.2.0.tar.gz", hash = "sha256:6a94c6402995a99c3970cc7e4884bb60b4a8639938157eeed436098bf9831757"}, -] -certifi = [ - {file = "certifi-2022.6.15-py3-none-any.whl", hash = "sha256:fe86415d55e84719d75f8b69414f6438ac3547d2078ab91b67e779ef69378412"}, - {file = "certifi-2022.6.15.tar.gz", hash = "sha256:84c85a9078b11105f04f3036a9482ae10e4621616db313fe045dd24743a0820d"}, -] -cftime = [ - {file = "cftime-1.6.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:bb0d680149f128d181ef1c6561eaebbf99b572329dee090c83b6735d7284a703"}, - {file = "cftime-1.6.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:517c50e29b3c141919d83bf3782892e4a4144034b63722e7a266db25488b3bb5"}, - {file = "cftime-1.6.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:64bcb6ca9ef922b2332e9ed91cd6f6f2fe28de392fb10e752f2ac83ffdc50854"}, - {file = "cftime-1.6.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1c56556900b9ae3a5b4c9705699d78f865994e5c3c92cd230d54c89d669b88f0"}, - {file = "cftime-1.6.0-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:13e92118fa3606b2a1d95bbe1a18a0a260ba85704d9ff061e9599b0e745bb4a9"}, - {file = "cftime-1.6.0-cp310-none-win_amd64.whl", hash = "sha256:bfb03c766250d86d6abf546d4c1fbe0db7401eaedeab5bbbd0e599fde7c7a7d3"}, - {file = "cftime-1.6.0-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:7900daf0efa495f263c3c5b0c96502cc909fb07ef56844791e3c8cdbb08a741c"}, - {file = "cftime-1.6.0-cp36-cp36m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1f43f1c839f5579bf045f13b0d2deb15048d314d209039664003ae1bf2544898"}, - {file = "cftime-1.6.0-cp36-cp36m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e020db7391b2112e4c1ec9db75ff82031f979666264903697ab5ad0bfb20d490"}, - {file = "cftime-1.6.0-cp36-cp36m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4d39b666284c78726eb7ea8b4ad29aacd387e912177721b3eb9bdc508e2b86fa"}, - {file = "cftime-1.6.0-cp36-none-win_amd64.whl", hash = "sha256:1888f0c0ab37d6ee23d07e74e51dcaae136da48784ceaa5d078115aa2e2b8b92"}, - {file = "cftime-1.6.0-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:ee740b8dd77cb1773ae1560b890cee3aa5b82a4a7ca056223f08f4b37ebb6466"}, - {file = "cftime-1.6.0-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e195ed19638f324c40bb0094d13385d58e798607670b91cc8f42717a0a832263"}, - {file = "cftime-1.6.0-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b420e3811da55db538008229b3ca34055734d6ade12316889d1979d770d7dfaf"}, - {file = "cftime-1.6.0-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:eca80007816b9dd1cc154a393b8da2ada22baad1ac7b2b2a9cc01451796e3e93"}, - {file = "cftime-1.6.0-cp37-none-win_amd64.whl", hash = "sha256:9b31455449d2e347d033a6440f94305ce7eb48d32d863dfe0f53671c78e2561d"}, - {file = "cftime-1.6.0-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:a8a56edad64912b11d8f80245b5ce7e61057eee22b6af0718e9d086b381a17d9"}, - {file = "cftime-1.6.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:a49b023ca5cab9c43d33b3a43edc5a112f5d452f75fc1a85f8ca136f4fa9d440"}, - {file = "cftime-1.6.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:cab3fee686c58e2ce2f61e1bf138711eefde6c0235b0cfc736c8ea96381d8346"}, - {file = "cftime-1.6.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f63c14e98022c3a67ff7c5c12edf17912a7353ddd95bbfde6db1e4bc05ea5bdc"}, - {file = "cftime-1.6.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:519d1c391ed7be3bb4d84990a51a76cbb1cc894bd776637c0227dfe1f6274f39"}, - {file = "cftime-1.6.0-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:09970124c0a8c84a66e34e8655c42f0254e1c29d73a766e71c9a871ce57f125b"}, - {file = "cftime-1.6.0-cp38-none-win_amd64.whl", hash = "sha256:1187fa1107974fe374f90936e39d2e09ac7cb4ffcd3b31314898684a2cebba87"}, - {file = "cftime-1.6.0-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:a6c1e59299250299f23ab526d1ad640dcc3b9eb311468a8f9112f9d53d6106c6"}, - {file = "cftime-1.6.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:80390ddb68a7e27b52bf83efc040c8e3ec2e3b0bb0e66084a75498fb39f63a63"}, - {file = "cftime-1.6.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:f7007e7cd837cb37716149d7c735b90b947b3370b7a5652d58675ea940541542"}, - {file = "cftime-1.6.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2da21d8626a7f549eaaae7d314110133914fa24726e4e7caab2775627cb7361a"}, - {file = "cftime-1.6.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4c608937082980e0905657ec2475b3ff2a2fc89255e185f44076da482102f617"}, - {file = "cftime-1.6.0-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:003abc800933a39d6f4ecec113f401aef9961642a4769aa1099ed34e0c1c3d46"}, - {file = "cftime-1.6.0-cp39-none-win_amd64.whl", hash = "sha256:c0b3aff3c955d18342c2097ad1102c78d0999dba5de178d0ce68a317caf6f87e"}, - {file = "cftime-1.6.0.tar.gz", hash = "sha256:13103e6650beea6552316bd5825d6aa3b7e98f5b8115026df4826798dff9f741"}, -] -click = [ - {file = "click-8.1.3-py3-none-any.whl", hash = "sha256:bb4d8133cb15a609f44e8213d9b391b0809795062913b383c62be0ee95b1db48"}, - {file = "click-8.1.3.tar.gz", hash = "sha256:7682dc8afb30297001674575ea00d1814d808d6a36af415a82bd481d37ba7b8e"}, -] -click-plugins = [ - {file = "click-plugins-1.1.1.tar.gz", hash = "sha256:46ab999744a9d831159c3411bb0c79346d94a444df9a3a3742e9ed63645f264b"}, - {file = "click_plugins-1.1.1-py2.py3-none-any.whl", hash = "sha256:5d262006d3222f5057fd81e1623d4443e41dcda5dc815c06b442aa3c02889fc8"}, -] -cligj = [ - {file = "cligj-0.7.2-py3-none-any.whl", hash = "sha256:c1ca117dbce1fe20a5809dc96f01e1c2840f6dcc939b3ddbb1111bf330ba82df"}, - {file = "cligj-0.7.2.tar.gz", hash = "sha256:a4bc13d623356b373c2c27c53dbd9c68cae5d526270bfa71f6c6fa69669c6b27"}, -] -cloudpickle = [ - {file = "cloudpickle-2.1.0-py3-none-any.whl", hash = "sha256:b5c434f75c34624eedad3a14f2be5ac3b5384774d5b0e3caf905c21479e6c4b1"}, - {file = "cloudpickle-2.1.0.tar.gz", hash = "sha256:bb233e876a58491d9590a676f93c7a5473a08f747d5ab9df7f9ce564b3e7938e"}, -] -colorama = [ - {file = "colorama-0.4.5-py2.py3-none-any.whl", hash = "sha256:854bf444933e37f5824ae7bfc1e98d5bce2ebe4160d46b5edf346a89358e99da"}, - {file = "colorama-0.4.5.tar.gz", hash = "sha256:e6c6b4334fc50988a639d9b98aa429a0b57da6e17b9a44f0451f930b6967b7a4"}, -] -dask = [ - {file = "dask-2022.6.0-py3-none-any.whl", hash = "sha256:5b9ed36af86e609af8466221a29287c020cecfb5b692fb1d65188a6c126ddb8f"}, - {file = "dask-2022.6.0.tar.gz", hash = "sha256:9f30f0652588140c2a345b72b35a400e59c44fff9ae14dd5097c7633d994d9cc"}, -] -dask-geopandas = [ - {file = "dask-geopandas-0.1.3.tar.gz", hash = "sha256:b853aabd865ead6666f58560496f819ef57f5b12d941b9c65a84ddff59c73fb4"}, - {file = "dask_geopandas-0.1.3-py3-none-any.whl", hash = "sha256:ff6accccc3814a0ee42f34c1d19d1c6b3aacc22a35d87d8db24eca9f5892f31f"}, -] -dask-image = [ - {file = "dask-image-2021.12.0.tar.gz", hash = "sha256:35be49626bd01c3e3892128126a27d5ee3266a198a8e3c7e30d59eaef712fcf9"}, -] -datacube = [ - {file = "datacube-1.8.7-py2.py3-none-any.whl", hash = "sha256:82cb77fc8ddd167f949b84f893341823c6449fbb691cb297d876a6b6ceddd4a2"}, - {file = "datacube-1.8.7.tar.gz", hash = "sha256:ed90d171d53938217091e5ce256172090b71645a82751c79c4b4c721fa4065fc"}, -] -distributed = [ - {file = "distributed-2022.6.0-py3-none-any.whl", hash = "sha256:80c63a1ee3efb38c6f8634daaaa00f7992b246914a003202b687cedd6299b9c9"}, - {file = "distributed-2022.6.0.tar.gz", hash = "sha256:2050d7cf9479766a6f4ad9cf85e97dee548401a19f8bb97af6a73dda9ffd3d05"}, -] -equi7grid = [ - {file = "Equi7Grid-0.1.0.tar.gz", hash = "sha256:82cdedba3ad098be4dfb5ff5971262a1272c95b31b4a9f34e20469287cfe5203"}, -] -fiona = [ - {file = "Fiona-1.8.21-cp310-cp310-macosx_10_10_x86_64.whl", hash = "sha256:39c656421e25b4d0d73d0b6acdcbf9848e71f3d9b74f44c27d2d516d463409ae"}, - {file = "Fiona-1.8.21-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:43b1d2e45506e56cf3a9f59ba5d6f7981f3f75f4725d1e6cb9a33ba856371ebd"}, - {file = "Fiona-1.8.21-cp36-cp36m-macosx_10_10_x86_64.whl", hash = "sha256:315e186cb880a8128e110312eb92f5956bbc54d7152af999d3483b463758d6f9"}, - {file = "Fiona-1.8.21-cp36-cp36m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9fb2407623c4f44732a33b3f056f8c58c54152b51f0324bf8f10945e711eb549"}, - {file = "Fiona-1.8.21-cp37-cp37m-macosx_10_10_x86_64.whl", hash = "sha256:b69054ed810eb7339d7effa88589afca48003206d7627d0b0b149715fc3fde41"}, - {file = "Fiona-1.8.21-cp37-cp37m-manylinux2014_x86_64.whl", hash = "sha256:11532ccfda1073d3f5f558e4bb78d45b268e8680fd6e14993a394c564ddbd069"}, - {file = "Fiona-1.8.21-cp38-cp38-macosx_10_10_x86_64.whl", hash = "sha256:3789523c811809a6e2e170cf9c437631f959f4c7a868f024081612d30afab468"}, - {file = "Fiona-1.8.21-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:085f18d943097ac3396f3f9664ac1ae04ad0ff272f54829f03442187f01b6116"}, - {file = "Fiona-1.8.21-cp39-cp39-macosx_10_10_x86_64.whl", hash = "sha256:388acc9fa07ba7858d508dfe826d4b04d813818bced16c4049de19cc7ca322ef"}, - {file = "Fiona-1.8.21-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:40b4eaf5b88407421d6c9e707520abd2ff16d7cd43efb59cd398aa41d2de332c"}, - {file = "Fiona-1.8.21.tar.gz", hash = "sha256:3a0edca2a7a070db405d71187214a43d2333a57b4097544a3fcc282066a58bfc"}, -] -fsspec = [ - {file = "fsspec-2022.5.0-py3-none-any.whl", hash = "sha256:2c198c50eb541a80bbd03540b07602c4a957366f3fb416a1f270d34bd4ff0926"}, - {file = "fsspec-2022.5.0.tar.gz", hash = "sha256:7a5459c75c44e760fbe6a3ccb1f37e81e023cde7da8ba20401258d877ec483b4"}, -] -gdal = [ - {file = "GDAL-3.5.0.3.tar.gz", hash = "sha256:1fabe82220f1e7e146eabe7b58d568e19a27e883471edaa16070d72435ce96a1"}, -] -geographiclib = [ - {file = "geographiclib-2.0-py3-none-any.whl", hash = "sha256:6b7225248e45ff7edcee32becc4e0a1504c606ac5ee163a5656d482e0cd38734"}, - {file = "geographiclib-2.0.tar.gz", hash = "sha256:f7f41c85dc3e1c2d3d935ec86660dc3b2c848c83e17f9a9e51ba9d5146a15859"}, -] -geopandas = [ - {file = "geopandas-0.10.2-py2.py3-none-any.whl", hash = "sha256:1722853464441b603d9be3d35baf8bde43831424a891e82a8545eb8997b65d6c"}, - {file = "geopandas-0.10.2.tar.gz", hash = "sha256:efbf47e70732e25c3727222019c92b39b2e0a66ebe4fe379fbe1aa43a2a871db"}, -] -greenlet = [ - {file = "greenlet-1.1.2-cp27-cp27m-macosx_10_14_x86_64.whl", hash = "sha256:58df5c2a0e293bf665a51f8a100d3e9956febfbf1d9aaf8c0677cf70218910c6"}, - {file = "greenlet-1.1.2-cp27-cp27m-manylinux1_x86_64.whl", hash = "sha256:aec52725173bd3a7b56fe91bc56eccb26fbdff1386ef123abb63c84c5b43b63a"}, - {file = "greenlet-1.1.2-cp27-cp27m-manylinux2010_x86_64.whl", hash = "sha256:833e1551925ed51e6b44c800e71e77dacd7e49181fdc9ac9a0bf3714d515785d"}, - {file = "greenlet-1.1.2-cp27-cp27m-win32.whl", hash = "sha256:aa5b467f15e78b82257319aebc78dd2915e4c1436c3c0d1ad6f53e47ba6e2713"}, - {file = "greenlet-1.1.2-cp27-cp27m-win_amd64.whl", hash = "sha256:40b951f601af999a8bf2ce8c71e8aaa4e8c6f78ff8afae7b808aae2dc50d4c40"}, - {file = "greenlet-1.1.2-cp27-cp27mu-manylinux1_x86_64.whl", hash = "sha256:95e69877983ea39b7303570fa6760f81a3eec23d0e3ab2021b7144b94d06202d"}, - {file = "greenlet-1.1.2-cp27-cp27mu-manylinux2010_x86_64.whl", hash = "sha256:356b3576ad078c89a6107caa9c50cc14e98e3a6c4874a37c3e0273e4baf33de8"}, - {file = "greenlet-1.1.2-cp310-cp310-macosx_10_14_x86_64.whl", hash = "sha256:8639cadfda96737427330a094476d4c7a56ac03de7265622fcf4cfe57c8ae18d"}, - {file = "greenlet-1.1.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:97e5306482182170ade15c4b0d8386ded995a07d7cc2ca8f27958d34d6736497"}, - {file = "greenlet-1.1.2-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e6a36bb9474218c7a5b27ae476035497a6990e21d04c279884eb10d9b290f1b1"}, - {file = "greenlet-1.1.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:abb7a75ed8b968f3061327c433a0fbd17b729947b400747c334a9c29a9af6c58"}, - {file = "greenlet-1.1.2-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:b336501a05e13b616ef81ce329c0e09ac5ed8c732d9ba7e3e983fcc1a9e86965"}, - {file = "greenlet-1.1.2-cp310-cp310-win_amd64.whl", hash = "sha256:14d4f3cd4e8b524ae9b8aa567858beed70c392fdec26dbdb0a8a418392e71708"}, - {file = "greenlet-1.1.2-cp35-cp35m-macosx_10_14_x86_64.whl", hash = "sha256:17ff94e7a83aa8671a25bf5b59326ec26da379ace2ebc4411d690d80a7fbcf23"}, - {file = "greenlet-1.1.2-cp35-cp35m-manylinux1_x86_64.whl", hash = "sha256:9f3cba480d3deb69f6ee2c1825060177a22c7826431458c697df88e6aeb3caee"}, - {file = "greenlet-1.1.2-cp35-cp35m-manylinux2010_x86_64.whl", hash = "sha256:fa877ca7f6b48054f847b61d6fa7bed5cebb663ebc55e018fda12db09dcc664c"}, - {file = "greenlet-1.1.2-cp35-cp35m-win32.whl", hash = "sha256:7cbd7574ce8e138bda9df4efc6bf2ab8572c9aff640d8ecfece1b006b68da963"}, - {file = "greenlet-1.1.2-cp35-cp35m-win_amd64.whl", hash = "sha256:903bbd302a2378f984aef528f76d4c9b1748f318fe1294961c072bdc7f2ffa3e"}, - {file = "greenlet-1.1.2-cp36-cp36m-macosx_10_14_x86_64.whl", hash = "sha256:049fe7579230e44daef03a259faa24511d10ebfa44f69411d99e6a184fe68073"}, - {file = "greenlet-1.1.2-cp36-cp36m-manylinux1_x86_64.whl", hash = "sha256:dd0b1e9e891f69e7675ba5c92e28b90eaa045f6ab134ffe70b52e948aa175b3c"}, - {file = "greenlet-1.1.2-cp36-cp36m-manylinux2010_x86_64.whl", hash = "sha256:7418b6bfc7fe3331541b84bb2141c9baf1ec7132a7ecd9f375912eca810e714e"}, - {file = "greenlet-1.1.2-cp36-cp36m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f9d29ca8a77117315101425ec7ec2a47a22ccf59f5593378fc4077ac5b754fce"}, - {file = "greenlet-1.1.2-cp36-cp36m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:21915eb821a6b3d9d8eefdaf57d6c345b970ad722f856cd71739493ce003ad08"}, - {file = "greenlet-1.1.2-cp36-cp36m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:eff9d20417ff9dcb0d25e2defc2574d10b491bf2e693b4e491914738b7908168"}, - {file = "greenlet-1.1.2-cp36-cp36m-musllinux_1_1_x86_64.whl", hash = "sha256:b8c008de9d0daba7b6666aa5bbfdc23dcd78cafc33997c9b7741ff6353bafb7f"}, - {file = "greenlet-1.1.2-cp36-cp36m-win32.whl", hash = "sha256:32ca72bbc673adbcfecb935bb3fb1b74e663d10a4b241aaa2f5a75fe1d1f90aa"}, - {file = "greenlet-1.1.2-cp36-cp36m-win_amd64.whl", hash = "sha256:f0214eb2a23b85528310dad848ad2ac58e735612929c8072f6093f3585fd342d"}, - {file = "greenlet-1.1.2-cp37-cp37m-macosx_10_14_x86_64.whl", hash = "sha256:b92e29e58bef6d9cfd340c72b04d74c4b4e9f70c9fa7c78b674d1fec18896dc4"}, - {file = "greenlet-1.1.2-cp37-cp37m-manylinux1_x86_64.whl", hash = "sha256:fdcec0b8399108577ec290f55551d926d9a1fa6cad45882093a7a07ac5ec147b"}, - {file = "greenlet-1.1.2-cp37-cp37m-manylinux2010_x86_64.whl", hash = "sha256:93f81b134a165cc17123626ab8da2e30c0455441d4ab5576eed73a64c025b25c"}, - {file = "greenlet-1.1.2-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1e12bdc622676ce47ae9abbf455c189e442afdde8818d9da983085df6312e7a1"}, - {file = "greenlet-1.1.2-cp37-cp37m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8c790abda465726cfb8bb08bd4ca9a5d0a7bd77c7ac1ca1b839ad823b948ea28"}, - {file = "greenlet-1.1.2-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f276df9830dba7a333544bd41070e8175762a7ac20350786b322b714b0e654f5"}, - {file = "greenlet-1.1.2-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:8c5d5b35f789a030ebb95bff352f1d27a93d81069f2adb3182d99882e095cefe"}, - {file = "greenlet-1.1.2-cp37-cp37m-win32.whl", hash = "sha256:64e6175c2e53195278d7388c454e0b30997573f3f4bd63697f88d855f7a6a1fc"}, - {file = "greenlet-1.1.2-cp37-cp37m-win_amd64.whl", hash = "sha256:b11548073a2213d950c3f671aa88e6f83cda6e2fb97a8b6317b1b5b33d850e06"}, - {file = "greenlet-1.1.2-cp38-cp38-macosx_10_14_x86_64.whl", hash = "sha256:9633b3034d3d901f0a46b7939f8c4d64427dfba6bbc5a36b1a67364cf148a1b0"}, - {file = "greenlet-1.1.2-cp38-cp38-manylinux1_x86_64.whl", hash = "sha256:eb6ea6da4c787111adf40f697b4e58732ee0942b5d3bd8f435277643329ba627"}, - {file = "greenlet-1.1.2-cp38-cp38-manylinux2010_x86_64.whl", hash = "sha256:f3acda1924472472ddd60c29e5b9db0cec629fbe3c5c5accb74d6d6d14773478"}, - {file = "greenlet-1.1.2-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e859fcb4cbe93504ea18008d1df98dee4f7766db66c435e4882ab35cf70cac43"}, - {file = "greenlet-1.1.2-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:00e44c8afdbe5467e4f7b5851be223be68adb4272f44696ee71fe46b7036a711"}, - {file = "greenlet-1.1.2-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ec8c433b3ab0419100bd45b47c9c8551248a5aee30ca5e9d399a0b57ac04651b"}, - {file = "greenlet-1.1.2-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:2bde6792f313f4e918caabc46532aa64aa27a0db05d75b20edfc5c6f46479de2"}, - {file = "greenlet-1.1.2-cp38-cp38-win32.whl", hash = "sha256:288c6a76705dc54fba69fbcb59904ae4ad768b4c768839b8ca5fdadec6dd8cfd"}, - {file = "greenlet-1.1.2-cp38-cp38-win_amd64.whl", hash = "sha256:8d2f1fb53a421b410751887eb4ff21386d119ef9cde3797bf5e7ed49fb51a3b3"}, - {file = "greenlet-1.1.2-cp39-cp39-macosx_10_14_x86_64.whl", hash = "sha256:166eac03e48784a6a6e0e5f041cfebb1ab400b394db188c48b3a84737f505b67"}, - {file = "greenlet-1.1.2-cp39-cp39-manylinux1_x86_64.whl", hash = "sha256:572e1787d1460da79590bf44304abbc0a2da944ea64ec549188fa84d89bba7ab"}, - {file = "greenlet-1.1.2-cp39-cp39-manylinux2010_x86_64.whl", hash = "sha256:be5f425ff1f5f4b3c1e33ad64ab994eed12fc284a6ea71c5243fd564502ecbe5"}, - {file = "greenlet-1.1.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b1692f7d6bc45e3200844be0dba153612103db241691088626a33ff1f24a0d88"}, - {file = "greenlet-1.1.2-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:7227b47e73dedaa513cdebb98469705ef0d66eb5a1250144468e9c3097d6b59b"}, - {file = "greenlet-1.1.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7ff61ff178250f9bb3cd89752df0f1dd0e27316a8bd1465351652b1b4a4cdfd3"}, - {file = "greenlet-1.1.2-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:0051c6f1f27cb756ffc0ffbac7d2cd48cb0362ac1736871399a739b2885134d3"}, - {file = "greenlet-1.1.2-cp39-cp39-win32.whl", hash = "sha256:f70a9e237bb792c7cc7e44c531fd48f5897961701cdaa06cf22fc14965c496cf"}, - {file = "greenlet-1.1.2-cp39-cp39-win_amd64.whl", hash = "sha256:013d61294b6cd8fe3242932c1c5e36e5d1db2c8afb58606c5a67efce62c1f5fd"}, - {file = "greenlet-1.1.2.tar.gz", hash = "sha256:e30f5ea4ae2346e62cedde8794a56858a67b878dd79f7df76a0767e356b1744a"}, -] -heapdict = [ - {file = "HeapDict-1.0.1-py3-none-any.whl", hash = "sha256:6065f90933ab1bb7e50db403b90cab653c853690c5992e69294c2de2b253fc92"}, - {file = "HeapDict-1.0.1.tar.gz", hash = "sha256:8495f57b3e03d8e46d5f1b2cc62ca881aca392fd5cc048dc0aa2e1a6d23ecdb6"}, -] -imageio = [ - {file = "imageio-2.19.3-py3-none-any.whl", hash = "sha256:d36ab8616175a093676693a4dbc85c6cc767f981c9ce93041422569c76d06347"}, - {file = "imageio-2.19.3.tar.gz", hash = "sha256:0c9df80e42f2ee68bea92001e7fcf612aa149910efe040eb757f5ce323250ae1"}, -] -importlib-resources = [ - {file = "importlib_resources-5.8.0-py3-none-any.whl", hash = "sha256:7952325ffd516c05a8ad0858c74dff2c3343f136fe66a6002b2623dd1d43f223"}, - {file = "importlib_resources-5.8.0.tar.gz", hash = "sha256:568c9f16cb204f9decc8d6d24a572eeea27dacbb4cee9e6b03a8025736769751"}, -] -iniconfig = [ - {file = "iniconfig-1.1.1-py2.py3-none-any.whl", hash = "sha256:011e24c64b7f47f6ebd835bb12a743f2fbe9a26d4cecaa7f53bc4f35ee9da8b3"}, - {file = "iniconfig-1.1.1.tar.gz", hash = "sha256:bc3af051d7d14b2ee5ef9969666def0cd1a000e121eaea580d4a313df4b37f32"}, -] -jinja2 = [ - {file = "Jinja2-3.1.2-py3-none-any.whl", hash = "sha256:6088930bfe239f0e6710546ab9c19c9ef35e29792895fed6e6e31a023a182a61"}, - {file = "Jinja2-3.1.2.tar.gz", hash = "sha256:31351a702a408a9e7595a8fc6150fc3f43bb6bf7e319770cbc0db9df9437e852"}, -] -jsonschema = [ - {file = "jsonschema-4.6.0-py3-none-any.whl", hash = "sha256:1c92d2db1900b668201f1797887d66453ab1fbfea51df8e4b46236689c427baf"}, - {file = "jsonschema-4.6.0.tar.gz", hash = "sha256:9d6397ba4a6c0bf0300736057f649e3e12ecbc07d3e81a0dacb72de4e9801957"}, -] -lark-parser = [ - {file = "lark-parser-0.12.0.tar.gz", hash = "sha256:15967db1f1214013dca65b1180745047b9be457d73da224fcda3d9dd4e96a138"}, - {file = "lark_parser-0.12.0-py2.py3-none-any.whl", hash = "sha256:0eaf30cb5ba787fe404d73a7d6e61df97b21d5a63ac26c5008c78a494373c675"}, -] -locket = [ - {file = "locket-1.0.0-py2.py3-none-any.whl", hash = "sha256:b6c819a722f7b6bd955b80781788e4a66a55628b858d347536b7e81325a3a5e3"}, - {file = "locket-1.0.0.tar.gz", hash = "sha256:5c0d4c052a8bbbf750e056a8e65ccd309086f4f0f18a2eac306a8dfa4112a632"}, -] -markupsafe = [ - {file = "MarkupSafe-2.1.1-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:86b1f75c4e7c2ac2ccdaec2b9022845dbb81880ca318bb7a0a01fbf7813e3812"}, - {file = "MarkupSafe-2.1.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:f121a1420d4e173a5d96e47e9a0c0dcff965afdf1626d28de1460815f7c4ee7a"}, - {file = "MarkupSafe-2.1.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a49907dd8420c5685cfa064a1335b6754b74541bbb3706c259c02ed65b644b3e"}, - {file = "MarkupSafe-2.1.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:10c1bfff05d95783da83491be968e8fe789263689c02724e0c691933c52994f5"}, - {file = "MarkupSafe-2.1.1-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b7bd98b796e2b6553da7225aeb61f447f80a1ca64f41d83612e6139ca5213aa4"}, - {file = "MarkupSafe-2.1.1-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:b09bf97215625a311f669476f44b8b318b075847b49316d3e28c08e41a7a573f"}, - {file = "MarkupSafe-2.1.1-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:694deca8d702d5db21ec83983ce0bb4b26a578e71fbdbd4fdcd387daa90e4d5e"}, - {file = "MarkupSafe-2.1.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:efc1913fd2ca4f334418481c7e595c00aad186563bbc1ec76067848c7ca0a933"}, - {file = "MarkupSafe-2.1.1-cp310-cp310-win32.whl", hash = "sha256:4a33dea2b688b3190ee12bd7cfa29d39c9ed176bda40bfa11099a3ce5d3a7ac6"}, - {file = "MarkupSafe-2.1.1-cp310-cp310-win_amd64.whl", hash = "sha256:dda30ba7e87fbbb7eab1ec9f58678558fd9a6b8b853530e176eabd064da81417"}, - {file = "MarkupSafe-2.1.1-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:671cd1187ed5e62818414afe79ed29da836dde67166a9fac6d435873c44fdd02"}, - {file = "MarkupSafe-2.1.1-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3799351e2336dc91ea70b034983ee71cf2f9533cdff7c14c90ea126bfd95d65a"}, - {file = "MarkupSafe-2.1.1-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e72591e9ecd94d7feb70c1cbd7be7b3ebea3f548870aa91e2732960fa4d57a37"}, - {file = "MarkupSafe-2.1.1-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6fbf47b5d3728c6aea2abb0589b5d30459e369baa772e0f37a0320185e87c980"}, - {file = "MarkupSafe-2.1.1-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:d5ee4f386140395a2c818d149221149c54849dfcfcb9f1debfe07a8b8bd63f9a"}, - {file = "MarkupSafe-2.1.1-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:bcb3ed405ed3222f9904899563d6fc492ff75cce56cba05e32eff40e6acbeaa3"}, - {file = "MarkupSafe-2.1.1-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:e1c0b87e09fa55a220f058d1d49d3fb8df88fbfab58558f1198e08c1e1de842a"}, - {file = "MarkupSafe-2.1.1-cp37-cp37m-win32.whl", hash = "sha256:8dc1c72a69aa7e082593c4a203dcf94ddb74bb5c8a731e4e1eb68d031e8498ff"}, - {file = "MarkupSafe-2.1.1-cp37-cp37m-win_amd64.whl", hash = "sha256:97a68e6ada378df82bc9f16b800ab77cbf4b2fada0081794318520138c088e4a"}, - {file = "MarkupSafe-2.1.1-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:e8c843bbcda3a2f1e3c2ab25913c80a3c5376cd00c6e8c4a86a89a28c8dc5452"}, - {file = "MarkupSafe-2.1.1-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:0212a68688482dc52b2d45013df70d169f542b7394fc744c02a57374a4207003"}, - {file = "MarkupSafe-2.1.1-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8e576a51ad59e4bfaac456023a78f6b5e6e7651dcd383bcc3e18d06f9b55d6d1"}, - {file = "MarkupSafe-2.1.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4b9fe39a2ccc108a4accc2676e77da025ce383c108593d65cc909add5c3bd601"}, - {file = "MarkupSafe-2.1.1-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:96e37a3dc86e80bf81758c152fe66dbf60ed5eca3d26305edf01892257049925"}, - {file = "MarkupSafe-2.1.1-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:6d0072fea50feec76a4c418096652f2c3238eaa014b2f94aeb1d56a66b41403f"}, - {file = "MarkupSafe-2.1.1-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:089cf3dbf0cd6c100f02945abeb18484bd1ee57a079aefd52cffd17fba910b88"}, - {file = "MarkupSafe-2.1.1-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:6a074d34ee7a5ce3effbc526b7083ec9731bb3cbf921bbe1d3005d4d2bdb3a63"}, - {file = "MarkupSafe-2.1.1-cp38-cp38-win32.whl", hash = "sha256:421be9fbf0ffe9ffd7a378aafebbf6f4602d564d34be190fc19a193232fd12b1"}, - {file = "MarkupSafe-2.1.1-cp38-cp38-win_amd64.whl", hash = "sha256:fc7b548b17d238737688817ab67deebb30e8073c95749d55538ed473130ec0c7"}, - {file = "MarkupSafe-2.1.1-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:e04e26803c9c3851c931eac40c695602c6295b8d432cbe78609649ad9bd2da8a"}, - {file = "MarkupSafe-2.1.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:b87db4360013327109564f0e591bd2a3b318547bcef31b468a92ee504d07ae4f"}, - {file = "MarkupSafe-2.1.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:99a2a507ed3ac881b975a2976d59f38c19386d128e7a9a18b7df6fff1fd4c1d6"}, - {file = "MarkupSafe-2.1.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:56442863ed2b06d19c37f94d999035e15ee982988920e12a5b4ba29b62ad1f77"}, - {file = "MarkupSafe-2.1.1-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:3ce11ee3f23f79dbd06fb3d63e2f6af7b12db1d46932fe7bd8afa259a5996603"}, - {file = "MarkupSafe-2.1.1-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:33b74d289bd2f5e527beadcaa3f401e0df0a89927c1559c8566c066fa4248ab7"}, - {file = "MarkupSafe-2.1.1-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:43093fb83d8343aac0b1baa75516da6092f58f41200907ef92448ecab8825135"}, - {file = "MarkupSafe-2.1.1-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:8e3dcf21f367459434c18e71b2a9532d96547aef8a871872a5bd69a715c15f96"}, - {file = "MarkupSafe-2.1.1-cp39-cp39-win32.whl", hash = "sha256:d4306c36ca495956b6d568d276ac11fdd9c30a36f1b6eb928070dc5360b22e1c"}, - {file = "MarkupSafe-2.1.1-cp39-cp39-win_amd64.whl", hash = "sha256:46d00d6cfecdde84d40e572d63735ef81423ad31184100411e6e3388d405e247"}, - {file = "MarkupSafe-2.1.1.tar.gz", hash = "sha256:7f91197cc9e48f989d12e4e6fbc46495c446636dfc81b9ccf50bb0ec74b91d4b"}, -] -msgpack = [ - {file = "msgpack-1.0.4-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:4ab251d229d10498e9a2f3b1e68ef64cb393394ec477e3370c457f9430ce9250"}, - {file = "msgpack-1.0.4-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:112b0f93202d7c0fef0b7810d465fde23c746a2d482e1e2de2aafd2ce1492c88"}, - {file = "msgpack-1.0.4-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:002b5c72b6cd9b4bafd790f364b8480e859b4712e91f43014fe01e4f957b8467"}, - {file = "msgpack-1.0.4-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:35bc0faa494b0f1d851fd29129b2575b2e26d41d177caacd4206d81502d4c6a6"}, - {file = "msgpack-1.0.4-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4733359808c56d5d7756628736061c432ded018e7a1dff2d35a02439043321aa"}, - {file = "msgpack-1.0.4-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:eb514ad14edf07a1dbe63761fd30f89ae79b42625731e1ccf5e1f1092950eaa6"}, - {file = "msgpack-1.0.4-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:c23080fdeec4716aede32b4e0ef7e213c7b1093eede9ee010949f2a418ced6ba"}, - {file = "msgpack-1.0.4-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:49565b0e3d7896d9ea71d9095df15b7f75a035c49be733051c34762ca95bbf7e"}, - {file = "msgpack-1.0.4-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:aca0f1644d6b5a73eb3e74d4d64d5d8c6c3d577e753a04c9e9c87d07692c58db"}, - {file = "msgpack-1.0.4-cp310-cp310-win32.whl", hash = "sha256:0dfe3947db5fb9ce52aaea6ca28112a170db9eae75adf9339a1aec434dc954ef"}, - {file = "msgpack-1.0.4-cp310-cp310-win_amd64.whl", hash = "sha256:4dea20515f660aa6b7e964433b1808d098dcfcabbebeaaad240d11f909298075"}, - {file = "msgpack-1.0.4-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:e83f80a7fec1a62cf4e6c9a660e39c7f878f603737a0cdac8c13131d11d97f52"}, - {file = "msgpack-1.0.4-cp36-cp36m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3c11a48cf5e59026ad7cb0dc29e29a01b5a66a3e333dc11c04f7e991fc5510a9"}, - {file = "msgpack-1.0.4-cp36-cp36m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1276e8f34e139aeff1c77a3cefb295598b504ac5314d32c8c3d54d24fadb94c9"}, - {file = "msgpack-1.0.4-cp36-cp36m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6c9566f2c39ccced0a38d37c26cc3570983b97833c365a6044edef3574a00c08"}, - {file = "msgpack-1.0.4-cp36-cp36m-musllinux_1_1_aarch64.whl", hash = "sha256:fcb8a47f43acc113e24e910399376f7277cf8508b27e5b88499f053de6b115a8"}, - {file = "msgpack-1.0.4-cp36-cp36m-musllinux_1_1_i686.whl", hash = "sha256:76ee788122de3a68a02ed6f3a16bbcd97bc7c2e39bd4d94be2f1821e7c4a64e6"}, - {file = "msgpack-1.0.4-cp36-cp36m-musllinux_1_1_x86_64.whl", hash = "sha256:0a68d3ac0104e2d3510de90a1091720157c319ceeb90d74f7b5295a6bee51bae"}, - {file = "msgpack-1.0.4-cp36-cp36m-win32.whl", hash = "sha256:85f279d88d8e833ec015650fd15ae5eddce0791e1e8a59165318f371158efec6"}, - {file = "msgpack-1.0.4-cp36-cp36m-win_amd64.whl", hash = "sha256:c1683841cd4fa45ac427c18854c3ec3cd9b681694caf5bff04edb9387602d661"}, - {file = "msgpack-1.0.4-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:a75dfb03f8b06f4ab093dafe3ddcc2d633259e6c3f74bb1b01996f5d8aa5868c"}, - {file = "msgpack-1.0.4-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9667bdfdf523c40d2511f0e98a6c9d3603be6b371ae9a238b7ef2dc4e7a427b0"}, - {file = "msgpack-1.0.4-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:11184bc7e56fd74c00ead4f9cc9a3091d62ecb96e97653add7a879a14b003227"}, - {file = "msgpack-1.0.4-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ac5bd7901487c4a1dd51a8c58f2632b15d838d07ceedaa5e4c080f7190925bff"}, - {file = "msgpack-1.0.4-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:1e91d641d2bfe91ba4c52039adc5bccf27c335356055825c7f88742c8bb900dd"}, - {file = "msgpack-1.0.4-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:2a2df1b55a78eb5f5b7d2a4bb221cd8363913830145fad05374a80bf0877cb1e"}, - {file = "msgpack-1.0.4-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:545e3cf0cf74f3e48b470f68ed19551ae6f9722814ea969305794645da091236"}, - {file = "msgpack-1.0.4-cp37-cp37m-win32.whl", hash = "sha256:2cc5ca2712ac0003bcb625c96368fd08a0f86bbc1a5578802512d87bc592fe44"}, - {file = "msgpack-1.0.4-cp37-cp37m-win_amd64.whl", hash = "sha256:eba96145051ccec0ec86611fe9cf693ce55f2a3ce89c06ed307de0e085730ec1"}, - {file = "msgpack-1.0.4-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:7760f85956c415578c17edb39eed99f9181a48375b0d4a94076d84148cf67b2d"}, - {file = "msgpack-1.0.4-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:449e57cc1ff18d3b444eb554e44613cffcccb32805d16726a5494038c3b93dab"}, - {file = "msgpack-1.0.4-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:d603de2b8d2ea3f3bcb2efe286849aa7a81531abc52d8454da12f46235092bcb"}, - {file = "msgpack-1.0.4-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:48f5d88c99f64c456413d74a975bd605a9b0526293218a3b77220a2c15458ba9"}, - {file = "msgpack-1.0.4-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6916c78f33602ecf0509cc40379271ba0f9ab572b066bd4bdafd7434dee4bc6e"}, - {file = "msgpack-1.0.4-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:81fc7ba725464651190b196f3cd848e8553d4d510114a954681fd0b9c479d7e1"}, - {file = "msgpack-1.0.4-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:d5b5b962221fa2c5d3a7f8133f9abffc114fe218eb4365e40f17732ade576c8e"}, - {file = "msgpack-1.0.4-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:77ccd2af37f3db0ea59fb280fa2165bf1b096510ba9fe0cc2bf8fa92a22fdb43"}, - {file = "msgpack-1.0.4-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:b17be2478b622939e39b816e0aa8242611cc8d3583d1cd8ec31b249f04623243"}, - {file = "msgpack-1.0.4-cp38-cp38-win32.whl", hash = "sha256:2bb8cdf50dd623392fa75525cce44a65a12a00c98e1e37bf0fb08ddce2ff60d2"}, - {file = "msgpack-1.0.4-cp38-cp38-win_amd64.whl", hash = "sha256:26b8feaca40a90cbe031b03d82b2898bf560027160d3eae1423f4a67654ec5d6"}, - {file = "msgpack-1.0.4-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:462497af5fd4e0edbb1559c352ad84f6c577ffbbb708566a0abaaa84acd9f3ae"}, - {file = "msgpack-1.0.4-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:2999623886c5c02deefe156e8f869c3b0aaeba14bfc50aa2486a0415178fce55"}, - {file = "msgpack-1.0.4-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:f0029245c51fd9473dc1aede1160b0a29f4a912e6b1dd353fa6d317085b219da"}, - {file = "msgpack-1.0.4-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ed6f7b854a823ea44cf94919ba3f727e230da29feb4a99711433f25800cf747f"}, - {file = "msgpack-1.0.4-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0df96d6eaf45ceca04b3f3b4b111b86b33785683d682c655063ef8057d61fd92"}, - {file = "msgpack-1.0.4-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6a4192b1ab40f8dca3f2877b70e63799d95c62c068c84dc028b40a6cb03ccd0f"}, - {file = "msgpack-1.0.4-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:0e3590f9fb9f7fbc36df366267870e77269c03172d086fa76bb4eba8b2b46624"}, - {file = "msgpack-1.0.4-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:1576bd97527a93c44fa856770197dec00d223b0b9f36ef03f65bac60197cedf8"}, - {file = "msgpack-1.0.4-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:63e29d6e8c9ca22b21846234913c3466b7e4ee6e422f205a2988083de3b08cae"}, - {file = "msgpack-1.0.4-cp39-cp39-win32.whl", hash = "sha256:fb62ea4b62bfcb0b380d5680f9a4b3f9a2d166d9394e9bbd9666c0ee09a3645c"}, - {file = "msgpack-1.0.4-cp39-cp39-win_amd64.whl", hash = "sha256:4d5834a2a48965a349da1c5a79760d94a1a0172fbb5ab6b5b33cbf8447e109ce"}, - {file = "msgpack-1.0.4.tar.gz", hash = "sha256:f5d869c18f030202eb412f08b28d2afeea553d6613aee89e200d7aca7ef01f5f"}, -] -munch = [ - {file = "munch-2.5.0-py2.py3-none-any.whl", hash = "sha256:6f44af89a2ce4ed04ff8de41f70b226b984db10a91dcc7b9ac2efc1c77022fdd"}, - {file = "munch-2.5.0.tar.gz", hash = "sha256:2d735f6f24d4dba3417fa448cae40c6e896ec1fdab6cdb5e6510999758a4dbd2"}, -] -mypy = [ - {file = "mypy-0.961-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:697540876638ce349b01b6786bc6094ccdaba88af446a9abb967293ce6eaa2b0"}, - {file = "mypy-0.961-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:b117650592e1782819829605a193360a08aa99f1fc23d1d71e1a75a142dc7e15"}, - {file = "mypy-0.961-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:bdd5ca340beffb8c44cb9dc26697628d1b88c6bddf5c2f6eb308c46f269bb6f3"}, - {file = "mypy-0.961-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:3e09f1f983a71d0672bbc97ae33ee3709d10c779beb613febc36805a6e28bb4e"}, - {file = "mypy-0.961-cp310-cp310-win_amd64.whl", hash = "sha256:e999229b9f3198c0c880d5e269f9f8129c8862451ce53a011326cad38b9ccd24"}, - {file = "mypy-0.961-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:b24be97351084b11582fef18d79004b3e4db572219deee0212078f7cf6352723"}, - {file = "mypy-0.961-cp36-cp36m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:f4a21d01fc0ba4e31d82f0fff195682e29f9401a8bdb7173891070eb260aeb3b"}, - {file = "mypy-0.961-cp36-cp36m-win_amd64.whl", hash = "sha256:439c726a3b3da7ca84a0199a8ab444cd8896d95012c4a6c4a0d808e3147abf5d"}, - {file = "mypy-0.961-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:5a0b53747f713f490affdceef835d8f0cb7285187a6a44c33821b6d1f46ed813"}, - {file = "mypy-0.961-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:0e9f70df36405c25cc530a86eeda1e0867863d9471fe76d1273c783df3d35c2e"}, - {file = "mypy-0.961-cp37-cp37m-win_amd64.whl", hash = "sha256:b88f784e9e35dcaa075519096dc947a388319cb86811b6af621e3523980f1c8a"}, - {file = "mypy-0.961-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:d5aaf1edaa7692490f72bdb9fbd941fbf2e201713523bdb3f4038be0af8846c6"}, - {file = "mypy-0.961-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:9f5f5a74085d9a81a1f9c78081d60a0040c3efb3f28e5c9912b900adf59a16e6"}, - {file = "mypy-0.961-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:f4b794db44168a4fc886e3450201365c9526a522c46ba089b55e1f11c163750d"}, - {file = "mypy-0.961-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:64759a273d590040a592e0f4186539858c948302c653c2eac840c7a3cd29e51b"}, - {file = "mypy-0.961-cp38-cp38-win_amd64.whl", hash = "sha256:63e85a03770ebf403291ec50097954cc5caf2a9205c888ce3a61bd3f82e17569"}, - {file = "mypy-0.961-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:5f1332964963d4832a94bebc10f13d3279be3ce8f6c64da563d6ee6e2eeda932"}, - {file = "mypy-0.961-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:006be38474216b833eca29ff6b73e143386f352e10e9c2fbe76aa8549e5554f5"}, - {file = "mypy-0.961-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:9940e6916ed9371809b35b2154baf1f684acba935cd09928952310fbddaba648"}, - {file = "mypy-0.961-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:a5ea0875a049de1b63b972456542f04643daf320d27dc592d7c3d9cd5d9bf950"}, - {file = "mypy-0.961-cp39-cp39-win_amd64.whl", hash = "sha256:1ece702f29270ec6af25db8cf6185c04c02311c6bb21a69f423d40e527b75c56"}, - {file = "mypy-0.961-py3-none-any.whl", hash = "sha256:03c6cc893e7563e7b2949b969e63f02c000b32502a1b4d1314cabe391aa87d66"}, - {file = "mypy-0.961.tar.gz", hash = "sha256:f730d56cb924d371c26b8eaddeea3cc07d78ff51c521c6d04899ac6904b75492"}, -] -mypy-extensions = [ - {file = "mypy_extensions-0.4.3-py2.py3-none-any.whl", hash = "sha256:090fedd75945a69ae91ce1303b5824f428daf5a028d2f6ab8a299250a846f15d"}, - {file = "mypy_extensions-0.4.3.tar.gz", hash = "sha256:2d82818f5bb3e369420cb3c4060a7970edba416647068eb4c5343488a6c604a8"}, -] -netcdf4 = [ - {file = "netCDF4-1.5.8-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:fd501ccb28ebae6770112968c750a14feb39cb495d788aa67c28360f7c1f2324"}, - {file = "netCDF4-1.5.8-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:18e257843fc29846909557a9502a29e37b381ee7760923f9280d3b26d844db8c"}, - {file = "netCDF4-1.5.8-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:8b4fac95819b0c17ca5fc1a4e8bb31116b6b808cceca0aa8b475bb50abab1063"}, - {file = "netCDF4-1.5.8-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e118bfccda464a381187b1f9c771bf9581c83c566faab309a8ec3f781668da4e"}, - {file = "netCDF4-1.5.8-cp310-cp310-win32.whl", hash = "sha256:bdba6ea34680a4c1b7018a4a7155f6112acd063289923c0c61918707e9f26910"}, - {file = "netCDF4-1.5.8-cp310-cp310-win_amd64.whl", hash = "sha256:339e534057be0b1998f80faeb8f9851f28b42cee5a6047e1adf12c0e38235437"}, - {file = "netCDF4-1.5.8-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:804d312a10e6fb196df16bf0d811624d885a51b7ebb3bc648278faa62ffece26"}, - {file = "netCDF4-1.5.8-cp36-cp36m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1442048c93ac668d61d1675a0b0f3aea3a73efa2969636af0cb95a52d119acec"}, - {file = "netCDF4-1.5.8-cp36-cp36m-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f5e9e1ca99aca1f6d40054ef42b97cf6d00c59d8a438f580cf9dfc309a8eb870"}, - {file = "netCDF4-1.5.8-cp36-cp36m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7519c1e8ad8d3d72636a0aedb5d79bb90556037a59d83811e2057f09ca272b52"}, - {file = "netCDF4-1.5.8-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:0774309a8b684654c0bbd4d55bcccaa399ffa6870b5dc2e35dbe919ec637a51f"}, - {file = "netCDF4-1.5.8-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a9ba575047ba1be7cf5f1b712c987ce329b4d092582d92c2e268296a06bfa639"}, - {file = "netCDF4-1.5.8-cp37-cp37m-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b2b0f370cda5cc5f46239e0a219bf8d4cf442c7d49dbd1c89abb39e71e266c60"}, - {file = "netCDF4-1.5.8-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:29426faabdc017e89572ff1d7835dab426aae4c22ad1a12d1877b932e969b6ac"}, - {file = "netCDF4-1.5.8-cp37-cp37m-win32.whl", hash = "sha256:225d17f7a487ebdab99640294203b61e39e01c951b4e6a4f578d8251623f5f5a"}, - {file = "netCDF4-1.5.8-cp37-cp37m-win_amd64.whl", hash = "sha256:f86399073b582bccd278006ee0213548e7037395e1119f1af9f4faad38279b1e"}, - {file = "netCDF4-1.5.8-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:0a33a953b60ee30dcb78db174231f7ab61923331af9645f84adff684e9add4e2"}, - {file = "netCDF4-1.5.8-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:f92b92f758dfc903af2a8a287fd68a531f73ffd3e5be72b5ad1eb3f083e7aaa2"}, - {file = "netCDF4-1.5.8-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:b21af57acca0d70c5401f8f779409ab4e818c505fb81706eea8d9475e1f0bb9b"}, - {file = "netCDF4-1.5.8-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7326afa46fd0c1b50d30db9764a1eefbcff576fcffa8e48bef403094590563b8"}, - {file = "netCDF4-1.5.8-cp38-cp38-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:916434a13ea317934cf248fb70dd5476c498f1def71041fc7e3fd23882ef2cda"}, - {file = "netCDF4-1.5.8-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:75ecf1ef2c841aace539f3326d101efda7c99f6c3283c48a444370aba48525af"}, - {file = "netCDF4-1.5.8-cp38-cp38-win32.whl", hash = "sha256:bd35c37342d9051d2b8fb12a9208856cc59201a94c78a742a198c81813cb00a8"}, - {file = "netCDF4-1.5.8-cp38-cp38-win_amd64.whl", hash = "sha256:bdd344d8de65849fa200f69941f1b15a2611b11b307161ce2fd8ff42148507e8"}, - {file = "netCDF4-1.5.8-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:06f7364086fd3ae097e757d2493dc1fe006e9ae9636a109a1e4c914db05d7e18"}, - {file = "netCDF4-1.5.8-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:0f570b5b4cc0434ef8a2a648fdebfa017de695ea7c836b24ae7b216ede4e3345"}, - {file = "netCDF4-1.5.8-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:db02d42f7b9c7d68cec351ea63ef3fc2a1ad5e7e74fc7b570b34ceb8c7645bf2"}, - {file = "netCDF4-1.5.8-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5c883a02c55fd1e5b61ad4f83dd7f11f90b894e14d120ba678d9c33d9e4b3a77"}, - {file = "netCDF4-1.5.8-cp39-cp39-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d784d6cf5baa90909f385bf60ead91138f13ff7f870467e458fb3650ef71b48d"}, - {file = "netCDF4-1.5.8-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:49a44c7382e5e1da39d8bab5d8e406ad30d46fda9386e85a3e69491e6caaca93"}, - {file = "netCDF4-1.5.8-cp39-cp39-win32.whl", hash = "sha256:cdb54afe51c1b06e900c0df5e8567d713ff7a26bf087116a88a99858345dadc6"}, - {file = "netCDF4-1.5.8-cp39-cp39-win_amd64.whl", hash = "sha256:318ef7dd29b365f3921f9b359ba54f62cfe3aa46ab4464f45c43624d15c4bf55"}, - {file = "netCDF4-1.5.8.tar.gz", hash = "sha256:ca3d468f4812c0999df86e3f428851fb0c17ac34ce0827115c246b0b690e4e84"}, -] -networkx = [ - {file = "networkx-2.8.4-py3-none-any.whl", hash = "sha256:6933b9b3174a0bdf03c911bb4a1ee43a86ce3edeb813e37e1d4c553b3f4a2c4f"}, - {file = "networkx-2.8.4.tar.gz", hash = "sha256:5e53f027c0d567cf1f884dbb283224df525644e43afd1145d64c9d88a3584762"}, -] -numexpr = [ - {file = "numexpr-2.8.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:d148e99483e15de22d0acd5100136d39a336e91c8f8d37bf2e84e9f0ab4c0610"}, - {file = "numexpr-2.8.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ebf31aeed426840aefe1e94c89bb0b7530a72be36444ed4c73e4411865b79be5"}, - {file = "numexpr-2.8.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:3bab5add6628fa8bb66fba7b1f0eed5d8d0ce05fdd2dcc326dde8a297a961c46"}, - {file = "numexpr-2.8.1-cp310-cp310-win32.whl", hash = "sha256:79ec94295aa57f5a9d212116bb7359744cd2f9e05d477df0dee383b7f44b9588"}, - {file = "numexpr-2.8.1-cp310-cp310-win_amd64.whl", hash = "sha256:cfd89f63028f8df3c9b11bf2c98085184f967a09f543a77c3335f4a0ec54f124"}, - {file = "numexpr-2.8.1-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:517f299c4bc8491b5117aa276e8f3cf7ee2e89223922e92e2ea78a32985d5087"}, - {file = "numexpr-2.8.1-cp36-cp36m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a9f046cb5752f08a9291dc1fd37a9cfd15770262188bb984e4418490fef9c9ec"}, - {file = "numexpr-2.8.1-cp36-cp36m-musllinux_1_1_x86_64.whl", hash = "sha256:6bce8a183afe157c25385d27be314be22f06ba644c89b611d20e2570a06bd5dd"}, - {file = "numexpr-2.8.1-cp36-cp36m-win32.whl", hash = "sha256:1639561d056d2d790a56ddab7e7df40b6181ad50338b50fba94aa42874a00958"}, - {file = "numexpr-2.8.1-cp36-cp36m-win_amd64.whl", hash = "sha256:a97a087a5f5e56cd81c69215918fdaca60eb478a099daa757455e4ff887f7600"}, - {file = "numexpr-2.8.1-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:bd402e43b8baf6436b7c2c14541f69eb4f97f023469585a7ad258c49622ff619"}, - {file = "numexpr-2.8.1-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:48258db3ba89ad028744e07b09dde963f82da7f081849d3a003bb0b96b112d4f"}, - {file = "numexpr-2.8.1-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:4eb79d9026f013cf8d16de8be74911c74c0c09362627bf4b39e2b7f1f3188c28"}, - {file = "numexpr-2.8.1-cp37-cp37m-win32.whl", hash = "sha256:fd6905bc80a11908e363c9821cbf8aeeca4dca5b6a2eea90a97b055bc73443e6"}, - {file = "numexpr-2.8.1-cp37-cp37m-win_amd64.whl", hash = "sha256:da180aaec7f6c387540b251f6ec2b8d280220c0e45731778853c8b0d86c4ae22"}, - {file = "numexpr-2.8.1-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:b57d3ab7054409d9b4d2148241ae70d738c0b0daeb1a0efd5ea89b9279752e22"}, - {file = "numexpr-2.8.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d7b64b125161e722c9dc8a27df282e755bd9a5adf826b2e3e1f038e3dfdc3307"}, - {file = "numexpr-2.8.1-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:a591f99ecbb413749725e8da4e52e663f0939dd5fbf1ae5a7c6c50ba734f57de"}, - {file = "numexpr-2.8.1-cp38-cp38-win32.whl", hash = "sha256:80db25e2934fd1a1b787440d5fa7946adb79a1289d7dc64e2c8bcd6ceae660ad"}, - {file = "numexpr-2.8.1-cp38-cp38-win_amd64.whl", hash = "sha256:d2b4b6379763ec5d794d4aaa1834ae00f1bba82a36d0b99c6e2d559302a21e85"}, - {file = "numexpr-2.8.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:ab6b2cb64bc9391f77f08203fda5af3647ed2abcefb928cc6282727854f97735"}, - {file = "numexpr-2.8.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2247d92da60b85de619e797e59a80e9c7302fba82dcd0525de8f7dd729a0d60f"}, - {file = "numexpr-2.8.1-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:5d0c98c4d8bcc25962e5859176e5728f69209cffb9b7f64bf6d1c801fe350946"}, - {file = "numexpr-2.8.1-cp39-cp39-win32.whl", hash = "sha256:24fb5b2c17273a76e7de9cea7817c54262198657998a093fceb4030f273524c7"}, - {file = "numexpr-2.8.1-cp39-cp39-win_amd64.whl", hash = "sha256:920c6a3088790573765e103e20592864977aa4b4d1b819c298fa9d88771cde1b"}, - {file = "numexpr-2.8.1.tar.gz", hash = "sha256:cd779aa44dd986c4ef10163519239602b027be06a527946656207acf1f58113b"}, -] -numpy = [ - {file = "numpy-1.23.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:58bfd40eb478f54ff7a5710dd61c8097e169bc36cc68333d00a9bcd8def53b38"}, - {file = "numpy-1.23.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:196cd074c3f97c4121601790955f915187736f9cf458d3ee1f1b46aff2b1ade0"}, - {file = "numpy-1.23.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f1d88ef79e0a7fa631bb2c3dda1ea46b32b1fe614e10fedd611d3d5398447f2f"}, - {file = "numpy-1.23.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d54b3b828d618a19779a84c3ad952e96e2c2311b16384e973e671aa5be1f6187"}, - {file = "numpy-1.23.0-cp310-cp310-win32.whl", hash = "sha256:2b2da66582f3a69c8ce25ed7921dcd8010d05e59ac8d89d126a299be60421171"}, - {file = "numpy-1.23.0-cp310-cp310-win_amd64.whl", hash = "sha256:97a76604d9b0e79f59baeca16593c711fddb44936e40310f78bfef79ee9a835f"}, - {file = "numpy-1.23.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:d8cc87bed09de55477dba9da370c1679bd534df9baa171dd01accbb09687dac3"}, - {file = "numpy-1.23.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:f0f18804df7370571fb65db9b98bf1378172bd4e962482b857e612d1fec0f53e"}, - {file = "numpy-1.23.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ac86f407873b952679f5f9e6c0612687e51547af0e14ddea1eedfcb22466babd"}, - {file = "numpy-1.23.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ae8adff4172692ce56233db04b7ce5792186f179c415c37d539c25de7298d25d"}, - {file = "numpy-1.23.0-cp38-cp38-win32.whl", hash = "sha256:fe8b9683eb26d2c4d5db32cd29b38fdcf8381324ab48313b5b69088e0e355379"}, - {file = "numpy-1.23.0-cp38-cp38-win_amd64.whl", hash = "sha256:5043bcd71fcc458dfb8a0fc5509bbc979da0131b9d08e3d5f50fb0bbb36f169a"}, - {file = "numpy-1.23.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:1c29b44905af288b3919803aceb6ec7fec77406d8b08aaa2e8b9e63d0fe2f160"}, - {file = "numpy-1.23.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:98e8e0d8d69ff4d3fa63e6c61e8cfe2d03c29b16b58dbef1f9baa175bbed7860"}, - {file = "numpy-1.23.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:79a506cacf2be3a74ead5467aee97b81fca00c9c4c8b3ba16dbab488cd99ba10"}, - {file = "numpy-1.23.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:092f5e6025813e64ad6d1b52b519165d08c730d099c114a9247c9bb635a2a450"}, - {file = "numpy-1.23.0-cp39-cp39-win32.whl", hash = "sha256:d6ca8dabe696c2785d0c8c9b0d8a9b6e5fdbe4f922bde70d57fa1a2848134f95"}, - {file = "numpy-1.23.0-cp39-cp39-win_amd64.whl", hash = "sha256:fc431493df245f3c627c0c05c2bd134535e7929dbe2e602b80e42bf52ff760bc"}, - {file = "numpy-1.23.0-pp38-pypy38_pp73-macosx_10_9_x86_64.whl", hash = "sha256:f9c3fc2adf67762c9fe1849c859942d23f8d3e0bee7b5ed3d4a9c3eeb50a2f07"}, - {file = "numpy-1.23.0-pp38-pypy38_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d0d2094e8f4d760500394d77b383a1b06d3663e8892cdf5df3c592f55f3bff66"}, - {file = "numpy-1.23.0-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:94b170b4fa0168cd6be4becf37cb5b127bd12a795123984385b8cd4aca9857e5"}, - {file = "numpy-1.23.0.tar.gz", hash = "sha256:bd3fa4fe2e38533d5336e1272fc4e765cabbbde144309ccee8675509d5cd7b05"}, -] -odc-algo = [ - {file = "odc-algo-0.2.2.tar.gz", hash = "sha256:b48a2cd98a5cb0ac6d4f2cd81f69c9fca876a53e84ee99b9178efb36a3d271b2"}, - {file = "odc_algo-0.2.2-py3-none-any.whl", hash = "sha256:0253f7739606c987db42adfb6488b95550a74976de33b52276ec8e0350765fe3"}, -] -packaging = [ - {file = "packaging-21.3-py3-none-any.whl", hash = "sha256:ef103e05f519cdc783ae24ea4e2e0f508a9c99b2d4969652eed6a2e1ea5bd522"}, - {file = "packaging-21.3.tar.gz", hash = "sha256:dd47c42927d89ab911e606518907cc2d3a1f38bbd026385970643f9c5b8ecfeb"}, -] -pandas = [ - {file = "pandas-1.4.3-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:d51674ed8e2551ef7773820ef5dab9322be0828629f2cbf8d1fc31a0c4fed640"}, - {file = "pandas-1.4.3-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:16ad23db55efcc93fa878f7837267973b61ea85d244fc5ff0ccbcfa5638706c5"}, - {file = "pandas-1.4.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:958a0588149190c22cdebbc0797e01972950c927a11a900fe6c2296f207b1d6f"}, - {file = "pandas-1.4.3-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e48fbb64165cda451c06a0f9e4c7a16b534fcabd32546d531b3c240ce2844112"}, - {file = "pandas-1.4.3-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6f803320c9da732cc79210d7e8cc5c8019aad512589c910c66529eb1b1818230"}, - {file = "pandas-1.4.3-cp310-cp310-win_amd64.whl", hash = "sha256:2893e923472a5e090c2d5e8db83e8f907364ec048572084c7d10ef93546be6d1"}, - {file = "pandas-1.4.3-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:24ea75f47bbd5574675dae21d51779a4948715416413b30614c1e8b480909f81"}, - {file = "pandas-1.4.3-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:d5ebc990bd34f4ac3c73a2724c2dcc9ee7bf1ce6cf08e87bb25c6ad33507e318"}, - {file = "pandas-1.4.3-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:d6c0106415ff1a10c326c49bc5dd9ea8b9897a6ca0c8688eb9c30ddec49535ef"}, - {file = "pandas-1.4.3-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:78b00429161ccb0da252229bcda8010b445c4bf924e721265bec5a6e96a92e92"}, - {file = "pandas-1.4.3-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6dfbf16b1ea4f4d0ee11084d9c026340514d1d30270eaa82a9f1297b6c8ecbf0"}, - {file = "pandas-1.4.3-cp38-cp38-win32.whl", hash = "sha256:48350592665ea3cbcd07efc8c12ff12d89be09cd47231c7925e3b8afada9d50d"}, - {file = "pandas-1.4.3-cp38-cp38-win_amd64.whl", hash = "sha256:605d572126eb4ab2eadf5c59d5d69f0608df2bf7bcad5c5880a47a20a0699e3e"}, - {file = "pandas-1.4.3-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:a3924692160e3d847e18702bb048dc38e0e13411d2b503fecb1adf0fcf950ba4"}, - {file = "pandas-1.4.3-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:07238a58d7cbc8a004855ade7b75bbd22c0db4b0ffccc721556bab8a095515f6"}, - {file = "pandas-1.4.3-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:755679c49460bd0d2f837ab99f0a26948e68fa0718b7e42afbabd074d945bf84"}, - {file = "pandas-1.4.3-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:41fc406e374590a3d492325b889a2686b31e7a7780bec83db2512988550dadbf"}, - {file = "pandas-1.4.3-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1d9382f72a4f0e93909feece6fef5500e838ce1c355a581b3d8f259839f2ea76"}, - {file = "pandas-1.4.3-cp39-cp39-win32.whl", hash = "sha256:0daf876dba6c622154b2e6741f29e87161f844e64f84801554f879d27ba63c0d"}, - {file = "pandas-1.4.3-cp39-cp39-win_amd64.whl", hash = "sha256:721a3dd2f06ef942f83a819c0f3f6a648b2830b191a72bbe9451bcd49c3bd42e"}, - {file = "pandas-1.4.3.tar.gz", hash = "sha256:2ff7788468e75917574f080cd4681b27e1a7bf36461fe968b49a87b5a54d007c"}, -] -partd = [ - {file = "partd-1.2.0-py3-none-any.whl", hash = "sha256:5c3a5d70da89485c27916328dc1e26232d0e270771bd4caef4a5124b6a457288"}, - {file = "partd-1.2.0.tar.gz", hash = "sha256:aa67897b84d522dcbc86a98b942afab8c6aa2f7f677d904a616b74ef5ddbc3eb"}, -] -pillow = [ - {file = "Pillow-9.1.1-cp310-cp310-macosx_10_10_x86_64.whl", hash = "sha256:42dfefbef90eb67c10c45a73a9bc1599d4dac920f7dfcbf4ec6b80cb620757fe"}, - {file = "Pillow-9.1.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:ffde4c6fabb52891d81606411cbfaf77756e3b561b566efd270b3ed3791fde4e"}, - {file = "Pillow-9.1.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9c857532c719fb30fafabd2371ce9b7031812ff3889d75273827633bca0c4602"}, - {file = "Pillow-9.1.1-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:59789a7d06c742e9d13b883d5e3569188c16acb02eeed2510fd3bfdbc1bd1530"}, - {file = "Pillow-9.1.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4d45dbe4b21a9679c3e8b3f7f4f42a45a7d3ddff8a4a16109dff0e1da30a35b2"}, - {file = "Pillow-9.1.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:e9ed59d1b6ee837f4515b9584f3d26cf0388b742a11ecdae0d9237a94505d03a"}, - {file = "Pillow-9.1.1-cp310-cp310-win32.whl", hash = "sha256:b3fe2ff1e1715d4475d7e2c3e8dabd7c025f4410f79513b4ff2de3d51ce0fa9c"}, - {file = "Pillow-9.1.1-cp310-cp310-win_amd64.whl", hash = "sha256:5b650dbbc0969a4e226d98a0b440c2f07a850896aed9266b6fedc0f7e7834108"}, - {file = "Pillow-9.1.1-cp37-cp37m-macosx_10_10_x86_64.whl", hash = "sha256:0b4d5ad2cd3a1f0d1df882d926b37dbb2ab6c823ae21d041b46910c8f8cd844b"}, - {file = "Pillow-9.1.1-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9370d6744d379f2de5d7fa95cdbd3a4d92f0b0ef29609b4b1687f16bc197063d"}, - {file = "Pillow-9.1.1-cp37-cp37m-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b761727ed7d593e49671d1827044b942dd2f4caae6e51bab144d4accf8244a84"}, - {file = "Pillow-9.1.1-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8a66fe50386162df2da701b3722781cbe90ce043e7d53c1fd6bd801bca6b48d4"}, - {file = "Pillow-9.1.1-cp37-cp37m-win32.whl", hash = "sha256:2b291cab8a888658d72b575a03e340509b6b050b62db1f5539dd5cd18fd50578"}, - {file = "Pillow-9.1.1-cp37-cp37m-win_amd64.whl", hash = "sha256:1d4331aeb12f6b3791911a6da82de72257a99ad99726ed6b63f481c0184b6fb9"}, - {file = "Pillow-9.1.1-cp38-cp38-macosx_10_10_x86_64.whl", hash = "sha256:8844217cdf66eabe39567118f229e275f0727e9195635a15e0e4b9227458daaf"}, - {file = "Pillow-9.1.1-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:b6617221ff08fbd3b7a811950b5c3f9367f6e941b86259843eab77c8e3d2b56b"}, - {file = "Pillow-9.1.1-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:20d514c989fa28e73a5adbddd7a171afa5824710d0ab06d4e1234195d2a2e546"}, - {file = "Pillow-9.1.1-cp38-cp38-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:088df396b047477dd1bbc7de6e22f58400dae2f21310d9e2ec2933b2ef7dfa4f"}, - {file = "Pillow-9.1.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:53c27bd452e0f1bc4bfed07ceb235663a1df7c74df08e37fd6b03eb89454946a"}, - {file = "Pillow-9.1.1-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:3f6c1716c473ebd1649663bf3b42702d0d53e27af8b64642be0dd3598c761fb1"}, - {file = "Pillow-9.1.1-cp38-cp38-win32.whl", hash = "sha256:c67db410508b9de9c4694c57ed754b65a460e4812126e87f5052ecf23a011a54"}, - {file = "Pillow-9.1.1-cp38-cp38-win_amd64.whl", hash = "sha256:f054b020c4d7e9786ae0404278ea318768eb123403b18453e28e47cdb7a0a4bf"}, - {file = "Pillow-9.1.1-cp39-cp39-macosx_10_10_x86_64.whl", hash = "sha256:c17770a62a71718a74b7548098a74cd6880be16bcfff5f937f900ead90ca8e92"}, - {file = "Pillow-9.1.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:f3f6a6034140e9e17e9abc175fc7a266a6e63652028e157750bd98e804a8ed9a"}, - {file = "Pillow-9.1.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f372d0f08eff1475ef426344efe42493f71f377ec52237bf153c5713de987251"}, - {file = "Pillow-9.1.1-cp39-cp39-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:09e67ef6e430f90caa093528bd758b0616f8165e57ed8d8ce014ae32df6a831d"}, - {file = "Pillow-9.1.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:66daa16952d5bf0c9d5389c5e9df562922a59bd16d77e2a276e575d32e38afd1"}, - {file = "Pillow-9.1.1-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:d78ca526a559fb84faaaf84da2dd4addef5edb109db8b81677c0bb1aad342601"}, - {file = "Pillow-9.1.1-cp39-cp39-win32.whl", hash = "sha256:55e74faf8359ddda43fee01bffbc5bd99d96ea508d8a08c527099e84eb708f45"}, - {file = "Pillow-9.1.1-cp39-cp39-win_amd64.whl", hash = "sha256:7c150dbbb4a94ea4825d1e5f2c5501af7141ea95825fadd7829f9b11c97aaf6c"}, - {file = "Pillow-9.1.1-pp37-pypy37_pp73-macosx_10_10_x86_64.whl", hash = "sha256:769a7f131a2f43752455cc72f9f7a093c3ff3856bf976c5fb53a59d0ccc704f6"}, - {file = "Pillow-9.1.1-pp37-pypy37_pp73-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:488f3383cf5159907d48d32957ac6f9ea85ccdcc296c14eca1a4e396ecc32098"}, - {file = "Pillow-9.1.1-pp37-pypy37_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0b525a356680022b0af53385944026d3486fc8c013638cf9900eb87c866afb4c"}, - {file = "Pillow-9.1.1-pp38-pypy38_pp73-macosx_10_10_x86_64.whl", hash = "sha256:6e760cf01259a1c0a50f3c845f9cad1af30577fd8b670339b1659c6d0e7a41dd"}, - {file = "Pillow-9.1.1-pp38-pypy38_pp73-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a4165205a13b16a29e1ac57efeee6be2dfd5b5408122d59ef2145bc3239fa340"}, - {file = "Pillow-9.1.1-pp38-pypy38_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:937a54e5694684f74dcbf6e24cc453bfc5b33940216ddd8f4cd8f0f79167f765"}, - {file = "Pillow-9.1.1-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:baf3be0b9446a4083cc0c5bb9f9c964034be5374b5bc09757be89f5d2fa247b8"}, - {file = "Pillow-9.1.1.tar.gz", hash = "sha256:7502539939b53d7565f3d11d87c78e7ec900d3c72945d4ee0e2f250d598309a0"}, -] -pims = [ - {file = "PIMS-0.6.1.tar.gz", hash = "sha256:e2b704461d4ea9bce8b6a22ca35836fe67d6d34537736b405341ae5547194f3b"}, -] -pluggy = [ - {file = "pluggy-1.0.0-py2.py3-none-any.whl", hash = "sha256:74134bbf457f031a36d68416e1509f34bd5ccc019f0bcc952c7b909d06b37bd3"}, - {file = "pluggy-1.0.0.tar.gz", hash = "sha256:4224373bacce55f955a878bf9cfa763c1e360858e330072059e10bad68531159"}, -] -psutil = [ - {file = "psutil-5.9.1-cp27-cp27m-manylinux2010_i686.whl", hash = "sha256:799759d809c31aab5fe4579e50addf84565e71c1dc9f1c31258f159ff70d3f87"}, - {file = "psutil-5.9.1-cp27-cp27m-manylinux2010_x86_64.whl", hash = "sha256:9272167b5f5fbfe16945be3db475b3ce8d792386907e673a209da686176552af"}, - {file = "psutil-5.9.1-cp27-cp27m-win32.whl", hash = "sha256:0904727e0b0a038830b019551cf3204dd48ef5c6868adc776e06e93d615fc5fc"}, - {file = "psutil-5.9.1-cp27-cp27m-win_amd64.whl", hash = "sha256:e7e10454cb1ab62cc6ce776e1c135a64045a11ec4c6d254d3f7689c16eb3efd2"}, - {file = "psutil-5.9.1-cp27-cp27mu-manylinux2010_i686.whl", hash = "sha256:56960b9e8edcca1456f8c86a196f0c3d8e3e361320071c93378d41445ffd28b0"}, - {file = "psutil-5.9.1-cp27-cp27mu-manylinux2010_x86_64.whl", hash = "sha256:44d1826150d49ffd62035785a9e2c56afcea66e55b43b8b630d7706276e87f22"}, - {file = "psutil-5.9.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:c7be9d7f5b0d206f0bbc3794b8e16fb7dbc53ec9e40bbe8787c6f2d38efcf6c9"}, - {file = "psutil-5.9.1-cp310-cp310-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:abd9246e4cdd5b554a2ddd97c157e292ac11ef3e7af25ac56b08b455c829dca8"}, - {file = "psutil-5.9.1-cp310-cp310-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:29a442e25fab1f4d05e2655bb1b8ab6887981838d22effa2396d584b740194de"}, - {file = "psutil-5.9.1-cp310-cp310-win32.whl", hash = "sha256:20b27771b077dcaa0de1de3ad52d22538fe101f9946d6dc7869e6f694f079329"}, - {file = "psutil-5.9.1-cp310-cp310-win_amd64.whl", hash = "sha256:58678bbadae12e0db55186dc58f2888839228ac9f41cc7848853539b70490021"}, - {file = "psutil-5.9.1-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:3a76ad658641172d9c6e593de6fe248ddde825b5866464c3b2ee26c35da9d237"}, - {file = "psutil-5.9.1-cp36-cp36m-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a6a11e48cb93a5fa606306493f439b4aa7c56cb03fc9ace7f6bfa21aaf07c453"}, - {file = "psutil-5.9.1-cp36-cp36m-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:068935df39055bf27a29824b95c801c7a5130f118b806eee663cad28dca97685"}, - {file = "psutil-5.9.1-cp36-cp36m-win32.whl", hash = "sha256:0f15a19a05f39a09327345bc279c1ba4a8cfb0172cc0d3c7f7d16c813b2e7d36"}, - {file = "psutil-5.9.1-cp36-cp36m-win_amd64.whl", hash = "sha256:db417f0865f90bdc07fa30e1aadc69b6f4cad7f86324b02aa842034efe8d8c4d"}, - {file = "psutil-5.9.1-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:91c7ff2a40c373d0cc9121d54bc5f31c4fa09c346528e6a08d1845bce5771ffc"}, - {file = "psutil-5.9.1-cp37-cp37m-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:fea896b54f3a4ae6f790ac1d017101252c93f6fe075d0e7571543510f11d2676"}, - {file = "psutil-5.9.1-cp37-cp37m-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3054e923204b8e9c23a55b23b6df73a8089ae1d075cb0bf711d3e9da1724ded4"}, - {file = "psutil-5.9.1-cp37-cp37m-win32.whl", hash = "sha256:d2d006286fbcb60f0b391741f520862e9b69f4019b4d738a2a45728c7e952f1b"}, - {file = "psutil-5.9.1-cp37-cp37m-win_amd64.whl", hash = "sha256:b14ee12da9338f5e5b3a3ef7ca58b3cba30f5b66f7662159762932e6d0b8f680"}, - {file = "psutil-5.9.1-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:19f36c16012ba9cfc742604df189f2f28d2720e23ff7d1e81602dbe066be9fd1"}, - {file = "psutil-5.9.1-cp38-cp38-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:944c4b4b82dc4a1b805329c980f270f170fdc9945464223f2ec8e57563139cf4"}, - {file = "psutil-5.9.1-cp38-cp38-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4b6750a73a9c4a4e689490ccb862d53c7b976a2a35c4e1846d049dcc3f17d83b"}, - {file = "psutil-5.9.1-cp38-cp38-win32.whl", hash = "sha256:a8746bfe4e8f659528c5c7e9af5090c5a7d252f32b2e859c584ef7d8efb1e689"}, - {file = "psutil-5.9.1-cp38-cp38-win_amd64.whl", hash = "sha256:79c9108d9aa7fa6fba6e668b61b82facc067a6b81517cab34d07a84aa89f3df0"}, - {file = "psutil-5.9.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:28976df6c64ddd6320d281128817f32c29b539a52bdae5e192537bc338a9ec81"}, - {file = "psutil-5.9.1-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b88f75005586131276634027f4219d06e0561292be8bd6bc7f2f00bdabd63c4e"}, - {file = "psutil-5.9.1-cp39-cp39-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:645bd4f7bb5b8633803e0b6746ff1628724668681a434482546887d22c7a9537"}, - {file = "psutil-5.9.1-cp39-cp39-win32.whl", hash = "sha256:32c52611756096ae91f5d1499fe6c53b86f4a9ada147ee42db4991ba1520e574"}, - {file = "psutil-5.9.1-cp39-cp39-win_amd64.whl", hash = "sha256:f65f9a46d984b8cd9b3750c2bdb419b2996895b005aefa6cbaba9a143b1ce2c5"}, - {file = "psutil-5.9.1.tar.gz", hash = "sha256:57f1819b5d9e95cdfb0c881a8a5b7d542ed0b7c522d575706a80bedc848c8954"}, -] -psycopg2 = [ - {file = "psycopg2-2.9.3-cp310-cp310-win32.whl", hash = "sha256:083707a696e5e1c330af2508d8fab36f9700b26621ccbcb538abe22e15485362"}, - {file = "psycopg2-2.9.3-cp310-cp310-win_amd64.whl", hash = "sha256:d3ca6421b942f60c008f81a3541e8faf6865a28d5a9b48544b0ee4f40cac7fca"}, - {file = "psycopg2-2.9.3-cp36-cp36m-win32.whl", hash = "sha256:9572e08b50aed176ef6d66f15a21d823bb6f6d23152d35e8451d7d2d18fdac56"}, - {file = "psycopg2-2.9.3-cp36-cp36m-win_amd64.whl", hash = "sha256:a81e3866f99382dfe8c15a151f1ca5fde5815fde879348fe5a9884a7c092a305"}, - {file = "psycopg2-2.9.3-cp37-cp37m-win32.whl", hash = "sha256:cb10d44e6694d763fa1078a26f7f6137d69f555a78ec85dc2ef716c37447e4b2"}, - {file = "psycopg2-2.9.3-cp37-cp37m-win_amd64.whl", hash = "sha256:4295093a6ae3434d33ec6baab4ca5512a5082cc43c0505293087b8a46d108461"}, - {file = "psycopg2-2.9.3-cp38-cp38-win32.whl", hash = "sha256:34b33e0162cfcaad151f249c2649fd1030010c16f4bbc40a604c1cb77173dcf7"}, - {file = "psycopg2-2.9.3-cp38-cp38-win_amd64.whl", hash = "sha256:0762c27d018edbcb2d34d51596e4346c983bd27c330218c56c4dc25ef7e819bf"}, - {file = "psycopg2-2.9.3-cp39-cp39-win32.whl", hash = "sha256:8cf3878353cc04b053822896bc4922b194792df9df2f1ad8da01fb3043602126"}, - {file = "psycopg2-2.9.3-cp39-cp39-win_amd64.whl", hash = "sha256:06f32425949bd5fe8f625c49f17ebb9784e1e4fe928b7cce72edc36fb68e4c0c"}, - {file = "psycopg2-2.9.3.tar.gz", hash = "sha256:8e841d1bf3434da985cc5ef13e6f75c8981ced601fd70cc6bf33351b91562981"}, -] -py = [ - {file = "py-1.11.0-py2.py3-none-any.whl", hash = "sha256:607c53218732647dff4acdfcd50cb62615cedf612e72d1724fb1a0cc6405b378"}, - {file = "py-1.11.0.tar.gz", hash = "sha256:51c75c4126074b472f746a24399ad32f6053d1b34b68d2fa41e558e6f4a98719"}, -] -pygeos = [ - {file = "pygeos-0.12.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:e3593360f1a93d2a6fe1ea75fa84882186bd3851d187e4c4bbb586495c748e3d"}, - {file = "pygeos-0.12.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:ec4112b69823866fa966ec4869e1b51b6560d892c65c20b3fb065266519046e2"}, - {file = "pygeos-0.12.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:75b5b0aefffb6b7747df299414df4f2e160e3a8993d2b6a86b805fb5b0196f13"}, - {file = "pygeos-0.12.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:26fae3eabb83a15348c2c3f78892114aca9bc4efaa342ab2fa3fa39a85e05dc5"}, - {file = "pygeos-0.12.0-cp310-cp310-win_amd64.whl", hash = "sha256:b4ec8fe577ca7ba6dd046481cdb736f99961216fcb54c84211287a10d1158459"}, - {file = "pygeos-0.12.0-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:6db68dc4583c88222d32cc624622234a97080b3c4650f0c0e12987664d49f374"}, - {file = "pygeos-0.12.0-cp36-cp36m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:da856315a4047d581300d860dd2aa01438e64121570bed46c81ad0a90f477db0"}, - {file = "pygeos-0.12.0-cp36-cp36m-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:3cf6d734aea07f04c7644ae24e303a447e96ea123ea524ab309e492ca683240e"}, - {file = "pygeos-0.12.0-cp36-cp36m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:12e06ec4417453f1a95d36b8ba8822569c30f6938dd4a7bac97433cab641b61f"}, - {file = "pygeos-0.12.0-cp36-cp36m-win32.whl", hash = "sha256:ea7f3ea9c76f8c94ed9b360b4d6249c44d5bc48c8db5cb3a5d4b017e51d1bd8a"}, - {file = "pygeos-0.12.0-cp36-cp36m-win_amd64.whl", hash = "sha256:a6cf496887f25b99427624399bcd07107660e6f9135466c33dc60ad9bd4c9ebe"}, - {file = "pygeos-0.12.0-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:f155f268676ff7b20a553a542a436be0f8df14233c873facc80214d836d6463b"}, - {file = "pygeos-0.12.0-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f74abd81487839532c7110721f3b1450d0c6bcfb5e18c45d604ddeb75ec99f86"}, - {file = "pygeos-0.12.0-cp37-cp37m-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6ac4ddfbe548d8a3e93732577b8a6d4df071f038338f6c400466b3c2bfe3dc78"}, - {file = "pygeos-0.12.0-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:504a03330147d2bb3309f291f4333db892cdba40a66ac4f3db8a2672dff7cf4f"}, - {file = "pygeos-0.12.0-cp37-cp37m-win32.whl", hash = "sha256:e3bcfb55e966aea26ff8e9b8fd314cee618c363f639e83b1eaaefb66bc97e7b0"}, - {file = "pygeos-0.12.0-cp37-cp37m-win_amd64.whl", hash = "sha256:835b7b1b2ef44453ff9d759dd67ee17fb89a52d8cdbd4d1655bf0be6ccfd90c3"}, - {file = "pygeos-0.12.0-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:60d103b4c099940ad73f0b193f65dfc77f957646451b8a399e4f1f5835c57ab6"}, - {file = "pygeos-0.12.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:5bc1b9a548848f9c69c913eca8ab0bb9164b35a28da51f86fcc0887c553bd863"}, - {file = "pygeos-0.12.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:11cb186f6cb9a2453a990a3e9894f861d308c574170d1c6f55a598cb11b87579"}, - {file = "pygeos-0.12.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b8fcb175645f57d7a6fa153a1582f9dbf625bb69c55267207b1bc8d2b983013b"}, - {file = "pygeos-0.12.0-cp38-cp38-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:2453c07c9b8a24054f897ed56e8046c7dd743939f7f5d6637fdeafdccc411f29"}, - {file = "pygeos-0.12.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:962df97f937d6656ce9293e7072318e99860b0d41f61df9017551855a8bc188e"}, - {file = "pygeos-0.12.0-cp38-cp38-win32.whl", hash = "sha256:d72e3691e47f44b49d3a23f05bb55eca34ed28b0e7b1b4aeb50207a95ae83f8f"}, - {file = "pygeos-0.12.0-cp38-cp38-win_amd64.whl", hash = "sha256:41119e394ea90bf8f697613f530cf92c77ab98346c19cb19beba33a82fd5b91d"}, - {file = "pygeos-0.12.0-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:dfad4c0a4b60861f8e571ca409ce128859d26e1ac26a15ee071cf1f222431fdd"}, - {file = "pygeos-0.12.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:aeaf1f9ae45cf35a25ccdeb2b083e057b31d98cf9351bfc42a59352130ff5c31"}, - {file = "pygeos-0.12.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:59971b44e3b8f61e96b159acdc5f9347b94766a4efb94af7b926b1c4958b60d4"}, - {file = "pygeos-0.12.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:efcbd52e5602d758b1ff42e67b91b33b1599667b478d0be9c13e17b286cbfcf0"}, - {file = "pygeos-0.12.0-cp39-cp39-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:47e7b2614d8982f841e33cc1f18d39b7a654d4d7958d456e4765ff4a9c76589b"}, - {file = "pygeos-0.12.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1f045632a940905c2f380544450bbcd48556b529bdfb9320aac777d90990fc25"}, - {file = "pygeos-0.12.0-cp39-cp39-win32.whl", hash = "sha256:d2fefb3a9cf96d1ee4841772464e82b2ae3a8ddf3caf14ecb04c5fcdae6a7248"}, - {file = "pygeos-0.12.0-cp39-cp39-win_amd64.whl", hash = "sha256:25b94e8bc755a8d3e50661995556b2c27d253bfdd55aa719ea3c202de44a9569"}, - {file = "pygeos-0.12.0.tar.gz", hash = "sha256:3c41542ef67c66015f443ae3e6e683503a8a221f9c24fb2380f6ae42aed1600a"}, -] -pyparsing = [ - {file = "pyparsing-3.0.9-py3-none-any.whl", hash = "sha256:5026bae9a10eeaefb61dab2f09052b9f4307d44aee4eda64b309723d8d206bbc"}, - {file = "pyparsing-3.0.9.tar.gz", hash = "sha256:2b020ecf7d21b687f219b71ecad3631f644a47f01403fa1d1036b0c6416d70fb"}, -] -pyproj = [ - {file = "pyproj-3.3.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:473961faef7a9fd723c5d432f65220ea6ab3854e606bf84b4d409a75a4261c78"}, - {file = "pyproj-3.3.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2fef9c1e339f25c57f6ae0558b5ab1bbdf7994529a30d8d7504fc6302ea51c03"}, - {file = "pyproj-3.3.1-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:140fa649fedd04f680a39f8ad339799a55cb1c49f6a84e1b32b97e49646647aa"}, - {file = "pyproj-3.3.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b59c08aea13ee428cf8a919212d55c036cc94784805ed77c8f31a4d1f541058c"}, - {file = "pyproj-3.3.1-cp310-cp310-win32.whl", hash = "sha256:1adc9ccd1bf04998493b6a2e87e60656c75ab790653b36cfe351e9ef214828ed"}, - {file = "pyproj-3.3.1-cp310-cp310-win_amd64.whl", hash = "sha256:42eea10afc750fccd1c5c4ba56de29ab791ab4d83c1f7db72705566282ac5396"}, - {file = "pyproj-3.3.1-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:531ea36519fa7b581466d4b6ab32f66ae4dadd9499d726352f71ee5e19c3d1c5"}, - {file = "pyproj-3.3.1-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:67025e37598a6bbed2c9c6c9e4c911f6dd39315d3e1148ead935a5c4d64309d5"}, - {file = "pyproj-3.3.1-cp38-cp38-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:aed1a3c0cd4182425f91b48d5db39f459bc2fe0d88017ead6425a1bc85faee33"}, - {file = "pyproj-3.3.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3cc4771403db54494e1e55bca8e6d33cde322f8cf0ed39f1557ff109c66d2cd1"}, - {file = "pyproj-3.3.1-cp38-cp38-win32.whl", hash = "sha256:c99f7b5757a28040a2dd4a28c9805fdf13eef79a796f4a566ab5cb362d10630d"}, - {file = "pyproj-3.3.1-cp38-cp38-win_amd64.whl", hash = "sha256:5dac03d4338a4c8bd0f69144c527474f517b4cbd7d2d8c532cd8937799723248"}, - {file = "pyproj-3.3.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:56b0f9ee2c5b2520b18db30a393a7b86130cf527ddbb8c96e7f3c837474a9d79"}, - {file = "pyproj-3.3.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5f92d8f6514516124abb714dce912b20867831162cfff9fae2678ef07b6fcf0f"}, - {file = "pyproj-3.3.1-cp39-cp39-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1ef1bfbe2dcc558c7a98e2f1836abdcd630390f3160724a6f4f5c818b2be0ad5"}, - {file = "pyproj-3.3.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5ca5f32b56210429b367ca4f9a57ffe67975c487af82e179a24370879a3daf68"}, - {file = "pyproj-3.3.1-cp39-cp39-win32.whl", hash = "sha256:aba199704c824fb84ab64927e7bc9ef71e603e483130ec0f7e09e97259b8f61f"}, - {file = "pyproj-3.3.1-cp39-cp39-win_amd64.whl", hash = "sha256:120d45ed73144c65e9677dc73ba8a531c495d179dd9f9f0471ac5acc02d7ac4b"}, - {file = "pyproj-3.3.1-pp38-pypy38_pp73-macosx_10_9_x86_64.whl", hash = "sha256:52efb681647dfac185cc655a709bc0caaf910031a0390f816f5fc8ce150cbedc"}, - {file = "pyproj-3.3.1-pp38-pypy38_pp73-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:5ab0d6e38fda7c13726afacaf62e9f9dd858089d67910471758afd9cb24e0ecd"}, - {file = "pyproj-3.3.1-pp38-pypy38_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:45487942c19c5a8b09c91964ea3201f4e094518e34743cae373889a36e3d9260"}, - {file = "pyproj-3.3.1-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:797ad5655d484feac14b0fbb4a4efeaac0cf780a223046e2465494c767fd1c3b"}, - {file = "pyproj-3.3.1.tar.gz", hash = "sha256:b3d8e14d91cc95fb3dbc03a9d0588ac58326803eefa5bbb0978d109de3304fbe"}, -] -pyrsistent = [ - {file = "pyrsistent-0.18.1-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:df46c854f490f81210870e509818b729db4488e1f30f2a1ce1698b2295a878d1"}, - {file = "pyrsistent-0.18.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5d45866ececf4a5fff8742c25722da6d4c9e180daa7b405dc0a2a2790d668c26"}, - {file = "pyrsistent-0.18.1-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4ed6784ceac462a7d6fcb7e9b663e93b9a6fb373b7f43594f9ff68875788e01e"}, - {file = "pyrsistent-0.18.1-cp310-cp310-win32.whl", hash = "sha256:e4f3149fd5eb9b285d6bfb54d2e5173f6a116fe19172686797c056672689daf6"}, - {file = "pyrsistent-0.18.1-cp310-cp310-win_amd64.whl", hash = "sha256:636ce2dc235046ccd3d8c56a7ad54e99d5c1cd0ef07d9ae847306c91d11b5fec"}, - {file = "pyrsistent-0.18.1-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:e92a52c166426efbe0d1ec1332ee9119b6d32fc1f0bbfd55d5c1088070e7fc1b"}, - {file = "pyrsistent-0.18.1-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d7a096646eab884bf8bed965bad63ea327e0d0c38989fc83c5ea7b8a87037bfc"}, - {file = "pyrsistent-0.18.1-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:cdfd2c361b8a8e5d9499b9082b501c452ade8bbf42aef97ea04854f4a3f43b22"}, - {file = "pyrsistent-0.18.1-cp37-cp37m-win32.whl", hash = "sha256:7ec335fc998faa4febe75cc5268a9eac0478b3f681602c1f27befaf2a1abe1d8"}, - {file = "pyrsistent-0.18.1-cp37-cp37m-win_amd64.whl", hash = "sha256:6455fc599df93d1f60e1c5c4fe471499f08d190d57eca040c0ea182301321286"}, - {file = "pyrsistent-0.18.1-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:fd8da6d0124efa2f67d86fa70c851022f87c98e205f0594e1fae044e7119a5a6"}, - {file = "pyrsistent-0.18.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7bfe2388663fd18bd8ce7db2c91c7400bf3e1a9e8bd7d63bf7e77d39051b85ec"}, - {file = "pyrsistent-0.18.1-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0e3e1fcc45199df76053026a51cc59ab2ea3fc7c094c6627e93b7b44cdae2c8c"}, - {file = "pyrsistent-0.18.1-cp38-cp38-win32.whl", hash = "sha256:b568f35ad53a7b07ed9b1b2bae09eb15cdd671a5ba5d2c66caee40dbf91c68ca"}, - {file = "pyrsistent-0.18.1-cp38-cp38-win_amd64.whl", hash = "sha256:d1b96547410f76078eaf66d282ddca2e4baae8964364abb4f4dcdde855cd123a"}, - {file = "pyrsistent-0.18.1-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:f87cc2863ef33c709e237d4b5f4502a62a00fab450c9e020892e8e2ede5847f5"}, - {file = "pyrsistent-0.18.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6bc66318fb7ee012071b2792024564973ecc80e9522842eb4e17743604b5e045"}, - {file = "pyrsistent-0.18.1-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:914474c9f1d93080338ace89cb2acee74f4f666fb0424896fcfb8d86058bf17c"}, - {file = "pyrsistent-0.18.1-cp39-cp39-win32.whl", hash = "sha256:1b34eedd6812bf4d33814fca1b66005805d3640ce53140ab8bbb1e2651b0d9bc"}, - {file = "pyrsistent-0.18.1-cp39-cp39-win_amd64.whl", hash = "sha256:e24a828f57e0c337c8d8bb9f6b12f09dfdf0273da25fda9e314f0b684b415a07"}, - {file = "pyrsistent-0.18.1.tar.gz", hash = "sha256:d4d61f8b993a7255ba714df3aca52700f8125289f84f704cf80916517c46eb96"}, -] -pytest = [ - {file = "pytest-7.1.2-py3-none-any.whl", hash = "sha256:13d0e3ccfc2b6e26be000cb6568c832ba67ba32e719443bfe725814d3c42433c"}, - {file = "pytest-7.1.2.tar.gz", hash = "sha256:a06a0425453864a270bc45e71f783330a7428defb4230fb5e6a731fde06ecd45"}, -] -python-dateutil = [ - {file = "python-dateutil-2.8.2.tar.gz", hash = "sha256:0123cacc1627ae19ddf3c27a5de5bd67ee4586fbdd6440d9748f8abb483d3e86"}, - {file = "python_dateutil-2.8.2-py2.py3-none-any.whl", hash = "sha256:961d03dc3453ebbc59dbdea9e4e11c5651520a876d0f4db161e8674aae935da9"}, -] -pytileproj = [ - {file = "pytileproj-0.0.16.tar.gz", hash = "sha256:c4d1629f5aa08e90a8d6a5cd3bf179deb0bdeeb1359bc66cab0bb3fbc0677879"}, -] -pytz = [ - {file = "pytz-2022.1-py2.py3-none-any.whl", hash = "sha256:e68985985296d9a66a881eb3193b0906246245294a881e7c8afe623866ac6a5c"}, - {file = "pytz-2022.1.tar.gz", hash = "sha256:1e760e2fe6a8163bc0b3d9a19c4f84342afa0a2affebfaa84b01b978a02ecaa7"}, -] -pywavelets = [ - {file = "PyWavelets-1.3.0-cp310-cp310-macosx_10_13_universal2.whl", hash = "sha256:eebaa9c28600da336743fefd650332460c132792660e70eb09abf343b0664b87"}, - {file = "PyWavelets-1.3.0-cp310-cp310-macosx_10_13_x86_64.whl", hash = "sha256:3eeffcf2f7eebae5cc27cb11a7d0d96118e2e9f75ac38ff1a05373d5fe75accb"}, - {file = "PyWavelets-1.3.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:35a945bea9da6db9755e42e06e871846514ae91bde3ae24a08a1d090b003a23b"}, - {file = "PyWavelets-1.3.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e8876764e349673ee8d48bc3cd0afd2f9f7b65378998e2665af12c277c8a56de"}, - {file = "PyWavelets-1.3.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c98ac1cee6276db05768e450dc3002033be6c2819c906103a974e0fb0d436f41"}, - {file = "PyWavelets-1.3.0-cp310-cp310-win32.whl", hash = "sha256:6ecfe051ccb097c2dcdcb0977e0a684e76144d6694a202badf0780143d8536f0"}, - {file = "PyWavelets-1.3.0-cp310-cp310-win_amd64.whl", hash = "sha256:437806465cfa5f2d91809ec13154be050b84a11025784a6b6ce04ac452872b36"}, - {file = "PyWavelets-1.3.0-cp37-cp37m-macosx_10_13_x86_64.whl", hash = "sha256:3c4ebe7ff2c9092f6bdd1f8bf98ce2745f5d43a9936d6e342ee83fbcae548116"}, - {file = "PyWavelets-1.3.0-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d4f9ed4f175c66c9b8646a93fd54c588fd8f4b2517f53c59aea5cdf370f9c9ba"}, - {file = "PyWavelets-1.3.0-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:41e4f0a3a6a088e955006513fe72f863cea3ce293033131cacb8a1a3068ed228"}, - {file = "PyWavelets-1.3.0-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:5b76731d2077242611b32f2e11c72adbf126b432ceae92e2ce8d0f693974c96d"}, - {file = "PyWavelets-1.3.0-cp37-cp37m-win32.whl", hash = "sha256:3d3ecc2ee87be94fb2dc8c2d35bcae3f24708677196e80028d24ba0fd2f6a70a"}, - {file = "PyWavelets-1.3.0-cp37-cp37m-win_amd64.whl", hash = "sha256:91e1b220f0ddd4c127bab718363c2c4a07dbcd95b9c4bfed09a3cdae47dbba43"}, - {file = "PyWavelets-1.3.0-cp38-cp38-macosx_10_13_universal2.whl", hash = "sha256:8a5941d1f4eb1bc9569c655b63ecb31aa15b3ef0fc9b57df275892c39bccc59e"}, - {file = "PyWavelets-1.3.0-cp38-cp38-macosx_10_13_x86_64.whl", hash = "sha256:a555a7a85da01357d8258cb45f751881f69013f8920f8738718c60cf8a47b755"}, - {file = "PyWavelets-1.3.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:69e9a46facf89b51e5700d10f6d831f29745471c1ab42917f2f849a257b9fd77"}, - {file = "PyWavelets-1.3.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a51225d24811ba7ef5184c03bb7072db0aa9651c4370a115d4069dedfb8d2f7a"}, - {file = "PyWavelets-1.3.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d7369597e1b1d125eb4b458a36cef052beed188444e55ed21445c1196008e200"}, - {file = "PyWavelets-1.3.0-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:307ab8a4c3e5c2b8f7d3d371de4a5f019cf4b030b897c3394a4a7ad157369367"}, - {file = "PyWavelets-1.3.0-cp38-cp38-win32.whl", hash = "sha256:27e99818d3c26481de3c68dbe880a7fcafe661cc031b22eff4a64237fe17a7ff"}, - {file = "PyWavelets-1.3.0-cp38-cp38-win_amd64.whl", hash = "sha256:3383d106fa8da0c2df30401ad056cd7a11b76d885f4bfa16ca7bcc6b4ca2831c"}, - {file = "PyWavelets-1.3.0-cp39-cp39-macosx_10_13_universal2.whl", hash = "sha256:84c58a179bdb9fc71039b1f68bcd0718a7d9814b5e3741d7681d3e027bb81b52"}, - {file = "PyWavelets-1.3.0-cp39-cp39-macosx_10_13_x86_64.whl", hash = "sha256:fccf468c55427828a3c534b651311f2759210836491c1112e1548e1babe368a5"}, - {file = "PyWavelets-1.3.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:0ed3afbda88498b3ea3c861bf5b55e4feca41747730a71a22102ed5a74d1e453"}, - {file = "PyWavelets-1.3.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:38cc635c08a050e175a492e66c9b63a8e1f42254e6879e614b6c9d8d69e0887f"}, - {file = "PyWavelets-1.3.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a486160f83efd8517cd748796adbab7c445ee8a3e1d168b4b8b60ed0f5aee3a0"}, - {file = "PyWavelets-1.3.0-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:f6e7d969a6ef64ae8be1766b0b0e32debb13424543d331911b8d7e967d60dd42"}, - {file = "PyWavelets-1.3.0-cp39-cp39-win32.whl", hash = "sha256:de67deb275474094e160900ab7e07f2a721b9cd351cf3826c4a3ab89bb71d4b3"}, - {file = "PyWavelets-1.3.0-cp39-cp39-win_amd64.whl", hash = "sha256:a354979e2ee8cd71a8952ded381f3d9f981692b73c6842bcc6c9f64047e0a5be"}, - {file = "PyWavelets-1.3.0.tar.gz", hash = "sha256:cbaa9d62052d9daf8da765fc8e7c30c38ea2b8e9e1c18841913dfb4aec671ee5"}, -] -pyyaml = [ - {file = "PyYAML-6.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:d4db7c7aef085872ef65a8fd7d6d09a14ae91f691dec3e87ee5ee0539d516f53"}, - {file = "PyYAML-6.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:9df7ed3b3d2e0ecfe09e14741b857df43adb5a3ddadc919a2d94fbdf78fea53c"}, - {file = "PyYAML-6.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:77f396e6ef4c73fdc33a9157446466f1cff553d979bd00ecb64385760c6babdc"}, - {file = "PyYAML-6.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a80a78046a72361de73f8f395f1f1e49f956c6be882eed58505a15f3e430962b"}, - {file = "PyYAML-6.0-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:f84fbc98b019fef2ee9a1cb3ce93e3187a6df0b2538a651bfb890254ba9f90b5"}, - {file = "PyYAML-6.0-cp310-cp310-win32.whl", hash = "sha256:2cd5df3de48857ed0544b34e2d40e9fac445930039f3cfe4bcc592a1f836d513"}, - {file = "PyYAML-6.0-cp310-cp310-win_amd64.whl", hash = "sha256:daf496c58a8c52083df09b80c860005194014c3698698d1a57cbcfa182142a3a"}, - {file = "PyYAML-6.0-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:897b80890765f037df3403d22bab41627ca8811ae55e9a722fd0392850ec4d86"}, - {file = "PyYAML-6.0-cp36-cp36m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:50602afada6d6cbfad699b0c7bb50d5ccffa7e46a3d738092afddc1f9758427f"}, - {file = "PyYAML-6.0-cp36-cp36m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:48c346915c114f5fdb3ead70312bd042a953a8ce5c7106d5bfb1a5254e47da92"}, - {file = "PyYAML-6.0-cp36-cp36m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:98c4d36e99714e55cfbaaee6dd5badbc9a1ec339ebfc3b1f52e293aee6bb71a4"}, - {file = "PyYAML-6.0-cp36-cp36m-win32.whl", hash = "sha256:0283c35a6a9fbf047493e3a0ce8d79ef5030852c51e9d911a27badfde0605293"}, - {file = "PyYAML-6.0-cp36-cp36m-win_amd64.whl", hash = "sha256:07751360502caac1c067a8132d150cf3d61339af5691fe9e87803040dbc5db57"}, - {file = "PyYAML-6.0-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:819b3830a1543db06c4d4b865e70ded25be52a2e0631ccd2f6a47a2822f2fd7c"}, - {file = "PyYAML-6.0-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:473f9edb243cb1935ab5a084eb238d842fb8f404ed2193a915d1784b5a6b5fc0"}, - {file = "PyYAML-6.0-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:0ce82d761c532fe4ec3f87fc45688bdd3a4c1dc5e0b4a19814b9009a29baefd4"}, - {file = "PyYAML-6.0-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:231710d57adfd809ef5d34183b8ed1eeae3f76459c18fb4a0b373ad56bedcdd9"}, - {file = "PyYAML-6.0-cp37-cp37m-win32.whl", hash = "sha256:c5687b8d43cf58545ade1fe3e055f70eac7a5a1a0bf42824308d868289a95737"}, - {file = "PyYAML-6.0-cp37-cp37m-win_amd64.whl", hash = "sha256:d15a181d1ecd0d4270dc32edb46f7cb7733c7c508857278d3d378d14d606db2d"}, - {file = "PyYAML-6.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:0b4624f379dab24d3725ffde76559cff63d9ec94e1736b556dacdfebe5ab6d4b"}, - {file = "PyYAML-6.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:213c60cd50106436cc818accf5baa1aba61c0189ff610f64f4a3e8c6726218ba"}, - {file = "PyYAML-6.0-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9fa600030013c4de8165339db93d182b9431076eb98eb40ee068700c9c813e34"}, - {file = "PyYAML-6.0-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:277a0ef2981ca40581a47093e9e2d13b3f1fbbeffae064c1d21bfceba2030287"}, - {file = "PyYAML-6.0-cp38-cp38-win32.whl", hash = "sha256:d4eccecf9adf6fbcc6861a38015c2a64f38b9d94838ac1810a9023a0609e1b78"}, - {file = "PyYAML-6.0-cp38-cp38-win_amd64.whl", hash = "sha256:1e4747bc279b4f613a09eb64bba2ba602d8a6664c6ce6396a4d0cd413a50ce07"}, - {file = "PyYAML-6.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:055d937d65826939cb044fc8c9b08889e8c743fdc6a32b33e2390f66013e449b"}, - {file = "PyYAML-6.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:e61ceaab6f49fb8bdfaa0f92c4b57bcfbea54c09277b1b4f7ac376bfb7a7c174"}, - {file = "PyYAML-6.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d67d839ede4ed1b28a4e8909735fc992a923cdb84e618544973d7dfc71540803"}, - {file = "PyYAML-6.0-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:cba8c411ef271aa037d7357a2bc8f9ee8b58b9965831d9e51baf703280dc73d3"}, - {file = "PyYAML-6.0-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:40527857252b61eacd1d9af500c3337ba8deb8fc298940291486c465c8b46ec0"}, - {file = "PyYAML-6.0-cp39-cp39-win32.whl", hash = "sha256:b5b9eccad747aabaaffbc6064800670f0c297e52c12754eb1d976c57e4f74dcb"}, - {file = "PyYAML-6.0-cp39-cp39-win_amd64.whl", hash = "sha256:b3d267842bf12586ba6c734f89d1f5b871df0273157918b0ccefa29deb05c21c"}, - {file = "PyYAML-6.0.tar.gz", hash = "sha256:68fb519c14306fec9720a2a5b45bc9f0c8d1b9c72adf45c37baedfcd949c35a2"}, -] -rasterio = [ - {file = "rasterio-1.2.10-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:f86efb0e4989201f244d6818575d442b716ce81af6cd969c3caead76b9690837"}, - {file = "rasterio-1.2.10-cp36-cp36m-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:831b6dbefb409c3ece23fa219d8446a7534e30c69a075fd366e72742b1f94c58"}, - {file = "rasterio-1.2.10-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:42a1a6364313c384fcd631d850792621301e930449b47f72ced048c415c9c84e"}, - {file = "rasterio-1.2.10-cp37-cp37m-manylinux1_x86_64.whl", hash = "sha256:1572003273225162933d4c88729076ac39050e7becd9de7d31988d1dd40942c1"}, - {file = "rasterio-1.2.10-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:8f9867a3b6663396260fc5bdfbea372cac9202074b709478db741767f40dfffc"}, - {file = "rasterio-1.2.10-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:ba95aa3221814e364ef49cf8dd8ca4a73e2ea702bd9228a3a845e197091792ae"}, - {file = "rasterio-1.2.10-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:2394ce0ae1e7b49b456ddc6bbf00ce6840656e926046c1a5a54cd0f66ea67dc4"}, - {file = "rasterio-1.2.10-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:c73248b4ba0564798bf64df869834821a7b823a4c9ceda3de9b772d69c3f5405"}, - {file = "rasterio-1.2.10.tar.gz", hash = "sha256:6062456047ba6494fe18bd0da98a383b6fad5306b16cd52a22e76c59172a2b5f"}, -] -rioxarray = [ - {file = "rioxarray-0.9.1.tar.gz", hash = "sha256:303e39c30918899ceeb601db628273a55796268e9e4e8b78b836080586c350e7"}, -] -scikit-image = [ - {file = "scikit-image-0.19.3.tar.gz", hash = "sha256:24b5367de1762da6ee126dd8f30cc4e7efda474e0d7d70685433f0e3aa2ec450"}, - {file = "scikit_image-0.19.3-cp310-cp310-macosx_10_13_x86_64.whl", hash = "sha256:3a01372ae4bca223873304b0bff79b9d92446ac6d6177f73d89b45561e2d09d8"}, - {file = "scikit_image-0.19.3-cp310-cp310-macosx_12_0_arm64.whl", hash = "sha256:fdf48d9b1f13af69e4e2c78e05067e322e9c8c97463c315cd0ecb47a94e259fc"}, - {file = "scikit_image-0.19.3-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6b6a8f98f2ac9bb73706461fd1dec875f6a5141759ed526850a5a49e90003d19"}, - {file = "scikit_image-0.19.3-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cfbb073f23deb48e0e60c47f8741d8089121d89cc78629ea8c5b51096efc5be7"}, - {file = "scikit_image-0.19.3-cp310-cp310-win_amd64.whl", hash = "sha256:cc24177de3fdceca5d04807ad9c87d665f0bf01032ed94a9055cd1ed2b3f33e9"}, - {file = "scikit_image-0.19.3-cp37-cp37m-macosx_10_13_x86_64.whl", hash = "sha256:fd9dd3994bb6f9f7a35f228323f3c4dc44b3cf2ff15fd72d895216e9333550c6"}, - {file = "scikit_image-0.19.3-cp37-cp37m-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:ad5d8000207a264d1a55681a9276e6a739d3f05cf4429004ad00d61d1892235f"}, - {file = "scikit_image-0.19.3-cp37-cp37m-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:84baa3179f3ae983c3a5d81c1e404bc92dcf7daeb41bfe9369badcda3fb22b92"}, - {file = "scikit_image-0.19.3-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7f9f8a1387afc6c70f2bed007c3854a2d7489f9f7713c242f16f32ee05934bc2"}, - {file = "scikit_image-0.19.3-cp37-cp37m-win32.whl", hash = "sha256:9fb0923a3bfa99457c5e17888f27b3b8a83a3600b4fef317992e7b7234764732"}, - {file = "scikit_image-0.19.3-cp37-cp37m-win_amd64.whl", hash = "sha256:ce3d2207f253b8eb2c824e30d145a9f07a34a14212d57f3beca9f7e03c383cbe"}, - {file = "scikit_image-0.19.3-cp38-cp38-macosx_10_13_x86_64.whl", hash = "sha256:2a02d1bd0e2b53e36b952bd5fd6118d9ccc3ee51de35705d63d8eb1f2e86adef"}, - {file = "scikit_image-0.19.3-cp38-cp38-macosx_12_0_arm64.whl", hash = "sha256:03779a7e1736fdf89d83c0ba67d44110496edd736a3bfce61a2b5177a1c8a099"}, - {file = "scikit_image-0.19.3-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:19a21a101a20c587a3b611a2cf6f86c35aae9f8d9563279b987e83ee1c9a9790"}, - {file = "scikit_image-0.19.3-cp38-cp38-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:2f50b923f8099c1045fcde7418d86b206c87e333e43da980f41d8577b9605245"}, - {file = "scikit_image-0.19.3-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e207c6ce5ce121d7d9b9d2b61b9adca57d1abed112c902d8ffbfdc20fb42c12b"}, - {file = "scikit_image-0.19.3-cp38-cp38-win32.whl", hash = "sha256:a7c3985c68bfe05f7571167ee021d14f5b8d1a4a250c91f0b13be7fb07e6af34"}, - {file = "scikit_image-0.19.3-cp38-cp38-win_amd64.whl", hash = "sha256:651de1c2ce1fbee834753b46b8e7d81cb12a5594898babba63ac82b30ddad49d"}, - {file = "scikit_image-0.19.3-cp39-cp39-macosx_10_13_x86_64.whl", hash = "sha256:8d8917fcf85b987b1f287f823f3a1a7dac38b70aaca759bc0200f3bc292d5ced"}, - {file = "scikit_image-0.19.3-cp39-cp39-macosx_12_0_arm64.whl", hash = "sha256:0b0a199157ce8487c77de4fde0edc0b42d6d42818881c11f459262351d678b2d"}, - {file = "scikit_image-0.19.3-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:33dfd463ee6cc509defa279b963829f2230c9e0639ccd3931045be055878eea6"}, - {file = "scikit_image-0.19.3-cp39-cp39-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a8714348ddd671f819457a797c97d4c672166f093def66d66c3254cbd1d43f83"}, - {file = "scikit_image-0.19.3-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ff3b1025356508d41f4fe48528e509d95f9e4015e90cf158cd58c56dc63e0ac5"}, - {file = "scikit_image-0.19.3-cp39-cp39-win32.whl", hash = "sha256:9439e5294de3f18d6e82ec8eee2c46590231cf9c690da80545e83a0733b7a69e"}, - {file = "scikit_image-0.19.3-cp39-cp39-win_amd64.whl", hash = "sha256:32fb88cc36203b99c9672fb972c9ef98635deaa5fc889fe969f3e11c44f22919"}, -] -scipy = [ - {file = "scipy-1.6.1-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:a15a1f3fc0abff33e792d6049161b7795909b40b97c6cc2934ed54384017ab76"}, - {file = "scipy-1.6.1-cp37-cp37m-manylinux1_i686.whl", hash = "sha256:e79570979ccdc3d165456dd62041d9556fb9733b86b4b6d818af7a0afc15f092"}, - {file = "scipy-1.6.1-cp37-cp37m-manylinux1_x86_64.whl", hash = "sha256:a423533c55fec61456dedee7b6ee7dce0bb6bfa395424ea374d25afa262be261"}, - {file = "scipy-1.6.1-cp37-cp37m-manylinux2014_aarch64.whl", hash = "sha256:33d6b7df40d197bdd3049d64e8e680227151673465e5d85723b3b8f6b15a6ced"}, - {file = "scipy-1.6.1-cp37-cp37m-win32.whl", hash = "sha256:6725e3fbb47da428794f243864f2297462e9ee448297c93ed1dcbc44335feb78"}, - {file = "scipy-1.6.1-cp37-cp37m-win_amd64.whl", hash = "sha256:5fa9c6530b1661f1370bcd332a1e62ca7881785cc0f80c0d559b636567fab63c"}, - {file = "scipy-1.6.1-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:bd50daf727f7c195e26f27467c85ce653d41df4358a25b32434a50d8870fc519"}, - {file = "scipy-1.6.1-cp38-cp38-manylinux1_i686.whl", hash = "sha256:f46dd15335e8a320b0fb4685f58b7471702234cba8bb3442b69a3e1dc329c345"}, - {file = "scipy-1.6.1-cp38-cp38-manylinux1_x86_64.whl", hash = "sha256:0e5b0ccf63155d90da576edd2768b66fb276446c371b73841e3503be1d63fb5d"}, - {file = "scipy-1.6.1-cp38-cp38-manylinux2014_aarch64.whl", hash = "sha256:2481efbb3740977e3c831edfd0bd9867be26387cacf24eb5e366a6a374d3d00d"}, - {file = "scipy-1.6.1-cp38-cp38-win32.whl", hash = "sha256:68cb4c424112cd4be886b4d979c5497fba190714085f46b8ae67a5e4416c32b4"}, - {file = "scipy-1.6.1-cp38-cp38-win_amd64.whl", hash = "sha256:5f331eeed0297232d2e6eea51b54e8278ed8bb10b099f69c44e2558c090d06bf"}, - {file = "scipy-1.6.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:0c8a51d33556bf70367452d4d601d1742c0e806cd0194785914daf19775f0e67"}, - {file = "scipy-1.6.1-cp39-cp39-manylinux1_i686.whl", hash = "sha256:83bf7c16245c15bc58ee76c5418e46ea1811edcc2e2b03041b804e46084ab627"}, - {file = "scipy-1.6.1-cp39-cp39-manylinux1_x86_64.whl", hash = "sha256:794e768cc5f779736593046c9714e0f3a5940bc6dcc1dba885ad64cbfb28e9f0"}, - {file = "scipy-1.6.1-cp39-cp39-manylinux2014_aarch64.whl", hash = "sha256:5da5471aed911fe7e52b86bf9ea32fb55ae93e2f0fac66c32e58897cfb02fa07"}, - {file = "scipy-1.6.1-cp39-cp39-win32.whl", hash = "sha256:8e403a337749ed40af60e537cc4d4c03febddcc56cd26e774c9b1b600a70d3e4"}, - {file = "scipy-1.6.1-cp39-cp39-win_amd64.whl", hash = "sha256:a5193a098ae9f29af283dcf0041f762601faf2e595c0db1da929875b7570353f"}, - {file = "scipy-1.6.1.tar.gz", hash = "sha256:c4fceb864890b6168e79b0e714c585dbe2fd4222768ee90bc1aa0f8218691b11"}, -] -shapely = [ - {file = "Shapely-1.8.2-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:7c9e3400b716c51ba43eea1678c28272580114e009b6c78cdd00c44df3e325fa"}, - {file = "Shapely-1.8.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:ce0b5c5f7acbccf98b3460eecaa40e9b18272b2a734f74fcddf1d7696e047e95"}, - {file = "Shapely-1.8.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:3a40bf497b57a6625b83996aed10ce2233bca0e5471b8af771b186d681433ac5"}, - {file = "Shapely-1.8.2-cp310-cp310-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:6bdc7728f1e5df430d8c588661f79f1eed4a2728c8b689e12707cfec217f68f8"}, - {file = "Shapely-1.8.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a60861b5ca2c488ebcdc706eca94d325c26d1567921c74acc83df5e6913590c7"}, - {file = "Shapely-1.8.2-cp310-cp310-win32.whl", hash = "sha256:840be3f27a1152851c54b968f2e12d718c9f13b7acd51c482e58a70f60f29e31"}, - {file = "Shapely-1.8.2-cp310-cp310-win_amd64.whl", hash = "sha256:c60f3758212ec480675b820b13035dda8af8f7cc560d2cc67999b2717fb8faef"}, - {file = "Shapely-1.8.2-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:56413f7d32c70b63f239eb0865b24c0c61029e38757de456cc4ab3c416559a0b"}, - {file = "Shapely-1.8.2-cp36-cp36m-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:256bdf8080bb7bb504d47b2c76919ecebab9708cc1b26266b3ec32b42448f642"}, - {file = "Shapely-1.8.2-cp36-cp36m-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:c0a0d7752b145343838bd36ed09382d85f5befe426832d7384c5b051c147acbd"}, - {file = "Shapely-1.8.2-cp36-cp36m-win32.whl", hash = "sha256:62056e64b12b6d483d79f8e34bf058d2fe734d51c9227c1713705399434eff3b"}, - {file = "Shapely-1.8.2-cp36-cp36m-win_amd64.whl", hash = "sha256:8e3ed52a081da58eb4a885c157c594876633dbd4eb283f13ba5bf39c82322d76"}, - {file = "Shapely-1.8.2-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:7c8eda45085ccdd7f9805ea4a93fdd5eb0b6039a61d5f0cefb960487e6dc17a1"}, - {file = "Shapely-1.8.2-cp37-cp37m-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:beee3949ddf381735049cfa6532fb234d5d20a5be910c4f2fb7c7295fd7960e3"}, - {file = "Shapely-1.8.2-cp37-cp37m-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:e07b0bd2a0e61a8afd4d1c1bd23f3550b711f01274ffb53de99358fd781eefd8"}, - {file = "Shapely-1.8.2-cp37-cp37m-win32.whl", hash = "sha256:78966332a89813b237de357a03f612fd451a871fe6e26c12b6b71645fe8eee39"}, - {file = "Shapely-1.8.2-cp37-cp37m-win_amd64.whl", hash = "sha256:8fe641f1f61b3d43dd61b5a85d2ef023e6e19bf8f204a5160a1cb1ec645cbc09"}, - {file = "Shapely-1.8.2-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:cec89a5617c0137f4678282e983c3d63bf838fb00cdf318cc555b4d8409f7130"}, - {file = "Shapely-1.8.2-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:68c8e18dc9dc8a198c3addc8c9596f64137101f566f04b96ecfca0b214cb8b12"}, - {file = "Shapely-1.8.2-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:f12695662c3ad1e6031b3de98f191963d0f09de6d1a4988acd907405644032ba"}, - {file = "Shapely-1.8.2-cp38-cp38-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:15a856fbb588ad5d042784e00918c662902776452008c771ecba2ff615cd197a"}, - {file = "Shapely-1.8.2-cp38-cp38-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:d74de394684d66e25e780b0359fda85be7766af85940fa2dfad728b1a815c71f"}, - {file = "Shapely-1.8.2-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d3f3fac625690f01f35af665649e993f15f924e740b5c0ac0376900655815521"}, - {file = "Shapely-1.8.2-cp38-cp38-win32.whl", hash = "sha256:1d95842cc6bbbeab673061b63e70b07be9a375c15a60f4098f8fbd29f43af1b4"}, - {file = "Shapely-1.8.2-cp38-cp38-win_amd64.whl", hash = "sha256:a58e1f362f2091743e5e13212f5d5d16251a4bb63dd0ed587c652d3be9620d3a"}, - {file = "Shapely-1.8.2-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:5254240eefc44139ab0d128faf671635d8bdd9c23955ee063d4d6b8f20073ae0"}, - {file = "Shapely-1.8.2-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:75042e8039c79dd01f102bb288beace9dc2f49fc44a2dea875f9b697aa8cd30d"}, - {file = "Shapely-1.8.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:0c0fd457ce477b1dced507a72f1e2084c9191bfcb8a1e09886990ebd02acf024"}, - {file = "Shapely-1.8.2-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:6fcb28836ae93809de1dde73c03c9c24bab0ba2b2bf419ddb2aeb72c96d110e9"}, - {file = "Shapely-1.8.2-cp39-cp39-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:44d2832c1b706bf43101fda92831a083467cc4b4923a7ed17319ab599c1025d8"}, - {file = "Shapely-1.8.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:137f1369630408024a62ff79a437a5657e6c5b76b9cd352dde704b425acdb298"}, - {file = "Shapely-1.8.2-cp39-cp39-win32.whl", hash = "sha256:2e02da2e988e74d61f15c720f9f613fab51942aae2dfeacdcb78eadece00e1f3"}, - {file = "Shapely-1.8.2-cp39-cp39-win_amd64.whl", hash = "sha256:3423299254deec075e79fb7dc7909d702104e4167149de7f45510c3a6342eeea"}, - {file = "Shapely-1.8.2.tar.gz", hash = "sha256:572af9d5006fd5e3213e37ee548912b0341fb26724d6dc8a4e3950c10197ebb6"}, -] -six = [ - {file = "six-1.16.0-py2.py3-none-any.whl", hash = "sha256:8abb2f1d86890a2dfb989f9a77cfcfd3e47c2a354b01111771326f8aa26e0254"}, - {file = "six-1.16.0.tar.gz", hash = "sha256:1e61c37477a1626458e36f7b1d82aa5c9b094fa4802892072e49de9c60c4c926"}, -] -slicerator = [ - {file = "slicerator-1.1.0-py3-none-any.whl", hash = "sha256:167668d48c6d3a5ba0bd3d54b2688e81ee267dc20aef299e547d711e6f3c441a"}, - {file = "slicerator-1.1.0.tar.gz", hash = "sha256:44010a7f5cd87680c07213b5cabe81d1fb71252962943e5373ee7d14605d6046"}, -] -snuggs = [ - {file = "snuggs-1.4.7-py3-none-any.whl", hash = "sha256:988dde5d4db88e9d71c99457404773dabcc7a1c45971bfbe81900999942d9f07"}, - {file = "snuggs-1.4.7.tar.gz", hash = "sha256:501cf113fe3892e14e2fee76da5cd0606b7e149c411c271898e6259ebde2617b"}, -] -sortedcontainers = [ - {file = "sortedcontainers-2.4.0-py2.py3-none-any.whl", hash = "sha256:a163dcaede0f1c021485e957a39245190e74249897e2ae4b2aa38595db237ee0"}, - {file = "sortedcontainers-2.4.0.tar.gz", hash = "sha256:25caa5a06cc30b6b83d11423433f65d1f9d76c4c6a0c90e3379eaa43b9bfdb88"}, -] -sqlalchemy = [ - {file = "SQLAlchemy-1.4.38-cp27-cp27m-macosx_10_14_x86_64.whl", hash = "sha256:cf1afb1deec19de7ba282062de8a8c4f931ef120faa8b3dc6fca826bbc2f6a9d"}, - {file = "SQLAlchemy-1.4.38-cp27-cp27m-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:c715347cac3b1c563941162fbbf751d3a5e0c356a33cb20925699f4910504a8f"}, - {file = "SQLAlchemy-1.4.38-cp27-cp27m-win_amd64.whl", hash = "sha256:55c09559e45d3f067435620195238f983d4a23f796650f959f19964ba9104c6f"}, - {file = "SQLAlchemy-1.4.38-cp27-cp27mu-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:f04789d723fbd6214a63006b4711d7afca37630473edb6ab972c5df2b43b7a56"}, - {file = "SQLAlchemy-1.4.38-cp310-cp310-macosx_10_15_universal2.whl", hash = "sha256:6edadd6a0a722c22558e1d1f5360d3e85fa938bc69d9049d29968a643de6dd34"}, - {file = "SQLAlchemy-1.4.38-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:42810e560b57e981ed0a947b65a4936b398b4fca97e5b56e10a9c5a151568de2"}, - {file = "SQLAlchemy-1.4.38-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:b8cd779ef29718f3d2c558042ccc45c03006c599dd722fb760faca641a2f32ac"}, - {file = "SQLAlchemy-1.4.38-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bf05b312bf0165f92fa0eb09e7661c26f2f06c7a89694ecb79fa15a933deb768"}, - {file = "SQLAlchemy-1.4.38-cp310-cp310-win32.whl", hash = "sha256:82701a4cbb14affc6c1ae62dcebdaff65611b7c7f96f9d0e92a34a8be112a8fa"}, - {file = "SQLAlchemy-1.4.38-cp310-cp310-win_amd64.whl", hash = "sha256:57ea67a9206eab2abe130e4fdae0662f10cca3dc72ba27553f70a7d613588571"}, - {file = "SQLAlchemy-1.4.38-cp36-cp36m-macosx_10_14_x86_64.whl", hash = "sha256:492f25432f0a998bcaa35e907f9d33f436d208326bb1e6c0f8485e8117502a3d"}, - {file = "SQLAlchemy-1.4.38-cp36-cp36m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fa64578158cb374e4dd6da2377f1ceabf9973313d171e67fc01a353aa8967858"}, - {file = "SQLAlchemy-1.4.38-cp36-cp36m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:bdea12b997b174903292cf19f40d36cad46b44b645725b9485164684d1849bfd"}, - {file = "SQLAlchemy-1.4.38-cp36-cp36m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:63f8e68356b53072a653e8f61c5f1c19721469af4dbfdb3e3356073e9918f1fe"}, - {file = "SQLAlchemy-1.4.38-cp36-cp36m-win32.whl", hash = "sha256:cfdb1b3763aa4bddccd7b627b9466fce94952dc150a49309eb56e5f50dd00806"}, - {file = "SQLAlchemy-1.4.38-cp36-cp36m-win_amd64.whl", hash = "sha256:b33388891faf67d0c4a7bb65657dd1a068168eda4b793cb929c4c3894adfdcf2"}, - {file = "SQLAlchemy-1.4.38-cp37-cp37m-macosx_10_15_x86_64.whl", hash = "sha256:a57edcbbb45e8307153c5d4635407df71529ed263666064c0524b0c412778306"}, - {file = "SQLAlchemy-1.4.38-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:470fd9d820fbd25c2a2a2929327c44aaff9d5871a20e0cadd32d293540817517"}, - {file = "SQLAlchemy-1.4.38-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:d8193b4a340d868f2daeeb856dfae9d9d4b011f249128380a83ee7342a887bdb"}, - {file = "SQLAlchemy-1.4.38-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1ac6b091b322ec54a30c751dfcb736987e317f5c53a5cf3beb62e11a18210319"}, - {file = "SQLAlchemy-1.4.38-cp37-cp37m-win32.whl", hash = "sha256:42a60988aad143a4b2745711548833f57340d7f35586160140361314a509e6f7"}, - {file = "SQLAlchemy-1.4.38-cp37-cp37m-win_amd64.whl", hash = "sha256:380e09881cdf3c87e90b8995425f7ea618e6bbd33c6b7c9234af21c4b6b3c143"}, - {file = "SQLAlchemy-1.4.38-cp38-cp38-macosx_10_15_x86_64.whl", hash = "sha256:e44e5f4d84861f4a2a00da8e55712db0dd2ec3d680544fb5d3ac84d3682d7d4c"}, - {file = "SQLAlchemy-1.4.38-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:77831317da71adec7b785ebf9e6467b59ba1e186de1ba13c94b4e4951387ba64"}, - {file = "SQLAlchemy-1.4.38-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:f036bdc951b0d64c64ae83e7ff83a1848eea74f1c6e42461347caab2ed7282b9"}, - {file = "SQLAlchemy-1.4.38-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ad2447f17425e6889f0fb2b229844799aabafc90ff780123067fc5846a30992c"}, - {file = "SQLAlchemy-1.4.38-cp38-cp38-win32.whl", hash = "sha256:737f4feee88d78230fa38027ad5645cb327fe9aac0dd0bde3f8fa7026ed81910"}, - {file = "SQLAlchemy-1.4.38-cp38-cp38-win_amd64.whl", hash = "sha256:eba2c5f717fa6d7be040bbc1e4334f1827d31e672cfd53ddbd995935d43e517e"}, - {file = "SQLAlchemy-1.4.38-cp39-cp39-macosx_10_15_x86_64.whl", hash = "sha256:cd1aba14bbb1ecfe8b5cc52dc840a7e071cfcce6bff545037cf56714c48dfc92"}, - {file = "SQLAlchemy-1.4.38-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:da424c8b285da91733fed2dd40fed7db076818a62859244d311b80fc8ba4d75e"}, - {file = "SQLAlchemy-1.4.38-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:07865d93e4ca77b59a5ce0f36fbae8161f7dfe57ba17934a3e442cf95dcb3c49"}, - {file = "SQLAlchemy-1.4.38-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3abe087b641788abbbe94abbf9f15f50bb985f72c0669ef35d1941d2912a276d"}, - {file = "SQLAlchemy-1.4.38-cp39-cp39-win32.whl", hash = "sha256:d3c4191e0348428b127c4c2e25ec9c1e8e895e3c6d9a7f083fca28dce23257ee"}, - {file = "SQLAlchemy-1.4.38-cp39-cp39-win_amd64.whl", hash = "sha256:97ba370e31b70be94f2f1e85494a5c90f8cf50381ddc02ab95a33a4a86371e02"}, - {file = "SQLAlchemy-1.4.38.tar.gz", hash = "sha256:93ae1d2ef42fbf0f0b3d44b35225bda123310df4b33c9bf662e7b50a68c48a98"}, -] -tblib = [ - {file = "tblib-1.7.0-py2.py3-none-any.whl", hash = "sha256:289fa7359e580950e7d9743eab36b0691f0310fce64dee7d9c31065b8f723e23"}, - {file = "tblib-1.7.0.tar.gz", hash = "sha256:059bd77306ea7b419d4f76016aef6d7027cc8a0785579b5aad198803435f882c"}, -] -tifffile = [ - {file = "tifffile-2022.5.4-py3-none-any.whl", hash = "sha256:52b4c02040d00c1811e26c0f6abd41e77e2d57559b3657ff3e873955f74f5c57"}, - {file = "tifffile-2022.5.4.tar.gz", hash = "sha256:b03147a15862b7c1d90d47435197f149bef7a52c25ad67cf1f9b465faa71b8d2"}, -] -tomli = [ - {file = "tomli-2.0.1-py3-none-any.whl", hash = "sha256:939de3e7a6161af0c887ef91b7d41a53e7c5a1ca976325f429cb46ea9bc30ecc"}, - {file = "tomli-2.0.1.tar.gz", hash = "sha256:de526c12914f0c550d15924c62d72abc48d6fe7364aa87328337a31007fe8a4f"}, -] -toolz = [ - {file = "toolz-0.11.2-py3-none-any.whl", hash = "sha256:a5700ce83414c64514d82d60bcda8aabfde092d1c1a8663f9200c07fdcc6da8f"}, - {file = "toolz-0.11.2.tar.gz", hash = "sha256:6b312d5e15138552f1bda8a4e66c30e236c831b612b2bf0005f8a1df10a4bc33"}, -] -tornado = [ - {file = "tornado-6.1-cp35-cp35m-macosx_10_9_x86_64.whl", hash = "sha256:d371e811d6b156d82aa5f9a4e08b58debf97c302a35714f6f45e35139c332e32"}, - {file = "tornado-6.1-cp35-cp35m-manylinux1_i686.whl", hash = "sha256:0d321a39c36e5f2c4ff12b4ed58d41390460f798422c4504e09eb5678e09998c"}, - {file = "tornado-6.1-cp35-cp35m-manylinux1_x86_64.whl", hash = "sha256:9de9e5188a782be6b1ce866e8a51bc76a0fbaa0e16613823fc38e4fc2556ad05"}, - {file = "tornado-6.1-cp35-cp35m-manylinux2010_i686.whl", hash = "sha256:61b32d06ae8a036a6607805e6720ef00a3c98207038444ba7fd3d169cd998910"}, - {file = "tornado-6.1-cp35-cp35m-manylinux2010_x86_64.whl", hash = "sha256:3e63498f680547ed24d2c71e6497f24bca791aca2fe116dbc2bd0ac7f191691b"}, - {file = "tornado-6.1-cp35-cp35m-manylinux2014_aarch64.whl", hash = "sha256:6c77c9937962577a6a76917845d06af6ab9197702a42e1346d8ae2e76b5e3675"}, - {file = "tornado-6.1-cp35-cp35m-win32.whl", hash = "sha256:6286efab1ed6e74b7028327365cf7346b1d777d63ab30e21a0f4d5b275fc17d5"}, - {file = "tornado-6.1-cp35-cp35m-win_amd64.whl", hash = "sha256:fa2ba70284fa42c2a5ecb35e322e68823288a4251f9ba9cc77be04ae15eada68"}, - {file = "tornado-6.1-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:0a00ff4561e2929a2c37ce706cb8233b7907e0cdc22eab98888aca5dd3775feb"}, - {file = "tornado-6.1-cp36-cp36m-manylinux1_i686.whl", hash = "sha256:748290bf9112b581c525e6e6d3820621ff020ed95af6f17fedef416b27ed564c"}, - {file = "tornado-6.1-cp36-cp36m-manylinux1_x86_64.whl", hash = "sha256:e385b637ac3acaae8022e7e47dfa7b83d3620e432e3ecb9a3f7f58f150e50921"}, - {file = "tornado-6.1-cp36-cp36m-manylinux2010_i686.whl", hash = "sha256:25ad220258349a12ae87ede08a7b04aca51237721f63b1808d39bdb4b2164558"}, - {file = "tornado-6.1-cp36-cp36m-manylinux2010_x86_64.whl", hash = "sha256:65d98939f1a2e74b58839f8c4dab3b6b3c1ce84972ae712be02845e65391ac7c"}, - {file = "tornado-6.1-cp36-cp36m-manylinux2014_aarch64.whl", hash = "sha256:e519d64089b0876c7b467274468709dadf11e41d65f63bba207e04217f47c085"}, - {file = "tornado-6.1-cp36-cp36m-win32.whl", hash = "sha256:b87936fd2c317b6ee08a5741ea06b9d11a6074ef4cc42e031bc6403f82a32575"}, - {file = "tornado-6.1-cp36-cp36m-win_amd64.whl", hash = "sha256:cc0ee35043162abbf717b7df924597ade8e5395e7b66d18270116f8745ceb795"}, - {file = "tornado-6.1-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:7250a3fa399f08ec9cb3f7b1b987955d17e044f1ade821b32e5f435130250d7f"}, - {file = "tornado-6.1-cp37-cp37m-manylinux1_i686.whl", hash = "sha256:ed3ad863b1b40cd1d4bd21e7498329ccaece75db5a5bf58cd3c9f130843e7102"}, - {file = "tornado-6.1-cp37-cp37m-manylinux1_x86_64.whl", hash = "sha256:dcef026f608f678c118779cd6591c8af6e9b4155c44e0d1bc0c87c036fb8c8c4"}, - {file = "tornado-6.1-cp37-cp37m-manylinux2010_i686.whl", hash = "sha256:70dec29e8ac485dbf57481baee40781c63e381bebea080991893cd297742b8fd"}, - {file = "tornado-6.1-cp37-cp37m-manylinux2010_x86_64.whl", hash = "sha256:d3f7594930c423fd9f5d1a76bee85a2c36fd8b4b16921cae7e965f22575e9c01"}, - {file = "tornado-6.1-cp37-cp37m-manylinux2014_aarch64.whl", hash = "sha256:3447475585bae2e77ecb832fc0300c3695516a47d46cefa0528181a34c5b9d3d"}, - {file = "tornado-6.1-cp37-cp37m-win32.whl", hash = "sha256:e7229e60ac41a1202444497ddde70a48d33909e484f96eb0da9baf8dc68541df"}, - {file = "tornado-6.1-cp37-cp37m-win_amd64.whl", hash = "sha256:cb5ec8eead331e3bb4ce8066cf06d2dfef1bfb1b2a73082dfe8a161301b76e37"}, - {file = "tornado-6.1-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:20241b3cb4f425e971cb0a8e4ffc9b0a861530ae3c52f2b0434e6c1b57e9fd95"}, - {file = "tornado-6.1-cp38-cp38-manylinux1_i686.whl", hash = "sha256:c77da1263aa361938476f04c4b6c8916001b90b2c2fdd92d8d535e1af48fba5a"}, - {file = "tornado-6.1-cp38-cp38-manylinux1_x86_64.whl", hash = "sha256:fba85b6cd9c39be262fcd23865652920832b61583de2a2ca907dbd8e8a8c81e5"}, - {file = "tornado-6.1-cp38-cp38-manylinux2010_i686.whl", hash = "sha256:1e8225a1070cd8eec59a996c43229fe8f95689cb16e552d130b9793cb570a288"}, - {file = "tornado-6.1-cp38-cp38-manylinux2010_x86_64.whl", hash = "sha256:d14d30e7f46a0476efb0deb5b61343b1526f73ebb5ed84f23dc794bdb88f9d9f"}, - {file = "tornado-6.1-cp38-cp38-manylinux2014_aarch64.whl", hash = "sha256:8f959b26f2634a091bb42241c3ed8d3cedb506e7c27b8dd5c7b9f745318ddbb6"}, - {file = "tornado-6.1-cp38-cp38-win32.whl", hash = "sha256:34ca2dac9e4d7afb0bed4677512e36a52f09caa6fded70b4e3e1c89dbd92c326"}, - {file = "tornado-6.1-cp38-cp38-win_amd64.whl", hash = "sha256:6196a5c39286cc37c024cd78834fb9345e464525d8991c21e908cc046d1cc02c"}, - {file = "tornado-6.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:f0ba29bafd8e7e22920567ce0d232c26d4d47c8b5cf4ed7b562b5db39fa199c5"}, - {file = "tornado-6.1-cp39-cp39-manylinux1_i686.whl", hash = "sha256:33892118b165401f291070100d6d09359ca74addda679b60390b09f8ef325ffe"}, - {file = "tornado-6.1-cp39-cp39-manylinux1_x86_64.whl", hash = "sha256:7da13da6f985aab7f6f28debab00c67ff9cbacd588e8477034c0652ac141feea"}, - {file = "tornado-6.1-cp39-cp39-manylinux2010_i686.whl", hash = "sha256:e0791ac58d91ac58f694d8d2957884df8e4e2f6687cdf367ef7eb7497f79eaa2"}, - {file = "tornado-6.1-cp39-cp39-manylinux2010_x86_64.whl", hash = "sha256:66324e4e1beede9ac79e60f88de548da58b1f8ab4b2f1354d8375774f997e6c0"}, - {file = "tornado-6.1-cp39-cp39-manylinux2014_aarch64.whl", hash = "sha256:a48900ecea1cbb71b8c71c620dee15b62f85f7c14189bdeee54966fbd9a0c5bd"}, - {file = "tornado-6.1-cp39-cp39-win32.whl", hash = "sha256:d3d20ea5782ba63ed13bc2b8c291a053c8d807a8fa927d941bd718468f7b950c"}, - {file = "tornado-6.1-cp39-cp39-win_amd64.whl", hash = "sha256:548430be2740e327b3fe0201abe471f314741efcb0067ec4f2d7dcfb4825f3e4"}, - {file = "tornado-6.1.tar.gz", hash = "sha256:33c6e81d7bd55b468d2e793517c909b139960b6c790a60b7991b9b6b76fb9791"}, -] -types-pyyaml = [ - {file = "types-PyYAML-6.0.8.tar.gz", hash = "sha256:d9495d377bb4f9c5387ac278776403eb3b4bb376851025d913eea4c22b4c6438"}, - {file = "types_PyYAML-6.0.8-py3-none-any.whl", hash = "sha256:56a7b0e8109602785f942a11ebfbd16e97d5d0e79f5fbb077ec4e6a0004837ff"}, -] -typing-extensions = [ - {file = "typing_extensions-4.2.0-py3-none-any.whl", hash = "sha256:6657594ee297170d19f67d55c05852a874e7eb634f4f753dbd667855e07c1708"}, - {file = "typing_extensions-4.2.0.tar.gz", hash = "sha256:f1c24655a0da0d1b67f07e17a5e6b2a105894e6824b92096378bb3668ef02376"}, -] -urllib3 = [ - {file = "urllib3-1.26.9-py2.py3-none-any.whl", hash = "sha256:44ece4d53fb1706f667c9bd1c648f5469a2ec925fcf3a776667042d645472c14"}, - {file = "urllib3-1.26.9.tar.gz", hash = "sha256:aabaf16477806a5e1dd19aa41f8c2b7950dd3c746362d7e3223dbe6de6ac448e"}, -] -xarray = [ - {file = "xarray-2022.3.0-py3-none-any.whl", hash = "sha256:560f36eaabe7a989d5583d37ec753dd737357aa6a6453e55c80bb4f92291a69e"}, - {file = "xarray-2022.3.0.tar.gz", hash = "sha256:398344bf7d170477aaceff70210e11ebd69af6b156fe13978054d25c48729440"}, -] -xgboost = [ - {file = "xgboost-1.6.1-py3-none-macosx_10_15_x86_64.macosx_11_0_x86_64.macosx_12_0_x86_64.whl", hash = "sha256:2b3d4ee105f8434873b40edc511330b8276bf3a8d9d42fb0319973079df30b07"}, - {file = "xgboost-1.6.1-py3-none-macosx_12_0_arm64.whl", hash = "sha256:bd3e59a5490e010004106d8ea1d07aa8e048be51a0974fca6b4f00988f087ab8"}, - {file = "xgboost-1.6.1-py3-none-manylinux2014_aarch64.whl", hash = "sha256:bbf16af8bf72e8761fcf69fdb5798bd5add6ecb48049198551b13c1d7abeabb5"}, - {file = "xgboost-1.6.1-py3-none-manylinux2014_x86_64.whl", hash = "sha256:6207c77f611b54d9f056edede819ead03f0235615675f88030ff9fe10d359551"}, - {file = "xgboost-1.6.1-py3-none-win_amd64.whl", hash = "sha256:3adcb7e4ccf774d5e0128c01e5c381303c3799910ab0f2e996160fe3cd23b7fc"}, - {file = "xgboost-1.6.1.tar.gz", hash = "sha256:24072028656f3428e7b8aabf77340ece057f273e41f7f85d67ccaefb7454bb18"}, -] -zict = [ - {file = "zict-2.2.0-py2.py3-none-any.whl", hash = "sha256:dabcc8c8b6833aa3b6602daad50f03da068322c1a90999ff78aed9eecc8fa92c"}, - {file = "zict-2.2.0.tar.gz", hash = "sha256:d7366c2e2293314112dcf2432108428a67b927b00005619feefc310d12d833f3"}, -] -zipp = [ - {file = "zipp-3.8.0-py3-none-any.whl", hash = "sha256:c4f6e5bbf48e74f7a38e7cc5b0480ff42b0ae5178957d564d18932525d5cf099"}, - {file = "zipp-3.8.0.tar.gz", hash = "sha256:56bf8aadb83c24db6c4b577e13de374ccfb67da2078beba1d037c17980bf43ad"}, -] +affine = [] +aiohttp = [] +aiosignal = [] +anyio = [] +appnope = [] +argon2-cffi = [] +argon2-cffi-bindings = [] +asttokens = [] +async-timeout = [] +atomicwrites = [] +attrs = [] +backcall = [] +beautifulsoup4 = [] +bleach = [] +branca = [] +cachetools = [] +certifi = [] +cffi = [] +cftime = [] +charset-normalizer = [] +click = [] +click-plugins = [] +cligj = [] +cloudpickle = [] +colorama = [] +cycler = [] +dask = [] +dask-geopandas = [] +dask-image = [] +datacube = [] +debugpy = [] +decorator = [] +defusedxml = [] +distributed = [] +entrypoints = [] +executing = [] +fastjsonschema = [] +fiona = [] +fonttools = [] +frozenlist = [] +fsspec = [] +gdal = [] +geopandas = [] +graphviz = [] +greenlet = [] +heapdict = [] +idna = [] +imageio = [] +importlib-resources = [] +iniconfig = [] +ipykernel = [] +ipyleaflet = [] +ipython = [] +ipython-genutils = [] +ipywidgets = [] +jedi = [] +jinja2 = [] +jsonschema = [] +jupyter-client = [] +jupyter-core = [] +jupyter-server = [] +jupyter-server-proxy = [] +jupyterlab-pygments = [] +jupyterlab-widgets = [] +kiwisolver = [] +lark-parser = [] +locket = [] +lz4 = [] +markupsafe = [] +matplotlib = [] +matplotlib-inline = [] +mercantile = [] +mistune = [] +msgpack = [] +multidict = [] +munch = [] +mypy = [] +mypy-extensions = [] +nbclient = [] +nbconvert = [] +nbformat = [] +nest-asyncio = [] +netcdf4 = [] +networkx = [] +notebook = [] +numexpr = [] +numpy = [] +odc-algo = [] +packaging = [] +pandas = [] +pandocfilters = [] +parso = [] +partd = [] +pexpect = [] +pickleshare = [] +pillow = [] +pims = [] +pkgutil-resolve-name = [] +pluggy = [] +prometheus-client = [] +prompt-toolkit = [] +psutil = [] +psycopg2 = [] +ptyprocess = [] +pure-eval = [] +py = [] +pycparser = [] +pygeos = [] +pygments = [] +pyparsing = [] +pyproj = [] +pyrsistent = [] +pystac = [] +pystac-client = [] +pytest = [] +python-dateutil = [] +pytz = [] +pywavelets = [] +pywin32 = [] +pywinpty = [] +pyyaml = [] +pyzmq = [] +rasterio = [] +requests = [] +rioxarray = [] +scikit-image = [] +scipy = [] +send2trash = [] +setuptools-scm = [] +shapely = [] +simpervisor = [] +six = [] +slicerator = [] +sniffio = [] +snuggs = [] +sortedcontainers = [] +soupsieve = [] +sqlalchemy = [] +stack-data = [] +stackstac = [] +tblib = [] +terminado = [] +tifffile = [] +tinycss2 = [] +tomli = [] +toolz = [] +tornado = [] +traitlets = [] +traittypes = [] +types-pyyaml = [] +typing-extensions = [] +urllib3 = [] +wcwidth = [] +webencodings = [] +websocket-client = [] +widgetsnbextension = [] +xarray = [] +xgboost = [] +yarl = [] +zict = [] +zipp = [] diff --git a/pyproject.toml b/pyproject.toml index e7f6f8b4..34a2a1e0 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -17,23 +17,35 @@ secondary = true python = "^3.8" numpy = "^1" pandas = "^1" -xarray = ">=0.18.2" pyproj = "^3" -xgboost = "^1.5.0" -rioxarray = "^0.9" -geopandas = "^0.10" -Equi7Grid = "^0.1.0" -datacube = "^1.8.4" -dask-geopandas = "^v0.1.0a7" +xarray = ">=0.18.2,<=2022.3.0" # 2022.6.0 onwards breaks the current ufunc implementations dask = {extras = ["array"], version = "^2022.02.1"} +distributed = "^2022.7.1" odc-algo = {extras = ["xarray"], version = "^0.2.2"} -GDAL = "^3.5.0" -PyYAML = "^6.0" +geopandas = { version = "^0.10", optional = true } +dask-geopandas = { version = "^v0.1.0", optional = true } +xgboost = { version = "^1.5.0", optional = true } +rioxarray = { version = "^0.9", optional = true } +datacube = { version = "^1.8.4", optional = true } +GDAL = { version = "^3.5.0", optional = true } +PyYAML = { version = "^6.0", optional = true } +stackstac = { extras = ["viz"], version = "^0.4.2", optional = true } +pystac-client = "^0.4.0" +lz4 = "^4.0.2" [tool.poetry.dev-dependencies] pytest = "^7.1.2" mypy = "^0.961" types-PyYAML = "^6.0" +ipykernel = "^6.15.1" +graphviz = "^0.20.1" + +[tool.poetry.extras] +load-save = ["datacube", "GDAL", "rioxarray", "PyYAML", "stackstac"] +vector = ["geopandas", "dask-geopandas"] +ml = ["xgboost"] +dask-worker = ["datacube", "rioxarray", "PyYAML", "stackstac", "geopandas", "dask-geopandas", "xgboost"] + [tool.mypy] files = "src" diff --git a/src/openeo_processes/__init__.py b/src/openeo_processes/__init__.py index d220e98e..c27c41cd 100644 --- a/src/openeo_processes/__init__.py +++ b/src/openeo_processes/__init__.py @@ -1,14 +1,5 @@ # -*- coding: utf-8 -*- # type: ignore -from pkg_resources import get_distribution, DistributionNotFound - -try: - # Change here if project is renamed and does not equal the package name - dist_name = 'openeo_processes' - __version__ = get_distribution(dist_name).version -except DistributionNotFound: - __version__ = 'unknown' - from openeo_processes.arrays import * from openeo_processes.comparison import *