diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 0000000..5bce681 --- /dev/null +++ b/.gitattributes @@ -0,0 +1,8 @@ +* text=auto + +*.{diff,patch} binary + +*.{py,yaml,yml,sh} text eol=lf +*.bat text eol=crlf + +pixi.lock linguist-language=YAML linguist-generated=true diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS new file mode 100644 index 0000000..046c0d9 --- /dev/null +++ b/.github/CODEOWNERS @@ -0,0 +1 @@ +* @adityagoel4512 @cbourjau diff --git a/.github/dependabot.yml b/.github/dependabot.yml new file mode 100644 index 0000000..1254038 --- /dev/null +++ b/.github/dependabot.yml @@ -0,0 +1,12 @@ +version: 2 +updates: + - package-ecosystem: github-actions + directory: / + schedule: + interval: monthly + reviewers: + - quantco/ci + groups: + gh-actions: + patterns: + - "*" diff --git a/.github/workflows/array-api.yml b/.github/workflows/array-api.yml new file mode 100644 index 0000000..1cd6665 --- /dev/null +++ b/.github/workflows/array-api.yml @@ -0,0 +1,45 @@ +name: Array API coverage tests +on: + push: + branches: + - "*" + schedule: + - cron: "0 8 * * *" + +# Automatically stop old builds on the same branch/PR +concurrency: + group: ${{ github.workflow }}-${{ github.ref }} + cancel-in-progress: true + +jobs: + array-api-tests: + # Run if the commit message contains 'run array-api tests' or if the job is triggered on schedule + if: >- + contains(github.event.head_commit.message, 'run array-api tests') || + github.event_name == 'schedule' + name: Array API test + timeout-minutes: 90 + runs-on: ubuntu-latest-8core + steps: + - name: Checkout branch + uses: actions/checkout@v4 + with: + ref: ${{ github.head_ref }} + fetch-depth: 0 + submodules: recursive + - name: Set up pixi + uses: prefix-dev/setup-pixi@ba3bb36eb2066252b2363392b7739741bb777659 + - name: Install repository + run: pixi run postinstall + - name: Run Array API tests + env: + ARRAY_API_TESTS_MODULE: ndonnx + run: | + pushd api-coverage-tests + pixi run pytest --ci --max-examples 2 array_api_tests/ --json-report --json-report-file=api-coverage-tests.json -n auto -vv --skips-file=../skips.txt + popd + - name: Upload Array API tests report + uses: actions/upload-artifact@v4 + with: + name: api-coverage-tests + path: api-coverage-tests/api-coverage-tests.json diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml new file mode 100644 index 0000000..bcd18e8 --- /dev/null +++ b/.github/workflows/build.yml @@ -0,0 +1,48 @@ +name: Build +on: + push: + branches: + - main + tags: + - "*" + pull_request: + +jobs: + build: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + with: + ref: ${{ github.ref }} + fetch-depth: 0 + - name: Set up pixi + uses: prefix-dev/setup-pixi@ba3bb36eb2066252b2363392b7739741bb777659 + with: + environments: build + - name: Build project + run: pixi run -e build build-wheel + - name: Upload package + uses: actions/upload-artifact@v4 + with: + name: artifact + path: dist/* + + release: + name: Publish package + if: startsWith(github.ref, 'refs/tags/') + needs: [build] + runs-on: ubuntu-latest + permissions: + id-token: write + environment: pypi + steps: + - uses: actions/download-artifact@v4 + with: + name: artifact + path: dist + - name: Publish package on TestPyPi + uses: pypa/gh-action-pypi-publish@81e9d935c883d0b210363ab89cf05f3894778450 + with: + repository-url: https://test.pypi.org/legacy/ + - name: Publish package on PyPi + uses: pypa/gh-action-pypi-publish@81e9d935c883d0b210363ab89cf05f3894778450 diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml new file mode 100644 index 0000000..d342e3f --- /dev/null +++ b/.github/workflows/ci.yml @@ -0,0 +1,55 @@ +name: CI +on: + push: + branches: + - main + pull_request: + +concurrency: + group: ${{ github.workflow }}-${{ github.ref }} + cancel-in-progress: true + +jobs: + pre-commit-checks: + name: Pre-commit Checks + timeout-minutes: 30 + runs-on: ubuntu-latest + steps: + - name: Checkout branch + uses: actions/checkout@v4 + - name: Set up pixi + uses: prefix-dev/setup-pixi@ba3bb36eb2066252b2363392b7739741bb777659 + with: + environments: default lint + - name: pre-commit + run: pixi run pre-commit-run --color=always --show-diff-on-failure + + unit-tests: + name: pytest + timeout-minutes: 30 + runs-on: ${{ matrix.os }} + strategy: + fail-fast: false + matrix: + os: + - ubuntu-latest + - macos-latest + - windows-latest + environment: + - py310 + - py311 + - py312 + steps: + - name: Checkout branch + uses: actions/checkout@v4 + with: + ref: ${{ github.head_ref }} + fetch-depth: 0 + - name: Set up pixi + uses: prefix-dev/setup-pixi@ba3bb36eb2066252b2363392b7739741bb777659 + with: + environments: ${{ matrix.environment }} + - name: Install repository + run: pixi run -e ${{ matrix.environment }} postinstall + - name: Run pytest + run: pixi run -e ${{ matrix.environment }} test-coverage --color=yes diff --git a/.github/workflows/docs.yml b/.github/workflows/docs.yml new file mode 100644 index 0000000..224fe9a --- /dev/null +++ b/.github/workflows/docs.yml @@ -0,0 +1,40 @@ +name: Documentation +on: + push: + branches: + - main + pull_request: + +concurrency: + group: ${{ github.workflow }}-${{ github.ref }} + cancel-in-progress: true + +jobs: + build: + name: Build Docs + runs-on: ubuntu-latest + steps: + - name: Checkout + uses: actions/checkout@v4 + with: + ref: ${{ github.head_ref }} + fetch-depth: 0 + - name: Set up pixi + uses: prefix-dev/setup-pixi@ba3bb36eb2066252b2363392b7739741bb777659 + with: + environments: docs + - name: Install package + run: pixi run -e docs postinstall + - name: Build docs + run: pixi run docs + - name: Upload html + uses: actions/upload-artifact@v4 + with: + name: docs + path: docs/_build/html + - name: Publish docs + if: github.event_name == 'push' && github.ref == 'refs/heads/main' + uses: peaceiris/actions-gh-pages@4f9cc6602d3f66b9c108549d475ec49e8ef4d45e + with: + github_token: ${{ secrets.GITHUB_TOKEN }} + publish_dir: ./docs/_build/html diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..41598b3 --- /dev/null +++ b/.gitignore @@ -0,0 +1,408 @@ +# Explicitly unignore hidden files for ripgrep. Individual folders can still +# be ignored in the blocks below. +!.* + +# NOTE: The block below is NOT copied sic from https://www.toptal.com/developers/gitignore. +# Instead, it contains some customizations that should be taken into account when adjusting the +# block. + +# Created by https://www.toptal.com/developers/gitignore/api/linux,macos,direnv,python,windows,pycharm+all,visualstudiocode,vim +# Edit at https://www.toptal.com/developers/gitignore?templates=linux,macos,direnv,python,windows,pycharm+all,visualstudiocode,vim + +### direnv ### +.direnv +.envrc + +### Linux ### +*~ + +# temporary files which can be created if a process still has a handle open of a deleted file +.fuse_hidden* + +# KDE directory preferences +.directory + +# Linux trash folder which might appear on any partition or disk +.Trash-* + +# .nfs files are created when an open file is removed but is still being accessed +.nfs* + +### macOS ### +# General +.DS_Store +.AppleDouble +.LSOverride + +# Icon must end with two \r +Icon + + +# Thumbnails +._* + +# Files that might appear in the root of a volume +.DocumentRevisions-V100 +.fseventsd +.Spotlight-V100 +.TemporaryItems +.Trashes +.VolumeIcon.icns +.com.apple.timemachine.donotpresent + +# Directories potentially created on remote AFP share +.AppleDB +.AppleDesktop +Network Trash Folder +Temporary Items +.apdisk + +### macOS Patch ### +# iCloud generated files +*.icloud + +### PyCharm+all ### +# Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio, WebStorm and Rider +# Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839 + +# User-specific stuff +.idea/**/workspace.xml +.idea/**/tasks.xml +.idea/**/usage.statistics.xml +.idea/**/dictionaries +.idea/**/shelf + +# AWS User-specific +.idea/**/aws.xml + +# Generated files +.idea/**/contentModel.xml + +# Sensitive or high-churn files +.idea/**/dataSources/ +.idea/**/dataSources.ids +.idea/**/dataSources.local.xml +.idea/**/sqlDataSources.xml +.idea/**/dynamic.xml +.idea/**/uiDesigner.xml +.idea/**/dbnavigator.xml + +# Gradle +.idea/**/gradle.xml +.idea/**/libraries + +# Gradle and Maven with auto-import +# When using Gradle or Maven with auto-import, you should exclude module files, +# since they will be recreated, and may cause churn. Uncomment if using +# auto-import. +# .idea/artifacts +# .idea/compiler.xml +# .idea/jarRepositories.xml +# .idea/modules.xml +# .idea/*.iml +# .idea/modules +# *.iml +# *.ipr + +# CMake +cmake-build-*/ + +# Mongo Explorer plugin +.idea/**/mongoSettings.xml + +# File-based project format +*.iws + +# IntelliJ +out/ + +# mpeltonen/sbt-idea plugin +.idea_modules/ + +# JIRA plugin +atlassian-ide-plugin.xml + +# Cursive Clojure plugin +.idea/replstate.xml + +# SonarLint plugin +.idea/sonarlint/ + +# Crashlytics plugin (for Android Studio and IntelliJ) +com_crashlytics_export_strings.xml +crashlytics.properties +crashlytics-build.properties +fabric.properties + +# Editor-based Rest Client +.idea/httpRequests + +# Android studio 3.1+ serialized cache file +.idea/caches/build_file_checksums.ser + +### PyCharm+all Patch ### +# Ignore everything but code style settings and run configurations +# that are supposed to be shared within teams. + +.idea/* + +!.idea/codeStyles +!.idea/runConfigurations + +### Python ### +# Byte-compiled / optimized / DLL files +__pycache__/ +*.py[cod] +*$py.class + +# C extensions +*.so + +# 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 + +# pixi +# Similar to Pipfile.lock, it is generally recommended to include pixi.lock in version control. +# This is especially recommended for binary packages to ensure reproducibility, and is more +# commonly ignored for libraries. +.pixi +#pixi.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 + +# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm +__pypackages__/ + +# 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/ + +### Python Patch ### +# Poetry local configuration file - https://python-poetry.org/docs/configuration/#local-configuration +poetry.toml + +# ruff +.ruff_cache/ + +# LSP config files +pyrightconfig.json + +### Vim ### +# Swap +[._]*.s[a-v][a-z] +!*.svg # comment out if you don't need vector files +[._]*.sw[a-p] +[._]s[a-rt-v][a-z] +[._]ss[a-gi-z] +[._]sw[a-p] + +# Session +Session.vim +Sessionx.vim + +# Temporary +.netrwhist +# Auto-generated tag files +tags +# Persistent undo +[._]*.un~ + +### VisualStudioCode ### +.vscode/ +#!.vscode/settings.json +#!.vscode/tasks.json +#!.vscode/launch.json +#!.vscode/extensions.json +#!.vscode/*.code-snippets + +# Local History for Visual Studio Code +.history/ + +# Built Visual Studio Code Extensions +*.vsix + +### VisualStudioCode Patch ### +# Ignore all local history of files +.history +.ionide + +### Windows ### +# Windows thumbnail cache files +Thumbs.db +Thumbs.db:encryptable +ehthumbs.db +ehthumbs_vista.db + +# Dump file +*.stackdump + +# Folder config file +[Dd]esktop.ini + +# Recycle Bin used on file shares +$RECYCLE.BIN/ + +# Windows Installer files +*.cab +*.msi +*.msix +*.msm +*.msp + +# Windows shortcuts +*.lnk + +# End of https://www.toptal.com/developers/gitignore/api/linux,macos,direnv,python,windows,pycharm+all,visualstudiocode,vim + +# rattler-build +output/ +# setuptools-scm needs `.git/refs/tags`, don't ignore +!.git/refs/tags + +# OS-specific +.DS_Store + +# Type-generated +ndonnx/_types.pyi +ndonnx/__init__.pyi diff --git a/.gitmodules b/.gitmodules new file mode 100644 index 0000000..aabd9d5 --- /dev/null +++ b/.gitmodules @@ -0,0 +1,3 @@ +[submodule "array-api-tests"] + path = api-coverage-tests + url = git@github.com:data-apis/array-api-tests.git diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml new file mode 100644 index 0000000..cdf712b --- /dev/null +++ b/.pre-commit-config.yaml @@ -0,0 +1,76 @@ +exclude: ^(\.copier-answers\.yml)|.pixi$ +repos: + - repo: local + hooks: + # ensure pixi environments are up to date + # workaround for https://github.com/prefix-dev/pixi/issues/1482 + - id: pixi-install + name: pixi-install + entry: pixi install -e default -e lint + language: system + always_run: true + require_serial: true + pass_filenames: false + # insert-license + - id: insert-license + name: insert-license + entry: >- + pixi run -e lint + insert-license + --license-base64 Q29weXJpZ2h0IChjKSBRdWFudENvIHt5ZWFyX3N0YXJ0fS17eWVhcl9lbmR9ClNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBMaWNlbnNlUmVmLVF1YW50Q28K + --dynamic-years + --comment-style "#" + language: system + types: [python] + # docformatter + - id: docformatter + name: docformatter + entry: pixi run -e lint docformatter -i + language: system + types: [python] + # ruff + - id: ruff + name: ruff + entry: pixi run -e lint ruff check --fix --exit-non-zero-on-fix --force-exclude + language: system + types_or: [python, pyi] + require_serial: true + - id: ruff-format + name: ruff-format + entry: pixi run -e lint ruff format --force-exclude + language: system + types_or: [python, pyi] + require_serial: true + # mypy + - id: mypy + name: mypy + entry: pixi run -e default mypy + language: system + types: [python] + require_serial: true + exclude: ^(tests|api-coverage-tests)/ + # prettier + - id: prettier + name: prettier + entry: pixi run -e lint prettier --write --list-different --ignore-unknown + language: system + types: [text] + files: \.(md|yml|yaml)$ + # pre-commit-hooks + - id: trailing-whitespace-fixer + name: trailing-whitespace-fixer + entry: pixi run -e lint trailing-whitespace-fixer + language: system + types: [text] + - id: end-of-file-fixer + name: end-of-file-fixer + entry: pixi run -e lint end-of-file-fixer + language: system + types: [text] + # typos + - id: typos + name: typos + entry: pixi run -e lint typos --force-exclude + language: system + types: [text] + require_serial: true diff --git a/.prettierignore b/.prettierignore new file mode 100644 index 0000000..c835e2c --- /dev/null +++ b/.prettierignore @@ -0,0 +1,6 @@ +build +conda.recipe +.copier-answers.yml + +*.html +*.properties diff --git a/.prettierrc b/.prettierrc new file mode 100644 index 0000000..478cc53 --- /dev/null +++ b/.prettierrc @@ -0,0 +1,7 @@ +{ + "singleQuote": false, + "bracketSpacing": true, + "printWidth": 200, + "endOfLine": "auto", + "tabWidth": 2 +} diff --git a/CHANGELOG.rst b/CHANGELOG.rst new file mode 100644 index 0000000..00dd5a0 --- /dev/null +++ b/CHANGELOG.rst @@ -0,0 +1,15 @@ +.. Versioning follows semantic versioning, see also + https://semver.org/spec/v2.0.0.html. The most important bits are: + * Update the major if you break the public API + * Update the minor if you add new functionality + * Update the patch if you fixed a bug +Changelog +========= + +0.4.0 (2024-05-16) +------------------ + +**Breaking changes** + +- The constant propagated value is no longer accessed from the ``eager_value`` property but instead the ``to_numpy()`` method. +- Non Array API functions have been moved to the ``ndonnx.additional`` namespace. diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..96b136e --- /dev/null +++ b/LICENSE @@ -0,0 +1,11 @@ +Copyright 2024 QuantCo Inc. + +Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: + +1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. + +2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. + +3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS “AS IS” AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/README.md b/README.md new file mode 100644 index 0000000..2f5a8a2 --- /dev/null +++ b/README.md @@ -0,0 +1,107 @@ +# ndonnx + +[![CI](https://img.shields.io/github/actions/workflow/status/quantco/ndonnx/ci.yml?style=flat-square&branch=main)](https://github.com/quantco/ndonnx/actions/workflows/ci.yml) +[![Documentation](https://img.shields.io/github/actions/workflow/status/quantco/ndonnx/docs.yml?style=flat-square&branch=main)](https://quantco.github.io/ndonnx) +[![conda-forge](https://img.shields.io/conda/pn/conda-forge/ndonnx?style=flat-square&logoColor=white&logo=conda-forge)](https://prefix.dev/channels/conda-forge/packages/ndonnx) + +An ONNX-backed array library that is compliant with the [Array API](https://data-apis.org/array-api/) standard. + +## Installation + +Releases are available on PyPI and conda-forge. + +```bash +# using pip +pip install ndonnx +# using conda +conda install ndonnx +# using pixi +pixi add ndonnx +``` + +## Development + +You can install the package in development mode using: + +```bash +git clone https://github.com/quantco/ndonnx +cd ndonnx + +# For Array API tests +git submodule update --init --recursive + +pixi shell +pre-commit run -a +pip install --no-build-isolation --no-deps -e . +pytest tests -n auto +``` + +## Quick start + +`ndonnx` is an ONNX based python array library. + +It has a couple of key features: + +- It implements the [`Array API`](https://data-apis.org/array-api/) standard. Standard compliant code can be executed without changes across numerous backends such as like `NumPy`, `JAX` and now `ndonnx`. + + ```python + import numpy.array_api as npx + import ndonnx as ndx + from jax.experimental import array_api as jxp + + def mean_drop_outliers(a, low=-5, high=5): + xp = a.__array_namespace__() + return xp.mean(a[(low < a) & (a < high)]) + + arr = [-12.12, 1.12, 2.12, 2.13, 123.,] + + np_result = mean_drop_outliers(npx.asarray(arr)) + jax_result = mean_drop_outliers(jxp.asarray(arr)) + ndx_result = mean_drop_outliers(ndx.asarray(arr)) + print(np_result) # 1.79 + print(jax_result) # 1.79 + print(ndx_result) # Array(1.79, dtype=ndx.Float64) + assert np_result == ndx_result.to_numpy() + ``` + +- It supports ONNX export. This allows you persist your logic into an ONNX computation graph for convenient and performant inference. + + ```python + import onnx + import ndonnx as ndx + + a = ndx.array(shape=("N",), dtype=ndx.float64) + b = ndx.array(shape=("N",), dtype=ndx.float64) + out = a[:2] + b[:2] + model_proto = ndx.build({"a": a, "b": b}, {"c": out}) + onnx.save(model_proto, "model.onnx") + + # Having serialised your model to disk, perform + # inference using a runtime of your choosing. + import onnxruntime as ort + import numpy as np + inference_session = ort.InferenceSession("model.onnx") + prediction, = inference_session.run(None, { + "a": np.array([1, 2, 3], dtype=np.float64), + "b": np.array([4, 5, 6], dtype=np.float64), + }) + print(prediction) # array([5., 7.]) + ``` + +In the future we will be enabling a stable API for an extensible data type system. This will allow users to define their own data types and operations on arrays with these data types. + +## Array API coverage + +Array API compatibility is tracked in the array-api coverage test suite in `api-coverage-tests`. Missing coverage is tracked in the `skips.txt` file. Contributions are welcome! + +Summary(1119 total): + +- 898 passed +- 210 failed +- 11 deselected + +Run the tests with: + +```bash +pixi run arrayapitests +``` diff --git a/api-coverage-tests b/api-coverage-tests new file mode 160000 index 0000000..ea15d57 --- /dev/null +++ b/api-coverage-tests @@ -0,0 +1 @@ +Subproject commit ea15d5792bbaeb57d2149e74870ad814730df704 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/_static/classify_iris.png b/docs/_static/classify_iris.png new file mode 100644 index 0000000..6b33f25 Binary files /dev/null and b/docs/_static/classify_iris.png differ diff --git a/docs/_static/modelhorizontal.png b/docs/_static/modelhorizontal.png new file mode 100644 index 0000000..d02f0b6 Binary files /dev/null and b/docs/_static/modelhorizontal.png differ diff --git a/docs/_static/reshape.png b/docs/_static/reshape.png new file mode 100644 index 0000000..2f70c1e Binary files /dev/null and b/docs/_static/reshape.png differ diff --git a/docs/api/modules.rst b/docs/api/modules.rst new file mode 100644 index 0000000..37262e6 --- /dev/null +++ b/docs/api/modules.rst @@ -0,0 +1,7 @@ +ndonnx +====== + +.. toctree:: + :maxdepth: 4 + + ndonnx diff --git a/docs/api/ndonnx.additional.rst b/docs/api/ndonnx.additional.rst new file mode 100644 index 0000000..de2d23d --- /dev/null +++ b/docs/api/ndonnx.additional.rst @@ -0,0 +1,10 @@ +ndonnx.additional package +========================= + +Module contents +--------------- + +.. automodule:: ndonnx.additional + :members: + :undoc-members: + :show-inheritance: diff --git a/docs/api/ndonnx.rst b/docs/api/ndonnx.rst new file mode 100644 index 0000000..fcad2d8 --- /dev/null +++ b/docs/api/ndonnx.rst @@ -0,0 +1,18 @@ +ndonnx package +============== + +Subpackages +----------- + +.. toctree:: + :maxdepth: 4 + + ndonnx.additional + +Module contents +--------------- + +.. automodule:: ndonnx + :members: + :undoc-members: + :show-inheritance: diff --git a/docs/conf.py b/docs/conf.py new file mode 100644 index 0000000..94cc609 --- /dev/null +++ b/docs/conf.py @@ -0,0 +1,129 @@ +# Copyright (c) QuantCo 2022-2024 +# SPDX-License-Identifier: LicenseRef-QuantCo + +# Configuration file for the Sphinx documentation builder. +# +# This file only contains a selection of the most common options. For a full +# list see the documentation: +# https://www.sphinx-doc.org/en/master/usage/configuration.html + +# -- Path setup -------------------------------------------------------------- + +# If extensions (or modules to document with autodoc) are in another directory, +# add these directories to sys.path here. If the directory is relative to the +# documentation root, use os.path.abspath to make it absolute, like shown here. +# +# import os +# import sys +# sys.path.insert(0, os.path.abspath('.')) + + +# -- Project information ----------------------------------------------------- + +import datetime +import importlib +import inspect +import os +import subprocess +import sys +from subprocess import CalledProcessError +from typing import cast + +_mod = importlib.import_module("ndonnx") + + +project = "ndonnx" +copyright = f"{datetime.date.today().year}, QuantCo, Inc" +author = "QuantCo, Inc." + +extensions = [ + "numpydoc", + "sphinxcontrib.apidoc", + "sphinx_toolbox.collapse", + "sphinx.ext.viewcode", + "sphinx.ext.linkcode", + "sphinx.ext.autosummary", + "sphinx.ext.autodoc", + "nbsphinx", +] + +apidoc_module_dir = "../ndonnx" +apidoc_output_dir = "api" +apidoc_separate_modules = True +apidoc_extra_args = ["--implicit-namespaces", "--follow-links"] + +templates_path = ["_templates"] +exclude_patterns = [ + "_build", + "Thumbs.db", + ".DS_Store", +] +html_theme = "sphinx_rtd_theme" +html_static_path = ["_static"] + +autosummary_generate = True +autodoc_type_aliases = {"npt.ArrayLike": "numpy.typing.ArrayLike"} +numpydoc_show_class_members = False +numpydoc_class_members_toctree = False + + +class ObjectInfo: + def __init__(self, module_name, full_name): + self.module_name = module_name + self.full_name = full_name + + def linkcode_resolve(self): + _submodule = sys.modules.get(self.module_name) + if _submodule is None: + return None + + _object = _submodule + for _part in self.full_name.split("."): + try: + _object = getattr(_object, _part) + except AttributeError: + return None + + try: + fn = inspect.getsourcefile(inspect.unwrap(_object)) # type: ignore + except TypeError: + fn = None + if not fn: + return None + + try: + source, line_number = inspect.getsourcelines(_object) + except OSError: + line_number = None # type: ignore + + if line_number: + linespec = f"#L{line_number}-L{line_number + len(source) - 1}" + else: + linespec = "" + + fn = os.path.relpath(fn, start=os.path.dirname(cast(str, _mod.__file__))) + + try: + # See https://stackoverflow.com/a/21901260 + commit = ( + subprocess.check_output(["git", "rev-parse", "HEAD"]) + .decode("ascii") + .strip() + ) + except CalledProcessError: + # If subprocess returns non-zero exit status + commit = "main" + + return ( + "https://github.com/quantco/ndonnx" + f"/blob/{commit}/{_mod.__name__.replace('.', '/')}/{fn}{linespec}" + ) + + +# Copied and adapted from +# https://github.com/pandas-dev/pandas/blob/4a14d064187367cacab3ff4652a12a0e45d0711b/doc/source/conf.py#L613-L659 +# Required configuration function to use sphinx.ext.linkcode +def linkcode_resolve(domain, info): + if domain != "py": + return None + return ObjectInfo(info["module"], info["fullname"]).linkcode_resolve() diff --git a/docs/datatypes/datatypes.rst b/docs/datatypes/datatypes.rst new file mode 100644 index 0000000..3d271a7 --- /dev/null +++ b/docs/datatypes/datatypes.rst @@ -0,0 +1,109 @@ +Data Types +========== +ndonnx exposes the following set of data types. There is also :doc:`unstable support <../experimental/experimental>` for defining your own structured data types. +"Core" types have a direct correspondence in ONNX. + +.. list-table:: + :widths: 25 50 20 20 + :header-rows: 1 + + * - Name + - Description + - Array API + - Core + * - ``float32`` + - 32-bit floating point number + - Yes + - Yes + * - ``float64`` + - 64-bit floating point number + - Yes + - Yes + * - ``int8`` + - 8-bit signed integer + - Yes + - Yes + * - ``int16`` + - 16-bit signed integer + - Yes + - Yes + * - ``int32`` + - 32-bit signed integer + - Yes + - Yes + * - ``int64`` + - 64-bit signed integer + - Yes + - Yes + * - ``uint8`` + - 8-bit unsigned integer + - Yes + - Yes + * - ``uint16`` + - 16-bit unsigned integer + - Yes + - Yes + * - ``uint32`` + - 32-bit unsigned integer + - Yes + - Yes + * - ``uint64`` + - 64-bit unsigned integer + - Yes + - Yes + * - ``bool`` + - Boolean + - Yes + - Yes + * - ``utf8`` + - UTF-8 string + - No + - Yes + * - ``nfloat32`` + - Nullable 32-bit floating point number + - No + - No + * - ``nfloat64`` + - Nullable 64-bit floating point number + - No + - No + * - ``nint8`` + - Nullable 8-bit signed integer + - No + - No + * - ``nint16`` + - Nullable 16-bit signed integer + - No + - No + * - ``nint32`` + - Nullable 32-bit signed integer + - No + - No + * - ``nint64`` + - Nullable 64-bit signed integer + - No + - No + * - ``nuint8`` + - Nullable 8-bit unsigned integer + - No + - No + * - ``nuint16`` + - Nullable 16-bit unsigned integer + - No + - No + * - ``nuint32`` + - Nullable 32-bit unsigned integer + - No + - No + * - ``nuint64`` + - Nullable 64-bit unsigned integer + - No + - No + * - ``nbool`` + - Nullable boolean + - No + - No + * - ``nutf8`` + - Nullable UTF-8 string + - No + - No diff --git a/docs/experimental/experimental.rst b/docs/experimental/experimental.rst new file mode 100644 index 0000000..b8c151f --- /dev/null +++ b/docs/experimental/experimental.rst @@ -0,0 +1,160 @@ +Experimental +============ + +This section documents features that are currently experimental. While we aim to promote these features to the public API, they may currently undergo breaking changes without prior notice and there is no strict timeline for inclusion. + +.. _propagation: + +Propagating values when interoperating with Spox +------------------------------------------------ + +As documented in the :doc:`Spox Interoperability ` section, you can extract a :class:`spox.Var` from an :class:`ndonnx.Array` using the :func:`ndonnx.Array.spox_var` method. +When exiting ndonnx to implement functionality using Spox' primitives, ndonnx is unable to propagate values by default. +Using the :func:`ndonnx._propagation.eager_propagate` decorator, you can make a function capable of propagating values. As with value propagation more broadly in ndonnx, this currently requires you to have onnxruntime installed. + +As an example, we implement a function to one-hot-encode an input array of strings. + +.. code-block:: python + + from typing import Iterable + import ndonnx as ndx + from ndonnx._propagation import eager_propagate + import spox.opset.ai.onnx.ml.v3 as ml + + @eager_propagate + def one_hot_encode(x: ndx.Array, categories: Iterable[str]) -> ndx.Array: + return ndx.from_spox_var(ml.one_hot_encoder(x.spox_var(), cats_strings=categories)) + + x = ndx.asarray(["a", "b", "a"]) + y = one_hot_encode(x, ["a", "b"]) + print(y.to_numpy()) + # [[1. 0.] + # [0. 1.] + # [1. 0.]] + +Using a custom operator library +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +The ONNX standard permits the definition of extensions in the form of custom operators. +If you are using your own custom operator with a onnxruntime-compatible implementation, value propagation may be extended to these operators too. + +.. code-block:: python + + import ndonnx as ndx + from ndonnx._propagation import _eager_propagate_with_custom_operators + + eager_propagate = _eager_propagate_with_custom_operators("path/to/shared_library.so") + + @eager_propagate + def my_op(x: ndx.Array) -> ndx.Array: + return ndx.from_spox_var(my_op(x.spox_var())) + +.. warning:: + Using custom operators may limit the portability of your exported ONNX model since not all runtimes may implement a non-standard operator. + + +User-defined data types +----------------------- + +Internally, ``ndonnx`` defines the ``StructType`` interface. This interface is used to implement the ``Nullable`` data types exported by ``ndonnx`` like ``nint64`` and ``nutf8`` but is actually designed to enable user-defined data types outside of ndonnx. + +The interface is defined below: + +.. autoclass:: ndonnx._experimental.StructType + :no-index: + :members: + :undoc-members: + :private-members: + + +Implementing a ``datetime64`` data type +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +Note that we will use the ``_experimental`` submodule. + +.. code-block:: python + + from typing import Self + + import ndonnx as ndx + from ndonnx import CastError, CoreType, Array + from ndonnx._experimental import OperationsBlock, CastMixin, Schema, StructType + import numpy as np + + + class DatetimeOperations(OperationsBlock): + def less_equal(self, x: Array, y: Array) -> Array: + if x.dtype == y.dtype == datetime64: + return x.unix_timestamp <= y.unix_timestamp + return NotImplemented + + class Datetime64(StructType, CastMixin): + def _fields(self) -> dict[str, StructType | CoreType]: + return { + "unix_timestamp": ndx.int64, + } + + def copy(self) -> Self: + return self + + def _schema(self) -> Schema: + return Schema( + type_name="datetime64", + author="myextensionlibrary", + ) + + def _parse_input(self, input: np.ndarray) -> dict: + # We accept numpy arrays of dtype datetime64[s] as input only. + if input.dtype == np.dtype("datetime64[s]"): + unix_timestamp = input.astype(np.int64) + else: + raise ValueError(f"Cannot parse input of dtype {input.dtype} to {self}") + + return { + "unix_timestamp": self._fields()["unix_timestamp"]._parse_input(unix_timestamp), + } + + def _assemble_output(self, fields: dict[str, np.ndarray]) -> np.ndarray: + return fields["unix_timestamp"].astype("datetime64[s]") + + def _cast_to(self, array: Array, dtype: CoreType | StructType) -> Array: + raise CastError(f"Cannot cast {self} to {dtype}") + + def _cast_from(self, array: Array) -> Array: + if isinstance(array.dtype, ndx.Numerical): + unix_timestamp = array.astype(ndx.int64) + else: + raise CastError(f"Cannot cast {array.dtype} to {self}") + + return Array._from_fields(self, unix_timestamp=unix_timestamp) + + _ops = DatetimeOperations() + + + datetime64 = Datetime64() + + +We can test our implementation out: + +.. code-block:: python + + a = np.array(["2024-02-01", "1969-07-20", "1912-02-12"], dtype="datetime64[s]") + b = np.array(["1924-02-01", "1969-07-21"], dtype="datetime64[s]") + + x = ndx.asarray(a, dtype=datetime64) + y = ndx.asarray(b, dtype=datetime64) + print(f"{x=}") + # x=Array(['2024-02-01T00:00:00' '1969-07-20T00:00:00' '1912-02-12T00:00:00'], dtype=Datetime64) + print(f"{y=}") + # y=Array(['1924-02-01T00:00:00' '1969-07-21T00:00:00'], dtype=Datetime64) + print(x[:2] <= y) + # Array([False True], dtype=Boolean) + +We've successfully implemented a ``datetime64`` data type! We now have a much more useful abstraction for working with datetime data in ONNX. + +Let's track back and explain how we just implemented this, in English rather than code: + +1. Decide the appropriate layout for ``datetime64`` and encoded it in ``_fields``. Representing time using an ``ndx.int64`` unix timestamp is a reasonable and efficient approach. +2. Implement ``_parse_input`` and ``_assemble_output``. These may be used by runtime utilities (and internally by ``ndonnx`` for propagation of build time values) to disassemble input datetime NumPy arrays into the constituent ``_fields`` and reassemble into datetime NumPy array from these fields. These functions must be each inverses. +3. Implement ``_schema``, which advertises some metadata about this type like the name, version and source library. This is written into the ONNX ``ModelProto`` for inference utilities and runtimes to optionally leverage. +4. Implement some optional casting behaviour using the ``CastMixin``. We would like to be able to cast between numerical arrays and ``datetime64`` arrays. +5. Implement functions that operate on arrays of our new type. Without this, arrays with ``datetime64`` dtype cannot do much. This is where the ``OperationsBlock`` is implemented and assigned to the ``_ops`` field of the data type. diff --git a/docs/index.rst b/docs/index.rst new file mode 100644 index 0000000..50eefc0 --- /dev/null +++ b/docs/index.rst @@ -0,0 +1,33 @@ +Welcome to ndonnx's documentation! +====================================== + +ndonnx is an ONNX-backed Python array library that implements the `Array API standard `_. + +.. toctree:: + :maxdepth: 1 + :caption: Guides + + Getting Started + Model Conversion + Interoperating with Spox + +.. toctree:: + :maxdepth: 2 + :caption: API Documentation + + API Reference + Data Types + +.. toctree:: + :maxdepth: 1 + :caption: Advanced Use Cases + + Experimental Features + Inference Utilities + +.. toctree:: + :maxdepth: 1 + :caption: Other + + Motivation + Changelog diff --git a/docs/inference/inference.rst b/docs/inference/inference.rst new file mode 100644 index 0000000..4f44921 --- /dev/null +++ b/docs/inference/inference.rst @@ -0,0 +1,89 @@ +Inference Utilities +=================== + +ndonnx addresses the challenge of converting models naturally expressed using arrays into ONNX. +It provides a relatively high level API and exposes complex data types like nullable integers that aren't actually present in the ONNX standard through library-level abstractions. + +Seeing an ONNX graph +-------------------- +Let's see how a simple reshape operation gets expressed in the ONNX graph exported by ndonnx. +Note that we're mixing nullable and non-nullable data types in this example. + +.. code-block:: python + + import ndonnx as ndx + import onnx + + x = ndx.array(shape=("N",), dtype=ndx.utf8) + y = ndx.array(shape=("M",), dtype=ndx.nutf8) + z = ndx.reshape(y, x.shape) + + model = ndx.build({"x": x, "y": y}, {"z": z}) + onnx.save(model, "reshape.onnx") + +We can visualize the model using Netron: + +.. image:: ../_static/reshape.png + :alt: Reshape Model + :align: center + +Why do we have three inputs? +~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +We end up with ``x``, ``y_values`` and ``y_null`` as inputs to the ONNX graph, even though only ``x`` and ``y`` were provided to :func:`ndonnx.build`. + +This comes from the fact that ``y`` has a nullable data type ``nutf8``. This is not present in the ONNX standard and is an abstraction provided by ndonnx to provide a more intuitive interface for dealing with missing data. +ndonnx implements this abstraction by composing a ``values`` and ``null`` mask array, which is decomposed into ``y_values`` and ``y_null`` when exporting to ONNX. + +.. note:: + + :func:`ndonnx.Array.values` and :func:`ndonnx.Array.null` may be used to access these components. + + .. code-block:: python + + y = ndx.array(shape=("N",), dtype=ndx.nutf8) + print(y) # Array(dtype=NUtf8) + print(y.values) # Array(dtype=Utf8) + print(y.null) # Array(dtype=Boolean) + +The suffixes ``_values`` and ``_null`` are not present when using standard :doc:`"core" data types <../datatypes/datatypes>` found in the ONNX standard. + +Inspecting metadata +------------------- + +To assist downstream packages, ndonnx includes metadata in the generated :class:`onnx.ModelProto`'s ``metadata_props`` field. +This includes a versioned JSON schema which documents the data type of each of the inputs and outputs. +This is by no means needed to run the model but can be useful for simplifying downstream inference code if you choose to use nullable data types. + +For the example model above, we extract the following schema: + +.. code-block:: json + + { + "version": 1, + "input_schema": { + "x": { + "type_name": "Utf8", + "author": "ndonnx", + "meta": null + }, + "y": { + "type_name": "NUtf8", + "author": "ndonnx", + "meta": null + } + }, + "output_schema": { + "z": { + "type_name": "NUtf8", + "author": "ndonnx", + "meta": null + } + } + } + +Since ndonnx strictly follows the versioning of the schema, downstream application code may choose to use this information to ensure incoming nullable input values are split into values and null fields and similarly combined for output values. +Inference code can be expressed at the same level of abstraction as the higher level data types provided by ndonnx. + +.. note:: + + Nullable data types are entirely opt-in in ndonnx. If you don't instantiate a nullable array you can safely expect not to produce one from a ndonnx function, unless explicitly a constructor. diff --git a/docs/intros/gettingstarted.rst b/docs/intros/gettingstarted.rst new file mode 100644 index 0000000..7e484a7 --- /dev/null +++ b/docs/intros/gettingstarted.rst @@ -0,0 +1,136 @@ +Getting Started +=============== + +This guide will go over the basic concepts of ndonnx and how to get started with the library. + +Array Programming +----------------- +ndonnx will feel familiar to users of libraries like NumPy since it implements a superset of the Array API standard. The complete Array API specification can be found `elsewhere `_. Additional parts of the API specific to ndonnx are listed :doc:`here <../api/ndonnx.additional>`. + +Creating Arrays +~~~~~~~~~~~~~~~ +ndonnx arrays can be instantiated from NumPy arrays, scalars or Python lists. +Unlike most other libraries, ndonnx arrays can also be created only from a shape and data type. +While these arrays don't contain any data, they are used to trace computation graphs to facilitate ONNX export. +This is discussed in more detail in the :ref:`onnx-export` section below. + +.. code-block:: python + + import ndonnx as ndx + + # Initializing an array with data + a = ndx.asarray([1, 2, 3]) + + # Initializing an array with shape and data type + b = ndx.array(shape=(3,), dtype=ndx.float64) + + # Shapes can be symbolic using string dimensions + c = ndx.array(shape=("N", "M"), dtype=ndx.utf8) + + +Functions +~~~~~~~~~ + +.. code-block:: python + + import ndonnx as ndx + import ndonnx.additional as nda + + a = ndx.asarray([1, 2, 3]) + + # Functions and operators as defined by the Array API + b = 1 / ndx.logaddexp(a, 2.0) + print(b) # Array([0.44651931 0.37502795 0.3021017 ], dtype=Float64) + + # Functions unique to ndonnx + c = nda.isin(a, [1, 3]) + print(c) # Array([True False True], dtype=Boolean) + + +Slicing, Indexing and Broadcasting +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +.. code-block:: python + + import ndonnx as ndx + + a = ndx.asarray([1, 2, 3]) + + # Indexing + b = a[0] + print(b) # Array(1, dtype=Int64) + + # Slicing and broadcasting + c = a[1:3] + 4 + print(c) # Array([6 7], dtype=Int64) + + +Data Types +~~~~~~~~~~ +ndonnx provides not only Array API compliant data types but also strings and nullable variants. You can find a full list :doc:`here <../datatypes/datatypes>`. + +.. code-block:: python + + import ndonnx as ndx + import numpy as np + + a = ndx.asarray(["foo", "bar", "baz"]) + print(a.dtype) # Utf8 + + # Array of nullable integers + b = ndx.asarray(np.ma.masked_array([1, 2, 3], mask=[0, 1, 0])) + print(b) # Array([1 -- 3], dtype=NInt64) + + # Mix and match nullable data types + c = b + ndx.asarray([1, 2, 3]) + print(c) # Array([2 -- 6], dtype=NInt64) + +Writing Array API compliant code +--------------------------------- +Writing code in a strictly Array API compliant fashion makes it instantly reusable across many different array backend libraries like NumPy, JAX, PyTorch and now ndonnx. + +.. code-block:: python + + import ndonnx as ndx + import numpy as np + import numpy.array_api as npx + + def mean_drop_outliers(a, low=-5, high=5): + xp = a.__array_namespace__() + return xp.mean(a[(low < a) & (a < high)]) + + np_result = mean_drop_outliers(npx.asarray([-10, 0.5, 1, 4])) + onnx_result = mean_drop_outliers(ndx.asarray([-10, 0.5, 1, 4])) + np.testing.assert_equal(np_result, onnx_result.to_numpy()) + + +.. _onnx-export: + +ONNX Export +----------- +ndonnx arrays do not *need* to hold data. They may instead be instantiated with only a *shape* and *data type* using the :class:`ndonnx.array` function. +This gives you the ability to persist the traced computation graph as an ONNX model and provide compatible input values only at inference time. + +.. code-block:: python + + import ndonnx as ndx + import onnx + + # Instantiate placeholder ndonnx array + x = ndx.array(shape=("N",), dtype=ndx.int64) + y = mean_drop_outliers(x) + + # Build and save my ONNX model to disk + model = ndx.build({"x": x}, {"y": y}) + onnx.save(model, "mean_drop_outliers.onnx") + + +We can visualize this model using `Netron `_. + +.. image:: ../_static/modelhorizontal.png + :width: 100% + :alt: ONNX model + +.. note:: + ndonnx will write versioned metadata in your ONNX model that may be used by downstream inference oriented libraries. + You can find out more in the :doc:`Inference Utilities <../inference/inference>` section. diff --git a/docs/intros/modelconversion.rst b/docs/intros/modelconversion.rst new file mode 100644 index 0000000..8c11f91 --- /dev/null +++ b/docs/intros/modelconversion.rst @@ -0,0 +1,112 @@ +Converting a scikit-learn model to ONNX +======================================= + +This tutorial will demonstrate how you can use the Array API and ndonnx to convert a machine learning model to ONNX. + +We will use scikit-learn to train a simple logistic regression model to classify species of the Iris plant using the classic `Iris Plant dataset `_ and use ndonnx to convert it to ONNX. +We'll begin with a few imports and by loading the dataset. + +.. code-block:: python + + from sklearn.datasets import load_iris + from sklearn.linear_model import LogisticRegression + from sklearn.pipeline import make_pipeline + import numpy as np + import ndonnx as ndx + from sklearn.model_selection import train_test_split + import onnx + + dataset = load_iris() + X_train, X_test, y_train, y_test = train_test_split(dataset.data, dataset.target, test_size=0.2) + +Extend predict in an Array API compatible manner +------------------------------------------------ + +We should begin by noting that only the inference logic is relevant for deployment. Since we would like to fit our classification model using scikit-learn’s ``LogisticRegression`` estimator, we are interested in exporting the logic of it's prediction method to ONNX. + +Unfortunately, ``LogisticRegression.predict`` does not yet adhere to the Array API which would have made it immediately convertible to ONNX using ndonnx. scikit-learn’s Array API support is growing over time - functionality that is already Array API compliant will be ONNX convertible without extra work thanks to ndonnx. + +Fortunately, we can easily extend LogisticRegression with our own class ``LogisticRegressionArrayAPI``. This extends the prediction logic in an Array API compliant fashion for Array API compliant inputs. + +.. code-block:: python + + class LogisticRegressionArrayAPI(LogisticRegression): + def predict(self, X): + if hasattr(X, "__array_namespace__"): + xp = X.__array_namespace__() + coef = xp.asarray(self.coef_) + intercept = xp.asarray(self.intercept_) + classes = xp.asarray(self.classes_) + index = xp.argmax(X @ coef.T + intercept, axis=1) + return xp.take(classes, xp.astype(index, xp.int32), axis=0) + else: + return super().predict(X) + +We can now fit our extended LogisticRegression model. + +.. code-block:: python + + model = LogisticRegressionArrayAPI(C=1e5) + model.fit(X_train, y_train) + +Notice how versatile our implementation is now. We can make predictions using a variety of array backends like NumPy, JAX and ndonnx. + +.. code-block:: python + + import ndonnx as ndx + + print(model.predict(X_test)) + # array([0, 0, 0, 1, 2, 2, 0, 1, 2, 1, 0, 2, 1, 1, 1, 2, 2, 0, 0, 1, 0, 1, 1, 0, 0, 2, 2, 2, 2, 2]) + + print(model.predict(ndx.asarray(X_test)).to_numpy()) + # array([0, 0, 0, 1, 2, 2, 0, 1, 2, 1, 0, 2, 1, 1, 1, 2, 2, 0, 0, 1, 0, 1, 1, 0, 0, 2, 2, 2, 2, 2]) + +Exporting to ONNX +----------------- + +Now that we have fit ``model`` and it’s inference path ``predict`` is Array API compatible, we can export it to ONNX using ndonnx. + +1. Begin by creating a placeholder array representing the input of our model. These are arrays that contain no data, only a shape (which may be symbolic) and data type. The shape is (“N”, 4) since we may have an arbitrary batch dimension “N” and always have 4 features as input. + + .. code-block:: python + + X = ndx.array(shape=("N", 4), dtype=ndx.float64) + +2. Call ``predict`` just as normal, providing X as input. The output array also does not have any data associated with it since its value depends on ``X``. + + .. code-block:: python + + y = model.predict(X) + assert y.to_numpy() is None + +3. Build the ONNX graph with :func:`ndonnx.build` and persist it to disk. The dictionary names are the names given to the inputs and outputs in the ONNX graph. + + .. code-block:: python + + onnx_model = ndx.build({"X": X}, {"y": y}) + onnx.save(onnx_model, "classify_iris.onnx") + +4. Visualize the ONNX model using Netron. It’s a fairly small model and you might be able to carefully map some of the ONNX operators to the operations that generated them. + + .. image:: ../_static/classify_iris.png + :alt: Iris Classification Model + :align: center + +Use the ONNX model in production +-------------------------------- + +Now we have our model computation and weights saved to disk as an ONNX file, we have tremendous amounts of flexibility to integrate our model into a wider system. +We can use an ONNX backend like onnxruntime to run our model. Here we use onnxruntime's python bindings to make a prediction. + +.. code-block:: python + + import onnxruntime as ort + + # Instantiate runtime session + inference_session = ort.InferenceSession("classify_iris.onnx") + + # Inference! + out, = inference_session.run(None, {"X": X_test}) + + print(out) + # array([0, 0, 0, 1, 2, 2, 0, 1, 2, 1, 0, 2, 1, 1, 1, 2, 2, 0, 0, 1, 0, 1, 1, 0, 0, 2, 2, 2, 2, 2]) diff --git a/docs/make.bat b/docs/make.bat new file mode 100644 index 0000000..922152e --- /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 + +if "%1" == "" goto help + +%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.http://sphinx-doc.org/ + exit /b 1 +) + +%SPHINXBUILD% -M %1 %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O% +goto end + +:help +%SPHINXBUILD% -M help %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O% + +:end +popd diff --git a/docs/motivation/motivation.rst b/docs/motivation/motivation.rst new file mode 100644 index 0000000..0b03c41 --- /dev/null +++ b/docs/motivation/motivation.rst @@ -0,0 +1,24 @@ +Why we created ndonnx +===================== + +ndonnx is an implementation of the `Array API `_ standard backed by `ONNX `_. + +We believe that ONNX is a flexible, performant way to take machine learning models from research to production. +However, tooling for converting models from the framework you have trained it in to ONNX has traditionally been error-prone and challenging to maintain. + +Existing tooling revolves around `ONNX converter libraries `_. +The fundamental problem with this approach that inference logic must be **duplicated**. It is first expressed in an API suitable for training using host libraries like NumPy or PyTorch and then reimplemented again in terms of ONNX operators using a library like `Spox `_. This is error-prone and hard to maintain as the host library evolves and the latest API changes need to be mirrored. + +We identified that an `Array API `_ standard compliant interface to ONNX would solve these problems by uniting these APIs while retaining complete development flexibility. This motivated us to create ndonnx. + +Practical features for expressing ONNX computation graphs +--------------------------------------------------------- +Beyond solving the code duplication problem outlined above, ndonnx has several features that make it a compelling choice for expressing ONNX computation graphs: + +#. **ndonnx is an array library**. Features like type promotion, advanced slicing, and other high-level functions you can come to expect from array libraries like NumPy and PyTorch are present in ndonnx. This leads to more concise, less buggy converters compared to using lower level libraries that only expose the `ONNX operator set `_. + +#. :doc:`Interoperability `. Parts of the ONNX standard are unsuitable for the Array abstraction such as the LSTM operator. ndonnx can be used incrementally where useful and where not, you can drop down to the ONNX operator set since ndonnx builds on `Spox `_. + +#. **Constant folding**. Arrays whose values can be determined before even building the ONNX graph are eagerly computed. This means that the exported ONNX computational graph is as lean as possible. + +#. :doc:`User-defined data types (experimental) `. ONNX specifies a narrow set of C-inspired data types. When defining Machine Learning pipelines, domain-specific types like datetimes and nullability are useful. We expose an experimental API for defining "struct" types as a user. We were inspired by NumPy's `structured arrays `_ and Arrow's `StructType `_ and use this feature extensively. diff --git a/docs/spox/spoxintegration.rst b/docs/spox/spoxintegration.rst new file mode 100644 index 0000000..2b6681e --- /dev/null +++ b/docs/spox/spoxintegration.rst @@ -0,0 +1,103 @@ +Interoperating with Spox +======================== + +`Spox `_ defines a Pythonic, direct interface to the ONNX standard and is an effective way to construct ONNX graphs. +ndonnx builds on Spox and so it is able to provide excellent interoperability with the lower level interface Spox has when needed. + +When is it useful to interoperate with Spox? +-------------------------------------------- + +1. You want to directly access an ONNX operator that describes your intent. High level operators like `LSTM `_ or `TreeEnsemble `_ are not directly accessible from ndonnx since they aren't natural array operations. +2. You want to reuse an existing ONNX model. Spox's `Inline `_ tool is a powerful utility for this. +3. You want to dispatch to certain specialized `custom operators `_ that go beyond the scope of the ONNX standard. This is also achieved via Spox's Inline tool. + +Moving between Spox and ndonnx +------------------------------ + +ndonnx to Spox +~~~~~~~~~~~~~~ + +Extract a :class:`spox.Var` from an :class:`ndonnx.Array` using the :func:`ndonnx.Array.spox_var` method. This allows you to use Spox to manipulate the ONNX graph more directly. + +.. code-block:: python + + import spox + import ndonnx as ndx + import spox.opset.ai.onnx.v20 as op + + x = ndx.array(shape=(2, 1), dtype=ndx.utf8) + + var = x.spox_var() + + # Freely use Spox + var = op.string_split(var, delimiter=",") + +While this is trivial in the case of data types with a direct correspondence in ONNX, arrays with nullable data types like :class:`ndonnx.nutf8` must first be decomposed into their constituent parts. +These can be accessed using the :func:`ndonnx.Array.values` property for the data and :func:`ndonnx.Array.null` for the boolean mask. + +.. code-block:: python + + import ndonnx as ndx + + x = ndx.array(shape=(2, 1), dtype=ndx.nutf8) + + # Disassemble the nullable array into its data and null components + data, null = x.values, x.null + + # data and null are regular ndonnx arrays + print(data, null) + # Array(dtype=Utf8) Array(dtype=Boolean) + + # Extract Spox Var + data_var = data.spox_var() + null_var = null.spox_var() + +Spox to ndonnx +~~~~~~~~~~~~~~ + +Taking the ``var`` from the previous example, we can convert it back to an :class:`ndonnx.Array` using the :func:`ndonnx.from_spox_var` function. + +.. code-block:: python + + array = ndx.from_spox_var(var) + + +Implementing a one-hot-encode function +----------------------------------------------- + +Spox allows you to directly access the standard ONNX operators. +This means that while ndonnx does not directly expose a ``one_hot_encode`` function, since the ONNX standard has a `specialized operator `_ for this, we can implement a function that one-hot-encodes ndonnx arrays by going through Spox. + +.. code-block:: python + + from typing import Iterable + import ndonnx as ndx + import spox.opset.ai.onnx.ml.v3 as ml + + def one_hot_encode(x: ndx.Array, categories: Iterable[str]) -> ndx.Array: + return ndx.from_spox_var(ml.one_hot_encoder(x.spox_var(), cats_strings=categories)) + +We can use this as normal to export and run an ONNX model. + +.. code-block:: python + + import onnxruntime as ort + import ndonnx as ndx + + x = ndx.array(shape=("N",), dtype=ndx.utf8) + y = one_hot_encode(x, ["a", "b", "c"]) + + model = ndx.build({"x": x}, {"y": y}) + onnx.save(model, "one_hot_encode.onnx") + + sess = ort.InferenceSession("one_hot_encode.onnx") + out, = sess.run(None, {"x": ["c", "b", "b", "a"]}) + print(out) + # [[0. 0. 1.] + # [0. 1. 0.] + # [0. 1. 0.] + # [1. 0. 0.]] + +.. note:: + When working with Spox directly, you step outside of ndonnx. This means ndonnx is unable to propagate values as you might typically expect. + :ref:`propagation` explains how you can ensure ndonnx can continue to eagerly propagate available values. diff --git a/ndonnx/__init__.py b/ndonnx/__init__.py new file mode 100644 index 0000000..a783fd0 --- /dev/null +++ b/ndonnx/__init__.py @@ -0,0 +1,327 @@ +# Copyright (c) QuantCo 2022-2024 +# SPDX-License-Identifier: LicenseRef-QuantCo + +import importlib.metadata +import warnings + +from ._array import Array, array, from_spox_var +from ._build import ( + build, +) +from ._data_types import ( + CastError, + CoreType, + Floating, + Integral, + Nullable, + NullableFloating, + NullableIntegral, + NullableNumerical, + Numerical, + from_numpy_dtype, + bool, + float32, + float64, + int8, + int16, + int32, + int64, + nbool, + nfloat32, + nfloat64, + nint8, + nint16, + nint32, + nint64, + nuint8, + nuint16, + nuint32, + nuint64, + nutf8, + uint8, + uint16, + uint32, + uint64, + utf8, +) +from ._funcs import ( + arange, + asarray, + empty, + empty_like, + eye, + full, + full_like, + linspace, + ones, + ones_like, + tril, + triu, + zeros, + zeros_like, + astype, + broadcast_arrays, + broadcast_to, + can_cast, + finfo, + iinfo, + result_type, + abs, + acos, + acosh, + add, + asin, + asinh, + atan, + atan2, + atanh, + bitwise_and, + bitwise_left_shift, + bitwise_invert, + bitwise_or, + bitwise_right_shift, + bitwise_xor, + ceil, + cos, + cosh, + divide, + equal, + exp, + expm1, + floor, + floor_divide, + greater, + greater_equal, + isfinite, + isinf, + isnan, + less, + less_equal, + log, + log1p, + log2, + log10, + logaddexp, + logical_and, + logical_not, + logical_or, + logical_xor, + multiply, + negative, + not_equal, + positive, + pow, + remainder, + round, + sign, + sin, + sinh, + square, + sqrt, + subtract, + tan, + tanh, + trunc, + matmul, + matrix_transpose, + concat, + expand_dims, + flip, + permute_dims, + reshape, + roll, + squeeze, + stack, + argmax, + argmin, + nonzero, + searchsorted, + where, + unique_all, + unique_counts, + unique_inverse, + unique_values, + argsort, + sort, + cumulative_sum, + max, + mean, + min, + prod, + clip, + std, + sum, + var, + all, + any, + take, +) +from ._constants import ( + e, + inf, + nan, + pi, +) + +try: + __version__ = importlib.metadata.version(__name__) +except importlib.metadata.PackageNotFoundError as err: # pragma: no cover + warnings.warn(f"Could not determine version of {__name__}\n{err!s}", stacklevel=2) + __version__ = "unknown" + + +__all__ = [ + "Array", + "array", + "from_spox_var", + "e", + "inf", + "nan", + "pi", + "arange", + "asarray", + "empty", + "empty_like", + "eye", + "full", + "full_like", + "linspace", + "ones", + "ones_like", + "tril", + "triu", + "zeros", + "zeros_like", + "astype", + "take", + "broadcast_arrays", + "broadcast_to", + "can_cast", + "finfo", + "iinfo", + "result_type", + "abs", + "acos", + "acosh", + "add", + "asin", + "asinh", + "atan", + "atan2", + "atanh", + "bitwise_and", + "bitwise_left_shift", + "bitwise_invert", + "bitwise_or", + "bitwise_right_shift", + "bitwise_xor", + "ceil", + "cos", + "cosh", + "divide", + "equal", + "exp", + "expm1", + "floor", + "floor_divide", + "greater", + "greater_equal", + "isfinite", + "isinf", + "isnan", + "less", + "less_equal", + "log", + "log1p", + "log2", + "log10", + "logaddexp", + "logical_and", + "logical_not", + "logical_or", + "logical_xor", + "multiply", + "negative", + "not_equal", + "positive", + "pow", + "remainder", + "round", + "sign", + "sin", + "sinh", + "square", + "sqrt", + "subtract", + "tan", + "tanh", + "trunc", + "matmul", + "matrix_transpose", + "concat", + "expand_dims", + "flip", + "permute_dims", + "reshape", + "roll", + "squeeze", + "stack", + "argmax", + "argmin", + "nonzero", + "searchsorted", + "where", + "unique_all", + "unique_counts", + "unique_inverse", + "unique_values", + "argsort", + "sort", + "cumulative_sum", + "max", + "mean", + "min", + "prod", + "clip", + "std", + "sum", + "var", + "all", + "any", + "build", + "bool", + "utf8", + "float32", + "float64", + "int8", + "int16", + "int32", + "int64", + "uint8", + "uint16", + "uint32", + "uint64", + "nbool", + "nutf8", + "nfloat32", + "nfloat64", + "nint8", + "nint16", + "nint32", + "nint64", + "nuint8", + "nuint16", + "nuint32", + "nuint64", + "NullableNumerical", + "Numerical", + "NullableFloating", + "Floating", + "NullableIntegral", + "Nullable", + "Integral", + "CoreType", + "CastError", + "promote_nullable", + "from_numpy_dtype", +] diff --git a/ndonnx/_array.py b/ndonnx/_array.py new file mode 100644 index 0000000..5f2031b --- /dev/null +++ b/ndonnx/_array.py @@ -0,0 +1,567 @@ +# Copyright (c) QuantCo 2023-2024 +# SPDX-License-Identifier: LicenseRef-QuantCo + +from __future__ import annotations + +import typing +from collections.abc import Callable +from typing import Union + +import numpy as np +import spox.opset.ai.onnx.v19 as op +from spox import Tensor, Var, argument +from typing_extensions import Self + +import ndonnx as ndx +import ndonnx._data_types as dtypes +from ndonnx.additional import shape + +from ._corearray import _CoreArray +from ._index import ScalarIndexType +from ._utility import get_shape + +if typing.TYPE_CHECKING: + from ndonnx._data_types.coretype import CoreType + from ndonnx._data_types.structtype import StructType + +IndexType = Union[ScalarIndexType, tuple[ScalarIndexType, ...], "Array"] + + +def array( + *, + shape: tuple[int | str | None, ...], + dtype: CoreType | StructType, +) -> Array: + """Creates a new lazy ndonnx array. This is used to define inputs to an ONNX model. + + Parameters + ---------- + shape : tuple[int | str | None, ...] + The shape of the array. str dimensions denote symbolic dimensions and must be globally consistent. None dimensions denote unknown dimensions. + dtype : CoreType | StructType + The data type of the array. + + Returns + ------- + out : Array + The new array. This represents an ONNX model input. + """ + return Array._construct(shape=shape, dtype=dtype) + + +def from_spox_var( + var: Var, +) -> Array: + """Construct an ``Array`` from a ``spox.Var``. This function is useful when + interoperating between ``ndonnx`` and ``spox``. + + Parameters + ---------- + var : spox.Var + The variable to construct the array from. + + Returns + ------- + out : Array + The constructed array. + """ + corearray = _CoreArray(var) + return _from_corearray(corearray) + + +def _from_corearray( + corearray: _CoreArray, +) -> Array: + return Array._from_fields(corearray.dtype, data=corearray) + + +class Array: + dtype: dtypes.StructType | dtypes.CoreType + _fields: dict[str, Array | _CoreArray] + + def __init__(self, *args, **kwargs) -> None: + raise TypeError("Array cannot be instantiated directly.") + + @classmethod + def _from_fields( + cls, dtype: StructType | CoreType, **fields: Array | _CoreArray + ) -> Array: + instance = cls.__new__(cls) + instance.dtype = dtype + if isinstance(dtype, dtypes.CoreType) and tuple(fields.keys()) != ("data",): + raise ValueError(f"Expected a single field 'data' for CoreType {dtype}") + if isinstance(dtype, dtypes.StructType) and set(fields.keys()) != set( + dtype._fields() + ): + raise ValueError( + f"Expected fields {dtype._fields()} for StructType {dtype}, received {fields}" + ) + instance._fields = fields + for name, field in fields.items(): + setattr(instance, name, field) + return instance + + def __getattr__(self, name: str) -> Array: + field = self._fields.get(name, None) + if isinstance(field, Array): + return field + else: + raise AttributeError(f"Field {name} not found") + + def _set(self, other: Array) -> Array: + self.dtype = other.dtype + self._fields = other._fields + for name, field in other._fields.items(): + setattr(self, name, self._fields[name]._set(field)) # type: ignore + return self + + def copy(self) -> Array: + """Clones the array, copying all the array fields. + + Returns + ------- + out : Array + The cloned array. + """ + return Array._from_fields( + self.dtype, + **{name: field.copy() for name, field in self._fields.items()}, + ) + + def to_numpy(self) -> np.ndarray | None: + """Returns the value of the Array as a NumPy array if available, otherwise + ``None``.""" + field_values = {} + for name, field in self._fields.items(): + if (eager_value := field.to_numpy()) is None: + return None + field_values[name] = eager_value + return self.dtype._assemble_output(field_values) + + def astype(self, to: CoreType | StructType) -> Array: + return ndx.astype(self, to) + + def __getitem__(self, index: IndexType) -> Array: + if isinstance(index, Array) and not ( + isinstance(index.dtype, dtypes.Integral) or index.dtype == dtypes.bool + ): + raise TypeError( + f"Index must be an integral or boolean 'Array', not `{index.dtype}`" + ) + + if isinstance(index, Array): + index = index._core() + + return self._transmute(lambda corearray: corearray[index]) + + def __setitem__( + self, index: IndexType | Self, updates: int | bool | float | Array + ) -> Array: + if ( + isinstance(index, Array) + and not isinstance(index.dtype, dtypes.Integral) + and index.dtype != dtypes.bool + ): + raise TypeError( + f"Index must be an integral or boolean 'Array', not `{index.dtype}`" + ) + + updates = ndx.asarray(updates).astype(self.dtype) + + for name, field in self._fields.items(): + if isinstance(field, _CoreArray): + field[index._core() if isinstance(index, Array) else index] = ( + updates._core() + ) + else: + field[index] = getattr(updates, name) + + return self + + def __repr__(self) -> str: + eager_value = self.to_numpy() + prefix = ( + f"Array({eager_value}, dtype={self.dtype})" + if eager_value is not None + else f"Array(dtype={self.dtype})" + ) + return f"{prefix}" + + @staticmethod + def _construct( + shape: tuple[int | str | None, ...], + dtype: CoreType | StructType, + eager_values: dict | None = None, + ) -> Array: + if isinstance(dtype, dtypes.CoreType): + var = ( + op.const(eager_values["data"], dtype=dtype.to_numpy_dtype()) + if eager_values is not None + else argument(Tensor(dtype.to_numpy_dtype(), shape)) + ) + return Array._from_fields( + dtype, + data=_CoreArray( + eager_values["data"] if eager_values is not None else var + ), + ) + else: + fields = {} + for name, field_dtype in dtype._fields().items(): + fields[name] = Array._construct( + shape, + field_dtype, + eager_values[name] if eager_values is not None else None, + ) + return Array._from_fields( + dtype, + **fields, + ) + + @property + def ndim(self) -> int: + """The rank of the array. + + This can be statically determined even for lazy arrays. + """ + return len(self._static_shape) + + @property + def shape(self) -> Array | tuple[int, ...]: + """The shape of the array. + + Returns: + Array | tuple[int, ...]: The shape of the array. + + Note that the shape of the array is a tuple of integers when the "eager value" + of the array can be determined. This is in strict compliance with the Array API standard which + presupposes tuples in compliance tests. + + When lazy arrays are involved, the shape is data-dependent (or runtime inputs dependent) and so we + cannot reliably determine the shape. In such cases, an integer ``ndx.Array`` is returned instead. + """ + # The Array API standard expects that the shape has type tuple[int | None, ...], as do compliance tests. + # However, when the array is completely lazy, a concrete shape may not be determinable. + # We therefore provide an int Array which is provisioned for in the standard. + # See https://data-apis.org/array-api/latest/API_specification/generated/array_api.array.shape.html#shape for more context. + eager_value = self.to_numpy() + if eager_value is not None: + return eager_value.shape + else: + return shape(self) + + @property + def values(self) -> Array: + """Accessor for data in a ``Array`` with nullable datatype.""" + if isinstance(self.dtype, dtypes.Nullable): + return self.__getattr__("values") + else: + raise AttributeError("Field 'values' does not exist") + + @values.setter + def values(self, value: Array) -> None: + if ( + isinstance(self.dtype, dtypes.Nullable) + and value.dtype == self.dtype._fields()["values"] + ): + self._fields["values"] = value + else: + raise ValueError("Field 'values' does not exist") + + @property + def null(self) -> Array: + """Accessor for missing null mask in a ``Array`` with nullable datatype.""" + if isinstance(self.dtype, dtypes.Nullable): + return self.__getattr__("null") + else: + raise AttributeError("Field 'null' does not exist") + + @null.setter + def null(self, value: Array) -> None: + if isinstance(self.dtype, dtypes.Nullable) and value.dtype == dtypes.bool: + self._fields["null"] = value + else: + raise ValueError("Field 'null' does not exist") + + @property + def _static_shape(self) -> tuple[int | str | None, ...]: + """Inferred shape of the array based on static ONNX shape propagation.""" + value = self.to_numpy() + if value is not None: + return value.shape + else: + current: _CoreArray | Array = self + while not isinstance(current, _CoreArray): + current = next(iter(current._fields.values())) + return get_shape(current) + + def _transmute(self, op: Callable[[_CoreArray], _CoreArray]) -> Array: + """Apply a layout transformation to the array (transmute the array). + + Data types must be preserved. This function will validate this and throw a ValueError if `op` breaks this contract. + """ + fields: dict[str, _CoreArray | Array] = {} + for name, field in self._fields.items(): + if isinstance(field, _CoreArray): + fields[name] = op(field) + else: + fields[name] = field._transmute(op) + if fields[name].dtype != field.dtype: + raise ValueError( + f"Transmute operation changed the dtype of field {name} from {field.dtype} to {fields[name].dtype}. Only layout transformations are permitted." + ) + return Array._from_fields(self.dtype, **fields) + + def _core(self) -> _CoreArray: + if isinstance(self.dtype, dtypes.CoreType): + return typing.cast(_CoreArray, self._fields["data"]) + raise ValueError("Only CoreType arrays have a core array") + + def spox_var(self) -> Var: + """Return the underlying Spox ``Var``. This is useful when interoperating + between ``Spox`` and ``ndonnx``. + + Raises + ------ + TypeError + If the data type of the ``Array`` is not a ``CoreType``, there is not a singular ``Var`` associated with it. + """ + return self._core().var + + @staticmethod + def __array_namespace__(): + return ndx + + def __float__(self) -> float: + eager_value = self.to_numpy() + if eager_value is not None and eager_value.size == 1: + return float(eager_value) + else: + raise ValueError(f"Cannot convert Array of shape {self.shape} to a float") + + def __index__(self) -> int: + eager_value = self.to_numpy() + if ( + self.ndim == 0 + and eager_value is not None + and isinstance(eager_value.item(), int) + ): + return int(eager_value) + else: + raise ValueError(f"Cannot convert Array {self} to an index (int)") + + def __int__(self) -> int: + eager_value = self.to_numpy() + if eager_value is not None and eager_value.size == 1: + return int(eager_value) + else: + raise ValueError(f"Cannot convert Array of shape {self.shape} to an int") + + def __bool__(self) -> bool: + eager_value = self.to_numpy() + if eager_value is not None and eager_value.size == 1: + return bool(self.to_numpy()) + else: + raise ValueError(f"Cannot convert Array of shape {self.shape} to a bool") + + def __len__(self) -> int: + if isinstance(eager_value := self.shape, tuple): + return eager_value[0] + else: + raise ValueError(f"Cannot convert Array of shape {self.shape} to a length") + + def __pos__(self): + return ndx.positive(self) + + def __neg__(self): + return ndx.negative(self) + + def __abs__(self): + return ndx.abs(self) + + def __add__(self, other): + return ndx.add(self, other) + + def __radd__(self, other): + return ndx.add(other, self) + + def __iadd__(self, other): + return self._set(ndx.add(self, other)) + + def __sub__(self, other): + return ndx.subtract(self, other) + + def __rsub__(self, other): + return ndx.subtract(other, self) + + def __isub__(self, other): + return self._set(ndx.subtract(self, other)) + + def __mul__(self, other): + return ndx.multiply(self, other) + + def __rmul__(self, other): + return ndx.multiply(other, self) + + def __imul__(self, other): + return self._set(ndx.multiply(self, other)) + + def __truediv__(self, other): + return ndx.divide(self, other) + + def __rtruediv__(self, other): + return ndx.divide(other, self) + + def __floordiv__(self, other): + return ndx.floor_divide(self, other) + + def __rfloordiv__(self, other): + return ndx.floor_divide(other, self) + + def __mod__(self, other): + return ndx.remainder(self, other) + + def __rmod__(self, other): + return ndx.remainder(other, self) + + def __pow__(self, other): + return ndx.pow(self, other) + + def __rpow__(self, other): + return ndx.pow(other, self) + + def __matmul__(self, other): + return ndx.matmul(self, other) + + def __lt__(self, other): + return ndx.less(self, other) + + def __le__(self, other): + return ndx.less_equal(self, other) + + def __gt__(self, other): + return ndx.greater(self, other) + + def __ge__(self, other): + return ndx.greater_equal(self, other) + + def __invert__(self): + return ndx.bitwise_invert(self) + + def __and__(self, other): + return ndx.bitwise_and(self, other) + + def __or__(self, other): + return ndx.bitwise_or(self, other) + + def __xor__(self, other): + return ndx.bitwise_xor(self, other) + + def __lshift__(self, other): + return ndx.bitwise_left_shift(self, other) + + def __rshift__(self, other): + return ndx.bitwise_right_shift(self, other) + + def __eq__(self, other): + if isinstance(other, type(Ellipsis)): + # FIXME: What is going on here? Deserves a comment, IMHO + return ndx.asarray(False) + return ndx.equal(self, other) + + def __ne__(self, other): + return ndx.not_equal(self, other) + + @property + def mT(self) -> ndx.Array: # noqa: N802 + """Transpose of a matrix (or a stack of matrices). + + If an array instance has fewer than two dimensions, an error should be raised. + + Returns + ------- + out: Array + array whose last two dimensions (axes) are permuted in reverse order relative to original array (i.e., for an array instance having shape ``(..., M, N)``, the returned array must have shape ``(..., N, M)``). The returned array must have the same data type as the original array. + """ + return ndx.matrix_transpose(self) + + @property + def size(self) -> ndx.Array: + """Number of elements in the array. + + Returns + ------- + out: Array + Scalar ``Array`` instance whose value is the number of elements in the original array. + """ + return ndx.prod(self.shape) + + @property + def T(self) -> ndx.Array: # noqa: N802 + """Transpose of the array. + + The array instance must be two-dimensional. + + Raises + ------ + TypeError + If the array instance is not two-dimensional. + + Returns + ------- + out: Array + Two-dimensional array whose first and last dimensions (axes) are permuted in reverse order relative to original array. The returned array must have the same data type as the original array. + """ + if self.ndim != 2: + raise TypeError("Cannot transpose Array of rank != 2") + + return ndx.matrix_transpose(self) + + def len(self): + """Returns the length of the array as an array. + + The array instance must be one-dimensional. + + Raises + ------ + TypeError + If the array instance is not one-dimensional. + + Returns + ------- + out: Array + Singleton array whose value is the length of the original array. + """ + if self.ndim != 1: + raise TypeError("Cannot call len on Array of rank != 1") + return ndx.asarray(self.shape[0]) + + def sum(self, axis: int | None = 0, keepdims: bool | None = False) -> ndx.Array: + """See :py:func:`ndonnx.sum` for documentation.""" + return ndx.sum(self, axis=axis, keepdims=False) + + def prod(self, axis: int | None = 0, keepdims: bool | None = False) -> ndx.Array: + """See :py:func:`ndonnx.prod` for documentation.""" + return ndx.prod(self, axis=axis, keepdims=False) + + def max(self, axis: int | None = 0, keepdims: bool | None = False) -> ndx.Array: + """See :py:func:`ndonnx.max` for documentation.""" + return ndx.max(self, axis=axis, keepdims=False) + + def min(self, axis: int | None = 0, keepdims: bool | None = False) -> ndx.Array: + """See :py:func:`ndonnx.min` for documentation.""" + return ndx.min(self, axis=axis, keepdims=False) + + def all(self, axis: int | None = 0, keepdims: bool | None = False) -> ndx.Array: + """See :py:func:`ndonnx.all` for documentation.""" + return ndx.all(self, axis=axis, keepdims=False) + + def any(self, axis: int | None = 0, keepdims: bool | None = False) -> ndx.Array: + """See :py:func:`ndonnx.any` for documentation.""" + return ndx.any(self, axis=axis, keepdims=False) + + +__all__ = [ + "Array", + "array", +] diff --git a/ndonnx/_build.py b/ndonnx/_build.py new file mode 100644 index 0000000..fa2b661 --- /dev/null +++ b/ndonnx/_build.py @@ -0,0 +1,232 @@ +# Copyright (c) QuantCo 2023-2024 +# SPDX-License-Identifier: LicenseRef-QuantCo + +from __future__ import annotations + +import dataclasses +import functools +import json + +import numpy as np +import onnx +import spox + +import ndonnx as ndx +import ndonnx._data_types as dtypes + +from ._array import Array +from ._corearray import _CoreArray + + +def build( + inputs: dict[str, Array], + outputs: dict[str, Array], +) -> onnx.ModelProto: + """Build utility to produce an ONNX model. Requires a dictionary of named input and + output arrays. + + Parameters + ---------- + inputs: dict[str, Array] + Inputs of the model + outputs: dict[str, Array] + Outputs of the model + + Returns + ------- + out: onnx.ModelProto + ONNX model + """ + + def collect_vars(name: str, arr: _CoreArray | Array): + if isinstance(arr, _CoreArray): + return {name: arr.var} + elif isinstance(arr.dtype, ndx.CoreType): + return {name: arr.spox_var()} + else: + constituent_vars: dict[str, spox.Var] = {} + for field_name, field in arr._fields.items(): + constituent_vars |= collect_vars(f"{name}_{field_name}", field) + return constituent_vars + + input_vars: dict[str, spox.Var] = functools.reduce( + lambda acc, arr: acc | collect_vars(*arr), inputs.items(), {} + ) + output_vars: dict[str, spox.Var] = functools.reduce( + lambda acc, arr: acc | collect_vars(*arr), outputs.items(), {} + ) + model_proto = spox.build(input_vars, output_vars) + input_schema = { + name: dataclasses.asdict(input.dtype._schema()) + for name, input in inputs.items() + } + output_schema = { + name: dataclasses.asdict(output.dtype._schema()) + for name, output in outputs.items() + } + model_proto.metadata_props.append( + onnx.StringStringEntryProto( + key="ndonnx_schema", + value=json.dumps( + { + "version": 1, + "input_schema": input_schema, + "output_schema": output_schema, + } + ), + ) + ) + return model_proto + + +def _get_dtype(dtype: str, version: int) -> dtypes.StructType | dtypes.CoreType: + """Get the ndonnx data type given a string representation and version number, as + found in the produced `onnx.ModelProto`.""" + if version == 1: + return _v1_dtypes[dtype] + else: + raise ValueError(f"Unknown schema version {version}") + + +def _extract_output_names( + output_dtypes: dict[str, dtypes.StructType | dtypes.CoreType], +) -> dict[str, ndx.CoreType]: + """Given a dictionary mapping output names to their data types, extract the + underlying fully qualified names and their CoreTypes. + + Parameters + ---------- + output_dtypes: dict[str, ndonnx.StructType | ndonnx.CoreType] + Dictionary mapping output names to their data types + + Returns + ------- + out: dict[str, ndonnx.CoreType] + Dictionary mapping fully qualified output names to their CoreTypes + """ + + def extract_output_name(name, type): + if isinstance(type, ndx.CoreType): + return {name: type} + else: + names: dict[str, ndx.CoreType] = {} + for field_name, field_type in type._fields().items(): + names |= extract_output_name(f"{name}_{field_name}", field_type) + return names + + return functools.reduce( + lambda acc, arr: acc | extract_output_name(*arr), output_dtypes.items(), {} + ) + + +def _flatten(input_dict, dtype: dtypes.CoreType | dtypes.StructType, field_name: str): + if isinstance(dtype, ndx.CoreType): + return {field_name: input_dict["data"]} + else: + flattened: dict[str, np.ndarray] = {} + for field, field_type in dtype._fields().items(): + flattened |= _flatten( + input_dict[field], field_type, f"{field_name}_{field}" + ) + return flattened + + +def _deconstruct_inputs( + inputs: dict[str, np.ndarray], + input_schema: dict[str, dtypes.CoreType | dtypes.StructType], +) -> dict[str, np.ndarray]: + """Given a dictionary of named inputs and a schema mapping these input names to + their ndonnx data types, return the disassembled inputs as valid inputs for + inference. + + Parameters + ---------- + inputs: dict[str, np.ndarray] + Dictionary of named inputs + input_schema: dict[str, ndonnx.CoreType | ndonnx.StructType] + Schema mapping input names to their ndonnx data types + + Returns + ------- + out: dict[str, np.ndarray] + Disassembled inputs with fully qualified names of core constituent fields of the inputs, based on the data type of the input in `input_schema`, based on the data type's `parse_input` method. + """ + + def parse_input(name, type): + structured_fields = type._parse_input(inputs[name]) + flattened_fields = _flatten(structured_fields, input_schema[name], name) + return flattened_fields + + return functools.reduce( + lambda acc, arr: acc | parse_input(*arr), input_schema.items(), {} + ) + + +def _assemble_outputs( + output_data: dict[str, np.ndarray], + output_schema: dict[str, dtypes.CoreType | dtypes.StructType], +) -> dict[str, np.ndarray]: + """Given a dictionary of named outputs and a schema mapping these output names to + their ndonnx data types, return the outputs assembled into values that reflect their + data type. + + Parameters + ---------- + output_data: dict[str, np.ndarray] + Dictionary of named outputs from inference + output_schema: dict[str, ndonnx.CoreType | ndonnx.StructType] + Schema mapping output names to their ndonnx data types + + Returns + ------- + out: dict[str, np.ndarray] + Assembled outputs with data type that is meaningful based on the `output_schema` entry, based on the data type's `assemble_output` method. + """ + + def _assemble_output(name, type): + # We want to recurse down the type here and recursively reassemble the output + def helper(cur_type, prefix): + if isinstance(cur_type, ndx.CoreType): + return cur_type._assemble_output({"data": output_data[prefix]}) + elif isinstance(cur_type, dtypes.StructType): + inputs = { + field: helper(field_type, f"{prefix}_{field}") + for field, field_type in cur_type._fields().items() + } + return cur_type._assemble_output(inputs) + else: + raise TypeError + + return {name: helper(type, name)} + + return functools.reduce( + lambda acc, arr: acc | _assemble_output(*arr), output_schema.items(), {} + ) + + +_v1_dtypes: dict[str, dtypes.CoreType | dtypes.StructType] = { + "UInt8": dtypes.uint8, + "UInt16": dtypes.uint16, + "UInt32": dtypes.uint32, + "UInt64": dtypes.uint64, + "Int8": dtypes.int8, + "Int16": dtypes.int16, + "Int32": dtypes.int32, + "Int64": dtypes.int64, + "Float32": dtypes.float32, + "Float64": dtypes.float64, + "Utf8": dtypes.utf8, + "Boolean": dtypes.bool, + "NUInt8": dtypes.nuint8, + "NUInt16": dtypes.nuint16, + "NUInt32": dtypes.nuint32, + "NUInt64": dtypes.nuint64, + "NInt8": dtypes.nint8, + "NInt16": dtypes.nint16, + "NInt32": dtypes.nint32, + "NInt64": dtypes.nint64, + "NFloat32": dtypes.nfloat32, + "NFloat64": dtypes.nfloat64, + "NUtf8": dtypes.nutf8, + "NBoolean": dtypes.nbool, +} diff --git a/ndonnx/_constants.py b/ndonnx/_constants.py new file mode 100644 index 0000000..c16ccca --- /dev/null +++ b/ndonnx/_constants.py @@ -0,0 +1,20 @@ +# Copyright (c) QuantCo 2024-2024 +# SPDX-License-Identifier: LicenseRef-QuantCo + +import numpy as np + +from ndonnx._funcs import asarray + +e = asarray(np.e) +inf = asarray(np.inf) +nan = asarray(np.nan) +pi = asarray(np.pi) +newaxis = None + +__all__ = [ + "e", + "inf", + "nan", + "pi", + "newaxis", +] diff --git a/ndonnx/_core/__init__.py b/ndonnx/_core/__init__.py new file mode 100644 index 0000000..159c41e --- /dev/null +++ b/ndonnx/_core/__init__.py @@ -0,0 +1,7 @@ +# Copyright (c) QuantCo 2024-2024 +# SPDX-License-Identifier: LicenseRef-QuantCo + +from ._impl import CoreOperationsImpl +from ._interface import OperationsBlock + +__all__ = ["CoreOperationsImpl", "OperationsBlock"] diff --git a/ndonnx/_core/_impl.py b/ndonnx/_core/_impl.py new file mode 100644 index 0000000..c77ac96 --- /dev/null +++ b/ndonnx/_core/_impl.py @@ -0,0 +1,1008 @@ +# Copyright (c) QuantCo 2024-2024 +# SPDX-License-Identifier: LicenseRef-QuantCo +from __future__ import annotations + +import functools +import warnings +from collections import namedtuple +from collections.abc import Callable, Iterable +from typing import TYPE_CHECKING, Literal + +import numpy as np + +import ndonnx as ndx +import ndonnx._data_types as dtypes +import ndonnx._opset_extensions as opx +from ndonnx._utility import promote +from ndonnx.additional import make_nullable + +from ._interface import OperationsBlock + +if TYPE_CHECKING: + from ndonnx._array import Array + from ndonnx._corearray import _CoreArray + + +class CoreOperationsImpl(OperationsBlock): + # elementwise.py + + def abs(self, x): + return _unary_op(x, opx.abs) + + def acos(self, x): + return _unary_op(x, opx.acos, dtypes.float32) + + def acosh(self, x): + return _unary_op(x, opx.acosh, dtypes.float32) + + def add(self, x, y) -> ndx.Array: + x, y = promote(x, y) + out_dtype = x.dtype + if out_dtype in (ndx.nutf8, ndx.utf8): + return _binary_op(x, y, opx.string_concat) + return _via_i64_f64(opx.add, [x, y]) + + def asin(self, x): + return _unary_op(x, opx.asin, dtypes.float32) + + def asinh(self, x): + return _unary_op(x, opx.asinh, dtypes.float32) + + def atan(self, x): + return _unary_op(x, opx.atan, dtypes.float32) + + def atan2(self, y, x): + return self.atan(self.divide(y, x)) + + def atanh(self, x): + return _unary_op(x, opx.atanh, dtypes.float32) + + def bitwise_and(self, x, y): + # FIXME: Bitwise operations like this one should raise a type + # error when encountering booleans! + x, y = promote(x, y) + if x.dtype in (dtypes.bool, dtypes.nbool): + return self.logical_and(x, y) + + return _binary_op(x, y, opx.bitwise_and) + + # TODO: ONNX standard -> not cyclic + def bitwise_left_shift(self, x, y): + return _binary_op( + x, y, lambda a, b: opx.bit_shift(a, b, direction="LEFT"), dtypes.uint64 + ) + + def bitwise_invert(self, x): + x = ndx.asarray(x) + if x.dtype in (dtypes.bool, dtypes.nbool): + return self.logical_not(x) + return _unary_op(x, opx.bitwise_not) + + def bitwise_or(self, x, y): + x, y = promote(x, y) + if x.dtype in (dtypes.bool, dtypes.nbool): + return self.logical_or(x, y) + return _binary_op(x, y, opx.bitwise_or) + + # TODO: ONNX standard -> not cyclic + def bitwise_right_shift(self, x, y): + x, y = promote(x, y) + return _binary_op( + x, + y, + lambda x, y: opx.bit_shift(x, y, direction="RIGHT"), + dtypes.uint64, + ) + + def bitwise_xor(self, x, y): + if x.dtype in (dtypes.bool, dtypes.nbool): + return self.logical_xor(x, y) + return _binary_op(x, y, opx.bitwise_xor) + + def ceil(self, x): + if isinstance(x.dtype, (dtypes.Floating, dtypes.NullableFloating)): + return _unary_op(x, opx.ceil, dtypes.float64) + return ndx.asarray(x, copy=False) + + def cos(self, x): + return _unary_op(x, opx.cos, dtypes.float32) + + def cosh(self, x): + return _unary_op(x, opx.cosh, dtypes.float32) + + def divide(self, x, y): + return _variadic_op([x, y], opx.div, via_dtype=dtypes.float64) + + def equal(self, x, y) -> Array: + x, y = promote(x, y) + if isinstance(x.dtype, (dtypes.Integral, dtypes.NullableIntegral)): + return _variadic_op([x, y], opx.equal, dtypes.int64, cast_return=False) + else: + return _binary_op(x, y, opx.equal) + + def exp(self, x): + return _unary_op(x, opx.exp, dtypes.float32) + + def expm1(self, x): + return self.subtract(self.exp(x), 1) + + def floor(self, x): + x = ndx.asarray(x) + if isinstance(x.dtype, (dtypes.Floating, dtypes.NullableFloating)): + return _unary_op(x, opx.floor, dtypes.float64) + return x + + def floor_divide(self, x, y): + return self.floor(self.divide(x, y)) + + def greater(self, x, y): + return _via_i64_f64(opx.greater, [x, y], cast_return=False) + + def greater_equal(self, x, y): + return _via_i64_f64(opx.greater_or_equal, [x, y], cast_return=False) + + def isfinite(self, x): + return self.logical_not(self.isinf(x)) + + def isinf(self, x): + x = ndx.asarray(x) + if isinstance(x.dtype, (dtypes.Floating, dtypes.NullableFloating)): + return _unary_op(x, opx.isinf) + return ndx.full(x.shape, fill_value=False) + + def isnan(self, x): + if not isinstance(x.dtype, (dtypes.Floating, dtypes.NullableFloating)): + return ndx.full_like(x, False, dtype=dtypes.bool) + else: + return _unary_op(x, opx.isnan) + + def less(self, x, y): + return _via_i64_f64(opx.less, [x, y], cast_return=False) + + def less_equal(self, x, y): + x, y = ndx.asarray(x), ndx.asarray(y) + if ndx.result_type(x, y) in (dtypes.utf8, dtypes.nutf8): + return self.less(x, y) | self.equal(x, y) + else: + return _via_i64_f64(opx.less_or_equal, [x, y], cast_return=False) + + def log(self, x): + return _unary_op(x, opx.log, dtypes.float64) + + def log1p(self, x): + return self.add(self.log(x), ndx.asarray(1, x.dtype)) + + def log2(self, x): + return self.log(x) / np.log(2) + + def log10(self, x): + return self.log(x) / np.log(10) + + def logaddexp(self, x, y): + return self.log(self.exp(x) + self.exp(y)) + + def logical_and(self, x, y): + x, y = promote(x, y) + if x.dtype not in (dtypes.bool, dtypes.nbool): + raise TypeError(f"Unsupported dtype for logical_and: {x.dtype}") + + # If one of the operands is True and the broadcasted shape can be guaranteed to be the other array's shape, + # we can return this other array directly. + if ( + x.to_numpy() is not None + and x.to_numpy().size == 1 + and x.ndim <= y.ndim + and x.to_numpy().item() + ): + return y.copy() + elif ( + y.to_numpy() is not None + and y.to_numpy().size == 1 + and y.ndim <= x.ndim + and y.to_numpy().item() + ): + return x.copy() + return _binary_op(x, y, opx.and_) + + def logical_not(self, x): + return _unary_op(x, opx.not_) + + def logical_or(self, x, y): + x, y = ndx.asarray(x), ndx.asarray(y) + dtype = ndx.result_type(x.dtype, y.dtype) + if dtype not in (dtypes.bool, dtypes.nbool): + raise TypeError(f"Unsupported dtype for logical_or: {dtype}") + # If one of the operands is False and the broadcasted shape can be guaranteed to be the other array's shape, + # we can return this other array directly. + if ( + x.to_numpy() is not None + and x.to_numpy().size == 1 + and x.ndim <= y.ndim + and not x.to_numpy().item() + ): + return y.copy() + elif ( + y.to_numpy() is not None + and y.to_numpy().size == 1 + and y.ndim <= x.ndim + and not y.to_numpy().item() + ): + return x.copy() + return _binary_op(x, y, opx.or_) + + def logical_xor(self, x, y): + return _binary_op(x, y, opx.xor) + + def multiply(self, x, y): + x, y = promote(x, y) + dtype = ndx.result_type(x, y) + via_dtype: dtypes.CoreType + if isinstance(dtype, (dtypes.Integral, dtypes.NullableIntegral)) or dtype in ( + dtypes.nbool, + dtypes.bool, + ): + via_dtype = dtypes.int64 + elif isinstance(dtype, (dtypes.Floating, dtypes.NullableFloating)): + via_dtype = dtypes.float64 + else: + raise TypeError(f"Unsupported dtype for multiply: {dtype}") + return _binary_op(x, y, opx.mul, via_dtype) + + def negative(self, x): + if isinstance( + x.dtype, (dtypes.Unsigned, dtypes.NullableUnsigned) + ) or x.dtype in (ndx.int16, ndx.nint16): + return _unary_op(x, opx.neg, dtypes.int64) + return _unary_op(x, opx.neg) + + def positive(self, x): + if not isinstance(x.dtype, (dtypes.Numerical, dtypes.NullableNumerical)): + raise TypeError(f"Unsupported dtype for positive: {x.dtype}") + return x.copy() + + def pow(self, x, y): + x, y = ndx.asarray(x), ndx.asarray(y) + dtype = ndx.result_type(x, y) + if isinstance(dtype, (dtypes.Unsigned, dtypes.NullableUnsigned)): + return _binary_op(x, y, opx.pow, dtypes.int64) + else: + return _binary_op(x, y, opx.pow) + + def remainder(self, x, y): + return _binary_op(x, y, lambda x, y: opx.mod(x, y, fmod=1)) + + def round(self, x): + x = ndx.asarray(x) + if isinstance(x.dtype, (dtypes.Floating, dtypes.NullableFloating)): + return _unary_op(x, opx.round) + else: + return x + + def sign(self, x): + (x_values,), (x_null,) = _split_nulls_and_values(x) + out_values = self.where(x_values > 0, 1, self.where(x_values < 0, -1, 0)) + if x_null is None: + return out_values + else: + return make_nullable(out_values, x_null) + + def sin(self, x): + return _unary_op(x, opx.sin, dtypes.float64) + + def sinh(self, x): + return _unary_op(x, opx.sinh, dtypes.float64) + + def square(self, x): + return self.multiply(x, x) + + def sqrt(self, x): + return _unary_op(x, opx.sqrt, dtypes.float32) + + def subtract(self, x, y): + x, y = promote(x, y) + if isinstance( + x.dtype, (dtypes.Unsigned, dtypes.NullableUnsigned) + ) or x.dtype in (dtypes.int16, dtypes.int8, dtypes.nint16, dtypes.nint8): + via_dtype = dtypes.int64 + else: + via_dtype = None + return _binary_op(x, y, opx.sub, via_dtype=via_dtype) + + def tan(self, x): + return _unary_op(x, opx.tan, dtypes.float32) + + def tanh(self, x): + return _unary_op(x, opx.tanh, dtypes.float32) + + def trunc(self, x): + x = ndx.asarray(x) + if isinstance(x.dtype, (dtypes.Floating, dtypes.NullableFloating)): + return self.where(x < 0, self.ceil(x), self.floor(x)) + return x + + # linalg.py + + def matmul(self, x, y): + return _via_i64_f64(opx.matmul, [x, y]) + + # searching.py + + def argmax(self, x, axis=None, keepdims=False): + if axis is None: + reshaped_x = ndx.reshape(x, [-1])._core() + if keepdims: + return _from_corearray( + opx.reshape( + opx.arg_max(reshaped_x, axis=0, keepdims=False), + opx.const([1 for x in range(x.ndim)], dtype=dtypes.int64), + ) + ) + else: + return _from_corearray( + opx.reshape( + opx.arg_max(reshaped_x, axis=0, keepdims=False), + opx.const([], dtype=dtypes.int64), + ) + ) + return _via_i64_f64(lambda x: opx.arg_max(x, axis=axis, keepdims=keepdims), [x]) + + def argmin(self, x, axis=None, keepdims=False): + if axis is None: + reshaped_x = ndx.reshape(x, [-1])._core() + if keepdims: + return _from_corearray( + opx.reshape( + opx.arg_min(reshaped_x, axis=0, keepdims=False), + opx.const([1 for x in range(x.ndim)], dtype=dtypes.int64), + ) + ) + else: + return _from_corearray( + opx.reshape( + opx.arg_min(reshaped_x, axis=0, keepdims=False), + opx.const([], dtype=dtypes.int64), + ) + ) + return _via_i64_f64(lambda x: opx.arg_min(x, axis=axis, keepdims=keepdims), [x]) + + def nonzero(self, x): + if x.ndim == 0: + return [ndx.arange(0, x != 0, dtype=dtypes.int64)] + + ret_full_flattened = ndx.reshape( + _from_corearray(opx.ndindex(opx.shape(x)))[x != 0], + [-1], + ) + + return [ + ndx.reshape( + _from_corearray( + opx.gather_elements( + ret_full_flattened._core(), + ndx.arange( + i, + ret_full_flattened.shape[0], + x.ndim, + dtype=dtypes.int64, + )._core(), + ) + ), + [-1], + ) + for i in range(x.ndim) + ] + + def searchsorted( + self, + x1, + x2, + *, + side: Literal["left", "right"] = "left", + sorter: ndx.Array | None = None, + ): + if x1.ndim != 1: + raise TypeError("x1 must be a 1-dimensional array") + if sorter is not None: + if not isinstance(sorter.dtype, ndx.Integral): + raise TypeError("sorter must be an array of integers") + x1 = ndx.take(x1, sorter) + + if side not in ("left", "right"): + raise ValueError("side must be 'left' or 'right'") + + nan_mask = ndx.isnan(x2) + combined = ndx.concat([x1, x2]) + positions = ndx.unique_all(combined).inverse_indices + 1 + + unique_x1 = ndx.unique_all(x1) + counts = unique_x1.counts[unique_x1.inverse_indices] + + indices_x1, indices_x2 = map( + _from_corearray, opx.get_indices(x1._core(), x2._core(), positions._core()) + ) + + how_many = ndx.zeros(ndx.asarray(combined.shape) + 1, dtype=dtypes.int64) + how_many[ + ndx.where(indices_x1 + 1 <= combined.shape[0], indices_x1 + 1, indices_x1) + ] = counts + how_many = ndx.cumulative_sum(how_many, include_initial=True) + + ret = ndx.zeros(x2.shape, dtype=dtypes.int64) + + if side == "left": + ret = how_many[indices_x2] + ret[nan_mask] = ndx.asarray(x1.shape, dtype=dtypes.int64) - 1 + else: + ret = how_many[indices_x2 + 1] + ret[nan_mask] = ndx.asarray(x1.shape, dtype=dtypes.int64) + + return ret + + def where(self, condition, x, y): + condition, x, y = ndx.asarray(condition), ndx.asarray(x), ndx.asarray(y) + if x.dtype != y.dtype: + x, y = promote(x, y) + if isinstance(condition.dtype, dtypes.Nullable) and not isinstance( + x.dtype, (dtypes.Nullable, dtypes.CoreType) + ): + raise TypeError("where condition is nullable, but both outputs are not") + if condition.to_numpy() is not None and condition.dtype == dtypes.bool: + if ( + condition.to_numpy().size == 1 + and condition.to_numpy().ndim <= x.ndim + and condition.to_numpy().item() + ): + return x.copy() + elif ( + condition.to_numpy().size == 1 + and condition.to_numpy().ndim <= y.ndim + and not condition.to_numpy().item() + ): + return y.copy() + if x.dtype == y.dtype and x.to_numpy() is not None and y.to_numpy() is not None: + if isinstance(x.to_numpy(), np.ma.MaskedArray): + if np.ma.allequal(x.to_numpy(), y.to_numpy(), fill_value=False): + return ndx.asarray( + np.broadcast_arrays(x.to_numpy(), y.to_numpy())[0] + ) + else: + cond = np.equal(x.to_numpy(), y.to_numpy()) + if isinstance(x.dtype, ndx.Floating): + cond |= np.isnan(x.to_numpy()) & np.isnan(y.to_numpy()) + if cond.all(): + return ndx.asarray( + np.broadcast_arrays(x.to_numpy(), y.to_numpy())[0] + ) + condition_values = ( + condition.values if condition.dtype == ndx.nbool else condition + ) + + # generic layout operation, work over both arrays with same data type to apply the condition + def where_dtype_agnostic(a: ndx.Array, b: ndx.Array) -> ndx.Array: + if a.dtype != b.dtype: + raise ValueError("The dtype of both arrays must be the same") + if a.dtype == dtypes.bool: + return ndx.logical_xor( + ndx.logical_and(condition_values, a), + ndx.logical_and(~condition_values, b), + ) + elif a.dtype in (dtypes.int8, dtypes.int16): + return _from_corearray( + opx.where( + condition_values._core(), + a.astype(dtypes.int32)._core(), + b.astype(dtypes.int32)._core(), + ) + ) + elif isinstance(a.dtype, dtypes.CoreType): + return _from_corearray( + opx.where( + condition_values._core(), + a._core(), + b._core(), + ) + ) + else: + fields = {} + for name in a.dtype._fields(): + fields[name] = where_dtype_agnostic( + getattr(a, name), getattr(b, name) + ) + return ndx.Array._from_fields(a.dtype, **fields) + + output = where_dtype_agnostic(x, y) + if condition.dtype == ndx.nbool: + # propagate null if present + if not isinstance(output.dtype, dtypes.Nullable): + output = make_nullable(output, condition.null) + else: + output.null = output.null | condition.null + return output + + # set.py + def unique_all(self, x): + new_dtype = x.dtype + if isinstance(x.dtype, dtypes.Integral) or x.dtype in ( + dtypes.bool, + dtypes.nbool, + ): + new_dtype = dtypes.int64 + elif isinstance(x.dtype, dtypes.Floating): + warnings.warn( + "Float unique_all is incomplete as nans are not handled correctly in onnxruntime" + ) + new_dtype = dtypes.float64 + + flattened = ndx.reshape(x, [-1]) + transformed = flattened.astype(new_dtype)._core() + + ret_opd = opx.unique(transformed, sorted=True) + + # FIXME: I think we can simply use arange/ones+cumsum or something for the indices + # maybe: indices = opx.cumsum(ones_like(flattened, dtype=dtypes.i64), axis=ndx.asarray(0)) + indices = opx.squeeze( + opx.ndindex(opx.shape(flattened._core())), + opx.const([1], dtype=dtypes.int64), + ) + + ret = namedtuple("ret", ["values", "indices", "inverse_indices", "counts"]) + + values = _from_corearray(ret_opd[0]) + indices = _from_corearray(indices[ret_opd[1]]) + inverse_indices = ndx.reshape(_from_corearray(ret_opd[2]), x.shape) + counts = _from_corearray(ret_opd[3]) + + return ret( + values=values, + indices=indices, + inverse_indices=inverse_indices, + counts=counts, + ) + + def unique_counts(self, x): + ret = namedtuple("ret", ["values", "counts"]) + ret_all = self.unique_all(x) + return ret(values=ret_all.values, counts=ret_all.counts) + + def unique_inverse(self, x): + ret = namedtuple("ret", ["values", "inverse_indices"]) + ret_all = self.unique_all(x) + return ret(values=ret_all.values, inverse_indices=ret_all.inverse_indices) + + def unique_values(self, x): + return self.unique_all(x).values + + # sorting.py + + def argsort(self, x, *, axis=-1, descending=False, stable=True): + if axis < 0: + axis += x.ndim + _len = opx.shape(x._core(), start=axis, end=axis + 1) + return _via_i64_f64( + lambda x: opx.top_k(x, _len, largest=descending, axis=axis)[1], [x] + ) + + def sort(self, x, *, axis=-1, descending=False, stable=True): + if axis < 0: + axis += x.ndim + _len = opx.shape(x._core(), start=axis, end=axis + 1) + return _via_i64_f64( + lambda x: opx.top_k(x, _len, largest=descending, axis=axis)[0], [x] + ) + + # statistical.py + def cumulative_sum( + self, + x, + *, + axis: int | None = None, + dtype: dtypes.CoreType | dtypes.StructType | None = None, + include_initial: bool = False, + ): + if not isinstance(x.dtype, ndx.CoreType): + return NotImplemented + if axis is None: + if x.ndim <= 1: + axis = 0 + else: + raise ValueError("axis must be specified for multi-dimensional arrays") + out = _from_corearray( + opx.cumsum( + x._core(), axis=opx.const(axis), exclusive=int(not include_initial) + ) + ) + if dtype is not None: + out = out.astype(dtype) + return out + + def max(self, x, *, axis=None, keepdims: bool = False): + if axis is None: + axes = [] + elif not isinstance(axis, Iterable): + axes = [axis] + else: + axes = axis # type: ignore + + if isinstance(x.dtype, dtypes.NullableFloating): + fill_value = dtypes.get_finfo(x.dtype.values).min + x = self.where(x.null, fill_value, x.values) + elif isinstance(x.dtype, dtypes.NullableIntegral): + fill_value = dtypes.get_iinfo(x.dtype.values).min + x = self.where(x.null, fill_value, x.values) + if not isinstance(x.dtype, dtypes.Numerical): + raise TypeError("min is not supported for non-numeric types") + + return _via_i64_f64( + lambda x: opx.reduce_max( + x, + opx.const(axes, dtype=dtypes.int64), + keepdims=keepdims, + noop_with_empty_axes=axis is not None, + ), + [x], + ) + + def mean(self, x, *, axis=None, keepdims: bool = False): + return self.sum(x, axis=axis, keepdims=keepdims) / self.sum( + ndx.full_like(x, 1), axis=axis, keepdims=keepdims + ) + + def min(self, x, *, axis=None, keepdims: bool = False): + if axis is None: + axes = [] + elif not isinstance(axis, Iterable): + axes = [axis] + else: + axes = axis # type: ignore + + if isinstance(x.dtype, dtypes.NullableFloating): + fill_value = dtypes.get_finfo(x.dtype.values).max + x = self.where(x.null, fill_value, x.values) + elif isinstance(x.dtype, dtypes.NullableIntegral): + fill_value = dtypes.get_iinfo(x.dtype.values).max + x = self.where(x.null, fill_value, x.values) + if not isinstance(x.dtype, dtypes.Numerical): + raise TypeError("min is not supported for non-numeric types") + + return _via_i64_f64( + lambda x: opx.reduce_min( + x, + opx.const(axes, dtype=dtypes.int64), + keepdims=keepdims, + noop_with_empty_axes=axis is not None, + ), + [x], + ) + + def prod( + self, + x, + *, + axis=None, + dtype: dtypes.CoreType | dtypes.StructType | None = None, + keepdims: bool = False, + ): + if axis is None: + axes = [] + elif not isinstance(axis, Iterable): + axes = [axis] + else: + axes = axis # type: ignore + + if isinstance(x.dtype, dtypes.NullableNumerical): + fill_value = 1 + x = self.where(x.null, fill_value, x.values) + if not isinstance(x.dtype, dtypes.Numerical): + raise TypeError("prod is not supported for non-numeric types") + + if dtype is not None: + x = x.astype(dtype) + + out = _via_i64_f64( + lambda x: opx.reduce_prod( + x, + opx.const(axes, dtype=dtypes.int64), + keepdims=keepdims, + noop_with_empty_axes=axis is not None, + ), + [x], + ) + + if isinstance(x.dtype, dtypes.Unsigned): + out = out.astype(dtypes.uint64) + elif isinstance(x.dtype, dtypes.NullableUnsigned): + out = out.astype(dtypes.nuint64) + + return out + + def clip( + self, + x, + *, + min=None, + max=None, + ): + input = x.copy() + if min is not None: + min = ndx.asarray(min) + if max is not None: + max = ndx.asarray(max) + if ( + min is not None + and max is not None + and min.ndim == 0 + and max.ndim == 0 + and isinstance(x.dtype, dtypes.Numerical) + ): + x, min, max = promote(x, min, max) + if isinstance(x.dtype, dtypes._NullableCore): + out_null = x.null + x_values = x.values._core() + clipped = _from_corearray(opx.clip(x_values, min._core(), max._core())) + clipped = Array._from_fields(x.dtype, values=clipped, null=out_null) + else: + clipped = _from_corearray(opx.clip(x._core(), min._core(), max._core())) + if isinstance(x.dtype, (dtypes.Floating, dtypes.NullableFloating)): + return ndx.where(ndx.isnan(input), np.nan, clipped) + else: + return clipped + else: + if max is not None: + x = ndx.where(x <= max, x, max) + if min is not None: + x = ndx.where(x >= min, x, min) + if isinstance(x.dtype, (dtypes.Floating, dtypes.NullableFloating)): + return ndx.where(ndx.isnan(input), np.nan, x) + else: + return x + + def std( + self, + x, + axis=None, + keepdims: bool = False, + correction=0.0, + dtype: dtypes.StructType | dtypes.CoreType | None = None, + ): + dtype = x.dtype if dtype is None else dtype + if not isinstance(dtype, dtypes.CoreType): + raise TypeError("std is not supported for non-core types") + return self.sqrt( + self.var( + x, axis=axis, keepdims=keepdims, correction=correction, dtype=dtype + ) + ) + + def sum( + self, + x, + *, + axis=None, + dtype: dtypes.StructType | dtypes.CoreType | None = None, + keepdims: bool = False, + ): + if axis is None: + axes = [] + elif not isinstance(axis, Iterable): + axes = [axis] + else: + axes = axis # type: ignore + + # Fill any nulls with 0 + if isinstance(x.dtype, dtypes.NullableNumerical): + x = self.where(x.null, 0, x.values) + + if not isinstance(x.dtype, dtypes.Numerical): + raise TypeError("sum is not supported for non-core types") + + if dtype is not None: + x = x.astype(dtype) + + out = _via_i64_f64( + lambda corearray: opx.reduce_sum( + corearray, + opx.const(axes, dtype=dtypes.int64), + keepdims=keepdims, + noop_with_empty_axes=axis is not None, + ), + [x], + ) + + if isinstance(x.dtype, dtypes.Unsigned): + out = out.astype(dtypes.uint64) + elif isinstance(x.dtype, dtypes.NullableUnsigned): + out = out.astype(dtypes.nuint64) + + return out + + def var( + self, + x, + *, + axis=None, + keepdims: bool = False, + correction=0.0, + dtype: dtypes.CoreType | dtypes.StructType | None = None, + ): + dtype = x.dtype if dtype is None else dtype + if not isinstance(dtype, dtypes.CoreType): + raise TypeError("var is not supported for non-core types") + # We keepdims, so it is still broadcastable to x + mean_ = self.mean(x, axis=axis, keepdims=True).astype(dtype) + + return self.sum(self.square(x - mean_), axis=axis, keepdims=keepdims).astype( + dtype + ) / ( + self.sum(ndx.full_like(x, 1), axis=axis, keepdims=keepdims).astype(dtype) + - correction + ) + + # additional.py + def fill_null(self, x, value): + value = ndx.asarray(value) + + if not isinstance(x.dtype, dtypes._NullableCore): + raise TypeError("fill_null accepts only nullable arrays") + + if value.dtype != x.values.dtype: + value = value.astype(x.values.dtype) + return ndx.where(x.null, value, x.values) + + def make_nullable(self, x, null): + if null.dtype != dtypes.bool: + raise TypeError("null must be a boolean array") + if not isinstance(x.dtype, dtypes.CoreType): + raise TypeError("make_nullable does not accept nullable arrays") + return ndx.Array._from_fields( + dtypes.promote_nullable(x.dtype), + values=x.copy(), + null=ndx.reshape(null, x.shape), + ) + + def shape(self, x): + current = x + while isinstance(current, ndx.Array): + current = next(iter(current._fields.values())) + return _from_corearray(opx.shape(current)) + + +def _binary_op( + x: ndx.Array, + y: ndx.Array, + op: Callable[[_CoreArray, _CoreArray], _CoreArray], + via_dtype: dtypes.CoreType | None = None, +): + return _variadic_op([x, y], op, via_dtype) + + +def _unary_op( + x: ndx.Array, + op: Callable[[_CoreArray], _CoreArray], + via_dtype: dtypes.CoreType | None = None, +) -> ndx.Array: + return _variadic_op([x], op, via_dtype) + + +def _variadic_op( + args: list[Array], + op: Callable[..., _CoreArray], + via_dtype: dtypes.CoreType | None = None, + cast_return: bool = True, +) -> ndx.Array: + args = promote(*args) + out_dtype = args[0].dtype + if not isinstance(out_dtype, (dtypes.CoreType, dtypes._NullableCore)): + raise TypeError( + f"Expected ndx.Array with CoreType or NullableCoreType, got {args[0].dtype}" + ) + data, nulls = _split_nulls_and_values(*args) + if via_dtype is None: + values = _from_corearray(op(*(x._core() for x in data))) + else: + values = _via_dtype(op, via_dtype, data, cast_return=cast_return) + + if (out_null := functools.reduce(_or_nulls, nulls)) is not None: + dtype = dtypes.promote_nullable(values.dtype) + return ndx.Array._from_fields(dtype, values=values, null=out_null) + else: + return values + + +def _split_nulls_and_values(*xs: ndx.Array) -> tuple[list[Array], list[Array | None]]: + """Helper function that splits a series of ndx.Arrays into their constituent value + and null mask components. + + Raises if an unexpected typed array is provided. + """ + data: list[Array] = [] + nulls: list[Array | None] = [] + for x in xs: + if isinstance(x.dtype, dtypes.Nullable): + nulls.append(x.null) + data.append(x.values) + elif isinstance(x, ndx.Array): + nulls.append(None) + data.append(x) + else: + raise TypeError(f"Expected ndx.Array got {x}") + return data, nulls + + +def _or_nulls(x: ndx.Array | None, y: ndx.Array | None) -> ndx.Array | None: + if x is None: + return y + if y is None: + return x + return ndx.logical_or(x, y) + + +def _via_dtype( + fn: Callable[..., _CoreArray], + dtype: dtypes.CoreType | dtypes.StructType, + arrays: list[Array], + *, + cast_return=True, +) -> ndx.Array: + """Call ``fn`` after casting to ``dtype`` and cast result back to the input dtype. + + The point of this function is to work around quirks / limited type support in the + onnxruntime. + + ndx.Arrays are promoted to a common type prior to their first use. + """ + promoted = promote(*arrays) + out_dtype = promoted[0].dtype + + if isinstance(out_dtype, dtypes._NullableCore) and out_dtype.values == dtype: + dtype = out_dtype + + values, nulls = _split_nulls_and_values( + *[ndx.astype(arr, dtype) for arr in promoted] + ) + + out_value = _from_corearray(fn(*[value._core() for value in values])) + out_null = functools.reduce(_or_nulls, nulls) + + if out_null is not None: + out_value = ndx.Array._from_fields( + dtypes.promote_nullable(out_value.dtype), values=out_value, null=out_null + ) + else: + out_value = ndx.Array._from_fields(out_value.dtype, data=out_value._core()) + + if cast_return: + return ndx.astype(out_value, dtype=out_dtype) + else: + return out_value + + +def _via_i64_f64( + fn: Callable[..., _CoreArray], arrays: list[Array], *, cast_return=True +) -> ndx.Array: + """Like ``_via_dtype`` but uses ``i64`` for integer or boolean types and ``float64`` + for floating point types. + + Raises TypeError if the provided arrays are neither. + """ + promoted_values = promote(*arrays) + + dtype = promoted_values[0].dtype + + via_dtype: dtypes.CoreType + if isinstance(dtype, (dtypes.Integral, dtypes.NullableIntegral)) or dtype in ( + dtypes.nbool, + dtypes.bool, + ): + via_dtype = dtypes.int64 + elif isinstance(dtype, (dtypes.Floating, dtypes.NullableFloating)): + via_dtype = dtypes.float64 + else: + raise TypeError(f"Expected numerical data type, found {dtype}") + + return _variadic_op(arrays, fn, via_dtype, cast_return) + + +def _from_corearray( + corearray: _CoreArray, +) -> ndx.Array: + return ndx.Array._from_fields(corearray.dtype, data=corearray) diff --git a/ndonnx/_core/_interface.py b/ndonnx/_core/_interface.py new file mode 100644 index 0000000..ea056e3 --- /dev/null +++ b/ndonnx/_core/_interface.py @@ -0,0 +1,354 @@ +# Copyright (c) QuantCo 2024-2024 +# SPDX-License-Identifier: LicenseRef-QuantCo +from __future__ import annotations + +from typing import Literal + +import numpy as np + +import ndonnx as ndx +import ndonnx._data_types as dtypes + + +class OperationsBlock: + """Interface for data types to implement top-level functions exported by ndonnx.""" + + # elementwise.py + + def abs(self, x) -> ndx.Array: + return NotImplemented + + def acos(self, x) -> ndx.Array: + return NotImplemented + + def acosh(self, x) -> ndx.Array: + return NotImplemented + + def add(self, x, y) -> ndx.Array: + return NotImplemented + + def asin(self, x) -> ndx.Array: + return NotImplemented + + def asinh(self, x) -> ndx.Array: + return NotImplemented + + def atan(self, x) -> ndx.Array: + return NotImplemented + + def atan2(self, y, x) -> ndx.Array: + return ndx.atan(ndx.divide(y, x)) + + def atanh(self, x) -> ndx.Array: + return NotImplemented + + def bitwise_and(self, x, y) -> ndx.Array: + return NotImplemented + + def bitwise_left_shift(self, x, y) -> ndx.Array: + return NotImplemented + + def bitwise_invert(self, x) -> ndx.Array: + return NotImplemented + + def bitwise_or(self, x, y) -> ndx.Array: + return NotImplemented + + def bitwise_right_shift(self, x, y) -> ndx.Array: + return NotImplemented + + def bitwise_xor(self, x, y) -> ndx.Array: + return NotImplemented + + def ceil(self, x) -> ndx.Array: + return NotImplemented + + def conj(*args): + return NotImplemented + + def cos(self, x) -> ndx.Array: + return NotImplemented + + def cosh(self, x) -> ndx.Array: + return NotImplemented + + def divide(self, x, y) -> ndx.Array: + return NotImplemented + + def equal(self, x, y) -> ndx.Array: + return NotImplemented + + def exp(self, x) -> ndx.Array: + return NotImplemented + + def expm1(self, x) -> ndx.Array: + return ndx.subtract(ndx.exp(x), 1) + + def floor(self, x) -> ndx.Array: + return NotImplemented + + def floor_divide(self, x, y) -> ndx.Array: + return ndx.floor(ndx.divide(x, y)) + + def greater(self, x, y) -> ndx.Array: + return NotImplemented + + def greater_equal(self, x, y) -> ndx.Array: + return NotImplemented + + def imag(*args): + return NotImplemented + + def isfinite(self, x) -> ndx.Array: + return ndx.logical_not(ndx.isinf(x)) + + def isinf(self, x) -> ndx.Array: + return NotImplemented + + def isnan(self, x) -> ndx.Array: + return NotImplemented + + def less(self, x, y) -> ndx.Array: + return NotImplemented + + def less_equal(self, x, y) -> ndx.Array: + return NotImplemented + + def log(self, x) -> ndx.Array: + return NotImplemented + + def log1p(self, x) -> ndx.Array: + return ndx.add(ndx.log(x), ndx.asarray(1, x.dtype)) + + def log2(self, x) -> ndx.Array: + return ndx.log(x) / np.log(2) + + def log10(self, x) -> ndx.Array: + return ndx.log(x) / np.log(10) + + def logaddexp(self, x, y) -> ndx.Array: + return ndx.log(ndx.exp(x) + ndx.exp(y)) + + def logical_and(self, x, y) -> ndx.Array: + return NotImplemented + + def logical_not(self, x) -> ndx.Array: + return NotImplemented + + def logical_or(self, x, y) -> ndx.Array: + return NotImplemented + + def logical_xor(self, x, y) -> ndx.Array: + return NotImplemented + + def multiply(self, x, y) -> ndx.Array: + return NotImplemented + + def negative(self, x) -> ndx.Array: + return NotImplemented + + def not_equal(self, x, y) -> ndx.Array: + return ndx.logical_not(ndx.equal(x, y)) + + def positive(self, x) -> ndx.Array: + return NotImplemented + + def pow(self, x, y) -> ndx.Array: + return NotImplemented + + def real(*args): + return NotImplemented + + def remainder(self, x, y) -> ndx.Array: + return NotImplemented + + def round(self, x) -> ndx.Array: + return NotImplemented + + def sign(self, x) -> ndx.Array: + return NotImplemented + + def sin(self, x) -> ndx.Array: + return NotImplemented + + def sinh(self, x) -> ndx.Array: + return NotImplemented + + def square(self, x) -> ndx.Array: + return ndx.multiply(x, x) + + def sqrt(self, x) -> ndx.Array: + return NotImplemented + + def subtract(self, x, y) -> ndx.Array: + return NotImplemented + + def tan(self, x) -> ndx.Array: + return NotImplemented + + def tanh(self, x) -> ndx.Array: + return NotImplemented + + def trunc(self, x) -> ndx.Array: + return NotImplemented + + # linalg.py + + def matmul(self, x, y) -> ndx.Array: + return NotImplemented + + def matrix_transpose(self, x) -> ndx.Array: + return ndx.permute_dims(x, list(range(x.ndim - 2)) + [x.ndim - 1, x.ndim - 2]) + + # searching.py + + def argmax(self, x, axis=None, keepdims=False) -> ndx.Array: + return NotImplemented + + def argmin(self, x, axis=None, keepdims=False) -> ndx.Array: + return NotImplemented + + def nonzero(self, x) -> list[ndx.Array]: + return NotImplemented + + def searchsorted( + self, + x1, + x2, + *, + side: Literal["left", "right"] = "left", + sorter: ndx.Array | None = None, + ) -> ndx.Array: + return NotImplemented + + def where(self, condition, x, y) -> ndx.Array: + return NotImplemented + + # set.py + def unique_all(self, x): + return NotImplemented + + def unique_counts(self, x): + return NotImplemented + + def unique_inverse(self, x): + return NotImplemented + + def unique_values(self, x): + return NotImplemented + + # sorting.py + + def argsort(self, x, *, axis=-1, descending=False, stable=True) -> ndx.Array: + return NotImplemented + + def sort(self, x, *, axis=-1, descending=False, stable=True) -> ndx.Array: + return NotImplemented + + # statistical.py + + def cumulative_sum( + self, + x, + *, + axis: int | None = None, + dtype: ndx.CoreType | dtypes.StructType | None = None, + include_initial: bool = False, + ): + return NotImplemented + + def max(self, x, *, axis=None, keepdims: bool = False) -> ndx.Array: + return NotImplemented + + def mean(self, x, *, axis=None, keepdims: bool = False) -> ndx.Array: + return NotImplemented + + def min(self, x, *, axis=None, keepdims: bool = False) -> ndx.Array: + return NotImplemented + + def prod( + self, + x, + *, + axis=None, + dtype: dtypes.CoreType | dtypes.StructType | None = None, + keepdims: bool = False, + ) -> ndx.Array: + return NotImplemented + + def clip(self, x, *, min=None, max=None) -> ndx.Array: + return NotImplemented + + def std( + self, + x, + axis=None, + keepdims: bool = False, + correction=0.0, + dtype: dtypes.StructType | dtypes.CoreType | None = None, + ) -> ndx.Array: + return NotImplemented + + def sum( + self, + x, + *, + axis=None, + dtype: dtypes.CoreType | dtypes.StructType | None = None, + keepdims: bool = False, + ) -> ndx.Array: + return NotImplemented + + def var( + self, + x, + *, + axis=None, + keepdims: bool = False, + correction=0.0, + dtype: dtypes.CoreType | dtypes.StructType | None = None, + ) -> ndx.Array: + return NotImplemented + + # utility.py + + def all(self, x, *, axis=None, keepdims: bool = False) -> ndx.Array: + return NotImplemented + + def any(self, x, *, axis=None, keepdims: bool = False) -> ndx.Array: + return NotImplemented + + # indexing.py + def take(self, x, indices, axis=None) -> ndx.Array: + return NotImplemented + + def broadcast_to(self, x, shape) -> ndx.Array: + return NotImplemented + + def expand_dims(self, x, axis) -> ndx.Array: + return NotImplemented + + def flip(self, x, axis) -> ndx.Array: + return NotImplemented + + def permute_dims(self, x, axes) -> ndx.Array: + return NotImplemented + + def reshape(self, x, shape, *, copy=None) -> ndx.Array: + return NotImplemented + + def roll(self, x, shift, axis) -> ndx.Array: + return NotImplemented + + def squeeze(self, x, axis) -> ndx.Array: + return NotImplemented + + # additional.py + def shape(self, x) -> ndx.Array: + return NotImplemented + + def fill_null(self, x, value) -> ndx.Array: + return NotImplemented + + def make_nullable(self, x, null) -> ndx.Array: + return NotImplemented diff --git a/ndonnx/_corearray.py b/ndonnx/_corearray.py new file mode 100644 index 0000000..7dd0dc7 --- /dev/null +++ b/ndonnx/_corearray.py @@ -0,0 +1,100 @@ +# Copyright (c) QuantCo 2023-2024 +# SPDX-License-Identifier: LicenseRef-QuantCo + +from __future__ import annotations + +from typing import TYPE_CHECKING, Union + +import numpy as np +import spox.opset.ai.onnx.v20 as op +from spox import Var +from typing_extensions import Self + +import ndonnx as ndx + +from ._index import ScalarIndexType, construct_index +from ._utility import get_dtype, get_rank, get_shape + +if TYPE_CHECKING: + from ._data_types import CoreType + +IndexType = Union[ScalarIndexType, tuple[ScalarIndexType, ...], "_CoreArray"] + + +class _CoreArray: + """Thin wrapper around a `spox.Var` as well as optionally the eager propagated + value.""" + + var: Var + _eager_value: np.ndarray | None + + def __init__(self, value: Var | np.ndarray) -> None: + if isinstance(value, Var): + self.var = value + self._eager_value = None + else: + self.var = op.const(value) + self._eager_value = value + + def _set(self, other: _CoreArray) -> Self: + self.var = other.var + self._eager_value = other.to_numpy() + return self + + def copy(self) -> Self: + return type(self)( + self.var if self._eager_value is None else self._eager_value, + ) + + def to_numpy(self) -> np.ndarray | None: + return self._eager_value + + @property + def dtype(self) -> CoreType: + return ndx.from_numpy_dtype(get_dtype(self)) + + def astype(self, dtype: CoreType) -> _CoreArray: + import ndonnx._opset_extensions as opx + + return opx.cast(self, dtype) + + def __getitem__(self, index: IndexType) -> _CoreArray: + import ndonnx._opset_extensions as opx + + normalised_index = self._normalise_index(index) + return opx.getitem(self, normalised_index) + + def __setitem__( + self, index: IndexType, updates: int | bool | float | _CoreArray + ) -> Self: + import ndonnx._opset_extensions as opx + + normalised_index = self._normalise_index(index) + normalised_updates = ( + updates + if isinstance(updates, _CoreArray) + else _CoreArray(np.array(updates)) + ) + ret = opx.setitem(self, normalised_index, normalised_updates) + return self._set(ret) + + def _normalise_index( + self, index: IndexType + ) -> _CoreArray | tuple[ScalarIndexType, ...]: + if isinstance(index, _CoreArray): + return index + else: + index = construct_index(self, index) + indexing_expressions = len(tuple(idx for idx in index if idx is not None)) + if self.ndim != indexing_expressions: + raise IndexError( + f"Index has {indexing_expressions} expressions but Array has rank {self.ndim}" + ) + return index + + @property + def ndim(self) -> int: + return get_rank(self) + + def __repr__(self) -> str: + return f" propagated: {self.to_numpy()}>" diff --git a/ndonnx/_data_types/__init__.py b/ndonnx/_data_types/__init__.py new file mode 100644 index 0000000..92004e0 --- /dev/null +++ b/ndonnx/_data_types/__init__.py @@ -0,0 +1,145 @@ +# Copyright (c) QuantCo 2023-2024 +# SPDX-License-Identifier: LicenseRef-QuantCo +from __future__ import annotations + +from .aliases import ( + bool, + float32, + float64, + int8, + int16, + int32, + int64, + nbool, + nfloat32, + nfloat64, + nint8, + nint16, + nint32, + nint64, + nuint8, + nuint16, + nuint32, + nuint64, + nutf8, + uint8, + uint16, + uint32, + uint64, + utf8, +) +from .classes import ( + Floating, + Integral, + Nullable, + NullableFloating, + NullableIntegral, + NullableNumerical, + NullableUnsigned, + Numerical, + Unsigned, + _NullableCore, + from_numpy_dtype, + get_finfo, + get_iinfo, +) +from .conversion import CastError, CastMixin +from .coretype import CoreType +from .schema import Schema +from .structtype import StructType + + +def promote_nullable(dtype: StructType | CoreType) -> _NullableCore: + """Promotes a non-nullable type to its nullable counterpart, if present. + + Parameters + ---------- + dtype : StructType | CoreType + A data type exported by ``ndonnx``. + + Returns + ------- + out : _NullableCore + The nullable counterpart of the input type. + + Raises + ------ + ValueError + If the input type is unknown to ``ndonnx``. + """ + + if dtype == bool: + return nbool + elif dtype == float32: + return nfloat32 + elif dtype == float64: + return nfloat64 + elif dtype == int8: + return nint8 + elif dtype == int16: + return nint16 + elif dtype == int32: + return nint32 + elif dtype == int64: + return nint64 + elif dtype == uint8: + return nuint8 + elif dtype == uint16: + return nuint16 + elif dtype == uint32: + return nuint32 + elif dtype == uint64: + return nuint64 + elif dtype == utf8: + return nutf8 + elif isinstance(dtype, _NullableCore): + return dtype + else: + raise ValueError(f"Cannot promote {dtype} to nullable") + + +__all__ = [ + "CoreType", + "StructType", + "_NullableCore", + "NullableFloating", + "NullableIntegral", + "NullableUnsigned", + "NullableNumerical", + "Nullable", + "Floating", + "Integral", + "Unsigned", + "Numerical", + "bool", + "from_numpy_dtype", + "float32", + "float64", + "int16", + "int32", + "int64", + "int8", + "uint16", + "uint32", + "uint64", + "uint8", + "utf8", + "nbool", + "nfloat32", + "nfloat64", + "nint8", + "nint16", + "nint32", + "nint64", + "nuint8", + "nuint16", + "nuint32", + "nuint64", + "nutf8", + "get_finfo", + "get_iinfo", + "promote_nullable", + "Schema", + "CastMixin", + "CastError", +] diff --git a/ndonnx/_data_types/aliases.py b/ndonnx/_data_types/aliases.py new file mode 100644 index 0000000..d88509e --- /dev/null +++ b/ndonnx/_data_types/aliases.py @@ -0,0 +1,57 @@ +# Copyright (c) QuantCo 2023-2024 +# SPDX-License-Identifier: LicenseRef-QuantCo + +from .classes import ( + Boolean, + Float32, + Float64, + Int8, + Int16, + Int32, + Int64, + NBoolean, + NFloat32, + NFloat64, + NInt8, + NInt16, + NInt32, + NInt64, + NUInt8, + NUInt16, + NUInt32, + NUInt64, + NUtf8, + UInt8, + UInt16, + UInt32, + UInt64, + Utf8, +) + +# Singleton exports of core data types +bool: Boolean = Boolean() +float32: Float32 = Float32() +float64: Float64 = Float64() +int16: Int16 = Int16() +int32: Int32 = Int32() +int64: Int64 = Int64() +int8: Int8 = Int8() +uint16: UInt16 = UInt16() +uint32: UInt32 = UInt32() +uint64: UInt64 = UInt64() +uint8: UInt8 = UInt8() +utf8: Utf8 = Utf8() + +# Singleton exports of nullable instances of the core data types +nbool: NBoolean = NBoolean() +nfloat32: NFloat32 = NFloat32() +nfloat64: NFloat64 = NFloat64() +nint8: NInt8 = NInt8() +nint16: NInt16 = NInt16() +nint32: NInt32 = NInt32() +nint64: NInt64 = NInt64() +nuint8: NUInt8 = NUInt8() +nuint16: NUInt16 = NUInt16() +nuint32: NUInt32 = NUInt32() +nuint64: NUInt64 = NUInt64() +nutf8: NUtf8 = NUtf8() diff --git a/ndonnx/_data_types/classes.py b/ndonnx/_data_types/classes.py new file mode 100644 index 0000000..59edf85 --- /dev/null +++ b/ndonnx/_data_types/classes.py @@ -0,0 +1,405 @@ +# Copyright (c) QuantCo 2023-2024 +# SPDX-License-Identifier: LicenseRef-QuantCo + +from __future__ import annotations + +from dataclasses import dataclass +from typing import TYPE_CHECKING, Generic, TypeVar + +import numpy as np +from typing_extensions import Self + +import ndonnx as ndx +from ndonnx._core import CoreOperationsImpl, OperationsBlock +from ndonnx._data_types.schema import Schema + +from .conversion import CastError, CastMixin +from .coretype import CoreType +from .structtype import StructType + +if TYPE_CHECKING: + from ndonnx import Array + + +class Numerical(CoreType): + """Base class for numerical data types.""" + + +class Integral(Numerical): + """Base class for integral data types.""" + + +class Unsigned(Integral): + """Base class for unsigned integral data types.""" + + +class Fractional(Numerical): + """Base class for fractional data types.""" + + +class Floating(Fractional): + """Base class for floating data types.""" + + +class Int8(Integral): + """8-bit signed integer.""" + + @staticmethod + def to_numpy_dtype() -> np.dtype: + return np.dtype("int8") + + +class Int16(Integral): + """16-bit signed integer.""" + + @staticmethod + def to_numpy_dtype() -> np.dtype: + return np.dtype("int16") + + +class Int32(Integral): + """32-bit signed integer.""" + + @staticmethod + def to_numpy_dtype() -> np.dtype: + return np.dtype("int32") + + +class Int64(Integral): + """64-bit signed integer.""" + + @staticmethod + def to_numpy_dtype() -> np.dtype: + return np.dtype("int64") + + +class UInt8(Unsigned): + """8-bit unsigned integer.""" + + @staticmethod + def to_numpy_dtype() -> np.dtype: + return np.dtype("uint8") + + +class UInt16(Unsigned): + """16-bit unsigned integer.""" + + @staticmethod + def to_numpy_dtype() -> np.dtype: + return np.dtype("uint16") + + +class UInt32(Unsigned): + """32-bit unsigned integer.""" + + @staticmethod + def to_numpy_dtype() -> np.dtype: + return np.dtype("uint32") + + +class UInt64(Unsigned): + """64-bit unsigned integer.""" + + @staticmethod + def to_numpy_dtype() -> np.dtype: + return np.dtype("uint64") + + +class Float32(Floating): + """32-bit floating point.""" + + @staticmethod + def to_numpy_dtype() -> np.dtype: + return np.dtype("float32") + + +class Float64(Floating): + """64-bit floating point.""" + + @staticmethod + def to_numpy_dtype() -> np.dtype: + return np.dtype("float64") + + +class Boolean(CoreType): + """Boolean type.""" + + @staticmethod + def to_numpy_dtype() -> np.dtype: + return np.dtype("bool") + + +class Utf8(CoreType): + """UTF-8 encoded string.""" + + @staticmethod + def to_numpy_dtype() -> np.dtype: + return np.dtype("str") + + def _parse_input(self, data: np.ndarray) -> dict[str, np.ndarray]: + if data.dtype.kind == "U" or ( + data.dtype.kind == "O" and all(isinstance(x, str) for x in data) + ): + return {"data": data.astype(np.str_)} + else: + raise TypeError(f"Expected data type with kind 'U', got {data.dtype}") + + def _assemble_output(self, fields: dict[str, np.ndarray]) -> np.ndarray: + if "data" not in fields: + raise ValueError( + f"Missing fields in output: {fields.keys()}, expected `data`" + ) + if fields["data"].dtype.kind == "O" and all( + isinstance(x, str) for x in fields["data"] + ): + return fields["data"].astype(np.str_) + elif fields["data"].dtype.kind == "U": + return fields["data"] + else: + raise TypeError( + f"Expected data type with kind 'U', got {fields['data'].dtype}" + ) + + +T = TypeVar("T", StructType, CoreType, covariant=True) + + +class Nullable(StructType, Generic[T]): + values: T + null: Boolean + + def _fields(self) -> dict[str, StructType | CoreType]: + return { + "values": self.values, + "null": self.null, + } + + +class _NullableCore(Nullable[CoreType], CastMixin): + def copy(self) -> Self: + return self + + def _parse_input(self, input: np.ndarray) -> dict: + if not isinstance(input, np.ma.MaskedArray): + raise TypeError(f"Expected numpy MaskedArray, got {type(input)}") + return { + "values": self.values._parse_input(input.data), + "null": self.null._parse_input(input.mask), + } + + def _assemble_output(self, fields: dict[str, np.ndarray]) -> np.ndarray: + if "values" not in fields or "null" not in fields: + raise ValueError( + f"Missing fields in output: {fields.keys()}, expected `null` and `values`" + ) + + return np.ma.masked_array(fields["values"], mask=fields["null"]) + + def _schema(self) -> Schema: + return Schema(type_name=type(self).__name__, author="ndonnx") + + def _cast_to(self, array: Array, dtype: CoreType | StructType) -> Array: + if isinstance(dtype, _NullableCore): + return ndx.Array._from_fields( + dtype, + values=self.values._cast_to(array.values, dtype.values), + null=array.null.copy(), + ) + else: + raise CastError(f"Cannot cast to {dtype} from {self}") + + def _cast_from(self, array: Array) -> Array: + if isinstance(array.dtype, CoreType): + # Promote to nullable variant + return ndx.Array._from_fields( + self, + values=self.values._cast_from(array), + null=ndx.zeros_like(array, dtype=Boolean()), + ) + elif isinstance(array.dtype, _NullableCore): + return ndx.Array._from_fields( + self, + values=self.values._cast_from(array.values), + null=array.null.copy(), + ) + else: + raise CastError(f"Cannot cast from {array.dtype} to {self}") + + _ops: OperationsBlock = CoreOperationsImpl() + + +class NullableNumerical(_NullableCore): + """Base class for nullable numerical data types.""" + + +class NullableIntegral(NullableNumerical): + """Base class for nullable integral data types.""" + + +class NullableUnsigned(NullableIntegral): + """Base class for nullable unsigned integral data types.""" + + +class NullableFractional(NullableNumerical): + """Base class for nullable fractional data types.""" + + +class NullableFloating(NullableFractional): + """Base class for nullable floating data types.""" + + +class NInt8(NullableIntegral): + values = Int8() + null = Boolean() + + +class NInt16(NullableIntegral): + values = Int16() + null = Boolean() + + +class NInt32(NullableIntegral): + values = Int32() + null = Boolean() + + +class NInt64(NullableIntegral): + values = Int64() + null = Boolean() + + +class NUInt8(NullableUnsigned): + values = UInt8() + null = Boolean() + + +class NUInt16(NullableUnsigned): + values = UInt16() + null = Boolean() + + +class NUInt32(NullableUnsigned): + values = UInt32() + null = Boolean() + + +class NUInt64(NullableUnsigned): + values = UInt64() + null = Boolean() + + +class NFloat32(NullableFloating): + values = Float32() + null = Boolean() + + +class NFloat64(NullableFloating): + values = Float64() + null = Boolean() + + +class NBoolean(_NullableCore): + values = Boolean() + null = Boolean() + + +class NUtf8(_NullableCore): + values = Utf8() + null = Boolean() + + +def from_numpy_dtype(np_dtype: np.dtype) -> CoreType: + """Convert a numpy dtype to an ndonnx data type.""" + if np_dtype == np.dtype("int8"): + return Int8() + if np_dtype == np.dtype("int16"): + return Int16() + if np_dtype == np.dtype("int32"): + return Int32() + if np_dtype == np.dtype("int64"): + return Int64() + if np_dtype == np.dtype("uint8"): + return UInt8() + if np_dtype == np.dtype("uint16"): + return UInt16() + if np_dtype == np.dtype("uint32"): + return UInt32() + if np_dtype == np.dtype("uint64"): + return UInt64() + if np_dtype == np.dtype("float32"): + return Float32() + if np_dtype == np.dtype("float64"): + return Float64() + if np_dtype == np.dtype("bool"): + return Boolean() + if np_dtype == np.dtype("str") or np_dtype.kind in ("U", "O"): + return Utf8() + raise TypeError(f"Unsupported data type: {np_dtype}") + + +@dataclass +class Iinfo: + # Number of bits occupied by the type. + bits: int + # Largest representable number. + max: int + # Smallest representable number. + min: int + # Integer data type. + dtype: CoreType + + @classmethod + def _from_dtype(cls, dtype: CoreType) -> Iinfo: + iinfo = np.iinfo(dtype.to_numpy_dtype()) + return cls( + bits=iinfo.bits, + max=iinfo.max, + min=iinfo.min, + dtype=dtype, + ) + + +@dataclass +class Finfo: + # number of bits occupied by the real-valued floating-point data type. + bits: int + # difference between 1.0 and the next smallest representable real-valued floating-point number larger than 1.0 according to the IEEE-754 standard. + eps: float + # largest representable real-valued number. + max: float + # smallest representable real-valued number. + min: float + # smallest positive real-valued floating-point number with full precision. + smallest_normal: float + # real-valued floating-point data type. + dtype: CoreType + + @classmethod + def _from_dtype(cls, dtype: CoreType) -> Finfo: + finfo = np.finfo(dtype.to_numpy_dtype()) + return cls( + bits=finfo.bits, + max=float(finfo.max), + min=float(finfo.min), + dtype=dtype, + eps=float(finfo.eps), + smallest_normal=float(finfo.smallest_normal), + ) + + +def get_finfo(dtype: _NullableCore | CoreType) -> Finfo: + try: + if isinstance(dtype, _NullableCore): + dtype = dtype.values + return Finfo._from_dtype(dtype) + except KeyError: + raise TypeError(f"'{dtype}' is not a floating point data type.") + + +def get_iinfo(dtype: _NullableCore | CoreType) -> Iinfo: + try: + if isinstance(dtype, _NullableCore): + dtype = dtype.values + return Iinfo._from_dtype(dtype) + except KeyError: + raise TypeError(f"'{dtype}' is not an integer data type.") diff --git a/ndonnx/_data_types/conversion.py b/ndonnx/_data_types/conversion.py new file mode 100644 index 0000000..7084fb3 --- /dev/null +++ b/ndonnx/_data_types/conversion.py @@ -0,0 +1,39 @@ +# Copyright (c) QuantCo 2024-2024 +# SPDX-License-Identifier: LicenseRef-QuantCo + +from __future__ import annotations + +from abc import abstractmethod +from typing import TYPE_CHECKING + +if TYPE_CHECKING: + from ndonnx._array import Array + from ndonnx._data_types import CoreType, StructType + + +class CastError(TypeError): + """Error raised when a casting operation fails.""" + + +class CastMixin: + """Abstract interface for casting operations. + + When implemented for a data type, arrays of this data type can be casted to and from + this data type. + """ + + @abstractmethod + def _cast_from(self, array: Array) -> Array: + """Casts the input array to this data type. + + Raise a `CastFailedError` if the cast is not possible. + """ + ... + + @abstractmethod + def _cast_to(self, array: Array, dtype: CoreType | StructType) -> Array: + """Cast the input array from this data type to the specified data type `dtype`. + + Raise a `CastFailedError` if the cast is not possible. + """ + ... diff --git a/ndonnx/_data_types/coretype.py b/ndonnx/_data_types/coretype.py new file mode 100644 index 0000000..cd4596f --- /dev/null +++ b/ndonnx/_data_types/coretype.py @@ -0,0 +1,82 @@ +# Copyright (c) QuantCo 2024-2024 +# SPDX-License-Identifier: LicenseRef-QuantCo + +from __future__ import annotations + +from abc import abstractmethod +from typing import TYPE_CHECKING + +import numpy as np + +import ndonnx as ndx +import ndonnx._core as impl +import ndonnx._opset_extensions as opx + +from .conversion import CastError, CastMixin +from .schema import Schema + +if TYPE_CHECKING: + from ndonnx._array import Array + + from .structtype import StructType + + +class CoreType(CastMixin): + """Base class for the standard data types present in ONNX.""" + + @staticmethod + @abstractmethod + def to_numpy_dtype() -> np.dtype: + """Returns the numpy dtype corresponding to this data type.""" + + def __eq__(self, other: object) -> bool: + return ( + type(self) is type(other) + or type(self) is other + or self.to_numpy_dtype() == other + ) + + def __ne__(self, other: object) -> bool: + return not self.__eq__(other) + + def __repr__(self) -> str: + return type(self).__name__ + + def __hash__(self) -> int: + return hash(type(self)) + + def __str__(self) -> str: + return repr(self) + + def _schema(self) -> Schema: + return Schema(type_name=type(self).__name__, author="ndonnx") + + def _assemble_output(self, fields: dict[str, np.ndarray]) -> np.ndarray: + if "data" not in fields: + raise ValueError("Fields must contain 'data' key") + return fields["data"] + + def _parse_input(self, data: np.ndarray) -> dict[str, np.ndarray]: + if data.dtype != self.to_numpy_dtype(): + raise ValueError( + f"Expected dtype {self.to_numpy_dtype()}, got {data.dtype}" + ) + if isinstance(data, np.ma.MaskedArray): + raise ValueError( + "Masked arrays are not supported for core data types. Use a nullable data type instead." + ) + return {"data": data} + + def _cast_from(self, array: Array) -> Array: + if isinstance(array.dtype, CoreType): + return ndx.Array._from_fields(self, data=opx.cast(array._core(), to=self)) + else: + raise CastError(f"Cannot cast from {array.dtype} to {self}") + + def _cast_to(self, array: Array, dtype: CoreType | StructType) -> Array: + if isinstance(dtype, CoreType): + return dtype._cast_from(array) + else: + raise CastError(f"Cannot cast from {array.dtype} to {dtype}") + + _ops: impl.CoreOperationsImpl = impl.CoreOperationsImpl() diff --git a/ndonnx/_data_types/schema.py b/ndonnx/_data_types/schema.py new file mode 100644 index 0000000..ff9d3f3 --- /dev/null +++ b/ndonnx/_data_types/schema.py @@ -0,0 +1,11 @@ +# Copyright (c) QuantCo 2024-2024 +# SPDX-License-Identifier: LicenseRef-QuantCo + +from dataclasses import dataclass + + +@dataclass +class Schema: + type_name: str + author: str + meta: object = None diff --git a/ndonnx/_data_types/structtype.py b/ndonnx/_data_types/structtype.py new file mode 100644 index 0000000..1f720b7 --- /dev/null +++ b/ndonnx/_data_types/structtype.py @@ -0,0 +1,107 @@ +# Copyright (c) QuantCo 2024-2024 +# SPDX-License-Identifier: LicenseRef-QuantCo + +from __future__ import annotations + +from abc import abstractmethod + +import numpy as np +import typing_extensions + +from ndonnx._core._interface import OperationsBlock +from ndonnx._data_types.coretype import CoreType + +from .schema import Schema + + +class StructType: + """The ``StructType`` class defines all data types that go beyond the core data + types present in the ONNX standard. + + Inheriting from ``StructType`` enables the implementation of more complex and domain-specific data types. The API for doing so is used to implement the nullable data types exported by ``ndonnx``. This API is not yet public but may be considered ready for experimentation. + """ + + @abstractmethod + def _fields(self) -> dict[str, StructType | CoreType]: + """Define the named fields of this StructType.""" + ... + + @abstractmethod + def _parse_input(self, input: np.ndarray) -> dict: + """This method may be used by runtime utilities. It should break down the input + numpy array into a dictionary of values with an entry for each field in this + StructType. + + As an example, consider defining a 128 bit data type as a StructType as follows: + + .. code-block:: python + + class My128BitType(StructType): + def __init__(self): + super().__init__(low=uint64(), high=uint64()) + + Then, ``parse_input`` can be defined as follows: + + .. code-block:: python + + def _parse_input(self, input: np.ndarray) -> dict[str, np.ndarray]: + # We expect a numpy array of python int objects. + if input.dtype != object: + raise TypeError("Input must be an object array") + mask = (1 << 64) - 1 + return { + "low": (input & mask).astype(np.uint64), + "high": (input >> 64).astype(np.uint64) & mask, + } + """ + ... + + @abstractmethod + def _assemble_output(self, fields: dict[str, np.ndarray]) -> np.ndarray: + """This method may be used by runtime utilities, and is essentially an inverse + of ``parse_input``. It should take a dictionary of values (representing the + fields of the struct being defined) and compose them into a single + representation of a value with this data type. + + As an example, consider defining a 128 bit data type as a StructType as follows: + + .. code-block:: python + + class My128BitType(StructType): + def __init__(self): + super().__init__(low=uint64(), high=uint64()) + + Then, ``assemble_output`` can be defined as follows: + + .. code-block:: python + + def _assemble_output(self, fields: dict[str, np.ndarray]) -> np.ndarray: + return (fields["high"].astype(object) << 64) | fields["low"].astype(object) + """ + + @abstractmethod + def _schema(self) -> Schema: + """Exports a schema that describes any basic information required by runtime + utilities to consume input values corresponding to this array.""" + ... + + @abstractmethod + def copy(self) -> typing_extensions.Self: + """Clone this data type.""" + ... + + def __eq__(self, other: object) -> bool: + return type(self) is type(other) or type(self) is other + + def __ne__(self, other: object) -> bool: + return not self.__eq__(other) + + def __repr__(self) -> str: + return type(self).__name__ + + def __hash__(self) -> int: + return hash(type(self)) + + _ops: OperationsBlock + """Defines functions that may be executed using a ``ndx.Array`` of this data + type.""" diff --git a/ndonnx/_experimental.py b/ndonnx/_experimental.py new file mode 100644 index 0000000..6814f44 --- /dev/null +++ b/ndonnx/_experimental.py @@ -0,0 +1,12 @@ +# Copyright (c) QuantCo 2024-2024 +# SPDX-License-Identifier: LicenseRef-QuantCo + +from ._core import OperationsBlock +from ._data_types import CastMixin, Schema, StructType + +__all__ = [ + "StructType", + "Schema", + "CastMixin", + "OperationsBlock", +] diff --git a/ndonnx/_funcs.py b/ndonnx/_funcs.py new file mode 100644 index 0000000..edfc6f6 --- /dev/null +++ b/ndonnx/_funcs.py @@ -0,0 +1,1041 @@ +# Copyright (c) QuantCo 2023-2024 +# SPDX-License-Identifier: LicenseRef-QuantCo + +from __future__ import annotations + +import builtins +import functools +import operator +from collections import namedtuple +from collections.abc import Iterable, Sequence +from typing import Literal + +import numpy as np +import numpy.typing as npt + +import ndonnx._data_types as dtypes +from ndonnx._data_types import CastError, CastMixin, CoreType, _NullableCore +from ndonnx._data_types.structtype import StructType + +from . import _opset_extensions as opx +from ._array import Array, _from_corearray +from ._utility import ( + promote, +) + +# creation.py + + +def arange( + start, + stop=None, + step=1, + *, + dtype: dtypes.CoreType | dtypes.StructType | None = None, + device=None, +): + step = asarray(step) + if stop is None: + stop = start + start = asarray(0) + elif start is None: + start = asarray(0) + + start, stop, step = promote(start, stop, step) + + if not builtins.all(isinstance(x.dtype, CoreType) for x in (start, stop, step)): + raise TypeError( + "Cannot perform arange with nullable `start`, `stop` or `step` parameters." + ) + + if dtype is None: + if builtins.all( + isinstance(x.dtype, dtypes.Integral) for x in [start, stop, step] + ): + dtype = dtypes.int64 + else: + dtype = dtypes.float64 + + return astype( + _from_corearray(opx.range(start._core(), stop._core(), step._core())), dtype + ) + + +def asarray( + x: npt.ArrayLike | Array, + dtype: dtypes.CoreType | dtypes.StructType | None = None, + copy=None, + device=None, +) -> Array: + if not isinstance(x, Array): + arr = np.asanyarray( + x, + dtype=( + dtype.to_numpy_dtype() if isinstance(dtype, dtypes.CoreType) else None + ), + ) + if dtype is None: + dtype = dtypes.from_numpy_dtype(arr.dtype) + if isinstance(arr, np.ma.masked_array): + dtype = dtypes.promote_nullable(dtype) + + ret = Array._construct( + shape=arr.shape, dtype=dtype, eager_values=dtype._parse_input(arr) + ) + else: + ret = x.copy() if copy is True else x + + if dtype is not None: + ret = ret.astype(dtype) + + return ret + + +def empty(shape, dtype: dtypes.CoreType | dtypes.StructType | None = None, device=None): + shape = asarray(shape, dtype=dtypes.int64) + if not isinstance(shape.dtype, dtypes.Integral): + raise TypeError("shape must be an integer array") + dtype = dtype or dtypes.float64 + return full(shape, 0, dtype=dtype) + + +def empty_like( + x, dtype: dtypes.CoreType | dtypes.StructType | None = None, device=None +): + dtype = x.dtype if dtype is None else dtype + return full(asarray(x).shape, 0, dtype=dtype) + + +def eye( + n_rows, + n_cols=None, + k=0, + dtype: dtypes.StructType | dtypes.CoreType | None = None, + device=None, +): + dtype = dtype or dtypes.float64 + if n_cols is None: + n_cols = n_rows + n_rows = asarray(n_rows, dtype=dtypes.int64) + n_cols = asarray(n_cols, dtype=dtypes.int64) + n_rows = reshape(n_rows, [-1]) + n_cols = reshape(n_cols, [-1]) + + if not isinstance(n_rows.dtype, CoreType): + raise TypeError("n_rows must be a non-nullable integer array") + + if not isinstance(n_cols.dtype, CoreType): + raise TypeError("n_cols must be a non-nullable integer array") + + shape = concat([n_rows, n_cols]) + dummy = zeros(shape, dtype=dtype) + return _from_corearray(opx.eye_like(dummy._core(), k=k)) + + +def full( + shape, + fill_value, + *, + dtype: dtypes.CoreType | dtypes.StructType | None = None, + device=None, +): + fill_value = asarray(fill_value) + if fill_value.ndim != 0: + raise ValueError("fill_value must be a scalar") + + dtype = fill_value.dtype if dtype is None else dtype + shape = asarray(shape, dtype=dtypes.int64)._core() + return fill_value._transmute(lambda corearray: opx.expand(corearray, shape)).astype( + dtype + ) + + +def full_like( + x, + fill_value, + dtype: dtypes.CoreType | dtypes.StructType | None = None, + device=None, +): + fill_value = asarray(fill_value) + ret = broadcast_to(fill_value, asarray(x).shape) + dtype = x.dtype if dtype is None else dtype + return astype(ret, dtype) + + +def linspace( + start: int | float, + stop: int | float, + num: int, + *, + dtype: dtypes.CoreType | dtypes.StructType | None = None, + device=None, + endpoint: bool = True, +) -> Array: + if device is not None: + raise ValueError("device argument is not supported for linspace") + + return asarray(np.linspace(start, stop, num=num, endpoint=endpoint), dtype=dtype) + + +def ones(shape, dtype: dtypes.CoreType | dtypes.StructType | None = None, device=None): + dtype = dtypes.float64 if dtype is None else dtype + return full(shape, 1, dtype=dtype) + + +def ones_like(x, dtype: dtypes.StructType | dtypes.CoreType | None = None, device=None): + return full_like(x, 1, dtype=dtype) + + +def tril(x, *, k: int = 0) -> Array: + return _from_corearray( + opx.trilu(x._core(), k=asarray(k, dtype=dtypes.int64)._core(), upper=0) + ) + + +def triu(x, *, k: int = 0) -> Array: + return _from_corearray( + opx.trilu(x._core(), k=asarray(k, dtype=dtypes.int64)._core(), upper=1) + ) + + +def zeros(shape, dtype: dtypes.CoreType | dtypes.StructType | None = None, device=None): + dtype = dtypes.float64 if dtype is None else dtype + return full(shape, 0, dtype=dtype) + + +def zeros_like( + x, dtype: dtypes.CoreType | dtypes.StructType | None = None, device=None +): + return full_like(x, 0, dtype=dtype) + + +# data_type.py + + +def astype(x: Array, dtype, copy=True): + if isinstance(dtype, np.dtype): + dtype = dtypes.from_numpy_dtype(dtype) + if x.dtype == dtype: + return x if not copy else x.copy() + if isinstance(x.dtype, CastMixin): + try: + out = x.dtype._cast_to(x, dtype) + if copy: + return out + else: + x._set(out) + return x + except CastError: + pass + if isinstance(dtype, CastMixin): + try: + out = dtype._cast_from(x) + if copy: + return out + else: + x._set(out) + return x + except CastError: + pass + raise CastError(f"Cannot cast {x.dtype} to {dtype}") + + +def can_cast(*args, **kwargs): + return np.can_cast(*args, **kwargs) + + +def finfo(dtype): + return dtypes.get_finfo(dtype) + + +def iinfo(dtype): + return dtypes.get_iinfo(dtype) + + +def isdtype(dtype, kind): + if isinstance(kind, str): + if kind == "bool": + return dtype == dtypes.bool + elif kind == "signed integer": + return dtype in (dtypes.int8, dtypes.int16, dtypes.int32, dtypes.int64) + elif kind == "unsigned integer": + return dtype in (dtypes.uint8, dtypes.uint16, dtypes.uint32, dtypes.uint64) + elif kind == "integral": + return isinstance(dtype, dtypes.Integral) + elif kind == "real floating": + return isinstance(dtype, dtypes.Floating) + elif kind == "complex floating": + raise ValueError("complex floating is not supported") + elif kind == "numeric": + return isinstance(dtype, dtypes.Numerical) + elif isinstance(kind, dtypes.CoreType): + return dtype == kind + elif isinstance(kind, tuple): + return any(isdtype(dtype, k) for k in kind) + else: + raise TypeError(f"kind must be a string or a dtype, not {type(kind)}") + + +def result_type( + *objects: dtypes.CoreType | dtypes.StructType | Array, +) -> dtypes.CoreType | dtypes.StructType: + """Find the common data type for the provided objects.""" + observed_dtypes = {obj.dtype if isinstance(obj, Array) else obj for obj in objects} + nullable = False + np_dtypes = [] + for dtype in observed_dtypes: + if isinstance(dtype, dtypes.StructType): + if isinstance(dtype, _NullableCore): + nullable = True + np_dtypes.append(dtype.values.to_numpy_dtype()) + else: + raise TypeError("result_type is not defined for arbitrary Struct types") + else: + np_dtypes.append(dtype.to_numpy_dtype()) + + ret_dtype = dtypes.from_numpy_dtype(np.result_type(*np_dtypes)) + if nullable: + return dtypes.promote_nullable(ret_dtype) + else: + return ret_dtype + + +# elementwise.py + + +def abs(x): + return _unary("abs", x) + + +def acos(x): + return _unary("acos", x) + + +def acosh(x): + return _unary("acosh", x) + + +def add(x, y): + return _binary("add", x, y) + + +def asin(x): + return _unary("asin", x) + + +def asinh(x): + return _unary("asinh", x) + + +def atan(x): + return _unary("atan", x) + + +def atan2(y, x): + return _binary("atan2", y, x) + + +def atanh(x): + return _unary("atanh", x) + + +def bitwise_and(x, y): + return _binary("bitwise_and", x, y) + + +def bitwise_left_shift(x, y): + return _binary("bitwise_left_shift", x, y) + + +def bitwise_invert(x): + return _unary("bitwise_invert", x) + + +def bitwise_or(x, y): + return _binary("bitwise_or", x, y) + + +def bitwise_right_shift(x, y): + return _binary("bitwise_right_shift", x, y) + + +def bitwise_xor(x, y): + return _binary("bitwise_xor", x, y) + + +def ceil(x): + return _unary("ceil", x) + + +def cos(x): + return _unary("cos", x) + + +def cosh(x): + return _unary("cosh", x) + + +def divide(x, y): + return _binary("divide", x, y) + + +def equal(x, y): + return _binary("equal", x, y) + + +def _binary(func_name, x, y): + x_dtype = asarray(x).dtype + y_dtype = asarray(y).dtype + if (out := getattr(x_dtype._ops, func_name)(x, y)) is not NotImplemented: + return out + if (out := getattr(y_dtype._ops, func_name)(x, y)) is not NotImplemented: + return out + raise TypeError( + f"Unsupported operand type(s) for {func_name}: '{x_dtype}' and '{y_dtype}'" + ) + + +def _unary(func_name, x): + x = asarray(x) + if (out := getattr(x.dtype._ops, func_name)(x)) is not NotImplemented: + return out + raise TypeError(f"Unsupported operand type for {func_name}: '{x.dtype}'") + + +def exp(x): + return _unary("exp", x) + + +def expm1(x): + return subtract(exp(x), 1) + + +def floor(x): + return _unary("floor", x) + + +def floor_divide(x, y): + return _binary("floor_divide", x, y) + + +def greater(x, y): + return _binary("greater", x, y) + + +def greater_equal(x, y): + return _binary("greater_equal", x, y) + + +def isfinite(x): + return logical_not(isinf(x)) + + +def isinf(x): + return _unary("isinf", x) + + +def isnan(x): + return _unary("isnan", x) + + +def less(x, y): + return _binary("less", x, y) + + +def less_equal(x, y): + return _binary("less_equal", x, y) + + +def log(x): + return _unary("log", x) + + +def log1p(x): + return log(x + 1) + + +def log2(x): + return log(x) / np.log(2) + + +def log10(x): + return log(x) / np.log(10) + + +def logaddexp(x, y): + return log(exp(x) + exp(y)) + + +def logical_and(x, y): + return _binary("logical_and", x, y) + + +def logical_not(x): + return _unary("logical_not", x) + + +def logical_or(x, y): + return _binary("logical_or", x, y) + + +def logical_xor(x, y): + return _binary("logical_xor", x, y) + + +def multiply(x, y): + return _binary("multiply", x, y) + + +def negative(x): + return _unary("negative", x) + + +def not_equal(x, y): + return _binary("not_equal", x, y) + + +def positive(x): + return _unary("positive", x) + + +def pow(x, y): + return _binary("pow", x, y) + + +def remainder(x, y): + return _binary("remainder", x, y) + + +def round(x): + return _unary("round", x) + + +def sign(x): + return _unary("sign", x) + + +def sin(x): + return _unary("sin", x) + + +def sinh(x): + return _unary("sinh", x) + + +def square(x): + return multiply(x, x) + + +def sqrt(x): + return _unary("sqrt", x) + + +def subtract(x, y): + return _binary("subtract", x, y) + + +def tan(x): + return _unary("tan", x) + + +def tanh(x): + return _unary("tanh", x) + + +def trunc(x): + return _unary("trunc", x) + + +# linalg.py + + +def matmul(x, y): + return _binary("matmul", x, y) + + +def matrix_transpose(x): + return permute_dims(x, list(range(x.ndim - 2)) + [x.ndim - 1, x.ndim - 2]) + + +# indexing.py + + +def take(x, indices, axis=None): + x = asarray(x) + if (out := x.dtype._ops.take(x, indices, axis)) is not NotImplemented: + return out + if axis is None: + axis = 0 + if isinstance(indices, Array): + indices = indices._core() + else: + indices = opx.const(indices, dtype=dtypes.int64) + return x._transmute(lambda corearray: opx.gather(corearray, indices, axis=axis)) + + +# manipulation.py + + +# TODO: onnx shape inference doesn't work for 2 empty arrays +def broadcast_arrays(*arrays): + if not arrays: + return [] + it = iter(arrays) + + def numeric_like(x): + if isinstance(x.dtype, dtypes.NullableNumerical): + return x + else: + return zeros_like(x) + + ret = numeric_like(next(it)) + while (x := next(it, None)) is not None: + ret = ret + numeric_like(x) + target_shape = _from_corearray(opx.shape(ret._core())) + return [broadcast_to(x, target_shape) for x in arrays] + + +def broadcast_to(x, shape): + x = asarray(x) + if (out := x.dtype._ops.broadcast_to(x, shape)) is not NotImplemented: + return out + shape = asarray(shape, dtype=dtypes.int64)._core() + return x._transmute(lambda corearray: opx.expand(corearray, shape)) + + +# TODO: onnxruntime doesn't work for 2 empty arrays of integer type +def concat(arrays, axis=None): + if axis is None: + arrays = [reshape(x, [-1]) for x in arrays] + axis = 0 + arrays = promote(*arrays) + # TODO: implement this as a layout operation agnostic of input types + return _from_corearray(opx.concat([array._core() for array in arrays], axis=axis)) + + +def expand_dims(x, axis=0): + x = asarray(x) + if (out := x.dtype._ops.expand_dims(x, axis)) is not NotImplemented: + return out + return x._transmute( + lambda corearray: opx.unsqueeze( + corearray, axes=opx.const([axis], dtype=dtypes.int64) + ) + ) + + +def flip(x, axis=None): + if (out := x.dtype._ops.flip(x, axis)) is not NotImplemented: + return out + + if x.ndim == 0: + return x.copy() + + if axis is None: + axis = range(x.ndim) + elif not isinstance(axis, Iterable): + axis = [axis] + + axis = [x.ndim + ax if ax < 0 else ax for ax in axis] + + index = tuple( + slice(None, None, None) if i not in axis else (slice(None, None, -1)) + for i in range(0, x.ndim) + ) + + return x[index] + + +def permute_dims(x, axes): + if (out := x.dtype._ops.permute_dims(x, axes)) is not NotImplemented: + return out + return x._transmute(lambda corearray: opx.transpose(corearray, perm=axes)) + + +def reshape(x, shape, *, copy=None): + if ( + isinstance(shape, (list, tuple)) + and len(shape) == x.ndim == 1 + and shape[0] == -1 + ): + return x.copy() + else: + x = asarray(x) + if (out := x.dtype._ops.reshape(x, shape, copy=copy)) is not NotImplemented: + return out + shape = asarray(shape, dtype=dtypes.int64)._core() + out = x._transmute(lambda corearray: opx.reshape(corearray, shape)) + if copy is False: + return x._set(out) + return out + + +def roll(x, shift, axis=None): + x = asarray(x) + if (out := x.dtype._ops.roll(x, shift, axis)) is not NotImplemented: + return out + if not isinstance(shift, Sequence): + shift = [shift] + + old_shape = x.shape + + if axis is None: + x = reshape(x, [-1]) + axis = 0 + + if not isinstance(axis, Sequence): + axis = [axis] + + if len(shift) != len(axis): + raise ValueError("shift and axis must have the same length") + + for sh, ax in zip(shift, axis): + len_single = opx.gather( + asarray(x.shape, dtype=dtypes.int64)._core(), opx.const(ax) + ) + shift_single = opx.add(opx.const(-sh, dtype=dtypes.int64), len_single) + # Find the needed element index and then gather from it + range = opx.cast( + opx.range( + opx.const(0, dtype=len_single.dtype), + len_single, + opx.const(1, dtype=len_single.dtype), + ), + to=dtypes.int64, + ) + new_indices = opx.mod(opx.add(range, shift_single), len_single) + x = take(x, _from_corearray(new_indices), axis=ax) + + return reshape(x, old_shape) + + +def squeeze(x, axis): + x = asarray(x) + if (out := x.dtype._ops.squeeze(x, axis)) is not NotImplemented: + return out + axis = [axis] if not isinstance(axis, Sequence) else axis + if len(axis) == 0: + return x.copy() + axes = opx.const(axis, dtype=dtypes.int64) + return x._transmute(lambda corearray: opx.squeeze(corearray, axes=axes)) + + +def stack(arrays, axis=0): + arrays = [expand_dims(x, axis=axis) for x in arrays] + return concat(arrays, axis=axis) + + +# searching.py + + +def argmax(x, axis=None, keepdims=False): + if ( + out := x.dtype._ops.argmax(x, axis=axis, keepdims=keepdims) + ) is not NotImplemented: + return out + raise TypeError(f"Unsupported operand type for argmax: '{x.dtype}'") + + +def argmin(x, axis=None, keepdims=False): + if ( + out := x.dtype._ops.argmax(x, axis=axis, keepdims=keepdims) + ) is not NotImplemented: + return out + raise TypeError(f"Unsupported operand type for argmin: '{x.dtype}'") + + +def nonzero(x): + return _unary("nonzero", x) + + +def searchsorted( + x1, x2, *, side: Literal["left", "right"] = "left", sorter: Array | None = None +): + if ( + out := x1.dtype._ops.searchsorted(x1, x2, side=side, sorter=sorter) + ) is not NotImplemented: + return out + raise TypeError(f"Unsupported operand type for searchsorted: '{x1.dtype}'") + + +def where(condition, x, y): + if (out := condition.dtype._ops.where(condition, x, y)) is not NotImplemented: + return out + raise TypeError(f"Unsupported condition dtype for where: '{condition.dtype}'") + + +# set.py +def unique_all(x: Array): + return _unary("unique_all", x) + + +def unique_counts(x): + ret = namedtuple("ret", ["values", "counts"]) + ret_all = unique_all(x) + return ret(values=ret_all.values, counts=ret_all.counts) + + +def unique_inverse(x): + ret = namedtuple("ret", ["values", "inverse_indices"]) + ret_all = unique_all(x) + return ret(values=ret_all.values, inverse_indices=ret_all.inverse_indices) + + +def unique_values(x): + return unique_all(x).values + + +# sorting.py + + +def argsort(x, *, axis=-1, descending=False, stable=True): + if ( + out := x.dtype._ops.argsort(x, axis=axis, descending=descending, stable=stable) + ) is not NotImplemented: + return out + raise TypeError(f"Unsupported operand type for argsort: '{x.dtype}'") + + +def sort(x, *, axis=-1, descending=False, stable=True): + if ( + out := x.dtype._ops.sort(x, axis=axis, descending=descending, stable=stable) + ) is not NotImplemented: + return out + raise TypeError(f"Unsupported operand type for sort: '{x.dtype}'") + + +# statistical.py +def cumulative_sum( + x, + *, + axis: int | None = None, + dtype: CoreType | StructType | None = None, + include_initial: bool = False, +): + if ( + out := x.dtype._ops.cumulative_sum( + x, axis=axis, dtype=dtype, include_initial=include_initial + ) + ) is not NotImplemented: + return out + raise TypeError(f"Unsupported operand type for cumulative_sum: '{x.dtype}'") + + +def max(x, *, axis=None, keepdims: bool = False): + if (out := x.dtype._ops.max(x, axis=axis, keepdims=keepdims)) is not NotImplemented: + return out + raise TypeError(f"Unsupported operand type for max: '{x.dtype}'") + + +def mean(x, *, axis=None, keepdims: bool = False): + if ( + out := x.dtype._ops.mean(x, axis=axis, keepdims=keepdims) + ) is not NotImplemented: + return out + raise TypeError(f"Unsupported operand type for max: '{x.dtype}'") + + +def min(x, *, axis=None, keepdims: bool = False): + if (out := x.dtype._ops.min(x, axis=axis, keepdims=keepdims)) is not NotImplemented: + return out + raise TypeError(f"Unsupported operand type for max: '{x.dtype}'") + + +def prod( + x, *, axis=None, dtype: CoreType | StructType | None = None, keepdims: bool = False +): + if ( + out := x.dtype._ops.prod(x, dtype=dtype, axis=axis, keepdims=keepdims) + ) is not NotImplemented: + return out + raise TypeError(f"Unsupported operand type for prod: '{x.dtype}'") + + +def clip(x, *, min=None, max=None): + if (out := x.dtype._ops.clip(x, min=min, max=max)) is not NotImplemented: + return out + raise TypeError(f"Unsupported operand type for clip: '{x.dtype}'") + + +def std( + x, + axis=None, + keepdims: bool = False, + correction=0.0, + dtype: dtypes.StructType | dtypes.CoreType | None = None, +): + dtype = x.dtype if dtype is None else dtype + return sqrt( + var(x, axis=axis, keepdims=keepdims, correction=correction, dtype=dtype) + ) + + +def sum( + x, + *, + axis=None, + dtype: dtypes.StructType | dtypes.CoreType | None = None, + keepdims: bool = False, +): + if ( + out := x.dtype._ops.sum(x, axis=axis, dtype=dtype, keepdims=keepdims) + ) is not NotImplemented: + return out + raise TypeError(f"Unsupported operand type for sum: '{x.dtype}'") + + +def var( + x, + *, + axis=None, + keepdims: bool = False, + correction=0.0, + dtype: dtypes.CoreType | dtypes.StructType | None = None, +): + dtype = x.dtype if dtype is None else dtype + if not isinstance(dtype, CoreType): + raise TypeError("var is not supported for non-core types") + # We keepdims, so it is still broadcastable to x + mean_ = mean(x, axis=axis, keepdims=True).astype(dtype) + + return sum(square(x - mean_), axis=axis, keepdims=keepdims).astype(dtype) / ( + sum(full_like(x, 1), axis=axis, keepdims=keepdims).astype(dtype) - correction + ) + + +# utility.py + + +def all(x, *, axis=None, keepdims: bool = False): + if isinstance(x.dtype, dtypes._NullableCore): + x = where(x.null, True, x.values) + if functools.reduce(operator.mul, x._static_shape, 1) == 0: + return asarray(True, dtype=dtypes.bool) + return min(x.astype(dtypes.int8), axis=axis, keepdims=keepdims).astype(dtypes.bool) + + +def any(x, *, axis=None, keepdims: bool = False): + if isinstance(x.dtype, dtypes._NullableCore): + x = where(x.null, False, x.values) + if functools.reduce(operator.mul, x._static_shape, 1) == 0: + return asarray(False, dtype=dtypes.bool) + return max(x.astype(dtypes.int8), axis=axis, keepdims=keepdims).astype(dtypes.bool) + + +__all__ = [ + "arange", + "asarray", + "empty", + "empty_like", + "eye", + "full", + "full_like", + "linspace", + "ones", + "ones_like", + "tril", + "triu", + "zeros", + "zeros_like", + "astype", + "broadcast_arrays", + "broadcast_to", + "can_cast", + "finfo", + "iinfo", + "result_type", + "abs", + "acos", + "acosh", + "add", + "asin", + "asinh", + "atan", + "atan2", + "atanh", + "bitwise_and", + "bitwise_left_shift", + "bitwise_invert", + "bitwise_or", + "bitwise_right_shift", + "bitwise_xor", + "ceil", + "cos", + "cosh", + "divide", + "equal", + "exp", + "expm1", + "floor", + "floor_divide", + "greater", + "greater_equal", + "isfinite", + "isinf", + "isnan", + "less", + "less_equal", + "log", + "log1p", + "log2", + "log10", + "logaddexp", + "logical_and", + "logical_not", + "logical_or", + "logical_xor", + "multiply", + "negative", + "not_equal", + "positive", + "pow", + "remainder", + "round", + "sign", + "sin", + "sinh", + "square", + "sqrt", + "subtract", + "tan", + "tanh", + "trunc", + "matmul", + "matrix_transpose", + "concat", + "expand_dims", + "flip", + "permute_dims", + "reshape", + "roll", + "squeeze", + "stack", + "argmax", + "argmin", + "nonzero", + "searchsorted", + "where", + "unique_all", + "unique_counts", + "unique_inverse", + "unique_values", + "argsort", + "sort", + "cumulative_sum", + "max", + "mean", + "min", + "prod", + "clip", + "std", + "sum", + "var", + "all", + "any", + "take", +] + +for func_name in __all__: + locals()[ + func_name + ].__doc__ = f"``{func_name}`` is inherited from the Array API standard. Documentation can be found `here `__." diff --git a/ndonnx/_index.py b/ndonnx/_index.py new file mode 100644 index 0000000..59aefdd --- /dev/null +++ b/ndonnx/_index.py @@ -0,0 +1,64 @@ +# Copyright (c) QuantCo 2023-2024 +# SPDX-License-Identifier: LicenseRef-QuantCo + +from collections.abc import Iterable +from typing import TypeVar, Union + +import numpy as np + +from ._utility import get_rank + +ellipsis = TypeVar("ellipsis") +ScalarIndexType = Union[int, bool, slice, ellipsis, None] + + +def index_normalise(a: Iterable[ScalarIndexType]) -> tuple[ScalarIndexType, ...]: + ret: list[ScalarIndexType] = [] + for x in a: + # x: Union[int, bool, slice, None] + if isinstance(x, (int, bool)): + ret.append(x) + elif isinstance(x, slice): + INDEX_MIN: int = np.iinfo(np.int64).min + INDEX_MAX: int = np.iinfo(np.int64).max + start = ( + x.start + if x.start is not None + else (0 if x.step is None or x.step > 0 else INDEX_MAX) + ) + stop = ( + x.stop + if x.stop is not None + else (INDEX_MAX if x.step is None or x.step > 0 else INDEX_MIN) + ) + step = x.step if x.step is not None else 1 + + if start == 0 and stop == INDEX_MAX and step == 1: + ret.append(slice(None, None, None)) + else: + ret.append(slice(start, stop, step)) + elif x is None: + ret.append(x) + else: + # ellipses are expected to be handled prior to this function call + raise TypeError(f"Index {x} for type {type(x)} not supported") + + return tuple(ret) + + +def construct_index( + arr, index: ScalarIndexType | tuple[ScalarIndexType, ...] +) -> tuple[ScalarIndexType, ...]: + index_ = index if isinstance(index, tuple) else (index,) + if any(i is Ellipsis for i in index_): + rank = get_rank(arr) + ellipsis_position = index_.index(Ellipsis) + count_some = len( + [x for x in index_ if not isinstance(x, (type(None), type(Ellipsis)))] + ) + index_ = ( + index_[:ellipsis_position] + + tuple([slice(None, None, None)] * (rank - count_some)) + + index_[ellipsis_position + 1 :] + ) + return index_normalise(index_) diff --git a/ndonnx/_opset_extensions.py b/ndonnx/_opset_extensions.py new file mode 100644 index 0000000..45a28c2 --- /dev/null +++ b/ndonnx/_opset_extensions.py @@ -0,0 +1,753 @@ +# Copyright (c) QuantCo 2023-2024 +# SPDX-License-Identifier: LicenseRef-QuantCo +from __future__ import annotations + +import builtins +import typing +from collections.abc import Mapping +from typing import TypeVar + +import numpy as np +import spox.opset.ai.onnx.ml.v4 as ml +import spox.opset.ai.onnx.v20 as op +from spox import Var +from spox._internal_op import unsafe_reshape + +import ndonnx._data_types as dtypes + +from ._corearray import _CoreArray +from ._index import ScalarIndexType +from ._propagation import eager_propagate +from ._utility import get_dtype, get_rank, get_shape + +if typing.TYPE_CHECKING: + from ndonnx._data_types.coretype import CoreType + +ellipsis = TypeVar("ellipsis") + + +KeyType = TypeVar("KeyType", int, str, float) +ValueType = TypeVar("ValueType", int, str, float) + + +@eager_propagate +def add(x: _CoreArray, y: _CoreArray) -> _CoreArray: + return _CoreArray( + op.add(x.var, y.var), + ) + + +@eager_propagate +def string_concat(x: _CoreArray, y: _CoreArray) -> _CoreArray: + return _CoreArray( + op.string_concat(x.var, y.var), + ) + + +@eager_propagate +def expand(input: _CoreArray, shape: _CoreArray) -> _CoreArray: + return _CoreArray( + op.expand(input.var, shape.var), + ) + + +@eager_propagate +def asin(x: _CoreArray) -> _CoreArray: + return _CoreArray(op.asin(x.var)) + + +@eager_propagate +def range(start: _CoreArray, limit: _CoreArray, delta: _CoreArray) -> _CoreArray: + return _CoreArray(op.range(start.var, limit.var, delta.var)) + + +@eager_propagate +def asinh(x: _CoreArray) -> _CoreArray: + return _CoreArray(op.asinh(x.var)) + + +@eager_propagate +def atan(x: _CoreArray) -> _CoreArray: + return _CoreArray(op.atan(x.var)) + + +@eager_propagate +def atanh(x: _CoreArray) -> _CoreArray: + return _CoreArray(op.atanh(x.var)) + + +@eager_propagate +def or_(x: _CoreArray, y: _CoreArray) -> _CoreArray: + return _CoreArray(op.or_(x.var, y.var)) + + +@eager_propagate +def mul(x: _CoreArray, y: _CoreArray) -> _CoreArray: + return _CoreArray(op.mul(x.var, y.var)) + + +@eager_propagate +def cast(x: _CoreArray, to: CoreType) -> _CoreArray: + return _CoreArray( + op.cast(x.var, to=to.to_numpy_dtype()), + ) + + +@eager_propagate +def shape(x: _CoreArray, *, end: int | None = None, start: int = 0) -> _CoreArray: + return _CoreArray(op.shape(x.var, end=end, start=start)) + + +@eager_propagate +def top_k( + x: _CoreArray, k: _CoreArray, *, axis: int = -1, largest: int = 1, sorted: int = 1 +) -> tuple[_CoreArray, _CoreArray]: + values, indices = op.top_k(x.var, k.var, axis=axis, largest=largest, sorted=sorted) + return _CoreArray(values), _CoreArray(indices) + + +@eager_propagate +def where(cond: _CoreArray, x: _CoreArray, y: _CoreArray) -> _CoreArray: + return _CoreArray(op.where(cond.var, x.var, y.var)) + + +@eager_propagate +def not_(x: _CoreArray) -> _CoreArray: + return _CoreArray(op.not_(x.var)) + + +@eager_propagate +def eye_like( + input: _CoreArray, *, dtype: CoreType | None = None, k: int = 0 +) -> _CoreArray: + return _CoreArray( + op.eye_like( + input.var, dtype=dtype if dtype is None else dtype.to_numpy_dtype(), k=k + ) + ) + + +@eager_propagate +def gather_elements( + data: _CoreArray, indices: _CoreArray, *, axis: int = 0 +) -> _CoreArray: + return _CoreArray(op.gather_elements(data.var, indices.var, axis=axis)) + + +@eager_propagate +def equal(x: _CoreArray, y: _CoreArray) -> _CoreArray: + return _CoreArray(op.equal(x.var, y.var)) + + +@eager_propagate +def reshape(x: _CoreArray, shape: _CoreArray) -> _CoreArray: + return _CoreArray(op.reshape(x.var, shape.var)) + + +@eager_propagate +def mod(x: _CoreArray, y: _CoreArray, fmod: int = 0) -> _CoreArray: + return _CoreArray(op.mod(x.var, y.var, fmod=fmod)) + + +@eager_propagate +def pow(x: _CoreArray, y: _CoreArray) -> _CoreArray: + return _CoreArray(op.pow(x.var, y.var)) + + +@eager_propagate +def div(x: _CoreArray, y: _CoreArray) -> _CoreArray: + return _CoreArray(op.div(x.var, y.var)) + + +@eager_propagate +def sub(x: _CoreArray, y: _CoreArray) -> _CoreArray: + return _CoreArray(op.sub(x.var, y.var)) + + +@eager_propagate +def ceil(x: _CoreArray) -> _CoreArray: + return _CoreArray(op.ceil(x.var)) + + +@eager_propagate +def transpose(x: _CoreArray, perm: list[int]) -> _CoreArray: + return _CoreArray(op.transpose(x.var, perm=perm)) + + +@eager_propagate +def const(value, dtype: CoreType | None = None) -> _CoreArray: + np_dtype = dtype.to_numpy_dtype() if dtype is not None else None + return _CoreArray( + np.array(value, dtype=np_dtype), + ) + + +@eager_propagate +def squeeze(data: _CoreArray, axes: _CoreArray | None = None) -> _CoreArray: + if axes is not None and axes.dtype != dtypes.int64: + raise ValueError(f"Expected axes to be of type int64, got {axes.dtype}") + return _CoreArray(op.squeeze(data.var, axes=axes.var if axes is not None else None)) + + +@eager_propagate +def abs(x: _CoreArray) -> _CoreArray: + return _CoreArray(op.abs(x.var)) + + +@eager_propagate +def sin(x: _CoreArray) -> _CoreArray: + return _CoreArray(op.sin(x.var)) + + +@eager_propagate +def cos(x: _CoreArray) -> _CoreArray: + return _CoreArray(op.cos(x.var)) + + +@eager_propagate +def log(x: _CoreArray) -> _CoreArray: + return _CoreArray(op.log(x.var)) + + +@eager_propagate +def exp(x: _CoreArray) -> _CoreArray: + return _CoreArray(op.exp(x.var)) + + +@eager_propagate +def tan(x: _CoreArray) -> _CoreArray: + return _CoreArray(op.tan(x.var)) + + +@eager_propagate +def acos(x: _CoreArray) -> _CoreArray: + return _CoreArray(op.acos(x.var)) + + +@eager_propagate +def neg(x: _CoreArray) -> _CoreArray: + return _CoreArray(op.neg(x.var)) + + +@eager_propagate +def sqrt(x: _CoreArray) -> _CoreArray: + return _CoreArray(op.sqrt(x.var)) + + +@eager_propagate +def floor(x: _CoreArray) -> _CoreArray: + return _CoreArray(op.floor(x.var)) + + +@eager_propagate +def tanh(x: _CoreArray) -> _CoreArray: + return _CoreArray(op.tanh(x.var)) + + +@eager_propagate +def sinh(x: _CoreArray) -> _CoreArray: + return _CoreArray(op.sinh(x.var)) + + +@eager_propagate +def cosh(x: _CoreArray) -> _CoreArray: + return _CoreArray(op.cosh(x.var)) + + +@eager_propagate +def round(x: _CoreArray) -> _CoreArray: + return _CoreArray(op.round(x.var)) + + +@eager_propagate +def less(x: _CoreArray, y: _CoreArray) -> _CoreArray: + return _CoreArray(op.less(x.var, y.var)) + + +@eager_propagate +def less_or_equal(x: _CoreArray, y: _CoreArray) -> _CoreArray: + return _CoreArray(op.less_or_equal(x.var, y.var)) + + +@eager_propagate +def greater(x: _CoreArray, y: _CoreArray) -> _CoreArray: + return _CoreArray(op.greater(x.var, y.var)) + + +@eager_propagate +def greater_or_equal(x: _CoreArray, y: _CoreArray) -> _CoreArray: + return _CoreArray(op.greater_or_equal(x.var, y.var)) + + +@eager_propagate +def isnan(x: _CoreArray) -> _CoreArray: + return _CoreArray(op.isnan(x.var)) + + +@eager_propagate +def isinf(x: _CoreArray) -> _CoreArray: + return _CoreArray(op.isinf(x.var)) + + +@eager_propagate +def reduce_sum( + data: _CoreArray, axes: _CoreArray, keepdims: int = 1, noop_with_empty_axes: int = 0 +) -> _CoreArray: + return _CoreArray( + op.reduce_sum( + data.var, + axes.var, + keepdims=keepdims, + noop_with_empty_axes=noop_with_empty_axes, + ) + ) + + +@eager_propagate +def reduce_min( + data: _CoreArray, axes: _CoreArray, keepdims: int = 1, noop_with_empty_axes: int = 0 +) -> _CoreArray: + return _CoreArray( + op.reduce_min( + data.var, + axes.var, + keepdims=keepdims, + noop_with_empty_axes=noop_with_empty_axes, + ) + ) + + +@eager_propagate +def reduce_max( + data: _CoreArray, axes: _CoreArray, keepdims: int = 1, noop_with_empty_axes: int = 0 +) -> _CoreArray: + return _CoreArray( + op.reduce_max( + data.var, + axes.var, + keepdims=keepdims, + noop_with_empty_axes=noop_with_empty_axes, + ) + ) + + +@eager_propagate +def reduce_mean( + data: _CoreArray, axes: _CoreArray, keepdims: int = 1, noop_with_empty_axes: int = 0 +) -> _CoreArray: + return _CoreArray( + op.reduce_mean( + data.var, + axes.var, + keepdims=keepdims, + noop_with_empty_axes=noop_with_empty_axes, + ) + ) + + +@eager_propagate +def reduce_prod( + data: _CoreArray, axes: _CoreArray, keepdims: int = 1, noop_with_empty_axes: int = 0 +) -> _CoreArray: + return _CoreArray( + op.reduce_prod( + data.var, + axes.var, + keepdims=keepdims, + noop_with_empty_axes=noop_with_empty_axes, + ) + ) + + +@eager_propagate +def concat(inputs: list[_CoreArray], axis: int) -> _CoreArray: + return _CoreArray(op.concat([x.var for x in inputs], axis=axis)) + + +@eager_propagate +def unsqueeze(data: _CoreArray, axes: _CoreArray) -> _CoreArray: + if axes.dtype != dtypes.int64: + raise TypeError(f"axes must be int64, got {axes.dtype}") + return _CoreArray(op.unsqueeze(data.var, axes.var)) + + +@eager_propagate +def trilu(x: _CoreArray, *, k: _CoreArray | None = None, upper: int = 0) -> _CoreArray: + return _CoreArray(op.trilu(x.var, k.var if k is not None else None, upper=upper)) + + +@eager_propagate +def unique( + x: _CoreArray, axis: int | None = None, sorted: int = 1 +) -> tuple[_CoreArray, _CoreArray, _CoreArray, _CoreArray]: + y, indices, inverse_indices, counts = op.unique(x.var, axis=axis, sorted=sorted) + return ( + _CoreArray(y), + _CoreArray(indices), + _CoreArray(inverse_indices), + _CoreArray(counts), + ) + + +@eager_propagate +def and_(x: _CoreArray, y: _CoreArray) -> _CoreArray: + return _CoreArray(op.and_(x.var, y.var)) + + +@eager_propagate +def gather(data: _CoreArray, indices: _CoreArray, axis: int = 0) -> _CoreArray: + return _CoreArray(op.gather(data.var, indices.var, axis=axis)) + + +@eager_propagate +def cumsum( + x: _CoreArray, axis: _CoreArray, exclusive: int = 0, reverse: int = 0 +) -> _CoreArray: + return _CoreArray( + op.cumsum(x.var, axis=axis.var, exclusive=exclusive, reverse=reverse) + ) + + +@eager_propagate +def split( + input: _CoreArray, + split: _CoreArray | None = None, + *, + num_outputs: int, + axis: int = 0, +) -> tuple[_CoreArray, ...]: + return tuple( + map( + _CoreArray, + op.split( + input.var, + split.var if split is not None else None, + num_outputs=num_outputs, + axis=axis, + ), + ) + ) + + +@eager_propagate +def clip(input: _CoreArray, min: _CoreArray, max: _CoreArray) -> _CoreArray: + return _CoreArray(op.clip(input.var, min.var, max.var)) + + +@eager_propagate +def matmul(a: _CoreArray, b: _CoreArray) -> _CoreArray: + return _CoreArray(op.matmul(a.var, b.var)) + + +@eager_propagate +def arg_max( + data: _CoreArray, *, axis: int = 0, keepdims: int = 1, select_last_index: int = 0 +) -> _CoreArray: + return _CoreArray( + op.arg_max( + data.var, axis=axis, keepdims=keepdims, select_last_index=select_last_index + ) + ) + + +@eager_propagate +def arg_min( + data: _CoreArray, *, axis: int = 0, keepdims: int = 1, select_last_index: int = 0 +) -> _CoreArray: + return _CoreArray( + op.arg_min( + data.var, axis=axis, keepdims=keepdims, select_last_index=select_last_index + ) + ) + + +@eager_propagate +def bitwise_and(x: _CoreArray, y: _CoreArray) -> _CoreArray: + return _CoreArray(op.bitwise_and(x.var, y.var)) + + +@eager_propagate +def bitwise_or(x: _CoreArray, y: _CoreArray) -> _CoreArray: + return _CoreArray(op.bitwise_or(x.var, y.var)) + + +@eager_propagate +def bitwise_xor(x: _CoreArray, y: _CoreArray) -> _CoreArray: + return _CoreArray(op.bitwise_xor(x.var, y.var)) + + +@eager_propagate +def bitwise_not(x: _CoreArray) -> _CoreArray: + return _CoreArray(op.bitwise_not(x.var)) + + +@eager_propagate +def bit_shift(x: _CoreArray, y: _CoreArray, *, direction: str) -> _CoreArray: + return _CoreArray(op.bit_shift(x.var, y.var, direction=direction)) + + +@eager_propagate +def xor(x: _CoreArray, y: _CoreArray) -> _CoreArray: + return _CoreArray(op.xor(x.var, y.var)) + + +@eager_propagate +def acosh(x: _CoreArray) -> _CoreArray: + return _CoreArray(op.acosh(x.var)) + + +@eager_propagate +def getitem_null(corearray: _CoreArray, index: _CoreArray) -> _CoreArray: + # Compress doesn't compress in case of scalars + # A solution that works is to transform + # var -> [var] + # index -> [index] + + var = corearray.var + if get_rank(index) == 0: + + def extend_shape(x: Var) -> Var: + return op.concat([op.const([1], dtype=np.int64), op.shape(x)], axis=0) + + var = op.reshape(var, extend_shape(var), allowzero=True) + index_var = op.reshape(index.var, extend_shape(index.var), allowzero=True) + return _CoreArray(op.compress(var, index_var, axis=0)) + + else: + if get_rank(index) == 1: + reshaped_var, reshaped_index = var, index.var + else: + ret_shape = op.concat( + [op.const([-1], dtype=np.int64), op.shape(var, start=get_rank(index))], + axis=0, + ) + reshaped_var = op.reshape(var, ret_shape, allowzero=True) + reshaped_index = op.reshape(index.var, op.const([-1]), allowzero=True) + + return _CoreArray( + op.compress( + unsafe_reshape( + reshaped_var, + tuple( + None + for _ in builtins.range(get_rank(var) - get_rank(index) + 1) + ), + ), + reshaped_index, + axis=0, + ) + ) + + +@eager_propagate +def getitem( + corearray: _CoreArray, + index: tuple[ScalarIndexType, ...] | _CoreArray, +) -> _CoreArray: + if isinstance(index, _CoreArray): + if get_dtype(index) == np.bool_: + if get_rank(corearray) < get_rank(index): + raise IndexError("Indexing with boolean array cannot happen") + return getitem_null(corearray, index) + else: + return _CoreArray(op.gather(corearray.var, index.var, axis=0)) + elif len(index) == 0: + return corearray.copy() + elif all(isinstance(i, bool) for i in index): + index = typing.cast(tuple[bool, ...], index) + return getitem( + corearray, + _CoreArray(op.const(index) if len(index) > 1 else op.const(index[0])), + ) + # index is a tuple of scalars + index_some = [x for x in index if x is not None] + + axis_slices = [ + (x.start, x.stop, x.step, ind) + for ind, x in enumerate(index_some) + if isinstance(x, slice) and x.step is not None + ] + var = corearray.var + if axis_slices: + ndim = get_rank(var) + var = op.slice( + var, + op.const(np.array([x[0] for x in axis_slices], np.int64)), + op.const(np.array([x[1] for x in axis_slices], np.int64)), + op.const(np.array([x[3] for x in axis_slices], np.int64)), + op.const(np.array([x[2] for x in axis_slices], np.int64)), + ) + + # TODO: onnx should be fixing this + var = unsafe_reshape(var, tuple(None for i in builtins.range(ndim))) + + axis_indices = [(ind, x) for ind, x in enumerate(index_some) if isinstance(x, int)] + for axis, axis_index in reversed(axis_indices): + var = op.gather(var, op.const(axis_index), axis=axis) + + index_filtered = [x for x in index if isinstance(x, (type(None), slice))] + axis_new_axes = [ind for ind, x in enumerate(index_filtered) if x is None] + if len(axis_new_axes) != 0: + var = op.unsqueeze(var, axes=op.const(axis_new_axes, dtype=np.int64)) + + return _CoreArray(var) + + +@eager_propagate +def setitem( + corearray: _CoreArray, index: tuple | _CoreArray, updates: _CoreArray +) -> _CoreArray: + if get_rank(corearray) == 0 and isinstance(index, tuple): + return updates + elif get_rank(corearray) == 0 and isinstance(index, Var): + return _CoreArray( + op.if_( + index, + then_branch=lambda: [updates.var], + else_branch=lambda: [corearray.var], + )[0] + ) + + var = corearray.var + indices = getitem(ndindex(_CoreArray(op.shape(var))), index) + + # broadcast updates as appropriate + index_path_shape = op.slice( + op.shape(indices.var), + op.const([0], dtype=np.int64), + op.const([-1], dtype=np.int64), + ) + return _CoreArray( + op.scatter_nd(var, indices.var, op.expand(updates.var, index_path_shape)) + ) + + +@eager_propagate +def ndindex(shape: _CoreArray, to_reverse=None, axes_permutation=None) -> _CoreArray: + """ + Returns a tensor of shape `shape`, where each element is its index in the tensor + Parameters: + shape: the shape of the tensor + to_reverse: a list of axes to reverse + axes_permutation: a permutation of the axes + Returns: + A tensor of shape `shape`, where each element is its index in the tensor + """ + if to_reverse is None: + to_reverse = [] + (rank,) = get_shape(shape.var) + + if not isinstance(rank, int): + raise ValueError("rank must be a constant integer") + + if rank == 0: + return const([], dtype=dtypes.int64) + + if axes_permutation is None: + axes_indices = list(builtins.range(rank)) + else: + axes_indices = [axes_permutation.index(i) for i in builtins.range(rank)] + + shape_var = shape.var + dtype = shape_var.unwrap_tensor().dtype + ranges = [ + ( + op.range( + op.const(0, dtype=dtype), + op.gather(shape_var, op.const(i)), + op.const(1, dtype=dtype), + ) + if i not in to_reverse + else op.range( + op.sub(op.gather(shape_var, op.const(i)), op.const(1, dtype=dtype)), + op.const(-1, dtype=dtype), + op.const(-1, dtype=dtype), + ) + ) + for i in builtins.range(rank) + ] + + fit_ranges = [ + op.unsqueeze( + r, + op.const( + [j for j in builtins.range(rank) if axes_indices[i] != j], + dtype=np.int64, + ), + ) + for i, r in enumerate(ranges) + ] + + if axes_permutation is not None: + shape_var = op.gather(shape_var, op.const(axes_permutation)) + + expanded_ranges = [op.expand(r, shape_var) for r in fit_ranges] + + ret = op.concat( + [op.unsqueeze(r, op.const([-1], dtype=np.int64)) for r in expanded_ranges], + axis=-1, + ) + + return _CoreArray(ret) + + +@eager_propagate +def reshape_like(x: _CoreArray, y: _CoreArray) -> _CoreArray: + x_var, y_var = x.var, y.var + return _CoreArray( + unsafe_reshape( + op.reshape(x_var, op.shape(y_var)), + [x.to_simple() for x in y_var.unwrap_tensor()._shape], # type: ignore + ) + ) + + +@eager_propagate +def static_map( + input: _CoreArray, mapping: Mapping[KeyType, ValueType], default: ValueType | None +) -> _CoreArray: + keys = np.array(tuple(mapping.keys())) + if keys.dtype == np.int32: + keys = keys.astype(np.int64) + values = np.array(tuple(mapping.values())) + value_dtype = values.dtype + if default is None: + if value_dtype == object: + default_tensor = np.array(["MISSING"]) + else: + default_tensor = np.array([0], dtype=value_dtype) + else: + default_tensor = np.array([default], dtype=value_dtype) + + if keys.dtype == np.float64 and isinstance(input.dtype, dtypes.Integral): + input = cast(input, dtypes.from_numpy_dtype(keys.dtype)) + elif keys.dtype == np.int64 and isinstance(input.dtype, dtypes.Floating): + keys = keys.astype(input.dtype.to_numpy_dtype()) + return _CoreArray( + ml.label_encoder( + input.var, + keys_tensor=keys, + values_tensor=values, + default_tensor=default_tensor, + ) + ) + + +@eager_propagate +def get_indices( + x: _CoreArray, y: _CoreArray, positions: _CoreArray +) -> tuple[_CoreArray, _CoreArray]: + """Given a position array representing the positions of x concatenated to those of + y, this function extracts the original positions back out as two tensors.""" + split_pos = shape(x) + split_pos_var = split_pos.var + positions_var = positions.var + indices_x = op.reshape( + op.slice(positions_var, op.const([0], dtype=np.int64), split_pos_var), + op.const([-1], dtype=np.int64), + ) + indices_y = op.reshape( + op.slice(positions_var, split_pos_var, op.const([np.iinfo(np.int64).max])), + op.const([-1], dtype=np.int64), + ) + return _CoreArray(indices_x), _CoreArray(indices_y) diff --git a/ndonnx/_propagation.py b/ndonnx/_propagation.py new file mode 100644 index 0000000..5a5591b --- /dev/null +++ b/ndonnx/_propagation.py @@ -0,0 +1,209 @@ +# Copyright (c) QuantCo 2023-2024 +# SPDX-License-Identifier: LicenseRef-QuantCo + +from __future__ import annotations + +import warnings +from collections import namedtuple +from pathlib import Path + +import numpy as np +import spox +import spox.opset.ai.onnx.v19 as op + +import ndonnx as ndx + +from ._corearray import _CoreArray + +Arguments = namedtuple("Arguments", ["args", "kwargs"]) +LazyEagerPair = namedtuple("LazyEagerPair", ["lazy", "value"]) + +try: + import onnxruntime as ort + + ORT_PRESENT = True +except ImportError: + ORT_PRESENT = False + warnings.warn( + "onnxruntime not found. Eager propagation and constant folding optimizations will be disabled." + ) + + +def eager_propagate(fn): + def wrapper(*args, **kwargs): + return _eager_propagate_with_custom_operators(None)(fn)(*args, **kwargs) + + return wrapper + + +def _eager_propagate_with_custom_operators(custom_operators_path: Path | None): + def decorator(fn): + def wrapper(*args, **kwargs): + constant_inputs, lazy_args, flattened_inference_inputs = ( + _aggregate_arguments(Arguments(args, kwargs)) + ) + outputs = fn(*args, **kwargs) + if constant_inputs and ORT_PRESENT: + is_sequence = isinstance(outputs, (list, tuple)) + prediction = _propagate_helper( + fn, lazy_args, flattened_inference_inputs, custom_operators_path + ) + outputs = [outputs] if not is_sequence else outputs + corearrays: list[_CoreArray] = [] + for output in outputs: + if isinstance(output, _CoreArray): + corearrays.append(output) + else: + _get_corearrays(output, corearrays) + for corearray_out, value in zip(corearrays, prediction): + if corearray_out.dtype == ndx.utf8: + value = value.astype(np.str_) + corearray_out._eager_value = value + corearray_out.var = op.const(value) + + return outputs[0] if not is_sequence else outputs + else: + return outputs + + return wrapper + + return decorator + + +def _aggregate_arguments( + args: Arguments, +) -> tuple[bool, Arguments, list[LazyEagerPair]]: + """Takes a function as input (which may only consist of _CoreArrays and various + structures of it) and also the arguments to the function. + + Inputs: + args: Arguments + The positional and keyword arguments to the function. + Returns: + constant_inputs: bool + Whether all the inputs are constant. + lazy_args: Arguments + The arguments to the function, but with all the _CoreArrays replaced with lazy variants. + flattened_inference_inputs: list[LazyEagerPair] + The constituent input _CoreArrays alongside their eager values. + """ + + constant_inputs = True + lazy_args: Arguments = Arguments([], {}) + flattened_inference_inputs: list[LazyEagerPair] = [] + + def collect_lazy_arguments(obj): + nonlocal constant_inputs + if isinstance(obj, _CoreArray): + if obj.to_numpy() is None: + constant_inputs = False + return obj + else: + constant_inputs &= obj.to_numpy() is not None + if obj.dtype == ndx.utf8: + # Lazy variant due to onnxruntime bug + lazy = _CoreArray( + spox.argument( + spox.Tensor( + obj.dtype.to_numpy_dtype(), + obj.var.unwrap_tensor().shape, + ) + ), + ) + flattened_inference_inputs.append( + LazyEagerPair(lazy, obj.to_numpy()) + ) + return lazy + else: + return obj + elif isinstance(obj, ndx.Array): + obj_value = obj.to_numpy() + if obj_value is None: + constant_inputs = False + return obj + else: + if obj.dtype in (ndx.utf8, ndx.nutf8): + # Lazy variant due to onnxruntime bug + lazy = ndx.array(shape=obj._static_shape, dtype=obj.dtype) # type: ignore + + # disassemble the array into its core_arrays + _flatten(obj, lazy, flattened_inference_inputs) + return lazy + else: + return ndx.asarray(obj_value, obj.dtype) + elif isinstance(obj, (list, tuple)): + return type(obj)(map(collect_lazy_arguments, obj)) + elif isinstance(obj, slice): + return slice( + collect_lazy_arguments(obj.start), + collect_lazy_arguments(obj.stop), + collect_lazy_arguments(obj.step), + ) + else: + return obj + + for arg in args.args: + lazy_args.args.append(collect_lazy_arguments(arg)) + for key, value in args.kwargs.items(): + lazy_args.kwargs[key] = collect_lazy_arguments(value) + return constant_inputs, lazy_args, flattened_inference_inputs + + +def _flatten(eager_array, lazy_array, flattened_inference_inputs): + if isinstance(eager_array, _CoreArray): + flattened_inference_inputs.append( + LazyEagerPair(lazy_array, eager_array.to_numpy()) + ) + else: + for name in eager_array._fields: + _flatten( + eager_array._fields[name], + lazy_array._fields[name], + flattened_inference_inputs, + ) + + +def _get_corearrays(array: ndx.Array, core_arrays: list[_CoreArray]): + for name, field in array._fields.items(): + if isinstance(field, _CoreArray): + core_arrays.append(field) + else: + _get_corearrays(field, core_arrays) + + +def _propagate_helper( + fn, lazy_args, flattened_inference_inputs, custom_operators_path: Path | None = None +): + lazy_outputs = fn(*lazy_args.args, **lazy_args.kwargs) + is_sequence = isinstance(lazy_outputs, (list, tuple)) + if not is_sequence: + lazy_outputs = [lazy_outputs] + + # destructure lazy_args and lazy_outputs into sequences of _CoreArrays for ModelProto creation + + model_proto = ndx.build( + { + f"input_{i}": input.lazy + for i, input in enumerate(flattened_inference_inputs) + }, + { + f"output_{i}": output_corearray + for i, output_corearray in enumerate(lazy_outputs) + }, + ) + + sess_options = ort.SessionOptions() + if custom_operators_path is not None: + sess_options.register_custom_ops_library(str(custom_operators_path)) + sess = ort.InferenceSession( + model_proto.SerializeToString(), sess_options=sess_options + ) + prediction = sess.run( + None, + { + f"input_{i}": input.value + for i, input in enumerate(flattened_inference_inputs) + }, + ) + + return prediction diff --git a/ndonnx/_utility.py b/ndonnx/_utility.py new file mode 100644 index 0000000..17ef119 --- /dev/null +++ b/ndonnx/_utility.py @@ -0,0 +1,113 @@ +# Copyright (c) QuantCo 2023-2024 +# SPDX-License-Identifier: LicenseRef-QuantCo + +from __future__ import annotations + +from typing import TYPE_CHECKING + +import numpy as np +import numpy.typing as npt +from spox import Var + +# FIXME: Remove private import from Spox! Better to just use reshape! +from spox._internal_op import unsafe_reshape + +import ndonnx._data_types as dtypes + +if TYPE_CHECKING: + from ndonnx import Array + + from ._corearray import _CoreArray + + +def _promote_with_none(*args: Array | npt.ArrayLike) -> list[Array | None]: + """Promote arguments following numpy's promotion rules. + + Constant scalars are converted to `Array` objects. + + `None` values are passed through. + """ + # FIXME: The import structure is rather FUBAR! + from ._array import Array + from ._funcs import asarray, astype, result_type + + arr_or_none: list[Array | None] = [] + scalars: list[Array] = [] + signed_integer = False + for arg in args: + if arg is None: + arr_or_none.append(arg) + elif isinstance(arg, Array): + arr_or_none.append(arg) + if arg.dtype in (dtypes.int8, dtypes.int16, dtypes.int32, dtypes.int64): + signed_integer = True + elif isinstance(arg, np.ndarray): + arr_or_none.append(asarray(arg)) + elif isinstance(arg, (int, float, str, np.generic)): + np_dtype = np.min_scalar_type(arg) + if np_dtype == np.dtype("float16"): + np_dtype = np.dtype("float32") + arr = asarray(arg, dtypes.from_numpy_dtype(np_dtype)) + arr_or_none.append(arr) + scalars.append(arr) + else: + raise TypeError(f"Cannot promote {type(arg)}") + + for scalar in scalars: + eager_value = scalar.to_numpy() + if eager_value is None: + raise ValueError("Cannot promote `None` value") + if signed_integer and eager_value.dtype.kind == "u": + # translate dtype to signed version + dtype = np.dtype(f"int{eager_value.dtype.itemsize * 8}") + if eager_value > np.iinfo(dtype).max: + dtype = np.dtype(f"int{eager_value.dtype.itemsize * 16}") + scalar._set(scalar.astype(dtypes.from_numpy_dtype(dtype))) + + target_dtype = result_type(*[arr for arr in arr_or_none if arr is not None]) + + return [None if arr is None else astype(arr, target_dtype) for arr in arr_or_none] + + +def promote(*args: Array | npt.ArrayLike) -> list[Array]: + """Promote arguments following numpy's promotion rules. + + Constant scalars are converted to `Array` objects. + """ + promoted = _promote_with_none(*args) + ret = [] + for el in promoted: + if el is None: + raise ValueError("Cannot promote `None` value") + ret.append(el) + return ret + + +# We assume that rank will be static, because +# it is part if the type we are working on +def get_rank(tensor: _CoreArray | Var) -> int: + return len(get_shape(tensor)) + + +# We assume that type will be static, because +# it is part if the type we are working on +def get_dtype(tensor: _CoreArray | Var) -> np.dtype: + return np.dtype(unwrap_var(tensor).unwrap_tensor().dtype) + + +def get_shape(x: _CoreArray | Var) -> tuple[int | str | None, ...]: + if (shape := unwrap_var(x).unwrap_tensor().shape) is None: + raise ValueError("Shape is not known") + return shape + + +def set_shape(tensor: _CoreArray | Var, shape): + tensor = unwrap_var(tensor) + return unsafe_reshape(tensor, shape) + + +def unwrap_var(tensor: _CoreArray | Var) -> Var: + if isinstance(tensor, Var): + return tensor + else: + return tensor.var diff --git a/ndonnx/additional/__init__.py b/ndonnx/additional/__init__.py new file mode 100644 index 0000000..ddfe2db --- /dev/null +++ b/ndonnx/additional/__init__.py @@ -0,0 +1,12 @@ +# Copyright (c) QuantCo 2024-2024 +# SPDX-License-Identifier: LicenseRef-QuantCo + +from ._additional import fill_null, make_nullable, isin, shape, static_map + +__all__ = [ + "fill_null", + "make_nullable", + "isin", + "shape", + "static_map", +] diff --git a/ndonnx/additional/_additional.py b/ndonnx/additional/_additional.py new file mode 100644 index 0000000..29e3dd1 --- /dev/null +++ b/ndonnx/additional/_additional.py @@ -0,0 +1,145 @@ +# Copyright (c) QuantCo 2023-2024 +# SPDX-License-Identifier: LicenseRef-QuantCo +from __future__ import annotations + +from collections.abc import Mapping, Sequence +from typing import TYPE_CHECKING, TypeAlias, TypeVar + +import numpy as np + +import ndonnx as ndx +from ndonnx import _opset_extensions as opx + +if TYPE_CHECKING: + from ndonnx import Array + +Scalar = TypeVar("Scalar", int, float, str) + +Key: TypeAlias = Scalar +Value = TypeVar("Value", int, float, str) + + +def shape(x: Array) -> Array: + """Returns shape of an array. + + Parameters + ---------- + x: Array + Array to get shape of + + Returns + ------- + out: Array + Array of shape + """ + x = ndx.asarray(x) + out = x.dtype._ops.shape(x) + if out is NotImplemented: + raise TypeError(f"`shape` not implemented for `{x.dtype}`") + return out + + +def isin(x: Array, items: Sequence[Scalar]) -> Array: + """Return true where the input ``Array`` contains an element in ``items``. + + Parameters + ---------- + x: Array + The input Array to check for the presence of items. + items: Sequence[Scalar] + Scalar items to check for in the input Array. + + Returns + ------- + out: Array + Array of booleans indicating whether each element of ``x`` is in ``items``. + """ + if isinstance(x.dtype, ndx.Nullable): + return isin(x.values, items) & ~x.null + elif len(items) == 1: + if isinstance(items[0], float) and np.isnan(items[0]): + return ndx.isnan(x) + else: + return x == items[0] + else: + mapping = dict(zip(items, (1,) * len(items))) + return static_map(x, mapping, 0).astype(ndx.bool) + + +def static_map( + x: Array, + mapping: Mapping[Key, Value], + default: Value | None = None, +) -> Array: + """Map values in ``x`` based on the static ``mapping``. + + Parameters + ---------- + x: Array + The Array whose values will be mapped. + mapping: Mapping[Key, Value] + A mapping from keys to values. The keys must be of the same type as the values in ``x``. + default: Value, optional + The default value to use when a key is not found in the mapping. + + Returns + ------- + out: Array + A new Array with the values mapped according to the mapping. + """ + if not isinstance(x.dtype, ndx.CoreType): + raise TypeError("static_map accepts only non-nullable arrays") + data = opx.static_map(x._core(), mapping, default) + return ndx.Array._from_fields(data.dtype, data=data) + + +def fill_null(x: Array, value: Array | Scalar) -> Array: + """Returns a new ``Array`` with the null values filled with the given value. + + Parameters + ---------- + x: Array + The Array to fill the null values of. + value: Array | Scalar + The value to fill the null values with. + + Returns + ------- + out: Array + A new Array with the null values filled with the given value. + """ + + x = ndx.asarray(x) + out = x.dtype._ops.fill_null(x, value) + if out is NotImplemented: + raise TypeError(f"`fill_null` not implemented for `{x.dtype}`") + return out + + +def make_nullable(x: Array, null: Array) -> Array: + """Given an array ``x`` of values and a null mask ``null``, construct a new Array + with a nullable data type. + + Parameters + ---------- + x: Array + Array of values + + null: Array + Array of booleans indicating whether each element of ``x`` is null. + + Returns + ------- + out: Array + A new Array with a nullable data type. + + Raises + ------ + TypeError + If the data type of ``x`` does not have a nullable counterpart. + """ + x = ndx.asarray(x) + out = x.dtype._ops.make_nullable(x, null) + if out is NotImplemented: + raise TypeError(f"'make_nullable' not implemented for `{x.dtype}`") + return out diff --git a/pixi.lock b/pixi.lock new file mode 100644 index 0000000..f26c57f --- /dev/null +++ b/pixi.lock @@ -0,0 +1,12903 @@ +version: 5 +environments: + build: + channels: + - url: https://conda.anaconda.org/conda-forge/ + packages: + linux-64: + - conda: https://conda.anaconda.org/conda-forge/linux-64/_libgcc_mutex-0.1-conda_forge.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-64/_openmp_mutex-4.5-2_gnu.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/build-0.7.0-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-64/bzip2-1.0.8-hd590300_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/ca-certificates-2024.6.2-hbcca054_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/importlib-metadata-7.1.0-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/ld_impl_linux-64-2.40-hf3520f5_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libabseil-20240116.2-cxx17_h59595ed_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libblas-3.9.0-22_linux64_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libcblas-3.9.0-22_linux64_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libexpat-2.6.2-h59595ed_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libffi-3.4.2-h7f98852_5.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-ng-13.2.0-h77fa898_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran-ng-13.2.0-h69a702a_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran5-13.2.0-hca663fb_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgomp-13.2.0-h77fa898_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/liblapack-3.9.0-22_linux64_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libnsl-2.0.1-hd590300_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenblas-0.3.27-pthreads_h413a1c8_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libprotobuf-4.25.3-h08a7969_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libsqlite-3.45.3-h2797004_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-ng-13.2.0-hc0a3c3a_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libuuid-2.38.1-h0b41bf4_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libxcrypt-4.4.36-hd590300_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libzlib-1.3.1-h4ab18f5_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/ncurses-6.5-h59595ed_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/numpy-1.26.4-py312heda63a1_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/onnx-1.16.1-py312hb223586_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/openssl-3.3.1-h4ab18f5_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-24.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pep517-0.13.0-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/pip-24.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/protobuf-4.25.3-py312h72fbbdf_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/python-3.12.3-hab00c5b_0_cpython.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/python_abi-3.12-4_cp312.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/readline-8.2-h8228510_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-70.0.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-scm-8.1.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/spox-0.12.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/tk-8.6.13-noxft_h4845f30_101.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tomli-2.0.1-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/typing-extensions-4.12.2-hd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.12.2-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2024a-h0c530f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/wheel-0.43.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xz-5.2.6-h166bdaf_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/zipp-3.19.2-pyhd8ed1ab_0.conda + linux-aarch64: + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/_openmp_mutex-4.5-2_gnu.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/build-0.7.0-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/bzip2-1.0.8-h31becfc_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ca-certificates-2024.6.2-hcefe29a_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/importlib-metadata-7.1.0-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ld_impl_linux-aarch64-2.40-h9fc2d93_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libabseil-20240116.2-cxx17_h2f0025b_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libblas-3.9.0-22_linuxaarch64_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libcblas-3.9.0-22_linuxaarch64_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libexpat-2.6.2-h2f0025b_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libffi-3.4.2-h3557bc0_5.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgcc-ng-13.2.0-he277a41_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgfortran-ng-13.2.0-he9431aa_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgfortran5-13.2.0-h87d9d71_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgomp-13.2.0-he277a41_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/liblapack-3.9.0-22_linuxaarch64_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libnsl-2.0.1-h31becfc_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libopenblas-0.3.27-pthreads_h5a5ec62_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libprotobuf-4.25.3-h648ac29_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libsqlite-3.45.3-h194ca79_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libstdcxx-ng-13.2.0-h3f4de04_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libuuid-2.38.1-hb4cce97_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libxcrypt-4.4.36-h31becfc_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libzlib-1.3.1-h68df207_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ncurses-6.5-h0425590_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/numpy-1.26.4-py312h470d778_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/onnx-1.16.1-py312h67626d2_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/openssl-3.3.1-h68df207_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-24.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pep517-0.13.0-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/pip-24.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/protobuf-4.25.3-py312h1e6a782_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/python-3.12.3-h43d1f9e_0_cpython.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/python_abi-3.12-4_cp312.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/readline-8.2-h8fc344f_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-70.0.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-scm-8.1.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/spox-0.12.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/tk-8.6.13-h194ca79_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tomli-2.0.1-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/typing-extensions-4.12.2-hd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.12.2-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2024a-h0c530f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/wheel-0.43.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/xz-5.2.6-h9cdd2b7_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/zipp-3.19.2-pyhd8ed1ab_0.conda + osx-64: + - conda: https://conda.anaconda.org/conda-forge/noarch/build-0.7.0-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/osx-64/bzip2-1.0.8-h10d778d_5.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/ca-certificates-2024.6.2-h8857fd0_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/importlib-metadata-7.1.0-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libabseil-20240116.2-cxx17_hc1bcbd7_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libblas-3.9.0-22_osx64_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libcblas-3.9.0-22_osx64_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libcxx-17.0.6-h88467a6_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libexpat-2.6.2-h73e2aa4_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libffi-3.4.2-h0d85af4_5.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/osx-64/libgfortran-5.0.0-13_2_0_h97931a8_3.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libgfortran5-13.2.0-h2873a65_3.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/liblapack-3.9.0-22_osx64_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libopenblas-0.3.27-openmp_hfef2a42_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libprotobuf-4.25.3-h4e4d658_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libsqlite-3.45.3-h92b6c6a_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libzlib-1.3.1-h87427d6_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/llvm-openmp-18.1.7-h15ab845_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/ncurses-6.5-h5846eda_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/numpy-1.26.4-py312he3a82b2_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/onnx-1.16.1-py312hefded4f_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/openssl-3.3.1-h87427d6_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-24.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pep517-0.13.0-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/pip-24.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/protobuf-4.25.3-py312hf6c9040_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/python-3.12.3-h1411813_0_cpython.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/python_abi-3.12-4_cp312.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/readline-8.2-h9e318b2_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-70.0.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-scm-8.1.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/spox-0.12.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/tk-8.6.13-h1abcd95_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tomli-2.0.1-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/typing-extensions-4.12.2-hd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.12.2-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2024a-h0c530f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/wheel-0.43.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/xz-5.2.6-h775f41a_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/zipp-3.19.2-pyhd8ed1ab_0.conda + osx-arm64: + - conda: https://conda.anaconda.org/conda-forge/noarch/build-0.7.0-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/bzip2-1.0.8-h93a5062_5.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ca-certificates-2024.6.2-hf0a4a13_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/importlib-metadata-7.1.0-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libabseil-20240116.2-cxx17_hebf3989_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libblas-3.9.0-22_osxarm64_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcblas-3.9.0-22_osxarm64_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcxx-17.0.6-h5f092b4_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libexpat-2.6.2-hebf3989_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libffi-3.4.2-h3422bc3_5.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgfortran-5.0.0-13_2_0_hd922786_3.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgfortran5-13.2.0-hf226fd6_3.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/liblapack-3.9.0-22_osxarm64_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libopenblas-0.3.27-openmp_h6c19121_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libprotobuf-4.25.3-hbfab5d5_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libsqlite-3.45.3-h091b4b1_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libzlib-1.3.1-hfb2fe0b_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/llvm-openmp-18.1.7-hde57baf_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ncurses-6.5-hb89a1cb_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/numpy-1.26.4-py312h8442bc7_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/onnx-1.16.1-py312hb2a1542_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/openssl-3.3.1-hfb2fe0b_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-24.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pep517-0.13.0-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/pip-24.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/protobuf-4.25.3-py312h1a610f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/python-3.12.3-h4a7b5fc_0_cpython.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/python_abi-3.12-4_cp312.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/readline-8.2-h92ec313_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-70.0.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-scm-8.1.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/spox-0.12.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/tk-8.6.13-h5083fa2_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tomli-2.0.1-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/typing-extensions-4.12.2-hd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.12.2-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2024a-h0c530f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/wheel-0.43.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/xz-5.2.6-h57fd34a_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/zipp-3.19.2-pyhd8ed1ab_0.conda + win-64: + - conda: https://conda.anaconda.org/conda-forge/noarch/build-0.7.0-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/win-64/bzip2-1.0.8-hcfcfb64_5.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/ca-certificates-2024.6.2-h56e8100_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/importlib-metadata-7.1.0-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/intel-openmp-2024.1.0-h57928b3_966.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libabseil-20240116.2-cxx17_h63175ca_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libblas-3.9.0-22_win64_mkl.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libcblas-3.9.0-22_win64_mkl.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libexpat-2.6.2-h63175ca_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libffi-3.4.2-h8ffe710_5.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/win-64/libhwloc-2.10.0-default_h8125262_1001.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libiconv-1.17-hcfcfb64_2.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/liblapack-3.9.0-22_win64_mkl.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libprotobuf-4.25.3-h503648d_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libsqlite-3.45.3-hcfcfb64_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libxml2-2.12.7-h283a6d9_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libzlib-1.3.1-h2466b09_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/mkl-2024.1.0-h66d3029_692.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/numpy-1.26.4-py312h8753938_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/onnx-1.16.1-py312ha2757a1_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/openssl-3.3.1-h2466b09_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-24.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pep517-0.13.0-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/pip-24.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/protobuf-4.25.3-py312h5594109_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/pthreads-win32-2.9.1-hfa6e2cd_3.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/win-64/python-3.12.3-h2628c8c_0_cpython.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/python_abi-3.12-4_cp312.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-70.0.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-scm-8.1.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/spox-0.12.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/tbb-2021.12.0-hc790b64_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/tk-8.6.13-h5226925_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tomli-2.0.1-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/typing-extensions-4.12.2-hd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.12.2-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2024a-h0c530f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/ucrt-10.0.22621.0-h57928b3_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/win-64/vc-14.3-h8a93ad2_20.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/vc14_runtime-14.40.33810-ha82c5b3_20.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/vs2015_runtime-14.40.33810-h3bf8584_20.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/wheel-0.43.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/xz-5.2.6-h8d14728_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/zipp-3.19.2-pyhd8ed1ab_0.conda + default: + channels: + - url: https://conda.anaconda.org/conda-forge/ + packages: + linux-64: + - conda: https://conda.anaconda.org/conda-forge/linux-64/_libgcc_mutex-0.1-conda_forge.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-64/_openmp_mutex-4.5-2_gnu.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/attrs-23.2.0-pyh71513ae_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/backports.zoneinfo-0.2.1-py312h7900ff3_8.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/bzip2-1.0.8-hd590300_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/ca-certificates-2024.6.2-hbcca054_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cffi-1.16.0-py312hf06ca03_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cfgv-3.3.1-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/charset-normalizer-3.3.2-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/click-8.1.7-unix_pyh707e725_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/colorama-0.4.6-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/coloredlogs-15.0.1-pyhd8ed1ab_3.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-64/coverage-7.5.3-py312h9a8786e_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/distlib-0.3.8-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/docformatter-1.7.5-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/exceptiongroup-1.2.0-pyhd8ed1ab_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/execnet-2.1.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/filelock-3.14.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gmp-6.3.0-h59595ed_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gmpy2-2.1.5-py312h1d5cde6_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/humanfriendly-10.0-pyhd8ed1ab_6.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/hypothesis-6.103.1-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/icu-73.2-h59595ed_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/identify-2.5.36-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/iniconfig-2.0.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/insert-license-header-1.3.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/ld_impl_linux-64-2.40-hf3520f5_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libabseil-20240116.2-cxx17_h59595ed_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libblas-3.9.0-22_linux64_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libcblas-3.9.0-22_linux64_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libexpat-2.6.2-h59595ed_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libffi-3.4.2-h7f98852_5.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-ng-13.2.0-h77fa898_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran-ng-13.2.0-h69a702a_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran5-13.2.0-hca663fb_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgomp-13.2.0-h77fa898_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/liblapack-3.9.0-22_linux64_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libnsl-2.0.1-hd590300_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenblas-0.3.27-pthreads_h413a1c8_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libprotobuf-4.25.3-h08a7969_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libsqlite-3.45.3-h2797004_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-ng-13.2.0-hc0a3c3a_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libuuid-2.38.1-h0b41bf4_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libuv-1.48.0-hd590300_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libxcrypt-4.4.36-hd590300_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libzlib-1.3.1-h4ab18f5_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/mpc-1.3.1-hfe3b2da_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/mpfr-4.2.1-h9458935_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/mpmath-1.3.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/mypy-1.10.0-py312h9a8786e_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/mypy_extensions-1.0.0-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/ncurses-6.5-h59595ed_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/nodeenv-1.9.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/nodejs-20.12.2-hb753e55_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/numpy-1.26.4-py312heda63a1_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/onnx-1.16.1-py312hb223586_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/onnxruntime-1.18.0-py312hbe6c245_2_cpu.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/openssl-3.3.1-h4ab18f5_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-24.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pip-24.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/platformdirs-4.2.2-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pluggy-1.5.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pre-commit-3.7.1-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pre-commit-hooks-4.6.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/prettier-3.2.5-h31abb78_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/protobuf-4.25.3-py312h72fbbdf_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/psutil-5.9.8-py312h98912ed_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pycparser-2.22-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-8.2.2-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-cov-5.0.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-json-report-1.5.0-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-metadata-3.1.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-xdist-3.5.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/python-3.12.3-hab00c5b_0_cpython.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python-flatbuffers-24.3.25-pyh59ac667_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/python_abi-3.12-4_cp312.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/pyyaml-6.0.1-py312h98912ed_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/rapidfuzz-3.9.3-py312h7070661_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/readline-8.2-h8228510_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/ruamel.yaml-0.18.6-py312h98912ed_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/ruamel.yaml.clib-0.2.8-py312h98912ed_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/ruff-0.4.8-py312h5715c7c_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-70.0.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-scm-8.1.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sortedcontainers-2.4.0-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/spox-0.12.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sympy-1.12-pypyh9d50eac_103.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/tk-8.6.13-noxft_h4845f30_101.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/toml-0.10.2-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/tomli-2.0.1-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/typing-extensions-4.12.2-hd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.12.2-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/typos-1.22.4-he9194b0_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2024a-h0c530f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/ukkonen-1.0.1-py312h8572e83_4.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/untokenize-0.1.1-py_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/virtualenv-20.26.2-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/wheel-0.43.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xz-5.2.6-h166bdaf_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-64/yaml-0.2.5-h7f98852_2.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-64/zlib-1.3.1-h4ab18f5_1.conda + linux-aarch64: + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/_openmp_mutex-4.5-2_gnu.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/attrs-23.2.0-pyh71513ae_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/backports.zoneinfo-0.2.1-py312h996f985_8.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/bzip2-1.0.8-h31becfc_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ca-certificates-2024.6.2-hcefe29a_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cffi-1.16.0-py312hf3c74c0_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cfgv-3.3.1-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/charset-normalizer-3.3.2-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/click-8.1.7-unix_pyh707e725_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/colorama-0.4.6-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/coloredlogs-15.0.1-pyhd8ed1ab_3.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/coverage-7.5.3-py312h5adff4d_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/distlib-0.3.8-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/docformatter-1.7.5-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/exceptiongroup-1.2.0-pyhd8ed1ab_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/execnet-2.1.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/filelock-3.14.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gmp-6.3.0-h2f0025b_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gmpy2-2.1.5-py312h67287d2_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/humanfriendly-10.0-pyhd8ed1ab_6.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/hypothesis-6.103.1-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/icu-73.2-h787c7f5_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/identify-2.5.36-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/iniconfig-2.0.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/insert-license-header-1.3.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ld_impl_linux-aarch64-2.40-h9fc2d93_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libabseil-20240116.2-cxx17_h2f0025b_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libblas-3.9.0-22_linuxaarch64_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libcblas-3.9.0-22_linuxaarch64_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libexpat-2.6.2-h2f0025b_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libffi-3.4.2-h3557bc0_5.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgcc-ng-13.2.0-he277a41_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgfortran-ng-13.2.0-he9431aa_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgfortran5-13.2.0-h87d9d71_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgomp-13.2.0-he277a41_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/liblapack-3.9.0-22_linuxaarch64_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libnsl-2.0.1-h31becfc_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libopenblas-0.3.27-pthreads_h5a5ec62_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libprotobuf-4.25.3-h648ac29_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libsqlite-3.45.3-h194ca79_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libstdcxx-ng-13.2.0-h3f4de04_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libuuid-2.38.1-hb4cce97_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libuv-1.48.0-h31becfc_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libxcrypt-4.4.36-h31becfc_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libzlib-1.3.1-h68df207_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/mpc-1.3.1-hf4c8f4c_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/mpfr-4.2.1-ha2d0fc4_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/mpmath-1.3.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/mypy-1.10.0-py312h396f95a_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/mypy_extensions-1.0.0-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ncurses-6.5-h0425590_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/nodeenv-1.9.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/nodejs-20.12.2-hc1f8a26_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/numpy-1.26.4-py312h470d778_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/onnx-1.16.1-py312h67626d2_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/onnxruntime-1.18.0-py312hfb296ae_2_cpu.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/openssl-3.3.1-h68df207_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-24.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pip-24.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/platformdirs-4.2.2-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pluggy-1.5.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pre-commit-3.7.1-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pre-commit-hooks-4.6.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/prettier-3.2.5-h4e45a9e_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/protobuf-4.25.3-py312h1e6a782_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/psutil-5.9.8-py312hdd3e373_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pycparser-2.22-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-8.2.2-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-cov-5.0.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-json-report-1.5.0-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-metadata-3.1.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-xdist-3.5.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/python-3.12.3-h43d1f9e_0_cpython.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python-flatbuffers-24.3.25-pyh59ac667_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/python_abi-3.12-4_cp312.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/pyyaml-6.0.1-py312hdd3e373_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/rapidfuzz-3.9.3-py312h7f10901_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/readline-8.2-h8fc344f_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ruamel.yaml-0.18.6-py312hdd3e373_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ruamel.yaml.clib-0.2.8-py312hdd3e373_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ruff-0.4.8-py312h18b2cab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-70.0.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-scm-8.1.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sortedcontainers-2.4.0-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/spox-0.12.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sympy-1.12-pypyh9d50eac_103.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/tk-8.6.13-h194ca79_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/toml-0.10.2-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/tomli-2.0.1-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/typing-extensions-4.12.2-hd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.12.2-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/typos-1.22.4-h09b8157_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2024a-h0c530f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ukkonen-1.0.1-py312h8f0b210_4.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/untokenize-0.1.1-py_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/virtualenv-20.26.2-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/wheel-0.43.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/xz-5.2.6-h9cdd2b7_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/yaml-0.2.5-hf897c2e_2.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/zlib-1.3.1-h68df207_1.conda + osx-64: + - conda: https://conda.anaconda.org/conda-forge/noarch/attrs-23.2.0-pyh71513ae_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/backports.zoneinfo-0.2.1-py312hb401068_8.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/bzip2-1.0.8-h10d778d_5.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/ca-certificates-2024.6.2-h8857fd0_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/cffi-1.16.0-py312h38bf5a0_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cfgv-3.3.1-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/charset-normalizer-3.3.2-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/click-8.1.7-unix_pyh707e725_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/colorama-0.4.6-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/coloredlogs-15.0.1-pyhd8ed1ab_3.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/osx-64/coverage-7.5.3-py312hbd25219_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/distlib-0.3.8-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/docformatter-1.7.5-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/exceptiongroup-1.2.0-pyhd8ed1ab_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/execnet-2.1.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/filelock-3.14.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/gmp-6.3.0-h73e2aa4_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/gmpy2-2.1.5-py312hd98c385_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/humanfriendly-10.0-pyhd8ed1ab_6.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/hypothesis-6.103.1-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/icu-73.2-hf5e326d_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/identify-2.5.36-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/iniconfig-2.0.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/insert-license-header-1.3.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libabseil-20240116.2-cxx17_hc1bcbd7_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libblas-3.9.0-22_osx64_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libcblas-3.9.0-22_osx64_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libcxx-17.0.6-h88467a6_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libexpat-2.6.2-h73e2aa4_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libffi-3.4.2-h0d85af4_5.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/osx-64/libgfortran-5.0.0-13_2_0_h97931a8_3.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libgfortran5-13.2.0-h2873a65_3.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/liblapack-3.9.0-22_osx64_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libopenblas-0.3.27-openmp_hfef2a42_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libprotobuf-4.25.3-h4e4d658_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libsqlite-3.45.3-h92b6c6a_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libuv-1.48.0-h67532ce_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libzlib-1.3.1-h87427d6_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/llvm-openmp-18.1.7-h15ab845_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/mpc-1.3.1-h81bd1dd_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/mpfr-4.2.1-h4f6b447_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/mpmath-1.3.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/mypy-1.10.0-py312h5fa3f64_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/mypy_extensions-1.0.0-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/ncurses-6.5-h5846eda_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/nodeenv-1.9.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/nodejs-20.12.2-hfc0f20e_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/numpy-1.26.4-py312he3a82b2_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/onnx-1.16.1-py312hefded4f_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/onnxruntime-1.18.0-py312hd03a33c_2_cpu.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/openssl-3.3.1-h87427d6_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-24.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pip-24.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/platformdirs-4.2.2-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pluggy-1.5.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pre-commit-3.7.1-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pre-commit-hooks-4.6.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/prettier-3.2.5-hbd11d21_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/protobuf-4.25.3-py312hf6c9040_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/psutil-5.9.8-py312h41838bb_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pycparser-2.22-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-8.2.2-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-cov-5.0.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-json-report-1.5.0-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-metadata-3.1.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-xdist-3.5.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/python-3.12.3-h1411813_0_cpython.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python-flatbuffers-24.3.25-pyh59ac667_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/python_abi-3.12-4_cp312.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/pyyaml-6.0.1-py312h104f124_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/rapidfuzz-3.9.3-py312h28f332c_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/readline-8.2-h9e318b2_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/ruamel.yaml-0.18.6-py312h41838bb_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/ruamel.yaml.clib-0.2.8-py312h41838bb_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/ruff-0.4.8-py312h8b25c6c_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-70.0.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-scm-8.1.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sortedcontainers-2.4.0-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/spox-0.12.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sympy-1.12-pypyh9d50eac_103.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/tk-8.6.13-h1abcd95_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/toml-0.10.2-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/tomli-2.0.1-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/typing-extensions-4.12.2-hd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.12.2-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/typos-1.22.4-h686f776_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2024a-h0c530f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/ukkonen-1.0.1-py312h49ebfd2_4.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/untokenize-0.1.1-py_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/virtualenv-20.26.2-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/wheel-0.43.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/xz-5.2.6-h775f41a_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/osx-64/yaml-0.2.5-h0d85af4_2.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/osx-64/zlib-1.3.1-h87427d6_1.conda + osx-arm64: + - conda: https://conda.anaconda.org/conda-forge/noarch/attrs-23.2.0-pyh71513ae_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/backports.zoneinfo-0.2.1-py312h81bd7bf_8.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/bzip2-1.0.8-h93a5062_5.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ca-certificates-2024.6.2-hf0a4a13_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/cffi-1.16.0-py312h8e38eb3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cfgv-3.3.1-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/charset-normalizer-3.3.2-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/click-8.1.7-unix_pyh707e725_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/colorama-0.4.6-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/coloredlogs-15.0.1-pyhd8ed1ab_3.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/coverage-7.5.3-py312h7e5086c_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/distlib-0.3.8-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/docformatter-1.7.5-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/exceptiongroup-1.2.0-pyhd8ed1ab_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/execnet-2.1.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/filelock-3.14.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/gmp-6.3.0-hebf3989_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/gmpy2-2.1.5-py312hfa9fade_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/humanfriendly-10.0-pyhd8ed1ab_6.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/hypothesis-6.103.1-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/icu-73.2-hc8870d7_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/identify-2.5.36-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/iniconfig-2.0.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/insert-license-header-1.3.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libabseil-20240116.2-cxx17_hebf3989_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libblas-3.9.0-22_osxarm64_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcblas-3.9.0-22_osxarm64_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcxx-17.0.6-h5f092b4_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libexpat-2.6.2-hebf3989_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libffi-3.4.2-h3422bc3_5.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgfortran-5.0.0-13_2_0_hd922786_3.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgfortran5-13.2.0-hf226fd6_3.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/liblapack-3.9.0-22_osxarm64_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libopenblas-0.3.27-openmp_h6c19121_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libprotobuf-4.25.3-hbfab5d5_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libsqlite-3.45.3-h091b4b1_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libuv-1.48.0-h93a5062_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libzlib-1.3.1-hfb2fe0b_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/llvm-openmp-18.1.7-hde57baf_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/mpc-1.3.1-h91ba8db_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/mpfr-4.2.1-h41d338b_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/mpmath-1.3.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/mypy-1.10.0-py312h4a164c9_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/mypy_extensions-1.0.0-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ncurses-6.5-hb89a1cb_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/nodeenv-1.9.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/nodejs-20.12.2-h3b52c9b_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/numpy-1.26.4-py312h8442bc7_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/onnx-1.16.1-py312hb2a1542_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/onnxruntime-1.18.0-py312hcd9b293_2_cpu.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/openssl-3.3.1-hfb2fe0b_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-24.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pip-24.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/platformdirs-4.2.2-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pluggy-1.5.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pre-commit-3.7.1-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pre-commit-hooks-4.6.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/prettier-3.2.5-hb67532b_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/protobuf-4.25.3-py312h1a610f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/psutil-5.9.8-py312he37b823_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pycparser-2.22-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-8.2.2-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-cov-5.0.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-json-report-1.5.0-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-metadata-3.1.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-xdist-3.5.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/python-3.12.3-h4a7b5fc_0_cpython.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python-flatbuffers-24.3.25-pyh59ac667_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/python_abi-3.12-4_cp312.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pyyaml-6.0.1-py312h02f2b3b_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/rapidfuzz-3.9.3-py312h5c2e7bc_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/readline-8.2-h92ec313_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ruamel.yaml-0.18.6-py312he37b823_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ruamel.yaml.clib-0.2.8-py312he37b823_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ruff-0.4.8-py312h3402d49_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-70.0.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-scm-8.1.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sortedcontainers-2.4.0-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/spox-0.12.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sympy-1.12-pypyh9d50eac_103.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/tk-8.6.13-h5083fa2_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/toml-0.10.2-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/tomli-2.0.1-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/typing-extensions-4.12.2-hd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.12.2-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/typos-1.22.4-h6e96688_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2024a-h0c530f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ukkonen-1.0.1-py312h389731b_4.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/untokenize-0.1.1-py_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/virtualenv-20.26.2-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/wheel-0.43.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/xz-5.2.6-h57fd34a_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/yaml-0.2.5-h3422bc3_2.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/zlib-1.3.1-hfb2fe0b_1.conda + win-64: + - conda: https://conda.anaconda.org/conda-forge/noarch/attrs-23.2.0-pyh71513ae_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/backports.zoneinfo-0.2.1-py312h2e8e312_8.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/bzip2-1.0.8-hcfcfb64_5.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/ca-certificates-2024.6.2-h56e8100_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/cffi-1.16.0-py312he70551f_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cfgv-3.3.1-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/charset-normalizer-3.3.2-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/click-8.1.7-win_pyh7428d3b_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/colorama-0.4.6-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/coloredlogs-15.0.1-pyhd8ed1ab_3.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/win-64/coverage-7.5.3-py312h4389bb4_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/distlib-0.3.8-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/docformatter-1.7.5-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/exceptiongroup-1.2.0-pyhd8ed1ab_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/execnet-2.1.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/filelock-3.14.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/humanfriendly-10.0-py312h2e8e312_5.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/hypothesis-6.103.1-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/identify-2.5.36-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/iniconfig-2.0.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/insert-license-header-1.3.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/intel-openmp-2024.1.0-h57928b3_966.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libabseil-20240116.2-cxx17_h63175ca_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libblas-3.9.0-22_win64_mkl.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libcblas-3.9.0-22_win64_mkl.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libexpat-2.6.2-h63175ca_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libffi-3.4.2-h8ffe710_5.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/win-64/libhwloc-2.10.0-default_h8125262_1001.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libiconv-1.17-hcfcfb64_2.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/liblapack-3.9.0-22_win64_mkl.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libprotobuf-4.25.3-h503648d_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libsqlite-3.45.3-hcfcfb64_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libxml2-2.12.7-h283a6d9_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libzlib-1.3.1-h2466b09_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/m2w64-gcc-libgfortran-5.3.0-6.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/win-64/m2w64-gcc-libs-5.3.0-7.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/win-64/m2w64-gcc-libs-core-5.3.0-7.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/win-64/m2w64-gmp-6.1.0-2.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/win-64/m2w64-libwinpthread-git-5.0.0.4634.697f757-2.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/win-64/mkl-2024.1.0-h66d3029_692.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/mpmath-1.3.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/msys2-conda-epoch-20160418-1.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/win-64/mypy-1.10.0-py312h4389bb4_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/mypy_extensions-1.0.0-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/nodeenv-1.9.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/nodejs-20.12.2-h57928b3_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/numpy-1.26.4-py312h8753938_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/onnx-1.16.1-py312ha2757a1_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/onnxruntime-1.18.0-py312h2704b8b_2_cpu.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/openssl-3.3.1-h2466b09_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-24.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pip-24.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/platformdirs-4.2.2-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pluggy-1.5.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pre-commit-3.7.1-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pre-commit-hooks-4.6.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/prettier-3.2.5-h98b3114_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/protobuf-4.25.3-py312h5594109_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/psutil-5.9.8-py312he70551f_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/pthreads-win32-2.9.1-hfa6e2cd_3.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/pycparser-2.22-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/pyreadline3-3.4.1-py312h2e8e312_3.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-8.2.2-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-cov-5.0.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-json-report-1.5.0-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-metadata-3.1.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-xdist-3.5.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/python-3.12.3-h2628c8c_0_cpython.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python-flatbuffers-24.3.25-pyh59ac667_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/python_abi-3.12-4_cp312.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/pyyaml-6.0.1-py312he70551f_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/rapidfuzz-3.9.3-py312h275cf98_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/ruamel.yaml-0.18.6-py312he70551f_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/ruamel.yaml.clib-0.2.8-py312he70551f_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/ruff-0.4.8-py312h7a6832a_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-70.0.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-scm-8.1.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sortedcontainers-2.4.0-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/spox-0.12.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sympy-1.12-pyh04b8f61_3.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/tbb-2021.12.0-hc790b64_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/tk-8.6.13-h5226925_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/toml-0.10.2-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/tomli-2.0.1-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/typing-extensions-4.12.2-hd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.12.2-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/typos-1.22.4-h813c833_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2024a-h0c530f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/ucrt-10.0.22621.0-h57928b3_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/win-64/ukkonen-1.0.1-py312h0d7def4_4.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/untokenize-0.1.1-py_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/win-64/vc-14.3-h8a93ad2_20.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/vc14_runtime-14.40.33810-ha82c5b3_20.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/virtualenv-20.26.2-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/vs2015_runtime-14.40.33810-h3bf8584_20.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/wheel-0.43.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/xz-5.2.6-h8d14728_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/win-64/yaml-0.2.5-h8ffe710_2.tar.bz2 + docs: + channels: + - url: https://conda.anaconda.org/conda-forge/ + packages: + linux-64: + - conda: https://conda.anaconda.org/conda-forge/linux-64/_libgcc_mutex-0.1-conda_forge.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-64/_openmp_mutex-4.5-2_gnu.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/alabaster-0.7.16-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/apeye-1.4.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/apeye-core-1.1.5-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/attrs-23.2.0-pyh71513ae_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/autodocsumm-0.2.12-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/babel-2.14.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/beautifulsoup4-4.12.3-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/bleach-6.1.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/brotli-python-1.1.0-py310hc6cd4ac_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/bzip2-1.0.8-hd590300_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/ca-certificates-2024.6.2-hbcca054_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cachecontrol-0.14.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/certifi-2024.6.2-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/charset-normalizer-3.3.2-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/colorama-0.4.6-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/cssutils-2.11.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/defusedxml-0.7.1-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/dict2css-0.3.0.post1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/docutils-0.18.1-py310hff52083_1.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/domdf-python-tools-3.8.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/entrypoints-0.4-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/filelock-3.14.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/html5lib-1.1-pyh9f0ad1d_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/idna-3.7-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/imagesize-1.4.1-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/importlib-metadata-7.1.0-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/importlib-resources-6.4.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/importlib_metadata-7.1.0-hd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/importlib_resources-6.4.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jinja2-3.1.4-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jsonschema-4.22.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jsonschema-specifications-2023.12.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jupyter_client-8.6.2-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/jupyter_core-5.7.2-py310hff52083_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jupyterlab_pygments-0.3.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/keyutils-1.6.1-h166bdaf_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-64/krb5-1.21.2-h659d440_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/ld_impl_linux-64-2.40-hf3520f5_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libabseil-20240116.2-cxx17_h59595ed_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libblas-3.9.0-22_linux64_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libcblas-3.9.0-22_linux64_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libedit-3.1.20191231-he28a2e2_2.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-64/libffi-3.4.2-h7f98852_5.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-ng-13.2.0-h77fa898_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran-ng-13.2.0-h69a702a_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran5-13.2.0-hca663fb_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgomp-13.2.0-h77fa898_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/liblapack-3.9.0-22_linux64_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libnsl-2.0.1-hd590300_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenblas-0.3.27-pthreads_h413a1c8_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libprotobuf-4.25.3-h08a7969_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libsodium-1.0.18-h36c2ea0_1.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-64/libsqlite-3.45.3-h2797004_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-ng-13.2.0-hc0a3c3a_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libuuid-2.38.1-h0b41bf4_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libxcrypt-4.4.36-hd590300_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libzlib-1.3.1-h4ab18f5_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/make-4.3-hd18ef5c_1.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-64/markupsafe-2.1.5-py310h2372a71_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/mistune-3.0.2-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/msgpack-python-1.0.8-py310h25c7140_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/mypy_extensions-1.0.0-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/natsort-8.4.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/nbclient-0.10.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/nbconvert-7.16.4-hd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/nbconvert-core-7.16.4-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/nbconvert-pandoc-7.16.4-hd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/nbformat-5.10.4-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/nbsphinx-0.9.4-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/ncurses-6.5-h59595ed_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/numpy-1.26.4-py310hb13e2d6_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/numpydoc-1.7.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/onnx-1.16.1-py310hc505232_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/openssl-3.3.1-h4ab18f5_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-24.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/pandoc-3.2-ha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pandocfilters-1.5.0-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/pbr-6.0.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pip-24.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pkgutil-resolve-name-1.3.10-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/platformdirs-4.2.2-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/protobuf-4.25.3-py310ha8c1f0e_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pygments-2.18.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pysocks-1.7.1-pyha2e5f31_6.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-64/python-3.10.14-hd12c33a_0_cpython.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python-dateutil-2.9.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python-fastjsonschema-2.19.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/python_abi-3.10-4_cp310.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pytz-2024.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/pyzmq-26.0.3-py310h6883aea_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/readline-8.2-h8228510_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/referencing-0.35.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/requests-2.32.3-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/rpds-py-0.18.1-py310he421c4c_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/ruamel.yaml-0.18.6-py310h2372a71_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/ruamel.yaml.clib-0.2.8-py310h2372a71_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-70.0.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-scm-8.1.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/six-1.16.0-pyh6c4a22f_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/snowballstemmer-2.2.0-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/soupsieve-2.5-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sphinx-5.0.0-pyh6c4a22f_1.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/sphinx-autodoc-typehints-1.19.2-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/sphinx-jinja2-compat-0.2.0.post1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sphinx-prompt-1.4.0-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/sphinx-tabs-3.4.1-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sphinx-toolbox-3.5.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sphinx_rtd_theme-2.0.0-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sphinxcontrib-apidoc-0.3.0-py_1.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/sphinxcontrib-applehelp-1.0.8-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sphinxcontrib-devhelp-1.0.6-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sphinxcontrib-htmlhelp-2.0.5-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sphinxcontrib-jquery-4.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sphinxcontrib-jsmath-1.0.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sphinxcontrib-qthelp-1.0.7-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sphinxcontrib-serializinghtml-1.1.10-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/spox-0.12.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tabulate-0.9.0-pyhd8ed1ab_1.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/tinycss2-1.3.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/tk-8.6.13-noxft_h4845f30_101.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tomli-2.0.1-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-64/tornado-6.4.1-py310hc51659f_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/traitlets-5.14.3-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/typing-extensions-4.12.2-hd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.12.2-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/typing_inspect-0.9.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2024a-h0c530f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/urllib3-2.2.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/webencodings-0.5.1-pyhd8ed1ab_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/wheel-0.43.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xz-5.2.6-h166bdaf_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-64/zeromq-4.3.5-h75354e8_4.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/zipp-3.19.2-pyhd8ed1ab_0.conda + linux-aarch64: + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/_openmp_mutex-4.5-2_gnu.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/alabaster-0.7.16-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/apeye-1.4.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/apeye-core-1.1.5-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/attrs-23.2.0-pyh71513ae_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/autodocsumm-0.2.12-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/babel-2.14.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/beautifulsoup4-4.12.3-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/bleach-6.1.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/brotli-python-1.1.0-py310hbb3657e_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/bzip2-1.0.8-h31becfc_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ca-certificates-2024.6.2-hcefe29a_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cachecontrol-0.14.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/certifi-2024.6.2-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/charset-normalizer-3.3.2-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/colorama-0.4.6-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/cssutils-2.11.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/defusedxml-0.7.1-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/dict2css-0.3.0.post1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/docutils-0.18.1-py310hbbe02a8_1.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/domdf-python-tools-3.8.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/entrypoints-0.4-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/filelock-3.14.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/html5lib-1.1-pyh9f0ad1d_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/idna-3.7-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/imagesize-1.4.1-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/importlib-metadata-7.1.0-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/importlib-resources-6.4.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/importlib_metadata-7.1.0-hd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/importlib_resources-6.4.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jinja2-3.1.4-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jsonschema-4.22.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jsonschema-specifications-2023.12.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jupyter_client-8.6.2-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/jupyter_core-5.7.2-py310h4c7bcd0_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jupyterlab_pygments-0.3.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/keyutils-1.6.1-h4e544f5_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/krb5-1.21.2-hc419048_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ld_impl_linux-aarch64-2.40-h9fc2d93_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libabseil-20240116.2-cxx17_h2f0025b_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libblas-3.9.0-22_linuxaarch64_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libcblas-3.9.0-22_linuxaarch64_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libedit-3.1.20191231-he28a2e2_2.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libffi-3.4.2-h3557bc0_5.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgcc-ng-13.2.0-he277a41_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgfortran-ng-13.2.0-he9431aa_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgfortran5-13.2.0-h87d9d71_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgomp-13.2.0-he277a41_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/liblapack-3.9.0-22_linuxaarch64_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libnsl-2.0.1-h31becfc_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libopenblas-0.3.27-pthreads_h5a5ec62_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libprotobuf-4.25.3-h648ac29_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libsodium-1.0.18-hb9de7d4_1.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libsqlite-3.45.3-h194ca79_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libstdcxx-ng-13.2.0-h3f4de04_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libuuid-2.38.1-hb4cce97_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libxcrypt-4.4.36-h31becfc_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libzlib-1.3.1-h68df207_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/make-4.3-h309ac5b_1.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/markupsafe-2.1.5-py310h7c1f4a2_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/mistune-3.0.2-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/msgpack-python-1.0.8-py310h6cd5c4a_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/mypy_extensions-1.0.0-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/natsort-8.4.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/nbclient-0.10.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/nbconvert-7.16.4-hd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/nbconvert-core-7.16.4-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/nbconvert-pandoc-7.16.4-hd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/nbformat-5.10.4-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/nbsphinx-0.9.4-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ncurses-6.5-h0425590_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/numpy-1.26.4-py310hcbab775_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/numpydoc-1.7.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/onnx-1.16.1-py310h25cd676_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/openssl-3.3.1-h68df207_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-24.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/pandoc-3.2-h8af1aa0_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pandocfilters-1.5.0-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/pbr-6.0.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pip-24.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pkgutil-resolve-name-1.3.10-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/platformdirs-4.2.2-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/protobuf-4.25.3-py310h6802e18_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pygments-2.18.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pysocks-1.7.1-pyha2e5f31_6.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/python-3.10.14-hbbe8eec_0_cpython.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python-dateutil-2.9.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python-fastjsonschema-2.19.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/python_abi-3.10-4_cp310.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pytz-2024.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/pyzmq-26.0.3-py310he875deb_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/readline-8.2-h8fc344f_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/referencing-0.35.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/requests-2.32.3-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/rpds-py-0.18.1-py310h59d1b7a_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ruamel.yaml-0.18.6-py310hb299538_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ruamel.yaml.clib-0.2.8-py310hb299538_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-70.0.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-scm-8.1.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/six-1.16.0-pyh6c4a22f_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/snowballstemmer-2.2.0-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/soupsieve-2.5-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sphinx-5.0.0-pyh6c4a22f_1.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/sphinx-autodoc-typehints-1.19.2-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/sphinx-jinja2-compat-0.2.0.post1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sphinx-prompt-1.4.0-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/sphinx-tabs-3.4.1-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sphinx-toolbox-3.5.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sphinx_rtd_theme-2.0.0-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sphinxcontrib-apidoc-0.3.0-py_1.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/sphinxcontrib-applehelp-1.0.8-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sphinxcontrib-devhelp-1.0.6-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sphinxcontrib-htmlhelp-2.0.5-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sphinxcontrib-jquery-4.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sphinxcontrib-jsmath-1.0.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sphinxcontrib-qthelp-1.0.7-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sphinxcontrib-serializinghtml-1.1.10-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/spox-0.12.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tabulate-0.9.0-pyhd8ed1ab_1.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/tinycss2-1.3.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/tk-8.6.13-h194ca79_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tomli-2.0.1-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/tornado-6.4.1-py310h03727f4_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/traitlets-5.14.3-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/typing-extensions-4.12.2-hd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.12.2-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/typing_inspect-0.9.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2024a-h0c530f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/urllib3-2.2.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/webencodings-0.5.1-pyhd8ed1ab_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/wheel-0.43.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/xz-5.2.6-h9cdd2b7_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/zeromq-4.3.5-h28faeed_4.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/zipp-3.19.2-pyhd8ed1ab_0.conda + osx-64: + - conda: https://conda.anaconda.org/conda-forge/noarch/alabaster-0.7.16-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/apeye-1.4.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/apeye-core-1.1.5-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/attrs-23.2.0-pyh71513ae_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/autodocsumm-0.2.12-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/babel-2.14.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/beautifulsoup4-4.12.3-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/bleach-6.1.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/brotli-python-1.1.0-py310h9e9d8ca_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/bzip2-1.0.8-h10d778d_5.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/ca-certificates-2024.6.2-h8857fd0_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cachecontrol-0.14.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/certifi-2024.6.2-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/charset-normalizer-3.3.2-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/colorama-0.4.6-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/cssutils-2.11.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/defusedxml-0.7.1-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/dict2css-0.3.0.post1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/docutils-0.18.1-py310h2ec42d9_1.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/domdf-python-tools-3.8.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/entrypoints-0.4-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/filelock-3.14.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/html5lib-1.1-pyh9f0ad1d_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/idna-3.7-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/imagesize-1.4.1-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/importlib-metadata-7.1.0-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/importlib-resources-6.4.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/importlib_metadata-7.1.0-hd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/importlib_resources-6.4.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jinja2-3.1.4-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jsonschema-4.22.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jsonschema-specifications-2023.12.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jupyter_client-8.6.2-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/jupyter_core-5.7.2-py310h2ec42d9_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jupyterlab_pygments-0.3.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/krb5-1.21.2-hb884880_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libabseil-20240116.2-cxx17_hc1bcbd7_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libblas-3.9.0-22_osx64_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libcblas-3.9.0-22_osx64_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libcxx-17.0.6-h88467a6_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libedit-3.1.20191231-h0678c8f_2.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/osx-64/libffi-3.4.2-h0d85af4_5.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/osx-64/libgfortran-5.0.0-13_2_0_h97931a8_3.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libgfortran5-13.2.0-h2873a65_3.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/liblapack-3.9.0-22_osx64_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libopenblas-0.3.27-openmp_hfef2a42_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libprotobuf-4.25.3-h4e4d658_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libsodium-1.0.18-hbcb3906_1.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/osx-64/libsqlite-3.45.3-h92b6c6a_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libzlib-1.3.1-h87427d6_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/llvm-openmp-18.1.7-h15ab845_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/make-4.3-h22f3db7_1.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/osx-64/markupsafe-2.1.5-py310hb372a2b_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/mistune-3.0.2-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/msgpack-python-1.0.8-py310h5334dd0_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/mypy_extensions-1.0.0-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/natsort-8.4.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/nbclient-0.10.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/nbconvert-7.16.4-hd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/nbconvert-core-7.16.4-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/nbconvert-pandoc-7.16.4-hd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/nbformat-5.10.4-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/nbsphinx-0.9.4-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/ncurses-6.5-h5846eda_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/numpy-1.26.4-py310h4bfa8fc_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/numpydoc-1.7.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/onnx-1.16.1-py310h00e9488_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/openssl-3.3.1-h87427d6_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-24.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/pandoc-3.2-h694c41f_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pandocfilters-1.5.0-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/pbr-6.0.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pip-24.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pkgutil-resolve-name-1.3.10-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/platformdirs-4.2.2-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/protobuf-4.25.3-py310h9015309_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pygments-2.18.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pysocks-1.7.1-pyha2e5f31_6.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/osx-64/python-3.10.14-h00d2728_0_cpython.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python-dateutil-2.9.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python-fastjsonschema-2.19.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/python_abi-3.10-4_cp310.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pytz-2024.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/pyzmq-26.0.3-py310he0bbd50_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/readline-8.2-h9e318b2_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/referencing-0.35.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/requests-2.32.3-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/rpds-py-0.18.1-py310h12a1ced_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/ruamel.yaml-0.18.6-py310hb372a2b_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/ruamel.yaml.clib-0.2.8-py310hb372a2b_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-70.0.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-scm-8.1.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/six-1.16.0-pyh6c4a22f_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/snowballstemmer-2.2.0-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/soupsieve-2.5-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sphinx-5.0.0-pyh6c4a22f_1.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/sphinx-autodoc-typehints-1.19.2-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/sphinx-jinja2-compat-0.2.0.post1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sphinx-prompt-1.4.0-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/sphinx-tabs-3.4.1-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sphinx-toolbox-3.5.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sphinx_rtd_theme-2.0.0-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sphinxcontrib-apidoc-0.3.0-py_1.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/sphinxcontrib-applehelp-1.0.8-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sphinxcontrib-devhelp-1.0.6-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sphinxcontrib-htmlhelp-2.0.5-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sphinxcontrib-jquery-4.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sphinxcontrib-jsmath-1.0.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sphinxcontrib-qthelp-1.0.7-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sphinxcontrib-serializinghtml-1.1.10-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/spox-0.12.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tabulate-0.9.0-pyhd8ed1ab_1.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/tinycss2-1.3.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/tk-8.6.13-h1abcd95_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tomli-2.0.1-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/osx-64/tornado-6.4.1-py310h936d840_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/traitlets-5.14.3-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/typing-extensions-4.12.2-hd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.12.2-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/typing_inspect-0.9.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2024a-h0c530f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/urllib3-2.2.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/webencodings-0.5.1-pyhd8ed1ab_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/wheel-0.43.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/xz-5.2.6-h775f41a_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/osx-64/zeromq-4.3.5-hde137ed_4.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/zipp-3.19.2-pyhd8ed1ab_0.conda + osx-arm64: + - conda: https://conda.anaconda.org/conda-forge/noarch/alabaster-0.7.16-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/apeye-1.4.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/apeye-core-1.1.5-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/attrs-23.2.0-pyh71513ae_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/autodocsumm-0.2.12-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/babel-2.14.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/beautifulsoup4-4.12.3-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/bleach-6.1.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/brotli-python-1.1.0-py310h1253130_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/bzip2-1.0.8-h93a5062_5.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ca-certificates-2024.6.2-hf0a4a13_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cachecontrol-0.14.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/certifi-2024.6.2-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/charset-normalizer-3.3.2-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/colorama-0.4.6-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/cssutils-2.11.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/defusedxml-0.7.1-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/dict2css-0.3.0.post1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/docutils-0.18.1-py310hbe9552e_1.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/domdf-python-tools-3.8.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/entrypoints-0.4-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/filelock-3.14.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/html5lib-1.1-pyh9f0ad1d_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/idna-3.7-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/imagesize-1.4.1-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/importlib-metadata-7.1.0-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/importlib-resources-6.4.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/importlib_metadata-7.1.0-hd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/importlib_resources-6.4.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jinja2-3.1.4-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jsonschema-4.22.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jsonschema-specifications-2023.12.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jupyter_client-8.6.2-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/jupyter_core-5.7.2-py310hbe9552e_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jupyterlab_pygments-0.3.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/krb5-1.21.2-h92f50d5_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libabseil-20240116.2-cxx17_hebf3989_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libblas-3.9.0-22_osxarm64_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcblas-3.9.0-22_osxarm64_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcxx-17.0.6-h5f092b4_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libedit-3.1.20191231-hc8eb9b7_2.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libffi-3.4.2-h3422bc3_5.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgfortran-5.0.0-13_2_0_hd922786_3.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgfortran5-13.2.0-hf226fd6_3.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/liblapack-3.9.0-22_osxarm64_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libopenblas-0.3.27-openmp_h6c19121_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libprotobuf-4.25.3-hbfab5d5_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libsodium-1.0.18-h27ca646_1.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libsqlite-3.45.3-h091b4b1_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libzlib-1.3.1-hfb2fe0b_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/llvm-openmp-18.1.7-hde57baf_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/make-4.3-he57ea6c_1.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/markupsafe-2.1.5-py310hd125d64_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/mistune-3.0.2-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/msgpack-python-1.0.8-py310he1a186f_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/mypy_extensions-1.0.0-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/natsort-8.4.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/nbclient-0.10.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/nbconvert-7.16.4-hd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/nbconvert-core-7.16.4-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/nbconvert-pandoc-7.16.4-hd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/nbformat-5.10.4-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/nbsphinx-0.9.4-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ncurses-6.5-hb89a1cb_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/numpy-1.26.4-py310hd45542a_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/numpydoc-1.7.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/onnx-1.16.1-py310h0fe6b08_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/openssl-3.3.1-hfb2fe0b_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-24.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pandoc-3.2-hce30654_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pandocfilters-1.5.0-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/pbr-6.0.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pip-24.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pkgutil-resolve-name-1.3.10-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/platformdirs-4.2.2-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/protobuf-4.25.3-py310h1e88e72_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pygments-2.18.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pysocks-1.7.1-pyha2e5f31_6.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/python-3.10.14-h2469fbe_0_cpython.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python-dateutil-2.9.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python-fastjsonschema-2.19.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/python_abi-3.10-4_cp310.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pytz-2024.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pyzmq-26.0.3-py310h16e08c9_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/readline-8.2-h92ec313_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/referencing-0.35.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/requests-2.32.3-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/rpds-py-0.18.1-py310h947b723_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ruamel.yaml-0.18.6-py310hd125d64_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ruamel.yaml.clib-0.2.8-py310hd125d64_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-70.0.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-scm-8.1.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/six-1.16.0-pyh6c4a22f_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/snowballstemmer-2.2.0-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/soupsieve-2.5-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sphinx-5.0.0-pyh6c4a22f_1.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/sphinx-autodoc-typehints-1.19.2-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/sphinx-jinja2-compat-0.2.0.post1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sphinx-prompt-1.4.0-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/sphinx-tabs-3.4.1-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sphinx-toolbox-3.5.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sphinx_rtd_theme-2.0.0-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sphinxcontrib-apidoc-0.3.0-py_1.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/sphinxcontrib-applehelp-1.0.8-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sphinxcontrib-devhelp-1.0.6-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sphinxcontrib-htmlhelp-2.0.5-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sphinxcontrib-jquery-4.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sphinxcontrib-jsmath-1.0.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sphinxcontrib-qthelp-1.0.7-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sphinxcontrib-serializinghtml-1.1.10-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/spox-0.12.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tabulate-0.9.0-pyhd8ed1ab_1.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/tinycss2-1.3.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/tk-8.6.13-h5083fa2_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tomli-2.0.1-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/tornado-6.4.1-py310ha6dd24b_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/traitlets-5.14.3-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/typing-extensions-4.12.2-hd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.12.2-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/typing_inspect-0.9.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2024a-h0c530f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/urllib3-2.2.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/webencodings-0.5.1-pyhd8ed1ab_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/wheel-0.43.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/xz-5.2.6-h57fd34a_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/zeromq-4.3.5-hcc0f68c_4.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/zipp-3.19.2-pyhd8ed1ab_0.conda + win-64: + - conda: https://conda.anaconda.org/conda-forge/noarch/alabaster-0.7.16-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/apeye-1.4.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/apeye-core-1.1.5-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/attrs-23.2.0-pyh71513ae_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/autodocsumm-0.2.12-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/babel-2.14.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/beautifulsoup4-4.12.3-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/bleach-6.1.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/brotli-python-1.1.0-py310h00ffb61_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/bzip2-1.0.8-hcfcfb64_5.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/ca-certificates-2024.6.2-h56e8100_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cachecontrol-0.14.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/certifi-2024.6.2-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/charset-normalizer-3.3.2-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/colorama-0.4.6-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/cssutils-2.11.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/defusedxml-0.7.1-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/dict2css-0.3.0.post1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/docutils-0.18.1-py310h5588dad_1.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/domdf-python-tools-3.8.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/entrypoints-0.4-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/filelock-3.14.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/html5lib-1.1-pyh9f0ad1d_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/idna-3.7-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/imagesize-1.4.1-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/importlib-metadata-7.1.0-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/importlib-resources-6.4.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/importlib_metadata-7.1.0-hd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/importlib_resources-6.4.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/intel-openmp-2024.1.0-h57928b3_966.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jinja2-3.1.4-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jsonschema-4.22.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jsonschema-specifications-2023.12.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jupyter_client-8.6.2-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/jupyter_core-5.7.2-py310h5588dad_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jupyterlab_pygments-0.3.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/krb5-1.21.2-heb0366b_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libabseil-20240116.2-cxx17_h63175ca_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libblas-3.9.0-22_win64_mkl.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libcblas-3.9.0-22_win64_mkl.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libffi-3.4.2-h8ffe710_5.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/win-64/libhwloc-2.10.0-default_h8125262_1001.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libiconv-1.17-hcfcfb64_2.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/liblapack-3.9.0-22_win64_mkl.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libprotobuf-4.25.3-h503648d_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libsodium-1.0.18-h8d14728_1.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/win-64/libsqlite-3.45.3-hcfcfb64_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libxml2-2.12.7-h283a6d9_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libzlib-1.3.1-h2466b09_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/m2w64-gcc-libgfortran-5.3.0-6.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/win-64/m2w64-gcc-libs-5.3.0-7.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/win-64/m2w64-gcc-libs-core-5.3.0-7.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/win-64/m2w64-gmp-6.1.0-2.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/win-64/m2w64-libwinpthread-git-5.0.0.4634.697f757-2.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/win-64/make-4.3-h3d2af85_1.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/win-64/markupsafe-2.1.5-py310h8d17308_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/mistune-3.0.2-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/mkl-2024.1.0-h66d3029_692.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/msgpack-python-1.0.8-py310hc19bc0b_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/msys2-conda-epoch-20160418-1.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/mypy_extensions-1.0.0-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/natsort-8.4.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/nbclient-0.10.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/nbconvert-7.16.4-hd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/nbconvert-core-7.16.4-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/nbconvert-pandoc-7.16.4-hd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/nbformat-5.10.4-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/nbsphinx-0.9.4-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/numpy-1.26.4-py310hf667824_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/numpydoc-1.7.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/onnx-1.16.1-py310hc705b4a_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/openssl-3.3.1-h2466b09_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-24.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/pandoc-3.2-h57928b3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pandocfilters-1.5.0-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/pbr-6.0.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pip-24.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pkgutil-resolve-name-1.3.10-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/platformdirs-4.2.2-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/protobuf-4.25.3-py310hf536535_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/pthreads-win32-2.9.1-hfa6e2cd_3.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/pygments-2.18.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pysocks-1.7.1-pyh0701188_6.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/win-64/python-3.10.14-h4de0772_0_cpython.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python-dateutil-2.9.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python-fastjsonschema-2.19.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/python_abi-3.10-4_cp310.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pytz-2024.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/pywin32-306-py310h00ffb61_2.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/pyzmq-26.0.3-py310h656833d_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/referencing-0.35.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/requests-2.32.3-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/rpds-py-0.18.1-py310hc226416_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/ruamel.yaml-0.18.6-py310h8d17308_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/ruamel.yaml.clib-0.2.8-py310h8d17308_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-70.0.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-scm-8.1.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/six-1.16.0-pyh6c4a22f_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/snowballstemmer-2.2.0-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/soupsieve-2.5-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sphinx-5.0.0-pyh6c4a22f_1.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/sphinx-autodoc-typehints-1.19.2-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/sphinx-jinja2-compat-0.2.0.post1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sphinx-prompt-1.4.0-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/sphinx-tabs-3.4.1-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sphinx-toolbox-3.5.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sphinx_rtd_theme-2.0.0-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sphinxcontrib-apidoc-0.3.0-py_1.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/sphinxcontrib-applehelp-1.0.8-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sphinxcontrib-devhelp-1.0.6-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sphinxcontrib-htmlhelp-2.0.5-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sphinxcontrib-jquery-4.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sphinxcontrib-jsmath-1.0.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sphinxcontrib-qthelp-1.0.7-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sphinxcontrib-serializinghtml-1.1.10-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/spox-0.12.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tabulate-0.9.0-pyhd8ed1ab_1.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/win-64/tbb-2021.12.0-hc790b64_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tinycss2-1.3.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/tk-8.6.13-h5226925_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tomli-2.0.1-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/win-64/tornado-6.4.1-py310ha8f682b_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/traitlets-5.14.3-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/typing-extensions-4.12.2-hd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.12.2-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/typing_inspect-0.9.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2024a-h0c530f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/ucrt-10.0.22621.0-h57928b3_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/urllib3-2.2.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/vc-14.3-h8a93ad2_20.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/vc14_runtime-14.40.33810-ha82c5b3_20.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/vs2015_runtime-14.40.33810-h3bf8584_20.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/webencodings-0.5.1-pyhd8ed1ab_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/wheel-0.43.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/win_inet_pton-1.1.0-pyhd8ed1ab_6.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/win-64/xz-5.2.6-h8d14728_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/win-64/zeromq-4.3.5-he1f189c_4.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/zipp-3.19.2-pyhd8ed1ab_0.conda + lint: + channels: + - url: https://conda.anaconda.org/conda-forge/ + packages: + linux-64: + - conda: https://conda.anaconda.org/conda-forge/linux-64/_libgcc_mutex-0.1-conda_forge.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-64/_openmp_mutex-4.5-2_gnu.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-64/bzip2-1.0.8-hd590300_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/ca-certificates-2024.6.2-hbcca054_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cffi-1.16.0-py312hf06ca03_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cfgv-3.3.1-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/charset-normalizer-3.3.2-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/distlib-0.3.8-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/docformatter-1.7.5-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/filelock-3.14.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/icu-73.2-h59595ed_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/identify-2.5.36-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/insert-license-header-1.3.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/ld_impl_linux-64-2.40-hf3520f5_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libblas-3.9.0-22_linux64_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libcblas-3.9.0-22_linux64_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libexpat-2.6.2-h59595ed_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libffi-3.4.2-h7f98852_5.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-ng-13.2.0-h77fa898_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran-ng-13.2.0-h69a702a_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran5-13.2.0-hca663fb_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgomp-13.2.0-h77fa898_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/liblapack-3.9.0-22_linux64_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libnsl-2.0.1-hd590300_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenblas-0.3.27-pthreads_h413a1c8_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libsqlite-3.45.3-h2797004_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-ng-13.2.0-hc0a3c3a_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libuuid-2.38.1-h0b41bf4_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libuv-1.48.0-hd590300_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libxcrypt-4.4.36-hd590300_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libzlib-1.3.1-h4ab18f5_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/ncurses-6.5-h59595ed_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/nodeenv-1.9.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/nodejs-20.12.2-hb753e55_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/numpy-1.26.4-py312heda63a1_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/openssl-3.3.1-h4ab18f5_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/platformdirs-4.2.2-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pre-commit-3.7.1-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pre-commit-hooks-4.6.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/prettier-3.2.5-h31abb78_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pycparser-2.22-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/python-3.12.3-hab00c5b_0_cpython.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/python_abi-3.12-4_cp312.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/pyyaml-6.0.1-py312h98912ed_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/rapidfuzz-3.9.3-py312h7070661_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/readline-8.2-h8228510_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/ruamel.yaml-0.18.6-py312h98912ed_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/ruamel.yaml.clib-0.2.8-py312h98912ed_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/ruff-0.4.8-py312h5715c7c_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-70.0.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/tk-8.6.13-noxft_h4845f30_101.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tomli-2.0.1-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-64/typos-1.22.3-he9194b0_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2024a-h0c530f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/ukkonen-1.0.1-py312h8572e83_4.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/untokenize-0.1.1-py_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/virtualenv-20.26.2-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xz-5.2.6-h166bdaf_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-64/yaml-0.2.5-h7f98852_2.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-64/zlib-1.3.1-h4ab18f5_1.conda + linux-aarch64: + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/_openmp_mutex-4.5-2_gnu.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/bzip2-1.0.8-h31becfc_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ca-certificates-2024.6.2-hcefe29a_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cffi-1.16.0-py312hf3c74c0_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cfgv-3.3.1-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/charset-normalizer-3.3.2-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/distlib-0.3.8-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/docformatter-1.7.5-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/filelock-3.14.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/icu-73.2-h787c7f5_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/identify-2.5.36-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/insert-license-header-1.3.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ld_impl_linux-aarch64-2.40-h9fc2d93_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libblas-3.9.0-22_linuxaarch64_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libcblas-3.9.0-22_linuxaarch64_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libexpat-2.6.2-h2f0025b_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libffi-3.4.2-h3557bc0_5.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgcc-ng-13.2.0-he277a41_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgfortran-ng-13.2.0-he9431aa_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgfortran5-13.2.0-h87d9d71_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgomp-13.2.0-he277a41_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/liblapack-3.9.0-22_linuxaarch64_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libnsl-2.0.1-h31becfc_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libopenblas-0.3.27-pthreads_h5a5ec62_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libsqlite-3.45.3-h194ca79_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libstdcxx-ng-13.2.0-h3f4de04_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libuuid-2.38.1-hb4cce97_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libuv-1.48.0-h31becfc_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libxcrypt-4.4.36-h31becfc_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libzlib-1.3.1-h68df207_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ncurses-6.5-h0425590_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/nodeenv-1.9.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/nodejs-20.12.2-hc1f8a26_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/numpy-1.26.4-py312h470d778_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/openssl-3.3.1-h68df207_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/platformdirs-4.2.2-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pre-commit-3.7.1-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pre-commit-hooks-4.6.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/prettier-3.2.5-h4e45a9e_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pycparser-2.22-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/python-3.12.3-h43d1f9e_0_cpython.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/python_abi-3.12-4_cp312.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/pyyaml-6.0.1-py312hdd3e373_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/rapidfuzz-3.9.3-py312h7f10901_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/readline-8.2-h8fc344f_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ruamel.yaml-0.18.6-py312hdd3e373_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ruamel.yaml.clib-0.2.8-py312hdd3e373_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ruff-0.4.8-py312h18b2cab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-70.0.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/tk-8.6.13-h194ca79_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tomli-2.0.1-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/typos-1.22.3-h09b8157_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2024a-h0c530f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ukkonen-1.0.1-py312h8f0b210_4.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/untokenize-0.1.1-py_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/virtualenv-20.26.2-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/xz-5.2.6-h9cdd2b7_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/yaml-0.2.5-hf897c2e_2.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/zlib-1.3.1-h68df207_1.conda + osx-64: + - conda: https://conda.anaconda.org/conda-forge/osx-64/bzip2-1.0.8-h10d778d_5.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/ca-certificates-2024.6.2-h8857fd0_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/cffi-1.16.0-py312h38bf5a0_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cfgv-3.3.1-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/charset-normalizer-3.3.2-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/distlib-0.3.8-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/docformatter-1.7.5-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/filelock-3.14.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/icu-73.2-hf5e326d_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/identify-2.5.36-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/insert-license-header-1.3.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libblas-3.9.0-22_osx64_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libcblas-3.9.0-22_osx64_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libcxx-17.0.6-h88467a6_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libexpat-2.6.2-h73e2aa4_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libffi-3.4.2-h0d85af4_5.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/osx-64/libgfortran-5.0.0-13_2_0_h97931a8_3.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libgfortran5-13.2.0-h2873a65_3.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/liblapack-3.9.0-22_osx64_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libopenblas-0.3.27-openmp_hfef2a42_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libsqlite-3.45.3-h92b6c6a_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libuv-1.48.0-h67532ce_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libzlib-1.3.1-h87427d6_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/llvm-openmp-18.1.7-h15ab845_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/ncurses-6.5-h5846eda_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/nodeenv-1.9.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/nodejs-20.12.2-hfc0f20e_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/numpy-1.26.4-py312he3a82b2_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/openssl-3.3.1-h87427d6_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/platformdirs-4.2.2-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pre-commit-3.7.1-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pre-commit-hooks-4.6.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/prettier-3.2.5-hbd11d21_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pycparser-2.22-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/python-3.12.3-h1411813_0_cpython.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/python_abi-3.12-4_cp312.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/pyyaml-6.0.1-py312h104f124_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/rapidfuzz-3.9.3-py312h28f332c_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/readline-8.2-h9e318b2_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/ruamel.yaml-0.18.6-py312h41838bb_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/ruamel.yaml.clib-0.2.8-py312h41838bb_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/ruff-0.4.8-py312h8b25c6c_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-70.0.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/tk-8.6.13-h1abcd95_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tomli-2.0.1-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/osx-64/typos-1.22.3-h686f776_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2024a-h0c530f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/ukkonen-1.0.1-py312h49ebfd2_4.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/untokenize-0.1.1-py_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/virtualenv-20.26.2-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/xz-5.2.6-h775f41a_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/osx-64/yaml-0.2.5-h0d85af4_2.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/osx-64/zlib-1.3.1-h87427d6_1.conda + osx-arm64: + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/bzip2-1.0.8-h93a5062_5.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ca-certificates-2024.6.2-hf0a4a13_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/cffi-1.16.0-py312h8e38eb3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cfgv-3.3.1-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/charset-normalizer-3.3.2-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/distlib-0.3.8-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/docformatter-1.7.5-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/filelock-3.14.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/icu-73.2-hc8870d7_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/identify-2.5.36-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/insert-license-header-1.3.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libblas-3.9.0-22_osxarm64_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcblas-3.9.0-22_osxarm64_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcxx-17.0.6-h5f092b4_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libexpat-2.6.2-hebf3989_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libffi-3.4.2-h3422bc3_5.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgfortran-5.0.0-13_2_0_hd922786_3.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgfortran5-13.2.0-hf226fd6_3.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/liblapack-3.9.0-22_osxarm64_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libopenblas-0.3.27-openmp_h6c19121_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libsqlite-3.45.3-h091b4b1_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libuv-1.48.0-h93a5062_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libzlib-1.3.1-hfb2fe0b_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/llvm-openmp-18.1.7-hde57baf_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ncurses-6.5-hb89a1cb_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/nodeenv-1.9.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/nodejs-20.12.2-h3b52c9b_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/numpy-1.26.4-py312h8442bc7_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/openssl-3.3.1-hfb2fe0b_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/platformdirs-4.2.2-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pre-commit-3.7.1-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pre-commit-hooks-4.6.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/prettier-3.2.5-hb67532b_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pycparser-2.22-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/python-3.12.3-h4a7b5fc_0_cpython.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/python_abi-3.12-4_cp312.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pyyaml-6.0.1-py312h02f2b3b_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/rapidfuzz-3.9.3-py312h5c2e7bc_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/readline-8.2-h92ec313_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ruamel.yaml-0.18.6-py312he37b823_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ruamel.yaml.clib-0.2.8-py312he37b823_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ruff-0.4.8-py312h3402d49_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-70.0.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/tk-8.6.13-h5083fa2_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tomli-2.0.1-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/typos-1.22.3-h6e96688_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2024a-h0c530f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ukkonen-1.0.1-py312h389731b_4.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/untokenize-0.1.1-py_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/virtualenv-20.26.2-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/xz-5.2.6-h57fd34a_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/yaml-0.2.5-h3422bc3_2.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/zlib-1.3.1-hfb2fe0b_1.conda + win-64: + - conda: https://conda.anaconda.org/conda-forge/win-64/bzip2-1.0.8-hcfcfb64_5.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/ca-certificates-2024.6.2-h56e8100_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/cffi-1.16.0-py312he70551f_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cfgv-3.3.1-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/charset-normalizer-3.3.2-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/distlib-0.3.8-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/docformatter-1.7.5-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/filelock-3.14.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/identify-2.5.36-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/insert-license-header-1.3.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/intel-openmp-2024.1.0-h57928b3_966.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libblas-3.9.0-22_win64_mkl.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libcblas-3.9.0-22_win64_mkl.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libexpat-2.6.2-h63175ca_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libffi-3.4.2-h8ffe710_5.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/win-64/libhwloc-2.10.0-default_h8125262_1001.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libiconv-1.17-hcfcfb64_2.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/liblapack-3.9.0-22_win64_mkl.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libsqlite-3.45.3-hcfcfb64_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libxml2-2.12.7-h283a6d9_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libzlib-1.3.1-h2466b09_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/m2w64-gcc-libgfortran-5.3.0-6.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/win-64/m2w64-gcc-libs-5.3.0-7.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/win-64/m2w64-gcc-libs-core-5.3.0-7.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/win-64/m2w64-gmp-6.1.0-2.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/win-64/m2w64-libwinpthread-git-5.0.0.4634.697f757-2.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/win-64/mkl-2024.1.0-h66d3029_692.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/msys2-conda-epoch-20160418-1.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/nodeenv-1.9.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/nodejs-20.12.2-h57928b3_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/numpy-1.26.4-py312h8753938_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/openssl-3.3.1-h2466b09_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/platformdirs-4.2.2-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pre-commit-3.7.1-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pre-commit-hooks-4.6.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/prettier-3.2.5-h98b3114_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/pthreads-win32-2.9.1-hfa6e2cd_3.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/pycparser-2.22-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/python-3.12.3-h2628c8c_0_cpython.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/python_abi-3.12-4_cp312.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/pyyaml-6.0.1-py312he70551f_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/rapidfuzz-3.9.3-py312h275cf98_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/ruamel.yaml-0.18.6-py312he70551f_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/ruamel.yaml.clib-0.2.8-py312he70551f_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/ruff-0.4.8-py312h7a6832a_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-70.0.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/tbb-2021.12.0-hc790b64_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/tk-8.6.13-h5226925_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tomli-2.0.1-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/win-64/typos-1.22.3-h813c833_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2024a-h0c530f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/ucrt-10.0.22621.0-h57928b3_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/win-64/ukkonen-1.0.1-py312h0d7def4_4.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/untokenize-0.1.1-py_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/win-64/vc-14.3-h8a93ad2_20.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/vc14_runtime-14.40.33810-ha82c5b3_20.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/virtualenv-20.26.2-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/vs2015_runtime-14.40.33810-h3bf8584_20.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/xz-5.2.6-h8d14728_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/win-64/yaml-0.2.5-h8ffe710_2.tar.bz2 + py310: + channels: + - url: https://conda.anaconda.org/conda-forge/ + packages: + linux-64: + - conda: https://conda.anaconda.org/conda-forge/linux-64/_libgcc_mutex-0.1-conda_forge.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-64/_openmp_mutex-4.5-2_gnu.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/attrs-23.2.0-pyh71513ae_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/backports.zoneinfo-0.2.1-py310hff52083_8.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/bzip2-1.0.8-hd590300_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/ca-certificates-2024.6.2-hbcca054_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/click-8.1.7-unix_pyh707e725_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/colorama-0.4.6-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/coloredlogs-15.0.1-pyhd8ed1ab_3.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-64/coverage-7.5.3-py310hc51659f_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/exceptiongroup-1.2.0-pyhd8ed1ab_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/execnet-2.1.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gmp-6.3.0-h59595ed_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gmpy2-2.1.5-py310hc7909c9_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/humanfriendly-10.0-pyhd8ed1ab_6.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/hypothesis-6.103.1-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/iniconfig-2.0.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/ld_impl_linux-64-2.40-hf3520f5_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libabseil-20240116.2-cxx17_h59595ed_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libblas-3.9.0-22_linux64_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libcblas-3.9.0-22_linux64_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libffi-3.4.2-h7f98852_5.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-ng-13.2.0-h77fa898_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran-ng-13.2.0-h69a702a_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran5-13.2.0-hca663fb_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgomp-13.2.0-h77fa898_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/liblapack-3.9.0-22_linux64_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libnsl-2.0.1-hd590300_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenblas-0.3.27-pthreads_h413a1c8_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libprotobuf-4.25.3-h08a7969_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libsqlite-3.45.3-h2797004_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-ng-13.2.0-hc0a3c3a_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libuuid-2.38.1-h0b41bf4_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libxcrypt-4.4.36-hd590300_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libzlib-1.3.1-h4ab18f5_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/mpc-1.3.1-hfe3b2da_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/mpfr-4.2.1-h9458935_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/mpmath-1.3.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/mypy-1.10.0-py310hc51659f_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/mypy_extensions-1.0.0-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/ncurses-6.5-h59595ed_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/numpy-1.26.4-py310hb13e2d6_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/onnx-1.16.1-py310hc505232_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/onnxruntime-1.18.0-py310hf6b898b_2_cpu.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/openssl-3.3.1-h4ab18f5_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-24.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pip-24.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pluggy-1.5.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/protobuf-4.25.3-py310ha8c1f0e_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/psutil-5.9.8-py310h2372a71_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-8.2.2-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-cov-5.0.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-json-report-1.5.0-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-metadata-3.1.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-xdist-3.5.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/python-3.10.14-hd12c33a_0_cpython.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python-flatbuffers-24.3.25-pyh59ac667_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/python_abi-3.10-4_cp310.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/readline-8.2-h8228510_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-70.0.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-scm-8.1.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sortedcontainers-2.4.0-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/spox-0.12.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sympy-1.12-pypyh9d50eac_103.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/tk-8.6.13-noxft_h4845f30_101.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/toml-0.10.2-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/tomli-2.0.1-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/typing-extensions-4.12.2-hd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.12.2-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2024a-h0c530f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/wheel-0.43.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xz-5.2.6-h166bdaf_0.tar.bz2 + linux-aarch64: + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/_openmp_mutex-4.5-2_gnu.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/attrs-23.2.0-pyh71513ae_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/backports.zoneinfo-0.2.1-py310h4c7bcd0_8.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/bzip2-1.0.8-h31becfc_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ca-certificates-2024.6.2-hcefe29a_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/click-8.1.7-unix_pyh707e725_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/colorama-0.4.6-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/coloredlogs-15.0.1-pyhd8ed1ab_3.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/coverage-7.5.3-py310h03727f4_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/exceptiongroup-1.2.0-pyhd8ed1ab_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/execnet-2.1.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gmp-6.3.0-h2f0025b_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gmpy2-2.1.5-py310h05bcf56_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/humanfriendly-10.0-pyhd8ed1ab_6.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/hypothesis-6.103.1-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/iniconfig-2.0.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ld_impl_linux-aarch64-2.40-h9fc2d93_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libabseil-20240116.2-cxx17_h2f0025b_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libblas-3.9.0-22_linuxaarch64_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libcblas-3.9.0-22_linuxaarch64_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libffi-3.4.2-h3557bc0_5.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgcc-ng-13.2.0-he277a41_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgfortran-ng-13.2.0-he9431aa_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgfortran5-13.2.0-h87d9d71_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgomp-13.2.0-he277a41_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/liblapack-3.9.0-22_linuxaarch64_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libnsl-2.0.1-h31becfc_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libopenblas-0.3.27-pthreads_h5a5ec62_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libprotobuf-4.25.3-h648ac29_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libsqlite-3.45.3-h194ca79_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libstdcxx-ng-13.2.0-h3f4de04_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libuuid-2.38.1-hb4cce97_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libxcrypt-4.4.36-h31becfc_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libzlib-1.3.1-h68df207_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/mpc-1.3.1-hf4c8f4c_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/mpfr-4.2.1-ha2d0fc4_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/mpmath-1.3.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/mypy-1.10.0-py310hb52b2da_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/mypy_extensions-1.0.0-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ncurses-6.5-h0425590_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/numpy-1.26.4-py310hcbab775_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/onnx-1.16.1-py310h25cd676_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/onnxruntime-1.18.0-py310h5952d15_2_cpu.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/openssl-3.3.1-h68df207_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-24.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pip-24.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pluggy-1.5.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/protobuf-4.25.3-py310h6802e18_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/psutil-5.9.8-py310hb299538_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-8.2.2-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-cov-5.0.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-json-report-1.5.0-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-metadata-3.1.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-xdist-3.5.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/python-3.10.14-hbbe8eec_0_cpython.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python-flatbuffers-24.3.25-pyh59ac667_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/python_abi-3.10-4_cp310.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/readline-8.2-h8fc344f_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-70.0.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-scm-8.1.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sortedcontainers-2.4.0-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/spox-0.12.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sympy-1.12-pypyh9d50eac_103.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/tk-8.6.13-h194ca79_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/toml-0.10.2-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/tomli-2.0.1-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/typing-extensions-4.12.2-hd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.12.2-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2024a-h0c530f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/wheel-0.43.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/xz-5.2.6-h9cdd2b7_0.tar.bz2 + osx-64: + - conda: https://conda.anaconda.org/conda-forge/noarch/attrs-23.2.0-pyh71513ae_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/backports.zoneinfo-0.2.1-py310h2ec42d9_8.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/bzip2-1.0.8-h10d778d_5.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/ca-certificates-2024.6.2-h8857fd0_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/click-8.1.7-unix_pyh707e725_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/colorama-0.4.6-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/coloredlogs-15.0.1-pyhd8ed1ab_3.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/osx-64/coverage-7.5.3-py310h936d840_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/exceptiongroup-1.2.0-pyhd8ed1ab_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/execnet-2.1.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/gmp-6.3.0-h73e2aa4_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/gmpy2-2.1.5-py310h0310db1_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/humanfriendly-10.0-pyhd8ed1ab_6.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/hypothesis-6.103.1-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/iniconfig-2.0.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libabseil-20240116.2-cxx17_hc1bcbd7_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libblas-3.9.0-22_osx64_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libcblas-3.9.0-22_osx64_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libcxx-17.0.6-h88467a6_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libffi-3.4.2-h0d85af4_5.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/osx-64/libgfortran-5.0.0-13_2_0_h97931a8_3.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libgfortran5-13.2.0-h2873a65_3.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/liblapack-3.9.0-22_osx64_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libopenblas-0.3.27-openmp_hfef2a42_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libprotobuf-4.25.3-h4e4d658_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libsqlite-3.45.3-h92b6c6a_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libzlib-1.3.1-h87427d6_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/llvm-openmp-18.1.7-h15ab845_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/mpc-1.3.1-h81bd1dd_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/mpfr-4.2.1-h4f6b447_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/mpmath-1.3.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/mypy-1.10.0-py310h74a5a53_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/mypy_extensions-1.0.0-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/ncurses-6.5-h5846eda_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/numpy-1.26.4-py310h4bfa8fc_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/onnx-1.16.1-py310h00e9488_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/onnxruntime-1.18.0-py310h8035873_2_cpu.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/openssl-3.3.1-h87427d6_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-24.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pip-24.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pluggy-1.5.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/protobuf-4.25.3-py310h9015309_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/psutil-5.9.8-py310hb372a2b_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-8.2.2-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-cov-5.0.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-json-report-1.5.0-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-metadata-3.1.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-xdist-3.5.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/python-3.10.14-h00d2728_0_cpython.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python-flatbuffers-24.3.25-pyh59ac667_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/python_abi-3.10-4_cp310.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/readline-8.2-h9e318b2_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-70.0.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-scm-8.1.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sortedcontainers-2.4.0-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/spox-0.12.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sympy-1.12-pypyh9d50eac_103.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/tk-8.6.13-h1abcd95_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/toml-0.10.2-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/tomli-2.0.1-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/typing-extensions-4.12.2-hd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.12.2-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2024a-h0c530f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/wheel-0.43.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/xz-5.2.6-h775f41a_0.tar.bz2 + osx-arm64: + - conda: https://conda.anaconda.org/conda-forge/noarch/attrs-23.2.0-pyh71513ae_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/backports.zoneinfo-0.2.1-py310hbe9552e_8.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/bzip2-1.0.8-h93a5062_5.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ca-certificates-2024.6.2-hf0a4a13_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/click-8.1.7-unix_pyh707e725_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/colorama-0.4.6-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/coloredlogs-15.0.1-pyhd8ed1ab_3.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/coverage-7.5.3-py310ha6dd24b_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/exceptiongroup-1.2.0-pyhd8ed1ab_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/execnet-2.1.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/gmp-6.3.0-hebf3989_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/gmpy2-2.1.5-py310h3bc658a_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/humanfriendly-10.0-pyhd8ed1ab_6.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/hypothesis-6.103.1-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/iniconfig-2.0.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libabseil-20240116.2-cxx17_hebf3989_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libblas-3.9.0-22_osxarm64_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcblas-3.9.0-22_osxarm64_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcxx-17.0.6-h5f092b4_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libffi-3.4.2-h3422bc3_5.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgfortran-5.0.0-13_2_0_hd922786_3.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgfortran5-13.2.0-hf226fd6_3.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/liblapack-3.9.0-22_osxarm64_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libopenblas-0.3.27-openmp_h6c19121_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libprotobuf-4.25.3-hbfab5d5_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libsqlite-3.45.3-h091b4b1_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libzlib-1.3.1-hfb2fe0b_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/llvm-openmp-18.1.7-hde57baf_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/mpc-1.3.1-h91ba8db_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/mpfr-4.2.1-h41d338b_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/mpmath-1.3.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/mypy-1.10.0-py310h8431ef1_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/mypy_extensions-1.0.0-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ncurses-6.5-hb89a1cb_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/numpy-1.26.4-py310hd45542a_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/onnx-1.16.1-py310h0fe6b08_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/onnxruntime-1.18.0-py310hfb6a49c_2_cpu.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/openssl-3.3.1-hfb2fe0b_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-24.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pip-24.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pluggy-1.5.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/protobuf-4.25.3-py310h1e88e72_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/psutil-5.9.8-py310hd125d64_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-8.2.2-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-cov-5.0.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-json-report-1.5.0-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-metadata-3.1.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-xdist-3.5.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/python-3.10.14-h2469fbe_0_cpython.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python-flatbuffers-24.3.25-pyh59ac667_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/python_abi-3.10-4_cp310.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/readline-8.2-h92ec313_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-70.0.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-scm-8.1.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sortedcontainers-2.4.0-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/spox-0.12.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sympy-1.12-pypyh9d50eac_103.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/tk-8.6.13-h5083fa2_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/toml-0.10.2-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/tomli-2.0.1-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/typing-extensions-4.12.2-hd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.12.2-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2024a-h0c530f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/wheel-0.43.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/xz-5.2.6-h57fd34a_0.tar.bz2 + win-64: + - conda: https://conda.anaconda.org/conda-forge/noarch/attrs-23.2.0-pyh71513ae_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/backports.zoneinfo-0.2.1-py310h5588dad_8.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/bzip2-1.0.8-hcfcfb64_5.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/ca-certificates-2024.6.2-h56e8100_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/click-8.1.7-win_pyh7428d3b_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/colorama-0.4.6-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/coloredlogs-15.0.1-pyhd8ed1ab_3.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/win-64/coverage-7.5.3-py310ha8f682b_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/exceptiongroup-1.2.0-pyhd8ed1ab_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/execnet-2.1.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/humanfriendly-10.0-py310h5588dad_5.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/hypothesis-6.103.1-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/iniconfig-2.0.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/intel-openmp-2024.1.0-h57928b3_966.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libabseil-20240116.2-cxx17_h63175ca_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libblas-3.9.0-22_win64_mkl.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libcblas-3.9.0-22_win64_mkl.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libffi-3.4.2-h8ffe710_5.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/win-64/libhwloc-2.10.0-default_h8125262_1001.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libiconv-1.17-hcfcfb64_2.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/liblapack-3.9.0-22_win64_mkl.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libprotobuf-4.25.3-h503648d_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libsqlite-3.45.3-hcfcfb64_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libxml2-2.12.7-h283a6d9_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libzlib-1.3.1-h2466b09_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/mkl-2024.1.0-h66d3029_692.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/mpmath-1.3.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/mypy-1.10.0-py310ha8f682b_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/mypy_extensions-1.0.0-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/numpy-1.26.4-py310hf667824_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/onnx-1.16.1-py310hc705b4a_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/onnxruntime-1.18.0-py310h2bb40e1_2_cpu.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/openssl-3.3.1-h2466b09_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-24.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pip-24.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pluggy-1.5.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/protobuf-4.25.3-py310hf536535_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/psutil-5.9.8-py310h8d17308_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/pthreads-win32-2.9.1-hfa6e2cd_3.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/win-64/pyreadline3-3.4.1-py310h5588dad_3.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-8.2.2-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-cov-5.0.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-json-report-1.5.0-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-metadata-3.1.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-xdist-3.5.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/python-3.10.14-h4de0772_0_cpython.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python-flatbuffers-24.3.25-pyh59ac667_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/python_abi-3.10-4_cp310.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-70.0.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-scm-8.1.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sortedcontainers-2.4.0-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/spox-0.12.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sympy-1.12-pyh04b8f61_3.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/tbb-2021.12.0-hc790b64_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/tk-8.6.13-h5226925_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/toml-0.10.2-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/tomli-2.0.1-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/typing-extensions-4.12.2-hd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.12.2-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2024a-h0c530f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/ucrt-10.0.22621.0-h57928b3_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/win-64/vc-14.3-h8a93ad2_20.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/vc14_runtime-14.40.33810-ha82c5b3_20.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/vs2015_runtime-14.40.33810-h3bf8584_20.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/wheel-0.43.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/xz-5.2.6-h8d14728_0.tar.bz2 + py311: + channels: + - url: https://conda.anaconda.org/conda-forge/ + packages: + linux-64: + - conda: https://conda.anaconda.org/conda-forge/linux-64/_libgcc_mutex-0.1-conda_forge.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-64/_openmp_mutex-4.5-2_gnu.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/attrs-23.2.0-pyh71513ae_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/backports.zoneinfo-0.2.1-py311h38be061_8.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/bzip2-1.0.8-hd590300_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/ca-certificates-2024.6.2-hbcca054_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/click-8.1.7-unix_pyh707e725_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/colorama-0.4.6-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/coloredlogs-15.0.1-pyhd8ed1ab_3.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-64/coverage-7.5.3-py311h331c9d8_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/exceptiongroup-1.2.0-pyhd8ed1ab_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/execnet-2.1.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gmp-6.3.0-h59595ed_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gmpy2-2.1.5-py311hc4f1f91_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/humanfriendly-10.0-pyhd8ed1ab_6.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/hypothesis-6.103.1-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/iniconfig-2.0.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/ld_impl_linux-64-2.40-hf3520f5_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libabseil-20240116.2-cxx17_h59595ed_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libblas-3.9.0-22_linux64_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libcblas-3.9.0-22_linux64_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libexpat-2.6.2-h59595ed_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libffi-3.4.2-h7f98852_5.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-ng-13.2.0-h77fa898_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran-ng-13.2.0-h69a702a_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran5-13.2.0-hca663fb_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgomp-13.2.0-h77fa898_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/liblapack-3.9.0-22_linux64_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libnsl-2.0.1-hd590300_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenblas-0.3.27-pthreads_h413a1c8_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libprotobuf-4.25.3-h08a7969_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libsqlite-3.45.3-h2797004_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-ng-13.2.0-hc0a3c3a_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libuuid-2.38.1-h0b41bf4_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libxcrypt-4.4.36-hd590300_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libzlib-1.3.1-h4ab18f5_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/mpc-1.3.1-hfe3b2da_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/mpfr-4.2.1-h9458935_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/mpmath-1.3.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/mypy-1.10.0-py311h331c9d8_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/mypy_extensions-1.0.0-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/ncurses-6.5-h59595ed_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/numpy-1.26.4-py311h64a7726_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/onnx-1.16.1-py311h0511f7a_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/onnxruntime-1.18.0-py311hd0df81e_2_cpu.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/openssl-3.3.1-h4ab18f5_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-24.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pip-24.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pluggy-1.5.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/protobuf-4.25.3-py311h7b78aeb_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/psutil-5.9.8-py311h459d7ec_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-8.2.2-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-cov-5.0.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-json-report-1.5.0-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-metadata-3.1.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-xdist-3.5.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/python-3.11.9-hb806964_0_cpython.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python-flatbuffers-24.3.25-pyh59ac667_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/python_abi-3.11-4_cp311.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/readline-8.2-h8228510_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-70.0.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-scm-8.1.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sortedcontainers-2.4.0-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/spox-0.12.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sympy-1.12-pypyh9d50eac_103.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/tk-8.6.13-noxft_h4845f30_101.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/toml-0.10.2-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/tomli-2.0.1-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/typing-extensions-4.12.2-hd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.12.2-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2024a-h0c530f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/wheel-0.43.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xz-5.2.6-h166bdaf_0.tar.bz2 + linux-aarch64: + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/_openmp_mutex-4.5-2_gnu.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/attrs-23.2.0-pyh71513ae_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/backports.zoneinfo-0.2.1-py311hec3470c_8.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/bzip2-1.0.8-h31becfc_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ca-certificates-2024.6.2-hcefe29a_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/click-8.1.7-unix_pyh707e725_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/colorama-0.4.6-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/coloredlogs-15.0.1-pyhd8ed1ab_3.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/coverage-7.5.3-py311h323e239_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/exceptiongroup-1.2.0-pyhd8ed1ab_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/execnet-2.1.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gmp-6.3.0-h2f0025b_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gmpy2-2.1.5-py311h3c136a7_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/humanfriendly-10.0-pyhd8ed1ab_6.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/hypothesis-6.103.1-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/iniconfig-2.0.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ld_impl_linux-aarch64-2.40-h9fc2d93_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libabseil-20240116.2-cxx17_h2f0025b_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libblas-3.9.0-22_linuxaarch64_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libcblas-3.9.0-22_linuxaarch64_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libexpat-2.6.2-h2f0025b_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libffi-3.4.2-h3557bc0_5.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgcc-ng-13.2.0-he277a41_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgfortran-ng-13.2.0-he9431aa_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgfortran5-13.2.0-h87d9d71_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgomp-13.2.0-he277a41_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/liblapack-3.9.0-22_linuxaarch64_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libnsl-2.0.1-h31becfc_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libopenblas-0.3.27-pthreads_h5a5ec62_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libprotobuf-4.25.3-h648ac29_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libsqlite-3.45.3-h194ca79_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libstdcxx-ng-13.2.0-h3f4de04_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libuuid-2.38.1-hb4cce97_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libxcrypt-4.4.36-h31becfc_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libzlib-1.3.1-h68df207_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/mpc-1.3.1-hf4c8f4c_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/mpfr-4.2.1-ha2d0fc4_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/mpmath-1.3.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/mypy-1.10.0-py311hf4892ed_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/mypy_extensions-1.0.0-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ncurses-6.5-h0425590_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/numpy-1.26.4-py311h69ead2a_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/onnx-1.16.1-py311h6c98c43_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/onnxruntime-1.18.0-py311hc6cc989_2_cpu.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/openssl-3.3.1-h68df207_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-24.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pip-24.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pluggy-1.5.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/protobuf-4.25.3-py311hf10afa8_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/psutil-5.9.8-py311hcd402e7_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-8.2.2-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-cov-5.0.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-json-report-1.5.0-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-metadata-3.1.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-xdist-3.5.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/python-3.11.9-hddfb980_0_cpython.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python-flatbuffers-24.3.25-pyh59ac667_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/python_abi-3.11-4_cp311.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/readline-8.2-h8fc344f_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-70.0.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-scm-8.1.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sortedcontainers-2.4.0-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/spox-0.12.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sympy-1.12-pypyh9d50eac_103.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/tk-8.6.13-h194ca79_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/toml-0.10.2-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/tomli-2.0.1-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/typing-extensions-4.12.2-hd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.12.2-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2024a-h0c530f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/wheel-0.43.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/xz-5.2.6-h9cdd2b7_0.tar.bz2 + osx-64: + - conda: https://conda.anaconda.org/conda-forge/noarch/attrs-23.2.0-pyh71513ae_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/backports.zoneinfo-0.2.1-py311h6eed73b_8.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/bzip2-1.0.8-h10d778d_5.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/ca-certificates-2024.6.2-h8857fd0_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/click-8.1.7-unix_pyh707e725_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/colorama-0.4.6-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/coloredlogs-15.0.1-pyhd8ed1ab_3.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/osx-64/coverage-7.5.3-py311h72ae277_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/exceptiongroup-1.2.0-pyhd8ed1ab_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/execnet-2.1.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/gmp-6.3.0-h73e2aa4_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/gmpy2-2.1.5-py311hab17429_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/humanfriendly-10.0-pyhd8ed1ab_6.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/hypothesis-6.103.1-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/iniconfig-2.0.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libabseil-20240116.2-cxx17_hc1bcbd7_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libblas-3.9.0-22_osx64_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libcblas-3.9.0-22_osx64_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libcxx-17.0.6-h88467a6_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libexpat-2.6.2-h73e2aa4_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libffi-3.4.2-h0d85af4_5.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/osx-64/libgfortran-5.0.0-13_2_0_h97931a8_3.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libgfortran5-13.2.0-h2873a65_3.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/liblapack-3.9.0-22_osx64_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libopenblas-0.3.27-openmp_hfef2a42_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libprotobuf-4.25.3-h4e4d658_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libsqlite-3.45.3-h92b6c6a_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libzlib-1.3.1-h87427d6_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/llvm-openmp-18.1.7-h15ab845_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/mpc-1.3.1-h81bd1dd_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/mpfr-4.2.1-h4f6b447_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/mpmath-1.3.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/mypy-1.10.0-py311h39126ff_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/mypy_extensions-1.0.0-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/ncurses-6.5-h5846eda_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/numpy-1.26.4-py311hc43a94b_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/onnx-1.16.1-py311hd6d7c3e_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/onnxruntime-1.18.0-py311h3f3472b_2_cpu.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/openssl-3.3.1-h87427d6_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-24.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pip-24.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pluggy-1.5.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/protobuf-4.25.3-py311h01b5fa2_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/psutil-5.9.8-py311he705e18_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-8.2.2-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-cov-5.0.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-json-report-1.5.0-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-metadata-3.1.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-xdist-3.5.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/python-3.11.9-h657bba9_0_cpython.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python-flatbuffers-24.3.25-pyh59ac667_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/python_abi-3.11-4_cp311.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/readline-8.2-h9e318b2_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-70.0.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-scm-8.1.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sortedcontainers-2.4.0-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/spox-0.12.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sympy-1.12-pypyh9d50eac_103.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/tk-8.6.13-h1abcd95_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/toml-0.10.2-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/tomli-2.0.1-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/typing-extensions-4.12.2-hd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.12.2-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2024a-h0c530f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/wheel-0.43.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/xz-5.2.6-h775f41a_0.tar.bz2 + osx-arm64: + - conda: https://conda.anaconda.org/conda-forge/noarch/attrs-23.2.0-pyh71513ae_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/backports.zoneinfo-0.2.1-py311h267d04e_8.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/bzip2-1.0.8-h93a5062_5.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ca-certificates-2024.6.2-hf0a4a13_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/click-8.1.7-unix_pyh707e725_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/colorama-0.4.6-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/coloredlogs-15.0.1-pyhd8ed1ab_3.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/coverage-7.5.3-py311hd3f4193_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/exceptiongroup-1.2.0-pyhd8ed1ab_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/execnet-2.1.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/gmp-6.3.0-hebf3989_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/gmpy2-2.1.5-py311h1e33d93_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/humanfriendly-10.0-pyhd8ed1ab_6.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/hypothesis-6.103.1-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/iniconfig-2.0.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libabseil-20240116.2-cxx17_hebf3989_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libblas-3.9.0-22_osxarm64_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcblas-3.9.0-22_osxarm64_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcxx-17.0.6-h5f092b4_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libexpat-2.6.2-hebf3989_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libffi-3.4.2-h3422bc3_5.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgfortran-5.0.0-13_2_0_hd922786_3.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgfortran5-13.2.0-hf226fd6_3.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/liblapack-3.9.0-22_osxarm64_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libopenblas-0.3.27-openmp_h6c19121_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libprotobuf-4.25.3-hbfab5d5_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libsqlite-3.45.3-h091b4b1_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libzlib-1.3.1-hfb2fe0b_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/llvm-openmp-18.1.7-hde57baf_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/mpc-1.3.1-h91ba8db_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/mpfr-4.2.1-h41d338b_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/mpmath-1.3.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/mypy-1.10.0-py311hd23d018_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/mypy_extensions-1.0.0-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ncurses-6.5-hb89a1cb_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/numpy-1.26.4-py311h7125741_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/onnx-1.16.1-py311h6ec6fdf_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/onnxruntime-1.18.0-py311h66f376b_2_cpu.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/openssl-3.3.1-hfb2fe0b_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-24.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pip-24.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pluggy-1.5.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/protobuf-4.25.3-py311hea19e3d_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/psutil-5.9.8-py311h05b510d_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-8.2.2-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-cov-5.0.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-json-report-1.5.0-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-metadata-3.1.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-xdist-3.5.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/python-3.11.9-h932a869_0_cpython.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python-flatbuffers-24.3.25-pyh59ac667_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/python_abi-3.11-4_cp311.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/readline-8.2-h92ec313_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-70.0.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-scm-8.1.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sortedcontainers-2.4.0-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/spox-0.12.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sympy-1.12-pypyh9d50eac_103.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/tk-8.6.13-h5083fa2_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/toml-0.10.2-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/tomli-2.0.1-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/typing-extensions-4.12.2-hd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.12.2-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2024a-h0c530f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/wheel-0.43.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/xz-5.2.6-h57fd34a_0.tar.bz2 + win-64: + - conda: https://conda.anaconda.org/conda-forge/noarch/attrs-23.2.0-pyh71513ae_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/backports.zoneinfo-0.2.1-py311h1ea47a8_8.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/bzip2-1.0.8-hcfcfb64_5.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/ca-certificates-2024.6.2-h56e8100_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/click-8.1.7-win_pyh7428d3b_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/colorama-0.4.6-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/coloredlogs-15.0.1-pyhd8ed1ab_3.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/win-64/coverage-7.5.3-py311he736701_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/exceptiongroup-1.2.0-pyhd8ed1ab_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/execnet-2.1.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/humanfriendly-10.0-py311h1ea47a8_5.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/hypothesis-6.103.1-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/iniconfig-2.0.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/intel-openmp-2024.1.0-h57928b3_966.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libabseil-20240116.2-cxx17_h63175ca_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libblas-3.9.0-22_win64_mkl.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libcblas-3.9.0-22_win64_mkl.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libexpat-2.6.2-h63175ca_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libffi-3.4.2-h8ffe710_5.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/win-64/libhwloc-2.10.0-default_h8125262_1001.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libiconv-1.17-hcfcfb64_2.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/liblapack-3.9.0-22_win64_mkl.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libprotobuf-4.25.3-h503648d_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libsqlite-3.45.3-hcfcfb64_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libxml2-2.12.7-h283a6d9_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libzlib-1.3.1-h2466b09_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/mkl-2024.1.0-h66d3029_692.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/mpmath-1.3.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/mypy-1.10.0-py311he736701_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/mypy_extensions-1.0.0-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/numpy-1.26.4-py311h0b4df5a_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/onnx-1.16.1-py311h20f75e2_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/onnxruntime-1.18.0-py311h15521e7_2_cpu.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/openssl-3.3.1-h2466b09_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-24.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pip-24.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pluggy-1.5.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/protobuf-4.25.3-py311hb041b4a_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/psutil-5.9.8-py311ha68e1ae_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/pthreads-win32-2.9.1-hfa6e2cd_3.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/win-64/pyreadline3-3.4.1-py311h1ea47a8_3.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-8.2.2-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-cov-5.0.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-json-report-1.5.0-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-metadata-3.1.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-xdist-3.5.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/python-3.11.9-h631f459_0_cpython.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python-flatbuffers-24.3.25-pyh59ac667_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/python_abi-3.11-4_cp311.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-70.0.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-scm-8.1.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sortedcontainers-2.4.0-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/spox-0.12.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sympy-1.12-pyh04b8f61_3.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/tbb-2021.12.0-hc790b64_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/tk-8.6.13-h5226925_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/toml-0.10.2-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/tomli-2.0.1-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/typing-extensions-4.12.2-hd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.12.2-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2024a-h0c530f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/ucrt-10.0.22621.0-h57928b3_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/win-64/vc-14.3-h8a93ad2_20.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/vc14_runtime-14.40.33810-ha82c5b3_20.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/vs2015_runtime-14.40.33810-h3bf8584_20.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/wheel-0.43.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/xz-5.2.6-h8d14728_0.tar.bz2 + py312: + channels: + - url: https://conda.anaconda.org/conda-forge/ + packages: + linux-64: + - conda: https://conda.anaconda.org/conda-forge/linux-64/_libgcc_mutex-0.1-conda_forge.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-64/_openmp_mutex-4.5-2_gnu.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/attrs-23.2.0-pyh71513ae_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/backports.zoneinfo-0.2.1-py312h7900ff3_8.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/bzip2-1.0.8-hd590300_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/ca-certificates-2024.6.2-hbcca054_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/click-8.1.7-unix_pyh707e725_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/colorama-0.4.6-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/coloredlogs-15.0.1-pyhd8ed1ab_3.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-64/coverage-7.5.3-py312h9a8786e_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/exceptiongroup-1.2.0-pyhd8ed1ab_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/execnet-2.1.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gmp-6.3.0-h59595ed_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gmpy2-2.1.5-py312h1d5cde6_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/humanfriendly-10.0-pyhd8ed1ab_6.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/hypothesis-6.103.1-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/iniconfig-2.0.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/ld_impl_linux-64-2.40-hf3520f5_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libabseil-20240116.2-cxx17_h59595ed_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libblas-3.9.0-22_linux64_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libcblas-3.9.0-22_linux64_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libexpat-2.6.2-h59595ed_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libffi-3.4.2-h7f98852_5.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-ng-13.2.0-h77fa898_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran-ng-13.2.0-h69a702a_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran5-13.2.0-hca663fb_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgomp-13.2.0-h77fa898_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/liblapack-3.9.0-22_linux64_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libnsl-2.0.1-hd590300_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenblas-0.3.27-pthreads_h413a1c8_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libprotobuf-4.25.3-h08a7969_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libsqlite-3.45.3-h2797004_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-ng-13.2.0-hc0a3c3a_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libuuid-2.38.1-h0b41bf4_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libxcrypt-4.4.36-hd590300_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libzlib-1.3.1-h4ab18f5_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/mpc-1.3.1-hfe3b2da_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/mpfr-4.2.1-h9458935_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/mpmath-1.3.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/mypy-1.10.0-py312h9a8786e_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/mypy_extensions-1.0.0-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/ncurses-6.5-h59595ed_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/numpy-1.26.4-py312heda63a1_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/onnx-1.16.1-py312hb223586_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/onnxruntime-1.18.0-py312hbe6c245_2_cpu.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/openssl-3.3.1-h4ab18f5_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-24.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pip-24.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pluggy-1.5.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/protobuf-4.25.3-py312h72fbbdf_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/psutil-5.9.8-py312h98912ed_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-8.2.2-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-cov-5.0.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-json-report-1.5.0-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-metadata-3.1.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-xdist-3.5.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/python-3.12.3-hab00c5b_0_cpython.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python-flatbuffers-24.3.25-pyh59ac667_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/python_abi-3.12-4_cp312.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/readline-8.2-h8228510_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-70.0.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-scm-8.1.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sortedcontainers-2.4.0-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/spox-0.12.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sympy-1.12-pypyh9d50eac_103.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/tk-8.6.13-noxft_h4845f30_101.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/toml-0.10.2-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/tomli-2.0.1-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/typing-extensions-4.12.2-hd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.12.2-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2024a-h0c530f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/wheel-0.43.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xz-5.2.6-h166bdaf_0.tar.bz2 + linux-aarch64: + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/_openmp_mutex-4.5-2_gnu.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/attrs-23.2.0-pyh71513ae_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/backports.zoneinfo-0.2.1-py312h996f985_8.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/bzip2-1.0.8-h31becfc_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ca-certificates-2024.6.2-hcefe29a_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/click-8.1.7-unix_pyh707e725_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/colorama-0.4.6-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/coloredlogs-15.0.1-pyhd8ed1ab_3.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/coverage-7.5.3-py312h5adff4d_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/exceptiongroup-1.2.0-pyhd8ed1ab_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/execnet-2.1.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gmp-6.3.0-h2f0025b_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gmpy2-2.1.5-py312h67287d2_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/humanfriendly-10.0-pyhd8ed1ab_6.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/hypothesis-6.103.1-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/iniconfig-2.0.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ld_impl_linux-aarch64-2.40-h9fc2d93_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libabseil-20240116.2-cxx17_h2f0025b_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libblas-3.9.0-22_linuxaarch64_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libcblas-3.9.0-22_linuxaarch64_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libexpat-2.6.2-h2f0025b_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libffi-3.4.2-h3557bc0_5.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgcc-ng-13.2.0-he277a41_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgfortran-ng-13.2.0-he9431aa_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgfortran5-13.2.0-h87d9d71_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgomp-13.2.0-he277a41_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/liblapack-3.9.0-22_linuxaarch64_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libnsl-2.0.1-h31becfc_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libopenblas-0.3.27-pthreads_h5a5ec62_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libprotobuf-4.25.3-h648ac29_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libsqlite-3.45.3-h194ca79_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libstdcxx-ng-13.2.0-h3f4de04_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libuuid-2.38.1-hb4cce97_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libxcrypt-4.4.36-h31becfc_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libzlib-1.3.1-h68df207_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/mpc-1.3.1-hf4c8f4c_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/mpfr-4.2.1-ha2d0fc4_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/mpmath-1.3.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/mypy-1.10.0-py312h396f95a_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/mypy_extensions-1.0.0-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ncurses-6.5-h0425590_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/numpy-1.26.4-py312h470d778_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/onnx-1.16.1-py312h67626d2_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/onnxruntime-1.18.0-py312hfb296ae_2_cpu.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/openssl-3.3.1-h68df207_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-24.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pip-24.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pluggy-1.5.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/protobuf-4.25.3-py312h1e6a782_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/psutil-5.9.8-py312hdd3e373_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-8.2.2-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-cov-5.0.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-json-report-1.5.0-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-metadata-3.1.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-xdist-3.5.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/python-3.12.3-h43d1f9e_0_cpython.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python-flatbuffers-24.3.25-pyh59ac667_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/python_abi-3.12-4_cp312.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/readline-8.2-h8fc344f_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-70.0.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-scm-8.1.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sortedcontainers-2.4.0-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/spox-0.12.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sympy-1.12-pypyh9d50eac_103.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/tk-8.6.13-h194ca79_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/toml-0.10.2-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/tomli-2.0.1-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/typing-extensions-4.12.2-hd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.12.2-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2024a-h0c530f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/wheel-0.43.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/xz-5.2.6-h9cdd2b7_0.tar.bz2 + osx-64: + - conda: https://conda.anaconda.org/conda-forge/noarch/attrs-23.2.0-pyh71513ae_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/backports.zoneinfo-0.2.1-py312hb401068_8.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/bzip2-1.0.8-h10d778d_5.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/ca-certificates-2024.6.2-h8857fd0_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/click-8.1.7-unix_pyh707e725_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/colorama-0.4.6-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/coloredlogs-15.0.1-pyhd8ed1ab_3.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/osx-64/coverage-7.5.3-py312hbd25219_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/exceptiongroup-1.2.0-pyhd8ed1ab_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/execnet-2.1.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/gmp-6.3.0-h73e2aa4_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/gmpy2-2.1.5-py312hd98c385_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/humanfriendly-10.0-pyhd8ed1ab_6.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/hypothesis-6.103.1-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/iniconfig-2.0.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libabseil-20240116.2-cxx17_hc1bcbd7_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libblas-3.9.0-22_osx64_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libcblas-3.9.0-22_osx64_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libcxx-17.0.6-h88467a6_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libexpat-2.6.2-h73e2aa4_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libffi-3.4.2-h0d85af4_5.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/osx-64/libgfortran-5.0.0-13_2_0_h97931a8_3.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libgfortran5-13.2.0-h2873a65_3.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/liblapack-3.9.0-22_osx64_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libopenblas-0.3.27-openmp_hfef2a42_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libprotobuf-4.25.3-h4e4d658_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libsqlite-3.45.3-h92b6c6a_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libzlib-1.3.1-h87427d6_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/llvm-openmp-18.1.7-h15ab845_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/mpc-1.3.1-h81bd1dd_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/mpfr-4.2.1-h4f6b447_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/mpmath-1.3.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/mypy-1.10.0-py312h5fa3f64_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/mypy_extensions-1.0.0-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/ncurses-6.5-h5846eda_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/numpy-1.26.4-py312he3a82b2_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/onnx-1.16.1-py312hefded4f_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/onnxruntime-1.18.0-py312hd03a33c_2_cpu.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/openssl-3.3.1-h87427d6_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-24.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pip-24.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pluggy-1.5.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/protobuf-4.25.3-py312hf6c9040_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/psutil-5.9.8-py312h41838bb_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-8.2.2-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-cov-5.0.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-json-report-1.5.0-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-metadata-3.1.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-xdist-3.5.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/python-3.12.3-h1411813_0_cpython.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python-flatbuffers-24.3.25-pyh59ac667_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/python_abi-3.12-4_cp312.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/readline-8.2-h9e318b2_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-70.0.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-scm-8.1.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sortedcontainers-2.4.0-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/spox-0.12.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sympy-1.12-pypyh9d50eac_103.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/tk-8.6.13-h1abcd95_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/toml-0.10.2-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/tomli-2.0.1-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/typing-extensions-4.12.2-hd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.12.2-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2024a-h0c530f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/wheel-0.43.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/xz-5.2.6-h775f41a_0.tar.bz2 + osx-arm64: + - conda: https://conda.anaconda.org/conda-forge/noarch/attrs-23.2.0-pyh71513ae_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/backports.zoneinfo-0.2.1-py312h81bd7bf_8.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/bzip2-1.0.8-h93a5062_5.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ca-certificates-2024.6.2-hf0a4a13_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/click-8.1.7-unix_pyh707e725_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/colorama-0.4.6-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/coloredlogs-15.0.1-pyhd8ed1ab_3.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/coverage-7.5.3-py312h7e5086c_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/exceptiongroup-1.2.0-pyhd8ed1ab_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/execnet-2.1.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/gmp-6.3.0-hebf3989_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/gmpy2-2.1.5-py312hfa9fade_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/humanfriendly-10.0-pyhd8ed1ab_6.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/hypothesis-6.103.1-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/iniconfig-2.0.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libabseil-20240116.2-cxx17_hebf3989_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libblas-3.9.0-22_osxarm64_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcblas-3.9.0-22_osxarm64_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcxx-17.0.6-h5f092b4_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libexpat-2.6.2-hebf3989_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libffi-3.4.2-h3422bc3_5.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgfortran-5.0.0-13_2_0_hd922786_3.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgfortran5-13.2.0-hf226fd6_3.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/liblapack-3.9.0-22_osxarm64_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libopenblas-0.3.27-openmp_h6c19121_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libprotobuf-4.25.3-hbfab5d5_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libsqlite-3.45.3-h091b4b1_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libzlib-1.3.1-hfb2fe0b_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/llvm-openmp-18.1.7-hde57baf_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/mpc-1.3.1-h91ba8db_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/mpfr-4.2.1-h41d338b_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/mpmath-1.3.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/mypy-1.10.0-py312h4a164c9_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/mypy_extensions-1.0.0-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ncurses-6.5-hb89a1cb_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/numpy-1.26.4-py312h8442bc7_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/onnx-1.16.1-py312hb2a1542_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/onnxruntime-1.18.0-py312hcd9b293_2_cpu.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/openssl-3.3.1-hfb2fe0b_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-24.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pip-24.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pluggy-1.5.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/protobuf-4.25.3-py312h1a610f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/psutil-5.9.8-py312he37b823_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-8.2.2-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-cov-5.0.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-json-report-1.5.0-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-metadata-3.1.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-xdist-3.5.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/python-3.12.3-h4a7b5fc_0_cpython.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python-flatbuffers-24.3.25-pyh59ac667_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/python_abi-3.12-4_cp312.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/readline-8.2-h92ec313_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-70.0.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-scm-8.1.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sortedcontainers-2.4.0-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/spox-0.12.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sympy-1.12-pypyh9d50eac_103.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/tk-8.6.13-h5083fa2_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/toml-0.10.2-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/tomli-2.0.1-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/typing-extensions-4.12.2-hd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.12.2-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2024a-h0c530f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/wheel-0.43.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/xz-5.2.6-h57fd34a_0.tar.bz2 + win-64: + - conda: https://conda.anaconda.org/conda-forge/noarch/attrs-23.2.0-pyh71513ae_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/backports.zoneinfo-0.2.1-py312h2e8e312_8.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/bzip2-1.0.8-hcfcfb64_5.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/ca-certificates-2024.6.2-h56e8100_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/click-8.1.7-win_pyh7428d3b_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/colorama-0.4.6-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/coloredlogs-15.0.1-pyhd8ed1ab_3.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/win-64/coverage-7.5.3-py312h4389bb4_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/exceptiongroup-1.2.0-pyhd8ed1ab_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/execnet-2.1.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/humanfriendly-10.0-py312h2e8e312_5.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/hypothesis-6.103.1-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/iniconfig-2.0.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/intel-openmp-2024.1.0-h57928b3_966.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libabseil-20240116.2-cxx17_h63175ca_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libblas-3.9.0-22_win64_mkl.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libcblas-3.9.0-22_win64_mkl.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libexpat-2.6.2-h63175ca_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libffi-3.4.2-h8ffe710_5.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/win-64/libhwloc-2.10.0-default_h8125262_1001.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libiconv-1.17-hcfcfb64_2.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/liblapack-3.9.0-22_win64_mkl.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libprotobuf-4.25.3-h503648d_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libsqlite-3.45.3-hcfcfb64_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libxml2-2.12.7-h283a6d9_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libzlib-1.3.1-h2466b09_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/mkl-2024.1.0-h66d3029_692.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/mpmath-1.3.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/mypy-1.10.0-py312h4389bb4_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/mypy_extensions-1.0.0-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/numpy-1.26.4-py312h8753938_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/onnx-1.16.1-py312ha2757a1_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/onnxruntime-1.18.0-py312h2704b8b_2_cpu.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/openssl-3.3.1-h2466b09_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-24.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pip-24.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pluggy-1.5.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/protobuf-4.25.3-py312h5594109_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/psutil-5.9.8-py312he70551f_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/pthreads-win32-2.9.1-hfa6e2cd_3.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/win-64/pyreadline3-3.4.1-py312h2e8e312_3.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-8.2.2-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-cov-5.0.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-json-report-1.5.0-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-metadata-3.1.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-xdist-3.5.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/python-3.12.3-h2628c8c_0_cpython.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python-flatbuffers-24.3.25-pyh59ac667_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/python_abi-3.12-4_cp312.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-70.0.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-scm-8.1.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sortedcontainers-2.4.0-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/spox-0.12.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sympy-1.12-pyh04b8f61_3.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/tbb-2021.12.0-hc790b64_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/tk-8.6.13-h5226925_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/toml-0.10.2-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/tomli-2.0.1-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/typing-extensions-4.12.2-hd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.12.2-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2024a-h0c530f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/ucrt-10.0.22621.0-h57928b3_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/win-64/vc-14.3-h8a93ad2_20.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/vc14_runtime-14.40.33810-ha82c5b3_20.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/vs2015_runtime-14.40.33810-h3bf8584_20.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/wheel-0.43.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/xz-5.2.6-h8d14728_0.tar.bz2 +packages: +- kind: conda + name: _libgcc_mutex + version: '0.1' + build: conda_forge + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/_libgcc_mutex-0.1-conda_forge.tar.bz2 + sha256: fe51de6107f9edc7aa4f786a70f4a883943bc9d39b3bb7307c04c41410990726 + md5: d7c89558ba9fa0495403155b64376d81 + license: None + size: 2562 + timestamp: 1578324546067 +- kind: conda + name: _openmp_mutex + version: '4.5' + build: 2_gnu + build_number: 16 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/_openmp_mutex-4.5-2_gnu.tar.bz2 + sha256: fbe2c5e56a653bebb982eda4876a9178aedfc2b545f25d0ce9c4c0b508253d22 + md5: 73aaf86a425cc6e73fcf236a5a46396d + depends: + - _libgcc_mutex 0.1 conda_forge + - libgomp >=7.5.0 + constrains: + - openmp_impl 9999 + license: BSD-3-Clause + license_family: BSD + size: 23621 + timestamp: 1650670423406 +- kind: conda + name: _openmp_mutex + version: '4.5' + build: 2_gnu + build_number: 16 + subdir: linux-aarch64 + url: https://conda.anaconda.org/conda-forge/linux-aarch64/_openmp_mutex-4.5-2_gnu.tar.bz2 + sha256: 3702bef2f0a4d38bd8288bbe54aace623602a1343c2cfbefd3fa188e015bebf0 + md5: 6168d71addc746e8f2b8d57dfd2edcea + depends: + - libgomp >=7.5.0 + constrains: + - openmp_impl 9999 + license: BSD-3-Clause + license_family: BSD + size: 23712 + timestamp: 1650670790230 +- kind: conda + name: alabaster + version: 0.7.16 + build: pyhd8ed1ab_0 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/alabaster-0.7.16-pyhd8ed1ab_0.conda + sha256: fd39ad2fabec1569bbb0dfdae34ab6ce7de6ec09dcec8638f83dad0373594069 + md5: def531a3ac77b7fb8c21d17bb5d0badb + depends: + - python >=3.9 + license: BSD-3-Clause + license_family: BSD + size: 18365 + timestamp: 1704848898483 +- kind: conda + name: apeye + version: 1.4.1 + build: pyhd8ed1ab_0 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/apeye-1.4.1-pyhd8ed1ab_0.conda + sha256: 1a47a4f7058a42d89950bab578199a853507e89a786554341d606a60bc26f967 + md5: b8056e03885a3a63364dec4b45947dd0 + depends: + - apeye-core >=1.0.0b2 + - domdf-python-tools >=2.6.0 + - platformdirs >=2.3.0 + - python >=3.6 + - requests >=2.24.0 + constrains: + - cachecontrol >=0.12.6 + license: LGPL-3.0-or-later + license_family: LGPL + size: 96025 + timestamp: 1692642749856 +- kind: conda + name: apeye-core + version: 1.1.5 + build: pyhd8ed1ab_0 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/apeye-core-1.1.5-pyhd8ed1ab_0.conda + sha256: 60e6c38789cab708a9979b7352811b410a508c66459928a05ade446dd4c53b95 + md5: 2f19f4ec38175dc1d748656bfcc14dcb + depends: + - domdf-python-tools >=2.6.0 + - idna >=2.5 + - python >=3.6 + license: BSD-3-Clause + license_family: BSD + size: 94417 + timestamp: 1706643922767 +- kind: conda + name: attrs + version: 23.2.0 + build: pyh71513ae_0 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/attrs-23.2.0-pyh71513ae_0.conda + sha256: 77c7d03bdb243a048fff398cedc74327b7dc79169ebe3b4c8448b0331ea55fea + md5: 5e4c0743c70186509d1412e03c2d8dfa + depends: + - python >=3.7 + license: MIT + license_family: MIT + size: 54582 + timestamp: 1704011393776 +- kind: conda + name: autodocsumm + version: 0.2.12 + build: pyhd8ed1ab_0 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/autodocsumm-0.2.12-pyhd8ed1ab_0.conda + sha256: 5358e7abb06cd8ab304ebf8e8d17e52760e2b7185fc25c9a99b5c61b7bc36ccb + md5: b0e58323e15cb50328a1bb3e8158a49c + depends: + - python >=3.5 + - six + - sphinx >=2.2,<=5.0 + license: Apache-2.0 + license_family: APACHE + size: 19022 + timestamp: 1704454587726 +- kind: conda + name: babel + version: 2.14.0 + build: pyhd8ed1ab_0 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/babel-2.14.0-pyhd8ed1ab_0.conda + sha256: 8584e3da58e92b72641c89ff9b98c51f0d5dbe76e527867804cbdf03ac91d8e6 + md5: 9669586875baeced8fc30c0826c3270e + depends: + - python >=3.7 + - pytz + - setuptools + license: BSD-3-Clause + license_family: BSD + size: 7609750 + timestamp: 1702422720584 +- kind: conda + name: backports.zoneinfo + version: 0.2.1 + build: py310h2ec42d9_8 + build_number: 8 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/backports.zoneinfo-0.2.1-py310h2ec42d9_8.conda + sha256: 9a818e62c31824c05892d78e8a16d1bb03be62785bfd391f4b19b976f2e842c7 + md5: 38ee987ff476741a4736147b0c97a6a2 + depends: + - python >=3.10,<3.11.0a0 + - python_abi 3.10.* *_cp310 + license: Apache-2.0 + license_family: APACHE + size: 6815 + timestamp: 1695531650569 +- kind: conda + name: backports.zoneinfo + version: 0.2.1 + build: py310h4c7bcd0_8 + build_number: 8 + subdir: linux-aarch64 + url: https://conda.anaconda.org/conda-forge/linux-aarch64/backports.zoneinfo-0.2.1-py310h4c7bcd0_8.conda + sha256: de0682603ae65add9d4eb2dbd02d5a1fed978ad9a73a077c616974f49d5d65a4 + md5: 4974419109f245f3ed0df88c3e37f541 + depends: + - python >=3.10,<3.11.0a0 + - python_abi 3.10.* *_cp310 + license: Apache-2.0 + license_family: APACHE + size: 6862 + timestamp: 1695531520750 +- kind: conda + name: backports.zoneinfo + version: 0.2.1 + build: py310h5588dad_8 + build_number: 8 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/backports.zoneinfo-0.2.1-py310h5588dad_8.conda + sha256: 413c5969e75903299351cea5785565d662c2652c857591232eac4d74deefd9e1 + md5: 8fd93c85ef214ed73dcf25c49fbfe0c0 + depends: + - python >=3.10,<3.11.0a0 + - python_abi 3.10.* *_cp310 + license: Apache-2.0 + license_family: APACHE + size: 7087 + timestamp: 1695531597353 +- kind: conda + name: backports.zoneinfo + version: 0.2.1 + build: py310hbe9552e_8 + build_number: 8 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/backports.zoneinfo-0.2.1-py310hbe9552e_8.conda + sha256: 6000caddf15ff122a91ea3bd737c06b8675358b034f49f8c7a431439fa416f48 + md5: 84d7e1dd696bd26fecd03827ba866ae7 + depends: + - python >=3.10,<3.11.0a0 + - python_abi 3.10.* *_cp310 + license: Apache-2.0 + license_family: APACHE + size: 6874 + timestamp: 1695531692308 +- kind: conda + name: backports.zoneinfo + version: 0.2.1 + build: py310hff52083_8 + build_number: 8 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/backports.zoneinfo-0.2.1-py310hff52083_8.conda + sha256: 18f868c36a5c6493c92acaab3753e9869b48bd486b2fcbc8e96d54b09c6a7512 + md5: a8d590bf67c0df86e375bad5bfb18680 + depends: + - python >=3.10,<3.11.0a0 + - python_abi 3.10.* *_cp310 + license: Apache-2.0 + license_family: APACHE + size: 6726 + timestamp: 1695531473449 +- kind: conda + name: backports.zoneinfo + version: 0.2.1 + build: py311h1ea47a8_8 + build_number: 8 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/backports.zoneinfo-0.2.1-py311h1ea47a8_8.conda + sha256: 30d71fe787342045a7a1896835627c0ed0a1a8b796a497d63b0d36b31a84b7e7 + md5: 6784cf61285ebc6d3772d9a51d9982eb + depends: + - python >=3.11,<3.12.0a0 + - python_abi 3.11.* *_cp311 + license: Apache-2.0 + license_family: APACHE + size: 7127 + timestamp: 1695531721081 +- kind: conda + name: backports.zoneinfo + version: 0.2.1 + build: py311h267d04e_8 + build_number: 8 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/backports.zoneinfo-0.2.1-py311h267d04e_8.conda + sha256: a1cdbc446ff4db99e9e39b73b1611932dc9c5111ecd90dd131fa6fdf62de904d + md5: acbef984789bc78fc49cca2e736b8006 + depends: + - python >=3.11,<3.12.0a0 + - python_abi 3.11.* *_cp311 + license: Apache-2.0 + license_family: APACHE + size: 6899 + timestamp: 1695531612758 +- kind: conda + name: backports.zoneinfo + version: 0.2.1 + build: py311h38be061_8 + build_number: 8 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/backports.zoneinfo-0.2.1-py311h38be061_8.conda + sha256: 1708c5e6729567f30ccde7761492cb43ee72fa2f7d5065b9102785278718505b + md5: 5384590f14dfe6ccd02811236afc9f8e + depends: + - python >=3.11,<3.12.0a0 + - python_abi 3.11.* *_cp311 + license: Apache-2.0 + license_family: APACHE + size: 6719 + timestamp: 1695531467111 +- kind: conda + name: backports.zoneinfo + version: 0.2.1 + build: py311h6eed73b_8 + build_number: 8 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/backports.zoneinfo-0.2.1-py311h6eed73b_8.conda + sha256: f6064fc69833fed6d02738d29132bc87a6195098ec74257f53044de306694ff3 + md5: 82f37234dbc0254423c109e9e21ce332 + depends: + - python >=3.11,<3.12.0a0 + - python_abi 3.11.* *_cp311 + license: Apache-2.0 + license_family: APACHE + size: 6835 + timestamp: 1695531603137 +- kind: conda + name: backports.zoneinfo + version: 0.2.1 + build: py311hec3470c_8 + build_number: 8 + subdir: linux-aarch64 + url: https://conda.anaconda.org/conda-forge/linux-aarch64/backports.zoneinfo-0.2.1-py311hec3470c_8.conda + sha256: 079b8b9d26e1de00de11ea8fda5d2e2a10fa1c8c0db2c69ede1ea28ba34fbf0b + md5: 9a537c2b13ad73025dc6c4cba1e3455a + depends: + - python >=3.11,<3.12.0a0 + - python_abi 3.11.* *_cp311 + license: Apache-2.0 + license_family: APACHE + size: 6897 + timestamp: 1695531526485 +- kind: conda + name: backports.zoneinfo + version: 0.2.1 + build: py312h2e8e312_8 + build_number: 8 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/backports.zoneinfo-0.2.1-py312h2e8e312_8.conda + sha256: 7fa2af5de8a313afdb3d18827d02253c9823c4f2538ccd7d0c75952c21e91e90 + md5: d81731eb1130e96145b6c1c5110db13b + depends: + - python >=3.12.0rc3,<3.13.0a0 + - python_abi 3.12.* *_cp312 + license: Apache-2.0 + license_family: APACHE + size: 7159 + timestamp: 1695531779340 +- kind: conda + name: backports.zoneinfo + version: 0.2.1 + build: py312h7900ff3_8 + build_number: 8 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/backports.zoneinfo-0.2.1-py312h7900ff3_8.conda + sha256: 5a46ad5be0683354238647d9190e03f78369e61041ecd133d767e0a0efcb8dc8 + md5: 67de4422abcd81a451cf69f14e12d7dc + depends: + - python >=3.12.0rc3,<3.13.0a0 + - python_abi 3.12.* *_cp312 + license: Apache-2.0 + license_family: APACHE + size: 6767 + timestamp: 1695531523245 +- kind: conda + name: backports.zoneinfo + version: 0.2.1 + build: py312h81bd7bf_8 + build_number: 8 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/backports.zoneinfo-0.2.1-py312h81bd7bf_8.conda + sha256: e233c2ca389ea9bf34a9f38e94d033cece302872024e83304807b3d1b5a6a458 + md5: 288d72f5f8e52ca04bb8df2af011d5a3 + depends: + - python >=3.12.0rc3,<3.13.0a0 + - python_abi 3.12.* *_cp312 + license: Apache-2.0 + license_family: APACHE + size: 6883 + timestamp: 1695531710824 +- kind: conda + name: backports.zoneinfo + version: 0.2.1 + build: py312h996f985_8 + build_number: 8 + subdir: linux-aarch64 + url: https://conda.anaconda.org/conda-forge/linux-aarch64/backports.zoneinfo-0.2.1-py312h996f985_8.conda + sha256: cb7ee85f6dd7ed0382b269405b9d1e540a7d9b113658f851b82c6ef991d7ce26 + md5: 9d14dc898ae8028f6b113b117f8c071f + depends: + - python >=3.12.0rc3,<3.13.0a0 + - python_abi 3.12.* *_cp312 + license: Apache-2.0 + license_family: APACHE + size: 6908 + timestamp: 1695531545221 +- kind: conda + name: backports.zoneinfo + version: 0.2.1 + build: py312hb401068_8 + build_number: 8 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/backports.zoneinfo-0.2.1-py312hb401068_8.conda + sha256: 71d6aa035929cd23dbeb23e85e8130919b32db07a3a43e2be4ece1b95074cc3d + md5: 15f98ebc910c7eea286fdad8f20072eb + depends: + - python >=3.12.0rc3,<3.13.0a0 + - python_abi 3.12.* *_cp312 + license: Apache-2.0 + license_family: APACHE + size: 6834 + timestamp: 1695531593366 +- kind: conda + name: beautifulsoup4 + version: 4.12.3 + build: pyha770c72_0 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/beautifulsoup4-4.12.3-pyha770c72_0.conda + sha256: 7b05b2d0669029326c623b9df7a29fa49d1982a9e7e31b2fea34b4c9a4a72317 + md5: 332493000404d8411859539a5a630865 + depends: + - python >=3.6 + - soupsieve >=1.2 + license: MIT + license_family: MIT + size: 118200 + timestamp: 1705564819537 +- kind: conda + name: bleach + version: 6.1.0 + build: pyhd8ed1ab_0 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/bleach-6.1.0-pyhd8ed1ab_0.conda + sha256: 845e77ef495376c5c3c328ccfd746ca0ef1978150cae8eae61a300fe7755fb08 + md5: 0ed9d7c0e9afa7c025807a9a8136ea3e + depends: + - packaging + - python >=3.6 + - setuptools + - six >=1.9.0 + - webencodings + license: Apache-2.0 + license_family: Apache + size: 131220 + timestamp: 1696630354218 +- kind: conda + name: brotli-python + version: 1.1.0 + build: py310h00ffb61_1 + build_number: 1 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/brotli-python-1.1.0-py310h00ffb61_1.conda + sha256: 8de77cf62a653dd6ffe19927b92c421f5fa73c078d7799181f5211a1bac2883b + md5: 42bfbc1d41cbe2696a3c9d8b0342324f + depends: + - python >=3.10,<3.11.0a0 + - python_abi 3.10.* *_cp310 + - ucrt >=10.0.20348.0 + - vc >=14.2,<15 + - vc14_runtime >=14.29.30139 + constrains: + - libbrotlicommon 1.1.0 hcfcfb64_1 + license: MIT + license_family: MIT + size: 321672 + timestamp: 1695990897641 +- kind: conda + name: brotli-python + version: 1.1.0 + build: py310h1253130_1 + build_number: 1 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/brotli-python-1.1.0-py310h1253130_1.conda + sha256: dab21e18c0275bfd93a09b751096998485677ed17c2e2d08298bc5b43c10bee1 + md5: 26fab7f65a80fff9f402ec3b7860b88a + depends: + - libcxx >=15.0.7 + - python >=3.10,<3.11.0a0 + - python >=3.10,<3.11.0a0 *_cpython + - python_abi 3.10.* *_cp310 + constrains: + - libbrotlicommon 1.1.0 hb547adb_1 + license: MIT + license_family: MIT + size: 344275 + timestamp: 1695990848681 +- kind: conda + name: brotli-python + version: 1.1.0 + build: py310h9e9d8ca_1 + build_number: 1 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/brotli-python-1.1.0-py310h9e9d8ca_1.conda + sha256: 57d66ca3e072b889c94cfaf56eb7e1794d3b1b3179bd475a4edef50a03359354 + md5: 2362e323293e7699cf1e621d502f86d6 + depends: + - libcxx >=15.0.7 + - python >=3.10,<3.11.0a0 + - python_abi 3.10.* *_cp310 + constrains: + - libbrotlicommon 1.1.0 h0dc2134_1 + license: MIT + license_family: MIT + size: 367037 + timestamp: 1695990378635 +- kind: conda + name: brotli-python + version: 1.1.0 + build: py310hbb3657e_1 + build_number: 1 + subdir: linux-aarch64 + url: https://conda.anaconda.org/conda-forge/linux-aarch64/brotli-python-1.1.0-py310hbb3657e_1.conda + sha256: 192f2537ca30953653375abd851f1ccf8b849988e3195e0189aa47384a3a88d9 + md5: 5ed52d1d3c480022fe67ae00d1cab792 + depends: + - libgcc-ng >=12 + - libstdcxx-ng >=12 + - python >=3.10,<3.11.0a0 + - python >=3.10,<3.11.0a0 *_cpython + - python_abi 3.10.* *_cp310 + constrains: + - libbrotlicommon 1.1.0 h31becfc_1 + license: MIT + license_family: MIT + size: 355646 + timestamp: 1695990521531 +- kind: conda + name: brotli-python + version: 1.1.0 + build: py310hc6cd4ac_1 + build_number: 1 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/brotli-python-1.1.0-py310hc6cd4ac_1.conda + sha256: e22268d81905338570786921b3def88e55f9ed6d0ccdd17d9fbae31a02fbef69 + md5: 1f95722c94f00b69af69a066c7433714 + depends: + - libgcc-ng >=12 + - libstdcxx-ng >=12 + - python >=3.10,<3.11.0a0 + - python_abi 3.10.* *_cp310 + constrains: + - libbrotlicommon 1.1.0 hd590300_1 + license: MIT + license_family: MIT + size: 349397 + timestamp: 1695990295884 +- kind: conda + name: build + version: 0.7.0 + build: pyhd8ed1ab_0 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/build-0.7.0-pyhd8ed1ab_0.tar.bz2 + sha256: 44e2d3270209d1f10b8adec2a159699ed66914e851ec34775902e856ea04afeb + md5: add7f31586d03678695b32b78a1337a1 + depends: + - importlib-metadata + - packaging + - pep517 >=0.9.1 + - python >=3.6 + - tomli + license: MIT + license_family: MIT + size: 17759 + timestamp: 1631843776429 +- kind: conda + name: bzip2 + version: 1.0.8 + build: h10d778d_5 + build_number: 5 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/bzip2-1.0.8-h10d778d_5.conda + sha256: 61fb2b488928a54d9472113e1280b468a309561caa54f33825a3593da390b242 + md5: 6097a6ca9ada32699b5fc4312dd6ef18 + license: bzip2-1.0.6 + license_family: BSD + size: 127885 + timestamp: 1699280178474 +- kind: conda + name: bzip2 + version: 1.0.8 + build: h31becfc_5 + build_number: 5 + subdir: linux-aarch64 + url: https://conda.anaconda.org/conda-forge/linux-aarch64/bzip2-1.0.8-h31becfc_5.conda + sha256: b9f170990625cb1eeefaca02e091dc009a64264b077166d8ed7aeb7a09e923b0 + md5: a64e35f01e0b7a2a152eca87d33b9c87 + depends: + - libgcc-ng >=12 + license: bzip2-1.0.6 + license_family: BSD + size: 189668 + timestamp: 1699280060686 +- kind: conda + name: bzip2 + version: 1.0.8 + build: h93a5062_5 + build_number: 5 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/bzip2-1.0.8-h93a5062_5.conda + sha256: bfa84296a638bea78a8bb29abc493ee95f2a0218775642474a840411b950fe5f + md5: 1bbc659ca658bfd49a481b5ef7a0f40f + license: bzip2-1.0.6 + license_family: BSD + size: 122325 + timestamp: 1699280294368 +- kind: conda + name: bzip2 + version: 1.0.8 + build: hcfcfb64_5 + build_number: 5 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/bzip2-1.0.8-hcfcfb64_5.conda + sha256: ae5f47a5c86fd6db822931255dcf017eb12f60c77f07dc782ccb477f7808aab2 + md5: 26eb8ca6ea332b675e11704cce84a3be + depends: + - ucrt >=10.0.20348.0 + - vc >=14.2,<15 + - vc14_runtime >=14.29.30139 + license: bzip2-1.0.6 + license_family: BSD + size: 124580 + timestamp: 1699280668742 +- kind: conda + name: bzip2 + version: 1.0.8 + build: hd590300_5 + build_number: 5 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/bzip2-1.0.8-hd590300_5.conda + sha256: 242c0c324507ee172c0e0dd2045814e746bb303d1eb78870d182ceb0abc726a8 + md5: 69b8b6202a07720f448be700e300ccf4 + depends: + - libgcc-ng >=12 + license: bzip2-1.0.6 + license_family: BSD + size: 254228 + timestamp: 1699279927352 +- kind: conda + name: ca-certificates + version: 2024.6.2 + build: h56e8100_0 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/ca-certificates-2024.6.2-h56e8100_0.conda + sha256: d872d11558ebeaeb87bcf9086e97c075a1a2dfffed2d0e97570cf197ab29e3d8 + md5: 12a3a2b3a00a21bbb390d4de5ad8dd0f + license: ISC + size: 156530 + timestamp: 1717311907623 +- kind: conda + name: ca-certificates + version: 2024.6.2 + build: h8857fd0_0 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/ca-certificates-2024.6.2-h8857fd0_0.conda + sha256: ba0614477229fcb0f0666356f2c4686caa66f0ed1446e7c9666ce234abe2bacf + md5: 3c23a8cab15ae51ebc9efdc229fccecf + license: ISC + size: 156145 + timestamp: 1717311781754 +- kind: conda + name: ca-certificates + version: 2024.6.2 + build: hbcca054_0 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/ca-certificates-2024.6.2-hbcca054_0.conda + sha256: 979af0932b2a5a26112044891a2d79e402e5ae8166f50fa48b8ebae47c0a2d65 + md5: 847c3c2905cc467cea52c24f9cfa8080 + license: ISC + size: 156035 + timestamp: 1717311767102 +- kind: conda + name: ca-certificates + version: 2024.6.2 + build: hcefe29a_0 + subdir: linux-aarch64 + url: https://conda.anaconda.org/conda-forge/linux-aarch64/ca-certificates-2024.6.2-hcefe29a_0.conda + sha256: d27b90ff1e00c34123c37a4c5332bb75c3c5cc6775c57ecfa9f430b629ad3108 + md5: 3ef6b1a30375f8a973a593698e317191 + license: ISC + size: 156128 + timestamp: 1717312862469 +- kind: conda + name: ca-certificates + version: 2024.6.2 + build: hf0a4a13_0 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/ca-certificates-2024.6.2-hf0a4a13_0.conda + sha256: f5fd189d48965df396d060eb48628cbd9f083f1a1ea79c5236f60d655c7b9633 + md5: b534f104f102479402f88f73adf750f5 + license: ISC + size: 156299 + timestamp: 1717311742040 +- kind: conda + name: cachecontrol + version: 0.14.0 + build: pyhd8ed1ab_0 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/cachecontrol-0.14.0-pyhd8ed1ab_0.conda + sha256: 3318732d60456c5ecc0db14a7343a320ea88e05ae168aea4164d7f9ec7907142 + md5: a661c39e223bf3038b38126b0bbf43d9 + depends: + - msgpack-python >=0.5.2 + - python >=3.7 + - requests >=2.16.0 + license: Apache-2.0 + license_family: Apache + size: 23734 + timestamp: 1706895342952 +- kind: conda + name: certifi + version: 2024.6.2 + build: pyhd8ed1ab_0 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/certifi-2024.6.2-pyhd8ed1ab_0.conda + sha256: f101b8f9155b79d623601214eb719747ffe1c2ad3ff6c4e600f59163bd5f4803 + md5: 8821ec1c8fcdc9e1d291d7b9f6e9968a + depends: + - python >=3.7 + license: ISC + size: 160543 + timestamp: 1718025161969 +- kind: conda + name: cffi + version: 1.16.0 + build: py312h38bf5a0_0 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/cffi-1.16.0-py312h38bf5a0_0.conda + sha256: 8b856583b56fc30f064a7cb286f85e4b5725f2bd4fda8ba0c4e94bffe258741e + md5: a45759c013ab20b9017ef9539d234dd7 + depends: + - libffi >=3.4,<4.0a0 + - pycparser + - python >=3.12.0rc3,<3.13.0a0 + - python_abi 3.12.* *_cp312 + license: MIT + license_family: MIT + size: 282370 + timestamp: 1696002004433 +- kind: conda + name: cffi + version: 1.16.0 + build: py312h8e38eb3_0 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/cffi-1.16.0-py312h8e38eb3_0.conda + sha256: 1544403cb1a5ca2aeabf0dac86d9ce6066d6fb4363493643b33ffd1b78038d18 + md5: 960ecbd65860d3b1de5e30373e1bffb1 + depends: + - libffi >=3.4,<4.0a0 + - pycparser + - python >=3.12.0rc3,<3.13.0a0 + - python >=3.12.0rc3,<3.13.0a0 *_cpython + - python_abi 3.12.* *_cp312 + license: MIT + license_family: MIT + size: 284245 + timestamp: 1696002181644 +- kind: conda + name: cffi + version: 1.16.0 + build: py312he70551f_0 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/cffi-1.16.0-py312he70551f_0.conda + sha256: dd39e594f5c6bca52dfed343de2af9326a99700ce2ba3404bd89706926fc0137 + md5: 5a51096925d52332c62bfd8904899055 + depends: + - pycparser + - python >=3.12.0rc3,<3.13.0a0 + - python_abi 3.12.* *_cp312 + - ucrt >=10.0.20348.0 + - vc >=14.2,<15 + - vc14_runtime >=14.29.30139 + license: MIT + license_family: MIT + size: 287805 + timestamp: 1696002408940 +- kind: conda + name: cffi + version: 1.16.0 + build: py312hf06ca03_0 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/cffi-1.16.0-py312hf06ca03_0.conda + sha256: 5a36e2c254603c367d26378fa3a205bd92263e30acf195f488749562b4c44251 + md5: 56b0ca764ce23cc54f3f7e2a7b970f6d + depends: + - libffi >=3.4,<4.0a0 + - libgcc-ng >=12 + - pycparser + - python >=3.12.0rc3,<3.13.0a0 + - python_abi 3.12.* *_cp312 + license: MIT + license_family: MIT + size: 294523 + timestamp: 1696001868949 +- kind: conda + name: cffi + version: 1.16.0 + build: py312hf3c74c0_0 + subdir: linux-aarch64 + url: https://conda.anaconda.org/conda-forge/linux-aarch64/cffi-1.16.0-py312hf3c74c0_0.conda + sha256: 3b8e96c60a39c6d2180f5db4a7209b900c0a7dec218b9d15f42c0c99dd925792 + md5: 2b087fcfbe35a1bb081e1723b8c6362a + depends: + - libffi >=3.4,<4.0a0 + - libgcc-ng >=12 + - pycparser + - python >=3.12.0rc3,<3.13.0a0 + - python_abi 3.12.* *_cp312 + license: MIT + license_family: MIT + size: 310955 + timestamp: 1696003981838 +- kind: conda + name: cfgv + version: 3.3.1 + build: pyhd8ed1ab_0 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/cfgv-3.3.1-pyhd8ed1ab_0.tar.bz2 + sha256: fbc03537a27ef756162c49b1d0608bf7ab12fa5e38ceb8563d6f4859e835ac5c + md5: ebb5f5f7dc4f1a3780ef7ea7738db08c + depends: + - python >=3.6.1 + license: MIT + license_family: MIT + size: 10788 + timestamp: 1629909423398 +- kind: conda + name: charset-normalizer + version: 3.3.2 + build: pyhd8ed1ab_0 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/charset-normalizer-3.3.2-pyhd8ed1ab_0.conda + sha256: 20cae47d31fdd58d99c4d2e65fbdcefa0b0de0c84e455ba9d6356a4bdbc4b5b9 + md5: 7f4a9e3fcff3f6356ae99244a014da6a + depends: + - python >=3.7 + license: MIT + license_family: MIT + size: 46597 + timestamp: 1698833765762 +- kind: conda + name: click + version: 8.1.7 + build: unix_pyh707e725_0 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/click-8.1.7-unix_pyh707e725_0.conda + sha256: f0016cbab6ac4138a429e28dbcb904a90305b34b3fe41a9b89d697c90401caec + md5: f3ad426304898027fc619827ff428eca + depends: + - __unix + - python >=3.8 + license: BSD-3-Clause + license_family: BSD + size: 84437 + timestamp: 1692311973840 +- kind: conda + name: click + version: 8.1.7 + build: win_pyh7428d3b_0 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/click-8.1.7-win_pyh7428d3b_0.conda + sha256: 90236b113b9a20041736e80b80ee965167f9aac0468315c55e2bad902d673fb0 + md5: 3549ecbceb6cd77b91a105511b7d0786 + depends: + - __win + - colorama + - python >=3.8 + license: BSD-3-Clause + license_family: BSD + size: 85051 + timestamp: 1692312207348 +- kind: conda + name: colorama + version: 0.4.6 + build: pyhd8ed1ab_0 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/colorama-0.4.6-pyhd8ed1ab_0.tar.bz2 + sha256: 2c1b2e9755ce3102bca8d69e8f26e4f087ece73f50418186aee7c74bef8e1698 + md5: 3faab06a954c2a04039983f2c4a50d99 + depends: + - python >=3.7 + license: BSD-3-Clause + license_family: BSD + size: 25170 + timestamp: 1666700778190 +- kind: conda + name: coloredlogs + version: 15.0.1 + build: pyhd8ed1ab_3 + build_number: 3 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/coloredlogs-15.0.1-pyhd8ed1ab_3.tar.bz2 + sha256: 0bb37abbf3367add8a8e3522405efdbd06605acfc674488ef52486968f2c119d + md5: 7b4fc18b7f66382257c45424eaf81935 + depends: + - humanfriendly >=9.1 + - python >=3.7 + license: MIT + license_family: MIT + size: 40569 + timestamp: 1643220223971 +- kind: conda + name: coverage + version: 7.5.3 + build: py310h03727f4_0 + subdir: linux-aarch64 + url: https://conda.anaconda.org/conda-forge/linux-aarch64/coverage-7.5.3-py310h03727f4_0.conda + sha256: 2fe8640a92bae9bfe4696617dcab6b1d26074225ab29b3d120c12e22701e3ad2 + md5: 1cd8e68fdc9841b9df00974df41c17cd + depends: + - libgcc-ng >=12 + - python >=3.10,<3.11.0a0 + - python_abi 3.10.* *_cp310 + - tomli + license: Apache-2.0 + license_family: APACHE + size: 291496 + timestamp: 1716932647485 +- kind: conda + name: coverage + version: 7.5.3 + build: py310h936d840_0 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/coverage-7.5.3-py310h936d840_0.conda + sha256: 302aa5c391fdd4f24ee59d26ff57f6f90c0e8f38ae26e90aa992a14fb880f032 + md5: 0422b3c2b7c022ccf32b06cb2b3bb708 + depends: + - __osx >=10.13 + - python >=3.10,<3.11.0a0 + - python_abi 3.10.* *_cp310 + - tomli + license: Apache-2.0 + license_family: APACHE + size: 288692 + timestamp: 1716931177292 +- kind: conda + name: coverage + version: 7.5.3 + build: py310ha6dd24b_0 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/coverage-7.5.3-py310ha6dd24b_0.conda + sha256: 502a17f24fa851aa701917e3ddeb41caa33db89abbf41c6ddbb9b1860ad1cbf5 + md5: b3ff8a8397566d39eaa6580fd09a20b1 + depends: + - __osx >=11.0 + - python >=3.10,<3.11.0a0 + - python >=3.10,<3.11.0a0 *_cpython + - python_abi 3.10.* *_cp310 + - tomli + license: Apache-2.0 + license_family: APACHE + size: 289749 + timestamp: 1716931270281 +- kind: conda + name: coverage + version: 7.5.3 + build: py310ha8f682b_0 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/coverage-7.5.3-py310ha8f682b_0.conda + sha256: 1322bb9f73ee730beabcdc10538dcaec2f6015d5c0df8e878de5d7c10ce310ad + md5: 0609217d7e0efa5d9095fef96081cf1e + depends: + - python >=3.10,<3.11.0a0 + - python_abi 3.10.* *_cp310 + - tomli + - ucrt >=10.0.20348.0 + - vc >=14.2,<15 + - vc14_runtime >=14.29.30139 + license: Apache-2.0 + license_family: APACHE + size: 315082 + timestamp: 1716931846322 +- kind: conda + name: coverage + version: 7.5.3 + build: py310hc51659f_0 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/coverage-7.5.3-py310hc51659f_0.conda + sha256: d14fd44ca7f9ae180e6a9a565d39ffe093d0c9eacda6b13c85cb26ec6ef8687e + md5: 4be0e55c0f724d339be3d4dc9dfc5752 + depends: + - libgcc-ng >=12 + - python >=3.10,<3.11.0a0 + - python_abi 3.10.* *_cp310 + - tomli + license: Apache-2.0 + license_family: APACHE + size: 290408 + timestamp: 1716931075677 +- kind: conda + name: coverage + version: 7.5.3 + build: py311h323e239_0 + subdir: linux-aarch64 + url: https://conda.anaconda.org/conda-forge/linux-aarch64/coverage-7.5.3-py311h323e239_0.conda + sha256: 005caa64bc5a4099ddba44fc40c4b08b70268f5d1de85165fa148014689c407d + md5: 7bb152380c7fbcf60a22c77c35fed0c9 + depends: + - libgcc-ng >=12 + - python >=3.11,<3.12.0a0 + - python_abi 3.11.* *_cp311 + - tomli + license: Apache-2.0 + license_family: APACHE + size: 370035 + timestamp: 1716932092165 +- kind: conda + name: coverage + version: 7.5.3 + build: py311h331c9d8_0 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/coverage-7.5.3-py311h331c9d8_0.conda + sha256: 88e0063cf333147890aafacc2f87360867991241af827a111d97433b7055691e + md5: 543dd05fd661e4e9c9deb3b37093d6a2 + depends: + - libgcc-ng >=12 + - python >=3.11,<3.12.0a0 + - python_abi 3.11.* *_cp311 + - tomli + license: Apache-2.0 + license_family: APACHE + size: 369467 + timestamp: 1716931054680 +- kind: conda + name: coverage + version: 7.5.3 + build: py311h72ae277_0 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/coverage-7.5.3-py311h72ae277_0.conda + sha256: 9dc466b8736f436190ae4936f1f57e12c0a81d2ce6f93e2f761ac6e8acb7a8bc + md5: a34013943f5189b08a14f8254a809461 + depends: + - __osx >=10.13 + - python >=3.11,<3.12.0a0 + - python_abi 3.11.* *_cp311 + - tomli + license: Apache-2.0 + license_family: APACHE + size: 367953 + timestamp: 1716931110483 +- kind: conda + name: coverage + version: 7.5.3 + build: py311hd3f4193_0 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/coverage-7.5.3-py311hd3f4193_0.conda + sha256: dcdfa3b24affe7399654f2e8429c15e05a54b8cce32583263a0731c37b62dcbc + md5: 402a8b40b9c9423f40a32be066b467be + depends: + - __osx >=11.0 + - python >=3.11,<3.12.0a0 + - python >=3.11,<3.12.0a0 *_cpython + - python_abi 3.11.* *_cp311 + - tomli + license: Apache-2.0 + license_family: APACHE + size: 368732 + timestamp: 1716931397116 +- kind: conda + name: coverage + version: 7.5.3 + build: py311he736701_0 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/coverage-7.5.3-py311he736701_0.conda + sha256: 16b1692a5ea5254842267e3f66489ecc009ff0d63c0d02148d756e32495c0947 + md5: eead686af955162027fb5825e83a3131 + depends: + - python >=3.11,<3.12.0a0 + - python_abi 3.11.* *_cp311 + - tomli + - ucrt >=10.0.20348.0 + - vc >=14.2,<15 + - vc14_runtime >=14.29.30139 + license: Apache-2.0 + license_family: APACHE + size: 395283 + timestamp: 1716931857373 +- kind: conda + name: coverage + version: 7.5.3 + build: py312h4389bb4_0 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/coverage-7.5.3-py312h4389bb4_0.conda + sha256: a28c73ff92bbf5912b36e9eb73cd3baf3713ad77349988b612bfe3d57f9b8a09 + md5: 9473b7c6d6656d151aa4e33596bb0deb + depends: + - python >=3.12,<3.13.0a0 + - python_abi 3.12.* *_cp312 + - tomli + - ucrt >=10.0.20348.0 + - vc >=14.2,<15 + - vc14_runtime >=14.29.30139 + license: Apache-2.0 + license_family: APACHE + size: 385419 + timestamp: 1716931749807 +- kind: conda + name: coverage + version: 7.5.3 + build: py312h5adff4d_0 + subdir: linux-aarch64 + url: https://conda.anaconda.org/conda-forge/linux-aarch64/coverage-7.5.3-py312h5adff4d_0.conda + sha256: 30c68c7b9c3c193d933d61c627f66f832d20cd48437953f78348ca3f98a2fc63 + md5: c70e5f6be56465c47fe1613f47441a6b + depends: + - libgcc-ng >=12 + - python >=3.12,<3.13.0a0 + - python_abi 3.12.* *_cp312 + - tomli + license: Apache-2.0 + license_family: APACHE + size: 361287 + timestamp: 1716932333270 +- kind: conda + name: coverage + version: 7.5.3 + build: py312h7e5086c_0 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/coverage-7.5.3-py312h7e5086c_0.conda + sha256: a645427a6a5a5f82a392f37c356689269866f1bb06494f5c7aceec72640b00b6 + md5: 3631dadcec974f1fb49efa995338db70 + depends: + - __osx >=11.0 + - python >=3.12,<3.13.0a0 + - python >=3.12,<3.13.0a0 *_cpython + - python_abi 3.12.* *_cp312 + - tomli + license: Apache-2.0 + license_family: APACHE + size: 358952 + timestamp: 1716931333247 +- kind: conda + name: coverage + version: 7.5.3 + build: py312h9a8786e_0 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/coverage-7.5.3-py312h9a8786e_0.conda + sha256: 1d42ae67b21d7bb836ac66a85f90da88be3939ca7980a1ad882c271deb9acd6e + md5: f01930d0afe8ac5f8062c98e6b8d1fd0 + depends: + - libgcc-ng >=12 + - python >=3.12,<3.13.0a0 + - python_abi 3.12.* *_cp312 + - tomli + license: Apache-2.0 + license_family: APACHE + size: 359527 + timestamp: 1716931082787 +- kind: conda + name: coverage + version: 7.5.3 + build: py312hbd25219_0 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/coverage-7.5.3-py312hbd25219_0.conda + sha256: ff5d5320fa1312efdf044d23e7a4e31134af99be7998d86b6fcea456c708297d + md5: 135eeb22a4da903e2d06c4323b459003 + depends: + - __osx >=10.13 + - python >=3.12,<3.13.0a0 + - python_abi 3.12.* *_cp312 + - tomli + license: Apache-2.0 + license_family: APACHE + size: 358490 + timestamp: 1716931167938 +- kind: conda + name: cssutils + version: 2.11.0 + build: pyhd8ed1ab_0 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/cssutils-2.11.0-pyhd8ed1ab_0.conda + sha256: 34a80de2eba8608cfd63bd416c5860f6f4de1f62827e1dc58fb2a049aa85735d + md5: 18c6c51800d3db7a1bc69d019c1afb03 + depends: + - python >=3.6 + license: LGPL-3.0-only + license_family: LGPL + size: 295611 + timestamp: 1715738264101 +- kind: conda + name: defusedxml + version: 0.7.1 + build: pyhd8ed1ab_0 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/defusedxml-0.7.1-pyhd8ed1ab_0.tar.bz2 + sha256: 9717a059677553562a8f38ff07f3b9f61727bd614f505658b0a5ecbcf8df89be + md5: 961b3a227b437d82ad7054484cfa71b2 + depends: + - python >=3.6 + license: PSF-2.0 + license_family: PSF + size: 24062 + timestamp: 1615232388757 +- kind: conda + name: dict2css + version: 0.3.0.post1 + build: pyhd8ed1ab_0 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/dict2css-0.3.0.post1-pyhd8ed1ab_0.conda + sha256: 1acd1f4e97d5a8a2065f85f85f9e3d375f405817b4f8ca1e53e721ff53b40d75 + md5: 994e7da2397f71885baba03107792852 + depends: + - cssutils >=2.2.0 + - domdf-python-tools >=2.2.0 + - python >=3.6 + license: MIT + license_family: MIT + size: 13601 + timestamp: 1700688549830 +- kind: conda + name: distlib + version: 0.3.8 + build: pyhd8ed1ab_0 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/distlib-0.3.8-pyhd8ed1ab_0.conda + sha256: 3ff11acdd5cc2f80227682966916e878e45ced94f59c402efb94911a5774e84e + md5: db16c66b759a64dc5183d69cc3745a52 + depends: + - python 2.7|>=3.6 + license: Apache-2.0 + license_family: APACHE + size: 274915 + timestamp: 1702383349284 +- kind: conda + name: docformatter + version: 1.7.5 + build: pyhd8ed1ab_0 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/docformatter-1.7.5-pyhd8ed1ab_0.conda + sha256: e6ec436da3615764106e16eb6bedfe6dc65d12de27e0bdb151dfdb39ec04d89e + md5: 3a941b6083e945aa87e739a9b85c82e9 + depends: + - charset-normalizer >=3.0.0 + - python >=3.7 + - untokenize >=0.1.1 + license: MIT + license_family: MIT + size: 28330 + timestamp: 1689652699366 +- kind: conda + name: docutils + version: 0.18.1 + build: py310h2ec42d9_1 + build_number: 1 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/docutils-0.18.1-py310h2ec42d9_1.tar.bz2 + sha256: 6353fb7f0a08d90e868ba710ba47a827c0200f4b358abb81c927d95276f862a5 + md5: f95000f735a9dbba847e6d03e9ce71ad + depends: + - python >=3.10,<3.11.0a0 + - python_abi 3.10.* *_cp310 + license: LicenseRef-Public-Domain-Dedictation and BSD-2-Clause and LicenseRef-PSF-2.1.1 and GPL-3.0-or-later + size: 776504 + timestamp: 1648737762668 +- kind: conda + name: docutils + version: 0.18.1 + build: py310h5588dad_1 + build_number: 1 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/docutils-0.18.1-py310h5588dad_1.tar.bz2 + sha256: a9c40df47e2c5eb8938198f8d2d90fb0d6342f2409f4283999be44fd5f58574f + md5: 10fe0cdd2629f3fe5d27db3f084545f5 + depends: + - python >=3.10,<3.11.0a0 + - python_abi 3.10.* *_cp310 + license: LicenseRef-Public-Domain-Dedictation and BSD-2-Clause and LicenseRef-PSF-2.1.1 and GPL-3.0-or-later + size: 782383 + timestamp: 1648737958205 +- kind: conda + name: docutils + version: 0.18.1 + build: py310hbbe02a8_1 + build_number: 1 + subdir: linux-aarch64 + url: https://conda.anaconda.org/conda-forge/linux-aarch64/docutils-0.18.1-py310hbbe02a8_1.tar.bz2 + sha256: 2551ebea199ac82f22d7e1f7570978e8c3d8b2feb6ebe51826c960581fe36e0f + md5: 12c8f02a8d7d54811491b661038ed8d4 + depends: + - python >=3.10,<3.11.0a0 + - python_abi 3.10.* *_cp310 + license: LicenseRef-Public-Domain-Dedictation and BSD-2-Clause and LicenseRef-PSF-2.1.1 and GPL-3.0-or-later + size: 780154 + timestamp: 1648738314678 +- kind: conda + name: docutils + version: 0.18.1 + build: py310hbe9552e_1 + build_number: 1 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/docutils-0.18.1-py310hbe9552e_1.tar.bz2 + sha256: c87ef2a39cfd1c39c0b029a9705be21b4fabbfd8383ed4e8714a752c27ebd21c + md5: 383129729506eb5ec23ee459993f2ad3 + depends: + - python >=3.10,<3.11.0a0 + - python >=3.10,<3.11.0a0 *_cpython + - python_abi 3.10.* *_cp310 + license: LicenseRef-Public-Domain-Dedictation and BSD-2-Clause and LicenseRef-PSF-2.1.1 and GPL-3.0-or-later + size: 778861 + timestamp: 1648737997220 +- kind: conda + name: docutils + version: 0.18.1 + build: py310hff52083_1 + build_number: 1 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/docutils-0.18.1-py310hff52083_1.tar.bz2 + sha256: 2071bf7c56305d234161bef00c0c2ba7ae345484105d2ccc448c7c734634f346 + md5: 6405f87c427cdbc25b6b6a21bd6bfc2a + depends: + - python >=3.10,<3.11.0a0 + - python_abi 3.10.* *_cp310 + license: LicenseRef-Public-Domain-Dedictation and BSD-2-Clause and LicenseRef-PSF-2.1.1 and GPL-3.0-or-later + size: 777277 + timestamp: 1648737636628 +- kind: conda + name: domdf-python-tools + version: 3.8.1 + build: pyhd8ed1ab_0 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/domdf-python-tools-3.8.1-pyhd8ed1ab_0.conda + sha256: 77eb69e5c3d64e4b3a4240b9e1213b9ada4bcc3ce1af1c9469d03bd87483133b + md5: 9a5300d8e266384d22ac627def456d05 + depends: + - importlib-metadata >=3.6.0 + - importlib-resources >=3.0.0 + - natsort >=7.0.1 + - python >=3.6 + - typing-extensions >=3.7.4.1 + license: MIT + license_family: MIT + size: 97505 + timestamp: 1718015733643 +- kind: conda + name: entrypoints + version: '0.4' + build: pyhd8ed1ab_0 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/entrypoints-0.4-pyhd8ed1ab_0.tar.bz2 + sha256: 2ec4a0900a4a9f42615fc04d0fb3286b796abe56590e8e042f6ec25e102dd5af + md5: 3cf04868fee0a029769bd41f4b2fbf2d + depends: + - python >=3.6 + license: MIT + license_family: MIT + size: 9199 + timestamp: 1643888357950 +- kind: conda + name: exceptiongroup + version: 1.2.0 + build: pyhd8ed1ab_2 + build_number: 2 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/exceptiongroup-1.2.0-pyhd8ed1ab_2.conda + sha256: a6ae416383bda0e3ed14eaa187c653e22bec94ff2aa3b56970cdf0032761e80d + md5: 8d652ea2ee8eaee02ed8dc820bc794aa + depends: + - python >=3.7 + license: MIT and PSF-2.0 + size: 20551 + timestamp: 1704921321122 +- kind: conda + name: execnet + version: 2.1.1 + build: pyhd8ed1ab_0 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/execnet-2.1.1-pyhd8ed1ab_0.conda + sha256: 564bc012d73ca29964e7acca18d60b2fa8d20eea6d258d98cfc24df5167beaf0 + md5: 15dda3cdbf330abfe9f555d22f66db46 + depends: + - python >=3.8 + license: MIT + license_family: MIT + size: 38883 + timestamp: 1712591929944 +- kind: conda + name: filelock + version: 3.14.0 + build: pyhd8ed1ab_0 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/filelock-3.14.0-pyhd8ed1ab_0.conda + sha256: 6031be667e1b0cc0dee713f1cbca887cdee4daafa8bac478da33096f3147d38b + md5: 831d85ae0acfba31b8efd0f0d07da736 + depends: + - python >=3.7 + license: Unlicense + size: 15902 + timestamp: 1714422911808 +- kind: conda + name: gmp + version: 6.3.0 + build: h2f0025b_1 + build_number: 1 + subdir: linux-aarch64 + url: https://conda.anaconda.org/conda-forge/linux-aarch64/gmp-6.3.0-h2f0025b_1.conda + sha256: a839590a28ea9938e01e4a7fcf6d240611ef9a645c7b4cb6767c7b1397d06f22 + md5: 0fdc64cdb43430acdca4d54fdfc64317 + depends: + - libgcc-ng >=12 + - libstdcxx-ng >=12 + license: GPL-2.0-or-later OR LGPL-3.0-or-later + size: 517903 + timestamp: 1710169423575 +- kind: conda + name: gmp + version: 6.3.0 + build: h59595ed_1 + build_number: 1 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/gmp-6.3.0-h59595ed_1.conda + sha256: cfc4202c23d6895d9c84042d08d5cda47d597772df870d4d2a10fc86dded5576 + md5: e358c7c5f6824c272b5034b3816438a7 + depends: + - libgcc-ng >=12 + - libstdcxx-ng >=12 + license: GPL-2.0-or-later OR LGPL-3.0-or-later + size: 569852 + timestamp: 1710169507479 +- kind: conda + name: gmp + version: 6.3.0 + build: h73e2aa4_1 + build_number: 1 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/gmp-6.3.0-h73e2aa4_1.conda + sha256: 1a5b117908deb5a12288aba84dd0cb913f779c31c75f5a57d1a00e659e8fa3d3 + md5: 92f8d748d95d97f92fc26cfac9bb5b6e + depends: + - libcxx >=16 + license: GPL-2.0-or-later OR LGPL-3.0-or-later + size: 519804 + timestamp: 1710170159201 +- kind: conda + name: gmp + version: 6.3.0 + build: hebf3989_1 + build_number: 1 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/gmp-6.3.0-hebf3989_1.conda + sha256: 0ed5aff70675dc0ed5c2f39bb02b908b864e8eee4ceb56e1c798ba8d7509551f + md5: 64f45819921ba710398706e1a6404eb5 + depends: + - libcxx >=16 + license: GPL-2.0-or-later OR LGPL-3.0-or-later + size: 448714 + timestamp: 1710169869298 +- kind: conda + name: gmpy2 + version: 2.1.5 + build: py310h0310db1_1 + build_number: 1 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/gmpy2-2.1.5-py310h0310db1_1.conda + sha256: 1f7c77d207c8d309619370b5177ef4a9a4360e4503a48467bf24fde85cd195ce + md5: fcefc03d2d057c4c59a5d99dc7f2e0f3 + depends: + - __osx >=10.9 + - gmp >=6.3.0,<7.0a0 + - mpc >=1.3.1,<2.0a0 + - mpfr >=4.2.1,<5.0a0 + - python >=3.10,<3.11.0a0 + - python_abi 3.10.* *_cp310 + license: LGPL-3.0-or-later + license_family: LGPL + size: 153689 + timestamp: 1715527516013 +- kind: conda + name: gmpy2 + version: 2.1.5 + build: py310h05bcf56_1 + build_number: 1 + subdir: linux-aarch64 + url: https://conda.anaconda.org/conda-forge/linux-aarch64/gmpy2-2.1.5-py310h05bcf56_1.conda + sha256: f7b32fa9f0a4503d1a9fcdce332dd64ffe1a79f0eea91cf1dc1111679ea5f7cd + md5: bc882c5d0a1afb8f61605b3022d4ec43 + depends: + - gmp >=6.3.0,<7.0a0 + - libgcc-ng >=12 + - mpc >=1.3.1,<2.0a0 + - mpfr >=4.2.1,<5.0a0 + - python >=3.10,<3.11.0a0 + - python >=3.10,<3.11.0a0 *_cpython + - python_abi 3.10.* *_cp310 + license: LGPL-3.0-or-later + license_family: LGPL + size: 196065 + timestamp: 1715527498626 +- kind: conda + name: gmpy2 + version: 2.1.5 + build: py310h3bc658a_1 + build_number: 1 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/gmpy2-2.1.5-py310h3bc658a_1.conda + sha256: 1cb4a9661004f665671acba8ec7831e053e4f75622cece4dc192b4cbeded191e + md5: f07083e7d1bbec2e66ca82a491b4730f + depends: + - __osx >=11.0 + - gmp >=6.3.0,<7.0a0 + - mpc >=1.3.1,<2.0a0 + - mpfr >=4.2.1,<5.0a0 + - python >=3.10,<3.11.0a0 + - python >=3.10,<3.11.0a0 *_cpython + - python_abi 3.10.* *_cp310 + license: LGPL-3.0-or-later + license_family: LGPL + size: 147895 + timestamp: 1715527619325 +- kind: conda + name: gmpy2 + version: 2.1.5 + build: py310hc7909c9_1 + build_number: 1 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/gmpy2-2.1.5-py310hc7909c9_1.conda + sha256: 5f6c80aeda212c5271c6482d5e9e97e5a2d4bd5c2592df83a5e9d0fff05db259 + md5: c22f487e9f1463c6650c2e37e9193e79 + depends: + - gmp >=6.3.0,<7.0a0 + - libgcc-ng >=12 + - mpc >=1.3.1,<2.0a0 + - mpfr >=4.2.1,<5.0a0 + - python >=3.10,<3.11.0a0 + - python_abi 3.10.* *_cp310 + license: LGPL-3.0-or-later + license_family: LGPL + size: 205664 + timestamp: 1715527404968 +- kind: conda + name: gmpy2 + version: 2.1.5 + build: py311h1e33d93_1 + build_number: 1 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/gmpy2-2.1.5-py311h1e33d93_1.conda + sha256: 047dd4dd8255fea1cf3c0629e5cfcb3a1602c18ab46fa0e16b615b669b9f8efe + md5: 7d974c438b0940fbf837ddca56231679 + depends: + - __osx >=11.0 + - gmp >=6.3.0,<7.0a0 + - mpc >=1.3.1,<2.0a0 + - mpfr >=4.2.1,<5.0a0 + - python >=3.11,<3.12.0a0 + - python >=3.11,<3.12.0a0 *_cpython + - python_abi 3.11.* *_cp311 + license: LGPL-3.0-or-later + license_family: LGPL + size: 147863 + timestamp: 1715527598324 +- kind: conda + name: gmpy2 + version: 2.1.5 + build: py311h3c136a7_1 + build_number: 1 + subdir: linux-aarch64 + url: https://conda.anaconda.org/conda-forge/linux-aarch64/gmpy2-2.1.5-py311h3c136a7_1.conda + sha256: fe5b8adf6d0ebd2ad77075c8f0a00b72d609f51669a3dd85eb69f1809b3fc703 + md5: 11787eda9370789dfcd608562771f925 + depends: + - gmp >=6.3.0,<7.0a0 + - libgcc-ng >=12 + - mpc >=1.3.1,<2.0a0 + - mpfr >=4.2.1,<5.0a0 + - python >=3.11,<3.12.0a0 + - python >=3.11,<3.12.0a0 *_cpython + - python_abi 3.11.* *_cp311 + license: LGPL-3.0-or-later + license_family: LGPL + size: 194426 + timestamp: 1715527557585 +- kind: conda + name: gmpy2 + version: 2.1.5 + build: py311hab17429_1 + build_number: 1 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/gmpy2-2.1.5-py311hab17429_1.conda + sha256: eb22b87ab27462800a9d7aad875c8a30c28c402ca2a37d655e7e228e3902c7ea + md5: 8670764c471116e9861347f36016d3f6 + depends: + - __osx >=10.9 + - gmp >=6.3.0,<7.0a0 + - mpc >=1.3.1,<2.0a0 + - mpfr >=4.2.1,<5.0a0 + - python >=3.11,<3.12.0a0 + - python_abi 3.11.* *_cp311 + license: LGPL-3.0-or-later + license_family: LGPL + size: 154289 + timestamp: 1715527528934 +- kind: conda + name: gmpy2 + version: 2.1.5 + build: py311hc4f1f91_1 + build_number: 1 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/gmpy2-2.1.5-py311hc4f1f91_1.conda + sha256: a174e05ee2531bd81f275bd01557c907faa1d794e68b7c1e73b1d9e7e8f42732 + md5: 30b83b4a5d116d790f8da79a4acac238 + depends: + - gmp >=6.3.0,<7.0a0 + - libgcc-ng >=12 + - mpc >=1.3.1,<2.0a0 + - mpfr >=4.2.1,<5.0a0 + - python >=3.11,<3.12.0a0 + - python_abi 3.11.* *_cp311 + license: LGPL-3.0-or-later + license_family: LGPL + size: 204853 + timestamp: 1715527414809 +- kind: conda + name: gmpy2 + version: 2.1.5 + build: py312h1d5cde6_1 + build_number: 1 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/gmpy2-2.1.5-py312h1d5cde6_1.conda + sha256: afe8fd8bacbb345bdeba6ae275dba6bda6ce9f5f7e1a0c658fff40373fae4654 + md5: 27abd7664bc87595bd98b6306b8393d1 + depends: + - gmp >=6.3.0,<7.0a0 + - libgcc-ng >=12 + - mpc >=1.3.1,<2.0a0 + - mpfr >=4.2.1,<5.0a0 + - python >=3.12,<3.13.0a0 + - python_abi 3.12.* *_cp312 + license: LGPL-3.0-or-later + license_family: LGPL + size: 212406 + timestamp: 1715527440339 +- kind: conda + name: gmpy2 + version: 2.1.5 + build: py312h67287d2_1 + build_number: 1 + subdir: linux-aarch64 + url: https://conda.anaconda.org/conda-forge/linux-aarch64/gmpy2-2.1.5-py312h67287d2_1.conda + sha256: f4b22a94d10e1899b4fdac767cc6398f322797b9e09c85dc2b765b806f7b7573 + md5: f0dec8897b98a0b8040ea234675ea32b + depends: + - gmp >=6.3.0,<7.0a0 + - libgcc-ng >=12 + - mpc >=1.3.1,<2.0a0 + - mpfr >=4.2.1,<5.0a0 + - python >=3.12,<3.13.0a0 + - python >=3.12,<3.13.0a0 *_cpython + - python_abi 3.12.* *_cp312 + license: LGPL-3.0-or-later + license_family: LGPL + size: 201953 + timestamp: 1715527507608 +- kind: conda + name: gmpy2 + version: 2.1.5 + build: py312hd98c385_1 + build_number: 1 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/gmpy2-2.1.5-py312hd98c385_1.conda + sha256: 23066e588d3e371c556e5439c1df3399f267c633f85d3b76c6aca9584e634398 + md5: 61eb95ccf29fae77bc94a70fd8acbd22 + depends: + - __osx >=10.9 + - gmp >=6.3.0,<7.0a0 + - mpc >=1.3.1,<2.0a0 + - mpfr >=4.2.1,<5.0a0 + - python >=3.12,<3.13.0a0 + - python_abi 3.12.* *_cp312 + license: LGPL-3.0-or-later + license_family: LGPL + size: 155260 + timestamp: 1715527543826 +- kind: conda + name: gmpy2 + version: 2.1.5 + build: py312hfa9fade_1 + build_number: 1 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/gmpy2-2.1.5-py312hfa9fade_1.conda + sha256: a8b23b61b0c217d765528849c9c2377fe1967a266d786c3646588bfb1c9a792c + md5: fe03ded0dd16d91a42d7467e9c1457f1 + depends: + - __osx >=11.0 + - gmp >=6.3.0,<7.0a0 + - mpc >=1.3.1,<2.0a0 + - mpfr >=4.2.1,<5.0a0 + - python >=3.12,<3.13.0a0 + - python >=3.12,<3.13.0a0 *_cpython + - python_abi 3.12.* *_cp312 + license: LGPL-3.0-or-later + license_family: LGPL + size: 148826 + timestamp: 1715527621898 +- kind: conda + name: html5lib + version: '1.1' + build: pyh9f0ad1d_0 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/html5lib-1.1-pyh9f0ad1d_0.tar.bz2 + sha256: 9ad06446fe9847e86cb20d220bf11614afcd2cbe9f58096f08d5d4018877bee4 + md5: b2355343d6315c892543200231d7154a + depends: + - python + - six >=1.9 + - webencodings + license: MIT + license_family: MIT + size: 91322 + timestamp: 1592930432911 +- kind: conda + name: humanfriendly + version: '10.0' + build: py310h5588dad_5 + build_number: 5 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/humanfriendly-10.0-py310h5588dad_5.conda + sha256: 670102deefb729d919c68f76de44d883fe7b7c24301270ba08b4f3338e0d6d24 + md5: ffd705b8080336c1ca777313642c228b + depends: + - pyreadline3 + - python >=3.10,<3.11.0a0 + - python_abi 3.10.* *_cp310 + license: MIT + license_family: MIT + size: 139915 + timestamp: 1696713640192 +- kind: conda + name: humanfriendly + version: '10.0' + build: py311h1ea47a8_5 + build_number: 5 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/humanfriendly-10.0-py311h1ea47a8_5.conda + sha256: a94127c7b2c759ee68b32edcda880f720a797c44a46e7047a675398cfc52f96a + md5: 95fa4dc3a35dbf6afd66e0718a8f793d + depends: + - pyreadline3 + - python >=3.11,<3.12.0a0 + - python_abi 3.11.* *_cp311 + license: MIT + license_family: MIT + size: 173484 + timestamp: 1696713670614 +- kind: conda + name: humanfriendly + version: '10.0' + build: py312h2e8e312_5 + build_number: 5 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/humanfriendly-10.0-py312h2e8e312_5.conda + sha256: dde7945411f9f118c5f4a22a1ad38fd5f988d6698286d0598d33167f751d91e7 + md5: c611d51325ea0a6eca4fbb2babf177d6 + depends: + - pyreadline3 + - python >=3.12,<3.13.0a0 + - python_abi 3.12.* *_cp312 + license: MIT + license_family: MIT + size: 167525 + timestamp: 1696713644431 +- kind: conda + name: humanfriendly + version: '10.0' + build: pyhd8ed1ab_6 + build_number: 6 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/humanfriendly-10.0-pyhd8ed1ab_6.conda + sha256: cd93d5d4b1d98f7ce76a8658c35de9c63e17b3a40e52f40fa2f459e0da83d0b1 + md5: 2ed1fe4b9079da97c44cfe9c2e5078fd + depends: + - __unix + - python >=3.8 + license: MIT + license_family: MIT + size: 73376 + timestamp: 1696765379156 +- kind: conda + name: hypothesis + version: 6.103.1 + build: pyha770c72_0 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/hypothesis-6.103.1-pyha770c72_0.conda + sha256: 601ba49238db5db6d9f56f9e58917bf47ad6a9002381b40acfb4034ae9efb2b8 + md5: 87e908d03466db19eeea69251f0bccc2 + depends: + - attrs >=19.2.0 + - backports.zoneinfo >=0.2.1 + - click >=7.0 + - exceptiongroup >=1.0.0rc8 + - python >=3.8 + - setuptools + - sortedcontainers >=2.1.0,<3.0.0 + license: MPL-2.0 + license_family: MOZILLA + size: 329876 + timestamp: 1717642658512 +- kind: conda + name: icu + version: '73.2' + build: h59595ed_0 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/icu-73.2-h59595ed_0.conda + sha256: e12fd90ef6601da2875ebc432452590bc82a893041473bc1c13ef29001a73ea8 + md5: cc47e1facc155f91abd89b11e48e72ff + depends: + - libgcc-ng >=12 + - libstdcxx-ng >=12 + license: MIT + license_family: MIT + size: 12089150 + timestamp: 1692900650789 +- kind: conda + name: icu + version: '73.2' + build: h787c7f5_0 + subdir: linux-aarch64 + url: https://conda.anaconda.org/conda-forge/linux-aarch64/icu-73.2-h787c7f5_0.conda + sha256: aedb9c911ede5596c87e1abd763ed940fab680d71fdb953bce8e4094119d47b3 + md5: 9d3c29d71f28452a2e843aff8cbe09d2 + depends: + - libgcc-ng >=12 + - libstdcxx-ng >=12 + license: MIT + license_family: MIT + size: 12237094 + timestamp: 1692900632394 +- kind: conda + name: icu + version: '73.2' + build: hc8870d7_0 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/icu-73.2-hc8870d7_0.conda + sha256: ff9cd0c6cd1349954c801fb443c94192b637e1b414514539f3c49c56a39f51b1 + md5: 8521bd47c0e11c5902535bb1a17c565f + license: MIT + license_family: MIT + size: 11997841 + timestamp: 1692902104771 +- kind: conda + name: icu + version: '73.2' + build: hf5e326d_0 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/icu-73.2-hf5e326d_0.conda + sha256: f66362dc36178ac9b7c7a9b012948a9d2d050b3debec24bbd94aadbc44854185 + md5: 5cc301d759ec03f28328428e28f65591 + license: MIT + license_family: MIT + size: 11787527 + timestamp: 1692901622519 +- kind: conda + name: identify + version: 2.5.36 + build: pyhd8ed1ab_0 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/identify-2.5.36-pyhd8ed1ab_0.conda + sha256: dc98ab2233d3ed3692499e2a06b027489ee317658cef9277ec23cab00236f31c + md5: ba68cb5105760379432cebc82b45af40 + depends: + - python >=3.6 + - ukkonen + license: MIT + license_family: MIT + size: 78375 + timestamp: 1713673091737 +- kind: conda + name: idna + version: '3.7' + build: pyhd8ed1ab_0 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/idna-3.7-pyhd8ed1ab_0.conda + sha256: 9687ee909ed46169395d4f99a0ee94b80a52f87bed69cd454bb6d37ffeb0ec7b + md5: c0cc1420498b17414d8617d0b9f506ca + depends: + - python >=3.6 + license: BSD-3-Clause + license_family: BSD + size: 52718 + timestamp: 1713279497047 +- kind: conda + name: imagesize + version: 1.4.1 + build: pyhd8ed1ab_0 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/imagesize-1.4.1-pyhd8ed1ab_0.tar.bz2 + sha256: c2bfd7043e0c4c12d8b5593de666c1e81d67b83c474a0a79282cc5c4ef845460 + md5: 7de5386c8fea29e76b303f37dde4c352 + depends: + - python >=3.4 + license: MIT + license_family: MIT + size: 10164 + timestamp: 1656939625410 +- kind: conda + name: importlib-metadata + version: 7.1.0 + build: pyha770c72_0 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/importlib-metadata-7.1.0-pyha770c72_0.conda + sha256: cc2e7d1f7f01cede30feafc1118b7aefa244d0a12224513734e24165ae12ba49 + md5: 0896606848b2dc5cebdf111b6543aa04 + depends: + - python >=3.8 + - zipp >=0.5 + license: Apache-2.0 + license_family: APACHE + size: 27043 + timestamp: 1710971498183 +- kind: conda + name: importlib-resources + version: 6.4.0 + build: pyhd8ed1ab_0 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/importlib-resources-6.4.0-pyhd8ed1ab_0.conda + sha256: 38db827f445ae437a15d50a94816ae67a48285d0700f736af3eb90800a71f079 + md5: dcbadab7a68738a028e195ab68ab2d2e + depends: + - importlib_resources >=6.4.0,<6.4.1.0a0 + - python >=3.8 + license: Apache-2.0 + license_family: APACHE + size: 9657 + timestamp: 1711041029062 +- kind: conda + name: importlib_metadata + version: 7.1.0 + build: hd8ed1ab_0 + subdir: noarch + noarch: generic + url: https://conda.anaconda.org/conda-forge/noarch/importlib_metadata-7.1.0-hd8ed1ab_0.conda + sha256: 01dc057a45dedcc742a71599f67c7383ae2bf873be6018ebcbd06ac8d994dedb + md5: 6ef2b72d291b39e479d7694efa2b2b98 + depends: + - importlib-metadata >=7.1.0,<7.1.1.0a0 + license: Apache-2.0 + license_family: APACHE + size: 9444 + timestamp: 1710971502542 +- kind: conda + name: importlib_resources + version: 6.4.0 + build: pyhd8ed1ab_0 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/importlib_resources-6.4.0-pyhd8ed1ab_0.conda + sha256: c6ae80c0beaeabb342c5b041f19669992ae6e937dbec56ced766cb035900f9de + md5: c5d3907ad8bd7bf557521a1833cf7e6d + depends: + - python >=3.8 + - zipp >=3.1.0 + constrains: + - importlib-resources >=6.4.0,<6.4.1.0a0 + license: Apache-2.0 + license_family: APACHE + size: 33056 + timestamp: 1711041009039 +- kind: conda + name: iniconfig + version: 2.0.0 + build: pyhd8ed1ab_0 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/iniconfig-2.0.0-pyhd8ed1ab_0.conda + sha256: 38740c939b668b36a50ef455b077e8015b8c9cf89860d421b3fff86048f49666 + md5: f800d2da156d08e289b14e87e43c1ae5 + depends: + - python >=3.7 + license: MIT + license_family: MIT + size: 11101 + timestamp: 1673103208955 +- kind: conda + name: insert-license-header + version: 1.3.0 + build: pyhd8ed1ab_0 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/insert-license-header-1.3.0-pyhd8ed1ab_0.conda + sha256: 2f39a8683665079080ff1473e65317d31099c34bdc0090b282eb42ba64ea979c + md5: be70384699d872b82cbb6050b684bb70 + depends: + - python >=3.8 + - rapidfuzz + license: MIT + license_family: MIT + size: 16786 + timestamp: 1706200055466 +- kind: conda + name: intel-openmp + version: 2024.1.0 + build: h57928b3_966 + build_number: 966 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/intel-openmp-2024.1.0-h57928b3_966.conda + sha256: 77465396f2636c8b3b3a587f1636ee35c17a73e2a2c7e0ea0957b05f84704cf3 + md5: 35d7ea07ad6c878bd7240d2d6c1b8657 + license: LicenseRef-IntelSimplifiedSoftwareOct2022 + license_family: Proprietary + size: 1616293 + timestamp: 1716560867765 +- kind: conda + name: jinja2 + version: 3.1.4 + build: pyhd8ed1ab_0 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/jinja2-3.1.4-pyhd8ed1ab_0.conda + sha256: 27380d870d42d00350d2d52598cddaf02f9505fb24be09488da0c9b8d1428f2d + md5: 7b86ecb7d3557821c649b3c31e3eb9f2 + depends: + - markupsafe >=2.0 + - python >=3.7 + license: BSD-3-Clause + license_family: BSD + size: 111565 + timestamp: 1715127275924 +- kind: conda + name: jsonschema + version: 4.22.0 + build: pyhd8ed1ab_0 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/jsonschema-4.22.0-pyhd8ed1ab_0.conda + sha256: 57a466e8c42635d8e930fa065dc6e461f4215aa259ab03873eacb03ddaeefc8a + md5: b9661a4b1200d6bc7d8a4cdafdc91468 + depends: + - attrs >=22.2.0 + - importlib_resources >=1.4.0 + - jsonschema-specifications >=2023.03.6 + - pkgutil-resolve-name >=1.3.10 + - python >=3.8 + - referencing >=0.28.4 + - rpds-py >=0.7.1 + license: MIT + license_family: MIT + size: 74149 + timestamp: 1714573245148 +- kind: conda + name: jsonschema-specifications + version: 2023.12.1 + build: pyhd8ed1ab_0 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/jsonschema-specifications-2023.12.1-pyhd8ed1ab_0.conda + sha256: a9630556ddc3121c0be32f4cbf792dd9102bd380d5cd81d57759d172cf0c2da2 + md5: a0e4efb5f35786a05af4809a2fb1f855 + depends: + - importlib_resources >=1.4.0 + - python >=3.8 + - referencing >=0.31.0 + license: MIT + license_family: MIT + size: 16431 + timestamp: 1703778502971 +- kind: conda + name: jupyter_client + version: 8.6.2 + build: pyhd8ed1ab_0 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/jupyter_client-8.6.2-pyhd8ed1ab_0.conda + sha256: 634f065cdd1d0aacd4bb6848ebf240dcebc8578135d65f4ad4aa42b2276c4e0c + md5: 3cdbb2fa84490e5fd44c9f9806c0d292 + depends: + - importlib_metadata >=4.8.3 + - jupyter_core >=4.12,!=5.0.* + - python >=3.8 + - python-dateutil >=2.8.2 + - pyzmq >=23.0 + - tornado >=6.2 + - traitlets >=5.3 + license: BSD-3-Clause + license_family: BSD + size: 106248 + timestamp: 1716472312833 +- kind: conda + name: jupyter_core + version: 5.7.2 + build: py310h2ec42d9_0 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/jupyter_core-5.7.2-py310h2ec42d9_0.conda + sha256: ab2f20f7532322b2393220846cad453ee47848491971ec306755e7c1010b4e0a + md5: cc37456f73db17d159de1b07a26e91cc + depends: + - platformdirs >=2.5 + - python >=3.10,<3.11.0a0 + - python_abi 3.10.* *_cp310 + - traitlets >=5.3 + license: BSD-3-Clause + license_family: BSD + size: 80504 + timestamp: 1710257739574 +- kind: conda + name: jupyter_core + version: 5.7.2 + build: py310h4c7bcd0_0 + subdir: linux-aarch64 + url: https://conda.anaconda.org/conda-forge/linux-aarch64/jupyter_core-5.7.2-py310h4c7bcd0_0.conda + sha256: 5df473384294f63ae50a12c75e6eaf1d960e4c382ff3d5d6919881a94bd88168 + md5: c73a831af0204c79654ef7e3cda8b212 + depends: + - platformdirs >=2.5 + - python >=3.10,<3.11.0a0 + - python >=3.10,<3.11.0a0 *_cpython + - python_abi 3.10.* *_cp310 + - traitlets >=5.3 + license: BSD-3-Clause + license_family: BSD + size: 80657 + timestamp: 1710257732089 +- kind: conda + name: jupyter_core + version: 5.7.2 + build: py310h5588dad_0 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/jupyter_core-5.7.2-py310h5588dad_0.conda + sha256: 220a6fe571d3e9a5b5f4467d7f2fb22080b96f7143c9b2703528032528338d50 + md5: 6646c59c6c096e0b99c53dc9d3deaada + depends: + - platformdirs >=2.5 + - python >=3.10,<3.11.0a0 + - python_abi 3.10.* *_cp310 + - pywin32 >=300 + - traitlets >=5.3 + license: BSD-3-Clause + license_family: BSD + size: 97082 + timestamp: 1710257770270 +- kind: conda + name: jupyter_core + version: 5.7.2 + build: py310hbe9552e_0 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/jupyter_core-5.7.2-py310hbe9552e_0.conda + sha256: 9e351b25482c50c49fdf0e2203e238c5f04fed0cf192e227915fec955c5d890f + md5: bd7737fbd26eecd0f39cafb52a956f9e + depends: + - platformdirs >=2.5 + - python >=3.10,<3.11.0a0 + - python >=3.10,<3.11.0a0 *_cpython + - python_abi 3.10.* *_cp310 + - traitlets >=5.3 + license: BSD-3-Clause + license_family: BSD + size: 80605 + timestamp: 1710257888050 +- kind: conda + name: jupyter_core + version: 5.7.2 + build: py310hff52083_0 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/jupyter_core-5.7.2-py310hff52083_0.conda + sha256: 837039256d39a249b5bec850f87948e1967c47c9e747056df8155d80c4d3b094 + md5: cb92c27600d5716fd526a206aa43342c + depends: + - platformdirs >=2.5 + - python >=3.10,<3.11.0a0 + - python_abi 3.10.* *_cp310 + - traitlets >=5.3 + license: BSD-3-Clause + license_family: BSD + size: 79565 + timestamp: 1710257392136 +- kind: conda + name: jupyterlab_pygments + version: 0.3.0 + build: pyhd8ed1ab_1 + build_number: 1 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/jupyterlab_pygments-0.3.0-pyhd8ed1ab_1.conda + sha256: 4aa622bbcf97e44cd1adf0100b7ff71b7e20268f043bdf6feae4d16152f1f242 + md5: afcd1b53bcac8844540358e33f33d28f + depends: + - pygments >=2.4.1,<3 + - python >=3.7 + constrains: + - jupyterlab >=4.0.8,<5.0.0 + license: BSD-3-Clause + license_family: BSD + size: 18776 + timestamp: 1707149279640 +- kind: conda + name: keyutils + version: 1.6.1 + build: h166bdaf_0 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/keyutils-1.6.1-h166bdaf_0.tar.bz2 + sha256: 150c05a6e538610ca7c43beb3a40d65c90537497a4f6a5f4d15ec0451b6f5ebb + md5: 30186d27e2c9fa62b45fb1476b7200e3 + depends: + - libgcc-ng >=10.3.0 + license: LGPL-2.1-or-later + size: 117831 + timestamp: 1646151697040 +- kind: conda + name: keyutils + version: 1.6.1 + build: h4e544f5_0 + subdir: linux-aarch64 + url: https://conda.anaconda.org/conda-forge/linux-aarch64/keyutils-1.6.1-h4e544f5_0.tar.bz2 + sha256: 6d4233d97a9b38acbb26e1268bcf8c10a8e79c2aed7e5a385ec3769967e3e65b + md5: 1f24853e59c68892452ef94ddd8afd4b + depends: + - libgcc-ng >=10.3.0 + license: LGPL-2.1-or-later + size: 112327 + timestamp: 1646166857935 +- kind: conda + name: krb5 + version: 1.21.2 + build: h659d440_0 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/krb5-1.21.2-h659d440_0.conda + sha256: 259bfaae731989b252b7d2228c1330ef91b641c9d68ff87dae02cbae682cb3e4 + md5: cd95826dbd331ed1be26bdf401432844 + depends: + - keyutils >=1.6.1,<2.0a0 + - libedit >=3.1.20191231,<3.2.0a0 + - libedit >=3.1.20191231,<4.0a0 + - libgcc-ng >=12 + - libstdcxx-ng >=12 + - openssl >=3.1.2,<4.0a0 + license: MIT + license_family: MIT + size: 1371181 + timestamp: 1692097755782 +- kind: conda + name: krb5 + version: 1.21.2 + build: h92f50d5_0 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/krb5-1.21.2-h92f50d5_0.conda + sha256: 70bdb9b4589ec7c7d440e485ae22b5a352335ffeb91a771d4c162996c3070875 + md5: 92f1cff174a538e0722bf2efb16fc0b2 + depends: + - libcxx >=15.0.7 + - libedit >=3.1.20191231,<3.2.0a0 + - libedit >=3.1.20191231,<4.0a0 + - openssl >=3.1.2,<4.0a0 + license: MIT + license_family: MIT + size: 1195575 + timestamp: 1692098070699 +- kind: conda + name: krb5 + version: 1.21.2 + build: hb884880_0 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/krb5-1.21.2-hb884880_0.conda + sha256: 081ae2008a21edf57c048f331a17c65d1ccb52d6ca2f87ee031a73eff4dc0fc6 + md5: 80505a68783f01dc8d7308c075261b2f + depends: + - libcxx >=15.0.7 + - libedit >=3.1.20191231,<3.2.0a0 + - libedit >=3.1.20191231,<4.0a0 + - openssl >=3.1.2,<4.0a0 + license: MIT + license_family: MIT + size: 1183568 + timestamp: 1692098004387 +- kind: conda + name: krb5 + version: 1.21.2 + build: hc419048_0 + subdir: linux-aarch64 + url: https://conda.anaconda.org/conda-forge/linux-aarch64/krb5-1.21.2-hc419048_0.conda + sha256: c3f24ead49fb7d7c29fae491bec3f090f63d77a46954eadbc4463f137e2b42cd + md5: 55b51af37bf6fdcfe06f140e62e8c8db + depends: + - keyutils >=1.6.1,<2.0a0 + - libedit >=3.1.20191231,<3.2.0a0 + - libedit >=3.1.20191231,<4.0a0 + - libgcc-ng >=12 + - libstdcxx-ng >=12 + - openssl >=3.1.2,<4.0a0 + license: MIT + license_family: MIT + size: 1473397 + timestamp: 1692097651347 +- kind: conda + name: krb5 + version: 1.21.2 + build: heb0366b_0 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/krb5-1.21.2-heb0366b_0.conda + sha256: 6002adff9e3dcfc9732b861730cb9e33d45fd76b2035b2cdb4e6daacb8262c0b + md5: 6e8b0f22b4eef3b3cb3849bb4c3d47f9 + depends: + - openssl >=3.1.2,<4.0a0 + - ucrt >=10.0.20348.0 + - vc >=14.2,<15 + - vc14_runtime >=14.29.30139 + license: MIT + license_family: MIT + size: 710894 + timestamp: 1692098129546 +- kind: conda + name: ld_impl_linux-64 + version: '2.40' + build: hf3520f5_3 + build_number: 3 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/ld_impl_linux-64-2.40-hf3520f5_3.conda + sha256: 002d48084157a23c7e40a9b225bab95ea02ac6cb9267aa7739da2a3491bb0220 + md5: 7c1062eaa78dec4ea8a9a988dbda6045 + constrains: + - binutils_impl_linux-64 2.40 + license: GPL-3.0-only + license_family: GPL + size: 713873 + timestamp: 1717997303330 +- kind: conda + name: ld_impl_linux-aarch64 + version: '2.40' + build: h9fc2d93_3 + build_number: 3 + subdir: linux-aarch64 + url: https://conda.anaconda.org/conda-forge/linux-aarch64/ld_impl_linux-aarch64-2.40-h9fc2d93_3.conda + sha256: 12665b1f44fd39ff3221d58496916269c0646a50c418a172f1fe36801f3706bf + md5: ad64d50af0338aa3297eff41e424a5a5 + constrains: + - binutils_impl_linux-aarch64 2.40 + license: GPL-3.0-only + license_family: GPL + size: 737166 + timestamp: 1717997630957 +- kind: conda + name: libabseil + version: '20240116.2' + build: cxx17_h2f0025b_0 + subdir: linux-aarch64 + url: https://conda.anaconda.org/conda-forge/linux-aarch64/libabseil-20240116.2-cxx17_h2f0025b_0.conda + sha256: 17ff1cb3680121a83b6cefc69bffd3d3c65b4ab321b30fc6f38a84f62ce7ef36 + md5: 8c82217c05aa59b86d0db83df2fa65b5 + depends: + - libgcc-ng >=12 + - libstdcxx-ng >=12 + constrains: + - libabseil-static =20240116.2=cxx17* + - abseil-cpp =20240116.2 + license: Apache-2.0 + license_family: Apache + size: 1283376 + timestamp: 1714403298858 +- kind: conda + name: libabseil + version: '20240116.2' + build: cxx17_h59595ed_0 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/libabseil-20240116.2-cxx17_h59595ed_0.conda + sha256: 19b789dc38dff64eee2002675991e63f381eedf5efd5c85f2dac512ed97376d7 + md5: 682bdbe046a68f749769b492f3625c5c + depends: + - libgcc-ng >=12 + - libstdcxx-ng >=12 + constrains: + - libabseil-static =20240116.2=cxx17* + - abseil-cpp =20240116.2 + license: Apache-2.0 + license_family: Apache + size: 1266634 + timestamp: 1714403128134 +- kind: conda + name: libabseil + version: '20240116.2' + build: cxx17_h63175ca_0 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/libabseil-20240116.2-cxx17_h63175ca_0.conda + sha256: 37539d02a9d1064a18838303a9829fa14d5bffa5e02349b3a15d9bd8a2815e79 + md5: 31b8c712b478ba94896707c159c60499 + depends: + - ucrt >=10.0.20348.0 + - vc >=14.2,<15 + - vc14_runtime >=14.29.30139 + constrains: + - abseil-cpp =20240116.2 + - libabseil-static =20240116.2=cxx17* + license: Apache-2.0 + license_family: Apache + size: 1781843 + timestamp: 1714404063887 +- kind: conda + name: libabseil + version: '20240116.2' + build: cxx17_hc1bcbd7_0 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/libabseil-20240116.2-cxx17_hc1bcbd7_0.conda + sha256: 91c7818fd4d4e1d7e7fb6ace5f72e699112a9207f00f1ee82e62b7a87d239837 + md5: f2ac89dbd4914f487706282ebf787636 + depends: + - libcxx >=16 + constrains: + - __osx >=10.13 + - libabseil-static =20240116.2=cxx17* + - abseil-cpp =20240116.2 + license: Apache-2.0 + license_family: Apache + size: 1131191 + timestamp: 1714403767205 +- kind: conda + name: libabseil + version: '20240116.2' + build: cxx17_hebf3989_0 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/libabseil-20240116.2-cxx17_hebf3989_0.conda + sha256: d96bd35e162637be3767637352195e6cdfd85d98068564f73f3450b0cb265776 + md5: edc3edb68fd9cbb014ac675dc73006c2 + depends: + - libcxx >=16 + constrains: + - abseil-cpp =20240116.2 + - libabseil-static =20240116.2=cxx17* + license: Apache-2.0 + license_family: Apache + size: 1143678 + timestamp: 1714403860076 +- kind: conda + name: libblas + version: 3.9.0 + build: 22_linux64_openblas + build_number: 22 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/libblas-3.9.0-22_linux64_openblas.conda + sha256: 082b8ac20d43a7bbcdc28b3b1cd40e4df3a8b5daf0a2d23d68953a44d2d12c1b + md5: 1a2a0cd3153464fee6646f3dd6dad9b8 + depends: + - libopenblas >=0.3.27,<0.3.28.0a0 + - libopenblas >=0.3.27,<1.0a0 + constrains: + - libcblas 3.9.0 22_linux64_openblas + - blas * openblas + - liblapacke 3.9.0 22_linux64_openblas + - liblapack 3.9.0 22_linux64_openblas + license: BSD-3-Clause + license_family: BSD + size: 14537 + timestamp: 1712542250081 +- kind: conda + name: libblas + version: 3.9.0 + build: 22_linuxaarch64_openblas + build_number: 22 + subdir: linux-aarch64 + url: https://conda.anaconda.org/conda-forge/linux-aarch64/libblas-3.9.0-22_linuxaarch64_openblas.conda + sha256: eb4398566a601e68b21ceab9a905a619b94d4d6c8242fffd9ed57cc26d29e278 + md5: 068ab33f2382cda4dd0b72a715ad33b5 + depends: + - libopenblas >=0.3.27,<0.3.28.0a0 + - libopenblas >=0.3.27,<1.0a0 + constrains: + - blas * openblas + - libcblas 3.9.0 22_linuxaarch64_openblas + - liblapacke 3.9.0 22_linuxaarch64_openblas + - liblapack 3.9.0 22_linuxaarch64_openblas + license: BSD-3-Clause + license_family: BSD + size: 14612 + timestamp: 1712542041279 +- kind: conda + name: libblas + version: 3.9.0 + build: 22_osx64_openblas + build_number: 22 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/libblas-3.9.0-22_osx64_openblas.conda + sha256: d72060239f904b3a81d2329efcf84dc62c2dfd66dbc4efc8dcae1afdf8f02b59 + md5: b80966a8c8dd0b531f8e65f709d732e8 + depends: + - libopenblas >=0.3.27,<0.3.28.0a0 + - libopenblas >=0.3.27,<1.0a0 + constrains: + - liblapacke 3.9.0 22_osx64_openblas + - blas * openblas + - libcblas 3.9.0 22_osx64_openblas + - liblapack 3.9.0 22_osx64_openblas + license: BSD-3-Clause + license_family: BSD + size: 14749 + timestamp: 1712542279018 +- kind: conda + name: libblas + version: 3.9.0 + build: 22_osxarm64_openblas + build_number: 22 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/libblas-3.9.0-22_osxarm64_openblas.conda + sha256: 8620e13366076011cfcc6b2565c7a2d362c5d3f0423f54b9ef9bfc17b1a012a4 + md5: aeaf35355ef0f37c7c1ba35b7b7db55f + depends: + - libopenblas >=0.3.27,<0.3.28.0a0 + - libopenblas >=0.3.27,<1.0a0 + constrains: + - blas * openblas + - liblapack 3.9.0 22_osxarm64_openblas + - liblapacke 3.9.0 22_osxarm64_openblas + - libcblas 3.9.0 22_osxarm64_openblas + license: BSD-3-Clause + license_family: BSD + size: 14824 + timestamp: 1712542396471 +- kind: conda + name: libblas + version: 3.9.0 + build: 22_win64_mkl + build_number: 22 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/libblas-3.9.0-22_win64_mkl.conda + sha256: 4faab445cbd9a13736a206b98fde962d0a9fa80dcbd38300951a8b2863e7c35c + md5: 65c56ecdeceffd6c32d3d54db7e02c6e + depends: + - mkl 2024.1.0 h66d3029_692 + constrains: + - liblapacke 3.9.0 22_win64_mkl + - blas * mkl + - libcblas 3.9.0 22_win64_mkl + - liblapack 3.9.0 22_win64_mkl + license: BSD-3-Clause + license_family: BSD + size: 5182602 + timestamp: 1712542984136 +- kind: conda + name: libcblas + version: 3.9.0 + build: 22_linux64_openblas + build_number: 22 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/libcblas-3.9.0-22_linux64_openblas.conda + sha256: da1b2faa017663c8f5555c1c5518e96ac4cd8e0be2a673c1c9e2cb8507c8fe46 + md5: 4b31699e0ec5de64d5896e580389c9a1 + depends: + - libblas 3.9.0 22_linux64_openblas + constrains: + - liblapack 3.9.0 22_linux64_openblas + - blas * openblas + - liblapacke 3.9.0 22_linux64_openblas + license: BSD-3-Clause + license_family: BSD + size: 14438 + timestamp: 1712542270166 +- kind: conda + name: libcblas + version: 3.9.0 + build: 22_linuxaarch64_openblas + build_number: 22 + subdir: linux-aarch64 + url: https://conda.anaconda.org/conda-forge/linux-aarch64/libcblas-3.9.0-22_linuxaarch64_openblas.conda + sha256: 04e31c5f3a3b345a8fcdfa6f5c75909688a134bf9ee93c367c6e5affca501068 + md5: fbe7fe553f2cc78a0311e009b26f180d + depends: + - libblas 3.9.0 22_linuxaarch64_openblas + constrains: + - blas * openblas + - liblapack 3.9.0 22_linuxaarch64_openblas + - liblapacke 3.9.0 22_linuxaarch64_openblas + license: BSD-3-Clause + license_family: BSD + size: 14514 + timestamp: 1712542053335 +- kind: conda + name: libcblas + version: 3.9.0 + build: 22_osx64_openblas + build_number: 22 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/libcblas-3.9.0-22_osx64_openblas.conda + sha256: 6a2ba9198e2320c3e22fe3d121310cf8a8ac663e94100c5693b34523fcb3cc04 + md5: b9fef82772330f61b2b0201c72d2c29b + depends: + - libblas 3.9.0 22_osx64_openblas + constrains: + - liblapacke 3.9.0 22_osx64_openblas + - blas * openblas + - liblapack 3.9.0 22_osx64_openblas + license: BSD-3-Clause + license_family: BSD + size: 14636 + timestamp: 1712542311437 +- kind: conda + name: libcblas + version: 3.9.0 + build: 22_osxarm64_openblas + build_number: 22 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/libcblas-3.9.0-22_osxarm64_openblas.conda + sha256: 2c7902985dc77db1d7252b4e838d92a34b1729799ae402988d62d077868f6cca + md5: 37b3682240a69874a22658dedbca37d9 + depends: + - libblas 3.9.0 22_osxarm64_openblas + constrains: + - blas * openblas + - liblapack 3.9.0 22_osxarm64_openblas + - liblapacke 3.9.0 22_osxarm64_openblas + license: BSD-3-Clause + license_family: BSD + size: 14741 + timestamp: 1712542420590 +- kind: conda + name: libcblas + version: 3.9.0 + build: 22_win64_mkl + build_number: 22 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/libcblas-3.9.0-22_win64_mkl.conda + sha256: 5503273924650330dc03edd1eb01ec4020b9967b5a4cafc377ba20b976d15590 + md5: 336c93ab102846c6131cf68e722a68f1 + depends: + - libblas 3.9.0 22_win64_mkl + constrains: + - liblapacke 3.9.0 22_win64_mkl + - blas * mkl + - liblapack 3.9.0 22_win64_mkl + license: BSD-3-Clause + license_family: BSD + size: 5191513 + timestamp: 1712543043641 +- kind: conda + name: libcxx + version: 17.0.6 + build: h5f092b4_0 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/libcxx-17.0.6-h5f092b4_0.conda + sha256: 119d3d9306f537d4c89dc99ed99b94c396d262f0b06f7833243646f68884f2c2 + md5: a96fd5dda8ce56c86a971e0fa02751d0 + depends: + - __osx >=11.0 + license: Apache-2.0 WITH LLVM-exception + license_family: Apache + size: 1248885 + timestamp: 1715020154867 +- kind: conda + name: libcxx + version: 17.0.6 + build: h88467a6_0 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/libcxx-17.0.6-h88467a6_0.conda + sha256: e7b57062c1edfcbd13d2129467c94cbff7f0a988ee75782bf48b1dc0e6300b8b + md5: 0fe355aecb8d24b8bc07c763209adbd9 + depends: + - __osx >=10.13 + license: Apache-2.0 WITH LLVM-exception + license_family: Apache + size: 1249309 + timestamp: 1715020018902 +- kind: conda + name: libedit + version: 3.1.20191231 + build: h0678c8f_2 + build_number: 2 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/libedit-3.1.20191231-h0678c8f_2.tar.bz2 + sha256: dbd3c3f2eca1d21c52e4c03b21930bbce414c4592f8ce805801575b9e9256095 + md5: 6016a8a1d0e63cac3de2c352cd40208b + depends: + - ncurses >=6.2,<7.0.0a0 + license: BSD-2-Clause + license_family: BSD + size: 105382 + timestamp: 1597616576726 +- kind: conda + name: libedit + version: 3.1.20191231 + build: hc8eb9b7_2 + build_number: 2 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/libedit-3.1.20191231-hc8eb9b7_2.tar.bz2 + sha256: 3912636197933ecfe4692634119e8644904b41a58f30cad9d1fc02f6ba4d9fca + md5: 30e4362988a2623e9eb34337b83e01f9 + depends: + - ncurses >=6.2,<7.0.0a0 + license: BSD-2-Clause + license_family: BSD + size: 96607 + timestamp: 1597616630749 +- kind: conda + name: libedit + version: 3.1.20191231 + build: he28a2e2_2 + build_number: 2 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/libedit-3.1.20191231-he28a2e2_2.tar.bz2 + sha256: a57d37c236d8f7c886e01656f4949d9dcca131d2a0728609c6f7fa338b65f1cf + md5: 4d331e44109e3f0e19b4cb8f9b82f3e1 + depends: + - libgcc-ng >=7.5.0 + - ncurses >=6.2,<7.0.0a0 + license: BSD-2-Clause + license_family: BSD + size: 123878 + timestamp: 1597616541093 +- kind: conda + name: libedit + version: 3.1.20191231 + build: he28a2e2_2 + build_number: 2 + subdir: linux-aarch64 + url: https://conda.anaconda.org/conda-forge/linux-aarch64/libedit-3.1.20191231-he28a2e2_2.tar.bz2 + sha256: debc31fb2f07ba2b0363f90e455873670734082822926ba4a9556431ec0bf36d + md5: 29371161d77933a54fccf1bb66b96529 + depends: + - libgcc-ng >=7.5.0 + - ncurses >=6.2,<7.0.0a0 + license: BSD-2-Clause + license_family: BSD + size: 134104 + timestamp: 1597617110769 +- kind: conda + name: libexpat + version: 2.6.2 + build: h2f0025b_0 + subdir: linux-aarch64 + url: https://conda.anaconda.org/conda-forge/linux-aarch64/libexpat-2.6.2-h2f0025b_0.conda + sha256: 07453df3232a649f39fb4d1e68cfe1c78c3457764f85225f6f3ccd1bdd9818a4 + md5: 1b9f46b804a2c3c5d7fd6a80b77c35f9 + depends: + - libgcc-ng >=12 + constrains: + - expat 2.6.2.* + license: MIT + license_family: MIT + size: 72544 + timestamp: 1710362309065 +- kind: conda + name: libexpat + version: 2.6.2 + build: h59595ed_0 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/libexpat-2.6.2-h59595ed_0.conda + sha256: 331bb7c7c05025343ebd79f86ae612b9e1e74d2687b8f3179faec234f986ce19 + md5: e7ba12deb7020dd080c6c70e7b6f6a3d + depends: + - libgcc-ng >=12 + constrains: + - expat 2.6.2.* + license: MIT + license_family: MIT + size: 73730 + timestamp: 1710362120304 +- kind: conda + name: libexpat + version: 2.6.2 + build: h63175ca_0 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/libexpat-2.6.2-h63175ca_0.conda + sha256: 79f612f75108f3e16bbdc127d4885bb74729cf66a8702fca0373dad89d40c4b7 + md5: bc592d03f62779511d392c175dcece64 + constrains: + - expat 2.6.2.* + license: MIT + license_family: MIT + size: 139224 + timestamp: 1710362609641 +- kind: conda + name: libexpat + version: 2.6.2 + build: h73e2aa4_0 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/libexpat-2.6.2-h73e2aa4_0.conda + sha256: a188a77b275d61159a32ab547f7d17892226e7dac4518d2c6ac3ac8fc8dfde92 + md5: 3d1d51c8f716d97c864d12f7af329526 + constrains: + - expat 2.6.2.* + license: MIT + license_family: MIT + size: 69246 + timestamp: 1710362566073 +- kind: conda + name: libexpat + version: 2.6.2 + build: hebf3989_0 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/libexpat-2.6.2-hebf3989_0.conda + sha256: ba7173ac30064ea901a4c9fb5a51846dcc25512ceb565759be7d18cbf3e5415e + md5: e3cde7cfa87f82f7cb13d482d5e0ad09 + constrains: + - expat 2.6.2.* + license: MIT + license_family: MIT + size: 63655 + timestamp: 1710362424980 +- kind: conda + name: libffi + version: 3.4.2 + build: h0d85af4_5 + build_number: 5 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/libffi-3.4.2-h0d85af4_5.tar.bz2 + sha256: 7a2d27a936ceee6942ea4d397f9c7d136f12549d86f7617e8b6bad51e01a941f + md5: ccb34fb14960ad8b125962d3d79b31a9 + license: MIT + license_family: MIT + size: 51348 + timestamp: 1636488394370 +- kind: conda + name: libffi + version: 3.4.2 + build: h3422bc3_5 + build_number: 5 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/libffi-3.4.2-h3422bc3_5.tar.bz2 + sha256: 41b3d13efb775e340e4dba549ab5c029611ea6918703096b2eaa9c015c0750ca + md5: 086914b672be056eb70fd4285b6783b6 + license: MIT + license_family: MIT + size: 39020 + timestamp: 1636488587153 +- kind: conda + name: libffi + version: 3.4.2 + build: h3557bc0_5 + build_number: 5 + subdir: linux-aarch64 + url: https://conda.anaconda.org/conda-forge/linux-aarch64/libffi-3.4.2-h3557bc0_5.tar.bz2 + sha256: 7e9258a102480757fe3faeb225a3ca04dffd10fecd2a958c65cdb4cdf75f2c3c + md5: dddd85f4d52121fab0a8b099c5e06501 + depends: + - libgcc-ng >=9.4.0 + license: MIT + license_family: MIT + size: 59450 + timestamp: 1636488255090 +- kind: conda + name: libffi + version: 3.4.2 + build: h7f98852_5 + build_number: 5 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/libffi-3.4.2-h7f98852_5.tar.bz2 + sha256: ab6e9856c21709b7b517e940ae7028ae0737546122f83c2aa5d692860c3b149e + md5: d645c6d2ac96843a2bfaccd2d62b3ac3 + depends: + - libgcc-ng >=9.4.0 + license: MIT + license_family: MIT + size: 58292 + timestamp: 1636488182923 +- kind: conda + name: libffi + version: 3.4.2 + build: h8ffe710_5 + build_number: 5 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/libffi-3.4.2-h8ffe710_5.tar.bz2 + sha256: 1951ab740f80660e9bc07d2ed3aefb874d78c107264fd810f24a1a6211d4b1a5 + md5: 2c96d1b6915b408893f9472569dee135 + depends: + - vc >=14.1,<15.0a0 + - vs2015_runtime >=14.16.27012 + license: MIT + license_family: MIT + size: 42063 + timestamp: 1636489106777 +- kind: conda + name: libgcc-ng + version: 13.2.0 + build: h77fa898_7 + build_number: 7 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/libgcc-ng-13.2.0-h77fa898_7.conda + sha256: 62af2b89acbe74a21606c8410c276e57309c0a2ab8a9e8639e3c8131c0b60c92 + md5: 72ec1b1b04c4d15d4204ece1ecea5978 + depends: + - _libgcc_mutex 0.1 conda_forge + - _openmp_mutex >=4.5 + constrains: + - libgomp 13.2.0 h77fa898_7 + license: GPL-3.0-only WITH GCC-exception-3.1 + license_family: GPL + size: 775806 + timestamp: 1715016057793 +- kind: conda + name: libgcc-ng + version: 13.2.0 + build: he277a41_7 + build_number: 7 + subdir: linux-aarch64 + url: https://conda.anaconda.org/conda-forge/linux-aarch64/libgcc-ng-13.2.0-he277a41_7.conda + sha256: ef2f338b3342b51700e6cda10831d27bb2983fe64d7e75e30e9ffb7f9cf76571 + md5: 01c5b27ce46f50abab2dc8454842c792 + depends: + - _openmp_mutex >=4.5 + constrains: + - libgomp 13.2.0 he277a41_7 + license: GPL-3.0-only WITH GCC-exception-3.1 + license_family: GPL + size: 458977 + timestamp: 1715017703433 +- kind: conda + name: libgfortran + version: 5.0.0 + build: 13_2_0_h97931a8_3 + build_number: 3 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/libgfortran-5.0.0-13_2_0_h97931a8_3.conda + sha256: 4874422e567b68334705c135c17e5acdca1404de8255673ce30ad3510e00be0d + md5: 0b6e23a012ee7a9a5f6b244f5a92c1d5 + depends: + - libgfortran5 13.2.0 h2873a65_3 + license: GPL-3.0-only WITH GCC-exception-3.1 + license_family: GPL + size: 110106 + timestamp: 1707328956438 +- kind: conda + name: libgfortran + version: 5.0.0 + build: 13_2_0_hd922786_3 + build_number: 3 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/libgfortran-5.0.0-13_2_0_hd922786_3.conda + sha256: 44e541b4821c96b28b27fef5630883a60ce4fee91fd9c79f25a199f8f73f337b + md5: 4a55d9e169114b2b90d3ec4604cd7bbf + depends: + - libgfortran5 13.2.0 hf226fd6_3 + license: GPL-3.0-only WITH GCC-exception-3.1 + license_family: GPL + size: 110233 + timestamp: 1707330749033 +- kind: conda + name: libgfortran-ng + version: 13.2.0 + build: h69a702a_7 + build_number: 7 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/libgfortran-ng-13.2.0-h69a702a_7.conda + sha256: a588e69f96b8e0983a8cdfdbf1dc75eb48189f5420ec71150c8d8cdc0a811a9b + md5: 1b84f26d9f4f6026e179e7805d5a15cd + depends: + - libgfortran5 13.2.0 hca663fb_7 + license: GPL-3.0-only WITH GCC-exception-3.1 + license_family: GPL + size: 24314 + timestamp: 1715016272844 +- kind: conda + name: libgfortran-ng + version: 13.2.0 + build: he9431aa_7 + build_number: 7 + subdir: linux-aarch64 + url: https://conda.anaconda.org/conda-forge/linux-aarch64/libgfortran-ng-13.2.0-he9431aa_7.conda + sha256: 295d9d4266894d7b5c65950e6f6e91c8b8e1730a540fa5bcc488192b76277913 + md5: d714db6ba9d67d55d21cf96316714ec8 + depends: + - libgfortran5 13.2.0 h87d9d71_7 + license: GPL-3.0-only WITH GCC-exception-3.1 + license_family: GPL + size: 24367 + timestamp: 1715017978335 +- kind: conda + name: libgfortran5 + version: 13.2.0 + build: h2873a65_3 + build_number: 3 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/libgfortran5-13.2.0-h2873a65_3.conda + sha256: da3db4b947e30aec7596a3ef92200d17e774cccbbf7efc47802529a4ca5ca31b + md5: e4fb4d23ec2870ff3c40d10afe305aec + depends: + - llvm-openmp >=8.0.0 + constrains: + - libgfortran 5.0.0 13_2_0_*_3 + license: GPL-3.0-only WITH GCC-exception-3.1 + license_family: GPL + size: 1571379 + timestamp: 1707328880361 +- kind: conda + name: libgfortran5 + version: 13.2.0 + build: h87d9d71_7 + build_number: 7 + subdir: linux-aarch64 + url: https://conda.anaconda.org/conda-forge/linux-aarch64/libgfortran5-13.2.0-h87d9d71_7.conda + sha256: 6fc946955668102fe1e73614810a24e2a2f50aa87390d68e757380fea8551e16 + md5: 423eb7de085dd6b46928723edf5f8767 + depends: + - libgcc-ng >=13.2.0 + constrains: + - libgfortran-ng 13.2.0 + license: GPL-3.0-only WITH GCC-exception-3.1 + license_family: GPL + size: 1083345 + timestamp: 1715017746481 +- kind: conda + name: libgfortran5 + version: 13.2.0 + build: hca663fb_7 + build_number: 7 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/libgfortran5-13.2.0-hca663fb_7.conda + sha256: 754ab038115edce550fdccdc9ddf7dead2fa8346b8cdd4428c59ae1e83293978 + md5: c0bd771f09a326fdcd95a60b617795bf + depends: + - libgcc-ng >=13.2.0 + constrains: + - libgfortran-ng 13.2.0 + license: GPL-3.0-only WITH GCC-exception-3.1 + license_family: GPL + size: 1441361 + timestamp: 1715016068766 +- kind: conda + name: libgfortran5 + version: 13.2.0 + build: hf226fd6_3 + build_number: 3 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/libgfortran5-13.2.0-hf226fd6_3.conda + sha256: bafc679eedb468a86aa4636061c55966186399ee0a04b605920d208d97ac579a + md5: 66ac81d54e95c534ae488726c1f698ea + depends: + - llvm-openmp >=8.0.0 + constrains: + - libgfortran 5.0.0 13_2_0_*_3 + license: GPL-3.0-only WITH GCC-exception-3.1 + license_family: GPL + size: 997381 + timestamp: 1707330687590 +- kind: conda + name: libgomp + version: 13.2.0 + build: h77fa898_7 + build_number: 7 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/libgomp-13.2.0-h77fa898_7.conda + sha256: 781444fa069d3b50e8ed667b750571cacda785761c7fc2a89ece1ac49693d4ad + md5: abf3fec87c2563697defa759dec3d639 + depends: + - _libgcc_mutex 0.1 conda_forge + license: GPL-3.0-only WITH GCC-exception-3.1 + license_family: GPL + size: 422336 + timestamp: 1715015995979 +- kind: conda + name: libgomp + version: 13.2.0 + build: he277a41_7 + build_number: 7 + subdir: linux-aarch64 + url: https://conda.anaconda.org/conda-forge/linux-aarch64/libgomp-13.2.0-he277a41_7.conda + sha256: bb3bc7e03f1add861884d8bad79b359ad991025570625e1f979964e82f1f8d9e + md5: 1d1691ec9e5be799f86310fa38f00b9f + license: GPL-3.0-only WITH GCC-exception-3.1 + license_family: GPL + size: 424004 + timestamp: 1715017599237 +- kind: conda + name: libhwloc + version: 2.10.0 + build: default_h8125262_1001 + build_number: 1001 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/libhwloc-2.10.0-default_h8125262_1001.conda + sha256: 7f1aa1b071269df72e88297c046ec153b7f9a81e6f135d2da4401c96f41b5052 + md5: e761885eb4c181074d172220d46319a0 + depends: + - libxml2 >=2.12.7,<3.0a0 + - pthreads-win32 + - ucrt >=10.0.20348.0 + - vc >=14.2,<15 + - vc14_runtime >=14.29.30139 + license: BSD-3-Clause + license_family: BSD + size: 2373948 + timestamp: 1715973819139 +- kind: conda + name: libiconv + version: '1.17' + build: hcfcfb64_2 + build_number: 2 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/libiconv-1.17-hcfcfb64_2.conda + sha256: 5f844dd19b046d43174ad80c6ea75b5d504020e3b63cfbc4ace97b8730d35c7b + md5: e1eb10b1cca179f2baa3601e4efc8712 + depends: + - ucrt >=10.0.20348.0 + - vc >=14.2,<15 + - vc14_runtime >=14.29.30139 + license: LGPL-2.1-only + size: 636146 + timestamp: 1702682547199 +- kind: conda + name: liblapack + version: 3.9.0 + build: 22_linux64_openblas + build_number: 22 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/liblapack-3.9.0-22_linux64_openblas.conda + sha256: db246341d42f9100d45adeb1a7ba8b1ef5b51ceb9056fd643e98046a3259fde6 + md5: b083767b6c877e24ee597d93b87ab838 + depends: + - libblas 3.9.0 22_linux64_openblas + constrains: + - libcblas 3.9.0 22_linux64_openblas + - blas * openblas + - liblapacke 3.9.0 22_linux64_openblas + license: BSD-3-Clause + license_family: BSD + size: 14471 + timestamp: 1712542277696 +- kind: conda + name: liblapack + version: 3.9.0 + build: 22_linuxaarch64_openblas + build_number: 22 + subdir: linux-aarch64 + url: https://conda.anaconda.org/conda-forge/linux-aarch64/liblapack-3.9.0-22_linuxaarch64_openblas.conda + sha256: a7cb3fd83fdd6eca14adbe3d0cbba6e6246683d39af783f5c05852ed2a9e16a5 + md5: 8c709d281609792c39b1d5c0241f90f1 + depends: + - libblas 3.9.0 22_linuxaarch64_openblas + constrains: + - blas * openblas + - libcblas 3.9.0 22_linuxaarch64_openblas + - liblapacke 3.9.0 22_linuxaarch64_openblas + license: BSD-3-Clause + license_family: BSD + size: 14451 + timestamp: 1712542059832 +- kind: conda + name: liblapack + version: 3.9.0 + build: 22_osx64_openblas + build_number: 22 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/liblapack-3.9.0-22_osx64_openblas.conda + sha256: e36744f3e780564d6748b5dd05e15ad6a1af9184cf32ab9d1304c13a6bc3e16b + md5: f21b282ff7ba14df6134a0fe6ab42b1b + depends: + - libblas 3.9.0 22_osx64_openblas + constrains: + - liblapacke 3.9.0 22_osx64_openblas + - blas * openblas + - libcblas 3.9.0 22_osx64_openblas + license: BSD-3-Clause + license_family: BSD + size: 14657 + timestamp: 1712542322711 +- kind: conda + name: liblapack + version: 3.9.0 + build: 22_osxarm64_openblas + build_number: 22 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/liblapack-3.9.0-22_osxarm64_openblas.conda + sha256: 2b1b24c98d15a6a3ad54cf7c8fef1ddccf84b7c557cde08235aaeffd1ff50ee8 + md5: f2794950bc005e123b2c21f7fa3d7a6e + depends: + - libblas 3.9.0 22_osxarm64_openblas + constrains: + - blas * openblas + - liblapacke 3.9.0 22_osxarm64_openblas + - libcblas 3.9.0 22_osxarm64_openblas + license: BSD-3-Clause + license_family: BSD + size: 14730 + timestamp: 1712542435551 +- kind: conda + name: liblapack + version: 3.9.0 + build: 22_win64_mkl + build_number: 22 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/liblapack-3.9.0-22_win64_mkl.conda + sha256: 8b28b361a13819ed83a67d3bfdde750a13bc8b50b9af26d94fd61616d0f2d703 + md5: c752cc2af9f3d8d7b2fdebb915a33ef7 + depends: + - libblas 3.9.0 22_win64_mkl + constrains: + - liblapacke 3.9.0 22_win64_mkl + - blas * mkl + - libcblas 3.9.0 22_win64_mkl + license: BSD-3-Clause + license_family: BSD + size: 5182500 + timestamp: 1712543085027 +- kind: conda + name: libnsl + version: 2.0.1 + build: h31becfc_0 + subdir: linux-aarch64 + url: https://conda.anaconda.org/conda-forge/linux-aarch64/libnsl-2.0.1-h31becfc_0.conda + sha256: fd18c2b75d7411096428d36a70b36b1a17e31f7b8956b6905d145792d49e97f8 + md5: c14f32510f694e3185704d89967ec422 + depends: + - libgcc-ng >=12 + license: LGPL-2.1-only + license_family: GPL + size: 34501 + timestamp: 1697358973269 +- kind: conda + name: libnsl + version: 2.0.1 + build: hd590300_0 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/libnsl-2.0.1-hd590300_0.conda + sha256: 26d77a3bb4dceeedc2a41bd688564fe71bf2d149fdcf117049970bc02ff1add6 + md5: 30fd6e37fe21f86f4bd26d6ee73eeec7 + depends: + - libgcc-ng >=12 + license: LGPL-2.1-only + license_family: GPL + size: 33408 + timestamp: 1697359010159 +- kind: conda + name: libopenblas + version: 0.3.27 + build: openmp_h6c19121_0 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/libopenblas-0.3.27-openmp_h6c19121_0.conda + sha256: feb2662444fc98a4842fe54cc70b1f109b2146108e7bac2b3bbad1f219cede90 + md5: 82eba59f4eca26a9fc904d584f8761c0 + depends: + - libgfortran 5.* + - libgfortran5 >=12.3.0 + - llvm-openmp >=16.0.6 + constrains: + - openblas >=0.3.27,<0.3.28.0a0 + license: BSD-3-Clause + license_family: BSD + size: 2925015 + timestamp: 1712364212874 +- kind: conda + name: libopenblas + version: 0.3.27 + build: openmp_hfef2a42_0 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/libopenblas-0.3.27-openmp_hfef2a42_0.conda + sha256: 45519189c0295296268cb7eabeeaa03ef54d780416c9a24be1d2a21db63a7848 + md5: 00237c9c7f2cb6725fe2960680a6e225 + depends: + - libgfortran 5.* + - libgfortran5 >=12.3.0 + - llvm-openmp >=16.0.6 + constrains: + - openblas >=0.3.27,<0.3.28.0a0 + license: BSD-3-Clause + license_family: BSD + size: 6047531 + timestamp: 1712366254156 +- kind: conda + name: libopenblas + version: 0.3.27 + build: pthreads_h413a1c8_0 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/libopenblas-0.3.27-pthreads_h413a1c8_0.conda + sha256: 2ae7559aed0705deb3f716c7b247c74fd1b5e35b64e39834ce8b95f7564d4a3e + md5: a356024784da6dfd4683dc5ecf45b155 + depends: + - libgcc-ng >=12 + - libgfortran-ng + - libgfortran5 >=12.3.0 + constrains: + - openblas >=0.3.27,<0.3.28.0a0 + license: BSD-3-Clause + license_family: BSD + size: 5598747 + timestamp: 1712364444346 +- kind: conda + name: libopenblas + version: 0.3.27 + build: pthreads_h5a5ec62_0 + subdir: linux-aarch64 + url: https://conda.anaconda.org/conda-forge/linux-aarch64/libopenblas-0.3.27-pthreads_h5a5ec62_0.conda + sha256: 8a898c64f769c03217fee45d2df9faaee6c1a24349e21ba3569bc7a2ed8dfd1e + md5: ffecca8f4f31cd50b92c0e6e6bfe4416 + depends: + - libgcc-ng >=12 + - libgfortran-ng + - libgfortran5 >=12.3.0 + constrains: + - openblas >=0.3.27,<0.3.28.0a0 + license: BSD-3-Clause + license_family: BSD + size: 4300345 + timestamp: 1712492725507 +- kind: conda + name: libprotobuf + version: 4.25.3 + build: h08a7969_0 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/libprotobuf-4.25.3-h08a7969_0.conda + sha256: 70e0eef046033af2e8d21251a785563ad738ed5281c74e21c31c457780845dcd + md5: 6945825cebd2aeb16af4c69d97c32c13 + depends: + - libabseil * cxx17* + - libabseil >=20240116.1,<20240117.0a0 + - libgcc-ng >=12 + - libstdcxx-ng >=12 + - libzlib >=1.2.13,<2.0.0a0 + license: BSD-3-Clause + license_family: BSD + size: 2811207 + timestamp: 1709514552541 +- kind: conda + name: libprotobuf + version: 4.25.3 + build: h4e4d658_0 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/libprotobuf-4.25.3-h4e4d658_0.conda + sha256: 3f126769fb5820387d436370ad48600e05d038a28689fdf9988b64e1059947a8 + md5: 57b7ee4f1fd8573781cfdabaec4a7782 + depends: + - __osx >=10.13 + - libabseil * cxx17* + - libabseil >=20240116.1,<20240117.0a0 + - libcxx >=16 + - libzlib >=1.2.13,<2.0.0a0 + license: BSD-3-Clause + license_family: BSD + size: 2216001 + timestamp: 1709514908146 +- kind: conda + name: libprotobuf + version: 4.25.3 + build: h503648d_0 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/libprotobuf-4.25.3-h503648d_0.conda + sha256: 5d4c5592be3994657ebf47e52f26b734cc50b0ea9db007d920e2e31762aac216 + md5: 4da7de0ba35777742edf67bf7a1075df + depends: + - libabseil * cxx17* + - libabseil >=20240116.1,<20240117.0a0 + - libzlib >=1.2.13,<2.0.0a0 + - ucrt >=10.0.20348.0 + - vc >=14.2,<15 + - vc14_runtime >=14.29.30139 + license: BSD-3-Clause + license_family: BSD + size: 5650604 + timestamp: 1709514804631 +- kind: conda + name: libprotobuf + version: 4.25.3 + build: h648ac29_0 + subdir: linux-aarch64 + url: https://conda.anaconda.org/conda-forge/linux-aarch64/libprotobuf-4.25.3-h648ac29_0.conda + sha256: 76775a1457b2d4de1097bec2fda16b8e6e80f761d11aa7a525fa215bff4ab87c + md5: a239d63913ec9e008bdbe35899f677f4 + depends: + - libabseil * cxx17* + - libabseil >=20240116.1,<20240117.0a0 + - libgcc-ng >=12 + - libstdcxx-ng >=12 + - libzlib >=1.2.13,<2.0.0a0 + license: BSD-3-Clause + license_family: BSD + size: 2576197 + timestamp: 1709513627963 +- kind: conda + name: libprotobuf + version: 4.25.3 + build: hbfab5d5_0 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/libprotobuf-4.25.3-hbfab5d5_0.conda + sha256: d754519abc3ddbdedab2a38d0639170f5347c1573eef80c707f3a8dc5dff706a + md5: 5f70b2b945a9741cba7e6dfe735a02a7 + depends: + - libabseil * cxx17* + - libabseil >=20240116.1,<20240117.0a0 + - libcxx >=16 + - libzlib >=1.2.13,<2.0.0a0 + license: BSD-3-Clause + license_family: BSD + size: 2154402 + timestamp: 1709514097574 +- kind: conda + name: libsodium + version: 1.0.18 + build: h27ca646_1 + build_number: 1 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/libsodium-1.0.18-h27ca646_1.tar.bz2 + sha256: 1d95fe5e5e6a0700669aab454b2a32f97289c9ed8d1f7667c2ba98327a6f05bc + md5: 90859688dbca4735b74c02af14c4c793 + license: ISC + size: 324912 + timestamp: 1605135878892 +- kind: conda + name: libsodium + version: 1.0.18 + build: h36c2ea0_1 + build_number: 1 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/libsodium-1.0.18-h36c2ea0_1.tar.bz2 + sha256: 53da0c8b79659df7b53eebdb80783503ce72fb4b10ed6e9e05cc0e9e4207a130 + md5: c3788462a6fbddafdb413a9f9053e58d + depends: + - libgcc-ng >=7.5.0 + license: ISC + size: 374999 + timestamp: 1605135674116 +- kind: conda + name: libsodium + version: 1.0.18 + build: h8d14728_1 + build_number: 1 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/libsodium-1.0.18-h8d14728_1.tar.bz2 + sha256: ecc463f0ab6eaf6bc5bd6ff9c17f65595de6c7a38db812222ab8ffde0d3f4bc2 + md5: 5c1fb45b5e2912c19098750ae8a32604 + depends: + - vc >=14.1,<15.0a0 + - vs2015_runtime >=14.16.27012 + license: ISC + size: 713431 + timestamp: 1605135918736 +- kind: conda + name: libsodium + version: 1.0.18 + build: hb9de7d4_1 + build_number: 1 + subdir: linux-aarch64 + url: https://conda.anaconda.org/conda-forge/linux-aarch64/libsodium-1.0.18-hb9de7d4_1.tar.bz2 + sha256: 9ee442d889242c633bc3ce3f50ae89e6d8ebf12e04d943c371c0a56913fa069b + md5: d09ab3c60eebb6f14eb4d07e172775cc + depends: + - libgcc-ng >=7.5.0 + license: ISC + size: 237003 + timestamp: 1605135724993 +- kind: conda + name: libsodium + version: 1.0.18 + build: hbcb3906_1 + build_number: 1 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/libsodium-1.0.18-hbcb3906_1.tar.bz2 + sha256: 2da45f14e3d383b4b9e3a8bacc95cd2832aac2dbf9fbc70d255d384a310c5660 + md5: 24632c09ed931af617fe6d5292919cab + license: ISC + size: 528765 + timestamp: 1605135849110 +- kind: conda + name: libsqlite + version: 3.45.3 + build: h091b4b1_0 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/libsqlite-3.45.3-h091b4b1_0.conda + sha256: 4337f466eb55bbdc74e168b52ec8c38f598e3664244ec7a2536009036e2066cc + md5: c8c1186c7f3351f6ffddb97b1f54fc58 + depends: + - libzlib >=1.2.13,<2.0.0a0 + license: Unlicense + size: 824794 + timestamp: 1713367748819 +- kind: conda + name: libsqlite + version: 3.45.3 + build: h194ca79_0 + subdir: linux-aarch64 + url: https://conda.anaconda.org/conda-forge/linux-aarch64/libsqlite-3.45.3-h194ca79_0.conda + sha256: be87d8b67bdf892665c709d82c48011991fbf2fa15c19b006379b03ed494b070 + md5: fb35b8afbe9e92467ac7b5608d60b775 + depends: + - libgcc-ng >=12 + - libzlib >=1.2.13,<2.0.0a0 + license: Unlicense + size: 1036705 + timestamp: 1713367400740 +- kind: conda + name: libsqlite + version: 3.45.3 + build: h2797004_0 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/libsqlite-3.45.3-h2797004_0.conda + sha256: e2273d6860eadcf714a759ffb6dc24a69cfd01f2a0ea9d6c20f86049b9334e0c + md5: b3316cbe90249da4f8e84cd66e1cc55b + depends: + - libgcc-ng >=12 + - libzlib >=1.2.13,<2.0.0a0 + license: Unlicense + size: 859858 + timestamp: 1713367435849 +- kind: conda + name: libsqlite + version: 3.45.3 + build: h92b6c6a_0 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/libsqlite-3.45.3-h92b6c6a_0.conda + sha256: 4d44b68fb29dcbc2216a8cae0b274b02ef9b4ae05d1d0f785362ed30b91c9b52 + md5: 68e462226209f35182ef66eda0f794ff + depends: + - libzlib >=1.2.13,<2.0.0a0 + license: Unlicense + size: 902546 + timestamp: 1713367776445 +- kind: conda + name: libsqlite + version: 3.45.3 + build: hcfcfb64_0 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/libsqlite-3.45.3-hcfcfb64_0.conda + sha256: 06ec75faa51d7ec6d5db98889e869b579a9df19d7d3d9baff8359627da4a3b7e + md5: 73f5dc8e2d55d9a1e14b11f49c3b4a28 + depends: + - ucrt >=10.0.20348.0 + - vc >=14.2,<15 + - vc14_runtime >=14.29.30139 + license: Unlicense + size: 870518 + timestamp: 1713367888406 +- kind: conda + name: libstdcxx-ng + version: 13.2.0 + build: h3f4de04_7 + build_number: 7 + subdir: linux-aarch64 + url: https://conda.anaconda.org/conda-forge/linux-aarch64/libstdcxx-ng-13.2.0-h3f4de04_7.conda + sha256: ed58d37fde428858e0efa4022c758beb2ea5ae7be93ccfb548f95ef9b60c2ef5 + md5: 2a54872c7fab2db99b0074212d8efe64 + license: GPL-3.0-only WITH GCC-exception-3.1 + license_family: GPL + size: 3750765 + timestamp: 1715017787940 +- kind: conda + name: libstdcxx-ng + version: 13.2.0 + build: hc0a3c3a_7 + build_number: 7 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-ng-13.2.0-hc0a3c3a_7.conda + sha256: 35f1e08be0a84810c9075f5bd008495ac94e6c5fe306dfe4b34546f11fed850f + md5: 53ebd4c833fa01cb2c6353e99f905406 + license: GPL-3.0-only WITH GCC-exception-3.1 + license_family: GPL + size: 3837704 + timestamp: 1715016117360 +- kind: conda + name: libuuid + version: 2.38.1 + build: h0b41bf4_0 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/libuuid-2.38.1-h0b41bf4_0.conda + sha256: 787eb542f055a2b3de553614b25f09eefb0a0931b0c87dbcce6efdfd92f04f18 + md5: 40b61aab5c7ba9ff276c41cfffe6b80b + depends: + - libgcc-ng >=12 + license: BSD-3-Clause + license_family: BSD + size: 33601 + timestamp: 1680112270483 +- kind: conda + name: libuuid + version: 2.38.1 + build: hb4cce97_0 + subdir: linux-aarch64 + url: https://conda.anaconda.org/conda-forge/linux-aarch64/libuuid-2.38.1-hb4cce97_0.conda + sha256: 616277b0c5f7616c2cdf36f6c316ea3f9aa5bb35f2d4476a349ab58b9b91675f + md5: 000e30b09db0b7c775b21695dff30969 + depends: + - libgcc-ng >=12 + license: BSD-3-Clause + license_family: BSD + size: 35720 + timestamp: 1680113474501 +- kind: conda + name: libuv + version: 1.48.0 + build: h31becfc_0 + subdir: linux-aarch64 + url: https://conda.anaconda.org/conda-forge/linux-aarch64/libuv-1.48.0-h31becfc_0.conda + sha256: 8be03c6a43e17fdf574e2c29f1f8b917ba2842b5f4662b51d577960a3083fc2c + md5: 97f754b22f63a943345bd807e1d51e01 + depends: + - libgcc-ng >=12 + license: MIT + license_family: MIT + size: 635472 + timestamp: 1709913320273 +- kind: conda + name: libuv + version: 1.48.0 + build: h67532ce_0 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/libuv-1.48.0-h67532ce_0.conda + sha256: fb87f7bfd464a3a841d23f418c86a206818da0c4346984392071d9342c9ea367 + md5: c8e7344c74f0d86584f7ecdc9f25c198 + license: MIT + license_family: MIT + size: 407040 + timestamp: 1709913680478 +- kind: conda + name: libuv + version: 1.48.0 + build: h93a5062_0 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/libuv-1.48.0-h93a5062_0.conda + sha256: 60bed2a7a85096387ab0381cbc32ea2da7f8dd99bd90e440983019c0cdd96ad1 + md5: abfd49e80f13453b62a56be226120ea8 + license: MIT + license_family: MIT + size: 405988 + timestamp: 1709913494015 +- kind: conda + name: libuv + version: 1.48.0 + build: hd590300_0 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/libuv-1.48.0-hd590300_0.conda + sha256: b7c0e8a0c93c2621be7645b37123d4e8d27e8a974da26a3fba47a9c37711aa7f + md5: 7e8b914b1062dd4386e3de4d82a3ead6 + depends: + - libgcc-ng >=12 + license: MIT + license_family: MIT + size: 899979 + timestamp: 1709913354710 +- kind: conda + name: libxcrypt + version: 4.4.36 + build: h31becfc_1 + build_number: 1 + subdir: linux-aarch64 + url: https://conda.anaconda.org/conda-forge/linux-aarch64/libxcrypt-4.4.36-h31becfc_1.conda + sha256: 6b46c397644091b8a26a3048636d10b989b1bf266d4be5e9474bf763f828f41f + md5: b4df5d7d4b63579d081fd3a4cf99740e + depends: + - libgcc-ng >=12 + license: LGPL-2.1-or-later + size: 114269 + timestamp: 1702724369203 +- kind: conda + name: libxcrypt + version: 4.4.36 + build: hd590300_1 + build_number: 1 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/libxcrypt-4.4.36-hd590300_1.conda + sha256: 6ae68e0b86423ef188196fff6207ed0c8195dd84273cb5623b85aa08033a410c + md5: 5aa797f8787fe7a17d1b0821485b5adc + depends: + - libgcc-ng >=12 + license: LGPL-2.1-or-later + size: 100393 + timestamp: 1702724383534 +- kind: conda + name: libxml2 + version: 2.12.7 + build: h283a6d9_1 + build_number: 1 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/libxml2-2.12.7-h283a6d9_1.conda + sha256: aef096aa784e61f860fab08974c6260836bf05d742fb69f304f0e9b7d557c99a + md5: 7ab2653cc21c44a1370ef3b409261b3d + depends: + - libiconv >=1.17,<2.0a0 + - libzlib >=1.2.13,<2.0a0 + - ucrt >=10.0.20348.0 + - vc >=14.2,<15 + - vc14_runtime >=14.29.30139 + license: MIT + license_family: MIT + size: 1709896 + timestamp: 1717547244225 +- kind: conda + name: libzlib + version: 1.3.1 + build: h2466b09_1 + build_number: 1 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/libzlib-1.3.1-h2466b09_1.conda + sha256: b13846a54a15243e15f96fec06b526d8155adc6a1ac2b6ed47a88f6a71a94b68 + md5: d4483ca8afc57ddf1f6dded53b36c17f + depends: + - ucrt >=10.0.20348.0 + - vc >=14.2,<15 + - vc14_runtime >=14.29.30139 + constrains: + - zlib 1.3.1 *_1 + license: Zlib + license_family: Other + size: 56186 + timestamp: 1716874730539 +- kind: conda + name: libzlib + version: 1.3.1 + build: h4ab18f5_1 + build_number: 1 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/libzlib-1.3.1-h4ab18f5_1.conda + sha256: adf6096f98b537a11ae3729eaa642b0811478f0ea0402ca67b5108fe2cb0010d + md5: 57d7dc60e9325e3de37ff8dffd18e814 + depends: + - libgcc-ng >=12 + constrains: + - zlib 1.3.1 *_1 + license: Zlib + license_family: Other + size: 61574 + timestamp: 1716874187109 +- kind: conda + name: libzlib + version: 1.3.1 + build: h68df207_1 + build_number: 1 + subdir: linux-aarch64 + url: https://conda.anaconda.org/conda-forge/linux-aarch64/libzlib-1.3.1-h68df207_1.conda + sha256: 0d6dfd1e36e10c205ff1fdcf42d42289ff0f50be7a4eaa7b34f086a5e22a0734 + md5: b13fb82f88902e34dd0638cd7d378c21 + depends: + - libgcc-ng >=12 + constrains: + - zlib 1.3.1 *_1 + license: Zlib + license_family: Other + size: 67199 + timestamp: 1716874136348 +- kind: conda + name: libzlib + version: 1.3.1 + build: h87427d6_1 + build_number: 1 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/libzlib-1.3.1-h87427d6_1.conda + sha256: 80a62db652b1da0ccc100812a1d86e94f75028968991bfb17f9536f3aa72d91d + md5: b7575b5aa92108dcc9aaab0f05f2dbce + depends: + - __osx >=10.13 + constrains: + - zlib 1.3.1 *_1 + license: Zlib + license_family: Other + size: 57372 + timestamp: 1716874211519 +- kind: conda + name: libzlib + version: 1.3.1 + build: hfb2fe0b_1 + build_number: 1 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/libzlib-1.3.1-hfb2fe0b_1.conda + sha256: c34365dd37b0eab27b9693af32a1f7f284955517c2cc91f1b88a7ef4738ff03e + md5: 636077128927cf79fd933276dc3aed47 + depends: + - __osx >=11.0 + constrains: + - zlib 1.3.1 *_1 + license: Zlib + license_family: Other + size: 46921 + timestamp: 1716874262512 +- kind: conda + name: llvm-openmp + version: 18.1.7 + build: h15ab845_0 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/llvm-openmp-18.1.7-h15ab845_0.conda + sha256: 66ab0feed5ed7ace0d9327bc7ae47500afb81ef51e6ef10a478af9d65dd60ac6 + md5: 57440310d92e93efd808c75fec50f94d + depends: + - __osx >=10.13 + constrains: + - openmp 18.1.7|18.1.7.* + license: Apache-2.0 WITH LLVM-exception + license_family: APACHE + size: 300573 + timestamp: 1717851511113 +- kind: conda + name: llvm-openmp + version: 18.1.7 + build: hde57baf_0 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/llvm-openmp-18.1.7-hde57baf_0.conda + sha256: 30121bc3ebf134d69bcb24ab1270bfa2beeb0ae59579b8acb67a38e3531c05d1 + md5: 2f651f8977594cc74852fa280785187a + depends: + - __osx >=11.0 + constrains: + - openmp 18.1.7|18.1.7.* + license: Apache-2.0 WITH LLVM-exception + license_family: APACHE + size: 276533 + timestamp: 1717851681081 +- kind: conda + name: m2w64-gcc-libgfortran + version: 5.3.0 + build: '6' + build_number: 6 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/m2w64-gcc-libgfortran-5.3.0-6.tar.bz2 + sha256: 9de95a7996d5366ae0808eef2acbc63f9b11b874aa42375f55379e6715845dc6 + md5: 066552ac6b907ec6d72c0ddab29050dc + depends: + - m2w64-gcc-libs-core + - msys2-conda-epoch ==20160418 + license: GPL, LGPL, FDL, custom + size: 350687 + timestamp: 1608163451316 +- kind: conda + name: m2w64-gcc-libs + version: 5.3.0 + build: '7' + build_number: 7 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/m2w64-gcc-libs-5.3.0-7.tar.bz2 + sha256: 3bd1ab02b7c89a5b153a17be03b36d833f1517ff2a6a77ead7c4a808b88196aa + md5: fe759119b8b3bfa720b8762c6fdc35de + depends: + - m2w64-gcc-libgfortran + - m2w64-gcc-libs-core + - m2w64-gmp + - m2w64-libwinpthread-git + - msys2-conda-epoch ==20160418 + license: GPL3+, partial:GCCRLE, partial:LGPL2+ + size: 532390 + timestamp: 1608163512830 +- kind: conda + name: m2w64-gcc-libs-core + version: 5.3.0 + build: '7' + build_number: 7 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/m2w64-gcc-libs-core-5.3.0-7.tar.bz2 + sha256: 58afdfe859ed2e9a9b1cc06bc408720cb2c3a6a132e59d4805b090d7574f4ee0 + md5: 4289d80fb4d272f1f3b56cfe87ac90bd + depends: + - m2w64-gmp + - m2w64-libwinpthread-git + - msys2-conda-epoch ==20160418 + license: GPL3+, partial:GCCRLE, partial:LGPL2+ + size: 219240 + timestamp: 1608163481341 +- kind: conda + name: m2w64-gmp + version: 6.1.0 + build: '2' + build_number: 2 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/m2w64-gmp-6.1.0-2.tar.bz2 + sha256: 7e3cd95f554660de45f8323fca359e904e8d203efaf07a4d311e46d611481ed1 + md5: 53a1c73e1e3d185516d7e3af177596d9 + depends: + - msys2-conda-epoch ==20160418 + license: LGPL3 + size: 743501 + timestamp: 1608163782057 +- kind: conda + name: m2w64-libwinpthread-git + version: 5.0.0.4634.697f757 + build: '2' + build_number: 2 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/m2w64-libwinpthread-git-5.0.0.4634.697f757-2.tar.bz2 + sha256: f63a09b2cae7defae0480f1740015d6235f1861afa6fe2e2d3e10bd0d1314ee0 + md5: 774130a326dee16f1ceb05cc687ee4f0 + depends: + - msys2-conda-epoch ==20160418 + license: MIT, BSD + size: 31928 + timestamp: 1608166099896 +- kind: conda + name: make + version: '4.3' + build: h22f3db7_1 + build_number: 1 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/make-4.3-h22f3db7_1.tar.bz2 + sha256: adef15126b518548b69ecaef24e22f88fa0a6358bd3c11e791af214f7344983b + md5: ac4a1dd58e6d821c518ae0011e8592b7 + license: GPL-3.0-or-later + license_family: GPL + size: 255465 + timestamp: 1602706542653 +- kind: conda + name: make + version: '4.3' + build: h309ac5b_1 + build_number: 1 + subdir: linux-aarch64 + url: https://conda.anaconda.org/conda-forge/linux-aarch64/make-4.3-h309ac5b_1.tar.bz2 + sha256: 771e7a32a555693a0d53d3f682ed9dc1139abe99937cba55b16400ae8b8a92d4 + md5: 0f876fc705b573cf9972bcbeb93864d9 + depends: + - libgcc-ng >=7.5.0 + license: GPL-3.0-or-later + license_family: GPL + size: 497104 + timestamp: 1602706670853 +- kind: conda + name: make + version: '4.3' + build: h3d2af85_1 + build_number: 1 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/make-4.3-h3d2af85_1.tar.bz2 + sha256: f31b00c710df71f2f75c641272ecb1f9bd1e15a5a77510055120641215487fbb + md5: c3be283d3d278c379b50137a2a17f869 + depends: + - m2w64-gcc-libs + license: GPL-3.0-or-later + license_family: GPL + size: 6245358 + timestamp: 1602706995515 +- kind: conda + name: make + version: '4.3' + build: hd18ef5c_1 + build_number: 1 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/make-4.3-hd18ef5c_1.tar.bz2 + sha256: 4a5fe7c80bb0de0015328e2d3fc8db1736f528cb1fd53cd0d5527e24269a4f7c + md5: 4049ebfd3190b580dffe76daed26155a + depends: + - libgcc-ng >=7.5.0 + license: GPL-3.0-or-later + license_family: GPL + size: 518896 + timestamp: 1602706451788 +- kind: conda + name: make + version: '4.3' + build: he57ea6c_1 + build_number: 1 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/make-4.3-he57ea6c_1.tar.bz2 + sha256: a011e3e1c4caec821eb4213d0a0154d39e5f81a44d2e8bafe6f84e7840c3909e + md5: 1939d04ef89e38fde652ee8c669e092f + license: GPL-3.0-or-later + license_family: GPL + size: 253227 + timestamp: 1602706492919 +- kind: conda + name: markupsafe + version: 2.1.5 + build: py310h2372a71_0 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/markupsafe-2.1.5-py310h2372a71_0.conda + sha256: 3c18347adf1d091ee9248612308a6bef79038f80b626ef67f58cd0e8d25c65b8 + md5: f6703fa0214a00bf49d1bef6dc7672d0 + depends: + - libgcc-ng >=12 + - python >=3.10,<3.11.0a0 + - python_abi 3.10.* *_cp310 + constrains: + - jinja2 >=3.0.0 + license: BSD-3-Clause + license_family: BSD + size: 24493 + timestamp: 1706900070478 +- kind: conda + name: markupsafe + version: 2.1.5 + build: py310h7c1f4a2_0 + subdir: linux-aarch64 + url: https://conda.anaconda.org/conda-forge/linux-aarch64/markupsafe-2.1.5-py310h7c1f4a2_0.conda + sha256: cb6f0045f1b0de02a02db296ca4aec1dec67287ac40785d5a3dd8ef21cca684f + md5: cd83a00c52970ab794e9e991f0b32db4 + depends: + - libgcc-ng >=12 + - python >=3.10,<3.11.0a0 + - python_abi 3.10.* *_cp310 + constrains: + - jinja2 >=3.0.0 + license: BSD-3-Clause + license_family: BSD + size: 25008 + timestamp: 1706902296399 +- kind: conda + name: markupsafe + version: 2.1.5 + build: py310h8d17308_0 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/markupsafe-2.1.5-py310h8d17308_0.conda + sha256: 2fe1bc52085b4b4f63e073803f8cce3da95b6eaaa182abee11c0a34b484f99dc + md5: eceba0306d8619bd34a650e673d3e6c3 + depends: + - python >=3.10,<3.11.0a0 + - python_abi 3.10.* *_cp310 + - ucrt >=10.0.20348.0 + - vc >=14.2,<15 + - vc14_runtime >=14.29.30139 + constrains: + - jinja2 >=3.0.0 + license: BSD-3-Clause + license_family: BSD + size: 26862 + timestamp: 1706900665420 +- kind: conda + name: markupsafe + version: 2.1.5 + build: py310hb372a2b_0 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/markupsafe-2.1.5-py310hb372a2b_0.conda + sha256: b4a3bdb4053bb990296cda261de6d1b095a2e006bf91c8b601019462dc43d7d8 + md5: fc49c4222ce625c835a5e3ce1fbfc503 + depends: + - python >=3.10,<3.11.0a0 + - python_abi 3.10.* *_cp310 + constrains: + - jinja2 >=3.0.0 + license: BSD-3-Clause + license_family: BSD + size: 23106 + timestamp: 1706900206202 +- kind: conda + name: markupsafe + version: 2.1.5 + build: py310hd125d64_0 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/markupsafe-2.1.5-py310hd125d64_0.conda + sha256: 75a43d7901fadee332b2175c71ba8df0e57ac0d0b2a7c52a10ad0d681cf1dc5a + md5: 29a6f644679ed1e2b94fc20c7e3dcc2d + depends: + - python >=3.10,<3.11.0a0 + - python >=3.10,<3.11.0a0 *_cpython + - python_abi 3.10.* *_cp310 + constrains: + - jinja2 >=3.0.0 + license: BSD-3-Clause + license_family: BSD + size: 23919 + timestamp: 1706900392293 +- kind: conda + name: mistune + version: 3.0.2 + build: pyhd8ed1ab_0 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/mistune-3.0.2-pyhd8ed1ab_0.conda + sha256: f95cb70007e3cc2ba44e17c29a056b499e6dadf08746706d0c817c8e2f47e05c + md5: 5cbee699846772cc939bef23a0d524ed + depends: + - python >=3.7 + license: BSD-3-Clause + license_family: BSD + size: 66022 + timestamp: 1698947249750 +- kind: conda + name: mkl + version: 2024.1.0 + build: h66d3029_692 + build_number: 692 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/mkl-2024.1.0-h66d3029_692.conda + sha256: abfdb5eb3a17af59a827ea49fcb4d2bf18e70b62498bf3720351962e636cb5b7 + md5: b43ec7ed045323edeff31e348eea8652 + depends: + - intel-openmp 2024.* + - tbb 2021.* + license: LicenseRef-ProprietaryIntel + license_family: Proprietary + size: 109491063 + timestamp: 1712153746272 +- kind: conda + name: mpc + version: 1.3.1 + build: h81bd1dd_0 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/mpc-1.3.1-h81bd1dd_0.conda + sha256: 2ae945a15c8a984d581dcfb974ad3b5d877a6527de2c95a3363e6b4490b2f312 + md5: c752c0eb6c250919559172c011e5f65b + depends: + - gmp >=6.2.1,<7.0a0 + - mpfr >=4.1.0,<5.0a0 + license: LGPL-3.0-or-later + license_family: LGPL + size: 109064 + timestamp: 1674264109148 +- kind: conda + name: mpc + version: 1.3.1 + build: h91ba8db_0 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/mpc-1.3.1-h91ba8db_0.conda + sha256: 6d8d4f8befca279f022c1c212241ad6672cb347181452555414e277484ad534c + md5: 362af269d860ae49580f8f032a68b0df + depends: + - gmp >=6.2.1,<7.0a0 + - mpfr >=4.1.0,<5.0a0 + license: LGPL-3.0-or-later + license_family: LGPL + size: 103657 + timestamp: 1674264097592 +- kind: conda + name: mpc + version: 1.3.1 + build: hf4c8f4c_0 + subdir: linux-aarch64 + url: https://conda.anaconda.org/conda-forge/linux-aarch64/mpc-1.3.1-hf4c8f4c_0.conda + sha256: 970e7e4a0b9e027189ba83f5829f4e062ec473c5fc47759b6d412429a2fa78b0 + md5: 12c6ffaf337910c2d5743530baa313ab + depends: + - gmp >=6.2.1,<7.0a0 + - libgcc-ng >=12 + - mpfr >=4.1.0,<5.0a0 + license: LGPL-3.0-or-later + license_family: LGPL + size: 129862 + timestamp: 1674263879163 +- kind: conda + name: mpc + version: 1.3.1 + build: hfe3b2da_0 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/mpc-1.3.1-hfe3b2da_0.conda + sha256: 2f88965949ba7b4b21e7e5facd62285f7c6efdb17359d1b365c3bb4ecc968d29 + md5: 289c71e83dc0daa7d4c81f04180778ca + depends: + - gmp >=6.2.1,<7.0a0 + - libgcc-ng >=12 + - mpfr >=4.1.0,<5.0a0 + license: LGPL-3.0-or-later + license_family: LGPL + size: 116276 + timestamp: 1674263855481 +- kind: conda + name: mpfr + version: 4.2.1 + build: h41d338b_1 + build_number: 1 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/mpfr-4.2.1-h41d338b_1.conda + sha256: a0b183cdf8bd1f2462d965f7a065cbfc32669d95bb6c8f970f7c7f63d2938436 + md5: 616d9bb6983991de582589b9a06e4cea + depends: + - gmp >=6.3.0,<7.0a0 + license: LGPL-3.0-only + license_family: LGPL + size: 346880 + timestamp: 1712339687453 +- kind: conda + name: mpfr + version: 4.2.1 + build: h4f6b447_1 + build_number: 1 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/mpfr-4.2.1-h4f6b447_1.conda + sha256: 002209e7d1f21cdd04de17050ab2050de4347e5bf04210ce6a636cbabf43e1d0 + md5: b90df08f0deb2f58631447c1462c92a7 + depends: + - gmp >=6.3.0,<7.0a0 + license: LGPL-3.0-only + license_family: LGPL + size: 373442 + timestamp: 1712339833358 +- kind: conda + name: mpfr + version: 4.2.1 + build: h9458935_1 + build_number: 1 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/mpfr-4.2.1-h9458935_1.conda + sha256: 38c501f6b8dff124e57711c01da23e204703a3c14276f4cf6abd28850b2b9893 + md5: 8083b20f566639c22f78bcd6ca35b276 + depends: + - gmp >=6.3.0,<7.0a0 + - libgcc-ng >=12 + license: LGPL-3.0-only + license_family: LGPL + size: 643060 + timestamp: 1712339500544 +- kind: conda + name: mpfr + version: 4.2.1 + build: ha2d0fc4_1 + build_number: 1 + subdir: linux-aarch64 + url: https://conda.anaconda.org/conda-forge/linux-aarch64/mpfr-4.2.1-ha2d0fc4_1.conda + sha256: 0d94d90405fd8d07d8d0e9a6d8d9e0eb1264dcd07c1820f0d061bf9e6bff296b + md5: c32a22a0daa21b7c4bc919a51c824d91 + depends: + - gmp >=6.3.0,<7.0a0 + - libgcc-ng >=12 + license: LGPL-3.0-only + license_family: LGPL + size: 427513 + timestamp: 1712339453106 +- kind: conda + name: mpmath + version: 1.3.0 + build: pyhd8ed1ab_0 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/mpmath-1.3.0-pyhd8ed1ab_0.conda + sha256: a4f025c712ec1502a55c471b56a640eaeebfce38dd497d5a1a33729014cac47a + md5: dbf6e2d89137da32fa6670f3bffc024e + depends: + - python >=3.6 + license: BSD-3-Clause + license_family: BSD + size: 438339 + timestamp: 1678228210181 +- kind: conda + name: msgpack-python + version: 1.0.8 + build: py310h25c7140_0 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/msgpack-python-1.0.8-py310h25c7140_0.conda + sha256: d7de996a5188f89b149fcfad848968c279c05f291801a28b10ae758e7355cc44 + md5: ad681a3290620ca6196bcd46ed3101cd + depends: + - libgcc-ng >=12 + - libstdcxx-ng >=12 + - python >=3.10,<3.11.0a0 + - python_abi 3.10.* *_cp310 + license: Apache-2.0 + license_family: Apache + size: 96849 + timestamp: 1715670779124 +- kind: conda + name: msgpack-python + version: 1.0.8 + build: py310h5334dd0_0 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/msgpack-python-1.0.8-py310h5334dd0_0.conda + sha256: dd095010d1b0392e3090ef99258fdff94c12e7cf81db5624ea1dc8803862eec9 + md5: 1ffe12f2799b78708e07ef810c304933 + depends: + - __osx >=10.13 + - libcxx >=16 + - python >=3.10,<3.11.0a0 + - python_abi 3.10.* *_cp310 + license: Apache-2.0 + license_family: Apache + size: 85969 + timestamp: 1715670941626 +- kind: conda + name: msgpack-python + version: 1.0.8 + build: py310h6cd5c4a_0 + subdir: linux-aarch64 + url: https://conda.anaconda.org/conda-forge/linux-aarch64/msgpack-python-1.0.8-py310h6cd5c4a_0.conda + sha256: 495bac7e2f91439d0beb1921d6d5ded63fd4a965118cc430cae7ddfb998b4fbd + md5: afe2537307d96a044524e8a71a5eec35 + depends: + - libgcc-ng >=12 + - libstdcxx-ng >=12 + - python >=3.10,<3.11.0a0 + - python >=3.10,<3.11.0a0 *_cpython + - python_abi 3.10.* *_cp310 + license: Apache-2.0 + license_family: Apache + size: 95043 + timestamp: 1715670863527 +- kind: conda + name: msgpack-python + version: 1.0.8 + build: py310hc19bc0b_0 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/msgpack-python-1.0.8-py310hc19bc0b_0.conda + sha256: f880861554e8dc98dec30ae039bcd8d491ce1b411a01e5b1e50270840eb57a8d + md5: f1188194dd35d19b490d8d13f6380f19 + depends: + - python >=3.10,<3.11.0a0 + - python_abi 3.10.* *_cp310 + - ucrt >=10.0.20348.0 + - vc >=14.2,<15 + - vc14_runtime >=14.29.30139 + license: Apache-2.0 + license_family: Apache + size: 83204 + timestamp: 1715671168114 +- kind: conda + name: msgpack-python + version: 1.0.8 + build: py310he1a186f_0 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/msgpack-python-1.0.8-py310he1a186f_0.conda + sha256: c92d58b80407ee9cc5059f311a06cf9ae0e23f557494126b973b706f9f690a5a + md5: 447a2f56f927d93c23989d1355d48a79 + depends: + - __osx >=11.0 + - libcxx >=16 + - python >=3.10,<3.11.0a0 + - python >=3.10,<3.11.0a0 *_cpython + - python_abi 3.10.* *_cp310 + license: Apache-2.0 + license_family: Apache + size: 86032 + timestamp: 1715670916277 +- kind: conda + name: msys2-conda-epoch + version: '20160418' + build: '1' + build_number: 1 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/msys2-conda-epoch-20160418-1.tar.bz2 + sha256: 99358d58d778abee4dca82ad29fb58058571f19b0f86138363c260049d4ac7f1 + md5: b0309b72560df66f71a9d5e34a5efdfa + size: 3227 + timestamp: 1608166968312 +- kind: conda + name: mypy + version: 1.10.0 + build: py310h74a5a53_0 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/mypy-1.10.0-py310h74a5a53_0.conda + sha256: b9067f0eb37985417c406ab80b5fae56ef7498e74dd4c393a950569f186aa1ae + md5: 85eda58ca98381d3b4c510bf05dc8016 + depends: + - __osx >=10.9 + - mypy_extensions >=1.0.0 + - psutil >=4.0 + - python >=3.10,<3.11.0a0 + - python_abi 3.10.* *_cp310 + - tomli >=1.1.0 + - typing_extensions >=4.1.0 + license: MIT + license_family: MIT + size: 11521107 + timestamp: 1714003064118 +- kind: conda + name: mypy + version: 1.10.0 + build: py310h8431ef1_0 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/mypy-1.10.0-py310h8431ef1_0.conda + sha256: 3a2205938a71495af49b3ca28e0c07f92cc9293c14be7cda035a25a3cc0af570 + md5: ef07d1d34676094de18e16563b8e962d + depends: + - __osx >=11.0 + - mypy_extensions >=1.0.0 + - psutil >=4.0 + - python >=3.10,<3.11.0a0 + - python >=3.10,<3.11.0a0 *_cpython + - python_abi 3.10.* *_cp310 + - tomli >=1.1.0 + - typing_extensions >=4.1.0 + license: MIT + license_family: MIT + size: 9078497 + timestamp: 1714003151264 +- kind: conda + name: mypy + version: 1.10.0 + build: py310ha8f682b_0 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/mypy-1.10.0-py310ha8f682b_0.conda + sha256: e879be045d16848287c313632920a47dc61848f31d55de43bd2c6bf837cb209c + md5: 31a2442ffdbf74fb863e35d53be09d57 + depends: + - mypy_extensions >=1.0.0 + - psutil >=4.0 + - python >=3.10,<3.11.0a0 + - python_abi 3.10.* *_cp310 + - tomli >=1.1.0 + - typing_extensions >=4.1.0 + - ucrt >=10.0.20348.0 + - vc >=14.2,<15 + - vc14_runtime >=14.29.30139 + license: MIT + license_family: MIT + size: 9424000 + timestamp: 1714002314904 +- kind: conda + name: mypy + version: 1.10.0 + build: py310hb52b2da_0 + subdir: linux-aarch64 + url: https://conda.anaconda.org/conda-forge/linux-aarch64/mypy-1.10.0-py310hb52b2da_0.conda + sha256: 4ea97db062a156cd9eadbe2caad3f8d3fc7ff10ba262e2f93740dc2522cf9fd6 + md5: 249fd28425236bedef62c3afa2c03513 + depends: + - libgcc-ng >=12 + - mypy_extensions >=1.0.0 + - psutil >=4.0 + - python >=3.10,<3.11.0a0 + - python >=3.10,<3.11.0a0 *_cpython + - python_abi 3.10.* *_cp310 + - tomli >=1.1.0 + - typing_extensions >=4.1.0 + license: MIT + license_family: MIT + size: 14695653 + timestamp: 1714002637578 +- kind: conda + name: mypy + version: 1.10.0 + build: py310hc51659f_0 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/mypy-1.10.0-py310hc51659f_0.conda + sha256: 144d9bafa3383936e7130bf8c2ec0fecf15511d521355c8b4964f9b2db594060 + md5: 0a5690e4aa1e515330d289966190c5b8 + depends: + - libgcc-ng >=12 + - mypy_extensions >=1.0.0 + - psutil >=4.0 + - python >=3.10,<3.11.0a0 + - python_abi 3.10.* *_cp310 + - tomli >=1.1.0 + - typing_extensions >=4.1.0 + license: MIT + license_family: MIT + size: 17412997 + timestamp: 1714002067856 +- kind: conda + name: mypy + version: 1.10.0 + build: py311h331c9d8_0 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/mypy-1.10.0-py311h331c9d8_0.conda + sha256: 08698ecb8bba455fcd05f8b002bb18c22b0828dc6f15c4be00ba2dab5e8271dc + md5: fe352f306f60a49679773f07759eab09 + depends: + - libgcc-ng >=12 + - mypy_extensions >=1.0.0 + - psutil >=4.0 + - python >=3.11,<3.12.0a0 + - python_abi 3.11.* *_cp311 + - typing_extensions >=4.1.0 + license: MIT + license_family: MIT + size: 17933953 + timestamp: 1714002240182 +- kind: conda + name: mypy + version: 1.10.0 + build: py311h39126ff_0 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/mypy-1.10.0-py311h39126ff_0.conda + sha256: 18538ea125edaa7e92c716a174982a49a9f245f23357bd6b555fea37b0070bee + md5: 45b0ce62823d7f5f4058e7e4889e78f1 + depends: + - __osx >=10.9 + - mypy_extensions >=1.0.0 + - psutil >=4.0 + - python >=3.11,<3.12.0a0 + - python_abi 3.11.* *_cp311 + - typing_extensions >=4.1.0 + license: MIT + license_family: MIT + size: 12163996 + timestamp: 1714002725551 +- kind: conda + name: mypy + version: 1.10.0 + build: py311hd23d018_0 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/mypy-1.10.0-py311hd23d018_0.conda + sha256: 395b4e24f91e24a78662ae681bd63253e33efa38da246ae58d63dda382c85728 + md5: 11672316ba5c128d873559d167d8ce8a + depends: + - __osx >=11.0 + - mypy_extensions >=1.0.0 + - psutil >=4.0 + - python >=3.11,<3.12.0a0 + - python >=3.11,<3.12.0a0 *_cpython + - python_abi 3.11.* *_cp311 + - typing_extensions >=4.1.0 + license: MIT + license_family: MIT + size: 9788454 + timestamp: 1714002801679 +- kind: conda + name: mypy + version: 1.10.0 + build: py311he736701_0 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/mypy-1.10.0-py311he736701_0.conda + sha256: dec60a480d1ec85bb1a530a3625b1a1afa676ca14c213eaa7e8d7a70d4d8dfa4 + md5: 4be5be08e3b977f3f60e3864d20d3943 + depends: + - mypy_extensions >=1.0.0 + - psutil >=4.0 + - python >=3.11,<3.12.0a0 + - python_abi 3.11.* *_cp311 + - typing_extensions >=4.1.0 + - ucrt >=10.0.20348.0 + - vc >=14.2,<15 + - vc14_runtime >=14.29.30139 + license: MIT + license_family: MIT + size: 10128737 + timestamp: 1714002375825 +- kind: conda + name: mypy + version: 1.10.0 + build: py311hf4892ed_0 + subdir: linux-aarch64 + url: https://conda.anaconda.org/conda-forge/linux-aarch64/mypy-1.10.0-py311hf4892ed_0.conda + sha256: 0500313b9ab2cfc68cebc2784b76969f71cc07c6808af5e15fe82e61b0a33130 + md5: 3fc375cbe593893bf626518343143a7a + depends: + - libgcc-ng >=12 + - mypy_extensions >=1.0.0 + - psutil >=4.0 + - python >=3.11,<3.12.0a0 + - python >=3.11,<3.12.0a0 *_cpython + - python_abi 3.11.* *_cp311 + - typing_extensions >=4.1.0 + license: MIT + license_family: MIT + size: 15284111 + timestamp: 1714002625542 +- kind: conda + name: mypy + version: 1.10.0 + build: py312h396f95a_0 + subdir: linux-aarch64 + url: https://conda.anaconda.org/conda-forge/linux-aarch64/mypy-1.10.0-py312h396f95a_0.conda + sha256: 2ddcff3817b2e96bcc22b9da312b246b5932f2b1ea5d6d7a9390c876aaf3747e + md5: c0586acc6ed5864bfbeb015d9554659e + depends: + - libgcc-ng >=12 + - mypy_extensions >=1.0.0 + - psutil >=4.0 + - python >=3.12,<3.13.0a0 + - python >=3.12,<3.13.0a0 *_cpython + - python_abi 3.12.* *_cp312 + - typing_extensions >=4.1.0 + license: MIT + license_family: MIT + size: 15461991 + timestamp: 1714002287106 +- kind: conda + name: mypy + version: 1.10.0 + build: py312h4389bb4_0 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/mypy-1.10.0-py312h4389bb4_0.conda + sha256: ebcbd3487698e9e4356dbf7a94eb3bb582c5421098862bc6d9fd8887a6949fb7 + md5: 31efeca32ad254e43198a0ce37156ce6 + depends: + - mypy_extensions >=1.0.0 + - psutil >=4.0 + - python >=3.12,<3.13.0a0 + - python_abi 3.12.* *_cp312 + - typing_extensions >=4.1.0 + - ucrt >=10.0.20348.0 + - vc >=14.2,<15 + - vc14_runtime >=14.29.30139 + license: MIT + license_family: MIT + size: 8388614 + timestamp: 1714002079609 +- kind: conda + name: mypy + version: 1.10.0 + build: py312h4a164c9_0 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/mypy-1.10.0-py312h4a164c9_0.conda + sha256: 3d6f618f8c366ff766686a36467c81068f2583696a23f63366641a50f2133082 + md5: 35bf371fb16eed1be04831c597f91870 + depends: + - __osx >=11.0 + - mypy_extensions >=1.0.0 + - psutil >=4.0 + - python >=3.12,<3.13.0a0 + - python >=3.12,<3.13.0a0 *_cpython + - python_abi 3.12.* *_cp312 + - typing_extensions >=4.1.0 + license: MIT + license_family: MIT + size: 9636672 + timestamp: 1714003119958 +- kind: conda + name: mypy + version: 1.10.0 + build: py312h5fa3f64_0 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/mypy-1.10.0-py312h5fa3f64_0.conda + sha256: e8a0e4be2df67f3e784839baa9df1b6c5a30077305586d3584c847c21a5a4f03 + md5: cfd2bcbfa59fc80f372fdb13b51dd3a2 + depends: + - __osx >=10.9 + - mypy_extensions >=1.0.0 + - psutil >=4.0 + - python >=3.12,<3.13.0a0 + - python_abi 3.12.* *_cp312 + - typing_extensions >=4.1.0 + license: MIT + license_family: MIT + size: 10339160 + timestamp: 1714002937960 +- kind: conda + name: mypy + version: 1.10.0 + build: py312h9a8786e_0 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/mypy-1.10.0-py312h9a8786e_0.conda + sha256: 202a1223ab7b6d78a553a8a6768a0088166f482e48b736afd2c6a6d65f466b99 + md5: 644f1c538810d1f250ef0fc844f3822d + depends: + - libgcc-ng >=12 + - mypy_extensions >=1.0.0 + - psutil >=4.0 + - python >=3.12,<3.13.0a0 + - python_abi 3.12.* *_cp312 + - typing_extensions >=4.1.0 + license: MIT + license_family: MIT + size: 16580238 + timestamp: 1714002375040 +- kind: conda + name: mypy_extensions + version: 1.0.0 + build: pyha770c72_0 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/mypy_extensions-1.0.0-pyha770c72_0.conda + sha256: f240217476e148e825420c6bc3a0c0efb08c0718b7042fae960400c02af858a3 + md5: 4eccaeba205f0aed9ac3a9ea58568ca3 + depends: + - python >=3.5 + license: MIT + license_family: MIT + size: 10492 + timestamp: 1675543414256 +- kind: conda + name: natsort + version: 8.4.0 + build: pyhd8ed1ab_0 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/natsort-8.4.0-pyhd8ed1ab_0.conda + sha256: 1d5c42c7f271779e450d095c49598ce7214a7089f229e59f0b78d8703de67059 + md5: 70959cd1db3cf77b2a27a0836cfd08a7 + depends: + - python >=3.7 + license: MIT + license_family: MIT + size: 37338 + timestamp: 1687263265777 +- kind: conda + name: nbclient + version: 0.10.0 + build: pyhd8ed1ab_0 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/nbclient-0.10.0-pyhd8ed1ab_0.conda + sha256: 589d72d36d61a23b39d6fff2c488f93e29e20de4fc6f5d315b5f2c16e81028bf + md5: 15b51397e0fe8ea7d7da60d83eb76ebc + depends: + - jupyter_client >=6.1.12 + - jupyter_core >=4.12,!=5.0.* + - nbformat >=5.1 + - python >=3.8 + - traitlets >=5.4 + license: BSD-3-Clause + license_family: BSD + size: 27851 + timestamp: 1710317767117 +- kind: conda + name: nbconvert + version: 7.16.4 + build: hd8ed1ab_0 + subdir: noarch + noarch: generic + url: https://conda.anaconda.org/conda-forge/noarch/nbconvert-7.16.4-hd8ed1ab_0.conda + sha256: 7a4a759b8930833cbfffbfd92da069f1d3fd43760ea629c8612b9e7ae9fff0e8 + md5: c9d64b8a7ee8e6bdbf0e7d8aa7f39601 + depends: + - nbconvert-core 7.16.4 pyhd8ed1ab_0 + - nbconvert-pandoc 7.16.4 hd8ed1ab_0 + license: BSD-3-Clause + license_family: BSD + size: 8434 + timestamp: 1714477296945 +- kind: conda + name: nbconvert-core + version: 7.16.4 + build: pyhd8ed1ab_0 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/nbconvert-core-7.16.4-pyhd8ed1ab_0.conda + sha256: aa5bf61e42c63cec2b2c33e66cd0bb064846d62dd60f6ac62ae0d2bf17583900 + md5: 43d9cd74e3950ab09cbddf36f1706b9f + depends: + - beautifulsoup4 + - bleach + - defusedxml + - entrypoints >=0.2.2 + - jinja2 >=3.0 + - jupyter_core >=4.7 + - jupyterlab_pygments + - markupsafe >=2.0 + - mistune >=2.0.3,<4 + - nbclient >=0.5.0 + - nbformat >=5.1 + - packaging + - pandocfilters >=1.4.1 + - pygments >=2.4.1 + - python >=3.8 + - tinycss2 + - traitlets >=5.0 + constrains: + - pandoc >=2.9.2,<4.0.0 + - nbconvert =7.16.4=*_0 + license: BSD-3-Clause + license_family: BSD + size: 189004 + timestamp: 1714477286178 +- kind: conda + name: nbconvert-pandoc + version: 7.16.4 + build: hd8ed1ab_0 + subdir: noarch + noarch: generic + url: https://conda.anaconda.org/conda-forge/noarch/nbconvert-pandoc-7.16.4-hd8ed1ab_0.conda + sha256: d3bd8b38a74825e9e502f3251fba167b303d7ad324cd4e41d459bfa3c118c9ee + md5: 391934bd1a79990c23df1d1809ddc821 + depends: + - nbconvert-core 7.16.4 pyhd8ed1ab_0 + - pandoc + license: BSD-3-Clause + license_family: BSD + size: 8479 + timestamp: 1714477291801 +- kind: conda + name: nbformat + version: 5.10.4 + build: pyhd8ed1ab_0 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/nbformat-5.10.4-pyhd8ed1ab_0.conda + sha256: 36fe73da4d37bc7ac2d1540526ecd294fbd09acda04e096181ab8f1ccd2b464c + md5: 0b57b5368ab7fc7cdc9e3511fa867214 + depends: + - jsonschema >=2.6 + - jupyter_core >=4.12,!=5.0.* + - python >=3.8 + - python-fastjsonschema >=2.15 + - traitlets >=5.1 + license: BSD-3-Clause + license_family: BSD + size: 101232 + timestamp: 1712239122969 +- kind: conda + name: nbsphinx + version: 0.9.4 + build: pyhd8ed1ab_0 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/nbsphinx-0.9.4-pyhd8ed1ab_0.conda + sha256: 2d5756e2ab94ba73d630b97bc8ce6b0ea6eb60aadc2ad7e47e6e6d48fe3f87e8 + md5: 9dc80eaeff56fb67dbf4f871b81bc13a + depends: + - docutils + - jinja2 + - nbconvert + - nbformat + - python >=3.6 + - sphinx + - traitlets + license: MIT + license_family: MIT + size: 33630 + timestamp: 1715074950890 +- kind: conda + name: ncurses + version: '6.5' + build: h0425590_0 + subdir: linux-aarch64 + url: https://conda.anaconda.org/conda-forge/linux-aarch64/ncurses-6.5-h0425590_0.conda + sha256: f8002feaa9e0eb929cd123f1275d8c0b3c6ffb7fd9269b192927009df19dc89e + md5: 38362af7bfac0efef69675acee564458 + depends: + - libgcc-ng >=12 + license: X11 AND BSD-3-Clause + size: 925099 + timestamp: 1715194843316 +- kind: conda + name: ncurses + version: '6.5' + build: h5846eda_0 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/ncurses-6.5-h5846eda_0.conda + sha256: 6ecc73db0e49143092c0934355ac41583a5d5a48c6914c5f6ca48e562d3a4b79 + md5: 02a888433d165c99bf09784a7b14d900 + license: X11 AND BSD-3-Clause + size: 823601 + timestamp: 1715195267791 +- kind: conda + name: ncurses + version: '6.5' + build: h59595ed_0 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/ncurses-6.5-h59595ed_0.conda + sha256: 4fc3b384f4072b68853a0013ea83bdfd3d66b0126e2238e1d6e1560747aa7586 + md5: fcea371545eda051b6deafb24889fc69 + depends: + - libgcc-ng >=12 + license: X11 AND BSD-3-Clause + size: 887465 + timestamp: 1715194722503 +- kind: conda + name: ncurses + version: '6.5' + build: hb89a1cb_0 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/ncurses-6.5-hb89a1cb_0.conda + sha256: 87d7cf716d9d930dab682cb57b3b8d3a61940b47d6703f3529a155c938a6990a + md5: b13ad5724ac9ae98b6b4fd87e4500ba4 + license: X11 AND BSD-3-Clause + size: 795131 + timestamp: 1715194898402 +- kind: conda + name: nodeenv + version: 1.9.1 + build: pyhd8ed1ab_0 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/nodeenv-1.9.1-pyhd8ed1ab_0.conda + sha256: 85ee07342ab055dc081f3de8292c5e7195e43e046db9c5750f242f928f6bb8f2 + md5: dfe0528d0f1c16c1f7c528ea5536ab30 + depends: + - python 2.7|>=3.7 + - setuptools + license: BSD-3-Clause + license_family: BSD + size: 34489 + timestamp: 1717585382642 +- kind: conda + name: nodejs + version: 20.12.2 + build: h3b52c9b_0 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/nodejs-20.12.2-h3b52c9b_0.conda + sha256: 81ea2a695b4b97ce6066220b9e54232e67b4a1e3eac3fc7016c08a463c588478 + md5: 0ba66fae46df4a035db42e2230453604 + depends: + - icu >=73.2,<74.0a0 + - libcxx >=16 + - libuv >=1.48.0,<1.49.0a0 + - libzlib >=1.2.13,<2.0.0a0 + - openssl >=3.2.1,<4.0a0 + - zlib + license: MIT + license_family: MIT + size: 11674337 + timestamp: 1714140786813 +- kind: conda + name: nodejs + version: 20.12.2 + build: h57928b3_0 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/nodejs-20.12.2-h57928b3_0.conda + sha256: 31b275bf914d57941e818b31f7ee8367c6c6a8532a2918639c87816bad1323af + md5: 28d4536e0beff7b51232a5b16f9c3444 + license: MIT + license_family: MIT + size: 22693430 + timestamp: 1714121518826 +- kind: conda + name: nodejs + version: 20.12.2 + build: hb753e55_0 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/nodejs-20.12.2-hb753e55_0.conda + sha256: 2f5813d9718963861314c6d9f75fe4630c3e6d078ec1e792770daf9ce7ac5c4f + md5: 1fd16ca757a195c4357a1fbb2cb553b5 + depends: + - __glibc >=2.17,<3.0.a0 + - icu >=73.2,<74.0a0 + - libgcc-ng >=12 + - libstdcxx-ng >=12 + - libuv >=1.48.0,<1.49.0a0 + - libzlib >=1.2.13,<2.0.0a0 + - openssl >=3.2.1,<4.0a0 + - zlib + license: MIT + license_family: MIT + size: 17183636 + timestamp: 1714128011970 +- kind: conda + name: nodejs + version: 20.12.2 + build: hc1f8a26_0 + subdir: linux-aarch64 + url: https://conda.anaconda.org/conda-forge/linux-aarch64/nodejs-20.12.2-hc1f8a26_0.conda + sha256: 4a473d7a5742d386a895947c49a5448f662044d07eddae68d6abbba4714c4a8d + md5: 45ab9f028d15806352380c65d99e7ac1 + depends: + - icu >=73.2,<74.0a0 + - libgcc-ng >=12 + - libstdcxx-ng >=12 + - libuv >=1.48.0,<1.49.0a0 + - libzlib >=1.2.13,<2.0.0a0 + - openssl >=3.2.1,<4.0a0 + - zlib + license: MIT + license_family: MIT + size: 17602434 + timestamp: 1714132245999 +- kind: conda + name: nodejs + version: 20.12.2 + build: hfc0f20e_0 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/nodejs-20.12.2-hfc0f20e_0.conda + sha256: 5b8de07e2c67793ca620f5fc9eff9dd7015198e4e390c5cc99b87d2af0523b30 + md5: ac7bb297a9842b851b8a89df778ce9c8 + depends: + - icu >=73.2,<74.0a0 + - libcxx >=16 + - libuv >=1.48.0,<1.49.0a0 + - libzlib >=1.2.13,<2.0.0a0 + - openssl >=3.2.1,<4.0a0 + - zlib + constrains: + - __osx >=10.15 + license: MIT + license_family: MIT + size: 12255489 + timestamp: 1714132368605 +- kind: conda + name: numpy + version: 1.26.4 + build: py310h4bfa8fc_0 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/numpy-1.26.4-py310h4bfa8fc_0.conda + sha256: 914476e2d3273fdf9c0419a7bdcb7b31a5ec25949e4afbc847297ff3a50c62c8 + md5: cd6a2298387f558c9ea70ee73a189791 + depends: + - libblas >=3.9.0,<4.0a0 + - libcblas >=3.9.0,<4.0a0 + - libcxx >=16 + - liblapack >=3.9.0,<4.0a0 + - python >=3.10,<3.11.0a0 + - python_abi 3.10.* *_cp310 + constrains: + - numpy-base <0a0 + license: BSD-3-Clause + license_family: BSD + size: 6491938 + timestamp: 1707226191321 +- kind: conda + name: numpy + version: 1.26.4 + build: py310hb13e2d6_0 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/numpy-1.26.4-py310hb13e2d6_0.conda + sha256: 028fe2ea8e915a0a032b75165f11747770326f3d767e642880540c60a3256425 + md5: 6593de64c935768b6bad3e19b3e978be + depends: + - libblas >=3.9.0,<4.0a0 + - libcblas >=3.9.0,<4.0a0 + - libgcc-ng >=12 + - liblapack >=3.9.0,<4.0a0 + - libstdcxx-ng >=12 + - python >=3.10,<3.11.0a0 + - python_abi 3.10.* *_cp310 + constrains: + - numpy-base <0a0 + license: BSD-3-Clause + license_family: BSD + size: 7009070 + timestamp: 1707225917496 +- kind: conda + name: numpy + version: 1.26.4 + build: py310hcbab775_0 + subdir: linux-aarch64 + url: https://conda.anaconda.org/conda-forge/linux-aarch64/numpy-1.26.4-py310hcbab775_0.conda + sha256: 027b2d9a63d074ada499727a3cd1af7c4c28a91ecad19bf84dca5b9b5663eff4 + md5: 2cb108b5220653a4024a029e60cf2c66 + depends: + - libblas >=3.9.0,<4.0a0 + - libcblas >=3.9.0,<4.0a0 + - libgcc-ng >=12 + - liblapack >=3.9.0,<4.0a0 + - libstdcxx-ng >=12 + - python >=3.10,<3.11.0a0 + - python >=3.10,<3.11.0a0 *_cpython + - python_abi 3.10.* *_cp310 + constrains: + - numpy-base <0a0 + license: BSD-3-Clause + license_family: BSD + size: 6085548 + timestamp: 1707225773389 +- kind: conda + name: numpy + version: 1.26.4 + build: py310hd45542a_0 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/numpy-1.26.4-py310hd45542a_0.conda + sha256: e3078108a4973e73c813b89228f4bd8095ec58f96ca29f55d2e45a6223a9a1db + md5: 267ee89a3a0b8c8fa838a2353f9ea0c0 + depends: + - libblas >=3.9.0,<4.0a0 + - libcblas >=3.9.0,<4.0a0 + - libcxx >=16 + - liblapack >=3.9.0,<4.0a0 + - python >=3.10,<3.11.0a0 + - python >=3.10,<3.11.0a0 *_cpython + - python_abi 3.10.* *_cp310 + constrains: + - numpy-base <0a0 + license: BSD-3-Clause + license_family: BSD + size: 5475744 + timestamp: 1707226187124 +- kind: conda + name: numpy + version: 1.26.4 + build: py310hf667824_0 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/numpy-1.26.4-py310hf667824_0.conda + sha256: 20ca447a8f840c01961f2bdf0847fc7b7785a62968e867d7aa4ca8a66d70f9ad + md5: 93e881c391880df90e74e43a4b67c16d + depends: + - libblas >=3.9.0,<4.0a0 + - libcblas >=3.9.0,<4.0a0 + - liblapack >=3.9.0,<4.0a0 + - python >=3.10,<3.11.0a0 + - python_abi 3.10.* *_cp310 + - ucrt >=10.0.20348.0 + - vc >=14.2,<15 + - vc14_runtime >=14.29.30139 + constrains: + - numpy-base <0a0 + license: BSD-3-Clause + license_family: BSD + size: 5977469 + timestamp: 1707226445438 +- kind: conda + name: numpy + version: 1.26.4 + build: py311h0b4df5a_0 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/numpy-1.26.4-py311h0b4df5a_0.conda + sha256: 14116e72107de3089cc58119a5ce5905c22abf9a715c9fe41f8ac14db0992326 + md5: 7b240edd44fd7a0991aa409b07cee776 + depends: + - libblas >=3.9.0,<4.0a0 + - libcblas >=3.9.0,<4.0a0 + - liblapack >=3.9.0,<4.0a0 + - python >=3.11,<3.12.0a0 + - python_abi 3.11.* *_cp311 + - ucrt >=10.0.20348.0 + - vc >=14.2,<15 + - vc14_runtime >=14.29.30139 + constrains: + - numpy-base <0a0 + license: BSD-3-Clause + license_family: BSD + size: 7104093 + timestamp: 1707226459646 +- kind: conda + name: numpy + version: 1.26.4 + build: py311h64a7726_0 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/numpy-1.26.4-py311h64a7726_0.conda + sha256: 3f4365e11b28e244c95ba8579942b0802761ba7bb31c026f50d1a9ea9c728149 + md5: a502d7aad449a1206efb366d6a12c52d + depends: + - libblas >=3.9.0,<4.0a0 + - libcblas >=3.9.0,<4.0a0 + - libgcc-ng >=12 + - liblapack >=3.9.0,<4.0a0 + - libstdcxx-ng >=12 + - python >=3.11,<3.12.0a0 + - python_abi 3.11.* *_cp311 + constrains: + - numpy-base <0a0 + license: BSD-3-Clause + license_family: BSD + size: 8065890 + timestamp: 1707225944355 +- kind: conda + name: numpy + version: 1.26.4 + build: py311h69ead2a_0 + subdir: linux-aarch64 + url: https://conda.anaconda.org/conda-forge/linux-aarch64/numpy-1.26.4-py311h69ead2a_0.conda + sha256: 88800a1d9d11c2fccab09d40d36f7001616f5119eaf0ec86186562f33564e651 + md5: 3fd00dd400c8d3f9da12bf33061dd28d + depends: + - libblas >=3.9.0,<4.0a0 + - libcblas >=3.9.0,<4.0a0 + - libgcc-ng >=12 + - liblapack >=3.9.0,<4.0a0 + - libstdcxx-ng >=12 + - python >=3.11,<3.12.0a0 + - python >=3.11,<3.12.0a0 *_cpython + - python_abi 3.11.* *_cp311 + constrains: + - numpy-base <0a0 + license: BSD-3-Clause + license_family: BSD + size: 7234391 + timestamp: 1707225781489 +- kind: conda + name: numpy + version: 1.26.4 + build: py311h7125741_0 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/numpy-1.26.4-py311h7125741_0.conda + sha256: 160a52a01fea44fe9753a2ed22cf13d7b55c8a89ea0b8738546fdbf4795d6514 + md5: 3160b93669a0def35a7a8158ebb33816 + depends: + - libblas >=3.9.0,<4.0a0 + - libcblas >=3.9.0,<4.0a0 + - libcxx >=16 + - liblapack >=3.9.0,<4.0a0 + - python >=3.11,<3.12.0a0 + - python >=3.11,<3.12.0a0 *_cpython + - python_abi 3.11.* *_cp311 + constrains: + - numpy-base <0a0 + license: BSD-3-Clause + license_family: BSD + size: 6652352 + timestamp: 1707226297967 +- kind: conda + name: numpy + version: 1.26.4 + build: py311hc43a94b_0 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/numpy-1.26.4-py311hc43a94b_0.conda + sha256: dc9628197125ee1d02b2e7a859a769d26291d747ed79337309b8a9e67a8b8e00 + md5: bb02b8801d17265160e466cf8bbf28da + depends: + - libblas >=3.9.0,<4.0a0 + - libcblas >=3.9.0,<4.0a0 + - libcxx >=16 + - liblapack >=3.9.0,<4.0a0 + - python >=3.11,<3.12.0a0 + - python_abi 3.11.* *_cp311 + constrains: + - numpy-base <0a0 + license: BSD-3-Clause + license_family: BSD + size: 7504319 + timestamp: 1707226235372 +- kind: conda + name: numpy + version: 1.26.4 + build: py312h470d778_0 + subdir: linux-aarch64 + url: https://conda.anaconda.org/conda-forge/linux-aarch64/numpy-1.26.4-py312h470d778_0.conda + sha256: 23767677a7790bee5457d5e75ebd508b9a31c5354216f4310dd1acfca3f7a6f9 + md5: 9cebf5a06cb87d4569cd68df887af476 + depends: + - libblas >=3.9.0,<4.0a0 + - libcblas >=3.9.0,<4.0a0 + - libgcc-ng >=12 + - liblapack >=3.9.0,<4.0a0 + - libstdcxx-ng >=12 + - python >=3.12,<3.13.0a0 + - python >=3.12,<3.13.0a0 *_cpython + - python_abi 3.12.* *_cp312 + constrains: + - numpy-base <0a0 + license: BSD-3-Clause + license_family: BSD + size: 6614296 + timestamp: 1707225994762 +- kind: conda + name: numpy + version: 1.26.4 + build: py312h8442bc7_0 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/numpy-1.26.4-py312h8442bc7_0.conda + sha256: c8841d6d6f61fd70ca80682efbab6bdb8606dc77c68d8acabfbd7c222054f518 + md5: d83fc83d589e2625a3451c9a7e21047c + depends: + - libblas >=3.9.0,<4.0a0 + - libcblas >=3.9.0,<4.0a0 + - libcxx >=16 + - liblapack >=3.9.0,<4.0a0 + - python >=3.12,<3.13.0a0 + - python >=3.12,<3.13.0a0 *_cpython + - python_abi 3.12.* *_cp312 + constrains: + - numpy-base <0a0 + license: BSD-3-Clause + license_family: BSD + size: 6073136 + timestamp: 1707226249608 +- kind: conda + name: numpy + version: 1.26.4 + build: py312h8753938_0 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/numpy-1.26.4-py312h8753938_0.conda + sha256: 73570817a5109d396b4ebbe5124a89525959269fd33fa33fd413700289fbe0ef + md5: f9ac74c3b07c396014434aca1e58d362 + depends: + - libblas >=3.9.0,<4.0a0 + - libcblas >=3.9.0,<4.0a0 + - liblapack >=3.9.0,<4.0a0 + - python >=3.12,<3.13.0a0 + - python_abi 3.12.* *_cp312 + - ucrt >=10.0.20348.0 + - vc >=14.2,<15 + - vc14_runtime >=14.29.30139 + constrains: + - numpy-base <0a0 + license: BSD-3-Clause + license_family: BSD + size: 6495445 + timestamp: 1707226412944 +- kind: conda + name: numpy + version: 1.26.4 + build: py312he3a82b2_0 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/numpy-1.26.4-py312he3a82b2_0.conda + sha256: 6152b73fba3e227afa4952df8753128fc9669bbaf142ee8f9972bf9df3bf8856 + md5: 96c61a21c4276613748dba069554846b + depends: + - libblas >=3.9.0,<4.0a0 + - libcblas >=3.9.0,<4.0a0 + - libcxx >=16 + - liblapack >=3.9.0,<4.0a0 + - python >=3.12,<3.13.0a0 + - python_abi 3.12.* *_cp312 + constrains: + - numpy-base <0a0 + license: BSD-3-Clause + license_family: BSD + size: 6990646 + timestamp: 1707226178262 +- kind: conda + name: numpy + version: 1.26.4 + build: py312heda63a1_0 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/numpy-1.26.4-py312heda63a1_0.conda + sha256: fe3459c75cf84dcef6ef14efcc4adb0ade66038ddd27cadb894f34f4797687d8 + md5: d8285bea2a350f63fab23bf460221f3f + depends: + - libblas >=3.9.0,<4.0a0 + - libcblas >=3.9.0,<4.0a0 + - libgcc-ng >=12 + - liblapack >=3.9.0,<4.0a0 + - libstdcxx-ng >=12 + - python >=3.12,<3.13.0a0 + - python_abi 3.12.* *_cp312 + constrains: + - numpy-base <0a0 + license: BSD-3-Clause + license_family: BSD + size: 7484186 + timestamp: 1707225809722 +- kind: conda + name: numpydoc + version: 1.7.0 + build: pyhd8ed1ab_0 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/numpydoc-1.7.0-pyhd8ed1ab_0.conda + sha256: fe33123d34c06c6bc05095f17f92d43f012f990813ad4cf0cc93f7b215c2ad04 + md5: 1ad3afced398492586ca1bef70328be4 + depends: + - jinja2 >=2.10 + - python >=3.7 + - sphinx >=5 + - tabulate >=0.8.10 + license: BSD-3-Clause + license_family: BSD + size: 57422 + timestamp: 1711638408735 +- kind: conda + name: onnx + version: 1.16.1 + build: py310h00e9488_0 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/onnx-1.16.1-py310h00e9488_0.conda + sha256: 5da5b54789c6354df6b8c1bffa2405ea24d7631842f1d6df68088e232691790c + md5: a8cb7501f455c383f684ccb079bcc419 + depends: + - __osx >=10.13 + - libcxx >=16 + - libprotobuf >=4.25.3,<4.25.4.0a0 + - numpy >=1.19,<3 + - protobuf + - python >=3.10,<3.11.0a0 + - python_abi 3.10.* *_cp310 + - typing-extensions >=3.6.2.1 + license: Apache-2.0 + license_family: APACHE + size: 11284668 + timestamp: 1716533133225 +- kind: conda + name: onnx + version: 1.16.1 + build: py310h0fe6b08_0 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/onnx-1.16.1-py310h0fe6b08_0.conda + sha256: 3ee3dcb1de14f368d0e0c0f086b9ec68181d5a88de1c12b8afc82f1122126928 + md5: c15f663d2816e047d8ed024d8c5256db + depends: + - __osx >=11.0 + - libcxx >=16 + - libprotobuf >=4.25.3,<4.25.4.0a0 + - numpy >=1.19,<3 + - protobuf + - python >=3.10,<3.11.0a0 + - python >=3.10,<3.11.0a0 *_cpython + - python_abi 3.10.* *_cp310 + - typing-extensions >=3.6.2.1 + license: Apache-2.0 + license_family: APACHE + size: 10668064 + timestamp: 1716533240797 +- kind: conda + name: onnx + version: 1.16.1 + build: py310h25cd676_0 + subdir: linux-aarch64 + url: https://conda.anaconda.org/conda-forge/linux-aarch64/onnx-1.16.1-py310h25cd676_0.conda + sha256: 079b473fdc39fd60ac023a77d5ec80d1e8c68170b0f97ee0873f2fda3afeee3d + md5: d3bdc9ae16e137d449976e34bc01ba3a + depends: + - libgcc-ng >=12 + - libprotobuf >=4.25.3,<4.25.4.0a0 + - libstdcxx-ng >=12 + - numpy >=1.19,<3 + - protobuf + - python >=3.10,<3.11.0a0 + - python_abi 3.10.* *_cp310 + - typing-extensions >=3.6.2.1 + license: Apache-2.0 + license_family: APACHE + size: 10737943 + timestamp: 1716537520250 +- kind: conda + name: onnx + version: 1.16.1 + build: py310hc505232_0 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/onnx-1.16.1-py310hc505232_0.conda + sha256: 3cc5a726fdbf2bd4dac9678b50f58916f3ddeb0dc325c3ee3c8acb7e2108e31c + md5: 155b5cb2aa20d5f7932ed846613526d5 + depends: + - libgcc-ng >=12 + - libprotobuf >=4.25.3,<4.25.4.0a0 + - libstdcxx-ng >=12 + - numpy >=1.19,<3 + - protobuf + - python >=3.10,<3.11.0a0 + - python_abi 3.10.* *_cp310 + - typing-extensions >=3.6.2.1 + license: Apache-2.0 + license_family: APACHE + size: 10863699 + timestamp: 1716533475058 +- kind: conda + name: onnx + version: 1.16.1 + build: py310hc705b4a_0 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/onnx-1.16.1-py310hc705b4a_0.conda + sha256: e8096e08e93327a952c45448968ef86e7ebf9b7b0888db1d59502cefe89ab462 + md5: 77006c1d20750418dd0c0cbc03d4a2d2 + depends: + - libprotobuf >=4.25.3,<4.25.4.0a0 + - numpy >=1.19,<3 + - protobuf + - python >=3.10,<3.11.0a0 + - python_abi 3.10.* *_cp310 + - typing-extensions >=3.6.2.1 + - ucrt >=10.0.20348.0 + - vc >=14.2,<15 + - vc14_runtime >=14.29.30139 + license: Apache-2.0 + license_family: APACHE + size: 10395355 + timestamp: 1716533908778 +- kind: conda + name: onnx + version: 1.16.1 + build: py311h0511f7a_0 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/onnx-1.16.1-py311h0511f7a_0.conda + sha256: 78afaf089c0f9e6898e6bc57a93cc8d96051903238ab890985c81a0a491d043d + md5: ca7c598c02747d39108434fa359b500c + depends: + - libgcc-ng >=12 + - libprotobuf >=4.25.3,<4.25.4.0a0 + - libstdcxx-ng >=12 + - numpy >=1.19,<3 + - protobuf + - python >=3.11,<3.12.0a0 + - python_abi 3.11.* *_cp311 + - typing-extensions >=3.6.2.1 + license: Apache-2.0 + license_family: APACHE + size: 11113406 + timestamp: 1716533385926 +- kind: conda + name: onnx + version: 1.16.1 + build: py311h20f75e2_0 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/onnx-1.16.1-py311h20f75e2_0.conda + sha256: ae49225a0dc31fefead3b6ec8cbd0738e3f7a26da71718c14cf53262aeb4d122 + md5: c9d950a2739e0479e04d91bbe965bafc + depends: + - libprotobuf >=4.25.3,<4.25.4.0a0 + - numpy >=1.19,<3 + - protobuf + - python >=3.11,<3.12.0a0 + - python_abi 3.11.* *_cp311 + - typing-extensions >=3.6.2.1 + - ucrt >=10.0.20348.0 + - vc >=14.2,<15 + - vc14_runtime >=14.29.30139 + license: Apache-2.0 + license_family: APACHE + size: 10496981 + timestamp: 1716533859346 +- kind: conda + name: onnx + version: 1.16.1 + build: py311h6c98c43_0 + subdir: linux-aarch64 + url: https://conda.anaconda.org/conda-forge/linux-aarch64/onnx-1.16.1-py311h6c98c43_0.conda + sha256: 0877cdd39adcfe23e820e03f6757e83f5dac72a5477d44214db876c3ab908a28 + md5: cb1b260a6701712461a9fe0bf544d3e3 + depends: + - libgcc-ng >=12 + - libprotobuf >=4.25.3,<4.25.4.0a0 + - libstdcxx-ng >=12 + - numpy >=1.19,<3 + - protobuf + - python >=3.11,<3.12.0a0 + - python_abi 3.11.* *_cp311 + - typing-extensions >=3.6.2.1 + license: Apache-2.0 + license_family: APACHE + size: 11192531 + timestamp: 1716538207425 +- kind: conda + name: onnx + version: 1.16.1 + build: py311h6ec6fdf_0 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/onnx-1.16.1-py311h6ec6fdf_0.conda + sha256: ad3f5737c9d3c81b726f43908bbbc8ac8b59c1465cdca1749bc7a7db96e4e6ad + md5: fab16e00511a9f6276d27f283cd11e42 + depends: + - __osx >=11.0 + - libcxx >=16 + - libprotobuf >=4.25.3,<4.25.4.0a0 + - numpy >=1.19,<3 + - protobuf + - python >=3.11,<3.12.0a0 + - python >=3.11,<3.12.0a0 *_cpython + - python_abi 3.11.* *_cp311 + - typing-extensions >=3.6.2.1 + license: Apache-2.0 + license_family: APACHE + size: 11130852 + timestamp: 1716533339652 +- kind: conda + name: onnx + version: 1.16.1 + build: py311hd6d7c3e_0 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/onnx-1.16.1-py311hd6d7c3e_0.conda + sha256: 524b3c3e7311f3e005709ad5d43993a94a51e0e14ee85d972651fd0dbaf76de4 + md5: 2c27091c1b2ebe40b570a173447ce5b8 + depends: + - __osx >=10.13 + - libcxx >=16 + - libprotobuf >=4.25.3,<4.25.4.0a0 + - numpy >=1.19,<3 + - protobuf + - python >=3.11,<3.12.0a0 + - python_abi 3.11.* *_cp311 + - typing-extensions >=3.6.2.1 + license: Apache-2.0 + license_family: APACHE + size: 10999939 + timestamp: 1716533015007 +- kind: conda + name: onnx + version: 1.16.1 + build: py312h67626d2_0 + subdir: linux-aarch64 + url: https://conda.anaconda.org/conda-forge/linux-aarch64/onnx-1.16.1-py312h67626d2_0.conda + sha256: 868eb58e3336824da8c78cf7bc081e7ffbd7b0f87ffbdda06d865209731e0b1c + md5: 5704dfc9985f79e1fd9e2324f52fb5ca + depends: + - libgcc-ng >=12 + - libprotobuf >=4.25.3,<4.25.4.0a0 + - libstdcxx-ng >=12 + - numpy >=1.19,<3 + - protobuf + - python >=3.12,<3.13.0a0 + - python_abi 3.12.* *_cp312 + - typing-extensions >=3.6.2.1 + license: Apache-2.0 + license_family: APACHE + size: 11027897 + timestamp: 1716537197490 +- kind: conda + name: onnx + version: 1.16.1 + build: py312ha2757a1_0 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/onnx-1.16.1-py312ha2757a1_0.conda + sha256: 4e0b94fb09f066302b6f7c2e61ec6a9120ed84c992998ec7405c042ce03c68dc + md5: a2c4ed154c58320feb3ae6649017acae + depends: + - libprotobuf >=4.25.3,<4.25.4.0a0 + - numpy >=1.19,<3 + - protobuf + - python >=3.12,<3.13.0a0 + - python_abi 3.12.* *_cp312 + - typing-extensions >=3.6.2.1 + - ucrt >=10.0.20348.0 + - vc >=14.2,<15 + - vc14_runtime >=14.29.30139 + license: Apache-2.0 + license_family: APACHE + size: 10182412 + timestamp: 1716533690275 +- kind: conda + name: onnx + version: 1.16.1 + build: py312hb223586_0 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/onnx-1.16.1-py312hb223586_0.conda + sha256: a230f010f344e526208891cc7bc9da557b68fc407beba1d6591c151487b9dffb + md5: 97d122c89a3eb38e5ee1aeedc749ca95 + depends: + - libgcc-ng >=12 + - libprotobuf >=4.25.3,<4.25.4.0a0 + - libstdcxx-ng >=12 + - numpy >=1.19,<3 + - protobuf + - python >=3.12,<3.13.0a0 + - python_abi 3.12.* *_cp312 + - typing-extensions >=3.6.2.1 + license: Apache-2.0 + license_family: APACHE + size: 11151606 + timestamp: 1716533345703 +- kind: conda + name: onnx + version: 1.16.1 + build: py312hb2a1542_0 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/onnx-1.16.1-py312hb2a1542_0.conda + sha256: 8108006104c13d50c8e4b39a32f583a8142b07b543e2771c0e49f095446bf59f + md5: 4e776dd06a860ba62726c6637f1b4c7f + depends: + - __osx >=11.0 + - libcxx >=16 + - libprotobuf >=4.25.3,<4.25.4.0a0 + - numpy >=1.19,<3 + - protobuf + - python >=3.12,<3.13.0a0 + - python >=3.12,<3.13.0a0 *_cpython + - python_abi 3.12.* *_cp312 + - typing-extensions >=3.6.2.1 + license: Apache-2.0 + license_family: APACHE + size: 11132882 + timestamp: 1716533226649 +- kind: conda + name: onnx + version: 1.16.1 + build: py312hefded4f_0 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/onnx-1.16.1-py312hefded4f_0.conda + sha256: 18c6aa2ba073ebda34bbf30e25e943a58858ba4ad5f4a285c9bbbd7882aa911a + md5: 0cb2867a01e0edbad24b6bd1552fd804 + depends: + - __osx >=10.13 + - libcxx >=16 + - libprotobuf >=4.25.3,<4.25.4.0a0 + - numpy >=1.19,<3 + - protobuf + - python >=3.12,<3.13.0a0 + - python_abi 3.12.* *_cp312 + - typing-extensions >=3.6.2.1 + license: Apache-2.0 + license_family: APACHE + size: 11185215 + timestamp: 1716533118750 +- kind: conda + name: onnxruntime + version: 1.18.0 + build: py310h2bb40e1_2_cpu + build_number: 2 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/onnxruntime-1.18.0-py310h2bb40e1_2_cpu.conda + sha256: 885624cb839df834698bb1cb133bf3889640438048906e54762b456e1fefab8f + md5: a4b03ae3606c5eae26adb032de5ca230 + depends: + - coloredlogs + - numpy >=1.19,<3 + - packaging + - protobuf + - python >=3.10,<3.11.0a0 + - python-flatbuffers + - python_abi 3.10.* *_cp310 + - sympy + - ucrt >=10.0.20348.0 + - vc >=14.3,<15 + - vc14_runtime >=14.38.33135 + license: MIT AND BSL-1.0 + size: 4650393 + timestamp: 1717075216055 +- kind: conda + name: onnxruntime + version: 1.18.0 + build: py310h5952d15_2_cpu + build_number: 2 + subdir: linux-aarch64 + url: https://conda.anaconda.org/conda-forge/linux-aarch64/onnxruntime-1.18.0-py310h5952d15_2_cpu.conda + sha256: a1bab2e17e0e5db311f509445756027ef08342aba9d9c466e9c325ce4066bbc5 + md5: 8f1dff7f0538273ddf9504619186c8a3 + depends: + - coloredlogs + - libgcc-ng >=12 + - libstdcxx-ng >=12 + - numpy >=1.19,<3 + - packaging + - protobuf + - python >=3.10,<3.11.0a0 + - python >=3.10,<3.11.0a0 *_cpython + - python-flatbuffers + - python_abi 3.10.* *_cp310 + - sympy + license: MIT AND BSL-1.0 + size: 5317915 + timestamp: 1717087429477 +- kind: conda + name: onnxruntime + version: 1.18.0 + build: py310h8035873_2_cpu + build_number: 2 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/onnxruntime-1.18.0-py310h8035873_2_cpu.conda + sha256: 7afd28b058f79b9a51351ee2c19c46613889fe22c3f3bc15d9a752f9007f0b55 + md5: 4a1ae3b56e1e3e2b69daa3361f447789 + depends: + - __osx >=10.15 + - coloredlogs + - libcxx >=16 + - numpy >=1.19,<3 + - packaging + - protobuf + - python >=3.10,<3.11.0a0 + - python-flatbuffers + - python_abi 3.10.* *_cp310 + - sympy + license: MIT AND BSL-1.0 + size: 5970017 + timestamp: 1717072187347 +- kind: conda + name: onnxruntime + version: 1.18.0 + build: py310hf6b898b_2_cpu + build_number: 2 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/onnxruntime-1.18.0-py310hf6b898b_2_cpu.conda + sha256: 9d1f579b1a4d611ba94947c3e2b746a235ecbb7f591ad4dff3b3993c00bd7f20 + md5: d35058732e1059a4c55595fb6d7635ac + depends: + - coloredlogs + - libgcc-ng >=12 + - libstdcxx-ng >=12 + - numpy >=1.19,<3 + - packaging + - protobuf + - python >=3.10,<3.11.0a0 + - python-flatbuffers + - python_abi 3.10.* *_cp310 + - sympy + license: MIT AND BSL-1.0 + size: 6114225 + timestamp: 1717075174822 +- kind: conda + name: onnxruntime + version: 1.18.0 + build: py310hfb6a49c_2_cpu + build_number: 2 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/onnxruntime-1.18.0-py310hfb6a49c_2_cpu.conda + sha256: baa527c1af8649b06c0637e3e68be5c895bca161a80bd35e51938c20a794debf + md5: 9101a038ffe1eae9ec7e1bd08ad9ad1f + depends: + - __osx >=11.0 + - coloredlogs + - libcxx >=16 + - numpy >=1.19,<3 + - packaging + - protobuf + - python >=3.10,<3.11.0a0 + - python >=3.10,<3.11.0a0 *_cpython + - python-flatbuffers + - python_abi 3.10.* *_cp310 + - sympy + license: MIT AND BSL-1.0 + size: 5364362 + timestamp: 1717074947758 +- kind: conda + name: onnxruntime + version: 1.18.0 + build: py311h15521e7_2_cpu + build_number: 2 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/onnxruntime-1.18.0-py311h15521e7_2_cpu.conda + sha256: 2e74484c7844d33ea741b057b2d934ed35ad4b16a8cb8f4c7760ee22413835f1 + md5: 3473b7ab2e82c6ed8024b7b32aa1851d + depends: + - coloredlogs + - numpy >=1.19,<3 + - packaging + - protobuf + - python >=3.11,<3.12.0a0 + - python-flatbuffers + - python_abi 3.11.* *_cp311 + - sympy + - ucrt >=10.0.20348.0 + - vc >=14.3,<15 + - vc14_runtime >=14.38.33135 + license: MIT AND BSL-1.0 + size: 5001460 + timestamp: 1717074829175 +- kind: conda + name: onnxruntime + version: 1.18.0 + build: py311h3f3472b_2_cpu + build_number: 2 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/onnxruntime-1.18.0-py311h3f3472b_2_cpu.conda + sha256: 2f6f0c8ff4ce2eb501085258360db11fd6699028328492422aaa2d9bf7f0f5b8 + md5: ea82c26cfebdc62cf55930559bf77d13 + depends: + - __osx >=10.15 + - coloredlogs + - libcxx >=16 + - numpy >=1.19,<3 + - packaging + - protobuf + - python >=3.11,<3.12.0a0 + - python-flatbuffers + - python_abi 3.11.* *_cp311 + - sympy + license: MIT AND BSL-1.0 + size: 6242894 + timestamp: 1717072884921 +- kind: conda + name: onnxruntime + version: 1.18.0 + build: py311h66f376b_2_cpu + build_number: 2 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/onnxruntime-1.18.0-py311h66f376b_2_cpu.conda + sha256: 0dc2b91d4a7ee8319d5561a9417a6f7ce57188b94b7f63a5a727bdc3f9e42a4b + md5: dfb90d2289b585b5a973d8f812d8d798 + depends: + - __osx >=11.0 + - coloredlogs + - libcxx >=16 + - numpy >=1.19,<3 + - packaging + - protobuf + - python >=3.11,<3.12.0a0 + - python >=3.11,<3.12.0a0 *_cpython + - python-flatbuffers + - python_abi 3.11.* *_cp311 + - sympy + license: MIT AND BSL-1.0 + size: 5794045 + timestamp: 1717074364501 +- kind: conda + name: onnxruntime + version: 1.18.0 + build: py311hc6cc989_2_cpu + build_number: 2 + subdir: linux-aarch64 + url: https://conda.anaconda.org/conda-forge/linux-aarch64/onnxruntime-1.18.0-py311hc6cc989_2_cpu.conda + sha256: 32430cb96807e42adb70ea823097ae5e76b7a3d0f89406f4c9ecf95e8aef95fc + md5: 58d04f344a3a638f67ec8a1e0ba29eb8 + depends: + - coloredlogs + - libgcc-ng >=12 + - libstdcxx-ng >=12 + - numpy >=1.19,<3 + - packaging + - protobuf + - python >=3.11,<3.12.0a0 + - python >=3.11,<3.12.0a0 *_cpython + - python-flatbuffers + - python_abi 3.11.* *_cp311 + - sympy + license: MIT AND BSL-1.0 + size: 5795305 + timestamp: 1717088403563 +- kind: conda + name: onnxruntime + version: 1.18.0 + build: py311hd0df81e_2_cpu + build_number: 2 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/onnxruntime-1.18.0-py311hd0df81e_2_cpu.conda + sha256: a9d152eb2384bd7fded89b61aba10b804831178131163b4252cdf69ee848b361 + md5: 18850530b9f595d5387597ee64eda228 + depends: + - coloredlogs + - libgcc-ng >=12 + - libstdcxx-ng >=12 + - numpy >=1.19,<3 + - packaging + - protobuf + - python >=3.11,<3.12.0a0 + - python-flatbuffers + - python_abi 3.11.* *_cp311 + - sympy + license: MIT AND BSL-1.0 + size: 6515016 + timestamp: 1717075688862 +- kind: conda + name: onnxruntime + version: 1.18.0 + build: py312h2704b8b_2_cpu + build_number: 2 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/onnxruntime-1.18.0-py312h2704b8b_2_cpu.conda + sha256: 141a2a0ef7101e78b126f8569a5016c090786fe901c729a64f6e3ab3a0cb8c5b + md5: 69f70a393d18adc56c6e09c895e23f81 + depends: + - coloredlogs + - numpy >=1.19,<3 + - packaging + - protobuf + - python >=3.12,<3.13.0a0 + - python-flatbuffers + - python_abi 3.12.* *_cp312 + - sympy + - ucrt >=10.0.20348.0 + - vc >=14.3,<15 + - vc14_runtime >=14.38.33135 + license: MIT AND BSL-1.0 + size: 5024740 + timestamp: 1717076239110 +- kind: conda + name: onnxruntime + version: 1.18.0 + build: py312hbe6c245_2_cpu + build_number: 2 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/onnxruntime-1.18.0-py312hbe6c245_2_cpu.conda + sha256: 2a3b00fc152c6174bbd16f3497a85647eaa9496e364dfa2a94ab51a1547e923e + md5: ca6e00476bebf788e264ba74d6260f51 + depends: + - coloredlogs + - libgcc-ng >=12 + - libstdcxx-ng >=12 + - numpy >=1.19,<3 + - packaging + - protobuf + - python >=3.12,<3.13.0a0 + - python-flatbuffers + - python_abi 3.12.* *_cp312 + - sympy + license: MIT AND BSL-1.0 + size: 6479580 + timestamp: 1717073834320 +- kind: conda + name: onnxruntime + version: 1.18.0 + build: py312hcd9b293_2_cpu + build_number: 2 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/onnxruntime-1.18.0-py312hcd9b293_2_cpu.conda + sha256: a1b075ae8200b6ba52335239f74fda4bd8c6ad5f3d7771243a4f7d9c8d45b4e0 + md5: 021bee05e7bed36baf6ea59b9b3df4d7 + depends: + - __osx >=11.0 + - coloredlogs + - libcxx >=16 + - numpy >=1.19,<3 + - packaging + - protobuf + - python >=3.12,<3.13.0a0 + - python >=3.12,<3.13.0a0 *_cpython + - python-flatbuffers + - python_abi 3.12.* *_cp312 + - sympy + license: MIT AND BSL-1.0 + size: 5733905 + timestamp: 1717074111989 +- kind: conda + name: onnxruntime + version: 1.18.0 + build: py312hd03a33c_2_cpu + build_number: 2 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/onnxruntime-1.18.0-py312hd03a33c_2_cpu.conda + sha256: 01698dce1095e9beccac9cd36fd0664456ed24f67f975ff1bbf2f9baf6b3b617 + md5: a0cb1ef33bec2e066fd04c4f70acfe1c + depends: + - __osx >=10.15 + - coloredlogs + - libcxx >=16 + - numpy >=1.19,<3 + - packaging + - protobuf + - python >=3.12,<3.13.0a0 + - python-flatbuffers + - python_abi 3.12.* *_cp312 + - sympy + license: MIT AND BSL-1.0 + size: 6345248 + timestamp: 1717072387253 +- kind: conda + name: onnxruntime + version: 1.18.0 + build: py312hfb296ae_2_cpu + build_number: 2 + subdir: linux-aarch64 + url: https://conda.anaconda.org/conda-forge/linux-aarch64/onnxruntime-1.18.0-py312hfb296ae_2_cpu.conda + sha256: 8988df1b0c3daf029a2aca49df3d933eecc497e250a69ec505459274a0737d48 + md5: 2f6ba23e7157b3876aab6ed0504d52fc + depends: + - coloredlogs + - libgcc-ng >=12 + - libstdcxx-ng >=12 + - numpy >=1.19,<3 + - packaging + - protobuf + - python >=3.12,<3.13.0a0 + - python >=3.12,<3.13.0a0 *_cpython + - python-flatbuffers + - python_abi 3.12.* *_cp312 + - sympy + license: MIT AND BSL-1.0 + size: 5757386 + timestamp: 1717090004942 +- kind: conda + name: openssl + version: 3.3.1 + build: h2466b09_0 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/openssl-3.3.1-h2466b09_0.conda + sha256: fbd63a41b854370a74e5f7ccc50d67f053d60c08e40389156e7924df0824d297 + md5: 27fe798366ef3a81715b13eedf699e2f + depends: + - ca-certificates + - ucrt >=10.0.20348.0 + - vc >=14.2,<15 + - vc14_runtime >=14.29.30139 + constrains: + - pyopenssl >=22.1 + license: Apache-2.0 + license_family: Apache + size: 8383610 + timestamp: 1717550042871 +- kind: conda + name: openssl + version: 3.3.1 + build: h4ab18f5_0 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/openssl-3.3.1-h4ab18f5_0.conda + sha256: 9691f8bd6394c5bb0b8d2f47cd1467b91bd5b1df923b69e6b517f54496ee4b50 + md5: a41fa0e391cc9e0d6b78ac69ca047a6c + depends: + - ca-certificates + - libgcc-ng >=12 + constrains: + - pyopenssl >=22.1 + license: Apache-2.0 + license_family: Apache + size: 2896170 + timestamp: 1717546157673 +- kind: conda + name: openssl + version: 3.3.1 + build: h68df207_0 + subdir: linux-aarch64 + url: https://conda.anaconda.org/conda-forge/linux-aarch64/openssl-3.3.1-h68df207_0.conda + sha256: 1688bf43c6ea6322ac7c1ca455712e5b64f6f524fee4c108b26c26ed7eac6f11 + md5: dc4bb65a3f9c97b26c8f947662eea202 + depends: + - ca-certificates + - libgcc-ng >=12 + constrains: + - pyopenssl >=22.1 + license: Apache-2.0 + license_family: Apache + size: 3427371 + timestamp: 1717546156492 +- kind: conda + name: openssl + version: 3.3.1 + build: h87427d6_0 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/openssl-3.3.1-h87427d6_0.conda + sha256: 272bee725877f417fef923f5e7852ebfe06b40b6bf3364f4498b2b3f568d5e2c + md5: 1bdad93ae01353340f194c5d879745db + depends: + - __osx >=10.13 + - ca-certificates + constrains: + - pyopenssl >=22.1 + license: Apache-2.0 + license_family: Apache + size: 2547614 + timestamp: 1717546605131 +- kind: conda + name: openssl + version: 3.3.1 + build: hfb2fe0b_0 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/openssl-3.3.1-hfb2fe0b_0.conda + sha256: 6cb2d44f027b259be8cba2240bdf21af7b426e4132a73e0052f7173ab8b60ab0 + md5: c4a0bbd96a0da60bf265dac62c87f4e1 + depends: + - __osx >=11.0 + - ca-certificates + constrains: + - pyopenssl >=22.1 + license: Apache-2.0 + license_family: Apache + size: 2891941 + timestamp: 1717545846389 +- kind: conda + name: packaging + version: '24.0' + build: pyhd8ed1ab_0 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/packaging-24.0-pyhd8ed1ab_0.conda + sha256: a390182d74c31dfd713c16db888c92c277feeb6d1fe96ff9d9c105f9564be48a + md5: 248f521b64ce055e7feae3105e7abeb8 + depends: + - python >=3.8 + license: Apache-2.0 + license_family: APACHE + size: 49832 + timestamp: 1710076089469 +- kind: conda + name: pandoc + version: '3.2' + build: h57928b3_0 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/pandoc-3.2-h57928b3_0.conda + sha256: 20781b4a5ed66b459968f5929a8994473198f0505797382a8eee794f5d9d7c32 + md5: 44c65fee440f2492edb8cb25f5770065 + license: GPL-2.0-or-later + license_family: GPL + size: 24991574 + timestamp: 1715499984220 +- kind: conda + name: pandoc + version: '3.2' + build: h694c41f_0 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/pandoc-3.2-h694c41f_0.conda + sha256: d1a975c8986fd47021ac368dc736f03c47eda8fcf5b1217bad184888747f7336 + md5: e2c54cad9c955434dbfe89fc655e516d + license: GPL-2.0-or-later + license_family: GPL + size: 14038781 + timestamp: 1715499676602 +- kind: conda + name: pandoc + version: '3.2' + build: h8af1aa0_0 + subdir: linux-aarch64 + url: https://conda.anaconda.org/conda-forge/linux-aarch64/pandoc-3.2-h8af1aa0_0.conda + sha256: aeb0736bb677db20e5c757b9f8cb1572c4df453f2806cd61f8281e0e6e32ada4 + md5: 7aaeabb3bef6483bc8437e541809027c + license: GPL-2.0-or-later + license_family: GPL + size: 22232407 + timestamp: 1715499607851 +- kind: conda + name: pandoc + version: '3.2' + build: ha770c72_0 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/pandoc-3.2-ha770c72_0.conda + sha256: 418348076c1a39170efb0bdc8a584ddd11e9ed0ff58ccd905488d3f165ca98ba + md5: 8c924f0b7f3e064b1c954a08e7c32fba + license: GPL-2.0-or-later + license_family: GPL + size: 21088628 + timestamp: 1715499623651 +- kind: conda + name: pandoc + version: '3.2' + build: hce30654_0 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/pandoc-3.2-hce30654_0.conda + sha256: f7836654ef1bb926d291c87512ff8f94bbaf1d61068bae0da13c171faf9cfd9e + md5: 8306d6d73bba59723aa360799277b014 + license: GPL-2.0-or-later + license_family: GPL + size: 22795212 + timestamp: 1715499669080 +- kind: conda + name: pandocfilters + version: 1.5.0 + build: pyhd8ed1ab_0 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/pandocfilters-1.5.0-pyhd8ed1ab_0.tar.bz2 + sha256: 2bb9ba9857f4774b85900c2562f7e711d08dd48e2add9bee4e1612fbee27e16f + md5: 457c2c8c08e54905d6954e79cb5b5db9 + depends: + - python !=3.0,!=3.1,!=3.2,!=3.3 + license: BSD-3-Clause + license_family: BSD + size: 11627 + timestamp: 1631603397334 +- kind: conda + name: pbr + version: 6.0.0 + build: pyhd8ed1ab_0 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/pbr-6.0.0-pyhd8ed1ab_0.conda + sha256: 4c83853fc6349de163c2871613e064e5fdab91723db9b50bcda681adc05e4b87 + md5: 8dbab5ba746ed14aa32cb232dc437f8f + depends: + - pip + - python >=3.6 + license: Apache-2.0 + license_family: Apache + size: 73106 + timestamp: 1699384879677 +- kind: conda + name: pep517 + version: 0.13.0 + build: pyhd8ed1ab_0 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/pep517-0.13.0-pyhd8ed1ab_0.tar.bz2 + sha256: 6a6f2fa6bc9106b2edcccc142242dc3ab1f2f77a6debbd5b480f08482f052636 + md5: d94aa03d99d8adc9898f783eba0d84d2 + depends: + - python >=3.8 + - tomli + license: MIT + license_family: MIT + size: 19044 + timestamp: 1667916747996 +- kind: conda + name: pip + version: '24.0' + build: pyhd8ed1ab_0 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/pip-24.0-pyhd8ed1ab_0.conda + sha256: b7c1c5d8f13e8cb491c4bd1d0d1896a4cf80fc47de01059ad77509112b664a4a + md5: f586ac1e56c8638b64f9c8122a7b8a67 + depends: + - python >=3.7 + - setuptools + - wheel + license: MIT + license_family: MIT + size: 1398245 + timestamp: 1706960660581 +- kind: conda + name: pkgutil-resolve-name + version: 1.3.10 + build: pyhd8ed1ab_1 + build_number: 1 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/pkgutil-resolve-name-1.3.10-pyhd8ed1ab_1.conda + sha256: fecf95377134b0e8944762d92ecf7b0149c07d8186fb5db583125a2705c7ea0a + md5: 405678b942f2481cecdb3e010f4925d9 + depends: + - python >=3.6 + license: MIT AND PSF-2.0 + size: 10778 + timestamp: 1694617398467 +- kind: conda + name: platformdirs + version: 4.2.2 + build: pyhd8ed1ab_0 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/platformdirs-4.2.2-pyhd8ed1ab_0.conda + sha256: adc59384cf0b2fc6dc7362840151e8cb076349197a38f7230278252698a88442 + md5: 6f6cf28bf8e021933869bae3f84b8fc9 + depends: + - python >=3.8 + license: MIT + license_family: MIT + size: 20572 + timestamp: 1715777739019 +- kind: conda + name: pluggy + version: 1.5.0 + build: pyhd8ed1ab_0 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/pluggy-1.5.0-pyhd8ed1ab_0.conda + sha256: 33eaa3359948a260ebccf9cdc2fd862cea5a6029783289e13602d8e634cd9a26 + md5: d3483c8fc2dc2cc3f5cf43e26d60cabf + depends: + - python >=3.8 + license: MIT + license_family: MIT + size: 23815 + timestamp: 1713667175451 +- kind: conda + name: pre-commit + version: 3.7.1 + build: pyha770c72_0 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/pre-commit-3.7.1-pyha770c72_0.conda + sha256: 689c169ce6ed5d516d8524cc1e6ef2687dff19747c1ed1ee9b347a71f47ff12d + md5: 724bc4489c1174fc8e3233b0624fa51f + depends: + - cfgv >=2.0.0 + - identify >=1.0.0 + - nodeenv >=0.11.1 + - python >=3.9 + - pyyaml >=5.1 + - virtualenv >=20.10.0 + license: MIT + license_family: MIT + size: 179748 + timestamp: 1715432871404 +- kind: conda + name: pre-commit-hooks + version: 4.6.0 + build: pyhd8ed1ab_0 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/pre-commit-hooks-4.6.0-pyhd8ed1ab_0.conda + sha256: 2d4a57474c7e2b90cc301df6197207d0812753279b2a7fae88106e0adc5d0b21 + md5: 9b353c467bcabf27ab5bae2e319c16bf + depends: + - python >=3.6 + - ruamel.yaml >=0.15 + - tomli >=1.1.0 + license: MIT + license_family: MIT + size: 34686 + timestamp: 1712432480698 +- kind: conda + name: prettier + version: 3.2.5 + build: h31abb78_0 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/prettier-3.2.5-h31abb78_0.conda + sha256: 998881927638de0d6bbed983217f194f261bf3ad56bc6aea75950db997e3894f + md5: c39304bb246986f8495cd19d57020111 + depends: + - __glibc >=2.17,<3.0.a0 + - nodejs >=20.9.0,<21.0a0 + license: MIT + license_family: MIT + size: 999015 + timestamp: 1707033152117 +- kind: conda + name: prettier + version: 3.2.5 + build: h4e45a9e_0 + subdir: linux-aarch64 + url: https://conda.anaconda.org/conda-forge/linux-aarch64/prettier-3.2.5-h4e45a9e_0.conda + sha256: 2c2c14d7b6cda57b56ca90b88c0a018c99819d8867525ecc76d6c5d579b9c8a5 + md5: 5d30d29a41d53b32679ace090d5cada1 + depends: + - nodejs >=20.9.0,<21.0a0 + license: MIT + license_family: MIT + size: 1001031 + timestamp: 1707033093064 +- kind: conda + name: prettier + version: 3.2.5 + build: h98b3114_0 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/prettier-3.2.5-h98b3114_0.conda + sha256: de088637ed01d973dbbd6ab37d30ea76fba970cdf7375d114e9db330fcc07ebb + md5: e62fb1708fa88409bc3cfcb66f172854 + depends: + - nodejs >=20.9.0,<21.0a0 + license: MIT + license_family: MIT + size: 1002255 + timestamp: 1707033279132 +- kind: conda + name: prettier + version: 3.2.5 + build: hb67532b_0 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/prettier-3.2.5-hb67532b_0.conda + sha256: 3e3f20534b72d523d74b9a2df375f551acb9364b096a09d187fcacb8e92d9c48 + md5: ba831dcb62f21f13e303d64e3076fce8 + depends: + - nodejs >=20.9.0,<21.0a0 + license: MIT + license_family: MIT + size: 1002362 + timestamp: 1707033187655 +- kind: conda + name: prettier + version: 3.2.5 + build: hbd11d21_0 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/prettier-3.2.5-hbd11d21_0.conda + sha256: 16ac0f3d9ebe08dafd773601ee7ca6903a880c94637216635d74aa6e0c0379ce + md5: fe9a3066af863ddaa13d4b86991c3a44 + depends: + - nodejs >=20.9.0,<21.0a0 + license: MIT + license_family: MIT + size: 999535 + timestamp: 1707033141882 +- kind: conda + name: protobuf + version: 4.25.3 + build: py310h1e88e72_0 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/protobuf-4.25.3-py310h1e88e72_0.conda + sha256: 09fceab9d0545c98cddb1508b7fe47647b980605b3945d968a86074548c5a76f + md5: a3b60edc6ee575ff71d8e107cea48dd0 + depends: + - libabseil * cxx17* + - libabseil >=20240116.1,<20240117.0a0 + - libcxx >=16 + - libprotobuf >=4.25.3,<4.25.4.0a0 + - python >=3.10,<3.11.0a0 + - python >=3.10,<3.11.0a0 *_cpython + - python_abi 3.10.* *_cp310 + - setuptools + license: BSD-3-Clause + license_family: BSD + size: 310787 + timestamp: 1709686391826 +- kind: conda + name: protobuf + version: 4.25.3 + build: py310h6802e18_0 + subdir: linux-aarch64 + url: https://conda.anaconda.org/conda-forge/linux-aarch64/protobuf-4.25.3-py310h6802e18_0.conda + sha256: 55c574b1942ab718e550eaad91bc611e8815eb04e78698cfd76e8ad809d8f053 + md5: 4bc0f5304b3a13c2c0a84763a445962e + depends: + - libabseil * cxx17* + - libabseil >=20240116.1,<20240117.0a0 + - libgcc-ng >=12 + - libprotobuf >=4.25.3,<4.25.4.0a0 + - libstdcxx-ng >=12 + - python >=3.10,<3.11.0a0 + - python >=3.10,<3.11.0a0 *_cpython + - python_abi 3.10.* *_cp310 + - setuptools + license: BSD-3-Clause + license_family: BSD + size: 333267 + timestamp: 1709686006646 +- kind: conda + name: protobuf + version: 4.25.3 + build: py310h9015309_0 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/protobuf-4.25.3-py310h9015309_0.conda + sha256: 71772d78033dfbc0733820b9574be73e254cb43c8f73d9f56e0764bb5c33df54 + md5: da17c79293b0bef7efda9845d8321891 + depends: + - __osx >=10.13 + - libabseil * cxx17* + - libabseil >=20240116.1,<20240117.0a0 + - libcxx >=16 + - libprotobuf >=4.25.3,<4.25.4.0a0 + - python >=3.10,<3.11.0a0 + - python_abi 3.10.* *_cp310 + - setuptools + license: BSD-3-Clause + license_family: BSD + size: 311037 + timestamp: 1709686410864 +- kind: conda + name: protobuf + version: 4.25.3 + build: py310ha8c1f0e_0 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/protobuf-4.25.3-py310ha8c1f0e_0.conda + sha256: 2da5aa342456c2f6a80ebfef9a2a8c57723e8f6c9b00a874660e49a937e8ed9b + md5: 0cee4d21cd822c598cf894d1df1657d4 + depends: + - libabseil * cxx17* + - libabseil >=20240116.1,<20240117.0a0 + - libgcc-ng >=12 + - libprotobuf >=4.25.3,<4.25.4.0a0 + - libstdcxx-ng >=12 + - python >=3.10,<3.11.0a0 + - python_abi 3.10.* *_cp310 + - setuptools + license: BSD-3-Clause + license_family: BSD + size: 332424 + timestamp: 1709685969897 +- kind: conda + name: protobuf + version: 4.25.3 + build: py310hf536535_0 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/protobuf-4.25.3-py310hf536535_0.conda + sha256: 0151cf8e3fe4e67e0e6e7faf11ed6b21177fe467da3410f7471a1cbd5ec85a5d + md5: 6685ec44bde5ddf28a58ad62f0ffb259 + depends: + - libabseil * cxx17* + - libabseil >=20240116.1,<20240117.0a0 + - libprotobuf >=4.25.3,<4.25.4.0a0 + - python >=3.10,<3.11.0a0 + - python_abi 3.10.* *_cp310 + - setuptools + - ucrt >=10.0.20348.0 + - vc >=14.2,<15 + - vc14_runtime >=14.29.30139 + license: BSD-3-Clause + license_family: BSD + size: 314709 + timestamp: 1709686491912 +- kind: conda + name: protobuf + version: 4.25.3 + build: py311h01b5fa2_0 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/protobuf-4.25.3-py311h01b5fa2_0.conda + sha256: 7543f0145d70ccf7144ef46794ef4271c3c2057394aee3010ba4b4241a6742a6 + md5: e256d9dfa0a194550d15be2aea20de3b + depends: + - __osx >=10.13 + - libabseil * cxx17* + - libabseil >=20240116.1,<20240117.0a0 + - libcxx >=16 + - libprotobuf >=4.25.3,<4.25.4.0a0 + - python >=3.11,<3.12.0a0 + - python_abi 3.11.* *_cp311 + - setuptools + license: BSD-3-Clause + license_family: BSD + size: 378791 + timestamp: 1709686486557 +- kind: conda + name: protobuf + version: 4.25.3 + build: py311h7b78aeb_0 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/protobuf-4.25.3-py311h7b78aeb_0.conda + sha256: 90eccef0b175777de1d179fc66e47af47ad0ae2bb9a949a08cc1d42b8b1ec57f + md5: fe6c263e6bd0ec098995b7cd176b0f95 + depends: + - libabseil * cxx17* + - libabseil >=20240116.1,<20240117.0a0 + - libgcc-ng >=12 + - libprotobuf >=4.25.3,<4.25.4.0a0 + - libstdcxx-ng >=12 + - python >=3.11,<3.12.0a0 + - python_abi 3.11.* *_cp311 + - setuptools + license: BSD-3-Clause + license_family: BSD + size: 399460 + timestamp: 1709685919243 +- kind: conda + name: protobuf + version: 4.25.3 + build: py311hb041b4a_0 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/protobuf-4.25.3-py311hb041b4a_0.conda + sha256: e27257d0aab5838ea3ccc4713e90912b69dfa49cbaa5f59e7f202038c0e7d6b3 + md5: f1e485893a5c4d0c85d862ff434928b3 + depends: + - libabseil * cxx17* + - libabseil >=20240116.1,<20240117.0a0 + - libprotobuf >=4.25.3,<4.25.4.0a0 + - python >=3.11,<3.12.0a0 + - python_abi 3.11.* *_cp311 + - setuptools + - ucrt >=10.0.20348.0 + - vc >=14.2,<15 + - vc14_runtime >=14.29.30139 + license: BSD-3-Clause + license_family: BSD + size: 382568 + timestamp: 1709686489093 +- kind: conda + name: protobuf + version: 4.25.3 + build: py311hea19e3d_0 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/protobuf-4.25.3-py311hea19e3d_0.conda + sha256: 5b92958d79445b82258d23725df338fc2d8e5791e8dfd853d87d132aab9425cc + md5: 5ab4584ffe61409531b56360d146301a + depends: + - libabseil * cxx17* + - libabseil >=20240116.1,<20240117.0a0 + - libcxx >=16 + - libprotobuf >=4.25.3,<4.25.4.0a0 + - python >=3.11,<3.12.0a0 + - python >=3.11,<3.12.0a0 *_cpython + - python_abi 3.11.* *_cp311 + - setuptools + license: BSD-3-Clause + license_family: BSD + size: 377277 + timestamp: 1709686346329 +- kind: conda + name: protobuf + version: 4.25.3 + build: py311hf10afa8_0 + subdir: linux-aarch64 + url: https://conda.anaconda.org/conda-forge/linux-aarch64/protobuf-4.25.3-py311hf10afa8_0.conda + sha256: d8fa19018ec4942aeca0d14ce56a722e761c3bb903e5ae9ae4f27cf8851602c0 + md5: e392e0e42b56ec1e198fe2aa36fdde77 + depends: + - libabseil * cxx17* + - libabseil >=20240116.1,<20240117.0a0 + - libgcc-ng >=12 + - libprotobuf >=4.25.3,<4.25.4.0a0 + - libstdcxx-ng >=12 + - python >=3.11,<3.12.0a0 + - python >=3.11,<3.12.0a0 *_cpython + - python_abi 3.11.* *_cp311 + - setuptools + license: BSD-3-Clause + license_family: BSD + size: 400324 + timestamp: 1709686044695 +- kind: conda + name: protobuf + version: 4.25.3 + build: py312h1a610f3_0 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/protobuf-4.25.3-py312h1a610f3_0.conda + sha256: 53cbb4ca7ba7acb84f54adae7ecebc301dc8abfaa5cb0c750ce322de82b2b47e + md5: aea352a3c501c12708c69c7546deb7e3 + depends: + - libabseil * cxx17* + - libabseil >=20240116.1,<20240117.0a0 + - libcxx >=16 + - libprotobuf >=4.25.3,<4.25.4.0a0 + - python >=3.12,<3.13.0a0 + - python >=3.12,<3.13.0a0 *_cpython + - python_abi 3.12.* *_cp312 + - setuptools + license: BSD-3-Clause + license_family: BSD + size: 368858 + timestamp: 1709686301568 +- kind: conda + name: protobuf + version: 4.25.3 + build: py312h1e6a782_0 + subdir: linux-aarch64 + url: https://conda.anaconda.org/conda-forge/linux-aarch64/protobuf-4.25.3-py312h1e6a782_0.conda + sha256: daf903e7389e789a8361160d0598749c98717dc12e70c43cf1ad2902a0fb70ee + md5: c829506abcb1fd02282ddbbdcf2d9c86 + depends: + - libabseil * cxx17* + - libabseil >=20240116.1,<20240117.0a0 + - libgcc-ng >=12 + - libprotobuf >=4.25.3,<4.25.4.0a0 + - libstdcxx-ng >=12 + - python >=3.12,<3.13.0a0 + - python >=3.12,<3.13.0a0 *_cpython + - python_abi 3.12.* *_cp312 + - setuptools + license: BSD-3-Clause + license_family: BSD + size: 390310 + timestamp: 1709686148131 +- kind: conda + name: protobuf + version: 4.25.3 + build: py312h5594109_0 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/protobuf-4.25.3-py312h5594109_0.conda + sha256: fd983a2358a08340a2495b53af8b4b51cc98a42430668b1f39547ba5b39ae957 + md5: 0800500c46ad798de471d173583f5e04 + depends: + - libabseil * cxx17* + - libabseil >=20240116.1,<20240117.0a0 + - libprotobuf >=4.25.3,<4.25.4.0a0 + - python >=3.12,<3.13.0a0 + - python_abi 3.12.* *_cp312 + - setuptools + - ucrt >=10.0.20348.0 + - vc >=14.2,<15 + - vc14_runtime >=14.29.30139 + license: BSD-3-Clause + license_family: BSD + size: 373722 + timestamp: 1709686267055 +- kind: conda + name: protobuf + version: 4.25.3 + build: py312h72fbbdf_0 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/protobuf-4.25.3-py312h72fbbdf_0.conda + sha256: 9bb6d2a6f1b1ae085eb9e3d7bea21da9583edbbc501eaf473511f7ddf0e741bd + md5: 83b85f6cee7bbdb9b5ad2f1b785234c8 + depends: + - libabseil * cxx17* + - libabseil >=20240116.1,<20240117.0a0 + - libgcc-ng >=12 + - libprotobuf >=4.25.3,<4.25.4.0a0 + - libstdcxx-ng >=12 + - python >=3.12,<3.13.0a0 + - python_abi 3.12.* *_cp312 + - setuptools + license: BSD-3-Clause + license_family: BSD + size: 391574 + timestamp: 1709685971370 +- kind: conda + name: protobuf + version: 4.25.3 + build: py312hf6c9040_0 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/protobuf-4.25.3-py312hf6c9040_0.conda + sha256: ec3894ff9b7563e5fd8a6756e0b4c252944320d091952fe499c76b4583534c73 + md5: 5e59fdfbfa2739dcaf60c91c8d40c2d4 + depends: + - __osx >=10.13 + - libabseil * cxx17* + - libabseil >=20240116.1,<20240117.0a0 + - libcxx >=16 + - libprotobuf >=4.25.3,<4.25.4.0a0 + - python >=3.12,<3.13.0a0 + - python_abi 3.12.* *_cp312 + - setuptools + license: BSD-3-Clause + license_family: BSD + size: 370786 + timestamp: 1709686452328 +- kind: conda + name: psutil + version: 5.9.8 + build: py310h2372a71_0 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/psutil-5.9.8-py310h2372a71_0.conda + sha256: f1866425aa67f3fe1e3f6e07562a4bc986fd487e01146a91eb1bdbe5ec16a836 + md5: bd19b3096442ea342c4a5208379660b1 + depends: + - libgcc-ng >=12 + - python >=3.10,<3.11.0a0 + - python_abi 3.10.* *_cp310 + license: BSD-3-Clause + license_family: BSD + size: 368328 + timestamp: 1705722544490 +- kind: conda + name: psutil + version: 5.9.8 + build: py310h8d17308_0 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/psutil-5.9.8-py310h8d17308_0.conda + sha256: f1ec2d213b2a45831ede5d794eb5c4d5adf072f24d12eb6f07df207bcc9de0fb + md5: f85b83fad1e1c12c212f27039f823138 + depends: + - python >=3.10,<3.11.0a0 + - python_abi 3.10.* *_cp310 + - ucrt >=10.0.20348.0 + - vc >=14.2,<15 + - vc14_runtime >=14.29.30139 + license: BSD-3-Clause + license_family: BSD + size: 386373 + timestamp: 1705722865736 +- kind: conda + name: psutil + version: 5.9.8 + build: py310hb299538_0 + subdir: linux-aarch64 + url: https://conda.anaconda.org/conda-forge/linux-aarch64/psutil-5.9.8-py310hb299538_0.conda + sha256: eef43ac7339881635909c27afa9457514f1840fafa7e20194808f18ca59f123f + md5: 3f89fc474876c9fd15bb3d9fd51976e6 + depends: + - libgcc-ng >=12 + - python >=3.10,<3.11.0a0 + - python >=3.10,<3.11.0a0 *_cpython + - python_abi 3.10.* *_cp310 + license: BSD-3-Clause + license_family: BSD + size: 370404 + timestamp: 1705722621461 +- kind: conda + name: psutil + version: 5.9.8 + build: py310hb372a2b_0 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/psutil-5.9.8-py310hb372a2b_0.conda + sha256: 6c52cb3ea7e9e42a9fe2e2ddf9d91093fb13f067982878edc96035601ff477c0 + md5: ec3a8263961880a89f9587670aad5c81 + depends: + - python >=3.10,<3.11.0a0 + - python_abi 3.10.* *_cp310 + license: BSD-3-Clause + license_family: BSD + size: 375259 + timestamp: 1705722685866 +- kind: conda + name: psutil + version: 5.9.8 + build: py310hd125d64_0 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/psutil-5.9.8-py310hd125d64_0.conda + sha256: 8d303673271d8a32a79956a5cf7b941a5fa4f9ef7f093a29efc871a6c8e69aa4 + md5: 0fb7c0c32b4212cc783aa315ea4fc173 + depends: + - python >=3.10,<3.11.0a0 + - python >=3.10,<3.11.0a0 *_cpython + - python_abi 3.10.* *_cp310 + license: BSD-3-Clause + license_family: BSD + size: 376671 + timestamp: 1705722806535 +- kind: conda + name: psutil + version: 5.9.8 + build: py311h05b510d_0 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/psutil-5.9.8-py311h05b510d_0.conda + sha256: 2b6e485c761fa3e7271c44a070c0d08e79a6758ac4d7a660eaff0ed0a60c6f2b + md5: 970ef0edddc6c2cfeb16b7225a28a1f4 + depends: + - python >=3.11,<3.12.0a0 + - python >=3.11,<3.12.0a0 *_cpython + - python_abi 3.11.* *_cp311 + license: BSD-3-Clause + license_family: BSD + size: 513415 + timestamp: 1705722847446 +- kind: conda + name: psutil + version: 5.9.8 + build: py311h459d7ec_0 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/psutil-5.9.8-py311h459d7ec_0.conda + sha256: 467788418a2c71fb3df9ac0a6282ae693d1070a6cb47cb59bdb529b53acaee1c + md5: 9bc62d25dcf64eec484974a3123c9d57 + depends: + - libgcc-ng >=12 + - python >=3.11,<3.12.0a0 + - python_abi 3.11.* *_cp311 + license: BSD-3-Clause + license_family: BSD + size: 505516 + timestamp: 1705722586221 +- kind: conda + name: psutil + version: 5.9.8 + build: py311ha68e1ae_0 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/psutil-5.9.8-py311ha68e1ae_0.conda + sha256: 77760f2ce0d2be9339d94d0fb5b3d102659355563f5b6471a1231525e63ff581 + md5: 17e48538806e7c682d2ffcbd5c9f9aa0 + depends: + - python >=3.11,<3.12.0a0 + - python_abi 3.11.* *_cp311 + - ucrt >=10.0.20348.0 + - vc >=14.2,<15 + - vc14_runtime >=14.29.30139 + license: BSD-3-Clause + license_family: BSD + size: 520242 + timestamp: 1705723070638 +- kind: conda + name: psutil + version: 5.9.8 + build: py311hcd402e7_0 + subdir: linux-aarch64 + url: https://conda.anaconda.org/conda-forge/linux-aarch64/psutil-5.9.8-py311hcd402e7_0.conda + sha256: d04efc76d734ac2f1e00f52e3385ba80b089becf60aaae52f0edf185ca9f69e0 + md5: 858767f880caa447ae640a991ec5ba9e + depends: + - libgcc-ng >=12 + - python >=3.11,<3.12.0a0 + - python >=3.11,<3.12.0a0 *_cpython + - python_abi 3.11.* *_cp311 + license: BSD-3-Clause + license_family: BSD + size: 506604 + timestamp: 1705722743163 +- kind: conda + name: psutil + version: 5.9.8 + build: py311he705e18_0 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/psutil-5.9.8-py311he705e18_0.conda + sha256: fcff83f4d265294b54821656a10be62421da377885ab2e9811a80eb76419b3fe + md5: 31aa294c58b3058c179a7a9593e99e18 + depends: + - python >=3.11,<3.12.0a0 + - python_abi 3.11.* *_cp311 + license: BSD-3-Clause + license_family: BSD + size: 513371 + timestamp: 1705722716862 +- kind: conda + name: psutil + version: 5.9.8 + build: py312h41838bb_0 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/psutil-5.9.8-py312h41838bb_0.conda + sha256: 12e5053d19bddaf7841e59cbe9ba98fa5d4d8502ceccddad80888515e1366107 + md5: 03926e7089a5e61b77043b470ae7b553 + depends: + - python >=3.12,<3.13.0a0 + - python_abi 3.12.* *_cp312 + license: BSD-3-Clause + license_family: BSD + size: 495162 + timestamp: 1705722685887 +- kind: conda + name: psutil + version: 5.9.8 + build: py312h98912ed_0 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/psutil-5.9.8-py312h98912ed_0.conda + sha256: 27e7f8f5d30c74439f39d61e21ac14c0cd03b5d55f7bf9f946fb619016f73c61 + md5: 3facaca6cc0f7988df3250efccd32da3 + depends: + - libgcc-ng >=12 + - python >=3.12,<3.13.0a0 + - python_abi 3.12.* *_cp312 + license: BSD-3-Clause + license_family: BSD + size: 486243 + timestamp: 1705722547420 +- kind: conda + name: psutil + version: 5.9.8 + build: py312hdd3e373_0 + subdir: linux-aarch64 + url: https://conda.anaconda.org/conda-forge/linux-aarch64/psutil-5.9.8-py312hdd3e373_0.conda + sha256: 21466ab2102ee041dc11805e0d8e7354782beccf49df2bfa366758e3ceae6c70 + md5: 1a87f588762a48fb42311b0c40fa1920 + depends: + - libgcc-ng >=12 + - python >=3.12,<3.13.0a0 + - python >=3.12,<3.13.0a0 *_cpython + - python_abi 3.12.* *_cp312 + license: BSD-3-Clause + license_family: BSD + size: 489623 + timestamp: 1705722741120 +- kind: conda + name: psutil + version: 5.9.8 + build: py312he37b823_0 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/psutil-5.9.8-py312he37b823_0.conda + sha256: a996bd5f878da264d1d3ba7fde717b0a2c158a86645efb1e899d087cca74832d + md5: cd6e99b9c5a623735161973b5f693a86 + depends: + - python >=3.12,<3.13.0a0 + - python >=3.12,<3.13.0a0 *_cpython + - python_abi 3.12.* *_cp312 + license: BSD-3-Clause + license_family: BSD + size: 499490 + timestamp: 1705722767772 +- kind: conda + name: psutil + version: 5.9.8 + build: py312he70551f_0 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/psutil-5.9.8-py312he70551f_0.conda + sha256: 36f8addb327f80da4d6bd421170ff4cf8fb570d9ee8df39372427a4e33298dca + md5: 5f2998851564bea33a159bd00e6249e8 + depends: + - python >=3.12,<3.13.0a0 + - python_abi 3.12.* *_cp312 + - ucrt >=10.0.20348.0 + - vc >=14.2,<15 + - vc14_runtime >=14.29.30139 + license: BSD-3-Clause + license_family: BSD + size: 503677 + timestamp: 1705722843679 +- kind: conda + name: pthreads-win32 + version: 2.9.1 + build: hfa6e2cd_3 + build_number: 3 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/pthreads-win32-2.9.1-hfa6e2cd_3.tar.bz2 + sha256: 576a228630a72f25d255a5e345e5f10878e153221a96560f2498040cd6f54005 + md5: e2da8758d7d51ff6aa78a14dfb9dbed4 + depends: + - vc 14.* + license: LGPL 2 + size: 144301 + timestamp: 1537755684331 +- kind: conda + name: pycparser + version: '2.22' + build: pyhd8ed1ab_0 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/pycparser-2.22-pyhd8ed1ab_0.conda + sha256: 406001ebf017688b1a1554b49127ca3a4ac4626ec0fd51dc75ffa4415b720b64 + md5: 844d9eb3b43095b031874477f7d70088 + depends: + - python >=3.8 + license: BSD-3-Clause + license_family: BSD + size: 105098 + timestamp: 1711811634025 +- kind: conda + name: pygments + version: 2.18.0 + build: pyhd8ed1ab_0 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/pygments-2.18.0-pyhd8ed1ab_0.conda + sha256: 78267adf4e76d0d64ea2ffab008c501156c108bb08fecb703816fb63e279780b + md5: b7f5c092b8f9800150d998a71b76d5a1 + depends: + - python >=3.8 + license: BSD-2-Clause + license_family: BSD + size: 879295 + timestamp: 1714846885370 +- kind: conda + name: pyreadline3 + version: 3.4.1 + build: py310h5588dad_3 + build_number: 3 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/pyreadline3-3.4.1-py310h5588dad_3.conda + sha256: 6e1d0b3b256a99b88a62ee66e9ec6d1120740a197ac1665f07ca7caaf7bf465c + md5: 8b077a59d55f903010311e125195aff7 + depends: + - python >=3.10,<3.11.0a0 + - python_abi 3.10.* *_cp310 + license: BSD-3-Clause + license_family: BSD + size: 158824 + timestamp: 1696532247316 +- kind: conda + name: pyreadline3 + version: 3.4.1 + build: py311h1ea47a8_3 + build_number: 3 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/pyreadline3-3.4.1-py311h1ea47a8_3.conda + sha256: c5d81c392bf2f7309eff87ac744de4beee4fb9d69073b27573741b6aa14afee4 + md5: e86fc6f567494744bf987c6fcd7478d3 + depends: + - python >=3.11,<3.12.0a0 + - python_abi 3.11.* *_cp311 + license: BSD-3-Clause + license_family: BSD + size: 207350 + timestamp: 1696532213432 +- kind: conda + name: pyreadline3 + version: 3.4.1 + build: py312h2e8e312_3 + build_number: 3 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/pyreadline3-3.4.1-py312h2e8e312_3.conda + sha256: e205b6c7f3564613b4cac43d5fa60fed08c98e7d787173f41823e87caa37307a + md5: ca08a170d39723d81acc8bd969c38950 + depends: + - python >=3.12,<3.13.0a0 + - python_abi 3.12.* *_cp312 + license: BSD-3-Clause + license_family: BSD + size: 201485 + timestamp: 1696532330233 +- kind: conda + name: pysocks + version: 1.7.1 + build: pyh0701188_6 + build_number: 6 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/pysocks-1.7.1-pyh0701188_6.tar.bz2 + sha256: b3a612bc887f3dd0fb7c4199ad8e342bd148cf69a9b74fd9468a18cf2bef07b7 + md5: 56cd9fe388baac0e90c7149cfac95b60 + depends: + - __win + - python >=3.8 + - win_inet_pton + license: BSD-3-Clause + license_family: BSD + size: 19348 + timestamp: 1661605138291 +- kind: conda + name: pysocks + version: 1.7.1 + build: pyha2e5f31_6 + build_number: 6 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/pysocks-1.7.1-pyha2e5f31_6.tar.bz2 + sha256: a42f826e958a8d22e65b3394f437af7332610e43ee313393d1cf143f0a2d274b + md5: 2a7de29fb590ca14b5243c4c812c8025 + depends: + - __unix + - python >=3.8 + license: BSD-3-Clause + license_family: BSD + size: 18981 + timestamp: 1661604969727 +- kind: conda + name: pytest + version: 8.2.2 + build: pyhd8ed1ab_0 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/pytest-8.2.2-pyhd8ed1ab_0.conda + sha256: 00b7a49b31cf705b59edbd96219d8a67d2b9f51a913aa059fadd921b016965cb + md5: 0f3f49c22c7ef3a1195fa61dad3c43be + depends: + - colorama + - exceptiongroup >=1.0.0rc8 + - iniconfig + - packaging + - pluggy <2.0,>=1.5 + - python >=3.8 + - tomli >=1 + constrains: + - pytest-faulthandler >=2 + license: MIT + license_family: MIT + size: 257061 + timestamp: 1717533913269 +- kind: conda + name: pytest-cov + version: 5.0.0 + build: pyhd8ed1ab_0 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/pytest-cov-5.0.0-pyhd8ed1ab_0.conda + sha256: 218306243faf3c36347131c2b36bb189daa948ac2e92c7ab52bb26cc8c157b3c + md5: c54c0107057d67ddf077751339ec2c63 + depends: + - coverage >=5.2.1 + - pytest >=4.6 + - python >=3.8 + - toml + license: MIT + license_family: MIT + size: 25507 + timestamp: 1711411153367 +- kind: conda + name: pytest-json-report + version: 1.5.0 + build: pyhd8ed1ab_0 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/pytest-json-report-1.5.0-pyhd8ed1ab_0.tar.bz2 + sha256: ed916397b9caec080b929d24c62a91654fd829b6d6569ccd573cb2aeb12e70aa + md5: 837e335fa428cf7c784ee2e80594506c + depends: + - pytest >=3.8.0 + - pytest-metadata + - python >=3.6 + license: MIT + license_family: MIT + size: 15397 + timestamp: 1647447962029 +- kind: conda + name: pytest-metadata + version: 3.1.1 + build: pyhd8ed1ab_0 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/pytest-metadata-3.1.1-pyhd8ed1ab_0.conda + sha256: 51bf04a99ad74e933fb270f52412320617f29d2014ca5cf8a03a3c5b8f37945b + md5: 52b91ecba854d55b28ad916a8b10da24 + depends: + - pytest >=7.0.0 + - python >=3.8 + license: MPL-2.0 + license_family: OTHER + size: 14577 + timestamp: 1707824772583 +- kind: conda + name: pytest-xdist + version: 3.5.0 + build: pyhd8ed1ab_0 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/pytest-xdist-3.5.0-pyhd8ed1ab_0.conda + sha256: 8dc1d422e48e5a80eb72e26ed0135bb4843cf508d3b1cb006c3257c8639784d1 + md5: d5f595da2daead898ca958ac62f0307b + depends: + - execnet >=1.1 + - pytest >=6.2.0 + - python >=3.7 + constrains: + - psutil >=3.0 + license: MIT + license_family: MIT + size: 36516 + timestamp: 1700593072448 +- kind: conda + name: python + version: 3.10.14 + build: h00d2728_0_cpython + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/python-3.10.14-h00d2728_0_cpython.conda + sha256: 00c1de2d46ede26609ef4e84a44b83be7876ba6a0215b7c83bff41a0656bf694 + md5: 0a1cddc4382c5c171e791c70740546dd + depends: + - bzip2 >=1.0.8,<2.0a0 + - libffi >=3.4,<4.0a0 + - libsqlite >=3.45.2,<4.0a0 + - libzlib >=1.2.13,<2.0.0a0 + - ncurses >=6.4.20240210,<7.0a0 + - openssl >=3.2.1,<4.0a0 + - readline >=8.2,<9.0a0 + - tk >=8.6.13,<8.7.0a0 + - tzdata + - xz >=5.2.6,<6.0a0 + constrains: + - python_abi 3.10.* *_cp310 + license: Python-2.0 + size: 11890228 + timestamp: 1710940046031 +- kind: conda + name: python + version: 3.10.14 + build: h2469fbe_0_cpython + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/python-3.10.14-h2469fbe_0_cpython.conda + sha256: 454d609fe25daedce9e886efcbfcadad103ed0362e7cb6d2bcddec90b1ecd3ee + md5: 4ae999c8227c6d8c7623d32d51d25ea9 + depends: + - bzip2 >=1.0.8,<2.0a0 + - libffi >=3.4,<4.0a0 + - libsqlite >=3.45.2,<4.0a0 + - libzlib >=1.2.13,<2.0.0a0 + - ncurses >=6.4.20240210,<7.0a0 + - openssl >=3.2.1,<4.0a0 + - readline >=8.2,<9.0a0 + - tk >=8.6.13,<8.7.0a0 + - tzdata + - xz >=5.2.6,<6.0a0 + constrains: + - python_abi 3.10.* *_cp310 + license: Python-2.0 + size: 12336005 + timestamp: 1710939659384 +- kind: conda + name: python + version: 3.10.14 + build: h4de0772_0_cpython + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/python-3.10.14-h4de0772_0_cpython.conda + sha256: 332f97d9927b65857d6d2d4d50d66dce9b37da81edb67833ae6b88ad52acbd0c + md5: 4a00e84f29d1eb418d84970598c444e1 + depends: + - bzip2 >=1.0.8,<2.0a0 + - libffi >=3.4,<4.0a0 + - libsqlite >=3.45.2,<4.0a0 + - libzlib >=1.2.13,<2.0.0a0 + - openssl >=3.2.1,<4.0a0 + - tk >=8.6.13,<8.7.0a0 + - tzdata + - vc >=14.1,<15 + - vc14_runtime >=14.16.27033 + - xz >=5.2.6,<6.0a0 + constrains: + - python_abi 3.10.* *_cp310 + license: Python-2.0 + size: 15864027 + timestamp: 1710938888352 +- kind: conda + name: python + version: 3.10.14 + build: hbbe8eec_0_cpython + subdir: linux-aarch64 + url: https://conda.anaconda.org/conda-forge/linux-aarch64/python-3.10.14-hbbe8eec_0_cpython.conda + sha256: 992583064b95d256e1b1f03581a51e225a425894d865e35ea2bf3017444c3e84 + md5: 8a8ee3a8c62032c554debc785a3b5aba + depends: + - bzip2 >=1.0.8,<2.0a0 + - ld_impl_linux-aarch64 >=2.36.1 + - libffi >=3.4,<4.0a0 + - libgcc-ng >=12 + - libnsl >=2.0.1,<2.1.0a0 + - libsqlite >=3.45.2,<4.0a0 + - libuuid >=2.38.1,<3.0a0 + - libxcrypt >=4.4.36 + - libzlib >=1.2.13,<2.0.0a0 + - ncurses >=6.4.20240210,<7.0a0 + - openssl >=3.2.1,<4.0a0 + - readline >=8.2,<9.0a0 + - tk >=8.6.13,<8.7.0a0 + - tzdata + - xz >=5.2.6,<6.0a0 + constrains: + - python_abi 3.10.* *_cp310 + license: Python-2.0 + size: 13116477 + timestamp: 1710971217224 +- kind: conda + name: python + version: 3.10.14 + build: hd12c33a_0_cpython + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/python-3.10.14-hd12c33a_0_cpython.conda + sha256: 76a5d12e73542678b70a94570f7b0f7763f9a938f77f0e75d9ea615ef22aa84c + md5: 2b4ba962994e8bd4be9ff5b64b75aff2 + depends: + - bzip2 >=1.0.8,<2.0a0 + - ld_impl_linux-64 >=2.36.1 + - libffi >=3.4,<4.0a0 + - libgcc-ng >=12 + - libnsl >=2.0.1,<2.1.0a0 + - libsqlite >=3.45.2,<4.0a0 + - libuuid >=2.38.1,<3.0a0 + - libxcrypt >=4.4.36 + - libzlib >=1.2.13,<2.0.0a0 + - ncurses >=6.4.20240210,<7.0a0 + - openssl >=3.2.1,<4.0a0 + - readline >=8.2,<9.0a0 + - tk >=8.6.13,<8.7.0a0 + - tzdata + - xz >=5.2.6,<6.0a0 + constrains: + - python_abi 3.10.* *_cp310 + license: Python-2.0 + size: 25517742 + timestamp: 1710939725109 +- kind: conda + name: python + version: 3.11.9 + build: h631f459_0_cpython + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/python-3.11.9-h631f459_0_cpython.conda + sha256: 23698d4eb24970f74911d120204318d48384fabbb25e1e57773ad74fcd38fb12 + md5: d7ed1e7c4e2dcdfd4599bd42c0613e6c + depends: + - bzip2 >=1.0.8,<2.0a0 + - libexpat >=2.6.2,<3.0a0 + - libffi >=3.4,<4.0a0 + - libsqlite >=3.45.3,<4.0a0 + - libzlib >=1.2.13,<2.0.0a0 + - openssl >=3.2.1,<4.0a0 + - tk >=8.6.13,<8.7.0a0 + - tzdata + - ucrt >=10.0.20348.0 + - vc >=14.2,<15 + - vc14_runtime >=14.29.30139 + - xz >=5.2.6,<6.0a0 + constrains: + - python_abi 3.11.* *_cp311 + license: Python-2.0 + size: 18232422 + timestamp: 1713551717924 +- kind: conda + name: python + version: 3.11.9 + build: h657bba9_0_cpython + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/python-3.11.9-h657bba9_0_cpython.conda + sha256: 3b50a5abb3b812875beaa9ab792dbd1bf44f335c64e9f9fedcf92d953995651c + md5: 612763bc5ede9552e4233ec518b9c9fb + depends: + - __osx >=10.9 + - bzip2 >=1.0.8,<2.0a0 + - libexpat >=2.6.2,<3.0a0 + - libffi >=3.4,<4.0a0 + - libsqlite >=3.45.3,<4.0a0 + - libzlib >=1.2.13,<2.0.0a0 + - ncurses >=6.4.20240210,<7.0a0 + - openssl >=3.2.1,<4.0a0 + - readline >=8.2,<9.0a0 + - tk >=8.6.13,<8.7.0a0 + - tzdata + - xz >=5.2.6,<6.0a0 + constrains: + - python_abi 3.11.* *_cp311 + license: Python-2.0 + size: 15503226 + timestamp: 1713553747073 +- kind: conda + name: python + version: 3.11.9 + build: h932a869_0_cpython + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/python-3.11.9-h932a869_0_cpython.conda + sha256: a436ceabde1f056a0ac3e347dadc780ee2a135a421ddb6e9a469370769829e3c + md5: 293e0713ae804b5527a673e7605c04fc + depends: + - __osx >=11.0 + - bzip2 >=1.0.8,<2.0a0 + - libexpat >=2.6.2,<3.0a0 + - libffi >=3.4,<4.0a0 + - libsqlite >=3.45.3,<4.0a0 + - libzlib >=1.2.13,<2.0.0a0 + - ncurses >=6.4.20240210,<7.0a0 + - openssl >=3.2.1,<4.0a0 + - readline >=8.2,<9.0a0 + - tk >=8.6.13,<8.7.0a0 + - tzdata + - xz >=5.2.6,<6.0a0 + constrains: + - python_abi 3.11.* *_cp311 + license: Python-2.0 + size: 14644189 + timestamp: 1713552154779 +- kind: conda + name: python + version: 3.11.9 + build: hb806964_0_cpython + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/python-3.11.9-hb806964_0_cpython.conda + sha256: 177f33a1fb8d3476b38f73c37b42f01c0b014fa0e039a701fd9f83d83aae6d40 + md5: ac68acfa8b558ed406c75e98d3428d7b + depends: + - bzip2 >=1.0.8,<2.0a0 + - ld_impl_linux-64 >=2.36.1 + - libexpat >=2.6.2,<3.0a0 + - libffi >=3.4,<4.0a0 + - libgcc-ng >=12 + - libnsl >=2.0.1,<2.1.0a0 + - libsqlite >=3.45.3,<4.0a0 + - libuuid >=2.38.1,<3.0a0 + - libxcrypt >=4.4.36 + - libzlib >=1.2.13,<2.0.0a0 + - ncurses >=6.4.20240210,<7.0a0 + - openssl >=3.2.1,<4.0a0 + - readline >=8.2,<9.0a0 + - tk >=8.6.13,<8.7.0a0 + - tzdata + - xz >=5.2.6,<6.0a0 + constrains: + - python_abi 3.11.* *_cp311 + license: Python-2.0 + size: 30884494 + timestamp: 1713553104915 +- kind: conda + name: python + version: 3.11.9 + build: hddfb980_0_cpython + subdir: linux-aarch64 + url: https://conda.anaconda.org/conda-forge/linux-aarch64/python-3.11.9-hddfb980_0_cpython.conda + sha256: 522ae1bc43929198e72643046e82362f80f2d70f4dbe8ac810d9ce2ba983fb2f + md5: 4846e936e27dd709ad78f91fa33a48e8 + depends: + - bzip2 >=1.0.8,<2.0a0 + - ld_impl_linux-aarch64 >=2.36.1 + - libexpat >=2.6.2,<3.0a0 + - libffi >=3.4,<4.0a0 + - libgcc-ng >=12 + - libnsl >=2.0.1,<2.1.0a0 + - libsqlite >=3.45.3,<4.0a0 + - libuuid >=2.38.1,<3.0a0 + - libxcrypt >=4.4.36 + - libzlib >=1.2.13,<2.0.0a0 + - ncurses >=6.4.20240210,<7.0a0 + - openssl >=3.2.1,<4.0a0 + - readline >=8.2,<9.0a0 + - tk >=8.6.13,<8.7.0a0 + - tzdata + - xz >=5.2.6,<6.0a0 + constrains: + - python_abi 3.11.* *_cp311 + license: Python-2.0 + size: 15304491 + timestamp: 1713551266002 +- kind: conda + name: python + version: 3.12.3 + build: h1411813_0_cpython + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/python-3.12.3-h1411813_0_cpython.conda + sha256: 3b327ffc152a245011011d1d730781577a8274fde1cf6243f073749ead8f1c2a + md5: df1448ec6cbf8eceb03d29003cf72ae6 + depends: + - __osx >=10.9 + - bzip2 >=1.0.8,<2.0a0 + - libexpat >=2.6.2,<3.0a0 + - libffi >=3.4,<4.0a0 + - libsqlite >=3.45.2,<4.0a0 + - libzlib >=1.2.13,<2.0.0a0 + - ncurses >=6.4.20240210,<7.0a0 + - openssl >=3.2.1,<4.0a0 + - readline >=8.2,<9.0a0 + - tk >=8.6.13,<8.7.0a0 + - tzdata + - xz >=5.2.6,<6.0a0 + constrains: + - python_abi 3.12.* *_cp312 + license: Python-2.0 + size: 14557341 + timestamp: 1713208068012 +- kind: conda + name: python + version: 3.12.3 + build: h2628c8c_0_cpython + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/python-3.12.3-h2628c8c_0_cpython.conda + sha256: 1a95494abe572a8819c933f978df89f00bde72ea9432d46a70632599e8029ea4 + md5: f07c8c5dd98767f9a652de5d039b284e + depends: + - bzip2 >=1.0.8,<2.0a0 + - libexpat >=2.6.2,<3.0a0 + - libffi >=3.4,<4.0a0 + - libsqlite >=3.45.2,<4.0a0 + - libzlib >=1.2.13,<2.0.0a0 + - openssl >=3.2.1,<4.0a0 + - tk >=8.6.13,<8.7.0a0 + - tzdata + - ucrt >=10.0.20348.0 + - vc >=14.2,<15 + - vc14_runtime >=14.29.30139 + - xz >=5.2.6,<6.0a0 + constrains: + - python_abi 3.12.* *_cp312 + license: Python-2.0 + size: 16179248 + timestamp: 1713205644673 +- kind: conda + name: python + version: 3.12.3 + build: h43d1f9e_0_cpython + subdir: linux-aarch64 + url: https://conda.anaconda.org/conda-forge/linux-aarch64/python-3.12.3-h43d1f9e_0_cpython.conda + sha256: e186f3ee570464241c844adff6a3ba8f395cef15c5d46c0a8f784cfd97b3bdca + md5: dc93ad1d2ba17ebc948bf5434ffa864b + depends: + - bzip2 >=1.0.8,<2.0a0 + - ld_impl_linux-aarch64 >=2.36.1 + - libexpat >=2.6.2,<3.0a0 + - libffi >=3.4,<4.0a0 + - libgcc-ng >=12 + - libnsl >=2.0.1,<2.1.0a0 + - libsqlite >=3.45.2,<4.0a0 + - libuuid >=2.38.1,<3.0a0 + - libxcrypt >=4.4.36 + - libzlib >=1.2.13,<2.0.0a0 + - ncurses >=6.4.20240210,<7.0a0 + - openssl >=3.2.1,<4.0a0 + - readline >=8.2,<9.0a0 + - tk >=8.6.13,<8.7.0a0 + - tzdata + - xz >=5.2.6,<6.0a0 + constrains: + - python_abi 3.12.* *_cp312 + license: Python-2.0 + size: 14051797 + timestamp: 1713205211165 +- kind: conda + name: python + version: 3.12.3 + build: h4a7b5fc_0_cpython + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/python-3.12.3-h4a7b5fc_0_cpython.conda + sha256: c761fb3713ea66bce3889b33b6f400afb2dd192d1fc2686446e9d8166cfcec6b + md5: 8643ab37bece6ae8f112464068d9df9c + depends: + - __osx >=11.0 + - bzip2 >=1.0.8,<2.0a0 + - libexpat >=2.6.2,<3.0a0 + - libffi >=3.4,<4.0a0 + - libsqlite >=3.45.2,<4.0a0 + - libzlib >=1.2.13,<2.0.0a0 + - ncurses >=6.4.20240210,<7.0a0 + - openssl >=3.2.1,<4.0a0 + - readline >=8.2,<9.0a0 + - tk >=8.6.13,<8.7.0a0 + - tzdata + - xz >=5.2.6,<6.0a0 + constrains: + - python_abi 3.12.* *_cp312 + license: Python-2.0 + size: 13207557 + timestamp: 1713206576646 +- kind: conda + name: python + version: 3.12.3 + build: hab00c5b_0_cpython + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/python-3.12.3-hab00c5b_0_cpython.conda + sha256: f9865bcbff69f15fd89a33a2da12ad616e98d65ce7c83c644b92e66e5016b227 + md5: 2540b74d304f71d3e89c81209db4db84 + depends: + - bzip2 >=1.0.8,<2.0a0 + - ld_impl_linux-64 >=2.36.1 + - libexpat >=2.6.2,<3.0a0 + - libffi >=3.4,<4.0a0 + - libgcc-ng >=12 + - libnsl >=2.0.1,<2.1.0a0 + - libsqlite >=3.45.2,<4.0a0 + - libuuid >=2.38.1,<3.0a0 + - libxcrypt >=4.4.36 + - libzlib >=1.2.13,<2.0.0a0 + - ncurses >=6.4.20240210,<7.0a0 + - openssl >=3.2.1,<4.0a0 + - readline >=8.2,<9.0a0 + - tk >=8.6.13,<8.7.0a0 + - tzdata + - xz >=5.2.6,<6.0a0 + constrains: + - python_abi 3.12.* *_cp312 + license: Python-2.0 + size: 31991381 + timestamp: 1713208036041 +- kind: conda + name: python-dateutil + version: 2.9.0 + build: pyhd8ed1ab_0 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/python-dateutil-2.9.0-pyhd8ed1ab_0.conda + sha256: f3ceef02ac164a8d3a080d0d32f8e2ebe10dd29e3a685d240e38b3599e146320 + md5: 2cf4264fffb9e6eff6031c5b6884d61c + depends: + - python >=3.7 + - six >=1.5 + license: Apache-2.0 + license_family: APACHE + size: 222742 + timestamp: 1709299922152 +- kind: conda + name: python-fastjsonschema + version: 2.19.1 + build: pyhd8ed1ab_0 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/python-fastjsonschema-2.19.1-pyhd8ed1ab_0.conda + sha256: 38b2db169d65cc5595e3ce63294c4fdb6a242ecf71f70b3ad8cad3bd4230d82f + md5: 4d3ceee3af4b0f9a1f48f57176bf8625 + depends: + - python >=3.3 + license: BSD-3-Clause + license_family: BSD + size: 225250 + timestamp: 1703781171097 +- kind: conda + name: python-flatbuffers + version: 24.3.25 + build: pyh59ac667_0 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/python-flatbuffers-24.3.25-pyh59ac667_0.conda + sha256: 6a9d285fef959480eccbc69e276ede64e292c8eee35ddc727d5a0fb9a4bcc3a2 + md5: dfc884dcd61ff6543fde37a41b7d7f31 + depends: + - python >=3.6 + license: Apache-2.0 + license_family: Apache + size: 34336 + timestamp: 1711466847930 +- kind: conda + name: python_abi + version: '3.10' + build: 4_cp310 + build_number: 4 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/python_abi-3.10-4_cp310.conda + sha256: 456bec815bfc2b364763084d08b412fdc4c17eb9ccc66a36cb775fa7ac3cbaec + md5: 26322ec5d7712c3ded99dd656142b8ce + constrains: + - python 3.10.* *_cpython + license: BSD-3-Clause + license_family: BSD + size: 6398 + timestamp: 1695147363189 +- kind: conda + name: python_abi + version: '3.10' + build: 4_cp310 + build_number: 4 + subdir: linux-aarch64 + url: https://conda.anaconda.org/conda-forge/linux-aarch64/python_abi-3.10-4_cp310.conda + sha256: 9191cc3ddf380b655c08b3436a8174ce0cc798a6dfcfa8ee80fa793d0b7165de + md5: b0ff2ed109650f9e90d627d3119eb442 + constrains: + - python 3.10.* *_cpython + license: BSD-3-Clause + license_family: BSD + size: 6436 + timestamp: 1695147402616 +- kind: conda + name: python_abi + version: '3.10' + build: 4_cp310 + build_number: 4 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/python_abi-3.10-4_cp310.conda + sha256: abc26b3b5a62f9c8112a2303d24b0c590d5f7fc9470521f5a520472d59c2223e + md5: b15c816c5a86abcc4d1458dd63aa4c65 + constrains: + - python 3.10.* *_cpython + license: BSD-3-Clause + license_family: BSD + size: 6484 + timestamp: 1695147705581 +- kind: conda + name: python_abi + version: '3.10' + build: 4_cp310 + build_number: 4 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/python_abi-3.10-4_cp310.conda + sha256: f69bac2f28082a275ef67313968b2c366d8236c3a6869b9cdf5cdb97a5821812 + md5: 1a3d9c6bb5f0b1b22d9e9296c127e8c7 + constrains: + - python 3.10.* *_cpython + license: BSD-3-Clause + license_family: BSD + size: 6490 + timestamp: 1695147522999 +- kind: conda + name: python_abi + version: '3.10' + build: 4_cp310 + build_number: 4 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/python_abi-3.10-4_cp310.conda + sha256: 19066c462fd0e32c64503c688f77cb603beb4019b812caf855d03f2a5447960b + md5: b41195997c14fb7473d26637ea4c3946 + constrains: + - python 3.10.* *_cpython + license: BSD-3-Clause + license_family: BSD + size: 6773 + timestamp: 1695147715814 +- kind: conda + name: python_abi + version: '3.11' + build: 4_cp311 + build_number: 4 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/python_abi-3.11-4_cp311.conda + sha256: 0be3ac1bf852d64f553220c7e6457e9c047dfb7412da9d22fbaa67e60858b3cf + md5: d786502c97404c94d7d58d258a445a65 + constrains: + - python 3.11.* *_cpython + license: BSD-3-Clause + license_family: BSD + size: 6385 + timestamp: 1695147338551 +- kind: conda + name: python_abi + version: '3.11' + build: 4_cp311 + build_number: 4 + subdir: linux-aarch64 + url: https://conda.anaconda.org/conda-forge/linux-aarch64/python_abi-3.11-4_cp311.conda + sha256: 135a21de5721a2667613529b4ac50a9454979bf969fa99d74b6e5ad9a4ff284d + md5: 89983f987dfee288f94ddb2ee550ea60 + constrains: + - python 3.11.* *_cpython + license: BSD-3-Clause + license_family: BSD + size: 6384 + timestamp: 1695147390555 +- kind: conda + name: python_abi + version: '3.11' + build: 4_cp311 + build_number: 4 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/python_abi-3.11-4_cp311.conda + sha256: f56dfe2a57b3b27bad3f9527f943548e8b2526e949d9d6fc0a383020d9359afe + md5: fef7a52f0eca6bae9e8e2e255bc86394 + constrains: + - python 3.11.* *_cpython + license: BSD-3-Clause + license_family: BSD + size: 6478 + timestamp: 1695147518012 +- kind: conda + name: python_abi + version: '3.11' + build: 4_cp311 + build_number: 4 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/python_abi-3.11-4_cp311.conda + sha256: 4837089c477b9b84fa38a17f453e6634e68237267211b27a8a2f5ccd847f4e55 + md5: 8d3751bc73d3bbb66f216fa2331d5649 + constrains: + - python 3.11.* *_cpython + license: BSD-3-Clause + license_family: BSD + size: 6492 + timestamp: 1695147509940 +- kind: conda + name: python_abi + version: '3.11' + build: 4_cp311 + build_number: 4 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/python_abi-3.11-4_cp311.conda + sha256: 67c2aade3e2160642eec0742384e766b20c766055e3d99335681e3e05d88ed7b + md5: 70513332c71b56eace4ee6441e66c012 + constrains: + - python 3.11.* *_cpython + license: BSD-3-Clause + license_family: BSD + size: 6755 + timestamp: 1695147711935 +- kind: conda + name: python_abi + version: '3.12' + build: 4_cp312 + build_number: 4 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/python_abi-3.12-4_cp312.conda + sha256: 182a329de10a4165f6e8a3804caf751f918f6ea6176dd4e5abcdae1ed3095bf6 + md5: dccc2d142812964fcc6abdc97b672dff + constrains: + - python 3.12.* *_cpython + license: BSD-3-Clause + license_family: BSD + size: 6385 + timestamp: 1695147396604 +- kind: conda + name: python_abi + version: '3.12' + build: 4_cp312 + build_number: 4 + subdir: linux-aarch64 + url: https://conda.anaconda.org/conda-forge/linux-aarch64/python_abi-3.12-4_cp312.conda + sha256: 4f4c3389b722cac9bf39183221332ab69e468351030ec5359042b50c5d975a15 + md5: 6c09f8e580146d88f649780cebed01de + constrains: + - python 3.12.* *_cpython + license: BSD-3-Clause + license_family: BSD + size: 6417 + timestamp: 1695147418374 +- kind: conda + name: python_abi + version: '3.12' + build: 4_cp312 + build_number: 4 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/python_abi-3.12-4_cp312.conda + sha256: 82c154d95c1637604671a02a89e72f1382e89a4269265a03506496bd928f6f14 + md5: 87201ac4314b911b74197e588cca3639 + constrains: + - python 3.12.* *_cpython + license: BSD-3-Clause + license_family: BSD + size: 6496 + timestamp: 1695147498447 +- kind: conda + name: python_abi + version: '3.12' + build: 4_cp312 + build_number: 4 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/python_abi-3.12-4_cp312.conda + sha256: db25428e4f24f8693ffa39f3ff6dfbb8fd53bc298764b775b57edab1c697560f + md5: bbb3a02c78b2d8219d7213f76d644a2a + constrains: + - python 3.12.* *_cpython + license: BSD-3-Clause + license_family: BSD + size: 6508 + timestamp: 1695147497048 +- kind: conda + name: python_abi + version: '3.12' + build: 4_cp312 + build_number: 4 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/python_abi-3.12-4_cp312.conda + sha256: 488f8519d04b48f59bd6fde21ebe2d7a527718ff28aac86a8b53aa63658bdef6 + md5: 17f4ccf6be9ded08bd0a376f489ac1a6 + constrains: + - python 3.12.* *_cpython + license: BSD-3-Clause + license_family: BSD + size: 6785 + timestamp: 1695147430513 +- kind: conda + name: pytz + version: '2024.1' + build: pyhd8ed1ab_0 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/pytz-2024.1-pyhd8ed1ab_0.conda + sha256: 1a7d6b233f7e6e3bbcbad054c8fd51e690a67b129a899a056a5e45dd9f00cb41 + md5: 3eeeeb9e4827ace8c0c1419c85d590ad + depends: + - python >=3.7 + license: MIT + license_family: MIT + size: 188538 + timestamp: 1706886944988 +- kind: conda + name: pywin32 + version: '306' + build: py310h00ffb61_2 + build_number: 2 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/pywin32-306-py310h00ffb61_2.conda + sha256: 24fd15c118974da18c38870380195e633d2452a7fb7dbc0ecb96b44416989b33 + md5: a65056c5f52aa83455577958872e4776 + depends: + - python >=3.10,<3.11.0a0 + - python_abi 3.10.* *_cp310 + - ucrt >=10.0.20348.0 + - vc >=14.2,<15 + - vc14_runtime >=14.29.30139 + license: PSF-2.0 + license_family: PSF + size: 5689476 + timestamp: 1695974437046 +- kind: conda + name: pyyaml + version: 6.0.1 + build: py312h02f2b3b_1 + build_number: 1 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/pyyaml-6.0.1-py312h02f2b3b_1.conda + sha256: b6b4027b89c17b9bbd8089aec3e44bc29f802a7d5668d5a75b5358d7ed9705ca + md5: a0c843e52a1c4422d8657dd76e9eb994 + depends: + - python >=3.12.0rc3,<3.13.0a0 + - python >=3.12.0rc3,<3.13.0a0 *_cpython + - python_abi 3.12.* *_cp312 + - yaml >=0.2.5,<0.3.0a0 + license: MIT + license_family: MIT + size: 182705 + timestamp: 1695373895409 +- kind: conda + name: pyyaml + version: 6.0.1 + build: py312h104f124_1 + build_number: 1 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/pyyaml-6.0.1-py312h104f124_1.conda + sha256: 04aa180782cb675b960c0bf4aad439b4a7a08553c6af74d0b8e5df9a0c7cc4f4 + md5: 260ed90aaf06061edabd7209638cf03b + depends: + - python >=3.12.0rc3,<3.13.0a0 + - python_abi 3.12.* *_cp312 + - yaml >=0.2.5,<0.3.0a0 + license: MIT + license_family: MIT + size: 185636 + timestamp: 1695373742454 +- kind: conda + name: pyyaml + version: 6.0.1 + build: py312h98912ed_1 + build_number: 1 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/pyyaml-6.0.1-py312h98912ed_1.conda + sha256: 7f347a10a7121b08d79d21cd4f438c07c23479ea0c74dfb89d6dc416f791bb7f + md5: e3fd78d8d490af1d84763b9fe3f2e552 + depends: + - libgcc-ng >=12 + - python >=3.12.0rc3,<3.13.0a0 + - python_abi 3.12.* *_cp312 + - yaml >=0.2.5,<0.3.0a0 + license: MIT + license_family: MIT + size: 196583 + timestamp: 1695373632212 +- kind: conda + name: pyyaml + version: 6.0.1 + build: py312hdd3e373_1 + build_number: 1 + subdir: linux-aarch64 + url: https://conda.anaconda.org/conda-forge/linux-aarch64/pyyaml-6.0.1-py312hdd3e373_1.conda + sha256: fa340199dd5e6f9a27af535066caa9a95ee66f3f75d8f3a8966e2541d48f052a + md5: 6955fe2d94dfdeda4690876d01437af1 + depends: + - libgcc-ng >=12 + - python >=3.12.0rc3,<3.13.0a0 + - python >=3.12.0rc3,<3.13.0a0 *_cpython + - python_abi 3.12.* *_cp312 + - yaml >=0.2.5,<0.3.0a0 + license: MIT + license_family: MIT + size: 186843 + timestamp: 1695373817252 +- kind: conda + name: pyyaml + version: 6.0.1 + build: py312he70551f_1 + build_number: 1 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/pyyaml-6.0.1-py312he70551f_1.conda + sha256: a72fa8152791b4738432f270e70b3a9a4d583ef059a78aa1c62f4b4ab7b15494 + md5: f91e0baa89ba21166916624ba7bfb422 + depends: + - python >=3.12.0rc3,<3.13.0a0 + - python_abi 3.12.* *_cp312 + - ucrt >=10.0.20348.0 + - vc >=14.2,<15 + - vc14_runtime >=14.29.30139 + - yaml >=0.2.5,<0.3.0a0 + license: MIT + license_family: MIT + size: 167932 + timestamp: 1695374097139 +- kind: conda + name: pyzmq + version: 26.0.3 + build: py310h16e08c9_0 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/pyzmq-26.0.3-py310h16e08c9_0.conda + sha256: ab68d301d71f6520e42b3cc808a69b101c3b2697832f205b346de185761d847f + md5: 0788836c393aef2b46851f83416fd0d7 + depends: + - __osx >=11.0 + - libcxx >=16 + - libsodium >=1.0.18,<1.0.19.0a0 + - python >=3.10,<3.11.0a0 + - python >=3.10,<3.11.0a0 *_cpython + - python_abi 3.10.* *_cp310 + - zeromq >=4.3.5,<4.4.0a0 + license: BSD-3-Clause + license_family: BSD + size: 366478 + timestamp: 1715024599862 +- kind: conda + name: pyzmq + version: 26.0.3 + build: py310h656833d_0 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/pyzmq-26.0.3-py310h656833d_0.conda + sha256: 2e582fd6637243d751bd1cbc76ccb4b82aeecaa5c10dc6d493de67cbfde5b64c + md5: 8add222e6a146d96ac213db83d854f7d + depends: + - libsodium >=1.0.18,<1.0.19.0a0 + - python >=3.10,<3.11.0a0 + - python_abi 3.10.* *_cp310 + - ucrt >=10.0.20348.0 + - vc >=14.2,<15 + - vc14_runtime >=14.29.30139 + - zeromq >=4.3.5,<4.3.6.0a0 + license: BSD-3-Clause + license_family: BSD + size: 368528 + timestamp: 1715025077475 +- kind: conda + name: pyzmq + version: 26.0.3 + build: py310h6883aea_0 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/pyzmq-26.0.3-py310h6883aea_0.conda + sha256: 64a1b5362c070ccae0687651dee40987540e43d4a968a41b3de85f7fd8ef340d + md5: af2e86793164f8bd11e892142d0faa4c + depends: + - libgcc-ng >=12 + - libsodium >=1.0.18,<1.0.19.0a0 + - libstdcxx-ng >=12 + - python >=3.10,<3.11.0a0 + - python_abi 3.10.* *_cp310 + - zeromq >=4.3.5,<4.4.0a0 + license: BSD-3-Clause + license_family: BSD + size: 388466 + timestamp: 1715024604414 +- kind: conda + name: pyzmq + version: 26.0.3 + build: py310he0bbd50_0 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/pyzmq-26.0.3-py310he0bbd50_0.conda + sha256: ddd28309169d61af6109c9d61392b4b035c1a2633a0bf1c58f1638c1a3870382 + md5: b4481c0107ab67a37e8b7b218689d865 + depends: + - __osx >=10.9 + - libcxx >=16 + - libsodium >=1.0.18,<1.0.19.0a0 + - python >=3.10,<3.11.0a0 + - python_abi 3.10.* *_cp310 + - zeromq >=4.3.5,<4.4.0a0 + license: BSD-3-Clause + license_family: BSD + size: 366807 + timestamp: 1715024677564 +- kind: conda + name: pyzmq + version: 26.0.3 + build: py310he875deb_0 + subdir: linux-aarch64 + url: https://conda.anaconda.org/conda-forge/linux-aarch64/pyzmq-26.0.3-py310he875deb_0.conda + sha256: 18a89a643f2cd05cdb4d89e04a3d00e5ddab6b3a691e4bf2379d387bbe7b7072 + md5: 390d0405bbbc188786a4ec6bb80ef0db + depends: + - libgcc-ng >=12 + - libsodium >=1.0.18,<1.0.19.0a0 + - libstdcxx-ng >=12 + - python >=3.10,<3.11.0a0 + - python_abi 3.10.* *_cp310 + - zeromq >=4.3.5,<4.4.0a0 + license: BSD-3-Clause + license_family: BSD + size: 383688 + timestamp: 1715026769554 +- kind: conda + name: rapidfuzz + version: 3.9.3 + build: py312h275cf98_0 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/rapidfuzz-3.9.3-py312h275cf98_0.conda + sha256: b45118c0119cf3b44e6f3311a22fa2af4e8722a599b6d59614de3c9ad1fc56ea + md5: 8e96b09d0841b78e9658d92eb77fa22f + depends: + - numpy + - python >=3.12,<3.13.0a0 + - python_abi 3.12.* *_cp312 + - ucrt >=10.0.20348.0 + - vc >=14.2,<15 + - vc14_runtime >=14.29.30139 + license: MIT + license_family: MIT + size: 1071073 + timestamp: 1717233199645 +- kind: conda + name: rapidfuzz + version: 3.9.3 + build: py312h28f332c_0 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/rapidfuzz-3.9.3-py312h28f332c_0.conda + sha256: 3bb79ffa13349a24e0d1d31b73b7c2ed730586279122fa99a46e1df5b4b0df1b + md5: b463bd2a68da3d26d431dcbe8ccecd49 + depends: + - __osx >=10.13 + - libcxx >=16 + - numpy + - python >=3.12,<3.13.0a0 + - python_abi 3.12.* *_cp312 + license: MIT + license_family: MIT + size: 1100909 + timestamp: 1717232777745 +- kind: conda + name: rapidfuzz + version: 3.9.3 + build: py312h5c2e7bc_0 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/rapidfuzz-3.9.3-py312h5c2e7bc_0.conda + sha256: f9eae0906e2112e67a5613411650939038654cca82558b80537cc27ec3ac32fb + md5: c892e97f7b96905a1ee7944757231244 + depends: + - __osx >=11.0 + - libcxx >=16 + - numpy + - python >=3.12,<3.13.0a0 + - python >=3.12,<3.13.0a0 *_cpython + - python_abi 3.12.* *_cp312 + license: MIT + license_family: MIT + size: 829694 + timestamp: 1717232844879 +- kind: conda + name: rapidfuzz + version: 3.9.3 + build: py312h7070661_0 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/rapidfuzz-3.9.3-py312h7070661_0.conda + sha256: ebb7a1a6b77a2e618edbcd07a256e2bc33b2099ed10b9a368ec79cc18c92689a + md5: 711cd7e9cd093d5f82c6bf8a6bdb844d + depends: + - libgcc-ng >=12 + - libstdcxx-ng >=12 + - numpy + - python >=3.12,<3.13.0a0 + - python_abi 3.12.* *_cp312 + license: MIT + license_family: MIT + size: 2203869 + timestamp: 1717232790275 +- kind: conda + name: rapidfuzz + version: 3.9.3 + build: py312h7f10901_0 + subdir: linux-aarch64 + url: https://conda.anaconda.org/conda-forge/linux-aarch64/rapidfuzz-3.9.3-py312h7f10901_0.conda + sha256: 7457e7f62ae9fde0703b16337ae083fb5ce527ee98376a5af0b4988afd683e97 + md5: d803201930954215b89458581a2b2cba + depends: + - libgcc-ng >=12 + - libstdcxx-ng >=12 + - numpy + - python >=3.12,<3.13.0a0 + - python >=3.12,<3.13.0a0 *_cpython + - python_abi 3.12.* *_cp312 + license: MIT + license_family: MIT + size: 1026860 + timestamp: 1717232710330 +- kind: conda + name: readline + version: '8.2' + build: h8228510_1 + build_number: 1 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/readline-8.2-h8228510_1.conda + sha256: 5435cf39d039387fbdc977b0a762357ea909a7694d9528ab40f005e9208744d7 + md5: 47d31b792659ce70f470b5c82fdfb7a4 + depends: + - libgcc-ng >=12 + - ncurses >=6.3,<7.0a0 + license: GPL-3.0-only + license_family: GPL + size: 281456 + timestamp: 1679532220005 +- kind: conda + name: readline + version: '8.2' + build: h8fc344f_1 + build_number: 1 + subdir: linux-aarch64 + url: https://conda.anaconda.org/conda-forge/linux-aarch64/readline-8.2-h8fc344f_1.conda + sha256: 4c99f7417419734e3797d45bc355e61c26520e111893b0d7087a01a7fbfbe3dd + md5: 105eb1e16bf83bfb2eb380a48032b655 + depends: + - libgcc-ng >=12 + - ncurses >=6.3,<7.0a0 + license: GPL-3.0-only + license_family: GPL + size: 294092 + timestamp: 1679532238805 +- kind: conda + name: readline + version: '8.2' + build: h92ec313_1 + build_number: 1 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/readline-8.2-h92ec313_1.conda + sha256: a1dfa679ac3f6007362386576a704ad2d0d7a02e98f5d0b115f207a2da63e884 + md5: 8cbb776a2f641b943d413b3e19df71f4 + depends: + - ncurses >=6.3,<7.0a0 + license: GPL-3.0-only + license_family: GPL + size: 250351 + timestamp: 1679532511311 +- kind: conda + name: readline + version: '8.2' + build: h9e318b2_1 + build_number: 1 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/readline-8.2-h9e318b2_1.conda + sha256: 41e7d30a097d9b060037f0c6a2b1d4c4ae7e942c06c943d23f9d481548478568 + md5: f17f77f2acf4d344734bda76829ce14e + depends: + - ncurses >=6.3,<7.0a0 + license: GPL-3.0-only + license_family: GPL + size: 255870 + timestamp: 1679532707590 +- kind: conda + name: referencing + version: 0.35.1 + build: pyhd8ed1ab_0 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/referencing-0.35.1-pyhd8ed1ab_0.conda + sha256: be8d6d9e86b1a3fef5424127ff81782f8ca63d3058980859609f6f1ecdd34cb3 + md5: 0fc8b52192a8898627c3efae1003e9f6 + depends: + - attrs >=22.2.0 + - python >=3.8 + - rpds-py >=0.7.0 + license: MIT + license_family: MIT + size: 42210 + timestamp: 1714619625532 +- kind: conda + name: requests + version: 2.32.3 + build: pyhd8ed1ab_0 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/requests-2.32.3-pyhd8ed1ab_0.conda + sha256: 5845ffe82a6fa4d437a2eae1e32a1ad308d7ad349f61e337c0a890fe04c513cc + md5: 5ede4753180c7a550a443c430dc8ab52 + depends: + - certifi >=2017.4.17 + - charset-normalizer >=2,<4 + - idna >=2.5,<4 + - python >=3.8 + - urllib3 >=1.21.1,<3 + constrains: + - chardet >=3.0.2,<6 + license: Apache-2.0 + license_family: APACHE + size: 58810 + timestamp: 1717057174842 +- kind: conda + name: rpds-py + version: 0.18.1 + build: py310h12a1ced_0 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/rpds-py-0.18.1-py310h12a1ced_0.conda + sha256: 1500458267537dc11c60eae5f7cf3a1b973d94c92f6718e4d5e615a9fea39266 + md5: 82511d28b7e8ffb6369a8455c49b1e63 + depends: + - __osx >=10.13 + - python >=3.10,<3.11.0a0 + - python_abi 3.10.* *_cp310 + constrains: + - __osx >=10.12 + license: MIT + license_family: MIT + size: 299110 + timestamp: 1715090304154 +- kind: conda + name: rpds-py + version: 0.18.1 + build: py310h59d1b7a_0 + subdir: linux-aarch64 + url: https://conda.anaconda.org/conda-forge/linux-aarch64/rpds-py-0.18.1-py310h59d1b7a_0.conda + sha256: 68ebe8cfd173c531f9e59d95822d4b97868eeabe75f1b6fd62ab15dc6a082500 + md5: ec03aa185dcb6b208ebcf81647e23fa5 + depends: + - libgcc-ng >=12 + - python >=3.10,<3.11.0a0 + - python_abi 3.10.* *_cp310 + license: MIT + license_family: MIT + size: 916129 + timestamp: 1715092354933 +- kind: conda + name: rpds-py + version: 0.18.1 + build: py310h947b723_0 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/rpds-py-0.18.1-py310h947b723_0.conda + sha256: 72f85b2851573b03b7af113dd86fe615bbf722e8d2bc2a6ff7d2591abcc50b1d + md5: dd3c552f3b52bc446338cd4c9faba7cb + depends: + - __osx >=11.0 + - python >=3.10,<3.11.0a0 + - python >=3.10,<3.11.0a0 *_cpython + - python_abi 3.10.* *_cp310 + constrains: + - __osx >=11.0 + license: MIT + license_family: MIT + size: 295376 + timestamp: 1715090488703 +- kind: conda + name: rpds-py + version: 0.18.1 + build: py310hc226416_0 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/rpds-py-0.18.1-py310hc226416_0.conda + sha256: 2f2b04233ac47bd701578ac7a51788c9d43861c1975e0a73cd6e83e15c6d351f + md5: cd1b4ba9096e55bc26dd46d2d1e27370 + depends: + - python >=3.10,<3.11.0a0 + - python_abi 3.10.* *_cp310 + - ucrt >=10.0.20348.0 + - vc >=14.2,<15 + - vc14_runtime >=14.29.30139 + license: MIT + license_family: MIT + size: 206495 + timestamp: 1715090887196 +- kind: conda + name: rpds-py + version: 0.18.1 + build: py310he421c4c_0 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/rpds-py-0.18.1-py310he421c4c_0.conda + sha256: b67df53e705727af50ddabafe2e97d827e5c60400359c979e8215f4fc0589ad7 + md5: f12c9d4fccaae5cfc7f22adb0a71506f + depends: + - libgcc-ng >=12 + - python >=3.10,<3.11.0a0 + - python_abi 3.10.* *_cp310 + license: MIT + license_family: MIT + size: 920937 + timestamp: 1715090194460 +- kind: conda + name: ruamel.yaml + version: 0.18.6 + build: py310h2372a71_0 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/ruamel.yaml-0.18.6-py310h2372a71_0.conda + sha256: 37581cbd99eb8855b6d268c85d189d723dd4fa1f9d115b8a633bed6dea4c370e + md5: 50b7d9b39099cdbabf65bf27df73a793 + depends: + - libgcc-ng >=12 + - python >=3.10,<3.11.0a0 + - python_abi 3.10.* *_cp310 + - ruamel.yaml.clib >=0.1.2 + license: MIT + license_family: MIT + size: 203692 + timestamp: 1707298326808 +- kind: conda + name: ruamel.yaml + version: 0.18.6 + build: py310h8d17308_0 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/ruamel.yaml-0.18.6-py310h8d17308_0.conda + sha256: 7c6f8954918242e84934af51eaa7d1464e391f6e3f24f52652e18256cfe663b0 + md5: b1117979e43fa36aab602b0b95bc07f2 + depends: + - python >=3.10,<3.11.0a0 + - python_abi 3.10.* *_cp310 + - ruamel.yaml.clib >=0.1.2 + - ucrt >=10.0.20348.0 + - vc >=14.2,<15 + - vc14_runtime >=14.29.30139 + license: MIT + license_family: MIT + size: 203921 + timestamp: 1707298493499 +- kind: conda + name: ruamel.yaml + version: 0.18.6 + build: py310hb299538_0 + subdir: linux-aarch64 + url: https://conda.anaconda.org/conda-forge/linux-aarch64/ruamel.yaml-0.18.6-py310hb299538_0.conda + sha256: 8da85c92767fcdfac00c8dc5f2725cbdeaa14c165761511b5c5ddd84188f9bcb + md5: 6112045712a11a44624c7c18e8f9ce65 + depends: + - libgcc-ng >=12 + - python >=3.10,<3.11.0a0 + - python >=3.10,<3.11.0a0 *_cpython + - python_abi 3.10.* *_cp310 + - ruamel.yaml.clib >=0.1.2 + license: MIT + license_family: MIT + size: 203470 + timestamp: 1707298454135 +- kind: conda + name: ruamel.yaml + version: 0.18.6 + build: py310hb372a2b_0 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/ruamel.yaml-0.18.6-py310hb372a2b_0.conda + sha256: 6b8700746c15be00d6a63391a69dc20078c19a93136a065658b34710815868ae + md5: a6691c80f3bf62bc0df37b87caac6a70 + depends: + - python >=3.10,<3.11.0a0 + - python_abi 3.10.* *_cp310 + - ruamel.yaml.clib >=0.1.2 + license: MIT + license_family: MIT + size: 203655 + timestamp: 1707298514456 +- kind: conda + name: ruamel.yaml + version: 0.18.6 + build: py310hd125d64_0 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/ruamel.yaml-0.18.6-py310hd125d64_0.conda + sha256: 65e89da67ec766fcb8c5ff22ab3623dd6f7c81fccf699766c252e5623bf81797 + md5: 122d1d9bab6c74cebc0f17736a705e32 + depends: + - python >=3.10,<3.11.0a0 + - python >=3.10,<3.11.0a0 *_cpython + - python_abi 3.10.* *_cp310 + - ruamel.yaml.clib >=0.1.2 + license: MIT + license_family: MIT + size: 203617 + timestamp: 1707298718718 +- kind: conda + name: ruamel.yaml + version: 0.18.6 + build: py312h41838bb_0 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/ruamel.yaml-0.18.6-py312h41838bb_0.conda + sha256: 27ab446d39a46f7db365265a48ce74929c672e14c86b1ce8955f59e2d92dff39 + md5: 9db93e711729ec70dacdfa58bf970cfd + depends: + - python >=3.12,<3.13.0a0 + - python_abi 3.12.* *_cp312 + - ruamel.yaml.clib >=0.1.2 + license: MIT + license_family: MIT + size: 268460 + timestamp: 1707298596313 +- kind: conda + name: ruamel.yaml + version: 0.18.6 + build: py312h98912ed_0 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/ruamel.yaml-0.18.6-py312h98912ed_0.conda + sha256: 26856daba883254736b7f3767c08f445b5d010eebbf4fc7aa384ee80e24aa663 + md5: a99a06a875138829ef65f44bbe2c30ca + depends: + - libgcc-ng >=12 + - python >=3.12,<3.13.0a0 + - python_abi 3.12.* *_cp312 + - ruamel.yaml.clib >=0.1.2 + license: MIT + license_family: MIT + size: 268015 + timestamp: 1707298336196 +- kind: conda + name: ruamel.yaml + version: 0.18.6 + build: py312hdd3e373_0 + subdir: linux-aarch64 + url: https://conda.anaconda.org/conda-forge/linux-aarch64/ruamel.yaml-0.18.6-py312hdd3e373_0.conda + sha256: d8576e72fec57ff9c4806fbcd6d336395652a3a3c1667bba6fc742e208a6dbdd + md5: 675a11ab58c2461d33d37275d117dcd2 + depends: + - libgcc-ng >=12 + - python >=3.12,<3.13.0a0 + - python >=3.12,<3.13.0a0 *_cpython + - python_abi 3.12.* *_cp312 + - ruamel.yaml.clib >=0.1.2 + license: MIT + license_family: MIT + size: 268146 + timestamp: 1707298453178 +- kind: conda + name: ruamel.yaml + version: 0.18.6 + build: py312he37b823_0 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/ruamel.yaml-0.18.6-py312he37b823_0.conda + sha256: 4a27b50445842e97a31e3f412816d4a0d576b4f1ee327b9a892a183ba5c60f6f + md5: cb9f9b4797001b2c52383f4007fa1f4b + depends: + - python >=3.12,<3.13.0a0 + - python >=3.12,<3.13.0a0 *_cpython + - python_abi 3.12.* *_cp312 + - ruamel.yaml.clib >=0.1.2 + license: MIT + license_family: MIT + size: 268637 + timestamp: 1707298502612 +- kind: conda + name: ruamel.yaml + version: 0.18.6 + build: py312he70551f_0 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/ruamel.yaml-0.18.6-py312he70551f_0.conda + sha256: 31a9e347107a46149ae334586430bebb3a769bb5792eba9ccb89c664dbce7970 + md5: 5833ba75a49ac40876242ccb5f77ab23 + depends: + - python >=3.12,<3.13.0a0 + - python_abi 3.12.* *_cp312 + - ruamel.yaml.clib >=0.1.2 + - ucrt >=10.0.20348.0 + - vc >=14.2,<15 + - vc14_runtime >=14.29.30139 + license: MIT + license_family: MIT + size: 267762 + timestamp: 1707298539404 +- kind: conda + name: ruamel.yaml.clib + version: 0.2.8 + build: py310h2372a71_0 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/ruamel.yaml.clib-0.2.8-py310h2372a71_0.conda + sha256: cfcb1b4528074684b2e339b6854320f42a03e7545ff1944ef8262e0130e5c6c8 + md5: dcf6d2535586c77b31425ed835610c54 + depends: + - libgcc-ng >=12 + - python >=3.10,<3.11.0a0 + - python_abi 3.10.* *_cp310 + license: MIT + license_family: MIT + size: 136172 + timestamp: 1707314637100 +- kind: conda + name: ruamel.yaml.clib + version: 0.2.8 + build: py310h8d17308_0 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/ruamel.yaml.clib-0.2.8-py310h8d17308_0.conda + sha256: 7ea7e20e777d2bccc5df44d68efa9da6540f917863e84d03d2e5757b76a94f26 + md5: 3f4173b2fe24f282b7c03e684a4579c4 + depends: + - python >=3.10,<3.11.0a0 + - python_abi 3.10.* *_cp310 + - ucrt >=10.0.20348.0 + - vc >=14.2,<15 + - vc14_runtime >=14.29.30139 + license: MIT + license_family: MIT + size: 99742 + timestamp: 1707315298946 +- kind: conda + name: ruamel.yaml.clib + version: 0.2.8 + build: py310hb299538_0 + subdir: linux-aarch64 + url: https://conda.anaconda.org/conda-forge/linux-aarch64/ruamel.yaml.clib-0.2.8-py310hb299538_0.conda + sha256: a17f10db68af72d637d62053192a799767f261257b2d0f9784dd042b486c2908 + md5: 9e5cbedd93166a986927571b869d4e6c + depends: + - libgcc-ng >=12 + - python >=3.10,<3.11.0a0 + - python >=3.10,<3.11.0a0 *_cpython + - python_abi 3.10.* *_cp310 + license: MIT + license_family: MIT + size: 129419 + timestamp: 1707314842727 +- kind: conda + name: ruamel.yaml.clib + version: 0.2.8 + build: py310hb372a2b_0 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/ruamel.yaml.clib-0.2.8-py310hb372a2b_0.conda + sha256: 76535acf0bbefbbfeeca68bc732e4b8eea7526f0ef2090f2bdcf0283ec4b3738 + md5: a6254db88b5bf45d4870c3a63dc39e8d + depends: + - python >=3.10,<3.11.0a0 + - python_abi 3.10.* *_cp310 + license: MIT + license_family: MIT + size: 118488 + timestamp: 1707314814452 +- kind: conda + name: ruamel.yaml.clib + version: 0.2.8 + build: py310hd125d64_0 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/ruamel.yaml.clib-0.2.8-py310hd125d64_0.conda + sha256: 83b27f5dafd201a9408886ff18af6ccdde45e748c934fce588a4b531cdd249d5 + md5: e0b9a24f19622386be17bf9f29674e81 + depends: + - python >=3.10,<3.11.0a0 + - python >=3.10,<3.11.0a0 *_cpython + - python_abi 3.10.* *_cp310 + license: MIT + license_family: MIT + size: 111512 + timestamp: 1707315215965 +- kind: conda + name: ruamel.yaml.clib + version: 0.2.8 + build: py312h41838bb_0 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/ruamel.yaml.clib-0.2.8-py312h41838bb_0.conda + sha256: c0a321d14505b3621d6301e1ed9bc0129b4c8b2812e7520040d2609aaeb07845 + md5: a134bf1778eb7add92ea760e801dc245 + depends: + - python >=3.12,<3.13.0a0 + - python_abi 3.12.* *_cp312 + license: MIT + license_family: MIT + size: 118650 + timestamp: 1707314908121 +- kind: conda + name: ruamel.yaml.clib + version: 0.2.8 + build: py312h98912ed_0 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/ruamel.yaml.clib-0.2.8-py312h98912ed_0.conda + sha256: 5965302881d8b1049291e3ba3912286cdc72cb82303230cbbf0a048c6f6dd7c1 + md5: 05f31c2a79ba61df8d6d903ce4a4ce7b + depends: + - libgcc-ng >=12 + - python >=3.12,<3.13.0a0 + - python_abi 3.12.* *_cp312 + license: MIT + license_family: MIT + size: 135640 + timestamp: 1707314642857 +- kind: conda + name: ruamel.yaml.clib + version: 0.2.8 + build: py312hdd3e373_0 + subdir: linux-aarch64 + url: https://conda.anaconda.org/conda-forge/linux-aarch64/ruamel.yaml.clib-0.2.8-py312hdd3e373_0.conda + sha256: d6d59cb7f978b80ed061447a51c992dfd23e443ab754612cb621f3f38b338830 + md5: 7d6fe36395d184fd7cfa4469c722339f + depends: + - libgcc-ng >=12 + - python >=3.12,<3.13.0a0 + - python >=3.12,<3.13.0a0 *_cpython + - python_abi 3.12.* *_cp312 + license: MIT + license_family: MIT + size: 127157 + timestamp: 1707314746829 +- kind: conda + name: ruamel.yaml.clib + version: 0.2.8 + build: py312he37b823_0 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/ruamel.yaml.clib-0.2.8-py312he37b823_0.conda + sha256: c3138824f484cca2804d22758c75965b578cd35b35243ff02e64da06bda03477 + md5: 2fa02324046cfcb7a67fae30fd06a945 + depends: + - python >=3.12,<3.13.0a0 + - python >=3.12,<3.13.0a0 *_cpython + - python_abi 3.12.* *_cp312 + license: MIT + license_family: MIT + size: 111221 + timestamp: 1707315016121 +- kind: conda + name: ruamel.yaml.clib + version: 0.2.8 + build: py312he70551f_0 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/ruamel.yaml.clib-0.2.8-py312he70551f_0.conda + sha256: 7d5705ee3190a5b1c24eee2def964cc1d70b9e856488d971f0fd6df0224ca666 + md5: f8de34a829b65a8e3ac6ddc61ed0d2e0 + depends: + - python >=3.12,<3.13.0a0 + - python_abi 3.12.* *_cp312 + - ucrt >=10.0.20348.0 + - vc >=14.2,<15 + - vc14_runtime >=14.29.30139 + license: MIT + license_family: MIT + size: 96333 + timestamp: 1707315306489 +- kind: conda + name: ruff + version: 0.4.8 + build: py312h18b2cab_0 + subdir: linux-aarch64 + url: https://conda.anaconda.org/conda-forge/linux-aarch64/ruff-0.4.8-py312h18b2cab_0.conda + sha256: 9cdb7abd42049e1c8e7b22a7456d2333fe429f0d7bb4b7589d795412a67ba925 + md5: c355d4c6dfb45a2697d0b458172fab87 + depends: + - libgcc-ng >=12 + - libstdcxx-ng >=12 + - python >=3.12,<3.13.0a0 + - python >=3.12,<3.13.0a0 *_cpython + - python_abi 3.12.* *_cp312 + license: MIT + license_family: MIT + size: 6080287 + timestamp: 1717617848970 +- kind: conda + name: ruff + version: 0.4.8 + build: py312h3402d49_0 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/ruff-0.4.8-py312h3402d49_0.conda + sha256: 68336bcc2b484f0a8255cff3a91acc7a0f075b49555238aac78f5ad37d8debe1 + md5: 6377beaf840a4af64f84c6ae7225fbff + depends: + - __osx >=11.0 + - libcxx >=16 + - python >=3.12,<3.13.0a0 + - python >=3.12,<3.13.0a0 *_cpython + - python_abi 3.12.* *_cp312 + constrains: + - __osx >=11.0 + license: MIT + license_family: MIT + size: 5887500 + timestamp: 1717618169193 +- kind: conda + name: ruff + version: 0.4.8 + build: py312h5715c7c_0 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/ruff-0.4.8-py312h5715c7c_0.conda + sha256: f07735cc40d935dee11bba7c855a7ad52ccf7b56c880292b743f135c77ba9b21 + md5: f6ceac9020200cf58545d3bcf94657ff + depends: + - libgcc-ng >=12 + - libstdcxx-ng >=12 + - python >=3.12,<3.13.0a0 + - python_abi 3.12.* *_cp312 + license: MIT + license_family: MIT + size: 6367071 + timestamp: 1717617541850 +- kind: conda + name: ruff + version: 0.4.8 + build: py312h7a6832a_0 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/ruff-0.4.8-py312h7a6832a_0.conda + sha256: 6628d1762f4e314f0a44e51e2c57bdf383c2e9106c995563606e3cabfd03b101 + md5: 311e1713f7ef19b7ec2b9cc98b9b264e + depends: + - python >=3.12,<3.13.0a0 + - python_abi 3.12.* *_cp312 + - ucrt >=10.0.20348.0 + - vc >=14.2,<15 + - vc14_runtime >=14.29.30139 + license: MIT + license_family: MIT + size: 6266759 + timestamp: 1717618966802 +- kind: conda + name: ruff + version: 0.4.8 + build: py312h8b25c6c_0 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/ruff-0.4.8-py312h8b25c6c_0.conda + sha256: 38e9281da98a014db028afabd8fe1d14249581fcf77aacb6cfe6c01938a9d37a + md5: 8a8a0e2830d64aafad5f432f881eba97 + depends: + - __osx >=10.13 + - libcxx >=16 + - python >=3.12,<3.13.0a0 + - python_abi 3.12.* *_cp312 + constrains: + - __osx >=10.12 + license: MIT + license_family: MIT + size: 6147815 + timestamp: 1717617914383 +- kind: conda + name: setuptools + version: 70.0.0 + build: pyhd8ed1ab_0 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/setuptools-70.0.0-pyhd8ed1ab_0.conda + sha256: daa4638d288cfdf3b0ecea395d8efa25cafc4ebf4026464a36c797c84541d2be + md5: c8ddb4f34a208df4dd42509a0f6a1c89 + depends: + - python >=3.8 + license: MIT + license_family: MIT + size: 483015 + timestamp: 1716368141661 +- kind: conda + name: setuptools-scm + version: 8.1.0 + build: pyhd8ed1ab_0 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/setuptools-scm-8.1.0-pyhd8ed1ab_0.conda + sha256: 3f7b45c90eaa1c9e7ef974d3995a98a37f7672b40e002455baf0fce256e7f202 + md5: ba9f7f0ec4f2a18de3e7bce67c4a431e + depends: + - packaging >=20.0 + - python >=3.8 + - setuptools >=45 + - tomli >=1.0.0 + - typing-extensions + license: MIT + license_family: MIT + size: 37824 + timestamp: 1715083339319 +- kind: conda + name: six + version: 1.16.0 + build: pyh6c4a22f_0 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/six-1.16.0-pyh6c4a22f_0.tar.bz2 + sha256: a85c38227b446f42c5b90d9b642f2c0567880c15d72492d8da074a59c8f91dd6 + md5: e5f25f8dbc060e9a8d912e432202afc2 + depends: + - python + license: MIT + license_family: MIT + size: 14259 + timestamp: 1620240338595 +- kind: conda + name: snowballstemmer + version: 2.2.0 + build: pyhd8ed1ab_0 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/snowballstemmer-2.2.0-pyhd8ed1ab_0.tar.bz2 + sha256: a0fd916633252d99efb6223b1050202841fa8d2d53dacca564b0ed77249d3228 + md5: 4d22a9315e78c6827f806065957d566e + depends: + - python >=2 + license: BSD-3-Clause + license_family: BSD + size: 58824 + timestamp: 1637143137377 +- kind: conda + name: sortedcontainers + version: 2.4.0 + build: pyhd8ed1ab_0 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/sortedcontainers-2.4.0-pyhd8ed1ab_0.tar.bz2 + sha256: 0cea408397d50c2afb2d25e987ebac4546ae11e549d65b1403d80dc368dfaaa6 + md5: 6d6552722448103793743dabfbda532d + depends: + - python >=2.7 + license: Apache-2.0 + license_family: APACHE + size: 26314 + timestamp: 1621217159824 +- kind: conda + name: soupsieve + version: '2.5' + build: pyhd8ed1ab_1 + build_number: 1 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/soupsieve-2.5-pyhd8ed1ab_1.conda + sha256: 54ae221033db8fbcd4998ccb07f3c3828b4d77e73b0c72b18c1d6a507059059c + md5: 3f144b2c34f8cb5a9abd9ed23a39c561 + depends: + - python >=3.8 + license: MIT + license_family: MIT + size: 36754 + timestamp: 1693929424267 +- kind: conda + name: sphinx + version: 5.0.0 + build: pyh6c4a22f_1 + build_number: 1 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/sphinx-5.0.0-pyh6c4a22f_1.tar.bz2 + sha256: fcbaaa7513cdf2f80bcb3e042016dc8a1bbd978ce87774efc2b4f20a849cf7d5 + md5: a7cc4b9c94548ff9a19b368f975e5404 + depends: + - alabaster >=0.7,<0.8 + - babel >=1.3 + - colorama >=0.3.5 + - docutils >=0.14,<0.19 + - imagesize + - importlib-metadata >=4.4 + - jinja2 >=2.3 + - packaging + - pygments >=2.0 + - python >=3.6 + - requests >=2.5.0 + - snowballstemmer >=1.1 + - sphinxcontrib-applehelp + - sphinxcontrib-devhelp + - sphinxcontrib-htmlhelp >=2.0.0 + - sphinxcontrib-jsmath + - sphinxcontrib-qthelp + - sphinxcontrib-serializinghtml >=1.1.5 + license: BSD-2-Clause + license_family: BSD + size: 1642660 + timestamp: 1653904787442 +- kind: conda + name: sphinx-autodoc-typehints + version: 1.19.2 + build: pyhd8ed1ab_0 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/sphinx-autodoc-typehints-1.19.2-pyhd8ed1ab_0.tar.bz2 + sha256: 089c8c9529e9c04dd9f31171a0ea43e967ac2b6ebfea0ff0529740a96d8b453c + md5: f30d82b96c9a4f40679479edfcb62c54 + depends: + - python >=3.7 + - sphinx >=4.5 + license: MIT + license_family: MIT + size: 16045 + timestamp: 1659955412567 +- kind: conda + name: sphinx-jinja2-compat + version: 0.2.0.post1 + build: pyhd8ed1ab_0 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/sphinx-jinja2-compat-0.2.0.post1-pyhd8ed1ab_0.conda + sha256: 47095a65a6be2d7dd10ec7b203ca159f247372f6201b25d5e4a5c60831034d9e + md5: 3c9d8ab77b74d614117447b4b1dbe7e1 + depends: + - jinja2 >=2.10 + - markupsafe >=1 + - python >=3.6 + license: MIT + license_family: MIT + size: 11604 + timestamp: 1700688565577 +- kind: conda + name: sphinx-prompt + version: 1.4.0 + build: pyhd8ed1ab_0 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/sphinx-prompt-1.4.0-pyhd8ed1ab_0.tar.bz2 + sha256: 3690b4b70322adc77f18c2b31545ddbbe69f1627de76ea9deace8c9809550bab + md5: 88ee91e8679603f2a5bd036d52919cc2 + depends: + - pygments + - python >=3.0 + - sphinx + license: BSD-3-Clause + license_family: BSD + size: 8196 + timestamp: 1616424811736 +- kind: conda + name: sphinx-tabs + version: 3.4.1 + build: pyhd8ed1ab_1 + build_number: 1 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/sphinx-tabs-3.4.1-pyhd8ed1ab_1.conda + sha256: 43c343edc9ea11ffd947d97fa60bf6347a404700e2cde81fb954e60b7e6a42c1 + md5: 8b8362d876396fd967cbb5f404def907 + depends: + - docutils >=0.18.0 + - pygments + - python >=3.6 + - sphinx >=2 + license: MIT + license_family: MIT + size: 15026 + timestamp: 1675342588275 +- kind: conda + name: sphinx-toolbox + version: 3.5.0 + build: pyhd8ed1ab_0 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/sphinx-toolbox-3.5.0-pyhd8ed1ab_0.conda + sha256: 06bb5894fb8ea284d4f159b2dbc057bbffd39e6e911732fc0f5666dc5bd707dd + md5: 183b733c7adcceb72984366cb0586d4c + depends: + - apeye >=0.4.0 + - autodocsumm >=0.2.0 + - beautifulsoup4 >=4.9.1 + - cachecontrol >=0.13.0 + - dict2css >=0.2.3 + - docutils >=0.16 + - domdf-python-tools >=2.9.0 + - filelock >=3.8.0 + - html5lib >=1.1 + - python >=3.7 + - ruamel.yaml >=0.16.12 + - sphinx >=3.2.0 + - sphinx-autodoc-typehints >=1.11.1 + - sphinx-jinja2-compat >=0.1.0 + - sphinx-prompt >=1.1.0 + - sphinx-tabs <3.5.0,>=1.2.1 + - tabulate >=0.8.7 + - typing-extensions !=3.10.0.1,>=3.7.4.3 + - typing_inspect >=0.6.0 + license: MIT + license_family: MIT + size: 96017 + timestamp: 1712739365366 +- kind: conda + name: sphinx_rtd_theme + version: 2.0.0 + build: pyha770c72_0 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/sphinx_rtd_theme-2.0.0-pyha770c72_0.conda + sha256: 8545c806d03092fd0236db6663c88036eab2dc99e34c91cd36c0704db03b148a + md5: baf6d9a33df1a789ca55e3b404c7ea28 + depends: + - docutils <0.21 + - python >=3.6 + - sphinx >=5,<8 + - sphinxcontrib-jquery >=4,<5 + license: MIT + license_family: MIT + size: 2614217 + timestamp: 1701183633165 +- kind: conda + name: sphinxcontrib-apidoc + version: 0.3.0 + build: py_1 + build_number: 1 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/sphinxcontrib-apidoc-0.3.0-py_1.tar.bz2 + sha256: 6dd136a86576c400b0bdbfffbdba4a35015846a0a7eb1129a1401a17d4f60b19 + md5: 855b087883443abb10f5faf6eef40860 + depends: + - pbr + - python + license: BSD-2-Clause + license_family: BSD + size: 10555 + timestamp: 1553967001880 +- kind: conda + name: sphinxcontrib-applehelp + version: 1.0.8 + build: pyhd8ed1ab_0 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/sphinxcontrib-applehelp-1.0.8-pyhd8ed1ab_0.conda + sha256: 710013443a063518d587d2af82299e92ab6d6695edf35a676ac3a0ccc9e3f8e6 + md5: 611a35a27914fac3aa37611a6fe40bb5 + depends: + - python >=3.9 + - sphinx >=5 + license: BSD-2-Clause + license_family: BSD + size: 29539 + timestamp: 1705126465971 +- kind: conda + name: sphinxcontrib-devhelp + version: 1.0.6 + build: pyhd8ed1ab_0 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/sphinxcontrib-devhelp-1.0.6-pyhd8ed1ab_0.conda + sha256: 63a6b60653ef13a6712848f4b3c4b713d4b564da1dae571893f1a3659cde85f3 + md5: d7e4954df0d3aea2eacc7835ad12671d + depends: + - python >=3.9 + - sphinx >=5 + license: BSD-2-Clause + license_family: BSD + size: 24474 + timestamp: 1705126153592 +- kind: conda + name: sphinxcontrib-htmlhelp + version: 2.0.5 + build: pyhd8ed1ab_0 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/sphinxcontrib-htmlhelp-2.0.5-pyhd8ed1ab_0.conda + sha256: 512f393cfe34cb3de96ade7a7ad900d6278e2087a1f0e5732aa60fadee396d99 + md5: 7e1e7437273682ada2ed5e9e9714b140 + depends: + - python >=3.9 + - sphinx >=5 + license: BSD-2-Clause + license_family: BSD + size: 33499 + timestamp: 1705118297318 +- kind: conda + name: sphinxcontrib-jquery + version: '4.1' + build: pyhd8ed1ab_0 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/sphinxcontrib-jquery-4.1-pyhd8ed1ab_0.conda + sha256: 2e5f16a2d58f9a31443ffbb8ce3852cfccf533a6349045828cd2e994ef0679ca + md5: 914897066d5873acfb13e75705276ad1 + depends: + - python >=2.7 + - sphinx >=1.8 + license: 0BSD AND MIT + size: 112985 + timestamp: 1678809100921 +- kind: conda + name: sphinxcontrib-jsmath + version: 1.0.1 + build: pyhd8ed1ab_0 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/sphinxcontrib-jsmath-1.0.1-pyhd8ed1ab_0.conda + sha256: d4337d83b8edba688547766fc80f1ac86d6ec86ceeeda93f376acc04079c5ce2 + md5: da1d979339e2714c30a8e806a33ec087 + depends: + - python >=3.5 + license: BSD-2-Clause + license_family: BSD + size: 10431 + timestamp: 1691604844204 +- kind: conda + name: sphinxcontrib-qthelp + version: 1.0.7 + build: pyhd8ed1ab_0 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/sphinxcontrib-qthelp-1.0.7-pyhd8ed1ab_0.conda + sha256: dd35b52f056c39081cd0ae01155174277af579b69e5d83798a33e9056ec78d63 + md5: 26acae54b06f178681bfb551760f5dd1 + depends: + - python >=3.9 + - sphinx >=5 + license: BSD-2-Clause + license_family: BSD + size: 27005 + timestamp: 1705126340442 +- kind: conda + name: sphinxcontrib-serializinghtml + version: 1.1.10 + build: pyhd8ed1ab_0 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/sphinxcontrib-serializinghtml-1.1.10-pyhd8ed1ab_0.conda + sha256: bf80e4c0ff97d5e8e5f6db0831ba60007e820a3a438e8f1afd868aa516d67d6f + md5: e507335cb4ca9cff4c3d0fa9cdab255e + depends: + - python >=3.9 + - sphinx >=5 + license: BSD-2-Clause + license_family: BSD + size: 28776 + timestamp: 1705118378942 +- kind: conda + name: spox + version: 0.12.0 + build: pyhd8ed1ab_0 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/spox-0.12.0-pyhd8ed1ab_0.conda + sha256: a13c8bf23c90e98b02bc9eea47ff73cb5a86a181d8add61e31ebda9610c75292 + md5: ff89e75ab2ac7cfecbecee376304e6d4 + depends: + - numpy + - onnx >=1.13 + - packaging + - python >=3.8.0 + license: BSD-3-Clause + license_family: BSD + size: 140627 + timestamp: 1715885353084 +- kind: conda + name: sympy + version: '1.12' + build: pyh04b8f61_3 + build_number: 3 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/sympy-1.12-pyh04b8f61_3.conda + sha256: 75b525ecb0948380796f519fe723470d52f9369e23c68f194c28f34df5e49b39 + md5: 6af285473a6a49ea8068e0b5b28ed7de + depends: + - mpmath >=0.19 + - python >=3.8 + license: BSD-3-Clause + license_family: BSD + size: 4243034 + timestamp: 1684180691391 +- kind: conda + name: sympy + version: '1.12' + build: pypyh9d50eac_103 + build_number: 103 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/sympy-1.12-pypyh9d50eac_103.conda + sha256: 0025dd4e6411423903bf478d1b9fbff0cbbbe546f51c9375dfd6729ef2e1a1ac + md5: 2f7d6347d7acf6edf1ac7f2189f44c8f + depends: + - __unix + - gmpy2 >=2.0.8 + - mpmath >=0.19 + - python * *_cpython + - python >=3.8 + license: BSD-3-Clause + license_family: BSD + size: 4256289 + timestamp: 1684180689319 +- kind: conda + name: tabulate + version: 0.9.0 + build: pyhd8ed1ab_1 + build_number: 1 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/tabulate-0.9.0-pyhd8ed1ab_1.tar.bz2 + sha256: f6e4a0dd24ba060a4af69ca79d32361a6678e61d78c73eb5e357909b025b4620 + md5: 4759805cce2d914c38472f70bf4d8bcb + depends: + - python >=3.7 + license: MIT + license_family: MIT + size: 35912 + timestamp: 1665138565317 +- kind: conda + name: tbb + version: 2021.12.0 + build: hc790b64_1 + build_number: 1 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/tbb-2021.12.0-hc790b64_1.conda + sha256: 87461c83a4f0d4f119af7368f20c47bbe0c27d963a7c22a3d08c71075077f855 + md5: e98333643abc739ebea1bac97a479828 + depends: + - libhwloc >=2.10.0,<2.10.1.0a0 + - ucrt >=10.0.20348.0 + - vc >=14.2,<15 + - vc14_runtime >=14.29.30139 + license: Apache-2.0 + license_family: APACHE + size: 161771 + timestamp: 1716031112705 +- kind: conda + name: tinycss2 + version: 1.3.0 + build: pyhd8ed1ab_0 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/tinycss2-1.3.0-pyhd8ed1ab_0.conda + sha256: bc55e5899e66805589c02061e315bfc23ae6cc2f2811f5cc13fb189a5ed9d90f + md5: 8662629d9a05f9cff364e31ca106c1ac + depends: + - python >=3.5 + - webencodings >=0.4 + license: BSD-3-Clause + license_family: BSD + size: 25405 + timestamp: 1713975078735 +- kind: conda + name: tk + version: 8.6.13 + build: h194ca79_0 + subdir: linux-aarch64 + url: https://conda.anaconda.org/conda-forge/linux-aarch64/tk-8.6.13-h194ca79_0.conda + sha256: 7fa27cc512d3a783f38bd16bbbffc008807372499d5b65d089a8e43bde9db267 + md5: f75105e0585851f818e0009dd1dde4dc + depends: + - libgcc-ng >=12 + - libzlib >=1.2.13,<2.0.0a0 + license: TCL + license_family: BSD + size: 3351802 + timestamp: 1695506242997 +- kind: conda + name: tk + version: 8.6.13 + build: h1abcd95_1 + build_number: 1 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/tk-8.6.13-h1abcd95_1.conda + sha256: 30412b2e9de4ff82d8c2a7e5d06a15f4f4fef1809a72138b6ccb53a33b26faf5 + md5: bf830ba5afc507c6232d4ef0fb1a882d + depends: + - libzlib >=1.2.13,<2.0.0a0 + license: TCL + license_family: BSD + size: 3270220 + timestamp: 1699202389792 +- kind: conda + name: tk + version: 8.6.13 + build: h5083fa2_1 + build_number: 1 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/tk-8.6.13-h5083fa2_1.conda + sha256: 72457ad031b4c048e5891f3f6cb27a53cb479db68a52d965f796910e71a403a8 + md5: b50a57ba89c32b62428b71a875291c9b + depends: + - libzlib >=1.2.13,<2.0.0a0 + license: TCL + license_family: BSD + size: 3145523 + timestamp: 1699202432999 +- kind: conda + name: tk + version: 8.6.13 + build: h5226925_1 + build_number: 1 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/tk-8.6.13-h5226925_1.conda + sha256: 2c4e914f521ccb2718946645108c9bd3fc3216ba69aea20c2c3cedbd8db32bb1 + md5: fc048363eb8f03cd1737600a5d08aafe + depends: + - ucrt >=10.0.20348.0 + - vc >=14.2,<15 + - vc14_runtime >=14.29.30139 + license: TCL + license_family: BSD + size: 3503410 + timestamp: 1699202577803 +- kind: conda + name: tk + version: 8.6.13 + build: noxft_h4845f30_101 + build_number: 101 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/tk-8.6.13-noxft_h4845f30_101.conda + sha256: e0569c9caa68bf476bead1bed3d79650bb080b532c64a4af7d8ca286c08dea4e + md5: d453b98d9c83e71da0741bb0ff4d76bc + depends: + - libgcc-ng >=12 + - libzlib >=1.2.13,<2.0.0a0 + license: TCL + license_family: BSD + size: 3318875 + timestamp: 1699202167581 +- kind: conda + name: toml + version: 0.10.2 + build: pyhd8ed1ab_0 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/toml-0.10.2-pyhd8ed1ab_0.tar.bz2 + sha256: f0f3d697349d6580e4c2f35ba9ce05c65dc34f9f049e85e45da03800b46139c1 + md5: f832c45a477c78bebd107098db465095 + depends: + - python >=2.7 + license: MIT + license_family: MIT + size: 18433 + timestamp: 1604308660817 +- kind: conda + name: tomli + version: 2.0.1 + build: pyhd8ed1ab_0 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/tomli-2.0.1-pyhd8ed1ab_0.tar.bz2 + sha256: 4cd48aba7cd026d17e86886af48d0d2ebc67ed36f87f6534f4b67138f5a5a58f + md5: 5844808ffab9ebdb694585b50ba02a96 + depends: + - python >=3.7 + license: MIT + license_family: MIT + size: 15940 + timestamp: 1644342331069 +- kind: conda + name: tornado + version: 6.4.1 + build: py310h03727f4_0 + subdir: linux-aarch64 + url: https://conda.anaconda.org/conda-forge/linux-aarch64/tornado-6.4.1-py310h03727f4_0.conda + sha256: c86d63d62ae38c545281958ad1e68a6ddd98c09d4f47879568f03fc1e5e188f4 + md5: 92e196159f87f3029f44fca35158d6e8 + depends: + - libgcc-ng >=12 + - python >=3.10,<3.11.0a0 + - python_abi 3.10.* *_cp310 + license: Apache-2.0 + license_family: Apache + size: 654396 + timestamp: 1717724618984 +- kind: conda + name: tornado + version: 6.4.1 + build: py310h936d840_0 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/tornado-6.4.1-py310h936d840_0.conda + sha256: 359da31bfb4bce1befbb2c60f0c59e93b2b10f89101a488a418d88b8cf963d84 + md5: ccb739e6a032172c69acc0efe05e4ac6 + depends: + - __osx >=10.13 + - python >=3.10,<3.11.0a0 + - python_abi 3.10.* *_cp310 + license: Apache-2.0 + license_family: Apache + size: 651964 + timestamp: 1717722798715 +- kind: conda + name: tornado + version: 6.4.1 + build: py310ha6dd24b_0 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/tornado-6.4.1-py310ha6dd24b_0.conda + sha256: 3f8b58e663d615e80c41fe278a5866a4ed7da07a6bddd510996cf9dfb0b2c5cb + md5: f04ca9be818f2673dce1a7e572872979 + depends: + - __osx >=11.0 + - python >=3.10,<3.11.0a0 + - python >=3.10,<3.11.0a0 *_cpython + - python_abi 3.10.* *_cp310 + license: Apache-2.0 + license_family: Apache + size: 651957 + timestamp: 1717722900580 +- kind: conda + name: tornado + version: 6.4.1 + build: py310ha8f682b_0 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/tornado-6.4.1-py310ha8f682b_0.conda + sha256: 3835993b73c51cc2182e6db7e02ff8e789a15a6c99d58b3b5201fd9b2d7819df + md5: 3a4766af5964f09e907838d42447c098 + depends: + - python >=3.10,<3.11.0a0 + - python_abi 3.10.* *_cp310 + - ucrt >=10.0.20348.0 + - vc >=14.2,<15 + - vc14_runtime >=14.29.30139 + license: Apache-2.0 + license_family: Apache + size: 653198 + timestamp: 1717723134108 +- kind: conda + name: tornado + version: 6.4.1 + build: py310hc51659f_0 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/tornado-6.4.1-py310hc51659f_0.conda + sha256: a7475a82b31221c327ab9892b63a8da97d48572af6c11d894746600af31ffbc5 + md5: c5a6aac4a1e0989986d9f06b3c2be2a0 + depends: + - libgcc-ng >=12 + - python >=3.10,<3.11.0a0 + - python_abi 3.10.* *_cp310 + license: Apache-2.0 + license_family: Apache + size: 652717 + timestamp: 1717722929287 +- kind: conda + name: traitlets + version: 5.14.3 + build: pyhd8ed1ab_0 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/traitlets-5.14.3-pyhd8ed1ab_0.conda + sha256: 8a64fa0f19022828513667c2c7176cfd125001f3f4b9bc00d33732e627dd2592 + md5: 3df84416a021220d8b5700c613af2dc5 + depends: + - python >=3.8 + license: BSD-3-Clause + license_family: BSD + size: 110187 + timestamp: 1713535244513 +- kind: conda + name: typing-extensions + version: 4.12.2 + build: hd8ed1ab_0 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/typing-extensions-4.12.2-hd8ed1ab_0.conda + sha256: d3b9a8ed6da7c9f9553c5fd8a4fca9c3e0ab712fa5f497859f82337d67533b73 + md5: 52d648bd608f5737b123f510bb5514b5 + depends: + - typing_extensions 4.12.2 pyha770c72_0 + license: PSF-2.0 + license_family: PSF + size: 10097 + timestamp: 1717802659025 +- kind: conda + name: typing_extensions + version: 4.12.2 + build: pyha770c72_0 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.12.2-pyha770c72_0.conda + sha256: 0fce54f8ec3e59f5ef3bb7641863be4e1bf1279623e5af3d3fa726e8f7628ddb + md5: ebe6952715e1d5eb567eeebf25250fa7 + depends: + - python >=3.8 + license: PSF-2.0 + license_family: PSF + size: 39888 + timestamp: 1717802653893 +- kind: conda + name: typing_inspect + version: 0.9.0 + build: pyhd8ed1ab_0 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/typing_inspect-0.9.0-pyhd8ed1ab_0.conda + sha256: 16e0b825c138e14ebc84623248d91d93a8cff29bb93595cc4aa46ca32f24f1de + md5: 9e924b76b91908a17e28a19a0ab88687 + depends: + - mypy_extensions >=0.3.0 + - python >=3.5 + - typing_extensions >=3.7.4 + license: MIT + license_family: MIT + size: 14906 + timestamp: 1685820229594 +- kind: conda + name: typos + version: 1.22.3 + build: h09b8157_0 + subdir: linux-aarch64 + url: https://conda.anaconda.org/conda-forge/linux-aarch64/typos-1.22.3-h09b8157_0.conda + sha256: 47f014a344e8ce67b05266e470e7822f53b4f3143821e0ca6df0ed51c810f088 + md5: e259f11f0d0d4914d2b1c2c0db8bcb82 + depends: + - libgcc-ng >=12 + license: MIT + license_family: MIT + size: 3575109 + timestamp: 1717789191744 +- kind: conda + name: typos + version: 1.22.3 + build: h686f776_0 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/typos-1.22.3-h686f776_0.conda + sha256: 699149f29bfe309e6cc1cfa0dce438d3430a2c2908f2e5f09c5d6f122cd5adff + md5: 62cdde4dad200126b25f42c9e1f44a20 + depends: + - __osx >=10.13 + constrains: + - __osx >=10.12 + license: MIT + license_family: MIT + size: 3364294 + timestamp: 1717789782714 +- kind: conda + name: typos + version: 1.22.3 + build: h6e96688_0 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/typos-1.22.3-h6e96688_0.conda + sha256: 70b191a134ce02582844d60bf1a801feec4ce86805bc5027cb74b352274cb2fc + md5: be121eb9dd7f7ff6da0b528e15a1415e + depends: + - __osx >=11.0 + constrains: + - __osx >=11.0 + license: MIT + license_family: MIT + size: 3354048 + timestamp: 1717789591052 +- kind: conda + name: typos + version: 1.22.3 + build: h813c833_0 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/typos-1.22.3-h813c833_0.conda + sha256: 030a6c63c9cf2b04f0ed866ff95a4ec8436f2c49e0ac8e81471160bf2555cbaa + md5: 3b5e5acf3d83ae8116ab9acdd29ff216 + depends: + - m2w64-gcc-libs + - m2w64-gcc-libs-core + - ucrt >=10.0.20348.0 + - vc >=14.3,<15 + - vc14_runtime >=14.40.33810 + license: MIT + license_family: MIT + size: 2613925 + timestamp: 1717790432186 +- kind: conda + name: typos + version: 1.22.3 + build: he9194b0_0 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/typos-1.22.3-he9194b0_0.conda + sha256: eea1b82496b69741c9f48031e71b5070f48e4feefb3a97c7b81c3d3bf1979cb6 + md5: c6cf5d1d2cda350bd398ad6f0eab159b + depends: + - libgcc-ng >=12 + license: MIT + license_family: MIT + size: 3663852 + timestamp: 1717789144569 +- kind: conda + name: typos + version: 1.22.4 + build: h09b8157_0 + subdir: linux-aarch64 + url: https://conda.anaconda.org/conda-forge/linux-aarch64/typos-1.22.4-h09b8157_0.conda + sha256: eba65c0391efdfaa1f3572ad5d2ec0b69b3fbb0da15459fc03170e7b75a2c566 + md5: d379a2ee66cb46a6a28840cf7f4893e1 + depends: + - libgcc-ng >=12 + license: MIT + license_family: MIT + size: 3575508 + timestamp: 1718072804865 +- kind: conda + name: typos + version: 1.22.4 + build: h686f776_0 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/typos-1.22.4-h686f776_0.conda + sha256: 172eaae1e296c110be7846446ad7107e06225c43f79bdb4bd82a265590833db9 + md5: 4bd24315c9ee0c04da4d0a997cb40733 + depends: + - __osx >=10.13 + constrains: + - __osx >=10.12 + license: MIT + license_family: MIT + size: 3352321 + timestamp: 1718073139478 +- kind: conda + name: typos + version: 1.22.4 + build: h6e96688_0 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/typos-1.22.4-h6e96688_0.conda + sha256: 8b596d10544a3840fdf1e6d8427c7eaf5e0838b72807c41b9ddc3b811d3e5573 + md5: 91f397a528af43db3cc5bed649f3e3b2 + depends: + - __osx >=11.0 + constrains: + - __osx >=11.0 + license: MIT + license_family: MIT + size: 3354634 + timestamp: 1718073140004 +- kind: conda + name: typos + version: 1.22.4 + build: h813c833_0 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/typos-1.22.4-h813c833_0.conda + sha256: 26e3b0f810c8bd37daaa8c66dd236a6233e4a3c629fff829e3ccd340be9ea81d + md5: b4a823389b94daa20a9a46e75e73c443 + depends: + - m2w64-gcc-libs + - m2w64-gcc-libs-core + - ucrt >=10.0.20348.0 + - vc >=14.3,<15 + - vc14_runtime >=14.40.33810 + license: MIT + license_family: MIT + size: 2612074 + timestamp: 1718073835609 +- kind: conda + name: typos + version: 1.22.4 + build: he9194b0_0 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/typos-1.22.4-he9194b0_0.conda + sha256: 322d63b596e91b23fdf7da99af3d5bce528a4ff38a33a4c60d0dc3fb6875ae1b + md5: 9926a188f41b6cf0321dffad7f10fc74 + depends: + - libgcc-ng >=12 + license: MIT + license_family: MIT + size: 3649998 + timestamp: 1718072708077 +- kind: conda + name: tzdata + version: 2024a + build: h0c530f3_0 + subdir: noarch + noarch: generic + url: https://conda.anaconda.org/conda-forge/noarch/tzdata-2024a-h0c530f3_0.conda + sha256: 7b2b69c54ec62a243eb6fba2391b5e443421608c3ae5dbff938ad33ca8db5122 + md5: 161081fc7cec0bfda0d86d7cb595f8d8 + license: LicenseRef-Public-Domain + size: 119815 + timestamp: 1706886945727 +- kind: conda + name: ucrt + version: 10.0.22621.0 + build: h57928b3_0 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/ucrt-10.0.22621.0-h57928b3_0.tar.bz2 + sha256: f29cdaf8712008f6b419b8b1a403923b00ab2504bfe0fb2ba8eb60e72d4f14c6 + md5: 72608f6cd3e5898229c3ea16deb1ac43 + constrains: + - vs2015_runtime >=14.29.30037 + license: LicenseRef-Proprietary + license_family: PROPRIETARY + size: 1283972 + timestamp: 1666630199266 +- kind: conda + name: ukkonen + version: 1.0.1 + build: py312h0d7def4_4 + build_number: 4 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/ukkonen-1.0.1-py312h0d7def4_4.conda + sha256: f5f7550991ca647f69b67b9188c7104a3456122611dd6a6e753cff555e45dfd9 + md5: 57cfbb8ce3a1800bd343bf6afba6f878 + depends: + - cffi + - python >=3.12.0rc3,<3.13.0a0 + - python_abi 3.12.* *_cp312 + - ucrt >=10.0.20348.0 + - vc >=14.2,<15 + - vc14_runtime >=14.29.30139 + license: MIT + license_family: MIT + size: 17235 + timestamp: 1695549871621 +- kind: conda + name: ukkonen + version: 1.0.1 + build: py312h389731b_4 + build_number: 4 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/ukkonen-1.0.1-py312h389731b_4.conda + sha256: 7336cf66feba973207f4903c20b05c3c82e351246df4b6113f72d92b9ee55b81 + md5: 6407429e0969b58b8717dbb4c6c15513 + depends: + - cffi + - libcxx >=15.0.7 + - python >=3.12.0rc3,<3.13.0a0 + - python >=3.12.0rc3,<3.13.0a0 *_cpython + - python_abi 3.12.* *_cp312 + license: MIT + license_family: MIT + size: 13948 + timestamp: 1695549890285 +- kind: conda + name: ukkonen + version: 1.0.1 + build: py312h49ebfd2_4 + build_number: 4 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/ukkonen-1.0.1-py312h49ebfd2_4.conda + sha256: efca19a5e73e4aacfc5e90a5389272b2508e41dc4adab9eb5353c5200ba37041 + md5: 4e6b5a8025cd8fd97b3cfe103ffce6b1 + depends: + - cffi + - libcxx >=15.0.7 + - python >=3.12.0rc3,<3.13.0a0 + - python_abi 3.12.* *_cp312 + license: MIT + license_family: MIT + size: 13246 + timestamp: 1695549689363 +- kind: conda + name: ukkonen + version: 1.0.1 + build: py312h8572e83_4 + build_number: 4 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/ukkonen-1.0.1-py312h8572e83_4.conda + sha256: f9a4384d466f4d8b5b497d951329dd4407ebe02f8f93456434e9ab789d6e23ce + md5: 52c9e25ee0a32485a102eeecdb7eef52 + depends: + - cffi + - libgcc-ng >=12 + - libstdcxx-ng >=12 + - python >=3.12.0rc3,<3.13.0a0 + - python_abi 3.12.* *_cp312 + license: MIT + license_family: MIT + size: 14050 + timestamp: 1695549556745 +- kind: conda + name: ukkonen + version: 1.0.1 + build: py312h8f0b210_4 + build_number: 4 + subdir: linux-aarch64 + url: https://conda.anaconda.org/conda-forge/linux-aarch64/ukkonen-1.0.1-py312h8f0b210_4.conda + sha256: 1660c56757ef39b3b467f1e2d6d51d236d36d426afa701dcbf71887e93c9f095 + md5: 6761f5b303f3fcb695ae5f297cde7bde + depends: + - cffi + - libgcc-ng >=12 + - libstdcxx-ng >=12 + - python >=3.12.0rc3,<3.13.0a0 + - python >=3.12.0rc3,<3.13.0a0 *_cpython + - python_abi 3.12.* *_cp312 + license: MIT + license_family: MIT + size: 14812 + timestamp: 1695549601083 +- kind: conda + name: untokenize + version: 0.1.1 + build: py_0 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/untokenize-0.1.1-py_0.tar.bz2 + sha256: 38ac6f277f228e8b79a0707a85a86971e4c73dc6b4483c2286cfb413f0b62b58 + md5: 1447ead40f2a01733a9c8dfc32988375 + depends: + - python + license: MIT + license_family: MIT + size: 6143 + timestamp: 1583436833181 +- kind: conda + name: urllib3 + version: 2.2.1 + build: pyhd8ed1ab_0 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/urllib3-2.2.1-pyhd8ed1ab_0.conda + sha256: d4009dcc9327684d6409706ce17656afbeae690d8522d3c9bc4df57649a352cd + md5: 08807a87fa7af10754d46f63b368e016 + depends: + - brotli-python >=1.0.9 + - pysocks >=1.5.6,<2.0,!=1.5.7 + - python >=3.7 + license: MIT + license_family: MIT + size: 94669 + timestamp: 1708239595549 +- kind: conda + name: vc + version: '14.3' + build: h8a93ad2_20 + build_number: 20 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/vc-14.3-h8a93ad2_20.conda + sha256: 23ac5feb15a9adf3ab2b8c4dcd63650f8b7ae860c5ceb073e49cf71d203eddef + md5: 8558f367e1d7700554f7cdb823c46faf + depends: + - vc14_runtime >=14.40.33810 + track_features: + - vc14 + license: BSD-3-Clause + license_family: BSD + size: 17391 + timestamp: 1717709040616 +- kind: conda + name: vc14_runtime + version: 14.40.33810 + build: ha82c5b3_20 + build_number: 20 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/vc14_runtime-14.40.33810-ha82c5b3_20.conda + sha256: af3cfa347e3d7c1277e9b964b0849a9a9f095bff61836cb3c3a89862fbc32e17 + md5: e39cc4c34c53654ec939558993d9dc5b + depends: + - ucrt >=10.0.20348.0 + constrains: + - vs2015_runtime 14.40.33810.* *_20 + license: LicenseRef-ProprietaryMicrosoft + license_family: Proprietary + size: 751934 + timestamp: 1717709031266 +- kind: conda + name: virtualenv + version: 20.26.2 + build: pyhd8ed1ab_0 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/virtualenv-20.26.2-pyhd8ed1ab_0.conda + sha256: 1eefd180723fb2fd295352323b53777eeae5765b24d62ae75fc9f1e71b455f11 + md5: 7d36e7a485ea2f5829408813bdbbfb38 + depends: + - distlib <1,>=0.3.7 + - filelock <4,>=3.12.2 + - platformdirs <5,>=3.9.1 + - python >=3.8 + license: MIT + license_family: MIT + size: 3458445 + timestamp: 1715681264937 +- kind: conda + name: vs2015_runtime + version: 14.40.33810 + build: h3bf8584_20 + build_number: 20 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/vs2015_runtime-14.40.33810-h3bf8584_20.conda + sha256: 0c2803f7a788c51f28235a7228dc2ab3f107b4b16ab0845a3e595c8c51e50a7a + md5: c21f1b4a3a30bbc3ef35a50957578e0e + depends: + - vc14_runtime >=14.40.33810 + license: BSD-3-Clause + license_family: BSD + size: 17395 + timestamp: 1717709043353 +- kind: conda + name: webencodings + version: 0.5.1 + build: pyhd8ed1ab_2 + build_number: 2 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/webencodings-0.5.1-pyhd8ed1ab_2.conda + sha256: 2adf9bd5482802837bc8814cbe28d7b2a4cbd2e2c52e381329eaa283b3ed1944 + md5: daf5160ff9cde3a468556965329085b9 + depends: + - python >=2.6 + license: BSD-3-Clause + license_family: BSD + size: 15600 + timestamp: 1694681458271 +- kind: conda + name: wheel + version: 0.43.0 + build: pyhd8ed1ab_1 + build_number: 1 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/wheel-0.43.0-pyhd8ed1ab_1.conda + sha256: cb318f066afd6fd64619f14c030569faf3f53e6f50abf743b4c865e7d95b96bc + md5: 0b5293a157c2b5cd513dd1b03d8d3aae + depends: + - python >=3.8 + license: MIT + license_family: MIT + size: 57963 + timestamp: 1711546009410 +- kind: conda + name: win_inet_pton + version: 1.1.0 + build: pyhd8ed1ab_6 + build_number: 6 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/win_inet_pton-1.1.0-pyhd8ed1ab_6.tar.bz2 + sha256: a11ae693a0645bf6c7b8a47bac030be9c0967d0b1924537b9ff7458e832c0511 + md5: 30878ecc4bd36e8deeea1e3c151b2e0b + depends: + - __win + - python >=3.6 + license: PUBLIC-DOMAIN + size: 8191 + timestamp: 1667051294134 +- kind: conda + name: xz + version: 5.2.6 + build: h166bdaf_0 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/xz-5.2.6-h166bdaf_0.tar.bz2 + sha256: 03a6d28ded42af8a347345f82f3eebdd6807a08526d47899a42d62d319609162 + md5: 2161070d867d1b1204ea749c8eec4ef0 + depends: + - libgcc-ng >=12 + license: LGPL-2.1 and GPL-2.0 + size: 418368 + timestamp: 1660346797927 +- kind: conda + name: xz + version: 5.2.6 + build: h57fd34a_0 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/xz-5.2.6-h57fd34a_0.tar.bz2 + sha256: 59d78af0c3e071021cfe82dc40134c19dab8cdf804324b62940f5c8cd71803ec + md5: 39c6b54e94014701dd157f4f576ed211 + license: LGPL-2.1 and GPL-2.0 + size: 235693 + timestamp: 1660346961024 +- kind: conda + name: xz + version: 5.2.6 + build: h775f41a_0 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/xz-5.2.6-h775f41a_0.tar.bz2 + sha256: eb09823f34cc2dd663c0ec4ab13f246f45dcd52e5b8c47b9864361de5204a1c8 + md5: a72f9d4ea13d55d745ff1ed594747f10 + license: LGPL-2.1 and GPL-2.0 + size: 238119 + timestamp: 1660346964847 +- kind: conda + name: xz + version: 5.2.6 + build: h8d14728_0 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/xz-5.2.6-h8d14728_0.tar.bz2 + sha256: 54d9778f75a02723784dc63aff4126ff6e6749ba21d11a6d03c1f4775f269fe0 + md5: 515d77642eaa3639413c6b1bc3f94219 + depends: + - vc >=14.1,<15 + - vs2015_runtime >=14.16.27033 + license: LGPL-2.1 and GPL-2.0 + size: 217804 + timestamp: 1660346976440 +- kind: conda + name: xz + version: 5.2.6 + build: h9cdd2b7_0 + subdir: linux-aarch64 + url: https://conda.anaconda.org/conda-forge/linux-aarch64/xz-5.2.6-h9cdd2b7_0.tar.bz2 + sha256: 93f58a7b393adf41fa007ac8c55978765e957e90cd31877ece1e5a343cb98220 + md5: 83baad393a31d59c20b63ba4da6592df + depends: + - libgcc-ng >=12 + license: LGPL-2.1 and GPL-2.0 + size: 440555 + timestamp: 1660348056328 +- kind: conda + name: yaml + version: 0.2.5 + build: h0d85af4_2 + build_number: 2 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/yaml-0.2.5-h0d85af4_2.tar.bz2 + sha256: 5301417e2c8dea45b401ffee8df3957d2447d4ce80c83c5ff151fc6bfe1c4148 + md5: d7e08fcf8259d742156188e8762b4d20 + license: MIT + license_family: MIT + size: 84237 + timestamp: 1641347062780 +- kind: conda + name: yaml + version: 0.2.5 + build: h3422bc3_2 + build_number: 2 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/yaml-0.2.5-h3422bc3_2.tar.bz2 + sha256: 93181a04ba8cfecfdfb162fc958436d868cc37db504c58078eab4c1a3e57fbb7 + md5: 4bb3f014845110883a3c5ee811fd84b4 + license: MIT + license_family: MIT + size: 88016 + timestamp: 1641347076660 +- kind: conda + name: yaml + version: 0.2.5 + build: h7f98852_2 + build_number: 2 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/yaml-0.2.5-h7f98852_2.tar.bz2 + sha256: a4e34c710eeb26945bdbdaba82d3d74f60a78f54a874ec10d373811a5d217535 + md5: 4cb3ad778ec2d5a7acbdf254eb1c42ae + depends: + - libgcc-ng >=9.4.0 + license: MIT + license_family: MIT + size: 89141 + timestamp: 1641346969816 +- kind: conda + name: yaml + version: 0.2.5 + build: h8ffe710_2 + build_number: 2 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/yaml-0.2.5-h8ffe710_2.tar.bz2 + sha256: 4e2246383003acbad9682c7c63178e2e715ad0eb84f03a8df1fbfba455dfedc5 + md5: adbfb9f45d1004a26763652246a33764 + depends: + - vc >=14.1,<15.0a0 + - vs2015_runtime >=14.16.27012 + license: MIT + license_family: MIT + size: 63274 + timestamp: 1641347623319 +- kind: conda + name: yaml + version: 0.2.5 + build: hf897c2e_2 + build_number: 2 + subdir: linux-aarch64 + url: https://conda.anaconda.org/conda-forge/linux-aarch64/yaml-0.2.5-hf897c2e_2.tar.bz2 + sha256: 8bc601d6dbe249eba44b3c456765265cd8f42ef1e778f8df9b0c9c88b8558d7e + md5: b853307650cb226731f653aa623936a4 + depends: + - libgcc-ng >=9.4.0 + license: MIT + license_family: MIT + size: 92927 + timestamp: 1641347626613 +- kind: conda + name: zeromq + version: 4.3.5 + build: h28faeed_4 + build_number: 4 + subdir: linux-aarch64 + url: https://conda.anaconda.org/conda-forge/linux-aarch64/zeromq-4.3.5-h28faeed_4.conda + sha256: 99a48b3a52c3a028d5a8aa5b586611c282347b5b76a3c675b2af3807b9d07f0f + md5: ae8c0108b4d6a5981bce484eeaaf1b55 + depends: + - krb5 >=1.21.2,<1.22.0a0 + - libgcc-ng >=12 + - libsodium >=1.0.18,<1.0.19.0a0 + - libstdcxx-ng >=12 + license: MPL-2.0 + license_family: MOZILLA + size: 383549 + timestamp: 1715611199541 +- kind: conda + name: zeromq + version: 4.3.5 + build: h75354e8_4 + build_number: 4 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/zeromq-4.3.5-h75354e8_4.conda + sha256: bc9aaee39e7be107d7daff237435dfd8f791aca460a98583a36a263615205262 + md5: 03cc8d9838ad9dd0060ab532e81ccb21 + depends: + - krb5 >=1.21.2,<1.22.0a0 + - libgcc-ng >=12 + - libsodium >=1.0.18,<1.0.19.0a0 + - libstdcxx-ng >=12 + license: MPL-2.0 + license_family: MOZILLA + size: 353229 + timestamp: 1715607188837 +- kind: conda + name: zeromq + version: 4.3.5 + build: hcc0f68c_4 + build_number: 4 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/zeromq-4.3.5-hcc0f68c_4.conda + sha256: c22520d6d66a80f17c5f2b3719ad4a6ee809b210b8ac87d6f05ab98b94b3abda + md5: 39fb79e7a7a880a03f82c1f2eb7f7c73 + depends: + - __osx >=11.0 + - krb5 >=1.21.2,<1.22.0a0 + - libcxx >=16 + - libsodium >=1.0.18,<1.0.19.0a0 + license: MPL-2.0 + license_family: MOZILLA + size: 298555 + timestamp: 1715607628741 +- kind: conda + name: zeromq + version: 4.3.5 + build: hde137ed_4 + build_number: 4 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/zeromq-4.3.5-hde137ed_4.conda + sha256: 871625ce993e6c61649b14659a3d1d6011fbb242b7d6a25cadbc6300b2356f32 + md5: e56609055da6c658aa329d42a6c6b9f2 + depends: + - __osx >=10.13 + - krb5 >=1.21.2,<1.22.0a0 + - libcxx >=16 + - libsodium >=1.0.18,<1.0.19.0a0 + license: MPL-2.0 + license_family: MOZILLA + size: 304498 + timestamp: 1715607961981 +- kind: conda + name: zeromq + version: 4.3.5 + build: he1f189c_4 + build_number: 4 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/zeromq-4.3.5-he1f189c_4.conda + sha256: 0f375034a88659f764ce837f324698a883da227fcb517561ffaf6a89474211b4 + md5: b755eb545c2728b9a53729f02e627834 + depends: + - krb5 >=1.21.2,<1.22.0a0 + - libsodium >=1.0.18,<1.0.19.0a0 + - ucrt >=10.0.20348.0 + - vc >=14.2,<15 + - vc14_runtime >=14.29.30139 + license: MPL-2.0 + license_family: MOZILLA + size: 2707065 + timestamp: 1715607874610 +- kind: conda + name: zipp + version: 3.19.2 + build: pyhd8ed1ab_0 + subdir: noarch + noarch: python + url: https://conda.anaconda.org/conda-forge/noarch/zipp-3.19.2-pyhd8ed1ab_0.conda + sha256: e3e9c8501f581bfdc4700b83ea283395e237ec6b9b5cbfbedb556e1da6f4fdc9 + md5: 49808e59df5535116f6878b2a820d6f4 + depends: + - python >=3.8 + license: MIT + license_family: MIT + size: 20917 + timestamp: 1718013395428 +- kind: conda + name: zlib + version: 1.3.1 + build: h4ab18f5_1 + build_number: 1 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/zlib-1.3.1-h4ab18f5_1.conda + sha256: cee16ab07a11303de721915f0a269e8c7a54a5c834aa52f74b1cc3a59000ade8 + md5: 9653f1bf3766164d0e65fa723cabbc54 + depends: + - libgcc-ng >=12 + - libzlib 1.3.1 h4ab18f5_1 + license: Zlib + license_family: Other + size: 93004 + timestamp: 1716874213487 +- kind: conda + name: zlib + version: 1.3.1 + build: h68df207_1 + build_number: 1 + subdir: linux-aarch64 + url: https://conda.anaconda.org/conda-forge/linux-aarch64/zlib-1.3.1-h68df207_1.conda + sha256: 7d4f12a602447c00f65f99fcf332f350cc49161a4f215466e9eb1bbe51852978 + md5: 6031f9e32654fbdb9fdba406ab980517 + depends: + - libgcc-ng >=12 + - libzlib 1.3.1 h68df207_1 + license: Zlib + license_family: Other + size: 95770 + timestamp: 1716874148566 +- kind: conda + name: zlib + version: 1.3.1 + build: h87427d6_1 + build_number: 1 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/zlib-1.3.1-h87427d6_1.conda + sha256: 41bd5fef28b2755d637e3a8ea5c84010628392fbcf80c7e3d7370aaced7ee4fe + md5: 3ac9ef8975965f9698dbedd2a4cc5894 + depends: + - __osx >=10.13 + - libzlib 1.3.1 h87427d6_1 + license: Zlib + license_family: Other + size: 88782 + timestamp: 1716874245467 +- kind: conda + name: zlib + version: 1.3.1 + build: hfb2fe0b_1 + build_number: 1 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/zlib-1.3.1-hfb2fe0b_1.conda + sha256: 87360c2dc662916aac37cf01e53324b4f4f78db6f399220818076752b093ede5 + md5: f27e021db7862b6ddbc1d3578f10d883 + depends: + - __osx >=11.0 + - libzlib 1.3.1 hfb2fe0b_1 + license: Zlib + license_family: Other + size: 78260 + timestamp: 1716874280334 diff --git a/pixi.toml b/pixi.toml new file mode 100644 index 0000000..733a33e --- /dev/null +++ b/pixi.toml @@ -0,0 +1,75 @@ +[project] +name = "ndonnx" +description = "ONNX backed array library compliant with Array API standard." +channels = ["conda-forge"] +platforms = ["osx-arm64", "osx-64", "linux-64", "linux-aarch64", "win-64"] + +[tasks] +postinstall = "pip install --no-build-isolation --no-deps --disable-pip-version-check -e ." + +[dependencies] +python = ">=3.10" +numpy = "*" +spox = ">=0.10" + +[host-dependencies] +pip = "*" +setuptools = ">=61" +setuptools-scm = "*" +[feature.docs.dependencies] +make = "*" +numpydoc = "*" +sphinx = "*" +sphinxcontrib-apidoc = "*" +sphinx_rtd_theme = "*" +sphinx-toolbox = "*" +nbsphinx = "*" +[feature.docs.tasks] +docs = "cd docs && make html" + +[feature.build.dependencies] +build = "*" +[feature.build.tasks] +build-wheel = "python -m build --no-isolation ." + +[feature.test.dependencies] +pytest = ">=6" +pytest-cov = "*" +pytest-json-report = "*" +pytest-xdist = "*" +hypothesis = "*" +onnxruntime = "*" +onnx = "*" +mypy = ">=1.10.0,<1.11" +[feature.test.tasks] +test = "pytest" +test-coverage = "pytest --cov=ndonnx --cov-report=xml --cov-report=term-missing" +arrayapitests = "ARRAY_API_TESTS_MODULE=ndonnx pytest --max-examples 2 api-coverage-tests/array_api_tests/ --json-report --json-report-file=api-coverage-tests.json -n auto -vv --skips-file=skips.txt" + +[feature.lint.dependencies] +pre-commit = "*" +insert-license-header = "*" +docformatter = "*" +ruff = "*" +prettier = "*" +pre-commit-hooks = "*" +typos = "*" +[feature.lint.tasks] +pre-commit-install = "pre-commit install" +pre-commit-run = "pre-commit run -a" + +[feature.py310.dependencies] +python = "3.10.*" +[feature.py311.dependencies] +python = "3.11.*" +[feature.py312.dependencies] +python = "3.12.*" + +[environments] +default = ["test", "lint"] +py310 = ["py310", "test"] +py311 = ["py311", "test"] +py312 = ["py312", "test"] +docs = ["docs"] +build = ["build"] +lint = { features = ["lint"], no-default-feature = true } diff --git a/pyproject.toml b/pyproject.toml new file mode 100644 index 0000000..fd6903d --- /dev/null +++ b/pyproject.toml @@ -0,0 +1,86 @@ +[build-system] +requires = ["setuptools", "setuptools-scm", "wheel"] + +[tool.setuptools_scm] +version_scheme = "post-release" + +[project] +name = "ndonnx" +description = "ONNX backed array library compliant with Array API standard." +readme = "README.md" +dynamic = ["version"] +authors = [ + { name = "Aditya Goel", email = "agoel4512@gmail.com" }, + { name = "Christian Bourjau", email = "christian.bourjau@quantco.com" }, +] +classifiers = [ + "Programming Language :: Python :: 3", + "Programming Language :: Python :: 3.10", + "Programming Language :: Python :: 3.11", + "Programming Language :: Python :: 3.12", +] +requires-python = ">=3.10" + +[project.urls] +repository = "https://github.com/quantco/ndonnx" + + +[tool.setuptools.packages.find] +include = ["ndonnx"] +namespaces = false + +[project.scripts] + +[tool.docformatter] +black = true # only sets the style options to the default values of black + +[tool.ruff] +line-length = 88 + +[tool.ruff.lint] +ignore = [ + "N803", # https://docs.astral.sh/ruff/rules/invalid-argument-name + "N806", # https://docs.astral.sh/ruff/rules/non-lowercase-variable-in-function + "E501", # https://docs.astral.sh/ruff/faq/#is-the-ruff-linter-compatible-with-black + "UP038", # https://github.com/astral-sh/ruff/issues/7871 + "UP007", +] +select = [ + # pyflakes + "F", + # pycodestyle + "E", + "W", + # isort + "I", + # pep8-naming + "N", + # pyupgrade + "UP", +] + +[tool.ruff.lint.per-file-ignores] +"__init__.py" = ["I"] + +[tool.ruff.format] +quote-style = "double" +indent-style = "space" + +[tool.mypy] +python_version = '3.10' +no_implicit_optional = true +check_untyped_defs = true +exclude = ["api-coverage-tests", "tests"] + +[[tool.mypy.overrides]] +module = ["onnxruntime"] +ignore_missing_imports = true + +[tool.pytest.ini_options] +pythonpath = "." +addopts = "--import-mode=importlib --ignore=api-coverage-tests" +testpaths = ["tests"] +exclude = ["docs/"] + +[tool.typos.default] +extend-ignore-identifiers-re = ["scatter_nd", "arange"] diff --git a/scripts/create_typing.sh b/scripts/create_typing.sh new file mode 100755 index 0000000..63844e3 --- /dev/null +++ b/scripts/create_typing.sh @@ -0,0 +1,5 @@ +# Create concatenation of all signature files, removing the definitions of array +sed '$s/$/\n/' api-coverage-tests/array-api/spec/API_specification/signatures/*.py | sed '/^array = /d' > ndonnx/__init__.pyi + +# Create _types.py +echo "from ._array import Array as array\n$( ndonnx/_types.pyi diff --git a/scripts/parse_test_report.py b/scripts/parse_test_report.py new file mode 100644 index 0000000..6dd0279 --- /dev/null +++ b/scripts/parse_test_report.py @@ -0,0 +1,24 @@ +# Copyright (c) QuantCo 2023-2024 +# SPDX-License-Identifier: LicenseRef-QuantCo + +import argparse +import json + +if __name__ == "__main__": + parser = argparse.ArgumentParser() + parser.add_argument("report_json", help="Directory containing reports") + args = parser.parse_args() + + print(args.report_json) + with open(args.report_json) as f: + report = json.load(f) + + for test in report["tests"]: + print(test["nodeid"], test["outcome"]) + + # Print summary in readable format + print("Summary:") + print(f'- {report["summary"]["passed"]} passed') + print(f'- {report["summary"]["failed"]} failed') + print(f'- {report["summary"]["skipped"]} deselected') + print(f'- {report["summary"]["total"]} total') diff --git a/scripts/test.sh b/scripts/test.sh new file mode 100755 index 0000000..12afabe --- /dev/null +++ b/scripts/test.sh @@ -0,0 +1,2 @@ +export ARRAY_API_TESTS_MODULE=ndonnx.testing && +pytest -n auto api-coverage-tests --json-report --json-report-file=api-coverage-tests.json diff --git a/skips.txt b/skips.txt new file mode 100644 index 0000000..a6b2b6f --- /dev/null +++ b/skips.txt @@ -0,0 +1,106 @@ +array_api_tests/test_array_object.py::test_setitem_masking +array_api_tests/test_creation_functions.py::test_meshgrid +array_api_tests/test_data_type_functions.py::test_can_cast +array_api_tests/test_has_names.py::test_has_names[array_attribute-device] +array_api_tests/test_has_names.py::test_has_names[array_method-__dlpack__] +array_api_tests/test_has_names.py::test_has_names[array_method-__dlpack_device__] +array_api_tests/test_has_names.py::test_has_names[array_method-to_device] +array_api_tests/test_has_names.py::test_has_names[linalg-det] +array_api_tests/test_has_names.py::test_has_names[linalg-diagonal] +array_api_tests/test_has_names.py::test_has_names[linalg-eigh] +array_api_tests/test_has_names.py::test_has_names[linalg-eigvalsh] +array_api_tests/test_has_names.py::test_has_names[linalg-inv] +array_api_tests/test_has_names.py::test_has_names[linalg-matmul] +array_api_tests/test_has_names.py::test_has_names[linalg-matrix_norm] +array_api_tests/test_has_names.py::test_has_names[linalg-matrix_power] +array_api_tests/test_has_names.py::test_has_names[linalg-matrix_rank] +array_api_tests/test_has_names.py::test_has_names[linalg-matrix_transpose] +array_api_tests/test_has_names.py::test_has_names[linalg-outer] +array_api_tests/test_has_names.py::test_has_names[linalg-pinv] +array_api_tests/test_has_names.py::test_has_names[linalg-qr] +array_api_tests/test_has_names.py::test_has_names[linalg-slogdet] +array_api_tests/test_has_names.py::test_has_names[linalg-solve] +array_api_tests/test_has_names.py::test_has_names[linalg-svd] +array_api_tests/test_has_names.py::test_has_names[linalg-svdvals] +array_api_tests/test_has_names.py::test_has_names[linalg-tensordot] +array_api_tests/test_has_names.py::test_has_names[linalg-trace] +array_api_tests/test_has_names.py::test_has_names[linalg-vecdot] +array_api_tests/test_has_names.py::test_has_names[linalg-vector_norm] +array_api_tests/test_has_names.py::test_has_names[linear_algebra-tensordot] +array_api_tests/test_has_names.py::test_has_names[linear_algebra-vecdot] +array_api_tests/test_has_names.py::test_has_names[linalg-cross] +array_api_tests/test_has_names.py::test_has_names[linalg-cholesky] +array_api_tests/test_linalg.py +array_api_tests/test_operators_and_elementwise_functions.py::test_atan2 +array_api_tests/test_operators_and_elementwise_functions.py::test_divide[__itruediv__(x, s)] +array_api_tests/test_operators_and_elementwise_functions.py::test_divide[__itruediv__(x1, x2)] +array_api_tests/test_operators_and_elementwise_functions.py::test_floor_divide +array_api_tests/test_operators_and_elementwise_functions.py::test_sign +array_api_tests/test_operators_and_elementwise_functions.py::test_sinh +array_api_tests/test_set_functions.py::test_unique_all +array_api_tests/test_set_functions.py::test_unique_counts +array_api_tests/test_set_functions.py::test_unique_inverse +array_api_tests/test_set_functions.py::test_unique_values +array_api_tests/test_signatures.py::test_array_method_signature[__array_namespace__] +array_api_tests/test_signatures.py::test_array_method_signature[__dlpack__] +array_api_tests/test_signatures.py::test_array_method_signature[__dlpack_device__] +array_api_tests/test_signatures.py::test_array_method_signature[to_device] +array_api_tests/test_signatures.py::test_func_signature[from_dlpack] +array_api_tests/test_signatures.py::test_func_signature[tensordot] +array_api_tests/test_signatures.py::test_func_signature[vecdot] +array_api_tests/test_signatures.py::test_func_signature[meshgrid] +array_api_tests/test_sorting_functions.py::test_argsort +array_api_tests/test_special_cases.py::test_binary[__mod__(isfinite(x1_i) and x1_i < 0 and x2_i is +infinity) -> x2_i] +array_api_tests/test_special_cases.py::test_binary[__mod__(isfinite(x1_i) and x1_i > 0 and x2_i is -infinity) -> x2_i] +array_api_tests/test_special_cases.py::test_binary[__mod__(x1_i is +0 and x2_i < 0) -> -0] +array_api_tests/test_special_cases.py::test_binary[__mod__(x1_i is -0 and x2_i > 0) -> +0] +array_api_tests/test_special_cases.py::test_binary[add(x1_i is -infinity and x2_i is -infinity) -> -infinity] +array_api_tests/test_special_cases.py::test_binary[atan2(x1_i is +infinity and x2_i is -infinity) -> roughly +3pi/4] +array_api_tests/test_special_cases.py::test_binary[atan2(x1_i < 0 and x2_i is -0) -> roughly -pi/2] +array_api_tests/test_special_cases.py::test_binary[atan2(x1_i > 0 and isfinite(x1_i) and x2_i is -infinity) -> roughly +pi] +array_api_tests/test_special_cases.py::test_binary[atan2(x1_i > 0 and x2_i is -0) -> roughly +pi/2] +array_api_tests/test_special_cases.py::test_binary[atan2(x1_i is +0 and x2_i < 0) -> roughly +pi] +array_api_tests/test_special_cases.py::test_binary[atan2(x1_i is +0 and x2_i is +0) -> +0] +array_api_tests/test_special_cases.py::test_binary[atan2(x1_i is +0 and x2_i is -0) -> roughly +pi] +array_api_tests/test_special_cases.py::test_binary[atan2(x1_i is -0 and x2_i < 0) -> roughly -pi] +array_api_tests/test_special_cases.py::test_binary[atan2(x1_i is -0 and x2_i is +0) -> -0] +array_api_tests/test_special_cases.py::test_binary[atan2(x1_i is -0 and x2_i is -0) -> roughly -pi] +array_api_tests/test_special_cases.py::test_binary[atan2(x1_i is -infinity and x2_i is +infinity) -> roughly -pi/4] +array_api_tests/test_special_cases.py::test_binary[atan2(x1_i is -infinity and x2_i is -infinity) -> roughly -3pi/4] +array_api_tests/test_special_cases.py::test_binary[floor_divide(copysign(1, x1_i) != copysign(1, x2_i) and isfinite(x1_i) and x1_i != 0 and isfinite(x2_i) and x2_i != 0) -> negative sign] +array_api_tests/test_special_cases.py::test_binary[remainder(isfinite(x1_i) and x1_i < 0 and x2_i is +infinity) -> x2_i] +array_api_tests/test_special_cases.py::test_binary[remainder(isfinite(x1_i) and x1_i > 0 and x2_i is -infinity) -> x2_i] +array_api_tests/test_special_cases.py::test_binary[remainder(x1_i is +0 and x2_i < 0) -> -0] +array_api_tests/test_special_cases.py::test_binary[remainder(x1_i is -0 and x2_i > 0) -> +0] +array_api_tests/test_special_cases.py::test_empty_arrays[prod] +array_api_tests/test_special_cases.py::test_iop[__imod__(isfinite(x1_i) and x1_i < 0 and x2_i is +infinity) -> x2_i] +array_api_tests/test_special_cases.py::test_iop[__imod__(isfinite(x1_i) and x1_i > 0 and x2_i is -infinity) -> x2_i] +array_api_tests/test_special_cases.py::test_iop[__imod__(x1_i is +0 and x2_i < 0) -> -0] +array_api_tests/test_special_cases.py::test_iop[__imod__(x1_i is -0 and x2_i > 0) -> +0] +array_api_tests/test_special_cases.py::test_nan_propagation[prod] +array_api_tests/test_special_cases.py::test_unary[acos(x_i < -1) -> NaN] +array_api_tests/test_special_cases.py::test_unary[acos(x_i > 1) -> NaN] +array_api_tests/test_special_cases.py::test_unary[asin(x_i < -1) -> NaN] +array_api_tests/test_special_cases.py::test_unary[asin(x_i > 1) -> NaN] +array_api_tests/test_special_cases.py::test_unary[atanh(x_i < -1) -> NaN] +array_api_tests/test_special_cases.py::test_unary[atanh(x_i > 1) -> NaN] +array_api_tests/test_special_cases.py::test_unary[expm1(x_i is -0) -> -0] +array_api_tests/test_special_cases.py::test_unary[log1p(x_i is +0) -> +0] +array_api_tests/test_special_cases.py::test_unary[log1p(x_i is -0) -> -0] +array_api_tests/test_special_cases.py::test_unary[log1p(x_i is -1) -> -infinity] +array_api_tests/test_special_cases.py::test_unary[sinh(x_i is +0) -> +0] +array_api_tests/test_special_cases.py::test_unary[sinh(x_i is +infinity) -> +infinity] +array_api_tests/test_special_cases.py::test_unary[sinh(x_i is -0) -> -0] +array_api_tests/test_special_cases.py::test_unary[sinh(x_i is -infinity) -> -infinity] +array_api_tests/test_special_cases.py::test_unary[sinh(x_i is NaN) -> NaN] +array_api_tests/test_special_cases.py::test_unary[sqrt(x_i < 0) -> NaN] +array_api_tests/test_statistical_functions.py::test_prod +array_api_tests/test_statistical_functions.py::test_std +array_api_tests/test_statistical_functions.py::test_var +array_api_tests/test_statistical_functions.py::test_sum +array_api_tests/test_special_cases.py::test_binary[atan2(x1_i < 0 and isfinite(x1_i) and x2_i is -infinity) -> roughly -pi] +array_api_tests/test_special_cases.py::test_binary[atan2(x1_i is +infinity and x2_i is +infinity) -> roughly +pi/4] +array_api_tests/test_has_names.py::test_has_names[array_attribute-size] +array_api_tests/test_has_names.py::test_has_names[creation-from_dlpack] +array_api_tests/test_has_names.py::test_has_names[creation-meshgrid] +array_api_tests/test_operators_and_elementwise_functions.py::test_pow diff --git a/tests/ndonnx/test_additional.py b/tests/ndonnx/test_additional.py new file mode 100644 index 0000000..5845ed3 --- /dev/null +++ b/tests/ndonnx/test_additional.py @@ -0,0 +1,115 @@ +# Copyright (c) QuantCo 2023-2024 +# SPDX-License-Identifier: LicenseRef-QuantCo + +import sys + +import numpy as np +import pytest + +import ndonnx as ndx +import ndonnx.additional as nda + +from .utils import run + + +@pytest.mark.parametrize( + "side", + [ + "left", + "right", + ], +) +def test_searchsorted(side): + a_val = [0, 1, 2, 5, 5, 6, 10, 15] + b_val = [0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 10, 15, 20, 20] + c_val = np.searchsorted(a_val, b_val, side) + + a = ndx.asarray(a_val, dtype=ndx.int64) + b = ndx.asarray(b_val, dtype=ndx.int64) + c = ndx.searchsorted(a, b, side=side) + np.testing.assert_equal(c_val, c.to_numpy()) + + +@pytest.mark.skip(reason="TODO: onnxruntime") +@pytest.mark.parametrize( + "side", + [ + "left", + "right", + ], +) +def test_searchsorted_nans(side): + a_val = np.array([0, 1, 2, 5, 5, 6, 10, 15, np.nan]) + b_val = np.array([0, 1, 2, np.nan, np.nan]) + c_val = np.searchsorted(a_val, b_val, side) + + a = ndx.array(shape=(len(a_val),), dtype=ndx.float64) + b = ndx.array(shape=(len(b_val),), dtype=ndx.float64) + c = ndx.searchsorted(a, b, side=side) + + model = ndx.build({"a": a, "b": b}, {"c": c}) + + np.testing.assert_equal(c_val, run(model, dict(a=a_val, b=b_val))["c"]) + + +def test_searchsorted_raises(): + with pytest.raises(TypeError): + a = ndx.array(shape=(), dtype=ndx.int64) + b = ndx.array(shape=(), dtype=ndx.float64) + + ndx.searchsorted(a, b) + + with pytest.raises(ValueError): + a = ndx.array(shape=(3,), dtype=ndx.int64) + b = ndx.array(shape=(3,), dtype=ndx.int64) + + ndx.searchsorted(a, b, side="middle") # type: ignore[arg-type] + + +@pytest.mark.skipif( + sys.platform.startswith("win"), + reason="ORT 1.18 not registering LabelEncoder(4) only on Windows.", +) +def test_static_map(): + a = ndx.array(shape=(3,), dtype=ndx.int64) + b = nda.static_map(a, {1: 2, 2: 3}) + + model = ndx.build({"a": a}, {"b": b}) + np.testing.assert_equal([0, 2, 3], run(model, {"a": np.array([0, 1, 2])})["b"]) + + # nans are mapped by static_map + a = ndx.array(shape=("N",), dtype=ndx.float64) + b = nda.static_map(a, {1.0: 2, np.nan: 3, 3.0: 42}, default=-1) + + model = ndx.build({"a": a}, {"b": b}) + np.testing.assert_equal( + [-1, -1, 42, 3], + run(model, {"a": np.array([0.0, 2.0, 3.0, np.nan])})["b"], + ) + + +@pytest.mark.skipif( + sys.platform.startswith("win"), + reason="ORT 1.18 not registering LabelEncoder(4) only on Windows.", +) +def test_isin(): + a = ndx.array(shape=("N",), dtype=ndx.utf8) + b = nda.isin(a, ["foo", "bar", "baz"]) + + model = ndx.build({"a": a}, {"b": b}) + np.testing.assert_equal( + [False, True, True, False], + run(model, dict(a=np.array(["hello", "foo", "baz", "!"])))["b"], + ) + + a = ndx.array(shape=("N",), dtype=ndx.utf8) + b = nda.isin(a, ["🔴", "🟡", "🟢"]) + + model = ndx.build({"a": a}, {"b": b}) + np.testing.assert_equal( + [False, True, False], + run(model, dict(a=np.array(["🚀", "🔴", "hi🟡"])))["b"], + ) + + a = ndx.asarray(["hello", "world"]) + np.testing.assert_equal([True, False], nda.isin(a, ["hello"]).to_numpy()) diff --git a/tests/ndonnx/test_build_utils.py b/tests/ndonnx/test_build_utils.py new file mode 100644 index 0000000..ab69ee0 --- /dev/null +++ b/tests/ndonnx/test_build_utils.py @@ -0,0 +1,40 @@ +# Copyright (c) QuantCo 2024-2024 +# SPDX-License-Identifier: LicenseRef-QuantCo + +import pytest + +import ndonnx as ndx + + +@pytest.mark.parametrize( + "dtype", + [ + ndx.int8, + ndx.int16, + ndx.int32, + ndx.int64, + ndx.float32, + ndx.float64, + ndx.utf8, + ndx.bool, + ndx.uint8, + ndx.uint16, + ndx.uint32, + ndx.uint64, + ], +) +def test_input_output_name_backwards_compatibility(dtype): + a = ndx.array(shape=("N",), dtype=dtype) + model_proto = ndx.build({"input": a}, {"output": a}) + assert [node.name for node in model_proto.graph.input] == ["input"] + assert [node.name for node in model_proto.graph.output] == ["output"] + a = ndx.array(shape=("N",), dtype=ndx._data_types.promote_nullable(dtype)) + model_proto = ndx.build({"input": a}, {"output": a}) + assert [node.name for node in model_proto.graph.input] == [ + "input_values", + "input_null", + ] + assert [node.name for node in model_proto.graph.output] == [ + "output_values", + "output_null", + ] diff --git a/tests/ndonnx/test_compute_modes.py b/tests/ndonnx/test_compute_modes.py new file mode 100644 index 0000000..551dc29 --- /dev/null +++ b/tests/ndonnx/test_compute_modes.py @@ -0,0 +1,108 @@ +# Copyright (c) QuantCo 2023-2024 +# SPDX-License-Identifier: LicenseRef-QuantCo + +import numpy as np +import numpy.array_api as npx +import pytest + +import ndonnx as ndx +import ndonnx._opset_extensions as opx + + +@pytest.mark.parametrize("op", ["add", "multiply", "subtract", "divide"]) +def test_eager_mode(op): + a = ndx.asarray(np.array([0.0, 1, 2, 3]), dtype=ndx.float64) + b = ndx.asarray(np.array([3.0, 4, 5, 6]), dtype=ndx.float64) + np.testing.assert_equal( + getattr(ndx, op)(a, b).to_numpy(), + getattr(npx, op)(npx.asarray(a.to_numpy()), npx.asarray(b.to_numpy())), + ) + + +def test_indexing(): + a = ndx.asarray(np.array([0.0, 1, 2, 3]), dtype=ndx.float64) + b = ndx.asarray(np.array([2, 1]), dtype=ndx.int64) + np.testing.assert_equal(a[b].to_numpy(), a.to_numpy()[b.to_numpy()]) # type: ignore + a[1] = 3.4 + np.testing.assert_equal( + a.to_numpy(), np.array([0.0, 3.4, 2.0, 3.0], dtype=np.float64) + ) + a[2] = 4.2 + np.testing.assert_equal( + a.to_numpy(), np.array([0.0, 3.4, 4.2, 3.0], dtype=np.float64) + ) + a[b] = ndx.asarray(np.array([-1.0, np.nan])) + np.testing.assert_equal( + a.to_numpy(), np.array([0.0, np.nan, -1.0, 3.0], dtype=np.float64) + ) + + +def test_slicing(): + a = ndx.asarray(np.array([0, 1, 2, 3], np.int64)) + b = ndx.asarray(np.array([1, 2], np.int64)) + c = a[1:3] * 2 + b + np.testing.assert_equal(c.to_numpy(), np.array([3, 6], dtype=np.int64)) + + +def test_creation(): + a = ndx.asarray(np.array([0.0, 1, 2, 3])) + assert a.to_numpy() is not None + np.testing.assert_equal(a.to_numpy(), np.array([0.0, 1, 2, 3], dtype=np.float64)) + + +def test_opset_extensions_eager_propagation(): + a = ndx.asarray( + np.arange(0, 4, dtype=np.int64), + ) + + b = ndx.asarray( + np.arange(10, 14, dtype=np.int64), + ) + result = opx.add(a.data, b.data) # type: ignore + np.testing.assert_equal(result.to_numpy(), [10, 12, 14, 16]) + result = opx.split(opx.concat([a.data, b.data], axis=0), num_outputs=2, axis=0) # type: ignore + assert isinstance(result, tuple) and len(result) == 2 + np.testing.assert_equal(result[0].to_numpy(), a.to_numpy()) + np.testing.assert_equal(result[1].to_numpy(), b.to_numpy()) + + +@pytest.mark.skip( + reason="Opset dispatch constant propagation leads to slow build times." +) +def test_opset_extensions_constant_folding(): + a = ndx.asarray(np.array([1, 2, 3])) + b = ndx.asarray(np.array([4, 5, 6])) + result = opx.add(a, b) + assert result._var._op.op_type.identifier == "Constant" + np.testing.assert_equal(result.to_numpy(), [5, 7, 9]) + + +def test_eager_propagate_decorator(): + import ndonnx._opset_extensions as opx + from ndonnx._array import _from_corearray + from ndonnx._propagation import eager_propagate + + @eager_propagate + def sin_plus(a, b): + return _from_corearray(opx.sin(a.data)) + b + + a = ndx.asarray( + np.array([0, 1, 2, 3], dtype=np.float64), + ) + b = ndx.asarray( + np.array([10, 11, 12, 13], dtype=np.float64), + ) + result = sin_plus(a, b) + np.testing.assert_equal(result.to_numpy(), np.sin(a.to_numpy()) + b.to_numpy()) + + @eager_propagate + def assign_inplace(a, indices, values): + a[indices] = values + return a + + index = ndx.asarray(np.array([0, 3], dtype=np.int64)) + c = ndx.asarray(np.array([100, 200], dtype=np.int64)) + result = assign_inplace(a, index, c) + np.testing.assert_equal(result.to_numpy(), [100, 1, 2, 200]) + np.testing.assert_equal(a.to_numpy(), [100, 1, 2, 200]) + assert a is result diff --git a/tests/ndonnx/test_constant_propagation.py b/tests/ndonnx/test_constant_propagation.py new file mode 100644 index 0000000..5e16161 --- /dev/null +++ b/tests/ndonnx/test_constant_propagation.py @@ -0,0 +1,239 @@ +# Copyright (c) QuantCo 2023-2024 +# SPDX-License-Identifier: LicenseRef-QuantCo + +from typing import Literal + +import numpy as np +import pytest + +import ndonnx as ndx + + +def test_add(): + candidate = ndx.asarray([1]) + 1 + np.testing.assert_array_equal(candidate.to_numpy(), np.array([2]), strict=True) + + +def indexing_model(mode: Literal["lazy", "constant"]): + if mode == "constant": + a = ndx.asarray([0, 1, 2, 3]) + else: + a = ndx.array( + shape=("N",), + dtype=ndx.int64, + ) + b = ndx.array(shape=("M",), dtype=ndx.int64) + return ndx.build( + {"a": a, "b": b} if mode == "lazy" else {"b": b}, {"y": a[1:3] * 2} + ) + + +def arithmetic_model(mode: Literal["lazy", "constant"]): + if mode == "constant": + a = ndx.asarray([0, 1, 2, 3]) + else: + a = ndx.array( + shape=("N",), + dtype=ndx.int64, + ) + b = ndx.array( + shape=("N",), + dtype=ndx.int64, + ) + return ndx.build({"a": a, "b": b} if mode == "lazy" else {"b": b}, {"y": a * 2 + b}) + + +def dynamic_masking_model(mode: Literal["lazy", "constant"]): + if mode == "constant": + a = ndx.asarray([0, 1, 2, 3], dtype=ndx.int64) + else: + a = ndx.array( + shape=("N",), + dtype=ndx.int64, + ) + b = ndx.array( + shape=("M",), + dtype=ndx.int64, + ) + c = ndx.array( + shape=("N",), + dtype=ndx.bool, + ) + inputs = {"b": b, "c": c} + if mode == "lazy": + inputs["a"] = a + return ndx.build(inputs, {"y": a[c] * 2 + b}) + + +def constant_indexing_model(mode: Literal["lazy", "constant"]): + if mode == "constant": + a = ndx.asarray([0, 1, 2, 3], dtype=ndx.int64) + else: + a = ndx.array( + shape=("N",), + dtype=ndx.int64, + ) + b = ndx.asarray([5, 7, 8, 8, 9, 9, 234], dtype=ndx.int64) + idx = ndx.asarray([1, 3, 5, 0]) + result = a * b[idx] + return ndx.build({"a": a} if mode == "lazy" else {}, {"y": result}) + + +@pytest.mark.parametrize( + "model_func, expected_operators_constant", + [ + ( + indexing_model, + {"Identity", "Constant"}, + ), + ( + arithmetic_model, + {"Identity", "Add", "Constant"}, + ), + ( + # We should be blocked from any real constant propagation + # here since we are indexing on an eager value. + dynamic_masking_model, + { + "Identity", + "Constant", + "Mul", + "Add", + "Compress", + }, + ), + ( + constant_indexing_model, + {"Constant", "Identity"}, + ), + ], +) +def test_model_constant_folds(model_func, expected_operators_constant): + operators_used_const = {node.op_type for node in model_func("constant").graph.node} + assert operators_used_const == expected_operators_constant + + +@pytest.mark.parametrize( + "a, b, op, expected_operators", + [ + ( + ndx.array(shape=("N",), dtype=ndx.bool), + ndx.array(shape=("N",), dtype=ndx.bool), + ndx.logical_or, + {"Identity", "Or"}, + ), + ( + ndx.asarray([False], dtype=ndx.bool), + ndx.array(shape=("N",), dtype=ndx.bool), + ndx.logical_or, + {"Identity"}, + ), + ( + ndx.asarray([False, False], dtype=ndx.bool), + ndx.array(shape=("N",), dtype=ndx.bool), + ndx.logical_or, + {"Identity", "Or", "Constant"}, + ), + ( + ndx.array(shape=("N",), dtype=ndx.bool), + ndx.array(shape=("N",), dtype=ndx.bool), + ndx.logical_and, + {"Identity", "And"}, + ), + ( + ndx.asarray([True], dtype=ndx.bool), + ndx.array(shape=("N",), dtype=ndx.bool), + ndx.logical_and, + {"Identity"}, + ), + ( + ndx.asarray([True, True], dtype=ndx.bool), + ndx.array(shape=("N",), dtype=ndx.bool), + ndx.logical_and, + {"Identity", "And", "Constant"}, + ), + ], +) +def test_logical_folding(a, b, op, expected_operators): + out = op(a, b) + inputs = {} + if a.to_numpy() is None: + inputs["a"] = a + if b.to_numpy() is None: + inputs["b"] = b + model_proto = ndx.build(inputs, {"out": out}) + operators_used_const = {node.op_type for node in model_proto.graph.node} + assert operators_used_const == expected_operators + + +@pytest.mark.parametrize( + "cond, x, y, expected_operators", + [ + ( + ndx.asarray([True, True]), + ndx.asarray(["a", "b"]), + ndx.asarray(["c", "d"]), + {"Identity", "Constant"}, + ), + ( + ndx.array(shape=("N",), dtype=ndx.bool), + ndx.asarray(["a", "b"]), + ndx.asarray(["c", "d"]), + {"Identity", "Constant", "Where"}, + ), + ( + ndx.asarray([False, False]), + ndx.asarray(["a", "b"]), + ndx.asarray(["c", "d"]), + {"Identity", "Constant"}, + ), + ( + ndx.asarray([True, False]), + ndx.asarray(["a", "b"]), + ndx.asarray(["a", "b"]), + {"Identity", "Constant"}, + ), + ( + ndx.asarray([True, False]), + ndx.asarray(["a", "a"]), + ndx.asarray(["a"]), + {"Identity", "Constant"}, + ), + ( + ndx.array(shape=("N",), dtype=ndx.bool), + ndx.asarray([np.nan]), + ndx.asarray([np.nan]), + {"Identity", "Constant"}, + ), + ( + ndx.array(shape=("N",), dtype=ndx.bool), + ndx.asarray(["a", "a"]), + ndx.asarray(["a"]), + {"Identity", "Constant"}, + ), + ( + ndx.array(shape=("N",), dtype=ndx.bool), + ndx.asarray(np.ma.masked_array(["a", "a"], mask=[True, False])), + ndx.asarray(["a"]), + {"Identity", "Constant", "And", "Xor", "Not", "Where"}, + ), + ( + ndx.array(shape=("N",), dtype=ndx.bool), + ndx.asarray(np.ma.masked_array(["a", "a"], mask=[True, False])), + ndx.asarray(np.ma.masked_array(["a", "a"], mask=[True, False])), + {"Identity", "Constant", "And", "Xor", "Not", "Where"}, + ), + ], +) +def test_where_folding(cond, x, y, expected_operators): + out = ndx.where(cond, x, y) + inputs = {} + if cond.to_numpy() is None: + inputs["cond"] = cond + if x.to_numpy() is None: + inputs["x"] = x + if y.to_numpy() is None: + inputs["y"] = y + model_proto = ndx.build(inputs, {"out": out}) + operators_used_const = {node.op_type for node in model_proto.graph.node} + assert operators_used_const == expected_operators diff --git a/tests/ndonnx/test_core.py b/tests/ndonnx/test_core.py new file mode 100644 index 0000000..14d4eea --- /dev/null +++ b/tests/ndonnx/test_core.py @@ -0,0 +1,530 @@ +# Copyright (c) QuantCo 2023-2024 +# SPDX-License-Identifier: LicenseRef-QuantCo + +from __future__ import annotations + +import re + +import numpy as np +import numpy.array_api as npx +import pytest +import spox.opset.ai.onnx.v19 as op + +import ndonnx as ndx +import ndonnx.additional as nda +from ndonnx import _data_types as dtypes + +from .utils import run + + +def numpy_to_graph_input(arr, eager=False): + dtype: dtypes.CoreType | dtypes.StructType + if isinstance(arr, np.ma.MaskedArray): + dtype = dtypes.promote_nullable(dtypes.from_numpy_dtype(arr.dtype)) + else: + dtype = dtypes.from_numpy_dtype(arr.dtype) + return ( + ndx.array( + shape=arr.shape, + dtype=dtype, + ) + if not eager + else ndx.asarray( + arr, + dtype=dtype, + ) + ) + + +@pytest.fixture +def _a(): + return np.array([1, 2, 3]) + + +@pytest.fixture +def _b(): + return np.array([2, 3, 3]) + + +@pytest.fixture +def _c(): + return np.array([[1, 2, 3], [4, 5, 6]]) + + +@pytest.mark.parametrize( + "dtype, input", + [ + (ndx.bool, np.array([True, False, True])), + (ndx.int8, np.array([1, 5, -12], np.int8)), + (ndx.nbool, np.ma.masked_array([True, True, False], mask=[1, 0, 0])), + (ndx.nint8, np.ma.masked_array([1, 5, -12], mask=[0, 1, 1], dtype=np.int8)), + ], +) +@pytest.mark.parametrize("shape", [(3,), ("N",)]) +def test_make_graph_input(dtype, input, shape): + a = ndx.array(shape=shape, dtype=dtype) + model = ndx.build({"a": a}, {"b": a}) + actual = run(model, {"a": input}) + np.testing.assert_equal(input, actual["b"]) + + +def test_null_promotion(): + a = ndx.array(shape=("N",), dtype=ndx.nfloat64) + b = ndx.array(shape=("N",), dtype=ndx.float64) + model = ndx.build({"a": a, "b": b}, {"c": a + b}) + inputs = { + "a": np.ma.masked_array([1.0, 2.0, 3.0, 4.0], mask=[0, 0, 1, 0]), + "b": np.array([4.0, 5.0, 6.0, 7.0]), + } + actual = run(model, inputs) + np.testing.assert_equal(np.add(inputs["a"], inputs["b"]), actual["c"]) + + +def test_asarray(): + a = ndx.asarray([1, 2, 3], dtype=ndx.int64) + assert a.dtype == ndx.int64 + np.testing.assert_array_equal( + np.array([1, 2, 3], np.int64), a.to_numpy(), strict=True + ) + + +def test_asarray_masked(): + np_arr = np.ma.masked_array([1, 2, 3], mask=[0, 0, 1]) + ndx_arr = ndx.asarray(np_arr) + assert isinstance(ndx_arr, ndx.Array) + assert isinstance(ndx_arr.to_numpy(), np.ma.MaskedArray) + np.testing.assert_array_equal(np_arr, ndx_arr.to_numpy()) + + +def test_basic_eager_add(_a, _b): + a = ndx.asarray(_a) + b = ndx.asarray(_b) + x = ndx.asarray([1]) + 2 + c = a + b + x + np.testing.assert_array_equal(c.to_numpy(), _a + _b + np.array([1]) + 2) + + +def test_string_concatenation(): + a = ndx.asarray(["a", "b", "c"]) + b = ndx.asarray(["d", "e", "f"]) + np.testing.assert_array_equal((a + b).to_numpy(), np.array(["ad", "be", "cf"])) + np.testing.assert_array_equal((a + "d").to_numpy(), np.array(["ad", "bd", "cd"])) + + +def test_combining_lazy_eager(): + a = ndx.array(shape=(3,), dtype=ndx.int64) + b = ndx.asarray(np.array([1, 2, 3], dtype=np.int64)) + c = a + b + assert not c.to_numpy() is not None + + +def test_basic_indexing(): + a = ndx.asarray([1, 2, 3]) + b = a[0] + a[0] = 2 + assert (a[0] != b).to_numpy().item() + assert (a[0] == 2).to_numpy().item() + + +def test_lazy_array(_a, _b): + a = numpy_to_graph_input(_a) + b = ndx.asarray(_b) + c = a * b + + model = ndx.build({"a": a}, {"c": c}) + actual = run(model, {"a": _a})["c"] + expected = _a * _b + np.testing.assert_equal(actual, expected) + + +def test_indexing(_a): + a = numpy_to_graph_input(_a) + b = a[0] + + model = ndx.build({"a": a}, {"b": b}) + actual = run(model, {"a": _a})["b"] + expected = _a[0] + np.testing.assert_array_equal(expected, actual) + + +@pytest.mark.parametrize( + "condition, x, y", + [ + ( + np.array([True, False, False], dtype=np.bool_), + np.array([1, 2, 3]), + np.array([3.12, 3.24, -124.0]), + ), + ( + np.array([True, False, True], dtype=np.bool_), + np.ma.masked_array([1, 2, 3], mask=[0, 0, 1]), + np.array([3.12, 3.24, -124.0]), + ), + ], +) +def test_where(condition, x, y): + expected = np.where(condition, x, y) + condition_onnx = numpy_to_graph_input(condition) + x_onnx = numpy_to_graph_input(x) + y_onnx = numpy_to_graph_input(y) + out = ndx.where(condition_onnx, x_onnx, y_onnx) + model = ndx.build( + {"condition": condition_onnx, "x": x_onnx, "y": y_onnx}, {"out": out} + ) + actual = run(model, {"condition": condition, "x": x, "y": y})["out"] + np.testing.assert_array_equal(expected, actual) + + +def test_indexing_on_scalar(): + res = ndx.asarray(1) + res = res[()] + res[()] = 2 + assert res == 2 + + +def test_indexing_on_scalar_mask(): + res = ndx.asarray([]) + res = res[False] + np.testing.assert_equal(nda.shape(res).to_numpy(), (0, 0)) + + +def test_indexing_with_mask(_a): + _mask = np.array([True, False, True]) + + a = numpy_to_graph_input(_a) + mask = numpy_to_graph_input(_mask) + c = ndx.reshape(a[mask], [-1]) + + expected_c = _a[_mask] + + model = ndx.build({"a": a, "mask_": mask}, {"c": c}) + actual = run(model, {"a": _a, "mask_": _mask})["c"] + np.testing.assert_array_equal(expected_c, actual) + + +def test_indexing_with_mask_raises(_a): + a = numpy_to_graph_input(_a) + mask = ndx.array(shape=(3, 1, 1), dtype=ndx.bool) + + with pytest.raises(IndexError): + a[mask] + + +def test_indexing_with_array(_a): + _index = np.array([0, 2]) + + a = numpy_to_graph_input(_a) + index = numpy_to_graph_input(_index) + c = ndx.reshape(a[index], [-1]) + + expected_c = _a[_index] + + model = ndx.build({"a": a, "index_": index}, {"c": c}) + actual = run(model, {"a": _a, "index_": _index})["c"] + np.testing.assert_array_equal(expected_c, actual) + + +def test_indexing_with_tuple_of_array(_a): + a = numpy_to_graph_input(_a) + index = numpy_to_graph_input(np.array([0, 2])) + + with pytest.raises( + TypeError, + match=re.escape(f"Index {index} for type {type(index)} not supported"), + ): + a[(index,)] + + +def test_slicing(_a): + a = numpy_to_graph_input(_a) + b = a[1:2] + + model = ndx.build({"a": a}, {"b": b}) + actual = run(model, {"a": _a})["b"] + np.testing.assert_equal(actual, _a[1:2]) + + +def test_indexing_list(_a): + a = numpy_to_graph_input(_a) + + with pytest.raises(TypeError, match="not supported"): + a[[0, 2]] + + +def test_indexing_slice_ellipsis(_c): + a = numpy_to_graph_input(_c) + b = a[..., 1] + + model = ndx.build({"a": a}, {"b": b}) + actual = run(model, {"a": _c})["b"] + expected = _c[..., 1] + np.testing.assert_array_equal(actual, expected) + + +def test_indexing_none(_c): + _index = (None, 1, None, 1) + + a = numpy_to_graph_input(_c) + b = a[_index] + + model = ndx.build({"a": a}, {"b": b}) + actual = run(model, {"a": _c})["b"] + expected = _c[_index] + np.testing.assert_array_equal(actual, expected) + + +def test_illegal_indexing(_a): + a = numpy_to_graph_input(_a) + + with pytest.raises(TypeError): + a["invalid", ...] + + +def test_indexing_with_invalid_rank(_a): + a = numpy_to_graph_input(_a) + + with pytest.raises(IndexError): + a[()] + + b = numpy_to_graph_input(np.array([[1, 2], [3, 4]])) + with pytest.raises(IndexError): + b[0, 0, 0] + with pytest.raises(IndexError): + b[0,] + + b[0, ...] + + +def test_indexing_set_with_array(_a): + _index = np.array([0, 2]) + + a = numpy_to_graph_input(_a) + index = numpy_to_graph_input(_index) + + c = a.copy() + c[index] = 0 + + expected_c = _a + expected_c[_index] = 0 + + model = ndx.build({"a": a, "index_": index}, {"c": c}) + actual = run(model, {"a": _a, "index_": _index})["c"] + np.testing.assert_equal(actual, expected_c) + + +def test_indexing_set_scalar(): + _a = np.array(2) + + a = numpy_to_graph_input(_a) + + c = a.copy() + c = ndx.asarray(0) + + expected_c = 0 + + model = ndx.build({"a": a}, {"c": c}) + np.testing.assert_array_equal(expected_c, run(model, {"a": _a})["c"], strict=True) + + +# Check if repr does not raise +def test_repr(): + a = ndx.array(shape=(3,), dtype=ndx.int64) + repr(a) + + b = ndx.asarray([1, 2, 3]) + repr(b) + + c = ndx.array(shape=(3,), dtype=ndx.nint8) + repr(c) + + d = ndx.asarray(np.array([1, 2, 3], np.int64)) + repr(d) + + +@pytest.mark.parametrize( + "rop", ["__radd__", "__rsub__", "__rmul__", "__rtruediv__", "__rpow__", "__rmod__"] +) +def test_rops(rop): + a = ndx.asarray([1.0, 2.0, 3.0]) + b = ndx.asarray([1.0, 2.0, 3.0]) + + res = getattr(a, rop)(b) + np.testing.assert_equal(res.to_numpy(), getattr(a.to_numpy(), rop)(b.to_numpy())) + + +def test_rsub(): + a = ndx.asarray([1, 2, 3]) + + res = 1 - a + a_value = a.to_numpy() + assert a_value is not None + np.testing.assert_equal(res.to_numpy(), 1 - a_value) + + +def test_matrix_transpose(): + a = ndx.array(shape=(3, 2, 3), dtype=ndx.int64) + b = ndx.matrix_transpose(a) + + model = ndx.build({"a": a}, {"b": b}) + np.testing.assert_equal( + npx.matrix_transpose(npx.reshape(npx.arange(3 * 2 * 3), (3, 2, 3))), + run(model, {"a": np.arange(3 * 2 * 3, dtype=np.int64).reshape(3, 2, 3)})["b"], + ) + + +def test_matrix_transpose_attribute(): + a = ndx.array(shape=(3, 2, 3), dtype=ndx.int64) + b = a.mT + + model = ndx.build({"a": a}, {"b": b}) + np.testing.assert_equal( + npx.reshape(npx.arange(3 * 2 * 3), (3, 2, 3)).mT, + run(model, {"a": np.arange(3 * 2 * 3, dtype=np.int64).reshape(3, 2, 3)})["b"], + ) + + +def test_transpose_attribute(): + a = ndx.array(shape=(3, 2), dtype=ndx.int64) + b = a.T + + model = ndx.build({"a": a}, {"b": b}) + np.testing.assert_equal( + npx.reshape(npx.arange(3 * 2), (3, 2)).T, + run(model, {"a": np.arange(3 * 2, dtype=np.int64).reshape(3, 2)})["b"], + ) + + +def test_array_spox_interoperability(): + a = ndx.array(shape=(3, 2), dtype=ndx.nint64) + add_var = op.add(a.values.data.var, op.const(5, dtype=np.int64)) # type: ignore + b = ndx.from_spox_var(var=add_var) + model = ndx.build({"a": a}, {"b": b}) + expected = npx.reshape(npx.arange(3 * 2), (3, 2)) + 5 + input = np.ma.masked_array( + np.arange(3 * 2, dtype=np.int64).reshape(3, 2), mask=np.ones((3, 2), dtype=bool) + ) + actual = run(model, {"a": input})["b"] + np.testing.assert_equal(expected, actual) + + +def test_creation_arange(): + a = ndx.arange(10) + np.testing.assert_equal(np.arange(10), a.to_numpy()) + + b = ndx.arange(1, 10) + np.testing.assert_equal(np.arange(1, 10), b.to_numpy()) + + c = ndx.arange(1, 10, 2) + np.testing.assert_equal(np.arange(1, 10, 2), c.to_numpy()) + + d = ndx.arange(0.0, None, step=-1) + np.testing.assert_array_equal( + np.arange(0.0, None, step=-1), d.to_numpy(), strict=True + ) + + +def test_creation_full(): + a = ndx.full((2, 3), 5) + np.testing.assert_equal(np.full((2, 3), 5), a.to_numpy()) + + b = ndx.full((2, 3), 5, dtype=ndx.float32) + np.testing.assert_equal(np.full((2, 3), 5, dtype=np.float32), b.to_numpy()) + c = ndx.full((2, 3), "a", dtype=ndx.nutf8) + np.testing.assert_equal(np.full((2, 3), "a"), c.to_numpy()) + + +@pytest.mark.parametrize( + "args, expected", + [ + ((ndx.int32, ndx.int64), ndx.int64), + ( + (ndx.asarray([1, 2, 3], ndx.int64), ndx.asarray([1, 2, 3], ndx.int32)), + ndx.int64, + ), + ((ndx.int32, ndx.asarray([1, 2, 3], ndx.int64)), ndx.int64), + ((ndx.float32, ndx.float64), ndx.float64), + ((ndx.float64, ndx.int32), ndx.float64), + ], +) +def test_result_type(args, expected): + assert ndx.result_type(*args) == expected + + +def test_ceil(): + a = ndx.asarray(np.array([1.2, 1.3, -13.13])) + np.testing.assert_equal(ndx.ceil(a).to_numpy(), [2.0, 2.0, -13.0]) + + +def test_propagates_minimal_dtype(): + a = ndx.asarray([1, 2, 4], dtype=ndx.int8) + b = a + 1 + assert b.dtype == ndx.int8 + np.testing.assert_equal(b.to_numpy(), [2, 3, 5]) + + +@pytest.mark.parametrize( + "x", + [ + ndx.asarray([True, False, False]), + ndx.asarray([False]), + ndx.asarray([True]), + ndx.asarray([True, True]), + ndx.asarray([], dtype=ndx.bool), + ], +) +def test_all(x): + np.testing.assert_equal(ndx.all(x).to_numpy(), np.all(x.to_numpy())) + + +@pytest.mark.parametrize( + "side", + [ + "left", + "right", + ], +) +def test_searchsorted(side): + a_val = [0, 1, 2, 5, 5, 6, 10, 15] + b_val = [0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 10, 15, 20, 20] + c_val = np.searchsorted(a_val, b_val, side) + + a = ndx.asarray(a_val, dtype=ndx.int64) + b = ndx.asarray(b_val, dtype=ndx.int64) + c = ndx.searchsorted(a, b, side=side) + np.testing.assert_equal(c_val, c.to_numpy()) + + +@pytest.mark.skip(reason="TODO: onnxruntime") +@pytest.mark.parametrize( + "side", + [ + "left", + "right", + ], +) +def test_searchsorted_nans(side): + a_val = np.array([0, 1, 2, 5, 5, 6, 10, 15, np.nan]) + b_val = np.array([0, 1, 2, np.nan, np.nan]) + c_val = np.searchsorted(a_val, b_val, side) + + a = ndx.array(shape=(len(a_val),), dtype=ndx.float64) + b = ndx.array(shape=(len(b_val),), dtype=ndx.float64) + c = ndx.searchsorted(a, b, side=side) + + model = ndx.build({"a": a, "b": b}, {"c": c}) + + np.testing.assert_equal(c_val, run(model, dict(a=a_val, b=b_val))["c"]) + + +def test_searchsorted_raises(): + with pytest.raises(TypeError): + a = ndx.array(shape=(), dtype=ndx.int64) + b = ndx.array(shape=(), dtype=ndx.float64) + + ndx.searchsorted(a, b) + + with pytest.raises(ValueError): + a = ndx.array(shape=(3,), dtype=ndx.int64) + b = ndx.array(shape=(3,), dtype=ndx.int64) + + ndx.searchsorted(a, b, side="middle") # type: ignore[arg-type] diff --git a/tests/ndonnx/test_dtypes.py b/tests/ndonnx/test_dtypes.py new file mode 100644 index 0000000..8b11699 --- /dev/null +++ b/tests/ndonnx/test_dtypes.py @@ -0,0 +1,168 @@ +# Copyright (c) QuantCo 2023-2024 +# SPDX-License-Identifier: LicenseRef-QuantCo +from __future__ import annotations + +import re + +import numpy as np +import pytest +from typing_extensions import Self + +import ndonnx as ndx +from ndonnx import ( + Array, + CastError, + CoreType, +) +from ndonnx._experimental import CastMixin, OperationsBlock, Schema, StructType + + +class Unsigned96Impl(OperationsBlock): + def equal(self, x, y): + return custom_equal(x, y) + + +class Unsigned96(StructType, CastMixin): + def _fields(self) -> dict[str, StructType | CoreType]: + return { + "upper": ndx.uint32, + "lower": ndx.uint64, + } + + def _parse_input(self, input: np.ndarray) -> dict: + upper = self._fields()["upper"]._parse_input( + np.array(input >> 64).astype(np.uint32) + ) + lower = self._fields()["lower"]._parse_input( + (input & np.array([0xFFFFFFFFFFFFFFFF])).astype(np.uint64) + ) + return { + "upper": upper, + "lower": lower, + } + + def _assemble_output(self, fields: dict[str, np.ndarray]) -> np.ndarray: + return (fields["upper"].astype(object) << 64) | fields["lower"].astype(object) + + def copy(self) -> Self: + return self + + def _schema(self) -> Schema: + return Schema(type_name="u96", author="value from data!") + + def _cast_to(self, array: Array, dtype: CoreType | StructType) -> Array: + raise CastError(f"Cannot cast {self} to {dtype}") + + def _cast_from(self, array: Array) -> Array: + if isinstance(array.dtype, ndx.Integral): + array = array.astype(ndx.uint64) + else: + raise CastError(f"Cannot cast {array.dtype} to {self}") + + return Array._from_fields( + Unsigned96(), upper=ndx.asarray(0, dtype=ndx.uint32), lower=array + ) + + _ops: OperationsBlock = Unsigned96Impl() + + +def custom_equal(x: Array, y: Array) -> Array: + if x.dtype != Unsigned96() or y.dtype != Unsigned96(): + raise ValueError("Can only compare Unsigned96 arrays") + # ort doesn't implement equality on unsigned 64s, so I roll my own! + return ((x.lower ^ y.lower) | (x.upper ^ y.upper)) == 0 + + +@pytest.fixture +def u96(): + return Unsigned96() + + +def test_custom_dtype_array_creation(u96): + ndx.asarray(np.array(0, dtype=object), dtype=u96) + + +def test_unsigned96_casting(u96): + with pytest.raises(CastError): + Array._from_fields( + u96, + upper=ndx.asarray(0, dtype=ndx.uint32), + lower=ndx.asarray(0, dtype=ndx.uint64), + ).astype(ndx.uint64) + + expected = ndx.asarray(0, dtype=u96) + actual = ndx.asarray(0, dtype=ndx.uint64).astype(u96) + custom_equal_result = custom_equal(expected, actual).to_numpy() + assert custom_equal_result is not None and custom_equal_result.item() + + expected = ndx.asarray(np.array([1 << 40], dtype=object), dtype=u96) + actual = ndx.asarray(np.array([1 << 40]), dtype=ndx.uint32).astype(u96) + + # Should overflow + custom_equal_result = custom_equal(expected, actual).to_numpy() + assert custom_equal_result is not None and not custom_equal_result.item() + actual_value = actual.to_numpy() + assert actual_value is not None and actual_value.item() == 0 + expected_value = expected.to_numpy() + assert expected_value is not None and expected_value.item() == 1 << 40 + + +def test_custom_dtype_function_dispatch(u96): + x = ndx.asarray(np.array([22314, 21 << 12, 12], dtype=object), dtype=u96) + y = ndx.asarray(np.array([22314, 21 << 12, 12], dtype=object), dtype=u96) + z = ndx.asarray(np.array([223, 21 << 12, 13], dtype=object), dtype=u96) + + np.testing.assert_equal(ndx.equal(x, y).to_numpy(), [True, True, True]) + np.testing.assert_equal(ndx.equal(x, z).to_numpy(), [False, True, False]) + + +def test_custom_dtype_layout_transformations(u96): + x = ndx.asarray(np.array([22314, 21 << 12, 12, 1242134], dtype=object), dtype=u96) + x_value = x.to_numpy() + if x_value is None: + raise ValueError("x.to_numpy() is None") + expected = x_value.reshape(2, 2) + actual = ndx.reshape(x, (2, 2)).to_numpy() + np.testing.assert_equal(expected, actual) + + expected = ndx.roll(x, 1).to_numpy() + if x.to_numpy() is None: + raise ValueError("x.to_numpy() is None") + actual = np.roll(x.to_numpy(), 1) + np.testing.assert_equal(expected, actual) + + +def test_error_message_unimplemented_dtype_dispatch(u96): + x = ndx.asarray(np.array([22314, 21 << 12, 12], dtype=object), dtype=u96) + y = ndx.asarray(np.array([223, 21 << 12, 13], dtype=object), dtype=u96) + + with pytest.raises( + TypeError, + match=re.escape("Unsupported operand type(s) for less_equal: 'Unsigned96'"), + ): + ndx.less_equal(x, y) + with pytest.raises( + TypeError, + match=re.escape("Unsupported operand type for bitwise_invert: 'Unsigned96'"), + ): + ~x + + +def test_isinstance_i32(): + assert isinstance(ndx.int32, ndx.CoreType) + assert isinstance(ndx.int32, ndx.Numerical) + assert isinstance(ndx.int32, ndx.Integral) + assert not isinstance(ndx.int32, ndx.Floating) + + +def test_isinstance_f32(): + assert isinstance(ndx.float32, ndx.CoreType) + assert isinstance(ndx.float32, ndx.Numerical) + assert isinstance(ndx.float32, ndx.Floating) + assert not isinstance(ndx.float32, ndx.NullableIntegral) + + +def test_equality(): + assert ndx.int32 == ndx.int32 + assert ndx.int32 != ndx.int64 + assert ndx.int32 != ndx.nint32 diff --git a/tests/ndonnx/test_include.py b/tests/ndonnx/test_include.py new file mode 100644 index 0000000..96dbcdc --- /dev/null +++ b/tests/ndonnx/test_include.py @@ -0,0 +1,13 @@ +# Copyright (c) QuantCo 2023-2024 +# SPDX-License-Identifier: LicenseRef-QuantCo + + +def test_import(): + import ndonnx # noqa + + +def test_onnxruntime(): + import onnxruntime + + # Test that the onnxruntime has InfereceSession + assert hasattr(onnxruntime, "InferenceSession") diff --git a/tests/ndonnx/test_masked.py b/tests/ndonnx/test_masked.py new file mode 100644 index 0000000..6510e62 --- /dev/null +++ b/tests/ndonnx/test_masked.py @@ -0,0 +1,203 @@ +# Copyright (c) QuantCo 2023-2024 +# SPDX-License-Identifier: LicenseRef-QuantCo + +import math + +import numpy as np +import numpy.array_api as npx +import pytest + +import ndonnx as ndx +import ndonnx.additional as nda + +from .utils import run + + +def testfill_null(): + a = ndx.array(shape=(3,), dtype=ndx.nint64) + b = nda.fill_null(a, ndx.asarray(0)) + + model = ndx.build({"a": a}, {"b": b}) + + expected_b = np.ma.masked_array([1, 2, 0], mask=[0, 0, 0], dtype=np.int64) + np.testing.assert_equal( + expected_b, + run( + model, {"a": np.ma.masked_array([1, 2, -1], mask=[0, 0, 1], dtype=np.int64)} + )["b"], + ) + + +@pytest.mark.parametrize( + "fn_name", + ["add", "subtract", "multiply", "divide", "floor_divide", "remainder"], +) +def test_arithmetic_none_propagation(fn_name): + fn = getattr(ndx, fn_name) + np_fn = getattr(np.ma, fn_name) + + a = ndx.array(shape=(3,), dtype=ndx.nfloat64) + b = ndx.array(shape=(3,), dtype=ndx.nfloat64) + c = fn(a, b) + + a_val = np.ma.masked_array([-1, 2.0, 3.0], mask=[1, 0, 0]) + b_val = np.ma.masked_array([2.0, 1.0, -1], mask=[0, 0, 1]) + + model = ndx.build({"a": a, "b": b}, {"c": c}) + + ret_c = run(model, {"a": a_val, "b": b_val})["c"] + expected_c = np_fn(a_val, b_val) + + assert np.ma.allclose(expected_c, ret_c, masked_equal=True) + + +@pytest.mark.parametrize( + "fn_name, default_value", + [ + ("sum", 0), + # ("prod", 1), + ("min", math.inf), + ("max", -math.inf), + ], +) +def test_reduce_ops_none_filling(fn_name, default_value): + fn = getattr(ndx, fn_name) + np_fn = getattr(np, fn_name) + + a = ndx.array(shape=(3,), dtype=ndx.nfloat32) + b = fn(a) + + model = ndx.build({"a": a}, {"b": b}) + + inp_a = np.ma.masked_array([0.0, -2.0, 3.0], dtype=np.float32, mask=[1, 0, 0]) + + ret_b = run(model, {"a": inp_a})["b"] + expected_b = np_fn(np.ma.filled(inp_a, default_value)) + + np.testing.assert_almost_equal(expected_b, ret_b) + + +@pytest.mark.parametrize( + "fn_name, args, kwargs", + [ + ("abs", (), {}), + ("exp", (), {}), + ("log", (), {}), + ("sqrt", (), {}), + ("sin", (), {}), + ("cos", (), {}), + ("tan", (), {}), + ("asin", (), {}), + ("acos", (), {}), + ("atan", (), {}), + # ("sinh", (), {}), + ("negative", (), {}), + ("positive", (), {}), + ("floor", (), {}), + ("sign", (), {}), + ("expand_dims", (), {"axis": 0}), + ("reshape", ((3, 1),), {}), + ("flip", (), {}), + ("permute_dims", ((1, 0),), {}), + ("roll", (1,), {}), + ("squeeze", (0,), {}), + ], +) +def test_unary_none_propagation(fn_name, args, kwargs): + fn = getattr(ndx, fn_name) + np_fn = getattr(npx, fn_name) + + a = ndx.array(shape=(1, 3), dtype=ndx.nfloat32) + b = fn(a, *args) + + model = ndx.build({"a": a}, {"b": b}) + + inp_a = np.ma.masked_array([[0, -2.0, 3.0]], mask=[[1, 0, 0]], dtype=np.float32) + ret_b = run(model, {"a": inp_a})["b"] + missing_a = inp_a.mask + expected_b = np_fn(npx.asarray(np.ma.filled(inp_a, np.nan)), *args, **kwargs) + np.testing.assert_almost_equal( + np.ma.masked_array(expected_b, mask=missing_a), + ret_b, + decimal=5, + ) + + +def test_forbidden_masked(): + a = ndx.array(shape=(3,), dtype=ndx.nint64) + + with pytest.raises(TypeError): + ndx.arange(a, 0, 1) + + +def test_masked_getitem(): + a = ndx.array(shape=(3,), dtype=ndx.nint64) + + model = ndx.build({"a": a}, {"b": a[0]}) + + np.testing.assert_equal( + [1], + run( + model, {"a": np.ma.masked_array([1, 2, 3], mask=[0, 0, 1], dtype=np.int64)} + )["b"], + ) + + +def test_masked_setitem(): + a_start = ndx.array(shape=(3,), dtype=ndx.nint64) + + a = a_start.copy() + a[0] = 1 + + model = ndx.build({"a": a_start}, {"b": a}) + + np.testing.assert_equal( + [1, 2, 3], + run( + model, dict(a=np.ma.masked_array([1, 2, 3], mask=[0, 0, 0], dtype=np.int64)) + )["b"], + ) + + +def test_asarray_masked(): + a = ndx.asarray(np.ma.masked_array([1, 2, 3], mask=[0, 0, 1])) + 1 + + assert np.ma.allclose( + np.ma.masked_array([1, 2, 3], mask=[0, 0, 1]) + 1, + a.to_numpy(), + masked_equal=True, + ) + + +def test_opset_extensions(): + import ndonnx._opset_extensions as opx + from ndonnx._corearray import _CoreArray + + a = ndx.asarray( + np.array([1, 2, 3]), + dtype=ndx.int64, + ) + shape = opx.shape(a.data) # type: ignore + # opset_extensions is an internal package that only deals with the internal state (lazy Spox Var and any eager values) + assert isinstance(shape, _CoreArray) + np.testing.assert_equal(shape.to_numpy(), np.array([3], dtype=np.int64)) + + +def test_eager_mode(): + a = ndx.asarray(np.ma.masked_array([1, 2, 3], mask=[0, 0, 1], dtype=np.int64)) + b = ndx.asarray(np.ma.masked_array([1, 2, 3], mask=[0, 0, 1], dtype=np.int64)) + c = ndx.asarray( + np.ma.masked_array([-12, 21, 12213], mask=[1, 0, 0], dtype=np.int64) + ) + np.testing.assert_equal( + (a + b).to_numpy(), + np.ma.masked_array([2, 4, 6], mask=[0, 0, 1], dtype=np.int64), + ) + np.testing.assert_equal( + (a - b).to_numpy(), + np.ma.masked_array([0, 0, 0], mask=[0, 0, 1], dtype=np.int64), + ) + np.testing.assert_equal( + (a * c).to_numpy(), + np.ma.masked_array([-12, 42, 36639], mask=[1, 0, 1], dtype=np.int64), + ) diff --git a/tests/ndonnx/utils.py b/tests/ndonnx/utils.py new file mode 100644 index 0000000..793929c --- /dev/null +++ b/tests/ndonnx/utils.py @@ -0,0 +1,63 @@ +# Copyright (c) QuantCo 2024-2024 +# SPDX-License-Identifier: LicenseRef-QuantCo + +from __future__ import annotations + +import json + +import numpy as np +import onnx +import onnxruntime as ort + +import ndonnx._data_types as dtypes +from ndonnx._build import ( + _assemble_outputs, + _deconstruct_inputs, + _extract_output_names, + _get_dtype, +) + +Dtype = dtypes.StructType | dtypes.CoreType + + +def run( + model_proto: onnx.ModelProto, inputs: dict[str, np.ndarray] +) -> dict[str, np.ndarray]: + # Extract input and output schemas + input_dtypes, output_dtypes = _get_dtypes(model_proto) + session = _make_session(model_proto) + flattened_inputs = _deconstruct_inputs(inputs, input_dtypes) + output_names = tuple(_extract_output_names(output_dtypes)) + outputs = dict(zip(output_names, session.run(output_names, flattened_inputs))) + return _assemble_outputs(outputs, output_dtypes) + + +def _make_session(model_proto: onnx.ModelProto) -> ort.InferenceSession: + session_options = ort.SessionOptions() + return ort.InferenceSession( + model_proto.SerializeToString(), sess_options=session_options + ) + + +def _get_dtypes( + model_proto: onnx.ModelProto, +) -> tuple[dict[str, Dtype], dict[str, Dtype]]: + encoding = json.loads( + [prop for prop in model_proto.metadata_props if prop.key == "ndonnx_schema"][ + 0 + ].value + ) + version = encoding["version"] + input_schema = {} + for name, schema in encoding["input_schema"].items(): + if schema["author"] != "ndonnx": + raise ValueError(f"Unknown author {schema}") + input_schema[name] = _get_dtype(schema["type_name"], version) + + output_schema = {} + for name, schema in encoding["output_schema"].items(): + if schema["author"] != "ndonnx": + raise ValueError(f"Unknown author {schema}") + output_schema[name] = _get_dtype(schema["type_name"], version) + + return input_schema, output_schema