diff --git a/.github/dependabot.yml b/.github/dependabot.yml
new file mode 100644
index 0000000..563dd9b
--- /dev/null
+++ b/.github/dependabot.yml
@@ -0,0 +1,11 @@
+# See https://docs.github.com/en/code-security/supply-chain-security/keeping-your-dependencies-updated-automatically/keeping-your-actions-up-to-date-with-dependabot
+
+version: 2
+updates:
+
+ - package-ecosystem: "github-actions"
+ directory: "/"
+ schedule:
+ interval: "daily"
+ labels:
+ - "Bot"
diff --git a/.github/workflows/conda-tests.yml b/.github/workflows/conda-tests.yml
deleted file mode 100644
index b4cf722..0000000
--- a/.github/workflows/conda-tests.yml
+++ /dev/null
@@ -1,38 +0,0 @@
-name: Conda-tests
-
-on:
- pull_request:
- push:
- branches: [master]
-
-jobs:
- run:
- runs-on: ${{ matrix.os }}
- strategy:
- matrix:
- python-version: ["3.7", "3.8", "3.9"]
- os: [windows-latest, ubuntu-latest, macos-latest]
-
- steps:
- - uses: actions/checkout@v2
-
- - name: Setup Conda
- uses: s-weigand/setup-conda@v1
- with:
- activate-conda: false
- conda-channels: conda-forge
-
- - name: Python ${{ matrix.python-version }}
- shell: bash -l {0}
- run: |
- conda create --name TEST python=${{ matrix.python-version }} --file requirements.txt --file requirements-dev.txt
- source activate TEST
- pip install -e . --no-deps --force-reinstall
- conda info --all
- conda list
-
- - name: Tests
- shell: bash -l {0}
- run: |
- source activate TEST
- pytest -rxs --cov=oceans tests
diff --git a/.github/workflows/deploy-docs.yml b/.github/workflows/deploy-docs.yml
new file mode 100644
index 0000000..abad4ab
--- /dev/null
+++ b/.github/workflows/deploy-docs.yml
@@ -0,0 +1,48 @@
+name: Documentation
+
+on:
+ pull_request:
+ push:
+ branches:
+ - main
+ release:
+ types:
+ - published
+
+jobs:
+ build-docs:
+ runs-on: ubuntu-latest
+
+ steps:
+ - name: checkout
+ uses: actions/checkout@v3
+ with:
+ fetch-depth: 0
+
+ - name: Setup Mamba
+ uses: mamba-org/provision-with-micromamba@v15
+ with:
+ environment-file: false
+
+ - name: Build environment
+ shell: bash -l {0}
+ run: |
+ micromamba create --name TEST python=3 --file requirements.txt --file requirements-dev.txt --channel conda-forge
+ micromamba activate TEST
+ python -m pip install -e . --no-deps --force-reinstall
+
+ - name: Build documentation
+ shell: bash -l {0}
+ run: |
+ set -e
+ micromamba activate TEST
+ pushd docs
+ make clean html linkcheck
+ popd
+
+ - name: Deploy
+ if: success() && github.event_name == 'release'
+ uses: peaceiris/actions-gh-pages@v3
+ with:
+ github_token: ${{ secrets.GITHUB_TOKEN }}
+ publish_dir: docs/build/html
diff --git a/.github/workflows/pip-tests.yml b/.github/workflows/pip-tests.yml
deleted file mode 100644
index a6bfef2..0000000
--- a/.github/workflows/pip-tests.yml
+++ /dev/null
@@ -1,33 +0,0 @@
-name: Pip-tests
-
-on:
- pull_request:
- push:
- branches: [master]
-
-jobs:
- run:
- runs-on: ${{ matrix.os }}
- strategy:
- matrix:
- python-version: ["3.7", "3.8", "3.9"]
- os: [ubuntu-latest]
-
- steps:
- - uses: actions/checkout@v2
-
- - name: Setup python
- uses: actions/setup-python@v2
-
- - name: Install proj
- run: sudo apt-get install libgeos-dev libproj-dev
-
- - name: Python ${{ matrix.python-version }}
- run: |
- pip install numpy cython
- pip install -r requirements.txt -r requirements-dev.txt
- pip install -e . --no-deps --force-reinstall
-
- - name: pip-tests
- run: |
- pytest -rxs --cov=oceans tests
diff --git a/.github/workflows/pre-commit.yml b/.github/workflows/pre-commit.yml
deleted file mode 100644
index 7233479..0000000
--- a/.github/workflows/pre-commit.yml
+++ /dev/null
@@ -1,14 +0,0 @@
-name: pre-commit
-
-on:
- pull_request:
- push:
- branches: [master]
-
-jobs:
- pre-commit:
- runs-on: ubuntu-latest
- steps:
- - uses: actions/checkout@v2
- - uses: actions/setup-python@v2
- - uses: pre-commit/action@v2.0.0
diff --git a/.github/workflows/pypi.yml b/.github/workflows/pypi.yml
new file mode 100644
index 0000000..bf4fd0a
--- /dev/null
+++ b/.github/workflows/pypi.yml
@@ -0,0 +1,52 @@
+name: Publish to PyPI
+
+on:
+ pull_request:
+ push:
+ branches:
+ - main
+ release:
+ types:
+ - published
+
+jobs:
+ packages:
+ runs-on: ubuntu-latest
+ steps:
+ - uses: actions/checkout@v3
+
+ - name: Set up Python
+ uses: actions/setup-python@v4
+ with:
+ python-version: "3.x"
+
+ - name: Get tags
+ run: git fetch --depth=1 origin +refs/tags/*:refs/tags/*
+ shell: bash
+
+ - name: Install build tools
+ run: |
+ python -m pip install --upgrade pip wheel setuptools setuptools_scm build twine
+
+ shell: bash
+
+ - name: Build binary wheel
+ run: python -m build --sdist --wheel . --outdir dist
+
+ - name: CheckFiles
+ run: |
+ ls dist
+ shell: bash
+
+ - name: Test wheels
+ run: |
+ cd dist && python -m pip install *.whl
+ python -m twine check *
+ shell: bash
+
+ - name: Publish a Python distribution to PyPI
+ if: success() && github.event_name == 'release'
+ uses: pypa/gh-action-pypi-publish@release/v1
+ with:
+ user: __token__
+ password: ${{ secrets.PYPI_PASSWORD }}
diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml
new file mode 100644
index 0000000..63251fa
--- /dev/null
+++ b/.github/workflows/tests.yml
@@ -0,0 +1,45 @@
+name: Tests
+
+on:
+ pull_request:
+ push:
+ branches: [main]
+
+jobs:
+ run:
+ runs-on: ${{ matrix.os }}
+ strategy:
+ matrix:
+ python-version: ["3.8", "3.9", "3.10", "3.11"]
+ os: [windows-latest, ubuntu-latest, macos-latest]
+ fail-fast: false
+
+ steps:
+ - uses: actions/checkout@v3
+ with:
+ fetch-depth: 0
+
+ - name: Setup Micromamba
+ uses: mamba-org/provision-with-micromamba@v15
+ with:
+ environment-file: false
+
+ - name: Python ${{ matrix.python-version }}
+ shell: bash -l {0}
+ run: >
+ micromamba create --name TEST python=${{ matrix.python-version }} --file requirements.txt --file requirements-dev.txt --channel conda-forge
+ && micromamba activate TEST
+ && python -m pip install -e . --no-deps --force-reinstall
+
+
+ - name: Tests
+ shell: bash -l {0}
+ run: >
+ micromamba activate TEST
+ && python -m pytest -n 2 -rxs --cov=oceans tests
+
+ - name: Doctests
+ shell: bash -l {0}
+ run: >
+ micromamba activate TEST
+ && python -m pytest -vv oceans --doctest-modules
diff --git a/.gitignore b/.gitignore
index 901aa23..9175c85 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,5 +1,7 @@
*.egg-info
.cache
+.coverage
+.ipynb_checkpoints/
build/
dist/
-.ipynb_checkpoints/
+oceans/_version.py
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index 5445db7..a88636b 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -1,7 +1,7 @@
repos:
- repo: https://github.com/pre-commit/pre-commit-hooks
- rev: v3.4.0
+ rev: v4.4.0
hooks:
- id: check-ast
- id: end-of-file-fixer
@@ -14,34 +14,43 @@ repos:
- id: trailing-whitespace
- id: debug-statements
-- repo: https://gitlab.com/pycqa/flake8
- rev: 3.9.0
+
+# - repo: https://github.com/econchick/interrogate
+# rev: 1.5.0
+# hooks:
+# - id: interrogate
+# exclude: ^(docs|setup.py|tests)
+# args: [--config=pyproject.toml]
+
+- repo: https://github.com/keewis/blackdoc
+ rev: v0.3.8
hooks:
- - id: flake8
- exclude: docs/source/conf.py
- args: [--max-line-length=105, "--ignore=E203,W503"]
+ - id: blackdoc
-- repo: https://github.com/pycqa/isort
- rev: 5.7.0
+- repo: https://github.com/charliermarsh/ruff-pre-commit
+ rev: v0.0.253
hooks:
- - id: isort
- additional_dependencies: [toml]
- args: ["--profile", "black", "--filter-files"]
+ - id: ruff
- repo: https://github.com/psf/black
- rev: 20.8b1
+ rev: 23.1.0
hooks:
- id: black
language_version: python3
-- repo: https://github.com/asottile/pyupgrade
- rev: v2.10.0
+- repo: https://github.com/codespell-project/codespell
+ rev: v2.2.2
hooks:
- - id: pyupgrade
+ - id: codespell
args:
- - --py36-plus
+ - --ignore-words-list=pres
- repo: https://github.com/asottile/add-trailing-comma
- rev: v2.1.0
+ rev: v2.4.0
hooks:
- id: add-trailing-comma
+
+- repo: https://github.com/tox-dev/pyproject-fmt
+ rev: "0.9.2"
+ hooks:
+ - id: pyproject-fmt
diff --git a/.travis.yml b/.travis.yml
deleted file mode 100644
index d4b1506..0000000
--- a/.travis.yml
+++ /dev/null
@@ -1,88 +0,0 @@
-language: python
-
-sudo: false
-
-dist: xenial
-services:
- - xvfb
-
-env:
- global:
- # Doctr deploy key for pyoceans/python-oceans
- - secure: "MohzYBz9P2VQhPTISFMV+X4Jj+E1RrrZt+39L+wc6G+uQp+cWn/gKMg2HaqH7Naed/Z4VNdcoKbT1XA+masTuLXERKtdCIi9ad7cdlaDapmnoKZ1eloZRZltQ7xzBYtMQYrgRYe4URG910pfbwRFKC0pg0+ektE5QGyEUTzHxUw="
-
-matrix:
- fast_finish: true
- include:
- - name: "python-3.7"
- env: PY=3.7
- - name: "python-3.8"
- env: PY=3.8
- - name: "doctests"
- env: PY=3
- - name: "tarball"
- env: PY=3
- - name: "docs"
- env: PY=3
-
-before_install:
- # Install miniconda and create TEST env.
- - |
- wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh -O miniconda.sh
- bash miniconda.sh -b -p $HOME/miniconda
- export PATH="$HOME/miniconda/bin:$PATH"
- conda config --set always_yes yes --set changeps1 no --set show_channel_urls true
- conda update --quiet conda
- conda config --add channels conda-forge --force
- conda config --set channel_priority strict
- conda config --set safety_checks disabled
- conda create --name TEST python=$PY --file requirements.txt --file requirements-dev.txt
- source activate TEST
- conda info --all
-
-install:
- - pip install -e . --no-deps --force-reinstall
-
-script:
- - if [[ $TRAVIS_JOB_NAME == python-* ]]; then
- cp -r tests/ /tmp ;
- pushd /tmp && pytest -n 2 -rxs --cov=oceans tests && popd ;
- fi
-
- - if [[ $TRAVIS_JOB_NAME == 'tarball' ]]; then
- pip wheel . -w dist --no-deps ;
- check-manifest --verbose ;
- twine check dist/* ;
- fi
-
- - if [[ $TRAVIS_JOB_NAME == doctests ]]; then
- pytest -vv oceans --doctest-modules ;
- fi
-
- - |
- if [[ $TRAVIS_JOB_NAME == 'docs' ]]; then
- set -e
- conda install doctr
- pushd docs
- make clean html linkcheck
- popd
- python -m doctr deploy . --key-path github_deploy_key.enc --built-docs docs/build/html/
- fi
-
-doctr:
- require-master: true
- sync: False
-
-deploy:
- skip_cleanup: true
- provider: pypi
- user: ocefpaf
- password:
- secure: "HifofjCDgTUP3hv0C8xD411JBCIp7VziSE5SiD9ZXo9CGo/rnr2rxtIcA9QDHfwO0n1iK26AhUbmeUURecn7+GjvvwCsbN3y21zfx0/D6KCSCvfEuJBJG2uAZqbNBFkT5//96umsavVngp0vNzOASDCljBgC9t5X0r1JnybQUro="
- distributions: sdist bdist_wheel
- upload_docs: no
- on:
- repo: pyoceans/python-oceans
- tags: true
- all_branches: master
- condition: '$TRAVIS_JOB_NAME == "tarball"'
diff --git a/MANIFEST.in b/MANIFEST.in
index ed12ad0..d1f5a65 100644
--- a/MANIFEST.in
+++ b/MANIFEST.in
@@ -1,6 +1,19 @@
-include README.rst
include *.txt
-recursive-include oceans *.py
-include oceans/colormaps/cmap_data/*.dat
-include versioneer.py
-include oceans/_version.py
+include README.md
+include pyproject.toml
+
+graft oceans
+
+prune docs
+prune tests
+prune notebooks
+prune *.egg-info
+prune .github
+
+exclude *.yml
+exclude .pre-commit-config.yaml
+exclude .gitignore
+exclude .isort.cfg
+exclude oceans/_version.py
+exclude code-of-conduct.md
+exclude .gitattributes
diff --git a/Makefile b/Makefile
deleted file mode 100644
index edcb8b9..0000000
--- a/Makefile
+++ /dev/null
@@ -1,24 +0,0 @@
-release:
- rm -rf dist/
- python setup.py sdist bdist_wheel
- twine upload dist/*
-
-isort:
- isort --remove-import . --apply --use-parentheses --trailing-comma
-
-format:
- black --line-length 79 .
-
-style: isort format
-
-docs:
- pushd docs && make clean html linkcheck && popd
-
-lint:
- pytest --flake8 -m flake8
-
-test:
- pytest -n 2 -rxs --cov=oceans tests
-
-check: style docs lint test
- echo "All checks complete!"
diff --git a/docs/source/conf.py b/docs/source/conf.py
index 28720b6..b1bd46b 100644
--- a/docs/source/conf.py
+++ b/docs/source/conf.py
@@ -19,13 +19,12 @@
# -- Project information -----------------------------------------------------
project = "oceans"
-copyright = "2018, Filipe Fernandes"
+copyright = "2023, Filipe Fernandes"
author = "Filipe Fernandes"
-from oceans._version import get_versions
+import oceans
-version = release = get_versions()["version"]
-del get_versions
+version = release = oceans.__version__
# -- General configuration ---------------------------------------------------
@@ -62,7 +61,7 @@
#
# This is also used if you do content translation via gettext catalogs.
# Usually you set "language" from the command line for these cases.
-language = None
+language = "en"
# List of patterns, relative to source directory, that match files and
# directories to ignore when looking for source files.
diff --git a/github_deploy_key.enc b/github_deploy_key.enc
deleted file mode 100644
index bf1c927..0000000
--- a/github_deploy_key.enc
+++ /dev/null
@@ -1 +0,0 @@
-gAAAAABb3uHirLV4cF5-conbMozB4SXggEYX8RmnOXf5lA2otCk3ZG0kGSDK7zYjTkoxOyXzC1JJ_SZsiyTJAvbCdx16T1_FqfH37uKWLuLaV20HF35eMBo79h9tTVajmxajJLaYKpxgnviM9QFyfYe1ltMeQo5D5y2N8bJ0oHr921vUMKXYSAp1-Z8EMRwZJy88yAOpiG7epfFqknWGVXpi6p4DPooTtmA5kXNh5m_k8Pe8Z0n6TnsKZwity9DPV7O6Ua0r-QZmC7Mv2LG4TrEjYPGTFknB8uqlptRnD3KL5G6G_csScQHGqHvXLghdIXVsBTFRwL36Tz4B-d4q5WAAecwPYWFVnEPIYMEVLWiO6i2bILcKOuRv5izaruTiZAljSbWwKU054KQGUuDco7AvrUBk5j8ucob4DXT9KARQ4HSnUO3JCERLli0boZe_6Sb2-DKV8Tv-tsSpBDO2RwnrS0726TOZrFsnvTtQ_rcOSmoD1gTZu5cOM4_coNPSzh-HL-J1x8HLsLbJW7ZhKTnh81MrbZVPNgp8FfRdprdC1pc3qu_5XORStfXT2JW2G9-qOsXFC6L4p6QCKQM5cKvnFQaixyJY1xAT3jzq5H9rOLyiLHHtrkohdKwoiH8co36Y4P9VOSK5iSyqQ6GzkmmiJlv972R-Rth5KfCCC08VQENKlRVer1QzsBRnFg1d8bqmhlka2iFR1sbeJ60GPrcK4yr3Wj6Ysg87P48V4odoIu_nLzzywDPnx_V5eYgnjyom9QISTTxdvlf-ZapOlraH2UDNFRfj8Grku7G-rXSUqFOdMq_5FdYwnl1MYi2H2Qs-ICWyadXMeSqhVFpQoTnPcxdE7iXoW2G-Qc9NLwKbhYXrkVKsSrOTTDrH2TKChueZ1sXdBs1otaFKlXcGf5LxpZbH6XW8wTeTq4kFnCIfNAs2byTq5_UsSybiCYAfAGrM-dP7GwlEqI5lxAZ9d8NkbPYqRJ-lVPxQ_E9Tj6T8Rp2RGHHgzZq4X7d5In7xxpm-LKAT8JkMSEWc6mZNHsnA3qF35Zo7DxPkeC4O50lbujmDEcPEdONjeCYhk-sJ0ASZQxKvs7IYtyX5LG1M4YC4HZykJhC0dm0h2xZedR8aHdC4MgJJvD9oAZT6V-KBT4SflfIJ8iOIVOv-mXvw-L9ziGMT74rkTweP5ysJ4puBwG4YRjhkaT_p_-aNsC-CV3zcDfVhIJVxM5qpXWzlW_P8_39AtyEIEFDdm5gTlNRTougz8wI7UkCKH5eAOBrPA6dfXqf2WjxquslHfCBQjs4eTgHPZ_KlwMlUIWRzShMwnwZmg0Khr5K8BxkXIEd1fs6ykYZbLn9MbQxV21De9DU-E_NUiDkDP9yMbekrNDAJlZAFizxIF9EuaXdeeUPnHGURChgSkaCIaAEWrc-x3U4pH4fW37-zAxOtfaEK1juwO8J3GFwBKfclVRF5aJ38PvHIjoeA-XFSqrVnoDwpQEuXJ4i2FxFuEcxYyxCtAQ9diBobtfy8QKMGs90j4KNBHbUzFf4vh0NHSrQbd3p5Clm8AC_-jCAtH8XSfmx0zTHspV8elSy_UATJ0QRsYWXmJq8wNOfxy8k5kCTtRgSVk5LbNKYdRM5wHg2btOvuJ1unwFIGWkZdOgjSKtI5euAyP71KMY2q59LMtrcl_BJlMjsimcMNhLHJf6rEkeqcMLau65OXBSJAZVx3-MP4QofpMGWKH9fO7k_YBfsR78_hgfW4ILwf6Tad4VPgSVNLbhg4V9RNndmX5hA4Wp7DSINUTf-BFjzw42ZSMcnqW5UnnjftEhsv3nQT152vYjYyhiLvW4Oex_B88pmxKFXL3KHrvZOW6nqNotERpJ7c22fVz7WlGfry9p5_R3Xcz9FjdcBvVU0CZ0eVQbnAW94L40dphGniPScG4saDdLAMML_Gsk_mb-a6wfAKMoMYGh-KuhnEWmBfKxtPnIMk7BzLpQxoxrC3RhYlokSPVuwE-Z2mAeikhwvoMkgs2r8MLYD84QG1wA3rPFN2HgASDnEVYmHU6-vrpR0GfIDvi-ulvqSBUhkAfRqmZ6vUyu39J-24f0tY1V9p6eG3z9LMBasJvjvtr7bmMRvcUmadSEBeEL_yYUhTj9703FVxNUgCoufgpFW5B5g_7YAxZTaGL2hImGu5qxLarwxNHsd_YoySMcIh9jKXSNqBtqpH4hS9LFkCDAatHeU4G3yFO6cKibKpqo5p7rEeZYi7LPfGdFlIyCq_rmIrkqFD_I7IgOV9v4auYvfBLLyDGSSbVuzhaxPoXD8ubm8q6m8tDhzVnmj2vv4pQlfs21MjP5F4mmZoC7SmVnU0tmUSTdJ7_DMs9rYVPtUopIIopGaHxW-pg-CLyswAQLQl8bfgeGPF_Edlsae0eY72j2wKKmwxv9ZUiQ36nfPZCWcxD93FH5OWjGqiK4tG2Kzqr61hrbqgjGddGEExmvbwYE_VU8tYJrNVQvuft28iabuaQYsJN3zPL2rZiTF-bUoxxesaPpeqYbIhVh4P7JYCF6_WDqh1g3-FEnqItmye3ezSiRfzuu4AmTeCtYaJQkBcMvcLm1x0R0jOAWo-NbLsKIJSAfFDEk64UJg8dcGYEQsGl1jPkTUjVjKps_a4BbMm8jHmz682cfL6F3tcmAe3NCK1G7u14HFPoxSW5S3uWYZwowHeUksSxs_DMxNaj-mAMsnkOJ5yXzq8_rKOqOX6u0Ib8KxIkJ7bQyee8FOSpdmttyDNePDhhaLS7F3TtaVOF5C_KQzDa29e1NPoHZhMdVh7cbgppUZxVzVIUWNsfEiCehyAx5H-gOqllwGomjoMG3V0nUyLFApj0Ik7--ImmvtRmMuhsBCWh4Z0ZjbwZqlC_7j0W6b6e6-1ZUJ8V5lBDZAZmCbdNXDHx_CNpwq1TMSZV2u-MVp2ATI7BR1xs7tIURhBIEsTV1xkcW4qsb9QjRs9ybxnhYo-ukSpy6OVFX9cSYyoiwMxSdCg25l3YBbm0KLOIdz3yg8HQprVvtNomYrdwtJzO4g0t6HrrV7aLTwadyLHp-NqVb-JZ2QNOw5kRtfabOBIkYdIWSdRJTdtaccU3j3cPNmVWs8v8YZv3NAQabZxJaWjpRN0CSqsJ-TVhQhyyyyDDk4_XcuyekK0V30BJ1XQo6VqzKbkeni6TBIXscoTHJWG9NauN84Sq1Vffdeho6ZoBZ95E6OBnc_wq6miBwAL9xm5Z41oHFkFP9IH50w0nJXCfGaV2c8yQ0d9VrZK7_kq4ak1tftjZ2wbqO7c5eSDt8H0rJQI5rDtIC8_6rYEHDP1GGQW0GOpzknfSmqaDfk6Ktak5yE926C-_R87D7pJw9bH0UZpIGCdkchkAv1mSaDN7jegcStlympxJBxr4lYXObCIEo_bA1OtE3rqOr9Q005il-cyruRXEwGCxljFRVedxfEigbPIw46Q60Bml771u4XjPmJM2v0ySxl4J75fPaEXqfPyMTxgtP32jysZML3UAIOTvqXBMCJamb1LmmN8PG4q4WCR51wmqqqCrb5i8aXsIya-SRL-ChutsQBJBHL_4od7OwHobhQhyxJJDBfH8n8RIpJ9pnvoFbu4__FLviveWgkb7gglwLGIPn2W0Hvj5GOUPwkfNGfw9gN-PQKOXyPsYby5SX587NUULX9efjxCxPxjXDKDMn4p5ytOGNBj0iRcjsJGRXXPozecXYAdfc-1OFpk8jUVsgCTxKhyGbn-W4qUo4cskLW5n54qa_8D2cfWTwCMfloXgWRybT3rMC4FU0G4FmLJJjcJ3BR2EzNGv7SMazsD7pa7VG5DTw_KVH4yaaJ8PfI6vvShDnxIhQoTBTUiRzz5IrzwmrLvu5W9YWxtiqPCTnwLq2seJqjzSzZtyIb-8u_jFZ-C43LAw15a-lU0M7PcD-Pm4XC65jf9qwvn82WZeoFy2YEbZOIA4W255HfDgoV1-aDhX_DgiU1v_zUACbr8ngTDp4c4gXwbWVWQyvAA6rcP7ekyq5Ja2Fn8r6ljZSoj1um2d9mh_63o7ZswI3bAC5fTZM2T_WgCeIjQIA5dLBBb1a2nn-NLmkYrWIO0vBK6jYnCufsp06_gyx7bZiTK1WXejnOl3V3MnSNWtFrjKv1v4Nw_us3RQsYcTQhUoQqSIUUa-xc-Wl5Bcp9zpRUAGE0E9K6OEtDl0jJ_yvKozE7DAWIpXOAsRFV-j9w-t0MHcAk-_p2ffKsAI9V0ZNU9k3fzE1Ws0g2SUIJFI6Lh2uvEn-imzvP0F9XkVGGQRyUprURgtz8Lx6dSQXHOCBZnoKQiQfgcRYILxG0DD4g2Kn-OP7FKYDoaYIbl_iEq_Z49qXurLKlUVKwg4Z6vEzCp6gCC4g8iODY1CmeZGUUFerKAFIFCRhyV7n8dX942xD2IOrki0xxt1wIaVFlm49nYg1JqNXSufw==
\ No newline at end of file
diff --git a/notebooks/fetch_datasets.ipynb b/notebooks/fetch_datasets.ipynb
index aec3289..ff689d4 100644
--- a/notebooks/fetch_datasets.ipynb
+++ b/notebooks/fetch_datasets.ipynb
@@ -1,16 +1,5 @@
{
"cells": [
- {
- "cell_type": "code",
- "execution_count": 1,
- "metadata": {},
- "outputs": [],
- "source": [
- "%matplotlib inline\n",
- "from matplotlib import style\n",
- "style.use([\"dark_background\", \"seaborn-poster\"])"
- ]
- },
{
"cell_type": "markdown",
"metadata": {},
@@ -20,63 +9,9 @@
},
{
"cell_type": "code",
- "execution_count": 2,
+ "execution_count": null,
"metadata": {},
- "outputs": [
- {
- "data": {
- "text/html": [
- "
\n",
- "\n",
- "
\n",
- " \n",
- " \n",
- " | \n",
- " lon | \n",
- " lat | \n",
- " depth | \n",
- "
\n",
- " \n",
- " \n",
- " \n",
- " 0 | \n",
- " -40 | \n",
- " -20 | \n",
- " -32.988164 | \n",
- "
\n",
- " \n",
- " 1 | \n",
- " -32 | \n",
- " -20 | \n",
- " -4275.633746 | \n",
- "
\n",
- " \n",
- "
\n",
- "
"
- ],
- "text/plain": [
- " lon lat depth\n",
- "0 -40 -20 -32.988164\n",
- "1 -32 -20 -4275.633746"
- ]
- },
- "execution_count": 2,
- "metadata": {},
- "output_type": "execute_result"
- }
- ],
+ "outputs": [],
"source": [
"import pandas as pd\n",
"from oceans.datasets import get_depth\n",
@@ -93,7 +28,7 @@
},
{
"cell_type": "code",
- "execution_count": 3,
+ "execution_count": null,
"metadata": {},
"outputs": [],
"source": [
@@ -108,22 +43,9 @@
},
{
"cell_type": "code",
- "execution_count": 4,
+ "execution_count": null,
"metadata": {},
- "outputs": [
- {
- "data": {
- "image/png": "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\n",
- "text/plain": [
- ""
- ]
- },
- "metadata": {
- "needs_background": "dark"
- },
- "output_type": "display_data"
- }
- ],
+ "outputs": [],
"source": [
"import matplotlib.pyplot as plt\n",
"import cartopy.crs as ccrs\n",
@@ -139,31 +61,18 @@
" ax.text(row[\"lon\"], row[\"lat\"], f\"{row['depth']:.2f} m\", color=\"white\")\n",
"\n",
"cs = ax.pcolormesh(lon, lat, bathy)\n",
- "for segment in segments:\n",
+ "for segment in segments[0]:\n",
" lines = ax.plot(segment[:, 0], segment[:, -1], \"darkorange\", linewidth=2)\n",
"\n",
"ax.coastlines(\"10m\")\n",
- "ax.gridlines(draw_labels=True, );"
+ "ax.gridlines(draw_labels=True);"
]
},
{
"cell_type": "code",
- "execution_count": 5,
+ "execution_count": null,
"metadata": {},
- "outputs": [
- {
- "data": {
- "image/png": "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\n",
- "text/plain": [
- ""
- ]
- },
- "metadata": {
- "needs_background": "dark"
- },
- "output_type": "display_data"
- }
- ],
+ "outputs": [],
"source": [
"from oceans.datasets import woa_profile\n",
"\n",
@@ -186,22 +95,9 @@
},
{
"cell_type": "code",
- "execution_count": 6,
+ "execution_count": null,
"metadata": {},
- "outputs": [
- {
- "data": {
- "image/png": "iVBORw0KGgoAAAANSUhEUgAAAo4AAAKhCAYAAADe9C8DAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi40LCBodHRwOi8vbWF0cGxvdGxpYi5vcmcv7US4rQAAIABJREFUeJzt3X2UZ3ddJ/h3VaUf0ulOp5smbUhoOgQwECIKCaAiIjrIgyAzA+zq6o66Pu/ojCs6Ps3JxFGZozKzZ1xhQFfXozirHJ9wVeQoLIQhIIQdHmJCIJBHmoSmO51+SHe6q377R1WkDXU/32/9qqurqn+v1zl9Oqlvfe+9dX/33vr25/v7vn9To9EoAADQMr3aBwAAwPpg4AgAQBcDRwAAuhg4AgDQxcARAIAuBo4AAHQxcAQAoIuBIwAAXQwcAQDoct5qHwAAwGr71NvfPtqya9eq7f9x11zz10levGoH0MnAEQCYeFt27cpvXHvtqu3/utFo9UatS2CqGgCALiqOAABJpmdW+wjWPhVHAAC6GDgCANDFVDUAMPGmppIZ5bQmpwgAgC4qjgAAsTimh4ojAABdDBwBAOhiqhoAmHgWx/RxigAA6KLiCAAQi2N6qDgCANDFwBEAgC6mqgGAiWdxTB+nCACALiqOAABTFsf0UHEEAKCLgSMAAF1MVQMAE28qybRyWpNTBABAFxVHAICI4+nhFAEA0MXAEQCALqaqAYCJNzWVzMhxbFJxBACgi4EjAABdTFUDAPjIwS4qjgAAdFFxBAAm3lTkOPZwigAA6GLgCABAF1PVAAAWx3RRcQQAoIuKIwAw8SyO6eMUAQDQxcARAIAupqoBACyO6aLiCABAFxVHAGDiWRzTxykCAKCLgSMAAF1MVQMAWBzTRcURAIAuKo4AwMSzOKaPUwQAQBcDRwAAupiqBgCwOKaLiiMAAF1UHAGAiWdxTB+nCACALgaOAAB0MVUNAGBxTBcVRwAAuhg4AgDQxVQ1ADDxrKru4xQBANBFxREAwOKYLiqOAAB0MXAEAKCLqWoAYOJZHNPHKQIAoIuKIwCAxTFdVBwBAOhi4AgAQBdT1QDAxLM4po9TBABAFxVHAACLY7qoOAIA0MXAEQCALqaqAYCJZ3FMH6cIAIAuKo4AABbHdFFxBACgi4EjAABdTFUDABPP4pg+ThEAAF1UHAEALI7pouIIAEAXA0cAALqYqgYAJp7FMX2cIgAAuhg4AgDQxVQ1AIBV1V1UHAEA6KLiCABMvKkk08ppTU4RAABdDBwBANa/VyX5oyR3JnkoySeSvC7JttO+Z2+S0cCfi3p2YqoaAGAqmVnfi2Nem+SuJD+T5J4kX5Xk3yX5hiRfk2TutO99XZK3Par/4Z6dGDgCAKx/L0/y+dP+/91JDiT5nSQvSPLO09o+neT94+zEwBEAmHjnwCfHfH6Rr31w4e9Lz9RO1vcpAgBgyNcv/H3Lo77+uiSnkhzK/JT11b0bVHEEAFh9T01y02n//6xlbu/SJD+f5G+SfGjhayeSvCnJOzJfobwy8++JfF+SZ+dLB5hfwsARAODc+uSYrUn+LPNVxe8+7ev7kvzgaf9/Q5K3J7k5yc8m+Y7Whg0cAQBW3y1JrjkD29mc+ennJ2Z+qvqexvffneS9Sa7t2biBIwAw8c6BxTFJsiHzWY7PTvJNST7W2W8q81mOTev/FAEAMJ3kLUm+Mcm3pj9uZ0+Sr03ygZ5vVnEEAFj/fj3Jq5P8YpKjSZ57Wts9C39en/kB5o2ZXxzz5Ul+OvPh4L/UsxMDRwCA9b845iULf//swp/TXZ/5T5G5OckPJfmuzH8U4f7MB4Nfn/mPKGwycAQAWP/2dnzPby38GZuBIwAw8aaSTFv50eQUAQDQxcARAIAupqoBAKaSmfW9OOasUHEEAKCLiiMAMPHOkU+OWXFOEQAAXQwcAQDoYqoaAGD9f3LMWaHiCABAFwNHAAC6mKoGACaeVdV9nCIAALqoOAIAWBzTRcURAIAuBo4AAHQxVQ0ATDyLY/o4RQAAdFFxBACwOKaLiiMAAF0MHAEA6GKqGgCYeBbH9HGKAADoouIIAGBxTBcVRwAAuhg4AgDQxVQ1ADDxLI7p4xQBANBFxREAmHhTU8mUxTFNKo4AAHQxcAQAoIupagCAJJlWT2txhgAA6GLgCABAF1PVAABTU8mMZdUtKo4AAHRRcQQASCyO6eAMAQDQxcARAIAupqoBACyO6aLiCABAFxVHAIDE4pgOzhAAAF0MHAEA6GKqGgDA4pguKo4AAHRRcQQASCyO6eAMAQDQxcARAIAupqoBACyO6aLiCABAFxVHAIDE4pgOzhAAAF0MHAEA6GKqGgDA4pguKo4AAHRRcQQASCyO6eAMAQDQxcARAIAupqoBACyO6aLiCABAFwNHAAC6mKoGAEisqu7gDAEA0EXFEQDA4pguKo4AAHQxcAQAoIupagCATCXTpqpbVBwBAOii4ggAMJVkRj2txRkCAKCLgSMAAF1MVQMAJD45poMzBABAFxVHAIApcTw9VBwBAOhi4AgAQBdT1QAAmUpmTFW3qDgCANBFxREAwCfHdHGGAADoYuAIAEAXU9UAAIlPjungDAEA0EXFEQDAJ8d0UXEEAKCLgSMAAF1MVQMA+OSYLiqOAAB06a44Tk1NbU5y7QoeCwAweT44Go2Or/ZB0GcpU9XXvnjqZe/Znd2D3/DYpz120a8f/PTB7HjijsF+VfuBOw/lor0XLdr2wB0PDLa12h/49MHsvHy477jH1Np2td2VOk9J41y0zuOYP0+rfaXOcavv/ruPZMdA++FP7c/OvdsH+67U67ca2221H/r0gfo1+MwDuWjgNRi3bdL6rsVjWq2+a/GYWu0H7ji05u7btdi3arvn6N35v+/4/ecnuWFwx2eLjxzsMjUajfq+cWrq6/7F1Pe8Z8/U3hU9oEebW6EXcXp2buy+rWNazrbHtVLnKVmbP091TK2+D2/YONi2+bh/9D5iZu7sv+6wnswKi162u0Z35HdGv/X80Wi0+gPHB28d5YPft3r7/8YbbkpyzTK28Kok37awjYuT3JXkj5P8UpLDp33fjiS/kuSVSc5PcmOSH0vysZ6dWBwDAJCs90+OeW3mB4s/k+SeJF+V5N8l+YYkX5NkLvN11bcluTzJjyQ5mOSnk7wryVcu9CsZOAIArH8vT/L50/7/3UkOJPmdJC9I8s4kr0jyvCQvzPxgMZmvOH4myU8m+dHWTtb10BoAgCT/eND4iA8u/H3pwt+vSPLZfHHQmCSHkvx5km/t2YmKIwDA1KrnOD41yU2n/f+zzsA2v37h71sW/r4qyccX+b6bk/zPSbYmOVJtUMURAODcc2mSn0/yN0k+tPC1nZl/X+OjHVj4e3hZ/QIVRwCATCXTq1pxvCXLW1V9uq1J/izJqSTffdrXp5IsFqcz1bvhJQ0c56anMzew4mg58ShV35WKzVmLx7Sc7VYRM8nyYmYOb9s22HZi06ay78kNGwbb9j3uksG2LUePldu9ZN++4b7H6r4bTz482HZg586y784DB8r2n5/9t4Nt109dP9i2nFiPKjbnwI76H4/Va7v7vvvKvrONKZ0Hty+eh3l8c33N3HPpZYNtrettx8HF/iE9b/uhQ2XfC4rrZjmvT3Weth0+PNjW6jv0LH7EhpMnB9umG1FLVd/Ws/P4ps2DbdXrt2v//rGPqRUddXTLlsG21rNxNWKpVjLyrfp5Hhi4Zx9RXa/jRsLNzU0ns2N1ZdjmzK+cfmLmp6pPXyl9IPNVx0d75JfF8EN0galqAIBzw4Ykf5Tk2Ulemi/NZrw58+9zfLSnZT7Kp3x/Y2KqGgDgXPjkmOkkb0nyjUleluT9i3zP2zI/df31mY/rSZILMx/l8/s9OzFwBABY/349yauT/GKSo0mee1rbPQt/3pb53MbfS/IT+WIA+FSSX+7ZiYEjAMDqL45Zrpcs/P2zC39Od33mP0VmLsm3JPnVJG/I/Pshb8z8p8vc3bMTA0cAgPVvb+f3HUjyPQt/lmxdT+YDAHD2qDgCAKz/xTFnxZIGjsc3b87R8y5YtK3M2JqtQ5oO7BjOzqu2u+nEiXK7ldYxzS7jfQ4zc8PbvnPPE8be7pNuv32wrZVFVuUpntw43JbM/zy/+uCP1wc3hlc8688H26rjTZLbnvKUZe37r97/4mX1H8d1o+vO+j5/ePcby/bqurlrz56y76GL6sy3/bt2Lfr1jz396rJflTHYymKsruX7d19c9q3yB6vnUFJn2FXPktZ2q2fJ9gfqc1E5VuQaJnUW6rYjdVrH4a1bB9uuKJ5hBxsZqknyXz77/Yt+/Qcf9+ay39C1mCQPN541B4ss1K3FuVjONXPxffeXfVvPx0p1XBsbx/xQcd1cWNyb1c/68KmNyUPlblljVBwBANb/4pizQk0WAIAuBo4AAHQxVQ0AYHFMF2cIAIAuKo50+R+f+geLfv3Q9nplbbI6K5hbdv/w8KrF+95Qr74FgEm1pIHjnXuekMMXXrlo275LLhnsd2TbcDxDkmw+Phyrs/XI4eG2w3UsxP0XDw8ALr333rLv3UUUyXmNyIJd+/cPtn2uOE9Pvu22cru3XLn4uU+SixoxJdNF/FAr1qh6bZfjbTe9fLDtuS/9QNn32PnDsRCtn6cVM3Muab12dz1h+Fy04kSqiJMkuefSyxb9+uaLN5X9qkPet69+lnzkiksH2xoJNKluocfsGz8epTqPrXihKi5p6Pw+oorUaUUTbTk63LeKoHnEbW95cvN7zqShmJ4e1T8ik2T3ffcNtlXxT63XZ/f9w9vdd8kluenPnjnY/oIXvqfcduXL9u0bbDu4qb43q2uqimGq7o/PHz2a3Fnu9uyaNhHb4gwBANDFVDUAwJQcxx4qjgAAdDFwBACgi6lqAIBMJTOmqlsMHFk1r7nqrcONxWrflfa4HxhedZgkn33TmV9lfuHrh9uK0IGml43fFQC+xJIGjl94zGNyYtfivzSriJONV+4ot3skyed+aClHciZcfbZ32OFpq30AS1YO/pZhz5135Q9vfvVYfb/um95btlcRKEeKSIn16E9f+cqyvYrXmNld59fsvbze94v2Lv71ueFkqCTJrZ8Ybtv12ORT31H3XwlP+O06vuahA8Ntp6p+uTgP/vhw+1f88XDbziQf/WflYS1DO5/1XNHObV2pXNfh6KiW//edzz+Dx7G6brjhhjz/+det9mHM88kxXZwhAAC6GDgCANDFexwBABKfHNPBGQIAoIuKIwDAlDieHiqOAAB0UXGk6aL/NNz2oo7+2157ZNGvv2S8w0mSfM033zjYttL/Xnz6a/5+sO3jfzgcqfT0lUku4jTf8sG6/f+59uwcB/BFT/q94baHivgt1qYlDRwPP+9JOfmUZyzadqrIMdu2eUnHxDrynn9ZZy0evX3xQWOSfOC5zznTh5Mk2b9rV9leZY7uueuusu/GkyfHOqaWZyx+WyVJGj9OZufG73vwwHBW44aNdd/tF9btQzM+jVOcpzw5+cuVuTTGdud3r85+Vy6nEfhSU8m0qeoWU9UAAHQxVQ0A4JNjujhDAAB0MXAEAKCLqWoAgEz55JgOa2bg+GVvXPzrF+8e7rN1a73Nx10yft9Dh+r2P/nKup3J9PjfHG7bvv3sHce56n/65GofAay8F76nbt9Q/Obe/4W67+HDdftt3z7c9tj/Y7itys3euq3eJ+vLkgaOJx5K5o4u3lYN0g89UG93s7ieNe2BHxtue8x/rvs+9urhEfrhDx4f84iS9/31V4/d96L/bfhfBQe/+sljb7d1HVf/WNld/APp0svq7e7cUbUeK/s+Yc/+orX4l1eSw0c2lO1Dz4SnX112W5YnP2Xltg2M52AR13fywbN3HE1T8ckxHdRkAQDoYuAIAECXNfMeRwCA1eOTY3qoOAIA0MXAEQCALqaqAQB85GAXA8cxXZ+Tg20nT9YxJb9QNwPAqviqP13tI2CtW9LAcftFyZZdi7fNzg33myvakuSyS5dyFF+0oTEAm50dbmsd05VXDrdt3jw8aJw0X/jR8fu+5I0fanzHi8ffeOGB/zicxL37h+8v+17+8osH257z3Hq/+/YNt131tKrnrfWG8+Girc5xTAZu6CRJcRMk2bZ1S2Pbexb9avWsaHnL+DGbsG7seXzdfn/xmLr3nrpvFca9rfHBGFVW7fmtx8GAh/YnjUzys8jimB5qsgAAdDFwBACgi/c4AgBYHNPFGQIAoIuKIwCAxTFdDBxXwfXFStfrMubSNP7B9SmWLyf563dccpaOBJJjuX6wbcu+z7Y3cMmbzuDRACzPkgaOj31ssuOyxdumi0nvmcYAfleVCFLYtKluP/TgcFt1vEmyefOhovX2su+GMifoinrHE+Sv3r8ycTvLsfna4bidJPnkJ4fbXvKSettX7BgeQFSW80+JVmTo/tw72HYkH1vW1q/LTy3e4A0yUGoVvY6fGG47cLDuu6V4oJxsJM1dOmZ0XhXj88Dnk0aCEGuMiiMAgMUxXZwhAAC6qDgCAGSq/T42VBwBAOhj4AgAQBdT1QAAU5Hj2MHAkXXp54rYiDINidV35LV1+/79w21bt7W3v+vXlnY8Cz5Q5C1e3ehbpZi4HCfT9Y3YtuRPi7YfP5OHAmfUkgaOX/EVd+YJz3vsQOutRc9W4PJwIHZS5SlW/ZLLiiDorTlSH1Khlat3f6oswEZQVp65xKPhS9XX2ze/6K1F64sa2x5+/a6b/c911y8UA6JNRdBZKx6iCDT92IaNZdftRdtdmSv7PjNFmBz/4GSS7blu0bbXX9LO9jSEmDxP2PPeRvvwP2W+/vl13+r5ODtX//6Zma5+f1W/q4fb7jzv3nyk3OtZNDXVDp7GexwBAOhj4AgAQBfvcQQAJt5cktlV3P96eT+0iiMAAF1UHAGAiTdKe/nqSlovFUcDR9amfT9Qt+9609k5DsZ382sW//oT9qzsfj/w0sW/3sppeqZEA77UXxQxTVUqQfIdZ/pQYE1Y0sDxpXlnnj2QTVVF1BxqLLav+lbBKq1/GWw4NBwBsH97fctXrVXoQJK8I/cPtn2yjC1KxPH0+YU3D8VCJTl+vO5cDSAa10WZI7ixMTDZUlzpVdvWrfV2C1dvv6j+hmK/e+Y63u1z8RsW//rQoDFJ9g3HZCVJjhUxW62+ywjvfc6HP5w888/G7j+OHz/5cPub1ksZgn/kukO/Xn/DieHn1LGL67i4LQeLSLHZOkYr2y8sGv+o7Hpsejjea0vx89xVxI39Xe7Mb5d7Za1RcQQAJt5qT1WvFxbHAADQxcARAIAupqoBgIlnqrqPiiMAAF1UHAGAiafi2MfAcY05VGSGJcn2XHeWjmTlHfxXU4NtO37q+8/ikcCCXy9inv7Xz5+94wBYo5Y0cNz9dx/Mnoc+sXhjkUe2q5UlV2WZHT8x2LRh5856u8eODh9T3TPZNpzXt+vSS8uu3178vO/d8snBtqtbxzRJ3vzmun26eJfFTCPL72Txb8oqQzBJtjfaK5uHs8zKrMa5Ri5blQG5o3GP7Ngx3NY6j0ly8cDXr/rDdt8hN37zcFvr9Xm4eG0fbCSw7t9ft6+EDb949vfJkrysuub+9m/G3/Dh4azGLQcP1H2re74VdF85v0pVTracKu6v84b3u+fE8O/xO29dxjOVVaHiCABMPFPVfSyOAQCgi4ojADDxVBz7qDgCANDFwBEAgC6mqtebO75ruG3v/7Uiu/zIPx2OzSkWvSepF/hdvnesw4Fzxq3fNnxvPeLK/zo6C0cCmKrus6SB4/GbPp5j9y/eduL4cL9WOkCVLFAlp2za1thwteMrr6z7VhEM1UElZbTK8y553HC/zZvq7a5GXMgKum04mSi7GnlJM9NVRE0dX1OkRnQk3wzcAEm2b6/7bthUFPirqJ7qBmm1Vz9skmwrYoBOnUye8Sd1/5Xw1X999vcJAw793C8PtlWpOZuKWzqpfz3NNOYCp4ukrLnZ8ftWv8eT+pir7VaO3DNeP1aPiiMAMPFUHPt4jyMAAF0MHAEA6GKqGgCYeKaq+6g4AgDQRcXxHHLktXW0x9ZfFesB43jr09uxOa/++Nm9v971gvqYWqtrv/GGyXkefOxVw+fqyOG679OuOsMHw5ql4thnSQPHT386ufCBxduWEy1QJYZsLNp27apf4k2bh9u3fPjD9UEVkTrZtq3uW+Wy3HHHcNvDjUv2oeGIoCP//fa67zJUWY3331f3ra6LKq7ijs/U2x13n639tvpW7VU0x/x+h7N+tm8ffm2rtiT1tfrVX1P3TZIr/2v7e1gRMhrXvhvfN9w2bpRcksw2or8qVWxOK8rs8JHhttbzr/pd3uo75I6D4/Vj9ZiqBgCgi6lqAGDimaruo+IIAEAXA0cAALqYqgYAJp6p6j4qjgAAdFFxnCC/+fh2Ft1irr76DB8InIP+w/nD99dPPTRe7M6N3zzePdvjzY+rt/39nx3vmN+4e3i7MzN133H3+YGX1j9LFZsDj1Bx7LOkgeMDh5L9A9lTVYZTK9+puqmrvq0crM2bhtumGw+wzZuGw66mZ4ogrCQbNuwbbKuy/lq5X8eKOL99w7tMktxzb90+7n6rTLCkzv2aLfK7WtmfW4sozep4k2R6GTlmVURnla2WJOeP+URqbXfXbHGtfuyj7R1cucQDmkCtcO9q0LhSWtf5oUPDba3Q63PN7UXMbes8tp7LQ1r3bWW2Ed5e2b+/bq9+97Weu+Nm4FbbPdT4HcKSXZbk3yS5Jskzkpyf5PIkd5z2PXuTDKUl70gykNg9T8URAODc8KQkr0lyU5Ibkryo+N7XJXnbo77W/GelgSMAMPHOkanq9yTZvfDf35t64PjpJO9f6g4sjgEAODcs48Ms+xg4AgAT75GK42r9SfLUzE8xP/Jnpb0uyakkhzI/Zd21FNZUNQDA5DiR5E1J3pHk85lfIvkzSd6X5NlJbqk6GzgCrLDf//LFV13v2lX327Z1BQ6m069csPgxVytrk2TDMn6rVBFB1ernr/6a8fcJa8gtmV8NvdL2JfnB0/7/hiRvT3Jzkp9N8h1V5yXd4ieOJ8cGlvIvJ46nii2oHlLLiZRoxfHMFXEIrQdndVzVw68V+3D8xHjbTZKTDw+3bdhY9/3kbcNtO3bWfavXtnoNqtibpD5Xrde2en1a12qllRVXxUc9WESntNz898NtzzlRNC7Y8urx9828KqdxaNDY40ARWVVFeyXJ4eI6b0WZPdR4nlROnhpvvxuXce/d+L7kXz8w/Br8zhOHX4PqWd/SiiNbDbON166Kxtnc+N1WPXfHjep5uPjddLadI4tjxnV3kvcmubb1jd7jCADAVObHzyVT1QDAxJvwiuOeJF+b5E9a32jgCABw7njVwt/PWvj7JZlfBPP5JO9O8vrMzzjfuPC1L0/y05mP8vml1sYNHAEAzh1vfdT/v2Hh73cneUHmF8H8UJLvSrItyf4k70xyfZJPtDZu4AgATLxzaKq6tSLvtxb+jMXiGAAAuqg4woR769OH/3H66o83F9jBmlBF7kCPc6jiuKKWNHA89ECyfyAjaqaRnVdp5d8NaeX1Vaosq9a2W32XkzFYqfa7nKDgKh8ySTYvY9vjZjXOziUv+7uVGbRUuXqzjXNRvbatXNFxX/tWzly13Xe8o+7byg5l+b79E8PX8V88ux7s7N8/3Haokf05bj5uUuezVpmwSTsjckgri/a8Igtw27a6b5VpeapxD1T3V3X/LCcfciVVP8+JxvOv6nt0zOzPA55B646pagAAupiqBgAmnqnqPiqOAAB0UXEEACaeimMfFUcAALqoOAKD3vtPhlf9HjxQ9z18ZPGvbyhWxz7iXIoBaq2cBlhPljRwPDWbnDy19J1s2Fi3V0v8N28abmtFiVQxP61fXtUxtaJvqjiK6phaMT+V5cT8tGIjqtiP1mtQRj8UcSErqYpHafmDp44/CKh+3uo89Qy0hrRen+qau3j3+PulTyvCqYqRad0/1XOoFX2znCiZar/L2e7Jk8lPHF383n3j7vq+nCuOaXom+dEvDD8TfuWC4W1X92br3jvXorDGjdUbZ0yxUkxV9zFVDQBAFwNHAAC6eI8jADDxTFX3UXEEAKCLiiMAMPFUHPuoOAIA0EXFEVhz7vpfhiNQ9vyfay/jUVbj2fFLGxc/zzt2LG+7r7/Q6we9lpbjeGq4jDtd1C5bMXRVttdqZV1V+VytXL2qeVORS7l5c73dqu9MI8exytiqsjKTZNO24Z/oxOH6Bdq0sxHu9RNH6/Y15n+4ZXjQ8sdfUf/yqa6bcbNMW9vd1Limqm0vp2+SbB0zAHzPnrp9vamyGlt5ilXOZjOLtsgubKmeu63M2HGzGlvbrXIrq+zIJNlQ/KY79lDdtzqu84rXYGvj9Tl4cLhtOZm+rXOxnCzNcXN5W8+StWTORGyTMwQAQBdT1QAAmUp7jhQVRwAAuhg4AgDQxVQ1AICp6i4Gjqyu279zuO2K3z17xwEANC1p4PjQQ8lAwka5FP+hRuREtcS/jMVpHP3hoYPN8iJODh2q+1bRNxuKY9q2dfxjqmIhkjpe40TjXOTQcOet2xp9n/GVw21XPLHReX35Zx8dP1+wivJpRo0Uba1Yj1YESmX79rp96No4eKDu14qoWYuq+6u6b6tnRVLHmLRiVQ4UcS+t1656nrfMjhn30rrOq2NunYvqOm+8BOVxbRwzYitJrriibv/2Tww/T964e/h5caT4HZMsL+Ku6lu9BtU5PL6mYllVHHt4jyMAAF0MHAEA6OI9jgAApqq7qDgCANBFxREAQMWxi4ojAABdVBzhLPmLZw9HaACc7h1f63nB2rSkgeMFFyTb19BQ8+Sp1dlvlcuW1HlWM0VmYjPHrAgca+UpVhmRVVZckmzYWhz05kbn/fuH2y7fW/edINU11cr3rLIAW3l95xd9L2r0bWUQTm9YfELjxLH6Qq/yB9eq6p6vcilbr091b7byLqtnQiv3sLrmWs+pattVDmAr97DabqtvlUs51+g7U2VAFvfArl31dqtH48W7676XXTbc1rouqhzihxsZj3PFaz/u67P1ZJLD9X7PHlP9dAPIAAAXYUlEQVTVPUxVAwDQZQ3VDwEAVouKYw8VRwAAuhg4AgDQxVQ1AICp6i4GjqxdN7+mbr/qD8/OcTDx3vNC0SgAyRIHjo95THLJQPxAtdy+Ff3QilIYV7XfVqRO1d6Kr5kp3gBQxTe0InWq6JRWZEu57VYmyNZi462+O3cOt1W5HrONi2Yd2lykGlXXW+ta3VGc4tbLU0aGtPJ2WnkjAzfKpu0Xlt0u+aZvqre7BlWv0fbtyctvGi3a1hqQVs+anTvqY6pur9YzudJ6/lXbbvWtVJE6rQiaqn058TUnTybffefir+1K+sBLh6+b1s/TeiZUxo1TqvodOZI1FMdDDxVHAABT1V0sjgEAoIuKIwCAimMXFUcAALoYOAIA0MVUNZwp/36F4gEAOAtMVfdY0sDxyiuTa3Yv3lZFMBw/UW+3Sv2oogWqeJMkOXxkuK0VcVL9PK2UkmrbVSxBK6pi4zIigrKpOFmtH2hbkeVTxe0kdQ5Q9eLu2VNvdx269LLhtuq6aL08VXvrOq9zpxo3WOvAhmKcdj227HZ742K+ot7rimidx+q1rbSiUc4r9lvdlsnyIp6qSLGW6rKoIlua12rh4IG6vbq/kuTiN5z9SJ3leM5fDh/v/T9cRzwt5zxXv1OruKRqnw/fl+RTYx8Sq0DFEQBAxbGL9zgCANDFwBEAgC6mqgEATFV3UXEEAKCLiiMAgIpjFwNHWIpf2rjaRzDx/iLXl+0vy3Vn6Uj6tSJSANaLJQ0cL33a9lzxpIHR+GwRfLgcm4tMt1bOXOVEI1zy8OHx+1amV+jdAcsJ+9vRyGKsAjOrnMYk2XL+cNtlw+F3t7eOKauT51c5cWyubL+iOOANm4rrYqYRLF6FpLWui+oequ69pA4ZrPbdCGDdVbS9t97jiqleu2T87NYrrxx/u9NbGs+/6vVrPYeqvq17vgqBrK6Z1nVe2FGFCCbJ/v1jb3u9aWZSVh9U0AgH3VFekMXrXtwEd99+Mnl7ERDJmqPiCABgqrqLxTEAAHRRcQQAUHHsouIIAEAXA0cAALqYqgYmw189t27/0AfPznGw9vz5s+r2l9+0+Nf3/cBwnw0d0V27fq39PUvV+lkomKrusbSB4zOekTxrICxjulji34jfyMlTw21VzMJsHX9SasU3VKpIgiQ5dmy87VbnMEnmlhF5VGWCtH6exxQBKY34hmzbOnxIReTOx+qtJlmlOJ4nP3mwadPOdoTQoCripPW6V/dBFY3S0rouzm9E/bTu+wHb77prsO3KPXvG2uZyXfzMS+tvuPzy4bblvD7LiVqqXp/WNVVFju3YUfcdN1anFfNz8uHhtlZE2m2fLPou43fBelRdq9WzPkl27x5uq67l6h644AtJ/lu9X9YUU9UAAHQxVQ0AYKq6i4ojAABdVBwBAFQcu6g4AgDQxcARAIAupqqZOP8h1w+2fUOj73PO7KGwEj7yT1f7CDjH3D7wzFhuJNihge3e3uhX7Xf72EeDqeo+Sxs4Pv7xyVMev3jbps1jH0SRMJgqEXH/MrbbUiWktW7qqm91Ux9qbPeSoq11Lqpb4dZG32qw1EiSK3+mfUXbR9LOAHxl8ztWwDOfOdzWynHcOpxpWWoECVevfesRWL0+rdd2OG2x1vrFdsWRw8Nttzau1iqTr8qgS5JXFlfU5sbzbbqYvKn228qiLa6Z/ePmJaa+95L6GddK0qyux3Gf9Ul9LTfSB3PF3uHswksaubu3F3mZH7jkcYNtreu8ep4vyyWNLe/dO9xWZTwmddbmbJEN+mDxpPmcgdp6o+IIAKDi2MV7HAEA6GLgCABAF1PVAACmqruoOAIA0EXFkXPO9Xlr2d5erw3A5FFx7LGkgeO7Nm7M5wZid6pT3Yp+qOIb5opf89M5UW53Lpc29lypfqJW0EIV79AKjqisVMBQHbzy9+XPU7+60/nkYNtcqniaIvZmme47dN1g263bhzMek+TtV1xVtLaOedzXbzmhR1c2+lbhKq2AqJbFr/XZufrBPLP1XcONV36s7LsjBwfbDubism8dkNI6j9U9Up3jOkhrU/5gsK31JLk3Tytaxw//+kjz+Ve1V0fdOqbWfTDsb6vzXMTttFX39HJ+89V99+bIYNuua64t+7ZijyrVq/fhIh5q+47hqLLbtg3Hb7E2maoGAKCLqWoAAFPVXVQcAQDoouIIAJDpqKe1OUMAAHQxcAQAoIupagBg4o1GyexoFQ9gnZTyljRwvCPfmVGeN9B6e9GzlZM1XrbXXJm7lhw/PtxWRE4lSQ4Px2RlQ2PR1Yliv0eLEK252Xq708Uxb2wcU3XMhxsxWtV+t22r+24q0rY3Lx4J+g9+fsyb6OixV5ftd99VNO4ZznhMks3Fz7OvEdt2663DbSdPDbe1Xp/qPB5rhLbt//xw25Ej9X27Y0e97Q0b6/Zh3zDYMjc73JYkh4oowF2N4MPqHmmdx+pZc6KMm60Pau/e4evxSPGMSpL9RUzg7OE6U/Sqa4dPRnVPJ8n2IsZxbm647cDB+nm+5fyirfErZmZmOEuzOt6kfv7tLO6B6Zmr6w0XtlURt0nu2DD8+t2xrLzfVvbksNm5Kwbb7imeYfceuSHJb4+9X84+FUcAgFG7gLOi1knFcZ0cJgAAq83AEQCALqaqAYCJN0oyu5pT1evkQ2tUHAEA6KLiyJr1ze8bbqtWUT75KWf+WACAJQ4cP3PHeTnymMVrqTPTVw72qyJokjpWYm62FeUznipuJ2lHTlSqaJwqtuPYQ/V2t1843HaykcBQRUo81Hh9Kq1ooumipn3x7uG2KtKo5UMfqtsPHhhue/e7676H9g2f6L133FH23VJkumyoXsBGXsiBYhS9uXEi9xY3wrZGDlB5zEmOXbD4cc1WF2Njv3ONHK3pYp5p6HgecWTrcLbUpupCTrKluIlOnjd8kxy6qH5tj986nF8zatx8jynaWtfF9MeHc432N67H/37pZWX7kO1VllKSmRWaQzywc2fZfsElw78Mqn/AbmrEjVURT63n397Lq7ik+rqofj/t2jUcqZPUz+x9nx1uO/TgcNsDnyp3eXaNktkiMmqduCzJv0lyTZJnJDk/yeVJ7njU9+1I8itJXrnwPTcm+bEkH2vtwFQ1AMC54UlJXpPkYJIbBr5nKsnbkrw4yY8k+eeZf4fluzI/8CyZqgYAJt4odUj9OvGeJI/Uhr83yYsW+Z5XJHlekhdmfrCYzFccP5PkJ5P8aLUDFUcAgHNDz9D3FUk+my8OGpP5j+n78yTf2ups4AgAsPqemuSm0/6slKuSfHyRr9+cZE+S8kMvTVUDAIxWOcfx7NmZL10skySPLB3dkWRw5aSBIwDA6rsl86uhV9pU5t/SudjXm5Y0cLzxxmTmc4u3VR8M/vCxesp954HhfJQq5mLPnXeV263iQg5fVi8c2r95OIKhFUNyTxFHMVfEesw2okaqvpsb0Q9bi8Jz683A1b/AWvut+t5//3Db8RP1dk8+PNx2+N66c3W97aiyoZJctW/fYNumKmspyXRxomeKG+gpt91WbvdYlQnSUF3L1b2XJNON3IqTA3Exmxvn6XhxUVX3QFKfi00n6uti+wPDcTAbTtX3/IaHh9urY7ri9tvL7S7nXFTPk1a0TXWudhw4WPa97J57h7dbvPZD18sjqmv1RONBdLR4DS6uHkRJ5m4bPs/VMbfin7YWD7lynjDJlrfdN9h23+4iMyfJieJ320eLSKok2XjljuFjKn7cKnro4TvKXZ5V58jimB4HMl91fLRHXuDyJvceRwCAyXFz5t/n+GhPS3JXimnqxMARAGCSvC3JpUm+/rSvXZjk5QttJe9xBAAY1W+7W0detfD3sxb+fkmSzy/8eXfmB4c3Jvm9JD+R+anpn878exx/ubVxA0cAgHPHWx/1/29Y+PvdSV6Q+azHb0nyqwttmzM/kPyGJHe3Nm7gCABMvFHOic+qTvpWRx9I8j0Lf5bEexwBAOhi4AgAQJclTVU/5QMfzfbbFq+AVrlfm0/UuW2bizyr6SJvrJXLVtlzd50BeXzTcC5YKzfvybd9crDtxKbhDK0qs62131amW2WukR9ZvQbNrLLDw6v6TxUZaHv27x/7mFr5g1Xm3vYHh7P8kuTkecPHXOU0JnUOXZWr17rOq4zB6mdN6qy/jY280iobLxnOpjy5sc7rqzItH1pGZmUrP3KmeP0ebmQMVudx+6Hha6r52havQStPtso2PK/Vt3hOVTmoreNq3SMrpXo+tp7n1c9T5Ti2cnmre771u+CCIhjx0nuHczST+ufdv2tX3feu4b7VNXNhcZ0f2f+pOjTwbDp3FsesKBVHAAC6WBwDAEy8USbms6qXRcURAIAuBo4AAHQxVQ0AMDpnchxXlIojAABdllRxvOyee/Jl+xdfjl9FC1QxF0kyW0QlVH2rSJbl2nJ0OO5gSxGFkNSxH1UcRSsWYm5m/HH+7PRwNEQr1qP6eVqxESulisFIkt/91HcMtv3kBb8y2FbFXCTJ8SJyovX6Va99FRfSijCp4qxaWvdmvd863mYojqR6VrSOqbqOk/Ejj5I6PmU5914VSdVSXRete6+K+qmiU5Jkx8HhgJRWTFP1PK/irqpn7iN+fvbfLvr11174+mbfX33wxxf9+vdd9ptlv+qaqqK/Wtdq9QxrXauVVgxQZVcjBm05xzXkcyduy+1nfKvjGUUcTw8VRwAAuhg4AgDQxeIYAIBRskofbrSuqDgCANDFwBEAgC6mqgGAiTeKHMceKo4AAHRZUsVx69Ej2X5i8RyumWWEH214uMheK7bbyjGrtttycuNwxtb2Q8NZZEmd+1Vld7XyISutTL1jFwxnDLb6bjh5aqxjSpKTG4YvsenGP+2GMtuW68Ht2wfbWjmO1Wvbui7GzQI8uuWCsv38ZVw3rft2KPsO1pLlXKe/cc/3nsEjmVz/8rG/PthW5T9uOjl+Du0ZN5Lj2EPFEQCALgaOAAB0sTgGAJh4Fsf0UXEEAKCLiiMAgMUxXQwcAYCmH3zcmwfbDCYmx5Je67mp6cxNLz67PfT1HrPTM4NtVVxIK0YmSX7h4Z8d65g4d/2Xz37/YNv1U9eXfceN1EmShzdsHGzbePLhwbYLjh11HQNr2qkiaq4yN+cdc+uNfyQAABNvlKSInGSBoT4AAF1UHAGAiTcaiePpoeIIAEAXA0cAALqYqgYAiBzHHiqOAAB0WVLF8V/95avydV/3dSt1LLDqrhtdt9qHALAmVRm447rhhhvyJ8//38/4dscySuYsjmlScQQAoIuBIwAAXSyOAQAmnk+O6aPiCABAFxVHAACLY7qoOAIA0MXAEQCALqaqAYCJN0oya6q6ScURAIAuBo4AAHQxVQ0AMErm5Dg2qTgCANBlSRXHG264YaWOAwCYMB/5yEdW+xD+gU+O6dM9cByNRjdMTU09fyUPBgCYOB9c7QOg35IqjqPRSMkRAGBCWRwDAEy80UiOYw+LYwAA6KLiCAAQcTw9VBwBAOhi4AgAQBdT1QAAo2TO4pgmFUcAALqoOAIAE28UcTw9VBwBAOhi4AgAQBdT1QAAIzmOPVQcAQDoouIIAEw8i2P6qDgCANDFwBEAgC6mqgEALI7pouIIAEAXA0cAALqYqgYAJt4oyayp6iYVRwAAuqg4AgATbzSS49hDxREAgC4GjgAAdDFVDQCQZM5UdZOKIwAAXVQcAQB8ckwXFUcAALoYOAIA0MVUNQAw8UaR49hDxREAgC4qjgAAFsd0UXEEAKCLgSMAAF1MVQMAE8/imD4qjgAAdFFxBACwOKaLiiMAAF0MHAEA6GKqGgCYeKMks6aqm1QcAQDoouIIADBK5sTxNKk4AgDQxcARAIAupqoBgIl3DiyOeUGSdy3y9UNJLjpTOzFwBAA4d/xokg+e9v+nzuTGDRwBAM4dtyR5/0pt3MARAJh4I6uqu1gcAwCw+p6a5KbT/ozrLUlmk3whye8n2bP8Q/siFUcAgCSz67vieCjJ65O8O8mDSb4qyc8kuXHhv+8/EzsxcAQAWH23JLlmGf3/v4U/j3h3kvck+bvML5j5uWVs+x+YqgYAODd9OMltSa49UxtUcQQAJt5olMyt7xzHIVOZj6k8I1QcAQDOTdckeUqSD5ypDao4AgBk3S+OeUuSz2R+evqBzC+I+ekk9yb5tTO1EwNHAID17+NJvi3JjyTZkuRzSf44yXVJ9p+pnRg4AgCsf69b+LOiDBwBgIl3Di+OOaMsjgEAoIuKIwBAklkVxyYVRwAAuhg4AgDQxVQ1AMBolOm5M/YBK2NYH7W89XGUAACsOhVHAGDiTWWUmVVdHbM+annr4ygBAFh1Bo4AAHQxVQ0AMEqm5+ZW+yjWPBVHAAC6qDgCABNv9RfHrA8qjgAAdDFwBACgi6lqAACLY7qoOAIA0MXAEQCALqaqAYCJN5VRZuasqm5RcQQAoIuKIwDAKJmetTimRcURAIAuBo4AAHQxVQ0ATDwfOdhHxREAgC4qjgAAPjmmi4ojAABdDBwBAOhiqhoAmHgWx/RRcQQAoIuKIwCAxTFdVBwBAOhi4AgAQBdT1QDAxJvKKDNzFse0qDgCANBFxREAYJRMz1oc06LiCABAFwNHAAC6mKoGACaexTF9VBwBAOhi4AgAQBdT1QAAVlV3UXEEAKCLiiMAMPGmRqPMzFoc06LiCABAFwNHAAC6mKoGACbeVJKZOYtjWlQcAQDoouIIADAaZdrimCYVRwAAuhg4AgDQxVQ1AECSaYtjmlQcAQDoouIIAEy8qYwyM2dxTIuKIwAAXQwcAQDoYqoaAGCUTM9aHNOi4ggAQBcVRwBg4lkc00fFEQCALgaOAAB0MVUNAGBxTBcVRwAAuqg4AgATb2o0ysysxTEtKo4AAHQxcAQAoIupagBg4k0lmZmzOKZFxREAgC4GjgAAdDFVDQAwGmXaquomFUcAALqoOAIAJJm2OKZJxREAgC4GjgAAdDFVDQBMPB852EfFEQCALiqOAACxOKaHiiMAAF0MHAEA6GKqGgCYeFMZZWbO4pgWFUcAALqoOAIAjJLpWYtjWlQcAQDoYuAIAEAXU9UAwMTzyTF9VBwBAOii4ggATLypJDM+OaZJxREAgC4GjgAAdDFVDQAwGmXa4pgmFUcAALqoOAIAJJle/4tjHp/kPyX5J5lf7/M3Sf51krvO1A5UHAEA1r8tSd6Z5Mok/yLJdyZ5cpJ3JbngTO1ExREAYP37viRPTPLlST618LWPJvlkkh9I8h/PxE4MHAGAiXcOfHLMK5K8P18cNCbJZ5L8tyTfmjM0cDRVDQCw+p6a5KbT/izVVUk+vsjXb07ytGUc1z9i4AgAsP7tTHJwka8fSLLjTO3EVDUAQFZ9VfUtSa5Z5jZGi3xtapnb/EdUHAEA1r+Dma86PtqOLF6JHIuKIwAw8aYyyszcul4cc3Pm3+f4aE9L8vdnaicqjgAA69/bkjw385E8j9ib5GsX2s4IA0cAgPXvN5LckeTPMh+/84qF/747yZvO1E5MVQMAE29qlEzPruuPHDya5IWZ/8jB3838opi/zfxHDh45UzsxcAQAODfcleSfr+QODBwBANb/J8ecFd7jCABAFwNHAAC6mKoGACbeVJKZ1f3kmHVBxREAgC4qjgAAo1GmLY5pUnEEAKCLgSMAAF1MVQMAE28qybTFMU0qjgAAdFFxBADwyTFdVBwBAOhi4AgAQBdT1QDAxLM4po+KIwAAXQwcAQDoYqoaAGA0ysycVdUtKo4AAHRRcQQAJt5UkulZi2NaVBwBAOhi4AgAQBdT1QAAPnKwi4ojAABdVBwBgIk3lYjj6aDiCABAFwNHAAC6mKoGABiN5Dh2UHEEAKCLiiMAMPHmF8eoOLaoOAIA0GVqNBqt9jEAAKy2tyfZtYr735/kxau4/y4GjgAAdDFVDQBAFwNHAAC6GDgCANDFwBEAgC4GjgAAdDFwBACgi4EjAABdDBwBAOhi4AgAQJf/H17Pr6KJMUMnAAAAAElFTkSuQmCC\n",
- "text/plain": [
- ""
- ]
- },
- "metadata": {
- "needs_background": "dark"
- },
- "output_type": "display_data"
- }
- ],
+ "outputs": [],
"source": [
"import iris.plot as iplt\n",
"from oceans.datasets import woa_subset\n",
@@ -227,22 +123,11 @@
},
{
"cell_type": "code",
- "execution_count": 7,
- "metadata": {},
- "outputs": [
- {
- "data": {
- "image/png": "iVBORw0KGgoAAAANSUhEUgAAAVUAAAFMCAYAAAB71S99AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi40LCBodHRwOi8vbWF0cGxvdGxpYi5vcmcv7US4rQAAIABJREFUeJzsnXV0VEcbh5/djRLHPTgELVoo7lCgxdpiQQoUh35IoVhwKFIoFawtxVpa3IpTXAPFIRQIgeAh7ln5/pi7FoEACQlknnNysjt37t25m81v35l5RWUwGJBIJBJJ2qDO6AFIJBLJu4QUVYlEIklDpKhKJBJJGiJFVSKRSNIQm4weQEZw9uxZNVACcMrosbyDRAE3q1atqs/ogUgkGUGWE9Vjx47lOXDgwNK9e/cWDgsLs8vo8bxruLm5xTdt2vRubGzsF7Vr136c0eORSN40WU5Uz5w5M2natGkF4+PjdUBMRo/nXeTUqVMFXV1dJ9WuXXtARo9FInnTZKk11bNnz7qfPn26Unx8vHTOTUfi4+MNp0+frnT27Fn3jB6LRPKmyVKiCuQJCAjIltGDyAoo73PujB6HRPKmyWqimi0yMtI2oweRFYiMjLRDbgRKsiBZTVQlbwiDjH+WZFGkqEokEkkaIkVVIpFI0hApqu8A8+bNy28wGKra2GQ5DzmJJNMhRVUikUjSECmqEolEkoZIUX0H6du3r8eJEydKBQcHV4qKiqp89erVsoMHD86RuJ/BYKj63Xff5R83blzuwMDACpGRkZVPnz5dumrVqg4ZMW6J5F0goxbhCgHzgaaACtgHfAnczaDxcAjKemSCsN0Q0NaHq69zjWLFitlv3rw55MaNG4/0er2hQYMGLvPnz/d0dHRUz5kz56ll3w4dOuTw9/eP/eqrr+7a2dmpp02bVnDjxo0lihcvflmr1b7ezUgkWZCMEJFswAEgDugBGIBpwD9ARUSWozeOB9jkhHciMODrr79+ZHysVqvZsWNHRN68eW179+6dK7GoarVaQ+PGjW9ahu4uX768WIMGDZz27duXIX8LieRtJiNEtS9QDCgN3FTaLgL/Af2AbzNgTIRApjDL0mIc5cuXt58xY0b+999/3yVHjhy2Go0GgLi4uCQO+UeOHAm3FNRz585FAxQtWtSODPqCk0jeZjJCVD8CTmIWVAB/4BjwMRkkqq875c4suLq6qnft2lUqNjZWP3ny5MAbN27ExcXFGQYPHpzr008/zZm4f3BwsJWIx8bGGgAcHBzkertE8gpkhKiWA7Yk034F+OQVr3nW4nHVV7zGO0GjRo2cCxQoYNe8eXO/PXv2RBrbv/zyS1VGjksiySpkhKhmB0KSaQ8GPF734gkJCYb4+PhkjxUpUoQiRYpgnA6/Kzg5ibwl7733XtUiRYoAkCdPntKVK1cGwMXFhaZNmwJQuXJlqy+dbNmy5atcuXI+4/N8+cRDDw+PIlWrVi0CoNe/fBL/QoUKUaRIkXNRUXIFIS1xcBCOGbGxsRk8kvQlWvOYWHUwANljVNj+JxKeGbKp0Xq6c9/mPuGqcACKa4tjZ7DjhiaUcpdziX4OBu6VMBCqVqOJh5zXxXVj7SFMB2hBpYIyZRJSPSYnJ6cgINeL+mXUbndyyTZex5IyCcWFCxcM1atXT7ZT6dKlAfDz83uNl8p8PHz4EIBz585x584dJk2axNChQ/Hx8cHJyYnx48fz+PFjXFxc+Pfff63OffTokVVbcLD4IAcEBBAdHQ3AtWvXXnpM0dHR1K5d+517rzMaX19fAKpVq5bBI0lfms+H8p+Jxz32OJGzZ38AruS5TdPHm+B3oIHSuQLwDPLvGY1vs2EA7GUvPeYHw2ef4RYAfWqJrjdKwrZnCBOOWMT2TuowGAwBqemXEetmIQhrNTEeJG/BSl6Ao6MjWq0WvV5PUFAQ7dq1Q6PRsH79embOnMnPP//M6tWrM3qYEkmqsXexePzU3vRY76zMQt0sOoeJXzkemvsFEQRqRd4sTDiDCgvzLX1WxDLCUr2CWFdNTFnekc2iN03JkiW5c+eO6fk///xDlSpVkvSbPHmy1XOVKumHKiAgwNTu5eWVtgOVSFKJnYWo2gZZlJJzjVN+K8+jMPnL5HzsaOoWRBBoCrzgVdJHVDPCUt0K1MTa7i4C1FaOSVJJ1apV+fLLL2nVqhXr1q3L6OFIJGmGpaVq+8xsgWrcFVE1FuoJM/fL+cQcCChEVeydqBIvNr6DluoyYDDCA2A8wjifCtwDlmTAeN5a/vrrL9RqNd999x0+Pj4ZPRyJJM0wWqo2CaAJM4uqbXZFVI3Tf0tRDTJXSgqyCU52+m/NuyOqUUAjRJjqKsSd7UeEqUY+5zxJIooXL57RQ5BI0gWjpWofB0SYRdU+V7wo0mNULktRfWYhqvYhJkvVknd1TRVEjH+HDHptiUSSyVEryqQyAHFmmbJxjQd7i44WnmUFg8w5gx4ZHgmfKUCV2CNQZ3yQeneql0FGzUgkkkxHQoz4rbUBdGaLU2ejs+5oYWyWeJxXnKPRExB9E5QyaWqLU3QaRNYRAMLTdMxGpKhKJJJMR4JwkU4iqgYbHVhanoqoqlFTLFBEYd/NF0w88aAEragtArENKqSoSiSSrIfWaKnagsFCVPU2OuuNJ0VUCzkVwz5eLBPcyvtYNCqWqsrCUtWrsEhZZLEgm4ZIUZVIJJkO4/QfQG+wFFV9spZqcVez6/tNj0DxwDj9t7BU9VaeABFpM9hESFGVSCSZDuP0HxKJqiaRpaooWAn70qamW45KNGlyomq1aSWn/xKJJIugTdFSTbSmqihYcczuhTc1/krnpGuqUlQlqaJHjx4YDIZkfxo3bvzS15H+r5KMRm+Z5ddih1+nN1irliKSjphDVMMSRFIglJLtLg/N3WOsanukj1t8htdkkqQdHTt2JDAw0Krt6lWZTkHyFqJK/nFCggosffqVTagEW/NulG2Corr2wqHV47a5e4hZe4Fo0gMpqu8Q58+f59atWxk9DInktbHK9aM2L6LqUhJVjXlebxOvnKyIqru/uXuoVZ3g9BFVOf3PIuTIkYOffvqJwMBAYmNjuXbtGn379k22b/78+dm0aRO+vr4cP36cH374wZQcWSJ5I6Qgqtp4lbUpqCwTaC0t1XhFdY2WqoWohlhN/6Wlmq7s8Yac2V7cL70JioZmq17tXI1GY1XVwGAwoNfrcXFx4dixYzg6OjJp0iT8/f1p3rw5ixYtwt7enh9++MHqOqtXr+avv/5i+/btVKhQgQEDBuDk5ESvXr1e59YkklfDylLF2lJVDNR4mxSm/wbz9D/CMQ6twTLGVYpqupIzG+R1zuhRvB6Js+wfPXqUunXrMmzYMDw9PalQoQI3b4p6i/v378fd3R0fHx8WLVqETmf+UP7999+MGjUKLy8vjh8/zpMnT5gyZQozZszgv//+e6P3JMmapHr6b7JUzdN/S1F1fAb2ijtqiGsCJFiKqoWLQRoiRVUhKH2+tF6a1xlH27ZtrTaqIiLEp6lFixacOnUKf39/K0t29+7d9O3bl7Jly3Lp0iVT+19//WV13bVr1zJ9+nRq1KghRVXyZrASVfPDlNZU7QzmRNZqY54Ue3ty3DB3DXXTWyVgSa8K7FJUFV51yp2ZuHz5crIbVblz56ZkyZJotdpkzhLrrZY8fvw42ecFCrwok7pEkjaoLYRTZZFlWqvDWrUUUW10+z1T03UHMRvDwYGCJ81dH+ezAQuRhfSpnyZFNQvw7Nkznjx5wrBhw5I9nnjZIE+ePFauWHny5AHg/v376TdIicQCVQpb6DodSab/pShFiWfiC/9slQc8VD8Sx+zsKHTC3PVewWxw2PjsFpA+n2cpqlmAXbt2MWTIEO7evcvTp09f2P/TTz/ln3/+MT3v1KkTOp2O06dPp+cwJRITKktL1aI9iajqoBWtTE93tPoPtgvzVWOwI78oPkuE6gkhEbktQlyPpsOoBVJUswDz58/ns88+48iRI8yfPx8/Pz+cnJwoU6YMdevWpW3btlb9P/zwQ2bPns3169epWLEiAwYMYOXKlXI9VfLGsJz+W0VUJZ7+axOL6g3YLDat8l11wEZJ83fP/jLca2Rx4pG0HrIJKapZgPDwcD744AMmTpzI6NGjKVCgAKGhofj5+bFhw4Yk/bt168aIESMYNGgQCQkJLFu2jJEjR2bAyCVZFbtUWqpFHxWlLGUBuFT+MfcKh0O8sFQLnTFvXgU6+0OA8ZkBOJ4ewwakqL4TrFixghUrVjy3T2hoKMOHD2f48OGpus6RI0dMJaqvXbuWdoOVSFJBthREVa/HSrVaXUw09QfQ6sHGhsLHzGfedYkGYxCA4wOICU3zMRuREVUSiSTT4Wi1GWVWUa3eYLJUsz/LTr9j/UzH/v5QEdUEPVU1AymobAGE54gjLMQsvjhcTKdRC6SoSiSSTIejRTipOsjN9DjMOdwkqlMnTCVHtHAH3FX5PDdLiuxUZcJb0SBujOmcEwWDIbSYeGIP6Jal69jTUlQ7AhsQKxcxCCewmYCLRZ8iiAWN5H7c03AsEonkLcZeWQ5V6UH1VJEGOy1hzhFgA033NKXd5nYAhBPO2B4iYMXzkCctQmeYrnPyI7h8Ia/5wo0jINzCeTUdSMs11ZGI0tNjgUCgMjAJaAh8gHVq2ZnA1kTnp09tA4lE8tZhq4iqTZwKjJZq4TC0BgMuBhdmfj3T1HcKU3iUJ47cF734qM9HaBAnX24Fxw6BaVW2JuBwJt3Hnpai2gawdII8BAQDK4AGwAGLY7eB9P26kEgkbyUFAZTpv/tdV9Ar8/2ioeh0MP72ePI/zA/A0UJH+f3e77gF9af90PbYRQlBvV34Nnv9i5lr+xVFmHYn/k338afl9D85r3Lj14KMb5RIJKmiHKBTLNXs/hargkVDKHzvA7zvewMQ4xDDqMajcCQ77Wf0x+mpEwAPVefZ5mFAbwwKdIqGlgiD9VH6i2p6u1TVV34n9smZCSxGZDQ4BIwDLvHqnDU+8PLywtfXN8WO48ePR62W+3OpwZhD1eha9TJ4enoybdq0tB5SlqdMmTIAz/2Mv+04L1vGarslALj7e5gPZNfTecfPpqffjP6G1rW6kffYF4T+J0zbkCIhuDQoivY3ZcnAAQr1tOWekg543+q5uNtbFapKc9JTVAsAU4B9gPETEAcsAfYgLNsyiDXY40ANkoqvRCLJYtgEBKBXlMnzn2LmA8tHon4sLNdzlc9xNEcQLdp/TWi0ENSoXFFsqHWPsN8qmk5RTTIQ+FRcrLCLNt0FFUBlMBhe3OvlcQYOAvkRYhn4nL6FgCuIjatur/vCvr6+hurVqyd7rHRpUcY2cQIRSfK8jvO/fK/TB6OFWq1atQweSfqxCTjtBw6hrvSp2QeVQQVqR9D3B9QEOt5nYaNz5NnRxnROSMFgtpZ9RtCekuYLjQCK3YPbhcTzk9/BsW9eeVwGg+Es8MI3Pj3mwQ4IgSwGNOf5ggpwD5HdIHkllEgkWYoCiL2pCr9XEIIKoH8PUPPM8QG/q+OsBPU621hdKsRaUKciRPW2RRmgaxvfwOjTXlRtEb6qNYAPSf06qQqL/DGSV2fZsmUYDAbmzZuX0UORSF4aNZAXUGvVVFxlzJGqAsoTm+sJf8V6oIkSSwIJDjHsqTmOHZpcxB9QyqprdNDtJPRG2TrPJdofX4TgN5MQKC1FVQ2sARoDH5N6l6nCQG3gVBqOJUvi4ODAJ598AkDXrl2tsvxLJG8DeRAbPRVXNiRbsNHKLEq4Cyx/mptog6gxHVTKjzW/d+bSjU6gqym6OSRA3+9hmDLdv2SRlP3q+jd1C2kqqj8CnwBzEbv6NS1+Cip95gHzgU8RQQH9ETm49MAMJK9Fu3btcHNzY8eOHeTJk4cWLVqk2bXt7Oxe3EkieU2E92ll6nzT2tQWrvZidYSrqUzfxeJrWLOsD89GzoPgCqLRLRbWrocS/lCggFCUK8qmlF4H17e8sXtIS1FtqfweB5xI9NNHOXYFqIPwANiLiLg6BrxPetU2yEL06NGD4OBgevbsSXR0NN27d7c67uPjg8FgoHz58hw4cICoqCgePHjA5MmTUVlUWqtfvz4Gg4EmTZowefJknjx5kqTEikSS1mQjG4MYC3yLRie2YnQ4s0pfihjAzjmC6yUGsLfEerQdNsJtZcpv/ww2/Ak1HoCbsq7qB8QrhkDAIYh+cXL2tCItXaqKpKLPr8pPpmPPHsiZM6NHAUFB0KzZy5+XL18+mjRpwtKlSwkKCmLz5s20b98ed3d3QkOt05xt3ryZX3/9lZkzZ9K8eXMmTpyIXq9n8uTJVv3GjRvHkSNH8Pb2NvmsSiTpQTvaMZ7x5CMc+NvUfppKxKImT8ULfPjTAFZ1agx7FoJBCblyugPtZkBZ4W1C3nLwGOG0aeTyn2/oLgQyn6pCzpyQN++L+2VWvL290Wg0rFy5EhC5Ubt06cJnn33GkiVLrPouW7aMb74RriV79+7F1dWVESNGsGDBAsLCwkz9Ll26xMSJE2U+VUm6UZayTGMaNakJXAV2YdyzvklJTmoqUfPT+VQcv5SvJ0wjMLCD+eSaJyBXP6hgLvpH/sqwGVPpaq5vhhvb3szNKEhRVQgKyugRCF51HN27d+fGjRucPCn2B/ft28f9+/fp3r17ElFNrgR13759KV++PMeOHTO179u379UGI5G8AHfc+Yqv8MYbDRrgImJFUHCNMuysmos8w1tSMCGWdp+s5+rVcuYL9F0K46fB/7TgqYSyavPAP+4QqfR5dB52p5yUPb2QoqrwKlPuzEK1atUoV64cs2bNws3NnHty48aNDBkyhJIlS1rVl0ptCerUFAmUSF4GNWq60pXRjCY72ZXWc4C50OQVSrN75iEM3mvwX1uf6ZN/JDRChKuqVDEYGo2EyZtEZz1Q2E0Yt7sbw0PlIvpw2PI5aGPf0J2ZkUHw7wA9evQAYMyYMYSGhpp+hgwZApBkw8pYcjrxc1mCWpKeVKc6O9nJN3xjElQdp7AUVH/cyZ5nAnrvNZz6YTCLRq02CWrhwgEULtwGymyyuKoaCrqCbzW4nk80aYDjYyDy0Zu5sURIUX3LsbW1pVOnTpw8eZIGDRok+fn333/x9va2OufTTz+1et6pUyciIiK4fPnymxy6JItQlKIsZCFb2EIFFBcoDDzjGBqLUtFbeUJRJhDrEMvWPj9zdNbXGAxCoho0+IedO1tia3vVWrXcXOBucThcz9xWKxxObU7/G0sBOf1/y2ndujU5c+ZkxIgRHDp0KMnxJUuWsHjxYho0aGBq69u3L2q1mjNnztC8eXP69u2Lj4+P1SaVRPI6qFDRgAb0pjeNaGR1LIRQEthNbosI9vn4colDQBvGBU7lWUBu07FhXRcwctZcNBq9KPxnGdOSox5sa4MpEXUN4H7G7gVIS/Utp0ePHoSHh7Nu3bpkj//xxx9ER0eblggAPv74Y5o2bcrWrVvp1q0bU6dOZerUqW9qyJJ3GBdc6E1vDnOYNayxEtRYdNzgX5xZYSWo0znMHG7izwr6s4RnOiGods4RDBv/OaP7zkajEY78Wi2mBNY8qAqq+aBVGoojvOAPHkz3+3we0lJ9y2nbtu1zj4eHh+PkJJL3+vj4AHD9+nUaNWqU4jmHDh1CpVK9Uh5VSdakBCXoRS8+4ROccbY6FkIst4glH7spZSGmD4lgJPv4h4bAGvwszivS8ABNZo3h/ceBVqafVotI2fSoEmxYA2QTBwproZUN6LSwf3+63WdqkKIqkUheCTVqGtGI3vSmvikfvZkrBHCDPLhzlTocwRZzLP7vXGIyD4lgIVDF1J6DID4tNxHH1ZtRqcA2kKSiqikP6/+AeFfRWPARtM0rLNhjpyAkJF3uN7VIUZVIJC+FK650ohM96UmRRIGUscSyk4MEUAwXctGczRTE7FXygAhG8A+H6AAMwDyXh0/5k4lMYUXREPTKEqmNFitRjXUpA5FrwaD4ptr7QbsQsFUid3btSvP7fVmkqGYhJk+enCQUVSJJLSUpyed8zid8QjbjtFvhPvdZxe/cJjcl6UpVLlKXnVbW6RouMoU4IliOSLdsxJ9hfMVoROCJnyMYM6PaJmAS1RvPShLR/C8wKP6tec+B289gN8l8qd270/KWXwkpqhKJ5LnUpjZDGUpd6iY5dpzj/MIv3CCeRsykLrY0ZL2VdXqfcEZyhkP0AD6zOFsLLALm0wfhpB8N3M+WSFQ1cO1pGTpv+AODo5KgI/dF6NAVLrQHFE8Bv6sQ+KKc+OmPFFWJRJIsdajDcIYrcflmYohhAxtYznL8eUQDJtGLxtTmGKW5YdV3FVeZSjki2QA4Whz5FxgFXOVDIIfSehxQWRjBmgRYc7sLE85NJVarnO9wBTp2BocwKN7S3DkTWKkgRVUikSSiLnUZwQhqUMOq/R73+I3f+IM/CCWUUrRhKL/SCD/K8xtqi+IdgYQzEgOH+QawTP8WBcwClgN6HAHLBam/AEdldh8X58yse7PZ52fh4fLkCnzaCRxDQF8FctQW7QYtrFmbVm/BayFFVSKRAFCPeoxgBNUTlYvzx58FLGAjG9Ghw4ncdGYJnXHhPTZhg87UN5gYFhLGCvoSRymLq2iB1cC3gDlr0BBETSoQheq2A81zwuPHFdi+fTGh0UVNfduXXMPG7ybC6BjABvTzwEbZ0bqxHe7dS7P34nWQoiqRZHHqU58RjKBaokKht7nNAhawiU3oFOGsRmdG0IaaXMKeeFPfKBJYygMW04WIRMsFsBOYCdy0ai2K2P8HIbnjlccPDb3Z+/sE9HqRZNrJNpJvmo6mkt0mNtqCSBvwBdgoOVQJgk2rX+ctSFOkqEokWZQGNGA4w5OI6S1usYAFbGazSUxz4IkPw2lJEE6cNfVNwMAKbvEdLXjGmESv4AtMA04n+/pTAHvl8S/ADQd3aDaPi/fN66TluMwS734U8/Dn/HkgH4iydiMsrrQXzmYOKxWkqEokWY6GNGQ4w6lKVav2W9xiPvPZwhaTmGrQ8CV96UNe3Lhr6qsHNnGPb6hAIN9jLSW3EZbpjhTH0AxRIRREov7Z+apC60XgWtDUp0r5X1l/cyoOHnEARESgFLGahXnT6zzwAC5mnnI/Mvb/HaBHjx4YDAYMBgMlS5ZMctxYc8pgMNC4ceNkriDJClSkIlvZyhrWWAnqTW4yiEHUp75p3VSNCm8ac4axjMAJNyJM/Q8TRSNgCNMIpDdmQX2GKFHXkOcJajmE/QrwzDE7n9afSEynTSZBtbcP5aOPetOm8ngc7ONM54WFAZ37AA1EgyESOAr/PYMI81JERiMt1XeI8PBwvL29mThxolV79+7dCQ8Px9XVNYNGJslIPPBgNKPpRjfUFnbUf/zHfOazla3oEQlLNKhoTyW+ogkFMICphilcw56xaDnFMMDN4hVigKXAT2AhvolxQjhR9QYi7N34plo/llTpS6ydk6mP6slZvMcOwM0tENe7iDh/IAYHfvaaDsU7my+oOgDEwfmMyZuaElJU3yE2btxIt27drETVwcGBDh06sGHDBnr16pUmr2NnZ0d8fOaxDCTJo0JFZzozlrEWWfbFBtQc5rCNbVZi2g4vRtGYQtiBhXvUfTz4BhXr+RgsrgM6hBPUXMwp95OnNcJ1ytnOmYVV+rCkaj/CHSyEWRcPvksowBzc3EQUVq5gwBkCKExflnG5eAWLK24DlGoWFzLP1B/SfvrfAPHXSPwTmqifB/AzwrciCtgHVEDyWqxatQpPT0/q1KljamvXrh0ajYYNGzZY9a1WrRrr1q3j3r17REdHc/36daZPn56kaupvv/3GkSNHaN26NefOnSM2NpaBAwe+kfuRvDqVqMR2tjOXuSZBjSaaGcygEY3Ywhb06LFBzWeU4xhfsJCWiqAKHpCH6ZSkFh+xnl6YBVUHrAfqITaMUhZUT2ANsMDGkU3VBlCzz0nm1P7KLKh6LVxcA7/UhqMzyVXaHNaa6yns92xEC3Zx2SgP+lhgOKK6n0IWsVSHAmcsnmstHquArQiPiiFACPA1oqbCe0CGxJl574FsmaBEdXQQrHrFelkBAQEcPnwYb29vjh4VGdW7d+/Opk2biIyMtOpbuHBhzp8/z2+//UZERATlypVj4sSJFCtWjM6dO1v1LVWqFAsXLmTq1Kncvn2b4ODgVxugJN3JTnbGMIYudLGa6m9nO5OZzH0lfNQWNZ9QjiG8j6fVVB4ekI/NFOFHShNiinUCsT21FeFrau0elRg7YBDwhcaedRW78eX7Q3jqZE48jUEPVzfAyfkQesfUnKus8ZXUrM83gl/K/890zOHpXWId+oLLJdD2EuqVoIOrmauWWnqJ6jXgZArHPkKkkm2EuTjNCcAf+AohyG+cbDnB+S0uUW1k5cqVzJs3j6FDh+Lh4UGTJk1o2bJlkn4bN260en7s2DHCw8NZuXIlgwYNshLOnDlz0qxZMy5cuJDu45e8GskX1BObUOMZz2EOA2CHhs8UMS2I9Rp7IAU4QCWWkxc/PBK9wjaEmPq9cCx1gClqW86U/4xGNb/koUt+6w5+W+H4PAj+L8m5ubwgmuz8zQ8ElG9gam/MPgJHD8Xv11DADmyUe/R7BrHaJNfJSDJiTfUj4AGW1b4gDPFX+5gMEtXoTFKi+nXHsW7dOn744QfatGmDp6cnjx49Yv/+/dSrV8+qn4uLC+PGjaNjx44UKlQIOzvztK9kyZKcOnXK9PzOnTtSUDMxlanMDGZQiUqmtiiiWMAClrKUBBKwR0NnKjCYGuTHxer8uxTiOO+zlewcxwXr1fKdwDzg6gvHkQuYoNKg92pPz1rDuevuad3h5m44PheeXkn2fJUatGUqsZplRCA8AVQGPSNVcxnGd1TQGdd5LQpXXshcU39IP1Fdgwj4DQV2A2PA5ORWDkiuwtwVoDvgjLlyd2oxeSN7eXnh6+ubYsfx48ejViddSvYd9pKvmI68bML9/PmFJVCiRAns7Ow4cOAAAwYMoECBAuzatYsyZcrg6Sk+4J6ennh5ebFgwQJq1arF999/z/Xr14mJiaFChQpMnDiR0qVLEx4ejoODA2q1mtDQ0JeuAuDp6ckdnAsYAAAgAElEQVS0adNe3FHyUpQpUwYAX19f1M/UuP7gSrZt1mn4YprGEPFlBL3y9KKXvieOuwNw+fECNo+irfoFUJgT1OKCbQH+TlBhOYmuWzeWL76IwMurErDyuWNSRUbivGYNfnsvM6buFK7mLmd1vFbeWPpVjKB85wrAihSv86dTNN86FEKnhAR4xATzY8IQGrj+g8GgYeiCsUxmKmCeUo5t1Zv2DWc+d3xvmrQW1TDE19ohIByoDIxFTO8rA08Qq913kjnXON/04OVFVWLB1q1bWbRoERqNhlGjRiU5bmdnR6NGjfjxxx9Zvdoc3leqVKkkfQEMBkOy7ZKMwZBgwOkPJ1wWu6COMhsICUUTCBsVRnwNYWvanXuC64J/sbtqvQbuTxFOUpM76vwc1Ku4lGA+9sEHQkzLl0/ghcTG4rRuHYY165lZcSAr2vtgUJnHUyVXLAMqRlI59/M9RbTAPDc31jmZlwmKR/7LH39+QYGeDwDQ6XITaPPAeNTUr3y85Zpv5iCtRfVf5cfIIeAwIk5tKCK8V4Wlv4YZ1Wu8rsmT+dq1a4bq1asn26l0aREr7Of34nWht4kaNUQ2oZs3b3Lr1i38/Pxo2LAhoaGhbNu2DYDcucUmQUBAAP7+/tjY2PDgwQOuXbtmus6iRYtMfa5du4aXlxd6vZ74+HirfqlBr9fTtWvXd+69zmguLr6I22w33G6bN5ciiWQ+8/nZ/2cSBiZQFHfGU4+WWAeCBFCYo9ThEfm4AhzSCw9TwUlgJsePn+H48eePwRboBAwDjpb8kAntt/LIJZ/puCboOrqDkzgXcJi+L7qhnDlh6VKoac4XUIE1fLdvHB628aiUyqnbtz/kF+0v0NEdUwqWW8F0qdv0Ra+QZqTWuHgTa6rngBtgSn0TjLWzmxHjynjGFph5B9Dr9XTp0iXF4+Hh4Zw4cYIRI0bw8OFDgoKC+PzzzylQoECK50gylgIUYAITyNnf2kVlPeuZznQe8xgPHPgfdehBJWwt6jg/IzuHqI8/RQlF+C8GmI7eBKYjVumejxpoC4wEbFwKMKbxDPYVN4uaKiEGw8kF6HwXgz4Vlm7FivDrr6AsX6kN8TRSjacSq8kfAJttoKvS9dQp5cUpaz5/3YvXeTOCN7VRZWmdXkGE/iamLGLdVU793wCdO3dm0aJF/Pjjj8TExPDXX38xbNgwduxIObxQ8uaxx57+9GcoQ3G0SPJ8mcuMZzynOY0dGvpRlWHUxB2zn3E0jhyjNpeogA4V51BxDKN/41PESt3vWHs8Jk8LhGtOCZWGX6r0Zs4Ho4i2iITiziEM+7+2co96Lh07wuzZoPhFO4Q8oa3bFxRQnSZHEHy9BdqNNXc/dQrhgInF2v6GrCuq1YBSiNALEI5uvYD6iOUBAFegDeIvLHlJVqxYwYoVKW8AgLnstJGAgAA+/PDDJP0s+wD07Nnzpaf+krShKU2ZzGSr4np6Vz3hA8NpMasFevS0oRRjqYsn7qY+WtScpRqnqUE89jwB9iASl4gJ/2JESGnUC8dQF7HLXBm4mLsCrZrN4VKeiuYO0UHwjw9c35S6m7KxgQkToK95YcDl6r/8dqsPx9uIIILHZ2HLDZihzG1DQuD6bSBvATDe57G7cD/lkNiMJK1FdQ3C3/QcYue/MsKx/z7wvdJnK2LjajUiFNjo/K8CZqfxeCSSt46iFGUKU2iMOfmNHj2rWU2zjc3Qu+t5b1YeJtGAalj7gF7Fi6PUIQJXEhD/aGeV84VdMxt4sRtSVWA0wuc00taJibW/4tfKn6NXm5cVuLgGjkyH2MQBkymQPTssXgwWEX8eW/7kiN8YrtcxJ07Z+zeUKQNuyrKxry8i5Z/aYuq/IfN+0ae1qF4GOiMM9WyIv95GwAdzum89IhR4LuLr0gHxt28IZJ6kiBLJG0aFij70YQxjrKb6vvgyjnFc4hLNdLVxn3SB7Vivmd8lD4dpwmPF3egusBdjfPg/iLxQLxaiesBghJgCHPSsz6hmc7hvkZKPZ//B3q/g/qlkrpACtWrB99+b1k/Raqm1zIcVoctxsoMAC5fWB77QoZH5+alTQIM8QBnl3ATYbl0LKzOR1qI6U/l5EcHA58qPRJLl8cST+cy3KrL3hCdMYxob2IAa6E1lcrffgToqwaKPLSdoyU1KACpiEWtqwhH8CjAVlGiqlFABLRGWkDF8IMTBncn1ffirvEX1U20snPwOfBeJBCipQaOB4cNh2DBQ/MM1wc+YuvYLesacADu4VQweKHukYfcg1B86dTJfYldQPpjVAYx5Cc77QWTmTegjs1RJJBmIChU96MF4xpMNsxP/ClYwnelEEsn7FGA6jSlLLlAENQo9x3mfy9RGr+z030Ts7EcRDMwA1oKShSo5bID2iBh9S+ernSVa8FXjmTxztohcCjwJe0ZCyO3U31yBAvDTT2Dh4ljg2inWHxyEZ4zif6qGbbXMpxz7BqpVg3JK/MCa2wW5Pb0dOBgj/h7ALMtgzMyHFFWJJIMoSEHmMY+61DW1PeABwxnOYQ6TBydm8SHtsY5mu5OnFLseNyQKZ0BsPR0ArgPwJ8I6TTnpjSNijW4A5qJ7AE+z5WRoo2kcKv2RuTE+Eg5PhwsrSd69PAVatYK5c80LozodPQ8uYMqFBdgYRFWBO6HwbW7wVAKkHvjCtU3w/ULx/BCejCn4MdjZKhe9B/GbwDcV7loZiBRViSQD6EIXJjEJZ0UYAf7gDyYxiRii6E81hlMLZ4tUfLeI47xTN+48LmxqM1unNxD79CnlMRIuNj2BPlgXjTYAc73a80PDKSQ4WriQ+/8j1k4j7qf+xhwdYdIk8PY2Nbk9e8DyvYOoqazB6vSw5Cz89B90OWg+9cAEyJEdWreGfRSlj+EjdHZGiboDbIHrWsi8M39AiqpE8kbJRz7mMpeGNDS1PeIRoxjFfvZTh8JMowOlLFLuhRPP3xTkAV0xKGGpMYjtp2vEAAsQblLJW3A5gS+AHpAolQpscMnPhCazCC3WxNwYGyrcpK6ue7mb8/KCRYvAIty54bW/+eHASDwUD4HLT2DEbrj0BJrNA3tlQJf/hMcXYPBgOGBfgv60JsEYTnX2FlTdBujgLcjrI0VVInlDdKAD05iGm0X+0vWsZyITsSWexbTmI0pbnfM3YVznCwyYd99vIXb2oziASK1xl+TIj9jJ7wRYph7XIypITanQlfv1J5qVDeC/v2H/WIh68nI316MH+PiYnPlt42OYemgS3hdXoQJiEmDeCVh6FrR6yFMRjHtg8ZFwdKbYx8rdrwxf0BKdMRfsjhtwaQdUVdaGpahKJBInnJjJTDrS0dT2lKeMZjS72EVNCrKIVuSxWAq4xFO2UQF7i1LMsYi106CcOqKC+pNScb1ciJ18b8wloEHYsRuB75zzcqfZPChqtpaJegoHxsGN7S93c46OMGcOtG9vaioddJ1F2wdQ5pnI+3DsLny1F/wVd1bH7PDhjyLVH8DJBULDm66vik+O+hiMaUA2XYOhO2G1xVquFFWJJGtTgQosYhHFKGZq28pWxjKWEIIZRHXGUAeNYpmFEMMSHhDL17hQyHSOsE51tOkUQ//+ETRokFRQPYCBCD9FR4v2GERUzmLgQZl20Hg6OJgjsLi6Xkz3Y18y7YanJ/zyM5Q1p/rzvrASn4OTyaaNISwWphyCPywSfdpmg3arILuSaOrZf3D2VxWV/27I3vcqm/rlOXiZx0P2QDmDiL0E4fV+/eWGmBHIEtXvALJEdeakN73ZylaToEYRxVCG0p/+6IhiOW0ZRz2ToJ7iPuPIjg0/mAQ1HtgFbOYWUXzMyJHhODtb78K7IJKcnES4RxkFNRZYArwPTHTMzoM2S6HVj2ZBjXoKm3vBzqEvLaiOLRpjt3enSVAdEmL4Yccgvtk3hqiwGGYfg9q/Wguq2gbaLIN8inZGPYGNfW3w3P0x/1oIasV/TvK4627QG6xT1v+EKI+VyZGW6juELFGdOfDAg/nMp5lF3qArXKE//bnFLSqQm2V8RGGLtdVfuMUtBlKc8qa2+4i8+2H8gvA7NSfqAxGy+DnCNcqy+Ek8IonGQpSA1OLNoOkccMpl7nRjO+wbAzEvV2+soJuKElP/x8GOI01tRUL8+XlrH1TXrvG/s7D5OsQlFj+V2JgyrjjERcC6IdmwX9MO/wLCp0qDntrb9nG43yXRqRTQSjk/CGFuvwVIUX2HeFMlqiUpU4Ma/MRP5LeIyV/OcqYwhTji6EZFptIQe+VfL4xYvgdsWUAOxX1KBxwHznAfA/8Djlq/SGwsfRHrppauUTpgHaKSVCCAnQs0nGLeEQKxs79/XOoToChUyw9d67qxffBC9luk+2tyay+fLh7ClKPhHA5I+fx646DcJ8o442H9xOzELW5PpIf4YnEinsZ/bmPr/+6YT7KsxrGUxN8pmRY5/X+HSOsS1ePGjePw4cPY2Fh/9zo5OREeHs6MGTPS94beItSo+ZIv2cAGk6CGEsrnfM44xqFGx0JaMpumJkG9TDDfURNHxmGjCOozhJV5mj8x0AhLQbUFsq1fT5527ZiMWVD1iA2o+ojizYEAhWpDj/3WgnrnIKxonGpB1aigdSnY2hlmDfFigc9Ok6CqDHqabZzD3XY9+WLN8wW1Sl+orlQ1N+hhww+FeDajs0lQ8xJBh9VrrQW1GKKaHYiUS7+lasiZAmmpGtmD9dd+RhFE8tlmU0Fal6heu3YtXbt2pV27dqxbZ/ZZ7Nq1K05OTixbtuzVBvqOkZvc/MAP1MH8ZXaGMwxkIPe5TylysJjWlLH4gG0jgiuMwMkiX/s54AhBaPkKsZIqUAMdEOum7rNmWb32DkRmIlN9BRtHqDsWqvQ2d0qIhoOT4eKqVN1PQVfo4AVdKkAhN9hYph0jm80l1las1tpHhmI/bDB7dh544bUqekPDyeKxAVi3rSL3hzZCbyN8UL14StOVm1g4JlEavyFgyrP9C29VlmUpqkZyYllP7K0lLUtU37p1i9OnT9OvXz8rUe3Xrx979uzB398/3e8ns1OPenzP9+RCrFfq0fM93zOXuejQ0Z1K+FAfR0SoZTQJ/EkRgumEMfgyApF3P4C/EQn3npmu30JpsfZeFVFUc4BLlo2FPhALl5ZVTO+fhp3DIOw5piTgai+s0o5loabiEpugtmFC/Yn8UqWPqZ/q6hXievchLuD513PKA01ng3GlIBQ3NgQ2JfRj89jqcYd6q7YxbUyiEKm2gNHAjkCI6luEFFUjmaRE9euOI61LVK9du5a5c+dSokQJbt68SbVq1ahSpQrt2rV7vYG+5WjQMIIRDGUoamUV7QlPGMIQjnAEDxyYSyurOlEBxLGLTkRauFf5AfsIJ5bxwHpT+weIJMOm4msKcdWqET5gAN17W1iitk5i0fK9nuY2bRwcnwO+i8WcOxls1NCwCHQoC82Kg4OFGjx2ys0XbZZypkANc+OGDRi++gpinr+4WbajWMp1cAc9Ks5RhSPa2ugL2pr6dOEiZVfuZ8LXicZWHZhv8XwBopzoW4QUVSOvOOXObERGRrJ582a8vb0pUqQIa9asSbZg2fLly2nSpAkTJ07k/PnzREVFUaNGDX766SerddV9+/bx6NEj+vXrx6hRo+jfvz/37983FRTMiuQjHz/yo1WaviMcYTCDecpTalOIhbQkn0VQ6GFc+ZeeaBX7NAbYD/ixD1GoRCSOroAQ0waJXvMCYv9//uLF1gc864mdfTezTysPzsLu4RD8X7Ljfy+vsEg/Lg05siU9vsW1BiM7LiHKQ8lSlZAg4vmXL3/e25LEOn1KTnZpm/HEJp9JafIRwXTdPo5Pvs34nxNdwBP4FXPEwjpg0XNfMlMiRfUdZOXKlezYsQONRmNaH7XE3t6ejz/+mEmTJrFw4UJTe4UKFZL01Wq1/PzzzwwcOJDZs2fTqVMn5s2bh073FjgMpgMNacj3fE92ZS1Uh455zGMhC1EDX1OHQdRArUQFRaBjF424SzXTNW4BewgnmgkI5RBFl0dh3psxchOYBfydeCB2LlB/IlTsam5LiIFjs+HcsiTWaUFXaO8lxLREMmU3Q2Jgix8sqtibez0ngq1iVT56BP36wZkzz31fvDpAo6nCOtWi4RTvc0pfA4ONuVKANxcYFHKYUf3jOXIk0QXcgVVgSnlwQnlD3kKkqL6D7N27l7/++ovQ0FCuXk1aHM3e3h4bGxsSEqwTcPTs2TPZ6y1ZsoSvv/6adevWYW9vnyU3qGywYTSjGcQgU9tDHjKIQZzkJJ648ROtqIy5VLMf9hyiOxEI/+BYRBKUq+xFrJQ+Ih/wP0R8vuU/4wNEWb6/SOrvfvSBPfT8B1wsSqkEnoI9I6zynRrXSTt4Qa1CJCFeB/tvi6Kk+x85kjDLOtyUkyeFoD59muL7ktg6fUA+dmmbEWKT0+RbVJQQ5rCHHH6BdOoFd+4kuogtsAwooTy/hUillcmzUaWEFNV3kLQuUf3gwQO2bdtG+/bt2bp1K4GBgek19ExJAQqwiEVUs7A2/+EfhjCEYILpgBczaWJK06fFwGHe4zyNMCjKcgfYTRiRTADW44FIdtIL62QnwYhibisQImyFvRuTTrqz3T+bOd1UQjQcmQn//goYnrtOasT3Aay/Ctv8ICQWKFIENv8MZS1qQC1bBlOngjblSquW1mk8thyjNucMVcBGWOlq9PTjLCM4zuFdWnoMgajkag3OBmpbvAHevNWF6qWoZlFetkT1unXraN++PUuWLHnDI81Y6lCHJSzBQ4lZ0qJlNrP5kR+xQ818mvOZRRTUU9Ts5TMeKr6q8cBB4BJ7ga9w5jF9gX6AZXxbFMK/fTFiwzsJnvWgxQIhqEbuHhPZ+MMCyJUNer4H3pUgZzLrpHdCRUXnDdfEYwBUKujSWVQ3NSaTjo6GkSNh8+YU3xP3ImIjypgt8A6e7NE1JULjhjEXSlmeMI89VOIx334L8+ZBkqV9NTAe805/HCJE7E6KL/1WIEX1HSA9S1Qbad26NXfu3GHnzp2vN9i3iC50YSYzsVU2lx7wgIEM5DSnyUk2fuVjq2qm/5KXo3QkXtlpuQvsJpxwxuHIBnoD/QHLJc14YCUipDRZxw+1DXwwCmoMMqV1ymajJ3rXWLiwinK5DPRtAW3LgJ3G+tTQWNjqJ8T0zINE1y1fHmbMELVLjNy+DX36wPXks5bYZoP3h0LVfmBjD9E48g8NuY6XyafU1qBluOokAzlDQrSePkPh7yQLwggXxh/BouiBiFw4nexLv1VIUZU8l4oVK1KvXj0+++wzhg8fnqwnwbuGChVjGMMQhpjaDnKQQQwihBDKkosVtKWAYmvGoWcPjbhBFUCFFlFq71/2Ys8ovuAJg0kaUroB4bif4mKKayGRACW/Wfiq5Y7Dp8Yzvl+/kr6fQO3C1qfo9LDvNvx1Bfb7i3VT62u6wldfifynGgsV3rpVtIeHJzuUMm2h3nixjGsALlOOg/r6xKnN+bCq6B/wrXo3pQjm3j3o2ROuJVfAtQbCJDf6heuAScDLRc5mWtJaVA9iTtSVmN0IX+YiQEpe4x4Yq+pKMgVr164lIiKCFStW8NNPP2X0cNIdBxxYwAI+stiHX8lKxjEOHTpaUILvaYmTsn4agoq/6aZsOQmXym3EEMQEevI7Q0kaU7IFsQl183kDKdUGms0Be2WRQK/F9uQcfhvsgOvBP/itrXX3iDj4/RL8+i/cS14XxSbUxImQO7e5zd8fxo2DgweTPSWnFzSaBoWU4nwhuLNH35RAdWHTRpR9XByT7I/grb6AGrG/1acPBCeXq6UfMA6z8jxF5Cs89rw34+0irUV1INZLRQC1EDketiZqn5lMW7LLSZKMo2zZslxL1tx498hJTpaznKqKy70ePVOZyhLEOvIgqvM1dU3uUoG4sIPORCq7RreAnfxLMwYykQASb/v9jbBMn5sS1MZRxHVW7GZq0kQE4h04kNFVfHE7Z909IBR+Pgd/XnlO1eZSpcRU/4MPzG2xsfD996LaaVxcklMc3MWqQ6XuoNaADjW+VOO4vhZ6tVk2qj+5wZLcB8iL2IFaswbGjhWurVa4IJz6LVecTiHWQx4/7w15+0hrUU3qvwN9EUtHaxO13+Z5VcokkjdISUqyilUURsynY4hhEIPYxS7s0DCbpnyKORnzVYqylzZosUUPHEVHDLPZy0+USOQEtRchplYhpcmRswy0WgQ5zUGplSO2s8JpFDm9rMOKTtyDZedgzy2RdjRZsmWDESOE2WhrjmZi3z6xOZVMqKlKDeU7Q92vRYZ+UNyk4psSYpfLZJ1qnkQwWXuAz/MLe1unE/EBvyQXUloW4TJV1KJtEcKsStm54K0lvddUHYFPgG08r2auRJKB1KUuS1lqqh31mMf0oAcXuUgOHPmVj6luYXee4H2OUxtQEQkc4B6j6cOHiWTzECI+P5FxmTyVukN9H1CSltgZYpiq8qGby2rjhjoJOkgo3pKo0l3o0Mw75WuBKEk6aRLkt/RlDRTT/127kj0lfzUx1c9TUTyPw47D2jpc1LwHdsoo9Aby7TnP5vePUii3MI3DwqB/fzh0KJmLfoYIBTMuvYYDX2KZL+adQ5XOGw9dgdWIQBFjXGMRxJpqEGINNQrx+RtHKr7MU+Cs8UFUVFSV6ynsXgKMHz+egBckg5AIjOGqsbFJPCZfiKenJ9OmTUvrIaU5Dvsc8BjngUonRCOheALB3wWjy6vDxj+M7EMPYfNQTG21Kg27Dc3FbjcQALi672Bc6BAcLbxK46pUIaJ/f+KrVHnh60fGq5h62p3998wbPqXwYzH9KaPkntLbuRFVoj1RJT+lVBWxXZ7SZ/yuRsNsNzdOWoQa2xgMeEdG8nlkJI7J/L9Hqx9z3vUHArKZPTvuUoi9+raEqs05IYonODMz4Ra1HX9HpRIRW1ptYZ49+xadrojVNUPVocx2nc2ebHvM95VQim+Cv6GQLplIhLeAqlWrngULZ+UUSG9LtTvwBJHA3EgcosrDHsQydRlEScjjiH3BrLGAJ8lwHA5YC2psrVhCZoZgcDZgd/4p2YcfRh0urLFIVTa2GNqaNqQu2cTSU/c5DUIPmq4XX6EC4f37E1+jhvABfQHXgm0Zc9SD+1Hmf8NurGISk8hGDAmuRYkq3ZmYIh9isHF4zpXEP9VvLi6scHYm3uK1q8fFMTosjCLJOPFrVbFcc1rJNecV6NRiXTUBG07rWnFSU8I01bczqBkYa2CY/QLsbc3LELGxNQkJmYHBYL2Nst9hP7PcZhGiMXvwt4luw+jQ0Tjw/Pt4F0hPSzU/cA/4DuGB9jwKAVcQG1fdXtD3ufj6+hqqV6+e7LHSpcValZ+fX7LHJdZ4eQmL7FU2qjL7e92c5ixlqckHdSMbGcYw0w7/j3xoStf3GA+20JEIXIkH7uDLN3jjrqRPug34IBKkpJr3eqJq4INBI3xanYlgLiP5iG2cuQ/zT8LBO0lP8/X1BUSScRP164uNqKIWi5aPHsHkybBlS7IvX6Yt1B0Hrha7aXcj87A1piVxuXKY2lyv3+cH2100KW52yomJgR9/hO++E2upJrIjpvqWCQzCgIkYUxy81RgMhgy3VLshvuue75UuuIdIcZ68GkokaUhTmrKEJSZB3cxmk6D24j2m0si0w3+HAmynLXE4EIUBN5aziAmoMZCA8F9fSDIhpSlh54JT67lEFW2D0ZwpzyWW0I/Yp3focRT23n7uFczkzSuEs00bc5tOB7/+KspGRybN7JynkggttXB9JUGnZtvF9/GvUBOcFfM0Xssn/sf5towvGsyG19atInr1/v1EF26F2HiydMbdj0jA9TCV9/OOkJ6i2h2RsSy1lbpVwLvvWS7JUBrRiKUsxU7xM93KVoYwBD06xlGXQZjzh16jFLtpiQ4bQtFRh//RXMl56otIovQydnjOIhUwtF7CM/siprYe/EbvsMnMPx7HxmvP2cm3QAvQty+MGgXOzuYDvr7w9ddw5UqSc5zzQp0xUO5T6/ZLvtk54NwCbWVzIpjcQU9Y4baTSqXNMV6XLgmHgdOJI55yANNJap36ILLBZEHSS1SrAeV48bTfSGFESoV3JKbizeLj48OkSZOwsbHJsin5UkN96vMzP2OvhJFuZzuDGYwaAwtoSQfMCUV8qcoh6gMqgomiF20pwRXCERqymtRbAO4OUKt1D/YXnkS8yjzd94kbyfVj22hyMZnIpxS4YGvLLHd3YaEaCQmB6dPhjz+SBNjbOIiw0veHiDBTI8G3YdvxygR1qAuOwmJX6fX0ijnDhJwnsFfcwoKCYNYsWLsW9IlzXbdBTPdzWLRZp4fNkqSXqHZHfKH+nsyxeYhlgROIjarSiLy8esSfSCJJc+pRj+UsN22U7GQnAxmIA2p+oS11EWU+9MAhGnBOCQCI4h6jaYYrYWwHJpB6X3VHG+hew4WAGnPYqTGbcl76y9Q8/wWTjt4hKrGTfEp4eMC4cfTOlcu6fe1amDYt2fClUq2h3gTr/NVx4XD4F2cuVmsB3cylTfLGhbLYfic1nESSgPh44XO6YAFEJA7JyQVMQ4iqkXdo7fR1SQ9RtQU6IzzRkvv8XUGUKu+JiLMIAg4Ak3m52ZREkiqqUc1KUPewh/70xwkNf9CR95RA0gTU7OJDbigVoew5yv/4jEcYGIpwV0ktH5WG9g3eY6LzIu5iFq/qT37j1qbJLI9MGsWUIm3aCEs0p8WC5bVrYqqfZD4Obp7QZCYUaWBuM+jh4ho4ssaVuF87QX5zVQJvLjDR/hBOCIXfu1cYwrcTr+06If5z+ymPjZjTw0pInxLVCYjvsjYpHP8VsSHlgRD1vEAXpKCmGQaDAR8fH6s2T09PDAYDPXr0MLUtX76ce/fu8d5773H48GGioqK4ceMG/fr1e9NDTjdKUYoVrMBR8T7fxz6+4Auc0PAnn5gENRo7NggTXdMAACAASURBVNKRG5TGgIGi/MxAPuUXDNQn9YJaNhes+1RFxdYD6OO8xSSo9roIsu/vz5lVYwlOraDmySPMxSVLTILqqNczLCwMmjdPIqhqW6gxGHocsBbUu8dgVTPYt8CZuCWfmAQ1tyGSVWzkG/bhRAL//QdduohcK1aCagf0Rswth2MW1FBgKNADKagWyCxVRvZ4J5+I8k0TFA3NUldKOC1wdXXl999/Z8GCBUyZMoVevXqxePFi/Pz8ePz47Q7KLkABfud3Uy7UE5ygL31xQs1aOlIBUYMpEgc28glPyY0OA3UYRxl+owMiPD01eDjAqNrQomJOhqu/4yANTcccgi4Qu2UgcaEvUX22c2cR/WTMc8r/2Tvv8KiK7w+/u5uEJCSkQmgCUoRQBBQURCAivUqV8qUKCCoKihQFQ1OUJvpDBAGRoiC9BSmhI70nEIpAgISEJKT3svv7Y+62FEggIW3e59mHvXPn3jsbNiczc875HMDbm4316lE2LY2f0sWdlm8MbX4Qma56YoPh0Ddwcxfgaotme2/SKjsCUJVwNqs24EYcISFimb92bTpNahWisukEMJlsC1Wp9Yh0sZDsf6TigjSqelxtoazd0/sVMUqVKkW3bt04rKgUHT16lLZt29KvXz8WLlyYv4N7DpxxZh3rKK/onV7lKkMYQknU/E0v6iCUmmKxZjN9CKM0KWjxYByl2UhnsqeVrFHBoPow/i24YtOCdvxMKCYqUOeWkHhsNmizuXlaqZIIh2puIjQaHi5c71u3UlaJU9VTwgGafwX1TbJWdVq4tAqOfw/JMWBX0Robr56ElhbJ/BWJ4m82YR0Vx+zFsHx5JgVSPRApOXXTte9GFM16osRW8UYaVT1h8fk9AsELHkdcXJzBoAIkJydz69YtKlWqlPVFBRxbbFnDGqorRY/ucY8BDMCS1HQG1YbN9CaM0iSipQ2jSWYnncleVeS3XoKZ70D10hbMYQK/8InxZPxj2PMZ3D2YvUGr1TBsGEyaJIRQ9GzbJgzq48cZLqn1HnhMh5ImvquQq7B/AgRfBGtr+OAzK05/0QNfC/GZ3YhldeJGtq2I4ZdfIDK90GZ9RML42+naTyLCHrIlZFC8kUZVzwtcchckIiIyFgNKSkoyK1NdmLDEkuUspyENAQgllH70I5UYNtCb2ggLFIsNm+jDY1yJRUt7PuA/9jIZeNqcsoI9fNMSutQUOfLdWWyIFgDg3jH451OIy+b2ySuviHojr5vcIyhIOKL2ZdzNjdEE0PMv833TlHg4MQ8uLAeVTuyNfvSFBV+U646vklrrrIun/46N9J8eRXD6PdCqCGdTek/INURMTjb/NkikUS2SJCYmYmVlZdbm4uKSRe+igwoVP/IjHngAEEMM/+N/xPCITfShlpLuE4stG+lDOC5EkEZnhrCfAzxNglujgk/fhE/eEKGdO+nMeOYZqqWiTYV/58LZXzKUiM78hhr45BMYNw5M/7/WrhVhUulU+C2s4ard71y1X0EVN2P7HW848BVEB0D79kJz2q5aST6jPaepCIBNSiLWIzbz4750oVdlEapR/TG3BgHAD4jI8Wx8FIkRaVSLIPfu3aNuXfPNsE6dOuXTaF4cIxlJD0SJ5SSSGMYw/sOPzbyfqUF9RBrtGcIyDvC0ylvONrCkM7xdSQg2f8dEFpmUWyE6ALw+gofnsr6JKWXLigT6pk2Nbf7+Ikvq33Qy+Cpw7w5vT4YrpYymPzYYDk6FW17g4gJLlkCdrk4soREbqU2y8uutTkgmoc8WEs6beJVcEeVcB5GxnOtPiMJZOYj6khiRRrUIoRfHWb9+PVOmTOGrr77i1KlTNG/enH79+uXz6PKWutRlMpMNx2MYwylO8DvdDGFTMdiySTGo99HSiiHM4QBXnnLvemVgRTeoWAqisecj3S8cVLU2dri5C/Z9CUnZ2YkFPDyE6r5+9aDVwm+/CQdVOo/RS82g5VSjxikAOhWXVuk4Nls4ot57D/rMLstah8aMpgY6TBSy4lPQDtoG55UEfCdErOkwwDTYJR6hHZdlOVdJdpFGtQhgY2NDamoqWiWPcPbs2Tg6OvLJJ58wadIkdu/ezcCBAzmTSaB4UcAGG6VktFhCL2c5u9jFD7SmDdUASMKCrfQkHBceAnX5knkc4PZT7t3DHea2Ecv9W1RnsHYl/mpxT3RaOPotnPs1ewO1sBAz0TEmM9zgYPj4Yzh50qyryyui0F7V1ua3cEtqTIPoz5j/1f8oXQYG/FmF043eoD/pNErjkuFPH1h2HgJjRJGjD4HhgL1JvyRgDfB/iPxGyXMjjWoRoEaNGvj7+xuOk5KSGDt2LGPHjjXrl7789NChQzO93zvviBhLvfRfQccTT2pQA4BrXONbvmUMbzCQ+gCkoWIn3QilDOGAFX+whnVPNKgaFUxtCSMV35E37zJK+wvxamX/NDEKvEaD/+HsDbJ8efj1VzCVpTx8WBhYE89+yTLw1nhR0kRtUuw07AYcnQkb5iwmDS2Nv3cnqn9jFlqYp62qIuLRLbsIf1wSNapLIgL0RwGOJh1TEEnkP1PsVKTyGmlUCzGvv/46zZs3p1OnTixYsCC/h5MvtKc9gxgEQCKJfMzHdKYqk00Kyu+nLfeoQixwjxPcY8oTDaqzDSztLMo/64BFfML3ukno1EoC4uNbsH0oRGRTo691axFd76wUfUpLgzlzYNEigwCKpS00Gg2NRoGVSQpo7CM4MRd8/wadlQUb7M7zp70vDwd1NHuEbVgk8fPPodtwFRJSRfmSUcDHmAuepCHy839ECG5Kch1pVAsxGzZsQK1W89NPP2VISy0OuOHGPOYZjmcyk9IksEBxVgGcoClXqUsScJIHxDKMO09wZ9crA793gwqlIB4bxukWsFPVDcM25e19sPsTSM6oVZoBCwtRWnTUKGPbw4fw0UeGFFOVBuq+LyqX2pl49FPi4exiOLcEUqxtYFxDrD5swNySt0BR2QJ4KeoRkd+eJWbdTUjTiVMfIJxQJvdDC2xD1DXOrl6r5JmQRrUQU61atfweQr6hQsVCFuKMmP15480JdrCdflgi1s0+1OUkTUkD9hNLMv25S3SW93yvFsxvK/ZPH1KO/2n/4Lq6nrHDyR9FMGh2RP+qVBHOKNPYU29vGDvWoChVqbmoRm2aWqpNA9914jFxCVYwvimqIfXRWVtiWoH6zeR76Bad5cy8e/ofCPRBpJSa1PoDYBeinOvNpw9b8vxIoyoplPSlLy1pCYgA/wl8wZ90opQyi7tLFbxpDajYg5Z4RvDgCYv+0Y3EHirAdWrSJ+1PwjSKdUqJhz1jlST6bDBokMjb12dGpabC7Nki5kmnw748tPwGanY1v+yONxydJXYX6FUbprSA0iUNJlyNlk7c4oMEDcMabzeq/TVBaLzVM78f+xDG1Dd7w5bkDtKoSgodLrgwhSmG4/GMZxi1cFeypR7jyE66oEXDUSCc2YSQWf1kMcGb5gEjlAnlCZoyMO13EjSKkEl0AGwbAqHXnj6wcuVEZpSHh7EtIABGj4bz51FbQqMPoclYc8HoEF84PB0e/AvULQPbWkFjY/EoK1Lpiy89w85TTT2FxEQPwsO3i7rEUwDz7VVRm3gOcPHpQ5bkPtKoSgod05hmUJ7awQ4iuMpo3geEp383nUnBipvALY4SmUWulJUGfu4gtE8BttOVT7Q/kaYU4yPkKmz5X/bSTbt3F5qnjiYu9vXrwdMTYmKo3BJazQJnkx2bhAgheuLzJ+hKWcN3zYQ6i9oYpdGa20znMCf+jGTgTDh40IMYVYwQhB4GmCbO3QCmQRZ/PyQvCGlUJYWKFrSgJz0BiCaa2czgT9qjUaSBT9OEENyIAA4TQQyfkdkeqL2VcEg1U3RjluhGMkM1zagwfO8o7Bj+dIeUs7OoN9K5s7EtNFTEo+7bh30F8JgvVPj16LTgsw6Oz4aESBX0rQtfNRdhBwqViWQGh6h+9w5ffgknTgAa2GC7gaX2S4VnX89jxMz0L0BW08l3pFGVFBqssWY2sw3Hs5nNSGpRVZm1BuPGad4kBdgJxPAFmRWfKGsHa3sIQWktKqZqPVmpHmnscG0T7P3i6XJ9bdqILKgyJlJ/u3bBpEloYsN5/ZOMS/3gSyJPP/gS0LAsrH0XGpQ1+YwpfMpphqeeY9XSND6cD4mJwDuAJ8xxnGO8WRKwApFWKrOgCgzSqEoKDZ/yKS8jatuf5zx3OcJsZdaaioZ/6IAWDQeBMNYgKvqYU90Z/uopUk4TKcHo1J/Ya2HiMTr9f2IK+STs7GDGDOjb19gWGSmUTLZuzXypHw7HZgvPvs7RBuY3h37mnqWO3GQah4n0jaHnF6KCKTURS/13MGcXQorv3pOHKnnxSKMqKRRUpzof8REAqaQyna/5lTaG88d5m3Bc8AWu8R86pmW4R53SsKE3ONlAHLb0TV3FeYtm4qROCwenwKU/njyQevWEqvNLJmmhhw/DF19gnRDEu79CrW7GU/raUMe/h8QIxAbu961FiVWFaoQzk4O8mXCPBQtE9ZRUO4TRHASYZFa5J7szLnocI0eazKwlBYq8qFElecF4enqi0+nQaDRP72zCypUruXs3ByU+8hFPPA25/b/xGz0oTQVFci+AClzgNUKBAySj5WPAXJiknB2s7i4Majw29Eo2MagpCWL/9GkGtXt3IRqtN6jx8UJUun9/KlUPYpC3uUENugh/dgLviZCYaAFz2gipK8Wg2pLM1xzlAKuw/PcerVvDL79Cal/gODAUo0ENAj6FVWGreC35tWf7IUpeCHKmKinwtKAF7/IuAMEEc5i/2EB3AFKwYC/tSEHNLiCVeYCP2fUlLWFVdyhnDwlY0yvpDy6XUAxqUgxsHQiBTxCb0WjE0t40M+rSJfjoIzRB/rztKUKl9CRFw5GZ4PMXwkf2ioswprWM1VA7cItZHMQmMpavZsG6daBrhFCJMt0VSAB+BX4R79WT5DyooJPd/6GKCB2bkwiRMB0iSi49TsByRNnpOMCbjCHJIBQc5yL+/iYo922Rg3FLiglq1ExlquF4AXP51uSrcpKmROLECSCcc5AufEqjgl87i/DPREowIHUFl0oougDJcSJk6kkG1dFRiEabGtSNG6FHD1xt/Bmw29ygPjgJq94VYVLogP714J8BBoNqTQo/sJ/l7OD4xlhatIC/vEH3E7Ad89+WXYjfinmkn3hLCjDZNarVEUlwEcCxLPqogB1Ae2AM0BOwBA6BIj9uZAUwArEF3xlhXPcCDXIwdkkWZLdEdWGgN72pQx1AKFCV4z41FIWQR5ThHI0IBs6RgJCwN8/rn/4OtK4KSVgxLO03TlkoHp+UBDFDfXg264fXqgW7d0NLJdUqNVVkSo39jNcHJzJgN5RWhLzSkoUK4MbeEBMI2FnBr51gnpL3ClTnMV78RZNbV+jVEz4bD2G9EUv9XibPvYn4bRsJBD7rT06SX2R3+X8UozzDcKBtJn26IsqFtUIYUhAz0LuIjORPlbb6iOINw4CVStsR4CowQ7nPi2ffPkNt9XwlLAzaZvbjLX7YYMMEJhiOVzKXbxHSeVpU7KMtqajZC+j4lvRKIR80hGENxRbBh7olHNYojq2UBNg6CAJOZf3wjh3hp5+gpCIZFR4Oo0Zhf+c47f+GSiaF8R7fFBorIfp00FfdsFjRmdQKxkSA9/FlSsIBlv6YytKlkNIMUffJVL4hGjEr/QMwr0AtKURk16hmp0pNV+AhRoMKoijlTqAbRqPaFaHm+LdJv1REJfFJCJ2dF1/IwdVVlLiQFBhGMYpyStG6gxzgfZyxUjw353mdENw4DYRxHOPfZ0HbamKWmoIFH7GYfar24kRqopDte5CuZIkelQrGjxd1o/RcuwbDhlGz4X1a/wbWJklTF1bAsW/FbQEsPn4d7aTmpCpOw5Ik8wP7KeV9nY5fwwMV8BvQLt1z1yMK7IXl8IckKXDkpqOqDplLN1xFBIbYAbFKv7uIvdn0/awQWw1Xc/js8/o37u7unDuXdZ2gKVOmoFZn3PW4ExNDmkX+++00MTFUzaE4dOnSIufd3d2dtLQ0Q5upyHT58uUN/+rbHRwcsLS0zFKMWl9R9VnEqitXrsysWbNyfJ0edYSaMl3LQALo1DoafWBNqWXiM0TiwAneIgTwtdGyc0MNypUzLuM1MQ8o/U8/1GmJfM0MvBDpTJZqHfPejaPZwMy1Z3XADEdHdpqUiG6dkICnkxM397/LNXuj4bZJc+XNSE/6dWgKHSANLTOdjrLLxqj4XI9H/JJ2CueokSTWfoeP/vFmmuM0ktTGOUPt5NpMiJpA3RZ1s+VVqFVLSFo96TsuyV9y04o4A/6ZtOu1dJwQRtUZsTebVT/nXBxTtqlq6oiQ5DvWB6xRJ4g/fvGd4rA56Gc4501rkrFkL/DZF9GUK2eem+lwYT7qtEQu0oDVioC1hVrHD2+H06x81oug1XZ2BoOq0ukYHRPD0NhYrtmtNDOoFRPe4Y3IrymhE1NWLTq+dTrCLhtj3ecPdBcZF1eepJjfiddZs8z+N5bZLzOcd0pz4pPoT+iS0AW1jGwsUuSmUVWRudCk6hn75QSDaKWfn5+usWnJChNq1hTKGTdu3HiORxU8QkNFcSE/Pz/S0tJITEwkKioKPz+jIbKxEXnlDx8+NLRHRUWRkpJi1s8U/Qw1q/NPQqvVMmDAgGf+Wf/N3zRX1Pun7BzOj8peajBu3KMKt4AQ7jBrVnNmzTJ+nd59Gdb0EHuuE9K+RacRBiv18Hd8PveXrB/Yti38/rvhUPfppyzevJmTw0R2lJ4jM+DckkMYdrlUYPdrG2K7isp8arTMjPiHde9fp64vYLMWFgJdTJ61FSImRzAzeiYzmZmjn4t+htqoUaMcXSd5fvSFNZ9GbhrVcDKfZTop/0aY9Kv0hH7hmZyT5IDCXqLaGWeaIko3BxLIayZSTD5KzJFQtVuJ6d9nK43YRwVYRz+uahqKg/DbcP63rB/o7i7KReu3hX76CTZvpk4fc4P67xyhxG+Kw6+tiTIxqJ5h/7C083Xu3wfKKUM0rYQ6GxGcKCmy5KZRvUrmUQG1gfuIpb++X3dEgdz4dP2Sgf9ycUzFiqJSoro97bFQvpp72UVvxD5iChZcpxaPgEBiMfd1iiJ9VZ0gAkdmpH1lzEY6OCVrcRRXV1i1yujl370b5szhlc7Qdr6x29lf4dRC80tdlrTicVdRXFCFjsmP9rCk43WCgoCGwO8YY2biESVOMsoRSIoYubmZswOoAIocu6AUYuGzI10/S6C3SZsF8D5Cq/zFe/4LOZmVqF60aBGffPIJ27Ztw93dnYEDB+bzKLNPJ4yz6hjOY6+o+d/kFZIpocxS/8b4d1qkoY5tIt7P0U0gRqMsmm56wb0sBEZLlIAVK6CiEkbt6wtjxvDyOzo6/mKsZnpplahkaorbUg8edxUzYRU6vgjcy5LWfsKgdgc2YzSogYj4F2lQiwU5manqw5P1+5cdEJXCQxFxpjsQcalrgS8Ry/3JiL1SE70yLiF+IxYijOtdYDTwMjDgWT5EcSe3S1TnJ4448jYiCDSYYJpgLC3qQz3igetA+hCqqS3B1lLUpVqN8gckJQEOT8v6YXPmGEtGh4TAkCFUbJBAl2WgEfH6XNsspPpMqbisJQGdjLWnPvbfz7IOV4mKRkRkm/7YzyEismWoVLEhJ0Z1Y7pjfT7gEcADEcvaGRG+vBiRinoSIVqWvhjuUIQGzyxENfLLiEysCzkYT7GnKJaobktbLBEW7Tg76aUk44XjRCAVuAykcQDTQP83K4iifTpgkvZbdPop5pn/U9KbMuHjj6G3slhKTIShQynr9pDuq8BS0Yq+9Y8oTWXqVn15eXPudjQ6iUb8t5+VHXyI0wHLMC9tsgGYiFx7FTNyYlSz450PR/xdHvaUfgnA58pL8owUxRLVpkt/DdfQZzhfpQ5pqLgMiCxnpY8KZrUS7zfRi4tqZeYZ6S82QjOjXTuYPNl4/MUXuCZepMcmsLITTf5HwGs06EyitV75vRk3279hOB7od4A1na6Q6ILIgqqjnNAiAvkzr+IiKeLkf7S75JkpaiWq7bE3qZD6iGZKQIgWFVepw00gjtuYFmEaWB/qlIFo7JmmnWL0Ehz6BtIymSLWrg2LFhk9/QsX4nR5K722go0SfxJwGrYPE/n8eur90RSftk0Mx719DrK+8yVSXkU4pEorJ2IRDql9z/ezkBReZNSxpMDQhjYGzVQftlNG2U+9y8vEYafsDf2Ofj3ubANfviWuXcDnRKiVsia394t6z+kpXdrc0+/lhd1fc+n1N5RUjOKjK0IWINVEFarx2jfxafuW4bjrxcNs7nCRlG7AJowG9T4iCVsa1GKNNKqSAkNnjNXxHLhveO9DPYKAYGIQG5WCic2E6PQNXmG57gPRmJoEhzPZCtF7+isopZ99fLCd+Sl9/tZRSmkKuwGb+0OySb2nt9e/wdlWRvWUNmePsqPrebSTgZ9BCUyA04j91OvP+OElRQa5/JcUCEpSEg88AIgggAY4ABBLSe5QVZmlrkfI9EK9MjDgVaNzSqtWvspnF4v91PTMnQv6LKRHjyjx2RB6/5GAkyh5RaQ/bOoraknpab25Ed5NmxuOW5w4zv7BZ8WWrmlEtl4KyGS7QFJ8kTNVSYGgNa2xRgi43MPLUHL6GrWJQc1NtJiGUc1qBWoV7KArp9WKin90AJxZlPHmn3wCvZSIwIQELD4eSq8FQbiKnAJiHsLGPhCnFF5VqaDz9tfwbmoMuX7j6AmOjj0tAgf1BjUNmIZwt0qDKlGQM1VJgcDo9dfhRhgoBtaXulwGtBxAr9fT0x0aVxDF+77RfmOcGhyeZr4ZCtC+PXxlDDRVT/6CnuMvUVaRQ48PEzPU6ABxrNFA950N2NTAWL60/qGTnPnpJPwDij62KAk9GqGJKpGYII2qJN+xwcZQgyoGP8opBjWACoTizBVAOKiEoP4URSJvIWMJVQs5QPyPwK3d5jeuU0d4+hVUP/3Ie922UVFx4idGCoMariRGW1lBH6/6rK3zruEad+/TXN59Qmzl6iUI/IHBwK1c+PCSIodc/kvynVa0wgYRcf/YJFzKh3rcAOK5hT6MalwTcLOD/6jGEp1SpjktBQ5NNb9p6dLwxx+g10b12kXnGvN4WZmA6stThV4TxzY2MGhvPdbWaW24RdV9Z/H77zgswGhQTyBSXKRBlWSBNKpFjGXLlqHT6Zg/f/7TOxcQjF7/RMor+fxJWHGTV0zCqKC6Mwx/TTinvtbNJE2lWLoLy4zTTRCe/t9/N3r6r1yhddJnvNJRhGKlJsK2IRCk5O/Z28Ow/XVZXtPofargfZ47mqNgKrO7FuiH1FGTPBFpVIsQ1tbW9FZSLwcMGIBGo3nKFfmPNda0RswOE7iElfKVvE4t7mFJKNHoM6Sne4ClBvbQnmMqD3GDmCA4+aP5TefNg9eV3PzgYJpdH0r9HmKvNS0Fdo40VlNxcoKR+2uzuKrRoJY+fJHASodBvwuQBkxF5PVnIXYlkeiRRrUI0b17dxwcHPDy8sLNzY327dvn95CeigcelFSC/BMwlkTxoR4XAB3rgHjaVYN3XoZ4bJiinW68wdGZkBJnPB4zBnr2FO8TEmhwbBhN+ogSJzot/DPGmBdQpgyM3l+LBZXao1OysB1OXSL01YPwinK/KOB/mGbGSiRPRBrVIsTgwYMJDw9nyJAhxMfHM2jQILPzK1eu5O7duxmuO3ToEIcOHTJra9iwIWvWrOHixYvcv3+fyZMnM23atGyrn2cXo9c/BGclLikUV/7Djf/QAn9gbQHTPESvX/iYIPVL4uDBCbi+zXizDh3Mcvqr7/ucd3tfMhzv+xJuKCKUFSrAx3tr8n35DgaDauNzhajXDxil1u8ghCuzUA6USDJDev/1DNwHtgWgRHV8GKzJeYnqcuXK0bp1a3777TfCwsLYtm0bPXr0wNHRkcjIyBzdy8XFhQMHDvD48WMmT57MnTt3GDduHFWqVMnxuJ6EFVa0VYI+k7lg8AX5UI9LqNCyH7jHqEZQ2RH8qcwi3UdC2kebKsSn9dStC/9nlNQve2gB3bptNxwfnAq+68T7qlXhw+01+MqlI1plXmHp70tCvf3G+x0DPgRy9qOTSKRRNWDrCnaFt0T1wIED0Wg0rF69GoBVq1bRv39/3n//fZYuXZqje33++eeULFmSHj168OjRI/z8/Ni7d6+ZZmtu0IIW2GOPqFAu6mClouEK7vgAsIIK9jBGEYb6RjedFJUIt+LiSghTckLLlDHz9Je6tJP+7xgddcd/gIvK8r1WLRi5pToTHDuRphhUdehVUqqYJOz/AXyjDEsiySHSqOqJLyAqws84jkGDBnHz5k1OnToFgLe3N4GBgQwaNCjHRrVJkyacPHmSR48eGdoSExPx8vJi2LCnqTpmH+PS/xZWiKoF/1GdS9iQwk3gGFNbgo0lePMu3iplBh8XCicVo2ltLXL6lRLcJe5dZlC9sagU0ZWzi+H0T6Jr/fowYmNVxtl1JlWptaKK9UNbei+gE0Z0KrAq1z6ipBgijaqeZ1hyFxQaNWpEnTp1+P7773FwcDC0b9myhTFjxlCjRg1u3cp+YGW5cuXw9fXN0G5qZJ8XSyxpRzsA0rhsKCflS10uAKmsoNlL0LUmJFKCr7UzjB6Ao7MgKVq8nz/f4OnXRAQzsPxQSmiEp//SKtEV4M034YM/X+YT2y6k6J+WfAOd3T+ATtSp+BA4nmsfUVJMkY6qIsDgwYMBmDRpEpGRkYbXmDFjAAwOq8TERKysrDJc7+LiYnYcFBREmTJlMvRzc3PL0PasNKMZjjgCUWgQ6vxRlOI4lYkkCo1qMzMV8emlfMgDtaJ88vAcXNsk3n/6KXTvDoAqKYFetkNxsAwGRBd9GRQPDxi1vjJjbLuSrJ9HJ7fw9gAAIABJREFUaG+C1W5AJ0pNdkYaVEmuII1qIcfS0pK+ffty6tQpPDw8MrwuXrxoKPp379493NzczIxo1apVqVmzptk9T506RdOmTc2MqLW1da6WuTYG/BtnxFepwwVUpLKOIQ3iqeUqUlUX6j4THXRaOPA1oIOOHWHSJMO17XRjqVhC1AW4tRv2jBPdOnSA4asqMbpEN5IMC7NboPYCtHAYYVAzBkVIJM+ENKqFnM6dO+Pq6sqvv/7KkSNHMryWLl1K5cqV8fDwYOPGjeh0Ov7880/atm1L//792b59O2Fh5vu4CxYsIC4ujmXLltG+fXu6du3Knj17SEpKMlRsfR4ssKA97QEtOsWo6oCT1OU2WhxL/MF4RRN6Bt+QpFKKRl1eDSE+UK8e/Pyz4X6NE+dTx3onAP6HwesjUQalZ08Y/NtLDLd8j0Sl7hXcBnYBWlgODASin/sjSSQGpFEt5AwePJjo6Gg2bkxfl1Gwbt064uPjGTx4MLdv36ZXr15UqFCBbdu2MWHCBD7//HNu3rxpds3jx4959913iYqKYvbs2SxevBhvb2+2bt1KVFTUc4+5KU1xxhm4h0pJS/WnCocphSX7mdLyPg7WcJTm7KKLuCghHP6dIzz9K1caPP3VknbQ3FoUPQw4Dds/EGVQBg6EAf9XgaGa7iYG9Q6wE1K0ot7vN4hsKYkkF5GOqkLOe++998Tz0dHRlCxpLPO8fft2tm/fbtZn//796S8z2zbw8/NDrVZz4cIFLlx4/oK3Rq+/j6HtEnXxBSo6rqBvXUjGkq90s4zlJo/NBhJh5Z8GT3/p5Et0KjEOFTqCLxvLoIweDe2mlqc/PUgwGFR/YAeEp8EIRJ1fiSQPyK5RrYgottsIqA/YAC+jF7gUvIsoPd0UKA88RFTr8QRC0t0vq7SchsClLM5JXiAzZswgPj6ehw8f4u7uzvDhw6lfvz4dOnR4rvuqUdORjkA8Om6jAhKwZgfV0HCDnzocR62CFXzAHVUNcVHwZRG5/8siaNgQANvUILpbDcOSBMJuwJYBogzKl19C83Hl6EdP4g3pBPeA7XAzTUj23XuujyCRPJHsGtXqQB/gPCLXJLP4o1GAHTALsc6qAUwH2gGvgrLOM/IHkD6A8iaSAoFOp2P06NGUKVMGrVbLlStX6NatG3v27Hmu+77Jm7jiCpxDpcSmXqM2Z7HAvdwKXi8PwbgxT/e5cZZ64Cv47FNQZuUabQLdLYZiTzARd2HT+2J3wNMT3viwLH3pSZzBoN4HtoF3KnyMEJeWSPKQ7BrVo4DeFTyczI3qR0CoyfERhJE8gjDIv6frHwicyvZIJS8UT09P1q9fD4jlf24hvP46TJf+e6lHHJEs6rgZgJlMJUFlJ076rIPXy8OECYb+HdRjKcsVYh4qBjVMlKCqN6AMfehJjKEaXwCwDZakij/1z+9jk0ieSnaNana+jqGZtOllhypk8zmSIowKlbL0D0IvSvqQcnjhyhsVf6WyYwKneJOt9BAXJEbC462wwZji1JR51GQncaGw8X2IDxYp/zW6l6YnvYhRqgZAICRvgUkpojCfRPKCyGtHlb5yWmZTndEIH2waYsbqidhaeBbO69+4u7tz7ty5LDtOmTIFtVoGPWQHa2thoNzd3XN8beXKlZk1a5ZZm9UlK1yHuyK22gVnqMs9tKzrsBodMBXjNeOawbqJfxFsIb6mNdlOUxZgqbWnp24pw/9+BQeHH0gsuYsW9CJGqR4AD3FIO8C86MU0HN8Qxud4+AWWWrVEtcInfccl+UteWhd7YCHCoG5Ld24tYrugNTASUU7tICg1iiVFEksfvSdeVNlLQ81f1KR5zWtUKnWPW9TgKnUAqOqQgktdrcGguuku045xWGpt8Hj8M06pr6DR3MPWdjP/xxtEoJRNIYgqKRdYHbachskNX/AnlEjybqZqAaxDLPubkVHvZ6DJ+2PAdkRqzSzg7Wd43uv6N35+frrGjRtn2kmfOXTjxo1neETxQz9DfZY9Va1Wy4ABA8x+1gtYQF96otfTC8eZm5SglYUI8dpPG0PfOzt/YEqlN6Ct2L5vppqDJYmcWAw/fDcUEDX93uhhz0qU0qikQuxO/JvG0O1xtxyPuTCgn6E2atQon0dS/MiulnBezFTVCJ2f1sB7oBTDfDIxgBeQuTWUFAmqUx2xlyq+nCG4Egp0qCG+InvSjFVMeXwW3hFV+qzTQqnMUUD4rQBq1hTBAAtoSophbnAJfomBx3n/WSSSrMgLo7oEeB/oCxzIwXUqso5flRQBXuEVTC2eP67ogEblfYjAkYtq5W9q1H1oUQcsxXZBbc021KRx/1+IVHL0x4+H22pnNijbBZAMoWfgtxf2cSSSTMltozofEXI1lIz7qE+iFNAJOJ3L45EUEMpSllKUAow6A9dwoXSJezjZRHIYD7QqZcZ554CxzhRQG6FK5fOXOK5XDzp1gh9oZlDuh3MwLwESXsCHkUieQE6Mai/lpd+/7KAc6z38E4HPgZWIquhNTF7VTO4zHlgG9Ec4pgYD/wJlAZP6GJLs0q1bN44cOcKjR4+Ij4/H39+frVu30q5du/wemoFXDJX0jEb1PK7UKiOW/gcwWfrH+xo0Up10tyiDDwkRQn0KRNbURcqy23DPeLhzTuziSyT5TE4cVekVOxYr/x5BGEd9/uIw5WXKKmCI8v4G0F15OSA0gv4FPgDO5GA8EmDMmDH8/PPPrFixgrlz5xIXF0e1atXo1KkTrVq1Yu/evfk9RABqoKScKkY1GUsu4sBHlXxIQ4239h3xJz4lHppVMlxXR7UJFeC3GdKShK1t3Rp6mfkzT8HsFFn+RFIgyIlRVT3lvEc277NTeUlygfHjx7N161aGDx9uaDt06BDLly9HpXraf9mLQ8xUk9DniYbgQgwq6pf14TyvE61WSpjeOwYTjZ57d7YAxqX/hAlwlEqcoLLSIxouXhFuTomkACCj4As5zs7OBAcHZ3oufQhIlSpVWLt2LSEhISQmJnLx4sUMKleenp7odDrq1q3LypUrOX/+PA8fPmT69OnPZaSFUTUu/f0RlWtfdbuCN62NHdNugVK1tSInKUUgD8+LGn9vvQVvN4dZNDe5878wU+r3SQoOUvrPwD6gAJSoJozMpRUy58yZMwwePJg7d+6wffv2LGtRVaxYkdOnTxMSEsK4ceMIDQ3l/fffZ/Pmzbz33nvs3Gm+eNi2bRu7du1i2bJluLu7880336DVapk+ffozfSphVO8bjq/jSrmSD3C2iTDfT21irDbgjtAC0JeWnjABvKiBL/qqt2Hg7ScVJCQFCmlUDbgCha9E9ahRo9i0aRNz585l7ty5hIWFsX//flauXGmmkzpt2jRUKhUtW7YkPFzk3e/bt4+XXnqJGTNmZDCqy5YtY8eOHQCsWLGCUqVK8cUXX7Bw4cIcC1W74ooTToBRi/UiLjQsf4UAKuBHbdEY4gvDxKxVo0vkFdUukmPh+jZo2RJee0NFC9O9VO2/MFtG4UkKFnL5byAMCC4Ar5yVqL516xYNGzakRYsWzJo1i0uXLtG9e3f27dvH119/bejXvn17du/eTVRUFBqNxvDau3cvDRo0wN7e3uy+GzZsMDtev3499vb21K1bN0fjA1PPvzFG9RSledXtivksVXUXnJwAqKbajzXRXN8mfFcTJ8Lf1MUfZe+Vh7Dpv8xVJSSSfETOVA0U3hLVWq2WY8eOceyY0KMpV64ce/bswdPTk19++YXIyEjKlCnD4MGDDZVX0+Pi4kJMjFFs9NGjR1SuXNnsGKBChZwLjgmjqkMvZBaHNUHY8qrbFVbwgbHj606Gt6YOqnbtoGYDCwbT1Ng3+RjMzfFQJJI8RxrVIkhQUBDLly/n559/pkaNGpw9e5bHjx9z7Ngxfvjhh0yvefjwodlx+nLU+uPAwMAcj0cY1XggEYD7uAIqqpe5xXFdMxFXkvAYuoiMKmvCeZmDhFyFR5fhy/2wivqEop9N34XfAyDnQ5FI8hxpVAs5FStWJCAgIEO7XiJOHxmwZ88emjZtytWrV0lMTHzqffv06WPYUwXo27cvMTEx+Pr6PuGqzBExqsZtjRu4UsE+AD/b2iTp5fp0d8BaGNWa7EBDCr7roHNnqFjbih9503jD2OPwfzkehkTyQpBGtZDj6+vLoUOH2Lp1K3fv3qVUqVJ07NiRUaNG8ffff/PgwQMAvvnmG86cOcPRo0dZtGgR/v7+ODk5UbduXapWrcoHH3xgdt8RI0ZQtmxZfHx8GDZsGCNGjMDT0/OZqqmm9/xfxpV6bj7moVQNHQxva7OZ1ES4sQ1+2gZLaGSilXoDfg6BiBwPQyJ5IUijWsiZOHEiHTt2ZMaMGbi5uZGWlsbNmzeZNGkSCxcuNPR78OABjRo1Ytq0aXz33XeULl2ax48f4+vry6pVqzLct1u3bqxYsYJRo0YRGRnJzJkzmTlzZo7H54QTpSmNqef/Aq54uO1hrV4BUpsKbYQzy5G7lOM8fl7QsRU4VLflV/Qyd1oI+RdW5HgYEskLQxrVQs7SpUtZujR9/cTMCQwMZMSIEdnqe/36dYYOFbqlz1OjypieavT838CF99wiCaK80hIAJaoAwkGlAq6th3VzYSFNSDKUmfaBORFSNEVSoJEhVZI8RRhVHfo91TDsiMaaYDeTmOB6JQ1v3dlC+G1oVhnUVUqxmleVMylw5xT8/cKGLpE8E9KoSvIUsZ8aDaQAcAtXytk95IRtM2OnN0oDUI5zOHEXv43w+ecwh7dIQ6N0ugizYkVFM4mkACONqsQMfY5/WlruWK/0Of9XcKWWmx8XeE00qKPQx/O7s4W0FKijg6jyrmzVZ1qRCBfPwp5cGZJEkqdIoyrJU9Ib1au4YuOWgE7/1atpBYCaFGqyA/8DMOYD+Ja30RmE0c7C9KeHgUkkBQFpVCV5hi22lKMc6WNUH7u5GDvVEaFSVTiELeFUCAf/MuU5aNA1j4MDF6TSrqTQIL3/kjyjEnqxaWFU01BxC2cs3JSYU1UKVFTqULGJmIfwcXsYairtpz0JM6X6tKTwIGeqkjyjMpURniWhivUAR2ztooktWUp0eFkNGrAimmrsp+Qd8HGuwgUqKneIhI0+cDM/Ri+RPBvSqEryDDFTjQS0AFzDFfsyRtEWagjP/ivsQqNNou+rMN10lpr8L8zVvrgBSyS5gDSqkjzjZapjup96HRdi3OxNOwBi6a+6B+dK1eIWZZSTIbDsOpjrvEgkBR65pyrJMypTBVFYV3AdV8L1Tio3HZRUYU8AFTmNR1k1IzGJXY09Dote6HAlklxBzlSLEG3atGH37t2EhYWRkJDAjRs3+P7773F0dMzRferXr4+npycODg5P75wFKlSUxgnzmaor6BUFq4lwKXe2oIrXccWmHkHoxxkAP96FnGu3SCT5TnaNakWE2NpJhDCmDqiSrk8VpT2zV/rfamuExHAQIpP7JNAip4OXGJk8eTL79u0jMTGR4cOH065dO5YsWcKQIUM4e/YsFStWfPpNFBo0aMC0adOey6haYaW805ek1hBoawt2SnNV8U9tNlPb0oK5NDFeHHYcVj7zoyWSfCW7y//qQB/gPHCMJ8vkzwZ2pGuLSXe8AugEfAncAT4G9gJNgUvZHJNEwcPDg1mzZvHjjz/y+eefG9qPHj3K1q1bOX/+PKtXr6ZVq1YvbEzCqKYgHFVwC2cSyyqGtiRQBspwBRduccXyDSIN1vY2fBuo17OWSAod2Z2pHkUs3DoCG5/S9w6ivqXpyzTnsT7QHxgHLAMOIAz2fWBGdgcuMTJhwgTCw8OZPHlyhnP+/v58//33vPPOO7zxxhsAaDQaJkyYwNWrV0lISCAkJIR//vmHmjVrMnjwYP744w9ACFtfu3YNnU5nVlolO1hjg8j5F1zHFZ2bksf/MqASs1RHbQl+o7HSSwd3jz/9GyaRFGCyO1PNzbiWrogpjKneUCqwHpgElACScvF52WIg+7AtACWq4wljTQ7qZWk0Glq2bMn27dtJSsr8x7Zjxw7mzJlDq1atOHPmDOvXr+e9995j4cKFeHt7Y21tTYsWLShXrhxeXl7MnDmTqVOnMnbsWIKDg/H39ycoKChHn6ME1pgqSd/ABYNjvyqoSKMW27iifoMErJUTfuAZlrvfNonkBZMX3v/ZwBIgDjgCfA34mJyvA9xF7M2achWwQmw1XM3hM8/r37i7u3Pu3LksO06ZMgW1OuMEvdStslin5r9RtbCwwL2Ge7b7u7i4YGtrS2xsLO7umV9nZSWW3a+++ipDhgyhV69efPfdd6xdu9bQ5+ZNEWFfunRpEhKEYOndu3d58OABiYmJVKtWLeONn0AJXQnQRRqO/Sgt1joaoDJU5ijWuli2qRoqPdKonRTJqu/PojLk/EvSoy+T86TvuCR/yU2jmgQsBfYhymbWAr4CTgBvYCwm7EzmxTDCTc6/cJI0BaM+R07HoVLlzAC99dZbaLVaNm7MwzW2DtQ6MN1K/6+Es3BSlQesRB2qRFVlUgwC1L6MixkmDaqk0JObRjUIGGVyfAwh1nYVMVv9n9KuQkQEpOd5fpte17/x8/PTNW7cONNONWvWBODGjRsZzvnR8jken4ukkqNa9hqNhvj4eOzs7LJU6Nd/7itXrlC1alXCw8O5dClrf6B+7zUpKYnExMQcK/9bYEG1mtUQixWR8//QyV78Dyt/MstyiQeYRCTE3GZE/RGZfzMkBvQz1EaNGj2lpyS30emy9+XM6zjVB8BxwNTKhZP5bNTJ5Lwkm6SlpXH06FHatGlDiRIlMu3TtWtXAA4ePEhYWBjOzs5YW1tn2jc3MIZTxQLwiJKkOCpOKmdQk4wTt7lsMKo6OPNQGlRJkeBFBP+nn5leRfh/bdP1qw0kA/+9gDEVKebOnYurqyvfffddhnNVqlRh4sSJHDlyhDNnzrBv3z7UajXDhw/P8n56h1dWRvppWGGN+C8Xav8BlAJ9yKsTuHCLFJ0lAQbHYCj8+8J9kxJJnpDXaaqVgGbAVpO2HcB0oDegL+NpAbyP2I+Vv1055ODBg0ydOpWZM2dSpUoVVq9eTUREBK+99hqTJk0iKiqKgQNF5dLDhw+zadMmFixYwEsvvcTBgwextLSkRYsWeHl5ceTIEa5duwZA//792bZtG7a2tly5coWUlJRsjceKEpi68NMb1dJcJUpVweSKABF4J5EUAXJiVHsp/+r3LzsgHFKhCC//fMTM96TSVhOYjPjtMp1CXUKEUy0ELBGRAKMRs9cBz/IhJDBr1izOnj3LuHHjWLlyJba2tty/f5/Vq1cze/ZsIiKMDrC+ffsyceJEBg8ezNixY4mKiuLs2bMsX74cEHuvnp6efPTRR/Tq1QuNRkOVKlW4d+9etsYijKoxNDmAUiKnTg2UgtL48QgTo5oUAL658EOQSAoAOTGq6d3Fi5V/jwAeiGX9aGAIYI/ITzyImJWm9wwNBb4FZiF+3S4D7TEtDi/JMXv37mXv3r1P7ZeWlsZ3332X6XaBnhkzZhgiBHLqqLLCkkxnqophdcWPs7xkvOBCoHDQSSRFgJwY1ad5539XXtkhAfhceUmKGBZYYDZTVZUS4VSKK9KRWzwwLHjC4Vj6kGWJpPAiVaokuY4FGsxmqvalxDfNCWwJIRIrY+E/AuB0foxSIskbpFGV5Doa1Jga1UBHpXyKk34/1SQ+NTUALr7Y8UkkeYk0qpJcxRJLZZ9IGNXH2JDgpGRNOYv9VLOg/6sBUpFKUqSQRlWSq1hiiYhRFUY1Y4yqHw8oqzREw9H0qpASSeFGGlVJrpJlOJUVSrpHKFqDf1Tup0qKHtKoSnIVIfmXLpyqFOAEalUKMZgkEGgD4OwLH6JEkqdIoyrJVSyxItOZqhM48x+BhqU/8F9gxpoQEkkhRxpVSa5ilc6oBlraC9lxJ3DlGg8pr5yJh6NSO0dS9JBGVZKrZAj8tzeGU1nzgFSDgpXM95cUTaRRLQIMHjwYnU5HREREhnLUGo0GnU6Hp6fnCxmLCPw3MapOilF1hjQzbfIAOPNChiSRvFCkUS1CODo6MnHixHwdg4VJ4H88FkQ6K7qtThBpKkB2P1BfvVoiKVJIo1qE2Lt3L2PGjMHNzS1fnm9pKI0iZqqPKAmOKigJNlaPCTaUoU6C46H5MkaJJK+RRrUIMWvWLAC+/vrrJ/Zr3Lgx+/fvJyYmhtjYWLy9vTEtQfPll1+SlJSEg4NDhmuvXr3K1q1bM7SD3qgal/4hlBSB/07gwC1SsFHOBMJJKfMvKZrktUh1oWEf+3AtACWqwwijbQ5KVJsSFBTEokWLGDt2LPPmzeP+/fsZ+tSrV88gRD1kyBB0Oh2TJk3iyJEjNGnShCtXrrB27Vpmz55Nhw4dWL9+veHa1157jdq1azN16tRMn58+8P8RdoZwKktMS1wHyqB/SZFFGlUFV1wpaxpDWUj54Ycf+PDDD/H09OSDDz7IcP6bb74hKSmJd999l6ioKAD279+Pv78/np6e9OzZk6CgIA4ePEjXrl3NjOrAgQMJDw9n165dmT7bKl3gfwglhbKuEyRjLFdNaAAE5MrHlUgKHNKoKoQVEK/J844jIiKC+fPn4+npyQ8//MDt27fNzrdo0YJdu3YZDCpATEwMO3bsoEuXLoa2NWvWsHr1aipXroyfnx8ajYa+ffuyYcMGkpOTM312+hjVkBIlDZJ/keivSYFjwc/1GSWSgow0qgrPuuQuiPz444+MGTOGGTNmMGCAeYUaZ2dngoKCMlwTHByMk5OT4Xjz5s0sWbKELl26sGfPHtq2bUvZsmVZs2ZNls8VRtWYhvqopOKYck4jiQSlNQhOaTNcK5EUFaSjqggSFxfH7Nmz6d27Nw0aNDA7Fx4eTtmyGbc5ypYtS3i4McMpPj4eb29vOnfuDMD//vc/bt++zYkTJ7J8bvrA/0elSoIKbB0CTNoDZdC/pEgjjWoRZfHixQQGBhoiAvQcOXKETp06YWdnZ2izs7OjS5cuHDlyxKzvjh07qFSpEm3btqVbt25PnKUCWJoE/uuAcAcbcAALjclyPypAFiGXFGmkUS2iJCcnM2PGDNq3b2/WPnPmTGxsbDhw4AA9evSge/fueHt7Y2try4wZM8z6njx5kkePHrFixQpKlizJ2rVrn/hMU8X/VDRQSgVOkEi00iMNTj3MrY8okRRIpFEtwqxcuZKbN2+atfn4+ODh4UF0dDSrVq1izZo1xMbG0rJlS65cuWLWV6fT4eXlRcWKFTlx4kQGp5cploYKqiL+NAW1odhfskGK6hGckGVTJUWb7DqqKgITgUZAfcAGeBnwN+nzBzA4i+tvALVMjrOK/G4IXMrmmCQKq1atYtWqVRna09LSqFmzZob2M2fO0KZNm2zde968eZmGZqUnfeC/qVE15qPK/VRJ0Se7RrU60Ac4DxyDTF3lM4El6dqqAOuAHZn0/wNYmq7tZib9JIWA9IH/qaihBKidEtDqZ6oJAXAtf8YnkbwosmtUjwL6hPLhZG5UbysvU/TToYzTKAhEzluKDMKoGkOlUlQaUAFOIUqLDs4FmtpdiaRIkt091WcNLByEmN1efcbrJYWEDDNVjRo0oLV/rLSEwvGkTK+VSIoSeRn83wyxbfBpFudHA18ifhNPAZ6IrYVn4bz+jbu7O+fOncuy45QpU1CrpX8uO1hbC9k+d3f3p/ZV3bWARGOWVqpGLWpTqYz7qctGLKPh4IZ5MNLiQ61awjXxpO+4JH/JS+syCJFesy6Tc2uBj4DWwEjABTgIeOTheCR5iCoVzBxVasVRhTJT1QVRO7l2PoxMInmx5NVMtQTCsbWLzKWIB5q8PwZsB3yBWcDbz/C81/Vv/Pz8dKYydqboPeE3btx4hkcUP/QzVD8/v6f3pQ4aZZcoDRVohI6qobJfaATNGjXLo5EWH/Qz1EaNGuXzSIofOl325CrzaqbaDSH6lpmDKjNiAC8gc2soKfBkCPxXA7ZaIE50uB+V1aUSSZEir4zqYMQMdXcOrlGRdfyqpACjQoXa5L8uBbX4ZtkkIQxtMtxNyOpyiaRIkRdG1Q0RcvUXppJFT6YU0AkpXVwoEUIqxgCRVNTiT2TJRKUlSuqnSooNOdlT7aX8q9+/7ACEKi9TJY4Byn2zWvqPB2oCh4CHQGWlraxyraSQkd6opqDGRgXYKkt/oiBjEQKJpEiSk5nqRuU1SjlerBxPT9dvMMLpdCGL+9wAagM/A/uBBcBdhIPqWUOqijX6EtX6V2xsLHfv3mXLli307t0blUqVp8835v0LUlXK18omVmmJggd5OgSJpMCQk5lqdn8z6z/l/E7lJcllevXqRUBAACVKlKBSpUp06tSJdevWMXLkSLp06UJiYuLTb/IMWKbLpkpVK3uqFiYzVWlUJcUEqfxfhLh06ZKZktTatWvZuHEjGzduZM6cOXz6aVZ5GM+HJVaYLf/Vyp4q8aIhLQoyFhuQSIokMrWoiLNlyxa2b9/OiBEjsLERJaJtbGz4/vvvuXPnDklJSdy5c4evvvoqwzaBk5MTU6dO5f79+yQmJnL//n1Wr16NlZWVWb/0ClWpGg1owBBOFRIJUvFPUkyQM1WFfQzEFdv8HgZhxNOWJyvs55Tdu3fTvXt3GjVqxIkTJ9i7dy+1a9dm5syZ+Pj40KRJE6ZOnYqzszPjx48HwNHRkb/++gsHBwemT5/OlStXKFOmDN26dcPKysqs+J9wVBnz+lM1yvJfP1O9F41EUlyQRlXBFVvKYvf0joWQ+/eF671cuXL069eP5s2b06JFC44dE37BgwcPAhgqsIaGhjJu3DgqVqxInz592LJli+FepiWr9QijaoxDNRrVBCAW7slpqqT4II2qQph+VpXP5MU49Mt6nU5H+/bt8ff358SJE2g0GkOfffv28e2339KkSRN27txJ27Zt8fX1zVaKqgYNxmwqoU4JLYsqAAAHqklEQVSFWqe0SSeVpHghjapCbi+5CxIvvfQSAEFBQZQpU4YqVaqQmpr57NHFxcXw7507d7J1fw0qzIyqGlDrHVfSqEqKF9KoFgM6depEQkIC58+f5/Hjx9y5c4c+ffpk2tff3x+AsLAw3NzcMu2THo3Je2lUJcUdaVSLON27d6dr16789NNPJCQksGfPHnr27ElsbOwT1br27dvHlClTqFmz5hO3ADLLppJGVVKckUa1CNGgQQNcXV2xsrKiUqVKdO7cmd69e7N//34mT54MwJ9//snQoUM5cOAA8+fP5/Lly1hZWVGtWjW6du3Ke++9R0JCAj/++CNDhgxhxYoVVKpUCR8fH1xdXenWrRujRo0iNlZkS2XI+1cpMaoqJcQqNRKCX/APQiLJR6RRLUJs2rQJgISEBEJCQrhw4QJ9+/Y1tAOkpqbSrl07Jk2axMiRI3n55ZeJi4vj9u3beHl5GUKloqKiGDBgAJ9++imTJk3CxcWFR48ecfDgQbNwqvSB/6kqxVGlb3sULetSSYoVquwKrxYWzp07J0Wqc4nsiFQ7U5qKlALEzPW+hQOR5aypWd8RfmnFjdPToU/R+o7lJ1KkOv/Q6XTngaf+4GVGleS5yCCmojadqcZBgDSokuKFNKqS5yKDUTUE/muBWCn5Jyl2SKMqeS4s0hnVFI0aNDpEEYdY6fmXFDukUZU8F6befx2QZqFWwqlUSKMqKY4UK6MaFxeHnV3RzO/PL0wL/qXpY1Q1adi5OBCrCpFGVVLsKFZGNTg4GHd3d7Ocd8nzYWFWRVUYVY0luHs04pH2LjzK3/FJJC+aYhWnmpqaipeXF/369cPPz88QwC7JnMqVKwOg1Wqz7FOFl1BhD0A8VthXq4J77/p4tQolNeix6XarRFIsKFZGFSAiIoL169fj5uYmtwKewqxZswAYMCDzeoy22LKYb9FXIt+rqcr0d9/mctsDpKr+g3tJmV4nkRRlip1RBTFjDQwMzO9hFBqySpaoSjUsSQAiAPC3UROosQBVDLKCqqS4Uqz2VCW5S3mqYCiZAoTYlETofCtGVTqpJMWQ7BjVXsBm4B5Cyv0GMBuUjTQjTsByIAzxm+bN/7d3N6FxlHEcx78JRmO6NmkgSkkbbekhUXyBgohIU4yiiKaKr/RQUBSs4EWsogfRgie9eehBRAQFPanRiy+oQaFCURHNRYRWLB66JRopCo1UD8+smW4m7szu052p+/1AmcnMs9NpJ/wzeZ6Z5weXZxxvEHiBEAX3J3AQ2NHGuatk42yF1KTax4eGku8Ki6p6V56i+jhhSoyngZuBA8Be4KPU5/uAuWT/o8CdwADwKbCp6XivAA8BzwC3EorrB8BVHfw7VIKNTHDanWptHdSWgWVgCY6WdWZSefL0qd4G1FNfzwOLwGvATuATYBa4DrieUEgh3IEeBp4AGtnIVwK7gQeAV1PHWwD2J8fRWeIiNpK+U60Pr4NaI6vKPlX1pjx3qvWMbYeS5XiynAV+YaWgAiwB7wG7UttmCbcxb6W2/QW8CdwEnJfjfFQRY1xI+k61PjIEFySPqZ1cgmPlnJdUpnZH/6eTZWNOuMuA7zPaLQB7CMMXJ5J2h2FVut0CcC6wLVkv6qvGytTU1L/To6kzk5OTAGv+f/bdMQY/h8u+TD+/jQxC7Xfgbzb3D/P2oY+7dao9o9U1UfnamU91HPgG+Ba4Mdn2A/A1cF9T2weBl4EJwrDFh8B64JqmdjcQ+mh3AJ8XPSFSRTX5u35q4xhabSpZto5UVbd4TcpzMTDWqlHRO9Ua8C7hV/b7U9v7CPNpNOvL+DpPu6K2d/h5ZWv8sHJG5OrwmlRckedUBwkj/FsJ/Z/psd1FYDTjMxuS5a852y0WOB9Jqpy8RXWA8Kzq1cAtwHdN+xcI/aXNLiWMAZ9ItdsCDGW0Own8mPN8JKmS8hTVfuANYIYwkv9lRps5Ql/rdGrbesLjWHNN7QaAu1PbzgHuJfS3+rJ4tWzHrpWq8ZpUXJ6BqgPAw8DzwPtN+44mf/qBL4DNwD7Cr/tPAVcQnk1Nv1vTeHxqH+FJgL2ElwCuJQx2SdJZK09RPUIY9cryHPBssj4KvAjcTuh/PQg8RnhKIO18QoHeDYwk+58EPity4pJURf+7iGpJKpOzVElSRBZVSYrIoipJEVlUJSkii6okRWRRlaSILKqSFJFFVZIisqj2tk3AS4S33/4gTMt4SUa7vKGO6lzsoE11mUW1t20D7iHM1bDW5OBFQh3VudhBm+oyX1Ptbf3AqWS9kdKwhTDfQ8Mu4B1OD3UcJkyG8zoroY6KY4zVuXB7CEGbM4SgTa9JhXmn2ttOtW6SO9RRccQM2lQJLKpq5b9CHScIETs6s4oEbXpNSmZRVSujrMThpDWibzZk7FM848B+wkBUI0LVa1JhFlW1cqbCGtVap0GbKkHRNFX1nryhjoorHbQ5TXtBmyqBd6pqJW+oo+KJFbSpElhU1UreUEfFETNoUyXwOVXdlSxnCAGPjxAe66kD8xQLdVTnYgdtqsssqlrrG2Ae2Jms5w11VOeOEDdoU11mUZWkiOxTlaSILKqSFJFFVZIisqhKUkQWVUmKyKIqSRFZVCUpIouqJEX0D5+EgzwcyaeUAAAAAElFTkSuQmCC\n",
- "text/plain": [
- ""
- ]
- },
- "metadata": {
- "needs_background": "dark"
- },
- "output_type": "display_data"
- }
- ],
+ "execution_count": null,
+ "metadata": {
+ "scrolled": false
+ },
+ "outputs": [],
"source": [
"import warnings\n",
"import iris\n",
@@ -273,7 +158,7 @@
],
"metadata": {
"kernelspec": {
- "display_name": "Python 3",
+ "display_name": "Python 3 (ipykernel)",
"language": "python",
"name": "python3"
},
@@ -287,7 +172,7 @@
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
- "version": "3.8.1"
+ "version": "3.11.0"
}
},
"nbformat": 4,
diff --git a/oceans/RPSstuff.py b/oceans/RPSstuff.py
index 34c60f7..46bd8ff 100644
--- a/oceans/RPSstuff.py
+++ b/oceans/RPSstuff.py
@@ -29,7 +29,7 @@ def hms2h(h, m=None, s=None):
Examples
--------
- >>> hms2h(12., 30., 36.)
+ >>> hms2h(12.0, 30.0, 36.0)
12.51
>>> # Or,
>>> hms2h(123036)
@@ -297,7 +297,7 @@ def rms(u):
m, n = u.shape
else:
m = u.size
- return np.sqrt(np.sum(u ** 2) / m)
+ return np.sqrt(np.sum(u**2) / m)
def z0toCn(z0, H):
diff --git a/oceans/__init__.py b/oceans/__init__.py
index 0377b35..cc5c453 100644
--- a/oceans/__init__.py
+++ b/oceans/__init__.py
@@ -1,4 +1,4 @@
-from ._version import get_versions # noqa
-
-__version__ = get_versions()["version"]
-del get_versions
+try:
+ from ._version import __version__
+except ImportError:
+ __version__ = "unknown"
diff --git a/oceans/_version.py b/oceans/_version.py
deleted file mode 100644
index c8e487c..0000000
--- a/oceans/_version.py
+++ /dev/null
@@ -1,556 +0,0 @@
-# This file helps to compute a version number in source trees obtained from
-# git-archive tarball (such as those provided by githubs download-from-tag
-# feature). Distribution tarballs (built by setup.py sdist) and build
-# directories (produced by setup.py build) will contain a much shorter file
-# that just contains the computed version number.
-
-# This file is released into the public domain. Generated by
-# versioneer-0.18 (https://github.com/warner/python-versioneer)
-
-"""Git implementation of _version.py."""
-
-import errno
-import os
-import re
-import subprocess
-import sys
-
-
-def get_keywords():
- """Get the keywords needed to look up the version information."""
- # these strings will be replaced by git during git-archive.
- # setup.py/versioneer.py will grep for the variable names, so they must
- # each be defined on a line of their own. _version.py will just call
- # get_keywords().
- git_refnames = "$Format:%d$"
- git_full = "$Format:%H$"
- git_date = "$Format:%ci$"
- keywords = {"refnames": git_refnames, "full": git_full, "date": git_date}
- return keywords
-
-
-class VersioneerConfig:
- """Container for Versioneer configuration parameters."""
-
-
-def get_config():
- """Create, populate and return the VersioneerConfig() object."""
- # these strings are filled in when 'setup.py versioneer' creates
- # _version.py
- cfg = VersioneerConfig()
- cfg.VCS = "git"
- cfg.style = "pep440"
- cfg.tag_prefix = "v"
- cfg.parentdir_prefix = ""
- cfg.versionfile_source = "oceans/_version.py"
- cfg.verbose = False
- return cfg
-
-
-class NotThisMethod(Exception):
- """Exception raised if a method is not valid for the current scenario."""
-
-
-LONG_VERSION_PY = {}
-HANDLERS = {}
-
-
-def register_vcs_handler(vcs, method): # decorator
- """Decorator to mark a method as the handler for a particular VCS."""
-
- def decorate(f):
- """Store f in HANDLERS[vcs][method]."""
- if vcs not in HANDLERS:
- HANDLERS[vcs] = {}
- HANDLERS[vcs][method] = f
- return f
-
- return decorate
-
-
-def run_command(commands, args, cwd=None, verbose=False, hide_stderr=False, env=None):
- """Call the given command(s)."""
- assert isinstance(commands, list)
- p = None
- for c in commands:
- try:
- dispcmd = str([c] + args)
- # remember shell=False, so use git.cmd on windows, not just git
- p = subprocess.Popen(
- [c] + args,
- cwd=cwd,
- env=env,
- stdout=subprocess.PIPE,
- stderr=(subprocess.PIPE if hide_stderr else None),
- )
- break
- except OSError:
- e = sys.exc_info()[1]
- if e.errno == errno.ENOENT:
- continue
- if verbose:
- print("unable to run %s" % dispcmd)
- print(e)
- return None, None
- else:
- if verbose:
- print(f"unable to find command, tried {commands}")
- return None, None
- stdout = p.communicate()[0].strip()
- if sys.version_info[0] >= 3:
- stdout = stdout.decode()
- if p.returncode != 0:
- if verbose:
- print("unable to run %s (error)" % dispcmd)
- print("stdout was %s" % stdout)
- return None, p.returncode
- return stdout, p.returncode
-
-
-def versions_from_parentdir(parentdir_prefix, root, verbose):
- """Try to determine the version from the parent directory name.
-
- Source tarballs conventionally unpack into a directory that includes both
- the project name and a version string. We will also support searching up
- two directory levels for an appropriately named parent directory
- """
- rootdirs = []
-
- for i in range(3):
- dirname = os.path.basename(root)
- if dirname.startswith(parentdir_prefix):
- return {
- "version": dirname[len(parentdir_prefix) :],
- "full-revisionid": None,
- "dirty": False,
- "error": None,
- "date": None,
- }
- else:
- rootdirs.append(root)
- root = os.path.dirname(root) # up a level
-
- if verbose:
- print(
- "Tried directories %s but none started with prefix %s"
- % (str(rootdirs), parentdir_prefix),
- )
- raise NotThisMethod("rootdir doesn't start with parentdir_prefix")
-
-
-@register_vcs_handler("git", "get_keywords")
-def git_get_keywords(versionfile_abs):
- """Extract version information from the given file."""
- # the code embedded in _version.py can just fetch the value of these
- # keywords. When used from setup.py, we don't want to import _version.py,
- # so we do it with a regexp instead. This function is not used from
- # _version.py.
- keywords = {}
- try:
- f = open(versionfile_abs)
- for line in f.readlines():
- if line.strip().startswith("git_refnames ="):
- mo = re.search(r'=\s*"(.*)"', line)
- if mo:
- keywords["refnames"] = mo.group(1)
- if line.strip().startswith("git_full ="):
- mo = re.search(r'=\s*"(.*)"', line)
- if mo:
- keywords["full"] = mo.group(1)
- if line.strip().startswith("git_date ="):
- mo = re.search(r'=\s*"(.*)"', line)
- if mo:
- keywords["date"] = mo.group(1)
- f.close()
- except OSError:
- pass
- return keywords
-
-
-@register_vcs_handler("git", "keywords")
-def git_versions_from_keywords(keywords, tag_prefix, verbose):
- """Get version information from git keywords."""
- if not keywords:
- raise NotThisMethod("no keywords at all, weird")
- date = keywords.get("date")
- if date is not None:
- # git-2.2.0 added "%cI", which expands to an ISO-8601 -compliant
- # datestamp. However we prefer "%ci" (which expands to an "ISO-8601
- # -like" string, which we must then edit to make compliant), because
- # it's been around since git-1.5.3, and it's too difficult to
- # discover which version we're using, or to work around using an
- # older one.
- date = date.strip().replace(" ", "T", 1).replace(" ", "", 1)
- refnames = keywords["refnames"].strip()
- if refnames.startswith("$Format"):
- if verbose:
- print("keywords are unexpanded, not using")
- raise NotThisMethod("unexpanded keywords, not a git-archive tarball")
- refs = {r.strip() for r in refnames.strip("()").split(",")}
- # starting in git-1.8.3, tags are listed as "tag: foo-1.0" instead of
- # just "foo-1.0". If we see a "tag: " prefix, prefer those.
- TAG = "tag: "
- tags = {r[len(TAG) :] for r in refs if r.startswith(TAG)}
- if not tags:
- # Either we're using git < 1.8.3, or there really are no tags. We use
- # a heuristic: assume all version tags have a digit. The old git %d
- # expansion behaves like git log --decorate=short and strips out the
- # refs/heads/ and refs/tags/ prefixes that would let us distinguish
- # between branches and tags. By ignoring refnames without digits, we
- # filter out many common branch names like "release" and
- # "stabilization", as well as "HEAD" and "master".
- tags = {r for r in refs if re.search(r"\d", r)}
- if verbose:
- print("discarding '%s', no digits" % ",".join(refs - tags))
- if verbose:
- print("likely tags: %s" % ",".join(sorted(tags)))
- for ref in sorted(tags):
- # sorting will prefer e.g. "2.0" over "2.0rc1"
- if ref.startswith(tag_prefix):
- r = ref[len(tag_prefix) :]
- if verbose:
- print("picking %s" % r)
- return {
- "version": r,
- "full-revisionid": keywords["full"].strip(),
- "dirty": False,
- "error": None,
- "date": date,
- }
- # no suitable tags, so version is "0+unknown", but full hex is still there
- if verbose:
- print("no suitable tags, using unknown + full revision id")
- return {
- "version": "0+unknown",
- "full-revisionid": keywords["full"].strip(),
- "dirty": False,
- "error": "no suitable tags",
- "date": None,
- }
-
-
-@register_vcs_handler("git", "pieces_from_vcs")
-def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command):
- """Get version from 'git describe' in the root of the source tree.
-
- This only gets called if the git-archive 'subst' keywords were *not*
- expanded, and _version.py hasn't already been rewritten with a short
- version string, meaning we're inside a checked out source tree.
- """
- GITS = ["git"]
- if sys.platform == "win32":
- GITS = ["git.cmd", "git.exe"]
-
- out, rc = run_command(GITS, ["rev-parse", "--git-dir"], cwd=root, hide_stderr=True)
- if rc != 0:
- if verbose:
- print("Directory %s not under git control" % root)
- raise NotThisMethod("'git rev-parse --git-dir' returned error")
-
- # if there is a tag matching tag_prefix, this yields TAG-NUM-gHEX[-dirty]
- # if there isn't one, this yields HEX[-dirty] (no NUM)
- describe_out, rc = run_command(
- GITS,
- [
- "describe",
- "--tags",
- "--dirty",
- "--always",
- "--long",
- "--match",
- "%s*" % tag_prefix,
- ],
- cwd=root,
- )
- # --long was added in git-1.5.5
- if describe_out is None:
- raise NotThisMethod("'git describe' failed")
- describe_out = describe_out.strip()
- full_out, rc = run_command(GITS, ["rev-parse", "HEAD"], cwd=root)
- if full_out is None:
- raise NotThisMethod("'git rev-parse' failed")
- full_out = full_out.strip()
-
- pieces = {}
- pieces["long"] = full_out
- pieces["short"] = full_out[:7] # maybe improved later
- pieces["error"] = None
-
- # parse describe_out. It will be like TAG-NUM-gHEX[-dirty] or HEX[-dirty]
- # TAG might have hyphens.
- git_describe = describe_out
-
- # look for -dirty suffix
- dirty = git_describe.endswith("-dirty")
- pieces["dirty"] = dirty
- if dirty:
- git_describe = git_describe[: git_describe.rindex("-dirty")]
-
- # now we have TAG-NUM-gHEX or HEX
-
- if "-" in git_describe:
- # TAG-NUM-gHEX
- mo = re.search(r"^(.+)-(\d+)-g([0-9a-f]+)$", git_describe)
- if not mo:
- # unparseable. Maybe git-describe is misbehaving?
- pieces["error"] = "unable to parse git-describe output: '%s'" % describe_out
- return pieces
-
- # tag
- full_tag = mo.group(1)
- if not full_tag.startswith(tag_prefix):
- if verbose:
- fmt = "tag '%s' doesn't start with prefix '%s'"
- print(fmt % (full_tag, tag_prefix))
- pieces["error"] = "tag '{}' doesn't start with prefix '{}'".format(
- full_tag,
- tag_prefix,
- )
- return pieces
- pieces["closest-tag"] = full_tag[len(tag_prefix) :]
-
- # distance: number of commits since tag
- pieces["distance"] = int(mo.group(2))
-
- # commit: short hex revision ID
- pieces["short"] = mo.group(3)
-
- else:
- # HEX: no tags
- pieces["closest-tag"] = None
- count_out, rc = run_command(GITS, ["rev-list", "HEAD", "--count"], cwd=root)
- pieces["distance"] = int(count_out) # total number of commits
-
- # commit date: see ISO-8601 comment in git_versions_from_keywords()
- date = run_command(GITS, ["show", "-s", "--format=%ci", "HEAD"], cwd=root)[
- 0
- ].strip()
- pieces["date"] = date.strip().replace(" ", "T", 1).replace(" ", "", 1)
-
- return pieces
-
-
-def plus_or_dot(pieces):
- """Return a + if we don't already have one, else return a ."""
- if "+" in pieces.get("closest-tag", ""):
- return "."
- return "+"
-
-
-def render_pep440(pieces):
- """Build up version string, with post-release "local version identifier".
-
- Our goal: TAG[+DISTANCE.gHEX[.dirty]] . Note that if you
- get a tagged build and then dirty it, you'll get TAG+0.gHEX.dirty
-
- Exceptions:
- 1: no tags. git_describe was just HEX. 0+untagged.DISTANCE.gHEX[.dirty]
- """
- if pieces["closest-tag"]:
- rendered = pieces["closest-tag"]
- if pieces["distance"] or pieces["dirty"]:
- rendered += plus_or_dot(pieces)
- rendered += "%d.g%s" % (pieces["distance"], pieces["short"])
- if pieces["dirty"]:
- rendered += ".dirty"
- else:
- # exception #1
- rendered = "0+untagged.%d.g%s" % (pieces["distance"], pieces["short"])
- if pieces["dirty"]:
- rendered += ".dirty"
- return rendered
-
-
-def render_pep440_pre(pieces):
- """TAG[.post.devDISTANCE] -- No -dirty.
-
- Exceptions:
- 1: no tags. 0.post.devDISTANCE
- """
- if pieces["closest-tag"]:
- rendered = pieces["closest-tag"]
- if pieces["distance"]:
- rendered += ".post.dev%d" % pieces["distance"]
- else:
- # exception #1
- rendered = "0.post.dev%d" % pieces["distance"]
- return rendered
-
-
-def render_pep440_post(pieces):
- """TAG[.postDISTANCE[.dev0]+gHEX] .
-
- The ".dev0" means dirty. Note that .dev0 sorts backwards
- (a dirty tree will appear "older" than the corresponding clean one),
- but you shouldn't be releasing software with -dirty anyways.
-
- Exceptions:
- 1: no tags. 0.postDISTANCE[.dev0]
- """
- if pieces["closest-tag"]:
- rendered = pieces["closest-tag"]
- if pieces["distance"] or pieces["dirty"]:
- rendered += ".post%d" % pieces["distance"]
- if pieces["dirty"]:
- rendered += ".dev0"
- rendered += plus_or_dot(pieces)
- rendered += "g%s" % pieces["short"]
- else:
- # exception #1
- rendered = "0.post%d" % pieces["distance"]
- if pieces["dirty"]:
- rendered += ".dev0"
- rendered += "+g%s" % pieces["short"]
- return rendered
-
-
-def render_pep440_old(pieces):
- """TAG[.postDISTANCE[.dev0]] .
-
- The ".dev0" means dirty.
-
- Eexceptions:
- 1: no tags. 0.postDISTANCE[.dev0]
- """
- if pieces["closest-tag"]:
- rendered = pieces["closest-tag"]
- if pieces["distance"] or pieces["dirty"]:
- rendered += ".post%d" % pieces["distance"]
- if pieces["dirty"]:
- rendered += ".dev0"
- else:
- # exception #1
- rendered = "0.post%d" % pieces["distance"]
- if pieces["dirty"]:
- rendered += ".dev0"
- return rendered
-
-
-def render_git_describe(pieces):
- """TAG[-DISTANCE-gHEX][-dirty].
-
- Like 'git describe --tags --dirty --always'.
-
- Exceptions:
- 1: no tags. HEX[-dirty] (note: no 'g' prefix)
- """
- if pieces["closest-tag"]:
- rendered = pieces["closest-tag"]
- if pieces["distance"]:
- rendered += "-%d-g%s" % (pieces["distance"], pieces["short"])
- else:
- # exception #1
- rendered = pieces["short"]
- if pieces["dirty"]:
- rendered += "-dirty"
- return rendered
-
-
-def render_git_describe_long(pieces):
- """TAG-DISTANCE-gHEX[-dirty].
-
- Like 'git describe --tags --dirty --always -long'.
- The distance/hash is unconditional.
-
- Exceptions:
- 1: no tags. HEX[-dirty] (note: no 'g' prefix)
- """
- if pieces["closest-tag"]:
- rendered = pieces["closest-tag"]
- rendered += "-%d-g%s" % (pieces["distance"], pieces["short"])
- else:
- # exception #1
- rendered = pieces["short"]
- if pieces["dirty"]:
- rendered += "-dirty"
- return rendered
-
-
-def render(pieces, style):
- """Render the given version pieces into the requested style."""
- if pieces["error"]:
- return {
- "version": "unknown",
- "full-revisionid": pieces.get("long"),
- "dirty": None,
- "error": pieces["error"],
- "date": None,
- }
-
- if not style or style == "default":
- style = "pep440" # the default
-
- if style == "pep440":
- rendered = render_pep440(pieces)
- elif style == "pep440-pre":
- rendered = render_pep440_pre(pieces)
- elif style == "pep440-post":
- rendered = render_pep440_post(pieces)
- elif style == "pep440-old":
- rendered = render_pep440_old(pieces)
- elif style == "git-describe":
- rendered = render_git_describe(pieces)
- elif style == "git-describe-long":
- rendered = render_git_describe_long(pieces)
- else:
- raise ValueError("unknown style '%s'" % style)
-
- return {
- "version": rendered,
- "full-revisionid": pieces["long"],
- "dirty": pieces["dirty"],
- "error": None,
- "date": pieces.get("date"),
- }
-
-
-def get_versions():
- """Get version information or return default if unable to do so."""
- # I am in _version.py, which lives at ROOT/VERSIONFILE_SOURCE. If we have
- # __file__, we can work backwards from there to the root. Some
- # py2exe/bbfreeze/non-CPython implementations don't do __file__, in which
- # case we can only use expanded keywords.
-
- cfg = get_config()
- verbose = cfg.verbose
-
- try:
- return git_versions_from_keywords(get_keywords(), cfg.tag_prefix, verbose)
- except NotThisMethod:
- pass
-
- try:
- root = os.path.realpath(__file__)
- # versionfile_source is the relative path from the top of the source
- # tree (where the .git directory might live) to this file. Invert
- # this to find the root from __file__.
- for i in cfg.versionfile_source.split("/"):
- root = os.path.dirname(root)
- except NameError:
- return {
- "version": "0+unknown",
- "full-revisionid": None,
- "dirty": None,
- "error": "unable to find root of source tree",
- "date": None,
- }
-
- try:
- pieces = git_pieces_from_vcs(cfg.tag_prefix, root, verbose)
- return render(pieces, cfg.style)
- except NotThisMethod:
- pass
-
- try:
- if cfg.parentdir_prefix:
- return versions_from_parentdir(cfg.parentdir_prefix, root, verbose)
- except NotThisMethod:
- pass
-
- return {
- "version": "0+unknown",
- "full-revisionid": None,
- "dirty": None,
- "error": "unable to compute version",
- "date": None,
- }
diff --git a/oceans/datasets.py b/oceans/datasets.py
index 1a8c84f..63ef84e 100644
--- a/oceans/datasets.py
+++ b/oceans/datasets.py
@@ -129,10 +129,11 @@ def woa_profile(lon, lat, variable="temperature", time_period="annual", resoluti
--------
>>> import matplotlib.pyplot as plt
>>> from oceans.datasets import woa_profile
- >>> cube = woa_profile(-143, 10, variable='temperature',
- ... time_period='annual', resolution='5')
+ >>> cube = woa_profile(
+ ... -143, 10, variable="temperature", time_period="annual", resolution="5"
+ ... )
>>> fig, ax = plt.subplots(figsize=(2.25, 5))
- >>> z = cube.coord(axis='Z').points
+ >>> z = cube.coord(axis="Z").points
>>> l = ax.plot(cube[0, :].data, z)
>>> ax.grid(True)
>>> ax.invert_yaxis()
@@ -187,7 +188,9 @@ def woa_subset(
>>> import matplotlib.pyplot as plt
>>> from oceans.colormaps import cm
>>> bbox = [2.5, 357.5, -87.5, 87.5]
- >>> cube = woa_subset(bbox, variable='temperature', time_period='annual', resolution='5')
+ >>> cube = woa_subset(
+ ... bbox, variable="temperature", time_period="annual", resolution="5"
+ ... )
>>> c = cube[0, 0, ...] # Slice singleton time and first level.
>>> cs = iplt.pcolormesh(c, cmap=cm.avhrr)
>>> cbar = plt.colorbar(cs)
@@ -196,18 +199,23 @@ def woa_subset(
>>> import iris
>>> from oceans.colormaps import get_color
>>> colors = get_color(12)
- >>> months = 'Jan Feb Apr Mar May Jun Jul Aug Sep Oct Nov Dec'.split()
+ >>> months = "Jan Feb Apr Mar May Jun Jul Aug Sep Oct Nov Dec".split()
>>> bbox = [-143, -141, 10, 12]
>>> fig, ax = plt.subplots(figsize=(5, 5))
>>> for month in months:
- ... cube = woa_subset(bbox, time_period=month, variable='temperature', resolution='1')
+ ... cube = woa_subset(
+ ... bbox, time_period=month, variable="temperature", resolution="1"
+ ... )
... grid_areas = iris.analysis.cartography.area_weights(cube)
- ... c = cube.collapsed(['longitude', 'latitude'], iris.analysis.MEAN, weights=grid_areas)
- ... z = c.coord(axis='Z').points
+ ... c = cube.collapsed(
+ ... ["longitude", "latitude"], iris.analysis.MEAN, weights=grid_areas
+ ... )
+ ... z = c.coord(axis="Z").points
... l = ax.plot(c[0, :].data, z, label=month, color=next(colors))
+ ...
>>> ax.grid(True)
>>> ax.invert_yaxis()
- >>> leg = ax.legend(loc='lower left')
+ >>> leg = ax.legend(loc="lower left")
>>> _ = ax.set_ylim(200, 0)
"""
@@ -261,7 +269,7 @@ def etopo_subset(bbox, tfile=None, smoo=False):
bathy = etopo.variables["z"][jmin:jmax, imin:imax]
if smoo:
- from scipy.ndimage.filters import gaussian_filter
+ from scipy.ndimage import gaussian_filter
bathy = gaussian_filter(bathy, sigma=1)
@@ -309,17 +317,25 @@ def get_isobath(bbox, iso=-200, tfile=None, smoo=False):
>>> lon, lat, bathy = etopo_subset(bbox=bbox, smoo=True)
>>> fig, ax = plt.subplots()
>>> cs = ax.pcolormesh(lon, lat, bathy)
- >>> for segment in segments:
- ... lines = ax.plot(segment[:, 0], segment[:, -1], 'k', linewidth=2)
+ >>> for segment in segments[0]:
+ ... lines = ax.plot(segment[:, 0], segment[:, -1], "k", linewidth=2)
+ ...
"""
- import matplotlib._contour as contour
+ import contourpy
lon, lat, topo = etopo_subset(bbox, tfile=tfile, smoo=smoo)
- # Required args for QuadContourGenerator.
- mask, corner_mask, nchunk = None, True, 0
- c = contour.QuadContourGenerator(lon, lat, topo, mask, corner_mask, nchunk)
+ c = contourpy.contour_generator(
+ lon,
+ lat,
+ topo,
+ name="mpl2014",
+ line_type=contourpy.LineType.SeparateCode,
+ fill_type=contourpy.FillType.OuterCode,
+ corner_mask=True,
+ chunk_size=0,
+ )
res = c.create_contour(iso)
nseg = len(res) // 2
segments = res[:nseg]
diff --git a/oceans/filters.py b/oceans/filters.py
index 5e59156..9100c0c 100644
--- a/oceans/filters.py
+++ b/oceans/filters.py
@@ -22,12 +22,12 @@ def lanc(numwt, haf):
>>> h = 2.5 * np.sin(2 * np.pi * t / 12.42)
>>> h += 1.5 * np.sin(2 * np.pi * t / 12.0)
>>> h += 0.3 * np.random.randn(len(t))
- >>> wt = lanc(96+1+96, 1./40)
- >>> low = np.convolve(wt, h, mode='same')
+ >>> wt = lanc(96 + 1 + 96, 1.0 / 40)
+ >>> low = np.convolve(wt, h, mode="same")
>>> high = h - low
>>> fig, (ax0, ax1) = plt.subplots(nrows=2)
- >>> _ = ax0.plot(high, label='high')
- >>> _ = ax1.plot(low, label='low')
+ >>> _ = ax0.plot(high, label="high")
+ >>> _ = ax1.plot(low, label="low")
>>> _ = ax0.legend(numpoints=1)
>>> _ = ax1.legend(numpoints=1)
@@ -84,28 +84,29 @@ def smoo1(datain, window_len=11, window="hanning"):
>>> from oceans.filters import smoo1
>>> import numpy as np
>>> import matplotlib.pyplot as plt
- >>> time = np.linspace( -4, 4, 100 )
+ >>> time = np.linspace(-4, 4, 100)
>>> series = np.sin(time)
- >>> noise_series = series + np.random.randn( len(time) ) * 0.1
+ >>> noise_series = series + np.random.randn(len(time)) * 0.1
>>> data_out = smoo1(series)
>>> ws = 31
>>> ax = plt.subplot(211)
>>> _ = ax.plot(np.ones(ws))
- >>> windows = ['flat', 'hanning', 'hamming', 'bartlett', 'blackman']
+ >>> windows = ["flat", "hanning", "hamming", "bartlett", "blackman"]
>>> for w in windows[1:]:
- ... _ = eval('plt.plot(np.' + w + '(ws) )')
+ ... _ = eval("plt.plot(np." + w + "(ws) )")
>>> _ = ax.axis([0, 30, 0, 1.1])
>>> leg = ax.legend(windows)
- >>> _ = plt.title('The smoothing windows')
+ >>> _ = plt.title("The smoothing windows")
>>> ax = plt.subplot(212)
- >>> l1, = ax.plot(series)
- >>> l2, = ax.plot(noise_series)
+ >>> (l1,) = ax.plot(series)
+ >>> (l2,) = ax.plot(noise_series)
>>> for w in windows:
... _ = plt.plot(smoo1(noise_series, 10, w))
- >>> l = ['original signal', 'signal with noise']
+ ...
+ >>> l = ["original signal", "signal with noise"]
>>> l.extend(windows)
>>> leg = ax.legend(l)
- >>> _ = plt.title('Smoothing a noisy signal')
+ >>> _ = plt.title("Smoothing a noisy signal")
TODO: window parameter can be the window itself (i.e. an array)
instead of a string.
@@ -390,28 +391,44 @@ def medfilt1(x, L=3):
>>> import matplotlib.pyplot as plt
>>> # 100 pseudo-random integers ranging from 1 to 100, plus three large
>>> # outliers for illustration.
- >>> x = np.r_[np.ceil(np.random.rand(25)*100), [1000],
- ... np.ceil(np.random.rand(25)*100), [2000],
- ... np.ceil(np.random.rand(25)*100), [3000],
- ... np.ceil(np.random.rand(25)*100)]
+ >>> x = np.r_[
+ ... np.ceil(np.random.rand(25) * 100),
+ ... [1000],
+ ... np.ceil(np.random.rand(25) * 100),
+ ... [2000],
+ ... np.ceil(np.random.rand(25) * 100),
+ ... [3000],
+ ... np.ceil(np.random.rand(25) * 100),
+ ... ]
>>> L = 2
>>> xout = medfilt1(x=x, L=L)
>>> ax = plt.subplot(211)
>>> l1, l2 = ax.plot(x), ax.plot(xout)
>>> ax.grid(True)
>>> y1min, y1max = np.min(xout) * 0.5, np.max(xout) * 2.0
- >>> leg1 = ax.legend(['x (pseudo-random)','xout'])
- >>> t1 = ax.set_title('''Median filter with window length %s.
- ... Removes outliers, tracks remaining signal)''' % L)
+ >>> leg1 = ax.legend(["x (pseudo-random)", "xout"])
+ >>> t1 = ax.set_title(
+ ... '''Median filter with window length %s.
+ ... Removes outliers, tracks remaining signal)'''
+ ... % L
+ ... )
>>> L = 103
>>> xout = medfilt1(x=x, L=L)
>>> ax = plt.subplot(212)
- >>> l1, l2, = ax.plot(x), ax.plot(xout)
+ >>> (
+ ... l1,
+ ... l2,
+ ... ) = ax.plot(
+ ... x
+ ... ), ax.plot(xout)
>>> ax.grid(True)
>>> y2min, y2max = np.min(xout) * 0.5, np.max(xout) * 2.0
>>> leg2 = ax.legend(["Same x (pseudo-random)", "xout"])
- >>> t2 = ax.set_title('''Median filter with window length %s.
- ... Removes outliers and noise''' % L)
+ >>> t2 = ax.set_title(
+ ... '''Median filter with window length %s.
+ ... Removes outliers and noise'''
+ ... % L
+ ... )
>>> ax = plt.subplot(211)
>>> lims1 = ax.set_ylim([min(y1min, y2min), max(y1max, y2max)])
>>> ax = plt.subplot(212)
@@ -469,10 +486,10 @@ def fft_lowpass(signal, low, high):
>>> x = 2.5 * np.sin(2 * np.pi * t / 12.42)
>>> x += 1.5 * np.sin(2 * np.pi * t / 12.0)
>>> x += 0.3 * np.random.randn(len(t))
- >>> filtered = fft_lowpass(x, low=1/30, high=1/40)
+ >>> filtered = fft_lowpass(x, low=1 / 30, high=1 / 40)
>>> fig, ax = plt.subplots()
- >>> l1, = ax.plot(t, x, label='original')
- >>> l2, = ax.plot(t, filtered, label='filtered')
+ >>> (l1,) = ax.plot(t, x, label="original")
+ >>> (l2,) = ax.plot(t, filtered, label="filtered")
>>> legend = ax.legend()
"""
@@ -520,9 +537,9 @@ def md_trenberth(x):
>>> x += 0.3 * np.random.randn(len(t))
>>> filtered = md_trenberth(x)
>>> fig, ax = plt.subplots()
- >>> l1, = ax.plot(t, x, label='original')
- >>> pad = [np.NaN]*5
- >>> l2, = ax.plot(t, np.r_[pad, filtered, pad], label='filtered')
+ >>> (l1,) = ax.plot(t, x, label="original")
+ >>> pad = [np.NaN] * 5
+ >>> (l2,) = ax.plot(t, np.r_[pad, filtered, pad], label="filtered")
>>> legend = ax.legend()
"""
@@ -573,14 +590,14 @@ def pl33tn(x, dt=1.0, T=33.0, mode="valid"):
>>> x = 2.5 * np.sin(2 * np.pi * t / 12.42)
>>> x += 1.5 * np.sin(2 * np.pi * t / 12.0)
>>> x += 0.3 * np.random.randn(len(t))
- >>> filtered_33 = pl33tn(x, dt=4.0) # 33 hr filter
+ >>> filtered_33 = pl33tn(x, dt=4.0) # 33 hr filter
>>> filtered_33d3 = pl33tn(x, dt=4.0, T=72.0) # 3 day filter
>>> fig, ax = plt.subplots()
- >>> l1, = ax.plot(t, x, label='original')
- >>> pad = [np.NaN]*8
- >>> l2, = ax.plot(t, np.r_[pad, filtered_33, pad], label='33 hours')
- >>> pad = [np.NaN]*17
- >>> l3, = ax.plot(t, np.r_[pad, filtered_33d3, pad], label='3 days')
+ >>> (l1,) = ax.plot(t, x, label="original")
+ >>> pad = [np.NaN] * 8
+ >>> (l2,) = ax.plot(t, np.r_[pad, filtered_33, pad], label="33 hours")
+ >>> pad = [np.NaN] * 17
+ >>> (l3,) = ax.plot(t, np.r_[pad, filtered_33d3, pad], label="3 days")
>>> legend = ax.legend()
diff --git a/oceans/ocfis.py b/oceans/ocfis.py
index 5d1631f..138c6c5 100644
--- a/oceans/ocfis.py
+++ b/oceans/ocfis.py
@@ -71,12 +71,14 @@ def uv2spdir(u, v, mag=0, rot=0):
>>> from oceans.ocfis import uv2spdir
>>> u = [+0, -0.5, -0.50, +0.90]
>>> v = [+1, +0.5, -0.45, -0.85]
- >>> wd, ws = uv2spdir(u,v)
+ >>> wd, ws = uv2spdir(u, v)
>>> fig, ax = plt.subplots(subplot_kw=dict(polar=True))
>>> kw = dict(arrowstyle="->")
>>> wd = np.deg2rad(wd)
- >>> lines = [ax.annotate("", xy=(d, s), xytext=(0, 0), arrowprops=kw)
- ... for d, s in zip(wd, ws)]
+ >>> lines = [
+ ... ax.annotate("", xy=(d, s), xytext=(0, 0), arrowprops=kw)
+ ... for d, s in zip(wd, ws)
+ ... ]
>>> _ = ax.set_ylim(0, np.max(ws))
"""
@@ -116,10 +118,10 @@ def del_eta_del_x(U, f, g, balance="geostrophic", R=None):
detadx = f * U / g
elif balance == "gradient":
- detadx = (U ** 2 / R + f * U) / g
+ detadx = (U**2 / R + f * U) / g
elif balance == "max_gradient":
- detadx = (R * f ** 2) / (4 * g)
+ detadx = (R * f**2) / (4 * g)
return detadx
@@ -216,37 +218,38 @@ def pcaben(u, v):
minor axis (minrax)
major azimuth (majaz)
minor azimuth (minaz)
- elipticity (elptcty)
+ ellipticity (elptcty)
Examples
--------
>>> import matplotlib.pyplot as plt
>>> from oceans.ocfis import pcaben, uv2spdir
- >>> u = np.r_[(0., 1., -2., -1., 1.), np.random.randn(10)]
- >>> v = np.r_[(3., 1., 0., -1., -1.), np.random.randn(10)]
+ >>> u = np.r_[(0.0, 1.0, -2.0, -1.0, 1.0), np.random.randn(10)]
+ >>> v = np.r_[(3.0, 1.0, 0.0, -1.0, -1.0), np.random.randn(10)]
>>> (mjrax, mjaz, mirax, miaz, el), (x1, x2, y1, y2) = pcaben(u, v)
>>> fig, ax = plt.subplots()
- >>> _ = ax.plot(x1, y1,'r-', x2, y2, 'r-')
- >>> ax.set_aspect('equal')
- >>> _ = ax.set_xlabel('U component')
- >>> _ = ax.set_ylabel('V component')
- >>> _ = ax.plot(u, v, 'bo')
+ >>> _ = ax.plot(x1, y1, "r-", x2, y2, "r-")
+ >>> ax.set_aspect("equal")
+ >>> _ = ax.set_xlabel("U component")
+ >>> _ = ax.set_ylabel("V component")
+ >>> _ = ax.plot(u, v, "bo")
>>> _ = ax.axis([-3.2, 3.2, -3.2, 3.2])
>>> mdir, mspd = uv2spdir(u.mean(), v.mean())
- >>> _ = ax.plot([0, u.mean()],[0, v.mean()], 'k-')
+ >>> _ = ax.plot([0, u.mean()], [0, v.mean()], "k-")
>>> flatness = 1 - mirax / mjrax
>>> if False:
- ... print('Mean u = {}'.format(u.mean()))
- ... print('Mean v = {}'.format(v.mean()))
- ... print('Mean magnitude: {}'.format(mspd))
- ... print('Direction: {}'.format(mdir))
- ... print('Axis 1 Length: {}'.format(mjrax))
- ... print('Axis 1 Azimuth: {}'.format(mjaz))
- ... print('Axis 2 Length: {}'.format.format(mirax))
- ... print('Axis 2 Azimuth: {}'.format(miaz))
- ... print('elipticity is : {}'.format(el))
- ... print('Negative (positive) means clockwise (anti-clockwise)')
- ... print('Flatness: {}'.format(flatness))
+ ... print("Mean u = {}".format(u.mean()))
+ ... print("Mean v = {}".format(v.mean()))
+ ... print("Mean magnitude: {}".format(mspd))
+ ... print("Direction: {}".format(mdir))
+ ... print("Axis 1 Length: {}".format(mjrax))
+ ... print("Axis 1 Azimuth: {}".format(mjaz))
+ ... print("Axis 2 Length: {}".format.format(mirax))
+ ... print("Axis 2 Azimuth: {}".format(miaz))
+ ... print("ellipticity is : {}".format(el))
+ ... print("Negative (positive) means clockwise (anti-clockwise)")
+ ... print("Flatness: {}".format(flatness))
+ ...
Notes:
https://pubs.usgs.gov/of/2002/of02-217/m-files/pcaben.m
@@ -452,12 +455,64 @@ def binave(datain, r):
Examples
--------
>>> from oceans.ocfis import binave
- >>> data = [10., 11., 13., 2., 34., 21.5, 6.46, 6.27, 7.0867, 15., 123.,
- ... 3.2, 0.52, 18.2, 10., 11., 13., 2., 34., 21.5, 6.46, 6.27,
- ... 7.0867, 15., 123., 3.2, 0.52, 18.2, 10., 11., 13., 2., 34.,
- ... 21.5, 6.46, 6.27, 7.0867, 15., 123., 3.2, 0.52, 18.2, 10.,
- ... 11., 13., 2., 34., 21.5, 6.46, 6.27, 7.0867, 15., 123., 3.2,
- ... 0.52, 18.2]
+ >>> data = [
+ ... 10.0,
+ ... 11.0,
+ ... 13.0,
+ ... 2.0,
+ ... 34.0,
+ ... 21.5,
+ ... 6.46,
+ ... 6.27,
+ ... 7.0867,
+ ... 15.0,
+ ... 123.0,
+ ... 3.2,
+ ... 0.52,
+ ... 18.2,
+ ... 10.0,
+ ... 11.0,
+ ... 13.0,
+ ... 2.0,
+ ... 34.0,
+ ... 21.5,
+ ... 6.46,
+ ... 6.27,
+ ... 7.0867,
+ ... 15.0,
+ ... 123.0,
+ ... 3.2,
+ ... 0.52,
+ ... 18.2,
+ ... 10.0,
+ ... 11.0,
+ ... 13.0,
+ ... 2.0,
+ ... 34.0,
+ ... 21.5,
+ ... 6.46,
+ ... 6.27,
+ ... 7.0867,
+ ... 15.0,
+ ... 123.0,
+ ... 3.2,
+ ... 0.52,
+ ... 18.2,
+ ... 10.0,
+ ... 11.0,
+ ... 13.0,
+ ... 2.0,
+ ... 34.0,
+ ... 21.5,
+ ... 6.46,
+ ... 6.27,
+ ... 7.0867,
+ ... 15.0,
+ ... 123.0,
+ ... 3.2,
+ ... 0.52,
+ ... 18.2,
+ ... ]
>>> binave(data, 24)
array([16.564725 , 21.1523625, 22.4670875])
@@ -469,7 +524,7 @@ def binave(datain, r):
"""
- datain, rows = np.asarray(datain), np.asarray(r, dtype=np.int)
+ datain, rows = np.asarray(datain), np.asarray(r, dtype=np.int64)
if datain.ndim != 1:
raise ValueError("Must be a 1D array.")
@@ -526,11 +581,11 @@ def bin_dates(self, freq, tz=None):
--------
>>> import numpy as np
>>> from pandas import Series, date_range
- >>> n = 24*30
+ >>> n = 24 * 30
>>> sig = np.random.rand(n) + 2 * np.cos(2 * np.pi * np.arange(n))
- >>> dates = date_range(start='1/1/2000', periods=n, freq='H')
+ >>> dates = date_range(start="1/1/2000", periods=n, freq="H")
>>> series = Series(data=sig, index=dates)
- >>> new_series = bin_dates(series, freq='D', tz=None)
+ >>> new_series = bin_dates(series, freq="D", tz=None)
"""
from pandas import date_range
@@ -602,7 +657,7 @@ def pol2cart(theta, radius, units="deg"):
Examples
--------
- >>> pol2cart(0, 1, units='deg')
+ >>> pol2cart(0, 1, units="deg")
(1.0, 0.0)
"""
@@ -746,7 +801,7 @@ def shiftdim(x, n=None):
Examples
--------
>>> import oceans.ocfis as ff
- >>> a = np.random.rand(1,1,3,1,2)
+ >>> a = np.random.rand(1, 1, 3, 1, 2)
>>> print("a shape and dimension: %s, %s" % (a.shape, a.ndim))
a shape and dimension: (1, 1, 3, 1, 2), 5
>>> # print(range(a.ndim))
diff --git a/oceans/plotting.py b/oceans/plotting.py
index 7fe6825..82b52ee 100644
--- a/oceans/plotting.py
+++ b/oceans/plotting.py
@@ -23,17 +23,17 @@ def stick_plot(time, u, v, **kw):
Examples
--------
>>> from pandas import date_range
- >>> time = date_range(start='1990-11-01 00:00', end='1991-2-1 00:00')
- >>> u = np.sin(0.1 * time.to_julian_date().values) ** 2 -0.5
+ >>> time = date_range(start="1990-11-01 00:00", end="1991-2-1 00:00")
+ >>> u = np.sin(0.1 * time.to_julian_date().values) ** 2 - 0.5
>>> v = np.cos(0.1 * time.to_julian_date().values)
- >>> fig, (ax0, ax1, ax2) = plt.subplots(nrows=3, figsize=(10, 6),
- ... sharex=True)
+ >>> fig, (ax0, ax1, ax2) = plt.subplots(nrows=3, figsize=(10, 6), sharex=True)
>>> q = stick_plot(time, u, v, ax=ax0)
- >>> qk = ax0.quiverkey(q, 0.2, 0.65, 1, "1 m s$^{-1}$",
- ... labelpos='N', coordinates='axes')
- >>> l = ax1.plot(time.to_pydatetime(), np.sqrt(u**2 + v**2), label='speed')
- >>> l0 = ax2.plot(time.to_pydatetime(), u, label='u')
- >>> l1 = ax2.plot(time.to_pydatetime(), v, label='v')
+ >>> qk = ax0.quiverkey(
+ ... q, 0.2, 0.65, 1, "1 m s$^{-1}$", labelpos="N", coordinates="axes"
+ ... )
+ >>> l = ax1.plot(time.to_pydatetime(), np.sqrt(u**2 + v**2), label="speed")
+ >>> l0 = ax2.plot(time.to_pydatetime(), u, label="u")
+ >>> l1 = ax2.plot(time.to_pydatetime(), v, label="v")
Based on Stephane Raynaud's example from:
https://www.mail-archive.com/matplotlib-users@lists.sourceforge.net/msg18051.html
@@ -216,9 +216,9 @@ class EditPoints:
>>> r = 1.5
>>> xs = r * np.cos(theta)
>>> ys = r * np.sin(theta)
- >>> points = ax.plot(xs, ys, 'ko')
+ >>> points = ax.plot(xs, ys, "ko")
>>> p = EditPoints(fig, ax, points[0], verbose=True)
- >>> _ = ax.set_title('Click and drag a point to move it')
+ >>> _ = ax.set_title("Click and drag a point to move it")
>>> _ = ax.axis([-2, 2, -2, 2])
Based on https://matplotlib.org/examples/event_handling/poly_editor.html
@@ -354,7 +354,7 @@ def key_press_callback(self, event):
if ind is not None:
if self.verbose:
print(
- "\nDeleted ({}, {}) ind: {}".format(x[ind], y[ind], ind),
+ f"\nDeleted ({x[ind]}, {y[ind]}) ind: {ind}",
) # noqa
x = np.delete(x, ind)
y = np.delete(y, ind)
diff --git a/oceans/sandbox/lines.py b/oceans/sandbox/lines.py
index cb84e5d..a5c0cac 100644
--- a/oceans/sandbox/lines.py
+++ b/oceans/sandbox/lines.py
@@ -26,12 +26,14 @@ def LineNormals2D(Vertices, Lines):
--------
>>> import numpy as np
>>> import matplotlib.pyplot as plt
- >>> data = np.load(os.path.join(_default_path, 'testdata.npz'))
- >>> Lines, Vertices = data['Lines'], data['Vertices']
+ >>> data = np.load(os.path.join(_default_path, "testdata.npz"))
+ >>> Lines, Vertices = data["Lines"], data["Vertices"]
>>> N = LineNormals2D(Vertices, Lines)
>>> fig, ax = plt.subplots(nrows=1, ncols=1)
- >>> _ = ax.plot(np.c_[Vertices[:, 0], Vertices[:,0 ] + 10 * N[:, 0]].T,
- ... np.c_[Vertices[:, 1], Vertices[:, 1] + 10 * N[:, 1]].T)
+ >>> _ = ax.plot(
+ ... np.c_[Vertices[:, 0], Vertices[:, 0] + 10 * N[:, 0]].T,
+ ... np.c_[Vertices[:, 1], Vertices[:, 1] + 10 * N[:, 1]].T,
+ ... )
Function based on LineNormals2D.m written by
D.Kroon University of Twente (August 2011)
@@ -56,8 +58,8 @@ def LineNormals2D(Vertices, Lines):
# Differences. Points which are closer give a more accurate estimate of
# the normal).
LL = np.sqrt(DT[:, 0] ** 2 + DT[:, 1] ** 2)
- DT[:, 0] = DT[:, 0] / np.maximum(LL ** 2, eps)
- DT[:, 1] = DT[:, 1] / np.maximum(LL ** 2, eps)
+ DT[:, 0] = DT[:, 0] / np.maximum(LL**2, eps)
+ DT[:, 1] = DT[:, 1] / np.maximum(LL**2, eps)
D1 = np.zeros_like(Vertices)
D2 = np.zeros_like(Vertices)
@@ -95,19 +97,23 @@ def LineCurvature2D(Vertices, Lines=None):
--------
>>> import numpy as np
>>> import matplotlib.pyplot as plt
- >>> data = np.load(os.path.join(_default_path, 'testdata.npz'))
- >>> Lines, Vertices = data['Lines'], data['Vertices']
+ >>> data = np.load(os.path.join(_default_path, "testdata.npz"))
+ >>> Lines, Vertices = data["Lines"], data["Vertices"]
>>> k = LineCurvature2D(Vertices, Lines)
>>> N = LineNormals2D(Vertices, Lines)
>>> k = k * 100
>>> fig, ax = plt.subplots(nrows=1, ncols=1)
- >>> _ = ax.plot(np.c_[Vertices[:, 0], Vertices[:, 0] + k * N[:, 0]].T,
- ... np.c_[Vertices[:, 1], Vertices[:, 1] + k * N[:, 1]].T, 'g')
- >>> _ = ax.plot(np.c_[Vertices[Lines[:, 0] - 1, 0],
- ... Vertices[Lines[:, 1] - 1, 0]].T,
- ... np.c_[Vertices[Lines[:, 0] - 1, 1],
- ... Vertices[Lines[:, 1] - 1, 1]].T, 'b')
- >>> _ = ax.plot(Vertices[:, 0], Vertices[:, 1], 'r.')
+ >>> _ = ax.plot(
+ ... np.c_[Vertices[:, 0], Vertices[:, 0] + k * N[:, 0]].T,
+ ... np.c_[Vertices[:, 1], Vertices[:, 1] + k * N[:, 1]].T,
+ ... "g",
+ ... )
+ >>> _ = ax.plot(
+ ... np.c_[Vertices[Lines[:, 0] - 1, 0], Vertices[Lines[:, 1] - 1, 0]].T,
+ ... np.c_[Vertices[Lines[:, 0] - 1, 1], Vertices[Lines[:, 1] - 1, 1]].T,
+ ... "b",
+ ... )
+ >>> _ = ax.plot(Vertices[:, 0], Vertices[:, 1], "r.")
Function based on LineCurvature2D.m written by
D.Kroon University of Twente (August 2011)
@@ -125,7 +131,7 @@ def LineCurvature2D(Vertices, Lines=None):
raise ValueError(f"Cannot recognized {Lines!r}.")
# Get left and right neighbor of each points.
- Na = np.zeros(Vertices.shape[0], dtype=np.int)
+ Na = np.zeros(Vertices.shape[0], dtype=np.int64)
Nb = np.zeros_like(Na)
# As int because we use it to index an array...
@@ -162,13 +168,13 @@ def LineCurvature2D(Vertices, Lines=None):
M = np.c_[
np.ones_like(Tb),
-Ta,
- Ta ** 2,
+ Ta**2,
np.ones_like(Tb),
np.zeros_like(Tb),
np.zeros_like(Tb),
np.ones_like(Tb),
-Tb,
- Tb ** 2,
+ Tb**2,
]
invM = inverse3(M)
diff --git a/oceans/sw_extras/gamma_GP_from_SP_pt.py b/oceans/sw_extras/gamma_GP_from_SP_pt.py
index 8d59edd..250f558 100644
--- a/oceans/sw_extras/gamma_GP_from_SP_pt.py
+++ b/oceans/sw_extras/gamma_GP_from_SP_pt.py
@@ -66,7 +66,7 @@ def gamma_G_north_atlantic(SP, pt):
for k in range(1, len(Fit)):
i = Fit[k, 0]
j = Fit[k, 1]
- gamma_NAtl = gamma_NAtl + Fit[k, 2] * (SP ** i * pt ** j)
+ gamma_NAtl = gamma_NAtl + Fit[k, 2] * (SP**i * pt**j)
return gamma_NAtl
@@ -114,7 +114,7 @@ def gamma_G_south_atlantic(SP, pt):
for k in range(1, len(Fit)):
i = Fit[k, 0]
j = Fit[k, 1]
- gamma_SAtl = gamma_SAtl + Fit[k, 2] * (SP ** i * pt ** j)
+ gamma_SAtl = gamma_SAtl + Fit[k, 2] * (SP**i * pt**j)
return gamma_SAtl
@@ -162,7 +162,7 @@ def gamma_G_pacific(SP, pt):
for k in range(1, len(Fit)):
i = Fit[k, 0]
j = Fit[k, 1]
- gamma_Pac = gamma_Pac + Fit[k, 2] * (SP ** i * pt ** j)
+ gamma_Pac = gamma_Pac + Fit[k, 2] * (SP**i * pt**j)
return gamma_Pac
@@ -210,7 +210,7 @@ def gamma_G_indian(SP, pt):
for k in range(1, len(Fit)):
i = Fit[k, 0]
j = Fit[k, 1]
- gamma_Ind = gamma_Ind + Fit[k, 2] * (SP ** i * pt ** j)
+ gamma_Ind = gamma_Ind + Fit[k, 2] * (SP**i * pt**j)
return gamma_Ind
@@ -258,7 +258,7 @@ def gamma_G_southern_ocean(SP, pt, p):
for k in range(1, len(Fit_N)):
i = Fit_N[k, 0]
j = Fit_N[k, 1]
- gamma_SOce_N = gamma_SOce_N + Fit_N[k, 2] * (SP ** i * pt ** j)
+ gamma_SOce_N = gamma_SOce_N + Fit_N[k, 2] * (SP**i * pt**j)
Fit_S = np.array(
[
@@ -287,7 +287,7 @@ def gamma_G_southern_ocean(SP, pt, p):
for k in range(1, len(Fit_S)):
i = Fit_S[k, 0]
j = Fit_S[k, 1]
- gamma_A = gamma_A + Fit_S[k, 2] * (SP ** i * pt ** j)
+ gamma_A = gamma_A + Fit_S[k, 2] * (SP**i * pt**j)
gamma_SOce_S = (
gamma_A
@@ -337,15 +337,84 @@ def gamma_GP_from_SP_pt(SP, pt, p, lon, lat):
Examples
--------
>>> from oceans.sw_extras.gamma_GP_from_SP_pt import gamma_GP_from_SP_pt
- >>> SP = [35.066, 35.086, 35.089, 35.078, 35.025, 34.851, 34.696, 34.572,
- ... 34.531, 34.509, 34.496, 34.452, 34.458, 34.456, 34.488, 34.536,
- ... 34.579, 34.612, 34.642, 34.657, 34.685, 34.707, 34.72, 34.729]
- >>> pt = [12.25, 12.21, 12.09, 11.99, 11.69, 10.54, 9.35, 8.36, 7.86, 7.43,
- ... 6.87, 6.04, 5.5, 4.9, 4.04, 3.29, 2.78, 2.45, 2.211, 2.011,
- ... 1.894, 1.788, 1.554, 1.38]
- >>> p = [1.0, 48.0, 97.0, 145.0, 194.0, 291.0, 388.0, 485.0, 581.0, 678.0,
- ... 775.0, 872.0, 969.0, 1066.0, 1260.0, 1454.0, 1647.0, 1841.0,
- ... 2020.0, 2216.0, 2413.0, 2611.0, 2878.0, 3000.0]
+ >>> SP = [
+ ... 35.066,
+ ... 35.086,
+ ... 35.089,
+ ... 35.078,
+ ... 35.025,
+ ... 34.851,
+ ... 34.696,
+ ... 34.572,
+ ... 34.531,
+ ... 34.509,
+ ... 34.496,
+ ... 34.452,
+ ... 34.458,
+ ... 34.456,
+ ... 34.488,
+ ... 34.536,
+ ... 34.579,
+ ... 34.612,
+ ... 34.642,
+ ... 34.657,
+ ... 34.685,
+ ... 34.707,
+ ... 34.72,
+ ... 34.729,
+ ... ]
+ >>> pt = [
+ ... 12.25,
+ ... 12.21,
+ ... 12.09,
+ ... 11.99,
+ ... 11.69,
+ ... 10.54,
+ ... 9.35,
+ ... 8.36,
+ ... 7.86,
+ ... 7.43,
+ ... 6.87,
+ ... 6.04,
+ ... 5.5,
+ ... 4.9,
+ ... 4.04,
+ ... 3.29,
+ ... 2.78,
+ ... 2.45,
+ ... 2.211,
+ ... 2.011,
+ ... 1.894,
+ ... 1.788,
+ ... 1.554,
+ ... 1.38,
+ ... ]
+ >>> p = [
+ ... 1.0,
+ ... 48.0,
+ ... 97.0,
+ ... 145.0,
+ ... 194.0,
+ ... 291.0,
+ ... 388.0,
+ ... 485.0,
+ ... 581.0,
+ ... 678.0,
+ ... 775.0,
+ ... 872.0,
+ ... 969.0,
+ ... 1066.0,
+ ... 1260.0,
+ ... 1454.0,
+ ... 1647.0,
+ ... 1841.0,
+ ... 2020.0,
+ ... 2216.0,
+ ... 2413.0,
+ ... 2611.0,
+ ... 2878.0,
+ ... 3000.0,
+ ... ]
>>> lon, lat, n = [187.317, -41.6667, 24]
>>> gamma_GP_from_SP_pt(SP, pt, p, lon, lat)
array([26.66339976, 26.68613362, 26.71169809, 26.72286813, 26.74102625,
diff --git a/oceans/sw_extras/sw_extras.py b/oceans/sw_extras/sw_extras.py
index 4d6978f..106dd6f 100644
--- a/oceans/sw_extras/sw_extras.py
+++ b/oceans/sw_extras/sw_extras.py
@@ -132,10 +132,10 @@ def N(bvfr2):
--------
>>> import numpy as np
>>> import oceans.sw_extras.sw_extras as swe
- >>> s = np.array([[0, 0, 0], [15, 15, 15], [30, 30, 30],[35,35,35]])
+ >>> s = np.array([[0, 0, 0], [15, 15, 15], [30, 30, 30], [35, 35, 35]])
>>> t = np.repeat(15, s.size).reshape(s.shape)
>>> p = [[0], [250], [500], [1000]]
- >>> lat = [30,32,35]
+ >>> lat = [30, 32, 35]
>>> swe.N(sw.bfrq(s, t, p, lat)[0])
array([[0.02124956, 0.02125302, 0.02125843],
[0.02110919, 0.02111263, 0.02111801],
@@ -174,10 +174,10 @@ def cph(bvfr2):
--------
>>> import numpy as np
>>> import oceans.sw_extras.sw_extras as swe
- >>> s = np.array([[0, 0, 0], [15, 15, 15], [30, 30, 30],[35,35,35]])
+ >>> s = np.array([[0, 0, 0], [15, 15, 15], [30, 30, 30], [35, 35, 35]])
>>> t = np.repeat(15, s.size).reshape(s.shape)
>>> p = [[0], [250], [500], [1000]]
- >>> lat = [30,32,35]
+ >>> lat = [30, 32, 35]
>>> swe.cph(sw.bfrq(s, t, p, lat)[0])
array([[12.17509899, 12.17708145, 12.18018192],
[12.09467754, 12.09664676, 12.09972655],
@@ -223,8 +223,7 @@ def shear(z, u, v=0):
--------
>>> import oceans.sw_extras.sw_extras as swe
>>> z = [[0], [250], [500], [1000]]
- >>> u = [[0.5, 0.5, 0.5], [0.15, 0.15, 0.15],
- ... [0.03, 0.03, .03], [0.,0.,0.]]
+ >>> u = [[0.5, 0.5, 0.5], [0.15, 0.15, 0.15], [0.03, 0.03, 0.03], [0.0, 0.0, 0.0]]
>>> swe.shear(z, u)[0]
array([[-1.4e-03, -1.4e-03, -1.4e-03],
[-4.8e-04, -4.8e-04, -4.8e-04],
@@ -238,7 +237,7 @@ def shear(z, u, v=0):
iup = np.arange(0, m - 1)
ilo = np.arange(1, m)
z_ave = (z[iup, :] + z[ilo, :]) / 2.0
- vel = np.sqrt(u ** 2 + v ** 2)
+ vel = np.sqrt(u**2 + v**2)
diff_vel = np.diff(vel, axis=0)
diff_z = np.diff(z, axis=0)
shr = diff_vel / diff_z
@@ -276,13 +275,12 @@ def richnumb(bvfr2, S2):
>>> import numpy as np
>>> import seawater as sw
>>> import oceans.sw_extras.sw_extras as swe
- >>> s = np.array([[0, 0, 0], [15, 15, 15], [30, 30, 30],[ 35, 35, 35]])
+ >>> s = np.array([[0, 0, 0], [15, 15, 15], [30, 30, 30], [35, 35, 35]])
>>> t = np.repeat(15, s.size).reshape(s.shape)
>>> p = [[0], [250], [500], [1000]]
>>> lat = [30, 32, 35]
>>> bvfr2 = sw.bfrq(s, t, p, lat)[0]
- >>> vel = [[0.5, 0.5, 0.5], [0.15, 0.15, 0.15],
- ... [0.03, 0.03, .03], [0.,0.,0.]]
+ >>> vel = [[0.5, 0.5, 0.5], [0.15, 0.15, 0.15], [0.03, 0.03, 0.03], [0.0, 0.0, 0.0]]
>>> S2 = swe.shear(p, vel)[0] ** 2
>>> swe.richnumb(bvfr2, S2)
array([[ 230.37941215, 230.45444299, 230.57181258],
@@ -358,8 +356,8 @@ def inertial_period(lat):
Examples
--------
>>> import oceans.sw_extras.sw_extras as swe
- >>> lat = 30.
- >>> swe.inertial_period(lat)/3600
+ >>> lat = 30.0
+ >>> swe.inertial_period(lat) / 3600
23.93484986278565
"""
@@ -389,11 +387,11 @@ def strat_period(N):
>>> import numpy as np
>>> import seawater as sw
>>> import oceans.sw_extras.sw_extras as swe
- >>> s = np.array([[0, 0, 0], [15, 15, 15], [30, 30, 30],[35,35,35]])
+ >>> s = np.array([[0, 0, 0], [15, 15, 15], [30, 30, 30], [35, 35, 35]])
>>> t = np.repeat(15, s.size).reshape(s.shape)
>>> p = [[0], [250], [500], [1000]]
- >>> lat = [30,32,35]
- >>> swe.strat_period(swe.N( sw.bfrq(s, t, p, lat)[0]))
+ >>> lat = [30, 32, 35]
+ >>> swe.strat_period(swe.N(sw.bfrq(s, t, p, lat)[0]))
array([[295.68548089, 295.63734267, 295.56208791],
[297.6515901 , 297.60313502, 297.52738493],
[729.91402019, 729.79520847, 729.60946944]])
@@ -428,7 +426,7 @@ def visc(s, t, p):
Examples
--------
>>> import oceans.sw_extras.sw_extras as swe
- >>> swe.visc(40., 40., 1000.)
+ >>> swe.visc(40.0, 40.0, 1000.0)
8.200192496633804e-07
Modifications: Original 1998/01/19 - Ayal Anis 1998
@@ -436,7 +434,7 @@ def visc(s, t, p):
"""
s, t, p = np.broadcast_arrays(s, t, p)
- visc = 1e-4 * (17.91 - 0.5381 * t + 0.00694 * t ** 2 + 0.02305 * s)
+ visc = 1e-4 * (17.91 - 0.5381 * t + 0.00694 * t**2 + 0.02305 * s)
visc /= sw.dens(s, t, p)
return visc
@@ -482,13 +480,13 @@ def tcond(s, t, p):
if False: # Castelli's option.
therm = 100.0 * (
- 5.5286e-3 + 3.4025e-8 * p + 1.8364e-5 * t - 3.3058e-9 * t ** 3
+ 5.5286e-3 + 3.4025e-8 * p + 1.8364e-5 * t - 3.3058e-9 * t**3
) # [W/m/K]
# 1) Caldwell's option # 2 - simplified formula, accurate to 0.5% (eqn. 9)
# in [cal/cm/C/sec]
therm = 0.001365 * (
- 1.0 + 0.003 * t - 1.025e-5 * t ** 2 + 0.0653 * (1e-4 * p) - 0.00029 * s
+ 1.0 + 0.003 * t - 1.025e-5 * t**2 + 0.0653 * (1e-4 * p) - 0.00029 * s
)
return therm * 418.4 # [cal/cm/C/sec] ->[ W/m/K]
@@ -606,11 +604,11 @@ def psu2ppt(psu):
a = [0.008, -0.1692, 25.3851, 14.0941, -7.0261, 2.7081]
return (
a[1]
- + a[2] * psu ** 0.5
+ + a[2] * psu**0.5
+ a[3] * psu
- + a[4] * psu ** 1.5
- + a[5] * psu ** 2
- + a[6] * psu ** 2.5
+ + a[4] * psu**1.5
+ + a[5] * psu**2
+ + a[6] * psu**2.5
)
@@ -851,7 +849,7 @@ def zmld_so(s, t, p, threshold=0.05, smooth=None):
References
----------
Mitchell B. G., Holm-Hansen, O., 1991. Observations of modeling of the
- Antartic phytoplankton crop in relation to mixing depth. Deep Sea
+ Antarctic phytoplankton crop in relation to mixing depth. Deep Sea
Research, 38(89):981-1007. doi:10.1016/0198-0149(91)90093-U
"""
@@ -984,7 +982,14 @@ def o2sol_SP_pt_benson_krause_84(SP, pt):
>>> SP = [34.7118, 34.8915, 35.0256, 34.8472, 34.7366, 34.7324]
>>> pt = [28.8099, 28.4392, 22.7862, 10.2262, 6.8272, 4.3236]
>>> o2sol = o2sol_SP_pt_benson_krause_84(SP, pt)
- >>> expected = [194.68254317, 195.61350628, 214.65593602, 273.56528327, 295.15807614, 312.95987166]
+ >>> expected = [
+ ... 194.68254317,
+ ... 195.61350628,
+ ... 214.65593602,
+ ... 273.56528327,
+ ... 295.15807614,
+ ... 312.95987166,
+ ... ]
>>> np.testing.assert_almost_equal(expected, o2sol)
@@ -998,21 +1003,21 @@ def o2sol_SP_pt_benson_krause_84(SP, pt):
Ts = np.log((298.15 - pt68) / (273.15 + pt68))
- # The coefficents for Benson and Krause 1984
+ # The coefficients for Benson and Krause 1984
# from the table 1 of Garcia and Gordon (1992).
A = [5.80871, 3.20291, 4.17887, 5.10006, -9.86643e-2, 3.80369]
B = [-7.01577e-3, -7.70028e-3, -1.13864e-2, -9.51519e-3]
C0 = -2.75915e-7
- # Equation 8 from Garcia and Gordon 1992 accoring to Pilson.
+ # Equation 8 from Garcia and Gordon 1992 according to Pilson.
lnCo = (
A[0]
+ A[1] * Ts
- + A[2] * Ts ** 2
- + A[3] * Ts ** 3
- + A[4] * Ts ** 4
- + A[5] * Ts ** 5
- + S * (B[0] + B[1] * Ts + B[2] * Ts ** 2 + B[3] * Ts ** 3)
- + C0 * S ** 2
+ + A[2] * Ts**2
+ + A[3] * Ts**3
+ + A[4] * Ts**4
+ + A[5] * Ts**5
+ + S * (B[0] + B[1] * Ts + B[2] * Ts**2 + B[3] * Ts**3)
+ + C0 * S**2
)
return np.exp(lnCo)
diff --git a/oceans/sw_extras/waves.py b/oceans/sw_extras/waves.py
index 653d3f7..46eac4f 100644
--- a/oceans/sw_extras/waves.py
+++ b/oceans/sw_extras/waves.py
@@ -37,58 +37,58 @@ class Waves:
--------
>>> from oceans.sw_extras.waves import Waves
>>> wav = Waves(h=10, T=5, L=None)
- >>> print("ho/Lo = %s" % wav.hoLo)
- ho/Lo = 0.2561951195588007
- >>> print("ho/L = %s" % wav.hoL)
- ho/L = 0.2732735643784346
- >>> print("Lo = %s" % wav.Lo)
- Lo = 39.03274979328733
- >>> print("L = %s" % wav.L)
- L = 36.59336761221369
- >>> print("k = %s" % wav.k)
- k = 0.17170284445431747
- >>> print("omega = %s" % wav.omega)
- omega = 1.2566370614359172
- >>> print("T = %s" % wav.T)
- T = 5.0
- >>> print("C = %s" % wav.C)
- C = 7.318673522442738
- >>> print("Cg = %s" % wav.Cg)
- Cg = 4.470858193067349
- >>> print("G = %s" % wav.G)
- G = 0.22176735425004176
+ >>> print(f"ho/Lo = {wav.hoLo:.3f}")
+ ho/Lo = 0.256
+ >>> print(f"ho/L = {wav.hoL:.3f}")
+ ho/L = 0.273
+ >>> print(f"Lo = {wav.Lo:.3f}")
+ Lo = 39.033
+ >>> print(f"L = {wav.L:.3f}")
+ L = 36.593
+ >>> print(f"k = {wav.k:.3f}")
+ k = 0.172
+ >>> print(f"omega = {wav.omega:.3f}")
+ omega = 1.257
+ >>> print(f"T = {wav.T:.3f}")
+ T = 5.000
+ >>> print(f"C = {wav.C:.3f}")
+ C = 7.319
+ >>> print(f"Cg = {wav.Cg:.3f}")
+ Cg = 4.471
+ >>> print(f"G = {wav.G:.3f}")
+ G = 0.222
>>> wav = Waves(h=10, T=None, L=100)
- >>> print("ho/Lo = %s" % wav.hoLo)
- ho/Lo = 0.05568933069002106
- >>> print("ho/L = %s" % wav.hoL)
- ho/L = 0.1
- >>> print("Lo = %s" % wav.Lo)
- Lo = 179.56760973950605
- >>> print("L = %s" % wav.L)
- L = 100.0
- >>> print("k = %s" % wav.k)
- k = 0.06283185307179587
- >>> print("omega = %s" % wav.omega)
- omega = 0.5858823798813203
- >>> print("T = %s" % wav.T)
- T = 10.724311778163298
- >>> print("C = %s" % wav.C)
- C = 9.324607682855573
- >>> print("Cg = %s" % wav.Cg)
- Cg = 8.291208888683515
- >>> print("G = %s" % wav.G)
- G = 0.7783501828024171
- >>> print("Ks = %s" % wav.Ks)
- Ks = 1.00485953746193
+ >>> print(f"ho/Lo = {wav.hoLo:.3f}")
+ ho/Lo = 0.056
+ >>> print(f"ho/L = {wav.hoL:.3f}")
+ ho/L = 0.100
+ >>> print(f"Lo = {wav.Lo:.3f}")
+ Lo = 179.568
+ >>> print(f"L = {wav.L:.3f}")
+ L = 100.000
+ >>> print(f"k = {wav.k:.3f}")
+ k = 0.063
+ >>> print(f"omega = {wav.omega:.3f}")
+ omega = 0.586
+ >>> print(f"T = {wav.T:.3f}")
+ T = 10.724
+ >>> print(f"C = {wav.C:.3f}")
+ C = 9.325
+ >>> print(f"Cg = {wav.Cg:.3f}")
+ Cg = 8.291
+ >>> print(f"G = {wav.G:.3f}")
+ G = 0.778
+ >>> print(f"Ks = {wav.Ks:.3f}")
+ Ks = 1.005
"""
def __init__(self, h, T=None, L=None, thetao=None, Ho=None, lat=None):
- self.T = np.asarray(T, dtype=np.float)
- self.L = np.asarray(L, dtype=np.float)
- self.Ho = np.asarray(Ho, dtype=np.float)
- self.lat = np.asarray(lat, dtype=np.float)
- self.thetao = np.asarray(thetao, dtype=np.float)
+ self.T = np.asarray(T, dtype=np.float64)
+ self.L = np.asarray(L, dtype=np.float64)
+ self.Ho = np.asarray(Ho, dtype=np.float64)
+ self.lat = np.asarray(lat, dtype=np.float64)
+ self.thetao = np.asarray(thetao, dtype=np.float64)
if isinstance(h, str):
if L is not None:
@@ -97,7 +97,7 @@ def __init__(self, h, T=None, L=None, thetao=None, Ho=None, lat=None):
elif h == "shallow":
self.h = self.L * 0.05
else:
- self.h = np.asarray(h, dtype=np.float)
+ self.h = np.asarray(h, dtype=np.float64)
if lat is None:
g = 9.81 # Default gravity.
@@ -106,13 +106,13 @@ def __init__(self, h, T=None, L=None, thetao=None, Ho=None, lat=None):
if L is None:
self.omega = 2 * np.pi / self.T
- self.Lo = (g * self.T ** 2) / 2 / np.pi
+ self.Lo = (g * self.T**2) / 2 / np.pi
# Returns wavenumber of the gravity wave dispersion relation using
# newtons method. The initial guess is shallow water wavenumber.
self.k = self.omega / np.sqrt(g)
# TODO: May change to,
# self.k = self.w ** 2 / (g * np.sqrt(self.w ** 2 * self.h / g))
- f = g * self.k * np.tanh(self.k * self.h) - self.omega ** 2
+ f = g * self.k * np.tanh(self.k * self.h) - self.omega**2
while np.abs(f.max()) > 1e-10:
dfdk = g * self.k * self.h * (
@@ -120,7 +120,7 @@ def __init__(self, h, T=None, L=None, thetao=None, Ho=None, lat=None):
) ** 2 + g * np.tanh(self.k * self.h)
self.k = self.k - f / dfdk
# FIXME:
- f = g * self.k * np.tanh(self.k * self.h) - self.omega ** 2
+ f = g * self.k * np.tanh(self.k * self.h) - self.omega**2
self.L = 2 * np.pi / self.k
if isinstance(h, str):
diff --git a/oceans/synop.py b/oceans/synop.py
index dfbfaed..cddbf52 100644
--- a/oceans/synop.py
+++ b/oceans/synop.py
@@ -28,7 +28,7 @@ def scaloa(xc, yc, x, y, t=None, corrlen=None, err=None, zc=None):
Notes
-----
- The funcion `scaloa` assumes that the user knows `err` and `corrlen` or
+ The function `scaloa` assumes that the user knows `err` and `corrlen` or
that these parameters where chosen arbitrary. The usual guess are the
first baroclinic Rossby radius for `corrlen` and 0.1 e 0.2 to the sampling
error.
@@ -53,12 +53,12 @@ def scaloa(xc, yc, x, y, t=None, corrlen=None, err=None, zc=None):
# Correlation matrix between stations (A) and cross correlation (stations
# and grid points (C)).
- A = (1 - err) * np.exp(-d2 / corrlen ** 2)
- C = (1 - err) * np.exp(-dc2 / corrlen ** 2)
+ A = (1 - err) * np.exp(-d2 / corrlen**2)
+ C = (1 - err) * np.exp(-dc2 / corrlen**2)
if 0: # NOTE: If the parameter zc is used (`scaloa2.m`)
- A = (1 - d2 / zc ** 2) * np.exp(-d2 / corrlen ** 2)
- C = (1 - dc2 / zc ** 2) * np.exp(-dc2 / corrlen ** 2)
+ A = (1 - d2 / zc**2) * np.exp(-d2 / corrlen**2)
+ C = (1 - dc2 / zc**2) * np.exp(-dc2 / corrlen**2)
# Add the diagonal matrix associated with the sampling error. We use the
# diagonal because the error is assumed to be random. This means it just
diff --git a/pyproject.toml b/pyproject.toml
new file mode 100644
index 0000000..3b93b06
--- /dev/null
+++ b/pyproject.toml
@@ -0,0 +1,93 @@
+[build-system]
+build-backend = "setuptools.build_meta"
+requires = [
+ "setuptools>=42",
+ "setuptools_scm[toml]>=3.4",
+ "wheel",
+]
+
+[project]
+name = "oceans"
+description = "Misc functions for oceanographic data analysis"
+readme = "README.md"
+license = {file = "LICENSE.txt"}
+authors = [
+ {name = "André Palóczy, Arnaldo Russo, Filipe Fernandes"},
+]
+requires-python = ">=3.8"
+dynamic = [
+ "version",
+]
+dependencies = [
+ "contourpy",
+ "gsw",
+ "matplotlib>=3.6",
+ "numpy>=1.20",
+ "pandas>=1.0.1",
+ "seawater",
+]
+[project.optional-dependencies]
+extras = [
+ "cartopy",
+ "iris",
+ "netcdf4",
+ "pandas",
+ "scipy",
+]
+[project.urls]
+documentation = "https://pyoceans.github.io/python-oceans/"
+homepage = "https://pypi.python.org/pypi/oceans/"
+repository = "https://github.com/pyoceans/python-oceans"
+
+[tool.setuptools]
+packages = ["oceans"]
+zip-safe = false
+include-package-data = true
+
+[tool.setuptools.package-data]
+oceans = ["colormaps/cmap_data/*.dat"]
+
+[tool.setuptools_scm]
+write_to = "oceans/_version.py"
+write_to_template = "__version__ = '{version}'"
+
+[tool.pytest.ini_options]
+markers = [
+ "web: marks tests require connection (deselect with '-m \"not web\"')"
+ ]
+
+[tool.ruff]
+select = [
+ "F", # flakes
+ "I", # import sorting
+ "U", # upgrade
+]
+target-version = "py311"
+line-length = 79
+
+[tool.ruff.per-file-ignores]
+"docs/conf.py" = ["E402"]
+
+[tool.interrogate]
+ignore-init-method = true
+ignore-init-module = false
+ignore-magic = false
+ignore-semiprivate = false
+ignore-private = false
+ignore-module = false
+fail-under = 95
+exclude = ["setup.py", "docs", "tests"]
+verbose = 1
+quiet = false
+color = true
+
+[tool.check-manifest]
+ignore = [
+ ".coveragerc",
+ "docs",
+ "docs/*",
+ "notebooks",
+ "notebooks/*",
+ "tests",
+ "tests/*",
+]
diff --git a/requirements-dev.txt b/requirements-dev.txt
index 96ac253..4a68520 100644
--- a/requirements-dev.txt
+++ b/requirements-dev.txt
@@ -1,21 +1,12 @@
black
cartopy
check-manifest
-doctr
-flake8
-flake8-builtins
-flake8-comprehensions
-flake8-mutable
iris
-isort
nbsphinx
netcdf4
pandas
-pylint
-pytest
pytest
pytest-cov
-pytest-flake8
pytest-xdist
scipy
sphinx
diff --git a/requirements.txt b/requirements.txt
index d2f7363..9675995 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,5 +1,6 @@
+contourpy
gsw
-matplotlib
-numpy
+matplotlib>=3.6.0
+numpy>=1.20
pandas>=1.0.1
seawater
diff --git a/setup.cfg b/setup.cfg
deleted file mode 100644
index 744e698..0000000
--- a/setup.cfg
+++ /dev/null
@@ -1,33 +0,0 @@
-
-# See the docstring in versioneer.py for instructions. Note that you must
-# re-run 'versioneer.py setup' after changing this section, and commit the
-# resulting files.
-
-[versioneer]
-VCS = git
-style = pep440
-versionfile_source = oceans/_version.py
-versionfile_build = oceans/_version.py
-tag_prefix = v
-parentdir_prefix =
-
-[tool:pytest]
-markers =
- web: marks tests require connection (deselect with '-m "not web"')
-
-[metadata]
-description-file = README.rst
-license_file = LICENSE.txt
-
-[check-manifest]
-ignore =
- .travis.yml
- .coveragerc
- Makefile
- docs
- docs/*
- *.enc
- notebooks
- notebooks/*
- tests
- tests/*
diff --git a/setup.py b/setup.py
deleted file mode 100644
index c8bce78..0000000
--- a/setup.py
+++ /dev/null
@@ -1,59 +0,0 @@
-import os
-
-from setuptools import find_packages, setup
-
-import versioneer
-
-rootpath = os.path.abspath(os.path.dirname(__file__))
-
-
-def read(*parts):
- return open(os.path.join(rootpath, *parts)).read()
-
-
-email = "ocefpaf@gmail.com"
-maintainer = "Filipe Fernandes"
-authors = ["André Palóczy", "Arnaldo Russo", "Filipe Fernandes"]
-
-# Dependencies.
-hard = ["gsw", "matplotlib", "numpy", "seawater"]
-soft = {"full": ["cartopy", "iris", "netcdf4", "pandas", "scipy"]}
-
-setup(
- name="oceans",
- version=versioneer.get_version(),
- cmdclass=versioneer.get_cmdclass(),
- packages=find_packages(),
- package_data={"oceans": ["colormaps/cmap_data/*.dat"]},
- license="BSD-3-Clause",
- long_description=f'{read("README.md")}',
- long_description_content_type="text/markdown",
- classifiers=[
- "Development Status :: 4 - Beta",
- "Environment :: Console",
- "Intended Audience :: Science/Research",
- "Intended Audience :: Developers",
- "Intended Audience :: Education",
- "License :: OSI Approved :: BSD License",
- "Operating System :: OS Independent",
- "Programming Language :: Python",
- "Topic :: Education",
- "Topic :: Scientific/Engineering",
- "Programming Language :: Python :: 3 :: Only",
- "Programming Language :: Python :: 3.6",
- "Programming Language :: Python :: 3.7",
- "Programming Language :: Python :: 3.8",
- ],
- description="Misc functions for oceanographic data analysis",
- author=authors,
- author_email=email,
- maintainer="Filipe Fernandes",
- maintainer_email=email,
- url="https://pypi.python.org/pypi/oceans/",
- platforms="any",
- keywords=["oceanography", "data analysis"],
- extras_require=soft,
- install_requires=hard,
- python_requires=">=3.6",
- tests_require=["pytest"],
-)
diff --git a/versioneer.py b/versioneer.py
deleted file mode 100644
index ffc686b..0000000
--- a/versioneer.py
+++ /dev/null
@@ -1,1886 +0,0 @@
-# Version: 0.18
-
-"""The Versioneer - like a rocketeer, but for versions.
-
-The Versioneer
-==============
-
-* like a rocketeer, but for versions!
-* https://github.com/warner/python-versioneer
-* Brian Warner
-* License: Public Domain
-* Compatible With: python2.6, 2.7, 3.2, 3.3, 3.4, 3.5, 3.6, and pypy
-* [![Latest Version]
-(https://pypip.in/version/versioneer/badge.svg?style=flat)
-](https://pypi.python.org/pypi/versioneer/)
-* [![Build Status]
-(https://travis-ci.org/warner/python-versioneer.png?branch=master)
-](https://travis-ci.org/warner/python-versioneer)
-
-This is a tool for managing a recorded version number in distutils-based
-python projects. The goal is to remove the tedious and error-prone "update
-the embedded version string" step from your release process. Making a new
-release should be as easy as recording a new tag in your version-control
-system, and maybe making new tarballs.
-
-
-## Quick Install
-
-* `pip install versioneer` to somewhere to your $PATH
-* add a `[versioneer]` section to your setup.cfg (see below)
-* run `versioneer install` in your source tree, commit the results
-
-## Version Identifiers
-
-Source trees come from a variety of places:
-
-* a version-control system checkout (mostly used by developers)
-* a nightly tarball, produced by build automation
-* a snapshot tarball, produced by a web-based VCS browser, like github's
- "tarball from tag" feature
-* a release tarball, produced by "setup.py sdist", distributed through PyPI
-
-Within each source tree, the version identifier (either a string or a number,
-this tool is format-agnostic) can come from a variety of places:
-
-* ask the VCS tool itself, e.g. "git describe" (for checkouts), which knows
- about recent "tags" and an absolute revision-id
-* the name of the directory into which the tarball was unpacked
-* an expanded VCS keyword ($Id$, etc)
-* a `_version.py` created by some earlier build step
-
-For released software, the version identifier is closely related to a VCS
-tag. Some projects use tag names that include more than just the version
-string (e.g. "myproject-1.2" instead of just "1.2"), in which case the tool
-needs to strip the tag prefix to extract the version identifier. For
-unreleased software (between tags), the version identifier should provide
-enough information to help developers recreate the same tree, while also
-giving them an idea of roughly how old the tree is (after version 1.2, before
-version 1.3). Many VCS systems can report a description that captures this,
-for example `git describe --tags --dirty --always` reports things like
-"0.7-1-g574ab98-dirty" to indicate that the checkout is one revision past the
-0.7 tag, has a unique revision id of "574ab98", and is "dirty" (it has
-uncommitted changes.
-
-The version identifier is used for multiple purposes:
-
-* to allow the module to self-identify its version: `myproject.__version__`
-* to choose a name and prefix for a 'setup.py sdist' tarball
-
-## Theory of Operation
-
-Versioneer works by adding a special `_version.py` file into your source
-tree, where your `__init__.py` can import it. This `_version.py` knows how to
-dynamically ask the VCS tool for version information at import time.
-
-`_version.py` also contains `$Revision$` markers, and the installation
-process marks `_version.py` to have this marker rewritten with a tag name
-during the `git archive` command. As a result, generated tarballs will
-contain enough information to get the proper version.
-
-To allow `setup.py` to compute a version too, a `versioneer.py` is added to
-the top level of your source tree, next to `setup.py` and the `setup.cfg`
-that configures it. This overrides several distutils/setuptools commands to
-compute the version when invoked, and changes `setup.py build` and `setup.py
-sdist` to replace `_version.py` with a small static file that contains just
-the generated version data.
-
-## Installation
-
-See [INSTALL.md](./INSTALL.md) for detailed installation instructions.
-
-## Version-String Flavors
-
-Code which uses Versioneer can learn about its version string at runtime by
-importing `_version` from your main `__init__.py` file and running the
-`get_versions()` function. From the "outside" (e.g. in `setup.py`), you can
-import the top-level `versioneer.py` and run `get_versions()`.
-
-Both functions return a dictionary with different flavors of version
-information:
-
-* `['version']`: A condensed version string, rendered using the selected
- style. This is the most commonly used value for the project's version
- string. The default "pep440" style yields strings like `0.11`,
- `0.11+2.g1076c97`, or `0.11+2.g1076c97.dirty`. See the "Styles" section
- below for alternative styles.
-
-* `['full-revisionid']`: detailed revision identifier. For Git, this is the
- full SHA1 commit id, e.g. "1076c978a8d3cfc70f408fe5974aa6c092c949ac".
-
-* `['date']`: Date and time of the latest `HEAD` commit. For Git, it is the
- commit date in ISO 8601 format. This will be None if the date is not
- available.
-
-* `['dirty']`: a boolean, True if the tree has uncommitted changes. Note that
- this is only accurate if run in a VCS checkout, otherwise it is likely to
- be False or None
-
-* `['error']`: if the version string could not be computed, this will be set
- to a string describing the problem, otherwise it will be None. It may be
- useful to throw an exception in setup.py if this is set, to avoid e.g.
- creating tarballs with a version string of "unknown".
-
-Some variants are more useful than others. Including `full-revisionid` in a
-bug report should allow developers to reconstruct the exact code being tested
-(or indicate the presence of local changes that should be shared with the
-developers). `version` is suitable for display in an "about" box or a CLI
-`--version` output: it can be easily compared against release notes and lists
-of bugs fixed in various releases.
-
-The installer adds the following text to your `__init__.py` to place a basic
-version in `YOURPROJECT.__version__`:
-
- from ._version import get_versions
- __version__ = get_versions()['version']
- del get_versions
-
-## Styles
-
-The setup.cfg `style=` configuration controls how the VCS information is
-rendered into a version string.
-
-The default style, "pep440", produces a PEP440-compliant string, equal to the
-un-prefixed tag name for actual releases, and containing an additional "local
-version" section with more detail for in-between builds. For Git, this is
-TAG[+DISTANCE.gHEX[.dirty]] , using information from `git describe --tags
---dirty --always`. For example "0.11+2.g1076c97.dirty" indicates that the
-tree is like the "1076c97" commit but has uncommitted changes (".dirty"), and
-that this commit is two revisions ("+2") beyond the "0.11" tag. For released
-software (exactly equal to a known tag), the identifier will only contain the
-stripped tag, e.g. "0.11".
-
-Other styles are available. See [details.md](details.md) in the Versioneer
-source tree for descriptions.
-
-## Debugging
-
-Versioneer tries to avoid fatal errors: if something goes wrong, it will tend
-to return a version of "0+unknown". To investigate the problem, run `setup.py
-version`, which will run the version-lookup code in a verbose mode, and will
-display the full contents of `get_versions()` (including the `error` string,
-which may help identify what went wrong).
-
-## Known Limitations
-
-Some situations are known to cause problems for Versioneer. This details the
-most significant ones. More can be found on Github
-[issues page](https://github.com/warner/python-versioneer/issues).
-
-### Subprojects
-
-Versioneer has limited support for source trees in which `setup.py` is not in
-the root directory (e.g. `setup.py` and `.git/` are *not* siblings). The are
-two common reasons why `setup.py` might not be in the root:
-
-* Source trees which contain multiple subprojects, such as
- [Buildbot](https://github.com/buildbot/buildbot), which contains both
- "master" and "slave" subprojects, each with their own `setup.py`,
- `setup.cfg`, and `tox.ini`. Projects like these produce multiple PyPI
- distributions (and upload multiple independently-installable tarballs).
-* Source trees whose main purpose is to contain a C library, but which also
- provide bindings to Python (and perhaps other langauges) in subdirectories.
-
-Versioneer will look for `.git` in parent directories, and most operations
-should get the right version string. However `pip` and `setuptools` have bugs
-and implementation details which frequently cause `pip install .` from a
-subproject directory to fail to find a correct version string (so it usually
-defaults to `0+unknown`).
-
-`pip install --editable .` should work correctly. `setup.py install` might
-work too.
-
-Pip-8.1.1 is known to have this problem, but hopefully it will get fixed in
-some later version.
-
-[Bug #38](https://github.com/warner/python-versioneer/issues/38) is tracking
-this issue. The discussion in
-[PR #61](https://github.com/warner/python-versioneer/pull/61) describes the
-issue from the Versioneer side in more detail.
-[pip PR#3176](https://github.com/pypa/pip/pull/3176) and
-[pip PR#3615](https://github.com/pypa/pip/pull/3615) contain work to improve
-pip to let Versioneer work correctly.
-
-Versioneer-0.16 and earlier only looked for a `.git` directory next to the
-`setup.cfg`, so subprojects were completely unsupported with those releases.
-
-### Editable installs with setuptools <= 18.5
-
-`setup.py develop` and `pip install --editable .` allow you to install a
-project into a virtualenv once, then continue editing the source code (and
-test) without re-installing after every change.
-
-"Entry-point scripts" (`setup(entry_points={"console_scripts": ..})`) are a
-convenient way to specify executable scripts that should be installed along
-with the python package.
-
-These both work as expected when using modern setuptools. When using
-setuptools-18.5 or earlier, however, certain operations will cause
-`pkg_resources.DistributionNotFound` errors when running the entrypoint
-script, which must be resolved by re-installing the package. This happens
-when the install happens with one version, then the egg_info data is
-regenerated while a different version is checked out. Many setup.py commands
-cause egg_info to be rebuilt (including `sdist`, `wheel`, and installing into
-a different virtualenv), so this can be surprising.
-
-[Bug #83](https://github.com/warner/python-versioneer/issues/83) describes
-this one, but upgrading to a newer version of setuptools should probably
-resolve it.
-
-### Unicode version strings
-
-While Versioneer works (and is continually tested) with both Python 2 and
-Python 3, it is not entirely consistent with bytes-vs-unicode distinctions.
-Newer releases probably generate unicode version strings on py2. It's not
-clear that this is wrong, but it may be surprising for applications when then
-write these strings to a network connection or include them in bytes-oriented
-APIs like cryptographic checksums.
-
-[Bug #71](https://github.com/warner/python-versioneer/issues/71) investigates
-this question.
-
-
-## Updating Versioneer
-
-To upgrade your project to a new release of Versioneer, do the following:
-
-* install the new Versioneer (`pip install -U versioneer` or equivalent)
-* edit `setup.cfg`, if necessary, to include any new configuration settings
- indicated by the release notes. See [UPGRADING](./UPGRADING.md) for details.
-* re-run `versioneer install` in your source tree, to replace
- `SRC/_version.py`
-* commit any changed files
-
-## Future Directions
-
-This tool is designed to make it easily extended to other version-control
-systems: all VCS-specific components are in separate directories like
-src/git/ . The top-level `versioneer.py` script is assembled from these
-components by running make-versioneer.py . In the future, make-versioneer.py
-will take a VCS name as an argument, and will construct a version of
-`versioneer.py` that is specific to the given VCS. It might also take the
-configuration arguments that are currently provided manually during
-installation by editing setup.py . Alternatively, it might go the other
-direction and include code from all supported VCS systems, reducing the
-number of intermediate scripts.
-
-
-## License
-
-To make Versioneer easier to embed, all its code is dedicated to the public
-domain. The `_version.py` that it creates is also in the public domain.
-Specifically, both are released under the Creative Commons "Public Domain
-Dedication" license (CC0-1.0), as described in
-https://creativecommons.org/publicdomain/zero/1.0/ .
-
-"""
-
-
-import errno
-import json
-import os
-import re
-import subprocess
-import sys
-
-try:
- import configparser
-except ImportError:
- import ConfigParser as configparser
-
-
-class VersioneerConfig:
- """Container for Versioneer configuration parameters."""
-
-
-def get_root():
- """Get the project root directory.
-
- We require that all commands are run from the project root, i.e. the
- directory that contains setup.py, setup.cfg, and versioneer.py .
- """
- root = os.path.realpath(os.path.abspath(os.getcwd()))
- setup_py = os.path.join(root, "setup.py")
- versioneer_py = os.path.join(root, "versioneer.py")
- if not (os.path.exists(setup_py) or os.path.exists(versioneer_py)):
- # allow 'python path/to/setup.py COMMAND'
- root = os.path.dirname(os.path.realpath(os.path.abspath(sys.argv[0])))
- setup_py = os.path.join(root, "setup.py")
- versioneer_py = os.path.join(root, "versioneer.py")
- if not (os.path.exists(setup_py) or os.path.exists(versioneer_py)):
- err = (
- "Versioneer was unable to run the project root directory. "
- "Versioneer requires setup.py to be executed from "
- "its immediate directory (like 'python setup.py COMMAND'), "
- "or in a way that lets it use sys.argv[0] to find the root "
- "(like 'python path/to/setup.py COMMAND')."
- )
- raise VersioneerBadRootError(err)
- try:
- # Certain runtime workflows (setup.py install/develop in a setuptools
- # tree) execute all dependencies in a single python process, so
- # "versioneer" may be imported multiple times, and python's shared
- # module-import table will cache the first one. So we can't use
- # os.path.dirname(__file__), as that will find whichever
- # versioneer.py was first imported, even in later projects.
- me = os.path.realpath(os.path.abspath(__file__))
- me_dir = os.path.normcase(os.path.splitext(me)[0])
- vsr_dir = os.path.normcase(os.path.splitext(versioneer_py)[0])
- if me_dir != vsr_dir:
- print(
- "Warning: build in %s is using versioneer.py from %s"
- % (os.path.dirname(me), versioneer_py),
- )
- except NameError:
- pass
- return root
-
-
-def get_config_from_root(root):
- """Read the project setup.cfg file to determine Versioneer config."""
- # This might raise EnvironmentError (if setup.cfg is missing), or
- # configparser.NoSectionError (if it lacks a [versioneer] section), or
- # configparser.NoOptionError (if it lacks "VCS="). See the docstring at
- # the top of versioneer.py for instructions on writing your setup.cfg .
- setup_cfg = os.path.join(root, "setup.cfg")
- parser = configparser.SafeConfigParser()
- with open(setup_cfg) as f:
- parser.readfp(f)
- VCS = parser.get("versioneer", "VCS") # mandatory
-
- def get(parser, name):
- if parser.has_option("versioneer", name):
- return parser.get("versioneer", name)
- return None
-
- cfg = VersioneerConfig()
- cfg.VCS = VCS
- cfg.style = get(parser, "style") or ""
- cfg.versionfile_source = get(parser, "versionfile_source")
- cfg.versionfile_build = get(parser, "versionfile_build")
- cfg.tag_prefix = get(parser, "tag_prefix")
- if cfg.tag_prefix in ("''", '""'):
- cfg.tag_prefix = ""
- cfg.parentdir_prefix = get(parser, "parentdir_prefix")
- cfg.verbose = get(parser, "verbose")
- return cfg
-
-
-class NotThisMethod(Exception):
- """Exception raised if a method is not valid for the current scenario."""
-
-
-# these dictionaries contain VCS-specific tools
-LONG_VERSION_PY = {}
-HANDLERS = {}
-
-
-def register_vcs_handler(vcs, method): # decorator
- """Decorator to mark a method as the handler for a particular VCS."""
-
- def decorate(f):
- """Store f in HANDLERS[vcs][method]."""
- if vcs not in HANDLERS:
- HANDLERS[vcs] = {}
- HANDLERS[vcs][method] = f
- return f
-
- return decorate
-
-
-def run_command(commands, args, cwd=None, verbose=False, hide_stderr=False, env=None):
- """Call the given command(s)."""
- assert isinstance(commands, list)
- p = None
- for c in commands:
- try:
- dispcmd = str([c] + args)
- # remember shell=False, so use git.cmd on windows, not just git
- p = subprocess.Popen(
- [c] + args,
- cwd=cwd,
- env=env,
- stdout=subprocess.PIPE,
- stderr=(subprocess.PIPE if hide_stderr else None),
- )
- break
- except OSError:
- e = sys.exc_info()[1]
- if e.errno == errno.ENOENT:
- continue
- if verbose:
- print("unable to run %s" % dispcmd)
- print(e)
- return None, None
- else:
- if verbose:
- print(f"unable to find command, tried {commands}")
- return None, None
- stdout = p.communicate()[0].strip()
- if sys.version_info[0] >= 3:
- stdout = stdout.decode()
- if p.returncode != 0:
- if verbose:
- print("unable to run %s (error)" % dispcmd)
- print("stdout was %s" % stdout)
- return None, p.returncode
- return stdout, p.returncode
-
-
-LONG_VERSION_PY[
- "git"
-] = r'''
-# This file helps to compute a version number in source trees obtained from
-# git-archive tarball (such as those provided by githubs download-from-tag
-# feature). Distribution tarballs (built by setup.py sdist) and build
-# directories (produced by setup.py build) will contain a much shorter file
-# that just contains the computed version number.
-
-# This file is released into the public domain. Generated by
-# versioneer-0.18 (https://github.com/warner/python-versioneer)
-
-"""Git implementation of _version.py."""
-
-import errno
-import os
-import re
-import subprocess
-import sys
-
-
-def get_keywords():
- """Get the keywords needed to look up the version information."""
- # these strings will be replaced by git during git-archive.
- # setup.py/versioneer.py will grep for the variable names, so they must
- # each be defined on a line of their own. _version.py will just call
- # get_keywords().
- git_refnames = "%(DOLLAR)sFormat:%%d%(DOLLAR)s"
- git_full = "%(DOLLAR)sFormat:%%H%(DOLLAR)s"
- git_date = "%(DOLLAR)sFormat:%%ci%(DOLLAR)s"
- keywords = {"refnames": git_refnames, "full": git_full, "date": git_date}
- return keywords
-
-
-class VersioneerConfig:
- """Container for Versioneer configuration parameters."""
-
-
-def get_config():
- """Create, populate and return the VersioneerConfig() object."""
- # these strings are filled in when 'setup.py versioneer' creates
- # _version.py
- cfg = VersioneerConfig()
- cfg.VCS = "git"
- cfg.style = "%(STYLE)s"
- cfg.tag_prefix = "%(TAG_PREFIX)s"
- cfg.parentdir_prefix = "%(PARENTDIR_PREFIX)s"
- cfg.versionfile_source = "%(VERSIONFILE_SOURCE)s"
- cfg.verbose = False
- return cfg
-
-
-class NotThisMethod(Exception):
- """Exception raised if a method is not valid for the current scenario."""
-
-
-LONG_VERSION_PY = {}
-HANDLERS = {}
-
-
-def register_vcs_handler(vcs, method): # decorator
- """Decorator to mark a method as the handler for a particular VCS."""
- def decorate(f):
- """Store f in HANDLERS[vcs][method]."""
- if vcs not in HANDLERS:
- HANDLERS[vcs] = {}
- HANDLERS[vcs][method] = f
- return f
- return decorate
-
-
-def run_command(commands, args, cwd=None, verbose=False, hide_stderr=False,
- env=None):
- """Call the given command(s)."""
- assert isinstance(commands, list)
- p = None
- for c in commands:
- try:
- dispcmd = str([c] + args)
- # remember shell=False, so use git.cmd on windows, not just git
- p = subprocess.Popen([c] + args, cwd=cwd, env=env,
- stdout=subprocess.PIPE,
- stderr=(subprocess.PIPE if hide_stderr
- else None))
- break
- except EnvironmentError:
- e = sys.exc_info()[1]
- if e.errno == errno.ENOENT:
- continue
- if verbose:
- print("unable to run %%s" %% dispcmd)
- print(e)
- return None, None
- else:
- if verbose:
- print("unable to find command, tried %%s" %% (commands,))
- return None, None
- stdout = p.communicate()[0].strip()
- if sys.version_info[0] >= 3:
- stdout = stdout.decode()
- if p.returncode != 0:
- if verbose:
- print("unable to run %%s (error)" %% dispcmd)
- print("stdout was %%s" %% stdout)
- return None, p.returncode
- return stdout, p.returncode
-
-
-def versions_from_parentdir(parentdir_prefix, root, verbose):
- """Try to determine the version from the parent directory name.
-
- Source tarballs conventionally unpack into a directory that includes both
- the project name and a version string. We will also support searching up
- two directory levels for an appropriately named parent directory
- """
- rootdirs = []
-
- for i in range(3):
- dirname = os.path.basename(root)
- if dirname.startswith(parentdir_prefix):
- return {"version": dirname[len(parentdir_prefix):],
- "full-revisionid": None,
- "dirty": False, "error": None, "date": None}
- else:
- rootdirs.append(root)
- root = os.path.dirname(root) # up a level
-
- if verbose:
- print("Tried directories %%s but none started with prefix %%s" %%
- (str(rootdirs), parentdir_prefix))
- raise NotThisMethod("rootdir doesn't start with parentdir_prefix")
-
-
-@register_vcs_handler("git", "get_keywords")
-def git_get_keywords(versionfile_abs):
- """Extract version information from the given file."""
- # the code embedded in _version.py can just fetch the value of these
- # keywords. When used from setup.py, we don't want to import _version.py,
- # so we do it with a regexp instead. This function is not used from
- # _version.py.
- keywords = {}
- try:
- f = open(versionfile_abs, "r")
- for line in f.readlines():
- if line.strip().startswith("git_refnames ="):
- mo = re.search(r'=\s*"(.*)"', line)
- if mo:
- keywords["refnames"] = mo.group(1)
- if line.strip().startswith("git_full ="):
- mo = re.search(r'=\s*"(.*)"', line)
- if mo:
- keywords["full"] = mo.group(1)
- if line.strip().startswith("git_date ="):
- mo = re.search(r'=\s*"(.*)"', line)
- if mo:
- keywords["date"] = mo.group(1)
- f.close()
- except EnvironmentError:
- pass
- return keywords
-
-
-@register_vcs_handler("git", "keywords")
-def git_versions_from_keywords(keywords, tag_prefix, verbose):
- """Get version information from git keywords."""
- if not keywords:
- raise NotThisMethod("no keywords at all, weird")
- date = keywords.get("date")
- if date is not None:
- # git-2.2.0 added "%%cI", which expands to an ISO-8601 -compliant
- # datestamp. However we prefer "%%ci" (which expands to an "ISO-8601
- # -like" string, which we must then edit to make compliant), because
- # it's been around since git-1.5.3, and it's too difficult to
- # discover which version we're using, or to work around using an
- # older one.
- date = date.strip().replace(" ", "T", 1).replace(" ", "", 1)
- refnames = keywords["refnames"].strip()
- if refnames.startswith("$Format"):
- if verbose:
- print("keywords are unexpanded, not using")
- raise NotThisMethod("unexpanded keywords, not a git-archive tarball")
- refs = set([r.strip() for r in refnames.strip("()").split(",")])
- # starting in git-1.8.3, tags are listed as "tag: foo-1.0" instead of
- # just "foo-1.0". If we see a "tag: " prefix, prefer those.
- TAG = "tag: "
- tags = set([r[len(TAG):] for r in refs if r.startswith(TAG)])
- if not tags:
- # Either we're using git < 1.8.3, or there really are no tags. We use
- # a heuristic: assume all version tags have a digit. The old git %%d
- # expansion behaves like git log --decorate=short and strips out the
- # refs/heads/ and refs/tags/ prefixes that would let us distinguish
- # between branches and tags. By ignoring refnames without digits, we
- # filter out many common branch names like "release" and
- # "stabilization", as well as "HEAD" and "master".
- tags = set([r for r in refs if re.search(r'\d', r)])
- if verbose:
- print("discarding '%%s', no digits" %% ",".join(refs - tags))
- if verbose:
- print("likely tags: %%s" %% ",".join(sorted(tags)))
- for ref in sorted(tags):
- # sorting will prefer e.g. "2.0" over "2.0rc1"
- if ref.startswith(tag_prefix):
- r = ref[len(tag_prefix):]
- if verbose:
- print("picking %%s" %% r)
- return {"version": r,
- "full-revisionid": keywords["full"].strip(),
- "dirty": False, "error": None,
- "date": date}
- # no suitable tags, so version is "0+unknown", but full hex is still there
- if verbose:
- print("no suitable tags, using unknown + full revision id")
- return {"version": "0+unknown",
- "full-revisionid": keywords["full"].strip(),
- "dirty": False, "error": "no suitable tags", "date": None}
-
-
-@register_vcs_handler("git", "pieces_from_vcs")
-def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command):
- """Get version from 'git describe' in the root of the source tree.
-
- This only gets called if the git-archive 'subst' keywords were *not*
- expanded, and _version.py hasn't already been rewritten with a short
- version string, meaning we're inside a checked out source tree.
- """
- GITS = ["git"]
- if sys.platform == "win32":
- GITS = ["git.cmd", "git.exe"]
-
- out, rc = run_command(GITS, ["rev-parse", "--git-dir"], cwd=root,
- hide_stderr=True)
- if rc != 0:
- if verbose:
- print("Directory %%s not under git control" %% root)
- raise NotThisMethod("'git rev-parse --git-dir' returned error")
-
- # if there is a tag matching tag_prefix, this yields TAG-NUM-gHEX[-dirty]
- # if there isn't one, this yields HEX[-dirty] (no NUM)
- describe_out, rc = run_command(GITS, ["describe", "--tags", "--dirty",
- "--always", "--long",
- "--match", "%%s*" %% tag_prefix],
- cwd=root)
- # --long was added in git-1.5.5
- if describe_out is None:
- raise NotThisMethod("'git describe' failed")
- describe_out = describe_out.strip()
- full_out, rc = run_command(GITS, ["rev-parse", "HEAD"], cwd=root)
- if full_out is None:
- raise NotThisMethod("'git rev-parse' failed")
- full_out = full_out.strip()
-
- pieces = {}
- pieces["long"] = full_out
- pieces["short"] = full_out[:7] # maybe improved later
- pieces["error"] = None
-
- # parse describe_out. It will be like TAG-NUM-gHEX[-dirty] or HEX[-dirty]
- # TAG might have hyphens.
- git_describe = describe_out
-
- # look for -dirty suffix
- dirty = git_describe.endswith("-dirty")
- pieces["dirty"] = dirty
- if dirty:
- git_describe = git_describe[:git_describe.rindex("-dirty")]
-
- # now we have TAG-NUM-gHEX or HEX
-
- if "-" in git_describe:
- # TAG-NUM-gHEX
- mo = re.search(r'^(.+)-(\d+)-g([0-9a-f]+)$', git_describe)
- if not mo:
- # unparseable. Maybe git-describe is misbehaving?
- pieces["error"] = ("unable to parse git-describe output: '%%s'"
- %% describe_out)
- return pieces
-
- # tag
- full_tag = mo.group(1)
- if not full_tag.startswith(tag_prefix):
- if verbose:
- fmt = "tag '%%s' doesn't start with prefix '%%s'"
- print(fmt %% (full_tag, tag_prefix))
- pieces["error"] = ("tag '%%s' doesn't start with prefix '%%s'"
- %% (full_tag, tag_prefix))
- return pieces
- pieces["closest-tag"] = full_tag[len(tag_prefix):]
-
- # distance: number of commits since tag
- pieces["distance"] = int(mo.group(2))
-
- # commit: short hex revision ID
- pieces["short"] = mo.group(3)
-
- else:
- # HEX: no tags
- pieces["closest-tag"] = None
- count_out, rc = run_command(GITS, ["rev-list", "HEAD", "--count"],
- cwd=root)
- pieces["distance"] = int(count_out) # total number of commits
-
- # commit date: see ISO-8601 comment in git_versions_from_keywords()
- date = run_command(GITS, ["show", "-s", "--format=%%ci", "HEAD"],
- cwd=root)[0].strip()
- pieces["date"] = date.strip().replace(" ", "T", 1).replace(" ", "", 1)
-
- return pieces
-
-
-def plus_or_dot(pieces):
- """Return a + if we don't already have one, else return a ."""
- if "+" in pieces.get("closest-tag", ""):
- return "."
- return "+"
-
-
-def render_pep440(pieces):
- """Build up version string, with post-release "local version identifier".
-
- Our goal: TAG[+DISTANCE.gHEX[.dirty]] . Note that if you
- get a tagged build and then dirty it, you'll get TAG+0.gHEX.dirty
-
- Exceptions:
- 1: no tags. git_describe was just HEX. 0+untagged.DISTANCE.gHEX[.dirty]
- """
- if pieces["closest-tag"]:
- rendered = pieces["closest-tag"]
- if pieces["distance"] or pieces["dirty"]:
- rendered += plus_or_dot(pieces)
- rendered += "%%d.g%%s" %% (pieces["distance"], pieces["short"])
- if pieces["dirty"]:
- rendered += ".dirty"
- else:
- # exception #1
- rendered = "0+untagged.%%d.g%%s" %% (pieces["distance"],
- pieces["short"])
- if pieces["dirty"]:
- rendered += ".dirty"
- return rendered
-
-
-def render_pep440_pre(pieces):
- """TAG[.post.devDISTANCE] -- No -dirty.
-
- Exceptions:
- 1: no tags. 0.post.devDISTANCE
- """
- if pieces["closest-tag"]:
- rendered = pieces["closest-tag"]
- if pieces["distance"]:
- rendered += ".post.dev%%d" %% pieces["distance"]
- else:
- # exception #1
- rendered = "0.post.dev%%d" %% pieces["distance"]
- return rendered
-
-
-def render_pep440_post(pieces):
- """TAG[.postDISTANCE[.dev0]+gHEX] .
-
- The ".dev0" means dirty. Note that .dev0 sorts backwards
- (a dirty tree will appear "older" than the corresponding clean one),
- but you shouldn't be releasing software with -dirty anyways.
-
- Exceptions:
- 1: no tags. 0.postDISTANCE[.dev0]
- """
- if pieces["closest-tag"]:
- rendered = pieces["closest-tag"]
- if pieces["distance"] or pieces["dirty"]:
- rendered += ".post%%d" %% pieces["distance"]
- if pieces["dirty"]:
- rendered += ".dev0"
- rendered += plus_or_dot(pieces)
- rendered += "g%%s" %% pieces["short"]
- else:
- # exception #1
- rendered = "0.post%%d" %% pieces["distance"]
- if pieces["dirty"]:
- rendered += ".dev0"
- rendered += "+g%%s" %% pieces["short"]
- return rendered
-
-
-def render_pep440_old(pieces):
- """TAG[.postDISTANCE[.dev0]] .
-
- The ".dev0" means dirty.
-
- Eexceptions:
- 1: no tags. 0.postDISTANCE[.dev0]
- """
- if pieces["closest-tag"]:
- rendered = pieces["closest-tag"]
- if pieces["distance"] or pieces["dirty"]:
- rendered += ".post%%d" %% pieces["distance"]
- if pieces["dirty"]:
- rendered += ".dev0"
- else:
- # exception #1
- rendered = "0.post%%d" %% pieces["distance"]
- if pieces["dirty"]:
- rendered += ".dev0"
- return rendered
-
-
-def render_git_describe(pieces):
- """TAG[-DISTANCE-gHEX][-dirty].
-
- Like 'git describe --tags --dirty --always'.
-
- Exceptions:
- 1: no tags. HEX[-dirty] (note: no 'g' prefix)
- """
- if pieces["closest-tag"]:
- rendered = pieces["closest-tag"]
- if pieces["distance"]:
- rendered += "-%%d-g%%s" %% (pieces["distance"], pieces["short"])
- else:
- # exception #1
- rendered = pieces["short"]
- if pieces["dirty"]:
- rendered += "-dirty"
- return rendered
-
-
-def render_git_describe_long(pieces):
- """TAG-DISTANCE-gHEX[-dirty].
-
- Like 'git describe --tags --dirty --always -long'.
- The distance/hash is unconditional.
-
- Exceptions:
- 1: no tags. HEX[-dirty] (note: no 'g' prefix)
- """
- if pieces["closest-tag"]:
- rendered = pieces["closest-tag"]
- rendered += "-%%d-g%%s" %% (pieces["distance"], pieces["short"])
- else:
- # exception #1
- rendered = pieces["short"]
- if pieces["dirty"]:
- rendered += "-dirty"
- return rendered
-
-
-def render(pieces, style):
- """Render the given version pieces into the requested style."""
- if pieces["error"]:
- return {"version": "unknown",
- "full-revisionid": pieces.get("long"),
- "dirty": None,
- "error": pieces["error"],
- "date": None}
-
- if not style or style == "default":
- style = "pep440" # the default
-
- if style == "pep440":
- rendered = render_pep440(pieces)
- elif style == "pep440-pre":
- rendered = render_pep440_pre(pieces)
- elif style == "pep440-post":
- rendered = render_pep440_post(pieces)
- elif style == "pep440-old":
- rendered = render_pep440_old(pieces)
- elif style == "git-describe":
- rendered = render_git_describe(pieces)
- elif style == "git-describe-long":
- rendered = render_git_describe_long(pieces)
- else:
- raise ValueError("unknown style '%%s'" %% style)
-
- return {"version": rendered, "full-revisionid": pieces["long"],
- "dirty": pieces["dirty"], "error": None,
- "date": pieces.get("date")}
-
-
-def get_versions():
- """Get version information or return default if unable to do so."""
- # I am in _version.py, which lives at ROOT/VERSIONFILE_SOURCE. If we have
- # __file__, we can work backwards from there to the root. Some
- # py2exe/bbfreeze/non-CPython implementations don't do __file__, in which
- # case we can only use expanded keywords.
-
- cfg = get_config()
- verbose = cfg.verbose
-
- try:
- return git_versions_from_keywords(get_keywords(), cfg.tag_prefix,
- verbose)
- except NotThisMethod:
- pass
-
- try:
- root = os.path.realpath(__file__)
- # versionfile_source is the relative path from the top of the source
- # tree (where the .git directory might live) to this file. Invert
- # this to find the root from __file__.
- for i in cfg.versionfile_source.split('/'):
- root = os.path.dirname(root)
- except NameError:
- return {"version": "0+unknown", "full-revisionid": None,
- "dirty": None,
- "error": "unable to find root of source tree",
- "date": None}
-
- try:
- pieces = git_pieces_from_vcs(cfg.tag_prefix, root, verbose)
- return render(pieces, cfg.style)
- except NotThisMethod:
- pass
-
- try:
- if cfg.parentdir_prefix:
- return versions_from_parentdir(cfg.parentdir_prefix, root, verbose)
- except NotThisMethod:
- pass
-
- return {"version": "0+unknown", "full-revisionid": None,
- "dirty": None,
- "error": "unable to compute version", "date": None}
-'''
-
-
-@register_vcs_handler("git", "get_keywords")
-def git_get_keywords(versionfile_abs):
- """Extract version information from the given file."""
- # the code embedded in _version.py can just fetch the value of these
- # keywords. When used from setup.py, we don't want to import _version.py,
- # so we do it with a regexp instead. This function is not used from
- # _version.py.
- keywords = {}
- try:
- f = open(versionfile_abs)
- for line in f.readlines():
- if line.strip().startswith("git_refnames ="):
- mo = re.search(r'=\s*"(.*)"', line)
- if mo:
- keywords["refnames"] = mo.group(1)
- if line.strip().startswith("git_full ="):
- mo = re.search(r'=\s*"(.*)"', line)
- if mo:
- keywords["full"] = mo.group(1)
- if line.strip().startswith("git_date ="):
- mo = re.search(r'=\s*"(.*)"', line)
- if mo:
- keywords["date"] = mo.group(1)
- f.close()
- except OSError:
- pass
- return keywords
-
-
-@register_vcs_handler("git", "keywords")
-def git_versions_from_keywords(keywords, tag_prefix, verbose):
- """Get version information from git keywords."""
- if not keywords:
- raise NotThisMethod("no keywords at all, weird")
- date = keywords.get("date")
- if date is not None:
- # git-2.2.0 added "%cI", which expands to an ISO-8601 -compliant
- # datestamp. However we prefer "%ci" (which expands to an "ISO-8601
- # -like" string, which we must then edit to make compliant), because
- # it's been around since git-1.5.3, and it's too difficult to
- # discover which version we're using, or to work around using an
- # older one.
- date = date.strip().replace(" ", "T", 1).replace(" ", "", 1)
- refnames = keywords["refnames"].strip()
- if refnames.startswith("$Format"):
- if verbose:
- print("keywords are unexpanded, not using")
- raise NotThisMethod("unexpanded keywords, not a git-archive tarball")
- refs = {r.strip() for r in refnames.strip("()").split(",")}
- # starting in git-1.8.3, tags are listed as "tag: foo-1.0" instead of
- # just "foo-1.0". If we see a "tag: " prefix, prefer those.
- TAG = "tag: "
- tags = {r[len(TAG) :] for r in refs if r.startswith(TAG)}
- if not tags:
- # Either we're using git < 1.8.3, or there really are no tags. We use
- # a heuristic: assume all version tags have a digit. The old git %d
- # expansion behaves like git log --decorate=short and strips out the
- # refs/heads/ and refs/tags/ prefixes that would let us distinguish
- # between branches and tags. By ignoring refnames without digits, we
- # filter out many common branch names like "release" and
- # "stabilization", as well as "HEAD" and "master".
- tags = {r for r in refs if re.search(r"\d", r)}
- if verbose:
- print("discarding '%s', no digits" % ",".join(refs - tags))
- if verbose:
- print("likely tags: %s" % ",".join(sorted(tags)))
- for ref in sorted(tags):
- # sorting will prefer e.g. "2.0" over "2.0rc1"
- if ref.startswith(tag_prefix):
- r = ref[len(tag_prefix) :]
- if verbose:
- print("picking %s" % r)
- return {
- "version": r,
- "full-revisionid": keywords["full"].strip(),
- "dirty": False,
- "error": None,
- "date": date,
- }
- # no suitable tags, so version is "0+unknown", but full hex is still there
- if verbose:
- print("no suitable tags, using unknown + full revision id")
- return {
- "version": "0+unknown",
- "full-revisionid": keywords["full"].strip(),
- "dirty": False,
- "error": "no suitable tags",
- "date": None,
- }
-
-
-@register_vcs_handler("git", "pieces_from_vcs")
-def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command):
- """Get version from 'git describe' in the root of the source tree.
-
- This only gets called if the git-archive 'subst' keywords were *not*
- expanded, and _version.py hasn't already been rewritten with a short
- version string, meaning we're inside a checked out source tree.
- """
- GITS = ["git"]
- if sys.platform == "win32":
- GITS = ["git.cmd", "git.exe"]
-
- out, rc = run_command(GITS, ["rev-parse", "--git-dir"], cwd=root, hide_stderr=True)
- if rc != 0:
- if verbose:
- print("Directory %s not under git control" % root)
- raise NotThisMethod("'git rev-parse --git-dir' returned error")
-
- # if there is a tag matching tag_prefix, this yields TAG-NUM-gHEX[-dirty]
- # if there isn't one, this yields HEX[-dirty] (no NUM)
- describe_out, rc = run_command(
- GITS,
- [
- "describe",
- "--tags",
- "--dirty",
- "--always",
- "--long",
- "--match",
- "%s*" % tag_prefix,
- ],
- cwd=root,
- )
- # --long was added in git-1.5.5
- if describe_out is None:
- raise NotThisMethod("'git describe' failed")
- describe_out = describe_out.strip()
- full_out, rc = run_command(GITS, ["rev-parse", "HEAD"], cwd=root)
- if full_out is None:
- raise NotThisMethod("'git rev-parse' failed")
- full_out = full_out.strip()
-
- pieces = {}
- pieces["long"] = full_out
- pieces["short"] = full_out[:7] # maybe improved later
- pieces["error"] = None
-
- # parse describe_out. It will be like TAG-NUM-gHEX[-dirty] or HEX[-dirty]
- # TAG might have hyphens.
- git_describe = describe_out
-
- # look for -dirty suffix
- dirty = git_describe.endswith("-dirty")
- pieces["dirty"] = dirty
- if dirty:
- git_describe = git_describe[: git_describe.rindex("-dirty")]
-
- # now we have TAG-NUM-gHEX or HEX
-
- if "-" in git_describe:
- # TAG-NUM-gHEX
- mo = re.search(r"^(.+)-(\d+)-g([0-9a-f]+)$", git_describe)
- if not mo:
- # unparseable. Maybe git-describe is misbehaving?
- pieces["error"] = "unable to parse git-describe output: '%s'" % describe_out
- return pieces
-
- # tag
- full_tag = mo.group(1)
- if not full_tag.startswith(tag_prefix):
- if verbose:
- fmt = "tag '%s' doesn't start with prefix '%s'"
- print(fmt % (full_tag, tag_prefix))
- pieces["error"] = "tag '{}' doesn't start with prefix '{}'".format(
- full_tag,
- tag_prefix,
- )
- return pieces
- pieces["closest-tag"] = full_tag[len(tag_prefix) :]
-
- # distance: number of commits since tag
- pieces["distance"] = int(mo.group(2))
-
- # commit: short hex revision ID
- pieces["short"] = mo.group(3)
-
- else:
- # HEX: no tags
- pieces["closest-tag"] = None
- count_out, rc = run_command(GITS, ["rev-list", "HEAD", "--count"], cwd=root)
- pieces["distance"] = int(count_out) # total number of commits
-
- # commit date: see ISO-8601 comment in git_versions_from_keywords()
- date = run_command(GITS, ["show", "-s", "--format=%ci", "HEAD"], cwd=root)[
- 0
- ].strip()
- pieces["date"] = date.strip().replace(" ", "T", 1).replace(" ", "", 1)
-
- return pieces
-
-
-def do_vcs_install(manifest_in, versionfile_source, ipy):
- """Git-specific installation logic for Versioneer.
-
- For Git, this means creating/changing .gitattributes to mark _version.py
- for export-subst keyword substitution.
- """
- GITS = ["git"]
- if sys.platform == "win32":
- GITS = ["git.cmd", "git.exe"]
- files = [manifest_in, versionfile_source]
- if ipy:
- files.append(ipy)
- try:
- me = __file__
- if me.endswith(".pyc") or me.endswith(".pyo"):
- me = os.path.splitext(me)[0] + ".py"
- versioneer_file = os.path.relpath(me)
- except NameError:
- versioneer_file = "versioneer.py"
- files.append(versioneer_file)
- present = False
- try:
- f = open(".gitattributes")
- for line in f.readlines():
- if line.strip().startswith(versionfile_source):
- if "export-subst" in line.strip().split()[1:]:
- present = True
- f.close()
- except OSError:
- pass
- if not present:
- f = open(".gitattributes", "a+")
- f.write("%s export-subst\n" % versionfile_source)
- f.close()
- files.append(".gitattributes")
- run_command(GITS, ["add", "--"] + files)
-
-
-def versions_from_parentdir(parentdir_prefix, root, verbose):
- """Try to determine the version from the parent directory name.
-
- Source tarballs conventionally unpack into a directory that includes both
- the project name and a version string. We will also support searching up
- two directory levels for an appropriately named parent directory
- """
- rootdirs = []
-
- for i in range(3):
- dirname = os.path.basename(root)
- if dirname.startswith(parentdir_prefix):
- return {
- "version": dirname[len(parentdir_prefix) :],
- "full-revisionid": None,
- "dirty": False,
- "error": None,
- "date": None,
- }
- else:
- rootdirs.append(root)
- root = os.path.dirname(root) # up a level
-
- if verbose:
- print(
- "Tried directories %s but none started with prefix %s"
- % (str(rootdirs), parentdir_prefix),
- )
- raise NotThisMethod("rootdir doesn't start with parentdir_prefix")
-
-
-SHORT_VERSION_PY = """
-# This file was generated by 'versioneer.py' (0.18) from
-# revision-control system data, or from the parent directory name of an
-# unpacked source archive. Distribution tarballs contain a pre-generated copy
-# of this file.
-
-import json
-
-version_json = '''
-%s
-''' # END VERSION_JSON
-
-
-def get_versions():
- return json.loads(version_json)
-"""
-
-
-def versions_from_file(filename):
- """Try to determine the version from _version.py if present."""
- try:
- with open(filename) as f:
- contents = f.read()
- except OSError:
- raise NotThisMethod("unable to read _version.py")
- mo = re.search(
- r"version_json = '''\n(.*)''' # END VERSION_JSON",
- contents,
- re.M | re.S,
- )
- if not mo:
- mo = re.search(
- r"version_json = '''\r\n(.*)''' # END VERSION_JSON",
- contents,
- re.M | re.S,
- )
- if not mo:
- raise NotThisMethod("no version_json in _version.py")
- return json.loads(mo.group(1))
-
-
-def write_to_version_file(filename, versions):
- """Write the given version number to the given _version.py file."""
- os.unlink(filename)
- contents = json.dumps(versions, sort_keys=True, indent=1, separators=(",", ": "))
- with open(filename, "w") as f:
- f.write(SHORT_VERSION_PY % contents)
-
- print("set {} to '{}'".format(filename, versions["version"]))
-
-
-def plus_or_dot(pieces):
- """Return a + if we don't already have one, else return a ."""
- if "+" in pieces.get("closest-tag", ""):
- return "."
- return "+"
-
-
-def render_pep440(pieces):
- """Build up version string, with post-release "local version identifier".
-
- Our goal: TAG[+DISTANCE.gHEX[.dirty]] . Note that if you
- get a tagged build and then dirty it, you'll get TAG+0.gHEX.dirty
-
- Exceptions:
- 1: no tags. git_describe was just HEX. 0+untagged.DISTANCE.gHEX[.dirty]
- """
- if pieces["closest-tag"]:
- rendered = pieces["closest-tag"]
- if pieces["distance"] or pieces["dirty"]:
- rendered += plus_or_dot(pieces)
- rendered += "%d.g%s" % (pieces["distance"], pieces["short"])
- if pieces["dirty"]:
- rendered += ".dirty"
- else:
- # exception #1
- rendered = "0+untagged.%d.g%s" % (pieces["distance"], pieces["short"])
- if pieces["dirty"]:
- rendered += ".dirty"
- return rendered
-
-
-def render_pep440_pre(pieces):
- """TAG[.post.devDISTANCE] -- No -dirty.
-
- Exceptions:
- 1: no tags. 0.post.devDISTANCE
- """
- if pieces["closest-tag"]:
- rendered = pieces["closest-tag"]
- if pieces["distance"]:
- rendered += ".post.dev%d" % pieces["distance"]
- else:
- # exception #1
- rendered = "0.post.dev%d" % pieces["distance"]
- return rendered
-
-
-def render_pep440_post(pieces):
- """TAG[.postDISTANCE[.dev0]+gHEX] .
-
- The ".dev0" means dirty. Note that .dev0 sorts backwards
- (a dirty tree will appear "older" than the corresponding clean one),
- but you shouldn't be releasing software with -dirty anyways.
-
- Exceptions:
- 1: no tags. 0.postDISTANCE[.dev0]
- """
- if pieces["closest-tag"]:
- rendered = pieces["closest-tag"]
- if pieces["distance"] or pieces["dirty"]:
- rendered += ".post%d" % pieces["distance"]
- if pieces["dirty"]:
- rendered += ".dev0"
- rendered += plus_or_dot(pieces)
- rendered += "g%s" % pieces["short"]
- else:
- # exception #1
- rendered = "0.post%d" % pieces["distance"]
- if pieces["dirty"]:
- rendered += ".dev0"
- rendered += "+g%s" % pieces["short"]
- return rendered
-
-
-def render_pep440_old(pieces):
- """TAG[.postDISTANCE[.dev0]] .
-
- The ".dev0" means dirty.
-
- Eexceptions:
- 1: no tags. 0.postDISTANCE[.dev0]
- """
- if pieces["closest-tag"]:
- rendered = pieces["closest-tag"]
- if pieces["distance"] or pieces["dirty"]:
- rendered += ".post%d" % pieces["distance"]
- if pieces["dirty"]:
- rendered += ".dev0"
- else:
- # exception #1
- rendered = "0.post%d" % pieces["distance"]
- if pieces["dirty"]:
- rendered += ".dev0"
- return rendered
-
-
-def render_git_describe(pieces):
- """TAG[-DISTANCE-gHEX][-dirty].
-
- Like 'git describe --tags --dirty --always'.
-
- Exceptions:
- 1: no tags. HEX[-dirty] (note: no 'g' prefix)
- """
- if pieces["closest-tag"]:
- rendered = pieces["closest-tag"]
- if pieces["distance"]:
- rendered += "-%d-g%s" % (pieces["distance"], pieces["short"])
- else:
- # exception #1
- rendered = pieces["short"]
- if pieces["dirty"]:
- rendered += "-dirty"
- return rendered
-
-
-def render_git_describe_long(pieces):
- """TAG-DISTANCE-gHEX[-dirty].
-
- Like 'git describe --tags --dirty --always -long'.
- The distance/hash is unconditional.
-
- Exceptions:
- 1: no tags. HEX[-dirty] (note: no 'g' prefix)
- """
- if pieces["closest-tag"]:
- rendered = pieces["closest-tag"]
- rendered += "-%d-g%s" % (pieces["distance"], pieces["short"])
- else:
- # exception #1
- rendered = pieces["short"]
- if pieces["dirty"]:
- rendered += "-dirty"
- return rendered
-
-
-def render(pieces, style):
- """Render the given version pieces into the requested style."""
- if pieces["error"]:
- return {
- "version": "unknown",
- "full-revisionid": pieces.get("long"),
- "dirty": None,
- "error": pieces["error"],
- "date": None,
- }
-
- if not style or style == "default":
- style = "pep440" # the default
-
- if style == "pep440":
- rendered = render_pep440(pieces)
- elif style == "pep440-pre":
- rendered = render_pep440_pre(pieces)
- elif style == "pep440-post":
- rendered = render_pep440_post(pieces)
- elif style == "pep440-old":
- rendered = render_pep440_old(pieces)
- elif style == "git-describe":
- rendered = render_git_describe(pieces)
- elif style == "git-describe-long":
- rendered = render_git_describe_long(pieces)
- else:
- raise ValueError("unknown style '%s'" % style)
-
- return {
- "version": rendered,
- "full-revisionid": pieces["long"],
- "dirty": pieces["dirty"],
- "error": None,
- "date": pieces.get("date"),
- }
-
-
-class VersioneerBadRootError(Exception):
- """The project root directory is unknown or missing key files."""
-
-
-def get_versions(verbose=False):
- """Get the project version from whatever source is available.
-
- Returns dict with two keys: 'version' and 'full'.
- """
- if "versioneer" in sys.modules:
- # see the discussion in cmdclass.py:get_cmdclass()
- del sys.modules["versioneer"]
-
- root = get_root()
- cfg = get_config_from_root(root)
-
- assert cfg.VCS is not None, "please set [versioneer]VCS= in setup.cfg"
- handlers = HANDLERS.get(cfg.VCS)
- assert handlers, "unrecognized VCS '%s'" % cfg.VCS
- verbose = verbose or cfg.verbose
- assert (
- cfg.versionfile_source is not None
- ), "please set versioneer.versionfile_source"
- assert cfg.tag_prefix is not None, "please set versioneer.tag_prefix"
-
- versionfile_abs = os.path.join(root, cfg.versionfile_source)
-
- # extract version from first of: _version.py, VCS command (e.g. 'git
- # describe'), parentdir. This is meant to work for developers using a
- # source checkout, for users of a tarball created by 'setup.py sdist',
- # and for users of a tarball/zipball created by 'git archive' or github's
- # download-from-tag feature or the equivalent in other VCSes.
-
- get_keywords_f = handlers.get("get_keywords")
- from_keywords_f = handlers.get("keywords")
- if get_keywords_f and from_keywords_f:
- try:
- keywords = get_keywords_f(versionfile_abs)
- ver = from_keywords_f(keywords, cfg.tag_prefix, verbose)
- if verbose:
- print("got version from expanded keyword %s" % ver)
- return ver
- except NotThisMethod:
- pass
-
- try:
- ver = versions_from_file(versionfile_abs)
- if verbose:
- print(f"got version from file {versionfile_abs} {ver}")
- return ver
- except NotThisMethod:
- pass
-
- from_vcs_f = handlers.get("pieces_from_vcs")
- if from_vcs_f:
- try:
- pieces = from_vcs_f(cfg.tag_prefix, root, verbose)
- ver = render(pieces, cfg.style)
- if verbose:
- print("got version from VCS %s" % ver)
- return ver
- except NotThisMethod:
- pass
-
- try:
- if cfg.parentdir_prefix:
- ver = versions_from_parentdir(cfg.parentdir_prefix, root, verbose)
- if verbose:
- print("got version from parentdir %s" % ver)
- return ver
- except NotThisMethod:
- pass
-
- if verbose:
- print("unable to compute version")
-
- return {
- "version": "0+unknown",
- "full-revisionid": None,
- "dirty": None,
- "error": "unable to compute version",
- "date": None,
- }
-
-
-def get_version():
- """Get the short version string for this project."""
- return get_versions()["version"]
-
-
-def get_cmdclass():
- """Get the custom setuptools/distutils subclasses used by Versioneer."""
- if "versioneer" in sys.modules:
- del sys.modules["versioneer"]
- # this fixes the "python setup.py develop" case (also 'install' and
- # 'easy_install .'), in which subdependencies of the main project are
- # built (using setup.py bdist_egg) in the same python process. Assume
- # a main project A and a dependency B, which use different versions
- # of Versioneer. A's setup.py imports A's Versioneer, leaving it in
- # sys.modules by the time B's setup.py is executed, causing B to run
- # with the wrong versioneer. Setuptools wraps the sub-dep builds in a
- # sandbox that restores sys.modules to it's pre-build state, so the
- # parent is protected against the child's "import versioneer". By
- # removing ourselves from sys.modules here, before the child build
- # happens, we protect the child from the parent's versioneer too.
- # Also see https://github.com/warner/python-versioneer/issues/52
-
- cmds = {}
-
- # we add "version" to both distutils and setuptools
- from distutils.core import Command
-
- class cmd_version(Command):
- description = "report generated version string"
- user_options = []
- boolean_options = []
-
- def initialize_options(self):
- pass
-
- def finalize_options(self):
- pass
-
- def run(self):
- vers = get_versions(verbose=True)
- print("Version: %s" % vers["version"])
- print(" full-revisionid: %s" % vers.get("full-revisionid"))
- print(" dirty: %s" % vers.get("dirty"))
- print(" date: %s" % vers.get("date"))
- if vers["error"]:
- print(" error: %s" % vers["error"])
-
- cmds["version"] = cmd_version
-
- # we override "build_py" in both distutils and setuptools
- #
- # most invocation pathways end up running build_py:
- # distutils/build -> build_py
- # distutils/install -> distutils/build ->..
- # setuptools/bdist_wheel -> distutils/install ->..
- # setuptools/bdist_egg -> distutils/install_lib -> build_py
- # setuptools/install -> bdist_egg ->..
- # setuptools/develop -> ?
- # pip install:
- # copies source tree to a tempdir before running egg_info/etc
- # if .git isn't copied too, 'git describe' will fail
- # then does setup.py bdist_wheel, or sometimes setup.py install
- # setup.py egg_info -> ?
-
- # we override different "build_py" commands for both environments
- if "setuptools" in sys.modules:
- from setuptools.command.build_py import build_py as _build_py
- else:
- from distutils.command.build_py import build_py as _build_py
-
- class cmd_build_py(_build_py):
- def run(self):
- root = get_root()
- cfg = get_config_from_root(root)
- versions = get_versions()
- _build_py.run(self)
- # now locate _version.py in the new build/ directory and replace
- # it with an updated value
- if cfg.versionfile_build:
- target_versionfile = os.path.join(self.build_lib, cfg.versionfile_build)
- print("UPDATING %s" % target_versionfile)
- write_to_version_file(target_versionfile, versions)
-
- cmds["build_py"] = cmd_build_py
-
- if "cx_Freeze" in sys.modules: # cx_freeze enabled?
- from cx_Freeze.dist import build_exe as _build_exe
-
- # nczeczulin reports that py2exe won't like the pep440-style string
- # as FILEVERSION, but it can be used for PRODUCTVERSION, e.g.
- # setup(console=[{
- # "version": versioneer.get_version().split("+", 1)[0], # FILEVERSION
- # "product_version": versioneer.get_version(),
- # ...
-
- class cmd_build_exe(_build_exe):
- def run(self):
- root = get_root()
- cfg = get_config_from_root(root)
- versions = get_versions()
- target_versionfile = cfg.versionfile_source
- print("UPDATING %s" % target_versionfile)
- write_to_version_file(target_versionfile, versions)
-
- _build_exe.run(self)
- os.unlink(target_versionfile)
- with open(cfg.versionfile_source, "w") as f:
- LONG = LONG_VERSION_PY[cfg.VCS]
- f.write(
- LONG
- % {
- "DOLLAR": "$",
- "STYLE": cfg.style,
- "TAG_PREFIX": cfg.tag_prefix,
- "PARENTDIR_PREFIX": cfg.parentdir_prefix,
- "VERSIONFILE_SOURCE": cfg.versionfile_source,
- },
- )
-
- cmds["build_exe"] = cmd_build_exe
- del cmds["build_py"]
-
- if "py2exe" in sys.modules: # py2exe enabled?
- try:
- from py2exe.distutils_buildexe import py2exe as _py2exe # py3
- except ImportError:
- from py2exe.build_exe import py2exe as _py2exe # py2
-
- class cmd_py2exe(_py2exe):
- def run(self):
- root = get_root()
- cfg = get_config_from_root(root)
- versions = get_versions()
- target_versionfile = cfg.versionfile_source
- print("UPDATING %s" % target_versionfile)
- write_to_version_file(target_versionfile, versions)
-
- _py2exe.run(self)
- os.unlink(target_versionfile)
- with open(cfg.versionfile_source, "w") as f:
- LONG = LONG_VERSION_PY[cfg.VCS]
- f.write(
- LONG
- % {
- "DOLLAR": "$",
- "STYLE": cfg.style,
- "TAG_PREFIX": cfg.tag_prefix,
- "PARENTDIR_PREFIX": cfg.parentdir_prefix,
- "VERSIONFILE_SOURCE": cfg.versionfile_source,
- },
- )
-
- cmds["py2exe"] = cmd_py2exe
-
- # we override different "sdist" commands for both environments
- if "setuptools" in sys.modules:
- from setuptools.command.sdist import sdist as _sdist
- else:
- from distutils.command.sdist import sdist as _sdist
-
- class cmd_sdist(_sdist):
- def run(self):
- versions = get_versions()
- self._versioneer_generated_versions = versions
- # unless we update this, the command will keep using the old
- # version
- self.distribution.metadata.version = versions["version"]
- return _sdist.run(self)
-
- def make_release_tree(self, base_dir, files):
- root = get_root()
- cfg = get_config_from_root(root)
- _sdist.make_release_tree(self, base_dir, files)
- # now locate _version.py in the new base_dir directory
- # (remembering that it may be a hardlink) and replace it with an
- # updated value
- target_versionfile = os.path.join(base_dir, cfg.versionfile_source)
- print("UPDATING %s" % target_versionfile)
- write_to_version_file(
- target_versionfile,
- self._versioneer_generated_versions,
- )
-
- cmds["sdist"] = cmd_sdist
-
- return cmds
-
-
-CONFIG_ERROR = """
-setup.cfg is missing the necessary Versioneer configuration. You need
-a section like:
-
- [versioneer]
- VCS = git
- style = pep440
- versionfile_source = src/myproject/_version.py
- versionfile_build = myproject/_version.py
- tag_prefix =
- parentdir_prefix = myproject-
-
-You will also need to edit your setup.py to use the results:
-
- import versioneer
- setup(version=versioneer.get_version(),
- cmdclass=versioneer.get_cmdclass(), ...)
-
-Please read the docstring in ./versioneer.py for configuration instructions,
-edit setup.cfg, and re-run the installer or 'python versioneer.py setup'.
-"""
-
-SAMPLE_CONFIG = """
-# See the docstring in versioneer.py for instructions. Note that you must
-# re-run 'versioneer.py setup' after changing this section, and commit the
-# resulting files.
-
-[versioneer]
-#VCS = git
-#style = pep440
-#versionfile_source =
-#versionfile_build =
-#tag_prefix =
-#parentdir_prefix =
-
-"""
-
-INIT_PY_SNIPPET = """
-from ._version import get_versions
-__version__ = get_versions()['version']
-del get_versions
-"""
-
-
-def do_setup():
- """Main VCS-independent setup function for installing Versioneer."""
- root = get_root()
- try:
- cfg = get_config_from_root(root)
- except (OSError, configparser.NoSectionError, configparser.NoOptionError) as e:
- if isinstance(e, (EnvironmentError, configparser.NoSectionError)):
- print("Adding sample versioneer config to setup.cfg", file=sys.stderr)
- with open(os.path.join(root, "setup.cfg"), "a") as f:
- f.write(SAMPLE_CONFIG)
- print(CONFIG_ERROR, file=sys.stderr)
- return 1
-
- print(" creating %s" % cfg.versionfile_source)
- with open(cfg.versionfile_source, "w") as f:
- LONG = LONG_VERSION_PY[cfg.VCS]
- f.write(
- LONG
- % {
- "DOLLAR": "$",
- "STYLE": cfg.style,
- "TAG_PREFIX": cfg.tag_prefix,
- "PARENTDIR_PREFIX": cfg.parentdir_prefix,
- "VERSIONFILE_SOURCE": cfg.versionfile_source,
- },
- )
-
- ipy = os.path.join(os.path.dirname(cfg.versionfile_source), "__init__.py")
- if os.path.exists(ipy):
- try:
- with open(ipy) as f:
- old = f.read()
- except OSError:
- old = ""
- if INIT_PY_SNIPPET not in old:
- print(" appending to %s" % ipy)
- with open(ipy, "a") as f:
- f.write(INIT_PY_SNIPPET)
- else:
- print(" %s unmodified" % ipy)
- else:
- print(" %s doesn't exist, ok" % ipy)
- ipy = None
-
- # Make sure both the top-level "versioneer.py" and versionfile_source
- # (PKG/_version.py, used by runtime code) are in MANIFEST.in, so
- # they'll be copied into source distributions. Pip won't be able to
- # install the package without this.
- manifest_in = os.path.join(root, "MANIFEST.in")
- simple_includes = set()
- try:
- with open(manifest_in) as f:
- for line in f:
- if line.startswith("include "):
- for include in line.split()[1:]:
- simple_includes.add(include)
- except OSError:
- pass
- # That doesn't cover everything MANIFEST.in can do
- # (http://docs.python.org/2/distutils/sourcedist.html#commands), so
- # it might give some false negatives. Appending redundant 'include'
- # lines is safe, though.
- if "versioneer.py" not in simple_includes:
- print(" appending 'versioneer.py' to MANIFEST.in")
- with open(manifest_in, "a") as f:
- f.write("include versioneer.py\n")
- else:
- print(" 'versioneer.py' already in MANIFEST.in")
- if cfg.versionfile_source not in simple_includes:
- print(
- " appending versionfile_source ('%s') to MANIFEST.in"
- % cfg.versionfile_source,
- )
- with open(manifest_in, "a") as f:
- f.write("include %s\n" % cfg.versionfile_source)
- else:
- print(" versionfile_source already in MANIFEST.in")
-
- # Make VCS-specific changes. For git, this means creating/changing
- # .gitattributes to mark _version.py for export-subst keyword
- # substitution.
- do_vcs_install(manifest_in, cfg.versionfile_source, ipy)
- return 0
-
-
-def scan_setup_py():
- """Validate the contents of setup.py against Versioneer's expectations."""
- found = set()
- setters = False
- errors = 0
- with open("setup.py") as f:
- for line in f.readlines():
- if "import versioneer" in line:
- found.add("import")
- if "versioneer.get_cmdclass()" in line:
- found.add("cmdclass")
- if "versioneer.get_version()" in line:
- found.add("get_version")
- if "versioneer.VCS" in line:
- setters = True
- if "versioneer.versionfile_source" in line:
- setters = True
- if len(found) != 3:
- print("")
- print("Your setup.py appears to be missing some important items")
- print("(but I might be wrong). Please make sure it has something")
- print("roughly like the following:")
- print("")
- print(" import versioneer")
- print(" setup( version=versioneer.get_version(),")
- print(" cmdclass=versioneer.get_cmdclass(), ...)")
- print("")
- errors += 1
- if setters:
- print("You should remove lines like 'versioneer.VCS = ' and")
- print("'versioneer.versionfile_source = ' . This configuration")
- print("now lives in setup.cfg, and should be removed from setup.py")
- print("")
- errors += 1
- return errors
-
-
-if __name__ == "__main__":
- cmd = sys.argv[1]
- if cmd == "setup":
- errors = do_setup()
- errors += scan_setup_py()
- if errors:
- sys.exit(1)