diff --git a/.DS_Store b/.DS_Store new file mode 100644 index 0000000..6b6f3ce Binary files /dev/null and b/.DS_Store differ diff --git a/.flake8 b/.flake8 new file mode 100644 index 0000000..1661ccd --- /dev/null +++ b/.flake8 @@ -0,0 +1,7 @@ +[flake8] +per-file-ignores = + __init__.py:F401 +max-line-length = 110 +safe = true +skip-string-normalization = true +ignore = E203,W503 diff --git a/.github/ISSUE_TEMPLATE/custom.md b/.github/ISSUE_TEMPLATE/custom.md new file mode 100644 index 0000000..f97195d --- /dev/null +++ b/.github/ISSUE_TEMPLATE/custom.md @@ -0,0 +1,32 @@ +--- +name: Custom issue template +about: Describe this issue template's purpose here. +title: '' +labels: '' +assignees: '' + +--- + +**Describe the bug** +A clear and concise description of what the bug is. + +**To Reproduce** +Steps to reproduce the behavior: +1. Go to '...' +2. Click on '....' +3. Scroll down to '....' +4. See error + +**Expected behavior** +A clear and concise description of what you expected to happen. + +**Screenshots** +If applicable, add screenshots to help explain your problem. + +**Desktop (please complete the following information):** + - pyoma2 version: [e.g. 0.1.0 or latest] + - OS: [e.g. iOS] + - Version [e.g. 22] + +**Additional context or possible solutions** +Add any other context about the problem here. diff --git a/.github/workflows/draft-pdf.yml b/.github/workflows/draft-pdf.yml new file mode 100644 index 0000000..b7053c0 --- /dev/null +++ b/.github/workflows/draft-pdf.yml @@ -0,0 +1,24 @@ +name: Draft PDF +on: [push] + +jobs: + paper: + runs-on: ubuntu-latest + name: Paper Draft + steps: + - name: Checkout + uses: actions/checkout@v4 + - name: Build draft PDF + uses: openjournals/openjournals-draft-action@master + with: + journal: joss + # This should be the path to the paper within your repo. + paper-path: paper/paper.md + - name: Upload + uses: actions/upload-artifact@v4 + with: + name: paper + # This is the output path where Pandoc will write the compiled + # PDF. Note, this should be the same directory as the input + # paper.md + path: paper/paper.pdf diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml new file mode 100644 index 0000000..c9f8892 --- /dev/null +++ b/.github/workflows/main.yml @@ -0,0 +1,105 @@ +name: Test Pyoma2 + +on: + push: + branches: + - main + pull_request: + branches: + - main + workflow_dispatch: + +jobs: + # pre-commit: + # runs-on: ubuntu-latest + # steps: + # - uses: actions/checkout@v4 + # - name: Set up Python + # uses: actions/setup-python@v5 + # with: + # python-version: "3.11" + # - name: Install pre-commit + # run: pip install pre-commit + # - name: Run pre-commit + # run: pre-commit run --all-files + + test: + # needs: pre-commit + runs-on: ${{ matrix.os }} + strategy: + fail-fast: false # Continue running jobs even if a previous job fails + matrix: + python-version: ["3.8", "3.9", "3.10", "3.11", "3.12"] + os: [ubuntu-latest, windows-latest, macos-latest] + exclude: + - os: macos-latest + python-version: "3.8" + + steps: + - uses: actions/checkout@v4 + + - name: Set up Python ${{ matrix.python-version }} + uses: actions/setup-python@v5 + with: + python-version: ${{ matrix.python-version }} + + - name: Install tkinter for Ubuntu + if: matrix.os == 'ubuntu-latest' + run: sudo apt-get install -y python3-tk + + - name: Install PDM + run: python -m pip install pdm==2.20.1 + + - name: Install dependencies (Linux) + if: matrix.os == 'ubuntu-latest' + run: | + if [ "${{ matrix.python-version }}" == "3.8" ]; then + pdm install --lockfile=pdm-py38unix.lock --without docs + else + pdm install --lockfile=pdm-py39+unix.lock --without docs + fi + shell: bash + + - name: Install dependencies (macOS) + if: matrix.os == 'macos-latest' + run: | + if [ "${{ matrix.python-version }}" == "3.8" ]; then + pdm install --lockfile=pdm-py38macos.lock --without docs + else + pdm install --lockfile=pdm-py39+macos.lock --without docs + fi + shell: bash + + - name: Install dependencies (Windows) + if: matrix.os == 'windows-latest' + run: | + if (${{ matrix.python-version }} -eq "3.8") { + pdm install --lockfile=pdm-py38win.lock --without docs + } else { + pdm install --lockfile=pdm-py39+win.lock --without docs + } + shell: pwsh + + - name: Run tests + run: pdm run pytest + continue-on-error: false + + - name: Set job status + if: failure() + run: echo "job_status=failure" >> $GITHUB_ENV + shell: bash + + check_failures: + # needs: [pre-commit, test] + needs: [test] + runs-on: ubuntu-latest + if: always() + steps: + - name: Check for failures + run: | + if [[ "${{ contains(needs.*.result, 'failure') }}" == "true" ]]; then + echo "One or more jobs failed" + exit 1 + else + echo "All jobs succeeded" + fi diff --git a/.github/workflows/python-publish.yml b/.github/workflows/python-publish.yml new file mode 100644 index 0000000..bdaab28 --- /dev/null +++ b/.github/workflows/python-publish.yml @@ -0,0 +1,39 @@ +# This workflow will upload a Python Package using Twine when a release is created +# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-python#publishing-to-package-registries + +# This workflow uses actions that are not certified by GitHub. +# They are provided by a third-party and are governed by +# separate terms of service, privacy policy, and support +# documentation. + +name: Upload Python Package + +on: + release: + types: [published] + +permissions: + contents: read + +jobs: + deploy: + + runs-on: ubuntu-latest + + steps: + - uses: actions/checkout@v3 + - name: Set up Python + uses: actions/setup-python@v3 + with: + python-version: '3.x' + - name: Install dependencies + run: | + python -m pip install --upgrade pip + pip install build + - name: Build package + run: python -m build + - name: Publish package + uses: pypa/gh-action-pypi-publish@27b31702a0e7fc50959f5ad993c78deac1bdfc29 + with: + user: __token__ + password: ${{ secrets.PYPI_API_TOKEN }} diff --git a/.github/workflows/templates/bug_report.md b/.github/workflows/templates/bug_report.md new file mode 100644 index 0000000..bd33526 --- /dev/null +++ b/.github/workflows/templates/bug_report.md @@ -0,0 +1,23 @@ +**Describe the bug** +A clear and concise description of what the bug is. + +**To Reproduce** +Steps to reproduce the behavior: +1. Go to '...' +2. Click on '....' +3. Scroll down to '....' +4. See error + +**Expected behavior** +A clear and concise description of what you expected to happen. + +**Screenshots** +If applicable, add screenshots to help explain your problem. + +**Desktop (please complete the following information):** + - pyoma2 version: [e.g. 0.1.0 or latest] + - OS: [e.g. iOS] + - Version [e.g. 22] + +**Additional context or possible solutions** +Add any other context about the problem here. diff --git a/.github/workflows/templates/feature_request.md b/.github/workflows/templates/feature_request.md new file mode 100644 index 0000000..6e74a07 --- /dev/null +++ b/.github/workflows/templates/feature_request.md @@ -0,0 +1,11 @@ +**Is your feature request related to a problem? Please describe.** +A clear and concise description of what the problem is. Ex. I'm always frustrated when [...] + +**Describe the solution you'd like** +A clear and concise description of what you want to happen. + +**Describe alternatives you've considered** +A clear and concise description of any alternative solutions or features you've considered. + +**Additional context** +Add any other context or screenshots about the feature request here. diff --git a/.github/workflows/templates/question.md b/.github/workflows/templates/question.md new file mode 100644 index 0000000..3249311 --- /dev/null +++ b/.github/workflows/templates/question.md @@ -0,0 +1,13 @@ +### Description +Provide a clear and concise description of your question or issue. Please ensure it's related to the usage of the library. + +## QA + +### Context +Include any relevant context about your question or issue. For example, if you're encountering an error, provide details about when it occurs and any steps you've already taken to troubleshoot. + +### Code Example (if applicable) +If your question involves code, please include a minimal example that demonstrates the issue: + +```python +# Your code snippet here diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..a29914b --- /dev/null +++ b/.gitignore @@ -0,0 +1,174 @@ +# Byte-compiled / optimized / DLL files +__pycache__/ +*.py[cod] +*$py.class + +# C extensions +*.so +*.DS_Store + +# Distribution / packaging +.Python +build/ +develop-eggs/ +dist/ +downloads/ +eggs/ +.eggs/ +lib/ +lib64/ +parts/ +sdist/ +var/ +wheels/ +share/python-wheels/ +*.egg-info/ +.installed.cfg +*.egg +MANIFEST + +# PyInstaller +# Usually these files are written by a python script from a template +# before PyInstaller builds the exe, so as to inject date/other infos into it. +*.manifest +*.spec + +# Installer logs +pip-log.txt +pip-delete-this-directory.txt + +# Unit test / coverage reports +htmlcov/ +.tox/ +.nox/ +.coverage +.coverage.* +.cache +nosetests.xml +coverage.xml +*.cover +*.py,cover +.hypothesis/ +.pytest_cache/ +cover/ + +# Translations +*.mo +*.pot + +# Django stuff: +*.log +local_settings.py +db.sqlite3 +db.sqlite3-journal + +# Flask stuff: +instance/ +.webassets-cache + +# Scrapy stuff: +.scrapy + +# Sphinx documentation +docs/_build/ + +# PyBuilder +.pybuilder/ +target/ + +# Jupyter Notebook +.ipynb_checkpoints + +# IPython +profile_default/ +ipython_config.py + +# pyenv +# For a library or package, you might want to ignore these files since the code is +# intended to run in multiple environments; otherwise, check them in: +.python-version + +# pipenv +# According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control. +# However, in case of collaboration, if having platform-specific dependencies or dependencies +# having no cross-platform support, pipenv may install dependencies that don't work, or not +# install all needed dependencies. +#Pipfile.lock + +# poetry +# Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control. +# This is especially recommended for binary packages to ensure reproducibility, and is more +# commonly ignored for libraries. +# https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control +#poetry.lock + +# pdm +# Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control. +#pdm.lock +# pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it +# in version control. +# https://pdm.fming.dev/#use-with-ide +.pdm.toml +.pdm-python + +# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm +__pypackages__/ + +# Google Cloud +.pdm-python + +# Celery stuff +celerybeat-schedule +celerybeat.pid + +# SageMath parsed files +*.sage.py + +# Environments +.env +.venv +env/ +venv/ +ENV/ +env.bak/ +venv.bak/ + +# Spyder project settings +.spyderproject +.spyproject + +# Rope project settings +.ropeproject + +# mkdocs documentation +/site + +# mypy +.mypy_cache/ +.dmypy.json +dmypy.json + +# Pyre type checker +.pyre/ + +# pytype static type analyzer +.pytype/ + +# Cython debug symbols +cython_debug/ + +# PyCharm +# JetBrains specific template is maintained in a separate JetBrains.gitignore that can +# be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore +# and can be added to the global gitignore or merged into this file. For a more nuclear +# option (not recommended) you can uncomment the following to ignore the entire idea folder. +.idea/ + + +# Visual Studio Code +.vscode/ + + +# pickle +*.pickle +*.pkl diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml new file mode 100644 index 0000000..d990321 --- /dev/null +++ b/.pre-commit-config.yaml @@ -0,0 +1,77 @@ +# See https://pre-commit.com for more information +# See https://pre-commit.com/hooks.html for more hooks +repos: +- repo: https://github.com/pre-commit/pre-commit-hooks + rev: v4.5.0 + hooks: + - id: trailing-whitespace + - id: end-of-file-fixer + - id: check-yaml + - id: debug-statements + - id: check-ast + language_version: python3 +- repo: https://github.com/astral-sh/ruff-pre-commit + # Ruff version. + rev: v0.3.4 + hooks: + # Run the linter. + - id: ruff + args: [ --fix ] + # Run the formatter. + - id: ruff-format +# export python requirements +# LINUX 3.8 +- repo: https://github.com/pdm-project/pdm + rev: 2.20.1 + hooks: + - id: pdm-export + name: pdm-export-py38unix + args: ['-o', 'requirements/requirementspy38unix.txt', '--without-hashes', '-L', 'pdm-py38unix.lock'] + files: ^pdm-py38unix.lock$ +# LINUX 3.9+ +- repo: https://github.com/pdm-project/pdm + rev: 2.20.1 + hooks: + - id: pdm-export + name: pdm-export-py39+unix + args: ['-o', 'requirements/requirementspy39+unix.txt', '--without-hashes', '-L', 'pdm-py39+unix.lock'] + files: ^pdm-py39\+unix.lock$ +# WINDOWS 3.8 +- repo: https://github.com/pdm-project/pdm + rev: 2.20.1 + hooks: + - id: pdm-export + name: pdm-export-py38win + args: ['-o', 'requirements/requirementspy38win.txt', '--without-hashes', '-L', 'pdm-py38win.lock'] + files: ^pdm-py38win.lock$ +# WINDOWS 3.9+ +- repo: https://github.com/pdm-project/pdm + rev: 2.20.1 + hooks: + - id: pdm-export + name: pdm-export-py39+win + args: ['-o', 'requirements/requirementspy39+win.txt', '--without-hashes', '-L', 'pdm-py39+win.lock'] + files: ^pdm-py39\+win.lock$ +# MACOS 3.8 +- repo: https://github.com/pdm-project/pdm + rev: 2.20.1 + hooks: + - id: pdm-export + name: pdm-export-py38mac + args: ['-o', 'requirements/requirementspy38mac.txt', '--without-hashes', '-L', 'pdm-py38macos.lock'] + files: ^pdm-py38macos.lock$ +# MACOS 3.9+ +- repo: https://github.com/pdm-project/pdm + rev: 2.20.1 + hooks: + - id: pdm-export + name: pdm-export-py39\+mac + args: ['-o', 'requirements/requirementspy39+mac.txt', '--without-hashes', '-L', 'pdm-py39+macos.lock'] + files: ^pdm-py39\+macos.lock$ + +# # Mypy +# - repo: https://github.com/pre-commit/mirrors-mypy +# rev: v1.9.0 +# hooks: +# - id: mypy +# args: [--python-version=38, --ignore-missing-imports, --explicit-package-bases, ] diff --git a/.readthedocs.yaml b/.readthedocs.yaml new file mode 100644 index 0000000..7b17d99 --- /dev/null +++ b/.readthedocs.yaml @@ -0,0 +1,32 @@ +# .readthedocs.yaml +# Read the Docs configuration file +# See https://docs.readthedocs.io/en/stable/config-file/v2.html for details + +# Required +version: 2 + +# Set the OS, Python version and other tools you might need +build: + os: ubuntu-22.04 + tools: + python: "3.11" + # You can also specify other tool versions: + # nodejs: "19" + # rust: "1.64" + # golang: "1.19" + +# Build documentation in the "docs/" directory with Sphinx +sphinx: + configuration: docs/conf.py + +# Optionally build your docs in additional formats such as PDF and ePub +# formats: +# - pdf +# - epub + +# Optional but recommended, declare the Python requirements required +# to build your documentation +# See https://docs.readthedocs.io/en/stable/guides/reproducible-builds.html +python: + install: + - requirements: docs/requirements.txt diff --git a/.virtual_documents/Examples/Example1.ipynb b/.virtual_documents/Examples/Example1.ipynb new file mode 100644 index 0000000..cea8e99 --- /dev/null +++ b/.virtual_documents/Examples/Example1.ipynb @@ -0,0 +1,93 @@ + + + + + + +import os +import sys +import numpy as np +# Add the directory we executed the script from to path: +sys.path.insert(0, os.path.realpath('__file__')) + +# import the function to generate the example dataset +from pyoma2.functions.gen import example_data + +# generate example data and results +data, ground_truth = example_data() + +# Print the exact results +np.set_printoptions(precision=3) +print(f"the natural frequencies are: {ground_truth[0]} \n") +print(f"the damping is: {ground_truth[2]} \n") +print("the (column-wise) mode shape matrix: \n" +f"{ground_truth[1]} \n") + + + + + +from pyoma2.setup.single import SingleSetup + +simp_5dof = SingleSetup(data, fs=600) + + + + + +# Decimate the data by factor 10 +simp_5dof.decimate_data(q=20) + + + + + +from pyoma2.algorithms.fdd import FDD +from pyoma2.algorithms.ssi import SSIdat + +# Initialise the algorithms +fdd = FDD(name="FDD", nxseg=1024, method_SD="cor") +ssidat = SSIdat(name="SSIdat", br=30, ordmax=30) + +# Add algorithms to the class +simp_5dof.add_algorithms(fdd, ssidat) + +# run +simp_5dof.run_all() + + + + + +# plot singular values of the spectral density matrix +_, _ = fdd.plot_CMIF(freqlim=(0,8)) + +# plot the stabilisation diagram +_, _ = ssidat.plot_stab(freqlim=(0,10),hide_poles=False) + + + + + +# get the modal parameters with the interactive plot +# simp_ex.mpe_from_plot("SSIdat", freqlim=(0,10)) + +# or manually +simp_5dof.mpe("SSIdat", sel_freq=[0.89, 2.598, 4.095, 5.261, 6.], order="find_min") + + + + + +# dict of results +ssidat_res = dict(ssidat.result) + +from pyoma2.functions.plot import plot_mac_matrix + +# print the results +print(f"order out: {ssidat_res['order_out']} \n") +print(f"the natural frequencies are: {ssidat_res['Fn']} \n") +print(f"the dampings are: {ssidat_res['Xi']} \n") +print("the (column-wise) mode shape matrix:") +print(f"{ssidat_res['Phi'].real} \n") +_, _ = plot_mac_matrix(ssidat_res['Phi'].real, ground_truth[1]) diff --git a/CHANGELOG.md b/CHANGELOG.md new file mode 100644 index 0000000..3f06932 --- /dev/null +++ b/CHANGELOG.md @@ -0,0 +1,300 @@ +# Changelog + +All notable changes to this project will be documented in this file. + +The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), +and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). + +## [Unreleased] + +* security dependencies patch + +## [1.1.1] - 2025-01-24 + +- fix cluster_plt parameter name to Xi + +## [1.1.0] - 2025-01-24 + +### Fixed + +- uncertainty calculations for SSI algorithm +- animation problem in pyvista +- small fix (moved ax.grid()) in plt_data +- updated docs + +### Changed + +- Renamed `anim_mode_g2` to `anim_mode_geo2` in `GeometryMixin` class +- Updated hierarchy for results and run_params classes +- Renamed `plot_cluster()` method to `plot_freqvsdamp()` +- SSI functions and classes re-organization: + - `cov_mm`method renamed to `cov` + - removed `ac2mp` function + - Hard criteria on MPC and MPD splitted + - HC on damping and on complex conjugate included into `SSI_poles`function + - order for run_param renamed to `order_in` + - Renamed uncertanties component from `xxx_cov`to `xxx_std` +- updated tests + +### Added + +- pre commit in github workflow +- clustering plotting functions to plot.py + + +## [1.0.0] - 2024-09-12 + +**BREAKING CHANGES** + +This version introduces a new project structure and a new way to handle the algorithms. +A script is available here https://gist.github.com/dfm88/2bd2a08bb8b5837103dd074033bd7710 +to help running the migration to new version. + +### Added + +- `pyvista` optional dependency for 3D plots +- file `src/pyoma2/support/mpl_plotter.py` to handle matplotlib plots +- file `src/pyoma2/support/pyvista_plotter.py` to handle pyvista plots +- file `src/pyoma2/test_data/3SL/Geo1.xlsx` +- file `src/pyoma2/test_data/3SL/Geo2.xlsx` +- file `src/pyoma2/test_data/5dof/Geo1.xlsx` +- file `src/pyoma2/test_data/5dof/Geo2.xlsx` +- file `src/pyoma2/test_data/Geometry/htc_geo2.xlsx` +- file `src/pyoma2/test_data/Template_Geometry2.xlsx` +- file `src/pyoma2/test_data/palisaden/Geo1.xlsx` +- file `src/pyoma2/test_data/palisaden/Geo2.xlsx` +- platform specific installation in github workflow and requirements extraction in pre-commit + + +### Changed + +- tests to support new project structure +- `OMA.py` removed `inplace` method from `SingleSetup` and `MultiSetup_PreGER` classes, add a copy of data on init with the possibility to `rollback` them +- moved `plot_mode_g1` and `plot_mode_g2` and `anim_mode_g2` methods from `SingleSetup` to `BaseSetup` class +- function `pyoma2/functions/fdd.py::SDOF_bellandMS` now have custom logic for algorithm methods `FSDD` and `EFDD` +- function `pyoma2/functions/plscf.py::pLSCF_poles` now return an additional element in the tuple +- function `pyoma2/functions/plscf.py::ac2mp_poly` now return an additional element in the tuple +- moved all geometry related methods to the `pyoma2/support/geometry/mixin.py` file where the following method are available `def_geo1`, `def_geo2`, `_def_geo_by_file`, `def_geo1_by_file`, `def_geo2_by_file`, `plot_geo1`, `plot_geo2`, `plot_geo2_mpl`, `plot_mode_geo1`, `plot_mode_geo2`, `plot_mode_geo2_mpl`, `anim_mode_geo2` and available to `BaseSetup` class and `MultiSetup_PoSER` class. The proxy to these method were removed from `BaseAlgorithm` class and moved to the mixin class `GeometryMixin` and so proxied by the `Setup` classes that implement the geometry mixin. + +- Library re-organization: + - file `pyoma2/OMA.py` split in `pyoma2/setup` package in the following files: + - `base.py`: here we moved the following classes `BaseSetup` + - `single.py`: here we moved the following classes `SingleSetup` + - `multi.py`: here we moved the following classes `MultiSetup_PreGER`, `MultiSetup_PoSER` + - file `pyoma2/support/utils/logging_handler.py` moved to `pyoma2/support/utils/logging_handler.py` + - file `pyoma2/utils/typing.py` moved to `pyoma2/support/utils/typing.py` + - package `pyoma2/algorithm` renamed to `pyoma2/algorithms` + - file `pyoma2/algorithm/data/geometry.py` moved to `pyoma2/support/geometry.py` + - file `pyoma2/plot/Sel_from_plot.py` moved to `pyoma2/support/Sel_from_plot.py` + - variable `pyoma2/algorithms/data/result.py::SSIResult.xi_poles` renamed to `pyoma2/algorithms/data/result.py::SSIResult.Xi_poles` + - variable `pyoma2/algorithms/data/result.py::xi_poles.xi_poles` renamed to `pyoma2/algorithms/data/result.py::xi_poles.Xi_poles` + - variable `pyoma2/algorithms/data/run_params.py::EFDDRunParams.method` renamed to `pyoma2/algorithms/data/run_params.py::EFDDRunParams.method_hank` + - class `pyoma2/algorithms/fdd.py::FDD_algo` renamed to `pyoma2/algorithms/fdd.py::FDD` + - class `pyoma2/algorithms/fdd.py::EFDD_algo` renamed to `pyoma2/algorithms/fdd.py::EFDD` + - class `pyoma2/algorithms/fdd.py::FSDD_algo` renamed to `pyoma2/algorithms/fdd.py::FSDD` + - class `pyoma2/algorithms/fdd.py::FDD_algo_MS` renamed to `pyoma2/algorithms/fdd.py::FDD_MS` + - class `pyoma2/algorithms/fdd.py::EFDD_algo_MS` renamed to `pyoma2/algorithms/fdd.py::EFDD_MS` + - method `pyoma2/algorithms/fdd.py::EFDD.plot_FIT` renamed to `pyoma2/algorithms/fdd.py::EFDD.plot_EFDDfit` + - function `pyoma2/functions/fdd.py::SD_Est` renamed to `pyoma2/functions/fdd.py::SD_est` + - function `pyoma2/functions/plscf.py::pLSCF_Poles` renamed to `pyoma2/functions/plscf.py::pLSCF_poles` + - function `pyoma2/functions/plscf.py::rmfd2AC` renamed to `pyoma2/functions/plscf.py::rmfd2ac` + - function `pyoma2/functions/plscf.py::AC2MP_poly` renamed to `pyoma2/functions/plscf.py::ac2mp_poly` + - function `pyoma2/functions/plscf.py::pLSCF_MPE` renamed to `pyoma2/functions/plscf.py::pLSCF_mpe` + - function `pyoma2/functions/ssi.py::BuildHank` renamed to `pyoma2/functions/ssi.py::build_hank` + - function `pyoma2/functions/ssi.py::AC2MP` renamed to `pyoma2/functions/ssi.py::ac2mp` + - function `pyoma2/functions/ssi.py::SSI_FAST` renamed to `pyoma2/functions/ssi.py::SSI_fast` + - function `pyoma2/functions/ssi.py::SSI_POLES` renamed to `pyoma2/functions/ssi.py::SSI_poles` + - function `pyoma2/functions/ssi.py::SSI_MulSet` renamed to `pyoma2/functions/ssi.py::SSI_multi_setup` + - function `pyoma2/functions/ssi.py::SSI_MPE` renamed to `pyoma2/functions/ssi.py::SSI_mpe` + - file `pyoma2/functions/FDD_funct.py` renamed to `pyoma2/functions/fdd.py` + - file `pyoma2/functions/plot_funct.py` renamed to `pyoma2/functions/plot.py` + - file `pyoma2/functions/Gen_funct.py` renamed to `pyoma2/functions/gen.py` + - file `pyoma2/functions/SSI_funct.py` renamed to `pyoma2/functions/ssi.py` + - method `pyoma2/algorithms/base.py::BaseAlgorithm.MPE` renamed to `pyoma2/algorithms/base.py::BaseAlgorithm.mpe` + - method `pyoma2/algorithms/base.py::BaseAlgorithm.mpe_fromPlot` renamed to `pyoma2/algorithms/base.py::BaseAlgorithm.mpe_from_plot` + + +### Fixed + +- python 3.12 support ([akaszynsk](https://github.com/akaszynski)) + +### Removed + +- file `src/pyoma2/plot/anim_mode.py` now handled by pyvista +- file `https://github.com/dagghe/pyOMA-test-data/tree/main/test_data/3SL/BG_lines.txt` +- file `https://github.com/dagghe/pyOMA-test-data/tree/main/test_data/3SL/BG_nodes.txt` +- file `https://github.com/dagghe/pyOMA-test-data/tree/main/test_data/3SL/geom.xlsx` +- file `https://github.com/dagghe/pyOMA-test-data/tree/main/test_data/3SL/pts_coord.txt` +- file `https://github.com/dagghe/pyOMA-test-data/tree/main/test_data/3SL/sens_coord.txt` +- file `https://github.com/dagghe/pyOMA-test-data/tree/main/test_data/3SL/sens_dir.txt` +- file `https://github.com/dagghe/pyOMA-test-data/tree/main/test_data/3SL/sens_lines.txt` +- file `https://github.com/dagghe/pyOMA-test-data/tree/main/test_data/3SL/sens_map.txt` +- file `https://github.com/dagghe/pyOMA-test-data/tree/main/test_data/3SL/sens_sign.txt` +- file `https://github.com/dagghe/pyOMA-test-data/tree/main/test_data/palisaden/BG_lines.txt'` +- file `https://github.com/dagghe/pyOMA-test-data/tree/main/test_data/palisaden/BG_nodes.txt` +- file `https://github.com/dagghe/pyOMA-test-data/tree/main/test_data/palisaden/geom_pali.xlsx` +- file `https://github.com/dagghe/pyOMA-test-data/tree/main/test_data/palisaden/pts_coord.txt` +- file `https://github.com/dagghe/pyOMA-test-data/tree/main/test_data/palisaden/sens_dir.txt` +- file `https://github.com/dagghe/pyOMA-test-data/tree/main/test_data/palisaden/sens_lines.txt` +- file `https://github.com/dagghe/pyOMA-test-data/tree/main/test_data/palisaden/sens_map.txt` +- file `https://github.com/dagghe/pyOMA-test-data/tree/main/test_data/palisaden/sens_sign.txt` +- function `pyoma2/functions/ssi.py::Lab_stab_SSI` +- function `pyoma2/functions/gen.py::lab_stab` +- support in testing for `python3.8` and `macos` due to `vtk` dependency that is not compatible with platform using during tests action +- File for example are now retrieved from the online repo https://github.com/dagghe/pyOMA-test-data/tree/main/test_data and removed from the repo + +## [0.6.0] - 2024-09-06 + +## Fixed + +- python 3.12 support ([akaszynsk](https://github.com/akaszynski)) + +## Added + +- tox.ini file to run tests locally on multiple python versions + +## [0.5.2] - 2024-05-21 + +### Fixed + +- type hints 3.8 compatibility + +## [0.5.1] - 2024-04-16 + +## Fixed +- `multi_setup_poser` tests +- bug "SSI_Poles orders issue #11" +- various minor fixes + +## Added +- python 3.12 support +- MPC and MPD criteria on stabilisation diagram for ssi and plscf +- colormap to mode shape animation +- method to save class to file + + +## [0.5.0] - 2024-04-09 + +### Added +- issue, feature, question templates + +### Changed +- `pre-commit` default formatter to `ruff` +- `OMA.py` moved `decimate_data`, `detrend_data`, `filter_data` to BaseSetup and add `inplace` option default to false + +### Fixed +- `mpe` in `FDD` algorithm + +### Added +- tests +- workflow for tests on push and pull request + +## [0.4.1] - 2024-03-05 + +### Added +- `pytest-cov` to qa dependencies +- first tests + +### Changed +- evaluation types on BaseAlgorithm excluding itself +- more readable error when defining new algorithms +- `_pre_run` on algorithms is now called from setup classes + +### Fixed +- `plscf.py` module name https://github.com/dagghe/pyOMA2/issues/5 + +## [0.4.0] - 2024-02-29 + +### Added +- `plscf` module for polymax +- `plot_STFT()` to plot the Short Time Fourier Transform magnitude of a channel (time-frequency plot) +- `filter_data()` method to apply a Butterworth filter to the dataset +- origin and reference axes (xyz) in modeshape plots and animations + +### Fixed +- axis argument for `detrend_data()` and `decimate_data()` methods +- minor fixes to `plot_data()` method + +### Changed +- revised `plot_ch_info()` method to assess quality of data +- `Stab_plot()` and `Cluster_plot()` functions have been revised so that `plot_cluster()` `plot_STDiag()` methods work for both ssi and plscf + +## [0.3.2] - 2024-02-17 + +### Fixed +- link to documentation in toml file +- pyOMA version in the requirements for documentation build +- small fixes in documentation + +### Removed +- MAC function from SSI_funct module (restored import from Gen_funct) + +## [0.3.1] - 2024-02-17 + +### Added +- docstring to all classes and functions +- option to save gif figure from animation of the mode shape +- documentation +- logo + +### Removed +- old example files under main +- util.py as it was not used + +### Changed +- the `freqlim` argument in all the plot function has been changed to a tuple, so to set both an upper and a lower limit to the x (frequency) axis +- moved info.svg under docs/img folder +- moved examples notebooks in Examples folder + +### Fixed +- docstring fix for OMA.py +- default ax value to 0 for `detrend_data()` and `decimate_data()` methods +- links to moved items + +## [0.3.0] - 2024-02-02 + +### Added +- methods: `plot_data()`, `plot_ch_info()`, `detrend_data()`, `decimate_data()` to Multisetup preGER class +- info.svg chart to README +- Multisetup PoSER and PreGER examples notebook +- several docstring to functions and classes + +### Removed +- channels name from `plot_mode_g1()` method + +### Changed +- default ax value to 0 for `detrend_data()` and `decimate_data()` methods +- name to single setup example notebook +- minor reorganisation of `pLSCF_funct.py` +- updated README.md with link to the example notebooks +- add `PYOMA_DISABLE_MATPLOTLIB_LOGGING` env variable to disable matplotlib logging, default to True + +### Fixed +- error to `plot_geo2()` method for both SS and MS ***(WARNING posx,posy)*** +- restored functions removed by mistake from `Gen_funct.py` + +## [0.2.0] - 2024-01-30 + +### Fixed + +- plot size +- small fixes in `OMA.py` and `plot_func.py` + +### Added + +- methods to plot channels info +- docstring on `SelFormPlot` class +- jupyter notebook for `SingleSetup` + + +## [0.1.0] - 2024-01-25 + +### Added + +- Initial release of the project + +### Removed + +### Changed + +### Fixed diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md new file mode 100644 index 0000000..93d6f15 --- /dev/null +++ b/CONTRIBUTING.md @@ -0,0 +1,251 @@ +# Contributing to pyOMA2 + +Welcome! **pyOMA2** is a highly technical Python library focused on **Operational Modal Analysis (OMA)**. As such, contributions can come from both **programmers** (for bug fixes, best practices, and performance improvements) and **field experts** (for validation, methodology suggestions, and real-world applications). We appreciate any contributions that help improve the library! + +## How to Get Involved + +We welcome contributions from both developers and OMA experts in different ways: + +- **Report Issues**: If you encounter a bug, have a feature request, or find something unclear in the documentation, please open a [GitHub Issue](https://github.com/dagghe/pyOMA2/issues). +- **Code Contributions**: If you are a developer, you can help improve the codebase, fix bugs, enhance performance, or improve best practices by submitting a Pull Request (PR). +- **Domain Expertise Contributions**: If you are an OMA specialist or engineer, we would love your input on methodology, validation of results, and possible improvements to the implemented techniques. +- **Documentation Improvements**: If you notice unclear explanations or missing information, feel free to suggest improvements. +- **Discussions & Questions**: If you're unsure about something, feel free to start a discussion in the Issues section. + +## Contribution Guidelines + +Before making a contribution, please ensure you follow these best practices: + +- Follow the [Conventional Commits](https://www.conventionalcommits.org/en/v1.0.0/) guidelines. +- Ensure your changes do not break existing functionality. +- Write tests for new features where applicable. +- Be respectful and follow our community guidelines. + +## Setup + +We use PDM as a dependency manager. Check the updated installation instructions from here, or follow these steps: + +Linux/MAC: + +```shell +# Install PDM Linux/MAC + +curl -sSL https://pdm-project.org/install-pdm.py | python3 - +``` + +Windows: + +```powershell +# Install PDM Windows + +(Invoke-WebRequest -Uri https://pdm-project.org/install-pdm.py -UseBasicParsing).Content | python - +``` + +Add PATH to environment manager and then run the appropriate command to install all the dependencies based on your Python version and operating system: + +### For Python 3.8 + +Linux: +```shell +pdm install --lockfile=pdm-py38unix.lock +``` + +Windows: +```shell +pdm install --lockfile=pdm-py38win.lock +``` + +macOS: +If you are using macOS with Python 3.8, you need to manually install the `vtk` package due to compatibility issues. You can do this by running the following command: + +```sh +pip install https://files.pythonhosted.org/packages/b3/15/40f8264f1b5379f12caf0e5153006a61c1f808937877c996e907610e8f23/vtk-9.3.1-cp38-cp38-macosx_10_10_x86_64.whl +```shell +pdm install --lockfile=pdm-py38macos.lock +``` + +### For Python 3.9 and above + +Linux: +```shell +pdm install --lockfile=pdm-py39+unix.lock +``` + +Windows: +```shell +pdm install --lockfile=pdm-py39+win.lock +``` + +macOS: +```shell +pdm install --lockfile=pdm-py39+macos.lock +``` + +### Using requirements.txt files + +The corresponding `requirements.txt` files are generated during pre-commit hooks and located in the `/requirements` folder. + +### Adding new packages + +When adding a new package, make sure to update the correct lock file(s). For example: + +For Python 3.8 Windows +```shell +pdm add --lockfile=pdm-py38win.lock +``` + +For Python 3.8 Linux +```shell +pdm add --lockfile=pdm-py38unix.lock +``` + +For Python 3.8 (macOS): +```shell +pdm add --lockfile=pdm-py38macos.lock +``` + +For Python 3.9+ Linux +```shell +pdm add --lockfile=pdm-py39+unix.lock +``` + +For Python 3.9+ (macOS): +```shell +pdm add --lockfile=pdm-py39+macos.lock +``` + +Remember to update all relevant lock files when adding or updating dependencies. + +### Regenerate the lock file + +If you need to regenerate the lock file, you can use the following command: + +```shell +# Example for macos and Python 3.8 +pdm lock --python="==3.8.*" --platform=macos --with pyvista --with openpyxl --lockfile=pdm-py38macos.lock +``` + +```shell +# Example for Windows and Python 3.9+ +pdm lock --python="==3.8.*" --platform=windows --with pyvista --with openpyxl --lockfile=pdm-py39+win.lock +``` + +```shell +# Example for Linux and Python 3.9+ +pdm lock --python="==3.8.*" --platform=linux --with pyvista --with openpyxl --lockfile=pdm-py39+unix.lock +``` + +### Install pre-commit + +```shell +pdm run pre-commit install --hook-type pre-commit --hook-type pre-push +``` + +## Run the project + +Linux/MAC: +```shell +pdm run src/pyoma2/main.py +``` + +## Updating lock files + +To update the lock files for different platforms and Python versions, use the following commands: + +For Python 3.8 (Linux/Windows): +```shell +pdm lock --python="3.8" --lockfile=pdm-py38.lock +``` + +For Python 3.8 (macOS): +```shell +pdm lock --python="3.8" --platform=macos --lockfile=pdm-py38macos.lock +``` + +For Python 3.9+ (Linux/Windows): +```shell +pdm lock --python=">=3.9" --lockfile=pdm-py39+.lock +``` + +For Python 3.9+ (macOS): +```shell +pdm lock --python=">=3.9" --platform=macos --lockfile=pdm-py39+macos.lock +``` + +Make sure to update all relevant lock files when making changes to the project dependencies. + +Windows + +```powershell +pdm run .\src\pyoma2\main.py +``` + +You'll probably need to install **tk** for the GUI on your system, here some instructions: + +Windows: + +https://www.pythonguis.com/installation/install-tkinter-windows/ + + +Linux: + +https://www.pythonguis.com/installation/install-tkinter-linux/ + +Mac: + +https://www.pythonguis.com/installation/install-tkinter-mac/ + +If using python with `pyenv`: + +https://dev.to/xshapira/using-tkinter-with-pyenv-a-simple-two-step-guide-hh5 + +### Building the lock file + +Due to [NEP 29](https://numpy.org/neps/nep-0029-deprecation_policy.html), Numpy drops support for active versions of Python before their support ends. Therefore, there are versions of numpy that cannot be installed for certain active versions of Python and this leads to PDM unable to resolve the dependencies, or attempting to install a version of numpy that does not have a wheel. + +By following [Lock for specific platforms or Python versions](https://pdm-project.org/en/latest/usage/lock-targets/), you can generate a single lock file for multiple versions of Python with: + +``` +pdm lock --python=">=3.9" --with pyvista --with openpyxl +pdm lock --python="==3.8.*" --with pyvista --with openpyxl +``` + +When bumping the minimum supported version of Python in `pyproject` (`requires-python`), be sure to also bump the conditional numpy versions supported. For example, when Python 3.8 is dropped, you will have to modify: + +``` + "numpy<1.25; python_version < '3.9'", + "numpy>=1.25; python_version >= '3.9'", +``` + +to (this is just a guess; numpy versions will have to change): + +``` + "numpy<2.0; python_version < '3.10'", + "numpy>=2.0; python_version >= '3.10'", +``` + +## Running tests + +```shell +make test +``` + +### Running tests with coverage + +```shell +make test-coverage +``` + +### Running tests with tox on multiple python versions + +```shell +make tox +``` + +### Running tests on + +## Conventions + +### Commits + +Use conventional commits guidelines https://www.conventionalcommits.org/en/v1.0.0/ diff --git a/Examples/Example1.ipynb b/Examples/Example1.ipynb new file mode 100644 index 0000000..5f4200c --- /dev/null +++ b/Examples/Example1.ipynb @@ -0,0 +1,306 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "90735c1f-eb61-43ef-925c-e9c1d50616ce", + "metadata": {}, + "source": [ + "# Example1 - Getting started" + ] + }, + { + "cell_type": "markdown", + "id": "9635ee93-a41f-49d7-81cb-8e92d18ff4b5", + "metadata": {}, + "source": [ + "In this first example we'll take a look at a simple 5 degrees of freedom (DOF) system. \n", + "\n", + "To access the data and the exact results of the system we can call the ```example_data()``` function under the submodule ```functions.gen```\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "d7254a40-7189-420d-819c-0c54272c9acc", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "the natural frequencies are: [0.89 2.598 4.095 5.261 6. ] \n", + "\n", + "the damping is: 0.02 \n", + "\n", + "the (column-wise) mode shape matrix: \n", + "[[-0.285 -0.764 1. -0.919 -0.546]\n", + " [-0.546 -1. 0.285 0.764 0.919]\n", + " [-0.764 -0.546 -0.919 0.285 -1. ]\n", + " [-0.919 0.285 -0.546 -1. 0.764]\n", + " [-1. 0.919 0.764 0.546 -0.285]] \n", + "\n" + ] + } + ], + "source": [ + "import os\n", + "import sys\n", + "import numpy as np\n", + "# Add the directory we executed the script from to path:\n", + "sys.path.insert(0, os.path.realpath('__file__'))\n", + "\n", + "# import the function to generate the example dataset\n", + "from pyoma2.functions.gen import example_data\n", + "\n", + "# generate example data and results\n", + "data, ground_truth = example_data()\n", + "\n", + "# Print the exact results\n", + "np.set_printoptions(precision=3)\n", + "print(f\"the natural frequencies are: {ground_truth[0]} \\n\")\n", + "print(f\"the damping is: {ground_truth[2]} \\n\")\n", + "print(\"the (column-wise) mode shape matrix: \\n\"\n", + "f\"{ground_truth[1]} \\n\")" + ] + }, + { + "cell_type": "markdown", + "id": "1543c3e2-44a3-4570-81ff-72bbe877a882", + "metadata": {}, + "source": [ + "Now we can instantiate the ```SingleSetup``` class, passing the dataset and the sampling frequency as arguments" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "1e83ebe6-a78a-4298-ae19-849dcdc870ed", + "metadata": {}, + "outputs": [], + "source": [ + "from pyoma2.setup.single import SingleSetup\n", + "\n", + "simp_5dof = SingleSetup(data, fs=600)" + ] + }, + { + "cell_type": "markdown", + "id": "dd10ab65-be17-462d-ad1e-f4322e2efd34", + "metadata": {}, + "source": [ + "Since the maximum frequency is at approximately 6Hz, we can decimate the signal quite a bit. To do this we can call the ```decimate_data()``` method" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "83f6c049-5f4a-497e-88cb-f0fa9737bdd3", + "metadata": {}, + "outputs": [], + "source": [ + "# Decimate the data\n", + "simp_5dof.decimate_data(q=30)" + ] + }, + { + "cell_type": "markdown", + "id": "0b180093-0a71-4105-94e6-5ded87b1f1b9", + "metadata": {}, + "source": [ + "To analise the data we need to instanciate the desired algorithm to use with a name and the required arguments." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "6e3e4972-4c63-44eb-ad9d-31e04f9b7932", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-01-22 19:21:55,424 - pyoma2.setup.base - INFO - Running FDD... (base:123)\n", + "2025-01-22 19:21:55,434 - pyoma2.setup.base - INFO - Running SSIdat... (base:123)\n", + "2025-01-22 19:21:55,435 - pyoma2.functions.ssi - INFO - Assembling Hankel matrix method: dat... (ssi:82)\n", + "2025-01-22 19:21:55,565 - pyoma2.functions.ssi - INFO - SSI for increasing model order... (ssi:319)\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 31/31 [00:00<00:00, 16701.79it/s]\n", + "2025-01-22 19:21:55,582 - pyoma2.functions.ssi - INFO - Calculating modal parameters for increasing model order... (ssi:484)\n", + "100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 31/31 [00:00<00:00, 4832.51it/s]\n", + "2025-01-22 19:21:55,622 - pyoma2.setup.base - INFO - all done (base:102)\n" + ] + } + ], + "source": [ + "from pyoma2.algorithms.fdd import FDD\n", + "from pyoma2.algorithms.ssi import SSIdat\n", + "\n", + "# Initialise the algorithms\n", + "fdd = FDD(name=\"FDD\", nxseg=1024, method_SD=\"cor\")\n", + "ssidat = SSIdat(name=\"SSIdat\", br=30, ordmax=30)\n", + "\n", + "# Add algorithms to the class\n", + "simp_5dof.add_algorithms(fdd, ssidat)\n", + "\n", + "# run\n", + "simp_5dof.run_all()" + ] + }, + { + "cell_type": "markdown", + "id": "3a84ac60-b333-4f10-a33b-2657e1ced413", + "metadata": {}, + "source": [ + "We can now check the results" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "293190de-208f-461d-a4a6-a066d3114afe", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# plot singular values of the spectral density matrix\n", + "_, _ = fdd.plot_CMIF(freqlim=(0,8))\n", + "\n", + "# plot the stabilisation diagram\n", + "_, _ = ssidat.plot_stab(freqlim=(0,10),hide_poles=False)" + ] + }, + { + "cell_type": "markdown", + "id": "53dce485-7d8d-4716-8bc2-fd6891da585f", + "metadata": {}, + "source": [ + "We can get the modal parameters with the help of an interactive plot calling the ```mpe_from_plot()``` method, or we can get the results \"manually\" with the ```mpe()``` method." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "948ff375-0e6c-4976-8469-866777da11df", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-01-22 19:21:55,785 - pyoma2.setup.base - INFO - Getting mpe modal parameters from SSIdat (base:149)\n", + "2025-01-22 19:21:55,785 - pyoma2.functions.ssi - INFO - Extracting SSI modal parameters (ssi:887)\n" + ] + } + ], + "source": [ + "# get the modal parameters with the interactive plot\n", + "# simp_ex.mpe_from_plot(\"SSIdat\", freqlim=(0,10))\n", + "\n", + "# or manually\n", + "simp_5dof.mpe(\"SSIdat\", sel_freq=[0.89, 2.598, 4.095, 5.261, 6.], order_in=\"find_min\")" + ] + }, + { + "cell_type": "markdown", + "id": "b721c477-cf2a-4381-801a-996d58f7cd52", + "metadata": {}, + "source": [ + "Now we can access all the results and compare them to the exact values." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "5b0a9f08-6578-4bce-ad3c-987e343b642a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "order out: 16 \n", + "\n", + "the natural frequencies are: [0.889 2.601 4.096 5.275 6.031] \n", + "\n", + "the dampings are: [0.028 0.018 0.018 0.024 0.022] \n", + "\n", + "the (column-wise) mode shape matrix:\n", + "[[ 0.266 0.814 1. 0.915 0.566]\n", + " [ 0.682 1. 0.235 -0.728 -0.959]\n", + " [ 0.846 0.556 -0.847 -0.308 1. ]\n", + " [ 1. -0.322 -0.524 1. -0.828]\n", + " [ 0.92 -0.895 0.812 -0.565 0.264]] \n", + "\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# dict of results\n", + "ssidat_res = dict(ssidat.result)\n", + "\n", + "from pyoma2.functions.plot import plot_mac_matrix\n", + "\n", + "# print the results\n", + "print(f\"order out: {ssidat_res['order_out']} \\n\")\n", + "print(f\"the natural frequencies are: {ssidat_res['Fn']} \\n\")\n", + "print(f\"the dampings are: {ssidat_res['Xi']} \\n\")\n", + "print(\"the (column-wise) mode shape matrix:\")\n", + "print(f\"{ssidat_res['Phi'].real} \\n\")\n", + "_, _ = plot_mac_matrix(ssidat_res['Phi'].real, ground_truth[1])" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.15" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Examples/Example2.ipynb b/Examples/Example2.ipynb new file mode 100644 index 0000000..5344875 --- /dev/null +++ b/Examples/Example2.ipynb @@ -0,0 +1,739 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "1e7210d6-0e76-4e51-bcac-a9753e21331a", + "metadata": {}, + "source": [ + "# Example2 - Real data set" + ] + }, + { + "cell_type": "markdown", + "id": "3fecbe89", + "metadata": {}, + "source": [ + "In this second example we will explore more functionalities with a real dataset from a CLT building, for more info **[APTF20](#ref-1)**.\n", + "\n", + "First of all we import the necessary modules.\n", + "Then we import the dataset we want to analyse and assign it to a variable.\n", + "All the files needed to run this example are available [here](https://github.com/dagghe/pyOMA-test-data/tree/main/test_data/palisaden)." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "5772675d-f285-4935-8256-1c819f50604c", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-01-22 19:42:49,103 - pyoma2.support.utils.sample_data - INFO - Palisaden_dataset.npy already exists locally. (sample_data:49)\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "from pyoma2.algorithms import FSDD, SSIcov, pLSCF\n", + "from pyoma2.setup import SingleSetup\n", + "from pyoma2.support.utils.sample_data import get_sample_data\n", + "\n", + "# load example dataset for single setup\n", + "data = np.load(get_sample_data(filename=\"Palisaden_dataset.npy\", folder=\"palisaden\"), allow_pickle=True)" + ] + }, + { + "cell_type": "markdown", + "id": "af59353b-4b43-417a-83eb-1e85362cc2bb", + "metadata": { + "tags": [] + }, + "source": [ + " Now we can proceed to instantiate the SingleSetup class, passing the dataset and the sampling frequency as parameters" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "ca2b6758-9d51-421e-85d3-24482d8a4570", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# create single setup\n", + "Pali_ss = SingleSetup(data, fs=100)" + ] + }, + { + "cell_type": "markdown", + "id": "67a32eaf-a301-4ea4-bb58-38390a69d921", + "metadata": {}, + "source": [ + "If we want to be able to plot the mode shapes, once we have the results, we need to define the geometry of the structure.\n", + "We have two different method available that offers unique plotting capabilities:\n", + "* The first method ```def_geo1()``` enables users to visualise mode shapes with arrows that represent the placement, direction, and magnitude of displacement for each sensor.\n", + "* The second method ```def_geo2()``` allows for the plotting and animation of mode shapes, with sensors mapped to user defined points." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "87ffdfb6-031b-4d45-aa55-294e198cc63d", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-01-22 19:42:49,119 - pyoma2.support.utils.sample_data - INFO - Geo1.xlsx already exists locally. (sample_data:49)\n", + "2025-01-22 19:42:49,119 - pyoma2.support.utils.sample_data - INFO - Geo2.xlsx already exists locally. (sample_data:49)\n" + ] + } + ], + "source": [ + "_geo1 = get_sample_data(filename=\"Geo1.xlsx\", folder=\"palisaden\")\n", + "_geo2 = get_sample_data(filename=\"Geo2.xlsx\", folder=\"palisaden\")\n", + "\n", + "Pali_ss.def_geo1_by_file(_geo1)\n", + "Pali_ss.def_geo2_by_file(_geo2)" + ] + }, + { + "cell_type": "markdown", + "id": "6d2c5cce-b6b8-43b5-abc6-7b338c64f849", + "metadata": {}, + "source": [ + "Once we have defined the geometry we can show it calling the ```plot_geo1()``` or ```plot_geo2()``` methods." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "42b87234-7ab5-4fe5-b6a8-024fae56a9fa", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the geometry (geometry1)\n", + "fig, ax = Pali_ss.plot_geo1()\n", + "# (geometry2) with pyvista\n", + "_ = Pali_ss.plot_geo2(scaleF=2)\n", + "# (geometry2) with matplotlib\n", + "_, _ = Pali_ss.plot_geo2_mpl(scaleF=2)" + ] + }, + { + "cell_type": "markdown", + "id": "256d0802-4700-4db4-90e3-ad5ad07deac3", + "metadata": {}, + "source": [ + "We can plot all the time histories of the channels calling the ```plot_data()``` method" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "162ff767-dc1b-462f-8adb-5e3a0465bbed", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the Time Histories\n", + "_, _ = Pali_ss.plot_data()" + ] + }, + { + "cell_type": "markdown", + "id": "6205e72d-84c3-48c9-90c0-f283a3614b25", + "metadata": {}, + "source": [ + "We can also get more info regarding the quality of the data for a specific channel calling the ```plot_ch_info()``` method" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "100e4b09-a547-416c-bde5-ff4e29186d5f", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot TH, PSD and KDE of the (selected) channels\n", + "_, _ = Pali_ss.plot_ch_info(ch_idx=[-1])" + ] + }, + { + "cell_type": "markdown", + "id": "648ca292-e924-4798-9c10-0f8711e9e4aa", + "metadata": { + "tags": [] + }, + "source": [ + "As we can see from the auto correlation there's a low frequency component in the data. \n", + "\n", + "Other than the ```detrend_data()``` and ```decimate_data()``` methods there's also a ```filter_data()```\n", + "method that can help us here. " + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "a562b5a6-9e13-41ed-b1a9-80b9bc662777", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Detrend and decimate\n", + "#Pali_ss.detrend_data()\n", + "Pali_ss.filter_data(Wn=(0.1), order=8, btype=\"highpass\")\n", + "Pali_ss.decimate_data(q=5)\n", + "_, _ = Pali_ss.plot_ch_info(ch_idx=[-1])" + ] + }, + { + "cell_type": "markdown", + "id": "c1083d2d-b2a6-4c22-b81c-c7eaceeaaca2", + "metadata": { + "tags": [] + }, + "source": [ + "We need now to instantiate the algorithms that we want to run, e.g. ```FSDD``` and ```SSIcov```. The algorithms must then be added to the setup class using the\n", + "```add_algorithms()``` method.\n", + "Thereafter, the algorithms can be executed either individually using the ```run_by_name()``` method or collectively with ```run_all()```." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "0172000b-f676-4371-bec5-4f639700857d", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-01-22 19:42:51,122 - pyoma2.setup.base - INFO - Running SSIcov... (base:123)\n", + "2025-01-22 19:42:51,122 - pyoma2.functions.ssi - INFO - Assembling Hankel matrix method: cov... (ssi:82)\n", + "2025-01-22 19:42:51,250 - pyoma2.functions.ssi - INFO - ... calculating cov(H)... (ssi:93)\n", + "2025-01-22 19:42:51,387 - pyoma2.functions.ssi - INFO - SSI for increasing model order... (ssi:319)\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 31/31 [00:00<00:00, 29530.64it/s]\n", + "2025-01-22 19:42:51,414 - pyoma2.functions.ssi - INFO - ... propagating uncertainty... (ssi:446)\n", + "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 30/30 [00:00<00:00, 42.61it/s]\n", + "2025-01-22 19:42:52,119 - pyoma2.functions.ssi - INFO - Calculating modal parameters for increasing model order... (ssi:484)\n", + "100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 31/31 [00:00<00:00, 247.04it/s]\n", + "2025-01-22 19:42:52,279 - pyoma2.setup.base - INFO - Running FSDD... (base:123)\n", + "2025-01-22 19:42:52,325 - pyoma2.setup.base - INFO - Running polymax... (base:123)\n", + "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 30/30 [00:00<00:00, 32.02it/s]\n" + ] + } + ], + "source": [ + "# Initialise the algorithms\n", + "fsdd = FSDD(name=\"FSDD\", nxseg=1024, method_SD=\"cor\")\n", + "ssicov = SSIcov(name=\"SSIcov\", br=30, ordmax=30, calc_unc=True)\n", + "plscf = pLSCF(name=\"polymax\",ordmax=30)\n", + "\n", + "# Overwrite/update run parameters for an algorithm\n", + "fsdd.run_params = FSDD.RunParamCls(nxseg=2048, method_SD=\"per\", pov=0.5)\n", + "\n", + "# Add algorithms to the single setup class\n", + "Pali_ss.add_algorithms(ssicov, fsdd, plscf)\n", + "\n", + "# Run all or run by name\n", + "Pali_ss.run_by_name(\"SSIcov\")\n", + "Pali_ss.run_by_name(\"FSDD\")\n", + "Pali_ss.run_by_name(\"polymax\")\n", + "# Pali_ss.run_all()\n", + "\n", + "# save dict of results\n", + "ssi_res = ssicov.result.model_dump()\n", + "fsdd_res = dict(fsdd.result)" + ] + }, + { + "cell_type": "markdown", + "id": "36461cf1-9956-43cb-aa10-b709ff5c67c8", + "metadata": {}, + "source": [ + "We can now plot some of the results:" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "0f957e31-02ab-4433-8414-81926c9eef45", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# plot Singular values of PSD\n", + "_, _ = fsdd.plot_CMIF(freqlim=(1,4))" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "201b515d-0fb3-42e7-8c38-06af1ac1eddd", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# plot Stabilisation chart for SSI\n", + "_, _ = ssicov.plot_stab(freqlim=(1,4), hide_poles=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "603bb370-5c37-4282-afa5-29fceb158515", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# plot frequecy-damping clusters for SSI\n", + "_, _ = ssicov.plot_freqvsdamp(freqlim=(1,4))" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "9e988ee5-d5b0-475a-bb52-50e06e9b7e75", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAxUAAAJOCAYAAADBIyqKAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAABoIklEQVR4nO3dfXxT9d3/8XfahpbaAi2lpYwK2AiOiswCU7wZIIIFb1DEdrBLQXG/eUE78V7oFJC1OKeA0Et06pDplHYoqBMqHePGG1BARCxOpCuC19qhlPtCacj5/dGrmbE3JE2Tkyav5+PRR3JOvjnnc76fnDSfnO/JsRiGYQgAAAAAWijM7AAAAAAAtG0UFQAAAAC8QlEBAAAAwCsUFQAAAAC8QlEBAAAAwCsUFQAAAAC8QlEBAAAAwCsUFQAAAAC8QlEBAAAAwCsUFQDgpY8++kg33XSTzj33XEVGRiopKUmDBw/Wfffd59LumWee0UsvveTVuiwWi7Kzs8/abv369bJYLFq/fr1z3qxZs2SxWFzaDR06VEOHDvUqpqZUV1dr1qxZLjHUe+mll2SxWLR3716frPtsHA6HXn75ZV199dVKSEiQ1WpVYmKirrvuOr399ttyOByS/tOPy5cv90tcq1at0qxZs/yyLgBoTRQVAOCFd955R5dddpmOHj2qJ554QmvWrNHTTz+tyy+/XIWFhS5tW6OocFd6ero2bdqk9PT0Zts988wzeuaZZ3wSQ3V1tWbPnt1oUXHttddq06ZNSk5O9sm6m3Pq1CmNHj1aEydOVGJiohYvXqy///3vevbZZ9WtWzfdcsstevvtt/0el1RXVMyePduUdQOANyLMDgAA2rInnnhCvXr10rvvvquIiP+8pf785z/XE088YVpcHTp00KWXXnrWdn379vVDNA116dJFXbp0MWXd9957r959910tXbpUt912m8tjY8eO1QMPPKCTJ0/6Nabq6mpFR0f7dZ0A0Jo4UgEAXjh48KASEhJcCop6YWH/eYvt2bOnSktLtWHDBlksFlksFvXs2VNS3Tfn9913n37yk5+oY8eOio+P1+DBg/Xmm282ud7nnntOvXv3VmRkpPr27atly5a5PN7Y8KfGNDb8afHixerfv79iYmIUGxurCy64QDNmzHA+/u2332rKlCnq27evYmJilJiYqKuuukrvvfees83evXudRcPs2bOd2zxp0iRJTQ9/+uMf/6j+/fsrKipK8fHxuummm/TFF1+4tJk0aZJiYmK0Z88ejR49WjExMUpJSdF9992nmpqaZre3srJSL7zwgq655poGBUW9888/XxdddJHLvNraWuXm5qpbt27q0KGDrr76an355ZcubUpKSjRmzBh1795dUVFRstls+tWvfqXvvvvOpV39MLRPPvlE48aNU1xcnFJTUzVp0iT9z//8jyQ5+8vMIWIA4AmOVACAFwYPHqwXXnhBv/71r/WLX/xC6enpslqtDdqtWLFC48aNU8eOHZ3DjSIjIyVJNTU1qqqq0v33368f/ehHOn36tP72t79p7NixWrJkSYMPv2+99ZbWrVunxx57TOecc46eeeYZjR8/XhERERo3bpxX27Ns2TJNmTJFOTk5evLJJxUWFqY9e/Zo165dzjZVVVWSpJkzZ6pr1646fvy4VqxYoaFDh2rt2rUaOnSokpOTVVxcrIyMDE2ePFl33nmnJDV7dGLu3LmaMWOGxo8fr7lz5+rgwYOaNWuWBg8erC1btuj88893tq2trdUNN9ygyZMn67777tPGjRs1Z84cdezYUY8++miT61i3bp1qa2t14403etQvM2bM0OWXX64XXnhBR48e1UMPPaTrr79eX3zxhcLDwyVJZWVlGjx4sO6880517NhRe/fu1bx583TFFVdo586dDV4XY8eO1c9//nPdddddOnHihC688EKdOHFCy5cv16ZNm5ztzBgiBgAeMwAALfbdd98ZV1xxhSHJkGRYrVbjsssuM+bOnWscO3bMpW1aWpoxZMiQsy7TbrcbtbW1xuTJk42LL77Y5TFJRvv27Y3KykqX9hdccIFhs9mc89atW2dIMtatW+ecN3PmTOOHb/tDhgxxiSk7O9vo1KmTG1veMN7hw4cbN910k3P+t99+a0gyZs6c2eA5S5YsMSQZ5eXlhmEYxqFDh4z27dsbo0ePdmm3b98+IzIy0pgwYYJz3sSJEw1JRlFRkUvb0aNHG3369Gk21scff9yQZBQXF7u1bfX9+MO4ioqKDEnGpk2bGn2ew+Ewamtrja+//tqQZLz55pvOx+rz8OijjzZ43tSpUxvkCADaAoY/AYAXOnfurPfee09btmzR448/rjFjxmj37t2aPn26+vXr12DoS1P+8pe/6PLLL1dMTIwiIiJktVr14osvNhj6I0nDhw9XUlKSczo8PFxZWVnas2ePvvnmG6+256c//akOHz6s8ePH680332wy/meffVbp6emKiopyxrt27dpG43XHpk2bdPLkSefwqHopKSm66qqrtHbtWpf5FotF119/vcu8iy66SF9//XWL1n82N9xwQ4N1SXJZ34EDB3TXXXcpJSXF2Sc9evSQpEb75eabb/ZJrABgBooKAGgFAwcO1EMPPaS//OUv+te//qV77rlHe/fudetk7TfeeEOZmZn60Y9+pFdeeUWbNm3Sli1bdMcdd+jUqVMN2nft2rXJeQcPHvRqO2699Vb98Y9/1Ndff62bb75ZiYmJuuSSS1RSUuJsM2/ePP33f/+3LrnkEr3++uvavHmztmzZooyMjBaf4Fwfd2NDfbp169Zgu6KjoxUVFeUyLzIystH++r5zzz1XklReXu5RfJ07d26wLknO7XU4HBo5cqTeeOMNPfjgg1q7dq0+/vhjbd682aXd9zGsCUAw4ZwKAGhlVqtVM2fO1Pz58/X555+ftf0rr7yiXr16qbCw0OU6Ek2ddFxZWdnkvB9++G2J22+/XbfffrtOnDihjRs3aubMmbruuuu0e/du9ejRQ6+88oqGDh2qxYsXuzzv2LFjLV5nfdwVFRUNHvvXv/6lhISEFi/7+4YNGyar1aqVK1fqrrvuapVlStLnn3+uHTt26KWXXtLEiROd8/fs2dPkc354zRAAaMs4UgEAXmjsQ7D0n+Eu3bp1c86LjIxs9Btri8Widu3auXzIrKysbPLXn9auXat///vfzukzZ86osLBQqamp6t69e4u2ozHnnHOORo0apdzcXJ0+fVqlpaXOeOu/qa/32WefuZxcLDX8Nr85gwcPVvv27fXKK6+4zP/mm2/097//XcOHD/dmU5y6du2qO++8U++++67+9Kc/NdqmrKxMn332mUfLrc/dD/vlueee82g5nvQZAAQSjlQAgBeuueYade/eXddff70uuOACORwOffrpp3rqqacUExOju+++29m2X79+WrZsmQoLC3XeeecpKipK/fr103XXXac33nhDU6ZM0bhx47R//37NmTNHycnJ+uqrrxqsMyEhQVdddZUeeeQR568//eMf/2jws7It8ctf/lLt27fX5ZdfruTkZFVWVmru3Lnq2LGjBg0aJEm67rrrNGfOHM2cOVNDhgzRl19+qccee0y9evWS3W53Lis2NlY9evTQm2++qeHDhys+Pl4JCQnOn9L9vk6dOumRRx7RjBkzdNttt2n8+PE6ePCgZs+eraioKM2cOdPrbas3b948/fOf/9SkSZP07rvv6qabblJSUpK+++47lZSUaMmSJVq2bFmDn5VtzgUXXKDU1FQ9/PDDMgxD8fHxevvtt12GjbmjX79+kqTf/e53GjVqlMLDw3XRRRepXbt2Hi0HAPzO7DPFAaAtKywsNCZMmGCcf/75RkxMjGG1Wo1zzz3XuPXWW41du3a5tN27d68xcuRIIzY21pBk9OjRw/nY448/bvTs2dOIjIw0fvzjHxvPP/98o7/WJMmYOnWq8cwzzxipqamG1Wo1LrjgAuPPf/6zS7uW/vrT0qVLjWHDhhlJSUlGu3btjG7duhmZmZnGZ5995mxTU1Nj3H///caPfvQjIyoqykhPTzdWrlxpTJw40WWbDMMw/va3vxkXX3yxERkZaUgyJk6caBhGw19/qvfCCy8YF110kdGuXTujY8eOxpgxY4zS0lKXNhMnTjTOOeecH6ai0e1rit1uN5YuXWpcddVVRnx8vBEREWF06dLFGDVqlPHqq68aZ86ccenHv/zlLy7PLy8vNyQZS5Yscc7btWuXMWLECCM2NtaIi4szbrnlFmPfvn0NfgGrPs5vv/22QVw1NTXGnXfeaXTp0sWwWCyN9hEABCKLYRiGKdUMAAAAgKDAORUAAAAAvEJRAQAAAMArFBUAAAAAvEJRAQAAAMArFBUAAAAAvEJRAQAAAMArQX/xO4fDoX/961+KjY11uVotAAAAEIoMw9CxY8fUrVs3hYW1zjGGoC8q/vWvfyklJcXsMAAAAICAsn//fnXv3r1VlhX0RUVsbKwkqby8XPHx8SZHg9ZUW1urNWvWaOTIkbJarWaHg1ZCXoMXuQ1e5DY4kdfgVVVVpV69ejk/J7eGoC8q6oc8xcbGqkOHDiZHg9ZUW1ur6OhodejQgTe7IEJegxe5DV7kNjiR1+BVW1srSa16agAnagMAAADwCkUFAAAAAK9QVAAAAADwCkUFAAAAAK9QVAAAAADwCkUFAAAAAK9QVAAAAADwCkUFAAAAAK9QVAAAAADwiqlFxeLFi3XRRRepQ4cO6tChgwYPHqzVq1c7HzcMQ7NmzVK3bt3Uvn17DR06VKWlpSZGDAAAAOCHTC0qunfvrscff1xbt27V1q1bddVVV2nMmDHOwuGJJ57QvHnzVFBQoC1btqhr164aMWKEjh07ZmbYAAAAAL7H1KLi+uuv1+jRo9W7d2/17t1beXl5iomJ0ebNm2UYhhYsWKDc3FyNHTtWF154oZYuXarq6mq9+uqrZoYNAAAA4HsC5pyKM2fOaNmyZTpx4oQGDx6s8vJyVVZWauTIkc42kZGRGjJkiD788EMTIwUAAADwfRFmB7Bz504NHjxYp06dUkxMjFasWKG+ffs6C4ekpCSX9klJSfr666+bXF5NTY1qamqc00ePHpUk1dbWqra21gdbALPU55O8BhfyGrzIbfAit8GJvAYvX+TU9KKiT58++vTTT3X48GG9/vrrmjhxojZs2OB83GKxuLQ3DKPBvO+bO3euZs+e3WD+unXrFB0d3XqBI2CUlJSYHQJ8gLwGL3IbvMhtcCKvwae6urrVl2kxDMNo9aV64eqrr1Zqaqoeeughpaam6pNPPtHFF1/sfHzMmDHq1KmTli5d2ujzGztSkZKSooqKCnXu3Nnn8cN/amtrVVJSohEjRshqtZodDloJeQ1e5DZ4kdvgRF6D18GDB5WcnKwjR46oQ4cOrbJM049U/JBhGKqpqVGvXr3UtWtXlZSUOIuK06dPa8OGDfrd737X5PMjIyMVGRnZYL7VamWHCFLkNjiR1+BFboMXuQ1O5DX4+CKfphYVM2bM0KhRo5SSkqJjx45p2bJlWr9+vYqLi2WxWDRt2jTl5+fr/PPP1/nnn6/8/HxFR0drwoQJZoYNAAAA4HtMLSr+/e9/69Zbb1VFRYU6duyoiy66SMXFxRoxYoQk6cEHH9TJkyc1ZcoUHTp0SJdcconWrFmj2NhYM8MGAAAA8D2mFhUvvvhis49bLBbNmjVLs2bN8k9AAAAAADwWMNepAAAAANA2UVQAAAAA8ApFBQAAAACvUFQAAAAA8ApFBQCgUXaHXQeOH5DdYTc7FFOE+vYDgCcoKgAALopKi2RbaJN1jlVJTyXJOscq20KbikqLzA7NL0J9+wGgJSgqAABOOatylLU8S2WHylzmlx0qU9byLOWsyjEpMv8I9e0HgJaiqAAASKr7hr5gS0GzbQq2FATtN/ahvv0A4A2KCgDNu/xyKTq67hZBbcbaGW61y12b6+NIzBHq2w8EjNxcKT297hZthqlX1AYQ4C6/XPrww7r7H35YN/3BB+bGBJ+wO+wNhvw0Zc+hPXI4HAoLC57vpUJ9+4GAkZsr5efX3d++ve42L8+8eOA23hEBNK3+Db2paQSNquoqz9qf8qx9oAv17QcCxurVrtPFxebEAY9RVABo2sUXNz+NoBEfHe9Z+yjP2ge6UN9+IGCMGuU6nZFhThzwGMOfADTtgw/qhjxt315XUDD0KWhFhEUoNS7VrSFAtjhb0A39CfXtBwJG/VCn4uK6goKhT20G74oAmvfBB1J1NQVFCMgfnu9Wu7zhwflPPtS3HwgYeXnStm0UFG0MRQUAQJKUmZap7EHZzbbJHpStzLRMP0XkX6G+/QDgDYoKAIDTotGLVDiuULY4m8t8W5xNheMKtWj0IpMi849Q334AaCnOqQAAuMhMy1RmWqbsDruqqquUEJ0QUucQhPr2A0BLUFQAABoVERahxJhEs8MwTahvPwB4gq9eAAAAAHiFogIAAACAVygqADTL7rDrwPEDsjvsZocCPwv13If69gOAJygqADSqqLRItoU2WedYlfRUkqxzrLIttKmotMjs0OBjoZ77UN9+AGgJigoADeSsylHW8qwGVxcuO1SmrOVZylmVY1Jk8LVQz32obz8AtBRFBQAXRaVFKthS0Gybgi0FfGsbhEI996G+/QDgDYoKAC5mrJ3hVrvctbk+jgT+Fuq5D/XtBwJGbq6Unl53izaD61QAcLI77A2GfTRlz6E9cjgcXBQsSIR67kN9+4GAkZsr5efX3d++ve42L8+8eOA23hEBOFVVV3nW/pRn7RG4Qj33ob79QMBYvdp1urjYnDjgMYoKAE7x0fGetY/yrD0CV6jnPtS3HwgYo0a5TmdkmBMHPMbwJwBOEWERSo1LdWsYiC3OxvCPIBLquQ/17QcCRv1Qp+LiuoKCoU9tBu+KAFzkD893q13ecN7og02o5z7Utx8IGHl50rZtFBRtDEUFABeZaZnKHpTdbJvsQdnKTMv0U0Twl1DPfahvPwB4g6ICQAOLRi9S4bhC2eJsLvNtcTYVjivUotGLTIoMvhbquQ/17QeAluKcCgCNykzLVGZapuwOu6qqq5QQncA48hAR6rkP9e0HgJagqADQrIiwCCXGJJodBkwQ6rkP9e0HAE/w1QsAAAAAr1BUAAAAAPAKRQUAAAAAr1BUAGiW3WHXgeMHZHfYzQ4FfhbquQ/17QcAT1BUAGhUUWmRbAttss6xKumpJFnnWGVbaFNRaZHZocHHQj33ob79ANASFBUAGshZlaOs5VkqO1TmMr/sUJmylmcpZ1WOSZHB10I996G+/QDQUhQVAFwUlRapYEtBs20KthTwrW0QCvXch/r2A4A3KCoAuJixdoZb7XLX5vo4EvhbqOc+1LcfCBi5uVJ6et0t2gwufgfAye6wNxj20ZQ9h/bI4XBwpeEgEeq5D/XtBwJGbq6Un193f/v2utu8PPPigdt4RwTgVFVd5Vn7U561R+AK9dyH+vYDAWP1atfp4mJz4oDHKCoAOMVHx3vWPsqz9ghcoZ77UN9+IGCMGuU6nZFhThzwGMOfADhFhEUoNS7VrWEgtjgbwz+CSKjnPtS3HwgY9UOdiovrCgqGPrUZvCsCcJE/PN+tdnnDeaMPNqGe+1DffiBg5OVJ27ZRULQxFBUAXGSmZSp7UHazbbIHZSszLdNPEcFfQj33ob79AOANigoADSwavUiF4wpli7O5zLfF2VQ4rlCLRi8yKTL4WqjnPtS3HwBainMqADQqMy1TmWmZsjvsqqquUkJ0AuPIQ0So5z7Utx8AWoKiAkCzIsIilBiTaHYYMEGo5z7Utx8APMFXLwAAAAC8QlEBAAAAwCsUFQCARtkddh04fkB2h93sUEwR6tsPAJ6gqAAAuCgqLZJtoU3WOVYlPZUk6xyrbAttKiotMjs0vwj17QeAlqCoAAA45azKUdbyrAZXli47VKas5VnKWZVjUmT+EerbDwAtRVEBAJBU9w19wZaCZtsUbCkI2m/sQ337AcAbFBUAmpebK6Wn190iqM1YO8Otdrlrg/O1EOrbDwDe4DoVAJqWmyvl59fd37697jYvz7x44DN2h73BkJ+m7Dm0Rw6HI6guCBfq2w8A3uIdEUDTVq92nS4uNicO+FxVdZVn7U951j7Qhfr2A4C3KCoANG3UKNfpjAxz4oDPxUfHe9Y+yrP2gS7Utx8AvMXwJwBNqx/qVFxcV1Aw9CloRYRFKDUu1a0hQLY4W9AN/Qn17QcAb/GuCKB5eXnStm0UFCEgf3i+W+3yhgfnayHUtx8AvEFRAQCQJGWmZSp7UHazbbIHZSszLdNPEflXqG8/AHiDogIA4LRo9CIVjiuULc7mMt8WZ1PhuEItGr3IpMj8I9S3HwBainMqAAAuMtMylZmWKbvDrqrqKiVEJ4TUOQShvv0A0BIUFQCARkWERSgxJtHsMEwT6tsPAJ7gqxcAAAAAXqGoAAAAAOAVigoAQKPsDrsOHD8gu8NudiimoQ8AwD0UFQAAF0WlRbIttMk6x6qkp5JknWOVbaFNRaVFZofmN/QBAHjG1KJi7ty5GjRokGJjY5WYmKgbb7xRX375pUubSZMmyWKxuPxdeumlJkUMAMEtZ1WOspZnNbiydNmhMmUtz1LOqhyTIvMf+gAAPGdqUbFhwwZNnTpVmzdvVklJiex2u0aOHKkTJ064tMvIyFBFRYXzb9WqVSZFDADBq6i0SAVbCpptU7ClIKi/racPAKBlTC0qiouLNWnSJKWlpal///5asmSJ9u3bp23btrm0i4yMVNeuXZ1/8fHxJkUMhKDcXCk9ve4WQW3G2hlutctdG7yvBfoAMBn/c9qsgLpOxZEjRySpQdGwfv16JSYmqlOnThoyZIjy8vKUmNj4b4fX1NSopqbGOX306FFJUm1trWpra30UOcxQn0/y6kOPPSbNn193/x//kMLCpEcf9ekqyas57A57g+E+TdlzaI9qamo8viBcoOfWH30QrAI9t2gZv+fVhP85ocoXObUYhmG0+lJbwDAMjRkzRocOHdJ7773nnF9YWKiYmBj16NFD5eXleuSRR2S327Vt2zZFRkY2WM6sWbM0e/bsBvNfffVVRUdH+3QbAKCtOlx7WJNKJ7nd/k8X/kkdIjr4LiAT0AcAQkV1dbUmTJigI0eOqEOH1nkfC5iiYurUqXrnnXf0/vvvq3v37k22q6ioUI8ePbRs2TKNHTu2weONHalISUlRRUWFOnfu7JPYYY7a2lqVlJRoxIgRslqtZocTnB57THrqqf9M33efX45UkFf/szvsin7c/S9eTj18qkVHKgI5t/7og2AV6LlFy/g9ryb8zwlVBw8eVHJycqsWFQEx/CknJ0dvvfWWNm7c2GxBIUnJycnq0aOHvvrqq0Yfj4yMbPQIhtVq5Y0uSJFbH5ozR3I4pOJiKSOjbtpPyKt/WWVValyqW8N/bHG2Rt9n3V5XgObWn30QrAI1t/CO3/Jq4v+cUOOLfJr6FYthGMrOztYbb7yhv//97+rVq9dZn3Pw4EHt379fycnJfogQgPLypG3b6m4R1PKH57vVLm948L4W6APAZPzPabNMLSqmTp2qV155Ra+++qpiY2NVWVmpyspKnTx5UpJ0/Phx3X///dq0aZP27t2r9evX6/rrr1dCQoJuuukmM0MHgKCTmZap7EHZzbbJHpStzLRMP0Xkf/QBALSMqUXF4sWLdeTIEQ0dOlTJycnOv8LCQklSeHi4du7cqTFjxqh3796aOHGievfurU2bNik2NtbM0AEgKC0avUiF4wpli7O5zLfF2VQ4rlCLRi8yKTL/oQ8AwHOmnlNxtnPE27dvr3fffddP0QAApLpv6zPTMmV32FVVXaWE6ISQOyGZPgAAzwTEidoAgMATERahxJjGrwkUKugDAHAPX7sAAAAA8ApFBQAAAACvUFQAAAAA8ApFBYBm2R12HTh+QHaH3exQ4Gfknj4AAHdRVABoVFFpkWwLbbLOsSrpqSRZ51hlW2hTUWmR2aHBx8g9fQAAnqKoANBAzqocZS3PUtmhMpf5ZYfKlLU8SzmrckyKDL5G7ukDAGgJigoALopKi1SwpaDZNgVbCvjGNgiRe/oAAFqKogKAixlrZ7jVLndtro8jgb+Re/oAMF1urpSeXneLNoWL3wFwsjvsDYZ8NGXPoT1yOBxcZThIkHv6ADBdbq6Un193f/v2utu8PPPigUd4NwTgVFVd5Vn7U561R+Ai9/QBYLrVq12ni4vNiQMtQlEBwCk+Ot6z9lGetUfgIvf0AWC6UaNcpzMyzIkDLcLwJwBOEWERSo1LdWsIiC3OxtCPIELu6QPAdPVDnYqL6woKhj61KbwjAnCRPzzfrXZ5w3mzDzbknj4ATJeXJ23bRkHRBlFUAHCRmZap7EHZzbbJHpStzLRMP0UEfyH39AEAtBRFBYAGFo1epMJxhbLF2Vzm2+JsKhxXqEWjF5kUGXyN3NMHANASnFMBoFGZaZnKTMuU3WFXVXWVEqITGEMeIsg9fQAAnqKoANCsiLAIJcYkmh0GTEDu6QMAcBdfuwAAAADwCkUFAAAAAK9QVAAAGmV32HXg+AHZHXazQzENfQAA7qGoAAC4KCotkm2hTdY5ViU9lSTrHKtsC20qKi0yOzS/oQ8AwDMUFQAAp5xVOcpantXgqtJlh8qUtTxLOatyTIrMf+gDAPAcRQUAQFLdt/MFWwqabVOwpSCov62nDwCgZSgqADQvN1dKT6+7RVCbsXaGW+1y1wbva4E+AEzG/5w2i+tUAGhabq6Un193f/v2utu8PPPigc/YHfYGw32asufQHjkcjqC7GBx9AJiM/zltGu+GAJq2erXrdHGxOXHA56qqqzxrf8qz9m0BfQCYjP85bRpFBYCmjRrlOp2RYU4c8Ln46HjP2kd51r4toA8Ak/E/p01j+BOAptUfdi4urntz5zB00IoIi1BqXKpbw39scbagHPZDHwAm439Om8Y7IoDm5eVJ27bx5h4C8ofnu9Uub3jwvhboA8Bk/M9psygqAACSpMy0TGUPym62TfagbGWmZfopIv+jDwCgZSgqAABOi0YvUuG4QtnibC7zbXE2FY4r1KLRi0yKzH/oAwDwHOdUAABcZKZlKjMtU3aHXVXVVUqITgi58wfoAwDwDEUFAKBREWERSoxJNDsMU9EHAOAevnYBAAAA4BWKCgAAAABeoagA0Cy7w64Dxw/I7rCbHQr8jNzTBwDgLooKAI0qKi2SbaFN1jlWJT2VJOscq2wLbSoqLTI7NPgYuacPAMBTFBUAGshZlaOs5VkNrixcdqhMWcuzlLMqx6TI4Gvknj4AgJagqADgoqi0SAVbCpptU7ClgG9sgxC5pw8AoKUoKgC4mLF2hlvtctfm+jgS+Bu5pw8AoKUoKgA42R32BkM+mrLn0B45HA4fRwR/Iff0AQB4g6ICgFNVdZVn7U951h6Bi9zTBwDgDYoKAE7x0fGetY/yrD0CF7mnDwDAGxQVAJwiwiKUGpfqVltbnE1hYbyFBAtyTx8AgDd4RwTgIn94vlvt8obn+TgS+Bu5pw8AoKUoKgC4yEzLVPag7GbbZA/KVmZapp8igr+Qe/oAAFqKogJAA4tGL1LhuELZ4mwu821xNhWOK9Si0YtMigy+Ru7pAwBoiQizAwAQmDLTMpWZlim7w66q6iolRCcwhjxEkHv6AAA8RVEBoFkRYRFKjEk0OwyYgNzTBwDgLr52AQAAAOAVigoAAAAAXqGoAAAAAOAVigoAzbI77Dpw/IDsDrvZocDPQj33ob79AOAJigoAjSoqLZJtoU3WOVYlPZUk6xyrbAttKiotMjs0+Fio5z7Utx8AWoKiAkADOatylLU8S2WHylzmlx0qU9byLOWsyjEpMvhaqOc+1LcfAFqKogKAi6LSIhVsKWi2TcGWAr61DUKhnvtQ334A8AZFBQAXM9bOcKtd7tpcH0cCfwv13If69gOANygqADjZHfYGwz6asufQHjkcDh9HBH8J9dyH+vYDgLcoKgA4VVVXedb+lGftEbhCPfehvv0A4C2KCgBO8dHxnrWP8qw9Aleo5z7Utx8AvEVRAcApIixCqXGpbrW1xdkUFsZbSLAI9dyH+vYDgLd4VwTgIn94vlvt8obn+TgS+Fuo5z7Utx8AvEFRAcBFZlqmsgdlN9sme1C2MtMy/RQR/CXUcx/q2w8A3qCoANDAotGLVDiuULY4m8t8W5xNheMKtWj0IpMig6+Feu5DffsBoKUizA4AQGDKTMtUZlqm7A67qqqrlBCdwDjyEBHquQ/17QeAlqCoANCsiLAIJcYkmh0GTBDquQ/17QcAT/DVCwAAAACvUFQAAAAA8ApFBYBm2R12HTh+QHaH3exQ4EfknT4AAE9QVABoVFFpkWwLbbLOsSrpqSRZ51hlW2hTUWmR2aHBh8g7fQAALWFqUTF37lwNGjRIsbGxSkxM1I033qgvv/zSpY1hGJo1a5a6deum9u3ba+jQoSotLTUpYiA05KzKUdbyLJUdKnOZX3aoTFnLs5SzKsekyOBL5J0+AICWMrWo2LBhg6ZOnarNmzerpKREdrtdI0eO1IkTJ5xtnnjiCc2bN08FBQXasmWLunbtqhEjRujYsWMmRg4Er6LSIhVsKWi2TcGWAr61DTLknT4AAG+YWlQUFxdr0qRJSktLU//+/bVkyRLt27dP27Ztk1R3lGLBggXKzc3V2LFjdeGFF2rp0qWqrq7Wq6++amboQNCasXaGW+1y1+b6OBL4E3mnDwDAGwF1nYojR45IkuLj4yVJ5eXlqqys1MiRI51tIiMjNWTIEH344Yf61a9+1WAZNTU1qqmpcU4fPXpUklRbW6va2lpfhg8/q88neW09doe9wbCPpuw5tEc1NTWtflEw8up//sp7IOc2EF77bVkg5xYtR16Dly9yGjBFhWEYuvfee3XFFVfowgsvlCRVVlZKkpKSklzaJiUl6euvv250OXPnztXs2bMbzF+3bp2io6NbOWoEgpKSErNDCBqHaw971L7or0XqENHBJ7GQV//xd94DMbeB9NpvywIxt/AeeQ0+1dXVrb7MgCkqsrOz9dlnn+n9999v8JjFYnGZNgyjwbx606dP17333uucPnr0qFJSUjRs2DB17ty5dYOGqWpra1VSUqIRI0bIarWaHU5QsDvsmlQ6ye32mddl+uRIBXn1L3/lPZBzGwiv/bYskHOLliOvwevgwYOtvsyAKCpycnL01ltvaePGjerevbtzfteuXSXVHbFITk52zj9w4ECDoxf1IiMjFRkZ2WC+1WplhwhS5Lb1WGVValyqW8NAbHG2Rve1VouFvPqNv/MeiLkNpNd+WxaIuYX3yGvw8UU+Tf2axTAMZWdn64033tDf//539erVy+XxXr16qWvXri6H3U6fPq0NGzbosssu83e4QEjIH57vVru84Xk+jgT+RN7pAwDwhqlFxdSpU/XKK6/o1VdfVWxsrCorK1VZWamTJ09Kqhv2NG3aNOXn52vFihX6/PPPNWnSJEVHR2vChAlmhg4Ercy0TGUPym62TfagbGWmZfopIvgDeacPAMAbphYVixcv1pEjRzR06FAlJyc7/woLC51tHnzwQU2bNk1TpkzRwIED9b//+79as2aNYmNjTYwcCG6LRi9S4bhC2eJsLvNtcTYVjivUotGLTIoMvkTe6QMAaClTz6kwDOOsbSwWi2bNmqVZs2b5PiAATplpmcpMy5TdYVdVdZUSohM4MTUEkHf6AABaIiBO1AYQuCLCIpQYk2h2GPAz8k4fAIAn+OoFAAAAgFcoKgAAAAB4haICAIAm2B12HTh+QHaH3exQACCgUVQAAPADRaVFsi20yTrHqqSnkmSdY5VtoU1FpUVmhwYAAYmiAgCA78lZlaOs5VkNrq5ddqhMWcuzlLMqx6TIACBwUVQAAPB/ikqLVLCloNk2BVsKOGIBAD9AUQGgebm5Unp63S1CR4jmfcbaGW61y10bWv0CAGfDdSoANC03V8rPr7u/fXvdbV6eefHAP0I073aHvcGQp6bsObRHDoeDi+IBwP/h3RBA01avdp0uLjYnDvhXiOa9qrrKs/anPGsPAMGMogJA00aNcp3OyDAnDvhXiOY9Pjres/ZRnrUHgGDG8CcATasf8lJcXPfBMgSGwEAhm/eIsAilxqW6NQTKFmdj6BMAfA/viACal5cnbdsWMh8s8X9CNO/5w/Pdapc3PLT6BQDOhqICAID/k5mWqexB2c22yR6Urcy0TD9FBABtA0UFAADfs2j0IhWOK5QtzuYy3xZnU+G4Qi0avcikyAAgcHFOBQAAP5CZlqnMtEzZHXZVVVcpITqBcygAoBkUFQAANCEiLEKJMYlmhwEAAY+vXQAAAAB4haICAAAAgFcoKgAAAAB4haICwFnZHXYdOH5Adofd7FDgB+QbAOApigoATSoqLZJtoU3WOVYlPZUk6xyrbAttKiotMjs0+AD5BgC0FEUFgEblrMpR1vIslR0qc5lfdqhMWcuzlLMqx6TI4AvkGwDgDYoKAA0UlRapYEtBs20KthTwDXaQIN8AAG95VFTU1tbq9ttv1z//+U9fxQMgAMxYO8Otdrlrc30cCfyBfDchN1dKT6+7BQA0y6Oiwmq1asWKFb6KBUAAsDvsDYbANGXPoT1yOBw+jgi+RL6bkJsr5edL27fX3VJYAECzPB7+dNNNN2nlypU+CAVAIKiqrvKs/SnP2iOwkO8mrF7tOl1cbE4cANBGRHj6BJvNpjlz5ujDDz/UgAEDdM4557g8/utf/7rVggPgf/HR8Z61j/KsPQIL+W7CqFF1RynqZWSYFwsAtAEeFxUvvPCCOnXqpG3btmnbtm0uj1ksFooKoI2LCItQalyqW0NibHE2hYXxew9tGfluQl5e3W1xcV1BUT8NAGiUx0VFeXm5L+IAEEDyh+cra3nWWdvlDeeDVjAg303Iy6OYAAA3tfgrp9OnT+vLL7+U3c4VV4Fgk5mWqexB2c22yR6Urcy0TD9FBF8i3wAAb3lcVFRXV2vy5MmKjo5WWlqa9u3bJ6nuXIrHH3+81QMEYI5FoxepcFyhbHE2l/m2OJsKxxVq0ehFJkUGXyDfAABveDz8afr06dqxY4fWr1+vjO+duHb11Vdr5syZevjhh1s1QADmyUzLVGZapuwOu6qqq5QQnRA6Y+pDEPkGALSUx0XFypUrVVhYqEsvvVQWi8U5v2/fviorc++3zgG0LRFhEUqMSTQ7DPgJ+QYAeMrjr6C+/fZbJSY2/Gdz4sQJlyIDAAAAQGjwuKgYNGiQ3nnnHed0fSHx/PPPa/Dgwa0XGQAAAIA2wePhT3PnzlVGRoZ27dolu92up59+WqWlpdq0aZM2bNjgixgBAH5Uf05FfHS8IsI8/jcRNOgHAHCfx0cqLrvsMn3wwQeqrq5Wamqq1qxZo6SkJG3atEkDBgzwRYwAAD8oKi2SbaFN1jlWJT2VJOscq2wLbSoqLTI7NL+iHwDAcy366qVfv35aunRpa8cCADBJzqocFWwpaDC/7FCZspZn6b2v3wuJn5WlHwCgZdwqKo4ePer2Ajt06NDiYAAA/ldUWtToB+nvK9hSoCt7XBnUF8CjHwCg5dwa/tSpUyfFxcW59QcgCOXmSunpdbcIOjPWznCrXe7a4M4//QAALefWkYp169Y57+/du1cPP/ywJk2a5Py1p02bNmnp0qWaO3eub6IEYJ7cXCk/v+7+9u11t3l55sWDVmV32FV2yL1rDO05tEcOhyMoL4hHPwCAd9wqKoYMGeK8/9hjj2nevHkaP368c94NN9ygfv366Q9/+IMmTpzY+lECMM/q1a7TxcUUFUGkqrrKs/an6q60HWzoBwDwjsdfs2zatEkDBw5sMH/gwIH6+OOPWyUoAAFk1CjX6YwMc+KAT8RHx3vWPsqz9m0F/QAA3vG4qEhJSdGzzz7bYP5zzz2nlJSUVgkKQADJy5NmzKg7p2LGDI5SBJmIsAilxqW61dYWZwvaIT/0AwB4x+OflJ0/f75uvvlmvfvuu7r00kslSZs3b1ZZWZlef/31Vg8QQADIy6OYCGL5w/OVtTzrrO3yhgf3a4B+AICW8/irltGjR+urr77SmDFjVFVVpYMHD2rMmDHavXu3Ro8e7YsYAQA+lJmWqexB2c22yR6UHfQ/o0o/AEDLeXSkora2ViNHjtRzzz2nPL61BICgsWj0Il3Z40rlrs3VnkN7nPNtcTblDc8LmQ/S9AMAtIxHRYXVatXnn38ui8Xiq3gAACbJTMtUZlqm7A67qqrrft0oFM8doB8AwHMev0vedtttevHFF30RCwAgAESERSgxJjHkP0jTDwDgPo9P1D59+rReeOEFlZSUaODAgTrnnHNcHp83b16rBQcAAAAg8HlcVHz++edKT0+XJO3evdvlMYZFAQAAAKHH46Ji3bp1vogDABAg6s8liI+OV0SYx/8mggp9AQDuadE75OHDh7Vnzx5ZLBalpqaqU6dOrRwWAMDfikqLNGPtDJUdKnPOS41LVf7w/JD71SP6AgA849HZZ3v37tW1116rhIQEXXLJJfrpT3+qhIQEXXfdddq7d6+PQgQA+FrOqhxlLc9y+RAtSWWHypS1PEs5q3JMisz/6AsA8JzbRyr279+vSy+9VFarVXPmzNGPf/xjGYahL774QosXL9bgwYO1ZcsWde/e3ZfxAgBaWVFpkQq2FDTbpmBLga7scWXQf0tPXwBAy7h9pGLmzJnq06ePvvrqK02fPl033nijbrrpJs2YMUO7d+9W7969NXPmTF/GCsAsublSenrdLYLOjLUz3GqXuzb4809fAEDLuH2kori4WEVFRYqKimrwWPv27TVnzhz9/Oc/b9XgAASA3FwpP7/u/vbtdbd5eebFg1Zld9gbDPNpyp5De+RwOIL2ug30BQC0nNvvhgcPHlTPnj2bfPy8887TwYMHWyMmAIFk9WrX6eJic+KAT1RVV3nW/pRn7dsS+gIAWs7toqJbt24qLS1t8vHPP/9cycnJrRIUgAAyapTrdEaGOXHAJ+Kj4z1rH+VZ+7aEvgCAlnO7qBgzZoweeOABffvttw0eO3DggB566CHdeOONrRkbgECQlyfNmFF3TsWMGQx9CjIRYRFKjUt1q60tzhbUw33oCwBoOY9O1D516pRSU1M1ZcoULVy4UAsXLtRdd90lm82mkydP6tFHH/VlrADMkpcnbdtGQRGk8ofnu9Uub3jw55++AICWcftE7bi4OH300UeaMWOGli1bpsOHD0uSOnXqpAkTJigvL0/x8RwKBoC2JjMtU+99/V6zP6WaPSg7JH5Clb4AgJbx6NhtXFycFi9erIMHD6qyslKVlZU6ePCgnn32WXXu3NlXMQIAfGzR6EUqHFcoW5zNZb4tzqbCcYVaNHqRSZH5H30BAJ5z+0jF91ksFiUmJrZ2LAAAE2WmZSozLVN2h11V1VVKiE4I2fMG6AsA8EyLigoAQPCKCItQYgxfHEn0BQC4i69dAAAAAHiFogIAAACAVygqAAAAAHjFrXMqFi5c6PYCf/3rX7c4GAAAAABtj1tFxfz5891amMVi8aio2Lhxo37/+99r27Ztqqio0IoVK1yuyj1p0iQtXbrU5TmXXHKJNm/e7PY6AAAAAPiWW0VFeXm5T1Z+4sQJ9e/fX7fffrtuvvnmRttkZGRoyZIlzul27dr5JBYAAAAALdPin5Q9ffq0ysvLlZqaqoiIli1m1KhRGjVqVLNtIiMj1bVr1xYtHwAAAIDveXyidnV1tSZPnqzo6GilpaVp3759kurOpXj88cdbPcD169crMTFRvXv31i9/+UsdOHCg1dcB4Cxyc6X09LpbBD/yXYd+AAC3eXyIYfr06dqxY4fWr1+vjIwM5/yrr75aM2fO1MMPP9xqwY0aNUq33HKLevToofLycj3yyCO66qqrtG3bNkVGRjb6nJqaGtXU1Dinjx49Kkmqra1VbW1tq8UG89Xnk7z62GOPSfXnVf3jH1JYmPTooz5bHXk1mQ/z3aZy6+fXfVvXpnILt5HX4OWLnFoMwzA8eUKPHj1UWFioSy+9VLGxsdqxY4fOO+887dmzR+np6c4P8R4HYrE0OFH7hyoqKtSjRw8tW7ZMY8eObbTNrFmzNHv27AbzX331VUVHR7coNgAAACBYVFdXa8KECTpy5Ig6dOjQKsv0+EjFt99+q8TExAbzT5w4IYvF0ipBNSU5OVk9evTQV1991WSb6dOn695773VOHz16VCkpKRo2bJg6d+7s0/jgX7W1tSopKdGIESNktVrNDid4PfaY9NRT/5m+7z6fH6kgrybyYb7bVG79/Lpv69pUbuE28hq8Dh482OrL9LioGDRokN555x3l5ORIkrOQeP755zV48ODWje4HDh48qP379ys5ObnJNpGRkY0OjbJarewQQYrc+ticOZLDIRUXSxkZddN+QF5N4od8t4ncmvS6b+vaRG7hMfIafHyRT4+Lirlz5yojI0O7du2S3W7X008/rdLSUm3atEkbNmzwaFnHjx/Xnj17nNPl5eX69NNPFR8fr/j4eM2aNUs333yzkpOTtXfvXs2YMUMJCQm66aabPA0bgDfy8ur+EBrIdx36AQDc5vGvP1122WX64IMPVF1drdTUVK1Zs0ZJSUnatGmTBgwY4NGytm7dqosvvlgXX3yxJOnee+/VxRdfrEcffVTh4eHauXOnxowZo969e2vixInq3bu3Nm3apNjYWE/DBgAAAOAjLbrARL9+/Rpc6bolhg4dqubOE3/33Xe9XgcAAAAA33KrqPDkF51a6wxyAAAAAG2DW0VFp06d3P5lpzNnzngVEAAAAIC2xa2iYt26dc77e/fu1cMPP6xJkyY5f+1p06ZNWrp0qebOneubKAEAAAAELLeKiiFDhjjvP/bYY5o3b57Gjx/vnHfDDTeoX79++sMf/qCJEye2fpQAAAAAApbHv/60adMmDRw4sMH8gQMH6uOPP26VoAAA5rI77Dpw/IDsDrvZoQAA2gCPi4qUlBQ9++yzDeY/99xzSklJaZWgAADmKCotkm2hTdY5ViU9lSTrHKtsC20qKi0yOzQAQADz+Cdl58+fr5tvvlnvvvuuLr30UknS5s2bVVZWptdff73VAwQA+EfOqhwVbCloML/sUJmylmfpva/f06LRi0yIDAAQ6Dw+UjF69Gh99dVXuuGGG1RVVaWDBw9qzJgx2r17t0aPHu2LGAEAPlZUWtRoQfF9BVsKOGIBAGhUiy5+1717d+Xn57d2LAACTW6utHq1NGqUlJdndjTwoRlrZ7jVLndtrjLTMn0cTYBhPwCAs2pRUXH48GG9+OKL+uKLL2SxWNS3b1/dcccd6tixY2vHB8AsublS/ZcH27fX3fKBKijZHXaVHSpzq+2eQ3vkcDgUFubxge62if0AANzi8X+FrVu3KjU1VfPnz1dVVZW+++47zZs3T6mpqfrkk098ESMAM6xe7TpdXGxOHPC5quoqz9qf8qx9m8Z+AABu8biouOeee3TDDTdo7969euONN7RixQqVl5fruuuu07Rp03wQIgBTjBrlOp2RYU4c8Ln46HjP2kd51r5NYz8AALd4PPxp69atev755xUR8Z+nRkRE6MEHH2z0+hUA2qj6IR7FxXUfpBjyEbQiwiKUGpfq1hAoW5wtdIY+SewHAOAmj/8zdOjQQfv27Wswf//+/YqNjW2VoAAEiLw8ads2PkiFgPzh7v34Rt7wEHwtsB8AwFl5XFRkZWVp8uTJKiws1P79+/XNN99o2bJluvPOOzV+/HhfxAgA8LHMtExlD8putk32oOzQ++UnAIBbPB7+9OSTT8pisei2226T3W6XJFmtVv33f/+3Hn/88VYPEADgH4tGL9KVPa5U7tpc7Tm0xznfFmdT3vA8CgoAQJM8LiratWunp59+WnPnzlVZWZkMw5DNZlN0dLQv4gMA+FFmWqYy0zJld9hVVV2lhOiE0DqHAgDQIi26ToUkRUdHq1+/fq0ZCwAgQESERSgxJtHsMAAAbYTbRcUdd9zhVrs//vGPLQ4GAAAAQNvjdlHx0ksvqUePHrr44otlGIYvYwIAAADQhrhdVNx1111atmyZ/vnPf+qOO+7Qf/3Xfyk+PoQugAQAAACgUW6ffffMM8+ooqJCDz30kN5++22lpKQoMzNT7777LkcuAAAAgBDm0U96REZGavz48SopKdGuXbuUlpamKVOmqEePHjp+/LivYgQAAAAQwFr8O4EWi0UWi0WGYcjhcLRmTAAAAADaEI+KipqaGr322msaMWKE+vTpo507d6qgoED79u1TTEyMr2IEYKbcXCk9ve4WoYO8/wd9AQBn5faJ2lOmTNGyZct07rnn6vbbb9eyZcvUuXNnX8YGwGy5uVJ+ft397dvrbvPyzIsH/kHe/4O+AAC3uF1UPPvsszr33HPVq1cvbdiwQRs2bGi03RtvvNFqwQEw2erVrtPFxXygCgXk/T/oCwBwi9tFxW233SaLxeLLWAAEmlGj/vPtrCRlZJgXC/yHvP8HfQEAbvHo4ncAQkz9N7LFxXUfpviGNjSQ9/+gLwDALW4XFQBCVF4eH6RCEXn/D/oCAM6qxT8pCwAAAAASRQUAAAAAL1FUAAAAAPAKRQUAAAAAr1BUAAAAAPAKRQUAAAAAr1BUAAAAAPAKRQUAAAAAr1BUAAAAAPAKRQUAAAAAr1BUAAAAAPAKRQWA5uXmSunpdbcIPeSfPgAAN0SYHQCAAJabK+Xn193fvr3uNi/PvHjgX+SfPgAAN3GkAkDTVq92nS4uNicOmIP80wcA4CaKCgBNGzXKdTojw5w4YA7yTx8AgJsY/gSgafXDPIqL6z5MMewjtJB/+gAA3ERRAaB5eXl8kApl5J8+AAA3MPwJAAAAgFcoKgAAAAB4haICAAAAgFcoKgAAAAB4haICAAAAgFcoKgAAAAB4haICAAAAgFcoKgAAAAB4haICAAAAgFcoKgAAAAB4haICANC03FwpPb3uNlTRBwBwVhFmBwAACFC5uVJ+ft397dvrbvPyzIvHDPQBALiFIxUAgMatXu06XVxsThxmog8AwC0UFQCAxo0a5TqdkWFOHGaiDwDALQx/AgA0rn6YT3Fx3YfpUBz2Qx8AgFsoKgAATcvL44M0fQAAZ8XwJwAAAABeoagAAAAA4BWKCgAAAABeoagAAAAA4BWKCgAAAABeoagAAAAA4BWKCgAAmuEwHDpx+oQchsPsUAAgYFFUAADQiB2VO3T7ytsVnRetmLkxis6L1u0rb9eOyh1mhwYAAcfUomLjxo26/vrr1a1bN1ksFq1cudLlccMwNGvWLHXr1k3t27fX0KFDVVpaak6wAICQ8drO1zTgDwP0ys5XVHOmRpJUc6ZGr+x8RQP+MECv7XzN5AgBILCYWlScOHFC/fv3V0FBQaOPP/HEE5o3b54KCgq0ZcsWde3aVSNGjNCxY8f8HCkAIFTsqNyhW1fcqjPGGdkddpfH7A67zhhndOuKWzliAQDfY2pRMWrUKP32t7/V2LFjGzxmGIYWLFig3NxcjR07VhdeeKGWLl2q6upqvfrqqyZEC4So3FwpPb3uFqEnBPO/YPMCWSyWZttYLBYt+GiBfwICgDYgwuwAmlJeXq7KykqNHDnSOS8yMlJDhgzRhx9+qF/96leNPq+mpkY1NTXO6aNHj0qSamtrVVtb69ug4Vf1+SSvPvTYY9L8+XX3//EPKSxMevRRn66SvAaQVs5/W8itw3Dotc9fa3CE4ofsDrte2/manhv13FkLkFDQFnILz5HX4OWLnAZsUVFZWSlJSkpKcpmflJSkr7/+usnnzZ07V7Nnz24wf926dYqOjm7dIBEQSkpKzA4heA0cKL32g7Hjq1b5ZdXkNQD4KP+BnNtTZ045z6E4m5ozNVr5zkpFhkX6OKq2I5Bzi5Yjr8Gnurq61ZcZsEVFvR9+A2QYRrPfCk2fPl333nuvc/ro0aNKSUnRsGHD1LlzZ5/FCf+rra1VSUmJRowYIavVanY4wemxx6SnnvrP9H33+eVIBXkNEK2c/7aQW4fhUOSuSLcKi8jwSN147Y0cqVDbyC08R16D18GDB1t9mQFbVHTt2lVS3RGL5ORk5/wDBw40OHrxfZGRkYqMbPitkdVqZYcIUuTWh+bMkRwOqbhYysiom/YT8hoAfJT/QM/t+AvH65WdrzQ7BCoiLELj+41Xu3bt/BhZ4Av03KJlyGvw8UU+A/Y6Fb169VLXrl1dDrmdPn1aGzZs0GWXXWZiZECIycuTtm2ru0XoCcH8T7t0mgzDaLaNYRiadsk0/wQEAG2AqUXF8ePH9emnn+rTTz+VVHdy9qeffqp9+/bJYrFo2rRpys/P14oVK/T5559r0qRJio6O1oQJE8wMGwAQxPp37a+Xb3pZ4ZZwRYS5HtCPCItQuCVcL9/0svp37W9ShAAQeEwd/rR161YNGzbMOV1/LsTEiRP10ksv6cEHH9TJkyc1ZcoUHTp0SJdcconWrFmj2NhYs0IGAISA8f3Gq2+Xvlrw0QK9tvM11ZypUWR4pMb3G69pl0yjoACAHzC1qBg6dGizh5gtFotmzZqlWbNm+S8oAABUd8RiyZglevGGF3Wy9qSirdGclA0ATQjYE7UBAAgEYZYwndPuHLPDAICAFrAnagMAAABoGygqAAAAAHiFogIAAACAVygqAAAAAHiFogIAAACAVygqAAAAAHiFogIAAACAVygqAACNy82V0tPrbkMVfQAAbuHidwCAhnJzpfz8uvvbt9fd5uWZF48Z6AMAcBtHKgAADa1e7TpdXGxOHGaiDwDAbRQVAICGRo1ync7IMCcOM9EHAOA2hj8BABqqH+ZTXFz3YToUh/3QBwDgNooKAEDj8vL4IE0fAIBbGP4EAAAAwCsUFQAAAAC8QlEBAAAAwCsUFQAAAAC8QlEBAAAAwCsUFQAAAAC8QlEBAAAAwCsUFQAAAAC8QlEBAAAAwCsUFQAAAAC8QlEBoHm5uVJ6et0tEIrYBwDgrCLMDgBAAMvNlfLz6+5v3153m5dnXjyAv7EPAIBbOFIBoGmrV7tOFxebEwdgFvYBAHALRQWApo0a5TqdkWFOHIBZ2AcAwC0MfwLQtPphHsXFdR+mGPaBUMM+AABuoagA0Ly8PD5IIbSxDwDAWTH8CQAAAIBXKCoAAAAAeIWiAgAAAIBXKCoAAAAAeIWiAgAAAIBXKCoAAAAAeIWiAgAAAIBXKCoAAAAAeIWiAgAAAIBXKCoAAAAAeIWiAkDzcnOl9PS6WyCU8NoHALdFmB0AgACWmyvl59fd37697jYvz7x4AH/htQ8AHuFIBYCmrV7tOl1cbE4cgL/x2gcAj1BUAGjaqFGu0xkZ5sQB+BuvfQDwCMOfADStfrhHcXHdhyqGfyBU8NoHAI9QVABoXl4eH6gQmnjtA4DbGP4EAAAAwCsUFQAAAAC8QlEBAAAAwCsUFQAAAAC8QlEBAAAAwCsUFQAAAAC8QlEBAAAAwCsUFQAAAAC8QlEBAAAAwCsUFQAAAAC8QlEBAAAAwCsUFQCal5srpafX3SL0kH8AgBsizA4AQADLzZXy8+vub99ed5uXZ1488C/yDwBwE0cqADRt9WrX6eJic+KAOcg/AMBNFBUAmjZqlOt0RoY5ccAc5B8A4CaGPwFoWv1Ql+Liug+UDH0JLeQfAOAmigoAzcvL48NkKCP/AAA3MPwJAAAAgFcoKgAAAAB4haICAAAAgFcoKgAAAAB4haICAAAAgFcoKgAAAAB4haICAAAAgFcoKgAAAAB4JaCLilmzZslisbj8de3a1eywAAAAAHxPwF9ROy0tTX/729+c0+Hh4SZGAwAAAOCHAr6oiIiI4OgEAAAAEMACvqj46quv1K1bN0VGRuqSSy5Rfn6+zjvvvCbb19TUqKamxjl99OhRSVJtba1qa2t9Hi/8pz6f5DW4kNfgRW6DF7kNTuQ1ePkipxbDMIxWX2orWb16taqrq9W7d2/9+9//1m9/+1v94x//UGlpqTp37tzoc2bNmqXZs2c3mP/qq68qOjra1yEDAAAAAa26uloTJkzQkSNH1KFDh1ZZZkAXFT904sQJpaam6sEHH9S9997baJvGjlSkpKSooqKiyUIEbVNtba1KSko0YsQIWa1Ws8NBKyGvwYvcBi9yG5zIa/A6ePCgkpOTW7WoCPjhT993zjnnqF+/fvrqq6+abBMZGanIyMgG861WKztEkCK3wYm8Bi9yG7zIbXAir8HHF/kM6J+U/aGamhp98cUXSk5ONjsUAAAAAP8noIuK+++/Xxs2bFB5ebk++ugjjRs3TkePHtXEiRPNDg0AAADA/wno4U/ffPONxo8fr++++05dunTRpZdeqs2bN6tHjx5mhwYAAADg/wR0UbFs2TKzQwAAAABwFgE9/AkAAABA4KOoAAAAAOAVigoAAAAAXqGoAAAAAOAVigoAAAAAXqGoAAAAAOAVigoAAAAAXqGoAAAAAOAVigoAAAAAXqGoAAAAAOAVigoAAAAAXqGoAAAAAOAVigoAAAAAXqGoAAAAAOAVigoAAAAAXqGoAAAAAOAVigoAAAAAXqGoAAAAAOAVigoAAAAAXqGoAAAAAOAVigoAAAAAXqGoAAAAAOAVigoAAAAAXqGoAAAAAOAVigoAAAAAXqGoAAAAAOAVigoAAAAAXqGoAAAAAOAVigoAAAAAXqGoAAAAAOAVigoAAAAAXqGoAAAAAOAVigoAAAAAXqGoAAAAAOAVigoAAAAAXqGoAAAAAOAVigoAAAAAXqGoAAAAAOAVigoAAAAAXqGoAAAAAOAVigoAAAAAXqGoAAAAAOCVCLMDANC2nDlzRrW1tT5bfm1trSIiInTq1CmdOXPGZ+uB/5Hb4OWP3IaHhysiIkIWi8UnywfgHYoKAG47fvy4vvnmGxmG4bN1GIahrl27av/+/Xx4CDLkNnj5K7fR0dFKTk5Wu3btfLYOAC1DUQHALWfOnNE333yj6OhodenSxWcfHBwOh44fP66YmBiFhTFCM5iQ2+Dl69wahqHTp0/r22+/VXl5uc4//3xeQ0CAoagA4Jba2loZhqEuXbqoffv2PluPw+HQ6dOnFRUVxYeGIENug5c/ctu+fXtZrVZ9/fXXznUBCBy8qwPwCMNWAJiFYhQIXOydAAAAALxCUQHA7xyGQydOn5DDcJgdild69uypBQsWNNvGYrFo5cqVfomnOe7EirZp1qxZ+slPftJsm0mTJunGG2/0SzzNcSdWAG0TRQUAv9lRuUO3r7xd0XnRipkbo+i8aN2+8nbtqNzhs3UeOHBAv/rVr3TuuecqMjJSXbt21TXXXKNNmzY52wTKB38EpqFDh2ratGkN5q9cubJVhwMGygd/AGgJTtQG4Bev7XxNt664VRaLRXaHXZJUc6ZGr+x8RS9/9rJevullje83vtXXe/PNN6u2tlZLly7Veeedp3//+99au3atqqqqWn1dAACEKo5UAPC5HZU7dOuKW3XGOOMsKOrZHXadMc7o1hW3tvoRi8OHD+v999/X7373Ow0bNkw9evTQT3/6U02fPl3XXnutpLphQZJ00003yWKxOKfLyso0ZswYJSUlKSYmRoMGDdLf/va3Bus4duyYJkyYoJiYGHXr1k2LFi1qNqb//d//VVZWluLi4tS5c2eNGTNGe/fubbL9+vXrZbFY9M4776h///6KiorSJZdcop07d7q0e/3115WWlqbIyEj17NlTTz31VLNxHDlyRP/v//0/JSYmqkOHDrrqqqu0Y4fvjhiFgvqhPS+//LJ69uypjh076uc//7mOHTvmbLN8+XL169dP7du3V+fOnXX11VfrxIkTmjVrlpYuXao333xTFotFFotF69evlyQ99NBD6t27t6Kjo3XeeefpkUceafQClM8995xSUlIUHR2tW265RYcPH24yVsMw9MQTT+i8885T+/bt1b9/fy1fvrzZ7evZs6fmzJnT7Ot93759GjNmjGJiYtShQwdlZmbq3//+d7PLXbJkiX784x8rKipKF1xwgZ555plm2wMITBQVAHxuweYFZx0mYrFYtOCjBa263piYGMXExGjlypWqqalptM2WLVsk1X2wqaiocE4fP35co0eP1t/+9jdt375d11xzja6//nrt27fP5fm///3vddFFF+mTTz7R9OnTdc8996ikpKTRdVVXV2vYsGGKiYnRxo0b9f777ysmJkYZGRk6ffp0s9vywAMP6Mknn9SWLVuUmJioG264wfnBctu2bcrMzNTPf/5z7dy5U7NmzdIjjzyil156qdFlGYaha6+9VpWVlVq1apW2bdum9PR0DR8+nCM4XiorK9PKlSv117/+VX/961+1YcMGPf7445KkiooKjR8/XnfccYe++OILrV+/XmPHjpVhGLr//vuVmZmpjIwMVVRUqKKiQpdddpkkKTY2Vi+99JJ27dqlp59+Ws8//7zmz5/vst49e/aoqKhIb7/9toqLi/Xpp59q6tSpTcb5m9/8RkuWLNHixYtVWlqqe+65R//1X/+lDRs2NLt9zb3eDcPQ2LFjVVVVpQ0bNqikpERlZWXKyspqcnnPP/+8cnNzlZeXpy+++EL5+fl65JFHtHTpUrf6G0AAMYLckSNHDEnGd999Z3YoaGWnT582Vq5caZw+fdrsUELCyZMnjV27dhknT5706HlnHGeMyDmRhmbprH+RcyINu91uHDp0yDhz5kyrxL18+XIjLi7OiIqKMi677DJj+vTpxo4dO1zaSDJWrFhx1mX17dvXWLRokXO6R48eRkZGhkubrKwsY9SoUY0u+8UXXzT69OljOBwO5+M1NTVG+/btjXfffbfRda5bt86QZCxbtsw57+DBg0b79u2NwsJCwzAMY8KECcaIESNcnvfAAw8Yffv2dYl1/vz5hmEYxtq1a40OHToYp06dcnlOamqq8dxzz52tG1rszJkzrZpbfxkyZIhx9913N5i/YsUK4/v/RmfOnGlER0cbR48edc574IEHjEsuucQwDMPYtm2bIcnYu3dvo+uZOHGiMWbMmLPG88QTTxgDBgxwWW94eLixf/9+57zVq1cbYWFhRkVFRYNlHz9+3IiKijI+/PBDl+VOnjzZGD9+fJPrbe71fubMGeONN94wwsPDjX379jkfLy0tNSQZH3/8sTPW/v37Ox9PSUkxXn31VZdlzpkzxxg8eHCjMbT0fQgtw//Z4PXdd98ZkowjR4602jI5UgHAp07WnlTNmcaPEvxQzZkanbSfbNX133zzzfrXv/6lt956S9dcc43Wr1+v9PT0Jr/Fr3fixAk9+OCD6tu3rzp16qSYmBj94x//aHCkYvDgwQ2mv/jii0aXuW3bNu3Zs0exsbHOoyjx8fE6deqUysrKmo3n++uJj49Xnz59nOv54osvdPnll7u0v/zyy/XVV1/pzJkzjcZx/Phxde7c2RlHTEyMysvLzxpHwHjrLemee+puA0jPnj0VGxvrnE5OTtaBAwckSf3799fw4cPVr18/3XLLLXr++ed16NChsy5z+fLluuKKK9S1a1fFxMTokUceafA6PPfcc9W9e3fn9ODBg+VwOPTll182WN6uXbt06tQpjRgxwiX/f/rTnzx6HdZP178Od+/erZSUFKWkpDgfr99/Gtsnvv32W+3fv1+TJ092ieO3v/1t23kdAnDiRG0APtXe2l6R4ZFuFRaR4ZFqH9Fex3TsrG09ERUVpREjRmjEiBF69NFHdeedd2rmzJmaNGlSk8954IEH9O677+rJJ5+UzWZT+/btNW7cuLMOU5KavkCgw+HQgAED9Oc//7nBY126dHF7e364HsMwGqzTMIwmn+dwOJScnOwcs/99nTp18jgOv3vrLWnMGCk8XFqwQHrzTemGG3y2ug4dOujIkSMN5h8+fFgdOnRwmWe1Wl2mLRaLHI66n04ODw9XSUmJPvzwQ61Zs0aLFi1Sbm6uPvroI/Xq1avRdW/evFk///nPNXv2bF1zzTXq2LGjli1bdtZzZupfD429Fuvjeeedd/SjH/3I5bHIyMhml9vcuhp7HTY3vz6O559/XpdcconLY+Hh4R7HAcBcFBUAfCrMEqbxF47XKztfaXCS9vdFhEVofL/xfrlid9++fV1+QtZqtTb4Rv+9997TpEmTdNNNN0mqO8eisROqN2/e3GD6ggsuaHS96enpKiwsdJ4c7YnNmzfr3HPPlSQdOnRIu3fvdq6nb9++ev/9913af/jhh+rdu3ejH87S09NVWVmpiIgI54npbcq6dXUFxZkzdbfr1/u0qLjgggu0evXqBvO3bNmiPn36eLQsi8Wiyy+/XJdffrkeffRR9ejRQytWrNC9996rdu3aNXgdfvDBB+rRo4dyc3Od877++usGy923b5/+9a9/qVu3bpKkTZs2KSwsTL17927Qtm/fvoqMjNS+ffs0ZMgQj+Jv7vXep08f7du3T/v373cerdi1a5eOHDmiH//4xw2WlZSUpB/96Ef65z//qV/84hcexQEg8DD8CYDPTbt0WrPfnEt132ZOu2Raq6734MGDuuqqq/TKK6/os88+U3l5uf7yl7/oiSee0JgxY5ztevbsqbVr16qystI5HMVms+mNN97Qp59+qh07dmjChAnOb1a/74MPPtATTzyh3bt363/+53/0l7/8RXfffXej8fziF79QQkKCxowZo/fee0/l5eXasGGD7r77bn3zzTfNbstjjz2mtWvX6vPPP9ekSZOUkJDgvKbBfffdp7Vr12rOnDnavXu3li5dqoKCAt1///2NLuvqq6/W4MGDdeONN+rdd9/V3r179eGHH+o3v/mNtm7d6k7XmmvYsP8UFGfOSEOH+nR1U6ZMUVlZmaZOnaodO3Y4c/3iiy/qgQcecHs5H330kfLz87V161bt27dPb7zxhr799lvnB+6ePXvqs88+05dffqnvvvtOtbW1stls2rdvn5YtW6aysjItXLhQK1asaLDsqKgoTZw4UTt27NB7772nX//618rMzFTXrl0btI2NjdX999+ve+65R0uXLlVZWZm2b9+u//mf/znrCdLNvd6HDh2qiy66SL/4xS/0ySef6OOPP9Ztt92mIUOGaODAgY0ub9asWZo7d66efvpp7d69Wzt37tSSJUs0b948t/sVQIBotbMzAhQnagcvTiDzL29PkHz1s1eN8NnhRsRjES4nZ0c8FmGEzw43Xv2s7mTN1jyZ99SpU8bDDz9spKenGx07djSio6ONPn36GL/5zW+M6upqZ7u33nrLsNlsRkREhNGjRw/DMAyjvLzcGDZsmNG+fXsjJSXFKCgoaHDCbo8ePYzZs2cbmZmZRnR0tJGUlGQsWLDAJQb94CTwiooK47bbbjMSEhKMyMhI47zzzjN++ctfNnmyXP2J2m+//baRlpZmtGvXzhg0aJDx6aefurRbvny50bdvX8NqtRrnnnuu8fvf/97l8e+fqG0YhnH06FEjJyfH6Natm2G1Wo2UlBTjF7/4hctJtq2tVU/UfvNNw7jnnrpbP9i6datxzTXXGImJiUaHDh2MgQMHGq+99ppLmx+ehGwYhjF//nzna2rXrl3GNddcY3Tp0sWIjIw0evfu7XLi/4EDB4wRI0YYMTExhiRj3bp1hmHUnezduXNnIyYmxsjKyjLmz59vdOzYscF6n3nmGaNbt25GVFSUMXbsWKOqqsrZ5ocngTscDuPpp582+vTpY1itVqNLly7GNddcY2zYsKHJPmju9V6f2/LycuOGG24wzjnnHCM2Nta45ZZbjMrKymb76M9//rPxk5/8xGjXrp0RFxdn/OxnPzPeeOONRmPgRG3/4v9s8PLFidoWwzjL14dt3NGjR9WxY0d999136ty5s9nhoBXV1tZq1apVGj16dINxzGh9p06dUnl5uXr16qWoqKgWLWNH5Q4t+GiBXtv5mmrO1CgyPFLj+43XtEumqX/X/pLqxlkfPXpUHTp0UFgYB1PXr1+vYcOG6dChQ23jfIdmkNu2rWfPnpo2bVqjVxf3V25b430I7uP/bPA6ePCgEhISdOTIEY+H4zaFcyoA+E3/rv21ZMwSvXjDizpZe1LR1mi/nEMBAAB8i6ICgN+FWcJ0TrtzzA4DAAC0EooKAAhgQ4cOPetJ7oA/NPbrZwBQj0GtAAAAALxCUQEAAADAKxQVADzCUBwAZuH9BwhcFBUA3FJ/ZebTp0+bHAmAUFVdXS1J/LwpEIA4URuAWyIiIhQdHa1vv/1WVqvVZ79F73A4dPr0aZ06dYprGQQZchu8fJ1bwzBUXV2tAwcOqFOnTs4vOQAEDooKAG6xWCxKTk5WeXm5vv76a5+txzAMnTx5Uu3bt+caFkGG3AYvf+W2U6dO6tq1q8+WD6DlKCoAuK1du3Y6//zzfToEqra2Vhs3btTPfvYzhjgEGXIbvPyRW6vVyhEKIIC1iaLimWee0e9//3tVVFQoLS1NCxYs0JVXXml2WEBICgsLU1RUlM+WHx4eLrvdrqioKD54BhlyG7zILYCAH9RaWFioadOmKTc3V9u3b9eVV16pUaNGad++fWaHBgAAAEBtoKiYN2+eJk+erDvvvFM//vGPtWDBAqWkpGjx4sVmhwYAAABAAV5UnD59Wtu2bdPIkSNd5o8cOVIffvihSVEBAAAA+L6APqfiu+++05kzZ5SUlOQyPykpSZWVlY0+p6amRjU1Nc7pI0eOSJKqqqp8FyhMUVtbq+rqah08eJAxvEGEvAYvchu8yG1wIq/Bq/5zcWteUDKgi4p6P/x5OsMwmvzJurlz52r27NkN5vfu3dsnsQEAAABt0cGDB9WxY8dWWVZAFxUJCQkKDw9vcFTiwIEDDY5e1Js+fbruvfde5/Thw4fVo0cP7du3r9U6DYHh6NGjSklJ0f79+9WhQwezw0ErIa/Bi9wGL3IbnMhr8Dpy5IjOPfdcxcfHt9oyA7qoaNeunQYMGKCSkhLddNNNzvklJSUaM2ZMo8+JjIxUZGRkg/kdO3ZkhwhSHTp0ILdBiLwGL3IbvMhtcCKvwSssrPVOrw7ookKS7r33Xt16660aOHCgBg8erD/84Q/at2+f7rrrLrNDAwAAAKA2UFRkZWXp4MGDeuyxx1RRUaELL7xQq1atUo8ePcwODQAAAIDaQFEhSVOmTNGUKVNa9NzIyEjNnDmz0SFRaNvIbXAir8GL3AYvchucyGvw8kVuLUZr/pYUAAAAgJAT0Be/AwAAABD4KCoAAAAAeIWiAgAAAIBX2nxRsXHjRl1//fXq1q2bLBaLVq5cedbnbNiwQQMGDFBUVJTOO+88Pfvss74PFB7xNK/r16+XxWJp8PePf/zDPwHDLXPnztWgQYMUGxurxMRE3Xjjjfryyy/P+jz22cDXktyy37YNixcv1kUXXeS8VsHgwYO1evXqZp/DPhv4PM0r+2vbNXfuXFksFk2bNq3Zdt7ut22+qDhx4oT69++vgoICt9qXl5dr9OjRuvLKK7V9+3bNmDFDv/71r/X666/7OFJ4wtO81vvyyy9VUVHh/Dv//PN9FCFaYsOGDZo6dao2b96skpIS2e12jRw5UidOnGjyOeyzbUNLcluP/Tawde/eXY8//ri2bt2qrVu36qqrrtKYMWNUWlraaHv22bbB07zWY39tW7Zs2aI//OEPuuiii5pt1yr7rRFEJBkrVqxots2DDz5oXHDBBS7zfvWrXxmXXnqpDyODN9zJ67p16wxJxqFDh/wSE1rHgQMHDEnGhg0bmmzDPts2uZNb9tu2Ky4uznjhhRcafYx9tu1qLq/sr23PsWPHjPPPP98oKSkxhgwZYtx9991Ntm2N/bbNH6nw1KZNmzRy5EiXeddcc422bt2q2tpak6JCa7n44ouVnJys4cOHa926dWaHg7M4cuSIJCk+Pr7JNuyzbZM7ua3Hftt2nDlzRsuWLdOJEyc0ePDgRtuwz7Y97uS1Hvtr2zF16lRde+21uvrqq8/atjX22zZx8bvWVFlZqaSkJJd5SUlJstvt+u6775ScnGxSZPBGcnKy/vCHP2jAgAGqqanRyy+/rOHDh2v9+vX62c9+ZnZ4aIRhGLr33nt1xRVX6MILL2yyHfts2+Nubtlv246dO3dq8ODBOnXqlGJiYrRixQr17du30bbss22HJ3llf21bli1bpk8++URbtmxxq31r7LchV1RIksVicZk2/u/6fz+cj7ajT58+6tOnj3N68ODB2r9/v5588kne7AJUdna2PvvsM73//vtnbcs+27a4m1v227ajT58++vTTT3X48GG9/vrrmjhxojZs2NDkB1D22bbBk7yyv7Yd+/fv19133601a9YoKirK7ed5u9+G3PCnrl27qrKy0mXegQMHFBERoc6dO5sUFXzh0ksv1VdffWV2GGhETk6O3nrrLa1bt07du3dvti37bNviSW4bw34bmNq1ayebzaaBAwdq7ty56t+/v55++ulG27LPth2e5LUx7K+Badu2bTpw4IAGDBigiIgIRUREaMOGDVq4cKEiIiJ05syZBs9pjf025I5UDB48WG+//bbLvDVr1mjgwIGyWq0mRQVf2L59O4fZA4xhGMrJydGKFSu0fv169erV66zPYZ9tG1qS28aw37YNhmGopqam0cfYZ9uu5vLaGPbXwDR8+HDt3LnTZd7tt9+uCy64QA899JDCw8MbPKdV9lvPziMPPMeOHTO2b99ubN++3ZBkzJs3z9i+fbvx9ddfG4ZhGA8//LBx6623Otv/85//NKKjo4177rnH2LVrl/Hiiy8aVqvVWL58uVmbgEZ4mtf58+cbK1asMHbv3m18/vnnxsMPP2xIMl5//XWzNgGN+O///m+jY8eOxvr1642KigrnX3V1tbMN+2zb1JLcst+2DdOnTzc2btxolJeXG5999pkxY8YMIywszFizZo1hGOyzbZWneWV/bdt++OtPvthv23xRUf8TZz/8mzhxomEYhjFx4kRjyJAhLs9Zv369cfHFFxvt2rUzevbsaSxevNj/gaNZnub1d7/7nZGammpERUUZcXFxxhVXXGG888475gSPJjWWU0nGkiVLnG3YZ9umluSW/bZtuOOOO4wePXoY7dq1M7p06WIMHz7c+cHTMNhn2ypP88r+2rb9sKjwxX5rMYz/OwsDAAAAAFog5E7UBgAAANC6KCoAAAAAeIWiAgAAAIBXKCoAAAAAeIWiAgAAAIBXKCoAAAAAeIWiAgAAAIBXKCoAAAAAeIWiAgAQVCZNmiSLxSKLxaKVK1e26rLXr1/vXPaNN97YqssGgLaMogIAAtz3PyR//2/Pnj1mhxawMjIyVFFRoVGjRjnnNVVkTJo0ye0C4bLLLlNFRYUyMzNbKVIACA4RZgcAADi7jIwMLVmyxGVely5dGrQ7ffq02rVr56+wAlZkZKS6du3a6stt166dunbtqvbt26umpqbVlw8AbRVHKgCgDaj/kPz9v/DwcA0dOlTZ2dm69957lZCQoBEjRkiSdu3apdGjRysmJkZJSUm69dZb9d133zmXd+LECd12222KiYlRcnKynnrqKQ0dOlTTpk1ztmnsm/1OnTrppZdeck7/7//+r7KyshQXF6fOnTtrzJgx2rt3r/Px+qMATz75pJKTk9W5c2dNnTpVtbW1zjY1NTV68MEHlZKSosjISJ1//vl68cUXZRiGbDabnnzySZcYPv/8c4WFhamsrMz7jv2BvXv3NnpUaOjQoa2+LgAIJhQVANDGLV26VBEREfrggw/03HPPqaKiQkOGDNFPfvITbd26VcXFxfr3v//tMmTngQce0Lp167RixQqtWbNG69ev17Zt2zxab3V1tYYNG6aYmBht3LhR77//vmJiYpSRkaHTp087261bt05lZWVat26dli5dqpdeesmlMLntttu0bNkyLVy4UF988YWeffZZxcTEyGKx6I477mhwhOaPf/yjrrzySqWmprasw5qRkpKiiooK59/27dvVuXNn/exnP2v1dQFAMGH4EwC0AX/9618VExPjnB41apT+8pe/SJJsNpueeOIJ52OPPvqo0tPTlZ+f75z3xz/+USkpKdq9e7e6deumF198UX/605+cRzaWLl2q7t27exTTsmXLFBYWphdeeEEWi0WStGTJEnXq1Enr16/XyJEjJUlxcXEqKChQeHi4LrjgAl177bVau3atfvnLX2r37t0qKipSSUmJrr76aknSeeed51zH7bffrkcffVQff/yxfvrTn6q2tlavvPKKfv/733sUa73x48crPDzcZV5NTY2uvfZaSVJ4eLhz2NSpU6d04403avDgwZo1a1aL1gcAoYKiAgDagGHDhmnx4sXO6XPOOcd5f+DAgS5tt23bpnXr1rkUIfXKysp08uRJnT59WoMHD3bOj4+PV58+fTyKadu2bdqzZ49iY2Nd5p86dcplaFJaWprLB/nk5GTt3LlTkvTpp58qPDxcQ4YMaXQdycnJuvbaa/XHP/5RP/3pT/XXv/5Vp06d0i233OJRrPXmz5/vLF7qPfTQQzpz5kyDtpMnT9axY8dUUlKisDAO7ANAcygqAKANOOecc2Sz2Zp87PscDoeuv/56/e53v2vQNjk5WV999ZVb67RYLDIMw2Xe98+FcDgcGjBggP785z83eO73TyK3Wq0NlutwOCRJ7du3P2scd955p2699VbNnz9fS5YsUVZWlqKjo93ahh/q2rVrg36MjY3V4cOHXeb99re/VXFxsT7++OMGRRMAoCGKCgAIMunp6Xr99dfVs2dPRUQ0fJu32WyyWq3avHmzzj33XEnSoUOHtHv3bpcjBl26dFFFRYVz+quvvlJ1dbXLegoLC5WYmKgOHTq0KNZ+/frJ4XBow4YNDY4g1Bs9erTOOeccLV68WKtXr9bGjRtbtC53vf7663rssce0evVqn5y3AQDBiOO5ABBkpk6dqqqqKo0fP14ff/yx/vnPf2rNmjW64447dObMGcXExGjy5Ml64IEHtHbtWn3++eeaNGlSgyE+V111lQoKCvTJJ59o69atuuuuu1yOOvziF79QQkKCxowZo/fee0/l5eXasGGD7r77bn3zzTduxdqzZ09NnDhRd9xxh1auXKny8nKtX79eRUVFzjbh4eGaNGmSpk+fLpvN5jJsq7V9/vnnuu222/TQQw8pLS1NlZWVqqysVFVVlc/WCQDBgKICAIJMt27d9MEHH+jMmTO65pprdOGFF+ruu+9Wx44dnYXD73//e/3sZz/TDTfcoKuvvlpXXHGFBgwY4LKcp556SikpKfrZz36mCRMm6P7773cZdhQdHa2NGzfq3HPP1dixY/XjH/9Yd9xxh06ePOnRkYvFixdr3LhxmjJlii644AL98pe/1IkTJ1zaTJ48WadPn9Ydd9zhRc+c3datW1VdXa3f/va3Sk5Odv6NHTvWp+sFgLbOYvxwwCwAICQNHTpUP/nJT7RgwQKzQ2nggw8+0NChQ/XNN98oKSmp2baTJk3S4cOHG716dmvxxzoAoC3hSAUAIGDV1NRoz549euSRR5SZmXnWgqJe/U/w/vWvf23VeN577z3FxMQ0enI6AIQyTtQGAASs1157TZMnT9ZPfvITvfzyy24954knntBvfvMbSXW/dtWaBg4cqE8//VSSGv3JXgAIVQx/AgAAAOAVhj8BAAAA8ApFBQAAAACvUFQAAAAA8ApFBQAAAACvUFQAAAAA8ApFBQAAAACvUFQAAAAA8ApFBQAAAACvUFQAAAAA8Mr/B+I7fkGzmN7VAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# plot Stabilisation chart for pLSCF\n", + "_, _ = plscf.plot_stab(freqlim=(1,4), hide_poles=False)" + ] + }, + { + "cell_type": "markdown", + "id": "3252709c-1639-43e6-b173-c3351a382869", + "metadata": { + "tags": [] + }, + "source": [ + "We are now ready to extract the modal properties of interest either from the interactive plots using the ```mpe_from_plot()``` method or using the ```mpe()``` method." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "5c59731a-068a-4972-b15c-2e5cff9c94eb", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-01-22 19:42:53,952 - pyoma2.setup.base - INFO - Getting mpe modal parameters from SSIcov (base:149)\n", + "2025-01-22 19:42:53,953 - pyoma2.functions.ssi - INFO - Extracting SSI modal parameters (ssi:887)\n", + "100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 3/3 [00:00<00:00, 23967.45it/s]\n" + ] + } + ], + "source": [ + "# Select modes to extract from plots\n", + "# Pali_ss.mpe_from_plot(\"SSIcov\", freqlim=(1,4))\n", + "\n", + "# or directly\n", + "Pali_ss.mpe(\"SSIcov\", sel_freq=[1.88, 2.42, 2.68], order_in=20)\n", + "\n", + "# update dict of results\n", + "ssi_res = dict(ssicov.result)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "534397fd-3584-4c17-b81b-f5327a46803b", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-01-22 19:42:53,956 - pyoma2.setup.base - INFO - Getting mpe modal parameters from FSDD (base:149)\n", + "2025-01-22 19:42:53,967 - pyoma2.functions.fdd - INFO - Extracting FDD modal parameters (fdd:284)\n", + "100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 3/3 [00:00<00:00, 34007.87it/s]\n", + "2025-01-22 19:42:53,968 - pyoma2.functions.fdd - INFO - Extracting EFDD modal parameters (fdd:492)\n", + "100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 3/3 [00:00<00:00, 71.37it/s]\n" + ] + } + ], + "source": [ + "# Select modes to extract from plots\n", + "# Pali_ss.mpe_from_plot(\"FSDD\", freqlim=(1,4), MAClim=0.95)\n", + "\n", + "# or directly\n", + "Pali_ss.mpe(\"FSDD\", sel_freq=[1.88, 2.42, 2.68], MAClim=0.95)\n", + "\n", + "# update dict of results\n", + "fsdd_res = dict(fsdd.result)" + ] + }, + { + "cell_type": "markdown", + "id": "5ed67412-745a-40b3-b9a3-1f7d63efd6dd", + "metadata": {}, + "source": [ + "We can compare the results from the two methods" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "f8086c84-b4ec-4895-9809-04663f6090bd", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([1.88221912, 2.42138812, 2.68726368])" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ssicov.result.Fn" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "22be622d-4fd8-4912-ae49-32896d389bd0", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([1.87660073, 2.42217607, 2.68224292])" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "fsdd.result.Fn" + ] + }, + { + "cell_type": "markdown", + "id": "50fffd69-4b97-42a7-b37f-81a186280381", + "metadata": {}, + "source": [ + "We can also plot some additional info regarding the estimates for the EFDD and FSDD algorithms" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "b27db2d8-8eee-47f8-9cec-19d79c867a5d", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAnkAAAHWCAYAAAALq58HAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdd1gTyRsH8G8IhC7Si1TFDopiAwtgAXvviiKW4+y9/Dx7QT27nu1OsfeCXeEUsKECgr0LogKiKEVaApnfHzF7xAQIkJAA83mePJLN7s6bMTt5M7s7wyKEEFAURVEURVGVioqiA6AoiqIoiqJkjyZ5FEVRFEVRlRBN8iiKoiiKoiohmuRRFEVRFEVVQjTJoyiKoiiKqoRokkdRFEVRFFUJ0SSPoiiKoiiqEqJJHkVRFEVRVCVEkzyKoiiKoqhKiCZ5lcC9e/fQp08fWFtbQ11dHaampnBxccGMGTNE1nN3dweLxQKLxYKKigp0dXVhb2+PAQMG4OTJk+Dz+RL3n5mZiVWrVqFJkybQ0dGBtrY2nJycsHLlSmRmZoqtb2try5Tz6+PHjx+Fvo+4uDix9atVq4bGjRtj48aNyM/PL1X9LF68GCwWS6wu3N3di92Wy+XCz88P5ubmYLPZcHJyKlUMsrJt2zbs3btXbLmw7iS9RlHlYfPmzWCxWHBwcCjzvi5duoTFixeXPagKTtp2ShJlbCuEbbGkx9atW8s9noKUsb5kQVXRAVBlc/HiRfTs2RPu7u5Ys2YNzM3NkZiYiMjISBw9ehTr1q0TWb9mzZo4dOgQAEHyFhsbi8DAQAwYMABt27bF+fPnoaenx6z/+fNndOzYEW/fvsXkyZOxZs0aAMD169exfPlyHDlyBP/++y9MTU1FymndujXWrl0rFq+Wllax72nSpEkYOnQoACA1NRXnzp3DtGnT8OHDB7H3I2/bt2/Hzp07sWXLFjg7O0NHR6dcy//Vtm3bYGRkBB8fH5Hl5ubmCA8PR61atRQTGFXl7dmzBwDw9OlT3Lt3Dy1btiz1vi5duoS//vqLJnploMxtxZUrV0S+ZwDAzs5OQdEIKHN9lQVN8iq4NWvWwM7ODlevXoWq6n//nYMHD2YSsoI0NTXRqlUrkWVjxoxBQEAAfH19MW7cOBw7dox5bcSIEXjx4gVCQkLQpk0bZnmnTp3QrVs3eHh4YOTIkbhy5YrIPqtXry5WjrSsra1Ftu3cuTOePHmCI0eOlHuS9+TJE2hqamLixInlWm5Jqaurl7q+KaqsIiMj8fDhQ3Tr1g0XL17E7t27y5TkVWQ8Hg8sFkukPRbKysqS6oeuPClDW+Hs7AwjIyOFxiAtZaivsqCnayu4lJQUGBkZSWxQVFSk/+8dNWoUunbtihMnTuD9+/cABA13UFAQRo8eLZLgCbVp0wa+vr64evUqoqKiSv8mpKCnpwc1NTWx5ceOHYOLiwu0tbWho6MDLy8vREdHy6RMFouFf/75B9nZ2cwphb179xbZfc9isUR6H4SnJ54+fYohQ4ZAT08Ppqam8PX1RVpamsi2fD4fW7ZsgZOTEzQ1NZlE+dy5cwAEp8GfPn2KsLAwJh5bW1sAhZ9SuHXrFjp06ABdXV1oaWnB1dUVFy9eFFln7969YLFYCAkJwe+//w4jIyMYGhqib9++SEhIKHM9UpXf7t27AQCrVq2Cq6srjh49iqysLJF1QkNDwWKxEBoaKrL818+uj48P/vrrLwAQOZ0XFxcHAMjJycG8efNgZ2cHDoeDGjVqYMKECUhNTZU63hcvXmDIkCEwNTWFuro6rK2tMWLECOTm5jLrPHnyBL169YK+vj40NDTg5OSEffv2SXxPBw4cwIwZM1CjRg2oq6vjzZs38PHxgY6ODh4/fgxPT0/o6uqiQ4cOAASXgSxfvhz16tWDuro6jI2NMWrUKHz58qXY2JcsWYKWLVvCwMAA1apVQ9OmTbF7924QQph1KmpbQdtW2aNJXgXn4uKCe/fuYfLkybh37x54PF6p99WzZ08QQnDz5k0AQHBwMACgd+/ehW4jfE24rhAhBHl5eSKPwq75+xWfz2e2SUlJwZ49e3DlyhV4e3uLrLdy5UoMGTIEDRo0wPHjx3HgwAFkZGSgbdu2ePbsmZTvunDh4eHo2rUrNDU1ER4ejvDwcHTr1q1U++rXrx/q1KmDU6dOYe7cuTh8+DCmTZsmso6Pjw+mTJmC5s2b49ixYzh69Ch69uzJfLmdOXMGNWvWRJMmTZh4zpw5U2iZYWFhaN++PdLS0rB7924cOXIEurq66NGjh0hvrdCYMWOgpqaGw4cPY82aNQgNDcXw4cNL9X6pqiM7OxtHjhxB8+bN4eDgAF9fX2RkZODEiROl2t+CBQvQv39/AGA+5+Hh4TA3NwchBL1798batWvh7e2NixcvYvr06di3bx/at28vkqQV5uHDh2jevDnu3r2LpUuX4vLly/D390dubi64XC4A4OXLl3B1dcXTp0+xefNmnD59Gg0aNICPj4/EMyTz5s1DfHw8duzYgfPnz8PExASAIJnr2bMn2rdvj7Nnz2LJkiXg8/no1asXVq1ahaFDh+LixYtYtWoVgoOD4e7ujuzs7CLjj4uLw2+//Ybjx4/j9OnT6Nu3LyZNmoRly5Yx6yh7W5Gfny/y3VDa660B2rYWi1AV2tevX0mbNm0IAAKAqKmpEVdXV+Lv708yMjJE1nVzcyMNGzYsdF+XL18mAMjq1asJIYT4+fkRAOTFixeFbvP8+XMCgPz+++/MMhsbGyaego/58+cX+V5iY2MlbgeA+Pj4kLy8PGbd+Ph4oqqqSiZNmiSyj4yMDGJmZkYGDhzILFu0aBH59aPu5uZG3NzcioyHEEJGjhxJtLW1JcYZEBAgtj4AsmjRIrGy16xZI7Le+PHjiYaGBuHz+YQQQm7cuCFVHTVs2FBi3JJiatWqFTExMRH5HOTl5REHBwdiaWnJlB0QEEAAkPHjx4vsc82aNQQASUxMLDImqmrbv38/AUB27NhBCBEcgzo6OqRt27Yi64WEhBAAJCQkRGS5pM/uhAkTxI5ZQgi5cuWKxOPp2LFjBADZtWtXsfG2b9+eVK9enSQnJxe6zuDBg4m6ujqJj48XWd6lSxeipaVFUlNTRd5Tu3btxPYxcuRIAoDs2bNHZPmRI0cIAHLq1CmR5REREQQA2bZtG7OsuHYqPz+f8Hg8snTpUmJoaMgc04QoZ1shbA9/fdSoUaPQ2IRo21o6tCevgjM0NMTNmzcRERGBVatWoVevXnj16hXmzZsHR0dHfP36Vep9kQLd/SXd5te7V9u0aYOIiAiRx/jx46Xa55QpU5htQkJCsHLlShw/fhxDhgxh1rl69Sry8vIwYsQIkV+EGhoacHNzEzslpGg9e/YUed6oUSPk5OQgOTkZAHD58mUAwIQJE2RSXmZmJu7du4f+/fuL3CzCZrPh7e2Njx8/4uXLl8XGCIA5fU9RkuzevRuampoYPHgwAEBHRwcDBgzAzZs38fr1a5mWdf36dQAQuzh+wIAB0NbWxrVr1wBIPpMACK6JCwsLw8CBA2FsbFxkOR06dICVlZXIch8fH2RlZSE8PFxkeb9+/Qrd16+vXbhwAdWrV0ePHj1E4nNycoKZmVmxbdf169fRsWNH6Onpgc1mQ01NDQsXLkRKSgrTnpSEItqKf//9V+S74dKlSyWOu6hYaNv6H3rjRSXRrFkzNGvWDIDgwt85c+Zgw4YNWLNmjcTTC5IIP3AWFhYABDdAAEBsbCzq1q0rcRthd/evjaGenh4TT0lZWlqKbCsc+mXevHm4evUqvLy88PnzZwBA8+bNJe6jJNcjlgdDQ0OR5+rq6gDAnJr58uUL2Gw2zMzMZFLe9+/fQQiBubm52GvC/9+UlJQSxUhRv3rz5g1u3LiBfv36gRDCXBfXv39/BAQEYM+ePfD395dZeSkpKVBVVRVL0FgsFszMzJjPdFhYGDw8PETWiY2NhZqaGvLz82FpaVlsOSU5diStCwhGE6hWrZrIss+fPyM1NRUcDkfiNkX9ML9//z48PT3h7u6Ov//+G5aWluBwOAgMDMSKFStKdawqoq1o3LixzG68oG1r0WiSVwmpqalh0aJF2LBhA548eSL1dufOnQOLxUK7du0ACO6g/d///ofAwEB07txZ4jaBgYHMuvIk/OXz8OFDeHl5MQ3EyZMnYWNjI9eyf6WhoQEAYtf//Hpgl4SxsTHy8/ORlJRU6BdGSejr60NFRQWJiYlirwkv+K0od7dRymvPnj0ghODkyZM4efKk2Ov79u3D8uXLwWazCz1uSnK2wdDQEHl5efjy5YtIokcIQVJSEvOjz9nZGRERESLbWlhYID8/H2w2Gx8/fiy2nJIcO7+eyShqufDi+19HJBDS1dUtNK6jR49CTU0NFy5cYOoT+K8dLg1laito2yp7ytXdQZWYpA8aADx//hzAf78sihMQEIDLly9jyJAhTA9es2bN4Onpid27d+P27dti29y6dQt79uxB586d4ezsXMp3IJ2YmBgAYC5o9vLygqqqKt6+fcv0Yv76kBdTU1NoaGjg0aNHIsvPnj1b6n126dIFgGBcvqKoq6tL9etPW1sbLVu2xOnTp0XW5/P5OHjwICwtLVGnTp1Sx0tR+fn52LdvH2rVqoWQkBCxx4wZM5CYmMicLhPerfjrcSO8w7Ggwno6hHenHjx4UGT5qVOnkJmZybyuq6sr1h5wOBxoamrCzc0NJ06cKDK57NChA65fvy52B+T+/fuhpaVVpiE1unfvjpSUFOTn50tstwo7awKAGZqFzWYzy7Kzs3HgwAGxdStiW0HbVtmjPXkVnJeXFywtLdGjRw/Uq1cPfD4fMTExWLduHXR0dDBlyhSR9bOzs3H37l3m73fv3iEwMBAXLlyAm5sbduzYIbL+/v370bFjR3h6emLy5MlMI3r9+nVs2rQJ9erVk/lI4PHx8UyMmZmZCA8Ph7+/P2xsbNC3b18Agi+MpUuXYv78+Xj37h06d+4MfX19fP78Gffv34e2tjaWLFki07iEWCwWhg8fjj179qBWrVpo3Lgx7t+/j8OHD5d6n23btoW3tzeWL1+Oz58/o3v37lBXV0d0dDS0tLQwadIkAICjoyOOHj2KY8eOoWbNmtDQ0ICjo6PEffr7+6NTp07w8PDAzJkzweFwsG3bNmbMwcJ6HyhKGpcvX0ZCQgJWr14tcVYGBwcHbN26Fbt370b37t1hZmaGjh07wt/fH/r6+rCxscG1a9dw+vRpsW2Fn+nVq1ejS5cuYLPZaNSoETp16gQvLy/MmTMH6enpaN26NR49eoRFixahSZMmYnfgS7J+/Xq0adMGLVu2xNy5c2Fvb4/Pnz/j3Llz2LlzJ3R1dbFo0SJcuHABHh4eWLhwIQwMDHDo0CFcvHgRa9asERvItyQGDx6MQ4cOoWvXrpgyZQpatGgBNTU1fPz4ESEhIejVqxf69Okjcdtu3bph/fr1GDp0KMaNG4eUlBSsXbuWSYp/rcOK1lbQtlUO5H5rByVXx44dI0OHDiW1a9cmOjo6RE1NjVhbWxNvb2/y7NkzkXXd3NxE7mjS1tYmNWvWJP379ycnTpwg+fn5Esv48eMHWblyJXFyciJaWlpES0uLNGrUiCxfvpz8+PFDbH0bGxvSrVu3Er8XSXfXamhokDp16pCpU6dKvBMpMDCQeHh4kGrVqhF1dXViY2ND+vfvT/79919mHVnfXUsIIWlpaWTMmDHE1NSUaGtrkx49epC4uLhC7wD78uWLyPbCu65iY2OZZfn5+WTDhg3EwcGBcDgcoqenR1xcXMj58+eZdeLi4oinpyfR1dUlAIiNjY1I3f16V9rNmzdJ+/btiba2NtHU1CStWrUS2V/BWCIiIkSWF3Y3JEURQkjv3r0Jh8Mp9i5VVVVVkpSURAghJDExkfTv358YGBgQPT09Mnz4cBIZGSn22c3NzSVjxowhxsbGhMViiRwr2dnZZM6cOcTGxoaoqakRc3Nz8vvvv5Pv379LHfuzZ8/IgAEDiKGhIeFwOMTa2pr4+PiQnJwcZp3Hjx+THj16ED09PcLhcEjjxo3Fji/hMXLixAmxMgprOwghhMfjkbVr15LGjRsTDQ0NoqOjQ+rVq0d+++038vr1a2Y9Se3Unj17SN26dYm6ujqpWbMm8ff3J7t37xZrT5SxrSisPSyItq2yxSKkFLdUUhRFURRFUUqNXpNHURRFURRVCdEkj6IoiqIoqhKiSR5FURRFUVQlRJM8iqIoiqKoSogmeRRFURRFUZUQTfIoiqIoiqIqIToYcjH4fD4SEhKgq6urXAMcUhQFQggyMjJgYWEh8/mKP3/+jJkzZ+LatWtITk7Gr6NN5efny7Q8RaNtHUUpr9K2dTTJK0ZCQgKsrKwUHQZFUUX48OFDsZPOl5SPjw/i4+OxYMECmJubV/rEh7Z1FKX8StrW0SSvGMLJomNjY2FgYKDgaCoGHo+HoKAgeHp6Qk1NTdHhVBi03kru27dvsLOzK3JS99K6desWbt68CScnJ5nvWxkJ6/DDhw+oVq1aoevRz6ns0LqUjapQj+np6bCysipxW0eTvGIIf73r6uoW2fBR/+HxeNDS0kK1atUq7QEnD7TeSo7H4wGAXHrZrKysxE7RVmbCOqxWrVqxSR79nMoGrUvZqEr1WNK2rkrceLFt2zbY2dlBQ0MDzs7OuHnzpqJDoihKyW3cuBFz585FXFxcuZZ748YN9OjRAxYWFmCxWAgMDCx2m7CwMDg7O0NDQwM1a9bEjh075B8oRVFKr9IneceOHcPUqVMxf/58REdHo23btujSpQvi4+MVHRpFUUps0KBBCA0NRa1ataCrqwsDAwORh7xkZmaicePG2Lp1q1Trx8bGomvXrmjbti2io6Pxv//9D5MnT8apU6fkFiNFURVDpT9du379eowePRpjxowBIPh1fvXqVWzfvh3+/v4Kjo6iKGW1ceNGhZTbpUsXdOnSRer1d+zYAWtraybe+vXrIzIyEmvXrkW/fv3kFCVFURVBpU7yuFwuoqKiMHfuXJHlnp6euHPnjsRtcnNzkZubyzxPT08HIDjnL7z+pyoihOBOmzbI//oVX+bMgZ61NTp06CDx+gBhPVXl+ioNWm8lJ8+6GjlypNz2LUvh4eHw9PQUWebl5YXdu3eDx+MVeo1Sads6Pz8/XL9+HSoqKujcubMM3kHVRY952agK9Vja91apk7yvX78iPz8fpqamIstNTU2RlJQkcRt/f38sWbJEbHlISAi0tLTkEmdFkBQdjd8iIgRP/PyQCGBer15oN2pUodsEBweXT3CVDK036WVlZcl1//n5+QgMDMTz58/BYrHQoEED9OzZE2w2W67llkRSUpLENi4vLw9fv36Fubm5xO0Ka+uCgoKKbOuioqIQFxeHkJAQ8Pn8sgVPAaDHvKxU5nosbVtXqZM8oV97mwghhd6hMm/ePEyfPp15Lrxt2cPDA4aGhnKNU5n9s2ePyHNzALbnzsFl1y7o6+uLvMbj8RAcHIxOnTpV+judZInWW8mlpKTIbd9v3rxB165d8enTJ9StWxeEELx69QpWVla4ePEiatWqJbeyS0pSGydpeUGFtXWenp5F3l37zz//4OHDh7C1tUWNGjXg4OCgVElvRUKPedmoCvUo7GkvqUqd5BkZGYHNZov12iUnJ4v98hVSV1eHurq62HI1NbVK++GRxo/btwEAudWqQf3nh20IIXgcEwOPX04VCVX1OistWm/Sk2c9TZ48GbVq1cLdu3eZGy1SUlIwfPhwTJ48GRcvXpRb2SVhZmYmsY1TVVUt8odpads6TU1NAMCCBQuQnp6OSZMmYfPmzaWMngLoMS8rlbkeS/u+KvXdtRwOB87OzmJduMHBwXB1dVVQVBXPt2/fYPmzx4Q/ZQrA44GrogIjAG/CwhQbHEXJSVhYGNasWSNyJ62hoSFWrVqFMCX63Lu4uIi1cUFBQWjWrJlcvvCEvXbCnoUtW7bIvAyKomSjUid5ADB9+nT8888/2LNnD54/f45p06YhPj4efn5+ig6twrh//z7q/fxbs3lzQFUVWT9P53yKjFRcYBQlR+rq6sjIyBBb/uPHD3A4HLmV++PHD8TExCAmJgaAYIiUmJgYZtinefPmYcSIEcz6fn5+eP/+PaZPn47nz59jz5492L17N2bOnCmX+OipWYqqOCr16VpAMNZVSkoKli5disTERDg4OODSpUuwsbFRdGgVxr179/C78Im1NQCAmJoCqalIjI4Gn8+X+eTwFKVo3bt3x7hx47B79260aNECgOBY8PPzQ8+ePeVWbmRkJDw8PJjnwuvmRo4cib179yIxMVFknE87OztcunQJ06ZNw19//QULCwts3rxZbsOn0CSPoiqOSp/kAcD48eMxfvx4RYdRYT0ID4eJ8ImFBQBAt04d4OVLqHz5guvXr6Njx44Ki+9Xqamp+Pvvv5GTk4NBgwahTp06ig6JqoA2b96MkSNHwsXFhTntmZeXh549e2LTpk1yK9fd3b3I6dT27t0rtszNzQ0PHjyQW0wFSfpBd+TIEbRr1w41atQolxgoipJOlUjyqNIjhOD9vXsAAL6aGlSMjAAAqj8bc3MA69atU5okLz8/H15eXrh//z4AYPfu3YiNjS3z3KbPnz9HUFAQ3NzcqsyE9VVd9erVcfbsWbx+/RovXrwAIQQNGjSAvb29okNTKEk9eUOHDkW1atWQlpamgIgoiioMTfKoIsXGxkIrNRUAwLKwAITJ0s+xt8xZLFy5cgURERFo3ry5gqL8z19//cUkeADw/v17PHz4sEyJ2ePHj9GiRQvk5ORAVVUVYWFh9MadKqR27dqoXbu2osNQGoWdri3tEA8URckPTfKoIq1btw4WP/9mFTwVY2YGAHAyNQWSknD9+nWFJ3lfv37F/PnzAQimerp06RLOnTuHS5culSnJ++uvv5CTkwNAcLpuxYoVSjN8BiVb06dPx7Jly6CtrS0yhpwk69evL6eolAu9Jo+iKg6a5FGF+v79O3bs2IGJwgUSkjyrnw1+eV0PVJRbt27hx48fqFu3LsaOHQsATJL3v//9r1T7zMrKwpEjRwAAO3fuhJ+fHy5duoRnz56hQYMGMoudUg7R0dHM9EHR0dEKjkY50SSPoioOmuRRhXr06BH4fD7qV6sGpKeLJnk/R/s3+vYNKlCOJE845ISLiwtUVFSYSd7Dw8Px7ds3kfHOpHXmzBmkp6fD1tYWY8aMwdWrV3H69GmsWrUK+/fvl2X4lBIICQmR+Df1H5rkUVTFQce9oAr1+PFjAEA9XV3BAkvL/16sWxfQ1IRqdjbqQDAFVGJiYvkHWcDDhw8BgDk1a21tDUdHR/D5fJw9e7bE++PxeNiwYQMAwMfHByoqKpg9ezYA4MCBAzh58qRsAqeUkq+vr8Rx8jIzM+Hr66uAiJRDUUneihUrcPjw4XKMhqKootAkjyrUo0ePAAA2wiETCiZ5qqrAz2Rq8M+L0v/888/yDE8EIYTpTWzcuDGzfOjQoQCAZcuWgcvllmif27ZtQ1RUFPT09JjTvy1btsTcuXMBALNmzWJO7VGVz759+5CdnS22PDs7u0r34hZ1p/off/yBYcOGlWM0FEUVhSZ5VKGEpz+Nc3MFC34dA8vZGQAw4ue1afv37y9yfC95CgsLQ3x8PDQ1NdG0aVNm+aRJk2BqaorY2NgS9+Zdu3YNADB//nxYWFgwyxcsWABTU1PExcXh/PnzsnkDlNJIT09HWloaCCHIyMhAeno68/j+/TsuXboEExOT4ndUSdHTtRRVcdAkj5Lo8+fPiPw5ZZn2zyFURHryAKB1awCATVwcNDU1kZKSghcvXpRjlP/ZunUrAGDUqFGo9nPKNQDQ1tZmeuF27dpVon1GRUUBEFzjV5CWlhb69u0LALhz506pY6aUU/Xq1WFgYAAWi4U6depAX1+feRgZGcHX1xcTJkxQdJgKQ5M8iqo4aJJHieHz+ZgwYQIIIejk5ASW8DRngd4sAMDPqZdUHj5Ep5+9Zzdv3izPUAEAubm5uHLlCgBg9OjRYq8Ll127dk3q6waTkpKQkJAAFoslcfiVli1bAoDImHxU5RASEoJr166BEIKTJ0/i+vXrzOPWrVuIj49nhuqpiqRJ8hTVo09RlCh6dy0l5vDhwzh16hQAYEznzkBMDGBqCvw6KbupKdCwIfD0KQZZWuIcgL///hve3t7lGu+NGzeQmZkJc3NzNGnSROx1W1tbuLi4IDw8HCdPnsSkSZOK3aewh65evXrQ0dERe104l+mdO3fw9etXGP2cCYSq+Nzc3AAIBgK3srKi8zL/Qpr64PF44PzaXlAUVe5o60WJEd4dN2TIEAxwcBAstLKSvHL9+gCArg0bQk9PD5GRkZgyZUq5/pIXDkzctWvXQi8KHzhwIAAgICCg2Ni+fv3KnI7r2rWrxHXq1q0LGxsb5Ofno1+/frTnohKysbGBiooKsrKy8OLFCzx69EjkUVVJk+SNGzcOQ4YMoccFRSmYzJO858+fIyAggLlon6pYUlJSEBwcDABYtGgRWGfOCF7o1EnyBj+nN6uenY09e/aAxWLh77//Zk6flgdhktetW7dC1/H29oaGhgaio6Nx+/btIvfXo0cPJCUlARAMnSKJiooKzp8/D3V1ddy4cQNhYWGlC55SWl++fEH37t2hq6uLhg0bokmTJiKPqkqaeaD37duHo0eP0u8BilKwMiV5S5cuFRk2IyQkBE5OTpg1axaaN2+OQ4cOlTlAqnydOXMGeXl5aNy4Mera2gLC6bsGDJC8wc8kDwkJ6Nu3L/N5OHDgAH78+CH3eJ88eYI3b95ATU0NHTt2LHQ9Q0NDDBkyBAAK/VwSQrB69WrcvXsXADB79mw4CHsyJXB0dGTGS1u9enVp3wKlpKZOnYrv37/j7t270NTUxJUrV7Bv3z7Url0b586dU3R4CiNNkidE57OlKMUqU5J38uRJkamdVqxYgcmTJ+Pr16/YunUrVq5cWeYAqfITHR2NmTNnAgAGDRoEJCUBOTmCa/EKm/tVmOT9vKFh2rRpsLe3F5kOTJ6WLl0KAEyPS1EGDRoEQJDI5ufni71+9OhRZgy8vn37SpW4zZw5EyoqKrhy5Qq907aSuX79OjZs2IDmzZtDRUUFNjY2GD58ONasWQN/f39Fh6cwJblGkc/nyzESiqKKU6okb//+/di3bx/i4uIQExPDPL99+zZ0dHSwf/9+8Pl8vHv3Dvv376/SA4dWFF+/fkX37t2RlpYGExMTjBgxAvj8WfCiqSlQ2K/3X5I8FRUV/PbbbwCA7du3y/WanOTkZGbWiSVLlhS7voeHB6pXr47Pnz8jKChI5DVCCNauXcs8X7RokVQx1KxZE8OHDwcADBgwoFx6L6nykZmZyYyHZ2BggC9fvgAQ9OAqwzR+ilKSnjya5FGUYpUqybOxsYGtrS04HA5MTU1hY2OD1NRUVKtWDR4eHrCxsUGtWrXAYrFga2sLGxsbWcdNydjSpUuRkJCAunXr4vHjx6hRowaQnCx4saiBX39J8gBgxIgRUFdXx5MnT7B161bm+jZZu3DhAgghcHZ2hqOjY7HrczgcjBo1CoBgtooHDx4wSejbt2/x4MEDcDgcfPnyBY0aNZI6ji1btsDW1hYJCQk4fvx46d4MpXTq1q2Lly9fAhBMlbdz5058+vQJO3bsgLnwc18FlaQnLzs7G+/evZNjNBRFFaVUSZ6bmxvc3NzQtGlTXLx4ERwOB1euXEHXrl3Rrl07uLm5wdzcHFZWVsxzSnkJv7gA4K+//vpvNP+CPXmFEX7Zff0K/BxPT19fHx06dAAATJ48Ga1bt5bL9F9Hjx4FAPTs2VPqbaZNmwZNTU08ffoUzs7O2Lx5MwAw1+E5OzuXeDiUatWqMb2X//zzT4m2pZTX1KlTmXEVFy1ahCtXrsDa2hqbN2+u0peilKQnr0ePHqhVqxZu3bolx4goiipMma7J+/PPPxEdHY3WrVvj/fv3zPVRALB371507ty5zAFS8rd161bweDy0bduWSc4A/NeTV1SSZ2gIaGgI/i7wi33w4MFMsvTu3TuZT/8VGhqK4OBgqKqqlmiuTCsrK5wR3jEMwVybT548YZK8Vq1alSqekSNHQk1NDeHh4cxMIVTFNmzYMObu6iZNmiAuLg4RERH48OEDc31nVVSacQP37t0r+0AoiipWmZK8xo0bIy4uDl++fMGzZ89gVWAstZkzZ1bpX7sVRWZmJnbu3AkAmDFjhuiLwp68ok7XqqgAP2d/wI0bzOJq1aohMjISvXr1AiC4Pk8W0tLSEB4ejlmzZgEAfvvtN9SqVatE+/Dy8kJ+fj5at26NHz9+wNHREQEBAQBKn+SZm5szX/ybNm0q1T4o5aalpYWmTZtW+YGvS9KTJ6SqSsfdpyhFkMmRZ2hoKLasKl+zUhEQQrB161YsW7YM379/h729Pbp37y66kjQ9eQDg5gaEhQke48Yxiy0sLLBx40acO3cO//77L169eoU6deqUOuZ///0XY8aMwfv37wEAOjo6WLhwYan2paKignPnzqFly5Z48+YNsrKyUKdOnUIHP5bG1KlTcfDgQRw7dgz+/v6w/HWuX0rpTZ8+Xep1169fL8dIlFdpkjw63y1FKYbcfl5FRkYiKysL7dq1k1cRVBmEhoZi8uTJzPNZs2aJN8TS9OQBQNu2gn9/nvIsyNbWFl27dsXFixexa9cujBo1CnXq1IGamlqJ4r1x4wY6/TIg84YNG/67frAUDAwMsGPHDvTo0QMuLi44fvy4xCnMpOXs7Iw2bdrg1q1b8PT0RFBQEE30Kpjo6Gip1itNolNZlHaat7i4ONja2so2GIqiiiS3JM/b2xuvXr2SOB4ZpXjCU7SAYCDfsWPHiq/06ZPg3+J6ZYW9cx8+ABL+v3/77TdcvHgR69atw7p16+Di4oJr165BU1NT6ngPHDgAQJCYrVixAmZmZujdu7fU2xemQ4cO+PLlC7S1tcu8LwDYvXs3OnTogOfPn6Nz586IiYmhp6oqkJCQEEWHoPRKk+Bu27YN27Ztw44dO5iblCiKkj+5zV177do1euu8koqJiWGG+oiOjsbs2bPFG24eD3j7VvB3cadYLSwANluwjbD3r4AuXbqIXDcXHh6Ov//+W+p4uVwuTp06BUAwALefn59MEjwhWSV4AFCnTh3cunULhoaGePr0KZYuXYqsrCyZ7Z8qf2/evMHVq1eRnZ0NAOU2H+u2bdtgZ2cHDQ0NODs74+bNm4WuGxoaChaLJfZ48eKFzOMqbU8eAJGzBxRFyZ/ckjwLCws6Pp4S+vLlCwYMGABCCAYPHgynwmayePsWyMsDdHSAGjWK3qmq6n/r/LxeTvRlVVy7dg2///4785m4fPkyACAvLw8ZGRlF7j4oKAjfv3+Hubl5hTj9b2NjgwULFgAAli1bhoYNGzJDcVAVR0pKCjp06MBcqyn8PxwzZoz4TUoyduzYMUydOhXz589HdHQ02rZtiy5duiA+Pr7I7V6+fInExETmUbt2bZnHVpZT1bRXm6LKV5mTPDabjWThBfoFpKSk0IttldCcOXPw5s0b2NnZYcOGDYWv+Py54N969Qqf7aIgYUJfyJeQjY0Ntm3bxgylcuXKFYwcORJ2dnawsLAodEqwZ8+eoUePHgCAgQMHVpjP1KRJk7BmzRoAgmuRLCwscPbsWQVHRZXEtGnToKamhvj4eGhpaTHLBw0ahCtXrsi17PXr12P06NEYM2YM6tevj40bN8LKyqrYu9RNTExgZmbGPORxvJSlJw8Anj9/Du7PMTUpipKvMid5hZ26yM3NBYfDKevuKRkJDAxEw4YNmaFCDh8+DDMzs8I3EE77Va+edAVYWwv+ldCTV5CDgwNzM8L+/fvx8eNH/PjxA3379sWHDx+Y9dLS0pCcnIwxY8Ywy4RjllUEKioqmDVrFoKDg5ll48ePr3Rfbj9+/Ki0U7kFBQVh9erVYjfP1K5dm7nDWx64XC6ioqLg6ekpstzT07PY+ZGbNGkCc3NzdOjQQW7XF5alJy8rKwsNGjSo0uMMUlR5KnXfuXCmABaLhX/++UfkrsT8/HzcuHED9aRNECi5OnToEEaOHMncBDN9+vSix4OLigJ+zoDB3DlbHGFPXjHXYbJYLJw7dw4BAQE4cOAAOnfujKioKLx+/RpOTk4YP3486tatCx8fHyZeFouFyMjIwk8tK7GOHTviyJEjGDJkCBISEnD48OEKlawWhcvlomXLlnj37h327duHgQMHKjokmcrMzBTpwRP6+vUr1NXV5Vbu169fkZ+fD9Nfhi4yNTUtdIpAc3Nz7Nq1C87OzsjNzcWBAwfQoUMHhIaGFnqJQ25uLnJzc5nn6enpAAAej1fkDDWymI82MDBQLrPgVDTCOqB1UTZVoR5L+95KneQJT/URQrBjxw6R0wIcDge2trbMVFnysGLFCly8eBExMTHgcDhITU0VWyc+Ph4TJkzA9evXoampiaFDh2Lt2rVVqodx69atmDRpEgDBr/yZM2diyJAhRW90/brg31atgNGjpSuoRQvBv5cuAT9/ABSmSZMmaNKkCTZt2gQWi4W4uDh0794dT58+xfLly8XWnzp1Kpo2bSpdHEpo8ODB+PDhA2bPno1Ro0bBwMCgRFOxKavjx4/j2bNnAASnMJ8+fYqZM2dCV1dXwZHJRrt27bB//34sW7YMgODHBp/Px59//gkPDw+5l/9rjxkhpNBetLp166Ju3brMcxcXF3z48AFr164tNMnz9/fHkiVLxJYHBQVJTG6FZHUzx6VLl2Syn8qgYI8/VXqVuR5LewNfqZO82NhYAICHhwdOnz4NfX390u6qVLhcLgYMGAAXFxfs3r1b7PX8/Hx069YNxsbGuHXrFlJSUjBy5EgQQrBly5ZyjVVRYmNjMW3aNACCRGndunXSXU/z5Ing327dBHfNSsPTU3CTxocPYN27J9Umwi8sW1tbxMTEYMSIEThy5AjzupqaGuzt7SV+EVU048aNw/Lly5Geno5evXph2bJl+OOPPxQdVpkIT/0LLV26FDdv3sSlS5egIZzqrgL7888/4e7ujsjISHC5XMyePRtPnz7Ft2/fcPv2bbmVa2RkBDabLdZrl5ycLNa7V5RWrVrh4MGDhb4+b948kcGf09PTYWVlBU9PT1SrVq3Q7RISEqSOoSihoaFo1KgRhg8fLpP9VUQ8Hg/BwcHo1KlTiccOpf5TFepR2NNeYqSCCwgIIHp6emLLL126RFRUVMinT5+YZUeOHCHq6uokLS1N6v2npaURAOTr16+yCLfc5OXlke7duxMApFOnToTP50u/cZMmhACEnDlTskK9vQkBSP7AgSQwMJBwudwSbR4XF0cAEACkQYMGhMfjkby8vJLFoMTCwsJI//79mfc4e/ZskffH5XJLVW+KkJubSzQ0NAgAsnr1auY9ASC9evUiXC6X3Lp1iyxZsoS8fv1abnF8/fqVACjRMV0SiYmJZOHChaRbt26kS5cuZP78+SQhIUEuZRXUokUL8vvvv4ssq1+/Ppk7d67U++jXrx/x8PCQen1hW1dcXf79998i/99lfVRlFemYV2ZVoR6lPT5/VaqevOnTp2PZsmXQ1tYudhogRU39Ex4eDgcHB1hYWDDLvLy8kJubi6ioqEJPt5T2OhVlM3XqVFy4cAEcDgfLly9HXl6edBvm50P12TOwAPDq1ROMfSetSZOgduAAWCdPQqNTpxLXl4WFBW7evImTJ0+if//+IISAECKTa4CUgYuLC1xcXFCjRg1s2rQJa9asgZGREaZOnQqgYl1XcvfuXeTk5DDxT5gwAeHh4ejevTvOnj0rcknEjRs3mCFzZE1edcXj8eDp6YmdO3cqpCd5+vTp8Pb2RrNmzeDi4oJdu3YhPj4efn5+AAS9cJ8+fcL+/fsBABs3boStrS0aNmwILpeLgwcP4tSpU8z4krJUlWf7oKiKplRJXnR0NNO4FjUNkCIbg6SkJLFTG/r6+uBwOIVevAwUfp1KSEhIkdepKAs+n487d+5g27ZtYLFYmDJlCjNmljS0P31Cx9xc5HE4uPT8OfDyZYnKd3VwgPGTJ7AOCUGwsXFp3gI8PDyQkpJSaa/ZcXd3R1paGvbu3YsFCxbg69ev4HA4aNasGQDlva4kOzsbd+/eRfPmzRH08+5re3t7kQRu5syZWLduHXJycphlISEhWL9+PY4cOYIGDRqgf//+MhvaQ14DTaupqeHJkycKa8MGDRqElJQULF26FImJiXBwcMClS5eYcSYTExNFxszjcrmYOXMmPn36BE1NTTRs2BAXL14s01zMhZF1nQQEBCA3N5dJYCmKkh0WIeU0fLsUFi9eXOyv5oiICObLEAD27t2LqVOnit14MW7cOLx//x5Xr14VWc7hcLB//34MHjxY4v4l9eRZWVkhMTERhoaGJXxH5evz58/o27cvIiIiAAgGbd22bVuJ9sEKDITqwIEgTZogT8pr60S2P3gQqr6+yLC0BPvly0p7fURZEULQoEEDvBXOKgLBhehcLhd8Ph+ampro0KGDAiMUxeVy4eHhgYiICPj5+eH9+/e4fPky1q5dKzaLwffv3zF58mQkJibi/fv3YsONLFu2DHPmzJFJXCkpKTA3N0daWlqR15GVxowZM6CmpoZVq1bJdL/KKj09HXp6esXWZUBAAHx9fWVeflxcXJUbQJ/H4+HSpUvo2rUrbSvLoCrUo7TH56+UavjxiRMnFpp8CUk7wbWZmRnu/ZKkfP/+HTwer8iLl9XV1SUOj6CmpqbUHx4+n48RI0YwCR6bzcbUqVNLHvOrVwAAloND6d5vr14AAN2PH8H78QNqJiYl30cV0b9/f6xevZp5fujQIRgYGDA3Bu3atUvynMIKcObMGeaztWfPHuYYcXd3F/ucmJiY4OjRowCALVu2iCWBW7ZswcyZM2Vyc4Y8j0kul4t//vkHwcHBaNasmdj0d4q6FEXR5NW7+ePHjyLvIKYoquTKnORlZmZi1apVuHbtGpKTk8WunyrJ/LVGRkYwMjIqa0gABNc/rVixAomJiTA3NwcgGBpAXV0dzs7OMilDGcTGxmL9+vUwNDRESEgItLW1sXv3btjZ2aFhw4Yl3+HTp4J/GzQoXUAGBiA1a4L17h1YDx4AnTuXbj9VwJQpU/DgwQPY2dlh165dOHTokMjrU6dORZcuXcQG41WEc+fOMX9zuVxwuVzo6uqicePGRW43ZswYrFq1CgkJCThx4gRmzJiB+Ph47N+/H+PGjZN32GXy5MkTZuieVz9//AhV5USkrDNeFGb69Ol48uQJIiMjmTaboqiyKXOSN2bMGISFhcHb2xvm5ubl1vjFx8fj27dviI+PR35+PmJiYgAIrhHS0dGBp6cnGjRoAG9vb/z555/49u0bZs6cibFjx8r8tI6iZGdno3v37sxYZYBgVoVSjyYfGwtcuCD4uzQJ4k/E2VmQ5EVG0iSvCObm5ggKCgIhBNnZ2Thw4AAAwM7ODmZmZggPD8e4ceOwaNEizJgxA/Pnz0eXLl3KPc78/Hzm+shmzZohMjISgGDqtuLmItXU1MStW7eQmJgIV1dXfPz4EdOmTcOyZcvQrVs31ChuXmQFyc/Px+LFi+Ho6AgDAwNFh6NU5NXGC6/zXLNmTdFTLlIUJb2y3tarp6dHbt26VdbdlNjIkSMl3o4fEhLCrPP+/XvSrVs3oqmpSQwMDMjEiRNJTk5OicpR5iFU9u7dK/Le2Ww2efnyZel3OGCAYOiUhg0Jycoq9W7yVq0SDKXSq1fpY6li+Hw+WbRoEVFXVyfHjx8nT548Ierq6gQAUVFRYf6Pnz9/TgghJDg4mBw/flyuMSUlJZFJkyaR8ePHEwBER0eHcLlccuzYMXLw4MGSDcvzU0ZGBrGxsSEAiJ2dHenZs6fYUCElIc8hVNTV1cm7d+9kvl9lJe0QDQcPHpTpECq/PiZMmEBevnxZqs9XRVMVhv4oD1WhHks7hEqZkzxbW1vy7Nmzsu5GaSljknfnzh0SGxtLOnToQACQhQsXkvPnz5ObN2+WfqdfvhCipiZI8qKjyxQf7/p1QgDCr1GjTPuparhcLjlz5gzTUB0+fJioqqqKfAH6+fmR5ORkwuFwCABy4MCBUpfH5/PJrVu3yMmTJ5nx+vh8Pvnrr7+IjY0NU4bw0aFDB5m8zzdv3hAtLS2RfZd2LD15JnnNmjUj//77r8z3q6yk/RI5dOiQXJM84WPz5s3l9M4VpyokJ+WhKtSjwpK8AwcOkP79+5PMzMyy7kopKUuSx+fzyfv378nx48dFGkIWiyWb3oZduwQJXtOmZd4V9/t3wldREezv48eyx1ZFSGqorl+/TmxtbUnz5s2Z//NWrVoxf+vq6jIDfr97945s376dRP+SpPN4PPLq1Sux8tauXcvsp0uXLuTu3bukZcuWhX7pTps2TWbvtWDZAIimpiZJTk4u8X7kmeRdvXqVODk5kfPnz5OEhASSlpYm8qhspP0SOXLkSLkkeRoaGuX0zhWnKiQn5aEq1KPCkjwnJyeiq6tLdHR0iIODA2nSpInIo6JThiTv6dOnpF27dhIbwrKc6hIxcKAgKVu8uMy74nK5JNXWVrC/kydlEFzVUFRDxefzSbdu3SR+Blq0aEFWr15N9PT0mMT/7NmzhBBCvn//ziRuBXtGMjMziaGhocT9aWpqkjlz5pCnT5+S/Px8Zvsy9RRLkJOTQzZu3MiUO3DgwBLvQ55JHovFYh4qKirMQ/i8spH2S+To0aPlkuQBIIMHDya3b98upxoof1UhOSkPVaEey3XGi4J69+5d1l1QRUhLS0Pbtm3x7ds3Zlnz5s0xa9YsPHz4EHPnzi17IXw+cP264O+OHcu+PwApDRpALy4O6N8fWLIEWLhQJvutqlgsFs6dO4dz587hxYsXUFdXR4cOHeDu7o779+/j/v37zLqEEIwYMQIHDhzAunXrmKGE5s6di5YtW2LWrFm4ceMGAMDGxgajR4/Gwp//P40aNUJQUJDIMENXr17FmzdvZH5Xurq6OsaMGYPAwECEhobi+PHjsLGxQZMmTdC7d29oamrKtLySCgkJUWj5yqo87yw+evQojh49CqI8w7lSVMUil5SzElF0T96ePXsIAFKzZk0SERFBIiMjZT+f66NHgl43bW1CZPBLiMvlktuLFwv2KXyU8IaXqqg0v0ZjYmJInTp1iIGBAdmwYQPJzMwkzs7OUveUnDhxgvB4PLJ69WrSv39/5saO8jZu3DiRuObOnUt4PB7Zt28f2bRpk0idhIaGko4dOxJHR0fm2r7KePq0vEnbU3DixIly68kTPlJSUiplL01V6IEqD1WhHhXWk0fJFpfLxb///ot58+YhMzMTnz9/BgD4+vqKzPQhU7dvC/51cQFkNLjs14YNQQwMwBL2QD58CLRoIZN9U/9p3Lgxnj9/Dj6fzwxnsn//fowZMwZZWVnQ19fHuHHjwOFw0L9/fwBA06ZN4e7ujpYtWzLLZs+erbD3AADbtm1DvXr1EBQUhCtXrmDVqlW4dOkSHj16BAA4ffo0li5divnz5+PWrVvlFldqaip2796N58+fg8VioUGDBvD19YWenl65xaBsFDFGoKGhIdzc3BAaGlruZVNURVbmJE9FRaXIgz4/P7+sRVQJfD4fkZGRmDBhAjMOmZClpSVGjx4tv8KFX5qtW8tsl0RNDXmXLkHNxUXQl3fvHk3y5ERFRUVkgNoGDRrgzp07Iuvk5+dj/vz50NbWxowZM8DhcMo7zCKx2WxMmzYNkyZNgo2NDRISEpgEDwDCwsLg5ubGPG/QoAGGDBmCtm3bwt3dXS4xRUZGwsvLC5qammjRogUIIVi/fj1WrFiBoKAgZqDkqkZegyEXJywsTCHlUlRFVuYk78yZMyLPeTweoqOjsW/fvmLnoaUE7t27h+HDh+PNmzciyzt27IihQ4eib9++8u05ECYEMkzyAABNmwKLFwOLFgEFrhmjyh+bzcby5csVHUaxVFVVcejQIWzatAmfP3+Gj48PTExMMHr0aHz79g3W1ta4fv06atWqBUAwd628TJs2DT179sTff//N9JLm5eVhzJgxmDp1KnNdY1WjyNk+Fi1aBDabzVxDSlFU0cqc5PX6OVdpQf3790fDhg1x7Ngx+fZAVUCfPn3Cxo0bUbt2bQQFBeHu3bv48uULM01UixYt0LlzZ5ibm2Po0KHyb1CTkwUzXbBY8ulpE16sHx0t+31TlZK7u7tY71yzZs2wfft2+Pj4MAmevEVGRookeIAgCZ09e7b8Lp2oABTVkwcAS5cuBQD89ttvRc5BTlGUgNyuyWvZsqXSTK6uDN68eYOVK1ciICBA4ut2dnaIiIiAoaFh+QYm7GGrVw+QR29hkyaCf1+8ALKzAQXfMUlVTJaWllixYkW5llmtWjXEx8ejXr16Iss/fPgAXV3dco1FmSjDvL1Hjx5FWloa/vjjD4UmnRSl7OSS5GVnZ2PLli1KMbF6eTp37hwuXLgADw8PDB48mGkMp02bho0bNxa6nZqaGg4dOlT+Cd6VK8D69YK/W7aUTxnm5oCxMfDlC/DkCdC8uXzKoSgZGzRoEEaPHo21a9fC1dUVLBYLt27dwqxZszBkyBBFh6cwypDkTZ06FQBgYWGBMWPGKDYYilJiZU7y9PX1RQ56QggyMjKgpaWFgwcPlnX3FcbXr1/Rv39/8Hg8/P3335g/fz5atGiBRo0aiSV4vr6+SEtLg7e3N9hsNqpXrw4XF5fyDfj9e6DgZPcdOsinHBZL0JsXFAQ8eECTPKrCWLt2LVgsFkaMGIG8vDwAgh9kv//+O1atWqXg6BRHmXrOjh49isDAQGzcuBH29vaKDoeilE6Zk7xfExgVFRUYGxujZcuW0NfXL+vulUZ6ejo4HA7WrFmDqKgobN++Ha9fv8auXbuQk5ODx48fg8fjARDUQWxsLGJjY3Hs2DEAQPfu3bF582acPXsWfn5+0NDQUOTbAe7e/e9vBwdg8GD5ldW06X9JHkVVEBwOB5s2bYK/vz/evn0LQgjs7e2hpaWl6NAUShl68oSuXbsGQDBo/KVLl6Ctra1USShFKVqZk7yRI0fKIg6lV7NmTZHnnp6eSElJEbu7b+vWrXB0dGRG8Y+Ojoa5uTm2b98OS0tL5jSDwgmHadHQAC5cAFTlOGSi8CL1yEjg338FvXlVeJwxqmJIS0tDfn4+DAwM4OjoyCz/9u0bVFVVUa1aNQVGpzjKmETdunUL+vr6+OOPP7B48WJFh0NRSoMOhlxKr169Yv5u0qQJjI2N0bp1a/j5+YHNZqNdu3bIyMjA3r170b17d+W7PjEqSvDvX38BNjbyLUt4h+2DB0CnTkDv3sAvQ+9QlLIZPHgwevTogfHjx4ssP378OM6dO4dLly4pKDLFUqaevILy8/OxZMkSPHz4EB06dMDEiRMVHRJFKZzy/SRTUjt37sT9+/fx/ft3bNiwgVm+du1aPHjwAFevXsXChQvBZrOZ13R1dTFp0iTY2dkpIuTC5eQIBicGymeAYhsbwMTkv+eBgYJhWyhKid27dw8eHh5iy93d3Zn5gKsiZezJKygwMBCTJk1CcHAwLl++rOhwKEqhaE+elPr168fc/TphwgRkZ2ejZs2aGDhwoIIjK4UbN4CsLMDCAmjYUP7lsViCQZEL9ojs2gX4+8u/bIoqpdzcXOaGi4J4PB6ys7MVEJFyUNaevF95enoCEJx1yc/PFxsKh6KqAprklYKamhrmzZun6DBK79w5wb+dOwsSsPLg5ye4/u/pU0GCOWxY+ZRLUaXUvHlz7Nq1C1u2bBFZvmPHDjgLL0GogipKkidUv3598Pl8PHjwAGZmZjAzM1N0SBRVbmSW5H358gUvX74Ei8VCnTp1YGxsLKtdU7KUlgbs3y/4++fk9OWCxQJGjSq/8iiqjFasWIGOHTsy13gBgrs5IyIiEBQUpODoFEfZT9f+Sjh/epOfA7MfOnQIgwcPrnDvg6JKo8yf8szMTPj6+sLCwgLt2rVD27ZtYWFhgdGjRyMrK0sWMVKydOQIkJEB1K8PeHkpOhqKUlqtW7dGeHg4rKyscPz4cZw/fx729vZ49OgR2rZtq+jwFKai9eT9atiwYdDU1MTq1avB5XKZJJCiKqMyJ3nTp09HWFgYzp07h9TUVKSmpuLs2bMICwvDjBkzZBEjJUsXLwr+9fYG6C9ZiiqSk5MTDh06hKdPnyIyMhJ79uxB7dq1y6Xsbdu2wc7ODhoaGnB2dsbNmzeLXD8sLAzOzs7Q0NBAzZo1sWPHDrnEVRl6wLhcLubOnQtzc3N06dIFb9++xcOHDxUdlszw+XwAQGpqKng8Hm7fvo0XL14gOjoaQUFBSEpKQlhYGHg8HkJCQpCXl4fk5GSJ16BSFVuZT9eeOnUKJ0+eFJlQvGvXrtDU1MTAgQOxffv2shZByUp2NvBz8FB066bYWCiKKtSxY8cwdepUbNu2Da1bt8bOnTvRpUsXPHv2DNbW1mLrx8bGomvXrhg7diwOHjyI27dvY/z48TA2Nka/fv1kGltF78kr6Nu3bwgODoa9vT1UVFTwxx9/4N69e9i0aROioqLQpUsXqKmpQVtbu1zed3p6OrhcLuLj4/Hy5UvY2tri2LFj8PT0xJ9//omBAwdi27ZtGDRoEMLCwlCnTh38+PED3759Q9OmTXHq1Cn069cPa9euRe/evXH48GE4OTnh4cOHUFNTQ15eHvh8PtTV1ZGbmwtzc3MkJiaiVatWuHfvHjp37oz4+Hg4ODhAS0sLycnJ6Nu3L86ePYvp06fjwoULGDduHIKCguDl5YUfP37A1NQU5ubmIIRUqs9GZcEihJCy7EBLSwtRUVGoX7++yPKnT5+iRYsWyMzMLFOAipaeng49PT18/fq1/OeWlaVHjwSDEHO5gK0t8O6d3G664PF4uHTpErp27Qo1NTW5lFEZ0XoruZSUFBgZGSEtLa1SDU7csmVLNG3aVORHcv369dG7d2/4S7grfc6cOTh37hyeP3/OLPPz88PDhw8RHh4uVZnCtq64urxz5w5at25dgndTcdWoUQOpqalo06YNGjduDA0NDQwfPhyvXr1C165dkZycDFNTU2RnZ4PD4SA7OxuxsbGwtLTE8ePH0adPH5w9exatW7fG58+foa6uDlNTU0RHR6NNmzbYvn071NXVERQUhAYNGuDYsWPIy8tDenq6ot+61IyMjGDyc4isESNG4O3bt/Dz80N0dDSGDBmCz58/w9bWViwBFCaFqampUFNTw5cvX5Camorq1avj8ePHcHBwwNWrV+Hl5YWLFy+iR48euH37NlxdXfHmzRvY2Ngws8/o6+vj3Llz6NevX6VtO6U9Pn9V5iSvQ4cOMDQ0xP79+5mpurKzszFy5Eh8+/YN//77b1l2r3CVIsnLzwcaNQKePRM8//tvQI6TetNkpXRovZVcZUzyuFwutLS0cOLECfTp04dZPmXKFMTExCAsLExsm3bt2qFJkybYtGkTs+zMmTMYOHAgsrKypPo8SfslEh4eDldX1xK+q8pH2AvWrVs3REREQFNTE1paWiKJNiVQt25dJCQkwMnJCS9fvkTDhg3x6NEjmJmZ4d27d2Cz2fjx40ep9q2urg51dXVwuVzUr18f8fHx6Nq1K8LDw9G+fXvExcXB3t4eWVlZ0NXVhY6ODng8HmrWrIlv377B0NAQXC4XOTk5yM/PR25uLn78+AE+n4/v37/D0NAQb968QePGjfHo0SM0bdoU9+7dQ8OGDREbGwttbW1kZmYiIyMDpqamiImJQYMGDXDv3j20a9cO9+/fh6urK96/fw87OzumR7V9+/a4f/8+Bg8ejGbCWaGKUNokD6SMHj16RGrUqEEMDQ1J+/btSYcOHYihoSGpUaMGefLkSVl3r3BpaWkEAPn69auiQym9AwcIAQSP8eMJ4fHkWhyXyyWBgYGEy+XKtZzKhtZbyX39+pUAIGlpaYoORWY+ffpEAJDbt2+LLF+xYgWpU6eOxG1q165NVqxYIbLs9u3bBABJSEiQuE1OTg5JS0tjHh8+fGDaOi6XW+jj5s2bBAB90Ad9yOgxZcqUIo85Lpdb6rauzNfkOTo64vXr1zh48CBevHgBQggGDx7M3MFEKVhuLrBggeDvlSuBijy+H0VVIYWd3irJ+pKWC/n7+2PJkiViy4OCgpjTYJK8ffu20NcoStmpqalBQ0MD+fn50NXVhZqaGlRUVJCfn8/06OXm5oLFYkFHR0dsfvqyUlFRgba2NnJzc2FsbIzExESoq6sXO01iaUcrKXOSd+PGDbi6umLs2LEiy/Py8nDjxg20a9eurEVQZbF1KxAXB5ibA1OmKDoailJqffv2lXrd06dPyyUGIyMjsNlsJCUliSwXXv8liZmZmcT1VVVVC73MZN68eZg+fTrzPD09HVZWVvD09CzydFBERIS0b6XSYLFY0NPTg6urK5KTk/G///0PQUFBmD59OkJCQuDo6Ij379/j48ePqFevHnbt2oVOnTrh77//xoABAxAWFgYnJycQQhAXF4f27dsjICAA3bp1w8qVK1GrVi28evWKScwrKjU1NTRp0gSfPn3CxIkT8eDBA0yePBkxMTHo3r07IiMj4ebmhrCwMDRr1gy3bt2CnZ0d7t69C0Dww+TBgwdwdHTElStX4O7ujpMnT6Jfv364evUqevXqhZs3b8LNzQ1xcXGwsLBAnTp18P79e6irq0NXVxddunRBTEwM2rVrh0ePHsHBwYE51cliscBiscDhcIr90ZSXlwc2m42MjAzo6Ojg06dPsLKyQnJyMoyNjREXFwcTExNkZWWBzWaDy+Xi27dvqFGjBh48eABXV1fcu3cPrVq1wuPHj1G/fn2kpqZCS0sL1atXR15eHlRVVfHu3TvY2toWe9d6aa/TLPM1eWw2G4mJicyFl0IpKSkwMTGp8GMQVehr8vh8wMwM+PIF2L0b8PUtl2LptWWlQ+ut5GR9Td6oAgN2E0Jw5swZ6OnpMdfMREVFITU1FX379kVAQECZyytMy5Yt4ezsjG3btjHLGjRogF69ehV648X58+fxTHjdLYDff/8dMTExMr/xIjIyEs2bNy/Bu6lYOnfujNu3b2PdunWIiYnB4MGDUb16dejr68PS0lKmZfF4PJw9exY9e/bEzZs3oauri5CQELx58wYmJiY4duwYnJ2dcfz4cTg5OSEmJgbW1taIj4+HkZERMjIyoKGhgerVqyMhIQHGxsZISEgAm80u9Xcvm80Gm80Gh8NBjRo1EBcXh3bt2uHatWuYMGECLl++jN9++w3//vsvevTogby8PNSoUQOtW7dGZmYm7O3tZVpH0qgKbWdpr8krc09eYdlwSkoKtLW1y7p7qiyePBEkeNragnHxKIoqUsHEbc6cORg4cCB27NgBNpsNQDB7wvjx4+V+k8f06dPh7e2NZs2awcXFBbt27UJ8fDz8/PwACHrhPn36hP0/Z6/x8/PD1q1bMX36dIwdOxbh4eHYvXs3jhw5IvPYKtswGc7OzuDz+di7dy+ePn2KwYMHl+t7VFNTA4vFYmZVadGiBfPaihUrAAB//fUXDA0NERMTg/r16+PFixewtLREWloaVFRUoK+vj9TUVBgaGuL27dto1aoVAgIC0KNHD2zfvh2urq64e/cuWCwWDA0NER4eDh8fHxw4cADTp0/H+fPn4e3tjaioKDRt2hSqqqpQUVGBlZUVMjIyYGxsjIyMDJHP/cyZM8utjqgyKNEVfAX06dOH9OnTh6ioqJCuXbsyz/v06UN69uxJbG1tiZeXV2l3X6TY2Fji6+tLbG1tiYaGBqlZsyZZuHAhyc3NFVnv/fv3pHv37kRLS4sYGhqSSZMmia1TnAp948WmTYKbLeT0/1AYegNB6dB6Kzl53nhhZGREXrx4Ibb8xYsXxMDAQObl/eqvv/4iNjY2hMPhkKZNm5KwsDDmtZEjRxI3NzeR9UNDQ0mTJk0Ih8Mhtra2ZPv27SUqT9jWFVeXDx48UPiF6rJ4ODo6kuXLlxNCCOHz+SWqK1mhx7xsVIV6lPb4/FWpe/L09PSESSJ0dXVFbrLgcDho1aqV2HV6svLixQvw+Xzs3LkT9vb2ePLkCcaOHYvMzEysXbsWgOAXd7du3WBsbIxbt24hJSUFI0eOBCFEbMLxSuv8ecG/BQaqpihKOnl5eXj+/Dnq1q0rsvz58+fMjALyNH78eIwfP17ia3v37hVb5ubmhgcPHsg5qordk6ejowNdXV1s3bpV5PrLivyeKKoopU7yhKc1bG1tMXPmzHI9Ndu5c2d07tyZeV6zZk28fPkS27dvZ5K8oKAgPHv2DB8+fICFhQUAYN26dfDx8cGKFSsqzZhahXr8GPj3X8HUZQMHKjoaiqpwRo0aBV9fX7x58watWrUCANy9exerVq0SuXavqqmICZGuri6ys7Nx9epVOsYfVaWU+Zq8RYsWySKOMktLS4OBgQHzPDw8HA4ODkyCBwBeXl7Izc1FVFQUPDw8JO4nNzcXubm5zHPhHS08Hg88Hk9O0csee+1aqADg9+6NfCsroBxjF9ZTRaovZUDrreTkWVdr166FmZkZNmzYgMTERACCAXBnz55dpeflrkhz12ppaSErKwsREREwMzNjzkBRVFVR5iRPGbx9+xZbtmzBunXrmGVJSUliww3o6+uDw+GIDTVQUGFjR4WEhBQ5dpQy4aSlwfPwYQDArZYt8b2Y8XfkJTg4WCHlVnS03qRX2rGjpKGiooLZs2dj9uzZzI+9Sn8GQAoVqSfv9evXyM7ORq1atRQdCkUphFIleYsXL5aYYBUUEREhMgVIQkICOnfujAEDBmDML1N1SWqMSDFj4xQ2dpSHh0eFGUKFdfo02Hl5IA4OcJk2rdzL5/F4CA4ORqdOnSrt7ezyQOut5GQ9UOmv8vLyEBoairdv32Lo0KEABG1OtWrVoKOjI9eylVVF6Mk7d+4cdHR0RM7kUFRVpFRJ3sSJEzF48OAi17G1tWX+TkhIgIeHBzPEQEFmZma4d++eyLLv37+Dx+MVOqAo8N88eL9SU1OrGF+8iYnA3LkAAFbr1gqNucLUmZKh9SY9edbT+/fv0blzZ8THxyM3NxedOnWCrq4u1qxZg5ycHOzYsUNuZSszZe7Jc3V1hbe3N3r06KHoUChKKShVkmdkZAQjIyOp1v306RM8PDzg7OyMgIAAsV+XLi4uWLFiBRITE2Fubg5AcDOGuro6nJ2dZR67UsjJATp1EsxwAQAFxluiKKpkpkyZgmbNmuHhw4civfh9+vQRO2tQlShrT56Pj49cB6imqIqoVEne5s2bpV538uTJpSmiSAkJCXB3d4e1tTXWrl2LL1++MK+ZmZkBADw9PdGgQQN4e3vjzz//xLdv3zBz5kyMHTu28l5Xs3078PTpf89btlRcLBRVwd26dQu3b98Gh8MRWW5jY4NPnz4pKCrFU7aevMGDB2PcuHF0Ck2KkqBUSd6GDRukWo/FYsklyQsKCsKbN2/w5s0bsWlmyM9Z2thsNi5evIjx48ejdevW0NTUxNChQ5khViqlAwcE/7ZoIRg2pWFDxcZDURUYn8+XODXUx48foaurq4CIlIOyJHmNGjVCfHw85s6di8aNGys6HIpSSqVK8mJjY2UdR4n4+PjAx8en2PWsra1x4cIF+QekDF6/BqKjAVVV4NIloILcJEJRyqpTp07YuHEjc70vi8XCjx8/sGjRInTt2lXB0SmOspyuXb58Obp37640SSdFKSOZXZPH5XIRGxuLWrVqQVVVqS71q9xSU4FNmwDhBeitWtEEj6JkYMOGDfDw8ECDBg2Qk5ODoUOH4vXr1zAyMpLLnLAVhaKTqhYtWuDjx49wd3dXeCwUpezKnI1lZWVh0qRJ2LdvHwDg1atXqFmzJiZPngwLCwvM/XmnJyUn06cDBS82LjC8DEVRpWdhYYGYmBgcOXIEDx48AJ/Px+jRozFs2DCRaRyrGkX35F27dg3q6ur0DnSKkkKZk7x58+bh4cOHCA0NFZlqrGPHjli0aBFN8uQpJ0c0wQOAynrnMEUpgKamJnx9feHr66voUJSGonvPtLW1FR4DRVUUZf5JFhgYiK1bt6JNmzYiB16DBg3w9u3bsu6eKsrNm+LLaE8eRckEm82Gh4cHvn37JrL88+fPYLPZCopK8RTVkxceHo5Xr17RBI+iSqDMPXlfvnyBiYmJ2PLMzEx6MMrbw4eCf3v1Apo3F/Ts1a2r2JgoqpIghCA3NxfNmjXDuXPn4ODgIPJaVaWodr1Vq1YKKZeiKrIy/yRr3rw5Ll68yDwXNgB///03XFxcyrp7qiiPHgn+bdYMmD8fWLYMoIk1RckEi8XCqVOn0KNHD7i6uuLs2bMir1VV5f3eBw0ahJMnT5ZrmRRVWZS5J8/f3x+dO3fGs2fPkJeXh02bNuHp06cIDw9HWFiYLGKkCiNM8ho1UmwcFFUJEULAZrOxadMmNGzYEIMGDcIff/xRpWe7AMr/dO3Ro0fLtTyKqkzKfLS6urrizp07yMrKQq1atRAUFARTU1OEh4dX3unDFCkzExg2DFi/Hnj2TLCMDgRKUXI1btw4XLlyBRs3boS3t7eiw1Go8kzyunfvXm5lUVRlVKaePB6Ph3HjxmHBggXMECqUnB05Ahw+LHgAQK1agLW1YmOiqErIxsZG5AYLd3d33L17Fz169FBgVIpXHkmei4sLJk2ahC5dusi9LIqqzMp0tKqpqeHMmTOyioUqSmYmcPo0cOiQ6PIePeh1eBQlB7GxsTD8ZWBxe3t7REdH4927dwqKSvHKI8kzMDDAkCFDUL16dbmXRVGVWZmP1j59+iAwMFAGoVCFys4GvLyAfv2A0FDBMkdHQF0doON3UVS50tDQgI2NjaLDUBh5JnkuLi6oVasWNm7cKLcyKKoqKfONF/b29li2bBnu3LkDZ2dnaGtri7w+efLkshZBTZoE3L793/NBgwSnbblcQaJHUZRMGBgY4NWrVzAyMoK+vn6Rd5L+On5eVSHPJM/Pzw8jRoyQ2/4pqqopc5L3zz//oHr16oiKikJUVJTIaywWiyZ5ZZWcDOzeLfh7925AXx/o2VNwipYmeBQlUxs2bICuri4A0N6kQsgzyaOnZylKtsqc5MXGxsoiDqowwmFSatemp2YpSs5Gjhwp8W/qP/JI8tatW4f379/Tu2kpSsbKnORRciZM8hwdFRsHRVUB6enpUq9brVo1OUaivOSR5Pn4+MDAwEDm+6Woqk4xkxBSxSME4POBx48Fz+mAxxQld9WrV4e+vn6RD+E68vL9+3d4e3tDT08Penp68Pb2RmpqapHb+Pj4gMViiTzkNQ2YPGa80NPTk/k+KYqiPXnKKTcXcHYWXI/35YtgGU3yKEruQkJCFB0Chg4dio8fP+LKlSsABAMxe3t74/z580Vu17lzZwQEBDDPORyOXOKTZU/e5s2bYWJiIjIeIUVRskOTPGVz7RrQsaPoMnt7wRAqFEXJlZubm0LLf/78Oa5cuYK7d++iZcuWAP6bB/zly5eoW7duoduqq6vDzMxM7jHKsidv0qRJMtsXRVHiaJKnbHr3Fn3eqROwYQOgpaWQcCiqqsvKykJ8fDy4XK7I8kZy6F0PDw+Hnp4ek+ABQKtWraCnp4c7d+4UmeSFhobCxMQE1atXh5ubG1asWAETE5NC18/NzUVubi7zXHg9Io/HA4/HK3S7ol4rKVnuqyISvv+qXg9lVRXqsbTvTaZJXmZmJo4dO4bs7Gx4enqidu3astx95XfgAPDjx3/Pt28H/PwUFw9FVWFfvnzBqFGjcPnyZYmv5+fny7zMpKQkiYmZiYkJkpKSCt2uS5cuGDBgAGxsbBAbG4sFCxagffv2iIqKgnohQy35+/tjyZIlYsuDgoKgJecflb169UKrVq1w6dIluZZTUQQHBys6hEqhMtdjVlZWqbYrdZIXHx8Pb29vPHjwAK1atcLu3bvRqVMnvH79GgCgqamJy5cvo127dqUtourg8YBFiwB///+Wde0KDBumuJgoqoqbOnUqvn//jrt378LDwwNnzpzB58+fsXz5cqxbt65E+1q8eLHEhKqgiIgIAJJPhxJCijxNOmjQIOZvBwcHNGvWDDY2Nrh48SL69u0rcZt58+Zh+vTpzPP09HRYWVnB09OzyDuHZdFbcuLEiTLvozLg8XgIDg5Gp06doKampuhwKqyqUI8lufO/oFIneTNnzgSXy8X27dtx4sQJeHl5oXbt2rhx4wZUVFQwfvx4LF68GNevXy9tEVXH4sX/JXhTpgDLlgE/B2SlKEoxrl+/jrNnz6J58+ZQUVGBjY0NOnXqhGrVqsHf3x/dunWTel8TJ07E4MGDi1zH1tYWjx49wufPn8Ve+/LlC0xNTaUuz9zcHDY2NsyPbknU1dUl9vKpqanJ/Yuysn4Rl1Z51HlVUJnrsbTvq9RJ3o0bN3Du3Dm0aNECXbt2hZGREfbs2cM0RH/88Qc6dOhQ2t1XbtnZAIcDXL0qGAdPOKPFn38CM2cqNjaKogAILj8Rnjo1MDDAly9fUKdOHTg6OuLBgwcl2peRkRGMjIyKXc/FxQVpaWm4f/8+WrRoAQC4d+8e0tLS4OrqKnV5KSkp+PDhA8zNzUsUZ3moyvP+UlR5K/W98F++fGEOVgMDA2hpaYn80jQzM8P379/LHmFlc+kSYG4umMGiWzdg3jzg82fAwACgU8BRlNKoW7cuXr58CQBwcnLCzp078enTJ+zYsUNuyVP9+vXRuXNnjB07Fnfv3sXdu3cxduxYdO/eXeSmi3r16uHMmTMAgB8/fmDmzJkIDw9HXFwcQkND0aNHDxgZGaFPnz5yibM07O3tsXjxYqUYpoaiqopS9+T9eo2IPAbIrHQiIoAhQ4D0dCAtTfS1AQMEvXsURSmFqVOnIjExEQCwaNEieHl54dChQ+BwONi7d6/cyj106BAmT54MT09PAEDPnj2xdetWkXVevnyJtJ9tCJvNxuPHj7F//36kpqbC3NwcHh4eOHbsGDMPrzKoXr06Fi1apOgwKKpKKdPdtQsXLmTuwuJyuVixYgUzcnlp7wSptP75Bxg79r/n/foBp07999zHp9xDoiiqcMMK3PjUpEkTxMXF4cWLF7C2tpbq1GtpGRgY4ODBg0WuQwhh/tbU1MTVq1flFo+s5OXlKToEiqpySp3ktWvXjjmVAQCurq549+6d2DoUBLNWFEzwmjQBTp4UDJfi4gLUqAEUGBeLoijlo6WlhaZNmyo6jAqLnu2hqPJX6iQvNDRUhmGUXM+ePRETE4Pk5GTo6+ujY8eOWL16NSwsLJh14uPjMWHCBFy/fh2ampoYOnQo1q5dK7fpfiQ6fx4YM0Z0mXCeRh2d/+ampWQqPz+/wg2MyePxoKqqipycHLmMwVZRcTgcmU6lJS1CCE6ePImQkBAkJyeDz+eLvH769Olyj6kiql69OlJTU7F+/XpFh0JRVU6FnfHCw8MD//vf/2Bubo5Pnz5h5syZ6N+/P+7cuQNA8CXfrVs3GBsb49atW0hJScHIkSNBCMGWLVvkH2BGBjBt2n93zjZsKOitO3oUWLVK/uVXUYQQJCUlFTuhuzIihMDMzAwfPnygvR4FqKiowM7Ornx/nAGYMmUKdu3aBQ8PD5iamtL/k1Jav349+vTpg+rVqys6FIqqckqV5BUcQLM48vr1Nm3aNOZvGxsbzJ07F7179waPx4OamhqCgoLw7NkzfPjwgendW7duHXx8fLBixYoiB/sss7g4oH17IDYWYLGAGTMEY99paPyX9FFyIUzwTExMoKWlVaG+mPl8Pn78+AEdHR2F9FwpIz6fj4SEBCQmJsLa2rpc/z8PHjyI06dPo2vXruVWZmXEYrFogkdRClKqJC86OlrkeVRUFPLz85lb/F+9egU2mw1nZ+eyRyiFb9++4dChQ3B1dWUGDAwPD4eDg4PI6VsvLy/k5uYiKioKHh4e8gvI0hIwMQH4fGDfPkDBk55XFfn5+UyCZ2hoqOhwSozP54PL5UJDQ4MmeQUYGxsjISEBeXl55TrQqZ6eHmrWrFlu5VVW2dnZig6BoqqsUiV5Bcc5Wr9+PXR1dbFv3z7o6+sDAL5//45Ro0ahbdu2somyEHPmzMHWrVuRlZWFVq1a4cKFC8xrSUlJYiPE6+vrg8PhFDkHZGkn7RZz+LDg2rtq1QTTllUhiposOjc3F4QQaGhoiF0/VREI75gkhFTI+OVFVVUVhBCR41JInp8x4VRke/bsgaamptzKqewyMzMVHQJFVVllviZv3bp1CAoKYhI8QJBMLV++HJ6enpgxY4bU+5J2fsdmzZoBAGbNmoXRo0fj/fv3WLJkCUaMGIELFy4wp3RKMwdkYZN2h4SEyH3S7sqmvCeLVlVVhZmZGTIzMyvcTRcFZWRkKDoEpcLlcpGdnY2wsDCxYTjkOVTTgAEDcOTIEZiYmMDW1lasF7Gks15UNY6Ojnjz5g2GDx+u6FAoqsoqc5KXnp6Oz58/o2HDhiLLk5OTS/xlJe38jkLCqYLq1KmD+vXrw8rKCnfv3oWLiwvMzMxw7949kW2/f/8OHo9X5ByQhU3a7eHhUSFPASqCoiaLzsnJwYcPH6CjowMNDY1yK1dWCCHIyMiArq5uhbqWUN5ycnKgqamJdu3aif2/pqSkyK1cHx8fREVFYfjw4fTGi1I4ffo0LC0tK+SxSFGVRZmTvD59+mDUqFFYt24dWrVqBQC4e/cuZs2ahb59+5ZoX9LO7yiJ8FSX8JSOi4sLVqxYgcTERGYKoqCgIKirqxd5raAiJ+2ubMq7zvLz88FisaCiolIhr2kTnqIVvgdlxWKxcObMGfTu3bvU+/Dx8UFqaioCAwMBAO7u7nBycsLGjRvF1lVRUQGLxZL4eZLn5+vixYu4evUq2rRpI7cyKjM1NTWa4FGUgpX5m2THjh3o1q0bhg8fDhsbG9jY2GDYsGHo0qULtm3bJosYxdy/fx9bt25FTEwM3r9/j5CQEAwdOhS1atWCi4sLAMDT0xMNGjSAt7c3oqOjce3aNcycORNjx46V7521FFUKycnJ8PPzg4ODAzQ1NWFmZgYvLy+Eh4cz69ja2oLFYoHFYkFTUxO2trYYOHAgrl+/LnGf+/btQ4sWLaCtrQ1dXV20a9dO5LpVQDDepXCfBR9//PGHXN9vRWBlZUXbijJgs9mKDoGiqrwyJ3laWlrYtm0bUlJSEB0djQcPHuDbt2/Ytm0btLW1ZRGjGE1NTZw+fRodOnRA3bp14evrCwcHB4SFhTG9cGw2GxcvXoSGhgZat26NgQMHonfv3li7dq1cYqKosujXrx8ePXqE7du348WLFzh37hzc3d3x7ds3kfWWLl2KxMREvHz5Evv370f16tXRsWNHrFixQmS9mTNn4rfffsPAgQPx8OFD3L9/H23btkWvXr3E5kEFBHOhJiYmMo+5c+fK9f1WBOvWrcPs2bMRFxen6FAqJFXVCjsMK0VVGjI7CrW1tdGoUSNZ7a5Ijo6OhfZeFGRtbS3Wc0FRyiY1NRW3bt3C9evX0aRJE1SrVg12dnZo0aKF2Lq6urowMzMDIPh8t2vXDubm5li4cCH69++PunXr4u7du1i3bh02b96MSZMmMduuWLECOTk5mD59Onr16gUrKyvmNRMTkxKNZZaYmIguXbogNDQUZmZmWLNmDQYMGMC8/unTJ0yfPh1BQUFQUVFBmzZtsGnTJpFrapXd8OHDkZWVhVq1akFLS0vs1PCvCTglSl4/8imKkh79qUVVboQAcrwDs0haWoLBsIuho6MDHR0dnD17Fg0aNChxMVOmTMGyZctw9uxZzJ49G0eOHIGOjg5+++03sXVnzJiB9evX49SpU5g6dWqJyxJasGABVq1ahU2bNuHAgQMYMmQIHBwcUL9+fWRlZcHDwwNt27bFjRs3oKqqiuXLl6Nz58549OhRuc9cUVqSrg+kpEeTPIpSPJrkUZVbVpZgjmBF+PEDkOKLTlVVFXv37sXYsWOxc+dONG3aFG5ubhg8eLBUveMGBgYwMTFhTiu+evUKtWrVkphMWVhYQE9PD69evRJZbmlpKfL8/fv3Rd5NPmDAAIz5OSfzsmXLEBwcjC1btmDbtm04evQoVFRU8M8//zB3pAYEBKB69eoIDQ2Fp6dnse9J0Xg8HkJDQ7FgwQI6IHIJxcXFQVVVValvHqKoqoIehRSlBPr164ePHz/i8OHD8PT0RGhoKJo2bYq9e/dKtX1x4z8Wt+7NmzcRExPDPAqOeymJ8Aangs+fP38OQDADzps3b6Crq8v0UhoYGCAnJwdv376VKkZFU1NTw5kzZxQdRoVkY2ODGjVqKDoMiqJAe/Koyk5LS9CjpqiyS0BDQwMeHh7o1asXFi1ahDFjxmDRokXw8fEpcruUlBR8+fIFdnZ2AIA6derg1q1b4HK5Yr15CQkJSE9PR+3atUWW29nZlXl+UWHiyOfz4ezsjEOHDomtY2xsXKYyylOfPn0QGBhYorm6KYqilAlN8qjKjcWS6pSpMmrQoAEzjlxRNm3aBBUVFWbcusGDB2Pz5s3YuXOnyI0XALB27VqoqamhX79+ZYrt7t27GDFihMjzJk2aAACaNm2KY8eOwcTEpEIPQWJvb49ly5bhzp07cHZ2FrvGbPLkyQqKjKIoSjo0yaMoBUtJScGAAQPg4+ODmjVrwtzcHA8ePMCaNWvQq1cvkXUzMjKQlJQEHo+H2NhYHDx4EP/88w/8/f1hb28PQHDqdMqUKZg1axa4XC569+4NHo+HgwcPYtOmTdi4caPInbWlceLECTRr1gxt2rTBoUOHcP/+fezevRsAMGzYMPz555/o1asXli5dCktLS8THx+P06dOYNWuW2PV/yuqff/5B9erVERUVhaioKJHXWCwWTfIoilJ6NMmjKAXT0dFBy5YtsWnTJrx58wZ5eXmwsrLC2LFj8b///U9k3YULF2LhwoXgcDgwMzNDq1atcO3aNXh4eIist3HjRjRq1Ajbt2/HggULwGKx0LRpUwQGBqJHjx5ljnnJkiU4evQoxo8fDzMzMxw6dIi5M1hLSws3btzAnDlz0LdvX2RkZKBGjRro0KFDherZi42NVXQIFUq/fv3KNAsKRVGyxyLC+cAoidLT06Gnp4evX7/SuWulxOPxcOnSJXTt2rXc566NjY2FnZ1dhZxOic/nIz09HdWqVaN3JhZQ1P9rSkoKjIyMkJaWJtcEUthMVub5a4VtXXF1yePxJN65Tb9KSk5RbWVlUxXqUdrj81f0m4SiKKoQ+/fvh6OjIzQ1NaGpqYlGjRrhwIEDig6LoihKKvR0LUVRlATr16/HggULMHHiRLRu3RqEENy+fRt+fn74+vUrpk2bpugQKYqiikSTPIqiKAm2bNmC7du3i9xF3KtXLzRs2BCLFy+mSR5FUUqPnq6lKIqSIDExEa6urmLLXV1dkZiYqICIlFdxg2dTFKUYNMmjKIqSwN7eHsePHxdbfuzYMbHBpGVpxYoVcHV1hZaWltQDVBNCsHjxYlhYWEBTUxPu7u54+vSp3GIU0tfXx8qVKxEZGSn3siiKKjl6upaqdPh8vqJDoGRIUXdtLlmyBIMGDcKNGzfQunVrsFgs3Lp1C9euXZOY/MkKl8vFgAED4OLiwow9WJw1a9Zg/fr12Lt3L+rUqYPly5ejU6dOePnyJXR1deUWq46ODubNmye3/VMUVTY0yaMqDQ6HAxUVFSQkJMDY2BgcDqdCDXnB5/PB5XKRk5NDh1D5iRCCL1++gMVilfvQCP369cO9e/ewYcMGBAYGghCCBg0a4P79+8zsHvKwZMkSACjRvMUbN27E/Pnz0bdvXwDAvn37YGpqisOHD+O3336TV6j0BxVFKTma5FGVhoqKCuzs7JCYmIiEhARFh1NihBBkZ2dDU1OzQiWn8sZisWBpaQk2m13uZTs7O+PgwYPlXm5JxMbGIikpCZ6enswydXV1uLm54c6dO4Umebm5ucjNzWWep6enAxCMOcbj8Qotj8fjoX79+nj+/DnGjBlT5LpU0YR1R+uwbKpCPZb2vdEkj6pUOBwOrK2tkZeXh/z8fEWHUyI8Hg83btxAu3btKu2AnqWhpqamkASvokhKSgIAmJqaiiw3NTXF+/fvC93O39+f6TUsKCgoCFpaWkWW+b///Q/Pnz9Ho0aNcOnSpVJETRUUHBys6BAqhcpcj1lZWaXajiZ5VKUjPLVX0RIlNpuNvLw8aGhoVLjYKxMVFZVie1JZLBby8vKk3ufixYslJlQFRUREoFmzZlLvU1JMBRFCinwf8+bNw/Tp05nn6enpsLKygqenZ7EzXgQHB2P+/Pn0c1pGwrrs1KkTrcsyqAr1KOxpLyma5FEURRVw5syZQl+7c+cOtmzZUuKbQSZOnIjBgwcXuY6trW2J9ilkZmYGQNCjZ25uzixPTk4W690rSF1dHerq6mLLpf2BVBF/SCkrWpeyUZnrsbTviyZ5FEVRBfTq1Uts2YsXLzBv3jycP38ew4YNw7Jly0q0TyMjIxgZGckqRBF2dnYwMzNDcHAwc0MIl8tFWFgYVq9eLZcyKYqqGOgtfBRFUYVISEjA2LFj0ahRI+Tl5SEmJgb79u2DtbW13MqMj49HTEwM4uPjkZ+fj5iYGMTExODHjx/MOvXq1WN6HFksFqZOnYqVK1fizJkzePLkCXx8fKClpYWhQ4fKLU6KopQf7ckrhvC0TEZGRqXtBpY1Ho+HrKwspKen0zorAVpvJZeRkQFA9mPppaWlYeXKldiyZQucnJxw7do1tG3bVqZlFGbhwoXYt28f81zYOxcSEgJ3d3cAwMuXL5GWlsasM3v2bGRnZ2P8+PH4/v07WrZsiaCgoBKNkSesw+Ku/aGfU9mhdSkbVaEehcdlSds6FlHUSKMVxLt371CrVi1Fh0FRVBHevn2LmjVrymRfa9aswerVq2FmZoaVK1dKPH1bGX38+BFWVlaKDoOiqCJ8+PABlpaWUq9Pk7xipKamQl9fH/Hx8dDT01N0OBWC8C69Dx8+FHmXHiWK1lvJpaWlwdraGt+/f5d6CrDiqKioQFNTEx07dixy6JbTp0/LpDxlwefzkZCQAF1d3SLvyqWfU9mhdSkbVaEeCSHIyMiAhYVFiQbLp6driyGsTD09vUr74ZGXatWq0TorBVpvJSfLGUJGjBhRJQejVlFRKVEPAf2cyg6tS9mo7PVYmo4mmuRRFEUVIO10YhRFUcqO3l1LURRFURRVCdEkrxjq6upYtGiRxEFDKclonZUOrbeSo3VW/midyw6tS9mg9Vg4euMFRVEURVFUJUR78iiKoiiKoiohmuRRFEVRFEVVQjTJoyiKoiiKqoRokkdRFEVRFFUJ0SSvEDdu3ECPHj1gYWEBFouFwMBARYek9Pz9/dG8eXPo6urCxMQEvXv3xsuXLxUdllLbvn07GjVqxAzi6eLigsuXLys6rArH398fLBYLU6dOVXQold62bdtgZ2cHDQ0NODs74+bNm4oOSalJ0y4SQrB48WJYWFhAU1MT7u7uePr0qYIirhgkHfO0HsXRJK8QmZmZaNy4MbZu3aroUCqMsLAwTJgwAXfv3kVwcDDy8vLg6emJzMxMRYemtCwtLbFq1SpERkYiMjIS7du3R69evap8w1QSERER2LVrFxo1aqToUCq9Y8eOYerUqZg/fz6io6PRtm1bdOnSBfHx8YoOTWlJ0y6uWbMG69evx9atWxEREQEzMzN06tQJGRkZCoxceRV2zNN6lIBQxQJAzpw5o+gwKpzk5GQCgISFhSk6lApFX1+f/PPPP4oOo0LIyMggtWvXJsHBwcTNzY1MmTJF0SFVai1atCB+fn4iy+rVq0fmzp2roIgqnl/bRT6fT8zMzMiqVauYdXJycoienh7ZsWOHosJUWoUd87QeJaM9eZTcpKWlAQAMDAwUHEnFkJ+fj6NHjyIzMxMuLi6KDqdCmDBhArp164aOHTsqOpRKj8vlIioqCp6eniLLPT09cefOHQVFVfH82i7GxsYiKSlJpF7V1dXh5uZG61WCwo55Wo+S0blrKbkghGD69Olo06YNHBwcFB2OUnv8+DFcXFyQk5MDHR0dnDlzBg0aNFB0WErv6NGjePDgASIiIhQdSpXw9etX5Ofnw9TUVGS5qakpkpKSFBRVxSKpXRTWnaR6ff/+fbnHqMyKOuZpPUpGkzxKLiZOnIhHjx7h1q1big5F6dWtWxcxMTFITU3FqVOnMHLkSISFhdFErwgfPnzAlClTEBQUBA0NDUWHU6WwWCyR54QQsWWUZEW1i7ReiybtMU/rURQ9XUvJ3KRJk3Du3DmEhITA0tJS0eEoPQ6HA3t7ezRr1gz+/v5o3LgxNm3apOiwlFpUVBSSk5Ph7OwMVVVVqKqqIiwsDJs3b4aqqiry8/MVHWKlY2RkBDabLdZrl5ycLNZ7QokrrF00MzMDAFqvxSjumBfWFa1HUTTJo2SGEIKJEyfi9OnTuH79Ouzs7BQdUoVECEFubq6iw1BqHTp0wOPHjxETE8M8mjVrhmHDhiEmJgZsNlvRIVY6HA4Hzs7OCA4OFlkeHBwMV1dXBUWl/IprF+3s7GBmZiZSr1wuF2FhYbReCyjumK9ZsyatRwno6dpC/PjxA2/evGGex8bGIiYmBgYGBrC2tlZgZMprwoQJOHz4MM6ePQtdXV3mF5Wenh40NTUVHJ1y+t///ocuXbrAysoKGRkZOHr0KEJDQ3HlyhVFh6bUdHV1xa711NbWhqGhIb0GVI6mT58Ob29vNGvWDC4uLti1axfi4+Ph5+en6NCUVnHtonCst5UrV6J27dqoXbs2Vq5cCS0tLQwdOlTB0SsPaY55Wo8SKO7GXuUWEhJCAIg9Ro4cqejQlJak+gJAAgICFB2a0vL19SU2NjaEw+EQY2Nj0qFDBxIUFKTosCokOoRK+fjrr7+Yz2zTpk3pEEnFkKZd5PP5ZNGiRcTMzIyoq6uTdu3akcePHysu6Ari12Oe1qM4FiGElHtmSVEURVEURckVvSaPoiiKoiiqEqJJHkVRFEVRVCVEkzyKoiiKoqhKiCZ5FEVRFEVRlRBN8iiKoiiKoiohmuRRFEVRFEVVQjTJoyiKoiiKqoRokkdRFEVRFFUJ0SSPouTAx8cHLBYLLBYLgYGBMt13aGgos+/evXvLdN8URcne4sWL4eTkVO7lCtuK1NRUme7X1taWaYOk2XdcXByzviLqoSqjSR4llYJJS8FHwfl9KVGdO3dGYmIiunTpwiwrLOnz8fGROmFzdXVFYmIiBg4cKKNIKYoqLUntYsGHj48PZs6ciWvXrik6VJlaunQpEhMToaenV+y6VlZWSExMxIwZM8ohMqogVUUHQFUcnTt3RkBAgMgyY2NjsfW4XC44HE55haW01NXVYWZmJvP9cjgcmJmZQVNTE7m5uTLfP0VR0ktMTGT+PnbsGBYuXIiXL18yyzQ1NaGjowMdHR1FhCc3urq6UrdvbDYbZmZmla4OKgLak0dJTZi0FHyw2Wy4u7tj4sSJmD59OoyMjNCpUycAwLNnz9C1a1fo6OjA1NQU3t7e+Pr1K7O/zMxMjBgxAjo6OjA3N8e6devg7u6OqVOnMutI6vmqXr069u7dyzz/9OkTBg0aBH19fRgaGqJXr16Ii4tjXhf2kq1duxbm5uYwNDTEhAkTwOPxmHVyc3Mxe/ZsWFlZQV1dHbVr18bu3btBCIG9vT3Wrl0rEsOTJ0+goqKCt2/flr1if1Hw1EbBh7u7u8zLoiiqbAq2h3p6emCxWGLLfj1dK2yTVq5cCVNTU1SvXh1LlixBXl4eZs2aBQMDA1haWmLPnj0iZRXX1hUnJSUFQ4YMgaWlJbS0tODo6IgjR46IrJORkYFhw4ZBW1sb5ubm2LBhg1i7LMn79+/Ro0cP6OvrQ1tbGw0bNsSlS5ekjo2SD5rkUTKxb98+qKqq4vbt29i5cycSExPh5uYGJycnREZG4sqVK/j8+bPIKcZZs2YhJCQEZ86cQVBQEEJDQxEVFVWicrOysuDh4QEdHR3cuHEDt27dgo6ODjp37gwul8usFxISgrdv3yIkJAT79u3D3r17RRLFESNG4OjRo9i8eTOeP3+OHTt2QEdHBywWC76+vmI9mHv27EHbtm1Rq1at0lVYEYSnNoSP6OhoGBoaol27djIvi6Ioxbh+/ToSEhJw48YNrF+/HosXL0b37t2hr6+Pe/fuwc/PD35+fvjw4QMA6du6ouTk5MDZ2RkXLlzAkydPMG7cOHh7e+PevXvMOtOnT8ft27dx7tw5BAcH4+bNm3jw4EGx+54wYQJyc3Nx48YNPH78GKtXr6Y9d8qAUJQURo4cSdhsNtHW1mYe/fv3J4QQ4ubmRpycnETWX7BgAfH09BRZ9uHDBwKAvHz5kmRkZBAOh0OOHj3KvJ6SkkI0NTXJlClTmGUAyJkzZ0T2o6enRwICAgghhOzevZvUrVuX8Pl85vXc3FyiqalJrl69ysRuY2ND8vLymHUGDBhABg0aRAgh5OXLlwQACQ4OlvjeExISCJvNJvfu3SOEEMLlcomxsTHZu3dvkfXVq1cvseUAiIaGhkg9amtrE1VVVYnrZ2dnk5YtW5Lu3buT/Px8qcqgKEoxAgICiJ6entjyRYsWkcaNGzPPhW1SwWO6bt26pG3btszzvLw8oq2tTY4cOUIIka6t+1VISAgBQL5//15ozF27diUzZswghBCSnp5O1NTUyIkTJ5jXU1NTiZaWlki7bGNjQzZs2CCyH0dHR7J48eJCyyFEvB4o+aPX5FFS8/DwwPbt25nn2trazN/NmjUTWTcqKgohISESf8m9ffsW2dnZ4HK5cHFxYZYbGBigbt26JYopKioKb968ga6ursjynJwckVOpDRs2BJvNZp6bm5vj8ePHAICYmBiw2Wy4ublJLMPc3BzdunXDnj170KJFC1y4cAE5OTkYMGBAiWIV2rBhAzp27CiybM6cOcjPzxdbd/To0cjIyEBwcDBUVGjHO0VVFg0bNhQ5pk1NTeHg4MA8Z7PZMDQ0RHJyMgDp27qi5OfnY9WqVTh27Bg+ffqE3Nxc5ObmMm35u3fvwOPx0KJFC2YbPT09qdrlyZMn4/fff0dQUBA6duyIfv36oVGjRlLFRckPTfIoqWlra8Pe3r7Q1wri8/no0aMHVq9eLbauubk5Xr9+LVWZLBYLhBCRZQWvpePz+XB2dsahQ4fEti14U4iamprYfvl8PgDBhdHFGTNmDLy9vbFhwwYEBARg0KBB0NLSkuo9/MrMzEysHnV1dcWGIli+fDmuXLmC+/fvizXsFEVVbJLapKLaKWnbuqKsW7cOGzZswMaNG+Ho6AhtbW1MnTqVOd0rbGtZLJbIdr+2wZKMGTMGXl5euHjxIoKCguDv749169Zh0qRJUsVGyQftGqDkomnTpnj69ClsbW1hb28v8hAmi2pqarh79y6zzffv3/Hq1SuR/RgbG4vcvfb69WtkZWWJlPP69WuYmJiIlSPNrf0A4OjoCD6fj7CwsELX6dq1K7S1tbF9+3ZcvnwZvr6+0lZFqZw6dQpLly7F8ePH5XLdH0VRFYss2rqbN2+iV69eGD58OBo3boyaNWuK/OCuVasW1NTUcP/+fWZZenq61D/Krays4Ofnh9OnT2PGjBn4+++/S/YmKZmjSR4lFxMmTMC3b98wZMgQ3L9/H+/evUNQUBB8fX2Rn58PHR0djB49GrNmzcK1a9fw5MkT+Pj4iJ2SbN++PbZu3YoHDx4gMjISfn5+Ir92hw0bBiMjI/Tq1Qs3b95EbGwswsLCMGXKFHz8+FGqWG1tbTFy5Ej4+voiMDAQsbGxCA0NxfHjx5l12Gw2fHx8MG/ePNjb24ucZpa1J0+eYMSIEZgzZw4aNmyIpKQkJCUl4du3b3Irk6Io5SaLts7e3h7BwcG4c+cOnj9/jt9++w1JSUnM67q6uhg5ciRzU9zTp0/h6+sLFRUVsd69X02dOhVXr15FbGwsHjx4gOvXr6N+/fples9U2dEkj5ILCwsL3L59G/n5+fDy8oKDgwOmTJkCPT09JpH7888/0a5dO/Ts2RMdO3ZEmzZt4OzsLLKfdevWwcrKCu3atcPQoUMxc+ZMkdOkWlpauHHjBqytrdG3b1/Ur18fvr6+yM7ORrVq1aSOd/v27ejfvz/Gjx+PevXqYezYscjMzBRZZ/To0eByuXLvxYuMjERWVhaWL18Oc3Nz5tG3b1+5lktRlPKSRVu3YMECNG3aFF5eXnB3d4eZmZnYIOzr16+Hi4sLunfvjo4dO6J169aoX78+NDQ0itx3fn4+JkyYgPr166Nz586oW7cutm3bVtq3S8kIi0hzsp2iyom7uzucnJywceNGRYci5vbt23B3d8fHjx9hampa5Lo+Pj5ITU2V+ZRm5V0GRVFVW2ZmJmrUqIF169Zh9OjRAARnP6ZOnVrs2Hm/Wrx4MQIDAxETEyP7QCmJaE8eRRUjNzcXb968wYIFCzBw4MBiEzyhCxcuQEdHBxcuXJBpPDdv3oSOjo7EC7ApiqLKIjo6GkeOHMHbt2/x4MEDDBs2DADQq1cvkfXmzJkDHR0dpKWlFbvP+Ph46OjoYOXKlXKJmSocvbuWoopx5MgRjB49Gk5OTjhw4IBU26xZswZ//PEHAMHdxLLUrFkz5pcwHWyUoihZW7t2LV6+fAkOhwNnZ2fcvHkTRkZGzOthYWHMKAfS3PlvYWHBtFnq6upyiZmSjJ6upSiKoiiKqoTo6VqKoiiKoqhKiCZ5FEVRFEVRlRBN8iiKoiiKoiohmuRRFEVRFEVVQjTJoyiKoiiKqoRokkdRFEVRFFUJ0SSPoiiKoiiqEqJJHkVRFEVRVCVEkzyKoiiKoqhKiCZ5FEVRFEVRlRBN8iiKoiiKoiohmuRRFEVRFEVVQjTJoyiKoiiKqoRokkdRFEVRFFUJ0SSPKtLevXvBYrGYh6qqKiwtLTFq1Ch8+vRJpmWtXLkSgYGBYstDQ0PBYrEQGhoq0/Kk9ccff8Da2hqqqqqoXr263MvbsmUL7O3tweFwwGKxkJqaCh8fH9ja2oqsV1h9UVRJ/HqMF3zMnDkTcXFxYLFY2Lt3L7PNnTt3sHjxYqSmpso8HmF5kh7NmjWTeXlU+Vi8eDFYLFax6/n4+Ij8n2tra8PW1hY9e/ZEQEAAcnNzyyHaspPUZiuCqqIDoCqGgIAA1KtXD9nZ2bhx4wb8/f0RFhaGx48fQ1tbWyZlrFy5Ev3790fv3r1Fljdt2hTh4eFo0KCBTMopibNnz2LFihWYP38+unTpAnV1dbmWFxMTg8mTJ2PMmDEYOXIkVFVVoauriwULFmDKlCki6xZWXxRVGsJjvCALCwuYmpoiPDwctWrVYpbfuXMHS5YsgY+Pj9x++EyaNAlDhw4VWaajoyOXsijloqmpievXrwMAsrOz8eHDB1y+fBljx47FunXrcOXKFVhaWio4yqJJarMVgSZ5lFQcHByYX9EeHh7Iz8/HsmXLEBgYiGHDhpVp39nZ2dDU1Cz09WrVqqFVq1ZlKqO0njx5AgCYPHkyTExMZLLPrKwsaGlpSXzt6dOnAICxY8eiRYsWzPKCX7AUJQ8Fj/FfKeL4s7a2lrpcQghycnKKbEeoikNFRUXs/37EiBEYNWoUunfvjv79++Pu3bsKik46ytJm09O1VKkID8D3798DAHJycjBv3jzY2dmBw+GgRo0amDBhgtjpHFtbW3Tv3h2nT59GkyZNoKGhgSVLloDFYiEzMxP79u1juund3d0BFH669ty5c3BxcYGWlhZ0dXXRqVMnhIeHi6wjPEXw9OlTDBkyBHp6ejA1NYWvry/S0tKKfI+2trb4448/AACmpqZgsVhYvHgxAIDP52PNmjWoV68e1NXVYWJighEjRuDjx48i+3B3d4eDgwNu3LgBV1dXaGlpwdfXV2J57u7uGD58OACgZcuWYLFY8PHxASDe9V9UfVGULP16unbx4sWYNWsWAMDOzo75/JXn5RQsFgsTJ07Ejh07UL9+fairq2Pfvn0AgNevX2Po0KEwMTGBuro66tevj7/++ktsHy9evEDnzp2hpaUFIyMj+Pn54fz582LvxdbWljkOC3J3dxc75tLT0zFz5kyRdnDq1KnIzMyUGP+BAwdQv359aGlpoXHjxrhw4YLEOIcMGQJTU1Ooq6vD2toaI0aMQG5uLuLi4qCqqgp/f3+x7W7cuAEWi4UTJ04UWo85OTmYMWMGnJycoKenBwMDA7i4uODs2bNi65Yk5osXL8LJyQnq6uqws7PD2rVrC42hJDw9PTF27Fjcu3cPN27cYJYfO3YMnp6eMDc3h6amJurXr4+5c+eK1buPjw90dHTw4sULeHl5QVtbG+bm5li1ahUA4O7du2jTpg20tbVRp04d5jMlJLy0ITg4GKNGjYKBgQG0tbXRo0cPvHv3TqysX0/XlqQOz549i0aNGkFdXR01a9bEpk2bpD7lLYJQVBECAgIIABIRESGyfNOmTQQA2bVrF+Hz+cTLy4uoqqqSBQsWkKCgILJ27Vqira1NmjRpQnJycpjtbGxsiLm5OalZsybZs2cPCQkJIffv3yfh4eFEU1OTdO3alYSHh5Pw8HDy9OlTQgghISEhBAAJCQlh9nPo0CECgHh6epLAwEBy7Ngx4uzsTDgcDrl58yaz3qJFiwgAUrduXbJw4UISHBxM1q9fT9TV1cmoUaOKfO8PHjwgo0ePJgDIlStXSHh4OPnw4QMhhJBx48YRAGTixInkypUrZMeOHcTY2JhYWVmRL1++MPtwc3MjBgYGxMrKimzZsoWEhISQsLAwieU9ffqU/PHHHwQACQgIIOHh4eTNmzeEEEJGjhxJbGxsmHWLqi+KKgnhMX737l3C4/FEHoQQEhsby3wmCSHkw4cPZNKkSQQAOX36NPP5S0tLk0k8wvJWr14tFg+fzyeEEAKA1KhRgzRq1IgcPnyYXL9+nTx58oQ8ffqU6OnpEUdHR7J//34SFBREZsyYQVRUVMjixYuZMpKSkoiJiQmpUaMGCQgIIJcuXSLDhg0j1tbWYm2NjY0NGTlypFicbm5uxM3NjXmemZlJnJyciJGREVm/fj35999/yaZNm4ienh5p3749E7swfltbW9KiRQty/PhxcunSJeLu7k5UVVXJ27dvmfViYmKIjo4OsbW1JTt27CDXrl0jBw8eJAMHDiTp6emEEEL69OlDrK2tSV5enkh8AwYMIBYWFsz/oySpqanEx8eHHDhwgFy/fp1cuXKFzJw5k6ioqJB9+/aJrCttzP/++y9hs9mkTZs25PTp0+TEiROkefPmTN0WZ+TIkURbW7vQ169cuUIAkGXLljHLli1bRjZs2EAuXrxIQkNDyY4dO4idnR3x8PAQ2zeHwyH169cnmzZtIsHBwWTUqFEEAJk3bx6pU6cO2b17N7l69Srp3r07AUAiIyOZ7YXHipWVFfH19SWXL18mu3btIiYmJsTKyop8//5dpKyCbXZJ6vDy5ctERUWFuLu7kzNnzpATJ06Qli1bEltbW6nqUKTMEq1NVTm/fgFkZGSQCxcuEGNjY6Krq0uSkpKYg27NmjUi2x47doxJBIVsbGwIm80mL1++FCtLW1tbYmP6a5KXn59PLCwsiKOjI8nPz2fWy8jIICYmJsTV1ZVZJkzyfo1t/PjxRENDQ6ThlUS4fcHE7fnz5wQAGT9+vMi69+7dIwDI//73P2aZm5sbAUCuXbtWZDlChSXVkhqMwuqLokpC+JmT9ODxeGJJHiGE/PnnnwQAiY2NlXk8wvIkPYKDgwkhgi9LPT098u3bN5Ftvby8iKWlpVjCOXHiRKKhocGsP2fOHMJisUhMTIzIep06dSp1kufv709UVFTEjt2TJ08SAOTSpUvMMgDE1NSUSdQIESSeKioqxN/fn1nWvn17Ur16dZKcnFxofQnbxzNnzjDLPn36RFRVVcmSJUsK3U6SvLw8wuPxyOjRo0mTJk1EXpM25pYtWxILCwuSnZ3NLEtPTycGBgYySfKE7e/vv/8u8XU+n094PB4JCwsjAMjDhw9F9g2AnDp1ilnG4/GIsbExAUAePHjALE9JSSFsNptMnz6dWSY8Vvr06SNS5u3btwkAsnz5cpGyJCV50tRh8+bNiZWVFcnNzWWWZWRkEENDwxInefR0LSWVVq1aQU1NDbq6uujevTvMzMxw+fJlmJqaMhfI/npKY8CAAdDW1sa1a9dEljdq1Ah16tQpdSwvX75EQkICvL29oaLy30dYR0cH/fr1w927d5GVlSWyTc+ePcViyMnJQXJyconLDwkJASD+flu0aIH69euLvV99fX20b9++xOVQVHnav38/IiIiRB6qqmW/bJsQgry8PJGHNKZMmSIWT8uWLZnX27dvD319feZ5Tk4Orl27hj59+kBLS0ukvK5duyInJ4e5jiskJAQNGzZE48aNRcr89UaPkrhw4QIcHBzg5OQkUraXl5fE09keHh7Q1dVlnpuamsLExIS5BCYrKwthYWEYOHAgjI2NCy3X3d0djRs3FjklvWPHDrBYLIwbN67YuE+cOIHWrVtDR0cHqqqqUFNTw+7du/H8+XOxdYuLOTMzExEREejbty80NDSY9XR1ddGjR49iY5GGIFcS9e7dOwwdOhRmZmZgs9lQU1ODm5sbAIi9DxaLha5duzLPVVVVYW9vD3NzczRp0oRZbmBgIPLeCvr1OnRXV1fY2Ngw3w1FkaYOIyMj0bt3b3A4HGY9HR2dUtUhvfGCksr+/ftRv359qKqqwtTUFObm5sxrKSkpUFVVFWuIWCwWzMzMkJKSIrK84LalIdyfpP1YWFiAz+fj+/fvIjc3GBoaiqwnvEs2Oztb5uX/2iiU9f1SVHmoX7++XIYoCQsLg4eHh8iy2NjYYoeXsLS0LDKeX4+rlJQU5OXlYcuWLdiyZYvEbb5+/cqsa2dnJ/a6mZlZkTEV5fPnz3jz5g3U1NSKLFvo1zYJELRLwjbp+/fvyM/Pl+ouUuEd+S9fvkTNmjXx999/o3///sW+n9OnT2PgwIEYMGAAZs2aBTMzM6iqqmL79u3Ys2eP2PrSxMzn8yWWW5a6LUjYvlpYWAAAfvz4gbZt20JDQwPLly9HnTp1oKWlhQ8fPqBv375ibbyWlpZIAgoAHA4HBgYGYmVxOBzk5ORI9V4kfddJIk0dEkJgamoqtp6kZcWhSR4llaK+AAwNDZGXl4cvX76IJHqEECQlJaF58+Yi65f4wlEJ5QFAYmKi2GsJCQlQUVER+YUvawXL/7UBTkhIgJGRkciysr5fiqrInJ2dERERIbJM+AVdFr8eV/r6+mCz2fD29saECRMkbiNM7AwNDZGUlCT2uqRlGhoaEsdm+/r1q8ixbmRkBE1NTYnJkfD1kjAwMACbzRa7mUuSoUOHYs6cOfjrr7/QqlUrJCUlFVoHBR08eBB2dnY4duyYSH2Wdiw6fX19sFgsqeu2NM6dOwcAzE0v169fR0JCAkJDQ5neOwByGcNRqLD3Z29vX+Z9C+vw8+fPUpVbHHq6liqzDh06ABA0GAWdOnUKmZmZzOvFKfhrpih169ZFjRo1cPjwYZGu+8zMTJw6dYq541ZehKdef32/EREReP78udTvt6ykrS+KkrWS9ITr6uqiWbNmIo+Cp6FkRUtLCx4eHoiOjkajRo3EymzWrBnzA83DwwNPnz7Fw4cPRfZx+PBhsf3a2tri0aNHIstevXqFly9fiizr3r073r59C0NDQ4lll3RgXE1NTbi5ueHEiRNivYC/0tDQwLhx47Bv3z6sX78eTk5OaN26dbFlsFgsZtB1oaSkJIl310pDW1sbLVq0wOnTp0V6wDIyMnD+/PlS7bOg4OBg/PPPP3B1dUWbNm0A/Jfs/zqG6c6dO8tcXmEOHTok8vzOnTt4//69TEY40NbWRrNmzRAYGAgul8ss//Hjh8S7cItDe/KoMuvUqRO8vLwwZ84cpKeno3Xr1nj06BEWLVqEJk2awNvbW6r9ODo6IjQ0FOfPn4e5uTl0dXVRt25dsfVUVFSwZs0aDBs2DN27d8dvv/2G3Nxc/Pnnn0hNTWVuh5eXunXrYty4cdiyZQtUVFTQpUsXxMXFYcGCBbCyssK0adPkWr6QtPVFUbLm6OgIANi0aRNGjhwJNTU11K1bV+RaI0XYtGkT2rRpg7Zt2+L333+Hra0tMjIy8ObNG5w/f565fnjq1KnYs2cPunXrhuXLl8PU1BSHDh3CixcvxPbp7e2N4cOHY/z48ejXrx/ev3+PNWvWiF2eMnXqVJw6dQrt2rXDtGnT0KhRI/D5fMTHxyMoKAgzZswQuaZQGuvXr0ebNm3QsmVLzJ07F/b29vj8+TPOnTuHnTt3itT3+PHjsWbNGkRFReGff/6Rav/C4azGjx+P/v3748OHD1i2bBnMzc3x+vXrEsUqtGzZMnTu3BmdOnXCjBkzkJ+fj9WrV0NbWxvfvn2Tah98Pp+5fjI3Nxfx8fG4fPkyjh8/jvr16+P48ePMuq6urtDX14efnx8WLfo/e2ceH9O5//H3ZJVNIogIscS+llJFkLQqllK3umhLqq3WVb1F1aVuN/SWUkVVUa2taKu/q9XFXpW0ltpjr9IkMiJEgsm+n98fk3PMJLOcM0lE4nm/XvNizjznOc85Mznzme/6Lq6urqxfv76UgC9PDh8+zIsvvsgTTzyBXq/nzTffpEGDBowbN65c5p85cyYPP/ww/fv3Z8KECRQWFvLhhx/i7e2t+hrKCEueoMzodDo2bdrEpEmTWLVqFYMGDWLevHlERkby66+/qu4S8fHHH9OiRQueeuop7rvvPv75z39aHfvMM8+wadMmUlNTGT58OM8//zw1a9Zk9+7dyi+8imTp0qV88MEHbNmyhcGDB/Pmm28SERHBvn37LMZcVARarpdAUJ6Eh4czbdo0fvrpJ3r16sV9993HkSNHKntZtG3blqNHj9K+fXveeustIiIiGD16NP/73//MLOyBgYFER0fTtm1bXn75ZUaOHEmNGjVYvHhxqTmfeeYZ5s6dy/bt2xk8eDBLly5l6dKlpZLHvLy8+P3333nuuedYvnw5Dz/8ME8++SSLFi2iYcOGDrW4uueeezh48CBdunRh2rRpDBgwgKlTp+Lu7l7KGtqgQQN69eqFv7+/6gSS559/ng8++ICtW7cyaNAg5syZwxtvvFGmBJR+/fqxadMm0tLSGD58OJMmTeKxxx6zWh/UEtnZ2fTo0YMePXowcOBA3nrrLTIyMvj88885cuQIDRo0UMbWrl2bzZs34+npyciRI3nhhRfw9vZmw4YNDp+DPVasWEFeXh5PPfUU48ePp2vXrkRFRVmM63OEAQMGsHHjRuX7bdKkSTz66KMMHTpUc4cZnWQpVUUgEAgEgruMqKgoHnjgAXbv3l3liosnJyfTuHFjXn31VebOnVvZy6mWrF69mueff55Dhw7d9j7K+fn5dOrUiQYNGrBjxw7V+wl3rUAgEAgEVZRLly4RGxvLhx9+iJOT0x3RL1VQdkaPHk2/fv2oX78+V65cYdmyZZw9e5aPP/5Y0zxC5AkEAoFAUEX54osvmDlzJk2aNGH9+vVmrkxB1SU9PZ3Jkydz7do1XF1duffee9myZQsPPfSQpnmEu1YgEAgEAoGgGiISLwQCgUAgEAiqIULkCQQCgUAgEFRDhMgTCAQCgUAgqIZoTry4evUqkydPZteuXSQnJ5dqFlxYWFhui7sTKCoq4vLly/j4+Ij2VALBHYYkSaSnpxMUFISTk/jNWhbEvU4guHNx9F6nWeQ999xzJCQk8Pbbb1O/fv1qfzO4fPkywcHBlb0MgUBgA71er6qRu8A64l4nENz5aL3XaRZ5e/bs4ffff6dTp05ad62SyG1j9Ho9NWvWtDk2Pz+fHTt2EBERgaur6+1Y3h2PuCalEdfEnLJcj7S0NIKDgyu9nVZ1QO29rrp/fqvz+VXnc4PqfX6O3us0i7zg4OBSLtrbxW+//caHH37IkSNHSEpK4vvvv+cf//iHzX2io6OZNGkSp0+fJigoiClTpjB27FjVx5QtlTVr1lQl8jw9PalZs2a1+4A5irgmpRHXxJzyuB7V3aNwO1B7r6vun9/qfH7V+dygapyfwWAgPT3dojXu0qVL+Pj44Ovra3V/rfc6zUEsCxcu5I033iA+Pl7rrmUmMzOTe+65x2J/QUvExcUxaNAgevfuzbFjx/jPf/7D+PHj2bhxYwWvVCAQCAQCgeAWBoOBAQMGEBYWhl6vN3tNr9cTFhbGgAEDMBgM5XZMzZa84cOHk5WVRbNmzfD09Cyllq9fv15uiyvJwIEDGThwoOrxy5Yto1GjRixcuBCANm3acPjwYebNm8djjz1WQasUCAQCgUAgMCc9PZ3k5GRiY2MJDw8nKiqK4OBg9Ho94eHhxMbGKuNsWfO0oFnkyYKpKrB//34iIiLMtvXv358VK1aQn59frubc/Px8tm7dWkqdCwQCgUAgEDRs2JCoqChF0IWHh7N27VoiIyOJjY0lJCSEqKiock0i0yzyRo0aVW4Hr2iuXLlCvXr1zLbVq1ePgoICUlJSqF+/fql9cnNzyc3NVZ6npaUBRhGXn59v9Vivvvoqn332GQMGDOCFF14opzOo+sjXzNa1u9sQ18ScslwPcQ0F5cGnn37Khx9+yKVLl5gwYQJ9+vSp7CUJqinBwcFmQi80NBRAEXjlneGuWeSBsRbepk2bOHv2LDqdjrZt2/LII4/g7OxcrosrD0oGKcpJI9aCF2fPns2MGTNKbd+xYweenp5WjyMLxr1797Jly5Y7Nuizsti5c2dlL+GOQ1wTcxy5HllZWRWwEsHdxKlTp5g4cSKbNm3i3nvvxdPTk6ioqAo/riOJhAUFBUyfPp3169dz5coV6tevz3PPPcdbb72l1E5r0qQJFy9eLLXvuHHjFE9cixYtrI759NNPy3xuAtsEBwezdu1ang4NZTYwHli7dm2FlDDSLPIuXLjAoEGDSExMpFWrVkiSxF9//UVwcDCbN2+mWbNm5b5IRwkMDOTKlStm25KTk3FxcaF27doW95k2bRqTJk1SnstpyxERETYzzvr378+yZcu4cuUKbm5ummIHTSksLOSTTz7h7NmzLFq0CHd3d4fmuVPIz89n586d9OvXTwjfYsQ1Macs10O2tAsEjvLjjz/SpUsXHn74YeD2WYflRMLnn39edYz4nDlzWLZsGWvWrKFdu3YcPnyY559/Hl9fXyZMmADAoUOHzJoSnDp1in79+vHEE08o2/bt22dWUNfSGEHFob94kZ2PPMJpwBvIAyIjI+8MS9748eNp1qwZf/zxB/7+/gCkpqYycuRIxo8fz+bNm8t1gWWhR48e/PTTT2bbduzYQdeuXa1+mbi7u1sUVq6urja/gFxdXenWrRs//vgjcXFxDn95r1ixgilTpgAwePBghg0bpm0CgwHS08GST//SJfDxgXIK6NSCvet3NyKuiTmOXA9x/QRloVmzZkqwu06nY+TIkaxcufK2HFtrIiEY48yHDh2qCNImTZrw9ddfc/jwYWVM3bp1zfb54IMPaNasGWFhYRQUFChjTP92TMcItKOlLErSrl1ce/hh3i0OC0vr2JF116+XSsYoLzSXUImOjmbu3LmKwAOoXbs2H3zwAdHR0eW2MEtkZGQQExNDTEwMYCyREhMTQ0JCAmC0wj377LPK+LFjx3Lx4kUmTZrE2bNnWblyJStWrGDy5MkVsr4mTZoAKOtxBFM3waFDh7TtbDDAgAEQFgYlE0D0euP2AQOM4wQCgeAuZ//+/YSEhPDhhx+SlJTEkiVLVO87a9YsvL29bT5+//33cl1vr1692LVrF3/99RcAx48fZ8+ePQwaNMji+Ly8PNatW8cLL7xgNURJzRiBdVSXRbl2DcPkyfg/9BD35uaSodNx/f33qXnsGKv27SMkJEQRepcuXSq39Wm25Lm7u5Oenl5qe0ZGBm5ubuWyKGscPnyYBx54QHkuu1VHjRrF6tWrSUpKMhNYTZs2ZcuWLbz22mt8+umnBAUFsWjRogorn9KoUSMAi7EOajl9+rTy/4MHD2rbOT0dkpMhNhbCwyEqCoKDjQIvPNy4XR5XCdY8gUAguJPw9vYmPj6eXr16ERgYCKh3144dO5Ynn3zS5pgGDRqUeY2mTJ06FYPBQOvWrXF2dqawsJD333+fp59+2uL4TZs2cfPmTZ577jmrc6oZI7COmrIoHXNy8OjTB7c//wTgV09PWv/6K0H33w+YJ2MEBASUawcfzSJv8ODBjBkzhhUrVtCtWzcADhw4wNixY3nkkUfKbWGWCA8Pt9ltY/Xq1aW2hYWFcfTo0Qpc1S0aN24MOG7JKygo4Ny5c8pzzetu2NAo7GRBFx4Oa9dCZKTxeUiI8XXR41MgEAg4ceIEAB06dNC8r7+/v5lH63awYcMG1q1bx1dffUW7du2IiYlh4sSJBAUFWax8sWLFCgYOHEhQUJDVOdWMEVjHVlmUK7GxfO7ry+grV9Bdvgx16pA1ezYt+/cnqIRLNjg4mOjoaLsdL7Si2V27aNEimjVrRo8ePahRowY1atQgNDSU5s2b8/HHH5fbwqoisiXPUZH3999/m/2KvHnzJhkZGdomCQ42CrmQEN6KjaVvaCjXTQWeaEAuEAgEAMTExNC8eXO8vLwAY5zcjBkzmDJlCs2bN+fMmTNW960Md+2///1v3njjDZ566ik6dOhAZGQkr732GrNnzy419uLFi/zyyy+8+OKLVudTM0ZgH9kSJ7tcQ0NDaRIby1kXF140GNAVFcGIEXD2LJ4vvkhDK9/DDRs2LFeBBw5Y8vz8/Pjhhx84f/48f/75J5Ik0bZtW5o3b16uC6uKyCLv6tWr5OXlaXZfy+KwXbt2JCQkkJ6ezuXLl2nZsqW2hQQHc3PJEt4fMACAycDKtWuFwBMIBAITYmJiuOeee5Tnp06d4vHHH2fu3LnExMTw008/0bZtW4v7Voa7NisryywrFsDZ2ZmioqJSY1etWkVAQICSpGEJNWME6pDLojwcGso8YDRAQYHxe3fZMrASN1nROFQnD4x1dlq0aFGea6ny1KpVCycnJ4qKirh+/boS46GWq1evAsbSL7Lr1iGRp9ezzSQBZROwYuRIdNHR2oTeHZqpKxAIBOVBTEyMEmZkMBhwdXXl2WefZcuWLbi5ueHn52d137K6azMyMrhw4YLyXE4k9Pf3VwwGixcv5vvvv2fXrl0ADBkyhPfff59GjRrRrl07jh07xvz580sV4C8qKmLVqlWMGjUKFxfLX/NqxgjUo9frWffoo5wB5DYLX9asyYPbt9OwTZtKW5eqd3bSpEm89957eHl5mdWQs8T8+fPLZWFVEScnJ7y9vUlLSyMlJcVhkVevXj2KiooUkaeJ4iSL6ORkZdMNICUujrqmyRj2kDN1k5NL7yMncgQEwLZtQugJBIIqR1FRESdPnuTtt98GjFY8Oc4cjElwY8eOrbDj20skBEhJSeHvv/9WxnzyySe8/fbbjBs3juTkZIKCgvjnP//JO++8Yzb3L7/8QkJCgs3uS2rG3M1oKYuSePgwp8PCWFJcnD2rUSOeKyjg/y5fJmTw4Aqpf6cWVSLv2LFjSqzYsWPHKnRBVR0fHx/S0tJITU3VvK+pyJNT2TWJvEuXlKSLeA8PyM5WXjoXFERdORkjOtp+8oXI1BUIBNUYJycnMjMzleenTp0yS8A4deoU7du3r7Dj20skBJg+fTrTp09Xnvv4+LBw4UK7PeQjIiLszq1mzN2KXBYlOTm5lECTs2YDAgLYtnUrhV98gffUqQwoKiIfyHr1VXznzuWja9c4YpKMER0dXa49adWiSuTt3r3b4v8FpalZsyaJiYmkpKRo3tdU5Mnmc00iz8fHaF0DLjo5wYULivv43MSJ9Fq2zPi6mvTsEpm6mX364LluHbpnnxWZugKBoNpx+vRpHnroIcDYeSgzM9Omu1ZQfVFTFiU4Px/3IUOosWcPACfc3Qn44QcC+/cHKrYsihY0Z9e+8MILFuvkZWZmCrMvKG9kWS15ci/ckm3ZbOLrC9u2IUVFcbFYHEZERADwV0qK0YKnxb1anKn7TUAAdeLjebpXL3OBJxI5BAJBNWHRokVKfJ6zs7PNzFpB9UYui2JaoHjfvn2Eh4cTHxvL+/7+/HrtmlHgeXiQ/d57+P/5pyLwZOSyKNu2bSv3rFm1aBZ5a9asIdvEDSiTnZ3Nl19+WS6LqsrIIs8RS54s6OrVq6cE9F6/fl3bJL6+pHp4KI3bQ0NDAUhMTDRa3TR+0AqDgng6OZkcYAOQAcbae0LgCQQCgaCaYqksimdsLEfd3fnP9es45eTAAw/AyZN4vPUWDYs7XpWkIsqiaEG1yEtLS8NgMCBJEunp6aSlpSmPGzdusGXLFgKKXYV3M2Wx5CUXJ0sEBAQ4LvK41XEjMDBQKdAsWwm1cv6338ye/w7G4sol26bZw5rb+dIl0WZNIBAIBHccclkUN2AmcBS4JzfXaCz5/HPYtQuaNavkVdpGdd60n58fOp0OnU5nsaSHTqdjxowZ5bq4qkjNmjUBxyx5N27cAIy9gHNycsy2aUGO42vYsCH16tUDHBR5ej0xTz1ltmmPnx8DSyZj2CItzfjvwIGwfbvI0hUIBAJBlUCv17PgiSc4BsjVEnd4etJu504a3HdfZS5NNapF3u7du5EkiQcffJCNGzea1Qdyc3OjcePGoi0KjlvycnJyFGHn5+enuMQdseTJArNu3bqOi7ziTN0Yk1IsAHFhYXDy5K2sW3uZunLHjvh4kaUrEAgEgkpDS1mUS3/+ya/338+GtDScgDx/f15zcWFJcjIhTz1VqWVRtKBa5IWFhQHGgo3BwcGlqm4LjMjtcQwaXZA3b94EjBbRmjVrkpubCxgteUVFRZqutyzy6tSpo4i8lJQUCgsLcXZ2VjdJcabuX1euQFYWffr04bfffiNerpsnW+DsZQwFBUFMDDRpAmfPsq97d9quXInfuHEiS1cgEAgEtwXVZVG2bSPvxx/RvfACowoKAMh48km8ly7ljcxMtt0BZVG0oFmpNW7cGCcnJ7Kysvjzzz85ceKE2eNux9PTEzDGMGpBFnm+vr44OTlRq1YtACRJ0iwYTUVenTp10Ol0FBUVaXMhF2fqJha75nv16gVAfHy80RKnNVN3yxa2BwYSevky3QYMEP10BQKBQHDbKFkWRV8cV25aFiUvKQmX0aOp++yzNCgoQO/iQvK6dXhv2AD+/mbJGJVZFkULmkXetWvXGDx4MD4+PrRr147OnTubPe52ZJGnVZjJsXdyXSY3NzfFKqjVZWsq8lxcXKhTpw7ggMvW15fLxXPJWbpJSUlGK6PWTN0GDVjVrh0A54HPQXuWrsFgdCNbQiRwCAQCgcAKtsqixMbG8mpAAAczMvDauBF0OnLHjcPp9GkCRowwm+dOKIuiBc0ib+LEidy4cYM//vgDDw8Ptm3bxpo1a2jRogU//vhjRayxSuGoyJMtebIFD3A4w/batWsAiriTXbbJJeLr7FFYWEhSUhIAHTt2VESnnL2raa6EBH7+9Vfl+WHQlqUrt1kLCyu9j15v3D5ggBB6AoGgyjJy5EglwVF+DKqkxvbVEUtlUXJjY9np6cmi5GScU1OhXTvYvx/3Tz+lgZW+8ZVdFkULmkXer7/+yoIFC7jvvvtwcnKicePGjBw5krlz5zJ79uyKWGOVwtRdq6VlTElLHtwSeVozbE0TL0zncUQsFhYWotPpCAwMVGIPZOGnhYv9+5Npcj2OurjcSt5QI/RKtlmT9zFN4EhONo4TCASCKsgLL7xAcHAwI0aM4LvvvuP48eOsX7++Qo7122+/MWTIEIKCgtDpdGzatMnuPtOnTy8lQi31aE9MTGTkyJHUrl0bT09POnXqxJEjR5TX169fT3BwMP7+/vz73/822zc+Pp6WLVtqDnlSi1wWRQf8EzgDPJSVBa6uMGMGHD0K999fIceuDDSLvMzMTKUenr+/v2I16tChA0ePHi3f1VVBZJFXVFRk1hfRHpYsefL/HRV5siXP0XkSExOBW23W5Pddk0WwuJzLhWJRFlgsPGMLCrjRuPEt0WbNDSsjt1kLCbm1z759twSeSOAQCARVmLy8PJ599lmmTp3KunXrePTRR+nYsaPZd0J5kpmZyT333MPixYs17deuXTuSkpKUx8mTJ81ev3HjBqGhobi6urJ161bOnDnDRx99pBgwUlJSePHFF5k3bx7bt29nzZo1bN68Wdn/5Zdf5oMPPlDKkZU3er2et4cPZzewDKgJHHV3J2nLFnjnHXBzq5DjVhaqs2tlWrVqxblz52jSpAmdOnXis88+o0mTJixbtkxpxXU34+7ujrOzM4WFhRgMBry9vVXtZ8mSJwd1WmojZwtZ5NWuXRtwXOTJ9fbk0jiyZVCTyCs+/wu1asHVq3QPDeXAgQMkJSVxYfFi7pswQX0/3eI2a4SHsys2lq9CQ5kD1BEJHAKBoIoTExPD1atXeemll27L8QYOHMjAgQM17+fi4mLReiczZ84cgoODWbVqlbKtiUk3iNjYWHx9fRk+fDgADzzwAGfOnOHhhx/mq6++ws3NjWHDhqlej5ayKPrYWL6+7z42X79ODaCwRg3e9/JiRmoqTf75zypTFkULDsXkye66d999l23bttGoUSMWLVrErFmzyn2BVQ2dTqd8oLTE5Vmy5MkiT4vZuqioSJmrrCJPttLKMX2yJU/eroriX2Pni28mLVq0UP6I9Hl5DvXTPTVjBg8BK4EPQSRwCKocS5YsoWnTptSoUYMuXbrw+++/Wx373HPPlXKR6XQ62hUnMgGsXr3a4hi59qbgzsfPz4+CggJmzZqFXq+nqKjI5vhZs2bh7e1t82Hrc+Uo58+fJygoiKZNm/LUU08RK9c6LebHH3+ka9euPPHEEwQEBNC5c2c+//xz5fUWLVqQlZXFsWPHuH79OocOHaJjx45cv36dd955R5NlUS6LEhYWpmTLyuj1esLCwhgwYAAGg4GrW7diaNOGKcUCL7tPH5zPnuX5Y8doYpKMccmeV6mKoVnkjRgxgueeew6Azp07Ex8fz6FDh9Dr9Yoyv9uRzcyOiDzTYE5HLHnp6elKLKA8l6MiTy7oLItFh9y1xcQV79O8eXMaNWoEGP8INWfp6vX879VXlacrgYKRI0UCh6DKsGHDBiZOnMibb77JsWPH6N27NwMHDiQhIcHi+I8//tjMPabX6/H39+eJJ54wG1ezZk2zcUlJSdSoUeN2nJKgHGjZsiVLlizhgw8+oFGjRri4uPDXX39ZHT927FhiYmJsPrp27Vqua7z//vv58ssv2b59O59//jlXrlyhZ8+eZsX/Y2NjWbp0KS1atGD79u2MHTuW8ePHK73ta9WqxZo1a3j22Wfp1q0bzz77LP3792fy5Mm8+uqrxMXF0blzZ9q3b8///vc/m+spWRZFDjFKTExUsmYNV66g+89/CBgyhPZ5edx0ciJ1/nw8oqKgSZMqWRZFC5rdtSXx9PTk3nvvLY+1VBtkkafFAicLOdM4BEdEniws3d3dlRt8WWP7ZJHnkLu2GNn626BBg1uWPK39b4uTLA4UC2KAFOCvuDjaqm2zVjKBQ3TgENxm5s+fz+jRo3nxxRcBWLhwIdu3b2fp0qUWk9d8fX3Nfvxt2rSJGzdu8Pzzz5uNsxYEL6gafPjhh3z44YdMnjxZKczbokULq+P9/f3NOk/dDkzdux06dKBHjx40a9aMNWvWMGnSJMDoTeratavi2evcuTOnT59m6dKlPPvsswA8+uijPProo8pcUVFRnDx5ksWLF9O8eXO+/vprAgMD6datG3369FEMDCWRy6LIgm7QoEHMnj2bQYMGERsby1P16/OlTofrkiUA5D36KFlvv01QiXJvclkUU9dudUGVyJPfPDXMnz/f4cVUFxxx18qC0PRXhCz4tIg8SxbBslry5AQOh9y1xcg1+gIDAx0TecVt1qTYWA46OUFRkRL7eDoggLZq26zJCRyyoAsPN7p7IyNFAoegwsnLy+PIkSO88cYbZtsjIiLYt2+fqjlWrFjBQw89ROPGjc22Z2Rk0LhxYwoLC+nUqRPvvfeezdqlubm5SmcduHUPys/PJz8/3+p+8mu2xlRlKuP89u3bx5tvvsmRI0do3bq1sr2guOOCJT744APmzJljc96ffvpJKWQPts+toKBA8zm7ubnRvn17zp07p+xbv359WrdubTZXy5Yt2bhxo8X5c3Nzefnll1mzZg1nz56loKCAnj17AkbX7t69exk8eLDVNQQGBrJr1y4GDRqkfM9kJSXxjZ8fw4uNC1JQEIWLFqF75BHqWjl/OSzpTv1cO7ouVSLv2LFjqibT6XQOLaK6IQs1LSKvvCx5ssgrj1IsJd21jlryCgsLlT+++vXrOybyitusXS4o4HpCAs7Ozjz99NOsW7eO0888wxM//uhQAsfu2FjWhoYyDBjsSAKHwWC0+lkShZcuGddTzX4ZChxHbi8of6HI1KtXjytXrtjdPykpia1bt/LVV1+ZbW/dujWrV6+mQ4cOpKWl8fHHHxMaGsrx48etWoNmz57NjBkzSm3fsWOHUiXAFjt37rQ7pipzO89PLikSGxtbKsbNGk2bNmXevHk2x1y7do0tW7aU2m7p3I4cOYKrq6u6BReTn59PTEwMAQEBynEaN27MH3/8YXbcHTt24OPjY3Et69evp2XLliQlJREbG0t2drYyLjU1lYMHD6pq6ylbwQMPHuSsszMexd9f8RERnB41igIXF7Bw/KpCVlaWQ/upEnm7d+92aPK7FVmcaSmhIgs5U0ueI4kXsrA0FXmyJU9rnbySIk+26Glqj4bx3OR6e3Xr1qVBgwaAxnp7xW3W4n/9FYYNIzg4mE6dOrFu3TrOJCYaLXhaBFVwMNKXX/JSr178DawCUj/9FH+tAm/AAKP7t6Q4lN2/AQHaEksEdwUlfxBLkqTqR/Lq1avx8/PjH//4h9n27t270717d+V5aGgo9957L5988gmLFi2yONe0adPMvDRpaWkEBwcTERFhs3xFfn4+O3fupF+/fppFQVWgMs4vKSmJ7777jrNnzzJw4ECCgoLM7uHlhem55ebmcuHCBeW12rVrExQUhL+/vxI3vWTJEn744Qe2b98OwNSpU3n44YcJDg7m2rVrzJo1i7y8PGbOnKlYlgMCAujTpw8nTpzg8ccf59ChQ+zatYslS5aUKux8+vRpjh07xqFDh/Dy8iI7O5v333+fq1evUq9ePZKSkvjnP/+pfGdYIzExkZEREUy6eJH78/IAuOjqivuXX9LgscewvXfVwNG6gQ7H5F24cIG///6bPn364OHhofomVVaWLFnChx9+SFJSEu3atWPhwoX07t3b4tioqCgeeOCBUtvPnj1rZhIvb+TOEBkZGar3kd/A8rLklae7tmSWrsFg0PR+y2uqU6cOrq6uikVQs9vX15f44l8zTZo0oU2bNgDG4GSt7lW9niPDh/O3yabto0bx9OHD6i15Ir5PoJE6derg7OxcymqXnJxcyrpXEkmSWLlyJZGRkbjZqeXl5OTEfffdx/nz562OcXd3x93dvdR2V1dXVeJG7biqyu08vzFjxpCamsqXX37J9OnTyc3N5dlnn2XNmjUVcjxXV1cOHjxo9v0oFyUeNWoUq1evBozfGbGxscp1uHz5MpGRkaSkpFC3bl26d+/OH3/8QfPmzZV5evTowffff8+0adN4//33adq0KQsXLmTUqFFma5AkiVdeeYUFCxYogtbV1ZXVq1fz8ssvk5uby+LFi83Kr4CFsigJCSzu1o0frl2jNlDk5MTKWrV4NTWVoDffJCo0tFqURXH0s6g5uzY1NZW+ffvSsmVLBg0apFhjXnzxRV5//XWHFqEWrVlpMufOnTPLOLMVzFoeyLXxtIg8W5Y8RxIvTH8Fyn8Mppm3aigp8uQ58/Pzyc7OVj2PLC7lOopybF9mZqZmE3R8fDxgFHnyH66cUaWaYhG2s8R+W5OT1XfgAFGgWaAZNzc3unTpUspdtnPnTiUOyRrR0dFcuHCB0aNH2z2OJEnExMSI2qVVBCcnJ958803OnDlDTk4OP/zwA19++SWFhYUVdszw8HAkSSr1kAUeGDtcyPdcgG+++YbLly+Tl5dHYmIiGzdupG3btqXmHjx4MCdPniQnJ4ezZ89arP2n0+ksxtv17t2bhg0b4uPjQ//+/c1eK1kWJemPP4hr3Zp5xQIvr00bfps7l4cOHyaoGpdF0YJmkffaa6/h6upKQkKCWdzG8OHD2bZtW7kuriSmWWlt2rRh4cKFBAcHs3TpUpv7BQQEEBgYqDycnZ0rdJ2yJU+Lu9aSJa8siReWiioXFRWpFlWSJJVKvPDy8lKu3U2TDFd7yCJPzvzz8fFRLBFarXmmIk8ufpmSkqJedBYncBAby+liMS4HJh93c1PfgUOmOL6vsGlTpsXGMi80FMlU4In6fYISTJo0iS+++IKVK1dy9uxZXnvtNRISEhg7dixgdKPKWYimrFixgvvvv5/27duXem3GjBls376d2NhYYmJiGD16NDExMcqcgqpDZmYme/bsoUuXLhX+XXUnUrIsihy7rdfrlSzalKtXkT7+mMCHHqJPdja5Oh03p0xBd/gwhubNadCgQbUui6IFzSJvx44dzJkzp1R16RYtWjjUuF4tclZaRESE2XY1WWmdO3emfv369O3b97bEF2q15OXl5ZFXHEdQXjF5pu5aT09PJXBV7VyZmZlKZpfspjUt9KxF5MnHlN20cmwelE3k+fn5KT80VFvzihM4CAnhdHEMyWOPPQbAXzodhU2bqk/gkAkOZsUTT/AB8G9gNThWoFnU77srGD58OAsXLmTmzJl06tSJ3377jS1btigxTUlJSaW8EwaDgY0bN1q14t28eZMxY8bQpk0bIiIiSExM5LfffqNbt24Vfj6C8mX9+vXs2bOHdevWVfZSKgW5LEqIiSVu3759isCLaNiQU7Vq4ffuu+gyMyno0YMbu3fjN2eOsf9sMXJZlG3btlW7siha0ByTl5mZaTHzKiUlxWJ8R3nhSFZa/fr1Wb58OV26dCE3N5e1a9fSt29foqKi6NOnj8V9HC0rII8B8PDwUPZVk/ZsmhBRo0YNZR+5zl16errq9Gl5Lh8fH7N9fHx8MBgMpKamKpY5W8jiy8XFBVdXV2UuPz8/rl+/TkpKiqo15efnK5bIWrVqKfvUrVuXxMRELl++rCk1XG61Vq9ePQoKCmjQoAHnz58nPj6+VEkJi3h6ws8/U2gw8Gdxx4B+/frh7u5OTm4uf3/5JU3btDGOU7uuxEQWLlyoPF3u5MTIF180ZnJZCBi2WMbg5k2jgEtKgv79b+2bmAiDBhm3u7sbx6nIfKxKlKVkxZ1a7sAe48aNY9y4cRZfM3WXyfj6+tq0wi9YsIAFCxaU1/IElciYMWMYM2ZMZS+jUpELFMvCLjQ0FFdgfq1aTExORidXLpg7F5cxYwi0kn1rqdXZ3YZmkdenTx++/PJL3nvvPcBolSkqKuLDDz+0mORQ3mjJSmvVqhWtWrVSnvfo0QO9Xs+8efOsiryylhUAiIuLA4xWJ0sp4yWRy4u4ubmxY8cOZbssMLOzs/npp59Ume7PnTsHGE3bpseWgza3b9/O33//bXFfU2RLgqenJ1u3bi31+s6dO1UncsgiLyUlpdT12LVrl6Y4Qdl0/9dff5Gbm6sI6s2bN2tyj1+9epWcnBxcXV05d+4cgYGBXLx4kbXbt9PVpHq7GtLT0zlbbIkFOKTTsfGdd/A4fhyOH7e6X6kyBsUlACRJImPPnltWXdMCuTExxkc1xJGSFY6WFRAIBHc2wcHBrF27ltDQUO4DVgAd5O+cwYNhyRLRr1wFmkXehx9+SHh4OIcPHyYvL48pU6Zw+vRprl+/zt69eytijUDZstJM6d69u00zuKNlBeBWevr999/PJ598goeHR6mUcUucOHECMFrJTMebWhR79+6tKqV+2bJlgPE8TeeqW7cuKSkpdOjQQZUYl13gdevWNZvn448/JjY2Vkm8sUd+fr5SsNN0Td9++60SGK5mHnkuWTA+/vjj1K1bl//973+cOHGCOnXqqJ4HjEHsYKzpNGTIENatW8fFixepVauW+nkuX4aBA9lWLJqbN2lCviRx8eJFak6ZQr+UFGjSBLZuhaAgs/OwVqKhMCGBZ++9l/9LS2OmiwtvuLoa57BiFTQjLQ2GDYNr10qPly2CdevCd98pPYXvBMpSssLRsgL2KCgoYPfu3WzdupXY2FiSk5Px8PCgXr16dOvWjcGDB5tlFAoEgvJFr9czZsQIPgImAM5AqpMT0qJF1Bk3DkRdXlVoFnlt27blxIkTLF26FGdnZzIzMxk2bBivvPJKhWZymWalmbZD2blzJ0OHDlU9z7Fjx2yus6xlBeBWPFxWVpaqfeSkgZo1a5qNd3V1xc3Njby8PMXqZA/ZmuXr62s2Xl5Tdna2qnnkeEI/Pz+z8XJ8XkZGhurrIc8VEBCg7CNn2N64cUP1PHIRZmdnZwIDA3FyclLey9TUVE0CQc4Kb9SoEa6urkqaflJSkvp5/PzA15ejXl6Ql0eP3r3Jycnh4sWLnB01ikFffWUsneLnZxYrImPpM/XLX3/xf8XCZVZBAWMKCqj3xRdGoWeP7GxjgkZsLPTta17SpW9f4/bcXOO44ozpOwlHSlZURImLlStX8vvvv9O6dWsiIiIICAigZs2a5Ofnk5aWxoULF1iyZAl5eXmMGzfOYnahQCBwHL1ez3+6dePHK1cIKd72vbc3L2Vk4Dt/PlGPPFItyqLcDjSJvPz8fCIiIvjss88sujQrmkmTJhEZGUnXrl3p0aMHy5cvL5WVlpiYqDRCXrhwIU2aNKFdu3bk5eWxbt06Nm7cyMaNGyt0nVoTL2TrlLyfKT4+PqSmpqq2WFgqxWL6XO08lhI44FbWrpbEC3lNtU2EhSO1+2S3dkBAgJJIIotFrV04ZLevfKOQYzc0pdoXF2g+//zz8P33tGvXTnnPz129qr1AM/DD+vXK/3OALcDzkZHqMnUttGxLX7YM73/+E11cnPaSLndZN4+srCz+7//+j759+/LCCy9YHXf//fczYsQIJEni559/5vr162atowQCQWkMBgPp6ekW4+RMa98lnjrFHz16sLb4XloQFITLF1/QtX17fItj9MLDw4mOjhYxdyrQJPJcXV05depUpbUvGz58OKmpqcycOZOkpCTat29vMystLy+PyZMnk5iYiIeHB+3atWPz5s2a3HqOoLUYsmx9syXy1JZRkY9Zci6t5VgslWIxfV4ZIk921Zu658sq8uTK7g61WgPw9eV8cWZvixYtlBixc+fOOVSgefuGDQB0dHPjRF4e+3x8eL5ksWVbmLRsWx4byz8jImgB7GvcmDpaSrrchd08PD09SxVstYVOp2PIkCEVuCKBoHpgMBgYMGAAycnJREVFmVnh5NIoAQEB/PLyy9T/9795IiODIiDzuefwWbQIfHwIBiUZ424vi6IFzSVUnn32WVasWFERa1HFuHHjiI+PJzc3lyNHjpglUKxevZqoqCjl+ZQpU7hw4QLZ2dlcv36d33//vcIFHmgXedaEGWgviGxtrvKy5DlSQsWWyNMyj2zJMxV58v+1ijz5x0CZLHnFyK2BmjdvriT6yAkwqrl0CUOfPsQXl62ZVJxssb9+ffNiy2rWFxxMzhdf8G7x0/PAyocf1hakXLKbhyx+Tbt5JCcbx6nBVg3A4oxpgUBQPbFX+y4rNpbpJ07gNWoUTsnJFLZsScp33+GzapVZOStRFkU7mmPy8vLy+OKLL9i5cyddu3ZVBI3M/Pnzy21xVRVTd62a9l+yJa/ktQTtIs+au7ayLHlZWVlKDUB/f39luyOWPFnIydY70/9rFXmymJPFnWn3jKKiIlUNscFYskYuW9OsWTOltuDVq1dJT09X/2vTx4eTxdnbDevXZ8CIEfD665w5f57sc+fwGDBAff0+vZ5fn3kG0xSlNZ9/zpQ33lAv9Eq4fmN69ODShAk8vHSpdtevPavgwIHGDOK0tEqNFWzatKlDXoqJEycyfvz4CliRQFA9kGvfhZu4W9euXUvkyJE8EBfHfCcnamZlgYsLvPEGzm++SUBxCTFLcwnUo1nknTp1invvvRco7hlqQmW5ce80ZJEnSRI5OTlKmQ9r2BJ5sjhTY4ErKiqy6vrVasmz1AMXbok8g8qivLKIc3Z2NhM8joi8lJQU4FZRZbgl8q5du6ZJnMmuXzlxo379+jg5OVFQUEBycrLSncMecrmcwMBA5f3z9fXFYDCg1+vVB+X7+nJy9Gh4/XU6du5MQEAAfn5+3Lx5kws5OXRQG99XbGnbW3x+/+jTh02//caZ/HxSe/em9u+/qxd6xa7ffd2780BiInlTpvABMFVrNw97PX6Lk2DIyKhUkWepPp0aSvbWFAgEpSlZ+y4yNJTlQF+AoiLo2hVWrICOHSt5pdULTSKvsLCQ6dOn06FDBzOrjMAc03p6GRkZdkVeeblrTWuGldWSZ6kHrulztZY8U7ev6Y8AR0ReyV66cEvwFRQUcPPmTVWfy8LCQkUwyu5eZ2dn6tSpQ3JysiaRJ1sE5dg++f8nT57UJvKA07GxALRv3x6dTkerVq04cOAA586do8Pjj6tZjGJ521ujBuTk8HBkJGcuXeKv2FgOXbzIgPBwY0KI2l/DwcH8t1Ej8opdqu8DE1eswF2L69dCQghr10JkpPF5mzbGcSZlZiqDsLCwSj2+QFDdCQ4OZu2qVWwMC+M9wBModHfH+f33YcIEoyVPUK5oislzdnamf//+qq04dyvOzs6K0FMTl1de7lp5jJOTk9Ito+Q8tzu7Vj6erXmKiopUzWVJ5Lm5uSlzq3XZpqSkUFRUZNZeDRxz/coir4FJTTrZ9VuyNZU9ZKtgs2bNAGjZsiVQ2mJuleKWbUVNm3K42KLZo0cPuhU3vj9Qq5bmlm1pZ86w648/lOfpwC9PP1269Zo9iq2C/wsIYGRsLD+EhhoFXkiIsabfHc6qVasqewkCQZXnyo4deEdE8BFGgbcLeCggAP2TTwqBV0FoTrzo0KEDscUWB4F1tCRflJfIM7UIlnSda7XkyeKsZAFoRy15JeeRLXmSJKlekyWRZ/rctD2cLeQEjtq1a+NicmNxROTJPXNN40Rkq57WTF1Z5DVt2hRAexJHcUmXxG++ITMrCxcXF1q2bKmEV5zs0UNbNqxeT9SDD5IHNHdx4ZVhwwDYeuWKeTKGSuILC3ny2jXWAyPBGDO4dq39Is93AN99951Z3+vs7GxGjBhRiSsSCKoQubkYJkygdv/+dMzNJc3JiQtvvMGYpk2JKk6+0FzZQKAKzSLv/fffZ/Lkyfz8888kJSWRlpZm9hAY0VIrz14JFdAm8iwF+2u15FlL4CiLu9aUGjVqKNZGtS5bWeSV7L0ru2hTVbYjs5SlC7dcv3LfXjXYsuRpuWlJkkR8fDxwS+TJ/2qyCPr6cq74PW7WrBmurq60bt0agHMJCeoFXrHr90jxter16KP0fOwxAI64u2vL9i1m4XvvKS3sMoAlYHTZFgvlO5l169bx5ptv8ueff3L+/Hl69+5NeHh4ZS9LIKhUDAaD1YoEly5dMt7/9+4lv317fBctwhXY5ulJ+oEDNJ89m6joaEJCQpRkDEeqGwhso9k+OmDAAAAeeeQRM2uRnEVaWFhYfqurwsiCTU0/VVmclTXxwlZRZa2WPHsiLzc3l5ycnFJu4ZJYswiC0ZqXlJTEjRs3VAWvy3F05WXJKynyyuKuNbXkOSLyrl69SnZ2NjqdTrEEOlrW5c8//wRQxJ3s9j1//rz65JRi1+/RK1cgK4t7e/emS5cuABzX6Sho2hQXLa5fvZ7NxUXKH/X05PusLLa5uzMzNtbYbs20P+8dxKRJk+jUqROdOnVi5cqVPPPMM0iSxMqVK+ncuXNlL08gqDTs1b57uE8f3s7O5vHkZFwliVRXV96uVYtphw/ToHisaTKGqH1XMWgWeaYuC4F1HLHklae71to8ai158riSf3SyK1iSJG7evGk3QcGaJQ/MRZ49ioqKFBFXUuTJlrzKEHmyu9bUkidfE/k4apCteA0bNsTNzU35PxhFnppSPDKyyJPdvU2aNMHV1ZXc3FwSEhLUZYMWu36PtmplFHn33kuLFi3w8fEhPT2ds599Rodu3dRZBi9d4lKvXlwoKMAJmL15M98/8ACH8/JIadwY3+Jz5/JlKC5sfqcQFhbGiRMn+Omnn/jzzz+5fPky3bt3Z8eOHVy+fJmHH364spcoEFQKJWvfyUJPr9fzbrdu/HzlCko62gsv4PLOO/zH2blUCRS59p3c8UJQvmgWeSIDTR3l7a5VM48td60WiyBYt+Q5OTnh6+vLzZs3MRgMZRJ5slVQjcgzGAxKgkZZRZ6lenumz7WIPFnImV4HR0ReyQ4ccEs45uTkcP369VLnbQ05tq9FixaAMRGoefPmnD17lr/++kt1yY+bksTl4nPo0KEDTk5OtG/fnv3793P2xg06qL0h+/jwW7FwvbdjR1qFh9OmTRvOnj3LwRkz6DdnjnGchc9/ZVBYWMimTZuIiIhg6NChZr2xs7OzOXXqFCdOnOCXX34RIk9w12Kp9t3Xn3zC5eHDWSm3JAsOxmXlSnjoIXwBa3cMUfuu4tAckwfGeKyPPvqIF198kZdeeokFCxaIjNsSaEm8sOWu1SIW7fXAleexl82am5tLfn4+YNnNqiUuz567Vu08soDz8vLC3d3d7DWtMXnWEjjkmDy1Ii8vL0/53Jtm6coWwpSUFKU4sj0sWQTd3d0V4anFZStbBRubWMXk+L6LFy+qnuf8+fOAUbTK759DHT18fTleLIa6Ffd4lZNBjur1sHWrcZyFz0hl4OzszMiRIy3GZnp4eHDfffcxevRoFixYUAmrEwjuHGR3a0jTpnSLjaXpww/zj4wMCoH0l17C5exZeOihyl7mXY1mkXf48GGaNWvGggULuH79OikpKcyfP59mzZpx9OjRilhjlaS83LVa5rHlrpW/pCVJshsnaOoatjSXFpFnz10L6ix58hh5H1O0xuRZc/uaFlZWgzzO2dnZbF21a9fG2dkZSZJUz2VJ5IH2uDxJkhQhZ2qxcyTjVy7dIsf0gYMiDzhRPL5jcaFTWeQdO3as0uvjWaJbt26KRVQgEFgnGDgUFMTXQF3gJHD688/xWb4cLHynCW4vmkXea6+9xiOPPEJ8fDzfffcd33//PXFxcQwePJiJEydWwBKrJloSL2y5ax0ReZbctR4eHkrAvb34Ptn65uHhYVZiREaL69daUWUoP5Gn1V1rzZKn1V0rC7g6deqYJTM4Ozsrlj25s4Y9ykvkpaamKp8n00BoR2r3yZY82e0LZRB5J04At0SenLQQExOjaZ7bxfjx4/nPf/4jyjoIBNYoKoKlSylq2xb/vXvJA94GugCPzp4t/nbuEByy5E2dOtXsy9/FxYUpU6Zw+PDhcl1cVcYRcWbJkqfF7WvLXavT6VSLM2vxeDKyVU6Ni95anTzQJvKs9dKF8hd56enpZGdn251HFnmmrloZrXF59kSe2hum7KqtX7++WeazI5Y8SyJPc4FmjO/v5eKOGe3btwduZf7Gx8crvY3vJJ544gkOHTpEu3btGDlyJF988QVHjhy5I9cqENx2/vrLWEJp3DicMjLYBwxp2JCBe/cSbFISRQi9ykezyKtZs6ZFa4BerxfpzyaoFXmm7tOKdNeC+kxd+XVLwsx0uxZLnq3ECzVuXzWWvLLG5NWsWRNXV1dAncvWWgIH3IrLU2vJs1RvD7Rb8uS/zcYlslQdKesiu33leD645QJOS0tTXStRFoRBQUHKZzAwMBBvb2+KioruyOLqcXFxfP/990yePJmsrCxmz55Nt27d8Pb2VqyRAkF1xGbtu7g4cqZPN/aX/f13MnU6XgVGNW3KF/v20bNnT2OMnqh9d8egObt2+PDhjB49mnnz5tGzZ090Oh179uzh3//+N08//XRFrLFKotYCl5OToxSIteWuzcnJoaCgwKL7VMaWuxbUizN7ljwtIs9aWzNwzJJX1pg8SZKsijydTkdAQACJiYkkJyebZbpawpYlTxZ5aix5kiSRlJQEGIWQKVpFnmwxKykWTUWe2nIssiA0dft6eXlRu3ZtUlNTuXjxokXLakksWQR1Oh3NmzcnJiaGCxcuqKvddxtp3LgxjRs3NsusTU9PJyYmRnE9CwTVDVu1765s2YLh0UdpWGzNzu/bl5HXr3PCYDAbK2rf3VloFnnz5s1Dp9Px7LPPKpmDrq6uvPzyy3zwwQflvsCqitqYPFMRKPe7tTSPPJetOkK23LWgvlbeneiulcfYctempaWRn5+vWOMskZGRoWQOWypJIos8NZY8eYwlS57srlVjyTN1D5csSSPfOLWKvJJisUGDBuh0OnJyckhJSbEoTE0pLCxU5jK90YPRmieLvHvuucfummSRZ5rAAUbRJ4u8kq/difj4+NC7d2969+5d2UsRCCoEi7Xv6tQhbdIk6ixbRiBww8kJaf58/MePZ3VaGunp6aL23R2M5p/Pbm5ufPzxx9y4cYOYmBiOHTvG9evXWbBgQanSFnczat2ssgisUaMGzs7OpV53d3dXtqsVjPZEnr01WSuELKPWkidJUrlZ8my5a02Fnz0XomzFc3d3tyiqtSRfyGPKasmTx3h5eZVy2ZcsiGwPayLP3d1dWZOa5IurV69SUFCAs7Mz9evXN3tNdgWrLcdiyZJn+vzChQuq5hEIBBWLXPtOdrdOuf9+slu1ouayZbgAP3t5kXX4MP4TJoBOh6+vr9Uadw0bNhQC7w5AsyXPYDBQWFiIv78/HTp0ULZfv34dFxcXq3Fcdxvyl7W9+DdbmbVgdGt5e3tjMBjsijN77trbHZOXmZmptLkrL3etJUuei4sLvr6+GAwGUlNTbVqpTF21llyW8r5qxJmaxAs1ljxLBZVlZLdrZmYmBoPBrntUFnklhRkYky+uXLmCXq9XWpRZQ3bV1q9fv9SPD60i7++//waMvXRNudNEXtOmTVV3FTFl4sSJjB8/vgJWJBDcfoKDg4n+8Ud+69GDZ4rDSC4BM+rV451Dh5SWZIKqgWaR99RTTzFkyBDGjRtntv3bb7/lxx9/ZMuWLeW2uKqMVnetpaQL07nUiDy17lq1Is+eJc+eu1Z+3cnJyaLVTBYsBoPBbpyYLUseGEWbwWCwG5dnLR5PRhZsapI4bLlrHbHklWyzBsYyNrKATUpKsivyrMX2gfHmffDgQVWWPEvxeDJaRZ6lun1w54m81atXO7Sf2g4iAkGV4KefaDh2LM8Ufw8sA6YCW7/7zuL9QHBno9lde+DAAR544IFS28PDwzlw4EC5LKo6IIs2eyLPVmatjFrXb3ln19qLybNnyZNFnpeXl0UBJ8+Tl5dHTk6OzblsWfJAfRkV+XV5fElk8ZeSkmJzHrDtrnXEkmdJ5MEtq5ws4GxhzV0L2sqo2BJ5sqiRy7XYIjs7Wzk/ayJPr9ffEaVJwsLC2L59Ox4eHoSFhal+lMxkVsOSJUto2rQpNWrUoEuXLvz+++9Wx0ZFRaHT6Uo95B7FMhs3bqRt27a4u7vTtm1bvv/+e83rEtzFXL0Kw4fDI4/A5cvEuboSBrwMpAGRkZGiJEoVRLPIy83NtdiqKT8/X1VtsbsFrSLPmjAzfU2tJc+aOFM7T3nF5Mkiz5IVT16PnFVpzypoz5KnVuTZs+TVqVMHUCfy1GTXXr9+XUn0sIYsBO2JPHuCUe5xC9YteaAuJk9O9CirJU8+lre3d6n3rm7dutSsWdMsu7iySUpKYvDgwdSvX58xY8awefNmcnNzy/UYGzZsYOLEibz55pscO3aM3r17M3DgQLvvy7lz50hKSlIepjGO+/fvZ/jw4URGRnL8+HEiIyN58sknxQ9vgX0kCb78Etq2hW+/RXJ2ZpmvL23z87kUEsLevXvNSqIIoVe10Czy7rvvPpYvX15q+7Jly+zG+dxNlLe71nSsvbnulDp59kSek5OTYs2zlzBhz5InizZ7bla1Is/ePKZ9ay25a/39/ZVyN/ZctuVlyZNfr1GjhsXrJAdIy9Y+W8g3cktB1bLIu3btGllZWTbnkYVg48aNS1lz5TIqoL5odEWzatUqrl69yrfffoufnx+vv/46derUYdiwYaxevVqV+LfH/PnzGT16NC+++CJt2rRh4cKFBAcHs3TpUpv7BQQEEBgYqDxMYyUXLlxIv379mDZtGq1bt2batGn07duXhQsXlnm9gmrMxYswcCCMGgXXr5PXrh1DAwN52WAgKCSEqKgoUfuuiqNZ5L3//vt88cUX9OnThxkzZjBjxgz69OnDypUrmTVrVkWssUpiasmzlRVZXu7agoICxeVZXokXZS2hYk/kgbqCyJIkqbbklZfIs/dlbtq31pKgcnJyUix89jJ1y0vkmbpqLbnHZeue3F3DFrbctX5+fspnw571yVTkWUIutHyniDwwis/evXszd+5c/vzzTw4ePEj37t35/PPPadCgAX369GHevHmqrmNJ8vLyOHLkCBEREWbbIyIi2Ldvn819O3fuTP369enbty+7d+82e23//v2l5uzfv7/dOQXVH4vFjQsLYdEiitq2he3bwd0dZs8mOyqKa8HBhBQLvJK170JCQkTtuyqG5sSL0NBQ9u/fz4cffsi3336Lh4cHHTt2ZMWKFaVKJNzNyKJNkiSys7OtCp3ycteavna7Ei8yMjIoLCy0WPoFzGPyrKHGkpeZmamECNgTefYyde2JPLUxedb61poSEBBAUlKSapFnKbsWHBN5lpAzdS9fvmw30cWWyNPpdDRu3JhTp05x8eJFpUWZJdSKPLX9giuDNm3a0KZNG6ZMmUJycjI//fQTP/74IwCTJ0/WNFdKSgqFhYWlBH29evWsuuPr16/P8uXL6dKlC7m5uaxdu5a+ffsSFRVFnz59AKMrX8ucYAy9MXVFy5b5/Px8myEG8mv2whCqKtXp/NLS0hg2bBjXrl1jy5YtRoGm1+MUFgYHD+IEHK9Zk0bbt+PdpQuewM8//0xGRgaBgYFm1yAwMJBff/0Vb29vPD0978jrU53eu5I4ek6aRR5Ap06dWL9+vUMHLCtLlizhww8/JCkpiXbt2rFw4UKbxUmjo6OZNGkSp0+fJigoiClTpjB27NgKX6epqMvMzLQq8srLXSu/5urqipubm8PzgPqYPHkua7WQtFjybFkFZQHo4uJida7yjsm7fv26TQFrK7NWRv7SvV2WPPl1S+VT4Jb4y83NJTU1VTnXkhQUFChzWcumk0WePUuenJxhLQNV3n4nWfJsERAQwOjRoxk9enSZ5ikpsG2J7latWtGqVSvleY8ePdDr9cybN08ReVrnBJg9ezYzZswotX3Hjh02/2Zldu7caXdMVaa6nN+kSZMAOHH4MC2++46w//s/nAsKyPfw4MyoUcRHRBB/9SqUqIwRExNTCastH6rLe2eKvdAYazgk8ioLOWB5yZIlhIaG8tlnnzFw4EDOnDljsQVVXFwcgwYN4qWXXmLdunXs3buXcePGUbduXR577LEKXauzszMeHh5kZ2eTmZlptXZbeblr7dXIM32trDF57u7uuLu7k5ubi8FgKBeRZ8uSZ+qqtfalVV4iT94uu4itCSFbmbUyagorS5JkV+TJFr6yWvLc3NyoW7cu165dIzEx0eq5JSUlUVRUhIuLi1URK/+9lZe79k625N28eZPt27eTmJiITqejfv369O/f36pV2RZ16tTB2dm5lIUtOTnZ6vtvie7du7Nu3TrleWBgoOY5p02bpggAMP64Cw4OJiIiwma90/z8fHbu3Em/fv1sdpepqlS380tMTGTqAw/w9sWLtCkOHYquWZMX8/JwjY5my9SppdogVlWq23tnipo2opaoUiLPNGAZjMHG27dvZ+nSpcyePbvU+GXLltGoUSMl+LhNmzYcPnyYefPmVbjIA6Nwy87OtinO1Ig8NX1w7dXIg/Jz14JRAF67ds3mB6+83LX2ki6g/ESeq6urWWFla0LIVmatjCyQbFmpMjIylF9o5RmTZ42goCCuXbvG5cuXrbYkk121DRo0sGrJLG+Rd/XqVVUdPW43K1asYM6cOTz88MPKF+Eff/zBu+++y5QpUzRb9Nzc3OjSpQs7d+7k0UcfVbbv3LnTrE+uPY4dO2Zmse3Rowc7d+7ktddeU7bt2LGDnj17Wp1D/rFWEldXV1VfkGrHVVWqxfllZtJk0SK+SUhAJ0lcAy6+/joDP/2U+kFBbN++vVrWvqsW710JHD2fKiPy5IDlN954w2y7rYBla8HIK1assNrj1NE4FXmM6b9eXl6kpKRgMBis7ivP7+HhYXWMh4eHMtbaGFkIeXl5WR1To0YNwCjibJ2LLPJq1KhhdZws8myVCJEtcLbiN2SLQWpqqtUxsqDy8/OzOkYWi/ZKlsgisGbNmlbHyYWVr1y5QkhIiMUxstWkTp06NueRx5qOMf2cyAHRnp6euLu7W5xLFpoGg4G0tDTl81ASOREgICDA6pqCgoI4fvw4CQkJVsfExcUBxsxaW/OAUcRZG5Ofn6+sKSgoyOI4WThlZ2drtmbJx6hI5s6dy9GjR0v9eHrvvffo0qWLQ27bSZMmERkZSdeuXenRowfLly8nISFBCSOZNm0aiYmJfPnll4Dxx2yTJk1o164deXl5rFu3jo0bN7Jx40ZlzgkTJtCnTx/mzJnD0KFD+eGHH/jll1/Ys2dPGc5eUKX55RcYMwbi4tAByf370yU6msW9e8OSJaxdu7ZaCjyBOVVG5DkSsGwtGLmgoICUlBSLsUtljVOBW/EAsmXi119/tRrIL1f7v3jxotVuIbI15Pz581bHHDx4EDA2lrc2RrYoGQwGq2MKCwsVy9KBAwdKFVyVkc/tl19+sZrsIPcs9fT0tBojIbvpTp48aXVNv/32G2D8Qrc2RhYTV69etXlushg+evQosbGxFsfJ1qvt27dbtTAePXoUMIpGa8eTP5dnzpyxOGbnzp2cPXsWMFpNrc0jSRJubm7k5eXxzTffWBVCf/31F2C0xFmbS05giYqKspro8csvvwDGDGF71/vPP/+0+XkrKirC1dWVI0eOWE1Q8fPz4+bNm2zYsEEpqaIWR+NU1KLT6cjIyCgl8jIyMhxqgQYwfPhwUlNTmTlzJklJSbRv354tW7Yo1s6kpCQzC2leXh6TJ08mMTERDw8P2rVrx+bNmxk0aJAypmfPnnzzzTe89dZbvP322zRr1owNGzZw//33O7RGQRXmxg14/XVYtcr4PDiYa//9Lz1mzCDV5DMbGRlplkErqKZIVYTExEQJkPbt22e2/b///a/UqlUri/u0aNFCmjVrltm2PXv2SICUlJRkcZ+cnBzJYDAoD71eLwFSSkqKlJeXZ/ORmZkpbdq0ScrMzJTy8vKk++67TwKkjRs3Wt1n0KBBEiAtW7bM6pjPP/9cAqQBAwZYHbNmzRoJkB588EGrYy5fviwBEiBlZWVZHJOcnKyMSU9PtzpXWFiYBEjr1q2zOqZPnz4SIE2ePFm5JiUf8+bNkwBp+PDhVuf56KOPJEB64oknrI6RPx+AlJ2dbXeMtfPPy8uTBg4cKAHSZ599ZnXMkCFDJEBavHix1TE//PCDBEidOnWy+jnZsGGDBEjdu3e3+dlq2rSpBEjR0dFWx/j5+UmAdOLECatj3n77bQmQRo8ebXXMq6++KgHSpEmTrI65cOGCBEiurq5STk6OxTE7d+6UAKl58+Y2z61bt252P0vWHikpKRIgGQyG8rnRlOCnn36SWrZsKQ0bNkx69dVXpVdffVV69NFHpZYtW0o//fRThRyzsjAYDKquZV5enrRp0yYpLy/vNq3s9lKlz+9//5OkevUkCSRJp5Okf/1L0p85I4WEhEiA1KZNG2nTpk1SmzZtJEAKCQmREhISKnvV5UaVfu/soPbvsySqLHnDhg1TLRq/++471WO14EjAsrVgZBcXF6sxWWWNUzEdK//6z83NtbqvbInw9fW1OkZ2RWZmZlodY1ojz9oY01Zeubm5Ft1+8jym67e1pqysLKvHk13Rnp6eVq+fvKa0tDSr88ju49q1a1sdY5ogkJGRYTGWTl6Pr6+vVZcn3Iqzu3nzptXjyZbZ+vXrWx0juzSvXbtmcYyrq6sSIxgYGGjz81W/fn3i4uKszpWVlaVYHRs1amR1LjmWLikpyeoY2UrXpEkTq2MaN26Mk5MT+fn5XL9+3aJVXHZF25oHjHF5Bw8e5NKlS5rjTioi7qawsJBNmzYRERHB4MGDGThwIAcPHlRKzzRo0IBu3bpZjVcUCCoag8FAenr6rWLlSUnwyitQ3MqusGVLnFeu5FLjxoSFhREbG0tISAhbtmzh+PHjbNmyhb59+yrFjaOjoy0WPhdUfVQVQ/b19VUeNWvWZNeuXRw+fFh5/ciRI+zatctqlmV5YBqwbMrOnTutBhfLwcim7Nixg65du96WoEw1rc20ZNfamkdNdq2bm5vShcFa8oWapAu4FUtnq/RJeWfX2kq8cHFxUdZkLfnCXtKFjJpaeWoSL0xLqEhWkgrsZdbK2Eu+kLd7enrazIyUhaetrhe2auTJuLi4KPF01pIv7CVdyGjphXs7cHZ2ZuTIkWYFr3v06MFjjz3G448/To8ePYTAE1QaBoOBAQMGEBYWhj4hAVasgDZt4PvvkVxcWOznx4N+fhjat8fHx4eAgACluLH8N9ugQQNR3PguQZUlb5Xs2wemTp3Kk08+ybJly5QbXWFhIePGjbP55VIeaA1YHjt2LIsXL2bSpEm89NJL7N+/nxUrVvD1119X6Dpl1Iiz8iqhoia7VqfT4ePjw40bN6zOZa9Gnows6MuaXaumTp69bhcy/v7+pKWllVnkqel6oUbkya/l5+djMBgsilR7fWtl7JVRsdftQka+ydvq1mCrb60pjRo1Qq/Xk5CQYDH2q6qKPIBu3boRFxdnNfFGIKgs0tPTjbHMsbHoW7UiuNj7ktexI/9ITWVrYiIhKSmKpW/btm3K/00TlYKDg4mOjsbHx6dCDTSCykVzW7OVK1cyefJks1+yzs7OTJo0iZUrV5br4koyfPhwFi5cyMyZM+nUqRO//fabzYDlpk2bsmXLFqKioujUqRPvvfceixYtui3lU0Bd6RN7/WZNXyvrPGC/jIq9Gnky9vrXSpKkSeSVtYQK2C+jUl4iT64PCLaLIdeoUUO5TtbKqJSXJU9N+RS4JfKuXbtmlkUuk5eXpwhPe+4be2VUZJFnrRCyzJ0o8saPH89//vMf0YxdcMfRMDCQI08/zSmdjp45OWTrdMT/61+0T083Crxiq5389+vr62v1b7lhw4ZC4FVzNGfXFhQUcPbsWbMK7ABnz56lqKio3BZmjXHjxjFu3DiLr61evbrUtrCwMCUT8nZT3u7ashZDNn29ot21WVlZFBYWArbdtWrq5Gmx5EH5iTxrfXBl8Wetb60pAQEBpKWlkZycXOpvBspP5JmWKrFF7dq1lUzdpKSkUgJMjjuTCyfbwp7Ik0uxqLXkXbx40W6XhtvFE088AUC7du145JFHCA8Pp3PnznTo0MFqRxmBoMI5cQJGj8avOFxqX40aRObkELt4MUCpnrMCgWaR9/zzz/PCCy9w4cIFunfvDhiLg37wwQc8//zz5b7AqkxFuGutfQmqcdeavl5WkWfPXSuLNmdnZ4uJLDKySMrKyrJau1CtJU8WbxUdk2fqqrVWFkSmXr16XLhwwWpHB3t9a2XUijx7let1Oh1BQUHEx8dz+fLlUiJPtlw1bNjQ7rnJ4k222JlSUFCgiL9mzZrZnCc4OBgnJyeys7O5evWq3WtxO4iLiyMmJobjx48TExPD7NmziY+Px9nZmdatW3PixInKXqLgbiInB/77X5gzBwoKwNcXPvoIWrcmtlcvZZiofScoiWaRN2/ePAIDA1mwYIFZr8wpU6bw+uuvl/sCqzL23LWFhYVKNqsad21RURE5OTkWM0O1umvLGpNnz10rW/h8fX1tWmZM3cIGg8FiVmxlWfKsiTw1Lc1k7HW90GrJs1YTUq3Ik8fEx8dbjMtTk3QhY8uSp9frKSwsxN3d3WovXRk3Nzf8/f1JSUkhLi7ujhB5jRs3pnHjxmZdKNLT04mJiRECT3B72bsXXnwR5Jqlw4bB4sXoCwqIDA83Gypq3wlKojkmz8nJiSlTppCYmMjNmze5efMmiYmJTJkyRWSclcCeu9Z0uy1Lnqm705o4U2vJu10xeaYizxYuLi7Kmqy5bMs7Js9aqzIZ+fUbN24oLmdT1CRdyNjqX5uRkaF8BtSKvOTkZKWgsSlaRZ7pPqaYWvLsYUvkyYWmmzZtatciCLfO31qB6ttBVlaWzbhAHx8fevfuzSuvvGK2/fTp0xW8MsFdSXo6/Otf0Lu3UeDVqwf/+x9s3Ii+oIDw8HClNMrevXsJCQlRSqKIWFKBjGaRB0ZXzC+//MLXX3+tWGkuX75sM2bsbkStyNPpdErLMUs4OzsrQs/aNb7dMXmyeLMWk6dW5JmOsSTy8vPzlXMrqyVPtszZE3nyPJIkWezmIYs8W0kXMrZEnpws4e3tbfd6161bF2dnZyRJsjhXeYk8WeTIPWVtIYu81NTUUp9xWaypzU6VYwnlLimVgaenJ3FxccybN0/pRGONwsJCfvzxR+bMmSPqiwnKBYPBoGS2s3UrtGsHn34KkkTm8OEYDhyAxx7j0qVLZgIvKiqKnj17KiVRZKGnzCW4q9Hsrr148SIDBgwgISGB3Nxc+vXrh4+PD3PnziUnJ4dly5ZVxDqrJPZi8uTt3t7edoPNvb29ycrKsmvJsycW7CVxaE28sBeTp0bk+fn5cenSJYsiz1RE2purvESeq6ur0morJSWl1Hgt7lrTWnklkV2v9pIlwGhBr1evHpcvXyYpKclsH0mSFMGmRnCoEXn2MmIBpW5mWloaer2e1q1bK6+ZWvLUIJ+P3JqtsnjggQfo0qUL8+bNIzo6Gl9fXwICApRexwaDgYsXL+Lr68vYsWOZOnVqpa5XUD2Qa9/lJyURfe+9eBUXNaZpU5L/+196vP02AU89xbZt25Tad4CZazY4OJioqCjCw8NF7TuBgmaRN2HCBLp27crx48fNYpseffRRXnzxxXJdXFXHXkyevN2Wq1bG29ub5OTkCrfkVURMnj1s1cqTLWk+Pj5KIWdryCLPXlasPZEHxrg9WeSVxBF3raWYPLVlT2QCAwMVkWdKSkoKeXl5AHbj3+CWyLP0S1/OiFUrzho1asSpU6dISEiwKPK0WvIqW+SB8bM9c+ZMwNhbOjY2lmvXrlGjRg3q1atHx44dK7wmqODuIj0tjftjY3kzORmvixeRnJzQTZzIpTFjCBs0SPl7slT7zhRR+05QEs0ib8+ePezdu7dUGYHGjRvbLLB6N6LWXatG5NkTjOUdk6fWXZuZmUlBQUEpAabVkme6jylqul3I2LLkFRUVqY7Jk8f8/fffFkWeLNjK6q6VLXlqhJnpuJIiT/67CwgIUFXew1osnSRJqmvbmc516tSpUrFsslh0ROTdKWVUAJo3b07z5s0rexmC6oxeT8OXX2Zh8T3iJPBOYCD/fuwxIosFnqXad9burSJ8QGCK5pi8oqIii8Holy5dEubhEqgVefaEmekYSyJPkiTV4qy8Ei9Mj2NprvKKyZMFm72MWLAt8gwGg/K5VTOXrVp5WsSZLXetLNbUWvLsiTw18XhwS8BdunTJLInj6tWr5OTk4OTkpDo7TxZAJWPptFryAgMDcXFxIT09XcQSCe4Oiopg6VJj7N3mzeDqiuH113miaVM2Xb5MaGiomcATGbMCR9As8vr168fChQuV5zqdjoyMDN59910GDRpUnmur8tiLf9PqrrU2V25uriJg1NbJK2tMnpubm5IsYsllW17uWlmwyQLOFrJ4u3HjRqnC3LJY8/b2tlm3T8ZWGRVZ5Kkp9SFb8m7evFmqw4RpCSI1lJfICwwMxM3NjcLCQjPru2yNa9iwoerezi1atADMRZ7BYFCut1q3r6urKy1btgTg5MmTqvapSA4dOkTfvn3p2LEjw4YNY+bMmfz4449WCz8LBJo4dw7Cw2HcOGMWbY8eEBOD77x5rFy3zmyoqH0nKAuaRd6CBQuIjo6mbdu25OTk8Mwzz9CkSRMSExOZM2dORayxylKe7lpb4szUklZWd60WcWar60V5uWvV1raDW9m3pi3VZLTE45keT46/k5EkSZPI8/PzU1zZJedy1JJXslaeVpHn5OSkuGxN3axaki5kLIm8v//+GzDGLGqx7rdv3x7gjqhDFxkZibOzM2PHjiUkJITo6Gief/55mjRpouqzKBBYJD8fZs+Ge+6B338HLy9YtMj4/7Zt0ev1REZGmu0SGRkpSqIIHEZzTF5QUBAxMTF8/fXXHD16lKKiIkaPHs2IESMsFum9m5HFW05ODoWFhaXqCKq1moE6kefl5WW3JpnaxAs1geW+vr4kJyfbtOSpiaWzJfK0WPLc3Nzw9vYmIyOD69evm5Vc0SryrLlZb9y4oTT5tlfbDoyCKiAggMuXL3PlyhWzeBlHRZ6csCEjuzfVijwwxtBeuHDBrFuFHEenReTJ1re///6boqIinJycOHPmDABt2rRRPQ8YRd633357R4g8vV7P5s2bS3XruHjxIjExMZWzKEHV5sgRY1Fj+fPTvz989hkUd47R6/VmpVHWrl1LZGSkUhJFuGwFjuBQnTwPDw9eeOEFFi9ezJIlS3jxxReFwLOAqVUtKyur1Otqu1SYjrFkFXRknvK05FkSebJgUysWTfcxRYslD6zH5Tkq8kpazeTn/v7+qty+YL1kiVZ3rXyDL+ky1GrJg1uxcrLVDbTVyJNp1KgRNWrUIDc3V5nr1KlTgLHvqxa6FIvCffv2lX7x0iWwUpOxIujRo4fF2MCSXTAEArtkZ8PUqXD//UaB5+8PX35prIVXLPBE7TtBRaFZ5Dk7O/PAAw+U+hK9evWq6HhRgho1aihZgpYscGrLnoA6S56aeWy1NcvPz1fEqBpxZstd64glr6wxeabjykvklSx9osVVK2NJ5GVnZyvvm1qRJ1vYrly5QnZ2trJdtsbJLlg1yBY405IljrhrnZ2dFTfr8ePHgVsdIOTtaum+YAHOGM/HzD2l10NYGAwYcNuE3qRJk3jvvfes1lwUCNSQ8fPP5LdtC3PnQmEhDB8OZ89CZCSXEhOVe55c+65kkoVc+y4kJETUvhM4hGaRJ0kSubm5dO3aVfnFbvqa4BY6nc5mXJ7asiemY2yJRTXz2HLXmm7TYoGzZcm7nTF5cGeLPNNf4XJpGDXdLmT8/f2V91i25hUVFSlu1pKuRVu0atUKgHPnzinb5C4PWix5AJ06dQJuiTz5X62WPJ8bN+hc/P9fvv3W+B+93higHhsLycnGIPXbwODBg9m9ezctWrTgueee47PPPuPgwYOlkmcEAosYDOQ+/zzeQ4bgGh9PQWAg/PADfPMNBASg1+sJCwtjwIABGAwGfH192bZtG9HR0aVcsnLtu23btonadwLNaBZ5Op2OjRs3MmTIEHr27MkPP/xg9prAHFsizxE3a3lZ8rKyskqVwpF/VdaoUUNVvTVb7lp5rrK6ax215JUsfeKoyLt27ZrZdSovS558Xmrj8cD49yVb2WSrW1JSErm5uTg7O2uK1zG15EmSRGZmplL2RJM4Mxi4p9jldPToUfR6PXq9HmdnZ+6tV0+b5W3LFv5RHEe54s03Yd++WwIvJASiouA21QA7f/48//d//8e//vUvbt68yQcffED37t3x8fGhY8eOt2UNgirKjz9C27a4r14NwDKgS40a6Dsbf8KYxt4lJycr929fX1+rNe4aNmwoBJ7AIRyy5Dk7O/Pxxx8zb948hg8fzn//+19hxbOCGgvc7XTXmgrKknPJYk3tzcSayCssLFTWVNbEi/Ky5GkphAy3ulmYFlGGW3F0WkSefOM2FXmyJU+LyANKiTxZmDVu3NhuRxBTmjZtirOzM5mZmVy6dElxsQYGBqq+RhgMMGAAPYpbGf7+++9ERUUB0KltW3weflibi7VBA57fvh1nYG9uLqdDQ80F3m0MOm/WrBnDhg1jxowZbNq0ibi4OG7evMkvv/zCmDFjbts6BFWIq1eN7tihQ+HyZWjenORvv+XDkBBOxMcTHh7Ovn37SsXeieLFgopEc3atKWPGjKFly5Y8/vjjREdHl9eaqhV3mru2Ro0aODs7U1hYSEZGhpmg05J0YTquZCydqehTM5ecBZuWllaqe4ZWS54sBq25a9WKRVdXV2rXrk1qaipXr15V6t2Vl7tWLqei9QYvu1Jl16rWosMybtnZtG3RgpN//smRI0eU69W+fXtjkoOPD9h779LTITmZzomJ1HFyIiU9nXfeeQeAXhcvgvw5SE+3P1cxQffdx+sjRtBo/XoUSbd27W0ReEOHDqVTp07Ko6TbumbNmvTp04c+ffpU+FoEVQhJMn5GJ06EGzfA2RkmT4Z33yXAw4Oo7t0VYRcaGgogChwLbhuaLXmNGzc2S7AIDw/njz/+EFk/VlDjrr2dljydTmc1Lk9L+RTTcSUtebLo8/DwUOX2NS11Ilu4wGgRlK17asWZtfp2Wt21YLlkiSMir3GxO/PixYtKkWZ5Hq3irG3btgCcPXsWgD///BNAW+utYgtct2LL4qFDhzh06BAAHZo0UZ/k0LAhREXhFBLCgOLzki2MT6WlOeZi1euZs38/rwDKpzAy0hibV8G0aNGCvXv3MmbMGJo1a4afnx9hYWFMmDCBVatWcezYMaV8jkAAQHy88W9l1CijwOvUCQ4ehA8+gOKKE8HBwaxdu9ZsN1HgWHC70Czy4uLiSn3hNm/enGPHjilWBcEtbJU+KS9LnhaRZzqupMjTasmzJvK0JF0AuLi4KC5b0w4TN2/eVMIATIWgLawlTDgi8iy5WR0ReY0aNcLZ2ZmcnBzF3SuvT2uSgyzyZPeqXFNOU5xYsQXuvuL3/0B0NLt37wYg/KeftCU5BAdDVBTTGjZU3AKhwP1Nm2p3sSYmmsfg7d1r/Dc21ri9goXevHnz+OWXX7h27RoJCQmsW7eOfv36kZiYyPvvv0/Xrl3x9vbmnnvuqdB1CKoAhYXw8cfQvj3s2AHu7sYixwcPwr33mg0VBY4FlUmZ3LWm1KhRQ7FYCG4hW/LK6mYtL3et6ThrIk+rJa+ku1arWASjBe7mzZtm8W+yC7FmzZqq22xZEnkFBQXKvHKsnRpkkWdqpXZE5Lm6utKoUSPi4uKIjY0lICBAWZ9mS17xmuLj48nMzFRagHXo0EG9m7XYAhfWsydcusSuvXsB4y++PlevarfABQfTdsMGfg4N5U/gWUC3bp12F+ugQaVj8KKibgm/8HCIjr4tyRcNGzakYcOGDB48WNmWkZHBsWPH7ohizYJK5MwZGD0a/vjD+Lx3b/j8cyjOWDdFFDgWVDaqLHn+/v6KJaRWrVr4+/tbfQjMudPctabjypp4Ya2EimzJU5N0ISNbh01Fnvx/LZ8rSyLv6tWrSsKQFpEn33zlX9x5eXnK34EWkQe3xFxsbCyFhYWKO1mTJc9goM6IEQQUh0tERUUpa2vv56etllxwMK337aOLiTs9HPBzJMlBr4fISPoDE4Ba4JiLtW7d0kkWstALCYGAAKOIrWCys7PZs2eP0rlDxtvbm/vuu0/UKrtbycuDGTOMLtk//jB+FpcuNX4+LQg8UeBYcCegSuQtWLBAubEtXLiQBQsWWH0IzCmvxIvysgiCfXdtecXkabXkARYteVp6hcoiLyUlhYKCAuBWRmy9evXstn0zpaQlT65N5+npqcntC7dq2P3999+K0KtRo4a27NpiN2vv4pIu706bBkDzJk3wGzpUey254GBmvP8+boAr8AFoT3IwrWNXVhfrd98ZLXUljx8cbNy+bZvqBA5H+euvv2jTpg19+vShQ4cOhIeHm8VkGgwGnn/++TIfZ8mSJTRt2pQaNWrQpUsXfv/9d6tjv/vuO/r160fdunWpWbMmPXr0YPv27WZjVq9ejU6nK/XIyckp81oFwIED0KULTJ8O+flkP/SQ0aI3diyY3FMuXbokChwL7ihUuWtHjRpl8f8C+1izwEmS5JC7Njc3l/z8fDP3ZXnF5DlaQsWau7YyLHl16tTBycmJoqIiUlJSCAwM1Nw+TKakyJNjTps0aaKtJqTBQOtiy9/JkyeVuLp27drhnJSkzsVqXBBERfFg585sTE3lSLGrdtD168ZMVq1uVr2eh5cuRQ9kACFgtMCpteRdulS6jl1ZXKw1a4I1QX+bykxMnTqVDh06cPjwYW7evMmkSZPo1asXUVFRSkeRspaL2rBhAxMnTmTJkiWEhoby2WefMXDgQM6cOWOxa8lvv/1Gv379mDVrFn5+fqxatYohQ4Zw4MABOnfurIyrWbOmWXFrMIbRCMpAZia8/TYsXAiSRFGdOrzr58dXf/9NlCRh+lciu2YDAgKUwsXbtm0jPT29VBa9XODYx8dH1L8TVCiqzBppaWmqHxXFjRs3iIyMxNfXF19fXyIjIy3WVTPlueeeK/XLtnv37hW2RktYs+RlZ2crXxZa69uVnEuryLNW+kSrJc+eu7a8LHlaRJ6pS1aOn5P/1Sry5F/eFy9eRJIkpbOEVhcrAwbQ5fPPAWPBYCVZolkz7e26goMZaFKAHGCIqcBTa4UzscAFhIQQ4ogFzsfH6EK9A1ys5cW+ffuYNWsWderUoXnz5vz4448MHDiQ3r17KyK/rEXf58+fz+jRo3nxxRdp06YNCxcuJDg4mKVLl1ocv3DhQqZMmcJ9991HixYtmDVrFi1atOCnn34yG6fT6QgMDDR7CBxHt2sXdOgACxYYy6SMHMmVXbv4qqiI2Lg4wsPDlXAJUeBYcKeiypLn5+dn98YmSRI6na5UF4Xy4plnnuHSpUts27YNMNboi4yMLHWjK8mAAQNYtWqV8lxNSY/yxJrIM7WieXp62p3Hzc0NFxcXCgoKyMjIMLOSaXXXWusw4aglLzs728y6KJdBKS9LnhZ3LRjdslevXlXEnaOWvJCQEJycnEhPT+fKlSuOibxiF2un4jUkJCQomawdoqONBVTlcSqve9PQUD54+WXeWLqUF4G+oM3NWl4WOF9fows1Pb30ONnFqtZKeYeQnZ1dqqj0p59+ipOTE2FhYXz11Vdlmj8vL48jR47wxhtvmG2PiIhg3759quYoKioiPT291I+fjIwMGjduTGFhIZ06deK9994zs/SVJDc316xNm/z3n5+fb7NUjPxadS0nk5+cTKdPPsFl1y4ApEaNKFy8GGnAAOoCu3btYtCgQcTHx9O/f3+WL1/OmDFjSEpKok2bNmzZsoV69erdkden2r931fj8HD0nVSJP/lKqLM6ePcu2bdv4448/uP/++wH4/PPP6dGjB+fOnVP6cFrC3d29Un/RWiuhIgszLy8vVXFiOp0Ob29vbt68Wcr1q9WSJ4uvsmbF+vr6otPpkCSJGzduKAWDHRFncoybaX07R9y1YPyFfOLECcXN6qjIc3d3p0mTJsTGxnLu3DnHRF6xi7VmeDitYmM5B/xRnJXX4+ZNh2vJTd2+nZcA5cpocbPKFjiwbIELD1dvgfP1tS7iqmAl/9atW3P48GHatGljtv2TTz5BkiQeeeSRMs2fkpJCYWGhEjsqU69ePeVHiT0++ugjMjMzefLJJ83WvXr1ajp06EBaWhoff/wxoaGhHD9+nBYtWlicZ/bs2cyYMaPU9h07dqj64blz505V661K1N+3j47Ll9P45k0knY64gQM5GxlJQVERbNmijJs9e7by/9TUVLPnx48fV/o336lUx/fOlOp4fllZWQ7tp0rkhYWFOTR5ebF//358fX0VgQfQvXt3fH192bdvn02RFxUVRUBAgFLY9P3331fEyO3AWsKEVmEGKCLPmmDUaskrq7vW2dkZPz8/bty4QWpqaplEnrWsWNPX1CLHNV28eBG4lR2rtYUYBgOtGjdWRN6pU6cAjJ83teVKQBFPwzt2ZGax9bRevXrcW6uWscaWg4kO/iEhRgteZOQt65saoVcNLXDlxaOPPsrXX39dqq4ZwOLFiykqKmJZcRu3slDSMyJ7Quzx9ddfM336dH744Qez+1j37t3NQlFCQ0O59957+eSTT1i0aJHFuaZNm8akSZOU52lpaQQHBxMREWHzHpCfn8/OnTvp16+f6tJGdzyXL+M8YQJOxaEQ6Q0b4rp6NcF9+mDtr+nAgQNEREQoz3fs2GH2HXUnUi3fOxOq8/k5Gg7ncJ28rKwsEhISyMvLM9teEc27r1y5YlGYBQQE2Pz1O3DgQJ544gkaN25MXFwcb7/9Ng8++CBHjhzB3d3d4j6OujDkMab/AspxMjIyzLbLrlJvb2/VZlhZMN68edNsH1kw1qhRQ9VcsrC8ceOG2Xj5XL28vFSvyd/fnxs3bnD16lWl64JcZsTX11e1+Vy25F29elUZK1vg6tatq8lU3dCkllx+fr4SS9WoUSP186SlwbBhNC9Objhy5IjSXaJD3brkR0QYS358950xYcAegYGM+uIL5j/+OBnA4MGDKXj2WXSBgaB2TZcvw8CBkJQEbdoYLQsNGsCuXcYac/Hx0L8/bN0K9gStp6fxYenYsqi+TS6PsrhYytstM23aNKYVZy1bYsmSJSxZssTh+evUqYOzs3Op+1ZycrLdHzMbNmxg9OjR/N///R8PPfSQzbFOTk7cd999nD9/3uoYd3d3i/dBV1dXVV+Qasfd0UgSrFhhbENmMICLC4X//jdRnTszoE8fq+en1+sZNWoU2dnZyrZRo0ZVmbp31eK9s0F1PD9Hz0ezyLt27RrPP/88W7dutfi6lpi86dOnW3QXmCK3W7L0K9fer9/hw4cr/2/fvj1du3alcePGbN68mWHDhlncp6wuDDA3Fcu1ti5fvswWE3P/0aNHAWN8jel2W8jXNioqSrHeFRQUKKL0jz/+UKxNtpD7nsbHx5sdWxZnMTExpXq/WkN2Ne/YsUOxBMqWs/PnzyvXwp75XP7SS0xMZPPmzeh0Ov7++2/A2GVF7TWCW5bEY8eOsXnzZmWeixcvapqHSZOMAuqTT/i8OHHCz8+PY0lJHJPdM3v2qJ/PxYXFq1dTUFBAnTp12HnjhpkLSBUmbiGOHzc+Sm6PiTE+qhiOuFgcdWFUFm5ubnTp0oWdO3fy6KOPKtt37tzJ0KFDre739ddf88ILL/D111/z8MMP2z2OJEnExMQYi2QLLHPhAowZA8XhSHkdO+K2di1FbdpQZPJ3eenSJbMsWFHgWFClkDTyzDPPSD179pQOHjwoeXl5STt27JDWrl0rtWrVSvr55581zXXt2jXp7NmzNh/Z2dnSihUrJF9f31L7+/r6SitXrtR0zObNm0sffPCB1ddzcnIkg8GgPPR6vQRIKSkpUl5ens1HZmamtGnTJikzM1PZtmvXLgmQmjdvbjb2q6++kgCpV69edueVH2FhYRIgrVu3Ttl29epVCZAAs+Paemzbtk0CpLZt2yrbcnNzJRcXFwmQYmNjVa9pwIABEiAtX75c2ebv7y8B0rFjxyxeE0uPGzduKOeRkpIi5ebmSp6enhIgnT17VvV68vLypN27d0uA1LRpUykhIUECJJ1OJ2VkZGiaJy8uTopt3lxZFyAN8PKS8jw8pLw2baS8uDjV8+S1aaPslxkdbbwm/v7a5snLk/JSUqS8+HjLr8XHG1/Xco53wEPtZ8TSIyUlRQIkg8Gg6T5QmXzzzTeSq6urtGLFCunMmTPSxIkTJS8vLyk+Pl6SJEl64403pMjISGX8V199Jbm4uEiffvqplJSUpDxu3rypjJk+fbq0bds26e+//5aOHTsmPf/885KLi4t04MAB1esyGAyqrmVeXp60adMmKS8vT+OZ3yHk50vShx9KkoeHJIFU5OEhfdyokdSi+H5hen4JCQlSSEiI1L17d+nmzZuSXq+XQkJCJEAKCQmREhISJEmSlHHydr1eX8knaZkq/97ZoTqfn9q/z5JotuT9+uuv/PDDD9x33304OTnRuHFj+vXrR82aNZk9e7aqX5kyderUUVVUtkePHhgMBg4ePEi3bt0AYzyEwWCgZ8+eqo+XmpqKXq+3GYBfVhdGybFy0kBGRobZ/nKRUh8fH9Xzym7WnJwcZR/ZXeDu7q7a0ijHyqWlpSnzZGVlKcWDa9eurXpN8vtnMBhwdXWlsLBQya4NDAxU5rF3/fz8/PD29iYjI4PU1FRcXV0VK01wcLAmU7VceFiv1yvJEsHBwYq7WzVNmtD0119p06wZZ4vdgiMzM3ENCYHt29XXkuvb91Ym6/btEBgIW7bgWq8ermfPGl9XW0uudm3rteSqeFtBR1wsVdElM3z4cFJTU5k5cyZJSUm0b9+eLVu2KG0hk5KSlMLbAJ999hkFBQW88sorvPLKK8r2UaNGsXr1asAYwjFmzBiuXLmCr68vnTt35rffflPul4Jijh83tiQ7csT4/MEHuTJjBh+PGqVY4nYVZ9UmJibSt29fJdwjPT1dKXAMWCxwLNfJEwWOBXcK6sv/F5OZmal8yP39/ZVsyA4dOiguyPKmTZs2DBgwgJdeeok//viDP/74g5deeonBgwebJV20bt2a77//HjCKqsmTJ7N//37i4+OJiopiyJAh1KlTx8xNUtHIAcwlCw9raWkmY6mwsiMtxOSxpiVUZFernMWrlpKlT27evKnU/9OaFStnQZuWP/Hx8dEmzgwGGmK87gUFBfxQHEgdEhJiFFxq69HJBAez6MMP8QM6Ak+AtnIl1mrJgdFVWwVryQnKzrhx44iPjyc3N5cjR47Qp08f5bXVq1cTFRWlPI+KikKSpFIPWeCBsSvRxYsXyc3NJTk5me3bt9OjR4/beEZ3ODk58NZb0LWrUeD5+sIXX8Avv1C/uNi13Gps0KBBAAwaNMisJZlc127btm1ER0eXcsnKBY7lQsgCwZ2AZpHXqlUrpap6p06d+Oyzz0hMTGTZsmWaS1RoYf369XTo0IGIiAgiIiLo2LEja9euNRtz7tw5Raw4Oztz8uRJhg4dSsuWLRk1ahQtW7Zk//79t/VXlizyMjMzzeIVtbQ0k5HXbZpl40h3CfkGlJGRoVjvTFvxaGn9VVLkyf/6+PhorkkoB54nJSUpSReayt8UFx7WhYdzT+vWAEos3b0tWmgvPAyg1/PQokVcAw4AbqCtL6ucyWqpXVeDBretXZdAcNeydy907gzvvw8FBTBsGJw9a7ToFcd0m7Yai4+PB4wxyyVbkoEocCyoWmh2106cOFH5An733Xfp378/69evx83NzeyXZXnj7+/PunXrbI6RTNoNeXh4lOrvWBmYCsr09HRFjGktewKW69s50l3CdGxaWhr+/v4OdZeA0iJPTt7QWsAYS9z/oQAAKaFJREFUjNmve/fu5eLFi4obWlMAc3HhYWJj6ZSSwu/cEtP3//CD8TV5nJrrZVKuxCUkBBdHypVAtaslJxBUCdLTYdo0+PRT4/PAQFi8GB57zOLw4OBg1q5da5a5vHbtWpFEIajSaLbkjRgxgueeew6Azp07Ex8fz6FDh9Dr9WbZrAIjpjF+phY4R+rkWepU4Yglz83NTXGByvFzskhTEyNpSskixo4WHoZbsXSxsbFKHIy8TRXFhYcJCeH+EjWFuiUnays8bKkrRM+et9p1yUKvuOCyQCC4g9iyBdq1uyXwXngBzpyxKvDAGMNbsj5iZGSkUi1AIKiKaBZ5JfH09OTee+/VLA7uJmSXranIK4slz1TkOWLJg1viTLa8OdpCTBZzsriTY+kc6TISEhICGEWeXPZEk8gDpfDw402bUqt4Ux+gidbertWwL6tAUO25dg1GjICHHwa9noJGjeCXX4y18GrVUoZdunTJzCNiWhalSZMmAEq3G9MetQJBVUOzu1aSJP73v/+xe/dukpOTKSoqMnv9u+++K7fFVRd8fHy4du1ahYg8Ryx5YBRzFy9eLBVL56jIu3z5MpIkOW7JMxgIKb4WsbGxyrVq1qyZtu4SAMHBuK9bx8bQUL4B3gNtyRIgukIIBFUJSYKvv4YJEyAlBcnJia/r1WOWkxNbW7Y061ohC7qAgAC2bdtGenq6Wd27LVu2cPz4cbZs2aJk14aHhxMdHW01Fk8guFPRbMmbMGECkZGRxMXF4e3tja+vr9lDUBpLGbaOJF7cyZa8rKws0tPTHRN5xQkTIZMnA8aAZzm5p5mXl/aECb0eIiN5APgMCABtyRIyvr7WXbsNGwqBJxDcCej1MHiw0YKXkgIdOpC8aRNve3hwOj7ezBJnarFLTk42K4siJ1k0aNAAgAYNGijJGKIsiqCqotmSt27dOr777jslzVxgH0vuWkcscOVtyYPSWbFaRZ6Xlxc1a9YkLS2NpKQkxV2rSeQVJ0w0SEiglpMTNwoKuHHjBq6urrQcN87YrkseZ09YmSRL4GhvV4FAcOdTVATLlsHUqZCRAW5uxjIpU6dSz82NqE6dFEEXHh5u1pnCtCwKoFj0GjZsaNYqTy6LYtrxQiCoSmi25Pn6+iqxUwJ1WBJ5ZalvV9bsWrBuyXMkttI0Ls8hS15xwoRTSAjhJu7/Hs7OeMXHq0+YEMkSAsHdwZ9/Gi38r7xiFHg9e8KxY/D220axh3lZlNjYWEJDQ80EniiLIrgb0Czy5H6zpo2ZBbYpb5FnWnDYkXmg/Cx5YC7yLl++bLZNNcUJDQ+ZHL9vTo7lIsLWEMkSAkH1Jj8fZs2Ce+4x9o328oJPPoHff4e2bUsNl8uimCLKogjuJjS7a5944gm+/vprAgICaNKkSam2QhXV9aIqI4s8SxY4R4oYFxQUkJWVhZeXV6XH5MGtWnbHjx/n6tWrgANZscaJGLVhA6cfeoh8YBxoS5gQyRICQfXlyBFjAePjx43PBwwwumtttPOzVhalpCVPIKiuaBZ5zz33HEeOHGHkyJHUq1cPXXHFcIF1ZAEmi7ycnByld60Wkefl5YWzszOFhYXcvHkTLy8vh92sspiTRZ7sZpW7TqjGYKB1sdVObiEWGBhoFLaXLoGHh/q59Hq8xozhU9NtkZHa4uhE4WGBoHqRlQXTp8NHH0FREYV+fjh/8okx0cLk++fSpUtmsXOmSRYhISFmMXnh4eFC6AnuCjSLvM2bN7N9+3Z69epVEeuplshdJOTCw6Z9YmUrnxp0Oh21atUiJSWF69ev06BBA0WkaRV5spi7cuUKubm5yjxyZpkqirNi28TFAfDnn38CxtZ3SgJEw4YwaZL9uUTChEAgKMnu3fDSS1BcN3NH7dq85e3NxrAwgk0Enr2yKLKgi4qKMkvGEGVRBNUdzTF5wcHBmoSJAGoVF+GUW4fJLtaaNWtq6hMLULduXcDYYSI3N1cpxaJV5Mk3tkuXLilWPHd3d21tzYqzYtsWu2hlWjVocEuwFXfCsIlImBAIBKbcvAljxsCDDxoFXoMGpKxcycu+vhy6eFFzWRTZYmeajCHKogjuBjSLvI8++ogpU6YoTZwF9pGFU0mRpzVZAsxFnmx9c3Z21jyXLPIyMzM5ffo0AEFBQdrc78VZsc2aNqWGyeZ7d+y4Jdi2bLE/j0iYEAgEMj/8YGxJ9vnnxudjx8Lp09R5/nmzbNnw8HD27dtXymInZ8Nu27aN6OjoUi5ZuSzKtm3bRNasoNqj2V07cuRIsrKyaNasGZ6enqUSL2QhI7hFSXdtWUReQEAAYC7y6tSpozk20sPDg9q1a5Oamsoff/wBaHTVygQH4xIdzRNt27K2uIvHUykptwRbYOCtQGlriIQJgUBw9SqMHw/ffmt83qKFUeiFhSlDSrpcQ0NDAayWRbEm4oSLVnC3oFnkLVy4sAKWUb2x5q4tiyUvOTnZ4Xg8DAYoLvyZmprKgQMHgGKRp7WFGEBwMPO++YZrgwfzCOALt7JiTQqL2kQkTAgEdyeSBF9+Ca+9BjdugLMz/Pvf8M47FhO35LIossADURZFILCGJpGXn59PVFQUb7/9tiiIrAFTS54kSQ6XPQHL7lpNIq84WYLkZIKbNuU4sGfPHgAa+voafzUHBBgta2rXp9cTMH48W023yVmxgYHq1yYQCO4u4uPhn/+EHTuMzzt3hi++gHvvtbqLKIsiEKhHU0yeq6sr33//fUWtpdoiW/Jyc3PJzs7mWnEygizYtGDNXaua4mQJYmNpeugQgFLYusP33xtj6ZKTjePUUDIrdu9e82SJxET1axMIBHcHhYXw8cfQvj3s2IHk7g4ffAAHD5oJvEuXLpnVFy1ZFmXv3r1mMXp6rf2pBYJqjubEi0cffZRNmzZVwFKqL97e3ri4GI2m169fJzk5Gbgl2LRg6q6V+8RqEovFyRKEhNDdpAMHwL3XrqlvIQbqsmJFj2OBQGDK6dMQGgoTJ0JmJsd8fHiobl30zzwDLrecS3q9nrCwMAYMGIDBYODSpUulkix69uxZKhnjksjCFwgUNMfkNW/enPfee499+/bRpUsXvLy8zF4fP358uS2uuqDT6fD39yc5OdlM5GkuPMwtYXj16lUlw7mxjYrvFinOWu0ZGmq0xBXTpmlTbfXo5KxYsJwVGx4ODlgrBQJBNSQvD2bPhvffN8bq1qzJjWnTeGL5cv6OizMrUGxqsQPMyqIAFsuiyHXyRFkUgeAWmkXeF198gZ+fH0eOHOHIkSNmr+l0OiHyrFC3bl2Sk5O5du2a0vrLEUueLOguXryoWPCaNGmifUHBwTT++mta9erFOWAY4LJunbaCw2qyYj08jD0mBQLB3cuBA8aWZMXlmhgyBJYsoVbDhuweMcKsQLFpZwrTsiiAUui4ZHasXBbFtOOFQCBwQOTFFXc3EGgjKCiI06dPk5iYWCZ3bXBwMC4uLuTm5rJv3z7AAUsegF6P7tln2QUkAN1AewsxsJ8Vqza7ViAQVAsMBsMtIZaZCW+9ZYy/kyQKa9cm98MP8XzuOaUlmSiLIhBUHJpj8kyRJAlJksprLdWaoKAgAC5fvlwmkefi4qJY7uRrr1nkmSRLNAgJocfevTibJkuI4GWBQOAABoOBAQMGEBYWRvL69cbEioULQZLIfOwxunl703f5cgwl4oHlsiimiLIoAkHZcUjkffnll3To0AEPDw88PDzo2LFjqT9QgTmyyEtISCA1NRVwLCYPoFmzZsr/3dzcCNRSpkS0EBMIBBVEeno6uUlJvBUbS8DIkcYSKY0ace3LL+l47BhHL15UWo+ZYq0sisiWFQjKhmaRN3/+fF5++WUGDRrEt99+y4YNGxgwYABjx45lwYIFFbHGaoEs8o4fP44kSeh0OmrXru3QXC1atFD+36lTJ239b0ULMYFAUBFIEg337+dQVhbPA0XA6po1+WPFCrpPn24xxg5EWRSBoCLRLPI++eQTli5dypw5c3jkkUcYOnQoc+fOZcmSJSxatKgi1lgtkEWeaRyds7OzQ3M9/vjjyv+HDBmibWc5WSI6unTsnZwsoaUQskAg0MySJUto2rQpNWrUoEuXLvz+++82x0dHR9OlSxdq1KhBSEgIy5YtKzVm48aNtG3bFnd3d9q2bVuuNU3lEiaWuHTpEml//gnDhsGTT+J87Rr5zZvzZFAQz6el0aNfPzOBZ+qCFWVRBIKKRbPIS0pKomfPnqW29+zZk6SkpHJZlCXef/99evbsiaenp+p2YJIkMX36dIKCgvDw8CA8PJzTcnbXbUYWeTKtWrVyeK4+ffrw8MMP4+vry7PPPqt9Al9f63XwGjYUAk8gqEA2bNjAxIkTefPNNzl27Bi9e/dm4MCBJCQkWBwfFxfHoEGD6N27N8eOHeM///kP48ePZ+PGjcqY/fv3M3z4cCIjIzl+/DiRkZE8+eSTSsvCsmAaZ1fSqqZPSGBJ587o2reHTZuMde7eeQfXU6eY9H//ZzbWUoydXBalpACUkzFCQkJEWRSBoAxoFnnNmzfnW7mBtAkbNmwwcyOWN3l5eTzxxBO8/PLLqveZO3cu8+fPZ/HixRw6dIjAwED69etXKh7kdtC6dWt0xdlk8nNH0el0bNq0iatXr9KoUaPyWJ5AILhNzJ8/n9GjR/Piiy/Spk0bFi5cSHBwMEuXLrU4ftmyZTRq1IiFCxfSpk0bXnzxRV544QXmzZunjFm4cCH9+vVj2rRptG7dmmnTptG3b99y6TWenp5OcnKyYlVLLO5ic3XvXi61asWslBR8CgvJu+ceOHoUZsxAn5ysKsbO19eXbdu2ER0dXUoAymVRtm3bJsqiCAQOolnkzZgxg3feeYcBAwbw3nvv8d///pcBAwYwY8YMZs6cWRFrVI772muv0aFDB1XjJUli4cKFvPnmmwwbNoz27duzZs0asrKy+Oqrrypsndbw8/OjTZs2yvOyiDwwZtm6u7uXdVkCgeA2kpeXx5EjR4iIiDDbHhERoYRylGT//v2lxvfv35/Dhw+TX1yiyNoYa3NqoWHDhmbu0yEDB9Js0ybqPPggPXJyyNbpuPHOO7gdOQIdOmiOsfP19bVa/qRhw4ZC4AkEZUBznbzHHnuMAwcOsGDBAjZt2oQkSbRt25aDBw/SuXPnilijQ8TFxXHlyhWzG5+7uzthYWHs27ePf/7zn7d9TV26dOHMmTMAdO/e/bYfXyAQVC4pKSkUFhaWyqyvV6+e0qawJFeuXLE4vqCggJSUFOrXr291jLU5wdhLOzc3V3meVlzWJD8/XxGPMoGBgezatYuhAwey8vx52v/5JwD7PT0J3rqVej16kF9UxOVLlxg4cCBJSUm0adOGLVu20KBBA3bt2sWgQYOIj4+nf//+bN26tVQIy52CfO4lr0F1oDqfG1Tv83P0nDSLPDCKlXXr1jl0wNuFfHOzdOO7ePGi1f203PhKYu8DNnr0aPbs2cOECRNo165dtfwglqQ6/9E5irgm5pTlelTVa2gaugEoGfdaxpfcrnXO2bNnM2PGjFLbd+zYgaenp8V9Zn7wAX5ffEHe7t2cfuEFkh98kOQbN2DLFrN5ZY4fP87x48dLbY+JiSEmJsbq2u4Edu7cWdlLqDCq87lB9Ty/rKwsh/ZzSOSVF9OnT7d4kzHl0KFDdO3a1eFj3I4bX0lsfcDkMjNbTG6KdwPV8Y+urIhrYo4j18PRG19lUadOHZydnUtZ2JKTk63WzQwMDLQ43sXFRSnDZG2MrVqc06ZNY9KkScrztLQ0goODiYiIoGbNmqXGJyYmMmjQIDKuXGH54sWMeP116v3yi2KtM50nIyPDoqXu8uXLeHt7W5z/TiE/P5+dO3fSr18/XF1dK3s55Up1Pjeo3ueXVqKAuFpUizwnJyeb4giMgqqgoED1wf/1r3/x1FNP2RzjUF9WUAoEX7lyhfr16yvby/vGZ0p1/oA5irgmpRHXxJyyXA9Hb3yVhZubG126dGHnzp08+uijyvadO3cydOhQi/v06NGDn376yWzbjh076Nq1q3K9evTowc6dO3nttdfMxliqhCDj7u5uMa7X1dW11Pug1+vp27cvsbGxtGnThtxatahXrx5nz56lb9++ZpmxtWvXtloD1KEWjJWEpetQXajO5wbV8/wcPR/VIs9WzaV9+/bxySefaG5xVqdOHerUqaNpH7U0bdqUwMBAdu7cqcQK5uXlER0dzZw5c6zup+XGZ43q+AErK+KalEZcE3McuR5V8fpNmjSJyMhIunbtSo8ePVi+fDkJCQmMHTsWMP7QTExM5MsvvwRg7NixLF68mEmTJvHSSy+xf/9+VqxYwddff63MOWHCBPr06cOcOXMYOnQoP/zwA7/88gt79uwp83pL1rLbsmULx48fZ8uWLYrwCw8PJzo6WvSPFQjuMFSLPEu/Mv/880+mTZvGTz/9xIgRI3jvvffKdXGmJCQkcP36dRISEigsLFTiOZo3b463tzdgzFidPXs2jz76KDqdjokTJzJr1ixatGhBixYtmDVrFp6enjzzzDMVtk6BQCCwxfDhw0lNTWXmzJkkJSXRvn17tmzZoli5kpKSzGrmNW3alC1btvDaa6/x6aefEhQUxKJFi3jssceUMT179uSbb77hrbfe4u2336ZZs2Zs2LCB+++/v8zrlWvZAURFRREYGMjx48dp0KABUVFRhIeHi1p2AsEdikMxeZcvX+bdd99lzZo19O/fn5iYGNq3b1/eazPjnXfeYc2aNcpz2Tq3e/duwsPDATh37hwGg0EZM2XKFLKzsxk3bhw3btzg/vvvZ8eOHeJmJBAIKpVx48Yxbtw4i6+tXr261LawsDCOHj1qc87HH3/crBtOeSHXsktPT6dhw4ZmyS5yLTsfHx9R6kQguAPRJPIMBgOzZs3ik08+oVOnTuzatYvevXtX1NrMWL16tcWbnykl3cU6nY7p06czffp0h48rz6km9ic/P5+srCzS0tKqpBupIhDXpDTimphTlush/11qDRURlMbWvU6n01GzZk3S0tJKvV9yrHJVi4+0RnX++6zO5wbV+/wcvdepFnlz585lzpw5BAYG8vXXX1sNEq5uyN0xSlZjFwgEdw7p6enCklRGxL1OILjz0Xqv00kqZaGTkxMeHh489NBDODs7Wx333XffqT54VaCoqIjLly/j4+NjN7tYzsTV6/V3dImA24m4JqUR18ScslwPSZJIT08nKCgIJyfNDXwEJqi911X3z291Pr/qfG5Qvc/P0Xudakves88+a1fkVEecnJw0Z4zVrFmz2n3Ayoq4JqUR18QcR6+HsOCVD1rvddX981udz686nxtU3/Nz5F6nWuTZi4cTCAQCgUAgENw5CP+GQCAQCAQCQTVEiLxyxN3dnXfffddiMeW7FXFNSiOuiTnielQtqvv7VZ3PrzqfG1T/83ME1YkXAoFAIBAIBIKqg7DkCQQCgUAgEFRDhMgTCAQCgUAgqIYIkScQCAQCgUBQDREiTyAQCAQCgaAaIkReObFkyRKaNm1KjRo16NKlC7///ntlL6nSmD17Nvfddx8+Pj4EBATwj3/8g3PnzlX2su4oZs+ejU6nY+LEiZW9lEolMTGRkSNHUrt2bTw9PenUqRNHjhyp7GUJbFAd73XTp09Hp9OZPQIDAyt7WQ7z22+/MWTIEIKCgtDpdGzatMnsdUmSmD59OkFBQXh4eBAeHs7p06crZ7EOYO/8nnvuuVLvZ/fu3StnsZWMEHnlwIYNG5g4cSJvvvkmx44do3fv3gwcOJCEhITKXlqlEB0dzSuvvMIff/zBzp07KSgoICIigszMzMpe2h3BoUOHWL58OR07dqzspVQqN27cIDQ0FFdXV7Zu3cqZM2f46KOP8PPzq+ylCaxQne917dq1IykpSXmcPHmyspfkMJmZmdxzzz0sXrzY4utz585l/vz5LF68mEOHDhEYGEi/fv2U/sV3OvbOD2DAgAFm7+eWLVtu4wrvICRBmenWrZs0duxYs22tW7eW3njjjUpa0Z1FcnKyBEjR0dGVvZRKJz09XWrRooW0c+dOKSwsTJowYUJlL6nSmDp1qtSrV6/KXoZAA9X1Xvfuu+9K99xzT2Uvo0IApO+//155XlRUJAUGBkoffPCBsi0nJ0fy9fWVli1bVgkrLBslz0+SJGnUqFHS0KFDK2U9dxrCkldG8vLyOHLkCBEREWbbIyIi2LdvXyWt6s7CYDAA4O/vX8krqXxeeeUVHn74YR566KHKXkql8+OPP9K1a1eeeOIJAgIC6Ny5M59//nllL0tghep+rzt//jxBQUE0bdqUp556itjY2MpeUoUQFxfHlStXzN5Hd3d3wsLCqsX7KBMVFUVAQAAtW7bkpZdeIjk5ubKXVCkIkVdGUlJSKCwspF69embb69Wrx5UrVyppVXcOkiQxadIkevXqRfv27St7OZXKN998w9GjR5k9e3ZlL+WOIDY2lqVLl9KiRQu2b9/O2LFjGT9+PF9++WVlL01ggep8r7v//vv58ssv2b59O59//jlXrlyhZ8+epKamVvbSyh35vaqO76PMwIEDWb9+Pb/++isfffQRhw4d4sEHHyQ3N7eyl3bbcansBVQXdDqd2XNJkkptuxv517/+xYkTJ9izZ09lL6VS0ev1TJgwgR07dlCjRo3KXs4dQVFREV27dmXWrFkAdO7cmdOnT7N06VKeffbZSl6dwBrV8V43cOBA5f8dOnSgR48eNGvWjDVr1jBp0qRKXFnFUR3fR5nhw4cr/2/fvj1du3alcePGbN68mWHDhlXiym4/wpJXRurUqYOzs3OpX0DJycmlfindbbz66qv8+OOP7N69m4YNG1b2ciqVI0eOkJycTJcuXXBxccHFxYXo6GgWLVqEi4sLhYWFlb3E2079+vVp27at2bY2bdpUiyD+6sjddK/z8vKiQ4cOnD9/vrKXUu7IWcN3w/soU79+fRo3blwt3097CJFXRtzc3OjSpQs7d+40275z50569uxZSauqXCRJ4l//+hffffcdv/76K02bNq3sJVU6ffv25eTJk8TExCiPrl27MmLECGJiYnB2dq7sJd52QkNDS5XW+euvv2jcuHElrUhgi7vpXpebm8vZs2epX79+ZS+l3GnatCmBgYFm72NeXh7R0dHV7n2USU1NRa/XV8v30x7CXVsOTJo0icjISLp27UqPHj1Yvnw5CQkJjB07trKXVim88sorfPXVV/zwww/4+Pgovxh9fX3x8PCo5NVVDj4+PqViEr28vKhdu/ZdG6v42muv0bNnT2bNmsWTTz7JwYMHWb58OcuXL6/spQmsUF3vdZMnT2bIkCE0atSI5ORk/vvf/5KWlsaoUaMqe2kOkZGRwYULF5TncXFxxMTE4O/vT6NGjZg4cSKzZs2iRYsWtGjRglmzZuHp6ckzzzxTiatWj63z8/f3Z/r06Tz22GPUr1+f+Ph4/vOf/1CnTh0effTRSlx1JVGpub3ViE8//VRq3Lix5ObmJt177713dbkQwOJj1apVlb20O4q7vYSKJEnSTz/9JLVv315yd3eXWrduLS1fvryylySwQ3W81w0fPlyqX7++5OrqKgUFBUnDhg2TTp8+XdnLcpjdu3dbvAePGjVKkiRjGZV3331XCgwMlNzd3aU+ffpIJ0+erNxFa8DW+WVlZUkRERFS3bp1JVdXV6lRo0bSqFGjpISEhMpedqWgkyRJuv3SUiAQCAQCgUBQkYiYPIFAIBAIBIJqiBB5AoFAIBAIBNUQIfIEAoFAIBAIqiFC5AkEAoFAIBBUQ4TIEwgEAoFAIKiGCJEnEAgEAoFAUA0RIk8gEAgEAoGgGiJEnqDSmD59Op06dbrtx42KikKn03Hz5s1ynbdJkybodDrVc8fHxyvjK+M6CAQCgaB6I0SeoEKQxYu1x3PPPcfkyZPZtWtXZS+1XJk5cyZJSUn4+vraHRscHExSUhKvv/76bViZQCC4G4iNjeWnn35Snm/atInXXnutElckqExE71pBhZCUlKT8f8OGDbzzzjtmzeg9PDzw9vbG29u7MpZXYfj4+BAYGKhqrLOzM4GBgdXuGggEgspj69atZGVlMWTIEABOnDjBPffcU8mrElQWwpInqBACAwOVh6+vLzqdrtS2ku7a5557jn/84x/MmjWLevXq4efnx4wZMygoKODf//43/v7+NGzYkJUrV5odKzExkeHDh1OrVi1q167N0KFDiY+PV73W1NRUnn76aRo2bIinpycdOnTg66+/NhuTnp7OiBEj8PLyon79+ixYsIDw8HAmTpxoc+6LFy8yZMgQatWqhZeXF+3atWPLli2q1yYQCASmvP7664qAK0l0dDRvvfUWn3/+OZ07dyY7O5sTJ07w119/0aNHDxo3bsyZM2du84oFlYkQeYI7il9//ZXLly/z22+/MX/+fKZPn87gwYOpVasWBw4cYOzYsYwdOxa9Xg9AVlYWDzzwAN7e3vz222/s2bMHb29vBgwYQF5enqpj5uTk0KVLF37++WdOnTrFmDFjiIyM5MCBA8qYSZMmsXfvXn788Ud27tzJ77//ztGjR+3O/corr5Cbm8tvv/3GyZMnmTNnjrDcCQTVFDU//MpKTEyM1RjesLAw2rdvz65duzh27BgeHh6cOHGC5s2bs3//fl566SUzV25FcDuugUA9QuQJ7ij8/f1ZtGgRrVq14oUXXqBVq1ZkZWXxn//8hxYtWjBt2jTc3NzYu3cvAN988w1OTk588cUXdOjQgTZt2rBq1SoSEhKIiopSdcwGDRowefJkOnXqREhICK+++ir9+/fn//7v/wCjFW/NmjXMmzePvn370r59e1atWkVhYaHduRMSEggNDaVDhw6EhIQwePBg+vTp4/D1EQgE1R9bP1CPHz9O586drb5+6dIlgoODAeOP4KKiIl544QUA3Nzc8PPzK9e1OoLaH+CCsiNEnuCOol27djg53fpY1qtXjw4dOijPnZ2dqV27NsnJyQAcOXKECxcu4OPjo8T4+fv7k5OTw99//63qmIWFhbz//vt07NiR2rVr4+3tzY4dO0hISACMgcz5+fl069ZN2cfX15dWrVrZnXv8+PH897//JTQ0lHfffZcTJ06oWpNAINBGUVERc+bMoXnz5ri7u9OoUSPef/99AHJzcxk/fjwBAQHUqFGDXr16cejQIbP9mzRpwsKFC822derUienTpwNGC9X48eOZMmUK/v7+BAYGKq+BMdwkOjqajz/+WEkwk8NGJEli7ty5hISE4OHhwT333MP//vc/Zd/w8HD+9a9/MWnSJOrUqUO/fv0snqNeryc1NVWx5N28eZMhQ4bQs2dPkpKSuHTpEg0aNFDGnzp1iq5du5o9b9eundVraG+d165dIzAwkFmzZinbDhw4gJubGzt27LB6Daydn73jydfm1VdfZeLEidSqVYt69eqxfPlyMjMzef755/Hx8aFZs2Zs3bpV9XncTQiRJ7ijcHV1NXuu0+ksbisqKgKMN/YuXboQExNj9vjrr7945plnVB3zo48+YsGCBUyZMoVff/2VmJgY+vfvr/zalCRJOa4p8nZbvPjii8TGxhIZGcnJkyfp2rUrn3zyiap1CQQC9UybNo05c+bw9ttvc+bMGb766ivq1asHwJQpU9i4cSNr1qzh6NGjNG/enP79+3P9+nVNx1izZg1eXl4cOHCAuXPnMnPmTHbu3AnAxx9/TI8ePXjppZdISkoiKSlJsai99dZbrFq1iqVLl3L69Glee+01Ro4cSXR0tNncLi4u7N27l88++8zi8WNiYvD19aVp06acPHmS++67j/r16xMVFUX9+vWJi4sjKChIGX/ixAmzH8knT56kffv2Vs/P3jrr1q3LypUrmT59OocPHyYjI4ORI0cybtw4IiIibF4DS+en5rrI+9apU4eDBw/y6quv8vLLL/PEE0/Qs2dPjh49Sv/+/YmMjCQrK0vTvHcFkkBQwaxatUry9fUttf3dd9+V7rnnHuX5qFGjpKFDh5qNCQsLkyZMmGC2rXHjxtKCBQskSZKk5cuXS7Vq1ZIMBoPq9ezevVsCpBs3bkiSJEmDBw+WXnjhBeX1wsJCqWXLlspa0tLSJFdXV+l///ufMsZgMEheXl5mazNdlzXeeOMNqUOHDmbbSl4HgUCgjbS0NMnd3V36/PPPS72WkZEhubq6SuvXr1e25eXlSUFBQdLcuXOVbZb+fu+55x7p3XfflSTJeC/q1auX2ev33XefNHXqVOW5pftVRkaGVKNGDWnfvn1m20ePHi09/fTTyn6dOnWye54zZ86U+vTpI61fv17y8/OTli1bZvb69evXpU6dOknt27eXzp49K40fP1764YcfJEmSpPz8fKl58+ZW51azTplx48ZJLVu2lEaMGCG1b99eys7OtnkNLJ2f2uOVvO4FBQWSl5eXFBkZqWxLSkqSAGn//v2azuNuQJRQEVRpRowYwYcffsjQoUOZOXMmDRs2JCEhge+++45///vfNGzY0O4czZs3Z+PGjezbt49atWoxf/58rly5Qps2bQBjWZRRo0YpGb4BAQG8++67ODk5lbLulWTixIkMHDiQli1bcuPGDX799VdlXoFAUD6cPXuW3Nxc+vbtW+q1v//+m/z8fEJDQ5Vtrq6udOvWjbNnz2o6TseOHc2e169fXwkdscaZM2fIyckp5YLNy8szi60zdataIyYmhpMnT/Kvf/2LzZs307NnT7PXa9WqxbFjx5TnH3/8sfJ/FxcXzp8/X+Z1AsybN4/27dvz7bffcvjwYWrUqGF37SXPT8vxTK+7HLJjaqGULbbJycma5r0bECJPUKXx9PTkt99+Y+rUqQwbNoz09HQaNGhA3759qVmzpqo53n77beLi4ujfvz+enp6MGTOGf/zjHxgMBmXM/PnzGTt2LIMHD6ZmzZpMmTIFvV5v9+ZWWFjIK6+8wqVLl6hZsyYDBgxgwYIFZTpngUBgjoeHh9XXJBvhFqbbnJycSoVg5Ofnmz23FTpiDfn1zZs3m8XLAbi7uyv/9/LysjkPGEXeY489xvr168u9Y4/adYIxTvny5csUFRVx8eLFUuLXEiXPT8vx7IXxyO9jUVGRpnnvBoTIE1Q4zz33HM8991yp7dOnTzcLXF69enWpMZYyZEvWwAsMDGTNmjWq1xMeHm52M/f392fTpk029/Hx8WH9+vXK88zMTGbMmMGYMWNs7ifi7wSCiqdFixZ4eHiwa9cuXnzxRbPXmjdvjpubG3v27FHidPPz8zl8+LBZqY+6deuaFXFPS0sjLi5O0zrc3NxKZd23bdsWd3d3EhISCAsL03hmt0hPTycuLo5x48YRGhrK008/zb59+2wmUmhB7Trz8vIYMWIEw4cPp3Xr1owePZqTJ08q1jRL16Asx6uo87hbECJPIFDBsWPH+PPPP+nWrRsGg4GZM2cCMHToULNxU6dO5a233iIxMdFua7OEhATatm1LXl4ebdu2rbC1CwTVnRo1ajB16lSmTJmCm5sboaGhXLt2jdOnTzN69GhefvllJdyiUaNGzJ07l6ysLEaPHq3M8eCDD7J69WqlePnbb7+Ns7OzpnU0adKEAwcOEB8fr2T6+/j4MHnyZF577TWKioro1asXaWlp7Nu3D29vb0aNGqVq7piYGJydnWnbti2dO3fm9OnTDBkyhIMHD1KnTh1N67SE2nW++eabGAwGFi1ahLe3N1u3bmX06NH8/PPPVq9BWY5XUedxtyBEnkCgknnz5nHu3Dnc3Nzo0qULv//+/+3cMYrCQBiG4W9B7ILaCFpZioVF8BhW9pI29mkiaJNC7ew8gKcQBBUvoFW6pMsFLNJltwvsIrguu8X+vk+fySTF8JIZcv60uJ5Op3J7x3Gch+O1221dLhdJr7mNAPym2WymSqWi+XyuLMvUarXk+74kablcqigKjcdj3W43DQYD7XY7NRqN8vowDJUkiYbDoWq1mqIoevpLXhAE8jxPvV5PeZ4rTVN1Oh1FUaRms6nFYqEkSVSv1+W6rqbT6bfHvl6v6na75VqxWq0Ux7FGo5H2+72q1epTc73n0TyPx6PW67UOh0N5HGa73arf72uz2Wgymdx9Bz+93189xyt5e/96CAEAAAD/Hv/JAwAAMIjIAwAAMIjIAwAAMIjIAwAAMIjIAwAAMIjIAwAAMIjIAwAAMIjIAwAAMIjIAwAAMIjIAwAAMIjIAwAAMIjIAwAAMIjIAwAAMOgDB/s2jUHWGAAAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAnkAAAHWCAYAAAALq58HAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdd1hT1xsH8G8IhC0yZClLUVwoCg5cgAPcWvcWcdRqXbhr3QO1bq2rVdyz7g1VwIUDhTrqFgUFHIiAzJCc3x8090dM2AlhvJ/nySO5Obn3zTG5eXPuGTzGGAMhhBBCCClX1FQdACGEEEIIUTxK8gghhBBCyiFK8gghhBBCyiFK8gghhBBCyiFK8gghhBBCyiFK8gghhBBCyiFK8gghhBBCyiFK8gghhBBCyiFK8gghhBBCyiFK8sqB27dv44cffoC1tTU0NTVhZmYGV1dXTJ06Vaqcu7s7eDweeDwe1NTUoK+vD3t7e/Tt2xd//fUXxGKx3P2npKRg+fLlaNSoEfT09KCrqwsnJycsW7YMKSkpMuVtbW2543x/+/btW66v482bNzLlK1WqhIYNG2LdunUQiURFqp8FCxaAx+PJ1IW7u3u+z83MzMTYsWNhYWEBPp8PJyenIsWgKJs3b8auXbtktkvqTt5jhJSEDRs2gMfjoX79+sXe1/nz57FgwYLiB1XGFfQ8JU9pPFdIzsXybps2bSrxeHIqjfWlCOqqDoAUz7lz59C9e3e4u7tj5cqVsLCwQGxsLMLCwnDo0CGsXr1aqnz16tWxf/9+ANnJW2RkJE6ePIm+ffuidevWOHPmDAwMDLjyHz58QPv27fHq1StMnDgRK1euBABcuXIFS5YswcGDB/H333/DzMxM6jgtW7bEqlWrZOLV0dHJ9zVNmDABgwYNAgB8/foVp0+fxpQpUxAdHS3zepRty5Yt2LZtGzZu3AhnZ2fo6emV6PG/t3nzZpiYmMDb21tqu4WFBUJDQ1GjRg3VBEYqvJ07dwIAHj9+jNu3b6NZs2ZF3tf58+fx+++/U6JXDKX5XHHx4kWp7xkAsLOzU1E02UpzfRUHJXll3MqVK2FnZ4dLly5BXf3//50DBgzgErKctLW10bx5c6lto0aNgr+/P3x8fDBmzBgcPnyYe2zYsGF4+vQpgoKC0KpVK257hw4d0KVLF3h4eGD48OG4ePGi1D4rV64sc5yCsra2lnpux44d8ejRIxw8eLDEk7xHjx5BW1sbP//8c4ket7A0NTWLXN+EFFdYWBj++ecfdOnSBefOncOOHTuKleSVZUKhEDweT+p8LJGamlqgH7rKVBrOFc7OzjAxMVFpDAVVGuqrOOhybRkXHx8PExMTuScUNbWC//eOGDECnTt3xtGjR/H27VsA2SfugIAAjBw5UirBk2jVqhV8fHxw6dIl3Lt3r+gvogAMDAygoaEhs/3w4cNwdXWFrq4u9PT04OXlhfDwcIUck8fj4c8//0RaWhp3SWHXrl15Nt/zeDyp1gfJ5YnHjx9j4MCBMDAwgJmZGXx8fJCYmCj1XLFYjI0bN8LJyQna2tpconz69GkA2ZfBHz9+jJCQEC4eW1tbALlfUrh+/TratWsHfX196OjooEWLFjh37pxUmV27doHH4yEoKAg//fQTTExMYGxsjF69eiEmJqbY9UjKvx07dgAAli9fjhYtWuDQoUNITU2VKhMcHAwej4fg4GCp7d+/d729vfH7778DgNTlvDdv3gAA0tPTMXv2bNjZ2UEgEKBq1aoYP348vn79WuB4nz59ioEDB8LMzAyampqwtrbGsGHDkJGRwZV59OgRevToAUNDQ2hpacHJyQm7d++W+5r27t2LqVOnomrVqtDU1MTLly/h7e0NPT09PHz4EJ6entDX10e7du0AZHcDWbJkCWrXrg1NTU1UqVIFI0aMwKdPn/KNfeHChWjWrBmMjIxQqVIlNG7cGDt27ABjjCtTVs8VdG5VPEryyjhXV1fcvn0bEydOxO3btyEUCou8r+7du4MxhmvXrgEAAgMDAQA9e/bM9TmSxyRlJRhjyMrKkrrl1ufve2KxmHtOfHw8du7ciYsXL2Lo0KFS5ZYtW4aBAweibt26OHLkCPbu3Yvk5GS0bt0a//77bwFfde5CQ0PRuXNnaGtrIzQ0FKGhoejSpUuR9tW7d2/UqlULx44dw6xZs3DgwAFMmTJFqoy3tzcmTZqEJk2a4PDhwzh06BC6d+/OfbmdOHEC1atXR6NGjbh4Tpw4kesxQ0JC0LZtWyQmJmLHjh04ePAg9PX10a1bN6nWWolRo0ZBQ0MDBw4cwMqVKxEcHIwhQ4YU6fWSiiMtLQ0HDx5EkyZNUL9+ffj4+CA5ORlHjx4t0v7mzp2LPn36AAD3Pg8NDYWFhQUYY+jZsydWrVqFoUOH4ty5c/D19cXu3bvRtm1bqSQtN//88w+aNGmCW7duYdGiRbhw4QL8/PyQkZGBzMxMAMCzZ8/QokULPH78GBs2bMDx48dRt25deHt7y71CMnv2bERFRWHr1q04c+YMTE1NAWQnc927d0fbtm1x6tQpLFy4EGKxGD169MDy5csxaNAgnDt3DsuXL0dgYCDc3d2RlpaWZ/xv3rzBjz/+iCNHjuD48ePo1asXJkyYgMWLF3NlSvu5QiQSSX03FLW/NUDn1nwxUqZ9/vyZtWrVigFgAJiGhgZr0aIF8/PzY8nJyVJl3dzcWL169XLd14ULFxgAtmLFCsYYY2PHjmUA2NOnT3N9zpMnTxgA9tNPP3HbbGxsuHhy3ubMmZPna4mMjJT7PADM29ubZWVlcWWjoqKYuro6mzBhgtQ+kpOTmbm5OevXrx+3bf78+ez7t7qbmxtzc3PLMx7GGBs+fDjT1dWVG6e/v79MeQBs/vz5MsdeuXKlVLlx48YxLS0tJhaLGWOMXb16tUB1VK9ePblxy4upefPmzNTUVOp9kJWVxerXr8+qVavGHdvf358BYOPGjZPa58qVKxkAFhsbm2dMpGLbs2cPA8C2bt3KGMv+DOrp6bHWrVtLlQsKCmIAWFBQkNR2ee/d8ePHy3xmGWPs4sWLcj9Phw8fZgDY9u3b8423bdu2rHLlyuzjx4+5lhkwYADT1NRkUVFRUts7derEdHR02NevX6VeU5s2bWT2MXz4cAaA7dy5U2r7wYMHGQB27Ngxqe13795lANjmzZu5bfmdp0QiERMKhWzRokXM2NiY+0wzVjrPFZLz4fe3qlWr5hqbBJ1bi4Za8so4Y2NjXLt2DXfv3sXy5cvRo0cPPH/+HLNnz4ajoyM+f/5c4H2xHM39hX3O96NXW7Vqhbt370rdxo0bV6B9Tpo0iXtOUFAQli1bhiNHjmDgwIFcmUuXLiErKwvDhg2T+kWopaUFNzc3mUtCqta9e3ep+w0aNEB6ejo+fvwIALhw4QIAYPz48Qo5XkpKCm7fvo0+ffpIDRbh8/kYOnQo3r17h2fPnuUbIwDu8j0h8uzYsQPa2toYMGAAAEBPTw99+/bFtWvX8OLFC4Ue68qVKwAg0zm+b9++0NXVxeXLlwHIv5IAZPeJCwkJQb9+/VClSpU8j9OuXTtYWVlJbff29kZqaipCQ0Oltvfu3TvXfX3/2NmzZ1G5cmV069ZNKj4nJyeYm5vne+66cuUK2rdvDwMDA/D5fGhoaGDevHmIj4/nzieFoYpzxd9//y313XD+/PlCx51XLHRu/T8aeFFOuLi4wMXFBUB2x9+ZM2di7dq1WLlypdzLC/JI3nCWlpYAsgdAAEBkZCQcHBzkPkfS3P39ydDAwICLp7CqVasm9VzJ1C+zZ8/GpUuX4OXlhQ8fPgAAmjRpIncfhemPWBKMjY2l7mtqagIAd2nm06dP4PP5MDc3V8jxEhISwBiDhYWFzGOS/9/4+PhCxUjI916+fImrV6+id+/eYIxx/eL69OkDf39/7Ny5E35+fgo7Xnx8PNTV1WUSNB6PB3Nzc+49HRISAg8PD6kykZGR0NDQgEgkQrVq1fI9TmE+O/LKAtmzCVSqVElq24cPH/D161cIBAK5z8nrh/mdO3fg6ekJd3d3/PHHH6hWrRoEAgFOnjyJpUuXFumzqopzRcOGDRU28ILOrXmjJK8c0tDQwPz587F27Vo8evSowM87ffo0eDwe2rRpAyB7BO0vv/yCkydPomPHjnKfc/LkSa6sMkl++fzzzz/w8vLiThB//fUXbGxslHrs72lpaQGATP+f7z/YhVGlShWIRCLExcXl+oVRGIaGhlBTU0NsbKzMY5IOv2VldBspvXbu3AnGGP766y/89ddfMo/v3r0bS5YsAZ/Pz/VzU5irDcbGxsjKysKnT5+kEj3GGOLi4rgffc7Ozrh7967Ucy0tLSESicDn8/Hu3bt8j1OYz873VzLy2i7pfP/9jAQS+vr6ucZ16NAhaGho4OzZs1x9Av8/DxdFaTpX0LlV8UpXcwcpNHlvNAB48uQJgP//ssiPv78/Lly4gIEDB3IteC4uLvD09MSOHTtw48YNmedcv34dO3fuRMeOHeHs7FzEV1AwERERAMB1aPby8oK6ujpevXrFtWJ+f1MWMzMzaGlp4cGDB1LbT506VeR9durUCUD2vHx50dTULNCvP11dXTRr1gzHjx+XKi8Wi7Fv3z5Uq1YNtWrVKnK8hIhEIuzevRs1atRAUFCQzG3q1KmIjY3lLpdJRit+/7mRjHDMKbeWDsno1H379kltP3bsGFJSUrjH9fX1Zc4HAoEA2tracHNzw9GjR/NMLtu1a4crV67IjIDcs2cPdHR0ijWlRteuXREfHw+RSCT3vJXbVRMA3NQsfD6f25aWloa9e/fKlC2L5wo6tyoeteSVcV5eXqhWrRq6deuG2rVrQywWIyIiAqtXr4aenh4mTZokVT4tLQ23bt3i/n79+jVOnjyJs2fPws3NDVu3bpUqv2fPHrRv3x6enp6YOHEidxK9cuUK1q9fj9q1ayt8JvCoqCguxpSUFISGhsLPzw82Njbo1asXgOwvjEWLFmHOnDl4/fo1OnbsCENDQ3z48AF37tyBrq4uFi5cqNC4JHg8HoYMGYKdO3eiRo0aaNiwIe7cuYMDBw4UeZ+tW7fG0KFDsWTJEnz48AFdu3aFpqYmwsPDoaOjgwkTJgAAHB0dcejQIRw+fBjVq1eHlpYWHB0d5e7Tz88PHTp0gIeHB6ZNmwaBQIDNmzdzcw7m1vpASEFcuHABMTExWLFihdxVGerXr49NmzZhx44d6Nq1K8zNzdG+fXv4+fnB0NAQNjY2uHz5Mo4fPy7zXMl7esWKFejUqRP4fD4aNGiADh06wMvLCzNnzkRSUhJatmyJBw8eYP78+WjUqJHMCHx51qxZg1atWqFZs2aYNWsW7O3t8eHDB5w+fRrbtm2Dvr4+5s+fj7Nnz8LDwwPz5s2DkZER9u/fj3PnzmHlypUyE/kWxoABA7B//3507twZkyZNQtOmTaGhoYF3794hKCgIPXr0wA8//CD3uV26dMGaNWswaNAgjBkzBvHx8Vi1ahWXFH9fh2XtXEHnViVQ+tAOolSHDx9mgwYNYjVr1mR6enpMQ0ODWVtbs6FDh7J///1Xqqybm5vUiCZdXV1WvXp11qdPH3b06FEmEonkHuPbt29s2bJlzMnJieno6DAdHR3WoEEDtmTJEvbt2zeZ8jY2NqxLly6Ffi3yRtdqaWmxWrVqscmTJ8sdiXTy5Enm4eHBKlWqxDQ1NZmNjQ3r06cP+/vvv7kyih5dyxhjiYmJbNSoUczMzIzp6uqybt26sTdv3uQ6AuzTp09Sz5eMuoqMjOS2iUQitnbtWla/fn0mEAiYgYEBc3V1ZWfOnOHKvHnzhnl6ejJ9fX0GgNnY2EjV3fej0q5du8batm3LdHV1mba2NmvevLnU/nLGcvfuXantuY2GJIQxxnr27MkEAkG+o1TV1dVZXFwcY4yx2NhY1qdPH2ZkZMQMDAzYkCFDWFhYmMx7NyMjg40aNYpVqVKF8Xg8qc9KWloamzlzJrOxsWEaGhrMwsKC/fTTTywhIaHAsf/777+sb9++zNjYmAkEAmZtbc28vb1Zeno6V+bhw4esW7duzMDAgAkEAtawYUOZz5fkM3L06FGZY+R27mCMMaFQyFatWsUaNmzItLS0mJ6eHqtduzb78ccf2YsXL7hy8s5TO3fuZA4ODkxTU5NVr16d+fn5sR07dsicT0rjuSK382FOdG5VLB5jRRhSSQghhBBCSjXqk0cIIYQQUg5RkkcIIYQQUg5RkkcIIYQQUg5RkkcIIYQQUg5RkkcIIYQQUg5RkkcIIYQQUg7RZMj5EIvFiImJgb6+fuma4JAQAsYYkpOTYWlpqfD1ij98+IBp06bh8uXL+PjxI76fbUokEin0eKpG5zpCSq+inusoyctHTEwMrKysVB0GISQP0dHR+S46X1je3t6IiorC3LlzYWFhUe4THzrXEVL6FfZcR0lePiSLRUdGRsLIyEjF0ZQNQqEQAQEB8PT0hIaGhqrDKTOo3grvy5cvsLOzy3NR96K6fv06rl27BicnJ4XvuzSS1GF0dDQqVaqUazl6nyoO1aViVIR6TEpKgpWVVaHPdZTk5UPy611fXz/PEx/5P6FQCB0dHVSqVKncfuCUgeqt8IRCIQAopZXNyspK5hJteSapw0qVKuWb5NH7VDGoLhWjItVjYc91FWLgxebNm2FnZwctLS04Ozvj2rVrqg6JEFLKrVu3DrNmzcKbN29K9LhXr15Ft27dYGlpCR6Ph5MnT+b7nJCQEDg7O0NLSwvVq1fH1q1blR8oIaTUK/dJ3uHDhzF58mTMmTMH4eHhaN26NTp16oSoqChVh0YIKcX69++P4OBg1KhRA/r6+jAyMpK6KUtKSgoaNmyITZs2Fah8ZGQkOnfujNatWyM8PBy//PILJk6ciGPHjiktRkJI2VDuL9euWbMGI0eOxKhRowBk/zq/dOkStmzZAj8/PxVHRwgprdatW6eS43bq1AmdOnUqcPmtW7fC2tqai7dOnToICwvDqlWr0Lt3byVFSQgpC8p1kpeZmYl79+5h1qxZUts9PT1x8+ZNuc/JyMhARkYGdz8pKQlA9jV/Sf+fiogxhjlz5uDt27fo1q0bTExM0K5dO7n9AyT1VJ7qi3f1KtTWrIF4/HiwDh2UcozyWG/Kpsy6Gj58uNL2rUihoaHw9PSU2ubl5YUdO3ZAKBTm2kepqOe6n376CZcvXwaPxytUMkpk0WdeMSpCPRb1tZXrJO/z588QiUQwMzOT2m5mZoa4uDi5z/Hz88PChQtltgcFBUFHR0cpcZYFr169wqpVqwAAR48eBQAMGTIEffr0yfU5gYGBJRKbsml/+IB2EyZALTMTuHgRwevXI1mJU02Ul3orCampqUrdv0gkwsmTJ/HkyRPweDzUrVsX3bt3B5/PV+pxCyMuLk7uOS4rKwufP3+GhYWF3Ofldq4LCAjI81x39+5dvHnzBsHBwRVqYIoy0WdeMcpzPRb1XFeukzyJ71ubGGO5jlCZPXs2fH19ufuSYcseHh4wNjZWapyl2dSpU2W2HTp0CKtXr4ahoaHUdqFQiMDAQHTo0KFcjHRS27YN/MzM7L/FYrglJUHcubPCj1Pe6q0kxMfHK23fL1++ROfOnfH+/Xs4ODiAMYbnz5/DysoK586dQ40aNZR27MKSd46Ttz2n3M51np6eeY6u/f333wEAUVFRqF27NqpXr16c0Cs0+swrRkWoR0lLe2GV6yTPxMQEfD5fptXu48ePMr98JTQ1NaGpqSmzXUNDo9y+eQriwoULAIBTp06hQ4cOqFevHiIjI/Ho0SO0bdtW7nPKTZ2Fh2f/q6UFpKeDf/s2+Ep8XeWm3kqAMutp4sSJqFGjBm7dusUNtIiPj8eQIUMwceJEnDt3TmnHLgxzc3O55zh1dfU8f5gW9VwnEAgAAMeOHcOxY8eoNU8B6DOvGOW5Hov6usr16FqBQABnZ2eZJtzAwEC0aNFCRVGVPV++fMHLly8BAK1bt4a2tjYaNWoEAAiXJEDl2d272f9OnJj9b2goQF9s5V5ISAhWrlwpNZLW2NgYy5cvR0hIiAojk+bq6ipzjgsICICLi4tSvvDK65coIeVRuU7yAMDX1xd//vkndu7ciSdPnmDKlCmIiorC2LFjVR1amXHnzh0AQK1atbhLsxUmyUtLAx4/zv77xx8BgQD49An4L+kl5ZempiaSk5Nltn/79o1rzVKGb9++ISIiAhEREQCyp0iJiIjgpn2aPXs2hg0bxpUfO3Ys3r59C19fXzx58gQ7d+7Ejh07MG3aNKXE932SRy15hJRe5T7J69+/P9atW4dFixbByckJV69exfnz52FjY6Pq0MqM27dvAwCaNm3KbWvcuDGA7KWfxGKxSuIqEY8fA2IxYGIC2NkBLi7Z20NDVRsXUbquXbtizJgxuH37NhhjYIzh1q1bGDt2LLp3766044aFhaFRo0bcDylfX180atQI8+bNAwDExsZKzfNpZ2eH8+fPIzg4GE5OTli8eDE2bNigtOlTvu/nZ2pqigcPHijlWISQ4inXffIkxo0bh3Hjxqk6jDJL0pLXrFkzbpu7uzsMDAzw9u1bXLlyBe3bt1dVeDK+fv2KP/74A+np6ejfvz9q1apV9J09fJj9r6MjwOMBLVoAN29m33K0ppDyZ8OGDRg+fDhcXV251qusrCx0794d69evV9px3d3d82wd27Vrl8w2Nzc33L9/X2kx5fR9kvf582eMGjWKO08QQkqPCpHkkaJjjMltydPR0cGQIUPw+++/Y/Xq1aUmyROJRPDy8uK+cHbs2IHIyMiir236X5L3pVo17F2/Ht0tLGAHAH//nd0vTwlrppLSoXLlyjh16hRevHiBp0+fgjGGunXrwt7eXtWhqZSamuwFoPI8PxkhZVm5v1xLiicyMhLx8fEQCARo2LCh1GNTpkwBn8/HxYsXcVcyOEHFfv/9d6kWhbdv3+Kff/4p+g7/6xf1y8GDmDx5MhrNmAGRtjbw6hVQijrfE+WpWbMmunXrhu7du1f4BA+QPy1LVlaWCiIhhOSHWvJInlavXg0AcHZ2lpluoUaNGujRoweOHz+OK1euoEmTJqoIkfP582fMmTMHQPZST+fPn8fp06dx/vx5ODk5FX6HHz4AV68CAIL++xJLFIkQYGKCTtHRwP79gLu7gqInpYGvry8WL14MXV1dqTnk5FmzZk0JRVW6yGvJoySPkNKJWvJIrhISErB161YAwKJFi+SWkfTTK6n+QHm5fv06vn37BgcHB4wePRqd/5uw+Pz580Xb4aFDgEiEu3w+ngPYtm0beDweNkZHZz9+5YpiAielRnh4OHfpMTw8PM9bRSWvJe/p06dy+woSQlSLWvJIrh48eACxWAwbG5tc+9xJRtmWhiRPMuWEq6sr1NTUuHU1Q0ND8eXLF6n5zgrkv/54Z0Ui2NraYtSoUbh06RICjh+HiMcD//Vr4O1bgEZqlxtBQUFy/yb/J68lDwBGjBgBb2/vkg2GEJInaskjuXr4X5LToEGDXMtIpnl4+fIlYmNjSySu3Ej63kkuzVpbW8PR0RFisRinTp0q9P7EMTEAgPcAvL29oaamhhkzZuAbgDDJ6MdbtxQQOSmNfHx85M6Tl5KSAh8fHxVEVDoUeRATIaTEUZJHciWZ+8rR0THXMsbGxtzqIb/99luJxCUPY4xrTcw5QGTQoEEAgMWLFyPzv/VnC+rzf0luko4ORo8eDSD78vSsWbMgmQpZ9OZN8QInpdbu3buRlpYmsz0tLQ179uxRQUSlQ24teQCQnp5egpEQQvJDSR7JleTyZ15JHgBusMOePXtUNvt9SEgIoqKioK2tzV1CBoAJEybAzMwMkZGRhW7NU//0CQDQZfRoWFpactvnzp2Lrzo6AIDIa9cUED0pTZKSkpCYmAjGGJKTk5GUlMTdEhIScP78eZiamqo6TJXJqyVPW1sbAQEBJRgNISQvlOQRuT58+ICwsDAAQKtWrfIs2759e2hrayM+Ph5Pnz4tifBkbNq0CUB2v6BKlSpx23V1dblWuO3btxd8h1lZqJyRAQCo7eEh9ZCOjg5M/7tMnfLiRXHCJqVQ5cqVYWRkBB6Pxy3lJ7mZmJjAx8cH48ePV3WYKpPf5dphNEk4IaUGDbwgMsRiMcaPHw/GGJo0aYJq1arlWV4gEKBZs2YIDg7GtWvXSnwusYyMDFy8eBEAMHLkSJnHR44ciSVLluDy5cuIjY2FhYVFvvv8+OgRTAGIANSTM02KiZMTcOMG+Cruh0gULygoCIwxtG3bFseOHZMasCMQCGBjYyPVslvR5HW5Fsj+PBJCSgdqySMyDhw4gGPHjgFAgUfLtWnTBgDwxx9/lPicWVevXkVKSgosLCy4gSA52drawtXVFYwx/PXXXwXa56PAQADAZ3V16BkYyO7zv9ZN/eRkfP78uRjRk9LGzc0N7u7uiIyMRI8ePeDm5sbdXF1dK3SCB+Tfkvf161euqwchRLUoySMyDhw4AAAYOHAgfvrppwI9Z8yYMTAwMEBYWBgmTZpUon3zzp07BwDo3Llzrl9A/fr1AwD4+/vnG9vnz5+xZ9kyAECmsbHcMjaurgAASwB9evVSWV9Eojw2NjZQU1NDamoqnj59igcPHkjdKqr8WvKA7FH3IpGoBKIhhORF4UnekydP4O/vT7/kyqj4+HgE/teKNX/+/AJPl1C1alXs3LkTPB4Pf/zxB3f5tCRIkrwuXbrkWmbo0KHQ0tJCeHg4bty4kef+unXrhmpfvwIA9HKs15uTWtWqYOrq0ADw7do1hNASZ+XOp0+f0LVrV+jr66NevXpo1KiR1K2iKug5obCj2QkhilesJG/RokVS02YEBQXByckJ06dPR5MmTbB///5iB0hK1okTJ5CVlYWGDRvCwcGhUM/t1asX937Yu3cvvn37powQpTx69AgvX76EhoZGrhM2A9lTvQwcOBAAcn1fMsawYsUK3Lp1C07/bTN0c5O/Q3V18Pr3BwAsALBixYqivQBSak2ePBkJCQm4desWtLW1cfHiRezevRs1a9bE6dOnVR2eyhSkJQ8At3IIIUR1ipXk/fXXX6hbty53f+nSpZg4cSI+f/6MTZs2Ydl/l7xI2RAeHo5p06YBAPr/l8AU1pQpU2Bvb4/U1FQcPHhQkeHJJVluTdLikhfJazpx4oTcS0mHDh3CrFmzUAlAH8nGvNa8/W/qmA4AQi5exM2bNwsXPCnVrly5grVr16JJkyZQU1ODjY0NhgwZgpUrV8LPz0/V4akMteQRUnYUKcnbs2cPdu/ejTdv3iAiIoK7f+PGDejp6WHPnj0Qi8V4/fo19uzZU6EnDi0rPn/+jK5duyIxMRGmpqZFngZBTU0NP/74IwBgy5YtSu2r9vHjR24gxcKFC/Mt7+HhgcqVK+PDhw8yc3kxxrBq1SoAgNTQjBwTK8uoXRuoWhWaAJoD6Nu3b4m0XpKSkZKSws2HZ2RkhE//zZvo6OhYKpbxU5WCJnl9+vSp0H0XCSkNipTk2djYwNbWFgKBAGZmZrCxscHXr19RqVIleHh4wMbGBjVq1ACPx4OtrS1saG3PUm/RokWIiYmBg4MDHj58iKpVqxZ5X8OGDYOmpiYePXqETZs2IS4uToGR/t/Zs2fBGIOzs3O+EzYD2dNfjBgxAgAwffp03L9/n0tCX716hfv370NbQwPttbSyn/Djj4CJSe475PGA/6ZX6WlggJiYGBw5cqRYr4mUHg4ODnj27BmA7KXytm3bhvfv32Pr1q0FmoanvCro5dqQkBDMnj1bydEQQvJSpCRPMp1A48aNce7cOQgEAly8eBGdO3dGmzZt4ObmBgsLC1hZWXH3Sekl+eICgN9//73Ys/kbGhqiXbt2AICJEyeiZcuWSumfc+jQIQBA9+7dC/ycKVOmQFtbG48fP4azszM2bNgAALj13xq0PerWBS89HdDVBX7/Pf8d/jd1TPf/ksE///yzMC+BlGKTJ0/m1mOeP38+Ll68CGtra2zYsKFCd0UpzNq158+fV2IkhJD8FKtP3m+//Ybw8HC0bNkSb9++5fpHAcCuXbvQsWPHYgdIlG/Tpk0QCoVo3bo1l5wV14ABA2DyX+Lz+vVrnDlzRiH7lQgODkZgYCDU1dUxePDgAj/PysoKJ06c4O7/+uuvePToEZfkTZEko46OAJ+f/w7/m0rFOi4OmurqCA0N5VYKIWXb4MGDuXkiGzVqhDdv3uDu3buIjo4ucp/V8qAwSR4hRLWKleQ1bNgQb968wadPn/Dvv//CysqKe2zatGkV+tduWZGSkoJt27YBAKZOnaqw/VaqVAlhYWHo0aMHgOz+eYqQmJiI0NBQTJ8+HQDw448/okaNGoXah5eXF0QiEVq2bIlv377B0dER/v7+8ALQ9N9/swvlNeAip7p1AT09qKWkwNfLCwCwfv36QsVDygYdHR00btyY+/FSURU2yWvbti3EYrGSoiGE5EUhy5oZy5kwtiL3WSkLGGPYtGkTFi9ejISEBNjb26Nr164KPYalpSXWrVuH06dP4++//8bz589Rq1atIu/v77//xqhRo/D27VsAgJ6eHubNm1ekfampqeH06dNo1qwZXr58idTUVPQxNAQSErIL/Lfebb74fKB5c+DvvzHe1hZ+AA4fPgw/P798l4MjpY+vr2+By65Zs0aJkZReBe2TJxEUFITXr1+X+HKHhBAlrl0bFhaG1NRUbrkrUroEBwdj4sSJ3P3p06eDX5DLk4Vka2uLzp0749y5c9i+fTtGjBiBWrVqQUNDo1D7uXr1Kjp06CC1be3atcXqP2hkZIStW7eiW7ducHV1xfC0NCA0FNixA2jcuOA7GjIE+PtvVD1zBm1atsTVGzfg6emJgIAASvTKmPDw8AKVq8iXLIvy2mk9W0JUQ2lJ3tChQ/H8+XNa2qaUklyiBbIn8h1d0JarIvjxxx9x7tw5rF69GqtXr4arqysuX74MbW3tAu9j7969ALITs6VLl8Lc3Bw9e/Ysdmzt2rXDp0+foKupCUjWqG3evHA76d8fmDgRiIrCng0b0OrtWzx58gQdO3ZEREQE1NWV9jEjChYUFKTqEEq9wrbkASjx9awJIdmUtnbt5cuX8fr1a2XtnhRDREQEN9VHeHg4ZsyYodSWiU6dOkn1mwsNDcUff/xR4OdnZmbi2LFjALIn4B47dqxCEjwJXV1dICoKSE0FNDWz578rDC0truXP5ssXXL9+HcbGxnj8+DEWLVqE1NRUhcVKSt7Lly9x6dIlpKWlAUCJrVO8efNm2NnZQUtLC87Ozrh27VquZYODg8Hj8WRuT58+VXhcRTlXODk5YfXq1QqPhRCSN6UleZaWljQ/Xin06dMn9O3bF4wxDBgwAE4FHWBQDOrq6rh8+TJ++ukn7j1x4cIFANm/8JOTk/N8fkBAABISEmBhYaG8y//v3mX/a2UFFKGlApK1TMPDYWNjg7lz5wIAFi9ejHr16nFTcZCyIz4+Hu3atUOtWrXQuXNn7v9w1KhRCh2kJM/hw4cxefJkzJkzB+Hh4WjdujU6deqEqKioPJ/37NkzxMbGcreaNWsqPLai/iCUrKZDCCk5xU7y+Hw+Pn78KLM9Pj5eKX28SPHMnDkTL1++hJ2dHdauXVtix7WxscHmzZu5qVQuXryI4cOHw87ODpaWlrkuCfbvv/+iW7duAIB+/fop7z0lSfKK2odO0ofvv5UQJkyYgJUrVwIA3rx5A0tLS5w6daq4UZISNGXKFGhoaCAqKgo6Ojrc9v79++PixYtKPfaaNWswcuRIjBo1CnXq1MG6detgZWWV7yh1U1NTmJubczdlfF6KcrmWEKIaxf605nbpIiMjAwKBoLi7Jwpy8uRJ1KtXD/7+/gCAAwcOwNzcvMTjqF+/PjcYYc+ePXj37h2+ffuGXr16ITo6miuXmJiIjx8/YtSoUdw2yZxlSlHcJM/ZOfvf+/cBoRBqamqYPn06AgMDuSLjxo0rd+t5fvv2rdwu5RYQEIAVK1bIDJ6pWbMmN8JbGTIzM3Hv3j14enpKbff09Mx3feRGjRrBwsIC7dq1U1r/wuJ07civ1Z4QolhF7hEuWSmAx+Phzz//hJ6eHveYSCTC1atXUbuwfZuIUuzfvx/Dhw/nBsH4+vqieWEHFygIj8fD6dOn4e/vj71796Jjx464d+8eXrx4AScnJ4wbNw4ODg7w9vbm4uXxeAgLC1PupeXiJnkODoBkCpbwcKBpUwBA+/btcfDgQQwcOBAxMTE4cOCAcpPVEpSZmYlmzZrh9evX2L17N/r166fqkBQqJSVFqgVP4vPnz9DU1FTacT9//gyRSAQzMzOp7WZmZrkuEWhhYYHt27fD2dkZGRkZ2Lt3L9q1a4fg4OBcuzhkZGRIjXpNSkoCAAiFwjxXqClOn8SqVavi+fPncqfdqogk9ayMFYEqkopQj0V9bUVO8iSX+hhj2Lp1q9RlAYFAAFtbW26pLGVYunQpzp07h4iICAgEAnz9+lWmTFRUFMaPH48rV65AW1sbgwYNwqpVqypUC+OmTZswYcIEANm/8qdNm4aBAweqNKZGjRqhUaNGWL9+PXg8Ht68eYOuXbvi8ePHWLJkiUz5yZMno3FhpjQpipx98opCTQ1o2RI4exa4cYNL8oDs1T+io6MxY8YMjBgxAkZGRoVaiq20OnLkCP79b/Lo/v374/Hjx5g2bRr09fVVHJlitGnTBnv27MHixYsBZP/YEIvF+O233+Dh4aH043/fYsYYy7UVzcHBAQ4ODtx9V1dXREdHY9WqVbkmeX5+fli4cKHM9oCAALnJrURxBtQlJydjw4YNaNasWZH3UR7lbPEnRVee67GoA/iKnORFRkYCADw8PHD8+HEYGhoWdVdFkpmZib59+8LV1RU7duyQeVwkEqFLly6oUqUKrl+/jvj4eAwfPhyMMWzcuLFEY1WVyMhITJkyBUB2orR69epS1Z9G8oVla2uLiIgIDBs2DAcPHuQe19DQgL29vdwvIoUrbkse8P8kLzQU+K/eJcaMGYMlS5YgKSkJPXr0wOLFi/Hrr78WI2DVk1z6l1i0aBGuXbuG8+fPQ0tLS0VRKc5vv/0Gd3d3hIWFITMzEzNmzMDjx4/x5csX3LhxQ2nHNTExAZ/Pl2m1+/jxo0zrXl6aN2+Offv25fr47NmzpSZ/TkpKgpWVFTw9PVGpUqVcn1fQuQRz4+TkhM6dOxdrH+WFUChEYGAgOnToUOi5Q8n/VYR6lLS0Fxor4/z9/ZmBgYHM9vPnzzM1NTX2/v17btvBgweZpqYmS0xMLPD+ExMTGQD2+fNnRYRbYrKysljXrl0ZANahQwcmFotL7NiZmZns5MmTLDMzs1DPe/PmDQPAALC6desyoVDIsrKylBTld2xsGAMYu3ev6Pu4fDl7H7a2ch8OCQlhffr04V7jjBkzpF5fUetNFTIyMpiWlhYDwFasWMG9JgCsR48eLDMzk12/fp0tXLiQvXjxQmlxfP78mQEo1Ge6MGJjY9m8efNYly5dWKdOndicOXNYTEyMUo6VU9OmTdlPP/0kta1OnTps1qxZBd5H7969mYeHR4HLS851+dXlokWLpP6/i3K7fPlygeMqz8rSZ740qwj1WNDP5/eK1JLn6+uLxYsXQ1dXN99lgFS19E9oaCjq168PS0tLbpuXlxcyMjJw7969XC+3FLWfSmkzefJknD17FgKBAEuWLCnRyUiL2j/C0tIS165dw19//YU+ffqAMQbGWMmse/n8OfD5M1C5MlDU/+cGDaABAG/eQBgTA1SpIvWwq6srXF1dUbVqVaxfvx4rV66EiYkJJk+eDKBs9Su5desW0tPTufjHjx+P0NBQdO3aFadOnZLqEnH16lVuyhxFU1ZdCYVCeHp6Ytu2bSXTkvwdX19fDB06FC4uLnB1dcX27dsRFRWFsWPHAshuhXv//j327NkDAFi3bh1sbW1Rr149ZGZmYt++fTh27Bg3v6QiKWJOzXbt2pXYfIOEVGRFSvLCw8O5k2teTfeqXPonLi5O5tKGoaEhBAJBrp2Xgdz7qQQFBeXZT6W0EIvFuHnzJjZv3gwej4dJkyZxc2aVtKL2j/Dw8EB8fDzOnz+v4IiUr52lJfRiYnBvyxZ8cHGRW8bd3R2JiYnYtWsX5s6di8+fP0MgEMDlv/KltV9JWloabt26hSZNmiAgIAAAYG9vL5XATZs2DatXr0Z6ejq3LSgoCGvWrMHBgwdRt25d9OnTR2FTeyhromkNDQ08evRIZeew/v37Iz4+HosWLUJsbCzq16+P8+fPc/NMxsbGSs2Zl5mZiWnTpuH9+/fQ1tZGvXr1cO7cOaVcFq3IS7oRUtbwWCn6ObVgwYJ8fzXfvXuX+zIEgF27dmHy5MkyAy/GjBmDt2/f4tKlS1LbBQIB9uzZgwEDBsjdv7yWPCsrK8TGxpb6EWEfPnxAr169cPfuXQDZk7Zu3ry5xOOoCP0jcqM2bhz4f/4JcadOEOUxLx5jDHXr1sWrV6+4befPn0dmZibEYjG0tbXRrl27kgi5QDIzM+Hh4YG7d+9i7NixePv2LS5cuIBVq1ZJrYEMAAkJCZg4cSJiY2Px9u1bmelGFi9ejJkzZyokrvj4eFhYWCAxMTHPfmRFMXXqVGhoaGD58uUK3W9plZSUBAMDg3zr0s/PD7/88kuxjxcaGqqyUf6lhVAoxPnz59G5c+cKd65UpIpQjwX9fH6vVC2q+fPPP+eafEnY2toWaF/m5ua4ffu21LaEhAQIhcI8Oy9ramrKnR5BQ0OjVL95xGIxhg0bxiV4fD4fkydPVmnMpb3OlGLmTMDfH2oXLkDt1i2gdetci/bp0wcrVqzg7u/fvx9GRkbcwKDt27crdU3hwjhx4gT33tq5cyf3GXF3d5f5PzY1NcWhQ4cAABs3bpRJAjdu3Ihp06YpZHCGMt9fmZmZ+PPPPxEYGAgXF5fs5e9yUFVXFFVTVEueq6srrl+/jpYtWypkf4QQWcVO8lJSUrB8+XJcvnwZHz9+lOk/VZjh9iYmJjAxMSluSACyTyBLly5FbGwsLCwsAGRPDaCpqQlnycS15UBkZCTWrFkDY2NjBAUFQVdXFzt27ICdnR3q1aun6vAqHnt7YNQoYNs2YPZs4Pr1XItOmjQJ9+/fh52dHbZv3479+/dLPT558mR06tRJZjJeVTh9+jT3d2ZmJjIzM6Gvr4+GDRvm+bxRo0Zh+fLliImJwdGjRzF16lRERUVhz549GDNmjLLDLpZHjx5xU/c8f/5c6rGKfMlSka/9/PnzlOQRokTFTvJGjRqFkJAQDB06FBYWFiV28ouKisKXL18QFRUFkUiEiIgIANl9hPT09ODp6Ym6deti6NCh+O233/DlyxdMmzYNo0ePVvhlHVVJS0tD165dubnKgOxVFfr376/CqAjmzctO8m7cAD58AHJpObawsEBAQAAYY0hLS8PevXsBAHZ2djA3N0doaCjGjBmD+fPnY+rUqZgzZw46depUkq8EQPZ0RJL+kS4uLggLCwOQvXSbunrepxBtbW1cv34dsbGxaNGiBd69e4cpU6Zg8eLF6NKlC6pWrar0+ItCJBJhwYIFcHR0hJGRkarDKVUUeY7P2XeTEKIExR3Wa2BgwK5fv17c3RTa8OHD5Q7NDwoK4sq8ffuWdenShWlrazMjIyP2888/s/T09EIdpzRPobJr1y6p187n89mzZ89UHVaFGM6er4YNs6dTOXCgQMXFYjGbP38+09TUZEeOHGGPHj1impqaDABTU1Pj/o+fPHnCGGMsMDCQHTlyRIkvgLG4uDg2YcIENm7cOAaA6enpsczMTHb48GG2b9++Ik3Lk5yczGxsbBgAZmdnx7p37y4zVUhhKHMKFU1NTfb69WuF77e0KugUDStXriz2FCo5b1OnTi2hV1j60LlSMSpCPRZ1CpViJ3m2trbs33//Le5uSq3SmOTdvHmTRUZGsnbt2jEAbN68eezMmTPs2rVrqg6NMVYxPnD5mjYtO8nr2rXAT8nMzGQnTpzg6u3AgQNMXV1d6gtx7Nix7OPHj0wgEDAAbO/evUUOUSwWs+vXr7O//vqLm69PLBaz33//ndnY2HDHkNzatWtX5GPl9PLlS6ajoyO176LOpafMJM/FxYX9/fffCt9vaVXQL5FVq1YpNMlTQFtDmUXnSsWoCPVY1CSv2MsfLF68GPPmzVPaVAYkG2MMUVFROHr0KFq0aAE7OztcvnwZPB4P3t7e6Nq1K1q1aqXqMInE8OGAunr2ChgeHkCOEdt5yXkpbODAgQgICICtrS2aNGkCANi6dSu6d++OzMxMANmX52NiYgBk98/cunUr13VBIisrCy9evJA51po1a9CqVSv06dMH3bp1w+3bt+Hq6orx48fj7du33DEkGjRoUOCXn5caNWpg0aJFMvv+9OmTQvavKEuXLsW0adNw9uxZxMbGIikpSepWUSmjS86uXbto3jxClKG42aWTkxPT19dnenp6rH79+qxRo0ZSt7KuNLTkPX78mLVp00buL+DiXOpSlorwq6pAVq/Obs0DGLt4Md/iedWbWCxmXbp0kfseaNq0KVuxYgUzMDBgABiPx2OnTp1ijDGWkJDAmjVrxgCwDRs2cPtLSUlhxsbGcvenra3NZs6cyR4/fsxEIhH3fEW3FKenp7N169Zxx+3Xr1+h96HMljwej8fd1NTUuJvkfnlT0JaCNWvWKLwlDwDbvn17Cb3S0oPOlYpREeqxRFe8yKlnz57F3QXJQ2JiIlq3bo0vX75w25o0aYLp06fjn3/+waxZs1QYHcmTry9w5w5w+DCwfXt2i16OlSAKg8fj4fTp0zh9+jSePn0KTU1NtGvXDu7u7rhz5w7u3LnDlWWMYdiwYdi7dy9Wr17NTSU0a9YsNGvWDNOnT8fVq1cBADY2Nhg5ciTmzZsHILtFLSAgQGqaoUuXLuHly5cKH5WuqamJUaNG4eTJkwgODsaRI0dgY2ODRo0aoWfPntDW1lbo8QorKChIpccvrZQ1uO7cuXMYNWpUhR65TIjCKSfnLD9U3ZK3c+dOBoBVr16d3b17l4WFhZXceq5FVBF+VRXY7t3/b82bMiXPokWpt4iICFarVi1mZGTE1q5dy1JSUpizs3OBW0+OHj3KhEIhW7FiBevTpw83sKOkjRkzRiquWbNmMaFQyHbv3s3Wr18vVSfBwcGsffv2zNHRkevbp6y1ayuSgrYUrF+/XikteQBY//79S+jVlg50rlSMilCPKmvJI4qVmZmJv//+G7Nnz0ZKSgo+fPgAAPDx8ZFa6YOUEZ6e///72DFAwRPoNmzYEE+ePIFYLOamM9mzZw9GjRqF1NRUGBoaYsyYMRAIBOjTpw8AoHHjxnB3d0ezZs24bTNmzFBoXIW1efNm1K5dGwEBAbh48SKWL1+O8+fP48GDBwCA48ePY9GiRZgzZw6u5zH3oKJ9/foVO3bswJMnT8Dj8VC3bl34+PjAwMCgxGIobZTZ0nb48GFuIm1CSPEVO8lTU1PL80MvEomKe4gKQSwWIywsDOPHj+fmIZOoVq0aRo4cqaLISLGYmwOvXgE1agBRUUBcXPY2BVJTU4Oa2v/HUNWtWxc3b96UKiMSiTBnzhzo6upi6tSpEBTxsrGy8Pl8TJkyBRMmTICNjQ1iYmK4BA8AQkJC4Obmxt2vW7cuBg4ciNatW8Pd3V0pMYWFhcHLywva2tpo2rQpGGNYs2YNli5dioCAAG6i5IpG2ZdT/f39MWTIkIq3Wg4hSlDsJO/EiRNS94VCIcLDw7F79+5816El2W7fvo0hQ4bg5cuXUtvbt2+PQYMGoVevXhW65aDMq14dcHQEHj4Ebt4EevUq8RD4fD6WLFlS4sctLHV1dezfvx/r16/Hhw8f4O3tDVNTU4wcORJfvnyBtbU1rly5gho1agDIXrtWWaZMmYLu3bvjjz/+4FpJs7KyMGrUKEyePJnr11jRKDvJ8/HxQWRkpMwIbEJI4RU7yevRo4fMtj59+qBevXo4fPgwtUB95/3791i3bh1q1qyJgIAA3Lp1C58+feKWiWratCk6duwICwsLDBo0iDohlxctW2YneTduqCTJK0vc3d1lWudcXFywZcsWeHt7cwmesoWFhUkleEB2EjpjxowK3XWiJM5JixcvRocOHdA6j7WfCSH5U1qfvGbNmpWaxdVLg5cvX2LZsmXw9/eX+7idnR3u3r0LY2PjEo6MlIjWrYGtW4EK2vpTXNWqVcPSpUtL9JiVKlVCVFQUateuLbU9Ojoa+vr6JRpLaZKza4AytWnThubOI6SYlPJpTUtLw8aNG0vFwuol6fTp0xgzZgwOHjwodXKaMmUKatasmWuCp6Ghgf3791OCV55JWiTCwoBfflFtLKRA+vfvj5EjR+Lw4cOIjo7Gu3fvcOjQIYwaNQoDBw5UdXgqU5JXF0aPHs1N9k0IKbxit+QZGhpKfegZY0hOToaOjg727dtX3N2XGZ8/f0afPn0gFArxxx9/YM6cOWjatCkaNGiAdevWSZX18fFBYmIihg4dCj6fj8qVK8PV1VU1gZOSYWUF1K8PPHoE+PkB7dpl30iptWrVKvB4PAwbNgxZWVkAsn+Q/fTTT1i+fLmKo1Odkkzy/vzzT9y+fRt79uyBk5NTiR2XkPKi2Ene9wmMmpoaqlSpgmbNmsHQ0LC4uy81kpKSIBAIsHLlSty7dw9btmzBixcvsH37dqSnp+Phw4cQCoUAsusgMjISkZGROHz4MACga9eu2LBhA06dOoWxY8dCS0tLlS+HqMKlS9n98W7fBubNoySvlBMIBFi/fj38/Pzw6tUrMMZgb28PHR0dVYemUiXdT/jhw4do1KgRPn/+DCMjI+qnTEghFDvJGz58uCLiKPWqV68udd/T0xPx8fEyo/s2bdoER0dHbhb/8PBwWFhYYMuWLahWrRomT55cglGTUsXSEjhxIrtV7+ZN4MkToE4dVUdFcpGYmAiRSAQjIyM4Ojpy2798+QJ1dXVUqlRJhdGpjqqSLBMTE6xfvx6DBg2CiYmJSmIgpKwpmR605dDz58+5BK9Ro0bw9PTEwoULMXbsWLRp0wZr1qxBSEgINmzYgBs3blS4/okkFxYWQJcu2X8PHAikpak2HpKrAQMGyJ2Y98iRIxgwYIAKIiodVNmSNmnSJFSpUgVjx47FzZs3ERcXR4MzCMkDJXkFtG3bNty5cwcJCQlYu3Ytt33VqlW4f/8+Ll26hHnz5oHP53OP6evrY8KECbCzs1NFyKS0Wr0aqFIF+Ocf4PRpVUdDcnH79m14eHjIbHd3d+fWA66ISsPl0m3btqFly5awsLCAmpoahg4diq1bt+LFixfIysqixI+Q/9CyZgXUu3dvbvTr+PHjkZaWhurVq6Nfv34qjoyUOfb2gI8PsGIFcPw40L+/qiMicmRkZHADLnISCoVIq8AtsKUhyfvevn37pAb6GRgYwM3NDe3atUPVqlXh5uYGPT096gtNKhxqySsCDQ0NzJ49G/379y+VJzxSBvzwQ/a/Fy4AYrFqYyFyNWnSBNu3b5fZvnXrVjg7O6sgotKhLJzzEhMTcfr0aUyaNAl9+vRBlSpVoK2tjRYtWuDcuXOIiopSdYiElAiFteR9+vQJz549A4/HQ61atVClShVF7ZqQ8sfZGdDSApKTgb/+AmrVAurVU3VUJIelS5eiffv2+Oeff9Duv5HQly9fxt27dxEQEKDi6FSnLCR5uQkNDUXXrl0BZM/BN2rUKFStWhVVq1ZVcWSEKEexW/JSUlLg4+MDS0tLtGnTBq1bt4alpSVGjhyJ1NRURcRISPmjrv7/pK5/f6BxY+DxY9XGRKS0bNkSoaGhsLKywpEjR3DmzBnY29vjwYMHFXq5rZJa8ULZ/vjjDzRr1gzVqlVD7dq18fvvv+Pff/9VdViEKFSxP62+vr4ICQnB6dOn8fXrV3z9+hWnTp1CSEgIpk6dqogYCSmf6tb9/9+MQe3mTQAA78IFoAK3FJUmTk5O2L9/Px4/foywsDDs3LkTNWvWLJFjb968GXZ2dtDS0oKzszOuXbuWZ/mQkBA4OztDS0sL1atXx9atW5USV1luycvNs2fP8PPPP6NevXqYMGECnj17puqQCFGIYid5x44dw44dO9CpUydUqlQJlSpVQufOnfHHH3/gr7/+UkSMhJRPpqbS9x8+hP6bN1Dv0QPw8gKoVaHCOnz4MCZPnow5c+YgPDwcrVu3RqdOnXLtSxYZGYnOnTujdevWCA8Pxy+//IKJEyfi2LFjCo+tPCZ5OW3atAm1a9eGnp4eNDQ0YGhoiM6dOyM8PBwZGRkKO867d+/w/v17PHnyBP/++y+io6MRHh6OO3fu4OHDh7hx4wYyMzO5SfYJKYpi98lLTU2FmZmZzHZTU1O6XEtIXqZMAYKCAD094OpV8B48QM2cid3ChcB/K6aQimXNmjUYOXIkRo0aBSB7ZaFLly5hy5Yt8PPzkym/detWWFtbcysQ1alTB2FhYVi1ahV69+6t0NjKe5InkZKSAgD4+vUrLly4gAsXLsDOzg7Tpk1DvXr18ObNG4jFYtjb28PU1BQODg4y+xCLxbh//z6EQiE+fPiAV69eISwsDGfPnsW3b9+4crNnz84zFisrK6irq8PExARmZmaoXbs2DA0NUaVKFVhbWyMrKwtJSUmoWbMmGGMwMjKCiYkJEhMT8c8//+Dt27cIDQ3Fly9fULlyZZibm8PU1BQaGhp4/PgxYmNjoaamBlNTU3h6esLGxgbW1taoXLkykpKSoK+vDx0dHairy6YMkqVMs7KyEBYWhq9fv+L169d49eoV1NTU8P79ewiFQlSrVg1CoRBaWlqoXLkyRCIRLCwsoK6ujnfv3kFdXR1JSUnc69XV1YWenh4cHBygpqaGzMxMmJqaIj09Hdra2rCwsIBQKISxsXGBp8zJysqCSCTCy5cvUaVKFYhEIujq6kIgECAhIQEfPnyAlpYWoqOjUbVqVejp6SExMRFmZmbg8XjQ0NCAgYGBwj4DjDEkJiaicuXKCtmfPMVO8lxdXTF//nzs2bOHG56elpaGhQsX0nqshOSlalXg3j3g4UOgQQPw7t+HVXr6/x8/cyZ7smRtbdXFSEpcZmYm7t27h1mzZklt9/T0xM3/Lul/LzQ0FJ6enlLbvLy8sGPHDgiFQmhoaCgsvvLSJ68oIiMjMX78+DzL2NvbQ09PDxEREQo7bnR0NHd8ADh79qzC9v293bt35/pYtWrVULduXRgZGeHRo0eIjIzkkmFVMzY2hrq6OsRiMYyNjfH06VM0btwY5ubmiIqKglAoVOhleB0dHaSmpqJ+/fowNzdHzZo1YW5ujkqVKiEpKQmVK1fGixcvEBkZiVevXiEjI4P7/zMzM8Pnz58hEonA5/Oxb98+pU2wrpC1azt16oRq1aqhYcOG4PF4iIiIgJaWFi5duqSIGAkp3+rWBRwdwXv4EADA9PXB09cHYmKAy5eB/0YDkopBcvL//gqJmZkZ4uLi5D4nLi5ObvmsrCx8/vwZFhYWMs/JyMiQuvwoaUURCoV5XiIU05Q/eXr58qWqQ1Cad+/e4d27d6oOQ66cS4x++vQJAHD//n2lHU9ypfLRo0d49OgR/v777wI/98OHD9zfIpEIT548yfeyfFEv2xc7yXN0dMSLFy+wb98+PH36FIwxDBgwAIMHD4Y2tUAQkj8+Hzh2LHsaFQAwMQE6dQI2b85e65aSvArp+0tCjLE8LxPJKy9vu4Sfnx8WLlwosz0gIAA6Ojq5HufBgwe5PkbKP0NDQ+jq6pbaZE8VdHR0UKNGDZiamiItLQ3fvn1DVlYW+Hw+YmJikJSUlGuS1rBhQzg6OuL8+fN5HqOo3d+KneRdvXoVLVq0wOjRo6W2Z2Vl4erVq2jTpk1xD0FI+VezJkRTpoC/di3EU6eCX69edpJ37BjQpw8wejSwdSslfErWq1evApc9fvy4UmIwMTEBn8+XabX7+PGj3P7PAGBubi63vLq6OrdSz/dmz54NX19f7n5SUhKsrKzg6emJSpUq5RpfRV7tAwD69u2LWrVqIT09He/fv4epqSnatm0LR0dHWFpags/ngzGGlJQU3L9/H/Hx8Xjy5AliYmK4wRW5tcgWBI/HQ6NGjaCtrQ0HBwdoa2tDTU0NWVlZ0NPTQ5UqVWBvb4/09HSIRCLcu3cPYWFhuHfvHtLS0mBqago7Ozvo6emBz+fj9evXePPmDbKyslC5cmW0bNkSXl5eqFOnDj5//gw7OztkZmZCIBCgfv36EAgEXCxfvnxBRkYGoqOj8f79e3z+/BkPHz7E8+fP8ejRI/D5fMTGxkJdXR2VK1eGUCiEmpoajI2NYWlpyb3PYmNjkZiYiOTkZOjq6qJq1aqoXLkyatasCQ0NDZiZmUEgECA5ORmmpqbQ09NDRkYGHBwcoK+vD7FYjKdPn6Jdu3YQCARQV1eHUCiEuro6eDweeDwesrKy8OnTJzx+/BiMMcTFxaFq1aowMjJCXFwcNDU18enTJ7x58wZGRkbQ1taGWCyGpaUlkpOTUalSJRgZGUEoFMLW1par97x+EOXEGINQKMS3b99QqVIlZGZmQlNTE2pqagXq4ydpaS+sYid5Hh4eiI2Nhel3IwUTExPh4eEBkUhU3EMQUiGI/fxw1doarUaNAl9DI7vP3vv3QOfO2QW6dcteHaOCdHxXBQMDA+5vxhhOnDgBAwMDuLi4AADu3buHr1+/FioZLCyBQABnZ2cEBgbiB8nKKAACAwPRo0cPuc9xdXXFmTNnpLYFBATAxcUl1/54mpqa0NTUlNmuoaGRZx8+eZ3vyzsDAwMMHjwYq1evLvDSaAKBgJtE+3uRkZFISEhAYGAg3r17x3V10tXVRUJCAlJSUlC7dm2IxWI4OjrCwsICjLEiXR0bMmRIgcrl11Isj+RHh7W1daHjUiShUIiXL19CV1eXe+/mTEaB7Pe1tbW1SmMVCATQ1dUFgEL/Xxa1X22xP625vTHi4+O5F0MIKQA1NSTZ2QFqatm3iROBmTOly9y+DTRvnr0cWlISrXurYP7+/tzfM2fORL9+/bB161bw+XwA2f1nxo0bl2dLlyL4+vpi6NChcHFxgaurK7Zv346oqCiMHTsWQHYr3Pv377Fnzx4AwNixY7Fp0yb4+vpi9OjRCA0NxY4dO3Dw4EGFx1beB17UrFkTCxYs4K5CaWhooEqVKgp93XZ2drCzs+Mu03Xu3Fmhg2OKoqKMmq5oipzkSX7J8ng8eHt7S/0iFIlEePDgAVq0aFH8COV48+YNFi9ejCtXriAuLg6WlpYYMmQI5syZI5W9R0VFYfz48bhy5Qq0tbUxaNAgrFq1SibDJ6RUmjBBNsm7cgVo2PD/rXu1agGNGpV8bBXAzp07cf36dS7BAwA+nw9fX1+0aNECv/32m9KO3b9/f8THx2PRokWIjY1F/fr1cf78edjY2ADIvryVc848Ozs7nD9/HlOmTMHvv/8OS0tLbNiwQeHTpwDlNxlwd3fHli1bUKNGDZUnXIQoSpGTPMllDcYY9PX1pZoeBQIBmjdvLtNPT1GePn0KsViMbdu2wd7eHo8ePcLo0aORkpKCVatWAchONLt06YIqVarg+vXriI+Px/Dhw8EYw8aNG5USFyEKpa0NHDoE5Bxaf/Nm9kTJEgcPUpKnJFlZWXjy5InM/GdPnjwpkRGm48aNw7hx4+Q+tmvXLpltbm5uSh1NKFFekjwLCwsMHz4cffv2hbW1NUxMTFQdEiEKV+QkT3JZw9bWFtOmTSvRS7MdO3ZEx44dufvVq1fHs2fPsGXLFi7JCwgI4GYRt7S0BACsXr0a3t7eWLp0qdIvtxCiEP37A3Z2wKdP2YMuQkOBu3f///iBA8Dy5dmXd4lCjRgxAj4+Pnj58iWaN28OALh16xaWL1+OESNGqDg61SnLSZ6WlhYGDx6MhQsXwszMrEL2LyQVS7Hf4fPnz1dEHMWWmJgIIyMj7n5oaCjq16/PJXhA9uSgGRkZuHfvHjw8POTup6hzR5H/k9QT1Vfh5FpvjRoBmZlQNzYGLz4ezNcX3Nfs+/fIunEDrHlzIDUVvIgIsIYNgQrSH1aZ77FVq1bB3Nwca9euRWxsLIDs1p8ZM2ZU6HW5y0qSp66uDhcXF7i5uaFWrVpo3749LC0tKbEjFUq5eLe/evUKGzduxOrVq7lt8iYHNTQ0hEAgyHP4em5zRwUFBRV4qDTJFhgYqOoQyqTc6q3KhAlotmwZ+N9NYRHt54eHI0ei5dy5MH7yBClmZri6ciUy/+tSYXPpEmofOoTbv/yCrzVrKj3+kqTMpRPV1NQwY8YMzJgxg/uxR1cASufAC2tra7Ru3RpdunSBg4MDGjRoADU1tVIZKyElqVQleQsWLJCbYOV09+5dbjoDAIiJiUHHjh3Rt29fbp1HCXm/OPMbJp7b3FEeHh65zjdFpAmFQgQGBqJDhw7UgbkQ8q23zp0h9vEBTp4E4uPBmjSBeteusL1yBTZaWlB78gQAoPvhAzxfvIB43jwgMREaPXsCAFpfuADRpEkl94JKQM5Z7pUhKysLwcHBePXqFQYNGgQg+5xTqVIl6OnpKfXYpVVpaMmrV68eOnXqhL59+6Jq1aqoWrWqqkMipFQqVUnezz//nO/6bba2ttzfMTEx8PDw4KYYyMnc3By3b9+W2paQkAChUJjrhKJA0eeOIrKozoomz3qzssoedQsAjAGtW4N37Rp4J05kbxs8GNi/H/zt28GfPz97Gpb/qN2/DzUeDyhHl6uU+f56+/YtOnbsiKioKGRkZKBDhw7Q19fHypUrkZ6ejq1btyrt2KWZKpM8Jycn/P333/SDm5ACKlVt2SYmJqhdu3aeN8lElO/fv4e7uzsaN24Mf39/mWZ5V1dXPHr0iOtLA2QPxtDU1ISzs3OJvi5ClILHA1au/P/9X34B/P0BIyPg40egQ4fs0beSL+WvX4Hr11USalk0adIkuLi4ICEhQWr2gB9++AGXL19WYWSqpaok748//kB4eDgleIQUQpF+0m/YsKHAZSfmaElQlJiYGLi7u8Pa2hqrVq3iFiMGslvwAMDT0xN169bF0KFD8dtvv+HLly+YNm0aRo8eTf1qSPnRvHn28mcxMcCCBdnr4PbsCezcCQQHZ5fZvh1ISAA0NIDatVUYbNly/fp13LhxQ2ZeTRsbG7x//15FUameKpK8iIgINGzYsMSPS0hZV6Qkb+3atQUqx+PxlJLkBQQE4OXLl3j58iWqVasm9ZhkUW4+n49z585h3LhxaNmypdRkyISUKz/9JH1/yhTgxInsxG7aNOC7vqqkYMRisdxlGd+9ewd9fX0VRFQ6lPRghocPH6J+/folekxCyosiJXmRkZGKjqNQvL294e3tnW85a2trnD17VvkBEVKa1K8PvHoFPH2a3dJHiqRDhw5Yt24d19+Xx+Ph27dvmD9/PjpLVhypgEqqJU9XVxfnz5+nBI+QYlBYD+zMzExERkaiRo0aNA8RIapmaAi4uqo6ijJt7dq18PDwQN26dZGeno5BgwbhxYsXMDExUcqasGVFSSV5ly9fRrNmzUrkWISUV8Vud09NTcXIkSOho6ODevXqcespTpw4EcuXLy92gIQQogqWlpaIiIjAtGnT8OOPP6JRo0ZYvnw5wsPDYWpqqurwVKYkkrxp06ahadOmSj8OIeVdsZvcZs+ejX/++QfBwcFSS421b98e8+fPx6xZs4p7CEIIUQltbW34+PjAx8dH1aGUGiXRJ++3335T+jEIqQiK/Wk9efIkNm3ahFatWkn9wqtbty5evXpV3N0TQohK8Pl8eHh44MuXL1LbP3z4AD6fr6KoVE/ZLXk7duxQ6v4JqUiKneR9+vRJ7qWLlJSUUjEzOiGEFAVjDBkZGXBxccGjR49kHquolHlej4iIoFZTQhSo2ElekyZNcO7cOe6+5ATwxx9/wJU6fhNCyigej4djx46hW7duaNGiBU6dOiX1WEWlrNeura0ttaIRIaT4it0nz8/PDx07dsS///6LrKwsrF+/Ho8fP0ZoaChCQkIUESMhhJQ4xhj4fD7Wr1+PevXqoX///vj1119l1siuaJSV5D148AAGBgZK2TchFVWxW/JatGiBmzdvIjU1FTVq1EBAQADMzMwQGhpKy4cRQsqFMWPG4OLFi1i3bh2GDh2q6nBUSlkDL+zt7ZWyX0IqsmK15AmFQowZMwZz587F7t27FRUTIYSonI2NjdQAC3d3d9y6dQvdunVTYVSqp4yWvEOHDil8n4SQYrbkaWho4MSJE4qKhRBCSo3IyEgYGxtLbbO3t0d4eDhev36toqhUT9FJXmxsLPr376/QfRJCshW73f2HH37AyZMnFRAKIYSUflpaWrCxsVF1GCqj6CSP+uERojzFHnhhb2+PxYsX4+bNm3B2doaurq7U4xMnTizuIQghpEQYGRnh+fPnMDExgaGhYZ4Jzffz51UUikzyZs2aBW1tbYXtjxAirdhJ3p9//onKlSvj3r17uHfvntRjPB6PkjxCSJmxdu1a6OvrAwDWrVun2mBKKUUleQYGBvDz81PIvggh8hU7yYuMjFREHIQQonLDhw+X+zf5P0UledbW1grZDyEkd8VO8gghpLxISkoqcNlKlSopMZLSSxFJno6ODtasWaOAaAgheVH+StOEEFJGVK5cGYaGhnneJGWUJSEhAUOHDoWBgQEMDAwwdOhQfP36Nc/neHt7g8fjSd2aN2+ulPgUkeQlJCSgffv2CoiGEJIXaskjhJD/BAUFqToEDBo0CO/evcPFixcBZE/EPHToUJw5cybP53Xs2BH+/v7cfYFAoJT4FJHkaWhoKCASQkh+KMkjhJD/uLm5qfT4T548wcWLF3Hr1i00a9YMwP/XAX/27BkcHBxyfa6mpibMzc2VHqMiVryoyGv/ElKSKMkjhJA8pKamIioqCpmZmVLbGzRooPBjhYaGwsDAgEvwAKB58+YwMDDAzZs380zygoODYWpqisqVK8PNzQ1Lly6FqalpruUzMjKQkZHB3Zf0RxQKhRAKhbk+TyQSFeYlyZg+fXqe+69IJPVA9VE8FaEei/raFJrkpaSk4PDhw0hLS4Onpydq1qypyN0TQkiJ+fTpE0aMGIELFy7Ifby4yY48cXFxchMzU1NTxMXF5fq8Tp06oW/fvrCxsUFkZCTmzp2Ltm3b4t69e9DU1JT7HD8/PyxcuFBme0BAAHR0dHI9VnR0dAFeiXw1a9ZEy5Ytcf78+SLvozwKDAxUdQjlQnmux9TU1CI9r8hJXlRUFIYOHYr79++jefPm2LFjBzp06IAXL14AALS1tXHhwgW0adOmqIcghBCVmTx5MhISEnDr1i14eHjgxIkT+PDhA5YsWYLVq1cXal8LFiyQm1DldPfuXQDyL2UyxvK8xJlzWbD69evDxcUFNjY2OHfuHHr16iX3ObNnz4avry93PykpCVZWVvD09Mxz5PCjR4/yfB15qVy5Mjp37lzk55c3QqEQgYGB6NChA/VTLIaKUI+FGfmfU5GTvGnTpiEzMxNbtmzB0aNH4eXlhZo1a+Lq1atQU1PDuHHjsGDBAly5cqWohyCEEJW5cuUKTp06hSZNmkBNTQ02Njbo0KEDKlWqBD8/P3Tp0qXA+/r5558xYMCAPMvY2triwYMH+PDhg8xjnz59gpmZWYGPZ2FhARsbG+5HtzyamppyW/k0NDTy/KIszoCO0aNHl9sv4eLIr85JwZTneizq6ypyknf16lWcPn0aTZs2RefOnWFiYoKdO3dyJ6Jff/0V7dq1K+ruCSFEpVJSUrhLp0ZGRvj06RNq1aoFR0dH3L9/v1D7MjExgYmJSb7lXF1dkZiYiDt37qBp06YAgNu3byMxMREtWrQo8PHi4+MRHR0NCwuLQsVZEEUdNHHlyhWVD2whpKIp8jCpT58+cYt0GxkZQUdHR+qXprm5ORISEoofISGEqICDgwOePXsGAHBycsK2bdvw/v17bN26VSnJEwDUqVMHHTt2xOjRo3Hr1i3cunULo0ePRteuXaUGXdSuXRsnTpwAAHz79g3Tpk1DaGgo3rx5g+DgYHTr1g0mJib44YcfFB5jUZM8Dw8PhYzMJYQUXJFb8r7vI0JD4gkh5cnkyZMRGxsLAJg/fz68vLywf/9+CAQC7Nq1S2nH3b9/PyZOnAhPT08AQPfu3bFp0yapMs+ePUNiYiIAgM/n4+HDh9izZw++fv0KCwsLeHh44PDhw9w6vIpE53pCyo5ija6dN28eNworMzMTS5cuhYGBAYCijwQhhJDSYPDgwdzfjRo1wps3b/D06VNYW1sX6NJrURkZGWHfvn15lmGMcX9ra2vj0qVLSovne0VJ8nbs2KGESAgh+SlyktemTRvuUgYAtGjRAq9fv5YpQwgh5YGOjg4aN26s6jBUrrCXXLt37w4fHx8lRUMIyUuRk7zg4GAFhlF43bt3R0REBD5+/AhDQ0O0b98eK1asgKWlJVcmKioK48ePx5UrV6CtrY1BgwZh1apVSlnuRyQSleuJGAtDKBRCXV0d6enpSplLTJk0NDTA5/NVHQYpBRhj+OuvvxAUFISPHz9CLBZLPX78+HEVRaZahW3JK6+jHQkpC8rsihceHh745ZdfYGFhgffv32PatGno06cPbt68CSA76erSpQuqVKmC69evIz4+HsOHDwdjDBs3blRYHIwxxMXF5buAeEXCGIO5uTmio6PLZP+dypUrw9zcvEzGThRn0qRJ2L59Ozw8PGBmZkbvh/9QkkdI2VGkJC/nBJr5WbNmTVEOka8pU6Zwf9vY2GDWrFno2bMnhEIhNDQ0EBAQgH///RfR0dFc697q1avh7e2NpUuX5jnZZ2FIEjxTU1Po6OjQFwEAsViMb9++QU9Pr0yNpmOMITU1FR8/fgQApY2gJGXDvn37cPz4cZq89zuFPccpY4QvIaRgipTkhYeHS92/d+8eRCIRN8T/+fPn4PP5cHZ2Ln6EBfDlyxfs378fLVq04H41hoaGon79+lKXb728vJCRkYF79+7Bw8Oj2McViURcgmdsbFzs/ZUXYrEYmZmZ0NLSKlNJHpDdiR0APn78CFNTU7p0W4EZGBigevXqqg6j1ClMknflyhW4u7srLxhCSJ6KlOQFBQVxf69Zswb6+vrYvXs3DA0NAQAJCQkYMWIEWrdurZgoczFz5kxs2rQJqampaN68Oc6ePcs9FhcXJzNDvKGhIQQCQZ5rQBZm0e6MjAwwxqClpSXTX6cik4z8Y4yVyXrR0tICYwxpaWm5rvupDBVhkW1FU2ZdSZYi27lzJ5f8k8INvFDEj2lCSNEVu0/e6tWrERAQwCV4QHYytWTJEnh6emLq1KkF3ldB13d0cXEBAEyfPh0jR47E27dvsXDhQgwbNgxnz57lfmkWZQ3I3BbtDgoKklm0W11dHebm5khJSaEvZjmSk5NVHUKRZGZmIi0tDSEhIcjKyirx45fnRbYVTZlTNfXt2xcHDx6EqakpbG1tZfqWFXbVi/KCuqQQUnYUO8lLSkrChw8fUK9ePantHz9+LPSXfEHXd5SQLBVUq1Yt1KlTB1ZWVrh16xZcXV1hbm6O27dvSz03ISEBQqEwzzUgc1u028PDQ+aSbHp6OqKjo6GnpwctLa1CvNLyjTGG5ORk6Ovrl8kvhPT0dGhra6NNmzYl+v9aERbZVrT4+Hil7dvb2xv37t3DkCFDaOBFDlQPhJQdxU7yfvjhB4wYMQKrV69G8+bNAQC3bt3C9OnT0atXr0Ltq6DrO8ojuUQoudTq6uqKpUuXIjY2lutAHxAQAE1NzTz7ChZm0W6RSAQejwc1NbUy1/dMmSSXaCV1Uxw8Hg8nTpxAz549i7wPb29vfP36FSdPngQAuLu7w8nJCevWrZNbXk1NDTweT2WLXZfnRbYVTZn1dO7cOVy6dAmtWrVS2jHKooIkeWZmZtQiTUgpUOzMZOvWrejSpQuGDBkCGxsb2NjYYPDgwejUqRM2b96siBhl3LlzB5s2bUJERATevn2LoKAgDBo0CDVq1ICrqysAwNPTE3Xr1sXQoUMRHh6Oy5cvY9q0aRg9erTCRtaWVR8/fsSPP/4Ia2traGpqwtzcHF5eXggNDeXK2NragsfjgcfjQVtbG7a2tujXrx+uXLkid5+7d+9G06ZNoaurCwMDA3Tu3FmqjySQPbeiZJ85b7/++qtSXy8hRWFlZVXhzxXyFCTJ8/X1haOjYwlEQwjJS7GTPB0dHWzevBnx8fEIDw/H/fv38eXLF2zevBm6urqKiFGGtrY2jh8/jnbt2sHBwQE+Pj6oX78+QkJCuFY4Pp+Pc+fOQUtLCy1btkS/fv3Qs2dPrFq1SikxlSW9e/fGP//8g927d+P58+c4ffo03N3d8eXLF6lyixYtQmxsLJ49e4Y9e/agcuXKaN++PZYuXSpVbtq0afjxxx/Rr18//PPPP9wl8x9++EFmzU0ge93N2NhY7jZr1iylvl5CimL16tWYMWMG3rx5o+pQSpWCtM5XrlxZ+YEQQvKlsMmQdXV10aBBA0XtLk+Ojo65tijlZG1tLdOaVNF9/foV169fR3BwMNzc3ABkzzPYtGlTmbL6+vowNzcHkF2Xbdq0gYWFBebNm4c+ffrAwcEBt27dwurVq7FhwwZMmDABQPbl2rlz54IxBl9fX/To0QNWVlbcfk1NTQv1JRAbG4tOnTohODgY5ubmWLlyJfr27cs9/v79e/j6+iIgIABqampo1aoV1q9fL9V/k5DCGjJkCFJTU1GjRg3o6OjIXBr+/kdRRZFfS16dOnUK3VWHEKIcZXbFi1KLMUCJI/5ypaMDFOAyip6eHvT09HDy5Ek0b9680FOETJo0CYsXL8apU6cwY8YMHDx4EHp6evjxxx9lyvr6+mLt2rU4duwYJk+eXKjj5DR37lwsX74c69evx969ezFw4EDUr18fderUQWpqKjw8PNC6dWtcvXoV6urqWLJkCTp27IgHDx4oZQk7UjHk1mezossvyfv3339LKBJCSH4oyVO01FRAT6/kj/vtG1CAy+Pq6urYtWsXRo8eja1bt6Jx48Zwc3PDgAEDCtQSa2RkBFNTU+4S1vPnz1GjRg25yZSlpSUMDAzw/Plzqe3VqlWTuv/27ds8J5Pu27cvRo0aBQBYvHgxAgMDsXHjRmzevBmHDh2Cmpoa/vzzT+7Lx9/fH5UrV0ZwcDA8PT3zfU2EfE8oFCI4OBhz586lCZG/Q6NrCSk7aEhoBdS7d2/ExMTg9OnT8PLyQnBwMBo3boxdu3YV6Pn5zTWYX9lr164hIiKCu+WcY1EeyWCanPefPHkCIHu1lZcvX0JfX59rpTQyMkJ6ejpevXpVoBgJ+Z6GhgZOnDih6jBKJZpJgJCyg1ryFE1HJ7tVTRXHLQQtLS106NABHTp0wLx58zBq1CjMnz8f3t7eeT4vPj4enz59gp2dHQCgVq1auH79OjIzM2Va82JiYpCUlISaNWtKbbezsyt2x2xJ4igWi+Hs7Iz9+/fLlKlSpUqxjkEqth9++AEnT54s1FrdFUFeP/Bq1apVgpEQQvJDSZ6i8XgFumxa2tStW5ebRy4v69evh5qaGjdv3YABA7BhwwZs27aNG3ghsXr1amhoaKB3797Fiu3WrVsYNmyY1P1GjRoBABo3bozDhw/D1NSUprsgCmVvb4/Fixfj5s2bcHZ2lpktYOLEiSqKTLVyS/LGjx+PxYsXl3A0hJC8UJJXwcTHx6Nv377w8fFBgwYNoK+vj7CwMKxcuRI9evSQKpucnIy4uDgIhUJERkZi3759+PPPP+Hn5wd7e3sA2ZdOJ02ahOnTpyMzMxM9e/ZERkYGdu7ciQ0bNmDdunVSI2uL4ujRo3BxcUGrVq2wf/9+3LlzBzt27AAADB48GL/99ht69OiBRYsWoVq1aoiKisLx48cxffp0mf5/hBTUn3/+icqVK+PevXu4d++e1GM8Ho+SvO94eHjk2/WCEFKyKMmrYPT09NCsWTOsXbsWr169glAohJWVFUaPHo1ffvlFquy8efMwb948CAQCmJubo3nz5rh8+bLMouPr1q1DgwYNsGXLFsydOxc8Hg8NGjTA8ePHZRLHoli4cCEOHTqEcePGwdzcHPv370fdunUBZM/TePXqVcycORO9evVCcnIyqlatinbt2lHLHimWyMhIVYdQKuWW5NEqLYSUPpTkVTCamprw8/ODn59fnuUKOwGsj48PfHx8AGT3k0tKSpJJstzd3bnl5wpKUn7cuHG5ljE3N8fu3btzffz7ASXBwcGFioEQyfuQRpbmPvBCsnwkIaT0oGFShBCSiz179sDR0RHa2trQ1tZGgwYNsHfvXlWHpVLyEt2FCxeiSZMmKoiGEJIXaskjhBA51qxZg7lz5+Lnn39Gy5YtwRjDjRs3MHbsWHz+/BlTpkxRdYgqIS/JmzdvngoiIYTkh5I8QgiRY+PGjdiyZYvUyO4ePXqgXr16WLBgASV5hJBSjy7XEkKIHLGxsWjRooXM9hYtWiA2NlZpx126dClatGgBHR2dAs8nyRjDggULYGlpCW1tbbi7u+Px48dKiY+SPELKDkryCCFEDnt7exw5ckRm++HDh2Um+FakzMxM9O3bFz/99FOBn7Ny5UqsWbMGmzZtwt27d2Fubo4OHTogOTlZ4fF9P/Biw4YNCj8GIUQx6HKtAojFYlWHQBSI/j8JkD2YoH///rh69SpatmwJHo+H69ev4/Lly3KTP0UeF5AdFZ4bxhjWrVuHOXPmoFevXgCA3bt3w8zMDAcOHMCPP/6o0PhytuQFBwfDzc1NofsnhCgOJXnFIBAIoKamhpiYGFSpUgUCgYAuZSA7ScrMzER6enqZWueSMYbMzEx8+vQJampqMsu0kYqld+/euH37NtauXYuTJ0+CMYa6devizp073IorpUFkZCTi4uLg6enJbdPU1ISbmxtu3ryp1CRPX19fofsmhCgWJXnFoKamBjs7O8TGxiImJkbV4ZQajDGkpaVBW1u7TCa9Ojo6sLa2LlMJKlEOZ2dn7Nu3T9Vh5CkuLg4AYGZmJrXdzMwMb9++zfV5GRkZyMjI4O4nJSUBAIRCIYRCYa7Py8rK4v62sLDIsyzJm6TuqA6LpyLUY1FfGyV5xSQQCGBtbY2srCyIRCJVh1MqCIVCXL16FW3atClzs+Dz+Xyoq6uXyeSUlF4LFizgLsPm5u7du3BxcSnyMb5/zzLG8nwf+/n5yY0pICAAOjo6eR5r/fr1yMjIwJ07d4oWLJESGBio6hDKhfJcj6mpqUV6HiV5CsDj8aChoVHmEhpl4fP5yMrKgpaWFtUJKXPU1NTyTfJ5PJ5Ui1Z+fv75ZwwYMCDPMra2tgXeX07m5uYAslv0cq468fHjR5nWvZxmz54NX19f7n5SUhKsrKzg6emZ55KAQqEQgYGB6NChA32+i4nqUjEqQj1KWtoLi5I8QgjJ4cSJE7k+dvPmTWzcuLHQy/OZmJjAxMSkuKHJZWdnB3NzcwQGBnJ9BTMzMxESEoIVK1bk+jxNTU1oamrKbC/oD1b6Yas4VJeKUZ7rsaivi5I8QgjJoUePHjLbnj59itmzZ+PMmTMYPHgwFi9erLTjR0VF4cuXL4iKioJIJEJERASA7Cld9PT0AAC1a9eGn58ffvjhB/B4PEyePBnLli1DzZo1UbNmTSxbtgw6OjoYNGiQ0uIkhJR+lOQRQkguYmJiMH/+fOzevRteXl6IiIhA/fr1lXrMefPmYffu3dx9SetcUFAQ3N3dAQDPnj1DYmIiV2bGjBlIS0vDuHHjkJCQgGbNmiEgIIBGvxJSwVGSlw/JZZnk5ORy2wysaEKhEKmpqUhKSqI6KwSqt8KTTPZb2Mun+UlMTMSyZcuwceNGODk54fLly2jdurVCj5GbXbt25TtH3vevl8fjYcGCBViwYEGRjyvZZ359f+h9qjhUl4pREepR8rks7LmOkrx8xMfHA8ju90IIKZ3i4+NhYGCgkH2tXLkSK1asgLm5OQ4ePCj38m15JEmYraysVBwJISQ3ycnJhTrX8ZiifwKXM1+/foWhoSGioqIU9iVS3klG6UVHR+c5So9Io3orvMTERFhbWyMhIaHA67zmR01NDdra2mjfvj34fH6u5Y4fP66Q45UWYrEYMTEx0NfXz3N0Mb1PFYfqUjEqQj0yxpCcnAxLS8tCzeFKLXn5kFSmgYFBuX3zKEulSpWozoqA6q3wFDlx9bBhwyrkPIlqamqoVq1agcvT+1RxqC4Vo7zXY1EamijJI4SQHAq6ZiwhhJR2tG4TIYQQQkg5RElePjQ1NTF//ny5k4YS+ajOiobqrfCozkoe1bniUF0qBtVj7mjgBSGEEEJIOUQteYQQQggh5RAleYQQQggh5RAleYQQQggh5RAleYQQQggh5RAlebm4evUqunXrBktLS/B4PJw8eVLVIZV6fn5+aNKkCfT19WFqaoqePXvi2bNnqg6rVNuyZQsaNGjATeLp6uqKCxcuqDqsMsfPzw88Hg+TJ09WdSjl3ubNm2FnZwctLS04Ozvj2rVrqg6pVCvIeZExhgULFsDS0hLa2tpwd3fH48ePVRRx2SDvM0/1KIuSvFykpKSgYcOG2LRpk6pDKTNCQkIwfvx43Lp1C4GBgcjKyoKnpydSUlJUHVqpVa1aNSxfvhxhYWEICwtD27Zt0aNHjwp/YiqMu3fvYvv27WjQoIGqQyn3Dh8+jMmTJ2POnDkIDw9H69at0alTJ0RFRak6tFKrIOfFlStXYs2aNdi0aRPu3r0Lc3NzdOjQgVtPmEjL7TNP9SgHI/kCwE6cOKHqMMqcjx8/MgAsJCRE1aGUKYaGhuzPP/9UdRhlQnJyMqtZsyYLDAxkbm5ubNKkSaoOqVxr2rQpGzt2rNS22rVrs1mzZqkoorLn+/OiWCxm5ubmbPny5VyZ9PR0ZmBgwLZu3aqqMEut3D7zVI/yUUseUZrExEQAgJGRkYojKRtEIhEOHTqElJQUuLq6qjqcMmH8+PHo0qUL2rdvr+pQyr3MzEzcu3cPnp6eUts9PT1x8+ZNFUVV9nx/XoyMjERcXJxUvWpqasLNzY3qVY7cPvNUj/LR2rVEKRhj8PX1RatWrVC/fn1Vh1OqPXz4EK6urkhPT4eenh5OnDiBunXrqjqsUu/QoUO4f/8+7t69q+pQKoTPnz9DJBLBzMxMaruZmRni4uJUFFXZIu+8KKk7efX69u3bEo+xNMvrM0/1KB8leUQpfv75Zzx48ADXr19XdSilnoODAyIiIvD161ccO3YMw4cPR0hICCV6eYiOjsakSZMQEBAALS0tVYdTofB4PKn7jDGZbUS+vM6LVK95K+hnnupRGl2uJQo3YcIEnD59GkFBQahWrZqqwyn1BAIB7O3t4eLiAj8/PzRs2BDr169XdVil2r179/Dx40c4OztDXV0d6urqCAkJwYYNG6Curg6RSKTqEMsdExMT8Pl8mVa7jx8/yrSeEFm5nRfNzc0BgOo1H/l95iV1RfUojZI8ojCMMfz88884fvw4rly5Ajs7O1WHVCYxxpCRkaHqMEq1du3a4eHDh4iIiOBuLi4uGDx4MCIiIsDn81UdYrkjEAjg7OyMwMBAqe2BgYFo0aKFiqIq/fI7L9rZ2cHc3FyqXjMzMxESEkL1mkN+n/nq1atTPcpBl2tz8e3bN7x8+ZK7HxkZiYiICBgZGcHa2lqFkZVe48ePx4EDB3Dq1Cno6+tzv6gMDAygra2t4uhKp19++QWdOnWClZUVkpOTcejQIQQHB+PixYuqDq1U09fXl+nrqaurC2NjY+oDqkS+vr4YOnQoXFxc4Orqiu3btyMqKgpjx45VdWilVn7nRclcb8uWLUPNmjVRs2ZNLFu2DDo6Ohg0aJCKoy89CvKZp3qUQ3UDe0u3oKAgBkDmNnz4cFWHVmrJqy8AzN/fX9WhlVo+Pj7MxsaGCQQCVqVKFdauXTsWEBCg6rDKJJpCpWT8/vvv3Hu2cePGNEVSPgpyXhSLxWz+/PnM3NycaWpqsjZt2rCHDx+qLugy4vvPPNWjLB5jjJV4ZkkIIYQQQpSK+uQRQgghhJRDlOQRQgghhJRDlOQRQgghhJRDlOQRQgghhJRDlOQRQgghhJRDlOQRQgghhJRDlOQRQgghhJRDlOQRQgghhJRDlOQRogTe3t7g8Xjg8Xg4efKkQvcdHBzM7btnz54K3TchRPEWLFgAJyenEj+u5Fzx9etXhe7X1taWOwcVZN9v3rzhyquiHioySvJIgeRMWnLecq7vS6R17NgRsbGx6NSpE7ctt6TP29u7wAlbixYtEBsbi379+ikoUkJIUck7L+a8eXt7Y9q0abh8+bKqQ1WoRYsWITY2FgYGBvmWtbKyQmxsLKZOnVoCkZGc1FUdACk7OnbsCH9/f6ltVapUkSmXmZkJgUBQUmGVWpqamjA3N1f4fgUCAczNzaGtrY2MjAyF758QUnCxsbHc34cPH8a8efPw7Nkzbpu2tjb09PSgp6enivCURl9fv8DnNz6fD3Nz83JXB2UBteSRApMkLTlvfD4f7u7u+Pnnn+Hr6wsTExN06NABAPDvv/+ic+fO0NPTg5mZGYYOHYrPnz9z+0tJScGwYcOgp6cHCwsLrF69Gu7u7pg8eTJXRl7LV+XKlbFr1y7u/vv379G/f38YGhrC2NgYPXr0wJs3b7jHJa1kq1atgoWFBYyNjTF+/HgIhUKuTEZGBmbMmAErKytoamqiZs2a2LFjBxhjsLe3x6pVq6RiePToEdTU1PDq1aviV+x3cl7ayHlzd3dX+LEIIcWT83xoYGAAHo8ns+37y7WSc9KyZctgZmaGypUrY+HChcjKysL06dNhZGSEatWqYefOnVLHyu9cl5/4+HgMHDgQ1apVg46ODhwdHXHw4EGpMsnJyRg8eDB0dXVhYWGBtWvXypyX5Xn79i26desGQ0ND6Orqol69ejh//nyBYyPKQUkeUYjdu3dDXV0dN27cwLZt2xAbGws3Nzc4OTkhLCwMFy9exIcPH6QuMU6fPh1BQUE4ceIEAgICEBwcjHv37hXquKmpqfDw8ICenh6uXr2K69evQ09PDx07dkRmZiZXLigoCK9evUJQUBB2796NXbt2SSWKw4YNw6FDh7BhwwY8efIEW7duhZ6eHng8Hnx8fGRaMHfu3InWrVujRo0aRauwPEgubUhu4eHhMDY2Rps2bRR+LEKIaly5cgUxMTG4evUq1qxZgwULFqBr164wNDTE7du3MXbsWIwdOxbR0dEACn6uy0t6ejqcnZ1x9uxZPHr0CGPGjMHQoUNx+/Ztroyvry9u3LiB06dPIzAwENeuXcP9+/fz3ff48eORkZGBq1ev4uHDh1ixYgW13JUGjJACGD58OOPz+UxXV5e79enThzHGmJubG3NycpIqP3fuXObp6Sm1LTo6mgFgz549Y8nJyUwgELBDhw5xj8fHxzNtbW02adIkbhsAduLECan9GBgYMH9/f8YYYzt27GAODg5MLBZzj2dkZDBtbW126dIlLnYbGxuWlZXFlenbty/r378/Y4yxZ8+eMQAsMDBQ7muPiYlhfD6f3b59mzHGWGZmJqtSpQrbtWtXnvXVo0cPme0AmJaWllQ96urqMnV1dbnl09LSWLNmzVjXrl2ZSCQq0DEIIarh7+/PDAwMZLbPnz+fNWzYkLsvOSfl/Ew7ODiw1q1bc/ezsrKYrq4uO3jwIGOsYOe67wUFBTEALCEhIdeYO3fuzKZOncoYYywpKYlpaGiwo0ePco9//fqV6ejoSJ2XbWxs2Nq1a6X24+joyBYsWJDrcRiTrQeifNQnjxSYh4cHtmzZwt3X1dXl/nZxcZEqe+/ePQQFBcn9Jffq1SukpaUhMzMTrq6u3HYjIyM4ODgUKqZ79+7h5cuX0NfXl9qenp4udSm1Xr164PP53H0LCws8fPgQABAREQE+nw83Nze5x7CwsECXLl2wc+dONG3aFGfPnkV6ejr69u1bqFgl1q5di/bt20ttmzlzJkQikUzZkSNHIjk5GYGBgVBTo4Z3QsqLevXqSX2mzczMUL9+fe4+n8+HsbExPn78CKDg57q8iEQiLF++HIcPH8b79++RkZGBjIwM7lz++vVrCIVCNG3alHuOgYFBgc7LEydOxE8//YSAgAC0b98evXv3RoMGDQoUF1EeSvJIgenq6sLe3j7Xx3ISi8Xo1q0bVqxYIVPWwsICL168KNAxeTweGGNS23L2pROLxXB2dsb+/ftlnptzUIiGhobMfsViMYDsjtH5GTVqFIYOHYq1a9fC398f/fv3h46OToFew/fMzc1l6lFfX19mKoIlS5bg4sWLuHPnjsyJnRBStsk7J+V1nirouS4vq1evxtq1a7Fu3To4OjpCV1cXkydP5i73Ss61PB5P6nnfn4PlGTVqFLy8vHDu3DkEBATAz88Pq1evxoQJEwoUG1EOahogStG4cWM8fvwYtra2sLe3l7pJkkUNDQ3cunWLe05CQgKeP38utZ8qVapIjV578eIFUlNTpY7z4sULmJqayhynIEP7AcDR0RFisRghISG5luncuTN0dXWxZcsWXLhwAT4+PgWtiiI5duwYFi1ahCNHjiil3x8hpGxRxLnu2rVr6NGjB4YMGYKGDRuievXqUj+4a9SoAQ0NDdy5c4fblpSUVOAf5VZWVhg7diyOHz+OqVOn4o8//ijciyQKR0keUYrx48fjy5cvGDhwIO7cuYPXr18jICAAPj4+EIlE0NPTw8iRIzF9+nRcvnwZjx49gre3t8wlybZt22LTpk24f/8+wsLCMHbsWKlfu4MHD4aJiQl69OiBa9euITIyEiEhIZg0aRLevXtXoFhtbW0xfPhw+Pj44OTJk4iMjERwcDCOHDnCleHz+fD29sbs2bNhb28vdZlZ0R49eoRhw4Zh5syZqFevHuLi4hAXF4cvX74o7ZiEkNJNEec6e3t7BAYG4ubNm3jy5Al+/PFHxMXFcY/r6+tj+PDh3KC4x48fw8fHB2pqajKte9+bPHkyLl26hMjISNy/fx9XrlxBnTp1ivWaSfFRkkeUwtLSEjdu3IBIJIKXlxfq16+PSZMmwcDAgEvkfvvtN7Rp0wbdu3dH+/bt0apVKzg7O0vtZ/Xq1bCyskKbNm0waNAgTJs2TeoyqY6ODq5evQpra2v06tULderUgY+PD9LS0lCpUqUCx7tlyxb06dMH48aNQ+3atTF69GikpKRIlRk5ciQyMzOV3ooXFhaG1NRULFmyBBYWFtytV69eSj0uIaT0UsS5bu7cuWjcuDG8vLzg7u4Oc3NzmUnY16xZA1dXV3Tt2hXt27dHy5YtUadOHWhpaeW5b5FIhPHjx6NOnTro2LEjHBwcsHnz5qK+XKIgPFaQi+2ElBB3d3c4OTlh3bp1qg5Fxo0bN+Du7o53797BzMwsz7Le3t74+vWrwpc0K+ljEEIqtpSUFFStWhWrV6/GyJEjAWRf/Zg8eXK+c+d9b8GCBTh58iQiIiIUHyiRi1ryCMlHRkYGXr58iblz56Jfv375JngSZ8+ehZ6eHs6ePavQeK5duwY9PT25HbAJIaQ4wsPDcfDgQbx69Qr379/H4MGDAQA9evSQKjdz5kzo6ekhMTEx331GRUVBT08Py5YtU0rMJHc0upaQfBw8eBAjR46Ek5MT9u7dW6DnrFy5Er/++iuA7NHEiuTi4sL9EqbJRgkhirZq1So8e/YMAoEAzs7OuHbtGkxMTLjHQ0JCuFkOCjLy39LSkjtnaWpqKiVmIh9driWEEEIIKYfoci0hhBBCSDlESR4hhBBCSDlESR4hhBBCSDlESR4hhBBCSDlESR4hhBBCSDlESR4hhBBCSDlESR4hhBBCSDlESR4hhBBCSDlESR4hhBBCSDlESR4hhBBCSDlESR4hhBBCSDlESR4hhBBCSDlESR4hhBBCSDlESR4hhBBCSDlESR7J065du8Dj8biburo6qlWrhhEjRuD9+/cKPdayZctw8uRJme3BwcHg8XgIDg5W6PEK6tdff4W1tTXU1dVRuXJlpR9v48aNsLe3h0AgAI/Hw9evX+Ht7Q1bW1upcrnVFyGF8f1nPOdt2rRpePPmDXg8Hnbt2sU95+bNm1iwYAG+fv2q8Hgkx5N3c3FxUfjxSMlYsGABeDxevuW8vb2l/s91dXVha2uL7t27w9/fHxkZGSUQbfHJO2ergrqqAyBlg7+/P2rXro20tDRcvXoVfn5+CAkJwcOHD6Grq6uQYyxbtgx9+vRBz549pbY3btwYoaGhqFu3rkKOUxinTp3C0qVLMWfOHHTq1AmamppKPV5ERAQmTpyIUaNGYfjw4VBXV4e+vj7mzp2LSZMmSZXNrb4IKQrJZzwnS0tLmJmZITQ0FDVq1OC237x5EwsXLoS3t7fSfvhMmDABgwYNktqmp6enlGOR0kVbWxtXrlwBAKSlpSE6OhoXLlzA6NGjsXr1aly8eBHVqlVTcZR5k3fOVgVK8kiB1K9fn/sV7eHhAZFIhMWLF+PkyZMYPHhwsfadlpYGbW3tXB+vVKkSmjdvXqxjFNWjR48AABMnToSpqalC9pmamgodHR25jz1+/BgAMHr0aDRt2pTbnvMLlhBlyPkZ/54qPn/W1tYFPi5jDOnp6XmeR0jZoaamJvN/P2zYMIwYMQJdu3ZFnz59cOvWLRVFVzCl5ZxNl2tJkUg+gG/fvgUApKenY/bs2bCzs4NAIEDVqlUxfvx4mcs5tra26Nq1K44fP45GjRpBS0sLCxcuBI/HQ0pKCnbv3s0107u7uwPI/XLt6dOn4erqCh0dHejr66NDhw4IDQ2VKiO5RPD48WMMHDgQBgYGMDMzg4+PDxITE/N8jba2tvj1118BAGZmZuDxeFiwYAEAQCwWY+XKlahduzY0NTVhamqKYcOG4d27d1L7cHd3R/369XH16lW0aNECOjo68PHxkXs8d3d3DBkyBADQrFkz8Hg8eHt7A5Bt+s+rvghRpO8v1y5YsADTp08HANjZ2XHvv5LsTsHj8fDzzz9j69atqFOnDjQ1NbF7924AwIsXLzBo0CCYmppCU1MTderUwe+//y6zj6dPn6Jjx47Q0dGBiYkJxo4dizNnzsi8FltbW+5zmJO7u7vMZy4pKQnTpk2TOg9OnjwZKSkpcuPfu3cv6tSpAx0dHTRs2BBnz56VG+fAgQNhZmYGTU1NWFtbY9iwYcjIyMCbN2+grq4OPz8/meddvXoVPB4PR48ezbUe09PTMXXqVDg5OcHAwABGRkZwdXXFqVOnZMoWJuZz587ByckJmpqasLOzw6pVq3KNoTA8PT0xevRo3L59G1evXuW2Hz58GJ6enrCwsIC2tjbq1KmDWbNmydS7t7c39PT08PTpU3h5eUFXVxcWFhZYvnw5AODWrVto1aoVdHV1UatWLe49JSHp2hAYGIgRI0bAyMgIurq66NatG16/fi1zrO8v1xamDk+dOoUGDRpAU1MT1atXx/r16wt8yVsKIyQP/v7+DAC7e/eu1Pb169czAGz79u1MLBYzLy8vpq6uzubOncsCAgLYqlWrmK6uLmvUqBFLT0/nnmdjY8MsLCxY9erV2c6dO1lQUBC7c+cOCw0NZdra2qxz584sNDSUhYaGssePHzPGGAsKCmIAWFBQELef/fv3MwDM09OTnTx5kh0+fJg5OzszgUDArl27xpWbP38+A8AcHBzYvHnzWGBgIFuzZg3T1NRkI0aMyPO1379/n40cOZIBYBcvXmShoaEsOjqaMcbYmDFjGAD2888/s4sXL7KtW7eyKlWqMCsrK/bp0yduH25ubszIyIhZWVmxjRs3sqCgIBYSEiL3eI8fP2a//vorA8D8/f1ZaGgoe/nyJWOMseHDhzMbGxuubF71RUhhSD7jt27dYkKhUOrGGGORkZHce5IxxqKjo9mECRMYAHb8+HHu/ZeYmKiQeCTHW7FihUw8YrGYMcYYAFa1alXWoEEDduDAAXblyhX26NEj9vjxY2ZgYMAcHR3Znj17WEBAAJs6dSpTU1NjCxYs4I4RFxfHTE1NWdWqVZm/vz87f/48Gzx4MLO2tpY519jY2LDhw4fLxOnm5sbc3Ny4+ykpKczJyYmZmJiwNWvWsL///putX7+eGRgYsLZt23KxS+K3tbVlTZs2ZUeOHGHnz59n7u7uTF1dnb169YorFxERwfT09JitrS3bunUru3z5Mtu3bx/r168fS0pKYowx9sMPPzBra2uWlZUlFV/fvn2ZpaUl9/8oz9evX5m3tzfbu3cvu3LlCrt48SKbNm0aU1NTY7t375YqW9CY//77b8bn81mrVq3Y8ePH2dGjR1mTJk24us3P8OHDma6ubq6PX7x4kQFgixcv5rYtXryYrV27lp07d44FBwezrVu3Mjs7O+bh4SGzb4FAwOrUqcPWr1/PAgMD2YgRIxgANnv2bFarVi22Y8cOdunSJda1a1cGgIWFhXHPl3xWrKysmI+PD7tw4QLbvn07MzU1ZVZWViwhIUHqWDnP2YWpwwsXLjA1NTXm7u7OTpw4wY4ePcqaNWvGbG1tC1SHUscsVGlS4Xz/BZCcnMzOnj3LqlSpwvT19VlcXBz3oVu5cqXUcw8fPswlghI2NjaMz+ezZ8+eyRxLV1dX7sn0+yRPJBIxS0tL5ujoyEQiEVcuOTmZmZqashYtWnDbJEne97GNGzeOaWlpSZ145ZE8P2fi9uTJEwaAjRs3Tqrs7du3GQD2yy+/cNvc3NwYAHb58uU8jyORW1It74SRW30RUhiS95y8m1AolEnyGGPst99+YwBYZGSkwuORHE/eLTAwkDGW/WVpYGDAvnz5IvVcLy8vVq1aNZmE8+eff2ZaWlpc+ZkzZzIej8ciIiKkynXo0KHISZ6fnx9TU1OT+ez+9ddfDAA7f/48tw0AMzMz4xI1xrITTzU1Nebn58dta9u2LatcuTL7+PFjrvUlOT+eOHGC2/b+/Xumrq7OFi5cmOvz5MnKymJCoZCNHDmSNWrUSOqxgsbcrFkzZmlpydLS0rhtSUlJzMjISCFJnuT8+9NPP8l9XCwWM6FQyEJCQhgA9s8//0jtGwA7duwYt00oFLIqVaowAOz+/fvc9vj4eMbn85mvry+3TfJZ+eGHH6SOeePGDQaALVmyROpY8pK8gtRhkyZNmJWVFcvIyOC2JScnM2Nj40IneXS5lhRI8+bNoaGhAX19fXTt2hXm5ua4cOECzMzMuA6y31/S6Nu3L3R1dXH58mWp7Q0aNECtWrWKHMuzZ88QExODoUOHQk3t/29hPT099O7dG7du3UJqaqrUc7p37y4TQ3p6Oj5+/Fjo4wcFBQGQfb1NmzZFnTp1ZF6voaEh2rZtW+jjEFKS9uzZg7t370rd1NWL322bMYasrCypW0FMmjRJJp5mzZpxj7dt2xaGhobc/fT0dFy+fBk//PADdHR0pI7XuXNnpKenc/24goKCUK9ePTRs2FDqmN8P9CiMs2fPon79+nBycpI6tpeXl9zL2R4eHtDX1+fum5mZwdTUlOsCk5qaipCQEPTr1w9VqlTJ9bju7u5o2LCh1CXprVu3gsfjYcyYMfnGffToUbRs2RJ6enpQV1eHhoYGduzYgSdPnsiUzS/mlJQU3L17F7169YKWlhZXTl9fH926dcs3loLIzpWkvX79GoMGDYK5uTn4fD40NDTg5uYGADKvg8fjoXPnztx9dXV12Nvbw8LCAo0aNeK2GxkZSb22nL7vh96iRQvY2Nhw3w15KUgdhoWFoWfPnhAIBFw5PT29ItUhDbwgBbJnzx7UqVMH6urqMDMzg4WFBfdYfHw81NXVZU5EPB4P5ubmiI+Pl9qe87lFIdmfvP1YWlpCLBYjISFBanCDsbGxVDnJKNm0tDSFH//7k0JxXy8hJaFOnTpKmaIkJCQEHh4eUtsiIyPznV6iWrVqecbz/ecqPj4eWVlZ2LhxIzZu3Cj3OZ8/f+bK2tnZyTxubm6eZ0x5+fDhA16+fAkNDY08jy3x/TkJyD4vSc5JCQkJEIlEBRpFKhmR/+zZM1SvXh1//PEH+vTpk+/rOX78OPr164e+ffti+vTpMDc3h7q6OrZs2YKdO3fKlC9IzGKxWO5xi1O3OUnOr5aWlgCAb9++oXXr1tDS0sKSJUtQq1Yt6OjoIDo6Gr169ZI5x+vo6EgloAAgEAhgZGQkcyyBQID09PQCvRZ533XyFKQOGWMwMzOTKSdvW34oySMFktcXgLGxMbKysvDp0yepRI8xhri4ODRp0kSqfKE7jso5HgDExsbKPBYTEwM1NTWpX/iKlvP435+AY2JiYGJiIrWtuK+XkLLM2dkZd+/eldom+YIuju8/V4aGhuDz+Rg6dCjGjx8v9zmSxM7Y2BhxcXEyj8vbpqWlJXduts+fP0t91k1MTKCtrS03OZI8XhhGRkbg8/kyg7nkGTRoEGbOnInff/8dzZs3R1xcXK51kNO+fftgZ2eHw4cPS9VnUeeiMzQ0BI/HK3DdFsXp06cBgBv0cuXKFcTExCA4OJhrvQOglDkcJXJ7ffb29sXet6QOP3z4UKDj5ocu15Jia9euHYDsE0ZOx44dQ0pKCvd4fnL+msmLg4MDqlatigMHDkg13aekpODYsWPciFtlkVx6/f713r17F0+ePCnw6y2ugtYXIYpWmJZwfX19uLi4SN1yXoZSFB0dHXh4eCA8PBwNGjSQOaaLiwv3A83DwwOPHz/GP//8I7WPAwcOyOzX1tYWDx48kNr2/PlzPHv2TGpb165d8erVKxgbG8s9dmEnxtXW1oabmxuOHj0q0wr4PS0tLYwZMwa7d+/GmjVr4OTkhJYtW+Z7DB6Px026LhEXFyd3dG1B6OrqomnTpjh+/LhUC1hycjLOnDlTpH3mFBgYiD///BMtWrRAq1atAPw/2f9+DtNt27YV+3i52b9/v9T9mzdv4u3btwqZ4UBXVxcuLi44efIkMjMzue3fvn2TOwo3P9SSR4qtQ4cO8PLywsyZM5GUlISWLVviwYMHmD9/Pho1aoShQ4cWaD+Ojo4IDg7GmTNnYGFhAX19fTg4OMiUU1NTw8qVKzF48GB07doVP/74IzIyMvDbb7/h69ev3HB4ZXFwcMCYMWOwceNGqKmpoVOnTnjz5g3mzp0LKysrTJkyRanHlyhofRGiaI6OjgCA9evXY/jw4dDQ0ICDg4NUXyNVWL9+PVq1aoXWrVvjp59+gq2tLZKTk/Hy5UucOXOG6z88efJk7Ny5E126dMGSJUtgZmaG/fv34+nTpzL7HDp0KIYMGYJx48ahd+/eePv2LVauXCnTPWXy5Mk4duwY2rRpgylTpqBBgwYQi8WIiopCQEAApk6dKtWnsCDWrFmDVq1aoVmzZpg1axbs7e3x4cMHnD59Gtu2bZOq73HjxmHlypW4d+8e/vzzzwLtXzKd1bhx49CnTx9ER0dj8eLFsLCwwIsXLwoVq8TixYvRsWNHdOjQAVOnToVIJMKKFSugq6uLL1++FGgfYrGY6z+ZkZGBqKgoXLhwAUeOHEGdOnVw5MgRrmyLFi1gaGiIsWPHYv78+dDQ0MD+/ftlEnhFCgsLw6hRo9C3b19ER0djzpw5qFq1KsaNG6eQ/S9atAhdunSBl5cXJk2aBJFIhN9++w16enoFrkMJaskjxcbj8XDy5En4+vrC398fnTt3xqpVqzB06FBcuXKlwKtErF+/HjVr1sSAAQPQpEkT/Pjjj7mWHTRoEE6ePIn4+Hj0798fI0aMQKVKlRAUFMT9wlOmLVu2YPny5Th//jy6du2KOXPmwNPTEzdv3pTb50IZClNfhCiSu7s7Zs+ejTNnzqBVq1Zo0qQJ7t27p+qwULduXdy/fx/169fHr7/+Ck9PT4wcORJ//fWXVAu7ubk5QkJCULduXfz0008YMmQItLS0sGnTJpl9Dho0CCtXrsSlS5fQtWtXbNmyBVu2bJEZPKarq4tr167B29sb27dvR5cuXdCvXz9s2LAB1apVK9ISVw0bNsSdO3fg7OyM2bNno2PHjpg5cyY0NTVlWkOrVq2KVq1awcjIqMADSEaMGIHly5fjwoUL6Ny5M1asWIFZs2YVawBKhw4dcPLkSSQlJaF///7w9fVF7969c50fVJ60tDS4urrC1dUVnTp1wq+//opv377hjz/+wL1791C1alWurLGxMc6dOwcdHR0MGTIEPj4+0NPTw+HDh//X3nmHR1Htf/jd9IQUakgCoYQmvaPUhIuEIogdrxpRQH8IisBFFFApKggiYAPFhgIiXgVraBdJaIq00EEwCdmEQAiBdLIp8/tjM8Nuspud2WxI4bzPkwd29syZM1tmP/Otdp+DLT7//HMMBgOPPvookydPpkePHkRFRVmM67OHoUOH8sMPPyi/b9OmTeP+++9n1KhRmjvM6CRLqSoCgUAgENxmREVFMXDgQHbu3FntiounpKTQtGlTXnjhBRYvXlzZy6mRrF69mqeffpoDBw7c8j7K+fn5dOnShUaNGrFt2zbV+wl3rUAgEAgE1ZTExERiY2N55513cHJyqhL9UgXlZ9y4cQwePJjAwEAuXbrExx9/zOnTp3nvvfc0zSNEnkAgEAgE1ZTPPvuM+fPn06xZM9atW2fmyhRUXzIzM5k+fTpXrlzB1dWVbt26ERkZyd13361pHuGuFQgEAoFAIKiBiMQLgUAgEAgEghqIEHkCgUAgEAgENRAh8gQCgUAgEAhqIJoTLy5fvsz06dPZsWMHKSkppZoFFxYWOmxxVYGioiIuXryIj4+PaE8lEFQxJEkiMzOToKAgnJzEPWt5ENc6gaDqYu+1TrPIe+qpp0hISOC1114jMDCwxl8MLl68SHBwcGUvQyAQlIFer1fVyL06sWLFCt555x2Sk5Np3749y5cvp3///lbHr1u3jsWLF3Pu3Dn8/PwYOnQoS5YsUV2cW1zrBIKqj9ZrnebsWh8fH3bv3k2XLl20rq1akp6eTu3atdHr9fj6+pY5Nj8/n23bthEeHo6rq+stWqFjEedQNagJ5wAVfx4ZGRkEBwdz/fp1/Pz8HD5/ZbFhwwYiIiJYsWIFffv25ZNPPuGzzz7j1KlTNGnSpNT4PXv2EBoayrJlyxg5ciRJSUlMmDCBVq1asWnTJlXHVHutqymfTWvU5POryecGNfv87L3WabbkBQcHl3LR3ip27drFO++8w6FDh0hOTmbTpk3cd999Ze4THR3NtGnTOHnyJEFBQcyYMYMJEyaoPqZsqfT19VUl8ry8vPD19a22HzBxDlWDmnAOcOvOo6Z5FJYuXcq4ceMYP348AMuXL2fr1q2sXLmShQsXlhr/559/0qxZMyZPngxA8+bN+b//+z9NnQ/UXutqymfTGjX5/GryuUH1OL/09HQyMzMtWuMSExPx8fEpU8RpvdZpFnnLly/nlVde4ZNPPrGrF195yM7OpnPnzjz99NM8+OCDNsfHxcUxfPhwnnnmGdauXcvevXuZOHEiDRo0ULW/QCAQ3GoMBgOHDh3ilVdeMdsu90a2RJ8+fZg9ezaRkZEMGzaMlJQUvv/+e+655x6rx8nLyyMvL095nJGRARh/KPPz863uJz9X1pjqTE0+v5p8blD1zy8jI4MHHniAK1euEBkZaVa4OikpieHDh9OgQQM2btxY6kbL3nPSLPJGjx5NTk4OLVq0wMvLq5RaTktLs2shahg2bBjDhg1TPf7jjz+mSZMmLF++HIC2bdty8OBBlixZIkSeQCCokqSmplJYWEjDhg3Ntjds2JBLly5Z3KdPnz6sW7eO0aNHc+PGDQoKCrj33nv54IMPrB5n4cKFzJs3r9T2bdu24eXlZXOd27dvtzmmOlOTz68mnxtU7fObNm0aAEePHuXo0aNmz8lW+j179pTaLycnx67j2WXJqy788ccfhIeHm20bMmQIn3/+Ofn5+Q4152ZnZ7N7927i4+MdNqdAILh9KemWkSTJqqvm1KlTTJ48mddff50hQ4aQnJzMSy+9xIQJE/j8888t7jNz5kzlBwduxvyEh4fbdNdu376dwYMHV1mXWHmoyedXk88Nqsf5yRa7+Ph4mjVrxqpVq3j22WeVxyUtfDKypV0rmkXemDFj7DpQZXDp0iWLd8MFBQWkpqYSGBhYah97XRizZs3i/fffZ+jQoTzzzDMOOoNbT1U3d6tBnEPVoaLPo7q/PpaoX78+zs7Opax2KSkppa5nMgsXLqRv37689NJLAHTq1IlatWrRv39/3nzzTYvXOnd3d9zd3Uttd3V1VfUDqXZcdeCjjz7inXfeITExkRdffJEBAwbUqPMrSU0+N6ja59esWTO2bt1KWFgYp0+fVjLmQ0JC2Lp1q9UMd3vPR7PIA2MtvB9//JHTp0+j0+lo164d9957L87OznYtoiKxdDdsabuMvS4M+bmTJ09WaVOxWsQ5VA1qwjlAxZ2HvS6Mqoybmxvdu3dn+/bt3H///cr27du3M2rUKIv75OTk4OJifjmXr8eiPXnZnDhxgilTpvDjjz/SrVs3vLy8iIqKqvDjLly4kI0bN3LmzBk8PT3p06cPixYtok2bNjb3TUpK4uWXX2bz5s3k5ubSunVrPv/8c7p37w5AQUEBc+fOZd26dVy6dInAwECeeuopXn75ZQAWLVrETz/9ZNexBeUnODiYNWvW0LdvX2XbmjVrKqSEkWaRd/78eYYPH05SUhJt2rRBkiT+/vtvgoOD+e2332jRooXDF2kvAQEBFu+GXVxcrNaOsteF0atXL95++230ej2dO3e2aG5Vw7fffst7773HhAkTePLJJ7VnDWZkQFYWBAWVfu7iRfD2hhruihHnUHWo6POw14VR1Zk2bRoRERH06NGD3r17s2rVKhISEpTKADNnziQpKYmvv/4agJEjR/LMM8+wcuVKxV07ZcoUevXqRZCla4FA4eeff6Z79+5Kksqtsg5HR0czadIkevbsSUFBAbNnzyY8PJxTp05Rq1Ytq/tdu3aNvn37MnDgQDZv3oy/vz///PMPtWvXVsYsWrSIjz/+mK+++or27dtz8OBBnn76aby9vWnRogW7d++269gCx6DX64mIiDDbFhERQVRUlOOFnqSRYcOGSUOHDpWuXr2qbEtNTZWGDh0qDR8+XOt0dgNImzZtKnPMjBkzpLZt25ptmzBhgnTXXXepPk56eroESOnp6TbHtm/fXgKk9evXq56/JP3795cACZB+/vlnbTtfvy5Jd90lSSEhkpSQYP5cQoJx+113GcdZwWAwSD/++KNkMBjsWH3VQJxD1aGiz0PL97O68dFHH0lNmzaV3NzcpG7duknR0dHKc2PGjJFCQ0PNxr///vtSu3btJE9PTykwMFB6/PHHpcTERNXHU/ta1pTPpiRJUkhIiHK9BaQnnnii0s4vJSVFAszeZ0u8/PLLUr9+/cocc88990hjx4412/bAAw9Ijz32mMVzU3vsqk51+GwmJCQon7uQkBBp7969Zo8TSv52F2PvtU5zH6Do6GgWL15M3bp1lW316tXj7bffJjo6unyK0wZZWVnExMQQExMDGEukxMTEkJCQABjvbp988kll/IQJE7hw4QLTpk3j9OnTfPHFF3z++edMnz69QtY3YMAAAKtlDtRw9uxZ5f8nTpzQtnNmJqSkQGwshIWBXm/crtcbH8fGGp/PzLR7fQKB4NYwceJE4uPjycvL49ChQ8r1BWD16tWlXIovvPACJ0+eJCcnh4sXL7J27Vq7PQq3C3/88QchISFKZ5EVK1ao3nfBggV4e3uX+bd7927V86WnpwOY/bZa4ueff6ZHjx48/PDD+Pv707VrVz799FOzMf369WPHjh38/fffgDGTc8+ePQwdOrRcxxaUj8TERMLCwoiNjSUkJISoqCj69OlDVFQUISEhxMbGEhYWRmJiosOOqdld6+7uTqYFkZCVlYWbm5tDFmWNgwcPMnDgQOWx7FYdM2YMq1evJjk5WRF8YCwIGhkZydSpU/noo48ICgri/fffr7DyKW3btgWMplh7yMnJISUlRXl84cIFbRM0bgxRUYqgO9S7N9deeom733/fKPBCQozP17D2TwKBQGAP3t7exMfH069fPwICAgD17toJEybwyCOPlDlGrciWJIlp06bRr18/OnToUObY2NhYVq5cybRp05g1axZ//fUXkydPxt3dXTFyvPzyy6Snp3PHHXfg7OxMYWEhb731Fo8++iiRkZF2H1tQPnx8fPD39wcwc80GBwcTFRVFWFgY/v7++Pj4OOyYmkXeiBEjePbZZ/n888/p1asXAPv372fChAnce++9DluYJcLCwsoMIl69enWpbaGhoRw+fLgCV3WT+vXrA3DlyhW79o+NjTV7rFnkAQQHQ1QUuQMG0CM+HqZM4RzQUhZ4ojelQCAQAHDs2DEAOnbsqHnfunXrOszy9fzzz3Ps2DGL9dFKUlRURI8ePViwYAEAXbt25eTJk6xcuVIReRs2bGDt2rV88803tG/fnpiYGKZMmYK/v7/yO2XPsQWWUdvFws/Pjy1btlgcGxwcTHR0tM2OF1rR7K59//33adGiBb1798bDwwMPDw/69u1Ly5Ytee+99xy2sOqIrNBNrXFa+Oeff8we2yXyAIKD2TFxovJwJ8CaNdoFXno6WDMbJyYanxcIBIJqSkxMDC1btlSSDYYNG8a8efOYMWMGLVu25NSpU1b3dZS79oUXXuDnn39m586dqhrPBwYG0q5dO7Ntbdu2NfNivfTSS7zyyis8+uijdOzYkYiICKZOnVqqzZ3WYwtKk56eztChQwkNDS3lxdPr9YSGhjJ06FDFJe7n52f1tW7cuLHDe3BrtuTVrl2bn376iXPnznHmzBkkSaJdu3a0bNnSoQurjjRo0ACw35J3/vx5ALp168bhw4e5cOFCmQVQraLX8+MbbygPdwPPRERos+RlZMCIEcYYvpL7yTF+/v6wZQvUoMbwAoHg9iEmJobOnTsrj0+cOMFDDz3E4sWLiYmJ4ZdffiklqGTK666VJIkXXniBTZs2ERUVRfPmzVWtuW/fvmax2wB///03TZs2VR7n5OTg5GRuw3F2dqaoqEg59vPPP6/52ILSZGZmkpKSosTTyW5YvV6vxN/J4xwt4NRgV508gFatWtGqVStHrqXaI1vyrl+/jsFg0ByjKFvyBg4cyOHDh8nJyeHq1aulzOtlUizANpvETUa7uNxMxlAr9LKyzJM45P1MkzjAmMQhRJ5AIKiGxMTEKGFG6enpuLq68uSTTxIZGYmbm5tZWZKSlNddO2nSJL755ht++uknfHx8lHJffn5+eHp6AvDhhx+yadMmduzYoew3depU+vTpw4IFC3jkkUf466+/WLVqFatWrVLGjBw5krfeeosmTZrQvn17jhw5wtKlS5VmBpMnT+bbb78t89gCdTRu3FiJp5OF3po1a4iIiDBLsLBqKZUk0GrI0YAqkTdt2jTeeOMNatWqZVZDzhJLly51yMKqI3Xq1MHJyYmioiKuXLmiObNNNre3adOGwMBAkpOTuXDhgnqRl5gIYWHkxcZy0XTeggKSmzQhUBZs0dG2ky+CgsySOG4MGID72rXonnxSexJHerpRDFoam5gIPj5CKAoEgltKUVERx48f57XXXgOMVjw5zhyMhe3luoQVwcqVKwFjrLkpX375JU899RRg7GNcMoynZ8+ebNq0iZkzZzJ//nyaN2/O8uXLefzxx5UxH3zwAa+99hoTJ04kJSWFoKAg/u///o+ZM2fyv//9j08++cTmsQXqMU2ciI2NVYocywLPau27PXvgP/+Bb76BCqoxrErkHTlyRMk4OnLkSIUspCbg5OSEn58f165dIyUlRbPIS0tLA4wJHE2bNlVEnlzF3CY+PuDvz6X8fNDrcXNzo379+ly8eJGkjz4i8MUXjS5WtZk7wcEYtm3jkU6d+CU+nvv69eMHuCnw1FgE09Nh6FDh9hUIBFUKJycnsrOzlccnTpwwS8A4ceJEhWablpVEKDN37lzmzp1bavuIESMYMWKE1f18fHxYvnx5qV7z8u+4wWCo1kXWqyKaulhcvgwvvwxffWV8/OqrsH59haxLlcjbuXOnxf8LSmMq8rQii7y6desqPSo1xff5+cGWLSRHR8OoUQQEBCgi77JOZ7TgabSa7b94kZ+KW0f9BBQALlqSOErW7hNuX4FAUAU5efIkd999N2Bs3ZmdnV2mu1YgMEVVF4vCQvj4Y5g9+2bi4vjxsHBhha1Lc3bt2LFjLdbJy87OZuzYsQ5ZVHVGDqwsr8irU6cOYGxho3EBJBcWAsYsLLn206VLl4zuUo1C6tz+/cr/C4F4gIiIm4WWbSHX7gsJuSn09u27KfBE7T6BQFAFeP/995X4PGdn5zIzawUCU0yTLEJCQti7d69ZcWO9Xg/790OvXvD880aB17Ur/PEHfPopaIm714hmkffVV1+Rm5tbantubq7SR/F2xl6RJ0mSRZEnb9NCcnIyYBR5skXw8uXLmudBr+fcW2+ZbTrdsGHpjhq2KK7dl92sGe/ExqLv29dc4Km1CoqSLgKBQCC4BaSnp1vtPJGYmKiURLHVxSI9NpZ97dvDXXfB4cNGQ8uHH8KBA8ZtFYxqkZeRkUF6ejqSJJGZmUlGRobyd+3aNSIjI5Xs0tsZe0VeZmYmhcUWONOsLc2WPMxFnpklTwsXL0JYGOeuXzfbfHrsWHOrnNr2K8HBfDB0KDOATkARaKvdJ8f2hYaWFpd6vXH70KFC6AkEAoGgXGipfSd3sSiZZBHcqBEHnnmGc05OjJa9n2PGwN9/w6RJ4Ox8S85FtcirXbs2devWRafT0bp1a+rUqaP81a9fn7FjxzJp0qSKXGu1wNfXFzBmRWlBtth5eHjg6elpv7uWmyIvKCjIfkuetzf4+3OuuAzMXcV3HKeTk2+6X7Ukcej1bPzySwCuA+tBm9tX9OUVCAQCwS2gZO07WeiZumVTUlKU2ndbtmwhOjr6ZuzdoUPQuzd1Z86kTlERhe3bw+7dsHq18XfzFqK6Tt7OnTuRJIl//etf/PDDD2b1gdzc3GjatClBQUEVssjqhJeXF2C0fGpBFnPy61oekXfxorGASmBgIN7e3oAdljxfX6TNmzlf/J6OHDmSP//8k9OnTxutb1qSOPR6pNBQYvPylE0/1qrF41pq95Xoy0tYmNESGBFROrZPZe9JgUAgEAhKorX2ndyyjGvXjEkVH39srH/n4wNvvIHzpEngYndZ4nKh+qihoaEAxMXFERwcXKqatsCIvSLPNB4PyifyTN218nrsiclLzskhJzcXZ2dn7r77bmbPnn2z1ZraRIni2n3n4uK4arI5LiQEsrNvCjY1tfuKY/sIC2NDbCwr+vZlLRAs+vIKBAKBwIFoqn1XVGQshzJjBshevMcegyVLIDCwElZ/E83SUm6dkpOTQ0JCAgaDwez5Tp06OWZl1ZSqIPJkq11AQICyHs2WPFCCThs1aqRYaVNTU7W1Wiuu3fdHZiZcuYKvry8ZGRnEJSVBTMzNOnkaavflfPopjw4aBMBbwMf29uUVBZoFAoFAYAVVte9iYowxdvv2GR+3awcffWT8basCaDbHXblyhREjRuDj40P79u3p2rWr2d/tjiyq0jUmADhK5Jlm6davX1+JyUtPT+fGjRua5pLjChs0aKD05S0oKOB6iWSMMimu3RdbXI39nnvuAYznm+HnZ7TgaSmErNfz1ejRysMDoC22D0QSh0AgEAhsYq32nV6vN/4+vPgidO9uFHi1asE779w0XlQRNIu8KVOmcO3aNf788088PT3ZsmULX331Fa1ateLnn3+uiDVWK+S+f46y5KWnpytZt2q4ceOGYl2tXbs2tWvXViqba834lUVe/fr1cXd3x6fY2qapQDMYa/cVV5Zv3bo19erVA4yuf021+4qTLH4ySWo5AqRqLekikjgEAkEV5IknnkCn05n9DR8+vLKXdVtSVu27Zd27U9iqFbz/vtFV+8gjcOYMTJ8OVayTiGaR9/vvv7Ns2TJ69uyJk5MTTZs25YknnmDx4sUsrMCqzdWFWrVqAY4TeaDNKihb2ZycnPD29kan0ylV27VaF01FHqBY8zSLPMzjBJs3bw4Uizy1FMf2ERtLnMmXSAKi/f21lXQxKdBcGBvL3336kBoZKQo0CwSCSmXs2LEEBwfz+OOPs3HjRo4ePcq6desq5Fi7du1i5MiRBAUFodPp+PHHH23us3DhQnr27KmUDbnvvvs4e/as6ucB1q1bR3BwMHXr1uWll14yey4+Pp7WrVtr/v10NNZq3+395BP+9PBg6ZUrOF+5Qn5ICGzbBhs2VNnfC80iLzs7W6mHV7duXeUHv2PHjhw+fNixq6uGyJa8zMxMioqKVO9XUuS5uroqglGLy1YWeX5+fkpyTI0QecWxfUXNmxNfHA8ox0n8M26c9pIuxUkc4R4etElMpOU993BNFGgWCASVhMFg4Mknn+Tll19m7dq13H///XTq1Mnsht+RZGdn07lzZz788EPV+0RHRzNp0iT+/PNPtm/fTkFBAeHh4UoPYFvPp6amMn78eJYsWcLWrVv56quv+O2335T5n3vuOd5++22lFFllUar2Xe3aMH06AUOHcueNG+TqdKwMDibnjz9g8OBKXastNCdetGnThrNnz9KsWTO6dOnCJ598QrNmzfj4448JrOQskqqAHJMHKDV01CALOdNeiXXr1iU7O5u0tDRatGihah5Z5JnOI69BUywdN0We7F6tVJEn9+X9+28MvXrh7OxM79692bt3L4lZWeYlXVSWULnu48PvxXGK6cBfwBB7CjSnpJQWhrLr199fW8yhQCC4LYmJieHy5cs888wzt+R4w4YNY9iwYZr22bJli9njL7/8En9/fw4dOsSAAQNsPh8bG4ufnx+ji+OqBw4cyKlTp7jnnnv45ptvcHNz44EHHijfiZVBeno6mZmZSukTUxITE/Hx8VHKoWzZsoXMjAwa79sH06YZGwQA3H8/12fM4LG2bVX/vlcmdsXkyT/Yc+bMYcuWLTRp0oT333+fBQsWOHyB1Q1XV1clBk6LyVkea3oHY0/yhSWRJ//fXpFXXkteYWGhUsIlKCiIRo0aAXaUdfHzI6641l5wcDDNmjUDjLET9vTlPbp9u9njQyAKNAsEgkqhdu3aFBQUsGDBAvR6vU1P0IIFC/D29i7zb/fu3RW6Ztk7ZFo3t6znW7VqRU5ODkeOHCEtLY0DBw7QqVMn0tLSeP311zVZFe1Zq9ouFgB+yck0fvppePRRo8Br0QIiI2HjRgLvuqtaCDyww5L3eHGWJEDXrl2Jj4/nzJkzNGnSRBEDtzM6nQ4/Pz9SU1M1ibzMYiHgY+JutEfkyR9QSyKvsty1qampFBYWotPpaNiwoTKf1q4gYIzZAGjevLmSxm6tv2CZ6PUcfe45s02Ha9W6KdjsKNC8pVcvmixZQrvXX7cvtk+UdREIbltat27NihUrmDp1KvPmzUOn03HmzBlat25tcfyECRN45JFHypxTvqGuCCRJYtq0afTr148OHTqoer5OnTp89dVXPPnkk+Tm5vLkk08yZMgQxo4dywsvvEBcXBz33nsv+fn5zJ07l4ceeshh6y3ZxUKudWeaYAGQdfkyfm+/De++a/QKeXjAzJnGGngeHg5bz62i3CWYvby86NatmyPWUmPw9fV1iMiT/5+pwRJUEe7a8oo82fLboEEDXFxcyiXyZBdvs2bNFJFX8q7MJsVJHEevGssz9+3Rg70HD3K4bl1o2NCuAs2He/dmWFISbk88wXnsKNBc0vVb3HO4+ASF61cgqOG88847vPPOO0yfPp2wsDD8/f1p1aqV1fGmPc4rg+eff55jx46xZ88eTc/ff//93H///crjqKgojh8/zocffkjLli1Zv349AQEB9OrViwEDBig5AOXFZheL5s3Z//LL1L/77ptemXvuMWbQhoQ4ZA2VgSqRN23aNNUTLl261O7F1BRkcabFcuZokWdqSq5sd61pPJ7pfOURec2bN1fiKi5fvozBYMCtuM+uTYqTOI4mJoLBwNMTJrB3/Hji9HquHTtGnfvu05zEsenuu+GrrzAAzwM/aS3QXNL1u2OHcXtSEgwaZNwujxMiTyCoUezdu5fZs2dz7Ngx7rjjDlX7LFiwwGaI1ObNm+nfv78jlmjGCy+8wM8//8yuXbssxrfZel4mLy+PiRMnsnbtWs6fP09BQYHSXat169bs37+fkSNHOmzd1rpY/Cs4mF+bNMHz//7POLBpU6O4u/dehx27slAl8o4cOaJqMtVdEGo4clxdVbHk2eOuLSoq4mqxpasiRZ6m7hkmczVu3Fip35eXl0dSUpKS0GETPz+kzZs506gRGAz069cPf39/UlJSSCgqoo6WvrwAej2/rV+vPNwGFD7xBM7R0eqFXsnevMOHw8KFxn9FWZfbkhUrVvDOO++QnJxM+/btWb58eZk/2Hl5ecyfP5+1a9dy6dIlGjduzOzZsxk7duwtXLXAHrZs2ULHjh1VCzyoHHetJEm88MILbNq0iaioqFLXXFvPl+SNN95g2LBhdOvWjSNHjlBQUKA8l5+fr6lGrFpMu1h4AjOB2Zcu4aTXg5ub0S07cyaYJFFWZ1SJvJ07d1b0OmoUWkWeJElVzl17/fp1JfBXzq6VxZks/tRSUizK/xoMBrKysszO2RaywGzQoAE6nY7GjRvzzz//oNfr1Ys8INPJieycHOBm27aUlBQuXrxI586dVc+DXk9yv34cMWnvdwO4EBdHiNrYPpli12/mgAGsOHeOeleuQHy8fWVdRGxftWbDhg1MmTKFFStW0LdvXz755BOGDRvGqVOnaNKkicV9HnnkES5fvsznn39Oy5YtSUlJMfvRFFRdmjRpwtGjR3nnnXe45557CAoKMruGW6K87tqsrCzOnz+vPI6LiyMmJoa6desqn7EPP/yQTZs2saPYszBp0iS++eYbfvrpJ3x8fJR2mX5+fnh6etp83pSTJ0+yYcMGYmJiALjjjjtwcnLi888/JyAggDNnztCzZ0+7z88acheLEcD7QHOA/HxyQ0Px/PRTKMNFXh3RnF0rc/78ebZu3Upubi5gFCq3ghUrVtC8eXM8PDzo3r17mdlDUVFRpaqHy8GsFYks8tRaznJzcxVBZUnkZWVlqT62o7JrZVeqj4+P4gaVxaLWBA5Z7Mr7e3l5KV94rS5b01ZrgBKXl5SUpGke2SLo4+ODt7e3cseraZ7i2L5TCQkAtGnRQundfMo0tk9LYkhwMM+0aMErBQWsWLHCuM2esi6iZVu1ZunSpYwbN47x48fTtm1bli9fTnBwMCtXrrQ4fsuWLURHRxMZGcndd99Ns2bN6NWrF3369LnFKxfYw7hx45g3bx5ffvkl3bp1o06dOowZM6ZCj3nw4EGzdqTTpk2ja9euvP7668qY1NRU/vnnH+XxypUrSU9PJywsjMDAQOVvw4YNqp6XkSSJZ599lmXLlin1YD09PVm9ejXz589n3LhxfPjhhw63ROr1ep7o25flsbH8glHgJTs78yDQISEBfTVMrLCF5sSLq1ev8sgjj7Bz5050Oh3nzp0jJCSE8ePHU7t2bd59992KWCdg390twNmzZ81Kk8gCoaLQaskztdTJH3ioXHetPNa0EKc8T0ZGBkVFRUqxZbVzmcYJ1q9fH71eT2pqqiYLnGzJK+lC1ioWS7qQg4KCALgo10JSQ3FsX1xGBqSmEtK6NX5+fhw7doxTY8cyYsMGbbF9wLFt29hQfNd85MgREj08aB4Rod6SVzK2T97PtKyLPE5Y86okBoOBQ4cO8corr5htDw8PZ5/cBL0EP//8Mz169GDx4sWsWbOGWrVqce+99/LGG2+UsqDI5OXlkVdckghuXq/y8/PJL6PWpPxcWWOqM5V1fjNmzGDGjBkA/PLLLzz44IN88sknODs7O+wYpufWt29fpQWmtXGzZ89m9uzZymNr4+V9bD1vSlRUVKntQ4YMMbMuan0PynrvLsbG8nO/fmxJTcUTkFxcKJoyBcPTT3P6oYdIjo9nyJAhbN68Wfk9qErY+3nULPKmTp2Kq6srCQkJtG3bVtk+evRopk6dWqEiz/TuFmD58uVs3bqVlStXltlSzd/f36bp25FoTbyQRZy3t7eZcPL29jZ7Xg2OctdaEmby/2X3sto6QZbmqlevHnq9XpPrNycnh5xiF6ss8mRXsr0iT/4y2yXyigs0x7/2GnzwAc2aNVPmOXXxonmBZjXo9WwsLhIqs87Hh1fLUdaFsDCjJTAiQsT2VRPkkkMNGzY0296wYUPF/VWS2NhY9uzZg4eHB5s2bSI1NZWJEyeSlpbGF198YXGfhQsXMm/evFLbt23bZlbU3RrbS9SZrGlU1vnduHGDb7/9lhYtWrB169YKOcbt9t75HzpEx08/5YXi34krHTty7NlnyQoOhnPnzPRDTEyM4kKuSsi/fVrRLPK2bdvG1q1bS2XMtGrVigsXLti1CDXYc3cr07VrV27cuEG7du149dVXGThwoNWx9t7dymPAvH+tGvUttzTz8fExGy/fgaudB27W1PP29i61nvT0dNXnIK/J19dX2ebs7KwkOqSmpqr6IYCb4rJWrVrKXLI4u3Tpkupzk3/gXF1d8fT0JD8/X7E0XrlypdRdXFnzyrX1GjZsSH5+vvKDqtfrtd0xeXnxT7F1sUmTJoQUp9qfOHGCfPlHWs18Fy/CsGGcKBb0TRo1IiEpiT86diQ/OdkYmzdkCGzeDLbuMgMCYMcObgwdyn9jY0kIDeU/Li54tG1rLOYZEKBuTRkZkJVl+XgXL4K3N9hoP1TRVpGaak2C0olsZSUpFRUVodPpWLdunXIztXTpUh566CE++ugji9a8mTNnmlVOyMjIIDg4mPDw8DLbSuXn57N9+3YGDx6sFH6vSVT2+X322WdcunSJTZs2aUrEUENln5ujycjI4IEHHuDKlStERkbi7++vnF9KSgrjBg9mzrVr9C42JhQFBHB19mxqP/ssA0p8ly5evIi3t3elt1Szhr39fDWLvOzsbIs/7qmpqbi7u9u1CDXYc3cbGBjIqlWr6N69O3l5eaxZs4ZBgwYRFRXFgAEDLO5T3rtbuCkgzp07R2RkpM3xJ0+eBIwXddPxcmPnxMREVfPATXfmsWPHlFg+eVtaWprqef7880/AeFdpuo+Hhwd5eXn8+uuvSscJW8hlT2JjY5W5ZLP+7t27VfdmlGNDvL292bx5M3Cza8aJEydKnVtZd6t79+4FjPGQkZGRigXvzJkzql8jGfmuLy0tTfkxVfvem7FwIX+98ALo9XTt0YOEpCRizpwhUo7NMx7M+KeCj5o0Ybv8GRozxliK4OhR458WHHBXW1GWA3vvbqsy9evXx9nZudR1LSUlpdT1TyYwMJBGjRqZWcvbtm2LJEkkJiZarLfm7u5u8Zpt2rWnLNSOq65U1vk999xzPFeiULujqSnvXW5uLomJicTGxjJo0CAlQSQlMZH/3nUXv1y7hhcgOTujmzIFpzlzaGAlfKZp06a3cOXasfv9kjQyfPhw6dVXX5UkSZK8vb2l2NhYqbCwUHr44YelBx98UOt0qklKSpIAad++fWbb33zzTalNmzaq5xkxYoQ0cuRIq8/fuHFDSk9PV/70er0ESKmpqZLBYCjzLzs7W/rxxx+lFStWSIA0fPhwm/sYDAbpxx9/lACpW7duZtv/97//SYDUunVrVfMYDAapVq1aEiCdOXNG2XblyhUJkAApIyND1Tm8/fbbEiCNHj3a7PlWrVpJgPT777+rXlPXrl0lQPrpp5+UbRMnTpQA6ZVXXlE9z2+//SYBUocOHZRtX3zxhQRIgwYNKnUO2dnZVud69NFHJUBatGiRZDAYpP3790uAFBAQoHo98l9gYKDy2bx48aLyWmdlZWmaJ+viRcnFxUUCpB07dkiA5OLiYjyP+HjJoOIzqPzFxUnBxXMB0hAnJ8nQtq1kiItTt398vHG8p6f5fnFx5tvj41V9nsp6L8rzl5qaKgFSenq63deWqkivXr2k5557zmxb27ZtpVdeecXi+E8++UTy9PSUMjMzlW0//vij5OTkJOXk5Kg6Znp6uqrX0mAwXrMMBoOqeasbNfn8auK5JSQkSCEhIRIgtW3bVto7b570j5ubJIEkgZR7552SdPx4ZS+z3Kj9fpZEsyXvnXfeISwsjIMHD2IwGJgxYwYnT54kLS1NsY5UBPbc3VrirrvuYu3atVafL+/dLdxMvMjJyVG1j5yh7OvrazZetnBlZWWpmqeoqIjs7GxlX3mfunXrotPpkCSJ7OxsVSVLZCug6TxwM9ZP7Zrgppm5Xr16yj5yFfNr166pnkd2+/r7+yv7yO99WlpaqXnKes9kC2Djxo1xdXVV7uIuX76MTqfDxUXdV+PGjRtKfF+rVq2Uc8zPz+fq1atlJgSV5Ny1axQUFODt7U3fvn0V13hiYqLV1kYW0etJCA1Fb1I+I1qSKDh9Gs9Bg9TF9jVtClu3GmP6Tp8mfeBAct57j8CpU2/G9m3dqjrr1zU3F9e0NIeXdalMa0RBQQE7d+5k8+bNxMbGkpKSgqenJw0bNqRXr16MGDGCli1b2jX3tGnTiIiIoEePHvTu3ZtVq1aRkJDAhAkTAKOrNSkpia+//hqAxx57jDfeeIOnn36aefPmkZqayksvvcTYsWOtJl4IBDUBucDxo/36MfXvv+kzZw4AV5ydcXr3XepNngy3cQ1fzSKvXbt2HDt2jJUrV+Ls7Ex2djYPPPAAkyZNUjIVKwI3Nze6d+/O9u3bzVqibN++nVGjRqme58iRIxW6TrgZA6e29ImlGnmmj9XOY+q6kpM2AJycnPD29iYzM5PMzEwCTFtmWaFk2RMZezJ15blMYx3sKcdSMrPW9P9aa/eVzK6VW64VFBRw+fJl1an7CcXlU2rVqkW9evXQ6XQEBgaSkJBAcnKyJpEnu+3btWuHk5MTgYGBxMfH8/fff6sXecVlXfYUr6tn585cTE0lKSmJPQEBDLajZVthaCh3xsURN2oUXwOjtdbtA3jgAePaSu5XTVu2ffHFF+zevZs77riD8PBw/P39lfjVjIwMzp8/z4oVKzAYDEycOJF27dppmn/06NFcvXqV+fPnk5ycTIcOHYiMjFRuRpKTk5XPHhi/79u3b+eFF16gR48e1KtXj0ceeYQ333zToectEFQ58vMJ3rCBXVeu4FxYiOTkxAqdjh6//cadQ4ZU9uoqHU0iLz8/n/DwcD755BOLcWsVjda72+XLl9OsWTPat2+PwWBg7dq1/PDDD/zwww8Vuk5ZYMlWNVtYE3nyPFlZWao6Q8hiUKfTlbp79/HxUUSeGiwJM3B8pq4WkVeyRh7cTODQKvJki7AseJ2cnKhbty4pKSlcvXpVtciT5wkKClLen6CgIBISErRl6nIz5rBNmzaAsUhzfHw8Z8+eZcSIEeomKS7rsic1FTIy6D9oEElJSWzYsIFj48cz+JtvNLds+33yZM5OnQrA40D/pUsJ0iLwAK5cqRFlXXJycvjvf//LoEGDyuwkceedd/L4448jSRK//voraWlp9OvXT9OxJk6cyMSJEy0+t3r16lLb7rjjjhqfNSm4PUhPTyczM9NiS7TExER8fHyMvyFRUTBpEpw6hTPwp5MTuUuW8NLs2QROnEhUVJRSS/V2RZPIc3V15cSJE5XWvkzr3a3BYGD69OkkJSXh6elJ+/bt+e233xg+fHiFrtNUnKnBliWvqKiInJwcsxp6lpCP5+3tXeo90lpzz5IwA+2WvBs3bihJFo4SeaaWPFnkZWdnc+PGDTxUFLMsLCxURKq8vzxvSkqKpnIsKSkpAGZNtGXroGwtVItciFm+sMnlWM6dO6d+kuKyLqeGDoU//6Rbt25KwtD51FS7yrp89dprysNCYNezz/Jot27aLHmRkTd78Fbjsi5eXl6aitTqdDqH9t4UCGo66enpDB06lJSUlFIiTa/XExYWRtvatdnYsiVu330HwFUnJ6YXFfFX69YsCAmhWbNmnD59mrCwsNte6GnuePHkk0/y+eefV8RaVDFx4kTi4+PJy8vj0KFDZlmyq1evVgosgrG45Pnz58nNzSUtLY3du3dXuMADlB/V8oq8WrVqKWJNjTgzFXkl0SryrLlrtYoz07Rv03WVR+SZCjM/Pz+lWKhaa55cZgYwawtkj1XQksizq+aeyXh5f1nMau3mgZ8fccVzhYSEKHFh586dMwopDQJPCg3ll+LPVa9il+PelBSjUCvZUaMsGjWCqCgymjXj37GxvNO3r7nAu40vwgKB4CaZmZmkpKQQGxtLWFgY+uLrjF6vZ1BoKCNiY1l/5Ahu332HpNOxzseHVkVF7AoJ4bfiqguRkZGEhIQocyRq6TpUw9Ack2cwGPjss8/Yvn07PXr0KGVdWrp0qcMWV11xlLtWp9NpiqVzpMiTxVd53bXyPD4+PmaV2+0RefJY00LPOp2OevXqaXKzyiLOz8/PLMHCnsLKjhR5spiTz0EWoFrnyc/PVy5qzZs3V1rmmVaSt0lxbJ8+Lo4MjFb8ybNm8cQTT7DXze2mRU5NbJ9McDATWrXi2/h4vgUGA120tGyrAjRv3twuT8aUKVOYPHlyBaxIIKhZNG7cmKioKMLCwhSRtmbNGpY//DD/vXiRzmDMm+3Zk+zFi/lw5kzqFFv9AgICOHr0KI0aNVLm8Pf319QfvaahWeSdOHGCbt26AfD333+bPVdZbtyqhiyyDAYDBoNB6f1qDWsiT96mNpauLJEni7XyWvK0umutuX21tn6Dm8Ky5FyyyFMrzuRCzyWbe9uTxOFId60s5sor8hISEigqKlIyPeXvZUJCAnl5eerqWRbH9p3MyYFLl2jdujVhYWEAHC0oILNZM3zsaNm23iRmbBYQqaVlWxXAUiycGtTWlBQIBDczZsPCwsiMjeXvvn35rvi5Qj8/nBcvhnHj8HZ2ZsuWLUr8nmlx9ODgYKKjo2/G792maBJ5hYWFzJ07l44dO5b6gRTcxNS6mZ2dbVPkOcoCdyvdtVotedbmyczMVN0H15IlD7S7WeVxpm5fe+aBmyLPtIyPPZa8oqKiUq3W5O9YSkoKBQUFqsu6yMWnmzVrhk6nU+5kMzMziY2NNWtHaBU5tm/JEnjzTdq3b0+jRo1o2LAhly9f5u+PPqJ7377qXb9JSex+7DEAmrq4cKGggB1AXmws7mpbtlUBQkNDK3sJAsFtQXBQENvvv586776LXC7/8ogRNPzySzCJy/bz87Mq4iwlbtxuaIrJc3Z2ZsiQIZpcbLcjbm5uSv0uNXF5slvXUmKFlv61pj1wS1JZiRe2snSl4j645VmTLIbUCk9rljxHuWvl/8slX9TOU1BQgE6nU9zyvr6+ODs7U1RUpBxHDaYiD4wWdrO4PLX4+XGy2IUslwBp0aIFAOe1ZsIOH86+YvE8dvJk6tWrhwE4FhR00/VbzeNmvvzyy8pegkBQM9i/H0OXLoQUC7zDwF1An1On0BfXlRWoQ3PiRceOHYmVSx4IrKIlLq8skVcZlryCggKzAs2mOMqS5+HhoVg4y+v6lYWnaUJFWViz5NnjrpWLKpuKPFOLoCRJquaRrX4NGzZULHbOzs6KhVCLVVAWec2bN1e2yYJPryVZAvPafXBT5MnlXlTToAH7is+r7/Dh9OrVC4C/nnvOmHyh0fVbFdm4cSM7d+5UHufm5vL4449X4ooEgmrG1avw7LNIvXvjduIE14E59epxY9curpgkUmi9jt3OaBZ5b731FtOnT+fXX38lOTmZjIwMsz+BES0FkWWRZ0mcaRGLjhJ5pkWVS4o8rbF91oSZ6TY1Is9gMHDjxg2Lc8kiz1GWvPLG5MnzGAwG1ck3JZMuZOT4Pi0iLz4+HjAXefYmg8iWP7lRumwR1CryklesIL6gACcnJ3r16nVT5J07Z0zeqEaFkK2xdu1aZs+ezZkzZzh37hz9+/dX4hgFAkEZFBXBp59C69bw6afoJInVQHiTJow/coQ+/fsTFRUlMmbtQHPixdChQwG49957zRIt5GK9hYWFjltdNUZLrTx5TFnu2soQeV5eXqXaRmlNmLDmrpW3XblyRdVcpkKw5Fxy+7fyWvK0umsNBoNZqzUZLy8vpSXZ1atXLb4fJSlZPkXGHpFXMoHDdF4t8+Tm5iqvqVxnSnHXasnUBU4XX5BbtWqFj4+PIvIOHjxYLerjlcW0adPo0qULXbp04YsvvuCxxx5DkiS++OILunbtWtnLEwiqNocOwcSJ8NdfABS2a8ckYPuNG2Y17kyTMW73jFktaBZ5pu4IgXUc5a61RyyWJfLUCCpZ5FnL9pWPpSZhwlGWPHmMt7e3WSkW0G7Jc5S7Vo65c3Z2VoQm3CzrcvHiRVJTU5Vi3WUhC0tTsQg3xZmWTF25C4dp+z5Z8GkRefIxPTw8lPfKXkueLApbtWoFQPv27ZXthYWFpd7T6kRoaCjHjh3jl19+4cyZM1y8eJG77rqLbdu2cfHiRe65557KXqJAUPW4dg1efRVWrjSWRPHxgXnzcH7hBRZlZ/OqhY4XImNWO5pFnsguU4cWcXYrRZ4aS54cj2dJ5Jla0bKysixa6ExxlMiTBVzJzFq4aclzlLs2PT2d/Pz8UlbMkpgWZy4pdmWRp1YwWurmATfbrtkjzkxFniwWtRRWNp1HttrLlrykpCRyc3NLtc+zhiwKZZHYuHFj3NzcMBgMJCYmqhLCVYnCwkJ+/PFHwsPDGTVqlFn/7NzcXE6cOMGxY8f43//+J0SeQIBJq7KgIPj6a5gxw9juEMgZNYqCt9/GtzgsRGTMOg7NIg+MP6aff/45p0+fRqfT0a5dO8aOHSuUtQlqY/LklmVgWZxpie1zlMiTY98siTx3d3dcXFwoKCggIyPDpsizVorFdJsWS56leRyVeFGnTh10Oh2SJJGWlmZWFsUSslgsOY/ptvKKPHkNajN1c3JylNfctHi2Pe7akiVdwHhe3t7eZGVlodfrad26taq55Ng+2ZLn7OxMSEgIZ86c4fz589VO5Dk7O/PEE09w8uTJUt8TT09PevbsSc+ePStpdQJB1UJuVVZXr2djYCDuBw8an2jblpQ5c+g9axb+Tz/Nli1bhI5wMJoTLw4ePEiLFi1YtmwZaWlppKamsnTpUlq0aMHhw4crYo3VErXuWtMkB0fF5JXlZi2vJU+n02lKvrDWOQMcJ/IcZclzdnZW5lcjGK3NA9pdv9ZEnvxYbQkV2VXr6elp9prL7tpr164p768tZEFoahHU6XR2CUbZXStb8kz/rzW+r6rQq1cvJZNZIBBYJyspiWdPneKnpCTcDx6kyMsLFi1C/8sv9J41i9jYWFJSUlQn9AnUo1nkTZ06lXvvvZf4+Hg2btzIpk2biIuLY8SIEUyZMqUCllg9UetmNRVvllxfVc1dC9qSL8oSZ/I8t9qSJ4+zJM60JHGUJfIcZcmTY/S0iryAgACzxCg/Pz/l86VWnFly+4J2q2BhYaFSdkm25EH1F3mTJ09m1qxZopyDQGANSYJ162g0aBBPZ2TgAvwXGFC/Pvv69SMsPJzY2FhCQkKIiooSrtgKwC5L3ssvv2xWfd/FxYUZM2YYM+UEgHo3qyzyvLy8LCYxVEWRp2UuNTF55RWLpokXturSFRYWKscrK76vqoi8Bg0aAOrdtdaEmT0WOEvuWtPHaudJS0vDYDDg6upKkyZNlO3VXeQ9/PDDHDhwgPbt2/PEE0/w2WefcejQIQwGQ2UvTSCofE6ehIED4Ykn4NIlaNWKlLVreSUkhL0JCfTt29dM4AVXg4431RHNIs/X15eEhIRS2/V6vUhpNkGtm7WsGnnguJg82WqWm5tLQUFBmfPIIs/amrRY8soqoeJod63BYLDpijRdc1lzyQKuLNSIPLXlWGxZ8jIyMpRYybKQhZlpPJ6MVnFmyV1rzzyyQA0ODjbLorWrC0cVIi4ujk2bNjF9+nRycnJYuHAhvXr1wtvbm06dOlX28gSCyiEzE156Cbp0MdbA9PSEt96C48fxf/xx1qxZYzZ8zZo1QuBVIJoTL0aPHs24ceNYsmQJffr0QafTsWfPHl566SX+/e9/V8QaqyVqLXBl1cgzncdRdfLkcZasWDJlJV6Ybi+vBc5RIk8uq1JYWMj169cV65clZAudl5eXxZ7ClWHJy8vLU967kiLPz88PV1dX8vPzuXLlis2LoaXyKTKy8JO7dNjCmlVQazkW+XUq6YqRu3BcuHBBqbNZnWjatClNmzY1y6zNzMwkJiaGY8eOVeLKBIJKQJLgv/+FadNAzuK/7z5YtgxMOu5ERESY7RYRESEseRWIZkvekiVLeOCBB3jyySdp1qwZTZs25amnnuKhhx5i0aJFFbHGaolWd60tkVdeS56bm5siamy5WdXG5Nmap7CwUFlTRZZQ0el0qmvllTUP3BRst1LkyWNMEz9kdDqdIlrVxOVZE2ZwM1NXq8grr7tWtlKW7OYhX9SzsrJqTD9sHx8f+vfvz6RJkyp7KQLBrePsWQgPh9GjjQKvRQv47TfYtMlM4IWFhSku2r1795p1sBCxrRWDZpHn5ubGe++9x7Vr14iJieHIkSOkpaWxbNky3N3dK2KN1RKt7tryijxJksoUeaA+ls5RiRemx7HW8QLKb8kD9ckXtkReZVjyTF21lqxZsstWTVyepTZrMlpEntytA8rvrpVfp5Iiz8vLS7FcXrhwQdVcAoGg6pB+8SIZzz8PHTvC//4H7u4wdy6cOEFip07KdTsxMdFM4EVFRdGnTx/RquwWoNldm56eTmFhIXXr1qVjx47K9rS0NFxcXGzWTbtd0JpdW16Rd+PGDYqKisz2KYmPjw9Xr14tt8hT666Vv+Du7u4WbwAclXgB6rteOFLklZWlq6WEimlRZUtoybBVI/Jkl25ZyGPc3NxKnZ+pyFPjZpVfA0uZc02bNiU1NZWEhAQ6d+5sc12VTfPmze1yK0+ZMoXJkydXwIoEgkpAkshet46cceMIlBON7rkH3nsPWrRQrHb+/v5s2bIFHx8f5ZokWpXdWjSLvEcffZSRI0cyceJEs+3fffcdP//8M5GRkQ5bXHVGa0yemsSLsn5QTY/j5eVlcYxWS56txAtb89gSZo6KyQP14kytyHNU4kVmZiYGg8Fi/J+MtaQLGS3uWtnaZykuUYslz1K3CxnZspebm0t6enqZ8Z1wU+SVtOQBNGnShEOHDllM5qqKrF692q795PhDgaDac/48TJ5Mrc2bqQXEAwsaNuS1FSsIbtLEzC0Lxmtg48aN2bJli/J/U0SrsopFs8jbv38/S5cuLbU9LCyM2bNnO2RRNQFHx+QVFRWRl5eHh4eHxXGy4PLy8rLaB1StBc5RiRdaRJ4ti1BVtOSVJfJq166Nk5MTRUVFXL161WKMnIwtkedoS54akWctsxaM9Rzr1KnDtWvXuHjxYrlFHlBtRF5oaCizZs3ivvvuo1evXpW9HIHg1pGbC2+/DYsWQV4euLmRPmEC9/z8M6fi49kxcCBr1qwhIiLCYu070aqsctAck5eXl2exBEd+fr7qSvq3A46KyTPdXpZgtGURBMfH5Nmap6zyKXBTsBUWFpp1/rCEWkueWpEnjy+J2sSLvLw85b2zNJeTk5Oy3ZbLVq3IsxWTl5OTo6zJliXPVj1Ba0kXMrJgs9ULt6ioyGp2LdwUedUpJi85OZkRI0YQGBjIs88+y2+//UZeXl5lL0sgqDh+/RXat4f5840CLzwcjh/H77332LJrlxJXJ2rfVT00i7yePXuyatWqUts//vhjunfv7pBF1QQcFZPn7OysdCqoaiKvvJa8WrVqKQWgbbls5eetWY3UJl7Iz5fXkic/r9PprJ6f2uQLR1nyZBHo5uZmUVjLIs9gMNh8vcvK0gX1yRdXrlyhsLAQnU5nsXaf3LO2uljyAL788ksuX77Md999R+3atfnPf/5D/fr1eeCBB1i9erXq2ogCQZUnLg7uvRdGjjT+v3Fj+P572LIFivtWBwcHi9p3VRjNIu+tt97is88+Y8CAAcybN4958+YxYMAAvvjiCxYsWFARa6yWaHXXliXO1Mx1K0Weo9y1pn1wyxIdN27cUCwljrLklVfkydapOnXqWOxUAo4TeWpj8kzj8Sy5vj09PZX3zpbLtix3LagXefLzDRs2xNXVtdTz1c1dK6PT6ejfvz+LFy/mzJkz/PXXX9x11118+umnNGrUiAEDBrBkyRKbls6yWLFiBc2bN8fDw4Pu3buze/duVfvt3bsXFxcXunTpYvexBbc5N27AG29Au3bwyy/g4gIvvwynT8ODD4LJ9cVa7TtREqVqoFnk9e3blz/++IPg4GC+++47fvnlF1q2bMmxY8fo379/RayxWiKLrYKCgjLbHNkqhmw6V1muX0eJPEmSlJi88iZe2HLXgroMW1kA6nQ6q8LT0SVUcnNzy+wwUVY8nsyttuSVFY8nozYuz5a7Vq3Ik0siWIrHg5si7+LFi9W6HVjbtm2ZMWMGe/fuRa/XM2bMGHbv3s369evtmm/Dhg1MmTKF2bNnc+TIEfr378+wYcNsiuH09HSefPJJBg0aZNdxBYLsjRvJb9sWXn/dKPYGDoRjx+Dtt0m8ft3shlzUvqv6aBZ5AF26dGHdunWcPHmSgwcP8sUXX5g1Hq9ItN7dRkdH0717dzw8PAgJCeHjjz++JetUG0tny10L6ly/jhJ5pqVYKtpda/pcWZY8+TkfHx+rVjNHJV74+voqVrCyBKMakae2jIqWmLyyYunKyqyV0SryHGXJsyYW/f39cXd3R5Kkclm9qhL+/v6MGzeOn376ienTp9s1x9KlSxk3bhzjx4+nbdu2LF++nODgYFauXFnmfv/3f//HY489Ru/eve06ruA2JiGB/HvvpdaDD+IaH0+hvz+sXw87dkDbtuj1ekJDQxk6dCjp6emi9l01wS6RV1lovbuNi4tj+PDh9O/fnyNHjjBr1iwmT57MDz/8UOFrdXV1VcpmqBF5ZYkzR4k8NRY40+dsFVW+1SKvrHkc5a41TZgor8hTa8mTn7cl8nJzc8u05sqWPEeIPEe5a2XhZs2Sp9Ppqq3L1pTr16+zYcMGli5dyrJly/j2229VZWhbwmAwcOjQIcLDw822h4eHs2/fPqv7ffnll/zzzz/MmTPHruMKblMMBmPWbNu2uP7yCwXAUqCblxf6vn1BpzOz2KWkpJCZmanUviuZZCHXvgsJCRG176oAmkuoVCamd7cAy5cvZ+vWraxcuZKFCxeWGv/xxx/TpEkTli9fDhhdKgcPHmTJkiU8+OCDFb5eb29v0tLSVLlZHWXJK+sLpcaSJz9nmhRRElks5ubmUlBQgIuL5Y+RGnGmJiZPzTxaEy9sCca0tDSHiTxbgfi2LHm1atXC09OT3NxcUlJSrIpv2ZJXXnet3CcXbGfXllfkgdFle+7cuWor8j7//HMWLVrEPffco5znn3/+yZw5c5gxYwbjxo3TNF9qaiqFhYXKeyXTsGFDq4Wsz507xyuvvMLu3butfh9LkpeXZ5YVLN+05efnk5+fb3U/+bmyxlRnavL5lTw33e+/4zx5Mrq//wagqF8/Ls+ezWfTphEfH8+QIUNYtWoVzz77LMnJybRt25bIyEjls/nrr7+SlZVFQECA2esVEBDA77//jre3N15eXrfstbwd3jutVBuRJ9/dvvLKK2bby7q7/eOPP0rdDQ8ZMoTPP/+c/Px8i4Hg9l745DGm/8oi7/r161b3lcWZh4eH1TFydm1GRobVMbIQKusLpWYeWdh4e3tbHWNaqy8tLc1qORLZalarVi2rc8nCMy0tzeoY2dLl6+trdYwsfExfa0tj5TWVdX6yYLxy5YrVMbIIql27drnmycnJUcrH+Pn5lVq7/K+/vz8XLlzg4sWLVrPWZAFQt25dq8eThWRycrLVMbJ7Re5gY2mcbC1MTk4mLy/P6g2BPFfDhg2tHk8urRIbG6v5QlYVLuaLFy/m8OHDpcT3G2+8Qffu3TWLPJmSyTPWakkWFhby2GOPMW/ePFoXZzyqYeHChcybN6/U9m3btlktqG7K9u3bVR+rOlKTz2/3t9/S/ssvabxnDwA3/Pw4+dRTJIaFQV6emdHk6tWrZo+PHj3K0aNHzeaLiYm5FctWTU1872yVGbNGtRF59tzdXrp0yeL4goICUlNTLbqiynvhg5sfMDl+aseOHVaD5mWLyvHjx63OJwvNAwcOWLWsnDhxQpnPWteRv4vv1vR6vdUxJ0+eBIylW8rqXuLq6kp+fj4///yzVfdgfHw8AP/884/VuWTRdfjwYatj5LhLg8Fgc5709HS2bt2Kk5NTqS96QUGBYlU9ePCg8nqURK4DGRUVZbVAs3yRu3r1qtU1qTl/WSy6uLiwa9euUseTz0F2/W/evNmq+1d+7y5dumTzeMePH7f5OfHz82PLli0WxxQUFKDT6cjPz+fbb7+16v4+d+4cYBSD1o4n31Tt3btXc8ccey98jkSn05GVlVVK5GVlZdnVAq1+/fo4OzuXuq6lpKSUup6B0fp+8OBBjhw5wvPPPw8Y6xNKkoSLiwvbtm3jX//6V6n9Zs6cybRp05THGRkZBAcHEx4eXmayVH5+Ptu3b2fw4MEWb5SrOzX5/PJzcoidMoX233+PLisLycmJogkTcJ47l061a9PJZOz+/fvNjCTbtm3jzjvvvPWL1kBNfu/UtP+0RLUReTJq727LGm9pu4y9Fz4o/QF788030ev1dOjQgeHDh5e5vrvvvttqncHffvuN6OhogoODrc7zyy+/ANCpUyerYzw9PVm4cCHOzs5WxxQWFgJGMWxtDBitVFeuXKF79+506NDB4pjXX38dMHZDKWlRldm7dy9btmzB39/f6vFk0dGyZUurY/Ly8njqqaeQJIk777yTAwcOlPqimxYTfuihh6y6tdauXcvRo0dp0qSJ1eN98803APTq1cvqmFq1arF48WKKioqsjjly5AhgtIzdc889yvaSn6VVq1Zx7tw5mjZtanWu+fPnA8bPkrUxBoNBST6yNkYWuSEhIWV+Bho0aEBKSgrt27e32ndWtjDfe++9tG/f3uKYK1eu8O2336LT6co8niXsvfA5kiVLlhAaGkqHDh0Ud21iYiInT57k3Xff1Tyfm5sb3bt3Z/v27dx///3K9u3btzNq1KhS4319fUvdJK5YsYLff/+d77//nubNm1s8jrWe0q6urqp+INWOq67UuPOLjsZl4kQ6nDplfHzXXehWrMC5a1dK9kiSM8RNGxyMGTOm2hQ4rnHvHdh9PqpE3gMPPKB6wo0bN9q1EFtovbsFY1yApfEuLi5Wm8GX98JnOlZ2Rd64ccPqvrK71s/Pz+oY0xg4a2NMXX7Wxshu1aysLJvz+Pr6lnm+Pj4+XLlypcw1yfF9devWLdea5NeoTp06Vse4uroqcWuyta7ke2Yatyi7ri0huzQzMjKsHk+2HDZo0MDqGPlzee3aNatjZBFUv359i2Pkc5Dj7K5evWp1LtM4OmtjZNdoSkpKueYBY1JGSkoKqampFsdlZmYqn4GmTZtanUsWIQkJCZovZJV1IS8sLOTHH38kPDycESNGMGzYMP766y8uXryIJEk0atSIXr16WW0xaItp06YRERFBjx496N27N6tWrSIhIYEJEyYAxpvRpKQkvv76a5ycnErdaPn7++Ph4WH1BkxwG3HpErz0Eqxdiw7I8/XFeckSXMaNAwthFiXLopi2KgsLC6s2Qk9gRJXIMw1SlySJTZs24efnR48ePQA4dOgQ169f1yQGtaL17hagd+/eioVLZtu2bfTo0eOW/DioSZiojGLIZVk/1MwD6jJ1b2V2LRiti7m5uVYTJmy1NJNxdHZtWlqaVYuzraQLGVutzSRJ0lwnz9qabGXWygQGBnL06FGl3EpJ5KQLLy+vMj9Ppl0vbFnmqwrOzs488cQTnDx5Eh8fH5ydnR1atmT06NFcvXqV+fPnk5ycTIcOHYiMjFReq+Tk5GqbqCK4RRQUwIoV8NprkJEBOh2FzzzDjv79GTx6tEWBZ6ksipwtK28PCwsjOjpa9JutJqgSeV9++aXy/5dffplHHnmEjz/+WLlLLSwsZOLEiTbdmeVFy90twIQJE/jwww+ZNm0azzzzDH/88Qeff/653QVKtWJLnOXn5ysFYG91MWRrP6ayALSV9m5LMEqSpCm7Vk0xZFsir06dOiQnJ1sVjLZampnOYzreEmpEnvxcYWEh6enpFo+rVeRZi+3MyMhQYtvUiLzc3FyysrIsvs+2CiHL2CqjIiddWLOay8g/Fjk5OaSlpdkcX1Xo1asXcXFxhISEVMj8EydOZOLEiRafW716dZn7zp07l7lz5zp+UYLqwb59MHEiFMcOGzp1wu2zzyjq0oV8k7jXxMREfHx8lGurXBYFsFgWJSwsTJRFqWZorpP3xRdfMH36dDM3hLOzM9OmTeOLL75w6OJKMnr0aJYvX878+fPp0qULu3btKvPutnnz5kRGRhIVFUWXLl144403eP/9929J+RSwLc5Mt9+KOnnyF7OwsNBqNwfZMmdLsNsSZ7m5uUp8360SebbKqGi15MlCzhJqRJ6Hh4eSrGNtLkeJPHm7XLLAGrVq1VJuKKyVUbFVCFlGft6WJa+s1wiMr5MsPquTdWry5MnMmjVLVPUXVB1SUmDsWOjbF44epah2bRY3b077zEz0JXpHlyxuDDeTreQYcFOCg4OJjo5my5YtNq/FgqqDZpFXUFDA6dOnS20/ffq00imhIpk4cSLx8fHk5eVx6NAhBgwYoDy3evVqoqKizMaHhoZy+PBh8vLyiIuLU6x+twJb4kze7uLiomRP2jOP6XNqxCJYd7M6yl0rXzScnJzKtFJqcdeqtcBVtCWvsLBQEYy2BIz8vLWMWLUiz1b/WjWuWhlbtfK0uGvBtshTY5mTCyJfuHDB5tiqwsMPP8yBAwdo3749TzzxBJ999hmHDh2q1u3ZBNWUwkJYuRLatAHZ8zZ2LJeiovhEp+N8XBxhYWHKdzIpKalUcWMZPz8/q67Yxo0bC4FXzdAs8p5++mnGjh3LkiVL2LNnD3v27GHJkiWMHz+ep59+uiLWWG2x5a5VE49n+nx5RZ6p4LImzuTt5XXXykLLtE2YJdRY8mRBpdaSZ63rhSzabFnyZGFmyyKoZi7TuDxL2Op2IWMrJs8ekWet9JBad60s8srrrgXzuLzqQlxcHJs2bWL69Onk5OSwcOFCevXqhbe3N506dbI9gUDgCP76C+680+ievX4dunQxums//5ygzp3N2ozJ2evDhw83i7sT8XU1F80lVJYsWUJAQADLli0zc+vMmDGD//znPw5fYHXGlrtWTbcL0+fLismTxZktwejj40N2drZVkSeLLbXuWluWPFvCTH6+Krprrc0jCzYfHx+b3QUcZckzdddaiqeUrXLlteQVFBQogtGWJU8WgY605FUnkde0aVOaNm1qlviVmZlJTEwMx44dq8SVCW4Lrl6FmTPhs89AksDPD958EyZMAJPrkmk8nVy7Mz4+vlQ7MkHNRLMlz8nJiRkzZpCUlMT169e5fv06SUlJzJgxw+5yATUVWxY4WbTZEnm25pEkSbWb1VZrMzXt0UyftybOtIrF7OxspT5bSbQkXpiOL4lWd62cFVsSNfF4MrYseVrdtQUFBRYtlbIws1ZOyJSyRF5KSgpFRUU4OTmV2QMXzN21ll4ntTF5UH1EXk5OjvJDaQkfHx/69+/PpEmTzLbLhaoFgnJTVGQUdm3awKefGgVeRAScPQvPP28m8GSCg4NZs2aN2bY1a9YIgXcboFnkgfGH5n//+x/r169XLAoXL14s0514O6I2Jq+87lqDwaAIpPLG0qm1CNpys6oVZqYi0NKa1GbpguMteQaDwawYqIwWkecoS567u7vyWlmKy3NUTJ5slQsICLB50xZQHMhtMBgsnp/srrV1blB9YvK8vLyIi4tjyZIlnD9/vsyxhYWF/PzzzyxatEi4wwSO4fBh6NMHnnnGaMnr0AGio+Hrr6GMGzy9Xk9ERITZtoiICJE0dBug2V174cIFhg4dSkJCAnl5eQwePBgfHx8WL17MjRs3lGr6AttuVkdZ8ky325rLliVPbUyeo9y1bm5ueHh4cOPGDTIyMkoJsBs3bij9SW+VJU+ue1ZYWMi1a9dKZavaY8mzJIIkSVJEnhqXpr+/PxkZGVy5coU2bdqYPedokWfLVQtG4env709KSgqJiYlmYs5gMChrUvM6VaeYvIEDB9K9e3eWLFlCdHQ0fn5++Pv7K31+09PTuXDhAn5+fkyYMIGXX365spcsqO5cu2asd7dyJRQVIfn4kD51KrVffRVK1HwtWRbFtLhx27ZtAWjWrBmnT58WxY1vAzSLvBdffJEePXpw9OhRsx+m+++/n/Hjxzt0cdUdR1nyZOGWk5OjuNIszePu7m6zyLNakWfLzarWXasmE8vX11cReSWRBZtOp7P5OjnKkqfT6ahTpw6pqalcu3ZNaVUlI89fXndtdna2UttOjbXL39+f8+fPW7TkyYKtvO5atZm1MsHBwaSkpKDX6+nSpYuyXXbhurq6qqqfKVvyLl26RF5ensWuM1UJX19fpY3c+fPniY2N5cqVK0o5mE6dOlV43VDBbYAkGa10L70ExUlXhoce4sHYWE6tXUvU+PFmAk0WdP7+/mzZsoXMzEyz4saRkZEcPXqUyMhIBg0aJIob3wZoFnl79uxh7969pUp+NG3aVInBERhxdEyeJEnk5uaWGq9WLIJ6kecod62aHzpfX19SUlIsWuBMLYIlxW1J1GbX2rLkAWYirySOctfKVjzTenplUVatPEdb8mxl1soEBwdz6NChUm4f2e3apEkTm+8bGMWw3JZOr9fTsmVLVcevCrRs2bJarVdQTTh2DCZNgj17jI/btoWPPiKlVStOhYaWajNmarED47W8ZHHjgIAAjh49SqNGjURx49sEzTF5RUVFSpFbU2QTseAmtty1asWZp6enEvtoSTCqTZYwHWNNnGktoVJed63pGEtrUls+BWy7a9Va8kzHWLLAOcpdaxqPp6aVV1m18irDXQsoVoSyRJ4adDpdtXLZCgQVRkYGTJ0K3boZBV6tWrBoEcTEwMCBNG7c2KwsSlhYGPv27SvVjkyuaSeKG9/eaBZ5gwcPZvny5cpjnU5HVlYWc+bMUWrwCIw4ypJnWt+uLJFXXktefn6+0gmjvB0vtIi8subSMk9Z7lpJkuwSeeW15MluWFnQmaI26ULGWq28/Px8ZU1aRF52dnapGxCt7lrZxVNS5MkZqGpFnunY6iLyDhw4wKBBg+jUqRMPPPAA8+fP5+eff6426xdUMSQJvvnGmDW7fLmxwPFDD8Hp0zBjBph4z+SyKLLQ69u3b6l+szKiuPHtjWaRt2zZMqKjo2nXrh03btzgscceo1mzZiQlJbFo0aKKWGO1xVTkWSoxobYYsukYS1ZBR4k8023lTbxQW0LFdIwtd60tZGGWm5urJGvIZGZmKhZote5aKL/Ik61vlooYa0m6AOvuWnluJycnVXP5+Pjg4eEBlLbm2eOuBeuWPNk6p4bqJvIiIiJwdnZmwoQJhISEEB0dzdNPP02zZs2qTf9dQRXh1CkKBgyAxx+HS5egVSvYuhX++18IDiYxMbHU9VGURRGoQXNMXlBQEDExMaxfv57Dhw9TVFTEuHHjePzxx/H09KyINVZbZOtbYWEhBoOhVDC52mLIpmMq0pInb3N1dVWdwJGXl2cxUN5R7lqtFkGdTockSaXEsGzFc3NzU/U5LavrhRaRJwuzrKwscnNzzY6tpbad6VwlRZ78uEGDBqri33Q6HQ0bNuTChQtcvnyZkJAQ5Tk5rtZRIs8eS15VL6Mio9fr+e2332jRooXZ9gsXLhATE1M5ixJUL7KyYP58pGXLcCkoIFenI++ll6g9fz4UX1NLJlOYZs1aKosismUFpthVJ8/T05OxY8fy4YcfsmLFCsaPHy8EngVMxZslcWaPJe9WiDw176Wppc/SXJXhrnVycjIrrmyKadKFmvg3R1nyfH19FcFc0pqnpUsFWI/J0xKPJyPXuDPtVpGXl6c8VivO5B+TxMREs97V9ljy5LHVReT17t1bqQVoSskuGAJBKSTJaKW74w545x10BQVs8/KirSTR/fvv0Rd/p02TKUx7zJpuDwkJYe/evWYxeqL+nUBGs8hzdnZm4MCBpQLSL1++LDpelMDFxUVxi5UlztRY8qqayHNxcVHGWZpLSwkVeYylrFgtIg9uijNrljw18Xim48qbeKHT6Wxa4LRa8kqKRXtEniXXqGzF8/DwUB0n2KhRI1xcXMjPz1f2LyoqssuSJ2eonj59WvU+lcm0adN44403rHYzEQgscvYsDBkCjzwCSUkQEgK//krbM2dwVpFMkZiYWGp7nz59SiVjWLoBEdx+aBZ5kiSRl5dHjx49OHHiRKnnBOaUJc6qmiVPFmZqrbJqLHBqYvLKKn0iz6Mmjs50XMnXSUv5FLBuyZMkSZPIA+txeVotefK41NRUswx3LTXyZCy5Rk2FmRprJxjFvuzu/fvvvwFjrTuDwYCTk5Om2ludO3dGp9Nx8eJFLl26pHq/ymLEiBHs3LmTVq1a8dRTT/HJJ5/w119/KbUPBQIzsrNh1izo2BG2bze6Y+fOhRMn4J57VCdTyGVRSm433V+URRHIaBZ5Op2OH374gZEjR9KnTx9++ukns+cE5pRVRsWemLxbkXihVeSV110rCypLIk9LCRXTuRxlySsp8kwTONTOZU3kabXk1atXT4k5NC3JYo8lz5JrVLbqaXGxAkr3jbNnzwJw6tQpAFq0aGEzttOUWgUF3FFszTt8+LD5k4mJYKU0TmVx7tw5/vvf//L8889z/fp13n77be666y58fHzo1KlTZS9PUFWQJPjxR2jXDhYuhPx8GD4cTp6EOXPA5HqrJplClEURaEFz4oUkSTg7O/Pee+/Rvn17Ro8ezauvviq6XVihqlnyyhJmWkWetZp7+fn5Ss/X8pY+kbepFVS2LHlq57GWeCGLK09PT9WvkzV3rVZLnouLC3Xr1uXq1aukpKQo+8lWL3tEnqm7Vv6/FhcrQOvWrYGbIu/kyZMAtG/fXv0k6ekwdCjdk5M5DRw6dOhmSSa9HsLCwN8ftmyBKvLj1aJFC1q0aMEDDzygbMvIyCAmJoZjx45V4soEVYZ//oEXXoDNm42PmzaF996De+8FC0YRtckUfn5+Vq+tonOFwBS7Ei9knn32WbZs2cLy5ctLfTAFRtSIs6oWk6em+wJYd9eaPlbjMijLkqdVnFmz5DnKXStb47QIKkuWPEmSNFvyTI9rOpccZK1FnJVlydMq8qxZ8jSJvMxMSEmhW/Fn+fDevcbtssCLjYWUFOO4SmTUqFHMmTOHTZs2ERcXV+p5X19fBgwYwPPPP18JqxNUGXJzjVa69u2NAs/NDWbPhlOnYNQoqwJPJFMIHI1mkde0aVOzBIuwsDD+/PNPEeRphbLcrI6y5KltRQY3RVd2drZZNiRoj8mzJhhlV62Xl5cqd11ZMXn2WvIcmXhhGmtqj2vUkiUvPT0dg8HgkLnsEWfy2NTUVOW1Kq/Ik2PyZEteu3bt1E/SuDFERdG9uAjziR07YN++mwIvJASioozjKpFWrVqxd+9enn32WVq0aEHt2rUJDQ3lxRdf5Msvv+TIkSOlajQKbjN+/dUo7ubPh7w8bvTvD8ePw5tvgskNtGntO5FMIagoNLtrLd29tmzZkiNHjlhsk3S742hLnqNi8uT9TBMj7I3JK2nJ05oRq8ZdqzbJwVGJF/LxCgoKyMrKUl43e0SeJUue/F3x9fVVMrC1zCWvo6ioyC5LXu3atfHx8SEzMxO9Xs8dd9xhV5cKgDbFwiw+Pp7MzExzd21xBw1VBAfTMzqamIEDaZeUBH37GrfLAq8K1P5asmSJ8v/ExERiYmKUv99++424uDhcXFy44447OHr0aCWuVHDLiYuDKVPg558BKGrUiFe9vNiQmEiUpyemn96Ste9K9pgtmUwheswK7EWzyLOGh4eH5oDt2wFrIq+wsFCJW1MjzhxVDNnd3R0XFxcKCgrIyMioEJGnpXwK3LSa5eTkYDAYcDNp3yNnspbXXavVkufl5YWXlxc5OTmkpKSUS+RZsr7Z46o1nUsWiZcvX1YyWdUWMIabvWJPnDhBbGwsTZs25fz58wC0bdtW/YLS02n45JO0cHHhn4ICPvvsM65fv46zszNtvLxg2DBjsHlGBqjoAuHZqhWdv/vupsADWLOmSgi8kjRu3JjGjRszYsQIZVtWVhZHjhwRMXm3E3l58M478NZbcOMGuLjAtGkkjx3LhuHDiY2LIywsTBFvpm5ZMF53GzduzJYtW5T/myInU/j4+IhkCoFmVLlr69atq7RgqlOnDnXr1rX6JzDHmrs2Jyen1JiycFRMnk6ns+pmtTfxwpq7Vk35lJLjTF22N27cUHrpltddq9WSJ3eFAPPWX/aIPFl8mbpatCZdyMh3+HIsnexiDQoK0pTJCjdj5o4dO8bp06cpKiqiXr16SqFkVRTH0oUXFADG2nEAA3v3xmPoUCi2DmKlf3Mp9HooGd8bEWHcXoXIzc1lz549SvyhjLe3Nz179hQWl9uFrVuhQwd47TWjwAsLg6NHYdEiGrVpU8rdaq32HYges4KKQZUlb9myZcpFa/ny5RW5nhqHNXEmixCdTqdKVDlK5IFRnF27dq2UOHNUnTyt7lpnZ2f8/PxIT0/n+vXrivCRhZmTk5PqH01HWfLAaGWLi4szq9lmj8iThZlcP87NzU1xsTZq1Ej1PGCMCQNj+Q6wv+wJ6el0DQlhA3DkyBECi12uHTt2RJeUBD4+6rJYi2PphvTsyUoTMfzQmTOQmgqyVVCNldE0ySIkxGjBi4gwPg4LqzIu27///pvw8HASEhLQ6XT079+fb775RhHz6enpPP300zz55JOVvFJBhaHXw9Sp8MMPxseBgfDuu/Doo2ZJFabuVrn2HVCqxp1AUFGosuSNGTNG6U06ZsyYMv8E5lgTZ6bxeGrqC5YVkyeLLLWWs4q25GlNlgDLcXmm1jc1PVlN5yn5OsmlT7RYm2WLVnkteQ0aNMDNzQ1JkrhYHKNmrziTu0LIrlW7kiWKy5V0/fJLwCjyjh8/DkDHZs0gNBSGDlVfly44mIG//45P8efYGbg/NdUo1CIj1c2RmFg6yaJPH+O/ISE3hV4VCDx/+eWX6dixIykpKZw9exZfX1/69etnVo7GEYXhV6xYQfPmzfHw8KB79+7s3r3b6tiNGzcyePBgGjRogK+vL71792br1q3lXoOgBAYDLFpkbEf2ww/g7GwUe2fOwL//bTFrVk3tO4GgolD1y5mRkaH6r6K4du0aERERSn2giIgIi9mYpjz11FPodDqzv7vuuqvC1mgJa+5a+bEaV63puJJiUZIkh4u88pZQsUfkWSqjUh6xaPo6FRUVKUkPWmLgHOWuNe38IFvw7OntCjdF3tWrV7l27Zoyj6YfjGIXa9diC+X58+f5448/AOj46692lSvxbdeOI99+y2LgR8AfjJY4tZZKHx9jHbySSRbBwTeFnr+/cVwls2/fPhYsWED9+vVp2bIlP//8M8OGDaN///5KnFV5C8Nv2LCBKVOmMHv2bI4cOUL//v0ZNmyYmZA0ZdeuXQwePJjIyEgOHTrEwIEDGTlyJEeOHCnXOgQm/P47dO4Mr7wCOTnQrx8cPgxLl0LxtdA0Y1bGWu07URJFcCtQJfJq165NnTp1yvyTx1QUjz32GDExMWzZsoUtW7YQExOjqjbf0KFDSU5OVv4i1VoWHIQtS55aF6u1eXJzc5UODLfakmdN5Glt+wWWy6hozawFc3etbE1JS0tTXiO1PVnBcZY8uCnCSoo8rZmstWrVUlyr586dUwL8NSVLFLtYG4SE0AjjjcK+ffsA6CFb4LSWK9HraTFzJi8BShpCRISxN6ca/PyMhY6jo0u7ZIODjdurSCHk3NxcXFzMI10++ugj7r33XkJDQ5VSMuVh6dKljBs3jvHjx9O2bVuWL19OcHAwK1eutDh++fLlzJgxg549e9KqVSsWLFhAq1at+OWXX8q9ltuepCSjlW7QIDhzhjRXV6Y3aIB+3Tow6Wyi1+sJDQ1l6NChitATte8ElY2qmLydO3dW9DrK5PTp02zZsoU///yTO++8E4BPP/2U3r17c/bsWaVOlyXc3d21BZI7GFsxeWotedbmkQWWTqdTPZc1kac1Jk+OuStpUS2PJc/UXas1sxZuisWioiKysrKoW7euIszq1KljlrlrC9mSJ8fkmVoEHSXyNFny0tMhM5NWrVqRnJzM33//rbT/6t6okfF5tSKo2EL2cIcOLC9+33sBXZo31x77VlYs3fDhxuxaNfj5WV9/Farif8cdd3Dw4MFSwvqDDz5AkiTuvffecs1vMBg4dOgQr7zyitn28PBwRYzboqioiMzMTJEMVx7y8+GDD4xFjbOywMmJrCef5F87d3L0wgU2DRxYZsZsZmZmqSSLkjF6YWFhREdHiy4VggpDlcgLDQ2t6HWUyR9//IGfn58i8ADuuusu/Pz82LdvX5kiLyoqCn9/f6Vo6VtvvaX5B7o8WIuls9eSV3IeWZj5+PiojltzlCVP/gGRxZhMedys5XXXenp64ubmhsFg4Pr162YiT+v7XtJde+3aNQqKs0i1WATBXORlZ2crMYKqRV5xHB0pKbTs2ZNdwC+//EJmZiYe7u60/b//g4YNtVm7goOZ9/33fBcezkVgFqBbu1abwLMUSye7WMPCbmbXXrxobOlUA7j//vtZv369RU/Chx9+SFFRER9//LHd86emplJYWFgqtKBhw4ZmSUBl8e6775Kdnc0jjzxidUxeXh55eXnKY/lakp+fX2ZBZ/m5mlr0OT8/n3onT+I8a5axQwVQdOedFL7/Pu5du/JjUhLDhw8nPj6eIUOGsGrVKp599lmSk5Np27YtkZGRNGzYkIyMDBo3boy7uzuRkZEEBASQn59PQEAAO3bsYPjw4TRo0ABPT89b9lreDu+d6b81CXvPye46eTk5OSQkJChV+2UqojH3pUuXLP5A+/v7l3nRGzZsGA8//DBNmzYlLi6O1157jX/9618cOnRISSQpib0XPnmM6b+AcpzMzEyz7aZdIdS8efI8ubm53LhxQ+k6IgssX19f1R8C2eJ3/fp1ZR/Z8gWovujI7tq0tDQMBoMShyQLGC1rkq2CV65cUfaRy/b4+flp+oD7+flx5coVUlNTCQ4OVpIdGjRooGkeWchdvnyZ/Px85S69QYMG6HQ6TXPJmZcXLlxQkib8/Pysvv+lPkvXrxuFXnIyd+3axRfAd999B0AnnQ7p0iXyPTyM41TGVJKUhOeLL7LD3Z3TksRwZ2fyx483JkuojaXz9DRa2dzdjfsFBBgtIAEBsGMH+fffbzwPDw/jdgdTGRfzmTNnMnPmTKvPr1ixghUrVpT7OCXj+iRJUhXrt379eubOnctPP/1U5o3NwoULmTdvXqnt27ZtUxWXu337dptjqhvu167RfvVq+kVHA5Dn48OpJ58kYdAgSE42/mF87WSuXr1q9vjo0aNKIWy5pJDpNhl5nz179lTcCVmhJr53ptTE8zMtu6YFzSLvypUrPP3002yWGy6XQI59UsPcuXMtXmRMOXDgAGA5kNnWRW/06NHK/zt06ECPHj1o2rQpv/32m1lTcVPKe+ED8w+YXEcrJSXFLB5w//79gNGipyZO0FRMb9q0SVmLHJOl0+lUxxvKlq0TJ04o+8iFmcEo8tR8SeR9DAYDGzduVCyAskvy77//Vr0mWRgePXpU2ScmJkZ5TksspeyS/d///kdycjJRUVGAUchqmSe5+IKelJREZGQkf/75J2C0OmqN7ZRf85iYGH4oLrtQp04dm/OYvQ/FPwoeGRlgUp6jblgYkRMmUHwA459aiud0ApSVHD1q/FNL8Q+Zxf3mzgVge/Fr52jsvfBVZerXr4+zs3OpG9iUlBSbiUMbNmxg3Lhx/Pe//+Xuu+8uc+zMmTMVEQLGG9rg4GDCw8PLjO/Nz89n+/btDB48WHNtxqpKRloauo8/ps7SpegyMpB0OgrGjsXprbeoe+MGTby9S70m+/fvJzw8XHm8bds2M29TVaQmvnem1OTzszexVbPImzJlCteuXePPP/9k4MCBbNq0icuXL/Pmm2/y7rvvaprr+eef59FHHy1zTLNmzTh27JjFlmlXrlzRlC0ZGBhI06ZNlRpjlrD3wgeWP2BBQUHMmjULSZIYPny4MvbMmTOAsV6S6XZrSJKEs7MzhYWF9OnTR7EMyZaMoKAgVfOAUdx9//331KtXT9knqThA3tnZGTc3N1VfEkmScHV1JT8/n549eypJBLJLc+jQoXTu3FnVmlJSUlizZg1ubm7Kmr799lsAevXqpfrcwFg4NCkpiWbNmjF8+HD++usvwGhl1jJPdnY2zz33HHl5efTp00f53HTu3FnTPGRk0P3tt3kD4+ssW4q7devG8M6djXFrDRrAxo1Klp7Vi1VSEgwfzgc6HQeKE0tmnznDnZ07q7e+Xbxo7EQRHw/Nmt203BXPrWzfvFldfbsyqOiLbkVm9FcWbm5udO/ene3bt3N/sSUUjIJ/1KhRVvdbv349Y8eOZf369dxzzz02j+Pu7m7Ro+Hq6qrqvVI7rqqTtW0bV++/n9bFNwxF3buze/Ro+kyZwqVLl/jXv/6ltB+TPQ56vZ4xY8aY3RyPGTOm2tS+qynvnTVq4vnZez6aRd7vv//OTz/9RM+ePXFycqJp06YMHjwYX19fFi5cqOriIlO/fn1VsU29e/cmPT2dv/76i169egHGu6j09HT69Omj+nhXr15Fr9cr2YmWKO+Fr+RY07ptpvvLFwdfX1/V83p7e5Oenk5eXp6yj2zJ8PPzUz2PpTXJsX516tRBp9OpPt969epx6dIlMjMzcXV1RZIkxYXs7++vek3ye3LlyhVlHznJoVGjRpo+4I0bN2b//v1cvnwZV1dXxUoYEBCgaZ7atWsTGBhIcnIy8fHxioWyRYsW2r5wubk0TkmhCZAgSXz4wQcADOjYEddBg4zxbHl5kJtbqvVXqfehWTP47DPe6NuX/wBvAv3WrTNuV39ixri9wEBjxX75R6lZM+PjsDDj87Vrg4MulBV10a1pF3KZadOmERERQY8ePejduzerVq0iISGBCcUW25kzZ5KUlMTXX38NGAXek08+yXvvvcddd92lWAE9PT1FpwRrXLkCL7+M95df0hpIA5bWr8/4DRu4fuIESUlJDBo0yCyZws/Pr1TG7Jo1a4iIiFASKaqL0BPcHqiL1DchOztbifOoW7eu8kPcsWNHJdPP0bRt25ahQ4fyzDPP8Oeff/Lnn3/yzDPPMGLECLOkizvuuINNmzYBRjfo9OnT+eOPP4iPjycqKoqRI0dSv359s7vjisY0K9a0QKrW7FrTuUyTL7TWyIObiRemVhB7MlmhdPJFbm6u4lrWMpel/q7yD5XW/q5ypprcRszeFmIArVu3Boyu57i4OMBoXda4IIiKomfxe51TLPD7fvaZecKCmgy74rZfQ4ATwH2gve1XNSpXcrsyevRoli9fzvz58+nSpQu7du0iMjJSSdRJTk42q5n3ySefUFBQwKRJkwgMDFT+Xnzxxco6hapLYSGsXAmtW0NxQfCs0aMZ0rQpb6WmMnzkSACGDx9eqv1YYmJiqYzZPn36lGpfllgFinYLBGCHyGvTpg1nz54FoEuXLnzyySckJSXx8ccfl2khKy/r1q2jY8eOhIeHEx4eTqdOnUpVET979qyS0ODs7Mzx48cZNWoUrVu3ZsyYMbRu3Zo//vjjlvaVlIVZUVGR0ocVtGfXguWCyOUReabZtfbUtjMdL1vL5HlcXFw0nZupyJPFsCzOtJbAkVuFyRdae7NrwVzkxRdnimoWeQDBwfSaPFl5WAvokpRUuvhvWZQsVbJ3r3k3CK1Cz5qobNxYCLwqwMSJE4mPjycvL49Dhw4xYMAA5bnVq1crsaZgrCIgSVKpv9WrV9/6hVdlDhyAu+6CiRONSUpdusC+fXh/+y0bd+8mJCRE+Z7Hx8eXaj/m4+ODv79/qe1yaZSQkBD8/f1F72JBlcGumDw5IH3OnDkMGTKEdevW4ebmVqEXlLp167J27doyx5hayjw9PatEWx/TZI3s7GwlOcEekSePNRVnssjT4pJxpMirV+xelPc3LXuipeq/LMBu3LhBZmYmnp6eSnatVkueLPLkOEP586p1HtLTaVW8rrNnzyoX/+bNmxtLh6jt71rMsH//m9eWLMGQn8/dFH/51qxRJ/BslSqRhV50dJWqKScQVAmuXoVZs+DTT0GSjLGvb74Jzz0HxYWt5fZjpgkrJduP+fn5sWXLFjIzM0vVtgsODiY6OhofHx/hIhdUGTSLvMcff1z5f9euXYmPj+fMmTM0adJEc+2w2wFnZ2c8PT3Jzc0lKytLeY3kenBaLgaWask52pJXXnetPV0qwCiGvb29ycrKIiUlRRHDzs7OipBUi3xRTkpKwmAwKIWHQ0JC1E9SXJeudbGLdteuXcrr1cTJydjf1d9fk1uzY+3a6IOCiLlwgR7yxogIdZY8ue0XWG77FRZWZdp+CQRVhqIi+OILYyuyYm8DERGweLGxzI8J1tqPlYyxk1trWkIUNRZUNTS7a0vi5eVFt27dhMArA0vdKmS3sizc1GCpv2tlu2tlAVbSXWtPiztTl61pHJ3aIs8yppa8uLg4ioqK8PLy0hZOUNzftXXxOmRrYI9OnfAcOlR7f9diV6v/hQuEh4RQV6urVcTRCQTaOHwY+vSBZ54xCrz27Y3fk6+/tijw5Fg7ORyjWbNmov2YoNqj2ZInSRLff/89O3fuJCUlhaKiIrPnN27c6LDF1RS8vb25cuWKWcKELPLsseSZtv5ytMjTIjqhtCVPdrFqtb6BUdDFxsaSkpKi1LqzpyVdQEAATk5O5OfnK22gWrZsqa1pfHGyRMvQUOrHxZFavHmUXg/XrmlLlnCUq7WatP0SCCqV69fh1VeRVq5EV1QE3t4wbx688IKSLZ6YmKi4VUsmU0RGRir1OuXsWtF+TFBd0WzJe/HFF4mIiCAuLg5vb2/FdF2WCft2x1LChGyNs8eSV16R52tSi01OBilv4oW8v9xdIsiO+mqyJe/y5cuKJc+eODrXK1eU11Xuu9yqVSuj2CoW16oIDsY1OppXTQTrKFOBp7ZMguxqLbmfLPRCQoSrVSAoL5JktNK1aQMffYSuqIhfatUi6fffjQW7iwWeXq8nNDSUoUOHkp6eXiqZQvYENGrUSCRTCKo9mi15a9euZePGjdqKwd7mlOWu1SKMHSXyfHx8cHFxoaCggKtXr9KoUSO73awl3bWOEnly/TNNljy5v2t6OgEBAaSlpSndJVr6+9sVR0dwMM/98AM7wsLwAzqA+mQJGdnVmplZ2uImu1o1JnEIBAITjh83ZswWtwjLb9mSsdnZrE1OJuTRcO7ZtAAAJt5JREFUR5W4OlO3LKAkUJgmU5i2yhPJFILqjmZLnp+fn7YAdkGp+nZFRUV2ZcVaismTxaKWu0wnJycaNGgA3CxTYq8lTxZhsrgrj8iTg5vj4uLsq5FXHEdHfDzt27cHbhaLbvXf/2qPowPQ63EbO5afgTWADrTXpQNRskQgqAgyMmDqVOja1SjwvLzg7bdxPXmSBfv3m9Wu27dvX6kad7L71c/Pz6ortnHjxkLgCaotmkWe3G/WtJ2LoGxKumszMzOVci9a3LWWYvJkcaY1Bq5k8WF7s2JlYZaYmEhRUZH9Ii89nbbFazp9+rRSi1EpV6LGzVocR0ezZnTs2NHsqbapqdri6MCxdekEAoHjkCRYvx7uuAOWLzcWOH7oIThzBl5+GdzczGrXxcbG0rdvXzOBJ7pSCG4HNLtrH374YdavX4+/vz/NmjUr1VaoorpeVGdKumtl65ubmxseHh6q5ynprs3Pz1eselqzm0uKPFN3rex6VUNQUBBOTk4YDAZSUlLsE3nFbta2xcWLT58+rbxmnRo21OZmDQ6GyEjaFPerBWgO3NW8ubY4OlGXTiCompw6Bc8/D8XxtrRqBR98AEOGlBoq177r27evsq1k7TuBoCajWeQ99dRTHDp0iCeeeIKGDRtqy1i8TSkp8uxJuoDSIk8WZjqdTnMsnewGTUlJoaCgQBGeWi15rq6uBAYGkpSURHx8vOL+tadcSavERJwwxhnK7uwOU6dCcRFiMjPVuTUbNcLd3Z3HnZ35tbCQTYDT2rXa4uhEXTqBoGqRlQXz58OyZVBQAJ6eMHs2TJ8OFvqNg/radwJBTUWzyPvtt9/YunUr/fr1q4j11EhKdqqwJ+kCSos82eJWp04dnJ2dNc1laskzdf9qFZ4ATZo0ISkpiYMHD1JUVISTk5O2FmLFblb3sDBCYmM5X7y5uYsLPvHx2t2sxZ0uvnB1RSosxB3UFx2WEckSAkHVQJLg+++NsXfF321GjTK6aU1aDJqWRQHz2nchISGsWbOGiIgIJUZPCD3B7YDmmLzg4GBNmZyC0hmo9nS7gJsCLCMjg8LCQqUmnT2FqE1FnuxibdCgAS4umnW/cqHcv38/YEzG0Co6ZQtZW5M2cB0LCrSXK9HroTjzW9e8Oe6iv6tAUH05e9bohn3kEUhKIsndnXEBAeg/+MBM4JUsi1Ky9l1UVBR9+vQxi9ELCwtT+lsLBDUVzSLv3XffZcaMGUofT4FtSoo8e7pdgHl5k/T09HIXHgajyEtISACMFjnNpKcTXHwef/75J2ASj2dHXbr+Tz2lPOwB2sqVyHF08mczMtJY8V6uRScLPXFhFwiqNjk5Rldsx46wfTu4u5MxdSqDAwP54tIlsy4Upha7lJQUMjMzS9W+k29ETZMxRO07we2AZrPNE088QU5ODi1atMDLy6tU4oUcJya4iWxpk0WZve5aV1dXatWqRXZ2NteuXXOYJU8WeZpdF8UJE03OnQPg/Hmjo7VNmzY3M1O11KXT65m+eTNdgLPAU6DNzSrH0cnxOcVFTUUcnUBQTZAk+OknePFFKL4uMXw4vP8+vi1asHXqVEXQhYWFmblgS5ZFMa19Z4qofSe4ndAs8pYvX14By6jZlBR59iZegNGaJ4s82TJYXkuefEes2ZJXnDDRvEQ2blinTjczUOVxti6mxaJQFxfH4JAQBq9ZYxR4svVNjdCT4+iuX4eYGPPnRBydQFC1+ecfmDzZaIEHaNIE3nvPGH9XnOAnW+JkoSdnzVoqi1JWFybRnkxwu6BJ5OXn5xMVFcVrr70mCiJrwJq71p67yDp16pCYmEhaWprDLHkXLlwA7BB5xQkTgwYMwC0+HkPx5oEffmgUbWoTJhxZrsTPz1gQtaTIk9crEAiqFOmXLqFbvBjfFSsgL8/Yfuyll2DWLBKvXcMnI8PsWinKoggE6tEUk+fq6sqmTZsqai01FlmEpaWlUVhYqGSz2iPy5NIkSUlJ9ou89HQCCgpwdnYmLy+PP/74AygWecVJGKoJDsZr1y7CTRImQkwFnhY3q+jtKhDcVmR/9x2ZzZrhu2yZUeDdfbexRdlbb6FPSzNLppCxVhZFL4qTCwSl0Jx4cf/99/Pjjz9WwFJqLnLtOUmSuH79ulJLTlPLrmJka5ter7fPXVscR+ceHk771q0BFEtesJsbDBtmHFdcp04VwcF8tGYNPYEPKW79pSVhQnazRkeX3kd2s2rpNysQCKo28fFw333UGj2axnl5JALP+/uj//xzaNPGYjIFlC6LsnfvXrNsWSH0BAJzNMfktWzZkjfeeIN9+/bRvXt3pWWXzOTJkx22uJqCq6srfn5+SkasI/q76vV6+yx5cn/X2Fi6eXtzzOSpJpMnw5UrxgdZWaBWPOr1NHnpJf4y3WZPXTprIk64WQWCmkFeHixZAm+9Bbm54OJCxrhxDNu6lRPx8WweONBqMoWlsiglY/TCwsKIjo4WMXcCQTGaRd5nn31G7dq1OXToEIcOHTJ7TqfTCZFnhXr16ikiLzk5GdDYFaIYWeQlJCQo8zRo0ED9BHJ/17AwusXGsrp4s49OR8OEBIratjVuUCtAS/Z3tSdhQiAQ1BjS09MtZrWybRv5EybgGhdnfBwWBh9+iG/79kSaWOisJVPIZVEAi2VRwsLCRFkUgaAEmkVenPwFFWiifv36iutBdteWx5J39uxZpfRJ62K3q4ZJICqK7nfdpcTgTZYknENCKIqMhKNH1c0j+rsKBAIT0tPTGTp0KCkpKTeFmF5v7Fbxww+4AqmurnitWIHXuHFmWbO2kin8/PxEWRSBQCOaY/JMkSQJSZIctZYajRw3d+bMGQoLC9HpdNpafxUjX/TkOLp69epps+TdnIgua9bQEAgCpoPRCifXllODSJgQCAQmZGZmkpKSQmxsLINDQ7k+cybccQf88AMFwDJgUKNGpA0dqgg8UJ9M4efnZ9UV27hxYyHwBIIS2CXyvv76azp27Iinpyeenp506tSJNWvWOHptNQo5bu748eOAsYRJeVqIybSV3ata0evxeuYZTgLHgdpgdLPKvSHVIBImBAKBCY0bNyYqKorHAwPZGBdH7bffhpwcDnh40A34MCSEX3ftMhNqIplCIKg4NIu8pUuX8txzzzF8+HC+++47NmzYwNChQ5kwYQLLli2riDXWCAICAgD46y9jeoI9rloALy8vs2xau0SeSRxdvZAQ6pr2dy3u+6oa0d9VIBDIXLxI8IwZrE1Oph2QAowBet24QbaFgsWix6xAULFoFnkffPABK1euZNGiRdx7772MGjWKxYsXs2LFCt5///2KWGONoF27dgD8888/gH1JFzKmwk6zyLMUR2fa31Xu+6q1Xp5AIHAoK1asoHnz5nh4eNC9e3d2795d5vjo6Gi6d++Oh4cHISEhfPzxxw5bS3p6ulWhlZiYSHpqKixdCm3awLffgpMTyQ88QGvg6+JxlgoWix6zAkHFolnkJScn06dPn1Lb+/Tpo2R7VgRvvfUWffr0wcvLS3U7MEmSmDt3LkFBQXh6ehIWFsbJkycrbI1l0bFjR7PH9lrywGhNlenQoYO2nW3F0TVrZnzs7W33+gQCQfnYsGEDU6ZMYfbs2Rw5coT+/fszbNgwJdmqJHFxcQwfPpz+/ftz5MgRZs2axeTJk/nhhx/KvRY5mSI0NLSU61Sv1zO9Vy9SmzSB//zHWHrpzju59Msv9IuJId1krLUYuy1bthAdHV1KAMrJFFu2bBGxdgKBnWgWeS1btuS7774rtX3Dhg20atXKIYuyhMFg4OGHH+a5555Tvc/ixYtZunQpH374IQcOHCAgIIDBgwcrhTVvJe3atcPJ6ebLXR6R17NnT7Zu3crcuXMZNGiQtp1txdFt3mz8v6+v3esTCATlY+nSpYwbN47x48fTtm1bli9fTnBwMCtXrrQ4/uOPP6ZJkyYsX76ctm3bMn78eMaOHcuSJUvKvRbTZIqwsDCSiuN2k2NiONiuHd8mJ9MiN5fCOnXg00/Rb9hA3xdeUB1jJ5IpBIKKQ3Pk/7x58xg9ejS7du2ib9++6HQ69uzZw44dOyyKP0cxb948AFavXq1qvCRJLF++nNmzZ/PAAw8A8NVXX9GwYUO++eYb/u///q+ilmoRT09PfHx8lPY89957b7nmCw8PJzw83L6dyyo8HBRkue+rQCC4JRgMBg4dOsQrr7xitj08PJx9+/ZZ3OePP/4odT0YMmQIn3/+Ofn5+bi6utq9HjmZQo6dGzlsGOv69aPOF19wf1ERRUDOY4/h/f77JObmEhYaKgoWCwRVBM0i78EHH2T//v0sW7aMH3/8EUmSaNeuHX/99Rddu3atiDXaRVxcHJcuXTK78Lm7uxMaGsq+fftuucgDlK4XAN27d7/lxxcIBFWf1NRUCgsLS7U9bNiwIZcuXbK4z6VLlyyOLygoIDU11WIMcF5eHnl5ecrjjOJWhvn5+eTn55uNDQgIYMeOHdw7bBhfnTtHpzNnADjh4UHd9etpcM895AOeGEWhu7s7kZGRBAQEkJ+fr+w/fPhwGjRogKenZ6ljVBXkdVXV9ZWHmnxuULPPz95z0l7DA6NAWbt2rV0HvFXIF0NLFz65xpwltFz4SmLrA/bhhx8ybdo0Pvnkkyr7IawJXxJxDlWHij6P6v76lIXOpI4cGL0TJbfZGm9pu8zChQsVD4kp27Ztw8vLy+I+b7z9Nr6ffYZh505OP/EE8eHh/KPTQWSkMmbatGkAHD16lKMlCqsvXLgQgD179lg9j6rC9u3bK3sJFUZNPjeomeeXk5Nj1352iTxHMXfuXIsXGVMOHDhAjx497D6G1gulPRe+kpT1AVuyZAmZmZlEmlwUqyI14UsizqHqUFHnYe+FrypTv359nJ2dS1ntUlJSSt20ygQEBFgc7+LiYlZyyZSZM2cqggyMN7TBwcGEh4fjayEmNykpieHDh5Nz6RIrP/qIJ6ZNo+GuXURGRtJISxH1Kk5+fj7bt29n8ODB5XJzV0Vq8rlBzT4/2eCkFdUiz8nJqUxxBEZBVVBQoPrgzz//PI8++miZY5rJ2Z4akevSXbp0ycxVUdaFErRf+EypCR8wcQ5Vg5pwDlDx52Hvha8q4+bmRvfu3dm+fTv333+/sn379u2MGjXK4j69e/fml19+Mdu2bds2evToYfV1d3d3x93dvdR2V1fXUvvo9XoGDRpEbGwsbdu2xVC7Ng0bNuT06dMMGjSoVP27moCl16GmUJPPDWrm+dl7PqpF3qZNm6w+t2/fPj744APNLc7q16+vdIJwNM2bNycgIIDt27crsYIGg4Ho6GgWLVpkdT8tFz5r1IQPmDiHqkFNOAeouPOoCa+NJaZNm0ZERAQ9evSgd+/erFq1ioSEBCZMmAAYb0aTkpL4+mtjFboJEyYo4SDPPPMMf/zxB59//jnr168v91pKFiyOjIzk6NGjREZGKsJPJFMIBFUT1SLP0h3kmTNnmDlzJr/88guPP/44b7zxhkMXZ0pCQgJpaWkkJCRQWFhITHEGaMuWLfEurul2xx13sHDhQu6//350Oh1TpkxhwYIFtGrVilatWrFgwQK8vLx47LHHKmydAoFAUF5Gjx7N1atXmT9/PsnJyXTo0IHIyEiaNm0KGOuVmtbMa968OZGRkUydOpWPPvqIoKAg3n//fR588MFyr0UuWAwQFRVFQEAAR48epVGjRkrWrChYLBBUTeyKybt48SJz5szhq6++YsiQIcTExGgvyquR119/na+++kp5LFvndu7cSVhYGABnz55VslcBZsyYQW5uLhMnTuTatWvceeedbNu2TVyMBAJBlWfixIlMnDjR4nOWSkmFhoZy+PBhh69DLlicmZlJ48aNzZJd5ILFPj4+op6dQFAF0STy0tPTWbBgAR988AFdunRhx44d9O/fv6LWZsbq1att1sgr6S7W6XTMnTuXuXPn2n1ceU41sT/5+fnk5OSQkZFRbd1I4hyqBjXhHKDiz0P+XmoNFRGUpqxrnU6nw9fXl4yMjFLvqRyrXFPiI2vKd88SNfncoGafn73XOtUib/HixSxatIiAgADWr19vNQC4piF3x6hpQcUCQU0iMzNTWJLKibjWCQRVH63XOp2kUhY6OTnh6enJ3XffjbOzs9VxGzduVH3w6kBRUREXL17Ex8fHZnaxnImr1+ttZuJWVcQ5VA1qwjlAxZ+HJElkZmYSFBRk1jZQoB2117qa8tm0Rk0+v5p8blCzz8/ea51qS96TTz5pU+TURJycnDRnjPn6+lb7D5g4h6pBTTgHqNjzEBY8x6D1WldTPpvWqMnnV5PPDWru+dlzrVMt8tT2jBUIBAKBQCAQVD7CvyEQCAQCgUBQAxEiz4G4u7szZ84ci8WUqwviHKoGNeEcoOach+AmNf09rcnnV5PPDWr++dmD6sQLgUAgEAgEAkH1QVjyBAKBQCAQCGogQuQJBAKBQCAQ1ECEyBMIBAKBQCCogQiRJxAIBAKBQFADESLPQaxYsYLmzZvj4eFB9+7d2b17d2UvSRO7du1i5MiRBAUFodPp+PHHHyt7SZpZuHAhPXv2xMfHB39/f+677z7Onj1b2cvSxMqVK+nUqZNSzLN3795s3ry5spdVLhYuXIhOp2PKlCmVvRSBA6ju1zpLzJ07F51OZ/YXEBBQ2cuyG1vXc0mSmDt3LkFBQXh6ehIWFsbJkycrZ7F2YOv8nnrqqVLv51133VU5i61khMhzABs2bGDKlCnMnj2bI0eO0L9/f4YNG0ZCQkJlL0012dnZdO7cmQ8//LCyl2I30dHRTJo0iT///JPt27dTUFBAeHg42dnZlb001TRu3Ji3336bgwcPcvDgQf71r38xatSoanUBNuXAgQOsWrWKTp06VfZSBA6gJlzrrNG+fXuSk5OVv+PHj1f2kuzG1vV88eLFLF26lA8//JADBw4QEBDA4MGDlf7FVR01v1dDhw41ez8jIyNv4QqrEJKg3PTq1UuaMGGC2bY77rhDeuWVVyppReUDkDZt2lTZyyg3KSkpEiBFR0dX9lLKRZ06daTPPvusspehmczMTKlVq1bS9u3bpdDQUOnFF1+s7CUJyklNu9bJzJkzR+rcuXNlL6NCKHk9LyoqkgICAqS3335b2Xbjxg3Jz89P+vjjjythheXD0u/VmDFjpFGjRlXKeqoawpJXTgwGA4cOHSI8PNxse3h4OPv27aukVQkA0tPTAahbt24lr8Q+CgsL+fbbb8nOzqZ3796VvRzNTJo0iXvuuYe77767spcicAA1/Vp37tw5goKCaN68OY8++iixsbGVvaQKIS4ujkuXLpm9j+7u7oSGhtaI91EmKioKf39/WrduzTPPPENKSkplL6lSUN27VmCZ1NRUCgsLadiwodn2hg0bcunSpUpalUCSJKZNm0a/fv3o0KFDZS9HE8ePH6d3797cuHEDb29vNm3aRLt27Sp7WZr49ttvOXz4MAcOHKjspQgcRE2+1t155518/fXXtG7dmsuXL/Pmm2/Sp08fTp48Sb169Sp7eQ5Ffq8svY8XLlyojCU5nGHDhvHwww/TtGlT4uLieO211/jXv/7FoUOHbrtuGELkOQidTmf2WJKkUtsEt47nn3+eY8eOsWfPnspeimbatGlDTEwM169f54cffmDMmDFER0dXG6Gn1+t58cUX2bZtGx4eHpW9HIGDqYnXumHDhin/79ixI71796ZFixZ89dVXTJs2rRJXVnHUxPdRZvTo0cr/O3ToQI8ePWjatCm//fYbDzzwQCWu7NYj3LXlpH79+jg7O5e6k01JSSl1pyS4Nbzwwgv8/PPP7Ny5k8aNG1f2cjTj5uZGy5Yt6dGjBwsXLqRz58689957lb0s1Rw6dIiUlBS6d++Oi4sLLi4uREdH8/777+Pi4kJhYWFlL1FgB7fTta5WrVp07NiRc+fOVfZSHI6cNXw7vI8ygYGBNG3atEa+n7YQIq+cuLm50b17d7Zv3262ffv27fTp06eSVnV7IkkSzz//PBs3buT333+nefPmlb0khyBJEnl5eZW9DNUMGjSI48ePExMTo/z16NGDxx9/nJiYGJydnSt7iQI7uJ2udXl5eZw+fZrAwMDKXorDad68OQEBAWbvo8FgIDo6usa9jzJXr15Fr9fXyPfTFsJd6wCmTZtGREQEPXr0oHfv3qxatYqEhAQmTJhQ2UtTTVZWFufPn1cex8XFERMTQ926dWnSpEklrkw9kyZN4ptvvuGnn37Cx8dHuVP18/PD09OzklenjlmzZjFs2DCCg4PJzMzk22+/JSoqii1btlT20lTj4+NTKg6yVq1a1KtXr9rFRwrMqQnXOktMnz6dkSNH0qRJE1JSUnjzzTfJyMhgzJgxlb00u7B1PZ8yZQoLFiygVatWtGrVigULFuDl5cVjjz1WiatWT1nnV7duXebOncuDDz5IYGAg8fHxzJo1i/r163P//fdX4qoricpM7a1JfPTRR1LTpk0lNzc3qVu3btWubMfOnTsloNTfmDFjKntpqrG0fkD68ssvK3tpqhk7dqzyOWrQoIE0aNAgadu2bZW9rHIjSqjUHKr7tc4So0ePlgIDAyVXV1cpKChIeuCBB6STJ09W9rLsxtb1vKioSJozZ44UEBAgubu7SwMGDJCOHz9euYvWQFnnl5OTI4WHh0sNGjSQXF1dpSZNmkhjxoyREhISKnvZlYJOkiTplqpKgUAgEAgEAkGFI2LyBAKBQCAQCGogQuQJBAKBQCAQ1ECEyBMIBAKBQCCogQiRJxAIBAKBQFADESJPIBAIBAKBoAYiRJ5AIBAIBAJBDUSIPIFAIBAIBIIaiBB5gkpj7ty5dOnS5ZYfNyoqCp1Ox/Xr1x06b7NmzdDpdKrnjo+PV8ZXxusgEAgEgpqNEHmCCkEWL9b+nnrqKaZPn86OHTsqe6kOZf78+SQnJ+Pn52dzbHBwMMnJyfznP/+5BSsTCAS3A7Gxsfzyyy/K4x9//JGpU6dW4ooElYnoXSuoEJKTk5X/b9iwgddff52zZ88q2zw9PfH29sbb27sylldh+Pj4EBAQoGqss7MzAQEBNe41EAgElcfmzZvJyclh5MiRABw7dozOnTtX8qoElYWw5AkqhICAAOXPz88PnU5XaltJd+1TTz3Ffffdx4IFC2jYsCG1a9dm3rx5FBQU8NJLL1G3bl0aN27MF198YXaspKQkRo8eTZ06dahXrx6jRo0iPj5e9VqvXr3Kv//9bxo3boyXlxcdO3Zk/fr1ZmMyMzN5/PHHqVWrFoGBgSxbtoywsDCmTJlS5twXLlxg5MiR1KlTh1q1atG+fXsiIyNVr00gEAhM+c9//qMIuJJER0fz6quv8umnn9K1a1dyc3M5duwYf//9N71796Zp06acOnXqFq9YUJkIkSeoUvz+++9cvHiRXbt2sXTpUubOncuIESOoU6cO+/fvZ8KECUyYMAG9Xg9ATk4OAwcOxNvbm127drFnzx68vb0ZOnQoBoNB1TFv3LhB9+7d+fXXXzlx4gTPPvssERER7N+/Xxkzbdo09u7dy88//8z27dvZvXs3hw8ftjn3pEmTyMvLY9euXRw/fpxFixYJy51AUENRc+NXXmJiYqzG8IaGhtKhQwd27NjBkSNH8PT05NixY7Rs2ZI//viDZ555xsyVWxHcitdAoB4h8gRVirp16/L+++/Tpk0bxo4dS5s2bcjJyWHWrFm0atWKmTNn4ubmxt69ewH49ttvcXJy4rPPPqNjx460bduWL7/8koSEBKKiolQds1GjRkyfPp0uXboQEhLCCy+8wJAhQ/jvf/8LGK14X331FUuWLGHQoEF06NCBL7/8ksLCQptzJyQk0LdvXzp27EhISAgjRoxgwIABdr8+AoGg5lPWDerRo0fp2rWr1ecTExMJDg4GjDfBRUVFjB07FgA3Nzdq167t0LXag9obcEH5ESJPUKVo3749Tk43P5YNGzakY8eOymNnZ2fq1atHSkoKAIcOHeL8+fP4+PgoMX5169blxo0b/PPPP6qOWVhYyFtvvUWnTp2oV68e3t7ebNu2jYSEBMAYyJyfn0+vXr2Uffz8/GjTpo3NuSdPnsybb75J3759mTNnDseOHVO1JoFAoI2ioiIWLVpEy5YtcXd3p0mTJrz11lsA5OXlMXnyZPz9/fHw8KBfv34cOHDAbP9mzZqxfPlys21dunRh7ty5gNFCNXnyZGbMmEHdunUJCAhQngNjuEl0dDTvvfeekmAmh41IksTixYsJCQnB09OTzp078/333yv7hoWF8fzzzzNt2jTq16/P4MGDLZ6jXq/n6tWriiXv+vXrjBw5kj59+pCcnExiYiKNGjVSxp84cYIePXqYPW7fvr3V19DWOq9cuUJAQAALFixQtu3fvx83Nze2bdtm9TWwdn62jie/Ni+88AJTpkyhTp06NGzYkFWrVpGdnc3TTz+Nj48PLVq0YPPmzarP43ZCiDxBlcLV1dXssU6ns7itqKgIMF7Yu3fvTkxMjNnf33//zWOPPabqmO+++y7Lli1jxowZ/P7778TExDBkyBDlblOSJOW4psjby2L8+PHExsYSERHB8ePH6dGjBx988IGqdQkEAvXMnDmTRYsW8dprr3Hq1Cm++eYbGjZsCMCMGTP44Ycf+Oqrrzh8+DAtW7ZkyJAhpKWlaTrGV199Ra1atdi/fz+LFy9m/vz5bN++HYD33nuP3r1788wzz5CcnExycrJiUXv11Vf58ssvWblyJSdPnmTq1Kk88cQTREdHm83t4uLC3r17+eSTTywePyYmBj8/P5o3b87x48fp2bMngYGBREVFERgYSFxcHEFBQcr4Y8eOmd0kHz9+nA4dOlg9P1vrbNCgAV988QVz587l4MGDZGVl8cQTTzBx4kTCw8PLfA0snZ+a10Xet379+vz111+88MILPPfcczz88MP06dOHw4cPM2TIECIiIsjJydE0722BJBBUMF9++aXk5+dXavucOXOkzp07K4/HjBkjjRo1ymxMaGio9OKLL5pta9q0qbRs2TJJkiRp1apVUp06daT09HTV69m5c6cESNeuXZMkSZJGjBghjR07Vnm+sLBQat26tbKWjIwMydXVVfr++++VMenp6VKtWrXM1ma6Lmu88sorUseOHc22lXwdBAKBNjIyMiR3d3fp008/LfVcVlaW5OrqKq1bt07ZZjAYpKCgIGnx4sXKNkvf386dO0tz5syRJMl4LerXr5/Z8z179pRefvll5bGl61VWVpbk4eEh7du3z2z7uHHjpH//+9/Kfl26dLF5nvPnz5cGDBggrVu3Tqpdu7b08ccfmz2flpYmdenSRerQoYN0+vRpafLkydJPP/0kSZIk5efnSy1btrQ6t5p1ykycOFFq3bq19Pjjj0sdOnSQcnNzy3wNLJ2f2uOVfN0LCgqkWrVqSREREcq25ORkCZD++OMPTedxOyBKqAiqNY8//jjvvPMOo0aNYv78+TRu3JiEhAQ2btzISy+9ROPGjW3O0bJlS3744Qf27dtHnTp1WLp0KZcuXaJt27aAsSzKmDFjlAxff39/5syZg5OTUynrXkmmTJnCsGHDaN26NdeuXeP3339X5hUIBI7h9OnT5OXlMWjQoFLP/fPPP+Tn59O3b19lm6urK7169eL06dOajtOpUyezx4GBgUroiDVOnTrFjRs3SrlgDQaDWWydqVvVGjExMRw/fpznn3+e3377jT59+pg9X6dOHY4cOaI8fu+995T/u7i4cO7cuXKvE2DJkiV06NCB7777joMHD+Lh4WFz7SXPT8vxTF93OWTH1EIpW2xTUlI0zXs7IESeoFrj5eXFrl27ePnll3nggQfIzMykUaNGDBo0CF9fX1VzvPbaa8TFxTFkyBC8vLx49tlnue+++0hPT1fGLF26lAkTJjBixAh8fX2ZMWMGer3e5sWtsLCQSZMmkZiYiK+vL0OHDmXZsmXlOmeBQGCOp6en1eekMsItTLc5OTmVCsHIz883e1xW6Ig15Od/++03s3g5AHd3d+X/tWrVKnMeMIq8Bx98kHXr1jm8Y4/adYIxTvnixYsUFRVx4cKFUuLXEiXPT8vxbIXxyO9jUVGRpnlvB4TIE1Q4Tz31FE899VSp7XPnzjULXF69enWpMZYyZEvWwAsICOCrr75SvZ6wsDCzi3ndunX58ccfy9zHx8eHdevWKY+zs7OZN28ezz77bJn7ifg7gaDiadWqFZ6enuzYsYPx48ebPdeyZUvc3NzYs2ePEqebn5/PwYMHzUp9NGjQwKyIe0ZGBnFxcZrW4ebmVirrvl27dri7u5OQkEBoaKjGM7tJZmYmcXFxTJw4kb59+/Lvf/+bffv2lZlIoQW16zQYDDz++OOMHj2aO+64g3HjxnH8+HHFmmbpNSjP8SrqPG4XhMgTCFRw5MgRzpw5Q69evUhPT2f+/PkAjBo1ymzcyy+/zKuvvkpSUpLN1mYJCQm0a9cOg8FAu3btKmztAkFNx8PDg5dffpkZM2bg5uZG3759uXLlCidPnmTcuHE899xzSrhFkyZNWLx4MTk5OYwbN06Z41//+herV69Wipe/9tprODs7a1pHs2bN2L9/P/Hx8Uqmv4+PD9OnT2fq1KkUFRXRr18/MjIy2LdvH97e3owZM0bV3DExMTg7O9OuXTu6du3KyZMnGTlyJH/99Rf169fXtE5LqF3n7NmzSU9P5/3338fb25vNmzczbtw4fv31V6uvQXmOV1HncbsgRJ5AoJIlS5Zw9uxZ3Nzc6N69O7t37za7uEZHRyvuHR8fH5vzBQUFERMTA9yebgSBwJG89tpruLi48Prrr3Px4kUCAwOZMGECAG+//TZFRUVERESQmZlJjx492Lp1K3Xq1FH2nzlzJrGxsYwYMQI/Pz/eeOMNzZa86dOnM2bMGNq1a0dubi5xcXE0a9aMN954A39/fxYuXEhsbCy1a9emW7duzJo1S/XcR48e5Y477lCuFYsWLeL06dM88MAD/O9//8PNzU3TWi1ha51RUVEsX76cnTt3KuEwa9asoVOnTqxcuZLnnnvO4mtg7/Eq6jxuJ3RSySAEgUAgEAgEAkG1R9TJEwgEAoFAIKiBCJEnEAgEAoFAUAMRIk8gEAgEAoGgBiJEnkAgEAgEAkENRIg8gUAgEAgEghqIEHkCgUAgEAgENRAh8gQCgUAgEAhqIELkCQQCgUAgENRAhMgTCAQCgUAgqIEIkScQCAQCgUBQAxEiTyAQCAQCgaAGIkSeQCAQCAQCQQ1EiDyBQCAQCASCGsj/A0SN6pkcC6t9AAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# plot additional info (goodness of fit) for EFDD or FSDD\n", + "_, _ = Pali_ss[fsdd.name].plot_EFDDfit(freqlim=(1,4))" + ] + }, + { + "cell_type": "markdown", + "id": "69d4051c-af8d-4e38-bb37-6bb2740ece18", + "metadata": {}, + "source": [ + "And finally we can plot and/or animate the mode shapes extracted from the analysis" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "d8f30664-1821-47b8-93cf-e6c78c2631c9", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAv8AAAMVCAYAAADgU5tyAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAABEGklEQVR4nO3deZhlZX0n8N+tvbr23mmaRRG1WRpEWRURlAkajXlERw1BgcgoLhOTScaJY7SNGpfIjIoxZhENozGLEgckGhNoOpgRA4goqOwN2PRC013VXb1X1Z0/LreWrrrVXdX3nnO73s/nee4jVJ+uOrc9L/193/M97y0Ui8ViAAAAc15D3icAAABkQ/gHAIBECP8AAJAI4R8AABIh/AMAQCKEfwAASITwDwAAiRD+AQAgEcI/AAAkQvgHAIBECP8AAJAI4R/IxVe+8pUoFApRKBTi1ltvnfTrxWIxnvOc50ShUIiXvexlVfu5q1atikKhULXvl7Vbbrklrrjiinj+858fHR0dceSRR8ZrX/vauOuuuw75ew8ODsaVV14ZRx55ZDQ1NcWzn/3sKpzxZNV+D3/1V38VhUIhOjs7Z/2zZnJO5Wv3zjvvnPJ8Xv3qV8exxx47q/cCUGvCP5Crrq6u+NKXvjTp62vWrImHH344urq6cjir+vVnf/ZnsXbt2vjt3/7t+Kd/+qf47Gc/G5s2bYqzzjorbrnllkP63r/7u78b3/zmN+Pqq6+O2267Lb797W9X6awnquZ7WLduXfze7/1eLFu27JB+Vi3/XAHqSaFYLBbzPgkgPV/5ylfi8ssvj7e97W3xta99LTZs2BDd3d2jv37ppZfGww8/HNu2bYuFCxdOeXdgNlatWhUf/vCHo17+07dz586YN2/eQR+/adOmWLx48YSvDQ4OxnOe85w46aST4l//9V9ndR579+6NBQsWxFVXXRWf+tSnZvU9DlY138NrXvOaKBQKMX/+/PjGN74Rg4ODs/pZMzmn8rV7xx13xIte9KJJ5/TqV7867r333li7du1Bvw+ArFj5B3L15je/OSIivv71r49+bWBgIL75zW/GFVdcMeXv+f73vx8vf/nLo6urK+bNmxfnnHNO3HTTTZOOu+mmm+LUU0+N1tbWeNaznhWf/vSnK57Hgw8+GL/xG78RixcvjtbW1lixYkX86Z/+6QHPv1wjuu++++LNb35z9PT0xJIlS+KKK66IgYGBKY/90Y9+FK9//eujr68vjjvuuAP+jPH2D6gREZ2dnXHCCSfEE088MaPvVXb55ZdHa2trDA4Oxp/8yZ9EoVCIs846a1bf62BU6z189atfjTVr1sQXvvCFQ/5ZtfhzLSvX26Z6mSAAWWvK+wSAtHV3d8frX//6uPbaa+Ptb397RJQmAg0NDfHGN74xPvOZz0w4fs2aNXHhhRfGypUr40tf+lK0trbGF77whXjNa14TX//61+ONb3xjRETcfPPN8drXvjbOPvvs+Nu//dsYHh6OT33qU7Fx48ZJ5/Czn/0szjnnnDj66KPj6quvjqVLl8Y///M/x3/9r/81Nm/eHB/60IcO+D4uvvjieOMb3xi/9Vu/FT/96U/jD/7gDyIi4tprr5107Ote97p405veFO94xztix44dM/0jm2RgYCB+9KMfxQUXXDCr3/++970vjjjiiPj4xz8eN9xwQyxatCgWLFhwwN9XLBZjeHj4oH5GU9P0f93M9D1s2rQp3vve98YnPvGJWL58+UH9npn+rAMdNzw8HENDQ5O+vv9dpR/84AcT/n3Xrl1x6aWXxvDwcMyfP39G5w5wyIoAOfjyl79cjIjiHXfcUVy9enUxIor33ntvsVgsFk8//fTiZZddViwWi8UTTzyxeN55543+vrPOOqu4ePHi4vbt20e/NjQ0VDzppJOKy5cvL46MjBSLxWLxzDPPLC5btqy4a9eu0eO2bdtWnD9/fnH///T9yq/8SnH58uXFgYGBCV9/97vfXWxraytu2bKl4vv40Ic+VIyI4qc+9akJX3/nO99ZbGtrGz2f8cd+8IMfPJg/ooN2ySWXFJuamop33nnnrL/He97znmJfX9+Mfk/5/7eDeT366KNVfQ8XX3xx8Zxzzhn9833rW99a7OjoOKjfe7A/q9Jx5Wt3utcxxxwz5fccGhoqvva1ry12dnYW77rrroM6X4BqsvIP5O68886L4447Lq699tq47LLL4o477oirr7560nE7duyIH/7wh3HVVVdN2NmlsbExLr300njf+94X999/fxx11FFxxx13xDvf+c5oa2sbPa6rqyte85rXxF//9V+Pfm337t1x8803x1VXXRXz5s2bsJL7qle9Kj7/+c/H7bffHq985SunfQ+/9mu/NuHfV65cGbt3745NmzbFkiVLJvzaxRdffHB/MAfhD//wD+NrX/taXHPNNfHCF75w1t/nrrvumvHvf+ELXxh33HHHQR1b6YHciJm/h29+85tx4403xt133z3jnZsO9mcdzHHXXXddrFixYtLXf+d3fqdiVejd73533HTTTXHjjTfGaaedNqNzB6gG4R/IXaFQiMsvvzw+97nPxe7du+O5z31unHvuuZOO27p1axSLxTjiiCMm/Vo5XD799NPR2dkZIyMjsXTp0knH7f+1p59+OoaGhuKaa66Ja665Zsrz27x58wHfw/41mdbW1ogoVTz2N9X5z8aHP/zh+OhHPxof+9jH4t3vfvesv8/w8HD8+Mc/jve85z0Tvn711VfHnXfeGe3t7XH99dfHsmXL4oYbbojnPOc5EVHqxJ966qkH9TMq1X5m+h4GBwfjXe96V7znPe+JZcuWRX9/f0SUHliOiOjv74/m5ubo6OiY9c862ONWrFgx5QO/PT09U4b/j370o/HFL34xvvSlL8VFF110oLcKUBMe+AXqwmWXXRabN2+OL37xi3H55ZdPeUxfX180NDTE+vXrJ/3ak08+GRERCxcujL6+vigUCrFhw4ZJx+3/tb6+vmhsbBy94zDV61WvelUV3uGYanzOwIc//OFYtWpVrFq1Kt7//vcf0vf6+c9/Hjt37py0wv3Tn/40brvttrjyyitjy5Ytcdppp8Vf/uVfjv76mjVrorm5+aBeUz3YOpv3sHnz5ti4cWNcffXV0dfXN/r6+te/Hjt27Ii+vr645JJLZv2zqvnnOt5XvvKV+MM//MNYtWpVxQfZAbJg5R+oC0ceeWT8/u//fvziF7+It771rVMe09HREWeeeWZcf/318elPfzra29sjImJkZCS++tWvxvLly+O5z31uFAqFOOOMM+L666+PP/mTPxmt/mzfvj1uvPHGCd9z3rx5cf7558fdd98dK1eujJaWltq+0Sr4yEc+EqtWrYoPfOADB/Uw8oGUP6xqqvC/atWqOPvssyMi4rjjjptwJ+NQaj+zfQ9Lly6N1atXT/r6Jz7xiVizZk185zvfiYULF87qZ1X7z7Xsu9/9blx55ZVxxRVXVPX7AsyG8A/UjU984hMHPObjH/94XHjhhXH++efH7/3e70VLS0t84QtfiHvvvTe+/vWvj66qf+QjH4mLLrooLrzwwvhv/+2/xfDwcHzyk5+Mjo6O2LJly4Tv+dnPfjZe8pKXxLnnnhtXXXVVHHvssbF9+/Z46KGH4sYbb8zkQ57WrFkTL3/5y+ODH/xgfPCDH6x43NVXXx0f/OAH46KLLopf/dVfjdtvv33Cr++/RWehUIjzzjtv2s9JuOuuu6K3t3fCJ/oODw/Hz372swl3Pe67774J/97V1TVl7eVAZvIe9v9zaWtrm/ITn7/yla9EY2PjpF872J810z/Xg/Xoo4/GG97whnj2s58dl19++aTv+4IXvGC0IgaQBeEfOKycd955ccstt8SHPvShuOyyy2JkZCROOeWUuOGGG+LVr3716HEXXnhhfOtb34oPfOAD8cY3vjGWLl0a73znO2PXrl3x4Q9/eML3POGEE+JHP/pRfOQjH4kPfOADsWnTpujt7Y3jjz++6pWfSorPbJs5MjIy7XHlOxff/e5347vf/e6U36es/IFXB3rG4K677pr08OlDDz0UXV1dE1bsf/KTn8T/+B//Y/o3chBm8h4O9s/lUH/WTM5pJh577LEYHByMBx54YMrnWB599NE49thjZ/W9AWbDJ/wCzFH/9E//FK9+9avjnnvuiZNPPnlGv/cb3/hG/MVf/EV873vfi4jSJxH39vbGwMDAaN0KgMOPB34B5qjVq1fHm970phkH/4hS3/+UU04Z/ff77rsvjjvuOMEf4DBn5R8AABJh5R8AABIh/AMAQCKEfwAASITwDwAAiRD+AQAgEcI/AAAkQvgHAIBECP8AAJAI4R8AABIh/AMAQCKEfwAASITwDwAAiRD+AQAgEcI/AAAkQvgHAIBECP8AAJAI4R8AABIh/AMAQCKEfwAASITwDwAAiRD+AQAgEcI/AAAkQvgHAIBECP8AAJAI4R8AABIh/AMAQCKEfwAASITwDwAAiRD+AQAgEcI/AAAkQvgHAIBECP8AAJAI4R8AABIh/AMAQCKEfwAASITwDwAAiRD+AQAgEcI/AAAkQvgHAIBECP8AAJAI4R8AABIh/AMAQCKEfwAASITwDxw+Nm+OeP/7I773vYgdO/I+GwA47BSKxWIx75MAOCj/8A8R//k/l/65qSnijDMizj8/4mUvizjnnIh583I9PQCod8I/cPh417sivvCFqX+tuTnizDNLE4HyZKC9PcuzA4C6J/wDh4+NGyNuvbX0Wr064v77Kx/b0lKaDJTvDJx1lskAAMkT/oHD1/r1Y5OBW2+NeOCByse2tpYmAOU7A2edFdHWlslpAkC9EP6BuWPduog1a0p3BW69NeKhhyof29oacfbZY3cGzjyz9DUAmMOEf2DueuKJ0mSgXBN65JHKx7a1lZ4TKN8ZOOMMkwEA5hzhH0jH449PrAk9+mjlY9vbS5OB8p2B008vPUcAAIcx4R9I19q1YzWh1atLk4NK5s2LePGLSxOB88+PeNGLSjsMAcBhRPgHKFu7dux5gdWrS7WhSjo6SpOB8p2BF77QZACAuif8A0ylWCzVgsoTgdWrSw8UV9LZGfGSl4zdGTjttNIHke1n9+rV8fR110WhoSEWvP3t0XrGGTV7CwCwP+Ef4GAUixEPPzzxcwaefLLy8V1dEeeeO/oAcXHlylj7+tfHz0ZGYkdHRxQionNwME5qaoqjbrghm/cAQPKEf4DZKBZLW4mOrwlt2FDx8KeWLYt/P/30iIjo3rYtolCI/p6eaBoainPPPjv6/uAPMjpxAFIm/ANUQ7FY+pCx8kTg1ltLn0j8jLtPOSUeeN7zYsmmTWO/JSI2LlkSK9eujRNuvz3zUwYgPZMLqQDMXKEQ8bznlV5vf3tpMnD//aMTgd1PPBFNQ0MTf0tENI6MxI5CIR544IHo7e2N3t7eaLGlKAA1IvwD1EKhEPH855deV10VvS97WTzW3BzFQiEKz9xwHSkUYqRQiNbm5njyySfjyWeeIejo6BidCPT29kazXYQAqBK1H4AMDP7N38S/X3dd9Pf0ROfgYEREbO/qigWbN8dJ73hHDJ5ySvT398eOHTsm/V6TAQCqRfgHyMjWT386fvGtb8Xm+fMjisVY/PTTseKtb43ut7999Jh9+/ZFf3//6KvSZKCvry96e3ujp6fHZACAgyb8A2Ro3549cfMnPxm7h4fjjLe/PZYtWzbt8Xv37o2BgYHYunVr9Pf3x86dOycd09nZOXpXwGQAgOno/ANkqKGpKQZPOCEGBwdj7969Bzy+paUlFi1aFIsWLYqI0mRg/J2BnTt3xuDgYAwODsYvf/nLiBibDPT19UVPT080TfFhYwCkyd8IABlraGiIiDio8L+/lpaWWLx4cSxevHj0exxoMtDV1TXhzoDJAEC6/A0AkLHGxsaIKPX7D9X+k4E9e/ZMmAzs2rUrtm/fHtu3b48nnngiIkwGAFLmv/gAGSoUCqPhfzYr/wfS2toaS5YsiSVLlkTEgScDhUIhOjs7JzxAXD4/AOYe4R8gY7UM//vbfzKwe/fuCQ8Q7969e3Qy8Pjjj0ehUJh0Z8BkAGDuEP4BMlbu/Fej9jNTbW1t0dbWNmEyMP7OwO7du2Pbtm2xbdu2SZOBvr6+6O7uNhkAOIwJ/wAZ2r/2UywWo1Ao5HY+bW1tsXTp0li6dGlETJwMbN26Nfbs2TNpMtDd3T16Z8BkAODwIvwDZKwclovFYgwNDdXVvvz7TwZ27do14c7Anj17YmBgIAYGBuKxxx4zGQA4zAj/ABkrFAoTtvusp/C/v/b29mhvb48jjjgiisXipJpQpclA+QHi7u7u0fcKQP6Ef4AMlSs+1dzuMyuFQqHiZKD8AHH5E4kHBgYiovR8w/53BkwGAPIj/APkIMsdf2plqsnA/jWh8R9CFjFxMtDX1xddXV0mAwAZEv4BMlau/RSLxcM6/O+vUCjEvHnzYt68ebFs2bIDTgbWrl0bDQ0N0dPTM3pnwGQAoLaEf4AcHI61n5maajKwc+fOCZOBffv2xdatW2Pr1q0RESYDADUm/APkYC7UfmaqUChER0dHdHR0xJFHHnlQk4HGxsYJk4HOzk6TAYBDIPwDZGz8Xv9zeeX/QKabDGzdujUGBgZi3759sWXLltiyZUtETJ4MdHV15fo5CQCHG+EfIAfjt/qkZKrJwI4dOybcGRgaGqo4Gejr64vOzk6TAYBpCP8AGSuv/M+1B36rrVAoRGdnZ3R2dsby5csPejJQvitQrgmZDACMEf4BcqD2M3NTTQYGBwdHJwIDAwMxNDQUTz/9dDz99NMREdHU1DTpmQGTASBlwj9ADhobG2N4eHj0VZ4McPAKhUJ0dXVFV1dXHHXUUZMmA+U7A/tPBsbfGejo6DAZAJIi/ANkrFAojO71H1Fa/Rf+D910k4HyA8RDQ0OxefPm2Lx5c0SYDADpEf4BclAoFKK5uTlGRkZi79690dbWlvcpzTlTTQa2b98+qSY0fjLQ3Nw84QHiefPmmQwAc4rwD5CT5ubm2LNnj4d+M1IoFKK7uzu6u7vj6KOPjpGRkUnPDOzbt2/SZGD8nQGTAeBwJ/wDZKwcHsvh30O/+WhoaJg0Gdj/zsC+ffviqaeeiqeeeioiTAaAw5/wD5CT5ubmiLDXf71oaGiInp6e6OnpiWOOOeagJgMtLS0TJgPt7e0mA0BdE/4BMlYOh01Npf8EC//1abrJwNatW2Pbtm2xd+/e2LRpU2zatCkiTAaA+if8A+SkvPKv9nN4mGoysG3bttE7AweaDPT19UVbW5vJAJAr4R8gJ2o/h7eGhobRYB8RkyYDAwMDkyYDra2tE+4MmAwAWRP+ATK2f+3Hyv/csP9kYHh4eNKdgT179sTGjRtj48aNEWEyAGRP+AfIiZX/ua2xsTH6+vqir68vIg5+MtDX1zdhMgBQTcI/QE7Gr/wXi0UrvnPcdJOBrVu3xvbt22PPnj2xYcOG2LBhQ0REtLW1TbozAHAohH+AjI3f579s37590dLSktcpkYPxk4FnPetZMTw8HAMDA6N3BrZv3x67d++uOBno6+uL1tbWnN8FcLgR/gFyUigUorm5Ofbt2xd79+4V/hPX2NgY8+fPj/nz50dEHNRkoL29fcKdAZMB4ECEf4CMlVf+i8VitLS0xL59+zz0yyT7TwaGhoYmTQZ27doVu3btivXr10eEyQBwYMI/QI489MvBampqigULFsSCBQsi4uAnA+MfIHZ3CRD+AXJUDmPCPzM13WRg69atMTg4ODoZePLJJyMiYt68eRPuDJgMQHqEf4CM7V/7ibDXP4duqslA+a5Af39/DA4Oxs6dO2Pnzp0mA5Aw4R8gR2o/1EpTU1MsXLgwFi5cGBGlCeb4mtBUk4GOjo4Jk4HxO1IBc4PwD5CT8Sv/wj+11tzcPGkyMP7OwI4dO0Zf69atiwiTAZiLhH+AjI3/MK9ymFL7IWvNzc2xaNGiWLRoUUQc/GSg/ABxT0+PyQAchoR/gBxZ+ade7D8Z2Lt374QHiHfu3Dk6GfjlL38ZERGdnZ2jdwV6enqiec+eiI6OCJ9WDXVL+AfIWKUHfovF4oS7ApCnlpaWSZOB8XcGdu7cGYODgzE4ODg2GfjHf4ze//f/onfFiug9++xouuCCiOc+12QA6ojwD5Cjcm1iZGQkhoeHo6nJf5apTy0tLbF48eJYvHhxRFSYDDz+eAx2dsYvn3gi4vHHo+tLX4rehoboXbEies45J5rOPz/i+ONNBiBH/pYByFFjY2M0NjbG8PBw7N27V/jnsLH/ZGBPf3/0NzVF/9at0d/aGrvmzYvtXV2xPSKeePzxiMcei66/+IvobWyM3hNOiJ4Xv7g0GTjuOJMByJC/ZQAyNr72E1Fa/R8eHvbQL4e11t7eWPIP/xBLhoYi7r479txyS/T/x39E/8MPR39bW+xqb4/t3d2lycBjj0Vh7dro/OIXo6+pKXpPPDF6zjknGi+4IOJZzzIZgBoS/gFy1tLSErt37/bQL3NDU1PE6adH6+mnx5KI0mTgrrti9+rVMfDMZGBre3vsHjcZePzRR6PwyCPR9Wd/Fr3NzaU7Ay95STSef35pMgBUjfAPkJPyyr8df5jTmpoizjwz2s48M9oiYsm+faXJwC23RP8dd0T/I49E/zOTgW3d3bEtxk0GPv/56G1tLd0ZKE8Gjjkm73cEhzXhHyBj++/oY69/ktLcHHHWWdF21lmxNCKW7t0bceedsXv16tJk4NFHY+u8ebGnrS229fSUJgMPPxyFBx+M7s99rjQZOPnk6H7xi0s1oaOOyvsdwWFF+AfImZV/ktbSEnHOOdF2zjljk4H/+I/YvXp1bL3jjuh/7LHof2YyMNDTEwMR8diDD0bh/vuj+zOfid729ug96aToPvfc0p2B5cvzfkdQ1wrF8n1nADJx9913x8DAQJx44omxaNGiWLduXTz44IOxaNGiOPHEE/M+Pagve/ZE8Yc/LN0ZuOuu6F+7Nvo7O2NPa+uEwwojI9G9bVv0dXSUJgMveUk0XHBBxLJl0377kW3bIoaGomH+/Fq+C6gbVv4Bclau/Vj5hym0tkbhpS+N9pe+NNoj4ojdu6N4++2xe82aUk3o8cdja2dn7G1tjYHe3hiIiLj//mj4+c+j++qro7ejI3pXrixNBs4/P+KIIyIiYte//Es89Ed/FL/s7IyRhoY4or8/nnPZZdF95ZV5vluoOSv/ABnbf+W/v78/fvzjH0d7e3uceeaZeZ8eHF527YriD34Qu9asKd0ZePzx6O/qir3P1OnKGkZGontgIHq7uqLr6KPjp+vWxYalS6N9165oGBmJHR0dMX/LlnjxlVdGxxvekNObgdqz8g8c/oaHIxob8z6LgzbVPv8RHviFWWlvj8IFF8S8Cy6IeRGxbOfO0mTg1ltLk4Ff/nJ0MtDf1xdbI2LBPffEphNOiIWbN0fT8HBERHTs2BGbFi+Ox//0T2OF8M8cJvwDh78rroj48Y8jLrgg4uUvj3jpSyO6u/M+q4NWfuB3aGgoRkZGoqGhIeczgvo1MjISQ0ND07+OOiqG3vzmGHrDG2Jo585oeuCB2PfQQ7F93brYOTgYXQMDUSwURoN/RERDsRgte/fGZoUI5jjhHzi8FYsRN98csW5dxE9+EvGZz5TuApx+emkicMEFEeecE9HWlveZTlJe+W9qaopCoRDFYjH27dsXrfs9yAhzyUGF92leIyMjM/+hRx8dcfTR0RkRnXv3RvP//J9RLBSiGBHjN94dbmqK1qGhKr1TqE/CP3B46+8vPcD35JOliUBEqQZ0++2l18c+FtHaGvHiF5cmAy9/ecQLX1j64KGc7L/Pf6FQiObm5ti7d2/s3btX+Keu5RLep9DU1DTh1djYOOlrU75uuSW2P/54rF22LAZ6eqJnYCAiInZ0dETD8HAcefzxVTk/qFce+AXmhq1bI9asKd0FuPnmiJ//vPKx3d0R5503dmfgpJMi9gvktXTPPffE1q1bY8WKFbFkyZKIiLjzzjtjcHAwTj755FiwYEFm50JaisXiQYf34eHhTMP7TF6NjY2TJtEH5ZprIt773oiRkXj02GPjvpNOih3z5kVERNvu3XH81q2x4l/+JQom4MxhVv6BuaGvL+LXf730iohYvz7illvGJgOPPz527LZtETfeWHpFRCxeHHH++WN3Bp71rJpOBvZ/4DfCQ78cnJmE90qvaq355RLeD1VfX8Qzk5dnveAFMf91r4vH//qvI0ZGYvnFF0fv298ehcNo8wCYDeEfmJuOOCLikktKr2Ix4pFHSpOAW24pvZ56auzYTZsi/u7vSq+IiGOOGbsrcMEFo/uC15JP+U2D8J6z3/zNiPvui2hujli1KtqHhuLpZz4R+KTzzjs83xPMkPAPzH2FQsRxx5Ve/+W/lFb+7rtv7K7AmjUR27ePHf/YYxHXXlt6RUSccMLYTkLnnVdaPawy4f/wUC/hvVAoHHzHfS6F92r44z8evbNXrjAVCoV0/zxIjvAPpKehIeLkk0uv9743Ymgo4s47x2pC//7vEXv2jB3/s5+VXp//fOn3nnba2J2Bl7wk4pnO8MFS+8lPsVis2GU/2N57tcL7oay8NzQ0CKuzNe7Prfz/pe11SYnwD9DUFHHWWaXX+98fsWtXxA9+MHZn4I47RnvCMTJSmijceWfEJz9Zqg+cffbY8wJnnFH62gxZ+T84Mw3vU72qQXifG8or/8I/KRH+AfbX3j7W9//YxyIGBiL+7d/G7gz89Kdjx+7bV/q1f/u3iA99KKKjo/QhY+Wa0CmnlO4WTCHFlX/hnXoyvvYDqRD+AQ6kpyfiNa8pvSJKDwivXj12Z+CRR8aO3bEj4jvfKb0iIubPH9tJ6IILIp773CmDRnNjY3Tcdlu0DA7G8JFHRmMGDxnPhvDOXKL2Q4rs8w9wqNauHdtF6OabIzZsqHzskUfGvb/2a7H5uc+N5553Xix7wQti8O/+Lu793Odi48KFMdLQEJ2Dg/G8+fPjqL/5m6pvO1gsFmcc1vcP+9VQ/mCzmT6kKrxTTf39/fHjH/845s2bF2eccUbepwOZEP4BqqlYLH3AWHkicOutpU8hHue+E0+MpxYtiuMfeCCWtLfH95cvjw1Ll0b3tm3RODwcg52d0TAyEmctXhxH/Pmf7/ftZx7e9w/y1dDQ0HDIK++Qty1btsRPfvKT6OjoiNNPPz3v04FMqP0AVFOhUNoa9IQTIt797ojh4Yi77x6rCH3/+xOO3bhrVzy1aFEs3Lw5mp4J5q1btsSmhQvjkfvuiw133y28Q42o/ZAi4R+glhobI170otLrfe8rbSF6ww2lzxlob4+dDz0UxUJhNPiXte/ZEwPd3bF3y5Ypqz/COxw6u/2QIuEfIEutrVE48cSIRYui+La3Rdull0ZExHBDQzSWtxONiD0tLbGkvz+ed/LJwjvUSHnl3/MjpET4B8hLsRhLhodj/pYtsXnhwujr74/GoaEY7OyMQrEYxy5bFosXL877LGHOsvJPilztADkpRkTL9dfHi+6/P5Zu2BCDHR2xZf78aNq3L07evj2W/5//k/cpwpxmn39SZOUfIGMTgsbChdF7991xbltb/OL974+hLVtiyRVXxJJXvjK/E4REeOCXFAn/AHlbuDAaImLnW94Sg4ODsXzlyrzPCJKg9kOKXO0AGSuv/PuYFciX2g8pEv4B6oRJAWRL7YcUudoBciLkQ77UfkiRqx0gYyoGUB/s80+KhH+AOuOOAGTDyj8pcrUD5GT/kG/1EbIl/JMiVztAxoR8qA9qP6RI+AeoM2o/kA0r/6TI1Q6QsUpbelp9hGzZ558UCf8AQJLs80+KXO0AOalU71H7gWyo/ZAiVztAxipVDFQPIFtqP6RI+AcAkqT2Q4pc7QA5UfuBfKn9kCJXO0DG1H6gPtjnnxQJ/wBAkqz8kyJXO0DGKu3zX6b2A9kQ/kmRqx2gTqgeQLbUfkiR8A+QEyv8kC8r/6TI1Q6QsQOtMpoUQDbs80+KhH+AOiGAQLbs80+KXO0AObHCD/kpFovCP0lytQNkTO0H8leu/ES460ZahH+AOiGAQHbGT7Kt/JMSVztAxg60zz9Qe1b+SZXwDwAkZ/we/8I/KRH+AXKy/8q/OwKQHXv8kypXPEDGrDJC/uzxT6qEfwAgObb5JFWueICcqP1AftR+SJUrHiBjagaQP7UfUiX8AwDJUfshVa54gIxVqveo/UB21H5IlSseAEjO+H3+ISXCP0BOrPBDfqz8kypXPEDGKq00qv1AdoR/UuWKBwCSo/ZDqoR/gJxY4Yf8WPknVa54gIyp/UD+7PNPqoR/ACA59vknVa54gIxZ4Yf8qf2QKlc8QJ0xKYDaU/shVcI/QE4qfcIvUHtqP6TKFQ+QMSEf8qf2Q6pc8QB1Ru0Has8+/6RK+AfIidoP5MfKP6lyxQNkTMiH/An/pMoVD1Bn1H6g9tR+SJXwD5CxSvv8CyGQHSv/pMoVDwAkxz7/pEr4B8hJpXqP2g/Unn3+SZUrHiBjlVYarUBCdtR+SJUrHgBIjtoPqRL+ATJW6YHfMrUfqD21H1LligeoE1YgITtqP6TKFQ8AJMc+/6RK+AfImNoP5M/KP6lyxQPUCSuQkB0P/JIq4R8gJ1b4IT8e+CVVrniAjB1opdGkAGpP7YdUueIB6oT6AWSjWCx64JdkCf8AGTvQA79AbY0fe1b+SY0rHgBISrnyEyH8kx5XPECdcEcAsjE+/Kv9kBrhHyBjQj7ka3zfX/gnNcI/AJAUO/2QMlc9QE72X/l3RwCyYacfUib8A2RM4IB8WfknZa56ACAp5fBvIk6KhH+AjFWq96j9QDbKY8zKPyly1QMASVH7IWWuegAgKWo/pEz4B8iY2g/kS+2HlLnqAYCkqP2QMlc9QE6s8EM+7PNPyoR/gIxVChxqP5ANK/+kzFUPACRF+CdlrnqAjFnhh3yp/ZAy4R+gzpgUQG1Z+SdlrnqAOmEVErJhn39SJvwDZEztB/Jln39S5qoHqDMmBVBbaj+kzFUPkJNKn/AL1JbaDykT/gEyJnBAvtR+SJmrHqDOqP1Aban9kDJXPUDGKj3w644AZMM+/6RM+AcAkmLln5S56gFyUqneo/YDteWBX1Im/ANkrFLgEEQgGx74JWWuegAgKWo/pMxVD5ATtR/Ih9oPKRP+ATKm9gP5UvshZa56gBxZ5Yfsqf2QMlc9QMYOtMJvQgC1pfZDyoR/gDohiEA21H5ImaseIEdW+SF7aj+kzFUPkDG1H8hXeYy520aKhH+AOiGIQDas/JMyVz1AjqzyQ/Y88EvKhH+AjKn9QH6KxaIHfkmaqx6gTliFhNobP7kW/kmRqx4gY+NDvlV+yFa58hNhwk2ahH8AIBlW/kmdqx4gR+ODSHkV0t0AqJ3xD/ta+SdFwj9AxgQOyI89/kmd8A8AJMMe/6TOlQ+QI7UfyJbwT+pc+QAZUzeA/Kj9kDrhHwBIhpV/UufKB8jBVBUftR+ovfG7/UCKhH8AIBnlybWVf1LlygfIkVV+yJbaD6lz5QPkYKrKgdoP1J7aD6kT/gGAZKj9kDpXPkCOrPJDttR+SJ0rHyAH01UOTAigduzzT+qEf4A6IYxA7Vn5J3WufIAceLgX8uGBX1In/APUGRMCqB0P/JI6Vz5Ajqb6hF+gdtR+SJ0rHyAHgj7kQ+2H1An/AHVG7QdqR+2H1LnyAXKk9gPZUvshda58gBwI+pAPtR9SJ/wD1Bm1H6gdtR9S58oHyMFU+/xbiYTaU/shda58ACAZ5Qm3yTapEv4BcjRVxUftB2rHyj+pc+UD5GCqVUcrkVB7HvgldcI/AJAMD/ySOlc+QI7UfiBbaj+kzpUPkAO1H8iH2g+pE/4BgGSo/ZA6Vz5ADqba579M7QdqR+2H1LnyAeqEGgLUnn3+SZ3wD5Ajq/yQLSv/pM6VD5CD6VYdTQigdoR/UufKB6gTaghQe2o/pE74B8iRVX7ITrFYtPJP8lz5ADlQ+4HsjR9bVv5JlfAPUCeEEait8eHfyj+pcuUD5GC6ff6B2ihXfiKEf9LlygeoQyYFUH3jw787baRK+AfIkQ4yZKc83qz6kzJXP0AOBH3Inp1+QPgHABJhj38Q/gFyVan2o/MP1WflH4R/gFxYeYTsCf8g/AMAiVD7AeEfIBdT7fOv9gO1ZeUfhH8AIBHl8G/ln5QJ/wA5ssIP2bHPPwj/ALk40MqjSQFUn9oPCP8AdUMVAWpL7QeEf4BcWeGH7Kj9gPAPkAu1H8ie2g8I/wB1QxUBass+/yD8A+Riqn3+gdqy8g/CP0BdMimA6vPALwj/ALmq9Am/QPV54BeEf4BcCPqQPbUfEP4B6pLaD1Sf2g8I/wC52j/kCyVQO2o/IPwD5ELIh+yp/YDwD1CX1H6g+uzzD8I/QC4q7fMvlEDtWPkH4R8ASITwD8I/QK4q1XvUfqD61H5A+AfIRaXwIZRA7Vj5B+EfAEiEff5B+AfIldoPZMc+/yD8A+RC7Qeyp/YDwj9ArqzwQ3bUfkD4B8jFgcKHSQFUn9oPCP8AdcWKJNSO2g8I/wC5ssIP2bHPPwj/ALlQ+4HsWfkH4R+grliRhNoR/kH4B8hFOeRb4YdsjB9rJtmkTPgHqEMmBVBd5VX/CCv/pM3VD5Cj/UO+FUmojfHh3zgjZcI/QA6ED8iW2g+UCP8AwJw3/mFf4Z+UCf8AOapU+9H5h+oqh3/Bn9QJ/wA5EEAgW+UJtYd9SZ0RAADMefb4hxIjACAHleo9aj9QG+Ux5a4bqRP+AYA5z8o/lBgBADmywg/Z8MAvlAj/ADk4UAAxKYDq8sAvlBgBAHXEqiTUhtoPlBgBADmywg/ZUPuBEuEfIAdqP5AttR8oMQIA6ohVSagNtR8oMQIAcmA/f8iW2g+UCP8AdcikAKpL7QdKjACAHFX6hF+gutR+oMQIAMiBkA/ZKk+0jT1SJ/wD1CG1H6guK/9QYgQA5EjtB7LhgV8oEf4BciCAQLY88AslRgBAHVL7gepS+4ESIwAgB5X2+XdHAGpD7QdKhH8AYM5T+4ESIwAgR5XqPWo/UF1qP1BiBADkoFL1QCUBasM+/1Ai/AMAc56VfygxAgBypPYD2RD+ocQIAMiB2g9kS+0HSoR/AGDOs/IPJUYAQA4q7fNfpvYD1WWffygR/gHqiGACtWGffygxAgByZIUfsqH2AyVGAEAODrTCb1IA1aX2AyXCP0AdEUygNtR+oMQIAMiRFX7IhtoPlBgBADlQ+4Fs2ecfSoR/gDoimED1FYtFtR94hhEAkIMD7fMPVE+58hNhgg3CPwAwp42fZFv5J3VGAECO9l/5d0cAqs/KP4wR/gFyIIBAdsbv8W/skTrhHwCY0zzsC2OMAoAcqf1A7dnjH8YYBQA5UD2A7Iyv/UDqhH8AYE5T+4ExRgFADg5U71H7gepR+4ExRgFAHVFLgOorT6aNLxD+AXJlhR9qz8o/jDEKAHJwoBVIkwKoHg/8whjhH6COCCdQfR74hTFGAUCOrPBD7an9wBijACAHaj+QHbUfGCP8A9QR4QSqT+0HxhgFADk40D7/QPWo/cAYowCgDpkUQPXY5x/GCP8AOdo/5AsnUH1W/mGMUQCQAyEfsiP8wxijAKAOqf1A9aj9wBjhHyBHaj9Qe1b+YYxRAJADIR+yY59/GCP8A9QhtR+oHvv8wxijACAHlfb5tzIJ1af2A2OMAgBgTlP7gTHCP0COKtV71H6getR+YIxRAJCDSiuQViah+tR+YIxRAADMafb5hzHCP0CO1H6g9qz8wxijACAHaj+QHQ/8whjhHwCY0zzwC2OMAoAcVNrnv0ztB6pH7QfGGAUAdUQtAapP7QfGCP8AObLCD7Wn9gNjjAKAHBxoBdKkAKpH7QfGGAUAdUQtAapP7QfGCP8AObLCD7Wn9gNjjAKAHKj9QDaKxaLwD+MYBQA52j/kqyVAdY0fY8YXCP8AuRBCIBvlvn+ElX+IEP4BgDlsfPg36QbhHyBXlWo/Ov9QHeWxVCgUhH8I4R8gF0IIZMMe/zCRkQCQM6v8UDv2+IeJhH+AOmRCANVhm0+YyEgAyEGlVUirk1Bdaj8wkZEAkDOr/FA74x/4BYR/gFz4hF/IhpV/mMhIAKgjViehuoR/mMhIAMiZVX6oHbUfmEj4B8iB2g9kw8o/TGQkANQRq5NQXfb5h4mEf4CcWeWH2rHPP0xkJADkQO0HsqH2AxMZCQA5Gx/0VROgutR+YCLhHyAHgghkQ+0HJjISAOqQ2g9Uh9oPTGQkAORM7Qdqxz7/MJHwD5ADQQSyYeUfJjISAOqQ2g9Uh/APExkJADlT+4HaUfuBiYR/gJwII1B7Vv5hIiMBIGdTVXzUfqA67PMPEwn/ADmZKowIKFBd9vmHiYwEAGDOUvuBiYwEgJyp/UDtqP3ARMI/QE7UfqD21H5gIiMBAJiz1H5gIiMBIGdqP1A79vmHiYR/gJyo/UDtWfmHiYwEgJxZ5Yfa8cAvTCT8A+RkujBiQgDV4YFfmMhIAKgjViehutR+YCIjASBnVvmhdtR+YCLhHyAnaj9Qe2o/MJGRAFBHrE5Cdan9wERGAkDOrPJDbRSLRfv8w36Ef4CcqP1AbY0fR1b+ocRIAMjZ+IBidRKqp1z5iRD+ocxIAMiJoA+1ZWINkwn/AMCcNH6bT+EfSoR/gJxN1e/X+YdDZ49/mEz4B8jJVIFESIHqscc/TGY0AABzkj3+YTKjASBnaj9QG2o/MJnwD5ATtR+oLbUfmMxoAMiZVX6oDbUfmMxoAMiJT/iF2iqPI3fUYIzwD1BHhBSoHiv/MJnRAJAzq/xQG8I/TGY0AORE7QdqS+0HJhP+AeqIkALVY+UfJjMaAHJSDvpW+aE27PMPkwn/AHXIhAAOnX3+YTKjASBn44O+FUqoHrUfmMxoAMiJoA+1pfYDkwn/AHVI7QcOndoPTGY0AORM7QdqQ+0HJjMaAHIi6ENt2ecfJhP+AeqQ2g8cOiv/MJnRAJCTqfb5t0IJ1eOBX5hM+AcA5iQP/MJkRgNAzqaq+Kj9wKFT+4HJjAaAnExVRVBPgOpR+4HJhH8AYE5S+4HJjAaAnKn9QG2o/cBkRgNATtR+oLbUfmAy4R8AmJPUfmAyowEgJ1Pt81+m9gOHTu0HJjMaAOqIegJUT3kSbVzBGOEfIGdW+aE2rPzDZEYDQE6mW400IYBD54FfmEz4B6gjQgpUjwd+YTKjASBnVvmhNtR+YDKjASAnaj9QW2o/MJnwD1BHhBSojmKxqPYDUzAaAHIy3T7/wKEZP66EfxhjNADUIRMCODTjx5A7ajBG+AfImaAP1Vfu+0dY+YfxjAaAnEy1GmmFEqpj/MO+xhWMEf4B6pQ7AjB75fEj+MNEwj9AzoR8qD57/MPUjAiAnKj9QO3Y4x+mJvwD5MzKP1SfPf5hakYEQE4OtCJpUgCzp/YDUzMiAOqIigJUh9oPTE34B8iZFX6oPrUfmJoRAZATtR+oHbUfmJoRAVBHVBSgOuzzD1MT/gFyZoUfqs/KP0zNiADIidoP1I4HfmFqwj9AzsaHfEEFqsMDvzA1IwIgJ4I+1I7aD0zNiACoU2o/MHtqPzA14R8gZ2o/UH1qPzA1IwIgJ4I+1I7aD0zNiACoU2o/MHtqPzA14R8gZ2o/UH1qPzA1IwIgJ4I+1I7aD0zNiADIWaV6j9oPzF55/Jhkw0TCP0BOKoUSYQUOnZV/mJoRAQDMOR74hakJ/wA5U/uB6vPAL0zNiADIidoP1I7aD0zNiAAA5hy1H5ia8A+QM7UfqD61H5iaEQGQE7UfqB21H5iaEQGQMyv8UH32+YepCf8AOTlQKDEpgNmz8g9TMyIA6oyVSjh0wj9MzYgAyJkVfqg+tR+YmvAPkBO1H6gdK/8wNSMCoM5YqYRDZ59/mJrwD5AzK/xQffb5h6kZEQA5UfuB2igWi2o/UIERAZAzIR+qa/yYUvuBiYR/gJz4hF+ojfHh38o/TGREAABzSrnyEyH8w/6MCICcVar9qAPB7Bg7UJnwD5ATtR+ojfEP+xpPMJHwDwDMKfb4h8qEf4Ccqf1AddnjHyozKgByovYDtWGPf6jMqADImRV+qC61H6hM+AfIiU/4hdpQ+4HKjAqAOmO1Eg6N2g9UZlQA5MwKP1SX2g9UJvwD5ETtB2pD7QcqMyoA6ozVSjg0aj9QmVEBkDMr/FBd5TFlIg2TCf8AOVH7gdqw8g+VGRUAOds/5FuthEPjgV+oTPgHyIlgArXhgV+ozKgAqFNqPzA7aj9QmVEBkDO1H6gutR+oTPgHyIlgArWh9gOVGRUAdUrtB2ZH7QcqMyoAcqb2A9Vln3+oTPgHyIlgArVh5R8qMyoAclap3qP2A7Mj/ENlRgVATiqt/LsjAIdG7QcqE/4BgDnFyj9UZlQA5EztB6rLPv9QmfAPkKPh4eHRoFImsMChsc8/VNaU9wkApGjz5s1xzz33xMMPPxwtLS3R0dERxx9/fLS2tuZ9anDYU/uByowKgIxt2bIlbr/99li/fn1ElFb/77333rjzzjtjeHh49Di1H5gdtR+ozMo/QMYeeeSR2LFjRyxYsCCGhoaiubk55s+fH+vXr4+nnnpKYIFDpPYDlRkVABnbvHlztLe3j4b8YrEYLS0tMTIyEtu2bcv57ODwp/YDlRkVABlra2uLffv2RUNDQ7S1tUVra2uMjIxEsViM5ubm0ePUfmB27PMPlQn/ABk75phjYmRkJPbt2xdLliyJ+fPnx5YtW6K7uzuWLl0qsMAhsvIPlen8A2TsmGOOiW3btsWjjz4amzZtikKhEN3d3XHqqadGe3t73qcHhz0P/EJlwj9AxhoaGmLlypVx7LHHRn9/fzQ1NcWiRYuipaVlwnFqPzA7HviFyoR/gBwUCoXo6emJnp6evE8F5hy1H6jMqACoM6oKcGjUfqAy4R+gTqn9wMyNHzdW/mEyowIAmDPKq/4Rwj9MxagAqDOqCjB748O/sQSTCf8AwJwxvvYj/MNkwj9AndL5h5kbv9OP8A+TCf8AdUZggdkrT5qNI5ia8A8AzBn2+IfpGRkAdUrtB2bOHv8wPeEfoM4ILTB75UmzlX+YmpEBAMwZaj8wPSMDoE6p/cDMqf3A9IR/gDojtMDsqf3A9IwMAGDOUPuB6RkZAHVK7Qdmzj7/MD3hH6DOCC0we1b+YXpGBgAwZwj/MD0jA6BOqf3AzKn9wPSEf4A6I7TA7Fn5h+kZGQDAnGGff5ie8A9Qp9R+YObs8w/TMzIA6owVS5g9tR+YnpEBAMwZaj8wPeEfoE6p/cDMqf3A9IwMgDpjxRJmT+0HpmdkAABzhn3+YXrCP0CdUvuBmbPyD9MzMgDqjBVLmD3hH6ZnZAAAc4baD0xP+AeoU2o/MHNW/mF6RgZAnbFiCbNnn3+YnvAPAMwZ9vmH6RkZAHVK7QdmTu0HpmdkANQZdQWYPbUfmJ7wDxlauzaiUJj8etnL8j4zgLlB7Qem15T3CUBKjjoqYv36sX/fsCHiFa+IeOlL8zsn6pfaD8yc2g9MT/iHDDU2RixdWvrn3bsjfv3XI84+O2LVqjzPCmDusM8/TE/4h5z81m9FbN8e8S//EmGBivGEFpg9K/8wPeEfcvDRj0Z897sR//EfEV1deZ8N9UrtB2bOA78wPeEfMrBvX6nm09wccdNNEX/0RxHf+U7EccflfWYAc4sHfmF6RgZk4B3viOjujnjf+yLe8pbS/554YumB3w0bIrZsyfsMqSdWLGF2isWi8A8HYGRABlpaSv/72GMRO3eWaj9HHDH2et3r8j0/6pPaD8xMufITYRINlQj/kIHW1tL/nnBCRLE4+XXrrbmeHsCcMH7CbOUfpmZkQAbKK/979+Z7HhwerFjC7Fj5hwMT/iED5ZX/PXsOfOx191wXCz61IPYMTTz44r+/ON7yj2+pwdkBzA3j9/gX/mFqwj9kYCbh/w0nvCGGR4bjhvtvGP3a5p2b49sPfDsuP/XyGp0h9UjnH2bGHv9wYEYHZGAmtZ/25vb4jZN/I7784y+Pfu1rP/laLO9eHi879mW1OUHqihVLmB3hHw7M6IAMzGTlPyLiytOujO89/L1Yt21dRER8+cdfjstOuUwoBJjG+NoPMDXhHzIw0wd+X3DEC+KUpafEdfdcFz9a/6P46aafxmWnXlaz86M+qf3AzFj5hwPzCb+QgYNd+R8aGYqhkaFoa2qLt73gbfG/b//fsW77unjFs18RR/UcVfsTpS5YtYTZKYd/YwgqMzWGDJTD/3Qr/zv37YyL//7iuOT6S2J4ZDguWXlJrNu+Lv7yR38ZV5x6RTYnCnAY8+m+cGBGB2SgXPuptPL/9M6n4xXXvSJuuP+GuOmBm+KejfdEd2t3XLzi4uhs6Yxff/6vZ3au1A+1H5gZtR84MLUfyMB0tZ/H+h+Li752Ufxi8y+it603bnzzjXHaEadFRMT6wfVxycmXRGtTa4ZnS95UFmB21H7gwIR/yEClB35/svEncdFXL4r1g+tjeffy+O4l340TF58YW3Ztie89/L245dFb4vOv/Hz2JwxwGFL7gQMT/iEDU63837r21njt3742tu3ZFictPim+c8l3Ynn38oiIOO3PT4utu7fGJ1/xyXjewuflcMbUA7UfmBm1Hzgw4R8ysP8Dv39/39/Hpf94aewd3hvnHn1u/N83/d/oa+8bPX7te9dmf5LUDZUFmB37/MOBmRpDBsY/8PvZ2z8bb/rGm2Lv8N64eMXF8b1Lvzch+AMwO1b+4cCMDshAeeX/6e3b473//N4oRjHedfq74u9e/3fR1tSW78lRt9R+4OANDAzEQw89FE888UQ88cQT0d/fn/cpQV0S/iELhVLZf+fuoYiI+OMLPhbXvPKaaGxonP33fOqpiKVLI/74j8e+9sMflm4zfO97h3K25ExlAWZm48aNcdttt8UjjzwS27dvj1/+8pdx2223xfr16/M+Nag7wj9k4I7b/0/pH4Za48vfiviDt/5VFP77f4+4/faIZ25Tz9iiRRHXXhuxalXEnXdGDA5G/OZvRrzznRH/6T9V69QB6trIyEjcd999sWvXrujt7Y158+ZFb29v7NmzJ+67774YHh7O+xShrgj/kIE3vOqN8auvuy7e9cI/jcvub4949NGIT3864uyzI44+OuK3fzvi3/4tYqZ/Sb3qVRFXXhlxySUR73hHRFtbxCc+UZs3QebUfuDAtm3bFv39/dHT0zP6tUKhEN3d3bFt27YYGBjI8eyg/gj/kIGuZV3x7W++JT5/+++X6jrf+EbEm98c0dkZsW5dxOc+F3HeeRFHHlkK8f/6rxH79h3cN//0pyOGhiL+/u8jvva10gSAw5raD8xMoVCIYrFotx84CMI/ZK2jI+LiiyP+5m9KE4Ebboh461sjensjNm6M+PM/j7jwwlKf/4orIm66aeqPBi575JGIJ58s1YceeyyztwFQD7q7u6Ovry8GBgair68vjjnmmOjt7Y2BgYHo7e2N3t7evE8R6kqh6L4y1Id9+yJWry7dFfjWt0oTg7Lu7ojXvKY0abjoooj29tLX9+6NOOOMiFNPjXj+8yP+1/+K+OlPI5YsyeMdUCVPPvlkPPDAA7FgwYI4+eST8z4dqHtPPfVU3HHHHbFt27ZobGyMkZGR6OzsjNNPPz0WL16c9+lBXRH+oR4NDUV8//ulicD110eM37Fi3rxS1//SSyNuu610zD33lCpE558f0dUV8e1v53fuHLL169fH/fffL/zDDGzfvj3WrVsXg4OD0dHREcuXL4+urq68TwvqjvAP9W5kpLQr0De/WXqVqz2/8isRN99culvwkpeUvvb44xErV0Z8/OMRV12V3zlzSIR/AGpF+IfDSbEYcdddpUnARReVHhJmzimH//nz58fKlSvzPh0A5pCmvE8AmIFCIeJFLyq9mLPsVAJArdjtBwAAEiH8A9QprUwAqk34B6gzaj8A1IrwDwAAiRD+AeqU2g8A1Wa3H4A6sn379njwwQdj7dq10dnZGQsXLowjjzxSFQiAqrDPP0Cd6O/vj9tvvz02btwYO3fujKamppg/f36sWLEiVqxYYQIAwCFT+wGoEw8++GAMDAzEggULor29PTo7O6O1tTUefPDB2L59e96nB8AcIPwD1IGhoaHYuHFjdHR0TFjh7+joiD179sSWLVtyPDsA5grhH6AOFAqFaGhoiJGRkdF/bmhoiGKxGMViMRoa/OcagEPnbxOAOtDY2BjLly+PnTt3RktLSxx99NGxePHi6O/vj87Ozli0aFHepwjAHGC3H4A6cfzxx8fWrVtj06ZNMTIyEsViMTo6OmLlypXR3t6e9+kBMAfY7Qegjuzbty82bNgQ27Zti+bm5li6dGl0d3fnfVoAzBHCPwAAJELnHwAAEiH8AwBAIoR/AABIhPAPAACJEP4BACARwj8AACRC+AcAgEQI/wAAkAjhHwAAEiH8AwBAIoR/AABIhPAPAACJEP4BACARwj8AACRC+AcAgEQI/wAAkAjhHwAAEiH8AwBAIoR/AABIhPAPAACJEP4BACARwj8AACRC+AcAgEQI/wAAkAjhHwAAEiH8AwBAIoR/AABIhPAPAACJEP4BACARwj8AACRC+AcAgEQI/wAAkAjhHwAAEiH8AwBAIoR/AABIhPAPAACJEP4BACARwj8AACRC+AcAgEQI/wAAkAjhHwAAEiH8AwBAIoR/AABIhPAPAACJEP4BACARwj8AACRC+AcAgEQI/wAAkAjhHwAAEiH8AwBAIoR/AABIhPAPAACJEP4BACARwj8AACRC+AcAgEQI/wAAkAjhHwAAEiH8AwBAIoR/AABIhPAPAACJEP4BACARwj8AACRC+AcAgEQI/wAAkAjhHwAAEiH8AwBAIoR/AABIhPAPAACJEP4BACARwj8AACRC+AcAgEQI/wAAkAjhHwAAEiH8AwBAIoR/AABIhPAPAACJEP4BACARwj8AACRC+AcAgEQI/wAAkAjhHwAAEiH8AwBAIoR/AABIhPAPAACJEP4BACARwj8AACRC+AcAgEQI/wAAkAjhHwAAEiH8AwBAIoR/AABIhPAPAACJEP4BACARwj8AACRC+AcAgEQI/wAAkAjhHwAAEiH8AwBAIoR/AABIhPAPAACJEP4BACARwj8AACRC+AcAgEQI/wAAkAjhHwAAEiH8AwBAIoR/AABIhPAPAACJEP4BACARwj8AACRC+AcAgEQI/wAAkAjhHwAAEiH8AwBAIoR/AABIhPAPAACJEP4BACARwj8AACRC+AcAgEQI/wAAkAjhHwAAEiH8AwBAIoR/AABIhPAPAACJEP4BACARwj8AACRC+AcAgEQI/wAAkAjhHwAAEiH8AwBAIoR/AABIhPAPAACJEP4BACARwj8AACTi/wNHIFvb+SpNjAAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# MODE SHAPES PLOT\n", + "# Plot mode 2 (geometry 1)\n", + "_, _ = Pali_ss.plot_mode_geo1(algo_res=fsdd.result, mode_nr=2, view=\"3D\", scaleF=2)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "90ba64f1-3385-42ee-b214-b1fcc531d2fa", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# Animate mode 1 (geometry 2)\n", + "_ = Pali_ss.anim_mode_geo2(\n", + " algo_res=ssicov.result, mode_nr=1, scaleF=3)" + ] + }, + { + "cell_type": "markdown", + "id": "1a5df13d-8450-4bdb-9efd-055ae0833e6a", + "metadata": {}, + "source": [ + "It is also possible to save and load the results to a pickled file." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "7eb9c29a-75a0-4581-b625-024ff0b5b123", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import os\n", + "import sys\n", + "import pathlib\n", + "# Add the directory we executed the script from to path:\n", + "sys.path.insert(0, os.path.realpath('__file__'))\n", + "\n", + "from pyoma2.functions.gen import save_to_file, load_from_file\n", + "\n", + "# Save setup\n", + "save_to_file(Pali_ss, pathlib.Path(r\"./test.pkl\"))\n", + "\n", + "# Load setup \n", + "pali2: SingleSetup = load_from_file(pathlib.Path(r\"./test.pkl\"))\n", + "\n", + "# plot from loded instance\n", + "_, _ = pali2.plot_mode_geo2_mpl(\n", + " algo_res=fsdd.result, mode_nr=1, view=\"3D\", scaleF=2)" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "c0a5863b", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-01-22 19:42:55.114 python[66066:51262326] +[IMKClient subclass]: chose IMKClient_Modern\n", + "2025-01-22 19:42:55.114 python[66066:51262326] +[IMKInputSession subclass]: chose IMKInputSession_Modern\n" + ] + } + ], + "source": [ + "# delete file\n", + "os.remove(pathlib.Path(r\"./test.pkl\"))" + ] + }, + { + "cell_type": "markdown", + "id": "23ea8bfe-a527-42b9-8068-d1d89210b425", + "metadata": {}, + "source": [ + "## References\n", + "[APTF20] Aloisio, A., Pasca, D., Tomasi, R., & Fragiacomo, M. (2020). Dynamic identification and model updating of an eight-storey CLT building. Engineering Structures, 213, 110593." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.15" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Examples/Example3.ipynb b/Examples/Example3.ipynb new file mode 100644 index 0000000..684d860 --- /dev/null +++ b/Examples/Example3.ipynb @@ -0,0 +1,439 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "f3667011-0968-4b0d-953b-70479293fe13", + "metadata": { + "scrolled": true + }, + "source": [ + "# Example3 - Multisetup with Post Separate Estimation Re-scaling (PoSER) method" + ] + }, + { + "cell_type": "markdown", + "id": "5884cd70-e3e5-452e-ac16-943d7dc560f4", + "metadata": { + "scrolled": true + }, + "source": [ + "In this example, we'll be working with a simulated dataset generated from a finite element model of a fictitious three-story, L-shaped building. This model was created using OpenSeesPy, and the corresponding Python script can be found [here](https://github.com/dagghe/pyOMA-test-data/blob/main/test_data/3SL/model.py). \n", + "\n", + "As always, first we import the necessary modules. All the files needed to run this example are available [here](https://github.com/dagghe/pyOMA-test-data/tree/main/test_data/3SL)." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "f3e2cd26-9c03-4511-a7b3-ef28222e6dde", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "\n", + "from pyoma2.algorithms import SSIcov\n", + "from pyoma2.setup import MultiSetup_PoSER, SingleSetup\n", + "from pyoma2.support.utils.sample_data import get_sample_data" + ] + }, + { + "cell_type": "markdown", + "id": "e16c688c-1833-45e8-96ac-5c07498ea323", + "metadata": {}, + "source": [ + "For the **PoSER** approach, after importing the necessary modules and loading the data, the next step is to create a separate instance of the single setup class for each available dataset.\n", + "\n", + "The exact natural frequencies of the system are: 2.63186, 2.69173, 3.43042, 8.29742, 8.42882, 10.6272, 14.0053, 14.093, 17.5741" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "ba84512c-b8a7-47ec-a2a3-bab2e2aee6f3", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-01-22 19:59:12,470 - pyoma2.support.utils.sample_data - INFO - set1.npy already exists locally. (sample_data:49)\n", + "2025-01-22 19:59:12,473 - pyoma2.support.utils.sample_data - INFO - set2.npy already exists locally. (sample_data:49)\n", + "2025-01-22 19:59:12,475 - pyoma2.support.utils.sample_data - INFO - set3.npy already exists locally. (sample_data:49)\n" + ] + } + ], + "source": [ + "# import data files\n", + "set1 = np.load(get_sample_data(filename=\"set1.npy\", folder=\"3SL\"), allow_pickle=True)\n", + "set2 = np.load(get_sample_data(filename=\"set2.npy\", folder=\"3SL\"), allow_pickle=True)\n", + "set3 = np.load(get_sample_data(filename=\"set3.npy\", folder=\"3SL\"), allow_pickle=True)\n", + "\n", + "# create single setup\n", + "ss1 = SingleSetup(set1, fs=100)\n", + "ss2 = SingleSetup(set2, fs=100)\n", + "ss3 = SingleSetup(set3, fs=100)\n", + "\n", + "# Detrend and decimate\n", + "ss1.decimate_data(q=2)\n", + "ss2.decimate_data(q=2)\n", + "ss3.decimate_data(q=2)" + ] + }, + { + "cell_type": "markdown", + "id": "93e03054-658f-444e-af18-b9b1220be29c", + "metadata": {}, + "source": [ + "The process for obtaining the modal properties from each setup remains the same as described in the example for the single setup. " + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "b51671c7-7df3-48a0-9cc7-54367d7b9d19", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-01-22 19:59:12,517 - pyoma2.setup.base - INFO - Running SSIcov_s1... (base:123)\n", + "2025-01-22 19:59:12,517 - pyoma2.functions.ssi - INFO - Assembling Hankel matrix method: cov... (ssi:82)\n", + "2025-01-22 19:59:12,840 - pyoma2.functions.ssi - INFO - SSI for increasing model order... (ssi:319)\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 81/81 [00:00<00:00, 17142.07it/s]\n", + "2025-01-22 19:59:12,866 - pyoma2.functions.ssi - INFO - Calculating modal parameters for increasing model order... (ssi:484)\n", + "100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 81/81 [00:00<00:00, 1100.21it/s]\n", + "2025-01-22 19:59:13,186 - pyoma2.setup.base - INFO - all done (base:102)\n", + "2025-01-22 19:59:13,186 - pyoma2.setup.base - INFO - Running SSIcov_s2... (base:123)\n", + "2025-01-22 19:59:13,186 - pyoma2.functions.ssi - INFO - Assembling Hankel matrix method: cov... (ssi:82)\n", + "2025-01-22 19:59:13,416 - pyoma2.functions.ssi - INFO - SSI for increasing model order... (ssi:319)\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 81/81 [00:00<00:00, 22076.72it/s]\n", + "2025-01-22 19:59:13,422 - pyoma2.functions.ssi - INFO - Calculating modal parameters for increasing model order... (ssi:484)\n", + "100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 81/81 [00:00<00:00, 1189.83it/s]\n", + "2025-01-22 19:59:13,730 - pyoma2.setup.base - INFO - all done (base:102)\n", + "2025-01-22 19:59:13,730 - pyoma2.setup.base - INFO - Running SSIcov_s3... (base:123)\n", + "2025-01-22 19:59:13,730 - pyoma2.functions.ssi - INFO - Assembling Hankel matrix method: cov... (ssi:82)\n", + "2025-01-22 19:59:13,948 - pyoma2.functions.ssi - INFO - SSI for increasing model order... (ssi:319)\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 81/81 [00:00<00:00, 22216.76it/s]\n", + "2025-01-22 19:59:13,954 - pyoma2.functions.ssi - INFO - Calculating modal parameters for increasing model order... (ssi:484)\n", + "100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 81/81 [00:00<00:00, 1195.85it/s]\n", + "2025-01-22 19:59:14,265 - pyoma2.setup.base - INFO - all done (base:102)\n", + "2025-01-22 19:59:14,335 - pyoma2.setup.base - INFO - Getting mpe modal parameters from SSIcov_s1 (base:149)\n", + "2025-01-22 19:59:14,336 - pyoma2.functions.ssi - INFO - Extracting SSI modal parameters (ssi:887)\n", + "100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 9/9 [00:00<00:00, 39321.60it/s]\n", + "2025-01-22 19:59:14,337 - pyoma2.setup.base - INFO - Getting mpe modal parameters from SSIcov_s2 (base:149)\n", + "2025-01-22 19:59:14,337 - pyoma2.functions.ssi - INFO - Extracting SSI modal parameters (ssi:887)\n", + "100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 9/9 [00:00<00:00, 43240.25it/s]\n", + "2025-01-22 19:59:14,338 - pyoma2.setup.base - INFO - Getting mpe modal parameters from SSIcov_s3 (base:149)\n", + "2025-01-22 19:59:14,338 - pyoma2.functions.ssi - INFO - Extracting SSI modal parameters (ssi:887)\n", + "100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 9/9 [00:00<00:00, 36472.21it/s]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Initialise the algorithms for setup 1\n", + "ssicov1 = SSIcov(name=\"SSIcov_s1\", method=\"cov\", br=50, ordmax=80)\n", + "# Add algorithms to the class\n", + "ss1.add_algorithms(ssicov1)\n", + "ss1.run_all()\n", + "\n", + "# Initialise the algorithms for setup 2\n", + "ssicov2 = SSIcov(name=\"SSIcov_s2\", method=\"cov\", br=50, ordmax=80)\n", + "ss2.add_algorithms(ssicov2)\n", + "ss2.run_all()\n", + "\n", + "# Initialise the algorithms for setup 3\n", + "ssicov3 = SSIcov(name=\"SSIcov_s3\", method=\"cov\", br=50, ordmax=80)\n", + "ss3.add_algorithms(ssicov3)\n", + "ss3.run_all()\n", + "\n", + "# Plot stabilisation chart\n", + "_, _ = ssicov1.plot_stab(freqlim=(1,20))\n", + "_, _ = ssicov2.plot_stab(freqlim=(1,20))\n", + "_, _ = ssicov3.plot_stab(freqlim=(1,20))\n", + "\n", + "# Extract results \n", + "ss1.mpe(\n", + " \"SSIcov_s1\",\n", + " sel_freq=[2.63, 2.69, 3.43, 8.29, 8.42, 10.62, 14.00, 14.09, 17.57],\n", + " order_in=50)\n", + "ss2.mpe(\n", + " \"SSIcov_s2\",\n", + " sel_freq=[2.63, 2.69, 3.43, 8.29, 8.42, 10.62, 14.00, 14.09, 17.57],\n", + " order_in=40)\n", + "ss3.mpe(\n", + " \"SSIcov_s3\",\n", + " sel_freq=[2.63, 2.69, 3.43, 8.29, 8.42, 10.62, 14.00, 14.09, 17.57],\n", + " order_in=40)" + ] + }, + { + "cell_type": "markdown", + "id": "a41a88e6-59a3-41b0-b476-447769bd5a0c", + "metadata": {}, + "source": [ + "After analyzing all datasets, the ```MultiSetup_PoSER``` class can be instantiated by passing the processed single setup and the lists of reference indices. Subsequently, the ```merge_results()``` method is used to combine the results." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "44a282d8-ac3f-42c8-99e0-75c06caeb772", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-01-22 19:59:14,504 - pyoma2.setup.multi - INFO - Merging SSIcov results for SSIcov group (multi:220)\n", + "2025-01-22 19:59:14,505 - pyoma2.setup.multi - INFO - Merging SSIcov_s1 results (multi:226)\n", + "2025-01-22 19:59:14,505 - pyoma2.setup.multi - INFO - Merging SSIcov_s2 results (multi:226)\n", + "2025-01-22 19:59:14,505 - pyoma2.setup.multi - INFO - Merging SSIcov_s3 results (multi:226)\n" + ] + }, + { + "data": { + "text/plain": [ + "array([ 2.63203919, 2.69132343, 3.4254799 , 8.29357079, 8.42973383,\n", + " 10.60678491, 14.00410737, 14.08557463, 17.42890419])" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# reference indices\n", + "ref_ind = [[0, 1, 2], [0, 1, 2], [0, 1, 2]]\n", + "# Creating Multi setup\n", + "msp = MultiSetup_PoSER(ref_ind=ref_ind, single_setups=[ss1, ss2, ss3], names=[\"SSIcov\"])\n", + "\n", + "# Merging results from single setups\n", + "result = msp.merge_results()\n", + "\n", + "# dictionary of merged results\n", + "res_ssicov = dict(result[SSIcov.__name__])\n", + "result[\"SSIcov\"].Fn" + ] + }, + { + "cell_type": "markdown", + "id": "5d47ec2b-caf5-495c-a769-90a46ac2ce96", + "metadata": {}, + "source": [ + "Once the class has been instantiated we can define the \"global\" geometry on it and then plot or animate the mode shapes" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "bd35c95d-0195-4212-abf8-3cc4076098a1", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-01-22 19:59:14,509 - pyoma2.support.utils.sample_data - INFO - Geo1.xlsx already exists locally. (sample_data:49)\n", + "2025-01-22 19:59:14,509 - pyoma2.support.utils.sample_data - INFO - Geo2.xlsx already exists locally. (sample_data:49)\n" + ] + } + ], + "source": [ + "# Geometry 1\n", + "_geo1 = get_sample_data(filename=\"Geo1.xlsx\", folder=\"3SL\")\n", + "# Geometry 2\n", + "_geo2 = get_sample_data(filename=\"Geo2.xlsx\", folder=\"3SL\")\n", + "\n", + "# Define geometry1\n", + "msp.def_geo1_by_file(_geo1)\n", + "\n", + "# Define geometry 2\n", + "msp.def_geo2_by_file(_geo2)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "434ed5f3-692e-4b82-99fe-099a543bde7f", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# define results variable\n", + "algoRes = result[SSIcov.__name__]\n", + "\n", + "# Plot mode 2 (geometry 1)\n", + "_, _ = msp.plot_mode_geo1(\n", + " algo_res=algoRes, mode_nr=2, scaleF=2)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "a92c34ca-28de-4ee8-b50e-619b2736802d", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/dagghe/miniforge3/envs/pyOMA2/lib/python3.10/site-packages/pyvista/jupyter/notebook.py:37: UserWarning: Failed to use notebook backend: \n", + "\n", + "cannot import name 'vtk' from 'trame.widgets' (/Users/dagghe/miniforge3/envs/pyOMA2/lib/python3.10/site-packages/trame/widgets/__init__.py)\n", + "\n", + "Falling back to a static output.\n", + " warnings.warn(\n" + ] + }, + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot mode 1 (geometry 2, pyvista)\n", + "_ = msp.plot_mode_geo2(\n", + " algo_res=algoRes, mode_nr=1, scaleF=3, notebook=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "d49d6d15-5bb8-4f3d-adda-38b1c861ec6d", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot mode 4 (geometry 2, matplotlib)\n", + "_, _ = msp.plot_mode_geo2_mpl(\n", + " algo_res=algoRes, mode_nr=4, view=\"xz\", scaleF=3)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "a3e92989-cf78-4069-b3de-f9e52384bfec", + "metadata": {}, + "outputs": [], + "source": [ + "# Animate mode 5 (geometry 2, pyvista)\n", + "_ = msp.anim_mode_geo2(\n", + " algo_res=algoRes, mode_nr=5, scaleF=3, notebook=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "0635b438-c4df-4416-bd15-52a1b9f09321", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 2.63203919, 2.69132343, 3.4254799 , 8.29357079, 8.42973383,\n", + " 10.60678491, 14.00410737, 14.08557463, 17.42890419])" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-01-22 19:59:15.597 python[66834:51276941] +[IMKClient subclass]: chose IMKClient_Modern\n", + "2025-01-22 19:59:15.597 python[66834:51276941] +[IMKInputSession subclass]: chose IMKInputSession_Modern\n" + ] + } + ], + "source": [ + "algoRes.Fn" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": ".venv", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.4" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Examples/Example4.ipynb b/Examples/Example4.ipynb new file mode 100644 index 0000000..f8cffe3 --- /dev/null +++ b/Examples/Example4.ipynb @@ -0,0 +1,297 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "c7027d59-ced7-40b6-83c9-014057444b73", + "metadata": {}, + "source": [ + "# Example4 - Multisetup with Pre Global Estimation Re-scaling (PreGER) method" + ] + }, + { + "cell_type": "markdown", + "id": "48016108-c0fd-4cc3-ae15-f3e9b72cc81c", + "metadata": {}, + "source": [ + "In this example, we'll be working with a simulated dataset generated from a finite element model of a fictitious three-story, L-shaped building. This model was created using OpenSeesPy, and the corresponding Python script can be found [here](https://github.com/dagghe/pyOMA-test-data/blob/main/test_data/3SL/model.py). \n", + "\n", + "As always, first we import the necessary modules. All the files needed to run this example are available [here](https://github.com/dagghe/pyOMA-test-data/tree/main/test_data/3SL)." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "a302263a-e67f-4420-8491-03ecfbed1677", + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "\n", + "import numpy as np\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "\n", + "from pyoma2.algorithms import SSIdat_MS\n", + "from pyoma2.setup import MultiSetup_PreGER\n", + "from pyoma2.support.utils.sample_data import get_sample_data" + ] + }, + { + "cell_type": "markdown", + "id": "e16c688c-1833-45e8-96ac-5c07498ea323", + "metadata": {}, + "source": [ + "For the **preGER** merging procedure, we adopt a strategy similar to that used for the single setup class. The first step involves instantiating the ```MultiSetup_PreGER``` class and passing the list of datasets, the lists of reference sensors, and their sampling frequency. Similarly to the single setup class, also for the ```MultiSetup_PreGER``` we have access to a wide set of tools to pre-process the data and get more information regarding its quality (e.g. ```decimate_data()```, ```filter_data()```, ```plot_ch_info()``` methods)." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "ba84512c-b8a7-47ec-a2a3-bab2e2aee6f3", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-01-22 20:27:41,885 - pyoma2.support.utils.sample_data - INFO - set1.npy already exists locally. (sample_data:49)\n", + "2025-01-22 20:27:41,889 - pyoma2.support.utils.sample_data - INFO - set2.npy already exists locally. (sample_data:49)\n", + "2025-01-22 20:27:41,891 - pyoma2.support.utils.sample_data - INFO - set3.npy already exists locally. (sample_data:49)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# import data files\n", + "set1 = np.load(get_sample_data(filename=\"set1.npy\", folder=\"3SL\"), allow_pickle=True)\n", + "set2 = np.load(get_sample_data(filename=\"set2.npy\", folder=\"3SL\"), allow_pickle=True)\n", + "set3 = np.load(get_sample_data(filename=\"set3.npy\", folder=\"3SL\"), allow_pickle=True)\n", + "\n", + "# list of datasets and reference indices\n", + "data = [set1, set2, set3]\n", + "ref_ind = [[0, 1, 2], [0, 1, 2], [0, 1, 2]]\n", + "\n", + "# Create multisetup\n", + "msp = MultiSetup_PreGER(fs=100, ref_ind=ref_ind, datasets=data)\n", + "\n", + "# decimate data\n", + "msp.decimate_data(q=2)\n", + "\n", + "# Plot TH, PSD and KDE of the (selected) channels of the (selected) datasets\n", + "_, _ = msp.plot_ch_info(data_idx=[1], ch_idx=[2])" + ] + }, + { + "cell_type": "markdown", + "id": "bec2907d-8df2-40be-8e93-6745d2454c55", + "metadata": {}, + "source": [ + "Again if we want to be able to plot the mode shapes later, then we need to define the geometry of the structure. " + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "7a6f9e34-2705-4940-9afa-985defb7618c", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-01-22 20:27:42,259 - pyoma2.support.utils.sample_data - INFO - Geo1.xlsx already exists locally. (sample_data:49)\n", + "2025-01-22 20:27:42,260 - pyoma2.support.utils.sample_data - INFO - Geo2.xlsx already exists locally. (sample_data:49)\n" + ] + } + ], + "source": [ + "# Geometry 1\n", + "_geo1 = get_sample_data(filename=\"Geo1.xlsx\", folder=\"3SL\")\n", + "# Geometry 2\n", + "_geo2 = get_sample_data(filename=\"Geo2.xlsx\", folder=\"3SL\")\n", + "\n", + "# Define geometry1\n", + "msp.def_geo1_by_file(_geo1)\n", + "# Define geometry 2\n", + "msp.def_geo2_by_file(_geo2)" + ] + }, + { + "cell_type": "markdown", + "id": "93e03054-658f-444e-af18-b9b1220be29c", + "metadata": {}, + "source": [ + "Now we need to instantiate the multi-setup versions of the algorithms we wish to execute, such as SSIdat." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "b51671c7-7df3-48a0-9cc7-54367d7b9d19", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-01-22 20:27:42,357 - pyoma2.setup.base - INFO - Running SSIdat... (base:123)\n", + "2025-01-22 20:27:42,370 - pyoma2.functions.ssi - INFO - Assembling Hankel matrix method: dat... (ssi:82) | 0/3 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Initialise the algorithms\n", + "ssidat = SSIdat_MS(name=\"SSIdat\", br=80, ordmax=80)\n", + "\n", + "# Add algorithms to the class\n", + "msp.add_algorithms(ssidat)\n", + "msp.run_all()\n", + "\n", + "# Plot\n", + "_, _ = ssidat.plot_stab(freqlim=(2,18))" + ] + }, + { + "cell_type": "markdown", + "id": "b3c814f4-0db0-409f-b38c-38a01f082390", + "metadata": {}, + "source": [ + "After the algorithms have been executed we can exctract the desired poles and plot the mode shapes." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "44a282d8-ac3f-42c8-99e0-75c06caeb772", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-01-22 20:28:09,424 - pyoma2.setup.base - INFO - Getting mpe modal parameters from SSIdat (base:149)\n", + "2025-01-22 20:28:09,425 - pyoma2.functions.ssi - INFO - Extracting SSI modal parameters (ssi:887)\n", + "100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 9/9 [00:00<00:00, 10020.90it/s]\n", + "/Users/dagghe/miniforge3/envs/pyOMA2/lib/python3.10/site-packages/pyvista/jupyter/notebook.py:37: UserWarning: Failed to use notebook backend: \n", + "\n", + "cannot import name 'vtk' from 'trame.widgets' (/Users/dagghe/miniforge3/envs/pyOMA2/lib/python3.10/site-packages/trame/widgets/__init__.py)\n", + "\n", + "Falling back to a static output.\n", + " warnings.warn(\n" + ] + }, + { + "data": { + "image/jpeg": "/9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAAgGBgcGBQgHBwcJCQgKDBQNDAsLDBkSEw8UHRofHh0aHBwgJC4nICIsIxwcKDcpLDAxNDQ0Hyc5PTgyPC4zNDL/2wBDAQkJCQwLDBgNDRgyIRwhMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjL/wAARCAMABAADASIAAhEBAxEB/8QAHwAAAQUBAQEBAQEAAAAAAAAAAAECAwQFBgcICQoL/8QAtRAAAgEDAwIEAwUFBAQAAAF9AQIDAAQRBRIhMUEGE1FhByJxFDKBkaEII0KxwRVS0fAkM2JyggkKFhcYGRolJicoKSo0NTY3ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlqc3R1dnd4eXqDhIWGh4iJipKTlJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uHi4+Tl5ufo6erx8vP09fb3+Pn6/8QAHwEAAwEBAQEBAQEBAQAAAAAAAAECAwQFBgcICQoL/8QAtREAAgECBAQDBAcFBAQAAQJ3AAECAxEEBSExBhJBUQdhcRMiMoEIFEKRobHBCSMzUvAVYnLRChYkNOEl8RcYGRomJygpKjU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6goOEhYaHiImKkpOUlZaXmJmaoqOkpaanqKmqsrO0tba3uLm6wsPExcbHyMnK0tPU1dbX2Nna4uPk5ebn6Onq8vP09fb3+Pn6/9oADAMBAAIRAxEAPwD3+iiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKAIL27jsLC4vJQxjgiaVgo5IUEnHvxXD+Dfi/4c8b62dJ0+DULe68ppV+1xoocDGQNrtzzn6A11niP/kWNW/68pv8A0A18raFZ3Hh7wjoXxB05CZtP1Z4LoD+KMhSufY5dSf8AaFAH15RVewvbfU9Ptr+0kElvcxLLE47qwyD+RqxQByHjj4j6J4ASzOqx3cz3Zby47VFZgFxkncy4HIrY8MeIrTxZ4ctNcsI547a6DFEnUBxtYqcgEjqp718++KT/AMLD8S+NPERPmaToFg9vaH+Fn5UEeuT5j/8AfNeufBb/AJJHoX+7N/6PkoA72iuS8afEbw/4FhQanO8l3IN0dnbgNKw9cZAUe5I74zXEH456ikf2uT4fawmndftRZsbfX/V4/wDHqAPZKK5fwb4/0DxzaPLpFwwnjAM1rMNssfuR0I9wSK6gkAEk4A70AFFeXa98cNEsNTbS9CsLzxBeqSCLMfu8jqA2CW+oBHvVK2+PEFpeRweJ/Cuq6GkhwssilwPcgqpx9AT7UAdtceO9LtviBaeDHgvDqN1EZklCL5IAVm5O7OcIe3pXUV4bPfWup/tOeHL2xuI7i1n05njljbKsDDN0r26eeK2gknnlSKGNS7yOwVVUdSSegoAkoryXUPjrYSahJZeF/D+peIJI/vPApRD7jCsxHuQKm0f45aRPqaab4i0q+8PXTkBTdrlBn+8SAV+pGPUigD1SikVldFdGDKwyCDkEUtABRXM+NvHGmeA9Kg1HVILuaGecQKtqiswbaW53MvGFNctrnxq0611N9M8O6Nf+IryL/WizB2KfTcAxJ+gx70Aen0V5Tovx00q41ZNM8R6Pe+HrlyApuuUBPTcSFK/XGPUivU3kVYWlzlQu7juKAH0V5ZL8fPCi+HG1aODUDIZ2gis5ERZZGCqxbhiAvzDknPoDXbeDvEb+LPC9prT2ElgbgviCRtxUK5UHOB1xnp3oA3aKKKACq9/fW2mafcX17MsNtbxmSWRuiqBkmrFeKfE/V7zxz4us/htoEpEe8S6pOvKoBztPsowSO7FR1FAHo3gvxtZeOdNm1DTrHULe1jk8pZLuNEEjd9u1myBxk8dfrjpao6NpFnoGjWmlafEIrW1jEca9/qfUk5JPcmr1ABRRRQAVyHi34meGPBcwt9VvWa8K7ha26eZIB6nsv4kZqx438daX4C023vtUgvJoribyVFqiswbBPO5l44r588GfEXw3pXjfX/E/iPT72+u72bfZNHDHIYFLMT95xg42AYzgAigD6U8M+IbTxX4etdbsYp4ra537EuFCuNrlTkAkdVPfpWtXA33xc0Cw8D6b4tltNSNhqE7QRRrHH5qspcHcN+Mfuz0J7Vna58atOtdTfTPDujX/AIivIv8AWizB2KfTcAxJ+gx70Aen0V5Tovx00q41ZNM8R6Pe+HrlyApuuUBPTcSFK/XGPUivVQQwBBBB5BFAC0UUUAFFFFABRRRQBT1fUodG0a+1S4WRoLO3kuJFjALFUUsQMkDOB6ivLF/aN8IMwUabrmScf6iL/wCO16/Xi37R3/Is6J/1/wD/ALIaAPaayfEfiXSvCmkSanrF0tvbIdo4yzseiqByT/8Ar6VrV4d46tl8Z/HrQfC96WbS7ODz5Yc8MdrO2fqFRfzoAvJ8dLy/3T6L4B1nULEH/j4UkcfRUYfrXVeCfiroPjS5awiWew1VAS1ndABmx12kcHHpwfau2hhit4UhgjSKKNQqIihVUDoAB0FeLfHrR49Ji0jxrpii21a1vUjeWMYLjBZS3qQVx9GxQB7ZRVexuhe6fbXajCzxLIB6bgD/AFqxQAVyM/xE0iPx3F4Pt7a+vNTYAyNbohig4yd7FgRgYJwD1A68UfEbxrB4G8KT6gSrXsv7qziP8chHUj0HU/THcVg/B/wTPoOjza/rIaTXtYPnTvJ9+NGO4Kfcn5m98DtQB6ZXIeN/iRoPgSKNdRkkmvZRuis7cBpGHTJyQFHuevOM4rr68L+GFhD4z+KPivxXqkYuHsrkRWayDcI8lgpA9VVFA+uetAGgfjlqUMX2u7+Huswab1N1lsbfXmML/wCPV6J4S8Z6L410w32j3BcIQssMg2yRE9mH9RkH1roCAQQRkHtXhc1jF4E/aM02PSkEGn65B++t04QFtwIA7fOit+JA4oA9S8X+N9E8Eaat5rFwymQkQwRDdJKR1Cj+pwBxzzXnq/HLUp4vtdt8PdZm03qLoM2NvrxGR/49VC2sYfHf7ReqLqqC4sNDgxDBJyhZdoAI7jczN+Ar3MAAYHAoA5LwV8RdB8dwSHTJZIruEZltJwFkQdM8EgjPcH64qXxl470vwPHYPqcF5KL6Uwx/ZkVsEY67mHHPvXmfxNsYfBfxT8K+KtKQW731wYrxIxhZMMoYkerK5B+gPWrX7Q3/AB7eF/8Ar+b+S0Ae1UUUUAcv4c8d6X4n8Qa1otlBeR3OkSmK4aZFCMQ7L8pDEkZU9QK6ivFfhF/yVX4i/wDX9J/6PlrV1T4/eFdJ1a902fT9Zaa0neCRo4YipZGKkjMgOMj0oA9Vorx//ho7wf8A9A3XP+/EP/x2vSvDXiC08VeHrTW7GOaO2ulZkWdQHGGK8gEjqD3oA1qKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAzPEf8AyLGrf9eU3/oBryX4P6FB4m+CGqaNc4Ed3czxhiM7G2oVb8GAP4V614j/AORY1b/rym/9ANed/s9f8k1k/wCwhL/6ClADPgVrs76Ff+E9Symo6HO0exjz5ZY8e+1gw+hWuk+K/ir/AIRPwBf3UUmy8uR9ltcHkO4PzD6LuP4CuF8Zf8W7+NmleK0/d6XrI+z3xHChuFYn/wAcf3Kml8VH/hYvxw0zw0n7zSdCX7ReY5Vm4ZgfXny09stQBatfC3/CKfs46pbyx7Ly6sXu7nI5DuBhT9F2j6g1u/Cm/i0r4G6dqM+fKtLa6nfH91ZZGP6Ctv4n/wDJMfEX/Xk9cx4AsJdV/Z0j0+AZmutPvYYx/tM8oH6mgDC+Dnh4eLNQ1H4g+IkW7vp7pktFkGVjxjLAH0yFX02n2r3GvJ/2fdUguvh8+nAgXNhdOssZ6gOdyn8csP8AgJr1igDwb4p6Qnw68X6N480CIWyS3PlXsEXypISMngcfOoYH3APWui+OHii5sfB9jpekyN9p12XyVZDgmLA3AfXcg+hNUf2ib1H8M6PokQ8y+vL9ZI4hySFVl/Uuo/OqPxvsZ9GsPBGrbDLDpE4ilxzk4jYfn5TUAel+BfBGm+B9AhsbSFDdMgN1dY+aZ+5z1256DsPfNbmqaVYa3p02n6naRXVpMMPFIuQff2PuORU1pdwX9lBeWsqy288ayRyL0ZSMgj8KmoA+Z/CXhZvB37SNjowdpLeIzvbO3UxNbyMv4jJB9wa7P426nfarqugeAtNlMT6tKr3LD+5u2rn1UEMx/wB0VltrFvq/7Vlh9mZXSziktS69Cy28pb8ixH4VB8adDs734reGJNZlmg0i/gW0kniYKUIkbJyQQMeYhOR0zQB7V4b8Oab4V0WDStLt1igiUAtgbpG7sx7k1V8Y+ENN8aaBPpmoRLuKkwT7QXgfsyn+Y7jivP8A/hnHwf8A9BLXP+/8P/xqkf8AZ08GxozvqmtqijLM1xCAB6n91QBP8Ctdv59H1TwvqrE3ehT+Su48iMlht99rIw+hA7V61XmXwn8NeC9KfUtQ8H6xf6kkm2CdrjGxSPmAH7tcnn3616bQB41+0h/yJGl/9hJf/RcleheBvDFl4T8J2GnWkKK/lK9xIBgyykZZie/PT0GBXnv7SH/IkaX/ANhJf/RclewW3/HrD/uL/KgDjvir4YsvEngHVDcQI11ZW8lzbS4+ZGRS2AfQgYI9/YVQ+EOrz6v8JLJ7ly8tsktsWJ5KoSF/Jdo/Cuu8Vf8AIn63/wBeE/8A6LavPvgR/wAkmk/6+Z/5CgDkv2dvCthejUfEV5bpPPbTLb2u9QRE2NzMP9rlRntz619C143+zf8A8iPqf/YSb/0VHXslABRRRQByPxK8Yr4I8G3OpJtN5IfItEboZWBwT7AAt+GO9eVeC/gZd6zpp1fxPrN/ay6iPNe2tmAkYMd2ZGYEZOc4xx654Gx+0MNkPhW4nUtYR3z+eMZB+6R+gevaUdZI1dGDIwBVlOQR6igDwXX/AAX4k+EVv/wkfhLXLu80u3Yfa7C6+YbM4yQOGHYkAEdfXHsvhfxDa+KvDVjrdmCsV1HuKE5KMDhlP0II/Co/GU1tb+CddkvCotxYTh93QgoRj8en41xPwAimj+GETS52SXczRZ/u5A4/4EGoA9RooooAK8V+A3/Ia8c/9fyf+hTV7VXivwG/5DXjn/r+T/0KagCX9pD/AJEfS/8AsJL/AOi5K9C8DeGLLwn4TsNOtIUV/KV7iQDBllIyzE9+enoMCvPf2kP+RI0v/sJL/wCi5K9gtv8Aj1h/3F/lQBx3xV8MWXiTwDqhuIEa6sreS5tpcfMjIpbAPoQMEe/sKrfBfV59X+F+mPcuXlti9sWJ5Ko2F/Jdo/Cuo8Vf8ifrf/XhP/6LauD/AGfv+SZL/wBfs3/stAHqdcB49vfiRa6pbL4L0u0u7Mw5medowRJuPA3Op6Yrv64Dx7r3xA0nVLaLwj4ftNStHh3TSTqSVfceBiRe2O1AHKf2v8ef+hd0z/v5B/8AHqP7X+PP/Qu6Z/38g/8Aj1H/AAmXxs/6EnTP+/bf/HqP+Ey+Nn/Qk6Z/37b/AOPUAeoeEpten8MWcnia3it9Ybf9oiiKlV+dtuNpI+7tPWtqsXwlea3qHhizuvEVlFZas+/z7eIEKmHYLjLN1UKep61tUAFeL/tHf8izon/X/wD+yGvaK8X/AGjv+RZ0T/r/AP8A2Q0Ae0V4sP8Ak6k/9eH/ALRr2mvFb5hp/wC1NYPOdiXtjiMnof3TKP1QigD2qvKv2g/+SZj/AK/ov5NXqteR/tE3SRfD21tyR5k+oRhV7kBHJP8AL86APSfDf/Ir6R/15Q/+gCtIkKpZiAAMkntVLRbd7TQtPtpBh4raONh6EKAah8TRzzeFNYits/aHsZli29dxQ4x+NAHgs+mar8dfH93eW92bLw7pbeTBPgk4znKDjLtjcT2G3PQZ6m9+AUNvG15oPinV7bVx8yzzyghm9ygDD65P41c/Z5mtn+HEsUJXzo76TzgOuSq4J/DA/CvWaAPLvhR461XV7vUfCnidca9pZOZCMGZAdpJxwSCRyOoYH1NY/wCz993xZ/1/r/7NTLMpdftUXj2RDLBZYuinTIiVefoSg+op3wHYWmteNdKlO24gvgSh68NIp/IgfnQB7VXi3xE/5L14F+i/+jGr2mvFfGzC+/aL8HWcJ3PbwLI4HbBkb+S5/GgBfhz/AMl28d/Vv/Rgr2mvFfAzCw/aI8ZWUx2yXETSxg/xfMjD9Gz+Fe1UAeLfH/8A1vhD/r/b/wBkqP8AaLdo9P8ADUioXZbxyFHViAvFP+OrC71/wRpcR3TzXxIUdeWjUfmSfyo/aG/49vC//X838loAtf8AC3/GH/RJtc/Ob/4xR/wt/wAYf9Em1z85v/jFewUUAeE/Ay8m1Dx744vbi0eznuJvNktpM7oWaWQlDkA5BOOg6dK92xXivwi/5Kr8Rf8Ar+k/9Hy1v/FvxzcaDp8Hh7Q90viLVsRQJF96JGO3d9SeF/E9qAOc8Y39z8VfHcXgfR5mXQ9Pk83VbuPozKeVB74PA9Wyei5r2awsbbTLC3sbKFYba3jEcUa9FUDAFcx8OPA9v4F8Lx2I2yX82Jb2cfxyY6A/3V6D8T3NdfQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQBR1q3lu9B1G2gXfNNbSRouQMsVIAyfeuM+DfhrV/Cngd9O1q0+y3ZvJJRH5iP8pCgHKkjsa9BooA434oeEW8Z+BrzTreNXv4iLi0yQMyL2yeBkFl545rD+DPgPUPCOkX95rsPl6xfzfvA0iyFY16ZZSRkksTz6elenUUAc7470y81nwLrOm6fD513c2rRxR7gu5j2ySAPxNU/hhouoeHfh1pOlarb/Z723Evmxb1fbmV2HKkg8EdDXXUUAePeJvh54j8OeLJvF/w8liE9wS13pkhASUk5OMkAgnnGQQeh7Bh+J/xF8v7MPhleC96eaRJ5WfXG3GP+BfjXslFAHkXg74d6/qni1PGvj+aN9RjwbSxQgrBj7pOOBt6gAnnknNeleIdBsPE+hXWj6lF5lrcptbHBU9QwPYg4IrTooA8N0+x+JnwqL6fp1gvibw+rEwqmfMjBPQAfMvuMMvpVi78YfFTxdGdM0bwfN4fE3yyXt2WUxqeCVZlXH4An0r2qigDwfwv8LtT8IfGDQbi3t57rToLV2u9QbG1pmilB4zkDJUD8PevVPG/gzT/HPh2TSr4mNwfMt7hRloZB0IHcc4I7g/Q10lFAHidjrXxV8AQrpeoeHD4msYRsgurVmaQqOgJUFv8Avpc+5qLULr4o/EyI6Suif8Ixo83y3Ms+4SMndecMQR2CjPQnBr3GigDF8KeGNP8AB/h630fTVIiiGXkb70rn7zt7n9OB2raoooA8z+NnhTW/F3hWwstCsvtdxFeiV081I8LscZy5A6kV6RApS3jVhghQCPwqSigDO8QWs194b1S0t03zz2ksUa5A3MyEAZPA5Ncd8JvDOr+Gfh4+l6xafZr0zyuIvMR+GAxypI/WvQqKAPNPgn4U1vwj4Vv7LXbL7JcS3xlRPNSTK7EGcoSOoNeganFLPpN5DACZpIHVADjLFSBz9at0UAef/B7w/r3hvwbPZeIoXhvWvXkVXnWU7CqAHKsR1B4zXoFFFAGD4x8KWPjPw1c6NfEosmGilUZMUg+6w/w7gkd68u0rVfif8N7ZdGvPDT+JdNtxstbi0Zi4QdBlQxwOwZcjpnGK9vooA8M1S2+IvxaMWmX2j/8ACM+Ht4e487PmSYOQMHDN6gYAz1PSvZdH0mz0HR7TSrCPy7W1jEca9Tgdz6k9SfU1eooA8aW4n+IPx2McM0n9h+GF+cIxCyTg9Djr84/ERn1r2WqWnaNpeked/Zum2dl5zbpfs0Cx7z6ttAyee9XaACvMPhJ4S1zwxqniubWLH7NHf3aSWx81H3qGkJPyscfeHXHWvT6KAPM/jZ4U1vxd4VsLLQrL7XcRXoldPNSPC7HGcuQOpFekQKUt41YYIUAj8KkooAzvEFrNfeG9UtLdN889pLFGuQNzMhAGTwOTXJfB7w3q3hbwKNN1q0+y3f2qSTy/MR/lOMHKkjt6131FABRRRQAUUUUAFFFFABXmPxq8Ja54t0PSrbQ7L7XLBeebIvmpHtXaRnLkZ5r06igArz74n/D2bxhb2epaRci01/TW32sxJUOM52kjoQRkHsc+uR6DRQB41B8RviXpMIs9X+HV1f3ifKbi0LbGPqdiuv5ED6VW07wh4x+I/i2x17xxappuk2DB7bTR1c5BwVySASBuLcnGAAOnt1FAHPeOtPv9V8D6xYaWjPfT25SFVcIS3H8RIA/Oq3w30rU9E+H+ladrMbR6hCsgmRpBIQTIxHzAkHgjvXVUUAeLan4J8WfD7xVd+IfAMUd7pt6d11pTnGOc4AyMgEnBByM4wR1kn+IvxL1eE2Ok/Du60+9cbftN1uKIfUb1VfzJH1r2WigDz/4Y/Dt/Bttd6hqlyLzXtRbfdTgkhRnO0E8nk5J7nHpWF4x8B+JNG8Zt438BmN7yUYvbByAJvUjJAIOASMg5GRz09dooA8cf4ofESSL7ND8MrxL0jAmk8wxZ9cbBx/wKtD4b+ANatPEN54z8YzLJr12pWOFWDCBTgHJHGcAKAOAPXPHqdFAHl/xH+H2rahrtn4w8ITrB4hswA0bMFFwo4HJ4zgkEHgjjjHOYPif8RbeH7Nc/DO8lvQMGaHzPKJ9cBWGP+BV7HRQB494P8D+J9e8bp448diOGeAf6Fp6EHy+u0kAnaBkkDJJPJ6c6Xxk8Ja54rg0FdFsftRtbtpJv3qJtXA5+Zhnp2r0+igAooooA8v8Ahz4S1zQfiB401TUrHyLPUrt5LSTzUbzFMrsDhWJHDDqB1rhofDPxW0/4g3/iuPwxZajeyu4hkvLmJliQnAKATLj5eBnsTX0TRQB4/wD8JD8c/wDoTND/AO/y/wDyRXoHg678TXuh+b4s062sNT81h5NswZdnGDw789e9dBRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUU15FjXLE8nAABJP0ApNpasLXHVn2Op/bZmj8nZhd2d2e49verWxpeZeF7Rj+p7/Tp9ab5EcDebDEqnGGCr1Gf8/X8q5qvtnOMoO0Vuur/AMjSPIk09yxRSAhgCCCDyCKWuozCiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACimySLEhdzhR/n8TUOJLn7waOHqAGIdvr/d+nX1xyKTfQaV9Rxn3sUgAdgcM38KH39/YfjjOadHCqNuJLyEYLtjOPTjtT1UKoVQAoGAAOAKWko9WNvogoooqiSJP3Unl/wNynt7f1H4+lS010EibTkdCCOxHIpsTl1IbAdeHA6Zx2qI+6+Xp0/wAv6/Qp6q5JRRRVkhRUbTIrFRlmH8KjOPr6fjSYlfq3ljsFwT+JPH+etAEVtqNpeSGOCXewG4jaRx+Iq1WXpmkwWFzPJE8rHOz52B4wp9K1KACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAoopHdY0Z3YKqjJYnAAoAWoJLkCQxQr5sw6qrD5PQsew/X0BxTPMlu/8AUN5cB6TDBZv90EEY9z17DkGrEcaRRhEGFHvn8Se596W5VlHcijt/nEs5WSYdG24C/wC6Oce/PP5AT0UUJWE23uFFFFMQUUUjMqKWZgoHcnFAC1FKCrCZQSRwwHcZ/mOv5+tHmM/+qXI/vtwPw9f5e9Hk7/8AWtv/ANnGF/L/ABzSkrqw07AJ1cDyf3ue6n5fz/yaPLd/9ZIQP7qcD8+v8qRP3MvlfwNynt/s/wBR+PpU1KLugasIqqihVUKB2AxS0UVQiKL78x7F+D+AFS1FB/qz/vv/AOhGpaACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiqX2prz5bI5iPW6BBQeoX+8ffG0c9SCtA0rk89ykG0EO8j52RouWb/Acjk4AyMkVGltJK6y3bhmU5WNMhF78/3jnufQEAGpILWK33MozI+PMlbG5z6k/wCQOgwKmoHe2wUUUUEhRRTHlVDt5LdlHJ/z70APpruqDLEDsPemfvn64jHty3+A/WnJEiHKqN3QseSfx60AN3Sv9xAo/vP1/L/64pViUMGYl3H8Tdvp6fhUlFABRRRQA2RBIm05HIII7EHINNhkLoQ+BIp2uB0zjPHtzUlQygo4mQEkDDKO65/mOv5jvUS0fMUtdCaikVgyhlIIIyCO9LVkkUH+rP8Avv8A+hGpait+bdG7sNx+p5/rUtABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFRXFzFaxh5S2CdqhVLMx9AoBJ4BPHYE9qhmu5Gma2tI/MlHDyH/Vwk8jdyCTjnaOemdoINOt7MRSGeV2luWGGkJOB6hVzhRwOB1wMknmnbuVZLVkX2eW+5vE8uH+G3WQnd/wBdCODxxt5Xrktxi9RRSE3cKKQkKCSQAOSTUfmlv9UhYf3jwv8Aj+QoES1GZhkhFaQjrt7fj0/Ck8kt/rXLew4X8u/45qQAKAAAAOABQBHskf8A1jbR/dQ/16/linoiRjCKqjrgDFOooAKKKKACiiigAooooAKKKKAIF/cTbP8AlnISU9m5JH9fz9qnpksYljZGJAI6jqPce9NilyrCTCun3uwx2P0P/wBbtULR2KequFt/x6w/7g/lUtR24K20QIIIQAg/SpKskKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKqXV8IZRbwxtNdMMrGoOB6F2wQi8Hk9cHAJGKaTew0rk89xDawtNcTRwxLjc8jBVHOOSap4utQ5JktLQ8qFOJZR/tZH7sdenzcjlCCKfBYsJlubyb7RcrnaVBWNOMfKmSAcE/McnkjOOBdp3S2HdLYjgghtoVhgiSKJfupGoVR34AqSmPKiHBJ3dcAEn8hTf3sn/TJfwLf4D9fwqSR7uqDLEDsPemb5H/ANWu0f3nH9Ov54pyRKh3clu7Hk/59qfQBGIVyGYs7DnLHP6dBUlFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABVS+UrbyTIPmVG3Afxrg8fXuPy4yat1Fc/8es3+4f5UmrjTsSKwZQykFSMgjoaWq6/6PP5f/LOUkp7NyWH49fz9hVihO4NWCiiimIKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACio554raFppm2ouOxJJJwAAOSScAAcknFUTFJqQMlyXhse1uwAMq+smRkA/3OOPvZyVDSvqxpdTifiK/iLVILG48LyX0drBv+03EM/kIwYptIJZdygZO/lQDnPXHa+HrKSw0CxiuIgl4YI2ujkFnm2gOzMPvMSOWyc+tWrhYr22ltjH50UqGN/mKqVIwRke2en6VW0l5rzSraS7lMk4Ty5wBtHmr8rg46/MGHHB7VvOq5UlBLRfeaSneCjbYTWNUOn2okgCSPv2suM44PoeDxUunzTX1jHPMwQvnKxjA6kdTz27YqzcALaSgAACMgAfSpa5zIaiKgwoA7n3p1FFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFRXHMJXsxCn6E4/rUtRT/AOrH++n/AKEKAHSxiaJo2JAYdR1B9R7imwylwySACVDhgO47Eex/+t2qWoLhWQi4jBLIPmVRy688fXuPy4yal6alLXQnopFZXUMpDKRkEHIIpaokKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAoopryJHjceT0A5J+goAdVa8vY7NVBR5ZXzsiQjcwHU8kAAZHJIHIHUgGCe6u5pmt7KOIOv+sklbIiz7Dq3OduenUjIzPbWENsxkG+WZvvTStuc/j2HJ+UYAycAZqrW1ZVrasrwWsssy3dx81wM7dzN5cXGMInGTjI3kAnJ6A7RdEIJDSEuw5Geg+g/wAmpKKTdxN3Cs3Tv9H1DULH+EOLmMDoqyZyM9c+Ysh+jDHoNKs26/ca7YT9FuEktmC9WbHmIT6gBJPoX46mqjrdDXYu3P8Ax6zf7h/lUtRXP/HrN/uH+VS1BIUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAVFP9xR3LrgfiDUtUb3ULW0uIEnl2NndjaTxhh2FAF6iiigCsv+jTFTxDIcqf7rknIPsSePfI9BVmmyRrKhRxlT/n8DUVvIxDRSnMsWAx6buOGA9D/MEdqlaaFPVXJ6KKKokKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooqLzg3+qUyf7Q+7+f8AhmgCWo2lUMVUF3H8K9vr6fjSeWz8yOf91CQB+PU/54pJp7eyiBkZIkJ2qP7x9FA6k+g5NAJX2F2yv99gg9EOSfx/z9appvvci2Ais2+9OrESSj/Z9Af7+c9cDkNT/ssl9zfohgPK2pXI/wCBnJDH26A/3sA1ep7FaR9SOGCG2hWGCJIol6JGoUDv0FSUUUiQooooAKzdf+XRLifr9m23W3+95TCTb7Z24z2z3rSopxdmmNOzuRXP/HrN/uH+VS1maGAulLZsB/ojva7W67EJVNw9Sm1vfdkcEVftyWtoiSSSgJJ+lElZ2BqzJKKKKQgooooAKKKKACiiigAooooAKKKKACiiigAooooAKKi87f8A6pd/+1nC/n/hmjyd/wDrW3/7OML+X+OaADzGf/VLkf324H4ev8ves6/0eG9uoJZ5ZS+dvykAAYY8DFa1RPzcRL2AZvx4H9TQBLRRRQAVBcRtlJohmWPjH95SRuH1449wO2anopNXGnZ3GxyLLEkiHKOoZT6g06sfUtXt9BmTz0keK5LMBGB8jDGepHBzn6565407adbm1iuEBCSoHUN1wRnmkpJvl6lypyjFTto9iWiiiqMwooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACimvIkeNx5PQDkn6CmbpJPujYv95up+g7fj+VAEjMqKWZgoHcnFR+Y7/6uMgf3n4H5df5UqxKGDMS7j+Ju309PwqSgCLyQ3MpLn0P3fy6fnUtFVHuGuHaC1JGDiSbb8qeoXPDN1HcDBz0wQaVx890InEMaGW4YZVADge7NjCjg8nrg4BPFEFsySGa4kEtwRt3BdqqvooycdATyST7AAPggW3QqpLMx3O7fedvU/wCcAAAYAFS0DbtogooooJCiiigAooooAKKKKAM2H/R/EF1F91LqFJ0HXc6/JIfbC+SMdPTvV22/49Yf9wfyqlqf+j3NhfDjy5hBJjqUlIXAHT/WeUSeuFP0N22/49Yf9wfyq5apMb7ktFFFQIKKKKACiiigAooooAKKKKACiiigAoqLzt/+qXf/ALWcL+f+GaPJ3/61t/8As4wv5f45oAPO3/6pd/8AtZwv5/4Zo8nf/rW3/wCzjC/l/jmpaKACiiigAqJv+PqP/cb+a1LVGS/gF2FiYzyIrKyQjeVbIwGxwvQ/ewOD6UDSb2L1IzKiM7sFVRkknAAqrm9uOQFtU/2gHkP5Hap9PvfTtTksYg6vK0k8gOQ0rZAI6EL90EeoA/nSHypbsT7fG/8Ax7xy3PvEvykezHCn8Dn8jRsvJv8AWSrbgdofnJ/4Ewxj2x+ParVFFg5ktkY+q6LYT2jTTQtK0ALgvK5JAwSuc5wcY9s5rVhiSCGOGNdscahVGc4AGBRNEs8EkLEhZFKnHXBGKbaytPaQysAGeNWIHTJGalRSloi5TlKCTexLRRRVmQUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUVF56txF+8Pqp4H1P+TR5cj/6x8D+6nH69fyxQArTIrFRlmH8KjOPr6fjSYlfq3ljsFwT+JPH+etSKqooVVCgdgMUtADUjSPO0cnqTyT9TTqKKACkd1jRndgqqMlicAD1pk0ywICQWYnaqL1Y+g/zx1PAqFYGndZrkEYOUh3cL6FscM3Q9wMDHTJCkurG/vr3/AJ620H4B5P6qMfRv93HNpEWNFRFCoowqqMAD0FOooE3cKKKKBBRRRQAUUUUAFFFFABRRRQBU1S1e90q6toiqzPEwiduAkmPlbPUENg5HIxml02dLrS7S4QEJLAjqG6gFQeatVkeHv3drdWvXyLl/m/veYBN07Y83b+Ge+Ba1j6f1/kPoa9FFFQIKKKKACiiigAooooAKKjMwJKxguw4OOg+p/wAmk8tn/wBa2R/cXgfj6/y9qAFMwJKxguw4OOg+p/yaTyjJzNhv9kfdH+P+elSABQAAABwAKWgAooqK4ure0jElzPFChO0NI4UE+mTQCV9iWiqP225m/wCPWxcr1Elw3kqR9MF8/VR9emV+x3M3/H1euV6FLdfKUj65LZ+jD6dcuxXLbdks99bWziOSUeaRkRL8zsPUKOT36Dsaj869uP8AUQJDGeklxnd9dg7H3ZSO445ngtoLVClvBHChOSsaBRn14qWkF4rZFP8As8S83kz3I/55uAIx/wABHUem7djHXvU0aLHOyIoVFjQKoGABluKmqJf+PqT/AHF/m1AnJvclooooEFFFFABVey4tQvZHdFHoqsQB+QFWKr23Et0o6CXgemVUn9ST+NS90UvhaLFFFFUSFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFNd1QZYgdh70AOpGZUUszBQO5OKj3Sv9xAo/vP1/L/AOuKVYlDBmJdx/E3b6en4UAJ5jP/AKpcj++3A/D1/l70eTv/ANa2/wD2cYX8v8c1LRQAUUUUAFFFFABUE07K4ihQSTEZ2ltoUepODj245/AkM897ni1ZfK6GcHI/4D2Y+/Qe+CKmhgigQrEgUE5OOrH1J7n3NK99ircu4yG2WNzK+JLhhhpSMHHoPRfb+Zyanoopibb3CiiigQUUUUAFFFFABRRRQAUUUUAFFFFABWRH/o+vxv0W7hkjYt03RyFkUe5Ekpx3CcdDWvWRqf7mxiv/APnxuTO2egTLLISOpxG7kAc5A69DcN7dxrc16KKKgQUUUUAFFRtKAxRfmf0Hb6+lJ5bP/rWyP7i8D8fX+XtQApmBJWMF2HBx0H1P+TSeWz/61sj+4vA/H1/l7VIAFAAAAHAApaAEACgAAADgAUtUZNVg8xordJbuVSVK26bgGHVS5wikehYH8xluNSu+GMdjEefkIklI7dRtUjv98HJwRjNVyvqVyvqXpJEijaSR1RFBZmY4AA6kmqX9p+dxZWs9znpJt8uP2O5sblPqgbj6jKx6TaLIssqNczKQyyXDGQq3qoPCc/3QBwPQVeo0Qe6vMoeRf3P/AB83CQRnrFbZLfQyHsfZVI7HjJmt7C1tZDJFCvmkYaViWkYehc5Y9B1PYelWaKV2Dk9gooopEhRRRQAVFHzNM3cEL+GM/wBTUtRRf6yf/fH/AKCKAJaKKKACiiigAqAfLfvn+OJdvvtJz/6EPzqeoJPlu4HPQhk/E4P/ALKaifR/12Kj1RPRRRVkhRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFAGDHd6mdbaF/OW0DN8whzxzt5x7VtRJFjfHtOeN+ck/jSHi6T3Rs++CMfzP50rR5YsjFG9uh+o/yaAJKKjEuCFlUITwDnIP0NSUAFFFFABRRSMyopZmCqBkknAAoASSRIkLyOqIOrMcAVBse65k+W3P8AyzK4Z/8Ae9Af7uPr3Fc/aaJdwa82rvsMBlkcRjPmbWyAcY9846/jxXUKyuoZWDKRkEHIIrKEnP4lY3qwjTtyu/6eQtFFFamAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFVjbxXdjPbTrvhm8yN1yRlSSCMj2qzUUH+rP++//oRo2AraPcS3OlwtO2+4TdDM+AA0iMUcjHYspI6cY4HSr1ZVjILbVdTswGYl0uURB8qq64I9AS6SMfXdnkk1obJH/wBY20f3UP8AXr+WKqfxDe4rSqGKqC7j+Fe319PxpNkj/wCsbaP7qH+vX8sVFc31lpyos88UJfPlx5+aQjsqjljyOACeR61X+23t3/x42WyI8efebo/xWPG445yG2Z4wcHIFFvUEmaKqqKFVQoHYDFU59WsbedoGn8y4XG6GBGlkUYzkogLAcjkjHI9RUX9mT3HN9qNxJ38u3Jt0B9RtO/p2LkZPTpi9BbwWsKw28McMS52pGoVRk54A96LRXmPRFLztUuv9Tbx2Kjq11iVifQIjYx77s8Ebe9H9jwy/8fs1xff7Nww2EehjUBDzzkqT78DGjRRzvpoHM+mg2ONIo1jjRUjQBVVRgKB0AFOooqSQooooAKKKKACiiigAooooAKii+/Mexfg/gBUtRQf6s/77/wDoRoAlooooAKKKKACobjjypP7kg49c/L/7Nn8KmqG6/wCPaRu6DePqOR/KoqfA2VH4kTUUUVZIUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQBFLxLCe+4j8Np/wABUtRT/cU9w64P4gVLQAhAYEEAg8EGo9rxf6v5l/uE4x9P8D+lS0UANSRXyBww6qeo+tOprxq+CeGHRh1H0pm54/vguv8AeUcj6j/D9KAJarTf6ROIBzEvM3oeOEP1zk+wweGp804iiVlAdnIVFB+8T/TufYE0tvD5MQUtvc8u+MF27n/PTp2pPXQpaK5LVdoWhYywAnJy8WeG+meAe/oe/qLFFDVxJ2GxyLKgdDlT+H4exp1QSRtG5mhGWP306b/f2b+fQ9iJIpVlUkAgg4ZT1U+hoT6MbXVD6KKKZIUUUUAFFFFABRRRQAUUUUAFFFFABRTHlVDt5LdlHJ/z71myavC8rw27NdTIxVoLQh3UjqHbIWM9eGIzg4JPFNRb2Glcu3c7JbzCHc84QlVQZIOOP8msfS7u4S2updXn+zQRsPmlxEoyT1bj1H51dWPVLlQv7rTYOo8oiWYjqOo2IR34cHJwRjJWz0q2hupLhxJcXKP8s07l2UlRkrnhM55CgDoMYAArlS3YWXU818d/ES88PeKbIaNb2ssIsm2tPDIFbe+SVOVDL+6XBGQcnk16V9j1G65u9Q8lD/yxs028HqrO2WPoGXYep44wat8lxpU7cRRXg3t6b43jX83dR+Oema0q2qVYuEVCNrddy5SVlZFa00+zsd5tbeOJpMeY4HzSEd2bqx5PJJPJqzRRXO23qzMKKKKQBRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABUUH+rP++/8A6EaWeeO2haaZtqL1OCfaodPuYbu182F9yliTwRgnnHP1oAtUUUUAFFFFABSOodGRhlWGCKWihq+jAjgYvbxMxyzICT74qSooOEYdw7ZH4k1LUU3eCuOW7CiiirEFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQBFc/wDHtKe4UkexqWkIDAggEHgg0y3Ja2iJJJKAkn6UASUUUUAFFFVLn/SZPsQ+6VzP/uHIAHuSMfQHocUDSuxlvF58pvkYIGGIRjgocEsR6kjPXoB7irSyZYK6lG9+h+h/yakpGVXUqyhgexGaEDd2LRUW2SP7nzr/AHWPP4H/AB/Ono6uMrn0ORgj8KBDqhliYsJYiBKBjno49D/Q9vzBmooaGnYjilWZSQCCDhlbqp9DUlQy24dhIjGOYDAYdD7Edx1/M4weaWGbzNysuyVfvpnOPceoPY/1BFK/cbS3RLRRRTJCiiigAoopskiQxPLK6pGgLMzHAUDqSewoAdRWU+tecdmnWsl055DsDFFjsd5HzA84Khh0yQCDQLLUb3nULwQxHn7PZ5Q+uGkzuOPVdmec8HFVy230Hy9y1eala2GxZ5D5r58uGNS8j467UGSfwHFU/tOq3/Fta/Yojz511ySOxCKc89wxQjI68ir1pp9pY7zbW8cbSY8xwPmkI7s3VjyeSSeTVmi6WyC6Rlpokco/4mE8l6DyYZAFhz3+QD5h0xvLkYHOck6UcaQxJFEipGihVRRgKB0AHYU6ik5N7g22FRRf6yf/AHx/6CKlqKL/AFk/++P/AEEUhFLXf+QfF/1+Wv8A6PjrSrN8QfLoN5OPvWyfaUHYtERIoPtlRn29K0qt/Avn+g+gUUUVAgooooAKKKKACiiigAooooAKKKKACiimu6oMtn0GBkn8KAHUx5Ap2jLP12jrTf3knUeWncZ+Y/l0/X8KeiKgwoA7n3oAr3Nn9ut2huGKo2PljPvnr36elM0qyjsbBI4ixVgHO7HXA/wq7UVt/wAesP8AuD+VAEtFFFABRRRQAUUUUARx8Syg9SQ34YA/oakqPpcH/aUY/A//AF6krOns15v8xsKKKK0EFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAVFb/6rHYMwHsNxqWoovvzDsH4H4A0AS0UUUAQ3M/2eEsF3yHiOPOC7dh/9fsMnoKLeDyIyC292Yu74xuJ/oOg9AAO1Q2/+lzfazzEPlgU/Ugv/wAC7deOc/MRVygp6LlCiiigkKY8Sud3Ibsw4P8An2p9FAEXmNH/AK0DH99QcfiO3+elSAhgCCCDyCKWozGVJaMkHqVJ+U/4fh+tAElRTQ+ZtZW2Sp9x8Zx7H1B7j+RAIVZQWCN8r+h7/T1qSgadiGKcu5jkjMUoGdpIIYeqnuPyPTIGRU1U9QurK3RFurlIZGJMI3fvGYf3B1Y84wAc5xg5xVWPUNRuWEMNisLlc+bdNsDLnAdUGWPqVYoRkDPOaaiyuW6ujWqhJrNksrwwu11OhKtFbKZCrdNrEcIc8fMQODzwaifTUkwdRvbi6Lf8sg2yP/aGxMbl9nL8fU5uxxssSRRItvEgCqqgZAHQAdAPz/Cn7q8xaIpPJqk2Nxt7CNugGZ5mB9BwqsP+2gz7Dkj0W2eVJrhHmlUhle5bzHVv7y5yseT2QDoOmABpJGkedo5PUnkn6mnUc76aBzPoNRFQYUAdz706iipJCiiigAooooAKii/1k/8Avj/0EVLUUfE0wPUsG/DAH9DQBS8Rf8izqv8A15zf+gGtKis3w7/yLOlf9ecP/oAq94en6/8ADD6GlRRRUCCiiigAooooAKKKKACiiigApCQoJJAA5JNR+bv4iG7/AG/4R/j+H6UohBIaQl2HIz0H0H+TQAm95OEUqv8AeYYP4D/H9ackSod3Jbux5P8An2p9FABRRRQBFc/8es3+4f5VLUVz/wAes3+4f5VLQAUUUUAFFFISACSQAOpNAC0VH5yt9wNJ7qOPzPFIxcLl2VB/s8n/AD+FZurHpr/XfYdmNmnjhmTe2Dg8YPQ9/wBKnqq1msx3yFw2Omf8/pVqsMM67nN1UlFtW7/P8Bu3QKKKK6yQooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACol/4+pP8AcX+bVLUTf8fUf+4381oAlqpdO0sq2cTFWYb5HU/cQEcccgtyB06MQcipridbaEyuCeQoVerMSAAPqSBzxTLOBoYi0pBuJTvmK9C+AOPYAAD2HPOTQVHT3iZEWNFRFCoowqqMAD0FOoooJCiiigAooqnPqdtDM0C+ZPcL1igQuyk9A2OEz2LED3wDTSb2Gk3sXKbJIkUbSSOqRoCzMxwFA6kmqH/E1uf+eFjGf+20pB/JUYf8DGfUDl0ej2ayLNMjXU6kMstyxkKt1yoPCc8/KAOBxwKdkt2OyW7GNqYuVK2VnPdA9JNvlxj0be2Ny99yBuOfTLPsepSj/Sb5hGesNqApAP8ACXbJb03DYep64xpu6oMtn0GBkn8KZ+9k/wCmS/gW/wAB+v4Uc1tkHNbYr2tvp9iGNtFHG8n32VcySEf3j95jyck5PJzUs0LXSBXBjUHIKthwfYjp+vBp/wBnjB3KCr/3xyx+pPX8aPNKf64BR/fB+X/63+ealu+4ru9yKD/R5PJl5dvuSnrJjsf9oen4juBapkkaTRlHGVPvj8Qex96hWZ4XEVwCQThZ+MNnoD6H8MHjoTilsO3NsWaKKKZIUUUUAFFFFABRRRQAVEv/AB9Sf7i/zapaiX/j6k/3F/m1AEtZvh/5dBtID962T7M57FoiY2I9sqce3pWlWbof/IPl/wCvy6/9HyVa+B/L9R9DSoooqBBRRRQAUUUUAFFNeRI8bjyegHJP0FM2ySfeOxf7q9T9T2/D86AFaVQxVQXcfwr2+vp+NJ5bP/rWyP7i8D8fX+XtUiqqKFVQoHYDFLQAUUUUAFFFFABRRSMyopZiFUDJJOABQBHccwMv9/CfTJx/Wpapz3aPGPJV5vnXlB8p+YdGOAfwNS7bmT7zpEPRPmP5nj9DU866alcr66EzMFUsxAAGST2qL7Srf6pXl90HH5ng/nQttEGDMDI4OQ0h3YPqPT8MVNS95+Qe6iLE7/eZIx6J8x/M/wCFKIEBDMC7DnLnOD7en4VJTJZVhUEgkk4VR1Y+go5I7vULt6IV3WNCzHAFNRWZhJIMH+Ff7v8A9f8Az9WxwkuJZjuk7AE7V+g/r15PQcVNTtfVg7LRBRRRVEhRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABUUv8ArIP98/8AoJqWs/U5GlVbKFmDysvmOhw0KE/e9iSMD3yedpoQ0rsfB/pl41yf9VAzRRDszdGf6ghlH/Auobi7TURI41jjVVRQAqqMAAdgKJJEijaSR1REBZmY4AA6kmmDd3oOorP/ALUWfiwge8HTzUIEQPb5z1HXOzcRg8Z4o+zX11zdXX2dP+eNqeo7gyMMn6qEIyeTwafL3Hy99CxdX1rZbBcTxxs+diE/M5HZV6seRwMnkVX+2Xl1/wAeVpsjPHnXeY/xEeNxxzw2zPGDg5Fi1sbez3mGPDvjfIzFnfHTcxyTjPGTxVii6WwXitjP/sxrj5tQuZLg/wDPNCYosdxsB+YHjIcsOuMA4q5Bbw2sKw28UcUS/dSNQqjvwBTndUGWIHYe9M3SSfdGxf7zdT9B2/H8qTk2JybHu6oMsQOw96Zukk+6Ni/3m6n6Dt+P5U5IlQ7uS3djyf8APtT6QhiRKh3clu7Hk/59qfRRQAUUUUAReUU/1JCj+4R8v/1v88Uu5Jg0TqMkYaN8HI+ncVJTXRXGGAPce1AECs1s6xysWiY4jkJyQeysf5Hv0PON1moWVgjJIPOjYYIKjOO+R3H+eahVvsiht7PanqzsS0R9yeSv15H0+6tivi9S5RRRTJCiiigAooooAKiX/j6k/wBxf5tUtRL/AMfUn+4v82oAlrN0r5LjVIF4iivDsX03xpI35s7H8cdMVpVm6d8upaujcMblJAD1KmGNQ30yrDPqp9KuOzKWzNKiiioJCiiovNL/AOpAYf3yfl/+v/nmgCRmVFLMwUDuTio90kn3RsX+83U/Qdvx/KlWIBg7fM/qe309KkoAakapkjlj1Y9T9adRRQAUUUUAFFVP7Sgk4tt10e3kDcv03fdB9iR+oo/06b/nlbIf+2j4/QKR/wACH5cq5XI+uhbqr9ujf/j3SS494x8pHsxwp/A/1o/s+F+bjdcnv5x3D67fug+4H8zVqjUPdXn/AF/XYrbbyX77xwL3Efzt9QxAA+m0/wCDls4QwdwZXByGlO4g+ozwv4YqeilyrqHO+mhFP/qx/vp/6EKlqKX/AFkH++f/AEE1LVEhRRUVxcJboGYFmY7URfvO3oP84ABJwATQCVxZplgQFgWZjtRF6sfQf545J4FNhhYMZpiDMRjjog/uj+p7/kA2CBw5nnIadhj5fuxj+6v9T1J9AABYoKbtogooooJCiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigDP1LXNN0lH+2XtvFIsZkELSqruOfugkZzgge9VnuYbWK5SVjcX8ikyrAhkKZyUQkDCgA4BbaDy3c1z3jXwX/AMJFrWn3P2/7PvH2bb5O/GFkfd94fTFdfYNCsJto7dLZ4fvQIAAuc8rgDKnnBx65wQQNWoKKad31OiUacaacXdvcjzqV1yoSxiPHzgSSkd+h2qR2++DkZA6UselW3mLNcBrudSGWW4wxUjoVGAqdvugZwM5NWbb/AI9Yf9wfyqWo5n0MeZ9NAopGZUUszBQO5OKj3yP/AKtdo/vOP6dfzxUkj3dUGWIHYe9M3SSfdGxf7zdT9B2/H8qckSod3Jbux5P+fan0AMSJUO7kt3Y8n/PtT6KKACiiigAooooAKKKKACiiigAqNogWLr8r+o7/AF9akooA5u01a5h1d7HyVa2V2AEancgGegz046dR0GeAOjVldFdGDKwyCDkEVH0uh/tIc/geP/QjUbq1q7SxKWiY5kjUZIPdlH8x36jnIZbFfF6lmikVldFdGDKwyGByCKWmSFFFFABUQ4umz/Egx+BOf5ipaib/AI+o/wDcb+a0AS1mwf8AIy33/Xnb/wDoc1aVZbt9m8SZwz/a7TAAH3fKf+vne2Nvvxcdmil1NSo2kwxVFLt7dB9T/k0m15Pvkov91Tyfqf8AD9akVVRQqqFA7AYqCSPyjJzNhv8AZH3R/j/npUtFFABRVD+17WXi033rdvsy71z6F/uA45wWB6eoyv8AxMrj/njZxn/trIQfyVWH/Axn6cvlfUrkfXQvVS/tS3k4td923b7ONy/Tf90HvgkfqKT+yraTm633jd/tB3Ln12fcB7ZAH6mr1Gge6vP+v67FP/iYT/8APG1Q/wDbRyD+SqR/wIZ+nJ/ZsD83O+6bv553L9dn3QfcAfqauUUg5300CiiigkKKKKACiiigCKX/AFkH++f/AEE1LUT8zxL6Zf8AIY/9m/So7u7+z7I40825lz5UQOM46knsoyMn3AGSQC0r6IBbq8W22II5JpnzshixuYDqeSAAMjkkDkDqQCltbuJDcXJVrlhj5eVjX+6v6ZPUkdgAAWlp9n3ySP5tzLjzZcYzjoAOyjJwPck5JJNmm2loir20QUUUVJIUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFAFG//wCPzS/+vpv/AETJU9zbedtkjfy548+XJjOM9QR3U4GR7A8EAiC//wCPzTP+vlv/AETJV6nfYtuyX9dzO07Ure4ikQyxLNG7eYgkBx8x5B7qex/kcgXN8j/6tdo/vOP6dfzxWFa+HjbXctwl1J5inarIArLkLnGcg5HGCMdDwQK17S7MjmCcBbhRngECQf3lB5HUZHUZHUEEluwrX1ROsShgzEu4/ibt9PT8KkoopEhRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQBE3/H1H/uN/NalqJ+LmMnoVZfx4P9DUtAFZoGgdprYE5OXi3cN67c8K3fsDk565E0UqTRiSM5U+2PqCOx9qfVeWJ45DPAMsf9ZHnHme49G9+/Q9iEVfm3LFFRwzLOhIBVgdrI3VT6H/PuODTyQoJJAA5JNMlqwtUJ9StIdSjgklxLgrt2k8nbgdKteY0nEQ4/vsOPw9f5VnyaPA+rx3byTNLjfyRjKlcdqANDMknTMa+pHzH/AA/H9KoSRpH4lsto5NncZJ5J+eHqaf8A23aS8WXmX7dvsi71z3Bk4QHHOCwPT1GfOfHWn+NdU8U2b6MlzaqbNtqQX4Q4D/Nu5UBvmjyBkcDk4rpoUeedpPl33NqVPmlZu3qer1nf21aS8WXmXzdvsq71z3Bk4QHHOCwPT1GT+xLSXm98y/bv9rbeuexEfCA44yFB6+pzo1h7q8zP3UZ//E1uf+eFlGf+2shB/JUYf8DGfUDlf7HtZObzzL1u/wBpbeufUJwgOOMhQevqc36KOZ9A5n00CiiipJCiiigAooooAKKKKACiiigAooooA4zVPiDpuneLl8P/AGW7k1AukCHCiIvIEK5bOQvIydpx2BrqrO0+z75JZPOupcebKRjOOgA/hUZOB7kkkkk5Vz4M8P3mvLrk9hv1FZElE3nSD5kxtO0NjjaO3at6tJyhZKHzAKKKKzAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooApal8n2S46+Vcp8vrvzH+m/P4Yq7VLVP8Aj0j/AOvmD/0alXaZT+FES/8AH1J/uL/NqZdWcd0qliySIdySpgOh9QfxPB4OSDT2/wCPqP8A3G/mtS0iU7FOC8Im+y3YWO4AyCOElHTcv6ZXqCe4wTcqG5tILyLy7iJZFByMjlT6g9Qeeo5qrDLPayrbTsZc/wCqkPWT2z03DqR3GSOhVXuVa+qNCimo6uMqQex9qdSJCiiigAooooAKKKKACiiigAooooAKKKKAIpf9ZB/vn/0E1LUUv+sg/wB8/wDoJp8kiRRtJI6oiAszMcAAdSTQA6is461byOEs4p71jyPs6jaR6h2IQ88cHOfoarXC6vdzx25uLe0VjmRLdfNZU/vb2AAyRtwVPc84OK5X1LUH10MPxRok+t6sbq2nt0gt4PLllmYqoILFucEcZGf/AKxx0I1S3lIMCz379U+zwkxk99shwnHu3UEdeKkttDsLZYcxNO8IXy3uHMhQjuu7hOg+6B0HoK0aSUVqa1K3PGMHtHYzv+Jtdf8APvYxn/ttKQfyVGH/AAMZ9QOY20W0luU+2779ijE/azvXORghOEU44yFH6mtWon4uIm7EMv48H+hp876aGPM+mhLWav77xLJu4+zWa7Md/Ndt2f8AvyuPqevGNKs3TP3l9qs/3gbkRpJ1yqxoCoPoHMnHZt3fNOOzYl1NKiiioEFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAUtU/49E/6+IP8A0alXap6n/wAeqf8AXxB/6NWrlBT+FfP9CKX/AFkH++f/AEE1LUU/+rH++n/oQqWgkKjmhjuImilXch98EEcggjkEHkEcg1JRQBniY28qw3coWQkLDcHAEvopHTf7d+q45C3FkO4I67XPTuD9DTnRJY2jkVXRgVZWGQQeoIqmCbVlt7kmS3chYpX5IPZHJ6+zd+h5wWe5W+xeoqL54vV09/vD/H+f1qRWDqGU5FIkWiiigAooooAKKKZNNFbxNLNKkUa9XdgoH4mgB9FUf7R83iztprj/AG9uyP2O5sbl91Dcfhk8nUJ+ZbpLZeuy2UMwP++4wR3+6Prxy7Fcj66FqaeK2iaWeVIo16u7BQO3U1U/tLzuLK1nuc9JNuyP2O5sblPqgbj8MyRadZ28gn8oNKmcTTMZHUY6BmJIHXjOOT61Nvkf/VrtH95x/Tr+eKNA91eZn3I1GSIGaaC0Quo2wgyuTuHIZgBn22Hp154emkwPIss0bSupDB7hzI4b1XPEfP8Adx26YGLUsSogbktvTLHk/eH+cVLLKkELzSNtjjUsxxnAHJo5n0DmeyIppFtIR5cYZ3YKiZwWY+p6+5PPAJ7U62g8iMgtvdmLu+Mbif6DoPQADtTLeJzI9xOuJH4RSc+WnHy+mSRk49hkgA1ZpA9FZBRRRQSFRS/6yD/fP/oJqWopf9ZB/vn/ANBNAEtZugfNo8U4+7cvJcoO4WV2kUH3wwz7561Z1G7/ALP0y7vdnmfZ4Xl2Zxu2qTjPbpRp1p9g0y0s9/mfZ4Ui34xu2qBnHbpV/YH0LNFFFQIKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAp6rxpVy4+9HGZUPoy/Mp/AgVcqpqv/IIvf+uEn/oJq3QU/hXz/Qiuf+PWb/cP8qloqK2/49Yf9wfyoJJaKKKACmuiSxtHIqujAqysMgg9QRTqKAKPmyaf8s2+S1HScnJiHo+Tkgf3uePvYwWNpogWLodjnqQOv19akrOlmi0YKZZEjsGYKu5gPJJ7D/Y/9B/3fuvcu3NtuXVlBYI42OegJ6/T1qSqTXb3ClbezlcH+OYGFQffPzfiFPPfrhht71gPPuWEfdLcYIHoWOS3pldp/Hohctt9C3PcwWqB7iaOFCcBpGCjPpzVf7dLNxa2cz/7cwMKA+h3Dd+IUj9cSW1paQt50EamRhgzE73Yehc5J6evarNAXivMpfZ76bmW+8nuFto149iXDbseoC/T0fDp1pDKsoi3zL92WVjI6j0DMSQOvGe59atVG0qhiqgu4/hXt9fT8adw52SVGZSSVjQsRwSeFH4/4ZpPLZ/9a2R/cXgfj6/y9qkACgAAADgAUiRghBIaQl2HIz0H0H+TUlFFAEVxxbu3dRuH1HP9KgT/AE2YSnm1TBi9JG/ve4HG33yeflNMv5HnSS3hYgKp89xxtG0kKD/ePH0GTwStXkRY0VEUKijCqowAPQUFfCvMWiiigkKKKKACopf9ZB/vn/0E1LUUv+sg/wB8/wDoJoAo6/8ANpLRH7k80MEg/vJJKiOPbKsRnrzxWnWZqP7zVtIiTl0mknYeiLE6E/8AfUiDHXn2NadW/hS/r+tB9AoooqBBRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFAFTVP+QTe/9cH/APQTVuqup/8AIKvP+uD/APoJq1S6lP4V8/0CooP9Wf8Aff8A9CNS1UN3BBPMkkg8wsCI1+ZyNo6KOT+XamJJvYt0VU+1Ty/8e9oxHZ5j5YP4YLZ+qj+WT7LPL/x8XbEd0gHlg/jktn6MP55Vx8tt2Sz3UFtt86VULfdUn5m9gOpPsKi+1Ty/8e1oxHZ528pT+GC2fqo+vTM0FrBbbvJiVC33mA+ZvcnqT7mpaYXitlcp/ZJ5f+Pm8cjukA8pT+OS2fow+nXMsFla2zmSGCNJCMNIF+Zvq3U/jU9FAObehR2S6f8A6mPzLMcmNc74h6IMfMvfbwRggZ4UXEdJI1kjZXRgCrKcgg9wadVKUGwZ7iMZt2O6WMfwk9XUfzXv1HOQz3D4vUstGdxdDh+4zwfr/jSfaEU7Xyr/AN3BJP09aRJTcxrJCy+UwBWTruHqB/X9Kd5EeOVDE8lj1J9c0iRMSSdSY1/uj7x/Ht+H51IqhFCqMCo8vF97Lp/eA+b8gP5f/XqQEMAQQQeQRQAtFFFABVe6naMLHCA08hwinnAyMsfYA57Z4GckU+4nW2t3mcEhRnavVj2A9STwB6mmW0DRmSWUgzSkFschQBgKD1wOfxJOBnFBSXVgLYQ2Twx5YkMcseWZskk9uSSfSp1YOoZTkEZBpaitv+PWH/cH8qCW76ktFFFABRRRQAVFNx5b/wB1xx9fl/rUtRT/AOrH++n/AKEKAKP+u8Uen2Sy+u/zn/THkfju7Y506zNO/eavrEr8uk0dup9I1iRwP++pXOevPsMadXPdIGFFFFQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQBS1a//svTJrzyvN8vb8m7bnJA64PrWb4e1S41LSY/ItUjEOIS8kmRwo5AA5+nHbn03JYYp4jFNGkkbdVdQQfwNZljHHpvnpEipCLhvOCjCpkblYe20qp7DrwASc5KXMnfQ6Kbh7Jxt71y59kkk5uLmVv9mI+WoPtj5vzYj9MLBBDbzyJDEkalVJCKAM5PpVmom/4+o/8Acb+a1dkYuTehLRRRTJCiiigAoqNpQGKIN7jqAen19KTyjJzNhv8AZH3R/j/npQAeaX/1IDD++T8v/wBf/PNKsQDB3O9x0JHT6elSUUAU3t5baRprUsyklntuArE9Sp7N367Sc5wSWFmGaOeJZY23KfbBB6EEHkEHgg9KfVWaGSKVrm2Xcx/1sWcCUeo9GA6Hv0PYq9yr825aqMxlSWi2qTyQRw3/ANf3pYZo54lkjbcp9sEHoQQehB4IPSn0iRiSBjtOVfrtPWn010Vxhs+owcEfjWfI73U5hf57JMiWQDAdgcbT6qOd2OM8dAwoGlcltv8ATJVvTzCVBt1Poc5f2JBGO4HpuIq7SAhgCCCDyCKWgG7sKitv+PWH/cH8qlqK3/1WOwZgPYbjQIlooooAKKKKACop/wDVj/fT/wBCFS1Q1q8/s7Rrq+8vzPs0Zm2Zxu284z26U0ruyAi8P/NpCzD7k889xGf70ckruh9sqwODzzzWpVXTbP8As7SrOy8zzPs8CQ78Y3bVAzjt0q1Tm7ybQBRRRUgFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFVD+61UE9J4toJ4wUJOPckOT/AMBP4W6p6j+7hjuf+faQSn0C8q5/BWY/UDr0oKhvbuPg/wBGdbU/6raPJJ9B/D9QB+I9cE1JL/rIP98/+gmnTRLPC0bEgMOo6g9iPcdRUBlZ43SQASROm7HAIyDuHt1+hBHOM0lpoD97UtUUjMEUsxwKjzJJ0BjX+8fvH8O34/lTJHvIEwMEk9ABkmmbXk++Si/3VPJ+p/w/WnpGkedo5PUnkn6mnUAIqqihVUKB2AxS0UUAFFFFABRRRQBVmtMStc2oRLk/eJGBKPR8foeo9xkGW3uEuIyyhlZTtdG+8jeh/wA4IIIyCDUtcx41uNS0/S0vtHWQXYkCStHFv/dbWJ3AgjAIHJ6ZPqctK7sa04upJQ6m7czOZUtYGxK/LuBkxJz83PGSRgZ9zghSKnhhSCIRxrhR75JPUknuSeST1rI8LG9k0GK41JJFv52Z5/Mj2MSDtGVwMfKq9vetqh6aE1Fytw7EZRlJaMjnqh4B9/b/AD9ackgfIwQR1BGCKdTXjV8E8MOjDqPpSIHVFB/qz/vv/wChGje0fEnK9nH9fT69PpUVrcwStJFFNHIysT8rg8Hn+uKALVFFFABRRRQAVwHxO0bxPrMGnw+HvtBi2zLdJFciIMDs2hgWG7o3r+td/RV05unJSQFDQ4ruDQNNivy5vEtYlnLvvYyBQGy2Tk5zznmr9FFS3d3AKKKKQBRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABTJoknhkhkXdHIpVhnGQRg0+igCtp8rzWMbStulXMcjYwC6kqxHtkGqev213cWA+w7hOrdVbB24OR9Dxx9PSrFr+61G9tx907J17Bd+QQB9ULZ7lj9TdoaLlpK6MzRmLWMJuSzXOWGZH3E4Yjg9PbitOqKx7IIpVUkFQJkHU4GMgf3gQPfA7kCrCybVDFvMiIyJBjp747e4/wDr0k+gmuqJqKKKZIUUUUAFFFFABRRRQAVS1L50toB96W5j2nt8h8w5/BD+OKu1Sm/eatbJ95Yo3lIH8LcKpP1BkA9efTgRUN7l2iiigkKKKKACsfSNHGnXc8gn3j7mNmOyn1rYqKLiWYd9wP4bR/gaAJaKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAo3n7q/sbjsWaByeiq4yD9dyIB/vY6kVeqpqcMk+mXCQrunCb4RnH7xfmTrx94Drx61PBPHc28c8LbopUDo2MZBGQeafQp6xTEg+4w7h2yPxJqNP9Fl8s8W7YEfojf3fYdMfiPQVJFxLMO+4H8No/wNPkjWWJ43GUcFWHqDUtCTtoxmwxcxAbe6Y/l6f56U9HVxlc+hyMEfhUcMjB2hlOXXlWPG9eOfr2P58ZFPePcdykq46H/Ed6E7g1YfRUayHcEcYfsccH6f4VJTEFFFFABRRRQAVTtv3mpXsvTZ5cGPXA35/wDImMe3vVyqem/NaGbr50jyhu7KWO0/987foAB2oKXwtlyiiigkKKKKACol/wCPqT/cX+bVLUS/8fUn+4v82oAlooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigArP0n93DcWp621w6YH3Qp+dAPYI6jHbGBwBWhWd/qfEfr9qtP++fKf9c+d+G3vnio6popbNFwcXT+6Lj3wTn+Y/Opaibi5jPbaw/Hj/A1LUkkc8XmoAG2upDK2OhH9Ox9iaIZfNQkrtdSVZc9CP6dx7EVJUMsbCQTxjLgbWTpvH+I7Z9T0zkS9NSlqrMlZQ6lWGRUeWi+9zH/AHieR9fb3/8A10+ORZY1kQ5RwGU+oNOqiRAQwBBBB5BFLUZRkJaPJHUp2P09/wBP505HDjIyCOCD1BoAdRRRQBBezNbWFxOgBaOJnAPTIGafbwrbW0UCElYkCAnrgDFQX/zrBCPvSTpg9vlO8/oh/HFW6RT0igooopkhRRRQAVEeLpPdGz74Ix/M/nUtRN/x9R/7jfzWgCWiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACs7Wf3UFteDra3KSEn7oVj5bs3sEdmz2xk8A1o1HcW8V1bS28y7opUKOuSMqRgjI9qqLs7sadmJL9+E9g/J/AipazdPuJbnRLWS4bdcKFS4OAMSIwWTpxwyt04444rSpNWdgas7BRRRSEVz/o0jP0gblsfwN3b6Hv6de5IsUjKrqVYBlIwQRkEVDEzRSGGQkgn90xOcjHQn1HP1HrzU7FfEvMnpjxhjuGFcdGx+n0p9FUSRrIdwRxh+xxwfp/hUlIyh1KsMio8tF97mP8AvE8j6+3v/wDroAil/ealbp1WNHkIH8LcKpP4F/19KtVUtyJb66lBGBsiGOc4G7P/AI/j8Kt0kVLov67hRRRTJCiiigAqJ+J4m9cp+Yz/AOy/rUtRS/6yD/fP/oJoAlooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAybcGK81izAPzbbmNV6Ksi7cAepeORj/vZ6k1qghgCCCDyCKzb/wD0fWNNuz9w+ZasTwE8zawYn/ejVAO5cfQ3rb/j2iHcKAfY1c9bMbJaKKKgQUyWJZoyjEjkEEdQQcg/mKfRQ1cE7akUMjOGSQASocMB3HYj2P8A9btUtRSxlmWWMgSICBnoQcZB/Ic+34F0UgmiWRQQGHQ9QfQ+4qU+jKa6ofRRUN1K0FnPMoBaONmAPTIGapu2okruxXsYyLczx4JmkeT5jwyljtPt8uP5fS4kivkDhh1U9R9aSGJYII4VJKxqFBPXAGKV0D4OSrDow6iktEOTvJsdRUauQwRxhux7N9P8P51JTJCiiigAqKX78J7B+T+BFS1FP/qx/vp/6EKAJaKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKAKOs28tzpU62677iPbNAmQA0iMHQHPYsoB6cZ5HWpNPuIruyjuIH3RS5kRsEZVjkHB5GQQfxq1WR4fH2eG708kZsrgwqAeFj2q0Y9TiNkGT3B69TW8fQDXoooqQCiiigAqvL/o7vcD/AFZH70emP4h+HX2A9MGxRSauNOwVWvPmWGMdXmTH/ATuP6KaVP8AR5REf9W5/dY/h4zt/QkflxgZJPnvoV6hEZyPRuAD+Rb9fSpbuioq0rliiiirIEZVdSrKGB7EZqPLRdcunbAJYf4/5+tS0UAICGAIIIPIIpajKFCWixk9VJ4P+FOSRXyBww6qeo+tADqin/1Y/wB9P/QhUtRXH/HvIe6ruH1HIoAlooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAK800f4eatp/xMl8SS3FkbN7q4mEaO/mYkDgcbcZ+YZ5r0uitIVJQTS6hYKKKKzAKKKKACiiigBrosiFWGQa57QdWudQ1GVJxH/qByoIJ2n6/wC0a6Oop42cK8ZAlQ5UnuO4Psf/AK/asalOUpRlF2t07m1OpFRlFrfr2JaKZDKs0SyKCAw6HqD3B9x0p9bbmLVtAooooAKa6B8HJVh0YdRTqKAI1chgjjDdj2b6f4fzpLn/AI9Zv9w/yqRlV1KsoYHsRmqd/N9jsZpH3yR7ccYLLnj8Rz9frQBdoqrYX8Wo25mhV1XO3DgA9Ae31q1QAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFAFaT/RZTMP9VI377P8PGA304AP58YObNIyq6FHUMrDBBGQRVeB2il+yysWbDNGxOdyA9D7jIHPXg+uFsV8S8yzRRRTJCiiigAqOeCO5haGZdyN1GSPepKKAKunW0NrZRpCm1WAYjJPOB61aqK2/wCPaIdwoB9jUtABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFQ3EHnxgBtjqwdHxnaR/Q9D6gkd6mooGnZ3RDbT/aIQxXZIOJI85KN3H/1+4wehqaqd1/obG9XiIc3I9VA+9j1GB9RnqQtXKByXVBRRRQSFFFFAEUH+rP++/8A6EalqKD/AFZ/33/9CNS0AFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRVLU9VtNHtUuL2TZG80cC4GSWdgqjH1P5ZrzuZ/DHin4yxRu1it5op4zjz7q5VSQB32RDJ92P+zVOLSUraMD1GiiipAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKpQf6FOtmf9TJuaBum3nJj/AH5cfwgjHy5N2orm3S6gMTlgMhgy9VYEEEfQgHnimik+jJaKrWNw88JWYKtzCRHOq/dD4B49iCCPYjODkVZpNWE1Z2CiiigRFDw0qjoH4/EAn9SalqKL/WT/wC+P/QRUtABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQB4Z+0Jd36y6LZnaunOskq4bl5VwDkdsKwx/vH0r1bwVd3t/4J0W71FUW6mtI3YqQQwI+VuAACRgkdicdq8r/AGif+Zb/AO3r/wBpV6r4L/5ETw9/2DLb/wBFLX0eNUf7Fwzsr3l+b/Mxj/EkblFFFfOGwUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAUb9HhIv4EZpIQfNjQZaaMA/KPUgnK++RkBiauRyJLGskbq6OAyspyGB6EGnVnL/wAS28EXSzuHZgx/5ZSs2dufRyxIz0PGTuUClqrFbqxo0UUVJJFHxNMvckN+GMf0NS1Ev/H1J/uL/NqloAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKAPDv2if+Zb/wC3r/2lXqvgv/kRPD3/AGDLb/0UteVftE/8y3/29f8AtKvVfBf/ACInh7/sGW3/AKKWvo8b/wAiXDesvzZjH+JI3KKKK+cNgooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKjngiuoWhmXcjY7kEEHIII5BBwQRyCMipKKAKWnXErI9pctuu7bakj4A80EZEgHYNz7BgwGcZq7VHUreVkS7tV3XdtueNMgeaCMGMnsG49gwUnOMVZt7iK6gWaFtyNnsQQQcEEHkEEEEHkEEGqlrqhvuC/8fUn+4v82qWom/4+o/8Acb+a1LUiCiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKo32rWdgkplmVpY1z5KMC59ABnv74FJyUVdlRjKTtFXKkPizRJ3gSK93yz3clkkQifeZkzvUrjIC4ySRgDBzgip9R1u008FWcSTD/lmh5/H0ryfRLbXm8cX+s/2fGj6zETKkG0tZkEAJnPO5Qu5l6snpivRNP8AC+SJtRYsx5Mat39z3/CuaVaU3y0Vfz6HbDDU6a58Q7eXU5XxNoR+IPkm7s3kFpuMPksVCZwWBPQ52gevpitTQvETaJawaVd2zC3tUWGMAEPGqjABB64AHv8AWu5jiSGNY40CoowAB0qpqOkWeqRFLiIb8YWReGX6GuhTxHslSlUbS2T2V+yPLx8ZVaiqYf3LK1uj9fMntLy3voFmtpVkjbuO319Knrg7vQtU0GQ3djM0kanlox8wH+0vcfnWnpXjGCfbFqCiF+nmDlSff0qVU6S0OWnjkpezrrll+D+Zu3eqWdjd2VrczeXLeyGK3BUkO4UuRkDAO1SecZxS6bqlnrFkLywm863LsiyBSAxVipIyBkZB5HB7E1znjXTP+Eu0CKy0yQTSR6jBvmt51VrdQ481gc9RGzcDn5q6m1toLK0htbaJYoIUEccaDAVQMAD8K0O9O+xLRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAVmS/wDErvUlX5bG4fbKo58uZ2AVgOwYkhsZ+YqcDLtWnTZI45onilRZI3UqyMMhgeoI7inF2AY3/H1H/uN/NalrkbvxdpPha6i0zXNQaOeJP3UjxvI08BHEjFQfm3KVPPJUtgBgB11OUHHfYAoooqQCiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigCC8kmjtZGtojLNj5EyBz+NcjD4a1Oe+WS827ZHzM5kG737YrtaKxqUY1GubodNDFToJqCWvXqVrSwtrGPZbxBB3PUn6mrNFFapJKyOeUnJ3k7sKKKKYgrA17w1BqUEktqiRXuMq3RXPo3+PWt+ik0nozOrShVjyzV0cR4e0rXdD1Au9rvtpfllSOZSP94Akcjp/kV29FFEY20FRoqjHli9AooopmoUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAcl4o+Hmk+LdTiv7+4vY5Y4RCBA6BcAse6nn5jXW0UVTnKSSb2AKKKKkAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigD//2Q==", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# get modal parameters\n", + "msp.mpe(\n", + " \"SSIdat\",\n", + " sel_freq=[2.63, 2.69, 3.43, 8.29, 8.42, 10.62, 14.00, 14.09, 17.57],\n", + " order_in=80)\n", + "\n", + "# plot mode shapes\n", + "_, _ = msp.plot_mode_geo1(algo_res=ssidat.result, mode_nr=1, view=\"3D\", scaleF=2)\n", + "_ = msp.plot_mode_geo2(algo_res=ssidat.result, mode_nr=6, scaleF=2, notebook=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "d7e89b53-5b8c-4f2d-b5e8-c6ed0ccbaabf", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 2.63125782, 2.69635965, 3.42653623, 8.28781744, 8.4216651 ,\n", + " 10.59955433, 13.97708409, 14.03198368, 17.50428592])" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ssidat.result.Fn" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e198383b-1fd4-4f4b-ad3e-5dc15ef43fb4", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.15" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/LICENSE b/LICENSE index 606ada9..0333116 100644 --- a/LICENSE +++ b/LICENSE @@ -1,6 +1,6 @@ MIT License -Copyright (c) 2023 dagghe +Copyright (c) 2021 Dag Pasca Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..4bd2790 --- /dev/null +++ b/Makefile @@ -0,0 +1,21 @@ +# Makefile + +test: + pdm run pytest + +test-coverage: + pdm run pytest --cov=pyoma2 --cov-report=html + +env38: + pdm venv create -n venv38 + pdm install --venv venv38 + # then with "pdm use" select the created venv + +tox: + pdm run tox + +export: + pdm export --without-hashes -L pdm.lock -v >> requirements.txt + + +.PHONY: test test-coverage env38 tox export diff --git a/README.md b/README.md new file mode 100644 index 0000000..8e37147 --- /dev/null +++ b/README.md @@ -0,0 +1,67 @@ +# pyOMA2 +![pyoma2_logo_v2_COMPACT](https://github.com/dagghe/pyOMA2/assets/64746269/aa19bc05-d452-4749-a404-b702e6fe685d) + +[![python](https://img.shields.io/badge/python-3.8%20%7C%203.9%20%7C%203.10%20%7C%203.11%20%7C%203.12-blue.svg?style=flat&logo=python&logoColor=white)](https://www.python.org) +[![pre-commit](https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&logoColor=white)](https://github.com/pre-commit/pre-commit) +[![Test Pyoma2](https://github.com/dagghe/pyOMA2/actions/workflows/main.yml/badge.svg?branch=main&event=push)](https://github.com/dagghe/pyOMA2/actions/workflows/main.yml) +![downloads](https://img.shields.io/pepy/dt/pyOMA-2) +[![docs](https://readthedocs.org/projects/pyoma/badge/?version=main)](https://pyoma.readthedocs.io/en/main/) +_______________________ + +This is the new and updated version of pyOMA module, a Python module designed for conducting operational modal analysis. +With this update, we've transformed pyOMA from a basic collection of functions into a more sophisticated module that fully leverages the capabilities of Python classes. + +The module now supports analysis of both single and multi-setup data measurements, which includes handling multiple acquisitions with a mix of reference and roving sensors. We've also introduced interactive plots, allowing users to select desired modes for extraction directly from the plots generated by the algorithms. Additionally, a new feature enables users to define the geometry of the structures being tested, facilitating the visualization of mode shapes after modal results are obtained. The underlying functions of these classes have been rigorously revised, resulting in significant enhancements and optimizations. +Since version 1.0.1, the uncertainty bounds of the modal properties can also be estimated for the SSI family of algorithms. + +## Documentation + +You can check the documentation at the following link: + +https://pyoma.readthedocs.io/en/main/ + +## Quick start + +Install the library with pip: + +```shell +pip install pyOMA-2 +``` + +or with conda/mamba: + +```shell +conda install pyOMA-2 +``` + +You'll probably need to install **tk** for the GUI on your system, here some instructions: + +Windows: + +https://www.pythonguis.com/installation/install-tkinter-windows/ + + +Linux: + +https://www.pythonguis.com/installation/install-tkinter-linux/ + +Mac: + +https://www.pythonguis.com/installation/install-tkinter-mac/ + +____ + +# Examples +To see how the module works please take a look at the jupyter notebook provided: + +- [Example1 - Getting started.ipynb](Examples/Example1.ipynb) +- [Example2 - Real dataset.ipynb](Examples/Example2.ipynb) +- [Example3 - Multisetup PoSER.ipynb](Examples/Example3.ipynb) +- [Example4 - MultiSetup PreGER.ipynb](Examples/Example4.ipynb) +____ + +# Schematic organisation of the module showing inheritance between classes. + +![](docs/img/info.svg "") + +____ diff --git a/docs/Example1 - Getting started.rst b/docs/Example1 - Getting started.rst new file mode 100644 index 0000000..7914a5a --- /dev/null +++ b/docs/Example1 - Getting started.rst @@ -0,0 +1,123 @@ +Example1 - Getting started +========================== + +In this first example we'll take a look at a simple 5 degrees of freedom (DOF) system. +To access the data and the exact results of the system we can call the ``example_data()`` function in the submodule ``functions.gen`` + +.. code:: python + + # import the function to generate the example dataset + from pyoma2.functions.gen import example_data + + # assign the returned values + data, ground_truth = example_data() + + # Print the exact results + np.set_printoptions(precision=3) + print(f"the natural frequencies are: {ground_truth[0]} \n") + print(f"the damping is: {ground_truth[2]} \n") + print("the (column-wise) mode shape matrix: \n" + f"{ground_truth[1]} \n") + + >>> the natural frequencies are: [0.89 2.598 4.095 5.261 6. ] + >>> the damping is: 0.02 + >>> the (column-wise) mode shape matrix: + [[ 0.285 -0.764 1. 0.919 -0.546] + [ 0.546 -1. 0.285 -0.764 0.919] + [ 0.764 -0.546 -0.919 -0.285 -1. ] + [ 0.919 0.285 -0.546 1. 0.764] + [ 1. 0.919 0.764 -0.546 -0.285]] + + + +Now we can instantiate the SingleSetup class, passing the dataset and the sampling frequency as arguments + +.. code:: python + + from pyoma2.setup.single import SingleSetup + + simp_5dof = SingleSetup(data, fs=600) + + +Since the maximum frequency is at approximately 6Hz, we can decimate the signal quite a bit. +To do this we can call the ``decimate_data()`` method + +.. code:: python + + # Decimate the data + simp_5dof.decimate_data(q=30) + + +To analise the data we need to instanciate the desired algorithm to use with a name and the required arguments. + +.. code:: python + + from pyoma2.algorithms.fdd import FDD + from pyoma2.algorithms.ssi import SSIdat + + # Initialise the algorithms + fdd = FDD(name="FDD", nxseg=1024, method_SD="cor") + ssidat = SSIdat(name="SSIdat", br=30, ordmax=30) + + # Add algorithms to the class + simp_5dof.add_algorithms(fdd, ssidat) + + # run + simp_5dof.run_all() + + +We can now check the results + +.. code:: python + + + # plot singular values of the spectral density matrix + _, _ = fdd.plot_CMIF(freqlim=(0,8)) + + # plot the stabilisation diagram + _, _ = ssidat.plot_stab(freqlim=(0,10),hide_poles=False) + +.. image:: /img/Ex1-Fig1.png +.. image:: /img/Ex1-Fig2.png + +We can get the modal parameters with the help of an interactive plot calling the ``mpe_from_plot()`` method, +or we can get the results "manually" with the ``mpe()`` method. + +.. code:: python + + # get the modal parameters with the interactive plot + # simp_ex.mpe_from_plot("SSIdat", freqlim=(0,10)) + + # or manually + simp_5dof.mpe("SSIdat", sel_freq=[0.89, 2.598, 4.095, 5.261, 6.], order_in="find_min") + + +Now we can now access all the results and compare them to the exact solution + +.. code:: python + + # dict of results + ssidat_res = dict(ssidat.result) + + from pyoma2.functions.plot import plot_mac_matrix + + # print the results + print(f"order out: {ssidat_res['order_out']} \n") + print(f"the natural frequencies are: {ssidat_res['Fn']} \n") + print(f"the dampings are: {ssidat_res['Xi']} \n") + print("the (column-wise) mode shape matrix:") + print(f"{ssidat_res['Phi'].real} \n") + + _, _ = plot_mac_matrix(ssidat_res['Phi'].real, ground_truth[1]) + + >>> the natural frequencies are: [0.891 2.596 4.097 5.263 5.998] + >>> the dampings are: [0.022 0.019 0.025 0.019 0.019] + >>> the (column-wise) mode shape matrix: + [[ 0.312 0.773 1. 0.926 0.537] + [ 0.545 1. 0.279 -0.762 -0.912] + [ 0.774 0.541 -0.912 -0.283 1. ] + [ 0.985 -0.285 -0.534 1. -0.738] + [ 1. -0.942 0.749 -0.544 0.279]] + + +.. image:: /img/Ex1-Fig3.png diff --git a/docs/Example2 - Real dataset.rst b/docs/Example2 - Real dataset.rst new file mode 100644 index 0000000..57b59ac --- /dev/null +++ b/docs/Example2 - Real dataset.rst @@ -0,0 +1,274 @@ +Example2 - Real dataset +======================= + +In this second example we will explore more functionalities with a real dataset [APTF20]_ +First of all we import the necessary modules. Then we import the dataset we want to analyse and assign it to a +variable + +.. code:: python + + import numpy as np + import pandas as pd + import matplotlib.pyplot as plt + from pyoma2.algorithms import pLSCF,FSDD,SSIcov + from pyoma2.setup import SingleSetup + from pyoma2.support.utils.example_data import get_sample_data + + # load example dataset for single setup + data = np.load(get_sample_data(filename="Palisaden_dataset.npy", folder="palisaden"), allow_pickle=True) + +Now we can proceed to instantiate the SingleSetup class, passing the +dataset and the sampling frequency as parameters + +.. code:: python + + # create single setup + Pali_ss = SingleSetup(data, fs=100) + + +If we want to be able to plot the mode shapes, once we have the +results, we need to define the geometry of the structure. We have two +different method available that offers unique plotting capabilities: + +- The first method ``def_geo1()`` enables users to visualise mode + shapes with arrows that represent the placement, direction, and + magnitude of displacement for each sensor. +- The second method ``def_geo2()`` allows for the plotting and + animation of mode shapes, with sensors mapped to user defined + points. + +.. code:: python + + _geo1 = get_sample_data(filename="Geo1.xlsx", folder="palisaden") + _geo2 = get_sample_data(filename="Geo2.xlsx", folder="palisaden") + + Pali_ss.def_geo1_by_file(_geo1) + Pali_ss.def_geo2_by_file(_geo2) + + +Once we have defined the geometry we can show it calling the +``plot_geo1()`` or ``plot_geo2()`` methods. + +.. code:: python + + # Plot the geometry (geometry1) + fig, ax = Pali_ss.plot_geo1(scaleF=2) + # (geometry2) with pyvista + _ = Pali_ss.plot_geo2(scaleF=2, notebook=True) + # (geometry2) with matplotlib + _, _ = Pali_ss.plot_geo2_mpl(scaleF=2) + + +.. figure:: /img/Ex2-Fig1.png +.. figure:: /img/Ex2-Fig2.png +.. figure:: /img/Ex2-Fig3.png + + +We can plot all the time histories of the channels calling the +``plot_data()`` method + +.. code:: python + + # Plot the Time Histories + fig, ax = Pali_ss.plot_data() + + +.. figure:: /img/Ex2-Fig4.png + + +We can also get more info regarding the quality of the data for each +channel calling the ``plot_ch_info()`` method + + +.. code:: python + + # Plot TH, PSD and KDE of the (selected) channels + fig, ax = Pali_ss.plot_ch_info(ch_idx=[-1]) + + +.. figure:: /img/Ex2-Fig5.png + + +As we can see from the auto correlation there's a low frequency component in the data. +Other than the ``detrend_data()`` and ``decimate_data()`` methods there's also a ``filter_data()`` method that can help us here. + +.. code:: python + + # Detrend and decimate + #Pali_ss.detrend_data() + Pali_ss.filter_data(Wn=(0.1), order=8, btype="highpass") + Pali_ss.decimate_data(q=5) + _, _ = Pali_ss.plot_ch_info(ch_idx=[-1]) + + +.. figure:: /img/Ex2-Fig6.png + + +Now we can instantiate the algorithms that we want to run, e.g. +``EFDD`` and ``SSIcov``. The algorithms must then be added +to the setup class using the ``add_algorithms()`` method. Thereafter, +the algorithms can be executed either individually using the +``run_by_name()`` method or collectively with ``run_all()``. + + +.. code:: python + + # Initialise the algorithms + fsdd = FSDD(name="FSDD", nxseg=1024, method_SD="cor") + ssicov = SSIcov(name="SSIcov", br=50, ordmax=50) + plscf = pLSCF(name="polymax",ordmax=30) + + # Overwrite/update run parameters for an algorithm + fsdd.run_params = FSDD.RunParamCls(nxseg=2048, method_SD="per", pov=0.5) + + # Add algorithms to the single setup class + Pali_ss.add_algorithms(ssicov, fsdd, plscf) + + # Run all or run by name + Pali_ss.run_by_name("SSIcov") + Pali_ss.run_by_name("FSDD") + Pali_ss.run_by_name("polymax") + # Pali_ss.run_all() + + # save dict of results + ssi_res = ssicov.result.model_dump() + fsdd_res = dict(fsdd.result) + + +We can now plot some of the results: + + +.. code:: python + + # plot Singular values of PSD + fsdd.plot_CMIF(freqlim=(0,5)) + + +.. figure:: /img/Ex2-Fig7.png + + +.. code:: python + + # plot Stabilisation chart for SSI + ssicov.plot_stab(freqlim=(0,5), hide_poles=False) + + +.. figure:: /img/Ex2-Fig8.png + + +.. code:: python + + # plot frequecy-damping clusters for SSI + ssicov.plot_freqvsdamp(freqlim=(0,5)) + + +.. figure:: /img/Ex2-Fig9.png + + +.. code:: python + + # plot Stabilisation chart for pLSCF + _, _ = plscf.plot_stab(freqlim=(1,4), hide_poles=False) + + +.. figure:: /img/Ex2-Fig10.png + + +We are now ready to extract the modal properties of interest either +from the interactive plots using the ``mpe_from_plot()`` method or +using the ``mpe()`` method. + + +.. code:: python + + # Select modes to extract from plots + # Pali_ss.mpe_from_plot("SSIcov", freqlim=(0,5)) + + # or directly + Pali_ss.mpe("SSIcov", sel_freq=[1.88, 2.42, 2.68], order_in=40) + + # update dict of results + ssi_res = dict(ssicov.result) + + +.. code:: python + + # Select modes to extract from plots + # Pali_ss.mpe_from_plot("FSDD", freqlim=(0,5), MAClim=0.95) + + # or directly + Pali_ss.mpe("FSDD", sel_freq=[1.88, 2.42, 2.68], MAClim=0.95) + + # update dict of results + fsdd_res = dict(fsdd.result) + +We can compare the results from the two methods + +.. code:: python + + ssicov.result.Fn + + >>> array([1.88205042, 2.4211625 , 2.68851009]) + + fsdd.result.Fn + + >>> array([1.8787832 , 2.42254302, 2.67381079]) + + +We can also plot some additional info regarding the estimates for the +EFDD and FSDD algorithms + +.. code:: python + + # plot additional info (goodness of fit) for EFDD or FSDD + Pali_ss[fsdd.name].plot_EFDDfit(freqlim=(0,5)) + + +.. figure:: /img/Ex2-Fig11.png + +.. figure:: /img/Ex2-Fig12.png + +.. figure:: /img/Ex2-Fig13.png + + +And finally we can plot and/or animate the mode shapes extracted from +the analysis + +.. code:: python + + # MODE SHAPES PLOT + # Plot mode 2 (geometry 1) + Pali_ss.plot_mode_geo1( + algo_res=fsdd.result, mode_nr=2, view="3D", scaleF=2) + + +.. figure:: /img/Ex2-Fig14.png + + +.. code:: python + + # Animate mode 1 (geometry 2) + Pali_ss.anim_mode_geo2( + algo_res=ssicov.result, mode_nr=1, scaleF=3) + +.. image:: /img/Ex2-Fig15.gif + +It is also possible to save and load the results to a pickled file. + +.. code:: python + + from pyoma2.functions.gen import save_to_file, load_from_file + + # Save setup + save_to_file(Pali_ss, "/name.pkl") + + # Load setup + pali2 = load_from_file("/name.pkl"") + + # plot from loded instance + pali2.plot_mode_geo2_mpl( + algo_res=fsdd.result, mode_nr=2, view="3D", scaleF=2) + +.. figure:: /img/Ex2-Fig16.png + +.. [APTF20] Aloisio, A., Pasca, D., Tomasi, R., & Fragiacomo, M. (2020). Dynamic identification and model updating of an eight-storey CLT building. Engineering Structures, 213, 110593. diff --git a/docs/Example3 - Multisetup PoSER.rst b/docs/Example3 - Multisetup PoSER.rst new file mode 100644 index 0000000..207642a --- /dev/null +++ b/docs/Example3 - Multisetup PoSER.rst @@ -0,0 +1,158 @@ +Example3 - Multisetup with Post Separate Estimation Re-scaling (PoSER) method +============================================================================= + +In this example, we'll be working with a simulated dataset generated from a finite +element model of a fictitious three-story, L-shaped building. This model was created +using OpenSeesPy, and the corresponding Python script can be found `here `_. + +As always, first we import the necessary modules. All the files needed to run this +example are available `here `_. + +.. code:: python + + import numpy as np + import pandas as pd + import matplotlib.pyplot as plt + + from pyoma2.algorithms import SSIcov + from pyoma2.setup import MultiSetup_PoSER, SingleSetup + from pyoma2.support.utils.example_data import get_sample_data + +For the **PoSER** approach, after importing the necessary modules and loading +the data, the next step is to create a separate instance of the single setup +class for each available dataset. + +In this example, we'll be working with a simulated dataset generated from a +finite element model of a fictitious three-story, L-shaped building. This model +was created using OpenSeesPy, and the corresponding Python script can be found +in the GitHub repository. + +The exact natural frequencies of the system are: +2.63186, 2.69173, 3.43042, 8.29742, 8.42882, 10.6272, 14.0053, 14.093, 17.5741 + +.. code:: python + + # import data files + set1 = np.load(get_sample_data(filename="set1.npy", folder="3SL"), allow_pickle=True) + set2 = np.load(get_sample_data(filename="set2.npy", folder="3SL"), allow_pickle=True) + set3 = np.load(get_sample_data(filename="set3.npy", folder="3SL"), allow_pickle=True) + + # create single setup + ss1 = SingleSetup(set1, fs=100) + ss2 = SingleSetup(set2, fs=100) + ss3 = SingleSetup(set3, fs=100) + + # Detrend and decimate + ss1.decimate_data(q=2) + ss2.decimate_data(q=2) + ss3.decimate_data(q=2) + print(ss1.fs, ss2.fs, ss3.fs) + + +The process for obtaining the modal properties from each setup +remains the same as described in the example for the single setup. + +.. code:: python + + # Initialise the algorithms for setup 1 + ssicov1 = SSIcov(name="SSIcov1", method="cov", br=50, ordmax=80) + # Add algorithms to the class + ss1.add_algorithms(ssicov1) + ss1.run_all() + + # Initialise the algorithms for setup 2 + ssicov2 = SSIcov(name="SSIcov2", method="cov", br=50, ordmax=80) + ss2.add_algorithms(ssicov2) + ss2.run_all() + + # Initialise the algorithms for setup 2 + ssicov3 = SSIcov(name="SSIcov3", method="cov", br=50, ordmax=80) + ss3.add_algorithms(ssicov3) + ss3.run_all() + + # Plot stabilisation chart + ssicov1.plot_stab(freqlim=(0,20)) + ssicov2.plot_stab(freqlim=(0,20)) + ssicov3.plot_stab(freqlim=(0,20)) + + ss1.mpe( + "SSIcov1", + sel_freq=[2.63, 2.69, 3.43, 8.29, 8.42, 10.62, 14.00, 14.09, 17.57], + order_in=50) + ss2.mpe( + "SSIcov2", + sel_freq=[2.63, 2.69, 3.43, 8.29, 8.42, 10.62, 14.00, 14.09, 17.57], + order_in=40) + ss3.mpe( + "SSIcov3", + sel_freq=[2.63, 2.69, 3.43, 8.29, 8.42, 10.62, 14.00, 14.09, 17.57], + order_in=40) + +.. figure:: /img/Ex3-Fig1.png +.. figure:: /img/Ex3-Fig2.png +.. figure:: /img/Ex3-Fig3.png + + +After analyzing all datasets, the ``MultiSetup_PoSER`` class can be +instantiated by passing the processed single setup and the lists of +reference indices. Subsequently, the ``merge_results()`` method is +used to combine the results. + + +.. code:: python + + # reference indices + ref_ind = [[0, 1, 2], [0, 1, 2], [0, 1, 2]] + # Creating Multi setup + msp = MultiSetup_PoSER(ref_ind=ref_ind, single_setups=[ss1, ss2, ss3]) + + # Merging results from single setups + result = msp.merge_results() + + # dictionary of merged results + res_ssicov = dict(result[SSIcov.__name__]) + result["SSIcov"].Fn + >>> array([ 2.63245926, 2.69030811, 3.4256547 , 8.29328508, 8.42526299, + 10.60096486, 13.99307818, 14.09286017, 17.46931459]) + + +Once the class has been instantiated we can define the "global" +geometry on it and then plot or animate the mode shapes + + +.. code:: python + + # Geometry 1 + _geo1 = get_sample_data(filename="Geo1.xlsx", folder="3SL") + # Geometry 2 + _geo2 = get_sample_data(filename="Geo2.xlsx", folder="3SL") + + # Define geometry1 + msp.def_geo1_by_file(_geo1) + # Define geometry 2 + msp.def_geo2_by_file(_geo2) + + +.. code:: python + + # define results variable + algoRes = result[SSIcov.__name__] + + # Plot mode 2 (geometry 1) + _, _ = msp.plot_mode_geo1( + algo_res=algoRes, mode_nr=2, scaleF=2) + # Plot mode 1 (geometry 2, pyvista) + _ = msp.plot_mode_geo2( + algo_res=algoRes, mode_nr=1, scaleF=3) + # Plot mode 4 (geometry 2, matplotlib) + _, _ = msp.plot_mode_geo2_mpl( + algo_res=algoRes, mode_nr=4, view="xz", scaleF=3) + # Animate mode 5 (geometry 2, pyvista) + _ = msp.anim_mode_geo2( + algo_res=algoRes, mode_nr=5, scaleF=3) + +.. figure:: /img/Ex3-Fig4.png +.. figure:: /img/Ex3-Fig5.png +.. figure:: /img/Ex3-Fig6.png + +.. image:: /img/Ex3-Fig7.gif diff --git a/docs/Example4 - Multisetup PreGER.rst b/docs/Example4 - Multisetup PreGER.rst new file mode 100644 index 0000000..affb3aa --- /dev/null +++ b/docs/Example4 - Multisetup PreGER.rst @@ -0,0 +1,113 @@ +Example4 - Multisetup with Pre Global Estimation Re-scaling (PreGER) method +=========================================================================== + +In this example, we'll be working with a simulated dataset generated from a finite +element model of a fictitious three-story, L-shaped building. This model was created +using OpenSeesPy, and the corresponding Python script can be found `here `_. + +As always, first we import the necessary modules. All the files needed to run this +example are available `here `_. + +.. code:: python + + import numpy as np + import pandas as pd + import matplotlib.pyplot as plt + + from pyoma2.algorithms import SSIdat_MS + from pyoma2.setup import MultiSetup_PreGER + from pyoma2.support.utils.example_data import get_sample_data + +For the **preGER** merging procedure, we adopt a strategy similar to that used +for the single setup class. The first step involves instantiating the +``MultiSetup_PreGER`` class and passing the list of datasets, the lists of +reference sensors, and their sampling frequency. Similarly to the single setup +class, also for the ``MultiSetup_PreGER`` we have access to a wide set of +tools to pre-process the data and get more information regarding its quality +(e.g. ``decimate_data()``, ``filter_data()``, ``plot_ch_info()`` methods). + +.. code:: python + + # import data files + set1 = np.load(get_sample_data(filename="set1.npy", folder="3SL")), allow_pickle=True) + set2 = np.load(get_sample_data(filename="set2.npy", folder="3SL")), allow_pickle=True) + set3 = np.load(get_sample_data(filename="set3.npy", folder="3SL")), allow_pickle=True) + + # list of datasets and reference indices + data = [set1, set2, set3] + ref_ind = [[0, 1, 2], [0, 1, 2], [0, 1, 2]] + + # Create multisetup + msp = MultiSetup_PreGER(fs=100, ref_ind=ref_ind, datasets=data) + + # decimate data + msp.decimate_data(q=2) + + # plot Time Histories of all channels for the selected datasets + msp.plot_data(data_idx=[2], nc=2) + + # Plot TH, PSD and KDE of the (selected) channels of the (selected) datasets + figs, axs = msp.plot_ch_info(data_idx=[1], ch_idx=[2]) + +.. figure:: /img/Ex4-Fig1.png + + +Again if we want to be able to plot the mode shapes later, then we +need to define the geometry of the structure. + +.. code:: python + + # Geometry 1 + _geo1 = get_sample_data(filename="Geo1.xlsx", folder="3SL") + # Geometry 2 + _geo2 = get_sample_data(filename="Geo2.xlsx", folder="3SL") + + # Define geometry1 + msp.def_geo1_by_file(_geo1) + # Define geometry 2 + msp.def_geo2_by_file(_geo2) + + +Now we need to instantiate the multi-setup versions of the algorithms +we wish to execute, such as ``SSIdat``. + + +.. code:: python + + # Initialise the algorithms + ssidat = SSIdat_MS(name="SSIdat", br=80, ordmax=80) + + # Add algorithms to the class + msp.add_algorithms(ssidat) + msp.run_all() + + # Plot + ssidat.plot_stab(freqlim=20) + +.. figure:: /img/Ex4-Fig2.png + + +After the algorithms have been executed we can exctract the desired +poles and plot the mode shapes. + +.. code:: python + + # get modal parameters + msp.mpe( + "SSIdat", + sel_freq=[2.63, 2.69, 3.43, 8.29, 8.42, 10.62, 14.00, 14.09, 17.57], + order_in=80) + + # plot mode shapes + msp.plot_mode_geo1(alg_res=SSIdat.result, mode_nr=1, view="3D", scaleF=2) + ssidat.plot_mode_geo2(geo2=msp.geo2, mode_nr=6, view="xy", scaleF=2) + +.. figure:: /img/Ex4-Fig3.png +.. figure:: /img/Ex4-Fig4.png + +.. code:: python + + ssidat.result.Fn + + >>> array([ 2.63102473, 2.69617968, 3.42605687, 8.27997956, 8.41882261, + 10.59171709, 13.96998337, 14.03397164, 17.49790384]) diff --git a/docs/Installation.rst b/docs/Installation.rst new file mode 100644 index 0000000..83b490c --- /dev/null +++ b/docs/Installation.rst @@ -0,0 +1,22 @@ +Installation +============ + +Install the library with pip: + +.. code:: console + + pip install pyOMA-2 + +or with conda/mamba: + +.. code:: console + + conda install pyOMA-2 + +You'll probably need to install **tk** for the GUI on your system, here some instructions: + +* `Windows `_ + +* `Linux `_ + +* `Mac `_ diff --git a/docs/Makefile b/docs/Makefile new file mode 100644 index 0000000..d4bb2cb --- /dev/null +++ b/docs/Makefile @@ -0,0 +1,20 @@ +# Minimal makefile for Sphinx documentation +# + +# You can set these variables from the command line, and also +# from the environment for the first two. +SPHINXOPTS ?= +SPHINXBUILD ?= sphinx-build +SOURCEDIR = . +BUILDDIR = _build + +# Put it first so that "make" without argument is like "make help". +help: + @$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) + +.PHONY: help Makefile + +# Catch-all target: route all unknown targets to Sphinx using the new +# "make mode" option. $(O) is meant as a shortcut for $(SPHINXOPTS). +%: Makefile + @$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) diff --git a/docs/conf.py b/docs/conf.py new file mode 100644 index 0000000..5dbcc03 --- /dev/null +++ b/docs/conf.py @@ -0,0 +1,111 @@ +# Configuration file for the Sphinx documentation builder. +# +# For the full list of built-in configuration values, see the documentation: +# https://www.sphinx-doc.org/en/master/usage/configuration.html +import os +import sys + +from pydantic import BaseModel +from sphinx.ext.autodoc import AttributeDocumenter, ClassDocumenter + +sys.path.insert(0, os.path.abspath("..")) +sys.path.insert(0, os.path.abspath("../")) +sys.path.insert(0, os.path.abspath("../src")) +sys.path.insert(0, os.path.abspath("../src/pyoma2")) + +# -- Project information ----------------------------------------------------- +# https://www.sphinx-doc.org/en/master/usage/configuration.html#project-information + +project = "pyoma2" +copyright = "2024, Dag Pasca" +author = "Dag Pasca" +release = "0.5.2" + + +### Code to exclude the docs from pydantic - start ### +class PydanticModelDocumenter(ClassDocumenter): + objtype = "pydantic_model" + directivetype = "class" + + @classmethod + def can_document_member(cls, member, membername, isattr, parent): + return isinstance(member, type) and issubclass(member, BaseModel) + + +# def add_directive_header(self, sig): +# super().add_directive_header(sig) +# self.add_line(' :show-inheritance:', self.get_sourcename()) + + +class PydanticAttributeDocumenter(AttributeDocumenter): + objtype = "pydantic_attribute" + directivetype = "attribute" + + @classmethod + def can_document_member(cls, member, membername, isattr, parent): + return ( + isattr + and isinstance(parent, type) + and issubclass(parent, BaseModel) + and membername in parent.__fields__ + ) + + +def setup(app): + app.add_autodocumenter(PydanticModelDocumenter) + app.add_autodocumenter(PydanticAttributeDocumenter) + + return { + "version": "0.1", + "parallel_read_safe": True, + "parallel_write_safe": True, + } + + +### Code to exclude the docs from pydantic - end ### + +# -- General configuration --------------------------------------------------- +# https://www.sphinx-doc.org/en/master/usage/configuration.html#general-configuration +extensions = [ + "sphinx.ext.duration", + "sphinx.ext.doctest", + "sphinx.ext.autodoc", + "sphinx.ext.autosummary", + "sphinx.ext.intersphinx", + "sphinx.ext.ifconfig", + "sphinx.ext.viewcode", + "sphinx.ext.githubpages", + "sphinx.ext.coverage", + "sphinx.ext.napoleon", + "nbsphinx", + "sphinx_rtd_theme", + # 'sphinxcontrib.bibtex', +] + +intersphinx_mapping = { + "python": ("https://docs.python.org/3/", None), + "sphinx": ("https://www.sphinx-doc.org/en/master/", None), +} +intersphinx_disabled_domains = ["std"] + +templates_path = ["_templates"] +exclude_patterns = ["_build", "Thumbs.db", ".DS_Store"] + +# -- Options for HTML output ------------------------------------------------- +# https://www.sphinx-doc.org/en/master/usage/configuration.html#options-for-html-output + +html_theme = "sphinx_rtd_theme" +html_static_path = ["_static"] + +# -- Options for EPUB output +epub_show_urls = "footnote" + +# Napoleon settings +napoleon_use_admonition_for_notes = True +napoleon_use_admonition_for_references = True + +# Autodoc configuration +autodoc_default_options = { + "special-members": "__init__", + "exclude-members": "model_computed_fields, model_config, model_fields", +} diff --git a/docs/docu/1 Setup Classes.rst b/docs/docu/1 Setup Classes.rst new file mode 100644 index 0000000..430841e --- /dev/null +++ b/docs/docu/1 Setup Classes.rst @@ -0,0 +1,43 @@ +Setup Classes +============= + +This module offers classes specifically designed for Operational Modal Analysis (OMA), +suitable for both single and multiple setup scenarios. The classes includes methods for +data management and processing, executing algorithms, visualizing outcomes, and setting +up the geometry of structures. The module utilises two methods when dealing with data +from multiple experimental setups: Post Separate Estimation Re-scaling (PoSER) [CRGF14]_, [RBCV15]_, +and Pre Global Estimation Re-scaling (PreGER) [MiDo11]_, [SARB21]_. + +Classes: + :class:`.SingleSetup` + Manages and processes single-setup data for OMA. + :class:`.MultiSetup_PoSER` + Conducts OMA for multi-setup experiments using the PoSER approach. + :class:`.MultiSetup_PreGER` + Conducts OMA for multi-setup experiments with the PreGER approach. + +.. Note:: + Users should be familiar with the concepts of modal analysis and system identification to effectively use this module. + +The ``SingleSetup`` class +------------------------- + +.. autoclass:: pyoma2.setup.single.SingleSetup + :members: + :inherited-members: + :show-inheritance: + +The ``MultiSetup_PoSER`` class +------------------------------ + +.. autoclass:: pyoma2.setup.multi.MultiSetup_PoSER + :members: + :show-inheritance: + +The ``MultiSetup_PreGER`` class +------------------------------- + +.. autoclass:: pyoma2.setup.multi.MultiSetup_PreGER + :members: + :inherited-members: + :show-inheritance: diff --git a/docs/docu/2_1 Algo_fdd.rst b/docs/docu/2_1 Algo_fdd.rst new file mode 100644 index 0000000..ab9e208 --- /dev/null +++ b/docs/docu/2_1 Algo_fdd.rst @@ -0,0 +1,69 @@ +The ``fdd`` algorithm module +============================ + +This module provides implementation of the Frequency Domain Decomposition (FDD) algorithm [BZA01]_, the Enhanced +Frequency Domain Decomposition (EFDD) algorithm [BVA01]_, and the Frequency Spatial Domain Decomposition (FSDD) +algorithm [ZWT10]_, along with their adaptations for multi-setup experimental data [SARB21]_. These algorithms +are used in structural dynamics to identify modal parameters such as natural frequencies, damping ratios, +and mode shapes from ambient vibration measurements. + +Classes: + :class:`.FDD` + Implements the basic FDD algorithm for single setup modal analysis. + :class:`.EFDD` + Extends ``FDD`` to provide Enhanced FDD analysis. + :class:`.FSDD` + Implements the Frequency-Spatial Domain Decomposition, a variant of EFDD. + :class:`.FDD_MS` + Adapts ``FDD`` for multi-setup modal analysis. + :class:`.EFDD_MS` + Extends ``EFDD`` for multi-setup scenarios. + +.. Important:: + Each class contains methods for executing the respective Frequency Domain Decomposition based + algorithm, extracting modal parameters, plotting results, and additional utilities relevant to + the specific FDD approach. + +.. Note:: + Users should be familiar with the concepts of modal analysis and system identification to effectively use this module. + + +The ``FDD`` class +---------------------- + +.. autoclass:: pyoma2.algorithms.fdd.FDD + :members: + :inherited-members: + :show-inheritance: + +The ``EFDD`` class +----------------------- + +.. autoclass:: pyoma2.algorithms.fdd.EFDD + :members: + :inherited-members: + :show-inheritance: + +The ``FSDD`` class +----------------------- + +.. autoclass:: pyoma2.algorithms.fdd.FSDD + :members: + :inherited-members: + :show-inheritance: + +The ``FDD_MS`` class +------------------------- + +.. autoclass:: pyoma2.algorithms.fdd.FDD_MS + :members: + :inherited-members: + :show-inheritance: + +The ``EFDD_MS`` class +-------------------------- + +.. autoclass:: pyoma2.algorithms.fdd.EFDD_MS + :members: + :inherited-members: + :show-inheritance: diff --git a/docs/docu/2_2 Algo_ssi.rst b/docs/docu/2_2 Algo_ssi.rst new file mode 100644 index 0000000..6f6663b --- /dev/null +++ b/docs/docu/2_2 Algo_ssi.rst @@ -0,0 +1,57 @@ +The ``ssi`` algorithm module +============================ + +This module implements the Stochastic Subspace Identification (SSI) [BPDG99]_, [MiDo11]_ algorithm in various forms, +tailored for both single and multiple experimental setup scenarios [MiDo11]_, [DOME13]_. It includes classes and methods +for conducting data-driven and covariance-driven SSI analyses, with optional uncertainty bounds estimation. + +Classes: + :class:`.SSIdat` + Implements the Data-Driven SSI algorithm for single setup. + :class:`.SSIcov` + Implements the Covariance-Driven SSI algorithm for single setup. + :class:`.SSIdat_MS` + Extends ``SSIdat`` for multi-setup experiments. + :class:`.SSIcov_MS` + Extends ``SSIdat_MS`` for covariance-based analysis in multi-setup experiments. + +.. Important:: + Each class contains methods for executing the SSI algorithm, extracting modal parameters, + plotting results, and additional utilities relevant to the specific SSI approach. + +.. Note:: + Users should be familiar with the concepts of modal analysis and system identification to effectively use this module. + + +The ``SSIdat`` class +------------------------- + +.. autoclass:: pyoma2.algorithms.ssi.SSIdat + :members: + :inherited-members: + :show-inheritance: + +The ``SSIcov`` class +------------------------- + +.. autoclass:: pyoma2.algorithms.ssi.SSIcov + :members: + :inherited-members: + :show-inheritance: + +The ``SSIdat_MS`` class +---------------------------- + +.. autoclass:: pyoma2.algorithms.ssi.SSIdat_MS + :members: + :inherited-members: + :show-inheritance: + + +The ``SSIcov_MS`` class +---------------------------- + +.. autoclass:: pyoma2.algorithms.ssi.SSIcov_MS + :members: + :inherited-members: + :show-inheritance: diff --git a/docs/docu/2_3 Algo_plscf.rst b/docs/docu/2_3 Algo_plscf.rst new file mode 100644 index 0000000..62a5d08 --- /dev/null +++ b/docs/docu/2_3 Algo_plscf.rst @@ -0,0 +1,37 @@ +The ``plscf`` algorithm module +============================== + +This module implements the Poly-reference Least Square Complex Frequency (pLSCF) algorithm [PAGL04]_, +a robust identification method in the frequency domain. It is specifically designed for both single and +multi-setup experimental scenarios. The module includes classes and methods for process measurement data, +extract modal parameters and visualisation tools. + +Classes: + :class:`.pLSCF` + Implements the Data-Driven SSI algorithm for single setup. + :class:`.pLSCF_MS` + Implements the Covariance-Driven SSI algorithm for single setup. + +.. Important:: + Each class contains methods for executing the pLSCF algorithm, extracting modal parameters, + plotting results, and additional utilities relevant to the specific approach. + +.. Note:: + Users should be familiar with the concepts of modal analysis and system identification to effectively use this module. + + +The ``pLSCF`` class +------------------------- + +.. autoclass:: pyoma2.algorithms.plscf.pLSCF + :members: + :inherited-members: + :show-inheritance: + +The ``pLSCF_MS`` class +------------------------- + +.. autoclass:: pyoma2.algorithms.plscf.pLSCF_MS + :members: + :inherited-members: + :show-inheritance: diff --git a/docs/docu/3 Support Classes.rst b/docs/docu/3 Support Classes.rst new file mode 100644 index 0000000..d7faa38 --- /dev/null +++ b/docs/docu/3 Support Classes.rst @@ -0,0 +1,19 @@ +Support classes +=============== + +.. Attention:: + These classes (and functions) are not instantiated or called directly by the users, but internally by the "main" classes. + + +.. toctree:: + :maxdepth: 1 + + 3_1 BaseSetup + 3_2 BaseAlgorithm + 3_3 geometry module + 3_4 result module + 3_5 run_param module + 3_6 sel_from_plot module + 3_7a mpl plotter + 3_7b pyvista plotter + 3_8 logging_handler diff --git a/docs/docu/3_1 BaseSetup.rst b/docs/docu/3_1 BaseSetup.rst new file mode 100644 index 0000000..1c4fb26 --- /dev/null +++ b/docs/docu/3_1 BaseSetup.rst @@ -0,0 +1,6 @@ +The ``BaseSetup`` class +----------------------- + +.. autoclass:: pyoma2.setup.base.BaseSetup + :members: + :show-inheritance: diff --git a/docs/docu/3_2 BaseAlgorithm.rst b/docs/docu/3_2 BaseAlgorithm.rst new file mode 100644 index 0000000..c90380a --- /dev/null +++ b/docs/docu/3_2 BaseAlgorithm.rst @@ -0,0 +1,6 @@ +The ``BaseAlgorithm`` class +--------------------------- + +.. autoclass:: pyoma2.algorithms.base.BaseAlgorithm + :members: + :show-inheritance: diff --git a/docs/docu/3_3 geometry module.rst b/docs/docu/3_3 geometry module.rst new file mode 100644 index 0000000..662d489 --- /dev/null +++ b/docs/docu/3_3 geometry module.rst @@ -0,0 +1,25 @@ +The ``geometry`` module +----------------------- + +This module provides classes for handling geometry-related data, specifically designed +to store and manipulate sensor and background geometry information. + +Classes: + :class:`.Geometry1` + Class for storing and managing sensor and background geometry data for Geometry 1. + :class:`.Geometry2` + Class for storing and managing sensor and background geometry data for Geometry 2. + :class:`.GeometryMixin` + Mixin that gives the ability to define the geometry the instance of the setup class. + +.. Warning:: + The module is designed to be used as part of the pyOMA2 package and relies on its + internal data structures and algorithms. + +.. automodule:: pyoma2.support.geometry.data + :members: + :show-inheritance: + +.. automodule:: pyoma2.support.geometry.mixin + :members: + :show-inheritance: diff --git a/docs/docu/3_4 result module.rst b/docs/docu/3_4 result module.rst new file mode 100644 index 0000000..4c31c15 --- /dev/null +++ b/docs/docu/3_4 result module.rst @@ -0,0 +1,12 @@ +The ``result`` module +--------------------- + +These classes are were the results of the analyses are stored. + +.. Warning:: + The module is designed to be used as part of the pyOMA2 package and relies on its + internal data structures and algorithms. + +.. automodule:: pyoma2.algorithms.data.result + :members: + :show-inheritance: diff --git a/docs/docu/3_5 run_param module.rst b/docs/docu/3_5 run_param module.rst new file mode 100644 index 0000000..0726c68 --- /dev/null +++ b/docs/docu/3_5 run_param module.rst @@ -0,0 +1,12 @@ +The ``run_params`` module +------------------------- + +These classes are were the parameters used to run the analyses are stored. + +.. Warning:: + The module is designed to be used as part of the pyOMA2 package and relies on its + internal data structures and algorithms. + +.. automodule:: pyoma2.algorithms.data.run_params + :members: + :show-inheritance: diff --git a/docs/docu/3_6 sel_from_plot module.rst b/docs/docu/3_6 sel_from_plot module.rst new file mode 100644 index 0000000..bc4d164 --- /dev/null +++ b/docs/docu/3_6 sel_from_plot module.rst @@ -0,0 +1,33 @@ +The ``sel_from_plot`` module +---------------------------- + +This module provides interactive plotting functionalities for selecting the mode to extract. +It is designed to work with Frequency Domain Decomposition (FDD) and Stochastic Subspace +Identification (SSI) algorithms, enabling users to visually inspect and interact with +stabilization charts and plots of the singular value of the PSD matrix. +The module integrates matplotlib plots into a Tkinter GUI, allowing for intuitive interaction +such as pole selection through mouse clicks and keyboard shortcuts. + +Classes: + :class:`.SelFromPlot`: A class for creating interactive plots where users can select or + deselect poles for further analysis in OMA. It supports various types + of plots (FDD, SSI, pLSCF) and provides utilities for saving figures, + toggling legends, and handling user inputs through a graphical interface. + +Key Features: + - Interactive selection of poles directly from stabilization charts and PSD plots. + - Compatibility with FDD, SSI, and pLSCF algorithm outputs. + - Integration of matplotlib plots within a Tkinter window for enhanced user interaction. + - Support for exporting plots and managing display settings like legends and pole visibility. + +References: + This module is inspired by and expands upon functionalities found in the pyEMA package [ZBGS20]_, + offering specialized features tailored for the pyOMA2 package's requirements. + +.. Warning:: + The module is designed to be used as part of the pyOMA2 package and relies on its + internal data structures and algorithms. + +.. automodule:: pyoma2.support.sel_from_plot + :members: + :show-inheritance: diff --git a/docs/docu/3_7a mpl plotter.rst b/docs/docu/3_7a mpl plotter.rst new file mode 100644 index 0000000..97e300f --- /dev/null +++ b/docs/docu/3_7a mpl plotter.rst @@ -0,0 +1,25 @@ +The ``mpl_plotter`` module +-------------------------- + +This module, part of the pyOMA2 package, is dedicated to visualising mode shapes +from Operational Modal Analysis (OMA) results. It provides an interface to create 3D +visualisations of mode shapes, integrating the geometry of the structure and the mode shape data +from OMA analysis. The module leverages `Matplotlib`'s capabilities to create visualizations that +can be interactively viewed or saved. + +Classes: + :class:`.Geo1MplPlotter`: A class to plot mode shapes in 3D specifically for geometry 1. + It takes geometry and result objects as inputs and provides functionalities to visualise + mode shapes with various customizable options such as scale factor, view type, and others. + + :class:`.Geo2MplPlotter`: A class to plot mode shapes in 3D specifically for geometry 2. + It takes geometry and result objects as inputs and provides functionalities to visualise + mode shapes with various customizable options such as scale factor, view type, and others. + +.. Warning:: + The module is designed for use within the pyOMA2 package. It requires OMA results and + geometry data specific to the structures being analyzed. + +.. automodule:: pyoma2.support.geometry.mpl_plotter + :members: + :show-inheritance: diff --git a/docs/docu/3_7b pyvista plotter.rst b/docs/docu/3_7b pyvista plotter.rst new file mode 100644 index 0000000..7441947 --- /dev/null +++ b/docs/docu/3_7b pyvista plotter.rst @@ -0,0 +1,21 @@ +The ``pyvista_plotter`` module +------------------------------ + +This module, part of the pyOMA2 package, provides tools for visualizing and +animating mode shapes derived from Operational Modal Analysis (OMA). It offers a flexible interface +to create interactive 3D visualizations of mode shapes, incorporating both structural geometry and +mode shape data from OMA results. The module leverages `PyVista` for rich 3D visualizations and +supports saving animations as GIFs. + +Classes: + :class:`.PvGeoPlotter`: A class to plot and animate mode shapes in 3D. + It takes geometry and result objects as inputs and provides functionalities to visualize mode + shapes with various customizable options such as scale factor, view type, and others. + +.. Warning:: + The module is designed for use within the pyOMA2 package. It requires OMA results and + geometry data specific to the structures being analyzed. + +.. automodule:: pyoma2.support.geometry.pyvista_plotter + :members: + :show-inheritance: diff --git a/docs/docu/3_8 logging_handler.rst b/docs/docu/3_8 logging_handler.rst new file mode 100644 index 0000000..24fe706 --- /dev/null +++ b/docs/docu/3_8 logging_handler.rst @@ -0,0 +1,4 @@ +The ``logging_handler`` module +------------------------------ + +.. autofunction:: pyoma2.support.utils.logging_handler.configure_logging diff --git a/docs/docu/4 Functions modules.rst b/docs/docu/4 Functions modules.rst new file mode 100644 index 0000000..3bddd84 --- /dev/null +++ b/docs/docu/4 Functions modules.rst @@ -0,0 +1,16 @@ +Functions module +================ + +The following functions are the "foundamental bricks" to perform the analyses. + +.. note:: + While these functions could be imported and used sequentially, doing so preclude access to interactive plotting features and mode animations. + +.. toctree:: + :maxdepth: 2 + + 4_1 fdd + 4_2 gen + 4_3 ssi + 4_4 plot + 4_5 plscf diff --git a/docs/docu/4_1 fdd.rst b/docs/docu/4_1 fdd.rst new file mode 100644 index 0000000..d9ee010 --- /dev/null +++ b/docs/docu/4_1 fdd.rst @@ -0,0 +1,18 @@ +The ``fdd`` module +------------------ + +This module is a part of the pyOMA2 package and provides utility functions for conducting +Operational Modal Analysis (OMA) using Frequency Domain Decomposition (FDD) algorithm [BZA01]_, Enhanced +Frequency Domain Decomposition (EFDD) algorithm [BVA01]_ and Frequency Spatial Domain Decomposition (FSDD) +algorithm [ZWT10]_. + +Functions: + - :func:`.SD_PreGER`: Estimates Power Spectral Density matrices for multi-setup experiments. + - :func:`.SD_est`: Computes Cross-Spectral Density using correlogram or periodogram methods. + - :func:`.SD_svalsvec`: Calculates singular values and vectors for Cross-Spectral Density matrices. + - :func:`.FDD_mpe`: Extracts modal parameters using the FDD method. + - :func:`.SDOF_bellandMS`: Utility function for EFDD and FSDD methods. + - :func:`.EFDD_mpe`: Extracts modal parameters using EFDD and FSDD methods. + +.. automodule:: pyoma2.functions.fdd + :members: diff --git a/docs/docu/4_2 gen.rst b/docs/docu/4_2 gen.rst new file mode 100644 index 0000000..117d0d4 --- /dev/null +++ b/docs/docu/4_2 gen.rst @@ -0,0 +1,39 @@ +The ``gen`` module +------------------ + +Part of the pyOMA2 package, this module provides general utility functions crucial for +implementational aspects of Operational Modal Analysis (OMA). These functions support +data preprocessing, mode shape merging, and key calculations such as the Modal Assurance +Criterion (MAC), Modal Scale Factor (MSF), and Modal Complexity Factor (MCF). + +Functions: + - :func:`.applymask`: Apply a mask to a list of arrays, filtering their values based on the mask. + - :func:`.HC_conj`: Apply Hard validation Criteria, complex conjugates. + - :func:`.HC_damp`: Apply Hard validation Criteria, damping. + - :func:`.HC_MPC`: Apply Hard validation Criteria, modal phase collinearity (MPC). + - :func:`.HC_MPD`: Apply Hard validation Criteria, modal phase deviation (MPD). + - :func:`.HC_CoV`: Apply Hard validation Criteria, Coefficient of Variation. + - :func:`.SC_apply`: Apply Soft validation Criteria. + - :func:`.dfphi_map_func`: Maps mode shapes to sensor locations and constraints. + - :func:`.check_on_geo1`: Validates geometry1 data. + - :func:`.check_on_geo2`: Validates geometry2 data. + - :func:`.flatten_sns_names`: Ensures that sensors names is in the correct form. + - :func:`.example_data`: Generates the example dataset. + - :func:`.merge_mode_shapes`: Merges mode shapes from different setups into a unified mode shape array. + - :func:`.MPC`: Calculate the Modal Phase Collinearity of a complex mode shape. + - :func:`.MPD`: Calculate the Mean Phase Deviation of a complex mode shape. + - :func:`.MSF`: Computes the Modal Scale Factor between two mode shape sets. + - :func:`.MCF`: Determines the complexity of mode shapes. + - :func:`.MAC`: Calculates the correlation between two sets of mode shapes. + - :func:`.pre_multisetup`: Preprocesses data from multiple setups, distinguishing between reference and moving sensors. + - :func:`.invperm`: Computes the inverse permutation of an array. + - :func:`.find_map`: Establishes a mapping between two arrays based on sorting order. + - :func:`.filter_data`: Apply a Butterworth filter to the input data. + - :func:`.save_to_file`: Save the specified setup instance to a file. + - :func:`.load_from_file`: Load a setup instance from a file. + - :func:`.read_excel_file`: Read an Excel file and return its contents as a dictionary. + + + +.. automodule:: pyoma2.functions.gen + :members: diff --git a/docs/docu/4_3 ssi.rst b/docs/docu/4_3 ssi.rst new file mode 100644 index 0000000..415739e --- /dev/null +++ b/docs/docu/4_3 ssi.rst @@ -0,0 +1,19 @@ +The ``ssi`` module +------------------ + +This module provides a collection of utility functions to support the implementation +of Stochastic Subspace Identification (SSI) algorithms [BPDG99]_, [MiDo11]_, [DOME13]_. +It includes functions for building Hankel matrices with various methods, converting +state-space representations to modal parameters,performing system identification using +SSI, and extracting modal parameters from identified systems. + +Functions: + - :func:`.build_hank`: Constructs a Hankel matrix from time series data. + - :func:`.SSI`: Performs system identification using the SSI method. + - :func:`.SSI_fast`: Efficient implementation of the SSI system identification. + - :func:`.SSI_poles`: Computes modal parameters from identified state-space models. + - :func:`.SSI_multi_setup`: SSI for multiple setup measurements. + - :func:`.SSI_mpe`: Extracts modal parameters for selected frequencies. + +.. automodule:: pyoma2.functions.ssi + :members: diff --git a/docs/docu/4_4 plot.rst b/docs/docu/4_4 plot.rst new file mode 100644 index 0000000..4718972 --- /dev/null +++ b/docs/docu/4_4 plot.rst @@ -0,0 +1,34 @@ +The ``plot`` module +------------------- + +This module, part of the pyOMA2 package, offers a suite of plotting functions +designed specifically for use within the pyOMA2 module. These functions aid in +visualizing modal analysis data, such as time histories, frequency responses, +and stabilization charts. They facilitate the intuitive interpretation of Operational +Modal Analysis (OMA) results. + +Functions: + - :func:`.plot_dtot_hist`: Plot a histogram of the total distance matrix. + - :func:`.adjust_alpha`: Adjust the alpha (opacity) of a given color. + - :func:`.rearrange_legend_elements`: Rearrange legend elements into a column-wise ordering. + - :func:`.freq_vs_damp_plot`: Plot frequency versus damping, with points grouped by clusters. + - :func:`.stab_clus_plot`: Plots a stabilization chart of the poles of a system with clusters. + - :func:`.CMIF_plot`: Visualizes the Complex Mode Indicator Function (CMIF). + - :func:`.EFDD_FIT_plot`: Presents detailed plots for EFDD and FSDD algorithms. + - :func:`.stab_plot`: Generates stabilization charts. + - :func:`.cluster_plot`: Visualizes frequency-damping clusters. + - :func:`.svalH_plot`: Plot the singular values of the Hankel matrix. + - :func:`.plt_nodes`: Function for plotting 3D geometrical representations. + - :func:`.plt_lines`: Function for plotting 3D geometrical representations. + - :func:`.plt_surf`: Function for plotting 3D geometrical representations. + - :func:`.plt_quiver`: Function for plotting 3D geometrical representations. + - :func:`.set_ax_options`: Utilities for customizing the appearance of 3D plots. + - :func:`.set_view`: Utilities for customizing the appearance of 3D plots. + - :func:`.plt_data`: Plots multi-channel time series data with RMS value inclusion. + - :func:`.plt_ch_info`: Generates comprehensive channel information plots. + - :func:`.STFT`: Perform the Short Time Fourier Transform (STFT) to generate spectrograms. + - :func:`.plot_mac_matrix`: Compute and plot the MAC matrix between the columns of two 2D arrays. + - :func:`.plot_mode_complexity`: Plot the complexity of a mode shape. + +.. automodule:: pyoma2.functions.plot + :members: diff --git a/docs/docu/4_5 plscf.rst b/docs/docu/4_5 plscf.rst new file mode 100644 index 0000000..f92a937 --- /dev/null +++ b/docs/docu/4_5 plscf.rst @@ -0,0 +1,16 @@ +The ``plscf`` module +-------------------- + +This module is a part of the pyOMA2 package and provides utility functions for conducting +Operational Modal Analysis (OMA) using the poly-reference Least Square Complex Frequency Domain (pLSCFD) +identification method, also known as polymax [PAGL04]_. + +Functions: + - :func:`.pLSCF`: Perform the poly-reference Least Square Complex Frequency (pLSCF) algorithm. + - :func:`.pLSCF_poles`: Extract poles from the pLSCF algorithm results. + - :func:`.rmfd2ac`: Convert Right Matrix Fraction Description to state-space representation. + - :func:`.ac2mp_poly`: Convert state-space representation to modal parameters. + - :func:`.pLSCF_mpe`: Extract modal parameters using the pLSCF method for selected frequencies. + +.. automodule:: pyoma2.functions.plscf + :members: diff --git a/docs/examples.rst b/docs/examples.rst new file mode 100644 index 0000000..3ca6f96 --- /dev/null +++ b/docs/examples.rst @@ -0,0 +1,10 @@ +Examples +======== + +.. toctree:: + :maxdepth: 2 + + Example1 - Getting started + Example2 - Real dataset + Example3 - Multisetup PoSER + Example4 - Multisetup PreGER diff --git a/docs/img/Ex1-Fig1.png b/docs/img/Ex1-Fig1.png new file mode 100644 index 0000000..dcd8853 Binary files /dev/null and b/docs/img/Ex1-Fig1.png differ diff --git a/docs/img/Ex1-Fig2.png b/docs/img/Ex1-Fig2.png new file mode 100644 index 0000000..51dddea Binary files /dev/null and b/docs/img/Ex1-Fig2.png differ diff --git a/docs/img/Ex1-Fig3.png b/docs/img/Ex1-Fig3.png new file mode 100644 index 0000000..7504975 Binary files /dev/null and b/docs/img/Ex1-Fig3.png differ diff --git a/docs/img/Ex2-Fig1.png b/docs/img/Ex2-Fig1.png new file mode 100644 index 0000000..955822a Binary files /dev/null and b/docs/img/Ex2-Fig1.png differ diff --git a/docs/img/Ex2-Fig10.png b/docs/img/Ex2-Fig10.png new file mode 100644 index 0000000..4ba5779 Binary files /dev/null and b/docs/img/Ex2-Fig10.png differ diff --git a/docs/img/Ex2-Fig11.png b/docs/img/Ex2-Fig11.png new file mode 100644 index 0000000..7b71e4a Binary files /dev/null and b/docs/img/Ex2-Fig11.png differ diff --git a/docs/img/Ex2-Fig12.png b/docs/img/Ex2-Fig12.png new file mode 100644 index 0000000..e7176d8 Binary files /dev/null and b/docs/img/Ex2-Fig12.png differ diff --git a/docs/img/Ex2-Fig13.png b/docs/img/Ex2-Fig13.png new file mode 100644 index 0000000..36986ab Binary files /dev/null and b/docs/img/Ex2-Fig13.png differ diff --git a/docs/img/Ex2-Fig14.png b/docs/img/Ex2-Fig14.png new file mode 100644 index 0000000..17f28d7 Binary files /dev/null and b/docs/img/Ex2-Fig14.png differ diff --git a/docs/img/Ex2-Fig15.gif b/docs/img/Ex2-Fig15.gif new file mode 100644 index 0000000..be9bb03 Binary files /dev/null and b/docs/img/Ex2-Fig15.gif differ diff --git a/docs/img/Ex2-Fig16.png b/docs/img/Ex2-Fig16.png new file mode 100644 index 0000000..81cabad Binary files /dev/null and b/docs/img/Ex2-Fig16.png differ diff --git a/docs/img/Ex2-Fig2.png b/docs/img/Ex2-Fig2.png new file mode 100644 index 0000000..970afc4 Binary files /dev/null and b/docs/img/Ex2-Fig2.png differ diff --git a/docs/img/Ex2-Fig3.png b/docs/img/Ex2-Fig3.png new file mode 100644 index 0000000..00ee6a7 Binary files /dev/null and b/docs/img/Ex2-Fig3.png differ diff --git a/docs/img/Ex2-Fig4.png b/docs/img/Ex2-Fig4.png new file mode 100644 index 0000000..9cfa6c0 Binary files /dev/null and b/docs/img/Ex2-Fig4.png differ diff --git a/docs/img/Ex2-Fig5.png b/docs/img/Ex2-Fig5.png new file mode 100644 index 0000000..0c0f5b6 Binary files /dev/null and b/docs/img/Ex2-Fig5.png differ diff --git a/docs/img/Ex2-Fig6.png b/docs/img/Ex2-Fig6.png new file mode 100644 index 0000000..4ef19cc Binary files /dev/null and b/docs/img/Ex2-Fig6.png differ diff --git a/docs/img/Ex2-Fig7.png b/docs/img/Ex2-Fig7.png new file mode 100644 index 0000000..311da1b Binary files /dev/null and b/docs/img/Ex2-Fig7.png differ diff --git a/docs/img/Ex2-Fig8.png b/docs/img/Ex2-Fig8.png new file mode 100644 index 0000000..5bc4103 Binary files /dev/null and b/docs/img/Ex2-Fig8.png differ diff --git a/docs/img/Ex2-Fig9.png b/docs/img/Ex2-Fig9.png new file mode 100644 index 0000000..706773e Binary files /dev/null and b/docs/img/Ex2-Fig9.png differ diff --git a/docs/img/Ex3-Fig1.png b/docs/img/Ex3-Fig1.png new file mode 100644 index 0000000..d5fd3ac Binary files /dev/null and b/docs/img/Ex3-Fig1.png differ diff --git a/docs/img/Ex3-Fig2.png b/docs/img/Ex3-Fig2.png new file mode 100644 index 0000000..8b0937c Binary files /dev/null and b/docs/img/Ex3-Fig2.png differ diff --git a/docs/img/Ex3-Fig3.png b/docs/img/Ex3-Fig3.png new file mode 100644 index 0000000..e63ee81 Binary files /dev/null and b/docs/img/Ex3-Fig3.png differ diff --git a/docs/img/Ex3-Fig4.png b/docs/img/Ex3-Fig4.png new file mode 100644 index 0000000..0cc3e63 Binary files /dev/null and b/docs/img/Ex3-Fig4.png differ diff --git a/docs/img/Ex3-Fig5.png b/docs/img/Ex3-Fig5.png new file mode 100644 index 0000000..d7777ed Binary files /dev/null and b/docs/img/Ex3-Fig5.png differ diff --git a/docs/img/Ex3-Fig6.png b/docs/img/Ex3-Fig6.png new file mode 100644 index 0000000..a7f51dc Binary files /dev/null and b/docs/img/Ex3-Fig6.png differ diff --git a/docs/img/Ex3-Fig7.gif b/docs/img/Ex3-Fig7.gif new file mode 100644 index 0000000..415d73f Binary files /dev/null and b/docs/img/Ex3-Fig7.gif differ diff --git a/docs/img/Ex4-Fig1.png b/docs/img/Ex4-Fig1.png new file mode 100644 index 0000000..9ba354f Binary files /dev/null and b/docs/img/Ex4-Fig1.png differ diff --git a/docs/img/Ex4-Fig2.png b/docs/img/Ex4-Fig2.png new file mode 100644 index 0000000..fa1ded2 Binary files /dev/null and b/docs/img/Ex4-Fig2.png differ diff --git a/docs/img/Ex4-Fig3.png b/docs/img/Ex4-Fig3.png new file mode 100644 index 0000000..b7fc752 Binary files /dev/null and b/docs/img/Ex4-Fig3.png differ diff --git a/docs/img/Ex4-Fig4.png b/docs/img/Ex4-Fig4.png new file mode 100644 index 0000000..9caf054 Binary files /dev/null and b/docs/img/Ex4-Fig4.png differ diff --git a/docs/img/info.svg b/docs/img/info.svg new file mode 100644 index 0000000..460fb58 --- /dev/null +++ b/docs/img/info.svg @@ -0,0 +1,4 @@ + + + +

pyoma2.setup.base

Abstract class

pyoma2.setup.base...

pyoma2.algorithms.base

BaseAlgorithm

Abstract class

pyoma2.algorithms.base...

pyoma2.setup.single

Single setup class

pyoma2.setup.single...

pyoma2.algorithms.fdd.

EFDD

EFDD algorithm class single setup 

pyoma2.algorithms.fdd....

pyoma2.algorithms.fdd.

EFDD_MS

EFDD algorithm class multi setup 

pyoma2.algorithms.fdd....

pyoma2.algorithms.fdd.

FDD

FDD algorithm class single setup 

pyoma2.algorithms.fdd....

pyoma2.algorithms.fdd.

FDD_MS

FDD algorithm class multi setup 

pyoma2.algorithms.fdd....

pyoma2.algorithms.fdd.

FSDD

FSDD algorithm class single setup
pyoma2.algorithms.fdd....

pyoma2.setup.multi

MultiSetup_poSER

Multiple setup class poSER

pyoma2.setup.multi...

pyoma2.setup.multi

MultiSetup_PreGER

Multiple setup class preGER

pyoma2.setup.multi...

pyoma2.algorithms.ssi.

SSIcov

SSIcov algorithm class single setup

pyoma2.algorithms.ssi....

pyoma2.algorithms.ssi.

SSIcov_MS

SSIcov algorithm class multi setup
pyoma2.algorithms.ssi....

pyoma2.algorithms.ssi.

SSIdat

SSIdat algorithm class single setup 

pyoma2.algorithms.ssi....

pyoma2.algorithms.ssi.

SSIdat_MS

SSIdat algorithm class multi setup 

pyoma2.algorithms.ssi....

pydantic.main.BaseModel

Abstract class

pydantic.main.BaseModel...

pyoma2.support.

sel_from_plot

Interactive mode selection class

pyoma2.support....

pyoma2.support.

utils

Utilities

pyoma2.support....

pyoma2.algorithms.data.

result.BaseResult

Abstract class

pyoma2.algorithms.data....

pyoma2.algorithms.data.

result.FDDResult

FDD results class

pyoma2.algorithms.data....

pyoma2.support.

geometry.plotter

Base plotter class 

pyoma2.support....

pyoma2.support.

geometry.mpl_plotter

Matplotlib mode shape plotter

pyoma2.support....

pyoma2.algorithms.data.

result.EFDDResult

EFDD/FSDD results class

pyoma2.algorithms.data....

pyoma2.algorithms.data.

result.pLSCFResult

pLSCF result class

pyoma2.algorithms.data....

pyoma2.algorithms.data.

result.SSIResult

SSI results class
pyoma2.algorithms.data....
LEVEL 1:
Setup classes
LEVEL 1:...
LEVEL 2:
Algorithm classes
LEVEL 2:...
LEVEL 3:
Support classes
LEVEL 3:...

pyoma2.algorithms.ssi.

pLSCF_MS

pLSCF algorithm class multi setup

pyoma2.algorithms.ssi....

pyoma2.algorithms.plscf.

pLSCF

pLSCF algorithm class single setup 

pyoma2.algorithms.plscf....

pyoma2.support.

geometry.pyvista_plotter

Pyvista mode shape plotter

pyoma2.support....

pyoma2.algorithms.data.

result.MsPoserResult

Multiple setup poSER result class

pyoma2.algorithms.data....

pyoma2.algorithms.data.

run_params.EFDDRunParams

EFDD/FSDD run parameters class

pyoma2.algorithms.data....

pyoma2.algorithms.data.

run_params.FDDRunParams

FDD run parameters class

pyoma2.algorithms.data....

pyoma2.algorithms.data.

run_params.SSIRunParams

SSI run parameters class

pyoma2.algorithms.data....

pyoma2.algorithms.data.

run_params.pLSCFRunParams

pLSCF run parameters class

pyoma2.algorithms.data....

pyoma2.support.

geometry.data

Class to manage geometry data

pyoma2.support....

pyoma2.support.

geometry.mixin

Mixin to manage methods for setup 

pyoma2.support....Text is not SVG - cannot display diff --git a/docs/index.rst b/docs/index.rst new file mode 100644 index 0000000..df2efe2 --- /dev/null +++ b/docs/index.rst @@ -0,0 +1,133 @@ +.. pyoma2 documentation master file, created by + sphinx-quickstart on Fri Feb 9 03:03:59 2024. + You can adapt this file completely to your liking, but it should at least + contain the root `toctree` directive. + +pyOMA2's documentation! +======================= + +.. image:: https://github.com/dagghe/pyOMA2/assets/64746269/aa19bc05-d452-4749-a404-b702e6fe685d + +|Python| |pre-commit| |Code style: black| |Downloads| |docs| + +This is the new and updated version of **pyOMA** module, a Python module designed for conducting +operational modal analysis. With this update, we've transformed **pyOMA** from a basic collection +of functions into a more sophisticated module that fully leverages the capabilities of Python classes. + +The module now supports analysis of both single and multi-setup data measurements, which includes +handling multiple acquisitions with a mix of reference and roving sensors. We've also introduced +interactive plots, allowing users to select desired modes for extraction directly from the plots +generated by the algorithms. Additionally, a new feature enables users to define the geometry of +the structures being tested, facilitating the visualization of mode shapes after modal results are +obtained. The underlying functions of these classes have been rigorously revised, resulting in +significant enhancements and optimizations. Since version 1.0.1, the uncertainty bounds of the +modal properties can also be estimated for the SSI family of algorithms. + +We provide four :doc:`examples` to show the modules capabilities: + + +Check out the project source_. + +.. note:: + + Please note that the project is still under active development. + + + +Schematic organisation of the module showing inheritance between classes +======================================================================== + +.. image:: /img/info.svg + + + +.. Hidden TOCs + +.. toctree:: + :caption: Quick start + :maxdepth: 2 + :hidden: + + Home + Installation + + +.. toctree:: + :caption: Documentation + :maxdepth: 2 + :hidden: + + Index + + +.. toctree:: + :caption: Examples + :maxdepth: 2 + :hidden: + + examples + +============================================================= + + +Index +===== + +* :ref:`genindex` +* :ref:`modindex` + + +References +========== + +.. [CRGF14] Rainieri, C., & Fabbrocino, G. (2014). Operational modal analysis of civil + engineering structures. Springer, New York, 142, 143. +.. [RBCV15] Brincker, R., & Ventura, C. (2015). Introduction to operational modal analysis. + John Wiley & Sons. +.. [BZA01] Brincker, R., Zhang, L., & Andersen, P. (2001). Modal identification of output-only + systems using frequency domain decomposition. Smart Materials and Structures, 10(3), 441. +.. [BVA01] Brincker, R., Ventura, C. E., & Andersen, P. (2001). Damping estimation by frequency + domain decomposition. In Proceedings of IMAC 19: A Conference on Structural Dynamics. +.. [ZWT10] Zhang, L., Wang, T., & Tamura, Y. (2010). A frequency–spatial domain decomposition + (FSDD) method for operational modal analysis. Mechanical Systems and Signal Processing, + 24(5), 1227-1239. +.. [ZBGS20] Zaletelj, K., Bregar, T., Gorjup, D., Slavič, J. (2020) sdypy-pyEMA, + 10.5281/zenodo.4016670, https://github.com/sdypy/sdypy +.. [BPDG99] Peeters, B., & De Roeck, G. (1999). Reference-based stochastic subspace + identification for output-only modal analysis. Mechanical Systems and + Signal Processing, 13(6), 855-878. +.. [MiDo11] Döhler, M. (2011). Subspace-based system identification and fault detection: + Algorithms for large systems and application to structural vibration analysis. + Diss. Université Rennes 1. +.. [DOME13] Döhler, M., & Mevel, L. (2013). Efficient multi-order uncertainty computation + for stochastic subspace identification. Mechanical Systems and Signal Processing, 38(2), 346-366. +.. [DLM13] Döhler, M., Lam, X. B., & Mevel, L. (2013). Uncertainty quantification for modal + parameters from stochastic subspace identification on multi-setup measurements. + Mechanical Systems and Signal Processing, 36(2), 562-581. +.. [SARB21] Amador, S. D., & Brincker, R. (2021). Robust multi-dataset identification with + frequency domain decomposition. Journal of Sound and Vibration, 508, 116207. +.. [PAGL04] Peeters, B., Van der Auweraer, H., Guillaume, P., & Leuridan, J. (2004). + The PolyMAX frequency-domain method: a new standard for modal parameter estimation?. + Shock and Vibration, 11(3-4), 395-409. + +.. _source: https://github.com/dagghe/pyOMA2 + +.. |Python| image:: https://img.shields.io/badge/python-3.8%20%7C%203.9%20%7C%203.10%20%7C%203.11%20%7C%203.12-blue.svg?style=flat&logo=python&logoColor=white + :alt: Python + :target: https://www.python.org + +.. |pre-commit| image:: https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&logoColor=white + :alt: pre-commit + :target: https://github.com/pre-commit/pre-commit + +.. |Code style: black| image:: https://img.shields.io/badge/code%20style-black-000000.svg + :alt: Code style: black + :target: https://img.shields.io/badge/code%20style-black-000000.svg + +.. |Downloads| image:: https://img.shields.io/pepy/dt/pyOMA-2 + :alt: Downloads + :target: https://img.shields.io/pepy/dt/pyOMA-2 + +.. |docs| image:: https://readthedocs.org/projects/pyoma/badge/?version=main + :target: https://pyoma.readthedocs.io/en/main/?badge=main + :alt: Documentation Status diff --git a/docs/make.bat b/docs/make.bat new file mode 100644 index 0000000..32bb245 --- /dev/null +++ b/docs/make.bat @@ -0,0 +1,35 @@ +@ECHO OFF + +pushd %~dp0 + +REM Command file for Sphinx documentation + +if "%SPHINXBUILD%" == "" ( + set SPHINXBUILD=sphinx-build +) +set SOURCEDIR=. +set BUILDDIR=_build + +%SPHINXBUILD% >NUL 2>NUL +if errorlevel 9009 ( + echo. + echo.The 'sphinx-build' command was not found. Make sure you have Sphinx + echo.installed, then set the SPHINXBUILD environment variable to point + echo.to the full path of the 'sphinx-build' executable. Alternatively you + echo.may add the Sphinx directory to PATH. + echo. + echo.If you don't have Sphinx installed, grab it from + echo.https://www.sphinx-doc.org/ + exit /b 1 +) + +if "%1" == "" goto help + +%SPHINXBUILD% -M %1 %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O% +goto end + +:help +%SPHINXBUILD% -M help %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O% + +:end +popd diff --git a/docs/modules.rst b/docs/modules.rst new file mode 100644 index 0000000..a18827f --- /dev/null +++ b/docs/modules.rst @@ -0,0 +1,24 @@ +.. autosummary:: + :toctree: generated + +========================== + User instantiated classes +========================== + +.. toctree:: + :maxdepth: 1 + + docu/1 Setup Classes + docu/2_1 Algo_fdd + docu/2_2 Algo_ssi + docu/2_3 Algo_plscf + +=============== +Support modules +=============== + +.. toctree:: + :maxdepth: 1 + + docu/3 Support Classes + docu/4 Functions modules diff --git a/docs/requirements.txt b/docs/requirements.txt new file mode 100644 index 0000000..63ab7ff --- /dev/null +++ b/docs/requirements.txt @@ -0,0 +1,4 @@ +sphinx==7.1.2 +sphinx-rtd-theme==1.3.0rc1 +nbsphinx==0.9.3 +git+https://github.com/dagghe/pyOMA2.git@main#egg=pyoma-2 diff --git a/paper/paper.bib b/paper/paper.bib new file mode 100644 index 0000000..15523ab --- /dev/null +++ b/paper/paper.bib @@ -0,0 +1,222 @@ +@article{amador2021robust, + title={Robust multi-dataset identification with frequency domain decomposition}, + author={Amador, Sandro DR and Brincker, Rune}, + journal={Journal of Sound and Vibration}, + volume={508}, + pages={116207}, + year={2021}, + publisher={Elsevier}, + doi={10.1016/j.jsv.2021.116207}, + url={https://doi.org/10.1016/j.jsv.2021.116207}, +} + +@article{peeters1999reference, + title={Reference-based stochastic subspace identification for output-only modal analysis}, + author={Peeters, Bart and De Roeck, Guido}, + journal={Mechanical systems and signal processing}, + volume={13}, + number={6}, + pages={855--878}, + year={1999}, + publisher={Elsevier}, + doi = {10.1006/mssp.1999.1249}, + url = {https://doi.org/10.1006/mssp.1999.1249}, +} + +@phdthesis{dohler2011subspace, + title={Subspace-based system identification and fault detection: Algorithms for large systems and application to structural vibration analysis}, + author={D{\"o}hler, Michael}, + year={2011}, + school={Universit{\'e} Rennes 1} +} + +@article{dohler2013efficient, + title={Efficient multi-order uncertainty computation for stochastic subspace identification}, + author={D{\"o}hler, Michael and Mevel, Laurent}, + journal={Mechanical Systems and Signal Processing}, + volume={38}, + number={2}, + pages={346--366}, + year={2013}, + publisher={Elsevier}, + doi = {10.1016/j.ymssp.2013.01.012}, + url = {https://doi.org/10.1016/j.ymssp.2013.01.012}, +} + +@article{peeters2004polymax, + title={The PolyMAX frequency-domain method: a new standard for modal parameter estimation?}, + author={Peeters, Bart and Van der Auweraer, Herman and Guillaume, Patrick and Leuridan, Jan}, + journal={Shock and Vibration}, + volume={11}, + number={3-4}, + pages={395--409}, + year={2004}, + publisher={IOS Press}, + doi = {10.1155/2004/523692}, + url = {https://doi.org/10.1155/2004/523692}, +} + +@article{brincker2001modal, + title={Modal identification of output-only systems using frequency domain decomposition}, + author={Brincker, Rune and Zhang, Lingmi and Andersen, Palle}, + journal={Smart materials and structures}, + volume={10}, + number={3}, + pages={441}, + year={2001}, + publisher={IOP Publishing} +} + +@inproceedings{brincker2001damping, + title={Damping estimation by frequency domain decomposition}, + author={Brincker, Rune and Ventura, Carlos E and Andersen, Palle}, + booktitle={Proceedings of IMAC 19: A Conference on Structural Dynamics: februar 5-8, 2001, Hyatt Orlando, Kissimmee, Florida, 2001}, + pages={698--703}, + year={2001}, + organization={Society for Experimental Mechanics} +} + +@article{zhang2010frequency, + title={A frequency--spatial domain decomposition (FSDD) method for operational modal analysis}, + author={Zhang, Lingmi and Wang, Tong and Tamura, Yukio}, + journal={Mechanical systems and signal processing}, + volume={24}, + number={5}, + pages={1227--1239}, + year={2010}, + publisher={Elsevier}, + doi={10.1016/j.ymssp.2009.10.024}, + url={https://doi.org/10.1016/j.ymssp.2009.10.024}, +} + +@book{brincker2015introduction, + title={Introduction to operational modal analysis}, + author={Brincker, Rune and Ventura, Carlos}, + year={2015}, + publisher={John Wiley \& Sons} +} + +@article{rainieri2014operational, + title={Operational modal analysis of civil engineering structures}, + author={Rainieri, Carlo and Fabbrocino, Giovanni}, + journal={Springer, New York}, + volume={142}, + pages={143}, + year={2014}, + publisher={Springer}, + doi={10.1007/978-1-4939-0767-0}, + url={https://doi.org/10.1007/978-1-4939-0767-0}, +} + +@article{reynders2012system, + title={System identification methods for (operational) modal analysis: review and comparison}, + author={Reynders, Edwin}, + journal={Archives of Computational Methods in Engineering}, + volume={19}, + pages={51--124}, + year={2012}, + publisher={Springer}, + doi={10.1007/s11831-012-9069-x}, + url={https://doi.org/10.1007/s11831-012-9069-x}, +} + +@book{van2012subspace, + title={Subspace identification for linear systems: Theory—Implementation—Applications}, + author={Van Overschee, Peter and De Moor, BL0888}, + year={2012}, + publisher={Springer Science \& Business Media} +} + +@article{dohler2013uncertainty, + title={Uncertainty quantification for modal parameters from stochastic subspace identification on multi-setup measurements}, + author={D{\"o}hler, Michael and Lam, Xuan-Binh and Mevel, Laurent}, + journal={Mechanical Systems and Signal Processing}, + volume={36}, + number={2}, + pages={562--581}, + year={2013}, + publisher={Elsevier}, + doi={10.1016/j.ymssp.2012.11.011}, + url={https://doi.org/10.1016/j.ymssp.2012.11.011}, +} + + +% +@article{alaggio2021two, + title={Two-years static and dynamic monitoring of the santa maria di collemaggio basilica}, + author={Alaggio, Rocco and Aloisio, Angelo and Antonacci, Elena and Cirella, Riccardo}, + journal={Construction and Building Materials}, + volume={268}, + pages={121069}, + year={2021}, + publisher={Elsevier}, + doi={10.1016/j.conbuildmat.2020.121069}, + url={https://doi.org/10.1016/j.conbuildmat.2020.121069}, +} + +@article{aloisio2020dynamic, + title={Dynamic identification and model updating of an eight-storey CLT building}, + author={Aloisio, Angelo and Pasca, Dag and Tomasi, Roberto and Fragiacomo, Massimo}, + journal={Engineering Structures}, + volume={213}, + pages={110593}, + year={2020}, + publisher={Elsevier}, + doi={10.1016/j.engstruct.2020.110593}, + url={https://doi.org/10.1016/j.engstruct.2020.110593}, +} + +@article{simoncelli2023intensity, + title={Intensity and location of corrosion on the reliability of a steel bridge}, + author={Simoncelli, Marco and Aloisio, Angelo and Zucca, Marco and Venturi, Giorgia and Alaggio, Rocco}, + journal={Journal of Constructional Steel Research}, + volume={206}, + pages={107937}, + year={2023}, + publisher={Elsevier}, + doi={10.1016/j.jcsr.2023.107937}, + url={https://doi.org/10.1016/j.jcsr.2023.107937}, +} + +@article{saharan2023convolutional, + title={Convolutional neural network--based structural health monitoring framework for wind turbine blade}, + author={Saharan, Nisha and Kumar, Pardeep and Pal, Joy}, + journal={Journal of Vibration and Control}, + pages={10775463231213423}, + year={2023}, + publisher={SAGE Publications Sage UK: London, England}, + doi={10.1177/10775463231213423}, + url={https://doi.org/10.1177/10775463231213423}, +} + +@inproceedings{croce2023towards, + title={Towards a Cloud-Based Platform for Structural Health Monitoring: Implementation and Numerical Issues}, + author={Croce, Tiziana and Girardi, Maria and Gurioli, Gianmarco and Padovani, Cristina and Pellegrini, Daniele}, + booktitle={International Conference on Experimental Vibration Analysis for Civil Engineering Structures}, + pages={610--619}, + year={2023}, + organization={Springer} +} + +@inproceedings{abuodeh2023examining, + title={Examining Methods for Modeling Road Surface Roughness Effects in Vehicle--Bridge Interaction Models via Physical Testing}, + author={Abuodeh, Omar and Locke, William and Redmond, Laura and Sreenivasulu, Rakesh Vulchi and Schmid, Matthias}, + booktitle={Society for Experimental Mechanics Annual Conference and Exposition}, + pages={33--47}, + year={2023}, + organization={Springer}, + doi={10.1007/978-3-031-36663-5_5}, + url={https://doi.org/10.1007/978-3-031-36663-5_5}, +} + +@inproceedings{talebi2023interoperability, + title={Interoperability between BIM and FEM for vibration-based model updating of a pedestrian bridge}, + author={Talebi, Aliasghar and Potenza, Francesco and Gattulli, Vincenzo}, + booktitle={Structures}, + volume={53}, + pages={1092--1107}, + year={2023}, + organization={Elsevier}, + doi={10.1016/j.istruc.2023.04.115}, + url={https://doi.org/10.1016/j.istruc.2023.04.115}, +} diff --git a/paper/paper.md b/paper/paper.md new file mode 100644 index 0000000..31b8884 --- /dev/null +++ b/paper/paper.md @@ -0,0 +1,103 @@ +--- +title: 'pyOMA2: A Python module for conducting operational modal analysis' +tags: + - Python + - operational modal analysis + - dynamics of structures + - system identification + - ambient vibrations +authors: + - name: Dag P. Pasca + orcid: 0000-0002-3830-2835 + corresponding: true + affiliation: "1" + - name: Diego Federico Margoni + affiliation: 2 +affiliations: + - name: Norsk Treteknisk Institutt, Oslo, Norway + index: 1 + - name: Politecnico di Torino, Italy + index: 2 + +date: 12 September 2024 +bibliography: paper.bib +--- + +# Summary + +Operational Modal Analysis (OMA) has garnered considerable attention from +the engineering community in recent years and has established itself as +the preferred method for estimating the modal properties of structures in +Structural Health Monitoring (SHM), particularly in civil engineering. +The key advantage of OMA over Experimental Modal Analysis (EMA) is its +ability to derive modal parameters solely from output measurements taken +during the structure's normal operation. This makes OMA a more practical +and efficient approach, as opposed to the traditional EMA, which requires +both input and output data. + +# Statement of need +`pyOMA2` is the latest and improved version of the pyOMA module, a Python +library specifically designed for conducting operational modal analysis. +It fully utilises Python's object-oriented capabilities to offer a +comprehensive suite of tools for performing OMA. + +The module supports both single and multi-setup data measurements, enabling +users to handle multiple acquisitions that combine reference and roving +sensors. It is user-friendly and provides a range of tools for pre-processing +and visualising data. A key enhancement is the introduction of interactive +plots, allowing users to select the desired modes directly from +algorithm-generated graphs. Additionally, a new feature enables users to +define the geometry of tested structures, facilitating the visualisation +of mode shapes. + +The following algorithm are included in the module: +- Frequency domain decomposition (FDD); +- Enhanced frequency domain decomposition (EFDD); +- Frequency spatial domain decomposition (FSDD); +- Reference based covariance driven stochastic subspace identification (SSIcov); +- Reference based data driven stochastic subspace identification (SSIdat); +- Poly-reference Least Square Frequency Domain (pLSCF); + +For the readers seeking a more comprehensive understanding of the algorithms +and the underlying theory, a wealth of literature is available for consultation. +Key references include works by Brincker +[@brincker2001modal;@brincker2015introduction;@brincker2001damping], +Zhang [@zhang2010frequency], Peeters [@peeters2004polymax;@peeters1999reference], +Van Overschee and De Moor [@van2012subspace], Reynders [@reynders2012system], +Rainieri and Fabbrocino [@rainieri2014operational], Amador [@amador2021robust], +Döhler [@dohler2011subspace,dohler2013efficient,dohler2013uncertainty], and others. + +The module's reliability and applicability for research purposes have been +demonstrated by the authors through various studies, such as +[@alaggio2021two;@aloisio2020dynamic;@simoncelli2023intensity]. +Additionally, the module has gained traction within the research community, +as evidenced by its use in studies by +[@saharan2023convolutional;@croce2023towards;@talebi2023interoperability;@abuodeh2023examining], and others. + +# Module's structure. +The module is structured into three primary levels: +1. At the first level are the `setup` classes. Users instantiate these classes by providing a data array and the sampling frequency for a single setup scenario, or a list of data arrays and their respective sampling frequencies, and reference indices, for a multi-setup scenario. +2. The second level comprises the `algorithms` classes. Users can instantiate the algorithms they wish to run and then add them to the setup class. +3. The third level contains the `support` classes, which serve as auxiliary components to the first two levels. This level includes various specialized classes: + * `result` classes, where outcomes are stored. + * `geometry` classes, for storing geometric data. + * `run_param` classes, where parameters used for running the algorithms are kept. + * Dedicated classes for animating mode shapes and interacting with plots generated by the algorithm classes. + +In addition to the levels depicted in the figure, there is a further +level not shown, comprised of the set of functions internally called +by the class methods. Many of these functions represent an updated +version of those available in our previous release, `pyOMA`. + +![Schematic organisation of the module showing inheritance between classes](../docs/img/info.svg) + +# Documentation +A comprehensive documentation for `pyOMA2`, including examples, is available at +[https://pyoma.readthedocs.io/en/main/](https://pyoma.readthedocs.io/en/main/). + + +# Acknowledgements + +We acknowledge contributions from Angelo Aloisio and Marco Martino Rosso. + +# References diff --git a/pdm-py38macos.lock b/pdm-py38macos.lock new file mode 100644 index 0000000..e7e5a57 --- /dev/null +++ b/pdm-py38macos.lock @@ -0,0 +1,2940 @@ +# This file is @generated by PDM. +# It is not intended for manual editing. + +[metadata] +groups = ["default", "docs", "openpyxl", "pyvista", "qa"] +strategy = ["inherit_metadata"] +lock_version = "4.5.0" +content_hash = "sha256:22cd5aee3b297d0bb4e82486997918f7af7cd34c35252bce0aa0be1ee01bc0c1" + +[[metadata.targets]] +requires_python = "==3.8.*" +platform = "macos_12_0_arm64" + +[[package]] +name = "aiohappyeyeballs" +version = "2.4.0" +requires_python = ">=3.8" +summary = "Happy Eyeballs for asyncio" +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +files = [ + {file = "aiohappyeyeballs-2.4.0-py3-none-any.whl", hash = "sha256:7ce92076e249169a13c2f49320d1967425eaf1f407522d707d59cac7628d62bd"}, + {file = "aiohappyeyeballs-2.4.0.tar.gz", hash = "sha256:55a1714f084e63d49639800f95716da97a1f173d46a16dfcfda0016abb93b6b2"}, +] + +[[package]] +name = "aiohttp" +version = "3.10.11" +requires_python = ">=3.8" +summary = "Async http client/server framework (asyncio)" +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +dependencies = [ + "aiohappyeyeballs>=2.3.0", + "aiosignal>=1.1.2", + "async-timeout<6.0,>=4.0; python_version < \"3.11\"", + "attrs>=17.3.0", + "frozenlist>=1.1.1", + "multidict<7.0,>=4.5", + "yarl<2.0,>=1.12.0", +] +files = [ + {file = "aiohttp-3.10.11-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:74baf1a7d948b3d640badeac333af581a367ab916b37e44cf90a0334157cdfd2"}, + {file = "aiohttp-3.10.11-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:c2f746a6968c54ab2186574e15c3f14f3e7f67aef12b761e043b33b89c5b5f95"}, + {file = "aiohttp-3.10.11.tar.gz", hash = "sha256:9dc2b8f3dcab2e39e0fa309c8da50c3b55e6f34ab25f1a71d3288f24924d33a7"}, +] + +[[package]] +name = "aiosignal" +version = "1.3.1" +requires_python = ">=3.7" +summary = "aiosignal: a list of registered asynchronous callbacks" +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +dependencies = [ + "frozenlist>=1.1.0", +] +files = [ + {file = "aiosignal-1.3.1-py3-none-any.whl", hash = "sha256:f8376fb07dd1e86a584e4fcdec80b36b7f81aac666ebc724e2c090300dd83b17"}, + {file = "aiosignal-1.3.1.tar.gz", hash = "sha256:54cd96e15e1649b75d6c87526a6ff0b6c1b0dd3459f43d9ca11d48c339b68cfc"}, +] + +[[package]] +name = "alabaster" +version = "0.7.13" +requires_python = ">=3.6" +summary = "A configurable sidebar-enabled Sphinx theme" +groups = ["docs"] +marker = "python_version == \"3.8\"" +files = [ + {file = "alabaster-0.7.13-py3-none-any.whl", hash = "sha256:1ee19aca801bbabb5ba3f5f258e4422dfa86f82f3e9cefb0859b283cdd7f62a3"}, + {file = "alabaster-0.7.13.tar.gz", hash = "sha256:a27a4a084d5e690e16e01e03ad2b2e552c61a65469419b907243193de1a84ae2"}, +] + +[[package]] +name = "annotated-types" +version = "0.7.0" +requires_python = ">=3.8" +summary = "Reusable constraint types to use with typing.Annotated" +groups = ["default"] +marker = "python_version == \"3.8\"" +dependencies = [ + "typing-extensions>=4.0.0; python_version < \"3.9\"", +] +files = [ + {file = "annotated_types-0.7.0-py3-none-any.whl", hash = "sha256:1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53"}, + {file = "annotated_types-0.7.0.tar.gz", hash = "sha256:aff07c09a53a08bc8cfccb9c85b05f1aa9a2a6f23728d790723543408344ce89"}, +] + +[[package]] +name = "anyio" +version = "4.4.0" +requires_python = ">=3.8" +summary = "High level compatibility layer for multiple asynchronous event loop implementations" +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "exceptiongroup>=1.0.2; python_version < \"3.11\"", + "idna>=2.8", + "sniffio>=1.1", + "typing-extensions>=4.1; python_version < \"3.11\"", +] +files = [ + {file = "anyio-4.4.0-py3-none-any.whl", hash = "sha256:c1b2d8f46a8a812513012e1107cb0e68c17159a7a594208005a57dc776e1bdc7"}, + {file = "anyio-4.4.0.tar.gz", hash = "sha256:5aadc6a1bbb7cdb0bede386cac5e2940f5e2ff3aa20277e991cf028e0585ce94"}, +] + +[[package]] +name = "appnope" +version = "0.1.4" +requires_python = ">=3.6" +summary = "Disable App Nap on macOS >= 10.9" +groups = ["pyvista", "qa"] +marker = "platform_system == \"Darwin\" and python_version == \"3.8\" or sys_platform == \"darwin\" and python_version == \"3.8\"" +files = [ + {file = "appnope-0.1.4-py2.py3-none-any.whl", hash = "sha256:502575ee11cd7a28c0205f379b525beefebab9d161b7c964670864014ed7213c"}, + {file = "appnope-0.1.4.tar.gz", hash = "sha256:1de3860566df9caf38f01f86f65e0e13e379af54f9e4bee1e66b48f2efffd1ee"}, +] + +[[package]] +name = "argon2-cffi" +version = "23.1.0" +requires_python = ">=3.7" +summary = "Argon2 for Python" +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "argon2-cffi-bindings", + "typing-extensions; python_version < \"3.8\"", +] +files = [ + {file = "argon2_cffi-23.1.0-py3-none-any.whl", hash = "sha256:c670642b78ba29641818ab2e68bd4e6a78ba53b7eff7b4c3815ae16abf91c7ea"}, + {file = "argon2_cffi-23.1.0.tar.gz", hash = "sha256:879c3e79a2729ce768ebb7d36d4609e3a78a4ca2ec3a9f12286ca057e3d0db08"}, +] + +[[package]] +name = "argon2-cffi-bindings" +version = "21.2.0" +requires_python = ">=3.6" +summary = "Low-level CFFI bindings for Argon2" +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "cffi>=1.0.1", +] +files = [ + {file = "argon2-cffi-bindings-21.2.0.tar.gz", hash = "sha256:bb89ceffa6c791807d1305ceb77dbfacc5aa499891d2c55661c6459651fc39e3"}, + {file = "argon2_cffi_bindings-21.2.0-cp38-abi3-macosx_10_9_universal2.whl", hash = "sha256:e415e3f62c8d124ee16018e491a009937f8cf7ebf5eb430ffc5de21b900dad93"}, +] + +[[package]] +name = "arrow" +version = "1.3.0" +requires_python = ">=3.8" +summary = "Better dates & times for Python" +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "python-dateutil>=2.7.0", + "types-python-dateutil>=2.8.10", +] +files = [ + {file = "arrow-1.3.0-py3-none-any.whl", hash = "sha256:c728b120ebc00eb84e01882a6f5e7927a53960aa990ce7dd2b10f39005a67f80"}, + {file = "arrow-1.3.0.tar.gz", hash = "sha256:d4540617648cb5f895730f1ad8c82a65f2dad0166f57b75f3ca54759c4d67a85"}, +] + +[[package]] +name = "asttokens" +version = "2.4.1" +summary = "Annotate AST trees with source code positions" +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "six>=1.12.0", + "typing; python_version < \"3.5\"", +] +files = [ + {file = "asttokens-2.4.1-py2.py3-none-any.whl", hash = "sha256:051ed49c3dcae8913ea7cd08e46a606dba30b79993209636c4875bc1d637bc24"}, + {file = "asttokens-2.4.1.tar.gz", hash = "sha256:b03869718ba9a6eb027e134bfdf69f38a236d681c83c160d510768af11254ba0"}, +] + +[[package]] +name = "async-lru" +version = "2.0.4" +requires_python = ">=3.8" +summary = "Simple LRU cache for asyncio" +groups = ["qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "typing-extensions>=4.0.0; python_version < \"3.11\"", +] +files = [ + {file = "async-lru-2.0.4.tar.gz", hash = "sha256:b8a59a5df60805ff63220b2a0c5b5393da5521b113cd5465a44eb037d81a5627"}, + {file = "async_lru-2.0.4-py3-none-any.whl", hash = "sha256:ff02944ce3c288c5be660c42dbcca0742b32c3b279d6dceda655190240b99224"}, +] + +[[package]] +name = "async-timeout" +version = "4.0.3" +requires_python = ">=3.7" +summary = "Timeout context manager for asyncio programs" +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +dependencies = [ + "typing-extensions>=3.6.5; python_version < \"3.8\"", +] +files = [ + {file = "async-timeout-4.0.3.tar.gz", hash = "sha256:4640d96be84d82d02ed59ea2b7105a0f7b33abe8703703cd0ab0bf87c427522f"}, + {file = "async_timeout-4.0.3-py3-none-any.whl", hash = "sha256:7405140ff1230c310e51dc27b3145b9092d659ce68ff733fb0cefe3ee42be028"}, +] + +[[package]] +name = "attrs" +version = "24.2.0" +requires_python = ">=3.7" +summary = "Classes Without Boilerplate" +groups = ["docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "importlib-metadata; python_version < \"3.8\"", +] +files = [ + {file = "attrs-24.2.0-py3-none-any.whl", hash = "sha256:81921eb96de3191c8258c199618104dd27ac608d9366f5e35d011eae1867ede2"}, + {file = "attrs-24.2.0.tar.gz", hash = "sha256:5cfb1b9148b5b086569baec03f20d7b6bf3bcacc9a42bebf87ffaaca362f6346"}, +] + +[[package]] +name = "babel" +version = "2.16.0" +requires_python = ">=3.8" +summary = "Internationalization utilities" +groups = ["docs", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "pytz>=2015.7; python_version < \"3.9\"", +] +files = [ + {file = "babel-2.16.0-py3-none-any.whl", hash = "sha256:368b5b98b37c06b7daf6696391c3240c938b37767d4584413e8438c5c435fa8b"}, + {file = "babel-2.16.0.tar.gz", hash = "sha256:d1f3554ca26605fe173f3de0c65f750f5a42f924499bf134de6423582298e316"}, +] + +[[package]] +name = "backcall" +version = "0.2.0" +summary = "Specifications for callback functions passed in to an API" +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "backcall-0.2.0-py2.py3-none-any.whl", hash = "sha256:fbbce6a29f263178a1f7915c1940bde0ec2b2a967566fe1c65c1dfb7422bd255"}, + {file = "backcall-0.2.0.tar.gz", hash = "sha256:5cbdbf27be5e7cfadb448baf0aa95508f91f2bbc6c6437cd9cd06e2a4c215e1e"}, +] + +[[package]] +name = "beautifulsoup4" +version = "4.12.3" +requires_python = ">=3.6.0" +summary = "Screen-scraping library" +groups = ["docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "soupsieve>1.2", +] +files = [ + {file = "beautifulsoup4-4.12.3-py3-none-any.whl", hash = "sha256:b80878c9f40111313e55da8ba20bdba06d8fa3969fc68304167741bbf9e082ed"}, + {file = "beautifulsoup4-4.12.3.tar.gz", hash = "sha256:74e3d1928edc070d21748185c46e3fb33490f22f52a3addee9aee0f4f7781051"}, +] + +[[package]] +name = "bleach" +version = "6.1.0" +requires_python = ">=3.8" +summary = "An easy safelist-based HTML-sanitizing tool." +groups = ["docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "six>=1.9.0", + "webencodings", +] +files = [ + {file = "bleach-6.1.0-py3-none-any.whl", hash = "sha256:3225f354cfc436b9789c66c4ee030194bee0568fbf9cbdad3bc8b5c26c5f12b6"}, + {file = "bleach-6.1.0.tar.gz", hash = "sha256:0a31f1837963c41d46bbf1331b8778e1308ea0791db03cc4e7357b97cf42a8fe"}, +] + +[[package]] +name = "bleach" +version = "6.1.0" +extras = ["css"] +requires_python = ">=3.8" +summary = "An easy safelist-based HTML-sanitizing tool." +groups = ["docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "bleach==6.1.0", + "tinycss2<1.3,>=1.1.0", +] +files = [ + {file = "bleach-6.1.0-py3-none-any.whl", hash = "sha256:3225f354cfc436b9789c66c4ee030194bee0568fbf9cbdad3bc8b5c26c5f12b6"}, + {file = "bleach-6.1.0.tar.gz", hash = "sha256:0a31f1837963c41d46bbf1331b8778e1308ea0791db03cc4e7357b97cf42a8fe"}, +] + +[[package]] +name = "cachetools" +version = "5.5.0" +requires_python = ">=3.7" +summary = "Extensible memoizing collections and decorators" +groups = ["qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "cachetools-5.5.0-py3-none-any.whl", hash = "sha256:02134e8439cdc2ffb62023ce1debca2944c3f289d66bb17ead3ab3dede74b292"}, + {file = "cachetools-5.5.0.tar.gz", hash = "sha256:2cc24fb4cbe39633fb7badd9db9ca6295d766d9c2995f245725a46715d050f2a"}, +] + +[[package]] +name = "certifi" +version = "2024.8.30" +requires_python = ">=3.6" +summary = "Python package for providing Mozilla's CA Bundle." +groups = ["docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "certifi-2024.8.30-py3-none-any.whl", hash = "sha256:922820b53db7a7257ffbda3f597266d435245903d80737e34f8a45ff3e3230d8"}, + {file = "certifi-2024.8.30.tar.gz", hash = "sha256:bec941d2aa8195e248a60b31ff9f0558284cf01a52591ceda73ea9afffd69fd9"}, +] + +[[package]] +name = "cffi" +version = "1.17.1" +requires_python = ">=3.8" +summary = "Foreign Function Interface for Python calling C code." +groups = ["docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "pycparser", +] +files = [ + {file = "cffi-1.17.1.tar.gz", hash = "sha256:1c39c6016c32bc48dd54561950ebd6836e1670f2ae46128f67cf49e789c52824"}, +] + +[[package]] +name = "cfgv" +version = "3.4.0" +requires_python = ">=3.8" +summary = "Validate configuration and produce human readable error messages." +groups = ["qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "cfgv-3.4.0-py2.py3-none-any.whl", hash = "sha256:b7265b1f29fd3316bfcd2b330d63d024f2bfd8bcb8b0272f8e19a504856c48f9"}, + {file = "cfgv-3.4.0.tar.gz", hash = "sha256:e52591d4c5f5dead8e0f673fb16db7949d2cfb3f7da4582893288f0ded8fe560"}, +] + +[[package]] +name = "chardet" +version = "5.2.0" +requires_python = ">=3.7" +summary = "Universal encoding detector for Python 3" +groups = ["qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "chardet-5.2.0-py3-none-any.whl", hash = "sha256:e1cf59446890a00105fe7b7912492ea04b6e6f06d4b742b2c788469e34c82970"}, + {file = "chardet-5.2.0.tar.gz", hash = "sha256:1b3b6ff479a8c414bc3fa2c0852995695c4a026dcd6d0633b2dd092ca39c1cf7"}, +] + +[[package]] +name = "charset-normalizer" +version = "3.3.2" +requires_python = ">=3.7.0" +summary = "The Real First Universal Charset Detector. Open, modern and actively maintained alternative to Chardet." +groups = ["docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "charset-normalizer-3.3.2.tar.gz", hash = "sha256:f30c3cb33b24454a82faecaf01b19c18562b1e89558fb6c56de4d9118a032fd5"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:6463effa3186ea09411d50efc7d85360b38d5f09b870c48e4600f63af490e56a"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:37e55c8e51c236f95b033f6fb391d7d7970ba5fe7ff453dad675e88cf303377a"}, + {file = "charset_normalizer-3.3.2-py3-none-any.whl", hash = "sha256:3e4d1f6587322d2788836a99c69062fbb091331ec940e02d12d179c1d53e25fc"}, +] + +[[package]] +name = "cmocean" +version = "4.0.3" +requires_python = ">=3.8" +summary = "Colormaps for Oceanography" +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +dependencies = [ + "matplotlib", + "numpy", + "packaging", +] +files = [ + {file = "cmocean-4.0.3-py3-none-any.whl", hash = "sha256:f2fc1d5e349db122ee0c9eac80bba969aa92dd2806548fce58dc8bef962f309e"}, + {file = "cmocean-4.0.3.tar.gz", hash = "sha256:37868399fb5f41b4eac596e69803f9bfaea49946514dfb2e7f48886854250d7c"}, +] + +[[package]] +name = "colorama" +version = "0.4.6" +requires_python = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,!=3.6.*,>=2.7" +summary = "Cross-platform colored terminal text." +groups = ["qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6"}, + {file = "colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44"}, +] + +[[package]] +name = "colorcet" +version = "3.1.0" +requires_python = ">=3.7" +summary = "Collection of perceptually uniform colormaps" +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +files = [ + {file = "colorcet-3.1.0-py3-none-any.whl", hash = "sha256:2a7d59cc8d0f7938eeedd08aad3152b5319b4ba3bcb7a612398cc17a384cb296"}, + {file = "colorcet-3.1.0.tar.gz", hash = "sha256:2921b3cd81a2288aaf2d63dbc0ce3c26dcd882e8c389cc505d6886bf7aa9a4eb"}, +] + +[[package]] +name = "comm" +version = "0.2.2" +requires_python = ">=3.8" +summary = "Jupyter Python Comm implementation, for usage in ipykernel, xeus-python etc." +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "traitlets>=4", +] +files = [ + {file = "comm-0.2.2-py3-none-any.whl", hash = "sha256:e6fb86cb70ff661ee8c9c14e7d36d6de3b4066f1441be4063df9c5009f0a64d3"}, + {file = "comm-0.2.2.tar.gz", hash = "sha256:3fd7a84065306e07bea1773df6eb8282de51ba82f77c72f9c85716ab11fe980e"}, +] + +[[package]] +name = "contourpy" +version = "1.1.1" +requires_python = ">=3.8" +summary = "Python library for calculating contours of 2D quadrilateral grids" +groups = ["default", "pyvista"] +marker = "python_version == \"3.8\"" +dependencies = [ + "numpy<2.0,>=1.16; python_version <= \"3.11\"", + "numpy<2.0,>=1.26.0rc1; python_version >= \"3.12\"", +] +files = [ + {file = "contourpy-1.1.1-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:8394e652925a18ef0091115e3cc191fef350ab6dc3cc417f06da66bf98071ae9"}, + {file = "contourpy-1.1.1.tar.gz", hash = "sha256:96ba37c2e24b7212a77da85004c38e7c4d155d3e72a45eeaf22c1f03f607e8ab"}, +] + +[[package]] +name = "coverage" +version = "7.6.1" +requires_python = ">=3.8" +summary = "Code coverage measurement for Python" +groups = ["qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "coverage-7.6.1-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:f1adfc8ac319e1a348af294106bc6a8458a0f1633cc62a1446aebc30c5fa186a"}, + {file = "coverage-7.6.1-pp38.pp39.pp310-none-any.whl", hash = "sha256:e9a6e0eb86070e8ccaedfbd9d38fec54864f3125ab95419970575b42af7541df"}, + {file = "coverage-7.6.1.tar.gz", hash = "sha256:953510dfb7b12ab69d20135a0662397f077c59b1e6379a768e97c59d852ee51d"}, +] + +[[package]] +name = "coverage" +version = "7.6.1" +extras = ["toml"] +requires_python = ">=3.8" +summary = "Code coverage measurement for Python" +groups = ["qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "coverage==7.6.1", + "tomli; python_full_version <= \"3.11.0a6\"", +] +files = [ + {file = "coverage-7.6.1-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:f1adfc8ac319e1a348af294106bc6a8458a0f1633cc62a1446aebc30c5fa186a"}, + {file = "coverage-7.6.1-pp38.pp39.pp310-none-any.whl", hash = "sha256:e9a6e0eb86070e8ccaedfbd9d38fec54864f3125ab95419970575b42af7541df"}, + {file = "coverage-7.6.1.tar.gz", hash = "sha256:953510dfb7b12ab69d20135a0662397f077c59b1e6379a768e97c59d852ee51d"}, +] + +[[package]] +name = "cycler" +version = "0.12.1" +requires_python = ">=3.8" +summary = "Composable style cycles" +groups = ["default", "pyvista"] +marker = "python_version == \"3.8\"" +files = [ + {file = "cycler-0.12.1-py3-none-any.whl", hash = "sha256:85cef7cff222d8644161529808465972e51340599459b8ac3ccbac5a854e0d30"}, + {file = "cycler-0.12.1.tar.gz", hash = "sha256:88bb128f02ba341da8ef447245a9e138fae777f6a23943da4540077d3601eb1c"}, +] + +[[package]] +name = "debugpy" +version = "1.8.5" +requires_python = ">=3.8" +summary = "An implementation of the Debug Adapter Protocol for Python" +groups = ["qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "debugpy-1.8.5-py2.py3-none-any.whl", hash = "sha256:55919dce65b471eff25901acf82d328bbd5b833526b6c1364bd5133754777a44"}, + {file = "debugpy-1.8.5.zip", hash = "sha256:b2112cfeb34b4507399d298fe7023a16656fc553ed5246536060ca7bd0e668d0"}, +] + +[[package]] +name = "decorator" +version = "5.1.1" +requires_python = ">=3.5" +summary = "Decorators for Humans" +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "decorator-5.1.1-py3-none-any.whl", hash = "sha256:b8c3f85900b9dc423225913c5aace94729fe1fa9763b38939a95226f02d37186"}, + {file = "decorator-5.1.1.tar.gz", hash = "sha256:637996211036b6385ef91435e4fae22989472f9d571faba8927ba8253acbc330"}, +] + +[[package]] +name = "defusedxml" +version = "0.7.1" +requires_python = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*" +summary = "XML bomb protection for Python stdlib modules" +groups = ["docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "defusedxml-0.7.1-py2.py3-none-any.whl", hash = "sha256:a352e7e428770286cc899e2542b6cdaedb2b4953ff269a210103ec58f6198a61"}, + {file = "defusedxml-0.7.1.tar.gz", hash = "sha256:1bb3032db185915b62d7c6209c5a8792be6a32ab2fedacc84e01b52c51aa3e69"}, +] + +[[package]] +name = "distlib" +version = "0.3.8" +summary = "Distribution utilities" +groups = ["qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "distlib-0.3.8-py2.py3-none-any.whl", hash = "sha256:034db59a0b96f8ca18035f36290806a9a6e6bd9d1ff91e45a7f172eb17e51784"}, + {file = "distlib-0.3.8.tar.gz", hash = "sha256:1530ea13e350031b6312d8580ddb6b27a104275a31106523b8f123787f494f64"}, +] + +[[package]] +name = "docutils" +version = "0.20.1" +requires_python = ">=3.7" +summary = "Docutils -- Python Documentation Utilities" +groups = ["docs"] +marker = "python_version == \"3.8\"" +files = [ + {file = "docutils-0.20.1-py3-none-any.whl", hash = "sha256:96f387a2c5562db4476f09f13bbab2192e764cac08ebbf3a34a95d9b1e4a59d6"}, + {file = "docutils-0.20.1.tar.gz", hash = "sha256:f08a4e276c3a1583a86dce3e34aba3fe04d02bba2dd51ed16106244e8a923e3b"}, +] + +[[package]] +name = "et-xmlfile" +version = "1.1.0" +requires_python = ">=3.6" +summary = "An implementation of lxml.xmlfile for the standard library" +groups = ["openpyxl"] +marker = "python_version == \"3.8\"" +files = [ + {file = "et_xmlfile-1.1.0-py3-none-any.whl", hash = "sha256:a2ba85d1d6a74ef63837eed693bcb89c3f752169b0e3e7ae5b16ca5e1b3deada"}, + {file = "et_xmlfile-1.1.0.tar.gz", hash = "sha256:8eb9e2bc2f8c97e37a2dc85a09ecdcdec9d8a396530a6d5a33b30b9a92da0c5c"}, +] + +[[package]] +name = "exceptiongroup" +version = "1.2.2" +requires_python = ">=3.7" +summary = "Backport of PEP 654 (exception groups)" +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "exceptiongroup-1.2.2-py3-none-any.whl", hash = "sha256:3111b9d131c238bec2f8f516e123e14ba243563fb135d3fe885990585aa7795b"}, + {file = "exceptiongroup-1.2.2.tar.gz", hash = "sha256:47c2edf7c6738fafb49fd34290706d1a1a2f4d1c6df275526b62cbb4aa5393cc"}, +] + +[[package]] +name = "executing" +version = "2.1.0" +requires_python = ">=3.8" +summary = "Get the currently executing AST node of a frame, and other information" +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "executing-2.1.0-py2.py3-none-any.whl", hash = "sha256:8d63781349375b5ebccc3142f4b30350c0cd9c79f921cde38be2be4637e98eaf"}, + {file = "executing-2.1.0.tar.gz", hash = "sha256:8ea27ddd260da8150fa5a708269c4a10e76161e2496ec3e587da9e3c0fe4b9ab"}, +] + +[[package]] +name = "fastjsonschema" +version = "2.20.0" +summary = "Fastest Python implementation of JSON schema" +groups = ["docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "fastjsonschema-2.20.0-py3-none-any.whl", hash = "sha256:5875f0b0fa7a0043a91e93a9b8f793bcbbba9691e7fd83dca95c28ba26d21f0a"}, + {file = "fastjsonschema-2.20.0.tar.gz", hash = "sha256:3d48fc5300ee96f5d116f10fe6f28d938e6008f59a6a025c2649475b87f76a23"}, +] + +[[package]] +name = "filelock" +version = "3.16.1" +requires_python = ">=3.8" +summary = "A platform independent file lock." +groups = ["qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "filelock-3.16.1-py3-none-any.whl", hash = "sha256:2082e5703d51fbf98ea75855d9d5527e33d8ff23099bec374a134febee6946b0"}, + {file = "filelock-3.16.1.tar.gz", hash = "sha256:c249fbfcd5db47e5e2d6d62198e565475ee65e4831e2561c8e313fa7eb961435"}, +] + +[[package]] +name = "fonttools" +version = "4.53.1" +requires_python = ">=3.8" +summary = "Tools to manipulate font files" +groups = ["default", "pyvista"] +marker = "python_version == \"3.8\"" +files = [ + {file = "fonttools-4.53.1-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:c818c058404eb2bba05e728d38049438afd649e3c409796723dfc17cd3f08749"}, + {file = "fonttools-4.53.1-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:651390c3b26b0c7d1f4407cad281ee7a5a85a31a110cbac5269de72a51551ba2"}, + {file = "fonttools-4.53.1-py3-none-any.whl", hash = "sha256:f1f8758a2ad110bd6432203a344269f445a2907dc24ef6bccfd0ac4e14e0d71d"}, + {file = "fonttools-4.53.1.tar.gz", hash = "sha256:e128778a8e9bc11159ce5447f76766cefbd876f44bd79aff030287254e4752c4"}, +] + +[[package]] +name = "fqdn" +version = "1.5.1" +requires_python = ">=2.7, !=3.0, !=3.1, !=3.2, !=3.3, !=3.4, <4" +summary = "Validates fully-qualified domain names against RFC 1123, so that they are acceptable to modern bowsers" +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "cached-property>=1.3.0; python_version < \"3.8\"", +] +files = [ + {file = "fqdn-1.5.1-py3-none-any.whl", hash = "sha256:3a179af3761e4df6eb2e026ff9e1a3033d3587bf980a0b1b2e1e5d08d7358014"}, + {file = "fqdn-1.5.1.tar.gz", hash = "sha256:105ed3677e767fb5ca086a0c1f4bb66ebc3c100be518f0e0d755d9eae164d89f"}, +] + +[[package]] +name = "frozenlist" +version = "1.4.1" +requires_python = ">=3.8" +summary = "A list-like structure which implements collections.abc.MutableSequence" +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +files = [ + {file = "frozenlist-1.4.1-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:20b51fa3f588ff2fe658663db52a41a4f7aa6c04f6201449c6c7c476bd255c0d"}, + {file = "frozenlist-1.4.1-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:c6321c9efe29975232da3bd0af0ad216800a47e93d763ce64f291917a381b8eb"}, + {file = "frozenlist-1.4.1-py3-none-any.whl", hash = "sha256:04ced3e6a46b4cfffe20f9ae482818e34eba9b5fb0ce4056e4cc9b6e212d09b7"}, + {file = "frozenlist-1.4.1.tar.gz", hash = "sha256:c037a86e8513059a2613aaba4d817bb90b9d9b6b69aace3ce9c877e8c8ed402b"}, +] + +[[package]] +name = "ghp-import" +version = "2.1.0" +summary = "Copy your docs directly to the gh-pages branch." +groups = ["docs"] +marker = "python_version == \"3.8\"" +dependencies = [ + "python-dateutil>=2.8.1", +] +files = [ + {file = "ghp-import-2.1.0.tar.gz", hash = "sha256:9c535c4c61193c2df8871222567d7fd7e5014d835f97dc7b7439069e2413d343"}, + {file = "ghp_import-2.1.0-py3-none-any.whl", hash = "sha256:8337dd7b50877f163d4c0289bc1f1c7f127550241988d568c1db512c4324a619"}, +] + +[[package]] +name = "h11" +version = "0.14.0" +requires_python = ">=3.7" +summary = "A pure-Python, bring-your-own-I/O implementation of HTTP/1.1" +groups = ["qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "typing-extensions; python_version < \"3.8\"", +] +files = [ + {file = "h11-0.14.0-py3-none-any.whl", hash = "sha256:e3fe4ac4b851c468cc8363d500db52c2ead036020723024a109d37346efaa761"}, + {file = "h11-0.14.0.tar.gz", hash = "sha256:8f19fbbe99e72420ff35c00b27a34cb9937e902a8b810e2c88300c6f0a3b699d"}, +] + +[[package]] +name = "httpcore" +version = "1.0.5" +requires_python = ">=3.8" +summary = "A minimal low-level HTTP client." +groups = ["qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "certifi", + "h11<0.15,>=0.13", +] +files = [ + {file = "httpcore-1.0.5-py3-none-any.whl", hash = "sha256:421f18bac248b25d310f3cacd198d55b8e6125c107797b609ff9b7a6ba7991b5"}, + {file = "httpcore-1.0.5.tar.gz", hash = "sha256:34a38e2f9291467ee3b44e89dd52615370e152954ba21721378a87b2960f7a61"}, +] + +[[package]] +name = "httpx" +version = "0.27.2" +requires_python = ">=3.8" +summary = "The next generation HTTP client." +groups = ["qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "anyio", + "certifi", + "httpcore==1.*", + "idna", + "sniffio", +] +files = [ + {file = "httpx-0.27.2-py3-none-any.whl", hash = "sha256:7bb2708e112d8fdd7829cd4243970f0c223274051cb35ee80c03301ee29a3df0"}, + {file = "httpx-0.27.2.tar.gz", hash = "sha256:f7c2be1d2f3c3c3160d441802406b206c2b76f5947b11115e6df10c6c65e66c2"}, +] + +[[package]] +name = "identify" +version = "2.6.0" +requires_python = ">=3.8" +summary = "File identification library for Python" +groups = ["qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "identify-2.6.0-py2.py3-none-any.whl", hash = "sha256:e79ae4406387a9d300332b5fd366d8994f1525e8414984e1a59e058b2eda2dd0"}, + {file = "identify-2.6.0.tar.gz", hash = "sha256:cb171c685bdc31bcc4c1734698736a7d5b6c8bf2e0c15117f4d469c8640ae5cf"}, +] + +[[package]] +name = "idna" +version = "3.8" +requires_python = ">=3.6" +summary = "Internationalized Domain Names in Applications (IDNA)" +groups = ["docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "idna-3.8-py3-none-any.whl", hash = "sha256:050b4e5baadcd44d760cedbd2b8e639f2ff89bbc7a5730fcc662954303377aac"}, + {file = "idna-3.8.tar.gz", hash = "sha256:d838c2c0ed6fced7693d5e8ab8e734d5f8fda53a039c0164afb0b82e771e3603"}, +] + +[[package]] +name = "imageio" +version = "2.35.1" +requires_python = ">=3.8" +summary = "Library for reading and writing a wide range of image, video, scientific, and volumetric data formats." +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +dependencies = [ + "numpy", + "pillow>=8.3.2", +] +files = [ + {file = "imageio-2.35.1-py3-none-any.whl", hash = "sha256:6eb2e5244e7a16b85c10b5c2fe0f7bf961b40fcb9f1a9fd1bd1d2c2f8fb3cd65"}, + {file = "imageio-2.35.1.tar.gz", hash = "sha256:4952dfeef3c3947957f6d5dedb1f4ca31c6e509a476891062396834048aeed2a"}, +] + +[[package]] +name = "imagesize" +version = "1.4.1" +requires_python = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*" +summary = "Getting image size from png/jpeg/jpeg2000/gif file" +groups = ["docs"] +marker = "python_version == \"3.8\"" +files = [ + {file = "imagesize-1.4.1-py2.py3-none-any.whl", hash = "sha256:0d8d18d08f840c19d0ee7ca1fd82490fdc3729b7ac93f49870406ddde8ef8d8b"}, + {file = "imagesize-1.4.1.tar.gz", hash = "sha256:69150444affb9cb0d5cc5a92b3676f0b2fb7cd9ae39e947a5e11a36b4497cd4a"}, +] + +[[package]] +name = "importlib-metadata" +version = "8.5.0" +requires_python = ">=3.8" +summary = "Read metadata from Python packages" +groups = ["docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "typing-extensions>=3.6.4; python_version < \"3.8\"", + "zipp>=3.20", +] +files = [ + {file = "importlib_metadata-8.5.0-py3-none-any.whl", hash = "sha256:45e54197d28b7a7f1559e60b95e7c567032b602131fbd588f1497f47880aa68b"}, + {file = "importlib_metadata-8.5.0.tar.gz", hash = "sha256:71522656f0abace1d072b9e5481a48f07c138e00f079c38c8f883823f9c26bd7"}, +] + +[[package]] +name = "importlib-resources" +version = "6.4.5" +requires_python = ">=3.8" +summary = "Read resources from Python packages" +groups = ["default", "docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "zipp>=3.1.0; python_version < \"3.10\"", +] +files = [ + {file = "importlib_resources-6.4.5-py3-none-any.whl", hash = "sha256:ac29d5f956f01d5e4bb63102a5a19957f1b9175e45649977264a1416783bb717"}, + {file = "importlib_resources-6.4.5.tar.gz", hash = "sha256:980862a1d16c9e147a59603677fa2aa5fd82b87f223b6cb870695bcfce830065"}, +] + +[[package]] +name = "iniconfig" +version = "2.0.0" +requires_python = ">=3.7" +summary = "brain-dead simple config-ini parsing" +groups = ["qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "iniconfig-2.0.0-py3-none-any.whl", hash = "sha256:b6a85871a79d2e3b22d2d1b94ac2824226a63c6b741c88f7ae975f18b6778374"}, + {file = "iniconfig-2.0.0.tar.gz", hash = "sha256:2d91e135bf72d31a410b17c16da610a82cb55f6b0477d1a902134b24a455b8b3"}, +] + +[[package]] +name = "ipdb" +version = "0.13.13" +requires_python = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*" +summary = "IPython-enabled pdb" +groups = ["qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "decorator; python_version == \"3.5\"", + "decorator; python_version == \"3.6\"", + "decorator; python_version > \"3.6\" and python_version < \"3.11\"", + "decorator; python_version >= \"3.11\"", + "decorator<5.0.0; python_version == \"2.7\"", + "decorator<5.0.0; python_version == \"3.4\"", + "ipython<6.0.0,>=5.1.0; python_version == \"2.7\"", + "ipython<7.0.0,>=6.0.0; python_version == \"3.4\"", + "ipython<7.10.0,>=7.0.0; python_version == \"3.5\"", + "ipython<7.17.0,>=7.16.3; python_version == \"3.6\"", + "ipython>=7.31.1; python_version > \"3.6\" and python_version < \"3.11\"", + "ipython>=7.31.1; python_version >= \"3.11\"", + "pathlib; python_version == \"2.7\"", + "toml>=0.10.2; python_version == \"2.7\"", + "toml>=0.10.2; python_version == \"3.4\"", + "toml>=0.10.2; python_version == \"3.5\"", + "tomli; python_version == \"3.6\"", + "tomli; python_version > \"3.6\" and python_version < \"3.11\"", +] +files = [ + {file = "ipdb-0.13.13-py3-none-any.whl", hash = "sha256:45529994741c4ab6d2388bfa5d7b725c2cf7fe9deffabdb8a6113aa5ed449ed4"}, + {file = "ipdb-0.13.13.tar.gz", hash = "sha256:e3ac6018ef05126d442af680aad863006ec19d02290561ac88b8b1c0b0cfc726"}, +] + +[[package]] +name = "ipykernel" +version = "6.29.5" +requires_python = ">=3.8" +summary = "IPython Kernel for Jupyter" +groups = ["qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "appnope; platform_system == \"Darwin\"", + "comm>=0.1.1", + "debugpy>=1.6.5", + "ipython>=7.23.1", + "jupyter-client>=6.1.12", + "jupyter-core!=5.0.*,>=4.12", + "matplotlib-inline>=0.1", + "nest-asyncio", + "packaging", + "psutil", + "pyzmq>=24", + "tornado>=6.1", + "traitlets>=5.4.0", +] +files = [ + {file = "ipykernel-6.29.5-py3-none-any.whl", hash = "sha256:afdb66ba5aa354b09b91379bac28ae4afebbb30e8b39510c9690afb7a10421b5"}, + {file = "ipykernel-6.29.5.tar.gz", hash = "sha256:f093a22c4a40f8828f8e330a9c297cb93dcab13bd9678ded6de8e5cf81c56215"}, +] + +[[package]] +name = "ipython" +version = "8.12.3" +requires_python = ">=3.8" +summary = "IPython: Productive Interactive Computing" +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "appnope; sys_platform == \"darwin\"", + "backcall", + "colorama; sys_platform == \"win32\"", + "decorator", + "jedi>=0.16", + "matplotlib-inline", + "pexpect>4.3; sys_platform != \"win32\"", + "pickleshare", + "prompt-toolkit!=3.0.37,<3.1.0,>=3.0.30", + "pygments>=2.4.0", + "stack-data", + "traitlets>=5", + "typing-extensions; python_version < \"3.10\"", +] +files = [ + {file = "ipython-8.12.3-py3-none-any.whl", hash = "sha256:b0340d46a933d27c657b211a329d0be23793c36595acf9e6ef4164bc01a1804c"}, + {file = "ipython-8.12.3.tar.gz", hash = "sha256:3910c4b54543c2ad73d06579aa771041b7d5707b033bd488669b4cf544e3b363"}, +] + +[[package]] +name = "ipywidgets" +version = "8.1.5" +requires_python = ">=3.7" +summary = "Jupyter interactive widgets" +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +dependencies = [ + "comm>=0.1.3", + "ipython>=6.1.0", + "jupyterlab-widgets~=3.0.12", + "traitlets>=4.3.1", + "widgetsnbextension~=4.0.12", +] +files = [ + {file = "ipywidgets-8.1.5-py3-none-any.whl", hash = "sha256:3290f526f87ae6e77655555baba4f36681c555b8bdbbff430b70e52c34c86245"}, + {file = "ipywidgets-8.1.5.tar.gz", hash = "sha256:870e43b1a35656a80c18c9503bbf2d16802db1cb487eec6fab27d683381dde17"}, +] + +[[package]] +name = "isoduration" +version = "20.11.0" +requires_python = ">=3.7" +summary = "Operations with ISO 8601 durations" +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "arrow>=0.15.0", +] +files = [ + {file = "isoduration-20.11.0-py3-none-any.whl", hash = "sha256:b2904c2a4228c3d44f409c8ae8e2370eb21a26f7ac2ec5446df141dde3452042"}, + {file = "isoduration-20.11.0.tar.gz", hash = "sha256:ac2f9015137935279eac671f94f89eb00584f940f5dc49462a0c4ee692ba1bd9"}, +] + +[[package]] +name = "jedi" +version = "0.19.1" +requires_python = ">=3.6" +summary = "An autocompletion tool for Python that can be used for text editors." +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "parso<0.9.0,>=0.8.3", +] +files = [ + {file = "jedi-0.19.1-py2.py3-none-any.whl", hash = "sha256:e983c654fe5c02867aef4cdfce5a2fbb4a50adc0af145f70504238f18ef5e7e0"}, + {file = "jedi-0.19.1.tar.gz", hash = "sha256:cf0496f3651bc65d7174ac1b7d043eff454892c708a87d1b683e57b569927ffd"}, +] + +[[package]] +name = "jinja2" +version = "3.1.5" +requires_python = ">=3.7" +summary = "A very fast and expressive template engine." +groups = ["docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "MarkupSafe>=2.0", +] +files = [ + {file = "jinja2-3.1.5-py3-none-any.whl", hash = "sha256:aba0f4dc9ed8013c424088f68a5c226f7d6097ed89b246d7749c2ec4175c6adb"}, + {file = "jinja2-3.1.5.tar.gz", hash = "sha256:8fefff8dc3034e27bb80d67c671eb8a9bc424c0ef4c0826edbff304cceff43bb"}, +] + +[[package]] +name = "json5" +version = "0.9.25" +requires_python = ">=3.8" +summary = "A Python implementation of the JSON5 data format." +groups = ["qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "json5-0.9.25-py3-none-any.whl", hash = "sha256:34ed7d834b1341a86987ed52f3f76cd8ee184394906b6e22a1e0deb9ab294e8f"}, + {file = "json5-0.9.25.tar.gz", hash = "sha256:548e41b9be043f9426776f05df8635a00fe06104ea51ed24b67f908856e151ae"}, +] + +[[package]] +name = "jsonpointer" +version = "3.0.0" +requires_python = ">=3.7" +summary = "Identify specific nodes in a JSON document (RFC 6901) " +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "jsonpointer-3.0.0-py2.py3-none-any.whl", hash = "sha256:13e088adc14fca8b6aa8177c044e12701e6ad4b28ff10e65f2267a90109c9942"}, + {file = "jsonpointer-3.0.0.tar.gz", hash = "sha256:2b2d729f2091522d61c3b31f82e11870f60b68f43fbc705cb76bf4b832af59ef"}, +] + +[[package]] +name = "jsonschema" +version = "4.23.0" +requires_python = ">=3.8" +summary = "An implementation of JSON Schema validation for Python" +groups = ["docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "attrs>=22.2.0", + "importlib-resources>=1.4.0; python_version < \"3.9\"", + "jsonschema-specifications>=2023.03.6", + "pkgutil-resolve-name>=1.3.10; python_version < \"3.9\"", + "referencing>=0.28.4", + "rpds-py>=0.7.1", +] +files = [ + {file = "jsonschema-4.23.0-py3-none-any.whl", hash = "sha256:fbadb6f8b144a8f8cf9f0b89ba94501d143e50411a1278633f56a7acf7fd5566"}, + {file = "jsonschema-4.23.0.tar.gz", hash = "sha256:d71497fef26351a33265337fa77ffeb82423f3ea21283cd9467bb03999266bc4"}, +] + +[[package]] +name = "jsonschema-specifications" +version = "2023.12.1" +requires_python = ">=3.8" +summary = "The JSON Schema meta-schemas and vocabularies, exposed as a Registry" +groups = ["docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "importlib-resources>=1.4.0; python_version < \"3.9\"", + "referencing>=0.31.0", +] +files = [ + {file = "jsonschema_specifications-2023.12.1-py3-none-any.whl", hash = "sha256:87e4fdf3a94858b8a2ba2778d9ba57d8a9cafca7c7489c46ba0d30a8bc6a9c3c"}, + {file = "jsonschema_specifications-2023.12.1.tar.gz", hash = "sha256:48a76787b3e70f5ed53f1160d2b81f586e4ca6d1548c5de7085d1682674764cc"}, +] + +[[package]] +name = "jsonschema" +version = "4.23.0" +extras = ["format-nongpl"] +requires_python = ">=3.8" +summary = "An implementation of JSON Schema validation for Python" +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "fqdn", + "idna", + "isoduration", + "jsonpointer>1.13", + "jsonschema==4.23.0", + "rfc3339-validator", + "rfc3986-validator>0.1.0", + "uri-template", + "webcolors>=24.6.0", +] +files = [ + {file = "jsonschema-4.23.0-py3-none-any.whl", hash = "sha256:fbadb6f8b144a8f8cf9f0b89ba94501d143e50411a1278633f56a7acf7fd5566"}, + {file = "jsonschema-4.23.0.tar.gz", hash = "sha256:d71497fef26351a33265337fa77ffeb82423f3ea21283cd9467bb03999266bc4"}, +] + +[[package]] +name = "jupyter-client" +version = "8.6.3" +requires_python = ">=3.8" +summary = "Jupyter protocol implementation and client libraries" +groups = ["docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "importlib-metadata>=4.8.3; python_version < \"3.10\"", + "jupyter-core!=5.0.*,>=4.12", + "python-dateutil>=2.8.2", + "pyzmq>=23.0", + "tornado>=6.2", + "traitlets>=5.3", +] +files = [ + {file = "jupyter_client-8.6.3-py3-none-any.whl", hash = "sha256:e8a19cc986cc45905ac3362915f410f3af85424b4c0905e94fa5f2cb08e8f23f"}, + {file = "jupyter_client-8.6.3.tar.gz", hash = "sha256:35b3a0947c4a6e9d589eb97d7d4cd5e90f910ee73101611f01283732bd6d9419"}, +] + +[[package]] +name = "jupyter-core" +version = "5.7.2" +requires_python = ">=3.8" +summary = "Jupyter core package. A base package on which Jupyter projects rely." +groups = ["docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "platformdirs>=2.5", + "pywin32>=300; sys_platform == \"win32\" and platform_python_implementation != \"PyPy\"", + "traitlets>=5.3", +] +files = [ + {file = "jupyter_core-5.7.2-py3-none-any.whl", hash = "sha256:4f7315d2f6b4bcf2e3e7cb6e46772eba760ae459cd1f59d29eb57b0a01bd7409"}, + {file = "jupyter_core-5.7.2.tar.gz", hash = "sha256:aa5f8d32bbf6b431ac830496da7392035d6f61b4f54872f15c4bd2a9c3f536d9"}, +] + +[[package]] +name = "jupyter-events" +version = "0.10.0" +requires_python = ">=3.8" +summary = "Jupyter Event System library" +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "jsonschema[format-nongpl]>=4.18.0", + "python-json-logger>=2.0.4", + "pyyaml>=5.3", + "referencing", + "rfc3339-validator", + "rfc3986-validator>=0.1.1", + "traitlets>=5.3", +] +files = [ + {file = "jupyter_events-0.10.0-py3-none-any.whl", hash = "sha256:4b72130875e59d57716d327ea70d3ebc3af1944d3717e5a498b8a06c6c159960"}, + {file = "jupyter_events-0.10.0.tar.gz", hash = "sha256:670b8229d3cc882ec782144ed22e0d29e1c2d639263f92ca8383e66682845e22"}, +] + +[[package]] +name = "jupyter-lsp" +version = "2.2.5" +requires_python = ">=3.8" +summary = "Multi-Language Server WebSocket proxy for Jupyter Notebook/Lab server" +groups = ["qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "importlib-metadata>=4.8.3; python_version < \"3.10\"", + "jupyter-server>=1.1.2", +] +files = [ + {file = "jupyter-lsp-2.2.5.tar.gz", hash = "sha256:793147a05ad446f809fd53ef1cd19a9f5256fd0a2d6b7ce943a982cb4f545001"}, + {file = "jupyter_lsp-2.2.5-py3-none-any.whl", hash = "sha256:45fbddbd505f3fbfb0b6cb2f1bc5e15e83ab7c79cd6e89416b248cb3c00c11da"}, +] + +[[package]] +name = "jupyter-server" +version = "2.14.2" +requires_python = ">=3.8" +summary = "The backend—i.e. core services, APIs, and REST endpoints—to Jupyter web applications." +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "anyio>=3.1.0", + "argon2-cffi>=21.1", + "jinja2>=3.0.3", + "jupyter-client>=7.4.4", + "jupyter-core!=5.0.*,>=4.12", + "jupyter-events>=0.9.0", + "jupyter-server-terminals>=0.4.4", + "nbconvert>=6.4.4", + "nbformat>=5.3.0", + "overrides>=5.0", + "packaging>=22.0", + "prometheus-client>=0.9", + "pywinpty>=2.0.1; os_name == \"nt\"", + "pyzmq>=24", + "send2trash>=1.8.2", + "terminado>=0.8.3", + "tornado>=6.2.0", + "traitlets>=5.6.0", + "websocket-client>=1.7", +] +files = [ + {file = "jupyter_server-2.14.2-py3-none-any.whl", hash = "sha256:47ff506127c2f7851a17bf4713434208fc490955d0e8632e95014a9a9afbeefd"}, + {file = "jupyter_server-2.14.2.tar.gz", hash = "sha256:66095021aa9638ced276c248b1d81862e4c50f292d575920bbe960de1c56b12b"}, +] + +[[package]] +name = "jupyter-server-proxy" +version = "4.4.0" +requires_python = ">=3.8" +summary = "A Jupyter server extension to run additional processes and proxy to them that comes bundled JupyterLab extension to launch pre-defined processes." +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +dependencies = [ + "aiohttp", + "importlib-metadata>=4.8.3; python_version < \"3.10\"", + "jupyter-server>=1.24.0", + "simpervisor>=1.0.0", + "tornado>=6.1.0", + "traitlets>=5.1.0", +] +files = [ + {file = "jupyter_server_proxy-4.4.0-py3-none-any.whl", hash = "sha256:707b5c84810bb8863d50f6c6d50a386fec216149e11802b7d4c451b54a63a9a6"}, + {file = "jupyter_server_proxy-4.4.0.tar.gz", hash = "sha256:e5732eb9c810c0caa997f90a2f15f7d09af638e7eea9c67eb5c43e9c1f0e1157"}, +] + +[[package]] +name = "jupyter-server-terminals" +version = "0.5.3" +requires_python = ">=3.8" +summary = "A Jupyter Server Extension Providing Terminals." +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "pywinpty>=2.0.3; os_name == \"nt\"", + "terminado>=0.8.3", +] +files = [ + {file = "jupyter_server_terminals-0.5.3-py3-none-any.whl", hash = "sha256:41ee0d7dc0ebf2809c668e0fc726dfaf258fcd3e769568996ca731b6194ae9aa"}, + {file = "jupyter_server_terminals-0.5.3.tar.gz", hash = "sha256:5ae0295167220e9ace0edcfdb212afd2b01ee8d179fe6f23c899590e9b8a5269"}, +] + +[[package]] +name = "jupyterlab" +version = "4.3.5" +requires_python = ">=3.8" +summary = "JupyterLab computational environment" +groups = ["qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "async-lru>=1.0.0", + "httpx>=0.25.0", + "importlib-metadata>=4.8.3; python_version < \"3.10\"", + "importlib-resources>=1.4; python_version < \"3.9\"", + "ipykernel>=6.5.0", + "jinja2>=3.0.3", + "jupyter-core", + "jupyter-lsp>=2.0.0", + "jupyter-server<3,>=2.4.0", + "jupyterlab-server<3,>=2.27.1", + "notebook-shim>=0.2", + "packaging", + "setuptools>=40.8.0", + "tomli>=1.2.2; python_version < \"3.11\"", + "tornado>=6.2.0", + "traitlets", +] +files = [ + {file = "jupyterlab-4.3.5-py3-none-any.whl", hash = "sha256:571bbdee20e4c5321ab5195bc41cf92a75a5cff886be5e57ce78dfa37a5e9fdb"}, + {file = "jupyterlab-4.3.5.tar.gz", hash = "sha256:c779bf72ced007d7d29d5bcef128e7fdda96ea69299e19b04a43635a7d641f9d"}, +] + +[[package]] +name = "jupyterlab-pygments" +version = "0.3.0" +requires_python = ">=3.8" +summary = "Pygments theme using JupyterLab CSS variables" +groups = ["docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "jupyterlab_pygments-0.3.0-py3-none-any.whl", hash = "sha256:841a89020971da1d8693f1a99997aefc5dc424bb1b251fd6322462a1b8842780"}, + {file = "jupyterlab_pygments-0.3.0.tar.gz", hash = "sha256:721aca4d9029252b11cfa9d185e5b5af4d54772bb8072f9b7036f4170054d35d"}, +] + +[[package]] +name = "jupyterlab-server" +version = "2.27.3" +requires_python = ">=3.8" +summary = "A set of server components for JupyterLab and JupyterLab like applications." +groups = ["qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "babel>=2.10", + "importlib-metadata>=4.8.3; python_version < \"3.10\"", + "jinja2>=3.0.3", + "json5>=0.9.0", + "jsonschema>=4.18.0", + "jupyter-server<3,>=1.21", + "packaging>=21.3", + "requests>=2.31", +] +files = [ + {file = "jupyterlab_server-2.27.3-py3-none-any.whl", hash = "sha256:e697488f66c3db49df675158a77b3b017520d772c6e1548c7d9bcc5df7944ee4"}, + {file = "jupyterlab_server-2.27.3.tar.gz", hash = "sha256:eb36caca59e74471988f0ae25c77945610b887f777255aa21f8065def9e51ed4"}, +] + +[[package]] +name = "jupyterlab-widgets" +version = "3.0.13" +requires_python = ">=3.7" +summary = "Jupyter interactive widgets for JupyterLab" +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +files = [ + {file = "jupyterlab_widgets-3.0.13-py3-none-any.whl", hash = "sha256:e3cda2c233ce144192f1e29914ad522b2f4c40e77214b0cc97377ca3d323db54"}, + {file = "jupyterlab_widgets-3.0.13.tar.gz", hash = "sha256:a2966d385328c1942b683a8cd96b89b8dd82c8b8f81dda902bb2bc06d46f5bed"}, +] + +[[package]] +name = "kiwisolver" +version = "1.4.7" +requires_python = ">=3.8" +summary = "A fast implementation of the Cassowary constraint solver" +groups = ["default", "pyvista"] +marker = "python_version == \"3.8\"" +files = [ + {file = "kiwisolver-1.4.7-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:5d5abf8f8ec1f4e22882273c423e16cae834c36856cac348cfbfa68e01c40f3a"}, + {file = "kiwisolver-1.4.7-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:b7d755065e4e866a8086c9bdada157133ff466476a2ad7861828e17b6026e22c"}, + {file = "kiwisolver-1.4.7-pp38-pypy38_pp73-macosx_11_0_arm64.whl", hash = "sha256:eee3ea935c3d227d49b4eb85660ff631556841f6e567f0f7bda972df6c2c9935"}, + {file = "kiwisolver-1.4.7.tar.gz", hash = "sha256:9893ff81bd7107f7b685d3017cc6583daadb4fc26e4a888350df530e41980a60"}, +] + +[[package]] +name = "markdown-it-py" +version = "3.0.0" +requires_python = ">=3.8" +summary = "Python port of markdown-it. Markdown parsing, done right!" +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +dependencies = [ + "mdurl~=0.1", +] +files = [ + {file = "markdown-it-py-3.0.0.tar.gz", hash = "sha256:e3f60a94fa066dc52ec76661e37c851cb232d92f9886b15cb560aaada2df8feb"}, + {file = "markdown_it_py-3.0.0-py3-none-any.whl", hash = "sha256:355216845c60bd96232cd8d8c40e8f9765cc86f46880e43a8fd22dc1a1a8cab1"}, +] + +[[package]] +name = "markupsafe" +version = "2.1.5" +requires_python = ">=3.7" +summary = "Safely add untrusted strings to HTML/XML markup." +groups = ["docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "MarkupSafe-2.1.5-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:656f7526c69fac7f600bd1f400991cc282b417d17539a1b228617081106feb4a"}, + {file = "MarkupSafe-2.1.5.tar.gz", hash = "sha256:d283d37a890ba4c1ae73ffadf8046435c76e7bc2247bbb63c00bd1a709c6544b"}, +] + +[[package]] +name = "matplotlib" +version = "3.7.5" +requires_python = ">=3.8" +summary = "Python plotting package" +groups = ["default", "pyvista"] +marker = "python_version == \"3.8\"" +dependencies = [ + "contourpy>=1.0.1", + "cycler>=0.10", + "fonttools>=4.22.0", + "importlib-resources>=3.2.0; python_version < \"3.10\"", + "kiwisolver>=1.0.1", + "numpy<2,>=1.20", + "packaging>=20.0", + "pillow>=6.2.0", + "pyparsing>=2.3.1", + "python-dateutil>=2.7", +] +files = [ + {file = "matplotlib-3.7.5-cp38-cp38-macosx_10_12_universal2.whl", hash = "sha256:cfff9b838531698ee40e40ea1a8a9dc2c01edb400b27d38de6ba44c1f9a8e3d2"}, + {file = "matplotlib-3.7.5-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:4cdf4ef46c2a1609a50411b66940b31778db1e4b73d4ecc2eaa40bd588979b13"}, + {file = "matplotlib-3.7.5.tar.gz", hash = "sha256:1e5c971558ebc811aa07f54c7b7c677d78aa518ef4c390e14673a09e0860184a"}, +] + +[[package]] +name = "matplotlib-inline" +version = "0.1.7" +requires_python = ">=3.8" +summary = "Inline Matplotlib backend for Jupyter" +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "traitlets", +] +files = [ + {file = "matplotlib_inline-0.1.7-py3-none-any.whl", hash = "sha256:df192d39a4ff8f21b1895d72e6a13f5fcc5099f00fa84384e0ea28c2cc0653ca"}, + {file = "matplotlib_inline-0.1.7.tar.gz", hash = "sha256:8423b23ec666be3d16e16b60bdd8ac4e86e840ebd1dd11a30b9f117f2fa0ab90"}, +] + +[[package]] +name = "mdurl" +version = "0.1.2" +requires_python = ">=3.7" +summary = "Markdown URL utilities" +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +files = [ + {file = "mdurl-0.1.2-py3-none-any.whl", hash = "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8"}, + {file = "mdurl-0.1.2.tar.gz", hash = "sha256:bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba"}, +] + +[[package]] +name = "meshio" +version = "5.3.5" +requires_python = ">=3.8" +summary = "I/O for many mesh formats" +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +dependencies = [ + "importlib-metadata; python_version < \"3.8\"", + "numpy>=1.20.0", + "rich", +] +files = [ + {file = "meshio-5.3.5-py3-none-any.whl", hash = "sha256:0736c6e34ecc768f62f2cde5d8233a3529512a9399b25c68ea2ca0d5900cdc10"}, + {file = "meshio-5.3.5.tar.gz", hash = "sha256:f21f01abd9f29ba06ea119304b3d39e610421cfe93b9dd23362834919f87586d"}, +] + +[[package]] +name = "mistune" +version = "3.0.2" +requires_python = ">=3.7" +summary = "A sane and fast Markdown parser with useful plugins and renderers" +groups = ["docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "mistune-3.0.2-py3-none-any.whl", hash = "sha256:71481854c30fdbc938963d3605b72501f5c10a9320ecd412c121c163a1c7d205"}, + {file = "mistune-3.0.2.tar.gz", hash = "sha256:fc7f93ded930c92394ef2cb6f04a8aabab4117a91449e72dcc8dfa646a508be8"}, +] + +[[package]] +name = "more-itertools" +version = "10.5.0" +requires_python = ">=3.8" +summary = "More routines for operating on iterables, beyond itertools" +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +files = [ + {file = "more-itertools-10.5.0.tar.gz", hash = "sha256:5482bfef7849c25dc3c6dd53a6173ae4795da2a41a80faea6700d9f5846c5da6"}, + {file = "more_itertools-10.5.0-py3-none-any.whl", hash = "sha256:037b0d3203ce90cca8ab1defbbdac29d5f993fc20131f3664dc8d6acfa872aef"}, +] + +[[package]] +name = "msgpack" +version = "1.1.0" +requires_python = ">=3.8" +summary = "MessagePack serializer" +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +files = [ + {file = "msgpack-1.1.0.tar.gz", hash = "sha256:dd432ccc2c72b914e4cb77afce64aab761c1137cc698be3984eee260bcb2896e"}, +] + +[[package]] +name = "multidict" +version = "6.1.0" +requires_python = ">=3.8" +summary = "multidict implementation" +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +dependencies = [ + "typing-extensions>=4.1.0; python_version < \"3.11\"", +] +files = [ + {file = "multidict-6.1.0-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:db7457bac39421addd0c8449933ac32d8042aae84a14911a757ae6ca3eef1392"}, + {file = "multidict-6.1.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:5845c1fd4866bb5dd3125d89b90e57ed3138241540897de748cdf19de8a2fca2"}, + {file = "multidict-6.1.0-py3-none-any.whl", hash = "sha256:48e171e52d1c4d33888e529b999e5900356b9ae588c2f09a52dcefb158b27506"}, + {file = "multidict-6.1.0.tar.gz", hash = "sha256:22ae2ebf9b0c69d206c003e2f6a914ea33f0a932d4aa16f236afc049d9958f4a"}, +] + +[[package]] +name = "nbclient" +version = "0.10.0" +requires_python = ">=3.8.0" +summary = "A client library for executing notebooks. Formerly nbconvert's ExecutePreprocessor." +groups = ["docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "jupyter-client>=6.1.12", + "jupyter-core!=5.0.*,>=4.12", + "nbformat>=5.1", + "traitlets>=5.4", +] +files = [ + {file = "nbclient-0.10.0-py3-none-any.whl", hash = "sha256:f13e3529332a1f1f81d82a53210322476a168bb7090a0289c795fe9cc11c9d3f"}, + {file = "nbclient-0.10.0.tar.gz", hash = "sha256:4b3f1b7dba531e498449c4db4f53da339c91d449dc11e9af3a43b4eb5c5abb09"}, +] + +[[package]] +name = "nbconvert" +version = "7.16.6" +requires_python = ">=3.8" +summary = "Converting Jupyter Notebooks (.ipynb files) to other formats. Output formats include asciidoc, html, latex, markdown, pdf, py, rst, script. nbconvert can be used both as a Python library (`import nbconvert`) or as a command line tool (invoked as `jupyter nbconvert ...`)." +groups = ["docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "beautifulsoup4", + "bleach[css]!=5.0.0", + "defusedxml", + "importlib-metadata>=3.6; python_version < \"3.10\"", + "jinja2>=3.0", + "jupyter-core>=4.7", + "jupyterlab-pygments", + "markupsafe>=2.0", + "mistune<4,>=2.0.3", + "nbclient>=0.5.0", + "nbformat>=5.7", + "packaging", + "pandocfilters>=1.4.1", + "pygments>=2.4.1", + "traitlets>=5.1", +] +files = [ + {file = "nbconvert-7.16.6-py3-none-any.whl", hash = "sha256:1375a7b67e0c2883678c48e506dc320febb57685e5ee67faa51b18a90f3a712b"}, + {file = "nbconvert-7.16.6.tar.gz", hash = "sha256:576a7e37c6480da7b8465eefa66c17844243816ce1ccc372633c6b71c3c0f582"}, +] + +[[package]] +name = "nbformat" +version = "5.10.4" +requires_python = ">=3.8" +summary = "The Jupyter Notebook format" +groups = ["docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "fastjsonschema>=2.15", + "jsonschema>=2.6", + "jupyter-core!=5.0.*,>=4.12", + "traitlets>=5.1", +] +files = [ + {file = "nbformat-5.10.4-py3-none-any.whl", hash = "sha256:3b48d6c8fbca4b299bf3982ea7db1af21580e4fec269ad087b9e81588891200b"}, + {file = "nbformat-5.10.4.tar.gz", hash = "sha256:322168b14f937a5d11362988ecac2a4952d3d8e3a2cbeb2319584631226d5b3a"}, +] + +[[package]] +name = "nbsphinx" +version = "0.9.6" +requires_python = ">=3.6" +summary = "Jupyter Notebook Tools for Sphinx" +groups = ["docs"] +marker = "python_version == \"3.8\"" +dependencies = [ + "docutils>=0.18.1", + "jinja2", + "nbconvert!=5.4,>=5.3", + "nbformat", + "sphinx>=1.8", + "traitlets>=5", +] +files = [ + {file = "nbsphinx-0.9.6-py3-none-any.whl", hash = "sha256:336b0b557945a7678ec7449b16449f854bc852a435bb53b8a72e6b5dc740d992"}, + {file = "nbsphinx-0.9.6.tar.gz", hash = "sha256:c2b28a2d702f1159a95b843831798e86e60a17fc647b9bff9ba1585355de54e3"}, +] + +[[package]] +name = "nest-asyncio" +version = "1.6.0" +requires_python = ">=3.5" +summary = "Patch asyncio to allow nested event loops" +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "nest_asyncio-1.6.0-py3-none-any.whl", hash = "sha256:87af6efd6b5e897c81050477ef65c62e2b2f35d51703cae01aff2905b1852e1c"}, + {file = "nest_asyncio-1.6.0.tar.gz", hash = "sha256:6f172d5449aca15afd6c646851f4e31e02c598d553a667e38cafa997cfec55fe"}, +] + +[[package]] +name = "nodeenv" +version = "1.9.1" +requires_python = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,!=3.6.*,>=2.7" +summary = "Node.js virtual environment builder" +groups = ["qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "nodeenv-1.9.1-py2.py3-none-any.whl", hash = "sha256:ba11c9782d29c27c70ffbdda2d7415098754709be8a7056d79a737cd901155c9"}, + {file = "nodeenv-1.9.1.tar.gz", hash = "sha256:6ec12890a2dab7946721edbfbcd91f3319c6ccc9aec47be7c7e6b7011ee6645f"}, +] + +[[package]] +name = "notebook" +version = "7.3.2" +requires_python = ">=3.8" +summary = "Jupyter Notebook - A web-based notebook environment for interactive computing" +groups = ["qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "jupyter-server<3,>=2.4.0", + "jupyterlab-server<3,>=2.27.1", + "jupyterlab<4.4,>=4.3.4", + "notebook-shim<0.3,>=0.2", + "tornado>=6.2.0", +] +files = [ + {file = "notebook-7.3.2-py3-none-any.whl", hash = "sha256:e5f85fc59b69d3618d73cf27544418193ff8e8058d5bf61d315ce4f473556288"}, + {file = "notebook-7.3.2.tar.gz", hash = "sha256:705e83a1785f45b383bf3ee13cb76680b92d24f56fb0c7d2136fe1d850cd3ca8"}, +] + +[[package]] +name = "notebook-shim" +version = "0.2.4" +requires_python = ">=3.7" +summary = "A shim layer for notebook traits and config" +groups = ["qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "jupyter-server<3,>=1.8", +] +files = [ + {file = "notebook_shim-0.2.4-py3-none-any.whl", hash = "sha256:411a5be4e9dc882a074ccbcae671eda64cceb068767e9a3419096986560e1cef"}, + {file = "notebook_shim-0.2.4.tar.gz", hash = "sha256:b4b2cfa1b65d98307ca24361f5b30fe785b53c3fd07b7a47e89acb5e6ac638cb"}, +] + +[[package]] +name = "numpy" +version = "1.24.4" +requires_python = ">=3.8" +summary = "Fundamental package for array computing in Python" +groups = ["default", "pyvista"] +marker = "python_version == \"3.8\"" +files = [ + {file = "numpy-1.24.4-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:04640dab83f7c6c85abf9cd729c5b65f1ebd0ccf9de90b270cd61935eef0197f"}, + {file = "numpy-1.24.4.tar.gz", hash = "sha256:80f5e3a4e498641401868df4208b74581206afbee7cf7b8329daae82676d9463"}, +] + +[[package]] +name = "openpyxl" +version = "3.1.5" +requires_python = ">=3.8" +summary = "A Python library to read/write Excel 2010 xlsx/xlsm files" +groups = ["openpyxl"] +marker = "python_version == \"3.8\"" +dependencies = [ + "et-xmlfile", +] +files = [ + {file = "openpyxl-3.1.5-py2.py3-none-any.whl", hash = "sha256:5282c12b107bffeef825f4617dc029afaf41d0ea60823bbb665ef3079dc79de2"}, + {file = "openpyxl-3.1.5.tar.gz", hash = "sha256:cf0e3cf56142039133628b5acffe8ef0c12bc902d2aadd3e0fe5878dc08d1050"}, +] + +[[package]] +name = "overrides" +version = "7.7.0" +requires_python = ">=3.6" +summary = "A decorator to automatically detect mismatch when overriding a method." +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "typing; python_version < \"3.5\"", +] +files = [ + {file = "overrides-7.7.0-py3-none-any.whl", hash = "sha256:c7ed9d062f78b8e4c1a7b70bd8796b35ead4d9f510227ef9c5dc7626c60d7e49"}, + {file = "overrides-7.7.0.tar.gz", hash = "sha256:55158fa3d93b98cc75299b1e67078ad9003ca27945c76162c1c0766d6f91820a"}, +] + +[[package]] +name = "packaging" +version = "24.2" +requires_python = ">=3.8" +summary = "Core utilities for Python packages" +groups = ["default", "docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "packaging-24.2-py3-none-any.whl", hash = "sha256:09abb1bccd265c01f4a3aa3f7a7db064b36514d2cba19a2f694fe6150451a759"}, + {file = "packaging-24.2.tar.gz", hash = "sha256:c228a6dc5e932d346bc5739379109d49e8853dd8223571c7c5b55260edc0b97f"}, +] + +[[package]] +name = "pandas" +version = "2.0.3" +requires_python = ">=3.8" +summary = "Powerful data structures for data analysis, time series, and statistics" +groups = ["default"] +marker = "python_version == \"3.8\"" +dependencies = [ + "numpy>=1.20.3; python_version < \"3.10\"", + "numpy>=1.21.0; python_version >= \"3.10\"", + "numpy>=1.23.2; python_version >= \"3.11\"", + "python-dateutil>=2.8.2", + "pytz>=2020.1", + "tzdata>=2022.1", +] +files = [ + {file = "pandas-2.0.3-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:32fca2ee1b0d93dd71d979726b12b61faa06aeb93cf77468776287f41ff8fdc5"}, + {file = "pandas-2.0.3.tar.gz", hash = "sha256:c02f372a88e0d17f36d3093a644c73cfc1788e876a7c4bcb4020a77512e2043c"}, +] + +[[package]] +name = "pandoc" +version = "2.4" +summary = "Pandoc Documents for Python" +groups = ["docs"] +marker = "python_version == \"3.8\"" +dependencies = [ + "plumbum", + "ply", +] +files = [ + {file = "pandoc-2.4.tar.gz", hash = "sha256:ecd1f8cbb7f4180c6b5db4a17a7c1a74df519995f5f186ef81ce72a9cbd0dd9a"}, +] + +[[package]] +name = "pandocfilters" +version = "1.5.1" +requires_python = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*" +summary = "Utilities for writing pandoc filters in python" +groups = ["docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "pandocfilters-1.5.1-py2.py3-none-any.whl", hash = "sha256:93be382804a9cdb0a7267585f157e5d1731bbe5545a85b268d6f5fe6232de2bc"}, + {file = "pandocfilters-1.5.1.tar.gz", hash = "sha256:002b4a555ee4ebc03f8b66307e287fa492e4a77b4ea14d3f934328297bb4939e"}, +] + +[[package]] +name = "parso" +version = "0.8.4" +requires_python = ">=3.6" +summary = "A Python Parser" +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "parso-0.8.4-py2.py3-none-any.whl", hash = "sha256:a418670a20291dacd2dddc80c377c5c3791378ee1e8d12bffc35420643d43f18"}, + {file = "parso-0.8.4.tar.gz", hash = "sha256:eb3a7b58240fb99099a345571deecc0f9540ea5f4dd2fe14c2a99d6b281ab92d"}, +] + +[[package]] +name = "pexpect" +version = "4.9.0" +summary = "Pexpect allows easy control of interactive console applications." +groups = ["pyvista", "qa"] +marker = "sys_platform != \"win32\" and python_version == \"3.8\"" +dependencies = [ + "ptyprocess>=0.5", +] +files = [ + {file = "pexpect-4.9.0-py2.py3-none-any.whl", hash = "sha256:7236d1e080e4936be2dc3e326cec0af72acf9212a7e1d060210e70a47e253523"}, + {file = "pexpect-4.9.0.tar.gz", hash = "sha256:ee7d41123f3c9911050ea2c2dac107568dc43b2d3b0c7557a33212c398ead30f"}, +] + +[[package]] +name = "pickleshare" +version = "0.7.5" +summary = "Tiny 'shelve'-like database with concurrency support" +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "pathlib2; python_version in \"2.6 2.7 3.2 3.3\"", +] +files = [ + {file = "pickleshare-0.7.5-py2.py3-none-any.whl", hash = "sha256:9649af414d74d4df115d5d718f82acb59c9d418196b7b4290ed47a12ce62df56"}, + {file = "pickleshare-0.7.5.tar.gz", hash = "sha256:87683d47965c1da65cdacaf31c8441d12b8044cdec9aca500cd78fc2c683afca"}, +] + +[[package]] +name = "pillow" +version = "10.4.0" +requires_python = ">=3.8" +summary = "Python Imaging Library (Fork)" +groups = ["default", "pyvista"] +marker = "python_version == \"3.8\"" +files = [ + {file = "pillow-10.4.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:7c1ee6f42250df403c5f103cbd2768a28fe1a0ea1f0f03fe151c8741e1469c8b"}, + {file = "pillow-10.4.0.tar.gz", hash = "sha256:166c1cd4d24309b30d61f79f4a9114b7b2313d7450912277855ff5dfd7cd4a06"}, +] + +[[package]] +name = "pkgutil-resolve-name" +version = "1.3.10" +requires_python = ">=3.6" +summary = "Resolve a name to an object." +groups = ["docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "pkgutil_resolve_name-1.3.10-py3-none-any.whl", hash = "sha256:ca27cc078d25c5ad71a9de0a7a330146c4e014c2462d9af19c6b828280649c5e"}, + {file = "pkgutil_resolve_name-1.3.10.tar.gz", hash = "sha256:357d6c9e6a755653cfd78893817c0853af365dd51ec97f3d358a819373bbd174"}, +] + +[[package]] +name = "platformdirs" +version = "4.3.6" +requires_python = ">=3.8" +summary = "A small Python package for determining appropriate platform-specific dirs, e.g. a `user data dir`." +groups = ["docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "platformdirs-4.3.6-py3-none-any.whl", hash = "sha256:73e575e1408ab8103900836b97580d5307456908a03e92031bab39e4554cc3fb"}, + {file = "platformdirs-4.3.6.tar.gz", hash = "sha256:357fb2acbc885b0419afd3ce3ed34564c13c9b95c89360cd9563f73aa5e2b907"}, +] + +[[package]] +name = "pluggy" +version = "1.5.0" +requires_python = ">=3.8" +summary = "plugin and hook calling mechanisms for python" +groups = ["qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "pluggy-1.5.0-py3-none-any.whl", hash = "sha256:44e1ad92c8ca002de6377e165f3e0f1be63266ab4d554740532335b9d75ea669"}, + {file = "pluggy-1.5.0.tar.gz", hash = "sha256:2cffa88e94fdc978c4c574f15f9e59b7f4201d439195c3715ca9e2486f1d0cf1"}, +] + +[[package]] +name = "plumbum" +version = "1.8.3" +requires_python = ">=3.6" +summary = "Plumbum: shell combinators library" +groups = ["docs"] +marker = "python_version == \"3.8\"" +dependencies = [ + "pywin32; platform_system == \"Windows\" and platform_python_implementation != \"PyPy\"", +] +files = [ + {file = "plumbum-1.8.3-py3-none-any.whl", hash = "sha256:8595d36dae2472587d6f59789c8d7b26250f45f6f6ed75ccb378de59ee7b9cf9"}, + {file = "plumbum-1.8.3.tar.gz", hash = "sha256:6092c85ab970b7a7a9d5d85c75200bc93be82b33c9bdf640ffa87d2d7c8709f0"}, +] + +[[package]] +name = "ply" +version = "3.11" +summary = "Python Lex & Yacc" +groups = ["docs"] +marker = "python_version == \"3.8\"" +files = [ + {file = "ply-3.11-py2.py3-none-any.whl", hash = "sha256:096f9b8350b65ebd2fd1346b12452efe5b9607f7482813ffca50c22722a807ce"}, + {file = "ply-3.11.tar.gz", hash = "sha256:00c7c1aaa88358b9c765b6d3000c6eec0ba42abca5351b095321aef446081da3"}, +] + +[[package]] +name = "pooch" +version = "1.8.2" +requires_python = ">=3.7" +summary = "A friend to fetch your data files" +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +dependencies = [ + "packaging>=20.0", + "platformdirs>=2.5.0", + "requests>=2.19.0", +] +files = [ + {file = "pooch-1.8.2-py3-none-any.whl", hash = "sha256:3529a57096f7198778a5ceefd5ac3ef0e4d06a6ddaf9fc2d609b806f25302c47"}, + {file = "pooch-1.8.2.tar.gz", hash = "sha256:76561f0de68a01da4df6af38e9955c4c9d1a5c90da73f7e40276a5728ec83d10"}, +] + +[[package]] +name = "pre-commit" +version = "3.5.0" +requires_python = ">=3.8" +summary = "A framework for managing and maintaining multi-language pre-commit hooks." +groups = ["qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "cfgv>=2.0.0", + "identify>=1.0.0", + "nodeenv>=0.11.1", + "pyyaml>=5.1", + "virtualenv>=20.10.0", +] +files = [ + {file = "pre_commit-3.5.0-py2.py3-none-any.whl", hash = "sha256:841dc9aef25daba9a0238cd27984041fa0467b4199fc4852e27950664919f660"}, + {file = "pre_commit-3.5.0.tar.gz", hash = "sha256:5804465c675b659b0862f07907f96295d490822a450c4c40e747d0b1c6ebcb32"}, +] + +[[package]] +name = "prometheus-client" +version = "0.20.0" +requires_python = ">=3.8" +summary = "Python client for the Prometheus monitoring system." +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "prometheus_client-0.20.0-py3-none-any.whl", hash = "sha256:cde524a85bce83ca359cc837f28b8c0db5cac7aa653a588fd7e84ba061c329e7"}, + {file = "prometheus_client-0.20.0.tar.gz", hash = "sha256:287629d00b147a32dcb2be0b9df905da599b2d82f80377083ec8463309a4bb89"}, +] + +[[package]] +name = "prompt-toolkit" +version = "3.0.47" +requires_python = ">=3.7.0" +summary = "Library for building powerful interactive command lines in Python" +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "wcwidth", +] +files = [ + {file = "prompt_toolkit-3.0.47-py3-none-any.whl", hash = "sha256:0d7bfa67001d5e39d02c224b663abc33687405033a8c422d0d675a5a13361d10"}, + {file = "prompt_toolkit-3.0.47.tar.gz", hash = "sha256:1e1b29cb58080b1e69f207c893a1a7bf16d127a5c30c9d17a25a5d77792e5360"}, +] + +[[package]] +name = "propcache" +version = "0.2.0" +requires_python = ">=3.8" +summary = "Accelerated property cache" +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +files = [ + {file = "propcache-0.2.0-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:53d1bd3f979ed529f0805dd35ddaca330f80a9a6d90bc0121d2ff398f8ed8861"}, + {file = "propcache-0.2.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:77a86c261679ea5f3896ec060be9dc8e365788248cc1e049632a1be682442063"}, + {file = "propcache-0.2.0-py3-none-any.whl", hash = "sha256:2ccc28197af5313706511fab3a8b66dcd6da067a1331372c82ea1cb74285e036"}, + {file = "propcache-0.2.0.tar.gz", hash = "sha256:df81779732feb9d01e5d513fad0122efb3d53bbc75f61b2a4f29a020bc985e70"}, +] + +[[package]] +name = "psutil" +version = "6.0.0" +requires_python = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7" +summary = "Cross-platform lib for process and system monitoring in Python." +groups = ["qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "psutil-6.0.0-cp38-abi3-macosx_11_0_arm64.whl", hash = "sha256:ffe7fc9b6b36beadc8c322f84e1caff51e8703b88eee1da46d1e3a6ae11b4fd0"}, + {file = "psutil-6.0.0.tar.gz", hash = "sha256:8faae4f310b6d969fa26ca0545338b21f73c6b15db7c4a8d934a5482faa818f2"}, +] + +[[package]] +name = "ptyprocess" +version = "0.7.0" +summary = "Run a subprocess in a pseudo terminal" +groups = ["pyvista", "qa"] +marker = "os_name != \"nt\" and python_version == \"3.8\" or sys_platform != \"win32\" and python_version == \"3.8\"" +files = [ + {file = "ptyprocess-0.7.0-py2.py3-none-any.whl", hash = "sha256:4b41f3967fce3af57cc7e94b888626c18bf37a083e3651ca8feeb66d492fef35"}, + {file = "ptyprocess-0.7.0.tar.gz", hash = "sha256:5c5d0a3b48ceee0b48485e0c26037c0acd7d29765ca3fbb5cb3831d347423220"}, +] + +[[package]] +name = "pure-eval" +version = "0.2.3" +summary = "Safely evaluate AST nodes without side effects" +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "pure_eval-0.2.3-py3-none-any.whl", hash = "sha256:1db8e35b67b3d218d818ae653e27f06c3aa420901fa7b081ca98cbedc874e0d0"}, + {file = "pure_eval-0.2.3.tar.gz", hash = "sha256:5f4e983f40564c576c7c8635ae88db5956bb2229d7e9237d03b3c0b0190eaf42"}, +] + +[[package]] +name = "pycparser" +version = "2.22" +requires_python = ">=3.8" +summary = "C parser in Python" +groups = ["docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "pycparser-2.22-py3-none-any.whl", hash = "sha256:c3702b6d3dd8c7abc1afa565d7e63d53a1d0bd86cdc24edd75470f4de499cfcc"}, + {file = "pycparser-2.22.tar.gz", hash = "sha256:491c8be9c040f5390f5bf44a5b07752bd07f56edf992381b05c701439eec10f6"}, +] + +[[package]] +name = "pydantic" +version = "2.9.1" +requires_python = ">=3.8" +summary = "Data validation using Python type hints" +groups = ["default"] +marker = "python_version == \"3.8\"" +dependencies = [ + "annotated-types>=0.6.0", + "pydantic-core==2.23.3", + "typing-extensions>=4.12.2; python_version >= \"3.13\"", + "typing-extensions>=4.6.1; python_version < \"3.13\"", +] +files = [ + {file = "pydantic-2.9.1-py3-none-any.whl", hash = "sha256:7aff4db5fdf3cf573d4b3c30926a510a10e19a0774d38fc4967f78beb6deb612"}, + {file = "pydantic-2.9.1.tar.gz", hash = "sha256:1363c7d975c7036df0db2b4a61f2e062fbc0aa5ab5f2772e0ffc7191a4f4bce2"}, +] + +[[package]] +name = "pydantic-core" +version = "2.23.3" +requires_python = ">=3.8" +summary = "Core functionality for Pydantic validation and serialization" +groups = ["default"] +marker = "python_version == \"3.8\"" +dependencies = [ + "typing-extensions!=4.7.0,>=4.6.0", +] +files = [ + {file = "pydantic_core-2.23.3-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:6cb968da9a0746a0cf521b2b5ef25fc5a0bee9b9a1a8214e0a1cfaea5be7e8a4"}, + {file = "pydantic_core-2.23.3.tar.gz", hash = "sha256:3cb0f65d8b4121c1b015c60104a685feb929a29d7cf204387c7f2688c7974690"}, +] + +[[package]] +name = "pygments" +version = "2.18.0" +requires_python = ">=3.8" +summary = "Pygments is a syntax highlighting package written in Python." +groups = ["docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "pygments-2.18.0-py3-none-any.whl", hash = "sha256:b8e6aca0523f3ab76fee51799c488e38782ac06eafcf95e7ba832985c8e7b13a"}, + {file = "pygments-2.18.0.tar.gz", hash = "sha256:786ff802f32e91311bff3889f6e9a86e81505fe99f2735bb6d60ae0c5004f199"}, +] + +[[package]] +name = "pyparsing" +version = "3.1.4" +requires_python = ">=3.6.8" +summary = "pyparsing module - Classes and methods to define and execute parsing grammars" +groups = ["default", "pyvista"] +marker = "python_version == \"3.8\"" +files = [ + {file = "pyparsing-3.1.4-py3-none-any.whl", hash = "sha256:a6a7ee4235a3f944aa1fa2249307708f893fe5717dc603503c6c7969c070fb7c"}, + {file = "pyparsing-3.1.4.tar.gz", hash = "sha256:f86ec8d1a83f11977c9a6ea7598e8c27fc5cddfa5b07ea2241edbbde1d7bc032"}, +] + +[[package]] +name = "pyproject-api" +version = "1.8.0" +requires_python = ">=3.8" +summary = "API to interact with the python pyproject.toml based projects" +groups = ["qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "packaging>=24.1", + "tomli>=2.0.1; python_version < \"3.11\"", +] +files = [ + {file = "pyproject_api-1.8.0-py3-none-any.whl", hash = "sha256:3d7d347a047afe796fd5d1885b1e391ba29be7169bd2f102fcd378f04273d228"}, + {file = "pyproject_api-1.8.0.tar.gz", hash = "sha256:77b8049f2feb5d33eefcc21b57f1e279636277a8ac8ad6b5871037b243778496"}, +] + +[[package]] +name = "pyqt5" +version = "5.15.10" +requires_python = ">=3.7" +summary = "Python bindings for the Qt cross platform application toolkit" +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +dependencies = [ + "PyQt5-Qt5>=5.15.2", + "PyQt5-sip<13,>=12.13", +] +files = [ + {file = "PyQt5-5.15.10-cp37-abi3-macosx_11_0_arm64.whl", hash = "sha256:862cea3be95b4b0a2b9678003b3a18edf7bd5eafd673860f58820f246d4bf616"}, + {file = "PyQt5-5.15.10.tar.gz", hash = "sha256:d46b7804b1b10a4ff91753f8113e5b5580d2b4462f3226288e2d84497334898a"}, +] + +[[package]] +name = "pyqt5-qt5" +version = "5.15.14" +summary = "The subset of a Qt installation needed by PyQt5." +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +files = [ + {file = "PyQt5_Qt5-5.15.14-py3-none-macosx_11_0_arm64.whl", hash = "sha256:730da7e6a97f6bad1b6df21082fe625647730418bc83e20cbc2ff6401ed0a8be"}, +] + +[[package]] +name = "pyqt5-sip" +version = "12.15.0" +requires_python = ">=3.8" +summary = "The sip module support for PyQt5" +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +files = [ + {file = "PyQt5_sip-12.15.0-cp38-cp38-macosx_11_0_universal2.whl", hash = "sha256:91b9538458a3a23e033c213bc879ce64f3d0a33d5a49cbd03e1e584efe307a35"}, + {file = "PyQt5_sip-12.15.0.tar.gz", hash = "sha256:d23fdfcf363b5cedd9d39f8a9c5710e7d52804f5b08a58e91c638b36eafcb702"}, +] + +[[package]] +name = "pytest" +version = "8.3.3" +requires_python = ">=3.8" +summary = "pytest: simple powerful testing with Python" +groups = ["qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "colorama; sys_platform == \"win32\"", + "exceptiongroup>=1.0.0rc8; python_version < \"3.11\"", + "iniconfig", + "packaging", + "pluggy<2,>=1.5", + "tomli>=1; python_version < \"3.11\"", +] +files = [ + {file = "pytest-8.3.3-py3-none-any.whl", hash = "sha256:a6853c7375b2663155079443d2e45de913a911a11d669df02a50814944db57b2"}, + {file = "pytest-8.3.3.tar.gz", hash = "sha256:70b98107bd648308a7952b06e6ca9a50bc660be218d53c257cc1fc94fda10181"}, +] + +[[package]] +name = "pytest-cov" +version = "5.0.0" +requires_python = ">=3.8" +summary = "Pytest plugin for measuring coverage." +groups = ["qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "coverage[toml]>=5.2.1", + "pytest>=4.6", +] +files = [ + {file = "pytest-cov-5.0.0.tar.gz", hash = "sha256:5837b58e9f6ebd335b0f8060eecce69b662415b16dc503883a02f45dfeb14857"}, + {file = "pytest_cov-5.0.0-py3-none-any.whl", hash = "sha256:4f0764a1219df53214206bf1feea4633c3b558a2925c8b59f144f682861ce652"}, +] + +[[package]] +name = "python-dateutil" +version = "2.9.0.post0" +requires_python = "!=3.0.*,!=3.1.*,!=3.2.*,>=2.7" +summary = "Extensions to the standard Python datetime module" +groups = ["default", "docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "six>=1.5", +] +files = [ + {file = "python-dateutil-2.9.0.post0.tar.gz", hash = "sha256:37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3"}, + {file = "python_dateutil-2.9.0.post0-py2.py3-none-any.whl", hash = "sha256:a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427"}, +] + +[[package]] +name = "python-json-logger" +version = "2.0.7" +requires_python = ">=3.6" +summary = "A python library adding a json log formatter" +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "python-json-logger-2.0.7.tar.gz", hash = "sha256:23e7ec02d34237c5aa1e29a070193a4ea87583bb4e7f8fd06d3de8264c4b2e1c"}, + {file = "python_json_logger-2.0.7-py3-none-any.whl", hash = "sha256:f380b826a991ebbe3de4d897aeec42760035ac760345e57b812938dc8b35e2bd"}, +] + +[[package]] +name = "pytz" +version = "2024.2" +summary = "World timezone definitions, modern and historical" +groups = ["default", "docs", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "pytz-2024.2-py2.py3-none-any.whl", hash = "sha256:31c7c1817eb7fae7ca4b8c7ee50c72f93aa2dd863de768e1ef4245d426aa0725"}, + {file = "pytz-2024.2.tar.gz", hash = "sha256:2aa355083c50a0f93fa581709deac0c9ad65cca8a9e9beac660adcbd493c798a"}, +] + +[[package]] +name = "pyvista" +version = "0.44.1" +requires_python = ">=3.8" +summary = "Easier Pythonic interface to VTK" +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +dependencies = [ + "matplotlib>=3.0.1", + "numpy>=1.21.0", + "pillow", + "pooch", + "scooby>=0.5.1", + "typing-extensions", + "vtk", +] +files = [ + {file = "pyvista-0.44.1-py3-none-any.whl", hash = "sha256:7a80e8114220ca36d57a4def8e6a3067c908b53b62aa426ea76c76069bb6d1c0"}, + {file = "pyvista-0.44.1.tar.gz", hash = "sha256:63976f5d57d151b3f7e1616dde40dcf56a66d1f37f6db067087fa9cc9667f512"}, +] + +[[package]] +name = "pyvista" +version = "0.44.1" +extras = ["all"] +requires_python = ">=3.8" +summary = "Easier Pythonic interface to VTK" +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +dependencies = [ + "pyvista==0.44.1", + "pyvista[colormaps,io,jupyter]", +] +files = [ + {file = "pyvista-0.44.1-py3-none-any.whl", hash = "sha256:7a80e8114220ca36d57a4def8e6a3067c908b53b62aa426ea76c76069bb6d1c0"}, + {file = "pyvista-0.44.1.tar.gz", hash = "sha256:63976f5d57d151b3f7e1616dde40dcf56a66d1f37f6db067087fa9cc9667f512"}, +] + +[[package]] +name = "pyvista" +version = "0.44.1" +extras = ["colormaps", "io", "jupyter"] +requires_python = ">=3.8" +summary = "Easier Pythonic interface to VTK" +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +dependencies = [ + "cmocean", + "colorcet", + "imageio", + "ipywidgets", + "jupyter-server-proxy", + "meshio>=5.2", + "nest-asyncio", + "pyvista==0.44.1", + "trame-client>=2.12.7", + "trame-server>=2.11.7", + "trame-vtk>=2.5.8", + "trame-vuetify>=2.3.1", + "trame>=2.5.2", +] +files = [ + {file = "pyvista-0.44.1-py3-none-any.whl", hash = "sha256:7a80e8114220ca36d57a4def8e6a3067c908b53b62aa426ea76c76069bb6d1c0"}, + {file = "pyvista-0.44.1.tar.gz", hash = "sha256:63976f5d57d151b3f7e1616dde40dcf56a66d1f37f6db067087fa9cc9667f512"}, +] + +[[package]] +name = "pyvistaqt" +version = "0.11.1" +requires_python = ">=3.7" +summary = "pyvista qt plotter" +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +dependencies = [ + "QtPy>=1.9.0", + "pyvista>=0.32.0", +] +files = [ + {file = "pyvistaqt-0.11.1-py3-none-any.whl", hash = "sha256:3ddc05418fcb297d471e7f7c0fdc89dbd5b6050653b4a86e66e5c1ce7e3563cc"}, + {file = "pyvistaqt-0.11.1.tar.gz", hash = "sha256:5403bfeb82cf063288107a9be9780ca3ca70948e73d33d16a65a83a711d51a36"}, +] + +[[package]] +name = "pyyaml" +version = "6.0.2" +requires_python = ">=3.8" +summary = "YAML parser and emitter for Python" +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "pyyaml-6.0.2.tar.gz", hash = "sha256:d584d9ec91ad65861cc08d42e834324ef890a082e591037abe114850ff7bbc3e"}, +] + +[[package]] +name = "pyzmq" +version = "26.2.0" +requires_python = ">=3.7" +summary = "Python bindings for 0MQ" +groups = ["docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "cffi; implementation_name == \"pypy\"", +] +files = [ + {file = "pyzmq-26.2.0-cp38-cp38-macosx_10_15_universal2.whl", hash = "sha256:2eb7735ee73ca1b0d71e0e67c3739c689067f055c764f73aac4cc8ecf958ee3f"}, + {file = "pyzmq-26.2.0.tar.gz", hash = "sha256:070672c258581c8e4f640b5159297580a9974b026043bd4ab0470be9ed324f1f"}, +] + +[[package]] +name = "qtpy" +version = "2.4.1" +requires_python = ">=3.7" +summary = "Provides an abstraction layer on top of the various Qt bindings (PyQt5/6 and PySide2/6)." +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +dependencies = [ + "packaging", +] +files = [ + {file = "QtPy-2.4.1-py3-none-any.whl", hash = "sha256:1c1d8c4fa2c884ae742b069151b0abe15b3f70491f3972698c683b8e38de839b"}, + {file = "QtPy-2.4.1.tar.gz", hash = "sha256:a5a15ffd519550a1361bdc56ffc07fda56a6af7292f17c7b395d4083af632987"}, +] + +[[package]] +name = "referencing" +version = "0.35.1" +requires_python = ">=3.8" +summary = "JSON Referencing + Python" +groups = ["docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "attrs>=22.2.0", + "rpds-py>=0.7.0", +] +files = [ + {file = "referencing-0.35.1-py3-none-any.whl", hash = "sha256:eda6d3234d62814d1c64e305c1331c9a3a6132da475ab6382eaa997b21ee75de"}, + {file = "referencing-0.35.1.tar.gz", hash = "sha256:25b42124a6c8b632a425174f24087783efb348a6f1e0008e63cd4466fedf703c"}, +] + +[[package]] +name = "requests" +version = "2.32.3" +requires_python = ">=3.8" +summary = "Python HTTP for Humans." +groups = ["docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "certifi>=2017.4.17", + "charset-normalizer<4,>=2", + "idna<4,>=2.5", + "urllib3<3,>=1.21.1", +] +files = [ + {file = "requests-2.32.3-py3-none-any.whl", hash = "sha256:70761cfe03c773ceb22aa2f671b4757976145175cdfca038c02654d061d6dcc6"}, + {file = "requests-2.32.3.tar.gz", hash = "sha256:55365417734eb18255590a9ff9eb97e9e1da868d4ccd6402399eaf68af20a760"}, +] + +[[package]] +name = "rfc3339-validator" +version = "0.1.4" +requires_python = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*" +summary = "A pure python RFC3339 validator" +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "six", +] +files = [ + {file = "rfc3339_validator-0.1.4-py2.py3-none-any.whl", hash = "sha256:24f6ec1eda14ef823da9e36ec7113124b39c04d50a4d3d3a3c2859577e7791fa"}, + {file = "rfc3339_validator-0.1.4.tar.gz", hash = "sha256:138a2abdf93304ad60530167e51d2dfb9549521a836871b88d7f4695d0022f6b"}, +] + +[[package]] +name = "rfc3986-validator" +version = "0.1.1" +requires_python = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*" +summary = "Pure python rfc3986 validator" +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "rfc3986_validator-0.1.1-py2.py3-none-any.whl", hash = "sha256:2f235c432ef459970b4306369336b9d5dbdda31b510ca1e327636e01f528bfa9"}, + {file = "rfc3986_validator-0.1.1.tar.gz", hash = "sha256:3d44bde7921b3b9ec3ae4e3adca370438eccebc676456449b145d533b240d055"}, +] + +[[package]] +name = "rich" +version = "13.8.1" +requires_python = ">=3.7.0" +summary = "Render rich text, tables, progress bars, syntax highlighting, markdown and more to the terminal" +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +dependencies = [ + "markdown-it-py>=2.2.0", + "pygments<3.0.0,>=2.13.0", + "typing-extensions<5.0,>=4.0.0; python_version < \"3.9\"", +] +files = [ + {file = "rich-13.8.1-py3-none-any.whl", hash = "sha256:1760a3c0848469b97b558fc61c85233e3dafb69c7a071b4d60c38099d3cd4c06"}, + {file = "rich-13.8.1.tar.gz", hash = "sha256:8260cda28e3db6bf04d2d1ef4dbc03ba80a824c88b0e7668a0f23126a424844a"}, +] + +[[package]] +name = "rpds-py" +version = "0.20.0" +requires_python = ">=3.8" +summary = "Python bindings to Rust's persistent data structures (rpds)" +groups = ["docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "rpds_py-0.20.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:1e5f3cd7397c8f86c8cc72d5a791071431c108edd79872cdd96e00abd8497d29"}, + {file = "rpds_py-0.20.0.tar.gz", hash = "sha256:d72a210824facfdaf8768cf2d7ca25a042c30320b3020de2fa04640920d4e121"}, +] + +[[package]] +name = "scipy" +version = "1.10.1" +requires_python = "<3.12,>=3.8" +summary = "Fundamental algorithms for scientific computing in Python" +groups = ["default"] +marker = "python_version == \"3.8\"" +dependencies = [ + "numpy<1.27.0,>=1.19.5", +] +files = [ + {file = "scipy-1.10.1-cp38-cp38-macosx_12_0_arm64.whl", hash = "sha256:39becb03541f9e58243f4197584286e339029e8908c46f7221abeea4b749fa88"}, + {file = "scipy-1.10.1.tar.gz", hash = "sha256:2cf9dfb80a7b4589ba4c40ce7588986d6d5cebc5457cad2c2880f6bc2d42f3a5"}, +] + +[[package]] +name = "scooby" +version = "0.10.0" +requires_python = ">=3.8" +summary = "A Great Dane turned Python environment detective" +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +files = [ + {file = "scooby-0.10.0-py3-none-any.whl", hash = "sha256:0a3d7e304f8ebb16f69ff7f6360c345d7f50b45f2ddbf7c3d18a6a0dc2cb03a6"}, + {file = "scooby-0.10.0.tar.gz", hash = "sha256:7ea33c262c0cc6a33c6eeeb5648df787be4f22660e53c114e5fff1b811a8854f"}, +] + +[[package]] +name = "send2trash" +version = "1.8.3" +requires_python = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7" +summary = "Send file to trash natively under Mac OS X, Windows and Linux" +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "Send2Trash-1.8.3-py3-none-any.whl", hash = "sha256:0c31227e0bd08961c7665474a3d1ef7193929fedda4233843689baa056be46c9"}, + {file = "Send2Trash-1.8.3.tar.gz", hash = "sha256:b18e7a3966d99871aefeb00cfbcfdced55ce4871194810fc71f4aa484b953abf"}, +] + +[[package]] +name = "setuptools" +version = "74.1.2" +requires_python = ">=3.8" +summary = "Easily download, build, install, upgrade, and uninstall Python packages" +groups = ["qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "setuptools-74.1.2-py3-none-any.whl", hash = "sha256:5f4c08aa4d3ebcb57a50c33b1b07e94315d7fc7230f7115e47fc99776c8ce308"}, + {file = "setuptools-74.1.2.tar.gz", hash = "sha256:95b40ed940a1c67eb70fc099094bd6e99c6ee7c23aa2306f4d2697ba7916f9c6"}, +] + +[[package]] +name = "simpervisor" +version = "1.0.0" +requires_python = ">=3.8" +summary = "Simple async process supervisor" +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +files = [ + {file = "simpervisor-1.0.0-py3-none-any.whl", hash = "sha256:3e313318264559beea3f475ead202bc1cd58a2f1288363abb5657d306c5b8388"}, + {file = "simpervisor-1.0.0.tar.gz", hash = "sha256:7eb87ca86d5e276976f5bb0290975a05d452c6a7b7f58062daea7d8369c823c1"}, +] + +[[package]] +name = "six" +version = "1.16.0" +requires_python = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*" +summary = "Python 2 and 3 compatibility utilities" +groups = ["default", "docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "six-1.16.0-py2.py3-none-any.whl", hash = "sha256:8abb2f1d86890a2dfb989f9a77cfcfd3e47c2a354b01111771326f8aa26e0254"}, + {file = "six-1.16.0.tar.gz", hash = "sha256:1e61c37477a1626458e36f7b1d82aa5c9b094fa4802892072e49de9c60c4c926"}, +] + +[[package]] +name = "sniffio" +version = "1.3.1" +requires_python = ">=3.7" +summary = "Sniff out which async library your code is running under" +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "sniffio-1.3.1-py3-none-any.whl", hash = "sha256:2f6da418d1f1e0fddd844478f41680e794e6051915791a034ff65e5f100525a2"}, + {file = "sniffio-1.3.1.tar.gz", hash = "sha256:f4324edc670a0f49750a81b895f35c3adb843cca46f0530f79fc1babb23789dc"}, +] + +[[package]] +name = "snowballstemmer" +version = "2.2.0" +summary = "This package provides 29 stemmers for 28 languages generated from Snowball algorithms." +groups = ["docs"] +marker = "python_version == \"3.8\"" +files = [ + {file = "snowballstemmer-2.2.0-py2.py3-none-any.whl", hash = "sha256:c8e1716e83cc398ae16824e5572ae04e0d9fc2c6b985fb0f900f5f0c96ecba1a"}, + {file = "snowballstemmer-2.2.0.tar.gz", hash = "sha256:09b16deb8547d3412ad7b590689584cd0fe25ec8db3be37788be3810cbf19cb1"}, +] + +[[package]] +name = "soupsieve" +version = "2.6" +requires_python = ">=3.8" +summary = "A modern CSS selector implementation for Beautiful Soup." +groups = ["docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "soupsieve-2.6-py3-none-any.whl", hash = "sha256:e72c4ff06e4fb6e4b5a9f0f55fe6e81514581fca1515028625d0f299c602ccc9"}, + {file = "soupsieve-2.6.tar.gz", hash = "sha256:e2e68417777af359ec65daac1057404a3c8a5455bb8abc36f1a9866ab1a51abb"}, +] + +[[package]] +name = "sphinx" +version = "7.1.2" +requires_python = ">=3.8" +summary = "Python documentation generator" +groups = ["docs"] +marker = "python_version == \"3.8\"" +dependencies = [ + "Jinja2>=3.0", + "Pygments>=2.13", + "alabaster<0.8,>=0.7", + "babel>=2.9", + "colorama>=0.4.5; sys_platform == \"win32\"", + "docutils<0.21,>=0.18.1", + "imagesize>=1.3", + "importlib-metadata>=4.8; python_version < \"3.10\"", + "packaging>=21.0", + "requests>=2.25.0", + "snowballstemmer>=2.0", + "sphinxcontrib-applehelp", + "sphinxcontrib-devhelp", + "sphinxcontrib-htmlhelp>=2.0.0", + "sphinxcontrib-jsmath", + "sphinxcontrib-qthelp", + "sphinxcontrib-serializinghtml>=1.1.5", +] +files = [ + {file = "sphinx-7.1.2-py3-none-any.whl", hash = "sha256:d170a81825b2fcacb6dfd5a0d7f578a053e45d3f2b153fecc948c37344eb4cbe"}, + {file = "sphinx-7.1.2.tar.gz", hash = "sha256:780f4d32f1d7d1126576e0e5ecc19dc32ab76cd24e950228dcf7b1f6d3d9e22f"}, +] + +[[package]] +name = "sphinx-rtd-theme" +version = "2.0.0" +requires_python = ">=3.6" +summary = "Read the Docs theme for Sphinx" +groups = ["docs"] +marker = "python_version == \"3.8\"" +dependencies = [ + "docutils<0.21", + "sphinx<8,>=5", + "sphinxcontrib-jquery<5,>=4", +] +files = [ + {file = "sphinx_rtd_theme-2.0.0-py2.py3-none-any.whl", hash = "sha256:ec93d0856dc280cf3aee9a4c9807c60e027c7f7b461b77aeffed682e68f0e586"}, + {file = "sphinx_rtd_theme-2.0.0.tar.gz", hash = "sha256:bd5d7b80622406762073a04ef8fadc5f9151261563d47027de09910ce03afe6b"}, +] + +[[package]] +name = "sphinxcontrib-applehelp" +version = "1.0.4" +requires_python = ">=3.8" +summary = "sphinxcontrib-applehelp is a Sphinx extension which outputs Apple help books" +groups = ["docs"] +marker = "python_version == \"3.8\"" +files = [ + {file = "sphinxcontrib-applehelp-1.0.4.tar.gz", hash = "sha256:828f867945bbe39817c210a1abfd1bc4895c8b73fcaade56d45357a348a07d7e"}, + {file = "sphinxcontrib_applehelp-1.0.4-py3-none-any.whl", hash = "sha256:29d341f67fb0f6f586b23ad80e072c8e6ad0b48417db2bde114a4c9746feb228"}, +] + +[[package]] +name = "sphinxcontrib-devhelp" +version = "1.0.2" +requires_python = ">=3.5" +summary = "sphinxcontrib-devhelp is a sphinx extension which outputs Devhelp document." +groups = ["docs"] +marker = "python_version == \"3.8\"" +files = [ + {file = "sphinxcontrib-devhelp-1.0.2.tar.gz", hash = "sha256:ff7f1afa7b9642e7060379360a67e9c41e8f3121f2ce9164266f61b9f4b338e4"}, + {file = "sphinxcontrib_devhelp-1.0.2-py2.py3-none-any.whl", hash = "sha256:8165223f9a335cc1af7ffe1ed31d2871f325254c0423bc0c4c7cd1c1e4734a2e"}, +] + +[[package]] +name = "sphinxcontrib-htmlhelp" +version = "2.0.1" +requires_python = ">=3.8" +summary = "sphinxcontrib-htmlhelp is a sphinx extension which renders HTML help files" +groups = ["docs"] +marker = "python_version == \"3.8\"" +files = [ + {file = "sphinxcontrib-htmlhelp-2.0.1.tar.gz", hash = "sha256:0cbdd302815330058422b98a113195c9249825d681e18f11e8b1f78a2f11efff"}, + {file = "sphinxcontrib_htmlhelp-2.0.1-py3-none-any.whl", hash = "sha256:c38cb46dccf316c79de6e5515e1770414b797162b23cd3d06e67020e1d2a6903"}, +] + +[[package]] +name = "sphinxcontrib-jquery" +version = "4.1" +requires_python = ">=2.7" +summary = "Extension to include jQuery on newer Sphinx releases" +groups = ["docs"] +marker = "python_version == \"3.8\"" +dependencies = [ + "Sphinx>=1.8", +] +files = [ + {file = "sphinxcontrib-jquery-4.1.tar.gz", hash = "sha256:1620739f04e36a2c779f1a131a2dfd49b2fd07351bf1968ced074365933abc7a"}, + {file = "sphinxcontrib_jquery-4.1-py2.py3-none-any.whl", hash = "sha256:f936030d7d0147dd026a4f2b5a57343d233f1fc7b363f68b3d4f1cb0993878ae"}, +] + +[[package]] +name = "sphinxcontrib-jsmath" +version = "1.0.1" +requires_python = ">=3.5" +summary = "A sphinx extension which renders display math in HTML via JavaScript" +groups = ["docs"] +marker = "python_version == \"3.8\"" +files = [ + {file = "sphinxcontrib-jsmath-1.0.1.tar.gz", hash = "sha256:a9925e4a4587247ed2191a22df5f6970656cb8ca2bd6284309578f2153e0c4b8"}, + {file = "sphinxcontrib_jsmath-1.0.1-py2.py3-none-any.whl", hash = "sha256:2ec2eaebfb78f3f2078e73666b1415417a116cc848b72e5172e596c871103178"}, +] + +[[package]] +name = "sphinxcontrib-qthelp" +version = "1.0.3" +requires_python = ">=3.5" +summary = "sphinxcontrib-qthelp is a sphinx extension which outputs QtHelp document." +groups = ["docs"] +marker = "python_version == \"3.8\"" +files = [ + {file = "sphinxcontrib-qthelp-1.0.3.tar.gz", hash = "sha256:4c33767ee058b70dba89a6fc5c1892c0d57a54be67ddd3e7875a18d14cba5a72"}, + {file = "sphinxcontrib_qthelp-1.0.3-py2.py3-none-any.whl", hash = "sha256:bd9fc24bcb748a8d51fd4ecaade681350aa63009a347a8c14e637895444dfab6"}, +] + +[[package]] +name = "sphinxcontrib-serializinghtml" +version = "1.1.5" +requires_python = ">=3.5" +summary = "sphinxcontrib-serializinghtml is a sphinx extension which outputs \"serialized\" HTML files (json and pickle)." +groups = ["docs"] +marker = "python_version == \"3.8\"" +files = [ + {file = "sphinxcontrib-serializinghtml-1.1.5.tar.gz", hash = "sha256:aa5f6de5dfdf809ef505c4895e51ef5c9eac17d0f287933eb49ec495280b6952"}, + {file = "sphinxcontrib_serializinghtml-1.1.5-py2.py3-none-any.whl", hash = "sha256:352a9a00ae864471d3a7ead8d7d79f5fc0b57e8b3f95e9867eb9eb28999b92fd"}, +] + +[[package]] +name = "stack-data" +version = "0.6.3" +summary = "Extract data from python stack frames and tracebacks for informative displays" +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "asttokens>=2.1.0", + "executing>=1.2.0", + "pure-eval", +] +files = [ + {file = "stack_data-0.6.3-py3-none-any.whl", hash = "sha256:d5558e0c25a4cb0853cddad3d77da9891a08cb85dd9f9f91b9f8cd66e511e695"}, + {file = "stack_data-0.6.3.tar.gz", hash = "sha256:836a778de4fec4dcd1dcd89ed8abff8a221f58308462e1c4aa2a3cf30148f0b9"}, +] + +[[package]] +name = "terminado" +version = "0.18.1" +requires_python = ">=3.8" +summary = "Tornado websocket backend for the Xterm.js Javascript terminal emulator library." +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "ptyprocess; os_name != \"nt\"", + "pywinpty>=1.1.0; os_name == \"nt\"", + "tornado>=6.1.0", +] +files = [ + {file = "terminado-0.18.1-py3-none-any.whl", hash = "sha256:a4468e1b37bb318f8a86514f65814e1afc977cf29b3992a4500d9dd305dcceb0"}, + {file = "terminado-0.18.1.tar.gz", hash = "sha256:de09f2c4b85de4765f7714688fff57d3e75bad1f909b589fde880460c753fd2e"}, +] + +[[package]] +name = "tinycss2" +version = "1.2.1" +requires_python = ">=3.7" +summary = "A tiny CSS parser" +groups = ["docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "webencodings>=0.4", +] +files = [ + {file = "tinycss2-1.2.1-py3-none-any.whl", hash = "sha256:2b80a96d41e7c3914b8cda8bc7f705a4d9c49275616e886103dd839dfc847847"}, + {file = "tinycss2-1.2.1.tar.gz", hash = "sha256:8cff3a8f066c2ec677c06dbc7b45619804a6938478d9d73c284b29d14ecb0627"}, +] + +[[package]] +name = "tomli" +version = "2.2.1" +requires_python = ">=3.8" +summary = "A lil' TOML parser" +groups = ["qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "tomli-2.2.1-py3-none-any.whl", hash = "sha256:cb55c73c5f4408779d0cf3eef9f762b9c9f147a77de7b258bef0a5628adc85cc"}, + {file = "tomli-2.2.1.tar.gz", hash = "sha256:cd45e1dc79c835ce60f7404ec8119f2eb06d38b1deba146f07ced3bbc44505ff"}, +] + +[[package]] +name = "tornado" +version = "6.4.2" +requires_python = ">=3.8" +summary = "Tornado is a Python web framework and asynchronous networking library, originally developed at FriendFeed." +groups = ["docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "tornado-6.4.2-cp38-abi3-macosx_10_9_universal2.whl", hash = "sha256:e828cce1123e9e44ae2a50a9de3055497ab1d0aeb440c5ac23064d9e44880da1"}, + {file = "tornado-6.4.2.tar.gz", hash = "sha256:92bad5b4746e9879fd7bf1eb21dce4e3fc5128d71601f80005afa39237ad620b"}, +] + +[[package]] +name = "tox" +version = "4.24.1" +requires_python = ">=3.8" +summary = "tox is a generic virtualenv management and test command line tool" +groups = ["qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "cachetools>=5.5", + "chardet>=5.2", + "colorama>=0.4.6", + "filelock>=3.16.1", + "packaging>=24.2", + "platformdirs>=4.3.6", + "pluggy>=1.5", + "pyproject-api>=1.8", + "tomli>=2.1; python_version < \"3.11\"", + "typing-extensions>=4.12.2; python_version < \"3.11\"", + "virtualenv>=20.27.1", +] +files = [ + {file = "tox-4.24.1-py3-none-any.whl", hash = "sha256:57ba7df7d199002c6df8c2db9e6484f3de6ca8f42013c083ea2d4d1e5c6bdc75"}, + {file = "tox-4.24.1.tar.gz", hash = "sha256:083a720adbc6166fff0b7d1df9d154f9d00bfccb9403b8abf6bc0ee435d6a62e"}, +] + +[[package]] +name = "tqdm" +version = "4.66.5" +requires_python = ">=3.7" +summary = "Fast, Extensible Progress Meter" +groups = ["default"] +marker = "python_version == \"3.8\"" +dependencies = [ + "colorama; platform_system == \"Windows\"", +] +files = [ + {file = "tqdm-4.66.5-py3-none-any.whl", hash = "sha256:90279a3770753eafc9194a0364852159802111925aa30eb3f9d85b0e805ac7cd"}, + {file = "tqdm-4.66.5.tar.gz", hash = "sha256:e1020aef2e5096702d8a025ac7d16b1577279c9d63f8375b63083e9a5f0fcbad"}, +] + +[[package]] +name = "traitlets" +version = "5.14.3" +requires_python = ">=3.8" +summary = "Traitlets Python configuration system" +groups = ["docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "traitlets-5.14.3-py3-none-any.whl", hash = "sha256:b74e89e397b1ed28cc831db7aea759ba6640cb3de13090ca145426688ff1ac4f"}, + {file = "traitlets-5.14.3.tar.gz", hash = "sha256:9ed0579d3502c94b4b3732ac120375cda96f923114522847de4b3bb98b96b6b7"}, +] + +[[package]] +name = "trame" +version = "3.6.5" +summary = "Trame, a framework to build applications in plain Python" +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +dependencies = [ + "trame-client<4,>=3", + "trame-server<4,>=3", + "wslink>=2.1.3", +] +files = [ + {file = "trame-3.6.5-py3-none-any.whl", hash = "sha256:58b5be29287d275dbd2be15b4e453c788361f640253ad153ca99fb3eb28e00f3"}, + {file = "trame-3.6.5.tar.gz", hash = "sha256:fc26a7067f94377e01263facb4cd40b111d799d970b5fc8e2aecb52e60378959"}, +] + +[[package]] +name = "trame-client" +version = "3.2.5" +summary = "Internal client of trame" +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +files = [ + {file = "trame-client-3.2.5.tar.gz", hash = "sha256:6f81c2a78389f1962bec38a318b0de47f241dae7778b25dba75fa3ed4d58bd33"}, + {file = "trame_client-3.2.5-py3-none-any.whl", hash = "sha256:023e062175fef67d45a65ac7a367b0e3468f6746c4f8c7a7aa3fe8e82273c62a"}, +] + +[[package]] +name = "trame-server" +version = "3.1.2" +summary = "Internal server side implementation of trame" +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +dependencies = [ + "more-itertools", + "wslink<3,>=2", +] +files = [ + {file = "trame-server-3.1.2.tar.gz", hash = "sha256:03bdd81e0132fb55de7b493c7ebdc4c21f6b0003960bceb3adca258fc432211f"}, + {file = "trame_server-3.1.2-py3-none-any.whl", hash = "sha256:b43d11edfbca012ac34a724dc751b6ecfaecd7d636eaea4ab0650d2adc9e3771"}, +] + +[[package]] +name = "trame-vtk" +version = "2.8.10" +summary = "VTK widgets for trame" +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +dependencies = [ + "trame-client", +] +files = [ + {file = "trame-vtk-2.8.10.tar.gz", hash = "sha256:4d8e38f7c1d5be8eafc28254bd5bd5dc5d4b336a334b944fc9383c9624184b5e"}, + {file = "trame_vtk-2.8.10-py3-none-any.whl", hash = "sha256:0fe850d1358193c1d73c9af87715d7877210df53edf4e4d468ba396c0845765c"}, +] + +[[package]] +name = "trame-vuetify" +version = "2.7.1" +summary = "Vuetify widgets for trame" +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +dependencies = [ + "trame-client", +] +files = [ + {file = "trame-vuetify-2.7.1.tar.gz", hash = "sha256:48443910a3a53b9fa040e05b261fce9326fe95309b3798d49f0d6aec84cbfdf8"}, + {file = "trame_vuetify-2.7.1-py3-none-any.whl", hash = "sha256:c6bfe3be49ac8b7aa354e4e2c1d92f2c2e9680eea563f46146eef6968a66c2de"}, +] + +[[package]] +name = "types-python-dateutil" +version = "2.9.0.20240906" +requires_python = ">=3.8" +summary = "Typing stubs for python-dateutil" +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "types-python-dateutil-2.9.0.20240906.tar.gz", hash = "sha256:9706c3b68284c25adffc47319ecc7947e5bb86b3773f843c73906fd598bc176e"}, + {file = "types_python_dateutil-2.9.0.20240906-py3-none-any.whl", hash = "sha256:27c8cc2d058ccb14946eebcaaa503088f4f6dbc4fb6093d3d456a49aef2753f6"}, +] + +[[package]] +name = "typing-extensions" +version = "4.12.2" +requires_python = ">=3.8" +summary = "Backported and Experimental Type Hints for Python 3.8+" +groups = ["default", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "typing_extensions-4.12.2-py3-none-any.whl", hash = "sha256:04e5ca0351e0f3f85c6853954072df659d0d13fac324d0072316b67d7794700d"}, + {file = "typing_extensions-4.12.2.tar.gz", hash = "sha256:1a7ead55c7e559dd4dee8856e3a88b41225abfe1ce8df57b7c13915fe121ffb8"}, +] + +[[package]] +name = "tzdata" +version = "2024.1" +requires_python = ">=2" +summary = "Provider of IANA time zone data" +groups = ["default"] +marker = "python_version == \"3.8\"" +files = [ + {file = "tzdata-2024.1-py2.py3-none-any.whl", hash = "sha256:9068bc196136463f5245e51efda838afa15aaeca9903f49050dfa2679db4d252"}, + {file = "tzdata-2024.1.tar.gz", hash = "sha256:2674120f8d891909751c38abcdfd386ac0a5a1127954fbc332af6b5ceae07efd"}, +] + +[[package]] +name = "uri-template" +version = "1.3.0" +requires_python = ">=3.7" +summary = "RFC 6570 URI Template Processor" +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "uri-template-1.3.0.tar.gz", hash = "sha256:0e00f8eb65e18c7de20d595a14336e9f337ead580c70934141624b6d1ffdacc7"}, + {file = "uri_template-1.3.0-py3-none-any.whl", hash = "sha256:a44a133ea12d44a0c0f06d7d42a52d71282e77e2f937d8abd5655b8d56fc1363"}, +] + +[[package]] +name = "urllib3" +version = "2.2.2" +requires_python = ">=3.8" +summary = "HTTP library with thread-safe connection pooling, file post, and more." +groups = ["docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "urllib3-2.2.2-py3-none-any.whl", hash = "sha256:a448b2f64d686155468037e1ace9f2d2199776e17f0a46610480d311f73e3472"}, + {file = "urllib3-2.2.2.tar.gz", hash = "sha256:dd505485549a7a552833da5e6063639d0d177c04f23bc3864e41e5dc5f612168"}, +] + +[[package]] +name = "virtualenv" +version = "20.29.1" +requires_python = ">=3.8" +summary = "Virtual Python Environment builder" +groups = ["qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "distlib<1,>=0.3.7", + "filelock<4,>=3.12.2", + "importlib-metadata>=6.6; python_version < \"3.8\"", + "platformdirs<5,>=3.9.1", +] +files = [ + {file = "virtualenv-20.29.1-py3-none-any.whl", hash = "sha256:4e4cb403c0b0da39e13b46b1b2476e505cb0046b25f242bee80f62bf990b2779"}, + {file = "virtualenv-20.29.1.tar.gz", hash = "sha256:b8b8970138d32fb606192cb97f6cd4bb644fa486be9308fb9b63f81091b5dc35"}, +] + +[[package]] +name = "vtk" +version = "9.3.1" +summary = "VTK is an open-source toolkit for 3D computer graphics, image processing, and visualization" +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +dependencies = [ + "matplotlib>=2.0.0", +] +files = [ + {file = "vtk-9.3.1-cp38-cp38-macosx_10_10_x86_64.whl", hash = "sha256:6adf4b812528a4658667602de8f023400c4381b8166f11b0ea8e0ab83c066539"}, +] + +[[package]] +name = "wcwidth" +version = "0.2.13" +summary = "Measures the displayed width of unicode strings in a terminal" +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "backports-functools-lru-cache>=1.2.1; python_version < \"3.2\"", +] +files = [ + {file = "wcwidth-0.2.13-py2.py3-none-any.whl", hash = "sha256:3da69048e4540d84af32131829ff948f1e022c1c6bdb8d6102117aac784f6859"}, + {file = "wcwidth-0.2.13.tar.gz", hash = "sha256:72ea0c06399eb286d978fdedb6923a9eb47e1c486ce63e9b4e64fc18303972b5"}, +] + +[[package]] +name = "webcolors" +version = "24.8.0" +requires_python = ">=3.8" +summary = "A library for working with the color formats defined by HTML and CSS." +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "webcolors-24.8.0-py3-none-any.whl", hash = "sha256:fc4c3b59358ada164552084a8ebee637c221e4059267d0f8325b3b560f6c7f0a"}, + {file = "webcolors-24.8.0.tar.gz", hash = "sha256:08b07af286a01bcd30d583a7acadf629583d1f79bfef27dd2c2c5c263817277d"}, +] + +[[package]] +name = "webencodings" +version = "0.5.1" +summary = "Character encoding aliases for legacy web content" +groups = ["docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "webencodings-0.5.1-py2.py3-none-any.whl", hash = "sha256:a0af1213f3c2226497a97e2b3aa01a7e4bee4f403f95be16fc9acd2947514a78"}, + {file = "webencodings-0.5.1.tar.gz", hash = "sha256:b36a1c245f2d304965eb4e0a82848379241dc04b865afcc4aab16748587e1923"}, +] + +[[package]] +name = "websocket-client" +version = "1.8.0" +requires_python = ">=3.8" +summary = "WebSocket client for Python with low level API options" +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "websocket_client-1.8.0-py3-none-any.whl", hash = "sha256:17b44cc997f5c498e809b22cdf2d9c7a9e71c02c8cc2b6c56e7c2d1239bfa526"}, + {file = "websocket_client-1.8.0.tar.gz", hash = "sha256:3239df9f44da632f96012472805d40a23281a991027ce11d2f45a6f24ac4c3da"}, +] + +[[package]] +name = "widgetsnbextension" +version = "4.0.13" +requires_python = ">=3.7" +summary = "Jupyter interactive widgets for Jupyter Notebook" +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +files = [ + {file = "widgetsnbextension-4.0.13-py3-none-any.whl", hash = "sha256:74b2692e8500525cc38c2b877236ba51d34541e6385eeed5aec15a70f88a6c71"}, + {file = "widgetsnbextension-4.0.13.tar.gz", hash = "sha256:ffcb67bc9febd10234a362795f643927f4e0c05d9342c727b65d2384f8feacb6"}, +] + +[[package]] +name = "wslink" +version = "2.1.3" +summary = "Python/JavaScript library for communicating over WebSocket" +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +dependencies = [ + "aiohttp<4", + "msgpack<2,>=1", +] +files = [ + {file = "wslink-2.1.3-py3-none-any.whl", hash = "sha256:a4a3689a30dd108255560e2f56903003355f4e0f3f6e5f12033a6de108bba18a"}, + {file = "wslink-2.1.3.tar.gz", hash = "sha256:528d008f1a6110bc8141c32588e43b16ff438cedb80c5bb85e9ef92ae753c98e"}, +] + +[[package]] +name = "yarl" +version = "1.15.2" +requires_python = ">=3.8" +summary = "Yet another URL library" +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +dependencies = [ + "idna>=2.0", + "multidict>=4.0", + "propcache>=0.2.0", +] +files = [ + {file = "yarl-1.15.2-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:fbbb63bed5fcd70cd3dd23a087cd78e4675fb5a2963b8af53f945cbbca79ae16"}, + {file = "yarl-1.15.2-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:af8ff8d7dc07ce873f643de6dfbcd45dc3db2c87462e5c387267197f59e6d776"}, + {file = "yarl-1.15.2-py3-none-any.whl", hash = "sha256:0d3105efab7c5c091609abacad33afff33bdff0035bece164c98bcf5a85ef90a"}, + {file = "yarl-1.15.2.tar.gz", hash = "sha256:a39c36f4218a5bb668b4f06874d676d35a035ee668e6e7e3538835c703634b84"}, +] + +[[package]] +name = "zipp" +version = "3.20.1" +requires_python = ">=3.8" +summary = "Backport of pathlib-compatible object wrapper for zip files" +groups = ["default", "docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "zipp-3.20.1-py3-none-any.whl", hash = "sha256:9960cd8967c8f85a56f920d5d507274e74f9ff813a0ab8889a5b5be2daf44064"}, + {file = "zipp-3.20.1.tar.gz", hash = "sha256:c22b14cc4763c5a5b04134207736c107db42e9d3ef2d9779d465f5f1bcba572b"}, +] diff --git a/pdm-py38unix.lock b/pdm-py38unix.lock new file mode 100644 index 0000000..50ab40a --- /dev/null +++ b/pdm-py38unix.lock @@ -0,0 +1,2928 @@ +# This file is @generated by PDM. +# It is not intended for manual editing. + +[metadata] +groups = ["default", "docs", "openpyxl", "pyvista", "qa"] +strategy = ["inherit_metadata"] +lock_version = "4.5.0" +content_hash = "sha256:22cd5aee3b297d0bb4e82486997918f7af7cd34c35252bce0aa0be1ee01bc0c1" + +[[metadata.targets]] +requires_python = "==3.8.*" +platform = "manylinux_2_17_x86_64" + +[[package]] +name = "aiohappyeyeballs" +version = "2.4.0" +requires_python = ">=3.8" +summary = "Happy Eyeballs for asyncio" +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +files = [ + {file = "aiohappyeyeballs-2.4.0-py3-none-any.whl", hash = "sha256:7ce92076e249169a13c2f49320d1967425eaf1f407522d707d59cac7628d62bd"}, + {file = "aiohappyeyeballs-2.4.0.tar.gz", hash = "sha256:55a1714f084e63d49639800f95716da97a1f173d46a16dfcfda0016abb93b6b2"}, +] + +[[package]] +name = "aiohttp" +version = "3.10.11" +requires_python = ">=3.8" +summary = "Async http client/server framework (asyncio)" +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +dependencies = [ + "aiohappyeyeballs>=2.3.0", + "aiosignal>=1.1.2", + "async-timeout<6.0,>=4.0; python_version < \"3.11\"", + "attrs>=17.3.0", + "frozenlist>=1.1.1", + "multidict<7.0,>=4.5", + "yarl<2.0,>=1.12.0", +] +files = [ + {file = "aiohttp-3.10.11-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5a5f7ab8baf13314e6b2485965cbacb94afff1e93466ac4d06a47a81c50f9cca"}, + {file = "aiohttp-3.10.11.tar.gz", hash = "sha256:9dc2b8f3dcab2e39e0fa309c8da50c3b55e6f34ab25f1a71d3288f24924d33a7"}, +] + +[[package]] +name = "aiosignal" +version = "1.3.1" +requires_python = ">=3.7" +summary = "aiosignal: a list of registered asynchronous callbacks" +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +dependencies = [ + "frozenlist>=1.1.0", +] +files = [ + {file = "aiosignal-1.3.1-py3-none-any.whl", hash = "sha256:f8376fb07dd1e86a584e4fcdec80b36b7f81aac666ebc724e2c090300dd83b17"}, + {file = "aiosignal-1.3.1.tar.gz", hash = "sha256:54cd96e15e1649b75d6c87526a6ff0b6c1b0dd3459f43d9ca11d48c339b68cfc"}, +] + +[[package]] +name = "alabaster" +version = "0.7.13" +requires_python = ">=3.6" +summary = "A configurable sidebar-enabled Sphinx theme" +groups = ["docs"] +marker = "python_version == \"3.8\"" +files = [ + {file = "alabaster-0.7.13-py3-none-any.whl", hash = "sha256:1ee19aca801bbabb5ba3f5f258e4422dfa86f82f3e9cefb0859b283cdd7f62a3"}, + {file = "alabaster-0.7.13.tar.gz", hash = "sha256:a27a4a084d5e690e16e01e03ad2b2e552c61a65469419b907243193de1a84ae2"}, +] + +[[package]] +name = "annotated-types" +version = "0.7.0" +requires_python = ">=3.8" +summary = "Reusable constraint types to use with typing.Annotated" +groups = ["default"] +marker = "python_version == \"3.8\"" +dependencies = [ + "typing-extensions>=4.0.0; python_version < \"3.9\"", +] +files = [ + {file = "annotated_types-0.7.0-py3-none-any.whl", hash = "sha256:1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53"}, + {file = "annotated_types-0.7.0.tar.gz", hash = "sha256:aff07c09a53a08bc8cfccb9c85b05f1aa9a2a6f23728d790723543408344ce89"}, +] + +[[package]] +name = "anyio" +version = "4.4.0" +requires_python = ">=3.8" +summary = "High level compatibility layer for multiple asynchronous event loop implementations" +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "exceptiongroup>=1.0.2; python_version < \"3.11\"", + "idna>=2.8", + "sniffio>=1.1", + "typing-extensions>=4.1; python_version < \"3.11\"", +] +files = [ + {file = "anyio-4.4.0-py3-none-any.whl", hash = "sha256:c1b2d8f46a8a812513012e1107cb0e68c17159a7a594208005a57dc776e1bdc7"}, + {file = "anyio-4.4.0.tar.gz", hash = "sha256:5aadc6a1bbb7cdb0bede386cac5e2940f5e2ff3aa20277e991cf028e0585ce94"}, +] + +[[package]] +name = "argon2-cffi" +version = "23.1.0" +requires_python = ">=3.7" +summary = "Argon2 for Python" +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "argon2-cffi-bindings", + "typing-extensions; python_version < \"3.8\"", +] +files = [ + {file = "argon2_cffi-23.1.0-py3-none-any.whl", hash = "sha256:c670642b78ba29641818ab2e68bd4e6a78ba53b7eff7b4c3815ae16abf91c7ea"}, + {file = "argon2_cffi-23.1.0.tar.gz", hash = "sha256:879c3e79a2729ce768ebb7d36d4609e3a78a4ca2ec3a9f12286ca057e3d0db08"}, +] + +[[package]] +name = "argon2-cffi-bindings" +version = "21.2.0" +requires_python = ">=3.6" +summary = "Low-level CFFI bindings for Argon2" +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "cffi>=1.0.1", +] +files = [ + {file = "argon2-cffi-bindings-21.2.0.tar.gz", hash = "sha256:bb89ceffa6c791807d1305ceb77dbfacc5aa499891d2c55661c6459651fc39e3"}, + {file = "argon2_cffi_bindings-21.2.0-cp36-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b746dba803a79238e925d9046a63aa26bf86ab2a2fe74ce6b009a1c3f5c8f2ae"}, + {file = "argon2_cffi_bindings-21.2.0-pp38-pypy38_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:20ef543a89dee4db46a1a6e206cd015360e5a75822f76df533845c3cbaf72670"}, +] + +[[package]] +name = "arrow" +version = "1.3.0" +requires_python = ">=3.8" +summary = "Better dates & times for Python" +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "python-dateutil>=2.7.0", + "types-python-dateutil>=2.8.10", +] +files = [ + {file = "arrow-1.3.0-py3-none-any.whl", hash = "sha256:c728b120ebc00eb84e01882a6f5e7927a53960aa990ce7dd2b10f39005a67f80"}, + {file = "arrow-1.3.0.tar.gz", hash = "sha256:d4540617648cb5f895730f1ad8c82a65f2dad0166f57b75f3ca54759c4d67a85"}, +] + +[[package]] +name = "asttokens" +version = "2.4.1" +summary = "Annotate AST trees with source code positions" +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "six>=1.12.0", + "typing; python_version < \"3.5\"", +] +files = [ + {file = "asttokens-2.4.1-py2.py3-none-any.whl", hash = "sha256:051ed49c3dcae8913ea7cd08e46a606dba30b79993209636c4875bc1d637bc24"}, + {file = "asttokens-2.4.1.tar.gz", hash = "sha256:b03869718ba9a6eb027e134bfdf69f38a236d681c83c160d510768af11254ba0"}, +] + +[[package]] +name = "async-lru" +version = "2.0.4" +requires_python = ">=3.8" +summary = "Simple LRU cache for asyncio" +groups = ["qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "typing-extensions>=4.0.0; python_version < \"3.11\"", +] +files = [ + {file = "async-lru-2.0.4.tar.gz", hash = "sha256:b8a59a5df60805ff63220b2a0c5b5393da5521b113cd5465a44eb037d81a5627"}, + {file = "async_lru-2.0.4-py3-none-any.whl", hash = "sha256:ff02944ce3c288c5be660c42dbcca0742b32c3b279d6dceda655190240b99224"}, +] + +[[package]] +name = "async-timeout" +version = "4.0.3" +requires_python = ">=3.7" +summary = "Timeout context manager for asyncio programs" +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +dependencies = [ + "typing-extensions>=3.6.5; python_version < \"3.8\"", +] +files = [ + {file = "async-timeout-4.0.3.tar.gz", hash = "sha256:4640d96be84d82d02ed59ea2b7105a0f7b33abe8703703cd0ab0bf87c427522f"}, + {file = "async_timeout-4.0.3-py3-none-any.whl", hash = "sha256:7405140ff1230c310e51dc27b3145b9092d659ce68ff733fb0cefe3ee42be028"}, +] + +[[package]] +name = "attrs" +version = "24.2.0" +requires_python = ">=3.7" +summary = "Classes Without Boilerplate" +groups = ["docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "importlib-metadata; python_version < \"3.8\"", +] +files = [ + {file = "attrs-24.2.0-py3-none-any.whl", hash = "sha256:81921eb96de3191c8258c199618104dd27ac608d9366f5e35d011eae1867ede2"}, + {file = "attrs-24.2.0.tar.gz", hash = "sha256:5cfb1b9148b5b086569baec03f20d7b6bf3bcacc9a42bebf87ffaaca362f6346"}, +] + +[[package]] +name = "babel" +version = "2.16.0" +requires_python = ">=3.8" +summary = "Internationalization utilities" +groups = ["docs", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "pytz>=2015.7; python_version < \"3.9\"", +] +files = [ + {file = "babel-2.16.0-py3-none-any.whl", hash = "sha256:368b5b98b37c06b7daf6696391c3240c938b37767d4584413e8438c5c435fa8b"}, + {file = "babel-2.16.0.tar.gz", hash = "sha256:d1f3554ca26605fe173f3de0c65f750f5a42f924499bf134de6423582298e316"}, +] + +[[package]] +name = "backcall" +version = "0.2.0" +summary = "Specifications for callback functions passed in to an API" +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "backcall-0.2.0-py2.py3-none-any.whl", hash = "sha256:fbbce6a29f263178a1f7915c1940bde0ec2b2a967566fe1c65c1dfb7422bd255"}, + {file = "backcall-0.2.0.tar.gz", hash = "sha256:5cbdbf27be5e7cfadb448baf0aa95508f91f2bbc6c6437cd9cd06e2a4c215e1e"}, +] + +[[package]] +name = "beautifulsoup4" +version = "4.12.3" +requires_python = ">=3.6.0" +summary = "Screen-scraping library" +groups = ["docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "soupsieve>1.2", +] +files = [ + {file = "beautifulsoup4-4.12.3-py3-none-any.whl", hash = "sha256:b80878c9f40111313e55da8ba20bdba06d8fa3969fc68304167741bbf9e082ed"}, + {file = "beautifulsoup4-4.12.3.tar.gz", hash = "sha256:74e3d1928edc070d21748185c46e3fb33490f22f52a3addee9aee0f4f7781051"}, +] + +[[package]] +name = "bleach" +version = "6.1.0" +requires_python = ">=3.8" +summary = "An easy safelist-based HTML-sanitizing tool." +groups = ["docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "six>=1.9.0", + "webencodings", +] +files = [ + {file = "bleach-6.1.0-py3-none-any.whl", hash = "sha256:3225f354cfc436b9789c66c4ee030194bee0568fbf9cbdad3bc8b5c26c5f12b6"}, + {file = "bleach-6.1.0.tar.gz", hash = "sha256:0a31f1837963c41d46bbf1331b8778e1308ea0791db03cc4e7357b97cf42a8fe"}, +] + +[[package]] +name = "bleach" +version = "6.1.0" +extras = ["css"] +requires_python = ">=3.8" +summary = "An easy safelist-based HTML-sanitizing tool." +groups = ["docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "bleach==6.1.0", + "tinycss2<1.3,>=1.1.0", +] +files = [ + {file = "bleach-6.1.0-py3-none-any.whl", hash = "sha256:3225f354cfc436b9789c66c4ee030194bee0568fbf9cbdad3bc8b5c26c5f12b6"}, + {file = "bleach-6.1.0.tar.gz", hash = "sha256:0a31f1837963c41d46bbf1331b8778e1308ea0791db03cc4e7357b97cf42a8fe"}, +] + +[[package]] +name = "cachetools" +version = "5.5.0" +requires_python = ">=3.7" +summary = "Extensible memoizing collections and decorators" +groups = ["qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "cachetools-5.5.0-py3-none-any.whl", hash = "sha256:02134e8439cdc2ffb62023ce1debca2944c3f289d66bb17ead3ab3dede74b292"}, + {file = "cachetools-5.5.0.tar.gz", hash = "sha256:2cc24fb4cbe39633fb7badd9db9ca6295d766d9c2995f245725a46715d050f2a"}, +] + +[[package]] +name = "certifi" +version = "2024.8.30" +requires_python = ">=3.6" +summary = "Python package for providing Mozilla's CA Bundle." +groups = ["docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "certifi-2024.8.30-py3-none-any.whl", hash = "sha256:922820b53db7a7257ffbda3f597266d435245903d80737e34f8a45ff3e3230d8"}, + {file = "certifi-2024.8.30.tar.gz", hash = "sha256:bec941d2aa8195e248a60b31ff9f0558284cf01a52591ceda73ea9afffd69fd9"}, +] + +[[package]] +name = "cffi" +version = "1.17.1" +requires_python = ">=3.8" +summary = "Foreign Function Interface for Python calling C code." +groups = ["docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "pycparser", +] +files = [ + {file = "cffi-1.17.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0e2b1fac190ae3ebfe37b979cc1ce69c81f4e4fe5746bb401dca63a9062cdaf1"}, + {file = "cffi-1.17.1.tar.gz", hash = "sha256:1c39c6016c32bc48dd54561950ebd6836e1670f2ae46128f67cf49e789c52824"}, +] + +[[package]] +name = "cfgv" +version = "3.4.0" +requires_python = ">=3.8" +summary = "Validate configuration and produce human readable error messages." +groups = ["qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "cfgv-3.4.0-py2.py3-none-any.whl", hash = "sha256:b7265b1f29fd3316bfcd2b330d63d024f2bfd8bcb8b0272f8e19a504856c48f9"}, + {file = "cfgv-3.4.0.tar.gz", hash = "sha256:e52591d4c5f5dead8e0f673fb16db7949d2cfb3f7da4582893288f0ded8fe560"}, +] + +[[package]] +name = "chardet" +version = "5.2.0" +requires_python = ">=3.7" +summary = "Universal encoding detector for Python 3" +groups = ["qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "chardet-5.2.0-py3-none-any.whl", hash = "sha256:e1cf59446890a00105fe7b7912492ea04b6e6f06d4b742b2c788469e34c82970"}, + {file = "chardet-5.2.0.tar.gz", hash = "sha256:1b3b6ff479a8c414bc3fa2c0852995695c4a026dcd6d0633b2dd092ca39c1cf7"}, +] + +[[package]] +name = "charset-normalizer" +version = "3.3.2" +requires_python = ">=3.7.0" +summary = "The Real First Universal Charset Detector. Open, modern and actively maintained alternative to Chardet." +groups = ["docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "charset-normalizer-3.3.2.tar.gz", hash = "sha256:f30c3cb33b24454a82faecaf01b19c18562b1e89558fb6c56de4d9118a032fd5"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:45485e01ff4d3630ec0d9617310448a8702f70e9c01906b0d0118bdf9d124cf2"}, + {file = "charset_normalizer-3.3.2-py3-none-any.whl", hash = "sha256:3e4d1f6587322d2788836a99c69062fbb091331ec940e02d12d179c1d53e25fc"}, +] + +[[package]] +name = "cmocean" +version = "4.0.3" +requires_python = ">=3.8" +summary = "Colormaps for Oceanography" +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +dependencies = [ + "matplotlib", + "numpy", + "packaging", +] +files = [ + {file = "cmocean-4.0.3-py3-none-any.whl", hash = "sha256:f2fc1d5e349db122ee0c9eac80bba969aa92dd2806548fce58dc8bef962f309e"}, + {file = "cmocean-4.0.3.tar.gz", hash = "sha256:37868399fb5f41b4eac596e69803f9bfaea49946514dfb2e7f48886854250d7c"}, +] + +[[package]] +name = "colorama" +version = "0.4.6" +requires_python = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,!=3.6.*,>=2.7" +summary = "Cross-platform colored terminal text." +groups = ["qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6"}, + {file = "colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44"}, +] + +[[package]] +name = "colorcet" +version = "3.1.0" +requires_python = ">=3.7" +summary = "Collection of perceptually uniform colormaps" +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +files = [ + {file = "colorcet-3.1.0-py3-none-any.whl", hash = "sha256:2a7d59cc8d0f7938eeedd08aad3152b5319b4ba3bcb7a612398cc17a384cb296"}, + {file = "colorcet-3.1.0.tar.gz", hash = "sha256:2921b3cd81a2288aaf2d63dbc0ce3c26dcd882e8c389cc505d6886bf7aa9a4eb"}, +] + +[[package]] +name = "comm" +version = "0.2.2" +requires_python = ">=3.8" +summary = "Jupyter Python Comm implementation, for usage in ipykernel, xeus-python etc." +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "traitlets>=4", +] +files = [ + {file = "comm-0.2.2-py3-none-any.whl", hash = "sha256:e6fb86cb70ff661ee8c9c14e7d36d6de3b4066f1441be4063df9c5009f0a64d3"}, + {file = "comm-0.2.2.tar.gz", hash = "sha256:3fd7a84065306e07bea1773df6eb8282de51ba82f77c72f9c85716ab11fe980e"}, +] + +[[package]] +name = "contourpy" +version = "1.1.1" +requires_python = ">=3.8" +summary = "Python library for calculating contours of 2D quadrilateral grids" +groups = ["default", "pyvista"] +marker = "python_version == \"3.8\"" +dependencies = [ + "numpy<2.0,>=1.16; python_version <= \"3.11\"", + "numpy<2.0,>=1.26.0rc1; python_version >= \"3.12\"", +] +files = [ + {file = "contourpy-1.1.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:41339b24471c58dc1499e56783fedc1afa4bb018bcd035cfb0ee2ad2a7501ef8"}, + {file = "contourpy-1.1.1-pp38-pypy38_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a10dab5ea1bd4401c9483450b5b0ba5416be799bbd50fc7a6cc5e2a15e03e8a3"}, + {file = "contourpy-1.1.1.tar.gz", hash = "sha256:96ba37c2e24b7212a77da85004c38e7c4d155d3e72a45eeaf22c1f03f607e8ab"}, +] + +[[package]] +name = "coverage" +version = "7.6.1" +requires_python = ">=3.8" +summary = "Code coverage measurement for Python" +groups = ["qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "coverage-7.6.1-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8929543a7192c13d177b770008bc4e8119f2e1f881d563fc6b6305d2d0ebe9de"}, + {file = "coverage-7.6.1-pp38.pp39.pp310-none-any.whl", hash = "sha256:e9a6e0eb86070e8ccaedfbd9d38fec54864f3125ab95419970575b42af7541df"}, + {file = "coverage-7.6.1.tar.gz", hash = "sha256:953510dfb7b12ab69d20135a0662397f077c59b1e6379a768e97c59d852ee51d"}, +] + +[[package]] +name = "coverage" +version = "7.6.1" +extras = ["toml"] +requires_python = ">=3.8" +summary = "Code coverage measurement for Python" +groups = ["qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "coverage==7.6.1", + "tomli; python_full_version <= \"3.11.0a6\"", +] +files = [ + {file = "coverage-7.6.1-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8929543a7192c13d177b770008bc4e8119f2e1f881d563fc6b6305d2d0ebe9de"}, + {file = "coverage-7.6.1-pp38.pp39.pp310-none-any.whl", hash = "sha256:e9a6e0eb86070e8ccaedfbd9d38fec54864f3125ab95419970575b42af7541df"}, + {file = "coverage-7.6.1.tar.gz", hash = "sha256:953510dfb7b12ab69d20135a0662397f077c59b1e6379a768e97c59d852ee51d"}, +] + +[[package]] +name = "cycler" +version = "0.12.1" +requires_python = ">=3.8" +summary = "Composable style cycles" +groups = ["default", "pyvista"] +marker = "python_version == \"3.8\"" +files = [ + {file = "cycler-0.12.1-py3-none-any.whl", hash = "sha256:85cef7cff222d8644161529808465972e51340599459b8ac3ccbac5a854e0d30"}, + {file = "cycler-0.12.1.tar.gz", hash = "sha256:88bb128f02ba341da8ef447245a9e138fae777f6a23943da4540077d3601eb1c"}, +] + +[[package]] +name = "debugpy" +version = "1.8.5" +requires_python = ">=3.8" +summary = "An implementation of the Debug Adapter Protocol for Python" +groups = ["qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "debugpy-1.8.5-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1cd04a73eb2769eb0bfe43f5bfde1215c5923d6924b9b90f94d15f207a402226"}, + {file = "debugpy-1.8.5-py2.py3-none-any.whl", hash = "sha256:55919dce65b471eff25901acf82d328bbd5b833526b6c1364bd5133754777a44"}, + {file = "debugpy-1.8.5.zip", hash = "sha256:b2112cfeb34b4507399d298fe7023a16656fc553ed5246536060ca7bd0e668d0"}, +] + +[[package]] +name = "decorator" +version = "5.1.1" +requires_python = ">=3.5" +summary = "Decorators for Humans" +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "decorator-5.1.1-py3-none-any.whl", hash = "sha256:b8c3f85900b9dc423225913c5aace94729fe1fa9763b38939a95226f02d37186"}, + {file = "decorator-5.1.1.tar.gz", hash = "sha256:637996211036b6385ef91435e4fae22989472f9d571faba8927ba8253acbc330"}, +] + +[[package]] +name = "defusedxml" +version = "0.7.1" +requires_python = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*" +summary = "XML bomb protection for Python stdlib modules" +groups = ["docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "defusedxml-0.7.1-py2.py3-none-any.whl", hash = "sha256:a352e7e428770286cc899e2542b6cdaedb2b4953ff269a210103ec58f6198a61"}, + {file = "defusedxml-0.7.1.tar.gz", hash = "sha256:1bb3032db185915b62d7c6209c5a8792be6a32ab2fedacc84e01b52c51aa3e69"}, +] + +[[package]] +name = "distlib" +version = "0.3.8" +summary = "Distribution utilities" +groups = ["qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "distlib-0.3.8-py2.py3-none-any.whl", hash = "sha256:034db59a0b96f8ca18035f36290806a9a6e6bd9d1ff91e45a7f172eb17e51784"}, + {file = "distlib-0.3.8.tar.gz", hash = "sha256:1530ea13e350031b6312d8580ddb6b27a104275a31106523b8f123787f494f64"}, +] + +[[package]] +name = "docutils" +version = "0.20.1" +requires_python = ">=3.7" +summary = "Docutils -- Python Documentation Utilities" +groups = ["docs"] +marker = "python_version == \"3.8\"" +files = [ + {file = "docutils-0.20.1-py3-none-any.whl", hash = "sha256:96f387a2c5562db4476f09f13bbab2192e764cac08ebbf3a34a95d9b1e4a59d6"}, + {file = "docutils-0.20.1.tar.gz", hash = "sha256:f08a4e276c3a1583a86dce3e34aba3fe04d02bba2dd51ed16106244e8a923e3b"}, +] + +[[package]] +name = "et-xmlfile" +version = "1.1.0" +requires_python = ">=3.6" +summary = "An implementation of lxml.xmlfile for the standard library" +groups = ["openpyxl"] +marker = "python_version == \"3.8\"" +files = [ + {file = "et_xmlfile-1.1.0-py3-none-any.whl", hash = "sha256:a2ba85d1d6a74ef63837eed693bcb89c3f752169b0e3e7ae5b16ca5e1b3deada"}, + {file = "et_xmlfile-1.1.0.tar.gz", hash = "sha256:8eb9e2bc2f8c97e37a2dc85a09ecdcdec9d8a396530a6d5a33b30b9a92da0c5c"}, +] + +[[package]] +name = "exceptiongroup" +version = "1.2.2" +requires_python = ">=3.7" +summary = "Backport of PEP 654 (exception groups)" +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "exceptiongroup-1.2.2-py3-none-any.whl", hash = "sha256:3111b9d131c238bec2f8f516e123e14ba243563fb135d3fe885990585aa7795b"}, + {file = "exceptiongroup-1.2.2.tar.gz", hash = "sha256:47c2edf7c6738fafb49fd34290706d1a1a2f4d1c6df275526b62cbb4aa5393cc"}, +] + +[[package]] +name = "executing" +version = "2.1.0" +requires_python = ">=3.8" +summary = "Get the currently executing AST node of a frame, and other information" +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "executing-2.1.0-py2.py3-none-any.whl", hash = "sha256:8d63781349375b5ebccc3142f4b30350c0cd9c79f921cde38be2be4637e98eaf"}, + {file = "executing-2.1.0.tar.gz", hash = "sha256:8ea27ddd260da8150fa5a708269c4a10e76161e2496ec3e587da9e3c0fe4b9ab"}, +] + +[[package]] +name = "fastjsonschema" +version = "2.20.0" +summary = "Fastest Python implementation of JSON schema" +groups = ["docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "fastjsonschema-2.20.0-py3-none-any.whl", hash = "sha256:5875f0b0fa7a0043a91e93a9b8f793bcbbba9691e7fd83dca95c28ba26d21f0a"}, + {file = "fastjsonschema-2.20.0.tar.gz", hash = "sha256:3d48fc5300ee96f5d116f10fe6f28d938e6008f59a6a025c2649475b87f76a23"}, +] + +[[package]] +name = "filelock" +version = "3.16.1" +requires_python = ">=3.8" +summary = "A platform independent file lock." +groups = ["qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "filelock-3.16.1-py3-none-any.whl", hash = "sha256:2082e5703d51fbf98ea75855d9d5527e33d8ff23099bec374a134febee6946b0"}, + {file = "filelock-3.16.1.tar.gz", hash = "sha256:c249fbfcd5db47e5e2d6d62198e565475ee65e4831e2561c8e313fa7eb961435"}, +] + +[[package]] +name = "fonttools" +version = "4.53.1" +requires_python = ">=3.8" +summary = "Tools to manipulate font files" +groups = ["default", "pyvista"] +marker = "python_version == \"3.8\"" +files = [ + {file = "fonttools-4.53.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c9cd19cf4fe0595ebdd1d4915882b9440c3a6d30b008f3cc7587c1da7b95be5f"}, + {file = "fonttools-4.53.1-py3-none-any.whl", hash = "sha256:f1f8758a2ad110bd6432203a344269f445a2907dc24ef6bccfd0ac4e14e0d71d"}, + {file = "fonttools-4.53.1.tar.gz", hash = "sha256:e128778a8e9bc11159ce5447f76766cefbd876f44bd79aff030287254e4752c4"}, +] + +[[package]] +name = "fqdn" +version = "1.5.1" +requires_python = ">=2.7, !=3.0, !=3.1, !=3.2, !=3.3, !=3.4, <4" +summary = "Validates fully-qualified domain names against RFC 1123, so that they are acceptable to modern bowsers" +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "cached-property>=1.3.0; python_version < \"3.8\"", +] +files = [ + {file = "fqdn-1.5.1-py3-none-any.whl", hash = "sha256:3a179af3761e4df6eb2e026ff9e1a3033d3587bf980a0b1b2e1e5d08d7358014"}, + {file = "fqdn-1.5.1.tar.gz", hash = "sha256:105ed3677e767fb5ca086a0c1f4bb66ebc3c100be518f0e0d755d9eae164d89f"}, +] + +[[package]] +name = "frozenlist" +version = "1.4.1" +requires_python = ">=3.8" +summary = "A list-like structure which implements collections.abc.MutableSequence" +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +files = [ + {file = "frozenlist-1.4.1-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:693945278a31f2086d9bf3df0fe8254bbeaef1fe71e1351c3bd730aa7d31c41b"}, + {file = "frozenlist-1.4.1-py3-none-any.whl", hash = "sha256:04ced3e6a46b4cfffe20f9ae482818e34eba9b5fb0ce4056e4cc9b6e212d09b7"}, + {file = "frozenlist-1.4.1.tar.gz", hash = "sha256:c037a86e8513059a2613aaba4d817bb90b9d9b6b69aace3ce9c877e8c8ed402b"}, +] + +[[package]] +name = "ghp-import" +version = "2.1.0" +summary = "Copy your docs directly to the gh-pages branch." +groups = ["docs"] +marker = "python_version == \"3.8\"" +dependencies = [ + "python-dateutil>=2.8.1", +] +files = [ + {file = "ghp-import-2.1.0.tar.gz", hash = "sha256:9c535c4c61193c2df8871222567d7fd7e5014d835f97dc7b7439069e2413d343"}, + {file = "ghp_import-2.1.0-py3-none-any.whl", hash = "sha256:8337dd7b50877f163d4c0289bc1f1c7f127550241988d568c1db512c4324a619"}, +] + +[[package]] +name = "h11" +version = "0.14.0" +requires_python = ">=3.7" +summary = "A pure-Python, bring-your-own-I/O implementation of HTTP/1.1" +groups = ["qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "typing-extensions; python_version < \"3.8\"", +] +files = [ + {file = "h11-0.14.0-py3-none-any.whl", hash = "sha256:e3fe4ac4b851c468cc8363d500db52c2ead036020723024a109d37346efaa761"}, + {file = "h11-0.14.0.tar.gz", hash = "sha256:8f19fbbe99e72420ff35c00b27a34cb9937e902a8b810e2c88300c6f0a3b699d"}, +] + +[[package]] +name = "httpcore" +version = "1.0.5" +requires_python = ">=3.8" +summary = "A minimal low-level HTTP client." +groups = ["qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "certifi", + "h11<0.15,>=0.13", +] +files = [ + {file = "httpcore-1.0.5-py3-none-any.whl", hash = "sha256:421f18bac248b25d310f3cacd198d55b8e6125c107797b609ff9b7a6ba7991b5"}, + {file = "httpcore-1.0.5.tar.gz", hash = "sha256:34a38e2f9291467ee3b44e89dd52615370e152954ba21721378a87b2960f7a61"}, +] + +[[package]] +name = "httpx" +version = "0.27.2" +requires_python = ">=3.8" +summary = "The next generation HTTP client." +groups = ["qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "anyio", + "certifi", + "httpcore==1.*", + "idna", + "sniffio", +] +files = [ + {file = "httpx-0.27.2-py3-none-any.whl", hash = "sha256:7bb2708e112d8fdd7829cd4243970f0c223274051cb35ee80c03301ee29a3df0"}, + {file = "httpx-0.27.2.tar.gz", hash = "sha256:f7c2be1d2f3c3c3160d441802406b206c2b76f5947b11115e6df10c6c65e66c2"}, +] + +[[package]] +name = "identify" +version = "2.6.0" +requires_python = ">=3.8" +summary = "File identification library for Python" +groups = ["qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "identify-2.6.0-py2.py3-none-any.whl", hash = "sha256:e79ae4406387a9d300332b5fd366d8994f1525e8414984e1a59e058b2eda2dd0"}, + {file = "identify-2.6.0.tar.gz", hash = "sha256:cb171c685bdc31bcc4c1734698736a7d5b6c8bf2e0c15117f4d469c8640ae5cf"}, +] + +[[package]] +name = "idna" +version = "3.8" +requires_python = ">=3.6" +summary = "Internationalized Domain Names in Applications (IDNA)" +groups = ["docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "idna-3.8-py3-none-any.whl", hash = "sha256:050b4e5baadcd44d760cedbd2b8e639f2ff89bbc7a5730fcc662954303377aac"}, + {file = "idna-3.8.tar.gz", hash = "sha256:d838c2c0ed6fced7693d5e8ab8e734d5f8fda53a039c0164afb0b82e771e3603"}, +] + +[[package]] +name = "imageio" +version = "2.35.1" +requires_python = ">=3.8" +summary = "Library for reading and writing a wide range of image, video, scientific, and volumetric data formats." +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +dependencies = [ + "numpy", + "pillow>=8.3.2", +] +files = [ + {file = "imageio-2.35.1-py3-none-any.whl", hash = "sha256:6eb2e5244e7a16b85c10b5c2fe0f7bf961b40fcb9f1a9fd1bd1d2c2f8fb3cd65"}, + {file = "imageio-2.35.1.tar.gz", hash = "sha256:4952dfeef3c3947957f6d5dedb1f4ca31c6e509a476891062396834048aeed2a"}, +] + +[[package]] +name = "imagesize" +version = "1.4.1" +requires_python = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*" +summary = "Getting image size from png/jpeg/jpeg2000/gif file" +groups = ["docs"] +marker = "python_version == \"3.8\"" +files = [ + {file = "imagesize-1.4.1-py2.py3-none-any.whl", hash = "sha256:0d8d18d08f840c19d0ee7ca1fd82490fdc3729b7ac93f49870406ddde8ef8d8b"}, + {file = "imagesize-1.4.1.tar.gz", hash = "sha256:69150444affb9cb0d5cc5a92b3676f0b2fb7cd9ae39e947a5e11a36b4497cd4a"}, +] + +[[package]] +name = "importlib-metadata" +version = "8.5.0" +requires_python = ">=3.8" +summary = "Read metadata from Python packages" +groups = ["docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "typing-extensions>=3.6.4; python_version < \"3.8\"", + "zipp>=3.20", +] +files = [ + {file = "importlib_metadata-8.5.0-py3-none-any.whl", hash = "sha256:45e54197d28b7a7f1559e60b95e7c567032b602131fbd588f1497f47880aa68b"}, + {file = "importlib_metadata-8.5.0.tar.gz", hash = "sha256:71522656f0abace1d072b9e5481a48f07c138e00f079c38c8f883823f9c26bd7"}, +] + +[[package]] +name = "importlib-resources" +version = "6.4.5" +requires_python = ">=3.8" +summary = "Read resources from Python packages" +groups = ["default", "docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "zipp>=3.1.0; python_version < \"3.10\"", +] +files = [ + {file = "importlib_resources-6.4.5-py3-none-any.whl", hash = "sha256:ac29d5f956f01d5e4bb63102a5a19957f1b9175e45649977264a1416783bb717"}, + {file = "importlib_resources-6.4.5.tar.gz", hash = "sha256:980862a1d16c9e147a59603677fa2aa5fd82b87f223b6cb870695bcfce830065"}, +] + +[[package]] +name = "iniconfig" +version = "2.0.0" +requires_python = ">=3.7" +summary = "brain-dead simple config-ini parsing" +groups = ["qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "iniconfig-2.0.0-py3-none-any.whl", hash = "sha256:b6a85871a79d2e3b22d2d1b94ac2824226a63c6b741c88f7ae975f18b6778374"}, + {file = "iniconfig-2.0.0.tar.gz", hash = "sha256:2d91e135bf72d31a410b17c16da610a82cb55f6b0477d1a902134b24a455b8b3"}, +] + +[[package]] +name = "ipdb" +version = "0.13.13" +requires_python = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*" +summary = "IPython-enabled pdb" +groups = ["qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "decorator; python_version == \"3.5\"", + "decorator; python_version == \"3.6\"", + "decorator; python_version > \"3.6\" and python_version < \"3.11\"", + "decorator; python_version >= \"3.11\"", + "decorator<5.0.0; python_version == \"2.7\"", + "decorator<5.0.0; python_version == \"3.4\"", + "ipython<6.0.0,>=5.1.0; python_version == \"2.7\"", + "ipython<7.0.0,>=6.0.0; python_version == \"3.4\"", + "ipython<7.10.0,>=7.0.0; python_version == \"3.5\"", + "ipython<7.17.0,>=7.16.3; python_version == \"3.6\"", + "ipython>=7.31.1; python_version > \"3.6\" and python_version < \"3.11\"", + "ipython>=7.31.1; python_version >= \"3.11\"", + "pathlib; python_version == \"2.7\"", + "toml>=0.10.2; python_version == \"2.7\"", + "toml>=0.10.2; python_version == \"3.4\"", + "toml>=0.10.2; python_version == \"3.5\"", + "tomli; python_version == \"3.6\"", + "tomli; python_version > \"3.6\" and python_version < \"3.11\"", +] +files = [ + {file = "ipdb-0.13.13-py3-none-any.whl", hash = "sha256:45529994741c4ab6d2388bfa5d7b725c2cf7fe9deffabdb8a6113aa5ed449ed4"}, + {file = "ipdb-0.13.13.tar.gz", hash = "sha256:e3ac6018ef05126d442af680aad863006ec19d02290561ac88b8b1c0b0cfc726"}, +] + +[[package]] +name = "ipykernel" +version = "6.29.5" +requires_python = ">=3.8" +summary = "IPython Kernel for Jupyter" +groups = ["qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "appnope; platform_system == \"Darwin\"", + "comm>=0.1.1", + "debugpy>=1.6.5", + "ipython>=7.23.1", + "jupyter-client>=6.1.12", + "jupyter-core!=5.0.*,>=4.12", + "matplotlib-inline>=0.1", + "nest-asyncio", + "packaging", + "psutil", + "pyzmq>=24", + "tornado>=6.1", + "traitlets>=5.4.0", +] +files = [ + {file = "ipykernel-6.29.5-py3-none-any.whl", hash = "sha256:afdb66ba5aa354b09b91379bac28ae4afebbb30e8b39510c9690afb7a10421b5"}, + {file = "ipykernel-6.29.5.tar.gz", hash = "sha256:f093a22c4a40f8828f8e330a9c297cb93dcab13bd9678ded6de8e5cf81c56215"}, +] + +[[package]] +name = "ipython" +version = "8.12.3" +requires_python = ">=3.8" +summary = "IPython: Productive Interactive Computing" +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "appnope; sys_platform == \"darwin\"", + "backcall", + "colorama; sys_platform == \"win32\"", + "decorator", + "jedi>=0.16", + "matplotlib-inline", + "pexpect>4.3; sys_platform != \"win32\"", + "pickleshare", + "prompt-toolkit!=3.0.37,<3.1.0,>=3.0.30", + "pygments>=2.4.0", + "stack-data", + "traitlets>=5", + "typing-extensions; python_version < \"3.10\"", +] +files = [ + {file = "ipython-8.12.3-py3-none-any.whl", hash = "sha256:b0340d46a933d27c657b211a329d0be23793c36595acf9e6ef4164bc01a1804c"}, + {file = "ipython-8.12.3.tar.gz", hash = "sha256:3910c4b54543c2ad73d06579aa771041b7d5707b033bd488669b4cf544e3b363"}, +] + +[[package]] +name = "ipywidgets" +version = "8.1.5" +requires_python = ">=3.7" +summary = "Jupyter interactive widgets" +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +dependencies = [ + "comm>=0.1.3", + "ipython>=6.1.0", + "jupyterlab-widgets~=3.0.12", + "traitlets>=4.3.1", + "widgetsnbextension~=4.0.12", +] +files = [ + {file = "ipywidgets-8.1.5-py3-none-any.whl", hash = "sha256:3290f526f87ae6e77655555baba4f36681c555b8bdbbff430b70e52c34c86245"}, + {file = "ipywidgets-8.1.5.tar.gz", hash = "sha256:870e43b1a35656a80c18c9503bbf2d16802db1cb487eec6fab27d683381dde17"}, +] + +[[package]] +name = "isoduration" +version = "20.11.0" +requires_python = ">=3.7" +summary = "Operations with ISO 8601 durations" +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "arrow>=0.15.0", +] +files = [ + {file = "isoduration-20.11.0-py3-none-any.whl", hash = "sha256:b2904c2a4228c3d44f409c8ae8e2370eb21a26f7ac2ec5446df141dde3452042"}, + {file = "isoduration-20.11.0.tar.gz", hash = "sha256:ac2f9015137935279eac671f94f89eb00584f940f5dc49462a0c4ee692ba1bd9"}, +] + +[[package]] +name = "jedi" +version = "0.19.1" +requires_python = ">=3.6" +summary = "An autocompletion tool for Python that can be used for text editors." +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "parso<0.9.0,>=0.8.3", +] +files = [ + {file = "jedi-0.19.1-py2.py3-none-any.whl", hash = "sha256:e983c654fe5c02867aef4cdfce5a2fbb4a50adc0af145f70504238f18ef5e7e0"}, + {file = "jedi-0.19.1.tar.gz", hash = "sha256:cf0496f3651bc65d7174ac1b7d043eff454892c708a87d1b683e57b569927ffd"}, +] + +[[package]] +name = "jinja2" +version = "3.1.5" +requires_python = ">=3.7" +summary = "A very fast and expressive template engine." +groups = ["docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "MarkupSafe>=2.0", +] +files = [ + {file = "jinja2-3.1.5-py3-none-any.whl", hash = "sha256:aba0f4dc9ed8013c424088f68a5c226f7d6097ed89b246d7749c2ec4175c6adb"}, + {file = "jinja2-3.1.5.tar.gz", hash = "sha256:8fefff8dc3034e27bb80d67c671eb8a9bc424c0ef4c0826edbff304cceff43bb"}, +] + +[[package]] +name = "json5" +version = "0.9.25" +requires_python = ">=3.8" +summary = "A Python implementation of the JSON5 data format." +groups = ["qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "json5-0.9.25-py3-none-any.whl", hash = "sha256:34ed7d834b1341a86987ed52f3f76cd8ee184394906b6e22a1e0deb9ab294e8f"}, + {file = "json5-0.9.25.tar.gz", hash = "sha256:548e41b9be043f9426776f05df8635a00fe06104ea51ed24b67f908856e151ae"}, +] + +[[package]] +name = "jsonpointer" +version = "3.0.0" +requires_python = ">=3.7" +summary = "Identify specific nodes in a JSON document (RFC 6901) " +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "jsonpointer-3.0.0-py2.py3-none-any.whl", hash = "sha256:13e088adc14fca8b6aa8177c044e12701e6ad4b28ff10e65f2267a90109c9942"}, + {file = "jsonpointer-3.0.0.tar.gz", hash = "sha256:2b2d729f2091522d61c3b31f82e11870f60b68f43fbc705cb76bf4b832af59ef"}, +] + +[[package]] +name = "jsonschema" +version = "4.23.0" +requires_python = ">=3.8" +summary = "An implementation of JSON Schema validation for Python" +groups = ["docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "attrs>=22.2.0", + "importlib-resources>=1.4.0; python_version < \"3.9\"", + "jsonschema-specifications>=2023.03.6", + "pkgutil-resolve-name>=1.3.10; python_version < \"3.9\"", + "referencing>=0.28.4", + "rpds-py>=0.7.1", +] +files = [ + {file = "jsonschema-4.23.0-py3-none-any.whl", hash = "sha256:fbadb6f8b144a8f8cf9f0b89ba94501d143e50411a1278633f56a7acf7fd5566"}, + {file = "jsonschema-4.23.0.tar.gz", hash = "sha256:d71497fef26351a33265337fa77ffeb82423f3ea21283cd9467bb03999266bc4"}, +] + +[[package]] +name = "jsonschema-specifications" +version = "2023.12.1" +requires_python = ">=3.8" +summary = "The JSON Schema meta-schemas and vocabularies, exposed as a Registry" +groups = ["docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "importlib-resources>=1.4.0; python_version < \"3.9\"", + "referencing>=0.31.0", +] +files = [ + {file = "jsonschema_specifications-2023.12.1-py3-none-any.whl", hash = "sha256:87e4fdf3a94858b8a2ba2778d9ba57d8a9cafca7c7489c46ba0d30a8bc6a9c3c"}, + {file = "jsonschema_specifications-2023.12.1.tar.gz", hash = "sha256:48a76787b3e70f5ed53f1160d2b81f586e4ca6d1548c5de7085d1682674764cc"}, +] + +[[package]] +name = "jsonschema" +version = "4.23.0" +extras = ["format-nongpl"] +requires_python = ">=3.8" +summary = "An implementation of JSON Schema validation for Python" +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "fqdn", + "idna", + "isoduration", + "jsonpointer>1.13", + "jsonschema==4.23.0", + "rfc3339-validator", + "rfc3986-validator>0.1.0", + "uri-template", + "webcolors>=24.6.0", +] +files = [ + {file = "jsonschema-4.23.0-py3-none-any.whl", hash = "sha256:fbadb6f8b144a8f8cf9f0b89ba94501d143e50411a1278633f56a7acf7fd5566"}, + {file = "jsonschema-4.23.0.tar.gz", hash = "sha256:d71497fef26351a33265337fa77ffeb82423f3ea21283cd9467bb03999266bc4"}, +] + +[[package]] +name = "jupyter-client" +version = "8.6.3" +requires_python = ">=3.8" +summary = "Jupyter protocol implementation and client libraries" +groups = ["docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "importlib-metadata>=4.8.3; python_version < \"3.10\"", + "jupyter-core!=5.0.*,>=4.12", + "python-dateutil>=2.8.2", + "pyzmq>=23.0", + "tornado>=6.2", + "traitlets>=5.3", +] +files = [ + {file = "jupyter_client-8.6.3-py3-none-any.whl", hash = "sha256:e8a19cc986cc45905ac3362915f410f3af85424b4c0905e94fa5f2cb08e8f23f"}, + {file = "jupyter_client-8.6.3.tar.gz", hash = "sha256:35b3a0947c4a6e9d589eb97d7d4cd5e90f910ee73101611f01283732bd6d9419"}, +] + +[[package]] +name = "jupyter-core" +version = "5.7.2" +requires_python = ">=3.8" +summary = "Jupyter core package. A base package on which Jupyter projects rely." +groups = ["docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "platformdirs>=2.5", + "pywin32>=300; sys_platform == \"win32\" and platform_python_implementation != \"PyPy\"", + "traitlets>=5.3", +] +files = [ + {file = "jupyter_core-5.7.2-py3-none-any.whl", hash = "sha256:4f7315d2f6b4bcf2e3e7cb6e46772eba760ae459cd1f59d29eb57b0a01bd7409"}, + {file = "jupyter_core-5.7.2.tar.gz", hash = "sha256:aa5f8d32bbf6b431ac830496da7392035d6f61b4f54872f15c4bd2a9c3f536d9"}, +] + +[[package]] +name = "jupyter-events" +version = "0.10.0" +requires_python = ">=3.8" +summary = "Jupyter Event System library" +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "jsonschema[format-nongpl]>=4.18.0", + "python-json-logger>=2.0.4", + "pyyaml>=5.3", + "referencing", + "rfc3339-validator", + "rfc3986-validator>=0.1.1", + "traitlets>=5.3", +] +files = [ + {file = "jupyter_events-0.10.0-py3-none-any.whl", hash = "sha256:4b72130875e59d57716d327ea70d3ebc3af1944d3717e5a498b8a06c6c159960"}, + {file = "jupyter_events-0.10.0.tar.gz", hash = "sha256:670b8229d3cc882ec782144ed22e0d29e1c2d639263f92ca8383e66682845e22"}, +] + +[[package]] +name = "jupyter-lsp" +version = "2.2.5" +requires_python = ">=3.8" +summary = "Multi-Language Server WebSocket proxy for Jupyter Notebook/Lab server" +groups = ["qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "importlib-metadata>=4.8.3; python_version < \"3.10\"", + "jupyter-server>=1.1.2", +] +files = [ + {file = "jupyter-lsp-2.2.5.tar.gz", hash = "sha256:793147a05ad446f809fd53ef1cd19a9f5256fd0a2d6b7ce943a982cb4f545001"}, + {file = "jupyter_lsp-2.2.5-py3-none-any.whl", hash = "sha256:45fbddbd505f3fbfb0b6cb2f1bc5e15e83ab7c79cd6e89416b248cb3c00c11da"}, +] + +[[package]] +name = "jupyter-server" +version = "2.14.2" +requires_python = ">=3.8" +summary = "The backend—i.e. core services, APIs, and REST endpoints—to Jupyter web applications." +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "anyio>=3.1.0", + "argon2-cffi>=21.1", + "jinja2>=3.0.3", + "jupyter-client>=7.4.4", + "jupyter-core!=5.0.*,>=4.12", + "jupyter-events>=0.9.0", + "jupyter-server-terminals>=0.4.4", + "nbconvert>=6.4.4", + "nbformat>=5.3.0", + "overrides>=5.0", + "packaging>=22.0", + "prometheus-client>=0.9", + "pywinpty>=2.0.1; os_name == \"nt\"", + "pyzmq>=24", + "send2trash>=1.8.2", + "terminado>=0.8.3", + "tornado>=6.2.0", + "traitlets>=5.6.0", + "websocket-client>=1.7", +] +files = [ + {file = "jupyter_server-2.14.2-py3-none-any.whl", hash = "sha256:47ff506127c2f7851a17bf4713434208fc490955d0e8632e95014a9a9afbeefd"}, + {file = "jupyter_server-2.14.2.tar.gz", hash = "sha256:66095021aa9638ced276c248b1d81862e4c50f292d575920bbe960de1c56b12b"}, +] + +[[package]] +name = "jupyter-server-proxy" +version = "4.4.0" +requires_python = ">=3.8" +summary = "A Jupyter server extension to run additional processes and proxy to them that comes bundled JupyterLab extension to launch pre-defined processes." +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +dependencies = [ + "aiohttp", + "importlib-metadata>=4.8.3; python_version < \"3.10\"", + "jupyter-server>=1.24.0", + "simpervisor>=1.0.0", + "tornado>=6.1.0", + "traitlets>=5.1.0", +] +files = [ + {file = "jupyter_server_proxy-4.4.0-py3-none-any.whl", hash = "sha256:707b5c84810bb8863d50f6c6d50a386fec216149e11802b7d4c451b54a63a9a6"}, + {file = "jupyter_server_proxy-4.4.0.tar.gz", hash = "sha256:e5732eb9c810c0caa997f90a2f15f7d09af638e7eea9c67eb5c43e9c1f0e1157"}, +] + +[[package]] +name = "jupyter-server-terminals" +version = "0.5.3" +requires_python = ">=3.8" +summary = "A Jupyter Server Extension Providing Terminals." +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "pywinpty>=2.0.3; os_name == \"nt\"", + "terminado>=0.8.3", +] +files = [ + {file = "jupyter_server_terminals-0.5.3-py3-none-any.whl", hash = "sha256:41ee0d7dc0ebf2809c668e0fc726dfaf258fcd3e769568996ca731b6194ae9aa"}, + {file = "jupyter_server_terminals-0.5.3.tar.gz", hash = "sha256:5ae0295167220e9ace0edcfdb212afd2b01ee8d179fe6f23c899590e9b8a5269"}, +] + +[[package]] +name = "jupyterlab" +version = "4.3.5" +requires_python = ">=3.8" +summary = "JupyterLab computational environment" +groups = ["qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "async-lru>=1.0.0", + "httpx>=0.25.0", + "importlib-metadata>=4.8.3; python_version < \"3.10\"", + "importlib-resources>=1.4; python_version < \"3.9\"", + "ipykernel>=6.5.0", + "jinja2>=3.0.3", + "jupyter-core", + "jupyter-lsp>=2.0.0", + "jupyter-server<3,>=2.4.0", + "jupyterlab-server<3,>=2.27.1", + "notebook-shim>=0.2", + "packaging", + "setuptools>=40.8.0", + "tomli>=1.2.2; python_version < \"3.11\"", + "tornado>=6.2.0", + "traitlets", +] +files = [ + {file = "jupyterlab-4.3.5-py3-none-any.whl", hash = "sha256:571bbdee20e4c5321ab5195bc41cf92a75a5cff886be5e57ce78dfa37a5e9fdb"}, + {file = "jupyterlab-4.3.5.tar.gz", hash = "sha256:c779bf72ced007d7d29d5bcef128e7fdda96ea69299e19b04a43635a7d641f9d"}, +] + +[[package]] +name = "jupyterlab-pygments" +version = "0.3.0" +requires_python = ">=3.8" +summary = "Pygments theme using JupyterLab CSS variables" +groups = ["docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "jupyterlab_pygments-0.3.0-py3-none-any.whl", hash = "sha256:841a89020971da1d8693f1a99997aefc5dc424bb1b251fd6322462a1b8842780"}, + {file = "jupyterlab_pygments-0.3.0.tar.gz", hash = "sha256:721aca4d9029252b11cfa9d185e5b5af4d54772bb8072f9b7036f4170054d35d"}, +] + +[[package]] +name = "jupyterlab-server" +version = "2.27.3" +requires_python = ">=3.8" +summary = "A set of server components for JupyterLab and JupyterLab like applications." +groups = ["qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "babel>=2.10", + "importlib-metadata>=4.8.3; python_version < \"3.10\"", + "jinja2>=3.0.3", + "json5>=0.9.0", + "jsonschema>=4.18.0", + "jupyter-server<3,>=1.21", + "packaging>=21.3", + "requests>=2.31", +] +files = [ + {file = "jupyterlab_server-2.27.3-py3-none-any.whl", hash = "sha256:e697488f66c3db49df675158a77b3b017520d772c6e1548c7d9bcc5df7944ee4"}, + {file = "jupyterlab_server-2.27.3.tar.gz", hash = "sha256:eb36caca59e74471988f0ae25c77945610b887f777255aa21f8065def9e51ed4"}, +] + +[[package]] +name = "jupyterlab-widgets" +version = "3.0.13" +requires_python = ">=3.7" +summary = "Jupyter interactive widgets for JupyterLab" +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +files = [ + {file = "jupyterlab_widgets-3.0.13-py3-none-any.whl", hash = "sha256:e3cda2c233ce144192f1e29914ad522b2f4c40e77214b0cc97377ca3d323db54"}, + {file = "jupyterlab_widgets-3.0.13.tar.gz", hash = "sha256:a2966d385328c1942b683a8cd96b89b8dd82c8b8f81dda902bb2bc06d46f5bed"}, +] + +[[package]] +name = "kiwisolver" +version = "1.4.7" +requires_python = ">=3.8" +summary = "A fast implementation of the Cassowary constraint solver" +groups = ["default", "pyvista"] +marker = "python_version == \"3.8\"" +files = [ + {file = "kiwisolver-1.4.7-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:a0f64a48bb81af7450e641e3fe0b0394d7381e342805479178b3d335d60ca7cf"}, + {file = "kiwisolver-1.4.7-pp38-pypy38_pp73-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:a17f6a29cf8935e587cc8a4dbfc8368c55edc645283db0ce9801016f83526c2d"}, + {file = "kiwisolver-1.4.7.tar.gz", hash = "sha256:9893ff81bd7107f7b685d3017cc6583daadb4fc26e4a888350df530e41980a60"}, +] + +[[package]] +name = "markdown-it-py" +version = "3.0.0" +requires_python = ">=3.8" +summary = "Python port of markdown-it. Markdown parsing, done right!" +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +dependencies = [ + "mdurl~=0.1", +] +files = [ + {file = "markdown-it-py-3.0.0.tar.gz", hash = "sha256:e3f60a94fa066dc52ec76661e37c851cb232d92f9886b15cb560aaada2df8feb"}, + {file = "markdown_it_py-3.0.0-py3-none-any.whl", hash = "sha256:355216845c60bd96232cd8d8c40e8f9765cc86f46880e43a8fd22dc1a1a8cab1"}, +] + +[[package]] +name = "markupsafe" +version = "2.1.5" +requires_python = ">=3.7" +summary = "Safely add untrusted strings to HTML/XML markup." +groups = ["docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "MarkupSafe-2.1.5-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fa9db3f79de01457b03d4f01b34cf91bc0048eb2c3846ff26f66687c2f6d16ab"}, + {file = "MarkupSafe-2.1.5.tar.gz", hash = "sha256:d283d37a890ba4c1ae73ffadf8046435c76e7bc2247bbb63c00bd1a709c6544b"}, +] + +[[package]] +name = "matplotlib" +version = "3.7.5" +requires_python = ">=3.8" +summary = "Python plotting package" +groups = ["default", "pyvista"] +marker = "python_version == \"3.8\"" +dependencies = [ + "contourpy>=1.0.1", + "cycler>=0.10", + "fonttools>=4.22.0", + "importlib-resources>=3.2.0; python_version < \"3.10\"", + "kiwisolver>=1.0.1", + "numpy<2,>=1.20", + "packaging>=20.0", + "pillow>=6.2.0", + "pyparsing>=2.3.1", + "python-dateutil>=2.7", +] +files = [ + {file = "matplotlib-3.7.5-cp38-cp38-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:53e64522934df6e1818b25fd48cf3b645b11740d78e6ef765fbb5fa5ce080d02"}, + {file = "matplotlib-3.7.5-pp38-pypy38_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f0ad550da9f160737d7890217c5eeed4337d07e83ca1b2ca6535078f354e7675"}, + {file = "matplotlib-3.7.5.tar.gz", hash = "sha256:1e5c971558ebc811aa07f54c7b7c677d78aa518ef4c390e14673a09e0860184a"}, +] + +[[package]] +name = "matplotlib-inline" +version = "0.1.7" +requires_python = ">=3.8" +summary = "Inline Matplotlib backend for Jupyter" +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "traitlets", +] +files = [ + {file = "matplotlib_inline-0.1.7-py3-none-any.whl", hash = "sha256:df192d39a4ff8f21b1895d72e6a13f5fcc5099f00fa84384e0ea28c2cc0653ca"}, + {file = "matplotlib_inline-0.1.7.tar.gz", hash = "sha256:8423b23ec666be3d16e16b60bdd8ac4e86e840ebd1dd11a30b9f117f2fa0ab90"}, +] + +[[package]] +name = "mdurl" +version = "0.1.2" +requires_python = ">=3.7" +summary = "Markdown URL utilities" +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +files = [ + {file = "mdurl-0.1.2-py3-none-any.whl", hash = "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8"}, + {file = "mdurl-0.1.2.tar.gz", hash = "sha256:bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba"}, +] + +[[package]] +name = "meshio" +version = "5.3.5" +requires_python = ">=3.8" +summary = "I/O for many mesh formats" +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +dependencies = [ + "importlib-metadata; python_version < \"3.8\"", + "numpy>=1.20.0", + "rich", +] +files = [ + {file = "meshio-5.3.5-py3-none-any.whl", hash = "sha256:0736c6e34ecc768f62f2cde5d8233a3529512a9399b25c68ea2ca0d5900cdc10"}, + {file = "meshio-5.3.5.tar.gz", hash = "sha256:f21f01abd9f29ba06ea119304b3d39e610421cfe93b9dd23362834919f87586d"}, +] + +[[package]] +name = "mistune" +version = "3.0.2" +requires_python = ">=3.7" +summary = "A sane and fast Markdown parser with useful plugins and renderers" +groups = ["docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "mistune-3.0.2-py3-none-any.whl", hash = "sha256:71481854c30fdbc938963d3605b72501f5c10a9320ecd412c121c163a1c7d205"}, + {file = "mistune-3.0.2.tar.gz", hash = "sha256:fc7f93ded930c92394ef2cb6f04a8aabab4117a91449e72dcc8dfa646a508be8"}, +] + +[[package]] +name = "more-itertools" +version = "10.5.0" +requires_python = ">=3.8" +summary = "More routines for operating on iterables, beyond itertools" +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +files = [ + {file = "more-itertools-10.5.0.tar.gz", hash = "sha256:5482bfef7849c25dc3c6dd53a6173ae4795da2a41a80faea6700d9f5846c5da6"}, + {file = "more_itertools-10.5.0-py3-none-any.whl", hash = "sha256:037b0d3203ce90cca8ab1defbbdac29d5f993fc20131f3664dc8d6acfa872aef"}, +] + +[[package]] +name = "msgpack" +version = "1.1.0" +requires_python = ">=3.8" +summary = "MessagePack serializer" +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +files = [ + {file = "msgpack-1.1.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f1ba6136e650898082d9d5a5217d5906d1e138024f836ff48691784bbe1adf96"}, + {file = "msgpack-1.1.0.tar.gz", hash = "sha256:dd432ccc2c72b914e4cb77afce64aab761c1137cc698be3984eee260bcb2896e"}, +] + +[[package]] +name = "multidict" +version = "6.1.0" +requires_python = ">=3.8" +summary = "multidict implementation" +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +dependencies = [ + "typing-extensions>=4.1.0; python_version < \"3.11\"", +] +files = [ + {file = "multidict-6.1.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d093be959277cb7dee84b801eb1af388b6ad3ca6a6b6bf1ed7585895789d027d"}, + {file = "multidict-6.1.0-py3-none-any.whl", hash = "sha256:48e171e52d1c4d33888e529b999e5900356b9ae588c2f09a52dcefb158b27506"}, + {file = "multidict-6.1.0.tar.gz", hash = "sha256:22ae2ebf9b0c69d206c003e2f6a914ea33f0a932d4aa16f236afc049d9958f4a"}, +] + +[[package]] +name = "nbclient" +version = "0.10.0" +requires_python = ">=3.8.0" +summary = "A client library for executing notebooks. Formerly nbconvert's ExecutePreprocessor." +groups = ["docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "jupyter-client>=6.1.12", + "jupyter-core!=5.0.*,>=4.12", + "nbformat>=5.1", + "traitlets>=5.4", +] +files = [ + {file = "nbclient-0.10.0-py3-none-any.whl", hash = "sha256:f13e3529332a1f1f81d82a53210322476a168bb7090a0289c795fe9cc11c9d3f"}, + {file = "nbclient-0.10.0.tar.gz", hash = "sha256:4b3f1b7dba531e498449c4db4f53da339c91d449dc11e9af3a43b4eb5c5abb09"}, +] + +[[package]] +name = "nbconvert" +version = "7.16.6" +requires_python = ">=3.8" +summary = "Converting Jupyter Notebooks (.ipynb files) to other formats. Output formats include asciidoc, html, latex, markdown, pdf, py, rst, script. nbconvert can be used both as a Python library (`import nbconvert`) or as a command line tool (invoked as `jupyter nbconvert ...`)." +groups = ["docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "beautifulsoup4", + "bleach[css]!=5.0.0", + "defusedxml", + "importlib-metadata>=3.6; python_version < \"3.10\"", + "jinja2>=3.0", + "jupyter-core>=4.7", + "jupyterlab-pygments", + "markupsafe>=2.0", + "mistune<4,>=2.0.3", + "nbclient>=0.5.0", + "nbformat>=5.7", + "packaging", + "pandocfilters>=1.4.1", + "pygments>=2.4.1", + "traitlets>=5.1", +] +files = [ + {file = "nbconvert-7.16.6-py3-none-any.whl", hash = "sha256:1375a7b67e0c2883678c48e506dc320febb57685e5ee67faa51b18a90f3a712b"}, + {file = "nbconvert-7.16.6.tar.gz", hash = "sha256:576a7e37c6480da7b8465eefa66c17844243816ce1ccc372633c6b71c3c0f582"}, +] + +[[package]] +name = "nbformat" +version = "5.10.4" +requires_python = ">=3.8" +summary = "The Jupyter Notebook format" +groups = ["docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "fastjsonschema>=2.15", + "jsonschema>=2.6", + "jupyter-core!=5.0.*,>=4.12", + "traitlets>=5.1", +] +files = [ + {file = "nbformat-5.10.4-py3-none-any.whl", hash = "sha256:3b48d6c8fbca4b299bf3982ea7db1af21580e4fec269ad087b9e81588891200b"}, + {file = "nbformat-5.10.4.tar.gz", hash = "sha256:322168b14f937a5d11362988ecac2a4952d3d8e3a2cbeb2319584631226d5b3a"}, +] + +[[package]] +name = "nbsphinx" +version = "0.9.6" +requires_python = ">=3.6" +summary = "Jupyter Notebook Tools for Sphinx" +groups = ["docs"] +marker = "python_version == \"3.8\"" +dependencies = [ + "docutils>=0.18.1", + "jinja2", + "nbconvert!=5.4,>=5.3", + "nbformat", + "sphinx>=1.8", + "traitlets>=5", +] +files = [ + {file = "nbsphinx-0.9.6-py3-none-any.whl", hash = "sha256:336b0b557945a7678ec7449b16449f854bc852a435bb53b8a72e6b5dc740d992"}, + {file = "nbsphinx-0.9.6.tar.gz", hash = "sha256:c2b28a2d702f1159a95b843831798e86e60a17fc647b9bff9ba1585355de54e3"}, +] + +[[package]] +name = "nest-asyncio" +version = "1.6.0" +requires_python = ">=3.5" +summary = "Patch asyncio to allow nested event loops" +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "nest_asyncio-1.6.0-py3-none-any.whl", hash = "sha256:87af6efd6b5e897c81050477ef65c62e2b2f35d51703cae01aff2905b1852e1c"}, + {file = "nest_asyncio-1.6.0.tar.gz", hash = "sha256:6f172d5449aca15afd6c646851f4e31e02c598d553a667e38cafa997cfec55fe"}, +] + +[[package]] +name = "nodeenv" +version = "1.9.1" +requires_python = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,!=3.6.*,>=2.7" +summary = "Node.js virtual environment builder" +groups = ["qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "nodeenv-1.9.1-py2.py3-none-any.whl", hash = "sha256:ba11c9782d29c27c70ffbdda2d7415098754709be8a7056d79a737cd901155c9"}, + {file = "nodeenv-1.9.1.tar.gz", hash = "sha256:6ec12890a2dab7946721edbfbcd91f3319c6ccc9aec47be7c7e6b7011ee6645f"}, +] + +[[package]] +name = "notebook" +version = "7.3.2" +requires_python = ">=3.8" +summary = "Jupyter Notebook - A web-based notebook environment for interactive computing" +groups = ["qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "jupyter-server<3,>=2.4.0", + "jupyterlab-server<3,>=2.27.1", + "jupyterlab<4.4,>=4.3.4", + "notebook-shim<0.3,>=0.2", + "tornado>=6.2.0", +] +files = [ + {file = "notebook-7.3.2-py3-none-any.whl", hash = "sha256:e5f85fc59b69d3618d73cf27544418193ff8e8058d5bf61d315ce4f473556288"}, + {file = "notebook-7.3.2.tar.gz", hash = "sha256:705e83a1785f45b383bf3ee13cb76680b92d24f56fb0c7d2136fe1d850cd3ca8"}, +] + +[[package]] +name = "notebook-shim" +version = "0.2.4" +requires_python = ">=3.7" +summary = "A shim layer for notebook traits and config" +groups = ["qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "jupyter-server<3,>=1.8", +] +files = [ + {file = "notebook_shim-0.2.4-py3-none-any.whl", hash = "sha256:411a5be4e9dc882a074ccbcae671eda64cceb068767e9a3419096986560e1cef"}, + {file = "notebook_shim-0.2.4.tar.gz", hash = "sha256:b4b2cfa1b65d98307ca24361f5b30fe785b53c3fd07b7a47e89acb5e6ac638cb"}, +] + +[[package]] +name = "numpy" +version = "1.24.4" +requires_python = ">=3.8" +summary = "Fundamental package for array computing in Python" +groups = ["default", "pyvista"] +marker = "python_version == \"3.8\"" +files = [ + {file = "numpy-1.24.4-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dd80e219fd4c71fc3699fc1dadac5dcf4fd882bfc6f7ec53d30fa197b8ee22dc"}, + {file = "numpy-1.24.4-pp38-pypy38_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:95f7ac6540e95bc440ad77f56e520da5bf877f87dca58bd095288dce8940532a"}, + {file = "numpy-1.24.4.tar.gz", hash = "sha256:80f5e3a4e498641401868df4208b74581206afbee7cf7b8329daae82676d9463"}, +] + +[[package]] +name = "openpyxl" +version = "3.1.5" +requires_python = ">=3.8" +summary = "A Python library to read/write Excel 2010 xlsx/xlsm files" +groups = ["openpyxl"] +marker = "python_version == \"3.8\"" +dependencies = [ + "et-xmlfile", +] +files = [ + {file = "openpyxl-3.1.5-py2.py3-none-any.whl", hash = "sha256:5282c12b107bffeef825f4617dc029afaf41d0ea60823bbb665ef3079dc79de2"}, + {file = "openpyxl-3.1.5.tar.gz", hash = "sha256:cf0e3cf56142039133628b5acffe8ef0c12bc902d2aadd3e0fe5878dc08d1050"}, +] + +[[package]] +name = "overrides" +version = "7.7.0" +requires_python = ">=3.6" +summary = "A decorator to automatically detect mismatch when overriding a method." +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "typing; python_version < \"3.5\"", +] +files = [ + {file = "overrides-7.7.0-py3-none-any.whl", hash = "sha256:c7ed9d062f78b8e4c1a7b70bd8796b35ead4d9f510227ef9c5dc7626c60d7e49"}, + {file = "overrides-7.7.0.tar.gz", hash = "sha256:55158fa3d93b98cc75299b1e67078ad9003ca27945c76162c1c0766d6f91820a"}, +] + +[[package]] +name = "packaging" +version = "24.2" +requires_python = ">=3.8" +summary = "Core utilities for Python packages" +groups = ["default", "docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "packaging-24.2-py3-none-any.whl", hash = "sha256:09abb1bccd265c01f4a3aa3f7a7db064b36514d2cba19a2f694fe6150451a759"}, + {file = "packaging-24.2.tar.gz", hash = "sha256:c228a6dc5e932d346bc5739379109d49e8853dd8223571c7c5b55260edc0b97f"}, +] + +[[package]] +name = "pandas" +version = "2.0.3" +requires_python = ">=3.8" +summary = "Powerful data structures for data analysis, time series, and statistics" +groups = ["default"] +marker = "python_version == \"3.8\"" +dependencies = [ + "numpy>=1.20.3; python_version < \"3.10\"", + "numpy>=1.21.0; python_version >= \"3.10\"", + "numpy>=1.23.2; python_version >= \"3.11\"", + "python-dateutil>=2.8.2", + "pytz>=2020.1", + "tzdata>=2022.1", +] +files = [ + {file = "pandas-2.0.3-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9eae3dc34fa1aa7772dd3fc60270d13ced7346fcbcfee017d3132ec625e23bb0"}, + {file = "pandas-2.0.3.tar.gz", hash = "sha256:c02f372a88e0d17f36d3093a644c73cfc1788e876a7c4bcb4020a77512e2043c"}, +] + +[[package]] +name = "pandoc" +version = "2.4" +summary = "Pandoc Documents for Python" +groups = ["docs"] +marker = "python_version == \"3.8\"" +dependencies = [ + "plumbum", + "ply", +] +files = [ + {file = "pandoc-2.4.tar.gz", hash = "sha256:ecd1f8cbb7f4180c6b5db4a17a7c1a74df519995f5f186ef81ce72a9cbd0dd9a"}, +] + +[[package]] +name = "pandocfilters" +version = "1.5.1" +requires_python = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*" +summary = "Utilities for writing pandoc filters in python" +groups = ["docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "pandocfilters-1.5.1-py2.py3-none-any.whl", hash = "sha256:93be382804a9cdb0a7267585f157e5d1731bbe5545a85b268d6f5fe6232de2bc"}, + {file = "pandocfilters-1.5.1.tar.gz", hash = "sha256:002b4a555ee4ebc03f8b66307e287fa492e4a77b4ea14d3f934328297bb4939e"}, +] + +[[package]] +name = "parso" +version = "0.8.4" +requires_python = ">=3.6" +summary = "A Python Parser" +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "parso-0.8.4-py2.py3-none-any.whl", hash = "sha256:a418670a20291dacd2dddc80c377c5c3791378ee1e8d12bffc35420643d43f18"}, + {file = "parso-0.8.4.tar.gz", hash = "sha256:eb3a7b58240fb99099a345571deecc0f9540ea5f4dd2fe14c2a99d6b281ab92d"}, +] + +[[package]] +name = "pexpect" +version = "4.9.0" +summary = "Pexpect allows easy control of interactive console applications." +groups = ["pyvista", "qa"] +marker = "sys_platform != \"win32\" and python_version == \"3.8\"" +dependencies = [ + "ptyprocess>=0.5", +] +files = [ + {file = "pexpect-4.9.0-py2.py3-none-any.whl", hash = "sha256:7236d1e080e4936be2dc3e326cec0af72acf9212a7e1d060210e70a47e253523"}, + {file = "pexpect-4.9.0.tar.gz", hash = "sha256:ee7d41123f3c9911050ea2c2dac107568dc43b2d3b0c7557a33212c398ead30f"}, +] + +[[package]] +name = "pickleshare" +version = "0.7.5" +summary = "Tiny 'shelve'-like database with concurrency support" +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "pathlib2; python_version in \"2.6 2.7 3.2 3.3\"", +] +files = [ + {file = "pickleshare-0.7.5-py2.py3-none-any.whl", hash = "sha256:9649af414d74d4df115d5d718f82acb59c9d418196b7b4290ed47a12ce62df56"}, + {file = "pickleshare-0.7.5.tar.gz", hash = "sha256:87683d47965c1da65cdacaf31c8441d12b8044cdec9aca500cd78fc2c683afca"}, +] + +[[package]] +name = "pillow" +version = "10.4.0" +requires_python = ">=3.8" +summary = "Python Imaging Library (Fork)" +groups = ["default", "pyvista"] +marker = "python_version == \"3.8\"" +files = [ + {file = "pillow-10.4.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7a8d4bade9952ea9a77d0c3e49cbd8b2890a399422258a77f357b9cc9be8d680"}, + {file = "pillow-10.4.0.tar.gz", hash = "sha256:166c1cd4d24309b30d61f79f4a9114b7b2313d7450912277855ff5dfd7cd4a06"}, +] + +[[package]] +name = "pkgutil-resolve-name" +version = "1.3.10" +requires_python = ">=3.6" +summary = "Resolve a name to an object." +groups = ["docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "pkgutil_resolve_name-1.3.10-py3-none-any.whl", hash = "sha256:ca27cc078d25c5ad71a9de0a7a330146c4e014c2462d9af19c6b828280649c5e"}, + {file = "pkgutil_resolve_name-1.3.10.tar.gz", hash = "sha256:357d6c9e6a755653cfd78893817c0853af365dd51ec97f3d358a819373bbd174"}, +] + +[[package]] +name = "platformdirs" +version = "4.3.6" +requires_python = ">=3.8" +summary = "A small Python package for determining appropriate platform-specific dirs, e.g. a `user data dir`." +groups = ["docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "platformdirs-4.3.6-py3-none-any.whl", hash = "sha256:73e575e1408ab8103900836b97580d5307456908a03e92031bab39e4554cc3fb"}, + {file = "platformdirs-4.3.6.tar.gz", hash = "sha256:357fb2acbc885b0419afd3ce3ed34564c13c9b95c89360cd9563f73aa5e2b907"}, +] + +[[package]] +name = "pluggy" +version = "1.5.0" +requires_python = ">=3.8" +summary = "plugin and hook calling mechanisms for python" +groups = ["qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "pluggy-1.5.0-py3-none-any.whl", hash = "sha256:44e1ad92c8ca002de6377e165f3e0f1be63266ab4d554740532335b9d75ea669"}, + {file = "pluggy-1.5.0.tar.gz", hash = "sha256:2cffa88e94fdc978c4c574f15f9e59b7f4201d439195c3715ca9e2486f1d0cf1"}, +] + +[[package]] +name = "plumbum" +version = "1.8.3" +requires_python = ">=3.6" +summary = "Plumbum: shell combinators library" +groups = ["docs"] +marker = "python_version == \"3.8\"" +dependencies = [ + "pywin32; platform_system == \"Windows\" and platform_python_implementation != \"PyPy\"", +] +files = [ + {file = "plumbum-1.8.3-py3-none-any.whl", hash = "sha256:8595d36dae2472587d6f59789c8d7b26250f45f6f6ed75ccb378de59ee7b9cf9"}, + {file = "plumbum-1.8.3.tar.gz", hash = "sha256:6092c85ab970b7a7a9d5d85c75200bc93be82b33c9bdf640ffa87d2d7c8709f0"}, +] + +[[package]] +name = "ply" +version = "3.11" +summary = "Python Lex & Yacc" +groups = ["docs"] +marker = "python_version == \"3.8\"" +files = [ + {file = "ply-3.11-py2.py3-none-any.whl", hash = "sha256:096f9b8350b65ebd2fd1346b12452efe5b9607f7482813ffca50c22722a807ce"}, + {file = "ply-3.11.tar.gz", hash = "sha256:00c7c1aaa88358b9c765b6d3000c6eec0ba42abca5351b095321aef446081da3"}, +] + +[[package]] +name = "pooch" +version = "1.8.2" +requires_python = ">=3.7" +summary = "A friend to fetch your data files" +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +dependencies = [ + "packaging>=20.0", + "platformdirs>=2.5.0", + "requests>=2.19.0", +] +files = [ + {file = "pooch-1.8.2-py3-none-any.whl", hash = "sha256:3529a57096f7198778a5ceefd5ac3ef0e4d06a6ddaf9fc2d609b806f25302c47"}, + {file = "pooch-1.8.2.tar.gz", hash = "sha256:76561f0de68a01da4df6af38e9955c4c9d1a5c90da73f7e40276a5728ec83d10"}, +] + +[[package]] +name = "pre-commit" +version = "3.5.0" +requires_python = ">=3.8" +summary = "A framework for managing and maintaining multi-language pre-commit hooks." +groups = ["qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "cfgv>=2.0.0", + "identify>=1.0.0", + "nodeenv>=0.11.1", + "pyyaml>=5.1", + "virtualenv>=20.10.0", +] +files = [ + {file = "pre_commit-3.5.0-py2.py3-none-any.whl", hash = "sha256:841dc9aef25daba9a0238cd27984041fa0467b4199fc4852e27950664919f660"}, + {file = "pre_commit-3.5.0.tar.gz", hash = "sha256:5804465c675b659b0862f07907f96295d490822a450c4c40e747d0b1c6ebcb32"}, +] + +[[package]] +name = "prometheus-client" +version = "0.20.0" +requires_python = ">=3.8" +summary = "Python client for the Prometheus monitoring system." +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "prometheus_client-0.20.0-py3-none-any.whl", hash = "sha256:cde524a85bce83ca359cc837f28b8c0db5cac7aa653a588fd7e84ba061c329e7"}, + {file = "prometheus_client-0.20.0.tar.gz", hash = "sha256:287629d00b147a32dcb2be0b9df905da599b2d82f80377083ec8463309a4bb89"}, +] + +[[package]] +name = "prompt-toolkit" +version = "3.0.47" +requires_python = ">=3.7.0" +summary = "Library for building powerful interactive command lines in Python" +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "wcwidth", +] +files = [ + {file = "prompt_toolkit-3.0.47-py3-none-any.whl", hash = "sha256:0d7bfa67001d5e39d02c224b663abc33687405033a8c422d0d675a5a13361d10"}, + {file = "prompt_toolkit-3.0.47.tar.gz", hash = "sha256:1e1b29cb58080b1e69f207c893a1a7bf16d127a5c30c9d17a25a5d77792e5360"}, +] + +[[package]] +name = "propcache" +version = "0.2.0" +requires_python = ">=3.8" +summary = "Accelerated property cache" +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +files = [ + {file = "propcache-0.2.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:67b69535c870670c9f9b14a75d28baa32221d06f6b6fa6f77a0a13c5a7b0a5b9"}, + {file = "propcache-0.2.0-py3-none-any.whl", hash = "sha256:2ccc28197af5313706511fab3a8b66dcd6da067a1331372c82ea1cb74285e036"}, + {file = "propcache-0.2.0.tar.gz", hash = "sha256:df81779732feb9d01e5d513fad0122efb3d53bbc75f61b2a4f29a020bc985e70"}, +] + +[[package]] +name = "psutil" +version = "6.0.0" +requires_python = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7" +summary = "Cross-platform lib for process and system monitoring in Python." +groups = ["qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "psutil-6.0.0-cp36-abi3-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5fd9a97c8e94059b0ef54a7d4baf13b405011176c3b6ff257c247cae0d560ecd"}, + {file = "psutil-6.0.0.tar.gz", hash = "sha256:8faae4f310b6d969fa26ca0545338b21f73c6b15db7c4a8d934a5482faa818f2"}, +] + +[[package]] +name = "ptyprocess" +version = "0.7.0" +summary = "Run a subprocess in a pseudo terminal" +groups = ["pyvista", "qa"] +marker = "os_name != \"nt\" and python_version == \"3.8\" or sys_platform != \"win32\" and python_version == \"3.8\"" +files = [ + {file = "ptyprocess-0.7.0-py2.py3-none-any.whl", hash = "sha256:4b41f3967fce3af57cc7e94b888626c18bf37a083e3651ca8feeb66d492fef35"}, + {file = "ptyprocess-0.7.0.tar.gz", hash = "sha256:5c5d0a3b48ceee0b48485e0c26037c0acd7d29765ca3fbb5cb3831d347423220"}, +] + +[[package]] +name = "pure-eval" +version = "0.2.3" +summary = "Safely evaluate AST nodes without side effects" +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "pure_eval-0.2.3-py3-none-any.whl", hash = "sha256:1db8e35b67b3d218d818ae653e27f06c3aa420901fa7b081ca98cbedc874e0d0"}, + {file = "pure_eval-0.2.3.tar.gz", hash = "sha256:5f4e983f40564c576c7c8635ae88db5956bb2229d7e9237d03b3c0b0190eaf42"}, +] + +[[package]] +name = "pycparser" +version = "2.22" +requires_python = ">=3.8" +summary = "C parser in Python" +groups = ["docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "pycparser-2.22-py3-none-any.whl", hash = "sha256:c3702b6d3dd8c7abc1afa565d7e63d53a1d0bd86cdc24edd75470f4de499cfcc"}, + {file = "pycparser-2.22.tar.gz", hash = "sha256:491c8be9c040f5390f5bf44a5b07752bd07f56edf992381b05c701439eec10f6"}, +] + +[[package]] +name = "pydantic" +version = "2.9.1" +requires_python = ">=3.8" +summary = "Data validation using Python type hints" +groups = ["default"] +marker = "python_version == \"3.8\"" +dependencies = [ + "annotated-types>=0.6.0", + "pydantic-core==2.23.3", + "typing-extensions>=4.12.2; python_version >= \"3.13\"", + "typing-extensions>=4.6.1; python_version < \"3.13\"", +] +files = [ + {file = "pydantic-2.9.1-py3-none-any.whl", hash = "sha256:7aff4db5fdf3cf573d4b3c30926a510a10e19a0774d38fc4967f78beb6deb612"}, + {file = "pydantic-2.9.1.tar.gz", hash = "sha256:1363c7d975c7036df0db2b4a61f2e062fbc0aa5ab5f2772e0ffc7191a4f4bce2"}, +] + +[[package]] +name = "pydantic-core" +version = "2.23.3" +requires_python = ">=3.8" +summary = "Core functionality for Pydantic validation and serialization" +groups = ["default"] +marker = "python_version == \"3.8\"" +dependencies = [ + "typing-extensions!=4.7.0,>=4.6.0", +] +files = [ + {file = "pydantic_core-2.23.3-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:04b07490bc2f6f2717b10c3969e1b830f5720b632f8ae2f3b8b1542394c47a8e"}, + {file = "pydantic_core-2.23.3.tar.gz", hash = "sha256:3cb0f65d8b4121c1b015c60104a685feb929a29d7cf204387c7f2688c7974690"}, +] + +[[package]] +name = "pygments" +version = "2.18.0" +requires_python = ">=3.8" +summary = "Pygments is a syntax highlighting package written in Python." +groups = ["docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "pygments-2.18.0-py3-none-any.whl", hash = "sha256:b8e6aca0523f3ab76fee51799c488e38782ac06eafcf95e7ba832985c8e7b13a"}, + {file = "pygments-2.18.0.tar.gz", hash = "sha256:786ff802f32e91311bff3889f6e9a86e81505fe99f2735bb6d60ae0c5004f199"}, +] + +[[package]] +name = "pyparsing" +version = "3.1.4" +requires_python = ">=3.6.8" +summary = "pyparsing module - Classes and methods to define and execute parsing grammars" +groups = ["default", "pyvista"] +marker = "python_version == \"3.8\"" +files = [ + {file = "pyparsing-3.1.4-py3-none-any.whl", hash = "sha256:a6a7ee4235a3f944aa1fa2249307708f893fe5717dc603503c6c7969c070fb7c"}, + {file = "pyparsing-3.1.4.tar.gz", hash = "sha256:f86ec8d1a83f11977c9a6ea7598e8c27fc5cddfa5b07ea2241edbbde1d7bc032"}, +] + +[[package]] +name = "pyproject-api" +version = "1.8.0" +requires_python = ">=3.8" +summary = "API to interact with the python pyproject.toml based projects" +groups = ["qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "packaging>=24.1", + "tomli>=2.0.1; python_version < \"3.11\"", +] +files = [ + {file = "pyproject_api-1.8.0-py3-none-any.whl", hash = "sha256:3d7d347a047afe796fd5d1885b1e391ba29be7169bd2f102fcd378f04273d228"}, + {file = "pyproject_api-1.8.0.tar.gz", hash = "sha256:77b8049f2feb5d33eefcc21b57f1e279636277a8ac8ad6b5871037b243778496"}, +] + +[[package]] +name = "pyqt5" +version = "5.15.10" +requires_python = ">=3.7" +summary = "Python bindings for the Qt cross platform application toolkit" +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +dependencies = [ + "PyQt5-Qt5>=5.15.2", + "PyQt5-sip<13,>=12.13", +] +files = [ + {file = "PyQt5-5.15.10-cp37-abi3-manylinux_2_17_x86_64.whl", hash = "sha256:b89478d16d4118664ff58ed609e0a804d002703c9420118de7e4e70fa1cb5486"}, + {file = "PyQt5-5.15.10.tar.gz", hash = "sha256:d46b7804b1b10a4ff91753f8113e5b5580d2b4462f3226288e2d84497334898a"}, +] + +[[package]] +name = "pyqt5-qt5" +version = "5.15.2" +summary = "The subset of a Qt installation needed by PyQt5." +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +files = [ + {file = "PyQt5_Qt5-5.15.2-py3-none-manylinux2014_x86_64.whl", hash = "sha256:1988f364ec8caf87a6ee5d5a3a5210d57539988bf8e84714c7d60972692e2f4a"}, +] + +[[package]] +name = "pyqt5-sip" +version = "12.15.0" +requires_python = ">=3.8" +summary = "The sip module support for PyQt5" +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +files = [ + {file = "PyQt5_sip-12.15.0-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:0c1c727ede7fdc464a1fe2e46109ba836509b2d7187a46fdeae443148ce51d1c"}, + {file = "PyQt5_sip-12.15.0.tar.gz", hash = "sha256:d23fdfcf363b5cedd9d39f8a9c5710e7d52804f5b08a58e91c638b36eafcb702"}, +] + +[[package]] +name = "pytest" +version = "8.3.3" +requires_python = ">=3.8" +summary = "pytest: simple powerful testing with Python" +groups = ["qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "colorama; sys_platform == \"win32\"", + "exceptiongroup>=1.0.0rc8; python_version < \"3.11\"", + "iniconfig", + "packaging", + "pluggy<2,>=1.5", + "tomli>=1; python_version < \"3.11\"", +] +files = [ + {file = "pytest-8.3.3-py3-none-any.whl", hash = "sha256:a6853c7375b2663155079443d2e45de913a911a11d669df02a50814944db57b2"}, + {file = "pytest-8.3.3.tar.gz", hash = "sha256:70b98107bd648308a7952b06e6ca9a50bc660be218d53c257cc1fc94fda10181"}, +] + +[[package]] +name = "pytest-cov" +version = "5.0.0" +requires_python = ">=3.8" +summary = "Pytest plugin for measuring coverage." +groups = ["qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "coverage[toml]>=5.2.1", + "pytest>=4.6", +] +files = [ + {file = "pytest-cov-5.0.0.tar.gz", hash = "sha256:5837b58e9f6ebd335b0f8060eecce69b662415b16dc503883a02f45dfeb14857"}, + {file = "pytest_cov-5.0.0-py3-none-any.whl", hash = "sha256:4f0764a1219df53214206bf1feea4633c3b558a2925c8b59f144f682861ce652"}, +] + +[[package]] +name = "python-dateutil" +version = "2.9.0.post0" +requires_python = "!=3.0.*,!=3.1.*,!=3.2.*,>=2.7" +summary = "Extensions to the standard Python datetime module" +groups = ["default", "docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "six>=1.5", +] +files = [ + {file = "python-dateutil-2.9.0.post0.tar.gz", hash = "sha256:37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3"}, + {file = "python_dateutil-2.9.0.post0-py2.py3-none-any.whl", hash = "sha256:a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427"}, +] + +[[package]] +name = "python-json-logger" +version = "2.0.7" +requires_python = ">=3.6" +summary = "A python library adding a json log formatter" +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "python-json-logger-2.0.7.tar.gz", hash = "sha256:23e7ec02d34237c5aa1e29a070193a4ea87583bb4e7f8fd06d3de8264c4b2e1c"}, + {file = "python_json_logger-2.0.7-py3-none-any.whl", hash = "sha256:f380b826a991ebbe3de4d897aeec42760035ac760345e57b812938dc8b35e2bd"}, +] + +[[package]] +name = "pytz" +version = "2024.2" +summary = "World timezone definitions, modern and historical" +groups = ["default", "docs", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "pytz-2024.2-py2.py3-none-any.whl", hash = "sha256:31c7c1817eb7fae7ca4b8c7ee50c72f93aa2dd863de768e1ef4245d426aa0725"}, + {file = "pytz-2024.2.tar.gz", hash = "sha256:2aa355083c50a0f93fa581709deac0c9ad65cca8a9e9beac660adcbd493c798a"}, +] + +[[package]] +name = "pyvista" +version = "0.44.1" +requires_python = ">=3.8" +summary = "Easier Pythonic interface to VTK" +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +dependencies = [ + "matplotlib>=3.0.1", + "numpy>=1.21.0", + "pillow", + "pooch", + "scooby>=0.5.1", + "typing-extensions", + "vtk", +] +files = [ + {file = "pyvista-0.44.1-py3-none-any.whl", hash = "sha256:7a80e8114220ca36d57a4def8e6a3067c908b53b62aa426ea76c76069bb6d1c0"}, + {file = "pyvista-0.44.1.tar.gz", hash = "sha256:63976f5d57d151b3f7e1616dde40dcf56a66d1f37f6db067087fa9cc9667f512"}, +] + +[[package]] +name = "pyvista" +version = "0.44.1" +extras = ["all"] +requires_python = ">=3.8" +summary = "Easier Pythonic interface to VTK" +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +dependencies = [ + "pyvista==0.44.1", + "pyvista[colormaps,io,jupyter]", +] +files = [ + {file = "pyvista-0.44.1-py3-none-any.whl", hash = "sha256:7a80e8114220ca36d57a4def8e6a3067c908b53b62aa426ea76c76069bb6d1c0"}, + {file = "pyvista-0.44.1.tar.gz", hash = "sha256:63976f5d57d151b3f7e1616dde40dcf56a66d1f37f6db067087fa9cc9667f512"}, +] + +[[package]] +name = "pyvista" +version = "0.44.1" +extras = ["colormaps", "io", "jupyter"] +requires_python = ">=3.8" +summary = "Easier Pythonic interface to VTK" +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +dependencies = [ + "cmocean", + "colorcet", + "imageio", + "ipywidgets", + "jupyter-server-proxy", + "meshio>=5.2", + "nest-asyncio", + "pyvista==0.44.1", + "trame-client>=2.12.7", + "trame-server>=2.11.7", + "trame-vtk>=2.5.8", + "trame-vuetify>=2.3.1", + "trame>=2.5.2", +] +files = [ + {file = "pyvista-0.44.1-py3-none-any.whl", hash = "sha256:7a80e8114220ca36d57a4def8e6a3067c908b53b62aa426ea76c76069bb6d1c0"}, + {file = "pyvista-0.44.1.tar.gz", hash = "sha256:63976f5d57d151b3f7e1616dde40dcf56a66d1f37f6db067087fa9cc9667f512"}, +] + +[[package]] +name = "pyvistaqt" +version = "0.11.1" +requires_python = ">=3.7" +summary = "pyvista qt plotter" +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +dependencies = [ + "QtPy>=1.9.0", + "pyvista>=0.32.0", +] +files = [ + {file = "pyvistaqt-0.11.1-py3-none-any.whl", hash = "sha256:3ddc05418fcb297d471e7f7c0fdc89dbd5b6050653b4a86e66e5c1ce7e3563cc"}, + {file = "pyvistaqt-0.11.1.tar.gz", hash = "sha256:5403bfeb82cf063288107a9be9780ca3ca70948e73d33d16a65a83a711d51a36"}, +] + +[[package]] +name = "pyyaml" +version = "6.0.2" +requires_python = ">=3.8" +summary = "YAML parser and emitter for Python" +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "PyYAML-6.0.2-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9056c1ecd25795207ad294bcf39f2db3d845767be0ea6e6a34d856f006006083"}, + {file = "pyyaml-6.0.2.tar.gz", hash = "sha256:d584d9ec91ad65861cc08d42e834324ef890a082e591037abe114850ff7bbc3e"}, +] + +[[package]] +name = "pyzmq" +version = "26.2.0" +requires_python = ">=3.7" +summary = "Python bindings for 0MQ" +groups = ["docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "cffi; implementation_name == \"pypy\"", +] +files = [ + {file = "pyzmq-26.2.0-cp38-cp38-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:8be4700cd8bb02cc454f630dcdf7cfa99de96788b80c51b60fe2fe1dac480289"}, + {file = "pyzmq-26.2.0-pp38-pypy38_pp73-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:226af7dcb51fdb0109f0016449b357e182ea0ceb6b47dfb5999d569e5db161d5"}, + {file = "pyzmq-26.2.0.tar.gz", hash = "sha256:070672c258581c8e4f640b5159297580a9974b026043bd4ab0470be9ed324f1f"}, +] + +[[package]] +name = "qtpy" +version = "2.4.1" +requires_python = ">=3.7" +summary = "Provides an abstraction layer on top of the various Qt bindings (PyQt5/6 and PySide2/6)." +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +dependencies = [ + "packaging", +] +files = [ + {file = "QtPy-2.4.1-py3-none-any.whl", hash = "sha256:1c1d8c4fa2c884ae742b069151b0abe15b3f70491f3972698c683b8e38de839b"}, + {file = "QtPy-2.4.1.tar.gz", hash = "sha256:a5a15ffd519550a1361bdc56ffc07fda56a6af7292f17c7b395d4083af632987"}, +] + +[[package]] +name = "referencing" +version = "0.35.1" +requires_python = ">=3.8" +summary = "JSON Referencing + Python" +groups = ["docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "attrs>=22.2.0", + "rpds-py>=0.7.0", +] +files = [ + {file = "referencing-0.35.1-py3-none-any.whl", hash = "sha256:eda6d3234d62814d1c64e305c1331c9a3a6132da475ab6382eaa997b21ee75de"}, + {file = "referencing-0.35.1.tar.gz", hash = "sha256:25b42124a6c8b632a425174f24087783efb348a6f1e0008e63cd4466fedf703c"}, +] + +[[package]] +name = "requests" +version = "2.32.3" +requires_python = ">=3.8" +summary = "Python HTTP for Humans." +groups = ["docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "certifi>=2017.4.17", + "charset-normalizer<4,>=2", + "idna<4,>=2.5", + "urllib3<3,>=1.21.1", +] +files = [ + {file = "requests-2.32.3-py3-none-any.whl", hash = "sha256:70761cfe03c773ceb22aa2f671b4757976145175cdfca038c02654d061d6dcc6"}, + {file = "requests-2.32.3.tar.gz", hash = "sha256:55365417734eb18255590a9ff9eb97e9e1da868d4ccd6402399eaf68af20a760"}, +] + +[[package]] +name = "rfc3339-validator" +version = "0.1.4" +requires_python = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*" +summary = "A pure python RFC3339 validator" +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "six", +] +files = [ + {file = "rfc3339_validator-0.1.4-py2.py3-none-any.whl", hash = "sha256:24f6ec1eda14ef823da9e36ec7113124b39c04d50a4d3d3a3c2859577e7791fa"}, + {file = "rfc3339_validator-0.1.4.tar.gz", hash = "sha256:138a2abdf93304ad60530167e51d2dfb9549521a836871b88d7f4695d0022f6b"}, +] + +[[package]] +name = "rfc3986-validator" +version = "0.1.1" +requires_python = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*" +summary = "Pure python rfc3986 validator" +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "rfc3986_validator-0.1.1-py2.py3-none-any.whl", hash = "sha256:2f235c432ef459970b4306369336b9d5dbdda31b510ca1e327636e01f528bfa9"}, + {file = "rfc3986_validator-0.1.1.tar.gz", hash = "sha256:3d44bde7921b3b9ec3ae4e3adca370438eccebc676456449b145d533b240d055"}, +] + +[[package]] +name = "rich" +version = "13.8.1" +requires_python = ">=3.7.0" +summary = "Render rich text, tables, progress bars, syntax highlighting, markdown and more to the terminal" +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +dependencies = [ + "markdown-it-py>=2.2.0", + "pygments<3.0.0,>=2.13.0", + "typing-extensions<5.0,>=4.0.0; python_version < \"3.9\"", +] +files = [ + {file = "rich-13.8.1-py3-none-any.whl", hash = "sha256:1760a3c0848469b97b558fc61c85233e3dafb69c7a071b4d60c38099d3cd4c06"}, + {file = "rich-13.8.1.tar.gz", hash = "sha256:8260cda28e3db6bf04d2d1ef4dbc03ba80a824c88b0e7668a0f23126a424844a"}, +] + +[[package]] +name = "rpds-py" +version = "0.20.0" +requires_python = ">=3.8" +summary = "Python bindings to Rust's persistent data structures (rpds)" +groups = ["docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "rpds_py-0.20.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:af0fc424a5842a11e28956e69395fbbeab2c97c42253169d87e90aac2886d751"}, + {file = "rpds_py-0.20.0.tar.gz", hash = "sha256:d72a210824facfdaf8768cf2d7ca25a042c30320b3020de2fa04640920d4e121"}, +] + +[[package]] +name = "scipy" +version = "1.10.1" +requires_python = "<3.12,>=3.8" +summary = "Fundamental algorithms for scientific computing in Python" +groups = ["default"] +marker = "python_version == \"3.8\"" +dependencies = [ + "numpy<1.27.0,>=1.19.5", +] +files = [ + {file = "scipy-1.10.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:07c3457ce0b3ad5124f98a86533106b643dd811dd61b548e78cf4c8786652f6f"}, + {file = "scipy-1.10.1.tar.gz", hash = "sha256:2cf9dfb80a7b4589ba4c40ce7588986d6d5cebc5457cad2c2880f6bc2d42f3a5"}, +] + +[[package]] +name = "scooby" +version = "0.10.0" +requires_python = ">=3.8" +summary = "A Great Dane turned Python environment detective" +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +files = [ + {file = "scooby-0.10.0-py3-none-any.whl", hash = "sha256:0a3d7e304f8ebb16f69ff7f6360c345d7f50b45f2ddbf7c3d18a6a0dc2cb03a6"}, + {file = "scooby-0.10.0.tar.gz", hash = "sha256:7ea33c262c0cc6a33c6eeeb5648df787be4f22660e53c114e5fff1b811a8854f"}, +] + +[[package]] +name = "send2trash" +version = "1.8.3" +requires_python = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7" +summary = "Send file to trash natively under Mac OS X, Windows and Linux" +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "Send2Trash-1.8.3-py3-none-any.whl", hash = "sha256:0c31227e0bd08961c7665474a3d1ef7193929fedda4233843689baa056be46c9"}, + {file = "Send2Trash-1.8.3.tar.gz", hash = "sha256:b18e7a3966d99871aefeb00cfbcfdced55ce4871194810fc71f4aa484b953abf"}, +] + +[[package]] +name = "setuptools" +version = "74.1.2" +requires_python = ">=3.8" +summary = "Easily download, build, install, upgrade, and uninstall Python packages" +groups = ["qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "setuptools-74.1.2-py3-none-any.whl", hash = "sha256:5f4c08aa4d3ebcb57a50c33b1b07e94315d7fc7230f7115e47fc99776c8ce308"}, + {file = "setuptools-74.1.2.tar.gz", hash = "sha256:95b40ed940a1c67eb70fc099094bd6e99c6ee7c23aa2306f4d2697ba7916f9c6"}, +] + +[[package]] +name = "simpervisor" +version = "1.0.0" +requires_python = ">=3.8" +summary = "Simple async process supervisor" +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +files = [ + {file = "simpervisor-1.0.0-py3-none-any.whl", hash = "sha256:3e313318264559beea3f475ead202bc1cd58a2f1288363abb5657d306c5b8388"}, + {file = "simpervisor-1.0.0.tar.gz", hash = "sha256:7eb87ca86d5e276976f5bb0290975a05d452c6a7b7f58062daea7d8369c823c1"}, +] + +[[package]] +name = "six" +version = "1.16.0" +requires_python = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*" +summary = "Python 2 and 3 compatibility utilities" +groups = ["default", "docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "six-1.16.0-py2.py3-none-any.whl", hash = "sha256:8abb2f1d86890a2dfb989f9a77cfcfd3e47c2a354b01111771326f8aa26e0254"}, + {file = "six-1.16.0.tar.gz", hash = "sha256:1e61c37477a1626458e36f7b1d82aa5c9b094fa4802892072e49de9c60c4c926"}, +] + +[[package]] +name = "sniffio" +version = "1.3.1" +requires_python = ">=3.7" +summary = "Sniff out which async library your code is running under" +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "sniffio-1.3.1-py3-none-any.whl", hash = "sha256:2f6da418d1f1e0fddd844478f41680e794e6051915791a034ff65e5f100525a2"}, + {file = "sniffio-1.3.1.tar.gz", hash = "sha256:f4324edc670a0f49750a81b895f35c3adb843cca46f0530f79fc1babb23789dc"}, +] + +[[package]] +name = "snowballstemmer" +version = "2.2.0" +summary = "This package provides 29 stemmers for 28 languages generated from Snowball algorithms." +groups = ["docs"] +marker = "python_version == \"3.8\"" +files = [ + {file = "snowballstemmer-2.2.0-py2.py3-none-any.whl", hash = "sha256:c8e1716e83cc398ae16824e5572ae04e0d9fc2c6b985fb0f900f5f0c96ecba1a"}, + {file = "snowballstemmer-2.2.0.tar.gz", hash = "sha256:09b16deb8547d3412ad7b590689584cd0fe25ec8db3be37788be3810cbf19cb1"}, +] + +[[package]] +name = "soupsieve" +version = "2.6" +requires_python = ">=3.8" +summary = "A modern CSS selector implementation for Beautiful Soup." +groups = ["docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "soupsieve-2.6-py3-none-any.whl", hash = "sha256:e72c4ff06e4fb6e4b5a9f0f55fe6e81514581fca1515028625d0f299c602ccc9"}, + {file = "soupsieve-2.6.tar.gz", hash = "sha256:e2e68417777af359ec65daac1057404a3c8a5455bb8abc36f1a9866ab1a51abb"}, +] + +[[package]] +name = "sphinx" +version = "7.1.2" +requires_python = ">=3.8" +summary = "Python documentation generator" +groups = ["docs"] +marker = "python_version == \"3.8\"" +dependencies = [ + "Jinja2>=3.0", + "Pygments>=2.13", + "alabaster<0.8,>=0.7", + "babel>=2.9", + "colorama>=0.4.5; sys_platform == \"win32\"", + "docutils<0.21,>=0.18.1", + "imagesize>=1.3", + "importlib-metadata>=4.8; python_version < \"3.10\"", + "packaging>=21.0", + "requests>=2.25.0", + "snowballstemmer>=2.0", + "sphinxcontrib-applehelp", + "sphinxcontrib-devhelp", + "sphinxcontrib-htmlhelp>=2.0.0", + "sphinxcontrib-jsmath", + "sphinxcontrib-qthelp", + "sphinxcontrib-serializinghtml>=1.1.5", +] +files = [ + {file = "sphinx-7.1.2-py3-none-any.whl", hash = "sha256:d170a81825b2fcacb6dfd5a0d7f578a053e45d3f2b153fecc948c37344eb4cbe"}, + {file = "sphinx-7.1.2.tar.gz", hash = "sha256:780f4d32f1d7d1126576e0e5ecc19dc32ab76cd24e950228dcf7b1f6d3d9e22f"}, +] + +[[package]] +name = "sphinx-rtd-theme" +version = "2.0.0" +requires_python = ">=3.6" +summary = "Read the Docs theme for Sphinx" +groups = ["docs"] +marker = "python_version == \"3.8\"" +dependencies = [ + "docutils<0.21", + "sphinx<8,>=5", + "sphinxcontrib-jquery<5,>=4", +] +files = [ + {file = "sphinx_rtd_theme-2.0.0-py2.py3-none-any.whl", hash = "sha256:ec93d0856dc280cf3aee9a4c9807c60e027c7f7b461b77aeffed682e68f0e586"}, + {file = "sphinx_rtd_theme-2.0.0.tar.gz", hash = "sha256:bd5d7b80622406762073a04ef8fadc5f9151261563d47027de09910ce03afe6b"}, +] + +[[package]] +name = "sphinxcontrib-applehelp" +version = "1.0.4" +requires_python = ">=3.8" +summary = "sphinxcontrib-applehelp is a Sphinx extension which outputs Apple help books" +groups = ["docs"] +marker = "python_version == \"3.8\"" +files = [ + {file = "sphinxcontrib-applehelp-1.0.4.tar.gz", hash = "sha256:828f867945bbe39817c210a1abfd1bc4895c8b73fcaade56d45357a348a07d7e"}, + {file = "sphinxcontrib_applehelp-1.0.4-py3-none-any.whl", hash = "sha256:29d341f67fb0f6f586b23ad80e072c8e6ad0b48417db2bde114a4c9746feb228"}, +] + +[[package]] +name = "sphinxcontrib-devhelp" +version = "1.0.2" +requires_python = ">=3.5" +summary = "sphinxcontrib-devhelp is a sphinx extension which outputs Devhelp document." +groups = ["docs"] +marker = "python_version == \"3.8\"" +files = [ + {file = "sphinxcontrib-devhelp-1.0.2.tar.gz", hash = "sha256:ff7f1afa7b9642e7060379360a67e9c41e8f3121f2ce9164266f61b9f4b338e4"}, + {file = "sphinxcontrib_devhelp-1.0.2-py2.py3-none-any.whl", hash = "sha256:8165223f9a335cc1af7ffe1ed31d2871f325254c0423bc0c4c7cd1c1e4734a2e"}, +] + +[[package]] +name = "sphinxcontrib-htmlhelp" +version = "2.0.1" +requires_python = ">=3.8" +summary = "sphinxcontrib-htmlhelp is a sphinx extension which renders HTML help files" +groups = ["docs"] +marker = "python_version == \"3.8\"" +files = [ + {file = "sphinxcontrib-htmlhelp-2.0.1.tar.gz", hash = "sha256:0cbdd302815330058422b98a113195c9249825d681e18f11e8b1f78a2f11efff"}, + {file = "sphinxcontrib_htmlhelp-2.0.1-py3-none-any.whl", hash = "sha256:c38cb46dccf316c79de6e5515e1770414b797162b23cd3d06e67020e1d2a6903"}, +] + +[[package]] +name = "sphinxcontrib-jquery" +version = "4.1" +requires_python = ">=2.7" +summary = "Extension to include jQuery on newer Sphinx releases" +groups = ["docs"] +marker = "python_version == \"3.8\"" +dependencies = [ + "Sphinx>=1.8", +] +files = [ + {file = "sphinxcontrib-jquery-4.1.tar.gz", hash = "sha256:1620739f04e36a2c779f1a131a2dfd49b2fd07351bf1968ced074365933abc7a"}, + {file = "sphinxcontrib_jquery-4.1-py2.py3-none-any.whl", hash = "sha256:f936030d7d0147dd026a4f2b5a57343d233f1fc7b363f68b3d4f1cb0993878ae"}, +] + +[[package]] +name = "sphinxcontrib-jsmath" +version = "1.0.1" +requires_python = ">=3.5" +summary = "A sphinx extension which renders display math in HTML via JavaScript" +groups = ["docs"] +marker = "python_version == \"3.8\"" +files = [ + {file = "sphinxcontrib-jsmath-1.0.1.tar.gz", hash = "sha256:a9925e4a4587247ed2191a22df5f6970656cb8ca2bd6284309578f2153e0c4b8"}, + {file = "sphinxcontrib_jsmath-1.0.1-py2.py3-none-any.whl", hash = "sha256:2ec2eaebfb78f3f2078e73666b1415417a116cc848b72e5172e596c871103178"}, +] + +[[package]] +name = "sphinxcontrib-qthelp" +version = "1.0.3" +requires_python = ">=3.5" +summary = "sphinxcontrib-qthelp is a sphinx extension which outputs QtHelp document." +groups = ["docs"] +marker = "python_version == \"3.8\"" +files = [ + {file = "sphinxcontrib-qthelp-1.0.3.tar.gz", hash = "sha256:4c33767ee058b70dba89a6fc5c1892c0d57a54be67ddd3e7875a18d14cba5a72"}, + {file = "sphinxcontrib_qthelp-1.0.3-py2.py3-none-any.whl", hash = "sha256:bd9fc24bcb748a8d51fd4ecaade681350aa63009a347a8c14e637895444dfab6"}, +] + +[[package]] +name = "sphinxcontrib-serializinghtml" +version = "1.1.5" +requires_python = ">=3.5" +summary = "sphinxcontrib-serializinghtml is a sphinx extension which outputs \"serialized\" HTML files (json and pickle)." +groups = ["docs"] +marker = "python_version == \"3.8\"" +files = [ + {file = "sphinxcontrib-serializinghtml-1.1.5.tar.gz", hash = "sha256:aa5f6de5dfdf809ef505c4895e51ef5c9eac17d0f287933eb49ec495280b6952"}, + {file = "sphinxcontrib_serializinghtml-1.1.5-py2.py3-none-any.whl", hash = "sha256:352a9a00ae864471d3a7ead8d7d79f5fc0b57e8b3f95e9867eb9eb28999b92fd"}, +] + +[[package]] +name = "stack-data" +version = "0.6.3" +summary = "Extract data from python stack frames and tracebacks for informative displays" +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "asttokens>=2.1.0", + "executing>=1.2.0", + "pure-eval", +] +files = [ + {file = "stack_data-0.6.3-py3-none-any.whl", hash = "sha256:d5558e0c25a4cb0853cddad3d77da9891a08cb85dd9f9f91b9f8cd66e511e695"}, + {file = "stack_data-0.6.3.tar.gz", hash = "sha256:836a778de4fec4dcd1dcd89ed8abff8a221f58308462e1c4aa2a3cf30148f0b9"}, +] + +[[package]] +name = "terminado" +version = "0.18.1" +requires_python = ">=3.8" +summary = "Tornado websocket backend for the Xterm.js Javascript terminal emulator library." +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "ptyprocess; os_name != \"nt\"", + "pywinpty>=1.1.0; os_name == \"nt\"", + "tornado>=6.1.0", +] +files = [ + {file = "terminado-0.18.1-py3-none-any.whl", hash = "sha256:a4468e1b37bb318f8a86514f65814e1afc977cf29b3992a4500d9dd305dcceb0"}, + {file = "terminado-0.18.1.tar.gz", hash = "sha256:de09f2c4b85de4765f7714688fff57d3e75bad1f909b589fde880460c753fd2e"}, +] + +[[package]] +name = "tinycss2" +version = "1.2.1" +requires_python = ">=3.7" +summary = "A tiny CSS parser" +groups = ["docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "webencodings>=0.4", +] +files = [ + {file = "tinycss2-1.2.1-py3-none-any.whl", hash = "sha256:2b80a96d41e7c3914b8cda8bc7f705a4d9c49275616e886103dd839dfc847847"}, + {file = "tinycss2-1.2.1.tar.gz", hash = "sha256:8cff3a8f066c2ec677c06dbc7b45619804a6938478d9d73c284b29d14ecb0627"}, +] + +[[package]] +name = "tomli" +version = "2.2.1" +requires_python = ">=3.8" +summary = "A lil' TOML parser" +groups = ["qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "tomli-2.2.1-py3-none-any.whl", hash = "sha256:cb55c73c5f4408779d0cf3eef9f762b9c9f147a77de7b258bef0a5628adc85cc"}, + {file = "tomli-2.2.1.tar.gz", hash = "sha256:cd45e1dc79c835ce60f7404ec8119f2eb06d38b1deba146f07ced3bbc44505ff"}, +] + +[[package]] +name = "tornado" +version = "6.4.2" +requires_python = ">=3.8" +summary = "Tornado is a Python web framework and asynchronous networking library, originally developed at FriendFeed." +groups = ["docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "tornado-6.4.2-cp38-abi3-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bca9eb02196e789c9cb5c3c7c0f04fb447dc2adffd95265b2c7223a8a615ccbf"}, + {file = "tornado-6.4.2.tar.gz", hash = "sha256:92bad5b4746e9879fd7bf1eb21dce4e3fc5128d71601f80005afa39237ad620b"}, +] + +[[package]] +name = "tox" +version = "4.24.1" +requires_python = ">=3.8" +summary = "tox is a generic virtualenv management and test command line tool" +groups = ["qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "cachetools>=5.5", + "chardet>=5.2", + "colorama>=0.4.6", + "filelock>=3.16.1", + "packaging>=24.2", + "platformdirs>=4.3.6", + "pluggy>=1.5", + "pyproject-api>=1.8", + "tomli>=2.1; python_version < \"3.11\"", + "typing-extensions>=4.12.2; python_version < \"3.11\"", + "virtualenv>=20.27.1", +] +files = [ + {file = "tox-4.24.1-py3-none-any.whl", hash = "sha256:57ba7df7d199002c6df8c2db9e6484f3de6ca8f42013c083ea2d4d1e5c6bdc75"}, + {file = "tox-4.24.1.tar.gz", hash = "sha256:083a720adbc6166fff0b7d1df9d154f9d00bfccb9403b8abf6bc0ee435d6a62e"}, +] + +[[package]] +name = "tqdm" +version = "4.66.5" +requires_python = ">=3.7" +summary = "Fast, Extensible Progress Meter" +groups = ["default"] +marker = "python_version == \"3.8\"" +dependencies = [ + "colorama; platform_system == \"Windows\"", +] +files = [ + {file = "tqdm-4.66.5-py3-none-any.whl", hash = "sha256:90279a3770753eafc9194a0364852159802111925aa30eb3f9d85b0e805ac7cd"}, + {file = "tqdm-4.66.5.tar.gz", hash = "sha256:e1020aef2e5096702d8a025ac7d16b1577279c9d63f8375b63083e9a5f0fcbad"}, +] + +[[package]] +name = "traitlets" +version = "5.14.3" +requires_python = ">=3.8" +summary = "Traitlets Python configuration system" +groups = ["docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "traitlets-5.14.3-py3-none-any.whl", hash = "sha256:b74e89e397b1ed28cc831db7aea759ba6640cb3de13090ca145426688ff1ac4f"}, + {file = "traitlets-5.14.3.tar.gz", hash = "sha256:9ed0579d3502c94b4b3732ac120375cda96f923114522847de4b3bb98b96b6b7"}, +] + +[[package]] +name = "trame" +version = "3.6.5" +summary = "Trame, a framework to build applications in plain Python" +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +dependencies = [ + "trame-client<4,>=3", + "trame-server<4,>=3", + "wslink>=2.1.3", +] +files = [ + {file = "trame-3.6.5-py3-none-any.whl", hash = "sha256:58b5be29287d275dbd2be15b4e453c788361f640253ad153ca99fb3eb28e00f3"}, + {file = "trame-3.6.5.tar.gz", hash = "sha256:fc26a7067f94377e01263facb4cd40b111d799d970b5fc8e2aecb52e60378959"}, +] + +[[package]] +name = "trame-client" +version = "3.2.5" +summary = "Internal client of trame" +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +files = [ + {file = "trame-client-3.2.5.tar.gz", hash = "sha256:6f81c2a78389f1962bec38a318b0de47f241dae7778b25dba75fa3ed4d58bd33"}, + {file = "trame_client-3.2.5-py3-none-any.whl", hash = "sha256:023e062175fef67d45a65ac7a367b0e3468f6746c4f8c7a7aa3fe8e82273c62a"}, +] + +[[package]] +name = "trame-server" +version = "3.1.2" +summary = "Internal server side implementation of trame" +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +dependencies = [ + "more-itertools", + "wslink<3,>=2", +] +files = [ + {file = "trame-server-3.1.2.tar.gz", hash = "sha256:03bdd81e0132fb55de7b493c7ebdc4c21f6b0003960bceb3adca258fc432211f"}, + {file = "trame_server-3.1.2-py3-none-any.whl", hash = "sha256:b43d11edfbca012ac34a724dc751b6ecfaecd7d636eaea4ab0650d2adc9e3771"}, +] + +[[package]] +name = "trame-vtk" +version = "2.8.10" +summary = "VTK widgets for trame" +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +dependencies = [ + "trame-client", +] +files = [ + {file = "trame-vtk-2.8.10.tar.gz", hash = "sha256:4d8e38f7c1d5be8eafc28254bd5bd5dc5d4b336a334b944fc9383c9624184b5e"}, + {file = "trame_vtk-2.8.10-py3-none-any.whl", hash = "sha256:0fe850d1358193c1d73c9af87715d7877210df53edf4e4d468ba396c0845765c"}, +] + +[[package]] +name = "trame-vuetify" +version = "2.7.1" +summary = "Vuetify widgets for trame" +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +dependencies = [ + "trame-client", +] +files = [ + {file = "trame-vuetify-2.7.1.tar.gz", hash = "sha256:48443910a3a53b9fa040e05b261fce9326fe95309b3798d49f0d6aec84cbfdf8"}, + {file = "trame_vuetify-2.7.1-py3-none-any.whl", hash = "sha256:c6bfe3be49ac8b7aa354e4e2c1d92f2c2e9680eea563f46146eef6968a66c2de"}, +] + +[[package]] +name = "types-python-dateutil" +version = "2.9.0.20240906" +requires_python = ">=3.8" +summary = "Typing stubs for python-dateutil" +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "types-python-dateutil-2.9.0.20240906.tar.gz", hash = "sha256:9706c3b68284c25adffc47319ecc7947e5bb86b3773f843c73906fd598bc176e"}, + {file = "types_python_dateutil-2.9.0.20240906-py3-none-any.whl", hash = "sha256:27c8cc2d058ccb14946eebcaaa503088f4f6dbc4fb6093d3d456a49aef2753f6"}, +] + +[[package]] +name = "typing-extensions" +version = "4.12.2" +requires_python = ">=3.8" +summary = "Backported and Experimental Type Hints for Python 3.8+" +groups = ["default", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "typing_extensions-4.12.2-py3-none-any.whl", hash = "sha256:04e5ca0351e0f3f85c6853954072df659d0d13fac324d0072316b67d7794700d"}, + {file = "typing_extensions-4.12.2.tar.gz", hash = "sha256:1a7ead55c7e559dd4dee8856e3a88b41225abfe1ce8df57b7c13915fe121ffb8"}, +] + +[[package]] +name = "tzdata" +version = "2024.1" +requires_python = ">=2" +summary = "Provider of IANA time zone data" +groups = ["default"] +marker = "python_version == \"3.8\"" +files = [ + {file = "tzdata-2024.1-py2.py3-none-any.whl", hash = "sha256:9068bc196136463f5245e51efda838afa15aaeca9903f49050dfa2679db4d252"}, + {file = "tzdata-2024.1.tar.gz", hash = "sha256:2674120f8d891909751c38abcdfd386ac0a5a1127954fbc332af6b5ceae07efd"}, +] + +[[package]] +name = "uri-template" +version = "1.3.0" +requires_python = ">=3.7" +summary = "RFC 6570 URI Template Processor" +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "uri-template-1.3.0.tar.gz", hash = "sha256:0e00f8eb65e18c7de20d595a14336e9f337ead580c70934141624b6d1ffdacc7"}, + {file = "uri_template-1.3.0-py3-none-any.whl", hash = "sha256:a44a133ea12d44a0c0f06d7d42a52d71282e77e2f937d8abd5655b8d56fc1363"}, +] + +[[package]] +name = "urllib3" +version = "2.2.2" +requires_python = ">=3.8" +summary = "HTTP library with thread-safe connection pooling, file post, and more." +groups = ["docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "urllib3-2.2.2-py3-none-any.whl", hash = "sha256:a448b2f64d686155468037e1ace9f2d2199776e17f0a46610480d311f73e3472"}, + {file = "urllib3-2.2.2.tar.gz", hash = "sha256:dd505485549a7a552833da5e6063639d0d177c04f23bc3864e41e5dc5f612168"}, +] + +[[package]] +name = "virtualenv" +version = "20.29.1" +requires_python = ">=3.8" +summary = "Virtual Python Environment builder" +groups = ["qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "distlib<1,>=0.3.7", + "filelock<4,>=3.12.2", + "importlib-metadata>=6.6; python_version < \"3.8\"", + "platformdirs<5,>=3.9.1", +] +files = [ + {file = "virtualenv-20.29.1-py3-none-any.whl", hash = "sha256:4e4cb403c0b0da39e13b46b1b2476e505cb0046b25f242bee80f62bf990b2779"}, + {file = "virtualenv-20.29.1.tar.gz", hash = "sha256:b8b8970138d32fb606192cb97f6cd4bb644fa486be9308fb9b63f81091b5dc35"}, +] + +[[package]] +name = "vtk" +version = "9.3.1" +summary = "VTK is an open-source toolkit for 3D computer graphics, image processing, and visualization" +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +dependencies = [ + "matplotlib>=2.0.0", +] +files = [ + {file = "vtk-9.3.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:eaf90d0a797b5b7ada3fd0100c072dd146e674a2ccd25411036a4aca676f9101"}, +] + +[[package]] +name = "wcwidth" +version = "0.2.13" +summary = "Measures the displayed width of unicode strings in a terminal" +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "backports-functools-lru-cache>=1.2.1; python_version < \"3.2\"", +] +files = [ + {file = "wcwidth-0.2.13-py2.py3-none-any.whl", hash = "sha256:3da69048e4540d84af32131829ff948f1e022c1c6bdb8d6102117aac784f6859"}, + {file = "wcwidth-0.2.13.tar.gz", hash = "sha256:72ea0c06399eb286d978fdedb6923a9eb47e1c486ce63e9b4e64fc18303972b5"}, +] + +[[package]] +name = "webcolors" +version = "24.8.0" +requires_python = ">=3.8" +summary = "A library for working with the color formats defined by HTML and CSS." +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "webcolors-24.8.0-py3-none-any.whl", hash = "sha256:fc4c3b59358ada164552084a8ebee637c221e4059267d0f8325b3b560f6c7f0a"}, + {file = "webcolors-24.8.0.tar.gz", hash = "sha256:08b07af286a01bcd30d583a7acadf629583d1f79bfef27dd2c2c5c263817277d"}, +] + +[[package]] +name = "webencodings" +version = "0.5.1" +summary = "Character encoding aliases for legacy web content" +groups = ["docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "webencodings-0.5.1-py2.py3-none-any.whl", hash = "sha256:a0af1213f3c2226497a97e2b3aa01a7e4bee4f403f95be16fc9acd2947514a78"}, + {file = "webencodings-0.5.1.tar.gz", hash = "sha256:b36a1c245f2d304965eb4e0a82848379241dc04b865afcc4aab16748587e1923"}, +] + +[[package]] +name = "websocket-client" +version = "1.8.0" +requires_python = ">=3.8" +summary = "WebSocket client for Python with low level API options" +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "websocket_client-1.8.0-py3-none-any.whl", hash = "sha256:17b44cc997f5c498e809b22cdf2d9c7a9e71c02c8cc2b6c56e7c2d1239bfa526"}, + {file = "websocket_client-1.8.0.tar.gz", hash = "sha256:3239df9f44da632f96012472805d40a23281a991027ce11d2f45a6f24ac4c3da"}, +] + +[[package]] +name = "widgetsnbextension" +version = "4.0.13" +requires_python = ">=3.7" +summary = "Jupyter interactive widgets for Jupyter Notebook" +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +files = [ + {file = "widgetsnbextension-4.0.13-py3-none-any.whl", hash = "sha256:74b2692e8500525cc38c2b877236ba51d34541e6385eeed5aec15a70f88a6c71"}, + {file = "widgetsnbextension-4.0.13.tar.gz", hash = "sha256:ffcb67bc9febd10234a362795f643927f4e0c05d9342c727b65d2384f8feacb6"}, +] + +[[package]] +name = "wslink" +version = "2.1.3" +summary = "Python/JavaScript library for communicating over WebSocket" +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +dependencies = [ + "aiohttp<4", + "msgpack<2,>=1", +] +files = [ + {file = "wslink-2.1.3-py3-none-any.whl", hash = "sha256:a4a3689a30dd108255560e2f56903003355f4e0f3f6e5f12033a6de108bba18a"}, + {file = "wslink-2.1.3.tar.gz", hash = "sha256:528d008f1a6110bc8141c32588e43b16ff438cedb80c5bb85e9ef92ae753c98e"}, +] + +[[package]] +name = "yarl" +version = "1.15.2" +requires_python = ">=3.8" +summary = "Yet another URL library" +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +dependencies = [ + "idna>=2.0", + "multidict>=4.0", + "propcache>=0.2.0", +] +files = [ + {file = "yarl-1.15.2-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9a13a07532e8e1c4a5a3afff0ca4553da23409fad65def1b71186fb867eeae8d"}, + {file = "yarl-1.15.2-py3-none-any.whl", hash = "sha256:0d3105efab7c5c091609abacad33afff33bdff0035bece164c98bcf5a85ef90a"}, + {file = "yarl-1.15.2.tar.gz", hash = "sha256:a39c36f4218a5bb668b4f06874d676d35a035ee668e6e7e3538835c703634b84"}, +] + +[[package]] +name = "zipp" +version = "3.20.1" +requires_python = ">=3.8" +summary = "Backport of pathlib-compatible object wrapper for zip files" +groups = ["default", "docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "zipp-3.20.1-py3-none-any.whl", hash = "sha256:9960cd8967c8f85a56f920d5d507274e74f9ff813a0ab8889a5b5be2daf44064"}, + {file = "zipp-3.20.1.tar.gz", hash = "sha256:c22b14cc4763c5a5b04134207736c107db42e9d3ef2d9779d465f5f1bcba572b"}, +] diff --git a/pdm-py38win.lock b/pdm-py38win.lock new file mode 100644 index 0000000..64c6579 --- /dev/null +++ b/pdm-py38win.lock @@ -0,0 +1,2925 @@ +# This file is @generated by PDM. +# It is not intended for manual editing. + +[metadata] +groups = ["default", "docs", "openpyxl", "pyvista", "qa"] +strategy = ["inherit_metadata"] +lock_version = "4.5.0" +content_hash = "sha256:22cd5aee3b297d0bb4e82486997918f7af7cd34c35252bce0aa0be1ee01bc0c1" + +[[metadata.targets]] +requires_python = "==3.8.*" +platform = "windows_amd64" + +[[package]] +name = "aiohappyeyeballs" +version = "2.4.0" +requires_python = ">=3.8" +summary = "Happy Eyeballs for asyncio" +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +files = [ + {file = "aiohappyeyeballs-2.4.0-py3-none-any.whl", hash = "sha256:7ce92076e249169a13c2f49320d1967425eaf1f407522d707d59cac7628d62bd"}, + {file = "aiohappyeyeballs-2.4.0.tar.gz", hash = "sha256:55a1714f084e63d49639800f95716da97a1f173d46a16dfcfda0016abb93b6b2"}, +] + +[[package]] +name = "aiohttp" +version = "3.10.11" +requires_python = ">=3.8" +summary = "Async http client/server framework (asyncio)" +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +dependencies = [ + "aiohappyeyeballs>=2.3.0", + "aiosignal>=1.1.2", + "async-timeout<6.0,>=4.0; python_version < \"3.11\"", + "attrs>=17.3.0", + "frozenlist>=1.1.1", + "multidict<7.0,>=4.5", + "yarl<2.0,>=1.12.0", +] +files = [ + {file = "aiohttp-3.10.11-cp38-cp38-win_amd64.whl", hash = "sha256:9c6e0ffd52c929f985c7258f83185d17c76d4275ad22e90aa29f38e211aacbec"}, + {file = "aiohttp-3.10.11.tar.gz", hash = "sha256:9dc2b8f3dcab2e39e0fa309c8da50c3b55e6f34ab25f1a71d3288f24924d33a7"}, +] + +[[package]] +name = "aiosignal" +version = "1.3.1" +requires_python = ">=3.7" +summary = "aiosignal: a list of registered asynchronous callbacks" +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +dependencies = [ + "frozenlist>=1.1.0", +] +files = [ + {file = "aiosignal-1.3.1-py3-none-any.whl", hash = "sha256:f8376fb07dd1e86a584e4fcdec80b36b7f81aac666ebc724e2c090300dd83b17"}, + {file = "aiosignal-1.3.1.tar.gz", hash = "sha256:54cd96e15e1649b75d6c87526a6ff0b6c1b0dd3459f43d9ca11d48c339b68cfc"}, +] + +[[package]] +name = "alabaster" +version = "0.7.13" +requires_python = ">=3.6" +summary = "A configurable sidebar-enabled Sphinx theme" +groups = ["docs"] +marker = "python_version == \"3.8\"" +files = [ + {file = "alabaster-0.7.13-py3-none-any.whl", hash = "sha256:1ee19aca801bbabb5ba3f5f258e4422dfa86f82f3e9cefb0859b283cdd7f62a3"}, + {file = "alabaster-0.7.13.tar.gz", hash = "sha256:a27a4a084d5e690e16e01e03ad2b2e552c61a65469419b907243193de1a84ae2"}, +] + +[[package]] +name = "annotated-types" +version = "0.7.0" +requires_python = ">=3.8" +summary = "Reusable constraint types to use with typing.Annotated" +groups = ["default"] +marker = "python_version == \"3.8\"" +dependencies = [ + "typing-extensions>=4.0.0; python_version < \"3.9\"", +] +files = [ + {file = "annotated_types-0.7.0-py3-none-any.whl", hash = "sha256:1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53"}, + {file = "annotated_types-0.7.0.tar.gz", hash = "sha256:aff07c09a53a08bc8cfccb9c85b05f1aa9a2a6f23728d790723543408344ce89"}, +] + +[[package]] +name = "anyio" +version = "4.4.0" +requires_python = ">=3.8" +summary = "High level compatibility layer for multiple asynchronous event loop implementations" +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "exceptiongroup>=1.0.2; python_version < \"3.11\"", + "idna>=2.8", + "sniffio>=1.1", + "typing-extensions>=4.1; python_version < \"3.11\"", +] +files = [ + {file = "anyio-4.4.0-py3-none-any.whl", hash = "sha256:c1b2d8f46a8a812513012e1107cb0e68c17159a7a594208005a57dc776e1bdc7"}, + {file = "anyio-4.4.0.tar.gz", hash = "sha256:5aadc6a1bbb7cdb0bede386cac5e2940f5e2ff3aa20277e991cf028e0585ce94"}, +] + +[[package]] +name = "argon2-cffi" +version = "23.1.0" +requires_python = ">=3.7" +summary = "Argon2 for Python" +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "argon2-cffi-bindings", + "typing-extensions; python_version < \"3.8\"", +] +files = [ + {file = "argon2_cffi-23.1.0-py3-none-any.whl", hash = "sha256:c670642b78ba29641818ab2e68bd4e6a78ba53b7eff7b4c3815ae16abf91c7ea"}, + {file = "argon2_cffi-23.1.0.tar.gz", hash = "sha256:879c3e79a2729ce768ebb7d36d4609e3a78a4ca2ec3a9f12286ca057e3d0db08"}, +] + +[[package]] +name = "argon2-cffi-bindings" +version = "21.2.0" +requires_python = ">=3.6" +summary = "Low-level CFFI bindings for Argon2" +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "cffi>=1.0.1", +] +files = [ + {file = "argon2-cffi-bindings-21.2.0.tar.gz", hash = "sha256:bb89ceffa6c791807d1305ceb77dbfacc5aa499891d2c55661c6459651fc39e3"}, + {file = "argon2_cffi_bindings-21.2.0-cp36-abi3-win_amd64.whl", hash = "sha256:b2ef1c30440dbbcba7a5dc3e319408b59676e2e039e2ae11a8775ecf482b192f"}, + {file = "argon2_cffi_bindings-21.2.0-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:5e00316dabdaea0b2dd82d141cc66889ced0cdcbfa599e8b471cf22c620c329a"}, +] + +[[package]] +name = "arrow" +version = "1.3.0" +requires_python = ">=3.8" +summary = "Better dates & times for Python" +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "python-dateutil>=2.7.0", + "types-python-dateutil>=2.8.10", +] +files = [ + {file = "arrow-1.3.0-py3-none-any.whl", hash = "sha256:c728b120ebc00eb84e01882a6f5e7927a53960aa990ce7dd2b10f39005a67f80"}, + {file = "arrow-1.3.0.tar.gz", hash = "sha256:d4540617648cb5f895730f1ad8c82a65f2dad0166f57b75f3ca54759c4d67a85"}, +] + +[[package]] +name = "asttokens" +version = "2.4.1" +summary = "Annotate AST trees with source code positions" +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "six>=1.12.0", + "typing; python_version < \"3.5\"", +] +files = [ + {file = "asttokens-2.4.1-py2.py3-none-any.whl", hash = "sha256:051ed49c3dcae8913ea7cd08e46a606dba30b79993209636c4875bc1d637bc24"}, + {file = "asttokens-2.4.1.tar.gz", hash = "sha256:b03869718ba9a6eb027e134bfdf69f38a236d681c83c160d510768af11254ba0"}, +] + +[[package]] +name = "async-lru" +version = "2.0.4" +requires_python = ">=3.8" +summary = "Simple LRU cache for asyncio" +groups = ["qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "typing-extensions>=4.0.0; python_version < \"3.11\"", +] +files = [ + {file = "async-lru-2.0.4.tar.gz", hash = "sha256:b8a59a5df60805ff63220b2a0c5b5393da5521b113cd5465a44eb037d81a5627"}, + {file = "async_lru-2.0.4-py3-none-any.whl", hash = "sha256:ff02944ce3c288c5be660c42dbcca0742b32c3b279d6dceda655190240b99224"}, +] + +[[package]] +name = "async-timeout" +version = "4.0.3" +requires_python = ">=3.7" +summary = "Timeout context manager for asyncio programs" +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +dependencies = [ + "typing-extensions>=3.6.5; python_version < \"3.8\"", +] +files = [ + {file = "async-timeout-4.0.3.tar.gz", hash = "sha256:4640d96be84d82d02ed59ea2b7105a0f7b33abe8703703cd0ab0bf87c427522f"}, + {file = "async_timeout-4.0.3-py3-none-any.whl", hash = "sha256:7405140ff1230c310e51dc27b3145b9092d659ce68ff733fb0cefe3ee42be028"}, +] + +[[package]] +name = "attrs" +version = "24.2.0" +requires_python = ">=3.7" +summary = "Classes Without Boilerplate" +groups = ["docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "importlib-metadata; python_version < \"3.8\"", +] +files = [ + {file = "attrs-24.2.0-py3-none-any.whl", hash = "sha256:81921eb96de3191c8258c199618104dd27ac608d9366f5e35d011eae1867ede2"}, + {file = "attrs-24.2.0.tar.gz", hash = "sha256:5cfb1b9148b5b086569baec03f20d7b6bf3bcacc9a42bebf87ffaaca362f6346"}, +] + +[[package]] +name = "babel" +version = "2.16.0" +requires_python = ">=3.8" +summary = "Internationalization utilities" +groups = ["docs", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "pytz>=2015.7; python_version < \"3.9\"", +] +files = [ + {file = "babel-2.16.0-py3-none-any.whl", hash = "sha256:368b5b98b37c06b7daf6696391c3240c938b37767d4584413e8438c5c435fa8b"}, + {file = "babel-2.16.0.tar.gz", hash = "sha256:d1f3554ca26605fe173f3de0c65f750f5a42f924499bf134de6423582298e316"}, +] + +[[package]] +name = "backcall" +version = "0.2.0" +summary = "Specifications for callback functions passed in to an API" +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "backcall-0.2.0-py2.py3-none-any.whl", hash = "sha256:fbbce6a29f263178a1f7915c1940bde0ec2b2a967566fe1c65c1dfb7422bd255"}, + {file = "backcall-0.2.0.tar.gz", hash = "sha256:5cbdbf27be5e7cfadb448baf0aa95508f91f2bbc6c6437cd9cd06e2a4c215e1e"}, +] + +[[package]] +name = "beautifulsoup4" +version = "4.12.3" +requires_python = ">=3.6.0" +summary = "Screen-scraping library" +groups = ["docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "soupsieve>1.2", +] +files = [ + {file = "beautifulsoup4-4.12.3-py3-none-any.whl", hash = "sha256:b80878c9f40111313e55da8ba20bdba06d8fa3969fc68304167741bbf9e082ed"}, + {file = "beautifulsoup4-4.12.3.tar.gz", hash = "sha256:74e3d1928edc070d21748185c46e3fb33490f22f52a3addee9aee0f4f7781051"}, +] + +[[package]] +name = "bleach" +version = "6.1.0" +requires_python = ">=3.8" +summary = "An easy safelist-based HTML-sanitizing tool." +groups = ["docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "six>=1.9.0", + "webencodings", +] +files = [ + {file = "bleach-6.1.0-py3-none-any.whl", hash = "sha256:3225f354cfc436b9789c66c4ee030194bee0568fbf9cbdad3bc8b5c26c5f12b6"}, + {file = "bleach-6.1.0.tar.gz", hash = "sha256:0a31f1837963c41d46bbf1331b8778e1308ea0791db03cc4e7357b97cf42a8fe"}, +] + +[[package]] +name = "bleach" +version = "6.1.0" +extras = ["css"] +requires_python = ">=3.8" +summary = "An easy safelist-based HTML-sanitizing tool." +groups = ["docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "bleach==6.1.0", + "tinycss2<1.3,>=1.1.0", +] +files = [ + {file = "bleach-6.1.0-py3-none-any.whl", hash = "sha256:3225f354cfc436b9789c66c4ee030194bee0568fbf9cbdad3bc8b5c26c5f12b6"}, + {file = "bleach-6.1.0.tar.gz", hash = "sha256:0a31f1837963c41d46bbf1331b8778e1308ea0791db03cc4e7357b97cf42a8fe"}, +] + +[[package]] +name = "cachetools" +version = "5.5.0" +requires_python = ">=3.7" +summary = "Extensible memoizing collections and decorators" +groups = ["qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "cachetools-5.5.0-py3-none-any.whl", hash = "sha256:02134e8439cdc2ffb62023ce1debca2944c3f289d66bb17ead3ab3dede74b292"}, + {file = "cachetools-5.5.0.tar.gz", hash = "sha256:2cc24fb4cbe39633fb7badd9db9ca6295d766d9c2995f245725a46715d050f2a"}, +] + +[[package]] +name = "certifi" +version = "2024.8.30" +requires_python = ">=3.6" +summary = "Python package for providing Mozilla's CA Bundle." +groups = ["docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "certifi-2024.8.30-py3-none-any.whl", hash = "sha256:922820b53db7a7257ffbda3f597266d435245903d80737e34f8a45ff3e3230d8"}, + {file = "certifi-2024.8.30.tar.gz", hash = "sha256:bec941d2aa8195e248a60b31ff9f0558284cf01a52591ceda73ea9afffd69fd9"}, +] + +[[package]] +name = "cffi" +version = "1.17.1" +requires_python = ">=3.8" +summary = "Foreign Function Interface for Python calling C code." +groups = ["docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "pycparser", +] +files = [ + {file = "cffi-1.17.1-cp38-cp38-win_amd64.whl", hash = "sha256:78122be759c3f8a014ce010908ae03364d00a1f81ab5c7f4a7a5120607ea56e1"}, + {file = "cffi-1.17.1.tar.gz", hash = "sha256:1c39c6016c32bc48dd54561950ebd6836e1670f2ae46128f67cf49e789c52824"}, +] + +[[package]] +name = "cfgv" +version = "3.4.0" +requires_python = ">=3.8" +summary = "Validate configuration and produce human readable error messages." +groups = ["qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "cfgv-3.4.0-py2.py3-none-any.whl", hash = "sha256:b7265b1f29fd3316bfcd2b330d63d024f2bfd8bcb8b0272f8e19a504856c48f9"}, + {file = "cfgv-3.4.0.tar.gz", hash = "sha256:e52591d4c5f5dead8e0f673fb16db7949d2cfb3f7da4582893288f0ded8fe560"}, +] + +[[package]] +name = "chardet" +version = "5.2.0" +requires_python = ">=3.7" +summary = "Universal encoding detector for Python 3" +groups = ["qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "chardet-5.2.0-py3-none-any.whl", hash = "sha256:e1cf59446890a00105fe7b7912492ea04b6e6f06d4b742b2c788469e34c82970"}, + {file = "chardet-5.2.0.tar.gz", hash = "sha256:1b3b6ff479a8c414bc3fa2c0852995695c4a026dcd6d0633b2dd092ca39c1cf7"}, +] + +[[package]] +name = "charset-normalizer" +version = "3.3.2" +requires_python = ">=3.7.0" +summary = "The Real First Universal Charset Detector. Open, modern and actively maintained alternative to Chardet." +groups = ["docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "charset-normalizer-3.3.2.tar.gz", hash = "sha256:f30c3cb33b24454a82faecaf01b19c18562b1e89558fb6c56de4d9118a032fd5"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-win_amd64.whl", hash = "sha256:eb8821e09e916165e160797a6c17edda0679379a4be5c716c260e836e122f54b"}, + {file = "charset_normalizer-3.3.2-py3-none-any.whl", hash = "sha256:3e4d1f6587322d2788836a99c69062fbb091331ec940e02d12d179c1d53e25fc"}, +] + +[[package]] +name = "cmocean" +version = "4.0.3" +requires_python = ">=3.8" +summary = "Colormaps for Oceanography" +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +dependencies = [ + "matplotlib", + "numpy", + "packaging", +] +files = [ + {file = "cmocean-4.0.3-py3-none-any.whl", hash = "sha256:f2fc1d5e349db122ee0c9eac80bba969aa92dd2806548fce58dc8bef962f309e"}, + {file = "cmocean-4.0.3.tar.gz", hash = "sha256:37868399fb5f41b4eac596e69803f9bfaea49946514dfb2e7f48886854250d7c"}, +] + +[[package]] +name = "colorama" +version = "0.4.6" +requires_python = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,!=3.6.*,>=2.7" +summary = "Cross-platform colored terminal text." +groups = ["default", "docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6"}, + {file = "colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44"}, +] + +[[package]] +name = "colorcet" +version = "3.1.0" +requires_python = ">=3.7" +summary = "Collection of perceptually uniform colormaps" +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +files = [ + {file = "colorcet-3.1.0-py3-none-any.whl", hash = "sha256:2a7d59cc8d0f7938eeedd08aad3152b5319b4ba3bcb7a612398cc17a384cb296"}, + {file = "colorcet-3.1.0.tar.gz", hash = "sha256:2921b3cd81a2288aaf2d63dbc0ce3c26dcd882e8c389cc505d6886bf7aa9a4eb"}, +] + +[[package]] +name = "comm" +version = "0.2.2" +requires_python = ">=3.8" +summary = "Jupyter Python Comm implementation, for usage in ipykernel, xeus-python etc." +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "traitlets>=4", +] +files = [ + {file = "comm-0.2.2-py3-none-any.whl", hash = "sha256:e6fb86cb70ff661ee8c9c14e7d36d6de3b4066f1441be4063df9c5009f0a64d3"}, + {file = "comm-0.2.2.tar.gz", hash = "sha256:3fd7a84065306e07bea1773df6eb8282de51ba82f77c72f9c85716ab11fe980e"}, +] + +[[package]] +name = "contourpy" +version = "1.1.1" +requires_python = ">=3.8" +summary = "Python library for calculating contours of 2D quadrilateral grids" +groups = ["default", "pyvista"] +marker = "python_version == \"3.8\"" +dependencies = [ + "numpy<2.0,>=1.16; python_version <= \"3.11\"", + "numpy<2.0,>=1.26.0rc1; python_version >= \"3.12\"", +] +files = [ + {file = "contourpy-1.1.1-cp38-cp38-win_amd64.whl", hash = "sha256:498e53573e8b94b1caeb9e62d7c2d053c263ebb6aa259c81050766beb50ff8d9"}, + {file = "contourpy-1.1.1-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:4f9147051cb8fdb29a51dc2482d792b3b23e50f8f57e3720ca2e3d438b7adf23"}, + {file = "contourpy-1.1.1.tar.gz", hash = "sha256:96ba37c2e24b7212a77da85004c38e7c4d155d3e72a45eeaf22c1f03f607e8ab"}, +] + +[[package]] +name = "coverage" +version = "7.6.1" +requires_python = ">=3.8" +summary = "Code coverage measurement for Python" +groups = ["qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "coverage-7.6.1-cp38-cp38-win_amd64.whl", hash = "sha256:3f1156e3e8f2872197af3840d8ad307a9dd18e615dc64d9ee41696f287c57ad8"}, + {file = "coverage-7.6.1-pp38.pp39.pp310-none-any.whl", hash = "sha256:e9a6e0eb86070e8ccaedfbd9d38fec54864f3125ab95419970575b42af7541df"}, + {file = "coverage-7.6.1.tar.gz", hash = "sha256:953510dfb7b12ab69d20135a0662397f077c59b1e6379a768e97c59d852ee51d"}, +] + +[[package]] +name = "coverage" +version = "7.6.1" +extras = ["toml"] +requires_python = ">=3.8" +summary = "Code coverage measurement for Python" +groups = ["qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "coverage==7.6.1", + "tomli; python_full_version <= \"3.11.0a6\"", +] +files = [ + {file = "coverage-7.6.1-cp38-cp38-win_amd64.whl", hash = "sha256:3f1156e3e8f2872197af3840d8ad307a9dd18e615dc64d9ee41696f287c57ad8"}, + {file = "coverage-7.6.1-pp38.pp39.pp310-none-any.whl", hash = "sha256:e9a6e0eb86070e8ccaedfbd9d38fec54864f3125ab95419970575b42af7541df"}, + {file = "coverage-7.6.1.tar.gz", hash = "sha256:953510dfb7b12ab69d20135a0662397f077c59b1e6379a768e97c59d852ee51d"}, +] + +[[package]] +name = "cycler" +version = "0.12.1" +requires_python = ">=3.8" +summary = "Composable style cycles" +groups = ["default", "pyvista"] +marker = "python_version == \"3.8\"" +files = [ + {file = "cycler-0.12.1-py3-none-any.whl", hash = "sha256:85cef7cff222d8644161529808465972e51340599459b8ac3ccbac5a854e0d30"}, + {file = "cycler-0.12.1.tar.gz", hash = "sha256:88bb128f02ba341da8ef447245a9e138fae777f6a23943da4540077d3601eb1c"}, +] + +[[package]] +name = "debugpy" +version = "1.8.5" +requires_python = ">=3.8" +summary = "An implementation of the Debug Adapter Protocol for Python" +groups = ["qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "debugpy-1.8.5-cp38-cp38-win_amd64.whl", hash = "sha256:a697beca97dad3780b89a7fb525d5e79f33821a8bc0c06faf1f1289e549743cf"}, + {file = "debugpy-1.8.5-py2.py3-none-any.whl", hash = "sha256:55919dce65b471eff25901acf82d328bbd5b833526b6c1364bd5133754777a44"}, + {file = "debugpy-1.8.5.zip", hash = "sha256:b2112cfeb34b4507399d298fe7023a16656fc553ed5246536060ca7bd0e668d0"}, +] + +[[package]] +name = "decorator" +version = "5.1.1" +requires_python = ">=3.5" +summary = "Decorators for Humans" +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "decorator-5.1.1-py3-none-any.whl", hash = "sha256:b8c3f85900b9dc423225913c5aace94729fe1fa9763b38939a95226f02d37186"}, + {file = "decorator-5.1.1.tar.gz", hash = "sha256:637996211036b6385ef91435e4fae22989472f9d571faba8927ba8253acbc330"}, +] + +[[package]] +name = "defusedxml" +version = "0.7.1" +requires_python = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*" +summary = "XML bomb protection for Python stdlib modules" +groups = ["docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "defusedxml-0.7.1-py2.py3-none-any.whl", hash = "sha256:a352e7e428770286cc899e2542b6cdaedb2b4953ff269a210103ec58f6198a61"}, + {file = "defusedxml-0.7.1.tar.gz", hash = "sha256:1bb3032db185915b62d7c6209c5a8792be6a32ab2fedacc84e01b52c51aa3e69"}, +] + +[[package]] +name = "distlib" +version = "0.3.8" +summary = "Distribution utilities" +groups = ["qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "distlib-0.3.8-py2.py3-none-any.whl", hash = "sha256:034db59a0b96f8ca18035f36290806a9a6e6bd9d1ff91e45a7f172eb17e51784"}, + {file = "distlib-0.3.8.tar.gz", hash = "sha256:1530ea13e350031b6312d8580ddb6b27a104275a31106523b8f123787f494f64"}, +] + +[[package]] +name = "docutils" +version = "0.20.1" +requires_python = ">=3.7" +summary = "Docutils -- Python Documentation Utilities" +groups = ["docs"] +marker = "python_version == \"3.8\"" +files = [ + {file = "docutils-0.20.1-py3-none-any.whl", hash = "sha256:96f387a2c5562db4476f09f13bbab2192e764cac08ebbf3a34a95d9b1e4a59d6"}, + {file = "docutils-0.20.1.tar.gz", hash = "sha256:f08a4e276c3a1583a86dce3e34aba3fe04d02bba2dd51ed16106244e8a923e3b"}, +] + +[[package]] +name = "et-xmlfile" +version = "1.1.0" +requires_python = ">=3.6" +summary = "An implementation of lxml.xmlfile for the standard library" +groups = ["openpyxl"] +marker = "python_version == \"3.8\"" +files = [ + {file = "et_xmlfile-1.1.0-py3-none-any.whl", hash = "sha256:a2ba85d1d6a74ef63837eed693bcb89c3f752169b0e3e7ae5b16ca5e1b3deada"}, + {file = "et_xmlfile-1.1.0.tar.gz", hash = "sha256:8eb9e2bc2f8c97e37a2dc85a09ecdcdec9d8a396530a6d5a33b30b9a92da0c5c"}, +] + +[[package]] +name = "exceptiongroup" +version = "1.2.2" +requires_python = ">=3.7" +summary = "Backport of PEP 654 (exception groups)" +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "exceptiongroup-1.2.2-py3-none-any.whl", hash = "sha256:3111b9d131c238bec2f8f516e123e14ba243563fb135d3fe885990585aa7795b"}, + {file = "exceptiongroup-1.2.2.tar.gz", hash = "sha256:47c2edf7c6738fafb49fd34290706d1a1a2f4d1c6df275526b62cbb4aa5393cc"}, +] + +[[package]] +name = "executing" +version = "2.1.0" +requires_python = ">=3.8" +summary = "Get the currently executing AST node of a frame, and other information" +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "executing-2.1.0-py2.py3-none-any.whl", hash = "sha256:8d63781349375b5ebccc3142f4b30350c0cd9c79f921cde38be2be4637e98eaf"}, + {file = "executing-2.1.0.tar.gz", hash = "sha256:8ea27ddd260da8150fa5a708269c4a10e76161e2496ec3e587da9e3c0fe4b9ab"}, +] + +[[package]] +name = "fastjsonschema" +version = "2.20.0" +summary = "Fastest Python implementation of JSON schema" +groups = ["docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "fastjsonschema-2.20.0-py3-none-any.whl", hash = "sha256:5875f0b0fa7a0043a91e93a9b8f793bcbbba9691e7fd83dca95c28ba26d21f0a"}, + {file = "fastjsonschema-2.20.0.tar.gz", hash = "sha256:3d48fc5300ee96f5d116f10fe6f28d938e6008f59a6a025c2649475b87f76a23"}, +] + +[[package]] +name = "filelock" +version = "3.16.1" +requires_python = ">=3.8" +summary = "A platform independent file lock." +groups = ["qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "filelock-3.16.1-py3-none-any.whl", hash = "sha256:2082e5703d51fbf98ea75855d9d5527e33d8ff23099bec374a134febee6946b0"}, + {file = "filelock-3.16.1.tar.gz", hash = "sha256:c249fbfcd5db47e5e2d6d62198e565475ee65e4831e2561c8e313fa7eb961435"}, +] + +[[package]] +name = "fonttools" +version = "4.53.1" +requires_python = ">=3.8" +summary = "Tools to manipulate font files" +groups = ["default", "pyvista"] +marker = "python_version == \"3.8\"" +files = [ + {file = "fonttools-4.53.1-cp38-cp38-win_amd64.whl", hash = "sha256:7b6b35e52ddc8fb0db562133894e6ef5b4e54e1283dff606fda3eed938c36fc8"}, + {file = "fonttools-4.53.1-py3-none-any.whl", hash = "sha256:f1f8758a2ad110bd6432203a344269f445a2907dc24ef6bccfd0ac4e14e0d71d"}, + {file = "fonttools-4.53.1.tar.gz", hash = "sha256:e128778a8e9bc11159ce5447f76766cefbd876f44bd79aff030287254e4752c4"}, +] + +[[package]] +name = "fqdn" +version = "1.5.1" +requires_python = ">=2.7, !=3.0, !=3.1, !=3.2, !=3.3, !=3.4, <4" +summary = "Validates fully-qualified domain names against RFC 1123, so that they are acceptable to modern bowsers" +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "cached-property>=1.3.0; python_version < \"3.8\"", +] +files = [ + {file = "fqdn-1.5.1-py3-none-any.whl", hash = "sha256:3a179af3761e4df6eb2e026ff9e1a3033d3587bf980a0b1b2e1e5d08d7358014"}, + {file = "fqdn-1.5.1.tar.gz", hash = "sha256:105ed3677e767fb5ca086a0c1f4bb66ebc3c100be518f0e0d755d9eae164d89f"}, +] + +[[package]] +name = "frozenlist" +version = "1.4.1" +requires_python = ">=3.8" +summary = "A list-like structure which implements collections.abc.MutableSequence" +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +files = [ + {file = "frozenlist-1.4.1-cp38-cp38-win_amd64.whl", hash = "sha256:5a7d70357e7cee13f470c7883a063aae5fe209a493c57d86eb7f5a6f910fae09"}, + {file = "frozenlist-1.4.1-py3-none-any.whl", hash = "sha256:04ced3e6a46b4cfffe20f9ae482818e34eba9b5fb0ce4056e4cc9b6e212d09b7"}, + {file = "frozenlist-1.4.1.tar.gz", hash = "sha256:c037a86e8513059a2613aaba4d817bb90b9d9b6b69aace3ce9c877e8c8ed402b"}, +] + +[[package]] +name = "ghp-import" +version = "2.1.0" +summary = "Copy your docs directly to the gh-pages branch." +groups = ["docs"] +marker = "python_version == \"3.8\"" +dependencies = [ + "python-dateutil>=2.8.1", +] +files = [ + {file = "ghp-import-2.1.0.tar.gz", hash = "sha256:9c535c4c61193c2df8871222567d7fd7e5014d835f97dc7b7439069e2413d343"}, + {file = "ghp_import-2.1.0-py3-none-any.whl", hash = "sha256:8337dd7b50877f163d4c0289bc1f1c7f127550241988d568c1db512c4324a619"}, +] + +[[package]] +name = "h11" +version = "0.14.0" +requires_python = ">=3.7" +summary = "A pure-Python, bring-your-own-I/O implementation of HTTP/1.1" +groups = ["qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "typing-extensions; python_version < \"3.8\"", +] +files = [ + {file = "h11-0.14.0-py3-none-any.whl", hash = "sha256:e3fe4ac4b851c468cc8363d500db52c2ead036020723024a109d37346efaa761"}, + {file = "h11-0.14.0.tar.gz", hash = "sha256:8f19fbbe99e72420ff35c00b27a34cb9937e902a8b810e2c88300c6f0a3b699d"}, +] + +[[package]] +name = "httpcore" +version = "1.0.5" +requires_python = ">=3.8" +summary = "A minimal low-level HTTP client." +groups = ["qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "certifi", + "h11<0.15,>=0.13", +] +files = [ + {file = "httpcore-1.0.5-py3-none-any.whl", hash = "sha256:421f18bac248b25d310f3cacd198d55b8e6125c107797b609ff9b7a6ba7991b5"}, + {file = "httpcore-1.0.5.tar.gz", hash = "sha256:34a38e2f9291467ee3b44e89dd52615370e152954ba21721378a87b2960f7a61"}, +] + +[[package]] +name = "httpx" +version = "0.27.2" +requires_python = ">=3.8" +summary = "The next generation HTTP client." +groups = ["qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "anyio", + "certifi", + "httpcore==1.*", + "idna", + "sniffio", +] +files = [ + {file = "httpx-0.27.2-py3-none-any.whl", hash = "sha256:7bb2708e112d8fdd7829cd4243970f0c223274051cb35ee80c03301ee29a3df0"}, + {file = "httpx-0.27.2.tar.gz", hash = "sha256:f7c2be1d2f3c3c3160d441802406b206c2b76f5947b11115e6df10c6c65e66c2"}, +] + +[[package]] +name = "identify" +version = "2.6.0" +requires_python = ">=3.8" +summary = "File identification library for Python" +groups = ["qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "identify-2.6.0-py2.py3-none-any.whl", hash = "sha256:e79ae4406387a9d300332b5fd366d8994f1525e8414984e1a59e058b2eda2dd0"}, + {file = "identify-2.6.0.tar.gz", hash = "sha256:cb171c685bdc31bcc4c1734698736a7d5b6c8bf2e0c15117f4d469c8640ae5cf"}, +] + +[[package]] +name = "idna" +version = "3.8" +requires_python = ">=3.6" +summary = "Internationalized Domain Names in Applications (IDNA)" +groups = ["docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "idna-3.8-py3-none-any.whl", hash = "sha256:050b4e5baadcd44d760cedbd2b8e639f2ff89bbc7a5730fcc662954303377aac"}, + {file = "idna-3.8.tar.gz", hash = "sha256:d838c2c0ed6fced7693d5e8ab8e734d5f8fda53a039c0164afb0b82e771e3603"}, +] + +[[package]] +name = "imageio" +version = "2.35.1" +requires_python = ">=3.8" +summary = "Library for reading and writing a wide range of image, video, scientific, and volumetric data formats." +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +dependencies = [ + "numpy", + "pillow>=8.3.2", +] +files = [ + {file = "imageio-2.35.1-py3-none-any.whl", hash = "sha256:6eb2e5244e7a16b85c10b5c2fe0f7bf961b40fcb9f1a9fd1bd1d2c2f8fb3cd65"}, + {file = "imageio-2.35.1.tar.gz", hash = "sha256:4952dfeef3c3947957f6d5dedb1f4ca31c6e509a476891062396834048aeed2a"}, +] + +[[package]] +name = "imagesize" +version = "1.4.1" +requires_python = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*" +summary = "Getting image size from png/jpeg/jpeg2000/gif file" +groups = ["docs"] +marker = "python_version == \"3.8\"" +files = [ + {file = "imagesize-1.4.1-py2.py3-none-any.whl", hash = "sha256:0d8d18d08f840c19d0ee7ca1fd82490fdc3729b7ac93f49870406ddde8ef8d8b"}, + {file = "imagesize-1.4.1.tar.gz", hash = "sha256:69150444affb9cb0d5cc5a92b3676f0b2fb7cd9ae39e947a5e11a36b4497cd4a"}, +] + +[[package]] +name = "importlib-metadata" +version = "8.5.0" +requires_python = ">=3.8" +summary = "Read metadata from Python packages" +groups = ["docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "typing-extensions>=3.6.4; python_version < \"3.8\"", + "zipp>=3.20", +] +files = [ + {file = "importlib_metadata-8.5.0-py3-none-any.whl", hash = "sha256:45e54197d28b7a7f1559e60b95e7c567032b602131fbd588f1497f47880aa68b"}, + {file = "importlib_metadata-8.5.0.tar.gz", hash = "sha256:71522656f0abace1d072b9e5481a48f07c138e00f079c38c8f883823f9c26bd7"}, +] + +[[package]] +name = "importlib-resources" +version = "6.4.5" +requires_python = ">=3.8" +summary = "Read resources from Python packages" +groups = ["default", "docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "zipp>=3.1.0; python_version < \"3.10\"", +] +files = [ + {file = "importlib_resources-6.4.5-py3-none-any.whl", hash = "sha256:ac29d5f956f01d5e4bb63102a5a19957f1b9175e45649977264a1416783bb717"}, + {file = "importlib_resources-6.4.5.tar.gz", hash = "sha256:980862a1d16c9e147a59603677fa2aa5fd82b87f223b6cb870695bcfce830065"}, +] + +[[package]] +name = "iniconfig" +version = "2.0.0" +requires_python = ">=3.7" +summary = "brain-dead simple config-ini parsing" +groups = ["qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "iniconfig-2.0.0-py3-none-any.whl", hash = "sha256:b6a85871a79d2e3b22d2d1b94ac2824226a63c6b741c88f7ae975f18b6778374"}, + {file = "iniconfig-2.0.0.tar.gz", hash = "sha256:2d91e135bf72d31a410b17c16da610a82cb55f6b0477d1a902134b24a455b8b3"}, +] + +[[package]] +name = "ipdb" +version = "0.13.13" +requires_python = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*" +summary = "IPython-enabled pdb" +groups = ["qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "decorator; python_version == \"3.5\"", + "decorator; python_version == \"3.6\"", + "decorator; python_version > \"3.6\" and python_version < \"3.11\"", + "decorator; python_version >= \"3.11\"", + "decorator<5.0.0; python_version == \"2.7\"", + "decorator<5.0.0; python_version == \"3.4\"", + "ipython<6.0.0,>=5.1.0; python_version == \"2.7\"", + "ipython<7.0.0,>=6.0.0; python_version == \"3.4\"", + "ipython<7.10.0,>=7.0.0; python_version == \"3.5\"", + "ipython<7.17.0,>=7.16.3; python_version == \"3.6\"", + "ipython>=7.31.1; python_version > \"3.6\" and python_version < \"3.11\"", + "ipython>=7.31.1; python_version >= \"3.11\"", + "pathlib; python_version == \"2.7\"", + "toml>=0.10.2; python_version == \"2.7\"", + "toml>=0.10.2; python_version == \"3.4\"", + "toml>=0.10.2; python_version == \"3.5\"", + "tomli; python_version == \"3.6\"", + "tomli; python_version > \"3.6\" and python_version < \"3.11\"", +] +files = [ + {file = "ipdb-0.13.13-py3-none-any.whl", hash = "sha256:45529994741c4ab6d2388bfa5d7b725c2cf7fe9deffabdb8a6113aa5ed449ed4"}, + {file = "ipdb-0.13.13.tar.gz", hash = "sha256:e3ac6018ef05126d442af680aad863006ec19d02290561ac88b8b1c0b0cfc726"}, +] + +[[package]] +name = "ipykernel" +version = "6.29.5" +requires_python = ">=3.8" +summary = "IPython Kernel for Jupyter" +groups = ["qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "appnope; platform_system == \"Darwin\"", + "comm>=0.1.1", + "debugpy>=1.6.5", + "ipython>=7.23.1", + "jupyter-client>=6.1.12", + "jupyter-core!=5.0.*,>=4.12", + "matplotlib-inline>=0.1", + "nest-asyncio", + "packaging", + "psutil", + "pyzmq>=24", + "tornado>=6.1", + "traitlets>=5.4.0", +] +files = [ + {file = "ipykernel-6.29.5-py3-none-any.whl", hash = "sha256:afdb66ba5aa354b09b91379bac28ae4afebbb30e8b39510c9690afb7a10421b5"}, + {file = "ipykernel-6.29.5.tar.gz", hash = "sha256:f093a22c4a40f8828f8e330a9c297cb93dcab13bd9678ded6de8e5cf81c56215"}, +] + +[[package]] +name = "ipython" +version = "8.12.3" +requires_python = ">=3.8" +summary = "IPython: Productive Interactive Computing" +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "appnope; sys_platform == \"darwin\"", + "backcall", + "colorama; sys_platform == \"win32\"", + "decorator", + "jedi>=0.16", + "matplotlib-inline", + "pexpect>4.3; sys_platform != \"win32\"", + "pickleshare", + "prompt-toolkit!=3.0.37,<3.1.0,>=3.0.30", + "pygments>=2.4.0", + "stack-data", + "traitlets>=5", + "typing-extensions; python_version < \"3.10\"", +] +files = [ + {file = "ipython-8.12.3-py3-none-any.whl", hash = "sha256:b0340d46a933d27c657b211a329d0be23793c36595acf9e6ef4164bc01a1804c"}, + {file = "ipython-8.12.3.tar.gz", hash = "sha256:3910c4b54543c2ad73d06579aa771041b7d5707b033bd488669b4cf544e3b363"}, +] + +[[package]] +name = "ipywidgets" +version = "8.1.5" +requires_python = ">=3.7" +summary = "Jupyter interactive widgets" +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +dependencies = [ + "comm>=0.1.3", + "ipython>=6.1.0", + "jupyterlab-widgets~=3.0.12", + "traitlets>=4.3.1", + "widgetsnbextension~=4.0.12", +] +files = [ + {file = "ipywidgets-8.1.5-py3-none-any.whl", hash = "sha256:3290f526f87ae6e77655555baba4f36681c555b8bdbbff430b70e52c34c86245"}, + {file = "ipywidgets-8.1.5.tar.gz", hash = "sha256:870e43b1a35656a80c18c9503bbf2d16802db1cb487eec6fab27d683381dde17"}, +] + +[[package]] +name = "isoduration" +version = "20.11.0" +requires_python = ">=3.7" +summary = "Operations with ISO 8601 durations" +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "arrow>=0.15.0", +] +files = [ + {file = "isoduration-20.11.0-py3-none-any.whl", hash = "sha256:b2904c2a4228c3d44f409c8ae8e2370eb21a26f7ac2ec5446df141dde3452042"}, + {file = "isoduration-20.11.0.tar.gz", hash = "sha256:ac2f9015137935279eac671f94f89eb00584f940f5dc49462a0c4ee692ba1bd9"}, +] + +[[package]] +name = "jedi" +version = "0.19.1" +requires_python = ">=3.6" +summary = "An autocompletion tool for Python that can be used for text editors." +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "parso<0.9.0,>=0.8.3", +] +files = [ + {file = "jedi-0.19.1-py2.py3-none-any.whl", hash = "sha256:e983c654fe5c02867aef4cdfce5a2fbb4a50adc0af145f70504238f18ef5e7e0"}, + {file = "jedi-0.19.1.tar.gz", hash = "sha256:cf0496f3651bc65d7174ac1b7d043eff454892c708a87d1b683e57b569927ffd"}, +] + +[[package]] +name = "jinja2" +version = "3.1.5" +requires_python = ">=3.7" +summary = "A very fast and expressive template engine." +groups = ["docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "MarkupSafe>=2.0", +] +files = [ + {file = "jinja2-3.1.5-py3-none-any.whl", hash = "sha256:aba0f4dc9ed8013c424088f68a5c226f7d6097ed89b246d7749c2ec4175c6adb"}, + {file = "jinja2-3.1.5.tar.gz", hash = "sha256:8fefff8dc3034e27bb80d67c671eb8a9bc424c0ef4c0826edbff304cceff43bb"}, +] + +[[package]] +name = "json5" +version = "0.9.25" +requires_python = ">=3.8" +summary = "A Python implementation of the JSON5 data format." +groups = ["qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "json5-0.9.25-py3-none-any.whl", hash = "sha256:34ed7d834b1341a86987ed52f3f76cd8ee184394906b6e22a1e0deb9ab294e8f"}, + {file = "json5-0.9.25.tar.gz", hash = "sha256:548e41b9be043f9426776f05df8635a00fe06104ea51ed24b67f908856e151ae"}, +] + +[[package]] +name = "jsonpointer" +version = "3.0.0" +requires_python = ">=3.7" +summary = "Identify specific nodes in a JSON document (RFC 6901) " +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "jsonpointer-3.0.0-py2.py3-none-any.whl", hash = "sha256:13e088adc14fca8b6aa8177c044e12701e6ad4b28ff10e65f2267a90109c9942"}, + {file = "jsonpointer-3.0.0.tar.gz", hash = "sha256:2b2d729f2091522d61c3b31f82e11870f60b68f43fbc705cb76bf4b832af59ef"}, +] + +[[package]] +name = "jsonschema" +version = "4.23.0" +requires_python = ">=3.8" +summary = "An implementation of JSON Schema validation for Python" +groups = ["docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "attrs>=22.2.0", + "importlib-resources>=1.4.0; python_version < \"3.9\"", + "jsonschema-specifications>=2023.03.6", + "pkgutil-resolve-name>=1.3.10; python_version < \"3.9\"", + "referencing>=0.28.4", + "rpds-py>=0.7.1", +] +files = [ + {file = "jsonschema-4.23.0-py3-none-any.whl", hash = "sha256:fbadb6f8b144a8f8cf9f0b89ba94501d143e50411a1278633f56a7acf7fd5566"}, + {file = "jsonschema-4.23.0.tar.gz", hash = "sha256:d71497fef26351a33265337fa77ffeb82423f3ea21283cd9467bb03999266bc4"}, +] + +[[package]] +name = "jsonschema-specifications" +version = "2023.12.1" +requires_python = ">=3.8" +summary = "The JSON Schema meta-schemas and vocabularies, exposed as a Registry" +groups = ["docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "importlib-resources>=1.4.0; python_version < \"3.9\"", + "referencing>=0.31.0", +] +files = [ + {file = "jsonschema_specifications-2023.12.1-py3-none-any.whl", hash = "sha256:87e4fdf3a94858b8a2ba2778d9ba57d8a9cafca7c7489c46ba0d30a8bc6a9c3c"}, + {file = "jsonschema_specifications-2023.12.1.tar.gz", hash = "sha256:48a76787b3e70f5ed53f1160d2b81f586e4ca6d1548c5de7085d1682674764cc"}, +] + +[[package]] +name = "jsonschema" +version = "4.23.0" +extras = ["format-nongpl"] +requires_python = ">=3.8" +summary = "An implementation of JSON Schema validation for Python" +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "fqdn", + "idna", + "isoduration", + "jsonpointer>1.13", + "jsonschema==4.23.0", + "rfc3339-validator", + "rfc3986-validator>0.1.0", + "uri-template", + "webcolors>=24.6.0", +] +files = [ + {file = "jsonschema-4.23.0-py3-none-any.whl", hash = "sha256:fbadb6f8b144a8f8cf9f0b89ba94501d143e50411a1278633f56a7acf7fd5566"}, + {file = "jsonschema-4.23.0.tar.gz", hash = "sha256:d71497fef26351a33265337fa77ffeb82423f3ea21283cd9467bb03999266bc4"}, +] + +[[package]] +name = "jupyter-client" +version = "8.6.3" +requires_python = ">=3.8" +summary = "Jupyter protocol implementation and client libraries" +groups = ["docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "importlib-metadata>=4.8.3; python_version < \"3.10\"", + "jupyter-core!=5.0.*,>=4.12", + "python-dateutil>=2.8.2", + "pyzmq>=23.0", + "tornado>=6.2", + "traitlets>=5.3", +] +files = [ + {file = "jupyter_client-8.6.3-py3-none-any.whl", hash = "sha256:e8a19cc986cc45905ac3362915f410f3af85424b4c0905e94fa5f2cb08e8f23f"}, + {file = "jupyter_client-8.6.3.tar.gz", hash = "sha256:35b3a0947c4a6e9d589eb97d7d4cd5e90f910ee73101611f01283732bd6d9419"}, +] + +[[package]] +name = "jupyter-core" +version = "5.7.2" +requires_python = ">=3.8" +summary = "Jupyter core package. A base package on which Jupyter projects rely." +groups = ["docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "platformdirs>=2.5", + "pywin32>=300; sys_platform == \"win32\" and platform_python_implementation != \"PyPy\"", + "traitlets>=5.3", +] +files = [ + {file = "jupyter_core-5.7.2-py3-none-any.whl", hash = "sha256:4f7315d2f6b4bcf2e3e7cb6e46772eba760ae459cd1f59d29eb57b0a01bd7409"}, + {file = "jupyter_core-5.7.2.tar.gz", hash = "sha256:aa5f8d32bbf6b431ac830496da7392035d6f61b4f54872f15c4bd2a9c3f536d9"}, +] + +[[package]] +name = "jupyter-events" +version = "0.10.0" +requires_python = ">=3.8" +summary = "Jupyter Event System library" +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "jsonschema[format-nongpl]>=4.18.0", + "python-json-logger>=2.0.4", + "pyyaml>=5.3", + "referencing", + "rfc3339-validator", + "rfc3986-validator>=0.1.1", + "traitlets>=5.3", +] +files = [ + {file = "jupyter_events-0.10.0-py3-none-any.whl", hash = "sha256:4b72130875e59d57716d327ea70d3ebc3af1944d3717e5a498b8a06c6c159960"}, + {file = "jupyter_events-0.10.0.tar.gz", hash = "sha256:670b8229d3cc882ec782144ed22e0d29e1c2d639263f92ca8383e66682845e22"}, +] + +[[package]] +name = "jupyter-lsp" +version = "2.2.5" +requires_python = ">=3.8" +summary = "Multi-Language Server WebSocket proxy for Jupyter Notebook/Lab server" +groups = ["qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "importlib-metadata>=4.8.3; python_version < \"3.10\"", + "jupyter-server>=1.1.2", +] +files = [ + {file = "jupyter-lsp-2.2.5.tar.gz", hash = "sha256:793147a05ad446f809fd53ef1cd19a9f5256fd0a2d6b7ce943a982cb4f545001"}, + {file = "jupyter_lsp-2.2.5-py3-none-any.whl", hash = "sha256:45fbddbd505f3fbfb0b6cb2f1bc5e15e83ab7c79cd6e89416b248cb3c00c11da"}, +] + +[[package]] +name = "jupyter-server" +version = "2.14.2" +requires_python = ">=3.8" +summary = "The backend—i.e. core services, APIs, and REST endpoints—to Jupyter web applications." +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "anyio>=3.1.0", + "argon2-cffi>=21.1", + "jinja2>=3.0.3", + "jupyter-client>=7.4.4", + "jupyter-core!=5.0.*,>=4.12", + "jupyter-events>=0.9.0", + "jupyter-server-terminals>=0.4.4", + "nbconvert>=6.4.4", + "nbformat>=5.3.0", + "overrides>=5.0", + "packaging>=22.0", + "prometheus-client>=0.9", + "pywinpty>=2.0.1; os_name == \"nt\"", + "pyzmq>=24", + "send2trash>=1.8.2", + "terminado>=0.8.3", + "tornado>=6.2.0", + "traitlets>=5.6.0", + "websocket-client>=1.7", +] +files = [ + {file = "jupyter_server-2.14.2-py3-none-any.whl", hash = "sha256:47ff506127c2f7851a17bf4713434208fc490955d0e8632e95014a9a9afbeefd"}, + {file = "jupyter_server-2.14.2.tar.gz", hash = "sha256:66095021aa9638ced276c248b1d81862e4c50f292d575920bbe960de1c56b12b"}, +] + +[[package]] +name = "jupyter-server-proxy" +version = "4.4.0" +requires_python = ">=3.8" +summary = "A Jupyter server extension to run additional processes and proxy to them that comes bundled JupyterLab extension to launch pre-defined processes." +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +dependencies = [ + "aiohttp", + "importlib-metadata>=4.8.3; python_version < \"3.10\"", + "jupyter-server>=1.24.0", + "simpervisor>=1.0.0", + "tornado>=6.1.0", + "traitlets>=5.1.0", +] +files = [ + {file = "jupyter_server_proxy-4.4.0-py3-none-any.whl", hash = "sha256:707b5c84810bb8863d50f6c6d50a386fec216149e11802b7d4c451b54a63a9a6"}, + {file = "jupyter_server_proxy-4.4.0.tar.gz", hash = "sha256:e5732eb9c810c0caa997f90a2f15f7d09af638e7eea9c67eb5c43e9c1f0e1157"}, +] + +[[package]] +name = "jupyter-server-terminals" +version = "0.5.3" +requires_python = ">=3.8" +summary = "A Jupyter Server Extension Providing Terminals." +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "pywinpty>=2.0.3; os_name == \"nt\"", + "terminado>=0.8.3", +] +files = [ + {file = "jupyter_server_terminals-0.5.3-py3-none-any.whl", hash = "sha256:41ee0d7dc0ebf2809c668e0fc726dfaf258fcd3e769568996ca731b6194ae9aa"}, + {file = "jupyter_server_terminals-0.5.3.tar.gz", hash = "sha256:5ae0295167220e9ace0edcfdb212afd2b01ee8d179fe6f23c899590e9b8a5269"}, +] + +[[package]] +name = "jupyterlab" +version = "4.3.5" +requires_python = ">=3.8" +summary = "JupyterLab computational environment" +groups = ["qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "async-lru>=1.0.0", + "httpx>=0.25.0", + "importlib-metadata>=4.8.3; python_version < \"3.10\"", + "importlib-resources>=1.4; python_version < \"3.9\"", + "ipykernel>=6.5.0", + "jinja2>=3.0.3", + "jupyter-core", + "jupyter-lsp>=2.0.0", + "jupyter-server<3,>=2.4.0", + "jupyterlab-server<3,>=2.27.1", + "notebook-shim>=0.2", + "packaging", + "setuptools>=40.8.0", + "tomli>=1.2.2; python_version < \"3.11\"", + "tornado>=6.2.0", + "traitlets", +] +files = [ + {file = "jupyterlab-4.3.5-py3-none-any.whl", hash = "sha256:571bbdee20e4c5321ab5195bc41cf92a75a5cff886be5e57ce78dfa37a5e9fdb"}, + {file = "jupyterlab-4.3.5.tar.gz", hash = "sha256:c779bf72ced007d7d29d5bcef128e7fdda96ea69299e19b04a43635a7d641f9d"}, +] + +[[package]] +name = "jupyterlab-pygments" +version = "0.3.0" +requires_python = ">=3.8" +summary = "Pygments theme using JupyterLab CSS variables" +groups = ["docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "jupyterlab_pygments-0.3.0-py3-none-any.whl", hash = "sha256:841a89020971da1d8693f1a99997aefc5dc424bb1b251fd6322462a1b8842780"}, + {file = "jupyterlab_pygments-0.3.0.tar.gz", hash = "sha256:721aca4d9029252b11cfa9d185e5b5af4d54772bb8072f9b7036f4170054d35d"}, +] + +[[package]] +name = "jupyterlab-server" +version = "2.27.3" +requires_python = ">=3.8" +summary = "A set of server components for JupyterLab and JupyterLab like applications." +groups = ["qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "babel>=2.10", + "importlib-metadata>=4.8.3; python_version < \"3.10\"", + "jinja2>=3.0.3", + "json5>=0.9.0", + "jsonschema>=4.18.0", + "jupyter-server<3,>=1.21", + "packaging>=21.3", + "requests>=2.31", +] +files = [ + {file = "jupyterlab_server-2.27.3-py3-none-any.whl", hash = "sha256:e697488f66c3db49df675158a77b3b017520d772c6e1548c7d9bcc5df7944ee4"}, + {file = "jupyterlab_server-2.27.3.tar.gz", hash = "sha256:eb36caca59e74471988f0ae25c77945610b887f777255aa21f8065def9e51ed4"}, +] + +[[package]] +name = "jupyterlab-widgets" +version = "3.0.13" +requires_python = ">=3.7" +summary = "Jupyter interactive widgets for JupyterLab" +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +files = [ + {file = "jupyterlab_widgets-3.0.13-py3-none-any.whl", hash = "sha256:e3cda2c233ce144192f1e29914ad522b2f4c40e77214b0cc97377ca3d323db54"}, + {file = "jupyterlab_widgets-3.0.13.tar.gz", hash = "sha256:a2966d385328c1942b683a8cd96b89b8dd82c8b8f81dda902bb2bc06d46f5bed"}, +] + +[[package]] +name = "kiwisolver" +version = "1.4.7" +requires_python = ">=3.8" +summary = "A fast implementation of the Cassowary constraint solver" +groups = ["default", "pyvista"] +marker = "python_version == \"3.8\"" +files = [ + {file = "kiwisolver-1.4.7-cp38-cp38-win_amd64.whl", hash = "sha256:d83db7cde68459fc803052a55ace60bea2bae361fc3b7a6d5da07e11954e4b09"}, + {file = "kiwisolver-1.4.7-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:ac542bf38a8a4be2dc6b15248d36315ccc65f0743f7b1a76688ffb6b5129a5c2"}, + {file = "kiwisolver-1.4.7.tar.gz", hash = "sha256:9893ff81bd7107f7b685d3017cc6583daadb4fc26e4a888350df530e41980a60"}, +] + +[[package]] +name = "markdown-it-py" +version = "3.0.0" +requires_python = ">=3.8" +summary = "Python port of markdown-it. Markdown parsing, done right!" +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +dependencies = [ + "mdurl~=0.1", +] +files = [ + {file = "markdown-it-py-3.0.0.tar.gz", hash = "sha256:e3f60a94fa066dc52ec76661e37c851cb232d92f9886b15cb560aaada2df8feb"}, + {file = "markdown_it_py-3.0.0-py3-none-any.whl", hash = "sha256:355216845c60bd96232cd8d8c40e8f9765cc86f46880e43a8fd22dc1a1a8cab1"}, +] + +[[package]] +name = "markupsafe" +version = "2.1.5" +requires_python = ">=3.7" +summary = "Safely add untrusted strings to HTML/XML markup." +groups = ["docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "MarkupSafe-2.1.5-cp38-cp38-win_amd64.whl", hash = "sha256:619bc166c4f2de5caa5a633b8b7326fbe98e0ccbfacabd87268a2b15ff73a029"}, + {file = "MarkupSafe-2.1.5.tar.gz", hash = "sha256:d283d37a890ba4c1ae73ffadf8046435c76e7bc2247bbb63c00bd1a709c6544b"}, +] + +[[package]] +name = "matplotlib" +version = "3.7.5" +requires_python = ">=3.8" +summary = "Python plotting package" +groups = ["default", "pyvista"] +marker = "python_version == \"3.8\"" +dependencies = [ + "contourpy>=1.0.1", + "cycler>=0.10", + "fonttools>=4.22.0", + "importlib-resources>=3.2.0; python_version < \"3.10\"", + "kiwisolver>=1.0.1", + "numpy<2,>=1.20", + "packaging>=20.0", + "pillow>=6.2.0", + "pyparsing>=2.3.1", + "python-dateutil>=2.7", +] +files = [ + {file = "matplotlib-3.7.5-cp38-cp38-win_amd64.whl", hash = "sha256:f0b60993ed3488b4532ec6b697059897891927cbfc2b8d458a891b60ec03d9d7"}, + {file = "matplotlib-3.7.5-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:20da7924a08306a861b3f2d1da0d1aa9a6678e480cf8eacffe18b565af2813e7"}, + {file = "matplotlib-3.7.5.tar.gz", hash = "sha256:1e5c971558ebc811aa07f54c7b7c677d78aa518ef4c390e14673a09e0860184a"}, +] + +[[package]] +name = "matplotlib-inline" +version = "0.1.7" +requires_python = ">=3.8" +summary = "Inline Matplotlib backend for Jupyter" +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "traitlets", +] +files = [ + {file = "matplotlib_inline-0.1.7-py3-none-any.whl", hash = "sha256:df192d39a4ff8f21b1895d72e6a13f5fcc5099f00fa84384e0ea28c2cc0653ca"}, + {file = "matplotlib_inline-0.1.7.tar.gz", hash = "sha256:8423b23ec666be3d16e16b60bdd8ac4e86e840ebd1dd11a30b9f117f2fa0ab90"}, +] + +[[package]] +name = "mdurl" +version = "0.1.2" +requires_python = ">=3.7" +summary = "Markdown URL utilities" +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +files = [ + {file = "mdurl-0.1.2-py3-none-any.whl", hash = "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8"}, + {file = "mdurl-0.1.2.tar.gz", hash = "sha256:bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba"}, +] + +[[package]] +name = "meshio" +version = "5.3.5" +requires_python = ">=3.8" +summary = "I/O for many mesh formats" +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +dependencies = [ + "importlib-metadata; python_version < \"3.8\"", + "numpy>=1.20.0", + "rich", +] +files = [ + {file = "meshio-5.3.5-py3-none-any.whl", hash = "sha256:0736c6e34ecc768f62f2cde5d8233a3529512a9399b25c68ea2ca0d5900cdc10"}, + {file = "meshio-5.3.5.tar.gz", hash = "sha256:f21f01abd9f29ba06ea119304b3d39e610421cfe93b9dd23362834919f87586d"}, +] + +[[package]] +name = "mistune" +version = "3.0.2" +requires_python = ">=3.7" +summary = "A sane and fast Markdown parser with useful plugins and renderers" +groups = ["docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "mistune-3.0.2-py3-none-any.whl", hash = "sha256:71481854c30fdbc938963d3605b72501f5c10a9320ecd412c121c163a1c7d205"}, + {file = "mistune-3.0.2.tar.gz", hash = "sha256:fc7f93ded930c92394ef2cb6f04a8aabab4117a91449e72dcc8dfa646a508be8"}, +] + +[[package]] +name = "more-itertools" +version = "10.5.0" +requires_python = ">=3.8" +summary = "More routines for operating on iterables, beyond itertools" +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +files = [ + {file = "more-itertools-10.5.0.tar.gz", hash = "sha256:5482bfef7849c25dc3c6dd53a6173ae4795da2a41a80faea6700d9f5846c5da6"}, + {file = "more_itertools-10.5.0-py3-none-any.whl", hash = "sha256:037b0d3203ce90cca8ab1defbbdac29d5f993fc20131f3664dc8d6acfa872aef"}, +] + +[[package]] +name = "msgpack" +version = "1.1.0" +requires_python = ">=3.8" +summary = "MessagePack serializer" +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +files = [ + {file = "msgpack-1.1.0-cp38-cp38-win_amd64.whl", hash = "sha256:879a7b7b0ad82481c52d3c7eb99bf6f0645dbdec5134a4bddbd16f3506947feb"}, + {file = "msgpack-1.1.0.tar.gz", hash = "sha256:dd432ccc2c72b914e4cb77afce64aab761c1137cc698be3984eee260bcb2896e"}, +] + +[[package]] +name = "multidict" +version = "6.1.0" +requires_python = ">=3.8" +summary = "multidict implementation" +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +dependencies = [ + "typing-extensions>=4.1.0; python_version < \"3.11\"", +] +files = [ + {file = "multidict-6.1.0-cp38-cp38-win_amd64.whl", hash = "sha256:22f3105d4fb15c8f57ff3959a58fcab6ce36814486500cd7485651230ad4d4ef"}, + {file = "multidict-6.1.0-py3-none-any.whl", hash = "sha256:48e171e52d1c4d33888e529b999e5900356b9ae588c2f09a52dcefb158b27506"}, + {file = "multidict-6.1.0.tar.gz", hash = "sha256:22ae2ebf9b0c69d206c003e2f6a914ea33f0a932d4aa16f236afc049d9958f4a"}, +] + +[[package]] +name = "nbclient" +version = "0.10.0" +requires_python = ">=3.8.0" +summary = "A client library for executing notebooks. Formerly nbconvert's ExecutePreprocessor." +groups = ["docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "jupyter-client>=6.1.12", + "jupyter-core!=5.0.*,>=4.12", + "nbformat>=5.1", + "traitlets>=5.4", +] +files = [ + {file = "nbclient-0.10.0-py3-none-any.whl", hash = "sha256:f13e3529332a1f1f81d82a53210322476a168bb7090a0289c795fe9cc11c9d3f"}, + {file = "nbclient-0.10.0.tar.gz", hash = "sha256:4b3f1b7dba531e498449c4db4f53da339c91d449dc11e9af3a43b4eb5c5abb09"}, +] + +[[package]] +name = "nbconvert" +version = "7.16.6" +requires_python = ">=3.8" +summary = "Converting Jupyter Notebooks (.ipynb files) to other formats. Output formats include asciidoc, html, latex, markdown, pdf, py, rst, script. nbconvert can be used both as a Python library (`import nbconvert`) or as a command line tool (invoked as `jupyter nbconvert ...`)." +groups = ["docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "beautifulsoup4", + "bleach[css]!=5.0.0", + "defusedxml", + "importlib-metadata>=3.6; python_version < \"3.10\"", + "jinja2>=3.0", + "jupyter-core>=4.7", + "jupyterlab-pygments", + "markupsafe>=2.0", + "mistune<4,>=2.0.3", + "nbclient>=0.5.0", + "nbformat>=5.7", + "packaging", + "pandocfilters>=1.4.1", + "pygments>=2.4.1", + "traitlets>=5.1", +] +files = [ + {file = "nbconvert-7.16.6-py3-none-any.whl", hash = "sha256:1375a7b67e0c2883678c48e506dc320febb57685e5ee67faa51b18a90f3a712b"}, + {file = "nbconvert-7.16.6.tar.gz", hash = "sha256:576a7e37c6480da7b8465eefa66c17844243816ce1ccc372633c6b71c3c0f582"}, +] + +[[package]] +name = "nbformat" +version = "5.10.4" +requires_python = ">=3.8" +summary = "The Jupyter Notebook format" +groups = ["docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "fastjsonschema>=2.15", + "jsonschema>=2.6", + "jupyter-core!=5.0.*,>=4.12", + "traitlets>=5.1", +] +files = [ + {file = "nbformat-5.10.4-py3-none-any.whl", hash = "sha256:3b48d6c8fbca4b299bf3982ea7db1af21580e4fec269ad087b9e81588891200b"}, + {file = "nbformat-5.10.4.tar.gz", hash = "sha256:322168b14f937a5d11362988ecac2a4952d3d8e3a2cbeb2319584631226d5b3a"}, +] + +[[package]] +name = "nbsphinx" +version = "0.9.6" +requires_python = ">=3.6" +summary = "Jupyter Notebook Tools for Sphinx" +groups = ["docs"] +marker = "python_version == \"3.8\"" +dependencies = [ + "docutils>=0.18.1", + "jinja2", + "nbconvert!=5.4,>=5.3", + "nbformat", + "sphinx>=1.8", + "traitlets>=5", +] +files = [ + {file = "nbsphinx-0.9.6-py3-none-any.whl", hash = "sha256:336b0b557945a7678ec7449b16449f854bc852a435bb53b8a72e6b5dc740d992"}, + {file = "nbsphinx-0.9.6.tar.gz", hash = "sha256:c2b28a2d702f1159a95b843831798e86e60a17fc647b9bff9ba1585355de54e3"}, +] + +[[package]] +name = "nest-asyncio" +version = "1.6.0" +requires_python = ">=3.5" +summary = "Patch asyncio to allow nested event loops" +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "nest_asyncio-1.6.0-py3-none-any.whl", hash = "sha256:87af6efd6b5e897c81050477ef65c62e2b2f35d51703cae01aff2905b1852e1c"}, + {file = "nest_asyncio-1.6.0.tar.gz", hash = "sha256:6f172d5449aca15afd6c646851f4e31e02c598d553a667e38cafa997cfec55fe"}, +] + +[[package]] +name = "nodeenv" +version = "1.9.1" +requires_python = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,!=3.6.*,>=2.7" +summary = "Node.js virtual environment builder" +groups = ["qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "nodeenv-1.9.1-py2.py3-none-any.whl", hash = "sha256:ba11c9782d29c27c70ffbdda2d7415098754709be8a7056d79a737cd901155c9"}, + {file = "nodeenv-1.9.1.tar.gz", hash = "sha256:6ec12890a2dab7946721edbfbcd91f3319c6ccc9aec47be7c7e6b7011ee6645f"}, +] + +[[package]] +name = "notebook" +version = "7.3.2" +requires_python = ">=3.8" +summary = "Jupyter Notebook - A web-based notebook environment for interactive computing" +groups = ["qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "jupyter-server<3,>=2.4.0", + "jupyterlab-server<3,>=2.27.1", + "jupyterlab<4.4,>=4.3.4", + "notebook-shim<0.3,>=0.2", + "tornado>=6.2.0", +] +files = [ + {file = "notebook-7.3.2-py3-none-any.whl", hash = "sha256:e5f85fc59b69d3618d73cf27544418193ff8e8058d5bf61d315ce4f473556288"}, + {file = "notebook-7.3.2.tar.gz", hash = "sha256:705e83a1785f45b383bf3ee13cb76680b92d24f56fb0c7d2136fe1d850cd3ca8"}, +] + +[[package]] +name = "notebook-shim" +version = "0.2.4" +requires_python = ">=3.7" +summary = "A shim layer for notebook traits and config" +groups = ["qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "jupyter-server<3,>=1.8", +] +files = [ + {file = "notebook_shim-0.2.4-py3-none-any.whl", hash = "sha256:411a5be4e9dc882a074ccbcae671eda64cceb068767e9a3419096986560e1cef"}, + {file = "notebook_shim-0.2.4.tar.gz", hash = "sha256:b4b2cfa1b65d98307ca24361f5b30fe785b53c3fd07b7a47e89acb5e6ac638cb"}, +] + +[[package]] +name = "numpy" +version = "1.24.4" +requires_python = ">=3.8" +summary = "Fundamental package for array computing in Python" +groups = ["default", "pyvista"] +marker = "python_version == \"3.8\"" +files = [ + {file = "numpy-1.24.4-cp38-cp38-win_amd64.whl", hash = "sha256:692f2e0f55794943c5bfff12b3f56f99af76f902fc47487bdfe97856de51a706"}, + {file = "numpy-1.24.4-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:e98f220aa76ca2a977fe435f5b04d7b3470c0a2e6312907b37ba6068f26787f2"}, + {file = "numpy-1.24.4.tar.gz", hash = "sha256:80f5e3a4e498641401868df4208b74581206afbee7cf7b8329daae82676d9463"}, +] + +[[package]] +name = "openpyxl" +version = "3.1.5" +requires_python = ">=3.8" +summary = "A Python library to read/write Excel 2010 xlsx/xlsm files" +groups = ["openpyxl"] +marker = "python_version == \"3.8\"" +dependencies = [ + "et-xmlfile", +] +files = [ + {file = "openpyxl-3.1.5-py2.py3-none-any.whl", hash = "sha256:5282c12b107bffeef825f4617dc029afaf41d0ea60823bbb665ef3079dc79de2"}, + {file = "openpyxl-3.1.5.tar.gz", hash = "sha256:cf0e3cf56142039133628b5acffe8ef0c12bc902d2aadd3e0fe5878dc08d1050"}, +] + +[[package]] +name = "overrides" +version = "7.7.0" +requires_python = ">=3.6" +summary = "A decorator to automatically detect mismatch when overriding a method." +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "typing; python_version < \"3.5\"", +] +files = [ + {file = "overrides-7.7.0-py3-none-any.whl", hash = "sha256:c7ed9d062f78b8e4c1a7b70bd8796b35ead4d9f510227ef9c5dc7626c60d7e49"}, + {file = "overrides-7.7.0.tar.gz", hash = "sha256:55158fa3d93b98cc75299b1e67078ad9003ca27945c76162c1c0766d6f91820a"}, +] + +[[package]] +name = "packaging" +version = "24.2" +requires_python = ">=3.8" +summary = "Core utilities for Python packages" +groups = ["default", "docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "packaging-24.2-py3-none-any.whl", hash = "sha256:09abb1bccd265c01f4a3aa3f7a7db064b36514d2cba19a2f694fe6150451a759"}, + {file = "packaging-24.2.tar.gz", hash = "sha256:c228a6dc5e932d346bc5739379109d49e8853dd8223571c7c5b55260edc0b97f"}, +] + +[[package]] +name = "pandas" +version = "2.0.3" +requires_python = ">=3.8" +summary = "Powerful data structures for data analysis, time series, and statistics" +groups = ["default"] +marker = "python_version == \"3.8\"" +dependencies = [ + "numpy>=1.20.3; python_version < \"3.10\"", + "numpy>=1.21.0; python_version >= \"3.10\"", + "numpy>=1.23.2; python_version >= \"3.11\"", + "python-dateutil>=2.8.2", + "pytz>=2020.1", + "tzdata>=2022.1", +] +files = [ + {file = "pandas-2.0.3-cp38-cp38-win_amd64.whl", hash = "sha256:69d7f3884c95da3a31ef82b7618af5710dba95bb885ffab339aad925c3e8ce78"}, + {file = "pandas-2.0.3.tar.gz", hash = "sha256:c02f372a88e0d17f36d3093a644c73cfc1788e876a7c4bcb4020a77512e2043c"}, +] + +[[package]] +name = "pandoc" +version = "2.4" +summary = "Pandoc Documents for Python" +groups = ["docs"] +marker = "python_version == \"3.8\"" +dependencies = [ + "plumbum", + "ply", +] +files = [ + {file = "pandoc-2.4.tar.gz", hash = "sha256:ecd1f8cbb7f4180c6b5db4a17a7c1a74df519995f5f186ef81ce72a9cbd0dd9a"}, +] + +[[package]] +name = "pandocfilters" +version = "1.5.1" +requires_python = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*" +summary = "Utilities for writing pandoc filters in python" +groups = ["docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "pandocfilters-1.5.1-py2.py3-none-any.whl", hash = "sha256:93be382804a9cdb0a7267585f157e5d1731bbe5545a85b268d6f5fe6232de2bc"}, + {file = "pandocfilters-1.5.1.tar.gz", hash = "sha256:002b4a555ee4ebc03f8b66307e287fa492e4a77b4ea14d3f934328297bb4939e"}, +] + +[[package]] +name = "parso" +version = "0.8.4" +requires_python = ">=3.6" +summary = "A Python Parser" +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "parso-0.8.4-py2.py3-none-any.whl", hash = "sha256:a418670a20291dacd2dddc80c377c5c3791378ee1e8d12bffc35420643d43f18"}, + {file = "parso-0.8.4.tar.gz", hash = "sha256:eb3a7b58240fb99099a345571deecc0f9540ea5f4dd2fe14c2a99d6b281ab92d"}, +] + +[[package]] +name = "pickleshare" +version = "0.7.5" +summary = "Tiny 'shelve'-like database with concurrency support" +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "pathlib2; python_version in \"2.6 2.7 3.2 3.3\"", +] +files = [ + {file = "pickleshare-0.7.5-py2.py3-none-any.whl", hash = "sha256:9649af414d74d4df115d5d718f82acb59c9d418196b7b4290ed47a12ce62df56"}, + {file = "pickleshare-0.7.5.tar.gz", hash = "sha256:87683d47965c1da65cdacaf31c8441d12b8044cdec9aca500cd78fc2c683afca"}, +] + +[[package]] +name = "pillow" +version = "10.4.0" +requires_python = ">=3.8" +summary = "Python Imaging Library (Fork)" +groups = ["default", "pyvista"] +marker = "python_version == \"3.8\"" +files = [ + {file = "pillow-10.4.0-cp38-cp38-win_amd64.whl", hash = "sha256:5161eef006d335e46895297f642341111945e2c1c899eb406882a6c61a4357ab"}, + {file = "pillow-10.4.0.tar.gz", hash = "sha256:166c1cd4d24309b30d61f79f4a9114b7b2313d7450912277855ff5dfd7cd4a06"}, +] + +[[package]] +name = "pkgutil-resolve-name" +version = "1.3.10" +requires_python = ">=3.6" +summary = "Resolve a name to an object." +groups = ["docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "pkgutil_resolve_name-1.3.10-py3-none-any.whl", hash = "sha256:ca27cc078d25c5ad71a9de0a7a330146c4e014c2462d9af19c6b828280649c5e"}, + {file = "pkgutil_resolve_name-1.3.10.tar.gz", hash = "sha256:357d6c9e6a755653cfd78893817c0853af365dd51ec97f3d358a819373bbd174"}, +] + +[[package]] +name = "platformdirs" +version = "4.3.6" +requires_python = ">=3.8" +summary = "A small Python package for determining appropriate platform-specific dirs, e.g. a `user data dir`." +groups = ["docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "platformdirs-4.3.6-py3-none-any.whl", hash = "sha256:73e575e1408ab8103900836b97580d5307456908a03e92031bab39e4554cc3fb"}, + {file = "platformdirs-4.3.6.tar.gz", hash = "sha256:357fb2acbc885b0419afd3ce3ed34564c13c9b95c89360cd9563f73aa5e2b907"}, +] + +[[package]] +name = "pluggy" +version = "1.5.0" +requires_python = ">=3.8" +summary = "plugin and hook calling mechanisms for python" +groups = ["qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "pluggy-1.5.0-py3-none-any.whl", hash = "sha256:44e1ad92c8ca002de6377e165f3e0f1be63266ab4d554740532335b9d75ea669"}, + {file = "pluggy-1.5.0.tar.gz", hash = "sha256:2cffa88e94fdc978c4c574f15f9e59b7f4201d439195c3715ca9e2486f1d0cf1"}, +] + +[[package]] +name = "plumbum" +version = "1.8.3" +requires_python = ">=3.6" +summary = "Plumbum: shell combinators library" +groups = ["docs"] +marker = "python_version == \"3.8\"" +dependencies = [ + "pywin32; platform_system == \"Windows\" and platform_python_implementation != \"PyPy\"", +] +files = [ + {file = "plumbum-1.8.3-py3-none-any.whl", hash = "sha256:8595d36dae2472587d6f59789c8d7b26250f45f6f6ed75ccb378de59ee7b9cf9"}, + {file = "plumbum-1.8.3.tar.gz", hash = "sha256:6092c85ab970b7a7a9d5d85c75200bc93be82b33c9bdf640ffa87d2d7c8709f0"}, +] + +[[package]] +name = "ply" +version = "3.11" +summary = "Python Lex & Yacc" +groups = ["docs"] +marker = "python_version == \"3.8\"" +files = [ + {file = "ply-3.11-py2.py3-none-any.whl", hash = "sha256:096f9b8350b65ebd2fd1346b12452efe5b9607f7482813ffca50c22722a807ce"}, + {file = "ply-3.11.tar.gz", hash = "sha256:00c7c1aaa88358b9c765b6d3000c6eec0ba42abca5351b095321aef446081da3"}, +] + +[[package]] +name = "pooch" +version = "1.8.2" +requires_python = ">=3.7" +summary = "A friend to fetch your data files" +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +dependencies = [ + "packaging>=20.0", + "platformdirs>=2.5.0", + "requests>=2.19.0", +] +files = [ + {file = "pooch-1.8.2-py3-none-any.whl", hash = "sha256:3529a57096f7198778a5ceefd5ac3ef0e4d06a6ddaf9fc2d609b806f25302c47"}, + {file = "pooch-1.8.2.tar.gz", hash = "sha256:76561f0de68a01da4df6af38e9955c4c9d1a5c90da73f7e40276a5728ec83d10"}, +] + +[[package]] +name = "pre-commit" +version = "3.5.0" +requires_python = ">=3.8" +summary = "A framework for managing and maintaining multi-language pre-commit hooks." +groups = ["qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "cfgv>=2.0.0", + "identify>=1.0.0", + "nodeenv>=0.11.1", + "pyyaml>=5.1", + "virtualenv>=20.10.0", +] +files = [ + {file = "pre_commit-3.5.0-py2.py3-none-any.whl", hash = "sha256:841dc9aef25daba9a0238cd27984041fa0467b4199fc4852e27950664919f660"}, + {file = "pre_commit-3.5.0.tar.gz", hash = "sha256:5804465c675b659b0862f07907f96295d490822a450c4c40e747d0b1c6ebcb32"}, +] + +[[package]] +name = "prometheus-client" +version = "0.20.0" +requires_python = ">=3.8" +summary = "Python client for the Prometheus monitoring system." +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "prometheus_client-0.20.0-py3-none-any.whl", hash = "sha256:cde524a85bce83ca359cc837f28b8c0db5cac7aa653a588fd7e84ba061c329e7"}, + {file = "prometheus_client-0.20.0.tar.gz", hash = "sha256:287629d00b147a32dcb2be0b9df905da599b2d82f80377083ec8463309a4bb89"}, +] + +[[package]] +name = "prompt-toolkit" +version = "3.0.47" +requires_python = ">=3.7.0" +summary = "Library for building powerful interactive command lines in Python" +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "wcwidth", +] +files = [ + {file = "prompt_toolkit-3.0.47-py3-none-any.whl", hash = "sha256:0d7bfa67001d5e39d02c224b663abc33687405033a8c422d0d675a5a13361d10"}, + {file = "prompt_toolkit-3.0.47.tar.gz", hash = "sha256:1e1b29cb58080b1e69f207c893a1a7bf16d127a5c30c9d17a25a5d77792e5360"}, +] + +[[package]] +name = "propcache" +version = "0.2.0" +requires_python = ">=3.8" +summary = "Accelerated property cache" +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +files = [ + {file = "propcache-0.2.0-cp38-cp38-win_amd64.whl", hash = "sha256:676135dcf3262c9c5081cc8f19ad55c8a64e3f7282a21266d05544450bffc3a5"}, + {file = "propcache-0.2.0-py3-none-any.whl", hash = "sha256:2ccc28197af5313706511fab3a8b66dcd6da067a1331372c82ea1cb74285e036"}, + {file = "propcache-0.2.0.tar.gz", hash = "sha256:df81779732feb9d01e5d513fad0122efb3d53bbc75f61b2a4f29a020bc985e70"}, +] + +[[package]] +name = "psutil" +version = "6.0.0" +requires_python = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7" +summary = "Cross-platform lib for process and system monitoring in Python." +groups = ["qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "psutil-6.0.0-cp37-abi3-win_amd64.whl", hash = "sha256:33ea5e1c975250a720b3a6609c490db40dae5d83a4eb315170c4fe0d8b1f34b3"}, + {file = "psutil-6.0.0.tar.gz", hash = "sha256:8faae4f310b6d969fa26ca0545338b21f73c6b15db7c4a8d934a5482faa818f2"}, +] + +[[package]] +name = "pure-eval" +version = "0.2.3" +summary = "Safely evaluate AST nodes without side effects" +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "pure_eval-0.2.3-py3-none-any.whl", hash = "sha256:1db8e35b67b3d218d818ae653e27f06c3aa420901fa7b081ca98cbedc874e0d0"}, + {file = "pure_eval-0.2.3.tar.gz", hash = "sha256:5f4e983f40564c576c7c8635ae88db5956bb2229d7e9237d03b3c0b0190eaf42"}, +] + +[[package]] +name = "pycparser" +version = "2.22" +requires_python = ">=3.8" +summary = "C parser in Python" +groups = ["docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "pycparser-2.22-py3-none-any.whl", hash = "sha256:c3702b6d3dd8c7abc1afa565d7e63d53a1d0bd86cdc24edd75470f4de499cfcc"}, + {file = "pycparser-2.22.tar.gz", hash = "sha256:491c8be9c040f5390f5bf44a5b07752bd07f56edf992381b05c701439eec10f6"}, +] + +[[package]] +name = "pydantic" +version = "2.9.1" +requires_python = ">=3.8" +summary = "Data validation using Python type hints" +groups = ["default"] +marker = "python_version == \"3.8\"" +dependencies = [ + "annotated-types>=0.6.0", + "pydantic-core==2.23.3", + "typing-extensions>=4.12.2; python_version >= \"3.13\"", + "typing-extensions>=4.6.1; python_version < \"3.13\"", +] +files = [ + {file = "pydantic-2.9.1-py3-none-any.whl", hash = "sha256:7aff4db5fdf3cf573d4b3c30926a510a10e19a0774d38fc4967f78beb6deb612"}, + {file = "pydantic-2.9.1.tar.gz", hash = "sha256:1363c7d975c7036df0db2b4a61f2e062fbc0aa5ab5f2772e0ffc7191a4f4bce2"}, +] + +[[package]] +name = "pydantic-core" +version = "2.23.3" +requires_python = ">=3.8" +summary = "Core functionality for Pydantic validation and serialization" +groups = ["default"] +marker = "python_version == \"3.8\"" +dependencies = [ + "typing-extensions!=4.7.0,>=4.6.0", +] +files = [ + {file = "pydantic_core-2.23.3-cp38-none-win_amd64.whl", hash = "sha256:13dd45ba2561603681a2676ca56006d6dee94493f03d5cadc055d2055615c3ea"}, + {file = "pydantic_core-2.23.3.tar.gz", hash = "sha256:3cb0f65d8b4121c1b015c60104a685feb929a29d7cf204387c7f2688c7974690"}, +] + +[[package]] +name = "pygments" +version = "2.18.0" +requires_python = ">=3.8" +summary = "Pygments is a syntax highlighting package written in Python." +groups = ["docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "pygments-2.18.0-py3-none-any.whl", hash = "sha256:b8e6aca0523f3ab76fee51799c488e38782ac06eafcf95e7ba832985c8e7b13a"}, + {file = "pygments-2.18.0.tar.gz", hash = "sha256:786ff802f32e91311bff3889f6e9a86e81505fe99f2735bb6d60ae0c5004f199"}, +] + +[[package]] +name = "pyparsing" +version = "3.1.4" +requires_python = ">=3.6.8" +summary = "pyparsing module - Classes and methods to define and execute parsing grammars" +groups = ["default", "pyvista"] +marker = "python_version == \"3.8\"" +files = [ + {file = "pyparsing-3.1.4-py3-none-any.whl", hash = "sha256:a6a7ee4235a3f944aa1fa2249307708f893fe5717dc603503c6c7969c070fb7c"}, + {file = "pyparsing-3.1.4.tar.gz", hash = "sha256:f86ec8d1a83f11977c9a6ea7598e8c27fc5cddfa5b07ea2241edbbde1d7bc032"}, +] + +[[package]] +name = "pyproject-api" +version = "1.8.0" +requires_python = ">=3.8" +summary = "API to interact with the python pyproject.toml based projects" +groups = ["qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "packaging>=24.1", + "tomli>=2.0.1; python_version < \"3.11\"", +] +files = [ + {file = "pyproject_api-1.8.0-py3-none-any.whl", hash = "sha256:3d7d347a047afe796fd5d1885b1e391ba29be7169bd2f102fcd378f04273d228"}, + {file = "pyproject_api-1.8.0.tar.gz", hash = "sha256:77b8049f2feb5d33eefcc21b57f1e279636277a8ac8ad6b5871037b243778496"}, +] + +[[package]] +name = "pyqt5" +version = "5.15.10" +requires_python = ">=3.7" +summary = "Python bindings for the Qt cross platform application toolkit" +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +dependencies = [ + "PyQt5-Qt5>=5.15.2", + "PyQt5-sip<13,>=12.13", +] +files = [ + {file = "PyQt5-5.15.10-cp37-abi3-win_amd64.whl", hash = "sha256:501355f327e9a2c38db0428e1a236d25ebcb99304cd6e668c05d1188d514adec"}, + {file = "PyQt5-5.15.10.tar.gz", hash = "sha256:d46b7804b1b10a4ff91753f8113e5b5580d2b4462f3226288e2d84497334898a"}, +] + +[[package]] +name = "pyqt5-qt5" +version = "5.15.2" +summary = "The subset of a Qt installation needed by PyQt5." +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +files = [ + {file = "PyQt5_Qt5-5.15.2-py3-none-win_amd64.whl", hash = "sha256:750b78e4dba6bdf1607febedc08738e318ea09e9b10aea9ff0d73073f11f6962"}, +] + +[[package]] +name = "pyqt5-sip" +version = "12.15.0" +requires_python = ">=3.8" +summary = "The sip module support for PyQt5" +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +files = [ + {file = "PyQt5_sip-12.15.0-cp38-cp38-win_amd64.whl", hash = "sha256:f600ae6f03e4bff91153c0dc7ebe52f90bd2b6afda58fd580e6990b3b951adc0"}, + {file = "PyQt5_sip-12.15.0.tar.gz", hash = "sha256:d23fdfcf363b5cedd9d39f8a9c5710e7d52804f5b08a58e91c638b36eafcb702"}, +] + +[[package]] +name = "pytest" +version = "8.3.3" +requires_python = ">=3.8" +summary = "pytest: simple powerful testing with Python" +groups = ["qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "colorama; sys_platform == \"win32\"", + "exceptiongroup>=1.0.0rc8; python_version < \"3.11\"", + "iniconfig", + "packaging", + "pluggy<2,>=1.5", + "tomli>=1; python_version < \"3.11\"", +] +files = [ + {file = "pytest-8.3.3-py3-none-any.whl", hash = "sha256:a6853c7375b2663155079443d2e45de913a911a11d669df02a50814944db57b2"}, + {file = "pytest-8.3.3.tar.gz", hash = "sha256:70b98107bd648308a7952b06e6ca9a50bc660be218d53c257cc1fc94fda10181"}, +] + +[[package]] +name = "pytest-cov" +version = "5.0.0" +requires_python = ">=3.8" +summary = "Pytest plugin for measuring coverage." +groups = ["qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "coverage[toml]>=5.2.1", + "pytest>=4.6", +] +files = [ + {file = "pytest-cov-5.0.0.tar.gz", hash = "sha256:5837b58e9f6ebd335b0f8060eecce69b662415b16dc503883a02f45dfeb14857"}, + {file = "pytest_cov-5.0.0-py3-none-any.whl", hash = "sha256:4f0764a1219df53214206bf1feea4633c3b558a2925c8b59f144f682861ce652"}, +] + +[[package]] +name = "python-dateutil" +version = "2.9.0.post0" +requires_python = "!=3.0.*,!=3.1.*,!=3.2.*,>=2.7" +summary = "Extensions to the standard Python datetime module" +groups = ["default", "docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "six>=1.5", +] +files = [ + {file = "python-dateutil-2.9.0.post0.tar.gz", hash = "sha256:37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3"}, + {file = "python_dateutil-2.9.0.post0-py2.py3-none-any.whl", hash = "sha256:a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427"}, +] + +[[package]] +name = "python-json-logger" +version = "2.0.7" +requires_python = ">=3.6" +summary = "A python library adding a json log formatter" +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "python-json-logger-2.0.7.tar.gz", hash = "sha256:23e7ec02d34237c5aa1e29a070193a4ea87583bb4e7f8fd06d3de8264c4b2e1c"}, + {file = "python_json_logger-2.0.7-py3-none-any.whl", hash = "sha256:f380b826a991ebbe3de4d897aeec42760035ac760345e57b812938dc8b35e2bd"}, +] + +[[package]] +name = "pytz" +version = "2024.2" +summary = "World timezone definitions, modern and historical" +groups = ["default", "docs", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "pytz-2024.2-py2.py3-none-any.whl", hash = "sha256:31c7c1817eb7fae7ca4b8c7ee50c72f93aa2dd863de768e1ef4245d426aa0725"}, + {file = "pytz-2024.2.tar.gz", hash = "sha256:2aa355083c50a0f93fa581709deac0c9ad65cca8a9e9beac660adcbd493c798a"}, +] + +[[package]] +name = "pyvista" +version = "0.44.1" +requires_python = ">=3.8" +summary = "Easier Pythonic interface to VTK" +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +dependencies = [ + "matplotlib>=3.0.1", + "numpy>=1.21.0", + "pillow", + "pooch", + "scooby>=0.5.1", + "typing-extensions", + "vtk", +] +files = [ + {file = "pyvista-0.44.1-py3-none-any.whl", hash = "sha256:7a80e8114220ca36d57a4def8e6a3067c908b53b62aa426ea76c76069bb6d1c0"}, + {file = "pyvista-0.44.1.tar.gz", hash = "sha256:63976f5d57d151b3f7e1616dde40dcf56a66d1f37f6db067087fa9cc9667f512"}, +] + +[[package]] +name = "pyvista" +version = "0.44.1" +extras = ["all"] +requires_python = ">=3.8" +summary = "Easier Pythonic interface to VTK" +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +dependencies = [ + "pyvista==0.44.1", + "pyvista[colormaps,io,jupyter]", +] +files = [ + {file = "pyvista-0.44.1-py3-none-any.whl", hash = "sha256:7a80e8114220ca36d57a4def8e6a3067c908b53b62aa426ea76c76069bb6d1c0"}, + {file = "pyvista-0.44.1.tar.gz", hash = "sha256:63976f5d57d151b3f7e1616dde40dcf56a66d1f37f6db067087fa9cc9667f512"}, +] + +[[package]] +name = "pyvista" +version = "0.44.1" +extras = ["colormaps", "io", "jupyter"] +requires_python = ">=3.8" +summary = "Easier Pythonic interface to VTK" +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +dependencies = [ + "cmocean", + "colorcet", + "imageio", + "ipywidgets", + "jupyter-server-proxy", + "meshio>=5.2", + "nest-asyncio", + "pyvista==0.44.1", + "trame-client>=2.12.7", + "trame-server>=2.11.7", + "trame-vtk>=2.5.8", + "trame-vuetify>=2.3.1", + "trame>=2.5.2", +] +files = [ + {file = "pyvista-0.44.1-py3-none-any.whl", hash = "sha256:7a80e8114220ca36d57a4def8e6a3067c908b53b62aa426ea76c76069bb6d1c0"}, + {file = "pyvista-0.44.1.tar.gz", hash = "sha256:63976f5d57d151b3f7e1616dde40dcf56a66d1f37f6db067087fa9cc9667f512"}, +] + +[[package]] +name = "pyvistaqt" +version = "0.11.1" +requires_python = ">=3.7" +summary = "pyvista qt plotter" +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +dependencies = [ + "QtPy>=1.9.0", + "pyvista>=0.32.0", +] +files = [ + {file = "pyvistaqt-0.11.1-py3-none-any.whl", hash = "sha256:3ddc05418fcb297d471e7f7c0fdc89dbd5b6050653b4a86e66e5c1ce7e3563cc"}, + {file = "pyvistaqt-0.11.1.tar.gz", hash = "sha256:5403bfeb82cf063288107a9be9780ca3ca70948e73d33d16a65a83a711d51a36"}, +] + +[[package]] +name = "pywin32" +version = "306" +summary = "Python for Window Extensions" +groups = ["docs", "pyvista", "qa"] +marker = "sys_platform == \"win32\" and platform_python_implementation != \"PyPy\" and python_version == \"3.8\" or platform_system == \"Windows\" and platform_python_implementation != \"PyPy\" and python_version == \"3.8\"" +files = [ + {file = "pywin32-306-cp38-cp38-win_amd64.whl", hash = "sha256:e8ac1ae3601bee6ca9f7cb4b5363bf1c0badb935ef243c4733ff9a393b1690c0"}, +] + +[[package]] +name = "pywinpty" +version = "2.0.13" +requires_python = ">=3.8" +summary = "Pseudo terminal support for Windows from Python." +groups = ["pyvista", "qa"] +marker = "os_name == \"nt\" and python_version == \"3.8\"" +files = [ + {file = "pywinpty-2.0.13-cp38-none-win_amd64.whl", hash = "sha256:61d420c2116c0212808d31625611b51caf621fe67f8a6377e2e8b617ea1c1f7d"}, + {file = "pywinpty-2.0.13.tar.gz", hash = "sha256:c34e32351a3313ddd0d7da23d27f835c860d32fe4ac814d372a3ea9594f41dde"}, +] + +[[package]] +name = "pyyaml" +version = "6.0.2" +requires_python = ">=3.8" +summary = "YAML parser and emitter for Python" +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "PyYAML-6.0.2-cp38-cp38-win_amd64.whl", hash = "sha256:01179a4a8559ab5de078078f37e5c1a30d76bb88519906844fd7bdea1b7729ff"}, + {file = "pyyaml-6.0.2.tar.gz", hash = "sha256:d584d9ec91ad65861cc08d42e834324ef890a082e591037abe114850ff7bbc3e"}, +] + +[[package]] +name = "pyzmq" +version = "26.2.0" +requires_python = ">=3.7" +summary = "Python bindings for 0MQ" +groups = ["docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "cffi; implementation_name == \"pypy\"", +] +files = [ + {file = "pyzmq-26.2.0-cp38-cp38-win_amd64.whl", hash = "sha256:76589f2cd6b77b5bdea4fca5992dc1c23389d68b18ccc26a53680ba2dc80ff2f"}, + {file = "pyzmq-26.2.0-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:29c7947c594e105cb9e6c466bace8532dc1ca02d498684128b339799f5248277"}, + {file = "pyzmq-26.2.0.tar.gz", hash = "sha256:070672c258581c8e4f640b5159297580a9974b026043bd4ab0470be9ed324f1f"}, +] + +[[package]] +name = "qtpy" +version = "2.4.1" +requires_python = ">=3.7" +summary = "Provides an abstraction layer on top of the various Qt bindings (PyQt5/6 and PySide2/6)." +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +dependencies = [ + "packaging", +] +files = [ + {file = "QtPy-2.4.1-py3-none-any.whl", hash = "sha256:1c1d8c4fa2c884ae742b069151b0abe15b3f70491f3972698c683b8e38de839b"}, + {file = "QtPy-2.4.1.tar.gz", hash = "sha256:a5a15ffd519550a1361bdc56ffc07fda56a6af7292f17c7b395d4083af632987"}, +] + +[[package]] +name = "referencing" +version = "0.35.1" +requires_python = ">=3.8" +summary = "JSON Referencing + Python" +groups = ["docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "attrs>=22.2.0", + "rpds-py>=0.7.0", +] +files = [ + {file = "referencing-0.35.1-py3-none-any.whl", hash = "sha256:eda6d3234d62814d1c64e305c1331c9a3a6132da475ab6382eaa997b21ee75de"}, + {file = "referencing-0.35.1.tar.gz", hash = "sha256:25b42124a6c8b632a425174f24087783efb348a6f1e0008e63cd4466fedf703c"}, +] + +[[package]] +name = "requests" +version = "2.32.3" +requires_python = ">=3.8" +summary = "Python HTTP for Humans." +groups = ["docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "certifi>=2017.4.17", + "charset-normalizer<4,>=2", + "idna<4,>=2.5", + "urllib3<3,>=1.21.1", +] +files = [ + {file = "requests-2.32.3-py3-none-any.whl", hash = "sha256:70761cfe03c773ceb22aa2f671b4757976145175cdfca038c02654d061d6dcc6"}, + {file = "requests-2.32.3.tar.gz", hash = "sha256:55365417734eb18255590a9ff9eb97e9e1da868d4ccd6402399eaf68af20a760"}, +] + +[[package]] +name = "rfc3339-validator" +version = "0.1.4" +requires_python = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*" +summary = "A pure python RFC3339 validator" +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "six", +] +files = [ + {file = "rfc3339_validator-0.1.4-py2.py3-none-any.whl", hash = "sha256:24f6ec1eda14ef823da9e36ec7113124b39c04d50a4d3d3a3c2859577e7791fa"}, + {file = "rfc3339_validator-0.1.4.tar.gz", hash = "sha256:138a2abdf93304ad60530167e51d2dfb9549521a836871b88d7f4695d0022f6b"}, +] + +[[package]] +name = "rfc3986-validator" +version = "0.1.1" +requires_python = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*" +summary = "Pure python rfc3986 validator" +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "rfc3986_validator-0.1.1-py2.py3-none-any.whl", hash = "sha256:2f235c432ef459970b4306369336b9d5dbdda31b510ca1e327636e01f528bfa9"}, + {file = "rfc3986_validator-0.1.1.tar.gz", hash = "sha256:3d44bde7921b3b9ec3ae4e3adca370438eccebc676456449b145d533b240d055"}, +] + +[[package]] +name = "rich" +version = "13.8.1" +requires_python = ">=3.7.0" +summary = "Render rich text, tables, progress bars, syntax highlighting, markdown and more to the terminal" +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +dependencies = [ + "markdown-it-py>=2.2.0", + "pygments<3.0.0,>=2.13.0", + "typing-extensions<5.0,>=4.0.0; python_version < \"3.9\"", +] +files = [ + {file = "rich-13.8.1-py3-none-any.whl", hash = "sha256:1760a3c0848469b97b558fc61c85233e3dafb69c7a071b4d60c38099d3cd4c06"}, + {file = "rich-13.8.1.tar.gz", hash = "sha256:8260cda28e3db6bf04d2d1ef4dbc03ba80a824c88b0e7668a0f23126a424844a"}, +] + +[[package]] +name = "rpds-py" +version = "0.20.0" +requires_python = ">=3.8" +summary = "Python bindings to Rust's persistent data structures (rpds)" +groups = ["docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "rpds_py-0.20.0-cp38-none-win_amd64.whl", hash = "sha256:a1862d2d7ce1674cffa6d186d53ca95c6e17ed2b06b3f4c476173565c862d232"}, + {file = "rpds_py-0.20.0.tar.gz", hash = "sha256:d72a210824facfdaf8768cf2d7ca25a042c30320b3020de2fa04640920d4e121"}, +] + +[[package]] +name = "scipy" +version = "1.10.1" +requires_python = "<3.12,>=3.8" +summary = "Fundamental algorithms for scientific computing in Python" +groups = ["default"] +marker = "python_version == \"3.8\"" +dependencies = [ + "numpy<1.27.0,>=1.19.5", +] +files = [ + {file = "scipy-1.10.1-cp38-cp38-win_amd64.whl", hash = "sha256:049a8bbf0ad95277ffba9b3b7d23e5369cc39e66406d60422c8cfef40ccc8415"}, + {file = "scipy-1.10.1.tar.gz", hash = "sha256:2cf9dfb80a7b4589ba4c40ce7588986d6d5cebc5457cad2c2880f6bc2d42f3a5"}, +] + +[[package]] +name = "scooby" +version = "0.10.0" +requires_python = ">=3.8" +summary = "A Great Dane turned Python environment detective" +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +files = [ + {file = "scooby-0.10.0-py3-none-any.whl", hash = "sha256:0a3d7e304f8ebb16f69ff7f6360c345d7f50b45f2ddbf7c3d18a6a0dc2cb03a6"}, + {file = "scooby-0.10.0.tar.gz", hash = "sha256:7ea33c262c0cc6a33c6eeeb5648df787be4f22660e53c114e5fff1b811a8854f"}, +] + +[[package]] +name = "send2trash" +version = "1.8.3" +requires_python = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7" +summary = "Send file to trash natively under Mac OS X, Windows and Linux" +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "Send2Trash-1.8.3-py3-none-any.whl", hash = "sha256:0c31227e0bd08961c7665474a3d1ef7193929fedda4233843689baa056be46c9"}, + {file = "Send2Trash-1.8.3.tar.gz", hash = "sha256:b18e7a3966d99871aefeb00cfbcfdced55ce4871194810fc71f4aa484b953abf"}, +] + +[[package]] +name = "setuptools" +version = "74.1.2" +requires_python = ">=3.8" +summary = "Easily download, build, install, upgrade, and uninstall Python packages" +groups = ["qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "setuptools-74.1.2-py3-none-any.whl", hash = "sha256:5f4c08aa4d3ebcb57a50c33b1b07e94315d7fc7230f7115e47fc99776c8ce308"}, + {file = "setuptools-74.1.2.tar.gz", hash = "sha256:95b40ed940a1c67eb70fc099094bd6e99c6ee7c23aa2306f4d2697ba7916f9c6"}, +] + +[[package]] +name = "simpervisor" +version = "1.0.0" +requires_python = ">=3.8" +summary = "Simple async process supervisor" +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +files = [ + {file = "simpervisor-1.0.0-py3-none-any.whl", hash = "sha256:3e313318264559beea3f475ead202bc1cd58a2f1288363abb5657d306c5b8388"}, + {file = "simpervisor-1.0.0.tar.gz", hash = "sha256:7eb87ca86d5e276976f5bb0290975a05d452c6a7b7f58062daea7d8369c823c1"}, +] + +[[package]] +name = "six" +version = "1.16.0" +requires_python = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*" +summary = "Python 2 and 3 compatibility utilities" +groups = ["default", "docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "six-1.16.0-py2.py3-none-any.whl", hash = "sha256:8abb2f1d86890a2dfb989f9a77cfcfd3e47c2a354b01111771326f8aa26e0254"}, + {file = "six-1.16.0.tar.gz", hash = "sha256:1e61c37477a1626458e36f7b1d82aa5c9b094fa4802892072e49de9c60c4c926"}, +] + +[[package]] +name = "sniffio" +version = "1.3.1" +requires_python = ">=3.7" +summary = "Sniff out which async library your code is running under" +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "sniffio-1.3.1-py3-none-any.whl", hash = "sha256:2f6da418d1f1e0fddd844478f41680e794e6051915791a034ff65e5f100525a2"}, + {file = "sniffio-1.3.1.tar.gz", hash = "sha256:f4324edc670a0f49750a81b895f35c3adb843cca46f0530f79fc1babb23789dc"}, +] + +[[package]] +name = "snowballstemmer" +version = "2.2.0" +summary = "This package provides 29 stemmers for 28 languages generated from Snowball algorithms." +groups = ["docs"] +marker = "python_version == \"3.8\"" +files = [ + {file = "snowballstemmer-2.2.0-py2.py3-none-any.whl", hash = "sha256:c8e1716e83cc398ae16824e5572ae04e0d9fc2c6b985fb0f900f5f0c96ecba1a"}, + {file = "snowballstemmer-2.2.0.tar.gz", hash = "sha256:09b16deb8547d3412ad7b590689584cd0fe25ec8db3be37788be3810cbf19cb1"}, +] + +[[package]] +name = "soupsieve" +version = "2.6" +requires_python = ">=3.8" +summary = "A modern CSS selector implementation for Beautiful Soup." +groups = ["docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "soupsieve-2.6-py3-none-any.whl", hash = "sha256:e72c4ff06e4fb6e4b5a9f0f55fe6e81514581fca1515028625d0f299c602ccc9"}, + {file = "soupsieve-2.6.tar.gz", hash = "sha256:e2e68417777af359ec65daac1057404a3c8a5455bb8abc36f1a9866ab1a51abb"}, +] + +[[package]] +name = "sphinx" +version = "7.1.2" +requires_python = ">=3.8" +summary = "Python documentation generator" +groups = ["docs"] +marker = "python_version == \"3.8\"" +dependencies = [ + "Jinja2>=3.0", + "Pygments>=2.13", + "alabaster<0.8,>=0.7", + "babel>=2.9", + "colorama>=0.4.5; sys_platform == \"win32\"", + "docutils<0.21,>=0.18.1", + "imagesize>=1.3", + "importlib-metadata>=4.8; python_version < \"3.10\"", + "packaging>=21.0", + "requests>=2.25.0", + "snowballstemmer>=2.0", + "sphinxcontrib-applehelp", + "sphinxcontrib-devhelp", + "sphinxcontrib-htmlhelp>=2.0.0", + "sphinxcontrib-jsmath", + "sphinxcontrib-qthelp", + "sphinxcontrib-serializinghtml>=1.1.5", +] +files = [ + {file = "sphinx-7.1.2-py3-none-any.whl", hash = "sha256:d170a81825b2fcacb6dfd5a0d7f578a053e45d3f2b153fecc948c37344eb4cbe"}, + {file = "sphinx-7.1.2.tar.gz", hash = "sha256:780f4d32f1d7d1126576e0e5ecc19dc32ab76cd24e950228dcf7b1f6d3d9e22f"}, +] + +[[package]] +name = "sphinx-rtd-theme" +version = "2.0.0" +requires_python = ">=3.6" +summary = "Read the Docs theme for Sphinx" +groups = ["docs"] +marker = "python_version == \"3.8\"" +dependencies = [ + "docutils<0.21", + "sphinx<8,>=5", + "sphinxcontrib-jquery<5,>=4", +] +files = [ + {file = "sphinx_rtd_theme-2.0.0-py2.py3-none-any.whl", hash = "sha256:ec93d0856dc280cf3aee9a4c9807c60e027c7f7b461b77aeffed682e68f0e586"}, + {file = "sphinx_rtd_theme-2.0.0.tar.gz", hash = "sha256:bd5d7b80622406762073a04ef8fadc5f9151261563d47027de09910ce03afe6b"}, +] + +[[package]] +name = "sphinxcontrib-applehelp" +version = "1.0.4" +requires_python = ">=3.8" +summary = "sphinxcontrib-applehelp is a Sphinx extension which outputs Apple help books" +groups = ["docs"] +marker = "python_version == \"3.8\"" +files = [ + {file = "sphinxcontrib-applehelp-1.0.4.tar.gz", hash = "sha256:828f867945bbe39817c210a1abfd1bc4895c8b73fcaade56d45357a348a07d7e"}, + {file = "sphinxcontrib_applehelp-1.0.4-py3-none-any.whl", hash = "sha256:29d341f67fb0f6f586b23ad80e072c8e6ad0b48417db2bde114a4c9746feb228"}, +] + +[[package]] +name = "sphinxcontrib-devhelp" +version = "1.0.2" +requires_python = ">=3.5" +summary = "sphinxcontrib-devhelp is a sphinx extension which outputs Devhelp document." +groups = ["docs"] +marker = "python_version == \"3.8\"" +files = [ + {file = "sphinxcontrib-devhelp-1.0.2.tar.gz", hash = "sha256:ff7f1afa7b9642e7060379360a67e9c41e8f3121f2ce9164266f61b9f4b338e4"}, + {file = "sphinxcontrib_devhelp-1.0.2-py2.py3-none-any.whl", hash = "sha256:8165223f9a335cc1af7ffe1ed31d2871f325254c0423bc0c4c7cd1c1e4734a2e"}, +] + +[[package]] +name = "sphinxcontrib-htmlhelp" +version = "2.0.1" +requires_python = ">=3.8" +summary = "sphinxcontrib-htmlhelp is a sphinx extension which renders HTML help files" +groups = ["docs"] +marker = "python_version == \"3.8\"" +files = [ + {file = "sphinxcontrib-htmlhelp-2.0.1.tar.gz", hash = "sha256:0cbdd302815330058422b98a113195c9249825d681e18f11e8b1f78a2f11efff"}, + {file = "sphinxcontrib_htmlhelp-2.0.1-py3-none-any.whl", hash = "sha256:c38cb46dccf316c79de6e5515e1770414b797162b23cd3d06e67020e1d2a6903"}, +] + +[[package]] +name = "sphinxcontrib-jquery" +version = "4.1" +requires_python = ">=2.7" +summary = "Extension to include jQuery on newer Sphinx releases" +groups = ["docs"] +marker = "python_version == \"3.8\"" +dependencies = [ + "Sphinx>=1.8", +] +files = [ + {file = "sphinxcontrib-jquery-4.1.tar.gz", hash = "sha256:1620739f04e36a2c779f1a131a2dfd49b2fd07351bf1968ced074365933abc7a"}, + {file = "sphinxcontrib_jquery-4.1-py2.py3-none-any.whl", hash = "sha256:f936030d7d0147dd026a4f2b5a57343d233f1fc7b363f68b3d4f1cb0993878ae"}, +] + +[[package]] +name = "sphinxcontrib-jsmath" +version = "1.0.1" +requires_python = ">=3.5" +summary = "A sphinx extension which renders display math in HTML via JavaScript" +groups = ["docs"] +marker = "python_version == \"3.8\"" +files = [ + {file = "sphinxcontrib-jsmath-1.0.1.tar.gz", hash = "sha256:a9925e4a4587247ed2191a22df5f6970656cb8ca2bd6284309578f2153e0c4b8"}, + {file = "sphinxcontrib_jsmath-1.0.1-py2.py3-none-any.whl", hash = "sha256:2ec2eaebfb78f3f2078e73666b1415417a116cc848b72e5172e596c871103178"}, +] + +[[package]] +name = "sphinxcontrib-qthelp" +version = "1.0.3" +requires_python = ">=3.5" +summary = "sphinxcontrib-qthelp is a sphinx extension which outputs QtHelp document." +groups = ["docs"] +marker = "python_version == \"3.8\"" +files = [ + {file = "sphinxcontrib-qthelp-1.0.3.tar.gz", hash = "sha256:4c33767ee058b70dba89a6fc5c1892c0d57a54be67ddd3e7875a18d14cba5a72"}, + {file = "sphinxcontrib_qthelp-1.0.3-py2.py3-none-any.whl", hash = "sha256:bd9fc24bcb748a8d51fd4ecaade681350aa63009a347a8c14e637895444dfab6"}, +] + +[[package]] +name = "sphinxcontrib-serializinghtml" +version = "1.1.5" +requires_python = ">=3.5" +summary = "sphinxcontrib-serializinghtml is a sphinx extension which outputs \"serialized\" HTML files (json and pickle)." +groups = ["docs"] +marker = "python_version == \"3.8\"" +files = [ + {file = "sphinxcontrib-serializinghtml-1.1.5.tar.gz", hash = "sha256:aa5f6de5dfdf809ef505c4895e51ef5c9eac17d0f287933eb49ec495280b6952"}, + {file = "sphinxcontrib_serializinghtml-1.1.5-py2.py3-none-any.whl", hash = "sha256:352a9a00ae864471d3a7ead8d7d79f5fc0b57e8b3f95e9867eb9eb28999b92fd"}, +] + +[[package]] +name = "stack-data" +version = "0.6.3" +summary = "Extract data from python stack frames and tracebacks for informative displays" +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "asttokens>=2.1.0", + "executing>=1.2.0", + "pure-eval", +] +files = [ + {file = "stack_data-0.6.3-py3-none-any.whl", hash = "sha256:d5558e0c25a4cb0853cddad3d77da9891a08cb85dd9f9f91b9f8cd66e511e695"}, + {file = "stack_data-0.6.3.tar.gz", hash = "sha256:836a778de4fec4dcd1dcd89ed8abff8a221f58308462e1c4aa2a3cf30148f0b9"}, +] + +[[package]] +name = "terminado" +version = "0.18.1" +requires_python = ">=3.8" +summary = "Tornado websocket backend for the Xterm.js Javascript terminal emulator library." +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "ptyprocess; os_name != \"nt\"", + "pywinpty>=1.1.0; os_name == \"nt\"", + "tornado>=6.1.0", +] +files = [ + {file = "terminado-0.18.1-py3-none-any.whl", hash = "sha256:a4468e1b37bb318f8a86514f65814e1afc977cf29b3992a4500d9dd305dcceb0"}, + {file = "terminado-0.18.1.tar.gz", hash = "sha256:de09f2c4b85de4765f7714688fff57d3e75bad1f909b589fde880460c753fd2e"}, +] + +[[package]] +name = "tinycss2" +version = "1.2.1" +requires_python = ">=3.7" +summary = "A tiny CSS parser" +groups = ["docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "webencodings>=0.4", +] +files = [ + {file = "tinycss2-1.2.1-py3-none-any.whl", hash = "sha256:2b80a96d41e7c3914b8cda8bc7f705a4d9c49275616e886103dd839dfc847847"}, + {file = "tinycss2-1.2.1.tar.gz", hash = "sha256:8cff3a8f066c2ec677c06dbc7b45619804a6938478d9d73c284b29d14ecb0627"}, +] + +[[package]] +name = "tomli" +version = "2.2.1" +requires_python = ">=3.8" +summary = "A lil' TOML parser" +groups = ["qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "tomli-2.2.1-py3-none-any.whl", hash = "sha256:cb55c73c5f4408779d0cf3eef9f762b9c9f147a77de7b258bef0a5628adc85cc"}, + {file = "tomli-2.2.1.tar.gz", hash = "sha256:cd45e1dc79c835ce60f7404ec8119f2eb06d38b1deba146f07ced3bbc44505ff"}, +] + +[[package]] +name = "tornado" +version = "6.4.2" +requires_python = ">=3.8" +summary = "Tornado is a Python web framework and asynchronous networking library, originally developed at FriendFeed." +groups = ["docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "tornado-6.4.2-cp38-abi3-win_amd64.whl", hash = "sha256:908b71bf3ff37d81073356a5fadcc660eb10c1476ee6e2725588626ce7e5ca38"}, + {file = "tornado-6.4.2.tar.gz", hash = "sha256:92bad5b4746e9879fd7bf1eb21dce4e3fc5128d71601f80005afa39237ad620b"}, +] + +[[package]] +name = "tox" +version = "4.24.1" +requires_python = ">=3.8" +summary = "tox is a generic virtualenv management and test command line tool" +groups = ["qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "cachetools>=5.5", + "chardet>=5.2", + "colorama>=0.4.6", + "filelock>=3.16.1", + "packaging>=24.2", + "platformdirs>=4.3.6", + "pluggy>=1.5", + "pyproject-api>=1.8", + "tomli>=2.1; python_version < \"3.11\"", + "typing-extensions>=4.12.2; python_version < \"3.11\"", + "virtualenv>=20.27.1", +] +files = [ + {file = "tox-4.24.1-py3-none-any.whl", hash = "sha256:57ba7df7d199002c6df8c2db9e6484f3de6ca8f42013c083ea2d4d1e5c6bdc75"}, + {file = "tox-4.24.1.tar.gz", hash = "sha256:083a720adbc6166fff0b7d1df9d154f9d00bfccb9403b8abf6bc0ee435d6a62e"}, +] + +[[package]] +name = "tqdm" +version = "4.66.5" +requires_python = ">=3.7" +summary = "Fast, Extensible Progress Meter" +groups = ["default"] +marker = "python_version == \"3.8\"" +dependencies = [ + "colorama; platform_system == \"Windows\"", +] +files = [ + {file = "tqdm-4.66.5-py3-none-any.whl", hash = "sha256:90279a3770753eafc9194a0364852159802111925aa30eb3f9d85b0e805ac7cd"}, + {file = "tqdm-4.66.5.tar.gz", hash = "sha256:e1020aef2e5096702d8a025ac7d16b1577279c9d63f8375b63083e9a5f0fcbad"}, +] + +[[package]] +name = "traitlets" +version = "5.14.3" +requires_python = ">=3.8" +summary = "Traitlets Python configuration system" +groups = ["docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "traitlets-5.14.3-py3-none-any.whl", hash = "sha256:b74e89e397b1ed28cc831db7aea759ba6640cb3de13090ca145426688ff1ac4f"}, + {file = "traitlets-5.14.3.tar.gz", hash = "sha256:9ed0579d3502c94b4b3732ac120375cda96f923114522847de4b3bb98b96b6b7"}, +] + +[[package]] +name = "trame" +version = "3.6.5" +summary = "Trame, a framework to build applications in plain Python" +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +dependencies = [ + "trame-client<4,>=3", + "trame-server<4,>=3", + "wslink>=2.1.3", +] +files = [ + {file = "trame-3.6.5-py3-none-any.whl", hash = "sha256:58b5be29287d275dbd2be15b4e453c788361f640253ad153ca99fb3eb28e00f3"}, + {file = "trame-3.6.5.tar.gz", hash = "sha256:fc26a7067f94377e01263facb4cd40b111d799d970b5fc8e2aecb52e60378959"}, +] + +[[package]] +name = "trame-client" +version = "3.2.5" +summary = "Internal client of trame" +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +files = [ + {file = "trame-client-3.2.5.tar.gz", hash = "sha256:6f81c2a78389f1962bec38a318b0de47f241dae7778b25dba75fa3ed4d58bd33"}, + {file = "trame_client-3.2.5-py3-none-any.whl", hash = "sha256:023e062175fef67d45a65ac7a367b0e3468f6746c4f8c7a7aa3fe8e82273c62a"}, +] + +[[package]] +name = "trame-server" +version = "3.1.2" +summary = "Internal server side implementation of trame" +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +dependencies = [ + "more-itertools", + "wslink<3,>=2", +] +files = [ + {file = "trame-server-3.1.2.tar.gz", hash = "sha256:03bdd81e0132fb55de7b493c7ebdc4c21f6b0003960bceb3adca258fc432211f"}, + {file = "trame_server-3.1.2-py3-none-any.whl", hash = "sha256:b43d11edfbca012ac34a724dc751b6ecfaecd7d636eaea4ab0650d2adc9e3771"}, +] + +[[package]] +name = "trame-vtk" +version = "2.8.10" +summary = "VTK widgets for trame" +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +dependencies = [ + "trame-client", +] +files = [ + {file = "trame-vtk-2.8.10.tar.gz", hash = "sha256:4d8e38f7c1d5be8eafc28254bd5bd5dc5d4b336a334b944fc9383c9624184b5e"}, + {file = "trame_vtk-2.8.10-py3-none-any.whl", hash = "sha256:0fe850d1358193c1d73c9af87715d7877210df53edf4e4d468ba396c0845765c"}, +] + +[[package]] +name = "trame-vuetify" +version = "2.7.1" +summary = "Vuetify widgets for trame" +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +dependencies = [ + "trame-client", +] +files = [ + {file = "trame-vuetify-2.7.1.tar.gz", hash = "sha256:48443910a3a53b9fa040e05b261fce9326fe95309b3798d49f0d6aec84cbfdf8"}, + {file = "trame_vuetify-2.7.1-py3-none-any.whl", hash = "sha256:c6bfe3be49ac8b7aa354e4e2c1d92f2c2e9680eea563f46146eef6968a66c2de"}, +] + +[[package]] +name = "types-python-dateutil" +version = "2.9.0.20240906" +requires_python = ">=3.8" +summary = "Typing stubs for python-dateutil" +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "types-python-dateutil-2.9.0.20240906.tar.gz", hash = "sha256:9706c3b68284c25adffc47319ecc7947e5bb86b3773f843c73906fd598bc176e"}, + {file = "types_python_dateutil-2.9.0.20240906-py3-none-any.whl", hash = "sha256:27c8cc2d058ccb14946eebcaaa503088f4f6dbc4fb6093d3d456a49aef2753f6"}, +] + +[[package]] +name = "typing-extensions" +version = "4.12.2" +requires_python = ">=3.8" +summary = "Backported and Experimental Type Hints for Python 3.8+" +groups = ["default", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "typing_extensions-4.12.2-py3-none-any.whl", hash = "sha256:04e5ca0351e0f3f85c6853954072df659d0d13fac324d0072316b67d7794700d"}, + {file = "typing_extensions-4.12.2.tar.gz", hash = "sha256:1a7ead55c7e559dd4dee8856e3a88b41225abfe1ce8df57b7c13915fe121ffb8"}, +] + +[[package]] +name = "tzdata" +version = "2024.1" +requires_python = ">=2" +summary = "Provider of IANA time zone data" +groups = ["default"] +marker = "python_version == \"3.8\"" +files = [ + {file = "tzdata-2024.1-py2.py3-none-any.whl", hash = "sha256:9068bc196136463f5245e51efda838afa15aaeca9903f49050dfa2679db4d252"}, + {file = "tzdata-2024.1.tar.gz", hash = "sha256:2674120f8d891909751c38abcdfd386ac0a5a1127954fbc332af6b5ceae07efd"}, +] + +[[package]] +name = "uri-template" +version = "1.3.0" +requires_python = ">=3.7" +summary = "RFC 6570 URI Template Processor" +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "uri-template-1.3.0.tar.gz", hash = "sha256:0e00f8eb65e18c7de20d595a14336e9f337ead580c70934141624b6d1ffdacc7"}, + {file = "uri_template-1.3.0-py3-none-any.whl", hash = "sha256:a44a133ea12d44a0c0f06d7d42a52d71282e77e2f937d8abd5655b8d56fc1363"}, +] + +[[package]] +name = "urllib3" +version = "2.2.2" +requires_python = ">=3.8" +summary = "HTTP library with thread-safe connection pooling, file post, and more." +groups = ["docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "urllib3-2.2.2-py3-none-any.whl", hash = "sha256:a448b2f64d686155468037e1ace9f2d2199776e17f0a46610480d311f73e3472"}, + {file = "urllib3-2.2.2.tar.gz", hash = "sha256:dd505485549a7a552833da5e6063639d0d177c04f23bc3864e41e5dc5f612168"}, +] + +[[package]] +name = "virtualenv" +version = "20.29.1" +requires_python = ">=3.8" +summary = "Virtual Python Environment builder" +groups = ["qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "distlib<1,>=0.3.7", + "filelock<4,>=3.12.2", + "importlib-metadata>=6.6; python_version < \"3.8\"", + "platformdirs<5,>=3.9.1", +] +files = [ + {file = "virtualenv-20.29.1-py3-none-any.whl", hash = "sha256:4e4cb403c0b0da39e13b46b1b2476e505cb0046b25f242bee80f62bf990b2779"}, + {file = "virtualenv-20.29.1.tar.gz", hash = "sha256:b8b8970138d32fb606192cb97f6cd4bb644fa486be9308fb9b63f81091b5dc35"}, +] + +[[package]] +name = "vtk" +version = "9.3.1" +summary = "VTK is an open-source toolkit for 3D computer graphics, image processing, and visualization" +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +dependencies = [ + "matplotlib>=2.0.0", +] +files = [ + {file = "vtk-9.3.1-cp38-cp38-win_amd64.whl", hash = "sha256:872e964c38dc1d969aaa29d10a5e56fd0324d61392e21dc044c679797fbdf0ef"}, +] + +[[package]] +name = "wcwidth" +version = "0.2.13" +summary = "Measures the displayed width of unicode strings in a terminal" +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +dependencies = [ + "backports-functools-lru-cache>=1.2.1; python_version < \"3.2\"", +] +files = [ + {file = "wcwidth-0.2.13-py2.py3-none-any.whl", hash = "sha256:3da69048e4540d84af32131829ff948f1e022c1c6bdb8d6102117aac784f6859"}, + {file = "wcwidth-0.2.13.tar.gz", hash = "sha256:72ea0c06399eb286d978fdedb6923a9eb47e1c486ce63e9b4e64fc18303972b5"}, +] + +[[package]] +name = "webcolors" +version = "24.8.0" +requires_python = ">=3.8" +summary = "A library for working with the color formats defined by HTML and CSS." +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "webcolors-24.8.0-py3-none-any.whl", hash = "sha256:fc4c3b59358ada164552084a8ebee637c221e4059267d0f8325b3b560f6c7f0a"}, + {file = "webcolors-24.8.0.tar.gz", hash = "sha256:08b07af286a01bcd30d583a7acadf629583d1f79bfef27dd2c2c5c263817277d"}, +] + +[[package]] +name = "webencodings" +version = "0.5.1" +summary = "Character encoding aliases for legacy web content" +groups = ["docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "webencodings-0.5.1-py2.py3-none-any.whl", hash = "sha256:a0af1213f3c2226497a97e2b3aa01a7e4bee4f403f95be16fc9acd2947514a78"}, + {file = "webencodings-0.5.1.tar.gz", hash = "sha256:b36a1c245f2d304965eb4e0a82848379241dc04b865afcc4aab16748587e1923"}, +] + +[[package]] +name = "websocket-client" +version = "1.8.0" +requires_python = ">=3.8" +summary = "WebSocket client for Python with low level API options" +groups = ["pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "websocket_client-1.8.0-py3-none-any.whl", hash = "sha256:17b44cc997f5c498e809b22cdf2d9c7a9e71c02c8cc2b6c56e7c2d1239bfa526"}, + {file = "websocket_client-1.8.0.tar.gz", hash = "sha256:3239df9f44da632f96012472805d40a23281a991027ce11d2f45a6f24ac4c3da"}, +] + +[[package]] +name = "widgetsnbextension" +version = "4.0.13" +requires_python = ">=3.7" +summary = "Jupyter interactive widgets for Jupyter Notebook" +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +files = [ + {file = "widgetsnbextension-4.0.13-py3-none-any.whl", hash = "sha256:74b2692e8500525cc38c2b877236ba51d34541e6385eeed5aec15a70f88a6c71"}, + {file = "widgetsnbextension-4.0.13.tar.gz", hash = "sha256:ffcb67bc9febd10234a362795f643927f4e0c05d9342c727b65d2384f8feacb6"}, +] + +[[package]] +name = "wslink" +version = "2.1.3" +summary = "Python/JavaScript library for communicating over WebSocket" +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +dependencies = [ + "aiohttp<4", + "msgpack<2,>=1", +] +files = [ + {file = "wslink-2.1.3-py3-none-any.whl", hash = "sha256:a4a3689a30dd108255560e2f56903003355f4e0f3f6e5f12033a6de108bba18a"}, + {file = "wslink-2.1.3.tar.gz", hash = "sha256:528d008f1a6110bc8141c32588e43b16ff438cedb80c5bb85e9ef92ae753c98e"}, +] + +[[package]] +name = "yarl" +version = "1.15.2" +requires_python = ">=3.8" +summary = "Yet another URL library" +groups = ["pyvista"] +marker = "python_version == \"3.8\"" +dependencies = [ + "idna>=2.0", + "multidict>=4.0", + "propcache>=0.2.0", +] +files = [ + {file = "yarl-1.15.2-cp38-cp38-win_amd64.whl", hash = "sha256:2cf441c4b6e538ba0d2591574f95d3fdd33f1efafa864faa077d9636ecc0c4e9"}, + {file = "yarl-1.15.2-py3-none-any.whl", hash = "sha256:0d3105efab7c5c091609abacad33afff33bdff0035bece164c98bcf5a85ef90a"}, + {file = "yarl-1.15.2.tar.gz", hash = "sha256:a39c36f4218a5bb668b4f06874d676d35a035ee668e6e7e3538835c703634b84"}, +] + +[[package]] +name = "zipp" +version = "3.20.1" +requires_python = ">=3.8" +summary = "Backport of pathlib-compatible object wrapper for zip files" +groups = ["default", "docs", "pyvista", "qa"] +marker = "python_version == \"3.8\"" +files = [ + {file = "zipp-3.20.1-py3-none-any.whl", hash = "sha256:9960cd8967c8f85a56f920d5d507274e74f9ff813a0ab8889a5b5be2daf44064"}, + {file = "zipp-3.20.1.tar.gz", hash = "sha256:c22b14cc4763c5a5b04134207736c107db42e9d3ef2d9779d465f5f1bcba572b"}, +] diff --git a/pdm-py39+macos.lock b/pdm-py39+macos.lock new file mode 100644 index 0000000..4443973 --- /dev/null +++ b/pdm-py39+macos.lock @@ -0,0 +1,3018 @@ +# This file is @generated by PDM. +# It is not intended for manual editing. + +[metadata] +groups = ["default", "docs", "openpyxl", "pyvista", "qa"] +strategy = ["inherit_metadata"] +lock_version = "4.5.0" +content_hash = "sha256:22cd5aee3b297d0bb4e82486997918f7af7cd34c35252bce0aa0be1ee01bc0c1" + +[[metadata.targets]] +requires_python = ">=3.9,<3.13" +platform = "macos_12_0_arm64" + +[[package]] +name = "aiohappyeyeballs" +version = "2.4.0" +requires_python = ">=3.8" +summary = "Happy Eyeballs for asyncio" +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "aiohappyeyeballs-2.4.0-py3-none-any.whl", hash = "sha256:7ce92076e249169a13c2f49320d1967425eaf1f407522d707d59cac7628d62bd"}, + {file = "aiohappyeyeballs-2.4.0.tar.gz", hash = "sha256:55a1714f084e63d49639800f95716da97a1f173d46a16dfcfda0016abb93b6b2"}, +] + +[[package]] +name = "aiohttp" +version = "3.11.12" +requires_python = ">=3.9" +summary = "Async http client/server framework (asyncio)" +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "aiohappyeyeballs>=2.3.0", + "aiosignal>=1.1.2", + "async-timeout<6.0,>=4.0; python_version < \"3.11\"", + "attrs>=17.3.0", + "frozenlist>=1.1.1", + "multidict<7.0,>=4.5", + "propcache>=0.2.0", + "yarl<2.0,>=1.17.0", +] +files = [ + {file = "aiohttp-3.11.12-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:aa8a8caca81c0a3e765f19c6953416c58e2f4cc1b84829af01dd1c771bb2f91f"}, + {file = "aiohttp-3.11.12-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:584096938a001378484aa4ee54e05dc79c7b9dd933e271c744a97b3b6f644957"}, + {file = "aiohttp-3.11.12-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:87a2e00bf17da098d90d4145375f1d985a81605267e7f9377ff94e55c5d769eb"}, + {file = "aiohttp-3.11.12-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:936d8a4f0f7081327014742cd51d320296b56aa6d324461a13724ab05f4b2933"}, + {file = "aiohttp-3.11.12-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:e392804a38353900c3fd8b7cacbea5132888f7129f8e241915e90b85f00e3250"}, + {file = "aiohttp-3.11.12-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:dc065a4285307607df3f3686363e7f8bdd0d8ab35f12226362a847731516e42c"}, + {file = "aiohttp-3.11.12-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:7c3623053b85b4296cd3925eeb725e386644fd5bc67250b3bb08b0f144803e7b"}, + {file = "aiohttp-3.11.12-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:6130459189e61baac5a88c10019b21e1f0c6d00ebc770e9ce269475650ff7f73"}, + {file = "aiohttp-3.11.12.tar.gz", hash = "sha256:7603ca26d75b1b86160ce1bbe2787a0b706e592af5b2504e12caa88a217767b0"}, +] + +[[package]] +name = "aiosignal" +version = "1.3.1" +requires_python = ">=3.7" +summary = "aiosignal: a list of registered asynchronous callbacks" +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "frozenlist>=1.1.0", +] +files = [ + {file = "aiosignal-1.3.1-py3-none-any.whl", hash = "sha256:f8376fb07dd1e86a584e4fcdec80b36b7f81aac666ebc724e2c090300dd83b17"}, + {file = "aiosignal-1.3.1.tar.gz", hash = "sha256:54cd96e15e1649b75d6c87526a6ff0b6c1b0dd3459f43d9ca11d48c339b68cfc"}, +] + +[[package]] +name = "alabaster" +version = "0.7.16" +requires_python = ">=3.9" +summary = "A light, configurable Sphinx theme" +groups = ["docs"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "alabaster-0.7.16-py3-none-any.whl", hash = "sha256:b46733c07dce03ae4e150330b975c75737fa60f0a7c591b6c8bf4928a28e2c92"}, + {file = "alabaster-0.7.16.tar.gz", hash = "sha256:75a8b99c28a5dad50dd7f8ccdd447a121ddb3892da9e53d1ca5cca3106d58d65"}, +] + +[[package]] +name = "annotated-types" +version = "0.7.0" +requires_python = ">=3.8" +summary = "Reusable constraint types to use with typing.Annotated" +groups = ["default"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "typing-extensions>=4.0.0; python_version < \"3.9\"", +] +files = [ + {file = "annotated_types-0.7.0-py3-none-any.whl", hash = "sha256:1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53"}, + {file = "annotated_types-0.7.0.tar.gz", hash = "sha256:aff07c09a53a08bc8cfccb9c85b05f1aa9a2a6f23728d790723543408344ce89"}, +] + +[[package]] +name = "anyio" +version = "4.4.0" +requires_python = ">=3.8" +summary = "High level compatibility layer for multiple asynchronous event loop implementations" +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "exceptiongroup>=1.0.2; python_version < \"3.11\"", + "idna>=2.8", + "sniffio>=1.1", + "typing-extensions>=4.1; python_version < \"3.11\"", +] +files = [ + {file = "anyio-4.4.0-py3-none-any.whl", hash = "sha256:c1b2d8f46a8a812513012e1107cb0e68c17159a7a594208005a57dc776e1bdc7"}, + {file = "anyio-4.4.0.tar.gz", hash = "sha256:5aadc6a1bbb7cdb0bede386cac5e2940f5e2ff3aa20277e991cf028e0585ce94"}, +] + +[[package]] +name = "appnope" +version = "0.1.4" +requires_python = ">=3.6" +summary = "Disable App Nap on macOS >= 10.9" +groups = ["qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\" and platform_system == \"Darwin\"" +files = [ + {file = "appnope-0.1.4-py2.py3-none-any.whl", hash = "sha256:502575ee11cd7a28c0205f379b525beefebab9d161b7c964670864014ed7213c"}, + {file = "appnope-0.1.4.tar.gz", hash = "sha256:1de3860566df9caf38f01f86f65e0e13e379af54f9e4bee1e66b48f2efffd1ee"}, +] + +[[package]] +name = "argon2-cffi" +version = "23.1.0" +requires_python = ">=3.7" +summary = "Argon2 for Python" +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "argon2-cffi-bindings", + "typing-extensions; python_version < \"3.8\"", +] +files = [ + {file = "argon2_cffi-23.1.0-py3-none-any.whl", hash = "sha256:c670642b78ba29641818ab2e68bd4e6a78ba53b7eff7b4c3815ae16abf91c7ea"}, + {file = "argon2_cffi-23.1.0.tar.gz", hash = "sha256:879c3e79a2729ce768ebb7d36d4609e3a78a4ca2ec3a9f12286ca057e3d0db08"}, +] + +[[package]] +name = "argon2-cffi-bindings" +version = "21.2.0" +requires_python = ">=3.6" +summary = "Low-level CFFI bindings for Argon2" +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "cffi>=1.0.1", +] +files = [ + {file = "argon2-cffi-bindings-21.2.0.tar.gz", hash = "sha256:bb89ceffa6c791807d1305ceb77dbfacc5aa499891d2c55661c6459651fc39e3"}, + {file = "argon2_cffi_bindings-21.2.0-cp38-abi3-macosx_10_9_universal2.whl", hash = "sha256:e415e3f62c8d124ee16018e491a009937f8cf7ebf5eb430ffc5de21b900dad93"}, +] + +[[package]] +name = "arrow" +version = "1.3.0" +requires_python = ">=3.8" +summary = "Better dates & times for Python" +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "python-dateutil>=2.7.0", + "types-python-dateutil>=2.8.10", +] +files = [ + {file = "arrow-1.3.0-py3-none-any.whl", hash = "sha256:c728b120ebc00eb84e01882a6f5e7927a53960aa990ce7dd2b10f39005a67f80"}, + {file = "arrow-1.3.0.tar.gz", hash = "sha256:d4540617648cb5f895730f1ad8c82a65f2dad0166f57b75f3ca54759c4d67a85"}, +] + +[[package]] +name = "asttokens" +version = "2.4.1" +summary = "Annotate AST trees with source code positions" +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "six>=1.12.0", + "typing; python_version < \"3.5\"", +] +files = [ + {file = "asttokens-2.4.1-py2.py3-none-any.whl", hash = "sha256:051ed49c3dcae8913ea7cd08e46a606dba30b79993209636c4875bc1d637bc24"}, + {file = "asttokens-2.4.1.tar.gz", hash = "sha256:b03869718ba9a6eb027e134bfdf69f38a236d681c83c160d510768af11254ba0"}, +] + +[[package]] +name = "async-lru" +version = "2.0.4" +requires_python = ">=3.8" +summary = "Simple LRU cache for asyncio" +groups = ["qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "typing-extensions>=4.0.0; python_version < \"3.11\"", +] +files = [ + {file = "async-lru-2.0.4.tar.gz", hash = "sha256:b8a59a5df60805ff63220b2a0c5b5393da5521b113cd5465a44eb037d81a5627"}, + {file = "async_lru-2.0.4-py3-none-any.whl", hash = "sha256:ff02944ce3c288c5be660c42dbcca0742b32c3b279d6dceda655190240b99224"}, +] + +[[package]] +name = "async-timeout" +version = "4.0.3" +requires_python = ">=3.7" +summary = "Timeout context manager for asyncio programs" +groups = ["pyvista"] +marker = "python_version < \"3.11\" and python_version >= \"3.9\"" +dependencies = [ + "typing-extensions>=3.6.5; python_version < \"3.8\"", +] +files = [ + {file = "async-timeout-4.0.3.tar.gz", hash = "sha256:4640d96be84d82d02ed59ea2b7105a0f7b33abe8703703cd0ab0bf87c427522f"}, + {file = "async_timeout-4.0.3-py3-none-any.whl", hash = "sha256:7405140ff1230c310e51dc27b3145b9092d659ce68ff733fb0cefe3ee42be028"}, +] + +[[package]] +name = "attrs" +version = "24.2.0" +requires_python = ">=3.7" +summary = "Classes Without Boilerplate" +groups = ["docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "importlib-metadata; python_version < \"3.8\"", +] +files = [ + {file = "attrs-24.2.0-py3-none-any.whl", hash = "sha256:81921eb96de3191c8258c199618104dd27ac608d9366f5e35d011eae1867ede2"}, + {file = "attrs-24.2.0.tar.gz", hash = "sha256:5cfb1b9148b5b086569baec03f20d7b6bf3bcacc9a42bebf87ffaaca362f6346"}, +] + +[[package]] +name = "babel" +version = "2.16.0" +requires_python = ">=3.8" +summary = "Internationalization utilities" +groups = ["docs", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "pytz>=2015.7; python_version < \"3.9\"", +] +files = [ + {file = "babel-2.16.0-py3-none-any.whl", hash = "sha256:368b5b98b37c06b7daf6696391c3240c938b37767d4584413e8438c5c435fa8b"}, + {file = "babel-2.16.0.tar.gz", hash = "sha256:d1f3554ca26605fe173f3de0c65f750f5a42f924499bf134de6423582298e316"}, +] + +[[package]] +name = "beautifulsoup4" +version = "4.12.3" +requires_python = ">=3.6.0" +summary = "Screen-scraping library" +groups = ["docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "soupsieve>1.2", +] +files = [ + {file = "beautifulsoup4-4.12.3-py3-none-any.whl", hash = "sha256:b80878c9f40111313e55da8ba20bdba06d8fa3969fc68304167741bbf9e082ed"}, + {file = "beautifulsoup4-4.12.3.tar.gz", hash = "sha256:74e3d1928edc070d21748185c46e3fb33490f22f52a3addee9aee0f4f7781051"}, +] + +[[package]] +name = "bleach" +version = "6.2.0" +requires_python = ">=3.9" +summary = "An easy safelist-based HTML-sanitizing tool." +groups = ["docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "webencodings", +] +files = [ + {file = "bleach-6.2.0-py3-none-any.whl", hash = "sha256:117d9c6097a7c3d22fd578fcd8d35ff1e125df6736f554da4e432fdd63f31e5e"}, + {file = "bleach-6.2.0.tar.gz", hash = "sha256:123e894118b8a599fd80d3ec1a6d4cc7ce4e5882b1317a7e1ba69b56e95f991f"}, +] + +[[package]] +name = "bleach" +version = "6.2.0" +extras = ["css"] +requires_python = ">=3.9" +summary = "An easy safelist-based HTML-sanitizing tool." +groups = ["docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "bleach==6.2.0", + "tinycss2<1.5,>=1.1.0", +] +files = [ + {file = "bleach-6.2.0-py3-none-any.whl", hash = "sha256:117d9c6097a7c3d22fd578fcd8d35ff1e125df6736f554da4e432fdd63f31e5e"}, + {file = "bleach-6.2.0.tar.gz", hash = "sha256:123e894118b8a599fd80d3ec1a6d4cc7ce4e5882b1317a7e1ba69b56e95f991f"}, +] + +[[package]] +name = "cachetools" +version = "5.5.0" +requires_python = ">=3.7" +summary = "Extensible memoizing collections and decorators" +groups = ["qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "cachetools-5.5.0-py3-none-any.whl", hash = "sha256:02134e8439cdc2ffb62023ce1debca2944c3f289d66bb17ead3ab3dede74b292"}, + {file = "cachetools-5.5.0.tar.gz", hash = "sha256:2cc24fb4cbe39633fb7badd9db9ca6295d766d9c2995f245725a46715d050f2a"}, +] + +[[package]] +name = "certifi" +version = "2024.8.30" +requires_python = ">=3.6" +summary = "Python package for providing Mozilla's CA Bundle." +groups = ["docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "certifi-2024.8.30-py3-none-any.whl", hash = "sha256:922820b53db7a7257ffbda3f597266d435245903d80737e34f8a45ff3e3230d8"}, + {file = "certifi-2024.8.30.tar.gz", hash = "sha256:bec941d2aa8195e248a60b31ff9f0558284cf01a52591ceda73ea9afffd69fd9"}, +] + +[[package]] +name = "cffi" +version = "1.17.1" +requires_python = ">=3.8" +summary = "Foreign Function Interface for Python calling C code." +groups = ["docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "pycparser", +] +files = [ + {file = "cffi-1.17.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:8f2cdc858323644ab277e9bb925ad72ae0e67f69e804f4898c070998d50b1a67"}, + {file = "cffi-1.17.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:30c5e0cb5ae493c04c8b42916e52ca38079f1b235c2f8ae5f4527b963c401caf"}, + {file = "cffi-1.17.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:733e99bc2df47476e3848417c5a4540522f234dfd4ef3ab7fafdf555b082ec0c"}, + {file = "cffi-1.17.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:28b16024becceed8c6dfbc75629e27788d8a3f9030691a1dbf9821a128b22c36"}, + {file = "cffi-1.17.1.tar.gz", hash = "sha256:1c39c6016c32bc48dd54561950ebd6836e1670f2ae46128f67cf49e789c52824"}, +] + +[[package]] +name = "cfgv" +version = "3.4.0" +requires_python = ">=3.8" +summary = "Validate configuration and produce human readable error messages." +groups = ["qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "cfgv-3.4.0-py2.py3-none-any.whl", hash = "sha256:b7265b1f29fd3316bfcd2b330d63d024f2bfd8bcb8b0272f8e19a504856c48f9"}, + {file = "cfgv-3.4.0.tar.gz", hash = "sha256:e52591d4c5f5dead8e0f673fb16db7949d2cfb3f7da4582893288f0ded8fe560"}, +] + +[[package]] +name = "chardet" +version = "5.2.0" +requires_python = ">=3.7" +summary = "Universal encoding detector for Python 3" +groups = ["qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "chardet-5.2.0-py3-none-any.whl", hash = "sha256:e1cf59446890a00105fe7b7912492ea04b6e6f06d4b742b2c788469e34c82970"}, + {file = "chardet-5.2.0.tar.gz", hash = "sha256:1b3b6ff479a8c414bc3fa2c0852995695c4a026dcd6d0633b2dd092ca39c1cf7"}, +] + +[[package]] +name = "charset-normalizer" +version = "3.3.2" +requires_python = ">=3.7.0" +summary = "The Real First Universal Charset Detector. Open, modern and actively maintained alternative to Chardet." +groups = ["docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "charset-normalizer-3.3.2.tar.gz", hash = "sha256:f30c3cb33b24454a82faecaf01b19c18562b1e89558fb6c56de4d9118a032fd5"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:25baf083bf6f6b341f4121c2f3c548875ee6f5339300e08be3f2b2ba1721cdd3"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:9063e24fdb1e498ab71cb7419e24622516c4a04476b17a2dab57e8baa30d6e03"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:802fe99cca7457642125a8a88a084cef28ff0cf9407060f7b93dca5aa25480db"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:549a3a73da901d5bc3ce8d24e0600d1fa85524c10287f6004fbab87672bf3e1e"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:0b2b64d2bb6d3fb9112bafa732def486049e63de9618b5843bcdd081d8144cd8"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:55086ee1064215781fff39a1af09518bc9255b50d6333f2e4c74ca09fac6a8f6"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:c235ebd9baae02f1b77bcea61bce332cb4331dc3617d254df3323aa01ab47bd4"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:68d1f8a9e9e37c1223b656399be5d6b448dea850bed7d0f87a8311f1ff3dabb0"}, + {file = "charset_normalizer-3.3.2-py3-none-any.whl", hash = "sha256:3e4d1f6587322d2788836a99c69062fbb091331ec940e02d12d179c1d53e25fc"}, +] + +[[package]] +name = "cmocean" +version = "4.0.3" +requires_python = ">=3.8" +summary = "Colormaps for Oceanography" +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "matplotlib", + "numpy", + "packaging", +] +files = [ + {file = "cmocean-4.0.3-py3-none-any.whl", hash = "sha256:f2fc1d5e349db122ee0c9eac80bba969aa92dd2806548fce58dc8bef962f309e"}, + {file = "cmocean-4.0.3.tar.gz", hash = "sha256:37868399fb5f41b4eac596e69803f9bfaea49946514dfb2e7f48886854250d7c"}, +] + +[[package]] +name = "colorama" +version = "0.4.6" +requires_python = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,!=3.6.*,>=2.7" +summary = "Cross-platform colored terminal text." +groups = ["qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6"}, + {file = "colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44"}, +] + +[[package]] +name = "colorcet" +version = "3.1.0" +requires_python = ">=3.7" +summary = "Collection of perceptually uniform colormaps" +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "colorcet-3.1.0-py3-none-any.whl", hash = "sha256:2a7d59cc8d0f7938eeedd08aad3152b5319b4ba3bcb7a612398cc17a384cb296"}, + {file = "colorcet-3.1.0.tar.gz", hash = "sha256:2921b3cd81a2288aaf2d63dbc0ce3c26dcd882e8c389cc505d6886bf7aa9a4eb"}, +] + +[[package]] +name = "comm" +version = "0.2.2" +requires_python = ">=3.8" +summary = "Jupyter Python Comm implementation, for usage in ipykernel, xeus-python etc." +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "traitlets>=4", +] +files = [ + {file = "comm-0.2.2-py3-none-any.whl", hash = "sha256:e6fb86cb70ff661ee8c9c14e7d36d6de3b4066f1441be4063df9c5009f0a64d3"}, + {file = "comm-0.2.2.tar.gz", hash = "sha256:3fd7a84065306e07bea1773df6eb8282de51ba82f77c72f9c85716ab11fe980e"}, +] + +[[package]] +name = "contourpy" +version = "1.3.0" +requires_python = ">=3.9" +summary = "Python library for calculating contours of 2D quadrilateral grids" +groups = ["default", "pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "numpy>=1.23", +] +files = [ + {file = "contourpy-1.3.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:76c905ef940a4474a6289c71d53122a4f77766eef23c03cd57016ce19d0f7b42"}, + {file = "contourpy-1.3.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:834e0cfe17ba12f79963861e0f908556b2cedd52e1f75e6578801febcc6a9f49"}, + {file = "contourpy-1.3.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:da84c537cb8b97d153e9fb208c221c45605f73147bd4cadd23bdae915042aad6"}, + {file = "contourpy-1.3.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:e8134301d7e204c88ed7ab50028ba06c683000040ede1d617298611f9dc6240c"}, + {file = "contourpy-1.3.0.tar.gz", hash = "sha256:7ffa0db17717a8ffb127efd0c95a4362d996b892c2904db72428d5b52e1938a4"}, +] + +[[package]] +name = "coverage" +version = "7.6.1" +requires_python = ">=3.8" +summary = "Code coverage measurement for Python" +groups = ["qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "coverage-7.6.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:cf4b19715bccd7ee27b6b120e7e9dd56037b9c0681dcc1adc9ba9db3d417fa36"}, + {file = "coverage-7.6.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:ed37bd3c3b063412f7620464a9ac1314d33100329f39799255fb8d3027da50d3"}, + {file = "coverage-7.6.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:5621a9175cf9d0b0c84c2ef2b12e9f5f5071357c4d2ea6ca1cf01814f45d2391"}, + {file = "coverage-7.6.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:547f45fa1a93154bd82050a7f3cddbc1a7a4dd2a9bf5cb7d06f4ae29fe94eaf8"}, + {file = "coverage-7.6.1-pp38.pp39.pp310-none-any.whl", hash = "sha256:e9a6e0eb86070e8ccaedfbd9d38fec54864f3125ab95419970575b42af7541df"}, + {file = "coverage-7.6.1.tar.gz", hash = "sha256:953510dfb7b12ab69d20135a0662397f077c59b1e6379a768e97c59d852ee51d"}, +] + +[[package]] +name = "coverage" +version = "7.6.1" +extras = ["toml"] +requires_python = ">=3.8" +summary = "Code coverage measurement for Python" +groups = ["qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "coverage==7.6.1", + "tomli; python_full_version <= \"3.11.0a6\"", +] +files = [ + {file = "coverage-7.6.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:cf4b19715bccd7ee27b6b120e7e9dd56037b9c0681dcc1adc9ba9db3d417fa36"}, + {file = "coverage-7.6.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:ed37bd3c3b063412f7620464a9ac1314d33100329f39799255fb8d3027da50d3"}, + {file = "coverage-7.6.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:5621a9175cf9d0b0c84c2ef2b12e9f5f5071357c4d2ea6ca1cf01814f45d2391"}, + {file = "coverage-7.6.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:547f45fa1a93154bd82050a7f3cddbc1a7a4dd2a9bf5cb7d06f4ae29fe94eaf8"}, + {file = "coverage-7.6.1-pp38.pp39.pp310-none-any.whl", hash = "sha256:e9a6e0eb86070e8ccaedfbd9d38fec54864f3125ab95419970575b42af7541df"}, + {file = "coverage-7.6.1.tar.gz", hash = "sha256:953510dfb7b12ab69d20135a0662397f077c59b1e6379a768e97c59d852ee51d"}, +] + +[[package]] +name = "cycler" +version = "0.12.1" +requires_python = ">=3.8" +summary = "Composable style cycles" +groups = ["default", "pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "cycler-0.12.1-py3-none-any.whl", hash = "sha256:85cef7cff222d8644161529808465972e51340599459b8ac3ccbac5a854e0d30"}, + {file = "cycler-0.12.1.tar.gz", hash = "sha256:88bb128f02ba341da8ef447245a9e138fae777f6a23943da4540077d3601eb1c"}, +] + +[[package]] +name = "debugpy" +version = "1.8.5" +requires_python = ">=3.8" +summary = "An implementation of the Debug Adapter Protocol for Python" +groups = ["qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "debugpy-1.8.5-cp311-cp311-macosx_12_0_universal2.whl", hash = "sha256:606bccba19f7188b6ea9579c8a4f5a5364ecd0bf5a0659c8a5d0e10dcee3032a"}, + {file = "debugpy-1.8.5-cp312-cp312-macosx_12_0_universal2.whl", hash = "sha256:5b5c770977c8ec6c40c60d6f58cacc7f7fe5a45960363d6974ddb9b62dbee156"}, + {file = "debugpy-1.8.5-py2.py3-none-any.whl", hash = "sha256:55919dce65b471eff25901acf82d328bbd5b833526b6c1364bd5133754777a44"}, + {file = "debugpy-1.8.5.zip", hash = "sha256:b2112cfeb34b4507399d298fe7023a16656fc553ed5246536060ca7bd0e668d0"}, +] + +[[package]] +name = "decorator" +version = "5.1.1" +requires_python = ">=3.5" +summary = "Decorators for Humans" +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "decorator-5.1.1-py3-none-any.whl", hash = "sha256:b8c3f85900b9dc423225913c5aace94729fe1fa9763b38939a95226f02d37186"}, + {file = "decorator-5.1.1.tar.gz", hash = "sha256:637996211036b6385ef91435e4fae22989472f9d571faba8927ba8253acbc330"}, +] + +[[package]] +name = "defusedxml" +version = "0.7.1" +requires_python = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*" +summary = "XML bomb protection for Python stdlib modules" +groups = ["docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "defusedxml-0.7.1-py2.py3-none-any.whl", hash = "sha256:a352e7e428770286cc899e2542b6cdaedb2b4953ff269a210103ec58f6198a61"}, + {file = "defusedxml-0.7.1.tar.gz", hash = "sha256:1bb3032db185915b62d7c6209c5a8792be6a32ab2fedacc84e01b52c51aa3e69"}, +] + +[[package]] +name = "distlib" +version = "0.3.8" +summary = "Distribution utilities" +groups = ["qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "distlib-0.3.8-py2.py3-none-any.whl", hash = "sha256:034db59a0b96f8ca18035f36290806a9a6e6bd9d1ff91e45a7f172eb17e51784"}, + {file = "distlib-0.3.8.tar.gz", hash = "sha256:1530ea13e350031b6312d8580ddb6b27a104275a31106523b8f123787f494f64"}, +] + +[[package]] +name = "docutils" +version = "0.20.1" +requires_python = ">=3.7" +summary = "Docutils -- Python Documentation Utilities" +groups = ["docs"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "docutils-0.20.1-py3-none-any.whl", hash = "sha256:96f387a2c5562db4476f09f13bbab2192e764cac08ebbf3a34a95d9b1e4a59d6"}, + {file = "docutils-0.20.1.tar.gz", hash = "sha256:f08a4e276c3a1583a86dce3e34aba3fe04d02bba2dd51ed16106244e8a923e3b"}, +] + +[[package]] +name = "et-xmlfile" +version = "1.1.0" +requires_python = ">=3.6" +summary = "An implementation of lxml.xmlfile for the standard library" +groups = ["openpyxl"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "et_xmlfile-1.1.0-py3-none-any.whl", hash = "sha256:a2ba85d1d6a74ef63837eed693bcb89c3f752169b0e3e7ae5b16ca5e1b3deada"}, + {file = "et_xmlfile-1.1.0.tar.gz", hash = "sha256:8eb9e2bc2f8c97e37a2dc85a09ecdcdec9d8a396530a6d5a33b30b9a92da0c5c"}, +] + +[[package]] +name = "exceptiongroup" +version = "1.2.2" +requires_python = ">=3.7" +summary = "Backport of PEP 654 (exception groups)" +groups = ["pyvista", "qa"] +marker = "python_version < \"3.11\" and python_version >= \"3.9\"" +files = [ + {file = "exceptiongroup-1.2.2-py3-none-any.whl", hash = "sha256:3111b9d131c238bec2f8f516e123e14ba243563fb135d3fe885990585aa7795b"}, + {file = "exceptiongroup-1.2.2.tar.gz", hash = "sha256:47c2edf7c6738fafb49fd34290706d1a1a2f4d1c6df275526b62cbb4aa5393cc"}, +] + +[[package]] +name = "executing" +version = "2.1.0" +requires_python = ">=3.8" +summary = "Get the currently executing AST node of a frame, and other information" +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "executing-2.1.0-py2.py3-none-any.whl", hash = "sha256:8d63781349375b5ebccc3142f4b30350c0cd9c79f921cde38be2be4637e98eaf"}, + {file = "executing-2.1.0.tar.gz", hash = "sha256:8ea27ddd260da8150fa5a708269c4a10e76161e2496ec3e587da9e3c0fe4b9ab"}, +] + +[[package]] +name = "fastjsonschema" +version = "2.20.0" +summary = "Fastest Python implementation of JSON schema" +groups = ["docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "fastjsonschema-2.20.0-py3-none-any.whl", hash = "sha256:5875f0b0fa7a0043a91e93a9b8f793bcbbba9691e7fd83dca95c28ba26d21f0a"}, + {file = "fastjsonschema-2.20.0.tar.gz", hash = "sha256:3d48fc5300ee96f5d116f10fe6f28d938e6008f59a6a025c2649475b87f76a23"}, +] + +[[package]] +name = "filelock" +version = "3.17.0" +requires_python = ">=3.9" +summary = "A platform independent file lock." +groups = ["qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "filelock-3.17.0-py3-none-any.whl", hash = "sha256:533dc2f7ba78dc2f0f531fc6c4940addf7b70a481e269a5a3b93be94ffbe8338"}, + {file = "filelock-3.17.0.tar.gz", hash = "sha256:ee4e77401ef576ebb38cd7f13b9b28893194acc20a8e68e18730ba9c0e54660e"}, +] + +[[package]] +name = "fonttools" +version = "4.53.1" +requires_python = ">=3.8" +summary = "Tools to manipulate font files" +groups = ["default", "pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "fonttools-4.53.1-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:0679a30b59d74b6242909945429dbddb08496935b82f91ea9bf6ad240ec23397"}, + {file = "fonttools-4.53.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:e8bf06b94694251861ba7fdeea15c8ec0967f84c3d4143ae9daf42bbc7717fe3"}, + {file = "fonttools-4.53.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:da33440b1413bad53a8674393c5d29ce64d8c1a15ef8a77c642ffd900d07bfe1"}, + {file = "fonttools-4.53.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:5ff7e5e9bad94e3a70c5cd2fa27f20b9bb9385e10cddab567b85ce5d306ea923"}, + {file = "fonttools-4.53.1-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:d92d3c2a1b39631a6131c2fa25b5406855f97969b068e7e08413325bc0afba58"}, + {file = "fonttools-4.53.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:3b3c8ebafbee8d9002bd8f1195d09ed2bd9ff134ddec37ee8f6a6375e6a4f0e8"}, + {file = "fonttools-4.53.1-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:75a157d8d26c06e64ace9df037ee93a4938a4606a38cb7ffaf6635e60e253b7a"}, + {file = "fonttools-4.53.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:4824c198f714ab5559c5be10fd1adf876712aa7989882a4ec887bf1ef3e00e31"}, + {file = "fonttools-4.53.1-py3-none-any.whl", hash = "sha256:f1f8758a2ad110bd6432203a344269f445a2907dc24ef6bccfd0ac4e14e0d71d"}, + {file = "fonttools-4.53.1.tar.gz", hash = "sha256:e128778a8e9bc11159ce5447f76766cefbd876f44bd79aff030287254e4752c4"}, +] + +[[package]] +name = "fqdn" +version = "1.5.1" +requires_python = ">=2.7, !=3.0, !=3.1, !=3.2, !=3.3, !=3.4, <4" +summary = "Validates fully-qualified domain names against RFC 1123, so that they are acceptable to modern bowsers" +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "cached-property>=1.3.0; python_version < \"3.8\"", +] +files = [ + {file = "fqdn-1.5.1-py3-none-any.whl", hash = "sha256:3a179af3761e4df6eb2e026ff9e1a3033d3587bf980a0b1b2e1e5d08d7358014"}, + {file = "fqdn-1.5.1.tar.gz", hash = "sha256:105ed3677e767fb5ca086a0c1f4bb66ebc3c100be518f0e0d755d9eae164d89f"}, +] + +[[package]] +name = "frozenlist" +version = "1.4.1" +requires_python = ">=3.8" +summary = "A list-like structure which implements collections.abc.MutableSequence" +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "frozenlist-1.4.1-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:f9aa1878d1083b276b0196f2dfbe00c9b7e752475ed3b682025ff20c1c1f51ac"}, + {file = "frozenlist-1.4.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:74fb4bee6880b529a0c6560885fce4dc95936920f9f20f53d99a213f7bf66776"}, + {file = "frozenlist-1.4.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:a0cb6f11204443f27a1628b0e460f37fb30f624be6051d490fa7d7e26d4af3d0"}, + {file = "frozenlist-1.4.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:fde5bd59ab5357e3853313127f4d3565fc7dad314a74d7b5d43c22c6a5ed2ced"}, + {file = "frozenlist-1.4.1-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:1979bc0aeb89b33b588c51c54ab0161791149f2461ea7c7c946d95d5f93b56ae"}, + {file = "frozenlist-1.4.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:c9c92be9fd329ac801cc420e08452b70e7aeab94ea4233a4804f0915c14eba9b"}, + {file = "frozenlist-1.4.1-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:bfa4a17e17ce9abf47a74ae02f32d014c5e9404b6d9ac7f729e01562bbee601e"}, + {file = "frozenlist-1.4.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:c99169d4ff810155ca50b4da3b075cbde79752443117d89429595c2e8e37fed8"}, + {file = "frozenlist-1.4.1-py3-none-any.whl", hash = "sha256:04ced3e6a46b4cfffe20f9ae482818e34eba9b5fb0ce4056e4cc9b6e212d09b7"}, + {file = "frozenlist-1.4.1.tar.gz", hash = "sha256:c037a86e8513059a2613aaba4d817bb90b9d9b6b69aace3ce9c877e8c8ed402b"}, +] + +[[package]] +name = "ghp-import" +version = "2.1.0" +summary = "Copy your docs directly to the gh-pages branch." +groups = ["docs"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "python-dateutil>=2.8.1", +] +files = [ + {file = "ghp-import-2.1.0.tar.gz", hash = "sha256:9c535c4c61193c2df8871222567d7fd7e5014d835f97dc7b7439069e2413d343"}, + {file = "ghp_import-2.1.0-py3-none-any.whl", hash = "sha256:8337dd7b50877f163d4c0289bc1f1c7f127550241988d568c1db512c4324a619"}, +] + +[[package]] +name = "h11" +version = "0.14.0" +requires_python = ">=3.7" +summary = "A pure-Python, bring-your-own-I/O implementation of HTTP/1.1" +groups = ["qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "typing-extensions; python_version < \"3.8\"", +] +files = [ + {file = "h11-0.14.0-py3-none-any.whl", hash = "sha256:e3fe4ac4b851c468cc8363d500db52c2ead036020723024a109d37346efaa761"}, + {file = "h11-0.14.0.tar.gz", hash = "sha256:8f19fbbe99e72420ff35c00b27a34cb9937e902a8b810e2c88300c6f0a3b699d"}, +] + +[[package]] +name = "httpcore" +version = "1.0.5" +requires_python = ">=3.8" +summary = "A minimal low-level HTTP client." +groups = ["qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "certifi", + "h11<0.15,>=0.13", +] +files = [ + {file = "httpcore-1.0.5-py3-none-any.whl", hash = "sha256:421f18bac248b25d310f3cacd198d55b8e6125c107797b609ff9b7a6ba7991b5"}, + {file = "httpcore-1.0.5.tar.gz", hash = "sha256:34a38e2f9291467ee3b44e89dd52615370e152954ba21721378a87b2960f7a61"}, +] + +[[package]] +name = "httpx" +version = "0.27.2" +requires_python = ">=3.8" +summary = "The next generation HTTP client." +groups = ["qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "anyio", + "certifi", + "httpcore==1.*", + "idna", + "sniffio", +] +files = [ + {file = "httpx-0.27.2-py3-none-any.whl", hash = "sha256:7bb2708e112d8fdd7829cd4243970f0c223274051cb35ee80c03301ee29a3df0"}, + {file = "httpx-0.27.2.tar.gz", hash = "sha256:f7c2be1d2f3c3c3160d441802406b206c2b76f5947b11115e6df10c6c65e66c2"}, +] + +[[package]] +name = "identify" +version = "2.6.0" +requires_python = ">=3.8" +summary = "File identification library for Python" +groups = ["qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "identify-2.6.0-py2.py3-none-any.whl", hash = "sha256:e79ae4406387a9d300332b5fd366d8994f1525e8414984e1a59e058b2eda2dd0"}, + {file = "identify-2.6.0.tar.gz", hash = "sha256:cb171c685bdc31bcc4c1734698736a7d5b6c8bf2e0c15117f4d469c8640ae5cf"}, +] + +[[package]] +name = "idna" +version = "3.8" +requires_python = ">=3.6" +summary = "Internationalized Domain Names in Applications (IDNA)" +groups = ["docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "idna-3.8-py3-none-any.whl", hash = "sha256:050b4e5baadcd44d760cedbd2b8e639f2ff89bbc7a5730fcc662954303377aac"}, + {file = "idna-3.8.tar.gz", hash = "sha256:d838c2c0ed6fced7693d5e8ab8e734d5f8fda53a039c0164afb0b82e771e3603"}, +] + +[[package]] +name = "imageio" +version = "2.35.1" +requires_python = ">=3.8" +summary = "Library for reading and writing a wide range of image, video, scientific, and volumetric data formats." +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "numpy", + "pillow>=8.3.2", +] +files = [ + {file = "imageio-2.35.1-py3-none-any.whl", hash = "sha256:6eb2e5244e7a16b85c10b5c2fe0f7bf961b40fcb9f1a9fd1bd1d2c2f8fb3cd65"}, + {file = "imageio-2.35.1.tar.gz", hash = "sha256:4952dfeef3c3947957f6d5dedb1f4ca31c6e509a476891062396834048aeed2a"}, +] + +[[package]] +name = "imagesize" +version = "1.4.1" +requires_python = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*" +summary = "Getting image size from png/jpeg/jpeg2000/gif file" +groups = ["docs"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "imagesize-1.4.1-py2.py3-none-any.whl", hash = "sha256:0d8d18d08f840c19d0ee7ca1fd82490fdc3729b7ac93f49870406ddde8ef8d8b"}, + {file = "imagesize-1.4.1.tar.gz", hash = "sha256:69150444affb9cb0d5cc5a92b3676f0b2fb7cd9ae39e947a5e11a36b4497cd4a"}, +] + +[[package]] +name = "importlib-metadata" +version = "8.5.0" +requires_python = ">=3.8" +summary = "Read metadata from Python packages" +groups = ["docs", "pyvista", "qa"] +marker = "python_version < \"3.10\" and python_version >= \"3.9\"" +dependencies = [ + "typing-extensions>=3.6.4; python_version < \"3.8\"", + "zipp>=3.20", +] +files = [ + {file = "importlib_metadata-8.5.0-py3-none-any.whl", hash = "sha256:45e54197d28b7a7f1559e60b95e7c567032b602131fbd588f1497f47880aa68b"}, + {file = "importlib_metadata-8.5.0.tar.gz", hash = "sha256:71522656f0abace1d072b9e5481a48f07c138e00f079c38c8f883823f9c26bd7"}, +] + +[[package]] +name = "importlib-resources" +version = "6.4.5" +requires_python = ">=3.8" +summary = "Read resources from Python packages" +groups = ["default", "pyvista"] +marker = "python_version < \"3.10\" and python_version >= \"3.9\"" +dependencies = [ + "zipp>=3.1.0; python_version < \"3.10\"", +] +files = [ + {file = "importlib_resources-6.4.5-py3-none-any.whl", hash = "sha256:ac29d5f956f01d5e4bb63102a5a19957f1b9175e45649977264a1416783bb717"}, + {file = "importlib_resources-6.4.5.tar.gz", hash = "sha256:980862a1d16c9e147a59603677fa2aa5fd82b87f223b6cb870695bcfce830065"}, +] + +[[package]] +name = "iniconfig" +version = "2.0.0" +requires_python = ">=3.7" +summary = "brain-dead simple config-ini parsing" +groups = ["qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "iniconfig-2.0.0-py3-none-any.whl", hash = "sha256:b6a85871a79d2e3b22d2d1b94ac2824226a63c6b741c88f7ae975f18b6778374"}, + {file = "iniconfig-2.0.0.tar.gz", hash = "sha256:2d91e135bf72d31a410b17c16da610a82cb55f6b0477d1a902134b24a455b8b3"}, +] + +[[package]] +name = "ipdb" +version = "0.13.13" +requires_python = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*" +summary = "IPython-enabled pdb" +groups = ["qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "decorator; python_version == \"3.5\"", + "decorator; python_version == \"3.6\"", + "decorator; python_version > \"3.6\" and python_version < \"3.11\"", + "decorator; python_version >= \"3.11\"", + "decorator<5.0.0; python_version == \"2.7\"", + "decorator<5.0.0; python_version == \"3.4\"", + "ipython<6.0.0,>=5.1.0; python_version == \"2.7\"", + "ipython<7.0.0,>=6.0.0; python_version == \"3.4\"", + "ipython<7.10.0,>=7.0.0; python_version == \"3.5\"", + "ipython<7.17.0,>=7.16.3; python_version == \"3.6\"", + "ipython>=7.31.1; python_version > \"3.6\" and python_version < \"3.11\"", + "ipython>=7.31.1; python_version >= \"3.11\"", + "pathlib; python_version == \"2.7\"", + "toml>=0.10.2; python_version == \"2.7\"", + "toml>=0.10.2; python_version == \"3.4\"", + "toml>=0.10.2; python_version == \"3.5\"", + "tomli; python_version == \"3.6\"", + "tomli; python_version > \"3.6\" and python_version < \"3.11\"", +] +files = [ + {file = "ipdb-0.13.13-py3-none-any.whl", hash = "sha256:45529994741c4ab6d2388bfa5d7b725c2cf7fe9deffabdb8a6113aa5ed449ed4"}, + {file = "ipdb-0.13.13.tar.gz", hash = "sha256:e3ac6018ef05126d442af680aad863006ec19d02290561ac88b8b1c0b0cfc726"}, +] + +[[package]] +name = "ipykernel" +version = "6.29.5" +requires_python = ">=3.8" +summary = "IPython Kernel for Jupyter" +groups = ["qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "appnope; platform_system == \"Darwin\"", + "comm>=0.1.1", + "debugpy>=1.6.5", + "ipython>=7.23.1", + "jupyter-client>=6.1.12", + "jupyter-core!=5.0.*,>=4.12", + "matplotlib-inline>=0.1", + "nest-asyncio", + "packaging", + "psutil", + "pyzmq>=24", + "tornado>=6.1", + "traitlets>=5.4.0", +] +files = [ + {file = "ipykernel-6.29.5-py3-none-any.whl", hash = "sha256:afdb66ba5aa354b09b91379bac28ae4afebbb30e8b39510c9690afb7a10421b5"}, + {file = "ipykernel-6.29.5.tar.gz", hash = "sha256:f093a22c4a40f8828f8e330a9c297cb93dcab13bd9678ded6de8e5cf81c56215"}, +] + +[[package]] +name = "ipython" +version = "8.18.1" +requires_python = ">=3.9" +summary = "IPython: Productive Interactive Computing" +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "colorama; sys_platform == \"win32\"", + "decorator", + "exceptiongroup; python_version < \"3.11\"", + "jedi>=0.16", + "matplotlib-inline", + "pexpect>4.3; sys_platform != \"win32\"", + "prompt-toolkit<3.1.0,>=3.0.41", + "pygments>=2.4.0", + "stack-data", + "traitlets>=5", + "typing-extensions; python_version < \"3.10\"", +] +files = [ + {file = "ipython-8.18.1-py3-none-any.whl", hash = "sha256:e8267419d72d81955ec1177f8a29aaa90ac80ad647499201119e2f05e99aa397"}, + {file = "ipython-8.18.1.tar.gz", hash = "sha256:ca6f079bb33457c66e233e4580ebfc4128855b4cf6370dddd73842a9563e8a27"}, +] + +[[package]] +name = "ipywidgets" +version = "8.1.5" +requires_python = ">=3.7" +summary = "Jupyter interactive widgets" +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "comm>=0.1.3", + "ipython>=6.1.0", + "jupyterlab-widgets~=3.0.12", + "traitlets>=4.3.1", + "widgetsnbextension~=4.0.12", +] +files = [ + {file = "ipywidgets-8.1.5-py3-none-any.whl", hash = "sha256:3290f526f87ae6e77655555baba4f36681c555b8bdbbff430b70e52c34c86245"}, + {file = "ipywidgets-8.1.5.tar.gz", hash = "sha256:870e43b1a35656a80c18c9503bbf2d16802db1cb487eec6fab27d683381dde17"}, +] + +[[package]] +name = "isoduration" +version = "20.11.0" +requires_python = ">=3.7" +summary = "Operations with ISO 8601 durations" +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "arrow>=0.15.0", +] +files = [ + {file = "isoduration-20.11.0-py3-none-any.whl", hash = "sha256:b2904c2a4228c3d44f409c8ae8e2370eb21a26f7ac2ec5446df141dde3452042"}, + {file = "isoduration-20.11.0.tar.gz", hash = "sha256:ac2f9015137935279eac671f94f89eb00584f940f5dc49462a0c4ee692ba1bd9"}, +] + +[[package]] +name = "jedi" +version = "0.19.1" +requires_python = ">=3.6" +summary = "An autocompletion tool for Python that can be used for text editors." +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "parso<0.9.0,>=0.8.3", +] +files = [ + {file = "jedi-0.19.1-py2.py3-none-any.whl", hash = "sha256:e983c654fe5c02867aef4cdfce5a2fbb4a50adc0af145f70504238f18ef5e7e0"}, + {file = "jedi-0.19.1.tar.gz", hash = "sha256:cf0496f3651bc65d7174ac1b7d043eff454892c708a87d1b683e57b569927ffd"}, +] + +[[package]] +name = "jinja2" +version = "3.1.5" +requires_python = ">=3.7" +summary = "A very fast and expressive template engine." +groups = ["docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "MarkupSafe>=2.0", +] +files = [ + {file = "jinja2-3.1.5-py3-none-any.whl", hash = "sha256:aba0f4dc9ed8013c424088f68a5c226f7d6097ed89b246d7749c2ec4175c6adb"}, + {file = "jinja2-3.1.5.tar.gz", hash = "sha256:8fefff8dc3034e27bb80d67c671eb8a9bc424c0ef4c0826edbff304cceff43bb"}, +] + +[[package]] +name = "json5" +version = "0.9.25" +requires_python = ">=3.8" +summary = "A Python implementation of the JSON5 data format." +groups = ["qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "json5-0.9.25-py3-none-any.whl", hash = "sha256:34ed7d834b1341a86987ed52f3f76cd8ee184394906b6e22a1e0deb9ab294e8f"}, + {file = "json5-0.9.25.tar.gz", hash = "sha256:548e41b9be043f9426776f05df8635a00fe06104ea51ed24b67f908856e151ae"}, +] + +[[package]] +name = "jsonpointer" +version = "3.0.0" +requires_python = ">=3.7" +summary = "Identify specific nodes in a JSON document (RFC 6901) " +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "jsonpointer-3.0.0-py2.py3-none-any.whl", hash = "sha256:13e088adc14fca8b6aa8177c044e12701e6ad4b28ff10e65f2267a90109c9942"}, + {file = "jsonpointer-3.0.0.tar.gz", hash = "sha256:2b2d729f2091522d61c3b31f82e11870f60b68f43fbc705cb76bf4b832af59ef"}, +] + +[[package]] +name = "jsonschema" +version = "4.23.0" +requires_python = ">=3.8" +summary = "An implementation of JSON Schema validation for Python" +groups = ["docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "attrs>=22.2.0", + "importlib-resources>=1.4.0; python_version < \"3.9\"", + "jsonschema-specifications>=2023.03.6", + "pkgutil-resolve-name>=1.3.10; python_version < \"3.9\"", + "referencing>=0.28.4", + "rpds-py>=0.7.1", +] +files = [ + {file = "jsonschema-4.23.0-py3-none-any.whl", hash = "sha256:fbadb6f8b144a8f8cf9f0b89ba94501d143e50411a1278633f56a7acf7fd5566"}, + {file = "jsonschema-4.23.0.tar.gz", hash = "sha256:d71497fef26351a33265337fa77ffeb82423f3ea21283cd9467bb03999266bc4"}, +] + +[[package]] +name = "jsonschema-specifications" +version = "2023.12.1" +requires_python = ">=3.8" +summary = "The JSON Schema meta-schemas and vocabularies, exposed as a Registry" +groups = ["docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "importlib-resources>=1.4.0; python_version < \"3.9\"", + "referencing>=0.31.0", +] +files = [ + {file = "jsonschema_specifications-2023.12.1-py3-none-any.whl", hash = "sha256:87e4fdf3a94858b8a2ba2778d9ba57d8a9cafca7c7489c46ba0d30a8bc6a9c3c"}, + {file = "jsonschema_specifications-2023.12.1.tar.gz", hash = "sha256:48a76787b3e70f5ed53f1160d2b81f586e4ca6d1548c5de7085d1682674764cc"}, +] + +[[package]] +name = "jsonschema" +version = "4.23.0" +extras = ["format-nongpl"] +requires_python = ">=3.8" +summary = "An implementation of JSON Schema validation for Python" +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "fqdn", + "idna", + "isoduration", + "jsonpointer>1.13", + "jsonschema==4.23.0", + "rfc3339-validator", + "rfc3986-validator>0.1.0", + "uri-template", + "webcolors>=24.6.0", +] +files = [ + {file = "jsonschema-4.23.0-py3-none-any.whl", hash = "sha256:fbadb6f8b144a8f8cf9f0b89ba94501d143e50411a1278633f56a7acf7fd5566"}, + {file = "jsonschema-4.23.0.tar.gz", hash = "sha256:d71497fef26351a33265337fa77ffeb82423f3ea21283cd9467bb03999266bc4"}, +] + +[[package]] +name = "jupyter-client" +version = "8.6.3" +requires_python = ">=3.8" +summary = "Jupyter protocol implementation and client libraries" +groups = ["docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "importlib-metadata>=4.8.3; python_version < \"3.10\"", + "jupyter-core!=5.0.*,>=4.12", + "python-dateutil>=2.8.2", + "pyzmq>=23.0", + "tornado>=6.2", + "traitlets>=5.3", +] +files = [ + {file = "jupyter_client-8.6.3-py3-none-any.whl", hash = "sha256:e8a19cc986cc45905ac3362915f410f3af85424b4c0905e94fa5f2cb08e8f23f"}, + {file = "jupyter_client-8.6.3.tar.gz", hash = "sha256:35b3a0947c4a6e9d589eb97d7d4cd5e90f910ee73101611f01283732bd6d9419"}, +] + +[[package]] +name = "jupyter-core" +version = "5.7.2" +requires_python = ">=3.8" +summary = "Jupyter core package. A base package on which Jupyter projects rely." +groups = ["docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "platformdirs>=2.5", + "pywin32>=300; sys_platform == \"win32\" and platform_python_implementation != \"PyPy\"", + "traitlets>=5.3", +] +files = [ + {file = "jupyter_core-5.7.2-py3-none-any.whl", hash = "sha256:4f7315d2f6b4bcf2e3e7cb6e46772eba760ae459cd1f59d29eb57b0a01bd7409"}, + {file = "jupyter_core-5.7.2.tar.gz", hash = "sha256:aa5f8d32bbf6b431ac830496da7392035d6f61b4f54872f15c4bd2a9c3f536d9"}, +] + +[[package]] +name = "jupyter-events" +version = "0.12.0" +requires_python = ">=3.9" +summary = "Jupyter Event System library" +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "jsonschema[format-nongpl]>=4.18.0", + "packaging", + "python-json-logger>=2.0.4", + "pyyaml>=5.3", + "referencing", + "rfc3339-validator", + "rfc3986-validator>=0.1.1", + "traitlets>=5.3", +] +files = [ + {file = "jupyter_events-0.12.0-py3-none-any.whl", hash = "sha256:6464b2fa5ad10451c3d35fabc75eab39556ae1e2853ad0c0cc31b656731a97fb"}, + {file = "jupyter_events-0.12.0.tar.gz", hash = "sha256:fc3fce98865f6784c9cd0a56a20644fc6098f21c8c33834a8d9fe383c17e554b"}, +] + +[[package]] +name = "jupyter-lsp" +version = "2.2.5" +requires_python = ">=3.8" +summary = "Multi-Language Server WebSocket proxy for Jupyter Notebook/Lab server" +groups = ["qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "importlib-metadata>=4.8.3; python_version < \"3.10\"", + "jupyter-server>=1.1.2", +] +files = [ + {file = "jupyter-lsp-2.2.5.tar.gz", hash = "sha256:793147a05ad446f809fd53ef1cd19a9f5256fd0a2d6b7ce943a982cb4f545001"}, + {file = "jupyter_lsp-2.2.5-py3-none-any.whl", hash = "sha256:45fbddbd505f3fbfb0b6cb2f1bc5e15e83ab7c79cd6e89416b248cb3c00c11da"}, +] + +[[package]] +name = "jupyter-server" +version = "2.15.0" +requires_python = ">=3.9" +summary = "The backend—i.e. core services, APIs, and REST endpoints—to Jupyter web applications." +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "anyio>=3.1.0", + "argon2-cffi>=21.1", + "jinja2>=3.0.3", + "jupyter-client>=7.4.4", + "jupyter-core!=5.0.*,>=4.12", + "jupyter-events>=0.11.0", + "jupyter-server-terminals>=0.4.4", + "nbconvert>=6.4.4", + "nbformat>=5.3.0", + "overrides>=5.0", + "packaging>=22.0", + "prometheus-client>=0.9", + "pywinpty>=2.0.1; os_name == \"nt\"", + "pyzmq>=24", + "send2trash>=1.8.2", + "terminado>=0.8.3", + "tornado>=6.2.0", + "traitlets>=5.6.0", + "websocket-client>=1.7", +] +files = [ + {file = "jupyter_server-2.15.0-py3-none-any.whl", hash = "sha256:872d989becf83517012ee669f09604aa4a28097c0bd90b2f424310156c2cdae3"}, + {file = "jupyter_server-2.15.0.tar.gz", hash = "sha256:9d446b8697b4f7337a1b7cdcac40778babdd93ba614b6d68ab1c0c918f1c4084"}, +] + +[[package]] +name = "jupyter-server-proxy" +version = "4.4.0" +requires_python = ">=3.8" +summary = "A Jupyter server extension to run additional processes and proxy to them that comes bundled JupyterLab extension to launch pre-defined processes." +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "aiohttp", + "importlib-metadata>=4.8.3; python_version < \"3.10\"", + "jupyter-server>=1.24.0", + "simpervisor>=1.0.0", + "tornado>=6.1.0", + "traitlets>=5.1.0", +] +files = [ + {file = "jupyter_server_proxy-4.4.0-py3-none-any.whl", hash = "sha256:707b5c84810bb8863d50f6c6d50a386fec216149e11802b7d4c451b54a63a9a6"}, + {file = "jupyter_server_proxy-4.4.0.tar.gz", hash = "sha256:e5732eb9c810c0caa997f90a2f15f7d09af638e7eea9c67eb5c43e9c1f0e1157"}, +] + +[[package]] +name = "jupyter-server-terminals" +version = "0.5.3" +requires_python = ">=3.8" +summary = "A Jupyter Server Extension Providing Terminals." +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "pywinpty>=2.0.3; os_name == \"nt\"", + "terminado>=0.8.3", +] +files = [ + {file = "jupyter_server_terminals-0.5.3-py3-none-any.whl", hash = "sha256:41ee0d7dc0ebf2809c668e0fc726dfaf258fcd3e769568996ca731b6194ae9aa"}, + {file = "jupyter_server_terminals-0.5.3.tar.gz", hash = "sha256:5ae0295167220e9ace0edcfdb212afd2b01ee8d179fe6f23c899590e9b8a5269"}, +] + +[[package]] +name = "jupyterlab" +version = "4.3.5" +requires_python = ">=3.8" +summary = "JupyterLab computational environment" +groups = ["qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "async-lru>=1.0.0", + "httpx>=0.25.0", + "importlib-metadata>=4.8.3; python_version < \"3.10\"", + "importlib-resources>=1.4; python_version < \"3.9\"", + "ipykernel>=6.5.0", + "jinja2>=3.0.3", + "jupyter-core", + "jupyter-lsp>=2.0.0", + "jupyter-server<3,>=2.4.0", + "jupyterlab-server<3,>=2.27.1", + "notebook-shim>=0.2", + "packaging", + "setuptools>=40.8.0", + "tomli>=1.2.2; python_version < \"3.11\"", + "tornado>=6.2.0", + "traitlets", +] +files = [ + {file = "jupyterlab-4.3.5-py3-none-any.whl", hash = "sha256:571bbdee20e4c5321ab5195bc41cf92a75a5cff886be5e57ce78dfa37a5e9fdb"}, + {file = "jupyterlab-4.3.5.tar.gz", hash = "sha256:c779bf72ced007d7d29d5bcef128e7fdda96ea69299e19b04a43635a7d641f9d"}, +] + +[[package]] +name = "jupyterlab-pygments" +version = "0.3.0" +requires_python = ">=3.8" +summary = "Pygments theme using JupyterLab CSS variables" +groups = ["docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "jupyterlab_pygments-0.3.0-py3-none-any.whl", hash = "sha256:841a89020971da1d8693f1a99997aefc5dc424bb1b251fd6322462a1b8842780"}, + {file = "jupyterlab_pygments-0.3.0.tar.gz", hash = "sha256:721aca4d9029252b11cfa9d185e5b5af4d54772bb8072f9b7036f4170054d35d"}, +] + +[[package]] +name = "jupyterlab-server" +version = "2.27.3" +requires_python = ">=3.8" +summary = "A set of server components for JupyterLab and JupyterLab like applications." +groups = ["qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "babel>=2.10", + "importlib-metadata>=4.8.3; python_version < \"3.10\"", + "jinja2>=3.0.3", + "json5>=0.9.0", + "jsonschema>=4.18.0", + "jupyter-server<3,>=1.21", + "packaging>=21.3", + "requests>=2.31", +] +files = [ + {file = "jupyterlab_server-2.27.3-py3-none-any.whl", hash = "sha256:e697488f66c3db49df675158a77b3b017520d772c6e1548c7d9bcc5df7944ee4"}, + {file = "jupyterlab_server-2.27.3.tar.gz", hash = "sha256:eb36caca59e74471988f0ae25c77945610b887f777255aa21f8065def9e51ed4"}, +] + +[[package]] +name = "jupyterlab-widgets" +version = "3.0.13" +requires_python = ">=3.7" +summary = "Jupyter interactive widgets for JupyterLab" +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "jupyterlab_widgets-3.0.13-py3-none-any.whl", hash = "sha256:e3cda2c233ce144192f1e29914ad522b2f4c40e77214b0cc97377ca3d323db54"}, + {file = "jupyterlab_widgets-3.0.13.tar.gz", hash = "sha256:a2966d385328c1942b683a8cd96b89b8dd82c8b8f81dda902bb2bc06d46f5bed"}, +] + +[[package]] +name = "kiwisolver" +version = "1.4.7" +requires_python = ">=3.8" +summary = "A fast implementation of the Cassowary constraint solver" +groups = ["default", "pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "kiwisolver-1.4.7-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:8a9c83f75223d5e48b0bc9cb1bf2776cf01563e00ade8775ffe13b0b6e1af3a6"}, + {file = "kiwisolver-1.4.7-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:aa0abdf853e09aff551db11fce173e2177d00786c688203f52c87ad7fcd91ef9"}, + {file = "kiwisolver-1.4.7-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:d2b0e12a42fb4e72d509fc994713d099cbb15ebf1103545e8a45f14da2dfca54"}, + {file = "kiwisolver-1.4.7-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:46707a10836894b559e04b0fd143e343945c97fd170d69a2d26d640b4e297935"}, + {file = "kiwisolver-1.4.7-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:5360cc32706dab3931f738d3079652d20982511f7c0ac5711483e6eab08efff2"}, + {file = "kiwisolver-1.4.7-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:48b571ecd8bae15702e4f22d3ff6a0f13e54d3d00cd25216d5e7f658242065ee"}, + {file = "kiwisolver-1.4.7-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:3f9362ecfca44c863569d3d3c033dbe8ba452ff8eed6f6b5806382741a1334bd"}, + {file = "kiwisolver-1.4.7-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:f32d6edbc638cde7652bd690c3e728b25332acbadd7cad670cc4a02558d9c417"}, + {file = "kiwisolver-1.4.7-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:5b7dfa3b546da08a9f622bb6becdb14b3e24aaa30adba66749d38f3cc7ea9706"}, + {file = "kiwisolver-1.4.7-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:48be928f59a1f5c8207154f935334d374e79f2b5d212826307d072595ad76a2e"}, + {file = "kiwisolver-1.4.7.tar.gz", hash = "sha256:9893ff81bd7107f7b685d3017cc6583daadb4fc26e4a888350df530e41980a60"}, +] + +[[package]] +name = "markdown-it-py" +version = "3.0.0" +requires_python = ">=3.8" +summary = "Python port of markdown-it. Markdown parsing, done right!" +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "mdurl~=0.1", +] +files = [ + {file = "markdown-it-py-3.0.0.tar.gz", hash = "sha256:e3f60a94fa066dc52ec76661e37c851cb232d92f9886b15cb560aaada2df8feb"}, + {file = "markdown_it_py-3.0.0-py3-none-any.whl", hash = "sha256:355216845c60bd96232cd8d8c40e8f9765cc86f46880e43a8fd22dc1a1a8cab1"}, +] + +[[package]] +name = "markupsafe" +version = "2.1.5" +requires_python = ">=3.7" +summary = "Safely add untrusted strings to HTML/XML markup." +groups = ["docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "MarkupSafe-2.1.5-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:a17a92de5231666cfbe003f0e4b9b3a7ae3afb1ec2845aadc2bacc93ff85febc"}, + {file = "MarkupSafe-2.1.5-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:629ddd2ca402ae6dbedfceeba9c46d5f7b2a61d9749597d4307f943ef198fc1f"}, + {file = "MarkupSafe-2.1.5-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:8dec4936e9c3100156f8a2dc89c4b88d5c435175ff03413b443469c7c8c5f4d1"}, + {file = "MarkupSafe-2.1.5-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:7a68b554d356a91cce1236aa7682dc01df0edba8d043fd1ce607c49dd3c1edcf"}, + {file = "MarkupSafe-2.1.5.tar.gz", hash = "sha256:d283d37a890ba4c1ae73ffadf8046435c76e7bc2247bbb63c00bd1a709c6544b"}, +] + +[[package]] +name = "matplotlib" +version = "3.9.4" +requires_python = ">=3.9" +summary = "Python plotting package" +groups = ["default", "pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "contourpy>=1.0.1", + "cycler>=0.10", + "fonttools>=4.22.0", + "importlib-resources>=3.2.0; python_version < \"3.10\"", + "kiwisolver>=1.3.1", + "numpy>=1.23", + "packaging>=20.0", + "pillow>=8", + "pyparsing>=2.3.1", + "python-dateutil>=2.7", +] +files = [ + {file = "matplotlib-3.9.4-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:d89bc4e85e40a71d1477780366c27fb7c6494d293e1617788986f74e2a03d7ff"}, + {file = "matplotlib-3.9.4-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:30e5b22e8bcfb95442bf7d48b0d7f3bdf4a450cbf68986ea45fca3d11ae9d099"}, + {file = "matplotlib-3.9.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:47aef0fab8332d02d68e786eba8113ffd6f862182ea2999379dec9e237b7e483"}, + {file = "matplotlib-3.9.4-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:d5f0a8430ffe23d7e32cfd86445864ccad141797f7d25b7c41759a5b5d17cfd7"}, + {file = "matplotlib-3.9.4-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:09debb9ce941eb23ecdbe7eab972b1c3e0276dcf01688073faff7b0f61d6c6ca"}, + {file = "matplotlib-3.9.4.tar.gz", hash = "sha256:1e00e8be7393cbdc6fedfa8a6fba02cf3e83814b285db1c60b906a023ba41bc3"}, +] + +[[package]] +name = "matplotlib-inline" +version = "0.1.7" +requires_python = ">=3.8" +summary = "Inline Matplotlib backend for Jupyter" +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "traitlets", +] +files = [ + {file = "matplotlib_inline-0.1.7-py3-none-any.whl", hash = "sha256:df192d39a4ff8f21b1895d72e6a13f5fcc5099f00fa84384e0ea28c2cc0653ca"}, + {file = "matplotlib_inline-0.1.7.tar.gz", hash = "sha256:8423b23ec666be3d16e16b60bdd8ac4e86e840ebd1dd11a30b9f117f2fa0ab90"}, +] + +[[package]] +name = "mdurl" +version = "0.1.2" +requires_python = ">=3.7" +summary = "Markdown URL utilities" +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "mdurl-0.1.2-py3-none-any.whl", hash = "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8"}, + {file = "mdurl-0.1.2.tar.gz", hash = "sha256:bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba"}, +] + +[[package]] +name = "meshio" +version = "5.3.5" +requires_python = ">=3.8" +summary = "I/O for many mesh formats" +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "importlib-metadata; python_version < \"3.8\"", + "numpy>=1.20.0", + "rich", +] +files = [ + {file = "meshio-5.3.5-py3-none-any.whl", hash = "sha256:0736c6e34ecc768f62f2cde5d8233a3529512a9399b25c68ea2ca0d5900cdc10"}, + {file = "meshio-5.3.5.tar.gz", hash = "sha256:f21f01abd9f29ba06ea119304b3d39e610421cfe93b9dd23362834919f87586d"}, +] + +[[package]] +name = "mistune" +version = "3.0.2" +requires_python = ">=3.7" +summary = "A sane and fast Markdown parser with useful plugins and renderers" +groups = ["docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "mistune-3.0.2-py3-none-any.whl", hash = "sha256:71481854c30fdbc938963d3605b72501f5c10a9320ecd412c121c163a1c7d205"}, + {file = "mistune-3.0.2.tar.gz", hash = "sha256:fc7f93ded930c92394ef2cb6f04a8aabab4117a91449e72dcc8dfa646a508be8"}, +] + +[[package]] +name = "more-itertools" +version = "10.5.0" +requires_python = ">=3.8" +summary = "More routines for operating on iterables, beyond itertools" +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "more-itertools-10.5.0.tar.gz", hash = "sha256:5482bfef7849c25dc3c6dd53a6173ae4795da2a41a80faea6700d9f5846c5da6"}, + {file = "more_itertools-10.5.0-py3-none-any.whl", hash = "sha256:037b0d3203ce90cca8ab1defbbdac29d5f993fc20131f3664dc8d6acfa872aef"}, +] + +[[package]] +name = "msgpack" +version = "1.1.0" +requires_python = ">=3.8" +summary = "MessagePack serializer" +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "msgpack-1.1.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:7ad442d527a7e358a469faf43fda45aaf4ac3249c8310a82f0ccff9164e5dccd"}, + {file = "msgpack-1.1.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:914571a2a5b4e7606997e169f64ce53a8b1e06f2cf2c3a7273aa106236d43dd5"}, + {file = "msgpack-1.1.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:3d364a55082fb2a7416f6c63ae383fbd903adb5a6cf78c5b96cc6316dc1cedc7"}, + {file = "msgpack-1.1.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:6ad622bf7756d5a497d5b6836e7fc3752e2dd6f4c648e24b1803f6048596f701"}, + {file = "msgpack-1.1.0-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:d46cf9e3705ea9485687aa4001a76e44748b609d260af21c4ceea7f2212a501d"}, + {file = "msgpack-1.1.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:58dfc47f8b102da61e8949708b3eafc3504509a5728f8b4ddef84bd9e16ad420"}, + {file = "msgpack-1.1.0-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:53258eeb7a80fc46f62fd59c876957a2d0e15e6449a9e71842b6d24419d88ca1"}, + {file = "msgpack-1.1.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:f3e9b4936df53b970513eac1758f3882c88658a220b58dcc1e39606dccaaf01c"}, + {file = "msgpack-1.1.0.tar.gz", hash = "sha256:dd432ccc2c72b914e4cb77afce64aab761c1137cc698be3984eee260bcb2896e"}, +] + +[[package]] +name = "multidict" +version = "6.1.0" +requires_python = ">=3.8" +summary = "multidict implementation" +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "typing-extensions>=4.1.0; python_version < \"3.11\"", +] +files = [ + {file = "multidict-6.1.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:3380252550e372e8511d49481bd836264c009adb826b23fefcc5dd3c69692f60"}, + {file = "multidict-6.1.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:a114d03b938376557927ab23f1e950827c3b893ccb94b62fd95d430fd0e5cf53"}, + {file = "multidict-6.1.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:3efe2c2cb5763f2f1b275ad2bf7a287d3f7ebbef35648a9726e3b69284a4f3d6"}, + {file = "multidict-6.1.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:27e5fc84ccef8dfaabb09d82b7d179c7cf1a3fbc8a966f8274fcb4ab2eb4cadb"}, + {file = "multidict-6.1.0-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:b04772ed465fa3cc947db808fa306d79b43e896beb677a56fb2347ca1a49c1fa"}, + {file = "multidict-6.1.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:071120490b47aa997cca00666923a83f02c7fbb44f71cf7f136df753f7fa8761"}, + {file = "multidict-6.1.0-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:4e18b656c5e844539d506a0a06432274d7bd52a7487e6828c63a63d69185626c"}, + {file = "multidict-6.1.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:ab7c4ceb38d91570a650dba194e1ca87c2b543488fe9309b4212694174fd539c"}, + {file = "multidict-6.1.0-py3-none-any.whl", hash = "sha256:48e171e52d1c4d33888e529b999e5900356b9ae588c2f09a52dcefb158b27506"}, + {file = "multidict-6.1.0.tar.gz", hash = "sha256:22ae2ebf9b0c69d206c003e2f6a914ea33f0a932d4aa16f236afc049d9958f4a"}, +] + +[[package]] +name = "nbclient" +version = "0.10.0" +requires_python = ">=3.8.0" +summary = "A client library for executing notebooks. Formerly nbconvert's ExecutePreprocessor." +groups = ["docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "jupyter-client>=6.1.12", + "jupyter-core!=5.0.*,>=4.12", + "nbformat>=5.1", + "traitlets>=5.4", +] +files = [ + {file = "nbclient-0.10.0-py3-none-any.whl", hash = "sha256:f13e3529332a1f1f81d82a53210322476a168bb7090a0289c795fe9cc11c9d3f"}, + {file = "nbclient-0.10.0.tar.gz", hash = "sha256:4b3f1b7dba531e498449c4db4f53da339c91d449dc11e9af3a43b4eb5c5abb09"}, +] + +[[package]] +name = "nbconvert" +version = "7.16.6" +requires_python = ">=3.8" +summary = "Converting Jupyter Notebooks (.ipynb files) to other formats. Output formats include asciidoc, html, latex, markdown, pdf, py, rst, script. nbconvert can be used both as a Python library (`import nbconvert`) or as a command line tool (invoked as `jupyter nbconvert ...`)." +groups = ["docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "beautifulsoup4", + "bleach[css]!=5.0.0", + "defusedxml", + "importlib-metadata>=3.6; python_version < \"3.10\"", + "jinja2>=3.0", + "jupyter-core>=4.7", + "jupyterlab-pygments", + "markupsafe>=2.0", + "mistune<4,>=2.0.3", + "nbclient>=0.5.0", + "nbformat>=5.7", + "packaging", + "pandocfilters>=1.4.1", + "pygments>=2.4.1", + "traitlets>=5.1", +] +files = [ + {file = "nbconvert-7.16.6-py3-none-any.whl", hash = "sha256:1375a7b67e0c2883678c48e506dc320febb57685e5ee67faa51b18a90f3a712b"}, + {file = "nbconvert-7.16.6.tar.gz", hash = "sha256:576a7e37c6480da7b8465eefa66c17844243816ce1ccc372633c6b71c3c0f582"}, +] + +[[package]] +name = "nbformat" +version = "5.10.4" +requires_python = ">=3.8" +summary = "The Jupyter Notebook format" +groups = ["docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "fastjsonschema>=2.15", + "jsonschema>=2.6", + "jupyter-core!=5.0.*,>=4.12", + "traitlets>=5.1", +] +files = [ + {file = "nbformat-5.10.4-py3-none-any.whl", hash = "sha256:3b48d6c8fbca4b299bf3982ea7db1af21580e4fec269ad087b9e81588891200b"}, + {file = "nbformat-5.10.4.tar.gz", hash = "sha256:322168b14f937a5d11362988ecac2a4952d3d8e3a2cbeb2319584631226d5b3a"}, +] + +[[package]] +name = "nbsphinx" +version = "0.9.6" +requires_python = ">=3.6" +summary = "Jupyter Notebook Tools for Sphinx" +groups = ["docs"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "docutils>=0.18.1", + "jinja2", + "nbconvert!=5.4,>=5.3", + "nbformat", + "sphinx>=1.8", + "traitlets>=5", +] +files = [ + {file = "nbsphinx-0.9.6-py3-none-any.whl", hash = "sha256:336b0b557945a7678ec7449b16449f854bc852a435bb53b8a72e6b5dc740d992"}, + {file = "nbsphinx-0.9.6.tar.gz", hash = "sha256:c2b28a2d702f1159a95b843831798e86e60a17fc647b9bff9ba1585355de54e3"}, +] + +[[package]] +name = "nest-asyncio" +version = "1.6.0" +requires_python = ">=3.5" +summary = "Patch asyncio to allow nested event loops" +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "nest_asyncio-1.6.0-py3-none-any.whl", hash = "sha256:87af6efd6b5e897c81050477ef65c62e2b2f35d51703cae01aff2905b1852e1c"}, + {file = "nest_asyncio-1.6.0.tar.gz", hash = "sha256:6f172d5449aca15afd6c646851f4e31e02c598d553a667e38cafa997cfec55fe"}, +] + +[[package]] +name = "nodeenv" +version = "1.9.1" +requires_python = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,!=3.6.*,>=2.7" +summary = "Node.js virtual environment builder" +groups = ["qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "nodeenv-1.9.1-py2.py3-none-any.whl", hash = "sha256:ba11c9782d29c27c70ffbdda2d7415098754709be8a7056d79a737cd901155c9"}, + {file = "nodeenv-1.9.1.tar.gz", hash = "sha256:6ec12890a2dab7946721edbfbcd91f3319c6ccc9aec47be7c7e6b7011ee6645f"}, +] + +[[package]] +name = "notebook" +version = "7.3.2" +requires_python = ">=3.8" +summary = "Jupyter Notebook - A web-based notebook environment for interactive computing" +groups = ["qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "jupyter-server<3,>=2.4.0", + "jupyterlab-server<3,>=2.27.1", + "jupyterlab<4.4,>=4.3.4", + "notebook-shim<0.3,>=0.2", + "tornado>=6.2.0", +] +files = [ + {file = "notebook-7.3.2-py3-none-any.whl", hash = "sha256:e5f85fc59b69d3618d73cf27544418193ff8e8058d5bf61d315ce4f473556288"}, + {file = "notebook-7.3.2.tar.gz", hash = "sha256:705e83a1785f45b383bf3ee13cb76680b92d24f56fb0c7d2136fe1d850cd3ca8"}, +] + +[[package]] +name = "notebook-shim" +version = "0.2.4" +requires_python = ">=3.7" +summary = "A shim layer for notebook traits and config" +groups = ["qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "jupyter-server<3,>=1.8", +] +files = [ + {file = "notebook_shim-0.2.4-py3-none-any.whl", hash = "sha256:411a5be4e9dc882a074ccbcae671eda64cceb068767e9a3419096986560e1cef"}, + {file = "notebook_shim-0.2.4.tar.gz", hash = "sha256:b4b2cfa1b65d98307ca24361f5b30fe785b53c3fd07b7a47e89acb5e6ac638cb"}, +] + +[[package]] +name = "numpy" +version = "2.0.2" +requires_python = ">=3.9" +summary = "Fundamental package for array computing in Python" +groups = ["default", "pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "numpy-2.0.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:f15975dfec0cf2239224d80e32c3170b1d168335eaedee69da84fbe9f1f9cd04"}, + {file = "numpy-2.0.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:11a76c372d1d37437857280aa142086476136a8c0f373b2e648ab2c8f18fb195"}, + {file = "numpy-2.0.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:8df823f570d9adf0978347d1f926b2a867d5608f434a7cff7f7908c6570dcf5e"}, + {file = "numpy-2.0.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:423e89b23490805d2a5a96fe40ec507407b8ee786d66f7328be214f9679df6dd"}, + {file = "numpy-2.0.2.tar.gz", hash = "sha256:883c987dee1880e2a864ab0dc9892292582510604156762362d9326444636e78"}, +] + +[[package]] +name = "openpyxl" +version = "3.1.5" +requires_python = ">=3.8" +summary = "A Python library to read/write Excel 2010 xlsx/xlsm files" +groups = ["openpyxl"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "et-xmlfile", +] +files = [ + {file = "openpyxl-3.1.5-py2.py3-none-any.whl", hash = "sha256:5282c12b107bffeef825f4617dc029afaf41d0ea60823bbb665ef3079dc79de2"}, + {file = "openpyxl-3.1.5.tar.gz", hash = "sha256:cf0e3cf56142039133628b5acffe8ef0c12bc902d2aadd3e0fe5878dc08d1050"}, +] + +[[package]] +name = "overrides" +version = "7.7.0" +requires_python = ">=3.6" +summary = "A decorator to automatically detect mismatch when overriding a method." +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "typing; python_version < \"3.5\"", +] +files = [ + {file = "overrides-7.7.0-py3-none-any.whl", hash = "sha256:c7ed9d062f78b8e4c1a7b70bd8796b35ead4d9f510227ef9c5dc7626c60d7e49"}, + {file = "overrides-7.7.0.tar.gz", hash = "sha256:55158fa3d93b98cc75299b1e67078ad9003ca27945c76162c1c0766d6f91820a"}, +] + +[[package]] +name = "packaging" +version = "24.2" +requires_python = ">=3.8" +summary = "Core utilities for Python packages" +groups = ["default", "docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "packaging-24.2-py3-none-any.whl", hash = "sha256:09abb1bccd265c01f4a3aa3f7a7db064b36514d2cba19a2f694fe6150451a759"}, + {file = "packaging-24.2.tar.gz", hash = "sha256:c228a6dc5e932d346bc5739379109d49e8853dd8223571c7c5b55260edc0b97f"}, +] + +[[package]] +name = "pandas" +version = "2.2.3" +requires_python = ">=3.9" +summary = "Powerful data structures for data analysis, time series, and statistics" +groups = ["default"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "numpy>=1.22.4; python_version < \"3.11\"", + "numpy>=1.23.2; python_version == \"3.11\"", + "numpy>=1.26.0; python_version >= \"3.12\"", + "python-dateutil>=2.8.2", + "pytz>=2020.1", + "tzdata>=2022.7", +] +files = [ + {file = "pandas-2.2.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:381175499d3802cde0eabbaf6324cce0c4f5d52ca6f8c377c29ad442f50f6348"}, + {file = "pandas-2.2.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:7c2875855b0ff77b2a64a0365e24455d9990730d6431b9e0ee18ad8acee13dbd"}, + {file = "pandas-2.2.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:a5a1595fe639f5988ba6a8e5bc9649af3baf26df3998a0abe56c02609392e0a4"}, + {file = "pandas-2.2.3-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:5dbca4c1acd72e8eeef4753eeca07de9b1db4f398669d5994086f788a5d7cc30"}, + {file = "pandas-2.2.3.tar.gz", hash = "sha256:4f18ba62b61d7e192368b84517265a99b4d7ee8912f8708660fb4a366cc82667"}, +] + +[[package]] +name = "pandoc" +version = "2.4" +summary = "Pandoc Documents for Python" +groups = ["docs"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "plumbum", + "ply", +] +files = [ + {file = "pandoc-2.4.tar.gz", hash = "sha256:ecd1f8cbb7f4180c6b5db4a17a7c1a74df519995f5f186ef81ce72a9cbd0dd9a"}, +] + +[[package]] +name = "pandocfilters" +version = "1.5.1" +requires_python = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*" +summary = "Utilities for writing pandoc filters in python" +groups = ["docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "pandocfilters-1.5.1-py2.py3-none-any.whl", hash = "sha256:93be382804a9cdb0a7267585f157e5d1731bbe5545a85b268d6f5fe6232de2bc"}, + {file = "pandocfilters-1.5.1.tar.gz", hash = "sha256:002b4a555ee4ebc03f8b66307e287fa492e4a77b4ea14d3f934328297bb4939e"}, +] + +[[package]] +name = "parso" +version = "0.8.4" +requires_python = ">=3.6" +summary = "A Python Parser" +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "parso-0.8.4-py2.py3-none-any.whl", hash = "sha256:a418670a20291dacd2dddc80c377c5c3791378ee1e8d12bffc35420643d43f18"}, + {file = "parso-0.8.4.tar.gz", hash = "sha256:eb3a7b58240fb99099a345571deecc0f9540ea5f4dd2fe14c2a99d6b281ab92d"}, +] + +[[package]] +name = "pexpect" +version = "4.9.0" +summary = "Pexpect allows easy control of interactive console applications." +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\" and sys_platform != \"win32\"" +dependencies = [ + "ptyprocess>=0.5", +] +files = [ + {file = "pexpect-4.9.0-py2.py3-none-any.whl", hash = "sha256:7236d1e080e4936be2dc3e326cec0af72acf9212a7e1d060210e70a47e253523"}, + {file = "pexpect-4.9.0.tar.gz", hash = "sha256:ee7d41123f3c9911050ea2c2dac107568dc43b2d3b0c7557a33212c398ead30f"}, +] + +[[package]] +name = "pillow" +version = "10.4.0" +requires_python = ">=3.8" +summary = "Python Imaging Library (Fork)" +groups = ["default", "pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "pillow-10.4.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:543f3dc61c18dafb755773efc89aae60d06b6596a63914107f75459cf984164d"}, + {file = "pillow-10.4.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:dfe91cb65544a1321e631e696759491ae04a2ea11d36715eca01ce07284738be"}, + {file = "pillow-10.4.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:866b6942a92f56300012f5fbac71f2d610312ee65e22f1aa2609e491284e5597"}, + {file = "pillow-10.4.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:298478fe4f77a4408895605f3482b6cc6222c018b2ce565c2b6b9c354ac3229b"}, + {file = "pillow-10.4.0-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:8f0aef4ef59694b12cadee839e2ba6afeab89c0f39a3adc02ed51d109117b8da"}, + {file = "pillow-10.4.0-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:1b5dea9831a90e9d0721ec417a80d4cbd7022093ac38a568db2dd78363b00908"}, + {file = "pillow-10.4.0.tar.gz", hash = "sha256:166c1cd4d24309b30d61f79f4a9114b7b2313d7450912277855ff5dfd7cd4a06"}, +] + +[[package]] +name = "platformdirs" +version = "4.3.6" +requires_python = ">=3.8" +summary = "A small Python package for determining appropriate platform-specific dirs, e.g. a `user data dir`." +groups = ["docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "platformdirs-4.3.6-py3-none-any.whl", hash = "sha256:73e575e1408ab8103900836b97580d5307456908a03e92031bab39e4554cc3fb"}, + {file = "platformdirs-4.3.6.tar.gz", hash = "sha256:357fb2acbc885b0419afd3ce3ed34564c13c9b95c89360cd9563f73aa5e2b907"}, +] + +[[package]] +name = "pluggy" +version = "1.5.0" +requires_python = ">=3.8" +summary = "plugin and hook calling mechanisms for python" +groups = ["qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "pluggy-1.5.0-py3-none-any.whl", hash = "sha256:44e1ad92c8ca002de6377e165f3e0f1be63266ab4d554740532335b9d75ea669"}, + {file = "pluggy-1.5.0.tar.gz", hash = "sha256:2cffa88e94fdc978c4c574f15f9e59b7f4201d439195c3715ca9e2486f1d0cf1"}, +] + +[[package]] +name = "plumbum" +version = "1.8.3" +requires_python = ">=3.6" +summary = "Plumbum: shell combinators library" +groups = ["docs"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "pywin32; platform_system == \"Windows\" and platform_python_implementation != \"PyPy\"", +] +files = [ + {file = "plumbum-1.8.3-py3-none-any.whl", hash = "sha256:8595d36dae2472587d6f59789c8d7b26250f45f6f6ed75ccb378de59ee7b9cf9"}, + {file = "plumbum-1.8.3.tar.gz", hash = "sha256:6092c85ab970b7a7a9d5d85c75200bc93be82b33c9bdf640ffa87d2d7c8709f0"}, +] + +[[package]] +name = "ply" +version = "3.11" +summary = "Python Lex & Yacc" +groups = ["docs"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "ply-3.11-py2.py3-none-any.whl", hash = "sha256:096f9b8350b65ebd2fd1346b12452efe5b9607f7482813ffca50c22722a807ce"}, + {file = "ply-3.11.tar.gz", hash = "sha256:00c7c1aaa88358b9c765b6d3000c6eec0ba42abca5351b095321aef446081da3"}, +] + +[[package]] +name = "pooch" +version = "1.8.2" +requires_python = ">=3.7" +summary = "A friend to fetch your data files" +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "packaging>=20.0", + "platformdirs>=2.5.0", + "requests>=2.19.0", +] +files = [ + {file = "pooch-1.8.2-py3-none-any.whl", hash = "sha256:3529a57096f7198778a5ceefd5ac3ef0e4d06a6ddaf9fc2d609b806f25302c47"}, + {file = "pooch-1.8.2.tar.gz", hash = "sha256:76561f0de68a01da4df6af38e9955c4c9d1a5c90da73f7e40276a5728ec83d10"}, +] + +[[package]] +name = "pre-commit" +version = "4.1.0" +requires_python = ">=3.9" +summary = "A framework for managing and maintaining multi-language pre-commit hooks." +groups = ["qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "cfgv>=2.0.0", + "identify>=1.0.0", + "nodeenv>=0.11.1", + "pyyaml>=5.1", + "virtualenv>=20.10.0", +] +files = [ + {file = "pre_commit-4.1.0-py2.py3-none-any.whl", hash = "sha256:d29e7cb346295bcc1cc75fc3e92e343495e3ea0196c9ec6ba53f49f10ab6ae7b"}, + {file = "pre_commit-4.1.0.tar.gz", hash = "sha256:ae3f018575a588e30dfddfab9a05448bfbd6b73d78709617b5a2b853549716d4"}, +] + +[[package]] +name = "prometheus-client" +version = "0.20.0" +requires_python = ">=3.8" +summary = "Python client for the Prometheus monitoring system." +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "prometheus_client-0.20.0-py3-none-any.whl", hash = "sha256:cde524a85bce83ca359cc837f28b8c0db5cac7aa653a588fd7e84ba061c329e7"}, + {file = "prometheus_client-0.20.0.tar.gz", hash = "sha256:287629d00b147a32dcb2be0b9df905da599b2d82f80377083ec8463309a4bb89"}, +] + +[[package]] +name = "prompt-toolkit" +version = "3.0.47" +requires_python = ">=3.7.0" +summary = "Library for building powerful interactive command lines in Python" +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "wcwidth", +] +files = [ + {file = "prompt_toolkit-3.0.47-py3-none-any.whl", hash = "sha256:0d7bfa67001d5e39d02c224b663abc33687405033a8c422d0d675a5a13361d10"}, + {file = "prompt_toolkit-3.0.47.tar.gz", hash = "sha256:1e1b29cb58080b1e69f207c893a1a7bf16d127a5c30c9d17a25a5d77792e5360"}, +] + +[[package]] +name = "propcache" +version = "0.2.1" +requires_python = ">=3.9" +summary = "Accelerated property cache" +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "propcache-0.2.1-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:6b3f39a85d671436ee3d12c017f8fdea38509e4f25b28eb25877293c98c243f6"}, + {file = "propcache-0.2.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:6445804cf4ec763dc70de65a3b0d9954e868609e83850a47ca4f0cb64bd79fea"}, + {file = "propcache-0.2.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:1ffc3cca89bb438fb9c95c13fc874012f7b9466b89328c3c8b1aa93cdcfadd16"}, + {file = "propcache-0.2.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:70693319e0b8fd35dd863e3e29513875eb15c51945bf32519ef52927ca883bc3"}, + {file = "propcache-0.2.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:081a430aa8d5e8876c6909b67bd2d937bfd531b0382d3fdedb82612c618bc41a"}, + {file = "propcache-0.2.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:14d86fe14b7e04fa306e0c43cdbeebe6b2c2156a0c9ce56b815faacc193e320d"}, + {file = "propcache-0.2.1-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:6a9a8c34fb7bb609419a211e59da8887eeca40d300b5ea8e56af98f6fbbb1541"}, + {file = "propcache-0.2.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:accb6150ce61c9c4b7738d45550806aa2b71c7668c6942f17b0ac182b6142fd4"}, + {file = "propcache-0.2.1-py3-none-any.whl", hash = "sha256:52277518d6aae65536e9cea52d4e7fd2f7a66f4aa2d30ed3f2fcea620ace3c54"}, + {file = "propcache-0.2.1.tar.gz", hash = "sha256:3f77ce728b19cb537714499928fe800c3dda29e8d9428778fc7c186da4c09a64"}, +] + +[[package]] +name = "psutil" +version = "6.0.0" +requires_python = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7" +summary = "Cross-platform lib for process and system monitoring in Python." +groups = ["qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "psutil-6.0.0-cp38-abi3-macosx_11_0_arm64.whl", hash = "sha256:ffe7fc9b6b36beadc8c322f84e1caff51e8703b88eee1da46d1e3a6ae11b4fd0"}, + {file = "psutil-6.0.0.tar.gz", hash = "sha256:8faae4f310b6d969fa26ca0545338b21f73c6b15db7c4a8d934a5482faa818f2"}, +] + +[[package]] +name = "ptyprocess" +version = "0.7.0" +summary = "Run a subprocess in a pseudo terminal" +groups = ["pyvista", "qa"] +marker = "os_name != \"nt\" and python_version < \"3.13\" and python_version >= \"3.9\" or sys_platform != \"win32\" and python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "ptyprocess-0.7.0-py2.py3-none-any.whl", hash = "sha256:4b41f3967fce3af57cc7e94b888626c18bf37a083e3651ca8feeb66d492fef35"}, + {file = "ptyprocess-0.7.0.tar.gz", hash = "sha256:5c5d0a3b48ceee0b48485e0c26037c0acd7d29765ca3fbb5cb3831d347423220"}, +] + +[[package]] +name = "pure-eval" +version = "0.2.3" +summary = "Safely evaluate AST nodes without side effects" +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "pure_eval-0.2.3-py3-none-any.whl", hash = "sha256:1db8e35b67b3d218d818ae653e27f06c3aa420901fa7b081ca98cbedc874e0d0"}, + {file = "pure_eval-0.2.3.tar.gz", hash = "sha256:5f4e983f40564c576c7c8635ae88db5956bb2229d7e9237d03b3c0b0190eaf42"}, +] + +[[package]] +name = "pycparser" +version = "2.22" +requires_python = ">=3.8" +summary = "C parser in Python" +groups = ["docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "pycparser-2.22-py3-none-any.whl", hash = "sha256:c3702b6d3dd8c7abc1afa565d7e63d53a1d0bd86cdc24edd75470f4de499cfcc"}, + {file = "pycparser-2.22.tar.gz", hash = "sha256:491c8be9c040f5390f5bf44a5b07752bd07f56edf992381b05c701439eec10f6"}, +] + +[[package]] +name = "pydantic" +version = "2.10.6" +requires_python = ">=3.8" +summary = "Data validation using Python type hints" +groups = ["default"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "annotated-types>=0.6.0", + "pydantic-core==2.27.2", + "typing-extensions>=4.12.2", +] +files = [ + {file = "pydantic-2.10.6-py3-none-any.whl", hash = "sha256:427d664bf0b8a2b34ff5dd0f5a18df00591adcee7198fbd71981054cef37b584"}, + {file = "pydantic-2.10.6.tar.gz", hash = "sha256:ca5daa827cce33de7a42be142548b0096bf05a7e7b365aebfa5f8eeec7128236"}, +] + +[[package]] +name = "pydantic-core" +version = "2.27.2" +requires_python = ">=3.8" +summary = "Core functionality for Pydantic validation and serialization" +groups = ["default"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "typing-extensions!=4.7.0,>=4.6.0", +] +files = [ + {file = "pydantic_core-2.27.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:491a2b73db93fab69731eaee494f320faa4e093dbed776be1a829c2eb222c34c"}, + {file = "pydantic_core-2.27.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:26f32e0adf166a84d0cb63be85c562ca8a6fa8de28e5f0d92250c6b7e9e2aff7"}, + {file = "pydantic_core-2.27.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:83097677b8e3bd7eaa6775720ec8e0405f1575015a463285a92bfdfe254529ef"}, + {file = "pydantic_core-2.27.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:ef592d4bad47296fb11f96cd7dc898b92e795032b4894dfb4076cfccd43a9308"}, + {file = "pydantic_core-2.27.2-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:b0cb791f5b45307caae8810c2023a184c74605ec3bcbb67d13846c28ff731ff8"}, + {file = "pydantic_core-2.27.2-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:00bad2484fa6bda1e216e7345a798bd37c68fb2d97558edd584942aa41b7d278"}, + {file = "pydantic_core-2.27.2.tar.gz", hash = "sha256:eb026e5a4c1fee05726072337ff51d1efb6f59090b7da90d30ea58625b1ffb39"}, +] + +[[package]] +name = "pygments" +version = "2.18.0" +requires_python = ">=3.8" +summary = "Pygments is a syntax highlighting package written in Python." +groups = ["docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "pygments-2.18.0-py3-none-any.whl", hash = "sha256:b8e6aca0523f3ab76fee51799c488e38782ac06eafcf95e7ba832985c8e7b13a"}, + {file = "pygments-2.18.0.tar.gz", hash = "sha256:786ff802f32e91311bff3889f6e9a86e81505fe99f2735bb6d60ae0c5004f199"}, +] + +[[package]] +name = "pyparsing" +version = "3.1.4" +requires_python = ">=3.6.8" +summary = "pyparsing module - Classes and methods to define and execute parsing grammars" +groups = ["default", "pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "pyparsing-3.1.4-py3-none-any.whl", hash = "sha256:a6a7ee4235a3f944aa1fa2249307708f893fe5717dc603503c6c7969c070fb7c"}, + {file = "pyparsing-3.1.4.tar.gz", hash = "sha256:f86ec8d1a83f11977c9a6ea7598e8c27fc5cddfa5b07ea2241edbbde1d7bc032"}, +] + +[[package]] +name = "pyproject-api" +version = "1.9.0" +requires_python = ">=3.9" +summary = "API to interact with the python pyproject.toml based projects" +groups = ["qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "packaging>=24.2", + "tomli>=2.2.1; python_version < \"3.11\"", +] +files = [ + {file = "pyproject_api-1.9.0-py3-none-any.whl", hash = "sha256:326df9d68dea22d9d98b5243c46e3ca3161b07a1b9b18e213d1e24fd0e605766"}, + {file = "pyproject_api-1.9.0.tar.gz", hash = "sha256:7e8a9854b2dfb49454fae421cb86af43efbb2b2454e5646ffb7623540321ae6e"}, +] + +[[package]] +name = "pyqt5" +version = "5.15.10" +requires_python = ">=3.7" +summary = "Python bindings for the Qt cross platform application toolkit" +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "PyQt5-Qt5>=5.15.2", + "PyQt5-sip<13,>=12.13", +] +files = [ + {file = "PyQt5-5.15.10-cp37-abi3-macosx_11_0_arm64.whl", hash = "sha256:862cea3be95b4b0a2b9678003b3a18edf7bd5eafd673860f58820f246d4bf616"}, + {file = "PyQt5-5.15.10.tar.gz", hash = "sha256:d46b7804b1b10a4ff91753f8113e5b5580d2b4462f3226288e2d84497334898a"}, +] + +[[package]] +name = "pyqt5-qt5" +version = "5.15.14" +summary = "The subset of a Qt installation needed by PyQt5." +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "PyQt5_Qt5-5.15.14-py3-none-macosx_11_0_arm64.whl", hash = "sha256:730da7e6a97f6bad1b6df21082fe625647730418bc83e20cbc2ff6401ed0a8be"}, +] + +[[package]] +name = "pyqt5-sip" +version = "12.15.0" +requires_python = ">=3.8" +summary = "The sip module support for PyQt5" +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "PyQt5_sip-12.15.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:749f7a3ffd6e3d2d5db65ed92c95cbd14490631595c61f0c0672c9238bfb17de"}, + {file = "PyQt5_sip-12.15.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:855563d4d3b59ce7438bbf2dd32fed2707787defa40f3efe94f204a19ef92b25"}, + {file = "PyQt5_sip-12.15.0-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:852b75cf208825602480e95ab63314108f872d0da251e9ad3deaaff5a183a6f5"}, + {file = "PyQt5_sip-12.15.0-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:c0c543d604116af26694a8a5ba90f510551ff9124d503ae5ee14bb73a61363a3"}, + {file = "PyQt5_sip-12.15.0.tar.gz", hash = "sha256:d23fdfcf363b5cedd9d39f8a9c5710e7d52804f5b08a58e91c638b36eafcb702"}, +] + +[[package]] +name = "pytest" +version = "8.3.4" +requires_python = ">=3.8" +summary = "pytest: simple powerful testing with Python" +groups = ["qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "colorama; sys_platform == \"win32\"", + "exceptiongroup>=1.0.0rc8; python_version < \"3.11\"", + "iniconfig", + "packaging", + "pluggy<2,>=1.5", + "tomli>=1; python_version < \"3.11\"", +] +files = [ + {file = "pytest-8.3.4-py3-none-any.whl", hash = "sha256:50e16d954148559c9a74109af1eaf0c945ba2d8f30f0a3d3335edde19788b6f6"}, + {file = "pytest-8.3.4.tar.gz", hash = "sha256:965370d062bce11e73868e0335abac31b4d3de0e82f4007408d242b4f8610761"}, +] + +[[package]] +name = "pytest-cov" +version = "6.0.0" +requires_python = ">=3.9" +summary = "Pytest plugin for measuring coverage." +groups = ["qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "coverage[toml]>=7.5", + "pytest>=4.6", +] +files = [ + {file = "pytest-cov-6.0.0.tar.gz", hash = "sha256:fde0b595ca248bb8e2d76f020b465f3b107c9632e6a1d1705f17834c89dcadc0"}, + {file = "pytest_cov-6.0.0-py3-none-any.whl", hash = "sha256:eee6f1b9e61008bd34975a4d5bab25801eb31898b032dd55addc93e96fcaaa35"}, +] + +[[package]] +name = "python-dateutil" +version = "2.9.0.post0" +requires_python = "!=3.0.*,!=3.1.*,!=3.2.*,>=2.7" +summary = "Extensions to the standard Python datetime module" +groups = ["default", "docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "six>=1.5", +] +files = [ + {file = "python-dateutil-2.9.0.post0.tar.gz", hash = "sha256:37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3"}, + {file = "python_dateutil-2.9.0.post0-py2.py3-none-any.whl", hash = "sha256:a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427"}, +] + +[[package]] +name = "python-json-logger" +version = "2.0.7" +requires_python = ">=3.6" +summary = "A python library adding a json log formatter" +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "python-json-logger-2.0.7.tar.gz", hash = "sha256:23e7ec02d34237c5aa1e29a070193a4ea87583bb4e7f8fd06d3de8264c4b2e1c"}, + {file = "python_json_logger-2.0.7-py3-none-any.whl", hash = "sha256:f380b826a991ebbe3de4d897aeec42760035ac760345e57b812938dc8b35e2bd"}, +] + +[[package]] +name = "pytz" +version = "2024.2" +summary = "World timezone definitions, modern and historical" +groups = ["default"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "pytz-2024.2-py2.py3-none-any.whl", hash = "sha256:31c7c1817eb7fae7ca4b8c7ee50c72f93aa2dd863de768e1ef4245d426aa0725"}, + {file = "pytz-2024.2.tar.gz", hash = "sha256:2aa355083c50a0f93fa581709deac0c9ad65cca8a9e9beac660adcbd493c798a"}, +] + +[[package]] +name = "pyvista" +version = "0.44.2" +requires_python = ">=3.8" +summary = "Easier Pythonic interface to VTK" +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "matplotlib>=3.0.1", + "numpy>=1.21.0", + "pillow", + "pooch", + "scooby>=0.5.1", + "typing-extensions", + "vtk<9.4.0", +] +files = [ + {file = "pyvista-0.44.2-py3-none-any.whl", hash = "sha256:8530d35f57cdaa33507ac9aec19e3292be0bc9026b28e4f12df7e8054438d028"}, + {file = "pyvista-0.44.2.tar.gz", hash = "sha256:db65943c3c1c9ba49fe16f5a25a5bc23b74bf1ea7a38aae4ef9c4dc5838ccf5e"}, +] + +[[package]] +name = "pyvista" +version = "0.44.2" +extras = ["all"] +requires_python = ">=3.8" +summary = "Easier Pythonic interface to VTK" +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "pyvista==0.44.2", + "pyvista[colormaps,io,jupyter]", +] +files = [ + {file = "pyvista-0.44.2-py3-none-any.whl", hash = "sha256:8530d35f57cdaa33507ac9aec19e3292be0bc9026b28e4f12df7e8054438d028"}, + {file = "pyvista-0.44.2.tar.gz", hash = "sha256:db65943c3c1c9ba49fe16f5a25a5bc23b74bf1ea7a38aae4ef9c4dc5838ccf5e"}, +] + +[[package]] +name = "pyvista" +version = "0.44.2" +extras = ["colormaps", "io", "jupyter"] +requires_python = ">=3.8" +summary = "Easier Pythonic interface to VTK" +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "cmocean", + "colorcet", + "imageio", + "ipywidgets", + "jupyter-server-proxy", + "meshio>=5.2", + "nest-asyncio", + "pyvista==0.44.2", + "trame-client>=2.12.7", + "trame-server>=2.11.7", + "trame-vtk>=2.5.8", + "trame-vuetify>=2.3.1", + "trame>=2.5.2", +] +files = [ + {file = "pyvista-0.44.2-py3-none-any.whl", hash = "sha256:8530d35f57cdaa33507ac9aec19e3292be0bc9026b28e4f12df7e8054438d028"}, + {file = "pyvista-0.44.2.tar.gz", hash = "sha256:db65943c3c1c9ba49fe16f5a25a5bc23b74bf1ea7a38aae4ef9c4dc5838ccf5e"}, +] + +[[package]] +name = "pyvistaqt" +version = "0.11.1" +requires_python = ">=3.7" +summary = "pyvista qt plotter" +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "QtPy>=1.9.0", + "pyvista>=0.32.0", +] +files = [ + {file = "pyvistaqt-0.11.1-py3-none-any.whl", hash = "sha256:3ddc05418fcb297d471e7f7c0fdc89dbd5b6050653b4a86e66e5c1ce7e3563cc"}, + {file = "pyvistaqt-0.11.1.tar.gz", hash = "sha256:5403bfeb82cf063288107a9be9780ca3ca70948e73d33d16a65a83a711d51a36"}, +] + +[[package]] +name = "pyyaml" +version = "6.0.2" +requires_python = ">=3.8" +summary = "YAML parser and emitter for Python" +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "PyYAML-6.0.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:29717114e51c84ddfba879543fb232a6ed60086602313ca38cce623c1d62cfbf"}, + {file = "PyYAML-6.0.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:1e2120ef853f59c7419231f3bf4e7021f1b936f6ebd222406c3b60212205d2ee"}, + {file = "PyYAML-6.0.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ce826d6ef20b1bc864f0a68340c8b3287705cae2f8b4b1d932177dcc76721725"}, + {file = "PyYAML-6.0.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:a8786accb172bd8afb8be14490a16625cbc387036876ab6ba70912730faf8e1f"}, + {file = "pyyaml-6.0.2.tar.gz", hash = "sha256:d584d9ec91ad65861cc08d42e834324ef890a082e591037abe114850ff7bbc3e"}, +] + +[[package]] +name = "pyzmq" +version = "26.2.0" +requires_python = ">=3.7" +summary = "Python bindings for 0MQ" +groups = ["docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "cffi; implementation_name == \"pypy\"", +] +files = [ + {file = "pyzmq-26.2.0-cp310-cp310-macosx_10_15_universal2.whl", hash = "sha256:ddf33d97d2f52d89f6e6e7ae66ee35a4d9ca6f36eda89c24591b0c40205a3629"}, + {file = "pyzmq-26.2.0-cp311-cp311-macosx_10_15_universal2.whl", hash = "sha256:8f7e66c7113c684c2b3f1c83cdd3376103ee0ce4c49ff80a648643e57fb22218"}, + {file = "pyzmq-26.2.0-cp312-cp312-macosx_10_15_universal2.whl", hash = "sha256:ded0fc7d90fe93ae0b18059930086c51e640cdd3baebdc783a695c77f123dcd9"}, + {file = "pyzmq-26.2.0-cp39-cp39-macosx_10_15_universal2.whl", hash = "sha256:b1d464cb8d72bfc1a3adc53305a63a8e0cac6bc8c5a07e8ca190ab8d3faa43c2"}, + {file = "pyzmq-26.2.0.tar.gz", hash = "sha256:070672c258581c8e4f640b5159297580a9974b026043bd4ab0470be9ed324f1f"}, +] + +[[package]] +name = "qtpy" +version = "2.4.1" +requires_python = ">=3.7" +summary = "Provides an abstraction layer on top of the various Qt bindings (PyQt5/6 and PySide2/6)." +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "packaging", +] +files = [ + {file = "QtPy-2.4.1-py3-none-any.whl", hash = "sha256:1c1d8c4fa2c884ae742b069151b0abe15b3f70491f3972698c683b8e38de839b"}, + {file = "QtPy-2.4.1.tar.gz", hash = "sha256:a5a15ffd519550a1361bdc56ffc07fda56a6af7292f17c7b395d4083af632987"}, +] + +[[package]] +name = "referencing" +version = "0.35.1" +requires_python = ">=3.8" +summary = "JSON Referencing + Python" +groups = ["docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "attrs>=22.2.0", + "rpds-py>=0.7.0", +] +files = [ + {file = "referencing-0.35.1-py3-none-any.whl", hash = "sha256:eda6d3234d62814d1c64e305c1331c9a3a6132da475ab6382eaa997b21ee75de"}, + {file = "referencing-0.35.1.tar.gz", hash = "sha256:25b42124a6c8b632a425174f24087783efb348a6f1e0008e63cd4466fedf703c"}, +] + +[[package]] +name = "requests" +version = "2.32.3" +requires_python = ">=3.8" +summary = "Python HTTP for Humans." +groups = ["docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "certifi>=2017.4.17", + "charset-normalizer<4,>=2", + "idna<4,>=2.5", + "urllib3<3,>=1.21.1", +] +files = [ + {file = "requests-2.32.3-py3-none-any.whl", hash = "sha256:70761cfe03c773ceb22aa2f671b4757976145175cdfca038c02654d061d6dcc6"}, + {file = "requests-2.32.3.tar.gz", hash = "sha256:55365417734eb18255590a9ff9eb97e9e1da868d4ccd6402399eaf68af20a760"}, +] + +[[package]] +name = "rfc3339-validator" +version = "0.1.4" +requires_python = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*" +summary = "A pure python RFC3339 validator" +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "six", +] +files = [ + {file = "rfc3339_validator-0.1.4-py2.py3-none-any.whl", hash = "sha256:24f6ec1eda14ef823da9e36ec7113124b39c04d50a4d3d3a3c2859577e7791fa"}, + {file = "rfc3339_validator-0.1.4.tar.gz", hash = "sha256:138a2abdf93304ad60530167e51d2dfb9549521a836871b88d7f4695d0022f6b"}, +] + +[[package]] +name = "rfc3986-validator" +version = "0.1.1" +requires_python = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*" +summary = "Pure python rfc3986 validator" +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "rfc3986_validator-0.1.1-py2.py3-none-any.whl", hash = "sha256:2f235c432ef459970b4306369336b9d5dbdda31b510ca1e327636e01f528bfa9"}, + {file = "rfc3986_validator-0.1.1.tar.gz", hash = "sha256:3d44bde7921b3b9ec3ae4e3adca370438eccebc676456449b145d533b240d055"}, +] + +[[package]] +name = "rich" +version = "13.8.1" +requires_python = ">=3.7.0" +summary = "Render rich text, tables, progress bars, syntax highlighting, markdown and more to the terminal" +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "markdown-it-py>=2.2.0", + "pygments<3.0.0,>=2.13.0", + "typing-extensions<5.0,>=4.0.0; python_version < \"3.9\"", +] +files = [ + {file = "rich-13.8.1-py3-none-any.whl", hash = "sha256:1760a3c0848469b97b558fc61c85233e3dafb69c7a071b4d60c38099d3cd4c06"}, + {file = "rich-13.8.1.tar.gz", hash = "sha256:8260cda28e3db6bf04d2d1ef4dbc03ba80a824c88b0e7668a0f23126a424844a"}, +] + +[[package]] +name = "rpds-py" +version = "0.20.0" +requires_python = ">=3.8" +summary = "Python bindings to Rust's persistent data structures (rpds)" +groups = ["docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "rpds_py-0.20.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:9bb4a0d90fdb03437c109a17eade42dfbf6190408f29b2744114d11586611d6f"}, + {file = "rpds_py-0.20.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:220002c1b846db9afd83371d08d239fdc865e8f8c5795bbaec20916a76db3318"}, + {file = "rpds_py-0.20.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:56e27147a5a4c2c21633ff8475d185734c0e4befd1c989b5b95a5d0db699b21b"}, + {file = "rpds_py-0.20.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:9824fb430c9cf9af743cf7aaf6707bf14323fb51ee74425c380f4c846ea70789"}, + {file = "rpds_py-0.20.0-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:9426133526f69fcaba6e42146b4e12d6bc6c839b8b555097020e2b78ce908dcc"}, + {file = "rpds_py-0.20.0-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:f60012a73aa396be721558caa3a6fd49b3dd0033d1675c6d59c4502e870fcf0c"}, + {file = "rpds_py-0.20.0.tar.gz", hash = "sha256:d72a210824facfdaf8768cf2d7ca25a042c30320b3020de2fa04640920d4e121"}, +] + +[[package]] +name = "scipy" +version = "1.13.1" +requires_python = ">=3.9" +summary = "Fundamental algorithms for scientific computing in Python" +groups = ["default"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "numpy<2.3,>=1.22.4", +] +files = [ + {file = "scipy-1.13.1-cp310-cp310-macosx_12_0_arm64.whl", hash = "sha256:d605e9c23906d1994f55ace80e0125c587f96c020037ea6aa98d01b4bd2e222f"}, + {file = "scipy-1.13.1-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:54f430b00f0133e2224c3ba42b805bfd0086fe488835effa33fa291561932326"}, + {file = "scipy-1.13.1-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:017367484ce5498445aade74b1d5ab377acdc65e27095155e448c88497755a5d"}, + {file = "scipy-1.13.1-cp39-cp39-macosx_12_0_arm64.whl", hash = "sha256:8335549ebbca860c52bf3d02f80784e91a004b71b059e3eea9678ba994796a24"}, + {file = "scipy-1.13.1.tar.gz", hash = "sha256:095a87a0312b08dfd6a6155cbbd310a8c51800fc931b8c0b84003014b874ed3c"}, +] + +[[package]] +name = "scooby" +version = "0.10.0" +requires_python = ">=3.8" +summary = "A Great Dane turned Python environment detective" +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "scooby-0.10.0-py3-none-any.whl", hash = "sha256:0a3d7e304f8ebb16f69ff7f6360c345d7f50b45f2ddbf7c3d18a6a0dc2cb03a6"}, + {file = "scooby-0.10.0.tar.gz", hash = "sha256:7ea33c262c0cc6a33c6eeeb5648df787be4f22660e53c114e5fff1b811a8854f"}, +] + +[[package]] +name = "send2trash" +version = "1.8.3" +requires_python = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7" +summary = "Send file to trash natively under Mac OS X, Windows and Linux" +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "Send2Trash-1.8.3-py3-none-any.whl", hash = "sha256:0c31227e0bd08961c7665474a3d1ef7193929fedda4233843689baa056be46c9"}, + {file = "Send2Trash-1.8.3.tar.gz", hash = "sha256:b18e7a3966d99871aefeb00cfbcfdced55ce4871194810fc71f4aa484b953abf"}, +] + +[[package]] +name = "setuptools" +version = "74.1.2" +requires_python = ">=3.8" +summary = "Easily download, build, install, upgrade, and uninstall Python packages" +groups = ["qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "setuptools-74.1.2-py3-none-any.whl", hash = "sha256:5f4c08aa4d3ebcb57a50c33b1b07e94315d7fc7230f7115e47fc99776c8ce308"}, + {file = "setuptools-74.1.2.tar.gz", hash = "sha256:95b40ed940a1c67eb70fc099094bd6e99c6ee7c23aa2306f4d2697ba7916f9c6"}, +] + +[[package]] +name = "simpervisor" +version = "1.0.0" +requires_python = ">=3.8" +summary = "Simple async process supervisor" +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "simpervisor-1.0.0-py3-none-any.whl", hash = "sha256:3e313318264559beea3f475ead202bc1cd58a2f1288363abb5657d306c5b8388"}, + {file = "simpervisor-1.0.0.tar.gz", hash = "sha256:7eb87ca86d5e276976f5bb0290975a05d452c6a7b7f58062daea7d8369c823c1"}, +] + +[[package]] +name = "six" +version = "1.16.0" +requires_python = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*" +summary = "Python 2 and 3 compatibility utilities" +groups = ["default", "docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "six-1.16.0-py2.py3-none-any.whl", hash = "sha256:8abb2f1d86890a2dfb989f9a77cfcfd3e47c2a354b01111771326f8aa26e0254"}, + {file = "six-1.16.0.tar.gz", hash = "sha256:1e61c37477a1626458e36f7b1d82aa5c9b094fa4802892072e49de9c60c4c926"}, +] + +[[package]] +name = "sniffio" +version = "1.3.1" +requires_python = ">=3.7" +summary = "Sniff out which async library your code is running under" +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "sniffio-1.3.1-py3-none-any.whl", hash = "sha256:2f6da418d1f1e0fddd844478f41680e794e6051915791a034ff65e5f100525a2"}, + {file = "sniffio-1.3.1.tar.gz", hash = "sha256:f4324edc670a0f49750a81b895f35c3adb843cca46f0530f79fc1babb23789dc"}, +] + +[[package]] +name = "snowballstemmer" +version = "2.2.0" +summary = "This package provides 29 stemmers for 28 languages generated from Snowball algorithms." +groups = ["docs"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "snowballstemmer-2.2.0-py2.py3-none-any.whl", hash = "sha256:c8e1716e83cc398ae16824e5572ae04e0d9fc2c6b985fb0f900f5f0c96ecba1a"}, + {file = "snowballstemmer-2.2.0.tar.gz", hash = "sha256:09b16deb8547d3412ad7b590689584cd0fe25ec8db3be37788be3810cbf19cb1"}, +] + +[[package]] +name = "soupsieve" +version = "2.6" +requires_python = ">=3.8" +summary = "A modern CSS selector implementation for Beautiful Soup." +groups = ["docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "soupsieve-2.6-py3-none-any.whl", hash = "sha256:e72c4ff06e4fb6e4b5a9f0f55fe6e81514581fca1515028625d0f299c602ccc9"}, + {file = "soupsieve-2.6.tar.gz", hash = "sha256:e2e68417777af359ec65daac1057404a3c8a5455bb8abc36f1a9866ab1a51abb"}, +] + +[[package]] +name = "sphinx" +version = "7.4.7" +requires_python = ">=3.9" +summary = "Python documentation generator" +groups = ["docs"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "Jinja2>=3.1", + "Pygments>=2.17", + "alabaster~=0.7.14", + "babel>=2.13", + "colorama>=0.4.6; sys_platform == \"win32\"", + "docutils<0.22,>=0.20", + "imagesize>=1.3", + "importlib-metadata>=6.0; python_version < \"3.10\"", + "packaging>=23.0", + "requests>=2.30.0", + "snowballstemmer>=2.2", + "sphinxcontrib-applehelp", + "sphinxcontrib-devhelp", + "sphinxcontrib-htmlhelp>=2.0.0", + "sphinxcontrib-jsmath", + "sphinxcontrib-qthelp", + "sphinxcontrib-serializinghtml>=1.1.9", + "tomli>=2; python_version < \"3.11\"", +] +files = [ + {file = "sphinx-7.4.7-py3-none-any.whl", hash = "sha256:c2419e2135d11f1951cd994d6eb18a1835bd8fdd8429f9ca375dc1f3281bd239"}, + {file = "sphinx-7.4.7.tar.gz", hash = "sha256:242f92a7ea7e6c5b406fdc2615413890ba9f699114a9c09192d7dfead2ee9cfe"}, +] + +[[package]] +name = "sphinx-rtd-theme" +version = "3.0.2" +requires_python = ">=3.8" +summary = "Read the Docs theme for Sphinx" +groups = ["docs"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "docutils<0.22,>0.18", + "sphinx<9,>=6", + "sphinxcontrib-jquery<5,>=4", +] +files = [ + {file = "sphinx_rtd_theme-3.0.2-py2.py3-none-any.whl", hash = "sha256:422ccc750c3a3a311de4ae327e82affdaf59eb695ba4936538552f3b00f4ee13"}, + {file = "sphinx_rtd_theme-3.0.2.tar.gz", hash = "sha256:b7457bc25dda723b20b086a670b9953c859eab60a2a03ee8eb2bb23e176e5f85"}, +] + +[[package]] +name = "sphinxcontrib-applehelp" +version = "2.0.0" +requires_python = ">=3.9" +summary = "sphinxcontrib-applehelp is a Sphinx extension which outputs Apple help books" +groups = ["docs"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "sphinxcontrib_applehelp-2.0.0-py3-none-any.whl", hash = "sha256:4cd3f0ec4ac5dd9c17ec65e9ab272c9b867ea77425228e68ecf08d6b28ddbdb5"}, + {file = "sphinxcontrib_applehelp-2.0.0.tar.gz", hash = "sha256:2f29ef331735ce958efa4734873f084941970894c6090408b079c61b2e1c06d1"}, +] + +[[package]] +name = "sphinxcontrib-devhelp" +version = "2.0.0" +requires_python = ">=3.9" +summary = "sphinxcontrib-devhelp is a sphinx extension which outputs Devhelp documents" +groups = ["docs"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "sphinxcontrib_devhelp-2.0.0-py3-none-any.whl", hash = "sha256:aefb8b83854e4b0998877524d1029fd3e6879210422ee3780459e28a1f03a8a2"}, + {file = "sphinxcontrib_devhelp-2.0.0.tar.gz", hash = "sha256:411f5d96d445d1d73bb5d52133377b4248ec79db5c793ce7dbe59e074b4dd1ad"}, +] + +[[package]] +name = "sphinxcontrib-htmlhelp" +version = "2.1.0" +requires_python = ">=3.9" +summary = "sphinxcontrib-htmlhelp is a sphinx extension which renders HTML help files" +groups = ["docs"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "sphinxcontrib_htmlhelp-2.1.0-py3-none-any.whl", hash = "sha256:166759820b47002d22914d64a075ce08f4c46818e17cfc9470a9786b759b19f8"}, + {file = "sphinxcontrib_htmlhelp-2.1.0.tar.gz", hash = "sha256:c9e2916ace8aad64cc13a0d233ee22317f2b9025b9cf3295249fa985cc7082e9"}, +] + +[[package]] +name = "sphinxcontrib-jquery" +version = "4.1" +requires_python = ">=2.7" +summary = "Extension to include jQuery on newer Sphinx releases" +groups = ["docs"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "Sphinx>=1.8", +] +files = [ + {file = "sphinxcontrib-jquery-4.1.tar.gz", hash = "sha256:1620739f04e36a2c779f1a131a2dfd49b2fd07351bf1968ced074365933abc7a"}, + {file = "sphinxcontrib_jquery-4.1-py2.py3-none-any.whl", hash = "sha256:f936030d7d0147dd026a4f2b5a57343d233f1fc7b363f68b3d4f1cb0993878ae"}, +] + +[[package]] +name = "sphinxcontrib-jsmath" +version = "1.0.1" +requires_python = ">=3.5" +summary = "A sphinx extension which renders display math in HTML via JavaScript" +groups = ["docs"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "sphinxcontrib-jsmath-1.0.1.tar.gz", hash = "sha256:a9925e4a4587247ed2191a22df5f6970656cb8ca2bd6284309578f2153e0c4b8"}, + {file = "sphinxcontrib_jsmath-1.0.1-py2.py3-none-any.whl", hash = "sha256:2ec2eaebfb78f3f2078e73666b1415417a116cc848b72e5172e596c871103178"}, +] + +[[package]] +name = "sphinxcontrib-qthelp" +version = "2.0.0" +requires_python = ">=3.9" +summary = "sphinxcontrib-qthelp is a sphinx extension which outputs QtHelp documents" +groups = ["docs"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "sphinxcontrib_qthelp-2.0.0-py3-none-any.whl", hash = "sha256:b18a828cdba941ccd6ee8445dbe72ffa3ef8cbe7505d8cd1fa0d42d3f2d5f3eb"}, + {file = "sphinxcontrib_qthelp-2.0.0.tar.gz", hash = "sha256:4fe7d0ac8fc171045be623aba3e2a8f613f8682731f9153bb2e40ece16b9bbab"}, +] + +[[package]] +name = "sphinxcontrib-serializinghtml" +version = "2.0.0" +requires_python = ">=3.9" +summary = "sphinxcontrib-serializinghtml is a sphinx extension which outputs \"serialized\" HTML files (json and pickle)" +groups = ["docs"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "sphinxcontrib_serializinghtml-2.0.0-py3-none-any.whl", hash = "sha256:6e2cb0eef194e10c27ec0023bfeb25badbbb5868244cf5bc5bdc04e4464bf331"}, + {file = "sphinxcontrib_serializinghtml-2.0.0.tar.gz", hash = "sha256:e9d912827f872c029017a53f0ef2180b327c3f7fd23c87229f7a8e8b70031d4d"}, +] + +[[package]] +name = "stack-data" +version = "0.6.3" +summary = "Extract data from python stack frames and tracebacks for informative displays" +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "asttokens>=2.1.0", + "executing>=1.2.0", + "pure-eval", +] +files = [ + {file = "stack_data-0.6.3-py3-none-any.whl", hash = "sha256:d5558e0c25a4cb0853cddad3d77da9891a08cb85dd9f9f91b9f8cd66e511e695"}, + {file = "stack_data-0.6.3.tar.gz", hash = "sha256:836a778de4fec4dcd1dcd89ed8abff8a221f58308462e1c4aa2a3cf30148f0b9"}, +] + +[[package]] +name = "terminado" +version = "0.18.1" +requires_python = ">=3.8" +summary = "Tornado websocket backend for the Xterm.js Javascript terminal emulator library." +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "ptyprocess; os_name != \"nt\"", + "pywinpty>=1.1.0; os_name == \"nt\"", + "tornado>=6.1.0", +] +files = [ + {file = "terminado-0.18.1-py3-none-any.whl", hash = "sha256:a4468e1b37bb318f8a86514f65814e1afc977cf29b3992a4500d9dd305dcceb0"}, + {file = "terminado-0.18.1.tar.gz", hash = "sha256:de09f2c4b85de4765f7714688fff57d3e75bad1f909b589fde880460c753fd2e"}, +] + +[[package]] +name = "tinycss2" +version = "1.3.0" +requires_python = ">=3.8" +summary = "A tiny CSS parser" +groups = ["docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "webencodings>=0.4", +] +files = [ + {file = "tinycss2-1.3.0-py3-none-any.whl", hash = "sha256:54a8dbdffb334d536851be0226030e9505965bb2f30f21a4a82c55fb2a80fae7"}, + {file = "tinycss2-1.3.0.tar.gz", hash = "sha256:152f9acabd296a8375fbca5b84c961ff95971fcfc32e79550c8df8e29118c54d"}, +] + +[[package]] +name = "tomli" +version = "2.2.1" +requires_python = ">=3.8" +summary = "A lil' TOML parser" +groups = ["docs", "qa"] +marker = "python_version < \"3.11\" and python_version >= \"3.9\"" +files = [ + {file = "tomli-2.2.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:023aa114dd824ade0100497eb2318602af309e5a55595f76b626d6d9f3b7b0a6"}, + {file = "tomli-2.2.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:8d57ca8095a641b8237d5b079147646153d22552f1c637fd3ba7f4b0b29167a8"}, + {file = "tomli-2.2.1-py3-none-any.whl", hash = "sha256:cb55c73c5f4408779d0cf3eef9f762b9c9f147a77de7b258bef0a5628adc85cc"}, + {file = "tomli-2.2.1.tar.gz", hash = "sha256:cd45e1dc79c835ce60f7404ec8119f2eb06d38b1deba146f07ced3bbc44505ff"}, +] + +[[package]] +name = "tornado" +version = "6.4.2" +requires_python = ">=3.8" +summary = "Tornado is a Python web framework and asynchronous networking library, originally developed at FriendFeed." +groups = ["docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "tornado-6.4.2-cp38-abi3-macosx_10_9_universal2.whl", hash = "sha256:e828cce1123e9e44ae2a50a9de3055497ab1d0aeb440c5ac23064d9e44880da1"}, + {file = "tornado-6.4.2.tar.gz", hash = "sha256:92bad5b4746e9879fd7bf1eb21dce4e3fc5128d71601f80005afa39237ad620b"}, +] + +[[package]] +name = "tox" +version = "4.24.1" +requires_python = ">=3.8" +summary = "tox is a generic virtualenv management and test command line tool" +groups = ["qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "cachetools>=5.5", + "chardet>=5.2", + "colorama>=0.4.6", + "filelock>=3.16.1", + "packaging>=24.2", + "platformdirs>=4.3.6", + "pluggy>=1.5", + "pyproject-api>=1.8", + "tomli>=2.1; python_version < \"3.11\"", + "typing-extensions>=4.12.2; python_version < \"3.11\"", + "virtualenv>=20.27.1", +] +files = [ + {file = "tox-4.24.1-py3-none-any.whl", hash = "sha256:57ba7df7d199002c6df8c2db9e6484f3de6ca8f42013c083ea2d4d1e5c6bdc75"}, + {file = "tox-4.24.1.tar.gz", hash = "sha256:083a720adbc6166fff0b7d1df9d154f9d00bfccb9403b8abf6bc0ee435d6a62e"}, +] + +[[package]] +name = "tqdm" +version = "4.67.1" +requires_python = ">=3.7" +summary = "Fast, Extensible Progress Meter" +groups = ["default"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "colorama; platform_system == \"Windows\"", +] +files = [ + {file = "tqdm-4.67.1-py3-none-any.whl", hash = "sha256:26445eca388f82e72884e0d580d5464cd801a3ea01e63e5601bdff9ba6a48de2"}, + {file = "tqdm-4.67.1.tar.gz", hash = "sha256:f8aef9c52c08c13a65f30ea34f4e5aac3fd1a34959879d7e59e63027286627f2"}, +] + +[[package]] +name = "traitlets" +version = "5.14.3" +requires_python = ">=3.8" +summary = "Traitlets Python configuration system" +groups = ["docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "traitlets-5.14.3-py3-none-any.whl", hash = "sha256:b74e89e397b1ed28cc831db7aea759ba6640cb3de13090ca145426688ff1ac4f"}, + {file = "traitlets-5.14.3.tar.gz", hash = "sha256:9ed0579d3502c94b4b3732ac120375cda96f923114522847de4b3bb98b96b6b7"}, +] + +[[package]] +name = "trame" +version = "3.6.5" +summary = "Trame, a framework to build applications in plain Python" +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "trame-client<4,>=3", + "trame-server<4,>=3", + "wslink>=2.1.3", +] +files = [ + {file = "trame-3.6.5-py3-none-any.whl", hash = "sha256:58b5be29287d275dbd2be15b4e453c788361f640253ad153ca99fb3eb28e00f3"}, + {file = "trame-3.6.5.tar.gz", hash = "sha256:fc26a7067f94377e01263facb4cd40b111d799d970b5fc8e2aecb52e60378959"}, +] + +[[package]] +name = "trame-client" +version = "3.2.5" +summary = "Internal client of trame" +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "trame-client-3.2.5.tar.gz", hash = "sha256:6f81c2a78389f1962bec38a318b0de47f241dae7778b25dba75fa3ed4d58bd33"}, + {file = "trame_client-3.2.5-py3-none-any.whl", hash = "sha256:023e062175fef67d45a65ac7a367b0e3468f6746c4f8c7a7aa3fe8e82273c62a"}, +] + +[[package]] +name = "trame-server" +version = "3.1.2" +summary = "Internal server side implementation of trame" +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "more-itertools", + "wslink<3,>=2", +] +files = [ + {file = "trame-server-3.1.2.tar.gz", hash = "sha256:03bdd81e0132fb55de7b493c7ebdc4c21f6b0003960bceb3adca258fc432211f"}, + {file = "trame_server-3.1.2-py3-none-any.whl", hash = "sha256:b43d11edfbca012ac34a724dc751b6ecfaecd7d636eaea4ab0650d2adc9e3771"}, +] + +[[package]] +name = "trame-vtk" +version = "2.8.10" +summary = "VTK widgets for trame" +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "trame-client", +] +files = [ + {file = "trame-vtk-2.8.10.tar.gz", hash = "sha256:4d8e38f7c1d5be8eafc28254bd5bd5dc5d4b336a334b944fc9383c9624184b5e"}, + {file = "trame_vtk-2.8.10-py3-none-any.whl", hash = "sha256:0fe850d1358193c1d73c9af87715d7877210df53edf4e4d468ba396c0845765c"}, +] + +[[package]] +name = "trame-vuetify" +version = "2.7.1" +summary = "Vuetify widgets for trame" +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "trame-client", +] +files = [ + {file = "trame-vuetify-2.7.1.tar.gz", hash = "sha256:48443910a3a53b9fa040e05b261fce9326fe95309b3798d49f0d6aec84cbfdf8"}, + {file = "trame_vuetify-2.7.1-py3-none-any.whl", hash = "sha256:c6bfe3be49ac8b7aa354e4e2c1d92f2c2e9680eea563f46146eef6968a66c2de"}, +] + +[[package]] +name = "types-python-dateutil" +version = "2.9.0.20240906" +requires_python = ">=3.8" +summary = "Typing stubs for python-dateutil" +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "types-python-dateutil-2.9.0.20240906.tar.gz", hash = "sha256:9706c3b68284c25adffc47319ecc7947e5bb86b3773f843c73906fd598bc176e"}, + {file = "types_python_dateutil-2.9.0.20240906-py3-none-any.whl", hash = "sha256:27c8cc2d058ccb14946eebcaaa503088f4f6dbc4fb6093d3d456a49aef2753f6"}, +] + +[[package]] +name = "typing-extensions" +version = "4.12.2" +requires_python = ">=3.8" +summary = "Backported and Experimental Type Hints for Python 3.8+" +groups = ["default", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "typing_extensions-4.12.2-py3-none-any.whl", hash = "sha256:04e5ca0351e0f3f85c6853954072df659d0d13fac324d0072316b67d7794700d"}, + {file = "typing_extensions-4.12.2.tar.gz", hash = "sha256:1a7ead55c7e559dd4dee8856e3a88b41225abfe1ce8df57b7c13915fe121ffb8"}, +] + +[[package]] +name = "tzdata" +version = "2024.1" +requires_python = ">=2" +summary = "Provider of IANA time zone data" +groups = ["default"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "tzdata-2024.1-py2.py3-none-any.whl", hash = "sha256:9068bc196136463f5245e51efda838afa15aaeca9903f49050dfa2679db4d252"}, + {file = "tzdata-2024.1.tar.gz", hash = "sha256:2674120f8d891909751c38abcdfd386ac0a5a1127954fbc332af6b5ceae07efd"}, +] + +[[package]] +name = "uri-template" +version = "1.3.0" +requires_python = ">=3.7" +summary = "RFC 6570 URI Template Processor" +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "uri-template-1.3.0.tar.gz", hash = "sha256:0e00f8eb65e18c7de20d595a14336e9f337ead580c70934141624b6d1ffdacc7"}, + {file = "uri_template-1.3.0-py3-none-any.whl", hash = "sha256:a44a133ea12d44a0c0f06d7d42a52d71282e77e2f937d8abd5655b8d56fc1363"}, +] + +[[package]] +name = "urllib3" +version = "2.2.2" +requires_python = ">=3.8" +summary = "HTTP library with thread-safe connection pooling, file post, and more." +groups = ["docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "urllib3-2.2.2-py3-none-any.whl", hash = "sha256:a448b2f64d686155468037e1ace9f2d2199776e17f0a46610480d311f73e3472"}, + {file = "urllib3-2.2.2.tar.gz", hash = "sha256:dd505485549a7a552833da5e6063639d0d177c04f23bc3864e41e5dc5f612168"}, +] + +[[package]] +name = "virtualenv" +version = "20.29.1" +requires_python = ">=3.8" +summary = "Virtual Python Environment builder" +groups = ["qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "distlib<1,>=0.3.7", + "filelock<4,>=3.12.2", + "importlib-metadata>=6.6; python_version < \"3.8\"", + "platformdirs<5,>=3.9.1", +] +files = [ + {file = "virtualenv-20.29.1-py3-none-any.whl", hash = "sha256:4e4cb403c0b0da39e13b46b1b2476e505cb0046b25f242bee80f62bf990b2779"}, + {file = "virtualenv-20.29.1.tar.gz", hash = "sha256:b8b8970138d32fb606192cb97f6cd4bb644fa486be9308fb9b63f81091b5dc35"}, +] + +[[package]] +name = "vtk" +version = "9.3.1" +summary = "VTK is an open-source toolkit for 3D computer graphics, image processing, and visualization" +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "matplotlib>=2.0.0", +] +files = [ + {file = "vtk-9.3.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:84c04327becc4c4dfe1fb04248baa4b5c480f188a9d52f4b912b163d33622442"}, + {file = "vtk-9.3.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:c977486b0e4d87cddb3f2c7c0710d1c86243cdd01286cbd036231143d8eb4f6e"}, + {file = "vtk-9.3.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:bdbefb1aef9599a0a0b8222c9582f26946732a93534e6ec37d4b8e2c524c627e"}, + {file = "vtk-9.3.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:ab96d6923fa37a202874cb8b8b4202d537bd4702bb151638d384e1966d877e3a"}, +] + +[[package]] +name = "wcwidth" +version = "0.2.13" +summary = "Measures the displayed width of unicode strings in a terminal" +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "backports-functools-lru-cache>=1.2.1; python_version < \"3.2\"", +] +files = [ + {file = "wcwidth-0.2.13-py2.py3-none-any.whl", hash = "sha256:3da69048e4540d84af32131829ff948f1e022c1c6bdb8d6102117aac784f6859"}, + {file = "wcwidth-0.2.13.tar.gz", hash = "sha256:72ea0c06399eb286d978fdedb6923a9eb47e1c486ce63e9b4e64fc18303972b5"}, +] + +[[package]] +name = "webcolors" +version = "24.8.0" +requires_python = ">=3.8" +summary = "A library for working with the color formats defined by HTML and CSS." +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "webcolors-24.8.0-py3-none-any.whl", hash = "sha256:fc4c3b59358ada164552084a8ebee637c221e4059267d0f8325b3b560f6c7f0a"}, + {file = "webcolors-24.8.0.tar.gz", hash = "sha256:08b07af286a01bcd30d583a7acadf629583d1f79bfef27dd2c2c5c263817277d"}, +] + +[[package]] +name = "webencodings" +version = "0.5.1" +summary = "Character encoding aliases for legacy web content" +groups = ["docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "webencodings-0.5.1-py2.py3-none-any.whl", hash = "sha256:a0af1213f3c2226497a97e2b3aa01a7e4bee4f403f95be16fc9acd2947514a78"}, + {file = "webencodings-0.5.1.tar.gz", hash = "sha256:b36a1c245f2d304965eb4e0a82848379241dc04b865afcc4aab16748587e1923"}, +] + +[[package]] +name = "websocket-client" +version = "1.8.0" +requires_python = ">=3.8" +summary = "WebSocket client for Python with low level API options" +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "websocket_client-1.8.0-py3-none-any.whl", hash = "sha256:17b44cc997f5c498e809b22cdf2d9c7a9e71c02c8cc2b6c56e7c2d1239bfa526"}, + {file = "websocket_client-1.8.0.tar.gz", hash = "sha256:3239df9f44da632f96012472805d40a23281a991027ce11d2f45a6f24ac4c3da"}, +] + +[[package]] +name = "widgetsnbextension" +version = "4.0.13" +requires_python = ">=3.7" +summary = "Jupyter interactive widgets for Jupyter Notebook" +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "widgetsnbextension-4.0.13-py3-none-any.whl", hash = "sha256:74b2692e8500525cc38c2b877236ba51d34541e6385eeed5aec15a70f88a6c71"}, + {file = "widgetsnbextension-4.0.13.tar.gz", hash = "sha256:ffcb67bc9febd10234a362795f643927f4e0c05d9342c727b65d2384f8feacb6"}, +] + +[[package]] +name = "wslink" +version = "2.1.3" +summary = "Python/JavaScript library for communicating over WebSocket" +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "aiohttp<4", + "msgpack<2,>=1", +] +files = [ + {file = "wslink-2.1.3-py3-none-any.whl", hash = "sha256:a4a3689a30dd108255560e2f56903003355f4e0f3f6e5f12033a6de108bba18a"}, + {file = "wslink-2.1.3.tar.gz", hash = "sha256:528d008f1a6110bc8141c32588e43b16ff438cedb80c5bb85e9ef92ae753c98e"}, +] + +[[package]] +name = "yarl" +version = "1.18.3" +requires_python = ">=3.9" +summary = "Yet another URL library" +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "idna>=2.0", + "multidict>=4.0", + "propcache>=0.2.0", +] +files = [ + {file = "yarl-1.18.3-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:7df647e8edd71f000a5208fe6ff8c382a1de8edfbccdbbfe649d263de07d8c34"}, + {file = "yarl-1.18.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:602d98f2c2d929f8e697ed274fbadc09902c4025c5a9963bf4e9edfc3ab6f7ed"}, + {file = "yarl-1.18.3-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:8503ad47387b8ebd39cbbbdf0bf113e17330ffd339ba1144074da24c545f0069"}, + {file = "yarl-1.18.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:67a283dd2882ac98cc6318384f565bffc751ab564605959df4752d42483ad889"}, + {file = "yarl-1.18.3-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:1dd4bdd05407ced96fed3d7f25dbbf88d2ffb045a0db60dbc247f5b3c5c25d50"}, + {file = "yarl-1.18.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:25b411eddcfd56a2f0cd6a384e9f4f7aa3efee14b188de13048c25b5e91f1640"}, + {file = "yarl-1.18.3-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:61e5e68cb65ac8f547f6b5ef933f510134a6bf31bb178be428994b0cb46c2a04"}, + {file = "yarl-1.18.3-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:a440a2a624683108a1b454705ecd7afc1c3438a08e890a1513d468671d90a04e"}, + {file = "yarl-1.18.3-py3-none-any.whl", hash = "sha256:b57f4f58099328dfb26c6a771d09fb20dbbae81d20cfb66141251ea063bd101b"}, + {file = "yarl-1.18.3.tar.gz", hash = "sha256:ac1801c45cbf77b6c99242eeff4fffb5e4e73a800b5c4ad4fc0be5def634d2e1"}, +] + +[[package]] +name = "zipp" +version = "3.20.1" +requires_python = ">=3.8" +summary = "Backport of pathlib-compatible object wrapper for zip files" +groups = ["default", "docs", "pyvista", "qa"] +marker = "python_version < \"3.10\" and python_version >= \"3.9\"" +files = [ + {file = "zipp-3.20.1-py3-none-any.whl", hash = "sha256:9960cd8967c8f85a56f920d5d507274e74f9ff813a0ab8889a5b5be2daf44064"}, + {file = "zipp-3.20.1.tar.gz", hash = "sha256:c22b14cc4763c5a5b04134207736c107db42e9d3ef2d9779d465f5f1bcba572b"}, +] diff --git a/pdm-py39+unix.lock b/pdm-py39+unix.lock new file mode 100644 index 0000000..faf7c52 --- /dev/null +++ b/pdm-py39+unix.lock @@ -0,0 +1,2977 @@ +# This file is @generated by PDM. +# It is not intended for manual editing. + +[metadata] +groups = ["default", "docs", "openpyxl", "pyvista", "qa"] +strategy = ["inherit_metadata"] +lock_version = "4.5.0" +content_hash = "sha256:22cd5aee3b297d0bb4e82486997918f7af7cd34c35252bce0aa0be1ee01bc0c1" + +[[metadata.targets]] +requires_python = ">=3.9,<3.13" +platform = "manylinux_2_17_x86_64" + +[[package]] +name = "aiohappyeyeballs" +version = "2.4.0" +requires_python = ">=3.8" +summary = "Happy Eyeballs for asyncio" +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "aiohappyeyeballs-2.4.0-py3-none-any.whl", hash = "sha256:7ce92076e249169a13c2f49320d1967425eaf1f407522d707d59cac7628d62bd"}, + {file = "aiohappyeyeballs-2.4.0.tar.gz", hash = "sha256:55a1714f084e63d49639800f95716da97a1f173d46a16dfcfda0016abb93b6b2"}, +] + +[[package]] +name = "aiohttp" +version = "3.11.12" +requires_python = ">=3.9" +summary = "Async http client/server framework (asyncio)" +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "aiohappyeyeballs>=2.3.0", + "aiosignal>=1.1.2", + "async-timeout<6.0,>=4.0; python_version < \"3.11\"", + "attrs>=17.3.0", + "frozenlist>=1.1.1", + "multidict<7.0,>=4.5", + "propcache>=0.2.0", + "yarl<2.0,>=1.17.0", +] +files = [ + {file = "aiohttp-3.11.12-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0b5263dcede17b6b0c41ef0c3ccce847d82a7da98709e75cf7efde3e9e3b5cae"}, + {file = "aiohttp-3.11.12-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8340def6737118f5429a5df4e88f440746b791f8f1c4ce4ad8a595f42c980bd5"}, + {file = "aiohttp-3.11.12-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6dfe7f984f28a8ae94ff3a7953cd9678550dbd2a1f9bda5dd9c5ae627744c78e"}, + {file = "aiohttp-3.11.12-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a478aa11b328983c4444dacb947d4513cb371cd323f3845e53caeda6be5589d5"}, + {file = "aiohttp-3.11.12.tar.gz", hash = "sha256:7603ca26d75b1b86160ce1bbe2787a0b706e592af5b2504e12caa88a217767b0"}, +] + +[[package]] +name = "aiosignal" +version = "1.3.1" +requires_python = ">=3.7" +summary = "aiosignal: a list of registered asynchronous callbacks" +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "frozenlist>=1.1.0", +] +files = [ + {file = "aiosignal-1.3.1-py3-none-any.whl", hash = "sha256:f8376fb07dd1e86a584e4fcdec80b36b7f81aac666ebc724e2c090300dd83b17"}, + {file = "aiosignal-1.3.1.tar.gz", hash = "sha256:54cd96e15e1649b75d6c87526a6ff0b6c1b0dd3459f43d9ca11d48c339b68cfc"}, +] + +[[package]] +name = "alabaster" +version = "0.7.16" +requires_python = ">=3.9" +summary = "A light, configurable Sphinx theme" +groups = ["docs"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "alabaster-0.7.16-py3-none-any.whl", hash = "sha256:b46733c07dce03ae4e150330b975c75737fa60f0a7c591b6c8bf4928a28e2c92"}, + {file = "alabaster-0.7.16.tar.gz", hash = "sha256:75a8b99c28a5dad50dd7f8ccdd447a121ddb3892da9e53d1ca5cca3106d58d65"}, +] + +[[package]] +name = "annotated-types" +version = "0.7.0" +requires_python = ">=3.8" +summary = "Reusable constraint types to use with typing.Annotated" +groups = ["default"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "typing-extensions>=4.0.0; python_version < \"3.9\"", +] +files = [ + {file = "annotated_types-0.7.0-py3-none-any.whl", hash = "sha256:1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53"}, + {file = "annotated_types-0.7.0.tar.gz", hash = "sha256:aff07c09a53a08bc8cfccb9c85b05f1aa9a2a6f23728d790723543408344ce89"}, +] + +[[package]] +name = "anyio" +version = "4.4.0" +requires_python = ">=3.8" +summary = "High level compatibility layer for multiple asynchronous event loop implementations" +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "exceptiongroup>=1.0.2; python_version < \"3.11\"", + "idna>=2.8", + "sniffio>=1.1", + "typing-extensions>=4.1; python_version < \"3.11\"", +] +files = [ + {file = "anyio-4.4.0-py3-none-any.whl", hash = "sha256:c1b2d8f46a8a812513012e1107cb0e68c17159a7a594208005a57dc776e1bdc7"}, + {file = "anyio-4.4.0.tar.gz", hash = "sha256:5aadc6a1bbb7cdb0bede386cac5e2940f5e2ff3aa20277e991cf028e0585ce94"}, +] + +[[package]] +name = "argon2-cffi" +version = "23.1.0" +requires_python = ">=3.7" +summary = "Argon2 for Python" +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "argon2-cffi-bindings", + "typing-extensions; python_version < \"3.8\"", +] +files = [ + {file = "argon2_cffi-23.1.0-py3-none-any.whl", hash = "sha256:c670642b78ba29641818ab2e68bd4e6a78ba53b7eff7b4c3815ae16abf91c7ea"}, + {file = "argon2_cffi-23.1.0.tar.gz", hash = "sha256:879c3e79a2729ce768ebb7d36d4609e3a78a4ca2ec3a9f12286ca057e3d0db08"}, +] + +[[package]] +name = "argon2-cffi-bindings" +version = "21.2.0" +requires_python = ">=3.6" +summary = "Low-level CFFI bindings for Argon2" +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "cffi>=1.0.1", +] +files = [ + {file = "argon2-cffi-bindings-21.2.0.tar.gz", hash = "sha256:bb89ceffa6c791807d1305ceb77dbfacc5aa499891d2c55661c6459651fc39e3"}, + {file = "argon2_cffi_bindings-21.2.0-cp36-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b746dba803a79238e925d9046a63aa26bf86ab2a2fe74ce6b009a1c3f5c8f2ae"}, +] + +[[package]] +name = "arrow" +version = "1.3.0" +requires_python = ">=3.8" +summary = "Better dates & times for Python" +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "python-dateutil>=2.7.0", + "types-python-dateutil>=2.8.10", +] +files = [ + {file = "arrow-1.3.0-py3-none-any.whl", hash = "sha256:c728b120ebc00eb84e01882a6f5e7927a53960aa990ce7dd2b10f39005a67f80"}, + {file = "arrow-1.3.0.tar.gz", hash = "sha256:d4540617648cb5f895730f1ad8c82a65f2dad0166f57b75f3ca54759c4d67a85"}, +] + +[[package]] +name = "asttokens" +version = "2.4.1" +summary = "Annotate AST trees with source code positions" +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "six>=1.12.0", + "typing; python_version < \"3.5\"", +] +files = [ + {file = "asttokens-2.4.1-py2.py3-none-any.whl", hash = "sha256:051ed49c3dcae8913ea7cd08e46a606dba30b79993209636c4875bc1d637bc24"}, + {file = "asttokens-2.4.1.tar.gz", hash = "sha256:b03869718ba9a6eb027e134bfdf69f38a236d681c83c160d510768af11254ba0"}, +] + +[[package]] +name = "async-lru" +version = "2.0.4" +requires_python = ">=3.8" +summary = "Simple LRU cache for asyncio" +groups = ["qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "typing-extensions>=4.0.0; python_version < \"3.11\"", +] +files = [ + {file = "async-lru-2.0.4.tar.gz", hash = "sha256:b8a59a5df60805ff63220b2a0c5b5393da5521b113cd5465a44eb037d81a5627"}, + {file = "async_lru-2.0.4-py3-none-any.whl", hash = "sha256:ff02944ce3c288c5be660c42dbcca0742b32c3b279d6dceda655190240b99224"}, +] + +[[package]] +name = "async-timeout" +version = "4.0.3" +requires_python = ">=3.7" +summary = "Timeout context manager for asyncio programs" +groups = ["pyvista"] +marker = "python_version < \"3.11\" and python_version >= \"3.9\"" +dependencies = [ + "typing-extensions>=3.6.5; python_version < \"3.8\"", +] +files = [ + {file = "async-timeout-4.0.3.tar.gz", hash = "sha256:4640d96be84d82d02ed59ea2b7105a0f7b33abe8703703cd0ab0bf87c427522f"}, + {file = "async_timeout-4.0.3-py3-none-any.whl", hash = "sha256:7405140ff1230c310e51dc27b3145b9092d659ce68ff733fb0cefe3ee42be028"}, +] + +[[package]] +name = "attrs" +version = "24.2.0" +requires_python = ">=3.7" +summary = "Classes Without Boilerplate" +groups = ["docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "importlib-metadata; python_version < \"3.8\"", +] +files = [ + {file = "attrs-24.2.0-py3-none-any.whl", hash = "sha256:81921eb96de3191c8258c199618104dd27ac608d9366f5e35d011eae1867ede2"}, + {file = "attrs-24.2.0.tar.gz", hash = "sha256:5cfb1b9148b5b086569baec03f20d7b6bf3bcacc9a42bebf87ffaaca362f6346"}, +] + +[[package]] +name = "babel" +version = "2.16.0" +requires_python = ">=3.8" +summary = "Internationalization utilities" +groups = ["docs", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "pytz>=2015.7; python_version < \"3.9\"", +] +files = [ + {file = "babel-2.16.0-py3-none-any.whl", hash = "sha256:368b5b98b37c06b7daf6696391c3240c938b37767d4584413e8438c5c435fa8b"}, + {file = "babel-2.16.0.tar.gz", hash = "sha256:d1f3554ca26605fe173f3de0c65f750f5a42f924499bf134de6423582298e316"}, +] + +[[package]] +name = "beautifulsoup4" +version = "4.12.3" +requires_python = ">=3.6.0" +summary = "Screen-scraping library" +groups = ["docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "soupsieve>1.2", +] +files = [ + {file = "beautifulsoup4-4.12.3-py3-none-any.whl", hash = "sha256:b80878c9f40111313e55da8ba20bdba06d8fa3969fc68304167741bbf9e082ed"}, + {file = "beautifulsoup4-4.12.3.tar.gz", hash = "sha256:74e3d1928edc070d21748185c46e3fb33490f22f52a3addee9aee0f4f7781051"}, +] + +[[package]] +name = "bleach" +version = "6.2.0" +requires_python = ">=3.9" +summary = "An easy safelist-based HTML-sanitizing tool." +groups = ["docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "webencodings", +] +files = [ + {file = "bleach-6.2.0-py3-none-any.whl", hash = "sha256:117d9c6097a7c3d22fd578fcd8d35ff1e125df6736f554da4e432fdd63f31e5e"}, + {file = "bleach-6.2.0.tar.gz", hash = "sha256:123e894118b8a599fd80d3ec1a6d4cc7ce4e5882b1317a7e1ba69b56e95f991f"}, +] + +[[package]] +name = "bleach" +version = "6.2.0" +extras = ["css"] +requires_python = ">=3.9" +summary = "An easy safelist-based HTML-sanitizing tool." +groups = ["docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "bleach==6.2.0", + "tinycss2<1.5,>=1.1.0", +] +files = [ + {file = "bleach-6.2.0-py3-none-any.whl", hash = "sha256:117d9c6097a7c3d22fd578fcd8d35ff1e125df6736f554da4e432fdd63f31e5e"}, + {file = "bleach-6.2.0.tar.gz", hash = "sha256:123e894118b8a599fd80d3ec1a6d4cc7ce4e5882b1317a7e1ba69b56e95f991f"}, +] + +[[package]] +name = "cachetools" +version = "5.5.0" +requires_python = ">=3.7" +summary = "Extensible memoizing collections and decorators" +groups = ["qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "cachetools-5.5.0-py3-none-any.whl", hash = "sha256:02134e8439cdc2ffb62023ce1debca2944c3f289d66bb17ead3ab3dede74b292"}, + {file = "cachetools-5.5.0.tar.gz", hash = "sha256:2cc24fb4cbe39633fb7badd9db9ca6295d766d9c2995f245725a46715d050f2a"}, +] + +[[package]] +name = "certifi" +version = "2024.8.30" +requires_python = ">=3.6" +summary = "Python package for providing Mozilla's CA Bundle." +groups = ["docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "certifi-2024.8.30-py3-none-any.whl", hash = "sha256:922820b53db7a7257ffbda3f597266d435245903d80737e34f8a45ff3e3230d8"}, + {file = "certifi-2024.8.30.tar.gz", hash = "sha256:bec941d2aa8195e248a60b31ff9f0558284cf01a52591ceda73ea9afffd69fd9"}, +] + +[[package]] +name = "cffi" +version = "1.17.1" +requires_python = ">=3.8" +summary = "Foreign Function Interface for Python calling C code." +groups = ["docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "pycparser", +] +files = [ + {file = "cffi-1.17.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2bb1a08b8008b281856e5971307cc386a8e9c5b625ac297e853d36da6efe9c17"}, + {file = "cffi-1.17.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:610faea79c43e44c71e1ec53a554553fa22321b65fae24889706c0a84d4ad86d"}, + {file = "cffi-1.17.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b62ce867176a75d03a665bad002af8e6d54644fad99a3c70905c543130e39d93"}, + {file = "cffi-1.17.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cdf5ce3acdfd1661132f2a9c19cac174758dc2352bfe37d98aa7512c6b7178b3"}, + {file = "cffi-1.17.1.tar.gz", hash = "sha256:1c39c6016c32bc48dd54561950ebd6836e1670f2ae46128f67cf49e789c52824"}, +] + +[[package]] +name = "cfgv" +version = "3.4.0" +requires_python = ">=3.8" +summary = "Validate configuration and produce human readable error messages." +groups = ["qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "cfgv-3.4.0-py2.py3-none-any.whl", hash = "sha256:b7265b1f29fd3316bfcd2b330d63d024f2bfd8bcb8b0272f8e19a504856c48f9"}, + {file = "cfgv-3.4.0.tar.gz", hash = "sha256:e52591d4c5f5dead8e0f673fb16db7949d2cfb3f7da4582893288f0ded8fe560"}, +] + +[[package]] +name = "chardet" +version = "5.2.0" +requires_python = ">=3.7" +summary = "Universal encoding detector for Python 3" +groups = ["qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "chardet-5.2.0-py3-none-any.whl", hash = "sha256:e1cf59446890a00105fe7b7912492ea04b6e6f06d4b742b2c788469e34c82970"}, + {file = "chardet-5.2.0.tar.gz", hash = "sha256:1b3b6ff479a8c414bc3fa2c0852995695c4a026dcd6d0633b2dd092ca39c1cf7"}, +] + +[[package]] +name = "charset-normalizer" +version = "3.3.2" +requires_python = ">=3.7.0" +summary = "The Real First Universal Charset Detector. Open, modern and actively maintained alternative to Chardet." +groups = ["docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "charset-normalizer-3.3.2.tar.gz", hash = "sha256:f30c3cb33b24454a82faecaf01b19c18562b1e89558fb6c56de4d9118a032fd5"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8465322196c8b4d7ab6d1e049e4c5cb460d0394da4a27d23cc242fbf0034b6b5"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:753f10e867343b4511128c6ed8c82f7bec3bd026875576dfd88483c5c73b2fd8"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:90d558489962fd4918143277a773316e56c72da56ec7aa3dc3dbbe20fdfed15b"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b261ccdec7821281dade748d088bb6e9b69e6d15b30652b74cbbac25e280b796"}, + {file = "charset_normalizer-3.3.2-py3-none-any.whl", hash = "sha256:3e4d1f6587322d2788836a99c69062fbb091331ec940e02d12d179c1d53e25fc"}, +] + +[[package]] +name = "cmocean" +version = "4.0.3" +requires_python = ">=3.8" +summary = "Colormaps for Oceanography" +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "matplotlib", + "numpy", + "packaging", +] +files = [ + {file = "cmocean-4.0.3-py3-none-any.whl", hash = "sha256:f2fc1d5e349db122ee0c9eac80bba969aa92dd2806548fce58dc8bef962f309e"}, + {file = "cmocean-4.0.3.tar.gz", hash = "sha256:37868399fb5f41b4eac596e69803f9bfaea49946514dfb2e7f48886854250d7c"}, +] + +[[package]] +name = "colorama" +version = "0.4.6" +requires_python = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,!=3.6.*,>=2.7" +summary = "Cross-platform colored terminal text." +groups = ["qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6"}, + {file = "colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44"}, +] + +[[package]] +name = "colorcet" +version = "3.1.0" +requires_python = ">=3.7" +summary = "Collection of perceptually uniform colormaps" +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "colorcet-3.1.0-py3-none-any.whl", hash = "sha256:2a7d59cc8d0f7938eeedd08aad3152b5319b4ba3bcb7a612398cc17a384cb296"}, + {file = "colorcet-3.1.0.tar.gz", hash = "sha256:2921b3cd81a2288aaf2d63dbc0ce3c26dcd882e8c389cc505d6886bf7aa9a4eb"}, +] + +[[package]] +name = "comm" +version = "0.2.2" +requires_python = ">=3.8" +summary = "Jupyter Python Comm implementation, for usage in ipykernel, xeus-python etc." +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "traitlets>=4", +] +files = [ + {file = "comm-0.2.2-py3-none-any.whl", hash = "sha256:e6fb86cb70ff661ee8c9c14e7d36d6de3b4066f1441be4063df9c5009f0a64d3"}, + {file = "comm-0.2.2.tar.gz", hash = "sha256:3fd7a84065306e07bea1773df6eb8282de51ba82f77c72f9c85716ab11fe980e"}, +] + +[[package]] +name = "contourpy" +version = "1.3.0" +requires_python = ">=3.9" +summary = "Python library for calculating contours of 2D quadrilateral grids" +groups = ["default", "pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "numpy>=1.23", +] +files = [ + {file = "contourpy-1.3.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:69375194457ad0fad3a839b9e29aa0b0ed53bb54db1bfb6c3ae43d111c31ce41"}, + {file = "contourpy-1.3.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:637f674226be46f6ba372fd29d9523dd977a291f66ab2a74fbeb5530bb3f445d"}, + {file = "contourpy-1.3.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3634b5385c6716c258d0419c46d05c8aa7dc8cb70326c9a4fb66b69ad2b52e09"}, + {file = "contourpy-1.3.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:68a32389b06b82c2fdd68276148d7b9275b5f5cf13e5417e4252f6d1a34f72a2"}, + {file = "contourpy-1.3.0-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:eca7e17a65f72a5133bdbec9ecf22401c62bcf4821361ef7811faee695799779"}, + {file = "contourpy-1.3.0-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8ca947601224119117f7c19c9cdf6b3ab54c5726ef1d906aa4a69dfb6dd58102"}, + {file = "contourpy-1.3.0.tar.gz", hash = "sha256:7ffa0db17717a8ffb127efd0c95a4362d996b892c2904db72428d5b52e1938a4"}, +] + +[[package]] +name = "coverage" +version = "7.6.1" +requires_python = ">=3.8" +summary = "Code coverage measurement for Python" +groups = ["qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "coverage-7.6.1-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8f59d57baca39b32db42b83b2a7ba6f47ad9c394ec2076b084c3f029b7afca23"}, + {file = "coverage-7.6.1-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0c0420b573964c760df9e9e86d1a9a622d0d27f417e1a949a8a66dd7bcee7bc6"}, + {file = "coverage-7.6.1-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c44fee9975f04b33331cb8eb272827111efc8930cfd582e0320613263ca849ca"}, + {file = "coverage-7.6.1-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:609b06f178fe8e9f89ef676532760ec0b4deea15e9969bf754b37f7c40326dbc"}, + {file = "coverage-7.6.1-pp38.pp39.pp310-none-any.whl", hash = "sha256:e9a6e0eb86070e8ccaedfbd9d38fec54864f3125ab95419970575b42af7541df"}, + {file = "coverage-7.6.1.tar.gz", hash = "sha256:953510dfb7b12ab69d20135a0662397f077c59b1e6379a768e97c59d852ee51d"}, +] + +[[package]] +name = "coverage" +version = "7.6.1" +extras = ["toml"] +requires_python = ">=3.8" +summary = "Code coverage measurement for Python" +groups = ["qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "coverage==7.6.1", + "tomli; python_full_version <= \"3.11.0a6\"", +] +files = [ + {file = "coverage-7.6.1-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8f59d57baca39b32db42b83b2a7ba6f47ad9c394ec2076b084c3f029b7afca23"}, + {file = "coverage-7.6.1-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0c0420b573964c760df9e9e86d1a9a622d0d27f417e1a949a8a66dd7bcee7bc6"}, + {file = "coverage-7.6.1-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c44fee9975f04b33331cb8eb272827111efc8930cfd582e0320613263ca849ca"}, + {file = "coverage-7.6.1-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:609b06f178fe8e9f89ef676532760ec0b4deea15e9969bf754b37f7c40326dbc"}, + {file = "coverage-7.6.1-pp38.pp39.pp310-none-any.whl", hash = "sha256:e9a6e0eb86070e8ccaedfbd9d38fec54864f3125ab95419970575b42af7541df"}, + {file = "coverage-7.6.1.tar.gz", hash = "sha256:953510dfb7b12ab69d20135a0662397f077c59b1e6379a768e97c59d852ee51d"}, +] + +[[package]] +name = "cycler" +version = "0.12.1" +requires_python = ">=3.8" +summary = "Composable style cycles" +groups = ["default", "pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "cycler-0.12.1-py3-none-any.whl", hash = "sha256:85cef7cff222d8644161529808465972e51340599459b8ac3ccbac5a854e0d30"}, + {file = "cycler-0.12.1.tar.gz", hash = "sha256:88bb128f02ba341da8ef447245a9e138fae777f6a23943da4540077d3601eb1c"}, +] + +[[package]] +name = "debugpy" +version = "1.8.5" +requires_python = ">=3.8" +summary = "An implementation of the Debug Adapter Protocol for Python" +groups = ["qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "debugpy-1.8.5-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4413b7a3ede757dc33a273a17d685ea2b0c09dbd312cc03f5534a0fd4d40750a"}, + {file = "debugpy-1.8.5-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:db9fb642938a7a609a6c865c32ecd0d795d56c1aaa7a7a5722d77855d5e77f2b"}, + {file = "debugpy-1.8.5-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c0a65b00b7cdd2ee0c2cf4c7335fef31e15f1b7056c7fdbce9e90193e1a8c8cb"}, + {file = "debugpy-1.8.5-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e84c276489e141ed0b93b0af648eef891546143d6a48f610945416453a8ad406"}, + {file = "debugpy-1.8.5-py2.py3-none-any.whl", hash = "sha256:55919dce65b471eff25901acf82d328bbd5b833526b6c1364bd5133754777a44"}, + {file = "debugpy-1.8.5.zip", hash = "sha256:b2112cfeb34b4507399d298fe7023a16656fc553ed5246536060ca7bd0e668d0"}, +] + +[[package]] +name = "decorator" +version = "5.1.1" +requires_python = ">=3.5" +summary = "Decorators for Humans" +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "decorator-5.1.1-py3-none-any.whl", hash = "sha256:b8c3f85900b9dc423225913c5aace94729fe1fa9763b38939a95226f02d37186"}, + {file = "decorator-5.1.1.tar.gz", hash = "sha256:637996211036b6385ef91435e4fae22989472f9d571faba8927ba8253acbc330"}, +] + +[[package]] +name = "defusedxml" +version = "0.7.1" +requires_python = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*" +summary = "XML bomb protection for Python stdlib modules" +groups = ["docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "defusedxml-0.7.1-py2.py3-none-any.whl", hash = "sha256:a352e7e428770286cc899e2542b6cdaedb2b4953ff269a210103ec58f6198a61"}, + {file = "defusedxml-0.7.1.tar.gz", hash = "sha256:1bb3032db185915b62d7c6209c5a8792be6a32ab2fedacc84e01b52c51aa3e69"}, +] + +[[package]] +name = "distlib" +version = "0.3.8" +summary = "Distribution utilities" +groups = ["qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "distlib-0.3.8-py2.py3-none-any.whl", hash = "sha256:034db59a0b96f8ca18035f36290806a9a6e6bd9d1ff91e45a7f172eb17e51784"}, + {file = "distlib-0.3.8.tar.gz", hash = "sha256:1530ea13e350031b6312d8580ddb6b27a104275a31106523b8f123787f494f64"}, +] + +[[package]] +name = "docutils" +version = "0.20.1" +requires_python = ">=3.7" +summary = "Docutils -- Python Documentation Utilities" +groups = ["docs"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "docutils-0.20.1-py3-none-any.whl", hash = "sha256:96f387a2c5562db4476f09f13bbab2192e764cac08ebbf3a34a95d9b1e4a59d6"}, + {file = "docutils-0.20.1.tar.gz", hash = "sha256:f08a4e276c3a1583a86dce3e34aba3fe04d02bba2dd51ed16106244e8a923e3b"}, +] + +[[package]] +name = "et-xmlfile" +version = "1.1.0" +requires_python = ">=3.6" +summary = "An implementation of lxml.xmlfile for the standard library" +groups = ["openpyxl"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "et_xmlfile-1.1.0-py3-none-any.whl", hash = "sha256:a2ba85d1d6a74ef63837eed693bcb89c3f752169b0e3e7ae5b16ca5e1b3deada"}, + {file = "et_xmlfile-1.1.0.tar.gz", hash = "sha256:8eb9e2bc2f8c97e37a2dc85a09ecdcdec9d8a396530a6d5a33b30b9a92da0c5c"}, +] + +[[package]] +name = "exceptiongroup" +version = "1.2.2" +requires_python = ">=3.7" +summary = "Backport of PEP 654 (exception groups)" +groups = ["pyvista", "qa"] +marker = "python_version < \"3.11\" and python_version >= \"3.9\"" +files = [ + {file = "exceptiongroup-1.2.2-py3-none-any.whl", hash = "sha256:3111b9d131c238bec2f8f516e123e14ba243563fb135d3fe885990585aa7795b"}, + {file = "exceptiongroup-1.2.2.tar.gz", hash = "sha256:47c2edf7c6738fafb49fd34290706d1a1a2f4d1c6df275526b62cbb4aa5393cc"}, +] + +[[package]] +name = "executing" +version = "2.1.0" +requires_python = ">=3.8" +summary = "Get the currently executing AST node of a frame, and other information" +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "executing-2.1.0-py2.py3-none-any.whl", hash = "sha256:8d63781349375b5ebccc3142f4b30350c0cd9c79f921cde38be2be4637e98eaf"}, + {file = "executing-2.1.0.tar.gz", hash = "sha256:8ea27ddd260da8150fa5a708269c4a10e76161e2496ec3e587da9e3c0fe4b9ab"}, +] + +[[package]] +name = "fastjsonschema" +version = "2.20.0" +summary = "Fastest Python implementation of JSON schema" +groups = ["docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "fastjsonschema-2.20.0-py3-none-any.whl", hash = "sha256:5875f0b0fa7a0043a91e93a9b8f793bcbbba9691e7fd83dca95c28ba26d21f0a"}, + {file = "fastjsonschema-2.20.0.tar.gz", hash = "sha256:3d48fc5300ee96f5d116f10fe6f28d938e6008f59a6a025c2649475b87f76a23"}, +] + +[[package]] +name = "filelock" +version = "3.17.0" +requires_python = ">=3.9" +summary = "A platform independent file lock." +groups = ["qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "filelock-3.17.0-py3-none-any.whl", hash = "sha256:533dc2f7ba78dc2f0f531fc6c4940addf7b70a481e269a5a3b93be94ffbe8338"}, + {file = "filelock-3.17.0.tar.gz", hash = "sha256:ee4e77401ef576ebb38cd7f13b9b28893194acc20a8e68e18730ba9c0e54660e"}, +] + +[[package]] +name = "fonttools" +version = "4.53.1" +requires_python = ">=3.8" +summary = "Tools to manipulate font files" +groups = ["default", "pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "fonttools-4.53.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a1c7c5aa18dd3b17995898b4a9b5929d69ef6ae2af5b96d585ff4005033d82f0"}, + {file = "fonttools-4.53.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bee32ea8765e859670c4447b0817514ca79054463b6b79784b08a8df3a4d78e3"}, + {file = "fonttools-4.53.1-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:10f5e6c3510b79ea27bb1ebfcc67048cde9ec67afa87c7dd7efa5c700491ac7f"}, + {file = "fonttools-4.53.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:84ec3fb43befb54be490147b4a922b5314e16372a643004f182babee9f9c3407"}, + {file = "fonttools-4.53.1-py3-none-any.whl", hash = "sha256:f1f8758a2ad110bd6432203a344269f445a2907dc24ef6bccfd0ac4e14e0d71d"}, + {file = "fonttools-4.53.1.tar.gz", hash = "sha256:e128778a8e9bc11159ce5447f76766cefbd876f44bd79aff030287254e4752c4"}, +] + +[[package]] +name = "fqdn" +version = "1.5.1" +requires_python = ">=2.7, !=3.0, !=3.1, !=3.2, !=3.3, !=3.4, <4" +summary = "Validates fully-qualified domain names against RFC 1123, so that they are acceptable to modern bowsers" +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "cached-property>=1.3.0; python_version < \"3.8\"", +] +files = [ + {file = "fqdn-1.5.1-py3-none-any.whl", hash = "sha256:3a179af3761e4df6eb2e026ff9e1a3033d3587bf980a0b1b2e1e5d08d7358014"}, + {file = "fqdn-1.5.1.tar.gz", hash = "sha256:105ed3677e767fb5ca086a0c1f4bb66ebc3c100be518f0e0d755d9eae164d89f"}, +] + +[[package]] +name = "frozenlist" +version = "1.4.1" +requires_python = ">=3.8" +summary = "A list-like structure which implements collections.abc.MutableSequence" +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "frozenlist-1.4.1-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a9b2de4cf0cdd5bd2dee4c4f63a653c61d2408055ab77b151c1957f221cabf2a"}, + {file = "frozenlist-1.4.1-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4f9c515e7914626b2a2e1e311794b4c35720a0be87af52b79ff8e1429fc25f19"}, + {file = "frozenlist-1.4.1-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9acbb16f06fe7f52f441bb6f413ebae6c37baa6ef9edd49cdd567216da8600cd"}, + {file = "frozenlist-1.4.1-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:89aa2c2eeb20957be2d950b85974b30a01a762f3308cd02bb15e1ad632e22dc7"}, + {file = "frozenlist-1.4.1-py3-none-any.whl", hash = "sha256:04ced3e6a46b4cfffe20f9ae482818e34eba9b5fb0ce4056e4cc9b6e212d09b7"}, + {file = "frozenlist-1.4.1.tar.gz", hash = "sha256:c037a86e8513059a2613aaba4d817bb90b9d9b6b69aace3ce9c877e8c8ed402b"}, +] + +[[package]] +name = "ghp-import" +version = "2.1.0" +summary = "Copy your docs directly to the gh-pages branch." +groups = ["docs"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "python-dateutil>=2.8.1", +] +files = [ + {file = "ghp-import-2.1.0.tar.gz", hash = "sha256:9c535c4c61193c2df8871222567d7fd7e5014d835f97dc7b7439069e2413d343"}, + {file = "ghp_import-2.1.0-py3-none-any.whl", hash = "sha256:8337dd7b50877f163d4c0289bc1f1c7f127550241988d568c1db512c4324a619"}, +] + +[[package]] +name = "h11" +version = "0.14.0" +requires_python = ">=3.7" +summary = "A pure-Python, bring-your-own-I/O implementation of HTTP/1.1" +groups = ["qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "typing-extensions; python_version < \"3.8\"", +] +files = [ + {file = "h11-0.14.0-py3-none-any.whl", hash = "sha256:e3fe4ac4b851c468cc8363d500db52c2ead036020723024a109d37346efaa761"}, + {file = "h11-0.14.0.tar.gz", hash = "sha256:8f19fbbe99e72420ff35c00b27a34cb9937e902a8b810e2c88300c6f0a3b699d"}, +] + +[[package]] +name = "httpcore" +version = "1.0.5" +requires_python = ">=3.8" +summary = "A minimal low-level HTTP client." +groups = ["qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "certifi", + "h11<0.15,>=0.13", +] +files = [ + {file = "httpcore-1.0.5-py3-none-any.whl", hash = "sha256:421f18bac248b25d310f3cacd198d55b8e6125c107797b609ff9b7a6ba7991b5"}, + {file = "httpcore-1.0.5.tar.gz", hash = "sha256:34a38e2f9291467ee3b44e89dd52615370e152954ba21721378a87b2960f7a61"}, +] + +[[package]] +name = "httpx" +version = "0.27.2" +requires_python = ">=3.8" +summary = "The next generation HTTP client." +groups = ["qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "anyio", + "certifi", + "httpcore==1.*", + "idna", + "sniffio", +] +files = [ + {file = "httpx-0.27.2-py3-none-any.whl", hash = "sha256:7bb2708e112d8fdd7829cd4243970f0c223274051cb35ee80c03301ee29a3df0"}, + {file = "httpx-0.27.2.tar.gz", hash = "sha256:f7c2be1d2f3c3c3160d441802406b206c2b76f5947b11115e6df10c6c65e66c2"}, +] + +[[package]] +name = "identify" +version = "2.6.0" +requires_python = ">=3.8" +summary = "File identification library for Python" +groups = ["qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "identify-2.6.0-py2.py3-none-any.whl", hash = "sha256:e79ae4406387a9d300332b5fd366d8994f1525e8414984e1a59e058b2eda2dd0"}, + {file = "identify-2.6.0.tar.gz", hash = "sha256:cb171c685bdc31bcc4c1734698736a7d5b6c8bf2e0c15117f4d469c8640ae5cf"}, +] + +[[package]] +name = "idna" +version = "3.8" +requires_python = ">=3.6" +summary = "Internationalized Domain Names in Applications (IDNA)" +groups = ["docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "idna-3.8-py3-none-any.whl", hash = "sha256:050b4e5baadcd44d760cedbd2b8e639f2ff89bbc7a5730fcc662954303377aac"}, + {file = "idna-3.8.tar.gz", hash = "sha256:d838c2c0ed6fced7693d5e8ab8e734d5f8fda53a039c0164afb0b82e771e3603"}, +] + +[[package]] +name = "imageio" +version = "2.35.1" +requires_python = ">=3.8" +summary = "Library for reading and writing a wide range of image, video, scientific, and volumetric data formats." +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "numpy", + "pillow>=8.3.2", +] +files = [ + {file = "imageio-2.35.1-py3-none-any.whl", hash = "sha256:6eb2e5244e7a16b85c10b5c2fe0f7bf961b40fcb9f1a9fd1bd1d2c2f8fb3cd65"}, + {file = "imageio-2.35.1.tar.gz", hash = "sha256:4952dfeef3c3947957f6d5dedb1f4ca31c6e509a476891062396834048aeed2a"}, +] + +[[package]] +name = "imagesize" +version = "1.4.1" +requires_python = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*" +summary = "Getting image size from png/jpeg/jpeg2000/gif file" +groups = ["docs"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "imagesize-1.4.1-py2.py3-none-any.whl", hash = "sha256:0d8d18d08f840c19d0ee7ca1fd82490fdc3729b7ac93f49870406ddde8ef8d8b"}, + {file = "imagesize-1.4.1.tar.gz", hash = "sha256:69150444affb9cb0d5cc5a92b3676f0b2fb7cd9ae39e947a5e11a36b4497cd4a"}, +] + +[[package]] +name = "importlib-metadata" +version = "8.5.0" +requires_python = ">=3.8" +summary = "Read metadata from Python packages" +groups = ["docs", "pyvista", "qa"] +marker = "python_version < \"3.10\" and python_version >= \"3.9\"" +dependencies = [ + "typing-extensions>=3.6.4; python_version < \"3.8\"", + "zipp>=3.20", +] +files = [ + {file = "importlib_metadata-8.5.0-py3-none-any.whl", hash = "sha256:45e54197d28b7a7f1559e60b95e7c567032b602131fbd588f1497f47880aa68b"}, + {file = "importlib_metadata-8.5.0.tar.gz", hash = "sha256:71522656f0abace1d072b9e5481a48f07c138e00f079c38c8f883823f9c26bd7"}, +] + +[[package]] +name = "importlib-resources" +version = "6.4.5" +requires_python = ">=3.8" +summary = "Read resources from Python packages" +groups = ["default", "pyvista"] +marker = "python_version < \"3.10\" and python_version >= \"3.9\"" +dependencies = [ + "zipp>=3.1.0; python_version < \"3.10\"", +] +files = [ + {file = "importlib_resources-6.4.5-py3-none-any.whl", hash = "sha256:ac29d5f956f01d5e4bb63102a5a19957f1b9175e45649977264a1416783bb717"}, + {file = "importlib_resources-6.4.5.tar.gz", hash = "sha256:980862a1d16c9e147a59603677fa2aa5fd82b87f223b6cb870695bcfce830065"}, +] + +[[package]] +name = "iniconfig" +version = "2.0.0" +requires_python = ">=3.7" +summary = "brain-dead simple config-ini parsing" +groups = ["qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "iniconfig-2.0.0-py3-none-any.whl", hash = "sha256:b6a85871a79d2e3b22d2d1b94ac2824226a63c6b741c88f7ae975f18b6778374"}, + {file = "iniconfig-2.0.0.tar.gz", hash = "sha256:2d91e135bf72d31a410b17c16da610a82cb55f6b0477d1a902134b24a455b8b3"}, +] + +[[package]] +name = "ipdb" +version = "0.13.13" +requires_python = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*" +summary = "IPython-enabled pdb" +groups = ["qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "decorator; python_version == \"3.5\"", + "decorator; python_version == \"3.6\"", + "decorator; python_version > \"3.6\" and python_version < \"3.11\"", + "decorator; python_version >= \"3.11\"", + "decorator<5.0.0; python_version == \"2.7\"", + "decorator<5.0.0; python_version == \"3.4\"", + "ipython<6.0.0,>=5.1.0; python_version == \"2.7\"", + "ipython<7.0.0,>=6.0.0; python_version == \"3.4\"", + "ipython<7.10.0,>=7.0.0; python_version == \"3.5\"", + "ipython<7.17.0,>=7.16.3; python_version == \"3.6\"", + "ipython>=7.31.1; python_version > \"3.6\" and python_version < \"3.11\"", + "ipython>=7.31.1; python_version >= \"3.11\"", + "pathlib; python_version == \"2.7\"", + "toml>=0.10.2; python_version == \"2.7\"", + "toml>=0.10.2; python_version == \"3.4\"", + "toml>=0.10.2; python_version == \"3.5\"", + "tomli; python_version == \"3.6\"", + "tomli; python_version > \"3.6\" and python_version < \"3.11\"", +] +files = [ + {file = "ipdb-0.13.13-py3-none-any.whl", hash = "sha256:45529994741c4ab6d2388bfa5d7b725c2cf7fe9deffabdb8a6113aa5ed449ed4"}, + {file = "ipdb-0.13.13.tar.gz", hash = "sha256:e3ac6018ef05126d442af680aad863006ec19d02290561ac88b8b1c0b0cfc726"}, +] + +[[package]] +name = "ipykernel" +version = "6.29.5" +requires_python = ">=3.8" +summary = "IPython Kernel for Jupyter" +groups = ["qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "appnope; platform_system == \"Darwin\"", + "comm>=0.1.1", + "debugpy>=1.6.5", + "ipython>=7.23.1", + "jupyter-client>=6.1.12", + "jupyter-core!=5.0.*,>=4.12", + "matplotlib-inline>=0.1", + "nest-asyncio", + "packaging", + "psutil", + "pyzmq>=24", + "tornado>=6.1", + "traitlets>=5.4.0", +] +files = [ + {file = "ipykernel-6.29.5-py3-none-any.whl", hash = "sha256:afdb66ba5aa354b09b91379bac28ae4afebbb30e8b39510c9690afb7a10421b5"}, + {file = "ipykernel-6.29.5.tar.gz", hash = "sha256:f093a22c4a40f8828f8e330a9c297cb93dcab13bd9678ded6de8e5cf81c56215"}, +] + +[[package]] +name = "ipython" +version = "8.18.1" +requires_python = ">=3.9" +summary = "IPython: Productive Interactive Computing" +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "colorama; sys_platform == \"win32\"", + "decorator", + "exceptiongroup; python_version < \"3.11\"", + "jedi>=0.16", + "matplotlib-inline", + "pexpect>4.3; sys_platform != \"win32\"", + "prompt-toolkit<3.1.0,>=3.0.41", + "pygments>=2.4.0", + "stack-data", + "traitlets>=5", + "typing-extensions; python_version < \"3.10\"", +] +files = [ + {file = "ipython-8.18.1-py3-none-any.whl", hash = "sha256:e8267419d72d81955ec1177f8a29aaa90ac80ad647499201119e2f05e99aa397"}, + {file = "ipython-8.18.1.tar.gz", hash = "sha256:ca6f079bb33457c66e233e4580ebfc4128855b4cf6370dddd73842a9563e8a27"}, +] + +[[package]] +name = "ipywidgets" +version = "8.1.5" +requires_python = ">=3.7" +summary = "Jupyter interactive widgets" +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "comm>=0.1.3", + "ipython>=6.1.0", + "jupyterlab-widgets~=3.0.12", + "traitlets>=4.3.1", + "widgetsnbextension~=4.0.12", +] +files = [ + {file = "ipywidgets-8.1.5-py3-none-any.whl", hash = "sha256:3290f526f87ae6e77655555baba4f36681c555b8bdbbff430b70e52c34c86245"}, + {file = "ipywidgets-8.1.5.tar.gz", hash = "sha256:870e43b1a35656a80c18c9503bbf2d16802db1cb487eec6fab27d683381dde17"}, +] + +[[package]] +name = "isoduration" +version = "20.11.0" +requires_python = ">=3.7" +summary = "Operations with ISO 8601 durations" +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "arrow>=0.15.0", +] +files = [ + {file = "isoduration-20.11.0-py3-none-any.whl", hash = "sha256:b2904c2a4228c3d44f409c8ae8e2370eb21a26f7ac2ec5446df141dde3452042"}, + {file = "isoduration-20.11.0.tar.gz", hash = "sha256:ac2f9015137935279eac671f94f89eb00584f940f5dc49462a0c4ee692ba1bd9"}, +] + +[[package]] +name = "jedi" +version = "0.19.1" +requires_python = ">=3.6" +summary = "An autocompletion tool for Python that can be used for text editors." +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "parso<0.9.0,>=0.8.3", +] +files = [ + {file = "jedi-0.19.1-py2.py3-none-any.whl", hash = "sha256:e983c654fe5c02867aef4cdfce5a2fbb4a50adc0af145f70504238f18ef5e7e0"}, + {file = "jedi-0.19.1.tar.gz", hash = "sha256:cf0496f3651bc65d7174ac1b7d043eff454892c708a87d1b683e57b569927ffd"}, +] + +[[package]] +name = "jinja2" +version = "3.1.5" +requires_python = ">=3.7" +summary = "A very fast and expressive template engine." +groups = ["docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "MarkupSafe>=2.0", +] +files = [ + {file = "jinja2-3.1.5-py3-none-any.whl", hash = "sha256:aba0f4dc9ed8013c424088f68a5c226f7d6097ed89b246d7749c2ec4175c6adb"}, + {file = "jinja2-3.1.5.tar.gz", hash = "sha256:8fefff8dc3034e27bb80d67c671eb8a9bc424c0ef4c0826edbff304cceff43bb"}, +] + +[[package]] +name = "json5" +version = "0.9.25" +requires_python = ">=3.8" +summary = "A Python implementation of the JSON5 data format." +groups = ["qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "json5-0.9.25-py3-none-any.whl", hash = "sha256:34ed7d834b1341a86987ed52f3f76cd8ee184394906b6e22a1e0deb9ab294e8f"}, + {file = "json5-0.9.25.tar.gz", hash = "sha256:548e41b9be043f9426776f05df8635a00fe06104ea51ed24b67f908856e151ae"}, +] + +[[package]] +name = "jsonpointer" +version = "3.0.0" +requires_python = ">=3.7" +summary = "Identify specific nodes in a JSON document (RFC 6901) " +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "jsonpointer-3.0.0-py2.py3-none-any.whl", hash = "sha256:13e088adc14fca8b6aa8177c044e12701e6ad4b28ff10e65f2267a90109c9942"}, + {file = "jsonpointer-3.0.0.tar.gz", hash = "sha256:2b2d729f2091522d61c3b31f82e11870f60b68f43fbc705cb76bf4b832af59ef"}, +] + +[[package]] +name = "jsonschema" +version = "4.23.0" +requires_python = ">=3.8" +summary = "An implementation of JSON Schema validation for Python" +groups = ["docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "attrs>=22.2.0", + "importlib-resources>=1.4.0; python_version < \"3.9\"", + "jsonschema-specifications>=2023.03.6", + "pkgutil-resolve-name>=1.3.10; python_version < \"3.9\"", + "referencing>=0.28.4", + "rpds-py>=0.7.1", +] +files = [ + {file = "jsonschema-4.23.0-py3-none-any.whl", hash = "sha256:fbadb6f8b144a8f8cf9f0b89ba94501d143e50411a1278633f56a7acf7fd5566"}, + {file = "jsonschema-4.23.0.tar.gz", hash = "sha256:d71497fef26351a33265337fa77ffeb82423f3ea21283cd9467bb03999266bc4"}, +] + +[[package]] +name = "jsonschema-specifications" +version = "2023.12.1" +requires_python = ">=3.8" +summary = "The JSON Schema meta-schemas and vocabularies, exposed as a Registry" +groups = ["docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "importlib-resources>=1.4.0; python_version < \"3.9\"", + "referencing>=0.31.0", +] +files = [ + {file = "jsonschema_specifications-2023.12.1-py3-none-any.whl", hash = "sha256:87e4fdf3a94858b8a2ba2778d9ba57d8a9cafca7c7489c46ba0d30a8bc6a9c3c"}, + {file = "jsonschema_specifications-2023.12.1.tar.gz", hash = "sha256:48a76787b3e70f5ed53f1160d2b81f586e4ca6d1548c5de7085d1682674764cc"}, +] + +[[package]] +name = "jsonschema" +version = "4.23.0" +extras = ["format-nongpl"] +requires_python = ">=3.8" +summary = "An implementation of JSON Schema validation for Python" +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "fqdn", + "idna", + "isoduration", + "jsonpointer>1.13", + "jsonschema==4.23.0", + "rfc3339-validator", + "rfc3986-validator>0.1.0", + "uri-template", + "webcolors>=24.6.0", +] +files = [ + {file = "jsonschema-4.23.0-py3-none-any.whl", hash = "sha256:fbadb6f8b144a8f8cf9f0b89ba94501d143e50411a1278633f56a7acf7fd5566"}, + {file = "jsonschema-4.23.0.tar.gz", hash = "sha256:d71497fef26351a33265337fa77ffeb82423f3ea21283cd9467bb03999266bc4"}, +] + +[[package]] +name = "jupyter-client" +version = "8.6.3" +requires_python = ">=3.8" +summary = "Jupyter protocol implementation and client libraries" +groups = ["docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "importlib-metadata>=4.8.3; python_version < \"3.10\"", + "jupyter-core!=5.0.*,>=4.12", + "python-dateutil>=2.8.2", + "pyzmq>=23.0", + "tornado>=6.2", + "traitlets>=5.3", +] +files = [ + {file = "jupyter_client-8.6.3-py3-none-any.whl", hash = "sha256:e8a19cc986cc45905ac3362915f410f3af85424b4c0905e94fa5f2cb08e8f23f"}, + {file = "jupyter_client-8.6.3.tar.gz", hash = "sha256:35b3a0947c4a6e9d589eb97d7d4cd5e90f910ee73101611f01283732bd6d9419"}, +] + +[[package]] +name = "jupyter-core" +version = "5.7.2" +requires_python = ">=3.8" +summary = "Jupyter core package. A base package on which Jupyter projects rely." +groups = ["docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "platformdirs>=2.5", + "pywin32>=300; sys_platform == \"win32\" and platform_python_implementation != \"PyPy\"", + "traitlets>=5.3", +] +files = [ + {file = "jupyter_core-5.7.2-py3-none-any.whl", hash = "sha256:4f7315d2f6b4bcf2e3e7cb6e46772eba760ae459cd1f59d29eb57b0a01bd7409"}, + {file = "jupyter_core-5.7.2.tar.gz", hash = "sha256:aa5f8d32bbf6b431ac830496da7392035d6f61b4f54872f15c4bd2a9c3f536d9"}, +] + +[[package]] +name = "jupyter-events" +version = "0.12.0" +requires_python = ">=3.9" +summary = "Jupyter Event System library" +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "jsonschema[format-nongpl]>=4.18.0", + "packaging", + "python-json-logger>=2.0.4", + "pyyaml>=5.3", + "referencing", + "rfc3339-validator", + "rfc3986-validator>=0.1.1", + "traitlets>=5.3", +] +files = [ + {file = "jupyter_events-0.12.0-py3-none-any.whl", hash = "sha256:6464b2fa5ad10451c3d35fabc75eab39556ae1e2853ad0c0cc31b656731a97fb"}, + {file = "jupyter_events-0.12.0.tar.gz", hash = "sha256:fc3fce98865f6784c9cd0a56a20644fc6098f21c8c33834a8d9fe383c17e554b"}, +] + +[[package]] +name = "jupyter-lsp" +version = "2.2.5" +requires_python = ">=3.8" +summary = "Multi-Language Server WebSocket proxy for Jupyter Notebook/Lab server" +groups = ["qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "importlib-metadata>=4.8.3; python_version < \"3.10\"", + "jupyter-server>=1.1.2", +] +files = [ + {file = "jupyter-lsp-2.2.5.tar.gz", hash = "sha256:793147a05ad446f809fd53ef1cd19a9f5256fd0a2d6b7ce943a982cb4f545001"}, + {file = "jupyter_lsp-2.2.5-py3-none-any.whl", hash = "sha256:45fbddbd505f3fbfb0b6cb2f1bc5e15e83ab7c79cd6e89416b248cb3c00c11da"}, +] + +[[package]] +name = "jupyter-server" +version = "2.15.0" +requires_python = ">=3.9" +summary = "The backend—i.e. core services, APIs, and REST endpoints—to Jupyter web applications." +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "anyio>=3.1.0", + "argon2-cffi>=21.1", + "jinja2>=3.0.3", + "jupyter-client>=7.4.4", + "jupyter-core!=5.0.*,>=4.12", + "jupyter-events>=0.11.0", + "jupyter-server-terminals>=0.4.4", + "nbconvert>=6.4.4", + "nbformat>=5.3.0", + "overrides>=5.0", + "packaging>=22.0", + "prometheus-client>=0.9", + "pywinpty>=2.0.1; os_name == \"nt\"", + "pyzmq>=24", + "send2trash>=1.8.2", + "terminado>=0.8.3", + "tornado>=6.2.0", + "traitlets>=5.6.0", + "websocket-client>=1.7", +] +files = [ + {file = "jupyter_server-2.15.0-py3-none-any.whl", hash = "sha256:872d989becf83517012ee669f09604aa4a28097c0bd90b2f424310156c2cdae3"}, + {file = "jupyter_server-2.15.0.tar.gz", hash = "sha256:9d446b8697b4f7337a1b7cdcac40778babdd93ba614b6d68ab1c0c918f1c4084"}, +] + +[[package]] +name = "jupyter-server-proxy" +version = "4.4.0" +requires_python = ">=3.8" +summary = "A Jupyter server extension to run additional processes and proxy to them that comes bundled JupyterLab extension to launch pre-defined processes." +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "aiohttp", + "importlib-metadata>=4.8.3; python_version < \"3.10\"", + "jupyter-server>=1.24.0", + "simpervisor>=1.0.0", + "tornado>=6.1.0", + "traitlets>=5.1.0", +] +files = [ + {file = "jupyter_server_proxy-4.4.0-py3-none-any.whl", hash = "sha256:707b5c84810bb8863d50f6c6d50a386fec216149e11802b7d4c451b54a63a9a6"}, + {file = "jupyter_server_proxy-4.4.0.tar.gz", hash = "sha256:e5732eb9c810c0caa997f90a2f15f7d09af638e7eea9c67eb5c43e9c1f0e1157"}, +] + +[[package]] +name = "jupyter-server-terminals" +version = "0.5.3" +requires_python = ">=3.8" +summary = "A Jupyter Server Extension Providing Terminals." +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "pywinpty>=2.0.3; os_name == \"nt\"", + "terminado>=0.8.3", +] +files = [ + {file = "jupyter_server_terminals-0.5.3-py3-none-any.whl", hash = "sha256:41ee0d7dc0ebf2809c668e0fc726dfaf258fcd3e769568996ca731b6194ae9aa"}, + {file = "jupyter_server_terminals-0.5.3.tar.gz", hash = "sha256:5ae0295167220e9ace0edcfdb212afd2b01ee8d179fe6f23c899590e9b8a5269"}, +] + +[[package]] +name = "jupyterlab" +version = "4.3.5" +requires_python = ">=3.8" +summary = "JupyterLab computational environment" +groups = ["qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "async-lru>=1.0.0", + "httpx>=0.25.0", + "importlib-metadata>=4.8.3; python_version < \"3.10\"", + "importlib-resources>=1.4; python_version < \"3.9\"", + "ipykernel>=6.5.0", + "jinja2>=3.0.3", + "jupyter-core", + "jupyter-lsp>=2.0.0", + "jupyter-server<3,>=2.4.0", + "jupyterlab-server<3,>=2.27.1", + "notebook-shim>=0.2", + "packaging", + "setuptools>=40.8.0", + "tomli>=1.2.2; python_version < \"3.11\"", + "tornado>=6.2.0", + "traitlets", +] +files = [ + {file = "jupyterlab-4.3.5-py3-none-any.whl", hash = "sha256:571bbdee20e4c5321ab5195bc41cf92a75a5cff886be5e57ce78dfa37a5e9fdb"}, + {file = "jupyterlab-4.3.5.tar.gz", hash = "sha256:c779bf72ced007d7d29d5bcef128e7fdda96ea69299e19b04a43635a7d641f9d"}, +] + +[[package]] +name = "jupyterlab-pygments" +version = "0.3.0" +requires_python = ">=3.8" +summary = "Pygments theme using JupyterLab CSS variables" +groups = ["docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "jupyterlab_pygments-0.3.0-py3-none-any.whl", hash = "sha256:841a89020971da1d8693f1a99997aefc5dc424bb1b251fd6322462a1b8842780"}, + {file = "jupyterlab_pygments-0.3.0.tar.gz", hash = "sha256:721aca4d9029252b11cfa9d185e5b5af4d54772bb8072f9b7036f4170054d35d"}, +] + +[[package]] +name = "jupyterlab-server" +version = "2.27.3" +requires_python = ">=3.8" +summary = "A set of server components for JupyterLab and JupyterLab like applications." +groups = ["qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "babel>=2.10", + "importlib-metadata>=4.8.3; python_version < \"3.10\"", + "jinja2>=3.0.3", + "json5>=0.9.0", + "jsonschema>=4.18.0", + "jupyter-server<3,>=1.21", + "packaging>=21.3", + "requests>=2.31", +] +files = [ + {file = "jupyterlab_server-2.27.3-py3-none-any.whl", hash = "sha256:e697488f66c3db49df675158a77b3b017520d772c6e1548c7d9bcc5df7944ee4"}, + {file = "jupyterlab_server-2.27.3.tar.gz", hash = "sha256:eb36caca59e74471988f0ae25c77945610b887f777255aa21f8065def9e51ed4"}, +] + +[[package]] +name = "jupyterlab-widgets" +version = "3.0.13" +requires_python = ">=3.7" +summary = "Jupyter interactive widgets for JupyterLab" +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "jupyterlab_widgets-3.0.13-py3-none-any.whl", hash = "sha256:e3cda2c233ce144192f1e29914ad522b2f4c40e77214b0cc97377ca3d323db54"}, + {file = "jupyterlab_widgets-3.0.13.tar.gz", hash = "sha256:a2966d385328c1942b683a8cd96b89b8dd82c8b8f81dda902bb2bc06d46f5bed"}, +] + +[[package]] +name = "kiwisolver" +version = "1.4.7" +requires_python = ">=3.8" +summary = "A fast implementation of the Cassowary constraint solver" +groups = ["default", "pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "kiwisolver-1.4.7-cp310-cp310-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:88f17c5ffa8e9462fb79f62746428dd57b46eb931698e42e990ad63103f35e6c"}, + {file = "kiwisolver-1.4.7-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:18077b53dc3bb490e330669a99920c5e6a496889ae8c63b58fbc57c3d7f33a18"}, + {file = "kiwisolver-1.4.7-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:693902d433cf585133699972b6d7c42a8b9f8f826ebcaf0132ff55200afc599e"}, + {file = "kiwisolver-1.4.7-cp39-cp39-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:dda56c24d869b1193fcc763f1284b9126550eaf84b88bbc7256e15028f19188a"}, + {file = "kiwisolver-1.4.7-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:40fa14dbd66b8b8f470d5fc79c089a66185619d31645f9b0773b88b19f7223c4"}, + {file = "kiwisolver-1.4.7-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:801fa7802e5cfabe3ab0c81a34c323a319b097dfb5004be950482d882f3d7225"}, + {file = "kiwisolver-1.4.7.tar.gz", hash = "sha256:9893ff81bd7107f7b685d3017cc6583daadb4fc26e4a888350df530e41980a60"}, +] + +[[package]] +name = "markdown-it-py" +version = "3.0.0" +requires_python = ">=3.8" +summary = "Python port of markdown-it. Markdown parsing, done right!" +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "mdurl~=0.1", +] +files = [ + {file = "markdown-it-py-3.0.0.tar.gz", hash = "sha256:e3f60a94fa066dc52ec76661e37c851cb232d92f9886b15cb560aaada2df8feb"}, + {file = "markdown_it_py-3.0.0-py3-none-any.whl", hash = "sha256:355216845c60bd96232cd8d8c40e8f9765cc86f46880e43a8fd22dc1a1a8cab1"}, +] + +[[package]] +name = "markupsafe" +version = "2.1.5" +requires_python = ">=3.7" +summary = "Safely add untrusted strings to HTML/XML markup." +groups = ["docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "MarkupSafe-2.1.5-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2174c595a0d73a3080ca3257b40096db99799265e1c27cc5a610743acd86d62f"}, + {file = "MarkupSafe-2.1.5-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b91c037585eba9095565a3556f611e3cbfaa42ca1e865f7b8015fe5c7336d5a5"}, + {file = "MarkupSafe-2.1.5-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f5dfb42c4604dddc8e4305050aa6deb084540643ed5804d7455b5df8fe16f5e5"}, + {file = "MarkupSafe-2.1.5-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:17b950fccb810b3293638215058e432159d2b71005c74371d784862b7e4683f3"}, + {file = "MarkupSafe-2.1.5.tar.gz", hash = "sha256:d283d37a890ba4c1ae73ffadf8046435c76e7bc2247bbb63c00bd1a709c6544b"}, +] + +[[package]] +name = "matplotlib" +version = "3.9.4" +requires_python = ">=3.9" +summary = "Python plotting package" +groups = ["default", "pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "contourpy>=1.0.1", + "cycler>=0.10", + "fonttools>=4.22.0", + "importlib-resources>=3.2.0; python_version < \"3.10\"", + "kiwisolver>=1.3.1", + "numpy>=1.23", + "packaging>=20.0", + "pillow>=8", + "pyparsing>=2.3.1", + "python-dateutil>=2.7", +] +files = [ + {file = "matplotlib-3.9.4-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:18ebcf248030173b59a868fda1fe42397253f6698995b55e81e1f57431d85e50"}, + {file = "matplotlib-3.9.4-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:aca90ed222ac3565d2752b83dbb27627480d27662671e4d39da72e97f657a423"}, + {file = "matplotlib-3.9.4-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:173ac3748acaac21afcc3fa1633924609ba1b87749006bc25051c52c422a5d00"}, + {file = "matplotlib-3.9.4-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:57aa235109e9eed52e2c2949db17da185383fa71083c00c6c143a60e07e0888c"}, + {file = "matplotlib-3.9.4-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bcc53cf157a657bfd03afab14774d54ba73aa84d42cfe2480c91bd94873952db"}, + {file = "matplotlib-3.9.4.tar.gz", hash = "sha256:1e00e8be7393cbdc6fedfa8a6fba02cf3e83814b285db1c60b906a023ba41bc3"}, +] + +[[package]] +name = "matplotlib-inline" +version = "0.1.7" +requires_python = ">=3.8" +summary = "Inline Matplotlib backend for Jupyter" +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "traitlets", +] +files = [ + {file = "matplotlib_inline-0.1.7-py3-none-any.whl", hash = "sha256:df192d39a4ff8f21b1895d72e6a13f5fcc5099f00fa84384e0ea28c2cc0653ca"}, + {file = "matplotlib_inline-0.1.7.tar.gz", hash = "sha256:8423b23ec666be3d16e16b60bdd8ac4e86e840ebd1dd11a30b9f117f2fa0ab90"}, +] + +[[package]] +name = "mdurl" +version = "0.1.2" +requires_python = ">=3.7" +summary = "Markdown URL utilities" +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "mdurl-0.1.2-py3-none-any.whl", hash = "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8"}, + {file = "mdurl-0.1.2.tar.gz", hash = "sha256:bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba"}, +] + +[[package]] +name = "meshio" +version = "5.3.5" +requires_python = ">=3.8" +summary = "I/O for many mesh formats" +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "importlib-metadata; python_version < \"3.8\"", + "numpy>=1.20.0", + "rich", +] +files = [ + {file = "meshio-5.3.5-py3-none-any.whl", hash = "sha256:0736c6e34ecc768f62f2cde5d8233a3529512a9399b25c68ea2ca0d5900cdc10"}, + {file = "meshio-5.3.5.tar.gz", hash = "sha256:f21f01abd9f29ba06ea119304b3d39e610421cfe93b9dd23362834919f87586d"}, +] + +[[package]] +name = "mistune" +version = "3.0.2" +requires_python = ">=3.7" +summary = "A sane and fast Markdown parser with useful plugins and renderers" +groups = ["docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "mistune-3.0.2-py3-none-any.whl", hash = "sha256:71481854c30fdbc938963d3605b72501f5c10a9320ecd412c121c163a1c7d205"}, + {file = "mistune-3.0.2.tar.gz", hash = "sha256:fc7f93ded930c92394ef2cb6f04a8aabab4117a91449e72dcc8dfa646a508be8"}, +] + +[[package]] +name = "more-itertools" +version = "10.5.0" +requires_python = ">=3.8" +summary = "More routines for operating on iterables, beyond itertools" +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "more-itertools-10.5.0.tar.gz", hash = "sha256:5482bfef7849c25dc3c6dd53a6173ae4795da2a41a80faea6700d9f5846c5da6"}, + {file = "more_itertools-10.5.0-py3-none-any.whl", hash = "sha256:037b0d3203ce90cca8ab1defbbdac29d5f993fc20131f3664dc8d6acfa872aef"}, +] + +[[package]] +name = "msgpack" +version = "1.1.0" +requires_python = ">=3.8" +summary = "MessagePack serializer" +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "msgpack-1.1.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d8ce0b22b890be5d252de90d0e0d119f363012027cf256185fc3d474c44b1b9e"}, + {file = "msgpack-1.1.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5e1da8f11a3dd397f0a32c76165cf0c4eb95b31013a94f6ecc0b280c05c91b59"}, + {file = "msgpack-1.1.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:17fb65dd0bec285907f68b15734a993ad3fc94332b5bb21b0435846228de1f39"}, + {file = "msgpack-1.1.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8a706d1e74dd3dea05cb54580d9bd8b2880e9264856ce5068027eed09680aa74"}, + {file = "msgpack-1.1.0.tar.gz", hash = "sha256:dd432ccc2c72b914e4cb77afce64aab761c1137cc698be3984eee260bcb2896e"}, +] + +[[package]] +name = "multidict" +version = "6.1.0" +requires_python = ">=3.8" +summary = "multidict implementation" +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "typing-extensions>=4.1.0; python_version < \"3.11\"", +] +files = [ + {file = "multidict-6.1.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d618649d4e70ac6efcbba75be98b26ef5078faad23592f9b51ca492953012429"}, + {file = "multidict-6.1.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ec2abea24d98246b94913b76a125e855eb5c434f7c46546046372fe60f666351"}, + {file = "multidict-6.1.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4b820514bfc0b98a30e3d85462084779900347e4d49267f747ff54060cc33925"}, + {file = "multidict-6.1.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:957cf8e4b6e123a9eea554fa7ebc85674674b713551de587eb318a2df3e00255"}, + {file = "multidict-6.1.0-py3-none-any.whl", hash = "sha256:48e171e52d1c4d33888e529b999e5900356b9ae588c2f09a52dcefb158b27506"}, + {file = "multidict-6.1.0.tar.gz", hash = "sha256:22ae2ebf9b0c69d206c003e2f6a914ea33f0a932d4aa16f236afc049d9958f4a"}, +] + +[[package]] +name = "nbclient" +version = "0.10.0" +requires_python = ">=3.8.0" +summary = "A client library for executing notebooks. Formerly nbconvert's ExecutePreprocessor." +groups = ["docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "jupyter-client>=6.1.12", + "jupyter-core!=5.0.*,>=4.12", + "nbformat>=5.1", + "traitlets>=5.4", +] +files = [ + {file = "nbclient-0.10.0-py3-none-any.whl", hash = "sha256:f13e3529332a1f1f81d82a53210322476a168bb7090a0289c795fe9cc11c9d3f"}, + {file = "nbclient-0.10.0.tar.gz", hash = "sha256:4b3f1b7dba531e498449c4db4f53da339c91d449dc11e9af3a43b4eb5c5abb09"}, +] + +[[package]] +name = "nbconvert" +version = "7.16.6" +requires_python = ">=3.8" +summary = "Converting Jupyter Notebooks (.ipynb files) to other formats. Output formats include asciidoc, html, latex, markdown, pdf, py, rst, script. nbconvert can be used both as a Python library (`import nbconvert`) or as a command line tool (invoked as `jupyter nbconvert ...`)." +groups = ["docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "beautifulsoup4", + "bleach[css]!=5.0.0", + "defusedxml", + "importlib-metadata>=3.6; python_version < \"3.10\"", + "jinja2>=3.0", + "jupyter-core>=4.7", + "jupyterlab-pygments", + "markupsafe>=2.0", + "mistune<4,>=2.0.3", + "nbclient>=0.5.0", + "nbformat>=5.7", + "packaging", + "pandocfilters>=1.4.1", + "pygments>=2.4.1", + "traitlets>=5.1", +] +files = [ + {file = "nbconvert-7.16.6-py3-none-any.whl", hash = "sha256:1375a7b67e0c2883678c48e506dc320febb57685e5ee67faa51b18a90f3a712b"}, + {file = "nbconvert-7.16.6.tar.gz", hash = "sha256:576a7e37c6480da7b8465eefa66c17844243816ce1ccc372633c6b71c3c0f582"}, +] + +[[package]] +name = "nbformat" +version = "5.10.4" +requires_python = ">=3.8" +summary = "The Jupyter Notebook format" +groups = ["docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "fastjsonschema>=2.15", + "jsonschema>=2.6", + "jupyter-core!=5.0.*,>=4.12", + "traitlets>=5.1", +] +files = [ + {file = "nbformat-5.10.4-py3-none-any.whl", hash = "sha256:3b48d6c8fbca4b299bf3982ea7db1af21580e4fec269ad087b9e81588891200b"}, + {file = "nbformat-5.10.4.tar.gz", hash = "sha256:322168b14f937a5d11362988ecac2a4952d3d8e3a2cbeb2319584631226d5b3a"}, +] + +[[package]] +name = "nbsphinx" +version = "0.9.6" +requires_python = ">=3.6" +summary = "Jupyter Notebook Tools for Sphinx" +groups = ["docs"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "docutils>=0.18.1", + "jinja2", + "nbconvert!=5.4,>=5.3", + "nbformat", + "sphinx>=1.8", + "traitlets>=5", +] +files = [ + {file = "nbsphinx-0.9.6-py3-none-any.whl", hash = "sha256:336b0b557945a7678ec7449b16449f854bc852a435bb53b8a72e6b5dc740d992"}, + {file = "nbsphinx-0.9.6.tar.gz", hash = "sha256:c2b28a2d702f1159a95b843831798e86e60a17fc647b9bff9ba1585355de54e3"}, +] + +[[package]] +name = "nest-asyncio" +version = "1.6.0" +requires_python = ">=3.5" +summary = "Patch asyncio to allow nested event loops" +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "nest_asyncio-1.6.0-py3-none-any.whl", hash = "sha256:87af6efd6b5e897c81050477ef65c62e2b2f35d51703cae01aff2905b1852e1c"}, + {file = "nest_asyncio-1.6.0.tar.gz", hash = "sha256:6f172d5449aca15afd6c646851f4e31e02c598d553a667e38cafa997cfec55fe"}, +] + +[[package]] +name = "nodeenv" +version = "1.9.1" +requires_python = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,!=3.6.*,>=2.7" +summary = "Node.js virtual environment builder" +groups = ["qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "nodeenv-1.9.1-py2.py3-none-any.whl", hash = "sha256:ba11c9782d29c27c70ffbdda2d7415098754709be8a7056d79a737cd901155c9"}, + {file = "nodeenv-1.9.1.tar.gz", hash = "sha256:6ec12890a2dab7946721edbfbcd91f3319c6ccc9aec47be7c7e6b7011ee6645f"}, +] + +[[package]] +name = "notebook" +version = "7.3.2" +requires_python = ">=3.8" +summary = "Jupyter Notebook - A web-based notebook environment for interactive computing" +groups = ["qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "jupyter-server<3,>=2.4.0", + "jupyterlab-server<3,>=2.27.1", + "jupyterlab<4.4,>=4.3.4", + "notebook-shim<0.3,>=0.2", + "tornado>=6.2.0", +] +files = [ + {file = "notebook-7.3.2-py3-none-any.whl", hash = "sha256:e5f85fc59b69d3618d73cf27544418193ff8e8058d5bf61d315ce4f473556288"}, + {file = "notebook-7.3.2.tar.gz", hash = "sha256:705e83a1785f45b383bf3ee13cb76680b92d24f56fb0c7d2136fe1d850cd3ca8"}, +] + +[[package]] +name = "notebook-shim" +version = "0.2.4" +requires_python = ">=3.7" +summary = "A shim layer for notebook traits and config" +groups = ["qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "jupyter-server<3,>=1.8", +] +files = [ + {file = "notebook_shim-0.2.4-py3-none-any.whl", hash = "sha256:411a5be4e9dc882a074ccbcae671eda64cceb068767e9a3419096986560e1cef"}, + {file = "notebook_shim-0.2.4.tar.gz", hash = "sha256:b4b2cfa1b65d98307ca24361f5b30fe785b53c3fd07b7a47e89acb5e6ac638cb"}, +] + +[[package]] +name = "numpy" +version = "2.0.2" +requires_python = ">=3.9" +summary = "Fundamental package for array computing in Python" +groups = ["default", "pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "numpy-2.0.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:496f71341824ed9f3d2fd36cf3ac57ae2e0165c143b55c3a035ee219413f3318"}, + {file = "numpy-2.0.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:13e689d772146140a252c3a28501da66dfecd77490b498b168b501835041f951"}, + {file = "numpy-2.0.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0123ffdaa88fa4ab64835dcbde75dcdf89c453c922f18dced6e27c90d1d0ec5a"}, + {file = "numpy-2.0.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f26b258c385842546006213344c50655ff1555a9338e2e5e02a0756dc3e803dd"}, + {file = "numpy-2.0.2-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:26df23238872200f63518dd2aa984cfca675d82469535dc7162dc2ee52d9dd5c"}, + {file = "numpy-2.0.2.tar.gz", hash = "sha256:883c987dee1880e2a864ab0dc9892292582510604156762362d9326444636e78"}, +] + +[[package]] +name = "openpyxl" +version = "3.1.5" +requires_python = ">=3.8" +summary = "A Python library to read/write Excel 2010 xlsx/xlsm files" +groups = ["openpyxl"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "et-xmlfile", +] +files = [ + {file = "openpyxl-3.1.5-py2.py3-none-any.whl", hash = "sha256:5282c12b107bffeef825f4617dc029afaf41d0ea60823bbb665ef3079dc79de2"}, + {file = "openpyxl-3.1.5.tar.gz", hash = "sha256:cf0e3cf56142039133628b5acffe8ef0c12bc902d2aadd3e0fe5878dc08d1050"}, +] + +[[package]] +name = "overrides" +version = "7.7.0" +requires_python = ">=3.6" +summary = "A decorator to automatically detect mismatch when overriding a method." +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "typing; python_version < \"3.5\"", +] +files = [ + {file = "overrides-7.7.0-py3-none-any.whl", hash = "sha256:c7ed9d062f78b8e4c1a7b70bd8796b35ead4d9f510227ef9c5dc7626c60d7e49"}, + {file = "overrides-7.7.0.tar.gz", hash = "sha256:55158fa3d93b98cc75299b1e67078ad9003ca27945c76162c1c0766d6f91820a"}, +] + +[[package]] +name = "packaging" +version = "24.2" +requires_python = ">=3.8" +summary = "Core utilities for Python packages" +groups = ["default", "docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "packaging-24.2-py3-none-any.whl", hash = "sha256:09abb1bccd265c01f4a3aa3f7a7db064b36514d2cba19a2f694fe6150451a759"}, + {file = "packaging-24.2.tar.gz", hash = "sha256:c228a6dc5e932d346bc5739379109d49e8853dd8223571c7c5b55260edc0b97f"}, +] + +[[package]] +name = "pandas" +version = "2.2.3" +requires_python = ">=3.9" +summary = "Powerful data structures for data analysis, time series, and statistics" +groups = ["default"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "numpy>=1.22.4; python_version < \"3.11\"", + "numpy>=1.23.2; python_version == \"3.11\"", + "numpy>=1.26.0; python_version >= \"3.12\"", + "python-dateutil>=2.8.2", + "pytz>=2020.1", + "tzdata>=2022.7", +] +files = [ + {file = "pandas-2.2.3-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:86976a1c5b25ae3f8ccae3a5306e443569ee3c3faf444dfd0f41cda24667ad57"}, + {file = "pandas-2.2.3-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c124333816c3a9b03fbeef3a9f230ba9a737e9e5bb4060aa2107a86cc0a497fc"}, + {file = "pandas-2.2.3-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fffb8ae78d8af97f849404f21411c95062db1496aeb3e56f146f0355c9989319"}, + {file = "pandas-2.2.3-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:99df71520d25fade9db7c1076ac94eb994f4d2673ef2aa2e86ee039b6746d20c"}, + {file = "pandas-2.2.3.tar.gz", hash = "sha256:4f18ba62b61d7e192368b84517265a99b4d7ee8912f8708660fb4a366cc82667"}, +] + +[[package]] +name = "pandoc" +version = "2.4" +summary = "Pandoc Documents for Python" +groups = ["docs"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "plumbum", + "ply", +] +files = [ + {file = "pandoc-2.4.tar.gz", hash = "sha256:ecd1f8cbb7f4180c6b5db4a17a7c1a74df519995f5f186ef81ce72a9cbd0dd9a"}, +] + +[[package]] +name = "pandocfilters" +version = "1.5.1" +requires_python = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*" +summary = "Utilities for writing pandoc filters in python" +groups = ["docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "pandocfilters-1.5.1-py2.py3-none-any.whl", hash = "sha256:93be382804a9cdb0a7267585f157e5d1731bbe5545a85b268d6f5fe6232de2bc"}, + {file = "pandocfilters-1.5.1.tar.gz", hash = "sha256:002b4a555ee4ebc03f8b66307e287fa492e4a77b4ea14d3f934328297bb4939e"}, +] + +[[package]] +name = "parso" +version = "0.8.4" +requires_python = ">=3.6" +summary = "A Python Parser" +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "parso-0.8.4-py2.py3-none-any.whl", hash = "sha256:a418670a20291dacd2dddc80c377c5c3791378ee1e8d12bffc35420643d43f18"}, + {file = "parso-0.8.4.tar.gz", hash = "sha256:eb3a7b58240fb99099a345571deecc0f9540ea5f4dd2fe14c2a99d6b281ab92d"}, +] + +[[package]] +name = "pexpect" +version = "4.9.0" +summary = "Pexpect allows easy control of interactive console applications." +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\" and sys_platform != \"win32\"" +dependencies = [ + "ptyprocess>=0.5", +] +files = [ + {file = "pexpect-4.9.0-py2.py3-none-any.whl", hash = "sha256:7236d1e080e4936be2dc3e326cec0af72acf9212a7e1d060210e70a47e253523"}, + {file = "pexpect-4.9.0.tar.gz", hash = "sha256:ee7d41123f3c9911050ea2c2dac107568dc43b2d3b0c7557a33212c398ead30f"}, +] + +[[package]] +name = "pillow" +version = "10.4.0" +requires_python = ">=3.8" +summary = "Python Imaging Library (Fork)" +groups = ["default", "pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "pillow-10.4.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e4d49b85c4348ea0b31ea63bc75a9f3857869174e2bf17e7aba02945cd218e6f"}, + {file = "pillow-10.4.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5e84b6cc6a4a3d76c153a6b19270b3526a5a8ed6b09501d3af891daa2a9de7d6"}, + {file = "pillow-10.4.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bf2342ac639c4cf38799a44950bbc2dfcb685f052b9e262f446482afaf4bffca"}, + {file = "pillow-10.4.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:930044bb7679ab003b14023138b50181899da3f25de50e9dbee23b61b4de2126"}, + {file = "pillow-10.4.0-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ff25afb18123cea58a591ea0244b92eb1e61a1fd497bf6d6384f09bc3262ec3e"}, + {file = "pillow-10.4.0-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:87dd88ded2e6d74d31e1e0a99a726a6765cda32d00ba72dc37f0651f306daaa8"}, + {file = "pillow-10.4.0.tar.gz", hash = "sha256:166c1cd4d24309b30d61f79f4a9114b7b2313d7450912277855ff5dfd7cd4a06"}, +] + +[[package]] +name = "platformdirs" +version = "4.3.6" +requires_python = ">=3.8" +summary = "A small Python package for determining appropriate platform-specific dirs, e.g. a `user data dir`." +groups = ["docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "platformdirs-4.3.6-py3-none-any.whl", hash = "sha256:73e575e1408ab8103900836b97580d5307456908a03e92031bab39e4554cc3fb"}, + {file = "platformdirs-4.3.6.tar.gz", hash = "sha256:357fb2acbc885b0419afd3ce3ed34564c13c9b95c89360cd9563f73aa5e2b907"}, +] + +[[package]] +name = "pluggy" +version = "1.5.0" +requires_python = ">=3.8" +summary = "plugin and hook calling mechanisms for python" +groups = ["qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "pluggy-1.5.0-py3-none-any.whl", hash = "sha256:44e1ad92c8ca002de6377e165f3e0f1be63266ab4d554740532335b9d75ea669"}, + {file = "pluggy-1.5.0.tar.gz", hash = "sha256:2cffa88e94fdc978c4c574f15f9e59b7f4201d439195c3715ca9e2486f1d0cf1"}, +] + +[[package]] +name = "plumbum" +version = "1.8.3" +requires_python = ">=3.6" +summary = "Plumbum: shell combinators library" +groups = ["docs"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "pywin32; platform_system == \"Windows\" and platform_python_implementation != \"PyPy\"", +] +files = [ + {file = "plumbum-1.8.3-py3-none-any.whl", hash = "sha256:8595d36dae2472587d6f59789c8d7b26250f45f6f6ed75ccb378de59ee7b9cf9"}, + {file = "plumbum-1.8.3.tar.gz", hash = "sha256:6092c85ab970b7a7a9d5d85c75200bc93be82b33c9bdf640ffa87d2d7c8709f0"}, +] + +[[package]] +name = "ply" +version = "3.11" +summary = "Python Lex & Yacc" +groups = ["docs"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "ply-3.11-py2.py3-none-any.whl", hash = "sha256:096f9b8350b65ebd2fd1346b12452efe5b9607f7482813ffca50c22722a807ce"}, + {file = "ply-3.11.tar.gz", hash = "sha256:00c7c1aaa88358b9c765b6d3000c6eec0ba42abca5351b095321aef446081da3"}, +] + +[[package]] +name = "pooch" +version = "1.8.2" +requires_python = ">=3.7" +summary = "A friend to fetch your data files" +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "packaging>=20.0", + "platformdirs>=2.5.0", + "requests>=2.19.0", +] +files = [ + {file = "pooch-1.8.2-py3-none-any.whl", hash = "sha256:3529a57096f7198778a5ceefd5ac3ef0e4d06a6ddaf9fc2d609b806f25302c47"}, + {file = "pooch-1.8.2.tar.gz", hash = "sha256:76561f0de68a01da4df6af38e9955c4c9d1a5c90da73f7e40276a5728ec83d10"}, +] + +[[package]] +name = "pre-commit" +version = "4.1.0" +requires_python = ">=3.9" +summary = "A framework for managing and maintaining multi-language pre-commit hooks." +groups = ["qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "cfgv>=2.0.0", + "identify>=1.0.0", + "nodeenv>=0.11.1", + "pyyaml>=5.1", + "virtualenv>=20.10.0", +] +files = [ + {file = "pre_commit-4.1.0-py2.py3-none-any.whl", hash = "sha256:d29e7cb346295bcc1cc75fc3e92e343495e3ea0196c9ec6ba53f49f10ab6ae7b"}, + {file = "pre_commit-4.1.0.tar.gz", hash = "sha256:ae3f018575a588e30dfddfab9a05448bfbd6b73d78709617b5a2b853549716d4"}, +] + +[[package]] +name = "prometheus-client" +version = "0.20.0" +requires_python = ">=3.8" +summary = "Python client for the Prometheus monitoring system." +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "prometheus_client-0.20.0-py3-none-any.whl", hash = "sha256:cde524a85bce83ca359cc837f28b8c0db5cac7aa653a588fd7e84ba061c329e7"}, + {file = "prometheus_client-0.20.0.tar.gz", hash = "sha256:287629d00b147a32dcb2be0b9df905da599b2d82f80377083ec8463309a4bb89"}, +] + +[[package]] +name = "prompt-toolkit" +version = "3.0.47" +requires_python = ">=3.7.0" +summary = "Library for building powerful interactive command lines in Python" +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "wcwidth", +] +files = [ + {file = "prompt_toolkit-3.0.47-py3-none-any.whl", hash = "sha256:0d7bfa67001d5e39d02c224b663abc33687405033a8c422d0d675a5a13361d10"}, + {file = "prompt_toolkit-3.0.47.tar.gz", hash = "sha256:1e1b29cb58080b1e69f207c893a1a7bf16d127a5c30c9d17a25a5d77792e5360"}, +] + +[[package]] +name = "propcache" +version = "0.2.1" +requires_python = ">=3.9" +summary = "Accelerated property cache" +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "propcache-0.2.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6b6fb63ae352e13748289f04f37868099e69dba4c2b3e271c46061e82c745634"}, + {file = "propcache-0.2.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cf6c4150f8c0e32d241436526f3c3f9cbd34429492abddbada2ffcff506c51af"}, + {file = "propcache-0.2.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:647894f5ae99c4cf6bb82a1bb3a796f6e06af3caa3d32e26d2350d0e3e3faf24"}, + {file = "propcache-0.2.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f089118d584e859c62b3da0892b88a83d611c2033ac410e929cb6754eec0ed16"}, + {file = "propcache-0.2.1-py3-none-any.whl", hash = "sha256:52277518d6aae65536e9cea52d4e7fd2f7a66f4aa2d30ed3f2fcea620ace3c54"}, + {file = "propcache-0.2.1.tar.gz", hash = "sha256:3f77ce728b19cb537714499928fe800c3dda29e8d9428778fc7c186da4c09a64"}, +] + +[[package]] +name = "psutil" +version = "6.0.0" +requires_python = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7" +summary = "Cross-platform lib for process and system monitoring in Python." +groups = ["qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "psutil-6.0.0-cp36-abi3-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5fd9a97c8e94059b0ef54a7d4baf13b405011176c3b6ff257c247cae0d560ecd"}, + {file = "psutil-6.0.0.tar.gz", hash = "sha256:8faae4f310b6d969fa26ca0545338b21f73c6b15db7c4a8d934a5482faa818f2"}, +] + +[[package]] +name = "ptyprocess" +version = "0.7.0" +summary = "Run a subprocess in a pseudo terminal" +groups = ["pyvista", "qa"] +marker = "os_name != \"nt\" and python_version < \"3.13\" and python_version >= \"3.9\" or sys_platform != \"win32\" and python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "ptyprocess-0.7.0-py2.py3-none-any.whl", hash = "sha256:4b41f3967fce3af57cc7e94b888626c18bf37a083e3651ca8feeb66d492fef35"}, + {file = "ptyprocess-0.7.0.tar.gz", hash = "sha256:5c5d0a3b48ceee0b48485e0c26037c0acd7d29765ca3fbb5cb3831d347423220"}, +] + +[[package]] +name = "pure-eval" +version = "0.2.3" +summary = "Safely evaluate AST nodes without side effects" +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "pure_eval-0.2.3-py3-none-any.whl", hash = "sha256:1db8e35b67b3d218d818ae653e27f06c3aa420901fa7b081ca98cbedc874e0d0"}, + {file = "pure_eval-0.2.3.tar.gz", hash = "sha256:5f4e983f40564c576c7c8635ae88db5956bb2229d7e9237d03b3c0b0190eaf42"}, +] + +[[package]] +name = "pycparser" +version = "2.22" +requires_python = ">=3.8" +summary = "C parser in Python" +groups = ["docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "pycparser-2.22-py3-none-any.whl", hash = "sha256:c3702b6d3dd8c7abc1afa565d7e63d53a1d0bd86cdc24edd75470f4de499cfcc"}, + {file = "pycparser-2.22.tar.gz", hash = "sha256:491c8be9c040f5390f5bf44a5b07752bd07f56edf992381b05c701439eec10f6"}, +] + +[[package]] +name = "pydantic" +version = "2.10.6" +requires_python = ">=3.8" +summary = "Data validation using Python type hints" +groups = ["default"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "annotated-types>=0.6.0", + "pydantic-core==2.27.2", + "typing-extensions>=4.12.2", +] +files = [ + {file = "pydantic-2.10.6-py3-none-any.whl", hash = "sha256:427d664bf0b8a2b34ff5dd0f5a18df00591adcee7198fbd71981054cef37b584"}, + {file = "pydantic-2.10.6.tar.gz", hash = "sha256:ca5daa827cce33de7a42be142548b0096bf05a7e7b365aebfa5f8eeec7128236"}, +] + +[[package]] +name = "pydantic-core" +version = "2.27.2" +requires_python = ">=3.8" +summary = "Core functionality for Pydantic validation and serialization" +groups = ["default"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "typing-extensions!=4.7.0,>=4.6.0", +] +files = [ + {file = "pydantic_core-2.27.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:47956ae78b6422cbd46f772f1746799cbb862de838fd8d1fbd34a82e05b0983a"}, + {file = "pydantic_core-2.27.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1c1fd185014191700554795c99b347d64f2bb637966c4cfc16998a0ca700d048"}, + {file = "pydantic_core-2.27.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6fb4aadc0b9a0c063206846d603b92030eb6f03069151a625667f982887153e2"}, + {file = "pydantic_core-2.27.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0d1e85068e818c73e048fe28cfc769040bb1f475524f4745a5dc621f75ac7630"}, + {file = "pydantic_core-2.27.2-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3d591580c34f4d731592f0e9fe40f9cc1b430d297eecc70b962e93c5c668f15f"}, + {file = "pydantic_core-2.27.2-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:251136cdad0cb722e93732cb45ca5299fb56e1344a833640bf93b2803f8d1bfd"}, + {file = "pydantic_core-2.27.2.tar.gz", hash = "sha256:eb026e5a4c1fee05726072337ff51d1efb6f59090b7da90d30ea58625b1ffb39"}, +] + +[[package]] +name = "pygments" +version = "2.18.0" +requires_python = ">=3.8" +summary = "Pygments is a syntax highlighting package written in Python." +groups = ["docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "pygments-2.18.0-py3-none-any.whl", hash = "sha256:b8e6aca0523f3ab76fee51799c488e38782ac06eafcf95e7ba832985c8e7b13a"}, + {file = "pygments-2.18.0.tar.gz", hash = "sha256:786ff802f32e91311bff3889f6e9a86e81505fe99f2735bb6d60ae0c5004f199"}, +] + +[[package]] +name = "pyparsing" +version = "3.1.4" +requires_python = ">=3.6.8" +summary = "pyparsing module - Classes and methods to define and execute parsing grammars" +groups = ["default", "pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "pyparsing-3.1.4-py3-none-any.whl", hash = "sha256:a6a7ee4235a3f944aa1fa2249307708f893fe5717dc603503c6c7969c070fb7c"}, + {file = "pyparsing-3.1.4.tar.gz", hash = "sha256:f86ec8d1a83f11977c9a6ea7598e8c27fc5cddfa5b07ea2241edbbde1d7bc032"}, +] + +[[package]] +name = "pyproject-api" +version = "1.9.0" +requires_python = ">=3.9" +summary = "API to interact with the python pyproject.toml based projects" +groups = ["qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "packaging>=24.2", + "tomli>=2.2.1; python_version < \"3.11\"", +] +files = [ + {file = "pyproject_api-1.9.0-py3-none-any.whl", hash = "sha256:326df9d68dea22d9d98b5243c46e3ca3161b07a1b9b18e213d1e24fd0e605766"}, + {file = "pyproject_api-1.9.0.tar.gz", hash = "sha256:7e8a9854b2dfb49454fae421cb86af43efbb2b2454e5646ffb7623540321ae6e"}, +] + +[[package]] +name = "pyqt5" +version = "5.15.10" +requires_python = ">=3.7" +summary = "Python bindings for the Qt cross platform application toolkit" +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "PyQt5-Qt5>=5.15.2", + "PyQt5-sip<13,>=12.13", +] +files = [ + {file = "PyQt5-5.15.10-cp37-abi3-manylinux_2_17_x86_64.whl", hash = "sha256:b89478d16d4118664ff58ed609e0a804d002703c9420118de7e4e70fa1cb5486"}, + {file = "PyQt5-5.15.10.tar.gz", hash = "sha256:d46b7804b1b10a4ff91753f8113e5b5580d2b4462f3226288e2d84497334898a"}, +] + +[[package]] +name = "pyqt5-qt5" +version = "5.15.2" +summary = "The subset of a Qt installation needed by PyQt5." +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "PyQt5_Qt5-5.15.2-py3-none-manylinux2014_x86_64.whl", hash = "sha256:1988f364ec8caf87a6ee5d5a3a5210d57539988bf8e84714c7d60972692e2f4a"}, +] + +[[package]] +name = "pyqt5-sip" +version = "12.15.0" +requires_python = ">=3.8" +summary = "The sip module support for PyQt5" +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "PyQt5_sip-12.15.0-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:b4adc529fa4ec05728e14ea55194d907cc51f18d6f2ac5cc9f6eb52ac038aa0f"}, + {file = "PyQt5_sip-12.15.0-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:0b718a362f4392430903bbb2a4b9bbff9841a16a52f0cfdd5b5bbd9d11457980"}, + {file = "PyQt5_sip-12.15.0-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:0cd21c3215e3c47fdd5fa7a2dc3dd1e07a7230b0626e905a7217925068c788b9"}, + {file = "PyQt5_sip-12.15.0-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:97f2d6e8d9b7b3d3e795d576d7f56e6257f524221f6383b33ded7287763e9f06"}, + {file = "PyQt5_sip-12.15.0.tar.gz", hash = "sha256:d23fdfcf363b5cedd9d39f8a9c5710e7d52804f5b08a58e91c638b36eafcb702"}, +] + +[[package]] +name = "pytest" +version = "8.3.4" +requires_python = ">=3.8" +summary = "pytest: simple powerful testing with Python" +groups = ["qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "colorama; sys_platform == \"win32\"", + "exceptiongroup>=1.0.0rc8; python_version < \"3.11\"", + "iniconfig", + "packaging", + "pluggy<2,>=1.5", + "tomli>=1; python_version < \"3.11\"", +] +files = [ + {file = "pytest-8.3.4-py3-none-any.whl", hash = "sha256:50e16d954148559c9a74109af1eaf0c945ba2d8f30f0a3d3335edde19788b6f6"}, + {file = "pytest-8.3.4.tar.gz", hash = "sha256:965370d062bce11e73868e0335abac31b4d3de0e82f4007408d242b4f8610761"}, +] + +[[package]] +name = "pytest-cov" +version = "6.0.0" +requires_python = ">=3.9" +summary = "Pytest plugin for measuring coverage." +groups = ["qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "coverage[toml]>=7.5", + "pytest>=4.6", +] +files = [ + {file = "pytest-cov-6.0.0.tar.gz", hash = "sha256:fde0b595ca248bb8e2d76f020b465f3b107c9632e6a1d1705f17834c89dcadc0"}, + {file = "pytest_cov-6.0.0-py3-none-any.whl", hash = "sha256:eee6f1b9e61008bd34975a4d5bab25801eb31898b032dd55addc93e96fcaaa35"}, +] + +[[package]] +name = "python-dateutil" +version = "2.9.0.post0" +requires_python = "!=3.0.*,!=3.1.*,!=3.2.*,>=2.7" +summary = "Extensions to the standard Python datetime module" +groups = ["default", "docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "six>=1.5", +] +files = [ + {file = "python-dateutil-2.9.0.post0.tar.gz", hash = "sha256:37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3"}, + {file = "python_dateutil-2.9.0.post0-py2.py3-none-any.whl", hash = "sha256:a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427"}, +] + +[[package]] +name = "python-json-logger" +version = "2.0.7" +requires_python = ">=3.6" +summary = "A python library adding a json log formatter" +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "python-json-logger-2.0.7.tar.gz", hash = "sha256:23e7ec02d34237c5aa1e29a070193a4ea87583bb4e7f8fd06d3de8264c4b2e1c"}, + {file = "python_json_logger-2.0.7-py3-none-any.whl", hash = "sha256:f380b826a991ebbe3de4d897aeec42760035ac760345e57b812938dc8b35e2bd"}, +] + +[[package]] +name = "pytz" +version = "2024.2" +summary = "World timezone definitions, modern and historical" +groups = ["default"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "pytz-2024.2-py2.py3-none-any.whl", hash = "sha256:31c7c1817eb7fae7ca4b8c7ee50c72f93aa2dd863de768e1ef4245d426aa0725"}, + {file = "pytz-2024.2.tar.gz", hash = "sha256:2aa355083c50a0f93fa581709deac0c9ad65cca8a9e9beac660adcbd493c798a"}, +] + +[[package]] +name = "pyvista" +version = "0.44.2" +requires_python = ">=3.8" +summary = "Easier Pythonic interface to VTK" +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "matplotlib>=3.0.1", + "numpy>=1.21.0", + "pillow", + "pooch", + "scooby>=0.5.1", + "typing-extensions", + "vtk<9.4.0", +] +files = [ + {file = "pyvista-0.44.2-py3-none-any.whl", hash = "sha256:8530d35f57cdaa33507ac9aec19e3292be0bc9026b28e4f12df7e8054438d028"}, + {file = "pyvista-0.44.2.tar.gz", hash = "sha256:db65943c3c1c9ba49fe16f5a25a5bc23b74bf1ea7a38aae4ef9c4dc5838ccf5e"}, +] + +[[package]] +name = "pyvista" +version = "0.44.2" +extras = ["all"] +requires_python = ">=3.8" +summary = "Easier Pythonic interface to VTK" +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "pyvista==0.44.2", + "pyvista[colormaps,io,jupyter]", +] +files = [ + {file = "pyvista-0.44.2-py3-none-any.whl", hash = "sha256:8530d35f57cdaa33507ac9aec19e3292be0bc9026b28e4f12df7e8054438d028"}, + {file = "pyvista-0.44.2.tar.gz", hash = "sha256:db65943c3c1c9ba49fe16f5a25a5bc23b74bf1ea7a38aae4ef9c4dc5838ccf5e"}, +] + +[[package]] +name = "pyvista" +version = "0.44.2" +extras = ["colormaps", "io", "jupyter"] +requires_python = ">=3.8" +summary = "Easier Pythonic interface to VTK" +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "cmocean", + "colorcet", + "imageio", + "ipywidgets", + "jupyter-server-proxy", + "meshio>=5.2", + "nest-asyncio", + "pyvista==0.44.2", + "trame-client>=2.12.7", + "trame-server>=2.11.7", + "trame-vtk>=2.5.8", + "trame-vuetify>=2.3.1", + "trame>=2.5.2", +] +files = [ + {file = "pyvista-0.44.2-py3-none-any.whl", hash = "sha256:8530d35f57cdaa33507ac9aec19e3292be0bc9026b28e4f12df7e8054438d028"}, + {file = "pyvista-0.44.2.tar.gz", hash = "sha256:db65943c3c1c9ba49fe16f5a25a5bc23b74bf1ea7a38aae4ef9c4dc5838ccf5e"}, +] + +[[package]] +name = "pyvistaqt" +version = "0.11.1" +requires_python = ">=3.7" +summary = "pyvista qt plotter" +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "QtPy>=1.9.0", + "pyvista>=0.32.0", +] +files = [ + {file = "pyvistaqt-0.11.1-py3-none-any.whl", hash = "sha256:3ddc05418fcb297d471e7f7c0fdc89dbd5b6050653b4a86e66e5c1ce7e3563cc"}, + {file = "pyvistaqt-0.11.1.tar.gz", hash = "sha256:5403bfeb82cf063288107a9be9780ca3ca70948e73d33d16a65a83a711d51a36"}, +] + +[[package]] +name = "pyyaml" +version = "6.0.2" +requires_python = ">=3.8" +summary = "YAML parser and emitter for Python" +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "PyYAML-6.0.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ec031d5d2feb36d1d1a24380e4db6d43695f3748343d99434e6f5f9156aaa2ed"}, + {file = "PyYAML-6.0.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3ad2a3decf9aaba3d29c8f537ac4b243e36bef957511b4766cb0057d32b0be85"}, + {file = "PyYAML-6.0.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:80bab7bfc629882493af4aa31a4cfa43a4c57c83813253626916b8c7ada83476"}, + {file = "PyYAML-6.0.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3b1fdb9dc17f5a7677423d508ab4f243a726dea51fa5e70992e59a7411c89d19"}, + {file = "pyyaml-6.0.2.tar.gz", hash = "sha256:d584d9ec91ad65861cc08d42e834324ef890a082e591037abe114850ff7bbc3e"}, +] + +[[package]] +name = "pyzmq" +version = "26.2.0" +requires_python = ">=3.7" +summary = "Python bindings for 0MQ" +groups = ["docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "cffi; implementation_name == \"pypy\"", +] +files = [ + {file = "pyzmq-26.2.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8ea039387c10202ce304af74def5021e9adc6297067f3441d348d2b633e8166a"}, + {file = "pyzmq-26.2.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:92a78853d7280bffb93df0a4a6a2498cba10ee793cc8076ef797ef2f74d107cf"}, + {file = "pyzmq-26.2.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ea7f69de383cb47522c9c208aec6dd17697db7875a4674c4af3f8cfdac0bdeae"}, + {file = "pyzmq-26.2.0-cp39-cp39-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:05590cdbc6b902101d0e65d6a4780af14dc22914cc6ab995d99b85af45362cc9"}, + {file = "pyzmq-26.2.0-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2c4a71d5d6e7b28a47a394c0471b7e77a0661e2d651e7ae91e0cab0a587859ca"}, + {file = "pyzmq-26.2.0-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7133d0a1677aec369d67dd78520d3fa96dd7f3dcec99d66c1762870e5ea1a50a"}, + {file = "pyzmq-26.2.0.tar.gz", hash = "sha256:070672c258581c8e4f640b5159297580a9974b026043bd4ab0470be9ed324f1f"}, +] + +[[package]] +name = "qtpy" +version = "2.4.1" +requires_python = ">=3.7" +summary = "Provides an abstraction layer on top of the various Qt bindings (PyQt5/6 and PySide2/6)." +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "packaging", +] +files = [ + {file = "QtPy-2.4.1-py3-none-any.whl", hash = "sha256:1c1d8c4fa2c884ae742b069151b0abe15b3f70491f3972698c683b8e38de839b"}, + {file = "QtPy-2.4.1.tar.gz", hash = "sha256:a5a15ffd519550a1361bdc56ffc07fda56a6af7292f17c7b395d4083af632987"}, +] + +[[package]] +name = "referencing" +version = "0.35.1" +requires_python = ">=3.8" +summary = "JSON Referencing + Python" +groups = ["docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "attrs>=22.2.0", + "rpds-py>=0.7.0", +] +files = [ + {file = "referencing-0.35.1-py3-none-any.whl", hash = "sha256:eda6d3234d62814d1c64e305c1331c9a3a6132da475ab6382eaa997b21ee75de"}, + {file = "referencing-0.35.1.tar.gz", hash = "sha256:25b42124a6c8b632a425174f24087783efb348a6f1e0008e63cd4466fedf703c"}, +] + +[[package]] +name = "requests" +version = "2.32.3" +requires_python = ">=3.8" +summary = "Python HTTP for Humans." +groups = ["docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "certifi>=2017.4.17", + "charset-normalizer<4,>=2", + "idna<4,>=2.5", + "urllib3<3,>=1.21.1", +] +files = [ + {file = "requests-2.32.3-py3-none-any.whl", hash = "sha256:70761cfe03c773ceb22aa2f671b4757976145175cdfca038c02654d061d6dcc6"}, + {file = "requests-2.32.3.tar.gz", hash = "sha256:55365417734eb18255590a9ff9eb97e9e1da868d4ccd6402399eaf68af20a760"}, +] + +[[package]] +name = "rfc3339-validator" +version = "0.1.4" +requires_python = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*" +summary = "A pure python RFC3339 validator" +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "six", +] +files = [ + {file = "rfc3339_validator-0.1.4-py2.py3-none-any.whl", hash = "sha256:24f6ec1eda14ef823da9e36ec7113124b39c04d50a4d3d3a3c2859577e7791fa"}, + {file = "rfc3339_validator-0.1.4.tar.gz", hash = "sha256:138a2abdf93304ad60530167e51d2dfb9549521a836871b88d7f4695d0022f6b"}, +] + +[[package]] +name = "rfc3986-validator" +version = "0.1.1" +requires_python = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*" +summary = "Pure python rfc3986 validator" +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "rfc3986_validator-0.1.1-py2.py3-none-any.whl", hash = "sha256:2f235c432ef459970b4306369336b9d5dbdda31b510ca1e327636e01f528bfa9"}, + {file = "rfc3986_validator-0.1.1.tar.gz", hash = "sha256:3d44bde7921b3b9ec3ae4e3adca370438eccebc676456449b145d533b240d055"}, +] + +[[package]] +name = "rich" +version = "13.8.1" +requires_python = ">=3.7.0" +summary = "Render rich text, tables, progress bars, syntax highlighting, markdown and more to the terminal" +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "markdown-it-py>=2.2.0", + "pygments<3.0.0,>=2.13.0", + "typing-extensions<5.0,>=4.0.0; python_version < \"3.9\"", +] +files = [ + {file = "rich-13.8.1-py3-none-any.whl", hash = "sha256:1760a3c0848469b97b558fc61c85233e3dafb69c7a071b4d60c38099d3cd4c06"}, + {file = "rich-13.8.1.tar.gz", hash = "sha256:8260cda28e3db6bf04d2d1ef4dbc03ba80a824c88b0e7668a0f23126a424844a"}, +] + +[[package]] +name = "rpds-py" +version = "0.20.0" +requires_python = ">=3.8" +summary = "Python bindings to Rust's persistent data structures (rpds)" +groups = ["docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "rpds_py-0.20.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f8e604fe73ba048c06085beaf51147eaec7df856824bfe7b98657cf436623daf"}, + {file = "rpds_py-0.20.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5c1dc0f53856b9cc9a0ccca0a7cc61d3d20a7088201c0937f3f4048c1718a209"}, + {file = "rpds_py-0.20.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ea438162a9fcbee3ecf36c23e6c68237479f89f962f82dae83dc15feeceb37e4"}, + {file = "rpds_py-0.20.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b4c29cbbba378759ac5786730d1c3cb4ec6f8ababf5c42a9ce303dc4b3d08cda"}, + {file = "rpds_py-0.20.0-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c3c20f0ddeb6e29126d45f89206b8291352b8c5b44384e78a6499d68b52ae511"}, + {file = "rpds_py-0.20.0-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f90a4cd061914a60bd51c68bcb4357086991bd0bb93d8aa66a6da7701370708f"}, + {file = "rpds_py-0.20.0.tar.gz", hash = "sha256:d72a210824facfdaf8768cf2d7ca25a042c30320b3020de2fa04640920d4e121"}, +] + +[[package]] +name = "scipy" +version = "1.13.1" +requires_python = ">=3.9" +summary = "Fundamental algorithms for scientific computing in Python" +groups = ["default"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "numpy<2.3,>=1.22.4", +] +files = [ + {file = "scipy-1.13.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f26264b282b9da0952a024ae34710c2aff7d27480ee91a2e82b7b7073c24722f"}, + {file = "scipy-1.13.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a78b4b3345f1b6f68a763c6e25c0c9a23a9fd0f39f5f3d200efe8feda560a5fa"}, + {file = "scipy-1.13.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:de3ade0e53bc1f21358aa74ff4830235d716211d7d077e340c7349bc3542e884"}, + {file = "scipy-1.13.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:637e98dcf185ba7f8e663e122ebf908c4702420477ae52a04f9908707456ba4d"}, + {file = "scipy-1.13.1.tar.gz", hash = "sha256:095a87a0312b08dfd6a6155cbbd310a8c51800fc931b8c0b84003014b874ed3c"}, +] + +[[package]] +name = "scooby" +version = "0.10.0" +requires_python = ">=3.8" +summary = "A Great Dane turned Python environment detective" +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "scooby-0.10.0-py3-none-any.whl", hash = "sha256:0a3d7e304f8ebb16f69ff7f6360c345d7f50b45f2ddbf7c3d18a6a0dc2cb03a6"}, + {file = "scooby-0.10.0.tar.gz", hash = "sha256:7ea33c262c0cc6a33c6eeeb5648df787be4f22660e53c114e5fff1b811a8854f"}, +] + +[[package]] +name = "send2trash" +version = "1.8.3" +requires_python = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7" +summary = "Send file to trash natively under Mac OS X, Windows and Linux" +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "Send2Trash-1.8.3-py3-none-any.whl", hash = "sha256:0c31227e0bd08961c7665474a3d1ef7193929fedda4233843689baa056be46c9"}, + {file = "Send2Trash-1.8.3.tar.gz", hash = "sha256:b18e7a3966d99871aefeb00cfbcfdced55ce4871194810fc71f4aa484b953abf"}, +] + +[[package]] +name = "setuptools" +version = "74.1.2" +requires_python = ">=3.8" +summary = "Easily download, build, install, upgrade, and uninstall Python packages" +groups = ["qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "setuptools-74.1.2-py3-none-any.whl", hash = "sha256:5f4c08aa4d3ebcb57a50c33b1b07e94315d7fc7230f7115e47fc99776c8ce308"}, + {file = "setuptools-74.1.2.tar.gz", hash = "sha256:95b40ed940a1c67eb70fc099094bd6e99c6ee7c23aa2306f4d2697ba7916f9c6"}, +] + +[[package]] +name = "simpervisor" +version = "1.0.0" +requires_python = ">=3.8" +summary = "Simple async process supervisor" +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "simpervisor-1.0.0-py3-none-any.whl", hash = "sha256:3e313318264559beea3f475ead202bc1cd58a2f1288363abb5657d306c5b8388"}, + {file = "simpervisor-1.0.0.tar.gz", hash = "sha256:7eb87ca86d5e276976f5bb0290975a05d452c6a7b7f58062daea7d8369c823c1"}, +] + +[[package]] +name = "six" +version = "1.16.0" +requires_python = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*" +summary = "Python 2 and 3 compatibility utilities" +groups = ["default", "docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "six-1.16.0-py2.py3-none-any.whl", hash = "sha256:8abb2f1d86890a2dfb989f9a77cfcfd3e47c2a354b01111771326f8aa26e0254"}, + {file = "six-1.16.0.tar.gz", hash = "sha256:1e61c37477a1626458e36f7b1d82aa5c9b094fa4802892072e49de9c60c4c926"}, +] + +[[package]] +name = "sniffio" +version = "1.3.1" +requires_python = ">=3.7" +summary = "Sniff out which async library your code is running under" +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "sniffio-1.3.1-py3-none-any.whl", hash = "sha256:2f6da418d1f1e0fddd844478f41680e794e6051915791a034ff65e5f100525a2"}, + {file = "sniffio-1.3.1.tar.gz", hash = "sha256:f4324edc670a0f49750a81b895f35c3adb843cca46f0530f79fc1babb23789dc"}, +] + +[[package]] +name = "snowballstemmer" +version = "2.2.0" +summary = "This package provides 29 stemmers for 28 languages generated from Snowball algorithms." +groups = ["docs"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "snowballstemmer-2.2.0-py2.py3-none-any.whl", hash = "sha256:c8e1716e83cc398ae16824e5572ae04e0d9fc2c6b985fb0f900f5f0c96ecba1a"}, + {file = "snowballstemmer-2.2.0.tar.gz", hash = "sha256:09b16deb8547d3412ad7b590689584cd0fe25ec8db3be37788be3810cbf19cb1"}, +] + +[[package]] +name = "soupsieve" +version = "2.6" +requires_python = ">=3.8" +summary = "A modern CSS selector implementation for Beautiful Soup." +groups = ["docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "soupsieve-2.6-py3-none-any.whl", hash = "sha256:e72c4ff06e4fb6e4b5a9f0f55fe6e81514581fca1515028625d0f299c602ccc9"}, + {file = "soupsieve-2.6.tar.gz", hash = "sha256:e2e68417777af359ec65daac1057404a3c8a5455bb8abc36f1a9866ab1a51abb"}, +] + +[[package]] +name = "sphinx" +version = "7.4.7" +requires_python = ">=3.9" +summary = "Python documentation generator" +groups = ["docs"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "Jinja2>=3.1", + "Pygments>=2.17", + "alabaster~=0.7.14", + "babel>=2.13", + "colorama>=0.4.6; sys_platform == \"win32\"", + "docutils<0.22,>=0.20", + "imagesize>=1.3", + "importlib-metadata>=6.0; python_version < \"3.10\"", + "packaging>=23.0", + "requests>=2.30.0", + "snowballstemmer>=2.2", + "sphinxcontrib-applehelp", + "sphinxcontrib-devhelp", + "sphinxcontrib-htmlhelp>=2.0.0", + "sphinxcontrib-jsmath", + "sphinxcontrib-qthelp", + "sphinxcontrib-serializinghtml>=1.1.9", + "tomli>=2; python_version < \"3.11\"", +] +files = [ + {file = "sphinx-7.4.7-py3-none-any.whl", hash = "sha256:c2419e2135d11f1951cd994d6eb18a1835bd8fdd8429f9ca375dc1f3281bd239"}, + {file = "sphinx-7.4.7.tar.gz", hash = "sha256:242f92a7ea7e6c5b406fdc2615413890ba9f699114a9c09192d7dfead2ee9cfe"}, +] + +[[package]] +name = "sphinx-rtd-theme" +version = "3.0.2" +requires_python = ">=3.8" +summary = "Read the Docs theme for Sphinx" +groups = ["docs"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "docutils<0.22,>0.18", + "sphinx<9,>=6", + "sphinxcontrib-jquery<5,>=4", +] +files = [ + {file = "sphinx_rtd_theme-3.0.2-py2.py3-none-any.whl", hash = "sha256:422ccc750c3a3a311de4ae327e82affdaf59eb695ba4936538552f3b00f4ee13"}, + {file = "sphinx_rtd_theme-3.0.2.tar.gz", hash = "sha256:b7457bc25dda723b20b086a670b9953c859eab60a2a03ee8eb2bb23e176e5f85"}, +] + +[[package]] +name = "sphinxcontrib-applehelp" +version = "2.0.0" +requires_python = ">=3.9" +summary = "sphinxcontrib-applehelp is a Sphinx extension which outputs Apple help books" +groups = ["docs"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "sphinxcontrib_applehelp-2.0.0-py3-none-any.whl", hash = "sha256:4cd3f0ec4ac5dd9c17ec65e9ab272c9b867ea77425228e68ecf08d6b28ddbdb5"}, + {file = "sphinxcontrib_applehelp-2.0.0.tar.gz", hash = "sha256:2f29ef331735ce958efa4734873f084941970894c6090408b079c61b2e1c06d1"}, +] + +[[package]] +name = "sphinxcontrib-devhelp" +version = "2.0.0" +requires_python = ">=3.9" +summary = "sphinxcontrib-devhelp is a sphinx extension which outputs Devhelp documents" +groups = ["docs"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "sphinxcontrib_devhelp-2.0.0-py3-none-any.whl", hash = "sha256:aefb8b83854e4b0998877524d1029fd3e6879210422ee3780459e28a1f03a8a2"}, + {file = "sphinxcontrib_devhelp-2.0.0.tar.gz", hash = "sha256:411f5d96d445d1d73bb5d52133377b4248ec79db5c793ce7dbe59e074b4dd1ad"}, +] + +[[package]] +name = "sphinxcontrib-htmlhelp" +version = "2.1.0" +requires_python = ">=3.9" +summary = "sphinxcontrib-htmlhelp is a sphinx extension which renders HTML help files" +groups = ["docs"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "sphinxcontrib_htmlhelp-2.1.0-py3-none-any.whl", hash = "sha256:166759820b47002d22914d64a075ce08f4c46818e17cfc9470a9786b759b19f8"}, + {file = "sphinxcontrib_htmlhelp-2.1.0.tar.gz", hash = "sha256:c9e2916ace8aad64cc13a0d233ee22317f2b9025b9cf3295249fa985cc7082e9"}, +] + +[[package]] +name = "sphinxcontrib-jquery" +version = "4.1" +requires_python = ">=2.7" +summary = "Extension to include jQuery on newer Sphinx releases" +groups = ["docs"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "Sphinx>=1.8", +] +files = [ + {file = "sphinxcontrib-jquery-4.1.tar.gz", hash = "sha256:1620739f04e36a2c779f1a131a2dfd49b2fd07351bf1968ced074365933abc7a"}, + {file = "sphinxcontrib_jquery-4.1-py2.py3-none-any.whl", hash = "sha256:f936030d7d0147dd026a4f2b5a57343d233f1fc7b363f68b3d4f1cb0993878ae"}, +] + +[[package]] +name = "sphinxcontrib-jsmath" +version = "1.0.1" +requires_python = ">=3.5" +summary = "A sphinx extension which renders display math in HTML via JavaScript" +groups = ["docs"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "sphinxcontrib-jsmath-1.0.1.tar.gz", hash = "sha256:a9925e4a4587247ed2191a22df5f6970656cb8ca2bd6284309578f2153e0c4b8"}, + {file = "sphinxcontrib_jsmath-1.0.1-py2.py3-none-any.whl", hash = "sha256:2ec2eaebfb78f3f2078e73666b1415417a116cc848b72e5172e596c871103178"}, +] + +[[package]] +name = "sphinxcontrib-qthelp" +version = "2.0.0" +requires_python = ">=3.9" +summary = "sphinxcontrib-qthelp is a sphinx extension which outputs QtHelp documents" +groups = ["docs"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "sphinxcontrib_qthelp-2.0.0-py3-none-any.whl", hash = "sha256:b18a828cdba941ccd6ee8445dbe72ffa3ef8cbe7505d8cd1fa0d42d3f2d5f3eb"}, + {file = "sphinxcontrib_qthelp-2.0.0.tar.gz", hash = "sha256:4fe7d0ac8fc171045be623aba3e2a8f613f8682731f9153bb2e40ece16b9bbab"}, +] + +[[package]] +name = "sphinxcontrib-serializinghtml" +version = "2.0.0" +requires_python = ">=3.9" +summary = "sphinxcontrib-serializinghtml is a sphinx extension which outputs \"serialized\" HTML files (json and pickle)" +groups = ["docs"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "sphinxcontrib_serializinghtml-2.0.0-py3-none-any.whl", hash = "sha256:6e2cb0eef194e10c27ec0023bfeb25badbbb5868244cf5bc5bdc04e4464bf331"}, + {file = "sphinxcontrib_serializinghtml-2.0.0.tar.gz", hash = "sha256:e9d912827f872c029017a53f0ef2180b327c3f7fd23c87229f7a8e8b70031d4d"}, +] + +[[package]] +name = "stack-data" +version = "0.6.3" +summary = "Extract data from python stack frames and tracebacks for informative displays" +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "asttokens>=2.1.0", + "executing>=1.2.0", + "pure-eval", +] +files = [ + {file = "stack_data-0.6.3-py3-none-any.whl", hash = "sha256:d5558e0c25a4cb0853cddad3d77da9891a08cb85dd9f9f91b9f8cd66e511e695"}, + {file = "stack_data-0.6.3.tar.gz", hash = "sha256:836a778de4fec4dcd1dcd89ed8abff8a221f58308462e1c4aa2a3cf30148f0b9"}, +] + +[[package]] +name = "terminado" +version = "0.18.1" +requires_python = ">=3.8" +summary = "Tornado websocket backend for the Xterm.js Javascript terminal emulator library." +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "ptyprocess; os_name != \"nt\"", + "pywinpty>=1.1.0; os_name == \"nt\"", + "tornado>=6.1.0", +] +files = [ + {file = "terminado-0.18.1-py3-none-any.whl", hash = "sha256:a4468e1b37bb318f8a86514f65814e1afc977cf29b3992a4500d9dd305dcceb0"}, + {file = "terminado-0.18.1.tar.gz", hash = "sha256:de09f2c4b85de4765f7714688fff57d3e75bad1f909b589fde880460c753fd2e"}, +] + +[[package]] +name = "tinycss2" +version = "1.3.0" +requires_python = ">=3.8" +summary = "A tiny CSS parser" +groups = ["docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "webencodings>=0.4", +] +files = [ + {file = "tinycss2-1.3.0-py3-none-any.whl", hash = "sha256:54a8dbdffb334d536851be0226030e9505965bb2f30f21a4a82c55fb2a80fae7"}, + {file = "tinycss2-1.3.0.tar.gz", hash = "sha256:152f9acabd296a8375fbca5b84c961ff95971fcfc32e79550c8df8e29118c54d"}, +] + +[[package]] +name = "tomli" +version = "2.2.1" +requires_python = ">=3.8" +summary = "A lil' TOML parser" +groups = ["docs", "qa"] +marker = "python_version < \"3.11\" and python_version >= \"3.9\"" +files = [ + {file = "tomli-2.2.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6972ca9c9cc9f0acaa56a8ca1ff51e7af152a9f87fb64623e31d5c83700080ee"}, + {file = "tomli-2.2.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:db2b95f9de79181805df90bedc5a5ab4c165e6ec3fe99f970d0e302f384ad222"}, + {file = "tomli-2.2.1-py3-none-any.whl", hash = "sha256:cb55c73c5f4408779d0cf3eef9f762b9c9f147a77de7b258bef0a5628adc85cc"}, + {file = "tomli-2.2.1.tar.gz", hash = "sha256:cd45e1dc79c835ce60f7404ec8119f2eb06d38b1deba146f07ced3bbc44505ff"}, +] + +[[package]] +name = "tornado" +version = "6.4.2" +requires_python = ">=3.8" +summary = "Tornado is a Python web framework and asynchronous networking library, originally developed at FriendFeed." +groups = ["docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "tornado-6.4.2-cp38-abi3-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bca9eb02196e789c9cb5c3c7c0f04fb447dc2adffd95265b2c7223a8a615ccbf"}, + {file = "tornado-6.4.2.tar.gz", hash = "sha256:92bad5b4746e9879fd7bf1eb21dce4e3fc5128d71601f80005afa39237ad620b"}, +] + +[[package]] +name = "tox" +version = "4.24.1" +requires_python = ">=3.8" +summary = "tox is a generic virtualenv management and test command line tool" +groups = ["qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "cachetools>=5.5", + "chardet>=5.2", + "colorama>=0.4.6", + "filelock>=3.16.1", + "packaging>=24.2", + "platformdirs>=4.3.6", + "pluggy>=1.5", + "pyproject-api>=1.8", + "tomli>=2.1; python_version < \"3.11\"", + "typing-extensions>=4.12.2; python_version < \"3.11\"", + "virtualenv>=20.27.1", +] +files = [ + {file = "tox-4.24.1-py3-none-any.whl", hash = "sha256:57ba7df7d199002c6df8c2db9e6484f3de6ca8f42013c083ea2d4d1e5c6bdc75"}, + {file = "tox-4.24.1.tar.gz", hash = "sha256:083a720adbc6166fff0b7d1df9d154f9d00bfccb9403b8abf6bc0ee435d6a62e"}, +] + +[[package]] +name = "tqdm" +version = "4.67.1" +requires_python = ">=3.7" +summary = "Fast, Extensible Progress Meter" +groups = ["default"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "colorama; platform_system == \"Windows\"", +] +files = [ + {file = "tqdm-4.67.1-py3-none-any.whl", hash = "sha256:26445eca388f82e72884e0d580d5464cd801a3ea01e63e5601bdff9ba6a48de2"}, + {file = "tqdm-4.67.1.tar.gz", hash = "sha256:f8aef9c52c08c13a65f30ea34f4e5aac3fd1a34959879d7e59e63027286627f2"}, +] + +[[package]] +name = "traitlets" +version = "5.14.3" +requires_python = ">=3.8" +summary = "Traitlets Python configuration system" +groups = ["docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "traitlets-5.14.3-py3-none-any.whl", hash = "sha256:b74e89e397b1ed28cc831db7aea759ba6640cb3de13090ca145426688ff1ac4f"}, + {file = "traitlets-5.14.3.tar.gz", hash = "sha256:9ed0579d3502c94b4b3732ac120375cda96f923114522847de4b3bb98b96b6b7"}, +] + +[[package]] +name = "trame" +version = "3.6.5" +summary = "Trame, a framework to build applications in plain Python" +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "trame-client<4,>=3", + "trame-server<4,>=3", + "wslink>=2.1.3", +] +files = [ + {file = "trame-3.6.5-py3-none-any.whl", hash = "sha256:58b5be29287d275dbd2be15b4e453c788361f640253ad153ca99fb3eb28e00f3"}, + {file = "trame-3.6.5.tar.gz", hash = "sha256:fc26a7067f94377e01263facb4cd40b111d799d970b5fc8e2aecb52e60378959"}, +] + +[[package]] +name = "trame-client" +version = "3.2.5" +summary = "Internal client of trame" +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "trame-client-3.2.5.tar.gz", hash = "sha256:6f81c2a78389f1962bec38a318b0de47f241dae7778b25dba75fa3ed4d58bd33"}, + {file = "trame_client-3.2.5-py3-none-any.whl", hash = "sha256:023e062175fef67d45a65ac7a367b0e3468f6746c4f8c7a7aa3fe8e82273c62a"}, +] + +[[package]] +name = "trame-server" +version = "3.1.2" +summary = "Internal server side implementation of trame" +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "more-itertools", + "wslink<3,>=2", +] +files = [ + {file = "trame-server-3.1.2.tar.gz", hash = "sha256:03bdd81e0132fb55de7b493c7ebdc4c21f6b0003960bceb3adca258fc432211f"}, + {file = "trame_server-3.1.2-py3-none-any.whl", hash = "sha256:b43d11edfbca012ac34a724dc751b6ecfaecd7d636eaea4ab0650d2adc9e3771"}, +] + +[[package]] +name = "trame-vtk" +version = "2.8.10" +summary = "VTK widgets for trame" +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "trame-client", +] +files = [ + {file = "trame-vtk-2.8.10.tar.gz", hash = "sha256:4d8e38f7c1d5be8eafc28254bd5bd5dc5d4b336a334b944fc9383c9624184b5e"}, + {file = "trame_vtk-2.8.10-py3-none-any.whl", hash = "sha256:0fe850d1358193c1d73c9af87715d7877210df53edf4e4d468ba396c0845765c"}, +] + +[[package]] +name = "trame-vuetify" +version = "2.7.1" +summary = "Vuetify widgets for trame" +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "trame-client", +] +files = [ + {file = "trame-vuetify-2.7.1.tar.gz", hash = "sha256:48443910a3a53b9fa040e05b261fce9326fe95309b3798d49f0d6aec84cbfdf8"}, + {file = "trame_vuetify-2.7.1-py3-none-any.whl", hash = "sha256:c6bfe3be49ac8b7aa354e4e2c1d92f2c2e9680eea563f46146eef6968a66c2de"}, +] + +[[package]] +name = "types-python-dateutil" +version = "2.9.0.20240906" +requires_python = ">=3.8" +summary = "Typing stubs for python-dateutil" +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "types-python-dateutil-2.9.0.20240906.tar.gz", hash = "sha256:9706c3b68284c25adffc47319ecc7947e5bb86b3773f843c73906fd598bc176e"}, + {file = "types_python_dateutil-2.9.0.20240906-py3-none-any.whl", hash = "sha256:27c8cc2d058ccb14946eebcaaa503088f4f6dbc4fb6093d3d456a49aef2753f6"}, +] + +[[package]] +name = "typing-extensions" +version = "4.12.2" +requires_python = ">=3.8" +summary = "Backported and Experimental Type Hints for Python 3.8+" +groups = ["default", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "typing_extensions-4.12.2-py3-none-any.whl", hash = "sha256:04e5ca0351e0f3f85c6853954072df659d0d13fac324d0072316b67d7794700d"}, + {file = "typing_extensions-4.12.2.tar.gz", hash = "sha256:1a7ead55c7e559dd4dee8856e3a88b41225abfe1ce8df57b7c13915fe121ffb8"}, +] + +[[package]] +name = "tzdata" +version = "2024.1" +requires_python = ">=2" +summary = "Provider of IANA time zone data" +groups = ["default"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "tzdata-2024.1-py2.py3-none-any.whl", hash = "sha256:9068bc196136463f5245e51efda838afa15aaeca9903f49050dfa2679db4d252"}, + {file = "tzdata-2024.1.tar.gz", hash = "sha256:2674120f8d891909751c38abcdfd386ac0a5a1127954fbc332af6b5ceae07efd"}, +] + +[[package]] +name = "uri-template" +version = "1.3.0" +requires_python = ">=3.7" +summary = "RFC 6570 URI Template Processor" +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "uri-template-1.3.0.tar.gz", hash = "sha256:0e00f8eb65e18c7de20d595a14336e9f337ead580c70934141624b6d1ffdacc7"}, + {file = "uri_template-1.3.0-py3-none-any.whl", hash = "sha256:a44a133ea12d44a0c0f06d7d42a52d71282e77e2f937d8abd5655b8d56fc1363"}, +] + +[[package]] +name = "urllib3" +version = "2.2.2" +requires_python = ">=3.8" +summary = "HTTP library with thread-safe connection pooling, file post, and more." +groups = ["docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "urllib3-2.2.2-py3-none-any.whl", hash = "sha256:a448b2f64d686155468037e1ace9f2d2199776e17f0a46610480d311f73e3472"}, + {file = "urllib3-2.2.2.tar.gz", hash = "sha256:dd505485549a7a552833da5e6063639d0d177c04f23bc3864e41e5dc5f612168"}, +] + +[[package]] +name = "virtualenv" +version = "20.29.1" +requires_python = ">=3.8" +summary = "Virtual Python Environment builder" +groups = ["qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "distlib<1,>=0.3.7", + "filelock<4,>=3.12.2", + "importlib-metadata>=6.6; python_version < \"3.8\"", + "platformdirs<5,>=3.9.1", +] +files = [ + {file = "virtualenv-20.29.1-py3-none-any.whl", hash = "sha256:4e4cb403c0b0da39e13b46b1b2476e505cb0046b25f242bee80f62bf990b2779"}, + {file = "virtualenv-20.29.1.tar.gz", hash = "sha256:b8b8970138d32fb606192cb97f6cd4bb644fa486be9308fb9b63f81091b5dc35"}, +] + +[[package]] +name = "vtk" +version = "9.3.1" +summary = "VTK is an open-source toolkit for 3D computer graphics, image processing, and visualization" +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "matplotlib>=2.0.0", +] +files = [ + {file = "vtk-9.3.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:890aee533fc0caca70bd1c8a4026b0d7f877518f237cc976ed4fb509d5f1dd83"}, + {file = "vtk-9.3.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f8edc04e0f8b6719cfc769e575a777267d667f447d1948c62fa97fb756cd75bb"}, + {file = "vtk-9.3.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f728bb61f43fce850d622ced3b3d51b3116f767685ca4e4e0076f624e2d2307d"}, + {file = "vtk-9.3.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:592b303f96b4cf907df7914bbf8c1f374df382c70c1d0b4fa4bd32ac1f4365ce"}, +] + +[[package]] +name = "wcwidth" +version = "0.2.13" +summary = "Measures the displayed width of unicode strings in a terminal" +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "backports-functools-lru-cache>=1.2.1; python_version < \"3.2\"", +] +files = [ + {file = "wcwidth-0.2.13-py2.py3-none-any.whl", hash = "sha256:3da69048e4540d84af32131829ff948f1e022c1c6bdb8d6102117aac784f6859"}, + {file = "wcwidth-0.2.13.tar.gz", hash = "sha256:72ea0c06399eb286d978fdedb6923a9eb47e1c486ce63e9b4e64fc18303972b5"}, +] + +[[package]] +name = "webcolors" +version = "24.8.0" +requires_python = ">=3.8" +summary = "A library for working with the color formats defined by HTML and CSS." +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "webcolors-24.8.0-py3-none-any.whl", hash = "sha256:fc4c3b59358ada164552084a8ebee637c221e4059267d0f8325b3b560f6c7f0a"}, + {file = "webcolors-24.8.0.tar.gz", hash = "sha256:08b07af286a01bcd30d583a7acadf629583d1f79bfef27dd2c2c5c263817277d"}, +] + +[[package]] +name = "webencodings" +version = "0.5.1" +summary = "Character encoding aliases for legacy web content" +groups = ["docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "webencodings-0.5.1-py2.py3-none-any.whl", hash = "sha256:a0af1213f3c2226497a97e2b3aa01a7e4bee4f403f95be16fc9acd2947514a78"}, + {file = "webencodings-0.5.1.tar.gz", hash = "sha256:b36a1c245f2d304965eb4e0a82848379241dc04b865afcc4aab16748587e1923"}, +] + +[[package]] +name = "websocket-client" +version = "1.8.0" +requires_python = ">=3.8" +summary = "WebSocket client for Python with low level API options" +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "websocket_client-1.8.0-py3-none-any.whl", hash = "sha256:17b44cc997f5c498e809b22cdf2d9c7a9e71c02c8cc2b6c56e7c2d1239bfa526"}, + {file = "websocket_client-1.8.0.tar.gz", hash = "sha256:3239df9f44da632f96012472805d40a23281a991027ce11d2f45a6f24ac4c3da"}, +] + +[[package]] +name = "widgetsnbextension" +version = "4.0.13" +requires_python = ">=3.7" +summary = "Jupyter interactive widgets for Jupyter Notebook" +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "widgetsnbextension-4.0.13-py3-none-any.whl", hash = "sha256:74b2692e8500525cc38c2b877236ba51d34541e6385eeed5aec15a70f88a6c71"}, + {file = "widgetsnbextension-4.0.13.tar.gz", hash = "sha256:ffcb67bc9febd10234a362795f643927f4e0c05d9342c727b65d2384f8feacb6"}, +] + +[[package]] +name = "wslink" +version = "2.1.3" +summary = "Python/JavaScript library for communicating over WebSocket" +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "aiohttp<4", + "msgpack<2,>=1", +] +files = [ + {file = "wslink-2.1.3-py3-none-any.whl", hash = "sha256:a4a3689a30dd108255560e2f56903003355f4e0f3f6e5f12033a6de108bba18a"}, + {file = "wslink-2.1.3.tar.gz", hash = "sha256:528d008f1a6110bc8141c32588e43b16ff438cedb80c5bb85e9ef92ae753c98e"}, +] + +[[package]] +name = "yarl" +version = "1.18.3" +requires_python = ">=3.9" +summary = "Yet another URL library" +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "idna>=2.0", + "multidict>=4.0", + "propcache>=0.2.0", +] +files = [ + {file = "yarl-1.18.3-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3236da9272872443f81fedc389bace88408f64f89f75d1bdb2256069a8730ccc"}, + {file = "yarl-1.18.3-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:75674776d96d7b851b6498f17824ba17849d790a44d282929c42dbb77d4f17ae"}, + {file = "yarl-1.18.3-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:00e5a1fea0fd4f5bfa7440a47eff01d9822a65b4488f7cff83155a0f31a2ecba"}, + {file = "yarl-1.18.3-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:77a6e85b90a7641d2e07184df5557132a337f136250caafc9ccaa4a2a998ca2c"}, + {file = "yarl-1.18.3-py3-none-any.whl", hash = "sha256:b57f4f58099328dfb26c6a771d09fb20dbbae81d20cfb66141251ea063bd101b"}, + {file = "yarl-1.18.3.tar.gz", hash = "sha256:ac1801c45cbf77b6c99242eeff4fffb5e4e73a800b5c4ad4fc0be5def634d2e1"}, +] + +[[package]] +name = "zipp" +version = "3.20.1" +requires_python = ">=3.8" +summary = "Backport of pathlib-compatible object wrapper for zip files" +groups = ["default", "docs", "pyvista", "qa"] +marker = "python_version < \"3.10\" and python_version >= \"3.9\"" +files = [ + {file = "zipp-3.20.1-py3-none-any.whl", hash = "sha256:9960cd8967c8f85a56f920d5d507274e74f9ff813a0ab8889a5b5be2daf44064"}, + {file = "zipp-3.20.1.tar.gz", hash = "sha256:c22b14cc4763c5a5b04134207736c107db42e9d3ef2d9779d465f5f1bcba572b"}, +] diff --git a/pdm-py39+win.lock b/pdm-py39+win.lock new file mode 100644 index 0000000..4ed600a --- /dev/null +++ b/pdm-py39+win.lock @@ -0,0 +1,2980 @@ +# This file is @generated by PDM. +# It is not intended for manual editing. + +[metadata] +groups = ["default", "docs", "openpyxl", "pyvista", "qa"] +strategy = ["inherit_metadata"] +lock_version = "4.5.0" +content_hash = "sha256:22cd5aee3b297d0bb4e82486997918f7af7cd34c35252bce0aa0be1ee01bc0c1" + +[[metadata.targets]] +requires_python = ">=3.9,<3.13" +platform = "windows_amd64" + +[[package]] +name = "aiohappyeyeballs" +version = "2.4.0" +requires_python = ">=3.8" +summary = "Happy Eyeballs for asyncio" +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "aiohappyeyeballs-2.4.0-py3-none-any.whl", hash = "sha256:7ce92076e249169a13c2f49320d1967425eaf1f407522d707d59cac7628d62bd"}, + {file = "aiohappyeyeballs-2.4.0.tar.gz", hash = "sha256:55a1714f084e63d49639800f95716da97a1f173d46a16dfcfda0016abb93b6b2"}, +] + +[[package]] +name = "aiohttp" +version = "3.11.12" +requires_python = ">=3.9" +summary = "Async http client/server framework (asyncio)" +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "aiohappyeyeballs>=2.3.0", + "aiosignal>=1.1.2", + "async-timeout<6.0,>=4.0; python_version < \"3.11\"", + "attrs>=17.3.0", + "frozenlist>=1.1.1", + "multidict<7.0,>=4.5", + "propcache>=0.2.0", + "yarl<2.0,>=1.17.0", +] +files = [ + {file = "aiohttp-3.11.12-cp310-cp310-win_amd64.whl", hash = "sha256:7fe3d65279bfbee8de0fb4f8c17fc4e893eed2dba21b2f680e930cc2b09075c5"}, + {file = "aiohttp-3.11.12-cp311-cp311-win_amd64.whl", hash = "sha256:246067ba0cf5560cf42e775069c5d80a8989d14a7ded21af529a4e10e3e0f0e6"}, + {file = "aiohttp-3.11.12-cp312-cp312-win_amd64.whl", hash = "sha256:54775858c7f2f214476773ce785a19ee81d1294a6bedc5cc17225355aab74802"}, + {file = "aiohttp-3.11.12-cp39-cp39-win_amd64.whl", hash = "sha256:74bd573dde27e58c760d9ca8615c41a57e719bff315c9adb6f2a4281a28e8798"}, + {file = "aiohttp-3.11.12.tar.gz", hash = "sha256:7603ca26d75b1b86160ce1bbe2787a0b706e592af5b2504e12caa88a217767b0"}, +] + +[[package]] +name = "aiosignal" +version = "1.3.1" +requires_python = ">=3.7" +summary = "aiosignal: a list of registered asynchronous callbacks" +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "frozenlist>=1.1.0", +] +files = [ + {file = "aiosignal-1.3.1-py3-none-any.whl", hash = "sha256:f8376fb07dd1e86a584e4fcdec80b36b7f81aac666ebc724e2c090300dd83b17"}, + {file = "aiosignal-1.3.1.tar.gz", hash = "sha256:54cd96e15e1649b75d6c87526a6ff0b6c1b0dd3459f43d9ca11d48c339b68cfc"}, +] + +[[package]] +name = "alabaster" +version = "0.7.16" +requires_python = ">=3.9" +summary = "A light, configurable Sphinx theme" +groups = ["docs"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "alabaster-0.7.16-py3-none-any.whl", hash = "sha256:b46733c07dce03ae4e150330b975c75737fa60f0a7c591b6c8bf4928a28e2c92"}, + {file = "alabaster-0.7.16.tar.gz", hash = "sha256:75a8b99c28a5dad50dd7f8ccdd447a121ddb3892da9e53d1ca5cca3106d58d65"}, +] + +[[package]] +name = "annotated-types" +version = "0.7.0" +requires_python = ">=3.8" +summary = "Reusable constraint types to use with typing.Annotated" +groups = ["default"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "typing-extensions>=4.0.0; python_version < \"3.9\"", +] +files = [ + {file = "annotated_types-0.7.0-py3-none-any.whl", hash = "sha256:1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53"}, + {file = "annotated_types-0.7.0.tar.gz", hash = "sha256:aff07c09a53a08bc8cfccb9c85b05f1aa9a2a6f23728d790723543408344ce89"}, +] + +[[package]] +name = "anyio" +version = "4.4.0" +requires_python = ">=3.8" +summary = "High level compatibility layer for multiple asynchronous event loop implementations" +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "exceptiongroup>=1.0.2; python_version < \"3.11\"", + "idna>=2.8", + "sniffio>=1.1", + "typing-extensions>=4.1; python_version < \"3.11\"", +] +files = [ + {file = "anyio-4.4.0-py3-none-any.whl", hash = "sha256:c1b2d8f46a8a812513012e1107cb0e68c17159a7a594208005a57dc776e1bdc7"}, + {file = "anyio-4.4.0.tar.gz", hash = "sha256:5aadc6a1bbb7cdb0bede386cac5e2940f5e2ff3aa20277e991cf028e0585ce94"}, +] + +[[package]] +name = "argon2-cffi" +version = "23.1.0" +requires_python = ">=3.7" +summary = "Argon2 for Python" +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "argon2-cffi-bindings", + "typing-extensions; python_version < \"3.8\"", +] +files = [ + {file = "argon2_cffi-23.1.0-py3-none-any.whl", hash = "sha256:c670642b78ba29641818ab2e68bd4e6a78ba53b7eff7b4c3815ae16abf91c7ea"}, + {file = "argon2_cffi-23.1.0.tar.gz", hash = "sha256:879c3e79a2729ce768ebb7d36d4609e3a78a4ca2ec3a9f12286ca057e3d0db08"}, +] + +[[package]] +name = "argon2-cffi-bindings" +version = "21.2.0" +requires_python = ">=3.6" +summary = "Low-level CFFI bindings for Argon2" +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "cffi>=1.0.1", +] +files = [ + {file = "argon2-cffi-bindings-21.2.0.tar.gz", hash = "sha256:bb89ceffa6c791807d1305ceb77dbfacc5aa499891d2c55661c6459651fc39e3"}, + {file = "argon2_cffi_bindings-21.2.0-cp36-abi3-win_amd64.whl", hash = "sha256:b2ef1c30440dbbcba7a5dc3e319408b59676e2e039e2ae11a8775ecf482b192f"}, +] + +[[package]] +name = "arrow" +version = "1.3.0" +requires_python = ">=3.8" +summary = "Better dates & times for Python" +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "python-dateutil>=2.7.0", + "types-python-dateutil>=2.8.10", +] +files = [ + {file = "arrow-1.3.0-py3-none-any.whl", hash = "sha256:c728b120ebc00eb84e01882a6f5e7927a53960aa990ce7dd2b10f39005a67f80"}, + {file = "arrow-1.3.0.tar.gz", hash = "sha256:d4540617648cb5f895730f1ad8c82a65f2dad0166f57b75f3ca54759c4d67a85"}, +] + +[[package]] +name = "asttokens" +version = "2.4.1" +summary = "Annotate AST trees with source code positions" +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "six>=1.12.0", + "typing; python_version < \"3.5\"", +] +files = [ + {file = "asttokens-2.4.1-py2.py3-none-any.whl", hash = "sha256:051ed49c3dcae8913ea7cd08e46a606dba30b79993209636c4875bc1d637bc24"}, + {file = "asttokens-2.4.1.tar.gz", hash = "sha256:b03869718ba9a6eb027e134bfdf69f38a236d681c83c160d510768af11254ba0"}, +] + +[[package]] +name = "async-lru" +version = "2.0.4" +requires_python = ">=3.8" +summary = "Simple LRU cache for asyncio" +groups = ["qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "typing-extensions>=4.0.0; python_version < \"3.11\"", +] +files = [ + {file = "async-lru-2.0.4.tar.gz", hash = "sha256:b8a59a5df60805ff63220b2a0c5b5393da5521b113cd5465a44eb037d81a5627"}, + {file = "async_lru-2.0.4-py3-none-any.whl", hash = "sha256:ff02944ce3c288c5be660c42dbcca0742b32c3b279d6dceda655190240b99224"}, +] + +[[package]] +name = "async-timeout" +version = "4.0.3" +requires_python = ">=3.7" +summary = "Timeout context manager for asyncio programs" +groups = ["pyvista"] +marker = "python_version < \"3.11\" and python_version >= \"3.9\"" +dependencies = [ + "typing-extensions>=3.6.5; python_version < \"3.8\"", +] +files = [ + {file = "async-timeout-4.0.3.tar.gz", hash = "sha256:4640d96be84d82d02ed59ea2b7105a0f7b33abe8703703cd0ab0bf87c427522f"}, + {file = "async_timeout-4.0.3-py3-none-any.whl", hash = "sha256:7405140ff1230c310e51dc27b3145b9092d659ce68ff733fb0cefe3ee42be028"}, +] + +[[package]] +name = "attrs" +version = "24.2.0" +requires_python = ">=3.7" +summary = "Classes Without Boilerplate" +groups = ["docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "importlib-metadata; python_version < \"3.8\"", +] +files = [ + {file = "attrs-24.2.0-py3-none-any.whl", hash = "sha256:81921eb96de3191c8258c199618104dd27ac608d9366f5e35d011eae1867ede2"}, + {file = "attrs-24.2.0.tar.gz", hash = "sha256:5cfb1b9148b5b086569baec03f20d7b6bf3bcacc9a42bebf87ffaaca362f6346"}, +] + +[[package]] +name = "babel" +version = "2.16.0" +requires_python = ">=3.8" +summary = "Internationalization utilities" +groups = ["docs", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "pytz>=2015.7; python_version < \"3.9\"", +] +files = [ + {file = "babel-2.16.0-py3-none-any.whl", hash = "sha256:368b5b98b37c06b7daf6696391c3240c938b37767d4584413e8438c5c435fa8b"}, + {file = "babel-2.16.0.tar.gz", hash = "sha256:d1f3554ca26605fe173f3de0c65f750f5a42f924499bf134de6423582298e316"}, +] + +[[package]] +name = "beautifulsoup4" +version = "4.12.3" +requires_python = ">=3.6.0" +summary = "Screen-scraping library" +groups = ["docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "soupsieve>1.2", +] +files = [ + {file = "beautifulsoup4-4.12.3-py3-none-any.whl", hash = "sha256:b80878c9f40111313e55da8ba20bdba06d8fa3969fc68304167741bbf9e082ed"}, + {file = "beautifulsoup4-4.12.3.tar.gz", hash = "sha256:74e3d1928edc070d21748185c46e3fb33490f22f52a3addee9aee0f4f7781051"}, +] + +[[package]] +name = "bleach" +version = "6.2.0" +requires_python = ">=3.9" +summary = "An easy safelist-based HTML-sanitizing tool." +groups = ["docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "webencodings", +] +files = [ + {file = "bleach-6.2.0-py3-none-any.whl", hash = "sha256:117d9c6097a7c3d22fd578fcd8d35ff1e125df6736f554da4e432fdd63f31e5e"}, + {file = "bleach-6.2.0.tar.gz", hash = "sha256:123e894118b8a599fd80d3ec1a6d4cc7ce4e5882b1317a7e1ba69b56e95f991f"}, +] + +[[package]] +name = "bleach" +version = "6.2.0" +extras = ["css"] +requires_python = ">=3.9" +summary = "An easy safelist-based HTML-sanitizing tool." +groups = ["docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "bleach==6.2.0", + "tinycss2<1.5,>=1.1.0", +] +files = [ + {file = "bleach-6.2.0-py3-none-any.whl", hash = "sha256:117d9c6097a7c3d22fd578fcd8d35ff1e125df6736f554da4e432fdd63f31e5e"}, + {file = "bleach-6.2.0.tar.gz", hash = "sha256:123e894118b8a599fd80d3ec1a6d4cc7ce4e5882b1317a7e1ba69b56e95f991f"}, +] + +[[package]] +name = "cachetools" +version = "5.5.0" +requires_python = ">=3.7" +summary = "Extensible memoizing collections and decorators" +groups = ["qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "cachetools-5.5.0-py3-none-any.whl", hash = "sha256:02134e8439cdc2ffb62023ce1debca2944c3f289d66bb17ead3ab3dede74b292"}, + {file = "cachetools-5.5.0.tar.gz", hash = "sha256:2cc24fb4cbe39633fb7badd9db9ca6295d766d9c2995f245725a46715d050f2a"}, +] + +[[package]] +name = "certifi" +version = "2024.8.30" +requires_python = ">=3.6" +summary = "Python package for providing Mozilla's CA Bundle." +groups = ["docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "certifi-2024.8.30-py3-none-any.whl", hash = "sha256:922820b53db7a7257ffbda3f597266d435245903d80737e34f8a45ff3e3230d8"}, + {file = "certifi-2024.8.30.tar.gz", hash = "sha256:bec941d2aa8195e248a60b31ff9f0558284cf01a52591ceda73ea9afffd69fd9"}, +] + +[[package]] +name = "cffi" +version = "1.17.1" +requires_python = ">=3.8" +summary = "Foreign Function Interface for Python calling C code." +groups = ["docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "pycparser", +] +files = [ + {file = "cffi-1.17.1-cp310-cp310-win_amd64.whl", hash = "sha256:0f048dcf80db46f0098ccac01132761580d28e28bc0f78ae0d58048063317e15"}, + {file = "cffi-1.17.1-cp311-cp311-win_amd64.whl", hash = "sha256:caaf0640ef5f5517f49bc275eca1406b0ffa6aa184892812030f04c2abf589a0"}, + {file = "cffi-1.17.1-cp312-cp312-win_amd64.whl", hash = "sha256:51392eae71afec0d0c8fb1a53b204dbb3bcabcb3c9b807eedf3e1e6ccf2de903"}, + {file = "cffi-1.17.1-cp39-cp39-win_amd64.whl", hash = "sha256:d016c76bdd850f3c626af19b0542c9677ba156e4ee4fccfdd7848803533ef662"}, + {file = "cffi-1.17.1.tar.gz", hash = "sha256:1c39c6016c32bc48dd54561950ebd6836e1670f2ae46128f67cf49e789c52824"}, +] + +[[package]] +name = "cfgv" +version = "3.4.0" +requires_python = ">=3.8" +summary = "Validate configuration and produce human readable error messages." +groups = ["qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "cfgv-3.4.0-py2.py3-none-any.whl", hash = "sha256:b7265b1f29fd3316bfcd2b330d63d024f2bfd8bcb8b0272f8e19a504856c48f9"}, + {file = "cfgv-3.4.0.tar.gz", hash = "sha256:e52591d4c5f5dead8e0f673fb16db7949d2cfb3f7da4582893288f0ded8fe560"}, +] + +[[package]] +name = "chardet" +version = "5.2.0" +requires_python = ">=3.7" +summary = "Universal encoding detector for Python 3" +groups = ["qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "chardet-5.2.0-py3-none-any.whl", hash = "sha256:e1cf59446890a00105fe7b7912492ea04b6e6f06d4b742b2c788469e34c82970"}, + {file = "chardet-5.2.0.tar.gz", hash = "sha256:1b3b6ff479a8c414bc3fa2c0852995695c4a026dcd6d0633b2dd092ca39c1cf7"}, +] + +[[package]] +name = "charset-normalizer" +version = "3.3.2" +requires_python = ">=3.7.0" +summary = "The Real First Universal Charset Detector. Open, modern and actively maintained alternative to Chardet." +groups = ["docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "charset-normalizer-3.3.2.tar.gz", hash = "sha256:f30c3cb33b24454a82faecaf01b19c18562b1e89558fb6c56de4d9118a032fd5"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-win_amd64.whl", hash = "sha256:10955842570876604d404661fbccbc9c7e684caf432c09c715ec38fbae45ae09"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-win_amd64.whl", hash = "sha256:663946639d296df6a2bb2aa51b60a2454ca1cb29835324c640dafb5ff2131a77"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-win_amd64.whl", hash = "sha256:96b02a3dc4381e5494fad39be677abcb5e6634bf7b4fa83a6dd3112607547001"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-win_amd64.whl", hash = "sha256:b01b88d45a6fcb69667cd6d2f7a9aeb4bf53760d7fc536bf679ec94fe9f3ff3d"}, + {file = "charset_normalizer-3.3.2-py3-none-any.whl", hash = "sha256:3e4d1f6587322d2788836a99c69062fbb091331ec940e02d12d179c1d53e25fc"}, +] + +[[package]] +name = "cmocean" +version = "4.0.3" +requires_python = ">=3.8" +summary = "Colormaps for Oceanography" +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "matplotlib", + "numpy", + "packaging", +] +files = [ + {file = "cmocean-4.0.3-py3-none-any.whl", hash = "sha256:f2fc1d5e349db122ee0c9eac80bba969aa92dd2806548fce58dc8bef962f309e"}, + {file = "cmocean-4.0.3.tar.gz", hash = "sha256:37868399fb5f41b4eac596e69803f9bfaea49946514dfb2e7f48886854250d7c"}, +] + +[[package]] +name = "colorama" +version = "0.4.6" +requires_python = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,!=3.6.*,>=2.7" +summary = "Cross-platform colored terminal text." +groups = ["default", "docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6"}, + {file = "colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44"}, +] + +[[package]] +name = "colorcet" +version = "3.1.0" +requires_python = ">=3.7" +summary = "Collection of perceptually uniform colormaps" +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "colorcet-3.1.0-py3-none-any.whl", hash = "sha256:2a7d59cc8d0f7938eeedd08aad3152b5319b4ba3bcb7a612398cc17a384cb296"}, + {file = "colorcet-3.1.0.tar.gz", hash = "sha256:2921b3cd81a2288aaf2d63dbc0ce3c26dcd882e8c389cc505d6886bf7aa9a4eb"}, +] + +[[package]] +name = "comm" +version = "0.2.2" +requires_python = ">=3.8" +summary = "Jupyter Python Comm implementation, for usage in ipykernel, xeus-python etc." +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "traitlets>=4", +] +files = [ + {file = "comm-0.2.2-py3-none-any.whl", hash = "sha256:e6fb86cb70ff661ee8c9c14e7d36d6de3b4066f1441be4063df9c5009f0a64d3"}, + {file = "comm-0.2.2.tar.gz", hash = "sha256:3fd7a84065306e07bea1773df6eb8282de51ba82f77c72f9c85716ab11fe980e"}, +] + +[[package]] +name = "contourpy" +version = "1.3.0" +requires_python = ">=3.9" +summary = "Python library for calculating contours of 2D quadrilateral grids" +groups = ["default", "pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "numpy>=1.23", +] +files = [ + {file = "contourpy-1.3.0-cp310-cp310-win_amd64.whl", hash = "sha256:87ddffef1dbe5e669b5c2440b643d3fdd8622a348fe1983fad7a0f0ccb1cd67b"}, + {file = "contourpy-1.3.0-cp311-cp311-win_amd64.whl", hash = "sha256:6cb6cc968059db9c62cb35fbf70248f40994dfcd7aa10444bbf8b3faeb7c2d67"}, + {file = "contourpy-1.3.0-cp312-cp312-win_amd64.whl", hash = "sha256:b11b39aea6be6764f84360fce6c82211a9db32a7c7de8fa6dd5397cf1d079c3b"}, + {file = "contourpy-1.3.0-cp39-cp39-win_amd64.whl", hash = "sha256:14e262f67bd7e6eb6880bc564dcda30b15e351a594657e55b7eec94b6ef72843"}, + {file = "contourpy-1.3.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:1ec4dc6bf570f5b22ed0d7efba0dfa9c5b9e0431aeea7581aa217542d9e809a4"}, + {file = "contourpy-1.3.0-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:c6ec93afeb848a0845a18989da3beca3eec2c0f852322efe21af1931147d12cb"}, + {file = "contourpy-1.3.0.tar.gz", hash = "sha256:7ffa0db17717a8ffb127efd0c95a4362d996b892c2904db72428d5b52e1938a4"}, +] + +[[package]] +name = "coverage" +version = "7.6.1" +requires_python = ">=3.8" +summary = "Code coverage measurement for Python" +groups = ["qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "coverage-7.6.1-cp310-cp310-win_amd64.whl", hash = "sha256:3115a95daa9bdba70aea750db7b96b37259a81a709223c8448fa97727d546fe0"}, + {file = "coverage-7.6.1-cp311-cp311-win_amd64.whl", hash = "sha256:8ae539519c4c040c5ffd0632784e21b2f03fc1340752af711f33e5be83a9d6c6"}, + {file = "coverage-7.6.1-cp312-cp312-win_amd64.whl", hash = "sha256:b5d7b556859dd85f3a541db6a4e0167b86e7273e1cdc973e5b175166bb634fdb"}, + {file = "coverage-7.6.1-cp39-cp39-win_amd64.whl", hash = "sha256:06a737c882bd26d0d6ee7269b20b12f14a8704807a01056c80bb881a4b2ce6ca"}, + {file = "coverage-7.6.1-pp38.pp39.pp310-none-any.whl", hash = "sha256:e9a6e0eb86070e8ccaedfbd9d38fec54864f3125ab95419970575b42af7541df"}, + {file = "coverage-7.6.1.tar.gz", hash = "sha256:953510dfb7b12ab69d20135a0662397f077c59b1e6379a768e97c59d852ee51d"}, +] + +[[package]] +name = "coverage" +version = "7.6.1" +extras = ["toml"] +requires_python = ">=3.8" +summary = "Code coverage measurement for Python" +groups = ["qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "coverage==7.6.1", + "tomli; python_full_version <= \"3.11.0a6\"", +] +files = [ + {file = "coverage-7.6.1-cp310-cp310-win_amd64.whl", hash = "sha256:3115a95daa9bdba70aea750db7b96b37259a81a709223c8448fa97727d546fe0"}, + {file = "coverage-7.6.1-cp311-cp311-win_amd64.whl", hash = "sha256:8ae539519c4c040c5ffd0632784e21b2f03fc1340752af711f33e5be83a9d6c6"}, + {file = "coverage-7.6.1-cp312-cp312-win_amd64.whl", hash = "sha256:b5d7b556859dd85f3a541db6a4e0167b86e7273e1cdc973e5b175166bb634fdb"}, + {file = "coverage-7.6.1-cp39-cp39-win_amd64.whl", hash = "sha256:06a737c882bd26d0d6ee7269b20b12f14a8704807a01056c80bb881a4b2ce6ca"}, + {file = "coverage-7.6.1-pp38.pp39.pp310-none-any.whl", hash = "sha256:e9a6e0eb86070e8ccaedfbd9d38fec54864f3125ab95419970575b42af7541df"}, + {file = "coverage-7.6.1.tar.gz", hash = "sha256:953510dfb7b12ab69d20135a0662397f077c59b1e6379a768e97c59d852ee51d"}, +] + +[[package]] +name = "cycler" +version = "0.12.1" +requires_python = ">=3.8" +summary = "Composable style cycles" +groups = ["default", "pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "cycler-0.12.1-py3-none-any.whl", hash = "sha256:85cef7cff222d8644161529808465972e51340599459b8ac3ccbac5a854e0d30"}, + {file = "cycler-0.12.1.tar.gz", hash = "sha256:88bb128f02ba341da8ef447245a9e138fae777f6a23943da4540077d3601eb1c"}, +] + +[[package]] +name = "debugpy" +version = "1.8.5" +requires_python = ">=3.8" +summary = "An implementation of the Debug Adapter Protocol for Python" +groups = ["qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "debugpy-1.8.5-cp310-cp310-win_amd64.whl", hash = "sha256:b78c1250441ce893cb5035dd6f5fc12db968cc07f91cc06996b2087f7cefdd8e"}, + {file = "debugpy-1.8.5-cp311-cp311-win_amd64.whl", hash = "sha256:345d6a0206e81eb68b1493ce2fbffd57c3088e2ce4b46592077a943d2b968ca3"}, + {file = "debugpy-1.8.5-cp312-cp312-win_amd64.whl", hash = "sha256:28ced650c974aaf179231668a293ecd5c63c0a671ae6d56b8795ecc5d2f48d3c"}, + {file = "debugpy-1.8.5-cp39-cp39-win_amd64.whl", hash = "sha256:7b0fe36ed9d26cb6836b0a51453653f8f2e347ba7348f2bbfe76bfeb670bfb1c"}, + {file = "debugpy-1.8.5-py2.py3-none-any.whl", hash = "sha256:55919dce65b471eff25901acf82d328bbd5b833526b6c1364bd5133754777a44"}, + {file = "debugpy-1.8.5.zip", hash = "sha256:b2112cfeb34b4507399d298fe7023a16656fc553ed5246536060ca7bd0e668d0"}, +] + +[[package]] +name = "decorator" +version = "5.1.1" +requires_python = ">=3.5" +summary = "Decorators for Humans" +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "decorator-5.1.1-py3-none-any.whl", hash = "sha256:b8c3f85900b9dc423225913c5aace94729fe1fa9763b38939a95226f02d37186"}, + {file = "decorator-5.1.1.tar.gz", hash = "sha256:637996211036b6385ef91435e4fae22989472f9d571faba8927ba8253acbc330"}, +] + +[[package]] +name = "defusedxml" +version = "0.7.1" +requires_python = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*" +summary = "XML bomb protection for Python stdlib modules" +groups = ["docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "defusedxml-0.7.1-py2.py3-none-any.whl", hash = "sha256:a352e7e428770286cc899e2542b6cdaedb2b4953ff269a210103ec58f6198a61"}, + {file = "defusedxml-0.7.1.tar.gz", hash = "sha256:1bb3032db185915b62d7c6209c5a8792be6a32ab2fedacc84e01b52c51aa3e69"}, +] + +[[package]] +name = "distlib" +version = "0.3.8" +summary = "Distribution utilities" +groups = ["qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "distlib-0.3.8-py2.py3-none-any.whl", hash = "sha256:034db59a0b96f8ca18035f36290806a9a6e6bd9d1ff91e45a7f172eb17e51784"}, + {file = "distlib-0.3.8.tar.gz", hash = "sha256:1530ea13e350031b6312d8580ddb6b27a104275a31106523b8f123787f494f64"}, +] + +[[package]] +name = "docutils" +version = "0.20.1" +requires_python = ">=3.7" +summary = "Docutils -- Python Documentation Utilities" +groups = ["docs"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "docutils-0.20.1-py3-none-any.whl", hash = "sha256:96f387a2c5562db4476f09f13bbab2192e764cac08ebbf3a34a95d9b1e4a59d6"}, + {file = "docutils-0.20.1.tar.gz", hash = "sha256:f08a4e276c3a1583a86dce3e34aba3fe04d02bba2dd51ed16106244e8a923e3b"}, +] + +[[package]] +name = "et-xmlfile" +version = "1.1.0" +requires_python = ">=3.6" +summary = "An implementation of lxml.xmlfile for the standard library" +groups = ["openpyxl"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "et_xmlfile-1.1.0-py3-none-any.whl", hash = "sha256:a2ba85d1d6a74ef63837eed693bcb89c3f752169b0e3e7ae5b16ca5e1b3deada"}, + {file = "et_xmlfile-1.1.0.tar.gz", hash = "sha256:8eb9e2bc2f8c97e37a2dc85a09ecdcdec9d8a396530a6d5a33b30b9a92da0c5c"}, +] + +[[package]] +name = "exceptiongroup" +version = "1.2.2" +requires_python = ">=3.7" +summary = "Backport of PEP 654 (exception groups)" +groups = ["pyvista", "qa"] +marker = "python_version < \"3.11\" and python_version >= \"3.9\"" +files = [ + {file = "exceptiongroup-1.2.2-py3-none-any.whl", hash = "sha256:3111b9d131c238bec2f8f516e123e14ba243563fb135d3fe885990585aa7795b"}, + {file = "exceptiongroup-1.2.2.tar.gz", hash = "sha256:47c2edf7c6738fafb49fd34290706d1a1a2f4d1c6df275526b62cbb4aa5393cc"}, +] + +[[package]] +name = "executing" +version = "2.1.0" +requires_python = ">=3.8" +summary = "Get the currently executing AST node of a frame, and other information" +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "executing-2.1.0-py2.py3-none-any.whl", hash = "sha256:8d63781349375b5ebccc3142f4b30350c0cd9c79f921cde38be2be4637e98eaf"}, + {file = "executing-2.1.0.tar.gz", hash = "sha256:8ea27ddd260da8150fa5a708269c4a10e76161e2496ec3e587da9e3c0fe4b9ab"}, +] + +[[package]] +name = "fastjsonschema" +version = "2.20.0" +summary = "Fastest Python implementation of JSON schema" +groups = ["docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "fastjsonschema-2.20.0-py3-none-any.whl", hash = "sha256:5875f0b0fa7a0043a91e93a9b8f793bcbbba9691e7fd83dca95c28ba26d21f0a"}, + {file = "fastjsonschema-2.20.0.tar.gz", hash = "sha256:3d48fc5300ee96f5d116f10fe6f28d938e6008f59a6a025c2649475b87f76a23"}, +] + +[[package]] +name = "filelock" +version = "3.17.0" +requires_python = ">=3.9" +summary = "A platform independent file lock." +groups = ["qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "filelock-3.17.0-py3-none-any.whl", hash = "sha256:533dc2f7ba78dc2f0f531fc6c4940addf7b70a481e269a5a3b93be94ffbe8338"}, + {file = "filelock-3.17.0.tar.gz", hash = "sha256:ee4e77401ef576ebb38cd7f13b9b28893194acc20a8e68e18730ba9c0e54660e"}, +] + +[[package]] +name = "fonttools" +version = "4.53.1" +requires_python = ">=3.8" +summary = "Tools to manipulate font files" +groups = ["default", "pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "fonttools-4.53.1-cp310-cp310-win_amd64.whl", hash = "sha256:8959a59de5af6d2bec27489e98ef25a397cfa1774b375d5787509c06659b3671"}, + {file = "fonttools-4.53.1-cp311-cp311-win_amd64.whl", hash = "sha256:d4d0096cb1ac7a77b3b41cd78c9b6bc4a400550e21dc7a92f2b5ab53ed74eb02"}, + {file = "fonttools-4.53.1-cp312-cp312-win_amd64.whl", hash = "sha256:6ed170b5e17da0264b9f6fae86073be3db15fa1bd74061c8331022bca6d09bab"}, + {file = "fonttools-4.53.1-cp39-cp39-win_amd64.whl", hash = "sha256:e5b708073ea3d684235648786f5f6153a48dc8762cdfe5563c57e80787c29fbb"}, + {file = "fonttools-4.53.1-py3-none-any.whl", hash = "sha256:f1f8758a2ad110bd6432203a344269f445a2907dc24ef6bccfd0ac4e14e0d71d"}, + {file = "fonttools-4.53.1.tar.gz", hash = "sha256:e128778a8e9bc11159ce5447f76766cefbd876f44bd79aff030287254e4752c4"}, +] + +[[package]] +name = "fqdn" +version = "1.5.1" +requires_python = ">=2.7, !=3.0, !=3.1, !=3.2, !=3.3, !=3.4, <4" +summary = "Validates fully-qualified domain names against RFC 1123, so that they are acceptable to modern bowsers" +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "cached-property>=1.3.0; python_version < \"3.8\"", +] +files = [ + {file = "fqdn-1.5.1-py3-none-any.whl", hash = "sha256:3a179af3761e4df6eb2e026ff9e1a3033d3587bf980a0b1b2e1e5d08d7358014"}, + {file = "fqdn-1.5.1.tar.gz", hash = "sha256:105ed3677e767fb5ca086a0c1f4bb66ebc3c100be518f0e0d755d9eae164d89f"}, +] + +[[package]] +name = "frozenlist" +version = "1.4.1" +requires_python = ">=3.8" +summary = "A list-like structure which implements collections.abc.MutableSequence" +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "frozenlist-1.4.1-cp310-cp310-win_amd64.whl", hash = "sha256:f56e2333dda1fe0f909e7cc59f021eba0d2307bc6f012a1ccf2beca6ba362439"}, + {file = "frozenlist-1.4.1-cp311-cp311-win_amd64.whl", hash = "sha256:fb3c2db03683b5767dedb5769b8a40ebb47d6f7f45b1b3e3b4b51ec8ad9d9825"}, + {file = "frozenlist-1.4.1-cp312-cp312-win_amd64.whl", hash = "sha256:64536573d0a2cb6e625cf309984e2d873979709f2cf22839bf2d61790b448ad5"}, + {file = "frozenlist-1.4.1-cp39-cp39-win_amd64.whl", hash = "sha256:e6a20a581f9ce92d389a8c7d7c3dd47c81fd5d6e655c8dddf341e14aa48659d0"}, + {file = "frozenlist-1.4.1-py3-none-any.whl", hash = "sha256:04ced3e6a46b4cfffe20f9ae482818e34eba9b5fb0ce4056e4cc9b6e212d09b7"}, + {file = "frozenlist-1.4.1.tar.gz", hash = "sha256:c037a86e8513059a2613aaba4d817bb90b9d9b6b69aace3ce9c877e8c8ed402b"}, +] + +[[package]] +name = "ghp-import" +version = "2.1.0" +summary = "Copy your docs directly to the gh-pages branch." +groups = ["docs"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "python-dateutil>=2.8.1", +] +files = [ + {file = "ghp-import-2.1.0.tar.gz", hash = "sha256:9c535c4c61193c2df8871222567d7fd7e5014d835f97dc7b7439069e2413d343"}, + {file = "ghp_import-2.1.0-py3-none-any.whl", hash = "sha256:8337dd7b50877f163d4c0289bc1f1c7f127550241988d568c1db512c4324a619"}, +] + +[[package]] +name = "h11" +version = "0.14.0" +requires_python = ">=3.7" +summary = "A pure-Python, bring-your-own-I/O implementation of HTTP/1.1" +groups = ["qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "typing-extensions; python_version < \"3.8\"", +] +files = [ + {file = "h11-0.14.0-py3-none-any.whl", hash = "sha256:e3fe4ac4b851c468cc8363d500db52c2ead036020723024a109d37346efaa761"}, + {file = "h11-0.14.0.tar.gz", hash = "sha256:8f19fbbe99e72420ff35c00b27a34cb9937e902a8b810e2c88300c6f0a3b699d"}, +] + +[[package]] +name = "httpcore" +version = "1.0.5" +requires_python = ">=3.8" +summary = "A minimal low-level HTTP client." +groups = ["qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "certifi", + "h11<0.15,>=0.13", +] +files = [ + {file = "httpcore-1.0.5-py3-none-any.whl", hash = "sha256:421f18bac248b25d310f3cacd198d55b8e6125c107797b609ff9b7a6ba7991b5"}, + {file = "httpcore-1.0.5.tar.gz", hash = "sha256:34a38e2f9291467ee3b44e89dd52615370e152954ba21721378a87b2960f7a61"}, +] + +[[package]] +name = "httpx" +version = "0.27.2" +requires_python = ">=3.8" +summary = "The next generation HTTP client." +groups = ["qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "anyio", + "certifi", + "httpcore==1.*", + "idna", + "sniffio", +] +files = [ + {file = "httpx-0.27.2-py3-none-any.whl", hash = "sha256:7bb2708e112d8fdd7829cd4243970f0c223274051cb35ee80c03301ee29a3df0"}, + {file = "httpx-0.27.2.tar.gz", hash = "sha256:f7c2be1d2f3c3c3160d441802406b206c2b76f5947b11115e6df10c6c65e66c2"}, +] + +[[package]] +name = "identify" +version = "2.6.0" +requires_python = ">=3.8" +summary = "File identification library for Python" +groups = ["qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "identify-2.6.0-py2.py3-none-any.whl", hash = "sha256:e79ae4406387a9d300332b5fd366d8994f1525e8414984e1a59e058b2eda2dd0"}, + {file = "identify-2.6.0.tar.gz", hash = "sha256:cb171c685bdc31bcc4c1734698736a7d5b6c8bf2e0c15117f4d469c8640ae5cf"}, +] + +[[package]] +name = "idna" +version = "3.8" +requires_python = ">=3.6" +summary = "Internationalized Domain Names in Applications (IDNA)" +groups = ["docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "idna-3.8-py3-none-any.whl", hash = "sha256:050b4e5baadcd44d760cedbd2b8e639f2ff89bbc7a5730fcc662954303377aac"}, + {file = "idna-3.8.tar.gz", hash = "sha256:d838c2c0ed6fced7693d5e8ab8e734d5f8fda53a039c0164afb0b82e771e3603"}, +] + +[[package]] +name = "imageio" +version = "2.35.1" +requires_python = ">=3.8" +summary = "Library for reading and writing a wide range of image, video, scientific, and volumetric data formats." +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "numpy", + "pillow>=8.3.2", +] +files = [ + {file = "imageio-2.35.1-py3-none-any.whl", hash = "sha256:6eb2e5244e7a16b85c10b5c2fe0f7bf961b40fcb9f1a9fd1bd1d2c2f8fb3cd65"}, + {file = "imageio-2.35.1.tar.gz", hash = "sha256:4952dfeef3c3947957f6d5dedb1f4ca31c6e509a476891062396834048aeed2a"}, +] + +[[package]] +name = "imagesize" +version = "1.4.1" +requires_python = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*" +summary = "Getting image size from png/jpeg/jpeg2000/gif file" +groups = ["docs"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "imagesize-1.4.1-py2.py3-none-any.whl", hash = "sha256:0d8d18d08f840c19d0ee7ca1fd82490fdc3729b7ac93f49870406ddde8ef8d8b"}, + {file = "imagesize-1.4.1.tar.gz", hash = "sha256:69150444affb9cb0d5cc5a92b3676f0b2fb7cd9ae39e947a5e11a36b4497cd4a"}, +] + +[[package]] +name = "importlib-metadata" +version = "8.5.0" +requires_python = ">=3.8" +summary = "Read metadata from Python packages" +groups = ["docs", "pyvista", "qa"] +marker = "python_version < \"3.10\" and python_version >= \"3.9\"" +dependencies = [ + "typing-extensions>=3.6.4; python_version < \"3.8\"", + "zipp>=3.20", +] +files = [ + {file = "importlib_metadata-8.5.0-py3-none-any.whl", hash = "sha256:45e54197d28b7a7f1559e60b95e7c567032b602131fbd588f1497f47880aa68b"}, + {file = "importlib_metadata-8.5.0.tar.gz", hash = "sha256:71522656f0abace1d072b9e5481a48f07c138e00f079c38c8f883823f9c26bd7"}, +] + +[[package]] +name = "importlib-resources" +version = "6.4.5" +requires_python = ">=3.8" +summary = "Read resources from Python packages" +groups = ["default", "pyvista"] +marker = "python_version < \"3.10\" and python_version >= \"3.9\"" +dependencies = [ + "zipp>=3.1.0; python_version < \"3.10\"", +] +files = [ + {file = "importlib_resources-6.4.5-py3-none-any.whl", hash = "sha256:ac29d5f956f01d5e4bb63102a5a19957f1b9175e45649977264a1416783bb717"}, + {file = "importlib_resources-6.4.5.tar.gz", hash = "sha256:980862a1d16c9e147a59603677fa2aa5fd82b87f223b6cb870695bcfce830065"}, +] + +[[package]] +name = "iniconfig" +version = "2.0.0" +requires_python = ">=3.7" +summary = "brain-dead simple config-ini parsing" +groups = ["qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "iniconfig-2.0.0-py3-none-any.whl", hash = "sha256:b6a85871a79d2e3b22d2d1b94ac2824226a63c6b741c88f7ae975f18b6778374"}, + {file = "iniconfig-2.0.0.tar.gz", hash = "sha256:2d91e135bf72d31a410b17c16da610a82cb55f6b0477d1a902134b24a455b8b3"}, +] + +[[package]] +name = "ipdb" +version = "0.13.13" +requires_python = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*" +summary = "IPython-enabled pdb" +groups = ["qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "decorator; python_version == \"3.5\"", + "decorator; python_version == \"3.6\"", + "decorator; python_version > \"3.6\" and python_version < \"3.11\"", + "decorator; python_version >= \"3.11\"", + "decorator<5.0.0; python_version == \"2.7\"", + "decorator<5.0.0; python_version == \"3.4\"", + "ipython<6.0.0,>=5.1.0; python_version == \"2.7\"", + "ipython<7.0.0,>=6.0.0; python_version == \"3.4\"", + "ipython<7.10.0,>=7.0.0; python_version == \"3.5\"", + "ipython<7.17.0,>=7.16.3; python_version == \"3.6\"", + "ipython>=7.31.1; python_version > \"3.6\" and python_version < \"3.11\"", + "ipython>=7.31.1; python_version >= \"3.11\"", + "pathlib; python_version == \"2.7\"", + "toml>=0.10.2; python_version == \"2.7\"", + "toml>=0.10.2; python_version == \"3.4\"", + "toml>=0.10.2; python_version == \"3.5\"", + "tomli; python_version == \"3.6\"", + "tomli; python_version > \"3.6\" and python_version < \"3.11\"", +] +files = [ + {file = "ipdb-0.13.13-py3-none-any.whl", hash = "sha256:45529994741c4ab6d2388bfa5d7b725c2cf7fe9deffabdb8a6113aa5ed449ed4"}, + {file = "ipdb-0.13.13.tar.gz", hash = "sha256:e3ac6018ef05126d442af680aad863006ec19d02290561ac88b8b1c0b0cfc726"}, +] + +[[package]] +name = "ipykernel" +version = "6.29.5" +requires_python = ">=3.8" +summary = "IPython Kernel for Jupyter" +groups = ["qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "appnope; platform_system == \"Darwin\"", + "comm>=0.1.1", + "debugpy>=1.6.5", + "ipython>=7.23.1", + "jupyter-client>=6.1.12", + "jupyter-core!=5.0.*,>=4.12", + "matplotlib-inline>=0.1", + "nest-asyncio", + "packaging", + "psutil", + "pyzmq>=24", + "tornado>=6.1", + "traitlets>=5.4.0", +] +files = [ + {file = "ipykernel-6.29.5-py3-none-any.whl", hash = "sha256:afdb66ba5aa354b09b91379bac28ae4afebbb30e8b39510c9690afb7a10421b5"}, + {file = "ipykernel-6.29.5.tar.gz", hash = "sha256:f093a22c4a40f8828f8e330a9c297cb93dcab13bd9678ded6de8e5cf81c56215"}, +] + +[[package]] +name = "ipython" +version = "8.18.1" +requires_python = ">=3.9" +summary = "IPython: Productive Interactive Computing" +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "colorama; sys_platform == \"win32\"", + "decorator", + "exceptiongroup; python_version < \"3.11\"", + "jedi>=0.16", + "matplotlib-inline", + "pexpect>4.3; sys_platform != \"win32\"", + "prompt-toolkit<3.1.0,>=3.0.41", + "pygments>=2.4.0", + "stack-data", + "traitlets>=5", + "typing-extensions; python_version < \"3.10\"", +] +files = [ + {file = "ipython-8.18.1-py3-none-any.whl", hash = "sha256:e8267419d72d81955ec1177f8a29aaa90ac80ad647499201119e2f05e99aa397"}, + {file = "ipython-8.18.1.tar.gz", hash = "sha256:ca6f079bb33457c66e233e4580ebfc4128855b4cf6370dddd73842a9563e8a27"}, +] + +[[package]] +name = "ipywidgets" +version = "8.1.5" +requires_python = ">=3.7" +summary = "Jupyter interactive widgets" +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "comm>=0.1.3", + "ipython>=6.1.0", + "jupyterlab-widgets~=3.0.12", + "traitlets>=4.3.1", + "widgetsnbextension~=4.0.12", +] +files = [ + {file = "ipywidgets-8.1.5-py3-none-any.whl", hash = "sha256:3290f526f87ae6e77655555baba4f36681c555b8bdbbff430b70e52c34c86245"}, + {file = "ipywidgets-8.1.5.tar.gz", hash = "sha256:870e43b1a35656a80c18c9503bbf2d16802db1cb487eec6fab27d683381dde17"}, +] + +[[package]] +name = "isoduration" +version = "20.11.0" +requires_python = ">=3.7" +summary = "Operations with ISO 8601 durations" +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "arrow>=0.15.0", +] +files = [ + {file = "isoduration-20.11.0-py3-none-any.whl", hash = "sha256:b2904c2a4228c3d44f409c8ae8e2370eb21a26f7ac2ec5446df141dde3452042"}, + {file = "isoduration-20.11.0.tar.gz", hash = "sha256:ac2f9015137935279eac671f94f89eb00584f940f5dc49462a0c4ee692ba1bd9"}, +] + +[[package]] +name = "jedi" +version = "0.19.1" +requires_python = ">=3.6" +summary = "An autocompletion tool for Python that can be used for text editors." +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "parso<0.9.0,>=0.8.3", +] +files = [ + {file = "jedi-0.19.1-py2.py3-none-any.whl", hash = "sha256:e983c654fe5c02867aef4cdfce5a2fbb4a50adc0af145f70504238f18ef5e7e0"}, + {file = "jedi-0.19.1.tar.gz", hash = "sha256:cf0496f3651bc65d7174ac1b7d043eff454892c708a87d1b683e57b569927ffd"}, +] + +[[package]] +name = "jinja2" +version = "3.1.5" +requires_python = ">=3.7" +summary = "A very fast and expressive template engine." +groups = ["docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "MarkupSafe>=2.0", +] +files = [ + {file = "jinja2-3.1.5-py3-none-any.whl", hash = "sha256:aba0f4dc9ed8013c424088f68a5c226f7d6097ed89b246d7749c2ec4175c6adb"}, + {file = "jinja2-3.1.5.tar.gz", hash = "sha256:8fefff8dc3034e27bb80d67c671eb8a9bc424c0ef4c0826edbff304cceff43bb"}, +] + +[[package]] +name = "json5" +version = "0.9.25" +requires_python = ">=3.8" +summary = "A Python implementation of the JSON5 data format." +groups = ["qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "json5-0.9.25-py3-none-any.whl", hash = "sha256:34ed7d834b1341a86987ed52f3f76cd8ee184394906b6e22a1e0deb9ab294e8f"}, + {file = "json5-0.9.25.tar.gz", hash = "sha256:548e41b9be043f9426776f05df8635a00fe06104ea51ed24b67f908856e151ae"}, +] + +[[package]] +name = "jsonpointer" +version = "3.0.0" +requires_python = ">=3.7" +summary = "Identify specific nodes in a JSON document (RFC 6901) " +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "jsonpointer-3.0.0-py2.py3-none-any.whl", hash = "sha256:13e088adc14fca8b6aa8177c044e12701e6ad4b28ff10e65f2267a90109c9942"}, + {file = "jsonpointer-3.0.0.tar.gz", hash = "sha256:2b2d729f2091522d61c3b31f82e11870f60b68f43fbc705cb76bf4b832af59ef"}, +] + +[[package]] +name = "jsonschema" +version = "4.23.0" +requires_python = ">=3.8" +summary = "An implementation of JSON Schema validation for Python" +groups = ["docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "attrs>=22.2.0", + "importlib-resources>=1.4.0; python_version < \"3.9\"", + "jsonschema-specifications>=2023.03.6", + "pkgutil-resolve-name>=1.3.10; python_version < \"3.9\"", + "referencing>=0.28.4", + "rpds-py>=0.7.1", +] +files = [ + {file = "jsonschema-4.23.0-py3-none-any.whl", hash = "sha256:fbadb6f8b144a8f8cf9f0b89ba94501d143e50411a1278633f56a7acf7fd5566"}, + {file = "jsonschema-4.23.0.tar.gz", hash = "sha256:d71497fef26351a33265337fa77ffeb82423f3ea21283cd9467bb03999266bc4"}, +] + +[[package]] +name = "jsonschema-specifications" +version = "2023.12.1" +requires_python = ">=3.8" +summary = "The JSON Schema meta-schemas and vocabularies, exposed as a Registry" +groups = ["docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "importlib-resources>=1.4.0; python_version < \"3.9\"", + "referencing>=0.31.0", +] +files = [ + {file = "jsonschema_specifications-2023.12.1-py3-none-any.whl", hash = "sha256:87e4fdf3a94858b8a2ba2778d9ba57d8a9cafca7c7489c46ba0d30a8bc6a9c3c"}, + {file = "jsonschema_specifications-2023.12.1.tar.gz", hash = "sha256:48a76787b3e70f5ed53f1160d2b81f586e4ca6d1548c5de7085d1682674764cc"}, +] + +[[package]] +name = "jsonschema" +version = "4.23.0" +extras = ["format-nongpl"] +requires_python = ">=3.8" +summary = "An implementation of JSON Schema validation for Python" +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "fqdn", + "idna", + "isoduration", + "jsonpointer>1.13", + "jsonschema==4.23.0", + "rfc3339-validator", + "rfc3986-validator>0.1.0", + "uri-template", + "webcolors>=24.6.0", +] +files = [ + {file = "jsonschema-4.23.0-py3-none-any.whl", hash = "sha256:fbadb6f8b144a8f8cf9f0b89ba94501d143e50411a1278633f56a7acf7fd5566"}, + {file = "jsonschema-4.23.0.tar.gz", hash = "sha256:d71497fef26351a33265337fa77ffeb82423f3ea21283cd9467bb03999266bc4"}, +] + +[[package]] +name = "jupyter-client" +version = "8.6.3" +requires_python = ">=3.8" +summary = "Jupyter protocol implementation and client libraries" +groups = ["docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "importlib-metadata>=4.8.3; python_version < \"3.10\"", + "jupyter-core!=5.0.*,>=4.12", + "python-dateutil>=2.8.2", + "pyzmq>=23.0", + "tornado>=6.2", + "traitlets>=5.3", +] +files = [ + {file = "jupyter_client-8.6.3-py3-none-any.whl", hash = "sha256:e8a19cc986cc45905ac3362915f410f3af85424b4c0905e94fa5f2cb08e8f23f"}, + {file = "jupyter_client-8.6.3.tar.gz", hash = "sha256:35b3a0947c4a6e9d589eb97d7d4cd5e90f910ee73101611f01283732bd6d9419"}, +] + +[[package]] +name = "jupyter-core" +version = "5.7.2" +requires_python = ">=3.8" +summary = "Jupyter core package. A base package on which Jupyter projects rely." +groups = ["docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "platformdirs>=2.5", + "pywin32>=300; sys_platform == \"win32\" and platform_python_implementation != \"PyPy\"", + "traitlets>=5.3", +] +files = [ + {file = "jupyter_core-5.7.2-py3-none-any.whl", hash = "sha256:4f7315d2f6b4bcf2e3e7cb6e46772eba760ae459cd1f59d29eb57b0a01bd7409"}, + {file = "jupyter_core-5.7.2.tar.gz", hash = "sha256:aa5f8d32bbf6b431ac830496da7392035d6f61b4f54872f15c4bd2a9c3f536d9"}, +] + +[[package]] +name = "jupyter-events" +version = "0.12.0" +requires_python = ">=3.9" +summary = "Jupyter Event System library" +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "jsonschema[format-nongpl]>=4.18.0", + "packaging", + "python-json-logger>=2.0.4", + "pyyaml>=5.3", + "referencing", + "rfc3339-validator", + "rfc3986-validator>=0.1.1", + "traitlets>=5.3", +] +files = [ + {file = "jupyter_events-0.12.0-py3-none-any.whl", hash = "sha256:6464b2fa5ad10451c3d35fabc75eab39556ae1e2853ad0c0cc31b656731a97fb"}, + {file = "jupyter_events-0.12.0.tar.gz", hash = "sha256:fc3fce98865f6784c9cd0a56a20644fc6098f21c8c33834a8d9fe383c17e554b"}, +] + +[[package]] +name = "jupyter-lsp" +version = "2.2.5" +requires_python = ">=3.8" +summary = "Multi-Language Server WebSocket proxy for Jupyter Notebook/Lab server" +groups = ["qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "importlib-metadata>=4.8.3; python_version < \"3.10\"", + "jupyter-server>=1.1.2", +] +files = [ + {file = "jupyter-lsp-2.2.5.tar.gz", hash = "sha256:793147a05ad446f809fd53ef1cd19a9f5256fd0a2d6b7ce943a982cb4f545001"}, + {file = "jupyter_lsp-2.2.5-py3-none-any.whl", hash = "sha256:45fbddbd505f3fbfb0b6cb2f1bc5e15e83ab7c79cd6e89416b248cb3c00c11da"}, +] + +[[package]] +name = "jupyter-server" +version = "2.15.0" +requires_python = ">=3.9" +summary = "The backend—i.e. core services, APIs, and REST endpoints—to Jupyter web applications." +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "anyio>=3.1.0", + "argon2-cffi>=21.1", + "jinja2>=3.0.3", + "jupyter-client>=7.4.4", + "jupyter-core!=5.0.*,>=4.12", + "jupyter-events>=0.11.0", + "jupyter-server-terminals>=0.4.4", + "nbconvert>=6.4.4", + "nbformat>=5.3.0", + "overrides>=5.0", + "packaging>=22.0", + "prometheus-client>=0.9", + "pywinpty>=2.0.1; os_name == \"nt\"", + "pyzmq>=24", + "send2trash>=1.8.2", + "terminado>=0.8.3", + "tornado>=6.2.0", + "traitlets>=5.6.0", + "websocket-client>=1.7", +] +files = [ + {file = "jupyter_server-2.15.0-py3-none-any.whl", hash = "sha256:872d989becf83517012ee669f09604aa4a28097c0bd90b2f424310156c2cdae3"}, + {file = "jupyter_server-2.15.0.tar.gz", hash = "sha256:9d446b8697b4f7337a1b7cdcac40778babdd93ba614b6d68ab1c0c918f1c4084"}, +] + +[[package]] +name = "jupyter-server-proxy" +version = "4.4.0" +requires_python = ">=3.8" +summary = "A Jupyter server extension to run additional processes and proxy to them that comes bundled JupyterLab extension to launch pre-defined processes." +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "aiohttp", + "importlib-metadata>=4.8.3; python_version < \"3.10\"", + "jupyter-server>=1.24.0", + "simpervisor>=1.0.0", + "tornado>=6.1.0", + "traitlets>=5.1.0", +] +files = [ + {file = "jupyter_server_proxy-4.4.0-py3-none-any.whl", hash = "sha256:707b5c84810bb8863d50f6c6d50a386fec216149e11802b7d4c451b54a63a9a6"}, + {file = "jupyter_server_proxy-4.4.0.tar.gz", hash = "sha256:e5732eb9c810c0caa997f90a2f15f7d09af638e7eea9c67eb5c43e9c1f0e1157"}, +] + +[[package]] +name = "jupyter-server-terminals" +version = "0.5.3" +requires_python = ">=3.8" +summary = "A Jupyter Server Extension Providing Terminals." +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "pywinpty>=2.0.3; os_name == \"nt\"", + "terminado>=0.8.3", +] +files = [ + {file = "jupyter_server_terminals-0.5.3-py3-none-any.whl", hash = "sha256:41ee0d7dc0ebf2809c668e0fc726dfaf258fcd3e769568996ca731b6194ae9aa"}, + {file = "jupyter_server_terminals-0.5.3.tar.gz", hash = "sha256:5ae0295167220e9ace0edcfdb212afd2b01ee8d179fe6f23c899590e9b8a5269"}, +] + +[[package]] +name = "jupyterlab" +version = "4.3.5" +requires_python = ">=3.8" +summary = "JupyterLab computational environment" +groups = ["qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "async-lru>=1.0.0", + "httpx>=0.25.0", + "importlib-metadata>=4.8.3; python_version < \"3.10\"", + "importlib-resources>=1.4; python_version < \"3.9\"", + "ipykernel>=6.5.0", + "jinja2>=3.0.3", + "jupyter-core", + "jupyter-lsp>=2.0.0", + "jupyter-server<3,>=2.4.0", + "jupyterlab-server<3,>=2.27.1", + "notebook-shim>=0.2", + "packaging", + "setuptools>=40.8.0", + "tomli>=1.2.2; python_version < \"3.11\"", + "tornado>=6.2.0", + "traitlets", +] +files = [ + {file = "jupyterlab-4.3.5-py3-none-any.whl", hash = "sha256:571bbdee20e4c5321ab5195bc41cf92a75a5cff886be5e57ce78dfa37a5e9fdb"}, + {file = "jupyterlab-4.3.5.tar.gz", hash = "sha256:c779bf72ced007d7d29d5bcef128e7fdda96ea69299e19b04a43635a7d641f9d"}, +] + +[[package]] +name = "jupyterlab-pygments" +version = "0.3.0" +requires_python = ">=3.8" +summary = "Pygments theme using JupyterLab CSS variables" +groups = ["docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "jupyterlab_pygments-0.3.0-py3-none-any.whl", hash = "sha256:841a89020971da1d8693f1a99997aefc5dc424bb1b251fd6322462a1b8842780"}, + {file = "jupyterlab_pygments-0.3.0.tar.gz", hash = "sha256:721aca4d9029252b11cfa9d185e5b5af4d54772bb8072f9b7036f4170054d35d"}, +] + +[[package]] +name = "jupyterlab-server" +version = "2.27.3" +requires_python = ">=3.8" +summary = "A set of server components for JupyterLab and JupyterLab like applications." +groups = ["qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "babel>=2.10", + "importlib-metadata>=4.8.3; python_version < \"3.10\"", + "jinja2>=3.0.3", + "json5>=0.9.0", + "jsonschema>=4.18.0", + "jupyter-server<3,>=1.21", + "packaging>=21.3", + "requests>=2.31", +] +files = [ + {file = "jupyterlab_server-2.27.3-py3-none-any.whl", hash = "sha256:e697488f66c3db49df675158a77b3b017520d772c6e1548c7d9bcc5df7944ee4"}, + {file = "jupyterlab_server-2.27.3.tar.gz", hash = "sha256:eb36caca59e74471988f0ae25c77945610b887f777255aa21f8065def9e51ed4"}, +] + +[[package]] +name = "jupyterlab-widgets" +version = "3.0.13" +requires_python = ">=3.7" +summary = "Jupyter interactive widgets for JupyterLab" +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "jupyterlab_widgets-3.0.13-py3-none-any.whl", hash = "sha256:e3cda2c233ce144192f1e29914ad522b2f4c40e77214b0cc97377ca3d323db54"}, + {file = "jupyterlab_widgets-3.0.13.tar.gz", hash = "sha256:a2966d385328c1942b683a8cd96b89b8dd82c8b8f81dda902bb2bc06d46f5bed"}, +] + +[[package]] +name = "kiwisolver" +version = "1.4.7" +requires_python = ">=3.8" +summary = "A fast implementation of the Cassowary constraint solver" +groups = ["default", "pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "kiwisolver-1.4.7-cp310-cp310-win_amd64.whl", hash = "sha256:44756f9fd339de0fb6ee4f8c1696cfd19b2422e0d70b4cefc1cc7f1f64045a8c"}, + {file = "kiwisolver-1.4.7-cp311-cp311-win_amd64.whl", hash = "sha256:929e294c1ac1e9f615c62a4e4313ca1823ba37326c164ec720a803287c4c499b"}, + {file = "kiwisolver-1.4.7-cp312-cp312-win_amd64.whl", hash = "sha256:58cb20602b18f86f83a5c87d3ee1c766a79c0d452f8def86d925e6c60fbf7bfb"}, + {file = "kiwisolver-1.4.7-cp39-cp39-win_amd64.whl", hash = "sha256:cf0438b42121a66a3a667de17e779330fc0f20b0d97d59d2f2121e182b0505e4"}, + {file = "kiwisolver-1.4.7-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:eb542fe7933aa09d8d8f9d9097ef37532a7df6497819d16efe4359890a2f417a"}, + {file = "kiwisolver-1.4.7-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:0c6c43471bc764fad4bc99c5c2d6d16a676b1abf844ca7c8702bdae92df01ee0"}, + {file = "kiwisolver-1.4.7.tar.gz", hash = "sha256:9893ff81bd7107f7b685d3017cc6583daadb4fc26e4a888350df530e41980a60"}, +] + +[[package]] +name = "markdown-it-py" +version = "3.0.0" +requires_python = ">=3.8" +summary = "Python port of markdown-it. Markdown parsing, done right!" +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "mdurl~=0.1", +] +files = [ + {file = "markdown-it-py-3.0.0.tar.gz", hash = "sha256:e3f60a94fa066dc52ec76661e37c851cb232d92f9886b15cb560aaada2df8feb"}, + {file = "markdown_it_py-3.0.0-py3-none-any.whl", hash = "sha256:355216845c60bd96232cd8d8c40e8f9765cc86f46880e43a8fd22dc1a1a8cab1"}, +] + +[[package]] +name = "markupsafe" +version = "2.1.5" +requires_python = ">=3.7" +summary = "Safely add untrusted strings to HTML/XML markup." +groups = ["docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "MarkupSafe-2.1.5-cp310-cp310-win_amd64.whl", hash = "sha256:bf50cd79a75d181c9181df03572cdce0fbb75cc353bc350712073108cba98de5"}, + {file = "MarkupSafe-2.1.5-cp311-cp311-win_amd64.whl", hash = "sha256:2b7c57a4dfc4f16f7142221afe5ba4e093e09e728ca65c51f5620c9aaeb9a617"}, + {file = "MarkupSafe-2.1.5-cp312-cp312-win_amd64.whl", hash = "sha256:823b65d8706e32ad2df51ed89496147a42a2a6e01c13cfb6ffb8b1e92bc910bb"}, + {file = "MarkupSafe-2.1.5-cp39-cp39-win_amd64.whl", hash = "sha256:fa173ec60341d6bb97a89f5ea19c85c5643c1e7dedebc22f5181eb73573142c5"}, + {file = "MarkupSafe-2.1.5.tar.gz", hash = "sha256:d283d37a890ba4c1ae73ffadf8046435c76e7bc2247bbb63c00bd1a709c6544b"}, +] + +[[package]] +name = "matplotlib" +version = "3.9.4" +requires_python = ">=3.9" +summary = "Python plotting package" +groups = ["default", "pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "contourpy>=1.0.1", + "cycler>=0.10", + "fonttools>=4.22.0", + "importlib-resources>=3.2.0; python_version < \"3.10\"", + "kiwisolver>=1.3.1", + "numpy>=1.23", + "packaging>=20.0", + "pillow>=8", + "pyparsing>=2.3.1", + "python-dateutil>=2.7", +] +files = [ + {file = "matplotlib-3.9.4-cp310-cp310-win_amd64.whl", hash = "sha256:4598c394ae9711cec135639374e70871fa36b56afae17bdf032a345be552a88d"}, + {file = "matplotlib-3.9.4-cp311-cp311-win_amd64.whl", hash = "sha256:1f6882828231eca17f501c4dcd98a05abb3f03d157fbc0769c6911fe08b6cfd3"}, + {file = "matplotlib-3.9.4-cp312-cp312-win_amd64.whl", hash = "sha256:a4a4cfc82330b27042a7169533da7991e8789d180dd5b3daeaee57d75cd5a03b"}, + {file = "matplotlib-3.9.4-cp39-cp39-win_amd64.whl", hash = "sha256:ef5f2d1b67d2d2145ff75e10f8c008bfbf71d45137c4b648c87193e7dd053eac"}, + {file = "matplotlib-3.9.4-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:ad45da51be7ad02387801fd154ef74d942f49fe3fcd26a64c94842ba7ec0d865"}, + {file = "matplotlib-3.9.4.tar.gz", hash = "sha256:1e00e8be7393cbdc6fedfa8a6fba02cf3e83814b285db1c60b906a023ba41bc3"}, +] + +[[package]] +name = "matplotlib-inline" +version = "0.1.7" +requires_python = ">=3.8" +summary = "Inline Matplotlib backend for Jupyter" +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "traitlets", +] +files = [ + {file = "matplotlib_inline-0.1.7-py3-none-any.whl", hash = "sha256:df192d39a4ff8f21b1895d72e6a13f5fcc5099f00fa84384e0ea28c2cc0653ca"}, + {file = "matplotlib_inline-0.1.7.tar.gz", hash = "sha256:8423b23ec666be3d16e16b60bdd8ac4e86e840ebd1dd11a30b9f117f2fa0ab90"}, +] + +[[package]] +name = "mdurl" +version = "0.1.2" +requires_python = ">=3.7" +summary = "Markdown URL utilities" +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "mdurl-0.1.2-py3-none-any.whl", hash = "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8"}, + {file = "mdurl-0.1.2.tar.gz", hash = "sha256:bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba"}, +] + +[[package]] +name = "meshio" +version = "5.3.5" +requires_python = ">=3.8" +summary = "I/O for many mesh formats" +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "importlib-metadata; python_version < \"3.8\"", + "numpy>=1.20.0", + "rich", +] +files = [ + {file = "meshio-5.3.5-py3-none-any.whl", hash = "sha256:0736c6e34ecc768f62f2cde5d8233a3529512a9399b25c68ea2ca0d5900cdc10"}, + {file = "meshio-5.3.5.tar.gz", hash = "sha256:f21f01abd9f29ba06ea119304b3d39e610421cfe93b9dd23362834919f87586d"}, +] + +[[package]] +name = "mistune" +version = "3.0.2" +requires_python = ">=3.7" +summary = "A sane and fast Markdown parser with useful plugins and renderers" +groups = ["docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "mistune-3.0.2-py3-none-any.whl", hash = "sha256:71481854c30fdbc938963d3605b72501f5c10a9320ecd412c121c163a1c7d205"}, + {file = "mistune-3.0.2.tar.gz", hash = "sha256:fc7f93ded930c92394ef2cb6f04a8aabab4117a91449e72dcc8dfa646a508be8"}, +] + +[[package]] +name = "more-itertools" +version = "10.5.0" +requires_python = ">=3.8" +summary = "More routines for operating on iterables, beyond itertools" +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "more-itertools-10.5.0.tar.gz", hash = "sha256:5482bfef7849c25dc3c6dd53a6173ae4795da2a41a80faea6700d9f5846c5da6"}, + {file = "more_itertools-10.5.0-py3-none-any.whl", hash = "sha256:037b0d3203ce90cca8ab1defbbdac29d5f993fc20131f3664dc8d6acfa872aef"}, +] + +[[package]] +name = "msgpack" +version = "1.1.0" +requires_python = ">=3.8" +summary = "MessagePack serializer" +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "msgpack-1.1.0-cp310-cp310-win_amd64.whl", hash = "sha256:685ec345eefc757a7c8af44a3032734a739f8c45d1b0ac45efc5d8977aa4720f"}, + {file = "msgpack-1.1.0-cp311-cp311-win_amd64.whl", hash = "sha256:fd2906780f25c8ed5d7b323379f6138524ba793428db5d0e9d226d3fa6aa1788"}, + {file = "msgpack-1.1.0-cp312-cp312-win_amd64.whl", hash = "sha256:115a7af8ee9e8cddc10f87636767857e7e3717b7a2e97379dc2054712693e90f"}, + {file = "msgpack-1.1.0-cp39-cp39-win_amd64.whl", hash = "sha256:4d1b7ff2d6146e16e8bd665ac726a89c74163ef8cd39fa8c1087d4e52d3a2325"}, + {file = "msgpack-1.1.0.tar.gz", hash = "sha256:dd432ccc2c72b914e4cb77afce64aab761c1137cc698be3984eee260bcb2896e"}, +] + +[[package]] +name = "multidict" +version = "6.1.0" +requires_python = ">=3.8" +summary = "multidict implementation" +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "typing-extensions>=4.1.0; python_version < \"3.11\"", +] +files = [ + {file = "multidict-6.1.0-cp310-cp310-win_amd64.whl", hash = "sha256:20b9b5fbe0b88d0bdef2012ef7dee867f874b72528cf1d08f1d59b0e3850129d"}, + {file = "multidict-6.1.0-cp311-cp311-win_amd64.whl", hash = "sha256:82176036e65644a6cc5bd619f65f6f19781e8ec2e5330f51aa9ada7504cc1926"}, + {file = "multidict-6.1.0-cp312-cp312-win_amd64.whl", hash = "sha256:188215fc0aafb8e03341995e7c4797860181562380f81ed0a87ff455b70bf1f1"}, + {file = "multidict-6.1.0-cp39-cp39-win_amd64.whl", hash = "sha256:aa466da5b15ccea564bdab9c89175c762bc12825f4659c11227f515cee76fa4a"}, + {file = "multidict-6.1.0-py3-none-any.whl", hash = "sha256:48e171e52d1c4d33888e529b999e5900356b9ae588c2f09a52dcefb158b27506"}, + {file = "multidict-6.1.0.tar.gz", hash = "sha256:22ae2ebf9b0c69d206c003e2f6a914ea33f0a932d4aa16f236afc049d9958f4a"}, +] + +[[package]] +name = "nbclient" +version = "0.10.0" +requires_python = ">=3.8.0" +summary = "A client library for executing notebooks. Formerly nbconvert's ExecutePreprocessor." +groups = ["docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "jupyter-client>=6.1.12", + "jupyter-core!=5.0.*,>=4.12", + "nbformat>=5.1", + "traitlets>=5.4", +] +files = [ + {file = "nbclient-0.10.0-py3-none-any.whl", hash = "sha256:f13e3529332a1f1f81d82a53210322476a168bb7090a0289c795fe9cc11c9d3f"}, + {file = "nbclient-0.10.0.tar.gz", hash = "sha256:4b3f1b7dba531e498449c4db4f53da339c91d449dc11e9af3a43b4eb5c5abb09"}, +] + +[[package]] +name = "nbconvert" +version = "7.16.6" +requires_python = ">=3.8" +summary = "Converting Jupyter Notebooks (.ipynb files) to other formats. Output formats include asciidoc, html, latex, markdown, pdf, py, rst, script. nbconvert can be used both as a Python library (`import nbconvert`) or as a command line tool (invoked as `jupyter nbconvert ...`)." +groups = ["docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "beautifulsoup4", + "bleach[css]!=5.0.0", + "defusedxml", + "importlib-metadata>=3.6; python_version < \"3.10\"", + "jinja2>=3.0", + "jupyter-core>=4.7", + "jupyterlab-pygments", + "markupsafe>=2.0", + "mistune<4,>=2.0.3", + "nbclient>=0.5.0", + "nbformat>=5.7", + "packaging", + "pandocfilters>=1.4.1", + "pygments>=2.4.1", + "traitlets>=5.1", +] +files = [ + {file = "nbconvert-7.16.6-py3-none-any.whl", hash = "sha256:1375a7b67e0c2883678c48e506dc320febb57685e5ee67faa51b18a90f3a712b"}, + {file = "nbconvert-7.16.6.tar.gz", hash = "sha256:576a7e37c6480da7b8465eefa66c17844243816ce1ccc372633c6b71c3c0f582"}, +] + +[[package]] +name = "nbformat" +version = "5.10.4" +requires_python = ">=3.8" +summary = "The Jupyter Notebook format" +groups = ["docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "fastjsonschema>=2.15", + "jsonschema>=2.6", + "jupyter-core!=5.0.*,>=4.12", + "traitlets>=5.1", +] +files = [ + {file = "nbformat-5.10.4-py3-none-any.whl", hash = "sha256:3b48d6c8fbca4b299bf3982ea7db1af21580e4fec269ad087b9e81588891200b"}, + {file = "nbformat-5.10.4.tar.gz", hash = "sha256:322168b14f937a5d11362988ecac2a4952d3d8e3a2cbeb2319584631226d5b3a"}, +] + +[[package]] +name = "nbsphinx" +version = "0.9.6" +requires_python = ">=3.6" +summary = "Jupyter Notebook Tools for Sphinx" +groups = ["docs"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "docutils>=0.18.1", + "jinja2", + "nbconvert!=5.4,>=5.3", + "nbformat", + "sphinx>=1.8", + "traitlets>=5", +] +files = [ + {file = "nbsphinx-0.9.6-py3-none-any.whl", hash = "sha256:336b0b557945a7678ec7449b16449f854bc852a435bb53b8a72e6b5dc740d992"}, + {file = "nbsphinx-0.9.6.tar.gz", hash = "sha256:c2b28a2d702f1159a95b843831798e86e60a17fc647b9bff9ba1585355de54e3"}, +] + +[[package]] +name = "nest-asyncio" +version = "1.6.0" +requires_python = ">=3.5" +summary = "Patch asyncio to allow nested event loops" +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "nest_asyncio-1.6.0-py3-none-any.whl", hash = "sha256:87af6efd6b5e897c81050477ef65c62e2b2f35d51703cae01aff2905b1852e1c"}, + {file = "nest_asyncio-1.6.0.tar.gz", hash = "sha256:6f172d5449aca15afd6c646851f4e31e02c598d553a667e38cafa997cfec55fe"}, +] + +[[package]] +name = "nodeenv" +version = "1.9.1" +requires_python = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,!=3.6.*,>=2.7" +summary = "Node.js virtual environment builder" +groups = ["qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "nodeenv-1.9.1-py2.py3-none-any.whl", hash = "sha256:ba11c9782d29c27c70ffbdda2d7415098754709be8a7056d79a737cd901155c9"}, + {file = "nodeenv-1.9.1.tar.gz", hash = "sha256:6ec12890a2dab7946721edbfbcd91f3319c6ccc9aec47be7c7e6b7011ee6645f"}, +] + +[[package]] +name = "notebook" +version = "7.3.2" +requires_python = ">=3.8" +summary = "Jupyter Notebook - A web-based notebook environment for interactive computing" +groups = ["qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "jupyter-server<3,>=2.4.0", + "jupyterlab-server<3,>=2.27.1", + "jupyterlab<4.4,>=4.3.4", + "notebook-shim<0.3,>=0.2", + "tornado>=6.2.0", +] +files = [ + {file = "notebook-7.3.2-py3-none-any.whl", hash = "sha256:e5f85fc59b69d3618d73cf27544418193ff8e8058d5bf61d315ce4f473556288"}, + {file = "notebook-7.3.2.tar.gz", hash = "sha256:705e83a1785f45b383bf3ee13cb76680b92d24f56fb0c7d2136fe1d850cd3ca8"}, +] + +[[package]] +name = "notebook-shim" +version = "0.2.4" +requires_python = ">=3.7" +summary = "A shim layer for notebook traits and config" +groups = ["qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "jupyter-server<3,>=1.8", +] +files = [ + {file = "notebook_shim-0.2.4-py3-none-any.whl", hash = "sha256:411a5be4e9dc882a074ccbcae671eda64cceb068767e9a3419096986560e1cef"}, + {file = "notebook_shim-0.2.4.tar.gz", hash = "sha256:b4b2cfa1b65d98307ca24361f5b30fe785b53c3fd07b7a47e89acb5e6ac638cb"}, +] + +[[package]] +name = "numpy" +version = "2.0.2" +requires_python = ">=3.9" +summary = "Fundamental package for array computing in Python" +groups = ["default", "pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "numpy-2.0.2-cp310-cp310-win_amd64.whl", hash = "sha256:c7b0be4ef08607dd04da4092faee0b86607f111d5ae68036f16cc787e250a131"}, + {file = "numpy-2.0.2-cp311-cp311-win_amd64.whl", hash = "sha256:286cd40ce2b7d652a6f22efdfc6d1edf879440e53e76a75955bc0c826c7e64dc"}, + {file = "numpy-2.0.2-cp312-cp312-win_amd64.whl", hash = "sha256:cfd41e13fdc257aa5778496b8caa5e856dc4896d4ccf01841daee1d96465467a"}, + {file = "numpy-2.0.2-cp39-cp39-win_amd64.whl", hash = "sha256:a3f4ab0caa7f053f6797fcd4e1e25caee367db3112ef2b6ef82d749530768c73"}, + {file = "numpy-2.0.2-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:a46288ec55ebbd58947d31d72be2c63cbf839f0a63b49cb755022310792a3385"}, + {file = "numpy-2.0.2.tar.gz", hash = "sha256:883c987dee1880e2a864ab0dc9892292582510604156762362d9326444636e78"}, +] + +[[package]] +name = "openpyxl" +version = "3.1.5" +requires_python = ">=3.8" +summary = "A Python library to read/write Excel 2010 xlsx/xlsm files" +groups = ["openpyxl"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "et-xmlfile", +] +files = [ + {file = "openpyxl-3.1.5-py2.py3-none-any.whl", hash = "sha256:5282c12b107bffeef825f4617dc029afaf41d0ea60823bbb665ef3079dc79de2"}, + {file = "openpyxl-3.1.5.tar.gz", hash = "sha256:cf0e3cf56142039133628b5acffe8ef0c12bc902d2aadd3e0fe5878dc08d1050"}, +] + +[[package]] +name = "overrides" +version = "7.7.0" +requires_python = ">=3.6" +summary = "A decorator to automatically detect mismatch when overriding a method." +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "typing; python_version < \"3.5\"", +] +files = [ + {file = "overrides-7.7.0-py3-none-any.whl", hash = "sha256:c7ed9d062f78b8e4c1a7b70bd8796b35ead4d9f510227ef9c5dc7626c60d7e49"}, + {file = "overrides-7.7.0.tar.gz", hash = "sha256:55158fa3d93b98cc75299b1e67078ad9003ca27945c76162c1c0766d6f91820a"}, +] + +[[package]] +name = "packaging" +version = "24.2" +requires_python = ">=3.8" +summary = "Core utilities for Python packages" +groups = ["default", "docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "packaging-24.2-py3-none-any.whl", hash = "sha256:09abb1bccd265c01f4a3aa3f7a7db064b36514d2cba19a2f694fe6150451a759"}, + {file = "packaging-24.2.tar.gz", hash = "sha256:c228a6dc5e932d346bc5739379109d49e8853dd8223571c7c5b55260edc0b97f"}, +] + +[[package]] +name = "pandas" +version = "2.2.3" +requires_python = ">=3.9" +summary = "Powerful data structures for data analysis, time series, and statistics" +groups = ["default"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "numpy>=1.22.4; python_version < \"3.11\"", + "numpy>=1.23.2; python_version == \"3.11\"", + "numpy>=1.26.0; python_version >= \"3.12\"", + "python-dateutil>=2.8.2", + "pytz>=2020.1", + "tzdata>=2022.7", +] +files = [ + {file = "pandas-2.2.3-cp310-cp310-win_amd64.whl", hash = "sha256:56534ce0746a58afaf7942ba4863e0ef81c9c50d3f0ae93e9497d6a41a057645"}, + {file = "pandas-2.2.3-cp311-cp311-win_amd64.whl", hash = "sha256:3fc6873a41186404dad67245896a6e440baacc92f5b716ccd1bc9ed2995ab2c5"}, + {file = "pandas-2.2.3-cp312-cp312-win_amd64.whl", hash = "sha256:59ef3764d0fe818125a5097d2ae867ca3fa64df032331b7e0917cf5d7bf66b13"}, + {file = "pandas-2.2.3-cp39-cp39-win_amd64.whl", hash = "sha256:4850ba03528b6dd51d6c5d273c46f183f39a9baf3f0143e566b89450965b105e"}, + {file = "pandas-2.2.3.tar.gz", hash = "sha256:4f18ba62b61d7e192368b84517265a99b4d7ee8912f8708660fb4a366cc82667"}, +] + +[[package]] +name = "pandoc" +version = "2.4" +summary = "Pandoc Documents for Python" +groups = ["docs"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "plumbum", + "ply", +] +files = [ + {file = "pandoc-2.4.tar.gz", hash = "sha256:ecd1f8cbb7f4180c6b5db4a17a7c1a74df519995f5f186ef81ce72a9cbd0dd9a"}, +] + +[[package]] +name = "pandocfilters" +version = "1.5.1" +requires_python = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*" +summary = "Utilities for writing pandoc filters in python" +groups = ["docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "pandocfilters-1.5.1-py2.py3-none-any.whl", hash = "sha256:93be382804a9cdb0a7267585f157e5d1731bbe5545a85b268d6f5fe6232de2bc"}, + {file = "pandocfilters-1.5.1.tar.gz", hash = "sha256:002b4a555ee4ebc03f8b66307e287fa492e4a77b4ea14d3f934328297bb4939e"}, +] + +[[package]] +name = "parso" +version = "0.8.4" +requires_python = ">=3.6" +summary = "A Python Parser" +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "parso-0.8.4-py2.py3-none-any.whl", hash = "sha256:a418670a20291dacd2dddc80c377c5c3791378ee1e8d12bffc35420643d43f18"}, + {file = "parso-0.8.4.tar.gz", hash = "sha256:eb3a7b58240fb99099a345571deecc0f9540ea5f4dd2fe14c2a99d6b281ab92d"}, +] + +[[package]] +name = "pillow" +version = "10.4.0" +requires_python = ">=3.8" +summary = "Python Imaging Library (Fork)" +groups = ["default", "pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "pillow-10.4.0-cp310-cp310-win_amd64.whl", hash = "sha256:ecd85a8d3e79cd7158dec1c9e5808e821feea088e2f69a974db5edf84dc53141"}, + {file = "pillow-10.4.0-cp311-cp311-win_amd64.whl", hash = "sha256:cbed61494057c0f83b83eb3a310f0bf774b09513307c434d4366ed64f4128a91"}, + {file = "pillow-10.4.0-cp312-cp312-win_amd64.whl", hash = "sha256:1d846aea995ad352d4bdcc847535bd56e0fd88d36829d2c90be880ef1ee4668a"}, + {file = "pillow-10.4.0-cp39-cp39-win_amd64.whl", hash = "sha256:961a7293b2457b405967af9c77dcaa43cc1a8cd50d23c532e62d48ab6cdd56f5"}, + {file = "pillow-10.4.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:0755ffd4a0c6f267cccbae2e9903d95477ca2f77c4fcf3a3a09570001856c8a5"}, + {file = "pillow-10.4.0-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:cfdd747216947628af7b259d274771d84db2268ca062dd5faf373639d00113a3"}, + {file = "pillow-10.4.0.tar.gz", hash = "sha256:166c1cd4d24309b30d61f79f4a9114b7b2313d7450912277855ff5dfd7cd4a06"}, +] + +[[package]] +name = "platformdirs" +version = "4.3.6" +requires_python = ">=3.8" +summary = "A small Python package for determining appropriate platform-specific dirs, e.g. a `user data dir`." +groups = ["docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "platformdirs-4.3.6-py3-none-any.whl", hash = "sha256:73e575e1408ab8103900836b97580d5307456908a03e92031bab39e4554cc3fb"}, + {file = "platformdirs-4.3.6.tar.gz", hash = "sha256:357fb2acbc885b0419afd3ce3ed34564c13c9b95c89360cd9563f73aa5e2b907"}, +] + +[[package]] +name = "pluggy" +version = "1.5.0" +requires_python = ">=3.8" +summary = "plugin and hook calling mechanisms for python" +groups = ["qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "pluggy-1.5.0-py3-none-any.whl", hash = "sha256:44e1ad92c8ca002de6377e165f3e0f1be63266ab4d554740532335b9d75ea669"}, + {file = "pluggy-1.5.0.tar.gz", hash = "sha256:2cffa88e94fdc978c4c574f15f9e59b7f4201d439195c3715ca9e2486f1d0cf1"}, +] + +[[package]] +name = "plumbum" +version = "1.8.3" +requires_python = ">=3.6" +summary = "Plumbum: shell combinators library" +groups = ["docs"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "pywin32; platform_system == \"Windows\" and platform_python_implementation != \"PyPy\"", +] +files = [ + {file = "plumbum-1.8.3-py3-none-any.whl", hash = "sha256:8595d36dae2472587d6f59789c8d7b26250f45f6f6ed75ccb378de59ee7b9cf9"}, + {file = "plumbum-1.8.3.tar.gz", hash = "sha256:6092c85ab970b7a7a9d5d85c75200bc93be82b33c9bdf640ffa87d2d7c8709f0"}, +] + +[[package]] +name = "ply" +version = "3.11" +summary = "Python Lex & Yacc" +groups = ["docs"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "ply-3.11-py2.py3-none-any.whl", hash = "sha256:096f9b8350b65ebd2fd1346b12452efe5b9607f7482813ffca50c22722a807ce"}, + {file = "ply-3.11.tar.gz", hash = "sha256:00c7c1aaa88358b9c765b6d3000c6eec0ba42abca5351b095321aef446081da3"}, +] + +[[package]] +name = "pooch" +version = "1.8.2" +requires_python = ">=3.7" +summary = "A friend to fetch your data files" +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "packaging>=20.0", + "platformdirs>=2.5.0", + "requests>=2.19.0", +] +files = [ + {file = "pooch-1.8.2-py3-none-any.whl", hash = "sha256:3529a57096f7198778a5ceefd5ac3ef0e4d06a6ddaf9fc2d609b806f25302c47"}, + {file = "pooch-1.8.2.tar.gz", hash = "sha256:76561f0de68a01da4df6af38e9955c4c9d1a5c90da73f7e40276a5728ec83d10"}, +] + +[[package]] +name = "pre-commit" +version = "4.1.0" +requires_python = ">=3.9" +summary = "A framework for managing and maintaining multi-language pre-commit hooks." +groups = ["qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "cfgv>=2.0.0", + "identify>=1.0.0", + "nodeenv>=0.11.1", + "pyyaml>=5.1", + "virtualenv>=20.10.0", +] +files = [ + {file = "pre_commit-4.1.0-py2.py3-none-any.whl", hash = "sha256:d29e7cb346295bcc1cc75fc3e92e343495e3ea0196c9ec6ba53f49f10ab6ae7b"}, + {file = "pre_commit-4.1.0.tar.gz", hash = "sha256:ae3f018575a588e30dfddfab9a05448bfbd6b73d78709617b5a2b853549716d4"}, +] + +[[package]] +name = "prometheus-client" +version = "0.20.0" +requires_python = ">=3.8" +summary = "Python client for the Prometheus monitoring system." +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "prometheus_client-0.20.0-py3-none-any.whl", hash = "sha256:cde524a85bce83ca359cc837f28b8c0db5cac7aa653a588fd7e84ba061c329e7"}, + {file = "prometheus_client-0.20.0.tar.gz", hash = "sha256:287629d00b147a32dcb2be0b9df905da599b2d82f80377083ec8463309a4bb89"}, +] + +[[package]] +name = "prompt-toolkit" +version = "3.0.47" +requires_python = ">=3.7.0" +summary = "Library for building powerful interactive command lines in Python" +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "wcwidth", +] +files = [ + {file = "prompt_toolkit-3.0.47-py3-none-any.whl", hash = "sha256:0d7bfa67001d5e39d02c224b663abc33687405033a8c422d0d675a5a13361d10"}, + {file = "prompt_toolkit-3.0.47.tar.gz", hash = "sha256:1e1b29cb58080b1e69f207c893a1a7bf16d127a5c30c9d17a25a5d77792e5360"}, +] + +[[package]] +name = "propcache" +version = "0.2.1" +requires_python = ">=3.9" +summary = "Accelerated property cache" +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "propcache-0.2.1-cp310-cp310-win_amd64.whl", hash = "sha256:2d3af2e79991102678f53e0dbf4c35de99b6b8b58f29a27ca0325816364caaba"}, + {file = "propcache-0.2.1-cp311-cp311-win_amd64.whl", hash = "sha256:edc9fc7051e3350643ad929df55c451899bb9ae6d24998a949d2e4c87fb596d3"}, + {file = "propcache-0.2.1-cp312-cp312-win_amd64.whl", hash = "sha256:c214999039d4f2a5b2073ac506bba279945233da8c786e490d411dfc30f855c1"}, + {file = "propcache-0.2.1-cp39-cp39-win_amd64.whl", hash = "sha256:92fc4500fcb33899b05ba73276dfb684a20d31caa567b7cb5252d48f896a91b1"}, + {file = "propcache-0.2.1-py3-none-any.whl", hash = "sha256:52277518d6aae65536e9cea52d4e7fd2f7a66f4aa2d30ed3f2fcea620ace3c54"}, + {file = "propcache-0.2.1.tar.gz", hash = "sha256:3f77ce728b19cb537714499928fe800c3dda29e8d9428778fc7c186da4c09a64"}, +] + +[[package]] +name = "psutil" +version = "6.0.0" +requires_python = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7" +summary = "Cross-platform lib for process and system monitoring in Python." +groups = ["qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "psutil-6.0.0-cp37-abi3-win_amd64.whl", hash = "sha256:33ea5e1c975250a720b3a6609c490db40dae5d83a4eb315170c4fe0d8b1f34b3"}, + {file = "psutil-6.0.0.tar.gz", hash = "sha256:8faae4f310b6d969fa26ca0545338b21f73c6b15db7c4a8d934a5482faa818f2"}, +] + +[[package]] +name = "pure-eval" +version = "0.2.3" +summary = "Safely evaluate AST nodes without side effects" +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "pure_eval-0.2.3-py3-none-any.whl", hash = "sha256:1db8e35b67b3d218d818ae653e27f06c3aa420901fa7b081ca98cbedc874e0d0"}, + {file = "pure_eval-0.2.3.tar.gz", hash = "sha256:5f4e983f40564c576c7c8635ae88db5956bb2229d7e9237d03b3c0b0190eaf42"}, +] + +[[package]] +name = "pycparser" +version = "2.22" +requires_python = ">=3.8" +summary = "C parser in Python" +groups = ["docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "pycparser-2.22-py3-none-any.whl", hash = "sha256:c3702b6d3dd8c7abc1afa565d7e63d53a1d0bd86cdc24edd75470f4de499cfcc"}, + {file = "pycparser-2.22.tar.gz", hash = "sha256:491c8be9c040f5390f5bf44a5b07752bd07f56edf992381b05c701439eec10f6"}, +] + +[[package]] +name = "pydantic" +version = "2.10.6" +requires_python = ">=3.8" +summary = "Data validation using Python type hints" +groups = ["default"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "annotated-types>=0.6.0", + "pydantic-core==2.27.2", + "typing-extensions>=4.12.2", +] +files = [ + {file = "pydantic-2.10.6-py3-none-any.whl", hash = "sha256:427d664bf0b8a2b34ff5dd0f5a18df00591adcee7198fbd71981054cef37b584"}, + {file = "pydantic-2.10.6.tar.gz", hash = "sha256:ca5daa827cce33de7a42be142548b0096bf05a7e7b365aebfa5f8eeec7128236"}, +] + +[[package]] +name = "pydantic-core" +version = "2.27.2" +requires_python = ">=3.8" +summary = "Core functionality for Pydantic validation and serialization" +groups = ["default"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "typing-extensions!=4.7.0,>=4.6.0", +] +files = [ + {file = "pydantic_core-2.27.2-cp310-cp310-win_amd64.whl", hash = "sha256:e0fd26b16394ead34a424eecf8a31a1f5137094cabe84a1bcb10fa6ba39d3d31"}, + {file = "pydantic_core-2.27.2-cp311-cp311-win_amd64.whl", hash = "sha256:08e125dbdc505fa69ca7d9c499639ab6407cfa909214d500897d02afb816e7cc"}, + {file = "pydantic_core-2.27.2-cp312-cp312-win_amd64.whl", hash = "sha256:cc3f1a99a4f4f9dd1de4fe0312c114e740b5ddead65bb4102884b384c15d8bc9"}, + {file = "pydantic_core-2.27.2-cp39-cp39-win_amd64.whl", hash = "sha256:77d1bca19b0f7021b3a982e6f903dcd5b2b06076def36a652e3907f596e29f67"}, + {file = "pydantic_core-2.27.2-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:7e17b560be3c98a8e3aa66ce828bdebb9e9ac6ad5466fba92eb74c4c95cb1151"}, + {file = "pydantic_core-2.27.2-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:7d0c8399fcc1848491f00e0314bd59fb34a9c008761bcb422a057670c3f65e35"}, + {file = "pydantic_core-2.27.2.tar.gz", hash = "sha256:eb026e5a4c1fee05726072337ff51d1efb6f59090b7da90d30ea58625b1ffb39"}, +] + +[[package]] +name = "pygments" +version = "2.18.0" +requires_python = ">=3.8" +summary = "Pygments is a syntax highlighting package written in Python." +groups = ["docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "pygments-2.18.0-py3-none-any.whl", hash = "sha256:b8e6aca0523f3ab76fee51799c488e38782ac06eafcf95e7ba832985c8e7b13a"}, + {file = "pygments-2.18.0.tar.gz", hash = "sha256:786ff802f32e91311bff3889f6e9a86e81505fe99f2735bb6d60ae0c5004f199"}, +] + +[[package]] +name = "pyparsing" +version = "3.1.4" +requires_python = ">=3.6.8" +summary = "pyparsing module - Classes and methods to define and execute parsing grammars" +groups = ["default", "pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "pyparsing-3.1.4-py3-none-any.whl", hash = "sha256:a6a7ee4235a3f944aa1fa2249307708f893fe5717dc603503c6c7969c070fb7c"}, + {file = "pyparsing-3.1.4.tar.gz", hash = "sha256:f86ec8d1a83f11977c9a6ea7598e8c27fc5cddfa5b07ea2241edbbde1d7bc032"}, +] + +[[package]] +name = "pyproject-api" +version = "1.9.0" +requires_python = ">=3.9" +summary = "API to interact with the python pyproject.toml based projects" +groups = ["qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "packaging>=24.2", + "tomli>=2.2.1; python_version < \"3.11\"", +] +files = [ + {file = "pyproject_api-1.9.0-py3-none-any.whl", hash = "sha256:326df9d68dea22d9d98b5243c46e3ca3161b07a1b9b18e213d1e24fd0e605766"}, + {file = "pyproject_api-1.9.0.tar.gz", hash = "sha256:7e8a9854b2dfb49454fae421cb86af43efbb2b2454e5646ffb7623540321ae6e"}, +] + +[[package]] +name = "pyqt5" +version = "5.15.10" +requires_python = ">=3.7" +summary = "Python bindings for the Qt cross platform application toolkit" +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "PyQt5-Qt5>=5.15.2", + "PyQt5-sip<13,>=12.13", +] +files = [ + {file = "PyQt5-5.15.10-cp37-abi3-win_amd64.whl", hash = "sha256:501355f327e9a2c38db0428e1a236d25ebcb99304cd6e668c05d1188d514adec"}, + {file = "PyQt5-5.15.10.tar.gz", hash = "sha256:d46b7804b1b10a4ff91753f8113e5b5580d2b4462f3226288e2d84497334898a"}, +] + +[[package]] +name = "pyqt5-qt5" +version = "5.15.2" +summary = "The subset of a Qt installation needed by PyQt5." +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "PyQt5_Qt5-5.15.2-py3-none-win_amd64.whl", hash = "sha256:750b78e4dba6bdf1607febedc08738e318ea09e9b10aea9ff0d73073f11f6962"}, +] + +[[package]] +name = "pyqt5-sip" +version = "12.15.0" +requires_python = ">=3.8" +summary = "The sip module support for PyQt5" +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "PyQt5_sip-12.15.0-cp310-cp310-win_amd64.whl", hash = "sha256:13f0c6a78e781255863e3e160304648efaf62276b7102741af637b63a6e96930"}, + {file = "PyQt5_sip-12.15.0-cp311-cp311-win_amd64.whl", hash = "sha256:c85be433fbafcb3d417581c0e1b67c8198d23858166e4f938e971c2262c13cdb"}, + {file = "PyQt5_sip-12.15.0-cp312-cp312-win_amd64.whl", hash = "sha256:24a1d4937332bf0a38dd95bb2ce4d89723df449f6e912b52ef0e107e11fefac1"}, + {file = "PyQt5_sip-12.15.0-cp39-cp39-win_amd64.whl", hash = "sha256:7f88c85702dce80ac2e1a162054f688ed394811d6dd03a5574b3fa8111b0a6db"}, + {file = "PyQt5_sip-12.15.0.tar.gz", hash = "sha256:d23fdfcf363b5cedd9d39f8a9c5710e7d52804f5b08a58e91c638b36eafcb702"}, +] + +[[package]] +name = "pytest" +version = "8.3.4" +requires_python = ">=3.8" +summary = "pytest: simple powerful testing with Python" +groups = ["qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "colorama; sys_platform == \"win32\"", + "exceptiongroup>=1.0.0rc8; python_version < \"3.11\"", + "iniconfig", + "packaging", + "pluggy<2,>=1.5", + "tomli>=1; python_version < \"3.11\"", +] +files = [ + {file = "pytest-8.3.4-py3-none-any.whl", hash = "sha256:50e16d954148559c9a74109af1eaf0c945ba2d8f30f0a3d3335edde19788b6f6"}, + {file = "pytest-8.3.4.tar.gz", hash = "sha256:965370d062bce11e73868e0335abac31b4d3de0e82f4007408d242b4f8610761"}, +] + +[[package]] +name = "pytest-cov" +version = "6.0.0" +requires_python = ">=3.9" +summary = "Pytest plugin for measuring coverage." +groups = ["qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "coverage[toml]>=7.5", + "pytest>=4.6", +] +files = [ + {file = "pytest-cov-6.0.0.tar.gz", hash = "sha256:fde0b595ca248bb8e2d76f020b465f3b107c9632e6a1d1705f17834c89dcadc0"}, + {file = "pytest_cov-6.0.0-py3-none-any.whl", hash = "sha256:eee6f1b9e61008bd34975a4d5bab25801eb31898b032dd55addc93e96fcaaa35"}, +] + +[[package]] +name = "python-dateutil" +version = "2.9.0.post0" +requires_python = "!=3.0.*,!=3.1.*,!=3.2.*,>=2.7" +summary = "Extensions to the standard Python datetime module" +groups = ["default", "docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "six>=1.5", +] +files = [ + {file = "python-dateutil-2.9.0.post0.tar.gz", hash = "sha256:37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3"}, + {file = "python_dateutil-2.9.0.post0-py2.py3-none-any.whl", hash = "sha256:a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427"}, +] + +[[package]] +name = "python-json-logger" +version = "2.0.7" +requires_python = ">=3.6" +summary = "A python library adding a json log formatter" +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "python-json-logger-2.0.7.tar.gz", hash = "sha256:23e7ec02d34237c5aa1e29a070193a4ea87583bb4e7f8fd06d3de8264c4b2e1c"}, + {file = "python_json_logger-2.0.7-py3-none-any.whl", hash = "sha256:f380b826a991ebbe3de4d897aeec42760035ac760345e57b812938dc8b35e2bd"}, +] + +[[package]] +name = "pytz" +version = "2024.2" +summary = "World timezone definitions, modern and historical" +groups = ["default"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "pytz-2024.2-py2.py3-none-any.whl", hash = "sha256:31c7c1817eb7fae7ca4b8c7ee50c72f93aa2dd863de768e1ef4245d426aa0725"}, + {file = "pytz-2024.2.tar.gz", hash = "sha256:2aa355083c50a0f93fa581709deac0c9ad65cca8a9e9beac660adcbd493c798a"}, +] + +[[package]] +name = "pyvista" +version = "0.44.2" +requires_python = ">=3.8" +summary = "Easier Pythonic interface to VTK" +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "matplotlib>=3.0.1", + "numpy>=1.21.0", + "pillow", + "pooch", + "scooby>=0.5.1", + "typing-extensions", + "vtk<9.4.0", +] +files = [ + {file = "pyvista-0.44.2-py3-none-any.whl", hash = "sha256:8530d35f57cdaa33507ac9aec19e3292be0bc9026b28e4f12df7e8054438d028"}, + {file = "pyvista-0.44.2.tar.gz", hash = "sha256:db65943c3c1c9ba49fe16f5a25a5bc23b74bf1ea7a38aae4ef9c4dc5838ccf5e"}, +] + +[[package]] +name = "pyvista" +version = "0.44.2" +extras = ["all"] +requires_python = ">=3.8" +summary = "Easier Pythonic interface to VTK" +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "pyvista==0.44.2", + "pyvista[colormaps,io,jupyter]", +] +files = [ + {file = "pyvista-0.44.2-py3-none-any.whl", hash = "sha256:8530d35f57cdaa33507ac9aec19e3292be0bc9026b28e4f12df7e8054438d028"}, + {file = "pyvista-0.44.2.tar.gz", hash = "sha256:db65943c3c1c9ba49fe16f5a25a5bc23b74bf1ea7a38aae4ef9c4dc5838ccf5e"}, +] + +[[package]] +name = "pyvista" +version = "0.44.2" +extras = ["colormaps", "io", "jupyter"] +requires_python = ">=3.8" +summary = "Easier Pythonic interface to VTK" +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "cmocean", + "colorcet", + "imageio", + "ipywidgets", + "jupyter-server-proxy", + "meshio>=5.2", + "nest-asyncio", + "pyvista==0.44.2", + "trame-client>=2.12.7", + "trame-server>=2.11.7", + "trame-vtk>=2.5.8", + "trame-vuetify>=2.3.1", + "trame>=2.5.2", +] +files = [ + {file = "pyvista-0.44.2-py3-none-any.whl", hash = "sha256:8530d35f57cdaa33507ac9aec19e3292be0bc9026b28e4f12df7e8054438d028"}, + {file = "pyvista-0.44.2.tar.gz", hash = "sha256:db65943c3c1c9ba49fe16f5a25a5bc23b74bf1ea7a38aae4ef9c4dc5838ccf5e"}, +] + +[[package]] +name = "pyvistaqt" +version = "0.11.1" +requires_python = ">=3.7" +summary = "pyvista qt plotter" +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "QtPy>=1.9.0", + "pyvista>=0.32.0", +] +files = [ + {file = "pyvistaqt-0.11.1-py3-none-any.whl", hash = "sha256:3ddc05418fcb297d471e7f7c0fdc89dbd5b6050653b4a86e66e5c1ce7e3563cc"}, + {file = "pyvistaqt-0.11.1.tar.gz", hash = "sha256:5403bfeb82cf063288107a9be9780ca3ca70948e73d33d16a65a83a711d51a36"}, +] + +[[package]] +name = "pywin32" +version = "306" +summary = "Python for Window Extensions" +groups = ["docs", "pyvista", "qa"] +marker = "sys_platform == \"win32\" and platform_python_implementation != \"PyPy\" and python_version < \"3.13\" and python_version >= \"3.9\" or platform_system == \"Windows\" and platform_python_implementation != \"PyPy\" and python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "pywin32-306-cp310-cp310-win_amd64.whl", hash = "sha256:84f4471dbca1887ea3803d8848a1616429ac94a4a8d05f4bc9c5dcfd42ca99c8"}, + {file = "pywin32-306-cp311-cp311-win_amd64.whl", hash = "sha256:a7639f51c184c0272e93f244eb24dafca9b1855707d94c192d4a0b4c01e1100e"}, + {file = "pywin32-306-cp312-cp312-win_amd64.whl", hash = "sha256:37257794c1ad39ee9be652da0462dc2e394c8159dfd913a8a4e8eb6fd346da0e"}, + {file = "pywin32-306-cp39-cp39-win_amd64.whl", hash = "sha256:39b61c15272833b5c329a2989999dcae836b1eed650252ab1b7bfbe1d59f30f4"}, +] + +[[package]] +name = "pywinpty" +version = "2.0.13" +requires_python = ">=3.8" +summary = "Pseudo terminal support for Windows from Python." +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\" and os_name == \"nt\"" +files = [ + {file = "pywinpty-2.0.13-cp310-none-win_amd64.whl", hash = "sha256:697bff211fb5a6508fee2dc6ff174ce03f34a9a233df9d8b5fe9c8ce4d5eaf56"}, + {file = "pywinpty-2.0.13-cp311-none-win_amd64.whl", hash = "sha256:b96fb14698db1284db84ca38c79f15b4cfdc3172065b5137383910567591fa99"}, + {file = "pywinpty-2.0.13-cp312-none-win_amd64.whl", hash = "sha256:2fd876b82ca750bb1333236ce98488c1be96b08f4f7647cfdf4129dfad83c2d4"}, + {file = "pywinpty-2.0.13-cp39-none-win_amd64.whl", hash = "sha256:71cb613a9ee24174730ac7ae439fd179ca34ccb8c5349e8d7b72ab5dea2c6f4b"}, + {file = "pywinpty-2.0.13.tar.gz", hash = "sha256:c34e32351a3313ddd0d7da23d27f835c860d32fe4ac814d372a3ea9594f41dde"}, +] + +[[package]] +name = "pyyaml" +version = "6.0.2" +requires_python = ">=3.8" +summary = "YAML parser and emitter for Python" +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "PyYAML-6.0.2-cp310-cp310-win_amd64.whl", hash = "sha256:a4d3091415f010369ae4ed1fc6b79def9416358877534caf6a0fdd2146c87a3e"}, + {file = "PyYAML-6.0.2-cp311-cp311-win_amd64.whl", hash = "sha256:e10ce637b18caea04431ce14fabcf5c64a1c61ec9c56b071a4b7ca131ca52d44"}, + {file = "PyYAML-6.0.2-cp312-cp312-win_amd64.whl", hash = "sha256:7e7401d0de89a9a855c839bc697c079a4af81cf878373abd7dc625847d25cbd8"}, + {file = "PyYAML-6.0.2-cp39-cp39-win_amd64.whl", hash = "sha256:39693e1f8320ae4f43943590b49779ffb98acb81f788220ea932a6b6c51004d8"}, + {file = "pyyaml-6.0.2.tar.gz", hash = "sha256:d584d9ec91ad65861cc08d42e834324ef890a082e591037abe114850ff7bbc3e"}, +] + +[[package]] +name = "pyzmq" +version = "26.2.0" +requires_python = ">=3.7" +summary = "Python bindings for 0MQ" +groups = ["docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "cffi; implementation_name == \"pypy\"", +] +files = [ + {file = "pyzmq-26.2.0-cp310-cp310-win_amd64.whl", hash = "sha256:49d34ab71db5a9c292a7644ce74190b1dd5a3475612eefb1f8be1d6961441971"}, + {file = "pyzmq-26.2.0-cp311-cp311-win_amd64.whl", hash = "sha256:5a509df7d0a83a4b178d0f937ef14286659225ef4e8812e05580776c70e155d5"}, + {file = "pyzmq-26.2.0-cp312-cp312-win_amd64.whl", hash = "sha256:2a50625acdc7801bc6f74698c5c583a491c61d73c6b7ea4dee3901bb99adb27a"}, + {file = "pyzmq-26.2.0-cp39-cp39-win_amd64.whl", hash = "sha256:e6fa2e3e683f34aea77de8112f6483803c96a44fd726d7358b9888ae5bb394ec"}, + {file = "pyzmq-26.2.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:90412f2db8c02a3864cbfc67db0e3dcdbda336acf1c469526d3e869394fe001c"}, + {file = "pyzmq-26.2.0-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:4f78c88905461a9203eac9faac157a2a0dbba84a0fd09fd29315db27be40af9f"}, + {file = "pyzmq-26.2.0.tar.gz", hash = "sha256:070672c258581c8e4f640b5159297580a9974b026043bd4ab0470be9ed324f1f"}, +] + +[[package]] +name = "qtpy" +version = "2.4.1" +requires_python = ">=3.7" +summary = "Provides an abstraction layer on top of the various Qt bindings (PyQt5/6 and PySide2/6)." +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "packaging", +] +files = [ + {file = "QtPy-2.4.1-py3-none-any.whl", hash = "sha256:1c1d8c4fa2c884ae742b069151b0abe15b3f70491f3972698c683b8e38de839b"}, + {file = "QtPy-2.4.1.tar.gz", hash = "sha256:a5a15ffd519550a1361bdc56ffc07fda56a6af7292f17c7b395d4083af632987"}, +] + +[[package]] +name = "referencing" +version = "0.35.1" +requires_python = ">=3.8" +summary = "JSON Referencing + Python" +groups = ["docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "attrs>=22.2.0", + "rpds-py>=0.7.0", +] +files = [ + {file = "referencing-0.35.1-py3-none-any.whl", hash = "sha256:eda6d3234d62814d1c64e305c1331c9a3a6132da475ab6382eaa997b21ee75de"}, + {file = "referencing-0.35.1.tar.gz", hash = "sha256:25b42124a6c8b632a425174f24087783efb348a6f1e0008e63cd4466fedf703c"}, +] + +[[package]] +name = "requests" +version = "2.32.3" +requires_python = ">=3.8" +summary = "Python HTTP for Humans." +groups = ["docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "certifi>=2017.4.17", + "charset-normalizer<4,>=2", + "idna<4,>=2.5", + "urllib3<3,>=1.21.1", +] +files = [ + {file = "requests-2.32.3-py3-none-any.whl", hash = "sha256:70761cfe03c773ceb22aa2f671b4757976145175cdfca038c02654d061d6dcc6"}, + {file = "requests-2.32.3.tar.gz", hash = "sha256:55365417734eb18255590a9ff9eb97e9e1da868d4ccd6402399eaf68af20a760"}, +] + +[[package]] +name = "rfc3339-validator" +version = "0.1.4" +requires_python = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*" +summary = "A pure python RFC3339 validator" +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "six", +] +files = [ + {file = "rfc3339_validator-0.1.4-py2.py3-none-any.whl", hash = "sha256:24f6ec1eda14ef823da9e36ec7113124b39c04d50a4d3d3a3c2859577e7791fa"}, + {file = "rfc3339_validator-0.1.4.tar.gz", hash = "sha256:138a2abdf93304ad60530167e51d2dfb9549521a836871b88d7f4695d0022f6b"}, +] + +[[package]] +name = "rfc3986-validator" +version = "0.1.1" +requires_python = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*" +summary = "Pure python rfc3986 validator" +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "rfc3986_validator-0.1.1-py2.py3-none-any.whl", hash = "sha256:2f235c432ef459970b4306369336b9d5dbdda31b510ca1e327636e01f528bfa9"}, + {file = "rfc3986_validator-0.1.1.tar.gz", hash = "sha256:3d44bde7921b3b9ec3ae4e3adca370438eccebc676456449b145d533b240d055"}, +] + +[[package]] +name = "rich" +version = "13.8.1" +requires_python = ">=3.7.0" +summary = "Render rich text, tables, progress bars, syntax highlighting, markdown and more to the terminal" +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "markdown-it-py>=2.2.0", + "pygments<3.0.0,>=2.13.0", + "typing-extensions<5.0,>=4.0.0; python_version < \"3.9\"", +] +files = [ + {file = "rich-13.8.1-py3-none-any.whl", hash = "sha256:1760a3c0848469b97b558fc61c85233e3dafb69c7a071b4d60c38099d3cd4c06"}, + {file = "rich-13.8.1.tar.gz", hash = "sha256:8260cda28e3db6bf04d2d1ef4dbc03ba80a824c88b0e7668a0f23126a424844a"}, +] + +[[package]] +name = "rpds-py" +version = "0.20.0" +requires_python = ">=3.8" +summary = "Python bindings to Rust's persistent data structures (rpds)" +groups = ["docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "rpds_py-0.20.0-cp310-none-win_amd64.whl", hash = "sha256:238a2d5b1cad28cdc6ed15faf93a998336eb041c4e440dd7f902528b8891b399"}, + {file = "rpds_py-0.20.0-cp311-none-win_amd64.whl", hash = "sha256:c638144ce971df84650d3ed0096e2ae7af8e62ecbbb7b201c8935c370df00a2c"}, + {file = "rpds_py-0.20.0-cp312-none-win_amd64.whl", hash = "sha256:0e13e6952ef264c40587d510ad676a988df19adea20444c2b295e536457bc585"}, + {file = "rpds_py-0.20.0-cp39-none-win_amd64.whl", hash = "sha256:e6900ecdd50ce0facf703f7a00df12374b74bbc8ad9fe0f6559947fb20f82364"}, + {file = "rpds_py-0.20.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:bb273176be34a746bdac0b0d7e4e2c467323d13640b736c4c477881a3220a989"}, + {file = "rpds_py-0.20.0-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:fdfc3a892927458d98f3d55428ae46b921d1f7543b89382fdb483f5640daaec8"}, + {file = "rpds_py-0.20.0.tar.gz", hash = "sha256:d72a210824facfdaf8768cf2d7ca25a042c30320b3020de2fa04640920d4e121"}, +] + +[[package]] +name = "scipy" +version = "1.13.1" +requires_python = ">=3.9" +summary = "Fundamental algorithms for scientific computing in Python" +groups = ["default"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "numpy<2.3,>=1.22.4", +] +files = [ + {file = "scipy-1.13.1-cp310-cp310-win_amd64.whl", hash = "sha256:2831f0dc9c5ea9edd6e51e6e769b655f08ec6db6e2e10f86ef39bd32eb11da54"}, + {file = "scipy-1.13.1-cp311-cp311-win_amd64.whl", hash = "sha256:5713f62f781eebd8d597eb3f88b8bf9274e79eeabf63afb4a737abc6c84ad37b"}, + {file = "scipy-1.13.1-cp312-cp312-win_amd64.whl", hash = "sha256:cdd7dacfb95fea358916410ec61bbc20440f7860333aee6d882bb8046264e949"}, + {file = "scipy-1.13.1-cp39-cp39-win_amd64.whl", hash = "sha256:392e4ec766654852c25ebad4f64e4e584cf19820b980bc04960bca0b0cd6eaa2"}, + {file = "scipy-1.13.1.tar.gz", hash = "sha256:095a87a0312b08dfd6a6155cbbd310a8c51800fc931b8c0b84003014b874ed3c"}, +] + +[[package]] +name = "scooby" +version = "0.10.0" +requires_python = ">=3.8" +summary = "A Great Dane turned Python environment detective" +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "scooby-0.10.0-py3-none-any.whl", hash = "sha256:0a3d7e304f8ebb16f69ff7f6360c345d7f50b45f2ddbf7c3d18a6a0dc2cb03a6"}, + {file = "scooby-0.10.0.tar.gz", hash = "sha256:7ea33c262c0cc6a33c6eeeb5648df787be4f22660e53c114e5fff1b811a8854f"}, +] + +[[package]] +name = "send2trash" +version = "1.8.3" +requires_python = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7" +summary = "Send file to trash natively under Mac OS X, Windows and Linux" +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "Send2Trash-1.8.3-py3-none-any.whl", hash = "sha256:0c31227e0bd08961c7665474a3d1ef7193929fedda4233843689baa056be46c9"}, + {file = "Send2Trash-1.8.3.tar.gz", hash = "sha256:b18e7a3966d99871aefeb00cfbcfdced55ce4871194810fc71f4aa484b953abf"}, +] + +[[package]] +name = "setuptools" +version = "74.1.2" +requires_python = ">=3.8" +summary = "Easily download, build, install, upgrade, and uninstall Python packages" +groups = ["qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "setuptools-74.1.2-py3-none-any.whl", hash = "sha256:5f4c08aa4d3ebcb57a50c33b1b07e94315d7fc7230f7115e47fc99776c8ce308"}, + {file = "setuptools-74.1.2.tar.gz", hash = "sha256:95b40ed940a1c67eb70fc099094bd6e99c6ee7c23aa2306f4d2697ba7916f9c6"}, +] + +[[package]] +name = "simpervisor" +version = "1.0.0" +requires_python = ">=3.8" +summary = "Simple async process supervisor" +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "simpervisor-1.0.0-py3-none-any.whl", hash = "sha256:3e313318264559beea3f475ead202bc1cd58a2f1288363abb5657d306c5b8388"}, + {file = "simpervisor-1.0.0.tar.gz", hash = "sha256:7eb87ca86d5e276976f5bb0290975a05d452c6a7b7f58062daea7d8369c823c1"}, +] + +[[package]] +name = "six" +version = "1.16.0" +requires_python = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*" +summary = "Python 2 and 3 compatibility utilities" +groups = ["default", "docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "six-1.16.0-py2.py3-none-any.whl", hash = "sha256:8abb2f1d86890a2dfb989f9a77cfcfd3e47c2a354b01111771326f8aa26e0254"}, + {file = "six-1.16.0.tar.gz", hash = "sha256:1e61c37477a1626458e36f7b1d82aa5c9b094fa4802892072e49de9c60c4c926"}, +] + +[[package]] +name = "sniffio" +version = "1.3.1" +requires_python = ">=3.7" +summary = "Sniff out which async library your code is running under" +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "sniffio-1.3.1-py3-none-any.whl", hash = "sha256:2f6da418d1f1e0fddd844478f41680e794e6051915791a034ff65e5f100525a2"}, + {file = "sniffio-1.3.1.tar.gz", hash = "sha256:f4324edc670a0f49750a81b895f35c3adb843cca46f0530f79fc1babb23789dc"}, +] + +[[package]] +name = "snowballstemmer" +version = "2.2.0" +summary = "This package provides 29 stemmers for 28 languages generated from Snowball algorithms." +groups = ["docs"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "snowballstemmer-2.2.0-py2.py3-none-any.whl", hash = "sha256:c8e1716e83cc398ae16824e5572ae04e0d9fc2c6b985fb0f900f5f0c96ecba1a"}, + {file = "snowballstemmer-2.2.0.tar.gz", hash = "sha256:09b16deb8547d3412ad7b590689584cd0fe25ec8db3be37788be3810cbf19cb1"}, +] + +[[package]] +name = "soupsieve" +version = "2.6" +requires_python = ">=3.8" +summary = "A modern CSS selector implementation for Beautiful Soup." +groups = ["docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "soupsieve-2.6-py3-none-any.whl", hash = "sha256:e72c4ff06e4fb6e4b5a9f0f55fe6e81514581fca1515028625d0f299c602ccc9"}, + {file = "soupsieve-2.6.tar.gz", hash = "sha256:e2e68417777af359ec65daac1057404a3c8a5455bb8abc36f1a9866ab1a51abb"}, +] + +[[package]] +name = "sphinx" +version = "7.4.7" +requires_python = ">=3.9" +summary = "Python documentation generator" +groups = ["docs"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "Jinja2>=3.1", + "Pygments>=2.17", + "alabaster~=0.7.14", + "babel>=2.13", + "colorama>=0.4.6; sys_platform == \"win32\"", + "docutils<0.22,>=0.20", + "imagesize>=1.3", + "importlib-metadata>=6.0; python_version < \"3.10\"", + "packaging>=23.0", + "requests>=2.30.0", + "snowballstemmer>=2.2", + "sphinxcontrib-applehelp", + "sphinxcontrib-devhelp", + "sphinxcontrib-htmlhelp>=2.0.0", + "sphinxcontrib-jsmath", + "sphinxcontrib-qthelp", + "sphinxcontrib-serializinghtml>=1.1.9", + "tomli>=2; python_version < \"3.11\"", +] +files = [ + {file = "sphinx-7.4.7-py3-none-any.whl", hash = "sha256:c2419e2135d11f1951cd994d6eb18a1835bd8fdd8429f9ca375dc1f3281bd239"}, + {file = "sphinx-7.4.7.tar.gz", hash = "sha256:242f92a7ea7e6c5b406fdc2615413890ba9f699114a9c09192d7dfead2ee9cfe"}, +] + +[[package]] +name = "sphinx-rtd-theme" +version = "3.0.2" +requires_python = ">=3.8" +summary = "Read the Docs theme for Sphinx" +groups = ["docs"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "docutils<0.22,>0.18", + "sphinx<9,>=6", + "sphinxcontrib-jquery<5,>=4", +] +files = [ + {file = "sphinx_rtd_theme-3.0.2-py2.py3-none-any.whl", hash = "sha256:422ccc750c3a3a311de4ae327e82affdaf59eb695ba4936538552f3b00f4ee13"}, + {file = "sphinx_rtd_theme-3.0.2.tar.gz", hash = "sha256:b7457bc25dda723b20b086a670b9953c859eab60a2a03ee8eb2bb23e176e5f85"}, +] + +[[package]] +name = "sphinxcontrib-applehelp" +version = "2.0.0" +requires_python = ">=3.9" +summary = "sphinxcontrib-applehelp is a Sphinx extension which outputs Apple help books" +groups = ["docs"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "sphinxcontrib_applehelp-2.0.0-py3-none-any.whl", hash = "sha256:4cd3f0ec4ac5dd9c17ec65e9ab272c9b867ea77425228e68ecf08d6b28ddbdb5"}, + {file = "sphinxcontrib_applehelp-2.0.0.tar.gz", hash = "sha256:2f29ef331735ce958efa4734873f084941970894c6090408b079c61b2e1c06d1"}, +] + +[[package]] +name = "sphinxcontrib-devhelp" +version = "2.0.0" +requires_python = ">=3.9" +summary = "sphinxcontrib-devhelp is a sphinx extension which outputs Devhelp documents" +groups = ["docs"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "sphinxcontrib_devhelp-2.0.0-py3-none-any.whl", hash = "sha256:aefb8b83854e4b0998877524d1029fd3e6879210422ee3780459e28a1f03a8a2"}, + {file = "sphinxcontrib_devhelp-2.0.0.tar.gz", hash = "sha256:411f5d96d445d1d73bb5d52133377b4248ec79db5c793ce7dbe59e074b4dd1ad"}, +] + +[[package]] +name = "sphinxcontrib-htmlhelp" +version = "2.1.0" +requires_python = ">=3.9" +summary = "sphinxcontrib-htmlhelp is a sphinx extension which renders HTML help files" +groups = ["docs"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "sphinxcontrib_htmlhelp-2.1.0-py3-none-any.whl", hash = "sha256:166759820b47002d22914d64a075ce08f4c46818e17cfc9470a9786b759b19f8"}, + {file = "sphinxcontrib_htmlhelp-2.1.0.tar.gz", hash = "sha256:c9e2916ace8aad64cc13a0d233ee22317f2b9025b9cf3295249fa985cc7082e9"}, +] + +[[package]] +name = "sphinxcontrib-jquery" +version = "4.1" +requires_python = ">=2.7" +summary = "Extension to include jQuery on newer Sphinx releases" +groups = ["docs"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "Sphinx>=1.8", +] +files = [ + {file = "sphinxcontrib-jquery-4.1.tar.gz", hash = "sha256:1620739f04e36a2c779f1a131a2dfd49b2fd07351bf1968ced074365933abc7a"}, + {file = "sphinxcontrib_jquery-4.1-py2.py3-none-any.whl", hash = "sha256:f936030d7d0147dd026a4f2b5a57343d233f1fc7b363f68b3d4f1cb0993878ae"}, +] + +[[package]] +name = "sphinxcontrib-jsmath" +version = "1.0.1" +requires_python = ">=3.5" +summary = "A sphinx extension which renders display math in HTML via JavaScript" +groups = ["docs"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "sphinxcontrib-jsmath-1.0.1.tar.gz", hash = "sha256:a9925e4a4587247ed2191a22df5f6970656cb8ca2bd6284309578f2153e0c4b8"}, + {file = "sphinxcontrib_jsmath-1.0.1-py2.py3-none-any.whl", hash = "sha256:2ec2eaebfb78f3f2078e73666b1415417a116cc848b72e5172e596c871103178"}, +] + +[[package]] +name = "sphinxcontrib-qthelp" +version = "2.0.0" +requires_python = ">=3.9" +summary = "sphinxcontrib-qthelp is a sphinx extension which outputs QtHelp documents" +groups = ["docs"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "sphinxcontrib_qthelp-2.0.0-py3-none-any.whl", hash = "sha256:b18a828cdba941ccd6ee8445dbe72ffa3ef8cbe7505d8cd1fa0d42d3f2d5f3eb"}, + {file = "sphinxcontrib_qthelp-2.0.0.tar.gz", hash = "sha256:4fe7d0ac8fc171045be623aba3e2a8f613f8682731f9153bb2e40ece16b9bbab"}, +] + +[[package]] +name = "sphinxcontrib-serializinghtml" +version = "2.0.0" +requires_python = ">=3.9" +summary = "sphinxcontrib-serializinghtml is a sphinx extension which outputs \"serialized\" HTML files (json and pickle)" +groups = ["docs"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "sphinxcontrib_serializinghtml-2.0.0-py3-none-any.whl", hash = "sha256:6e2cb0eef194e10c27ec0023bfeb25badbbb5868244cf5bc5bdc04e4464bf331"}, + {file = "sphinxcontrib_serializinghtml-2.0.0.tar.gz", hash = "sha256:e9d912827f872c029017a53f0ef2180b327c3f7fd23c87229f7a8e8b70031d4d"}, +] + +[[package]] +name = "stack-data" +version = "0.6.3" +summary = "Extract data from python stack frames and tracebacks for informative displays" +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "asttokens>=2.1.0", + "executing>=1.2.0", + "pure-eval", +] +files = [ + {file = "stack_data-0.6.3-py3-none-any.whl", hash = "sha256:d5558e0c25a4cb0853cddad3d77da9891a08cb85dd9f9f91b9f8cd66e511e695"}, + {file = "stack_data-0.6.3.tar.gz", hash = "sha256:836a778de4fec4dcd1dcd89ed8abff8a221f58308462e1c4aa2a3cf30148f0b9"}, +] + +[[package]] +name = "terminado" +version = "0.18.1" +requires_python = ">=3.8" +summary = "Tornado websocket backend for the Xterm.js Javascript terminal emulator library." +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "ptyprocess; os_name != \"nt\"", + "pywinpty>=1.1.0; os_name == \"nt\"", + "tornado>=6.1.0", +] +files = [ + {file = "terminado-0.18.1-py3-none-any.whl", hash = "sha256:a4468e1b37bb318f8a86514f65814e1afc977cf29b3992a4500d9dd305dcceb0"}, + {file = "terminado-0.18.1.tar.gz", hash = "sha256:de09f2c4b85de4765f7714688fff57d3e75bad1f909b589fde880460c753fd2e"}, +] + +[[package]] +name = "tinycss2" +version = "1.3.0" +requires_python = ">=3.8" +summary = "A tiny CSS parser" +groups = ["docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "webencodings>=0.4", +] +files = [ + {file = "tinycss2-1.3.0-py3-none-any.whl", hash = "sha256:54a8dbdffb334d536851be0226030e9505965bb2f30f21a4a82c55fb2a80fae7"}, + {file = "tinycss2-1.3.0.tar.gz", hash = "sha256:152f9acabd296a8375fbca5b84c961ff95971fcfc32e79550c8df8e29118c54d"}, +] + +[[package]] +name = "tomli" +version = "2.2.1" +requires_python = ">=3.8" +summary = "A lil' TOML parser" +groups = ["docs", "qa"] +marker = "python_version < \"3.11\" and python_version >= \"3.9\"" +files = [ + {file = "tomli-2.2.1-cp311-cp311-win_amd64.whl", hash = "sha256:2d0f2fdd22b02c6d81637a3c95f8cd77f995846af7414c5c4b8d0545afa1bc4b"}, + {file = "tomli-2.2.1-cp312-cp312-win_amd64.whl", hash = "sha256:7fc04e92e1d624a4a63c76474610238576942d6b8950a2d7f908a340494e67e4"}, + {file = "tomli-2.2.1-py3-none-any.whl", hash = "sha256:cb55c73c5f4408779d0cf3eef9f762b9c9f147a77de7b258bef0a5628adc85cc"}, + {file = "tomli-2.2.1.tar.gz", hash = "sha256:cd45e1dc79c835ce60f7404ec8119f2eb06d38b1deba146f07ced3bbc44505ff"}, +] + +[[package]] +name = "tornado" +version = "6.4.2" +requires_python = ">=3.8" +summary = "Tornado is a Python web framework and asynchronous networking library, originally developed at FriendFeed." +groups = ["docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "tornado-6.4.2-cp38-abi3-win_amd64.whl", hash = "sha256:908b71bf3ff37d81073356a5fadcc660eb10c1476ee6e2725588626ce7e5ca38"}, + {file = "tornado-6.4.2.tar.gz", hash = "sha256:92bad5b4746e9879fd7bf1eb21dce4e3fc5128d71601f80005afa39237ad620b"}, +] + +[[package]] +name = "tox" +version = "4.24.1" +requires_python = ">=3.8" +summary = "tox is a generic virtualenv management and test command line tool" +groups = ["qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "cachetools>=5.5", + "chardet>=5.2", + "colorama>=0.4.6", + "filelock>=3.16.1", + "packaging>=24.2", + "platformdirs>=4.3.6", + "pluggy>=1.5", + "pyproject-api>=1.8", + "tomli>=2.1; python_version < \"3.11\"", + "typing-extensions>=4.12.2; python_version < \"3.11\"", + "virtualenv>=20.27.1", +] +files = [ + {file = "tox-4.24.1-py3-none-any.whl", hash = "sha256:57ba7df7d199002c6df8c2db9e6484f3de6ca8f42013c083ea2d4d1e5c6bdc75"}, + {file = "tox-4.24.1.tar.gz", hash = "sha256:083a720adbc6166fff0b7d1df9d154f9d00bfccb9403b8abf6bc0ee435d6a62e"}, +] + +[[package]] +name = "tqdm" +version = "4.67.1" +requires_python = ">=3.7" +summary = "Fast, Extensible Progress Meter" +groups = ["default"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "colorama; platform_system == \"Windows\"", +] +files = [ + {file = "tqdm-4.67.1-py3-none-any.whl", hash = "sha256:26445eca388f82e72884e0d580d5464cd801a3ea01e63e5601bdff9ba6a48de2"}, + {file = "tqdm-4.67.1.tar.gz", hash = "sha256:f8aef9c52c08c13a65f30ea34f4e5aac3fd1a34959879d7e59e63027286627f2"}, +] + +[[package]] +name = "traitlets" +version = "5.14.3" +requires_python = ">=3.8" +summary = "Traitlets Python configuration system" +groups = ["docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "traitlets-5.14.3-py3-none-any.whl", hash = "sha256:b74e89e397b1ed28cc831db7aea759ba6640cb3de13090ca145426688ff1ac4f"}, + {file = "traitlets-5.14.3.tar.gz", hash = "sha256:9ed0579d3502c94b4b3732ac120375cda96f923114522847de4b3bb98b96b6b7"}, +] + +[[package]] +name = "trame" +version = "3.6.5" +summary = "Trame, a framework to build applications in plain Python" +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "trame-client<4,>=3", + "trame-server<4,>=3", + "wslink>=2.1.3", +] +files = [ + {file = "trame-3.6.5-py3-none-any.whl", hash = "sha256:58b5be29287d275dbd2be15b4e453c788361f640253ad153ca99fb3eb28e00f3"}, + {file = "trame-3.6.5.tar.gz", hash = "sha256:fc26a7067f94377e01263facb4cd40b111d799d970b5fc8e2aecb52e60378959"}, +] + +[[package]] +name = "trame-client" +version = "3.2.5" +summary = "Internal client of trame" +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "trame-client-3.2.5.tar.gz", hash = "sha256:6f81c2a78389f1962bec38a318b0de47f241dae7778b25dba75fa3ed4d58bd33"}, + {file = "trame_client-3.2.5-py3-none-any.whl", hash = "sha256:023e062175fef67d45a65ac7a367b0e3468f6746c4f8c7a7aa3fe8e82273c62a"}, +] + +[[package]] +name = "trame-server" +version = "3.1.2" +summary = "Internal server side implementation of trame" +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "more-itertools", + "wslink<3,>=2", +] +files = [ + {file = "trame-server-3.1.2.tar.gz", hash = "sha256:03bdd81e0132fb55de7b493c7ebdc4c21f6b0003960bceb3adca258fc432211f"}, + {file = "trame_server-3.1.2-py3-none-any.whl", hash = "sha256:b43d11edfbca012ac34a724dc751b6ecfaecd7d636eaea4ab0650d2adc9e3771"}, +] + +[[package]] +name = "trame-vtk" +version = "2.8.10" +summary = "VTK widgets for trame" +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "trame-client", +] +files = [ + {file = "trame-vtk-2.8.10.tar.gz", hash = "sha256:4d8e38f7c1d5be8eafc28254bd5bd5dc5d4b336a334b944fc9383c9624184b5e"}, + {file = "trame_vtk-2.8.10-py3-none-any.whl", hash = "sha256:0fe850d1358193c1d73c9af87715d7877210df53edf4e4d468ba396c0845765c"}, +] + +[[package]] +name = "trame-vuetify" +version = "2.7.1" +summary = "Vuetify widgets for trame" +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "trame-client", +] +files = [ + {file = "trame-vuetify-2.7.1.tar.gz", hash = "sha256:48443910a3a53b9fa040e05b261fce9326fe95309b3798d49f0d6aec84cbfdf8"}, + {file = "trame_vuetify-2.7.1-py3-none-any.whl", hash = "sha256:c6bfe3be49ac8b7aa354e4e2c1d92f2c2e9680eea563f46146eef6968a66c2de"}, +] + +[[package]] +name = "types-python-dateutil" +version = "2.9.0.20240906" +requires_python = ">=3.8" +summary = "Typing stubs for python-dateutil" +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "types-python-dateutil-2.9.0.20240906.tar.gz", hash = "sha256:9706c3b68284c25adffc47319ecc7947e5bb86b3773f843c73906fd598bc176e"}, + {file = "types_python_dateutil-2.9.0.20240906-py3-none-any.whl", hash = "sha256:27c8cc2d058ccb14946eebcaaa503088f4f6dbc4fb6093d3d456a49aef2753f6"}, +] + +[[package]] +name = "typing-extensions" +version = "4.12.2" +requires_python = ">=3.8" +summary = "Backported and Experimental Type Hints for Python 3.8+" +groups = ["default", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "typing_extensions-4.12.2-py3-none-any.whl", hash = "sha256:04e5ca0351e0f3f85c6853954072df659d0d13fac324d0072316b67d7794700d"}, + {file = "typing_extensions-4.12.2.tar.gz", hash = "sha256:1a7ead55c7e559dd4dee8856e3a88b41225abfe1ce8df57b7c13915fe121ffb8"}, +] + +[[package]] +name = "tzdata" +version = "2024.1" +requires_python = ">=2" +summary = "Provider of IANA time zone data" +groups = ["default"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "tzdata-2024.1-py2.py3-none-any.whl", hash = "sha256:9068bc196136463f5245e51efda838afa15aaeca9903f49050dfa2679db4d252"}, + {file = "tzdata-2024.1.tar.gz", hash = "sha256:2674120f8d891909751c38abcdfd386ac0a5a1127954fbc332af6b5ceae07efd"}, +] + +[[package]] +name = "uri-template" +version = "1.3.0" +requires_python = ">=3.7" +summary = "RFC 6570 URI Template Processor" +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "uri-template-1.3.0.tar.gz", hash = "sha256:0e00f8eb65e18c7de20d595a14336e9f337ead580c70934141624b6d1ffdacc7"}, + {file = "uri_template-1.3.0-py3-none-any.whl", hash = "sha256:a44a133ea12d44a0c0f06d7d42a52d71282e77e2f937d8abd5655b8d56fc1363"}, +] + +[[package]] +name = "urllib3" +version = "2.2.2" +requires_python = ">=3.8" +summary = "HTTP library with thread-safe connection pooling, file post, and more." +groups = ["docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "urllib3-2.2.2-py3-none-any.whl", hash = "sha256:a448b2f64d686155468037e1ace9f2d2199776e17f0a46610480d311f73e3472"}, + {file = "urllib3-2.2.2.tar.gz", hash = "sha256:dd505485549a7a552833da5e6063639d0d177c04f23bc3864e41e5dc5f612168"}, +] + +[[package]] +name = "virtualenv" +version = "20.29.1" +requires_python = ">=3.8" +summary = "Virtual Python Environment builder" +groups = ["qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "distlib<1,>=0.3.7", + "filelock<4,>=3.12.2", + "importlib-metadata>=6.6; python_version < \"3.8\"", + "platformdirs<5,>=3.9.1", +] +files = [ + {file = "virtualenv-20.29.1-py3-none-any.whl", hash = "sha256:4e4cb403c0b0da39e13b46b1b2476e505cb0046b25f242bee80f62bf990b2779"}, + {file = "virtualenv-20.29.1.tar.gz", hash = "sha256:b8b8970138d32fb606192cb97f6cd4bb644fa486be9308fb9b63f81091b5dc35"}, +] + +[[package]] +name = "vtk" +version = "9.3.1" +summary = "VTK is an open-source toolkit for 3D computer graphics, image processing, and visualization" +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "matplotlib>=2.0.0", +] +files = [ + {file = "vtk-9.3.1-cp310-cp310-win_amd64.whl", hash = "sha256:b8feed5029486703f4f8f81d8544a30d1788de87dc3396e16a281c343e1ac1cc"}, + {file = "vtk-9.3.1-cp311-cp311-win_amd64.whl", hash = "sha256:59cc043f611e3eca2870cc50f27e67852a182857de322415e942bdc133594acd"}, + {file = "vtk-9.3.1-cp312-cp312-win_amd64.whl", hash = "sha256:685988e09070e06c8605886591698fd42d8225489509b6537a5046cd034cc93e"}, + {file = "vtk-9.3.1-cp39-cp39-win_amd64.whl", hash = "sha256:6dee68abcd15603ad8ef6cef21fb13e2996d520a16880780abc41eb409dbec0c"}, +] + +[[package]] +name = "wcwidth" +version = "0.2.13" +summary = "Measures the displayed width of unicode strings in a terminal" +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "backports-functools-lru-cache>=1.2.1; python_version < \"3.2\"", +] +files = [ + {file = "wcwidth-0.2.13-py2.py3-none-any.whl", hash = "sha256:3da69048e4540d84af32131829ff948f1e022c1c6bdb8d6102117aac784f6859"}, + {file = "wcwidth-0.2.13.tar.gz", hash = "sha256:72ea0c06399eb286d978fdedb6923a9eb47e1c486ce63e9b4e64fc18303972b5"}, +] + +[[package]] +name = "webcolors" +version = "24.8.0" +requires_python = ">=3.8" +summary = "A library for working with the color formats defined by HTML and CSS." +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "webcolors-24.8.0-py3-none-any.whl", hash = "sha256:fc4c3b59358ada164552084a8ebee637c221e4059267d0f8325b3b560f6c7f0a"}, + {file = "webcolors-24.8.0.tar.gz", hash = "sha256:08b07af286a01bcd30d583a7acadf629583d1f79bfef27dd2c2c5c263817277d"}, +] + +[[package]] +name = "webencodings" +version = "0.5.1" +summary = "Character encoding aliases for legacy web content" +groups = ["docs", "pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "webencodings-0.5.1-py2.py3-none-any.whl", hash = "sha256:a0af1213f3c2226497a97e2b3aa01a7e4bee4f403f95be16fc9acd2947514a78"}, + {file = "webencodings-0.5.1.tar.gz", hash = "sha256:b36a1c245f2d304965eb4e0a82848379241dc04b865afcc4aab16748587e1923"}, +] + +[[package]] +name = "websocket-client" +version = "1.8.0" +requires_python = ">=3.8" +summary = "WebSocket client for Python with low level API options" +groups = ["pyvista", "qa"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "websocket_client-1.8.0-py3-none-any.whl", hash = "sha256:17b44cc997f5c498e809b22cdf2d9c7a9e71c02c8cc2b6c56e7c2d1239bfa526"}, + {file = "websocket_client-1.8.0.tar.gz", hash = "sha256:3239df9f44da632f96012472805d40a23281a991027ce11d2f45a6f24ac4c3da"}, +] + +[[package]] +name = "widgetsnbextension" +version = "4.0.13" +requires_python = ">=3.7" +summary = "Jupyter interactive widgets for Jupyter Notebook" +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +files = [ + {file = "widgetsnbextension-4.0.13-py3-none-any.whl", hash = "sha256:74b2692e8500525cc38c2b877236ba51d34541e6385eeed5aec15a70f88a6c71"}, + {file = "widgetsnbextension-4.0.13.tar.gz", hash = "sha256:ffcb67bc9febd10234a362795f643927f4e0c05d9342c727b65d2384f8feacb6"}, +] + +[[package]] +name = "wslink" +version = "2.1.3" +summary = "Python/JavaScript library for communicating over WebSocket" +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "aiohttp<4", + "msgpack<2,>=1", +] +files = [ + {file = "wslink-2.1.3-py3-none-any.whl", hash = "sha256:a4a3689a30dd108255560e2f56903003355f4e0f3f6e5f12033a6de108bba18a"}, + {file = "wslink-2.1.3.tar.gz", hash = "sha256:528d008f1a6110bc8141c32588e43b16ff438cedb80c5bb85e9ef92ae753c98e"}, +] + +[[package]] +name = "yarl" +version = "1.18.3" +requires_python = ">=3.9" +summary = "Yet another URL library" +groups = ["pyvista"] +marker = "python_version < \"3.13\" and python_version >= \"3.9\"" +dependencies = [ + "idna>=2.0", + "multidict>=4.0", + "propcache>=0.2.0", +] +files = [ + {file = "yarl-1.18.3-cp310-cp310-win_amd64.whl", hash = "sha256:93b2e109287f93db79210f86deb6b9bbb81ac32fc97236b16f7433db7fc437d8"}, + {file = "yarl-1.18.3-cp311-cp311-win_amd64.whl", hash = "sha256:b9d60031cf568c627d028239693fd718025719c02c9f55df0a53e587aab951b5"}, + {file = "yarl-1.18.3-cp312-cp312-win_amd64.whl", hash = "sha256:7e2ee16578af3b52ac2f334c3b1f92262f47e02cc6193c598502bd46f5cd1477"}, + {file = "yarl-1.18.3-cp39-cp39-win_amd64.whl", hash = "sha256:ba87babd629f8af77f557b61e49e7c7cac36f22f871156b91e10a6e9d4f829e9"}, + {file = "yarl-1.18.3-py3-none-any.whl", hash = "sha256:b57f4f58099328dfb26c6a771d09fb20dbbae81d20cfb66141251ea063bd101b"}, + {file = "yarl-1.18.3.tar.gz", hash = "sha256:ac1801c45cbf77b6c99242eeff4fffb5e4e73a800b5c4ad4fc0be5def634d2e1"}, +] + +[[package]] +name = "zipp" +version = "3.20.1" +requires_python = ">=3.8" +summary = "Backport of pathlib-compatible object wrapper for zip files" +groups = ["default", "docs", "pyvista", "qa"] +marker = "python_version < \"3.10\" and python_version >= \"3.9\"" +files = [ + {file = "zipp-3.20.1-py3-none-any.whl", hash = "sha256:9960cd8967c8f85a56f920d5d507274e74f9ff813a0ab8889a5b5be2daf44064"}, + {file = "zipp-3.20.1.tar.gz", hash = "sha256:c22b14cc4763c5a5b04134207736c107db42e9d3ef2d9779d465f5f1bcba572b"}, +] diff --git a/pyOMA2/OMA.py b/pyOMA2/OMA.py deleted file mode 100644 index 0a8d262..0000000 --- a/pyOMA2/OMA.py +++ /dev/null @@ -1,820 +0,0 @@ -import os -import glob -import numpy as np -from numpy.linalg import pinv -from scipy import signal -from scipy.optimize import curve_fit -from scipy.linalg import eig -import matplotlib.pyplot as plt - - -from . import tools -from . import Sel_from_plot - -# ============================================================================= -# pyOMA classes -# ============================================================================= -class Model(): - """ - Model. - """ - - def __init__(self, data, fs): - - """ - Bla bla bla - - """ - - try: - self.data = np.asarray(data) - except: - raise Exception("Cannot convert data into a numpy array") - - try: - self.fs = float(fs) - except: - raise Exception("Cannot convert sampling frequency into a float") - - self.Ndat = data.shape[0] - self.Nch = data.shape[1] - self.data = data - self.samp_freq = fs - self.freq_max = self.samp_freq / 2 # Nyquist frequency - self.Results = {} - -# ----------------------------------------------------------------------------- -# Algorithms / Methods -# ----------------------------------------------------------------------------- - - def FDDsvp(self, df=0.01, pov=0.5, window="hann"): - """ - Bla bla bla - - """ - nxseg = self.samp_freq / df # number of points per segment - noverlap = int(nxseg * pov) # Number of overlapping points - Nf = int(nxseg / 2) + 1 # Number of frequency lines - - # Calculating Auto e Cross-Spectral Density - _f, PSD_matr = signal.csd( - self.data.T.reshape(self.Nch, 1, self.Ndat), - self.data.T.reshape(1, self.Nch, self.Ndat), - fs=self.samp_freq, - nperseg=nxseg, - noverlap=noverlap, - window=window, - ) - - # Singular Value loop - S_val = np.empty((self.Nch, self.Nch, Nf)) - S_vec = np.empty((self.Nch, self.Nch, Nf), dtype=complex) - for i in range(Nf): - U1, S1, V1_t = np.linalg.svd(PSD_matr[:, :, i]) - U1_1 = U1.T - S_val[:, :, i] = np.sqrt(np.diag(S1)) - S_vec[:, :, i] = U1_1 - - - self.Results["FDD"] = { - "df": df, - "freqs": _f, - "S_val": S_val, - "S_vec": S_vec, - "PSD_matr": PSD_matr, - } - -#------------------------------------------------------------------------------ - - def FDDmodEX(self, ndf=5): - """ - Bla bla bla - - """ - df = self.Results["FDD"]["df"] - S_val = self.Results["FDD"]["S_val"] - S_vec = self.Results["FDD"]["S_vec"] - deltaf = ndf * df - freqs = self.Results["FDD"]["freqs"] - sel_freq = self.sel_freq - - Freq = [] - Fi = [] - index = [] - - for freq in sel_freq: - lim = (freq - deltaf, freq + deltaf) # Frequency bandwidth where the peak is searched - idxlim = (np.argmin(np.abs(freqs - lim[0])), - np.argmin(np.abs(freqs - lim[1]))) # Indices of the limits - - # Ratios between the first and second singular value - diffS1S2 = S_val[0, 0, idxlim[0]:idxlim[1]] / \ - S_val[1, 1, idxlim[0]:idxlim[1]] - maxDiffS1S2 = np.max(diffS1S2) # Looking for the maximum difference - idx1 = np.argmin(np.abs(diffS1S2 - maxDiffS1S2)) # Index of the max diff - idxfin = idxlim[0] + idx1 # Final index - - # Modal properties - fr_FDD = freqs[idxfin] # Frequency - fi_FDD = S_vec[0, :, idxfin] # Mode shape - fi_FDDn = fi_FDD / fi_FDD[np.argmax(np.abs(fi_FDD))] # Normalized (unity displacement) - - Freq.append(fr_FDD) - Fi.append(fi_FDDn) - index.append(idxfin) - - Freq = np.array(Freq) - Fi = np.array(Fi) - index = np.array(index) - - self.Results["FDD"]["Fn"] = Freq - self.Results["FDD"]["Phi"] = Fi.T - self.Results["FDD"]["Freq ind"] = index - -#------------------------------------------------------------------------------ - - def EFDDmodEX(self, ndf=5, cm=1 , MAClim=0.85, sppk=3, npmax=30, - method='FSDD', plot=False): - ''' - Bla bla bla - ''' - sel_freq = self.sel_freq - df = self.Results["FDD"]["df"] - S_val = self.Results["FDD"]["S_val"] - S_vec = self.Results["FDD"]["S_vec"] - PSD_matr = self.Results["FDD"]["PSD_matr"] - freqs = self.Results["FDD"]["freqs"] - # Run FDD to get a first estimate of the modal properties - self.FDDmodEX(ndf=ndf) - Freq, Fi = self.Results["FDD"]["Fn"], self.Results["FDD"]["Phi"] - - freq_max = self.freq_max - tlag = 1/df # time lag - Nf = freq_max/df+1 # number of spectral lines - # f = np.linspace(0, int(freq_max), int(Nf)) # all spectral lines - - nIFFT = (int(Nf))*20 # number of points for the inverse transform (zeropadding) - - # Initialize Results - Freq_E = [] - Fi_E = [] - Damp_E = [] - Figs = [] - - for n in range(len(sel_freq)): # looping through all frequencies to estimate - _fi = Fi[: , n] # Select reference mode shape (from FDD) - # Initialise SDOF bell and Mode Shape - SDOFbell = np.zeros(int(Nf), dtype=complex) # - SDOFms = np.zeros((int(Nf), self.Nch), dtype=complex) - - for csm in range(cm):# Loop through close mode (if any, default 1) - # Frequency Spatial Domain Decomposition variation (defaulf) - if method == "FSDD": - # Save values that satisfy MAC > MAClim condition - SDOFbell += np.array([_fi.conj().T@PSD_matr[:,:, _l]@_fi # Enhanced PSD matrix (frequency filtered) - if tools.MAC(_fi, S_vec[csm,:,_l]) > MAClim - else 0 - for _l in range(int(Nf))]) - # Do the same for mode shapes - SDOFms += np.array([ S_vec[csm,:,_l] - if tools.MAC(_fi, S_vec[csm,:,_l]) > MAClim - else np.zeros(self.Nch) - for _l in range(int(Nf))]) - # Classical Enhanced Frequency Domain Decomposition method - else: - SDOFbell += np.array([S_val[csm, csm, _l] - if tools.MAC(_fi, S_vec[csm,:,_l]) > MAClim - else 0 - for _l in range(int(Nf) )]) - SDOFms += np.array([ S_vec[csm,:,_l] - if tools.MAC(_fi, S_vec[csm,:,_l]) > MAClim - else np.zeros(self.Nch) - for _l in range(int(Nf))]) - - # indices of the singular values in SDOFsval - idSV = np.array(np.where(SDOFbell)).T - fsval = freqs[idSV] - - # Mode shapes (singular vectors) associated to each singular values - # and weighted with respect to the singular value itself - FIs = [ SDOFbell[idSV[u]] * SDOFms[idSV[u],:] - for u in range(len(idSV)) ] - FIs = np.squeeze(np.array(FIs)) - - meanFi = np.mean(FIs,axis=0) - - # Normalised mode shape (unity disp) - meanFi = meanFi/meanFi[np.argmax(abs(meanFi))] - - # Autocorrelation function (Free Decay) - SDOFcorr1 = np.fft.ifft(SDOFbell,n=nIFFT,axis=0,norm='ortho').real - timeLag = np.linspace(0,tlag,len(SDOFcorr1)) # t - - # NORMALISED AUTOCORRELATION - idxmax = np.argmax(SDOFcorr1) - normSDOFcorr = SDOFcorr1[:len(SDOFcorr1)//2]/SDOFcorr1[idxmax] - - # finding where x = 0 - sgn = np.sign(normSDOFcorr).real # finding the sign - sgn1 = np.diff(sgn,axis=0) # finding where the sign changes (intersept with x=0) - zc1 = np.where(sgn1)[0] # Zero crossing indices - - # finding maximums and minimums (peaks) of the autoccorelation - maxSDOFcorr = [np.max(normSDOFcorr[zc1[_i]:zc1[_i+2]]) - for _i in range(0,len(zc1)-2,2)] - minSDOFcorr = [np.min(normSDOFcorr[zc1[_i]:zc1[_i+2]]) - for _i in range(0,len(zc1)-2,2)] - if len(maxSDOFcorr) > len(minSDOFcorr): - maxSDOFcorr = maxSDOFcorr[:-1] - elif len(maxSDOFcorr) < len(minSDOFcorr): - minSDOFcorr = minSDOFcorr[:-1] - minmax = np.array((minSDOFcorr, maxSDOFcorr)) - minmax = np.ravel(minmax, order='F') - - # finding the indices of the peaks - maxSDOFcorr_idx = [np.argmin(abs(normSDOFcorr-maxx)) - for maxx in maxSDOFcorr] - minSDOFcorr_idx = [np.argmin(abs(normSDOFcorr-minn)) - for minn in minSDOFcorr] - minmax_idx = np.array((minSDOFcorr_idx, maxSDOFcorr_idx)) - minmax_idx = np.ravel(minmax_idx, order='F') - - # Peacks and indices of the peaks to be used in the fitting - minmax_fit = np.array([minmax[_a] - for _a in range(sppk,sppk+npmax)]) - minmax_fit_idx = np.array([minmax_idx[_a] - for _a in range(sppk,sppk+npmax)]) - - # estimating the natural frequency from the distance between the peaks - Td = np.diff(timeLag[minmax_fit_idx])*2 # *2 because we use both max and min - Td_EFDD = np.mean(Td) - - fd_EFDD = 1/Td_EFDD # damped natural frequency - - # Log decrement - delta = np.array([2*np.log(np.abs(minmax[0])/np.abs(minmax[ii])) - for ii in range(len(minmax_fit))]) - - # Fit - _fit = lambda x,m:m*x - m, _ = curve_fit(_fit, np.arange(len(minmax_fit)), delta) - - # damping ratio - xi_EFDD = m/np.sqrt(4*np.pi**2 + m**2) - fn_EFDD = fd_EFDD/np.sqrt(1-xi_EFDD**2) - - # Finally appending the results to the returned dictionary - Freq_E.append(fn_EFDD) - Damp_E.append(xi_EFDD) - Fi_E.append(meanFi) - - - # If the plot option is activated we return the following plots - # build a rectangle in axes coords - left, width = .25, .5 - bottom, height = .25, .5 - right = left + width - top = bottom + height - # axes coordinates are 0,0 is bottom left and 1,1 is upper right - - if plot: - # PLOT 1 - Plotting the SDOF bell function extracted - _fig, ((_ax1,_ax2),(_ax3,_ax4)) = plt.subplots(nrows=2,ncols=2) - _ax1.plot(freqs, 10*np.log10(S_val[0,0]), c='b') - _ax1.plot(fsval, 10*np.log10(SDOFbell[idSV].real), c='r', - label='SDOF bell') - _ax1.set_title("SDOF Bell function") - _ax1.set_xlabel('Frequency [Hz]') - _ax1.set_ylabel(r'dB $[V^2/Hz]$') - _ax1.legend() - - # Plot 2 - _ax2.plot(timeLag[:len(SDOFcorr1)//2], normSDOFcorr) - _ax2.set_title("Auto-correlation Function") - _ax2.set_xlabel('Time lag[s]') - _ax2.set_ylabel('Normalized correlation') - - # PLOT 3 (PORTION for FIT) - _ax3.plot(timeLag[:minmax_fit_idx[-1]], - normSDOFcorr[:minmax_fit_idx[-1]]) - _ax3.scatter(timeLag[minmax_fit_idx], - normSDOFcorr[minmax_fit_idx]) - _ax3.set_title("Portion for fit") - _ax3.set_xlabel('Time lag[s]') - _ax3.set_ylabel('Normalized correlation') - - # PLOT 4 (FIT) - _ax4.scatter(np.arange(len(minmax_fit)), delta) - _ax4.plot(np.arange(len(minmax_fit)), - m*np.arange(len(minmax_fit))) - - _ax4.text(left, top, r'''$f_n$ = %.3f - $\xi$ = %.2f%s'''% (fn_EFDD, float(xi_EFDD)*100,"%"), - transform=_ax4.transAxes) - - _ax4.set_title("Fit - Frequency and Damping") - _ax4.set_xlabel(r'counter $k^{th}$ extreme') - _ax4.set_ylabel(r'$2ln\left(r_0/|r_k|\right)$') - - plt.tight_layout() - Figs.append(_fig) - - Freq = np.array(Freq_E) - Damp = np.array(Damp_E) - Fi = np.array(Fi_E) - - self.Results["EFDD"] = {"Method": method} - self.Results["EFDD"]['Fn'] = Freq - self.Results["EFDD"]['Phi'] = Fi.T - self.Results["EFDD"]['xi'] = Damp - self.Results["EFDD"]['Figs'] = Figs - -#------------------------------------------------------------------------------ - - def SSIcov(self, br, ordmin=0, ordmax=None, method='1'): - ''' - Bla bla bla - ''' - self.SSItype = "cov" - Nch = self.Nch - - try: - self.br = int(br) - except: - pass - - # If the maximum order is not given (default) it is set as the maximum - # allowable model order which is: number of block rows * number of channels - if ordmax == None: - self.SSI_ordmax = self.br*Nch - else: - self.SSI_ordmax = ordmax - self.SSI_ordmin = ordmin - - Yy=self.data.T # - - # Calculating R[i] (with i from 0 to 2*br) - R_is = np.array( [ 1/(self.Ndat - _s) * (Yy[:, : self.Ndat - _s] @ \ - Yy[:, _s:].T) for _s in range(br*2+1)]) - - # Assembling the Toepliz matrix - Tb = np.vstack([ np.hstack( - [ R_is[_o,:,:] - for _o in range(br+_l, _l,-1)] - ) - for _l in range(br)]) - - if method == "2": - # One-lag shifted Toeplitz matrix (used in "NExT-ERA" method) - Tb2 = np.vstack([ np.hstack( - [ R_is[_o,:,:] - for _o in range(br + _l, _l, -1) ] - ) - for _l in range(1, br+1)]) - - # SINGULAR VALUE DECOMPOSITION - U1, S1, V1_t = np.linalg.svd(Tb) - S1 = np.diag(S1) - S1rad=np.sqrt(S1) - - # initializing arrays - Fr=np.full((self.SSI_ordmax, int((self.SSI_ordmax)/2+1)), np.nan) # initialization of the matrix that contains the frequencies - Sm=np.full((self.SSI_ordmax, int((self.SSI_ordmax)/2+1)), np.nan) # initialization of the matrix that contains the damping ratios - Ms=np.full((self.SSI_ordmax, int((self.SSI_ordmax)/2+1), Nch), np.nan, - dtype=complex) # initialization of the matrix that contains the damping ratios - - # loop for increasing order of the system - for ii in range(self.SSI_ordmin, self.SSI_ordmax+1, 2): - O = U1[:br*Nch, :ii] @ S1rad[:ii, :ii] # Observability matrix - # _GAM = S11 @ V11 # Controllability matrix - - # Estimating matrix A - if method == '2':# Method 2 "NExT-ERA" - A = np.linalg.inv(S1rad[:ii, :ii]) @ U1[:br*Nch, :ii].T @ \ - Tb2 @ V1_t[:ii, :br*Nch].T @ np.linalg.inv(S1rad[:ii, :ii]) - else:# Method 1 (BALANCED_REALIZATION) - A = pinv(O[:O.shape[0] - Nch,:]) @ O[Nch:,:] - - # Output Influence Matrix - C = O[:Nch,:] - - [_AuVal, _AuVett] = np.linalg.eig(A) - Lambda =(np.log(_AuVal))*self.samp_freq - fr = abs(Lambda)/(2*np.pi) # natural frequencies - smorz = -((np.real(Lambda))/(abs(Lambda))) # damping ratios - # -------------- - # This is a fix for a bug. We make shure that there are not nans - # (it has, seldom, happened that at the first iteration the first - # eigenvalue was negative, yielding the log to return a nan that - # messed up with the plot of the stabilisation diagram) - for _j in range(len(fr)): - if np.isnan(fr[_j]) == True: - fr[_j] = 0 - # -------------- - - # Complex mode shapes - Mcomp = C @ _AuVett - # normalised (unity displacement) - Mcomp = np.array([ Mcomp[:, ii]/Mcomp[np.argmax(abs(Mcomp[:, ii])), ii] - for ii in range(Mcomp.shape[1])]).reshape(-1, Nch) - - # we are increasing 2 orders at each step - _ind_new = int((ii-self.SSI_ordmin)/2) - - Fr[:len(fr),_ind_new] = fr # save the frequencies - Sm[:len(fr),_ind_new] = smorz # save the damping ratios - Ms[:len(fr), _ind_new, :] = Mcomp - - - self.Results["SSIcov"] = {"Method": method} - self.Results["SSIcov"]['Fn_poles'] = Fr - self.Results["SSIcov"]['xi_poles'] = Sm - self.Results["SSIcov"]['Phi_poles'] = Ms - -#------------------------------------------------------------------------------ - - def SSIdat(self, br, ordmin=0, ordmax=None, method='1'): - ''' - Bla bla bla - ''' - self.SSItype = "dat" - Ndat = self.Ndat - Nch = self.Nch - - try: - self.br = int(br) - except: - pass - - # If the maximum order is not given (default) it is set as the maximum - # allowable model order which is: number of block rows * number of channels - if ordmax == None: - self.SSI_ordmax = self.br*Nch - else: - self.SSI_ordmax = ordmax - self.SSI_ordmin = ordmin - - Yy=self.data.T # - - j=Ndat-2*br+1; # Dimension of the Hankel matrix - - # calculating Hankel matrix - H=np.zeros((Nch*2*br,j)) # Initialization of the Hankel matrix - for k in range(0,2*br): - H[k*Nch:((k+1)*Nch),:]=(1/j**0.5)*Yy[:,k:k+j] # calculating Hankel matrix - - # LQ factorization of the Hankel matrix - Q , L = np.linalg.qr(H.T) - L = L.T - Q = Q.T - - L21 = L[Nch*br: Nch*br + Nch, : Nch*br] - L22 = L[Nch*br: Nch*br + Nch, Nch*br: Nch*br + Nch] - L31 = L[Nch*br + Nch: , : Nch*br] - L32 = L[Nch*br + Nch: , Nch*br : Nch*br + Nch] - - Q1 = Q[: Nch*br, :] - Q2 = Q[Nch*br: Nch*br + Nch, :] - - P_i = np.vstack((L21, L31)) @ Q1 # Projection Matrix P_i - if method == '2': - P_im1 = np.hstack((L31, L32)) @ np.vstack((Q1, Q2)) # Projection P_(i-1) - Y_i = np.hstack((L21, L22)) @ np.vstack((Q1, Q2)) # Output sequence - - # SINGULAR VALUE DECOMPOSITION - U1, S1, V1_t = np.linalg.svd(P_i,full_matrices=False) - S1 = np.diag(S1) - S1rad=np.sqrt(S1) - - # initializing arrays - Fr=np.full((self.SSI_ordmax, int((self.SSI_ordmax)/2+1)), np.nan) # initialization of the matrix that contains the frequencies - Sm=np.full((self.SSI_ordmax, int((self.SSI_ordmax)/2+1)), np.nan) # initialization of the matrix that contains the damping ratios - Ms=np.full((self.SSI_ordmax, int((self.SSI_ordmax)/2+1), Nch), np.nan, - dtype=complex) # initialization of the matrix that contains the damping ratios - - # loop for increasing order of the system - for ii in range(self.SSI_ordmin, self.SSI_ordmax+1, 2): - - O = U1[:br*Nch, :ii] @ S1rad[:ii, :ii] # Observability matrix - - S = np.linalg.pinv(O) @ P_i # Kalman filter state sequence - - # Estimate of the discrete Matrices A and C - if method == '1': # Method 1 - A = np.linalg.pinv(O[:O.shape[0] - Nch,:]) @ O[Nch:,:] - C = O[:Nch,:] - # Ci sarebbero da calcolare le matrici G e R0 - - else: # Method 2 - Sp1 = np.linalg.pinv(O[:O.shape[0] - Nch,:]) @ P_im1 # kalman state sequence S_(i+1) - - AC = np.vstack((Sp1, Y_i)) @ np.linalg.pinv(S) - A = AC[:Sp1.shape[0]] - C = AC[Sp1.shape[0]:] - # Ci sarebbero da calcolare le matrici G e R0 - - [_AuVal, _AuVett] = np.linalg.eig(A) - Lambda =(np.log(_AuVal))*self.samp_freq - fr = abs(Lambda)/(2*np.pi) # natural frequencies - smorz = -((np.real(Lambda))/(abs(Lambda))) # damping ratios - # -------------- - # This is a fix for a bug. We make shure that there are not nans - # (it has, seldom, happened that at the first iteration the first - # eigenvalue was negative, yielding the log to return a nan that - # messed up with the plot of the stabilisation diagram) - for _j in range(len(fr)): - if np.isnan(fr[_j]) == True: - fr[_j] = 0 - # -------------- - - # Complex mode shapes - Mcomp = C @ _AuVett - # normalised (unity displacement) - Mcomp = np.array([ Mcomp[:, ii]/Mcomp[np.argmax(abs(Mcomp[:, ii])), ii] - for ii in range(Mcomp.shape[1])]).reshape(-1, Nch) - - # we are increasing 2 orders at each step - _ind_new = int((ii-self.SSI_ordmin)/2) - - Fr[:len(fr),_ind_new] = fr # save the frequencies - Sm[:len(fr),_ind_new] = smorz # save the damping ratios - Ms[:len(fr), _ind_new, :] = Mcomp - - - self.Results["SSIdat"] = {"Method": method} - self.Results["SSIdat"]['Fn_poles'] = Fr - self.Results["SSIdat"]['xi_poles'] = Sm - self.Results["SSIdat"]['Phi_poles'] = Ms - -#------------------------------------------------------------------------------ - - def SSImodEX(self): - """ - Bla bla bla - """ - FreQ = self.sel_freq - XI = self.sel_xi - Fi = np.array(self.sel_phi).T - - # Save in dictionary of results - if self.SSItype == "cov": - self.Results["SSIcov"]['Fn'] = np.array(FreQ) - self.Results["SSIcov"]['Phi'] = Fi - self.Results["SSIcov"]['xi'] = np.array(XI) - - elif self.SSItype == "dat": - self.Results["SSIdat"]['Fn'] = np.array(FreQ) - self.Results["SSIdat"]['Phi'] = Fi - self.Results["SSIdat"]['xi'] = np.array(XI) -#------------------------------------------------------------------------------ - - def pLSCF(self, ordmax, df=0.01, pov=0.5, window="hann"): - ''' - Bla bla bla - ''' - Nch = self.Nch - # PSD - nxseg = self.samp_freq / df # number of point per segments - # nseg = self.Ndat // nxseg # number of segments - noverlap = nxseg // (1 / pov) # Number of overlapping points - Nf = int((nxseg) / 2 + 1) # Number of frequency lines - - # Calculating Auto e Cross-Spectral Density - freqs_hz, PSD_matr = signal.csd( - self.data.T.reshape(Nch, 1, self.Ndat), - self.data.T.reshape(1, Nch, self.Ndat), - fs=self.samp_freq, - nperseg=nxseg, - noverlap=noverlap, - window=window, - ) - - # p-LSCF - METODO CON MATRICI REALI - self.pLSCF_ordmax = ordmax - freqs = 2*np.pi*freqs_hz - - # The PSD matrix should be in the format (k, o, o) where: - # k=1,2,...Nf; and o=1,2...l - Sy = np.copy(PSD_matr.T) - - dt = 1/self.samp_freq - Fr = np.full((ordmax*Nch, ordmax), np.nan) # initialise - Sm = np.full((ordmax*Nch, ordmax), np.nan) # initialise - Ls = np.full((ordmax*Nch, ordmax), np.nan, dtype=complex) # initialise - - # Calculation of companion matrix A and modal parameters for each order - for j in range(1, ordmax+1): # loop for increasing model order - M = np.zeros(((j+1)*Nch, (j+1)*Nch)) # inizializzo - I0 = np.array([np.exp(1j*freqs*dt*jj) for jj in range(j+1)]).T - I0h = I0.conj().T # Calculate complex transpose - R0 = np.real(I0h @ I0) # 4.163 - - for o in range(0, Nch): # loop on channels - Y0 = np.array([np.kron(-I0[kk, :], Sy[kk, o, :]) for kk in range(Nf)]) - S0 = np.real(I0h @ Y0) # 4.164 - T0 = np.real(Y0.conj().T @ Y0) # 4.165 - M += 2*(T0 - (S0.T @ np.linalg.solve(R0, S0))) # 4.167 - - alfa = np.linalg.solve(-M[: j*Nch, : j*Nch], M[: j*Nch, j*Nch: (j+1)*Nch]) # 4.169 - alfa = np.vstack((alfa, np.eye(Nch))) - - # beta0 = np.linalg.solve(-R0, S0@alfa) - - # Companion matrix - A = np.zeros((j*Nch, j*Nch)); - for ii in range(j): - Aj = alfa[ii*Nch: (ii+1)*Nch, :] - A[(j-1)*Nch: , ii*Nch: (ii+1)*Nch] = -Aj.T - A[: (j-1)*Nch, Nch: j*Nch] = np.eye(((j-1)*Nch)); - - # Eigenvalueproblem - [my, My] = eig(A); - lambd = np.log(my)/dt # From discrete-time to continuous time 4.136 - - # replace with nan every value with negative real part (should be the other way around!) - lambd = np.where(np.real(lambd)<0, np.nan, lambd) - Ls[:j*Nch, j-1] = lambd - Fr[:j*Nch, j-1] = abs(lambd)/(2*np.pi) # Natural frequencies (Hz) 4.137 - Sm[:j*Nch, j-1] = ((np.real(lambd))/abs(lambd)) # Damping ratio initial calc 4.139 - - self.ordmax = ordmax - self.ws = freqs - self.Sy = Sy - self.freqs = freqs_hz - self.Results["pLSCF"] = {"ordmax": ordmax} - self.Results["pLSCF"]['Fn_poles'] = Fr - self.Results["pLSCF"]['xi_poles'] = Sm - self.Results["pLSCF"]['lam_poles'] = Ls - - -#------------------------------------------------------------------------------ - - def pLSCFmodEx(self): - ''' - Bla bla bla - ''' - - Nch = self.Nch - w_sel = np.array(self.sel_freq)*(2*np.pi) - sel_lam = self.sel_lam - Nm = len(sel_lam) # numero modi - Fi = np.zeros((self.Nch, Nm), dtype=complex) - - LL = np.zeros((Nch*Nm, Nch*Nm), dtype=complex) # inizializzo - GL = np.zeros((Nch*Nm, Nch), dtype=complex) # inizializzo - - for ww in w_sel: # loop su poli selezionati - - idx_w = np.argmin(np.abs(self.ws-ww)) # trovo indice - - # loop sulle linee di frequenza intorno al polo fisico (+20 e -20) - for kk in range(idx_w-20, idx_w+20): - GL += np.array( - [ self.Sy[kk, :, :]/(1j*self.ws[kk]-sel_lam[jj]) for jj in range(Nm)] - ).reshape(-1, Nch) - - LL += np.array([ - np.array([np.eye(Nch)/((1j*self.ws[kk]-sel_lam[jj1])*(1j*self.ws[kk]-sel_lam[jj2])) - for jj2 in range(Nm)]).reshape((Nch*Nm, Nch),order="c").T - for jj1 in range(Nm)]).reshape((Nch*Nm, Nch*Nm)) - - R = np.linalg.solve(LL, GL) # matrice dei residui (fi@fi^T - - for jj in range(len(w_sel)): - # SVD della matrice dei residui per ciascun modo fisico del sistema - U, S, VT = np.linalg.svd(R[jj*Nch: (jj+1)*Nch, :]) - - phi = U[: , 0] # la forma modale è la prima colonna di U - - idmax = np.argmax(abs(phi)) - phiN = phi/phi[idmax] # normalised (unity displacement) - - Fi[:, jj]= phiN - - # Save in dictionary of results - self.Results["pLSCF"]['Fn'] = np.array(self.sel_freq) - self.Results["pLSCF"]['Phi'] = Fi - self.Results["pLSCF"]['xi'] = np.array(self.sel_xi) - - - -#------------------------------------------------------------------------------ - - def sel_peak_FDD(self, freqlim=None, ndf=5): - """ - Bla bla bla - """ - _ = Sel_from_plot.SelFromPlot(self, freqlim=freqlim, plot="FDD") - self.FDDmodEX(ndf) - - - def sel_peak_EFDD(self, freqlim=None, ndf=5, cm=1 , MAClim=0.85, sppk=3, - npmax=30, method='FSDD', plot=False): - """ - Bla bla bla - """ - _ = Sel_from_plot.SelFromPlot(self, freqlim=freqlim, plot="FDD") - self.EFDDmodEX(ndf, cm, MAClim, sppk, npmax, method, plot) - - - def sel_pole_SSI(self, freqlim=None, ordmin=0, ordmax=None, method='1'): - """ - Bla bla bla - """ - self.FDDsvp() - _ = Sel_from_plot.SelFromPlot(self, freqlim=freqlim, plot="SSI") - self.SSImodEX() - - - def sel_pole_pLSCF(self, freqlim=None): - """ - Bla bla bla - """ - self.FDDsvp() - _ = Sel_from_plot.SelFromPlot(self, freqlim=freqlim, plot="pLSCF") - self.pLSCFmodEx() - - -# ============================================================================= -# DA TESTARE - def get_mod_FDD(self, sel_freq, ndf=5): - """ - Bla bla bla - """ - self.sel_freq = sel_freq - self.FDDmodEX(ndf) - - - def get_mod_EFDD(self, sel_freq, ndf=5, cm=1 , MAClim=0.85, sppk=3, - npmax=30, method='FSDD', plot=False): - """ - Bla bla bla - """ - self.sel_freq = sel_freq - self.EFDDmodEX(ndf, cm, MAClim, sppk, npmax, method, plot) - - - def get_mod_SSI(self, sel_freq, order="find_min"): - """ - Bla bla bla - """ - try: - order == "find_min" or order % 2 == 0 - except: - raise Exception('ordmin must either be = "find_min" or an even number') - - SSItype = self.SSItype - self.sel_freq = [] - self.sel_xi = [] - self.sel_phi = [] - order = int(order/2) - # Loop through the frequencies given in the input list - for fj in sel_freq: - - if order == "find_min": # here we find the minimum model order so to get a stable pole for every mode of interest - pass - else: # when the model order is provided - Fr = self.Results[f"SSI{SSItype}"]["Fn_poles"][:, order] - Sm = self.Results[f"SSI{SSItype}"]["xi_poles"][:, order] - Ms = self.Results[f"SSI{SSItype}"]["Phi_poles"][:, order] - # Find closest frequency index - sel = np.nanargmin(np.abs(Fr - fj)) - - self.sel_freq.append(Fr[sel]) - self.sel_xi.append(Sm[sel]) - self.sel_phi.append(Ms[sel, :]) - - self.Results[f"SSI{SSItype}"]['Fn'] = np.array(self.sel_freq) - self.Results[f"SSI{SSItype}"]['Phi'] = np.array(self.sel_phi).T - self.Results[f"SSI{SSItype}"]['xi'] = np.array(self.sel_xi) - - - def get_mod_pLSCF(self, sel_freq, order="find_min"): - """ - Bla bla bla - """ - self.sel_freq = [] - self.sel_xi = [] - self.sel_lam = [] - # Loop through the frequencies given in the input list - for fj in sel_freq: - - if order == "find_min": # here we find the minimum model order so to get a stable pole for every mode of interest - pass - else: # when the model order is provided - Fr = self.Results["pLSCF"]["Fn_poles"][:, order] - Sm = self.Results["pLSCF"]["xi_poles"][:, order] - Ls = self.Results["pLSCF"]['lam_poles'][:, order] - - # Find closest frequency index - sel = np.nanargmin(np.abs(Fr - fj)) - - self.sel_freq.append(Fr[sel]) - self.sel_xi.append(Sm[sel]) - self.sel_lam.append(Ls[sel]) - - self.pLSCFmodEx() - - - - diff --git a/pyOMA2/SSIcov_ref_test.py b/pyOMA2/SSIcov_ref_test.py deleted file mode 100644 index e50e7d9..0000000 --- a/pyOMA2/SSIcov_ref_test.py +++ /dev/null @@ -1,78 +0,0 @@ -# -*- coding: utf-8 -*- -""" -Created on Sat Aug 19 09:12:54 2023 - -@author: dpa -""" - -import numpy as np - -def blockhankel(Y_ref, Y_all, s): - r = Y_all.shape[0] - c = Y_ref.shape[0] - R = np.zeros((r, c, 2*s)) - - for i in range(r): - for j in range(c): - temp = np.correlate(Y_all[i, :], Y_ref[j, :], mode='full') - R[i, j, :] = temp[2*s+2:] # Only the positive time lags - - H = np.zeros((s*r, c*s)) - for i in range(s): - temp = R[:, :, i:i+s].reshape(r, c*s) - H[i*r:(i+1)*r, :] = temp - - return H - -def ssicovref(Y, order, s): - print('SSI-cov/ref status:') - n_setups = len(Y) # number of different sensor arrangements/setups - n_ref = Y[0]['ref'].shape[0] # number of reference sensors - n_mov = np.array([y['mov'].shape[0] for y in Y]) # number of moving sensors in each setup - n_s = n_ref + np.sum(n_mov) # total number of sensors - Obs = [None] * n_setups - - for i in range(n_setups): - print(f' processing setup {i+1} of {n_setups}...') - Y_ref = Y[i]['ref'] - Y_mov = Y[i]['mov'] - H = blockhankel(Y_ref, np.vstack((Y_ref, Y_mov)), s) - U, S, _ = np.linalg.svd(H, full_matrices=False) - S = S[:order, :order] - obs = U[:, :order] @ np.sqrt(S) - - id = np.zeros((n_ref, s), dtype=int) - for j in range(n_ref): - id[j, :] = np.arange(s) * (n_ref + n_mov[i]) + j - - obs_ref = obs[id.flatten(), :].reshape(n_ref, s, order) - obs[id.flatten(), :] = 0 # Delete reference portion from obs_mov - - if i == 0: - obs1_ref = obs_ref.copy() - - obs = obs @ np.linalg.pinv(obs_ref) @ obs1_ref - Obs[i] = obs - - print(' generating global observability matrix...') - Obs_all = np.zeros((n_s * s, order)) - for i in range(s): - id1 = (i * n_s) - id2 = id1 + n_ref - Obs_all[id1:id2, :] = obs1_ref[(i * n_ref):(i + 1) * n_ref, :] - - for j in range(n_setups): - id1 = id2 - id2 = id1 + n_mov[j] - Obs_all[id1:id2, :] = Obs[j][(i * n_mov[j]):(i + 1) * n_mov[j], :] - - A = [None] * order - C = [None] * order - - print(f' generating system matrices A,C for {order} model orders...') - for i in range(order): - A[i] = np.linalg.pinv(Obs_all[:-n_s, :i]) @ Obs_all[n_s:, :i] - C[i] = Obs_all[:n_s, :i] - - print('SSI-cov/ref finished.') - return A, C \ No newline at end of file diff --git a/pyOMA2/Sel_from_plot.py b/pyOMA2/Sel_from_plot.py deleted file mode 100644 index 7bbd056..0000000 --- a/pyOMA2/Sel_from_plot.py +++ /dev/null @@ -1,553 +0,0 @@ -# -*- coding: utf-8 -*- -""" -Created on Sun Aug 13 16:31:54 2023 - -@author: dpa -""" - -import os -import glob -import numpy as np - -import matplotlib.pyplot as plt -from matplotlib.ticker import (MultipleLocator, FormatStrFormatter) -from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg, NavigationToolbar2Tk -from matplotlib.figure import Figure - -import tkinter as tk - -from . import tools - -# ============================================================================= -# PLOTTING CLASS -# ============================================================================= - -class SelFromPlot(): - def __init__(self, Model, plot, freqlim=None): - """ - Bla bla bla - """ - self.Model = Model - - if freqlim is not None: - self.freq_max = freqlim - else: - self.freq_max = self.Model.samp_freq / 2 # Nyquist frequency - - self.shift_is_held = False - - self.samp_freq = self.Model.samp_freq - self.freqs = self.Model.Results["FDD"]["freqs"] - - self.root = tk.Tk() - - self.Model.sel_freq = [] - if plot == "SSI" or plot == "pLSCF": - self.show_legend = 0 - self.hide_poles = 1 - self.S_val = self.Model.Results["FDD"]["S_val"] - - self.Model.sel_xi = [] - self.Model.sel_phi = [] - self.Model.sel_lam = [] - self.Model.pole_ind = [] - - self.root.title('Stabilisation Chart') - - elif plot == "FDD": - self.Model.freq_ind = [] - self.root.title('Singular Values of PSD matrix') - - self.fig = Figure(figsize=(16, 8)) - - # Create axes - self.ax2 = self.fig.add_subplot(111) - self.ax2.grid(True) - if plot == "SSI" or plot == "pLSCF": - self.ax1 = self.ax2.twinx() - - # Tkinter menu - menubar = tk.Menu(self.root) - filemenu = tk.Menu(menubar, tearoff=0) - filemenu.add_command(label='Save figure', command=self.save_this_figure) - menubar.add_cascade(label='File', menu=filemenu) - - if plot == "SSI" or plot == "pLSCF": - self.plot = plot - hidepolesmenu = tk.Menu(menubar, tearoff=0) - hidepolesmenu.add_command(label='Show unstable poles', - command=lambda: (self.toggle_hide_poles(0), self.toggle_legend(1))) - hidepolesmenu.add_command(label='Hide unstable poles', - command=lambda: (self.toggle_hide_poles(1), self.toggle_legend(0))) - menubar.add_cascade(label="Show/Hide Unstable Poles", - menu=hidepolesmenu) - - helpmenu = tk.Menu(menubar, tearoff=0) - helpmenu.add_command(label='Help', command=self.show_help) - menubar.add_cascade(label='Help', menu=helpmenu) - - self.root.config(menu=menubar) - - - # Program execution - if plot == "SSI" or plot == "pLSCF": - self.get_stab(plot) - self.plot_stab(plot) - elif plot == "FDD": - self.plot_svPSD() - - - # Integrate matplotlib figure - canvas = FigureCanvasTkAgg(self.fig, self.root) - canvas.get_tk_widget().pack(side='top', fill='both', expand=1) - NavigationToolbar2Tk(canvas, self.root) - - - # Connecting functions to event manager - self.fig.canvas.mpl_connect('key_press_event', - lambda x: self.on_key_press(x)) - self.fig.canvas.mpl_connect('key_release_event', - lambda x: self.on_key_release(x)) - if plot == "SSI" or plot == "pLSCF": - self.fig.canvas.mpl_connect('button_press_event', - lambda x: self.on_click_SSI(x, plot)) - - elif plot == "FDD": - self.fig.canvas.mpl_connect('button_press_event', - lambda x: self.on_click_FDD(x)) - - self.root.protocol("WM_DELETE_WINDOW", lambda: self.on_closing()) - self.root.mainloop() - -#------------------------------------------------------------------------------ - - def plot_svPSD(self, update_ticks=False): - - S_val = self.Model.Results["FDD"]["S_val"] - - if not update_ticks: - self.ax2.clear() - self.ax2.grid(True) - - for ii in range(self.Model.Nch): - self.ax2.plot(self.freqs[:], 10*np.log10(S_val[ii, ii])) - - df = self.Model.Results["FDD"]["df"] - self.ax2.set_xlim(left=0, right=self.freq_max) - self.ax2.xaxis.set_major_locator(MultipleLocator(self.freq_max / 10)) - self.ax2.xaxis.set_major_formatter(FormatStrFormatter("%g")) - self.ax2.xaxis.set_minor_locator(MultipleLocator(self.freq_max / 100)) - self.ax2.set_title("Singular values plot - (Freq. res. ={0})".format(df)) - self.ax2.set_xlabel("Frequency [Hz]") - self.ax2.set_ylabel(r"dB $[g^2/Hz]$") - - self.line, = self.ax2.plot(self.Model.sel_freq, - [10*np.log10(S_val[0,0,i]*1.05) for i in self.Model.freq_ind] - , 'kv', markersize=8) - - plt.tight_layout() - - else: - self.line.set_xdata(np.asarray(self.Model.sel_freq)) # update data - self.line.set_ydata([10*np.log10(S_val[0,0,i]*1.05) for i in - self.Model.freq_ind]) - - plt.tight_layout() - - self.fig.canvas.draw() - -#------------------------------------------------------------------------------ - - def get_closest_freq(self): - """ - On-the-fly selection of the closest poles. - """ - freq = self.Model.Results["FDD"]["freqs"] - # Find closest frequency - sel = np.argmin(np.abs(freq - self.x_data_pole)) - - self.Model.sel_freq.append(self.Model.Results["FDD"]["freqs"][sel]) - self.Model.freq_ind.append(sel) - self.sort_selected_poles() - - -#------------------------------------------------------------------------------ - - def get_stab(self, plot, err_fn=0.01, err_xi=0.05, err_ms=0.02): - """ - - """ - - if plot == "SSI": - ordmax = self.Model.SSI_ordmax - ordmin = self.Model.SSI_ordmin - if self.Model.SSItype == "cov": - Fr = self.Model.Results["SSIcov"]['Fn_poles'] - Sm = self.Model.Results["SSIcov"]['xi_poles'] - Ms = self.Model.Results["SSIcov"]['Phi_poles'] - - elif self.Model.SSItype == "dat": - Fr = self.Model.Results["SSIdat"]['Fn_poles'] - Sm = self.Model.Results["SSIdat"]['xi_poles'] - Ms = self.Model.Results["SSIdat"]['Phi_poles'] - - self.Lab = tools._stab_SSI(Fr, Sm, Ms, ordmin, ordmax, - err_fn=err_fn, err_xi=err_xi, err_ms=err_ms) - - elif plot == "pLSCF": - ordmax = self.Model.pLSCF_ordmax - Fr = self.Model.Results["pLSCF"]['Fn_poles'] - Sm = self.Model.Results["pLSCF"]['xi_poles'] - nch = self.Model.Nch - self.Lab = tools._stab_pLSCF(Fr, Sm, ordmax, - err_fn=err_fn, err_xi=err_xi, nch=nch) - -#------------------------------------------------------------------------------ - - def plot_stab(self, plot, update_ticks=False): - - S_val = self.Model.Results["FDD"]["S_val"] - - if not update_ticks: - self.ax1.clear() - self.ax2.clear() - self.ax2.grid(True) - - for ii in range(2): - self.ax2.plot(self.freqs[:], 10*np.log10(S_val[ii, ii]),"gray") - - self.ax1.set_xlim(left=0, right=self.freq_max) - self.ax1.xaxis.set_major_locator(MultipleLocator(self.freq_max / 10)) - self.ax1.xaxis.set_major_formatter(FormatStrFormatter("%g")) - self.ax1.xaxis.set_minor_locator(MultipleLocator(self.freq_max / 100)) - self.ax1.set_xlabel("Frequency [Hz]") - - self.ax2.set_ylabel(r"dB $[g^2/Hz]$") - - #----------------------- - if plot == "SSI": - self.ax1.set_ylabel("Model Order (x2)") - if self.Model.SSItype == "cov": - Fr = self.Model.Results["SSIcov"]['Fn_poles'] - - elif self.Model.SSItype == "dat": - Fr = self.Model.Results["SSIdat"]['Fn_poles'] - - Lab = self.Lab - - # Stable pole - a = np.where(Lab == 7, Fr, np.nan) - # Stable frequency, stable mode shape - b = np.where(Lab == 6, Fr, np.nan) - # Stable frequency, stable damping - c = np.where(Lab == 5, Fr, np.nan) - # Stable damping, stable mode shape - d = np.where(Lab == 4, Fr, np.nan) - # Stable damping - e = np.where(Lab == 3, Fr, np.nan) - # Stable mode shape - f = np.where(Lab == 2, Fr, np.nan) - # Stable frequency - g = np.where(Lab == 1, Fr, np.nan) - # new or unstable - h = np.where(Lab == 0, Fr, np.nan) - - if self.hide_poles: - x = a.flatten(order='f') - y = np.array([i//len(a) for i in range(len(x))]) - - self.ax1.plot(x, y, 'go', markersize=7, label="Stable pole") - - self.line, = self.ax1.plot(self.Model.sel_freq, - [i for i in self.Model.pole_ind] - , 'kx', markersize=10) - - else: - x = a.flatten(order='f') - x1 = b.flatten(order='f') - x2 = c.flatten(order='f') - x3 = d.flatten(order='f') - x4 = e.flatten(order='f') - x5 = f.flatten(order='f') - x6 = g.flatten(order='f') - x7 = h.flatten(order='f') - - y = np.array([i//len(a) for i in range(len(x))]) - - self.ax1.plot(x, y, 'go', markersize=7, label="Stable pole") - - self.ax1.scatter(x1, y, - marker='o', s=4, c='#FFFF00', - label="Stable frequency, stable mode shape") - self.ax1.scatter(x2, y, - marker='o', s=4, c='#FFFF00', - label="Stable frequency, stable damping") - self.ax1.scatter(x3, y, - marker='o', s=4, c='#FFFF00', - label="Stable damping, stable mode shape") - self.ax1.scatter(x4, y, - marker='o', s=4, c='#FFA500', - label="Stable damping") - self.ax1.scatter(x5, y, - marker='o', s=4, c='#FFA500', - label="Stable mode shape") - self.ax1.scatter(x6, y, - marker='o', s=4, c='#FFA500', - label="Stable frequency") - self.ax1.scatter(x7, y, - marker='o', s=4, c='r', - label="Unstable pole") - - self.line, = self.ax1.plot(self.Model.sel_freq, - [i for i in self.Model.pole_ind] - , 'kx', markersize=10) - - #----------------------- - elif plot == "pLSCF": - self.ax1.set_ylabel("Model Order") - Fr = self.Model.Results["pLSCF"]['Fn_poles'] - Lab = self.Lab - - # Stable pole - a = np.where(Lab == 3, Fr, np.nan) - # Stable damping - b = np.where(Lab == 2, Fr, np.nan) - # Stable frequency - c = np.where(Lab == 1, Fr, np.nan) - # Unstable pole - d = np.where(Lab == 0, Fr, np.nan) - - if self.hide_poles: - x = a.flatten(order='f') - y = np.array([i//len(a) for i in range(len(x))]) - - self.ax1.plot(x, y, 'go', markersize=7, label="Stable pole") - - self.line, = self.ax1.plot(self.Model.sel_freq, - [i for i in self.Model.pole_ind] - , 'kx', markersize=10) - - else: - x = a.flatten(order='f') - x1 = b.flatten(order='f') - x2 = c.flatten(order='f') - x3 = d.flatten(order='f') - - y = np.array([i//len(a) for i in range(len(x))]) - - self.ax1.plot(x, y, 'go', markersize=7, label="Stable pole") - - self.ax1.scatter(x1, y, - marker='o', s=4, c='#FFFF00', - label="Stable damping") - self.ax1.scatter(x2, y, - marker='o', s=4, c='#FFFF00', - label="Stable frequency") - self.ax1.scatter(x3, y, - marker='o', s=4, c='r', - label="Unstable pole") - - self.line, = self.ax1.plot(self.Model.sel_freq, - [i for i in self.Model.pole_ind] - , 'kx', markersize=10) - - #----------------------- - if self.show_legend: - self.pole_legend = self.ax1.legend(loc='lower center', ncol=4, frameon=True) - - plt.tight_layout() - - else: - self.line.set_xdata(np.asarray(self.Model.sel_freq)) # update data - self.line.set_ydata([i for i in self.Model.pole_ind]) - - plt.tight_layout() - - self.fig.canvas.draw() - - -#------------------------------------------------------------------------------ - - def get_closest_pole(self, plot): - """ - On-the-fly selection of the closest poles. - """ - - if plot == "SSI": - if self.Model.SSItype == "cov": - Fr = self.Model.Results["SSIcov"]['Fn_poles'] - Sm = self.Model.Results["SSIcov"]['xi_poles'] - Ms = self.Model.Results["SSIcov"]['Phi_poles'] - - elif self.Model.SSItype == "dat": - Fr = self.Model.Results["SSIdat"]['Fn_poles'] - Sm = self.Model.Results["SSIdat"]['xi_poles'] - Ms = self.Model.Results["SSIdat"]['Phi_poles'] - - elif plot == "pLSCF": - Fr = self.Model.Results["pLSCF"]['Fn_poles'] - Sm = self.Model.Results["pLSCF"]['xi_poles'] - Ls = self.Model.Results["pLSCF"]['lam_poles'] - - y_ind = int(np.argmin(np.abs(np.arange(Fr.shape[1])-self.y_data_pole))) # Find closest pole order index - x = Fr[:, y_ind] - # Find closest frequency index - sel = np.nanargmin(np.abs(x - self.x_data_pole)) - - self.Model.pole_ind.append(y_ind) - self.Model.sel_freq.append(Fr[sel, y_ind]) - self.Model.sel_xi.append(Sm[sel, y_ind]) - - if plot == "SSI": - self.Model.sel_phi.append(Ms[sel, y_ind, :]) - if plot == "pLSCF": - self.Model.sel_lam.append(Ls[sel, y_ind]) - - self.sort_selected_poles() - -#------------------------------------------------------------------------------ - - def on_click_FDD(self, event): - # on button 1 press (left mouse button) + SHIFT is held - if event.button == 1 and self.shift_is_held: - self.y_data_pole = [event.ydata] - self.x_data_pole = event.xdata - - self.get_closest_freq() - - self.plot_svPSD() - - # On button 3 press (left mouse button) - elif event.button == 3 and self.shift_is_held: - try: - del self.Model.sel_freq[-1] # delete last point - del self.Model.freq_ind[-1] - - self.plot_svPSD() - except: - pass - - elif event.button == 2 and self.shift_is_held: - i = np.argmin(np.abs(self.Model.sel_freq - event.xdata)) - try: - del self.Model.sel_freq[i] - del self.Model.freq_ind[i] - - self.plot_svPSD() - except: - pass - - - if self.shift_is_held: - self.plot_svPSD(update_ticks=True) - -#------------------------------------------------------------------------------ - - def on_click_SSI(self, event, plot): - # on button 1 press (left mouse button) + SHIFT is held - if event.button == 1 and self.shift_is_held: - self.y_data_pole = [event.ydata] - self.x_data_pole = event.xdata - - self.get_closest_pole(plot) - - self.plot_stab(plot) - - # On button 3 press (left mouse button) - elif event.button == 3 and self.shift_is_held: - try: - del self.Model.sel_freq[-1] # delete last point - del self.Model.sel_xi[-1] - del self.Model.pole_ind[-1] - if plot == "SSI": - del self.Model.sel_phi[-1] - - self.plot_stab(plot) - except: - pass - - elif event.button == 2 and self.shift_is_held: - i = np.argmin(np.abs(self.Model.sel_freq - event.xdata)) - try: - del self.Model.sel_freq[i] - del self.Model.sel_xi[i] - del self.Model.pole_ind[i] - if plot == "SSI": - del self.Model.sel_phi[i] - - self.plot_stab(plot) - except: - pass - - - if self.shift_is_held: - self.plot_stab(plot, update_ticks=True) - -#------------------------------------------------------------------------------ - - def on_key_press(self, event): - """Function triggered on key press (SHIFT).""" - if event.key == 'shift': - self.shift_is_held = True - - - def on_key_release(self, event): - """Function triggered on key release (SHIFT).""" - if event.key == 'shift': - self.shift_is_held = False - - - def on_closing(self): - self.root.destroy() - - - def toggle_legend(self, x): - if x: - self.show_legend = 1 - else: - self.show_legend = 0 - - self.plot_stab(self.plot) - - - def toggle_hide_poles(self, x): - if x: - self.hide_poles = 1 - else: - self.hide_poles = 0 - - self.plot_stab(self.plot) - - - def sort_selected_poles(self): - _ = np.argsort(self.Model.sel_freq) - self.Model.sel_freq = list(np.array(self.Model.sel_freq)[_]) - - - def show_help(self): - lines = [ - 'Pole selection help', - ' ', - '- Select a pole: SHIFT + LEFT mouse button', - '- Deselect a pole: SHIFT + RIGHT mouse button', - '- Deselect the closest pole (frequency wise): SHIFT + MIDDLE mouse button', - ] - tk.messagebox.showinfo('Picking poles', '\n'.join(lines)) - - - def save_this_figure(self): - filename = 'pole_chart_' - directory = 'pole_figures' - - if not os.path.exists(directory): - os.mkdir(directory) - - files = glob.glob(directory + '/*.png') - i = 1 - while True: - f = os.path.join(directory, filename + f'{i:0>3}.png') - if f not in files: - break - i += 1 - - self.fig.savefig(f) diff --git a/pyOMA2/Test.py b/pyOMA2/Test.py deleted file mode 100644 index dadac14..0000000 --- a/pyOMA2/Test.py +++ /dev/null @@ -1,75 +0,0 @@ -# -*- coding: utf-8 -*- -""" -Created on Fri Aug 18 18:48:53 2023 - -@author: dagpa -""" - -import pyOMA2 as oma - -import pandas as pd -import numpy as np -from scipy import signal - -# _file = r"C:\Users\dpa\OneDrive - Norsk Treteknisk Institutt\Dokumenter\Python Scripts\pyOMA_TEST\5DOF_fixed_ex1.txt" -# _file = r"X:\OneDrive - Norsk Treteknisk Institutt\Dokumenter\Python Scripts\pyOMA_TEST\5DOF_fixed_ex1.txt" - -# open the file with pandas and then convert to numpy array -# data = pd.read_csv(_file, header=0, sep="\t", index_col=False) -# data = data.to_numpy() - -# open the example data -data, (fn_ex, FI_ex, xi_ex) = oma.Exdata() - -# sampling frequency -fs = 100 - - -# ----------------------------------------------------------------------------- -# Filtering -data = signal.detrend(data, axis=0) # Trend rmoval -q = 5 # Decimation factor -data = signal.decimate(data, q, ftype='fir', axis=0) # Decimation -fs = fs/q # [Hz] Decimated sampling frequency -# ----------------------------------------------------------------------------- - - - -Test = oma.Model(data, fs) - - - - -#%% -# Run pLSCF -sel_freq = [0.89, 2.59, 4.1, 5.25, 6.0] - -Test.pLSCF(40) -# Test.sel_pole_pLSCF(freqlim=6.25) -Test.get_mod_pLSCF(sel_freq=sel_freq, order =39) - -# Run SSIcov -Test.SSIcov(30, ordmax=50) -# Test.sel_pole_SSI(freqlim=6.25) -Test.get_mod_SSI(sel_freq=[0.89, 2.59, 4.1, 5.25, 6.0], order = 30) - -# Run SSIdat -Test.SSIdat(30, ordmax=50) -# Test.sel_pole_SSI(freqlim=6.25) -Test.get_mod_SSI(sel_freq=[0.89, 2.59, 4.1, 5.25, 6.0], order = 44) - -# Run (E)FDD -Test.FDDsvp() -# Test.sel_peak_FDD(freqlim=8) -# Test.sel_peak_EFDD(freqlim=6.25) -Test.get_mod_EFDD(sel_freq=[0.89, 2.59, 4.1, 5.25, 6.0]) - -# Save dictionary of results -Res = Test.Results - -# Calculate MAC -MAC1 = oma.MAC(FI_ex, Test.Results["pLSCF"]["Phi"]) -MAC2 = oma.MAC(FI_ex, Test.Results["SSIcov"]["Phi"]) -MAC3 = oma.MAC(FI_ex, Test.Results["SSIdat"]["Phi"]) -MAC4 = oma.MAC(FI_ex, Test.Results["FDD"]["Phi"]) - diff --git a/pyOMA2/__init__.py b/pyOMA2/__init__.py deleted file mode 100644 index dd69e99..0000000 --- a/pyOMA2/__init__.py +++ /dev/null @@ -1,8 +0,0 @@ -__version__ = "0.1" - -from .OMA import Model -from .tools import * - -from .Sel_from_plot import SelFromPlot - -import warnings \ No newline at end of file diff --git a/pyOMA2/tools.py b/pyOMA2/tools.py deleted file mode 100644 index ac7d24d..0000000 --- a/pyOMA2/tools.py +++ /dev/null @@ -1,461 +0,0 @@ -# -*- coding: utf-8 -*- -""" -Created on Sun Aug 13 16:31:54 2023 - -@author: dpa -""" - -import numpy as np -from scipy import signal -import scipy as sp - -# ============================================================================= -# Helping Funcitons -# ============================================================================= -def MAC(phi_X, phi_A): - """Modal Assurance Criterion. - - The number of locations (axis 0) must be the same for ``phi_X`` and - ``phi_A``. The nubmer of modes (axis 1) is arbitrary. - - Literature: - [1] Maia, N. M. M., and J. M. M. Silva. - "Modal analysis identification techniques." Philosophical - Transactions of the Royal Society of London. Series A: - Mathematical, Physical and Engineering Sciences 359.1778 - (2001): 29-40. - - :param phi_X: Mode shape matrix X, shape: ``(n_locations, n_modes)`` - or ``n_locations``. - :param phi_A: Mode shape matrix A, shape: ``(n_locations, n_modes)`` - or ``n_locations``. - :return: MAC matrix. Returns MAC value if both ``phi_X`` and ``phi_A`` are - one-dimensional arrays. - """ - if phi_X.ndim == 1: - phi_X = phi_X[:, np.newaxis] - - if phi_A.ndim == 1: - phi_A = phi_A[:, np.newaxis] - - if phi_X.ndim > 2 or phi_A.ndim > 2: - raise Exception(f'Mode shape matrices must have 1 or 2 dimensions (phi_X: {phi_X.ndim}, phi_A: {phi_A.ndim})') - - if phi_X.shape[0] != phi_A.shape[0]: - raise Exception(f'Mode shapes must have the same first dimension (phi_X: {phi_X.shape[0]}, phi_A: {phi_A.shape[0]})') - - MAC = np.abs(np.conj(phi_X).T @ phi_A)**2 - for i in range(phi_X.shape[1]): - for j in range(phi_A.shape[1]): - MAC[i, j] = MAC[i, j]/\ - (np.conj(phi_X[:, i]) @ phi_X[:, i] *\ - np.conj(phi_A[:, j]) @ phi_A[:, j]) - - - if MAC.shape == (1, 1): - MAC = MAC[0, 0] - - return MAC - -# ----------------------------------------------------------------------------- - -def MSF(phi_1, phi_2): - """Modal Scale Factor. - - If ``phi_1`` and ``phi_2`` are matrices, multiple msf are returned. - - The MAF scales ``phi_1`` to ``phi_2`` when multiplying: ``msf*phi_1``. - Also takes care of 180 deg phase difference. - - :param phi_1: Mode shape matrix X, shape: ``(n_locations, n_modes)`` - or ``n_locations``. - :param phi_2: Mode shape matrix A, shape: ``(n_locations, n_modes)`` - or ``n_locations``. - :return: np.ndarray, MSF values - """ - if phi_1.ndim == 1: - phi_1 = phi_1[:, None] - if phi_2.ndim == 1: - phi_2 = phi_2[:, None] - - if phi_1.shape[0] != phi_2.shape[0] or phi_1.shape[1] != phi_2.shape[1]: - raise Exception(f'`phi_1` and `phi_2` must have the same shape: {phi_1.shape} and {phi_2.shape}') - - n_modes = phi_1.shape[1] - msf = [] - for i in range(n_modes): - _msf = (phi_2[:, i].T @ phi_1[:, i]) / \ - (phi_1[:, i].T @ phi_1[:, i]) - - msf.append(_msf) - - return np.array(msf).real - -# ----------------------------------------------------------------------------- - -def MCF(phi): - """ Modal complexity factor. - - The MCF ranges from 0 to 1. It returns 0 for real modes and 1 for complex modes. - When ``dtype`` of ``phi`` is ``complex``, the modes can still be real, if the angles - of all components are the same. - - Additional information on MCF: - http://www.svibs.com/resources/ARTeMIS_Modal_Help/Generic%20Complexity%20Plot.html - - :param phi: Complex mode shape matrix, shape: ``(n_locations, n_modes)`` - or ``n_locations``. - :return: MCF (a value between 0 and 1) - """ - if phi.ndim == 1: - phi = phi[:, None] - n_modes = phi.shape[1] - mcf = [] - for i in range(n_modes): - S_xx = np.dot(phi[:, i].real, phi[:, i].real) - S_yy = np.dot(phi[:, i].imag, phi[:, i].imag) - S_xy = np.dot(phi[:, i].real, phi[:, i].imag) - - _mcf = 1 - ((S_xx - S_yy)**2 + 4*S_xy**2) / (S_xx + S_yy)**2 - - mcf.append(_mcf) - return np.array(mcf) - -# ----------------------------------------------------------------------------- - -def _stab_SSI(Fr, Sm, Ms, ordmin, ordmax, err_fn, err_xi, err_ms): - """ - Helping function for the construction of the Stability Chart when using - Subspace Identification (SSI) method. - - This function performs stability analysis of identified poles. - It categorizes modes based on their stabilityin terms of frequency, - damping, and mode shape. - - :param Fr: Frequency poles, shape: ``(ordmax, ordmax/2+1)`` - :param Sm: Damping poles, shape: ``(ordmax, ordmax/2+1)`` - :param Ms: Mode shape array, shape: ``(ordmax, ordmax/2+1, nch)`` - :param ordmin: Minimum order of model - :param ordmax: Maximum order of model - :param err_fn: Threshold for relative frequency difference for stability checks - :param err_xi: Threshold for relative damping ratio difference for stability checks - :param err_ms: Threshold for Modal Assurance Criterion (MAC) for stability checks - - :return: Stability label matrix (Lab), shape: ``(n_locations, n_modes)`` - - 7: Stable (frequency, damping, mode shape) - - 6: Stable (frequency, mode shape) - - 5: Stable (frequency, damping) - - 4: Stable (damping, mode shape) - - 3: Stable (damping) - - 2: Stable (mode shape) - - 1: Stable (frequency) - - 0: New or unstable pole - - Note: - nch = number of channesl (number of time series) - """ - Lab = np.zeros(Fr.shape , dtype='int') - - for n in range(ordmin, ordmax+1, 2): - _ind_new = int((n-ordmin)/2) - - f_n = Fr[:,_ind_new].reshape(-1,1) - xi_n = Sm[:,_ind_new].reshape(-1,1) - phi_n = Ms[:, _ind_new, :] - - f_n1 = Fr[:,_ind_new-1].reshape(-1,1) - xi_n1 = Sm[:,_ind_new-1].reshape(-1,1) - phi_n1 = Ms[:, _ind_new-1, :] - - if n != 0 and n != 2: - - for i in range(len(f_n)): - - if np.isnan(f_n[i]): - pass - else: - - idx = np.nanargmin(np.abs(f_n1 - f_n[i] )) - - cond1 = np.abs(f_n[i] - f_n1[idx]) / f_n[i] - cond2 = np.abs(xi_n[i] - xi_n1[idx]) / xi_n[i] - cond3 = 1 - MAC(phi_n[i, :], phi_n1[idx, :]) - - if cond1 < err_fn and cond2 < err_xi and cond3 < err_ms: - Lab[i, _ind_new] = 7 # Stable - - elif cond1 < err_fn and cond3 < err_ms: - Lab[i, _ind_new] = 6 # Stable frequency, stable mode shape - - elif cond1 < err_fn and cond2 < err_xi: - Lab[i, _ind_new] = 5 # Stable frequency, stable damping - - elif cond2 < err_xi and cond3 < err_ms: - Lab[i, _ind_new] = 4 # Stable damping, stable mode shape - - elif cond2 < err_xi: - Lab[i, _ind_new] = 3 # Stable damping - - elif cond3 < err_ms: - Lab[i, _ind_new] = 2 # Stable mode shape - - elif cond1 < err_fn: - Lab[i, _ind_new] = 1 # Stable frequency - - else: - Lab[i, _ind_new] = 0 # Nuovo polo o polo instabile - - return Lab - -# ----------------------------------------------------------------------------- - -def _stab_pLSCF(Fr, Sm, ordmax, err_fn, err_xi, nch): - """ - Helping function for the construction of the Stability Chart when using - poly-reference Least Square Complex Frequency (pLSCF, also known as - Polymax) method. - - This function performs stability analysis of identified poles, it categorizes modes based on their stability in terms - of frequency and damping. - - :param Fr: Frequency matrix, shape: ``(n_locations, n_modes)`` - :param Sm: Damping matrix, shape: ``(n_locations, n_modes)`` - :param ordmax: Maximum order of modes to consider (exclusive) - :param err_fn: Threshold for relative frequency difference for stability checks - :param err_xi: Threshold for relative damping ratio difference for stability checks - :param nch: Number of channels (modes) in the analysis - - :return: Stability label matrix (Lab), shape: ``(n_locations, n_modes)`` - - 3: Stable Pole (frequency and damping) - - 2: Stable damping - - 1: Stable frequency - - 0: New or unstable pole - - Note: - - """ - Lab = np.zeros(Fr.shape , dtype='int') - - for nn in range(ordmax): - - f_n = Fr[:, nn].reshape(-1,1) - xi_n = Sm[:, nn].reshape(-1,1) - - f_n1 = Fr[:, nn-1].reshape(-1,1) - xi_n1 = Sm[:, nn-1].reshape(-1,1) - - if nn != 0: - - for i in range(len(f_n)): - - if np.isnan(f_n[i]): - pass - else: - try: - idx = np.nanargmin(np.abs(f_n1 - f_n[i] )) - - cond1 = np.abs(f_n[i] - f_n1[idx]) / f_n[i] - cond2 = np.abs(xi_n[i] - xi_n1[idx]) / xi_n[i] - - if cond1 < err_fn and cond2 < err_xi: - Lab[i, nn] = 3 # Stable Pole - - elif cond2 < err_xi: - Lab[i, nn] = 2 # Stable damping - - elif cond1 < err_fn: - Lab[i, nn] = 1 # Stable frequency - - else: - Lab[i, nn] = 0 # Nuovo polo o polo instabile - except: - pass - return Lab - -# ----------------------------------------------------------------------------- - -def Exdata(): - ''' - This function generates a time history of acceleration for a 5 DOF - system. - - The function returns a (360001,5) array and a tuple containing: the - natural frequencies of the system (fn = (5,) array); the unity - displacement normalised mode shapes matrix (FI_1 = (5,5) array); and the - damping ratios (xi = float) - - ------- - Returns - ------- - acc : 2D array - Time histories of the 5 DOF of the system. - (fn, FI_1, xi) : tuple - Tuple containing the natural frequencies (fn), the mode shape - matrix (FI_1), and the damping ratio (xi) of the system. - ''' - - rng = np.random.RandomState(12345) # Set the seed - fs = 100 # [Hz] Sampling freqiency - T = 3600 # [sec] Period of the time series (60 minutes) - - dt = 1/fs # [sec] time resolution - df = 1/T # [Hz] frequency resolution - N = int(T/dt) # number of data points - fmax = fs/2 # Nyquist frequency - - t = np.arange(0, T, dt) # time instants array - - fs = np.arange(0, fmax+df, df) # spectral lines array - - #------------------- - # SYSTEM DEFINITION - - m = 25.91 # mass - k = 10000. # stiffness - - # Mass matrix - M = np.eye(5)*m - _ndof = M.shape[0] # number of DOF (5) - - # Stiffness matrix - K = np.array([[2,-1,0,0,0], - [-1,2,-1,0,0], - [0,-1,2,-1,0], - [0,0,-1,2,-1], - [0,0,0,-1,1]])*k - - lam , FI = sp.linalg.eigh(K,b=M) # Solving eigen value problem - - fn = np.sqrt(lam)/(2*np.pi) # Natural frequencies - - # Unity displacement normalised mode shapes - FI_1 = np.array([FI[:,k]/max(abs(FI[:,k])) for k in range(_ndof)]).T - # Ordering from smallest to largest - FI_1 = FI_1[:, np.argsort(fn)] - fn = np.sort(fn) - - # K_M = FI_M.T @ K @ FI_M # Modal stiffness - M_M = FI_1.T @ M @ FI_1 # Modal mass - - xi = 0.02 # damping ratio for all modes (2%) - # Modal damping - C_M = np.diag(np.array([2*M_M[i, i]*xi*fn[i]*(2*np.pi) for i in range(_ndof)])) - - C = sp.linalg.inv(FI_1.T) @ C_M @ sp.linalg.inv(FI_1) # Damping matrix - # C = LA.solve(LA.solve(FI_1.T, C_M), FI_1) - # n = _ndof*2 # order of the system - - #------------------- - # STATE-SPACE FORMULATION - - a1 = np.zeros((_ndof,_ndof)) # Zeros (ndof x ndof) - a2 = np.eye(_ndof) # Identity (ndof x ndof) - A1 = np.hstack((a1,a2)) # horizontal stacking (ndof x 2*ndof) - a3 = -sp.linalg.inv(M) @ K # M^-1 @ K (ndof x ndof) - # a3 = -LA.solve(M, K) # M^-1 @ K (ndof x ndof) - a4 = -sp.linalg.inv(M) @ C # M^-1 @ C (ndof x ndof) - # a4 = -LA.solve(M, C) # M^-1 @ C (ndof x ndof) - A2 = np.hstack((a3,a4)) # horizontal stacking(ndof x 2*ndof) - # vertical stacking of A1 e A2 - Ac = np.vstack((A1,A2)) # State Matrix A (2*ndof x 2*ndof)) - - b2 = -sp.linalg.inv(M) - # Input Influence Matrix B (2*ndof x n°input=ndof) - Bc = np.vstack((a1,b2)) - - # N.B. number of rows = n°output*ndof - # n°output may be 1, 2 o 3 (displacements, velocities, accelerations) - # the Cc matrix has to be defined accordingly - c1 = np.hstack((a2,a1)) # displacements row - c2 = np.hstack((a1,a2)) # velocities row - c3 = np.hstack((a3,a4)) # accelerations row - # Output Influence Matrix C (n°output*ndof x 2*ndof) - Cc = np.vstack((c1,c2,c3)) - - # Direct Transmission Matrix D (n°output*ndof x n°input=ndof) - Dc = np.vstack((a1,a1, b2)) - - #------------------- - # Using SciPy's LTI to solve the system - - # Defining the system - sys = signal.lti(Ac, Bc, Cc, Dc) - - # Defining the amplitute of the force - af = 1 - - # Assembling the forcing vectors (N x ndof) (random white noise!) - # N.B. N=number of data points; ndof=number of DOF - u = np.array([rng.randn(N)*af for r in range(_ndof)]).T - - # Solving the system - tout, yout, xout = signal.lsim(sys, U=u, T=t) - - # d = yout[:,:5] # displacement - # v = yout[:,5:10] # velocity - a = yout[:,10:] # acceleration - - #------------------- - # Adding noise - # SNR = 10*np.log10(_af/_ar) - SNR = 10 # Signal-to-Noise ratio - ar = af/(10**(SNR/10)) # Noise amplitude - - # Initialize the arrays (copy of accelerations) - acc = a.copy() - for _ind in range(_ndof): - # Measurments POLLUTED BY NOISE - acc[:,_ind] = a[:,_ind] + ar*rng.randn(N) - - #------------------- - # # Subplot of the accelerations - # fig, axs = plt.subplots(5,1,sharex=True) - # for _nr in range(_ndof): - # axs[_nr].plot(t, a[:,_nr], alpha=1, linewidth=1, label=f'story{_nr+1}') - # axs[_nr].legend(loc=1, shadow=True, framealpha=1) - # axs[_nr].grid(alpha=0.3) - # axs[_nr].set_ylabel('$mm/s^2$') - # axs[_nr].set_xlabel('t [sec]') - # fig.suptitle('Accelerations plot', fontsize=12) - # plt.show() - - return acc, (fn,FI_1,xi) - -# ----------------------------------------------------------------------------- - -def merge_mode_shapes(MSarr_list, refsens_idx_list): - Nmodes = MSarr_list[0].shape[1] - Nsetup = len(MSarr_list) - Nref = len(refsens_idx_list[0]) - M = Nref + np.sum([ MSarr_list[i].shape[0]- Nref for i in range(Nsetup)]) - - # Check if the input arrays have consistent dimensions - - for i in range(1, Nsetup): - if MSarr_list[i].shape[1] != Nmodes: - raise ValueError("All mode shape arrays must have the same number of modes.") - - # Initialize merged mode shape array - merged_mode_shapes = np.zeros((M, Nmodes)) - - # Loop through each mode - for k in range(Nmodes): - phi_1_k = MSarr_list[0][:, k] # Save the mode shape from first setup - phi_ref_1_k = phi_1_k[refsens_idx_list[0]] # Save the reference sensors - - merged_mode_k = phi_1_k.copy() # initialise the merged mode shape - # Loop through each setup - for i in range(1, Nsetup): - ref_indices = refsens_idx_list[i] # reference sensors indices for the specific setup - phi_i_k = MSarr_list[i][:, k] # mode shape of setup i - phi_ref_i_k = MSarr_list[i][ref_indices, k] # save data from reference sensors - phi_rov_i_k = np.delete(phi_i_k, ref_indices, axis=0) # saave data from roving sensors - # Find scaling factor - alpha_i_k = MSF(phi_ref_1_k, phi_ref_i_k) - # Merge mode - merged_mode_k = np.hstack((merged_mode_k, alpha_i_k * phi_rov_i_k )) - - merged_mode_shapes[:, k] = merged_mode_k - - return merged_mode_shapes - diff --git a/pyproject.toml b/pyproject.toml new file mode 100644 index 0000000..7bf6b67 --- /dev/null +++ b/pyproject.toml @@ -0,0 +1,141 @@ +[project] +name = "pyOMA_2" +version = "1.1.1" +description = "Python module for conducting Operational Modal Analysis" +authors = [ + {name = "Dag Pasca", email = "dpa@treteknisk.no"}, + {name = "Angelo Aloisio", email = "angelo.aloisio1@univaq.it"}, + {name = "Marco Martino Rosso", email = "marco.rosso@polito.it"}, + {name = "Diego Federico Margoni", email = "diegofederico.margoni@studenti.polito.it"}, +] +dependencies = [ + "numpy>=1.20,<1.25; python_version < '3.9'", + "numpy>=1.25; python_version >= '3.9'", + "pandas>=2.0.3", + "scipy>=1.9.3", + "pydantic>=2.5.1", + "tqdm>=4.66.1", + "matplotlib>=3.7.4", +] +requires-python = ">=3.8,<3.13" +readme = "README.md" +license = {text = "MIT"} + + +[project.urls] +Homepage = "https://github.com/dagghe/pyOMA2" +Documentation = "https://pyoma.readthedocs.io/en/main/" +Repository = "https://github.com/dagghe/pyOMA2" +Changelog = "https://github.com/dagghe/pyOMA2/blob/main/CHANGELOG.md" +Contributing = "https://github.com/dagghe/pyOMA2/blob/main/CONTRIBUTING.md" + + +[project.optional-dependencies] +pyvista = [ + "pyvista[all]", + "pyvistaqt", + "PyQt5==5.15.10", + "PyQt5-Qt5==5.15.2; sys_platform != 'darwin'", + "PyQt5-Qt5==5.15.14; sys_platform == 'darwin'", + "PyQt5-sip==12.15.0", + # # For macOS with Python 3.8, users will need to manually install the specific vtk wheel + # "vtk @ https://files.pythonhosted.org/packages/b3/15/40f8264f1b5379f12caf0e5153006a61c1f808937877c996e907610e8f23/vtk-9.3.1-cp38-cp38-macosx_10_10_x86_64.whl ; python_version == '3.8' and sys_platform == 'darwin'", + "vtk==9.3.1; python_version != '3.8' or sys_platform != 'darwin'", +] +openpyxl = [ + "openpyxl>=3.1.3", +] + +[build-system] +requires = ["pdm-backend"] +build-backend = "pdm.backend" + + +[tool.ruff] +# Exclude common directories that are typically not part of the source code or are generated by tools. +exclude = [ + ".direnv", + ".eggs", + ".git", + ".git-rewrite", + ".hg", + ".mypy_cache", + ".nox", + ".pants.d", + ".pytype", + ".ruff_cache", + ".svn", + ".tox", + "__pypackages__", + "_build", + "build", + "dist", + "venv", + ".venv", +] + +# Set the maximum line length to 90 characters. +line-length = 90 + +# Define the number of spaces used for indentation, aligning with Black's style. +indent-width = 4 + +# The minimum Python version to target, e.g., when considering automatic code upgrades, +# like rewriting type annotations +target-version = "py38" + +[tool.ruff.lint] +# Enable Pyflakes (F) and a subset of the pycodestyle (E) codes by default. +# pycodestyle warnings (W) +# Activate Security Rules (S) to replace bandit +# Enable the isort rules (I) to replace isort +# flake8-bugbear (B) +# flake8-simplify (SIM) +select = ["F", "E4", "E7", "E9", "W", "S", "I", "B","SIM"] +ignore = [ + "S101", # User of assert in code + "B011", # assert False +] # List any rules to be ignored, currently empty. + +# Allow auto-fixing of all enabled rules when using the `--fix` option. +fixable = ["ALL"] +unfixable = [] # Specify rules that cannot be auto-fixed, if any. + +# Define a regex pattern for allowed unused variables (typically underscore-prefixed). +dummy-variable-rgx = "^(_+|(_+[a-zA-Z0-9_]*[a-zA-Z0-9]+?))$" + +[tool.ruff.format] +# Enforce double quotes for strings, following Black's style. +quote-style = "double" + +# Use spaces for indentation, in line with Black's formatting style. +indent-style = "space" + +# Keep magic trailing commas, a feature of Black's formatting. +skip-magic-trailing-comma = false + +# Automatically detect and use the appropriate line ending style. +line-ending = "auto" + +[tool.ruff.lint.per-file-ignores] +"__init__.py" = [ + "E402", # import violations + "F401", # imported but unused +] + +[tool.pdm.dev-dependencies] +docs = [ + "sphinx>=7.1.2", + "sphinx-rtd-theme>=2.0.0", + "ghp-import>=2.1.0", + "nbsphinx>=0.9.3", + "pandoc>=2.3", +] +qa = [ + "pre-commit>=3.5.0", + "ipdb>=0.13.13", + "pytest>=7.4.4", + "pytest-cov>=4.1.0", + "notebook>=7.1.2", + "tox>=4.14.2", +] diff --git a/requirements/requirementspy38mac.txt b/requirements/requirementspy38mac.txt new file mode 100644 index 0000000..1ee2cef --- /dev/null +++ b/requirements/requirementspy38mac.txt @@ -0,0 +1,195 @@ +# This file is @generated by PDM. +# Please do not edit it manually. + +aiohappyeyeballs==2.4.0; python_version == "3.8" +aiohttp==3.10.11; python_version == "3.8" +aiosignal==1.3.1; python_version == "3.8" +alabaster==0.7.13; python_version == "3.8" +annotated-types==0.7.0; python_version == "3.8" +anyio==4.4.0; python_version == "3.8" +appnope==0.1.4; platform_system == "Darwin" and python_version == "3.8" or sys_platform == "darwin" and python_version == "3.8" +argon2-cffi==23.1.0; python_version == "3.8" +argon2-cffi-bindings==21.2.0; python_version == "3.8" +arrow==1.3.0; python_version == "3.8" +asttokens==2.4.1; python_version == "3.8" +async-lru==2.0.4; python_version == "3.8" +async-timeout==4.0.3; python_version == "3.8" +attrs==24.2.0; python_version == "3.8" +babel==2.16.0; python_version == "3.8" +backcall==0.2.0; python_version == "3.8" +beautifulsoup4==4.12.3; python_version == "3.8" +bleach[css]==6.1.0; python_version == "3.8" +cachetools==5.5.0; python_version == "3.8" +certifi==2024.8.30; python_version == "3.8" +cffi==1.17.1; python_version == "3.8" +cfgv==3.4.0; python_version == "3.8" +chardet==5.2.0; python_version == "3.8" +charset-normalizer==3.3.2; python_version == "3.8" +cmocean==4.0.3; python_version == "3.8" +colorama==0.4.6; python_version == "3.8" +colorcet==3.1.0; python_version == "3.8" +comm==0.2.2; python_version == "3.8" +contourpy==1.1.1; python_version == "3.8" +coverage[toml]==7.6.1; python_version == "3.8" +cycler==0.12.1; python_version == "3.8" +debugpy==1.8.5; python_version == "3.8" +decorator==5.1.1; python_version == "3.8" +defusedxml==0.7.1; python_version == "3.8" +distlib==0.3.8; python_version == "3.8" +docutils==0.20.1; python_version == "3.8" +et-xmlfile==1.1.0; python_version == "3.8" +exceptiongroup==1.2.2; python_version == "3.8" +executing==2.1.0; python_version == "3.8" +fastjsonschema==2.20.0; python_version == "3.8" +filelock==3.16.1; python_version == "3.8" +fonttools==4.53.1; python_version == "3.8" +fqdn==1.5.1; python_version == "3.8" +frozenlist==1.4.1; python_version == "3.8" +ghp-import==2.1.0; python_version == "3.8" +h11==0.14.0; python_version == "3.8" +httpcore==1.0.5; python_version == "3.8" +httpx==0.27.2; python_version == "3.8" +identify==2.6.0; python_version == "3.8" +idna==3.8; python_version == "3.8" +imageio==2.35.1; python_version == "3.8" +imagesize==1.4.1; python_version == "3.8" +importlib-metadata==8.5.0; python_version == "3.8" +importlib-resources==6.4.5; python_version == "3.8" +iniconfig==2.0.0; python_version == "3.8" +ipdb==0.13.13; python_version == "3.8" +ipykernel==6.29.5; python_version == "3.8" +ipython==8.12.3; python_version == "3.8" +ipywidgets==8.1.5; python_version == "3.8" +isoduration==20.11.0; python_version == "3.8" +jedi==0.19.1; python_version == "3.8" +jinja2==3.1.5; python_version == "3.8" +json5==0.9.25; python_version == "3.8" +jsonpointer==3.0.0; python_version == "3.8" +jsonschema-specifications==2023.12.1; python_version == "3.8" +jsonschema[format-nongpl]==4.23.0; python_version == "3.8" +jupyter-client==8.6.3; python_version == "3.8" +jupyter-core==5.7.2; python_version == "3.8" +jupyter-events==0.10.0; python_version == "3.8" +jupyter-lsp==2.2.5; python_version == "3.8" +jupyter-server==2.14.2; python_version == "3.8" +jupyter-server-proxy==4.4.0; python_version == "3.8" +jupyter-server-terminals==0.5.3; python_version == "3.8" +jupyterlab==4.3.5; python_version == "3.8" +jupyterlab-pygments==0.3.0; python_version == "3.8" +jupyterlab-server==2.27.3; python_version == "3.8" +jupyterlab-widgets==3.0.13; python_version == "3.8" +kiwisolver==1.4.7; python_version == "3.8" +markdown-it-py==3.0.0; python_version == "3.8" +markupsafe==2.1.5; python_version == "3.8" +matplotlib==3.7.5; python_version == "3.8" +matplotlib-inline==0.1.7; python_version == "3.8" +mdurl==0.1.2; python_version == "3.8" +meshio==5.3.5; python_version == "3.8" +mistune==3.0.2; python_version == "3.8" +more-itertools==10.5.0; python_version == "3.8" +msgpack==1.1.0; python_version == "3.8" +multidict==6.1.0; python_version == "3.8" +nbclient==0.10.0; python_version == "3.8" +nbconvert==7.16.6; python_version == "3.8" +nbformat==5.10.4; python_version == "3.8" +nbsphinx==0.9.6; python_version == "3.8" +nest-asyncio==1.6.0; python_version == "3.8" +nodeenv==1.9.1; python_version == "3.8" +notebook==7.3.2; python_version == "3.8" +notebook-shim==0.2.4; python_version == "3.8" +numpy==1.24.4; python_version == "3.8" +openpyxl==3.1.5; python_version == "3.8" +overrides==7.7.0; python_version == "3.8" +packaging==24.2; python_version == "3.8" +pandas==2.0.3; python_version == "3.8" +pandoc==2.4; python_version == "3.8" +pandocfilters==1.5.1; python_version == "3.8" +parso==0.8.4; python_version == "3.8" +pexpect==4.9.0; sys_platform != "win32" and python_version == "3.8" +pickleshare==0.7.5; python_version == "3.8" +pillow==10.4.0; python_version == "3.8" +pkgutil-resolve-name==1.3.10; python_version == "3.8" +platformdirs==4.3.6; python_version == "3.8" +pluggy==1.5.0; python_version == "3.8" +plumbum==1.8.3; python_version == "3.8" +ply==3.11; python_version == "3.8" +pooch==1.8.2; python_version == "3.8" +pre-commit==3.5.0; python_version == "3.8" +prometheus-client==0.20.0; python_version == "3.8" +prompt-toolkit==3.0.47; python_version == "3.8" +propcache==0.2.0; python_version == "3.8" +psutil==6.0.0; python_version == "3.8" +ptyprocess==0.7.0; os_name != "nt" and python_version == "3.8" or sys_platform != "win32" and python_version == "3.8" +pure-eval==0.2.3; python_version == "3.8" +pycparser==2.22; python_version == "3.8" +pydantic==2.9.1; python_version == "3.8" +pydantic-core==2.23.3; python_version == "3.8" +pygments==2.18.0; python_version == "3.8" +pyparsing==3.1.4; python_version == "3.8" +pyproject-api==1.8.0; python_version == "3.8" +pyqt5==5.15.10; python_version == "3.8" +pyqt5-qt5==5.15.14; python_version == "3.8" +pyqt5-sip==12.15.0; python_version == "3.8" +pytest==8.3.3; python_version == "3.8" +pytest-cov==5.0.0; python_version == "3.8" +python-dateutil==2.9.0.post0; python_version == "3.8" +python-json-logger==2.0.7; python_version == "3.8" +pytz==2024.2; python_version == "3.8" +pyvista[all]==0.44.1; python_version == "3.8" +pyvista[colormaps,io,jupyter]==0.44.1; python_version == "3.8" +pyvistaqt==0.11.1; python_version == "3.8" +pyyaml==6.0.2; python_version == "3.8" +pyzmq==26.2.0; python_version == "3.8" +qtpy==2.4.1; python_version == "3.8" +referencing==0.35.1; python_version == "3.8" +requests==2.32.3; python_version == "3.8" +rfc3339-validator==0.1.4; python_version == "3.8" +rfc3986-validator==0.1.1; python_version == "3.8" +rich==13.8.1; python_version == "3.8" +rpds-py==0.20.0; python_version == "3.8" +scipy==1.10.1; python_version == "3.8" +scooby==0.10.0; python_version == "3.8" +send2trash==1.8.3; python_version == "3.8" +setuptools==74.1.2; python_version == "3.8" +simpervisor==1.0.0; python_version == "3.8" +six==1.16.0; python_version == "3.8" +sniffio==1.3.1; python_version == "3.8" +snowballstemmer==2.2.0; python_version == "3.8" +soupsieve==2.6; python_version == "3.8" +sphinx==7.1.2; python_version == "3.8" +sphinx-rtd-theme==2.0.0; python_version == "3.8" +sphinxcontrib-applehelp==1.0.4; python_version == "3.8" +sphinxcontrib-devhelp==1.0.2; python_version == "3.8" +sphinxcontrib-htmlhelp==2.0.1; python_version == "3.8" +sphinxcontrib-jquery==4.1; python_version == "3.8" +sphinxcontrib-jsmath==1.0.1; python_version == "3.8" +sphinxcontrib-qthelp==1.0.3; python_version == "3.8" +sphinxcontrib-serializinghtml==1.1.5; python_version == "3.8" +stack-data==0.6.3; python_version == "3.8" +terminado==0.18.1; python_version == "3.8" +tinycss2==1.2.1; python_version == "3.8" +tomli==2.2.1; python_version == "3.8" +tornado==6.4.2; python_version == "3.8" +tox==4.24.1; python_version == "3.8" +tqdm==4.66.5; python_version == "3.8" +traitlets==5.14.3; python_version == "3.8" +trame==3.6.5; python_version == "3.8" +trame-client==3.2.5; python_version == "3.8" +trame-server==3.1.2; python_version == "3.8" +trame-vtk==2.8.10; python_version == "3.8" +trame-vuetify==2.7.1; python_version == "3.8" +types-python-dateutil==2.9.0.20240906; python_version == "3.8" +typing-extensions==4.12.2; python_version == "3.8" +tzdata==2024.1; python_version == "3.8" +uri-template==1.3.0; python_version == "3.8" +urllib3==2.2.2; python_version == "3.8" +virtualenv==20.29.1; python_version == "3.8" +vtk==9.3.1; python_version == "3.8" +wcwidth==0.2.13; python_version == "3.8" +webcolors==24.8.0; python_version == "3.8" +webencodings==0.5.1; python_version == "3.8" +websocket-client==1.8.0; python_version == "3.8" +widgetsnbextension==4.0.13; python_version == "3.8" +wslink==2.1.3; python_version == "3.8" +yarl==1.15.2; python_version == "3.8" +zipp==3.20.1; python_version == "3.8" diff --git a/requirements/requirementspy38unix.txt b/requirements/requirementspy38unix.txt new file mode 100644 index 0000000..aeaf35b --- /dev/null +++ b/requirements/requirementspy38unix.txt @@ -0,0 +1,194 @@ +# This file is @generated by PDM. +# Please do not edit it manually. + +aiohappyeyeballs==2.4.0; python_version == "3.8" +aiohttp==3.10.11; python_version == "3.8" +aiosignal==1.3.1; python_version == "3.8" +alabaster==0.7.13; python_version == "3.8" +annotated-types==0.7.0; python_version == "3.8" +anyio==4.4.0; python_version == "3.8" +argon2-cffi==23.1.0; python_version == "3.8" +argon2-cffi-bindings==21.2.0; python_version == "3.8" +arrow==1.3.0; python_version == "3.8" +asttokens==2.4.1; python_version == "3.8" +async-lru==2.0.4; python_version == "3.8" +async-timeout==4.0.3; python_version == "3.8" +attrs==24.2.0; python_version == "3.8" +babel==2.16.0; python_version == "3.8" +backcall==0.2.0; python_version == "3.8" +beautifulsoup4==4.12.3; python_version == "3.8" +bleach[css]==6.1.0; python_version == "3.8" +cachetools==5.5.0; python_version == "3.8" +certifi==2024.8.30; python_version == "3.8" +cffi==1.17.1; python_version == "3.8" +cfgv==3.4.0; python_version == "3.8" +chardet==5.2.0; python_version == "3.8" +charset-normalizer==3.3.2; python_version == "3.8" +cmocean==4.0.3; python_version == "3.8" +colorama==0.4.6; python_version == "3.8" +colorcet==3.1.0; python_version == "3.8" +comm==0.2.2; python_version == "3.8" +contourpy==1.1.1; python_version == "3.8" +coverage[toml]==7.6.1; python_version == "3.8" +cycler==0.12.1; python_version == "3.8" +debugpy==1.8.5; python_version == "3.8" +decorator==5.1.1; python_version == "3.8" +defusedxml==0.7.1; python_version == "3.8" +distlib==0.3.8; python_version == "3.8" +docutils==0.20.1; python_version == "3.8" +et-xmlfile==1.1.0; python_version == "3.8" +exceptiongroup==1.2.2; python_version == "3.8" +executing==2.1.0; python_version == "3.8" +fastjsonschema==2.20.0; python_version == "3.8" +filelock==3.16.1; python_version == "3.8" +fonttools==4.53.1; python_version == "3.8" +fqdn==1.5.1; python_version == "3.8" +frozenlist==1.4.1; python_version == "3.8" +ghp-import==2.1.0; python_version == "3.8" +h11==0.14.0; python_version == "3.8" +httpcore==1.0.5; python_version == "3.8" +httpx==0.27.2; python_version == "3.8" +identify==2.6.0; python_version == "3.8" +idna==3.8; python_version == "3.8" +imageio==2.35.1; python_version == "3.8" +imagesize==1.4.1; python_version == "3.8" +importlib-metadata==8.5.0; python_version == "3.8" +importlib-resources==6.4.5; python_version == "3.8" +iniconfig==2.0.0; python_version == "3.8" +ipdb==0.13.13; python_version == "3.8" +ipykernel==6.29.5; python_version == "3.8" +ipython==8.12.3; python_version == "3.8" +ipywidgets==8.1.5; python_version == "3.8" +isoduration==20.11.0; python_version == "3.8" +jedi==0.19.1; python_version == "3.8" +jinja2==3.1.5; python_version == "3.8" +json5==0.9.25; python_version == "3.8" +jsonpointer==3.0.0; python_version == "3.8" +jsonschema-specifications==2023.12.1; python_version == "3.8" +jsonschema[format-nongpl]==4.23.0; python_version == "3.8" +jupyter-client==8.6.3; python_version == "3.8" +jupyter-core==5.7.2; python_version == "3.8" +jupyter-events==0.10.0; python_version == "3.8" +jupyter-lsp==2.2.5; python_version == "3.8" +jupyter-server==2.14.2; python_version == "3.8" +jupyter-server-proxy==4.4.0; python_version == "3.8" +jupyter-server-terminals==0.5.3; python_version == "3.8" +jupyterlab==4.3.5; python_version == "3.8" +jupyterlab-pygments==0.3.0; python_version == "3.8" +jupyterlab-server==2.27.3; python_version == "3.8" +jupyterlab-widgets==3.0.13; python_version == "3.8" +kiwisolver==1.4.7; python_version == "3.8" +markdown-it-py==3.0.0; python_version == "3.8" +markupsafe==2.1.5; python_version == "3.8" +matplotlib==3.7.5; python_version == "3.8" +matplotlib-inline==0.1.7; python_version == "3.8" +mdurl==0.1.2; python_version == "3.8" +meshio==5.3.5; python_version == "3.8" +mistune==3.0.2; python_version == "3.8" +more-itertools==10.5.0; python_version == "3.8" +msgpack==1.1.0; python_version == "3.8" +multidict==6.1.0; python_version == "3.8" +nbclient==0.10.0; python_version == "3.8" +nbconvert==7.16.6; python_version == "3.8" +nbformat==5.10.4; python_version == "3.8" +nbsphinx==0.9.6; python_version == "3.8" +nest-asyncio==1.6.0; python_version == "3.8" +nodeenv==1.9.1; python_version == "3.8" +notebook==7.3.2; python_version == "3.8" +notebook-shim==0.2.4; python_version == "3.8" +numpy==1.24.4; python_version == "3.8" +openpyxl==3.1.5; python_version == "3.8" +overrides==7.7.0; python_version == "3.8" +packaging==24.2; python_version == "3.8" +pandas==2.0.3; python_version == "3.8" +pandoc==2.4; python_version == "3.8" +pandocfilters==1.5.1; python_version == "3.8" +parso==0.8.4; python_version == "3.8" +pexpect==4.9.0; sys_platform != "win32" and python_version == "3.8" +pickleshare==0.7.5; python_version == "3.8" +pillow==10.4.0; python_version == "3.8" +pkgutil-resolve-name==1.3.10; python_version == "3.8" +platformdirs==4.3.6; python_version == "3.8" +pluggy==1.5.0; python_version == "3.8" +plumbum==1.8.3; python_version == "3.8" +ply==3.11; python_version == "3.8" +pooch==1.8.2; python_version == "3.8" +pre-commit==3.5.0; python_version == "3.8" +prometheus-client==0.20.0; python_version == "3.8" +prompt-toolkit==3.0.47; python_version == "3.8" +propcache==0.2.0; python_version == "3.8" +psutil==6.0.0; python_version == "3.8" +ptyprocess==0.7.0; os_name != "nt" and python_version == "3.8" or sys_platform != "win32" and python_version == "3.8" +pure-eval==0.2.3; python_version == "3.8" +pycparser==2.22; python_version == "3.8" +pydantic==2.9.1; python_version == "3.8" +pydantic-core==2.23.3; python_version == "3.8" +pygments==2.18.0; python_version == "3.8" +pyparsing==3.1.4; python_version == "3.8" +pyproject-api==1.8.0; python_version == "3.8" +pyqt5==5.15.10; python_version == "3.8" +pyqt5-qt5==5.15.2; python_version == "3.8" +pyqt5-sip==12.15.0; python_version == "3.8" +pytest==8.3.3; python_version == "3.8" +pytest-cov==5.0.0; python_version == "3.8" +python-dateutil==2.9.0.post0; python_version == "3.8" +python-json-logger==2.0.7; python_version == "3.8" +pytz==2024.2; python_version == "3.8" +pyvista[all]==0.44.1; python_version == "3.8" +pyvista[colormaps,io,jupyter]==0.44.1; python_version == "3.8" +pyvistaqt==0.11.1; python_version == "3.8" +pyyaml==6.0.2; python_version == "3.8" +pyzmq==26.2.0; python_version == "3.8" +qtpy==2.4.1; python_version == "3.8" +referencing==0.35.1; python_version == "3.8" +requests==2.32.3; python_version == "3.8" +rfc3339-validator==0.1.4; python_version == "3.8" +rfc3986-validator==0.1.1; python_version == "3.8" +rich==13.8.1; python_version == "3.8" +rpds-py==0.20.0; python_version == "3.8" +scipy==1.10.1; python_version == "3.8" +scooby==0.10.0; python_version == "3.8" +send2trash==1.8.3; python_version == "3.8" +setuptools==74.1.2; python_version == "3.8" +simpervisor==1.0.0; python_version == "3.8" +six==1.16.0; python_version == "3.8" +sniffio==1.3.1; python_version == "3.8" +snowballstemmer==2.2.0; python_version == "3.8" +soupsieve==2.6; python_version == "3.8" +sphinx==7.1.2; python_version == "3.8" +sphinx-rtd-theme==2.0.0; python_version == "3.8" +sphinxcontrib-applehelp==1.0.4; python_version == "3.8" +sphinxcontrib-devhelp==1.0.2; python_version == "3.8" +sphinxcontrib-htmlhelp==2.0.1; python_version == "3.8" +sphinxcontrib-jquery==4.1; python_version == "3.8" +sphinxcontrib-jsmath==1.0.1; python_version == "3.8" +sphinxcontrib-qthelp==1.0.3; python_version == "3.8" +sphinxcontrib-serializinghtml==1.1.5; python_version == "3.8" +stack-data==0.6.3; python_version == "3.8" +terminado==0.18.1; python_version == "3.8" +tinycss2==1.2.1; python_version == "3.8" +tomli==2.2.1; python_version == "3.8" +tornado==6.4.2; python_version == "3.8" +tox==4.24.1; python_version == "3.8" +tqdm==4.66.5; python_version == "3.8" +traitlets==5.14.3; python_version == "3.8" +trame==3.6.5; python_version == "3.8" +trame-client==3.2.5; python_version == "3.8" +trame-server==3.1.2; python_version == "3.8" +trame-vtk==2.8.10; python_version == "3.8" +trame-vuetify==2.7.1; python_version == "3.8" +types-python-dateutil==2.9.0.20240906; python_version == "3.8" +typing-extensions==4.12.2; python_version == "3.8" +tzdata==2024.1; python_version == "3.8" +uri-template==1.3.0; python_version == "3.8" +urllib3==2.2.2; python_version == "3.8" +virtualenv==20.29.1; python_version == "3.8" +vtk==9.3.1; python_version == "3.8" +wcwidth==0.2.13; python_version == "3.8" +webcolors==24.8.0; python_version == "3.8" +webencodings==0.5.1; python_version == "3.8" +websocket-client==1.8.0; python_version == "3.8" +widgetsnbextension==4.0.13; python_version == "3.8" +wslink==2.1.3; python_version == "3.8" +yarl==1.15.2; python_version == "3.8" +zipp==3.20.1; python_version == "3.8" diff --git a/requirements/requirementspy38win.txt b/requirements/requirementspy38win.txt new file mode 100644 index 0000000..5fae151 --- /dev/null +++ b/requirements/requirementspy38win.txt @@ -0,0 +1,194 @@ +# This file is @generated by PDM. +# Please do not edit it manually. + +aiohappyeyeballs==2.4.0; python_version == "3.8" +aiohttp==3.10.11; python_version == "3.8" +aiosignal==1.3.1; python_version == "3.8" +alabaster==0.7.13; python_version == "3.8" +annotated-types==0.7.0; python_version == "3.8" +anyio==4.4.0; python_version == "3.8" +argon2-cffi==23.1.0; python_version == "3.8" +argon2-cffi-bindings==21.2.0; python_version == "3.8" +arrow==1.3.0; python_version == "3.8" +asttokens==2.4.1; python_version == "3.8" +async-lru==2.0.4; python_version == "3.8" +async-timeout==4.0.3; python_version == "3.8" +attrs==24.2.0; python_version == "3.8" +babel==2.16.0; python_version == "3.8" +backcall==0.2.0; python_version == "3.8" +beautifulsoup4==4.12.3; python_version == "3.8" +bleach[css]==6.1.0; python_version == "3.8" +cachetools==5.5.0; python_version == "3.8" +certifi==2024.8.30; python_version == "3.8" +cffi==1.17.1; python_version == "3.8" +cfgv==3.4.0; python_version == "3.8" +chardet==5.2.0; python_version == "3.8" +charset-normalizer==3.3.2; python_version == "3.8" +cmocean==4.0.3; python_version == "3.8" +colorama==0.4.6; python_version == "3.8" +colorcet==3.1.0; python_version == "3.8" +comm==0.2.2; python_version == "3.8" +contourpy==1.1.1; python_version == "3.8" +coverage[toml]==7.6.1; python_version == "3.8" +cycler==0.12.1; python_version == "3.8" +debugpy==1.8.5; python_version == "3.8" +decorator==5.1.1; python_version == "3.8" +defusedxml==0.7.1; python_version == "3.8" +distlib==0.3.8; python_version == "3.8" +docutils==0.20.1; python_version == "3.8" +et-xmlfile==1.1.0; python_version == "3.8" +exceptiongroup==1.2.2; python_version == "3.8" +executing==2.1.0; python_version == "3.8" +fastjsonschema==2.20.0; python_version == "3.8" +filelock==3.16.1; python_version == "3.8" +fonttools==4.53.1; python_version == "3.8" +fqdn==1.5.1; python_version == "3.8" +frozenlist==1.4.1; python_version == "3.8" +ghp-import==2.1.0; python_version == "3.8" +h11==0.14.0; python_version == "3.8" +httpcore==1.0.5; python_version == "3.8" +httpx==0.27.2; python_version == "3.8" +identify==2.6.0; python_version == "3.8" +idna==3.8; python_version == "3.8" +imageio==2.35.1; python_version == "3.8" +imagesize==1.4.1; python_version == "3.8" +importlib-metadata==8.5.0; python_version == "3.8" +importlib-resources==6.4.5; python_version == "3.8" +iniconfig==2.0.0; python_version == "3.8" +ipdb==0.13.13; python_version == "3.8" +ipykernel==6.29.5; python_version == "3.8" +ipython==8.12.3; python_version == "3.8" +ipywidgets==8.1.5; python_version == "3.8" +isoduration==20.11.0; python_version == "3.8" +jedi==0.19.1; python_version == "3.8" +jinja2==3.1.5; python_version == "3.8" +json5==0.9.25; python_version == "3.8" +jsonpointer==3.0.0; python_version == "3.8" +jsonschema-specifications==2023.12.1; python_version == "3.8" +jsonschema[format-nongpl]==4.23.0; python_version == "3.8" +jupyter-client==8.6.3; python_version == "3.8" +jupyter-core==5.7.2; python_version == "3.8" +jupyter-events==0.10.0; python_version == "3.8" +jupyter-lsp==2.2.5; python_version == "3.8" +jupyter-server==2.14.2; python_version == "3.8" +jupyter-server-proxy==4.4.0; python_version == "3.8" +jupyter-server-terminals==0.5.3; python_version == "3.8" +jupyterlab==4.3.5; python_version == "3.8" +jupyterlab-pygments==0.3.0; python_version == "3.8" +jupyterlab-server==2.27.3; python_version == "3.8" +jupyterlab-widgets==3.0.13; python_version == "3.8" +kiwisolver==1.4.7; python_version == "3.8" +markdown-it-py==3.0.0; python_version == "3.8" +markupsafe==2.1.5; python_version == "3.8" +matplotlib==3.7.5; python_version == "3.8" +matplotlib-inline==0.1.7; python_version == "3.8" +mdurl==0.1.2; python_version == "3.8" +meshio==5.3.5; python_version == "3.8" +mistune==3.0.2; python_version == "3.8" +more-itertools==10.5.0; python_version == "3.8" +msgpack==1.1.0; python_version == "3.8" +multidict==6.1.0; python_version == "3.8" +nbclient==0.10.0; python_version == "3.8" +nbconvert==7.16.6; python_version == "3.8" +nbformat==5.10.4; python_version == "3.8" +nbsphinx==0.9.6; python_version == "3.8" +nest-asyncio==1.6.0; python_version == "3.8" +nodeenv==1.9.1; python_version == "3.8" +notebook==7.3.2; python_version == "3.8" +notebook-shim==0.2.4; python_version == "3.8" +numpy==1.24.4; python_version == "3.8" +openpyxl==3.1.5; python_version == "3.8" +overrides==7.7.0; python_version == "3.8" +packaging==24.2; python_version == "3.8" +pandas==2.0.3; python_version == "3.8" +pandoc==2.4; python_version == "3.8" +pandocfilters==1.5.1; python_version == "3.8" +parso==0.8.4; python_version == "3.8" +pickleshare==0.7.5; python_version == "3.8" +pillow==10.4.0; python_version == "3.8" +pkgutil-resolve-name==1.3.10; python_version == "3.8" +platformdirs==4.3.6; python_version == "3.8" +pluggy==1.5.0; python_version == "3.8" +plumbum==1.8.3; python_version == "3.8" +ply==3.11; python_version == "3.8" +pooch==1.8.2; python_version == "3.8" +pre-commit==3.5.0; python_version == "3.8" +prometheus-client==0.20.0; python_version == "3.8" +prompt-toolkit==3.0.47; python_version == "3.8" +propcache==0.2.0; python_version == "3.8" +psutil==6.0.0; python_version == "3.8" +pure-eval==0.2.3; python_version == "3.8" +pycparser==2.22; python_version == "3.8" +pydantic==2.9.1; python_version == "3.8" +pydantic-core==2.23.3; python_version == "3.8" +pygments==2.18.0; python_version == "3.8" +pyparsing==3.1.4; python_version == "3.8" +pyproject-api==1.8.0; python_version == "3.8" +pyqt5==5.15.10; python_version == "3.8" +pyqt5-qt5==5.15.2; python_version == "3.8" +pyqt5-sip==12.15.0; python_version == "3.8" +pytest==8.3.3; python_version == "3.8" +pytest-cov==5.0.0; python_version == "3.8" +python-dateutil==2.9.0.post0; python_version == "3.8" +python-json-logger==2.0.7; python_version == "3.8" +pytz==2024.2; python_version == "3.8" +pyvista[all]==0.44.1; python_version == "3.8" +pyvista[colormaps,io,jupyter]==0.44.1; python_version == "3.8" +pyvistaqt==0.11.1; python_version == "3.8" +pywin32==306; sys_platform == "win32" and platform_python_implementation != "PyPy" and python_version == "3.8" or platform_system == "Windows" and platform_python_implementation != "PyPy" and python_version == "3.8" +pywinpty==2.0.13; os_name == "nt" and python_version == "3.8" +pyyaml==6.0.2; python_version == "3.8" +pyzmq==26.2.0; python_version == "3.8" +qtpy==2.4.1; python_version == "3.8" +referencing==0.35.1; python_version == "3.8" +requests==2.32.3; python_version == "3.8" +rfc3339-validator==0.1.4; python_version == "3.8" +rfc3986-validator==0.1.1; python_version == "3.8" +rich==13.8.1; python_version == "3.8" +rpds-py==0.20.0; python_version == "3.8" +scipy==1.10.1; python_version == "3.8" +scooby==0.10.0; python_version == "3.8" +send2trash==1.8.3; python_version == "3.8" +setuptools==74.1.2; python_version == "3.8" +simpervisor==1.0.0; python_version == "3.8" +six==1.16.0; python_version == "3.8" +sniffio==1.3.1; python_version == "3.8" +snowballstemmer==2.2.0; python_version == "3.8" +soupsieve==2.6; python_version == "3.8" +sphinx==7.1.2; python_version == "3.8" +sphinx-rtd-theme==2.0.0; python_version == "3.8" +sphinxcontrib-applehelp==1.0.4; python_version == "3.8" +sphinxcontrib-devhelp==1.0.2; python_version == "3.8" +sphinxcontrib-htmlhelp==2.0.1; python_version == "3.8" +sphinxcontrib-jquery==4.1; python_version == "3.8" +sphinxcontrib-jsmath==1.0.1; python_version == "3.8" +sphinxcontrib-qthelp==1.0.3; python_version == "3.8" +sphinxcontrib-serializinghtml==1.1.5; python_version == "3.8" +stack-data==0.6.3; python_version == "3.8" +terminado==0.18.1; python_version == "3.8" +tinycss2==1.2.1; python_version == "3.8" +tomli==2.2.1; python_version == "3.8" +tornado==6.4.2; python_version == "3.8" +tox==4.24.1; python_version == "3.8" +tqdm==4.66.5; python_version == "3.8" +traitlets==5.14.3; python_version == "3.8" +trame==3.6.5; python_version == "3.8" +trame-client==3.2.5; python_version == "3.8" +trame-server==3.1.2; python_version == "3.8" +trame-vtk==2.8.10; python_version == "3.8" +trame-vuetify==2.7.1; python_version == "3.8" +types-python-dateutil==2.9.0.20240906; python_version == "3.8" +typing-extensions==4.12.2; python_version == "3.8" +tzdata==2024.1; python_version == "3.8" +uri-template==1.3.0; python_version == "3.8" +urllib3==2.2.2; python_version == "3.8" +virtualenv==20.29.1; python_version == "3.8" +vtk==9.3.1; python_version == "3.8" +wcwidth==0.2.13; python_version == "3.8" +webcolors==24.8.0; python_version == "3.8" +webencodings==0.5.1; python_version == "3.8" +websocket-client==1.8.0; python_version == "3.8" +widgetsnbextension==4.0.13; python_version == "3.8" +wslink==2.1.3; python_version == "3.8" +yarl==1.15.2; python_version == "3.8" +zipp==3.20.1; python_version == "3.8" diff --git a/requirements/requirementspy39+mac.txt b/requirements/requirementspy39+mac.txt new file mode 100644 index 0000000..23fb7c4 --- /dev/null +++ b/requirements/requirementspy39+mac.txt @@ -0,0 +1,192 @@ +# This file is @generated by PDM. +# Please do not edit it manually. + +aiohappyeyeballs==2.4.0; python_version < "3.13" and python_version >= "3.9" +aiohttp==3.11.12; python_version < "3.13" and python_version >= "3.9" +aiosignal==1.3.1; python_version < "3.13" and python_version >= "3.9" +alabaster==0.7.16; python_version < "3.13" and python_version >= "3.9" +annotated-types==0.7.0; python_version < "3.13" and python_version >= "3.9" +anyio==4.4.0; python_version < "3.13" and python_version >= "3.9" +appnope==0.1.4; python_version < "3.13" and python_version >= "3.9" and platform_system == "Darwin" +argon2-cffi==23.1.0; python_version < "3.13" and python_version >= "3.9" +argon2-cffi-bindings==21.2.0; python_version < "3.13" and python_version >= "3.9" +arrow==1.3.0; python_version < "3.13" and python_version >= "3.9" +asttokens==2.4.1; python_version < "3.13" and python_version >= "3.9" +async-lru==2.0.4; python_version < "3.13" and python_version >= "3.9" +async-timeout==4.0.3; python_version < "3.11" and python_version >= "3.9" +attrs==24.2.0; python_version < "3.13" and python_version >= "3.9" +babel==2.16.0; python_version < "3.13" and python_version >= "3.9" +beautifulsoup4==4.12.3; python_version < "3.13" and python_version >= "3.9" +bleach[css]==6.2.0; python_version < "3.13" and python_version >= "3.9" +cachetools==5.5.0; python_version < "3.13" and python_version >= "3.9" +certifi==2024.8.30; python_version < "3.13" and python_version >= "3.9" +cffi==1.17.1; python_version < "3.13" and python_version >= "3.9" +cfgv==3.4.0; python_version < "3.13" and python_version >= "3.9" +chardet==5.2.0; python_version < "3.13" and python_version >= "3.9" +charset-normalizer==3.3.2; python_version < "3.13" and python_version >= "3.9" +cmocean==4.0.3; python_version < "3.13" and python_version >= "3.9" +colorama==0.4.6; python_version < "3.13" and python_version >= "3.9" +colorcet==3.1.0; python_version < "3.13" and python_version >= "3.9" +comm==0.2.2; python_version < "3.13" and python_version >= "3.9" +contourpy==1.3.0; python_version < "3.13" and python_version >= "3.9" +coverage[toml]==7.6.1; python_version < "3.13" and python_version >= "3.9" +cycler==0.12.1; python_version < "3.13" and python_version >= "3.9" +debugpy==1.8.5; python_version < "3.13" and python_version >= "3.9" +decorator==5.1.1; python_version < "3.13" and python_version >= "3.9" +defusedxml==0.7.1; python_version < "3.13" and python_version >= "3.9" +distlib==0.3.8; python_version < "3.13" and python_version >= "3.9" +docutils==0.20.1; python_version < "3.13" and python_version >= "3.9" +et-xmlfile==1.1.0; python_version < "3.13" and python_version >= "3.9" +exceptiongroup==1.2.2; python_version < "3.11" and python_version >= "3.9" +executing==2.1.0; python_version < "3.13" and python_version >= "3.9" +fastjsonschema==2.20.0; python_version < "3.13" and python_version >= "3.9" +filelock==3.17.0; python_version < "3.13" and python_version >= "3.9" +fonttools==4.53.1; python_version < "3.13" and python_version >= "3.9" +fqdn==1.5.1; python_version < "3.13" and python_version >= "3.9" +frozenlist==1.4.1; python_version < "3.13" and python_version >= "3.9" +ghp-import==2.1.0; python_version < "3.13" and python_version >= "3.9" +h11==0.14.0; python_version < "3.13" and python_version >= "3.9" +httpcore==1.0.5; python_version < "3.13" and python_version >= "3.9" +httpx==0.27.2; python_version < "3.13" and python_version >= "3.9" +identify==2.6.0; python_version < "3.13" and python_version >= "3.9" +idna==3.8; python_version < "3.13" and python_version >= "3.9" +imageio==2.35.1; python_version < "3.13" and python_version >= "3.9" +imagesize==1.4.1; python_version < "3.13" and python_version >= "3.9" +importlib-metadata==8.5.0; python_version < "3.10" and python_version >= "3.9" +importlib-resources==6.4.5; python_version < "3.10" and python_version >= "3.9" +iniconfig==2.0.0; python_version < "3.13" and python_version >= "3.9" +ipdb==0.13.13; python_version < "3.13" and python_version >= "3.9" +ipykernel==6.29.5; python_version < "3.13" and python_version >= "3.9" +ipython==8.18.1; python_version < "3.13" and python_version >= "3.9" +ipywidgets==8.1.5; python_version < "3.13" and python_version >= "3.9" +isoduration==20.11.0; python_version < "3.13" and python_version >= "3.9" +jedi==0.19.1; python_version < "3.13" and python_version >= "3.9" +jinja2==3.1.5; python_version < "3.13" and python_version >= "3.9" +json5==0.9.25; python_version < "3.13" and python_version >= "3.9" +jsonpointer==3.0.0; python_version < "3.13" and python_version >= "3.9" +jsonschema-specifications==2023.12.1; python_version < "3.13" and python_version >= "3.9" +jsonschema[format-nongpl]==4.23.0; python_version < "3.13" and python_version >= "3.9" +jupyter-client==8.6.3; python_version < "3.13" and python_version >= "3.9" +jupyter-core==5.7.2; python_version < "3.13" and python_version >= "3.9" +jupyter-events==0.12.0; python_version < "3.13" and python_version >= "3.9" +jupyter-lsp==2.2.5; python_version < "3.13" and python_version >= "3.9" +jupyter-server==2.15.0; python_version < "3.13" and python_version >= "3.9" +jupyter-server-proxy==4.4.0; python_version < "3.13" and python_version >= "3.9" +jupyter-server-terminals==0.5.3; python_version < "3.13" and python_version >= "3.9" +jupyterlab==4.3.5; python_version < "3.13" and python_version >= "3.9" +jupyterlab-pygments==0.3.0; python_version < "3.13" and python_version >= "3.9" +jupyterlab-server==2.27.3; python_version < "3.13" and python_version >= "3.9" +jupyterlab-widgets==3.0.13; python_version < "3.13" and python_version >= "3.9" +kiwisolver==1.4.7; python_version < "3.13" and python_version >= "3.9" +markdown-it-py==3.0.0; python_version < "3.13" and python_version >= "3.9" +markupsafe==2.1.5; python_version < "3.13" and python_version >= "3.9" +matplotlib==3.9.4; python_version < "3.13" and python_version >= "3.9" +matplotlib-inline==0.1.7; python_version < "3.13" and python_version >= "3.9" +mdurl==0.1.2; python_version < "3.13" and python_version >= "3.9" +meshio==5.3.5; python_version < "3.13" and python_version >= "3.9" +mistune==3.0.2; python_version < "3.13" and python_version >= "3.9" +more-itertools==10.5.0; python_version < "3.13" and python_version >= "3.9" +msgpack==1.1.0; python_version < "3.13" and python_version >= "3.9" +multidict==6.1.0; python_version < "3.13" and python_version >= "3.9" +nbclient==0.10.0; python_version < "3.13" and python_version >= "3.9" +nbconvert==7.16.6; python_version < "3.13" and python_version >= "3.9" +nbformat==5.10.4; python_version < "3.13" and python_version >= "3.9" +nbsphinx==0.9.6; python_version < "3.13" and python_version >= "3.9" +nest-asyncio==1.6.0; python_version < "3.13" and python_version >= "3.9" +nodeenv==1.9.1; python_version < "3.13" and python_version >= "3.9" +notebook==7.3.2; python_version < "3.13" and python_version >= "3.9" +notebook-shim==0.2.4; python_version < "3.13" and python_version >= "3.9" +numpy==2.0.2; python_version < "3.13" and python_version >= "3.9" +openpyxl==3.1.5; python_version < "3.13" and python_version >= "3.9" +overrides==7.7.0; python_version < "3.13" and python_version >= "3.9" +packaging==24.2; python_version < "3.13" and python_version >= "3.9" +pandas==2.2.3; python_version < "3.13" and python_version >= "3.9" +pandoc==2.4; python_version < "3.13" and python_version >= "3.9" +pandocfilters==1.5.1; python_version < "3.13" and python_version >= "3.9" +parso==0.8.4; python_version < "3.13" and python_version >= "3.9" +pexpect==4.9.0; python_version < "3.13" and python_version >= "3.9" and sys_platform != "win32" +pillow==10.4.0; python_version < "3.13" and python_version >= "3.9" +platformdirs==4.3.6; python_version < "3.13" and python_version >= "3.9" +pluggy==1.5.0; python_version < "3.13" and python_version >= "3.9" +plumbum==1.8.3; python_version < "3.13" and python_version >= "3.9" +ply==3.11; python_version < "3.13" and python_version >= "3.9" +pooch==1.8.2; python_version < "3.13" and python_version >= "3.9" +pre-commit==4.1.0; python_version < "3.13" and python_version >= "3.9" +prometheus-client==0.20.0; python_version < "3.13" and python_version >= "3.9" +prompt-toolkit==3.0.47; python_version < "3.13" and python_version >= "3.9" +propcache==0.2.1; python_version < "3.13" and python_version >= "3.9" +psutil==6.0.0; python_version < "3.13" and python_version >= "3.9" +ptyprocess==0.7.0; os_name != "nt" and python_version < "3.13" and python_version >= "3.9" or sys_platform != "win32" and python_version < "3.13" and python_version >= "3.9" +pure-eval==0.2.3; python_version < "3.13" and python_version >= "3.9" +pycparser==2.22; python_version < "3.13" and python_version >= "3.9" +pydantic==2.10.6; python_version < "3.13" and python_version >= "3.9" +pydantic-core==2.27.2; python_version < "3.13" and python_version >= "3.9" +pygments==2.18.0; python_version < "3.13" and python_version >= "3.9" +pyparsing==3.1.4; python_version < "3.13" and python_version >= "3.9" +pyproject-api==1.9.0; python_version < "3.13" and python_version >= "3.9" +pyqt5==5.15.10; python_version < "3.13" and python_version >= "3.9" +pyqt5-qt5==5.15.14; python_version < "3.13" and python_version >= "3.9" +pyqt5-sip==12.15.0; python_version < "3.13" and python_version >= "3.9" +pytest==8.3.4; python_version < "3.13" and python_version >= "3.9" +pytest-cov==6.0.0; python_version < "3.13" and python_version >= "3.9" +python-dateutil==2.9.0.post0; python_version < "3.13" and python_version >= "3.9" +python-json-logger==2.0.7; python_version < "3.13" and python_version >= "3.9" +pytz==2024.2; python_version < "3.13" and python_version >= "3.9" +pyvista[all]==0.44.2; python_version < "3.13" and python_version >= "3.9" +pyvista[colormaps,io,jupyter]==0.44.2; python_version < "3.13" and python_version >= "3.9" +pyvistaqt==0.11.1; python_version < "3.13" and python_version >= "3.9" +pyyaml==6.0.2; python_version < "3.13" and python_version >= "3.9" +pyzmq==26.2.0; python_version < "3.13" and python_version >= "3.9" +qtpy==2.4.1; python_version < "3.13" and python_version >= "3.9" +referencing==0.35.1; python_version < "3.13" and python_version >= "3.9" +requests==2.32.3; python_version < "3.13" and python_version >= "3.9" +rfc3339-validator==0.1.4; python_version < "3.13" and python_version >= "3.9" +rfc3986-validator==0.1.1; python_version < "3.13" and python_version >= "3.9" +rich==13.8.1; python_version < "3.13" and python_version >= "3.9" +rpds-py==0.20.0; python_version < "3.13" and python_version >= "3.9" +scipy==1.13.1; python_version < "3.13" and python_version >= "3.9" +scooby==0.10.0; python_version < "3.13" and python_version >= "3.9" +send2trash==1.8.3; python_version < "3.13" and python_version >= "3.9" +setuptools==74.1.2; python_version < "3.13" and python_version >= "3.9" +simpervisor==1.0.0; python_version < "3.13" and python_version >= "3.9" +six==1.16.0; python_version < "3.13" and python_version >= "3.9" +sniffio==1.3.1; python_version < "3.13" and python_version >= "3.9" +snowballstemmer==2.2.0; python_version < "3.13" and python_version >= "3.9" +soupsieve==2.6; python_version < "3.13" and python_version >= "3.9" +sphinx==7.4.7; python_version < "3.13" and python_version >= "3.9" +sphinx-rtd-theme==3.0.2; python_version < "3.13" and python_version >= "3.9" +sphinxcontrib-applehelp==2.0.0; python_version < "3.13" and python_version >= "3.9" +sphinxcontrib-devhelp==2.0.0; python_version < "3.13" and python_version >= "3.9" +sphinxcontrib-htmlhelp==2.1.0; python_version < "3.13" and python_version >= "3.9" +sphinxcontrib-jquery==4.1; python_version < "3.13" and python_version >= "3.9" +sphinxcontrib-jsmath==1.0.1; python_version < "3.13" and python_version >= "3.9" +sphinxcontrib-qthelp==2.0.0; python_version < "3.13" and python_version >= "3.9" +sphinxcontrib-serializinghtml==2.0.0; python_version < "3.13" and python_version >= "3.9" +stack-data==0.6.3; python_version < "3.13" and python_version >= "3.9" +terminado==0.18.1; python_version < "3.13" and python_version >= "3.9" +tinycss2==1.3.0; python_version < "3.13" and python_version >= "3.9" +tomli==2.2.1; python_version < "3.11" and python_version >= "3.9" +tornado==6.4.2; python_version < "3.13" and python_version >= "3.9" +tox==4.24.1; python_version < "3.13" and python_version >= "3.9" +tqdm==4.67.1; python_version < "3.13" and python_version >= "3.9" +traitlets==5.14.3; python_version < "3.13" and python_version >= "3.9" +trame==3.6.5; python_version < "3.13" and python_version >= "3.9" +trame-client==3.2.5; python_version < "3.13" and python_version >= "3.9" +trame-server==3.1.2; python_version < "3.13" and python_version >= "3.9" +trame-vtk==2.8.10; python_version < "3.13" and python_version >= "3.9" +trame-vuetify==2.7.1; python_version < "3.13" and python_version >= "3.9" +types-python-dateutil==2.9.0.20240906; python_version < "3.13" and python_version >= "3.9" +typing-extensions==4.12.2; python_version < "3.13" and python_version >= "3.9" +tzdata==2024.1; python_version < "3.13" and python_version >= "3.9" +uri-template==1.3.0; python_version < "3.13" and python_version >= "3.9" +urllib3==2.2.2; python_version < "3.13" and python_version >= "3.9" +virtualenv==20.29.1; python_version < "3.13" and python_version >= "3.9" +vtk==9.3.1; python_version < "3.13" and python_version >= "3.9" +wcwidth==0.2.13; python_version < "3.13" and python_version >= "3.9" +webcolors==24.8.0; python_version < "3.13" and python_version >= "3.9" +webencodings==0.5.1; python_version < "3.13" and python_version >= "3.9" +websocket-client==1.8.0; python_version < "3.13" and python_version >= "3.9" +widgetsnbextension==4.0.13; python_version < "3.13" and python_version >= "3.9" +wslink==2.1.3; python_version < "3.13" and python_version >= "3.9" +yarl==1.18.3; python_version < "3.13" and python_version >= "3.9" +zipp==3.20.1; python_version < "3.10" and python_version >= "3.9" diff --git a/requirements/requirementspy39+unix.txt b/requirements/requirementspy39+unix.txt new file mode 100644 index 0000000..7c7c4e7 --- /dev/null +++ b/requirements/requirementspy39+unix.txt @@ -0,0 +1,191 @@ +# This file is @generated by PDM. +# Please do not edit it manually. + +aiohappyeyeballs==2.4.0; python_version < "3.13" and python_version >= "3.9" +aiohttp==3.11.12; python_version < "3.13" and python_version >= "3.9" +aiosignal==1.3.1; python_version < "3.13" and python_version >= "3.9" +alabaster==0.7.16; python_version < "3.13" and python_version >= "3.9" +annotated-types==0.7.0; python_version < "3.13" and python_version >= "3.9" +anyio==4.4.0; python_version < "3.13" and python_version >= "3.9" +argon2-cffi==23.1.0; python_version < "3.13" and python_version >= "3.9" +argon2-cffi-bindings==21.2.0; python_version < "3.13" and python_version >= "3.9" +arrow==1.3.0; python_version < "3.13" and python_version >= "3.9" +asttokens==2.4.1; python_version < "3.13" and python_version >= "3.9" +async-lru==2.0.4; python_version < "3.13" and python_version >= "3.9" +async-timeout==4.0.3; python_version < "3.11" and python_version >= "3.9" +attrs==24.2.0; python_version < "3.13" and python_version >= "3.9" +babel==2.16.0; python_version < "3.13" and python_version >= "3.9" +beautifulsoup4==4.12.3; python_version < "3.13" and python_version >= "3.9" +bleach[css]==6.2.0; python_version < "3.13" and python_version >= "3.9" +cachetools==5.5.0; python_version < "3.13" and python_version >= "3.9" +certifi==2024.8.30; python_version < "3.13" and python_version >= "3.9" +cffi==1.17.1; python_version < "3.13" and python_version >= "3.9" +cfgv==3.4.0; python_version < "3.13" and python_version >= "3.9" +chardet==5.2.0; python_version < "3.13" and python_version >= "3.9" +charset-normalizer==3.3.2; python_version < "3.13" and python_version >= "3.9" +cmocean==4.0.3; python_version < "3.13" and python_version >= "3.9" +colorama==0.4.6; python_version < "3.13" and python_version >= "3.9" +colorcet==3.1.0; python_version < "3.13" and python_version >= "3.9" +comm==0.2.2; python_version < "3.13" and python_version >= "3.9" +contourpy==1.3.0; python_version < "3.13" and python_version >= "3.9" +coverage[toml]==7.6.1; python_version < "3.13" and python_version >= "3.9" +cycler==0.12.1; python_version < "3.13" and python_version >= "3.9" +debugpy==1.8.5; python_version < "3.13" and python_version >= "3.9" +decorator==5.1.1; python_version < "3.13" and python_version >= "3.9" +defusedxml==0.7.1; python_version < "3.13" and python_version >= "3.9" +distlib==0.3.8; python_version < "3.13" and python_version >= "3.9" +docutils==0.20.1; python_version < "3.13" and python_version >= "3.9" +et-xmlfile==1.1.0; python_version < "3.13" and python_version >= "3.9" +exceptiongroup==1.2.2; python_version < "3.11" and python_version >= "3.9" +executing==2.1.0; python_version < "3.13" and python_version >= "3.9" +fastjsonschema==2.20.0; python_version < "3.13" and python_version >= "3.9" +filelock==3.17.0; python_version < "3.13" and python_version >= "3.9" +fonttools==4.53.1; python_version < "3.13" and python_version >= "3.9" +fqdn==1.5.1; python_version < "3.13" and python_version >= "3.9" +frozenlist==1.4.1; python_version < "3.13" and python_version >= "3.9" +ghp-import==2.1.0; python_version < "3.13" and python_version >= "3.9" +h11==0.14.0; python_version < "3.13" and python_version >= "3.9" +httpcore==1.0.5; python_version < "3.13" and python_version >= "3.9" +httpx==0.27.2; python_version < "3.13" and python_version >= "3.9" +identify==2.6.0; python_version < "3.13" and python_version >= "3.9" +idna==3.8; python_version < "3.13" and python_version >= "3.9" +imageio==2.35.1; python_version < "3.13" and python_version >= "3.9" +imagesize==1.4.1; python_version < "3.13" and python_version >= "3.9" +importlib-metadata==8.5.0; python_version < "3.10" and python_version >= "3.9" +importlib-resources==6.4.5; python_version < "3.10" and python_version >= "3.9" +iniconfig==2.0.0; python_version < "3.13" and python_version >= "3.9" +ipdb==0.13.13; python_version < "3.13" and python_version >= "3.9" +ipykernel==6.29.5; python_version < "3.13" and python_version >= "3.9" +ipython==8.18.1; python_version < "3.13" and python_version >= "3.9" +ipywidgets==8.1.5; python_version < "3.13" and python_version >= "3.9" +isoduration==20.11.0; python_version < "3.13" and python_version >= "3.9" +jedi==0.19.1; python_version < "3.13" and python_version >= "3.9" +jinja2==3.1.5; python_version < "3.13" and python_version >= "3.9" +json5==0.9.25; python_version < "3.13" and python_version >= "3.9" +jsonpointer==3.0.0; python_version < "3.13" and python_version >= "3.9" +jsonschema-specifications==2023.12.1; python_version < "3.13" and python_version >= "3.9" +jsonschema[format-nongpl]==4.23.0; python_version < "3.13" and python_version >= "3.9" +jupyter-client==8.6.3; python_version < "3.13" and python_version >= "3.9" +jupyter-core==5.7.2; python_version < "3.13" and python_version >= "3.9" +jupyter-events==0.12.0; python_version < "3.13" and python_version >= "3.9" +jupyter-lsp==2.2.5; python_version < "3.13" and python_version >= "3.9" +jupyter-server==2.15.0; python_version < "3.13" and python_version >= "3.9" +jupyter-server-proxy==4.4.0; python_version < "3.13" and python_version >= "3.9" +jupyter-server-terminals==0.5.3; python_version < "3.13" and python_version >= "3.9" +jupyterlab==4.3.5; python_version < "3.13" and python_version >= "3.9" +jupyterlab-pygments==0.3.0; python_version < "3.13" and python_version >= "3.9" +jupyterlab-server==2.27.3; python_version < "3.13" and python_version >= "3.9" +jupyterlab-widgets==3.0.13; python_version < "3.13" and python_version >= "3.9" +kiwisolver==1.4.7; python_version < "3.13" and python_version >= "3.9" +markdown-it-py==3.0.0; python_version < "3.13" and python_version >= "3.9" +markupsafe==2.1.5; python_version < "3.13" and python_version >= "3.9" +matplotlib==3.9.4; python_version < "3.13" and python_version >= "3.9" +matplotlib-inline==0.1.7; python_version < "3.13" and python_version >= "3.9" +mdurl==0.1.2; python_version < "3.13" and python_version >= "3.9" +meshio==5.3.5; python_version < "3.13" and python_version >= "3.9" +mistune==3.0.2; python_version < "3.13" and python_version >= "3.9" +more-itertools==10.5.0; python_version < "3.13" and python_version >= "3.9" +msgpack==1.1.0; python_version < "3.13" and python_version >= "3.9" +multidict==6.1.0; python_version < "3.13" and python_version >= "3.9" +nbclient==0.10.0; python_version < "3.13" and python_version >= "3.9" +nbconvert==7.16.6; python_version < "3.13" and python_version >= "3.9" +nbformat==5.10.4; python_version < "3.13" and python_version >= "3.9" +nbsphinx==0.9.6; python_version < "3.13" and python_version >= "3.9" +nest-asyncio==1.6.0; python_version < "3.13" and python_version >= "3.9" +nodeenv==1.9.1; python_version < "3.13" and python_version >= "3.9" +notebook==7.3.2; python_version < "3.13" and python_version >= "3.9" +notebook-shim==0.2.4; python_version < "3.13" and python_version >= "3.9" +numpy==2.0.2; python_version < "3.13" and python_version >= "3.9" +openpyxl==3.1.5; python_version < "3.13" and python_version >= "3.9" +overrides==7.7.0; python_version < "3.13" and python_version >= "3.9" +packaging==24.2; python_version < "3.13" and python_version >= "3.9" +pandas==2.2.3; python_version < "3.13" and python_version >= "3.9" +pandoc==2.4; python_version < "3.13" and python_version >= "3.9" +pandocfilters==1.5.1; python_version < "3.13" and python_version >= "3.9" +parso==0.8.4; python_version < "3.13" and python_version >= "3.9" +pexpect==4.9.0; python_version < "3.13" and python_version >= "3.9" and sys_platform != "win32" +pillow==10.4.0; python_version < "3.13" and python_version >= "3.9" +platformdirs==4.3.6; python_version < "3.13" and python_version >= "3.9" +pluggy==1.5.0; python_version < "3.13" and python_version >= "3.9" +plumbum==1.8.3; python_version < "3.13" and python_version >= "3.9" +ply==3.11; python_version < "3.13" and python_version >= "3.9" +pooch==1.8.2; python_version < "3.13" and python_version >= "3.9" +pre-commit==4.1.0; python_version < "3.13" and python_version >= "3.9" +prometheus-client==0.20.0; python_version < "3.13" and python_version >= "3.9" +prompt-toolkit==3.0.47; python_version < "3.13" and python_version >= "3.9" +propcache==0.2.1; python_version < "3.13" and python_version >= "3.9" +psutil==6.0.0; python_version < "3.13" and python_version >= "3.9" +ptyprocess==0.7.0; os_name != "nt" and python_version < "3.13" and python_version >= "3.9" or sys_platform != "win32" and python_version < "3.13" and python_version >= "3.9" +pure-eval==0.2.3; python_version < "3.13" and python_version >= "3.9" +pycparser==2.22; python_version < "3.13" and python_version >= "3.9" +pydantic==2.10.6; python_version < "3.13" and python_version >= "3.9" +pydantic-core==2.27.2; python_version < "3.13" and python_version >= "3.9" +pygments==2.18.0; python_version < "3.13" and python_version >= "3.9" +pyparsing==3.1.4; python_version < "3.13" and python_version >= "3.9" +pyproject-api==1.9.0; python_version < "3.13" and python_version >= "3.9" +pyqt5==5.15.10; python_version < "3.13" and python_version >= "3.9" +pyqt5-qt5==5.15.2; python_version < "3.13" and python_version >= "3.9" +pyqt5-sip==12.15.0; python_version < "3.13" and python_version >= "3.9" +pytest==8.3.4; python_version < "3.13" and python_version >= "3.9" +pytest-cov==6.0.0; python_version < "3.13" and python_version >= "3.9" +python-dateutil==2.9.0.post0; python_version < "3.13" and python_version >= "3.9" +python-json-logger==2.0.7; python_version < "3.13" and python_version >= "3.9" +pytz==2024.2; python_version < "3.13" and python_version >= "3.9" +pyvista[all]==0.44.2; python_version < "3.13" and python_version >= "3.9" +pyvista[colormaps,io,jupyter]==0.44.2; python_version < "3.13" and python_version >= "3.9" +pyvistaqt==0.11.1; python_version < "3.13" and python_version >= "3.9" +pyyaml==6.0.2; python_version < "3.13" and python_version >= "3.9" +pyzmq==26.2.0; python_version < "3.13" and python_version >= "3.9" +qtpy==2.4.1; python_version < "3.13" and python_version >= "3.9" +referencing==0.35.1; python_version < "3.13" and python_version >= "3.9" +requests==2.32.3; python_version < "3.13" and python_version >= "3.9" +rfc3339-validator==0.1.4; python_version < "3.13" and python_version >= "3.9" +rfc3986-validator==0.1.1; python_version < "3.13" and python_version >= "3.9" +rich==13.8.1; python_version < "3.13" and python_version >= "3.9" +rpds-py==0.20.0; python_version < "3.13" and python_version >= "3.9" +scipy==1.13.1; python_version < "3.13" and python_version >= "3.9" +scooby==0.10.0; python_version < "3.13" and python_version >= "3.9" +send2trash==1.8.3; python_version < "3.13" and python_version >= "3.9" +setuptools==74.1.2; python_version < "3.13" and python_version >= "3.9" +simpervisor==1.0.0; python_version < "3.13" and python_version >= "3.9" +six==1.16.0; python_version < "3.13" and python_version >= "3.9" +sniffio==1.3.1; python_version < "3.13" and python_version >= "3.9" +snowballstemmer==2.2.0; python_version < "3.13" and python_version >= "3.9" +soupsieve==2.6; python_version < "3.13" and python_version >= "3.9" +sphinx==7.4.7; python_version < "3.13" and python_version >= "3.9" +sphinx-rtd-theme==3.0.2; python_version < "3.13" and python_version >= "3.9" +sphinxcontrib-applehelp==2.0.0; python_version < "3.13" and python_version >= "3.9" +sphinxcontrib-devhelp==2.0.0; python_version < "3.13" and python_version >= "3.9" +sphinxcontrib-htmlhelp==2.1.0; python_version < "3.13" and python_version >= "3.9" +sphinxcontrib-jquery==4.1; python_version < "3.13" and python_version >= "3.9" +sphinxcontrib-jsmath==1.0.1; python_version < "3.13" and python_version >= "3.9" +sphinxcontrib-qthelp==2.0.0; python_version < "3.13" and python_version >= "3.9" +sphinxcontrib-serializinghtml==2.0.0; python_version < "3.13" and python_version >= "3.9" +stack-data==0.6.3; python_version < "3.13" and python_version >= "3.9" +terminado==0.18.1; python_version < "3.13" and python_version >= "3.9" +tinycss2==1.3.0; python_version < "3.13" and python_version >= "3.9" +tomli==2.2.1; python_version < "3.11" and python_version >= "3.9" +tornado==6.4.2; python_version < "3.13" and python_version >= "3.9" +tox==4.24.1; python_version < "3.13" and python_version >= "3.9" +tqdm==4.67.1; python_version < "3.13" and python_version >= "3.9" +traitlets==5.14.3; python_version < "3.13" and python_version >= "3.9" +trame==3.6.5; python_version < "3.13" and python_version >= "3.9" +trame-client==3.2.5; python_version < "3.13" and python_version >= "3.9" +trame-server==3.1.2; python_version < "3.13" and python_version >= "3.9" +trame-vtk==2.8.10; python_version < "3.13" and python_version >= "3.9" +trame-vuetify==2.7.1; python_version < "3.13" and python_version >= "3.9" +types-python-dateutil==2.9.0.20240906; python_version < "3.13" and python_version >= "3.9" +typing-extensions==4.12.2; python_version < "3.13" and python_version >= "3.9" +tzdata==2024.1; python_version < "3.13" and python_version >= "3.9" +uri-template==1.3.0; python_version < "3.13" and python_version >= "3.9" +urllib3==2.2.2; python_version < "3.13" and python_version >= "3.9" +virtualenv==20.29.1; python_version < "3.13" and python_version >= "3.9" +vtk==9.3.1; python_version < "3.13" and python_version >= "3.9" +wcwidth==0.2.13; python_version < "3.13" and python_version >= "3.9" +webcolors==24.8.0; python_version < "3.13" and python_version >= "3.9" +webencodings==0.5.1; python_version < "3.13" and python_version >= "3.9" +websocket-client==1.8.0; python_version < "3.13" and python_version >= "3.9" +widgetsnbextension==4.0.13; python_version < "3.13" and python_version >= "3.9" +wslink==2.1.3; python_version < "3.13" and python_version >= "3.9" +yarl==1.18.3; python_version < "3.13" and python_version >= "3.9" +zipp==3.20.1; python_version < "3.10" and python_version >= "3.9" diff --git a/requirements/requirementspy39+win.txt b/requirements/requirementspy39+win.txt new file mode 100644 index 0000000..3f46fae --- /dev/null +++ b/requirements/requirementspy39+win.txt @@ -0,0 +1,191 @@ +# This file is @generated by PDM. +# Please do not edit it manually. + +aiohappyeyeballs==2.4.0; python_version < "3.13" and python_version >= "3.9" +aiohttp==3.11.12; python_version < "3.13" and python_version >= "3.9" +aiosignal==1.3.1; python_version < "3.13" and python_version >= "3.9" +alabaster==0.7.16; python_version < "3.13" and python_version >= "3.9" +annotated-types==0.7.0; python_version < "3.13" and python_version >= "3.9" +anyio==4.4.0; python_version < "3.13" and python_version >= "3.9" +argon2-cffi==23.1.0; python_version < "3.13" and python_version >= "3.9" +argon2-cffi-bindings==21.2.0; python_version < "3.13" and python_version >= "3.9" +arrow==1.3.0; python_version < "3.13" and python_version >= "3.9" +asttokens==2.4.1; python_version < "3.13" and python_version >= "3.9" +async-lru==2.0.4; python_version < "3.13" and python_version >= "3.9" +async-timeout==4.0.3; python_version < "3.11" and python_version >= "3.9" +attrs==24.2.0; python_version < "3.13" and python_version >= "3.9" +babel==2.16.0; python_version < "3.13" and python_version >= "3.9" +beautifulsoup4==4.12.3; python_version < "3.13" and python_version >= "3.9" +bleach[css]==6.2.0; python_version < "3.13" and python_version >= "3.9" +cachetools==5.5.0; python_version < "3.13" and python_version >= "3.9" +certifi==2024.8.30; python_version < "3.13" and python_version >= "3.9" +cffi==1.17.1; python_version < "3.13" and python_version >= "3.9" +cfgv==3.4.0; python_version < "3.13" and python_version >= "3.9" +chardet==5.2.0; python_version < "3.13" and python_version >= "3.9" +charset-normalizer==3.3.2; python_version < "3.13" and python_version >= "3.9" +cmocean==4.0.3; python_version < "3.13" and python_version >= "3.9" +colorama==0.4.6; python_version < "3.13" and python_version >= "3.9" +colorcet==3.1.0; python_version < "3.13" and python_version >= "3.9" +comm==0.2.2; python_version < "3.13" and python_version >= "3.9" +contourpy==1.3.0; python_version < "3.13" and python_version >= "3.9" +coverage[toml]==7.6.1; python_version < "3.13" and python_version >= "3.9" +cycler==0.12.1; python_version < "3.13" and python_version >= "3.9" +debugpy==1.8.5; python_version < "3.13" and python_version >= "3.9" +decorator==5.1.1; python_version < "3.13" and python_version >= "3.9" +defusedxml==0.7.1; python_version < "3.13" and python_version >= "3.9" +distlib==0.3.8; python_version < "3.13" and python_version >= "3.9" +docutils==0.20.1; python_version < "3.13" and python_version >= "3.9" +et-xmlfile==1.1.0; python_version < "3.13" and python_version >= "3.9" +exceptiongroup==1.2.2; python_version < "3.11" and python_version >= "3.9" +executing==2.1.0; python_version < "3.13" and python_version >= "3.9" +fastjsonschema==2.20.0; python_version < "3.13" and python_version >= "3.9" +filelock==3.17.0; python_version < "3.13" and python_version >= "3.9" +fonttools==4.53.1; python_version < "3.13" and python_version >= "3.9" +fqdn==1.5.1; python_version < "3.13" and python_version >= "3.9" +frozenlist==1.4.1; python_version < "3.13" and python_version >= "3.9" +ghp-import==2.1.0; python_version < "3.13" and python_version >= "3.9" +h11==0.14.0; python_version < "3.13" and python_version >= "3.9" +httpcore==1.0.5; python_version < "3.13" and python_version >= "3.9" +httpx==0.27.2; python_version < "3.13" and python_version >= "3.9" +identify==2.6.0; python_version < "3.13" and python_version >= "3.9" +idna==3.8; python_version < "3.13" and python_version >= "3.9" +imageio==2.35.1; python_version < "3.13" and python_version >= "3.9" +imagesize==1.4.1; python_version < "3.13" and python_version >= "3.9" +importlib-metadata==8.5.0; python_version < "3.10" and python_version >= "3.9" +importlib-resources==6.4.5; python_version < "3.10" and python_version >= "3.9" +iniconfig==2.0.0; python_version < "3.13" and python_version >= "3.9" +ipdb==0.13.13; python_version < "3.13" and python_version >= "3.9" +ipykernel==6.29.5; python_version < "3.13" and python_version >= "3.9" +ipython==8.18.1; python_version < "3.13" and python_version >= "3.9" +ipywidgets==8.1.5; python_version < "3.13" and python_version >= "3.9" +isoduration==20.11.0; python_version < "3.13" and python_version >= "3.9" +jedi==0.19.1; python_version < "3.13" and python_version >= "3.9" +jinja2==3.1.5; python_version < "3.13" and python_version >= "3.9" +json5==0.9.25; python_version < "3.13" and python_version >= "3.9" +jsonpointer==3.0.0; python_version < "3.13" and python_version >= "3.9" +jsonschema-specifications==2023.12.1; python_version < "3.13" and python_version >= "3.9" +jsonschema[format-nongpl]==4.23.0; python_version < "3.13" and python_version >= "3.9" +jupyter-client==8.6.3; python_version < "3.13" and python_version >= "3.9" +jupyter-core==5.7.2; python_version < "3.13" and python_version >= "3.9" +jupyter-events==0.12.0; python_version < "3.13" and python_version >= "3.9" +jupyter-lsp==2.2.5; python_version < "3.13" and python_version >= "3.9" +jupyter-server==2.15.0; python_version < "3.13" and python_version >= "3.9" +jupyter-server-proxy==4.4.0; python_version < "3.13" and python_version >= "3.9" +jupyter-server-terminals==0.5.3; python_version < "3.13" and python_version >= "3.9" +jupyterlab==4.3.5; python_version < "3.13" and python_version >= "3.9" +jupyterlab-pygments==0.3.0; python_version < "3.13" and python_version >= "3.9" +jupyterlab-server==2.27.3; python_version < "3.13" and python_version >= "3.9" +jupyterlab-widgets==3.0.13; python_version < "3.13" and python_version >= "3.9" +kiwisolver==1.4.7; python_version < "3.13" and python_version >= "3.9" +markdown-it-py==3.0.0; python_version < "3.13" and python_version >= "3.9" +markupsafe==2.1.5; python_version < "3.13" and python_version >= "3.9" +matplotlib==3.9.4; python_version < "3.13" and python_version >= "3.9" +matplotlib-inline==0.1.7; python_version < "3.13" and python_version >= "3.9" +mdurl==0.1.2; python_version < "3.13" and python_version >= "3.9" +meshio==5.3.5; python_version < "3.13" and python_version >= "3.9" +mistune==3.0.2; python_version < "3.13" and python_version >= "3.9" +more-itertools==10.5.0; python_version < "3.13" and python_version >= "3.9" +msgpack==1.1.0; python_version < "3.13" and python_version >= "3.9" +multidict==6.1.0; python_version < "3.13" and python_version >= "3.9" +nbclient==0.10.0; python_version < "3.13" and python_version >= "3.9" +nbconvert==7.16.6; python_version < "3.13" and python_version >= "3.9" +nbformat==5.10.4; python_version < "3.13" and python_version >= "3.9" +nbsphinx==0.9.6; python_version < "3.13" and python_version >= "3.9" +nest-asyncio==1.6.0; python_version < "3.13" and python_version >= "3.9" +nodeenv==1.9.1; python_version < "3.13" and python_version >= "3.9" +notebook==7.3.2; python_version < "3.13" and python_version >= "3.9" +notebook-shim==0.2.4; python_version < "3.13" and python_version >= "3.9" +numpy==2.0.2; python_version < "3.13" and python_version >= "3.9" +openpyxl==3.1.5; python_version < "3.13" and python_version >= "3.9" +overrides==7.7.0; python_version < "3.13" and python_version >= "3.9" +packaging==24.2; python_version < "3.13" and python_version >= "3.9" +pandas==2.2.3; python_version < "3.13" and python_version >= "3.9" +pandoc==2.4; python_version < "3.13" and python_version >= "3.9" +pandocfilters==1.5.1; python_version < "3.13" and python_version >= "3.9" +parso==0.8.4; python_version < "3.13" and python_version >= "3.9" +pillow==10.4.0; python_version < "3.13" and python_version >= "3.9" +platformdirs==4.3.6; python_version < "3.13" and python_version >= "3.9" +pluggy==1.5.0; python_version < "3.13" and python_version >= "3.9" +plumbum==1.8.3; python_version < "3.13" and python_version >= "3.9" +ply==3.11; python_version < "3.13" and python_version >= "3.9" +pooch==1.8.2; python_version < "3.13" and python_version >= "3.9" +pre-commit==4.1.0; python_version < "3.13" and python_version >= "3.9" +prometheus-client==0.20.0; python_version < "3.13" and python_version >= "3.9" +prompt-toolkit==3.0.47; python_version < "3.13" and python_version >= "3.9" +propcache==0.2.1; python_version < "3.13" and python_version >= "3.9" +psutil==6.0.0; python_version < "3.13" and python_version >= "3.9" +pure-eval==0.2.3; python_version < "3.13" and python_version >= "3.9" +pycparser==2.22; python_version < "3.13" and python_version >= "3.9" +pydantic==2.10.6; python_version < "3.13" and python_version >= "3.9" +pydantic-core==2.27.2; python_version < "3.13" and python_version >= "3.9" +pygments==2.18.0; python_version < "3.13" and python_version >= "3.9" +pyparsing==3.1.4; python_version < "3.13" and python_version >= "3.9" +pyproject-api==1.9.0; python_version < "3.13" and python_version >= "3.9" +pyqt5==5.15.10; python_version < "3.13" and python_version >= "3.9" +pyqt5-qt5==5.15.2; python_version < "3.13" and python_version >= "3.9" +pyqt5-sip==12.15.0; python_version < "3.13" and python_version >= "3.9" +pytest==8.3.4; python_version < "3.13" and python_version >= "3.9" +pytest-cov==6.0.0; python_version < "3.13" and python_version >= "3.9" +python-dateutil==2.9.0.post0; python_version < "3.13" and python_version >= "3.9" +python-json-logger==2.0.7; python_version < "3.13" and python_version >= "3.9" +pytz==2024.2; python_version < "3.13" and python_version >= "3.9" +pyvista[all]==0.44.2; python_version < "3.13" and python_version >= "3.9" +pyvista[colormaps,io,jupyter]==0.44.2; python_version < "3.13" and python_version >= "3.9" +pyvistaqt==0.11.1; python_version < "3.13" and python_version >= "3.9" +pywin32==306; sys_platform == "win32" and platform_python_implementation != "PyPy" and python_version < "3.13" and python_version >= "3.9" or platform_system == "Windows" and platform_python_implementation != "PyPy" and python_version < "3.13" and python_version >= "3.9" +pywinpty==2.0.13; python_version < "3.13" and python_version >= "3.9" and os_name == "nt" +pyyaml==6.0.2; python_version < "3.13" and python_version >= "3.9" +pyzmq==26.2.0; python_version < "3.13" and python_version >= "3.9" +qtpy==2.4.1; python_version < "3.13" and python_version >= "3.9" +referencing==0.35.1; python_version < "3.13" and python_version >= "3.9" +requests==2.32.3; python_version < "3.13" and python_version >= "3.9" +rfc3339-validator==0.1.4; python_version < "3.13" and python_version >= "3.9" +rfc3986-validator==0.1.1; python_version < "3.13" and python_version >= "3.9" +rich==13.8.1; python_version < "3.13" and python_version >= "3.9" +rpds-py==0.20.0; python_version < "3.13" and python_version >= "3.9" +scipy==1.13.1; python_version < "3.13" and python_version >= "3.9" +scooby==0.10.0; python_version < "3.13" and python_version >= "3.9" +send2trash==1.8.3; python_version < "3.13" and python_version >= "3.9" +setuptools==74.1.2; python_version < "3.13" and python_version >= "3.9" +simpervisor==1.0.0; python_version < "3.13" and python_version >= "3.9" +six==1.16.0; python_version < "3.13" and python_version >= "3.9" +sniffio==1.3.1; python_version < "3.13" and python_version >= "3.9" +snowballstemmer==2.2.0; python_version < "3.13" and python_version >= "3.9" +soupsieve==2.6; python_version < "3.13" and python_version >= "3.9" +sphinx==7.4.7; python_version < "3.13" and python_version >= "3.9" +sphinx-rtd-theme==3.0.2; python_version < "3.13" and python_version >= "3.9" +sphinxcontrib-applehelp==2.0.0; python_version < "3.13" and python_version >= "3.9" +sphinxcontrib-devhelp==2.0.0; python_version < "3.13" and python_version >= "3.9" +sphinxcontrib-htmlhelp==2.1.0; python_version < "3.13" and python_version >= "3.9" +sphinxcontrib-jquery==4.1; python_version < "3.13" and python_version >= "3.9" +sphinxcontrib-jsmath==1.0.1; python_version < "3.13" and python_version >= "3.9" +sphinxcontrib-qthelp==2.0.0; python_version < "3.13" and python_version >= "3.9" +sphinxcontrib-serializinghtml==2.0.0; python_version < "3.13" and python_version >= "3.9" +stack-data==0.6.3; python_version < "3.13" and python_version >= "3.9" +terminado==0.18.1; python_version < "3.13" and python_version >= "3.9" +tinycss2==1.3.0; python_version < "3.13" and python_version >= "3.9" +tomli==2.2.1; python_version < "3.11" and python_version >= "3.9" +tornado==6.4.2; python_version < "3.13" and python_version >= "3.9" +tox==4.24.1; python_version < "3.13" and python_version >= "3.9" +tqdm==4.67.1; python_version < "3.13" and python_version >= "3.9" +traitlets==5.14.3; python_version < "3.13" and python_version >= "3.9" +trame==3.6.5; python_version < "3.13" and python_version >= "3.9" +trame-client==3.2.5; python_version < "3.13" and python_version >= "3.9" +trame-server==3.1.2; python_version < "3.13" and python_version >= "3.9" +trame-vtk==2.8.10; python_version < "3.13" and python_version >= "3.9" +trame-vuetify==2.7.1; python_version < "3.13" and python_version >= "3.9" +types-python-dateutil==2.9.0.20240906; python_version < "3.13" and python_version >= "3.9" +typing-extensions==4.12.2; python_version < "3.13" and python_version >= "3.9" +tzdata==2024.1; python_version < "3.13" and python_version >= "3.9" +uri-template==1.3.0; python_version < "3.13" and python_version >= "3.9" +urllib3==2.2.2; python_version < "3.13" and python_version >= "3.9" +virtualenv==20.29.1; python_version < "3.13" and python_version >= "3.9" +vtk==9.3.1; python_version < "3.13" and python_version >= "3.9" +wcwidth==0.2.13; python_version < "3.13" and python_version >= "3.9" +webcolors==24.8.0; python_version < "3.13" and python_version >= "3.9" +webencodings==0.5.1; python_version < "3.13" and python_version >= "3.9" +websocket-client==1.8.0; python_version < "3.13" and python_version >= "3.9" +widgetsnbextension==4.0.13; python_version < "3.13" and python_version >= "3.9" +wslink==2.1.3; python_version < "3.13" and python_version >= "3.9" +yarl==1.18.3; python_version < "3.13" and python_version >= "3.9" +zipp==3.20.1; python_version < "3.10" and python_version >= "3.9" diff --git a/src/pyoma2/__init__.py b/src/pyoma2/__init__.py new file mode 100644 index 0000000..b8a9bad --- /dev/null +++ b/src/pyoma2/__init__.py @@ -0,0 +1,3 @@ +from .support.utils.logging_handler import configure_logging + +configure_logging() diff --git a/src/pyoma2/algorithms/__init__.py b/src/pyoma2/algorithms/__init__.py new file mode 100644 index 0000000..d250089 --- /dev/null +++ b/src/pyoma2/algorithms/__init__.py @@ -0,0 +1,5 @@ +from .data.run_params import FDDRunParams, SSIRunParams, pLSCFRunParams # noqa +from .fdd import EFDD, EFDD_MS, FDD, FDD_MS, FSDD # noqa +from .plscf import pLSCF, pLSCF_MS # noqa +from .ssi import SSIcov, SSIcov_MS, SSIdat, SSIdat_MS # noqa +from .base import BaseAlgorithm # noqa diff --git a/src/pyoma2/algorithms/base.py b/src/pyoma2/algorithms/base.py new file mode 100644 index 0000000..2aa11e3 --- /dev/null +++ b/src/pyoma2/algorithms/base.py @@ -0,0 +1,369 @@ +""" +Abstract Base Class Module used by various OMA algorithms. +Part of the pyOMA2 package. +Authors: +Dag Pasca +Diego Margoni +""" + +from __future__ import annotations + +import abc +import typing + +from pydantic import BaseModel + +from pyoma2.algorithms.data.result import BaseResult +from pyoma2.algorithms.data.run_params import BaseRunParams + +if typing.TYPE_CHECKING: + pass + + +T_RunParams = typing.TypeVar("T_RunParams", bound=BaseRunParams) +T_Result = typing.TypeVar("T_Result", bound=BaseResult) +T_Data = typing.TypeVar("T_Data", bound=typing.Iterable) + + +class BaseAlgorithm(typing.Generic[T_RunParams, T_Result, T_Data], abc.ABC): + """ + Abstract base class for OMA algorithms. + + This class serves as a foundational structure for implementing various OMA algorithms, + setting a standard interface and workflow. + + Attributes + ---------- + result : Optional[T_Result] + Stores the results produced by the algorithm. The type of result depends on T_Result. + run_params : Optional[T_RunParams] + Holds the parameters necessary to run the algorithm. The type of run parameters + depends on T_RunParams. + name : Optional[str] + The name of the algorithm, used for identification and logging. + RunParamCls : Type[T_RunParams] + The class used for instantiating run parameters. Must be a subclass of BaseModel. + ResultCls : Type[T_Result] + The class used for encapsulating the algorithm's results. Must be a subclass + of BaseResult. + fs : Optional[float] + The sampling frequency of the input data. + dt : Optional[float] + The sampling interval, derived from the sampling frequency. + data : Optional[T_Data] + The input data for the algorithm. The type of data depends on T_Data. + + Methods + ------- + __init__(self, run_params=None, name=None, *args, **kwargs) + Initializes the algorithm with optional run parameters and a name. + set_run_params(self, run_params) + Sets the run parameters for the algorithm. + _set_result(self, result) + Assigns the result to the algorithm after execution. + _set_data(self, data, fs) + Sets the input data and sampling frequency for the algorithm. + __class_getitem__(cls, item) + Evaluates the types of `RunParamCls` and `ResultCls` at runtime. + __init_subclass__(cls, **kwargs) + Ensures that subclasses define `RunParamCls` and `ResultCls`. + + Warning + ------- + The BaseAlgorithm class is not intended for direct instantiation by users. + Specific functionalities are provided through its subclasses. + """ + + result: typing.Optional[T_Result] = None + run_params: typing.Optional[T_RunParams] = None + name: typing.Optional[str] = None + RunParamCls: typing.Type[T_RunParams] + ResultCls: typing.Type[T_Result] + + # additional attributes set by the Setup Class + fs: typing.Optional[float] # sampling frequency + dt: typing.Optional[float] # sampling interval + data: typing.Optional[T_Data] # data + + def __init__( + self, + run_params: typing.Optional[T_RunParams] = None, + name: typing.Optional[str] = None, + *args: typing.Any, + **kwargs: typing.Any, + ): + """ + Initialize the algorithm with optional run parameters and a name. + + Parameters + ---------- + run_params : Optional[T_RunParams], optional + The parameters required to run the algorithm. If not provided, can be set later. + name : Optional[str], optional + The name of the algorithm. If not provided, defaults to the class name. + *args : tuple + Additional positional arguments. + **kwargs : dict + Additional keyword arguments used to instantiate run parameters if `run_params` is not provided. + """ + if run_params: + self.run_params = run_params + elif kwargs: + self.run_params = self.RunParamCls(**kwargs) + + self.name = name or self.__class__.__name__ + + def _pre_run(self): + """ + Internal method to perform pre-run checks. + + Raises + ------ + ValueError + If the sampling frequency (`fs`) or the input data (`data`) is not set. + If the run parameters (`run_params`) are not set. + + Note + ----- + This method is called internally by the `run` method to ensure that the necessary prerequisites + for running the algorithm are satisfied. + """ + if self.fs is None or self.data is None: + raise ValueError( + f"{self.name}: Sampling frequency and data must be set before running the algorithm, " + "use a Setup class to run it" + ) + if not self.run_params: + raise ValueError( + f"{self.name}: Run parameters must be set before running the algorithm, " + "use a Setup class to run it" + ) + + @abc.abstractmethod + def run(self) -> T_Result: + """ + Abstract method to execute the algorithm. + + This method must be implemented by all subclasses. It should use the set `run_params` and input `data` + to perform the modal analysis and save the result in the `result` attribute. + + Returns + ------- + T_Result + The result of the algorithm execution. + + Raises + ------ + NotImplementedError + If the method is not implemented in the subclass. + + Note + ----- + Implementing classes should handle the algorithm logic within this method and ensure that the + output is an instance of the `ResultCls`. + """ + + def set_run_params(self, run_params: T_RunParams) -> "BaseAlgorithm": + """ + Set the run parameters for the algorithm. + + Parameters + ---------- + run_params : T_RunParams + The run parameters for the algorithm. + + Returns + ------- + BaseAlgorithm + Returns the instance with updated run parameters. + + Note + ----- + This method allows dynamically setting or updating the run parameters for the algorithm + after its initialization. + """ + self.run_params = run_params + return self + + def _set_result(self, result: T_Result) -> "BaseAlgorithm": + """ + Set the result of the algorithm. + + Parameters + ---------- + result : T_Result + The result obtained from running the algorithm. + + Returns + ------- + BaseAlgorithm + Returns the instance with the set result. + + Note + ----- + This method is used to assign the result after the algorithm execution. The result should be + an instance of the `ResultCls`. + """ + self.result = result + return self + + @abc.abstractmethod + def mpe(self, *args, **kwargs) -> typing.Any: + """ + Abstract method to return the modal parameters extracted by the algorithm. + + Parameters + ---------- + *args : tuple + Positional arguments. + **kwargs : dict + Keyword arguments. + + Returns + ------- + typing.Any + The modal parameters extracted by the algorithm. + + Raises + ------ + NotImplementedError + If the method is not implemented in the subclass. + ValueError + If the algorithm has not been run or the result is not set. + + Note + ----- + Implementing classes should override this method to provide functionality for extracting + and returning modal parameters based on the algorithm's results. + """ + # METODO 2 (manuale) + if not self.result: + raise ValueError("Run algorithm first") + + @abc.abstractmethod + def mpe_from_plot(self, *args, **kwargs) -> typing.Any: + """ + Abstract method to select peaks or modal parameters from plots. + + Parameters + ---------- + *args : tuple + Positional arguments. + **kwargs : dict + Keyword arguments. + + Returns + ------- + typing.Any + The selected peaks or modal parameters. + + Raises + ------ + NotImplementedError + If the method is not implemented in the subclass. + ValueError + If the algorithm has not been run or the result is not set. + + Note + ----- + Implementing classes should provide mechanisms for selecting and returning peaks or modal parameters + from graphical plots or visual representations of the data. + """ + # METODO 2 (grafico) + if not self.result: + raise ValueError(f"{self.name}:Run algorithm first") + + def _set_data(self, data: T_Data, fs: float) -> "BaseAlgorithm": + """ + Set the input data and sampling frequency for the algorithm. + + Parameters + ---------- + data : T_Data + The input data for the algorithm. + fs : float + The sampling frequency of the data. + + Returns + ------- + BaseAlgorithm + Returns the instance with the set data and sampling frequency. + + Note + ----- + This method is typically used by the Setup class to provide the necessary data and sampling + frequency to the algorithm before its execution. + """ + self.data = data + self.fs = fs + self.dt = 1 / fs + return self + + def __class_getitem__(cls, item): + """ + Class method to evaluate the types of `RunParamCls` and `ResultCls` at runtime. + + This method dynamically sets the `RunParamCls` and `ResultCls` class attributes based on the + provided `item` types. + + Parameters + ---------- + item : tuple + A tuple containing the types for `RunParamCls` and `ResultCls`. + + Returns + ------- + cls : BaseAlgorithm + The class with evaluated `RunParamCls` and `ResultCls`. + + Note + ----- + This class method is a workaround to dynamically determine the types of `RunParamCls` and `ResultCls` + at runtime. It is particularly useful for type checking and ensuring consistency across different + subclasses of `BaseAlgorithm`. + """ + # tricky way to evaluate at runtime the type of the RunParamCls and ResultCls + if not issubclass(cls, BaseAlgorithm): + # avoid evaluating the types for the BaseAlgorithm class itself + cls.RunParamCls = item[0] + cls.ResultCls = item[1] + return cls + + def __init_subclass__(cls, **kwargs): + """ + Initialize subclass of `BaseAlgorithm`. + + This method ensures that subclasses of `BaseAlgorithm` define `RunParamCls` and `ResultCls`. + + Raises + ------ + ValueError + If `RunParamCls` or `ResultCls` are not defined or not subclasses of `BaseModel` and `BaseResult`, + respectively. + + Note + ----- + This method is automatically called when a subclass of `BaseAlgorithm` is defined. It checks that + `RunParamCls` and `ResultCls` are correctly set in the subclass. This is essential for the proper + functioning of the algorithm's infrastructure. + """ + super().__init_subclass__(**kwargs) + + if not getattr(cls, "RunParamCls", None) or not issubclass( + cls.RunParamCls, BaseModel + ): + raise ValueError( + f"{cls.__name__}: RunParamCls must be defined in subclasses of BaseAlgorithm\n\n" + "# Example\n" + f"class {cls.__name__}:\n" + f"\tRunParamCls = ...\n" + ) + if not getattr(cls, "ResultCls", None) or not issubclass( + cls.ResultCls, BaseResult + ): + raise ValueError( + f"{cls.__name__}: ResultCls must be defined in subclasses of BaseAlgorithm\n\n" + "# Example\n" + f"class {cls.__name__}:\n" + f"\tResultCls = ...\n" + ) diff --git a/src/pyoma2/algorithms/data/result.py b/src/pyoma2/algorithms/data/result.py new file mode 100644 index 0000000..f424411 --- /dev/null +++ b/src/pyoma2/algorithms/data/result.py @@ -0,0 +1,208 @@ +""" +This module provides classes for handling and storing various types of results data +related to the pyOMA2 module. +""" + +from __future__ import annotations + +from typing import List, Optional, Union + +import numpy as np +import numpy.typing as npt +from pydantic import BaseModel, ConfigDict + + +class BaseResult(BaseModel): + """ + Base class for storing results data. + + Attributes + ---------- + Fn : numpy.NDArray + Array of natural frequencies obtained from modal analysis. + Phi : numpy.NDArray + Array of mode shape vectors obtained from modal analysis. + """ + + model_config = ConfigDict(from_attributes=True, arbitrary_types_allowed=True) + # dopo mpe o mpe_from_plot + Fn: Optional[npt.NDArray[np.float64]] = None # array of natural frequencies + Phi: Optional[npt.NDArray[np.float64]] = None # array of Mode shape vectors + + +class FDDResult(BaseResult): + """ + Class for storing Frequency Domain Decomposition (FDD) results data. + + Attributes + ---------- + freq : numpy.NDArray + Array of frequencies. + Sy : numpy.NDArray + PSD obtained from the FDD analysis. + S_val : numpy.NDArray + Singular values of the PSD. + S_vec : numpy.NDArray + Singular vectors of the PSD. + """ + + freq: Optional[npt.NDArray[np.float64]] = None + Sy: Optional[npt.NDArray[np.float64]] = None + S_val: Optional[npt.NDArray[np.float64]] = None + S_vec: Optional[npt.NDArray[np.float64]] = None + + +class EFDDResult(FDDResult): + """ + Class for storing results data from Enhanced Frequency Domain Decomposition (EFDD) + and Frequency Spatial Domain Decomposition (FSDD). + + Attributes + ---------- + freq : numpy.NDArray + Array of frequencies. + Sy : numpy.NDArray + PSD obtained from the analysis. + S_val : numpy.NDArray + Singular values of the PSD. + S_vec : numpy.NDArray + Singular vectors of the PSD. + Xi : numpy.NDArray + Array of damping ratios obtained from modal analysis. + forPlot : list + A list to store data for plotting purposes. + """ + + # dopo mpe, MPE_forPlot + Xi: Optional[npt.NDArray[np.float64]] = None # array of damping ratios + forPlot: Optional[List] = None + + +class SSIResult(BaseResult): + """ + Class for storing results data from Stochastic Subspace Identification (SSI) methods. + + Attributes + ---------- + Obs : numpy.NDArray, optional + Observability matrix obtained from the SSI analysis. + A : list of numpy.NDArray, optional + List of system matrices A from the SSI analysis. + C : list of numpy.NDArray, optional + List of system matrices C from the SSI analysis. + H : numpy.NDArray, optional + Hankel matrix used in SSI analysis. + Lambds : numpy.NDArray, optional + Array of eigenvalues from the SSI analysis. + Fn_poles : numpy.NDArray, optional + Array of all natural frequencies. + Xi_poles : numpy.NDArray, optional + Array of all damping ratios. + Phi_poles : numpy.NDArray, optional + Array of all mode shape vectors. + Lab : numpy.NDArray, optional + Array of labels for all the poles. + Fn_poles_std : numpy.NDArray, optional + Covariance of all natural frequencies. + Xi_poles_std : numpy.NDArray, optional + Covariance of all damping ratios. + Phi_poles_std : numpy.NDArray, optional + Covariance of all mode shape vectors. + Xi : numpy.NDArray, optional + Array of damping ratios. + order_out : Union[list[int], int], optional + Output order after modal parameter estimation. Can be a list of integers or a single integer. + Fn_std : numpy.NDArray, optional + Covariance of natural frequencies obtained from the analysis. + Xi_std : numpy.NDArray, optional + Covariance of damping ratios obtained from the analysis. + Phi_std : numpy.NDArray, optional + Covariance of mode shape vectors obtained from the analysis. + """ + + Obs: Optional[npt.NDArray[np.float64]] = None + A: Optional[List[npt.NDArray[np.float64]]] = None + C: Optional[List[npt.NDArray[np.float64]]] = None + H: Optional[npt.NDArray[np.float64]] = None + + Lambds: Optional[npt.NDArray[np.float64]] = None + Fn_poles: Optional[npt.NDArray[np.float64]] = None + Xi_poles: Optional[npt.NDArray[np.float64]] = None + Phi_poles: Optional[npt.NDArray[np.float64]] = None + Lab: Optional[npt.NDArray[np.float64]] = None + Fn_poles_std: Optional[npt.NDArray[np.float64]] = None + Xi_poles_std: Optional[npt.NDArray[np.float64]] = None + Phi_poles_std: Optional[npt.NDArray[np.float64]] = None + # dopo mpe, MPE_forPlot + Xi: Optional[npt.NDArray[np.float64]] = None # array of damping ratios + order_out: Optional[Union[int, List[int]]] = None + Fn_std: Optional[npt.NDArray[np.float64]] = None # covariance of natural frequencies + Xi_std: Optional[npt.NDArray[np.float64]] = None # covariance of damping ratios + Phi_std: Optional[npt.NDArray[np.float64]] = None # covariance of mode shapes + + +class pLSCFResult(BaseResult): + """ + Class for storing results data from the poly-reference Least Square Complex Frequency (pLSCF) method. + + Attributes + ---------- + freq : numpy.NDArray + Array of frequencies. + Sy : numpy.NDArray + PSD obtained from the analysis. + Ad : list of numpy.NDArray + Denominator polynomial coefficients from pLSCF analysis. + Bn : list of numpy.NDArray + Numerator polynomial coefficients from pLSCF analysis. + Fn_poles : numpy.NDArray + Array of identified natural frequencies (poles) from pLSCF analysis. + xi_poles : numpy.NDArray + Array of damping ratios corresponding to identified poles. + Phi_poles : numpy.NDArray + Array of mode shape vectors corresponding to identified poles. + Lab : numpy.NDArray + Array of labels for the identified poles. + Xi : numpy.NDArray + Array of damping ratios obtained after modal parameter estimation. + order_out : Union[list[int], int] + Output order after modal parameter estimation. Can be a list of integers, or a single integer. + """ + + freq: Optional[npt.NDArray[np.float64]] = None + Sy: Optional[npt.NDArray[np.float64]] = None + Ad: Optional[List[npt.NDArray[np.float64]]] = None + Bn: Optional[List[npt.NDArray[np.float64]]] = None + Fn_poles: Optional[npt.NDArray[np.float64]] = None + Xi_poles: Optional[npt.NDArray[np.float64]] = None + Phi_poles: Optional[npt.NDArray[np.float64]] = None + Lab: Optional[npt.NDArray[np.float64]] = None + # dopo mpe, MPE_forPlot + Xi: Optional[npt.NDArray[np.float64]] = None # array of damping ratios + order_out: Optional[Union[List[int], int]] = None + + +class MsPoserResult(BaseResult): + """ + Base class for MultiSetup Poser result data. + + Attributes + ---------- + Phi : numpy.NDArray + Array of mode shape vectors obtained from MultiSetup Poser analysis. + Fn : numpy.NDArray + Array of natural frequencies obtained from MultiSetup Poser analysis (mean value). + Fn_std : numpy.NDArray + Standard deviation of natural frequencies between setups. + Xi : numpy.NDArray + Array of damping ratios obtained from MultiSetup Poser analysis (mean value). + Xi_std : numpy.NDArray + Standard deviation of damping ratios. + """ + + model_config = ConfigDict(from_attributes=True, arbitrary_types_allowed=True) + Phi: npt.NDArray[np.float64] + Fn: npt.NDArray[np.float64] + Fn_std: npt.NDArray[np.float64] + Xi: npt.NDArray[np.float64] + Xi_std: npt.NDArray[np.float64] diff --git a/src/pyoma2/algorithms/data/run_params.py b/src/pyoma2/algorithms/data/run_params.py new file mode 100644 index 0000000..40fd641 --- /dev/null +++ b/src/pyoma2/algorithms/data/run_params.py @@ -0,0 +1,243 @@ +""" +This module provides classes for storing run parameters for various modal analysis +algorithms included in the pyOMA2 module. +""" + +from __future__ import annotations + +from typing import List, Literal, Optional, Union + +import numpy as np +import numpy.typing as npt +from pydantic import BaseModel, ConfigDict +from typing_extensions import TypedDict + + +class HCDictType(TypedDict): + xi_max: Optional[float] = None + mpc_lim: Optional[float] = None + mpd_lim: Optional[float] = None + CoV_max: Optional[float] = None + + +class SCDictType(TypedDict): + err_fn: float + err_xi: float + err_phi: float + + +class BaseRunParams(BaseModel): + """ + Base class for storing run parameters for modal analysis algorithms. + """ + + model_config = ConfigDict( + from_attributes=True, arbitrary_types_allowed=True, extra="forbid" + ) + + +class FDDRunParams(BaseRunParams): + """ + Class for storing Frequency Domain Decomposition (FDD) run parameters. + + Attributes + ---------- + nxseg : int, optional + Number of points per segment, default is 1024. + method_SD : str, optional ["per", "cor"] + Method used for spectral density estimation, default is "per". + pov : float, optional + Percentage of overlap between segments (only for "per"), default is 0.5. + sel_freq : numpy.ndarray + Array of selected frequencies for modal parameter estimation,. + DF : float, optional + Frequency resolution for estimation, default is 0.1. + + Notes + ----- + `sel_freq` and `DF` are used in the ``mpe`` method. + """ + + # METODO 1: run + nxseg: int = 1024 + method_SD: Literal["per", "cor"] = "per" + pov: float = 0.5 + # METODO 2: mpe e mpe_from_plot + sel_freq: Optional[npt.NDArray[np.float64]] = None + DF: float = 0.1 + + +class EFDDRunParams(BaseRunParams): + """ + Class for storing Enhanced Frequency Domain Decomposition (EFDD) run parameters. + + Attributes + ---------- + nxseg : int, optional + Number of points per segment, default is 1024. + method_SD : str, optional ["per", "cor"] + Method used for spectral density estimation, default is "per". + pov : float, optional + Percentage of overlap between segments (only for "per"), default is 0.5. + sel_freq : numpy.ndarray + Array of selected frequencies for modal parameter estimation,. + DF1 : float, optional + Frequency resolution for estimation, default is 0.1. + DF2 : float + Frequency resolution for the second stage of EFDD, default is 1.0. + cm : int + Number of closely spaced modes, default is 1. + MAClim : float + Minimum acceptable Modal Assurance Criterion value, default is 0.85. + sppk : int + Number of peaks to skip for the fit, default is 3. + npmax : int + Maximum number of peaks to use in the fit, default is 20. + Notes + ----- + `sel_freq`, `DF1`, `DF2`, `cm`, `MAClim`, `sppk` and `npmax` + are used in the ``mpe`` method. + """ + + # METODO 1: run + nxseg: int = 1024 + method_SD: Literal["per", "cor"] = "per" + pov: float = 0.5 + # METODO 2: mpe e mpe_from_plot + sel_freq: Optional[npt.NDArray[np.float64]] = None + DF1: float = 0.1 + DF2: float = 1.0 + cm: int = 1 + MAClim: float = 0.95 + sppk: int = 3 + npmax: int = 20 + + +class SSIRunParams(BaseRunParams): + """ + Parameters for the Stochastic Subspace Identification (SSI) method. + + Attributes + ---------- + br : int + Number of block rows in the Hankel matrix. + method_hank : str or None, optional + Method used in the SSI algorithm. Options are ['data', 'cov', 'cov_R']. + Default is None. + ref_ind : list of int or None, optional + List of reference indices used for subspace identification. Default is None. + ordmin : int, optional + Minimum model order for the analysis. Default is 0. + ordmax : int or None, optional + Maximum model order for the analysis. Default is None. + step : int, optional + Step size for iterating through model orders. Default is 1. + sc : dict, optional + Soft criteria for the SSI analysis, including thresholds for relative + frequency difference (`err_fn`), damping ratio difference (`err_xi`), and + Modal Assurance Criterion (`err_phi`). Default values are {'err_fn': 0.01, + 'err_xi': 0.05, 'err_phi': 0.03}. + hc : dict, optional + Hard criteria for the SSI analysis, including settings for presence of + complex conjugates (`conj`), maximum damping ratio (`xi_max`), + Modal Phase Collinearity (`mpc_lim`), and Mean Phase Deviation (`mpd_lim`) + and maximum covariance (`cov_max`). Default values are {'conj': True, + 'xi_max': 0.1, 'mpc_lim': 0.7, 'mpd_lim': 0.3, 'cov_max': 0.2}. + calc_unc : bool, optional + Whether to calculate uncertainty. Default is False. + nb : int, optional + Number of bootstrap samples to use for uncertainty calculations (default is 100). + sel_freq : list of float or None, optional + List of selected frequencies for modal parameter extraction. Default is None. + order_in : int, list of int, or str + Specified model order(s) for which the modal parameters are to be extracted. + If 'find_min', the function attempts to find the minimum model order that provides + stable poles for each mode of interest. + rtol : float, optional + Relative tolerance for comparing identified frequencies with the selected ones. + Default is 5e-2. + + Notes + ----- + `sel_freq`, `order_in`, and `rtol` are used in the ``mpe`` method to extract + modal parameters. + """ + + # METODO 1: run + br: int = 20 + method: str = None + ref_ind: Optional[List[int]] = None + ordmin: int = 0 + ordmax: Optional[int] = None + step: int = 1 + sc: SCDictType = dict(err_fn=0.05, err_xi=0.05, err_phi=0.05) + hc: HCDictType = dict(xi_max=0.1, mpc_lim=0.5, mpd_lim=0.5, CoV_max=0.05) + calc_unc: bool = False # uncertainty calculations + nb: int = 50 # number of dataset blocks + # METODO 2: mpe e mpe_from_plot + sel_freq: Optional[List[float]] = None + order_in: Union[int, List[int], str] = "find_min" + rtol: float = 5e-2 + + +class pLSCFRunParams(BaseRunParams): + """ + Parameters for the poly-reference Least Square Complex Frequency (pLSCF) method. + + Attributes + ---------- + ordmax : int + Maximum order for the analysis. + ordmin : int, optional + Minimum order for the analysis. Default is 0. + nxseg : int, optional + Number of segments for the Power Spectral Density (PSD) estimation. + Default is 1024. + method_SD : str, optional + Method used for spectral density estimation. Options are ['per', 'cor']. + Default is 'per'. + pov : float, optional + Percentage of overlap between segments for PSD estimation (only applicable + for 'per' method). Default is 0.5. + sc : dict, optional + Soft criteria for the SSI analysis, including thresholds for relative + frequency difference (`err_fn`), damping ratio difference (`err_xi`), and + Modal Assurance Criterion (`err_phi`). Default values are {'err_fn': 0.01, + 'err_xi': 0.05, 'err_phi': 0.03}. + hc : dict, optional + Hard criteria for the SSI analysis, including settings for presence of + complex conjugates (`conj`), maximum damping ratio (`xi_max`), + Modal Phase Collinearity (`mpc_lim`), and Mean Phase Deviation (`mpd_lim`) + and maximum covariance (`cov_max`). Default values are {'conj': True, + 'xi_max': 0.1, 'mpc_lim': 0.7, 'mpd_lim': 0.3, 'cov_max': 0.2}. + sel_freq : list of float or None, optional + List of selected frequencies for modal parameter extraction. Default is None. + order_in : int or str, optional + Specified model order for extraction. Can be an integer or 'find_min'. Default + is 'find_min'. + deltaf : float, optional + Frequency bandwidth around each selected frequency. Default is 0.05. + rtol : float, optional + Relative tolerance for comparing identified frequencies with the selected ones. + Default is 1e-2. + + Notes + ----- + `sel_freq`, `order_in`, `deltaf`, and `rtol` are used in the ``mpe`` method to + extract modal parameters. + """ + + # METODO 1: run + ordmax: int + ordmin: int = 0 + nxseg: int = 1024 + method_SD: Literal["per", "cor"] = "per" + pov: float = 0.5 + # sgn_basf: int = -1 + # step: int = 1 + sc: SCDictType = dict(err_fn=0.05, err_xi=0.05, err_phi=0.05) + hc: HCDictType = dict(xi_max=0.1, mpc_lim=0.7, mpd_lim=0.3) + # METODO 2: mpe e mpe_from_plot + sel_freq: Optional[List[float]] = None + order_in: Union[int, List[int], str] = "find_min" + rtol: float = 5e-2 diff --git a/src/pyoma2/algorithms/fdd.py b/src/pyoma2/algorithms/fdd.py new file mode 100644 index 0000000..4bc0f23 --- /dev/null +++ b/src/pyoma2/algorithms/fdd.py @@ -0,0 +1,557 @@ +""" +Frequency Domain Decomposition (FDD) Algorithm Module. +Part of the pyOMA2 package. +Authors: +Dag Pasca +Diego Margoni +""" + +from __future__ import annotations + +import logging +import typing + +from pyoma2.algorithms.base import BaseAlgorithm +from pyoma2.algorithms.data.result import EFDDResult, FDDResult +from pyoma2.algorithms.data.run_params import EFDDRunParams, FDDRunParams +from pyoma2.functions import fdd, plot +from pyoma2.support.sel_from_plot import SelFromPlot + +logger = logging.getLogger(__name__) + + +# ============================================================================= +# SINGLE SETUP +# ============================================================================= +# FREQUENCY DOMAIN DECOMPOSITION +class FDD(BaseAlgorithm[FDDRunParams, FDDResult, typing.Iterable[float]]): + """ + Frequency Domain Decomposition (FDD) algorithm for operational modal analysis. + + This class implements the FDD algorithm, used to identify modal parameters such as + natural frequencies, damping ratios, and mode shapes from ambient vibrations. The algorithm + operates in the frequency domain and is suitable for output-only modal analysis. + + Attributes + ---------- + RunParamCls : Type[FDDRunParams] + Class of the run parameters specific to the FDD algorithm. + ResultCls : Type[FDDResult] + Class of the results generated by the FDD algorithm. + data : Iterable[float] + Input data for the algorithm, typically a time series of vibration measurements. + """ + + RunParamCls = FDDRunParams + ResultCls = FDDResult + + def run(self) -> FDDResult: + """ + Executes the FDD algorithm on the input data and computes modal parameters. + + Processes the input time series data to compute the spectral density matrix. It then + extracts its singular values and vectors, which are crucial for modal parameter identification. + + Returns + ------- + FDDResult + An object containing frequency spectrum, spectral density matrix, singular values, + and vectors as analysis results. + """ + Y = self.data.T + nxseg = self.run_params.nxseg + method = self.run_params.method_SD + pov = self.run_params.pov + # self.run_params.df = 1 / dt / nxseg + + freq, Sy = fdd.SD_est(Y, Y, self.dt, nxseg, method=method, pov=pov) + Sval, Svec = fdd.SD_svalsvec(Sy) + + # Return results + return self.ResultCls( + freq=freq, + Sy=Sy, + S_val=Sval, + S_vec=Svec, + ) + + def mpe(self, sel_freq: typing.List[float], DF: float = 0.1) -> typing.Any: + """ + Performs Modal Parameter Estimation (mpe) on selected frequencies using FDD results. + + Estimates modal parameters such as natural frequencies and mode shapes from the + frequencies specified by the user. + + Parameters + ---------- + sel_freq : List[float] + List of selected frequencies for modal parameter estimation. + DF : float, optional + Frequency resolution for estimation. Default is 0.1. + + Returns + ------- + None + The method updates the results in the associated FDDResult object with the estimated + modal parameters. + """ + super().mpe(sel_freq=sel_freq, DF=DF) + + self.run_params.sel_freq = sel_freq + self.run_params.DF = DF + # Sy = self.result.Sy + S_val = self.result.S_val + S_vec = self.result.S_vec + freq = self.result.freq + + # Get Modal Parameters + Fn_FDD, Phi_FDD = fdd.FDD_mpe( + Sval=S_val, Svec=S_vec, freq=freq, sel_freq=sel_freq, DF=DF + ) + + # Save results + self.result.Fn = Fn_FDD + self.result.Phi = Phi_FDD + + def mpe_from_plot( + self, freqlim: typing.Optional[tuple[float, float]] = None, DF: float = 0.1 + ) -> typing.Any: + """ + Extracts modal parameters interactively from a plot using selected frequencies. + + This method allows for interactive selection of frequencies from a plot, followed by + mpe at those frequencies. + + Parameters + ---------- + freqlim : Optional[tuple[float, float]], optional + Frequency range for the interactive plot. Default is None. + DF : float, optional + Frequency resolution for estimation. Default is 0.1. + + Returns + ------- + None + Updates the results in the associated FDDResult object with the selected modal parameters. + """ + super().mpe_from_plot(freqlim=freqlim) + + # Sy = self.result.Sy + S_val = self.result.S_val + S_vec = self.result.S_vec + freq = self.result.freq + + self.run_params.DF = DF + + # chiamare plot interattivo + SFP = SelFromPlot(algo=self, freqlim=freqlim, plot="FDD") + sel_freq = SFP.result[0] + + # e poi estrarre risultati + Fn_FDD, Phi_FDD = fdd.FDD_mpe( + Sval=S_val, Svec=S_vec, freq=freq, sel_freq=sel_freq, DF=DF + ) + + # Save results + self.result.Fn = Fn_FDD + self.result.Phi = Phi_FDD + + def plot_CMIF( + self, + freqlim: typing.Optional[tuple[float, float]] = None, + nSv: typing.Optional[int] = "all", + ) -> typing.Any: + """ + Plots the Complex Mode Indication Function (CMIF) for the FDD results. + + CMIF is used to identify modes in the frequency domain data. It plots the singular values + of the spectral density matrix as a function of frequency. + + Parameters + ---------- + freqlim : Optional[tuple[float, float]], optional + Frequency range for the CMIF plot. Default is None. + nSv : Optional[int], optional + Number of singular values to include in the plot. Default is 'all'. + + Returns + ------- + tuple + A tuple containing the Matplotlib figure and axes objects for the CMIF plot. + + Raises + ------ + ValueError + If the algorithm has not been run and no results are available. + """ + if not self.result: + raise ValueError("Run algorithm first") + fig, ax = plot.CMIF_plot( + S_val=self.result.S_val, freq=self.result.freq, freqlim=freqlim, nSv=nSv + ) + return fig, ax + + +# ------------------------------------------------------------------------------ +# ENHANCED FREQUENCY DOMAIN DECOMPOSITION EFDD +class EFDD(FDD[EFDDRunParams, EFDDResult, typing.Iterable[float]]): + """ + Enhanced Frequency Domain Decomposition (EFDD) Algorithm Class. + + This class implements the EFDD algorithm, an enhanced version of the basic FDD method. + It provides more accurate modal parameters from ambient vibration data. + + Attributes + ---------- + method : str + The method used in the analysis. Set to "EFDD" for this class. + RunParamCls : EFDDRunParams + Class for the run parameters specific to the EFDD algorithm. + ResultCls : EFDDResult + Class for storing results obtained from the EFDD analysis. + + Note + ----- + Inherits from `FDD` and provides specialized methods and functionalities + for EFDD-specific analyses. + """ + + method: typing.Literal["EFDD", "FSDD"] = "EFDD" + + RunParamCls = EFDDRunParams + ResultCls = EFDDResult + + def mpe( + self, + sel_freq: typing.List[float], + DF1: float = 0.1, + DF2: float = 1.0, + cm: int = 1, + MAClim: float = 0.85, + sppk: int = 3, + npmax: int = 20, + ) -> typing.Any: + """ + Performs Modal Parameter Estimation (mpe) on selected frequencies using EFDD results. + + Estimates modal parameters such as natural frequencies, damping ratios, and mode shapes + from the frequencies specified by the user. + + Parameters + ---------- + sel_freq : List[float] + List of selected frequencies for modal parameter estimation. + DF1 : float, optional + Frequency resolution for the first stage of EFDD. Default is 0.1. + DF2 : float, optional + Frequency resolution for the second stage of EFDD. Default is 1.0. + cm : int, optional + Number of closely spaced modes. Default is 1. + MAClim : float, optional + Minimum acceptable Modal Assurance Criterion value. Default is 0.85. + sppk : int, optional + Number of peaks to skip for the fit. Default is 3. + npmax : int, optional + Maximum number of peaks to use in the fit. Default is 20. + + Returns + ------- + None + Updates the EFDDResult object with estimated modal parameters. + """ + + # Save run parameters + self.run_params.sel_freq = sel_freq + self.run_params.DF1 = DF1 + self.run_params.DF2 = DF2 + self.run_params.cm = cm + self.run_params.MAClim = MAClim + self.run_params.sppk = sppk + self.run_params.npmax = npmax + + # Extract modal results + Fn_FDD, Xi_FDD, Phi_FDD, forPlot = fdd.EFDD_mpe( + self.result.Sy, + self.result.freq, + self.dt, + sel_freq, + self.run_params.method_SD, + method=self.method, + DF1=DF1, + DF2=DF2, + cm=cm, + MAClim=MAClim, + sppk=sppk, + npmax=npmax, + ) + + # Save results + self.result.Fn = Fn_FDD.reshape(-1) + self.result.Xi = Xi_FDD.reshape(-1) + self.result.Phi = Phi_FDD + self.result.forPlot = forPlot + + def mpe_from_plot( + self, + DF1: float = 0.1, + DF2: float = 1.0, + cm: int = 1, + MAClim: float = 0.85, + sppk: int = 3, + npmax: int = 20, + freqlim: typing.Optional[tuple[float, float]] = None, + ) -> typing.Any: + """ + Performs Interactive Modal Parameter Estimation using plots in EFDD analysis. + + Allows interactive selection of frequencies from a plot for modal parameter estimation. + The method enhances user interaction and accuracy in selecting the frequencies for analysis. + + Parameters + ---------- + DF1 : float, optional + Frequency resolution for the first stage of EFDD. Default is 0.1. + DF2 : float, optional + Frequency resolution for the second stage of EFDD. Default is 1.0. + cm : int, optional + Number of clusters for mode separation. Default is 1. + MAClim : float, optional + Minimum acceptable MAC value. Default is 0.85. + sppk : int, optional + Number of spectral peaks to consider. Default is 3. + npmax : int, optional + Maximum number of peaks. Default is 20. + freqlim : Optional[tuple[float, float]], optional + Frequency limit for interactive plot. Default is None. + + Returns + ------- + None + Updates the EFDDResult object with modal parameters selected from the plot. + """ + + # Save run parameters + self.run_params.DF1 = DF1 + self.run_params.DF2 = DF2 + self.run_params.cm = cm + self.run_params.MAClim = MAClim + self.run_params.sppk = sppk + self.run_params.npmax = npmax + + # chiamare plot interattivo + SFP = SelFromPlot(algo=self, freqlim=freqlim, plot="FDD") + sel_freq = SFP.result[0] + + # e poi estrarre risultati + Fn_FDD, Xi_FDD, Phi_FDD, forPlot = fdd.EFDD_mpe( + self.result.Sy, + self.result.freq, + self.dt, + sel_freq, + self.run_params.method_SD, + method=self.method, + DF1=DF1, + DF2=DF2, + cm=cm, + MAClim=MAClim, + sppk=sppk, + npmax=npmax, + ) + # Save results + self.result.Fn = Fn_FDD.reshape(-1) + self.result.Xi = Xi_FDD.reshape(-1) + self.result.Phi = Phi_FDD + self.result.forPlot = forPlot + + def plot_EFDDfit( + self, freqlim: typing.Optional[tuple[float, float]] = None, *args, **kwargs + ) -> typing.Any: + """ + Plots Frequency domain Identification (FIT) results for EFDD analysis. + + Generates a FIT plot to visualize the quality and accuracy of modal identification in EFDD. + + Parameters + ---------- + freqlim : Optional[tuple[float, float]], optional + Frequency limit for the FIT plot. Default is None. + *args, **kwargs + Additional arguments and keyword arguments for plot customization. + + Returns + ------- + tuple + A tuple containing the Matplotlib figure and axes objects for the EFDD FIT plot. + + Raises + ------ + ValueError + If the algorithm has not been run and no results are available. + """ + + if not self.result: + raise ValueError("Run algorithm first") + + fig, ax = plot.EFDD_FIT_plot( + Fn=self.result.Fn, + Xi=self.result.Xi, + PerPlot=self.result.forPlot, + freqlim=freqlim, + ) + return fig, ax + + +# ------------------------------------------------------------------------------ +# FREQUENCY SPATIAL DOMAIN DECOMPOSITION FSDD +class FSDD(EFDD): + """ + Frequency-Spatial Domain Decomposition (FSDD) Algorithm Class. + + This class provides the implementation of the Frequency-Spatial Domain Decomposition (FSDD) + algorithm, a variant of the Enhanced Frequency Domain Decomposition (EFDD) method. + The FSDD approach extends the capabilities of EFDD enhancing the accuracy of modal parameter + estimation in operational modal analysis. + + Attributes + ---------- + method : str + The method used in the analysis. Set to "FSDD" for this class. + RunParamCls : Type[EFDDRunParams] + Class for specifying run parameters unique to the FSDD algorithm. + ResultCls : Type[EFDDResult] + Class for storing results obtained from the FSDD analysis. + + Methods + ------- + Inherits all methods from the EFDD class, with modifications for the FSDD approach. + + Note + ----- + Inherits functionalities from the EFDD class while focusing on the unique + aspects of the FSDD approach. + """ + + method: str = "FSDD" + + +# ============================================================================= +# MULTI SETUP +# ============================================================================= +# FREQUENCY DOMAIN DECOMPOSITION +class FDD_MS(FDD[FDDRunParams, FDDResult, typing.Iterable[dict]]): + """ + Frequency Domain Decomposition (FDD) Algorithm for Multi-Setup Analysis. + + This class extends the standard FDD algorithm to handle data from multiple experimental setups. + It's designed to merge and analyze data from different configurations. + + Attributes + ---------- + RunParamCls : Type[FDDRunParams] + Defines the run parameters specific to the FDD algorithm for multi-setup analysis. + ResultCls : Type[FDDResult] + Represents the class for storing results obtained from multi-setup FDD analysis. + data : Iterable[dict] + The input data for the algorithm, typically a collection of vibration measurements + from multiple setups. + + Note + ----- + Inherits the functionality from the standard FDD algorithm class, modifying it + for application with multiple experimental setups. + """ + + RunParamCls = FDDRunParams + ResultCls = FDDResult + + def run(self) -> FDDResult: + """ + Executes the FDD algorithm on multi-setup data for operational modal analysis. + + Processes input data from multiple experimental setups to conduct frequency domain decomposition. + The method computes spectral density matrices for each setup and then merges them to extract + singular values and vectors. + + Returns + ------- + FDDResult + An object encapsulating the results of the FDD analysis for multi-setup data, including + frequency spectrum, merged spectral density matrix, and associated singular values and vectors. + """ + Y = self.data + nxseg = self.run_params.nxseg + method = self.run_params.method_SD + pov = self.run_params.pov + # self.run_params.df = 1 / dt / nxseg + + freq, Sy = fdd.SD_PreGER(Y, self.fs, nxseg=nxseg, method=method, pov=pov) + Sval, Svec = fdd.SD_svalsvec(Sy) + + # Return results + return self.ResultCls( + freq=freq, + Sy=Sy, + S_val=Sval, + S_vec=Svec, + ) + + +# ------------------------------------------------------------------------------ +# ENHANCED FREQUENCY DOMAIN DECOMPOSITION EFDD +class EFDD_MS(EFDD[EFDDRunParams, EFDDResult, typing.Iterable[dict]]): + """ + Enhanced Frequency Domain Decomposition (EFDD) Algorithm for Multi-Setup Analysis. + + This class extends the EFDD algorithm to accommodate operational modal analysis + across multiple experimental setups. + + Attributes + ---------- + method : str + The method employed for multi-setup analysis ("EFDD"). + RunParamCls : EFDDRunParams + Class for specifying run parameters unique to the EFDD algorithm for multi-setups. + ResultCls : EFDDResult + Class for storing results obtained from the multi-setup EFDD analysis. + data : Iterable[dict] + The input data, consisting of vibration measurements from multiple setups. + + Note + ----- + This class adapts the EFDD algorithm's functionality for multiple experimental setups. + """ + + method = "EFDD" + RunParamCls = EFDDRunParams + ResultCls = EFDDResult + + def run(self) -> FDDResult: + """ + Executes the Enhanced Frequency Domain Decomposition (EFDD) algorithm on multi-setup data. + + Processes input data from multiple experimental setups for operational modal analysis using the EFDD + method. The method computes spectral density matrices for each setup and then merges them to extract + singular values and vectors. + + Returns + ------- + EFDDResult + An object encapsulating the results of the EFDD analysis for multi-setup data, including enhanced + frequency spectrum, merged spectral density matrices, and associated singular values and vectors. + """ + Y = self.data + nxseg = self.run_params.nxseg + method = self.run_params.method_SD + pov = self.run_params.pov + # self.run_params.df = 1 / dt / nxseg + + freq, Sy = fdd.SD_PreGER(Y, self.fs, nxseg=nxseg, method=method, pov=pov) + Sval, Svec = fdd.SD_svalsvec(Sy) + + # Return results + return self.ResultCls( + freq=freq, + Sy=Sy, + S_val=Sval, + S_vec=Svec, + ) diff --git a/src/pyoma2/algorithms/plscf.py b/src/pyoma2/algorithms/plscf.py new file mode 100644 index 0000000..a5613fa --- /dev/null +++ b/src/pyoma2/algorithms/plscf.py @@ -0,0 +1,429 @@ +""" +Poly-reference Least Square Frequency Domain (pLSCF) Module. +Part of the pyOMA2 package. +Authors: +Dag Pasca +Diego Margoni +""" + +from __future__ import annotations + +import logging +import typing + +from pyoma2.algorithms.data.result import pLSCFResult +from pyoma2.algorithms.data.run_params import pLSCFRunParams +from pyoma2.functions import fdd, gen, plot, plscf +from pyoma2.support.sel_from_plot import SelFromPlot + +from .base import BaseAlgorithm + +logger = logging.getLogger(__name__) + + +# ============================================================================= +# SINGLE SETUP +# ============================================================================= +class pLSCF(BaseAlgorithm[pLSCFRunParams, pLSCFResult, typing.Iterable[float]]): + """ + Implementation of the poly-reference Least Square Complex Frequency (pLSCF) algorithm for modal analysis. + + This class inherits from `BaseAlgorithm` and specializes in handling modal analysis computations and + visualizations based on the pLSCF method. It provides methods to run the analysis, extract modal parameter + estimation (mpe), plot stability diagrams, cluster diagrams, mode shapes, and animations of mode shapes. + + Parameters + ---------- + BaseAlgorithm : type + Inherits from the BaseAlgorithm class with specified type parameters for pLSCFRunParams, pLSCFResult, + and Iterable[float]. + + Attributes + ---------- + RunParamCls : pLSCFRunParams + Class attribute for run parameters specific to pLSCF algorithm. + ResultCls : pLSCFResult + Class attribute for results specific to pLSCF algorithm. + """ + + RunParamCls = pLSCFRunParams + ResultCls = pLSCFResult + + def run(self) -> pLSCFResult: + """ + Execute the pLSCF algorithm to perform modal analysis on the provided data. + + This method conducts a frequency domain analysis using the Least Square Complex Frequency method. + It computes system matrices, identifies poles, and labels them based on stability and other + criteria. + + Returns + ------- + pLSCFResult + An instance of `pLSCFResult` containing the analysis results, including frequencies, system + matrices, identified poles, and their labels. + """ + Y = self.data.T + nxseg = self.run_params.nxseg + method = self.run_params.method_SD + pov = self.run_params.pov + # sgn_basf = self.run_params.sgn_basf + ordmax = self.run_params.ordmax + ordmin = self.run_params.ordmin + sc = self.run_params.sc + hc = self.run_params.hc + + if method == "per": + sgn_basf = -1 + elif method == "cor": + sgn_basf = +1 + + freq, Sy = fdd.SD_est(Y, Y, self.dt, nxseg, method=method, pov=pov) + + Ad, Bn = plscf.pLSCF(Sy, self.dt, ordmax, sgn_basf=sgn_basf) + + Fns, Xis, Phis, Lambds = plscf.pLSCF_poles( + Ad, Bn, self.dt, nxseg=nxseg, methodSy=method + ) + + # Apply HARD CRITERIA + # hc_conj = hc.get("conj") + hc_xi_max = hc["xi_max"] + hc_mpc_lim = hc["mpc_lim"] + hc_mpd_lim = hc["mpd_lim"] + + # HC - presence of complex conjugate + # if hc_conj: + Lambds, mask1 = gen.HC_conj(Lambds) + lista = [Fns, Xis, Phis] + Fns, Xis, Phis = gen.applymask(lista, mask1, Phis.shape[2]) + + # HC - damping + Xis, mask2 = gen.HC_damp(Xis, hc_xi_max) + lista = [Fns, Phis] + Fns, Phis = gen.applymask(lista, mask2, Phis.shape[2]) + + # HC - MPC and MPD + if hc_mpc_lim is not None: + mask3 = gen.HC_MPC(Phis, hc_mpc_lim) + lista = [Fns, Xis, Phis, Lambds] + Fns, Xis, Phis, Lambds = gen.applymask(lista, mask3, Phis.shape[2]) + if hc_mpd_lim is not None: + mask4 = gen.HC_MPD(Phis, hc_mpd_lim) + lista = [Fns, Xis, Phis, Lambds] + Fns, Xis, Phis, Lambds = gen.applymask(lista, mask4, Phis.shape[2]) + + # Apply SOFT CRITERIA + # Get the labels of the poles + Lab = gen.SC_apply( + Fns, + Xis, + Phis, + ordmin, + ordmax - 1, + 1, + sc["err_fn"], + sc["err_xi"], + sc["err_phi"], + ) + + # Return results + return self.ResultCls( + freq=freq, + Sy=Sy, + Ad=Ad, + Bn=Bn, + Fn_poles=Fns, + Xi_poles=Xis, + Phi_poles=Phis, + Lab=Lab, + ) + + def mpe( + self, + sel_freq: typing.List[float], + order: typing.Union[int, str] = "find_min", + rtol: float = 5e-2, + ) -> typing.Any: + """ + Extract the modal parameters at the selected frequencies and order. + + Parameters + ---------- + sel_freq : List[float] + A list of frequencies for which the modal parameters are to be estimated. + order : int or str, optional + The order for modal parameter estimation or "find_min". + Default is 'find_min'. + deltaf : float, optional + The frequency range around each selected frequency to consider for estimation. Default is 0.05. + rtol : float, optional + Relative tolerance for convergence in the iterative estimation process. Default is 1e-2. + + Returns + ------- + Any + The results of the modal parameter estimation, typically including estimated frequencies, damping + ratios, and mode shapes. + """ + super().mpe(sel_freq=sel_freq, order=order, rtol=rtol) + + # Save run parameters + self.run_params.sel_freq = sel_freq + self.run_params.order_in = order + self.run_params.rtol = rtol + + # Get poles + Fn_pol = self.result.Fn_poles + Sm_pol = self.result.Xi_poles + Ms_pol = self.result.Phi_poles + Lab = self.result.Lab + + # Extract modal results + Fn_pLSCF, Xi_pLSCF, Phi_pLSCF, order_out = plscf.pLSCF_mpe( + sel_freq, Fn_pol, Sm_pol, Ms_pol, order, Lab=Lab, rtol=rtol + ) + + # Save results + self.result.order_out = order_out + self.result.Fn = Fn_pLSCF + self.result.Xi = Xi_pLSCF + self.result.Phi = Phi_pLSCF + + def mpe_from_plot( + self, + freqlim: typing.Optional[tuple[float, float]] = None, + rtol: float = 5e-2, + ) -> typing.Any: + """ + Extract the modal parameters directly from the stabilisation chart. + + Parameters + ---------- + freqlim : tuple of float, optional + A tuple specifying the frequency limits (min, max) for the plot. If None, the limits are + determined automatically. Default is None. + deltaf : float, optional + The frequency range around each selected frequency to consider for estimation. Default is 0.05. + rtol : float, optional + Relative tolerance for convergence in the iterative estimation process. Default is 1e-2. + + Returns + ------- + Any + The results of the modal parameter estimation based on user selection from the plot. + """ + super().mpe_from_plot(freqlim=freqlim, rtol=rtol) + + # Save run parameters + self.run_params.rtol = rtol + + # Get poles + Fn_pol = self.result.Fn_poles + Sm_pol = self.result.Xi_poles + Ms_pol = self.result.Phi_poles + + # chiamare plot interattivo + SFP = SelFromPlot(algo=self, freqlim=freqlim, plot="pLSCF") + sel_freq = SFP.result[0] + order = SFP.result[1] + + # e poi estrarre risultati + Fn_pLSCF, Xi_pLSCF, Phi_pLSCF, order_out = plscf.pLSCF_mpe( + sel_freq, Fn_pol, Sm_pol, Ms_pol, order, Lab=None, rtol=rtol + ) + + # Save results + self.result.order_out = order_out + self.result.Fn = Fn_pLSCF + self.result.Xi = Xi_pLSCF + self.result.Phi = Phi_pLSCF + + def plot_stab( + self, + freqlim: typing.Optional[tuple[float, float]] = None, + hide_poles: typing.Optional[bool] = True, + ) -> typing.Any: + """ + Plot the Stability Diagram for the pLSCF analysis. + + The stability diagram helps visualize the stability of poles across different model orders. + It can be used to identify stable poles, which correspond to physical modes. + + Parameters + ---------- + freqlim : tuple of float, optional + Frequency limits (min, max) for the stability diagram. If None, limits are determined + automatically. Default is None. + hide_poles : bool, optional + Option to hide the unstable poles in the diagram for clarity. Default is True. + + Returns + ------- + Any + A tuple containing the matplotlib figure and axes objects for the stability diagram. + """ + fig, ax = plot.stab_plot( + Fn=self.result.Fn_poles, + Lab=self.result.Lab, + step=1, + ordmax=self.run_params.ordmax, + ordmin=self.run_params.ordmin, + freqlim=freqlim, + hide_poles=hide_poles, + fig=None, + ax=None, + ) + return fig, ax + + def plot_freqvsdamp( + self, + freqlim: typing.Optional[tuple[float, float]] = None, + hide_poles: typing.Optional[bool] = True, + ) -> typing.Any: + """ + Plot the frequency-damping cluster diagram for the identified modal parameters. + + The cluster diagram visualizes the distribution of identified modal frequencies and their + corresponding damping ratios. It helps identify clusters of stable modes. + + Parameters + ---------- + freqlim : tuple of float, optional + Frequency limits for the plot. If None, limits are determined automatically. Default is None. + hide_poles : bool, optional + Option to hide poles in the plot for clarity. Default is True. + + Returns + ------- + typing.Any + A tuple containing the matplotlib figure and axes of the cluster diagram plot. + """ + if not self.result: + raise ValueError("Run algorithm first") + + fig, ax = plot.cluster_plot( + Fn=self.result.Fn_poles, + Xi=self.result.Xi_poles, + Lab=self.result.Lab, + ordmin=self.run_params.ordmin, + freqlim=freqlim, + hide_poles=hide_poles, + ) + return fig, ax + + +# ============================================================================= +# MULTI SETUP +# ============================================================================= +class pLSCF_MS(pLSCF[pLSCFRunParams, pLSCFResult, typing.Iterable[dict]]): + """ + A multi-setup extension of the pLSCF class for the poly-reference Least Square Complex Frequency + (pLSCF) algorithm. + + + Parameters + ---------- + pLSCF : type + Inherits from the pLSCF class with specified type parameters for pLSCFRunParams, pLSCFResult, and + Iterable[dict]. + + Attributes + ---------- + RunParamCls : pLSCFRunParams + Class attribute for run parameters specific to pLSCF algorithm. + ResultCls : pLSCFResult + Class attribute for results specific to pLSCF algorithm. + """ + + RunParamCls = pLSCFRunParams + ResultCls = pLSCFResult + + def run(self) -> pLSCFResult: + """ + Execute the pLSCF algorithm to perform modal analysis on the provided data. + + This method conducts a frequency domain analysis using the Least Square Complex Frequency method. + It computes system matrices, identifies poles, and labels them based on stability and other criteria. + + Returns + ------- + pLSCFResult + An instance of `pLSCFResult` containing the analysis results, including frequencies, + system matrices, identified poles, and their labels. + """ + Y = self.data + nxseg = self.run_params.nxseg + method = self.run_params.method_SD + pov = self.run_params.pov + # sgn_basf = self.run_params.sgn_basf + # step = self.run_params.step + ordmax = self.run_params.ordmax + ordmin = self.run_params.ordmin + sc = self.run_params.sc + hc = self.run_params.hc + + if method == "per": + sgn_basf = -1 + elif method == "cor": + sgn_basf = +1 + + freq, Sy = fdd.SD_PreGER(Y, self.fs, nxseg=nxseg, method=method, pov=pov) + + Ad, Bn = plscf.pLSCF(Sy, self.dt, ordmax, sgn_basf=sgn_basf) + + Fns, Xis, Phis, Lambds = plscf.pLSCF_poles( + Ad, Bn, self.dt, nxseg=nxseg, methodSy=method + ) + + # Apply HARD CRITERIA + hc_xi_max = hc["xi_max"] + hc_mpc_lim = hc["mpc_lim"] + hc_mpd_lim = hc["mpd_lim"] + + # HC - presence of complex conjugate + # if hc_conj: + Lambds, mask1 = gen.HC_conj(Lambds) + lista = [Fns, Xis, Phis] + Fns, Xis, Phis = gen.applymask(lista, mask1, Phis.shape[2]) + + # HC - damping + Xis, mask2 = gen.HC_damp(Xis, hc_xi_max) + lista = [Fns, Phis] + Fns, Phis = gen.applymask(lista, mask2, Phis.shape[2]) + + # HC - MPC and MPD + if hc_mpc_lim is not None: + mask3 = gen.HC_MPC(Phis, hc_mpc_lim) + lista = [Fns, Xis, Phis, Lambds] + Fns, Xis, Phis, Lambds = gen.applymask(lista, mask3, Phis.shape[2]) + if hc_mpd_lim is not None: + mask4 = gen.HC_MPD(Phis, hc_mpd_lim) + lista = [Fns, Xis, Phis, Lambds] + Fns, Xis, Phis, Lambds = gen.applymask(lista, mask4, Phis.shape[2]) + + # Apply SOFT CRITERIA + # Get the labels of the poles + Lab = gen.SC_apply( + Fns, + Xis, + Phis, + ordmin, + ordmax - 1, + 1, + sc["err_fn"], + sc["err_xi"], + sc["err_phi"], + ) + + # Return results + return self.ResultCls( + freq=freq, + Sy=Sy, + Ad=Ad, + Bn=Bn, + Fn_poles=Fns, + Xi_poles=Xis, + Phi_poles=Phis, + Lab=Lab, + ) diff --git a/src/pyoma2/algorithms/ssi.py b/src/pyoma2/algorithms/ssi.py new file mode 100644 index 0000000..a364c61 --- /dev/null +++ b/src/pyoma2/algorithms/ssi.py @@ -0,0 +1,565 @@ +""" +Stochastic Subspace Identification (SSI) Algorithm Module. +Part of the pyOMA2 package. +Authors: +Dag Pasca +Diego Margoni +""" + +from __future__ import annotations + +import logging +import typing + +from pyoma2.algorithms.data.result import SSIResult +from pyoma2.algorithms.data.run_params import SSIRunParams +from pyoma2.functions import gen, plot, ssi +from pyoma2.support.sel_from_plot import SelFromPlot + +from .base import BaseAlgorithm + +logger = logging.getLogger(__name__) + + +# ============================================================================= +# SINGLE SETUP +# ============================================================================= +# (REF)DATA-DRIVEN STOCHASTIC SUBSPACE IDENTIFICATION +class SSIdat(BaseAlgorithm[SSIRunParams, SSIResult, typing.Iterable[float]]): + """ + Data-Driven Stochastic Subspace Identification (SSI) algorithm for single setup + analysis. + + This class processes measurement data from a single setup experiment to identify + and extract modal parameters using the SSIdat-ref method. + + Attributes + ---------- + RunParamCls : Type[SSIRunParams] + The class of parameters specific to this algorithm's run. + ResultCls : Type[SSIResult] + The class of results produced by this algorithm. + method : str + The method used in this SSI algorithm, set to 'dat' by default. + """ + + RunParamCls = SSIRunParams + ResultCls = SSIResult + method: typing.Literal["dat"] = "dat" + + def run(self) -> SSIResult: + """ + Executes the SSIdat algorithm and returns the results. + + Processes the input data using the Data-Driven Stochastic Subspace Identification method. + Computes state space matrices, modal parameters, and other relevant results. + + Returns + ------- + SSIResult + An object containing the computed matrices and modal parameters. + """ + Y = self.data.T + br = self.run_params.br + method_hank = self.run_params.method or self.method + ordmin = self.run_params.ordmin + ordmax = self.run_params.ordmax + step = self.run_params.step + sc = self.run_params.sc + hc = self.run_params.hc + calc_unc = self.run_params.calc_unc + nb = self.run_params.nb + + if self.run_params.ref_ind is not None: + ref_ind = self.run_params.ref_ind + Yref = Y[ref_ind, :] + else: + Yref = Y + + # Build Hankel matrix + H, T = ssi.build_hank( + Y=Y, Yref=Yref, br=br, method=method_hank, calc_unc=calc_unc, nb=nb + ) + + # Get state matrix and output matrix + Obs, A, C = ssi.SSI_fast(H, br, ordmax, step=step) + + hc_xi_max = hc["xi_max"] + # Get frequency poles (and damping and mode shapes) + Fns, Xis, Phis, Lambds, Fn_std, Xi_std, Phi_std = ssi.SSI_poles( + Obs, + A, + C, + ordmax, + self.dt, + step=step, + calc_unc=calc_unc, + H=H, + T=T, + xi_max=hc_xi_max, + HC=True, + ) + + hc_mpc_lim = hc["mpc_lim"] + hc_mpd_lim = hc["mpd_lim"] + hc_CoV_max = hc["CoV_max"] + + # HC - MPC and MPD + if hc_mpc_lim is not None: + mask3 = gen.HC_MPC(Phis, hc_mpc_lim) + lista = [Fns, Xis, Phis, Lambds, Fn_std, Xi_std, Phi_std] + Fns, Xis, Phis, Lambds, Fn_std, Xi_std, Phi_std = gen.applymask( + lista, mask3, Phis.shape[2] + ) + if hc_mpd_lim is not None: + mask4 = gen.HC_MPD(Phis, hc_mpd_lim) + lista = [Fns, Xis, Phis, Lambds, Fn_std, Xi_std, Phi_std] + Fns, Xis, Phis, Lambds, Fn_std, Xi_std, Phi_std = gen.applymask( + lista, mask4, Phis.shape[2] + ) + + # HC - maximum covariance + if Fn_std is not None and hc_CoV_max is not None: + Fn_std, mask5 = gen.HC_CoV(Fns, Fn_std, hc_CoV_max) + lista = [Fns, Xis, Phis, Lambds, Xi_std, Phi_std] + Fns, Xis, Phis, Lambds, Xi_std, Phi_std = gen.applymask( + lista, mask5, Phis.shape[2] + ) + + # Apply SOFT CRITERIA + # Get the labels of the poles + Lab = gen.SC_apply( + Fns, + Xis, + Phis, + ordmin, + ordmax, + step, + sc["err_fn"], + sc["err_xi"], + sc["err_phi"], + ) + + return SSIResult( + Obs=Obs, + A=A, + C=C, + H=H, + Lambds=Lambds, + Fn_poles=Fns, + Xi_poles=Xis, + Phi_poles=Phis, + Lab=Lab, + Fn_poles_std=Fn_std, + Xi_poles_std=Xi_std, + Phi_poles_std=Phi_std, + ) + + def mpe( + self, + sel_freq: typing.List[float], + order_in: typing.Union[int, str] = "find_min", + rtol: float = 5e-2, + ) -> typing.Any: + """ + Extracts the modal parameters at the selected frequencies. + + Parameters + ---------- + sel_freq : list of float + Selected frequencies for modal parameter extraction. + order : int or str, optional + Model order for extraction, or 'find_min' to auto-determine the minimum stable order. + Default is 'find_min'. + rtol : float, optional + Relative tolerance for comparing frequencies. Default is 5e-2. + + Returns + ------- + typing.Any + The extracted modal parameters. The format and content depend on the algorithm's implementation. + """ + super().mpe(sel_freq=sel_freq, order_in=order_in, rtol=rtol) + + # Save run parameters + self.run_params.sel_freq = sel_freq + self.run_params.order_in = order_in + self.run_params.rtol = rtol + + # Get poles + Fn_pol = self.result.Fn_poles + Xi_pol = self.result.Xi_poles + Phi_pol = self.result.Phi_poles + Lab = self.result.Lab + step = self.run_params.step + + # Get cov + Fn_pol_std = self.result.Fn_poles_std + Xi_pol_std = self.result.Xi_poles_std + Phi_pol_std = self.result.Phi_poles_std + # Extract modal results + Fn, Xi, Phi, order_out, Fn_std, Xi_std, Phi_std = ssi.SSI_mpe( + sel_freq, + Fn_pol, + Xi_pol, + Phi_pol, + order_in, + step, + Lab=Lab, + rtol=rtol, + Fn_std=Fn_pol_std, + Xi_std=Xi_pol_std, + Phi_std=Phi_pol_std, + ) + + # Save results + self.result.order_out = order_out + self.result.Fn = Fn + self.result.Xi = Xi + self.result.Phi = Phi + self.result.Fn_std = Fn_std + self.result.Xi_std = Xi_std + self.result.Phi_std = Phi_std + + def mpe_from_plot( + self, + freqlim: typing.Optional[tuple[float, float]] = None, + rtol: float = 1e-2, + ) -> typing.Any: + """ + Interactive method for extracting modal parameters by selecting frequencies from a plot. + + Parameters + ---------- + freqlim : tuple of float, optional + Frequency limits for the plot. If None, limits are determined automatically. Default is None. + rtol : float, optional + Relative tolerance for comparing frequencies. Default is 1e-2. + + Returns + ------- + typing.Any + The extracted modal parameters after interactive selection. Format depends on algorithm's + implementation. + """ + super().mpe_from_plot(freqlim=freqlim, rtol=rtol) + + # Save run parameters + self.run_params.rtol = rtol + + # Get poles + Fn_pol = self.result.Fn_poles + Xi_pol = self.result.Xi_poles + Phi_pol = self.result.Phi_poles + step = self.run_params.step + + # Get cov + Fn_pol_std = self.result.Fn_poles_std + Xi_pol_std = self.result.Xi_poles_std + Phi_pol_std = self.result.Phi_poles_std + + # call interactive plot + SFP = SelFromPlot(algo=self, freqlim=freqlim, plot="SSI") + sel_freq = SFP.result[0] + order = SFP.result[1] + + # and then extract results + Fn, Xi, Phi, order_out, Fn_std, Xi_std, Phi_std = ssi.SSI_mpe( + sel_freq, + Fn_pol, + Xi_pol, + Phi_pol, + order, + step, + Lab=None, + rtol=rtol, + Fn_std=Fn_pol_std, + Xi_std=Xi_pol_std, + Phi_std=Phi_pol_std, + ) + + # Save results + self.result.order_out = order_out + self.result.Fn = Fn + self.result.Xi = Xi + self.result.Phi = Phi + self.result.Fn_std = Fn_std + self.result.Xi_std = Xi_std + self.result.Phi_std = Phi_std + + def plot_stab( + self, + freqlim: typing.Optional[tuple[float, float]] = None, + hide_poles: typing.Optional[bool] = True, + ) -> typing.Any: + """ + Plot the Stability Diagram for the SSI algorithms. + + The Stability Diagram helps visualize the stability of identified poles across different + model orders, making it easier to separate physical poles from spurious ones. + + Parameters + ---------- + freqlim : tuple of float, optional + Frequency limits for the plot. If None, limits are determined automatically. Default is None. + hide_poles : bool, optional + Option to hide poles in the plot for clarity. Default is True. + + Returns + ------- + typing.Any + A tuple containing the matplotlib figure and axes of the Stability Diagram plot. + """ + if not self.result: + raise ValueError("Run algorithm first") + + fig, ax = plot.stab_plot( + Fn=self.result.Fn_poles, + Lab=self.result.Lab, + step=self.run_params.step, + ordmax=self.run_params.ordmax, + ordmin=self.run_params.ordmin, + freqlim=freqlim, + hide_poles=hide_poles, + fig=None, + ax=None, + Fn_std=self.result.Fn_poles_std, + ) + return fig, ax + + def plot_freqvsdamp( + self, + freqlim: typing.Optional[tuple[float, float]] = None, + hide_poles: typing.Optional[bool] = True, + ) -> typing.Any: + """ + Plot the frequency-damping cluster diagram for the identified modal parameters. + + The cluster diagram visualizes the relationship between frequencies and damping + ratios for the identified poles, helping to identify clusters of physical modes. + + Parameters + ---------- + freqlim : tuple of float, optional + Frequency limits for the plot. If None, limits are determined automatically. Default is None. + hide_poles : bool, optional + Option to hide poles in the plot for clarity. Default is True. + + Returns + ------- + typing.Any + A tuple containing the matplotlib figure and axes of the cluster diagram plot. + """ + if not self.result: + raise ValueError("Run algorithm first") + + fig, ax = plot.cluster_plot( + Fn=self.result.Fn_poles, + Xi=self.result.Xi_poles, + Lab=self.result.Lab, + ordmin=self.run_params.ordmin, + freqlim=freqlim, + hide_poles=hide_poles, + ) + return fig, ax + + def plot_svalH( + self, + iter_n: typing.Optional[int] = None, + ) -> typing.Any: + """ + Plot the singular values of the Hankel matrix for the SSI algorithm. + + This plot is useful for checking the influence of the number of block-rows, br, + on the Singular Values of the Hankel matrix. + + Parameters + ---------- + iter_n : int, optional + The iteration number for which to plot the singular values. If None, the last + iteration is used. Default is None. + + Returns + ------- + typing.Any + A tuple containing the matplotlib figure and axes of the singular value plot. + + Raises + ------ + ValueError + If the algorithm has not been run before plotting. + """ + if not self.result: + raise ValueError("Run algorithm first") + + fig, ax = plot.svalH_plot(H=self.result.H, br=self.run_params.br, iter_n=iter_n) + return fig, ax + + +# ------------------------------------------------------------------------------ +# (REF)COVARIANCE-DRIVEN STOCHASTIC SUBSPACE IDENTIFICATION +# FIXME ADD REFERENCE +class SSIcov(SSIdat): + """ + Implements the Covariance-driven Stochastic Subspace Identification (SSI) algorithm + for single setup experiments. + + This class is an extension of the SSIdat class, adapted for covariance-driven analysis. + It processes measurement data from a single setup to identify system dynamics and extract + modal parameters using the SSIcov-ref method. + + Inherits all attributes and methods from SSIdat. + + Attributes + ---------- + method : str + The method used in this SSI algorithm, overridden to 'cov' or 'cov_R' for + covariance-based analysis. + + Methods + ------- + Inherits all methods from SSIdat with covariance-specific implementations. + """ + + method: typing.Literal["cov_R", "cov"] = "cov" + + +# ============================================================================= +# MULTISETUP +# ============================================================================= +# (REF)DATA-DRIVEN STOCHASTIC SUBSPACE IDENTIFICATION +class SSIdat_MS(SSIdat[SSIRunParams, SSIResult, typing.Iterable[dict]]): + """ + Implements the Data-Driven Stochastic Subspace Identification (SSI) algorithm for multi-setup + experiments. + + This class extends the SSIdat class to handle data from multiple experimental setups, with + moving and reference sensors. + + Inherits all attributes and methods from SSIdat, with focus on multi-setup data handling. + + Attributes + ---------- + Inherits all attributes from SSIdat. + + Methods + ------- + Inherits other methods from SSIdat, applicable to multi-setup scenarios. + """ + + def run(self) -> SSIResult: + """ + Executes the SSI algorithm for multiple setups and returns the results. + + Processes the input data from multiple setups using the Data-Driven Stochastic Subspace + Identification method. It builds Hankel matrices for each setup and computes the state and + output matrices, along with frequency poles. + + Returns + ------- + SSIResult + An object containing the system matrices, poles, damping ratios, and mode shapes across + multiple setups. + """ + + Y = self.data + br = self.run_params.br + method_hank = self.run_params.method or self.method + ordmin = self.run_params.ordmin + ordmax = self.run_params.ordmax + step = self.run_params.step + sc = self.run_params.sc + hc = self.run_params.hc + + # Build Hankel matrix and Get observability matrix, state matrix and output matrix + Obs, A, C = ssi.SSI_multi_setup( + Y, self.fs, br, ordmax, step=1, method_hank=method_hank + ) + + hc_xi_max = hc["xi_max"] + # Get frequency poles (and damping and mode shapes) + Fns, Xis, Phis, Lambds, Fn_std, Xi_std, Phi_std = ssi.SSI_poles( + Obs, + A, + C, + ordmax, + self.dt, + step=step, + calc_unc=False, + HC=True, + xi_max=hc_xi_max, + ) + + # VALIDATION CRITERIA FOR POLES + hc_mpc_lim = hc["mpc_lim"] + hc_mpd_lim = hc["mpd_lim"] + # hc_CoV_max = hc["CoV_max"] + + # HC - MPC and MPD + if hc_mpc_lim is not None: + mask3 = gen.HC_MPC(Phis, hc_mpc_lim) + lista = [Fns, Xis, Phis, Lambds, Fn_std, Xi_std, Phi_std] + Fns, Xis, Phis, Lambds, Fn_std, Xi_std, Phi_std = gen.applymask( + lista, mask3, Phis.shape[2] + ) + if hc_mpd_lim is not None: + mask4 = gen.HC_MPD(Phis, hc_mpd_lim) + lista = [Fns, Xis, Phis, Lambds, Fn_std, Xi_std, Phi_std] + Fns, Xis, Phis, Lambds, Fn_std, Xi_std, Phi_std = gen.applymask( + lista, mask4, Phis.shape[2] + ) + + # Apply SOFT CRITERIA + # Get the labels of the poles + Lab = gen.SC_apply( + Fns, + Xis, + Phis, + ordmin, + ordmax, + step, + sc["err_fn"], + sc["err_xi"], + sc["err_phi"], + ) + + # Return results + return SSIResult( + Obs=Obs, + A=A, + C=C, + H=None, + Lambds=Lambds, + Fn_poles=Fns, + Xi_poles=Xis, + Phi_poles=Phis, + Lab=Lab, + Fn_poles_std=Fn_std, + Xi_poles_std=Xi_std, + Phi_poles_std=Phi_std, + ) + + +# ------------------------------------------------------------------------------ +# (REF)COVARIANCE-DRIVEN STOCHASTIC SUBSPACE IDENTIFICATION +class SSIcov_MS(SSIdat_MS): + """ + Implements the Covariance-Driven Stochastic Subspace Identification (SSI) algorithm + for multi-setup experiments. + + This class extends SSIdat_MS, focusing on the covariance-driven approach to SSI + for multiple experimental setups. + + Inherits all attributes and methods from SSIdat_MS, adapted for covariance-driven + analysis methods. + + Attributes + ---------- + Inherits all attributes from SSIdat_MS. + + Methods + ------- + Inherits all methods from SSIdat_MS, adapted for covariance-based analysis. + """ + + method: typing.Literal["cov_R", "cov"] = "cov" diff --git a/src/pyoma2/functions/__init__.py b/src/pyoma2/functions/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/pyoma2/functions/fdd.py b/src/pyoma2/functions/fdd.py new file mode 100644 index 0000000..73078b3 --- /dev/null +++ b/src/pyoma2/functions/fdd.py @@ -0,0 +1,595 @@ +""" +Frequency Domain Decomposition (FDD) Utility Functions module. +Part of the pyOMA2 package. +Author: +Dag Pasca +""" + +import logging +import typing + +import numpy as np +from scipy import signal +from scipy.optimize import curve_fit +from tqdm import tqdm, trange + +from .gen import MAC + +logger = logging.getLogger(__name__) + +# ============================================================================= +# FUNZIONI FDD +# ============================================================================= + + +def SD_PreGER( + Y: typing.List[typing.Dict[str, np.ndarray]], + fs: float, + nxseg: int = 1024, + pov: float = 0.5, + method: typing.Literal["per", "cor"] = "per", +): + """ + Estimate the PSD matrix for a multi-setup experiment using either the correlogram + method or the periodogram method. + + Parameters + ---------- + Y : list of dicts + A list where each element corresponds to a different setup. Each element is a + dictionary with keys 'ref' and 'mov' for reference and moving sensor data, + respectively. Each should be a numpy array with dimensions [N x M], where N is the + number of sensors and M is the number of data points. + fs : float + Sampling frequency of the data. + nxseg : int, optional + Number of data points in each segment for spectral analysis. Default is 1024. + pov : float, optional + Proportion of overlap between segments in spectral analysis. Default is 0.5. + method : str, optional + Method for spectral density estimation. 'per' for periodogram and 'cor' for + correlogram method. Default is 'per'. + + Returns + ------- + tuple + freq : ndarray + Array of frequency values at which the spectral densities are evaluated. + Sy : ndarray + The scaled spectral density matrices. The shape of the array is [N x N x K], + where N is the total number of sensors (reference + moving) and K is the number + of frequency points. + + Note + ----- + The function uses an internal function 'SD_Est' to estimate the spectral densities. + The logger is used for debugging purposes to track the progress of analysis. + """ + dt = 1 / fs + n_setup = len(Y) # number of setup + n_ref = Y[0]["ref"].shape[0] # number of reference sensor + # n_mov = [Y[i]["mov"].shape[0] for i in range(n_setup)] # number of moving sensor + # n_DOF = n_ref+np.sum(n_mov) # total number of sensors + Gyy = [] + for ii in trange(n_setup): + logger.debug("Analyising setup nr.: %s...", ii) + + Y_ref = Y[ii]["ref"] + Y_mov = Y[ii]["mov"] + # Ndat = Y[ii]["ref"].shape[1] # number of data points + Y_all = np.vstack((Y[ii]["ref"], Y[ii]["mov"])) + # r = Y_all.shape[0] # total sensor for the ii setup + + if method == "per": + # noverlap = nxseg*pov + freq, Sy_allref = SD_est(Y_all, Y_ref, dt, nxseg, method) + _, Sy_allmov = SD_est(Y_all, Y_mov, dt, nxseg, method) + Gyy.append(np.hstack((Sy_allref, Sy_allmov))) + + elif method == "cor": + freq, Sy_allref = SD_est(Y_all, Y_ref, dt, nxseg, method) + _, Sy_allmov = SD_est(Y_all, Y_mov, dt, nxseg, method) + Gyy.append(np.hstack((Sy_allref, Sy_allmov))) + logger.debug("... Done with setup nr.: %s!", ii) + + Gy_refref = ( + 1 / n_setup * np.sum([Gyy[ii][:n_ref, :n_ref] for ii in range(n_setup)], axis=0) + ) + + Gg = [] + # Scale spectrum to reference spectrum + for ff in range(len(freq)): + G1 = [ + np.dot( + np.dot( + Gyy[ii][n_ref:, :n_ref][:, :, ff], + np.linalg.inv(Gyy[ii][:n_ref, :n_ref][:, :, ff]), + ), + Gy_refref[:, :, ff], + ) + for ii in range(n_setup) + ] + G2 = np.vstack(G1) + G3 = np.vstack([Gy_refref[:, :, ff], G2]) + Gg.append(G3) + + Sy = np.array(Gg) + Sy = np.moveaxis(Sy, 0, 2) + return freq, Sy + + +# ----------------------------------------------------------------------------- + + +def SD_est( + Yall, + Yref, + dt, + nxseg=1024, + method="cor", + pov=0.5, +): + """ + Estimate the Cross-Spectral Density (CSD) using either the correlogram method or the + periodogram method. + + Parameters + ---------- + Yall : ndarray + Input signal data. + Yref : ndarray + Reference signal data. + dt : float + Sampling interval. + nxseg : int, optional + Length of each segment for CSD estimation. Default is 1024. + method : str, optional + Method for CSD estimation, either "cor" for correlogram method or "per" for + periodogram. Default is "cor". + pov : float, optional + Proportion of overlap for the periodogram method. Default is 0.5. + + Returns + ------- + tuple + freq : ndarray + Array of frequencies. + Sy : ndarray + Cross-Spectral Density (CSD) estimation. + """ + if method == "cor": + Ndat = Yref.shape[1] # number of data points + n_ref = Yref.shape[0] + n_all = Yall.shape[0] + # Calculating Auto e Cross-Spectral Density (Y_all, Y_ref) + _, Pxy = signal.csd( + Yall.reshape(n_all, 1, Ndat), + Yref.reshape(1, n_ref, Ndat), + nperseg=nxseg // 2, + nfft=nxseg, + noverlap=0, + window="boxcar", + ) + Rxy = np.fft.irfft(Pxy) + + tau = -Rxy.shape[2] / np.log(0.01) + win = signal.windows.exponential(Rxy.shape[2], center=0, tau=tau, sym=False) + Rxy *= win + Sy = np.fft.rfft(Rxy) + freq = np.arange(0, Sy.shape[2]) * (1 / dt / (nxseg)) # Frequency vector + + elif method == "per": + noverlap = nxseg * pov + Ndat = Yref.shape[1] + n_ref = Yref.shape[0] + n_all = Yall.shape[0] + # Calculating Auto e Cross-Spectral Density (Y_all, Y_ref) + freq, Sy = signal.csd( + Yall.reshape(n_all, 1, Ndat), + Yref.reshape(1, n_ref, Ndat), + fs=1 / dt, + nperseg=nxseg, + noverlap=noverlap, + window="hann", + ) + return freq, Sy + + +# ----------------------------------------------------------------------------- + + +def SD_svalsvec(SD): + """ + Compute the singular values and singular vectors for a given set of Cross-Spectral + Density (CSD) matrices. + + Parameters + ---------- + SD : ndarray + Array of Cross-Spectral Density (CSD) matrices, with shape + (number_of_rows, number_of_columns, number_of_frequencies). + + Returns + ------- + tuple + S_val : ndarray + Singular values. + S_vec : ndarray + Singular vectors. + """ + nr, nc, nf = SD.shape + Sval = np.zeros((nf, nc)) + S_val = np.empty((nf, nc, nc)) + S_vec = np.empty((nf, nr, nr), dtype=complex) + for k in range(nf): + U1, S, _ = np.linalg.svd(SD[:, :, k]) + U1_1 = U1.conj().T + Sval[k, :] = np.sqrt(S) + S_val[k, :, :] = np.diag(np.sqrt(S)) + S_vec[k, :, :] = U1_1 + S_val = np.moveaxis(S_val, 0, 2) + S_vec = np.moveaxis(S_vec, 0, 2) + return S_val, S_vec + + +# ----------------------------------------------------------------------------- + + +def FDD_mpe( + Sval, + Svec, + freq, + sel_freq, + DF=0.1, + ): + """ + Extracts modal parameters using the Frequency Domain Decomposition (FDD) method. + + Parameters + ---------- + Sval : ndarray + A 3D array of singular values. Dimensions are [Nch, Nref, Nf], where Nch is the + number of channels, Nref is the number of reference channels, and Nf is the + number of frequency points. + Svec : ndarray + A 3D array of singular vectors corresponding to Sval. Dimensions are the same as Sval. + freq : ndarray + 1D array of frequency values corresponding to the singular values and vectors. + sel_freq : list or ndarray + Selected frequencies around which modal parameters are to be extracted. + DF : float, optional + Frequency bandwidth around each selected frequency within which the function + searches for a peak. Default is 0.1. + + Returns + ------- + tuple + Fn : ndarray + Extracted modal frequencies. + Phi : ndarray + Corresponding normalized mode shapes (each column corresponds to a mode shape). + + Note + ----- + The function assumes that the first singular value and vector correspond to the dominant + mode at each frequency point. + """ + # Sval, Svec = SD_svalsvec(Sy) + Nch, Nref, Nf = Sval.shape + + Freq = [] + Fi = [] + index = [] + maxSy_diff = [] + logger.info("Extracting FDD modal parameters") + if Nref == 1: + logging.warning("Only 1 reference channel is used - Peak-searching is disabled") + for sel_fn in tqdm(sel_freq): + if Nref > 1: # peak serching is not available for single ref. ch. + # Frequency bandwidth where the peak is searched + lim = (sel_fn - DF, sel_fn + DF) + idxlim = ( + np.argmin(np.abs(freq - lim[0])), + np.argmin(np.abs(freq - lim[1])), + ) # Indices of the limits + # Ratios between the first and second singular value + diffS1S2 = Sval[0, 0, idxlim[0] : idxlim[1]] / Sval[1, 1, idxlim[0] : idxlim[1]] + maxDiffS1S2 = np.max(diffS1S2) # Looking for the maximum difference + idx1 = np.argmin(np.abs(diffS1S2 - maxDiffS1S2)) # Index of the max diff + idxfin = idxlim[0] + idx1 # Final index + maxSy_diff.append(maxDiffS1S2) + else: + idxfin = np.argmin(np.abs(freq - sel_fn)) + # Modal properties + fn_FDD = freq[idxfin] # Frequency + phi_FDD = Svec[0, :, idxfin] # Mode shape + # Normalized (unity displacement) + phi_FDDn = phi_FDD / phi_FDD[np.argmax(np.abs(phi_FDD))] + + Freq.append(fn_FDD) + Fi.append(phi_FDDn) + index.append(idxfin) + logger.debug("Done!") + + Fn = np.array(Freq) + Phi = np.array(Fi).T + index = np.array(index) + return Fn, Phi + + + +# ----------------------------------------------------------------------------- +# COMMENT +# Utility function (Hidden for users?) +def SDOF_bellandMS(Sy, dt, sel_fn, phi_FDD, method="FSDD", cm=1, MAClim=0.85, DF=1.0): + """ + Computes the SDOF bell and mode shapes for a specified frequency range using FSDD or + EFDD methods. + + Parameters + ---------- + Sy : ndarray + Spectral matrix of the system. Expected dimensions are [Nch, Nch, Nf], where Nch is + the number of channels and Nf is the number of frequency points. + dt : float + Time interval of the data sampling. + sel_fn : float + Selected modal frequency around which the SDOF analysis is to be performed. + phi_FDD : ndarray + Mode shape corresponding to the selected modal frequency. + method : str, optional + Method for SDOF analysis. Supports 'FSDD' for Frequency Spatial Domain Decomposition + and 'EFDD' for Enhanced Frequency Domain Decomposition. Default is 'FSDD'. + cm : int, optional + Number of close modes to consider in the analysis. Default is 1. + MAClim : float, optional + Threshold for the Modal Assurance Criterion (MAC) to filter modes. Default is 0.85. + DF : float, optional + Frequency bandwidth around the selected frequency for analysis. Default is 1.0. + + Returns + ------- + tuple + SDOFbell1 : ndarray + The SDOF bell (power spectral density) of the selected mode. + SDOFms1 : ndarray + The mode shapes corresponding to the SDOF bell. + """ + + Sval, Svec = SD_svalsvec(Sy) + Nch = phi_FDD.shape[0] + nxseg = Sval.shape[2] + freq = np.arange(0, nxseg) * (1 / dt / (2 * nxseg)) + # Frequency bandwidth where the peak is searched + lim = (sel_fn - DF, sel_fn + DF) + idxlim = ( + np.argmin(np.abs(freq - lim[0])), + np.argmin(np.abs(freq - lim[1])), + ) # Indices of the limits + # Initialise SDOF bell and Mode Shape + SDOFbell = np.zeros(len(np.arange(idxlim[0], idxlim[1])), dtype=complex) + SDOFms = np.zeros((len(np.arange(idxlim[0], idxlim[1])), Nch), dtype=complex) + + for csm in range(cm): # Loop through close mode (if any, default 1) + # Frequency Spatial Domain Decomposition variation (defaulf) + if method == "FSDD": + # Save values that satisfy MAC > MAClim condition + SDOFbell += np.array( + [ + np.dot( + np.dot(phi_FDD.conj().T, Sy[:, :, el]), phi_FDD + ) # Enhanced PSD matrix (frequency filtered) + if MAC(phi_FDD, Svec[csm, :, el]) > MAClim + else 0 + for el in range(int(idxlim[0]), int(idxlim[1])) + ] + ) + # Do the same for mode shapes + SDOFms += np.array( + [ + Svec[csm, :, el] + if MAC(phi_FDD, Svec[csm, :, el]) > MAClim + else np.zeros(Nch) + for el in range(int(idxlim[0]), int(idxlim[1])) + ] + ) + elif method == "EFDD": + SDOFbell += np.array( + [ + Sval[csm, csm, l_] if MAC(phi_FDD, Svec[csm, :, l_]) > MAClim else 0 + for l_ in range(int(idxlim[0]), int(idxlim[1])) + ] + ) + SDOFms += np.array( + [ + Svec[csm, :, l_] + if MAC(phi_FDD, Svec[csm, :, l_]) > MAClim + else np.zeros(Nch) + for l_ in range(int(idxlim[0]), int(idxlim[1])) + ] + ) + + SDOFbell1 = np.zeros((nxseg), dtype=complex) + SDOFms1 = np.zeros((nxseg, Nch), dtype=complex) + SDOFbell1[idxlim[0] : idxlim[1]] = SDOFbell + SDOFms1[idxlim[0] : idxlim[1], :] = SDOFms + return SDOFbell1, SDOFms1 + + +# ----------------------------------------------------------------------------- + + +def EFDD_mpe( + Sy: np.ndarray, + freq: np.ndarray, + dt: float, + sel_freq: list, + methodSy: str, + method: str = "FSDD", + DF1: float = 0.1, + DF2: float = 1.0, + cm: int = 1, + MAClim: float = 0.85, + sppk: int = 3, + npmax: int = 20, +) -> typing.Tuple[np.ndarray, np.ndarray, np.ndarray, typing.List]: + """ + Extracts modal parameters using the Enhanced Frequency Domain Decomposition (EFDD) and + the Frequency Spatial Domain Decomposition (FSDD) algorithms. + + Parameters + ---------- + Sy : ndarray + Spectral matrix with dimensions [Nch, Nch, Nf] where Nch is the number of channels + and Nf is the number of frequency points. + freq : ndarray + Array of frequency values corresponding to the spectral matrix. + dt : float + Sampling interval of the data. + sel_freq : list or ndarray + Selected modal frequencies around which parameters are to be estimated. + methodSy : str + Method used for spectral density estimation ('cor' for correlation or 'per' + for periodogram). + method : str, optional + Specifies the method for SDOF analysis ('FSDD' or 'EFDD'). Default is 'FSDD'. + DF1 : float, optional + Frequency bandwidth for initial FDD modal parameter extraction. Default is 0.1. + DF2 : float, optional + Frequency bandwidth for SDOF analysis. Default is 1.0. + cm : int, optional + Number of close modes to consider. Default is 1. + MAClim : float, optional + Threshold for the Modal Assurance Criterion (MAC) to filter modes. Default is 0.85. + sppk : int, optional + Number of initial peaks to skip in autocorrelation analysis. Default is 3. + npmax : int, optional + Maximum number of peaks to consider in the curve fitting for damping ratio + estimation. Default is 20. + + Returns + ------- + tuple + Fn : ndarray + Estimated natural frequencies. + Xi : ndarray + Estimated damping ratios. + Phi : ndarray + Corresponding mode shapes. + PerPlot : list + Additional data for plotting and analysis, including frequency response, time, + SDOF bell, singular values, indices of singular values, normalized + autocorrelation, indices of peaks, damping ratio fit parameters, and delta values. + """ + Sval, Svec = SD_svalsvec(Sy) + + Nch, Nref, nxseg = Sval.shape + # number of points for the inverse transform (zeropadding) + nIFFT = (int(nxseg)) * 5 + Freq_FDD, Phi_FDD = FDD_mpe(Sval, Svec, freq, sel_freq, DF=DF1) + + # Initialize Results + PerPlot = [] + Fn_E = [] + Phi_E = [] + Xi_E = [] + + logger.info("Extracting EFDD modal parameters") + for n in trange(len(sel_freq)): # looping through all frequencies to estimate + phi_FDD = Phi_FDD[:, n] # Select reference mode shape (from FDD) + sel_fn = sel_freq[n] + SDOFbell, SDOFms = SDOF_bellandMS( + Sy, dt, sel_fn, phi_FDD, method=method, cm=cm, MAClim=MAClim, DF=DF2 + ) + + # indices of the singular values in SDOFsval + idSV = np.array(np.where(SDOFbell)).T + # Autocorrelation function (Free Decay) + SDOFcorr1 = np.fft.ifft(SDOFbell, n=nIFFT, axis=0, norm="ortho").real + df = 1 / dt / nxseg + tlag = 1 / df # time lag + time = np.linspace(0, tlag, len(SDOFcorr1) // 2) # t + + # NORMALISED AUTOCORRELATION + normSDOFcorr = SDOFcorr1[: len(SDOFcorr1) // 2] / SDOFcorr1[np.argmax(SDOFcorr1)] + + # finding where x = 0 + sgn = np.sign(normSDOFcorr).real # finding the sign + # finding where the sign changes (crossing x) + sgn1 = np.diff(sgn, axis=0) + zc1 = np.where(sgn1)[0] # Zero crossing indices + + # finding maximums and minimums (peaks) of the autoccorelation + maxSDOFcorr = [ + np.max(normSDOFcorr[zc1[_i] : zc1[_i + 2]]) + for _i in range(0, len(zc1) - 2, 2) + ] + minSDOFcorr = [ + np.min(normSDOFcorr[zc1[_i] : zc1[_i + 2]]) + for _i in range(0, len(zc1) - 2, 2) + ] + if len(maxSDOFcorr) > len(minSDOFcorr): + maxSDOFcorr = maxSDOFcorr[:-1] + elif len(maxSDOFcorr) < len(minSDOFcorr): + minSDOFcorr = minSDOFcorr[:-1] + + minmax = np.array((minSDOFcorr, maxSDOFcorr)) + minmax = np.ravel(minmax, order="F") + + # finding the indices of the peaks + maxSDOFcorr_idx = [np.argmin(abs(normSDOFcorr - maxx)) for maxx in maxSDOFcorr] + minSDOFcorr_idx = [np.argmin(abs(normSDOFcorr - minn)) for minn in minSDOFcorr] + minmax_idx = np.array((minSDOFcorr_idx, maxSDOFcorr_idx)) + minmax_idx = np.ravel(minmax_idx, order="F") + + # Peacks and indices of the peaks to be used in the fitting + minmax_fit = np.array([minmax[_a] for _a in range(sppk, sppk + npmax)]) + minmax_fit_idx = np.array([minmax_idx[_a] for _a in range(sppk, sppk + npmax)]) + + # estimating the natural frequency from the distance between the peaks + # *2 because we use both max and min + Td = np.diff(time[minmax_fit_idx]) * 2 + Td_EFDD = np.mean(Td) + + fd_EFDD = 1 / Td_EFDD # damped natural frequency + + # Log decrement + delta = np.array( + [ + 1 * np.log(np.abs(minmax[0]) / np.abs(minmax[ii])) + for ii in range(len(minmax_fit)) + ] + ) + + # Fit + def _fit(x, m): + return m * x + + lam, _ = curve_fit(_fit, np.arange(len(minmax_fit)), delta) + + # damping ratio + if methodSy == "cor": # correct for exponential window + tau = -(nxseg - 1) / np.log(0.01) + lam = 2 * lam - 1 / tau # lam*2 because we use both max and min + elif methodSy == "per": + lam = 2 * lam # lam*2 because we use both max and min + + xi_EFDD = lam / np.sqrt(4 * np.pi**2 + lam**2) + + fn_EFDD = fd_EFDD / np.sqrt(1 - xi_EFDD**2) + + # Finally appending the results + Fn_E.append(fn_EFDD) + Xi_E.append(xi_EFDD) + Phi_E.append(phi_FDD) + + PerPlot.append( + [freq, time, SDOFbell, Sval, idSV, normSDOFcorr, minmax_fit_idx, lam, delta] + ) + logger.debug("Done!") + + Fn = np.array(Fn_E) + Xi = np.array(Xi_E) + Phi = np.array(Phi_E).T + + return Fn, Xi, Phi, PerPlot diff --git a/src/pyoma2/functions/gen.py b/src/pyoma2/functions/gen.py new file mode 100644 index 0000000..f71a93b --- /dev/null +++ b/src/pyoma2/functions/gen.py @@ -0,0 +1,1539 @@ +# -*- coding: utf-8 -*- +""" +General Utility Functions module. +Part of the pyOMA2 package. +Author: +Dag Pasca +""" + +import logging +import pickle +import typing + +import numpy as np +import pandas as pd +from scipy import linalg, signal + +logger = logging.getLogger(__name__) + + +# ============================================================================= +# FUNZIONI GENERALI +# ============================================================================= +def applymask(list_arr, mask, len_phi) -> typing.List[np.ndarray]: + """ + Apply a mask to a list of arrays, filtering their values based on the mask. + + Parameters + ---------- + list_arr : list of np.ndarray + List of arrays to be filtered. Arrays can be 2D or 3D. + mask : np.ndarray + 2D boolean array indicating which values to keep (True) or set to NaN (False). + len_phi : int + The length of the mode shape dimension for expanding the mask to 3D. + + Returns + ------- + list of np.ndarray + List of filtered arrays with the same shapes as the input arrays. + + Notes + ----- + - If an array in `list_arr` is 3D, the mask is expanded to 3D and applied. + - If an array in `list_arr` is 2D, the original mask is applied directly. + - Values not matching the mask are set to NaN. + """ + # Expand the mask to 3D by adding a new axis (for mode shape) + expandedmask1 = np.expand_dims(mask, axis=-1) + # Repeat the mask along the new dimension + expandedmask1 = np.repeat(expandedmask1, len_phi, axis=-1) + list_filt_arr = [] + for arr in list_arr: + if arr is None: + list_filt_arr.append(None) + elif arr.ndim == 3: + list_filt_arr.append(np.where(expandedmask1, arr, np.nan)) + elif arr.ndim == 2: + list_filt_arr.append(np.where(mask, arr, np.nan)) + return list_filt_arr + + +# ----------------------------------------------------------------------------- + + +def HC_conj(lambd) -> typing.Tuple[np.ndarray, np.ndarray]: + """ + Apply Hard validation Criteria (HC), retaining only those elements which have their conjugates also present in the array. + + Parameters + ---------- + lambd : np.ndarray + Array of complex numbers. + + Returns + ------- + filt_lambd : np.ndarray + Array of the same shape as `lambd` with only elements that have their conjugates also present. + Other elements are set to NaN. + mask : np.ndarray + Boolean array of the same shape as `lambd`, where True indicates that the element and its conjugate are both present. + """ + # Create a set to store elements and their conjugates + element_set = set(lambd.flatten()) + + # Create a mask to identify elements to keep + mask = np.zeros(lambd.shape, dtype=bool) + + for i in range(lambd.shape[0]): + for j in range(lambd.shape[1]): + element = lambd[i, j] + conjugate = np.conj(element) + # Check if both element and its conjugate are in the set + if element in element_set and conjugate in element_set: + mask[i, j] = True + + # Create an output array filled with NaNs + filt_lambd = np.full(lambd.shape, np.nan, dtype=lambd.dtype) + + # Copy elements that satisfy the condition to the output array + filt_lambd[mask] = lambd[mask] + + return filt_lambd, mask + + +# ----------------------------------------------------------------------------- + + +def HC_damp(damp, max_damp) -> typing.Tuple[np.ndarray, np.ndarray]: + """ + Apply Hard validation Criteria (HC), retaining only those elements which are positive and less than a specified maximum (damping). + + Parameters + ---------- + damp : np.ndarray + Array of damping ratios. + max_damp : float + Maximum allowed damping ratio. + + Returns + ------- + filt_damp : np.ndarray + Array of the same shape as `damp` with elements that do not satisfy the condition set to NaN. + mask : np.ndarray + Boolean array of the same shape as `damp`, where True indicates that the element is positive and less than `max_damp`. + + """ + mask = np.logical_and(damp < max_damp, damp > 0).astype(int) + filt_damp = damp * mask + filt_damp[filt_damp == 0] = np.nan + # should be the same as + # filt_damp = np.where(damp, np.logical_and(damp < max_damp, damp > 0), damp, np.nan) + return filt_damp, mask + + +# ----------------------------------------------------------------------------- + + +def HC_MPC(phi, mpc_lim) -> np.ndarray: + """ + Apply Hard validation Criteria (HC), based on modal phase collinearity (MPC) limit. + + Parameters + ---------- + phi : np.ndarray + Array of mode shapes with shape (number of modes, number of channels, mode shape length). + mpc_lim : float + Minimum allowed value for modal phase collinearity. + + Returns + ------- + mask_mpc : np.ndarray + Boolean array indicating elements that satisfy the MPC condition. + """ + mask2 = [] + for o in range(phi.shape[0]): + for i in range(phi.shape[1]): + try: + mask2.append((MPC(phi[o, i, :]) >= mpc_lim).astype(int)) + except Exception: + mask2.append(0) + mask2 = np.array(mask2).reshape((phi.shape[0], phi.shape[1])) + mask3 = np.expand_dims(mask2, axis=-1) + mask3 = np.repeat(mask3, phi.shape[2], axis=-1) + return mask3[:, :, 0] + + +# ----------------------------------------------------------------------------- + + +def HC_MPD(phi, mpd_lim) -> np.ndarray: + """ + Apply Hard validation Criteria (HC), based on modal phase deviation (MPD) limit. + + Parameters + ---------- + phi : np.ndarray + Array of mode shapes with shape (number of modes, number of channels, mode shape length). + mpd_lim : float + Maximum allowed value for modal phase deviation. + + Returns + ------- + mask_mpd : np.ndarray + Boolean array indicating elements that satisfy the MPD condition. + + """ + mask = [] + for o in range(phi.shape[0]): + for i in range(phi.shape[1]): + try: + mask.append((MPD(phi[o, i, :]) <= mpd_lim).astype(int)) + except Exception: + mask.append(0) + mask = np.array(mask).reshape((phi.shape[0], phi.shape[1])) + mask1 = np.expand_dims(mask, axis=-1) + mask1 = np.repeat(mask1, phi.shape[2], axis=-1) + return mask1[:, :, 0] + + +# ----------------------------------------------------------------------------- + + +def HC_CoV(Fn, Fn_std, CoV_max) -> typing.Tuple[np.ndarray, np.ndarray]: + """ + Apply Hard validation Criteria (HC), retaining only those elements which have a + Coefficient of Variation (CoV) less than a specified maximum. + + Parameters + ---------- + Fn : np.ndarray + Array of frequencies. + Fn_std : np.ndarray + Array of frequency covariances (standard deviation). + CoV_max : float + Maximum allowed Coefficient of Variation (standard deviation/mean value). + + Returns + ------- + filt_cov : np.ndarray + Array of the same shape as `Fn_std` with elements that do not satisfy the condition set to NaN. + mask : np.ndarray + Boolean array of the same shape as `Fn_std`, where True indicates that the element is less than `max_cov`. + + """ + mask = (Fn_std < CoV_max * Fn).astype(int) + filt_std = Fn_std * mask + filt_std[filt_std == 0] = np.nan + # should be the same as + # filt_damp = np.where(damp, np.logical_and(damp < max_damp, damp > 0), damp, np.nan) + return filt_std, mask + + +# ----------------------------------------------------------------------------- + + +def SC_apply(Fn, Xi, Phi, ordmin, ordmax, step, err_fn, err_xi, err_phi) -> np.ndarray: + """ + Apply Soft validation Criteria (SC) to determine the stability of modal parameters between consecutive orders. + + Parameters + ---------- + Fn : np.ndarray + Array of natural frequencies. + Xi : np.ndarray + Array of damping ratios. + Phi : np.ndarray + Array of mode shapes. + ordmin : int + Minimum model order. + ordmax : int + Maximum model order. + step : int + Step size for increasing model order. + err_fn : float + Tolerance for the natural frequency error. + err_xi : float + Tolerance for the damping ratio error. + err_phi : float + Tolerance for the mode shape error. + + Returns + ------- + Lab : np.ndarray + Array of labels indicating stability (1 for stable, 0 for unstable). + """ + # inirialise labels + Lab = np.zeros(Fn.shape, dtype="int") + + # SOFT CONDITIONS + # STABILITY BETWEEN CONSECUTIVE ORDERS + for oo in range(ordmin, ordmax + 1, step): + o = int(oo / step - 1) + + f_n = Fn[:, o].reshape(-1, 1) + xi_n = Xi[:, o].reshape(-1, 1) + phi_n = Phi[:, o, :] + + f_n1 = Fn[:, o - 1].reshape(-1, 1) + xi_n1 = Xi[:, o - 1].reshape(-1, 1) + phi_n1 = Phi[:, o - 1, :] + + # Skip the first order as it has no previous order to compare with + if o == 0: + continue + + for i in range(len(f_n)): + try: + idx = np.nanargmin(np.abs(f_n1 - f_n[i])) + + cond1 = np.abs(f_n[i] - f_n1[idx]) / f_n[i] + cond2 = np.abs(xi_n[i] - xi_n1[idx]) / xi_n[i] + cond3 = 1 - MAC(phi_n[i, :], phi_n1[idx, :]) + if cond1 < err_fn and cond2 < err_xi and cond3 < err_phi: + Lab[i, o] = 1 # Stable + else: + Lab[i, o] = 0 # Nuovo polo o polo instabile + except Exception as e: + # If f_n[i] is nan, do nothin, n.b. the lab stays 0 + logger.debug(e) + return Lab + + +# ----------------------------------------------------------------------------- + + +def dfphi_map_func(phi, sens_names, sens_map, cstrn=None) -> pd.DataFrame: + """ + Maps mode shapes to sensor locations and constraints, creating a dataframe. + + Parameters + ---------- + phi : np.ndarray + Array of mode shapes. + sens_names : list + List of sensor names corresponding to the mode shapes. + sens_map : pd.DataFrame + DataFrame containing the sensor mappings. + cstrn : pd.DataFrame, optional + DataFrame containing constraints, by default None. + + Returns + ------- + pd.DataFrame + DataFrame with mode shapes mapped to sensor points. + """ + # create mode shape dataframe + df_phi = pd.DataFrame( + {"sName": sens_names, "Phi": phi}, + ) + + # APPLY POINTS TO SENSOR MAPPING + # check for costraints + if cstrn is not None: + cstr = cstrn.to_numpy(na_value=0)[:, :] + val = cstr @ phi + ctn_df = pd.DataFrame( + {"cName": cstrn.index, "val": val}, + ) + # apply sensor mapping + mapping_sens = dict(zip(df_phi["sName"], df_phi["Phi"])) + # apply costraints mapping + mapping_cstrn = dict(zip(ctn_df["cName"], ctn_df["val"])) + mapping = dict(mapping_sens, **mapping_cstrn) + # else apply only sensor mapping + else: + mapping = dict(zip(df_phi["sName"], df_phi["Phi"])) + + # mode shape mapped to points + df_phi_map = sens_map.replace(mapping).astype(float) + return df_phi_map + + +# ----------------------------------------------------------------------------- + + +def check_on_geo1( + file_dict, ref_ind=None +) -> typing.Tuple[ + typing.List[str], + pd.DataFrame, + np.ndarray, + np.ndarray, + np.ndarray, + np.ndarray, + np.ndarray, +]: + """ + Validates and processes sensor and background geometry data from a dictionary of dataframes. + + Parameters + ---------- + file_dict : dict + Dictionary containing dataframes of sensor and background geometry data. + ref_ind : list, optional + List of reference indices for sensor names, by default None. + + Returns + ------- + tuple + A tuple containing: + - sens_names (list): List of sensor names. + - sens_coord (pd.DataFrame): DataFrame of sensor coordinates. + - sens_dir (np.ndarray): Array of sensor directions. + - sens_lines (np.ndarray or None): Array of sensor lines. + - BG_nodes (np.ndarray or None): Array of background nodes. + - BG_lines (np.ndarray or None): Array of background lines. + - BG_surf (np.ndarray or None): Array of background surfaces. + + Raises + ------ + ValueError + If required sheets are missing or invalid. + If shapes of 'sensors coordinates' and 'sensors directions' do not match. + If 'sensors coordinates' or 'BG nodes' does not have 3 columns. + If 'BG lines' does not have 2 columns. + If 'BG surfaces' does not have 3 columns. + If sensor names are not present in the index of 'sensors coordinates'. + """ + + # Remove INFO sheet from dict of dataframes + if "INFO" in file_dict: + del file_dict["INFO"] + + # ----------------------------------------------------------------------------- + required_sheets = ["sensors names", "sensors coordinates", "sensors directions"] + all_sheets = required_sheets + [ + "sensors lines", + "BG nodes", + "BG lines", + "BG surfaces", + ] + + # Ensure required sheets exist + if not all(sheet in file_dict for sheet in required_sheets): + raise ValueError(f"At least the sheets {required_sheets} must be defined!") + + # Ensure all sheets are valid + for sheet in file_dict: + if sheet not in all_sheets: + raise ValueError( + f"'{sheet}' is not a valid name. Valid sheet names are: \n" + f"{all_sheets}" + ) + + # ----------------------------------------------------------------------------- + # Check 'sensors coordinates' shape + if file_dict["sensors coordinates"].values.shape[1] != 3: + raise ValueError( + "'sensors coordinates' should have 3 columns for the x,y and z coordinates." + f"'sensors coordinates' have {file_dict['sensors coordinates'].values.shape[1]} columns" + ) + + # Check on same shape 'sensors coordinates' and 'sensors directions' + if ( + file_dict["sensors coordinates"].values.shape + != file_dict["sensors directions"].values.shape + ): + raise ValueError( + "'sensors coordinates' and 'sensors directions' must have the same shape.\n" + f"'sensors coordinates' shape is {file_dict['sensors coordinates'].values.shape} while 'sensors directions' shape is {file_dict['sensors directions'].values.shape}" + ) + + # Check 'BG nodes' shape + if ( + file_dict.get("BG nodes") is not None + and not file_dict["BG nodes"].empty + and file_dict["BG nodes"].values.shape[1] != 3 + ): + raise ValueError( + "'BG nodes' should have 3 columns for the x,y and z coordinates." + f"'BG nodess' have {file_dict['BG nodes'].values.shape[1]} columns" + ) + + # Check 'BG lines' shape + if ( + file_dict.get("BG lines") is not None + and not file_dict["BG lines"].empty + and file_dict["BG lines"].values.shape[1] != 2 + ): + raise ValueError( + "'BG lines' should have 2 columns for the starting and ending node of the line." + f"'BG lines' have {file_dict['BG lines'].values.shape[1]} columns" + ) + + # Check 'BG surfaces' shape + if ( + file_dict.get("BG surfaces") is not None + and not file_dict["BG surfaces"].empty + and file_dict["BG surfaces"].values.shape[1] != 3 + ): + raise ValueError( + "'BG surfaces' should have 3 columns for the i,j and k node of the triangle." + f"'BG surfaces' have {file_dict['BG surfaces'].values.shape[1]} columns" + ) + + # Check on same index 'sensors coordinates' and 'sensors directions' + if ( + file_dict["sensors coordinates"].index.to_list() + != file_dict["sensors directions"].index.to_list() + ): + raise ValueError( + "'sensors coordinates' and 'sensors directions' must have the same index.\n" + f"'sensors coordinates' index is {file_dict['sensors coordinates'].index} while 'sensors directions' index is {file_dict['sensors directions'].index}" + ) + + # Extract the relevant dataframes + sens_names = file_dict["sensors names"] + sens_names = flatten_sns_names(sens_names, ref_ind) + + # Check for the presence of each string in the list + if not all( + item in file_dict["sensors coordinates"].index.to_list() for item in sens_names + ): + raise ValueError( + "All sensors names must be present as index of the sensors coordinates dataframe!" + ) + + # ----------------------------------------------------------------------------- + # Find the indices that rearrange sens_coord to sens_names + # newIDX = find_map(sens_names, file_dict['sensors coordinates'].index.to_numpy()) + # reorder if necessary + sens_coord = file_dict["sensors coordinates"].reindex(index=sens_names) + sens_dir = file_dict["sensors directions"].reindex(index=sens_names).values + + # ----------------------------------------------------------------------------- + # Adjust to 0 indexing + for key in ["sensors lines", "BG lines", "BG surfaces"]: + if key in file_dict and not file_dict[key].empty: + file_dict[key] = file_dict[key].sub(1) + # ----------------------------------------------------------------------------- + # if there is no entry create an empty one + for key in all_sheets: + if key not in file_dict: + file_dict[key] = pd.DataFrame() + + # Transform to None empty dataframes + for sheet, df in file_dict.items(): + if df.empty: + file_dict[sheet] = None + + # Transform to array relevant dataframes + if ( + sheet in ["sensors lines", "BG nodes", "BG lines", "BG surfaces"] + and file_dict[sheet] is not None + ): + file_dict[sheet] = file_dict[sheet].to_numpy() + + sens_lines = file_dict["sensors lines"] + BG_nodes = file_dict["BG nodes"] + BG_lines = file_dict["BG lines"] + BG_surf = file_dict["BG surfaces"] + + return (sens_names, sens_coord, sens_dir, sens_lines, BG_nodes, BG_lines, BG_surf) + + +# ----------------------------------------------------------------------------- + + +def check_on_geo2( + file_dict, ref_ind=None, fill_na="zero" +) -> typing.Tuple[ + typing.List[str], + pd.DataFrame, + np.ndarray, + pd.DataFrame, + pd.DataFrame, + np.ndarray, + np.ndarray, + np.ndarray, + np.ndarray, + np.ndarray, +]: + """ + Validates and processes sensor and background geometry data from a dictionary of dataframes. + + Parameters + ---------- + file_dict : dict + Dictionary containing dataframes of sensor and background geometry data. + ref_ind : list, optional + List of reference indices for sensor names, by default None. + fill_na : str, optional + Method to fill missing values in the mapping dataframe, by default "zero". + + Returns + ------- + tuple + A tuple containing: + - sens_names (list): List of sensor names. + - pts_coord (pd.DataFrame): DataFrame of points coordinates. + - sens_map (pd.DataFrame): DataFrame of sensor mappings. + - cstr (pd.DataFrame or None): DataFrame of constraints. + - sens_sign (pd.DataFrame): DataFrame of sensor signs. + - sens_lines (np.ndarray or None): Array of sensor lines. + - sens_surf (np.ndarray or None): Array of sensor surfaces. + - BG_nodes (np.ndarray or None): Array of background nodes. + - BG_lines (np.ndarray or None): Array of background lines. + - BG_surf (np.ndarray or None): Array of background surfaces. + + Raises + ------ + ValueError + If required sheets are missing or invalid. + If shapes of 'points coordinates' and 'mapping' do not match. + If 'points coordinates' or 'BG nodes' does not have 3 columns. + If 'BG lines' does not have 2 columns. + If 'BG surfaces' does not have 3 columns. + If sensor names are not present in the mapping dataframe. + If constraints columns do not correspond to sensor names. + If constraints names are not the same as those used in the mapping. + """ + # Remove INFO sheet from dict of dataframes + if "INFO" in file_dict: + del file_dict["INFO"] + + # ----------------------------------------------------------------------------- + required_sheets = ["sensors names", "points coordinates", "mapping"] + all_sheets = required_sheets + [ + "constraints", + "sensors sign", + "sensors lines", + "sensors surfaces", + "BG nodes", + "BG lines", + "BG surfaces", + ] + + # Ensure required sheets exist + if not all(sheet in file_dict for sheet in required_sheets): + raise ValueError(f"At least the sheets {required_sheets} must be defined!") + + # Ensure all sheets are valid + for sheet in file_dict: + if sheet not in all_sheets: + raise ValueError( + f"'{sheet}' is not a valid name. Valid sheet names are: \n" + f"{all_sheets}" + ) + + # ----------------------------------------------------------------------------- + # Check 'points coordinates' shape + if file_dict["points coordinates"].values.shape[1] != 3: + raise ValueError( + "'points coordinates' should have 3 columns for the x,y and z coordinates." + f"'points coordinates' have {file_dict['points coordinates'].values.shape[1]} columns" + ) + + # Check on same shape 'points coordinates' and 'mapping' + if file_dict["points coordinates"].values.shape != file_dict["mapping"].values.shape: + raise ValueError( + "'points coordinates' and 'mapping' must have the same shape.\n" + f"'points coordinates' shape is {file_dict['points coordinates'].values.shape} while 'mapping' shape is {file_dict['mapping'].values.shape}" + ) + + # Check on shape for 'sensors sign' + if ( + file_dict.get("sensors sign") is not None + and not file_dict["sensors sign"].empty + and file_dict["points coordinates"].values.shape + != file_dict["sensors sign"].values.shape + ): + raise ValueError( + "'points coordinates' and 'sensors sign' must have the same shape.\n" + f"'points coordinates' shape is {file_dict['points coordinates'].values.shape} while 'sensors sign' shape is {file_dict['sensors sign'].values.shape}" + ) + + # Check 'BG nodes' shape + if ( + file_dict.get("BG nodes") is not None + and not file_dict["BG nodes"].empty + and file_dict["BG nodes"].values.shape[1] != 3 + ): + raise ValueError( + "'BG nodes' should have 3 columns for the x,y and z coordinates." + f"'BG nodess' have {file_dict['BG nodes'].values.shape[1]} columns" + ) + + # Check 'BG lines' shape + if ( + file_dict.get("BG lines") is not None + and not file_dict["BG lines"].empty + and file_dict["BG lines"].values.shape[1] != 2 + ): + raise ValueError( + "'BG lines' should have 2 columns for the starting and ending node of the line." + f"'BG lines' have {file_dict['BG lines'].values.shape[1]} columns" + ) + + # Check 'BG surfaces' shape + if ( + file_dict.get("BG surfaces") is not None + and not file_dict["BG surfaces"].empty + and file_dict["BG surfaces"].values.shape[1] != 3 + ): + raise ValueError( + "'BG surfaces' should have 3 columns for the i,j and k node of the triangle." + f"'BG surfaces' have {file_dict['BG surfaces'].values.shape[1]} columns" + ) + + # if there is no 'sensors sign' create one + if file_dict.get("sensors sign") is None or file_dict["sensors sign"].empty: + sens_sign = pd.DataFrame( + np.ones(file_dict["points coordinates"].values.shape), + columns=file_dict["points coordinates"].columns, + ) + file_dict["sensors sign"] = sens_sign + + # ----------------------------------------------------------------------------- + # Check that mapping contains all sensors name + # Extract the relevant dataframes + sens_names = file_dict["sensors names"] + sens_names = flatten_sns_names(sens_names, ref_ind) + df_map = file_dict["mapping"] + constraints = file_dict["constraints"].fillna(0) + + if fill_na == "zero": + df_map = df_map.fillna(0.0) + # elif fill_na == "interp": + # df_map = df_map.fillna("interp") + + file_dict["mapping"] = df_map + + # Step 1: Flatten the DataFrame to a single list of values + map_fl = df_map.values.flatten() + # Step 2: Convert all values to strings + map_str_fl = [str(value) for value in map_fl] + # Step 3: Check for the presence of each string in the list + if not all(item in map_str_fl for item in sens_names): + raise ValueError("All sensors names must be present in the mapping dataframe!") + + # ----------------------------------------------------------------------------- + # Check that the constraints columns correspond to sensors names + columns = constraints.columns.to_list() + indices = constraints.index.to_list() + if not all(item in sens_names for item in columns): + raise ValueError( + "The constraints columns names must correspond to sensors names.\n" + f"constraints columns names: {columns}, \n" + f"sensors names: {sens_names}" + ) + + # ----------------------------------------------------------------------------- + # Check that the constraints names are the same as those used in mapping + list_of_possible_constraints = ["0", "0.0", "interp"] + # remove values equal to sensors names and other possible values (should be left with only contraints) + map_str_cstr = [ + value + for value in map_str_fl + if value not in sens_names and value not in list_of_possible_constraints + ] + if not all(item in map_str_cstr for item in indices): + raise ValueError( + "The constraints names (index column) must be the same as those used in mapping.\n" + f"constraints index column: {indices}, \n" + f"mapping : {map_str_cstr}" + ) + + # ----------------------------------------------------------------------------- + # Add missing sensor names with all zeros to the constraints DataFrame + missing_sensors = [name for name in sens_names if name not in columns] + for name in missing_sensors: + constraints[name] = 0 + + # Reorder columns to match the order of sens_names if necessary + file_dict["constraints"] = constraints[sens_names] + + # ----------------------------------------------------------------------------- + # Adjust to 0 indexing + for key in ["sensors lines", "sensors surfaces", "BG lines", "BG surfaces"]: + if key in file_dict and not file_dict[key].empty: + file_dict[key] = file_dict[key].sub(1) + # ----------------------------------------------------------------------------- + # if there is no entry create an empty one + for key in all_sheets: + if key not in file_dict: + file_dict[key] = pd.DataFrame() + + # Transform to None empty dataframes + for sheet, df in file_dict.items(): + if df.empty: + file_dict[sheet] = None + + # Transform to array relevant dataframes + if ( + sheet + in [ + "sensors lines", + "sensors surfaces", + "BG nodes", + "BG lines", + "BG surfaces", + ] + and file_dict[sheet] is not None + ): + file_dict[sheet] = file_dict[sheet].to_numpy() + + # sens_names = file_dict["sensors names"] + pts_coord = file_dict["points coordinates"] + sens_map = file_dict["mapping"] + cstr = file_dict["constraints"] + sens_sign = file_dict["sensors sign"] + sens_lines = file_dict["sensors lines"] + sens_surf = file_dict["sensors surfaces"] + BG_nodes = file_dict["BG nodes"] + BG_lines = file_dict["BG lines"] + BG_surf = file_dict["BG surfaces"] + + return ( + sens_names, + pts_coord, + sens_map, + cstr, + sens_sign, + sens_lines, + sens_surf, + BG_nodes, + BG_lines, + BG_surf, + ) + + +# ----------------------------------------------------------------------------- + + +def flatten_sns_names(sens_names, ref_ind=None) -> typing.List[str]: + """ + Ensures that sensors names is in the correct form (1D list of strings) for both + single-setup or multi-setup geometries. + + Parameters + ---------- + sens_names : list, pd.DataFrame, or np.ndarray + Sensor names which can be a list of strings, list of lists of strings, DataFrame, + or 1D numpy array of strings. + ref_ind : list, optional + List of reference indices for multi-setup geometries, by default None. + + Returns + ------- + list + Flattened list of sensor names. + + Raises + ------ + AttributeError + If `ref_ind` is not provided for multi-setup geometries. + ValueError + If `sens_names` is not of the expected types. + """ + # check if sens_names is a dataframe with one row and transform it to a list + # FOR SINGLE-SETUP GEOMETRIES + if isinstance(sens_names, pd.DataFrame) and sens_names.values.shape[0] == 1: + sns_names_fl = sens_names.values.tolist()[0] + # Check if sens_names is a DataFrame with more than one row or a list of lists + # FOR MULTI-SETUP GEOMETRIES + elif (isinstance(sens_names, pd.DataFrame) and sens_names.values.shape[0] > 1) or ( + isinstance(sens_names, list) + and all(isinstance(elem, list) for elem in sens_names) + ): + # if sens_names is a dataframe, transform it to a list + if isinstance(sens_names, pd.DataFrame): + sens_names = [ + [item for item in row if not pd.isna(item)] + for row in sens_names.values.tolist() + ] + n = len(sens_names) + if ref_ind is None: + raise AttributeError( + "You need to specify the reference indices for a Multi-setup test" + ) + k = len(ref_ind[0]) # number of reference sensor (from the first setup) + sns_names_fl = [] + # Create the reference strings + for i in range(k): + sns_names_fl.append(f"REF{i+1}") + # Flatten the list of strings and exclude the reference indices + for i in range(n): + for j in range(len(sens_names[i])): + if j not in ref_ind[i]: + sns_names_fl.append(sens_names[i][j]) + + elif isinstance(sens_names, list) and all( + isinstance(elem, str) for elem in sens_names + ): + sns_names_fl = sens_names + + elif isinstance(sens_names, np.ndarray) and sens_names.ndim == 1: + sns_names_fl = sens_names.tolist() + + else: + raise ValueError( + "The input must of type: [list(str), list(list(str)), pd.DataFrame, NDArray(str)]" + ) + + return sns_names_fl + + +# ----------------------------------------------------------------------------- + + +def example_data() -> dict: + """ + This function generates a time history of acceleration for a 5 DOF + system. + + The function returns a (360001,5) array and a tuple containing: the + natural frequencies of the system (fn = (5,) array); the unity + displacement normalised mode shapes matrix (FI_1 = (5,5) array); and the + damping ratios (xi = float) + + Returns + ------- + acc : 2D array + Time histories of the 5 DOF of the system. + (fn, FI_1, xi) : tuple + Tuple containing the natural frequencies (fn), the mode shape + matrix (FI_1), and the damping ratio (xi) of the system. + + """ + + rng = np.random.RandomState(12345) # Set the seed + fs = 600 # [Hz] Sampling freqiency + T = 900 # [sec] Period of the time series + + dt = 1 / fs # [sec] time resolution + Ndat = int(T / dt) # number of data points + + t = np.linspace(0, T + dt, Ndat) + + # ========================================================================= + # SYSTEM DEFINITION + + m = 25.91 # mass + k = 10000.0 # stiffness + + # Mass matrix + M = np.eye(5) * m + _ndof = M.shape[0] # number of DOF (5) + + # Stiffness matrix + K = ( + np.array( + [ + [2, -1, 0, 0, 0], + [-1, 2, -1, 0, 0], + [0, -1, 2, -1, 0], + [0, 0, -1, 2, -1], + [0, 0, 0, -1, 1], + ] + ) + * k + ) + + lam, FI = linalg.eigh(K, b=M) # Solving eigen value problem + + fn = np.sqrt(lam) / (2 * np.pi) # Natural frequencies + + # Unity displacement normalised mode shapes + FI_1 = np.array([FI[:, k] / max(abs(FI[:, k])) for k in range(_ndof)]).T + # Ordering from smallest to largest + FI_1 = FI_1[:, np.argsort(fn)] + fn = np.sort(fn) + + # K_M = FI_M.T @ K @ FI_M # Modal stiffness + M_M = FI_1.T @ M @ FI_1 # Modal mass + + xi = 0.02 # damping ratio for all modes (2%) + # Modal damping + C_M = np.diag( + np.array([2 * M_M[i, i] * xi * fn[i] * (2 * np.pi) for i in range(_ndof)]) + ) + + C = linalg.inv(FI_1.T) @ C_M @ linalg.inv(FI_1) # Damping matrix + + # ========================================================================= + # STATE-SPACE FORMULATION + + a1 = np.zeros((_ndof, _ndof)) # Zeros (ndof x ndof) + a2 = np.eye(_ndof) # Identity (ndof x ndof) + A1 = np.hstack((a1, a2)) # horizontal stacking (ndof x 2*ndof) + a3 = -linalg.inv(M) @ K # M^-1 @ K (ndof x ndof) + a4 = -linalg.inv(M) @ C # M^-1 @ C (ndof x ndof) + A2 = np.hstack((a3, a4)) # horizontal stacking(ndof x 2*ndof) + # vertical stacking of A1 e A2 + Ac = np.vstack((A1, A2)) # State Matrix A (2*ndof x 2*ndof)) + + b2 = -linalg.inv(M) + # Input Influence Matrix B (2*ndof x n°input=ndof) + Bc = np.vstack((a1, b2)) + + # N.B. number of rows = n°output*ndof + # n°output may be 1, 2 o 3 (displacements, velocities, accelerations) + # the Cc matrix has to be defined accordingly + c1 = np.hstack((a2, a1)) # displacements row + c2 = np.hstack((a1, a2)) # velocities row + c3 = np.hstack((a3, a4)) # accelerations row + # Output Influence Matrix C (n°output*ndof x 2*ndof) + Cc = np.vstack((c1, c2, c3)) + + # Direct Transmission Matrix D (n°output*ndof x n°input=ndof) + Dc = np.vstack((a1, a1, b2)) + + # ========================================================================= + # Using SciPy's LTI to solve the system + + # Defining the system + sys = signal.lti(Ac, Bc, Cc, Dc) + + # Defining the amplitute of the force + af = 1 + + # Assembling the forcing vectors (N x ndof) (random white noise!) + # N.B. N=number of data points; ndof=number of DOF + u = np.array([rng.randn(Ndat) * af for r in range(_ndof)]).T + + # Solving the system + tout, yout, xout = signal.lsim(sys, U=u, T=t) + + # d = yout[:,:5] # displacement + # v = yout[:,5:10] # velocity + a = yout[:, 10:] # acceleration + + # ========================================================================= + # Adding noise + # SNR = 10*np.log10(_af/_ar) + SNR = 10 # Signal-to-Noise ratio + ar = af / (10 ** (SNR / 20)) # Noise amplitude + + # Initialize the arrays (copy of accelerations) + acc = a.copy() + for _ind in range(_ndof): + # Measurments POLLUTED BY NOISE + acc[:, _ind] = a[:, _ind] + ar * rng.randn(Ndat) + + # # Subplot of the accelerations + # fig, axs = plt.subplots(5,1,sharex=True) + # for _nr in range(_ndof): + # axs[_nr].plot(t, a[:,_nr], alpha=1, linewidth=1, label=f'story{_nr+1}') + # axs[_nr].legend(loc=1, shadow=True, framealpha=1) + # axs[_nr].grid(alpha=0.3) + # axs[_nr].set_ylabel('$mm/s^2$') + # axs[_nr].set_xlabel('t [sec]') + # fig.suptitle('Accelerations plot', fontsize=12) + # plt.show() + + return acc, (fn, FI_1, xi) + + +# ----------------------------------------------------------------------------- + + +def merge_mode_shapes( + MSarr_list: typing.List[np.ndarray], reflist: typing.List[typing.List[int]] +) -> np.ndarray: + """ + Merges multiple mode shape arrays from different setups into a single mode shape array. + + Parameters + ---------- + MSarr_list : List[np.ndarray] + A list of mode shape arrays. Each array in the list corresponds + to a different experimental setup. Each array should have dimensions [N x M], where N is the number + of sensors (including both reference and roving sensors) and M is the number of modes. + reflist : List[List[int]] + A list of lists containing the indices of reference sensors. Each sublist + corresponds to the indices of the reference sensors used in the corresponding setup in `MSarr_list`. + Each sublist should contain the same number of elements. + + Returns + ------- + np.ndarray + A merged mode shape array. The number of rows in the array equals the sum of the number + of unique sensors across all setups minus the number of reference sensors in each setup + (except the first one). The number of columns equals the number of modes. + + Raises + ------ + ValueError + If the mode shape arrays in `MSarr_list` do not have the same number of modes. + """ + Nsetup = len(MSarr_list) # number of setup + Nmodes = MSarr_list[0].shape[1] # number of modes + Nref = len(reflist[0]) # number of reference sensors + M = Nref + np.sum( + [MSarr_list[i].shape[0] - Nref for i in range(Nsetup)] + ) # total number of nodes in a mode shape + # Check if the input arrays have consistent dimensions + for i in range(1, Nsetup): + if MSarr_list[i].shape[1] != Nmodes: + raise ValueError("All mode shape arrays must have the same number of modes.") + # Initialize merged mode shape array + merged_mode_shapes = np.zeros((M, Nmodes)).astype(complex) + # Loop through each mode + for k in range(Nmodes): + phi_1_k = MSarr_list[0][:, k] # Save the mode shape from first setup + phi_ref_1_k = phi_1_k[reflist[0]] # Save the reference sensors + merged_mode_k = np.concatenate( + (phi_ref_1_k, np.delete(phi_1_k, reflist[0])) + ) # initialise the merged mode shape + # Loop through each setup + for i in range(1, Nsetup): + ref_ind = reflist[i] # reference sensors indices for the specific setup + phi_i_k = MSarr_list[i][:, k] # mode shape of setup i + phi_ref_i_k = MSarr_list[i][ref_ind, k] # save data from reference sensors + phi_rov_i_k = np.delete( + phi_i_k, ref_ind, axis=0 + ) # saave data from roving sensors + # Find scaling factor + alpha_i_k = MSF(phi_ref_1_k, phi_ref_i_k) + # Merge mode + merged_mode_k = np.hstack((merged_mode_k, alpha_i_k * phi_rov_i_k)) + + merged_mode_shapes[:, k] = merged_mode_k + + return merged_mode_shapes + + +# ----------------------------------------------------------------------------- + + +def MPC(phi: np.ndarray) -> float: + """ + Calculate the Modal Phase Collinearity (MPC) of a complex mode shape. + + The MPC is a measure of the collinearity between the real and imaginary parts + of a mode shape. A value of 1 indicates perfect collinearity, while lower values + indicate a more complex (non-collinear) mode. + + Parameters + ---------- + phi : ndarray + Complex mode shape vector, shape: (n_locations, ). + + Returns + ------- + float + MPC value, ranging between 0 and 1, where 1 indicates perfect collinearity. + """ + try: + S = np.cov(phi.real, phi.imag) + lambd = np.linalg.eigvals(S) + MPC = (lambd[0] - lambd[1]) ** 2 / (lambd[0] + lambd[1]) ** 2 + except Exception: + MPC = np.nan + return MPC + + +# ----------------------------------------------------------------------------- + + +def MPD(phi: np.ndarray) -> float: + """ + Calculate the Mean Phase Deviation (MPD) of a complex mode shape. + + The MPD measures the deviation of the mode shape phases from a purely + real mode. It quantifies the phase variation along the mode shape. + + Parameters + ---------- + phi : ndarray + Complex mode shape vector, shape: (n_locations, ). + + Returns + ------- + float + MPD value, representing the average deviation of the phase from a + purely real mode. + """ + try: + U, s, VT = np.linalg.svd(np.c_[phi.real, phi.imag]) + V = VT.T + w = np.abs(phi) + num = phi.real * V[1, 1] - phi.imag * V[0, 1] + den = np.sqrt(V[0, 1] ** 2 + V[1, 1] ** 2) * np.abs(phi) + MPD = np.sum(w * np.arccos(np.abs(num / den))) / np.sum(w) + except Exception: + MPD = np.nan + return MPD + + +# ----------------------------------------------------------------------------- + + +def MSF(phi_1: np.ndarray, phi_2: np.ndarray) -> np.ndarray: + """ + Calculates the Modal Scale Factor (MSF) between two sets of mode shapes. + + Parameters + ---------- + phi_1 : ndarray + Mode shape matrix X, shape: (n_locations, n_modes) or n_locations. + phi_2 : ndarray + Mode shape matrix A, shape: (n_locations, n_modes) or n_locations. + + Returns + ------- + ndarray + The MSF values, real numbers that scale `phi_1` to `phi_2`. + + Raises + ------ + Exception + If `phi_1` and `phi_2` do not have the same shape. + """ + if phi_1.ndim == 1: + phi_1 = phi_1[:, None] + if phi_2.ndim == 1: + phi_2 = phi_2[:, None] + + if phi_1.shape[0] != phi_2.shape[0] or phi_1.shape[1] != phi_2.shape[1]: + raise Exception( + f"`phi_1` and `phi_2` must have the same shape: {phi_1.shape} " + f"and {phi_2.shape}" + ) + + n_modes = phi_1.shape[1] + msf = [] + for i in range(n_modes): + _msf = np.dot(phi_2[:, i].T, phi_1[:, i]) / np.dot(phi_1[:, i].T, phi_1[:, i]) + + msf.append(_msf) + + return np.array(msf).real + + +# ----------------------------------------------------------------------------- + + +def MCF(phi: np.ndarray) -> np.ndarray: + """ + Calculates the Modal Complexity Factor (MCF) for mode shapes. + + Parameters + ---------- + phi : ndarray + Complex mode shape matrix, shape: (n_locations, n_modes) or n_locations. + + Returns + ------- + ndarray + MCF values, ranging from 0 (for real modes) to 1 (for complex modes). + """ + if phi.ndim == 1: + phi = phi[:, None] + n_modes = phi.shape[1] + mcf = [] + for i in range(n_modes): + S_xx = np.dot(phi[:, i].real, phi[:, i].real) + S_yy = np.dot(phi[:, i].imag, phi[:, i].imag) + S_xy = np.dot(phi[:, i].real, phi[:, i].imag) + + _mcf = 1 - ((S_xx - S_yy) ** 2 + 4 * S_xy**2) / (S_xx + S_yy) ** 2 + + mcf.append(_mcf) + return np.array(mcf) + + +# ----------------------------------------------------------------------------- + + +def MAC(phi_X: np.ndarray, phi_A: np.ndarray) -> np.ndarray: + """ + Calculates the Modal Assurance Criterion (MAC) between two sets of mode shapes. + + Parameters + ---------- + phi_X : ndarray + Mode shape matrix X, shape: (n_locations, n_modes) or n_locations. + phi_A : ndarray + Mode shape matrix A, shape: (n_locations, n_modes) or n_locations. + + Returns + ------- + ndarray + MAC matrix. Returns a single MAC value if both `phi_X` and `phi_A` are + one-dimensional arrays. + + Raises + ------ + Exception + If mode shape matrices have more than 2 dimensions or if their first dimensions do not match. + """ + if phi_X.ndim == 1: + phi_X = phi_X[:, np.newaxis] + + if phi_A.ndim == 1: + phi_A = phi_A[:, np.newaxis] + + if phi_X.ndim > 2 or phi_A.ndim > 2: + raise Exception( + f"Mode shape matrices must have 1 or 2 dimensions (phi_X: {phi_X.ndim}, phi_A: {phi_A.ndim})" + ) + + if phi_X.shape[0] != phi_A.shape[0]: + raise Exception( + f"Mode shapes must have the same first dimension (phi_X: {phi_X.shape[0]}, " + f"phi_A: {phi_A.shape[0]})" + ) + + # mine + # MAC = np.abs(np.dot(phi_X.conj().T, phi_A)) ** 2 / ( + # (np.dot(phi_X.conj().T, phi_X)) * (np.dot(phi_A.conj().T, phi_A)) + # ) + # original + MAC = np.abs(np.conj(phi_X).T @ phi_A) ** 2 + MAC = MAC.astype(complex) + for i in range(phi_X.shape[1]): + for j in range(phi_A.shape[1]): + MAC[i, j] = MAC[i, j] / ( + np.conj(phi_X[:, i]) @ phi_X[:, i] * np.conj(phi_A[:, j]) @ phi_A[:, j] + ) + + if MAC.shape == (1, 1): + MAC = MAC[0, 0] + + return MAC.real + + +# ----------------------------------------------------------------------------- + + +def pre_multisetup( + dataList: typing.List[np.ndarray], reflist: typing.List[typing.List[int]] +) -> typing.List[typing.Dict[str, np.ndarray]]: + """ + Preprocesses data from multiple setups by separating reference and moving sensor data. + + Parameters + ---------- + DataList : list of numpy arrays + List of input data arrays for each setup, where each array represents sensor data. + reflist : list of lists + List of lists containing indices of sensors used as references for each setup. + + Returns + ------- + list of dicts + A list of dictionaries, each containing the data for a setup. + Each dictionary has keys 'ref' and 'mov' corresponding to reference and moving sensor data. + """ + n_setup = len(dataList) # number of setup + Y = [] + for i in range(n_setup): + y = dataList[i] + n_ref = len(reflist[i]) + n_sens = y.shape[1] + ref_id = reflist[i] + mov_id = list(range(n_sens)) + for ii in range(n_ref): + mov_id.remove(ref_id[ii]) + ref = y[:, ref_id] + mov = y[:, mov_id] + # TO DO: check that len(n_ref) is the same in all setup + + # N.B. ONLY FOR TEST + # Y.append({"ref": np.array(ref).reshape(n_ref,-1)}) + Y.append( + { + "ref": np.array(ref).T.reshape(n_ref, -1), + "mov": np.array(mov).T.reshape( + (n_sens - n_ref), + -1, + ), + } + ) + + return Y + + +# ----------------------------------------------------------------------------- + + +def invperm(p: np.ndarray) -> np.ndarray: + """ + Compute the inverse permutation of a given array. + + Parameters + ---------- + p : array-like + A permutation of integers from 0 to n-1, where n is the length of the array. + + Returns + ------- + ndarray + An array representing the inverse permutation of `p`. + """ + q = np.empty_like(p) + q[p] = np.arange(len(p)) + return q + + +# ----------------------------------------------------------------------------- + + +def find_map(arr1: np.ndarray, arr2: np.ndarray) -> np.ndarray: + """ + Maps the elements of one array to another based on sorting order. + + Parameters + ---------- + arr1 : array-like + The first input array. + arr2 : array-like + The second input array, which should have the same length as `arr1`. + + Returns + ------- + ndarray + An array of indices that maps the sorted version of `arr1` to the sorted version of `arr2`. + """ + o1 = np.argsort(arr1) + o2 = np.argsort(arr2) + return o2[invperm(o1)] + + +# ----------------------------------------------------------------------------- + + +def filter_data( + data: np.ndarray, + fs: float, + Wn: float, + order: int = 4, + btype: str = "lowpass", +) -> np.ndarray: + """ + Apply a Butterworth filter to the input data. + + This function designs and applies a digital Butterworth filter to the input data array. The filter + is applied in a forward-backward manner using the second-order sections representation to minimize + phase distortion. + + Parameters + ---------- + data : array_like + The input signal to filter. If `data` is a multi-dimensional array, the filter is applied along + the first axis. + fs : float + The sampling frequency of the input data. + Wn : array_like + The critical frequency or frequencies. For lowpass and highpass filters, Wn is a scalar; for + bandpass and bandstop filters, Wn is a length-2 sequence. + order : int, optional + The order of the filter. Higher order means a sharper frequency cutoff, but the filter will + also be less stable. The default is 4. + btype : str, optional + The type of filter to apply. Can be 'lowpass', 'highpass', 'bandpass', or 'bandstop'. The default + is 'lowpass'. + + Returns + ------- + filt_data : ndarray + The filtered signal. + + Note + ---- + This function uses `scipy.signal.butter` to design the filter and `scipy.signal.sosfiltfilt` for + filtering to apply the filter in a zero-phase manner, which does not introduce phase delay to the + filtered signal. For more information, see the scipy documentation for `signal.butter` + (https://docs.scipy.org/doc/scipy/reference/generated/scipy.signal.butter.html) and `signal.sosfiltfilt` + (https://docs.scipy.org/doc/scipy/reference/generated/scipy.signal.sosfiltfilt.html). + + """ + sos = signal.butter(order, Wn, btype=btype, output="sos", fs=fs) + filt_data = signal.sosfiltfilt(sos, data, axis=0) + return filt_data + + +# ----------------------------------------------------------------------------- + + +def save_to_file(setup: object, file_name: str) -> None: + """ + Save the specified setup instance to a file. + + This method serializes the current instance and saves it to a file using the pickle module. + + Parameters + ---------- + setup : obj + The Setup class that is to be saved. + file_name : str + The name (path) of the file where the setup instance will be saved. + """ + with open(file_name, "wb") as f: + pickle.dump(setup, f) + + +def load_from_file(file_name: str) -> object: + """ + Load a setup instance from a file. + + This method deserializes a saved setup instance from the specified file. + + Parameters + ---------- + file_name : str + The name (path) of the file from which the setup instance will be loaded. + + Returns + ------- + Setup + An instance of the setup loaded from the file. + """ + with open(file_name, "rb") as f: + instance = pickle.load(f) # noqa S301 + return instance + + +def read_excel_file( + path: str, + sheet_name: typing.Optional[str] = None, + engine: str = "openpyxl", + index_col: int = 0, + **kwargs: typing.Any, +) -> dict: + """ + Read an Excel file and return its contents as a dictionary. + + Parameters + ---------- + path : str + The path to the Excel file. + sheet_name : str, optional + The name of the sheet to read. If None, all sheets are read. Default is None. + engine : str, optional + The engine to use for reading the Excel file. Default is 'openpyxl'. + index_col : int, optional + The column to use as the index. Default is 0 + **kwargs : dict, optional + Additional keyword arguments to pass to pd.read_excel. + + Returns + ------- + dict + A dictionary containing the contents of the Excel file, with sheet names as keys. + + Raises + ------ + ImportError + If the specified engine is not available. + RuntimeError + If an error occurs while reading the Excel file. + """ + try: + file_dict = pd.read_excel( + path, sheet_name=sheet_name, engine=engine, index_col=index_col, **kwargs + ) + return file_dict + except ImportError as e: + raise ImportError( + "Optional package 'openpyxl' is not installed. " + "Install 'openpyxl' with 'pip install openpyxl' or 'pip install pyoma_2[pyvista]'" + ) from e + except Exception as e: + logger.error("An error occurred while reading the Excel file: %s", e) + raise RuntimeError( + f"An error occurred while reading the Excel file: {e.__class__}: {e}" + ) from e diff --git a/src/pyoma2/functions/plot.py b/src/pyoma2/functions/plot.py new file mode 100644 index 0000000..ce847f7 --- /dev/null +++ b/src/pyoma2/functions/plot.py @@ -0,0 +1,1964 @@ +""" +Plotting Utility Functions module. +Part of the pyOMA2 package. +Author: +Dag Pasca +""" + +import logging +import typing + +import matplotlib +import matplotlib.pyplot as plt +import matplotlib.tri as mtri +import numpy as np +from matplotlib.colors import to_rgba +from matplotlib.lines import Line2D +from matplotlib.ticker import MultipleLocator +from scipy import signal, stats +from scipy.interpolate import interp1d + +from .gen import MAC + +logger = logging.getLogger(__name__) + +# ============================================================================= +# PLOT ALGORITMI +# ============================================================================= + + +def plot_dtot_hist(dtot, bins="auto", sugg_co=True): + """ + Plot a histogram of the total distance matrix with optional suggested cut-off distances. + + This function plots a histogram of the values in the input distance matrix or vector `dtot`. + It overlays a kernel density estimate (KDE) and optionally indicates suggested cut-off distances + for clustering using single-linkage and average-linkage methods. + + Parameters + ---------- + dtot : ndarray + The input distance data. If a 2D array is provided, the upper triangular elements + (excluding the diagonal) are extracted. If a 1D array is provided, it is used as is. + bins : int or str, optional + The number of bins for the histogram. Defaults to "auto". + sugg_co : bool, optional + Whether to compute and display suggested cut-off distances for clustering. + Defaults to True. + + Returns + ------- + fig : matplotlib.figure.Figure + The figure object containing the plot. + ax : matplotlib.axes.Axes + The axes object for the histogram plot. + """ + if dtot.ndim == 2: + # Extract upper triangular indices and values + upper_tri_indices = np.triu_indices_from(dtot, k=0) + x = dtot[upper_tri_indices] + elif dtot.ndim == 1: + x = dtot + + xs = np.linspace(dtot.min(), dtot.max(), 500) + + kde = stats.gaussian_kde(x) + # Evaluate the KDE to get the PDF + pdf = kde(xs) + + # Create a figure and axis + fig, ax = plt.subplots(figsize=(10, 6)) + + # Plot the histogram on the axis + ax.hist(x, bins=bins, color="skyblue", edgecolor="black") + ax1 = ax.twinx() + ax1.plot(xs, kde(xs), "k-", label="Kernel density estimate") + + if sugg_co: + minima_in = signal.argrelmin(pdf)[0] + minima = pdf[minima_in] + min_abs = minima.argmin() + min_abs_ind = minima_in[min_abs] + maxima_in = signal.argrelmax(pdf) + dc2_ind = maxima_in[0][0] + dc2 = xs[dc2_ind] + dc1 = xs[min_abs_ind] + + ax1.axvline( + dc2, + color="red", + linestyle="dashed", + linewidth=2, + label=f"Suggested cut-off distance single-linkage: {dc2:.4f}", + ) + ax1.axvline( + dc1, + color="red", + linestyle="dotted", + linewidth=2, + label=f"Suggested cut-off distance average-linkage: {dc1:.4f}", + ) + + # Customize plot + ax.set_xlabel("dtot") + ax.set_ylabel("Frequency") + ax.set_title("Histogram of distances") + ax.xaxis.set_major_locator(MultipleLocator(0.1)) # Major ticks every 0.1 + ax.xaxis.set_minor_locator( + MultipleLocator(0.02) + ) # Minor ticks every 1/5 of major (0.02) + + # Add grid only for the x-axis + ax.grid(which="major", axis="x", color="gray", linestyle="-", linewidth=0.5) + ax.grid( + which="minor", axis="x", color="gray", linestyle=":", linewidth=0.5, alpha=0.7 + ) + ax1.legend(framealpha=1) + plt.tight_layout() + return fig, ax + + +# ----------------------------------------------------------------------------- + + +# Helper function to adjust alpha of colors +def adjust_alpha(color, alpha): + """ + Adjust the alpha (opacity) of a given color. + + Parameters + ---------- + color : str or tuple + The input color in any valid Matplotlib format (e.g., string name, hex code, or RGB tuple). + alpha : float + The desired alpha value, between 0 (completely transparent) and 1 (completely opaque). + + Returns + ------- + tuple + The RGBA representation of the input color with the specified alpha value. + """ + rgba = to_rgba(color) + return rgba[:3] + (alpha,) + + +# Rearrange legend elements for column-wise ordering +def rearrange_legend_elements(legend_elements, ncols): + """ + Rearrange legend elements into a column-wise ordering. + + Parameters + ---------- + legend_elements : list of matplotlib.lines.Line2D + A list of legend elements to be rearranged. + ncols : int + The number of columns to arrange the legend elements into. + + Returns + ------- + list + A reordered list of legend elements arranged column-wise. + """ + n = len(legend_elements) + nrows = int(np.ceil(n / ncols)) + total_entries = nrows * ncols + legend_elements_padded = legend_elements + [None] * (total_entries - n) + legend_elements_array = np.array(legend_elements_padded).reshape(nrows, ncols) + rearranged_elements = legend_elements_array.flatten(order="F") + rearranged_elements = [elem for elem in rearranged_elements if elem is not None] + return rearranged_elements + + +# ----------------------------------------------------------------------------- + + +def freq_vs_damp_plot( + Fn_fl: np.ndarray, + Xi_fl: np.ndarray, + labels: np.ndarray, + freqlim: typing.Optional[typing.Tuple] = None, + plot_noise: bool = False, + name: str = None, + fig: typing.Optional[plt.Figure] = None, + ax: typing.Optional[plt.Axes] = None, +) -> typing.Tuple[plt.Figure, plt.Axes]: + """ + Plot frequency versus damping, with points grouped by clusters. + + Parameters + ---------- + Fn_fl : np.ndarray + Array of natural frequencies (flattened, 1d). + Xi_fl : np.ndarray + Array of damping ratios (flattened, 1d). + labels : np.ndarray + Cluster labels for each data point. Use `-1` for noise. + freqlim : tuple of float, optional + Tuple specifying the (min, max) limits for the frequency axis, by default None. + plot_noise : bool, optional + Whether to include points labeled as noise (`-1`) in the plot, by default False. + fig : plt.Figure, optional + Existing Matplotlib figure to plot on, by default None. + ax : plt.Axes, optional + Existing Matplotlib axes to plot on, by default None. + + Returns + ------- + fig : plt.Figure + The Matplotlib figure object containing the plot. + ax : plt.Axes + The Matplotlib axes object containing the plot. + """ + # Initialize figure and axes if not provided + if fig is None and ax is None: + fig, ax = plt.subplots(figsize=(10, 6)) + fig.subplots_adjust( + right=0.75 + ) # Adjust the right margin to make room for the legend + elif fig is not None and ax is None: + ax = fig.add_subplot(1, 1, 1) + elif fig is None and ax is not None: + fig = ax.figure + + # Assign x and y + x = Fn_fl + y = Xi_fl * 100 # N.B. Transform to percent + + # Filter out noise points if plot_noise is False + if not plot_noise: + mask = labels != -1 + x = x[mask] + y = y[mask] + labels_filtered = labels[mask] + + else: + labels_filtered = labels + + # Identify unique labels (after filtering) + unique_labels = np.unique(labels_filtered) + + # Separate noise label + labels_without_noise = unique_labels[unique_labels != -1] + n_labels = len(labels_without_noise) + + # Choose a colormap with enough distinct colors, excluding greys + if n_labels <= 9: # Exclude grey from tab10 + cmap = plt.get_cmap("tab10") + colors = [cmap.colors[i] for i in range(len(cmap.colors)) if i != 7] + elif n_labels <= 18: # Exclude greys from tab20 + cmap = plt.get_cmap("tab20") + colors = [cmap.colors[i] for i in range(len(cmap.colors)) if i not in [14, 15]] + else: + # Generate a colormap with n_labels distinct colors + cmap = plt.cm.get_cmap("hsv", n_labels) + colors = cmap(np.linspace(0, 1, n_labels)) + + # Create a mapping from label to color for clusters (excluding noise) + color_map = {label: colors[i] for i, label in enumerate(labels_without_noise)} + + # Assign grey color to noise label + if -1 in unique_labels: + color_map[-1] = "grey" + + point_colors = [color_map[label] for label in labels_filtered] + + # Create masks for noise and cluster data + noise_mask = labels_filtered == -1 + cluster_mask = labels_filtered != -1 + + # Plot the scatter points for clusters + ax.scatter( + x[cluster_mask], + y[cluster_mask], + c=[point_colors[i] for i in range(len(point_colors)) if cluster_mask[i]], + s=70, + alpha=0.5, + edgecolors="k", + linewidth=0.9, + ) + + # Plot the scatter points for noise cluster + if plot_noise and noise_mask.any(): + ax.scatter( + x[noise_mask], + y[noise_mask], + c=[point_colors[i] for i in range(len(point_colors)) if noise_mask[i]], + s=70, + alpha=0.2, + edgecolors="k", + linewidth=0.5, + ) + + # Prepare legend labels + legend_labels = {} + cluster_counter = 1 + for label in unique_labels: + if label == -1 and plot_noise: + legend_labels[label] = "Noise" + elif label == -1 and not plot_noise: + continue # Skip noise label + else: + legend_labels[label] = f"Cluster {cluster_counter}" + cluster_counter += 1 + + # Create custom legend handles with formatted labels + legend_elements = [] + for label in unique_labels: + if label == -1 and not plot_noise: + continue # Skip adding Noise to legend if plot_noise is False + if label == -1: + facecolor = adjust_alpha(color_map[label], 0.5) + else: + facecolor = adjust_alpha(color_map[label], 0.9) + legend_elements.append( + Line2D( + [0], + [0], + marker="o", + color="w", + markerfacecolor=facecolor, + markeredgecolor="k", + markeredgewidth=0.5, + markersize=10, + label=legend_labels[label], + ) + ) + + # Determine the number of columns for the legend + ncols = 1 if len(legend_elements) <= 20 else 2 + + legend_elements = rearrange_legend_elements(legend_elements, ncols) + + # Add the legend to the plot + ax.legend( + handles=legend_elements, + title="Clusters", + loc="center left", + bbox_to_anchor=(1, 0.5), + frameon=True, + ncol=ncols, + borderaxespad=0.0, + ) + + # Add cross for each cluster (excluding Noise) + for label in labels_without_noise: + # Extract x-values for the current cluster + cluster_x = x[labels_filtered == label] + cluster_y = y[labels_filtered == label] + if len(cluster_x) == 0: + continue # Skip if no points in cluster + median_x = np.median(cluster_x) + median_y = np.median(cluster_y) + + ax.plot( + median_x, + median_y, + marker="x", # 'x' marker for cross + markersize=12, # Larger size than cluster circles + markeredgewidth=2, # Thin lines for the cross + markeredgecolor="red", # Red color for visibility + linestyle="None", # No connecting lines + ) + + # Set plot titles and labels + ax.set_title(f"Frequency vs Damping - Clusters {name}") + ax.set_xlabel("Frequency [Hz]") + ax.set_ylabel("Damping [%]") + + # Set x-axis limits if freqlim is provided + if freqlim is not None: + ax.set_xlim(freqlim[0], freqlim[1]) + + # Add grid for better readability + ax.grid(True, linestyle="--", alpha=0.6) + plt.tight_layout() + + return fig, ax + + +# ----------------------------------------------------------------------------- + + +def stab_clus_plot( + Fn_fl: np.ndarray, + order_fl: np.ndarray, + labels: np.ndarray, + step: int, + ordmax: int, + ordmin: int = 0, + freqlim: typing.Optional[typing.Tuple[float, float]] = None, + Fn_std: np.ndarray = None, + plot_noise: bool = False, + name: str = None, + fig: typing.Optional[plt.Figure] = None, + ax: typing.Optional[plt.Axes] = None, +) -> typing.Tuple[plt.Figure, plt.Axes]: + """ + Plots a stabilization chart of the poles of a system with clusters indicated by colors. + The legend labels clusters as "Cluster 1", "Cluster 2", ..., "Cluster N", and "-1" as "Noise". + Additionally, adds a vertical line at the median frequency of each cluster. + Optionally, the noise cluster can be excluded from the plot. + + Parameters + ---------- + Fn_fl : np.ndarray + Frequency values. + order_fl : np.ndarray + Model order values. + labels : np.ndarray + Cluster labels for each point. + step : int + Step parameter (usage not shown in the plot). + ordmax : int + Maximum order for y-axis limit. + ordmin : int, optional + Minimum order for y-axis limit, by default 0. + freqlim : tuple of float, optional + Frequency limits for x-axis, by default None. + Fn_std : np.ndarray, optional + Standard deviation for frequency, by default None. + fig : plt.Figure, optional + Existing figure to plot on, by default None. + ax : plt.Axes, optional + Existing axes to plot on, by default None. + plot_noise : bool, optional + Whether to include the noise cluster in the plot, by default False. + + Returns + ------- + fig : plt.Figure + The matplotlib Figure object containing the plot. + ax : plt.Axes + The matplotlib Axes object containing the plot. + """ + + # Initialize figure and axes if not provided + if fig is None and ax is None: + fig, ax = plt.subplots(figsize=(10, 6)) + fig.subplots_adjust( + right=0.75 + ) # Adjust the right margin to make room for the legend + elif fig is not None and ax is None: + ax = fig.add_subplot(1, 1, 1) + elif fig is None and ax is not None: + fig = ax.figure + + # Assign x and y + x = Fn_fl + y = order_fl + + # Filter out noise points if plot_noise is False + if not plot_noise: + mask = labels != -1 + x = x[mask] + y = y[mask] + labels_filtered = labels[mask] + if Fn_std is not None: + Fn_std = Fn_std[mask] + else: + labels_filtered = labels + + # Identify unique labels (after filtering) + unique_labels = np.unique(labels_filtered) + + # Separate noise label + labels_without_noise = unique_labels[unique_labels != -1] + n_labels = len(labels_without_noise) + + # Choose a colormap with enough distinct colors, excluding greys + if n_labels <= 9: # Exclude grey from tab10 + cmap = plt.get_cmap("tab10") + colors = [cmap.colors[i] for i in range(len(cmap.colors)) if i != 7] + elif n_labels <= 18: # Exclude greys from tab20 + cmap = plt.get_cmap("tab20") + colors = [cmap.colors[i] for i in range(len(cmap.colors)) if i not in [14, 15]] + else: + # Generate a colormap with n_labels distinct colors + cmap = plt.cm.get_cmap("hsv", n_labels) + colors = cmap(np.linspace(0, 1, n_labels)) + + # Create a mapping from label to color for clusters (excluding noise) + color_map = {label: colors[i] for i, label in enumerate(labels_without_noise)} + + # Assign grey color to noise label + if -1 in unique_labels: + color_map[-1] = "grey" + + point_colors = [color_map[label] for label in labels_filtered] + + # Create masks for noise and cluster data + noise_mask = labels_filtered == -1 + cluster_mask = labels_filtered != -1 + + # Plot the scatter points for clusters + ax.scatter( + x[cluster_mask], + y[cluster_mask], + c=[point_colors[i] for i in range(len(point_colors)) if cluster_mask[i]], + s=70, + alpha=0.9, + edgecolors="k", + linewidth=0.9, + ) + + # Plot the scatter points for noise cluster + if plot_noise and noise_mask.any(): + ax.scatter( + x[noise_mask], + y[noise_mask], + c=[point_colors[i] for i in range(len(point_colors)) if noise_mask[i]], + s=70, + alpha=0.2, + edgecolors="k", + linewidth=0.5, + ) + + # If Fn_std is provided, add error bars + if Fn_std is not None: + # For cluster data + if cluster_mask.any(): + ax.errorbar( + x[cluster_mask].squeeze(), + y[cluster_mask].squeeze(), + xerr=Fn_std[cluster_mask].squeeze(), + fmt="none", + ecolor="gray", + alpha=0.7, + capsize=5, + ) + # For noise data + if plot_noise and noise_mask.any(): + ax.errorbar( + x[noise_mask].squeeze(), + y[noise_mask].squeeze(), + xerr=Fn_std[noise_mask].squeeze(), + fmt="none", + ecolor="gray", + alpha=0.5, + capsize=5, + ) + + # Prepare legend labels + legend_labels = {} + cluster_counter = 1 + for label in unique_labels: + if label == -1 and plot_noise: + legend_labels[label] = "Noise" + elif label == -1 and not plot_noise: + continue # Skip noise label + else: + legend_labels[label] = f"Cluster {cluster_counter}" + cluster_counter += 1 + + # Create custom legend handles with formatted labels + legend_elements = [] + for label in unique_labels: + if label == -1 and not plot_noise: + continue # Skip adding Noise to legend if plot_noise is False + if label == -1: + facecolor = adjust_alpha(color_map[label], 0.5) + else: + facecolor = adjust_alpha(color_map[label], 0.9) + legend_elements.append( + Line2D( + [0], + [0], + marker="o", + color="w", + markerfacecolor=facecolor, + markeredgecolor="k", + markeredgewidth=0.5, + markersize=10, + label=legend_labels[label], + ) + ) + + # Determine the number of columns for the legend + ncols = 1 if len(legend_elements) <= 20 else 2 + + legend_elements = rearrange_legend_elements(legend_elements, ncols) + + # Add the legend to the plot + ax.legend( + handles=legend_elements, + title="Clusters", + loc="center left", + bbox_to_anchor=(1, 0.5), + frameon=True, + ncol=ncols, + borderaxespad=0.0, + ) + + # Add vertical lines for each cluster (excluding Noise) + for label in labels_without_noise: + # Extract x-values for the current cluster + cluster_x = x[labels_filtered == label] + if len(cluster_x) == 0: + continue # Skip if no points in cluster + median_x = np.median(cluster_x) + ax.axvline( + x=median_x, color=color_map[label], alpha=0.8, linestyle="--", linewidth=2 + ) + + # Set plot titles and labels + ax.set_title(f"Stabilization Chart with Clusters {name}") + ax.set_xlabel("Frequency [Hz]") + ax.set_ylabel("Model Order") + + # Set y-axis limits + ax.set_ylim(ordmin, ordmax + 1) + + # Set x-axis limits if freqlim is provided + if freqlim is not None: + ax.set_xlim(freqlim[0], freqlim[1]) + + # Add grid for better readability + ax.grid(True, linestyle="--", alpha=0.6) + plt.tight_layout() + + return fig, ax + + +# ----------------------------------------------------------------------------- + + +def CMIF_plot( + S_val: np.ndarray, + freq: np.ndarray, + freqlim: typing.Optional[typing.Tuple] = None, + nSv: str = "all", + fig: typing.Optional[plt.Figure] = None, + ax: typing.Optional[plt.Axes] = None, +) -> typing.Tuple[plt.Figure, plt.Axes]: + """ + Plots the Complex Mode Indicator Function (CMIF) based on given singular values and frequencies. + + Parameters + ---------- + S_val : ndarray + A 3D array representing the singular values, with shape [nChannel, nChannel, nFrequencies]. + freq : ndarray + An array representing the frequency values corresponding to the singular values. + freqlim : tuple of float, optional + The frequency range (lower, upper) for the plot. If None, includes all frequencies. Default is None. + nSv : int or str, optional + The number of singular values to plot. If "all", plots all singular values. + Otherwise, should be an integer specifying the number of singular values. Default is "all". + fig : matplotlib.figure.Figure, optional + An existing matplotlib figure object to plot on. If None, a new figure is created. Default is None. + ax : matplotlib.axes.Axes, optional + An existing axes object to plot on. If None, new axes are created on the provided or new figure. + Default is None. + + Returns + ------- + fig : matplotlib.figure.Figure + The matplotlib figure object. + ax : matplotlib.axes.Axes + The axes object with the CMIF plot. + + Raises + ------ + ValueError + If `nSv` is not "all" and is not less than the number of singular values in `S_val`. + """ + # COMPLEX MODE INDICATOR FUNCTION + if fig is None and ax is None: + fig, ax = plt.subplots(figsize=(8, 6), tight_layout=True) + if nSv == "all": + nSv = S_val.shape[1] + # Check that the number of singular value to plot is lower thant the total + # number of singular values + else: + try: + assert int(nSv) < S_val.shape[1] + except Exception as e: + raise ValueError( + f"ERROR: nSV must be less or equal to {S_val.shape[1]}. nSV={int(nSv)}" + ) from e + + for k in range(nSv): + if k == 0: + ax.plot( + freq, + 10 * np.log10(S_val[k, k, :] / S_val[k, k, :][np.argmax(S_val[k, k, :])]), + "k", + linewidth=2, + ) + else: + ax.plot( + freq, + 10 * np.log10(S_val[k, k, :] / S_val[0, 0, :][np.argmax(S_val[0, 0, :])]), + "grey", + ) + + ax.set_title("Singular values of spectral matrix") + ax.set_ylabel("dB rel. to unit") + ax.set_xlabel("Frequency [Hz]") + if freqlim is not None: + ax.set_xlim(freqlim[0], freqlim[1]) + ax.grid() + # plt.show() + return fig, ax + + +# ----------------------------------------------------------------------------- + + +def EFDD_FIT_plot( + Fn: np.ndarray, + Xi: np.ndarray, + PerPlot: typing.List[typing.Tuple], + freqlim: typing.Optional[typing.Tuple] = None, +) -> typing.Tuple[plt.Figure, typing.List[plt.Axes]]: + """ + Plot detailed results for the Enhanced Frequency Domain Decomposition (EFDD) and + the Frequency Spatial Domain Decomposition (FSDD) algorithms. + + Parameters + ---------- + Fn : ndarray + An array containing the natural frequencies identified for each mode. + Xi : ndarray + An array containing the damping ratios identified for each mode. + PerPlot : list of tuples + A list where each tuple contains data for one mode. Each tuple should have + the structure (freq, time, SDOFbell, Sval, idSV, normSDOFcorr, minmax_fit_idx, lam, delta). + freqlim : tuple of float, optional + The frequency range (lower, upper) for the plots. If None, includes all frequencies. Default is None. + + Returns + ------- + figs : list of matplotlib.figure.Figure + A list of matplotlib figure objects. + axs : list of lists of matplotlib.axes.Axes + A list of lists containing axes objects for each figure. + + Note + ----- + The function plots several aspects of the EFDD method for each mode, including the SDOF Bell function, + auto-correlation function, and the selected portion for fit and the actual fit. Each mode's plot + includes four subplots, showing the details of the EFDD fit process, including identified frequency + and damping ratio. + """ + + figs = [] + axs = [] + for numb_mode in range(len(PerPlot)): + freq = PerPlot[numb_mode][0] + time = PerPlot[numb_mode][1] + SDOFbell = PerPlot[numb_mode][2] + Sval = PerPlot[numb_mode][3] + idSV = PerPlot[numb_mode][4] + fsval = freq[idSV] + + normSDOFcorr = PerPlot[numb_mode][5] + minmax_fit_idx = PerPlot[numb_mode][6] + lam = PerPlot[numb_mode][7] + delta = PerPlot[numb_mode][8] + + xi_EFDD = Xi[numb_mode] + fn_EFDD = Fn[numb_mode] + + # If the plot option is activated we return the following plots + # build a rectangle in axes coords + left, _ = 0.25, 0.5 + bottom, height = 0.25, 0.5 + # right = left + width + top = bottom + height + # axes coordinates are 0,0 is bottom left and 1,1 is upper right + + # PLOT 1 - Plotting the SDOF bell function extracted + fig, ((ax1, ax2), (ax3, ax4)) = plt.subplots(nrows=2, ncols=2) + ax1.plot( + freq, 10 * np.log10(Sval[0, 0] / Sval[0, 0][np.argmax(Sval[0, 0])]), c="k" + ) + ax1.plot( + fsval, + 10 * np.log10(SDOFbell[idSV].real / SDOFbell[np.argmax(SDOFbell)].real), + c="r", + label="SDOF bell", + ) + ax1.set_title("SDOF Bell function") + ax1.set_xlabel("Frequency [Hz]") + ax1.set_ylabel(r"dB rel to unit.$") + ax1.grid() + + if freqlim is not None: + ax1.set_xlim(freqlim[0], freqlim[1]) + + ax1.legend() + + # Plot 2 + ax2.plot(time[:], normSDOFcorr, c="k") + ax2.set_title("Auto-correlation Function") + ax2.set_xlabel("Time lag[s]") + ax2.set_ylabel("Normalized correlation") + ax2.grid() + + # PLOT 3 (PORTION for FIT) + ax3.plot(time[: minmax_fit_idx[-1]], normSDOFcorr[: minmax_fit_idx[-1]], c="k") + ax3.scatter(time[minmax_fit_idx], normSDOFcorr[minmax_fit_idx], c="r", marker="x") + ax3.set_title("Portion for fit") + ax3.set_xlabel("Time lag[s]") + ax3.set_ylabel("Normalized correlation") + ax3.grid() + + # PLOT 4 (FIT) + ax4.scatter(np.arange(len(minmax_fit_idx)), delta, c="k", marker="x") + ax4.plot( + np.arange(len(minmax_fit_idx)), + lam / 2 * np.arange(len(minmax_fit_idx)), + c="r", + ) + + ax4.text( + left, + top, + r"""$f_n$ = %.3f + $\xi$ = %.2f%s""" + % (fn_EFDD, float(xi_EFDD) * 100, "%"), + transform=ax4.transAxes, + ) + + ax4.set_title("Fit - Frequency and Damping") + ax4.set_xlabel(r"counter $k^{th}$ extreme") + ax4.set_ylabel(r"$2ln\left(r_0/|r_k|\right)$") + ax4.grid() + + plt.tight_layout() + + figs.append(fig) + axs.append([ax1, ax2, ax3, ax4]) + + return figs, axs + + +# ----------------------------------------------------------------------------- + + +def stab_plot( + Fn: np.ndarray, + Lab: np.ndarray, + step: int, + ordmax: int, + ordmin: int = 0, + freqlim: typing.Optional[typing.Tuple] = None, + hide_poles: bool = True, + Fn_std: np.array = None, + fig: typing.Optional[plt.Figure] = None, + ax: typing.Optional[plt.Axes] = None, +) -> typing.Tuple[plt.Figure, plt.Axes]: + """ + Plots a stabilization chart of the poles of a system. + + Parameters + ---------- + Fn : np.ndarray + The frequencies of the poles. + Lab : np.ndarray + Labels indicating whether each pole is stable (1) or unstable (0). + step : int + The step size between model orders. + ordmax : int + The maximum model order. + ordmin : int, optional + The minimum model order, by default 0. + freqlim : tuple, optional + The frequency limits for the x-axis as a tuple (min_freq, max_freq), by default None. + hide_poles : bool, optional + Whether to hide the unstable poles, by default True. + fig : plt.Figure, optional + A matplotlib Figure object, by default None. + ax : plt.Axes, optional + A matplotlib Axes object, by default None. + Fn_std : np.ndarray, optional + The covariance of the frequencies, used for error bars, by default None. + + Returns + ------- + fig : plt.Figure + The matplotlib Figure object containing the plot. + ax : plt.Axes + The matplotlib Axes object containing the plot. + """ + if fig is None and ax is None: + fig, ax = plt.subplots(figsize=(8, 6), tight_layout=True) + + # Stable pole + Fns_stab = np.where(Lab == 1, Fn, np.nan) + + # new or unstable + Fns_unstab = np.where(Lab == 0, Fn, np.nan) + + ax.set_title("Stabilisation Chart") + ax.set_ylabel("Model Order") + ax.set_xlabel("Frequency [Hz]") + + if hide_poles: + x = Fns_stab.flatten(order="F") + y = np.array([i // len(Fns_stab) for i in range(len(x))]) * step + ax.plot(x, y, "go", markersize=7) + + if Fn_std is not None: + xerr = Fn_std.flatten(order="f") + + ax.errorbar(x, y, xerr=xerr, fmt="None", capsize=5, ecolor="gray") + + else: + x = Fns_stab.flatten(order="f") + y = np.array([i // len(Fns_stab) for i in range(len(x))]) * step + + x1 = Fns_unstab.flatten(order="f") + y1 = np.array([i // len(Fns_unstab) for i in range(len(x))]) * step + + ax.plot(x, y, "go", markersize=7, label="Stable pole") + ax.scatter(x1, y1, marker="o", s=4, c="r", label="Unstable pole") + + if Fn_std is not None: + xerr = abs(Fn_std).flatten(order="f") + + ax.errorbar( + x, y, xerr=xerr.flatten(order="f"), fmt="None", capsize=5, ecolor="gray" + ) + + ax.errorbar( + x1, y1, xerr=xerr.flatten(order="f"), fmt="None", capsize=5, ecolor="gray" + ) + + ax.legend(loc="lower center", ncol=2) + ax.set_ylim(ordmin, ordmax + 1) + + ax.grid() + if freqlim is not None: + ax.set_xlim(freqlim[0], freqlim[1]) + plt.tight_layout() + return fig, ax + + +# ----------------------------------------------------------------------------- + + +def cluster_plot( + Fn: np.ndarray, + Xi: np.ndarray, + Lab: np.ndarray, + ordmin: int = 0, + freqlim: typing.Optional[typing.Tuple] = None, + hide_poles: bool = True, +) -> typing.Tuple[plt.Figure, plt.Axes]: + """ + Plots the frequency-damping clusters of the identified poles. + + Parameters + ---------- + Fn : ndarray + An array containing the frequencies of poles for each model order and identification step. + Xi : ndarray + An array containing the damping ratios associated with the poles in `Fn`. + Lab : ndarray + Labels indicating whether each pole is stable (1) or unstable (0). + ordmin : int, optional + The minimum model order to be displayed on the plot. Default is 0. + freqlim : tuple of float, optional + The frequency limits for the x-axis as a tuple (min_freq, max_freq), by default None. + hide_poles : bool, optional + Whether to hide the unstable poles, by default True. + + Returns + ------- + tuple + fig : matplotlib.figure.Figure + The matplotlib figure object. + ax : matplotlib.axes.Axes + The axes object with the stabilization chart. + """ + # Stable pole + a = np.where(Lab == 1, Fn, np.nan) + aa = np.where(Lab == 1, Xi, np.nan) + + # new or unstable + b = np.where(Lab == 0, Fn, np.nan) + bb = np.where(Lab == 0, Xi, np.nan) + + fig, ax = plt.subplots(figsize=(8, 6), tight_layout=True) + ax.set_title("Frequency-damping clustering") + ax.set_ylabel("Damping") + ax.set_xlabel("Frequency [Hz]") + if hide_poles: + x = a.flatten(order="f") + y = aa.flatten(order="f") + ax.plot(x, y, "go", markersize=7, label="Stable pole") + + else: + x = a.flatten(order="f") + y = aa.flatten(order="f") + + x1 = b.flatten(order="f") + y1 = bb.flatten(order="f") + + ax.plot(x, y, "go", markersize=7, label="Stable pole") + + ax.scatter(x1, y1, marker="o", s=4, c="r", label="Unstable pole") + + ax.legend(loc="lower center", ncol=2) + + ax.grid() + if freqlim is not None: + ax.set_xlim(freqlim[0], freqlim[1]) + plt.tight_layout() + return fig, ax + + +# ----------------------------------------------------------------------------- + + +def svalH_plot( + H: np.ndarray, + br: int, + iter_n: int = None, + fig: typing.Optional[plt.Figure] = None, + ax: typing.Optional[plt.Axes] = None, +) -> typing.Tuple[plt.Figure, plt.Axes]: + """ + Plot the singular values of the Hankel matrix. + """ + if fig is None and ax is None: + fig, ax = plt.subplots(figsize=(8, 6), tight_layout=True) + + # SINGULAR VALUE DECOMPOSITION + U1, S1, V1_t = np.linalg.svd(H) + S1rad = np.sqrt(S1) + + ax.stem(S1rad, linefmt="k-") + + ax.set_title(f"Singular values plot, for block-rows = {br}") + ax.set_ylabel("Singular values") + ax.set_xlabel("Index number") + if iter_n is not None: + ax.set_xlim(-1, iter_n) + + ax.grid() + + return fig, ax + + +# ----------------------------------------------------------------------------- + + +# ============================================================================= +# PLOT GEO +# ============================================================================= + + +def plt_nodes( + ax: plt.Axes, + nodes_coord: np.ndarray, + alpha: float = 1.0, + color: str = "k", + initial_coord: np.ndarray = None, +) -> plt.Axes: + """ + Plots nodes coordinates in a 3D scatter plot on the provided axes. + + Parameters + ---------- + ax : matplotlib.axes.Axes + The axes object where the nodes will be plotted. This should be a 3D axes. + nodes_coord : ndarray + A 2D array with dimensions [number of nodes, 3], representing the coordinates (x, y, z) of each node. + alpha : float, optional + The alpha blending value, between 0 (transparent) and 1 (opaque). Default is 1. + color : str or list of str, optional + Color or list of colors for the nodes. Default is "k" (black). If 'cmap' is provided, initial_coord must be specified. + initial_coord : ndarray, optional + A 2D array with dimensions [number of nodes, 3], representing the initial coordinates (x, y, z) of each node. + Required if color is 'cmap'. + + Returns + ------- + matplotlib.axes.Axes + The modified axes object with the nodes plotted. + + Note + ----- + This function is designed to work with 3D plots and adds node representations to an existing 3D plot. + """ + if color == "cmap": + if initial_coord is None: + raise ValueError("initial_coord must be specified when color is 'cmap'") + + # Calculate distances from initial positions + distances = np.linalg.norm(nodes_coord - initial_coord, axis=1) + + # Normalize distances to the range [0, 1] + norm = plt.Normalize(vmin=np.min(distances), vmax=np.max(distances)) + cmap = plt.cm.plasma + + # Map distances to colors + colors = cmap(norm(distances)) + else: + colors = color + if isinstance(colors, np.ndarray) and colors.ndim > 1: + for iter in range(nodes_coord.shape[0]): + ax.scatter( + nodes_coord[iter, 0], + nodes_coord[iter, 1], + nodes_coord[iter, 2], + alpha=0.5, + color=matplotlib.colors.to_rgba(colors[iter, :]), + ) + else: + ax.scatter( + nodes_coord[:, 0], + nodes_coord[:, 1], + nodes_coord[:, 2], + alpha=alpha, + color=colors, + ) + return ax + + +def plt_lines( + ax: plt.Axes, + nodes_coord: np.ndarray, + lines: np.ndarray, + alpha: float = 1.0, + color: str = "k", + initial_coord: np.ndarray = None, +) -> plt.Axes: + """ + Plots lines between specified nodes in a 3D plot on the provided axes. + + Parameters + ---------- + ax : matplotlib.axes.Axes + The axes object where the lines will be plotted. This should be a 3D axes. + nodes_coord : ndarray + A 2D array with dimensions [number of nodes, 3], representing the coordinates + (x, y, z) of each node. + lines : ndarray + A 2D array with dimensions [number of lines, 2]. Each row represents a line, + with the two elements being indices into `nodes_coord` indicating the start + and end nodes of the line. + alpha : float, optional + The alpha blending value for the lines, between 0 (transparent) and 1 (opaque). + Default is 1. + color : str or list of str, optional + Color or list of colors for the lines. Default is "k" (black). If 'cmap' is provided, initial_coord must be specified. + initial_coord : ndarray, optional + A 2D array with dimensions [number of nodes, 3], representing the initial coordinates (x, y, z) of each node. + Required if color is 'cmap'. + + Returns + ------- + matplotlib.axes.Axes + The modified axes object with the lines plotted. + + Note + ----- + This function is designed to work with 3D plots and adds line representations between + nodes in an existing 3D plot. + """ + if color == "cmap": + if initial_coord is None: + raise ValueError("initial_coord must be specified when color is 'cmap'") + + # Calculate distances from initial positions + distances_start = np.linalg.norm( + nodes_coord[lines[:, 0]] - initial_coord[lines[:, 0]], axis=1 + ) + distances_end = np.linalg.norm( + nodes_coord[lines[:, 1]] - initial_coord[lines[:, 1]], axis=1 + ) + + # Calculate average distances + avg_distances = (distances_start + distances_end) / 2 + + # Normalize distances to the range [0, 1] + norm = plt.Normalize(vmin=np.min(avg_distances), vmax=np.max(avg_distances)) + cmap = plt.cm.plasma + + # Map average distances to colors + line_colors = cmap(norm(avg_distances)) + else: + line_colors = [color] * lines.shape[0] + + for ii in range(lines.shape[0]): + StartX, EndX = nodes_coord[lines[ii, 0]][0], nodes_coord[lines[ii, 1]][0] + StartY, EndY = nodes_coord[lines[ii, 0]][1], nodes_coord[lines[ii, 1]][1] + StartZ, EndZ = nodes_coord[lines[ii, 0]][2], nodes_coord[lines[ii, 1]][2] + ax.plot( + [StartX, EndX], + [StartY, EndY], + [StartZ, EndZ], + alpha=alpha, + color=line_colors[ii], + ) + + return ax + + +# ----------------------------------------------------------------------------- + + +def plt_surf( + ax: plt.Axes, + nodes_coord: np.ndarray, + surf: np.ndarray, + alpha: float = 0.5, + color: str = "cyan", + initial_coord: np.ndarray = None, +) -> plt.Axes: + """ + Plots a 3D surface defined by nodes and surface triangulation on the provided axes. + + Parameters + ---------- + ax : matplotlib.axes.Axes + The axes object where the surface will be plotted. This should be a 3D axes. + nodes_coord : ndarray + A 2D array with dimensions [number of nodes, 3], representing the coordinates (x, y, z) of each node. + surf : ndarray + A 2D array specifying the triangles that make up the surface. Each row represents a triangle, + with the three elements being indices into `nodes_coord` indicating the vertices of the triangle. + alpha : float, optional + The alpha blending value for the surface, between 0 (transparent) and 1 (opaque). Default is 0.5. + color : str, optional + Color for the surface. Default is "cyan". + + Returns + ------- + matplotlib.axes.Axes + The modified axes object with the 3D surface plotted. + + Note + ----- + This function is designed for plotting 3D surfaces in a 3D plot. It uses `matplotlib.tri.Triangulation` + for creating a triangulated surface. Ideal for visualizing complex surfaces or meshes in a 3D space. + """ + xy = nodes_coord[:, :2] + z = nodes_coord[:, 2] + triang = mtri.Triangulation(xy[:, 0], xy[:, 1], triangles=surf) + + if color == "cmap": + if initial_coord is None: + raise ValueError("initial_coord must be specified when color is 'cmap'") + + # Calculate distances from initial positions + distances = np.linalg.norm(nodes_coord - initial_coord, axis=1) + + # Normalize distances to the range [0, 1] + norm = plt.Normalize(vmin=np.min(distances), vmax=np.max(distances)) + cmap = plt.cm.plasma + + # Map distances to colors + colors = cmap(norm(distances)) + + # Loop through each triangle and plot + for triangle_indices in surf: + triangle_xy = xy[triangle_indices] + triangle_z = z[triangle_indices] + triangle_colors = colors[triangle_indices].mean(axis=0) + triangle = mtri.Triangulation( + triangle_xy[:, 0], triangle_xy[:, 1], triangles=[[0, 1, 2]] + ) + ax.plot_trisurf(triangle, triangle_z, facecolor=triangle_colors, alpha=0.4) + else: + ax.plot_trisurf(triang, z, alpha=alpha, color=color) + + return ax + + +# ----------------------------------------------------------------------------- + + +def plt_quiver( + ax: plt.Axes, + nodes_coord: np.ndarray, + directions: np.ndarray, + scaleF: float = 2, + color: str = "red", + names: typing.Optional[typing.List[str]] = None, + color_text: str = "red", + method: str = "1", +) -> plt.Axes: + """ + Plots vectors (arrows) on a 3D plot to represent directions and magnitudes at given node coordinates. + + Parameters + ---------- + ax : matplotlib.axes.Axes + The axes object where the vectors will be plotted. This should be a 3D axes. + nodes_coord : ndarray + A 2D array with dimensions [number of nodes, 3], representing the coordinates (x, y, z) + of each node. + directions : ndarray + A 2D array with the same shape as `nodes_coord`, representing the direction and magnitude vectors + originating from the node coordinates. + scaleF : float, optional + Scaling factor for the magnitude of the vectors. Default is 2. + color : str, optional + Color of the vectors. Default is "red". + names : list of str, optional + Names or labels for each vector. If provided, labels are placed at the end of each vector. + Default is None. + color_text : str, optional + Color of the text labels. Default is "red". + + Returns + ------- + matplotlib.axes.Axes + The modified axes object with the vectors plotted. + + Note + ----- + Designed to work with 3D plots, allowing for the visualization of vector fields or directional data. + `directions` array determines the direction and magnitude of the arrows, while `nodes_coord` specifies + their starting points. + """ + Points_f = nodes_coord + directions * scaleF + xs0, ys0, zs0 = nodes_coord[:, 0], nodes_coord[:, 1], nodes_coord[:, 2] + xs1, ys1, zs1 = Points_f[:, 0], Points_f[:, 1], Points_f[:, 2] + if method == "1": + ax.quiver( + xs0, + ys0, + zs0, + (xs1 - xs0), + (ys1 - ys0), + (zs1 - zs0), + length=scaleF, + color=color, + ) + elif method == "2": + for ii in range(len(xs0)): + ax.plot( + [xs0[ii], xs1[ii]], + [ys0[ii], ys1[ii]], + [zs0[ii], zs1[ii]], + c=color, + linewidth=2, + ) + else: + raise AttributeError("method must be either '1' or '2'!") + + if names is not None: + for ii, nam in enumerate(names): + ax.text( + Points_f[ii, 0], + Points_f[ii, 1], + Points_f[ii, 2], + f"{nam}", + color=color_text, + ) + return ax + + +# ----------------------------------------------------------------------------- + + +def set_ax_options( + ax: plt.Axes, + bg_color: str = "w", + remove_fill: bool = True, + remove_grid: bool = True, + remove_axis: bool = True, + add_orig: bool = True, + scaleF: float = 1, +) -> plt.Axes: + """ + Configures various display options for a given matplotlib 3D axes object. + + Parameters + ---------- + ax : matplotlib.axes._subplots.Axes3DSubplot + The 3D axes object to be configured. + bg_color : str, optional + Background color for the axes. Default is "w" (white). + remove_fill : bool, optional + If True, removes the fill from the axes panes. Default is True. + remove_grid : bool, optional + If True, removes the grid from the axes. Default is True. + remove_axis : bool, optional + If True, turns off the axis lines, labels, and ticks. Default is True. + add_orig : bool, optional + If True, adds origin lines for the x, y, and z axes in red, green, and blue, respectively. + Default is True. + + Returns + ------- + matplotlib.axes._subplots.Axes3DSubplot + The modified 3D axes object with the applied configurations. + + Note + ----- + Customizes the appearance of 3D plots. Controls background color, fill, grid, and axis visibility. + """ + # avoid auto scaling of axis + ax.set_aspect("equal") + # Set backgroung color to white + ax.xaxis.pane.set_edgecolor(bg_color) + ax.yaxis.pane.set_edgecolor(bg_color) + ax.zaxis.pane.set_edgecolor(bg_color) + if remove_fill: + # Remove fill + ax.xaxis.pane.fill = False + ax.yaxis.pane.fill = False + ax.zaxis.pane.fill = False + if remove_grid: + # Get rid of the grid + ax.grid(False) + if remove_axis: + # Turn off axis + ax.set_axis_off() + if add_orig: + Or = (0, 0, 0) + CS = np.asarray( + [[0.4 * scaleF, 0, 0], [0, 0.4 * scaleF, 0], [0, 0, 0.4 * scaleF]] + ) + _colours = ["r", "g", "b"] + _axname = ["x", "y", "z"] + for ii, _col in enumerate(_colours): + ax.plot([Or[0], CS[ii, 0]], [Or[1], CS[ii, 1]], [Or[2], CS[ii, 2]], c=_col) + # Q = ax.quiver( + # Or[0], Or[1], Or[2], (CS[ii,0] - Or[0]), (CS[ii,1] - Or[1]), (CS[ii,2] - Or[2]), + # color=_col,) + ax.text( + (CS[ii, 0] - Or[0]), + (CS[ii, 1] - Or[1]), + (CS[ii, 2] - Or[2]), + f"{_axname[ii]}", + color=_col, + ) + + return ax + + +# ----------------------------------------------------------------------------- + + +def set_view(ax: plt.Axes, view: str) -> plt.Axes: + """ + Sets the viewing angle of a 3D matplotlib axes object based on a predefined view option. + + Parameters + ---------- + ax : matplotlib.axes.Axes + The 3D axes object whose view angle is to be set. + view : str + A string specifying the desired view. Options include "3D", "xy", "xz", and "yz". + + Returns + ------- + matplotlib.axes.Axes + The modified axes object with the new view angle set. + + Raises + ------ + ValueError + If the 'view' parameter is not one of the specified options. + + Note + ----- + Useful for quickly setting the axes to a standard viewing angle, especially in 3D visualizations. + View options: "3D" (azimuth -60, elevation 30), "xy" (top-down), "xz" (side, along y-axis), + "yz" (side, along x-axis). + """ + if view == "3D": + azim = -60 + elev = 30 + ax.view_init(azim=azim, elev=elev) + elif view == "xy": + azim = 0 + elev = 90 + ax.view_init(azim=azim, elev=elev) + elif view == "xz": + azim = 90 + elev = 0 + ax.view_init(azim=azim, elev=elev) + elif view == "yz": + azim = 0 + elev = 0 + ax.view_init(azim=azim, elev=elev) + else: + raise ValueError(f"view must be one of (3D, xy, xz, yz), your input was '{view}'") + return ax + + +# ============================================================================= +# PLOT DATA +# ============================================================================= + + +def plt_data( + data: np.ndarray, + fs: float, + nc: int = 1, + names: typing.Optional[typing.List[str]] = None, + unit: str = "unit", + show_rms: bool = False, +) -> typing.Tuple[plt.Figure, np.ndarray]: + """ + Plots time series data for multiple channels, with an option to include the Root Mean Square (RMS) + of each signal. + + Parameters + ---------- + data : ndarray + A 2D array with dimensions [number of data points, number of channels], representing signal data + for multiple channels. + fs : float + Sampling frequency. + nc : int, optional + Number of columns for subplots, indicating how many subplots per row to display. Default is 1. + names : list of str, optional + Names of the channels, used for titling each subplot if provided. Default is None. + unit : str, optional + The unit to display on the y-axis label. Default is "unit". + show_rms : bool, optional + If True, includes the RMS of each signal on the corresponding subplot. Default is False. + + Returns + ------- + fig : matplotlib.figure.Figure + The matplotlib figure object. + axs : array of matplotlib.axes.Axes + An array of axes objects for the generated subplots. + + Note + ----- + Plots each channel in its own subplot for comparison. Supports multiple columns and adjusts the number of + rows based on channels and columns. + If `show_rms` is True, the RMS value of each signal is plotted as a constant line. + """ + # show RMS of signal + if show_rms is True: + a_rmss = np.array( + [ + np.sqrt(1 / len(data[:, _kk]) * np.sum(data[:, _kk] ** 2)) + for _kk in range(data.shape[1]) + ] + ) + + Ndat = data.shape[0] # number of data points + Nch = data.shape[1] # number of channels + timef = Ndat / fs # final time value + time = np.linspace(0, timef - 1 / fs, Ndat) # time array + + nr = round(Nch / nc) # number of rows in the subplot + fig, axs = plt.subplots( + figsize=(8, 6), nrows=nr, ncols=nc, sharex=True, sharey=True, tight_layout=True + ) + fig.suptitle("Time Histories of all channels") + + kk = 0 # iterator for the dataset + for ii in range(nr): + # if there are more than one columns + if nc != 1: + # loop over the columns + for jj in range(nc): + ax = axs[ii, jj] + ax.grid() + try: + # while kk < data.shape[1] + ax.plot(time, data[:, kk], c="k") + if names is not None: + ax.set_title(f"{names[kk]}") + if ii == nr - 1: + ax.set_xlabel("time [s]") + if jj == 0: + ax.set_ylabel(f"{unit}") + if show_rms is True: + ax.plot( + time, + np.repeat(a_rmss[kk], len(time)), + label=f"arms={a_rmss[kk][0]:.3f}", + c="r", + ) + ax.legend() + except Exception as e: + logger.exception(e) + + kk += 1 + # if there is only 1 column + else: + ax = axs[ii] + ax.plot(time, data[:, kk], c="k") + if names is not None: + ax.set_title(f"{names[kk]}") + if ii == nr - 1: + ax.set_xlabel("time [s]") + if show_rms is True: + ax.plot( + time, + np.repeat(a_rmss[kk], len(time)), + label=f"arms={a_rmss[kk]:.3f}", + c="r", + ) + ax.legend() + ax.set_ylabel(f"{unit}") + kk += 1 + # ax.grid() + plt.tight_layout() + + return fig, ax + + +# ----------------------------------------------------------------------------- + + +def plt_ch_info( + data: np.ndarray, + fs: float, + nxseg: int = 1024, + freqlim: typing.Optional[typing.Tuple] = None, + logscale: bool = False, + ch_idx: typing.Union[int, typing.List[int], str] = "all", + unit: str = "unit", +) -> typing.Tuple[plt.Figure, np.ndarray]: + """ + Plot channel information including time history, normalised auto-correlation, + power spectral density (PSD), probability density function, and a normal + probability plot for each channel in the data. + + Parameters + ---------- + data : ndarray + The input signal data. + fs : float + The sampling frequency of the input data in Hz. + nxseg : int, optional + The number of points per segment. + freqlim : tuple of float, optional + The frequency limits (min, max) for the PSD plot. If None, the full frequency range is used. + Default is None. + logscale : bool, optional + If True, the PSD plot will be in log scale (decibel). Otherwise, it will be in linear scale. + Default is False. + ch_idx : int, list of int, or "all", optional + The index (indices) of the channel(s) to plot. If "all", information for all channels is plotted. + Default is "all". + unit : str, optional + The unit of the input data for labelling the PSD plot. Default is "unit". + + Returns + ------- + fig : matplotlib.figure.Figure + The figure object containing all the plots. + axes : list of matplotlib.axes.Axes + The list of axes objects corresponding to each subplot. + + Note + ----- + This function is designed to provide a comprehensive overview of the signal characteristics for one or + multiple channels of a dataset. It plots the time history, normalised auto-correlation, PSD, probability + density function, and a normal probability plot for each specified channel. + """ + if ch_idx != "all": + data = data[:, ch_idx] + + ndat, nch = data.shape + + figs = [] + axs = [] + for ii in range(nch): + fig = plt.figure(figsize=(8, 6), layout="constrained") + spec = fig.add_gridspec(3, 2) + + # select channel + x = data[:, ii] + + # Normalize data + x = x - np.mean(x) + x = x / np.std(x) + sorted_x = np.sort(x) + n = len(x) + y = np.arange(1, n + 1) / n + + # Adjusted axis limits + xlim = max(abs(sorted_x.min()), abs(sorted_x.max())) + ylim = max( + abs(np.sort(np.random.randn(n)).min()), abs(np.sort(np.random.randn(n)).max()) + ) + maxlim = np.max((xlim, ylim)) + + # Plot 1: Time History + ax0 = fig.add_subplot(spec[0, :]) + ax0.plot(np.linspace(0, len(x) / fs, len(x)), x, c="k") + ax0.set_xlabel("Time [s]") + ax0.set_title("Time History") + ax0.set_ylabel("Unit") + ax0.grid() + + # Plot 2: Normalised auto-correlation + ax10 = fig.add_subplot(spec[1, 0]) + # R_i = np.array([ 1/(ndat - kk) * np.dot(x[:ndat-kk], x[kk:].T) for kk in range(nxseg)]) + R_i = signal.correlate(x, x, mode="full")[len(x) - 1 : len(x) + nxseg - 1] + R_i /= np.max(R_i) + ax10.plot(np.linspace(0, len(R_i) / fs, len(R_i)), R_i, c="k") + ax10.set_xlabel("Time [s]") + ax10.set_ylabel("Norm. auto-corr.") + ax10.set_title("Normalised auto-correlation") + ax10.grid() + + # Plot 3: PSD + freq, psd = signal.welch( + x, + fs, + nperseg=nxseg, + noverlap=nxseg * 0.5, + window="hann", + ) + ax20 = fig.add_subplot(spec[2, 0]) + if logscale is True: + ax20.plot(freq, 10 * np.log10(psd), c="k") + ax20.set_ylabel(f"dB rel. to {unit}") + elif logscale is False: + ax20.plot(freq, np.sqrt(psd), c="k") + ax20.set_ylabel(rf"${unit}^2 / Hz$") + if freqlim is not None: + ax20.set_xlim(freqlim[0], freqlim[1]) + ax20.set_xlabel("Frequency [Hz]") + ax20.set_title("PSD") + ax20.grid() + + # Plot 4: Density function + ax11 = fig.add_subplot(spec[1, 1]) + xm = min(abs(min(sorted_x)), abs(max(sorted_x))) + dx = nxseg * xm / n + xi = np.arange(-xm, xm + dx, dx) + Fi = interp1d(sorted_x, y, kind="linear", fill_value="extrapolate")(xi) + F2 = Fi[1:] + F1 = Fi[:-1] + f = (F2 - F1) / dx + xf = (xi[1:] + xi[:-1]) / 2 + ax11.plot( + xf, + f, + "k", + ) + ax11.set_title("Probability Density Function") + ax11.set_xlabel( + "Normalised data", + ) + ax11.set_ylabel("Probability") + ax11.set_xlim(-xlim, xlim) + ax11.grid() + + # Plot 5: Normal probability plot + ax21 = fig.add_subplot(spec[2, 1]) + np.random.seed(0) + xn = np.random.randn(n) + sxn = np.sort(xn) + ax21.plot(sorted_x, sxn, "k+", markersize=5) + ax21.set_title( + "Normal probability plot", + ) + ax21.set_xlabel( + "Normalised data", + ) + ax21.set_ylabel( + "Gaussian axis", + ) + ax21.grid() + ax21.set_xlim(-maxlim, maxlim) + ax21.set_ylim(-maxlim, maxlim) + + if ch_idx != "all": + fig.suptitle(f"Info plot channel nr.{ch_idx[ii]}") + else: + fig.suptitle(f"Info plot channel nr.{ii}") + figs.append(fig) + axs.append([ax0, ax10, ax20, ax11, ax21]) + # return fig, [ax0, ax10, ax20, ax11, ax21] + return figs, axs + + +# ----------------------------------------------------------------------------- + + +# Short time Fourier transform - SPECTROGRAM +def STFT( + data: np.ndarray, + fs: float, + nxseg: int = 512, + pov: float = 0.9, + win: str = "hann", + freqlim: typing.Optional[typing.Tuple] = None, + ch_idx: typing.Union[int, typing.List[int], str] = "all", +) -> typing.Tuple[plt.Figure, np.ndarray]: + """ + Perform the Short Time Fourier Transform (STFT) to generate spectrograms for given signal data. + + This function computes the STFT for each channel in the signal data, visualising the frequency content + of the signal over time. It allows for the selection of specific channels and customisation of the + STFT computation parameters. + + Parameters + ---------- + data : ndarray + The input signal data. + fs : float + The sampling frequency of the input data in Hz. + nxseg : int, optional + The number of points per segment for the STFT. Default is 512. + pov : float, optional + The proportion of overlap between segments, expressed as a value between 0 and 1. Default is 0.9. + win : str, optional + The type of window function to apply. Default is "hann". + freqlim : tuple of float, optional + The frequency limits (minimum, maximum) for the frequency axis of the spectrogram. If None, + the full frequency range is used. Default is None. + ch_idx : int, list of int, or "all", optional + The index (indices) of the channel(s) to compute the STFT for. If "all", the STFT for all + channels is computed. Default is "all". + + Returns + ------- + figs : list of matplotlib.figure.Figure + The list of figure objects created, each corresponding to a channel in the input data. + axs : list of matplotlib.axes.Axes + The list of Axes objects corresponding to each figure, used for plotting the spectrograms. + + Notes + ----- + The function visualises the magnitude of the STFT, showing how the frequency content of the signal + changes over time. This is useful for analysing non-stationary signals. The function returns the + figures and axes for further customisation or display. + """ + if ch_idx != "all": + data = data[:, ch_idx] + + ndat, nch = data.shape + figs = [] + axs = [] + for ii in range(nch): + # select channel + ch = data[:, ii] + fig = plt.figure(figsize=(8, 6)) + ax = fig.add_subplot() + ax.set_title(f"STFT Magnitude for channel nr.{ii+1}") + ax.set_xlabel("Time [sec]") + ax.set_ylabel("Frequency [Hz]") + # nxseg = w_T*fs + noverlap = nxseg * pov + freq, time, Sxx = signal.stft( + ch, fs, window=win, nperseg=nxseg, noverlap=noverlap + ) + if freqlim is not None: + idx1 = np.argmin(abs(freq - freqlim[0])) + idx2 = np.argmin(abs(freq - freqlim[1])) + + freq = freq[idx1:idx2] + Sxx = Sxx[idx1:idx2] + ax.pcolormesh(time, freq, np.abs(Sxx)) + plt.tight_layout() + figs.append(fig) + axs.append(ax) + return figs, axs + + +# ----------------------------------------------------------------------------- + + +def plot_mac_matrix( + array1, array2, colormap="plasma", ax=None +) -> typing.Tuple[plt.Figure, plt.Axes]: + """ + Compute and plot the MAC matrix between the columns of two 2D arrays. + + Parameters + ---------- + array1 : np.ndarray + The first 2D array with shape (n_modes, n_dofs). + array2 : np.ndarray + The second 2D array with shape (n_modes, n_dofs). + colormap : str, optional + The colormap to use for the plot. Default is 'plasma'. + ax : matplotlib.axes.Axes, optional + The axes object to plot on. If None, a new figure and axes will be created. Default is None. + + Returns + ------- + fig : matplotlib.figure.Figure + The matplotlib figure object. + ax : matplotlib.axes.Axes + The matplotlib axes object. + """ + # Check if there are more than 1 column vector in the input arrays + if array1.shape[1] < 2 or array2.shape[1] < 2: + raise ValueError("Each input array must have more than one column vector.") + + mac_matr = MAC(array1, array2) + + if ax is None: + fig, ax = plt.subplots(figsize=(8, 6), tight_layout=True) + else: + fig = ax.figure + + cax = ax.imshow(mac_matr, cmap=colormap, aspect="auto") + fig.colorbar(cax, ax=ax, label="MAC value") + + n_cols1 = array1.shape[1] + n_cols2 = array2.shape[1] + x_labels = [f"mode nr. {i+1}" for i in range(n_cols1)] + y_labels = [f"mode nr. {i+1}" for i in range(n_cols2)] + + ax.set_xticks(np.arange(n_cols1)) + ax.set_xticklabels(x_labels, rotation=45) + ax.set_yticks(np.arange(n_cols2)) + ax.set_yticklabels(y_labels) + + ax.set_xlabel("Array 1") + ax.set_ylabel("Array 2") + ax.set_title("MAC Matrix") + + return fig, ax + + +# ----------------------------------------------------------------------------- + + +def plot_mode_complexity(mode_shape): + """ + Plot the complexity of a mode shape. + """ + + # Get angles (in radians) and magnitudes + angles = np.angle(mode_shape) + magnitudes = np.abs(mode_shape) + + # Create a polar plot + fig, ax = plt.subplots(subplot_kw={"projection": "polar"}, figsize=(6, 6)) + ax.set_theta_zero_location("E") # Set 0 degrees to East + ax.set_theta_direction(1) # Counterclockwise + ax.set_rmax(1.1) # Set maximum radius slightly above 1 for clarity + ax.grid(True, linestyle="--", alpha=0.5) + + # Plot arrows using annotate with fixed head size + for angle, magnitude in zip(angles, magnitudes): + ax.annotate( + "", + xy=(angle, magnitude), + xytext=(angle, 0), + arrowprops=dict( + facecolor="blue", + edgecolor="blue", + arrowstyle="-|>", + linewidth=1.5, + mutation_scale=20, # Controls the size of the arrowhead + ), + ) + # Highlight directions (0° and 180°) + principal_angles = [0, np.pi] + for pa in principal_angles: + ax.plot([pa, pa], [0, 1.1], color="red", linestyle="--", linewidth=1) + + ax.set_yticklabels([]) + # Add title + ax.set_title( + "Mode Shape Complexity Plot", va="bottom", fontsize=14, fontweight="bold" + ) + plt.tight_layout() + plt.show() diff --git a/src/pyoma2/functions/plscf.py b/src/pyoma2/functions/plscf.py new file mode 100644 index 0000000..79d0831 --- /dev/null +++ b/src/pyoma2/functions/plscf.py @@ -0,0 +1,413 @@ +""" +poly-reference Least Square Complex Frequency (pLSCF) Utility Functions module. +Part of the pyOMA2 package. +Authors: +Dag Pasca +""" + +import itertools +import logging +import typing + +import numpy as np + +# import matplotlib.pyplot as plt +from tqdm import tqdm, trange + +np.seterr(divide="ignore", invalid="ignore") +logger = logging.getLogger(__name__) + +# ============================================================================= +# FUNZIONI PolyMAX +# ============================================================================= + + +def pLSCF( + Sy: np.ndarray, dt: float, ordmax: int, sgn_basf: int = -1.0 +) -> typing.Tuple[typing.List[np.ndarray], typing.List[np.ndarray]]: + """ + Perform the poly-reference Least Square Complex Frequency (pLSCF) algorithm. + + Parameters + ---------- + Sy : numpy.ndarray + Spectral density matrix of the system. + dt : float + Time step of the measurement data. + ordmax : int + Maximum model order for the algorithm. + sgn_basf : int, optional + Sign of the basis function, -1 for 'LO' and 1 for 'HI', by default -1. + + Returns + ------- + tuple of list numpy.ndarray + - Ad : The denominator polynomial coefficients of the transfer function. + - Bn : The numerator polynomial coefficients of the transfer function. + """ + if sgn_basf == -1: + constr = "LO" + if sgn_basf == 1: + constr = "HI" + + Nch = Sy.shape[1] + Nref = Sy.shape[0] + Nf = Sy.shape[2] + + fs = 1 / dt + freq = np.linspace(0.0, fs / 2, Nf) + omega = 2 * np.pi * freq + Omega = np.exp(sgn_basf * 1j * omega * dt) + + Ad = [] + Bn = [] + for n in trange(1, ordmax + 1): + M = np.zeros(((n + 1) * Nch, (n + 1) * Nch)) # iNchzializzo + Xo = np.array([Omega**i for i in range(n + 1)]).T + Xoh = Xo.conj().T + Ro = np.real(np.dot(Xoh, Xo)) # 4.163 + So_s = [] + for o in range(0, Nref): # loop on channels + Syo = Sy[o, :, :] + Yo = np.array([-np.kron(xo, Hoi) for xo, Hoi in zip(Xo, Syo.T)]) + So = np.real(np.dot(Xoh, Yo)) # 4.164 + To = np.real(np.dot(Yo.conj().T, Yo)) # 4.165 + # M += To - np.dot(np.dot(So.T, np.linalg.inv(Ro)), So) + M += To - np.dot(So.T.conj(), np.linalg.solve(Ro, So)) + So_s.append(So) + + if constr == "LO": + alpha = np.r_[ + np.eye(Nch), + np.linalg.solve( + -M[Nch : (n + 1) * Nch, Nch : (n + 1) * Nch], + M[Nch : (n + 1) * Nch, 0:Nch], + ), + ] + elif constr == "HI": + alpha = np.r_[ + np.linalg.solve( + -M[0 : n * Nch, 0 : n * Nch], M[0 : n * Nch, n * Nch : (n + 1) * Nch] + ), + np.eye(Nch), + ] + + A_den = alpha.reshape((-1, Nch, Nch)) + beta = np.array( + [np.linalg.solve(-Ro, np.dot(So_s[o], alpha)) for o in range(Nref)] + ) + B_num = np.moveaxis(beta, 1, 0) + Ad.append(A_den) + Bn.append(B_num) + + return Ad, Bn + + +def pLSCF_poles( + Ad: np.ndarray, Bn: np.ndarray, dt: float, methodSy: str, nxseg: int +) -> typing.Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]: + """ + Extract poles from the pLSCF algorithm results. + + Parameters + ---------- + Ad : numpy.ndarray + Denominator polynomial coefficients from pLSCF. + Bn : numpy.ndarray + Numerator polynomial coefficients from pLSCF. + dt : float + Time step of the measurement data. + methodSy : str + Method used for the PSD estimation (either "per" or "cor") + nxseg : int + Number of segments used in the algorithm. + + Returns + ------- + tuple of numpy.ndarray + - Fns : Natural frequencies from the pLSCF analysis. + - Xis : Damping ratios from the pLSCF analysis. + - Phis : Mode shapes from the pLSCF analysis. + - Lambdas : Complex poles from the pLSCF analysis. + """ + Fns = [] + Xis = [] + Phis = [] + Lambds = [] + for ii in range(len(Ad)): + A_den = Ad[ii] + B_num = Bn[ii] + A, C = rmfd2ac(A_den, B_num) + + fn, xi, phi, lam_c = ac2mp_poly(A, C, dt, methodSy, nxseg) + fn[fn == np.inf] = np.nan + Fns.append(fn) + Xis.append(xi) + Phis.append(phi) + Lambds.append(lam_c) + # Transform each array in list + Fns = [list(c) for c in Fns] + Xis = [list(c) for c in Xis] + Phi1 = [list(c) for c in Phis] + Lambds = [list(c) for c in Lambds] + + # Fill with nan values so to get same size and then convert back to array + Fns = np.array(list(itertools.zip_longest(*Fns, fillvalue=np.nan))) + Xis = np.array(list(itertools.zip_longest(*Xis, fillvalue=np.nan))) + Lambds = np.array(list(itertools.zip_longest(*Lambds, fillvalue=np.nan))) + Phi1 = [] + for phi in Phis: + phi1 = np.full((len(Phis[-1]), phi.shape[1]), np.nan).astype(complex) + phi1[: len(phi)] = phi + Phi1.append(phi1) + + Phi1 = np.array(Phi1) + Phi1 = np.moveaxis(Phi1, 1, 0) + return Fns, Xis, Phi1, Lambds + + +def rmfd2ac(A_den: np.ndarray, B_num: np.ndarray) -> typing.Tuple[np.ndarray, np.ndarray]: + """ + Convert Right Matrix Fraction Description (RMFD) to state-space representation. + + Parameters + ---------- + A_den : numpy.ndarray + Denominator matrix of the RMFD. + B_num : numpy.ndarray + Numerator matrix of the RMFD. + + Returns + ------- + tuple of numpy.ndarray + - A : State matrix of the system. + - C : Output matrix of the system. + """ + n, l_, m = B_num.shape + A = np.zeros((n * m, n * m)) + A[m:, :-m] = np.eye((n - 1) * m) + C = np.zeros((l_, n * m)) + Bn_last = B_num[-1] + Ad_last = A_den[-1] + for i, (Adi, Bni) in enumerate(zip(A_den[:-1][::-1], B_num[:-1][::-1])): + prod = np.linalg.solve(Ad_last, Adi) + A[:m, i * m : (i + 1) * m] = -prod + C[:, i * m : (i + 1) * m] = Bni - np.dot(Bn_last, prod) + return A, C + + +def ac2mp_poly( + A: np.ndarray, C: np.ndarray, dt: float, methodSy: str, nxseg: int +) -> typing.Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]: + """ + Convert state-space representation to modal parameters. + + Parameters + ---------- + A : numpy.ndarray + State matrix of the system. + C : numpy.ndarray + Output matrix of the system. + dt : float + Time step or sampling interval. + methodSy : str + Method used for PSD estimation. + nxseg : int + Number of segments used in the algorithm. + + Returns + ------- + tuple of numpy.ndarray + - fn : Natural frequencies in Hz. + - xi : Damping ratios. + - phi : Complex mode shapes. + - lam_c : Complex poles. + """ + Nch = C.shape[0] + lam_d, AuVett = np.linalg.eig(A) + lambd = (np.log(lam_d)) * (1 / dt) + # replace with nan every value with positive real part + lam_c = np.where(np.real(lambd) > 0, np.nan, lambd) + # also for the part fact + Q = np.array( + [ + np.where( + np.real(lambd[ii]) > 0, np.repeat(np.nan, AuVett.shape[1]), AuVett[:, ii] + ) + for ii in range(len(lam_c)) + ] + ).T + # correct for exponential window + if methodSy == "cor": + tau = -(nxseg - 1) / np.log(0.01) + lam_c = lam_c - 1 / tau + fn = abs(lam_c) / (2 * np.pi) # natural frequencies + xi = -((np.real(lam_c)) / (abs(lam_c))) # damping ratios + # Complex mode shapes + phi = np.dot(C, Q) + # normalised (unity displacement) + phi = np.array( + [phi[:, ii] / phi[np.argmax(abs(phi[:, ii])), ii] for ii in range(phi.shape[1])] + ).reshape(-1, Nch) + return fn, xi, phi, lam_c + + +# ----------------------------------------------------------------------------- + + +def pLSCF_mpe( + sel_freq: typing.List[float], + Fn_pol: np.ndarray, + Xi_pol: np.ndarray, + Phi_pol: np.ndarray, + order: typing.Union[int, typing.List[int], str] = "find_min", + Lab: np.ndarray = None, + deltaf: float = 0.05, + rtol: float = 1e-2, +) -> typing.Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]: + """ + Extract modal parameters using the pLSCF method for selected frequencies. + + Parameters + ---------- + sel_freq : list of float + Selected frequencies for modal parameter extraction. + Fn_pol : numpy.ndarray + Natural frequencies obtained from the pLSCF method. + Xi_pol : numpy.ndarray + Damping ratios obtained from the pLSCF method. + Phi_pol : numpy.ndarray + Mode shapes obtained from the pLSCF method. + order : int, list of int, or 'find_min' + Model order for extraction. + Lab : numpy.ndarray, optional + Labels identifying stable poles. + deltaf : float, optional + Frequency bandwidth for searching poles, by default 0.05. + rtol : float, optional + Relative tolerance for frequency comparison, by default 1e-2. + + Returns + ------- + tuple of numpy.ndarray + - Fn : Extracted natural frequencies. + - Xi : Extracted damping ratios. + - Phi : Extracted mode shapes. + - order_out : Model order used for extraction. + """ + + # if order != "find_min" and type(order) != int and type(order) != list[int]: + # raise ValueError( + # f"The argument order must either be 'find_min' or be and integer, your input is {order}" + # ) + if order == "find_min" and Lab is None: + raise ValueError( + "When order ='find_min', one must also provide the Lab list for the poles" + ) + sel_xi = [] + sel_phi = [] + sel_freq1 = [] + # Loop through the frequencies given in the input list + logger.info("Extracting SSI modal parameters") + order_out = np.empty(len(sel_freq)) + for ii, fj in enumerate(tqdm(sel_freq)): + # ============================================================================= + # OPZIONE order = "find_min" + # here we find the minimum model order so to get a stable pole for every mode of interest + # ----------------------------------------------------------------------------- + if order == "find_min": + # keep only Stable pole + a = np.where(Lab == 7, Fn_pol, np.nan) + # find the limits for the search + limits = [(fj - deltaf, fj + deltaf) for fj in sel_freq] + # find poles between limits and append them to list + aas = [ + np.where(((a < limits[ii][1]) & (a > limits[ii][0])), a, np.nan) + for ii in range(len(sel_freq)) + ] + # ============================================================================= + # N.B if deltaf is too big and a +- limits includes also another frequency from + # sel_freq, then the method of adding the matrices together in the next loop + # wont work. + # DOVREI ESCLUDERE LE FREQUENZE CHE HANNO FORME MODALI DIVERSE (MAC<0.85?) + # RISPETTO AD UNA FORMA DI RIFERIMENTO FORNITA + # ============================================================================= + # then loop through list + aa = 0 + for bb in aas: + # transform nan into 0 (so to be able to add the matrices together) + bb = np.nan_to_num(bb, copy=True, nan=0.0) + aa += bb + # convert back 0s to nans + aa = np.where(aa == 0, np.nan, aa) + + ii = 0 + check = np.array([False, False]) + while check.any() == False: # noqa: E712 + # try: + fn_at_ord_ii = aa[:, ii] + fn_at_ord_ii = np.unique(fn_at_ord_ii) + # remove nans + fn_at_ord_ii = fn_at_ord_ii[~np.isnan(fn_at_ord_ii)] + + if fn_at_ord_ii.shape[0] == len(sel_freq): + check = np.isclose(fn_at_ord_ii, sel_freq, rtol=rtol) + else: + pass + if ii == aa.shape[1] - 1: + logger.warning("Could not find any values") + break + ii += 1 + # except: + # pass + ii -= 1 # remove last iteration to find the correct index + + sel_freq1 = fn_at_ord_ii + sel_xi = [] + sel_phi = [] + b = aa[:, ii] + c = b[~np.isnan(b)] + if c.any(): + for fj in sel_freq1: + r_ind = np.nanargmin(np.abs(b - fj)) + sel_xi.append(Xi_pol[r_ind, ii]) + sel_phi.append(Phi_pol[r_ind, ii, :]) + order_out = ii + # ============================================================================= + # OPZIONE 2 order = int + # ----------------------------------------------------------------------------- + elif isinstance(order, int): + sel = np.nanargmin(np.abs(Fn_pol[:, order] - fj)) + fns_at_ord_ii = Fn_pol[:, order][sel] + check = np.isclose(fns_at_ord_ii, sel_freq, rtol=rtol) + if not check.any(): + logger.warning("Could not find any values") + order_out = order + else: + sel_freq1.append(Fn_pol[:, order][sel]) + sel_xi.append(Xi_pol[:, order][sel]) + sel_phi.append(Phi_pol[:, order][sel, :]) + order_out = order + # ============================================================================= + # OPZIONE 3 order = list[int] + # ----------------------------------------------------------------------------- + elif isinstance(order, list): + sel = np.nanargmin(np.abs(Fn_pol[:, order[ii]] - fj)) + fns_at_ord_ii = Fn_pol[:, order[ii]][sel] + check = np.isclose(fns_at_ord_ii, sel_freq, rtol=rtol) + if not check.any(): + logger.warning("Could not find any values") + order_out[ii] = order[ii] + else: + sel_freq1.append(Fn_pol[:, order[ii]][sel]) + sel_xi.append(Xi_pol[:, order[ii]][sel]) + sel_phi.append(Phi_pol[:, order[ii]][sel, :]) + order_out[ii] = order[ii] + else: + raise ValueError('order must be either of type(int) or "find_min"') + logger.debug("Done!") + + Fn = np.array(sel_freq1) + Phi = np.array(sel_phi).T + Xi = np.array(sel_xi) + return Fn, Xi, Phi, order_out diff --git a/src/pyoma2/functions/ssi.py b/src/pyoma2/functions/ssi.py new file mode 100644 index 0000000..745a2a1 --- /dev/null +++ b/src/pyoma2/functions/ssi.py @@ -0,0 +1,993 @@ +""" +Stochastic Subspace Identification (SSI) Utility Functions module. +Part of the pyOMA2 package. +Authors: +Dag Pasca +Angelo Aloisio +""" + +import logging +import typing + +import numpy as np +from scipy import linalg +from tqdm import tqdm, trange + +np.seterr(divide="ignore", invalid="ignore") +logger = logging.getLogger(__name__) + +# ============================================================================= +# FUNZIONI SSI +# ============================================================================= + + +def build_hank( + Y: np.ndarray, + Yref: np.ndarray, + br: int, + method: typing.Literal["cov", "cov_R", "dat"], + calc_unc: bool = False, + nb: int = 50, +) -> typing.Tuple[np.ndarray, typing.Optional[np.ndarray]]: + """ + Construct a Hankel matrix with optional uncertainty calculations. + + This function constructs a Hankel matrix using various methods, such as covariance-based + or data-driven approaches, and optionally computes uncertainty matrices. + + Parameters + ---------- + Y : np.ndarray + The primary data matrix with shape (number of channels, number of data points). + Yref : np.ndarray + The reference data matrix with shape (number of reference channels, number of data points). + br : int + The number of block rows in the Hankel matrix. + method : {'cov', 'cov_R', 'dat'} + The method for constructing the Hankel matrix: + - 'cov': Covariance-based. + - 'cov_R': Covariance-based with auto-correlations. + - 'dat': Data-driven. + calc_unc : bool, optional + Whether to calculate uncertainty matrices. Default is False. + nb : int, optional + The number of data blocks to use for uncertainty calculations. Default is 50. + + Returns + ------- + Hank : np.ndarray + The constructed Hankel matrix. + T : np.ndarray or None + The uncertainty matrix, returned only if `calc_unc` is True. None otherwise. + + Raises + ------ + AttributeError + If `method` is not one of {'cov', 'cov_R', 'dat'}, or if data is insufficient for + uncertainty calculation. + + Notes + ----- + Uncertainty calculations follow the approach detailed in [DOME13]_. + """ + + Ndat = Y.shape[1] # number of data points + l = Y.shape[0] # number of channels # noqa E741 (ambiguous variable name 'l') + r = Yref.shape[0] # number of reference channels + p = br - 1 # number of block rows + q = br # block columns + N = Ndat - p - q # length of the Hankel matrix + + T = None + logger.info("Assembling Hankel matrix method: %s...", method) + + if method == "cov": + # Future and past Output (Y^+ and Y^-) + Yf = np.vstack([Y[:, q + i : N + q + i] for i in range(p + 1)]) + Yp = np.vstack([Yref[:, (q - 1) + i : N + (q - 1) + i] for i in range(0, -q, -1)]) + + Hank = np.dot(Yf, Yp.T) / N + + # Uncertainty calculations + if calc_unc: + logger.info("... calculating cov(H)...") + Nb = N // nb # number of samples per segment + T = np.zeros(((p + 1) * q * l * r, nb)) # Square root of SIGMA_H + Hvec0 = Hank.reshape(-1, order="F") # vectorized Hankel + + for k in range(nb): + # Section 3.2 and 5.1 of DoMe13 + Yf_k = Yf[:, (k * Nb) : ((k + 1) * Nb)] + Yp_k = Yp[:, (k * Nb) : ((k + 1) * Nb)] + Hcov_k = np.dot(Yf_k, Yp_k.T) / Nb + + Hcov_vec_k = Hcov_k.reshape(-1, order="F") + if Hcov_vec_k.shape[0] < T.shape[0]: + raise AttributeError( + "Not enough data points per data block." + "Try reducing the number of data blocks, nb and/or the number of block-rows, br" + ) + else: + T[:, k] = (Hcov_vec_k - Hvec0) / np.sqrt(nb * (nb - 1)) + + elif method == "cov_R": + # Correlations + Ri = np.array( + [1 / (N) * np.dot(Y[:, k:], Yref[:, : Ndat - k].T) for k in range(p + q)] + ) + # Assembling the Toepliz matrix + Hank = np.vstack( + [np.hstack([Ri[i + j, :, :] for j in range(p + 1)]) for i in range(q)] + ) + + # Uncertainty calculations + if calc_unc is True: + logger.info("... calculating cov(H)...") + Nb = N // nb # number of samples per segment + T = np.zeros(((p + 1) * q * l * r, nb)) # Square root of SIGMA_H + Hvec0 = Hank.reshape(-1, 1, order="f") # vectorialised hankel + + for j in range(1, nb + 1): + print(j, nb) + Ri = np.array([]) + for k in range(p + q): + print(f"{k=}, {p=}, {q=}") + res = np.array( + [1 / (Nb) * np.dot(Y[:, : j * Nb - k], Yref[:, k : j * Nb].T)] + ) + Ri = np.vstack([Ri, res]) + Hcov_j = np.vstack( + [np.hstack([Ri[i + j, :, :] for j in range(p + 1)]) for i in range(q)] + ) + + Hcov_vec_j = Hcov_j.reshape(-1, 1, order="f") + if Hcov_vec_j.shape[0] < T.shape[0]: + raise AttributeError( + "Not enough data points per data block." + "Try reducing the number of data blocks, nb and/or the number of block-rows, br" + ) + else: + T[:, j - 1] = (Hcov_vec_j - Hvec0).flatten() / np.sqrt(nb * (nb - 1)) + + elif method == "dat": + # Efficient method for assembling the Hankel matrix for data-driven SSI + Yf = np.vstack([Y[:, q + i : N + q + i] for i in range(p + 1)]) + Yp = np.vstack([Yref[:, (q - 1) + i : N + (q - 1) + i] for i in range(0, -q, -1)]) + Ys = np.vstack((Yp / np.sqrt(N), Yf / np.sqrt(N))) + + R21 = np.linalg.qr(Ys.T, mode="r").T + Hank = R21[r * (p + 1) :, : r * (p + 1)] + + # Uncertainty calculations + if calc_unc: + logger.info("... calculating cov(H)...") + Nb = N // nb # number of samples per segment + T = np.zeros(((p + 1) * q * l * r, nb)) # Square root of SIGMA_H + Hvec0 = Hank.reshape(-1, order="F") # vectorized Hankel + + for j in range(nb): + Yf_k = Yf[:, j * Nb : (j + 1) * Nb] + Yp_k = Yp[:, j * Nb : (j + 1) * Nb] + Ys_k = np.vstack((Yp_k / np.sqrt(Nb), Yf_k / np.sqrt(Nb))) + + R = np.linalg.qr(Ys_k.T, mode="r").T + Hdat_j = R[r * (p + 1) :, : r * (p + 1)] + + Hdat_vec_j = Hdat_j.reshape(-1, order="F") + if Hdat_vec_j.shape[0] < T.shape[0]: + raise AttributeError( + "Not enough data points per data block." + "Try reducing the number of data blocks, nb and/or the number of block-rows, br" + ) + else: + T[:, j] = (Hdat_vec_j - Hvec0) / np.sqrt(nb * (nb - 1)) + + else: + raise AttributeError( + f'{method} is not a valid argument. "method" must be ' + f'one of: "cov", "cov_R", "dat"' + ) + + logger.debug("... Hankel and SIGMA_H Done!") + return Hank, T + + +# ----------------------------------------------------------------------------- + + +# Legacy +def SSI( + H: np.ndarray, br: int, ordmax: int, step: int = 1 +) -> typing.Tuple[np.ndarray, typing.List[np.ndarray], typing.List[np.ndarray]]: + """ + Perform System Identification using the Stochastic Subspace Identification (SSI) method. + + The SSI algorithm estimates system matrices and output influence matrices for increasing + model orders, based on a provided Hankel matrix. + + Parameters + ---------- + H : np.ndarray + The Hankel matrix of the system. + br : int + Number of block rows in the Hankel matrix. + ordmax : int + Maximum system order to consider for identification. + step : int, optional + Step size for increasing system order. Default is 1. + + Returns + ------- + Obs : np.ndarray + The observability matrix for the system. + A : list of np.ndarray + Estimated system matrices for various system orders. + C : list of np.ndarray + Estimated output influence matrices for various system orders. + + Notes + ----- + This is a classical implementation of SSI using the shift structure of the observability + matrix. For faster implementations, consider using `SSI_fast`. + """ + + Nch = int(H.shape[0] / (br)) + # SINGULAR VALUE DECOMPOSITION + U1, S1, V1_t = np.linalg.svd(H) + S1rad = np.sqrt(np.diag(S1)) + # initializing arrays + # Obs = np.dot(U1[:, :ordmax], S1rad[:ordmax, :ordmax]) # Observability matrix + # Con = np.dot(S1rad[:ordmax, :ordmax], V1_t[: ordmax, :]) # Controllability matrix + A = [] + C = [] + # loop for increasing order of the system + logger.info("SSI for increasing model order...") + for ii in trange(0, ordmax + 1, step): + Obs = np.dot(U1[:, :ii], S1rad[:ii, :ii]) # Observability matrix + # Con = np.dot(S1rad[:ii, :ii], V1_t[: ii, :]) # Controllability matrix + # System Matrix + A.append(np.dot(np.linalg.pinv(Obs[: Obs.shape[0] - Nch, :]), Obs[Nch:, :])) + # Output Influence Matrix + C.append(Obs[:Nch, :]) + # G = Con[:, Nch:] + logger.debug("... Done!") + return Obs, A, C + + +# ----------------------------------------------------------------------------- + + +def SSI_fast( + H: np.ndarray, + br: int, + ordmax: int, + step: int = 1, +) -> typing.Tuple[ + typing.List[np.ndarray], + typing.List[np.ndarray], + typing.List[np.ndarray], +]: + """ + Perform a fast implementation of Stochastic Subspace Identification (SSI). + + This optimized SSI method uses QR decomposition to accelerate the extraction of system + and output matrices for varying model orders. + + Parameters + ---------- + H : np.ndarray + The Hankel matrix. + br : int + Number of block rows in the Hankel matrix. + ordmax : int + Maximum system order for identification. + step : int, optional + Step size for increasing system order. Default is 1. + + Returns + ------- + Obs : np.ndarray + The global observability matrix of the system. + A : list of np.ndarray + List of estimated system matrices for each model order. + C : list of np.ndarray + List of estimated output influence matrices for each model order. + + Notes + ----- + This method is computationally more efficient than the classical SSI approach, + leveraging QR decomposition for rapid estimation, see [DOME13]_. + """ + + l = int(H.shape[0] / (br)) # noqa E741 (ambiguous variable name 'l') Number of channels + + # SINGULAR VALUE DECOMPOSITION + U, SIG, VT = np.linalg.svd(H) + + S1rad = np.sqrt(np.diag(SIG)) + # initializing arrays + Obs = np.dot(U[:, :ordmax], S1rad[:ordmax, :ordmax]) # Observability matrix + + Oup = Obs[: Obs.shape[0] - l, :] + Odw = Obs[l:, :] + # # Extract system matrices + # QR decomposition + Q, R = np.linalg.qr(Oup) + S = np.dot(Q.T, Odw) + # Con = np.dot(S1rad[:ordmax, :ordmax], V1_t[: ordmax, :]) # Controllability matrix + # Initialize A and C matrices + A, C = [], [] + # loop for increasing order of the system + logger.info("SSI for increasing model order...") + for n in trange(0, ordmax + 1, step): + A.append(np.dot(np.linalg.inv(R[:n, :n]), S[:n, :n])) + C.append(Obs[:l, :n]) + logger.debug("... Done!") + return Obs, A, C + + +# ----------------------------------------------------------------------------- + + +def SSI_poles( + Obs: np.ndarray, + AA: typing.List[np.ndarray], + CC: typing.List[np.ndarray], + ordmax: int, + dt: float, + step: int = 1, + HC: bool = True, + xi_max: float = 0.1, + calc_unc: bool = False, + H: np.ndarray = None, + T: np.ndarray = None, +) -> typing.Tuple[ + np.ndarray, + np.ndarray, + np.ndarray, + np.ndarray, + typing.Optional[np.ndarray], + typing.Optional[np.ndarray], + typing.Optional[np.ndarray], + typing.Optional[np.ndarray], +]: + """ + Calculate modal parameters using the Stochastic Subspace Identification (SSI) method. + + The function computes natural frequencies, damping ratios, and mode shapes for a range + of system orders. Optional uncertainty propagation can be performed. + + Parameters + ---------- + Obs : np.ndarray + The global observability matrix. + AA : list of np.ndarray + List of estimated system matrices for each model order. + CC : list of np.ndarray + List of output matrices for each model order. + ordmax : int + The maximum model order. + dt : float + Sampling time step. + step : int, optional + Step size for increasing model order. Default is 1. + HC : bool, optional + Whether to apply modal filtering to remove unstable poles. Default is True. + xi_max : float, optional + Maximum allowed damping ratio. Default is 0.1. + calc_unc : bool, optional + Whether to calculate uncertainties for modal parameters. Default is False. + H : np.ndarray, optional + The Hankel matrix, required for uncertainty propagation. Default is None. + T : np.ndarray, optional + Auxiliary uncertainty matrix `cov(H)` used in uncertainty propagation. + + Returns + ------- + Fn : np.ndarray + Array of natural frequencies for each system order. + Xi : np.ndarray + Array of damping ratios for each system order. + Phi : np.ndarray + Normalised (to unity) mode shapes for each system order. + Lambdas : np.ndarray + Continuous-time eigenvalues for each system order. + Fn_std : np.ndarray, optional + Standard deviations of natural frequencies, returned if `calc_unc` is True. + Xi_std : np.ndarray, optional + Standard deviations of damping ratios, returned if `calc_unc` is True. + Phi_std : np.ndarray, optional + Standard deviations of mode shapes, returned if `calc_unc` is True. + """ + + # NB Nch = l + + l = int(CC[0].shape[0]) # noqa E741 (ambiguous variable name 'l') + p = int(Obs.shape[0] / l - 1) + q = int(p + 1) # block column + + # Build selector matrices + S1 = np.hstack([np.eye(p * l), np.zeros((p * l, l))]) + S2 = np.hstack([np.zeros((p * l, l)), np.eye(p * l)]) + + # initialization of the matrix that contains the frequencies + Lambdas = np.full((ordmax, int((ordmax) / step + 1)), np.nan, dtype=complex) + # initialization of the matrix that contains the frequencies + Fn = np.full((ordmax, int((ordmax) / step + 1)), np.nan) + # initialization of the matrix that contains the damping ratios + Xi = np.full((ordmax, int((ordmax) / step + 1)), np.nan) + # initialization of the matrix that contains the mode shapes + Phi = np.full((ordmax, int((ordmax) / step + 1), l), np.nan, dtype=complex) + + if calc_unc: + nb = T.shape[1] + r = int(H.shape[1] / q) # Number of reference channels + + # Calculate SVD and truncate at nth order + U, S, VT = np.linalg.svd(H) + + # initialization of the matrix that contains the frequencies + Fn_std = np.full((ordmax, int((ordmax) / step + 1)), np.nan) + # initialization of the matrix that contains the damping ratios + Xi_std = np.full((ordmax, int((ordmax) / step + 1)), np.nan) + # initialization of the matrix that contains the mode shapes + Phi_std = np.full( + (ordmax, int((ordmax) / step + 1), l), + np.nan, + ) + + # SVD truncation at ordmax + Un = U[:, :ordmax] + Vn = VT.T[:, :ordmax] + Sn = np.diag(S[:ordmax]) + + Q1 = np.zeros(((ordmax) ** 2, nb)) + Q2 = np.zeros_like(Q1) + Q3 = np.zeros_like(Q1) + Q4 = np.zeros((l * ordmax, nb)) + logger.info("... propagating uncertainty...") + for ii in trange(1, ordmax + 1, step): + sn_k = Sn[ii - 1, ii - 1] + Vn_k = Vn[:, ii - 1].reshape(-1, 1) + Un_k = Un[:, ii - 1].reshape(-1, 1) + # Eq. 28 + Kj = ( + np.eye(q * r) + + np.vstack([np.zeros((q * r - 1, q * r)), 2 * Vn_k.T]) + - np.dot(H.T, H) / sn_k**2 + ) + Ki = np.linalg.inv(Kj) + # Eq. 29 + Bi1 = np.eye((p + 1) * l) + (H / sn_k) @ Ki @ ( + (H.T / sn_k) - np.vstack([np.zeros((q * r - 1, (p + 1) * l)), Un_k.T]) + ) + Bi1 = np.hstack([Bi1, (H / sn_k) @ Ki]) + # Remark 9 + # Eq. 33 + Ti1 = np.kron(np.eye(q * r), Un_k.T) @ T + Ti2 = np.kron(Vn_k.T, np.eye((p + 1) * l)) @ T + # Eq. 34 + JOHTi = (1 / (2 * np.sqrt(sn_k))) * (Un_k @ (Vn_k.T @ Ti1)) + ( + 1 / np.sqrt(sn_k) + ) * ( + Bi1 + @ np.vstack( + [Ti2 - (Un_k @ (Un_k.T @ Ti2)), Ti1 - (Vn_k @ (Vn_k.T @ Ti1))] + ) + ) + # Eq. 36-37 + Q1[(ii - 1) * ordmax : (ii) * ordmax, :] = ((S1 @ Obs).T @ S1) @ JOHTi + Q2[(ii - 1) * ordmax : (ii) * ordmax, :] = ((S2 @ Obs).T @ S1) @ JOHTi + Q3[(ii - 1) * ordmax : (ii) * ordmax, :] = ((S1 @ Obs).T @ S2) @ JOHTi + Q4[(ii - 1) * l : (ii) * l, :] = ( + np.hstack([np.eye(l), np.zeros((l, p * l))]) @ JOHTi + ) + + logger.info("Calculating modal parameters for increasing model order...") + for nn in trange(0, ordmax + 1, step): + n = nn // step + Oi = Obs[:, :nn] + Oup = np.dot(S1, Oi) + A = AA[n] + C = CC[n] + + # Check if A is an empty array and continue if it is + if A.size == 0: + continue + + # Compute modal parameters + lam_d, l_eigvt, r_eigvt = linalg.eig(A, left=True) # l_eigvt=chi, r_eigvt=phi + lam_c = (np.log(lam_d)) * (1 / dt) # to continous time + xi = -((np.real(lam_c)) / (abs(lam_c))) # damping ratios + phi = np.dot(C, r_eigvt) # N.B. this is \varphi + fn = abs(lam_c) / (2 * np.pi) # natural frequencies + + if HC is not False: + # REMOVING UNSTABLE POLES to speed up loop on lam_c + # Identify elements that have their conjugate in lam_c + mask_conj = np.isin(lam_c, np.conj(lam_c)) + # Remove conjugate duplicates by keeping only one element from each pair + unique_mask = mask_conj.copy() + processed = set() + for i, elem in enumerate(lam_c): + if unique_mask[i]: + conj = np.conj(elem) + if conj in processed: + unique_mask[i] = False # Remove the conjugate duplicate + else: + processed.add(elem) # Mark the element as processed + # Filter lam_c based on unique_mask + lam_c = np.where(unique_mask, lam_c, np.nan) + # Apply damping mask + mask_damp = (xi > 0) & (xi < xi_max) + lam_c = np.where(mask_damp, lam_c, np.nan) + # Filtered frequencies and damping + fn = abs(lam_c) / (2 * np.pi) # natural frequencies + xi = -((np.real(lam_c)) / (abs(lam_c))) # damping ratios + # Expand the mask to 3D by adding a new axis (for mode shape) + expandedmask1 = np.expand_dims(unique_mask, axis=-1) + expandedmask2 = np.expand_dims(mask_damp, axis=-1) + # Repeat the mask along the new dimension + expandedmask1 = np.repeat(expandedmask1, Phi.shape[2], axis=-1) + expandedmask2 = np.repeat(expandedmask2, Phi.shape[2], axis=-1) + # mask the values + phi1 = np.where(expandedmask1, phi.T, np.nan) + phi1 = np.where(expandedmask2, phi1, np.nan) + phi = phi1.T + + try: + # Normalisation to unity + idx = np.argmax(abs(phi), axis=0) + phi = ( + np.array( + [ + phi[:, ii] / phi[np.argmax(abs(phi[:, ii])), ii] + for ii in range(phi.shape[1]) + ] + ) + .reshape(-1, l) + .T + ) + vmaxs = [phi[idx[k1], k1] for k1 in range(len(idx))] + except Exception as e: + logging.debug(f"Ignored exception during normalization: {e}") + pass + + Fn[: len(fn), n] = fn # save the frequencies + Xi[: len(fn), n] = xi # save the damping ratios + Phi[: len(fn), n, :] = phi.T + Lambdas[: len(fn), n] = lam_c + + if calc_unc: + In = np.eye(nn) + Inl = np.eye(nn * l) + Zero = np.zeros((nn, (ordmax) - nn)) + Zero1 = np.zeros((nn * l, l * ((ordmax) - nn))) + matr = np.hstack((In, Zero)) + matr1 = np.hstack((Inl, Zero1)) + + # Selection matrix + S4_n = np.kron(matr, matr) + # Proposition 11 + Q1n = np.dot(S4_n, Q1) + Q2n = np.dot(S4_n, Q2) + Q3n = np.dot(S4_n, Q3) + Q4n = np.dot(matr1, Q4) + + Un = U[:, :nn] + Vn = VT.T[:, :nn] + Sn = np.diag(S[:nn]) + + Pnn = np.zeros((nn**2, nn**2)) + for jj in range(nn): + ek = np.zeros(nn).reshape(-1, 1) + ek[jj, 0] = 1 + Pnn[:, jj * nn : (jj + 1) * nn] = np.kron(np.eye(nn), ek) + + OO = np.linalg.pinv(np.dot(Oup.T, Oup)) + PnQ1 = (Pnn + np.eye(nn**2)) @ Q1n + PnQ23 = Pnn @ Q2n + Q3n + + # step 3 algo 2 + for jj in range(len(lam_c)): + if not np.isnan(fn[jj]): + # step 4 algo 2 + # Eq. 44 + Qi = np.dot( + np.kron(r_eigvt[:, jj].T, np.eye(nn)), (-lam_d[jj] * PnQ1 + PnQ23) + ) + # Lemma 5 - fn and xi + Mat1 = np.array( + [[1 / (2 * np.pi), 0], [0, 1 / (np.abs(lam_c[jj]) ** 2)]] + ) + Mat2 = np.array( + [ + [np.real(lam_c[jj]), np.imag(lam_c[jj])], + [ + -(np.imag(lam_c[jj]) ** 2), + np.real(lam_c[jj]) * np.imag(lam_c[jj]), + ], + ] + ) + Mat3 = np.array( + [ + [np.real(lam_d[jj]), np.imag(lam_d[jj])], + [-np.imag(lam_d[jj]), np.real(lam_d[jj])], + ] + ) + Jfx_l = ( + 1 + / (dt * np.abs(lam_d[jj]) ** 2 * np.abs(lam_c[jj])) + * (np.dot(np.dot(Mat1, Mat2), Mat3)) + ) + # Eq. 43 + JaohT = ( + 1 + / (np.dot(np.conj(l_eigvt[:, jj]), r_eigvt[:, jj])) + * np.dot(np.dot(np.conj(l_eigvt[:, jj]), OO), Qi) + ) + # Eq. 42 + Ufx = np.dot(Jfx_l, np.vstack([np.real(JaohT), np.imag(JaohT)])) + # Eq. 40 + cov_fx = np.dot(Ufx, Ufx.T) + # standard deviation + Fn_std[jj, n] = cov_fx[0, 0] ** 0.5 + Xi_std[jj, n] = cov_fx[1, 1] ** 0.5 + + # Lemma 5 - phi + Mat1_1 = np.linalg.pinv(lam_d[jj] * np.eye(nn) - A) + Mat2_1 = np.eye(nn) - np.dot( + r_eigvt[:, jj].reshape(-1, 1), + l_eigvt[:, jj].reshape(-1, 1).conj().T, + ) / np.dot( + l_eigvt[:, jj].reshape(-1, 1).conj().T, + r_eigvt[:, jj].reshape(-1, 1), + ) + # Eq. 46 + JpaohT = np.dot(np.dot(np.dot(Mat1_1, Mat2_1), OO), Qi) + + if idx[jj] == 0: + Mat1_2 = np.eye(l) - np.hstack( + [phi[:, jj].reshape(-1, 1), np.zeros((l, l - 1))] + ) + else: + Mat1_2 = np.eye(l) - np.hstack( + [ + np.zeros((l, idx[jj])), + phi[:, jj].reshape(-1, 1), + np.zeros((l, l - idx[jj] - 1)), + ] + ) + + Mat2_2 = np.dot(C, JpaohT) + np.dot( + np.kron(r_eigvt[:, jj].T, np.eye(l)), Q4n + ) + # Eq. 45 + JpacohT = 1 / vmaxs[jj] * np.dot(Mat1_2, Mat2_2) + + Uph = np.vstack([np.real(JpacohT), np.imag(JpacohT)]) + # Eq. 40 + cov_phi = np.dot(Uph, Uph.T) + # standard deviation + Phi_std[jj, n, :] = abs(np.diag(cov_phi[:l, :l])) ** 0.5 + logger.debug("... uncertainty calculations done!") + if calc_unc is True: + return Fn, Xi, Phi, Lambdas, Fn_std, Xi_std, Phi_std + else: + return Fn, Xi, Phi, Lambdas, None, None, None + + +# ----------------------------------------------------------------------------- + + +def SSI_multi_setup( + Y: list, + fs: float, + br: int, + ordmax: int, + method_hank: str, + step: int = 1, +) -> typing.Tuple[ + np.ndarray, + typing.List[np.ndarray], + typing.List[np.ndarray], +]: + """ + Perform Subspace System Identification SSI for multiple setup measurements. + + Parameters + ---------- + Y : list of dictionaries + List of dictionaries, each representing data from a different setup. + Each dictionary must have keys 'ref' (reference sensor data) and + 'mov' (moving sensor data), with corresponding numpy arrays. + fs : float + Sampling frequency of the data. + br : int + Number of block rows in the Hankel matrix. + ordmax : int + Maximum order for the system identification process. + methodHank : str + Method for Hankel matrix construction. Can be 'cov', 'cov_R', 'dat'. + step : int, optional + Step size for increasing the order in the identification process. Default is 1. + + Returns + ------- + tuple + Obs_all : numpy array of the global observability matrix. + A : list of numpy arrays + System matrices for each model order. + C : list of numpy arrays + Output influence matrices for each model order. + """ + + n_setup = len(Y) # number of setup + n_ref = Y[0]["ref"].shape[0] # number of reference sensor + + # N.B. ONLY FOR TEST + n_mov = [0 for i in range(n_setup)] # number of moving sensor + n_mov = [Y[i]["mov"].shape[0] for i in range(n_setup)] # number of moving sensor + + n_DOF = n_ref + np.sum(n_mov) # total number of sensors + # dt = 1 / fs + O_mov_s = [] # initialise the scaled moving part of the observability matrix + for kk in trange(n_setup): + logger.debug("Analyising setup nr.: %s...", kk) + Y_ref = Y[kk]["ref"] + # Ndat = Y_ref.shape[1] # number of data points + + # N.B. ONLY FOR TEST + Y_all = Y[kk]["ref"] + Y_all = np.vstack((Y[kk]["ref"], Y[kk]["mov"])) + + r = Y_all.shape[0] # total sensor for the ii setup + # Build HANKEL MATRIX + H, _ = build_hank(Y_all, Y_ref, br, method=method_hank, calc_unc=False) + # SINGULAR VALUE DECOMPOSITION + U1, S1, V1_t = np.linalg.svd(H) + S1rad = np.sqrt(np.diag(S1)) + # Observability matrix + Obs = np.dot(U1[:, :ordmax], S1rad[:ordmax, :ordmax]) + # get reference idexes + ref_id = np.array([np.arange(br) * (n_ref + n_mov[kk]) + j for j in range(n_ref)]) + ref_id = ref_id.flatten(order="f") + mov_id = np.array( + [np.arange(br) * (n_ref + n_mov[kk]) + j for j in range(n_ref, r)] + ) + mov_id = mov_id.flatten(order="f") + + O_ref = Obs[ref_id, :] # reference portion + O_mov = Obs[mov_id, :] # moving portion + + if kk == 0: + O1_ref = O_ref # basis + # scale the moving observability matrix to the reference basis + O_movs = np.dot(np.dot(O_mov, np.linalg.pinv(O_ref)), O1_ref) + O_mov_s.append(O_movs) + logger.debug("... Done with setup nr.: %s!", kk) + + # global observability matrix formation via block-interleaving + Obs_all = np.zeros((n_DOF * br, ordmax)) + for ii in range(br): + # reference portion block rows + id1 = (ii) * n_DOF + id2 = id1 + n_ref + Obs_all[id1:id2, :] = O1_ref[ii * n_ref : (ii + 1) * n_ref, :] + for jj in range(n_setup): + # moving sensor portion block rows + id1 = id2 + id2 = id1 + n_mov[jj] + Obs_all[id1:id2, :] = O_mov_s[jj][ii * n_mov[jj] : (ii + 1) * n_mov[jj], :] + + # if method == "FAST": + # Obs minus last br, minus first br, respectibely + Oup = Obs_all[: Obs_all.shape[0] - n_DOF, :] + Odw = Obs_all[n_DOF:, :] + # QR decomposition + Q, R = np.linalg.qr(Oup) + S = np.dot(Q.T, Odw) + # Con = np.dot(S1rad[:ordmax, :ordmax], V1_t[: ordmax, :]) # Controllability matrix + A = [] + C = [] + # loop for increasing order of the system + for i in trange(0, ordmax + 1, step): + # System Matrix + A.append(np.dot(np.linalg.inv(R[:i, :i]), S[:i, :i])) + # Output Influence Matrix + C.append(Obs_all[:n_DOF, :i]) + + return Obs_all, A, C + + +# ----------------------------------------------------------------------------- + + +def SSI_mpe( + freq_ref: list, + Fn_pol: np.ndarray, + Xi_pol: np.ndarray, + Phi_pol: np.ndarray, + order: typing.Union[int, list, str], + step: int, + Lab: typing.Optional[np.ndarray] = None, + rtol: float = 5e-2, + Fn_std: np.ndarray = None, + Xi_std: np.ndarray = None, + Phi_std: np.ndarray = None, +) -> typing.Tuple[ + np.ndarray, + np.ndarray, + np.ndarray, + typing.Union[np.ndarray, int], + typing.Optional[np.ndarray], + typing.Optional[np.ndarray], + typing.Optional[np.ndarray], +]: + """ + Extract modal parameters using the Stochastic Subspace Identification (SSI) method + for selected frequencies. + + Parameters + ---------- + freq_ref : list + List of selected frequencies for modal parameter extraction. + Fn_pol : numpy.ndarray + Array of natural frequencies obtained from SSI for each model order. + Xi_pol : numpy.ndarray + Array of damping ratios obtained from SSI for each model order. + Phi_pol : numpy.ndarray + 3D array of mode shapes obtained from SSI for each model order. + order : int, list of int, or str + Specifies the model order(s) for which the modal parameters are to be extracted. + If 'find_min', the function attempts to find the minimum model order that provides + stable poles for each mode of interest. + Lab : numpy.ndarray, optional + Array of labels identifying stable poles. Required if order is 'find_min'. + rtol : float, optional + Relative tolerance for comparing frequencies, by default 5e-2. + Fn_std : numpy.ndarray, optional + Covariance array of natural frequencies, by default None. + Xi_std : numpy.ndarray, optional + Covariance array of damping ratios, by default None. + Phi_std : numpy.ndarray, optional + Covariance array of mode shapes, by default None. + + Returns + ------- + tuple + A tuple containing: + - Fn (numpy.ndarray): Extracted natural frequencies. + - Xi (numpy.ndarray): Extracted damping ratios. + - Phi (numpy.ndarray): Extracted mode shapes. + - order_out (numpy.ndarray or int): Output model order used for extraction for each frequency. + - Fn_std (numpy.ndarray, optional): Covariance of extracted natural frequencies. + - Xi_std (numpy.ndarray, optional): Covariance of extracted damping ratios. + - Phi_std (numpy.ndarray, optional): Covariance of extracted mode shapes. + + Raises + ------ + AttributeError + If 'order' is not an int, list of int, or 'find_min', or if 'order' is 'find_min' + but 'Lab' is not provided. + """ + + if order == "find_min" and Lab is None: + raise AttributeError( + "When order ='find_min', one must also provide the Lab list for the poles" + ) + + sel_xi = [] + sel_phi = [] + sel_freq = [] + if Fn_std is not None: + sel_Xi_std = [] + sel_Phi_std = [] + sel_freq_cov = [] + + # Loop through the frequencies given in the input list + logger.info("Extracting SSI modal parameters") + # ============================================================================= + # OPZIONE order = "find_min" + # here we find the minimum model order so to get a stable pole for every mode of interest + # ----------------------------------------------------------------------------- + if order == "find_min": + # Find stable poles + stable_poles = np.where(Lab == 1, Fn_pol, np.nan) + limits = [(f - rtol, f + rtol) for f in freq_ref] + + # Accumulate frequencies within the tolerance limits + aggregated_poles = np.zeros_like(stable_poles) + for lower, upper in limits: + within_limits = np.where( + (stable_poles >= lower) & (stable_poles <= upper), stable_poles, 0 + ) + aggregated_poles += within_limits + + aggregated_poles = np.where(aggregated_poles == 0, np.nan, aggregated_poles) + + found = False + for i in range(aggregated_poles.shape[1]): + current_order_poles = aggregated_poles[:, i] + unique_poles = np.unique(current_order_poles[~np.isnan(current_order_poles)]) + + if len(unique_poles) == len(freq_ref) and np.allclose( + unique_poles, freq_ref, rtol=rtol + ): + found = True + sel_freq.append(unique_poles) + for freq in unique_poles: + index = np.nanargmin(np.abs(current_order_poles - freq)) + sel_xi.append(Xi_pol[index, i]) + sel_phi.append(Phi_pol[index, i, :]) + if Fn_std is not None: + sel_freq_cov.append(Fn_std[index, i]) + sel_Xi_std.append(Xi_std[index, i]) + sel_Phi_std.append(Phi_std[index, i, :]) + order_out = i * step + break + + if not found: + logger.warning("Could not find any values") + order_out = None + # ============================================================================= + # OPZIONE 2 order = int + # ----------------------------------------------------------------------------- + elif isinstance(order, int): + order = int(order / step) + for fj in tqdm(freq_ref): + sel = np.nanargmin(np.abs(Fn_pol[:, order] - fj)) + fns_at_ord_ii = Fn_pol[:, order][sel] + check = np.isclose(fns_at_ord_ii, freq_ref, rtol=rtol) + if not check.any(): + logger.warning("Could not find any values") + order_out = order + else: + sel_freq.append(Fn_pol[:, order][sel]) + sel_xi.append(Xi_pol[:, order][sel]) + sel_phi.append(Phi_pol[:, order][sel, :]) + if Fn_std is not None: + sel_freq_cov.append(Fn_std[:, order][sel]) + sel_Xi_std.append(Xi_std[:, order][sel]) + sel_Phi_std.append(Phi_std[:, order][sel, :]) + order_out = order * step + # ============================================================================= + # OPZIONE 3 order = list[int] + # ----------------------------------------------------------------------------- + elif isinstance(order, list): + # Convert each element in the order list to model orders + order = [int(o / step) for o in order] + order_out = np.array(order) + for ii, fj in enumerate(tqdm(freq_ref)): + sel = np.nanargmin(np.abs(Fn_pol[:, order[ii]] - fj)) + fns_at_ord_ii = Fn_pol[:, order[ii]][sel] + check = np.isclose(fns_at_ord_ii, freq_ref, rtol=rtol) + if not check.any(): + logger.warning("Could not find any values") + order_out[ii] = order[ii] + else: + sel_freq.append(Fn_pol[:, order[ii]][sel]) + sel_xi.append(Xi_pol[:, order[ii]][sel]) + sel_phi.append(Phi_pol[:, order[ii]][sel, :]) + if Fn_std is not None: + sel_freq_cov.append(Fn_std[:, order[ii]][sel]) + sel_Xi_std.append(Xi_std[:, order[ii]][sel]) + sel_Phi_std.append(Phi_std[:, order[ii]][sel, :]) + order_out[ii] = order[ii] * step + else: + raise AttributeError( + 'order must be either of type(int), type(list(int)) or "find_min"' + ) + logger.debug("Done!") + + Fn = np.array(sel_freq).reshape(-1) + Phi = np.array(sel_phi).T + Xi = np.array(sel_xi) + + if Fn_std is not None: + Fn_std = np.array(sel_freq_cov).reshape(-1) + Phi_std = np.array(sel_Phi_std).T + Xi_std = np.array(sel_Xi_std) + return Fn, Xi, Phi, order_out, Fn_std, Xi_std, Phi_std + else: + return Fn, Xi, Phi, order_out, None, None, None diff --git a/src/pyoma2/setup/__init__.py b/src/pyoma2/setup/__init__.py new file mode 100644 index 0000000..57e5a26 --- /dev/null +++ b/src/pyoma2/setup/__init__.py @@ -0,0 +1,3 @@ +from .base import BaseSetup # noqa +from .multi import MultiSetup_PoSER, MultiSetup_PreGER # noqa +from .single import SingleSetup # noqa diff --git a/src/pyoma2/setup/base.py b/src/pyoma2/setup/base.py new file mode 100644 index 0000000..44cc483 --- /dev/null +++ b/src/pyoma2/setup/base.py @@ -0,0 +1,363 @@ +# -*- coding: utf-8 -*- +""" +Operational Modal Analysis Module for Single and Multi-Setup Configurations. +Part of the pyOMA2 package. +Authors: +Dag Pasca +Diego Margoni +""" + +from __future__ import annotations + +import logging +import typing + +import numpy as np +from scipy.signal import decimate, detrend + +from pyoma2.functions.gen import ( + filter_data, +) + +if typing.TYPE_CHECKING: + from pyoma2.algorithms import BaseAlgorithm + + +logger = logging.getLogger(__name__) + + +class BaseSetup: + """ + Base class for operational modal analysis (OMA) setups. + + This class provides foundational methods and attributes used by both + SingleSetup and MultiSetup classes. It serves as a superclass for specific + setup types, offering common functionalities for handling data, running algorithms, and + extracting modal properties. + + Attributes + ---------- + algorithms : dict[str, BaseAlgorithm] + Dictionary storing algorithms added to the setup, keyed by their names. + data : np.ndarray, optional + Time series data array, typically representing the system's output. + fs : float, optional + Sampling frequency of the data. + + Warning + ------- + The BaseSetup class is not intended for direct instantiation by users. + It acts as a common interface for handling different types of setup configurations. + Specific functionalities are provided through its subclasses. + """ + + algorithms: typing.Dict[str, BaseAlgorithm] + data: np.ndarray # TODO use generic typing + fs: float # sampling frequency + + def rollback(self) -> None: + """ + Rollback the data to the initial state. + + This method must be implemented by subclasses to provide a rollback mechanism for the data. + Raises a `NotImplementedError` in the base class. + """ + raise NotImplementedError("Rollback method must be implemented by subclasses.") + + # add algorithm (method) to the set. + def add_algorithms(self, *algorithms: BaseAlgorithm) -> None: + """ + Adds algorithms to the setup and configures them with data and sampling frequency. + + Parameters + ---------- + algorithms : variable number of BaseAlgorithm + One or more algorithm instances to be added to the setup. + + Notes + ----- + The algorithms must be instantiated before adding them to the setup, + and their names must be unique. + """ + self.algorithms = { + **getattr(self, "algorithms", {}), + **{alg.name: alg._set_data(data=self.data, fs=self.fs) for alg in algorithms}, + } + + # run the whole set of algorithms (methods). METODO 1 di tutti + def run_all(self) -> None: + """ + Runs all the algorithms added to the setup. + + Iterates through each algorithm stored in the setup and executes it. The results are saved within + each algorithm instance. + + Notes + ----- + This method assumes that all algorithms are properly initialized and can be executed without + additional parameters. + """ + for alg_name in self.algorithms: + self.run_by_name(name=alg_name) + logger.info("all done") + + # run algorithm (method) by name. QUESTO è IL METODO 1 di un singolo + def run_by_name(self, name: str) -> None: + """ + Runs a specific algorithm by its name. + + Parameters + ---------- + name : str + The name of the algorithm to be executed. + + Raises + ------ + KeyError + If the specified algorithm name does not exist in the setup. + + Notes + ----- + The result of the algorithm execution is saved within the algorithm instance. + """ + logger.info("Running %s...", name) + logger.debug("...with parameters: %s", self[name].run_params) + self[name]._pre_run() + result = self[name].run() + logger.debug("...saving %s result", name) + self[name]._set_result(result) + + # get the modal properties (all results). + def mpe(self, name: str, *args, **kwargs) -> None: + """ + Extracts modal parameters from selected poles/peaks of a specified algorithm. + + Parameters + ---------- + name : str + Name of the algorithm from which to extract modal parameters. + args : tuple + Positional arguments to be passed to the algorithm's mpe method. + kwargs : dict + Keyword arguments to be passed to the algorithm's mpe method. + + Raises + ------ + KeyError + If the specified algorithm name does not exist in the setup. + """ + logger.info("Getting mpe modal parameters from %s", name) + self[name].mpe(*args, **kwargs) + + # get the modal properties (all results) from the plots. + def mpe_from_plot(self, name: str, *args, **kwargs) -> None: + """ + Extracts modal parameters directly from plot selections of a specified algorithm. + + Parameters + ---------- + name : str + Name of the algorithm from which to extract modal parameters. + args : tuple + Positional arguments to be passed to the algorithm's mpe method. + kwargs : dict + Keyword arguments to be passed to the algorithm's mpe method. + + Raises + ------ + KeyError + If the specified algorithm name does not exist in the setup. + """ + logger.info("Getting mpe modal parameters from plot... %s", name) + self[name].mpe_from_plot(*args, **kwargs) + + def __getitem__(self, name: str) -> BaseAlgorithm: + """ + Retrieves an algorithm from the setup by its name. + + Parameters + ---------- + name : str + The name of the algorithm to retrieve. + + Returns + ------- + BaseAlgorithm + The algorithm instance with the specified name. + + Raises + ------ + KeyError + If no algorithm with the given name exists in the setup. + """ + if name in self.algorithms: + return self.algorithms[name] + else: + raise KeyError(f"No algorithm named '{name}' exists.") + + def get( + self, name: str, default: typing.Optional[BaseAlgorithm] = None + ) -> typing.Optional[BaseAlgorithm]: + """ + Retrieves an algorithm from the setup by its name, returning a default value if not found. + + Parameters + ---------- + name : str + The name of the algorithm to retrieve. + default : BaseAlgorithm, optional + The default value to return if the specified algorithm is not found. + + Returns + ------- + BaseAlgorithm or None + The algorithm instance with the specified name or the default value if not found. + """ + return self.algorithms.get(name, default) + + # method to decimate data + @staticmethod + def _decimate_data(data: np.ndarray, fs: float, q: int, **kwargs) -> tuple: + """ + Applies decimation to the data using the scipy.signal.decimate function. + + This method reduces the sampling rate of the data by a factor of 'q'. + The decimation process includes low-pass filtering to reduce aliasing. + The method updates the instance's data and sampling frequency attributes. + + Parameters + ---------- + data : np.ndarray + The input data to be decimated. + q : int + The decimation factor. Must be greater than 1. + axis : int, optional + The axis along which to decimate the data. Default is 0. + **kwargs : dict, optional, will be passed to scipy.signal.decimate + Additional keyword arguments for the scipy.signal.decimate function: + n : int, optional + The order of the filter (if 'ftype' is 'fir') or the number of times + to apply the filter (if 'ftype' is 'iir'). If None, a default value is used. + ftype : {'iir', 'fir'}, optional + The type of filter to use for decimation: 'iir' for an IIR filter + or 'fir' for an FIR filter. Default is 'iir'. + + zero_phase : bool, optional + If True, applies a zero-phase filter, which has no phase distortion. + If False, uses a causal filter with some phase distortion. Default is True. + + Raises + ------ + ValueError + If the decimation factor 'q' is not greater than 1. + + Returns + ------- + tuple + A tuple containing the decimated data, updated sampling frequency, sampling interval, + + Notes + ----- + For further information, see `scipy.signal.decimate + `_. + """ + newdata = decimate(data, q, **kwargs) + fs = fs / q + dt = 1 / fs + Ndat = newdata.shape[0] + T = 1 / fs / q * Ndat + return newdata, fs, dt, Ndat, T + + # method to detrend data + @staticmethod + def _detrend_data(data: np.ndarray, **kwargs) -> np.ndarray: + """ + Applies detrending to the data using the scipy.signal.detrend function. + + This method removes a linear or constant trend from the data, commonly used to remove drifts + or offsets in time series data. It's a preprocessing step, often necessary for methods that + assume stationary data. The method updates the instance's data attribute. + + Parameters + ---------- + data : np.ndarray + The input data to be detrended. + axis : int, optional + The axis along which to detrend the data. Default is 0. + **kwargs : dict, optional, will be passed to scipy.signal.detrend + Additional keyword arguments for the scipy.signal.detrend function: + type : {'linear', 'constant'}, optional + The type of detrending: 'linear' for linear detrend, or 'constant' for just + subtracting the mean. Default is 'linear'. + bp : int or numpy.ndarray of int, optional + Breakpoints where the data is split for piecewise detrending. Default is 0. + + Raises + ------ + ValueError + If invalid parameters are provided. + + Returns + ------- + np.ndarray + The detrended data. + + Notes + ----- + For further information, see `scipy.signal.detrend + `_. + """ + axis = kwargs.pop("axis", 0) + return detrend(data, axis=axis, **kwargs) + + # method to detrend data + @staticmethod + def _filter_data( + data: np.ndarray, + fs: float, + Wn: typing.Union[float, typing.Tuple[float, float]], + order: int = 8, + btype: str = "lowpass", + ) -> np.ndarray: + """ + Apply a Butterworth filter to the input data and return the filtered signal. + + This function designs and applies a Butterworth filter with the specified parameters to the input + data. It can be used to apply lowpass, highpass, bandpass, or bandstop filters. + + Parameters + ---------- + data : ndarray + The input signal data to be filtered. The filter is applied along the first axis + (i.e., each column is filtered independently). + fs : float + The sampling frequency of the input data. + Wn : float or tuple of float + The critical frequency or frequencies. For lowpass and highpass filters, Wn is a scalar; + for bandpass and bandstop filters, Wn is a length-2 sequence. + order : int, optional + The order of the filter. A higher order leads to a sharper frequency cutoff but can also + lead to instability and significant phase delay. Default is 8. + btype : str, optional + The type of filter to apply. Options are "lowpass", "highpass", "bandpass", or "bandstop". + Default is "lowpass". + + Returns + ------- + filt_data : ndarray + The filtered signal, with the same shape as the input data. + + Notes + ----- + For more information, see the scipy documentation for `signal.butter` + (https://docs.scipy.org/doc/scipy/reference/generated/scipy.signal.butter.html) + and `signal.sosfiltfilt` + (https://docs.scipy.org/doc/scipy/reference/generated/scipy.signal.sosfiltfilt.html). + """ + return filter_data( + data=data, + fs=fs, + Wn=Wn, + order=order, + btype=btype, + ) diff --git a/src/pyoma2/setup/multi.py b/src/pyoma2/setup/multi.py new file mode 100644 index 0000000..1366399 --- /dev/null +++ b/src/pyoma2/setup/multi.py @@ -0,0 +1,716 @@ +# -*- coding: utf-8 -*- +""" +Operational Modal Analysis Module for Single and Multi-Setup Configurations. +Part of the pyOMA2 package. +Authors: +Dag Pasca +Diego Margoni +""" + +from __future__ import annotations + +import copy +import logging +import typing + +import matplotlib.pyplot as plt +import numpy as np +import numpy.typing as npt + +from pyoma2.algorithms.data.result import MsPoserResult +from pyoma2.functions.gen import ( + merge_mode_shapes, + pre_multisetup, +) +from pyoma2.functions.plot import ( + STFT, + plt_ch_info, + plt_data, +) +from pyoma2.setup.base import BaseSetup +from pyoma2.setup.single import SingleSetup +from pyoma2.support.geometry import ( + GeometryMixin, +) + +if typing.TYPE_CHECKING: + from pyoma2.algorithms import BaseAlgorithm + + +logger = logging.getLogger(__name__) + +# ============================================================================= +# POSER +# ============================================================================= + + +class MultiSetup_PoSER(GeometryMixin): + """ + Class for conducting Operational Modal Analysis (OMA) on multi-setup experiments using + the Post Separate Estimation Re-scaling (PoSER) approach. This approach is designed to + merge and analyze data from multiple experimental setups for operational modal analysis. + + Attributes + ---------- + ref_ind : List[List[int]] + Indices of reference sensors for each dataset, as a list of lists. + setups : List[SingleSetup] + A list of SingleSetup instances representing individual measurement setups. + names : List[str] + A list of names for the algorithms used in each setup. Used to retrieve results. + __result : Optional[Dict[str, MsPoserResult]] + Private attribute to store the merged results from multiple setups. Each entry in the + dictionary corresponds to a specific algorithm used across setups, with its results. + Warning + ------- + The PoSER approach assumes that the setups used are compatible in terms of their experimental + setup and data characteristics. + """ + + __result: typing.Optional[typing.Dict[str, MsPoserResult]] = None + + def __init__( + self, + ref_ind: typing.List[typing.List[int]], + single_setups: typing.List[SingleSetup], + names: typing.List[str], + ): + """ + Initializes the MultiSetup_PoSER instance with reference indices and a list of SingleSetup instances. + + Parameters + ---------- + ref_ind : List[List[int]] + Reference indices for merging results from different setups. + single_setups : List[SingleSetup] + A list of SingleSetup instances to be merged using the PoSER approach. + names : List[str] + A list of names for the algorithms used in each setup. Used to retrieve results. + Te list must be len as the number of algorithms in each setup. + + Raises + ------ + ValueError + If any of the provided setups are invalid or incompatible. + """ + self.names = names + self._setups = [ + el for el in self._init_setups(setups=single_setups if single_setups else []) + ] + self.ref_ind = ref_ind + self.__result = None + + @property + def setups(self) -> typing.List[SingleSetup]: + """ + Returns the list of SingleSetup instances representing individual measurement setups. + """ + return self._setups + + @setups.setter + def setups(self, setups: typing.List[SingleSetup]) -> None: + """ + Sets the list of SingleSetup instances. Not allowed after initialization. + + Raises + ------ + AttributeError + If trying to set setups after initialization. + """ + # not allow to set setups after initialization + if hasattr(self, "_setups"): + raise AttributeError("Cannot set setups after initialization") + self._setups = setups + + @property + def result(self) -> typing.Dict[str, MsPoserResult]: + """ + Returns the merged results after applying the PoSER method. + + Raises + ------ + ValueError + If the merge_results() method has not been run yet. + """ + if self.__result is None: + raise ValueError("You must run merge_results() first") + return self.__result + + def _init_setups( + self, setups: typing.List[SingleSetup] + ) -> typing.Generator[SingleSetup, None, None]: + """ + Ensures each setup has run its algorithms and that algorithms are internally consistent. + + Parameters + ---------- + setups : List[SingleSetup] + List of SingleSetup instances to initialize. + + Yields + ------ + Generator[SingleSetup, None, None] + Generator yielding initialized SingleSetup instances. + + Raises + ------ + ValueError + If there are issues with the provided setups or algorithms. + """ + if len(setups) <= 1: + raise ValueError("You must pass at least two setup") + if any(not setup.algorithms for setup in setups): + raise ValueError("You must pass setups with at least one algorithm") + + algo_instances = [setup.algorithms.values() for setup in setups] + + # The following validation ensures that each list of algorithms has the same set of algorithm classes. + # This means that the order and presence of each class must be consistent across all lists. + # For example: + # [[fdd, ssi], [fdd, ssi], [fdd, ssi]] is valid (same order and presence) + # [[fdd, fdd], [fdd, fdd], [fdd, fdd]] is valid (same order and presence) + # [[fdd, ssi], [fdd, ssi], [fdd, fdd]] is not valid (different presence in the last list) + # [[fdd, ssi], [fdd, ssi], [ssi, fdd]] is not valid (different order in the last list) + # [[fdd, ssi], [fdd, ], [ssi, fdd]] is not valid (different presence in the second list) + if not all( + [type(algo) for algo in algos] == [type(algo) for algo in algo_instances[0]] + for algos in algo_instances + ): + raise ValueError("The algorithms must be consistent between setups") + + if len(self.names) != len(setups[0].algorithms): + raise ValueError("The number of names must match the number of algorithms") + + for i, setup in enumerate(setups): + logger.debug("Initializing %s/%s setups", i + 1, len(setups)) + for alg in setup.algorithms.values(): + if not alg.result or alg.result.Fn is None: + raise ValueError( + "You must pass Single setups that have already been run" + " and the Modal Parameters have to be extracted (call mpe method on SingleSetup)" + ) + yield setup + + def merge_results(self) -> typing.Dict[str, MsPoserResult]: + """ + Merges results from individual setups into a combined result using the PoSER method. + + Groups algorithms by type across all setups and merges their results. + Calculates the mean and covariance of natural frequencies and damping ratios, + and merges mode shapes. + + Returns + ------- + Dict[str, MsPoserResult] + A dictionary containing the merged results for each algorithm type. + + Raises + ------ + ValueError + If the method is called before running algorithms on the setups. + """ + # group algorithms by type + alg_groups: typing.Dict[str, typing.List[BaseAlgorithm]] = {} + for setup in self.setups: + for ii, alg in enumerate(setup.algorithms.values()): + alg_groups.setdefault(self.names[ii], []).append(alg) + + for alg_name, algs in alg_groups.items(): + alg_cl = algs[0].__class__ + logger.info("Merging %s results for %s group", alg_cl.__name__, alg_name) + # get the reference algorithm + all_fn = [] + all_xi = [] + all_phi = [] + for alg in algs: + logger.info("Merging %s results", alg.name) + all_fn.append(alg.result.Fn) + all_xi.append(alg.result.Xi) + all_phi.append(alg.result.Phi) + + # Convert lists to numpy arrays + all_fn = np.array(all_fn) + all_xi = np.array(all_xi) + + # Calculate mean and covariance + fn_mean = np.mean(all_fn, axis=0) + xi_mean = np.mean(all_xi, axis=0) + + fn_std = np.std(all_fn, axis=0) # / fn_mean + xi_std = np.std(all_xi, axis=0) # / xi_mean + Phi = merge_mode_shapes(MSarr_list=all_phi, reflist=self.ref_ind) + + if self.__result is None: + self.__result = {} + + self.__result[alg_name] = MsPoserResult( + Phi=Phi, + Fn=fn_mean, + Fn_std=fn_std, + Xi=xi_mean, + Xi_std=xi_std, + ) + return self.__result + + +# ============================================================================= +# +# ============================================================================= + + +class MultiSetup_PreGER(BaseSetup, GeometryMixin): + """ + Class for conducting Operational Modal Analysis on multi-setup experiments using the + Pre-Global Estimation Re-scaling (PreGER) approach. + This class is tailored for handling and processing multiple datasets, applying the PreGER method + efficiently. It offers functionalities for data visualization, preprocessing, and geometric + configuration for the structure under analysis. + + Attributes + ---------- + fs : float + The common sampling frequency across all datasets. + dt : float + The sampling interval, calculated as the inverse of the sampling frequency. + ref_ind : list[list[int]] + Indices of reference sensors for each dataset, as a list of lists. + datasets : list[npt.NDArray[np.float64]] + The original list of datasets, each represented as a NumPy array. + data : npt.NDArray[np.float64] + Processed data after applying the PreGER method, ready for analysis. + algorithms : dict[str, BaseAlgorithm] + Dictionary storing algorithms added to the setup, keyed by their names. + Nchs : list[int] + A list containing the number of channels for each dataset. + Ndats : list[int] + A list containing the number of data points for each dataset. + Ts : list[float] + A list containing the total duration (in seconds) of each dataset. + Nsetup : int + The number of setups (or datasets) included in the analysis. + + Warning + ------- + The PreGER approach assumes that the setups used are compatible in terms of their experimental + setup and data characteristics. + """ + + dt: float + Nsetup: int + data: typing.List[typing.Dict[str, np.ndarray]] + algorithms: typing.Dict[str, BaseAlgorithm] + Nchs: typing.List[int] + Ndats: typing.List[int] + Ts: typing.List[float] + + def __init__( + self, + fs: float, + ref_ind: typing.List[typing.List[int]], + datasets: typing.List[npt.NDArray[np.float64]], + ): + """ + Initializes the MultiSetup_PreGER instance with specified sampling frequency, + reference indices, and datasets. + + Parameters + ---------- + fs : float + The sampling frequency common to all datasets. + ref_ind : typing.List[typing.List[int]] + Reference indices for each dataset, used in the PreGER method. + datasets : typing.List[npt.NDArray[np.float64]] + A list of datasets, each as a NumPy array. + """ + self.fs = fs # sampling frequencies + self.ref_ind = ref_ind # list of (list of) reference indices + self.datasets = datasets + + self._initialize_data(fs=fs, ref_ind=ref_ind, datasets=datasets) + + def _initialize_data( + self, + fs: float, + ref_ind: typing.List[typing.List[int]], + datasets: typing.List[npt.NDArray[np.float64]], + ) -> None: + """ + Pre process the data and set the initial attributes after copying the data. + + This method is called internally to pre-process the data and set the initial attributes + """ + # Store a copy of the initial data + self._initial_fs = fs + self._initial_ref_ind = copy.deepcopy(ref_ind) + self._initial_datasets = copy.deepcopy(datasets) + + self.dt = 1 / fs # sampling interval + self.Nsetup = len(ref_ind) + + # Pre-process the data so to be multi-setup compatible + Y = pre_multisetup(datasets, ref_ind) + + self.data = Y + self.algorithms: typing.Dict[str, BaseAlgorithm] = {} # set of algo + Nchs = [] + Ndats = [] + Ts = [] + for data in datasets: # loop through each dataset in the dataset list + Nch = data.shape[1] # number of channels + Ndat = data.shape[0] # number of data points + T = self.dt * Ndat # Period of acquisition [sec] + Nchs.append(Nch) + Ndats.append(Ndat) + Ts.append(T) + self.Nchs = Nchs + self.Ndats = Ndats + self.Ts = Ts + + def rollback(self) -> None: + """ + Restores the data and sampling frequency to their initial state. + + This method reverts the `data` and `fs` attributes to their original values, effectively + undoing any operations that modify the data, such as filtering, detrending, or decimation. + It can be used to reset the setup to the state it was in after instantiation. + """ + self.fs = self._initial_fs + self.ref_ind = self._initial_ref_ind + self.datasets = self._initial_datasets + + self._initialize_data( + fs=self._initial_fs, + ref_ind=self._initial_ref_ind, + datasets=self._initial_datasets, + ) + + # method to plot the time histories of the data channels. + def plot_data( + self, + data_idx: typing.Union[str, typing.List[int]] = "all", + nc: int = 1, + names: typing.Optional[typing.List[str]] = None, + # names: list[list[str]] = None, + unit: str = "unit", + show_rms: bool = False, + ) -> typing.Tuple[plt.Figure, plt.Axes]: + """ + Plots the time histories of the data channels for selected datasets. + + Allows for visualization of the time history of each data channel across multiple datasets. + Users can specify which datasets to plot, configure subplot layout, and optionally display + RMS acceleration. + + Parameters + ---------- + data_idx : str | list[int], optional + Indices of datasets to be plotted. Can be a list of indices or 'all' for all datasets. + Default is 'all'. + nc : int, optional + Number of columns for the subplot layout. Default is 1. + names : typing.Optional[typing.List[str]], optional + Names for the channels in each dataset. If provided, these names are used as labels. + Default is None. + unit : str, optional + Unit of measurement for the y-axis. Default is "unit". + show_rms : bool, optional + If True, shows the RMS acceleration in the plot. Default is False. + + Returns + ------- + list + A list of tuples, each containing the figure and axes objects for the plots of each dataset. + """ + if data_idx != "all": + datasets = [self.datasets[i] for i in data_idx] + else: + datasets = self.datasets + + fs = self.fs + figs, axs = [], [] + for ii, data in enumerate(datasets): + nc = nc # number of columns for subplot + nam = ( + names[ii] if names is not None else None + ) # list of names (str) of the channnels + unit = unit # str label for the y-axis (unit of measurement) + show_rms = show_rms # wheter to show or not the rms acc in the plot + fig, ax = plt_data(data, fs, nc, nam, unit, show_rms) + figs.append(fig) + axs.append(ax) + return figs, axs + + # method to plot TH, PSD and KDE for each channel + def plot_ch_info( + self, + data_idx: typing.Union[str, typing.List[int]] = "all", + nxseg: float = 1024, + ch_idx: typing.Union[str, typing.List[int]] = "all", + freqlim: typing.Optional[typing.Tuple[float, float]] = None, + logscale: bool = True, + unit: str = "unit", + ) -> typing.Tuple[plt.Figure, np.ndarray[plt.Axes]]: + """ + Plot channel information including time history, normalized auto-correlation, + power spectral density (PSD), probability density function, and normal probability + plot for each channel in the selected datasets. + + Parameters + ---------- + data_idx : str or list[int], optional + Indices of the datasets to plot. Use 'all' to plot data for all datasets. Default is 'all'. + nxseg : float, optional + The number of data points per segment for the PSD estimation. Default is 1024. + ch_idx : str or list[int], optional + Indices of the channels to plot. Use 'all' to plot information for all channels. Default is 'all'. + freqlim : tuple of float, optional + Frequency limits (min, max) for the PSD plot. Default is None, using the full range. + logscale : bool, optional + Whether to use a logarithmic scale for the PSD plot. Default is True. + unit : str, optional + Unit of measurement for the data, used in labeling the plots. Default is 'unit'. + + Returns + ------- + tuple + A tuple containing lists of figure and axes objects for further customization or saving. + """ + if data_idx != "all": + datasets = [self.datasets[i] for i in data_idx] + else: + datasets = self.datasets + fs = self.fs + figs, axs = [], [] + for data in datasets: + fig, ax = plt_ch_info( + data, + fs, + ch_idx=ch_idx, + freqlim=freqlim, + logscale=logscale, + nxseg=nxseg, + unit=unit, + ) + figs.append(fig) + axs.append(ax) + return figs, axs + + # method to plot TH, PSD and KDE for each channel + def plot_STFT( + self, + data_idx: typing.Union[str, typing.List[int]] = "all", + nxseg: float = 256, + pov: float = 0.9, + ch_idx: typing.Union[str, typing.List[int]] = "all", + freqlim: typing.Optional[typing.Tuple[float, float]] = None, + win: str = "hann", + ) -> typing.Tuple[plt.Figure, np.ndarray[plt.Axes]]: + """ + Plot the Short-Time Fourier Transform (STFT) magnitude spectrogram for the specified channels. + + This method computes and plots the STFT magnitude spectrogram for each selected channel in the + specified datasets. The spectrogram is plotted as a heatmap where the x-axis represents time, the y-axis + represents frequency, and the color intensity represents the magnitude of the STFT. + + Parameters + ---------- + data_idx : str or list[int], optional + Indices of the datasets to plot. Use 'all' to plot data for all datasets. Default is 'all'. + nxseg : float, optional + The number of data points per segment for the STFT calculation. Default is 256. + pov : float, optional + Proportion of overlap between consecutive segments, expressed as a decimal between 0 and 1. + Default is 0.9 (90% overlap). + ch_idx : str or list[int], optional + Indices of the channels to plot. Use 'all' to plot information for all channels. Default is 'all'. + freqlim : tuple of float, optional + Frequency limits (min, max) for the STFT plot. Default is None, using the full range. + win : str, optional + The windowing function to apply to each segment. Default is 'hann'. + + Returns + ------- + tuple + A tuple containing lists of figure and axes objects for further customization or saving. + """ + if data_idx != "all": + datasets = [self.datasets[i] for i in data_idx] + else: + datasets = self.datasets + fs = self.fs + figs, axs = [], [] + for data in datasets: + fig, ax = STFT( + data, + fs, + nxseg=nxseg, + pov=pov, + win=win, + ch_idx=ch_idx, + freqlim=freqlim, + ) + figs.append(fig) + axs.append(ax) + return figs, axs + + # method to decimate data + def decimate_data( + self, + q: int, + **kwargs: typing.Any, + ) -> None: + """ + Applies decimation to the data using the scipy.signal.decimate function. + + This method reduces the sampling rate of the data by a factor of 'q'. + The decimation process includes low-pass filtering to reduce aliasing. + The method updates the instance's data and sampling frequency attributes. + + Parameters + ---------- + q : int + The decimation factor. Must be greater than 1. + **kwargs : dict, optional, will be passed to scipy.signal.decimate + Additional keyword arguments for the scipy.signal.decimate function: + + n : int, optional + The order of the filter (if 'ftype' is 'fir') or the number of times + to apply the filter (if 'ftype' is 'iir'). If None, a default value is used. + ftype : {'iir', 'fir'}, optional + The type of filter to use for decimation: 'iir' for an IIR filter + or 'fir' for an FIR filter. Default is 'iir'. + + zero_phase : bool, optional + If True, applies a zero-phase filter, which has no phase distortion. + If False, uses a causal filter with some phase distortion. Default is True. + + Raises + ------ + ValueError + If the decimation factor 'q' is not greater than 1. + + Notes + ----- + For further information, see `scipy.signal.decimate + `_. + """ + n = kwargs.get("n") + ftype = kwargs.get("ftype", "iir") + axis = kwargs.get("axis", 0) + zero_phase = kwargs.get("zero_phase", True) + + newdatasets = [] + Ndats = [] + Ts = [] + for data in self.datasets: + newdata, _, _, Ndat, T = super()._decimate_data( + data=data, + fs=self.fs, + q=q, + n=n, + ftype=ftype, + axis=axis, + zero_phase=zero_phase, + **kwargs, + ) + newdatasets.append(newdata) + Ndats.append(Ndat) + Ts.append(T) + + Y = pre_multisetup(newdatasets, self.ref_ind) + fs = self.fs / q + dt = 1 / self.fs + + self.datasets = newdatasets + self.data = Y + self.fs = fs + self.dt = dt + self.Ndats = Ndats + self.Ts = Ts + + # method to filter data + def filter_data( + self, + Wn: typing.Union[float, typing.Tuple[float, float]], + order: int = 8, + btype: str = "lowpass", + ) -> None: + """ + Apply a Butterworth filter to the input data and return the filtered signal. + + This function designs and applies a Butterworth filter with the specified parameters to the input + data. It can be used to apply lowpass, highpass, bandpass, or bandstop filters. + + Parameters + ---------- + Wn : float or tuple of float + The critical frequency or frequencies. For lowpass and highpass filters, Wn is a scalar; + for bandpass and bandstop filters, Wn is a length-2 sequence. + order : int, optional + The order of the filter. A higher order leads to a sharper frequency cutoff but can also + lead to instability and significant phase delay. Default is 8. + btype : str, optional + The type of filter to apply. Options are "lowpass", "highpass", "bandpass", or "bandstop". + Default is "lowpass". + + Notes + ----- + For more information, see the scipy documentation for `signal.butter` + (https://docs.scipy.org/doc/scipy/reference/generated/scipy.signal.butter.html) + and `signal.sosfiltfilt` + (https://docs.scipy.org/doc/scipy/reference/generated/scipy.signal.sosfiltfilt.html). + """ + newdatasets = [] + for data in self.datasets: + newdata = super()._filter_data( + data=data, + fs=self.fs, + Wn=Wn, + order=order, + btype=btype, + ) + newdatasets.append(newdata) + + Y = pre_multisetup(newdatasets, self.ref_ind) + self.data = Y + + # method to detrend data + def detrend_data( + self, + **kwargs: typing.Any, + ) -> None: + """ + Detrends the data using the scipy.signal.detrend function. + + This method removes a linear or constant trend from the data, commonly used to remove drifts + or offsets in time series data. It's a preprocessing step, often necessary for methods that + assume stationary data. The method updates the instance's data attribute. + + Parameters + ---------- + **kwargs : dict, optional + Additional keyword arguments for the scipy.signal.detrend function: + + type : {'linear', 'constant'}, optional + The type of detrending: 'linear' for linear detrend, or 'constant' for just + subtracting the mean. Default is 'linear'. + bp : int or numpy.ndarray of int, optional + Breakpoints where the data is split for piecewise detrending. Default is 0. + + Raises + ------ + ValueError + If invalid parameters are provided. + + Notes + ----- + For further information, see `scipy.signal.detrend + `_. + """ + newdatasets = [] + for data in self.datasets: + newdata = super()._detrend_data(data=data, **kwargs) + newdatasets.append(newdata) + + Y = pre_multisetup(newdatasets, self.ref_ind) + self.data = Y diff --git a/src/pyoma2/setup/single.py b/src/pyoma2/setup/single.py new file mode 100644 index 0000000..c61aaf7 --- /dev/null +++ b/src/pyoma2/setup/single.py @@ -0,0 +1,375 @@ +# -*- coding: utf-8 -*- +""" +Operational Modal Analysis Module for Single and Multi-Setup Configurations. +Part of the pyOMA2 package. +Authors: +Dag Pasca +Diego Margoni +""" + +from __future__ import annotations + +import copy +import logging +import typing + +import matplotlib.pyplot as plt +import numpy as np + +from pyoma2.functions import plot +from pyoma2.setup.base import BaseSetup +from pyoma2.support.geometry import GeometryMixin + +if typing.TYPE_CHECKING: + from pyoma2.algorithms import BaseAlgorithm + + +logger = logging.getLogger(__name__) + + +class SingleSetup(BaseSetup, GeometryMixin): + """ + Class for managing and processing single setup data for Operational Modal Analysis. + + This class handles data from a single setup, offering functionalities like plotting, + data processing, and interaction with various analysis algorithms. It inherits + attributes and methods from the BaseSetup class. + + Parameters + ---------- + data : Iterable[float] + The data to be processed, expected as an iterable of floats. + fs : float + The sampling frequency of the data. + + Attributes + ---------- + data : Iterable[float] + Stores the input data. + fs : float + Stores the sampling frequency. + dt : float + The sampling interval, calculated as the inverse of the sampling frequency. + algorithms : Dict[str, BaseAlgorithm] + A dictionary to store algorithms associated with the setup. + + Notes + ----- + The ``algorithms`` dictionary is initialized empty and is meant to store various algorithms as needed. + """ + + dt: float + Nch: int + Ndat: int + T: float + algorithms: typing.Dict[str, BaseAlgorithm] + + def __init__(self, data: np.ndarray, fs: float): + """ + Initialize a SingleSetup instance with data and sampling frequency. + + Parameters + ---------- + data : np.ndarray + The data to be processed, expected as a 2D array of shape (N, M) + fs : float + The sampling frequency of the data. + """ + self.data = data # data + self.fs = fs # sampling frequency [Hz] + + self._initialize_data(data=data, fs=fs) + + def _initialize_data(self, data: np.ndarray, fs: float) -> None: + """ + Pre process the data and set the initial attributes after copying the data. + + This method is called during the initialization of the SingleSetup instance. + """ + # Store a copy of the initial data + self._initial_data = copy.deepcopy(data) + self._initial_fs = fs + + self.dt = 1 / fs # sampling interval + self.Nch = data.shape[1] # number of channels + self.Ndat = data.shape[0] # number of data points + self.T = self.dt * self.Ndat # Period of acquisition [sec] + + self.algorithms: typing.Dict[str, BaseAlgorithm] = {} # set of algo + + def rollback(self) -> None: + """ + Restores the data and sampling frequency to their initial state. + + This method reverts the `data` and `fs` attributes to their original values, effectively + undoing any operations that modify the data, such as filtering, detrending, or decimation. + It can be used to reset the setup to the state it was in after instantiation. + """ + self.data = self._initial_data + self.fs = self._initial_fs + + self._initialize_data(data=self._initial_data, fs=self._initial_fs) + + # method to plot the time histories of the data channels. + def plot_data( + self, + nc: int = 1, + names: typing.Optional[typing.List[str]] = None, + unit: str = "unit", + show_rms: bool = False, + ) -> typing.Tuple[plt.Figure, np.ndarray]: + """ + Plots the time histories of the data channels in a subplot format. + + Parameters + ---------- + nc : int, optional + Number of columns for the subplot. Default is 1. + names : List[str], optional + List of names for the channels. If provided, these names are used as labels. + Default is None. + unit : str, optional + String label for the y-axis representing the unit of measurement. Default is "unit". + show_rms : bool, optional + If True, the RMS acceleration is shown in the plot. Default is False. + + Returns + ------- + tuple + A tuple containing the figure and axis objects of the plot for further customization + or saving externally. + """ + data = self.data + fs = self.fs + nc = nc # number of columns for subplot + names = names # list of names (str) of the channnels + unit = unit # str label for the y-axis (unit of measurement) + show_rms = show_rms # wheter to show or not the rms acc in the plot + fig, ax = plot.plt_data(data, fs, nc, names, unit, show_rms) + return fig, ax + + # Method to plot info on channel (TH,auto-corr,PSD,PDF,dataVSgauss) + def plot_ch_info( + self, + nxseg: float = 1024, + ch_idx: typing.Union[str, typing.List[int]] = "all", + freqlim: typing.Optional[tuple[float, float]] = None, + logscale: bool = True, + unit: str = "unit", + ) -> typing.Tuple[plt.Figure, np.ndarray]: + """ + Plot channel information including time history, normalized auto-correlation, + power spectral density (PSD), probability density function, and normal probability + plot for each channel in the data. + + Parameters + ---------- + data : ndarray + The input signal data. + fs : float + The sampling frequency of the input data. + nxseg : int, optional + The number of points per segment for the PSD estimation. Default is 1024. + freqlim : tuple of float, optional + The frequency limits (min, max) for the PSD plot. Default is None. + logscale : bool, optional + If True, the PSD plot will use a logarithmic scale. Default is False. + ch_idx : str or list of int, optional + The indices of the channels to plot. If "all", information for all channels is plotted. + Default is "all". + unit : str, optional + The unit of the input data for labeling the plots. Default is "unit". + + Returns + ------- + figs : list of matplotlib.figure.Figure + A list of figure objects, one for each channel plotted. + axs : list of matplotlib.axes.Axes + A list of Axes objects corresponding to the subplots for each channel's information. + """ + data = self.data + fs = self.fs + fig, ax = plot.plt_ch_info( + data, + fs, + ch_idx=ch_idx, + freqlim=freqlim, + logscale=logscale, + nxseg=nxseg, + unit=unit, + ) + return fig, ax + + # Method to plot Short Time Fourier Transform + def plot_STFT( + self, + nxseg: float = 512, + pov: float = 0.9, + ch_idx: typing.Union[str, typing.List[int]] = "all", + freqlim: typing.Optional[tuple[float, float]] = None, + win: str = "hann", + ) -> typing.Tuple[plt.Figure, np.ndarray]: + """ + Plot the Short-Time Fourier Transform (STFT) magnitude spectrogram for the specified channels. + + This method computes and plots the STFT magnitude spectrogram for each selected channel in the + data. The spectrogram is plotted as a heatmap where the x-axis represents time, the y-axis + represents frequency, and the color intensity represents the magnitude of the STFT. + + Parameters + ---------- + data : ndarray + The input signal data. + fs : float + The sampling frequency of the input data. + nxseg : int, optional + The number of data points used in each segment of the STFT. Default is 512. + pov : float, optional + The proportion of overlap between consecutive segments, expressed as a decimal between 0 and 1. + Default is 0.9. + win : str, optional + The type of window function to apply to each segment. Default is "hann". + freqlim : tuple of float, optional + The frequency limits (min, max) for the spectrogram display. Default is None, which uses the + full frequency range. + ch_idx : str or list of int, optional + The indices of the channels to plot. If "all", the STFT for all channels is plotted. + Default is "all". + + Returns + ------- + figs : list of matplotlib.figure.Figure + A list of figure objects, one for each channel plotted. + axs : list of matplotlib.axes.Axes + A list of Axes objects corresponding to the figures. + """ + + data = self.data + fs = self.fs + fig, ax = plot.STFT( + data, + fs, + nxseg=nxseg, + pov=pov, + win=win, + ch_idx=ch_idx, + freqlim=freqlim, + ) + return fig, ax + + def decimate_data(self, q: int, **kwargs) -> None: + """ + Decimates the data using the scipy.signal.decimate function. + + This method reduces the sampling rate of the data by a factor of 'q'. + The decimation process includes low-pass filtering to reduce aliasing. + The method updates the instance's data and sampling frequency attributes. + + Parameters + ---------- + q : int + The decimation factor. Must be greater than 1. + **kwargs : dict, optional + Additional keyword arguments for the scipy.signal.decimate function: + + n : int, optional + The order of the filter (if 'ftype' is 'fir') or the number of times + to apply the filter (if 'ftype' is 'iir'). If None, a default value is used. + ftype : {'iir', 'fir'}, optional + The type of filter to use for decimation: 'iir' for an IIR filter + or 'fir' for an FIR filter. Default is 'iir'. + zero_phase : bool, optional + If True, applies a zero-phase filter, which has no phase distortion. + If False, uses a causal filter with some phase distortion. Default is True. + + Raises + ------ + ValueError + If the decimation factor 'q' is not greater than 1. + + Notes + ----- + For further information, see `scipy.signal.decimate + `_. + """ + axis = kwargs.pop("axis", 0) + decimated_data, fs, dt, Ndat, T = super()._decimate_data( + data=self.data, fs=self.fs, q=q, axis=axis, **kwargs + ) + self.data = decimated_data + self.fs = fs + self.dt = dt + self.Ndat = Ndat + self.T = T + + def detrend_data(self, **kwargs) -> None: + """ + Detrends the data using the scipy.signal.detrend function. + + This method removes a linear or constant trend from the data, commonly used to remove drifts + or offsets in time series data. It's a preprocessing step, often necessary for methods that + assume stationary data. The method updates the instance's data attribute. + + Parameters + ---------- + **kwargs : dict, optional + Additional keyword arguments for the scipy.signal.detrend function: + + type : {'linear', 'constant'}, optional + The type of detrending: 'linear' for linear detrend, or 'constant' for just + subtracting the mean. Default is 'linear'. + bp : int or numpy.ndarray of int, optional + Breakpoints where the data is split for piecewise detrending. Default is 0. + + Raises + ------ + ValueError + If invalid parameters are provided. + + Notes + ----- + For further information, see `scipy.signal.detrend + `_. + """ + detrended_data = super()._detrend_data(data=self.data, **kwargs) + self.data = detrended_data + + def filter_data( + self, + Wn: typing.Union[float, typing.Tuple[float, float]], + order: int = 8, + btype: str = "lowpass", + ) -> None: + """ + Apply a Butterworth filter to the input data and return the filtered signal. + + This function designs and applies a Butterworth filter with the specified parameters to the input + data. It can be used to apply lowpass, highpass, bandpass, or bandstop filters. + + Parameters + ---------- + Wn : float or tuple of float + The critical frequency or frequencies. For lowpass and highpass filters, Wn is a scalar; + for bandpass and bandstop filters, Wn is a length-2 sequence. + order : int, optional + The order of the filter. A higher order leads to a sharper frequency cutoff but can also + lead to instability and significant phase delay. Default is 8. + btype : str, optional + The type of filter to apply. Options are "lowpass", "highpass", "bandpass", or "bandstop". + Default is "lowpass". + + Notes + ----- + For more information, see the scipy documentation for `signal.butter` + (https://docs.scipy.org/doc/scipy/reference/generated/scipy.signal.butter.html) + and `signal.sosfiltfilt` + (https://docs.scipy.org/doc/scipy/reference/generated/scipy.signal.sosfiltfilt.html). + """ + filt_data = super()._filter_data( + data=self.data, + fs=self.fs, + Wn=Wn, + order=order, + btype=btype, + ) + self.data = filt_data diff --git a/src/pyoma2/support/__init__.py b/src/pyoma2/support/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/pyoma2/support/geometry/__init__.py b/src/pyoma2/support/geometry/__init__.py new file mode 100644 index 0000000..ada958f --- /dev/null +++ b/src/pyoma2/support/geometry/__init__.py @@ -0,0 +1,71 @@ +""" +This module provides classes for handling geometry-related data, specifically designed +to store and manipulate sensor and background geometry information. It includes two +classes: Geometry1 and Geometry2, each offering unique plotting capabilities: + +- Geometry1 enables users to visualise mode + shapes with arrows that represent the placement, direction, and + magnitude of displacement for each sensor. +- Geometry2 allows for the plotting and + animation of mode shapes, with sensors mapped to user defined + points. + +Modules: +-------- +- data: Contains the definitions for Geometry1, Geometry2, and BaseGeometry classes. +- mpl_plotter: Provides Geo1MplPlotter and Geo2MplPlotter classes for plotting using Matplotlib. +- pyvista_plotter: Provides PvGeoPlotter class for 3D visualization and animation using PyVista. +- mixin: Contains mixin classes to add additional functionality to geometry classes. + +Classes: +-------- +- Geometry1: A class to store and manage sensor geometry data, enabling visualization of mode shapes with arrows. +- Geometry2: A class to store and manage sensor and background geometry data, allowing for plotting and animation of mode shapes. +- BaseGeometry: A base class for storing and managing sensor and background geometry data. +- Geo1MplPlotter: A class to plot Geometry1 data using Matplotlib. +- Geo2MplPlotter: A class to plot Geometry2 data using Matplotlib. +- PvGeoPlotter: A class to visualize and animate mode shapes in 3D using PyVista. +- GeometryMixin: A mixin class to add additional functionality to geometry classes. + +Functions: +---------- +- save_to_file: Save geometry data to a file. +- load_from_file: Load geometry data from a file. + +Examples: +--------- +# Example usage of Geometry1 and Geometry2 +from pyoma2.support.geometry import Geometry1, Geometry2, Geo1MplPlotter, Geo2MplPlotter, PvGeoPlotter + +# Define geometry data for Geometry1 +geo1 = Geometry1( + sens_names=["Sensor1", "Sensor2"], + sens_coord=pd.DataFrame([[0, 0, 0], [1, 1, 1]], columns=["x", "y", "z"]), + sens_dir=np.array([[1, 0, 0], [0, 1, 0]]) +) + +# Plot Geometry1 data using Matplotlib +plotter1 = Geo1MplPlotter(geo1) +plotter1.plot() + +# Define geometry data for Geometry2 +geo2 = Geometry2( + sens_names=["Sensor1", "Sensor2"], + pts_coord=pd.DataFrame([[0, 0, 0], [1, 1, 1]], columns=["x", "y", "z"]), + sens_map=pd.DataFrame([["Sensor1", "Sensor2"]], columns=["Sensor1", "Sensor2"]) +) + +# Plot Geometry2 data using Matplotlib +plotter2 = Geo2MplPlotter(geo2) +plotter2.plot() + +# Visualize and animate Geometry2 data using PyVista +pv_plotter = PvGeoPlotter(geo2) +pv_plotter.plot_geo() +pv_plotter.animate_mode(mode_nr=1, saveGIF=True) +""" + +from .data import BaseGeometry, Geometry1, Geometry2 +from .mixin import GeometryMixin +from .mpl_plotter import Geo1MplPlotter, Geo2MplPlotter +from .pyvista_plotter import PvGeoPlotter diff --git a/src/pyoma2/support/geometry/data.py b/src/pyoma2/support/geometry/data.py new file mode 100644 index 0000000..edb02d3 --- /dev/null +++ b/src/pyoma2/support/geometry/data.py @@ -0,0 +1,118 @@ +from __future__ import annotations + +import typing + +import numpy as np +import numpy.typing as npt +import pandas as pd +from pydantic import BaseModel, ConfigDict + + +class BaseGeometry(BaseModel): + """ + Base class for storing and managing sensor and background geometry data. + + Attributes + ---------- + sens_names : List[str] + Names of the sensors. + sens_lines : numpy.ndarray of shape (n, 2), optional + An array representing lines between sensors, where each entry is a pair of + sensor indices. Default is None. + bg_nodes : numpy.ndarray of shape (m, 3), optional + An array of background nodes in 3D space. Default is None. + bg_lines : numpy.ndarray of shape (p, 2), optional + An array of lines between background nodes, where each entry is a pair of + node indices. Default is None. + bg_surf : numpy.ndarray of shape (q, 3), optional + An array of background surfaces, where each entry is a node index. + Default is None. + """ + + model_config = ConfigDict(from_attributes=True, arbitrary_types_allowed=True) + # MANDATORY + sens_names: typing.List[str] + # OPTIONAL + sens_lines: typing.Optional[npt.NDArray[np.int64]] = None # lines between sensors + bg_nodes: typing.Optional[npt.NDArray[np.float64]] = None # Background nodes + bg_lines: typing.Optional[npt.NDArray[np.int64]] = None # Background lines + bg_surf: typing.Optional[npt.NDArray[np.int64]] = None # Background surfaces + + +class Geometry1(BaseGeometry): + """ + Class for storing and managing sensor and background geometry data for Geometry 1. + + This class provides a structured way to store the coordinates and directions of + sensors, as well as optional background data such as nodes, lines, and surfaces. + + Attributes + ---------- + sens_names : List[str] + Names of the sensors. + sens_coord : pandas.DataFrame + A DataFrame containing the coordinates of each sensor. + sens_dir : numpy.ndarray of shape (n, 3) + An array representing the direction vectors of the sensors. + sens_lines : numpy.ndarray of shape (n, 2), optional + An array representing lines between sensors, where each entry is a pair of + sensor indices. Default is None. + bg_nodes : numpy.ndarray of shape (m, 3), optional + An array of background nodes in 3D space. Default is None. + bg_lines : numpy.ndarray of shape (p, 2), optional + An array of lines between background nodes, where each entry is a pair of + node indices. Default is None. + bg_surf : numpy.ndarray of shape (q, 3), optional + An array of background surfaces, where each entry is a node index. + Default is None. + """ + + # MANDATORY + sens_coord: pd.DataFrame # sensors' coordinates + sens_dir: npt.NDArray[np.int64] # sensors' directions + + +class Geometry2(BaseGeometry): + """ + Class for storing and managing sensor and background geometry data for Geometry 2. + + This class is designed to store sensor data and their associated point coordinates, + along with optional constraints and sensor surface information. It supports mapping + sensors to specific points in space, and includes optional background data for + further geometric analysis. + + Attributes + ---------- + sens_names : List[str] + Names of the sensors. + pts_coord : pandas.DataFrame + A DataFrame containing the coordinates of the points. + sens_map : pandas.DataFrame + A DataFrame mapping sensors to points locations. + cstrn : pandas.DataFrame, optional + A DataFrame of constraints applied to the points or sensors. Default is None. + sens_sign : pandas.DataFrame, optional + A DataFrame indicating the sign or orientation of the sensors. Default is None. + sens_lines : numpy.ndarray of shape (n, 2), optional + An array representing lines between sensors, where each entry is a pair of + sensor indices. Default is None. + sens_surf : numpy.ndarray of shape (p, ?), optional + An array representing surfaces between sensors, where each entry is a node index. + Default is None. + bg_nodes : numpy.ndarray of shape (m, 3), optional + An array of background nodes in 3D space. Default is None. + bg_lines : numpy.ndarray of shape (p, 2), optional + An array of lines between background nodes, where each entry is a pair of + node indices. Default is None. + bg_surf : numpy.ndarray of shape (q, 3), optional + An array of background surfaces, where each entry is a node index. + Default is None. + """ + + # MANDATORY + pts_coord: pd.DataFrame # points' coordinates + sens_map: pd.DataFrame # mapping sensors to points + # OPTIONAL + cstrn: typing.Optional[pd.DataFrame] = None + sens_sign: typing.Optional[pd.DataFrame] = None # sensors sign + sens_surf: typing.Optional[npt.NDArray[np.int64]] = None # surfaces between sensors diff --git a/src/pyoma2/support/geometry/mixin.py b/src/pyoma2/support/geometry/mixin.py new file mode 100644 index 0000000..f9549da --- /dev/null +++ b/src/pyoma2/support/geometry/mixin.py @@ -0,0 +1,779 @@ +from __future__ import annotations + +import typing +import warnings + +import matplotlib.pyplot as plt +import numpy as np +import numpy.typing as npt +import pandas as pd + +from pyoma2.algorithms.data.result import BaseResult +from pyoma2.functions.gen import ( + check_on_geo1, + check_on_geo2, + read_excel_file, +) + +from .data import Geometry1, Geometry2 +from .mpl_plotter import Geo1MplPlotter, Geo2MplPlotter +from .pyvista_plotter import PvGeoPlotter + +if typing.TYPE_CHECKING: + try: + import pyvista as pv + except ImportError: + warnings.warn( + "Optional package 'pyvista' is not installed. Some features may not be available.", + ImportWarning, + stacklevel=2, + ) + warnings.warn( + "Install 'pyvista' with 'pip install pyvista' or 'pip install pyoma_2[pyvista]'", + ImportWarning, + stacklevel=2, + ) + + +class GeometryMixin: + """ + Mixin that gives the ability to define the geometry the instance of the setup class. + + This mixin provides methods to define the geometry setups for the instance, including + sensor names, coordinates, directions, and optional elements like lines, surfaces, and + background nodes. It also includes methods to plot the geometry setups using Matplotlib + and PyVista for 2D and 3D visualization, respectively. + """ + + geo1: typing.Optional[Geometry1] = None + geo2: typing.Optional[Geometry2] = None + + def def_geo1( + self, + # # MANDATORY + sens_names: typing.Union[ + typing.List[str], + typing.List[typing.List[str]], + pd.DataFrame, + npt.NDArray[np.str_], + ], # sensors' names + sens_coord: pd.DataFrame, # sensors' coordinates + sens_dir: npt.NDArray[np.int64], # sensors' directions + # # OPTIONAL + sens_lines: npt.NDArray[np.int64] = None, # lines connecting sensors + bg_nodes: npt.NDArray[np.float64] = None, # Background nodes + bg_lines: npt.NDArray[np.int64] = None, # Background lines + bg_surf: npt.NDArray[np.float64] = None, # Background surfaces + ) -> None: + """ + Defines the first geometry setup (geo1) for the instance. + + This method sets up the geometry involving sensors' names, coordinates, directions, + and optional elements like sensor lines, background nodes, lines, and surfaces. + + Parameters + ---------- + sens_names : Union[numpy.ndarray of string, List of string] + An array or list containing the names of the sensors. + sens_coord : pandas.DataFrame + A DataFrame containing the coordinates of the sensors. + sens_dir : numpy.ndarray of int64 + An array defining the directions of the sensors. + sens_lines : numpy.ndarray of int64, optional + An array defining lines connecting sensors. Default is None. + bg_nodes : numpy.ndarray of float64, optional + An array defining background nodes. Default is None. + bg_lines : numpy.ndarray of int64, optional + An array defining background lines. Default is None. + bg_surf : numpy.ndarray of float64, optional + An array defining background surfaces. Default is None. + """ + # Get reference index (if any) + ref_ind = getattr(self, "ref_ind", None) + + # Assemble dictionary for check function + file_dict = { + "sensors names": sens_names, + "sensors coordinates": sens_coord, + "sensors directions": sens_dir, + "sensors lines": sens_lines if sens_lines is not None else pd.DataFrame(), + "BG nodes": bg_nodes if bg_nodes is not None else pd.DataFrame(), + "BG lines": bg_lines if bg_lines is not None else pd.DataFrame(), + "BG surfaces": bg_surf if bg_surf is not None else pd.DataFrame(), + } + + # check on input + res_ok = check_on_geo1(file_dict, ref_ind=ref_ind) + + self.geo1 = Geometry1( + sens_names=res_ok[0], + sens_coord=res_ok[1], + sens_dir=res_ok[2], + sens_lines=res_ok[3], + bg_nodes=res_ok[4], + bg_lines=res_ok[5], + bg_surf=res_ok[6], + ) + + # metodo per definire geometria 2 + def def_geo2( + self, + # MANDATORY + sens_names: typing.Union[ + typing.List[str], + typing.List[typing.List[str]], + pd.DataFrame, + npt.NDArray[np.str_], + ], # sensors' names + pts_coord: pd.DataFrame, # points' coordinates + sens_map: pd.DataFrame, # mapping + # OPTIONAL + cstr: pd.DataFrame = None, + sens_sign: pd.DataFrame = None, + sens_lines: npt.NDArray[np.int64] = None, # lines connecting sensors + sens_surf: npt.NDArray[np.int64] = None, # surf connecting sensors + bg_nodes: npt.NDArray[np.float64] = None, # Background nodes + bg_lines: npt.NDArray[np.float64] = None, # Background lines + bg_surf: npt.NDArray[np.float64] = None, # Background lines + ) -> None: + """ + Defines the second geometry setup (geo2) for the instance. + + This method sets up an alternative geometry configuration, including sensors' names, + points' coordinates, mapping, sign data, and optional elements like constraints, + sensor lines, background nodes, lines, and surfaces. + + Parameters + ---------- + sens_names : Union[list of str, list of list of str, pandas.DataFrame, numpy.ndarray of str] + Sensors' names. It can be a list of strings, a list of lists of strings, a DataFrame, or a NumPy array. + pts_coord : pandas.DataFrame + A DataFrame containing the coordinates of the points. + sens_map : pandas.DataFrame + A DataFrame containing the mapping data for sensors. + cstrn : pandas.DataFrame, optional + A DataFrame containing constraints. Default is None. + sens_sign : pandas.DataFrame, optional + A DataFrame containing sign data for the sensors. Default is None. + sens_lines : numpy.ndarray of int64, optional + An array defining lines connecting sensors. Default is None. + bg_nodes : numpy.ndarray of float64, optional + An array defining background nodes. Default is None. + bg_lines : numpy.ndarray of float64, optional + An array defining background lines. Default is None. + bg_surf : numpy.ndarray of float64, optional + An array defining background surfaces. Default is None. + + Notes + ----- + This method adapts indices for 0-indexed lines in `bg_lines`, `sens_lines`, and `bg_surf`. + """ + # Get reference index + ref_ind = getattr(self, "ref_ind", None) + + # Assemble dictionary for check function + file_dict = { + "sensors names": sens_names, + "points coordinates": pts_coord, + "mapping": sens_map, + "constraints": cstr if cstr is not None else pd.DataFrame(), + "sensors sign": sens_sign if sens_sign is not None else pd.DataFrame(), + "sensors lines": sens_lines if sens_lines is not None else pd.DataFrame(), + "sensors surfaces": sens_surf if sens_surf is not None else pd.DataFrame(), + "BG nodes": bg_nodes if bg_nodes is not None else pd.DataFrame(), + "BG lines": bg_lines if bg_lines is not None else pd.DataFrame(), + "BG surfaces": bg_surf if bg_surf is not None else pd.DataFrame(), + } + + # check on input + res_ok = check_on_geo2(file_dict, ref_ind=ref_ind) + + # Save to geometry + self.geo2 = Geometry2( + sens_names=res_ok[0], + pts_coord=res_ok[1].astype(float), + sens_map=res_ok[2], + cstrn=res_ok[3], + sens_sign=res_ok[4], + sens_lines=res_ok[5], + sens_surf=res_ok[6], + bg_nodes=res_ok[7], + bg_lines=res_ok[8], + bg_surf=res_ok[9], + ) + + def _def_geo_by_file( + self, geo_type: str, path: str, **read_excel_file_kwargs + ) -> None: + """ + Defines the geometry setup from an Excel file. + + This method reads an Excel file to extract sensor information, including sensor names, + coordinates, and other optional geometry elements such as lines and background nodes. + The information is used to set up the geometry for the instance. + + Parameters + ---------- + geo_type : str + The type of geometry to define: 'geo1' or 'geo2'. + path : str + The file path to the Excel file containing the geometry data. + read_excel_file_kwargs : dict, optional + Additional keyword arguments to pass to the `read_excel_file` function. + + Raises + ------ + ValueError + If the input data is invalid or missing required fields. + """ + # Get reference index + ref_ind = getattr(self, "ref_ind", None) + + # Read the Excel file + file_dict = read_excel_file(path=path, **read_excel_file_kwargs) + + # Check on input + if geo_type == "geo1": + res_ok = check_on_geo1(file_dict, ref_ind=ref_ind) + self.geo1 = Geometry1( + sens_names=res_ok[0], + sens_coord=res_ok[1], + sens_dir=res_ok[2], + sens_lines=res_ok[3], + bg_nodes=res_ok[4], + bg_lines=res_ok[5], + bg_surf=res_ok[6], + ) + elif geo_type == "geo2": + res_ok = check_on_geo2(file_dict, ref_ind=ref_ind) + self.geo2 = Geometry2( + sens_names=res_ok[0], + pts_coord=res_ok[1].astype(float), + sens_map=res_ok[2], + cstrn=res_ok[3], + sens_sign=res_ok[4], + sens_lines=res_ok[5], + sens_surf=res_ok[6], + bg_nodes=res_ok[7], + bg_lines=res_ok[8], + bg_surf=res_ok[9], + ) + else: + raise ValueError(f"Invalid geometry type: {geo_type}") + + # metodo per definire geometria 1 da file + def def_geo1_by_file(self, path: str, **read_excel_file_kwargs) -> None: + """ + Defines the first geometry (geo1) from an Excel file. + + This method reads an Excel file to extract sensor information, including sensor names, + coordinates, and other optional geometry elements such as lines and background nodes. + The information is used to set up the geometry for the instance. + + Parameters + ---------- + path : str + The file path to the Excel file containing the geometry data. + read_excel_file_kwargs : dict, optional + Additional keyword arguments to pass to the `read_excel_file` function. + + Raises + ------ + ValueError + If the input data is invalid or missing required fields. + """ + self._def_geo_by_file(geo_type="geo1", path=path, **read_excel_file_kwargs) + + def def_geo2_by_file(self, path: str, **read_excel_file_kwargs) -> None: + """ + Defines the second geometry (geo2) from an Excel file. + + This method reads an Excel file to extract information related to the geometry configuration, + including sensor names, points' coordinates, mapping, and optional background nodes and surfaces. + The information is used to set up the second geometry for the instance. + + Parameters + ---------- + path : str + The file path to the Excel file containing the geometry data. + read_excel_file_kwargs : dict, optional + Additional keyword arguments to pass to the `read_excel_file` function. + + Raises + ------ + ValueError + If the input data is invalid or missing required fields. + """ + self._def_geo_by_file(geo_type="geo2", path=path, **read_excel_file_kwargs) + + # PLOT GEO1 - mpl plotter + def plot_geo1( + self, + scaleF: int = 1, + view: typing.Literal["3D", "xy", "xz", "yz"] = "3D", + col_sns: str = "red", + col_sns_lines: str = "red", + col_BG_nodes: str = "gray", + col_BG_lines: str = "gray", + col_BG_surf: str = "gray", + col_txt: str = "red", + ) -> typing.Tuple[plt.Figure, plt.Axes]: + """ + Plots the first geometry setup (geo1) using Matplotlib. + + This method creates a 2D or 3D plot of the first geometry, including sensors, lines, background nodes, + and surfaces, using customizable color schemes for each element. + + Parameters + ---------- + scaleF : int, optional + Scaling factor for the plot. Default is 1. + view : {'3D', 'xy', 'xz', 'yz'}, optional + The view angle of the plot. Default is '3D'. + col_sns : str, optional + Color of the sensors. Default is 'red'. + col_sns_lines : str, optional + Color of the lines connecting sensors. Default is 'red'. + col_BG_nodes : str, optional + Color of the background nodes. Default is 'gray'. + col_BG_lines : str, optional + Color of the background lines. Default is 'gray'. + col_BG_surf : str, optional + Color of the background surfaces. Default is 'gray'. + col_txt : str, optional + Color of the text labels for sensors. Default is 'red'. + + Returns + ------- + tuple + A tuple containing the Matplotlib figure and axes objects. + + Raises + ------ + ValueError + If `geo1` is not defined. + """ + + if self.geo1 is None: + raise ValueError("geo1 is not defined. Call def_geo1 first.") + + Plotter = Geo1MplPlotter(self.geo1) + + fig, ax = Plotter.plot_geo( + scaleF, + view, + col_sns, + col_sns_lines, + col_BG_nodes, + col_BG_lines, + col_BG_surf, + col_txt, + ) + return fig, ax + + # PLOT GEO2 - PyVista plotter + def plot_geo2( + self, + scaleF: int = 1, + col_sens: str = "red", + plot_lines: bool = True, + plot_surf: bool = True, + points_sett: dict = "default", + lines_sett: dict = "default", + surf_sett: dict = "default", + bg_plotter: bool = True, + notebook: bool = False, + ) -> "pv.Plotter": + """ + Plots the second geometry setup (geo2) using PyVista for 3D visualization. + + This method creates a 3D interactive plot of the second geometry setup with options + to visualize sensor points, connecting lines, and surfaces. It provides various + customization options for coloring and rendering. + + Parameters + ---------- + scaleF : int, optional + Scaling factor for the plot. Default is 1. + col_sens : str, optional + Color of the sensors. Default is 'red'. + plot_lines : bool, optional + Whether to plot lines connecting sensors. Default is True. + plot_surf : bool, optional + Whether to plot surfaces connecting sensors. Default is True. + points_sett : dict, optional + Settings for the points' appearance. Default is 'default'. + lines_sett : dict, optional + Settings for the lines' appearance. Default is 'default'. + surf_sett : dict, optional + Settings for the surfaces' appearance. Default is 'default'. + bg_plotter : bool, optional + Whether to include a background plotter. Default is True. + notebook : bool, optional + Whether to render the plot in a Jupyter notebook environment. Default is False. + + Returns + ------- + pyvista.Plotter + A PyVista Plotter object with the geometry visualization. + + Raises + ------ + ValueError + If `geo2` is not defined. + """ + if self.geo2 is None: + raise ValueError("geo2 is not defined. Call def_geo2 first.") + + Plotter = PvGeoPlotter(self.geo2) + + pl = Plotter.plot_geo( + scaleF=scaleF, + col_sens=col_sens, + plot_lines=plot_lines, + plot_surf=plot_surf, + points_sett=points_sett, + lines_sett=lines_sett, + surf_sett=surf_sett, + pl=None, + bg_plotter=bg_plotter, + notebook=notebook, + ) + return pl + + # PLOT GEO2 - Matplotlib plotter + def plot_geo2_mpl( + self, + scaleF: int = 1, + view: typing.Literal["3D", "xy", "xz", "yz", "x", "y", "z"] = "3D", + col_sns: str = "red", + col_sns_lines: str = "black", + col_sns_surf: str = "lightcoral", + col_BG_nodes: str = "gray", + col_BG_lines: str = "gray", + col_BG_surf: str = "gray", + col_txt: str = "red", + ) -> typing.Tuple[plt.Figure, plt.Axes]: + """ + Plots the second geometry setup (geo2) using Matplotlib. + + This method creates a 2D or 3D plot of the second geometry, including sensors, lines, + surfaces, background nodes, and surfaces, with customizable colors. + + Parameters + ---------- + scaleF : int, optional + Scaling factor for the plot. Default is 1. + view : {'3D', 'xy', 'xz', 'yz', 'x', 'y', 'z'}, optional + The view angle of the plot. Default is '3D'. + col_sns : str, optional + Color of the sensors. Default is 'red'. + col_sns_lines : str, optional + Color of the lines connecting sensors. Default is 'black'. + col_sns_surf : str, optional + Color of the surfaces connecting sensors. Default is 'lightcoral'. + col_BG_nodes : str, optional + Color of the background nodes. Default is 'gray'. + col_BG_lines : str, optional + Color of the background lines. Default is 'gray'. + col_BG_surf : str, optional + Color of the background surfaces. Default is 'gray'. + col_txt : str, optional + Color of the text labels for sensors. Default is 'red'. + + Returns + ------- + tuple + A tuple containing the Matplotlib figure and axes objects. + + Raises + ------ + ValueError + If `geo2` is not defined. + """ + if self.geo2 is None: + raise ValueError("geo2 is not defined. Call def_geo2 first.") + + Plotter = Geo2MplPlotter(self.geo2) + + fig, ax = Plotter.plot_geo( + scaleF, + view, + col_sns, + col_sns_lines, + col_sns_surf, + col_BG_nodes, + col_BG_lines, + col_BG_surf, + col_txt, + ) + return fig, ax + + def plot_mode_geo1( + self, + algo_res: BaseResult, + mode_nr: int, + scaleF: int = 1, + view: typing.Literal["3D", "xy", "xz", "yz"] = "3D", + col_sns: str = "red", + col_sns_lines: str = "red", + col_BG_nodes: str = "gray", + col_BG_lines: str = "gray", + col_BG_surf: str = "gray", + ) -> typing.Tuple[plt.Figure, plt.Axes]: + """ + Plots the mode shapes for the first geometry setup (geo1) using Matplotlib. + + This method visualizes the mode shapes corresponding to the specified mode number, with customizable + colors and scaling for different geometrical elements such as sensors, lines, and background surfaces. + + Parameters + ---------- + algo_res : BaseResult + The result object containing modal parameters and mode shape data. + mode_nr : int + The mode number to be plotted. + scaleF : int, optional + Scaling factor to adjust the size of the mode shapes. Default is 1. + view : {'3D', 'xy', 'xz', 'yz'}, optional + The viewing plane or angle for the plot. Default is '3D'. + col_sns : str, optional + Color of the sensors in the plot. Default is 'red'. + col_sns_lines : str, optional + Color of the lines connecting the sensors. Default is 'red'. + col_BG_nodes : str, optional + Color of the background nodes in the plot. Default is 'gray'. + col_BG_lines : str, optional + Color of the background lines in the plot. Default is 'gray'. + col_BG_surf : str, optional + Color of the background surfaces in the plot. Default is 'gray'. + + Returns + ------- + tuple + A tuple containing the Matplotlib figure and axes objects for further customization or saving. + + Raises + ------ + ValueError + If `geo1` is not defined or if the algorithm results are missing. + """ + if self.geo1 is None: + raise ValueError("geo1 is not defined. Call def_geo1 first.") + + if algo_res.Fn is None: + raise ValueError("Run algorithm first") + Plotter = Geo1MplPlotter(self.geo1, algo_res) + + fig, ax = Plotter.plot_mode( + mode_nr, + scaleF, + view, + col_sns, + col_sns_lines, + col_BG_nodes, + col_BG_lines, + col_BG_surf, + ) + return fig, ax + + # PLOT MODI - PyVista plotter + def plot_mode_geo2( + self, + algo_res: BaseResult, + mode_nr: int = 1, + scaleF: float = 1.0, + plot_lines: bool = True, + plot_surf: bool = True, + plot_undef: bool = True, + def_sett: dict = "default", + undef_sett: dict = "default", + bg_plotter: bool = True, + notebook: bool = False, + *args, + **kwargs, + ) -> "pv.Plotter": + """ + Plots the mode shapes for the second geometry setup (geo2) using PyVista for interactive 3D visualization. + + This method uses PyVista for creating an interactive 3D plot of the mode shapes corresponding + to the specified mode number. The plot can include options for visualizing lines, surfaces, and + undeformed geometries, with customization for appearance settings. + + Parameters + ---------- + algo_res : BaseResult + The result object containing modal parameters and mode shape data. + mode_nr : int, optional + The mode number to be plotted. Default is 1. + scaleF : float, optional + Scaling factor for the mode shape visualization. Default is 1.0. + plot_lines : bool, optional + Whether to plot lines connecting sensors. Default is True. + plot_surf : bool, optional + Whether to plot surfaces connecting sensors. Default is True. + plot_undef : bool, optional + Whether to plot the undeformed geometry. Default is True. + def_sett : dict, optional + Settings for the deformed mode shapes. Default is 'default'. + undef_sett : dict, optional + Settings for the undeformed mode shapes. Default is 'default'. + bg_plotter : bool, optional + Whether to include a background plotter. Default is True. + notebook : bool, optional + Whether to render the plot in a Jupyter notebook. Default is False. + + Returns + ------- + pyvista.Plotter + A PyVista plotter object with the interactive 3D visualization. + + Raises + ------ + ValueError + If `geo2` is not defined or if the algorithm results are missing (e.g., `Fn` is None). + """ + + if self.geo2 is None: + raise ValueError("geo2 is not defined. Call def_geo2 first.") + + if algo_res.Fn is None: + raise ValueError("Run algorithm first") + + Plotter = PvGeoPlotter(self.geo2, algo_res) + + pl = Plotter.plot_mode( + mode_nr=mode_nr, + scaleF=scaleF, + plot_lines=plot_lines, + plot_surf=plot_surf, + plot_undef=plot_undef, + def_sett=def_sett, + undef_sett=undef_sett, + pl=None, + bg_plotter=bg_plotter, + notebook=notebook, + ) + return pl + + # PLOT MODI - Matplotlib plotter + def plot_mode_geo2_mpl( + self, + algo_res: BaseResult, + mode_nr: typing.Optional[int], + scaleF: int = 1, + view: typing.Literal["3D", "xy", "xz", "yz"] = "3D", + color: str = "cmap", + *args, + **kwargs, + ) -> typing.Tuple[plt.Figure, plt.Axes]: + """ + Plots the mode shapes for the second geometry setup (geo2) using Matplotlib. + + This method visualizes the mode shapes for geo2, with customizable scaling, color, and viewing options. + The plot can be configured for different modes and color maps. + + Parameters + ---------- + algo_res : BaseResult + The result object containing modal parameters and mode shape data. + mode_nr : int, optional + The mode number to be plotted. If None, the default mode is plotted. + scaleF : int, optional + Scaling factor to adjust the size of the mode shapes. Default is 1. + view : {'3D', 'xy', 'xz', 'yz'}, optional + The viewing plane or angle for the plot. Default is '3D'. + color : str, optional + Color scheme or colormap to be used for the mode shapes. Default is 'cmap'. + + Returns + ------- + tuple + A tuple containing the Matplotlib figure and axes objects for further customization or saving. + + Raises + ------ + ValueError + If `geo2` is not defined or if the algorithm results are missing (e.g., `Fn` is None). + """ + if self.geo2 is None: + raise ValueError("geo2 is not defined. Call def_geo2 first.") + + if algo_res.Fn is None: + raise ValueError("Run algorithm first") + + Plotter = Geo2MplPlotter(self.geo2, algo_res) + + fig, ax = Plotter.plot_mode(mode_nr, scaleF, view, color) + return fig, ax + + # PLOT MODI - PyVista plotter + def anim_mode_geo2( + self, + algo_res: BaseResult, + mode_nr: int = 1, + scaleF: float = 1.0, + pl=None, + plot_points: bool = True, + plot_lines: bool = True, + plot_surf: bool = True, + def_sett: dict = "default", + saveGIF: bool = False, + *args, + **kwargs, + ) -> "pv.Plotter": + """ + Creates an animation of the mode shapes for the second geometry setup (geo2) using PyVista. + + This method animates the mode shapes corresponding to the specified mode number, using + PyVista for interactive 3D visualization. It supports saving the animation as a GIF. + + Parameters + ---------- + algo_res : BaseResult + The result object containing modal parameters and mode shape data. + mode_nr : int, optional + The mode number to animate. Default is 1. + scaleF : float, optional + Scaling factor for the mode shape animation. Default is 1.0. + pl : pyvista.Plotter, optional + An existing PyVista plotter object for the animation. If None, a new plotter is created. + plot_points : bool, optional + Whether to plot sensor points. Default is True. + plot_lines : bool, optional + Whether to plot lines connecting sensors. Default is True. + plot_surf : bool, optional + Whether to plot surfaces connecting sensors. Default is True. + def_sett : dict, optional + Settings for the deformed mode shapes. Default is 'default'. + saveGIF : bool, optional + Whether to save the animation as a GIF. Default is False. + + Returns + ------- + pyvista.Plotter + A PyVista plotter object with the animated 3D visualization. + + Raises + ------ + ValueError + If `geo2` is not defined or if the algorithm results are missing (e.g., `Fn` is None). + """ + if self.geo2 is None: + raise ValueError("geo2 is not defined. Call def_geo2 first.") + + if algo_res.Fn is None: + raise ValueError("Run algorithm first") + + Plotter = PvGeoPlotter(self.geo2, algo_res) + + pl = Plotter.animate_mode( + mode_nr=mode_nr, + scaleF=scaleF, + plot_lines=plot_lines, + plot_surf=plot_surf, + def_sett=def_sett, + saveGIF=saveGIF, + pl=None, + ) + return pl diff --git a/src/pyoma2/support/geometry/mpl_plotter.py b/src/pyoma2/support/geometry/mpl_plotter.py new file mode 100644 index 0000000..9d9d8ea --- /dev/null +++ b/src/pyoma2/support/geometry/mpl_plotter.py @@ -0,0 +1,481 @@ +# -*- coding: utf-8 -*- +""" +Created on Sun Jun 9 12:48:34 2024 + +@author: dagpa +""" + +from __future__ import annotations + +import typing + +import matplotlib.pyplot as plt +import numpy as np + +from pyoma2.functions.gen import dfphi_map_func +from pyoma2.functions.plot import ( + plt_lines, + plt_nodes, + plt_quiver, + plt_surf, + set_ax_options, + set_view, +) + +from .data import Geometry1, Geometry2 +from .plotter import BasePlotter, T_Geo + + +class MplPlotter(BasePlotter[T_Geo]): + """An abstract base class for plotting geometry and mode shapes using Matplotlib.""" + + def _create_figure(self): + """Create and return a new figure and 3D axis.""" + fig = plt.figure(figsize=(8, 8), tight_layout=True) + ax = fig.add_subplot(111, projection="3d") + return fig, ax + + def _set_common_options(self, ax, scaleF, view): + """Set common axis options and view.""" + set_ax_options( + ax, + bg_color="w", + remove_fill=True, + remove_grid=True, + remove_axis=True, + scaleF=scaleF, + ) + set_view(ax, view=view) + + def _plot_background(self, ax, col_BG_nodes, col_BG_lines, col_BG_surf): + """Plot background nodes, lines, and surfaces if they exist.""" + if self.geo.bg_nodes is not None: + # if True plot + plt_nodes(ax, self.geo.bg_nodes, color=col_BG_nodes, alpha=0.5) + # Check that BG lines are defined + if self.geo.bg_lines is not None: + # if True plot + plt_lines( + ax, + self.geo.bg_nodes, + self.geo.bg_lines, + color=col_BG_lines, + alpha=0.5, + ) + if self.geo.bg_surf is not None: + # if True plot + plt_surf( + ax, self.geo.bg_nodes, self.geo.bg_surf, color=col_BG_surf, alpha=0.1 + ) + + +class Geo1MplPlotter(MplPlotter[Geometry1]): + """A class to plot mode shapes in 3D using Geometry1.""" + + def plot_geo( + self, + scaleF: int = 1, + view: typing.Literal["3D", "xy", "xz", "yz"] = "3D", + col_sns: str = "red", + col_sns_lines: str = "red", + col_BG_nodes: str = "gray", + col_BG_lines: str = "gray", + col_BG_surf: str = "gray", + col_txt: str = "red", + ) -> typing.Tuple[plt.Figure, plt.Axes]: + """ + Plots the geometry (type 1) of tested structure. + + This method visualizes the geometry of a structure, including sensor placements and directions. + It allows customization of the plot through various parameters such as scaling factor, + view type, and options to remove fill, grid, and axis from the plot. + + Parameters + ---------- + scaleF : int, optional + The scaling factor for the sensor direction quivers. A higher value results in + longer quivers. Default is 1. + view : {'3D', 'xy', 'xz', 'yz'}, optional + The type of view for plotting the geometry. Options include 3D and 2D projections + on various planes. Default is "3D". + remove_fill : bool, optional + If True, removes the fill from the plot. Default is True. + remove_grid : bool, optional + If True, removes the grid from the plot. Default is True. + remove_axis : bool, optional + If True, removes the axis labels and ticks from the plot. Default is True. + + Raises + ------ + ValueError + If Geo is not defined in the setup. + + Returns + ------- + tuple + A tuple containing the figure and axis objects of the plot. This can be used for + further customization or saving the plot externally. + + """ + fig, ax = self._create_figure() + + # plot sensors' nodes + sens_coord = self.geo.sens_coord[["x", "y", "z"]].to_numpy() + plt_nodes(ax, sens_coord, color=col_sns) + + # plot sensors' directions + plt_quiver( + ax, + sens_coord, + self.geo.sens_dir, + scaleF=scaleF, + names=self.geo.sens_names, + color=col_sns, + color_text=col_txt, + method="2", + ) + + self._plot_background(ax, col_BG_nodes, col_BG_lines, col_BG_surf) + + # check for sens_lines + if self.geo.sens_lines is not None: + plt_lines(ax, sens_coord, self.geo.sens_lines, color=col_sns_lines) + + self._set_common_options(ax, scaleF, view) + + return fig, ax + + def plot_mode( + self, + mode_nr: int, + scaleF: int = 1, + view: typing.Literal["3D", "xy", "xz", "yz"] = "3D", + col_sns: str = "red", + col_sns_lines: str = "red", + col_BG_nodes: str = "gray", + col_BG_lines: str = "gray", + col_BG_surf: str = "gray", + ) -> typing.Tuple[plt.Figure, plt.Axes]: + """ + Plots a 3D mode shape for a specified mode number using the Geometry1 object. + + Parameters + ---------- + Geo : Geometry1 + Geometry object containing sensor coordinates and other information. + mode_nr : int + Mode number to visualize. + scaleF : int, optional + Scale factor for mode shape visualization. Default is 1. + view : {'3D', 'xy', 'xz', 'yz'}, optional + View for the 3D plot. Default is '3D'. + remove_fill : bool, optional + Whether to remove fill from the plot. Default is True. + remove_grid : bool, optional + Whether to remove grid from the plot. Default is True. + remove_axis : bool, optional + Whether to remove axis from the plot. Default is True. + + Returns + ------- + typing.Any + A tuple containing the matplotlib figure and axes of the mode shape plot. + """ + if self.res.Fn is None: + raise ValueError("Run algorithm first") + + # Select the (real) mode shape + phi = self.res.Phi[:, int(mode_nr - 1)].real + fn = self.res.Fn[int(mode_nr - 1)] + + fig, ax = self._create_figure() + # Set title + ax.set_title(f"Mode nr. {mode_nr}, $f_n$={fn:.3f}Hz") + + # plot sensors' nodes + sens_coord = self.geo.sens_coord[["x", "y", "z"]].to_numpy() + plt_nodes(ax, sens_coord, color="red") + + # plot Mode shape + plt_quiver( + ax, + sens_coord, + self.geo.sens_dir * phi.reshape(-1, 1), + scaleF=scaleF, + method="2", + color=col_sns, + ) + + self._plot_background(ax, col_BG_nodes, col_BG_lines, col_BG_surf) + + # check for sens_lines + if self.geo.sens_lines is not None: + # if True plot + plt_lines(ax, sens_coord, self.geo.sens_lines, color=col_sns_lines) + + self._set_common_options(ax, scaleF, view) + + return fig, ax + + +class Geo2MplPlotter(MplPlotter[Geometry2]): + """A class to plot mode shapes in 3D using Geometry2.""" + + def plot_geo( + self, + scaleF: int = 1, + view: typing.Literal["3D", "xy", "xz", "yz"] = "3D", + col_sns: str = "red", + col_sns_lines: str = "black", + col_sns_surf: str = "lightcoral", + col_BG_nodes: str = "gray", + col_BG_lines: str = "gray", + col_BG_surf: str = "gray", + col_txt: str = "red", + ) -> typing.Tuple[plt.Figure, plt.Axes]: + """ + Plots the geometry (type 2) of tested structure. + + This method creates a 3D or 2D plot of a specific geometric configuration (geo2) with + customizable features such as scaling factor, view type, and visibility options for + fill, grid, and axes. It involves plotting sensor points, directions, and additional + geometric elements if available. + + Parameters + ---------- + scaleF : int, optional + Scaling factor for the quiver plots representing sensors' directions. Default is 1. + view : {'3D', 'xy', 'xz', 'yz'}, optional + Specifies the type of view for the plot. Can be a 3D view or 2D projections on + various planes. Default is "3D". + remove_fill : bool, optional + If True, the plot's fill is removed. Default is True. + remove_grid : bool, optional + If True, the plot's grid is removed. Default is True. + remove_axis : bool, optional + If True, the plot's axes are removed. Default is True. + + Raises + ------ + ValueError + If geo2 is not defined in the setup. + + Returns + ------- + tuple + Returns a tuple containing the figure and axis objects of the matplotlib plot. + This allows for further customization or saving outside the method. + """ + fig, ax = self._create_figure() + + # plot sensors' + pts = self.geo.pts_coord.to_numpy()[:, :] + plt_nodes(ax, pts, color="red") + + # plot sensors' directions + ch_names = self.geo.sens_map.to_numpy() + s_sign = self.geo.sens_sign.to_numpy().astype(float) + + zero2 = np.zeros((s_sign.shape[0], 2)) + s_sign[s_sign == 0] = np.nan + s_signs = [ + np.hstack((s_sign[:, 0].reshape(-1, 1), zero2)), + np.insert(zero2, 1, s_sign[:, 1], axis=1), + np.hstack((zero2, s_sign[:, 2].reshape(-1, 1))), + ] + + for i, s_sign_direction in enumerate(s_signs): + valid_indices = ch_names[:, i] != 0 + if np.any(valid_indices): + plt_quiver( + ax, + pts[valid_indices], + s_sign_direction[valid_indices], + scaleF=scaleF, + names=ch_names[valid_indices, i], + color=col_sns, + color_text=col_txt, + method="2", + ) + + self._plot_background(ax, col_BG_nodes, col_BG_lines, col_BG_surf) + + # check for sens_lines + if self.geo.sens_lines is not None: + # if True plot + plt_lines(ax, pts, self.geo.sens_lines, color=col_sns_lines) + + if self.geo.sens_surf is not None: + # if True plot + plt_surf( + ax, + self.geo.pts_coord.values, + self.geo.sens_surf, + color=col_sns_surf, + alpha=0.3, + ) + + self._set_common_options(ax, scaleF, view) + + return fig, ax + + def plot_mode( + self, + mode_nr: typing.Optional[int], + scaleF: int = 1, + view: typing.Literal["3D", "xy", "xz", "yz"] = "3D", + color: str = "cmap", + *args, + **kwargs, + ) -> typing.Tuple[plt.Figure, plt.Axes]: + """ + Plots a 3D mode shape for a specified mode number using the Geometry2 object. + + Parameters + ---------- + geo2 : Geometry2 + Geometry object containing nodes, sensor information, and additional geometrical data. + mode_nr : int + Mode number to visualize. + scaleF : int, optional + Scale factor for mode shape visualization. Default is 1. + view : {'3D', 'xy', 'xz', 'yz', 'x', 'y', 'z'}, optional + View for the 3D plot. Default is '3D'. + remove_fill : bool, optional + Whether to remove fill from the plot. Default is True. + remove_grid : bool, optional + Whether to remove grid from the plot. Default is True. + remove_axis : bool, optional + Whether to remove axis from the plot. Default is True. + *args, **kwargs + Additional arguments for customizations. + + Returns + ------- + typing.Tuple[plt.Figure, plt.Axes] + A tuple containing the matplotlib figure and axes of the mode shape plot. + """ + if self.res.Fn is None: + raise ValueError("Run algorithm first") + + # Select the (real) mode shape + fn = self.res.Fn[int(mode_nr - 1)] + phi = self.res.Phi[:, int(mode_nr - 1)].real * scaleF + + # APPLY POINTS TO SENSOR MAPPING + df_phi_map = dfphi_map_func( + phi, self.geo.sens_names, self.geo.sens_map, cstrn=self.geo.cstrn + ) + # add together coordinates and mode shape displacement + newpoints = ( + self.geo.pts_coord.to_numpy() + + df_phi_map.to_numpy() * self.geo.sens_sign.to_numpy() + ) + + # create fig and ax + fig, ax = self._create_figure() + ax.set_title(f"Mode nr. {mode_nr}, $f_n$={fn:.3f}Hz") + + self._plot_background(ax, "gray", "gray", "gray") + + # PLOT MODE SHAPE + if color == "cmap": + oldpoints = self.geo.pts_coord.to_numpy()[:, :] + plt_nodes(ax, newpoints, color="cmap", initial_coord=oldpoints) + + else: + plt_nodes(ax, newpoints, color=color) + # check for sens_lines + if self.geo.sens_lines is not None: + if color == "cmap": + plt_lines( + ax, + newpoints, + self.geo.sens_lines, + color="cmap", + initial_coord=oldpoints, + ) + else: + plt_lines(ax, newpoints, self.geo.sens_lines, color=color) + + if self.geo.sens_surf is not None: + if color == "cmap": + plt_surf( + ax, + newpoints, + self.geo.sens_surf, + color="cmap", + initial_coord=oldpoints, + alpha=0.4, + ) + else: + plt_surf(ax, newpoints, self.geo.sens_surf, color=color, alpha=0.4) + + self._set_common_options(ax, scaleF, view) + + return fig, ax + + +# # ============================================================================= +# # TEST +# # ============================================================================= +# # START - IMPORT DATA + +# # r"C:\Users\dpa\ +# # r"X:\ +# _geo1=r"C:\Users\dpa\OneDrive - Norsk Treteknisk Institutt\Dokumenter\Dev\pyomaTEST\HTC_geom\geo1.xlsx" +# _geo2=r"C:\Users\dpa\OneDrive - Norsk Treteknisk Institutt\Dokumenter\Dev\pyomaTEST\HTC_geom\Geo2_noBG.xlsx" +# _file=r"C:\Users\dpa\OneDrive - Norsk Treteknisk Institutt\Dokumenter\Dev\pyomaTEST\HTC_geom\PHI.npy" +# ref_ind = [[4, 5], [6, 7], [6, 7], [6, 7]] + +# # Load mode shape +# Phi=np.load(_file) + +# # Load geometry file +# Geo = import_excel_GEO1(_geo1,ref_ind) +# # Geo = import_excel_GEO2(_geo2,ref_ind) + +# # ============================================================================= +# # DEFINE GEOMETRY + +# Geo1 = Geometry1( +# sens_names=Geo[0], +# sens_coord=Geo[1], +# sens_dir=Geo[2].values, +# sens_lines=Geo[3], +# bg_nodes=Geo[4], +# bg_lines=Geo[5], +# bg_surf=Geo[6], +# ) + +# # Geo2 = Geometry2( +# # sens_names=Geo[0], +# # pts_coord=Geo[1], +# # sens_map=Geo[2], +# # cstrn=Geo[3], +# # sens_sign=Geo[4], +# # sens_lines=Geo[5], +# # sens_surf=Geo[6], +# # bg_nodes=Geo[7], +# # bg_lines=Geo[8], +# # bg_surf=Geo[9], +# # ) + +# Res = BaseResult( +# Fn= np.arange(Phi.shape[1]), +# Phi=Phi) + + +# # CREATE PLOTTER +# PlotterGeo1 = Geo1MplPlotter(Geo1, Res) +# PlotterGeo2 = Geo2MplPlotter(Geo2, Res) + +# # ============================================================================= +# # GEO1 +# PlotterGeo1.plot_geo(scaleF=8000) +# PlotterGeo1.plot_mode(mode_nr=6, scaleF=8000) + +# # ============================================================================= +# # GEO2 +# # PlotterGeo2.plot_geo(scaleF=8000) +# # PlotterGeo2.plot_mode(mode_nr=6, scaleF=8000) diff --git a/src/pyoma2/support/geometry/plotter.py b/src/pyoma2/support/geometry/plotter.py new file mode 100644 index 0000000..b9f8ad7 --- /dev/null +++ b/src/pyoma2/support/geometry/plotter.py @@ -0,0 +1,30 @@ +from __future__ import annotations + +import abc +import typing + +from pyoma2.algorithms.data.result import BaseResult + +from .data import BaseGeometry + +if typing.TYPE_CHECKING: + from pyoma2.algorithms.data.result import BaseResult + + +T_Geo = typing.TypeVar("T_Geo", bound=BaseGeometry) + + +class BasePlotter(typing.Generic[T_Geo], abc.ABC): + """An abstract base class for plotting geometry and mode shapes.""" + + def __init__(self, geo: T_Geo, res: typing.Optional[BaseResult] = None): + self.geo = geo + self.res = res + + @abc.abstractmethod + def plot_geo(self, *args, **kwargs): + """Plot the geometry.""" + + @abc.abstractmethod + def plot_mode(self, *args, **kwargs): + """Plot the mode shapes.""" diff --git a/src/pyoma2/support/geometry/pyvista_plotter.py b/src/pyoma2/support/geometry/pyvista_plotter.py new file mode 100644 index 0000000..228656e --- /dev/null +++ b/src/pyoma2/support/geometry/pyvista_plotter.py @@ -0,0 +1,485 @@ +# -*- coding: utf-8 -*- +""" +Created on Sat Jun 8 21:25:39 2024 + +@author: dagpa +""" + +import typing +import warnings + +import numpy as np + +from pyoma2.support.geometry.data import Geometry2 + +# import numpy.typing as npt +try: + import pyvista as pv + import pyvistaqt as pvqt +except ImportError: + warnings.warn( + "Optional package 'pyvista' is not installed. Some features may not be available.", + ImportWarning, + stacklevel=2, + ) + warnings.warn( + "Install 'pyvista' with 'pip install pyvista' or 'pip install pyoma_2[pyvista]'", + ImportWarning, + stacklevel=2, + ) + pv = None + pvqt = None +from pyoma2.algorithms.data.result import BaseResult +from pyoma2.functions import gen + +from .plotter import BasePlotter + +if typing.TYPE_CHECKING: + from pyoma2.support.geometry import Geometry2 + + +class PvGeoPlotter(BasePlotter[Geometry2]): + """ + A class to visualize and animate mode shapes in 3D using `pyvista`. + + This class provides methods for plotting geometry, mode shapes, and animating + mode shapes, utilizing the `pyvista` and `pyvistaqt` libraries for visualization. + + Parameters + ---------- + geo : Geometry2 + The geometric data of the model, which includes sensor coordinates and other + structural information. + Res : Union[BaseResult, MsPoserResult], optional + The result data containing mode shapes and frequency data (default is None). + + Raises + ------ + ImportError + If `pyvista` or `pyvistaqt` are not installed, an error is raised when attempting + to instantiate the class. + """ + + def __init__(self, geo: Geometry2, res: typing.Optional[BaseResult] = None): + """ + Initialize the class with geometric and result data. + Ensure that the `pyvista` and `pyvistaqt` libraries are installed. + """ + super().__init__(geo, res) + if pv is None or pvqt is None: + raise ImportError( + "Optional package 'pyvista' is not installed. Some features may not be available." + "Install 'pyvista' with 'pip install pyvista' or 'pip install pyoma_2[pyvista]'" + ) + + def plot_geo( + self, + scaleF=1, + col_sens="red", + plot_points=True, + points_sett="default", + plot_lines=True, + lines_sett="default", + plot_surf=True, + surf_sett="default", + pl=None, + bg_plotter: bool = True, + notebook: bool = False, + ): + """ + Plot the 3D geometry of the model, including points, lines, and surfaces. + + Parameters + ---------- + scaleF : float, optional + Scale factor for the sensor vectors (default is 1). + col_sens : str, optional + Color for the sensor points and arrows (default is 'red'). + plot_points : bool, optional + Whether to plot sensor points (default is True). + points_sett : dict or str, optional + Settings for plotting points (default is 'default', which applies preset settings). + plot_lines : bool, optional + Whether to plot lines representing connections between sensors (default is True). + lines_sett : dict or str, optional + Settings for plotting lines (default is 'default', which applies preset settings). + plot_surf : bool, optional + Whether to plot surfaces (default is True). + surf_sett : dict or str, optional + Settings for plotting surfaces (default is 'default', which applies preset settings). + pl : pyvista.Plotter, optional + Existing plotter instance to use (default is None, which creates a new plotter). + bg_plotter : bool, optional + Whether to use a background plotter for visualization (default is True). + notebook : bool, optional + If True, a plotter for use in Jupyter notebooks is created (default is False). + + Returns + ------- + pyvista.Plotter + The plotter object used for visualization. + + Notes + ----- + If `pyvistaqt` is used, a background plotter will be created. If running in + a notebook environment, a `pyvista` plotter with notebook support is used. + """ + # import geometry + geo = self.geo + + # define the plotter object type + if pl is None: + if notebook: + pl = pv.Plotter(notebook=True) + elif bg_plotter: + pl = pvqt.BackgroundPlotter() + else: + pl = pv.Plotter() + + # define default settings for plot + undef_sett = dict( + color="gray", + opacity=0.7, + ) + + if points_sett == "default": + points_sett = undef_sett + + if lines_sett == "default": + lines_sett = undef_sett + + if surf_sett == "default": + surf_sett = undef_sett + + # GEOMETRY + points = geo.pts_coord.to_numpy() + lines = geo.sens_lines + surfs = geo.sens_surf + # geometry in pyvista format + if lines is not None: + lines = np.array([np.hstack([2, line]) for line in lines]) + if surfs is not None: + surfs = np.array([np.hstack([3, surf]) for surf in surfs]) + + # PLOTTING + if plot_points: + pl.add_points(points, **points_sett) + if plot_lines: + line_mesh = pv.PolyData(points, lines=lines) + pl.add_mesh(line_mesh, **lines_sett) + if plot_surf: + face_mesh = pv.PolyData(points, faces=surfs) + pl.add_mesh(face_mesh, **surf_sett) + + # # Add axes + # pl.add_axes(line_width=5, labels_off=False) + # pl.show() + + # add sensor points + arrows for direction + sens_names = geo.sens_names + ch_names = geo.sens_map.to_numpy() + ch_names = np.array( + [name if name in sens_names else "nan" for name in ch_names.flatten()] + ).reshape(ch_names.shape) + + ch_names_fl = ch_names.flatten()[ch_names.flatten() != "nan"] + ch_names_fl = [str(ele) for ele in ch_names_fl] + # Plot points where ch_names_1 is not np.nan + valid_indices = ch_names != "nan" # FIXME + valid_points = points[np.any(valid_indices, axis=1)] + + pl.add_points( + valid_points, + render_points_as_spheres=True, + color=col_sens, + point_size=10, + ) + + points_new = [] + directions = [] + for i, (row1, row2) in enumerate(zip(ch_names, points)): + for j, elem in enumerate(row1): + if elem != "nan": + vector = [0, 0, 0] + # vector[j] = 1 + vector[j] = geo.sens_sign.values[i, j] + directions.append(vector) + points_new.append(row2) + + points_new = np.array(points_new) + directions = np.array(directions) + # Add arrow to plotter + pl.add_arrows(points_new, directions, mag=scaleF, color=col_sens) + pl.add_point_labels( + points_new + directions * scaleF, + ch_names_fl, + font_size=20, + always_visible=True, + shape_color="white", + ) + + # Add axes + pl.add_axes(line_width=5, labels_off=False) + pl.show() + + return pl + + def plot_mode( + self, + mode_nr: int = 1, + scaleF: float = 1.0, + plot_lines: bool = True, + plot_surf: bool = True, + plot_undef: bool = True, + def_sett: dict = "default", + undef_sett: dict = "default", + pl=None, + bg_plotter: bool = True, + notebook: bool = False, + ): + """ + Plot the mode shape of the structure for a given mode number. + + Parameters + ---------- + mode_nr : int, optional + The mode number to plot (default is 1). + scaleF : float, optional + Scale factor for the deformation (default is 1.0). + plot_lines : bool, optional + Whether to plot lines connecting sensor points (default is True). + plot_surf : bool, optional + Whether to plot surface meshes (default is True). + plot_undef : bool, optional + Whether to plot the undeformed shape of the structure (default is True). + def_sett : dict or str, optional + Settings for the deformed plot (default is 'default', which applies preset settings). + undef_sett : dict or str, optional + Settings for the undeformed plot (default is 'default', which applies preset settings). + pl : pyvista.Plotter, optional + Existing plotter instance to use (default is None, which creates a new plotter). + bg_plotter : bool, optional + Whether to use a background plotter for visualization (default is True). + notebook : bool, optional + If True, a plotter for use in Jupyter notebooks is created (default is False). + + Returns + ------- + pyvista.Plotter + The plotter object used for visualization. + + Raises + ------ + ValueError + If the result (`Res`) data is not provided when plotting a mode shape. + """ + # import geometry and results + geo = self.geo + res = self.res + + # define the plotter object type + if pl is None: + if notebook: + pl = pv.Plotter(notebook=True) + elif bg_plotter: + pl = pvqt.BackgroundPlotter() + else: + pl = pv.Plotter() + + # define default settings for plot + def_settings = dict(cmap="plasma", opacity=0.7, show_scalar_bar=False) + undef_settings = dict(color="gray", opacity=0.3) + + if def_sett == "default": + def_sett = def_settings + + if undef_sett == "default": + undef_sett = undef_settings + + # GEOMETRY + points = geo.pts_coord.to_numpy() + lines = geo.sens_lines + surfs = geo.sens_surf + # geometry in pyvista format + if lines is not None: + lines = np.array([np.hstack([2, line]) for line in lines]) + if surfs is not None: + surfs = np.array([np.hstack([3, surf]) for surf in surfs]) + + # Mode shape + if res is not None: + phi = res.Phi[:, int(mode_nr - 1)].real * scaleF + else: + raise ValueError("You must pass the Res class to plot a mode shape!") + + # APPLY POINTS TO SENSOR MAPPING + df_phi_map = gen.dfphi_map_func( + phi, geo.sens_names, geo.sens_map, cstrn=geo.cstrn + ) + # calculate deformed shape (NEW POINTS) + newpoints = points + df_phi_map.to_numpy() * geo.sens_sign.to_numpy() + + # If true plot undeformed shape + if plot_undef: + pl.add_points(points, **undef_sett) + if plot_lines: + line_mesh = pv.PolyData(points, lines=lines) + pl.add_mesh(line_mesh, **undef_sett) + if plot_surf: + face_mesh = pv.PolyData(points, faces=surfs) + pl.add_mesh(face_mesh, **undef_sett) + + # PLOT MODE SHAPE + pl.add_points(newpoints, scalars=df_phi_map.values, **def_sett) + if plot_lines: + line_mesh = pv.PolyData(newpoints, lines=lines) + pl.add_mesh(line_mesh, scalars=df_phi_map.values, **def_sett) + if plot_surf: + face_mesh = pv.PolyData(newpoints, faces=surfs) + pl.add_mesh(face_mesh, scalars=df_phi_map.values, **def_sett) + + pl.add_text( + rf"Mode nr. {mode_nr}, fn = {res.Fn[mode_nr-1]:.3f}Hz", + position="upper_edge", + color="black", + # font_size=26, + ) + pl.add_axes(line_width=5, labels_off=False) + pl.show() + + return pl + + def animate_mode( + self, + mode_nr: int = 1, + scaleF: float = 1.0, + plot_lines: bool = True, + plot_surf: bool = True, + def_sett: dict = "default", + saveGIF: bool = False, + pl=None, + ) -> "pv.Plotter": + """ + Animate the mode shape for the given mode number. + + Parameters + ---------- + mode_nr : int, optional + The mode number to animate (default is 1). + scaleF : float, optional + Scale factor for the deformation (default is 1.0). + plot_lines : bool, optional + Whether to plot lines connecting sensor points (default is True). + plot_surf : bool, optional + Whether to plot surface meshes (default is True). + def_sett : dict or str, optional + Settings for the deformed plot (default is 'default', which applies preset settings). + saveGIF : bool, optional + If True, the animation is saved as a GIF (default is False). + pl : pyvista.Plotter, optional + Existing plotter instance to use (default is None, which creates a new plotter). + + Returns + ------- + pyvista.Plotter + The plotter object used for the animation. + """ + # define default settings for plot + def_settings = dict(cmap="plasma", opacity=0.7, show_scalar_bar=False) + if def_sett == "default": + def_sett = def_settings + + # import geometry and results + geo = self.geo + res = self.res + points = pv.pyvista_ndarray(geo.pts_coord.to_numpy()) + lines = geo.sens_lines + surfs = geo.sens_surf + + if lines is not None: + lines = np.array([np.hstack([2, line]) for line in lines]) + if surfs is not None: + surfs = np.array([np.hstack([3, surf]) for surf in surfs]) + + # Mode shape + phi = res.Phi[:, int(mode_nr - 1)].real * scaleF + + # mode shape mapped to points + df_phi_map = gen.dfphi_map_func( + phi, geo.sens_names, geo.sens_map, cstrn=geo.cstrn + ) + sens_sign = geo.sens_sign.to_numpy() + + # copy points since we will deform them + points_c = points.copy() + + if pl is None: + pl = pv.Plotter(off_screen=False) if saveGIF else pvqt.BackgroundPlotter() + + # Add initial meshes + def_pts = pl.add_points(points_c, scalars=df_phi_map.values, **def_sett) + + if plot_lines: + line_mesh = pv.PolyData(points_c, lines=lines) + pl.add_mesh(line_mesh, scalars=df_phi_map.values, **def_sett) + else: + line_mesh = None + + if plot_surf: + face_mesh = pv.PolyData(points_c, faces=surfs) + pl.add_mesh(face_mesh, scalars=df_phi_map.values, **def_sett) + else: + face_mesh = None + + pl.add_text( + rf"Mode nr. {mode_nr}, fn = {res.Fn[mode_nr-1]:.3f}Hz", + position="upper_edge", + color="black", + ) + + if saveGIF: + # GIF saving logic (unchanged) + pl.enable_anti_aliasing("fxaa") + n_frames = 30 + pl.open_gif(f"Mode nr. {mode_nr}.gif") + frames = np.linspace(0, 2 * np.pi, n_frames, endpoint=False) + for phase in frames: + new_coords = points + df_phi_map.to_numpy() * sens_sign * np.cos(phase) + def_pts.mapper.dataset.points = new_coords + if line_mesh is not None: + line_mesh.points = new_coords + if face_mesh is not None: + face_mesh.points = new_coords + pl.add_axes(line_width=5, labels_off=False) + pl.write_frame() + pl.show(auto_close=False) + + else: + # Interactive animation using callback + n_frames = 30 + frames = np.linspace(0, 2 * np.pi, n_frames, endpoint=False) + self._current_frame = 0 # track current frame externally + + def update_shape(): + # Update just one frame per callback call + phase = frames[self._current_frame] + new_coords = points + df_phi_map.to_numpy() * sens_sign * np.cos(phase) + def_pts.mapper.dataset.points = new_coords + if line_mesh is not None: + line_mesh.points = new_coords + if face_mesh is not None: + face_mesh.points = new_coords + pl.update() + + # Move to the next frame + self._current_frame = (self._current_frame + 1) % n_frames + + # Add the callback to run every 100 ms (for example) + pl.add_callback(update_shape, interval=100) + + # Make sure to start the interactive session + # If using BackgroundPlotter, it typically shows automatically. + # If not, uncomment pl.show() below. + pl.show() + + return pl diff --git a/src/pyoma2/support/sel_from_plot.py b/src/pyoma2/support/sel_from_plot.py new file mode 100644 index 0000000..a8e7424 --- /dev/null +++ b/src/pyoma2/support/sel_from_plot.py @@ -0,0 +1,440 @@ +""" +Module for interactive plots. +Part of the pyOMA2 package. +Authors: +Dag Pasca +Diego Margoni + +This module provides the SelFromPlot class for interactive selection of poles in +operational modal analysis plots. It supports FDD, SSI, and pLSCF methods and +integrates matplotlib plots into a Tkinter window for user interaction. +""" + +from __future__ import annotations + +import glob +import logging +import os +import tkinter as tk +import typing +from typing import Literal, Tuple + +import numpy as np +from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg, NavigationToolbar2Tk +from matplotlib.figure import Figure + +if typing.TYPE_CHECKING: + from pyoma2.algorithms import BaseAlgorithm + +from pyoma2.functions.plot import CMIF_plot, stab_plot + +logger = logging.getLogger(__name__) + +# ============================================================================= +# PLOTTING CLASS +# ============================================================================= + + +class SelFromPlot: + """ + A class for interactive selection of poles. + + This class integrates matplotlib plots into a Tkinter window, enabling users to interactively + select or deselect poles using mouse clicks and keyboard shortcuts. It supports FDD, SSI, and + pLSCF methods for operational modal analysis. The design and functionality of this class is + strongly inspired by the pyEMA module [ZBGS20]_. + + Attributes + ---------- + algo : BaseAlgorithm + An instance of a base algorithm class that provides necessary data for plotting. + freqlim : tuple, optional + Upper frequency limit for the plot, defaults to half the Nyquist frequency if not provided. + plot : str + Type of plot to be displayed. Supported values are "FDD", "SSI", and "pLSCF". + root : tkinter.Tk + Root widget of the Tkinter application. + sel_freq : list + List of selected frequencies. + shift_is_held : bool + Flag to track if the SHIFT key is held down during mouse interactions. + fig : matplotlib.figure.Figure + Matplotlib Figure object for plotting. + ax2 : matplotlib.axes.Axes + Axes object for the figure. + MARKER : matplotlib.lines.Line2D + Line2D object for displaying selected points on the plot. + show_legend : int + Flag to control the visibility of the legend in the plot. + hide_poles : int + Flag to control the visibility of unstable poles in the plot. + """ + + def __init__( + self, + algo: BaseAlgorithm, + freqlim: Tuple[float, float] = None, + plot: Literal["FDD", "SSI", "pLSCF"] = "FDD", + ): + """ + Initializes the SelFromPlot class with specified algorithm, frequency limit, and plot type. + + Parameters + ---------- + algo : BaseAlgorithm + An instance of a base algorithm class providing necessary data for plotting. + freqlim : tuple, optional + Upper frequency limit for the plot, defaults to half the Nyquist frequency if not provided. + plot : str, optional + Type of plot to be displayed. Supported values are "FDD", "SSI", and "pLSCF". Default is "FDD". + """ + self.algo = algo + self.plot = plot + self.fs = self.algo.fs + self.freqlim = freqlim if freqlim is not None else (0.0, self.fs / 2) + self.shift_is_held = False + self.sel_freq = [] + + if self.plot in ("SSI", "pLSCF"): + self.show_legend = 0 + self.hide_poles = 1 + self.pole_ind = [] + elif self.plot == "FDD": + self.freq_ind = [] + + self._initialize_gui() + + if self.plot in ("SSI", "pLSCF"): + self.plot_stab(self.plot) + elif self.plot == "FDD": + self.plot_svPSD() + + self.root.mainloop() + + if self.plot in ("SSI", "pLSCF"): + self.result = self.sel_freq, self.pole_ind + elif self.plot == "FDD": + self.result = self.sel_freq, None + + def _initialize_gui(self) -> None: + """ + Initializes the Tkinter GUI components. + """ + self.root = tk.Tk() + self.root.title( + "Stabilisation Chart" + if self.plot in ("SSI", "pLSCF") + else "Singular Values of PSD matrix" + ) + + self.fig = Figure(figsize=(12, 6), tight_layout=True) + self.ax2 = self.fig.add_subplot(111) + + menubar = tk.Menu(self.root) + filemenu = tk.Menu(menubar, tearoff=0) + filemenu.add_command(label="Save figure", command=self.save_this_figure) + menubar.add_cascade(label="File", menu=filemenu) + + if self.plot in ("SSI", "pLSCF"): + hidepolesmenu = tk.Menu(menubar, tearoff=0) + hidepolesmenu.add_command( + label="Show unstable poles", + command=lambda: (self.toggle_hide_poles(0), self.toggle_legend(1)), + ) + hidepolesmenu.add_command( + label="Hide unstable poles", + command=lambda: (self.toggle_hide_poles(1), self.toggle_legend(0)), + ) + menubar.add_cascade(label="Show/Hide Unstable Poles", menu=hidepolesmenu) + + helpmenu = tk.Menu(menubar, tearoff=0) + helpmenu.add_command(label="Help", command=self.show_help) + menubar.add_cascade(label="Help", menu=helpmenu) + + self.root.config(menu=menubar) + + canvas = FigureCanvasTkAgg(self.fig, self.root) + self.ax2.grid() + canvas.get_tk_widget().pack(side="top", fill="both", expand=1) + NavigationToolbar2Tk(canvas, self.root) + + self.fig.canvas.mpl_connect("key_press_event", self.on_key_press) + self.fig.canvas.mpl_connect("key_release_event", self.on_key_release) + if self.plot in ("SSI", "pLSCF"): + self.fig.canvas.mpl_connect( + "button_press_event", lambda event: self.on_click_SSI(event, self.plot) + ) + elif self.plot == "FDD": + self.fig.canvas.mpl_connect("button_press_event", self.on_click_FDD) + + self.root.protocol("WM_DELETE_WINDOW", self.on_closing) + + def plot_svPSD(self, update_ticks: bool = False) -> None: + """ + Plots the Singular Values of the Power Spectral Density matrix for FDD analysis. + + Parameters + ---------- + update_ticks : bool, optional + Flag indicating whether to update tick marks for selected frequencies. Default is False. + """ + freq = self.algo.result.freq + S_val = self.algo.result.S_val + + if not update_ticks: + self.ax2.clear() + CMIF_plot(S_val, freq, freqlim=self.freqlim, fig=self.fig, ax=self.ax2) + # Compute the y-values for the selected frequencies + marker_y_values = [ + 10 + * np.log10( + (S_val[0, 0, i] / S_val[0, 0, np.argmax(S_val[0, 0, :])]) * 1.25 + ) + for i in self.freq_ind + ] + (self.MARKER,) = self.ax2.plot( + self.sel_freq, marker_y_values, "kv", markersize=8 + ) + else: + marker_y_values = [ + 10 + * np.log10( + (S_val[0, 0, i] / S_val[0, 0, np.argmax(S_val[0, 0, :])]) * 1.25 + ) + for i in self.freq_ind + ] + self.MARKER.set_xdata(np.asarray(self.sel_freq)) + self.MARKER.set_ydata(marker_y_values) + + self.ax2.grid(True) # Ensure grid is always displayed + self.fig.canvas.draw_idle() # Use draw_idle for better performance and interaction handling + + def get_closest_freq(self) -> None: + """ + Selects the frequency closest to the mouse click location for FDD plots. + """ + freq = self.algo.result.freq + sel = np.argmin(np.abs(freq - self.x_data_pole)) + self.freq_ind.append(sel) + self.sel_freq.append(freq[sel]) + self.sort_selected_poles() + + def plot_stab( + self, plot: Literal["SSI", "pLSCF"], update_ticks: bool = False + ) -> None: + """ + Plots the stabilization chart for SSI or pLSCF methods. + + Parameters + ---------- + plot : str + Type of plot to be displayed ("SSI" or "pLSCF"). + update_ticks : bool, optional + Flag indicating whether to update tick marks for selected poles. Default is False. + """ + freqlim = self.freqlim + hide_poles = self.hide_poles + + Fn = self.algo.result.Fn_poles + Lab = self.algo.result.Lab + + # step = self.algo.run_params.step + ordmin = self.algo.run_params.ordmin + ordmax = self.algo.run_params.ordmax + + if not update_ticks: + self.ax2.clear() + stab_plot( + Fn, + Lab, + 1, + ordmax, + ordmin=ordmin, + freqlim=freqlim, + hide_poles=hide_poles, + fig=self.fig, + ax=self.ax2, + ) + (self.MARKER,) = self.ax2.plot( + self.sel_freq, self.pole_ind, "kx", markersize=10 + ) + else: + self.MARKER.set_xdata(np.asarray(self.sel_freq)) + self.MARKER.set_ydata(self.pole_ind) + + self.ax2.grid(True) # Ensure grid is always displayed + self.fig.canvas.draw_idle() # Use draw_idle for better performance and interaction handling + + def get_closest_pole(self, plot: Literal["SSI", "pLSCF"]) -> None: + """ + Selects the pole closest to the mouse click location for SSI or pLSCF plots. + + Parameters + ---------- + plot : str + Type of plot ("SSI" or "pLSCF") for which the pole is being selected. + """ + if plot in ("SSI", "pLSCF"): + Fn_poles = self.algo.result.Fn_poles + + y_ind = int(np.argmin(np.abs(np.arange(Fn_poles.shape[1]) - self.y_data_pole))) + x = Fn_poles[:, y_ind] + sel = np.nanargmin(np.abs(x - self.x_data_pole)) + + self.pole_ind.append(y_ind) + self.sel_freq.append(Fn_poles[sel, y_ind]) + + self.sort_selected_poles() + + def on_click_FDD(self, event) -> None: + """ + Handles mouse click events for FDD plots. + + Parameters + ---------- + event : matplotlib.backend_bases.MouseEvent + The mouse event triggered on the plot. + """ + if event.button == 1 and self.shift_is_held: + self.y_data_pole = [event.ydata] + self.x_data_pole = event.xdata + self.get_closest_freq() + self.plot_svPSD() + + elif event.button == 3 and self.shift_is_held: + if self.sel_freq and self.freq_ind: + self.sel_freq.pop() + self.freq_ind.pop() + self.plot_svPSD() + + elif event.button == 2 and self.shift_is_held: + if self.sel_freq and self.freq_ind: + i = np.argmin(np.abs(self.sel_freq - event.xdata)) + self.sel_freq.pop(i) + self.freq_ind.pop(i) + self.plot_svPSD() + + def on_click_SSI(self, event, plot: Literal["SSI", "pLSCF"]) -> None: + """ + Handles mouse click events for SSI or pLSCF plots. + + Parameters + ---------- + event : matplotlib.backend_bases.MouseEvent + The mouse event triggered on the plot. + plot : str + Type of plot ("SSI" or "pLSCF") where the event occurred. + """ + if event.button == 1 and self.shift_is_held: + self.y_data_pole = [event.ydata] + self.x_data_pole = event.xdata + self.get_closest_pole(plot) + self.plot_stab(plot) + + elif event.button == 3 and self.shift_is_held: + if self.sel_freq and self.pole_ind: + self.sel_freq.pop() + self.pole_ind.pop() + self.plot_stab(plot) + + elif event.button == 2 and self.shift_is_held: + if self.sel_freq and self.pole_ind: + i = np.argmin(np.abs(self.sel_freq - event.xdata)) + self.sel_freq.pop(i) + self.pole_ind.pop(i) + self.plot_stab(plot) + + def on_key_press(self, event) -> None: + """ + Handles key press events for interactive pole selection. + + Parameters + ---------- + event : matplotlib.backend_bases.KeyEvent + The key event triggered on the plot. + """ + if event.key == "shift": + self.shift_is_held = True + + def on_key_release(self, event) -> None: + """ + Handles key release events. + + Parameters + ---------- + event : matplotlib.backend_bases.KeyEvent + The key event triggered on the plot. + """ + if event.key == "shift": + self.shift_is_held = False + + def on_closing(self) -> None: + """ + Handles the closing event of the Tkinter window. + """ + self.root.quit() + self.root.destroy() + + def toggle_legend(self, x: int) -> None: + """ + Toggles the visibility of the legend in the plot. + + Parameters + ---------- + x : int + Flag indicating whether to show (1) or hide (0) the legend. + """ + self.show_legend = bool(x) + self.plot_stab(self.plot) + + def toggle_hide_poles(self, x: int) -> None: + """ + Toggles the visibility of unstable poles in the plot. + + Parameters + ---------- + x : int + Flag indicating whether to hide (1) or show (0) unstable poles. + """ + self.hide_poles = bool(x) + self.plot_stab(self.plot) + + def sort_selected_poles(self) -> None: + """ + Sorts the selected poles based on their frequencies. + """ + sorted_indices = np.argsort(self.sel_freq) + self.sel_freq = list(np.array(self.sel_freq)[sorted_indices]) + + def show_help(self) -> None: + """ + Displays a help dialog with instructions for selecting poles. + """ + lines = [ + "Pole selection help", + " ", + "- Select a pole: SHIFT + LEFT mouse button", + "- Deselect a pole: SHIFT + RIGHT mouse button", + "- Deselect the closest pole (frequency wise): SHIFT + MIDDLE mouse button", + ] + tk.messagebox.showinfo("Picking poles", "\n".join(lines)) + + def save_this_figure(self) -> None: + """ + Saves the current plot to a file. + """ + filename = "pole_chart_" + directory = "pole_figures" + + if not os.path.exists(directory): + os.mkdir(directory) + + files = glob.glob(directory + "/*.png") + i = 1 + while True: + f = os.path.join(directory, f"{filename}{i:03}.png") + if f not in files: + break + i += 1 + + self.fig.savefig(f) diff --git a/src/pyoma2/support/utils/logging_handler.py b/src/pyoma2/support/utils/logging_handler.py new file mode 100644 index 0000000..254b6a6 --- /dev/null +++ b/src/pyoma2/support/utils/logging_handler.py @@ -0,0 +1,64 @@ +""" +Logging handler. +Part of the pyOMA2 package. +Authors: +Diego Margoni +""" + +import logging +import os + + +def configure_logging() -> logging.Logger: + """ + Configures and initializes logging for the pyOMA2 package. + + The function sets up a root logger specifically for the package with a logging level determined by + an environment variable. It also configures a console handler to output log messages with a specific + format, including timestamp, logger name, log level, message, module, and line number. Optionally, + this function can disable logging from the 'matplotlib' library based on an environment variable. + + Environment Variables + --------------------- + PYOMA_LOG_LEVEL : str, optional + Defines the logging level for the pyOMA2 logger. Acceptable values include 'DEBUG', 'INFO', 'WARNING', + 'ERROR', and 'CRITICAL'. Defaults to 'INFO' if not specified. + PYOMA_DISABLE_MATPLOTLIB_LOGGING : str, optional + If set to 'True' or '1', disables logging from the 'matplotlib' library. Defaults to 'True'. + + Returns + ------- + logging.Logger + The configured root logger for the pyOMA2 package. + + Notes + ----- + - The logger's name is set to 'pyoma2'. + - The logger outputs to the console. + - The log format includes the timestamp, logger name, log level, message, and the module and line number + where the log was generated. + """ + # Read logging level from environment variable with a default of INFO + log_level = os.getenv("PYOMA_LOG_LEVEL", "INFO").upper() + level = getattr(logging, log_level, logging.INFO) + + # Create a root logger + logger = logging.getLogger(name="pyoma2") + logger.setLevel(level) + + # Create a console handler and set its level + ch = logging.StreamHandler() + ch.setLevel(level) # Set level from environment variable + + # log also module and line number and level + formatter = logging.Formatter( + "%(asctime)s - %(name)s - %(levelname)s - %(message)s (%(module)s:%(lineno)d)" + ) + ch.setFormatter(formatter) + # Add the handlers to the logger + logger.addHandler(ch) + + # disable logging from matplotlib + if os.getenv("PYOMA_DISABLE_MATPLOTLIB_LOGGING", "True") in ["True", "true", "1"]: + logging.getLogger("matplotlib").setLevel(logging.CRITICAL + 1) + return logger diff --git a/src/pyoma2/support/utils/sample_data.py b/src/pyoma2/support/utils/sample_data.py new file mode 100644 index 0000000..8d31163 --- /dev/null +++ b/src/pyoma2/support/utils/sample_data.py @@ -0,0 +1,53 @@ +import logging +import os +import typing +from pathlib import Path + +import requests + +logger = logging.getLogger(__name__) + +SAMPLE_DATA_DEFAULT_LOCAL_DIR: Path = Path("./.pyoma2_data/test_data/") + + +def get_sample_data( + filename: str, + folder: str, + local_dir: typing.Union[str, Path] = SAMPLE_DATA_DEFAULT_LOCAL_DIR, +): + """ + Download a sample data file from the specified GitHub repository if it doesn't exist locally. + + Args: + filename (str): Name of the file to download. + folder (str): Folder in the GitHub repository where the file is located. + local_dir (str): Local directory to save the file. + + Returns: + str: Path to the local file. + + Raises: + Exception: If there is an error downloading the file. + """ + try: + local_dir = str(local_dir) + github_raw_url = f"https://raw.githubusercontent.com/dagghe/pyOMA-test-data/main/test_data/{folder}/{filename}" + local_file_path = Path(local_dir) / folder / filename + + if not local_file_path.exists(): + logger.info("Downloading %s from GitHub...", filename) + # Create the directory if it doesn't exist + os.makedirs(local_file_path.parent, exist_ok=True) + # Download the file + response = requests.get(url=github_raw_url, timeout=60) + response.raise_for_status() # Raise an exception for HTTP errors + # Save the file locally + with open(local_file_path, "wb") as f: + f.write(response.content) + logger.info("Downloaded %s successfully.", filename) + else: + logger.info("%s already exists locally.", filename) + except Exception as e: + logger.error("Error downloading %s: %s", filename, e) + raise e + return str(local_file_path) diff --git a/src/pyoma2/support/utils/typing.py b/src/pyoma2/support/utils/typing.py new file mode 100644 index 0000000..997b882 --- /dev/null +++ b/src/pyoma2/support/utils/typing.py @@ -0,0 +1,26 @@ +"""Custom types for pydantic models. + +i.e. allow serialization of numpy arrays. +https://github.com/pydantic/pydantic/issues/7017 +""" + +import numpy as np +from pydantic import BeforeValidator, PlainSerializer +from typing_extensions import Annotated + + +def nd_array_custom_before_validator(x): + # custome before validation logic + return x + + +def nd_array_custom_serializer(x): + # custome serialization logic + return str(x) + + +NdArray = Annotated[ + np.ndarray, + BeforeValidator(nd_array_custom_before_validator), + PlainSerializer(nd_array_custom_serializer, return_type=str), +] diff --git a/tests/__init__.py b/tests/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/tests/conftest.py b/tests/conftest.py new file mode 100644 index 0000000..b5a6520 --- /dev/null +++ b/tests/conftest.py @@ -0,0 +1,278 @@ +from __future__ import annotations + +import shutil +import sys +import typing +import unittest.mock +from unittest.mock import MagicMock + +if typing.TYPE_CHECKING: + from pyoma2.setup import BaseSetup, MultiSetup_PoSER, MultiSetup_PreGER, SingleSetup + +import numpy as np +import pytest +from pyoma2.algorithms import SSIcov +from pyoma2.support.utils.sample_data import ( + SAMPLE_DATA_DEFAULT_LOCAL_DIR, + get_sample_data, +) + +from .factory import FakeAlgorithm, FakeAlgorithm2, FakeResult, FakeRunParams + + +@pytest.fixture(scope="session") +def fake_algorithm_no_param_fixture() -> typing.Generator[FakeAlgorithm, None, None]: + """Fixture for FakeAlgorithm without parameters.""" + yield FakeAlgorithm() + + +@pytest.fixture(scope="session") +def fake_ran_algorithm() -> typing.Generator[FakeAlgorithm, None, None]: + """Fixture for FakeAlgorithm that has been run.""" + fa = FakeAlgorithm() + # set result to mock that the algorithm has been run + fa.result = FakeResult() + yield fa + + +@pytest.fixture(scope="session") +def fake_ran_algorithm2() -> typing.Generator[FakeAlgorithm2, None, None]: + """Fixture for FakeAlgorithm2 that has been run.""" + fa = FakeAlgorithm2() + # set result to mock that the algorithm has been run + fa.result = FakeResult() + yield fa + + +@pytest.fixture(scope="session") +def fake_algorithm2_no_param_fixture() -> typing.Generator[FakeAlgorithm2, None, None]: + """Fixture for FakeAlgorithm without parameters.""" + yield FakeAlgorithm2() + + +@pytest.fixture(scope="session") +def fake_algorithm_with_param_fixture() -> typing.Generator[FakeAlgorithm, None, None]: + """Fixture for FakeAlgorithm with parameters.""" + yield FakeAlgorithm(run_params=FakeRunParams()) + + +@pytest.fixture(scope="session") +def fake_single_setup_fixture_no_param() -> typing.Generator[SingleSetup, None, None]: + """Fixture for SingleSetup without parameters.""" + from pyoma2.setup import SingleSetup + + ss = SingleSetup(data=np.array([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]]), fs=1000) + ss.add_algorithms(FakeAlgorithm()) + yield ss + + +@pytest.fixture(scope="session") +def fake_single_setup_fixture_with_param() -> typing.Generator[SingleSetup, None, None]: + """Fixture for SingleSetup with parameters.""" + from pyoma2.setup import SingleSetup + + ss = SingleSetup(data=np.array([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]]), fs=1000) + ss.add_algorithms(FakeAlgorithm(run_params=FakeRunParams())) + yield ss + + +@pytest.fixture(scope="session") +def single_setup_data_fixture(): + """Fixture for SingleSetup data""" + # mock with repeatable random the palisaden/Palisaden_dataset.npy data + np.random.seed(42) + data = np.random.rand(540_000, 6) + + # import geometry files + # Names of the channels + Names = ["ch1", "ch2", "ch3", "ch4", "ch5", "ch6"] + + yield ( + data, + Names, + ) + + +@pytest.fixture(scope="function", name="bs") +def base_setup_fixture( + single_setup_data_fixture, +) -> typing.Generator[BaseSetup, None, None]: + """ + Fixture for BaseSetup with parameters. + + it has 2 algorithms: + FakeAlgorithm with name "fake_1" + FakeAlgorithm2 with name "fake_2" + """ + from pyoma2.setup import BaseSetup + + data, *_ = single_setup_data_fixture + ss = BaseSetup() + ss.data = data + ss.fs = 100 + yield ss + + +@pytest.fixture(scope="function", name="ss") +def single_setup_fixture( + single_setup_data_fixture, +) -> typing.Generator[SingleSetup, None, None]: + """Fixture for SingleSetup with parameters.""" + from pyoma2.setup import SingleSetup + + data, *_ = single_setup_data_fixture + ss = SingleSetup(data=data, fs=100) + yield ss + + +@pytest.fixture(scope="session") +def multi_setup_data_fixture(): + """Fixture for MultiSetup data""" + set1 = np.load(get_sample_data(filename="set1.npy", folder="3SL"), allow_pickle=True) + set2 = np.load(get_sample_data(filename="set2.npy", folder="3SL"), allow_pickle=True) + set3 = np.load(get_sample_data(filename="set3.npy", folder="3SL"), allow_pickle=True) + yield ( + set1, + set2, + set3, + ) + + +@pytest.fixture(scope="function", name="ms_poser") +def multi_setup_poser_fixture( + multi_setup_data_fixture, +) -> typing.Generator[MultiSetup_PoSER, None, None]: + from pyoma2.setup import MultiSetup_PoSER, SingleSetup + + """Fixture for MultiSetup Poser with parameters.""" + set1, set2, set3 = multi_setup_data_fixture + ss1 = SingleSetup(set1, fs=100) + ss2 = SingleSetup(set2, fs=100) + ss3 = SingleSetup(set3, fs=100) + # Detrend and decimate + ss1.decimate_data(q=2) + ss2.decimate_data(q=2) + ss3.decimate_data(q=2) + + # Initialise the algorithms for setup 1 + ssicov1 = SSIcov(name="SSIcov1", method="cov", br=50, ordmax=80) + # Add algorithms to the class + ss1.add_algorithms(ssicov1) + ss1.run_all() + + # Initialise the algorithms for setup 2 + ssicov2 = SSIcov(name="SSIcov2", method="cov", br=50, ordmax=80) + ss2.add_algorithms(ssicov2) + ss2.run_all() + + # Initialise the algorithms for setup 2 + ssicov3 = SSIcov(name="SSIcov3", method="cov", br=50, ordmax=80) + ss3.add_algorithms(ssicov3) + ss3.run_all() + + # run mpe + ss1.mpe( + "SSIcov1", + sel_freq=[2.63, 2.69, 3.43, 8.29, 8.42, 10.62, 14.00, 14.09, 17.57], + order_in=50, + ) + ss2.mpe( + "SSIcov2", + sel_freq=[2.63, 2.69, 3.43, 8.29, 8.42, 10.62, 14.00, 14.09, 17.57], + order_in=40, + ) + ss3.mpe( + "SSIcov3", + sel_freq=[2.63, 2.69, 3.43, 8.29, 8.42, 10.62, 14.00, 14.09, 17.57], + order_in=40, + ) + # reference indices + ref_ind = [[0, 1, 2], [0, 1, 2], [0, 1, 2]] + # Creating Multi setup + msp = MultiSetup_PoSER( + ref_ind=ref_ind, single_setups=[ss1, ss2, ss3], names=["the_coolest_algo"] + ) + yield msp + + +@pytest.fixture(scope="function", name="ms_preger") +def multi_setup_preger_fixture( + multi_setup_data_fixture, +) -> typing.Generator[MultiSetup_PreGER, None, None]: + """Fixture for MultiSetup Poser with parameters.""" + from pyoma2.setup import MultiSetup_PreGER + + set1, set2, set3 = multi_setup_data_fixture + data = [set1, set2, set3] + ref_ind = [[0, 1, 2], [0, 1, 2], [0, 1, 2]] + # Creating Multi setup + msp = MultiSetup_PreGER(fs=100, ref_ind=ref_ind, datasets=data) + yield msp + + +# Mock imports for GUI and plotting +sys.modules["vtkmodules"] = unittest.mock.Mock() +sys.modules["pyvista"] = unittest.mock.Mock() +sys.modules["pyvistaqt"] = unittest.mock.Mock() + + +@pytest.fixture(autouse=True) +def mock_imports(): + with unittest.mock.patch( + "matplotlib.pyplot.figure" + ) as mock_figure, unittest.mock.patch( + "matplotlib.pyplot.show" + ) as mock_show, unittest.mock.patch( + "matplotlib.pyplot.subplots" + ) as subplots, unittest.mock.patch( + "pyoma2.support.sel_from_plot.NavigationToolbar2Tk" + ), unittest.mock.patch( + "pyoma2.support.sel_from_plot.FigureCanvasTkAgg" + ), unittest.mock.patch( + "src.pyoma2.functions.plot.plt.tight_layout" + ), unittest.mock.patch("tkinter.Tk"), unittest.mock.patch("tkinter.Menu"): + """ + Mocks the imports for the tests. + All mocked imports area bout GUI and plotting. + """ + + def subplots_side_effect(nrows=1, ncols=1, *args, **kwargs): + """ + Mock for matplotlib.pyplot.subplots. + Returns a tuple with a MagicMock for the figure and a 2-dimensional + array of MagicMocks for the axes. + """ + if nrows == 1 and ncols == 1: + return (MagicMock(), MagicMock()) + else: + if nrows == 1 or ncols == 1: + size = max( + nrows, ncols + ) # Determine the size of the 1-dimensional array + mock_array = np.empty( + size, dtype=object + ) # Create a 1-dimensional array + for i in range(size): + mock_array[i] = MagicMock() + else: + mock_array = np.empty((nrows, ncols), dtype=object) + for i in range(nrows): + for j in range(ncols): + mock_array[i, j] = MagicMock() + + return (MagicMock(), mock_array) + + subplots.side_effect = subplots_side_effect + yield mock_figure, mock_show, subplots + + +@pytest.fixture(scope="session", autouse=True) +def cleanup_sample_data_dir(): + """ + Fixture to delete the SAMPLE_DATA_DEFAULT_LOCAL_DIR after all tests have run. + """ + yield + # Cleanup code to delete the directory + if SAMPLE_DATA_DEFAULT_LOCAL_DIR.exists() and SAMPLE_DATA_DEFAULT_LOCAL_DIR.is_dir(): + shutil.rmtree(SAMPLE_DATA_DEFAULT_LOCAL_DIR) + print(f"Deleted directory: {SAMPLE_DATA_DEFAULT_LOCAL_DIR}") diff --git a/tests/factory.py b/tests/factory.py new file mode 100644 index 0000000..6776c1d --- /dev/null +++ b/tests/factory.py @@ -0,0 +1,78 @@ +from __future__ import annotations + +import typing +import unittest.mock + +import numpy as np +import numpy.typing as npt +from matplotlib.axes import Axes +from matplotlib.figure import Figure +from pyoma2.algorithms import BaseAlgorithm +from pyoma2.algorithms.data.result import BaseResult +from pyoma2.algorithms.data.run_params import BaseRunParams + +if typing.TYPE_CHECKING: + pass + +FakeFigure = unittest.mock.MagicMock(spec=Figure) +FakeAxes = unittest.mock.MagicMock(spec=Axes) + + +class FakeRunParams(BaseRunParams): + """FakeRunParams is a subclass of BaseRunParams.""" + + param1: int = 1 + param2: str = "test" + + +class FakeResult(BaseResult): + """FakeResult is a subclass of BaseResult.""" + + Fn: npt.ArrayLike = np.array([1.0, 2.0, 3.0]) + Phi: npt.ArrayLike = np.array( + [ + [1.0, 2.0, 3.0], + [4.0, 5.0, 6.0], + [7.0, 8.0, 9.0], + [10.0, 11.0, 12.0], + [13.0, 14.0, 15.0], + [16.0, 17.0, 18.0], + ] + ) + result1: int = 1 + result2: str = "test" + + +class FakeAlgorithm(BaseAlgorithm[FakeRunParams, FakeResult, typing.Iterable[float]]): + """FakeAlgorithm is a subclass of BaseAlgorithm.""" + + RunParamCls = FakeRunParams + ResultCls = FakeResult + + def run(self) -> FakeResult: + return FakeResult() + + def mpe(self, *args, **kwargs) -> typing.Any: + return np.array([1.0, 2.0, 3.0]) + + def mpe_from_plot(self, *args, **kwargs) -> typing.Any: + return np.array([1.0, 2.0, 3.0]) + + +class FakeAlgorithm2(FakeAlgorithm): + """FakeAlgorithm2 is a subclass of FakeAlgorithm.""" + + +def assert_array_equal_with_nan(arr1: npt.ArrayLike, arr2: npt.ArrayLike) -> bool: + """Utility function to compare two arrays with NaN values. + + Args: + arr1 (npt.ArrayLike) + arr2 (npt.ArrayLike) + + Returns: + bool: True if the arrays are equal, False otherwise + """ + nan_equal = np.isnan(arr1) == np.isnan(arr2) + allclose_equal = np.allclose(arr1[~np.isnan(arr1)], arr2[~np.isnan(arr2)]) + return np.all(nan_equal) and allclose_equal diff --git a/tests/integration/__init__.py b/tests/integration/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/tests/integration/setup/__init__.py b/tests/integration/setup/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/tests/integration/setup/test_base_setup.py b/tests/integration/setup/test_base_setup.py new file mode 100644 index 0000000..1f6c78a --- /dev/null +++ b/tests/integration/setup/test_base_setup.py @@ -0,0 +1,132 @@ +import numpy as np +import pytest +from pyoma2.setup.base import BaseSetup + +from tests.factory import FakeAlgorithm, FakeResult, FakeRunParams + + +@pytest.fixture +def base_setup(): + """Fixture for BaseSetup class.""" + setup = BaseSetup() + setup.data = np.random.rand(1000, 3) + setup.fs = 100 + return setup + + +def test_add_algorithms(base_setup): + """Test the add_algorithms method.""" + alg1 = FakeAlgorithm(name="alg1") + alg2 = FakeAlgorithm(name="alg2") + base_setup.add_algorithms(alg1, alg2) + + assert "alg1" in base_setup.algorithms + assert "alg2" in base_setup.algorithms + assert base_setup.algorithms["alg1"].data is not None + assert base_setup.algorithms["alg2"].fs == 100 + + +def test_run_all(base_setup): + """Test the run_all method.""" + alg1 = FakeAlgorithm(name="alg1", run_params=FakeRunParams(param1=2, param2="test")) + alg2 = FakeAlgorithm(name="alg2", run_params=FakeRunParams(param1=3, param2="test")) + base_setup.add_algorithms(alg1, alg2) + + base_setup.run_all() + + assert isinstance(base_setup.algorithms["alg1"].result, FakeResult) + assert isinstance(base_setup.algorithms["alg2"].result, FakeResult) + + +def test_run_by_name(base_setup): + """Test the run_by_name method.""" + alg = FakeAlgorithm( + name="test_alg", run_params=FakeRunParams(param1=2, param2="test") + ) + base_setup.add_algorithms(alg) + + base_setup.run_by_name("test_alg") + + assert isinstance(base_setup.algorithms["test_alg"].result, FakeResult) + + +def test_mpe(base_setup): + """Test the mpe method.""" + alg = FakeAlgorithm(name="test_alg") + base_setup.add_algorithms(alg) + + base_setup.mpe("test_alg") + + # Since FakeAlgorithm's mpe method doesn't do anything, we just check if it runs without error + + +def test_mpe_from_plot(base_setup): + """Test the mpe_from_plot method.""" + alg = FakeAlgorithm(name="test_alg") + base_setup.add_algorithms(alg) + + base_setup.mpe_from_plot("test_alg") + + # Since FakeAlgorithm's mpe_from_plot method doesn't do anything, we just check if it runs without error + + +def test_getitem(base_setup): + """Test the __getitem__ method.""" + alg = FakeAlgorithm(name="test_alg") + base_setup.add_algorithms(alg) + + retrieved_alg = base_setup["test_alg"] + + assert retrieved_alg.name == "test_alg" + + +def test_get(base_setup): + """Test the get method.""" + alg = FakeAlgorithm(name="test_alg") + base_setup.add_algorithms(alg) + + retrieved_alg = base_setup.get("test_alg") + nonexistent_alg = base_setup.get("nonexistent", default="Not found") + + assert retrieved_alg.name == "test_alg" + assert nonexistent_alg == "Not found" + + +def test_decimate_data(): + """Test the _decimate_data method.""" + data = np.random.rand(10000, 100) + fs = 1000 + q = 10 + + new_data, new_fs, dt, Ndat, T = BaseSetup._decimate_data(data, fs, q) + + assert new_data.shape == (10000, 10) + assert new_fs == 100 + assert dt == 1 / 100 + assert Ndat == 10000 + assert np.isclose(T, 10, atol=1e-6) + + +def test_detrend_data(): + """Test the _detrend_data method.""" + data = np.arange(100).reshape(100, 1) + np.random.rand(100, 1) + + detrended_data = BaseSetup._detrend_data(data) + + assert detrended_data.shape == data.shape + assert np.allclose(np.mean(detrended_data), 0, atol=1e-10) + + +def test_filter_data(): + """Test the _filter_data method.""" + t = np.linspace(0, 1, 1000, endpoint=False) + data = np.sin(2 * np.pi * 10 * t) + 0.5 * np.sin(2 * np.pi * 20 * t) + fs = 1000 + + filtered_data = BaseSetup._filter_data(data, fs, Wn=15, btype="lowpass") + + assert filtered_data.shape == data.shape + # Check that high frequency component is attenuated + assert np.max(np.abs(np.fft.fft(filtered_data)[200:])) < np.max( + np.abs(np.fft.fft(data)[200:]) + ) diff --git a/tests/integration/setup/test_multi_setup_poser.py b/tests/integration/setup/test_multi_setup_poser.py new file mode 100644 index 0000000..3cc97a5 --- /dev/null +++ b/tests/integration/setup/test_multi_setup_poser.py @@ -0,0 +1,84 @@ +import pytest + +from src.pyoma2.setup import MultiSetup_PoSER + + +def test_geo1(ms_poser: MultiSetup_PoSER) -> None: + """ + Test the first geometric definition. + """ + + # Test that the geometric is not defined + assert ms_poser.geo1 is None + + # plot without defining the geometry + with pytest.raises(ValueError) as e: + ms_poser.plot_geo1() + assert "geo1 is not defined. Call def_geo1 first." in str(e.value) + + ms_poser.def_geo1_by_file(path="./tests/test_data/3SL/Geo1.xlsx") + + assert ms_poser.geo1 is not None + + # Merging results from single setups + result = ms_poser.merge_results() + + # access the result with custom names defined on initialization + NR_ALG_IN_EACH_SETUP = 1 + assert "the_coolest_algo" in result + assert len(result) == NR_ALG_IN_EACH_SETUP + # define results variable + algo_res = result["the_coolest_algo"] + + # PLOTE_MODE_G1 + try: + _ = ms_poser.plot_mode_geo1(algo_res=algo_res, mode_nr=2) + except Exception as e: + assert False, f"plot_mode_geo1 raised an exception {e} for MultiSetup_PoSER" + + # PLOT geo1 + try: + _ = ms_poser.plot_geo1() + except Exception as e: + assert False, f"plot_geo1 raised an exception {e} for MultiSetup_PoSER" + + +def test_geo2(ms_poser: MultiSetup_PoSER) -> None: + """ + Test the second geometric definition. + """ + # Test that the geometric is not defined + assert ms_poser.geo2 is None + + # plot without defining the geometry + with pytest.raises(ValueError) as e: + ms_poser.plot_geo2() + assert "geo2 is not defined. Call def_geo2 first." in str(e.value) + + ms_poser.def_geo2_by_file(path="./tests/test_data/3SL/Geo2.xlsx") + + assert ms_poser.geo2 is not None + + # Merging results from single setups + result = ms_poser.merge_results() + # define results variable + # access the result with custom names defined on initialization + NR_ALG_IN_EACH_SETUP = 1 + assert "the_coolest_algo" in result + assert len(result) == NR_ALG_IN_EACH_SETUP + # define results variable + algo_res = result["the_coolest_algo"] + + # PLOTE_MODE_geo2 + try: + _ = ms_poser.plot_mode_geo2(algo_res=algo_res, mode_nr=1, scaleF=3, notebook=True) + # assert isinstance(fig, Figure) + # assert isinstance(ax, Axes) + except Exception as e: + assert False, f"plot_mode_geo2 raised an exception {e} for MultiSetup_PoSER" + + # PLOT GEO2 + try: + _ = ms_poser.plot_geo2() + except Exception as e: + assert False, f"plot_geo2 raised an exception {e} for MultiSetup_PoSER" diff --git a/tests/integration/setup/test_multi_setup_preger.py b/tests/integration/setup/test_multi_setup_preger.py new file mode 100644 index 0000000..4ec1534 --- /dev/null +++ b/tests/integration/setup/test_multi_setup_preger.py @@ -0,0 +1,148 @@ +import math + +from pyoma2.algorithms import SSIdat_MS, pLSCF_MS + +from src.pyoma2.setup import MultiSetup_PreGER + + +def test_geo1(ms_preger: MultiSetup_PreGER) -> None: + """ + Test the first geometric definition. + """ + + # Test that the geometric is not defined + assert ms_preger.geo1 is None + + ms_preger.def_geo1_by_file(path="./tests/test_data/3SL/Geo1.xlsx") + + assert ms_preger.geo1 is not None + + +def test_geo2(ms_preger: MultiSetup_PreGER) -> None: + """ + Test the second geometric definition. + """ + + # Test that the geometric is not defined + assert ms_preger.geo2 is None + + ms_preger.def_geo2_by_file(path="./tests/test_data/3SL/Geo2.xlsx") + + assert ms_preger.geo2 is not None + + +def test_plot_data(ms_preger: MultiSetup_PreGER) -> None: + """ + Test the plotting and data manipulation methods of the MultiSetup_PreGER class. + """ + initial_data_first_ref = ms_preger.data[0]["ref"][0][0] + initial_datasets_first_el = ms_preger.datasets[0][0][0] + initial_fs = ms_preger.fs + initial_dt = ms_preger.dt + + # test DECIMATE_DATA method + decimation_factor = 4 + ms_preger.decimate_data(q=decimation_factor) + # data has changed and is different from the initial data + assert math.isclose(ms_preger.data[0]["ref"][0][0], -3.27248603574735e-05) + assert not math.isclose(ms_preger.data[0]["ref"][0][0], initial_data_first_ref) + # datasets has changed and is different from the initial datasets + assert math.isclose(ms_preger.datasets[0][0][0], -3.272486035745707e-05) + assert not math.isclose(ms_preger.datasets[0][0][0], initial_datasets_first_el) + assert ms_preger.fs == 25.0 + assert ms_preger.dt == 0.01 + # rollback the data + ms_preger.rollback() + assert ms_preger.data[0]["ref"][0][0] == initial_data_first_ref + assert ms_preger.datasets[0][0][0] == initial_datasets_first_el + assert ms_preger.fs == initial_fs + assert ms_preger.dt == initial_dt + + # test DETREND_DATA method + ms_preger.detrend_data() + # data has changed and is different from the initial data + assert math.isclose(ms_preger.data[0]["ref"][0][0], -3.238227274628828e-05) + assert not math.isclose(ms_preger.data[0]["ref"][0][0], initial_data_first_ref) + assert ms_preger.fs == initial_fs + assert ms_preger.dt == initial_dt + # datasets has changed and is not different from the initial datasets + assert math.isclose(ms_preger.datasets[0][0][0], -3.249758486587817e-05) + assert math.isclose(ms_preger.datasets[0][0][0], initial_datasets_first_el) + # rollback the data + ms_preger.rollback() + assert ms_preger.data[0]["ref"][0][0] == initial_data_first_ref + assert ms_preger.datasets[0][0][0] == initial_datasets_first_el + assert ms_preger.fs == initial_fs + assert ms_preger.dt == initial_dt + + # test FILTER_DATA method + ms_preger.filter_data(Wn=1, order=1, btype="lowpass") + # data has changed and is different from the initial data + assert math.isclose(ms_preger.data[0]["ref"][0][0], -3.4815804592448214e-05) + assert not math.isclose(ms_preger.data[0]["ref"][0][0], initial_data_first_ref) + assert ms_preger.fs == initial_fs + assert ms_preger.dt == initial_dt + # datasets has changed and is not different from the initial datasets + assert math.isclose(ms_preger.datasets[0][0][0], -3.249758486587817e-05) + assert math.isclose(ms_preger.datasets[0][0][0], initial_datasets_first_el) + # rollback the data + ms_preger.rollback() + assert ms_preger.data[0]["ref"][0][0] == initial_data_first_ref + assert ms_preger.datasets[0][0][0] == initial_datasets_first_el + assert ms_preger.fs == initial_fs + assert ms_preger.dt == initial_dt + + # test PLOT_DATA method + try: + figs, axs = ms_preger.plot_data(data_idx=[0, 1, 2]) + assert isinstance(figs, list) + assert isinstance(axs, list) + except Exception as e: + assert False, f"plot_data raised an exception {e}" + + # test PLOT_CH_INFO method + try: + figs, axs = ms_preger.plot_ch_info(data_idx=[0, 1, 2], ch_idx=[-1]) + assert isinstance(figs, list) + assert isinstance(axs, list) + except Exception as e: + assert False, f"plot_ch_info raised an exception {e}" + + # test plot_STFT method + try: + figs, axs = ms_preger.plot_STFT(data_idx=[0, 1, 2]) + assert isinstance(figs, list) + assert isinstance(axs, list) + except Exception as e: + assert False, f"plot_STFT raised an exception {e}" + + +def test_run(ms_preger: MultiSetup_PreGER) -> None: + """ + Test the running of the algorithms in the MultiSetup_PreGER class. + """ + # Define geometry1 + ms_preger.def_geo1_by_file(path="./tests/test_data/3SL/Geo1.xlsx") # BG lines + + # Define geometry 2 + ms_preger.def_geo2_by_file(path="./tests/test_data/3SL/Geo2.xlsx") + + # Initialise the algorithms + ssidat = SSIdat_MS(name="SSIdat", br=5, ordmax=5) + plscf = pLSCF_MS(name="pLSCF", ordmax=5, nxseg=64) + + ms_preger.decimate_data(q=50) + + # Add algorithms to the class + ms_preger.add_algorithms(ssidat, plscf) + + # Results are None + assert ms_preger["SSIdat"].result is None + assert ms_preger["pLSCF"].result is None + + # Run all algorithms + ms_preger.run_all() + + # Check the results + assert ms_preger["SSIdat"].result is not None + assert ms_preger["pLSCF"].result is not None diff --git a/tests/integration/setup/test_single_setup.py b/tests/integration/setup/test_single_setup.py new file mode 100644 index 0000000..db8afe1 --- /dev/null +++ b/tests/integration/setup/test_single_setup.py @@ -0,0 +1,496 @@ +import math +import typing + +import numpy as np +import pandas as pd +import pytest +from scipy.signal import decimate, detrend + +from src.pyoma2.algorithms import FDD, FSDD, SSIcov +from src.pyoma2.setup import BaseSetup, SingleSetup +from tests.factory import FakeAlgorithm, FakeAlgorithm2 + + +def test_base_setup(single_setup_data_fixture, bs: BaseSetup) -> None: + """Test BaseSetup utility functions.""" + ( + data, + *_, + ) = single_setup_data_fixture + alg1 = FakeAlgorithm(name="fake_1") + alg2 = FakeAlgorithm2(name="fake_2") + + # Test the INITIALIZATION of the FakeAlgorithm and FakeAlgorithm2 + assert getattr(alg1, "data", None) is None + assert getattr(alg1, "fs", None) is None + assert alg1.name == "fake_1" + + assert getattr(alg2, "data", None) is None + assert getattr(alg2, "fs", None) is None + assert alg2.name == "fake_2" + + # Test the INITIALIZATION of the BaseSetup + assert bs.data is not None + assert bs.fs == 100 + assert getattr(bs, "algorithms", None) is None + + # Test the ADD_ALGORITHMS method + bs.add_algorithms(alg1, alg2) + assert bs.algorithms["fake_1"].name == "fake_1" + assert bs.algorithms["fake_2"].name == "fake_2" + assert bs["fake_1"].name == "fake_1" + assert bs["fake_2"].name == "fake_2" + + # Test the GET ALGORITHM method + assert bs.get("fake_1").name == "fake_1" + assert bs.get("fake_2").name == "fake_2" + + # Test the GET ALGORITHM method with an unknown algorithm + with pytest.raises(KeyError): + bs.algorithms["unknown"] + with pytest.raises(KeyError): + bs["unknown"] + assert bs.get("unknown") is None + + # Test DECIMATE_DATA method + data = np.array(np.arange(0, 30)) + fs = 100 + q = 2 + newdata, fs, dt, Ndat, T = BaseSetup._decimate_data(data=data, fs=fs, q=q, axis=0) + assert np.array_equal( + newdata, decimate(data, q) + ) # Use scipy's decimate function for expected result + assert fs == 50 + assert dt == 0.02 + assert Ndat == len(newdata) + assert T == 0.15 + + # Test DETREND_DATA method + detrended_data = BaseSetup._detrend_data(data) + assert np.array_equal( + detrended_data, detrend(data) + ) # Use scipy's detrend function for expected result + + # Test the FILTER_DATA method + filtered_data = BaseSetup._filter_data( + data=np.array(np.arange(0, 7)), fs=fs, Wn=1, order=1, btype="lowpass" + ) + assert np.allclose( + filtered_data, + np.array( + [ + 0.20431932, + 0.76033598, + 1.31254294, + 1.85382214, + 2.37688175, + 2.87414037, + 3.33760645, + ] + ), + ) # Use scipy's lfilter function for expected result + + +def test_geo1(single_setup_data_fixture, ss: SingleSetup) -> None: + """ + Test the first geometry definition and plotting of the SingleSetup. + """ + _, Names = single_setup_data_fixture + + # Test that the geometry is not defined + assert ss.geo1 is None + + # plot without defining the geometry + with pytest.raises(ValueError) as e: + ss.plot_geo1() + assert "geo1 is not defined. Call def_geo1 first." in str(e.value) + + # DEFINE THE GEOMETRY + ss.def_geo1_by_file( + path="./tests/test_data/palisaden/Geo1.xlsx", + ) + + # Test the initialization of the Geometry + assert ss.geo1 is not None + assert ss.geo1.sens_names == Names + # bg_lines are different because the first column is 0-indexed + assert np.array_equal( + ss.geo1.bg_lines, + np.array([[3, 0], [4, 1], [5, 2], [0, 1], [1, 2], [2, 0]]), + ) + # sens_cord was reindexed + assert ss.geo1.sens_coord.equals( + pd.DataFrame( + { + "label": ["ch1", "ch2", "ch3", "ch4", "ch5", "ch6"], + "x": [2, 11, 5, 2, 11, 5], + "y": [8, 8, 2, 8, 8, 2], + "z": [20, 20, 20, 20, 20, 20], + }, + ).set_index("label") + ) + assert np.array_equal( + ss.geo1.sens_dir, + np.array( + [ + [-1.0, 0.0, 0.0], + [0.0, -1.0, 0.0], + [-1.0, 0.0, 0.0], + [0.0, -1.0, 0.0], + [-1.0, 0.0, 0.0], + [0.0, 1.0, 0.0], + ] + ), + ) + assert np.array_equal( + ss.geo1.bg_nodes, + np.array( + [[2, 8, 20], [11, 8, 20], [5, 2, 20], [2, 8, 0], [11, 8, 0], [5, 2, 0]], + dtype=int, + ), + ) + assert ss.geo1.bg_surf is None + + # PLOT THE GEOMETRY + # Call the plot_geo1 method and check that it doesn't raise an exception + try: + fig, ax = ss.plot_geo1() + except Exception as e: + assert False, f"plot_geo1 raised an exception {e}" + + # PLOT GEOMETRY WITH bg_surf + # Define the bg_surf + bg_surf = np.array([[0, 1, 2], [2, 3, 0]]) + ss.geo1.bg_surf = bg_surf + + try: + fig, ax = ss.plot_geo1() + except Exception as e: + assert False, f"plot_geo1 with bg_surf raised an exception: {e}" + + # PLOT GEOMETRY WITH sens_lines + # Define the sens_lines + sens_lines = np.array([[0, 1], [1, 2], [2, 3], [3, 4], [4, 5]]) + ss.geo1.sens_lines = sens_lines + + try: + fig, ax = ss.plot_geo1() + except Exception as e: + assert False, f"plot_geo1 with sens_lines raised an exception: {e}" + + # PLOT_MODE_GEO1 + try: + f_al = FakeAlgorithm(name="fake1", run_params=FakeAlgorithm.RunParamCls()) + ss.add_algorithms(f_al) + ss.run_all() + fig, ax = ss.plot_mode_geo1(algo_res=f_al.result, mode_nr=2, view="3D", scaleF=2) + except Exception as e: + assert False, f"plot_mode_geo1 raised an exception {e}" + + +@pytest.mark.parametrize( + "input_sens_map, input_sens_sign", + ( + ( + pd.DataFrame( + { + "ptName": [1, 2, 3, 4, 5, 6], + "x": ["ch1", "ch3", "ch5", "ch1", "ch2", "ch4"], + "y": ["ch2", "ch4", "ch6", "ch3", "ch5", "ch6"], + "z": [0, 0, 0, 0, 0, 0], + } + ), + pd.DataFrame( + { + "ptName": [1, 2, 3, 4, 5, 6], + "x": [-1, -1, -1, 0, 0, 0], + "y": [-1, -1, 1, 0, 0, 0], + "z": [0, 0, 0, 0, 0, 0], + } + ), + ), + (None, None), # use default sens map and sens sign + (None, None), # use default sens map and sens sign + (None, None), # use default sens map and sens sign + ( + pd.DataFrame( + { + "ptName": [1, 2, 3, 4, 5, 6], + "x": ["ch1", "ch3", "ch5", "ch1", "ch2", "ch4"], + } + ), + pd.DataFrame( + { + "ptName": [1, 2, 3, 4, 5, 6], + "x": [-1, -1, -1, 0, 0, 0], + } + ), + ), + ( + pd.DataFrame( + { + "ptName": [1, 2, 3, 4, 5, 6], + "x": ["ch1", "ch3", "ch5", "ch1", "ch2", "ch4"], + } + ), + pd.DataFrame( + { + "ptName": [1, 2, 3, 4, 5, 6], + "x": [-1, -1, -1, 0, 0, 0], + } + ), + ), + ( + pd.DataFrame( + { + "ptName": [1, 2, 3, 4, 5, 6], + "x": ["ch1", "ch3", "ch5", "ch1", "ch2", "ch4"], + } + ), + pd.DataFrame( + { + "ptName": [1, 2, 3, 4, 5, 6], + "x": [-1, -1, -1, 0, 0, 0], + } + ), + ), + ), +) +def test_geo2( + ss: SingleSetup, + input_sens_map: typing.Optional[pd.DataFrame], + input_sens_sign: typing.Optional[pd.DataFrame], +) -> None: + """ + Test the second geometry definition and plotting of the SingleSetup. + """ + if input_sens_map is not None: + _ = input_sens_map + if input_sens_sign is not None: + _ = input_sens_sign + + # Test the initialization of the SingleSetup + assert ss.geo2 is None + + # plot without defining the geometry + with pytest.raises(ValueError) as e: + ss.plot_geo2() + assert "geo2 is not defined. Call def_geo2 first." in str(e.value) + + # DEFINE THE GEOMETRY + ss.def_geo2_by_file(path="./tests/test_data/palisaden/Geo2.xlsx") + + # Test the initialization of the Geometry + assert ss.geo2 is not None + assert np.array_equal( + ss.geo2.bg_lines, + np.array([[3, 0], [4, 1], [5, 2], [0, 1], [1, 2], [2, 0]]), + ) + assert np.array_equal( + ss.geo2.sens_lines, np.array([[3, 0], [4, 1], [5, 2], [0, 1], [1, 2], [2, 0]]) + ) + assert ss.geo2.pts_coord.equals( + pd.DataFrame( + { + "ptName": [1, 2, 3, 4, 5, 6], + "x": [2.0, 11.0, 5.0, 2.0, 11.0, 5.0], + "y": [8.0, 8.0, 2.0, 8.0, 8.0, 2.0], + "z": [20.0, 20.0, 20.0, 0.0, 0.0, 0.0], + } + ).set_index("ptName") + ) + + # PLOT THE GEOMETRY + # Call the plot_geo2 method and check that it doesn't raise an exception + try: + _ = ss.plot_geo2() + except Exception as e: + assert False, f"plot_geo2 raised an exception {e}" + + # PLOT GEOMETRY WITH bg_surf + # Define the bg_surf + bg_surf = np.array([[0, 1, 2], [2, 3, 0]]) + ss.geo2.bg_surf = bg_surf + + try: + _ = ss.plot_geo2() + except Exception as e: + assert False, f"plot_geo2 with bg_surf raised an exception: {e}" + + +def test_plot_data( + ss: SingleSetup, +) -> None: + """ + Test the plotting and data manipulation methods of the SingleSetup. + """ + initial_data_first_el = ss.data[0][0] + initial_fs = ss.fs + initial_dt = ss.dt + initial_shape = ss.data.shape + decimation_factor = 4 + initial_T = ss.T + + # test DECIMATE_DATA method + ss.decimate_data(q=decimation_factor) + assert ss.data.shape == (initial_shape[0] // decimation_factor, initial_shape[1]) + assert ss.fs != initial_fs + assert ss.data[0][0] != initial_data_first_el + assert initial_T != ss.T + # rollback the data + ss.rollback() + assert ss.data.shape == initial_shape + assert ss.fs == initial_fs + assert ss.dt == initial_dt + assert ss.data[0][0] == initial_data_first_el + assert initial_T == ss.T + + # test DETREND_DATA method + initial_shape = ss.data.shape + ss.detrend_data() + assert math.isclose(ss.data[0][0], -0.12528615865785814) + assert ss.data.shape == initial_shape + # rollback the data + ss.rollback() + assert ss.data.shape == initial_shape + assert ss.data[0][0] == initial_data_first_el + assert ss.fs == initial_fs + assert ss.dt == initial_dt + + # test FILTER_DATA method + initial_shape = ss.data.shape + ss.filter_data(Wn=1, order=1, btype="lowpass") + assert math.isclose(ss.data[0][0], 0.41342428991383917) + assert ss.data.shape == initial_shape + # rollback the data + ss.rollback() + assert ss.data.shape == initial_shape + assert ss.data[0][0] == initial_data_first_el + assert ss.fs == initial_fs + assert ss.dt == initial_dt + + # test PLOT_DATA method + try: + fig, ax = ss.plot_data() + except Exception as e: + assert False, f"plot_data raised an exception {e}" + + # test PLOT_CH_INFO method + try: + fig, ax = ss.plot_ch_info(ch_idx=[-1]) + assert isinstance(ax, list) + except Exception as e: + assert False, f"plot_ch_info raised an exception {e}" + + +def test_run(ss: SingleSetup) -> None: + """ + Test the running of the algorithms in the SingleSetup. + """ + + # Define geometry1 + ss.def_geo1_by_file( + path="./tests/test_data/palisaden/Geo1.xlsx", + ) + + # Define geometry 2 + ss.def_geo2_by_file(path="./tests/test_data/palisaden/Geo2.xlsx") + + # Initialise the algorithms + fdd = FDD(name="FDD") + fsdd = FSDD(name="FSDD", nxseg=2048, method_SD="per", pov=0.5) + ssicov = SSIcov(name="SSIcov", br=50, ordmax=80) + + # Overwrite/update run parameters for an algorithm + fdd.run_params = FDD.RunParamCls(nxseg=512, method_SD="cor") + # Aggiungere esempio anche col metodo + + # Add algorithms to the single setup class + ss.add_algorithms(ssicov, fsdd, fdd) + + # results are none + assert ss["FDD"].result is None + assert ss["FSDD"].result is None + assert ss["SSIcov"].result is None + + # Run all or run by name + ss.run_by_name("SSIcov") + ss.run_by_name("FSDD") + + # Run all algorithms + ss.run_all() + + # Check the result + assert ss["FDD"].result is not None + assert ss["FSDD"].result is not None + assert ss["SSIcov"].result is not None + + # plot SINGULAR VALUES + try: + fig, ax = fsdd.plot_CMIF(freqlim=(1, 4)) + except Exception as e: + assert False, f"plot_CMIF raised an exception {e}" + + # plot STABILISATION CHART for SSI + try: + fig4, ax4 = ssicov.plot_stab(freqlim=(1, 4), hide_poles=False) + except Exception as e: + assert False, f"plot_stab raised an exception {e}" + + # plot FREQUECY-DAMPING CLUSTERS for SSI + try: + fig4, ax4 = ssicov.plot_freqvsdamp(freqlim=(1, 4)) + except Exception as e: + assert False, f"plot_freqvsdamp raised an exception {e}" + + # run mpe_from_plot for algorithms + try: + ss.mpe_from_plot("SSIcov", freqlim=(1, 4)) + except Exception as e: + assert False, f"mpe_from_plot raised an exception {e} for SSIcov" + + try: + ss.mpe_from_plot("FSDD", freqlim=(1, 4)) + except Exception as e: + assert False, f"mpe_from_plot raised an exception {e} for FSDD" + + try: + ss.mpe_from_plot("FDD", freqlim=(1, 4)) + except Exception as e: + assert False, f"mpe_from_plot raised an exception {e} for FDD" + + # run mpe for algorithms + try: + ss.mpe("SSIcov", sel_freq=[1.88, 2.42, 2.68], order_in=40) + except Exception as e: + assert False, f"mpe raised an exception {e} for SSIcov" + + try: + ss.mpe("FSDD", sel_freq=[1.88, 2.42, 2.68], MAClim=0.95) + except Exception as e: + assert False, f"mpe raised an exception {e} for FSDD" + + try: + ss.mpe("FDD", sel_freq=[1.88, 2.42, 2.68]) + except Exception as e: + assert False, f"mpe raised an exception {e} for FDD" + + # plot_EFDDfit for FSDD algorithms + try: + figs, axs = ss["FSDD"].plot_EFDDfit(freqlim=(1, 4)) + assert isinstance(figs, list) + assert isinstance(axs, list) + except Exception as e: + assert False, f"plot_fit raised an exception {e} for FDD" + + # PLOTE_MODE_G1 + try: + _ = ss.plot_mode_geo1(algo_res=fdd.result, mode_nr=2, view="3D", scaleF=2) + except Exception as e: + assert False, f"plot_mode_geo1 raised an exception {e} for FDD" + + # PLOTE_MODE_geo2 + try: + _ = ss.plot_mode_geo2(algo_res=fsdd.result, mode_nr=2, view="3D", scaleF=2) + except Exception as e: + assert False, f"plot_mode_geo2 raised an exception {e} for FSDD" diff --git a/tests/test_data/3SL/Geo1.xlsx b/tests/test_data/3SL/Geo1.xlsx new file mode 100644 index 0000000..eadf010 Binary files /dev/null and b/tests/test_data/3SL/Geo1.xlsx differ diff --git a/tests/test_data/3SL/Geo2.xlsx b/tests/test_data/3SL/Geo2.xlsx new file mode 100644 index 0000000..bc764d8 Binary files /dev/null and b/tests/test_data/3SL/Geo2.xlsx differ diff --git a/tests/test_data/palisaden/Geo1.xlsx b/tests/test_data/palisaden/Geo1.xlsx new file mode 100644 index 0000000..a85b954 Binary files /dev/null and b/tests/test_data/palisaden/Geo1.xlsx differ diff --git a/tests/test_data/palisaden/Geo2.xlsx b/tests/test_data/palisaden/Geo2.xlsx new file mode 100644 index 0000000..d914f8f Binary files /dev/null and b/tests/test_data/palisaden/Geo2.xlsx differ diff --git a/tests/unit/__init__.py b/tests/unit/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/tests/unit/functions/__init__.py b/tests/unit/functions/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/tests/unit/functions/test_fdd.py b/tests/unit/functions/test_fdd.py new file mode 100644 index 0000000..97b28df --- /dev/null +++ b/tests/unit/functions/test_fdd.py @@ -0,0 +1,131 @@ +import numpy as np +import pytest +from pyoma2.functions import fdd + + +@pytest.mark.parametrize( + "input_method", + [ + "cor", + "per", + ], +) +def test_SD_PreGER(input_method: str) -> None: + fs = 1000.0 + nxseg = 1024 + pov = 0.5 + + Y = [ + {"ref": np.random.rand(2, 10000), "mov": np.random.rand(3, 10000)}, + {"ref": np.random.rand(2, 10000), "mov": np.random.rand(3, 10000)}, + ] + freq, Sy = fdd.SD_PreGER(Y, fs, nxseg=nxseg, pov=pov, method=input_method) + assert len(freq) > 0 # Ensure frequency array is not empty + + # Check that the output is a tuple + assert isinstance(freq, np.ndarray) + assert isinstance(Sy, np.ndarray) + assert Sy.shape[0] == 8 # Ensure correct shape of Sy + + +@pytest.mark.parametrize( + "input_method", + [ + "cor", + "per", + ], +) +def test_SD_est(input_method: str) -> None: + fs = 1000 + N = 1000 + Yall = np.random.rand(10, N) + Yref = np.random.rand(5, N) + nxseg = 1024 + pov = 0.5 + dt = 1 / fs + freq, Sy = fdd.SD_est(Yall, Yref, dt, nxseg=nxseg, method=input_method, pov=pov) + assert len(freq) > 0 # Ensure frequency array is not empty + assert Sy.shape[0] == Yall.shape[0] # Ensure correct shape of Sy + + +def test_FDD_mpe(): + # Generate some dummy data + Sval = np.random.rand(2, 2, 1000) + Svec = np.random.rand(2, 2, 1000) + freq = np.linspace(0, 100, 1000) + sel_freq = [25, 50, 75] + DF = 0.1 + + # Call the function with the dummy data + Fn, Phi = fdd.FDD_mpe(Sval, Svec, freq, sel_freq, DF) + + # Check that the output has the expected shape + assert Fn.shape == (len(sel_freq),) + assert Phi.shape == (Svec.shape[1], len(sel_freq)) + + # Check that the output is a tuple + assert isinstance(Fn, np.ndarray) + assert isinstance(Phi, np.ndarray) + + +@pytest.mark.parametrize( + "input_method", + [ + "FSDD", + "EFDD", + ], +) +def test_SDOF_bellandMS(input_method: str) -> None: + Nch = 3 # Number of channels + Nf = 100 # Number of frequency points + dt = 0.01 # Time interval of the data sampling + sel_fn = 10.0 # Selected modal frequency + cm = 1 # Number of close modes to consider in the analysis + MAClim = 0.85 # Threshold for the Modal Assurance Criterion (MAC) + DF = 1.0 # Frequency bandwidth around the selected frequency for analysis + + # Create a random spectral matrix + Sy = np.random.rand(Nch, Nch, Nf) + 1j * np.random.rand(Nch, Nch, Nf) + + # Create a random mode shape + phi_FDD = np.random.rand(Nch) + 1j * np.random.rand(Nch) + phi_FDD /= np.linalg.norm(phi_FDD) # Normalize the mode shape + + # Call the function with the dummy data + SDOFbell1, SDOFms1 = fdd.SDOF_bellandMS( + Sy, dt, sel_fn, phi_FDD, input_method, cm, MAClim, DF + ) + + # Check that the output has the expected shape + assert SDOFbell1.shape == (Sy.shape[2],) + assert SDOFms1.shape == (Sy.shape[2], phi_FDD.shape[0]) + + # Check that the output is a tuple + assert isinstance(SDOFbell1, np.ndarray) + assert isinstance(SDOFms1, np.ndarray) + + +@pytest.mark.parametrize( + "input_method", + [ + "cor", + "paer", + ], +) +def test_EFDD_mpe(input_method: str) -> None: + # Sample data + Sy = np.random.rand(3, 3, 100) + freq = np.linspace(0, 1, 100) + dt = 0.1 + sel_freq = [0.3, 0.5, 0.7] + + # Call the function + Fn, Xi, Phi, PerPlot = fdd.EFDD_mpe( + Sy=Sy, freq=freq, dt=dt, sel_freq=sel_freq, methodSy=input_method, npmax=2 + ) + + # Basic assertions to ensure the output has the correct shape + assert Fn.shape[0] == len(sel_freq) + assert Xi.shape[0] == len(sel_freq) + assert Phi.shape == (Sy.shape[0], len(sel_freq)) + assert all([len(per_plot) == 9 for per_plot in PerPlot]) diff --git a/tests/unit/functions/test_gen.py b/tests/unit/functions/test_gen.py new file mode 100644 index 0000000..9f03d8a --- /dev/null +++ b/tests/unit/functions/test_gen.py @@ -0,0 +1,119 @@ +import numpy as np +import pytest +from pyoma2.functions import gen + + +def test_merge_mode_shapes() -> None: + """Test the merge_mode_shapes function.""" + MSarr_list = [np.array([[1, 2], [3, 4]]), np.array([[5, 6], [7, 8]])] + reflist = [[0], [1]] + merged = gen.merge_mode_shapes(MSarr_list, reflist) + assert merged.shape == (3, 2) + + +def test_merge_mode_shape_exc() -> None: + """Test the merge_mode_shapes function with an exception.""" + MSarr_list = [np.array([[1, 2], [3, 4]]), np.array([[5], [7]])] + reflist = [[0], [1], [2]] + with pytest.raises(ValueError) as excinfo: + gen.merge_mode_shapes(MSarr_list, reflist) + assert "All mode shape arrays must have the same number of modes." in str( + excinfo.value + ) + + +def test_MPC() -> None: + """Test the MPC function.""" + phi = np.array([1 + 2j, 2 + 3j, 3 + 4j]) + assert gen.MPC(phi) == pytest.approx(1.0) + + +def test_MPD() -> None: + """Test the MPD function.""" + phi = np.array([1 + 2j, 2 + 3j, 3 + 4j]) + assert gen.MPD(phi) == pytest.approx(0.052641260122719684) + + +def test_MSF() -> None: + """Test the MSF function.""" + phi_1 = np.array([1 + 2j, 2 + 3j, 3 + 4j]) + phi_2 = np.array([2 + 3j, 3 + 4j, 4 + 5j]) + assert gen.MSF(phi_1, phi_2) == pytest.approx([1.35342466]) + + +def test_MSF_exc() -> None: + """Test the MSF function with an exception.""" + phi_1 = np.array([1 + 2j, 2 + 3j, 3 + 4j]) + phi_2 = np.array([2 + 3j, 3 + 4j, 4 + 5j, 5 + 6j]) + with pytest.raises(Exception) as excinfo: + gen.MSF(phi_1, phi_2) + assert "`phi_1` and `phi_2` must have the same shape" in str(excinfo.value) + + +def test_MCF() -> None: + """Test the MCF function.""" + phi = np.array([1 + 2j, 2 + 3j, 3 + 4j]) + assert gen.MCF(phi) == pytest.approx([0.01297999]) + + +def test_MAC() -> None: + """Test the MAC function.""" + phi_X = np.array([1 + 2j, 2 + 3j, 3 + 4j]) + phi_A = np.array([2 + 3j, 3 + 4j, 4 + 5j]) + assert gen.MAC(phi_X, phi_A) == pytest.approx(0.9929349425964087 + 0j) + + +@pytest.mark.parametrize( + "input_phi_X, expected_exc_msg", + [ + ( + np.array([[1 + 2j, 2 + 3j, 3 + 4j]]), + "Mode shapes must have the same first dimension", + ), + ( + np.array([[[1 + 2j, 2 + 3j, 3 + 4j]]]), + " shape matrices must have 1 or 2 dimensions ", + ), + ], +) +def test_MAC_exc(input_phi_X: np.ndarray, expected_exc_msg: str) -> None: + """Test the MAC function with an exception.""" + phi_A = np.array([2 + 3j, 3 + 4j, 4 + 5j, 5 + 6j]) + with pytest.raises(Exception) as excinfo: + gen.MAC(input_phi_X, phi_A) + assert expected_exc_msg in str(excinfo.value) + + +def test_PRE_MultiSetup() -> None: + """Test the pre_multisetup function.""" + DataList = [np.array([[1, 2], [3, 4]]), np.array([[5, 6], [7, 8]])] + reflist = [[0], [1]] + result = gen.pre_multisetup(DataList, reflist) + assert len(result) == len(DataList) + assert "ref" in result[0] and "mov" in result[0] + + +def test_invperm() -> None: + """Test the invperm function.""" + p = np.array([3, 0, 2, 1]) + assert np.array_equal(gen.invperm(p), np.array([1, 3, 2, 0])) + + +def test_find_map() -> None: + """Test the find_map function.""" + arr1 = np.array([10, 30, 20]) + arr2 = np.array([3, 2, 1]) + assert np.array_equal(gen.find_map(arr1, arr2), np.array([2, 0, 1])) + + +@pytest.mark.parametrize( + "fs, Wn, order, btype, expected_shape", + [ + (1000, 100, 4, "lowpass", (100, 2)), + ], +) +def test_filter_data(fs, Wn, order, btype, expected_shape) -> None: + """Test the filter_data function.""" + data = np.random.rand(100, 2) + filt_data = gen.filter_data(data, fs, Wn, order, btype) + assert filt_data.shape == expected_shape diff --git a/tests/unit/functions/test_plot.py b/tests/unit/functions/test_plot.py new file mode 100644 index 0000000..192cf7d --- /dev/null +++ b/tests/unit/functions/test_plot.py @@ -0,0 +1,31 @@ +import numpy as np +import pytest +from pyoma2.functions import plot + + +def test_CMIF_plot() -> None: + """Test the CMIF_plot function.""" + S_val = np.random.rand(3, 3, 10) + freq = np.linspace(0, 10, 10) + + # Test with default parameters + try: + fig, ax = plot.CMIF_plot(S_val, freq) + except Exception as e: + assert False, f"CMIF_plot raised an exception {e}" + + # Test with custom parameters + try: + fig, ax = plot.CMIF_plot(S_val, freq, freqlim=(2, 8), nSv=2) + except Exception as e: + assert False, f"CMIF_plot raised an exception {e}" + + +def test_CMIF_plot_exc() -> None: + """Test the CMIF_plot function with invalid input.""" + S_val = np.random.rand(3, 3, 10) + freq = np.linspace(0, 10, 10) + + # Test with invalid nSv + with pytest.raises(ValueError): + plot.CMIF_plot(S_val, freq, nSv="invalid") diff --git a/tests/unit/functions/test_plscf.py b/tests/unit/functions/test_plscf.py new file mode 100644 index 0000000..c2facf4 --- /dev/null +++ b/tests/unit/functions/test_plscf.py @@ -0,0 +1,165 @@ +import numpy as np +import pytest +from pyoma2.functions import plscf + + +@pytest.mark.parametrize("input_sgn_basf", [-1, 1]) +def test_pLSCF(input_sgn_basf: int): + """ + Test the pLSCF function. + """ + # Define test inputs + Sy = np.random.rand(3, 3, 100) # Spectral density matrix + dt = 0.1 # Time step + ordmax = 5 # Maximum model order + + # Call the function with test inputs + Ad, Bn = plscf.pLSCF(Sy, dt, ordmax, input_sgn_basf) + + # Assert that the outputs have the expected shape + assert [el.shape for el in Ad] == [ + (2, 3, 3), + (3, 3, 3), + (4, 3, 3), + (5, 3, 3), + (6, 3, 3), + ] + assert [el.shape for el in Bn] == [ + (2, 3, 3), + (3, 3, 3), + (4, 3, 3), + (5, 3, 3), + (6, 3, 3), + ] + + # Assert that the outputs are of the correct type + assert all([isinstance(el, np.ndarray) for el in Ad]) + assert all([isinstance(el, np.ndarray) for el in Bn]) + + +def test_pLSCF_poles() -> None: + """ + Test the pLSCF_poles function. + """ + Ad = np.array([[[[1, -0.5], [1, -0.7]]]]) + Bn = np.array([[[[7, 8], [9, 10]]]]) + dt = 0.01 + methodSy = "per" + nxseg = 10 + Fns, Xis, Phi1, lambdas = plscf.pLSCF_poles(Ad, Bn, dt, methodSy, nxseg) + + # Check if output types are correct + assert isinstance(Fns, np.ndarray) + assert isinstance(Xis, np.ndarray) + assert isinstance(Phi1, np.ndarray) + assert isinstance(lambdas, np.ndarray) + + # Check shapes of output arrays + assert Fns.shape == (2, 1) + assert Xis.shape == (2, 1) + assert Phi1.shape == (2, 1, 2) + + +def test_rmfd2ac() -> None: + """Test the rmfd2ac function.""" + # Define test data + A_den = np.array([[[1, 2], [3, 4]]]) + B_num = np.array([[[1, 2]], [[3, 4]], [[5, 6]]]) + + # Call the function with test data + + A, C = plscf.rmfd2ac(A_den, B_num) + + # Define expected output + assert np.allclose( + A, + np.array( + [ + [0.0, 0.0, 0.0, 0.0, 0.0, 0.0], + [0.0, 0.0, 0.0, 0.0, 0.0, 0.0], + [1.0, 0.0, 0.0, 0.0, 0.0, 0.0], + [0.0, 1.0, 0.0, 0.0, 0.0, 0.0], + [0.0, 0.0, 1.0, 0.0, 0.0, 0.0], + [0.0, 0.0, 0.0, 1.0, 0.0, 0.0], + ] + ), + ) + assert np.allclose(C, ([[0.0, 0.0, 0.0, 0.0, 0.0, 0.0]])) + + +def test_ac2mp_poly() -> None: + """Test the ac2mp_poly function.""" + # Define test inputs + A = np.array([[-1, -2], [1, 0]]) + C = np.array([[1, 0], [0, 1]]) + dt = 0.1 + methodSy = "cor" + nxseg = 100 + + # Call the function with test inputs + fn, xi, phi, lam_c = plscf.ac2mp_poly(A, C, dt, methodSy, nxseg) + + assert fn.shape == (2,) + assert xi.shape == (2,) + assert phi.shape == (2, 2) + assert lam_c.shape == (2,) + + +@pytest.mark.parametrize( + "input_order, expected_order", + [("find_min", 1), (1, 1), ([0, 1, 2], np.array([0.0, 1.0, 2.0]))], +) +def test_pLSCF_mpe(input_order, expected_order) -> None: + """Test the pLSCF_mpe function.""" + # Define test inputs + sel_freq = [1.0, 2.0, 3.0] + Fn_pol = np.array( + [ + [[1.0, 2.0, 3.0], [1.1, 2.1, 3.1], [1.2, 2.2, 3.2]], + [[4.0, 5.0, 6.0], [4.1, 5.1, 6.1], [4.2, 5.2, 6.2]], + [[7.0, 8.0, 9.0], [7.1, 8.1, 9.1], [7.2, 8.2, 9.2]], + ] + ) + Xi_pol = np.array( + [ + [[1.0, 2.0, 3.0], [1.1, 2.1, 3.1], [1.2, 2.2, 3.2]], + [[4.0, 5.0, 6.0], [4.1, 5.1, 6.1], [4.2, 5.2, 6.2]], + [[7.0, 8.0, 9.0], [7.1, 8.1, 9.1], [7.2, 8.2, 9.2]], + ] + ) + Phi_pol = np.array( + [ + [[1.0, 2.0, 3.0], [1.1, 2.1, 3.1], [1.2, 2.2, 3.2]], + [[4.0, 5.0, 6.0], [4.1, 5.1, 6.1], [4.2, 5.2, 6.2]], + [[7.0, 8.0, 9.0], [7.1, 8.1, 9.1], [7.2, 8.2, 9.2]], + ] + ) + + Lab = np.array([[1, 1, 1], [1, 1, 1], [7, 7, 7]]) + deltaf = 0.05 + rtol = 1e-2 + + # Call the function with test inputs + Fn, Xi, Phi, order_out = plscf.pLSCF_mpe( + sel_freq, Fn_pol, Xi_pol, Phi_pol, input_order, Lab, deltaf, rtol + ) + + if isinstance(order_out, np.ndarray): + assert np.allclose(order_out, expected_order) + else: + assert order_out == expected_order + + +def test_pLSCF_mpe_exc() -> None: + """Test the pLSCF_mpe function. Exception case.""" + # Define test inputs + sel_freq = [1.0, 2.0, 3.0] + Fn_pol = Xi_pol = Phi_pol = np.array([]) + order = "find_min" + Lab = None + deltaf = 0.05 + rtol = 1e-2 + + with pytest.raises(ValueError): + # Call the function with test inputs + plscf.pLSCF_mpe(sel_freq, Fn_pol, Xi_pol, Phi_pol, order, Lab, deltaf, rtol) diff --git a/tests/unit/functions/test_ssi.py b/tests/unit/functions/test_ssi.py new file mode 100644 index 0000000..e45f3de --- /dev/null +++ b/tests/unit/functions/test_ssi.py @@ -0,0 +1,383 @@ +import typing + +import numpy as np +import pytest +from pyoma2.functions import ssi + +from tests.factory import assert_array_equal_with_nan + + +@pytest.mark.parametrize( + "Y, Yref, br, method, calc_unc, expected_hank, expected_uncertainty_is_none, expected_error", + [ + ( + np.array([[1, 2, 3, 4, 5]]), + np.array([[1, 2, 3, 4, 5]]), + 1, + "cov", + True, + np.array([[10.0]]), + None, + False, + ), + ( + np.array([[1, 2, 3, 4, 5]]), + np.array([[1, 2, 3, 4, 5]]), + 1, + "cov", + False, + np.array([[10.0]]), + True, + False, + ), + ( + np.array([[1, 2, 3, 4, 5]]), + np.array([[1, 2, 3, 4, 5]]), + 1, + "cov_R", + False, + np.array([[13.75]]), + True, + False, + ), + ( + np.array([[1, 2, 3, 4, 5]]), + np.array([[1, 2, 3, 4, 5]]), + 1, + "dat", + True, + None, + None, + True, + ), + ( + np.array([[1, 2, 3, 4, 5]]), + np.array([[1, 2, 3, 4, 5]]), + 1, + "dat", + False, + np.array([[-3.65148372]]), + True, + False, + ), + ( + np.array([[1, 2, 3, 4, 5]]), + np.array([[1, 2, 3, 4, 5]]), + 1, + "YfYp", + True, + None, + None, + True, + ), + ], +) +def test_build_hank( + Y: np.ndarray, + Yref: np.ndarray, + br: int, + method: str, + calc_unc: bool, + expected_hank: typing.Union[np.ndarray, None], + expected_uncertainty_is_none: bool, + expected_error: bool, +) -> None: + """Test the build_hank function.""" + if expected_error: + with pytest.raises(AttributeError) as e: + ssi.build_hank( + Y=Y, Yref=Yref, br=br, method=method, calc_unc=calc_unc, nb=100 + ) + assert ( + e.value == "Uncertainty calculations are only available for 'cov' method" + ) + else: + hank, uncertainty = ssi.build_hank( + Y=Y, Yref=Yref, br=br, method=method, calc_unc=calc_unc, nb=100 + ) + assert np.allclose(hank, expected_hank) + if expected_uncertainty_is_none: + assert uncertainty is None + else: + assert uncertainty is not None + + +def test_build_hank_invalid_method() -> None: + """Test the build_hank function with invalid method.""" + with pytest.raises(AttributeError) as e: + ssi.build_hank( + Y=np.array([[1, 2, 3, 4, 5]]), + Yref=np.array([[1, 2, 3, 4, 5]]), + br=1, + method="invalid_method", + calc_unc=False, + nb=100, + ) + assert e.value == "Uncertainty calculations are only available for 'cov' method" + + +def test_SSI() -> None: + """Test the SSI function.""" + # Define test input + H = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]]) + br = 1 + ordmax = 2 + step = 1 + + # Call the function with test input + Obs, A, C = ssi.SSI(H, br, ordmax, step) + + # Check if the output has the correct shape + assert Obs.shape == (4, 2) + assert A[0].shape == (0, 0) + assert A[1].shape == (1, 1) + assert A[2].shape == (2, 2) + + assert C[0].shape == (4, 0) + assert C[1].shape == (4, 1) + assert C[2].shape == (4, 2) + + # Check if the output is of the correct type + assert all([isinstance(a, np.ndarray) for a in A]) + assert all([isinstance(c, np.ndarray) for c in C]) + + +def test_SSI_fast() -> None: + """Test the SSI_fast function.""" + H = np.array( + [ + [1, 2, 3], + [4, 5, 6], + [7, 8, 9], + [10, 11, 12], + [13, 14, 15], + [16, 17, 18], + [19, 20, 21], + [22, 23, 24], + ] + ) + br = 2 # Increase block rows + ordmax = 2 + step = 1 + + # Call the function with test input + Obs, A, C = ssi.SSI_fast(H, br, ordmax, step) + + # Check output shapes + assert len(A) == ordmax + 1 + assert len(C) == ordmax + 1 + assert isinstance(Obs, np.ndarray) + + +# def test_SSI_poles() -> None: +# """Test the SSI_poles function.""" +# # Define test input +# A = [np.array([[1, 2], [3, 4]]), np.array([[5, 6], [7, 8]])] +# C = [np.array([[1, 0], [0, 1]]), np.array([[1, 0], [0, 1]])] +# ordmax = 2 +# dt = 0.1 +# step = 1 + +# # Call the function with test input +# Fn, Sm, Ms = ssi.SSI_poles(A, C, ordmax, dt, step) + +# # Check if the output has the correct shape +# assert Fn.shape == (ordmax, int((ordmax) / step + 1)) +# assert Sm.shape == (ordmax, int((ordmax) / step + 1)) +# assert Ms.shape == (ordmax, int((ordmax) / step + 1), C[0].shape[0]) + +# # Check if the output is of the correct type +# assert isinstance(Fn, np.ndarray) +# assert isinstance(Sm, np.ndarray) +# assert isinstance(Ms, np.ndarray) + + +@pytest.mark.parametrize( + "Obs, AA, CC, ordmax, dt, " + "step, calc_unc," + "expected_Fn, expected_Xi, expected_Phi, " + "expected_lambdas, expected_Fn_cov, expected_Xi_cov, expected_Phi_cov", + [ + # Test case 1: Basic functionality without uncertainty calculation + ( + np.array([[1, 2], [6, 7]]), # Obs + [np.array([[1]]), np.array([[7]])], # AA (reduced to 1x1) + [np.array([[1]]), np.array([[1]])], # CC (reduced to 1x1) + 1, # ordmax + 0.01, # dt + 1, # step + False, # calc_unc + np.array([[np.nan, np.nan]]), # expected_Fn + np.array([[np.nan, np.nan]]), # expected_Xi + np.array([[np.nan, np.nan]]), # expected_Phi + np.array([[np.nan, np.nan]]), # expected_lambdas + None, # expected_Fn_cov + None, # expected_Xi_cov + None, # expected_Phi_cov + ), + ], +) +def test_SSI_poles( + Obs, + AA, + CC, + ordmax, + dt, + step, + calc_unc, + expected_Fn, + expected_Xi, + expected_Phi, + expected_lambdas, + expected_Fn_cov, + expected_Xi_cov, + expected_Phi_cov, +) -> None: + Fn, Xi, Phi, Lambds, Fn_cov, Xi_cov, Phi_cov = ssi.SSI_poles( + Obs=Obs, + AA=AA, + CC=CC, + ordmax=ordmax, + dt=dt, + step=step, + calc_unc=calc_unc, + ) + assert assert_array_equal_with_nan(Fn, expected_Fn) + assert assert_array_equal_with_nan(Xi, expected_Xi) + assert assert_array_equal_with_nan(Phi, expected_Phi) + assert assert_array_equal_with_nan(Lambds, expected_lambdas) + + if expected_Fn_cov: + assert assert_array_equal_with_nan(Fn_cov, expected_Fn_cov) + else: + assert Fn_cov is None + if expected_Xi_cov: + assert assert_array_equal_with_nan(Xi_cov, expected_Xi_cov) + else: + assert Xi_cov is None + if expected_Phi_cov: + assert assert_array_equal_with_nan(Phi_cov, expected_Phi_cov) + else: + assert Phi_cov is None + + +def test_SSI_multi_setup() -> None: + """Test the SSI_multi_setup function.""" + # Define test data + Y = [ + {"ref": np.random.rand(3, 10), "mov": np.random.rand(2, 10)}, + {"ref": np.random.rand(3, 10), "mov": np.random.rand(2, 10)}, + ] + fs = 1.0 + br = 2 + ordmax = 3 + methodHank = "cov" + + # Test with default step and method + A, C, *_ = ssi.SSI_multi_setup(Y, fs, br, ordmax, methodHank) + assert isinstance(A, np.ndarray) and isinstance(C, list) + assert all(isinstance(a, np.ndarray) for a in A) and all( + isinstance(c, np.ndarray) for c in C + ) + + # Test with non-default step and method + Obs_all, A, C = ssi.SSI_multi_setup(Y, fs, br, ordmax, step=2, method_hank="cov") + + assert isinstance(Obs_all, np.ndarray) and isinstance(A, list) and isinstance(C, list) + assert all(isinstance(a, np.ndarray) for a in A) and all( + isinstance(c, np.ndarray) for c in C + ) + + # Test with invalid method + with pytest.raises(AttributeError): + ssi.SSI_multi_setup(Y, fs, br, ordmax, method_hank="INVALID") + + # Test with invalid methodHank + with pytest.raises(AttributeError): + ssi.SSI_multi_setup(Y, fs, br, ordmax, "INVALID") + + +# Dummy MAC function +def MAC(a, b): + return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b)) + + +def test_SSI_mpe() -> None: + """Test the SSI_mpe function.""" + # Define test data + sel_freq = [1.0, 2.0, 3.0] + Fn_pol = np.random.rand(10, 11) + Sm_pol = np.random.rand(10, 11) + Ms_pol = np.random.rand(10, 11, 12) + order = 5 + Lab = np.random.randint(0, 8, size=(10, 11)) + + # Test with default parameters + Fn, Xi, Phi, order_out, *_ = ssi.SSI_mpe( + freq_ref=sel_freq, + Fn_pol=Fn_pol, + Xi_pol=Sm_pol, + Phi_pol=Ms_pol, + order=order, + Lab=Lab, + step=1, + ) + assert isinstance(Fn, np.ndarray) + assert isinstance(Xi, np.ndarray) + assert isinstance(Phi, np.ndarray) + assert isinstance(order_out, (int, np.ndarray)) + + # Test with order as 'find_min' + Fn, Xi, Phi, order_out, *_ = ssi.SSI_mpe( + freq_ref=sel_freq, + Fn_pol=Fn_pol, + Xi_pol=Sm_pol, + Phi_pol=Ms_pol, + order="find_min", + Lab=Lab, + step=1, + ) + assert isinstance(Fn, np.ndarray) + assert isinstance(Xi, np.ndarray) + assert isinstance(Phi, np.ndarray) + assert isinstance(order_out, (int, np.ndarray)) if order_out is not None else True + + # Test with order as list of int + order = [1, 2, 3] + Fn, Xi, Phi, order_out, *_ = ssi.SSI_mpe( + freq_ref=sel_freq, + Fn_pol=Fn_pol, + Xi_pol=Sm_pol, + Phi_pol=Ms_pol, + order=order, + Lab=Lab, + step=1, + ) + assert isinstance(Fn, np.ndarray) + assert isinstance(Xi, np.ndarray) + assert isinstance(Phi, np.ndarray) + assert isinstance(order_out, (int, np.ndarray)) if order_out is not None else True + + # Test with invalid order + with pytest.raises(AttributeError): + ssi.SSI_mpe( + freq_ref=sel_freq, + Fn_pol=Fn_pol, + Xi_pol=Sm_pol, + Phi_pol=Ms_pol, + order="INVALID", + Lab=Lab, + step=1, + ) + + # Test with order='find_min' but Lab is None + with pytest.raises(AttributeError): + ssi.SSI_mpe( + freq_ref=sel_freq, + Fn_pol=Fn_pol, + Xi_pol=Sm_pol, + Phi_pol=Ms_pol, + order="find_min", + Lab=None, + step=1, + ) diff --git a/tests/unit/test_algorithms.py b/tests/unit/test_algorithms.py new file mode 100644 index 0000000..6c1e7a5 --- /dev/null +++ b/tests/unit/test_algorithms.py @@ -0,0 +1,136 @@ +from typing import Any + +import pytest +from pyoma2.algorithms import BaseAlgorithm +from pyoma2.algorithms.data.run_params import BaseRunParams +from pyoma2.setup import SingleSetup + + +def test_child_algo_must_define_run_param_cls(): + """ + Check that a subclass of BaseAlgorithm must define RunParamCls + """ + with pytest.raises(ValueError) as excinfo: + # Attempt to define or instantiate a subclass of BaseAlgorithm + # without defining RunParamCls + class MyClass(BaseAlgorithm): + def run(self): + return super().run() + + def mpe(self, *args, **kwargs) -> Any: + return super().mpe(*args, **kwargs) + + def mpe_from_plot(self, *args, **kwargs) -> Any: + return super().mpe_from_plot(*args, **kwargs) + + assert "RunParamCls must be defined in subclasses of BaseAlgorithm" in str( + excinfo.value + ) + + +def test_run_param_cls_is_subclass_of_base_run_params(): + """ + Check that RunParamCls must be a subclass of BaseRunParams + """ + with pytest.raises(ValueError) as excinfo: + # Attempt to define or instantiate a subclass of BaseAlgorithm + # with a RunParamCls that is not a subclass of BaseRunParams + class MyClass(BaseAlgorithm): + RunParamCls = object + + def run(self): + return super().run() + + def mpe(self, *args, **kwargs) -> Any: + return super().mpe(*args, **kwargs) + + def mpe_from_plot(self, *args, **kwargs) -> Any: + return super().mpe_from_plot(*args, **kwargs) + + assert "RunParamCls must be defined in subclasses of BaseAlgorithm" in str( + excinfo.value + ) + + +def test_child_algo_must_define_result_cls(): + """ + Check that a subclass of BaseAlgorithm must define ResultCls + """ + with pytest.raises(ValueError) as excinfo: + # Attempt to define or instantiate a subclass of BaseAlgorithm without defining ResultCls + class MyClass(BaseAlgorithm): + RunParamCls = BaseRunParams + + def run(self): + return super().run() + + def mpe(self, *args, **kwargs) -> Any: + return super().mpe(*args, **kwargs) + + def mpe_from_plot(self, *args, **kwargs) -> Any: + return super().mpe_from_plot(*args, **kwargs) + + assert "ResultCls must be defined in subclasses of BaseAlgorithm" in str( + excinfo.value + ) + + +def test_result_cls_is_subclass_of_base_result(): + """ + Check that ResultCls must be a subclass of BaseResult + """ + with pytest.raises(ValueError) as excinfo: + # Attempt to define or instantiate a subclass of BaseAlgorit + # with a ResultCls that is not a subclass of BaseResult + class MyClass(BaseAlgorithm): + RunParamCls = BaseRunParams + ResultCls = object + + def run(self): + return super().run() + + def mpe(self, *args, **kwargs) -> Any: + return super().mpe(*args, **kwargs) + + def mpe_from_plot(self, *args, **kwargs) -> Any: + return super().mpe_from_plot(*args, **kwargs) + + assert "ResultCls must be defined in subclasses of BaseAlgorithm" in str( + excinfo.value + ) + + +def test_run_cant_be_called_without_run_param( + fake_single_setup_fixture_no_param: SingleSetup, +): + """ + Check that run can't be called without setting run_params + """ + + with pytest.raises(ValueError) as excinfo: + # Attempt to call run without setting run_params + fake_single_setup_fixture_no_param.run_all() + + assert ( + "Run parameters must be set before running the algorithm, use a Setup class to run it" + in str(excinfo.value) + ) + + +def test_result_from_setup(fake_single_setup_fixture_with_param: SingleSetup): + """ + Check that result is not none after run with the setupclass or after call set_result + """ + assert all( + [ + algo.result is None + for algo in fake_single_setup_fixture_with_param.algorithms.values() + ] + ) + fake_single_setup_fixture_with_param.run_all() + assert all( + [ + algo.result is not None + for algo in fake_single_setup_fixture_with_param.algorithms.values() + ] + ) diff --git a/tests/unit/test_setups.py b/tests/unit/test_setups.py new file mode 100644 index 0000000..4fc3691 --- /dev/null +++ b/tests/unit/test_setups.py @@ -0,0 +1,277 @@ +import typing + +import numpy as np +import pytest + +from src.pyoma2.algorithms import BaseAlgorithm +from src.pyoma2.setup import MultiSetup_PoSER, MultiSetup_PreGER, SingleSetup + +from ..factory import FakeAlgorithm, FakeAlgorithm2 + + +def test_init_single_setup(ss: SingleSetup) -> None: + """Test the initialization of SingleSetup.""" + assert ss.dt == 1 / ss.fs + assert ss.Nch == ss.data.shape[1] + assert ss.Ndat == ss.data.shape[0] + assert ss.dt * ss.Ndat == ss.T + assert ss.algorithms == {} + + +@pytest.mark.parametrize( + "init_kwargs, algorithms, names, run_first, expected_exception, expected_message", + [ + # 1. No setups + ( + {"ref_ind": [], "single_setups": []}, # init_kwargs + {}, # algorithms + [], # names + False, # run_first + ValueError, # expected_exception + "You must pass at least two setup", # expected_message + ), + # 2. Only one setup + ( + { + "ref_ind": [], + "single_setups": [SingleSetup(np.zeros((10, 10)), fs=100)], + }, # init_kwargs + {0: [FakeAlgorithm(name="one")]}, # algorithms + ["one"], # names + False, # run_first + ValueError, # expected_exception + "You must pass at least two setup", # expected_message + ), + # 3. Setups with no algorithms + ( + { + "ref_ind": [], + "single_setups": [ + SingleSetup(np.zeros((10, 10)), fs=100), + SingleSetup(np.zeros((10, 10)), fs=100), + ], + }, # init_kwargs + {}, # algorithms + ["one"], # names + False, # run_first + ValueError, # expected_exception + "You must pass setups with at least one algorithm", # expected_message + ), + # 4. Names len different from nr of algorithms + ( + { + "ref_ind": [], + "single_setups": [ + SingleSetup(np.zeros((10, 10)), fs=100), + SingleSetup(np.zeros((10, 10)), fs=100), + ], + }, # init_kwargs + { + 0: [ + FakeAlgorithm(run_params=FakeAlgorithm.RunParamCls(param1=1)), + ], + 1: [ + FakeAlgorithm(run_params=FakeAlgorithm.RunParamCls(param1=1)), + ], + }, # algorithms + ["one", "two", "three"], # names + False, # run_first + ValueError, # expected_exception + "The number of names must match the number of algorithms", # expected_message + ), + # 5. Algorithm in setup not ran + ( + { + "ref_ind": [], + "single_setups": [ + SingleSetup(np.zeros((10, 10)), fs=100), + SingleSetup(np.zeros((10, 10)), fs=100), + ], + }, # init_kwargs + { + 0: [ + FakeAlgorithm(run_params=FakeAlgorithm.RunParamCls(param1=1)), + ], + 1: [ + FakeAlgorithm(run_params=FakeAlgorithm.RunParamCls(param1=1)), + ], + }, # algorithms + [ + "one", + ], # names + False, # run_first + ValueError, # expected_exception + "You must pass Single setups that have already been run", # expected_message + ), + # 6. Setup with less algorithms than expected + ( + { + "ref_ind": [], + "single_setups": [ + SingleSetup(np.zeros((10, 10)), fs=100), + SingleSetup(np.zeros((10, 10)), fs=100), + ], + }, # init_kwargs + { + 0: [ + FakeAlgorithm(run_params=FakeAlgorithm.RunParamCls(param1=1)), + FakeAlgorithm2(run_params=FakeAlgorithm2.RunParamCls(param1=1)), + ], + 1: [ + FakeAlgorithm(run_params=FakeAlgorithm.RunParamCls(param1=1)), + ], + }, # algorithms + ["one", "two"], + True, + ValueError, + "The algorithms must be consistent between setups", + ), + # 7. Setup with different order of algorithms + ( + { + "ref_ind": [], + "single_setups": [ + SingleSetup(np.zeros((10, 10)), fs=100), + SingleSetup(np.zeros((10, 10)), fs=100), + ], + }, # init_kwargs + { + 0: [ + FakeAlgorithm(run_params=FakeAlgorithm.RunParamCls(param1=1)), + FakeAlgorithm2(run_params=FakeAlgorithm2.RunParamCls(param1=1)), + ], + 1: [ + # order is inverted + FakeAlgorithm2(run_params=FakeAlgorithm2.RunParamCls(param1=1)), + FakeAlgorithm(run_params=FakeAlgorithm.RunParamCls(param1=1)), + ], + }, # algorithms + ["one", "two"], + True, + ValueError, + "The algorithms must be consistent between setups", + ), + # 8. Setup with different order of algorithms + ( + { + "ref_ind": [], + "single_setups": [ + SingleSetup(np.zeros((10, 10)), fs=100), + SingleSetup(np.zeros((10, 10)), fs=100), + ], + }, # init_kwargs + { + 0: [ + FakeAlgorithm(run_params=FakeAlgorithm.RunParamCls(param1=1)), + FakeAlgorithm2(run_params=FakeAlgorithm2.RunParamCls(param1=1)), + ], + 1: [ + # different set of algorithms + FakeAlgorithm(run_params=FakeAlgorithm2.RunParamCls(param1=1)), + FakeAlgorithm(run_params=FakeAlgorithm.RunParamCls(param1=1)), + ], + }, # algorithms + ["one", "two"], + True, + ValueError, + "The algorithms must be consistent between setups", + ), + ], + ids=[ + "1. No setups", + "2. Only one setup", + "3. Setups with no algorithms", + "4. Names len different from nr of algorithms", + "5. Algorithm in setup not ran", + "6. Setup with less algorithms than expected", + "7. Setup with different order of algorithms", + "8. Setup with different set of algorithms", + ], +) +def test_init_multisetup_poser_exc( + init_kwargs: typing.Dict, + algorithms: typing.Dict[int, typing.List[BaseAlgorithm]], + names: typing.List[str], + run_first: bool, + expected_exception: Exception, + expected_message: str, +) -> None: + """Test the failure of initialization of MultiSetup_PoSER.""" + + # Add algorithms to the setups + for i, ss in enumerate(init_kwargs["single_setups"]): + if i in algorithms: + ss.add_algorithms(*algorithms[i]) + if run_first: + ss.run_all() + + # Test the exception + with pytest.raises(expected_exception) as excinfo: + MultiSetup_PoSER(**init_kwargs, names=names) + assert expected_message in str(excinfo.value) + + +def test_init_multisetup_poser(multi_setup_data_fixture) -> None: + """Test the initialization of MultiSetup_PoSER.""" + + # setup multisetup poser initialization + set1, set2, set3 = multi_setup_data_fixture + ss1 = SingleSetup(set1, fs=100) + ss2 = SingleSetup(set2, fs=100) + ss3 = SingleSetup(set3, fs=100) + ss1.add_algorithms( + FakeAlgorithm(run_params=FakeAlgorithm.RunParamCls(param1=1), name="fa_1"), + FakeAlgorithm2(run_params=FakeAlgorithm2.RunParamCls(param1=1), name="fa2_1"), + ) + ss2.add_algorithms( + FakeAlgorithm(run_params=FakeAlgorithm.RunParamCls(param1=1)), + FakeAlgorithm2(run_params=FakeAlgorithm2.RunParamCls(param1=1)), + ) + ss3.add_algorithms( + FakeAlgorithm(run_params=FakeAlgorithm.RunParamCls(param1=1)), + FakeAlgorithm2(run_params=FakeAlgorithm2.RunParamCls(param1=1)), + ) + ss1.run_all() + ss2.run_all() + ss3.run_all() + + # initialize MultiSetup_PoSER + msp = MultiSetup_PoSER( + ref_ind=[[0, 1, 2], [0, 1, 2], [0, 1, 2]], + single_setups=[ss1, ss2, ss3], + names=["one", "two"], + ) + assert msp.ref_ind == [[0, 1, 2], [0, 1, 2], [0, 1, 2]] + assert msp.setups == [ss1, ss2, ss3] + + # set setups after initialization + with pytest.raises(AttributeError) as excinfo: + msp.setups = [] + assert "Cannot set setups after initialization" in str(excinfo.value) + + # access result before merging + with pytest.raises(ValueError) as excinfo: + _ = msp.result + assert "You must run merge_results() first" in str(excinfo.value) + + +def test_init_multisetup_preger(multi_setup_data_fixture) -> None: + """Test the initialization of MultiSetup_PreGER.""" + + # setup multisetup poser initialization + set1, set2, set3 = multi_setup_data_fixture + # list of datasets and reference indices + data = [set1, set2, set3] + ref_ind = [[0, 1, 2], [0, 1, 2], [0, 1, 2]] + + # initialize MultiSetup_PreGER + msp = MultiSetup_PreGER(fs=100, ref_ind=ref_ind, datasets=data) + + assert msp.dt == 1 / msp.fs + assert msp.Nsetup == len(ref_ind) + + assert len(msp.data) == len(data) + + assert all(([k for k in d] == ["ref", "mov"] for d in msp.data)) + assert all(([isinstance(v, np.ndarray) for v in d.values()] for d in msp.data)) + assert msp.Ts == [600.0, 600.0, 600.0] diff --git a/tox.ini b/tox.ini new file mode 100644 index 0000000..f9f7d1d --- /dev/null +++ b/tox.ini @@ -0,0 +1,43 @@ +[tox] +envlist = py38, py39, py310, py311, py312 + +[testenv] +deps = + pdm==2.17.2 + pytest===7.4.4 + +[testenv:py38] +basepython = python3.8 +commands = + pdm install --lockfile=pdm-py38unix.lock + pdm run pytest + +[testenv:py39] +basepython = python3.9 +commands = + pdm install --lockfile=pdm-py39+unix.lock + pdm run pytest + +[testenv:py310] +basepython = python3.10 +commands = + pdm install --lockfile=pdm-py39+unix.lock + pdm run pytest + +[testenv:py311] +basepython = python3.11 +commands = + pdm install --lockfile=pdm-py39+unix.lock + pdm run pytest + +[testenv:py312] +basepython = python3.12 +commands = + pdm install --lockfile=pdm-py39+unix.lock + pdm run pytest + +[testenv:tkinter] +basepython = python3 +whitelist_externals = sudo +commands_pre = + sudo apt-get install -y python3-tk